![[BACK]](/icons/back.gif){kind=icon}
Return to normal.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim|
Return to normal.c CVS log | Up to [local] / src / usr.bin / vim |
1.1 downsj 1: /* $OpenBSD$ */
2: /* vi:set ts=4 sw=4:
3: *
4: * VIM - Vi IMproved by Bram Moolenaar
5: *
6: * Do ":help uganda" in Vim to read copying and usage conditions.
7: * Do ":help credits" in Vim to see a list of people who contributed.
8: */
9:
10: /*
11: * Contains the main routine for processing characters in command mode.
12: * Communicates closely with the code in ops.c to handle the operators.
13: */
14:
15: #include "vim.h"
16: #include "globals.h"
17: #include "proto.h"
18: #include "option.h"
19:
20: #undef EXTERN
21: #undef INIT
22: #define EXTERN
23: #define INIT(x) x
24: #include "ops.h"
25:
26: /*
27: * Generally speaking, every command in normal() should either clear any
28: * pending operator (with clearop()), or set the motion type variable.
29: */
30:
31: /*
32: * If a count is given before the operator, it is saved in opnum.
33: */
34: static linenr_t opnum = 0;
35: static linenr_t Prenum; /* The (optional) number before a command. */
36: static int prechar = NUL; /* prepended command char */
37: /*
38: * The visual area is remembered for reselection.
39: */
40: static int resel_VIsual_mode = NUL; /* 'v', 'V', or Ctrl-V */
41: static linenr_t resel_VIsual_line_count; /* number of lines */
42: static colnr_t resel_VIsual_col; /* number of cols or end column */
43:
44: #ifdef USE_MOUSE
45: static void find_start_of_word __ARGS((FPOS *));
46: static void find_end_of_word __ARGS((FPOS *));
47: static int get_mouse_class __ARGS((int));
48: #endif
49: static void prep_redo __ARGS((long, int, int, int, int));
50: static int checkclearop __ARGS((void));
51: static int checkclearopq __ARGS((void));
52: static void clearop __ARGS((void));
53: static void clearopbeep __ARGS((void));
54: static void del_from_showcmd __ARGS((int));
55: static void do_gd __ARGS((int nchar));
56:
57: /*
58: * normal
59: *
60: * Execute a command in normal mode.
61: *
62: * This is basically a big switch with the cases arranged in rough categories
63: * in the following order:
64: *
65: * 0. Macros (q, @)
66: * 1. Screen positioning commands (^U, ^D, ^F, ^B, ^E, ^Y, z)
67: * 2. Control commands (:, <help>, ^L, ^G, ^^, ZZ, *, ^], ^T)
68: * 3. Cursor motions (G, H, M, L, l, K_RIGHT, , h, K_LEFT, ^H, k, K_UP,
69: * ^P, +, CR, LF, j, K_DOWN, ^N, _, |, B, b, W, w, E, e, $, ^, 0)
70: * 4. Searches (?, /, n, N, T, t, F, f, ,, ;, ], [, %, (, ), {, })
71: * 5. Edits (., u, K_UNDO, ^R, U, r, J, p, P, ^A, ^S)
72: * 6. Inserts (A, a, I, i, o, O, R)
73: * 7. Operators (~, d, c, y, >, <, !, =, Q)
74: * 8. Abbreviations (x, X, D, C, s, S, Y, &)
75: * 9. Marks (m, ', `, ^O, ^I)
76: * 10. Buffer setting (")
77: * 11. Visual (v, V, ^V)
78: * 12. Suspend (^Z)
79: * 13. Window commands (^W)
80: * 14. extended commands (starting with 'g')
81: * 15. mouse click
82: * 16. scrollbar movement
83: * 17. The end (ESC)
84: */
85:
86: void
87: normal()
88: {
89: register int c;
90: long n = 0; /* init for GCC */
91: int flag = FALSE;
92: int flag2 = FALSE;
93: int type = 0; /* type of operation */
94: int dir = FORWARD; /* search direction */
95: int nchar = NUL; /* next command char */
96: int finish_op;
97: linenr_t Prenum1;
98: char_u *searchbuff = NULL; /* buffer for search string */
99: FPOS *pos = NULL; /* init for gcc */
100: char_u *ptr = NULL;
101: int command_busy = FALSE;
102: int ctrl_w = FALSE; /* got CTRL-W command */
103: int old_col = 0;
104: int dont_adjust_op_end = FALSE;
105:
106: Prenum = 0;
107: /*
108: * If there is an operator pending, then the command we take this time
109: * will terminate it. Finish_op tells us to finish the operation before
110: * returning this time (unless the operation was cancelled).
111: */
112: finish_op = (op_type != NOP);
113:
114: if (!finish_op && !yankbuffer)
115: opnum = 0;
116:
117: State = NORMAL_BUSY;
118: c = vgetc();
119: #ifdef HAVE_LANGMAP
120: LANGMAP_ADJUST(c, TRUE);
121: #endif
122: if (c == NUL)
123: c = K_ZERO;
124: (void)add_to_showcmd(c, FALSE);
125:
126: getcount:
127: /* Pick up any leading digits and compute 'Prenum' */
128: while ((c >= '1' && c <= '9') || (Prenum != 0 && (c == K_DEL || c == '0')))
129: {
130: if (c == K_DEL)
131: {
132: Prenum /= 10;
133: del_from_showcmd(4); /* delete the digit and ~@% */
134: }
135: else
136: Prenum = Prenum * 10 + (c - '0');
137: if (Prenum < 0) /* got too large! */
138: Prenum = 999999999;
139: c = vgetc();
140: #ifdef HAVE_LANGMAP
141: LANGMAP_ADJUST(c, TRUE);
142: #endif
143: (void)add_to_showcmd(c, FALSE);
144: }
145:
146: /*
147: * If we got CTRL-W there may be a/another count
148: */
149: if (c == Ctrl('W') && !ctrl_w && op_type == NOP)
150: {
151: ctrl_w = TRUE;
152: opnum = Prenum; /* remember first count */
153: Prenum = 0;
154: ++no_mapping;
155: ++allow_keys; /* no mapping for nchar, but keys */
156: c = vgetc(); /* get next character */
157: #ifdef HAVE_LANGMAP
158: LANGMAP_ADJUST(c, TRUE);
159: #endif
160: --no_mapping;
161: --allow_keys;
162: (void)add_to_showcmd(c, FALSE);
163: goto getcount; /* jump back */
164: }
165:
166: /*
167: * If we're in the middle of an operator (including after entering a yank
168: * buffer with ") AND we had a count before the
169: * operator, then that count overrides the current value of Prenum. What
170: * this means effectively, is that commands like "3dw" get turned into
171: * "d3w" which makes things fall into place pretty neatly.
172: * If you give a count before AND after the operator, they are multiplied.
173: */
174: if (opnum != 0)
175: {
176: if (Prenum)
177: Prenum *= opnum;
178: else
179: Prenum = opnum;
180: opnum = 0;
181: }
182:
183: Prenum1 = (Prenum == 0 ? 1 : Prenum); /* Prenum often defaults to 1 */
184:
185: /*
186: * Get an additional character if we need one.
187: * For CTRL-W we already got it when looking for a count.
188: */
189: if (ctrl_w)
190: {
191: nchar = c;
192: c = Ctrl('W');
193: }
194: else if ((op_type == NOP && vim_strchr((char_u *)"@zm\"", c) != NULL) ||
195: (op_type == NOP && !VIsual_active &&
196: vim_strchr((char_u *)"rZ", c) != NULL) ||
197: vim_strchr((char_u *)"tTfF[]g'`", c) != NULL ||
198: (c == 'q' && !Recording && !Exec_reg))
199: {
200: ++no_mapping;
201: ++allow_keys; /* no mapping for nchar, but allow key codes */
202: nchar = vgetc();
203: #ifdef HAVE_LANGMAP
204: /* adjust chars > 127: tTfFr should leave lang of nchar unchanged! */
205: LANGMAP_ADJUST(nchar, vim_strchr((char_u *)"tTfFr", c) == NULL);
206: #endif
207: #ifdef RIGHTLEFT
208: if (p_hkmap && strchr("tTfFr", c) && KeyTyped) /* Hebrew mapped char */
209: nchar = hkmap(nchar);
210: #endif
211: --no_mapping;
212: --allow_keys;
213: (void)add_to_showcmd(nchar, FALSE);
214: }
215: if (p_sc)
216: flushbuf(); /* flush the showcmd characters onto the
217: * screen so we can see them while the command
218: * is being executed
219: */
220:
221: State = NORMAL;
222: if (nchar == ESC)
223: {
224: clearop();
225: goto normal_end;
226: }
227: msg_didout = FALSE; /* don't scroll screen up for normal command */
228: msg_col = 0;
229:
230: #ifdef RIGHTLEFT
231: if (curwin->w_p_rl && KeyTyped) /* invert horizontal operations */
232: switch (c)
233: {
234: case 'l': c = 'h'; break;
235: case K_RIGHT: c = K_LEFT; break;
236: case 'h': c = 'l'; break;
237: case K_LEFT: c = K_RIGHT; break;
238: case '>': c = '<'; break;
239: case '<': c = '>'; break;
240: }
241: #endif
242: switch (c)
243: {
244:
245: /*
246: * 0: Macros
247: */
248: case 'q': /* (stop) recording into a named register */
249: if (checkclearop())
250: break;
251: /* command is ignored while executing a register */
252: if (!Exec_reg && do_record(nchar) == FAIL)
253: clearopbeep();
254: break;
255:
256: case '@': /* execute a named buffer */
257: if (checkclearop())
258: break;
259: while (Prenum1--)
260: {
261: if (do_execbuf(nchar, FALSE, FALSE) == FAIL)
262: {
263: clearopbeep();
264: break;
265: }
266: }
267: break;
268:
269: /*
270: * 1: Screen positioning commands
271: */
272: case Ctrl('D'):
273: flag = TRUE;
274:
275: case Ctrl('U'):
276: if ((c == Ctrl('U') && curwin->w_cursor.lnum == 1) ||
277: (c == Ctrl('D') && curwin->w_cursor.lnum ==
278: curbuf->b_ml.ml_line_count))
279: clearopbeep();
280: else
281: {
282: if (checkclearop())
283: break;
284: halfpage(flag, Prenum);
285: }
286: break;
287:
288: case Ctrl('B'):
289: case K_S_UP:
290: case K_PAGEUP:
291: dir = BACKWARD;
292:
293: case Ctrl('F'):
294: case K_S_DOWN:
295: case K_PAGEDOWN:
296: if (checkclearop())
297: break;
298: (void)onepage(dir, Prenum1);
299: break;
300:
301: case Ctrl('E'):
302: if (checkclearop())
303: break;
304: scrollup(Prenum1);
305: if (p_so)
306: cursor_correct();
307: /* We may have moved to another line -- webb */
308: coladvance(curwin->w_curswant);
309: cursupdate();
310: updateScreen(VALID);
311: break;
312:
313: case Ctrl('Y'):
314: if (checkclearop())
315: break;
316: scrolldown(Prenum1);
317: if (p_so)
318: cursor_correct();
319: /* We may have moved to another line -- webb */
320: coladvance(curwin->w_curswant);
321: updateScreen(VALID);
322: break;
323:
324: case 'z':
325: if (checkclearop())
326: break;
327: if (nchar < 0x100 && isdigit(nchar))
328: {
329: Prenum = nchar - '0';
330: for (;;)
331: {
332: ++no_mapping;
333: ++allow_keys; /* no mapping for nchar, but allow key codes */
334: nchar = vgetc();
335: #ifdef HAVE_LANGMAP
336: LANGMAP_ADJUST(c, TRUE);
337: #endif
338: --no_mapping;
339: --allow_keys;
340: (void)add_to_showcmd(nchar, FALSE);
341: if (c == K_DEL)
342: Prenum /= 10;
343: else if (nchar < 0x100 && isdigit(nchar))
344: Prenum = Prenum * 10 + (nchar - '0');
345: else if (nchar == CR)
346: {
347: win_setheight((int)Prenum);
348: break;
349: }
350: else if (nchar == 'l' || nchar == 'h' ||
351: nchar == K_LEFT || nchar == K_RIGHT)
352: {
353: Prenum1 = Prenum ? Prenum : 1;
354: goto dozet;
355: }
356: else
357: {
358: clearopbeep();
359: break;
360: }
361: }
362: op_type = NOP;
363: break;
364: }
365: dozet:
366: /*
367: * If line number given, set cursor, except for "zh", "zl", "ze" and
368: * "zs"
369: */
370: if (vim_strchr((char_u *)"hles", nchar) == NULL &&
371: nchar != K_LEFT && nchar != K_RIGHT &&
372: Prenum && Prenum != curwin->w_cursor.lnum)
373: {
374: setpcmark();
375: if (Prenum > curbuf->b_ml.ml_line_count)
376: curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
377: else
378: curwin->w_cursor.lnum = Prenum;
379: }
380: switch (nchar)
381: {
382: case NL: /* put curwin->w_cursor at top of screen */
383: case CR:
384: beginline(TRUE);
385: /* FALLTHROUGH */
386: case 't':
387: scroll_cursor_top(0, TRUE);
388: break;
389:
390: case '.': /* put curwin->w_cursor in middle of screen */
391: beginline(TRUE);
392: /* FALLTHROUGH */
393: case 'z':
394: scroll_cursor_halfway(TRUE);
395: break;
396:
397: case '-': /* put curwin->w_cursor at bottom of screen */
398: beginline(TRUE);
399: /* FALLTHROUGH */
400: case 'b':
401: scroll_cursor_bot(0, TRUE);
402: break;
403:
404: /* "zh" - scroll screen to the right */
405: case 'h':
406: case K_LEFT:
407: if (!curwin->w_p_wrap)
408: {
409: colnr_t s, e;
410:
411: if ((colnr_t)Prenum1 > curwin->w_leftcol)
412: curwin->w_leftcol = 0;
413: else
414: curwin->w_leftcol -= (colnr_t)Prenum1;
415: n = curwin->w_leftcol + Columns -
416: (curwin->w_p_nu ? 8 : 0) - 1;
417: if (curwin->w_virtcol > (colnr_t)n)
418: coladvance((colnr_t)n);
419:
420: getvcol(curwin, &curwin->w_cursor, &s, NULL, &e);
421: if (e > (colnr_t)n)
422: coladvance(s - 1);
423: redraw_later(NOT_VALID);
424: }
425: break;
426:
427: /* "zl" - scroll screen to the left */
428: case 'l':
429: case K_RIGHT:
430: if (!curwin->w_p_wrap)
431: {
432: colnr_t s, e;
433:
434: /* scroll the window left */
435: curwin->w_leftcol += (colnr_t)Prenum1;
436:
437: /* If the cursor has moved off the screen, put it at the
438: * first char on the screen */
439: if (curwin->w_leftcol > curwin->w_virtcol)
440: (void)coladvance(curwin->w_leftcol);
441:
442: /* If the start of the character under the cursor is not
443: * on the screen, advance the cursor one more char. If
444: * this fails (last char of the line) adjust the
445: * scrolling. */
446: getvcol(curwin, &curwin->w_cursor, &s, NULL, &e);
447: if (s < curwin->w_leftcol)
448: if (coladvance(e + 1) == FAIL)
449: curwin->w_leftcol = s;
450:
451: redraw_later(NOT_VALID);
452: }
453: break;
454:
455: /* "zs" - scroll screen, cursor at the start */
456: case 's':
457: if (!curwin->w_p_wrap)
458: {
459: colnr_t s;
460:
461: getvcol(curwin, &curwin->w_cursor, &s, NULL, NULL);
462: curwin->w_leftcol = s;
463: redraw_later(NOT_VALID);
464: }
465: break;
466:
467: /* "ze" - scroll screen, cursor at the end */
468: case 'e':
469: if (!curwin->w_p_wrap)
470: {
471: colnr_t e;
472:
473: getvcol(curwin, &curwin->w_cursor, NULL, NULL, &e);
474: if ((long)e < Columns)
475: curwin->w_leftcol = 0;
476: else
477: curwin->w_leftcol = e - Columns + 1;
478: redraw_later(NOT_VALID);
479: }
480: break;
481:
482: case Ctrl('S'): /* ignore CTRL-S and CTRL-Q to avoid problems */
483: case Ctrl('Q'): /* with terminals that use xon/xoff */
484: break;
485:
486: default:
487: clearopbeep();
488: }
489: updateScreen(VALID);
490: break;
491:
492: /*
493: * 2: Control commands
494: */
495: case ':':
496: if (VIsual_active)
497: goto dooperator;
498: if (checkclearop())
499: break;
500: /*
501: * translate "count:" into ":.,.+(count - 1)"
502: */
503: if (Prenum)
504: {
505: stuffReadbuff((char_u *)".");
506: if (Prenum > 1)
507: {
508: stuffReadbuff((char_u *)",.+");
509: stuffnumReadbuff((long)Prenum - 1L);
510: }
511: }
512: do_cmdline(NULL, FALSE, FALSE);
513: break;
514:
515: case K_HELP:
516: case K_F1:
517: if (checkclearopq())
518: break;
519: do_help((char_u *)"");
520: break;
521:
522: case Ctrl('L'):
523: if (checkclearop())
524: break;
525: updateScreen(CLEAR);
526: break;
527:
528: case Ctrl('G'):
529: if (checkclearop())
530: break;
531: /* print full name if count given or :cd used */
532: fileinfo(did_cd | (int)Prenum, FALSE, FALSE);
533:
534: /*
535: * In Visual mode and "^O^G" in Insert mode, the message will be
536: * overwritten by the mode message. Wait a bit, until a key is hit.
537: */
538: if ((VIsual_active || (restart_edit && p_smd)) && KeyTyped)
539: {
540: setcursor();
541: flushbuf();
542: mch_delay(10000L, FALSE);
543: }
544: break;
545:
546: case K_CCIRCM: /* CTRL-^, short for ":e #" */
547: if (checkclearopq())
548: break;
549: (void)buflist_getfile((int)Prenum, (linenr_t)0, GETF_SETMARK|GETF_ALT);
550: break;
551:
552: case 'Z': /* write, if changed, and exit */
553: if (checkclearopq())
554: break;
555: if (nchar != 'Z')
556: {
557: clearopbeep();
558: break;
559: }
560: stuffReadbuff((char_u *)":x\n");
561: break;
562:
563: case Ctrl(']'): /* :ta to current identifier */
564: case 'K': /* run program for current identifier */
565: if (VIsual_active) /* :ta to visual highlighted text */
566: {
567: if (VIsual.lnum != curwin->w_cursor.lnum)
568: {
569: clearopbeep();
570: break;
571: }
572: if (lt(curwin->w_cursor, VIsual))
573: {
574: ptr = ml_get_pos(&curwin->w_cursor);
575: n = VIsual.col - curwin->w_cursor.col + 1;
576: }
577: else
578: {
579: ptr = ml_get_pos(&VIsual);
580: n = curwin->w_cursor.col - VIsual.col + 1;
581: }
582: end_visual_mode();
583: ++RedrawingDisabled;
584: update_curbuf(NOT_VALID); /* update the inversion later */
585: --RedrawingDisabled;
586: }
587: if (checkclearopq())
588: break;
589: /*FALLTHROUGH*/
590:
591: case 163: /* the pound sign, '#' for English keyboards */
592: if (c == 163)
593: c = '#';
594: /*FALLTHROUGH*/
595:
596: case '*': /* / to current identifier or string */
597: case '#': /* ? to current identifier or string */
598: search_word:
599: if (c == 'g')
600: type = nchar; /* "g*" or "g#" */
601: else
602: type = c;
603: if (ptr == NULL && (n = find_ident_under_cursor(&ptr, (type == '*' ||
604: type == '#') ? FIND_IDENT|FIND_STRING : FIND_IDENT)) == 0)
605: {
606: clearop();
607: break;
608: }
609:
610: if (Prenum)
611: stuffnumReadbuff(Prenum);
612: switch (type)
613: {
614: case '*':
615: stuffReadbuff((char_u *)"/");
616: /* FALLTHROUGH */
617:
618: case '#':
619: if (type == '#')
620: stuffReadbuff((char_u *)"?");
621:
622: /*
623: * put cursor at start of word, makes search skip the word
624: * under the cursor
625: */
626: curwin->w_cursor.col = ptr - ml_get_curline();
627:
628: if (c != 'g' && iswordchar(*ptr))
629: stuffReadbuff((char_u *)"\\<");
630: no_smartcase = TRUE; /* don't use 'smartcase' now */
631: break;
632:
633: case 'K':
634: if (*p_kp == NUL)
635: stuffReadbuff((char_u *)":he ");
636: else
637: {
638: stuffReadbuff((char_u *)":! ");
639: stuffReadbuff(p_kp);
640: stuffReadbuff((char_u *)" ");
641: }
642: break;
643: default:
644: if (curbuf->b_help)
645: stuffReadbuff((char_u *)":he ");
646: else
647: stuffReadbuff((char_u *)":ta ");
648: }
649:
650: /*
651: * Now grab the chars in the identifier
652: */
653: while (n--)
654: {
655: /* put a backslash before \ and some others */
656: if (*ptr == '\\' || (!(type == '*' || type == '#') &&
657: vim_strchr(escape_chars, *ptr) != NULL))
658: stuffcharReadbuff('\\');
659: /* don't interpret the characters as edit commands */
660: if (*ptr < ' ' || *ptr > '~')
661: stuffcharReadbuff(Ctrl('V'));
662: stuffcharReadbuff(*ptr++);
663: }
664:
665: if (c != 'g' && (type == '*' || type == '#') && iswordchar(ptr[-1]))
666: stuffReadbuff((char_u *)"\\>");
667: stuffReadbuff((char_u *)"\n");
668: break;
669:
670: case Ctrl('T'): /* backwards in tag stack */
671: if (checkclearopq())
672: break;
673: do_tag((char_u *)"", 2, (int)Prenum1);
674: break;
675:
676: /*
677: * Cursor motions
678: */
679: case 'G':
680: goto_line:
681: op_motion_type = MLINE;
682: setpcmark();
683: if (Prenum == 0 || Prenum > curbuf->b_ml.ml_line_count)
684: curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
685: else
686: curwin->w_cursor.lnum = Prenum;
687: beginline(MAYBE);
688: break;
689:
690: case 'H':
691: case 'M':
692: if (c == 'M')
693: {
694: int used = 0;
695:
696: for (n = 0; curwin->w_topline + n < curbuf->b_ml.ml_line_count; ++n)
697: if ((used += plines(curwin->w_topline + n)) >=
698: (curwin->w_height - curwin->w_empty_rows + 1) / 2)
699: break;
700: if (n && used > curwin->w_height)
701: --n;
702: }
703: else
704: n = Prenum;
705: op_motion_type = MLINE;
706: setpcmark();
707: curwin->w_cursor.lnum = curwin->w_topline + n;
708: if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
709: curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
710: cursor_correct(); /* correct for 'so' */
711: beginline(MAYBE);
712: break;
713:
714: case 'L':
715: op_motion_type = MLINE;
716: setpcmark();
717: curwin->w_cursor.lnum = curwin->w_botline - 1;
718: if (Prenum >= curwin->w_cursor.lnum)
719: curwin->w_cursor.lnum = 1;
720: else
721: curwin->w_cursor.lnum -= Prenum;
722: cursor_correct(); /* correct for 'so' */
723: beginline(MAYBE);
724: break;
725:
726: case 'l':
727: case K_RIGHT:
728: case ' ':
729: op_motion_type = MCHAR;
730: op_inclusive = FALSE;
731: n = Prenum1;
732: while (n--)
733: {
734: if (oneright() == FAIL)
735: {
736: /* space wraps to next line if 'whichwrap' bit 1 set */
737: /* 'l' wraps to next line if 'whichwrap' bit 2 set */
738: /* CURS_RIGHT wraps to next line if 'whichwrap' bit 3 set */
739: if (((c == ' ' && vim_strchr(p_ww, 's') != NULL) ||
740: (c == 'l' && vim_strchr(p_ww, 'l') != NULL) ||
741: (c == K_RIGHT && vim_strchr(p_ww, '>') != NULL)) &&
742: curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
743: {
744: /* When deleting we also count the NL as a character.
745: * Set op_inclusive when last char in the line is
746: * included, move to next line after that */
747: if ((op_type == DELETE || op_type == CHANGE) &&
748: !op_inclusive && !lineempty(curwin->w_cursor.lnum))
749: op_inclusive = TRUE;
750: else
751: {
752: ++curwin->w_cursor.lnum;
753: curwin->w_cursor.col = 0;
754: curwin->w_set_curswant = TRUE;
755: op_inclusive = FALSE;
756: }
757: continue;
758: }
759: if (op_type == NOP)
760: beep_flush();
761: else
762: {
763: if (lineempty(curwin->w_cursor.lnum))
764: clearopbeep();
765: else
766: {
767: op_inclusive = TRUE;
768: if (n)
769: beep_flush();
770: }
771: }
772: break;
773: }
774: }
775: break;
776:
777: case 'h':
778: case K_LEFT:
779: case K_BS:
780: case Ctrl('H'):
781: op_motion_type = MCHAR;
782: op_inclusive = FALSE;
783: n = Prenum1;
784: while (n--)
785: {
786: if (oneleft() == FAIL)
787: {
788: /* backspace and del wrap to previous line if 'whichwrap'
789: * bit 0 set.
790: * 'h' wraps to previous line if 'whichwrap' bit 2 set.
791: * CURS_LEFT wraps to previous line if 'whichwrap' bit 3
792: * set. */
793: if ( (((c == K_BS || c == Ctrl('H'))
794: && vim_strchr(p_ww, 'b') != NULL) ||
795: (c == 'h' && vim_strchr(p_ww, 'h') != NULL) ||
796: (c == K_LEFT && vim_strchr(p_ww, '<') != NULL)) &&
797: curwin->w_cursor.lnum > 1)
798: {
799: --(curwin->w_cursor.lnum);
800: coladvance(MAXCOL);
801: curwin->w_set_curswant = TRUE;
802:
803: /* When the NL before the first char has to be deleted we
804: * put the cursor on the NUL after the previous line.
805: * This is a very special case, be careful!
806: * don't adjust op_end now, otherwise it won't work */
807: if ((op_type == DELETE || op_type == CHANGE) &&
808: !lineempty(curwin->w_cursor.lnum))
809: {
810: ++curwin->w_cursor.col;
811: dont_adjust_op_end = TRUE;
812: }
813: continue;
814: }
815: else if (op_type != DELETE && op_type != CHANGE)
816: beep_flush();
817: else if (Prenum1 == 1)
818: clearopbeep();
819: break;
820: }
821: }
822: break;
823:
824: case '-':
825: flag = TRUE;
826: /* FALLTHROUGH */
827:
828: case 'k':
829: case K_UP:
830: case Ctrl('P'):
831: normal_k:
832: op_motion_type = MLINE;
833: if (cursor_up(Prenum1) == FAIL)
834: clearopbeep();
835: else if (flag)
836: beginline(TRUE);
837: break;
838:
839: case '+':
840: case CR:
841: flag = TRUE;
842: /* FALLTHROUGH */
843:
844: case 'j':
845: case K_DOWN:
846: case Ctrl('N'):
847: case NL:
848: normal_j:
849: op_motion_type = MLINE;
850: if (cursor_down(Prenum1) == FAIL)
851: clearopbeep();
852: else if (flag)
853: beginline(TRUE);
854: break;
855:
856: /*
857: * This is a strange motion command that helps make operators more
858: * logical. It is actually implemented, but not documented in the
859: * real 'vi'. This motion command actually refers to "the current
860: * line". Commands like "dd" and "yy" are really an alternate form of
861: * "d_" and "y_". It does accept a count, so "d3_" works to delete 3
862: * lines.
863: */
864: case '_':
865: lineop:
866: old_col = curwin->w_curswant;
867: op_motion_type = MLINE;
868: if (cursor_down((long)(Prenum1 - 1)) == FAIL)
869: clearopbeep();
870: if (op_type == DELETE || op_type == LSHIFT || op_type == RSHIFT)
871: beginline(MAYBE);
872: else if (op_type != YANK) /* 'Y' does not move cursor */
873: beginline(TRUE);
874: break;
875:
876: case K_HOME:
877: if ((mod_mask & MOD_MASK_CTRL))
878: goto goto_line_one;
879: Prenum = 1;
880: /* FALLTHROUGH */
881:
882: case '|':
883: op_motion_type = MCHAR;
884: op_inclusive = FALSE;
885: beginline(FALSE);
886: if (Prenum > 0)
887: {
888: coladvance((colnr_t)(Prenum - 1));
889: curwin->w_curswant = (colnr_t)(Prenum - 1);
890: }
891: else
892: curwin->w_curswant = 0;
893: /* keep curswant at the column where we wanted to go, not where
894: we ended; differs is line is too short */
895: curwin->w_set_curswant = FALSE;
896: break;
897:
898: /*
899: * Word Motions
900: */
901:
902: case 'B':
903: type = 1;
904: /* FALLTHROUGH */
905:
906: case 'b':
907: case K_S_LEFT:
908: op_motion_type = MCHAR;
909: op_inclusive = FALSE;
910: curwin->w_set_curswant = TRUE;
911: if (bck_word(Prenum1, type, FALSE) == FAIL)
912: clearopbeep();
913: break;
914:
915: case 'E':
916: type = 1;
917: /* FALLTHROUGH */
918:
919: case 'e':
920: op_inclusive = TRUE;
921: goto dowrdcmd;
922:
923: case 'W':
924: type = 1;
925: /* FALLTHROUGH */
926:
927: case 'w':
928: case K_S_RIGHT:
929: op_inclusive = FALSE;
930: flag = TRUE;
931: /*
932: * This is a little strange. To match what the real vi does, we
933: * effectively map 'cw' to 'ce', and 'cW' to 'cE', provided that we
934: * are not on a space or a TAB. This seems impolite at first, but it's
935: * really more what we mean when we say 'cw'.
936: * Another strangeness: When standing on the end of a word "ce" will
937: * change until the end of the next wordt, but "cw" will change only
938: * one character! This is done by setting type to 2.
939: */
940: if (op_type == CHANGE && (n = gchar_cursor()) != ' ' && n != TAB &&
941: n != NUL)
942: {
943: op_inclusive = TRUE;
944: flag = FALSE;
945: flag2 = TRUE;
946: }
947:
948: dowrdcmd:
949: op_motion_type = MCHAR;
950: curwin->w_set_curswant = TRUE;
951: if (flag)
952: n = fwd_word(Prenum1, type, op_type != NOP);
953: else
954: n = end_word(Prenum1, type, flag2, FALSE);
955: if (n == FAIL)
956: clearopbeep();
957: break;
958:
959: case K_END:
960: if ((mod_mask & MOD_MASK_CTRL))
961: goto goto_line;
962: /* FALLTHROUGH */
963:
964: case '$':
965: op_motion_type = MCHAR;
966: op_inclusive = TRUE;
967: curwin->w_curswant = MAXCOL; /* so we stay at the end */
968: if (cursor_down((long)(Prenum1 - 1)) == FAIL)
969: {
970: clearopbeep();
971: break;
972: }
973: break;
974:
975: case '^':
976: flag = TRUE;
977: /* FALLTHROUGH */
978:
979: case '0':
980: op_motion_type = MCHAR;
981: op_inclusive = FALSE;
982: beginline(flag);
983: break;
984:
985: /*
986: * 4: Searches
987: */
988: case '?':
989: case '/':
990: if ((searchbuff = getcmdline(c, Prenum1)) == NULL)
991: {
992: clearop();
993: break;
994: }
995: op_motion_type = MCHAR;
996: op_inclusive = FALSE;
997: curwin->w_set_curswant = TRUE;
998:
999: n = do_search(c, searchbuff, Prenum1,
1000: SEARCH_MARK | SEARCH_OPT | SEARCH_ECHO | SEARCH_MSG);
1001: if (n == 0)
1002: clearop();
1003: else if (n == 2)
1004: op_motion_type = MLINE;
1005: break;
1006:
1007: case 'N':
1008: flag = SEARCH_REV;
1009:
1010: case 'n':
1011: op_motion_type = MCHAR;
1012: op_inclusive = FALSE;
1013: curwin->w_set_curswant = TRUE;
1014: if (!do_search(0, NULL, Prenum1,
1015: SEARCH_MARK | SEARCH_OPT | SEARCH_ECHO | SEARCH_MSG | flag))
1016: clearop();
1017: break;
1018:
1019: /*
1020: * Character searches
1021: */
1022: case 'T':
1023: dir = BACKWARD;
1024: /* FALLTHROUGH */
1025:
1026: case 't':
1027: type = 1;
1028: goto docsearch;
1029:
1030: case 'F':
1031: dir = BACKWARD;
1032: /* FALLTHROUGH */
1033:
1034: case 'f':
1035: docsearch:
1036: op_motion_type = MCHAR;
1037: if (dir == BACKWARD)
1038: op_inclusive = FALSE;
1039: else
1040: op_inclusive = TRUE;
1041: curwin->w_set_curswant = TRUE;
1042: if (nchar >= 0x100 || !searchc(nchar, dir, type, Prenum1))
1043: clearopbeep();
1044: break;
1045:
1046: case ',':
1047: flag = 1;
1048: /* FALLTHROUGH */
1049:
1050: case ';':
1051: dir = flag;
1052: goto docsearch; /* nchar == NUL, thus repeat previous search */
1053:
1054: /*
1055: * section or C function searches
1056: */
1057: case '[':
1058: dir = BACKWARD;
1059: /* FALLTHROUGH */
1060:
1061: case ']':
1062: op_motion_type = MCHAR;
1063: op_inclusive = FALSE;
1064:
1065: /*
1066: * "[f" or "]f" : Edit file under the cursor (same as "gf")
1067: */
1068: if (nchar == 'f')
1069: goto gotofile;
1070:
1071: /*
1072: * Find the occurence(s) of the identifier or define under cursor
1073: * in current and included files or jump to the first occurence.
1074: *
1075: * search list jump
1076: * fwd bwd fwd bwd fwd bwd
1077: * identifier "]i" "[i" "]I" "[I" "]^I" "[^I"
1078: * define "]d" "[d" "]D" "[D" "]^D" "[^D"
1079: */
1080: if (nchar == 'i' || nchar == 'I' || nchar == Ctrl('I') ||
1081: nchar == 'd' || nchar == 'D' || nchar == Ctrl('D'))
1082: {
1083: int len;
1084:
1085: if ((len = find_ident_under_cursor(&ptr, FIND_IDENT)) == 0)
1086: {
1087: clearop();
1088: break;
1089: }
1090: find_pattern_in_path(ptr, len, TRUE,
1091: Prenum == 0 ? !isupper(nchar) : FALSE,
1092: ((nchar & 0xf) == ('d' & 0xf)) ? FIND_DEFINE : FIND_ANY,
1093: Prenum1,
1094: isupper(nchar) ? ACTION_SHOW_ALL :
1095: islower(nchar) ? ACTION_SHOW : ACTION_GOTO,
1096: c == ']' ? curwin->w_cursor.lnum : (linenr_t)1,
1097: (linenr_t)MAXLNUM);
1098: curwin->w_set_curswant = TRUE;
1099: break;
1100: }
1101:
1102: /*
1103: * "[{", "[(", "]}" or "])": go to Nth unclosed '{', '(', '}' or ')'
1104: * "[#", "]#": go to start/end of Nth innermost #if..#endif construct.
1105: * "[/", "[*", "]/", "]*": go to Nth comment start/end.
1106: */
1107: if ((c == '[' && vim_strchr((char_u *)"{(*/#", nchar) != NULL) ||
1108: (c == ']' && vim_strchr((char_u *)"})*/#", nchar) != NULL))
1109: {
1110: FPOS old_pos;
1111: FPOS new_pos;
1112:
1113: if (nchar == '*')
1114: nchar = '/';
1115: old_pos = curwin->w_cursor;
1116: new_pos.lnum = 0;
1117: while (Prenum1--)
1118: {
1119: if ((pos = findmatchlimit(nchar,
1120: (c == '[') ? FM_BACKWARD : FM_FORWARD, 0)) == NULL)
1121: {
1122: if (new_pos.lnum == 0) /* nothing found */
1123: clearopbeep();
1124: else
1125: pos = &new_pos; /* use last one found */
1126: break;
1127: }
1128: curwin->w_cursor = *pos;
1129: new_pos= *pos;
1130: }
1131: curwin->w_cursor = old_pos;
1132: if (pos != NULL)
1133: {
1134: setpcmark();
1135: curwin->w_cursor = *pos;
1136: curwin->w_set_curswant = TRUE;
1137: }
1138: break;
1139: }
1140:
1141: /*
1142: * "[[", "[]", "]]" and "][": move to start or end of function
1143: */
1144: if (nchar == '[' || nchar == ']')
1145: {
1146: if (nchar == c) /* "]]" or "[[" */
1147: flag = '{';
1148: else
1149: flag = '}'; /* "][" or "[]" */
1150:
1151: curwin->w_set_curswant = TRUE;
1152: /*
1153: * Imitate strange vi behaviour: When using "]]" with an operator
1154: * we also stop at '}'.
1155: */
1156: if (!findpar(dir, Prenum1, flag,
1157: (op_type != NOP && dir == FORWARD && flag == '{')))
1158: clearopbeep();
1159: else if (op_type == NOP)
1160: beginline(TRUE);
1161: break;
1162: }
1163:
1164: /*
1165: * "[p", "[P", "]P" and "]p": put with indent adjustment
1166: */
1167: if (nchar == 'p' || nchar == 'P')
1168: {
1169: if (checkclearopq())
1170: break;
1171: prep_redo(Prenum, NUL, c, nchar, NUL);
1172: do_put((c == ']' && nchar == 'p') ? FORWARD : BACKWARD,
1173: Prenum1, TRUE);
1174: break;
1175: }
1176:
1177: #ifdef USE_MOUSE
1178: /*
1179: * [ or ] followed by a middle mouse click: put selected text with
1180: * indent adjustment. Any other button just does as usual.
1181: */
1182: if (nchar >= K_LEFTMOUSE && nchar <= K_RIGHTRELEASE)
1183: {
1184: (void)do_mouse(nchar, (c == ']') ? FORWARD : BACKWARD,
1185: Prenum1, TRUE);
1186: break;
1187: }
1188: #endif /* USE_MOUSE */
1189:
1190: /*
1191: * end of '[' and ']': not a valid nchar
1192: */
1193: clearopbeep();
1194: break;
1195:
1196: case '%':
1197: op_inclusive = TRUE;
1198: if (Prenum) /* {cnt}% : goto {cnt} percentage in file */
1199: {
1200: if (Prenum > 100)
1201: clearopbeep();
1202: else
1203: {
1204: op_motion_type = MLINE;
1205: setpcmark();
1206: /* round up, so CTRL-G will give same value */
1207: curwin->w_cursor.lnum = (curbuf->b_ml.ml_line_count *
1208: Prenum + 99) / 100;
1209: beginline(MAYBE);
1210: }
1211: }
1212: else /* % : go to matching paren */
1213: {
1214: op_motion_type = MCHAR;
1215: if ((pos = findmatch(NUL)) == NULL)
1216: clearopbeep();
1217: else
1218: {
1219: setpcmark();
1220: curwin->w_cursor = *pos;
1221: curwin->w_set_curswant = TRUE;
1222: }
1223: }
1224: break;
1225:
1226: case '(':
1227: dir = BACKWARD;
1228: /* FALLTHROUGH */
1229:
1230: case ')':
1231: op_motion_type = MCHAR;
1232: if (c == ')')
1233: op_inclusive = FALSE;
1234: else
1235: op_inclusive = TRUE;
1236: curwin->w_set_curswant = TRUE;
1237:
1238: if (findsent(dir, Prenum1) == FAIL)
1239: clearopbeep();
1240: break;
1241:
1242: case '{':
1243: dir = BACKWARD;
1244: /* FALLTHROUGH */
1245:
1246: case '}':
1247: op_motion_type = MCHAR;
1248: op_inclusive = FALSE;
1249: curwin->w_set_curswant = TRUE;
1250: if (!findpar(dir, Prenum1, NUL, FALSE))
1251: clearopbeep();
1252: break;
1253:
1254: /*
1255: * 5: Edits
1256: */
1257: case '.': /* redo command */
1258: if (checkclearopq())
1259: break;
1260: /*
1261: * if restart_edit is TRUE, the last but one command is repeated
1262: * instead of the last command (inserting text). This is used for
1263: * CTRL-O <.> in insert mode
1264: */
1265: if (start_redo(Prenum, restart_edit && !arrow_used) == FAIL)
1266: clearopbeep();
1267: break;
1268:
1269: case 'u': /* undo */
1270: if (VIsual_active || op_type == vim_strchr(opchars, 'u') - opchars + 1)
1271: goto dooperator;
1272: case K_UNDO:
1273: if (checkclearopq())
1274: break;
1275: u_undo((int)Prenum1);
1276: curwin->w_set_curswant = TRUE;
1277: break;
1278:
1279: case Ctrl('R'): /* undo undo */
1280: if (checkclearopq())
1281: break;
1282: u_redo((int)Prenum1);
1283: curwin->w_set_curswant = TRUE;
1284: break;
1285:
1286: case 'U': /* Undo line */
1287: if (VIsual_active || op_type == vim_strchr(opchars, 'U') - opchars + 1)
1288: goto dooperator;
1289: if (checkclearopq())
1290: break;
1291: u_undoline();
1292: curwin->w_set_curswant = TRUE;
1293: break;
1294:
1295: case 'r':
1296: if (VIsual_active)
1297: {
1298: c = 'c';
1299: goto dooperator;
1300: }
1301: if (checkclearop())
1302: break;
1303: ptr = ml_get_cursor();
1304: /* special key or not enough characters to replace */
1305: if (nchar >= 0x100 || STRLEN(ptr) < (unsigned)Prenum1)
1306: {
1307: clearopbeep();
1308: break;
1309: }
1310: /*
1311: * Replacing with a TAB is done by edit(), because it is complicated
1312: * when 'expandtab' is set.
1313: * Other characters are done below to avoid problems with things like
1314: * CTRL-V 048 (for edit() this would be R CTRL-V 0 ESC).
1315: */
1316: if (nchar == '\t' && curbuf->b_p_et)
1317: {
1318: prep_redo(Prenum1, NUL, 'r', '\t', NUL);
1319: stuffnumReadbuff(Prenum1);
1320: stuffcharReadbuff('R');
1321: stuffcharReadbuff('\t');
1322: stuffcharReadbuff(ESC);
1323: break;
1324: }
1325:
1326: if (nchar == Ctrl('V')) /* get another character */
1327: {
1328: c = Ctrl('V');
1329: nchar = get_literal();
1330: }
1331: else
1332: c = NUL;
1333: prep_redo(Prenum1, NUL, 'r', c, nchar);
1334: if (u_save_cursor() == FAIL) /* save line for undo */
1335: break;
1336: /*
1337: * Replace characters by a newline.
1338: * Strange vi behaviour: Only one newline is inserted.
1339: * Delete the characters here.
1340: * Insert the newline with an insert command, takes care of
1341: * autoindent.
1342: */
1343: if (c != Ctrl('V') && (nchar == '\r' || nchar == '\n'))
1344: {
1345: while (Prenum1--) /* delete the characters */
1346: delchar(FALSE);
1347: /* replacing the last character of a line is different */
1348: if (curwin->w_cursor.col > 0 && gchar_cursor() == NUL)
1349: {
1350: --curwin->w_cursor.col;
1351: stuffcharReadbuff('a');
1352: }
1353: else
1354: stuffcharReadbuff('i');
1355: stuffcharReadbuff('\r');
1356: stuffcharReadbuff(ESC);
1357: }
1358: else
1359: {
1360: while (Prenum1--) /* replace the characters */
1361: {
1362: /*
1363: * Replace a 'normal' character.
1364: * Get ptr again, because u_save and/or showmatch() will have
1365: * released the line. At the same time we let know that the
1366: * line will be changed.
1367: */
1368: ptr = ml_get_buf(curbuf, curwin->w_cursor.lnum, TRUE);
1369: ptr[curwin->w_cursor.col] = nchar;
1370: if (p_sm && (nchar == ')' || nchar == '}' || nchar == ']'))
1371: showmatch();
1372: ++curwin->w_cursor.col;
1373: }
1374: --curwin->w_cursor.col; /* cursor on the last replaced char */
1375: }
1376: curwin->w_set_curswant = TRUE;
1377: CHANGED;
1378: updateline();
1379: set_last_insert(nchar);
1380: break;
1381:
1382: case 'J':
1383: if (VIsual_active) /* join the visual lines */
1384: goto dooperator;
1385: if (checkclearop())
1386: break;
1387: if (Prenum <= 1)
1388: Prenum = 2; /* default for join is two lines! */
1389: if (curwin->w_cursor.lnum + Prenum - 1 > curbuf->b_ml.ml_line_count)
1390: {
1391: clearopbeep(); /* beyond last line */
1392: break;
1393: }
1394:
1395: prep_redo(Prenum, NUL, 'J', NUL, NUL);
1396: do_do_join(Prenum, TRUE, TRUE);
1397: break;
1398:
1399: case 'P':
1400: dir = BACKWARD;
1401: /* FALLTHROUGH */
1402:
1403: case 'p':
1404: /*
1405: * 'P' after an operator or with Visual: Set current block.
1406: * 'p' after an operator or with Visual: Set current paragraph.
1407: */
1408: if (op_type != NOP || VIsual_active)
1409: {
1410: if (c == 'P')
1411: {
1412: if (current_block('{', Prenum1) == FAIL)
1413: clearopbeep();
1414: }
1415: else
1416: {
1417: if (current_par(c, Prenum1) == FAIL)
1418: clearopbeep();
1419: }
1420: curwin->w_set_curswant = TRUE;
1421: }
1422: else
1423: {
1424: prep_redo(Prenum, NUL, c, NUL, NUL);
1425: do_put(dir, Prenum1, FALSE);
1426: }
1427: break;
1428:
1429: case Ctrl('A'): /* add to number */
1430: case Ctrl('X'): /* subtract from number */
1431: if (checkclearopq())
1432: break;
1433: if (do_addsub((int)c, Prenum1) == OK)
1434: prep_redo(Prenum1, NUL, c, NUL, NUL);
1435: break;
1436:
1437: /*
1438: * 6: Inserts
1439: */
1440: case 'A':
1441: type = 1;
1442: /* FALLTHROUGH */
1443:
1444: case 'a':
1445: if (op_type != NOP || VIsual_active)
1446: {
1447: if (current_word(Prenum1, type) == FAIL)
1448: clearopbeep();
1449: curwin->w_set_curswant = TRUE;
1450: }
1451: else
1452: {
1453: if (c == 'A')
1454: {
1455: curwin->w_set_curswant = TRUE;
1456: while (oneright() == OK)
1457: ;
1458: }
1459:
1460: /* Works just like an 'i'nsert on the next character. */
1461: if (u_save_cursor() == OK)
1462: {
1463: if (!lineempty(curwin->w_cursor.lnum))
1464: inc_cursor();
1465: command_busy = edit(c, FALSE, Prenum1);
1466: }
1467: }
1468: break;
1469:
1470: case 'I':
1471: if (checkclearopq())
1472: break;
1473: beginline(TRUE);
1474: /* FALLTHROUGH */
1475:
1476: case 'i':
1477: case K_INS:
1478: insert_command:
1479: if (checkclearopq())
1480: break;
1481: if (u_save_cursor() == OK)
1482: command_busy = edit(c, FALSE, Prenum1);
1483: break;
1484:
1485: case 'o':
1486: if (VIsual_active) /* switch start and end of visual */
1487: {
1488: Prenum = VIsual.lnum;
1489: VIsual.lnum = curwin->w_cursor.lnum;
1490: curwin->w_cursor.lnum = Prenum;
1491: n = VIsual.col;
1492: VIsual.col = curwin->w_cursor.col;
1493: curwin->w_cursor.col = (int)n;
1494: curwin->w_set_curswant = TRUE;
1495: break;
1496: }
1497: if (checkclearop())
1498: break;
1499: if (has_format_option(FO_OPEN_COMS))
1500: fo_do_comments = TRUE;
1501: if (u_save(curwin->w_cursor.lnum,
1502: (linenr_t)(curwin->w_cursor.lnum + 1)) == OK &&
1503: Opencmd(FORWARD, TRUE, FALSE))
1504: command_busy = edit('o', TRUE, Prenum1);
1505: fo_do_comments = FALSE;
1506: break;
1507:
1508: case 'O':
1509: if (checkclearopq())
1510: break;
1511: if (has_format_option(FO_OPEN_COMS))
1512: fo_do_comments = TRUE;
1513: if (u_save((linenr_t)(curwin->w_cursor.lnum - 1),
1514: curwin->w_cursor.lnum) == OK && Opencmd(BACKWARD, TRUE, FALSE))
1515: command_busy = edit('O', TRUE, Prenum1);
1516: fo_do_comments = FALSE;
1517: break;
1518:
1519: case 'R':
1520: if (VIsual_active)
1521: {
1522: c = 'c';
1523: VIsual_mode = 'V';
1524: goto dooperator;
1525: }
1526: if (checkclearopq())
1527: break;
1528: if (u_save_cursor() == OK)
1529: command_busy = edit('R', FALSE, Prenum1);
1530: break;
1531:
1532: /*
1533: * 7: Operators
1534: */
1535: case '~': /* swap case */
1536: /*
1537: * if tilde is not an operator and Visual is off: swap case
1538: * of a single character
1539: */
1540: if (!p_to && !VIsual_active &&
1541: op_type != vim_strchr(opchars, '~') - opchars + 1)
1542: {
1543: if (checkclearopq())
1544: break;
1545: if (lineempty(curwin->w_cursor.lnum))
1546: {
1547: clearopbeep();
1548: break;
1549: }
1550: prep_redo(Prenum, NUL, '~', NUL, NUL);
1551:
1552: if (u_save_cursor() == FAIL)
1553: break;
1554:
1555: for (; Prenum1 > 0; --Prenum1)
1556: {
1557: if (gchar_cursor() == NUL)
1558: break;
1559: swapchar(&curwin->w_cursor);
1560: inc_cursor();
1561: }
1562:
1563: curwin->w_set_curswant = TRUE;
1564: CHANGED;
1565: updateline();
1566: break;
1567: }
1568: /*FALLTHROUGH*/
1569:
1570: case 'd':
1571: case 'c':
1572: case 'y':
1573: case '>':
1574: case '<':
1575: case '!':
1576: case '=':
1577: case 'Q': /* should start Ex mode */
1578: dooperator:
1579: n = vim_strchr(opchars, c) - opchars + 1;
1580: if (n == op_type) /* double operator works on lines */
1581: goto lineop;
1582: if (checkclearop())
1583: break;
1584: if (Prenum != 0)
1585: opnum = Prenum;
1586: curbuf->b_op_start = curwin->w_cursor;
1587: op_type = (int)n;
1588: break;
1589:
1590: /*
1591: * 8: Abbreviations
1592: */
1593:
1594: /* when Visual the next commands are operators */
1595: case K_DEL:
1596: c = 'x'; /* DEL key behaves like 'x' */
1597: case 'S':
1598: case 'Y':
1599: case 'D':
1600: case 'C':
1601: case 'x':
1602: case 'X':
1603: case 's':
1604: /*
1605: * 's' or 'S' with an operator: Operate on sentence or section.
1606: */
1607: if (op_type != NOP || VIsual_active)
1608: {
1609: if (c == 's') /* sentence */
1610: {
1611: if (current_sent(Prenum1) == FAIL)
1612: clearopbeep();
1613: curwin->w_set_curswant = TRUE;
1614: break;
1615: }
1616: if (c == 'S') /* block with () */
1617: {
1618: if (current_block('(', Prenum1) == FAIL)
1619: clearopbeep();
1620: curwin->w_set_curswant = TRUE;
1621: break;
1622: }
1623: }
1624: if (VIsual_active)
1625: {
1626: static char_u trans[] = "YyDdCcxdXd";
1627:
1628: /* uppercase means linewise */
1629: if (isupper(c) && VIsual_mode != Ctrl('V'))
1630: VIsual_mode = 'V';
1631: c = *(vim_strchr(trans, c) + 1);
1632: goto dooperator;
1633: }
1634:
1635: case '&':
1636: if (checkclearopq())
1637: break;
1638: if (Prenum)
1639: stuffnumReadbuff(Prenum);
1640:
1641: {
1642: static char_u *(ar[8]) = {(char_u *)"dl", (char_u *)"dh",
1643: (char_u *)"d$", (char_u *)"c$",
1644: (char_u *)"cl", (char_u *)"cc",
1645: (char_u *)"yy", (char_u *)":s\r"};
1646: static char_u *str = (char_u *)"xXDCsSY&";
1647:
1648: stuffReadbuff(ar[(int)(vim_strchr(str, c) - str)]);
1649: }
1650: break;
1651:
1652: /*
1653: * 9: Marks
1654: */
1655:
1656: case 'm':
1657: if (checkclearop())
1658: break;
1659: if (setmark(nchar) == FAIL)
1660: clearopbeep();
1661: break;
1662:
1663: case '\'':
1664: flag = TRUE;
1665: /* FALLTHROUGH */
1666:
1667: case '`':
1668: pos = getmark(nchar, (op_type == NOP));
1669: if (pos == (FPOS *)-1) /* jumped to other file */
1670: {
1671: if (flag)
1672: beginline(TRUE);
1673: break;
1674: }
1675:
1676: cursormark:
1677: if (check_mark(pos) == FAIL)
1678: clearop();
1679: else
1680: {
1681: if (c == '\'' || c == '`')
1682: setpcmark();
1683: curwin->w_cursor = *pos;
1684: if (flag)
1685: beginline(TRUE);
1686: }
1687: op_motion_type = flag ? MLINE : MCHAR;
1688: op_inclusive = FALSE; /* ignored if not MCHAR */
1689: curwin->w_set_curswant = TRUE;
1690: break;
1691:
1692: case Ctrl('O'): /* goto older pcmark */
1693: Prenum1 = -Prenum1;
1694: /* FALLTHROUGH */
1695:
1696: case Ctrl('I'): /* goto newer pcmark */
1697: if (checkclearopq())
1698: break;
1699: pos = movemark((int)Prenum1);
1700: if (pos == (FPOS *)-1) /* jump to other file */
1701: {
1702: curwin->w_set_curswant = TRUE;
1703: break;
1704: }
1705: if (pos != NULL) /* can jump */
1706: goto cursormark;
1707: clearopbeep();
1708: break;
1709:
1710: /*
1711: * 10. Buffer setting
1712: */
1713: case '"':
1714: if (checkclearop())
1715: break;
1716: if (nchar != NUL && is_yank_buffer(nchar, FALSE))
1717: {
1718: yankbuffer = nchar;
1719: opnum = Prenum; /* remember count before '"' */
1720: }
1721: else
1722: clearopbeep();
1723: break;
1724:
1725: /*
1726: * 11. Visual
1727: */
1728: case 'v':
1729: case 'V':
1730: case Ctrl('V'):
1731: if (checkclearop())
1732: break;
1733:
1734: /* change Visual mode */
1735: if (VIsual_active)
1736: {
1737: if (VIsual_mode == c) /* stop visual mode */
1738: {
1739: end_visual_mode();
1740: }
1741: else /* toggle char/block mode */
1742: { /* or char/line mode */
1743: VIsual_mode = c;
1744: showmode();
1745: }
1746: update_curbuf(NOT_VALID); /* update the inversion */
1747: }
1748: /* start Visual mode */
1749: else
1750: {
1751: VIsual_save = VIsual; /* keep for "gv" */
1752: VIsual_mode_save = VIsual_mode;
1753: start_visual_highlight();
1754: if (Prenum) /* use previously selected part */
1755: {
1756: if (resel_VIsual_mode == NUL) /* there is none */
1757: {
1758: beep_flush();
1759: break;
1760: }
1761: VIsual = curwin->w_cursor;
1762: VIsual_active = TRUE;
1763: #ifdef USE_MOUSE
1764: setmouse();
1765: #endif
1766: if (p_smd)
1767: redraw_cmdline = TRUE; /* show visual mode later */
1768: /*
1769: * For V and ^V, we multiply the number of lines even if there
1770: * was only one -- webb
1771: */
1772: if (resel_VIsual_mode != 'v' || resel_VIsual_line_count > 1)
1773: {
1774: curwin->w_cursor.lnum += resel_VIsual_line_count * Prenum - 1;
1775: if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
1776: curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
1777: }
1778: VIsual_mode = resel_VIsual_mode;
1779: if (VIsual_mode == 'v')
1780: {
1781: if (resel_VIsual_line_count <= 1)
1782: curwin->w_cursor.col += resel_VIsual_col * Prenum - 1;
1783: else
1784: curwin->w_cursor.col = resel_VIsual_col;
1785: }
1786: if (resel_VIsual_col == MAXCOL)
1787: {
1788: curwin->w_curswant = MAXCOL;
1789: coladvance(MAXCOL);
1790: }
1791: else if (VIsual_mode == Ctrl('V'))
1792: {
1793: curwin->w_curswant = curwin->w_virtcol +
1794: resel_VIsual_col * Prenum - 1;
1795: coladvance((colnr_t)curwin->w_curswant);
1796: }
1797: else
1798: curwin->w_set_curswant = TRUE;
1799: curs_columns(TRUE); /* recompute w_virtcol */
1800: update_curbuf(NOT_VALID); /* show the inversion */
1801: }
1802: else
1803: {
1804: VIsual = curwin->w_cursor;
1805: VIsual_mode = c;
1806: VIsual_active = TRUE;
1807: #ifdef USE_MOUSE
1808: setmouse();
1809: #endif
1810: if (p_smd)
1811: redraw_cmdline = TRUE; /* show visual mode later */
1812: updateline(); /* start the inversion */
1813: }
1814: }
1815: break;
1816:
1817: /*
1818: * 12. Suspend
1819: */
1820:
1821: case Ctrl('Z'):
1822: clearop();
1823: if (VIsual_active)
1824: end_visual_mode(); /* stop Visual */
1825: stuffReadbuff((char_u *)":st\r"); /* with autowrite */
1826: break;
1827:
1828: /*
1829: * 13. Window commands
1830: */
1831:
1832: case Ctrl('W'):
1833: if (checkclearop())
1834: break;
1835: do_window(nchar, Prenum); /* everything is in window.c */
1836: break;
1837:
1838: /*
1839: * 14. extended commands (starting with 'g')
1840: */
1841: case 'g':
1842: switch (nchar)
1843: {
1844: /*
1845: * "gv": reselect the previous visual area
1846: */
1847: case 'v':
1848: if (checkclearop())
1849: break;
1850: if (VIsual_active)
1851: pos = &VIsual_save;
1852: else
1853: pos = &VIsual;
1854: if (pos->lnum == 0 || pos->lnum > curbuf->b_ml.ml_line_count ||
1855: VIsual_end.lnum == 0)
1856: beep_flush();
1857: else
1858: {
1859: FPOS tt;
1860: int t;
1861:
1862: /* exchange previous and current visual area */
1863: if (VIsual_active)
1864: {
1865: tt = VIsual;
1866: VIsual = VIsual_save;
1867: VIsual_save = tt;
1868: t = VIsual_mode;
1869: VIsual_mode = VIsual_mode_save;
1870: VIsual_mode_save = t;
1871: tt = curwin->w_cursor;
1872: }
1873: curwin->w_cursor = VIsual_end;
1874: if (VIsual_active)
1875: VIsual_end = tt;
1876: check_cursor();
1877: VIsual_active = TRUE;
1878: #ifdef USE_MOUSE
1879: setmouse();
1880: #endif
1881: update_curbuf(NOT_VALID);
1882: showmode();
1883: }
1884: break;
1885:
1886: /*
1887: * "gj" and "gk" two new funny movement keys -- up and down
1888: * movement based on *screen* line rather than *file* line.
1889: */
1890: case 'j':
1891: case K_DOWN:
1892: if (!curwin->w_p_wrap)
1893: goto normal_j;
1894: if (screengo(FORWARD, Prenum1) == FAIL)
1895: clearopbeep();
1896: break;
1897:
1898: case 'k':
1899: case K_UP:
1900: if (!curwin->w_p_wrap)
1901: goto normal_k;
1902: if (screengo(BACKWARD, Prenum1) == FAIL)
1903: clearopbeep();
1904: break;
1905:
1906: /*
1907: * "g0", "g^" and "g$": Like "0", "^" and "$" but for screen lines.
1908: */
1909: case '^':
1910: flag = TRUE;
1911: /* FALLTHROUGH */
1912:
1913: case '0':
1914: case K_HOME:
1915: op_motion_type = MCHAR;
1916: op_inclusive = FALSE;
1917: if (curwin->w_p_wrap)
1918: {
1919: n = ((curwin->w_virtcol + (curwin->w_p_nu ? 8 : 0)) /
1920: Columns) * Columns;
1921: if (curwin->w_p_nu && n > 8)
1922: n -= 8;
1923: }
1924: else
1925: n = curwin->w_leftcol;
1926: coladvance((colnr_t)n);
1927: if (flag)
1928: while (vim_iswhite(gchar_cursor()) && oneright() == OK)
1929: ;
1930: curwin->w_set_curswant = TRUE;
1931: break;
1932:
1933: case '$':
1934: case K_END:
1935: op_motion_type = MCHAR;
1936: op_inclusive = TRUE;
1937: if (curwin->w_p_wrap)
1938: {
1939: curwin->w_curswant = MAXCOL; /* so we stay at the end */
1940: if (Prenum1 == 1)
1941: {
1942: n = ((curwin->w_virtcol + (curwin->w_p_nu ? 8 : 0)) /
1943: Columns + 1) * Columns - 1;
1944: if (curwin->w_p_nu && n > 8)
1945: n -= 8;
1946: coladvance((colnr_t)n);
1947: }
1948: else if (screengo(FORWARD, Prenum1 - 1) == FAIL)
1949: clearopbeep();
1950: }
1951: else
1952: {
1953: n = curwin->w_leftcol + Columns - 1;
1954: if (curwin->w_p_nu)
1955: n -= 8;
1956: coladvance((colnr_t)n);
1957: curwin->w_set_curswant = TRUE;
1958: }
1959: break;
1960:
1961: /*
1962: * "g*" and "g#", like "*" and "#" but without using "\<" and "\>"
1963: */
1964: case '*':
1965: case '#':
1966: goto search_word;
1967:
1968: /*
1969: * ge and gE: go back to end of word
1970: */
1971: case 'e':
1972: case 'E':
1973: op_motion_type = MCHAR;
1974: curwin->w_set_curswant = TRUE;
1975: op_inclusive = TRUE;
1976: if (bckend_word(Prenum1, nchar == 'E', FALSE) == FAIL)
1977: clearopbeep();
1978: break;
1979:
1980: /*
1981: * g CTRL-G: display info about cursor position
1982: */
1983: case Ctrl('G'):
1984: cursor_pos_info();
1985: break;
1986:
1987: /*
1988: * "gI": Start insert in column 1.
1989: */
1990: case 'I':
1991: beginline(FALSE);
1992: goto insert_command;
1993:
1994: /*
1995: * "gf": goto file, edit file under cursor
1996: * "]f" and "[f": can also be used.
1997: */
1998: case 'f':
1999: gotofile:
2000: ptr = file_name_at_cursor(FNAME_MESS|FNAME_HYP|FNAME_EXP);
2001: if (ptr != NULL)
2002: {
2003: /* do autowrite if necessary */
2004: if (curbuf->b_changed && curbuf->b_nwindows <= 1 && !p_hid)
2005: autowrite(curbuf);
2006: setpcmark();
2007: (void)do_ecmd(0, ptr, NULL, NULL, p_hid, (linenr_t)0,
2008: FALSE);
2009: vim_free(ptr);
2010: }
2011: else
2012: clearop();
2013: break;
2014:
2015: /*
2016: * "gs": Goto sleep, but keep on checking for CTRL-C
2017: */
2018: case 's':
2019: while (Prenum1-- && !got_int)
2020: {
2021: mch_delay(1000L, TRUE);
2022: mch_breakcheck();
2023: }
2024: break;
2025:
2026: /*
2027: * "ga": Display the ascii value of the character under the
2028: * cursor. It is displayed in decimal, hex, and octal. -- webb
2029: */
2030: case 'a':
2031: do_ascii();
2032: break;
2033:
2034: /*
2035: * "gg": Goto the first line in file. With a count it goes to
2036: * that line number like for G. -- webb
2037: */
2038: case 'g':
2039: goto_line_one:
2040: if (Prenum == 0)
2041: Prenum = 1;
2042: goto goto_line;
2043:
2044: /*
2045: * Operater to format text:
2046: * gq same as 'Q' operator.
2047: * Operators to change the case of text:
2048: * g~ Toggle the case of the text.
2049: * gu Change text to lower case.
2050: * gU Change text to upper case.
2051: * --webb
2052: */
2053: case 'q':
2054: case '~':
2055: case 'u':
2056: case 'U':
2057: prechar = c;
2058: c = nchar;
2059: goto dooperator;
2060:
2061: /*
2062: * "gd": Find first occurence of pattern under the cursor in the
2063: * current function
2064: * "gD": idem, but in the current file.
2065: */
2066: case 'd':
2067: case 'D':
2068: do_gd(nchar);
2069: break;
2070:
2071: #ifdef USE_MOUSE
2072: /*
2073: * g<*Mouse> : <C-*mouse>
2074: */
2075: case K_MIDDLEMOUSE:
2076: case K_MIDDLEDRAG:
2077: case K_MIDDLERELEASE:
2078: case K_LEFTMOUSE:
2079: case K_LEFTDRAG:
2080: case K_LEFTRELEASE:
2081: case K_RIGHTMOUSE:
2082: case K_RIGHTDRAG:
2083: case K_RIGHTRELEASE:
2084: mod_mask = MOD_MASK_CTRL;
2085: (void)do_mouse(nchar, BACKWARD, Prenum1, FALSE);
2086: break;
2087:
2088: case K_IGNORE:
2089: break;
2090: #endif
2091:
2092: default:
2093: clearopbeep();
2094: break;
2095: }
2096: break;
2097:
2098: /*
2099: * 15. mouse click
2100: */
2101: #ifdef USE_MOUSE
2102: case K_MIDDLEMOUSE:
2103: case K_MIDDLEDRAG:
2104: case K_MIDDLERELEASE:
2105: case K_LEFTMOUSE:
2106: case K_LEFTDRAG:
2107: case K_LEFTRELEASE:
2108: case K_RIGHTMOUSE:
2109: case K_RIGHTDRAG:
2110: case K_RIGHTRELEASE:
2111: (void)do_mouse(c, BACKWARD, Prenum1, FALSE);
2112: break;
2113:
2114: case K_IGNORE:
2115: break;
2116: #endif
2117:
2118: #ifdef USE_GUI
2119: /*
2120: * 16. scrollbar movement
2121: */
2122: case K_SCROLLBAR:
2123: if (op_type != NOP)
2124: clearopbeep();
2125:
2126: /* Even if an operator was pending, we still want to scroll */
2127: gui_do_scroll();
2128: break;
2129:
2130: case K_HORIZ_SCROLLBAR:
2131: if (op_type != NOP)
2132: clearopbeep();
2133:
2134: /* Even if an operator was pending, we still want to scroll */
2135: gui_do_horiz_scroll();
2136: break;
2137: #endif
2138:
2139: /*
2140: * 17. The end
2141: */
2142: case ESC:
2143: /* Don't drop through and beep if we are canceling a command: */
2144: if (!VIsual_active && (op_type != NOP ||
2145: opnum || Prenum || yankbuffer))
2146: {
2147: clearop(); /* don't beep */
2148: break;
2149: }
2150: if (VIsual_active)
2151: {
2152: end_visual_mode(); /* stop Visual */
2153: update_curbuf(NOT_VALID);
2154: clearop(); /* don't beep */
2155: break;
2156: }
2157: /* ESC in normal mode: beep, but don't flush buffers */
2158: clearop();
2159: vim_beep();
2160: break;
2161:
2162: default: /* not a known command */
2163: clearopbeep();
2164: break;
2165:
2166: } /* end of switch on command character */
2167:
2168: /*
2169: * if we didn't start or finish an operator, reset yankbuffer, unless we
2170: * need it later.
2171: */
2172: if (!finish_op && !op_type && vim_strchr((char_u *)"\"DCYSsXx.", c) == NULL)
2173: yankbuffer = 0;
2174:
2175: /*
2176: * If an operation is pending, handle it...
2177: */
2178: do_pending_operator(c, nchar, finish_op, searchbuff,
2179: &command_busy, old_col, FALSE, dont_adjust_op_end);
2180:
2181: normal_end:
2182: if (op_type == NOP && yankbuffer == 0)
2183: clear_showcmd();
2184:
2185: if (restart_edit && op_type == NOP && !VIsual_active
2186: && !command_busy && stuff_empty() && yankbuffer == 0)
2187: (void)edit(restart_edit, FALSE, 1L);
2188:
2189: checkpcmark(); /* check if we moved since setting pcmark */
2190: vim_free(searchbuff);
2191:
2192: /*
2193: * Update the other windows for the current buffer if modified has been set in
2194: * set_Changed() (This should be done more efficiently)
2195: */
2196: if (modified)
2197: {
2198: WIN *wp;
2199:
2200: for (wp = firstwin; wp; wp = wp->w_next)
2201: if (wp != curwin && wp->w_buffer == curbuf)
2202: {
2203: cursor_off();
2204: wp->w_redr_type = NOT_VALID;
2205: /*
2206: * don't do the actual redraw if wait_return() has just been
2207: * called and the user typed a ":"
2208: */
2209: if (!skip_redraw)
2210: win_update(wp);
2211: }
2212: modified = FALSE;
2213: }
2214: }
2215:
2216: /*
2217: * Handle an operator after visual mode or when the movement is finished
2218: */
2219: void
2220: do_pending_operator(c, nchar, finish_op, searchbuff, command_busy,
2221: old_col, gui_yank, dont_adjust_op_end)
2222: register int c;
2223: int nchar;
2224: int finish_op;
2225: char_u *searchbuff;
2226: int *command_busy;
2227: int old_col;
2228: int gui_yank; /* yanking visual area for GUI */
2229: int dont_adjust_op_end;
2230: {
2231: /* The visual area is remembered for redo */
2232: static int redo_VIsual_mode = NUL; /* 'v', 'V', or Ctrl-V */
2233: static linenr_t redo_VIsual_line_count; /* number of lines */
2234: static colnr_t redo_VIsual_col; /* number of cols or end column */
2235: static long redo_VIsual_Prenum; /* Prenum for operator */
2236:
2237: linenr_t Prenum1 = 1L;
2238: FPOS old_cursor;
2239: int VIsual_was_active = VIsual_active;
2240: int redraw;
2241:
2242: #ifdef USE_GUI
2243: /*
2244: * Yank the visual area into the GUI selection register before we operate
2245: * on it and lose it forever. This could call do_pending_operator()
2246: * recursively, but that's OK because gui_yank will be TRUE for the
2247: * nested call. Note also that we call gui_copy_selection() and not
2248: * gui_auto_select(). This is because even when 'autoselect' is not set,
2249: * if we operate on the text, eg by deleting it, then this is considered to
2250: * be an explicit request for it to be put in the global cut buffer, so we
2251: * always want to do it here. -- webb
2252: */
2253: if (gui.in_use && op_type != NOP && !gui_yank && VIsual_active
2254: && !redo_VIsual_busy)
2255: gui_copy_selection();
2256: #endif
2257: old_cursor = curwin->w_cursor;
2258:
2259: /*
2260: * If an operation is pending, handle it...
2261: */
2262: if ((VIsual_active || finish_op) && op_type != NOP)
2263: {
2264: op_is_VIsual = VIsual_active;
2265: if (op_type != YANK && !VIsual_active) /* can't redo yank */
2266: {
2267: prep_redo(Prenum, prechar, opchars[op_type - 1], c, nchar);
2268: if (c == '/' || c == '?') /* was a search */
2269: {
2270: /*
2271: * If 'cpoptions' does not contain 'r', insert the search
2272: * pattern to really repeat the same command.
2273: */
2274: if (vim_strchr(p_cpo, CPO_REDO) == NULL)
2275: AppendToRedobuff(searchbuff);
2276: AppendToRedobuff(NL_STR);
2277: }
2278: }
2279:
2280: if (redo_VIsual_busy)
2281: {
2282: curbuf->b_op_start = curwin->w_cursor;
2283: curwin->w_cursor.lnum += redo_VIsual_line_count - 1;
2284: if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
2285: curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
2286: VIsual_mode = redo_VIsual_mode;
2287: if (VIsual_mode == 'v')
2288: {
2289: if (redo_VIsual_line_count <= 1)
2290: curwin->w_cursor.col += redo_VIsual_col - 1;
2291: else
2292: curwin->w_cursor.col = redo_VIsual_col;
2293: }
2294: if (redo_VIsual_col == MAXCOL)
2295: {
2296: curwin->w_curswant = MAXCOL;
2297: coladvance(MAXCOL);
2298: }
2299: Prenum = redo_VIsual_Prenum;
2300: }
2301: else if (VIsual_active)
2302: {
2303: curbuf->b_op_start = VIsual;
2304: VIsual_end = curwin->w_cursor;
2305: if (VIsual_mode == 'V')
2306: curbuf->b_op_start.col = 0;
2307: }
2308:
2309: if (lt(curbuf->b_op_start, curwin->w_cursor))
2310: {
2311: curbuf->b_op_end = curwin->w_cursor;
2312: curwin->w_cursor = curbuf->b_op_start;
2313: }
2314: else
2315: {
2316: curbuf->b_op_end = curbuf->b_op_start;
2317: curbuf->b_op_start = curwin->w_cursor;
2318: }
2319: op_line_count = curbuf->b_op_end.lnum - curbuf->b_op_start.lnum + 1;
2320:
2321: if (VIsual_active || redo_VIsual_busy)
2322: {
2323: if (VIsual_mode == Ctrl('V')) /* block mode */
2324: {
2325: colnr_t start, end;
2326:
2327: op_block_mode = TRUE;
2328: getvcol(curwin, &(curbuf->b_op_start),
2329: &op_start_vcol, NULL, &op_end_vcol);
2330: if (!redo_VIsual_busy)
2331: {
2332: getvcol(curwin, &(curbuf->b_op_end), &start, NULL, &end);
2333: if (start < op_start_vcol)
2334: op_start_vcol = start;
2335: if (end > op_end_vcol)
2336: op_end_vcol = end;
2337: }
2338:
2339: /* if '$' was used, get op_end_vcol from longest line */
2340: if (curwin->w_curswant == MAXCOL)
2341: {
2342: curwin->w_cursor.col = MAXCOL;
2343: op_end_vcol = 0;
2344: for (curwin->w_cursor.lnum = curbuf->b_op_start.lnum;
2345: curwin->w_cursor.lnum <= curbuf->b_op_end.lnum;
2346: ++curwin->w_cursor.lnum)
2347: {
2348: getvcol(curwin, &curwin->w_cursor, NULL, NULL, &end);
2349: if (end > op_end_vcol)
2350: op_end_vcol = end;
2351: }
2352: curwin->w_cursor = curbuf->b_op_start;
2353: }
2354: else if (redo_VIsual_busy)
2355: op_end_vcol = op_start_vcol + redo_VIsual_col - 1;
2356: coladvance(op_start_vcol);
2357: }
2358:
2359: if (!redo_VIsual_busy)
2360: {
2361: /*
2362: * Prepare to reselect and redo Visual: this is based on the
2363: * size of the Visual text
2364: */
2365: resel_VIsual_mode = VIsual_mode;
2366: if (curwin->w_curswant == MAXCOL)
2367: resel_VIsual_col = MAXCOL;
2368: else if (VIsual_mode == Ctrl('V'))
2369: resel_VIsual_col = op_end_vcol - op_start_vcol + 1;
2370: else if (op_line_count > 1)
2371: resel_VIsual_col = curbuf->b_op_end.col;
2372: else
2373: resel_VIsual_col = curbuf->b_op_end.col -
2374: curbuf->b_op_start.col + 1;
2375: resel_VIsual_line_count = op_line_count;
2376: }
2377: /* can't redo yank and : */
2378: if (op_type != YANK && op_type != COLON)
2379: {
2380: prep_redo(0L, NUL, 'v', prechar, opchars[op_type - 1]);
2381: redo_VIsual_mode = resel_VIsual_mode;
2382: redo_VIsual_col = resel_VIsual_col;
2383: redo_VIsual_line_count = resel_VIsual_line_count;
2384: redo_VIsual_Prenum = Prenum;
2385: }
2386:
2387: /*
2388: * Mincl defaults to TRUE.
2389: * If op_end is on a NUL (empty line) op_inclusive becomes FALSE
2390: * This makes "d}P" and "v}dP" work the same.
2391: */
2392: op_inclusive = TRUE;
2393: if (VIsual_mode == 'V')
2394: op_motion_type = MLINE;
2395: else
2396: {
2397: op_motion_type = MCHAR;
2398: if (*ml_get_pos(&(curbuf->b_op_end)) == NUL)
2399: op_inclusive = FALSE;
2400: }
2401:
2402: redo_VIsual_busy = FALSE;
2403: /*
2404: * Switch Visual off now, so screen updating does
2405: * not show inverted text when the screen is redrawn.
2406: * With YANK and sometimes with COLON and FILTER there is no screen
2407: * redraw, so it is done here to remove the inverted part.
2408: */
2409: if (!gui_yank)
2410: {
2411: VIsual_active = FALSE;
2412: #ifdef USE_MOUSE
2413: setmouse();
2414: #endif
2415: if (p_smd)
2416: clear_cmdline = TRUE; /* unshow visual mode later */
2417: if (op_type == YANK || op_type == COLON || op_type == FILTER)
2418: update_curbuf(NOT_VALID);
2419: }
2420:
2421: /* set Prenum1 for LSHIFT and RSHIFT, e.g. "V3j2>" */
2422: if (Prenum == 0)
2423: Prenum1 = 1L;
2424: else
2425: Prenum1 = Prenum;
2426: }
2427:
2428: curwin->w_set_curswant = TRUE;
2429:
2430: /* op_empty is set when start and end are the same */
2431: op_empty = (op_motion_type == MCHAR && !op_inclusive &&
2432: equal(curbuf->b_op_start, curbuf->b_op_end));
2433:
2434: /*
2435: * If the end of an operator is in column one while op_motion_type is
2436: * MCHAR and op_inclusive is FALSE, we put op_end after the last character
2437: * in the previous line. If op_start is on or before the first non-blank
2438: * in the line, the operator becomes linewise (strange, but that's the way
2439: * vi does it).
2440: */
2441: if (op_motion_type == MCHAR && op_inclusive == FALSE &&
2442: !dont_adjust_op_end && curbuf->b_op_end.col == 0 &&
2443: op_line_count > 1)
2444: {
2445: op_end_adjusted = TRUE; /* remember that we did this */
2446: --op_line_count;
2447: --curbuf->b_op_end.lnum;
2448: if (inindent(0))
2449: op_motion_type = MLINE;
2450: else
2451: {
2452: curbuf->b_op_end.col = STRLEN(ml_get(curbuf->b_op_end.lnum));
2453: if (curbuf->b_op_end.col)
2454: {
2455: --curbuf->b_op_end.col;
2456: op_inclusive = TRUE;
2457: }
2458: }
2459: }
2460: else
2461: op_end_adjusted = FALSE;
2462: switch (op_type)
2463: {
2464: case LSHIFT:
2465: case RSHIFT:
2466: do_shift(op_type, TRUE, (int)Prenum1);
2467: break;
2468:
2469: case JOIN:
2470: if (op_line_count < 2)
2471: op_line_count = 2;
2472: if (curwin->w_cursor.lnum + op_line_count - 1 >
2473: curbuf->b_ml.ml_line_count)
2474: beep_flush();
2475: else
2476: {
2477: /*
2478: * If the cursor position has been changed, recompute the
2479: * current cursor position in the window. If it's not visible,
2480: * don't keep the window updated when joining the lines.
2481: */
2482: if (old_cursor.lnum != curwin->w_cursor.lnum ||
2483: old_cursor.col != curwin->w_cursor.col)
2484: redraw = (curs_rows() == OK);
2485: else
2486: redraw = TRUE;
2487: do_do_join(op_line_count, TRUE, redraw);
2488: }
2489: break;
2490:
2491: case DELETE:
2492: if (!op_empty)
2493: do_delete();
2494: break;
2495:
2496: case YANK:
2497: if (!op_empty)
2498: (void)do_yank(FALSE, !gui_yank);
2499: break;
2500:
2501: case CHANGE:
2502: *command_busy = do_change(); /* will set op_type to NOP */
2503: break;
2504:
2505: case FILTER:
2506: if (vim_strchr(p_cpo, CPO_FILTER) != NULL)
2507: AppendToRedobuff((char_u *)"!\r"); /* use any last used !cmd */
2508: else
2509: bangredo = TRUE; /* do_bang() will put cmd in redo buffer */
2510:
2511: case INDENT:
2512: case COLON:
2513:
2514: #if defined(LISPINDENT) || defined(CINDENT)
2515: /*
2516: * If 'equalprg' is empty, do the indenting internally.
2517: */
2518: if (op_type == INDENT && *p_ep == NUL)
2519: {
2520: # ifdef LISPINDENT
2521: if (curbuf->b_p_lisp)
2522: {
2523: do_reindent(get_lisp_indent);
2524: break;
2525: }
2526: # endif
2527: # ifdef CINDENT
2528: do_reindent(get_c_indent);
2529: break;
2530: # endif
2531: }
2532: #endif /* defined(LISPINDENT) || defined(CINDENT) */
2533:
2534: dofilter:
2535: if (VIsual_was_active)
2536: sprintf((char *)IObuff, ":'<,'>");
2537: else
2538: sprintf((char *)IObuff, ":%ld,%ld",
2539: (long)curbuf->b_op_start.lnum,
2540: (long)curbuf->b_op_end.lnum);
2541: stuffReadbuff(IObuff);
2542: if (op_type != COLON)
2543: stuffReadbuff((char_u *)"!");
2544: if (op_type == INDENT)
2545: {
2546: #ifndef CINDENT
2547: if (*p_ep == NUL)
2548: stuffReadbuff((char_u *)"indent");
2549: else
2550: #endif
2551: stuffReadbuff(p_ep);
2552: stuffReadbuff((char_u *)"\n");
2553: }
2554: else if (op_type == FORMAT || op_type == GFORMAT)
2555: {
2556: if (*p_fp == NUL)
2557: stuffReadbuff((char_u *)"fmt");
2558: else
2559: stuffReadbuff(p_fp);
2560: stuffReadbuff((char_u *)"\n");
2561: }
2562: /* do_cmdline() does the rest */
2563: break;
2564:
2565: case TILDE:
2566: case UPPER:
2567: case LOWER:
2568: if (!op_empty)
2569: do_tilde();
2570: break;
2571:
2572: case FORMAT:
2573: case GFORMAT:
2574: if (*p_fp != NUL)
2575: goto dofilter; /* use external command */
2576: do_format(); /* use internal function */
2577: break;
2578:
2579: default:
2580: clearopbeep();
2581: }
2582: prechar = NUL;
2583: if (!gui_yank)
2584: {
2585: /*
2586: * if 'sol' not set, go back to old column for some commands
2587: */
2588: if (!p_sol && op_motion_type == MLINE && (op_type == LSHIFT ||
2589: op_type == RSHIFT || op_type == DELETE))
2590: coladvance(curwin->w_curswant = old_col);
2591: op_type = NOP;
2592: }
2593: else
2594: curwin->w_cursor = old_cursor;
2595: op_block_mode = FALSE;
2596: yankbuffer = 0;
2597: }
2598: }
2599:
2600: #ifdef USE_MOUSE
2601: /*
2602: * Do the appropriate action for the current mouse click in the current mode.
2603: *
2604: * Normal Mode:
2605: * event modi- position visual change action
2606: * fier cursor window
2607: * left press - yes end yes
2608: * left press C yes end yes "^]" (2)
2609: * left press S yes end yes "*" (2)
2610: * left drag - yes start if moved no
2611: * left relse - yes start if moved no
2612: * middle press - yes if not active no put register
2613: * middle press - yes if active no yank and put
2614: * right press - yes start or extend yes
2615: * right press S yes no change yes "#" (2)
2616: * right drag - yes extend no
2617: * right relse - yes extend no
2618: *
2619: * Insert or Replace Mode:
2620: * event modi- position visual change action
2621: * fier cursor window
2622: * left press - yes (cannot be active) yes
2623: * left press C yes (cannot be active) yes "CTRL-O^]" (2)
2624: * left press S yes (cannot be active) yes "CTRL-O*" (2)
2625: * left drag - yes start or extend (1) no CTRL-O (1)
2626: * left relse - yes start or extend (1) no CTRL-O (1)
2627: * middle press - no (cannot be active) no put register
2628: * right press - yes start or extend yes CTRL-O
2629: * right press S yes (cannot be active) yes "CTRL-O#" (2)
2630: *
2631: * (1) only if mouse pointer moved since press
2632: * (2) only if click is in same buffer
2633: *
2634: * Return TRUE if start_arrow() should be called for edit mode.
2635: */
2636: int
2637: do_mouse(c, dir, count, fix_indent)
2638: int c; /* K_LEFTMOUSE, etc */
2639: int dir; /* Direction to 'put' if necessary */
2640: long count;
2641: int fix_indent; /* Do we fix indent for 'put' if necessary? */
2642: {
2643: static int ignore_drag_release = FALSE;
2644: static FPOS orig_cursor;
2645: static int do_always = FALSE; /* ignore 'mouse' setting next time */
2646: static int got_click = FALSE; /* got a click some time back */
2647:
2648: int which_button; /* MOUSE_LEFT, _MIDDLE or _RIGHT */
2649: int is_click; /* If FALSE it's a drag or release event */
2650: int is_drag; /* If TRUE it's a drag event */
2651: int jump_flags = 0; /* flags for jump_to_mouse() */
2652: FPOS start_visual;
2653: FPOS end_visual;
2654: BUF *save_buffer;
2655: int diff;
2656: int moved; /* Has cursor moved? */
2657: int c1, c2;
2658: int VIsual_was_active = VIsual_active;
2659:
2660: /*
2661: * When GUI is active, always recognize mouse events, otherwise:
2662: * - Ignore mouse event in normal mode if 'mouse' doesn't include 'n'.
2663: * - Ignore mouse event in visual mode if 'mouse' doesn't include 'v'.
2664: * - For command line and insert mode 'mouse' is checked before calling
2665: * do_mouse().
2666: */
2667: if (do_always)
2668: do_always = FALSE;
2669: else
2670: #ifdef USE_GUI
2671: if (!gui.in_use)
2672: #endif
2673: {
2674: if (VIsual_active)
2675: {
2676: if (!mouse_has(MOUSE_VISUAL))
2677: return FALSE;
2678: }
2679: else if (State == NORMAL && !mouse_has(MOUSE_NORMAL))
2680: return FALSE;
2681: }
2682:
2683: which_button = get_mouse_button(KEY2TERMCAP1(c), &is_click, &is_drag);
2684:
2685: /*
2686: * Ignore drag and release events if we didn't get a click.
2687: */
2688: if (is_click)
2689: got_click = TRUE;
2690: else
2691: {
2692: if (!got_click) /* didn't get click, ignore */
2693: return FALSE;
2694: if (!is_drag) /* release, reset got_click */
2695: got_click = FALSE;
2696: }
2697:
2698: /*
2699: * ALT is currently ignored
2700: */
2701: if ((mod_mask & MOD_MASK_ALT))
2702: return FALSE;
2703:
2704: /*
2705: * CTRL right mouse button does CTRL-T
2706: */
2707: if (is_click && (mod_mask & MOD_MASK_CTRL) && which_button == MOUSE_RIGHT)
2708: {
2709: if (State & INSERT)
2710: stuffcharReadbuff(Ctrl('O'));
2711: stuffcharReadbuff(Ctrl('T'));
2712: got_click = FALSE; /* ignore drag&release now */
2713: return FALSE;
2714: }
2715:
2716: /*
2717: * CTRL only works with left mouse button
2718: */
2719: if ((mod_mask & MOD_MASK_CTRL) && which_button != MOUSE_LEFT)
2720: return FALSE;
2721:
2722: /*
2723: * When a modifier is down, ignore drag and release events, as well as
2724: * multiple clicks and the middle mouse button.
2725: */
2726: if ((mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL | MOD_MASK_ALT)) &&
2727: (!is_click || (mod_mask & MOD_MASK_MULTI_CLICK) ||
2728: which_button == MOUSE_MIDDLE))
2729: return FALSE;
2730:
2731: /*
2732: * If the button press was used as the movement command for an operator
2733: * (eg "d<MOUSE>"), or it is the middle button that is held down, ignore
2734: * drag/release events.
2735: */
2736: if (!is_click && (ignore_drag_release || which_button == MOUSE_MIDDLE))
2737: return FALSE;
2738:
2739: /*
2740: * Middle mouse button does a 'put' of the selected text
2741: */
2742: if (which_button == MOUSE_MIDDLE)
2743: {
2744: if (State == NORMAL)
2745: {
2746: /*
2747: * If an operator was pending, we don't know what the user wanted
2748: * to do. Go back to normal mode: Clear the operator and beep().
2749: */
2750: if (op_type != NOP)
2751: {
2752: clearopbeep();
2753: return FALSE;
2754: }
2755:
2756: /*
2757: * If visual was active, yank the highlighted text and put it
2758: * before the mouse pointer position.
2759: */
2760: if (VIsual_active)
2761: {
2762: stuffcharReadbuff('y');
2763: stuffcharReadbuff(K_MIDDLEMOUSE);
2764: do_always = TRUE; /* ignore 'mouse' setting next time */
2765: return FALSE;
2766: }
2767: /*
2768: * The rest is below jump_to_mouse()
2769: */
2770: }
2771:
2772: /*
2773: * Middle click in insert mode doesn't move the mouse, just insert the
2774: * contents of a register. '.' register is special, can't insert that
2775: * with do_put().
2776: */
2777: else if (State & INSERT)
2778: {
2779: if (yankbuffer == '.')
2780: insertbuf(yankbuffer);
2781: else
2782: {
2783: #ifdef USE_GUI
2784: if (gui.in_use && yankbuffer == 0)
2785: yankbuffer = '*';
2786: #endif
2787: do_put(BACKWARD, 1L, fix_indent);
2788:
2789: /* Put cursor after the end of the just pasted text. */
2790: curwin->w_cursor = curbuf->b_op_end;
2791: if (gchar_cursor() != NUL)
2792: ++curwin->w_cursor.col;
2793:
2794: /* Repeat it with CTRL-R x, not exactly the same, but mostly
2795: * works fine. */
2796: AppendCharToRedobuff(Ctrl('R'));
2797: if (yankbuffer == 0)
2798: AppendCharToRedobuff('"');
2799: else
2800: AppendCharToRedobuff(yankbuffer);
2801: }
2802: return FALSE;
2803: }
2804: else
2805: return FALSE;
2806: }
2807:
2808: if (!is_click)
2809: jump_flags |= MOUSE_FOCUS;
2810:
2811: start_visual.lnum = 0;
2812:
2813: if ((State & (NORMAL | INSERT)) &&
2814: !(mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)))
2815: {
2816: if (which_button == MOUSE_LEFT)
2817: {
2818: if (is_click)
2819: {
2820: if (VIsual_active)
2821: {
2822: end_visual_mode();
2823: update_curbuf(NOT_VALID);
2824: }
2825: }
2826: else
2827: jump_flags |= MOUSE_MAY_VIS;
2828: }
2829: else if (which_button == MOUSE_RIGHT)
2830: {
2831: if (is_click && VIsual_active)
2832: {
2833: /*
2834: * Remember the start and end of visual before moving the
2835: * cursor.
2836: */
2837: if (lt(curwin->w_cursor, VIsual))
2838: {
2839: start_visual = curwin->w_cursor;
2840: end_visual = VIsual;
2841: }
2842: else
2843: {
2844: start_visual = VIsual;
2845: end_visual = curwin->w_cursor;
2846: }
2847: }
2848: jump_flags |= MOUSE_MAY_VIS;
2849: }
2850: }
2851:
2852: if (!is_drag)
2853: {
2854: /*
2855: * If an operator is pending, ignore all drags and releases until the
2856: * next mouse click.
2857: */
2858: ignore_drag_release = (op_type != NOP);
2859: }
2860:
2861: /*
2862: * Jump!
2863: */
2864: if (!is_click)
2865: jump_flags |= MOUSE_DID_MOVE;
2866: save_buffer = curbuf;
2867: moved = (jump_to_mouse(jump_flags) & CURSOR_MOVED);
2868:
2869: /* When jumping to another buffer, stop visual mode */
2870: if (curbuf != save_buffer && VIsual_active)
2871: {
2872: end_visual_mode();
2873: update_curbuf(NOT_VALID); /* delete the inversion */
2874: }
2875: else if (start_visual.lnum) /* right click in visual mode */
2876: {
2877: /*
2878: * If the click is before the start of visual, change the start. If
2879: * the click is after the end of visual, change the end. If the click
2880: * is inside the visual, change the closest side.
2881: */
2882: if (lt(curwin->w_cursor, start_visual))
2883: VIsual = end_visual;
2884: else if (lt(end_visual, curwin->w_cursor))
2885: VIsual = start_visual;
2886: else
2887: {
2888: /* In the same line, compare column number */
2889: if (end_visual.lnum == start_visual.lnum)
2890: {
2891: if (curwin->w_cursor.col - start_visual.col >
2892: end_visual.col - curwin->w_cursor.col)
2893: VIsual = start_visual;
2894: else
2895: VIsual = end_visual;
2896: }
2897:
2898: /* In different lines, compare line number */
2899: else
2900: {
2901: diff = (curwin->w_cursor.lnum - start_visual.lnum) -
2902: (end_visual.lnum - curwin->w_cursor.lnum);
2903:
2904: if (diff > 0) /* closest to end */
2905: VIsual = start_visual;
2906: else if (diff < 0) /* closest to start */
2907: VIsual = end_visual;
2908: else /* in the middle line */
2909: {
2910: if (curwin->w_cursor.col <
2911: (start_visual.col + end_visual.col) / 2)
2912: VIsual = end_visual;
2913: else
2914: VIsual = start_visual;
2915: }
2916: }
2917: }
2918: }
2919: /*
2920: * If Visual mode started in insert mode, execute "CTRL-O"
2921: */
2922: else if ((State & INSERT) && VIsual_active)
2923: stuffcharReadbuff(Ctrl('O'));
2924: /*
2925: * If cursor has moved, need to update Cline_row
2926: */
2927: else if (moved)
2928: cursupdate();
2929:
2930: /*
2931: * Middle mouse click: Put text before cursor.
2932: */
2933: if (which_button == MOUSE_MIDDLE)
2934: {
2935: #ifdef USE_GUI
2936: if (gui.in_use && yankbuffer == 0)
2937: yankbuffer = '*';
2938: #endif
2939: if (yank_buffer_mline())
2940: {
2941: if (mouse_past_bottom)
2942: dir = FORWARD;
2943: }
2944: else if (mouse_past_eol)
2945: dir = FORWARD;
2946:
2947: if (fix_indent)
2948: {
2949: c1 = (dir == BACKWARD) ? '[' : ']';
2950: c2 = 'p';
2951: }
2952: else
2953: {
2954: c1 = (dir == FORWARD) ? 'p' : 'P';
2955: c2 = NUL;
2956: }
2957: prep_redo(Prenum, NUL, c1, c2, NUL);
2958: /*
2959: * Remember where the paste started, so in edit() Insstart can be set
2960: * to this position
2961: */
2962: if (restart_edit)
2963: where_paste_started = curwin->w_cursor;
2964: do_put(dir, count, fix_indent);
2965:
2966: /* Put cursor at the end of the just pasted text. */
2967: curwin->w_cursor = curbuf->b_op_end;
2968: if (restart_edit && gchar_cursor() != NUL)
2969: ++curwin->w_cursor.col; /* put cursor after the text */
2970: }
2971:
2972: /*
2973: * Ctrl-Mouse click jumps to the tag under the mouse pointer
2974: */
2975: else if ((mod_mask & MOD_MASK_CTRL))
2976: {
2977: if (State & INSERT)
2978: stuffcharReadbuff(Ctrl('O'));
2979: stuffcharReadbuff(Ctrl(']'));
2980: ignore_drag_release = TRUE; /* ignore drag and release now */
2981: }
2982:
2983: /*
2984: * Shift-Mouse click searches for the next occurrence of the word under
2985: * the mouse pointer
2986: */
2987: else if ((mod_mask & MOD_MASK_SHIFT))
2988: {
2989: if (State & INSERT)
2990: stuffcharReadbuff(Ctrl('O'));
2991: if (which_button == MOUSE_LEFT)
2992: stuffcharReadbuff('*');
2993: else /* MOUSE_RIGHT */
2994: stuffcharReadbuff('#');
2995: }
2996:
2997: /* Handle double clicks */
2998: else if ((mod_mask & MOD_MASK_MULTI_CLICK) && (State & (NORMAL | INSERT)))
2999: {
3000: if (is_click || !VIsual_active)
3001: {
3002: if (VIsual_active)
3003: orig_cursor = VIsual;
3004: else
3005: {
3006: start_visual_highlight();
3007: VIsual = curwin->w_cursor;
3008: orig_cursor = VIsual;
3009: VIsual_active = TRUE;
3010: #ifdef USE_MOUSE
3011: setmouse();
3012: #endif
3013: if (p_smd)
3014: redraw_cmdline = TRUE; /* show visual mode later */
3015: }
3016: if (mod_mask & MOD_MASK_2CLICK)
3017: VIsual_mode = 'v';
3018: else if (mod_mask & MOD_MASK_3CLICK)
3019: VIsual_mode = 'V';
3020: else if (mod_mask & MOD_MASK_4CLICK)
3021: VIsual_mode = Ctrl('V');
3022: }
3023: if (mod_mask & MOD_MASK_2CLICK)
3024: {
3025: if (lt(curwin->w_cursor, orig_cursor))
3026: {
3027: find_start_of_word(&curwin->w_cursor);
3028: find_end_of_word(&VIsual);
3029: }
3030: else
3031: {
3032: find_start_of_word(&VIsual);
3033: find_end_of_word(&curwin->w_cursor);
3034: }
3035: curwin->w_set_curswant = TRUE;
3036: }
3037: if (is_click)
3038: {
3039: curs_columns(TRUE); /* recompute w_virtcol */
3040: update_curbuf(NOT_VALID); /* update the inversion */
3041: }
3042: }
3043: else if (VIsual_active && VIsual_was_active != VIsual_active)
3044: VIsual_mode = 'v';
3045:
3046: return moved;
3047: }
3048:
3049: static void
3050: find_start_of_word(pos)
3051: FPOS *pos;
3052: {
3053: char_u *ptr;
3054: int cclass;
3055:
3056: ptr = ml_get(pos->lnum);
3057: cclass = get_mouse_class(ptr[pos->col]);
3058:
3059: /* Can't test pos->col >= 0 because pos->col is unsigned */
3060: while (pos->col > 0 && get_mouse_class(ptr[pos->col]) == cclass)
3061: pos->col--;
3062: if (pos->col != 0 || get_mouse_class(ptr[0]) != cclass)
3063: pos->col++;
3064: }
3065:
3066: static void
3067: find_end_of_word(pos)
3068: FPOS *pos;
3069: {
3070: char_u *ptr;
3071: int cclass;
3072:
3073: ptr = ml_get(pos->lnum);
3074: cclass = get_mouse_class(ptr[pos->col]);
3075: while (ptr[pos->col] && get_mouse_class(ptr[pos->col]) == cclass)
3076: pos->col++;
3077: pos->col--;
3078: }
3079:
3080: static int
3081: get_mouse_class(c)
3082: int c;
3083: {
3084: if (c == ' ' || c == '\t')
3085: return ' ';
3086:
3087: if (isidchar(c))
3088: return 'a';
3089:
3090: /*
3091: * There are a few special cases where we want certain combinations of
3092: * characters to be considered as a single word. These are things like
3093: * "->", "/ *", "*=", "+=", "&=", "<=", ">=", "!=" etc. Otherwise, each
3094: * character is in it's own class.
3095: */
3096: if (c != NUL && vim_strchr((char_u *)"-+*/%<>&|^!=", c) != NULL)
3097: return '=';
3098: return c;
3099: }
3100: #endif /* USE_MOUSE */
3101:
3102: /*
3103: * start highlighting for visual mode
3104: */
3105: void
3106: start_visual_highlight()
3107: {
3108: static int didwarn = FALSE; /* warned for broken inversion */
3109:
3110: if (!didwarn && set_highlight('v') == FAIL)/* cannot highlight */
3111: {
3112: EMSG("Warning: terminal cannot highlight");
3113: didwarn = TRUE;
3114: }
3115: }
3116:
3117: /*
3118: * End visual mode. If we are using the GUI, and autoselect is set, then
3119: * remember what was selected in case we need to paste it somewhere while we
3120: * still own the selection. This function should ALWAYS be called to end
3121: * visual mode.
3122: */
3123: void
3124: end_visual_mode()
3125: {
3126: #ifdef USE_GUI
3127: if (gui.in_use)
3128: gui_auto_select();
3129: #endif
3130: VIsual_active = FALSE;
3131: #ifdef USE_MOUSE
3132: setmouse();
3133: #endif
3134: VIsual_end = curwin->w_cursor; /* remember for '> mark */
3135: if (p_smd)
3136: clear_cmdline = TRUE; /* unshow visual mode later */
3137: }
3138:
3139: /*
3140: * Find the identifier under or to the right of the cursor. If none is
3141: * found and find_type has FIND_STRING, then find any non-white string. The
3142: * length of the string is returned, or zero if no string is found. If a
3143: * string is found, a pointer to the string is put in *string, but note that
3144: * the caller must use the length returned as this string may not be NUL
3145: * terminated.
3146: */
3147: int
3148: find_ident_under_cursor(string, find_type)
3149: char_u **string;
3150: int find_type;
3151: {
3152: char_u *ptr;
3153: int col = 0; /* init to shut up GCC */
3154: int i;
3155:
3156: /*
3157: * if i == 0: try to find an identifier
3158: * if i == 1: try to find any string
3159: */
3160: ptr = ml_get_curline();
3161: for (i = (find_type & FIND_IDENT) ? 0 : 1; i < 2; ++i)
3162: {
3163: /*
3164: * skip to start of identifier/string
3165: */
3166: col = curwin->w_cursor.col;
3167: while (ptr[col] != NUL &&
3168: (i == 0 ? !iswordchar(ptr[col]) : vim_iswhite(ptr[col])))
3169: ++col;
3170:
3171: /*
3172: * Back up to start of identifier/string. This doesn't match the
3173: * real vi but I like it a little better and it shouldn't bother
3174: * anyone.
3175: * When FIND_IDENT isn't defined, we backup until a blank.
3176: */
3177: while (col > 0 && (i == 0 ? iswordchar(ptr[col - 1]) :
3178: (!vim_iswhite(ptr[col - 1]) &&
3179: (!(find_type & FIND_IDENT) || !iswordchar(ptr[col - 1])))))
3180: --col;
3181:
3182: /*
3183: * if we don't want just any old string, or we've found an identifier,
3184: * stop searching.
3185: */
3186: if (!(find_type & FIND_STRING) || iswordchar(ptr[col]))
3187: break;
3188: }
3189: /*
3190: * didn't find an identifier or string
3191: */
3192: if (ptr[col] == NUL || (!iswordchar(ptr[col]) && i == 0))
3193: {
3194: if (find_type & FIND_STRING)
3195: EMSG("No string under cursor");
3196: else
3197: EMSG("No identifier under cursor");
3198: return 0;
3199: }
3200: ptr += col;
3201: *string = ptr;
3202: col = 0;
3203: while (i == 0 ? iswordchar(*ptr) : (*ptr != NUL && !vim_iswhite(*ptr)))
3204: {
3205: ++ptr;
3206: ++col;
3207: }
3208: return col;
3209: }
3210:
3211: static void
3212: prep_redo(num, pre_char, cmd, c, nchar)
3213: long num;
3214: int pre_char;
3215: int cmd;
3216: int c;
3217: int nchar;
3218: {
3219: ResetRedobuff();
3220: if (yankbuffer != 0) /* yank from specified buffer */
3221: {
3222: AppendCharToRedobuff('\"');
3223: AppendCharToRedobuff(yankbuffer);
3224: }
3225: if (num)
3226: AppendNumberToRedobuff(num);
3227: if (pre_char != NUL)
3228: AppendCharToRedobuff(pre_char);
3229: AppendCharToRedobuff(cmd);
3230: if (c != NUL)
3231: AppendCharToRedobuff(c);
3232: if (nchar != NUL)
3233: AppendCharToRedobuff(nchar);
3234: }
3235:
3236: /*
3237: * check for operator active and clear it
3238: *
3239: * return TRUE if operator was active
3240: */
3241: static int
3242: checkclearop()
3243: {
3244: if (op_type == NOP)
3245: return (FALSE);
3246: clearopbeep();
3247: return (TRUE);
3248: }
3249:
3250: /*
3251: * check for operator or Visual active and clear it
3252: *
3253: * return TRUE if operator was active
3254: */
3255: static int
3256: checkclearopq()
3257: {
3258: if (op_type == NOP && !VIsual_active)
3259: return (FALSE);
3260: clearopbeep();
3261: return (TRUE);
3262: }
3263:
3264: static void
3265: clearop()
3266: {
3267: op_type = NOP;
3268: yankbuffer = 0;
3269: prechar = NUL;
3270: }
3271:
3272: static void
3273: clearopbeep()
3274: {
3275: clearop();
3276: beep_flush();
3277: }
3278:
3279: /*
3280: * Routines for displaying a partly typed command
3281: */
3282:
3283: static char_u showcmd_buf[SHOWCMD_COLS + 1];
3284: static char_u old_showcmd_buf[SHOWCMD_COLS + 1]; /* For push_showcmd() */
3285: static int is_showcmd_clear = TRUE;
3286:
3287: static void display_showcmd __ARGS((void));
3288:
3289: void
3290: clear_showcmd()
3291: {
3292: if (!p_sc)
3293: return;
3294:
3295: showcmd_buf[0] = NUL;
3296:
3297: /*
3298: * Don't actually display something if there is nothing to clear.
3299: */
3300: if (is_showcmd_clear)
3301: return;
3302:
3303: display_showcmd();
3304: }
3305:
3306: /*
3307: * Add 'c' to string of shown command chars.
3308: * Return TRUE if setcursor() has been called.
3309: */
3310: int
3311: add_to_showcmd(c, display_always)
3312: int c;
3313: int display_always;
3314: {
3315: char_u *p;
3316: int old_len;
3317: int extra_len;
3318: int overflow;
3319:
3320: if (!p_sc)
3321: return FALSE;
3322:
3323: p = transchar(c);
3324: old_len = STRLEN(showcmd_buf);
3325: extra_len = STRLEN(p);
3326: overflow = old_len + extra_len - SHOWCMD_COLS;
3327: if (overflow > 0)
3328: STRCPY(showcmd_buf, showcmd_buf + overflow);
3329: STRCAT(showcmd_buf, p);
3330:
3331: if (!display_always && char_avail())
3332: return FALSE;
3333:
3334: display_showcmd();
3335:
3336: return TRUE;
3337: }
3338:
3339: /*
3340: * Delete 'len' characters from the end of the shown command.
3341: */
3342: static void
3343: del_from_showcmd(len)
3344: int len;
3345: {
3346: int old_len;
3347:
3348: if (!p_sc)
3349: return;
3350:
3351: old_len = STRLEN(showcmd_buf);
3352: if (len > old_len)
3353: len = old_len;
3354: showcmd_buf[old_len - len] = NUL;
3355:
3356: if (!char_avail())
3357: display_showcmd();
3358: }
3359:
3360: void
3361: push_showcmd()
3362: {
3363: if (p_sc)
3364: STRCPY(old_showcmd_buf, showcmd_buf);
3365: }
3366:
3367: void
3368: pop_showcmd()
3369: {
3370: if (!p_sc)
3371: return;
3372:
3373: STRCPY(showcmd_buf, old_showcmd_buf);
3374:
3375: display_showcmd();
3376: }
3377:
3378: static void
3379: display_showcmd()
3380: {
3381: int len;
3382:
3383: cursor_off();
3384:
3385: len = STRLEN(showcmd_buf);
3386: if (len == 0)
3387: is_showcmd_clear = TRUE;
3388: else
3389: {
3390: screen_msg(showcmd_buf, (int)Rows - 1, sc_col);
3391: is_showcmd_clear = FALSE;
3392: }
3393:
3394: /*
3395: * clear the rest of an old message by outputing up to SHOWCMD_COLS spaces
3396: */
3397: screen_msg((char_u *)" " + len, (int)Rows - 1, sc_col + len);
3398:
3399: setcursor(); /* put cursor back where it belongs */
3400: }
3401:
3402: /*
3403: * Implementation of "gd" and "gD" command.
3404: */
3405: static void
3406: do_gd(nchar)
3407: int nchar;
3408: {
3409: int len;
3410: char_u *pat;
3411: FPOS old_pos;
3412: int t;
3413: int save_p_ws;
3414: int save_p_scs;
3415: char_u *ptr;
3416:
3417: if ((len = find_ident_under_cursor(&ptr, FIND_IDENT)) == 0 ||
3418: (pat = alloc(len + 5)) == NULL)
3419: {
3420: clearopbeep();
3421: return;
3422: }
3423: sprintf((char *)pat, iswordchar(*ptr) ? "\\<%.*s\\>" :
3424: "%.*s", len, ptr);
3425: old_pos = curwin->w_cursor;
3426: save_p_ws = p_ws;
3427: save_p_scs = p_scs;
3428: p_ws = FALSE; /* don't wrap around end of file now */
3429: p_scs = FALSE; /* don't switch ignorecase off now */
3430: fo_do_comments = TRUE;
3431:
3432: /*
3433: * Search back for the end of the previous function.
3434: * If this fails, and with "gD", go to line 1.
3435: * Search forward for the identifier, ignore comment lines.
3436: */
3437: if (nchar == 'D' || !findpar(BACKWARD, 1L, '}', FALSE))
3438: {
3439: setpcmark(); /* Set in findpar() otherwise */
3440: curwin->w_cursor.lnum = 1;
3441: }
3442:
3443: while ((t = searchit(&curwin->w_cursor, FORWARD, pat, 1L, 0, RE_LAST))
3444: == OK &&
3445: get_leader_len(ml_get_curline(), NULL) &&
3446: old_pos.lnum > curwin->w_cursor.lnum)
3447: ++curwin->w_cursor.lnum;
3448: if (t == FAIL || old_pos.lnum <= curwin->w_cursor.lnum)
3449: {
3450: clearopbeep();
3451: curwin->w_cursor = old_pos;
3452: }
3453: else
3454: curwin->w_set_curswant = TRUE;
3455:
3456: vim_free(pat);
3457: p_ws = save_p_ws;
3458: p_scs = save_p_scs;
3459: fo_do_comments = FALSE;
3460: }