1 /* vi:set ts=8 sts=4 sw=4 noet: 2 * 3 * VIM - Vi IMproved by Bram Moolenaar 4 * 5 * Do ":help uganda" in Vim to read copying and usage conditions. 6 * Do ":help credits" in Vim to see a list of people who contributed. 7 * See README.txt for an overview of the Vim source code. 8 */ 9 /* 10 * normal.c: Contains the main routine for processing characters in command 11 * mode. Communicates closely with the code in ops.c to handle 12 * the operators. 13 */ 14 15 #include "vim.h" 16 17 static int VIsual_mode_orig = NUL; // saved Visual mode 18 static int restart_VIsual_select = 0; 19 20 #ifdef FEAT_EVAL 21 static void set_vcount_ca(cmdarg_T *cap, int *set_prevcount); 22 #endif 23 static int nv_compare(const void *s1, const void *s2); 24 static void unshift_special(cmdarg_T *cap); 25 #ifdef FEAT_CMDL_INFO 26 static void del_from_showcmd(int); 27 #endif 28 29 /* 30 * nv_*(): functions called to handle Normal and Visual mode commands. 31 * n_*(): functions called to handle Normal mode commands. 32 * v_*(): functions called to handle Visual mode commands. 33 */ 34 static void nv_ignore(cmdarg_T *cap); 35 static void nv_nop(cmdarg_T *cap); 36 static void nv_error(cmdarg_T *cap); 37 static void nv_help(cmdarg_T *cap); 38 static void nv_addsub(cmdarg_T *cap); 39 static void nv_page(cmdarg_T *cap); 40 static void nv_zet(cmdarg_T *cap); 41 #ifdef FEAT_GUI 42 static void nv_ver_scrollbar(cmdarg_T *cap); 43 static void nv_hor_scrollbar(cmdarg_T *cap); 44 #endif 45 #ifdef FEAT_GUI_TABLINE 46 static void nv_tabline(cmdarg_T *cap); 47 static void nv_tabmenu(cmdarg_T *cap); 48 #endif 49 static void nv_exmode(cmdarg_T *cap); 50 static void nv_colon(cmdarg_T *cap); 51 static void nv_ctrlg(cmdarg_T *cap); 52 static void nv_ctrlh(cmdarg_T *cap); 53 static void nv_clear(cmdarg_T *cap); 54 static void nv_ctrlo(cmdarg_T *cap); 55 static void nv_hat(cmdarg_T *cap); 56 static void nv_Zet(cmdarg_T *cap); 57 static void nv_ident(cmdarg_T *cap); 58 static void nv_tagpop(cmdarg_T *cap); 59 static void nv_scroll(cmdarg_T *cap); 60 static void nv_right(cmdarg_T *cap); 61 static void nv_left(cmdarg_T *cap); 62 static void nv_up(cmdarg_T *cap); 63 static void nv_down(cmdarg_T *cap); 64 static void nv_end(cmdarg_T *cap); 65 static void nv_dollar(cmdarg_T *cap); 66 static void nv_search(cmdarg_T *cap); 67 static void nv_next(cmdarg_T *cap); 68 static int normal_search(cmdarg_T *cap, int dir, char_u *pat, int opt, int *wrapped); 69 static void nv_csearch(cmdarg_T *cap); 70 static void nv_brackets(cmdarg_T *cap); 71 static void nv_percent(cmdarg_T *cap); 72 static void nv_brace(cmdarg_T *cap); 73 static void nv_mark(cmdarg_T *cap); 74 static void nv_findpar(cmdarg_T *cap); 75 static void nv_undo(cmdarg_T *cap); 76 static void nv_kundo(cmdarg_T *cap); 77 static void nv_Replace(cmdarg_T *cap); 78 static void nv_replace(cmdarg_T *cap); 79 static void nv_cursormark(cmdarg_T *cap, int flag, pos_T *pos); 80 static void v_visop(cmdarg_T *cap); 81 static void nv_subst(cmdarg_T *cap); 82 static void nv_abbrev(cmdarg_T *cap); 83 static void nv_optrans(cmdarg_T *cap); 84 static void nv_gomark(cmdarg_T *cap); 85 static void nv_pcmark(cmdarg_T *cap); 86 static void nv_regname(cmdarg_T *cap); 87 static void nv_visual(cmdarg_T *cap); 88 static void n_start_visual_mode(int c); 89 static void nv_window(cmdarg_T *cap); 90 static void nv_suspend(cmdarg_T *cap); 91 static void nv_g_cmd(cmdarg_T *cap); 92 static void nv_dot(cmdarg_T *cap); 93 static void nv_redo(cmdarg_T *cap); 94 static void nv_Undo(cmdarg_T *cap); 95 static void nv_tilde(cmdarg_T *cap); 96 static void nv_operator(cmdarg_T *cap); 97 #ifdef FEAT_EVAL 98 static void set_op_var(int optype); 99 #endif 100 static void nv_lineop(cmdarg_T *cap); 101 static void nv_home(cmdarg_T *cap); 102 static void nv_pipe(cmdarg_T *cap); 103 static void nv_bck_word(cmdarg_T *cap); 104 static void nv_wordcmd(cmdarg_T *cap); 105 static void nv_beginline(cmdarg_T *cap); 106 static void adjust_cursor(oparg_T *oap); 107 static void adjust_for_sel(cmdarg_T *cap); 108 static void nv_select(cmdarg_T *cap); 109 static void nv_goto(cmdarg_T *cap); 110 static void nv_normal(cmdarg_T *cap); 111 static void nv_esc(cmdarg_T *oap); 112 static void nv_edit(cmdarg_T *cap); 113 static void invoke_edit(cmdarg_T *cap, int repl, int cmd, int startln); 114 #ifdef FEAT_TEXTOBJ 115 static void nv_object(cmdarg_T *cap); 116 #endif 117 static void nv_record(cmdarg_T *cap); 118 static void nv_at(cmdarg_T *cap); 119 static void nv_halfpage(cmdarg_T *cap); 120 static void nv_join(cmdarg_T *cap); 121 static void nv_put(cmdarg_T *cap); 122 static void nv_put_opt(cmdarg_T *cap, int fix_indent); 123 static void nv_open(cmdarg_T *cap); 124 #ifdef FEAT_NETBEANS_INTG 125 static void nv_nbcmd(cmdarg_T *cap); 126 #endif 127 #ifdef FEAT_DND 128 static void nv_drop(cmdarg_T *cap); 129 #endif 130 static void nv_cursorhold(cmdarg_T *cap); 131 132 static char *e_noident = N_("E349: No identifier under cursor"); 133 134 /* 135 * Function to be called for a Normal or Visual mode command. 136 * The argument is a cmdarg_T. 137 */ 138 typedef void (*nv_func_T)(cmdarg_T *cap); 139 140 // Values for cmd_flags. 141 #define NV_NCH 0x01 // may need to get a second char 142 #define NV_NCH_NOP (0x02|NV_NCH) // get second char when no operator pending 143 #define NV_NCH_ALW (0x04|NV_NCH) // always get a second char 144 #define NV_LANG 0x08 // second char needs language adjustment 145 146 #define NV_SS 0x10 // may start selection 147 #define NV_SSS 0x20 // may start selection with shift modifier 148 #define NV_STS 0x40 // may stop selection without shift modif. 149 #define NV_RL 0x80 // 'rightleft' modifies command 150 #define NV_KEEPREG 0x100 // don't clear regname 151 #define NV_NCW 0x200 // not allowed in command-line window 152 153 /* 154 * Generally speaking, every Normal mode command should either clear any 155 * pending operator (with *clearop*()), or set the motion type variable 156 * oap->motion_type. 157 * 158 * When a cursor motion command is made, it is marked as being a character or 159 * line oriented motion. Then, if an operator is in effect, the operation 160 * becomes character or line oriented accordingly. 161 */ 162 163 /* 164 * This table contains one entry for every Normal or Visual mode command. 165 * The order doesn't matter, init_normal_cmds() will create a sorted index. 166 * It is faster when all keys from zero to '~' are present. 167 */ 168 static const struct nv_cmd 169 { 170 int cmd_char; // (first) command character 171 nv_func_T cmd_func; // function for this command 172 short_u cmd_flags; // NV_ flags 173 short cmd_arg; // value for ca.arg 174 } nv_cmds[] = 175 { 176 {NUL, nv_error, 0, 0}, 177 {Ctrl_A, nv_addsub, 0, 0}, 178 {Ctrl_B, nv_page, NV_STS, BACKWARD}, 179 {Ctrl_C, nv_esc, 0, TRUE}, 180 {Ctrl_D, nv_halfpage, 0, 0}, 181 {Ctrl_E, nv_scroll_line, 0, TRUE}, 182 {Ctrl_F, nv_page, NV_STS, FORWARD}, 183 {Ctrl_G, nv_ctrlg, 0, 0}, 184 {Ctrl_H, nv_ctrlh, 0, 0}, 185 {Ctrl_I, nv_pcmark, 0, 0}, 186 {NL, nv_down, 0, FALSE}, 187 {Ctrl_K, nv_error, 0, 0}, 188 {Ctrl_L, nv_clear, 0, 0}, 189 {CAR, nv_down, 0, TRUE}, 190 {Ctrl_N, nv_down, NV_STS, FALSE}, 191 {Ctrl_O, nv_ctrlo, 0, 0}, 192 {Ctrl_P, nv_up, NV_STS, FALSE}, 193 {Ctrl_Q, nv_visual, 0, FALSE}, 194 {Ctrl_R, nv_redo, 0, 0}, 195 {Ctrl_S, nv_ignore, 0, 0}, 196 {Ctrl_T, nv_tagpop, NV_NCW, 0}, 197 {Ctrl_U, nv_halfpage, 0, 0}, 198 {Ctrl_V, nv_visual, 0, FALSE}, 199 {'V', nv_visual, 0, FALSE}, 200 {'v', nv_visual, 0, FALSE}, 201 {Ctrl_W, nv_window, 0, 0}, 202 {Ctrl_X, nv_addsub, 0, 0}, 203 {Ctrl_Y, nv_scroll_line, 0, FALSE}, 204 {Ctrl_Z, nv_suspend, 0, 0}, 205 {ESC, nv_esc, 0, FALSE}, 206 {Ctrl_BSL, nv_normal, NV_NCH_ALW, 0}, 207 {Ctrl_RSB, nv_ident, NV_NCW, 0}, 208 {Ctrl_HAT, nv_hat, NV_NCW, 0}, 209 {Ctrl__, nv_error, 0, 0}, 210 {' ', nv_right, 0, 0}, 211 {'!', nv_operator, 0, 0}, 212 {'"', nv_regname, NV_NCH_NOP|NV_KEEPREG, 0}, 213 {'#', nv_ident, 0, 0}, 214 {'$', nv_dollar, 0, 0}, 215 {'%', nv_percent, 0, 0}, 216 {'&', nv_optrans, 0, 0}, 217 {'\'', nv_gomark, NV_NCH_ALW, TRUE}, 218 {'(', nv_brace, 0, BACKWARD}, 219 {')', nv_brace, 0, FORWARD}, 220 {'*', nv_ident, 0, 0}, 221 {'+', nv_down, 0, TRUE}, 222 {',', nv_csearch, 0, TRUE}, 223 {'-', nv_up, 0, TRUE}, 224 {'.', nv_dot, NV_KEEPREG, 0}, 225 {'/', nv_search, 0, FALSE}, 226 {'0', nv_beginline, 0, 0}, 227 {'1', nv_ignore, 0, 0}, 228 {'2', nv_ignore, 0, 0}, 229 {'3', nv_ignore, 0, 0}, 230 {'4', nv_ignore, 0, 0}, 231 {'5', nv_ignore, 0, 0}, 232 {'6', nv_ignore, 0, 0}, 233 {'7', nv_ignore, 0, 0}, 234 {'8', nv_ignore, 0, 0}, 235 {'9', nv_ignore, 0, 0}, 236 {':', nv_colon, 0, 0}, 237 {';', nv_csearch, 0, FALSE}, 238 {'<', nv_operator, NV_RL, 0}, 239 {'=', nv_operator, 0, 0}, 240 {'>', nv_operator, NV_RL, 0}, 241 {'?', nv_search, 0, FALSE}, 242 {'@', nv_at, NV_NCH_NOP, FALSE}, 243 {'A', nv_edit, 0, 0}, 244 {'B', nv_bck_word, 0, 1}, 245 {'C', nv_abbrev, NV_KEEPREG, 0}, 246 {'D', nv_abbrev, NV_KEEPREG, 0}, 247 {'E', nv_wordcmd, 0, TRUE}, 248 {'F', nv_csearch, NV_NCH_ALW|NV_LANG, BACKWARD}, 249 {'G', nv_goto, 0, TRUE}, 250 {'H', nv_scroll, 0, 0}, 251 {'I', nv_edit, 0, 0}, 252 {'J', nv_join, 0, 0}, 253 {'K', nv_ident, 0, 0}, 254 {'L', nv_scroll, 0, 0}, 255 {'M', nv_scroll, 0, 0}, 256 {'N', nv_next, 0, SEARCH_REV}, 257 {'O', nv_open, 0, 0}, 258 {'P', nv_put, 0, 0}, 259 {'Q', nv_exmode, NV_NCW, 0}, 260 {'R', nv_Replace, 0, FALSE}, 261 {'S', nv_subst, NV_KEEPREG, 0}, 262 {'T', nv_csearch, NV_NCH_ALW|NV_LANG, BACKWARD}, 263 {'U', nv_Undo, 0, 0}, 264 {'W', nv_wordcmd, 0, TRUE}, 265 {'X', nv_abbrev, NV_KEEPREG, 0}, 266 {'Y', nv_abbrev, NV_KEEPREG, 0}, 267 {'Z', nv_Zet, NV_NCH_NOP|NV_NCW, 0}, 268 {'[', nv_brackets, NV_NCH_ALW, BACKWARD}, 269 {'\\', nv_error, 0, 0}, 270 {']', nv_brackets, NV_NCH_ALW, FORWARD}, 271 {'^', nv_beginline, 0, BL_WHITE | BL_FIX}, 272 {'_', nv_lineop, 0, 0}, 273 {'`', nv_gomark, NV_NCH_ALW, FALSE}, 274 {'a', nv_edit, NV_NCH, 0}, 275 {'b', nv_bck_word, 0, 0}, 276 {'c', nv_operator, 0, 0}, 277 {'d', nv_operator, 0, 0}, 278 {'e', nv_wordcmd, 0, FALSE}, 279 {'f', nv_csearch, NV_NCH_ALW|NV_LANG, FORWARD}, 280 {'g', nv_g_cmd, NV_NCH_ALW, FALSE}, 281 {'h', nv_left, NV_RL, 0}, 282 {'i', nv_edit, NV_NCH, 0}, 283 {'j', nv_down, 0, FALSE}, 284 {'k', nv_up, 0, FALSE}, 285 {'l', nv_right, NV_RL, 0}, 286 {'m', nv_mark, NV_NCH_NOP, 0}, 287 {'n', nv_next, 0, 0}, 288 {'o', nv_open, 0, 0}, 289 {'p', nv_put, 0, 0}, 290 {'q', nv_record, NV_NCH, 0}, 291 {'r', nv_replace, NV_NCH_NOP|NV_LANG, 0}, 292 {'s', nv_subst, NV_KEEPREG, 0}, 293 {'t', nv_csearch, NV_NCH_ALW|NV_LANG, FORWARD}, 294 {'u', nv_undo, 0, 0}, 295 {'w', nv_wordcmd, 0, FALSE}, 296 {'x', nv_abbrev, NV_KEEPREG, 0}, 297 {'y', nv_operator, 0, 0}, 298 {'z', nv_zet, NV_NCH_ALW, 0}, 299 {'{', nv_findpar, 0, BACKWARD}, 300 {'|', nv_pipe, 0, 0}, 301 {'}', nv_findpar, 0, FORWARD}, 302 {'~', nv_tilde, 0, 0}, 303 304 // pound sign 305 {POUND, nv_ident, 0, 0}, 306 {K_MOUSEUP, nv_mousescroll, 0, MSCR_UP}, 307 {K_MOUSEDOWN, nv_mousescroll, 0, MSCR_DOWN}, 308 {K_MOUSELEFT, nv_mousescroll, 0, MSCR_LEFT}, 309 {K_MOUSERIGHT, nv_mousescroll, 0, MSCR_RIGHT}, 310 {K_LEFTMOUSE, nv_mouse, 0, 0}, 311 {K_LEFTMOUSE_NM, nv_mouse, 0, 0}, 312 {K_LEFTDRAG, nv_mouse, 0, 0}, 313 {K_LEFTRELEASE, nv_mouse, 0, 0}, 314 {K_LEFTRELEASE_NM, nv_mouse, 0, 0}, 315 {K_MOUSEMOVE, nv_mouse, 0, 0}, 316 {K_MIDDLEMOUSE, nv_mouse, 0, 0}, 317 {K_MIDDLEDRAG, nv_mouse, 0, 0}, 318 {K_MIDDLERELEASE, nv_mouse, 0, 0}, 319 {K_RIGHTMOUSE, nv_mouse, 0, 0}, 320 {K_RIGHTDRAG, nv_mouse, 0, 0}, 321 {K_RIGHTRELEASE, nv_mouse, 0, 0}, 322 {K_X1MOUSE, nv_mouse, 0, 0}, 323 {K_X1DRAG, nv_mouse, 0, 0}, 324 {K_X1RELEASE, nv_mouse, 0, 0}, 325 {K_X2MOUSE, nv_mouse, 0, 0}, 326 {K_X2DRAG, nv_mouse, 0, 0}, 327 {K_X2RELEASE, nv_mouse, 0, 0}, 328 {K_IGNORE, nv_ignore, NV_KEEPREG, 0}, 329 {K_NOP, nv_nop, 0, 0}, 330 {K_INS, nv_edit, 0, 0}, 331 {K_KINS, nv_edit, 0, 0}, 332 {K_BS, nv_ctrlh, 0, 0}, 333 {K_UP, nv_up, NV_SSS|NV_STS, FALSE}, 334 {K_S_UP, nv_page, NV_SS, BACKWARD}, 335 {K_DOWN, nv_down, NV_SSS|NV_STS, FALSE}, 336 {K_S_DOWN, nv_page, NV_SS, FORWARD}, 337 {K_LEFT, nv_left, NV_SSS|NV_STS|NV_RL, 0}, 338 {K_S_LEFT, nv_bck_word, NV_SS|NV_RL, 0}, 339 {K_C_LEFT, nv_bck_word, NV_SSS|NV_RL|NV_STS, 1}, 340 {K_RIGHT, nv_right, NV_SSS|NV_STS|NV_RL, 0}, 341 {K_S_RIGHT, nv_wordcmd, NV_SS|NV_RL, FALSE}, 342 {K_C_RIGHT, nv_wordcmd, NV_SSS|NV_RL|NV_STS, TRUE}, 343 {K_PAGEUP, nv_page, NV_SSS|NV_STS, BACKWARD}, 344 {K_KPAGEUP, nv_page, NV_SSS|NV_STS, BACKWARD}, 345 {K_PAGEDOWN, nv_page, NV_SSS|NV_STS, FORWARD}, 346 {K_KPAGEDOWN, nv_page, NV_SSS|NV_STS, FORWARD}, 347 {K_END, nv_end, NV_SSS|NV_STS, FALSE}, 348 {K_KEND, nv_end, NV_SSS|NV_STS, FALSE}, 349 {K_S_END, nv_end, NV_SS, FALSE}, 350 {K_C_END, nv_end, NV_SSS|NV_STS, TRUE}, 351 {K_HOME, nv_home, NV_SSS|NV_STS, 0}, 352 {K_KHOME, nv_home, NV_SSS|NV_STS, 0}, 353 {K_S_HOME, nv_home, NV_SS, 0}, 354 {K_C_HOME, nv_goto, NV_SSS|NV_STS, FALSE}, 355 {K_DEL, nv_abbrev, 0, 0}, 356 {K_KDEL, nv_abbrev, 0, 0}, 357 {K_UNDO, nv_kundo, 0, 0}, 358 {K_HELP, nv_help, NV_NCW, 0}, 359 {K_F1, nv_help, NV_NCW, 0}, 360 {K_XF1, nv_help, NV_NCW, 0}, 361 {K_SELECT, nv_select, 0, 0}, 362 #ifdef FEAT_GUI 363 {K_VER_SCROLLBAR, nv_ver_scrollbar, 0, 0}, 364 {K_HOR_SCROLLBAR, nv_hor_scrollbar, 0, 0}, 365 #endif 366 #ifdef FEAT_GUI_TABLINE 367 {K_TABLINE, nv_tabline, 0, 0}, 368 {K_TABMENU, nv_tabmenu, 0, 0}, 369 #endif 370 #ifdef FEAT_NETBEANS_INTG 371 {K_F21, nv_nbcmd, NV_NCH_ALW, 0}, 372 #endif 373 #ifdef FEAT_DND 374 {K_DROP, nv_drop, NV_STS, 0}, 375 #endif 376 {K_CURSORHOLD, nv_cursorhold, NV_KEEPREG, 0}, 377 {K_PS, nv_edit, 0, 0}, 378 }; 379 380 // Number of commands in nv_cmds[]. 381 #define NV_CMDS_SIZE (sizeof(nv_cmds) / sizeof(struct nv_cmd)) 382 383 // Sorted index of commands in nv_cmds[]. 384 static short nv_cmd_idx[NV_CMDS_SIZE]; 385 386 // The highest index for which 387 // nv_cmds[idx].cmd_char == nv_cmd_idx[nv_cmds[idx].cmd_char] 388 static int nv_max_linear; 389 390 /* 391 * Compare functions for qsort() below, that checks the command character 392 * through the index in nv_cmd_idx[]. 393 */ 394 static int 395 nv_compare(const void *s1, const void *s2) 396 { 397 int c1, c2; 398 399 // The commands are sorted on absolute value. 400 c1 = nv_cmds[*(const short *)s1].cmd_char; 401 c2 = nv_cmds[*(const short *)s2].cmd_char; 402 if (c1 < 0) 403 c1 = -c1; 404 if (c2 < 0) 405 c2 = -c2; 406 return c1 - c2; 407 } 408 409 /* 410 * Initialize the nv_cmd_idx[] table. 411 */ 412 void 413 init_normal_cmds(void) 414 { 415 int i; 416 417 // Fill the index table with a one to one relation. 418 for (i = 0; i < (int)NV_CMDS_SIZE; ++i) 419 nv_cmd_idx[i] = i; 420 421 // Sort the commands by the command character. 422 qsort((void *)&nv_cmd_idx, (size_t)NV_CMDS_SIZE, sizeof(short), nv_compare); 423 424 // Find the first entry that can't be indexed by the command character. 425 for (i = 0; i < (int)NV_CMDS_SIZE; ++i) 426 if (i != nv_cmds[nv_cmd_idx[i]].cmd_char) 427 break; 428 nv_max_linear = i - 1; 429 } 430 431 /* 432 * Search for a command in the commands table. 433 * Returns -1 for invalid command. 434 */ 435 static int 436 find_command(int cmdchar) 437 { 438 int i; 439 int idx; 440 int top, bot; 441 int c; 442 443 // A multi-byte character is never a command. 444 if (cmdchar >= 0x100) 445 return -1; 446 447 // We use the absolute value of the character. Special keys have a 448 // negative value, but are sorted on their absolute value. 449 if (cmdchar < 0) 450 cmdchar = -cmdchar; 451 452 // If the character is in the first part: The character is the index into 453 // nv_cmd_idx[]. 454 if (cmdchar <= nv_max_linear) 455 return nv_cmd_idx[cmdchar]; 456 457 // Perform a binary search. 458 bot = nv_max_linear + 1; 459 top = NV_CMDS_SIZE - 1; 460 idx = -1; 461 while (bot <= top) 462 { 463 i = (top + bot) / 2; 464 c = nv_cmds[nv_cmd_idx[i]].cmd_char; 465 if (c < 0) 466 c = -c; 467 if (cmdchar == c) 468 { 469 idx = nv_cmd_idx[i]; 470 break; 471 } 472 if (cmdchar > c) 473 bot = i + 1; 474 else 475 top = i - 1; 476 } 477 return idx; 478 } 479 480 /* 481 * Execute a command in Normal mode. 482 */ 483 void 484 normal_cmd( 485 oparg_T *oap, 486 int toplevel UNUSED) // TRUE when called from main() 487 { 488 cmdarg_T ca; // command arguments 489 int c; 490 int ctrl_w = FALSE; // got CTRL-W command 491 int old_col = curwin->w_curswant; 492 #ifdef FEAT_CMDL_INFO 493 int need_flushbuf; // need to call out_flush() 494 #endif 495 pos_T old_pos; // cursor position before command 496 int mapped_len; 497 static int old_mapped_len = 0; 498 int idx; 499 #ifdef FEAT_EVAL 500 int set_prevcount = FALSE; 501 #endif 502 int save_did_cursorhold = did_cursorhold; 503 504 CLEAR_FIELD(ca); // also resets ca.retval 505 ca.oap = oap; 506 507 // Use a count remembered from before entering an operator. After typing 508 // "3d" we return from normal_cmd() and come back here, the "3" is 509 // remembered in "opcount". 510 ca.opcount = opcount; 511 512 /* 513 * If there is an operator pending, then the command we take this time 514 * will terminate it. Finish_op tells us to finish the operation before 515 * returning this time (unless the operation was cancelled). 516 */ 517 #ifdef CURSOR_SHAPE 518 c = finish_op; 519 #endif 520 finish_op = (oap->op_type != OP_NOP); 521 #ifdef CURSOR_SHAPE 522 if (finish_op != c) 523 { 524 ui_cursor_shape(); // may show different cursor shape 525 # ifdef FEAT_MOUSESHAPE 526 update_mouseshape(-1); 527 # endif 528 } 529 #endif 530 531 // When not finishing an operator and no register name typed, reset the 532 // count. 533 if (!finish_op && !oap->regname) 534 { 535 ca.opcount = 0; 536 #ifdef FEAT_EVAL 537 set_prevcount = TRUE; 538 #endif 539 } 540 541 // Restore counts from before receiving K_CURSORHOLD. This means after 542 // typing "3", handling K_CURSORHOLD and then typing "2" we get "32", not 543 // "3 * 2". 544 if (oap->prev_opcount > 0 || oap->prev_count0 > 0) 545 { 546 ca.opcount = oap->prev_opcount; 547 ca.count0 = oap->prev_count0; 548 oap->prev_opcount = 0; 549 oap->prev_count0 = 0; 550 } 551 552 mapped_len = typebuf_maplen(); 553 554 State = NORMAL_BUSY; 555 #ifdef USE_ON_FLY_SCROLL 556 dont_scroll = FALSE; // allow scrolling here 557 #endif 558 559 #ifdef FEAT_EVAL 560 // Set v:count here, when called from main() and not a stuffed 561 // command, so that v:count can be used in an expression mapping 562 // when there is no count. Do set it for redo. 563 if (toplevel && readbuf1_empty()) 564 set_vcount_ca(&ca, &set_prevcount); 565 #endif 566 567 /* 568 * Get the command character from the user. 569 */ 570 c = safe_vgetc(); 571 LANGMAP_ADJUST(c, get_real_state() != SELECTMODE); 572 573 /* 574 * If a mapping was started in Visual or Select mode, remember the length 575 * of the mapping. This is used below to not return to Insert mode for as 576 * long as the mapping is being executed. 577 */ 578 if (restart_edit == 0) 579 old_mapped_len = 0; 580 else if (old_mapped_len 581 || (VIsual_active && mapped_len == 0 && typebuf_maplen() > 0)) 582 old_mapped_len = typebuf_maplen(); 583 584 if (c == NUL) 585 c = K_ZERO; 586 587 /* 588 * In Select mode, typed text replaces the selection. 589 */ 590 if (VIsual_active 591 && VIsual_select 592 && (vim_isprintc(c) || c == NL || c == CAR || c == K_KENTER)) 593 { 594 // Fake a "c"hange command. When "restart_edit" is set (e.g., because 595 // 'insertmode' is set) fake a "d"elete command, Insert mode will 596 // restart automatically. 597 // Insert the typed character in the typeahead buffer, so that it can 598 // be mapped in Insert mode. Required for ":lmap" to work. 599 ins_char_typebuf(vgetc_char, vgetc_mod_mask); 600 if (restart_edit != 0) 601 c = 'd'; 602 else 603 c = 'c'; 604 msg_nowait = TRUE; // don't delay going to insert mode 605 old_mapped_len = 0; // do go to Insert mode 606 } 607 608 #ifdef FEAT_CMDL_INFO 609 need_flushbuf = add_to_showcmd(c); 610 #endif 611 612 getcount: 613 if (!(VIsual_active && VIsual_select)) 614 { 615 /* 616 * Handle a count before a command and compute ca.count0. 617 * Note that '0' is a command and not the start of a count, but it's 618 * part of a count after other digits. 619 */ 620 while ( (c >= '1' && c <= '9') 621 || (ca.count0 != 0 && (c == K_DEL || c == K_KDEL || c == '0'))) 622 { 623 if (c == K_DEL || c == K_KDEL) 624 { 625 ca.count0 /= 10; 626 #ifdef FEAT_CMDL_INFO 627 del_from_showcmd(4); // delete the digit and ~@% 628 #endif 629 } 630 else 631 ca.count0 = ca.count0 * 10 + (c - '0'); 632 if (ca.count0 < 0) // got too large! 633 ca.count0 = 999999999L; 634 #ifdef FEAT_EVAL 635 // Set v:count here, when called from main() and not a stuffed 636 // command, so that v:count can be used in an expression mapping 637 // right after the count. Do set it for redo. 638 if (toplevel && readbuf1_empty()) 639 set_vcount_ca(&ca, &set_prevcount); 640 #endif 641 if (ctrl_w) 642 { 643 ++no_mapping; 644 ++allow_keys; // no mapping for nchar, but keys 645 } 646 ++no_zero_mapping; // don't map zero here 647 c = plain_vgetc(); 648 LANGMAP_ADJUST(c, TRUE); 649 --no_zero_mapping; 650 if (ctrl_w) 651 { 652 --no_mapping; 653 --allow_keys; 654 } 655 #ifdef FEAT_CMDL_INFO 656 need_flushbuf |= add_to_showcmd(c); 657 #endif 658 } 659 660 /* 661 * If we got CTRL-W there may be a/another count 662 */ 663 if (c == Ctrl_W && !ctrl_w && oap->op_type == OP_NOP) 664 { 665 ctrl_w = TRUE; 666 ca.opcount = ca.count0; // remember first count 667 ca.count0 = 0; 668 ++no_mapping; 669 ++allow_keys; // no mapping for nchar, but keys 670 c = plain_vgetc(); // get next character 671 LANGMAP_ADJUST(c, TRUE); 672 --no_mapping; 673 --allow_keys; 674 #ifdef FEAT_CMDL_INFO 675 need_flushbuf |= add_to_showcmd(c); 676 #endif 677 goto getcount; // jump back 678 } 679 } 680 681 if (c == K_CURSORHOLD) 682 { 683 // Save the count values so that ca.opcount and ca.count0 are exactly 684 // the same when coming back here after handling K_CURSORHOLD. 685 oap->prev_opcount = ca.opcount; 686 oap->prev_count0 = ca.count0; 687 } 688 else if (ca.opcount != 0) 689 { 690 /* 691 * If we're in the middle of an operator (including after entering a 692 * yank buffer with '"') AND we had a count before the operator, then 693 * that count overrides the current value of ca.count0. 694 * What this means effectively, is that commands like "3dw" get turned 695 * into "d3w" which makes things fall into place pretty neatly. 696 * If you give a count before AND after the operator, they are 697 * multiplied. 698 */ 699 if (ca.count0) 700 ca.count0 *= ca.opcount; 701 else 702 ca.count0 = ca.opcount; 703 } 704 705 /* 706 * Always remember the count. It will be set to zero (on the next call, 707 * above) when there is no pending operator. 708 * When called from main(), save the count for use by the "count" built-in 709 * variable. 710 */ 711 ca.opcount = ca.count0; 712 ca.count1 = (ca.count0 == 0 ? 1 : ca.count0); 713 714 #ifdef FEAT_EVAL 715 /* 716 * Only set v:count when called from main() and not a stuffed command. 717 * Do set it for redo. 718 */ 719 if (toplevel && readbuf1_empty()) 720 set_vcount(ca.count0, ca.count1, set_prevcount); 721 #endif 722 723 /* 724 * Find the command character in the table of commands. 725 * For CTRL-W we already got nchar when looking for a count. 726 */ 727 if (ctrl_w) 728 { 729 ca.nchar = c; 730 ca.cmdchar = Ctrl_W; 731 } 732 else 733 ca.cmdchar = c; 734 idx = find_command(ca.cmdchar); 735 if (idx < 0) 736 { 737 // Not a known command: beep. 738 clearopbeep(oap); 739 goto normal_end; 740 } 741 742 if (text_locked() && (nv_cmds[idx].cmd_flags & NV_NCW)) 743 { 744 // This command is not allowed while editing a cmdline: beep. 745 clearopbeep(oap); 746 text_locked_msg(); 747 goto normal_end; 748 } 749 if ((nv_cmds[idx].cmd_flags & NV_NCW) && curbuf_locked()) 750 goto normal_end; 751 752 /* 753 * In Visual/Select mode, a few keys are handled in a special way. 754 */ 755 if (VIsual_active) 756 { 757 // when 'keymodel' contains "stopsel" may stop Select/Visual mode 758 if (km_stopsel 759 && (nv_cmds[idx].cmd_flags & NV_STS) 760 && !(mod_mask & MOD_MASK_SHIFT)) 761 { 762 end_visual_mode(); 763 redraw_curbuf_later(INVERTED); 764 } 765 766 // Keys that work different when 'keymodel' contains "startsel" 767 if (km_startsel) 768 { 769 if (nv_cmds[idx].cmd_flags & NV_SS) 770 { 771 unshift_special(&ca); 772 idx = find_command(ca.cmdchar); 773 if (idx < 0) 774 { 775 // Just in case 776 clearopbeep(oap); 777 goto normal_end; 778 } 779 } 780 else if ((nv_cmds[idx].cmd_flags & NV_SSS) 781 && (mod_mask & MOD_MASK_SHIFT)) 782 mod_mask &= ~MOD_MASK_SHIFT; 783 } 784 } 785 786 #ifdef FEAT_RIGHTLEFT 787 if (curwin->w_p_rl && KeyTyped && !KeyStuffed 788 && (nv_cmds[idx].cmd_flags & NV_RL)) 789 { 790 // Invert horizontal movements and operations. Only when typed by the 791 // user directly, not when the result of a mapping or "x" translated 792 // to "dl". 793 switch (ca.cmdchar) 794 { 795 case 'l': ca.cmdchar = 'h'; break; 796 case K_RIGHT: ca.cmdchar = K_LEFT; break; 797 case K_S_RIGHT: ca.cmdchar = K_S_LEFT; break; 798 case K_C_RIGHT: ca.cmdchar = K_C_LEFT; break; 799 case 'h': ca.cmdchar = 'l'; break; 800 case K_LEFT: ca.cmdchar = K_RIGHT; break; 801 case K_S_LEFT: ca.cmdchar = K_S_RIGHT; break; 802 case K_C_LEFT: ca.cmdchar = K_C_RIGHT; break; 803 case '>': ca.cmdchar = '<'; break; 804 case '<': ca.cmdchar = '>'; break; 805 } 806 idx = find_command(ca.cmdchar); 807 } 808 #endif 809 810 /* 811 * Get an additional character if we need one. 812 */ 813 if ((nv_cmds[idx].cmd_flags & NV_NCH) 814 && (((nv_cmds[idx].cmd_flags & NV_NCH_NOP) == NV_NCH_NOP 815 && oap->op_type == OP_NOP) 816 || (nv_cmds[idx].cmd_flags & NV_NCH_ALW) == NV_NCH_ALW 817 || (ca.cmdchar == 'q' 818 && oap->op_type == OP_NOP 819 && reg_recording == 0 820 && reg_executing == 0) 821 || ((ca.cmdchar == 'a' || ca.cmdchar == 'i') 822 && (oap->op_type != OP_NOP || VIsual_active)))) 823 { 824 int *cp; 825 int repl = FALSE; // get character for replace mode 826 int lit = FALSE; // get extra character literally 827 int langmap_active = FALSE; // using :lmap mappings 828 int lang; // getting a text character 829 #ifdef HAVE_INPUT_METHOD 830 int save_smd; // saved value of p_smd 831 #endif 832 833 ++no_mapping; 834 ++allow_keys; // no mapping for nchar, but allow key codes 835 // Don't generate a CursorHold event here, most commands can't handle 836 // it, e.g., nv_replace(), nv_csearch(). 837 did_cursorhold = TRUE; 838 if (ca.cmdchar == 'g') 839 { 840 /* 841 * For 'g' get the next character now, so that we can check for 842 * "gr", "g'" and "g`". 843 */ 844 ca.nchar = plain_vgetc(); 845 LANGMAP_ADJUST(ca.nchar, TRUE); 846 #ifdef FEAT_CMDL_INFO 847 need_flushbuf |= add_to_showcmd(ca.nchar); 848 #endif 849 if (ca.nchar == 'r' || ca.nchar == '\'' || ca.nchar == '`' 850 || ca.nchar == Ctrl_BSL) 851 { 852 cp = &ca.extra_char; // need to get a third character 853 if (ca.nchar != 'r') 854 lit = TRUE; // get it literally 855 else 856 repl = TRUE; // get it in replace mode 857 } 858 else 859 cp = NULL; // no third character needed 860 } 861 else 862 { 863 if (ca.cmdchar == 'r') // get it in replace mode 864 repl = TRUE; 865 cp = &ca.nchar; 866 } 867 lang = (repl || (nv_cmds[idx].cmd_flags & NV_LANG)); 868 869 /* 870 * Get a second or third character. 871 */ 872 if (cp != NULL) 873 { 874 if (repl) 875 { 876 State = REPLACE; // pretend Replace mode 877 #ifdef CURSOR_SHAPE 878 ui_cursor_shape(); // show different cursor shape 879 #endif 880 } 881 if (lang && curbuf->b_p_iminsert == B_IMODE_LMAP) 882 { 883 // Allow mappings defined with ":lmap". 884 --no_mapping; 885 --allow_keys; 886 if (repl) 887 State = LREPLACE; 888 else 889 State = LANGMAP; 890 langmap_active = TRUE; 891 } 892 #ifdef HAVE_INPUT_METHOD 893 save_smd = p_smd; 894 p_smd = FALSE; // Don't let the IM code show the mode here 895 if (lang && curbuf->b_p_iminsert == B_IMODE_IM) 896 im_set_active(TRUE); 897 #endif 898 899 *cp = plain_vgetc(); 900 901 if (langmap_active) 902 { 903 // Undo the decrement done above 904 ++no_mapping; 905 ++allow_keys; 906 State = NORMAL_BUSY; 907 } 908 #ifdef HAVE_INPUT_METHOD 909 if (lang) 910 { 911 if (curbuf->b_p_iminsert != B_IMODE_LMAP) 912 im_save_status(&curbuf->b_p_iminsert); 913 im_set_active(FALSE); 914 } 915 p_smd = save_smd; 916 #endif 917 State = NORMAL_BUSY; 918 #ifdef FEAT_CMDL_INFO 919 need_flushbuf |= add_to_showcmd(*cp); 920 #endif 921 922 if (!lit) 923 { 924 #ifdef FEAT_DIGRAPHS 925 // Typing CTRL-K gets a digraph. 926 if (*cp == Ctrl_K 927 && ((nv_cmds[idx].cmd_flags & NV_LANG) 928 || cp == &ca.extra_char) 929 && vim_strchr(p_cpo, CPO_DIGRAPH) == NULL) 930 { 931 c = get_digraph(FALSE); 932 if (c > 0) 933 { 934 *cp = c; 935 # ifdef FEAT_CMDL_INFO 936 // Guessing how to update showcmd here... 937 del_from_showcmd(3); 938 need_flushbuf |= add_to_showcmd(*cp); 939 # endif 940 } 941 } 942 #endif 943 944 // adjust chars > 127, except after "tTfFr" commands 945 LANGMAP_ADJUST(*cp, !lang); 946 #ifdef FEAT_RIGHTLEFT 947 // adjust Hebrew mapped char 948 if (p_hkmap && lang && KeyTyped) 949 *cp = hkmap(*cp); 950 #endif 951 } 952 953 /* 954 * When the next character is CTRL-\ a following CTRL-N means the 955 * command is aborted and we go to Normal mode. 956 */ 957 if (cp == &ca.extra_char 958 && ca.nchar == Ctrl_BSL 959 && (ca.extra_char == Ctrl_N || ca.extra_char == Ctrl_G)) 960 { 961 ca.cmdchar = Ctrl_BSL; 962 ca.nchar = ca.extra_char; 963 idx = find_command(ca.cmdchar); 964 } 965 else if ((ca.nchar == 'n' || ca.nchar == 'N') && ca.cmdchar == 'g') 966 ca.oap->op_type = get_op_type(*cp, NUL); 967 else if (*cp == Ctrl_BSL) 968 { 969 long towait = (p_ttm >= 0 ? p_ttm : p_tm); 970 971 // There is a busy wait here when typing "f<C-\>" and then 972 // something different from CTRL-N. Can't be avoided. 973 while ((c = vpeekc()) <= 0 && towait > 0L) 974 { 975 do_sleep(towait > 50L ? 50L : towait); 976 towait -= 50L; 977 } 978 if (c > 0) 979 { 980 c = plain_vgetc(); 981 if (c != Ctrl_N && c != Ctrl_G) 982 vungetc(c); 983 else 984 { 985 ca.cmdchar = Ctrl_BSL; 986 ca.nchar = c; 987 idx = find_command(ca.cmdchar); 988 } 989 } 990 } 991 992 // When getting a text character and the next character is a 993 // multi-byte character, it could be a composing character. 994 // However, don't wait for it to arrive. Also, do enable mapping, 995 // because if it's put back with vungetc() it's too late to apply 996 // mapping. 997 --no_mapping; 998 while (enc_utf8 && lang && (c = vpeekc()) > 0 999 && (c >= 0x100 || MB_BYTE2LEN(vpeekc()) > 1)) 1000 { 1001 c = plain_vgetc(); 1002 if (!utf_iscomposing(c)) 1003 { 1004 vungetc(c); // it wasn't, put it back 1005 break; 1006 } 1007 else if (ca.ncharC1 == 0) 1008 ca.ncharC1 = c; 1009 else 1010 ca.ncharC2 = c; 1011 } 1012 ++no_mapping; 1013 } 1014 --no_mapping; 1015 --allow_keys; 1016 } 1017 1018 #ifdef FEAT_CMDL_INFO 1019 /* 1020 * Flush the showcmd characters onto the screen so we can see them while 1021 * the command is being executed. Only do this when the shown command was 1022 * actually displayed, otherwise this will slow down a lot when executing 1023 * mappings. 1024 */ 1025 if (need_flushbuf) 1026 out_flush(); 1027 #endif 1028 if (ca.cmdchar != K_IGNORE) 1029 { 1030 if (ex_normal_busy) 1031 did_cursorhold = save_did_cursorhold; 1032 else 1033 did_cursorhold = FALSE; 1034 } 1035 1036 State = NORMAL; 1037 1038 if (ca.nchar == ESC) 1039 { 1040 clearop(oap); 1041 if (restart_edit == 0 && goto_im()) 1042 restart_edit = 'a'; 1043 goto normal_end; 1044 } 1045 1046 if (ca.cmdchar != K_IGNORE) 1047 { 1048 msg_didout = FALSE; // don't scroll screen up for normal command 1049 msg_col = 0; 1050 } 1051 1052 old_pos = curwin->w_cursor; // remember where cursor was 1053 1054 // When 'keymodel' contains "startsel" some keys start Select/Visual 1055 // mode. 1056 if (!VIsual_active && km_startsel) 1057 { 1058 if (nv_cmds[idx].cmd_flags & NV_SS) 1059 { 1060 start_selection(); 1061 unshift_special(&ca); 1062 idx = find_command(ca.cmdchar); 1063 } 1064 else if ((nv_cmds[idx].cmd_flags & NV_SSS) 1065 && (mod_mask & MOD_MASK_SHIFT)) 1066 { 1067 start_selection(); 1068 mod_mask &= ~MOD_MASK_SHIFT; 1069 } 1070 } 1071 1072 /* 1073 * Execute the command! 1074 * Call the command function found in the commands table. 1075 */ 1076 ca.arg = nv_cmds[idx].cmd_arg; 1077 (nv_cmds[idx].cmd_func)(&ca); 1078 1079 /* 1080 * If we didn't start or finish an operator, reset oap->regname, unless we 1081 * need it later. 1082 */ 1083 if (!finish_op 1084 && !oap->op_type 1085 && (idx < 0 || !(nv_cmds[idx].cmd_flags & NV_KEEPREG))) 1086 { 1087 clearop(oap); 1088 #ifdef FEAT_EVAL 1089 reset_reg_var(); 1090 #endif 1091 } 1092 1093 // Get the length of mapped chars again after typing a count, second 1094 // character or "z333<cr>". 1095 if (old_mapped_len > 0) 1096 old_mapped_len = typebuf_maplen(); 1097 1098 /* 1099 * If an operation is pending, handle it. But not for K_IGNORE. 1100 */ 1101 if (ca.cmdchar != K_IGNORE) 1102 do_pending_operator(&ca, old_col, FALSE); 1103 1104 /* 1105 * Wait for a moment when a message is displayed that will be overwritten 1106 * by the mode message. 1107 * In Visual mode and with "^O" in Insert mode, a short message will be 1108 * overwritten by the mode message. Wait a bit, until a key is hit. 1109 * In Visual mode, it's more important to keep the Visual area updated 1110 * than keeping a message (e.g. from a /pat search). 1111 * Only do this if the command was typed, not from a mapping. 1112 * Don't wait when emsg_silent is non-zero. 1113 * Also wait a bit after an error message, e.g. for "^O:". 1114 * Don't redraw the screen, it would remove the message. 1115 */ 1116 if ( ((p_smd 1117 && msg_silent == 0 1118 && (restart_edit != 0 1119 || (VIsual_active 1120 && old_pos.lnum == curwin->w_cursor.lnum 1121 && old_pos.col == curwin->w_cursor.col) 1122 ) 1123 && (clear_cmdline 1124 || redraw_cmdline) 1125 && (msg_didout || (msg_didany && msg_scroll)) 1126 && !msg_nowait 1127 && KeyTyped) 1128 || (restart_edit != 0 1129 && !VIsual_active 1130 && (msg_scroll 1131 || emsg_on_display))) 1132 && oap->regname == 0 1133 && !(ca.retval & CA_COMMAND_BUSY) 1134 && stuff_empty() 1135 && typebuf_typed() 1136 && emsg_silent == 0 1137 && !did_wait_return 1138 && oap->op_type == OP_NOP) 1139 { 1140 int save_State = State; 1141 1142 // Draw the cursor with the right shape here 1143 if (restart_edit != 0) 1144 State = INSERT; 1145 1146 // If need to redraw, and there is a "keep_msg", redraw before the 1147 // delay 1148 if (must_redraw && keep_msg != NULL && !emsg_on_display) 1149 { 1150 char_u *kmsg; 1151 1152 kmsg = keep_msg; 1153 keep_msg = NULL; 1154 // Showmode() will clear keep_msg, but we want to use it anyway. 1155 // First update w_topline. 1156 setcursor(); 1157 update_screen(0); 1158 // now reset it, otherwise it's put in the history again 1159 keep_msg = kmsg; 1160 1161 kmsg = vim_strsave(keep_msg); 1162 if (kmsg != NULL) 1163 { 1164 msg_attr((char *)kmsg, keep_msg_attr); 1165 vim_free(kmsg); 1166 } 1167 } 1168 setcursor(); 1169 #ifdef CURSOR_SHAPE 1170 ui_cursor_shape(); // may show different cursor shape 1171 #endif 1172 cursor_on(); 1173 out_flush(); 1174 if (msg_scroll || emsg_on_display) 1175 ui_delay(1003L, TRUE); // wait at least one second 1176 ui_delay(3003L, FALSE); // wait up to three seconds 1177 State = save_State; 1178 1179 msg_scroll = FALSE; 1180 emsg_on_display = FALSE; 1181 } 1182 1183 /* 1184 * Finish up after executing a Normal mode command. 1185 */ 1186 normal_end: 1187 1188 msg_nowait = FALSE; 1189 1190 #ifdef FEAT_EVAL 1191 if (finish_op) 1192 reset_reg_var(); 1193 #endif 1194 1195 // Reset finish_op, in case it was set 1196 #ifdef CURSOR_SHAPE 1197 c = finish_op; 1198 #endif 1199 finish_op = FALSE; 1200 #ifdef CURSOR_SHAPE 1201 // Redraw the cursor with another shape, if we were in Operator-pending 1202 // mode or did a replace command. 1203 if (c || ca.cmdchar == 'r') 1204 { 1205 ui_cursor_shape(); // may show different cursor shape 1206 # ifdef FEAT_MOUSESHAPE 1207 update_mouseshape(-1); 1208 # endif 1209 } 1210 #endif 1211 1212 #ifdef FEAT_CMDL_INFO 1213 if (oap->op_type == OP_NOP && oap->regname == 0 1214 && ca.cmdchar != K_CURSORHOLD) 1215 clear_showcmd(); 1216 #endif 1217 1218 checkpcmark(); // check if we moved since setting pcmark 1219 vim_free(ca.searchbuf); 1220 1221 if (has_mbyte) 1222 mb_adjust_cursor(); 1223 1224 if (curwin->w_p_scb && toplevel) 1225 { 1226 validate_cursor(); // may need to update w_leftcol 1227 do_check_scrollbind(TRUE); 1228 } 1229 1230 if (curwin->w_p_crb && toplevel) 1231 { 1232 validate_cursor(); // may need to update w_leftcol 1233 do_check_cursorbind(); 1234 } 1235 1236 #ifdef FEAT_TERMINAL 1237 // don't go to Insert mode if a terminal has a running job 1238 if (term_job_running(curbuf->b_term)) 1239 restart_edit = 0; 1240 #endif 1241 1242 /* 1243 * May restart edit(), if we got here with CTRL-O in Insert mode (but not 1244 * if still inside a mapping that started in Visual mode). 1245 * May switch from Visual to Select mode after CTRL-O command. 1246 */ 1247 if ( oap->op_type == OP_NOP 1248 && ((restart_edit != 0 && !VIsual_active && old_mapped_len == 0) 1249 || restart_VIsual_select == 1) 1250 && !(ca.retval & CA_COMMAND_BUSY) 1251 && stuff_empty() 1252 && oap->regname == 0) 1253 { 1254 if (restart_VIsual_select == 1) 1255 { 1256 VIsual_select = TRUE; 1257 showmode(); 1258 restart_VIsual_select = 0; 1259 } 1260 if (restart_edit != 0 && !VIsual_active && old_mapped_len == 0) 1261 (void)edit(restart_edit, FALSE, 1L); 1262 } 1263 1264 if (restart_VIsual_select == 2) 1265 restart_VIsual_select = 1; 1266 1267 // Save count before an operator for next time. 1268 opcount = ca.opcount; 1269 } 1270 1271 #ifdef FEAT_EVAL 1272 /* 1273 * Set v:count and v:count1 according to "cap". 1274 * Set v:prevcount only when "set_prevcount" is TRUE. 1275 */ 1276 static void 1277 set_vcount_ca(cmdarg_T *cap, int *set_prevcount) 1278 { 1279 long count = cap->count0; 1280 1281 // multiply with cap->opcount the same way as above 1282 if (cap->opcount != 0) 1283 count = cap->opcount * (count == 0 ? 1 : count); 1284 set_vcount(count, count == 0 ? 1 : count, *set_prevcount); 1285 *set_prevcount = FALSE; // only set v:prevcount once 1286 } 1287 #endif 1288 1289 /* 1290 * Check if highlighting for Visual mode is possible, give a warning message 1291 * if not. 1292 */ 1293 void 1294 check_visual_highlight(void) 1295 { 1296 static int did_check = FALSE; 1297 1298 if (full_screen) 1299 { 1300 if (!did_check && HL_ATTR(HLF_V) == 0) 1301 msg(_("Warning: terminal cannot highlight")); 1302 did_check = TRUE; 1303 } 1304 } 1305 1306 /* 1307 * End Visual mode. 1308 * This function should ALWAYS be called to end Visual mode, except from 1309 * do_pending_operator(). 1310 */ 1311 void 1312 end_visual_mode(void) 1313 { 1314 #ifdef FEAT_CLIPBOARD 1315 /* 1316 * If we are using the clipboard, then remember what was selected in case 1317 * we need to paste it somewhere while we still own the selection. 1318 * Only do this when the clipboard is already owned. Don't want to grab 1319 * the selection when hitting ESC. 1320 */ 1321 if (clip_star.available && clip_star.owned) 1322 clip_auto_select(); 1323 #endif 1324 1325 VIsual_active = FALSE; 1326 setmouse(); 1327 mouse_dragging = 0; 1328 1329 // Save the current VIsual area for '< and '> marks, and "gv" 1330 curbuf->b_visual.vi_mode = VIsual_mode; 1331 curbuf->b_visual.vi_start = VIsual; 1332 curbuf->b_visual.vi_end = curwin->w_cursor; 1333 curbuf->b_visual.vi_curswant = curwin->w_curswant; 1334 #ifdef FEAT_EVAL 1335 curbuf->b_visual_mode_eval = VIsual_mode; 1336 #endif 1337 if (!virtual_active()) 1338 curwin->w_cursor.coladd = 0; 1339 may_clear_cmdline(); 1340 1341 adjust_cursor_eol(); 1342 } 1343 1344 /* 1345 * Reset VIsual_active and VIsual_reselect. 1346 */ 1347 void 1348 reset_VIsual_and_resel(void) 1349 { 1350 if (VIsual_active) 1351 { 1352 end_visual_mode(); 1353 redraw_curbuf_later(INVERTED); // delete the inversion later 1354 } 1355 VIsual_reselect = FALSE; 1356 } 1357 1358 /* 1359 * Reset VIsual_active and VIsual_reselect if it's set. 1360 */ 1361 void 1362 reset_VIsual(void) 1363 { 1364 if (VIsual_active) 1365 { 1366 end_visual_mode(); 1367 redraw_curbuf_later(INVERTED); // delete the inversion later 1368 VIsual_reselect = FALSE; 1369 } 1370 } 1371 1372 void 1373 restore_visual_mode(void) 1374 { 1375 if (VIsual_mode_orig != NUL) 1376 { 1377 curbuf->b_visual.vi_mode = VIsual_mode_orig; 1378 VIsual_mode_orig = NUL; 1379 } 1380 } 1381 1382 /* 1383 * Check for a balloon-eval special item to include when searching for an 1384 * identifier. When "dir" is BACKWARD "ptr[-1]" must be valid! 1385 * Returns TRUE if the character at "*ptr" should be included. 1386 * "dir" is FORWARD or BACKWARD, the direction of searching. 1387 * "*colp" is in/decremented if "ptr[-dir]" should also be included. 1388 * "bnp" points to a counter for square brackets. 1389 */ 1390 static int 1391 find_is_eval_item( 1392 char_u *ptr, 1393 int *colp, 1394 int *bnp, 1395 int dir) 1396 { 1397 // Accept everything inside []. 1398 if ((*ptr == ']' && dir == BACKWARD) || (*ptr == '[' && dir == FORWARD)) 1399 ++*bnp; 1400 if (*bnp > 0) 1401 { 1402 if ((*ptr == '[' && dir == BACKWARD) || (*ptr == ']' && dir == FORWARD)) 1403 --*bnp; 1404 return TRUE; 1405 } 1406 1407 // skip over "s.var" 1408 if (*ptr == '.') 1409 return TRUE; 1410 1411 // two-character item: s->var 1412 if (ptr[dir == BACKWARD ? 0 : 1] == '>' 1413 && ptr[dir == BACKWARD ? -1 : 0] == '-') 1414 { 1415 *colp += dir; 1416 return TRUE; 1417 } 1418 return FALSE; 1419 } 1420 1421 /* 1422 * Find the identifier under or to the right of the cursor. 1423 * "find_type" can have one of three values: 1424 * FIND_IDENT: find an identifier (keyword) 1425 * FIND_STRING: find any non-white text 1426 * FIND_IDENT + FIND_STRING: find any non-white text, identifier preferred. 1427 * FIND_EVAL: find text useful for C program debugging 1428 * 1429 * There are three steps: 1430 * 1. Search forward for the start of an identifier/text. Doesn't move if 1431 * already on one. 1432 * 2. Search backward for the start of this identifier/text. 1433 * This doesn't match the real Vi but I like it a little better and it 1434 * shouldn't bother anyone. 1435 * 3. Search forward to the end of this identifier/text. 1436 * When FIND_IDENT isn't defined, we backup until a blank. 1437 * 1438 * Returns the length of the text, or zero if no text is found. 1439 * If text is found, a pointer to the text is put in "*text". This 1440 * points into the current buffer line and is not always NUL terminated. 1441 */ 1442 int 1443 find_ident_under_cursor(char_u **text, int find_type) 1444 { 1445 return find_ident_at_pos(curwin, curwin->w_cursor.lnum, 1446 curwin->w_cursor.col, text, NULL, find_type); 1447 } 1448 1449 /* 1450 * Like find_ident_under_cursor(), but for any window and any position. 1451 * However: Uses 'iskeyword' from the current window!. 1452 */ 1453 int 1454 find_ident_at_pos( 1455 win_T *wp, 1456 linenr_T lnum, 1457 colnr_T startcol, 1458 char_u **text, 1459 int *textcol, // column where "text" starts, can be NULL 1460 int find_type) 1461 { 1462 char_u *ptr; 1463 int col = 0; // init to shut up GCC 1464 int i; 1465 int this_class = 0; 1466 int prev_class; 1467 int prevcol; 1468 int bn = 0; // bracket nesting 1469 1470 /* 1471 * if i == 0: try to find an identifier 1472 * if i == 1: try to find any non-white text 1473 */ 1474 ptr = ml_get_buf(wp->w_buffer, lnum, FALSE); 1475 for (i = (find_type & FIND_IDENT) ? 0 : 1; i < 2; ++i) 1476 { 1477 /* 1478 * 1. skip to start of identifier/text 1479 */ 1480 col = startcol; 1481 if (has_mbyte) 1482 { 1483 while (ptr[col] != NUL) 1484 { 1485 // Stop at a ']' to evaluate "a[x]". 1486 if ((find_type & FIND_EVAL) && ptr[col] == ']') 1487 break; 1488 this_class = mb_get_class(ptr + col); 1489 if (this_class != 0 && (i == 1 || this_class != 1)) 1490 break; 1491 col += (*mb_ptr2len)(ptr + col); 1492 } 1493 } 1494 else 1495 while (ptr[col] != NUL 1496 && (i == 0 ? !vim_iswordc(ptr[col]) : VIM_ISWHITE(ptr[col])) 1497 && (!(find_type & FIND_EVAL) || ptr[col] != ']') 1498 ) 1499 ++col; 1500 1501 // When starting on a ']' count it, so that we include the '['. 1502 bn = ptr[col] == ']'; 1503 1504 /* 1505 * 2. Back up to start of identifier/text. 1506 */ 1507 if (has_mbyte) 1508 { 1509 // Remember class of character under cursor. 1510 if ((find_type & FIND_EVAL) && ptr[col] == ']') 1511 this_class = mb_get_class((char_u *)"a"); 1512 else 1513 this_class = mb_get_class(ptr + col); 1514 while (col > 0 && this_class != 0) 1515 { 1516 prevcol = col - 1 - (*mb_head_off)(ptr, ptr + col - 1); 1517 prev_class = mb_get_class(ptr + prevcol); 1518 if (this_class != prev_class 1519 && (i == 0 1520 || prev_class == 0 1521 || (find_type & FIND_IDENT)) 1522 && (!(find_type & FIND_EVAL) 1523 || prevcol == 0 1524 || !find_is_eval_item(ptr + prevcol, &prevcol, 1525 &bn, BACKWARD)) 1526 ) 1527 break; 1528 col = prevcol; 1529 } 1530 1531 // If we don't want just any old text, or we've found an 1532 // identifier, stop searching. 1533 if (this_class > 2) 1534 this_class = 2; 1535 if (!(find_type & FIND_STRING) || this_class == 2) 1536 break; 1537 } 1538 else 1539 { 1540 while (col > 0 1541 && ((i == 0 1542 ? vim_iswordc(ptr[col - 1]) 1543 : (!VIM_ISWHITE(ptr[col - 1]) 1544 && (!(find_type & FIND_IDENT) 1545 || !vim_iswordc(ptr[col - 1])))) 1546 || ((find_type & FIND_EVAL) 1547 && col > 1 1548 && find_is_eval_item(ptr + col - 1, &col, 1549 &bn, BACKWARD)) 1550 )) 1551 --col; 1552 1553 // If we don't want just any old text, or we've found an 1554 // identifier, stop searching. 1555 if (!(find_type & FIND_STRING) || vim_iswordc(ptr[col])) 1556 break; 1557 } 1558 } 1559 1560 if (ptr[col] == NUL || (i == 0 1561 && (has_mbyte ? this_class != 2 : !vim_iswordc(ptr[col])))) 1562 { 1563 // didn't find an identifier or text 1564 if ((find_type & FIND_NOERROR) == 0) 1565 { 1566 if (find_type & FIND_STRING) 1567 emsg(_("E348: No string under cursor")); 1568 else 1569 emsg(_(e_noident)); 1570 } 1571 return 0; 1572 } 1573 ptr += col; 1574 *text = ptr; 1575 if (textcol != NULL) 1576 *textcol = col; 1577 1578 /* 1579 * 3. Find the end if the identifier/text. 1580 */ 1581 bn = 0; 1582 startcol -= col; 1583 col = 0; 1584 if (has_mbyte) 1585 { 1586 // Search for point of changing multibyte character class. 1587 this_class = mb_get_class(ptr); 1588 while (ptr[col] != NUL 1589 && ((i == 0 ? mb_get_class(ptr + col) == this_class 1590 : mb_get_class(ptr + col) != 0) 1591 || ((find_type & FIND_EVAL) 1592 && col <= (int)startcol 1593 && find_is_eval_item(ptr + col, &col, &bn, FORWARD)) 1594 )) 1595 col += (*mb_ptr2len)(ptr + col); 1596 } 1597 else 1598 while ((i == 0 ? vim_iswordc(ptr[col]) 1599 : (ptr[col] != NUL && !VIM_ISWHITE(ptr[col]))) 1600 || ((find_type & FIND_EVAL) 1601 && col <= (int)startcol 1602 && find_is_eval_item(ptr + col, &col, &bn, FORWARD)) 1603 ) 1604 ++col; 1605 1606 return col; 1607 } 1608 1609 /* 1610 * Prepare for redo of a normal command. 1611 */ 1612 static void 1613 prep_redo_cmd(cmdarg_T *cap) 1614 { 1615 prep_redo(cap->oap->regname, cap->count0, 1616 NUL, cap->cmdchar, NUL, NUL, cap->nchar); 1617 } 1618 1619 /* 1620 * Prepare for redo of any command. 1621 * Note that only the last argument can be a multi-byte char. 1622 */ 1623 void 1624 prep_redo( 1625 int regname, 1626 long num, 1627 int cmd1, 1628 int cmd2, 1629 int cmd3, 1630 int cmd4, 1631 int cmd5) 1632 { 1633 ResetRedobuff(); 1634 if (regname != 0) // yank from specified buffer 1635 { 1636 AppendCharToRedobuff('"'); 1637 AppendCharToRedobuff(regname); 1638 } 1639 if (num) 1640 AppendNumberToRedobuff(num); 1641 1642 if (cmd1 != NUL) 1643 AppendCharToRedobuff(cmd1); 1644 if (cmd2 != NUL) 1645 AppendCharToRedobuff(cmd2); 1646 if (cmd3 != NUL) 1647 AppendCharToRedobuff(cmd3); 1648 if (cmd4 != NUL) 1649 AppendCharToRedobuff(cmd4); 1650 if (cmd5 != NUL) 1651 AppendCharToRedobuff(cmd5); 1652 } 1653 1654 /* 1655 * check for operator active and clear it 1656 * 1657 * return TRUE if operator was active 1658 */ 1659 static int 1660 checkclearop(oparg_T *oap) 1661 { 1662 if (oap->op_type == OP_NOP) 1663 return FALSE; 1664 clearopbeep(oap); 1665 return TRUE; 1666 } 1667 1668 /* 1669 * Check for operator or Visual active. Clear active operator. 1670 * 1671 * Return TRUE if operator or Visual was active. 1672 */ 1673 static int 1674 checkclearopq(oparg_T *oap) 1675 { 1676 if (oap->op_type == OP_NOP && !VIsual_active) 1677 return FALSE; 1678 clearopbeep(oap); 1679 return TRUE; 1680 } 1681 1682 void 1683 clearop(oparg_T *oap) 1684 { 1685 oap->op_type = OP_NOP; 1686 oap->regname = 0; 1687 oap->motion_force = NUL; 1688 oap->use_reg_one = FALSE; 1689 } 1690 1691 void 1692 clearopbeep(oparg_T *oap) 1693 { 1694 clearop(oap); 1695 beep_flush(); 1696 } 1697 1698 /* 1699 * Remove the shift modifier from a special key. 1700 */ 1701 static void 1702 unshift_special(cmdarg_T *cap) 1703 { 1704 switch (cap->cmdchar) 1705 { 1706 case K_S_RIGHT: cap->cmdchar = K_RIGHT; break; 1707 case K_S_LEFT: cap->cmdchar = K_LEFT; break; 1708 case K_S_UP: cap->cmdchar = K_UP; break; 1709 case K_S_DOWN: cap->cmdchar = K_DOWN; break; 1710 case K_S_HOME: cap->cmdchar = K_HOME; break; 1711 case K_S_END: cap->cmdchar = K_END; break; 1712 } 1713 cap->cmdchar = simplify_key(cap->cmdchar, &mod_mask); 1714 } 1715 1716 /* 1717 * If the mode is currently displayed clear the command line or update the 1718 * command displayed. 1719 */ 1720 void 1721 may_clear_cmdline(void) 1722 { 1723 if (mode_displayed) 1724 clear_cmdline = TRUE; // unshow visual mode later 1725 #ifdef FEAT_CMDL_INFO 1726 else 1727 clear_showcmd(); 1728 #endif 1729 } 1730 1731 #if defined(FEAT_CMDL_INFO) || defined(PROTO) 1732 /* 1733 * Routines for displaying a partly typed command 1734 */ 1735 1736 #define SHOWCMD_BUFLEN SHOWCMD_COLS + 1 + 30 1737 static char_u showcmd_buf[SHOWCMD_BUFLEN]; 1738 static char_u old_showcmd_buf[SHOWCMD_BUFLEN]; // For push_showcmd() 1739 static int showcmd_is_clear = TRUE; 1740 static int showcmd_visual = FALSE; 1741 1742 static void display_showcmd(void); 1743 1744 void 1745 clear_showcmd(void) 1746 { 1747 if (!p_sc) 1748 return; 1749 1750 if (VIsual_active && !char_avail()) 1751 { 1752 int cursor_bot = LT_POS(VIsual, curwin->w_cursor); 1753 long lines; 1754 colnr_T leftcol, rightcol; 1755 linenr_T top, bot; 1756 1757 // Show the size of the Visual area. 1758 if (cursor_bot) 1759 { 1760 top = VIsual.lnum; 1761 bot = curwin->w_cursor.lnum; 1762 } 1763 else 1764 { 1765 top = curwin->w_cursor.lnum; 1766 bot = VIsual.lnum; 1767 } 1768 # ifdef FEAT_FOLDING 1769 // Include closed folds as a whole. 1770 (void)hasFolding(top, &top, NULL); 1771 (void)hasFolding(bot, NULL, &bot); 1772 # endif 1773 lines = bot - top + 1; 1774 1775 if (VIsual_mode == Ctrl_V) 1776 { 1777 # ifdef FEAT_LINEBREAK 1778 char_u *saved_sbr = p_sbr; 1779 char_u *saved_w_sbr = curwin->w_p_sbr; 1780 1781 // Make 'sbr' empty for a moment to get the correct size. 1782 p_sbr = empty_option; 1783 curwin->w_p_sbr = empty_option; 1784 # endif 1785 getvcols(curwin, &curwin->w_cursor, &VIsual, &leftcol, &rightcol); 1786 # ifdef FEAT_LINEBREAK 1787 p_sbr = saved_sbr; 1788 curwin->w_p_sbr = saved_w_sbr; 1789 # endif 1790 sprintf((char *)showcmd_buf, "%ldx%ld", lines, 1791 (long)(rightcol - leftcol + 1)); 1792 } 1793 else if (VIsual_mode == 'V' || VIsual.lnum != curwin->w_cursor.lnum) 1794 sprintf((char *)showcmd_buf, "%ld", lines); 1795 else 1796 { 1797 char_u *s, *e; 1798 int l; 1799 int bytes = 0; 1800 int chars = 0; 1801 1802 if (cursor_bot) 1803 { 1804 s = ml_get_pos(&VIsual); 1805 e = ml_get_cursor(); 1806 } 1807 else 1808 { 1809 s = ml_get_cursor(); 1810 e = ml_get_pos(&VIsual); 1811 } 1812 while ((*p_sel != 'e') ? s <= e : s < e) 1813 { 1814 l = (*mb_ptr2len)(s); 1815 if (l == 0) 1816 { 1817 ++bytes; 1818 ++chars; 1819 break; // end of line 1820 } 1821 bytes += l; 1822 ++chars; 1823 s += l; 1824 } 1825 if (bytes == chars) 1826 sprintf((char *)showcmd_buf, "%d", chars); 1827 else 1828 sprintf((char *)showcmd_buf, "%d-%d", chars, bytes); 1829 } 1830 showcmd_buf[SHOWCMD_COLS] = NUL; // truncate 1831 showcmd_visual = TRUE; 1832 } 1833 else 1834 { 1835 showcmd_buf[0] = NUL; 1836 showcmd_visual = FALSE; 1837 1838 // Don't actually display something if there is nothing to clear. 1839 if (showcmd_is_clear) 1840 return; 1841 } 1842 1843 display_showcmd(); 1844 } 1845 1846 /* 1847 * Add 'c' to string of shown command chars. 1848 * Return TRUE if output has been written (and setcursor() has been called). 1849 */ 1850 int 1851 add_to_showcmd(int c) 1852 { 1853 char_u *p; 1854 int old_len; 1855 int extra_len; 1856 int overflow; 1857 int i; 1858 static int ignore[] = 1859 { 1860 #ifdef FEAT_GUI 1861 K_VER_SCROLLBAR, K_HOR_SCROLLBAR, 1862 K_LEFTMOUSE_NM, K_LEFTRELEASE_NM, 1863 #endif 1864 K_IGNORE, K_PS, 1865 K_LEFTMOUSE, K_LEFTDRAG, K_LEFTRELEASE, K_MOUSEMOVE, 1866 K_MIDDLEMOUSE, K_MIDDLEDRAG, K_MIDDLERELEASE, 1867 K_RIGHTMOUSE, K_RIGHTDRAG, K_RIGHTRELEASE, 1868 K_MOUSEDOWN, K_MOUSEUP, K_MOUSELEFT, K_MOUSERIGHT, 1869 K_X1MOUSE, K_X1DRAG, K_X1RELEASE, K_X2MOUSE, K_X2DRAG, K_X2RELEASE, 1870 K_CURSORHOLD, 1871 0 1872 }; 1873 1874 if (!p_sc || msg_silent != 0) 1875 return FALSE; 1876 1877 if (showcmd_visual) 1878 { 1879 showcmd_buf[0] = NUL; 1880 showcmd_visual = FALSE; 1881 } 1882 1883 // Ignore keys that are scrollbar updates and mouse clicks 1884 if (IS_SPECIAL(c)) 1885 for (i = 0; ignore[i] != 0; ++i) 1886 if (ignore[i] == c) 1887 return FALSE; 1888 1889 p = transchar(c); 1890 if (*p == ' ') 1891 STRCPY(p, "<20>"); 1892 old_len = (int)STRLEN(showcmd_buf); 1893 extra_len = (int)STRLEN(p); 1894 overflow = old_len + extra_len - SHOWCMD_COLS; 1895 if (overflow > 0) 1896 mch_memmove(showcmd_buf, showcmd_buf + overflow, 1897 old_len - overflow + 1); 1898 STRCAT(showcmd_buf, p); 1899 1900 if (char_avail()) 1901 return FALSE; 1902 1903 display_showcmd(); 1904 1905 return TRUE; 1906 } 1907 1908 void 1909 add_to_showcmd_c(int c) 1910 { 1911 if (!add_to_showcmd(c)) 1912 setcursor(); 1913 } 1914 1915 /* 1916 * Delete 'len' characters from the end of the shown command. 1917 */ 1918 static void 1919 del_from_showcmd(int len) 1920 { 1921 int old_len; 1922 1923 if (!p_sc) 1924 return; 1925 1926 old_len = (int)STRLEN(showcmd_buf); 1927 if (len > old_len) 1928 len = old_len; 1929 showcmd_buf[old_len - len] = NUL; 1930 1931 if (!char_avail()) 1932 display_showcmd(); 1933 } 1934 1935 /* 1936 * push_showcmd() and pop_showcmd() are used when waiting for the user to type 1937 * something and there is a partial mapping. 1938 */ 1939 void 1940 push_showcmd(void) 1941 { 1942 if (p_sc) 1943 STRCPY(old_showcmd_buf, showcmd_buf); 1944 } 1945 1946 void 1947 pop_showcmd(void) 1948 { 1949 if (!p_sc) 1950 return; 1951 1952 STRCPY(showcmd_buf, old_showcmd_buf); 1953 1954 display_showcmd(); 1955 } 1956 1957 static void 1958 display_showcmd(void) 1959 { 1960 int len; 1961 1962 cursor_off(); 1963 1964 len = (int)STRLEN(showcmd_buf); 1965 if (len == 0) 1966 showcmd_is_clear = TRUE; 1967 else 1968 { 1969 screen_puts(showcmd_buf, (int)Rows - 1, sc_col, 0); 1970 showcmd_is_clear = FALSE; 1971 } 1972 1973 /* 1974 * clear the rest of an old message by outputting up to SHOWCMD_COLS 1975 * spaces 1976 */ 1977 screen_puts((char_u *)" " + len, (int)Rows - 1, sc_col + len, 0); 1978 1979 setcursor(); // put cursor back where it belongs 1980 } 1981 #endif 1982 1983 /* 1984 * When "check" is FALSE, prepare for commands that scroll the window. 1985 * When "check" is TRUE, take care of scroll-binding after the window has 1986 * scrolled. Called from normal_cmd() and edit(). 1987 */ 1988 void 1989 do_check_scrollbind(int check) 1990 { 1991 static win_T *old_curwin = NULL; 1992 static linenr_T old_topline = 0; 1993 #ifdef FEAT_DIFF 1994 static int old_topfill = 0; 1995 #endif 1996 static buf_T *old_buf = NULL; 1997 static colnr_T old_leftcol = 0; 1998 1999 if (check && curwin->w_p_scb) 2000 { 2001 // If a ":syncbind" command was just used, don't scroll, only reset 2002 // the values. 2003 if (did_syncbind) 2004 did_syncbind = FALSE; 2005 else if (curwin == old_curwin) 2006 { 2007 /* 2008 * Synchronize other windows, as necessary according to 2009 * 'scrollbind'. Don't do this after an ":edit" command, except 2010 * when 'diff' is set. 2011 */ 2012 if ((curwin->w_buffer == old_buf 2013 #ifdef FEAT_DIFF 2014 || curwin->w_p_diff 2015 #endif 2016 ) 2017 && (curwin->w_topline != old_topline 2018 #ifdef FEAT_DIFF 2019 || curwin->w_topfill != old_topfill 2020 #endif 2021 || curwin->w_leftcol != old_leftcol)) 2022 { 2023 check_scrollbind(curwin->w_topline - old_topline, 2024 (long)(curwin->w_leftcol - old_leftcol)); 2025 } 2026 } 2027 else if (vim_strchr(p_sbo, 'j')) // jump flag set in 'scrollopt' 2028 { 2029 /* 2030 * When switching between windows, make sure that the relative 2031 * vertical offset is valid for the new window. The relative 2032 * offset is invalid whenever another 'scrollbind' window has 2033 * scrolled to a point that would force the current window to 2034 * scroll past the beginning or end of its buffer. When the 2035 * resync is performed, some of the other 'scrollbind' windows may 2036 * need to jump so that the current window's relative position is 2037 * visible on-screen. 2038 */ 2039 check_scrollbind(curwin->w_topline - curwin->w_scbind_pos, 0L); 2040 } 2041 curwin->w_scbind_pos = curwin->w_topline; 2042 } 2043 2044 old_curwin = curwin; 2045 old_topline = curwin->w_topline; 2046 #ifdef FEAT_DIFF 2047 old_topfill = curwin->w_topfill; 2048 #endif 2049 old_buf = curwin->w_buffer; 2050 old_leftcol = curwin->w_leftcol; 2051 } 2052 2053 /* 2054 * Synchronize any windows that have "scrollbind" set, based on the 2055 * number of rows by which the current window has changed 2056 * (1998-11-02 16:21:01 R. Edward Ralston <[email protected]>) 2057 */ 2058 void 2059 check_scrollbind(linenr_T topline_diff, long leftcol_diff) 2060 { 2061 int want_ver; 2062 int want_hor; 2063 win_T *old_curwin = curwin; 2064 buf_T *old_curbuf = curbuf; 2065 int old_VIsual_select = VIsual_select; 2066 int old_VIsual_active = VIsual_active; 2067 colnr_T tgt_leftcol = curwin->w_leftcol; 2068 long topline; 2069 long y; 2070 2071 /* 2072 * check 'scrollopt' string for vertical and horizontal scroll options 2073 */ 2074 want_ver = (vim_strchr(p_sbo, 'v') && topline_diff != 0); 2075 #ifdef FEAT_DIFF 2076 want_ver |= old_curwin->w_p_diff; 2077 #endif 2078 want_hor = (vim_strchr(p_sbo, 'h') && (leftcol_diff || topline_diff != 0)); 2079 2080 /* 2081 * loop through the scrollbound windows and scroll accordingly 2082 */ 2083 VIsual_select = VIsual_active = 0; 2084 FOR_ALL_WINDOWS(curwin) 2085 { 2086 curbuf = curwin->w_buffer; 2087 // skip original window and windows with 'noscrollbind' 2088 if (curwin != old_curwin && curwin->w_p_scb) 2089 { 2090 /* 2091 * do the vertical scroll 2092 */ 2093 if (want_ver) 2094 { 2095 #ifdef FEAT_DIFF 2096 if (old_curwin->w_p_diff && curwin->w_p_diff) 2097 { 2098 diff_set_topline(old_curwin, curwin); 2099 } 2100 else 2101 #endif 2102 { 2103 curwin->w_scbind_pos += topline_diff; 2104 topline = curwin->w_scbind_pos; 2105 if (topline > curbuf->b_ml.ml_line_count) 2106 topline = curbuf->b_ml.ml_line_count; 2107 if (topline < 1) 2108 topline = 1; 2109 2110 y = topline - curwin->w_topline; 2111 if (y > 0) 2112 scrollup(y, FALSE); 2113 else 2114 scrolldown(-y, FALSE); 2115 } 2116 2117 redraw_later(VALID); 2118 cursor_correct(); 2119 curwin->w_redr_status = TRUE; 2120 } 2121 2122 /* 2123 * do the horizontal scroll 2124 */ 2125 if (want_hor && curwin->w_leftcol != tgt_leftcol) 2126 { 2127 curwin->w_leftcol = tgt_leftcol; 2128 leftcol_changed(); 2129 } 2130 } 2131 } 2132 2133 /* 2134 * reset current-window 2135 */ 2136 VIsual_select = old_VIsual_select; 2137 VIsual_active = old_VIsual_active; 2138 curwin = old_curwin; 2139 curbuf = old_curbuf; 2140 } 2141 2142 /* 2143 * Command character that's ignored. 2144 * Used for CTRL-Q and CTRL-S to avoid problems with terminals that use 2145 * xon/xoff. 2146 */ 2147 static void 2148 nv_ignore(cmdarg_T *cap) 2149 { 2150 cap->retval |= CA_COMMAND_BUSY; // don't call edit() now 2151 } 2152 2153 /* 2154 * Command character that doesn't do anything, but unlike nv_ignore() does 2155 * start edit(). Used for "startinsert" executed while starting up. 2156 */ 2157 static void 2158 nv_nop(cmdarg_T *cap UNUSED) 2159 { 2160 } 2161 2162 /* 2163 * Command character doesn't exist. 2164 */ 2165 static void 2166 nv_error(cmdarg_T *cap) 2167 { 2168 clearopbeep(cap->oap); 2169 } 2170 2171 /* 2172 * <Help> and <F1> commands. 2173 */ 2174 static void 2175 nv_help(cmdarg_T *cap) 2176 { 2177 if (!checkclearopq(cap->oap)) 2178 ex_help(NULL); 2179 } 2180 2181 /* 2182 * CTRL-A and CTRL-X: Add or subtract from letter or number under cursor. 2183 */ 2184 static void 2185 nv_addsub(cmdarg_T *cap) 2186 { 2187 #ifdef FEAT_JOB_CHANNEL 2188 if (bt_prompt(curbuf) && !prompt_curpos_editable()) 2189 clearopbeep(cap->oap); 2190 else 2191 #endif 2192 if (!VIsual_active && cap->oap->op_type == OP_NOP) 2193 { 2194 prep_redo_cmd(cap); 2195 cap->oap->op_type = cap->cmdchar == Ctrl_A ? OP_NR_ADD : OP_NR_SUB; 2196 op_addsub(cap->oap, cap->count1, cap->arg); 2197 cap->oap->op_type = OP_NOP; 2198 } 2199 else if (VIsual_active) 2200 nv_operator(cap); 2201 else 2202 clearop(cap->oap); 2203 } 2204 2205 /* 2206 * CTRL-F, CTRL-B, etc: Scroll page up or down. 2207 */ 2208 static void 2209 nv_page(cmdarg_T *cap) 2210 { 2211 if (!checkclearop(cap->oap)) 2212 { 2213 if (mod_mask & MOD_MASK_CTRL) 2214 { 2215 // <C-PageUp>: tab page back; <C-PageDown>: tab page forward 2216 if (cap->arg == BACKWARD) 2217 goto_tabpage(-(int)cap->count1); 2218 else 2219 goto_tabpage((int)cap->count0); 2220 } 2221 else 2222 (void)onepage(cap->arg, cap->count1); 2223 } 2224 } 2225 2226 /* 2227 * Implementation of "gd" and "gD" command. 2228 */ 2229 static void 2230 nv_gd( 2231 oparg_T *oap, 2232 int nchar, 2233 int thisblock) // 1 for "1gd" and "1gD" 2234 { 2235 int len; 2236 char_u *ptr; 2237 2238 if ((len = find_ident_under_cursor(&ptr, FIND_IDENT)) == 0 2239 || find_decl(ptr, len, nchar == 'd', thisblock, SEARCH_START) 2240 == FAIL) 2241 clearopbeep(oap); 2242 #ifdef FEAT_FOLDING 2243 else if ((fdo_flags & FDO_SEARCH) && KeyTyped && oap->op_type == OP_NOP) 2244 foldOpenCursor(); 2245 #endif 2246 } 2247 2248 /* 2249 * Return TRUE if line[offset] is not inside a C-style comment or string, FALSE 2250 * otherwise. 2251 */ 2252 static int 2253 is_ident(char_u *line, int offset) 2254 { 2255 int i; 2256 int incomment = FALSE; 2257 int instring = 0; 2258 int prev = 0; 2259 2260 for (i = 0; i < offset && line[i] != NUL; i++) 2261 { 2262 if (instring != 0) 2263 { 2264 if (prev != '\\' && line[i] == instring) 2265 instring = 0; 2266 } 2267 else if ((line[i] == '"' || line[i] == '\'') && !incomment) 2268 { 2269 instring = line[i]; 2270 } 2271 else 2272 { 2273 if (incomment) 2274 { 2275 if (prev == '*' && line[i] == '/') 2276 incomment = FALSE; 2277 } 2278 else if (prev == '/' && line[i] == '*') 2279 { 2280 incomment = TRUE; 2281 } 2282 else if (prev == '/' && line[i] == '/') 2283 { 2284 return FALSE; 2285 } 2286 } 2287 2288 prev = line[i]; 2289 } 2290 2291 return incomment == FALSE && instring == 0; 2292 } 2293 2294 /* 2295 * Search for variable declaration of "ptr[len]". 2296 * When "locally" is TRUE in the current function ("gd"), otherwise in the 2297 * current file ("gD"). 2298 * When "thisblock" is TRUE check the {} block scope. 2299 * Return FAIL when not found. 2300 */ 2301 int 2302 find_decl( 2303 char_u *ptr, 2304 int len, 2305 int locally, 2306 int thisblock, 2307 int flags_arg) // flags passed to searchit() 2308 { 2309 char_u *pat; 2310 pos_T old_pos; 2311 pos_T par_pos; 2312 pos_T found_pos; 2313 int t; 2314 int save_p_ws; 2315 int save_p_scs; 2316 int retval = OK; 2317 int incll; 2318 int searchflags = flags_arg; 2319 int valid; 2320 2321 if ((pat = alloc(len + 7)) == NULL) 2322 return FAIL; 2323 2324 // Put "\V" before the pattern to avoid that the special meaning of "." 2325 // and "~" causes trouble. 2326 sprintf((char *)pat, vim_iswordp(ptr) ? "\\V\\<%.*s\\>" : "\\V%.*s", 2327 len, ptr); 2328 old_pos = curwin->w_cursor; 2329 save_p_ws = p_ws; 2330 save_p_scs = p_scs; 2331 p_ws = FALSE; // don't wrap around end of file now 2332 p_scs = FALSE; // don't switch ignorecase off now 2333 2334 /* 2335 * With "gD" go to line 1. 2336 * With "gd" Search back for the start of the current function, then go 2337 * back until a blank line. If this fails go to line 1. 2338 */ 2339 if (!locally || !findpar(&incll, BACKWARD, 1L, '{', FALSE)) 2340 { 2341 setpcmark(); // Set in findpar() otherwise 2342 curwin->w_cursor.lnum = 1; 2343 par_pos = curwin->w_cursor; 2344 } 2345 else 2346 { 2347 par_pos = curwin->w_cursor; 2348 while (curwin->w_cursor.lnum > 1 && *skipwhite(ml_get_curline()) != NUL) 2349 --curwin->w_cursor.lnum; 2350 } 2351 curwin->w_cursor.col = 0; 2352 2353 // Search forward for the identifier, ignore comment lines. 2354 CLEAR_POS(&found_pos); 2355 for (;;) 2356 { 2357 t = searchit(curwin, curbuf, &curwin->w_cursor, NULL, FORWARD, 2358 pat, 1L, searchflags, RE_LAST, NULL); 2359 if (curwin->w_cursor.lnum >= old_pos.lnum) 2360 t = FAIL; // match after start is failure too 2361 2362 if (thisblock && t != FAIL) 2363 { 2364 pos_T *pos; 2365 2366 // Check that the block the match is in doesn't end before the 2367 // position where we started the search from. 2368 if ((pos = findmatchlimit(NULL, '}', FM_FORWARD, 2369 (int)(old_pos.lnum - curwin->w_cursor.lnum + 1))) != NULL 2370 && pos->lnum < old_pos.lnum) 2371 { 2372 // There can't be a useful match before the end of this block. 2373 // Skip to the end. 2374 curwin->w_cursor = *pos; 2375 continue; 2376 } 2377 } 2378 2379 if (t == FAIL) 2380 { 2381 // If we previously found a valid position, use it. 2382 if (found_pos.lnum != 0) 2383 { 2384 curwin->w_cursor = found_pos; 2385 t = OK; 2386 } 2387 break; 2388 } 2389 if (get_leader_len(ml_get_curline(), NULL, FALSE, TRUE) > 0) 2390 { 2391 // Ignore this line, continue at start of next line. 2392 ++curwin->w_cursor.lnum; 2393 curwin->w_cursor.col = 0; 2394 continue; 2395 } 2396 valid = is_ident(ml_get_curline(), curwin->w_cursor.col); 2397 2398 // If the current position is not a valid identifier and a previous 2399 // match is present, favor that one instead. 2400 if (!valid && found_pos.lnum != 0) 2401 { 2402 curwin->w_cursor = found_pos; 2403 break; 2404 } 2405 2406 // Global search: use first valid match found 2407 if (valid && !locally) 2408 break; 2409 if (valid && curwin->w_cursor.lnum >= par_pos.lnum) 2410 { 2411 // If we previously found a valid position, use it. 2412 if (found_pos.lnum != 0) 2413 curwin->w_cursor = found_pos; 2414 break; 2415 } 2416 2417 // For finding a local variable and the match is before the "{" or 2418 // inside a comment, continue searching. For K&R style function 2419 // declarations this skips the function header without types. 2420 if (!valid) 2421 CLEAR_POS(&found_pos); 2422 else 2423 found_pos = curwin->w_cursor; 2424 // Remove SEARCH_START from flags to avoid getting stuck at one 2425 // position. 2426 searchflags &= ~SEARCH_START; 2427 } 2428 2429 if (t == FAIL) 2430 { 2431 retval = FAIL; 2432 curwin->w_cursor = old_pos; 2433 } 2434 else 2435 { 2436 curwin->w_set_curswant = TRUE; 2437 // "n" searches forward now 2438 reset_search_dir(); 2439 } 2440 2441 vim_free(pat); 2442 p_ws = save_p_ws; 2443 p_scs = save_p_scs; 2444 2445 return retval; 2446 } 2447 2448 /* 2449 * Move 'dist' lines in direction 'dir', counting lines by *screen* 2450 * lines rather than lines in the file. 2451 * 'dist' must be positive. 2452 * 2453 * Return OK if able to move cursor, FAIL otherwise. 2454 */ 2455 static int 2456 nv_screengo(oparg_T *oap, int dir, long dist) 2457 { 2458 int linelen = linetabsize(ml_get_curline()); 2459 int retval = OK; 2460 int atend = FALSE; 2461 int n; 2462 int col_off1; // margin offset for first screen line 2463 int col_off2; // margin offset for wrapped screen line 2464 int width1; // text width for first screen line 2465 int width2; // test width for wrapped screen line 2466 2467 oap->motion_type = MCHAR; 2468 oap->inclusive = (curwin->w_curswant == MAXCOL); 2469 2470 col_off1 = curwin_col_off(); 2471 col_off2 = col_off1 - curwin_col_off2(); 2472 width1 = curwin->w_width - col_off1; 2473 width2 = curwin->w_width - col_off2; 2474 if (width2 == 0) 2475 width2 = 1; // avoid divide by zero 2476 2477 if (curwin->w_width != 0) 2478 { 2479 /* 2480 * Instead of sticking at the last character of the buffer line we 2481 * try to stick in the last column of the screen. 2482 */ 2483 if (curwin->w_curswant == MAXCOL) 2484 { 2485 atend = TRUE; 2486 validate_virtcol(); 2487 if (width1 <= 0) 2488 curwin->w_curswant = 0; 2489 else 2490 { 2491 curwin->w_curswant = width1 - 1; 2492 if (curwin->w_virtcol > curwin->w_curswant) 2493 curwin->w_curswant += ((curwin->w_virtcol 2494 - curwin->w_curswant - 1) / width2 + 1) * width2; 2495 } 2496 } 2497 else 2498 { 2499 if (linelen > width1) 2500 n = ((linelen - width1 - 1) / width2 + 1) * width2 + width1; 2501 else 2502 n = width1; 2503 if (curwin->w_curswant >= (colnr_T)n) 2504 curwin->w_curswant = n - 1; 2505 } 2506 2507 while (dist--) 2508 { 2509 if (dir == BACKWARD) 2510 { 2511 if ((long)curwin->w_curswant >= width1) 2512 // Move back within the line. This can give a negative value 2513 // for w_curswant if width1 < width2 (with cpoptions+=n), 2514 // which will get clipped to column 0. 2515 curwin->w_curswant -= width2; 2516 else 2517 { 2518 // to previous line 2519 if (curwin->w_cursor.lnum == 1) 2520 { 2521 retval = FAIL; 2522 break; 2523 } 2524 --curwin->w_cursor.lnum; 2525 #ifdef FEAT_FOLDING 2526 // Move to the start of a closed fold. Don't do that when 2527 // 'foldopen' contains "all": it will open in a moment. 2528 if (!(fdo_flags & FDO_ALL)) 2529 (void)hasFolding(curwin->w_cursor.lnum, 2530 &curwin->w_cursor.lnum, NULL); 2531 #endif 2532 linelen = linetabsize(ml_get_curline()); 2533 if (linelen > width1) 2534 curwin->w_curswant += (((linelen - width1 - 1) / width2) 2535 + 1) * width2; 2536 } 2537 } 2538 else // dir == FORWARD 2539 { 2540 if (linelen > width1) 2541 n = ((linelen - width1 - 1) / width2 + 1) * width2 + width1; 2542 else 2543 n = width1; 2544 if (curwin->w_curswant + width2 < (colnr_T)n) 2545 // move forward within line 2546 curwin->w_curswant += width2; 2547 else 2548 { 2549 // to next line 2550 #ifdef FEAT_FOLDING 2551 // Move to the end of a closed fold. 2552 (void)hasFolding(curwin->w_cursor.lnum, NULL, 2553 &curwin->w_cursor.lnum); 2554 #endif 2555 if (curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count) 2556 { 2557 retval = FAIL; 2558 break; 2559 } 2560 curwin->w_cursor.lnum++; 2561 curwin->w_curswant %= width2; 2562 // Check if the cursor has moved below the number display 2563 // when width1 < width2 (with cpoptions+=n). Subtract width2 2564 // to get a negative value for w_curswant, which will get 2565 // clipped to column 0. 2566 if (curwin->w_curswant >= width1) 2567 curwin->w_curswant -= width2; 2568 linelen = linetabsize(ml_get_curline()); 2569 } 2570 } 2571 } 2572 } 2573 2574 if (virtual_active() && atend) 2575 coladvance(MAXCOL); 2576 else 2577 coladvance(curwin->w_curswant); 2578 2579 if (curwin->w_cursor.col > 0 && curwin->w_p_wrap) 2580 { 2581 colnr_T virtcol; 2582 2583 /* 2584 * Check for landing on a character that got split at the end of the 2585 * last line. We want to advance a screenline, not end up in the same 2586 * screenline or move two screenlines. 2587 */ 2588 validate_virtcol(); 2589 virtcol = curwin->w_virtcol; 2590 #if defined(FEAT_LINEBREAK) 2591 if (virtcol > (colnr_T)width1 && *get_showbreak_value(curwin) != NUL) 2592 virtcol -= vim_strsize(get_showbreak_value(curwin)); 2593 #endif 2594 2595 if (virtcol > curwin->w_curswant 2596 && (curwin->w_curswant < (colnr_T)width1 2597 ? (curwin->w_curswant > (colnr_T)width1 / 2) 2598 : ((curwin->w_curswant - width1) % width2 2599 > (colnr_T)width2 / 2))) 2600 --curwin->w_cursor.col; 2601 } 2602 2603 if (atend) 2604 curwin->w_curswant = MAXCOL; // stick in the last column 2605 2606 return retval; 2607 } 2608 2609 /* 2610 * Handle CTRL-E and CTRL-Y commands: scroll a line up or down. 2611 * cap->arg must be TRUE for CTRL-E. 2612 */ 2613 void 2614 nv_scroll_line(cmdarg_T *cap) 2615 { 2616 if (!checkclearop(cap->oap)) 2617 scroll_redraw(cap->arg, cap->count1); 2618 } 2619 2620 /* 2621 * Scroll "count" lines up or down, and redraw. 2622 */ 2623 void 2624 scroll_redraw(int up, long count) 2625 { 2626 linenr_T prev_topline = curwin->w_topline; 2627 #ifdef FEAT_DIFF 2628 int prev_topfill = curwin->w_topfill; 2629 #endif 2630 linenr_T prev_lnum = curwin->w_cursor.lnum; 2631 2632 if (up) 2633 scrollup(count, TRUE); 2634 else 2635 scrolldown(count, TRUE); 2636 if (get_scrolloff_value()) 2637 { 2638 // Adjust the cursor position for 'scrolloff'. Mark w_topline as 2639 // valid, otherwise the screen jumps back at the end of the file. 2640 cursor_correct(); 2641 check_cursor_moved(curwin); 2642 curwin->w_valid |= VALID_TOPLINE; 2643 2644 // If moved back to where we were, at least move the cursor, otherwise 2645 // we get stuck at one position. Don't move the cursor up if the 2646 // first line of the buffer is already on the screen 2647 while (curwin->w_topline == prev_topline 2648 #ifdef FEAT_DIFF 2649 && curwin->w_topfill == prev_topfill 2650 #endif 2651 ) 2652 { 2653 if (up) 2654 { 2655 if (curwin->w_cursor.lnum > prev_lnum 2656 || cursor_down(1L, FALSE) == FAIL) 2657 break; 2658 } 2659 else 2660 { 2661 if (curwin->w_cursor.lnum < prev_lnum 2662 || prev_topline == 1L 2663 || cursor_up(1L, FALSE) == FAIL) 2664 break; 2665 } 2666 // Mark w_topline as valid, otherwise the screen jumps back at the 2667 // end of the file. 2668 check_cursor_moved(curwin); 2669 curwin->w_valid |= VALID_TOPLINE; 2670 } 2671 } 2672 if (curwin->w_cursor.lnum != prev_lnum) 2673 coladvance(curwin->w_curswant); 2674 redraw_later(VALID); 2675 } 2676 2677 /* 2678 * Commands that start with "z". 2679 */ 2680 static void 2681 nv_zet(cmdarg_T *cap) 2682 { 2683 long n; 2684 colnr_T col; 2685 int nchar = cap->nchar; 2686 #ifdef FEAT_FOLDING 2687 long old_fdl = curwin->w_p_fdl; 2688 int old_fen = curwin->w_p_fen; 2689 #endif 2690 #ifdef FEAT_SPELL 2691 int undo = FALSE; 2692 #endif 2693 long siso = get_sidescrolloff_value(); 2694 2695 if (VIM_ISDIGIT(nchar)) 2696 { 2697 /* 2698 * "z123{nchar}": edit the count before obtaining {nchar} 2699 */ 2700 if (checkclearop(cap->oap)) 2701 return; 2702 n = nchar - '0'; 2703 for (;;) 2704 { 2705 #ifdef USE_ON_FLY_SCROLL 2706 dont_scroll = TRUE; // disallow scrolling here 2707 #endif 2708 ++no_mapping; 2709 ++allow_keys; // no mapping for nchar, but allow key codes 2710 nchar = plain_vgetc(); 2711 LANGMAP_ADJUST(nchar, TRUE); 2712 --no_mapping; 2713 --allow_keys; 2714 #ifdef FEAT_CMDL_INFO 2715 (void)add_to_showcmd(nchar); 2716 #endif 2717 if (nchar == K_DEL || nchar == K_KDEL) 2718 n /= 10; 2719 else if (VIM_ISDIGIT(nchar)) 2720 n = n * 10 + (nchar - '0'); 2721 else if (nchar == CAR) 2722 { 2723 #ifdef FEAT_GUI 2724 need_mouse_correct = TRUE; 2725 #endif 2726 win_setheight((int)n); 2727 break; 2728 } 2729 else if (nchar == 'l' 2730 || nchar == 'h' 2731 || nchar == K_LEFT 2732 || nchar == K_RIGHT) 2733 { 2734 cap->count1 = n ? n * cap->count1 : cap->count1; 2735 goto dozet; 2736 } 2737 else 2738 { 2739 clearopbeep(cap->oap); 2740 break; 2741 } 2742 } 2743 cap->oap->op_type = OP_NOP; 2744 return; 2745 } 2746 2747 dozet: 2748 if ( 2749 #ifdef FEAT_FOLDING 2750 // "zf" and "zF" are always an operator, "zd", "zo", "zO", "zc" 2751 // and "zC" only in Visual mode. "zj" and "zk" are motion 2752 // commands. 2753 cap->nchar != 'f' && cap->nchar != 'F' 2754 && !(VIsual_active && vim_strchr((char_u *)"dcCoO", cap->nchar)) 2755 && cap->nchar != 'j' && cap->nchar != 'k' 2756 && 2757 #endif 2758 checkclearop(cap->oap)) 2759 return; 2760 2761 /* 2762 * For "z+", "z<CR>", "zt", "z.", "zz", "z^", "z-", "zb": 2763 * If line number given, set cursor. 2764 */ 2765 if ((vim_strchr((char_u *)"+\r\nt.z^-b", nchar) != NULL) 2766 && cap->count0 2767 && cap->count0 != curwin->w_cursor.lnum) 2768 { 2769 setpcmark(); 2770 if (cap->count0 > curbuf->b_ml.ml_line_count) 2771 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; 2772 else 2773 curwin->w_cursor.lnum = cap->count0; 2774 check_cursor_col(); 2775 } 2776 2777 switch (nchar) 2778 { 2779 // "z+", "z<CR>" and "zt": put cursor at top of screen 2780 case '+': 2781 if (cap->count0 == 0) 2782 { 2783 // No count given: put cursor at the line below screen 2784 validate_botline(); // make sure w_botline is valid 2785 if (curwin->w_botline > curbuf->b_ml.ml_line_count) 2786 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; 2787 else 2788 curwin->w_cursor.lnum = curwin->w_botline; 2789 } 2790 // FALLTHROUGH 2791 case NL: 2792 case CAR: 2793 case K_KENTER: 2794 beginline(BL_WHITE | BL_FIX); 2795 // FALLTHROUGH 2796 2797 case 't': scroll_cursor_top(0, TRUE); 2798 redraw_later(VALID); 2799 set_fraction(curwin); 2800 break; 2801 2802 // "z." and "zz": put cursor in middle of screen 2803 case '.': beginline(BL_WHITE | BL_FIX); 2804 // FALLTHROUGH 2805 2806 case 'z': scroll_cursor_halfway(TRUE); 2807 redraw_later(VALID); 2808 set_fraction(curwin); 2809 break; 2810 2811 // "z^", "z-" and "zb": put cursor at bottom of screen 2812 case '^': // Strange Vi behavior: <count>z^ finds line at top of window 2813 // when <count> is at bottom of window, and puts that one at 2814 // bottom of window. 2815 if (cap->count0 != 0) 2816 { 2817 scroll_cursor_bot(0, TRUE); 2818 curwin->w_cursor.lnum = curwin->w_topline; 2819 } 2820 else if (curwin->w_topline == 1) 2821 curwin->w_cursor.lnum = 1; 2822 else 2823 curwin->w_cursor.lnum = curwin->w_topline - 1; 2824 // FALLTHROUGH 2825 case '-': 2826 beginline(BL_WHITE | BL_FIX); 2827 // FALLTHROUGH 2828 2829 case 'b': scroll_cursor_bot(0, TRUE); 2830 redraw_later(VALID); 2831 set_fraction(curwin); 2832 break; 2833 2834 // "zH" - scroll screen right half-page 2835 case 'H': 2836 cap->count1 *= curwin->w_width / 2; 2837 // FALLTHROUGH 2838 2839 // "zh" - scroll screen to the right 2840 case 'h': 2841 case K_LEFT: 2842 if (!curwin->w_p_wrap) 2843 { 2844 if ((colnr_T)cap->count1 > curwin->w_leftcol) 2845 curwin->w_leftcol = 0; 2846 else 2847 curwin->w_leftcol -= (colnr_T)cap->count1; 2848 leftcol_changed(); 2849 } 2850 break; 2851 2852 // "zL" - scroll screen left half-page 2853 case 'L': cap->count1 *= curwin->w_width / 2; 2854 // FALLTHROUGH 2855 2856 // "zl" - scroll screen to the left 2857 case 'l': 2858 case K_RIGHT: 2859 if (!curwin->w_p_wrap) 2860 { 2861 // scroll the window left 2862 curwin->w_leftcol += (colnr_T)cap->count1; 2863 leftcol_changed(); 2864 } 2865 break; 2866 2867 // "zs" - scroll screen, cursor at the start 2868 case 's': if (!curwin->w_p_wrap) 2869 { 2870 #ifdef FEAT_FOLDING 2871 if (hasFolding(curwin->w_cursor.lnum, NULL, NULL)) 2872 col = 0; // like the cursor is in col 0 2873 else 2874 #endif 2875 getvcol(curwin, &curwin->w_cursor, &col, NULL, NULL); 2876 if ((long)col > siso) 2877 col -= siso; 2878 else 2879 col = 0; 2880 if (curwin->w_leftcol != col) 2881 { 2882 curwin->w_leftcol = col; 2883 redraw_later(NOT_VALID); 2884 } 2885 } 2886 break; 2887 2888 // "ze" - scroll screen, cursor at the end 2889 case 'e': if (!curwin->w_p_wrap) 2890 { 2891 #ifdef FEAT_FOLDING 2892 if (hasFolding(curwin->w_cursor.lnum, NULL, NULL)) 2893 col = 0; // like the cursor is in col 0 2894 else 2895 #endif 2896 getvcol(curwin, &curwin->w_cursor, NULL, NULL, &col); 2897 n = curwin->w_width - curwin_col_off(); 2898 if ((long)col + siso < n) 2899 col = 0; 2900 else 2901 col = col + siso - n + 1; 2902 if (curwin->w_leftcol != col) 2903 { 2904 curwin->w_leftcol = col; 2905 redraw_later(NOT_VALID); 2906 } 2907 } 2908 break; 2909 2910 #ifdef FEAT_FOLDING 2911 // "zF": create fold command 2912 // "zf": create fold operator 2913 case 'F': 2914 case 'f': if (foldManualAllowed(TRUE)) 2915 { 2916 cap->nchar = 'f'; 2917 nv_operator(cap); 2918 curwin->w_p_fen = TRUE; 2919 2920 // "zF" is like "zfzf" 2921 if (nchar == 'F' && cap->oap->op_type == OP_FOLD) 2922 { 2923 nv_operator(cap); 2924 finish_op = TRUE; 2925 } 2926 } 2927 else 2928 clearopbeep(cap->oap); 2929 break; 2930 2931 // "zd": delete fold at cursor 2932 // "zD": delete fold at cursor recursively 2933 case 'd': 2934 case 'D': if (foldManualAllowed(FALSE)) 2935 { 2936 if (VIsual_active) 2937 nv_operator(cap); 2938 else 2939 deleteFold(curwin->w_cursor.lnum, 2940 curwin->w_cursor.lnum, nchar == 'D', FALSE); 2941 } 2942 break; 2943 2944 // "zE": erase all folds 2945 case 'E': if (foldmethodIsManual(curwin)) 2946 { 2947 clearFolding(curwin); 2948 changed_window_setting(); 2949 } 2950 else if (foldmethodIsMarker(curwin)) 2951 deleteFold((linenr_T)1, curbuf->b_ml.ml_line_count, 2952 TRUE, FALSE); 2953 else 2954 emsg(_("E352: Cannot erase folds with current 'foldmethod'")); 2955 break; 2956 2957 // "zn": fold none: reset 'foldenable' 2958 case 'n': curwin->w_p_fen = FALSE; 2959 break; 2960 2961 // "zN": fold Normal: set 'foldenable' 2962 case 'N': curwin->w_p_fen = TRUE; 2963 break; 2964 2965 // "zi": invert folding: toggle 'foldenable' 2966 case 'i': curwin->w_p_fen = !curwin->w_p_fen; 2967 break; 2968 2969 // "za": open closed fold or close open fold at cursor 2970 case 'a': if (hasFolding(curwin->w_cursor.lnum, NULL, NULL)) 2971 openFold(curwin->w_cursor.lnum, cap->count1); 2972 else 2973 { 2974 closeFold(curwin->w_cursor.lnum, cap->count1); 2975 curwin->w_p_fen = TRUE; 2976 } 2977 break; 2978 2979 // "zA": open fold at cursor recursively 2980 case 'A': if (hasFolding(curwin->w_cursor.lnum, NULL, NULL)) 2981 openFoldRecurse(curwin->w_cursor.lnum); 2982 else 2983 { 2984 closeFoldRecurse(curwin->w_cursor.lnum); 2985 curwin->w_p_fen = TRUE; 2986 } 2987 break; 2988 2989 // "zo": open fold at cursor or Visual area 2990 case 'o': if (VIsual_active) 2991 nv_operator(cap); 2992 else 2993 openFold(curwin->w_cursor.lnum, cap->count1); 2994 break; 2995 2996 // "zO": open fold recursively 2997 case 'O': if (VIsual_active) 2998 nv_operator(cap); 2999 else 3000 openFoldRecurse(curwin->w_cursor.lnum); 3001 break; 3002 3003 // "zc": close fold at cursor or Visual area 3004 case 'c': if (VIsual_active) 3005 nv_operator(cap); 3006 else 3007 closeFold(curwin->w_cursor.lnum, cap->count1); 3008 curwin->w_p_fen = TRUE; 3009 break; 3010 3011 // "zC": close fold recursively 3012 case 'C': if (VIsual_active) 3013 nv_operator(cap); 3014 else 3015 closeFoldRecurse(curwin->w_cursor.lnum); 3016 curwin->w_p_fen = TRUE; 3017 break; 3018 3019 // "zv": open folds at the cursor 3020 case 'v': foldOpenCursor(); 3021 break; 3022 3023 // "zx": re-apply 'foldlevel' and open folds at the cursor 3024 case 'x': curwin->w_p_fen = TRUE; 3025 curwin->w_foldinvalid = TRUE; // recompute folds 3026 newFoldLevel(); // update right now 3027 foldOpenCursor(); 3028 break; 3029 3030 // "zX": undo manual opens/closes, re-apply 'foldlevel' 3031 case 'X': curwin->w_p_fen = TRUE; 3032 curwin->w_foldinvalid = TRUE; // recompute folds 3033 old_fdl = -1; // force an update 3034 break; 3035 3036 // "zm": fold more 3037 case 'm': if (curwin->w_p_fdl > 0) 3038 { 3039 curwin->w_p_fdl -= cap->count1; 3040 if (curwin->w_p_fdl < 0) 3041 curwin->w_p_fdl = 0; 3042 } 3043 old_fdl = -1; // force an update 3044 curwin->w_p_fen = TRUE; 3045 break; 3046 3047 // "zM": close all folds 3048 case 'M': curwin->w_p_fdl = 0; 3049 old_fdl = -1; // force an update 3050 curwin->w_p_fen = TRUE; 3051 break; 3052 3053 // "zr": reduce folding 3054 case 'r': curwin->w_p_fdl += cap->count1; 3055 { 3056 int d = getDeepestNesting(); 3057 3058 if (curwin->w_p_fdl >= d) 3059 curwin->w_p_fdl = d; 3060 } 3061 break; 3062 3063 // "zR": open all folds 3064 case 'R': curwin->w_p_fdl = getDeepestNesting(); 3065 old_fdl = -1; // force an update 3066 break; 3067 3068 case 'j': // "zj" move to next fold downwards 3069 case 'k': // "zk" move to next fold upwards 3070 if (foldMoveTo(TRUE, nchar == 'j' ? FORWARD : BACKWARD, 3071 cap->count1) == FAIL) 3072 clearopbeep(cap->oap); 3073 break; 3074 3075 #endif // FEAT_FOLDING 3076 3077 #ifdef FEAT_SPELL 3078 case 'u': // "zug" and "zuw": undo "zg" and "zw" 3079 ++no_mapping; 3080 ++allow_keys; // no mapping for nchar, but allow key codes 3081 nchar = plain_vgetc(); 3082 LANGMAP_ADJUST(nchar, TRUE); 3083 --no_mapping; 3084 --allow_keys; 3085 #ifdef FEAT_CMDL_INFO 3086 (void)add_to_showcmd(nchar); 3087 #endif 3088 if (vim_strchr((char_u *)"gGwW", nchar) == NULL) 3089 { 3090 clearopbeep(cap->oap); 3091 break; 3092 } 3093 undo = TRUE; 3094 // FALLTHROUGH 3095 3096 case 'g': // "zg": add good word to word list 3097 case 'w': // "zw": add wrong word to word list 3098 case 'G': // "zG": add good word to temp word list 3099 case 'W': // "zW": add wrong word to temp word list 3100 { 3101 char_u *ptr = NULL; 3102 int len; 3103 3104 if (checkclearop(cap->oap)) 3105 break; 3106 if (VIsual_active && get_visual_text(cap, &ptr, &len) 3107 == FAIL) 3108 return; 3109 if (ptr == NULL) 3110 { 3111 pos_T pos = curwin->w_cursor; 3112 3113 // Find bad word under the cursor. When 'spell' is 3114 // off this fails and find_ident_under_cursor() is 3115 // used below. 3116 emsg_off++; 3117 len = spell_move_to(curwin, FORWARD, TRUE, TRUE, NULL); 3118 emsg_off--; 3119 if (len != 0 && curwin->w_cursor.col <= pos.col) 3120 ptr = ml_get_pos(&curwin->w_cursor); 3121 curwin->w_cursor = pos; 3122 } 3123 3124 if (ptr == NULL && (len = find_ident_under_cursor(&ptr, 3125 FIND_IDENT)) == 0) 3126 return; 3127 spell_add_word(ptr, len, nchar == 'w' || nchar == 'W' 3128 ? SPELL_ADD_BAD : SPELL_ADD_GOOD, 3129 (nchar == 'G' || nchar == 'W') 3130 ? 0 : (int)cap->count1, 3131 undo); 3132 } 3133 break; 3134 3135 case '=': // "z=": suggestions for a badly spelled word 3136 if (!checkclearop(cap->oap)) 3137 spell_suggest((int)cap->count0); 3138 break; 3139 #endif 3140 3141 default: clearopbeep(cap->oap); 3142 } 3143 3144 #ifdef FEAT_FOLDING 3145 // Redraw when 'foldenable' changed 3146 if (old_fen != curwin->w_p_fen) 3147 { 3148 # ifdef FEAT_DIFF 3149 win_T *wp; 3150 3151 if (foldmethodIsDiff(curwin) && curwin->w_p_scb) 3152 { 3153 // Adjust 'foldenable' in diff-synced windows. 3154 FOR_ALL_WINDOWS(wp) 3155 { 3156 if (wp != curwin && foldmethodIsDiff(wp) && wp->w_p_scb) 3157 { 3158 wp->w_p_fen = curwin->w_p_fen; 3159 changed_window_setting_win(wp); 3160 } 3161 } 3162 } 3163 # endif 3164 changed_window_setting(); 3165 } 3166 3167 // Redraw when 'foldlevel' changed. 3168 if (old_fdl != curwin->w_p_fdl) 3169 newFoldLevel(); 3170 #endif 3171 } 3172 3173 #ifdef FEAT_GUI 3174 /* 3175 * Vertical scrollbar movement. 3176 */ 3177 static void 3178 nv_ver_scrollbar(cmdarg_T *cap) 3179 { 3180 if (cap->oap->op_type != OP_NOP) 3181 clearopbeep(cap->oap); 3182 3183 // Even if an operator was pending, we still want to scroll 3184 gui_do_scroll(); 3185 } 3186 3187 /* 3188 * Horizontal scrollbar movement. 3189 */ 3190 static void 3191 nv_hor_scrollbar(cmdarg_T *cap) 3192 { 3193 if (cap->oap->op_type != OP_NOP) 3194 clearopbeep(cap->oap); 3195 3196 // Even if an operator was pending, we still want to scroll 3197 gui_do_horiz_scroll(scrollbar_value, FALSE); 3198 } 3199 #endif 3200 3201 #if defined(FEAT_GUI_TABLINE) || defined(PROTO) 3202 /* 3203 * Click in GUI tab. 3204 */ 3205 static void 3206 nv_tabline(cmdarg_T *cap) 3207 { 3208 if (cap->oap->op_type != OP_NOP) 3209 clearopbeep(cap->oap); 3210 3211 // Even if an operator was pending, we still want to jump tabs. 3212 goto_tabpage(current_tab); 3213 } 3214 3215 /* 3216 * Selected item in tab line menu. 3217 */ 3218 static void 3219 nv_tabmenu(cmdarg_T *cap) 3220 { 3221 if (cap->oap->op_type != OP_NOP) 3222 clearopbeep(cap->oap); 3223 3224 // Even if an operator was pending, we still want to jump tabs. 3225 handle_tabmenu(); 3226 } 3227 3228 /* 3229 * Handle selecting an item of the GUI tab line menu. 3230 * Used in Normal and Insert mode. 3231 */ 3232 void 3233 handle_tabmenu(void) 3234 { 3235 switch (current_tabmenu) 3236 { 3237 case TABLINE_MENU_CLOSE: 3238 if (current_tab == 0) 3239 do_cmdline_cmd((char_u *)"tabclose"); 3240 else 3241 { 3242 vim_snprintf((char *)IObuff, IOSIZE, "tabclose %d", 3243 current_tab); 3244 do_cmdline_cmd(IObuff); 3245 } 3246 break; 3247 3248 case TABLINE_MENU_NEW: 3249 if (current_tab == 0) 3250 do_cmdline_cmd((char_u *)"$tabnew"); 3251 else 3252 { 3253 vim_snprintf((char *)IObuff, IOSIZE, "%dtabnew", 3254 current_tab - 1); 3255 do_cmdline_cmd(IObuff); 3256 } 3257 break; 3258 3259 case TABLINE_MENU_OPEN: 3260 if (current_tab == 0) 3261 do_cmdline_cmd((char_u *)"browse $tabnew"); 3262 else 3263 { 3264 vim_snprintf((char *)IObuff, IOSIZE, "browse %dtabnew", 3265 current_tab - 1); 3266 do_cmdline_cmd(IObuff); 3267 } 3268 break; 3269 } 3270 } 3271 #endif 3272 3273 /* 3274 * "Q" command. 3275 */ 3276 static void 3277 nv_exmode(cmdarg_T *cap) 3278 { 3279 /* 3280 * Ignore 'Q' in Visual mode, just give a beep. 3281 */ 3282 if (VIsual_active) 3283 vim_beep(BO_EX); 3284 else if (!checkclearop(cap->oap)) 3285 do_exmode(FALSE); 3286 } 3287 3288 /* 3289 * Handle a ":" command. 3290 */ 3291 static void 3292 nv_colon(cmdarg_T *cap) 3293 { 3294 int old_p_im; 3295 int cmd_result; 3296 3297 if (VIsual_active) 3298 nv_operator(cap); 3299 else 3300 { 3301 if (cap->oap->op_type != OP_NOP) 3302 { 3303 // Using ":" as a movement is characterwise exclusive. 3304 cap->oap->motion_type = MCHAR; 3305 cap->oap->inclusive = FALSE; 3306 } 3307 else if (cap->count0) 3308 { 3309 // translate "count:" into ":.,.+(count - 1)" 3310 stuffcharReadbuff('.'); 3311 if (cap->count0 > 1) 3312 { 3313 stuffReadbuff((char_u *)",.+"); 3314 stuffnumReadbuff((long)cap->count0 - 1L); 3315 } 3316 } 3317 3318 // When typing, don't type below an old message 3319 if (KeyTyped) 3320 compute_cmdrow(); 3321 3322 old_p_im = p_im; 3323 3324 // get a command line and execute it 3325 cmd_result = do_cmdline(NULL, getexline, NULL, 3326 cap->oap->op_type != OP_NOP ? DOCMD_KEEPLINE : 0); 3327 3328 // If 'insertmode' changed, enter or exit Insert mode 3329 if (p_im != old_p_im) 3330 { 3331 if (p_im) 3332 restart_edit = 'i'; 3333 else 3334 restart_edit = 0; 3335 } 3336 3337 if (cmd_result == FAIL) 3338 // The Ex command failed, do not execute the operator. 3339 clearop(cap->oap); 3340 else if (cap->oap->op_type != OP_NOP 3341 && (cap->oap->start.lnum > curbuf->b_ml.ml_line_count 3342 || cap->oap->start.col > 3343 (colnr_T)STRLEN(ml_get(cap->oap->start.lnum)) 3344 || did_emsg 3345 )) 3346 // The start of the operator has become invalid by the Ex command. 3347 clearopbeep(cap->oap); 3348 } 3349 } 3350 3351 /* 3352 * Handle CTRL-G command. 3353 */ 3354 static void 3355 nv_ctrlg(cmdarg_T *cap) 3356 { 3357 if (VIsual_active) // toggle Selection/Visual mode 3358 { 3359 VIsual_select = !VIsual_select; 3360 showmode(); 3361 } 3362 else if (!checkclearop(cap->oap)) 3363 // print full name if count given or :cd used 3364 fileinfo((int)cap->count0, FALSE, TRUE); 3365 } 3366 3367 /* 3368 * Handle CTRL-H <Backspace> command. 3369 */ 3370 static void 3371 nv_ctrlh(cmdarg_T *cap) 3372 { 3373 if (VIsual_active && VIsual_select) 3374 { 3375 cap->cmdchar = 'x'; // BS key behaves like 'x' in Select mode 3376 v_visop(cap); 3377 } 3378 else 3379 nv_left(cap); 3380 } 3381 3382 /* 3383 * CTRL-L: clear screen and redraw. 3384 */ 3385 static void 3386 nv_clear(cmdarg_T *cap) 3387 { 3388 if (!checkclearop(cap->oap)) 3389 { 3390 #ifdef FEAT_SYN_HL 3391 // Clear all syntax states to force resyncing. 3392 syn_stack_free_all(curwin->w_s); 3393 # ifdef FEAT_RELTIME 3394 { 3395 win_T *wp; 3396 3397 FOR_ALL_WINDOWS(wp) 3398 wp->w_s->b_syn_slow = FALSE; 3399 } 3400 # endif 3401 #endif 3402 redraw_later(CLEAR); 3403 #if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL)) 3404 # ifdef VIMDLL 3405 if (!gui.in_use) 3406 # endif 3407 resize_console_buf(); 3408 #endif 3409 } 3410 } 3411 3412 /* 3413 * CTRL-O: In Select mode: switch to Visual mode for one command. 3414 * Otherwise: Go to older pcmark. 3415 */ 3416 static void 3417 nv_ctrlo(cmdarg_T *cap) 3418 { 3419 if (VIsual_active && VIsual_select) 3420 { 3421 VIsual_select = FALSE; 3422 showmode(); 3423 restart_VIsual_select = 2; // restart Select mode later 3424 } 3425 else 3426 { 3427 cap->count1 = -cap->count1; 3428 nv_pcmark(cap); 3429 } 3430 } 3431 3432 /* 3433 * CTRL-^ command, short for ":e #". Works even when the alternate buffer is 3434 * not named. 3435 */ 3436 static void 3437 nv_hat(cmdarg_T *cap) 3438 { 3439 if (!checkclearopq(cap->oap)) 3440 (void)buflist_getfile((int)cap->count0, (linenr_T)0, 3441 GETF_SETMARK|GETF_ALT, FALSE); 3442 } 3443 3444 /* 3445 * "Z" commands. 3446 */ 3447 static void 3448 nv_Zet(cmdarg_T *cap) 3449 { 3450 if (!checkclearopq(cap->oap)) 3451 { 3452 switch (cap->nchar) 3453 { 3454 // "ZZ": equivalent to ":x". 3455 case 'Z': do_cmdline_cmd((char_u *)"x"); 3456 break; 3457 3458 // "ZQ": equivalent to ":q!" (Elvis compatible). 3459 case 'Q': do_cmdline_cmd((char_u *)"q!"); 3460 break; 3461 3462 default: clearopbeep(cap->oap); 3463 } 3464 } 3465 } 3466 3467 /* 3468 * Call nv_ident() as if "c1" was used, with "c2" as next character. 3469 */ 3470 void 3471 do_nv_ident(int c1, int c2) 3472 { 3473 oparg_T oa; 3474 cmdarg_T ca; 3475 3476 clear_oparg(&oa); 3477 CLEAR_FIELD(ca); 3478 ca.oap = &oa; 3479 ca.cmdchar = c1; 3480 ca.nchar = c2; 3481 nv_ident(&ca); 3482 } 3483 3484 /* 3485 * Handle the commands that use the word under the cursor. 3486 * [g] CTRL-] :ta to current identifier 3487 * [g] 'K' run program for current identifier 3488 * [g] '*' / to current identifier or string 3489 * [g] '#' ? to current identifier or string 3490 * g ']' :tselect for current identifier 3491 */ 3492 static void 3493 nv_ident(cmdarg_T *cap) 3494 { 3495 char_u *ptr = NULL; 3496 char_u *buf; 3497 unsigned buflen; 3498 char_u *newbuf; 3499 char_u *p; 3500 char_u *kp; // value of 'keywordprg' 3501 int kp_help; // 'keywordprg' is ":he" 3502 int kp_ex; // 'keywordprg' starts with ":" 3503 int n = 0; // init for GCC 3504 int cmdchar; 3505 int g_cmd; // "g" command 3506 int tag_cmd = FALSE; 3507 char_u *aux_ptr; 3508 int isman; 3509 int isman_s; 3510 3511 if (cap->cmdchar == 'g') // "g*", "g#", "g]" and "gCTRL-]" 3512 { 3513 cmdchar = cap->nchar; 3514 g_cmd = TRUE; 3515 } 3516 else 3517 { 3518 cmdchar = cap->cmdchar; 3519 g_cmd = FALSE; 3520 } 3521 3522 if (cmdchar == POUND) // the pound sign, '#' for English keyboards 3523 cmdchar = '#'; 3524 3525 /* 3526 * The "]", "CTRL-]" and "K" commands accept an argument in Visual mode. 3527 */ 3528 if (cmdchar == ']' || cmdchar == Ctrl_RSB || cmdchar == 'K') 3529 { 3530 if (VIsual_active && get_visual_text(cap, &ptr, &n) == FAIL) 3531 return; 3532 if (checkclearopq(cap->oap)) 3533 return; 3534 } 3535 3536 if (ptr == NULL && (n = find_ident_under_cursor(&ptr, 3537 (cmdchar == '*' || cmdchar == '#') 3538 ? FIND_IDENT|FIND_STRING : FIND_IDENT)) == 0) 3539 { 3540 clearop(cap->oap); 3541 return; 3542 } 3543 3544 // Allocate buffer to put the command in. Inserting backslashes can 3545 // double the length of the word. p_kp / curbuf->b_p_kp could be added 3546 // and some numbers. 3547 kp = (*curbuf->b_p_kp == NUL ? p_kp : curbuf->b_p_kp); 3548 kp_help = (*kp == NUL || STRCMP(kp, ":he") == 0 3549 || STRCMP(kp, ":help") == 0); 3550 if (kp_help && *skipwhite(ptr) == NUL) 3551 { 3552 emsg(_(e_noident)); // found white space only 3553 return; 3554 } 3555 kp_ex = (*kp == ':'); 3556 buflen = (unsigned)(n * 2 + 30 + STRLEN(kp)); 3557 buf = alloc(buflen); 3558 if (buf == NULL) 3559 return; 3560 buf[0] = NUL; 3561 3562 switch (cmdchar) 3563 { 3564 case '*': 3565 case '#': 3566 /* 3567 * Put cursor at start of word, makes search skip the word 3568 * under the cursor. 3569 * Call setpcmark() first, so "*``" puts the cursor back where 3570 * it was. 3571 */ 3572 setpcmark(); 3573 curwin->w_cursor.col = (colnr_T) (ptr - ml_get_curline()); 3574 3575 if (!g_cmd && vim_iswordp(ptr)) 3576 STRCPY(buf, "\\<"); 3577 no_smartcase = TRUE; // don't use 'smartcase' now 3578 break; 3579 3580 case 'K': 3581 if (kp_help) 3582 STRCPY(buf, "he! "); 3583 else if (kp_ex) 3584 { 3585 if (cap->count0 != 0) 3586 vim_snprintf((char *)buf, buflen, "%s %ld", 3587 kp, cap->count0); 3588 else 3589 STRCPY(buf, kp); 3590 STRCAT(buf, " "); 3591 } 3592 else 3593 { 3594 // An external command will probably use an argument starting 3595 // with "-" as an option. To avoid trouble we skip the "-". 3596 while (*ptr == '-' && n > 0) 3597 { 3598 ++ptr; 3599 --n; 3600 } 3601 if (n == 0) 3602 { 3603 emsg(_(e_noident)); // found dashes only 3604 vim_free(buf); 3605 return; 3606 } 3607 3608 // When a count is given, turn it into a range. Is this 3609 // really what we want? 3610 isman = (STRCMP(kp, "man") == 0); 3611 isman_s = (STRCMP(kp, "man -s") == 0); 3612 if (cap->count0 != 0 && !(isman || isman_s)) 3613 sprintf((char *)buf, ".,.+%ld", cap->count0 - 1); 3614 3615 STRCAT(buf, "! "); 3616 if (cap->count0 == 0 && isman_s) 3617 STRCAT(buf, "man"); 3618 else 3619 STRCAT(buf, kp); 3620 STRCAT(buf, " "); 3621 if (cap->count0 != 0 && (isman || isman_s)) 3622 { 3623 sprintf((char *)buf + STRLEN(buf), "%ld", cap->count0); 3624 STRCAT(buf, " "); 3625 } 3626 } 3627 break; 3628 3629 case ']': 3630 tag_cmd = TRUE; 3631 #ifdef FEAT_CSCOPE 3632 if (p_cst) 3633 STRCPY(buf, "cstag "); 3634 else 3635 #endif 3636 STRCPY(buf, "ts "); 3637 break; 3638 3639 default: 3640 tag_cmd = TRUE; 3641 if (curbuf->b_help) 3642 STRCPY(buf, "he! "); 3643 else 3644 { 3645 if (g_cmd) 3646 STRCPY(buf, "tj "); 3647 else 3648 sprintf((char *)buf, "%ldta ", cap->count0); 3649 } 3650 } 3651 3652 /* 3653 * Now grab the chars in the identifier 3654 */ 3655 if (cmdchar == 'K' && !kp_help) 3656 { 3657 ptr = vim_strnsave(ptr, n); 3658 if (kp_ex) 3659 // Escape the argument properly for an Ex command 3660 p = vim_strsave_fnameescape(ptr, FALSE); 3661 else 3662 // Escape the argument properly for a shell command 3663 p = vim_strsave_shellescape(ptr, TRUE, TRUE); 3664 vim_free(ptr); 3665 if (p == NULL) 3666 { 3667 vim_free(buf); 3668 return; 3669 } 3670 newbuf = vim_realloc(buf, STRLEN(buf) + STRLEN(p) + 1); 3671 if (newbuf == NULL) 3672 { 3673 vim_free(buf); 3674 vim_free(p); 3675 return; 3676 } 3677 buf = newbuf; 3678 STRCAT(buf, p); 3679 vim_free(p); 3680 } 3681 else 3682 { 3683 if (cmdchar == '*') 3684 aux_ptr = (char_u *)(p_magic ? "/.*~[^$\\" : "/^$\\"); 3685 else if (cmdchar == '#') 3686 aux_ptr = (char_u *)(p_magic ? "/?.*~[^$\\" : "/?^$\\"); 3687 else if (tag_cmd) 3688 { 3689 if (curbuf->b_help) 3690 // ":help" handles unescaped argument 3691 aux_ptr = (char_u *)""; 3692 else 3693 aux_ptr = (char_u *)"\\|\"\n["; 3694 } 3695 else 3696 aux_ptr = (char_u *)"\\|\"\n*?["; 3697 3698 p = buf + STRLEN(buf); 3699 while (n-- > 0) 3700 { 3701 // put a backslash before \ and some others 3702 if (vim_strchr(aux_ptr, *ptr) != NULL) 3703 *p++ = '\\'; 3704 // When current byte is a part of multibyte character, copy all 3705 // bytes of that character. 3706 if (has_mbyte) 3707 { 3708 int i; 3709 int len = (*mb_ptr2len)(ptr) - 1; 3710 3711 for (i = 0; i < len && n >= 1; ++i, --n) 3712 *p++ = *ptr++; 3713 } 3714 *p++ = *ptr++; 3715 } 3716 *p = NUL; 3717 } 3718 3719 /* 3720 * Execute the command. 3721 */ 3722 if (cmdchar == '*' || cmdchar == '#') 3723 { 3724 if (!g_cmd && (has_mbyte 3725 ? vim_iswordp(mb_prevptr(ml_get_curline(), ptr)) 3726 : vim_iswordc(ptr[-1]))) 3727 STRCAT(buf, "\\>"); 3728 3729 // put pattern in search history 3730 init_history(); 3731 add_to_history(HIST_SEARCH, buf, TRUE, NUL); 3732 3733 (void)normal_search(cap, cmdchar == '*' ? '/' : '?', buf, 0, NULL); 3734 } 3735 else 3736 { 3737 g_tag_at_cursor = TRUE; 3738 do_cmdline_cmd(buf); 3739 g_tag_at_cursor = FALSE; 3740 } 3741 3742 vim_free(buf); 3743 } 3744 3745 /* 3746 * Get visually selected text, within one line only. 3747 * Returns FAIL if more than one line selected. 3748 */ 3749 int 3750 get_visual_text( 3751 cmdarg_T *cap, 3752 char_u **pp, // return: start of selected text 3753 int *lenp) // return: length of selected text 3754 { 3755 if (VIsual_mode != 'V') 3756 unadjust_for_sel(); 3757 if (VIsual.lnum != curwin->w_cursor.lnum) 3758 { 3759 if (cap != NULL) 3760 clearopbeep(cap->oap); 3761 return FAIL; 3762 } 3763 if (VIsual_mode == 'V') 3764 { 3765 *pp = ml_get_curline(); 3766 *lenp = (int)STRLEN(*pp); 3767 } 3768 else 3769 { 3770 if (LT_POS(curwin->w_cursor, VIsual)) 3771 { 3772 *pp = ml_get_pos(&curwin->w_cursor); 3773 *lenp = VIsual.col - curwin->w_cursor.col + 1; 3774 } 3775 else 3776 { 3777 *pp = ml_get_pos(&VIsual); 3778 *lenp = curwin->w_cursor.col - VIsual.col + 1; 3779 } 3780 if (has_mbyte) 3781 // Correct the length to include the whole last character. 3782 *lenp += (*mb_ptr2len)(*pp + (*lenp - 1)) - 1; 3783 } 3784 reset_VIsual_and_resel(); 3785 return OK; 3786 } 3787 3788 /* 3789 * CTRL-T: backwards in tag stack 3790 */ 3791 static void 3792 nv_tagpop(cmdarg_T *cap) 3793 { 3794 if (!checkclearopq(cap->oap)) 3795 do_tag((char_u *)"", DT_POP, (int)cap->count1, FALSE, TRUE); 3796 } 3797 3798 /* 3799 * Handle scrolling command 'H', 'L' and 'M'. 3800 */ 3801 static void 3802 nv_scroll(cmdarg_T *cap) 3803 { 3804 int used = 0; 3805 long n; 3806 #ifdef FEAT_FOLDING 3807 linenr_T lnum; 3808 #endif 3809 int half; 3810 3811 cap->oap->motion_type = MLINE; 3812 setpcmark(); 3813 3814 if (cap->cmdchar == 'L') 3815 { 3816 validate_botline(); // make sure curwin->w_botline is valid 3817 curwin->w_cursor.lnum = curwin->w_botline - 1; 3818 if (cap->count1 - 1 >= curwin->w_cursor.lnum) 3819 curwin->w_cursor.lnum = 1; 3820 else 3821 { 3822 #ifdef FEAT_FOLDING 3823 if (hasAnyFolding(curwin)) 3824 { 3825 // Count a fold for one screen line. 3826 for (n = cap->count1 - 1; n > 0 3827 && curwin->w_cursor.lnum > curwin->w_topline; --n) 3828 { 3829 (void)hasFolding(curwin->w_cursor.lnum, 3830 &curwin->w_cursor.lnum, NULL); 3831 --curwin->w_cursor.lnum; 3832 } 3833 } 3834 else 3835 #endif 3836 curwin->w_cursor.lnum -= cap->count1 - 1; 3837 } 3838 } 3839 else 3840 { 3841 if (cap->cmdchar == 'M') 3842 { 3843 #ifdef FEAT_DIFF 3844 // Don't count filler lines above the window. 3845 used -= diff_check_fill(curwin, curwin->w_topline) 3846 - curwin->w_topfill; 3847 #endif 3848 validate_botline(); // make sure w_empty_rows is valid 3849 half = (curwin->w_height - curwin->w_empty_rows + 1) / 2; 3850 for (n = 0; curwin->w_topline + n < curbuf->b_ml.ml_line_count; ++n) 3851 { 3852 #ifdef FEAT_DIFF 3853 // Count half he number of filler lines to be "below this 3854 // line" and half to be "above the next line". 3855 if (n > 0 && used + diff_check_fill(curwin, curwin->w_topline 3856 + n) / 2 >= half) 3857 { 3858 --n; 3859 break; 3860 } 3861 #endif 3862 used += plines(curwin->w_topline + n); 3863 if (used >= half) 3864 break; 3865 #ifdef FEAT_FOLDING 3866 if (hasFolding(curwin->w_topline + n, NULL, &lnum)) 3867 n = lnum - curwin->w_topline; 3868 #endif 3869 } 3870 if (n > 0 && used > curwin->w_height) 3871 --n; 3872 } 3873 else // (cap->cmdchar == 'H') 3874 { 3875 n = cap->count1 - 1; 3876 #ifdef FEAT_FOLDING 3877 if (hasAnyFolding(curwin)) 3878 { 3879 // Count a fold for one screen line. 3880 lnum = curwin->w_topline; 3881 while (n-- > 0 && lnum < curwin->w_botline - 1) 3882 { 3883 (void)hasFolding(lnum, NULL, &lnum); 3884 ++lnum; 3885 } 3886 n = lnum - curwin->w_topline; 3887 } 3888 #endif 3889 } 3890 curwin->w_cursor.lnum = curwin->w_topline + n; 3891 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) 3892 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; 3893 } 3894 3895 // Correct for 'so', except when an operator is pending. 3896 if (cap->oap->op_type == OP_NOP) 3897 cursor_correct(); 3898 beginline(BL_SOL | BL_FIX); 3899 } 3900 3901 /* 3902 * Cursor right commands. 3903 */ 3904 static void 3905 nv_right(cmdarg_T *cap) 3906 { 3907 long n; 3908 int past_line; 3909 3910 if (mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)) 3911 { 3912 // <C-Right> and <S-Right> move a word or WORD right 3913 if (mod_mask & MOD_MASK_CTRL) 3914 cap->arg = TRUE; 3915 nv_wordcmd(cap); 3916 return; 3917 } 3918 3919 cap->oap->motion_type = MCHAR; 3920 cap->oap->inclusive = FALSE; 3921 past_line = (VIsual_active && *p_sel != 'o'); 3922 3923 /* 3924 * In virtual edit mode, there's no such thing as "past_line", as lines 3925 * are (theoretically) infinitely long. 3926 */ 3927 if (virtual_active()) 3928 past_line = 0; 3929 3930 for (n = cap->count1; n > 0; --n) 3931 { 3932 if ((!past_line && oneright() == FAIL) 3933 || (past_line && *ml_get_cursor() == NUL) 3934 ) 3935 { 3936 /* 3937 * <Space> wraps to next line if 'whichwrap' has 's'. 3938 * 'l' wraps to next line if 'whichwrap' has 'l'. 3939 * CURS_RIGHT wraps to next line if 'whichwrap' has '>'. 3940 */ 3941 if ( ((cap->cmdchar == ' ' 3942 && vim_strchr(p_ww, 's') != NULL) 3943 || (cap->cmdchar == 'l' 3944 && vim_strchr(p_ww, 'l') != NULL) 3945 || (cap->cmdchar == K_RIGHT 3946 && vim_strchr(p_ww, '>') != NULL)) 3947 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) 3948 { 3949 // When deleting we also count the NL as a character. 3950 // Set cap->oap->inclusive when last char in the line is 3951 // included, move to next line after that 3952 if ( cap->oap->op_type != OP_NOP 3953 && !cap->oap->inclusive 3954 && !LINEEMPTY(curwin->w_cursor.lnum)) 3955 cap->oap->inclusive = TRUE; 3956 else 3957 { 3958 ++curwin->w_cursor.lnum; 3959 curwin->w_cursor.col = 0; 3960 curwin->w_cursor.coladd = 0; 3961 curwin->w_set_curswant = TRUE; 3962 cap->oap->inclusive = FALSE; 3963 } 3964 continue; 3965 } 3966 if (cap->oap->op_type == OP_NOP) 3967 { 3968 // Only beep and flush if not moved at all 3969 if (n == cap->count1) 3970 beep_flush(); 3971 } 3972 else 3973 { 3974 if (!LINEEMPTY(curwin->w_cursor.lnum)) 3975 cap->oap->inclusive = TRUE; 3976 } 3977 break; 3978 } 3979 else if (past_line) 3980 { 3981 curwin->w_set_curswant = TRUE; 3982 if (virtual_active()) 3983 oneright(); 3984 else 3985 { 3986 if (has_mbyte) 3987 curwin->w_cursor.col += (*mb_ptr2len)(ml_get_cursor()); 3988 else 3989 ++curwin->w_cursor.col; 3990 } 3991 } 3992 } 3993 #ifdef FEAT_FOLDING 3994 if (n != cap->count1 && (fdo_flags & FDO_HOR) && KeyTyped 3995 && cap->oap->op_type == OP_NOP) 3996 foldOpenCursor(); 3997 #endif 3998 } 3999 4000 /* 4001 * Cursor left commands. 4002 * 4003 * Returns TRUE when operator end should not be adjusted. 4004 */ 4005 static void 4006 nv_left(cmdarg_T *cap) 4007 { 4008 long n; 4009 4010 if (mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)) 4011 { 4012 // <C-Left> and <S-Left> move a word or WORD left 4013 if (mod_mask & MOD_MASK_CTRL) 4014 cap->arg = 1; 4015 nv_bck_word(cap); 4016 return; 4017 } 4018 4019 cap->oap->motion_type = MCHAR; 4020 cap->oap->inclusive = FALSE; 4021 for (n = cap->count1; n > 0; --n) 4022 { 4023 if (oneleft() == FAIL) 4024 { 4025 // <BS> and <Del> wrap to previous line if 'whichwrap' has 'b'. 4026 // 'h' wraps to previous line if 'whichwrap' has 'h'. 4027 // CURS_LEFT wraps to previous line if 'whichwrap' has '<'. 4028 if ( (((cap->cmdchar == K_BS 4029 || cap->cmdchar == Ctrl_H) 4030 && vim_strchr(p_ww, 'b') != NULL) 4031 || (cap->cmdchar == 'h' 4032 && vim_strchr(p_ww, 'h') != NULL) 4033 || (cap->cmdchar == K_LEFT 4034 && vim_strchr(p_ww, '<') != NULL)) 4035 && curwin->w_cursor.lnum > 1) 4036 { 4037 --(curwin->w_cursor.lnum); 4038 coladvance((colnr_T)MAXCOL); 4039 curwin->w_set_curswant = TRUE; 4040 4041 // When the NL before the first char has to be deleted we 4042 // put the cursor on the NUL after the previous line. 4043 // This is a very special case, be careful! 4044 // Don't adjust op_end now, otherwise it won't work. 4045 if ( (cap->oap->op_type == OP_DELETE 4046 || cap->oap->op_type == OP_CHANGE) 4047 && !LINEEMPTY(curwin->w_cursor.lnum)) 4048 { 4049 char_u *cp = ml_get_cursor(); 4050 4051 if (*cp != NUL) 4052 { 4053 if (has_mbyte) 4054 curwin->w_cursor.col += (*mb_ptr2len)(cp); 4055 else 4056 ++curwin->w_cursor.col; 4057 } 4058 cap->retval |= CA_NO_ADJ_OP_END; 4059 } 4060 continue; 4061 } 4062 // Only beep and flush if not moved at all 4063 else if (cap->oap->op_type == OP_NOP && n == cap->count1) 4064 beep_flush(); 4065 break; 4066 } 4067 } 4068 #ifdef FEAT_FOLDING 4069 if (n != cap->count1 && (fdo_flags & FDO_HOR) && KeyTyped 4070 && cap->oap->op_type == OP_NOP) 4071 foldOpenCursor(); 4072 #endif 4073 } 4074 4075 /* 4076 * Cursor up commands. 4077 * cap->arg is TRUE for "-": Move cursor to first non-blank. 4078 */ 4079 static void 4080 nv_up(cmdarg_T *cap) 4081 { 4082 if (mod_mask & MOD_MASK_SHIFT) 4083 { 4084 // <S-Up> is page up 4085 cap->arg = BACKWARD; 4086 nv_page(cap); 4087 } 4088 else 4089 { 4090 cap->oap->motion_type = MLINE; 4091 if (cursor_up(cap->count1, cap->oap->op_type == OP_NOP) == FAIL) 4092 clearopbeep(cap->oap); 4093 else if (cap->arg) 4094 beginline(BL_WHITE | BL_FIX); 4095 } 4096 } 4097 4098 /* 4099 * Cursor down commands. 4100 * cap->arg is TRUE for CR and "+": Move cursor to first non-blank. 4101 */ 4102 static void 4103 nv_down(cmdarg_T *cap) 4104 { 4105 if (mod_mask & MOD_MASK_SHIFT) 4106 { 4107 // <S-Down> is page down 4108 cap->arg = FORWARD; 4109 nv_page(cap); 4110 } 4111 #if defined(FEAT_QUICKFIX) 4112 // Quickfix window only: view the result under the cursor. 4113 else if (bt_quickfix(curbuf) && cap->cmdchar == CAR) 4114 qf_view_result(FALSE); 4115 #endif 4116 else 4117 { 4118 #ifdef FEAT_CMDWIN 4119 // In the cmdline window a <CR> executes the command. 4120 if (cmdwin_type != 0 && cap->cmdchar == CAR) 4121 cmdwin_result = CAR; 4122 else 4123 #endif 4124 #ifdef FEAT_JOB_CHANNEL 4125 // In a prompt buffer a <CR> in the last line invokes the callback. 4126 if (bt_prompt(curbuf) && cap->cmdchar == CAR 4127 && curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count) 4128 { 4129 invoke_prompt_callback(); 4130 if (restart_edit == 0) 4131 restart_edit = 'a'; 4132 } 4133 else 4134 #endif 4135 { 4136 cap->oap->motion_type = MLINE; 4137 if (cursor_down(cap->count1, cap->oap->op_type == OP_NOP) == FAIL) 4138 clearopbeep(cap->oap); 4139 else if (cap->arg) 4140 beginline(BL_WHITE | BL_FIX); 4141 } 4142 } 4143 } 4144 4145 #ifdef FEAT_SEARCHPATH 4146 /* 4147 * Grab the file name under the cursor and edit it. 4148 */ 4149 static void 4150 nv_gotofile(cmdarg_T *cap) 4151 { 4152 char_u *ptr; 4153 linenr_T lnum = -1; 4154 4155 if (text_locked()) 4156 { 4157 clearopbeep(cap->oap); 4158 text_locked_msg(); 4159 return; 4160 } 4161 if (curbuf_locked()) 4162 { 4163 clearop(cap->oap); 4164 return; 4165 } 4166 #ifdef FEAT_PROP_POPUP 4167 if (ERROR_IF_TERM_POPUP_WINDOW) 4168 return; 4169 #endif 4170 4171 ptr = grab_file_name(cap->count1, &lnum); 4172 4173 if (ptr != NULL) 4174 { 4175 // do autowrite if necessary 4176 if (curbufIsChanged() && curbuf->b_nwindows <= 1 && !buf_hide(curbuf)) 4177 (void)autowrite(curbuf, FALSE); 4178 setpcmark(); 4179 if (do_ecmd(0, ptr, NULL, NULL, ECMD_LAST, 4180 buf_hide(curbuf) ? ECMD_HIDE : 0, curwin) == OK 4181 && cap->nchar == 'F' && lnum >= 0) 4182 { 4183 curwin->w_cursor.lnum = lnum; 4184 check_cursor_lnum(); 4185 beginline(BL_SOL | BL_FIX); 4186 } 4187 vim_free(ptr); 4188 } 4189 else 4190 clearop(cap->oap); 4191 } 4192 #endif 4193 4194 /* 4195 * <End> command: to end of current line or last line. 4196 */ 4197 static void 4198 nv_end(cmdarg_T *cap) 4199 { 4200 if (cap->arg || (mod_mask & MOD_MASK_CTRL)) // CTRL-END = goto last line 4201 { 4202 cap->arg = TRUE; 4203 nv_goto(cap); 4204 cap->count1 = 1; // to end of current line 4205 } 4206 nv_dollar(cap); 4207 } 4208 4209 /* 4210 * Handle the "$" command. 4211 */ 4212 static void 4213 nv_dollar(cmdarg_T *cap) 4214 { 4215 cap->oap->motion_type = MCHAR; 4216 cap->oap->inclusive = TRUE; 4217 // In virtual mode when off the edge of a line and an operator 4218 // is pending (whew!) keep the cursor where it is. 4219 // Otherwise, send it to the end of the line. 4220 if (!virtual_active() || gchar_cursor() != NUL 4221 || cap->oap->op_type == OP_NOP) 4222 curwin->w_curswant = MAXCOL; // so we stay at the end 4223 if (cursor_down((long)(cap->count1 - 1), 4224 cap->oap->op_type == OP_NOP) == FAIL) 4225 clearopbeep(cap->oap); 4226 #ifdef FEAT_FOLDING 4227 else if ((fdo_flags & FDO_HOR) && KeyTyped && cap->oap->op_type == OP_NOP) 4228 foldOpenCursor(); 4229 #endif 4230 } 4231 4232 /* 4233 * Implementation of '?' and '/' commands. 4234 * If cap->arg is TRUE don't set PC mark. 4235 */ 4236 static void 4237 nv_search(cmdarg_T *cap) 4238 { 4239 oparg_T *oap = cap->oap; 4240 pos_T save_cursor = curwin->w_cursor; 4241 4242 if (cap->cmdchar == '?' && cap->oap->op_type == OP_ROT13) 4243 { 4244 // Translate "g??" to "g?g?" 4245 cap->cmdchar = 'g'; 4246 cap->nchar = '?'; 4247 nv_operator(cap); 4248 return; 4249 } 4250 4251 // When using 'incsearch' the cursor may be moved to set a different search 4252 // start position. 4253 cap->searchbuf = getcmdline(cap->cmdchar, cap->count1, 0, TRUE); 4254 4255 if (cap->searchbuf == NULL) 4256 { 4257 clearop(oap); 4258 return; 4259 } 4260 4261 (void)normal_search(cap, cap->cmdchar, cap->searchbuf, 4262 (cap->arg || !EQUAL_POS(save_cursor, curwin->w_cursor)) 4263 ? 0 : SEARCH_MARK, NULL); 4264 } 4265 4266 /* 4267 * Handle "N" and "n" commands. 4268 * cap->arg is SEARCH_REV for "N", 0 for "n". 4269 */ 4270 static void 4271 nv_next(cmdarg_T *cap) 4272 { 4273 pos_T old = curwin->w_cursor; 4274 int wrapped = FALSE; 4275 int i = normal_search(cap, 0, NULL, SEARCH_MARK | cap->arg, &wrapped); 4276 4277 if (i == 1 && !wrapped && EQUAL_POS(old, curwin->w_cursor)) 4278 { 4279 // Avoid getting stuck on the current cursor position, which can 4280 // happen when an offset is given and the cursor is on the last char 4281 // in the buffer: Repeat with count + 1. 4282 cap->count1 += 1; 4283 (void)normal_search(cap, 0, NULL, SEARCH_MARK | cap->arg, NULL); 4284 cap->count1 -= 1; 4285 } 4286 } 4287 4288 /* 4289 * Search for "pat" in direction "dir" ('/' or '?', 0 for repeat). 4290 * Uses only cap->count1 and cap->oap from "cap". 4291 * Return 0 for failure, 1 for found, 2 for found and line offset added. 4292 */ 4293 static int 4294 normal_search( 4295 cmdarg_T *cap, 4296 int dir, 4297 char_u *pat, 4298 int opt, // extra flags for do_search() 4299 int *wrapped) 4300 { 4301 int i; 4302 searchit_arg_T sia; 4303 4304 cap->oap->motion_type = MCHAR; 4305 cap->oap->inclusive = FALSE; 4306 cap->oap->use_reg_one = TRUE; 4307 curwin->w_set_curswant = TRUE; 4308 4309 CLEAR_FIELD(sia); 4310 i = do_search(cap->oap, dir, dir, pat, cap->count1, 4311 opt | SEARCH_OPT | SEARCH_ECHO | SEARCH_MSG, &sia); 4312 if (wrapped != NULL) 4313 *wrapped = sia.sa_wrapped; 4314 if (i == 0) 4315 clearop(cap->oap); 4316 else 4317 { 4318 if (i == 2) 4319 cap->oap->motion_type = MLINE; 4320 curwin->w_cursor.coladd = 0; 4321 #ifdef FEAT_FOLDING 4322 if (cap->oap->op_type == OP_NOP && (fdo_flags & FDO_SEARCH) && KeyTyped) 4323 foldOpenCursor(); 4324 #endif 4325 } 4326 4327 // "/$" will put the cursor after the end of the line, may need to 4328 // correct that here 4329 check_cursor(); 4330 return i; 4331 } 4332 4333 /* 4334 * Character search commands. 4335 * cap->arg is BACKWARD for 'F' and 'T', FORWARD for 'f' and 't', TRUE for 4336 * ',' and FALSE for ';'. 4337 * cap->nchar is NUL for ',' and ';' (repeat the search) 4338 */ 4339 static void 4340 nv_csearch(cmdarg_T *cap) 4341 { 4342 int t_cmd; 4343 4344 if (cap->cmdchar == 't' || cap->cmdchar == 'T') 4345 t_cmd = TRUE; 4346 else 4347 t_cmd = FALSE; 4348 4349 cap->oap->motion_type = MCHAR; 4350 if (IS_SPECIAL(cap->nchar) || searchc(cap, t_cmd) == FAIL) 4351 clearopbeep(cap->oap); 4352 else 4353 { 4354 curwin->w_set_curswant = TRUE; 4355 // Include a Tab for "tx" and for "dfx". 4356 if (gchar_cursor() == TAB && virtual_active() && cap->arg == FORWARD 4357 && (t_cmd || cap->oap->op_type != OP_NOP)) 4358 { 4359 colnr_T scol, ecol; 4360 4361 getvcol(curwin, &curwin->w_cursor, &scol, NULL, &ecol); 4362 curwin->w_cursor.coladd = ecol - scol; 4363 } 4364 else 4365 curwin->w_cursor.coladd = 0; 4366 adjust_for_sel(cap); 4367 #ifdef FEAT_FOLDING 4368 if ((fdo_flags & FDO_HOR) && KeyTyped && cap->oap->op_type == OP_NOP) 4369 foldOpenCursor(); 4370 #endif 4371 } 4372 } 4373 4374 /* 4375 * "[" and "]" commands. 4376 * cap->arg is BACKWARD for "[" and FORWARD for "]". 4377 */ 4378 static void 4379 nv_brackets(cmdarg_T *cap) 4380 { 4381 pos_T new_pos = {0, 0, 0}; 4382 pos_T prev_pos; 4383 pos_T *pos = NULL; // init for GCC 4384 pos_T old_pos; // cursor position before command 4385 int flag; 4386 long n; 4387 int findc; 4388 int c; 4389 4390 cap->oap->motion_type = MCHAR; 4391 cap->oap->inclusive = FALSE; 4392 old_pos = curwin->w_cursor; 4393 curwin->w_cursor.coladd = 0; // TODO: don't do this for an error. 4394 4395 #ifdef FEAT_SEARCHPATH 4396 /* 4397 * "[f" or "]f" : Edit file under the cursor (same as "gf") 4398 */ 4399 if (cap->nchar == 'f') 4400 nv_gotofile(cap); 4401 else 4402 #endif 4403 4404 #ifdef FEAT_FIND_ID 4405 /* 4406 * Find the occurrence(s) of the identifier or define under cursor 4407 * in current and included files or jump to the first occurrence. 4408 * 4409 * search list jump 4410 * fwd bwd fwd bwd fwd bwd 4411 * identifier "]i" "[i" "]I" "[I" "]^I" "[^I" 4412 * define "]d" "[d" "]D" "[D" "]^D" "[^D" 4413 */ 4414 if (vim_strchr((char_u *) 4415 # ifdef EBCDIC 4416 "iI\005dD\067", 4417 # else 4418 "iI\011dD\004", 4419 # endif 4420 cap->nchar) != NULL) 4421 { 4422 char_u *ptr; 4423 int len; 4424 4425 if ((len = find_ident_under_cursor(&ptr, FIND_IDENT)) == 0) 4426 clearop(cap->oap); 4427 else 4428 { 4429 find_pattern_in_path(ptr, 0, len, TRUE, 4430 cap->count0 == 0 ? !isupper(cap->nchar) : FALSE, 4431 ((cap->nchar & 0xf) == ('d' & 0xf)) ? FIND_DEFINE : FIND_ANY, 4432 cap->count1, 4433 isupper(cap->nchar) ? ACTION_SHOW_ALL : 4434 islower(cap->nchar) ? ACTION_SHOW : ACTION_GOTO, 4435 cap->cmdchar == ']' ? curwin->w_cursor.lnum + 1 : (linenr_T)1, 4436 (linenr_T)MAXLNUM); 4437 curwin->w_set_curswant = TRUE; 4438 } 4439 } 4440 else 4441 #endif 4442 4443 /* 4444 * "[{", "[(", "]}" or "])": go to Nth unclosed '{', '(', '}' or ')' 4445 * "[#", "]#": go to start/end of Nth innermost #if..#endif construct. 4446 * "[/", "[*", "]/", "]*": go to Nth comment start/end. 4447 * "[m" or "]m" search for prev/next start of (Java) method. 4448 * "[M" or "]M" search for prev/next end of (Java) method. 4449 */ 4450 if ( (cap->cmdchar == '[' 4451 && vim_strchr((char_u *)"{(*/#mM", cap->nchar) != NULL) 4452 || (cap->cmdchar == ']' 4453 && vim_strchr((char_u *)"})*/#mM", cap->nchar) != NULL)) 4454 { 4455 if (cap->nchar == '*') 4456 cap->nchar = '/'; 4457 prev_pos.lnum = 0; 4458 if (cap->nchar == 'm' || cap->nchar == 'M') 4459 { 4460 if (cap->cmdchar == '[') 4461 findc = '{'; 4462 else 4463 findc = '}'; 4464 n = 9999; 4465 } 4466 else 4467 { 4468 findc = cap->nchar; 4469 n = cap->count1; 4470 } 4471 for ( ; n > 0; --n) 4472 { 4473 if ((pos = findmatchlimit(cap->oap, findc, 4474 (cap->cmdchar == '[') ? FM_BACKWARD : FM_FORWARD, 0)) == NULL) 4475 { 4476 if (new_pos.lnum == 0) // nothing found 4477 { 4478 if (cap->nchar != 'm' && cap->nchar != 'M') 4479 clearopbeep(cap->oap); 4480 } 4481 else 4482 pos = &new_pos; // use last one found 4483 break; 4484 } 4485 prev_pos = new_pos; 4486 curwin->w_cursor = *pos; 4487 new_pos = *pos; 4488 } 4489 curwin->w_cursor = old_pos; 4490 4491 /* 4492 * Handle "[m", "]m", "[M" and "[M". The findmatchlimit() only 4493 * brought us to the match for "[m" and "]M" when inside a method. 4494 * Try finding the '{' or '}' we want to be at. 4495 * Also repeat for the given count. 4496 */ 4497 if (cap->nchar == 'm' || cap->nchar == 'M') 4498 { 4499 // norm is TRUE for "]M" and "[m" 4500 int norm = ((findc == '{') == (cap->nchar == 'm')); 4501 4502 n = cap->count1; 4503 // found a match: we were inside a method 4504 if (prev_pos.lnum != 0) 4505 { 4506 pos = &prev_pos; 4507 curwin->w_cursor = prev_pos; 4508 if (norm) 4509 --n; 4510 } 4511 else 4512 pos = NULL; 4513 while (n > 0) 4514 { 4515 for (;;) 4516 { 4517 if ((findc == '{' ? dec_cursor() : inc_cursor()) < 0) 4518 { 4519 // if not found anything, that's an error 4520 if (pos == NULL) 4521 clearopbeep(cap->oap); 4522 n = 0; 4523 break; 4524 } 4525 c = gchar_cursor(); 4526 if (c == '{' || c == '}') 4527 { 4528 // Must have found end/start of class: use it. 4529 // Or found the place to be at. 4530 if ((c == findc && norm) || (n == 1 && !norm)) 4531 { 4532 new_pos = curwin->w_cursor; 4533 pos = &new_pos; 4534 n = 0; 4535 } 4536 // if no match found at all, we started outside of the 4537 // class and we're inside now. Just go on. 4538 else if (new_pos.lnum == 0) 4539 { 4540 new_pos = curwin->w_cursor; 4541 pos = &new_pos; 4542 } 4543 // found start/end of other method: go to match 4544 else if ((pos = findmatchlimit(cap->oap, findc, 4545 (cap->cmdchar == '[') ? FM_BACKWARD : FM_FORWARD, 4546 0)) == NULL) 4547 n = 0; 4548 else 4549 curwin->w_cursor = *pos; 4550 break; 4551 } 4552 } 4553 --n; 4554 } 4555 curwin->w_cursor = old_pos; 4556 if (pos == NULL && new_pos.lnum != 0) 4557 clearopbeep(cap->oap); 4558 } 4559 if (pos != NULL) 4560 { 4561 setpcmark(); 4562 curwin->w_cursor = *pos; 4563 curwin->w_set_curswant = TRUE; 4564 #ifdef FEAT_FOLDING 4565 if ((fdo_flags & FDO_BLOCK) && KeyTyped 4566 && cap->oap->op_type == OP_NOP) 4567 foldOpenCursor(); 4568 #endif 4569 } 4570 } 4571 4572 /* 4573 * "[[", "[]", "]]" and "][": move to start or end of function 4574 */ 4575 else if (cap->nchar == '[' || cap->nchar == ']') 4576 { 4577 if (cap->nchar == cap->cmdchar) // "]]" or "[[" 4578 flag = '{'; 4579 else 4580 flag = '}'; // "][" or "[]" 4581 4582 curwin->w_set_curswant = TRUE; 4583 /* 4584 * Imitate strange Vi behaviour: When using "]]" with an operator 4585 * we also stop at '}'. 4586 */ 4587 if (!findpar(&cap->oap->inclusive, cap->arg, cap->count1, flag, 4588 (cap->oap->op_type != OP_NOP 4589 && cap->arg == FORWARD && flag == '{'))) 4590 clearopbeep(cap->oap); 4591 else 4592 { 4593 if (cap->oap->op_type == OP_NOP) 4594 beginline(BL_WHITE | BL_FIX); 4595 #ifdef FEAT_FOLDING 4596 if ((fdo_flags & FDO_BLOCK) && KeyTyped && cap->oap->op_type == OP_NOP) 4597 foldOpenCursor(); 4598 #endif 4599 } 4600 } 4601 4602 /* 4603 * "[p", "[P", "]P" and "]p": put with indent adjustment 4604 */ 4605 else if (cap->nchar == 'p' || cap->nchar == 'P') 4606 { 4607 nv_put_opt(cap, TRUE); 4608 } 4609 4610 /* 4611 * "['", "[`", "]'" and "]`": jump to next mark 4612 */ 4613 else if (cap->nchar == '\'' || cap->nchar == '`') 4614 { 4615 pos = &curwin->w_cursor; 4616 for (n = cap->count1; n > 0; --n) 4617 { 4618 prev_pos = *pos; 4619 pos = getnextmark(pos, cap->cmdchar == '[' ? BACKWARD : FORWARD, 4620 cap->nchar == '\''); 4621 if (pos == NULL) 4622 break; 4623 } 4624 if (pos == NULL) 4625 pos = &prev_pos; 4626 nv_cursormark(cap, cap->nchar == '\'', pos); 4627 } 4628 4629 /* 4630 * [ or ] followed by a middle mouse click: put selected text with 4631 * indent adjustment. Any other button just does as usual. 4632 */ 4633 else if (cap->nchar >= K_RIGHTRELEASE && cap->nchar <= K_LEFTMOUSE) 4634 { 4635 (void)do_mouse(cap->oap, cap->nchar, 4636 (cap->cmdchar == ']') ? FORWARD : BACKWARD, 4637 cap->count1, PUT_FIXINDENT); 4638 } 4639 4640 #ifdef FEAT_FOLDING 4641 /* 4642 * "[z" and "]z": move to start or end of open fold. 4643 */ 4644 else if (cap->nchar == 'z') 4645 { 4646 if (foldMoveTo(FALSE, cap->cmdchar == ']' ? FORWARD : BACKWARD, 4647 cap->count1) == FAIL) 4648 clearopbeep(cap->oap); 4649 } 4650 #endif 4651 4652 #ifdef FEAT_DIFF 4653 /* 4654 * "[c" and "]c": move to next or previous diff-change. 4655 */ 4656 else if (cap->nchar == 'c') 4657 { 4658 if (diff_move_to(cap->cmdchar == ']' ? FORWARD : BACKWARD, 4659 cap->count1) == FAIL) 4660 clearopbeep(cap->oap); 4661 } 4662 #endif 4663 4664 #ifdef FEAT_SPELL 4665 /* 4666 * "[s", "[S", "]s" and "]S": move to next spell error. 4667 */ 4668 else if (cap->nchar == 's' || cap->nchar == 'S') 4669 { 4670 setpcmark(); 4671 for (n = 0; n < cap->count1; ++n) 4672 if (spell_move_to(curwin, cap->cmdchar == ']' ? FORWARD : BACKWARD, 4673 cap->nchar == 's' ? TRUE : FALSE, FALSE, NULL) == 0) 4674 { 4675 clearopbeep(cap->oap); 4676 break; 4677 } 4678 else 4679 curwin->w_set_curswant = TRUE; 4680 # ifdef FEAT_FOLDING 4681 if (cap->oap->op_type == OP_NOP && (fdo_flags & FDO_SEARCH) && KeyTyped) 4682 foldOpenCursor(); 4683 # endif 4684 } 4685 #endif 4686 4687 // Not a valid cap->nchar. 4688 else 4689 clearopbeep(cap->oap); 4690 } 4691 4692 /* 4693 * Handle Normal mode "%" command. 4694 */ 4695 static void 4696 nv_percent(cmdarg_T *cap) 4697 { 4698 pos_T *pos; 4699 #if defined(FEAT_FOLDING) 4700 linenr_T lnum = curwin->w_cursor.lnum; 4701 #endif 4702 4703 cap->oap->inclusive = TRUE; 4704 if (cap->count0) // {cnt}% : goto {cnt} percentage in file 4705 { 4706 if (cap->count0 > 100) 4707 clearopbeep(cap->oap); 4708 else 4709 { 4710 cap->oap->motion_type = MLINE; 4711 setpcmark(); 4712 // Round up, so CTRL-G will give same value. Watch out for a 4713 // large line count, the line number must not go negative! 4714 if (curbuf->b_ml.ml_line_count > 1000000) 4715 curwin->w_cursor.lnum = (curbuf->b_ml.ml_line_count + 99L) 4716 / 100L * cap->count0; 4717 else 4718 curwin->w_cursor.lnum = (curbuf->b_ml.ml_line_count * 4719 cap->count0 + 99L) / 100L; 4720 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) 4721 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; 4722 beginline(BL_SOL | BL_FIX); 4723 } 4724 } 4725 else // "%" : go to matching paren 4726 { 4727 cap->oap->motion_type = MCHAR; 4728 cap->oap->use_reg_one = TRUE; 4729 if ((pos = findmatch(cap->oap, NUL)) == NULL) 4730 clearopbeep(cap->oap); 4731 else 4732 { 4733 setpcmark(); 4734 curwin->w_cursor = *pos; 4735 curwin->w_set_curswant = TRUE; 4736 curwin->w_cursor.coladd = 0; 4737 adjust_for_sel(cap); 4738 } 4739 } 4740 #ifdef FEAT_FOLDING 4741 if (cap->oap->op_type == OP_NOP 4742 && lnum != curwin->w_cursor.lnum 4743 && (fdo_flags & FDO_PERCENT) 4744 && KeyTyped) 4745 foldOpenCursor(); 4746 #endif 4747 } 4748 4749 /* 4750 * Handle "(" and ")" commands. 4751 * cap->arg is BACKWARD for "(" and FORWARD for ")". 4752 */ 4753 static void 4754 nv_brace(cmdarg_T *cap) 4755 { 4756 cap->oap->motion_type = MCHAR; 4757 cap->oap->use_reg_one = TRUE; 4758 // The motion used to be inclusive for "(", but that is not what Vi does. 4759 cap->oap->inclusive = FALSE; 4760 curwin->w_set_curswant = TRUE; 4761 4762 if (findsent(cap->arg, cap->count1) == FAIL) 4763 clearopbeep(cap->oap); 4764 else 4765 { 4766 // Don't leave the cursor on the NUL past end of line. 4767 adjust_cursor(cap->oap); 4768 curwin->w_cursor.coladd = 0; 4769 #ifdef FEAT_FOLDING 4770 if ((fdo_flags & FDO_BLOCK) && KeyTyped && cap->oap->op_type == OP_NOP) 4771 foldOpenCursor(); 4772 #endif 4773 } 4774 } 4775 4776 /* 4777 * "m" command: Mark a position. 4778 */ 4779 static void 4780 nv_mark(cmdarg_T *cap) 4781 { 4782 if (!checkclearop(cap->oap)) 4783 { 4784 if (setmark(cap->nchar) == FAIL) 4785 clearopbeep(cap->oap); 4786 } 4787 } 4788 4789 /* 4790 * "{" and "}" commands. 4791 * cmd->arg is BACKWARD for "{" and FORWARD for "}". 4792 */ 4793 static void 4794 nv_findpar(cmdarg_T *cap) 4795 { 4796 cap->oap->motion_type = MCHAR; 4797 cap->oap->inclusive = FALSE; 4798 cap->oap->use_reg_one = TRUE; 4799 curwin->w_set_curswant = TRUE; 4800 if (!findpar(&cap->oap->inclusive, cap->arg, cap->count1, NUL, FALSE)) 4801 clearopbeep(cap->oap); 4802 else 4803 { 4804 curwin->w_cursor.coladd = 0; 4805 #ifdef FEAT_FOLDING 4806 if ((fdo_flags & FDO_BLOCK) && KeyTyped && cap->oap->op_type == OP_NOP) 4807 foldOpenCursor(); 4808 #endif 4809 } 4810 } 4811 4812 /* 4813 * "u" command: Undo or make lower case. 4814 */ 4815 static void 4816 nv_undo(cmdarg_T *cap) 4817 { 4818 if (cap->oap->op_type == OP_LOWER || VIsual_active) 4819 { 4820 // translate "<Visual>u" to "<Visual>gu" and "guu" to "gugu" 4821 cap->cmdchar = 'g'; 4822 cap->nchar = 'u'; 4823 nv_operator(cap); 4824 } 4825 else 4826 nv_kundo(cap); 4827 } 4828 4829 /* 4830 * <Undo> command. 4831 */ 4832 static void 4833 nv_kundo(cmdarg_T *cap) 4834 { 4835 if (!checkclearopq(cap->oap)) 4836 { 4837 #ifdef FEAT_JOB_CHANNEL 4838 if (bt_prompt(curbuf)) 4839 { 4840 clearopbeep(cap->oap); 4841 return; 4842 } 4843 #endif 4844 u_undo((int)cap->count1); 4845 curwin->w_set_curswant = TRUE; 4846 } 4847 } 4848 4849 /* 4850 * Handle the "r" command. 4851 */ 4852 static void 4853 nv_replace(cmdarg_T *cap) 4854 { 4855 char_u *ptr; 4856 int had_ctrl_v; 4857 long n; 4858 4859 if (checkclearop(cap->oap)) 4860 return; 4861 #ifdef FEAT_JOB_CHANNEL 4862 if (bt_prompt(curbuf) && !prompt_curpos_editable()) 4863 { 4864 clearopbeep(cap->oap); 4865 return; 4866 } 4867 #endif 4868 4869 // get another character 4870 if (cap->nchar == Ctrl_V) 4871 { 4872 had_ctrl_v = Ctrl_V; 4873 cap->nchar = get_literal(); 4874 // Don't redo a multibyte character with CTRL-V. 4875 if (cap->nchar > DEL) 4876 had_ctrl_v = NUL; 4877 } 4878 else 4879 had_ctrl_v = NUL; 4880 4881 // Abort if the character is a special key. 4882 if (IS_SPECIAL(cap->nchar)) 4883 { 4884 clearopbeep(cap->oap); 4885 return; 4886 } 4887 4888 // Visual mode "r" 4889 if (VIsual_active) 4890 { 4891 if (got_int) 4892 reset_VIsual(); 4893 if (had_ctrl_v) 4894 { 4895 // Use a special (negative) number to make a difference between a 4896 // literal CR or NL and a line break. 4897 if (cap->nchar == CAR) 4898 cap->nchar = REPLACE_CR_NCHAR; 4899 else if (cap->nchar == NL) 4900 cap->nchar = REPLACE_NL_NCHAR; 4901 } 4902 nv_operator(cap); 4903 return; 4904 } 4905 4906 // Break tabs, etc. 4907 if (virtual_active()) 4908 { 4909 if (u_save_cursor() == FAIL) 4910 return; 4911 if (gchar_cursor() == NUL) 4912 { 4913 // Add extra space and put the cursor on the first one. 4914 coladvance_force((colnr_T)(getviscol() + cap->count1)); 4915 curwin->w_cursor.col -= cap->count1; 4916 } 4917 else if (gchar_cursor() == TAB) 4918 coladvance_force(getviscol()); 4919 } 4920 4921 // Abort if not enough characters to replace. 4922 ptr = ml_get_cursor(); 4923 if (STRLEN(ptr) < (unsigned)cap->count1 4924 || (has_mbyte && mb_charlen(ptr) < cap->count1)) 4925 { 4926 clearopbeep(cap->oap); 4927 return; 4928 } 4929 4930 /* 4931 * Replacing with a TAB is done by edit() when it is complicated because 4932 * 'expandtab' or 'smarttab' is set. CTRL-V TAB inserts a literal TAB. 4933 * Other characters are done below to avoid problems with things like 4934 * CTRL-V 048 (for edit() this would be R CTRL-V 0 ESC). 4935 */ 4936 if (had_ctrl_v != Ctrl_V && cap->nchar == '\t' && (curbuf->b_p_et || p_sta)) 4937 { 4938 stuffnumReadbuff(cap->count1); 4939 stuffcharReadbuff('R'); 4940 stuffcharReadbuff('\t'); 4941 stuffcharReadbuff(ESC); 4942 return; 4943 } 4944 4945 // save line for undo 4946 if (u_save_cursor() == FAIL) 4947 return; 4948 4949 if (had_ctrl_v != Ctrl_V && (cap->nchar == '\r' || cap->nchar == '\n')) 4950 { 4951 /* 4952 * Replace character(s) by a single newline. 4953 * Strange vi behaviour: Only one newline is inserted. 4954 * Delete the characters here. 4955 * Insert the newline with an insert command, takes care of 4956 * autoindent. The insert command depends on being on the last 4957 * character of a line or not. 4958 */ 4959 (void)del_chars(cap->count1, FALSE); // delete the characters 4960 stuffcharReadbuff('\r'); 4961 stuffcharReadbuff(ESC); 4962 4963 // Give 'r' to edit(), to get the redo command right. 4964 invoke_edit(cap, TRUE, 'r', FALSE); 4965 } 4966 else 4967 { 4968 prep_redo(cap->oap->regname, cap->count1, 4969 NUL, 'r', NUL, had_ctrl_v, cap->nchar); 4970 4971 curbuf->b_op_start = curwin->w_cursor; 4972 if (has_mbyte) 4973 { 4974 int old_State = State; 4975 4976 if (cap->ncharC1 != 0) 4977 AppendCharToRedobuff(cap->ncharC1); 4978 if (cap->ncharC2 != 0) 4979 AppendCharToRedobuff(cap->ncharC2); 4980 4981 // This is slow, but it handles replacing a single-byte with a 4982 // multi-byte and the other way around. Also handles adding 4983 // composing characters for utf-8. 4984 for (n = cap->count1; n > 0; --n) 4985 { 4986 State = REPLACE; 4987 if (cap->nchar == Ctrl_E || cap->nchar == Ctrl_Y) 4988 { 4989 int c = ins_copychar(curwin->w_cursor.lnum 4990 + (cap->nchar == Ctrl_Y ? -1 : 1)); 4991 if (c != NUL) 4992 ins_char(c); 4993 else 4994 // will be decremented further down 4995 ++curwin->w_cursor.col; 4996 } 4997 else 4998 ins_char(cap->nchar); 4999 State = old_State; 5000 if (cap->ncharC1 != 0) 5001 ins_char(cap->ncharC1); 5002 if (cap->ncharC2 != 0) 5003 ins_char(cap->ncharC2); 5004 } 5005 } 5006 else 5007 { 5008 /* 5009 * Replace the characters within one line. 5010 */ 5011 for (n = cap->count1; n > 0; --n) 5012 { 5013 /* 5014 * Get ptr again, because u_save and/or showmatch() will have 5015 * released the line. At the same time we let know that the 5016 * line will be changed. 5017 */ 5018 ptr = ml_get_buf(curbuf, curwin->w_cursor.lnum, TRUE); 5019 if (cap->nchar == Ctrl_E || cap->nchar == Ctrl_Y) 5020 { 5021 int c = ins_copychar(curwin->w_cursor.lnum 5022 + (cap->nchar == Ctrl_Y ? -1 : 1)); 5023 if (c != NUL) 5024 ptr[curwin->w_cursor.col] = c; 5025 } 5026 else 5027 ptr[curwin->w_cursor.col] = cap->nchar; 5028 if (p_sm && msg_silent == 0) 5029 showmatch(cap->nchar); 5030 ++curwin->w_cursor.col; 5031 } 5032 #ifdef FEAT_NETBEANS_INTG 5033 if (netbeans_active()) 5034 { 5035 colnr_T start = (colnr_T)(curwin->w_cursor.col - cap->count1); 5036 5037 netbeans_removed(curbuf, curwin->w_cursor.lnum, start, 5038 (long)cap->count1); 5039 netbeans_inserted(curbuf, curwin->w_cursor.lnum, start, 5040 &ptr[start], (int)cap->count1); 5041 } 5042 #endif 5043 5044 // mark the buffer as changed and prepare for displaying 5045 changed_bytes(curwin->w_cursor.lnum, 5046 (colnr_T)(curwin->w_cursor.col - cap->count1)); 5047 } 5048 --curwin->w_cursor.col; // cursor on the last replaced char 5049 // if the character on the left of the current cursor is a multi-byte 5050 // character, move two characters left 5051 if (has_mbyte) 5052 mb_adjust_cursor(); 5053 curbuf->b_op_end = curwin->w_cursor; 5054 curwin->w_set_curswant = TRUE; 5055 set_last_insert(cap->nchar); 5056 } 5057 } 5058 5059 /* 5060 * 'o': Exchange start and end of Visual area. 5061 * 'O': same, but in block mode exchange left and right corners. 5062 */ 5063 static void 5064 v_swap_corners(int cmdchar) 5065 { 5066 pos_T old_cursor; 5067 colnr_T left, right; 5068 5069 if (cmdchar == 'O' && VIsual_mode == Ctrl_V) 5070 { 5071 old_cursor = curwin->w_cursor; 5072 getvcols(curwin, &old_cursor, &VIsual, &left, &right); 5073 curwin->w_cursor.lnum = VIsual.lnum; 5074 coladvance(left); 5075 VIsual = curwin->w_cursor; 5076 5077 curwin->w_cursor.lnum = old_cursor.lnum; 5078 curwin->w_curswant = right; 5079 // 'selection "exclusive" and cursor at right-bottom corner: move it 5080 // right one column 5081 if (old_cursor.lnum >= VIsual.lnum && *p_sel == 'e') 5082 ++curwin->w_curswant; 5083 coladvance(curwin->w_curswant); 5084 if (curwin->w_cursor.col == old_cursor.col 5085 && (!virtual_active() 5086 || curwin->w_cursor.coladd == old_cursor.coladd)) 5087 { 5088 curwin->w_cursor.lnum = VIsual.lnum; 5089 if (old_cursor.lnum <= VIsual.lnum && *p_sel == 'e') 5090 ++right; 5091 coladvance(right); 5092 VIsual = curwin->w_cursor; 5093 5094 curwin->w_cursor.lnum = old_cursor.lnum; 5095 coladvance(left); 5096 curwin->w_curswant = left; 5097 } 5098 } 5099 else 5100 { 5101 old_cursor = curwin->w_cursor; 5102 curwin->w_cursor = VIsual; 5103 VIsual = old_cursor; 5104 curwin->w_set_curswant = TRUE; 5105 } 5106 } 5107 5108 /* 5109 * "R" (cap->arg is FALSE) and "gR" (cap->arg is TRUE). 5110 */ 5111 static void 5112 nv_Replace(cmdarg_T *cap) 5113 { 5114 if (VIsual_active) // "R" is replace lines 5115 { 5116 cap->cmdchar = 'c'; 5117 cap->nchar = NUL; 5118 VIsual_mode_orig = VIsual_mode; // remember original area for gv 5119 VIsual_mode = 'V'; 5120 nv_operator(cap); 5121 } 5122 else if (!checkclearopq(cap->oap)) 5123 { 5124 if (!curbuf->b_p_ma) 5125 emsg(_(e_modifiable)); 5126 else 5127 { 5128 if (virtual_active()) 5129 coladvance(getviscol()); 5130 invoke_edit(cap, FALSE, cap->arg ? 'V' : 'R', FALSE); 5131 } 5132 } 5133 } 5134 5135 /* 5136 * "gr". 5137 */ 5138 static void 5139 nv_vreplace(cmdarg_T *cap) 5140 { 5141 if (VIsual_active) 5142 { 5143 cap->cmdchar = 'r'; 5144 cap->nchar = cap->extra_char; 5145 nv_replace(cap); // Do same as "r" in Visual mode for now 5146 } 5147 else if (!checkclearopq(cap->oap)) 5148 { 5149 if (!curbuf->b_p_ma) 5150 emsg(_(e_modifiable)); 5151 else 5152 { 5153 if (cap->extra_char == Ctrl_V) // get another character 5154 cap->extra_char = get_literal(); 5155 stuffcharReadbuff(cap->extra_char); 5156 stuffcharReadbuff(ESC); 5157 if (virtual_active()) 5158 coladvance(getviscol()); 5159 invoke_edit(cap, TRUE, 'v', FALSE); 5160 } 5161 } 5162 } 5163 5164 /* 5165 * Swap case for "~" command, when it does not work like an operator. 5166 */ 5167 static void 5168 n_swapchar(cmdarg_T *cap) 5169 { 5170 long n; 5171 pos_T startpos; 5172 int did_change = 0; 5173 #ifdef FEAT_NETBEANS_INTG 5174 pos_T pos; 5175 char_u *ptr; 5176 int count; 5177 #endif 5178 5179 if (checkclearopq(cap->oap)) 5180 return; 5181 5182 if (LINEEMPTY(curwin->w_cursor.lnum) && vim_strchr(p_ww, '~') == NULL) 5183 { 5184 clearopbeep(cap->oap); 5185 return; 5186 } 5187 5188 prep_redo_cmd(cap); 5189 5190 if (u_save_cursor() == FAIL) 5191 return; 5192 5193 startpos = curwin->w_cursor; 5194 #ifdef FEAT_NETBEANS_INTG 5195 pos = startpos; 5196 #endif 5197 for (n = cap->count1; n > 0; --n) 5198 { 5199 did_change |= swapchar(cap->oap->op_type, &curwin->w_cursor); 5200 inc_cursor(); 5201 if (gchar_cursor() == NUL) 5202 { 5203 if (vim_strchr(p_ww, '~') != NULL 5204 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) 5205 { 5206 #ifdef FEAT_NETBEANS_INTG 5207 if (netbeans_active()) 5208 { 5209 if (did_change) 5210 { 5211 ptr = ml_get(pos.lnum); 5212 count = (int)STRLEN(ptr) - pos.col; 5213 netbeans_removed(curbuf, pos.lnum, pos.col, 5214 (long)count); 5215 netbeans_inserted(curbuf, pos.lnum, pos.col, 5216 &ptr[pos.col], count); 5217 } 5218 pos.col = 0; 5219 pos.lnum++; 5220 } 5221 #endif 5222 ++curwin->w_cursor.lnum; 5223 curwin->w_cursor.col = 0; 5224 if (n > 1) 5225 { 5226 if (u_savesub(curwin->w_cursor.lnum) == FAIL) 5227 break; 5228 u_clearline(); 5229 } 5230 } 5231 else 5232 break; 5233 } 5234 } 5235 #ifdef FEAT_NETBEANS_INTG 5236 if (did_change && netbeans_active()) 5237 { 5238 ptr = ml_get(pos.lnum); 5239 count = curwin->w_cursor.col - pos.col; 5240 netbeans_removed(curbuf, pos.lnum, pos.col, (long)count); 5241 netbeans_inserted(curbuf, pos.lnum, pos.col, &ptr[pos.col], count); 5242 } 5243 #endif 5244 5245 5246 check_cursor(); 5247 curwin->w_set_curswant = TRUE; 5248 if (did_change) 5249 { 5250 changed_lines(startpos.lnum, startpos.col, curwin->w_cursor.lnum + 1, 5251 0L); 5252 curbuf->b_op_start = startpos; 5253 curbuf->b_op_end = curwin->w_cursor; 5254 if (curbuf->b_op_end.col > 0) 5255 --curbuf->b_op_end.col; 5256 } 5257 } 5258 5259 /* 5260 * Move cursor to mark. 5261 */ 5262 static void 5263 nv_cursormark(cmdarg_T *cap, int flag, pos_T *pos) 5264 { 5265 if (check_mark(pos) == FAIL) 5266 clearop(cap->oap); 5267 else 5268 { 5269 if (cap->cmdchar == '\'' 5270 || cap->cmdchar == '`' 5271 || cap->cmdchar == '[' 5272 || cap->cmdchar == ']') 5273 setpcmark(); 5274 curwin->w_cursor = *pos; 5275 if (flag) 5276 beginline(BL_WHITE | BL_FIX); 5277 else 5278 check_cursor(); 5279 } 5280 cap->oap->motion_type = flag ? MLINE : MCHAR; 5281 if (cap->cmdchar == '`') 5282 cap->oap->use_reg_one = TRUE; 5283 cap->oap->inclusive = FALSE; // ignored if not MCHAR 5284 curwin->w_set_curswant = TRUE; 5285 } 5286 5287 /* 5288 * Handle commands that are operators in Visual mode. 5289 */ 5290 static void 5291 v_visop(cmdarg_T *cap) 5292 { 5293 static char_u trans[] = "YyDdCcxdXdAAIIrr"; 5294 5295 // Uppercase means linewise, except in block mode, then "D" deletes till 5296 // the end of the line, and "C" replaces till EOL 5297 if (isupper(cap->cmdchar)) 5298 { 5299 if (VIsual_mode != Ctrl_V) 5300 { 5301 VIsual_mode_orig = VIsual_mode; 5302 VIsual_mode = 'V'; 5303 } 5304 else if (cap->cmdchar == 'C' || cap->cmdchar == 'D') 5305 curwin->w_curswant = MAXCOL; 5306 } 5307 cap->cmdchar = *(vim_strchr(trans, cap->cmdchar) + 1); 5308 nv_operator(cap); 5309 } 5310 5311 /* 5312 * "s" and "S" commands. 5313 */ 5314 static void 5315 nv_subst(cmdarg_T *cap) 5316 { 5317 #ifdef FEAT_TERMINAL 5318 // When showing output of term_dumpdiff() swap the top and botom. 5319 if (term_swap_diff() == OK) 5320 return; 5321 #endif 5322 #ifdef FEAT_JOB_CHANNEL 5323 if (bt_prompt(curbuf) && !prompt_curpos_editable()) 5324 { 5325 clearopbeep(cap->oap); 5326 return; 5327 } 5328 #endif 5329 if (VIsual_active) // "vs" and "vS" are the same as "vc" 5330 { 5331 if (cap->cmdchar == 'S') 5332 { 5333 VIsual_mode_orig = VIsual_mode; 5334 VIsual_mode = 'V'; 5335 } 5336 cap->cmdchar = 'c'; 5337 nv_operator(cap); 5338 } 5339 else 5340 nv_optrans(cap); 5341 } 5342 5343 /* 5344 * Abbreviated commands. 5345 */ 5346 static void 5347 nv_abbrev(cmdarg_T *cap) 5348 { 5349 if (cap->cmdchar == K_DEL || cap->cmdchar == K_KDEL) 5350 cap->cmdchar = 'x'; // DEL key behaves like 'x' 5351 5352 // in Visual mode these commands are operators 5353 if (VIsual_active) 5354 v_visop(cap); 5355 else 5356 nv_optrans(cap); 5357 } 5358 5359 /* 5360 * Translate a command into another command. 5361 */ 5362 static void 5363 nv_optrans(cmdarg_T *cap) 5364 { 5365 static char_u *(ar[8]) = {(char_u *)"dl", (char_u *)"dh", 5366 (char_u *)"d$", (char_u *)"c$", 5367 (char_u *)"cl", (char_u *)"cc", 5368 (char_u *)"yy", (char_u *)":s\r"}; 5369 static char_u *str = (char_u *)"xXDCsSY&"; 5370 5371 if (!checkclearopq(cap->oap)) 5372 { 5373 // In Vi "2D" doesn't delete the next line. Can't translate it 5374 // either, because "2." should also not use the count. 5375 if (cap->cmdchar == 'D' && vim_strchr(p_cpo, CPO_HASH) != NULL) 5376 { 5377 cap->oap->start = curwin->w_cursor; 5378 cap->oap->op_type = OP_DELETE; 5379 #ifdef FEAT_EVAL 5380 set_op_var(OP_DELETE); 5381 #endif 5382 cap->count1 = 1; 5383 nv_dollar(cap); 5384 finish_op = TRUE; 5385 ResetRedobuff(); 5386 AppendCharToRedobuff('D'); 5387 } 5388 else 5389 { 5390 if (cap->count0) 5391 stuffnumReadbuff(cap->count0); 5392 stuffReadbuff(ar[(int)(vim_strchr(str, cap->cmdchar) - str)]); 5393 } 5394 } 5395 cap->opcount = 0; 5396 } 5397 5398 /* 5399 * "'" and "`" commands. Also for "g'" and "g`". 5400 * cap->arg is TRUE for "'" and "g'". 5401 */ 5402 static void 5403 nv_gomark(cmdarg_T *cap) 5404 { 5405 pos_T *pos; 5406 int c; 5407 #ifdef FEAT_FOLDING 5408 pos_T old_cursor = curwin->w_cursor; 5409 int old_KeyTyped = KeyTyped; // getting file may reset it 5410 #endif 5411 5412 if (cap->cmdchar == 'g') 5413 c = cap->extra_char; 5414 else 5415 c = cap->nchar; 5416 pos = getmark(c, (cap->oap->op_type == OP_NOP)); 5417 if (pos == (pos_T *)-1) // jumped to other file 5418 { 5419 if (cap->arg) 5420 { 5421 check_cursor_lnum(); 5422 beginline(BL_WHITE | BL_FIX); 5423 } 5424 else 5425 check_cursor(); 5426 } 5427 else 5428 nv_cursormark(cap, cap->arg, pos); 5429 5430 // May need to clear the coladd that a mark includes. 5431 if (!virtual_active()) 5432 curwin->w_cursor.coladd = 0; 5433 check_cursor_col(); 5434 #ifdef FEAT_FOLDING 5435 if (cap->oap->op_type == OP_NOP 5436 && pos != NULL 5437 && (pos == (pos_T *)-1 || !EQUAL_POS(old_cursor, *pos)) 5438 && (fdo_flags & FDO_MARK) 5439 && old_KeyTyped) 5440 foldOpenCursor(); 5441 #endif 5442 } 5443 5444 /* 5445 * Handle CTRL-O, CTRL-I, "g;" and "g," commands. 5446 */ 5447 static void 5448 nv_pcmark(cmdarg_T *cap) 5449 { 5450 #ifdef FEAT_JUMPLIST 5451 pos_T *pos; 5452 # ifdef FEAT_FOLDING 5453 linenr_T lnum = curwin->w_cursor.lnum; 5454 int old_KeyTyped = KeyTyped; // getting file may reset it 5455 # endif 5456 5457 if (!checkclearopq(cap->oap)) 5458 { 5459 if (cap->cmdchar == 'g') 5460 pos = movechangelist((int)cap->count1); 5461 else 5462 pos = movemark((int)cap->count1); 5463 if (pos == (pos_T *)-1) // jump to other file 5464 { 5465 curwin->w_set_curswant = TRUE; 5466 check_cursor(); 5467 } 5468 else if (pos != NULL) // can jump 5469 nv_cursormark(cap, FALSE, pos); 5470 else if (cap->cmdchar == 'g') 5471 { 5472 if (curbuf->b_changelistlen == 0) 5473 emsg(_("E664: changelist is empty")); 5474 else if (cap->count1 < 0) 5475 emsg(_("E662: At start of changelist")); 5476 else 5477 emsg(_("E663: At end of changelist")); 5478 } 5479 else 5480 clearopbeep(cap->oap); 5481 # ifdef FEAT_FOLDING 5482 if (cap->oap->op_type == OP_NOP 5483 && (pos == (pos_T *)-1 || lnum != curwin->w_cursor.lnum) 5484 && (fdo_flags & FDO_MARK) 5485 && old_KeyTyped) 5486 foldOpenCursor(); 5487 # endif 5488 } 5489 #else 5490 clearopbeep(cap->oap); 5491 #endif 5492 } 5493 5494 /* 5495 * Handle '"' command. 5496 */ 5497 static void 5498 nv_regname(cmdarg_T *cap) 5499 { 5500 if (checkclearop(cap->oap)) 5501 return; 5502 #ifdef FEAT_EVAL 5503 if (cap->nchar == '=') 5504 cap->nchar = get_expr_register(); 5505 #endif 5506 if (cap->nchar != NUL && valid_yank_reg(cap->nchar, FALSE)) 5507 { 5508 cap->oap->regname = cap->nchar; 5509 cap->opcount = cap->count0; // remember count before '"' 5510 #ifdef FEAT_EVAL 5511 set_reg_var(cap->oap->regname); 5512 #endif 5513 } 5514 else 5515 clearopbeep(cap->oap); 5516 } 5517 5518 /* 5519 * Handle "v", "V" and "CTRL-V" commands. 5520 * Also for "gh", "gH" and "g^H" commands: Always start Select mode, cap->arg 5521 * is TRUE. 5522 * Handle CTRL-Q just like CTRL-V. 5523 */ 5524 static void 5525 nv_visual(cmdarg_T *cap) 5526 { 5527 if (cap->cmdchar == Ctrl_Q) 5528 cap->cmdchar = Ctrl_V; 5529 5530 // 'v', 'V' and CTRL-V can be used while an operator is pending to make it 5531 // characterwise, linewise, or blockwise. 5532 if (cap->oap->op_type != OP_NOP) 5533 { 5534 motion_force = cap->oap->motion_force = cap->cmdchar; 5535 finish_op = FALSE; // operator doesn't finish now but later 5536 return; 5537 } 5538 5539 VIsual_select = cap->arg; 5540 if (VIsual_active) // change Visual mode 5541 { 5542 if (VIsual_mode == cap->cmdchar) // stop visual mode 5543 end_visual_mode(); 5544 else // toggle char/block mode 5545 { // or char/line mode 5546 VIsual_mode = cap->cmdchar; 5547 showmode(); 5548 } 5549 redraw_curbuf_later(INVERTED); // update the inversion 5550 } 5551 else // start Visual mode 5552 { 5553 check_visual_highlight(); 5554 if (cap->count0 > 0 && resel_VIsual_mode != NUL) 5555 { 5556 // use previously selected part 5557 VIsual = curwin->w_cursor; 5558 5559 VIsual_active = TRUE; 5560 VIsual_reselect = TRUE; 5561 if (!cap->arg) 5562 // start Select mode when 'selectmode' contains "cmd" 5563 may_start_select('c'); 5564 setmouse(); 5565 if (p_smd && msg_silent == 0) 5566 redraw_cmdline = TRUE; // show visual mode later 5567 /* 5568 * For V and ^V, we multiply the number of lines even if there 5569 * was only one -- webb 5570 */ 5571 if (resel_VIsual_mode != 'v' || resel_VIsual_line_count > 1) 5572 { 5573 curwin->w_cursor.lnum += 5574 resel_VIsual_line_count * cap->count0 - 1; 5575 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) 5576 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; 5577 } 5578 VIsual_mode = resel_VIsual_mode; 5579 if (VIsual_mode == 'v') 5580 { 5581 if (resel_VIsual_line_count <= 1) 5582 { 5583 validate_virtcol(); 5584 curwin->w_curswant = curwin->w_virtcol 5585 + resel_VIsual_vcol * cap->count0 - 1; 5586 } 5587 else 5588 curwin->w_curswant = resel_VIsual_vcol; 5589 coladvance(curwin->w_curswant); 5590 } 5591 if (resel_VIsual_vcol == MAXCOL) 5592 { 5593 curwin->w_curswant = MAXCOL; 5594 coladvance((colnr_T)MAXCOL); 5595 } 5596 else if (VIsual_mode == Ctrl_V) 5597 { 5598 validate_virtcol(); 5599 curwin->w_curswant = curwin->w_virtcol 5600 + resel_VIsual_vcol * cap->count0 - 1; 5601 coladvance(curwin->w_curswant); 5602 } 5603 else 5604 curwin->w_set_curswant = TRUE; 5605 redraw_curbuf_later(INVERTED); // show the inversion 5606 } 5607 else 5608 { 5609 if (!cap->arg) 5610 // start Select mode when 'selectmode' contains "cmd" 5611 may_start_select('c'); 5612 n_start_visual_mode(cap->cmdchar); 5613 if (VIsual_mode != 'V' && *p_sel == 'e') 5614 ++cap->count1; // include one more char 5615 if (cap->count0 > 0 && --cap->count1 > 0) 5616 { 5617 // With a count select that many characters or lines. 5618 if (VIsual_mode == 'v' || VIsual_mode == Ctrl_V) 5619 nv_right(cap); 5620 else if (VIsual_mode == 'V') 5621 nv_down(cap); 5622 } 5623 } 5624 } 5625 } 5626 5627 /* 5628 * Start selection for Shift-movement keys. 5629 */ 5630 void 5631 start_selection(void) 5632 { 5633 // if 'selectmode' contains "key", start Select mode 5634 may_start_select('k'); 5635 n_start_visual_mode('v'); 5636 } 5637 5638 /* 5639 * Start Select mode, if "c" is in 'selectmode' and not in a mapping or menu. 5640 */ 5641 void 5642 may_start_select(int c) 5643 { 5644 VIsual_select = (stuff_empty() && typebuf_typed() 5645 && (vim_strchr(p_slm, c) != NULL)); 5646 } 5647 5648 /* 5649 * Start Visual mode "c". 5650 * Should set VIsual_select before calling this. 5651 */ 5652 static void 5653 n_start_visual_mode(int c) 5654 { 5655 #ifdef FEAT_CONCEAL 5656 // Check for redraw before changing the state. 5657 conceal_check_cursor_line(); 5658 #endif 5659 5660 VIsual_mode = c; 5661 VIsual_active = TRUE; 5662 VIsual_reselect = TRUE; 5663 5664 // Corner case: the 0 position in a tab may change when going into 5665 // virtualedit. Recalculate curwin->w_cursor to avoid bad highlighting. 5666 if (c == Ctrl_V && (ve_flags & VE_BLOCK) && gchar_cursor() == TAB) 5667 { 5668 validate_virtcol(); 5669 coladvance(curwin->w_virtcol); 5670 } 5671 VIsual = curwin->w_cursor; 5672 5673 #ifdef FEAT_FOLDING 5674 foldAdjustVisual(); 5675 #endif 5676 5677 setmouse(); 5678 #ifdef FEAT_CONCEAL 5679 // Check for redraw after changing the state. 5680 conceal_check_cursor_line(); 5681 #endif 5682 5683 if (p_smd && msg_silent == 0) 5684 redraw_cmdline = TRUE; // show visual mode later 5685 #ifdef FEAT_CLIPBOARD 5686 // Make sure the clipboard gets updated. Needed because start and 5687 // end may still be the same, and the selection needs to be owned 5688 clip_star.vmode = NUL; 5689 #endif 5690 5691 // Only need to redraw this line, unless still need to redraw an old 5692 // Visual area (when 'lazyredraw' is set). 5693 if (curwin->w_redr_type < INVERTED) 5694 { 5695 curwin->w_old_cursor_lnum = curwin->w_cursor.lnum; 5696 curwin->w_old_visual_lnum = curwin->w_cursor.lnum; 5697 } 5698 } 5699 5700 5701 /* 5702 * CTRL-W: Window commands 5703 */ 5704 static void 5705 nv_window(cmdarg_T *cap) 5706 { 5707 if (cap->nchar == ':') 5708 { 5709 // "CTRL-W :" is the same as typing ":"; useful in a terminal window 5710 cap->cmdchar = ':'; 5711 cap->nchar = NUL; 5712 nv_colon(cap); 5713 } 5714 else if (!checkclearop(cap->oap)) 5715 do_window(cap->nchar, cap->count0, NUL); // everything is in window.c 5716 } 5717 5718 /* 5719 * CTRL-Z: Suspend 5720 */ 5721 static void 5722 nv_suspend(cmdarg_T *cap) 5723 { 5724 clearop(cap->oap); 5725 if (VIsual_active) 5726 end_visual_mode(); // stop Visual mode 5727 do_cmdline_cmd((char_u *)"st"); 5728 } 5729 5730 /* 5731 * Commands starting with "g". 5732 */ 5733 static void 5734 nv_g_cmd(cmdarg_T *cap) 5735 { 5736 oparg_T *oap = cap->oap; 5737 pos_T tpos; 5738 int i; 5739 int flag = FALSE; 5740 5741 switch (cap->nchar) 5742 { 5743 case Ctrl_A: 5744 case Ctrl_X: 5745 #ifdef MEM_PROFILE 5746 /* 5747 * "g^A": dump log of used memory. 5748 */ 5749 if (!VIsual_active && cap->nchar == Ctrl_A) 5750 vim_mem_profile_dump(); 5751 else 5752 #endif 5753 /* 5754 * "g^A/g^X": sequentially increment visually selected region 5755 */ 5756 if (VIsual_active) 5757 { 5758 cap->arg = TRUE; 5759 cap->cmdchar = cap->nchar; 5760 cap->nchar = NUL; 5761 nv_addsub(cap); 5762 } 5763 else 5764 clearopbeep(oap); 5765 break; 5766 5767 /* 5768 * "gR": Enter virtual replace mode. 5769 */ 5770 case 'R': 5771 cap->arg = TRUE; 5772 nv_Replace(cap); 5773 break; 5774 5775 case 'r': 5776 nv_vreplace(cap); 5777 break; 5778 5779 case '&': 5780 do_cmdline_cmd((char_u *)"%s//~/&"); 5781 break; 5782 5783 /* 5784 * "gv": Reselect the previous Visual area. If Visual already active, 5785 * exchange previous and current Visual area. 5786 */ 5787 case 'v': 5788 if (checkclearop(oap)) 5789 break; 5790 5791 if ( curbuf->b_visual.vi_start.lnum == 0 5792 || curbuf->b_visual.vi_start.lnum > curbuf->b_ml.ml_line_count 5793 || curbuf->b_visual.vi_end.lnum == 0) 5794 beep_flush(); 5795 else 5796 { 5797 // set w_cursor to the start of the Visual area, tpos to the end 5798 if (VIsual_active) 5799 { 5800 i = VIsual_mode; 5801 VIsual_mode = curbuf->b_visual.vi_mode; 5802 curbuf->b_visual.vi_mode = i; 5803 # ifdef FEAT_EVAL 5804 curbuf->b_visual_mode_eval = i; 5805 # endif 5806 i = curwin->w_curswant; 5807 curwin->w_curswant = curbuf->b_visual.vi_curswant; 5808 curbuf->b_visual.vi_curswant = i; 5809 5810 tpos = curbuf->b_visual.vi_end; 5811 curbuf->b_visual.vi_end = curwin->w_cursor; 5812 curwin->w_cursor = curbuf->b_visual.vi_start; 5813 curbuf->b_visual.vi_start = VIsual; 5814 } 5815 else 5816 { 5817 VIsual_mode = curbuf->b_visual.vi_mode; 5818 curwin->w_curswant = curbuf->b_visual.vi_curswant; 5819 tpos = curbuf->b_visual.vi_end; 5820 curwin->w_cursor = curbuf->b_visual.vi_start; 5821 } 5822 5823 VIsual_active = TRUE; 5824 VIsual_reselect = TRUE; 5825 5826 // Set Visual to the start and w_cursor to the end of the Visual 5827 // area. Make sure they are on an existing character. 5828 check_cursor(); 5829 VIsual = curwin->w_cursor; 5830 curwin->w_cursor = tpos; 5831 check_cursor(); 5832 update_topline(); 5833 /* 5834 * When called from normal "g" command: start Select mode when 5835 * 'selectmode' contains "cmd". When called for K_SELECT, always 5836 * start Select mode. 5837 */ 5838 if (cap->arg) 5839 VIsual_select = TRUE; 5840 else 5841 may_start_select('c'); 5842 setmouse(); 5843 #ifdef FEAT_CLIPBOARD 5844 // Make sure the clipboard gets updated. Needed because start and 5845 // end are still the same, and the selection needs to be owned 5846 clip_star.vmode = NUL; 5847 #endif 5848 redraw_curbuf_later(INVERTED); 5849 showmode(); 5850 } 5851 break; 5852 /* 5853 * "gV": Don't reselect the previous Visual area after a Select mode 5854 * mapping of menu. 5855 */ 5856 case 'V': 5857 VIsual_reselect = FALSE; 5858 break; 5859 5860 /* 5861 * "gh": start Select mode. 5862 * "gH": start Select line mode. 5863 * "g^H": start Select block mode. 5864 */ 5865 case K_BS: 5866 cap->nchar = Ctrl_H; 5867 // FALLTHROUGH 5868 case 'h': 5869 case 'H': 5870 case Ctrl_H: 5871 # ifdef EBCDIC 5872 // EBCDIC: 'v'-'h' != '^v'-'^h' 5873 if (cap->nchar == Ctrl_H) 5874 cap->cmdchar = Ctrl_V; 5875 else 5876 # endif 5877 cap->cmdchar = cap->nchar + ('v' - 'h'); 5878 cap->arg = TRUE; 5879 nv_visual(cap); 5880 break; 5881 5882 // "gn", "gN" visually select next/previous search match 5883 // "gn" selects next match 5884 // "gN" selects previous match 5885 case 'N': 5886 case 'n': 5887 if (!current_search(cap->count1, cap->nchar == 'n')) 5888 clearopbeep(oap); 5889 break; 5890 5891 /* 5892 * "gj" and "gk" two new funny movement keys -- up and down 5893 * movement based on *screen* line rather than *file* line. 5894 */ 5895 case 'j': 5896 case K_DOWN: 5897 // with 'nowrap' it works just like the normal "j" command; also when 5898 // in a closed fold 5899 if (!curwin->w_p_wrap 5900 #ifdef FEAT_FOLDING 5901 || hasFolding(curwin->w_cursor.lnum, NULL, NULL) 5902 #endif 5903 ) 5904 { 5905 oap->motion_type = MLINE; 5906 i = cursor_down(cap->count1, oap->op_type == OP_NOP); 5907 } 5908 else 5909 i = nv_screengo(oap, FORWARD, cap->count1); 5910 if (i == FAIL) 5911 clearopbeep(oap); 5912 break; 5913 5914 case 'k': 5915 case K_UP: 5916 // with 'nowrap' it works just like the normal "k" command; also when 5917 // in a closed fold 5918 if (!curwin->w_p_wrap 5919 #ifdef FEAT_FOLDING 5920 || hasFolding(curwin->w_cursor.lnum, NULL, NULL) 5921 #endif 5922 ) 5923 { 5924 oap->motion_type = MLINE; 5925 i = cursor_up(cap->count1, oap->op_type == OP_NOP); 5926 } 5927 else 5928 i = nv_screengo(oap, BACKWARD, cap->count1); 5929 if (i == FAIL) 5930 clearopbeep(oap); 5931 break; 5932 5933 /* 5934 * "gJ": join two lines without inserting a space. 5935 */ 5936 case 'J': 5937 nv_join(cap); 5938 break; 5939 5940 /* 5941 * "g0", "g^" and "g$": Like "0", "^" and "$" but for screen lines. 5942 * "gm": middle of "g0" and "g$". 5943 */ 5944 case '^': 5945 flag = TRUE; 5946 // FALLTHROUGH 5947 5948 case '0': 5949 case 'm': 5950 case K_HOME: 5951 case K_KHOME: 5952 oap->motion_type = MCHAR; 5953 oap->inclusive = FALSE; 5954 if (curwin->w_p_wrap && curwin->w_width != 0) 5955 { 5956 int width1 = curwin->w_width - curwin_col_off(); 5957 int width2 = width1 + curwin_col_off2(); 5958 5959 validate_virtcol(); 5960 i = 0; 5961 if (curwin->w_virtcol >= (colnr_T)width1 && width2 > 0) 5962 i = (curwin->w_virtcol - width1) / width2 * width2 + width1; 5963 } 5964 else 5965 i = curwin->w_leftcol; 5966 // Go to the middle of the screen line. When 'number' or 5967 // 'relativenumber' is on and lines are wrapping the middle can be more 5968 // to the left. 5969 if (cap->nchar == 'm') 5970 i += (curwin->w_width - curwin_col_off() 5971 + ((curwin->w_p_wrap && i > 0) 5972 ? curwin_col_off2() : 0)) / 2; 5973 coladvance((colnr_T)i); 5974 if (flag) 5975 { 5976 do 5977 i = gchar_cursor(); 5978 while (VIM_ISWHITE(i) && oneright() == OK); 5979 curwin->w_valid &= ~VALID_WCOL; 5980 } 5981 curwin->w_set_curswant = TRUE; 5982 break; 5983 5984 case 'M': 5985 { 5986 char_u *ptr = ml_get_curline(); 5987 5988 oap->motion_type = MCHAR; 5989 oap->inclusive = FALSE; 5990 if (has_mbyte) 5991 i = mb_string2cells(ptr, (int)STRLEN(ptr)); 5992 else 5993 i = (int)STRLEN(ptr); 5994 if (cap->count0 > 0 && cap->count0 <= 100) 5995 coladvance((colnr_T)(i * cap->count0 / 100)); 5996 else 5997 coladvance((colnr_T)(i / 2)); 5998 curwin->w_set_curswant = TRUE; 5999 } 6000 break; 6001 6002 case '_': 6003 // "g_": to the last non-blank character in the line or <count> lines 6004 // downward. 6005 cap->oap->motion_type = MCHAR; 6006 cap->oap->inclusive = TRUE; 6007 curwin->w_curswant = MAXCOL; 6008 if (cursor_down((long)(cap->count1 - 1), 6009 cap->oap->op_type == OP_NOP) == FAIL) 6010 clearopbeep(cap->oap); 6011 else 6012 { 6013 char_u *ptr = ml_get_curline(); 6014 6015 // In Visual mode we may end up after the line. 6016 if (curwin->w_cursor.col > 0 && ptr[curwin->w_cursor.col] == NUL) 6017 --curwin->w_cursor.col; 6018 6019 // Decrease the cursor column until it's on a non-blank. 6020 while (curwin->w_cursor.col > 0 6021 && VIM_ISWHITE(ptr[curwin->w_cursor.col])) 6022 --curwin->w_cursor.col; 6023 curwin->w_set_curswant = TRUE; 6024 adjust_for_sel(cap); 6025 } 6026 break; 6027 6028 case '$': 6029 case K_END: 6030 case K_KEND: 6031 { 6032 int col_off = curwin_col_off(); 6033 6034 oap->motion_type = MCHAR; 6035 oap->inclusive = TRUE; 6036 if (curwin->w_p_wrap && curwin->w_width != 0) 6037 { 6038 curwin->w_curswant = MAXCOL; // so we stay at the end 6039 if (cap->count1 == 1) 6040 { 6041 int width1 = curwin->w_width - col_off; 6042 int width2 = width1 + curwin_col_off2(); 6043 6044 validate_virtcol(); 6045 i = width1 - 1; 6046 if (curwin->w_virtcol >= (colnr_T)width1) 6047 i += ((curwin->w_virtcol - width1) / width2 + 1) 6048 * width2; 6049 coladvance((colnr_T)i); 6050 6051 // Make sure we stick in this column. 6052 validate_virtcol(); 6053 curwin->w_curswant = curwin->w_virtcol; 6054 curwin->w_set_curswant = FALSE; 6055 if (curwin->w_cursor.col > 0 && curwin->w_p_wrap) 6056 { 6057 /* 6058 * Check for landing on a character that got split at 6059 * the end of the line. We do not want to advance to 6060 * the next screen line. 6061 */ 6062 if (curwin->w_virtcol > (colnr_T)i) 6063 --curwin->w_cursor.col; 6064 } 6065 } 6066 else if (nv_screengo(oap, FORWARD, cap->count1 - 1) == FAIL) 6067 clearopbeep(oap); 6068 } 6069 else 6070 { 6071 if (cap->count1 > 1) 6072 // if it fails, let the cursor still move to the last char 6073 (void)cursor_down(cap->count1 - 1, FALSE); 6074 6075 i = curwin->w_leftcol + curwin->w_width - col_off - 1; 6076 coladvance((colnr_T)i); 6077 6078 // Make sure we stick in this column. 6079 validate_virtcol(); 6080 curwin->w_curswant = curwin->w_virtcol; 6081 curwin->w_set_curswant = FALSE; 6082 } 6083 } 6084 break; 6085 6086 /* 6087 * "g*" and "g#", like "*" and "#" but without using "\<" and "\>" 6088 */ 6089 case '*': 6090 case '#': 6091 #if POUND != '#' 6092 case POUND: // pound sign (sometimes equal to '#') 6093 #endif 6094 case Ctrl_RSB: // :tag or :tselect for current identifier 6095 case ']': // :tselect for current identifier 6096 nv_ident(cap); 6097 break; 6098 6099 /* 6100 * ge and gE: go back to end of word 6101 */ 6102 case 'e': 6103 case 'E': 6104 oap->motion_type = MCHAR; 6105 curwin->w_set_curswant = TRUE; 6106 oap->inclusive = TRUE; 6107 if (bckend_word(cap->count1, cap->nchar == 'E', FALSE) == FAIL) 6108 clearopbeep(oap); 6109 break; 6110 6111 /* 6112 * "g CTRL-G": display info about cursor position 6113 */ 6114 case Ctrl_G: 6115 cursor_pos_info(NULL); 6116 break; 6117 6118 /* 6119 * "gi": start Insert at the last position. 6120 */ 6121 case 'i': 6122 if (curbuf->b_last_insert.lnum != 0) 6123 { 6124 curwin->w_cursor = curbuf->b_last_insert; 6125 check_cursor_lnum(); 6126 i = (int)STRLEN(ml_get_curline()); 6127 if (curwin->w_cursor.col > (colnr_T)i) 6128 { 6129 if (virtual_active()) 6130 curwin->w_cursor.coladd += curwin->w_cursor.col - i; 6131 curwin->w_cursor.col = i; 6132 } 6133 } 6134 cap->cmdchar = 'i'; 6135 nv_edit(cap); 6136 break; 6137 6138 /* 6139 * "gI": Start insert in column 1. 6140 */ 6141 case 'I': 6142 beginline(0); 6143 if (!checkclearopq(oap)) 6144 invoke_edit(cap, FALSE, 'g', FALSE); 6145 break; 6146 6147 #ifdef FEAT_SEARCHPATH 6148 /* 6149 * "gf": goto file, edit file under cursor 6150 * "]f" and "[f": can also be used. 6151 */ 6152 case 'f': 6153 case 'F': 6154 nv_gotofile(cap); 6155 break; 6156 #endif 6157 6158 // "g'm" and "g`m": jump to mark without setting pcmark 6159 case '\'': 6160 cap->arg = TRUE; 6161 // FALLTHROUGH 6162 case '`': 6163 nv_gomark(cap); 6164 break; 6165 6166 /* 6167 * "gs": Goto sleep. 6168 */ 6169 case 's': 6170 do_sleep(cap->count1 * 1000L); 6171 break; 6172 6173 /* 6174 * "ga": Display the ascii value of the character under the 6175 * cursor. It is displayed in decimal, hex, and octal. -- webb 6176 */ 6177 case 'a': 6178 do_ascii(NULL); 6179 break; 6180 6181 /* 6182 * "g8": Display the bytes used for the UTF-8 character under the 6183 * cursor. It is displayed in hex. 6184 * "8g8" finds illegal byte sequence. 6185 */ 6186 case '8': 6187 if (cap->count0 == 8) 6188 utf_find_illegal(); 6189 else 6190 show_utf8(); 6191 break; 6192 6193 // "g<": show scrollback text 6194 case '<': 6195 show_sb_text(); 6196 break; 6197 6198 /* 6199 * "gg": Goto the first line in file. With a count it goes to 6200 * that line number like for "G". -- webb 6201 */ 6202 case 'g': 6203 cap->arg = FALSE; 6204 nv_goto(cap); 6205 break; 6206 6207 /* 6208 * Two-character operators: 6209 * "gq" Format text 6210 * "gw" Format text and keep cursor position 6211 * "g~" Toggle the case of the text. 6212 * "gu" Change text to lower case. 6213 * "gU" Change text to upper case. 6214 * "g?" rot13 encoding 6215 * "g@" call 'operatorfunc' 6216 */ 6217 case 'q': 6218 case 'w': 6219 oap->cursor_start = curwin->w_cursor; 6220 // FALLTHROUGH 6221 case '~': 6222 case 'u': 6223 case 'U': 6224 case '?': 6225 case '@': 6226 nv_operator(cap); 6227 break; 6228 6229 /* 6230 * "gd": Find first occurrence of pattern under the cursor in the 6231 * current function 6232 * "gD": idem, but in the current file. 6233 */ 6234 case 'd': 6235 case 'D': 6236 nv_gd(oap, cap->nchar, (int)cap->count0); 6237 break; 6238 6239 /* 6240 * g<*Mouse> : <C-*mouse> 6241 */ 6242 case K_MIDDLEMOUSE: 6243 case K_MIDDLEDRAG: 6244 case K_MIDDLERELEASE: 6245 case K_LEFTMOUSE: 6246 case K_LEFTDRAG: 6247 case K_LEFTRELEASE: 6248 case K_MOUSEMOVE: 6249 case K_RIGHTMOUSE: 6250 case K_RIGHTDRAG: 6251 case K_RIGHTRELEASE: 6252 case K_X1MOUSE: 6253 case K_X1DRAG: 6254 case K_X1RELEASE: 6255 case K_X2MOUSE: 6256 case K_X2DRAG: 6257 case K_X2RELEASE: 6258 mod_mask = MOD_MASK_CTRL; 6259 (void)do_mouse(oap, cap->nchar, BACKWARD, cap->count1, 0); 6260 break; 6261 6262 case K_IGNORE: 6263 break; 6264 6265 /* 6266 * "gP" and "gp": same as "P" and "p" but leave cursor just after new text 6267 */ 6268 case 'p': 6269 case 'P': 6270 nv_put(cap); 6271 break; 6272 6273 #ifdef FEAT_BYTEOFF 6274 // "go": goto byte count from start of buffer 6275 case 'o': 6276 goto_byte(cap->count0); 6277 break; 6278 #endif 6279 6280 // "gQ": improved Ex mode 6281 case 'Q': 6282 if (text_locked()) 6283 { 6284 clearopbeep(cap->oap); 6285 text_locked_msg(); 6286 break; 6287 } 6288 6289 if (!checkclearopq(oap)) 6290 do_exmode(TRUE); 6291 break; 6292 6293 #ifdef FEAT_JUMPLIST 6294 case ',': 6295 nv_pcmark(cap); 6296 break; 6297 6298 case ';': 6299 cap->count1 = -cap->count1; 6300 nv_pcmark(cap); 6301 break; 6302 #endif 6303 6304 case 't': 6305 if (!checkclearop(oap)) 6306 goto_tabpage((int)cap->count0); 6307 break; 6308 case 'T': 6309 if (!checkclearop(oap)) 6310 goto_tabpage(-(int)cap->count1); 6311 break; 6312 6313 case '+': 6314 case '-': // "g+" and "g-": undo or redo along the timeline 6315 if (!checkclearopq(oap)) 6316 undo_time(cap->nchar == '-' ? -cap->count1 : cap->count1, 6317 FALSE, FALSE, FALSE); 6318 break; 6319 6320 default: 6321 clearopbeep(oap); 6322 break; 6323 } 6324 } 6325 6326 /* 6327 * Handle "o" and "O" commands. 6328 */ 6329 static void 6330 n_opencmd(cmdarg_T *cap) 6331 { 6332 #ifdef FEAT_CONCEAL 6333 linenr_T oldline = curwin->w_cursor.lnum; 6334 #endif 6335 6336 if (!checkclearopq(cap->oap)) 6337 { 6338 #ifdef FEAT_FOLDING 6339 if (cap->cmdchar == 'O') 6340 // Open above the first line of a folded sequence of lines 6341 (void)hasFolding(curwin->w_cursor.lnum, 6342 &curwin->w_cursor.lnum, NULL); 6343 else 6344 // Open below the last line of a folded sequence of lines 6345 (void)hasFolding(curwin->w_cursor.lnum, 6346 NULL, &curwin->w_cursor.lnum); 6347 #endif 6348 if (u_save((linenr_T)(curwin->w_cursor.lnum - 6349 (cap->cmdchar == 'O' ? 1 : 0)), 6350 (linenr_T)(curwin->w_cursor.lnum + 6351 (cap->cmdchar == 'o' ? 1 : 0)) 6352 ) == OK 6353 && open_line(cap->cmdchar == 'O' ? BACKWARD : FORWARD, 6354 has_format_option(FO_OPEN_COMS) ? OPENLINE_DO_COM : 0, 6355 0) == OK) 6356 { 6357 #ifdef FEAT_CONCEAL 6358 if (curwin->w_p_cole > 0 && oldline != curwin->w_cursor.lnum) 6359 redrawWinline(curwin, oldline); 6360 #endif 6361 #ifdef FEAT_SYN_HL 6362 if (curwin->w_p_cul) 6363 // force redraw of cursorline 6364 curwin->w_valid &= ~VALID_CROW; 6365 #endif 6366 // When '#' is in 'cpoptions' ignore the count. 6367 if (vim_strchr(p_cpo, CPO_HASH) != NULL) 6368 cap->count1 = 1; 6369 invoke_edit(cap, FALSE, cap->cmdchar, TRUE); 6370 } 6371 } 6372 } 6373 6374 /* 6375 * "." command: redo last change. 6376 */ 6377 static void 6378 nv_dot(cmdarg_T *cap) 6379 { 6380 if (!checkclearopq(cap->oap)) 6381 { 6382 /* 6383 * If "restart_edit" is TRUE, the last but one command is repeated 6384 * instead of the last command (inserting text). This is used for 6385 * CTRL-O <.> in insert mode. 6386 */ 6387 if (start_redo(cap->count0, restart_edit != 0 && !arrow_used) == FAIL) 6388 clearopbeep(cap->oap); 6389 } 6390 } 6391 6392 /* 6393 * CTRL-R: undo undo 6394 */ 6395 static void 6396 nv_redo(cmdarg_T *cap) 6397 { 6398 if (!checkclearopq(cap->oap)) 6399 { 6400 u_redo((int)cap->count1); 6401 curwin->w_set_curswant = TRUE; 6402 } 6403 } 6404 6405 /* 6406 * Handle "U" command. 6407 */ 6408 static void 6409 nv_Undo(cmdarg_T *cap) 6410 { 6411 // In Visual mode and typing "gUU" triggers an operator 6412 if (cap->oap->op_type == OP_UPPER || VIsual_active) 6413 { 6414 // translate "gUU" to "gUgU" 6415 cap->cmdchar = 'g'; 6416 cap->nchar = 'U'; 6417 nv_operator(cap); 6418 } 6419 else if (!checkclearopq(cap->oap)) 6420 { 6421 u_undoline(); 6422 curwin->w_set_curswant = TRUE; 6423 } 6424 } 6425 6426 /* 6427 * '~' command: If tilde is not an operator and Visual is off: swap case of a 6428 * single character. 6429 */ 6430 static void 6431 nv_tilde(cmdarg_T *cap) 6432 { 6433 if (!p_to && !VIsual_active && cap->oap->op_type != OP_TILDE) 6434 { 6435 #ifdef FEAT_JOB_CHANNEL 6436 if (bt_prompt(curbuf) && !prompt_curpos_editable()) 6437 { 6438 clearopbeep(cap->oap); 6439 return; 6440 } 6441 #endif 6442 n_swapchar(cap); 6443 } 6444 else 6445 nv_operator(cap); 6446 } 6447 6448 /* 6449 * Handle an operator command. 6450 * The actual work is done by do_pending_operator(). 6451 */ 6452 static void 6453 nv_operator(cmdarg_T *cap) 6454 { 6455 int op_type; 6456 6457 op_type = get_op_type(cap->cmdchar, cap->nchar); 6458 #ifdef FEAT_JOB_CHANNEL 6459 if (bt_prompt(curbuf) && op_is_change(op_type) && !prompt_curpos_editable()) 6460 { 6461 clearopbeep(cap->oap); 6462 return; 6463 } 6464 #endif 6465 6466 if (op_type == cap->oap->op_type) // double operator works on lines 6467 nv_lineop(cap); 6468 else if (!checkclearop(cap->oap)) 6469 { 6470 cap->oap->start = curwin->w_cursor; 6471 cap->oap->op_type = op_type; 6472 #ifdef FEAT_EVAL 6473 set_op_var(op_type); 6474 #endif 6475 } 6476 } 6477 6478 #ifdef FEAT_EVAL 6479 /* 6480 * Set v:operator to the characters for "optype". 6481 */ 6482 static void 6483 set_op_var(int optype) 6484 { 6485 char_u opchars[3]; 6486 6487 if (optype == OP_NOP) 6488 set_vim_var_string(VV_OP, NULL, 0); 6489 else 6490 { 6491 opchars[0] = get_op_char(optype); 6492 opchars[1] = get_extra_op_char(optype); 6493 opchars[2] = NUL; 6494 set_vim_var_string(VV_OP, opchars, -1); 6495 } 6496 } 6497 #endif 6498 6499 /* 6500 * Handle linewise operator "dd", "yy", etc. 6501 * 6502 * "_" is is a strange motion command that helps make operators more logical. 6503 * It is actually implemented, but not documented in the real Vi. This motion 6504 * command actually refers to "the current line". Commands like "dd" and "yy" 6505 * are really an alternate form of "d_" and "y_". It does accept a count, so 6506 * "d3_" works to delete 3 lines. 6507 */ 6508 static void 6509 nv_lineop(cmdarg_T *cap) 6510 { 6511 cap->oap->motion_type = MLINE; 6512 if (cursor_down(cap->count1 - 1L, cap->oap->op_type == OP_NOP) == FAIL) 6513 clearopbeep(cap->oap); 6514 else if ( (cap->oap->op_type == OP_DELETE // only with linewise motions 6515 && cap->oap->motion_force != 'v' 6516 && cap->oap->motion_force != Ctrl_V) 6517 || cap->oap->op_type == OP_LSHIFT 6518 || cap->oap->op_type == OP_RSHIFT) 6519 beginline(BL_SOL | BL_FIX); 6520 else if (cap->oap->op_type != OP_YANK) // 'Y' does not move cursor 6521 beginline(BL_WHITE | BL_FIX); 6522 } 6523 6524 /* 6525 * <Home> command. 6526 */ 6527 static void 6528 nv_home(cmdarg_T *cap) 6529 { 6530 // CTRL-HOME is like "gg" 6531 if (mod_mask & MOD_MASK_CTRL) 6532 nv_goto(cap); 6533 else 6534 { 6535 cap->count0 = 1; 6536 nv_pipe(cap); 6537 } 6538 ins_at_eol = FALSE; // Don't move cursor past eol (only necessary in a 6539 // one-character line). 6540 } 6541 6542 /* 6543 * "|" command. 6544 */ 6545 static void 6546 nv_pipe(cmdarg_T *cap) 6547 { 6548 cap->oap->motion_type = MCHAR; 6549 cap->oap->inclusive = FALSE; 6550 beginline(0); 6551 if (cap->count0 > 0) 6552 { 6553 coladvance((colnr_T)(cap->count0 - 1)); 6554 curwin->w_curswant = (colnr_T)(cap->count0 - 1); 6555 } 6556 else 6557 curwin->w_curswant = 0; 6558 // keep curswant at the column where we wanted to go, not where 6559 // we ended; differs if line is too short 6560 curwin->w_set_curswant = FALSE; 6561 } 6562 6563 /* 6564 * Handle back-word command "b" and "B". 6565 * cap->arg is 1 for "B" 6566 */ 6567 static void 6568 nv_bck_word(cmdarg_T *cap) 6569 { 6570 cap->oap->motion_type = MCHAR; 6571 cap->oap->inclusive = FALSE; 6572 curwin->w_set_curswant = TRUE; 6573 if (bck_word(cap->count1, cap->arg, FALSE) == FAIL) 6574 clearopbeep(cap->oap); 6575 #ifdef FEAT_FOLDING 6576 else if ((fdo_flags & FDO_HOR) && KeyTyped && cap->oap->op_type == OP_NOP) 6577 foldOpenCursor(); 6578 #endif 6579 } 6580 6581 /* 6582 * Handle word motion commands "e", "E", "w" and "W". 6583 * cap->arg is TRUE for "E" and "W". 6584 */ 6585 static void 6586 nv_wordcmd(cmdarg_T *cap) 6587 { 6588 int n; 6589 int word_end; 6590 int flag = FALSE; 6591 pos_T startpos = curwin->w_cursor; 6592 6593 /* 6594 * Set inclusive for the "E" and "e" command. 6595 */ 6596 if (cap->cmdchar == 'e' || cap->cmdchar == 'E') 6597 word_end = TRUE; 6598 else 6599 word_end = FALSE; 6600 cap->oap->inclusive = word_end; 6601 6602 /* 6603 * "cw" and "cW" are a special case. 6604 */ 6605 if (!word_end && cap->oap->op_type == OP_CHANGE) 6606 { 6607 n = gchar_cursor(); 6608 if (n != NUL) // not an empty line 6609 { 6610 if (VIM_ISWHITE(n)) 6611 { 6612 /* 6613 * Reproduce a funny Vi behaviour: "cw" on a blank only 6614 * changes one character, not all blanks until the start of 6615 * the next word. Only do this when the 'w' flag is included 6616 * in 'cpoptions'. 6617 */ 6618 if (cap->count1 == 1 && vim_strchr(p_cpo, CPO_CW) != NULL) 6619 { 6620 cap->oap->inclusive = TRUE; 6621 cap->oap->motion_type = MCHAR; 6622 return; 6623 } 6624 } 6625 else 6626 { 6627 /* 6628 * This is a little strange. To match what the real Vi does, 6629 * we effectively map 'cw' to 'ce', and 'cW' to 'cE', provided 6630 * that we are not on a space or a TAB. This seems impolite 6631 * at first, but it's really more what we mean when we say 6632 * 'cw'. 6633 * Another strangeness: When standing on the end of a word 6634 * "ce" will change until the end of the next word, but "cw" 6635 * will change only one character! This is done by setting 6636 * flag. 6637 */ 6638 cap->oap->inclusive = TRUE; 6639 word_end = TRUE; 6640 flag = TRUE; 6641 } 6642 } 6643 } 6644 6645 cap->oap->motion_type = MCHAR; 6646 curwin->w_set_curswant = TRUE; 6647 if (word_end) 6648 n = end_word(cap->count1, cap->arg, flag, FALSE); 6649 else 6650 n = fwd_word(cap->count1, cap->arg, cap->oap->op_type != OP_NOP); 6651 6652 // Don't leave the cursor on the NUL past the end of line. Unless we 6653 // didn't move it forward. 6654 if (LT_POS(startpos, curwin->w_cursor)) 6655 adjust_cursor(cap->oap); 6656 6657 if (n == FAIL && cap->oap->op_type == OP_NOP) 6658 clearopbeep(cap->oap); 6659 else 6660 { 6661 adjust_for_sel(cap); 6662 #ifdef FEAT_FOLDING 6663 if ((fdo_flags & FDO_HOR) && KeyTyped && cap->oap->op_type == OP_NOP) 6664 foldOpenCursor(); 6665 #endif 6666 } 6667 } 6668 6669 /* 6670 * Used after a movement command: If the cursor ends up on the NUL after the 6671 * end of the line, may move it back to the last character and make the motion 6672 * inclusive. 6673 */ 6674 static void 6675 adjust_cursor(oparg_T *oap) 6676 { 6677 // The cursor cannot remain on the NUL when: 6678 // - the column is > 0 6679 // - not in Visual mode or 'selection' is "o" 6680 // - 'virtualedit' is not "all" and not "onemore". 6681 if (curwin->w_cursor.col > 0 && gchar_cursor() == NUL 6682 && (!VIsual_active || *p_sel == 'o') 6683 && !virtual_active() && (ve_flags & VE_ONEMORE) == 0) 6684 { 6685 --curwin->w_cursor.col; 6686 // prevent cursor from moving on the trail byte 6687 if (has_mbyte) 6688 mb_adjust_cursor(); 6689 oap->inclusive = TRUE; 6690 } 6691 } 6692 6693 /* 6694 * "0" and "^" commands. 6695 * cap->arg is the argument for beginline(). 6696 */ 6697 static void 6698 nv_beginline(cmdarg_T *cap) 6699 { 6700 cap->oap->motion_type = MCHAR; 6701 cap->oap->inclusive = FALSE; 6702 beginline(cap->arg); 6703 #ifdef FEAT_FOLDING 6704 if ((fdo_flags & FDO_HOR) && KeyTyped && cap->oap->op_type == OP_NOP) 6705 foldOpenCursor(); 6706 #endif 6707 ins_at_eol = FALSE; // Don't move cursor past eol (only necessary in a 6708 // one-character line). 6709 } 6710 6711 /* 6712 * In exclusive Visual mode, may include the last character. 6713 */ 6714 static void 6715 adjust_for_sel(cmdarg_T *cap) 6716 { 6717 if (VIsual_active && cap->oap->inclusive && *p_sel == 'e' 6718 && gchar_cursor() != NUL && LT_POS(VIsual, curwin->w_cursor)) 6719 { 6720 if (has_mbyte) 6721 inc_cursor(); 6722 else 6723 ++curwin->w_cursor.col; 6724 cap->oap->inclusive = FALSE; 6725 } 6726 } 6727 6728 /* 6729 * Exclude last character at end of Visual area for 'selection' == "exclusive". 6730 * Should check VIsual_mode before calling this. 6731 * Returns TRUE when backed up to the previous line. 6732 */ 6733 int 6734 unadjust_for_sel(void) 6735 { 6736 pos_T *pp; 6737 6738 if (*p_sel == 'e' && !EQUAL_POS(VIsual, curwin->w_cursor)) 6739 { 6740 if (LT_POS(VIsual, curwin->w_cursor)) 6741 pp = &curwin->w_cursor; 6742 else 6743 pp = &VIsual; 6744 if (pp->coladd > 0) 6745 --pp->coladd; 6746 else 6747 if (pp->col > 0) 6748 { 6749 --pp->col; 6750 mb_adjustpos(curbuf, pp); 6751 } 6752 else if (pp->lnum > 1) 6753 { 6754 --pp->lnum; 6755 pp->col = (colnr_T)STRLEN(ml_get(pp->lnum)); 6756 return TRUE; 6757 } 6758 } 6759 return FALSE; 6760 } 6761 6762 /* 6763 * SELECT key in Normal or Visual mode: end of Select mode mapping. 6764 */ 6765 static void 6766 nv_select(cmdarg_T *cap) 6767 { 6768 if (VIsual_active) 6769 VIsual_select = TRUE; 6770 else if (VIsual_reselect) 6771 { 6772 cap->nchar = 'v'; // fake "gv" command 6773 cap->arg = TRUE; 6774 nv_g_cmd(cap); 6775 } 6776 } 6777 6778 6779 /* 6780 * "G", "gg", CTRL-END, CTRL-HOME. 6781 * cap->arg is TRUE for "G". 6782 */ 6783 static void 6784 nv_goto(cmdarg_T *cap) 6785 { 6786 linenr_T lnum; 6787 6788 if (cap->arg) 6789 lnum = curbuf->b_ml.ml_line_count; 6790 else 6791 lnum = 1L; 6792 cap->oap->motion_type = MLINE; 6793 setpcmark(); 6794 6795 // When a count is given, use it instead of the default lnum 6796 if (cap->count0 != 0) 6797 lnum = cap->count0; 6798 if (lnum < 1L) 6799 lnum = 1L; 6800 else if (lnum > curbuf->b_ml.ml_line_count) 6801 lnum = curbuf->b_ml.ml_line_count; 6802 curwin->w_cursor.lnum = lnum; 6803 beginline(BL_SOL | BL_FIX); 6804 #ifdef FEAT_FOLDING 6805 if ((fdo_flags & FDO_JUMP) && KeyTyped && cap->oap->op_type == OP_NOP) 6806 foldOpenCursor(); 6807 #endif 6808 } 6809 6810 /* 6811 * CTRL-\ in Normal mode. 6812 */ 6813 static void 6814 nv_normal(cmdarg_T *cap) 6815 { 6816 if (cap->nchar == Ctrl_N || cap->nchar == Ctrl_G) 6817 { 6818 clearop(cap->oap); 6819 if (restart_edit != 0 && mode_displayed) 6820 clear_cmdline = TRUE; // unshow mode later 6821 restart_edit = 0; 6822 #ifdef FEAT_CMDWIN 6823 if (cmdwin_type != 0) 6824 cmdwin_result = Ctrl_C; 6825 #endif 6826 if (VIsual_active) 6827 { 6828 end_visual_mode(); // stop Visual 6829 redraw_curbuf_later(INVERTED); 6830 } 6831 // CTRL-\ CTRL-G restarts Insert mode when 'insertmode' is set. 6832 if (cap->nchar == Ctrl_G && p_im) 6833 restart_edit = 'a'; 6834 } 6835 else 6836 clearopbeep(cap->oap); 6837 } 6838 6839 /* 6840 * ESC in Normal mode: beep, but don't flush buffers. 6841 * Don't even beep if we are canceling a command. 6842 */ 6843 static void 6844 nv_esc(cmdarg_T *cap) 6845 { 6846 int no_reason; 6847 6848 no_reason = (cap->oap->op_type == OP_NOP 6849 && cap->opcount == 0 6850 && cap->count0 == 0 6851 && cap->oap->regname == 0 6852 && !p_im); 6853 6854 if (cap->arg) // TRUE for CTRL-C 6855 { 6856 if (restart_edit == 0 6857 #ifdef FEAT_CMDWIN 6858 && cmdwin_type == 0 6859 #endif 6860 && !VIsual_active 6861 && no_reason) 6862 { 6863 if (anyBufIsChanged()) 6864 msg(_("Type :qa! and press <Enter> to abandon all changes and exit Vim")); 6865 else 6866 msg(_("Type :qa and press <Enter> to exit Vim")); 6867 } 6868 6869 // Don't reset "restart_edit" when 'insertmode' is set, it won't be 6870 // set again below when halfway a mapping. 6871 if (!p_im) 6872 restart_edit = 0; 6873 #ifdef FEAT_CMDWIN 6874 if (cmdwin_type != 0) 6875 { 6876 cmdwin_result = K_IGNORE; 6877 got_int = FALSE; // don't stop executing autocommands et al. 6878 return; 6879 } 6880 #endif 6881 } 6882 6883 if (VIsual_active) 6884 { 6885 end_visual_mode(); // stop Visual 6886 check_cursor_col(); // make sure cursor is not beyond EOL 6887 curwin->w_set_curswant = TRUE; 6888 redraw_curbuf_later(INVERTED); 6889 } 6890 else if (no_reason) 6891 vim_beep(BO_ESC); 6892 clearop(cap->oap); 6893 6894 // A CTRL-C is often used at the start of a menu. When 'insertmode' is 6895 // set return to Insert mode afterwards. 6896 if (restart_edit == 0 && goto_im() && ex_normal_busy == 0) 6897 restart_edit = 'a'; 6898 } 6899 6900 /* 6901 * Move the cursor for the "A" command. 6902 */ 6903 void 6904 set_cursor_for_append_to_line(void) 6905 { 6906 curwin->w_set_curswant = TRUE; 6907 if (ve_flags == VE_ALL) 6908 { 6909 int save_State = State; 6910 6911 // Pretend Insert mode here to allow the cursor on the 6912 // character past the end of the line 6913 State = INSERT; 6914 coladvance((colnr_T)MAXCOL); 6915 State = save_State; 6916 } 6917 else 6918 curwin->w_cursor.col += (colnr_T)STRLEN(ml_get_cursor()); 6919 } 6920 6921 /* 6922 * Handle "A", "a", "I", "i" and <Insert> commands. 6923 * Also handle K_PS, start bracketed paste. 6924 */ 6925 static void 6926 nv_edit(cmdarg_T *cap) 6927 { 6928 // <Insert> is equal to "i" 6929 if (cap->cmdchar == K_INS || cap->cmdchar == K_KINS) 6930 cap->cmdchar = 'i'; 6931 6932 // in Visual mode "A" and "I" are an operator 6933 if (VIsual_active && (cap->cmdchar == 'A' || cap->cmdchar == 'I')) 6934 { 6935 #ifdef FEAT_TERMINAL 6936 if (term_in_normal_mode()) 6937 { 6938 end_visual_mode(); 6939 clearop(cap->oap); 6940 term_enter_job_mode(); 6941 return; 6942 } 6943 #endif 6944 v_visop(cap); 6945 } 6946 6947 // in Visual mode and after an operator "a" and "i" are for text objects 6948 else if ((cap->cmdchar == 'a' || cap->cmdchar == 'i') 6949 && (cap->oap->op_type != OP_NOP || VIsual_active)) 6950 { 6951 #ifdef FEAT_TEXTOBJ 6952 nv_object(cap); 6953 #else 6954 clearopbeep(cap->oap); 6955 #endif 6956 } 6957 #ifdef FEAT_TERMINAL 6958 else if (term_in_normal_mode()) 6959 { 6960 clearop(cap->oap); 6961 term_enter_job_mode(); 6962 return; 6963 } 6964 #endif 6965 else if (!curbuf->b_p_ma && !p_im) 6966 { 6967 // Only give this error when 'insertmode' is off. 6968 emsg(_(e_modifiable)); 6969 clearop(cap->oap); 6970 if (cap->cmdchar == K_PS) 6971 // drop the pasted text 6972 bracketed_paste(PASTE_INSERT, TRUE, NULL); 6973 } 6974 else if (cap->cmdchar == K_PS && VIsual_active) 6975 { 6976 pos_T old_pos = curwin->w_cursor; 6977 pos_T old_visual = VIsual; 6978 6979 // In Visual mode the selected text is deleted. 6980 if (VIsual_mode == 'V' || curwin->w_cursor.lnum != VIsual.lnum) 6981 { 6982 shift_delete_registers(); 6983 cap->oap->regname = '1'; 6984 } 6985 else 6986 cap->oap->regname = '-'; 6987 cap->cmdchar = 'd'; 6988 cap->nchar = NUL; 6989 nv_operator(cap); 6990 do_pending_operator(cap, 0, FALSE); 6991 cap->cmdchar = K_PS; 6992 6993 // When the last char in the line was deleted then append. Detect this 6994 // by checking if the cursor moved to before the Visual area. 6995 if (*ml_get_cursor() != NUL && LT_POS(curwin->w_cursor, old_pos) 6996 && LT_POS(curwin->w_cursor, old_visual)) 6997 inc_cursor(); 6998 6999 // Insert to replace the deleted text with the pasted text. 7000 invoke_edit(cap, FALSE, cap->cmdchar, FALSE); 7001 } 7002 else if (!checkclearopq(cap->oap)) 7003 { 7004 switch (cap->cmdchar) 7005 { 7006 case 'A': // "A"ppend after the line 7007 set_cursor_for_append_to_line(); 7008 break; 7009 7010 case 'I': // "I"nsert before the first non-blank 7011 if (vim_strchr(p_cpo, CPO_INSEND) == NULL) 7012 beginline(BL_WHITE); 7013 else 7014 beginline(BL_WHITE|BL_FIX); 7015 break; 7016 7017 case K_PS: 7018 // Bracketed paste works like "a"ppend, unless the cursor is in 7019 // the first column, then it inserts. 7020 if (curwin->w_cursor.col == 0) 7021 break; 7022 // FALLTHROUGH 7023 7024 case 'a': // "a"ppend is like "i"nsert on the next character. 7025 // increment coladd when in virtual space, increment the 7026 // column otherwise, also to append after an unprintable char 7027 if (virtual_active() 7028 && (curwin->w_cursor.coladd > 0 7029 || *ml_get_cursor() == NUL 7030 || *ml_get_cursor() == TAB)) 7031 curwin->w_cursor.coladd++; 7032 else if (*ml_get_cursor() != NUL) 7033 inc_cursor(); 7034 break; 7035 } 7036 7037 if (curwin->w_cursor.coladd && cap->cmdchar != 'A') 7038 { 7039 int save_State = State; 7040 7041 // Pretend Insert mode here to allow the cursor on the 7042 // character past the end of the line 7043 State = INSERT; 7044 coladvance(getviscol()); 7045 State = save_State; 7046 } 7047 7048 invoke_edit(cap, FALSE, cap->cmdchar, FALSE); 7049 } 7050 else if (cap->cmdchar == K_PS) 7051 // drop the pasted text 7052 bracketed_paste(PASTE_INSERT, TRUE, NULL); 7053 } 7054 7055 /* 7056 * Invoke edit() and take care of "restart_edit" and the return value. 7057 */ 7058 static void 7059 invoke_edit( 7060 cmdarg_T *cap, 7061 int repl, // "r" or "gr" command 7062 int cmd, 7063 int startln) 7064 { 7065 int restart_edit_save = 0; 7066 7067 // Complicated: When the user types "a<C-O>a" we don't want to do Insert 7068 // mode recursively. But when doing "a<C-O>." or "a<C-O>rx" we do allow 7069 // it. 7070 if (repl || !stuff_empty()) 7071 restart_edit_save = restart_edit; 7072 else 7073 restart_edit_save = 0; 7074 7075 // Always reset "restart_edit", this is not a restarted edit. 7076 restart_edit = 0; 7077 7078 if (edit(cmd, startln, cap->count1)) 7079 cap->retval |= CA_COMMAND_BUSY; 7080 7081 if (restart_edit == 0) 7082 restart_edit = restart_edit_save; 7083 } 7084 7085 #ifdef FEAT_TEXTOBJ 7086 /* 7087 * "a" or "i" while an operator is pending or in Visual mode: object motion. 7088 */ 7089 static void 7090 nv_object( 7091 cmdarg_T *cap) 7092 { 7093 int flag; 7094 int include; 7095 char_u *mps_save; 7096 7097 if (cap->cmdchar == 'i') 7098 include = FALSE; // "ix" = inner object: exclude white space 7099 else 7100 include = TRUE; // "ax" = an object: include white space 7101 7102 // Make sure (), [], {} and <> are in 'matchpairs' 7103 mps_save = curbuf->b_p_mps; 7104 curbuf->b_p_mps = (char_u *)"(:),{:},[:],<:>"; 7105 7106 switch (cap->nchar) 7107 { 7108 case 'w': // "aw" = a word 7109 flag = current_word(cap->oap, cap->count1, include, FALSE); 7110 break; 7111 case 'W': // "aW" = a WORD 7112 flag = current_word(cap->oap, cap->count1, include, TRUE); 7113 break; 7114 case 'b': // "ab" = a braces block 7115 case '(': 7116 case ')': 7117 flag = current_block(cap->oap, cap->count1, include, '(', ')'); 7118 break; 7119 case 'B': // "aB" = a Brackets block 7120 case '{': 7121 case '}': 7122 flag = current_block(cap->oap, cap->count1, include, '{', '}'); 7123 break; 7124 case '[': // "a[" = a [] block 7125 case ']': 7126 flag = current_block(cap->oap, cap->count1, include, '[', ']'); 7127 break; 7128 case '<': // "a<" = a <> block 7129 case '>': 7130 flag = current_block(cap->oap, cap->count1, include, '<', '>'); 7131 break; 7132 case 't': // "at" = a tag block (xml and html) 7133 // Do not adjust oap->end in do_pending_operator() 7134 // otherwise there are different results for 'dit' 7135 // (note leading whitespace in last line): 7136 // 1) <b> 2) <b> 7137 // foobar foobar 7138 // </b> </b> 7139 cap->retval |= CA_NO_ADJ_OP_END; 7140 flag = current_tagblock(cap->oap, cap->count1, include); 7141 break; 7142 case 'p': // "ap" = a paragraph 7143 flag = current_par(cap->oap, cap->count1, include, 'p'); 7144 break; 7145 case 's': // "as" = a sentence 7146 flag = current_sent(cap->oap, cap->count1, include); 7147 break; 7148 case '"': // "a"" = a double quoted string 7149 case '\'': // "a'" = a single quoted string 7150 case '`': // "a`" = a backtick quoted string 7151 flag = current_quote(cap->oap, cap->count1, include, 7152 cap->nchar); 7153 break; 7154 #if 0 // TODO 7155 case 'S': // "aS" = a section 7156 case 'f': // "af" = a filename 7157 case 'u': // "au" = a URL 7158 #endif 7159 default: 7160 flag = FAIL; 7161 break; 7162 } 7163 7164 curbuf->b_p_mps = mps_save; 7165 if (flag == FAIL) 7166 clearopbeep(cap->oap); 7167 adjust_cursor_col(); 7168 curwin->w_set_curswant = TRUE; 7169 } 7170 #endif 7171 7172 /* 7173 * "q" command: Start/stop recording. 7174 * "q:", "q/", "q?": edit command-line in command-line window. 7175 */ 7176 static void 7177 nv_record(cmdarg_T *cap) 7178 { 7179 if (cap->oap->op_type == OP_FORMAT) 7180 { 7181 // "gqq" is the same as "gqgq": format line 7182 cap->cmdchar = 'g'; 7183 cap->nchar = 'q'; 7184 nv_operator(cap); 7185 } 7186 else if (!checkclearop(cap->oap)) 7187 { 7188 #ifdef FEAT_CMDWIN 7189 if (cap->nchar == ':' || cap->nchar == '/' || cap->nchar == '?') 7190 { 7191 stuffcharReadbuff(cap->nchar); 7192 stuffcharReadbuff(K_CMDWIN); 7193 } 7194 else 7195 #endif 7196 // (stop) recording into a named register, unless executing a 7197 // register 7198 if (reg_executing == 0 && do_record(cap->nchar) == FAIL) 7199 clearopbeep(cap->oap); 7200 } 7201 } 7202 7203 /* 7204 * Handle the "@r" command. 7205 */ 7206 static void 7207 nv_at(cmdarg_T *cap) 7208 { 7209 if (checkclearop(cap->oap)) 7210 return; 7211 #ifdef FEAT_EVAL 7212 if (cap->nchar == '=') 7213 { 7214 if (get_expr_register() == NUL) 7215 return; 7216 } 7217 #endif 7218 while (cap->count1-- && !got_int) 7219 { 7220 if (do_execreg(cap->nchar, FALSE, FALSE, FALSE) == FAIL) 7221 { 7222 clearopbeep(cap->oap); 7223 break; 7224 } 7225 line_breakcheck(); 7226 } 7227 } 7228 7229 /* 7230 * Handle the CTRL-U and CTRL-D commands. 7231 */ 7232 static void 7233 nv_halfpage(cmdarg_T *cap) 7234 { 7235 if ((cap->cmdchar == Ctrl_U && curwin->w_cursor.lnum == 1) 7236 || (cap->cmdchar == Ctrl_D 7237 && curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count)) 7238 clearopbeep(cap->oap); 7239 else if (!checkclearop(cap->oap)) 7240 halfpage(cap->cmdchar == Ctrl_D, cap->count0); 7241 } 7242 7243 /* 7244 * Handle "J" or "gJ" command. 7245 */ 7246 static void 7247 nv_join(cmdarg_T *cap) 7248 { 7249 if (VIsual_active) // join the visual lines 7250 nv_operator(cap); 7251 else if (!checkclearop(cap->oap)) 7252 { 7253 if (cap->count0 <= 1) 7254 cap->count0 = 2; // default for join is two lines! 7255 if (curwin->w_cursor.lnum + cap->count0 - 1 > 7256 curbuf->b_ml.ml_line_count) 7257 { 7258 // can't join when on the last line 7259 if (cap->count0 <= 2) 7260 { 7261 clearopbeep(cap->oap); 7262 return; 7263 } 7264 cap->count0 = curbuf->b_ml.ml_line_count 7265 - curwin->w_cursor.lnum + 1; 7266 } 7267 7268 prep_redo(cap->oap->regname, cap->count0, 7269 NUL, cap->cmdchar, NUL, NUL, cap->nchar); 7270 (void)do_join(cap->count0, cap->nchar == NUL, TRUE, TRUE, TRUE); 7271 } 7272 } 7273 7274 /* 7275 * "P", "gP", "p" and "gp" commands. 7276 */ 7277 static void 7278 nv_put(cmdarg_T *cap) 7279 { 7280 nv_put_opt(cap, FALSE); 7281 } 7282 7283 /* 7284 * "P", "gP", "p" and "gp" commands. 7285 * "fix_indent" is TRUE for "[p", "[P", "]p" and "]P". 7286 */ 7287 static void 7288 nv_put_opt(cmdarg_T *cap, int fix_indent) 7289 { 7290 int regname = 0; 7291 void *reg1 = NULL, *reg2 = NULL; 7292 int empty = FALSE; 7293 int was_visual = FALSE; 7294 int dir; 7295 int flags = 0; 7296 7297 if (cap->oap->op_type != OP_NOP) 7298 { 7299 #ifdef FEAT_DIFF 7300 // "dp" is ":diffput" 7301 if (cap->oap->op_type == OP_DELETE && cap->cmdchar == 'p') 7302 { 7303 clearop(cap->oap); 7304 nv_diffgetput(TRUE, cap->opcount); 7305 } 7306 else 7307 #endif 7308 clearopbeep(cap->oap); 7309 } 7310 #ifdef FEAT_JOB_CHANNEL 7311 else if (bt_prompt(curbuf) && !prompt_curpos_editable()) 7312 { 7313 clearopbeep(cap->oap); 7314 } 7315 #endif 7316 else 7317 { 7318 if (fix_indent) 7319 { 7320 dir = (cap->cmdchar == ']' && cap->nchar == 'p') 7321 ? FORWARD : BACKWARD; 7322 flags |= PUT_FIXINDENT; 7323 } 7324 else 7325 dir = (cap->cmdchar == 'P' 7326 || (cap->cmdchar == 'g' && cap->nchar == 'P')) 7327 ? BACKWARD : FORWARD; 7328 prep_redo_cmd(cap); 7329 if (cap->cmdchar == 'g') 7330 flags |= PUT_CURSEND; 7331 7332 if (VIsual_active) 7333 { 7334 // Putting in Visual mode: The put text replaces the selected 7335 // text. First delete the selected text, then put the new text. 7336 // Need to save and restore the registers that the delete 7337 // overwrites if the old contents is being put. 7338 was_visual = TRUE; 7339 regname = cap->oap->regname; 7340 #ifdef FEAT_CLIPBOARD 7341 adjust_clip_reg(®name); 7342 #endif 7343 if (regname == 0 || regname == '"' 7344 || VIM_ISDIGIT(regname) || regname == '-' 7345 #ifdef FEAT_CLIPBOARD 7346 || (clip_unnamed && (regname == '*' || regname == '+')) 7347 #endif 7348 7349 ) 7350 { 7351 // The delete is going to overwrite the register we want to 7352 // put, save it first. 7353 reg1 = get_register(regname, TRUE); 7354 } 7355 7356 // Now delete the selected text. Avoid messages here. 7357 cap->cmdchar = 'd'; 7358 cap->nchar = NUL; 7359 cap->oap->regname = NUL; 7360 ++msg_silent; 7361 nv_operator(cap); 7362 do_pending_operator(cap, 0, FALSE); 7363 empty = (curbuf->b_ml.ml_flags & ML_EMPTY); 7364 --msg_silent; 7365 7366 // delete PUT_LINE_BACKWARD; 7367 cap->oap->regname = regname; 7368 7369 if (reg1 != NULL) 7370 { 7371 // Delete probably changed the register we want to put, save 7372 // it first. Then put back what was there before the delete. 7373 reg2 = get_register(regname, FALSE); 7374 put_register(regname, reg1); 7375 } 7376 7377 // When deleted a linewise Visual area, put the register as 7378 // lines to avoid it joined with the next line. When deletion was 7379 // characterwise, split a line when putting lines. 7380 if (VIsual_mode == 'V') 7381 flags |= PUT_LINE; 7382 else if (VIsual_mode == 'v') 7383 flags |= PUT_LINE_SPLIT; 7384 if (VIsual_mode == Ctrl_V && dir == FORWARD) 7385 flags |= PUT_LINE_FORWARD; 7386 dir = BACKWARD; 7387 if ((VIsual_mode != 'V' 7388 && curwin->w_cursor.col < curbuf->b_op_start.col) 7389 || (VIsual_mode == 'V' 7390 && curwin->w_cursor.lnum < curbuf->b_op_start.lnum)) 7391 // cursor is at the end of the line or end of file, put 7392 // forward. 7393 dir = FORWARD; 7394 // May have been reset in do_put(). 7395 VIsual_active = TRUE; 7396 } 7397 do_put(cap->oap->regname, dir, cap->count1, flags); 7398 7399 // If a register was saved, put it back now. 7400 if (reg2 != NULL) 7401 put_register(regname, reg2); 7402 7403 // What to reselect with "gv"? Selecting the just put text seems to 7404 // be the most useful, since the original text was removed. 7405 if (was_visual) 7406 { 7407 curbuf->b_visual.vi_start = curbuf->b_op_start; 7408 curbuf->b_visual.vi_end = curbuf->b_op_end; 7409 // need to adjust cursor position 7410 if (*p_sel == 'e') 7411 inc(&curbuf->b_visual.vi_end); 7412 } 7413 7414 // When all lines were selected and deleted do_put() leaves an empty 7415 // line that needs to be deleted now. 7416 if (empty && *ml_get(curbuf->b_ml.ml_line_count) == NUL) 7417 { 7418 ml_delete_flags(curbuf->b_ml.ml_line_count, ML_DEL_MESSAGE); 7419 deleted_lines(curbuf->b_ml.ml_line_count + 1, 1); 7420 7421 // If the cursor was in that line, move it to the end of the last 7422 // line. 7423 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) 7424 { 7425 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; 7426 coladvance((colnr_T)MAXCOL); 7427 } 7428 } 7429 auto_format(FALSE, TRUE); 7430 } 7431 } 7432 7433 /* 7434 * "o" and "O" commands. 7435 */ 7436 static void 7437 nv_open(cmdarg_T *cap) 7438 { 7439 #ifdef FEAT_DIFF 7440 // "do" is ":diffget" 7441 if (cap->oap->op_type == OP_DELETE && cap->cmdchar == 'o') 7442 { 7443 clearop(cap->oap); 7444 nv_diffgetput(FALSE, cap->opcount); 7445 } 7446 else 7447 #endif 7448 if (VIsual_active) // switch start and end of visual 7449 v_swap_corners(cap->cmdchar); 7450 #ifdef FEAT_JOB_CHANNEL 7451 else if (bt_prompt(curbuf)) 7452 clearopbeep(cap->oap); 7453 #endif 7454 else 7455 n_opencmd(cap); 7456 } 7457 7458 #ifdef FEAT_NETBEANS_INTG 7459 static void 7460 nv_nbcmd(cmdarg_T *cap) 7461 { 7462 netbeans_keycommand(cap->nchar); 7463 } 7464 #endif 7465 7466 #ifdef FEAT_DND 7467 static void 7468 nv_drop(cmdarg_T *cap UNUSED) 7469 { 7470 do_put('~', BACKWARD, 1L, PUT_CURSEND); 7471 } 7472 #endif 7473 7474 /* 7475 * Trigger CursorHold event. 7476 * When waiting for a character for 'updatetime' K_CURSORHOLD is put in the 7477 * input buffer. "did_cursorhold" is set to avoid retriggering. 7478 */ 7479 static void 7480 nv_cursorhold(cmdarg_T *cap) 7481 { 7482 apply_autocmds(EVENT_CURSORHOLD, NULL, NULL, FALSE, curbuf); 7483 did_cursorhold = TRUE; 7484 cap->retval |= CA_COMMAND_BUSY; // don't call edit() now 7485 } 7486