1 /* vi:set ts=8 sts=4 sw=4: 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 /* 11 * edit.c: functions for Insert mode 12 */ 13 14 #include "vim.h" 15 16 #ifdef FEAT_INS_EXPAND 17 /* 18 * definitions used for CTRL-X submode 19 */ 20 #define CTRL_X_WANT_IDENT 0x100 21 22 #define CTRL_X_NOT_DEFINED_YET 1 23 #define CTRL_X_SCROLL 2 24 #define CTRL_X_WHOLE_LINE 3 25 #define CTRL_X_FILES 4 26 #define CTRL_X_TAGS (5 + CTRL_X_WANT_IDENT) 27 #define CTRL_X_PATH_PATTERNS (6 + CTRL_X_WANT_IDENT) 28 #define CTRL_X_PATH_DEFINES (7 + CTRL_X_WANT_IDENT) 29 #define CTRL_X_FINISHED 8 30 #define CTRL_X_DICTIONARY (9 + CTRL_X_WANT_IDENT) 31 #define CTRL_X_THESAURUS (10 + CTRL_X_WANT_IDENT) 32 #define CTRL_X_CMDLINE 11 33 #define CTRL_X_FUNCTION 12 34 #define CTRL_X_OMNI 13 35 #define CTRL_X_SPELL 14 36 #define CTRL_X_LOCAL_MSG 15 /* only used in "ctrl_x_msgs" */ 37 38 #define CTRL_X_MSG(i) ctrl_x_msgs[(i) & ~CTRL_X_WANT_IDENT] 39 40 static char *ctrl_x_msgs[] = 41 { 42 N_(" Keyword completion (^N^P)"), /* ctrl_x_mode == 0, ^P/^N compl. */ 43 N_(" ^X mode (^]^D^E^F^I^K^L^N^O^Ps^U^V^Y)"), 44 NULL, 45 N_(" Whole line completion (^L^N^P)"), 46 N_(" File name completion (^F^N^P)"), 47 N_(" Tag completion (^]^N^P)"), 48 N_(" Path pattern completion (^N^P)"), 49 N_(" Definition completion (^D^N^P)"), 50 NULL, 51 N_(" Dictionary completion (^K^N^P)"), 52 N_(" Thesaurus completion (^T^N^P)"), 53 N_(" Command-line completion (^V^N^P)"), 54 N_(" User defined completion (^U^N^P)"), 55 N_(" Omni completion (^O^N^P)"), 56 N_(" Spelling suggestion (s^N^P)"), 57 N_(" Keyword Local completion (^N^P)"), 58 }; 59 60 static char e_hitend[] = N_("Hit end of paragraph"); 61 #ifdef FEAT_COMPL_FUNC 62 static char e_complwin[] = N_("E839: Completion function changed window"); 63 static char e_compldel[] = N_("E840: Completion function deleted text"); 64 #endif 65 66 /* 67 * Structure used to store one match for insert completion. 68 */ 69 typedef struct compl_S compl_T; 70 struct compl_S 71 { 72 compl_T *cp_next; 73 compl_T *cp_prev; 74 char_u *cp_str; /* matched text */ 75 char cp_icase; /* TRUE or FALSE: ignore case */ 76 char_u *(cp_text[CPT_COUNT]); /* text for the menu */ 77 char_u *cp_fname; /* file containing the match, allocated when 78 * cp_flags has FREE_FNAME */ 79 int cp_flags; /* ORIGINAL_TEXT, CONT_S_IPOS or FREE_FNAME */ 80 int cp_number; /* sequence number */ 81 }; 82 83 #define ORIGINAL_TEXT (1) /* the original text when the expansion begun */ 84 #define FREE_FNAME (2) 85 86 /* 87 * All the current matches are stored in a list. 88 * "compl_first_match" points to the start of the list. 89 * "compl_curr_match" points to the currently selected entry. 90 * "compl_shown_match" is different from compl_curr_match during 91 * ins_compl_get_exp(). 92 */ 93 static compl_T *compl_first_match = NULL; 94 static compl_T *compl_curr_match = NULL; 95 static compl_T *compl_shown_match = NULL; 96 97 /* After using a cursor key <Enter> selects a match in the popup menu, 98 * otherwise it inserts a line break. */ 99 static int compl_enter_selects = FALSE; 100 101 /* When "compl_leader" is not NULL only matches that start with this string 102 * are used. */ 103 static char_u *compl_leader = NULL; 104 105 static int compl_get_longest = FALSE; /* put longest common string 106 in compl_leader */ 107 108 static int compl_used_match; /* Selected one of the matches. When 109 FALSE the match was edited or using 110 the longest common string. */ 111 112 static int compl_was_interrupted = FALSE; /* didn't finish finding 113 completions. */ 114 115 static int compl_restarting = FALSE; /* don't insert match */ 116 117 /* When the first completion is done "compl_started" is set. When it's 118 * FALSE the word to be completed must be located. */ 119 static int compl_started = FALSE; 120 121 /* Set when doing something for completion that may call edit() recursively, 122 * which is not allowed. */ 123 static int compl_busy = FALSE; 124 125 static int compl_matches = 0; 126 static char_u *compl_pattern = NULL; 127 static int compl_direction = FORWARD; 128 static int compl_shows_dir = FORWARD; 129 static int compl_pending = 0; /* > 1 for postponed CTRL-N */ 130 static pos_T compl_startpos; 131 static colnr_T compl_col = 0; /* column where the text starts 132 * that is being completed */ 133 static char_u *compl_orig_text = NULL; /* text as it was before 134 * completion started */ 135 static int compl_cont_mode = 0; 136 static expand_T compl_xp; 137 138 static int compl_opt_refresh_always = FALSE; 139 140 static void ins_ctrl_x __ARGS((void)); 141 static int has_compl_option __ARGS((int dict_opt)); 142 static int ins_compl_accept_char __ARGS((int c)); 143 static int ins_compl_add __ARGS((char_u *str, int len, int icase, char_u *fname, char_u **cptext, int cdir, int flags, int adup)); 144 static int ins_compl_equal __ARGS((compl_T *match, char_u *str, int len)); 145 static void ins_compl_longest_match __ARGS((compl_T *match)); 146 static void ins_compl_add_matches __ARGS((int num_matches, char_u **matches, int icase)); 147 static int ins_compl_make_cyclic __ARGS((void)); 148 static void ins_compl_upd_pum __ARGS((void)); 149 static void ins_compl_del_pum __ARGS((void)); 150 static int pum_wanted __ARGS((void)); 151 static int pum_enough_matches __ARGS((void)); 152 static void ins_compl_dictionaries __ARGS((char_u *dict, char_u *pat, int flags, int thesaurus)); 153 static void ins_compl_files __ARGS((int count, char_u **files, int thesaurus, int flags, regmatch_T *regmatch, char_u *buf, int *dir)); 154 static char_u *find_line_end __ARGS((char_u *ptr)); 155 static void ins_compl_free __ARGS((void)); 156 static void ins_compl_clear __ARGS((void)); 157 static int ins_compl_bs __ARGS((void)); 158 static int ins_compl_need_restart __ARGS((void)); 159 static void ins_compl_new_leader __ARGS((void)); 160 static void ins_compl_addleader __ARGS((int c)); 161 static int ins_compl_len __ARGS((void)); 162 static void ins_compl_restart __ARGS((void)); 163 static void ins_compl_set_original_text __ARGS((char_u *str)); 164 static void ins_compl_addfrommatch __ARGS((void)); 165 static int ins_compl_prep __ARGS((int c)); 166 static void ins_compl_fixRedoBufForLeader __ARGS((char_u *ptr_arg)); 167 static buf_T *ins_compl_next_buf __ARGS((buf_T *buf, int flag)); 168 #if defined(FEAT_COMPL_FUNC) || defined(FEAT_EVAL) 169 static void ins_compl_add_list __ARGS((list_T *list)); 170 static void ins_compl_add_dict __ARGS((dict_T *dict)); 171 #endif 172 static int ins_compl_get_exp __ARGS((pos_T *ini)); 173 static void ins_compl_delete __ARGS((void)); 174 static void ins_compl_insert __ARGS((void)); 175 static int ins_compl_next __ARGS((int allow_get_expansion, int count, int insert_match)); 176 static int ins_compl_key2dir __ARGS((int c)); 177 static int ins_compl_pum_key __ARGS((int c)); 178 static int ins_compl_key2count __ARGS((int c)); 179 static int ins_compl_use_match __ARGS((int c)); 180 static int ins_complete __ARGS((int c)); 181 static unsigned quote_meta __ARGS((char_u *dest, char_u *str, int len)); 182 #endif /* FEAT_INS_EXPAND */ 183 184 #define BACKSPACE_CHAR 1 185 #define BACKSPACE_WORD 2 186 #define BACKSPACE_WORD_NOT_SPACE 3 187 #define BACKSPACE_LINE 4 188 189 static void ins_redraw __ARGS((int ready)); 190 static void ins_ctrl_v __ARGS((void)); 191 static void undisplay_dollar __ARGS((void)); 192 static void insert_special __ARGS((int, int, int)); 193 static void internal_format __ARGS((int textwidth, int second_indent, int flags, int format_only, int c)); 194 static void check_auto_format __ARGS((int)); 195 static void redo_literal __ARGS((int c)); 196 static void start_arrow __ARGS((pos_T *end_insert_pos)); 197 #ifdef FEAT_SPELL 198 static void check_spell_redraw __ARGS((void)); 199 static void spell_back_to_badword __ARGS((void)); 200 static int spell_bad_len = 0; /* length of located bad word */ 201 #endif 202 static void stop_insert __ARGS((pos_T *end_insert_pos, int esc)); 203 static int echeck_abbr __ARGS((int)); 204 static int replace_pop __ARGS((void)); 205 static void replace_join __ARGS((int off)); 206 static void replace_pop_ins __ARGS((void)); 207 #ifdef FEAT_MBYTE 208 static void mb_replace_pop_ins __ARGS((int cc)); 209 #endif 210 static void replace_flush __ARGS((void)); 211 static void replace_do_bs __ARGS((int limit_col)); 212 static int del_char_after_col __ARGS((int limit_col)); 213 #ifdef FEAT_CINDENT 214 static int cindent_on __ARGS((void)); 215 #endif 216 static void ins_reg __ARGS((void)); 217 static void ins_ctrl_g __ARGS((void)); 218 static void ins_ctrl_hat __ARGS((void)); 219 static int ins_esc __ARGS((long *count, int cmdchar, int nomove)); 220 #ifdef FEAT_RIGHTLEFT 221 static void ins_ctrl_ __ARGS((void)); 222 #endif 223 #ifdef FEAT_VISUAL 224 static int ins_start_select __ARGS((int c)); 225 #endif 226 static void ins_insert __ARGS((int replaceState)); 227 static void ins_ctrl_o __ARGS((void)); 228 static void ins_shift __ARGS((int c, int lastc)); 229 static void ins_del __ARGS((void)); 230 static int ins_bs __ARGS((int c, int mode, int *inserted_space_p)); 231 #ifdef FEAT_MOUSE 232 static void ins_mouse __ARGS((int c)); 233 static void ins_mousescroll __ARGS((int dir)); 234 #endif 235 #if defined(FEAT_GUI_TABLINE) || defined(PROTO) 236 static void ins_tabline __ARGS((int c)); 237 #endif 238 static void ins_left __ARGS((void)); 239 static void ins_home __ARGS((int c)); 240 static void ins_end __ARGS((int c)); 241 static void ins_s_left __ARGS((void)); 242 static void ins_right __ARGS((void)); 243 static void ins_s_right __ARGS((void)); 244 static void ins_up __ARGS((int startcol)); 245 static void ins_pageup __ARGS((void)); 246 static void ins_down __ARGS((int startcol)); 247 static void ins_pagedown __ARGS((void)); 248 #ifdef FEAT_DND 249 static void ins_drop __ARGS((void)); 250 #endif 251 static int ins_tab __ARGS((void)); 252 static int ins_eol __ARGS((int c)); 253 #ifdef FEAT_DIGRAPHS 254 static int ins_digraph __ARGS((void)); 255 #endif 256 static int ins_ctrl_ey __ARGS((int tc)); 257 #ifdef FEAT_SMARTINDENT 258 static void ins_try_si __ARGS((int c)); 259 #endif 260 static colnr_T get_nolist_virtcol __ARGS((void)); 261 #ifdef FEAT_AUTOCMD 262 static char_u *do_insert_char_pre __ARGS((int c)); 263 #endif 264 265 static colnr_T Insstart_textlen; /* length of line when insert started */ 266 static colnr_T Insstart_blank_vcol; /* vcol for first inserted blank */ 267 268 static char_u *last_insert = NULL; /* the text of the previous insert, 269 K_SPECIAL and CSI are escaped */ 270 static int last_insert_skip; /* nr of chars in front of previous insert */ 271 static int new_insert_skip; /* nr of chars in front of current insert */ 272 static int did_restart_edit; /* "restart_edit" when calling edit() */ 273 274 #ifdef FEAT_CINDENT 275 static int can_cindent; /* may do cindenting on this line */ 276 #endif 277 278 static int old_indent = 0; /* for ^^D command in insert mode */ 279 280 #ifdef FEAT_RIGHTLEFT 281 static int revins_on; /* reverse insert mode on */ 282 static int revins_chars; /* how much to skip after edit */ 283 static int revins_legal; /* was the last char 'legal'? */ 284 static int revins_scol; /* start column of revins session */ 285 #endif 286 287 static int ins_need_undo; /* call u_save() before inserting a 288 char. Set when edit() is called. 289 after that arrow_used is used. */ 290 291 static int did_add_space = FALSE; /* auto_format() added an extra space 292 under the cursor */ 293 294 /* 295 * edit(): Start inserting text. 296 * 297 * "cmdchar" can be: 298 * 'i' normal insert command 299 * 'a' normal append command 300 * 'R' replace command 301 * 'r' "r<CR>" command: insert one <CR>. Note: count can be > 1, for redo, 302 * but still only one <CR> is inserted. The <Esc> is not used for redo. 303 * 'g' "gI" command. 304 * 'V' "gR" command for Virtual Replace mode. 305 * 'v' "gr" command for single character Virtual Replace mode. 306 * 307 * This function is not called recursively. For CTRL-O commands, it returns 308 * and lets the caller handle the Normal-mode command. 309 * 310 * Return TRUE if a CTRL-O command caused the return (insert mode pending). 311 */ 312 int 313 edit(cmdchar, startln, count) 314 int cmdchar; 315 int startln; /* if set, insert at start of line */ 316 long count; 317 { 318 int c = 0; 319 char_u *ptr; 320 int lastc; 321 int mincol; 322 static linenr_T o_lnum = 0; 323 int i; 324 int did_backspace = TRUE; /* previous char was backspace */ 325 #ifdef FEAT_CINDENT 326 int line_is_white = FALSE; /* line is empty before insert */ 327 #endif 328 linenr_T old_topline = 0; /* topline before insertion */ 329 #ifdef FEAT_DIFF 330 int old_topfill = -1; 331 #endif 332 int inserted_space = FALSE; /* just inserted a space */ 333 int replaceState = REPLACE; 334 int nomove = FALSE; /* don't move cursor on return */ 335 336 /* Remember whether editing was restarted after CTRL-O. */ 337 did_restart_edit = restart_edit; 338 339 /* sleep before redrawing, needed for "CTRL-O :" that results in an 340 * error message */ 341 check_for_delay(TRUE); 342 343 #ifdef HAVE_SANDBOX 344 /* Don't allow inserting in the sandbox. */ 345 if (sandbox != 0) 346 { 347 EMSG(_(e_sandbox)); 348 return FALSE; 349 } 350 #endif 351 /* Don't allow changes in the buffer while editing the cmdline. The 352 * caller of getcmdline() may get confused. */ 353 if (textlock != 0) 354 { 355 EMSG(_(e_secure)); 356 return FALSE; 357 } 358 359 #ifdef FEAT_INS_EXPAND 360 /* Don't allow recursive insert mode when busy with completion. */ 361 if (compl_started || compl_busy || pum_visible()) 362 { 363 EMSG(_(e_secure)); 364 return FALSE; 365 } 366 ins_compl_clear(); /* clear stuff for CTRL-X mode */ 367 #endif 368 369 #ifdef FEAT_AUTOCMD 370 /* 371 * Trigger InsertEnter autocommands. Do not do this for "r<CR>" or "grx". 372 */ 373 if (cmdchar != 'r' && cmdchar != 'v') 374 { 375 pos_T save_cursor = curwin->w_cursor; 376 377 # ifdef FEAT_EVAL 378 if (cmdchar == 'R') 379 ptr = (char_u *)"r"; 380 else if (cmdchar == 'V') 381 ptr = (char_u *)"v"; 382 else 383 ptr = (char_u *)"i"; 384 set_vim_var_string(VV_INSERTMODE, ptr, 1); 385 set_vim_var_string(VV_CHAR, NULL, -1); /* clear v:char */ 386 # endif 387 apply_autocmds(EVENT_INSERTENTER, NULL, NULL, FALSE, curbuf); 388 389 /* Make sure the cursor didn't move. Do call check_cursor_col() in 390 * case the text was modified. Since Insert mode was not started yet 391 * a call to check_cursor_col() may move the cursor, especially with 392 * the "A" command, thus set State to avoid that. Also check that the 393 * line number is still valid (lines may have been deleted). 394 * Do not restore if v:char was set to a non-empty string. */ 395 if (!equalpos(curwin->w_cursor, save_cursor) 396 # ifdef FEAT_EVAL 397 && *get_vim_var_str(VV_CHAR) == NUL 398 # endif 399 && save_cursor.lnum <= curbuf->b_ml.ml_line_count) 400 { 401 int save_state = State; 402 403 curwin->w_cursor = save_cursor; 404 State = INSERT; 405 check_cursor_col(); 406 State = save_state; 407 } 408 } 409 #endif 410 411 #ifdef FEAT_CONCEAL 412 /* Check if the cursor line needs redrawing before changing State. If 413 * 'concealcursor' is "n" it needs to be redrawn without concealing. */ 414 conceal_check_cursur_line(); 415 #endif 416 417 #ifdef FEAT_MOUSE 418 /* 419 * When doing a paste with the middle mouse button, Insstart is set to 420 * where the paste started. 421 */ 422 if (where_paste_started.lnum != 0) 423 Insstart = where_paste_started; 424 else 425 #endif 426 { 427 Insstart = curwin->w_cursor; 428 if (startln) 429 Insstart.col = 0; 430 } 431 Insstart_textlen = (colnr_T)linetabsize(ml_get_curline()); 432 Insstart_blank_vcol = MAXCOL; 433 if (!did_ai) 434 ai_col = 0; 435 436 if (cmdchar != NUL && restart_edit == 0) 437 { 438 ResetRedobuff(); 439 AppendNumberToRedobuff(count); 440 #ifdef FEAT_VREPLACE 441 if (cmdchar == 'V' || cmdchar == 'v') 442 { 443 /* "gR" or "gr" command */ 444 AppendCharToRedobuff('g'); 445 AppendCharToRedobuff((cmdchar == 'v') ? 'r' : 'R'); 446 } 447 else 448 #endif 449 { 450 AppendCharToRedobuff(cmdchar); 451 if (cmdchar == 'g') /* "gI" command */ 452 AppendCharToRedobuff('I'); 453 else if (cmdchar == 'r') /* "r<CR>" command */ 454 count = 1; /* insert only one <CR> */ 455 } 456 } 457 458 if (cmdchar == 'R') 459 { 460 #ifdef FEAT_FKMAP 461 if (p_fkmap && p_ri) 462 { 463 beep_flush(); 464 EMSG(farsi_text_3); /* encoded in Farsi */ 465 State = INSERT; 466 } 467 else 468 #endif 469 State = REPLACE; 470 } 471 #ifdef FEAT_VREPLACE 472 else if (cmdchar == 'V' || cmdchar == 'v') 473 { 474 State = VREPLACE; 475 replaceState = VREPLACE; 476 orig_line_count = curbuf->b_ml.ml_line_count; 477 vr_lines_changed = 1; 478 } 479 #endif 480 else 481 State = INSERT; 482 483 stop_insert_mode = FALSE; 484 485 /* 486 * Need to recompute the cursor position, it might move when the cursor is 487 * on a TAB or special character. 488 */ 489 curs_columns(TRUE); 490 491 /* 492 * Enable langmap or IME, indicated by 'iminsert'. 493 * Note that IME may enabled/disabled without us noticing here, thus the 494 * 'iminsert' value may not reflect what is actually used. It is updated 495 * when hitting <Esc>. 496 */ 497 if (curbuf->b_p_iminsert == B_IMODE_LMAP) 498 State |= LANGMAP; 499 #ifdef USE_IM_CONTROL 500 im_set_active(curbuf->b_p_iminsert == B_IMODE_IM); 501 #endif 502 503 #ifdef FEAT_MOUSE 504 setmouse(); 505 #endif 506 #ifdef FEAT_CMDL_INFO 507 clear_showcmd(); 508 #endif 509 #ifdef FEAT_RIGHTLEFT 510 /* there is no reverse replace mode */ 511 revins_on = (State == INSERT && p_ri); 512 if (revins_on) 513 undisplay_dollar(); 514 revins_chars = 0; 515 revins_legal = 0; 516 revins_scol = -1; 517 #endif 518 519 /* 520 * Handle restarting Insert mode. 521 * Don't do this for "CTRL-O ." (repeat an insert): we get here with 522 * restart_edit non-zero, and something in the stuff buffer. 523 */ 524 if (restart_edit != 0 && stuff_empty()) 525 { 526 #ifdef FEAT_MOUSE 527 /* 528 * After a paste we consider text typed to be part of the insert for 529 * the pasted text. You can backspace over the pasted text too. 530 */ 531 if (where_paste_started.lnum) 532 arrow_used = FALSE; 533 else 534 #endif 535 arrow_used = TRUE; 536 restart_edit = 0; 537 538 /* 539 * If the cursor was after the end-of-line before the CTRL-O and it is 540 * now at the end-of-line, put it after the end-of-line (this is not 541 * correct in very rare cases). 542 * Also do this if curswant is greater than the current virtual 543 * column. Eg after "^O$" or "^O80|". 544 */ 545 validate_virtcol(); 546 update_curswant(); 547 if (((ins_at_eol && curwin->w_cursor.lnum == o_lnum) 548 || curwin->w_curswant > curwin->w_virtcol) 549 && *(ptr = ml_get_curline() + curwin->w_cursor.col) != NUL) 550 { 551 if (ptr[1] == NUL) 552 ++curwin->w_cursor.col; 553 #ifdef FEAT_MBYTE 554 else if (has_mbyte) 555 { 556 i = (*mb_ptr2len)(ptr); 557 if (ptr[i] == NUL) 558 curwin->w_cursor.col += i; 559 } 560 #endif 561 } 562 ins_at_eol = FALSE; 563 } 564 else 565 arrow_used = FALSE; 566 567 /* we are in insert mode now, don't need to start it anymore */ 568 need_start_insertmode = FALSE; 569 570 /* Need to save the line for undo before inserting the first char. */ 571 ins_need_undo = TRUE; 572 573 #ifdef FEAT_MOUSE 574 where_paste_started.lnum = 0; 575 #endif 576 #ifdef FEAT_CINDENT 577 can_cindent = TRUE; 578 #endif 579 #ifdef FEAT_FOLDING 580 /* The cursor line is not in a closed fold, unless 'insertmode' is set or 581 * restarting. */ 582 if (!p_im && did_restart_edit == 0) 583 foldOpenCursor(); 584 #endif 585 586 /* 587 * If 'showmode' is set, show the current (insert/replace/..) mode. 588 * A warning message for changing a readonly file is given here, before 589 * actually changing anything. It's put after the mode, if any. 590 */ 591 i = 0; 592 if (p_smd && msg_silent == 0) 593 i = showmode(); 594 595 if (!p_im && did_restart_edit == 0) 596 change_warning(i == 0 ? 0 : i + 1); 597 598 #ifdef CURSOR_SHAPE 599 ui_cursor_shape(); /* may show different cursor shape */ 600 #endif 601 #ifdef FEAT_DIGRAPHS 602 do_digraph(-1); /* clear digraphs */ 603 #endif 604 605 /* 606 * Get the current length of the redo buffer, those characters have to be 607 * skipped if we want to get to the inserted characters. 608 */ 609 ptr = get_inserted(); 610 if (ptr == NULL) 611 new_insert_skip = 0; 612 else 613 { 614 new_insert_skip = (int)STRLEN(ptr); 615 vim_free(ptr); 616 } 617 618 old_indent = 0; 619 620 /* 621 * Main loop in Insert mode: repeat until Insert mode is left. 622 */ 623 for (;;) 624 { 625 #ifdef FEAT_RIGHTLEFT 626 if (!revins_legal) 627 revins_scol = -1; /* reset on illegal motions */ 628 else 629 revins_legal = 0; 630 #endif 631 if (arrow_used) /* don't repeat insert when arrow key used */ 632 count = 0; 633 634 if (stop_insert_mode) 635 { 636 /* ":stopinsert" used or 'insertmode' reset */ 637 count = 0; 638 goto doESCkey; 639 } 640 641 /* set curwin->w_curswant for next K_DOWN or K_UP */ 642 if (!arrow_used) 643 curwin->w_set_curswant = TRUE; 644 645 /* If there is no typeahead may check for timestamps (e.g., for when a 646 * menu invoked a shell command). */ 647 if (stuff_empty()) 648 { 649 did_check_timestamps = FALSE; 650 if (need_check_timestamps) 651 check_timestamps(FALSE); 652 } 653 654 /* 655 * When emsg() was called msg_scroll will have been set. 656 */ 657 msg_scroll = FALSE; 658 659 #ifdef FEAT_GUI 660 /* When 'mousefocus' is set a mouse movement may have taken us to 661 * another window. "need_mouse_correct" may then be set because of an 662 * autocommand. */ 663 if (need_mouse_correct) 664 gui_mouse_correct(); 665 #endif 666 667 #ifdef FEAT_FOLDING 668 /* Open fold at the cursor line, according to 'foldopen'. */ 669 if (fdo_flags & FDO_INSERT) 670 foldOpenCursor(); 671 /* Close folds where the cursor isn't, according to 'foldclose' */ 672 if (!char_avail()) 673 foldCheckClose(); 674 #endif 675 676 /* 677 * If we inserted a character at the last position of the last line in 678 * the window, scroll the window one line up. This avoids an extra 679 * redraw. 680 * This is detected when the cursor column is smaller after inserting 681 * something. 682 * Don't do this when the topline changed already, it has 683 * already been adjusted (by insertchar() calling open_line())). 684 */ 685 if (curbuf->b_mod_set 686 && curwin->w_p_wrap 687 && !did_backspace 688 && curwin->w_topline == old_topline 689 #ifdef FEAT_DIFF 690 && curwin->w_topfill == old_topfill 691 #endif 692 ) 693 { 694 mincol = curwin->w_wcol; 695 validate_cursor_col(); 696 697 if ((int)curwin->w_wcol < mincol - curbuf->b_p_ts 698 && curwin->w_wrow == W_WINROW(curwin) 699 + curwin->w_height - 1 - p_so 700 && (curwin->w_cursor.lnum != curwin->w_topline 701 #ifdef FEAT_DIFF 702 || curwin->w_topfill > 0 703 #endif 704 )) 705 { 706 #ifdef FEAT_DIFF 707 if (curwin->w_topfill > 0) 708 --curwin->w_topfill; 709 else 710 #endif 711 #ifdef FEAT_FOLDING 712 if (hasFolding(curwin->w_topline, NULL, &old_topline)) 713 set_topline(curwin, old_topline + 1); 714 else 715 #endif 716 set_topline(curwin, curwin->w_topline + 1); 717 } 718 } 719 720 /* May need to adjust w_topline to show the cursor. */ 721 update_topline(); 722 723 did_backspace = FALSE; 724 725 validate_cursor(); /* may set must_redraw */ 726 727 /* 728 * Redraw the display when no characters are waiting. 729 * Also shows mode, ruler and positions cursor. 730 */ 731 ins_redraw(TRUE); 732 733 #ifdef FEAT_SCROLLBIND 734 if (curwin->w_p_scb) 735 do_check_scrollbind(TRUE); 736 #endif 737 738 #ifdef FEAT_CURSORBIND 739 if (curwin->w_p_crb) 740 do_check_cursorbind(); 741 #endif 742 update_curswant(); 743 old_topline = curwin->w_topline; 744 #ifdef FEAT_DIFF 745 old_topfill = curwin->w_topfill; 746 #endif 747 748 #ifdef USE_ON_FLY_SCROLL 749 dont_scroll = FALSE; /* allow scrolling here */ 750 #endif 751 752 /* 753 * Get a character for Insert mode. Ignore K_IGNORE. 754 */ 755 lastc = c; /* remember previous char for CTRL-D */ 756 do 757 { 758 c = safe_vgetc(); 759 } while (c == K_IGNORE); 760 761 #ifdef FEAT_AUTOCMD 762 /* Don't want K_CURSORHOLD for the second key, e.g., after CTRL-V. */ 763 did_cursorhold = TRUE; 764 #endif 765 766 #ifdef FEAT_RIGHTLEFT 767 if (p_hkmap && KeyTyped) 768 c = hkmap(c); /* Hebrew mode mapping */ 769 #endif 770 #ifdef FEAT_FKMAP 771 if (p_fkmap && KeyTyped) 772 c = fkmap(c); /* Farsi mode mapping */ 773 #endif 774 775 #ifdef FEAT_INS_EXPAND 776 /* 777 * Special handling of keys while the popup menu is visible or wanted 778 * and the cursor is still in the completed word. Only when there is 779 * a match, skip this when no matches were found. 780 */ 781 if (compl_started 782 && pum_wanted() 783 && curwin->w_cursor.col >= compl_col 784 && (compl_shown_match == NULL 785 || compl_shown_match != compl_shown_match->cp_next)) 786 { 787 /* BS: Delete one character from "compl_leader". */ 788 if ((c == K_BS || c == Ctrl_H) 789 && curwin->w_cursor.col > compl_col 790 && (c = ins_compl_bs()) == NUL) 791 continue; 792 793 /* When no match was selected or it was edited. */ 794 if (!compl_used_match) 795 { 796 /* CTRL-L: Add one character from the current match to 797 * "compl_leader". Except when at the original match and 798 * there is nothing to add, CTRL-L works like CTRL-P then. */ 799 if (c == Ctrl_L 800 && (ctrl_x_mode != CTRL_X_WHOLE_LINE 801 || (int)STRLEN(compl_shown_match->cp_str) 802 > curwin->w_cursor.col - compl_col)) 803 { 804 ins_compl_addfrommatch(); 805 continue; 806 } 807 808 /* A non-white character that fits in with the current 809 * completion: Add to "compl_leader". */ 810 if (ins_compl_accept_char(c)) 811 { 812 #ifdef FEAT_AUTOCMD 813 /* Trigger InsertCharPre. */ 814 char_u *str = do_insert_char_pre(c); 815 char_u *p; 816 817 if (str != NULL) 818 { 819 for (p = str; *p != NUL; mb_ptr_adv(p)) 820 ins_compl_addleader(PTR2CHAR(p)); 821 vim_free(str); 822 } 823 else 824 #endif 825 ins_compl_addleader(c); 826 continue; 827 } 828 829 /* Pressing CTRL-Y selects the current match. When 830 * compl_enter_selects is set the Enter key does the same. */ 831 if (c == Ctrl_Y || (compl_enter_selects 832 && (c == CAR || c == K_KENTER || c == NL))) 833 { 834 ins_compl_delete(); 835 ins_compl_insert(); 836 } 837 } 838 } 839 840 /* Prepare for or stop CTRL-X mode. This doesn't do completion, but 841 * it does fix up the text when finishing completion. */ 842 compl_get_longest = FALSE; 843 if (ins_compl_prep(c)) 844 continue; 845 #endif 846 847 /* CTRL-\ CTRL-N goes to Normal mode, 848 * CTRL-\ CTRL-G goes to mode selected with 'insertmode', 849 * CTRL-\ CTRL-O is like CTRL-O but without moving the cursor. */ 850 if (c == Ctrl_BSL) 851 { 852 /* may need to redraw when no more chars available now */ 853 ins_redraw(FALSE); 854 ++no_mapping; 855 ++allow_keys; 856 c = plain_vgetc(); 857 --no_mapping; 858 --allow_keys; 859 if (c != Ctrl_N && c != Ctrl_G && c != Ctrl_O) 860 { 861 /* it's something else */ 862 vungetc(c); 863 c = Ctrl_BSL; 864 } 865 else if (c == Ctrl_G && p_im) 866 continue; 867 else 868 { 869 if (c == Ctrl_O) 870 { 871 ins_ctrl_o(); 872 ins_at_eol = FALSE; /* cursor keeps its column */ 873 nomove = TRUE; 874 } 875 count = 0; 876 goto doESCkey; 877 } 878 } 879 880 #ifdef FEAT_DIGRAPHS 881 c = do_digraph(c); 882 #endif 883 884 #ifdef FEAT_INS_EXPAND 885 if ((c == Ctrl_V || c == Ctrl_Q) && ctrl_x_mode == CTRL_X_CMDLINE) 886 goto docomplete; 887 #endif 888 if (c == Ctrl_V || c == Ctrl_Q) 889 { 890 ins_ctrl_v(); 891 c = Ctrl_V; /* pretend CTRL-V is last typed character */ 892 continue; 893 } 894 895 #ifdef FEAT_CINDENT 896 if (cindent_on() 897 # ifdef FEAT_INS_EXPAND 898 && ctrl_x_mode == 0 899 # endif 900 ) 901 { 902 /* A key name preceded by a bang means this key is not to be 903 * inserted. Skip ahead to the re-indenting below. 904 * A key name preceded by a star means that indenting has to be 905 * done before inserting the key. */ 906 line_is_white = inindent(0); 907 if (in_cinkeys(c, '!', line_is_white)) 908 goto force_cindent; 909 if (can_cindent && in_cinkeys(c, '*', line_is_white) 910 && stop_arrow() == OK) 911 do_c_expr_indent(); 912 } 913 #endif 914 915 #ifdef FEAT_RIGHTLEFT 916 if (curwin->w_p_rl) 917 switch (c) 918 { 919 case K_LEFT: c = K_RIGHT; break; 920 case K_S_LEFT: c = K_S_RIGHT; break; 921 case K_C_LEFT: c = K_C_RIGHT; break; 922 case K_RIGHT: c = K_LEFT; break; 923 case K_S_RIGHT: c = K_S_LEFT; break; 924 case K_C_RIGHT: c = K_C_LEFT; break; 925 } 926 #endif 927 928 #ifdef FEAT_VISUAL 929 /* 930 * If 'keymodel' contains "startsel", may start selection. If it 931 * does, a CTRL-O and c will be stuffed, we need to get these 932 * characters. 933 */ 934 if (ins_start_select(c)) 935 continue; 936 #endif 937 938 /* 939 * The big switch to handle a character in insert mode. 940 */ 941 switch (c) 942 { 943 case ESC: /* End input mode */ 944 if (echeck_abbr(ESC + ABBR_OFF)) 945 break; 946 /*FALLTHROUGH*/ 947 948 case Ctrl_C: /* End input mode */ 949 #ifdef FEAT_CMDWIN 950 if (c == Ctrl_C && cmdwin_type != 0) 951 { 952 /* Close the cmdline window. */ 953 cmdwin_result = K_IGNORE; 954 got_int = FALSE; /* don't stop executing autocommands et al. */ 955 nomove = TRUE; 956 goto doESCkey; 957 } 958 #endif 959 960 #ifdef UNIX 961 do_intr: 962 #endif 963 /* when 'insertmode' set, and not halfway a mapping, don't leave 964 * Insert mode */ 965 if (goto_im()) 966 { 967 if (got_int) 968 { 969 (void)vgetc(); /* flush all buffers */ 970 got_int = FALSE; 971 } 972 else 973 vim_beep(); 974 break; 975 } 976 doESCkey: 977 /* 978 * This is the ONLY return from edit()! 979 */ 980 /* Always update o_lnum, so that a "CTRL-O ." that adds a line 981 * still puts the cursor back after the inserted text. */ 982 if (ins_at_eol && gchar_cursor() == NUL) 983 o_lnum = curwin->w_cursor.lnum; 984 985 if (ins_esc(&count, cmdchar, nomove)) 986 { 987 #ifdef FEAT_AUTOCMD 988 if (cmdchar != 'r' && cmdchar != 'v') 989 apply_autocmds(EVENT_INSERTLEAVE, NULL, NULL, 990 FALSE, curbuf); 991 did_cursorhold = FALSE; 992 #endif 993 return (c == Ctrl_O); 994 } 995 continue; 996 997 case Ctrl_Z: /* suspend when 'insertmode' set */ 998 if (!p_im) 999 goto normalchar; /* insert CTRL-Z as normal char */ 1000 stuffReadbuff((char_u *)":st\r"); 1001 c = Ctrl_O; 1002 /*FALLTHROUGH*/ 1003 1004 case Ctrl_O: /* execute one command */ 1005 #ifdef FEAT_COMPL_FUNC 1006 if (ctrl_x_mode == CTRL_X_OMNI) 1007 goto docomplete; 1008 #endif 1009 if (echeck_abbr(Ctrl_O + ABBR_OFF)) 1010 break; 1011 ins_ctrl_o(); 1012 1013 #ifdef FEAT_VIRTUALEDIT 1014 /* don't move the cursor left when 'virtualedit' has "onemore". */ 1015 if (ve_flags & VE_ONEMORE) 1016 { 1017 ins_at_eol = FALSE; 1018 nomove = TRUE; 1019 } 1020 #endif 1021 count = 0; 1022 goto doESCkey; 1023 1024 case K_INS: /* toggle insert/replace mode */ 1025 case K_KINS: 1026 ins_insert(replaceState); 1027 break; 1028 1029 case K_SELECT: /* end of Select mode mapping - ignore */ 1030 break; 1031 1032 #ifdef FEAT_SNIFF 1033 case K_SNIFF: /* Sniff command received */ 1034 stuffcharReadbuff(K_SNIFF); 1035 goto doESCkey; 1036 #endif 1037 1038 case K_HELP: /* Help key works like <ESC> <Help> */ 1039 case K_F1: 1040 case K_XF1: 1041 stuffcharReadbuff(K_HELP); 1042 if (p_im) 1043 need_start_insertmode = TRUE; 1044 goto doESCkey; 1045 1046 #ifdef FEAT_NETBEANS_INTG 1047 case K_F21: /* NetBeans command */ 1048 ++no_mapping; /* don't map the next key hits */ 1049 i = plain_vgetc(); 1050 --no_mapping; 1051 netbeans_keycommand(i); 1052 break; 1053 #endif 1054 1055 case K_ZERO: /* Insert the previously inserted text. */ 1056 case NUL: 1057 case Ctrl_A: 1058 /* For ^@ the trailing ESC will end the insert, unless there is an 1059 * error. */ 1060 if (stuff_inserted(NUL, 1L, (c == Ctrl_A)) == FAIL 1061 && c != Ctrl_A && !p_im) 1062 goto doESCkey; /* quit insert mode */ 1063 inserted_space = FALSE; 1064 break; 1065 1066 case Ctrl_R: /* insert the contents of a register */ 1067 ins_reg(); 1068 auto_format(FALSE, TRUE); 1069 inserted_space = FALSE; 1070 break; 1071 1072 case Ctrl_G: /* commands starting with CTRL-G */ 1073 ins_ctrl_g(); 1074 break; 1075 1076 case Ctrl_HAT: /* switch input mode and/or langmap */ 1077 ins_ctrl_hat(); 1078 break; 1079 1080 #ifdef FEAT_RIGHTLEFT 1081 case Ctrl__: /* switch between languages */ 1082 if (!p_ari) 1083 goto normalchar; 1084 ins_ctrl_(); 1085 break; 1086 #endif 1087 1088 case Ctrl_D: /* Make indent one shiftwidth smaller. */ 1089 #if defined(FEAT_INS_EXPAND) && defined(FEAT_FIND_ID) 1090 if (ctrl_x_mode == CTRL_X_PATH_DEFINES) 1091 goto docomplete; 1092 #endif 1093 /* FALLTHROUGH */ 1094 1095 case Ctrl_T: /* Make indent one shiftwidth greater. */ 1096 # ifdef FEAT_INS_EXPAND 1097 if (c == Ctrl_T && ctrl_x_mode == CTRL_X_THESAURUS) 1098 { 1099 if (has_compl_option(FALSE)) 1100 goto docomplete; 1101 break; 1102 } 1103 # endif 1104 ins_shift(c, lastc); 1105 auto_format(FALSE, TRUE); 1106 inserted_space = FALSE; 1107 break; 1108 1109 case K_DEL: /* delete character under the cursor */ 1110 case K_KDEL: 1111 ins_del(); 1112 auto_format(FALSE, TRUE); 1113 break; 1114 1115 case K_BS: /* delete character before the cursor */ 1116 case Ctrl_H: 1117 did_backspace = ins_bs(c, BACKSPACE_CHAR, &inserted_space); 1118 auto_format(FALSE, TRUE); 1119 break; 1120 1121 case Ctrl_W: /* delete word before the cursor */ 1122 did_backspace = ins_bs(c, BACKSPACE_WORD, &inserted_space); 1123 auto_format(FALSE, TRUE); 1124 break; 1125 1126 case Ctrl_U: /* delete all inserted text in current line */ 1127 # ifdef FEAT_COMPL_FUNC 1128 /* CTRL-X CTRL-U completes with 'completefunc'. */ 1129 if (ctrl_x_mode == CTRL_X_FUNCTION) 1130 goto docomplete; 1131 # endif 1132 did_backspace = ins_bs(c, BACKSPACE_LINE, &inserted_space); 1133 auto_format(FALSE, TRUE); 1134 inserted_space = FALSE; 1135 break; 1136 1137 #ifdef FEAT_MOUSE 1138 case K_LEFTMOUSE: /* mouse keys */ 1139 case K_LEFTMOUSE_NM: 1140 case K_LEFTDRAG: 1141 case K_LEFTRELEASE: 1142 case K_LEFTRELEASE_NM: 1143 case K_MIDDLEMOUSE: 1144 case K_MIDDLEDRAG: 1145 case K_MIDDLERELEASE: 1146 case K_RIGHTMOUSE: 1147 case K_RIGHTDRAG: 1148 case K_RIGHTRELEASE: 1149 case K_X1MOUSE: 1150 case K_X1DRAG: 1151 case K_X1RELEASE: 1152 case K_X2MOUSE: 1153 case K_X2DRAG: 1154 case K_X2RELEASE: 1155 ins_mouse(c); 1156 break; 1157 1158 case K_MOUSEDOWN: /* Default action for scroll wheel up: scroll up */ 1159 ins_mousescroll(MSCR_DOWN); 1160 break; 1161 1162 case K_MOUSEUP: /* Default action for scroll wheel down: scroll down */ 1163 ins_mousescroll(MSCR_UP); 1164 break; 1165 1166 case K_MOUSELEFT: /* Scroll wheel left */ 1167 ins_mousescroll(MSCR_LEFT); 1168 break; 1169 1170 case K_MOUSERIGHT: /* Scroll wheel right */ 1171 ins_mousescroll(MSCR_RIGHT); 1172 break; 1173 #endif 1174 #ifdef FEAT_GUI_TABLINE 1175 case K_TABLINE: 1176 case K_TABMENU: 1177 ins_tabline(c); 1178 break; 1179 #endif 1180 1181 case K_IGNORE: /* Something mapped to nothing */ 1182 break; 1183 1184 #ifdef FEAT_AUTOCMD 1185 case K_CURSORHOLD: /* Didn't type something for a while. */ 1186 apply_autocmds(EVENT_CURSORHOLDI, NULL, NULL, FALSE, curbuf); 1187 did_cursorhold = TRUE; 1188 break; 1189 #endif 1190 1191 #ifdef FEAT_GUI_W32 1192 /* On Win32 ignore <M-F4>, we get it when closing the window was 1193 * cancelled. */ 1194 case K_F4: 1195 if (mod_mask != MOD_MASK_ALT) 1196 goto normalchar; 1197 break; 1198 #endif 1199 1200 #ifdef FEAT_GUI 1201 case K_VER_SCROLLBAR: 1202 ins_scroll(); 1203 break; 1204 1205 case K_HOR_SCROLLBAR: 1206 ins_horscroll(); 1207 break; 1208 #endif 1209 1210 case K_HOME: /* <Home> */ 1211 case K_KHOME: 1212 case K_S_HOME: 1213 case K_C_HOME: 1214 ins_home(c); 1215 break; 1216 1217 case K_END: /* <End> */ 1218 case K_KEND: 1219 case K_S_END: 1220 case K_C_END: 1221 ins_end(c); 1222 break; 1223 1224 case K_LEFT: /* <Left> */ 1225 if (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL)) 1226 ins_s_left(); 1227 else 1228 ins_left(); 1229 break; 1230 1231 case K_S_LEFT: /* <S-Left> */ 1232 case K_C_LEFT: 1233 ins_s_left(); 1234 break; 1235 1236 case K_RIGHT: /* <Right> */ 1237 if (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL)) 1238 ins_s_right(); 1239 else 1240 ins_right(); 1241 break; 1242 1243 case K_S_RIGHT: /* <S-Right> */ 1244 case K_C_RIGHT: 1245 ins_s_right(); 1246 break; 1247 1248 case K_UP: /* <Up> */ 1249 #ifdef FEAT_INS_EXPAND 1250 if (pum_visible()) 1251 goto docomplete; 1252 #endif 1253 if (mod_mask & MOD_MASK_SHIFT) 1254 ins_pageup(); 1255 else 1256 ins_up(FALSE); 1257 break; 1258 1259 case K_S_UP: /* <S-Up> */ 1260 case K_PAGEUP: 1261 case K_KPAGEUP: 1262 #ifdef FEAT_INS_EXPAND 1263 if (pum_visible()) 1264 goto docomplete; 1265 #endif 1266 ins_pageup(); 1267 break; 1268 1269 case K_DOWN: /* <Down> */ 1270 #ifdef FEAT_INS_EXPAND 1271 if (pum_visible()) 1272 goto docomplete; 1273 #endif 1274 if (mod_mask & MOD_MASK_SHIFT) 1275 ins_pagedown(); 1276 else 1277 ins_down(FALSE); 1278 break; 1279 1280 case K_S_DOWN: /* <S-Down> */ 1281 case K_PAGEDOWN: 1282 case K_KPAGEDOWN: 1283 #ifdef FEAT_INS_EXPAND 1284 if (pum_visible()) 1285 goto docomplete; 1286 #endif 1287 ins_pagedown(); 1288 break; 1289 1290 #ifdef FEAT_DND 1291 case K_DROP: /* drag-n-drop event */ 1292 ins_drop(); 1293 break; 1294 #endif 1295 1296 case K_S_TAB: /* When not mapped, use like a normal TAB */ 1297 c = TAB; 1298 /* FALLTHROUGH */ 1299 1300 case TAB: /* TAB or Complete patterns along path */ 1301 #if defined(FEAT_INS_EXPAND) && defined(FEAT_FIND_ID) 1302 if (ctrl_x_mode == CTRL_X_PATH_PATTERNS) 1303 goto docomplete; 1304 #endif 1305 inserted_space = FALSE; 1306 if (ins_tab()) 1307 goto normalchar; /* insert TAB as a normal char */ 1308 auto_format(FALSE, TRUE); 1309 break; 1310 1311 case K_KENTER: /* <Enter> */ 1312 c = CAR; 1313 /* FALLTHROUGH */ 1314 case CAR: 1315 case NL: 1316 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX) 1317 /* In a quickfix window a <CR> jumps to the error under the 1318 * cursor. */ 1319 if (bt_quickfix(curbuf) && c == CAR) 1320 { 1321 if (curwin->w_llist_ref == NULL) /* quickfix window */ 1322 do_cmdline_cmd((char_u *)".cc"); 1323 else /* location list window */ 1324 do_cmdline_cmd((char_u *)".ll"); 1325 break; 1326 } 1327 #endif 1328 #ifdef FEAT_CMDWIN 1329 if (cmdwin_type != 0) 1330 { 1331 /* Execute the command in the cmdline window. */ 1332 cmdwin_result = CAR; 1333 goto doESCkey; 1334 } 1335 #endif 1336 if (ins_eol(c) && !p_im) 1337 goto doESCkey; /* out of memory */ 1338 auto_format(FALSE, FALSE); 1339 inserted_space = FALSE; 1340 break; 1341 1342 #if defined(FEAT_DIGRAPHS) || defined(FEAT_INS_EXPAND) 1343 case Ctrl_K: /* digraph or keyword completion */ 1344 # ifdef FEAT_INS_EXPAND 1345 if (ctrl_x_mode == CTRL_X_DICTIONARY) 1346 { 1347 if (has_compl_option(TRUE)) 1348 goto docomplete; 1349 break; 1350 } 1351 # endif 1352 # ifdef FEAT_DIGRAPHS 1353 c = ins_digraph(); 1354 if (c == NUL) 1355 break; 1356 # endif 1357 goto normalchar; 1358 #endif 1359 1360 #ifdef FEAT_INS_EXPAND 1361 case Ctrl_X: /* Enter CTRL-X mode */ 1362 ins_ctrl_x(); 1363 break; 1364 1365 case Ctrl_RSB: /* Tag name completion after ^X */ 1366 if (ctrl_x_mode != CTRL_X_TAGS) 1367 goto normalchar; 1368 goto docomplete; 1369 1370 case Ctrl_F: /* File name completion after ^X */ 1371 if (ctrl_x_mode != CTRL_X_FILES) 1372 goto normalchar; 1373 goto docomplete; 1374 1375 case 's': /* Spelling completion after ^X */ 1376 case Ctrl_S: 1377 if (ctrl_x_mode != CTRL_X_SPELL) 1378 goto normalchar; 1379 goto docomplete; 1380 #endif 1381 1382 case Ctrl_L: /* Whole line completion after ^X */ 1383 #ifdef FEAT_INS_EXPAND 1384 if (ctrl_x_mode != CTRL_X_WHOLE_LINE) 1385 #endif 1386 { 1387 /* CTRL-L with 'insertmode' set: Leave Insert mode */ 1388 if (p_im) 1389 { 1390 if (echeck_abbr(Ctrl_L + ABBR_OFF)) 1391 break; 1392 goto doESCkey; 1393 } 1394 goto normalchar; 1395 } 1396 #ifdef FEAT_INS_EXPAND 1397 /* FALLTHROUGH */ 1398 1399 case Ctrl_P: /* Do previous/next pattern completion */ 1400 case Ctrl_N: 1401 /* if 'complete' is empty then plain ^P is no longer special, 1402 * but it is under other ^X modes */ 1403 if (*curbuf->b_p_cpt == NUL 1404 && ctrl_x_mode != 0 1405 && !(compl_cont_status & CONT_LOCAL)) 1406 goto normalchar; 1407 1408 docomplete: 1409 compl_busy = TRUE; 1410 if (ins_complete(c) == FAIL) 1411 compl_cont_status = 0; 1412 compl_busy = FALSE; 1413 break; 1414 #endif /* FEAT_INS_EXPAND */ 1415 1416 case Ctrl_Y: /* copy from previous line or scroll down */ 1417 case Ctrl_E: /* copy from next line or scroll up */ 1418 c = ins_ctrl_ey(c); 1419 break; 1420 1421 default: 1422 #ifdef UNIX 1423 if (c == intr_char) /* special interrupt char */ 1424 goto do_intr; 1425 #endif 1426 1427 normalchar: 1428 /* 1429 * Insert a normal character. 1430 */ 1431 #ifdef FEAT_AUTOCMD 1432 if (!p_paste) 1433 { 1434 /* Trigger InsertCharPre. */ 1435 char_u *str = do_insert_char_pre(c); 1436 char_u *p; 1437 1438 if (str != NULL) 1439 { 1440 if (*str != NUL && stop_arrow() != FAIL) 1441 { 1442 /* Insert the new value of v:char literally. */ 1443 for (p = str; *p != NUL; mb_ptr_adv(p)) 1444 { 1445 c = PTR2CHAR(p); 1446 if (c == CAR || c == K_KENTER || c == NL) 1447 ins_eol(c); 1448 else 1449 ins_char(c); 1450 } 1451 AppendToRedobuffLit(str, -1); 1452 } 1453 vim_free(str); 1454 c = NUL; 1455 } 1456 1457 /* If the new value is already inserted or an empty string 1458 * then don't insert any character. */ 1459 if (c == NUL) 1460 break; 1461 } 1462 #endif 1463 #ifdef FEAT_SMARTINDENT 1464 /* Try to perform smart-indenting. */ 1465 ins_try_si(c); 1466 #endif 1467 1468 if (c == ' ') 1469 { 1470 inserted_space = TRUE; 1471 #ifdef FEAT_CINDENT 1472 if (inindent(0)) 1473 can_cindent = FALSE; 1474 #endif 1475 if (Insstart_blank_vcol == MAXCOL 1476 && curwin->w_cursor.lnum == Insstart.lnum) 1477 Insstart_blank_vcol = get_nolist_virtcol(); 1478 } 1479 1480 /* Insert a normal character and check for abbreviations on a 1481 * special character. Let CTRL-] expand abbreviations without 1482 * inserting it. */ 1483 if (vim_iswordc(c) || (!echeck_abbr( 1484 #ifdef FEAT_MBYTE 1485 /* Add ABBR_OFF for characters above 0x100, this is 1486 * what check_abbr() expects. */ 1487 (has_mbyte && c >= 0x100) ? (c + ABBR_OFF) : 1488 #endif 1489 c) && c != Ctrl_RSB)) 1490 { 1491 insert_special(c, FALSE, FALSE); 1492 #ifdef FEAT_RIGHTLEFT 1493 revins_legal++; 1494 revins_chars++; 1495 #endif 1496 } 1497 1498 auto_format(FALSE, TRUE); 1499 1500 #ifdef FEAT_FOLDING 1501 /* When inserting a character the cursor line must never be in a 1502 * closed fold. */ 1503 foldOpenCursor(); 1504 #endif 1505 break; 1506 } /* end of switch (c) */ 1507 1508 #ifdef FEAT_AUTOCMD 1509 /* If typed something may trigger CursorHoldI again. */ 1510 if (c != K_CURSORHOLD) 1511 did_cursorhold = FALSE; 1512 #endif 1513 1514 /* If the cursor was moved we didn't just insert a space */ 1515 if (arrow_used) 1516 inserted_space = FALSE; 1517 1518 #ifdef FEAT_CINDENT 1519 if (can_cindent && cindent_on() 1520 # ifdef FEAT_INS_EXPAND 1521 && ctrl_x_mode == 0 1522 # endif 1523 ) 1524 { 1525 force_cindent: 1526 /* 1527 * Indent now if a key was typed that is in 'cinkeys'. 1528 */ 1529 if (in_cinkeys(c, ' ', line_is_white)) 1530 { 1531 if (stop_arrow() == OK) 1532 /* re-indent the current line */ 1533 do_c_expr_indent(); 1534 } 1535 } 1536 #endif /* FEAT_CINDENT */ 1537 1538 } /* for (;;) */ 1539 /* NOTREACHED */ 1540 } 1541 1542 /* 1543 * Redraw for Insert mode. 1544 * This is postponed until getting the next character to make '$' in the 'cpo' 1545 * option work correctly. 1546 * Only redraw when there are no characters available. This speeds up 1547 * inserting sequences of characters (e.g., for CTRL-R). 1548 */ 1549 static void 1550 ins_redraw(ready) 1551 int ready UNUSED; /* not busy with something */ 1552 { 1553 #ifdef FEAT_CONCEAL 1554 linenr_T conceal_old_cursor_line = 0; 1555 linenr_T conceal_new_cursor_line = 0; 1556 int conceal_update_lines = FALSE; 1557 #endif 1558 1559 if (!char_avail()) 1560 { 1561 #if defined(FEAT_AUTOCMD) || defined(FEAT_CONCEAL) 1562 /* Trigger CursorMoved if the cursor moved. Not when the popup menu is 1563 * visible, the command might delete it. */ 1564 if (ready && ( 1565 # ifdef FEAT_AUTOCMD 1566 has_cursormovedI() 1567 # endif 1568 # if defined(FEAT_AUTOCMD) && defined(FEAT_CONCEAL) 1569 || 1570 # endif 1571 # ifdef FEAT_CONCEAL 1572 curwin->w_p_cole > 0 1573 # endif 1574 ) 1575 && !equalpos(last_cursormoved, curwin->w_cursor) 1576 # ifdef FEAT_INS_EXPAND 1577 && !pum_visible() 1578 # endif 1579 ) 1580 { 1581 # ifdef FEAT_SYN_HL 1582 /* Need to update the screen first, to make sure syntax 1583 * highlighting is correct after making a change (e.g., inserting 1584 * a "(". The autocommand may also require a redraw, so it's done 1585 * again below, unfortunately. */ 1586 if (syntax_present(curwin) && must_redraw) 1587 update_screen(0); 1588 # endif 1589 # ifdef FEAT_AUTOCMD 1590 if (has_cursormovedI()) 1591 apply_autocmds(EVENT_CURSORMOVEDI, NULL, NULL, FALSE, curbuf); 1592 # endif 1593 # ifdef FEAT_CONCEAL 1594 if (curwin->w_p_cole > 0) 1595 { 1596 conceal_old_cursor_line = last_cursormoved.lnum; 1597 conceal_new_cursor_line = curwin->w_cursor.lnum; 1598 conceal_update_lines = TRUE; 1599 } 1600 # endif 1601 last_cursormoved = curwin->w_cursor; 1602 } 1603 #endif 1604 #ifdef FEAT_AUTOCMD 1605 /* Trigger TextChangedI if b_changedtick differs. */ 1606 if (!ready && has_textchangedI() 1607 && last_changedtick != curbuf->b_changedtick 1608 # ifdef FEAT_INS_EXPAND 1609 && !pum_visible() 1610 # endif 1611 ) 1612 { 1613 if (last_changedtick_buf == curbuf) 1614 apply_autocmds(EVENT_TEXTCHANGEDI, NULL, NULL, FALSE, curbuf); 1615 last_changedtick_buf = curbuf; 1616 last_changedtick = curbuf->b_changedtick; 1617 } 1618 #endif 1619 if (must_redraw) 1620 update_screen(0); 1621 else if (clear_cmdline || redraw_cmdline) 1622 showmode(); /* clear cmdline and show mode */ 1623 # if defined(FEAT_CONCEAL) 1624 if ((conceal_update_lines 1625 && (conceal_old_cursor_line != conceal_new_cursor_line 1626 || conceal_cursor_line(curwin))) 1627 || need_cursor_line_redraw) 1628 { 1629 if (conceal_old_cursor_line != conceal_new_cursor_line) 1630 update_single_line(curwin, conceal_old_cursor_line); 1631 update_single_line(curwin, conceal_new_cursor_line == 0 1632 ? curwin->w_cursor.lnum : conceal_new_cursor_line); 1633 curwin->w_valid &= ~VALID_CROW; 1634 } 1635 # endif 1636 showruler(FALSE); 1637 setcursor(); 1638 emsg_on_display = FALSE; /* may remove error message now */ 1639 } 1640 } 1641 1642 /* 1643 * Handle a CTRL-V or CTRL-Q typed in Insert mode. 1644 */ 1645 static void 1646 ins_ctrl_v() 1647 { 1648 int c; 1649 int did_putchar = FALSE; 1650 1651 /* may need to redraw when no more chars available now */ 1652 ins_redraw(FALSE); 1653 1654 if (redrawing() && !char_avail()) 1655 { 1656 edit_putchar('^', TRUE); 1657 did_putchar = TRUE; 1658 } 1659 AppendToRedobuff((char_u *)CTRL_V_STR); /* CTRL-V */ 1660 1661 #ifdef FEAT_CMDL_INFO 1662 add_to_showcmd_c(Ctrl_V); 1663 #endif 1664 1665 c = get_literal(); 1666 if (did_putchar) 1667 /* when the line fits in 'columns' the '^' is at the start of the next 1668 * line and will not removed by the redraw */ 1669 edit_unputchar(); 1670 #ifdef FEAT_CMDL_INFO 1671 clear_showcmd(); 1672 #endif 1673 insert_special(c, FALSE, TRUE); 1674 #ifdef FEAT_RIGHTLEFT 1675 revins_chars++; 1676 revins_legal++; 1677 #endif 1678 } 1679 1680 /* 1681 * Put a character directly onto the screen. It's not stored in a buffer. 1682 * Used while handling CTRL-K, CTRL-V, etc. in Insert mode. 1683 */ 1684 static int pc_status; 1685 #define PC_STATUS_UNSET 0 /* pc_bytes was not set */ 1686 #define PC_STATUS_RIGHT 1 /* right halve of double-wide char */ 1687 #define PC_STATUS_LEFT 2 /* left halve of double-wide char */ 1688 #define PC_STATUS_SET 3 /* pc_bytes was filled */ 1689 static char_u pc_bytes[MB_MAXBYTES + 1]; /* saved bytes */ 1690 static int pc_attr; 1691 static int pc_row; 1692 static int pc_col; 1693 1694 void 1695 edit_putchar(c, highlight) 1696 int c; 1697 int highlight; 1698 { 1699 int attr; 1700 1701 if (ScreenLines != NULL) 1702 { 1703 update_topline(); /* just in case w_topline isn't valid */ 1704 validate_cursor(); 1705 if (highlight) 1706 attr = hl_attr(HLF_8); 1707 else 1708 attr = 0; 1709 pc_row = W_WINROW(curwin) + curwin->w_wrow; 1710 pc_col = W_WINCOL(curwin); 1711 #if defined(FEAT_RIGHTLEFT) || defined(FEAT_MBYTE) 1712 pc_status = PC_STATUS_UNSET; 1713 #endif 1714 #ifdef FEAT_RIGHTLEFT 1715 if (curwin->w_p_rl) 1716 { 1717 pc_col += W_WIDTH(curwin) - 1 - curwin->w_wcol; 1718 # ifdef FEAT_MBYTE 1719 if (has_mbyte) 1720 { 1721 int fix_col = mb_fix_col(pc_col, pc_row); 1722 1723 if (fix_col != pc_col) 1724 { 1725 screen_putchar(' ', pc_row, fix_col, attr); 1726 --curwin->w_wcol; 1727 pc_status = PC_STATUS_RIGHT; 1728 } 1729 } 1730 # endif 1731 } 1732 else 1733 #endif 1734 { 1735 pc_col += curwin->w_wcol; 1736 #ifdef FEAT_MBYTE 1737 if (mb_lefthalve(pc_row, pc_col)) 1738 pc_status = PC_STATUS_LEFT; 1739 #endif 1740 } 1741 1742 /* save the character to be able to put it back */ 1743 #if defined(FEAT_RIGHTLEFT) || defined(FEAT_MBYTE) 1744 if (pc_status == PC_STATUS_UNSET) 1745 #endif 1746 { 1747 screen_getbytes(pc_row, pc_col, pc_bytes, &pc_attr); 1748 pc_status = PC_STATUS_SET; 1749 } 1750 screen_putchar(c, pc_row, pc_col, attr); 1751 } 1752 } 1753 1754 /* 1755 * Undo the previous edit_putchar(). 1756 */ 1757 void 1758 edit_unputchar() 1759 { 1760 if (pc_status != PC_STATUS_UNSET && pc_row >= msg_scrolled) 1761 { 1762 #if defined(FEAT_MBYTE) 1763 if (pc_status == PC_STATUS_RIGHT) 1764 ++curwin->w_wcol; 1765 if (pc_status == PC_STATUS_RIGHT || pc_status == PC_STATUS_LEFT) 1766 redrawWinline(curwin->w_cursor.lnum, FALSE); 1767 else 1768 #endif 1769 screen_puts(pc_bytes, pc_row - msg_scrolled, pc_col, pc_attr); 1770 } 1771 } 1772 1773 /* 1774 * Called when p_dollar is set: display a '$' at the end of the changed text 1775 * Only works when cursor is in the line that changes. 1776 */ 1777 void 1778 display_dollar(col) 1779 colnr_T col; 1780 { 1781 colnr_T save_col; 1782 1783 if (!redrawing()) 1784 return; 1785 1786 cursor_off(); 1787 save_col = curwin->w_cursor.col; 1788 curwin->w_cursor.col = col; 1789 #ifdef FEAT_MBYTE 1790 if (has_mbyte) 1791 { 1792 char_u *p; 1793 1794 /* If on the last byte of a multi-byte move to the first byte. */ 1795 p = ml_get_curline(); 1796 curwin->w_cursor.col -= (*mb_head_off)(p, p + col); 1797 } 1798 #endif 1799 curs_columns(FALSE); /* recompute w_wrow and w_wcol */ 1800 if (curwin->w_wcol < W_WIDTH(curwin)) 1801 { 1802 edit_putchar('$', FALSE); 1803 dollar_vcol = curwin->w_virtcol; 1804 } 1805 curwin->w_cursor.col = save_col; 1806 } 1807 1808 /* 1809 * Call this function before moving the cursor from the normal insert position 1810 * in insert mode. 1811 */ 1812 static void 1813 undisplay_dollar() 1814 { 1815 if (dollar_vcol >= 0) 1816 { 1817 dollar_vcol = -1; 1818 redrawWinline(curwin->w_cursor.lnum, FALSE); 1819 } 1820 } 1821 1822 /* 1823 * Insert an indent (for <Tab> or CTRL-T) or delete an indent (for CTRL-D). 1824 * Keep the cursor on the same character. 1825 * type == INDENT_INC increase indent (for CTRL-T or <Tab>) 1826 * type == INDENT_DEC decrease indent (for CTRL-D) 1827 * type == INDENT_SET set indent to "amount" 1828 * if round is TRUE, round the indent to 'shiftwidth' (only with _INC and _Dec). 1829 */ 1830 void 1831 change_indent(type, amount, round, replaced, call_changed_bytes) 1832 int type; 1833 int amount; 1834 int round; 1835 int replaced; /* replaced character, put on replace stack */ 1836 int call_changed_bytes; /* call changed_bytes() */ 1837 { 1838 int vcol; 1839 int last_vcol; 1840 int insstart_less; /* reduction for Insstart.col */ 1841 int new_cursor_col; 1842 int i; 1843 char_u *ptr; 1844 int save_p_list; 1845 int start_col; 1846 colnr_T vc; 1847 #ifdef FEAT_VREPLACE 1848 colnr_T orig_col = 0; /* init for GCC */ 1849 char_u *new_line, *orig_line = NULL; /* init for GCC */ 1850 1851 /* VREPLACE mode needs to know what the line was like before changing */ 1852 if (State & VREPLACE_FLAG) 1853 { 1854 orig_line = vim_strsave(ml_get_curline()); /* Deal with NULL below */ 1855 orig_col = curwin->w_cursor.col; 1856 } 1857 #endif 1858 1859 /* for the following tricks we don't want list mode */ 1860 save_p_list = curwin->w_p_list; 1861 curwin->w_p_list = FALSE; 1862 vc = getvcol_nolist(&curwin->w_cursor); 1863 vcol = vc; 1864 1865 /* 1866 * For Replace mode we need to fix the replace stack later, which is only 1867 * possible when the cursor is in the indent. Remember the number of 1868 * characters before the cursor if it's possible. 1869 */ 1870 start_col = curwin->w_cursor.col; 1871 1872 /* determine offset from first non-blank */ 1873 new_cursor_col = curwin->w_cursor.col; 1874 beginline(BL_WHITE); 1875 new_cursor_col -= curwin->w_cursor.col; 1876 1877 insstart_less = curwin->w_cursor.col; 1878 1879 /* 1880 * If the cursor is in the indent, compute how many screen columns the 1881 * cursor is to the left of the first non-blank. 1882 */ 1883 if (new_cursor_col < 0) 1884 vcol = get_indent() - vcol; 1885 1886 if (new_cursor_col > 0) /* can't fix replace stack */ 1887 start_col = -1; 1888 1889 /* 1890 * Set the new indent. The cursor will be put on the first non-blank. 1891 */ 1892 if (type == INDENT_SET) 1893 (void)set_indent(amount, call_changed_bytes ? SIN_CHANGED : 0); 1894 else 1895 { 1896 #ifdef FEAT_VREPLACE 1897 int save_State = State; 1898 1899 /* Avoid being called recursively. */ 1900 if (State & VREPLACE_FLAG) 1901 State = INSERT; 1902 #endif 1903 shift_line(type == INDENT_DEC, round, 1, call_changed_bytes); 1904 #ifdef FEAT_VREPLACE 1905 State = save_State; 1906 #endif 1907 } 1908 insstart_less -= curwin->w_cursor.col; 1909 1910 /* 1911 * Try to put cursor on same character. 1912 * If the cursor is at or after the first non-blank in the line, 1913 * compute the cursor column relative to the column of the first 1914 * non-blank character. 1915 * If we are not in insert mode, leave the cursor on the first non-blank. 1916 * If the cursor is before the first non-blank, position it relative 1917 * to the first non-blank, counted in screen columns. 1918 */ 1919 if (new_cursor_col >= 0) 1920 { 1921 /* 1922 * When changing the indent while the cursor is touching it, reset 1923 * Insstart_col to 0. 1924 */ 1925 if (new_cursor_col == 0) 1926 insstart_less = MAXCOL; 1927 new_cursor_col += curwin->w_cursor.col; 1928 } 1929 else if (!(State & INSERT)) 1930 new_cursor_col = curwin->w_cursor.col; 1931 else 1932 { 1933 /* 1934 * Compute the screen column where the cursor should be. 1935 */ 1936 vcol = get_indent() - vcol; 1937 curwin->w_virtcol = (colnr_T)((vcol < 0) ? 0 : vcol); 1938 1939 /* 1940 * Advance the cursor until we reach the right screen column. 1941 */ 1942 vcol = last_vcol = 0; 1943 new_cursor_col = -1; 1944 ptr = ml_get_curline(); 1945 while (vcol <= (int)curwin->w_virtcol) 1946 { 1947 last_vcol = vcol; 1948 #ifdef FEAT_MBYTE 1949 if (has_mbyte && new_cursor_col >= 0) 1950 new_cursor_col += (*mb_ptr2len)(ptr + new_cursor_col); 1951 else 1952 #endif 1953 ++new_cursor_col; 1954 vcol += lbr_chartabsize(ptr + new_cursor_col, (colnr_T)vcol); 1955 } 1956 vcol = last_vcol; 1957 1958 /* 1959 * May need to insert spaces to be able to position the cursor on 1960 * the right screen column. 1961 */ 1962 if (vcol != (int)curwin->w_virtcol) 1963 { 1964 curwin->w_cursor.col = (colnr_T)new_cursor_col; 1965 i = (int)curwin->w_virtcol - vcol; 1966 ptr = alloc((unsigned)(i + 1)); 1967 if (ptr != NULL) 1968 { 1969 new_cursor_col += i; 1970 ptr[i] = NUL; 1971 while (--i >= 0) 1972 ptr[i] = ' '; 1973 ins_str(ptr); 1974 vim_free(ptr); 1975 } 1976 } 1977 1978 /* 1979 * When changing the indent while the cursor is in it, reset 1980 * Insstart_col to 0. 1981 */ 1982 insstart_less = MAXCOL; 1983 } 1984 1985 curwin->w_p_list = save_p_list; 1986 1987 if (new_cursor_col <= 0) 1988 curwin->w_cursor.col = 0; 1989 else 1990 curwin->w_cursor.col = (colnr_T)new_cursor_col; 1991 curwin->w_set_curswant = TRUE; 1992 changed_cline_bef_curs(); 1993 1994 /* 1995 * May have to adjust the start of the insert. 1996 */ 1997 if (State & INSERT) 1998 { 1999 if (curwin->w_cursor.lnum == Insstart.lnum && Insstart.col != 0) 2000 { 2001 if ((int)Insstart.col <= insstart_less) 2002 Insstart.col = 0; 2003 else 2004 Insstart.col -= insstart_less; 2005 } 2006 if ((int)ai_col <= insstart_less) 2007 ai_col = 0; 2008 else 2009 ai_col -= insstart_less; 2010 } 2011 2012 /* 2013 * For REPLACE mode, may have to fix the replace stack, if it's possible. 2014 * If the number of characters before the cursor decreased, need to pop a 2015 * few characters from the replace stack. 2016 * If the number of characters before the cursor increased, need to push a 2017 * few NULs onto the replace stack. 2018 */ 2019 if (REPLACE_NORMAL(State) && start_col >= 0) 2020 { 2021 while (start_col > (int)curwin->w_cursor.col) 2022 { 2023 replace_join(0); /* remove a NUL from the replace stack */ 2024 --start_col; 2025 } 2026 while (start_col < (int)curwin->w_cursor.col || replaced) 2027 { 2028 replace_push(NUL); 2029 if (replaced) 2030 { 2031 replace_push(replaced); 2032 replaced = NUL; 2033 } 2034 ++start_col; 2035 } 2036 } 2037 2038 #ifdef FEAT_VREPLACE 2039 /* 2040 * For VREPLACE mode, we also have to fix the replace stack. In this case 2041 * it is always possible because we backspace over the whole line and then 2042 * put it back again the way we wanted it. 2043 */ 2044 if (State & VREPLACE_FLAG) 2045 { 2046 /* If orig_line didn't allocate, just return. At least we did the job, 2047 * even if you can't backspace. */ 2048 if (orig_line == NULL) 2049 return; 2050 2051 /* Save new line */ 2052 new_line = vim_strsave(ml_get_curline()); 2053 if (new_line == NULL) 2054 return; 2055 2056 /* We only put back the new line up to the cursor */ 2057 new_line[curwin->w_cursor.col] = NUL; 2058 2059 /* Put back original line */ 2060 ml_replace(curwin->w_cursor.lnum, orig_line, FALSE); 2061 curwin->w_cursor.col = orig_col; 2062 2063 /* Backspace from cursor to start of line */ 2064 backspace_until_column(0); 2065 2066 /* Insert new stuff into line again */ 2067 ins_bytes(new_line); 2068 2069 vim_free(new_line); 2070 } 2071 #endif 2072 } 2073 2074 /* 2075 * Truncate the space at the end of a line. This is to be used only in an 2076 * insert mode. It handles fixing the replace stack for REPLACE and VREPLACE 2077 * modes. 2078 */ 2079 void 2080 truncate_spaces(line) 2081 char_u *line; 2082 { 2083 int i; 2084 2085 /* find start of trailing white space */ 2086 for (i = (int)STRLEN(line) - 1; i >= 0 && vim_iswhite(line[i]); i--) 2087 { 2088 if (State & REPLACE_FLAG) 2089 replace_join(0); /* remove a NUL from the replace stack */ 2090 } 2091 line[i + 1] = NUL; 2092 } 2093 2094 #if defined(FEAT_VREPLACE) || defined(FEAT_INS_EXPAND) \ 2095 || defined(FEAT_COMMENTS) || defined(PROTO) 2096 /* 2097 * Backspace the cursor until the given column. Handles REPLACE and VREPLACE 2098 * modes correctly. May also be used when not in insert mode at all. 2099 * Will attempt not to go before "col" even when there is a composing 2100 * character. 2101 */ 2102 void 2103 backspace_until_column(col) 2104 int col; 2105 { 2106 while ((int)curwin->w_cursor.col > col) 2107 { 2108 curwin->w_cursor.col--; 2109 if (State & REPLACE_FLAG) 2110 replace_do_bs(col); 2111 else if (!del_char_after_col(col)) 2112 break; 2113 } 2114 } 2115 #endif 2116 2117 /* 2118 * Like del_char(), but make sure not to go before column "limit_col". 2119 * Only matters when there are composing characters. 2120 * Return TRUE when something was deleted. 2121 */ 2122 static int 2123 del_char_after_col(limit_col) 2124 int limit_col UNUSED; 2125 { 2126 #ifdef FEAT_MBYTE 2127 if (enc_utf8 && limit_col >= 0) 2128 { 2129 colnr_T ecol = curwin->w_cursor.col + 1; 2130 2131 /* Make sure the cursor is at the start of a character, but 2132 * skip forward again when going too far back because of a 2133 * composing character. */ 2134 mb_adjust_cursor(); 2135 while (curwin->w_cursor.col < (colnr_T)limit_col) 2136 { 2137 int l = utf_ptr2len(ml_get_cursor()); 2138 2139 if (l == 0) /* end of line */ 2140 break; 2141 curwin->w_cursor.col += l; 2142 } 2143 if (*ml_get_cursor() == NUL || curwin->w_cursor.col == ecol) 2144 return FALSE; 2145 del_bytes((long)((int)ecol - curwin->w_cursor.col), FALSE, TRUE); 2146 } 2147 else 2148 #endif 2149 (void)del_char(FALSE); 2150 return TRUE; 2151 } 2152 2153 #if defined(FEAT_INS_EXPAND) || defined(PROTO) 2154 /* 2155 * CTRL-X pressed in Insert mode. 2156 */ 2157 static void 2158 ins_ctrl_x() 2159 { 2160 /* CTRL-X after CTRL-X CTRL-V doesn't do anything, so that CTRL-X 2161 * CTRL-V works like CTRL-N */ 2162 if (ctrl_x_mode != CTRL_X_CMDLINE) 2163 { 2164 /* if the next ^X<> won't ADD nothing, then reset 2165 * compl_cont_status */ 2166 if (compl_cont_status & CONT_N_ADDS) 2167 compl_cont_status |= CONT_INTRPT; 2168 else 2169 compl_cont_status = 0; 2170 /* We're not sure which CTRL-X mode it will be yet */ 2171 ctrl_x_mode = CTRL_X_NOT_DEFINED_YET; 2172 edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode)); 2173 edit_submode_pre = NULL; 2174 showmode(); 2175 } 2176 } 2177 2178 /* 2179 * Return TRUE if the 'dict' or 'tsr' option can be used. 2180 */ 2181 static int 2182 has_compl_option(dict_opt) 2183 int dict_opt; 2184 { 2185 if (dict_opt ? (*curbuf->b_p_dict == NUL && *p_dict == NUL 2186 # ifdef FEAT_SPELL 2187 && !curwin->w_p_spell 2188 # endif 2189 ) 2190 : (*curbuf->b_p_tsr == NUL && *p_tsr == NUL)) 2191 { 2192 ctrl_x_mode = 0; 2193 edit_submode = NULL; 2194 msg_attr(dict_opt ? (char_u *)_("'dictionary' option is empty") 2195 : (char_u *)_("'thesaurus' option is empty"), 2196 hl_attr(HLF_E)); 2197 if (emsg_silent == 0) 2198 { 2199 vim_beep(); 2200 setcursor(); 2201 out_flush(); 2202 ui_delay(2000L, FALSE); 2203 } 2204 return FALSE; 2205 } 2206 return TRUE; 2207 } 2208 2209 /* 2210 * Is the character 'c' a valid key to go to or keep us in CTRL-X mode? 2211 * This depends on the current mode. 2212 */ 2213 int 2214 vim_is_ctrl_x_key(c) 2215 int c; 2216 { 2217 /* Always allow ^R - let it's results then be checked */ 2218 if (c == Ctrl_R) 2219 return TRUE; 2220 2221 /* Accept <PageUp> and <PageDown> if the popup menu is visible. */ 2222 if (ins_compl_pum_key(c)) 2223 return TRUE; 2224 2225 switch (ctrl_x_mode) 2226 { 2227 case 0: /* Not in any CTRL-X mode */ 2228 return (c == Ctrl_N || c == Ctrl_P || c == Ctrl_X); 2229 case CTRL_X_NOT_DEFINED_YET: 2230 return ( c == Ctrl_X || c == Ctrl_Y || c == Ctrl_E 2231 || c == Ctrl_L || c == Ctrl_F || c == Ctrl_RSB 2232 || c == Ctrl_I || c == Ctrl_D || c == Ctrl_P 2233 || c == Ctrl_N || c == Ctrl_T || c == Ctrl_V 2234 || c == Ctrl_Q || c == Ctrl_U || c == Ctrl_O 2235 || c == Ctrl_S || c == Ctrl_K || c == 's'); 2236 case CTRL_X_SCROLL: 2237 return (c == Ctrl_Y || c == Ctrl_E); 2238 case CTRL_X_WHOLE_LINE: 2239 return (c == Ctrl_L || c == Ctrl_P || c == Ctrl_N); 2240 case CTRL_X_FILES: 2241 return (c == Ctrl_F || c == Ctrl_P || c == Ctrl_N); 2242 case CTRL_X_DICTIONARY: 2243 return (c == Ctrl_K || c == Ctrl_P || c == Ctrl_N); 2244 case CTRL_X_THESAURUS: 2245 return (c == Ctrl_T || c == Ctrl_P || c == Ctrl_N); 2246 case CTRL_X_TAGS: 2247 return (c == Ctrl_RSB || c == Ctrl_P || c == Ctrl_N); 2248 #ifdef FEAT_FIND_ID 2249 case CTRL_X_PATH_PATTERNS: 2250 return (c == Ctrl_P || c == Ctrl_N); 2251 case CTRL_X_PATH_DEFINES: 2252 return (c == Ctrl_D || c == Ctrl_P || c == Ctrl_N); 2253 #endif 2254 case CTRL_X_CMDLINE: 2255 return (c == Ctrl_V || c == Ctrl_Q || c == Ctrl_P || c == Ctrl_N 2256 || c == Ctrl_X); 2257 #ifdef FEAT_COMPL_FUNC 2258 case CTRL_X_FUNCTION: 2259 return (c == Ctrl_U || c == Ctrl_P || c == Ctrl_N); 2260 case CTRL_X_OMNI: 2261 return (c == Ctrl_O || c == Ctrl_P || c == Ctrl_N); 2262 #endif 2263 case CTRL_X_SPELL: 2264 return (c == Ctrl_S || c == Ctrl_P || c == Ctrl_N); 2265 } 2266 EMSG(_(e_internal)); 2267 return FALSE; 2268 } 2269 2270 /* 2271 * Return TRUE when character "c" is part of the item currently being 2272 * completed. Used to decide whether to abandon complete mode when the menu 2273 * is visible. 2274 */ 2275 static int 2276 ins_compl_accept_char(c) 2277 int c; 2278 { 2279 if (ctrl_x_mode & CTRL_X_WANT_IDENT) 2280 /* When expanding an identifier only accept identifier chars. */ 2281 return vim_isIDc(c); 2282 2283 switch (ctrl_x_mode) 2284 { 2285 case CTRL_X_FILES: 2286 /* When expanding file name only accept file name chars. But not 2287 * path separators, so that "proto/<Tab>" expands files in 2288 * "proto", not "proto/" as a whole */ 2289 return vim_isfilec(c) && !vim_ispathsep(c); 2290 2291 case CTRL_X_CMDLINE: 2292 case CTRL_X_OMNI: 2293 /* Command line and Omni completion can work with just about any 2294 * printable character, but do stop at white space. */ 2295 return vim_isprintc(c) && !vim_iswhite(c); 2296 2297 case CTRL_X_WHOLE_LINE: 2298 /* For while line completion a space can be part of the line. */ 2299 return vim_isprintc(c); 2300 } 2301 return vim_iswordc(c); 2302 } 2303 2304 /* 2305 * This is like ins_compl_add(), but if 'ic' and 'inf' are set, then the 2306 * case of the originally typed text is used, and the case of the completed 2307 * text is inferred, ie this tries to work out what case you probably wanted 2308 * the rest of the word to be in -- webb 2309 */ 2310 int 2311 ins_compl_add_infercase(str, len, icase, fname, dir, flags) 2312 char_u *str; 2313 int len; 2314 int icase; 2315 char_u *fname; 2316 int dir; 2317 int flags; 2318 { 2319 char_u *p; 2320 int i, c; 2321 int actual_len; /* Take multi-byte characters */ 2322 int actual_compl_length; /* into account. */ 2323 int min_len; 2324 int *wca; /* Wide character array. */ 2325 int has_lower = FALSE; 2326 int was_letter = FALSE; 2327 2328 if (p_ic && curbuf->b_p_inf && len > 0) 2329 { 2330 /* Infer case of completed part. */ 2331 2332 /* Find actual length of completion. */ 2333 #ifdef FEAT_MBYTE 2334 if (has_mbyte) 2335 { 2336 p = str; 2337 actual_len = 0; 2338 while (*p != NUL) 2339 { 2340 mb_ptr_adv(p); 2341 ++actual_len; 2342 } 2343 } 2344 else 2345 #endif 2346 actual_len = len; 2347 2348 /* Find actual length of original text. */ 2349 #ifdef FEAT_MBYTE 2350 if (has_mbyte) 2351 { 2352 p = compl_orig_text; 2353 actual_compl_length = 0; 2354 while (*p != NUL) 2355 { 2356 mb_ptr_adv(p); 2357 ++actual_compl_length; 2358 } 2359 } 2360 else 2361 #endif 2362 actual_compl_length = compl_length; 2363 2364 /* "actual_len" may be smaller than "actual_compl_length" when using 2365 * thesaurus, only use the minimum when comparing. */ 2366 min_len = actual_len < actual_compl_length 2367 ? actual_len : actual_compl_length; 2368 2369 /* Allocate wide character array for the completion and fill it. */ 2370 wca = (int *)alloc((unsigned)(actual_len * sizeof(int))); 2371 if (wca != NULL) 2372 { 2373 p = str; 2374 for (i = 0; i < actual_len; ++i) 2375 #ifdef FEAT_MBYTE 2376 if (has_mbyte) 2377 wca[i] = mb_ptr2char_adv(&p); 2378 else 2379 #endif 2380 wca[i] = *(p++); 2381 2382 /* Rule 1: Were any chars converted to lower? */ 2383 p = compl_orig_text; 2384 for (i = 0; i < min_len; ++i) 2385 { 2386 #ifdef FEAT_MBYTE 2387 if (has_mbyte) 2388 c = mb_ptr2char_adv(&p); 2389 else 2390 #endif 2391 c = *(p++); 2392 if (MB_ISLOWER(c)) 2393 { 2394 has_lower = TRUE; 2395 if (MB_ISUPPER(wca[i])) 2396 { 2397 /* Rule 1 is satisfied. */ 2398 for (i = actual_compl_length; i < actual_len; ++i) 2399 wca[i] = MB_TOLOWER(wca[i]); 2400 break; 2401 } 2402 } 2403 } 2404 2405 /* 2406 * Rule 2: No lower case, 2nd consecutive letter converted to 2407 * upper case. 2408 */ 2409 if (!has_lower) 2410 { 2411 p = compl_orig_text; 2412 for (i = 0; i < min_len; ++i) 2413 { 2414 #ifdef FEAT_MBYTE 2415 if (has_mbyte) 2416 c = mb_ptr2char_adv(&p); 2417 else 2418 #endif 2419 c = *(p++); 2420 if (was_letter && MB_ISUPPER(c) && MB_ISLOWER(wca[i])) 2421 { 2422 /* Rule 2 is satisfied. */ 2423 for (i = actual_compl_length; i < actual_len; ++i) 2424 wca[i] = MB_TOUPPER(wca[i]); 2425 break; 2426 } 2427 was_letter = MB_ISLOWER(c) || MB_ISUPPER(c); 2428 } 2429 } 2430 2431 /* Copy the original case of the part we typed. */ 2432 p = compl_orig_text; 2433 for (i = 0; i < min_len; ++i) 2434 { 2435 #ifdef FEAT_MBYTE 2436 if (has_mbyte) 2437 c = mb_ptr2char_adv(&p); 2438 else 2439 #endif 2440 c = *(p++); 2441 if (MB_ISLOWER(c)) 2442 wca[i] = MB_TOLOWER(wca[i]); 2443 else if (MB_ISUPPER(c)) 2444 wca[i] = MB_TOUPPER(wca[i]); 2445 } 2446 2447 /* 2448 * Generate encoding specific output from wide character array. 2449 * Multi-byte characters can occupy up to five bytes more than 2450 * ASCII characters, and we also need one byte for NUL, so stay 2451 * six bytes away from the edge of IObuff. 2452 */ 2453 p = IObuff; 2454 i = 0; 2455 while (i < actual_len && (p - IObuff + 6) < IOSIZE) 2456 #ifdef FEAT_MBYTE 2457 if (has_mbyte) 2458 p += (*mb_char2bytes)(wca[i++], p); 2459 else 2460 #endif 2461 *(p++) = wca[i++]; 2462 *p = NUL; 2463 2464 vim_free(wca); 2465 } 2466 2467 return ins_compl_add(IObuff, len, icase, fname, NULL, dir, 2468 flags, FALSE); 2469 } 2470 return ins_compl_add(str, len, icase, fname, NULL, dir, flags, FALSE); 2471 } 2472 2473 /* 2474 * Add a match to the list of matches. 2475 * If the given string is already in the list of completions, then return 2476 * NOTDONE, otherwise add it to the list and return OK. If there is an error, 2477 * maybe because alloc() returns NULL, then FAIL is returned. 2478 */ 2479 static int 2480 ins_compl_add(str, len, icase, fname, cptext, cdir, flags, adup) 2481 char_u *str; 2482 int len; 2483 int icase; 2484 char_u *fname; 2485 char_u **cptext; /* extra text for popup menu or NULL */ 2486 int cdir; 2487 int flags; 2488 int adup; /* accept duplicate match */ 2489 { 2490 compl_T *match; 2491 int dir = (cdir == 0 ? compl_direction : cdir); 2492 2493 ui_breakcheck(); 2494 if (got_int) 2495 return FAIL; 2496 if (len < 0) 2497 len = (int)STRLEN(str); 2498 2499 /* 2500 * If the same match is already present, don't add it. 2501 */ 2502 if (compl_first_match != NULL && !adup) 2503 { 2504 match = compl_first_match; 2505 do 2506 { 2507 if ( !(match->cp_flags & ORIGINAL_TEXT) 2508 && STRNCMP(match->cp_str, str, len) == 0 2509 && match->cp_str[len] == NUL) 2510 return NOTDONE; 2511 match = match->cp_next; 2512 } while (match != NULL && match != compl_first_match); 2513 } 2514 2515 /* Remove any popup menu before changing the list of matches. */ 2516 ins_compl_del_pum(); 2517 2518 /* 2519 * Allocate a new match structure. 2520 * Copy the values to the new match structure. 2521 */ 2522 match = (compl_T *)alloc_clear((unsigned)sizeof(compl_T)); 2523 if (match == NULL) 2524 return FAIL; 2525 match->cp_number = -1; 2526 if (flags & ORIGINAL_TEXT) 2527 match->cp_number = 0; 2528 if ((match->cp_str = vim_strnsave(str, len)) == NULL) 2529 { 2530 vim_free(match); 2531 return FAIL; 2532 } 2533 match->cp_icase = icase; 2534 2535 /* match-fname is: 2536 * - compl_curr_match->cp_fname if it is a string equal to fname. 2537 * - a copy of fname, FREE_FNAME is set to free later THE allocated mem. 2538 * - NULL otherwise. --Acevedo */ 2539 if (fname != NULL 2540 && compl_curr_match != NULL 2541 && compl_curr_match->cp_fname != NULL 2542 && STRCMP(fname, compl_curr_match->cp_fname) == 0) 2543 match->cp_fname = compl_curr_match->cp_fname; 2544 else if (fname != NULL) 2545 { 2546 match->cp_fname = vim_strsave(fname); 2547 flags |= FREE_FNAME; 2548 } 2549 else 2550 match->cp_fname = NULL; 2551 match->cp_flags = flags; 2552 2553 if (cptext != NULL) 2554 { 2555 int i; 2556 2557 for (i = 0; i < CPT_COUNT; ++i) 2558 if (cptext[i] != NULL && *cptext[i] != NUL) 2559 match->cp_text[i] = vim_strsave(cptext[i]); 2560 } 2561 2562 /* 2563 * Link the new match structure in the list of matches. 2564 */ 2565 if (compl_first_match == NULL) 2566 match->cp_next = match->cp_prev = NULL; 2567 else if (dir == FORWARD) 2568 { 2569 match->cp_next = compl_curr_match->cp_next; 2570 match->cp_prev = compl_curr_match; 2571 } 2572 else /* BACKWARD */ 2573 { 2574 match->cp_next = compl_curr_match; 2575 match->cp_prev = compl_curr_match->cp_prev; 2576 } 2577 if (match->cp_next) 2578 match->cp_next->cp_prev = match; 2579 if (match->cp_prev) 2580 match->cp_prev->cp_next = match; 2581 else /* if there's nothing before, it is the first match */ 2582 compl_first_match = match; 2583 compl_curr_match = match; 2584 2585 /* 2586 * Find the longest common string if still doing that. 2587 */ 2588 if (compl_get_longest && (flags & ORIGINAL_TEXT) == 0) 2589 ins_compl_longest_match(match); 2590 2591 return OK; 2592 } 2593 2594 /* 2595 * Return TRUE if "str[len]" matches with match->cp_str, considering 2596 * match->cp_icase. 2597 */ 2598 static int 2599 ins_compl_equal(match, str, len) 2600 compl_T *match; 2601 char_u *str; 2602 int len; 2603 { 2604 if (match->cp_icase) 2605 return STRNICMP(match->cp_str, str, (size_t)len) == 0; 2606 return STRNCMP(match->cp_str, str, (size_t)len) == 0; 2607 } 2608 2609 /* 2610 * Reduce the longest common string for match "match". 2611 */ 2612 static void 2613 ins_compl_longest_match(match) 2614 compl_T *match; 2615 { 2616 char_u *p, *s; 2617 int c1, c2; 2618 int had_match; 2619 2620 if (compl_leader == NULL) 2621 { 2622 /* First match, use it as a whole. */ 2623 compl_leader = vim_strsave(match->cp_str); 2624 if (compl_leader != NULL) 2625 { 2626 had_match = (curwin->w_cursor.col > compl_col); 2627 ins_compl_delete(); 2628 ins_bytes(compl_leader + ins_compl_len()); 2629 ins_redraw(FALSE); 2630 2631 /* When the match isn't there (to avoid matching itself) remove it 2632 * again after redrawing. */ 2633 if (!had_match) 2634 ins_compl_delete(); 2635 compl_used_match = FALSE; 2636 } 2637 } 2638 else 2639 { 2640 /* Reduce the text if this match differs from compl_leader. */ 2641 p = compl_leader; 2642 s = match->cp_str; 2643 while (*p != NUL) 2644 { 2645 #ifdef FEAT_MBYTE 2646 if (has_mbyte) 2647 { 2648 c1 = mb_ptr2char(p); 2649 c2 = mb_ptr2char(s); 2650 } 2651 else 2652 #endif 2653 { 2654 c1 = *p; 2655 c2 = *s; 2656 } 2657 if (match->cp_icase ? (MB_TOLOWER(c1) != MB_TOLOWER(c2)) 2658 : (c1 != c2)) 2659 break; 2660 #ifdef FEAT_MBYTE 2661 if (has_mbyte) 2662 { 2663 mb_ptr_adv(p); 2664 mb_ptr_adv(s); 2665 } 2666 else 2667 #endif 2668 { 2669 ++p; 2670 ++s; 2671 } 2672 } 2673 2674 if (*p != NUL) 2675 { 2676 /* Leader was shortened, need to change the inserted text. */ 2677 *p = NUL; 2678 had_match = (curwin->w_cursor.col > compl_col); 2679 ins_compl_delete(); 2680 ins_bytes(compl_leader + ins_compl_len()); 2681 ins_redraw(FALSE); 2682 2683 /* When the match isn't there (to avoid matching itself) remove it 2684 * again after redrawing. */ 2685 if (!had_match) 2686 ins_compl_delete(); 2687 } 2688 2689 compl_used_match = FALSE; 2690 } 2691 } 2692 2693 /* 2694 * Add an array of matches to the list of matches. 2695 * Frees matches[]. 2696 */ 2697 static void 2698 ins_compl_add_matches(num_matches, matches, icase) 2699 int num_matches; 2700 char_u **matches; 2701 int icase; 2702 { 2703 int i; 2704 int add_r = OK; 2705 int dir = compl_direction; 2706 2707 for (i = 0; i < num_matches && add_r != FAIL; i++) 2708 if ((add_r = ins_compl_add(matches[i], -1, icase, 2709 NULL, NULL, dir, 0, FALSE)) == OK) 2710 /* if dir was BACKWARD then honor it just once */ 2711 dir = FORWARD; 2712 FreeWild(num_matches, matches); 2713 } 2714 2715 /* Make the completion list cyclic. 2716 * Return the number of matches (excluding the original). 2717 */ 2718 static int 2719 ins_compl_make_cyclic() 2720 { 2721 compl_T *match; 2722 int count = 0; 2723 2724 if (compl_first_match != NULL) 2725 { 2726 /* 2727 * Find the end of the list. 2728 */ 2729 match = compl_first_match; 2730 /* there's always an entry for the compl_orig_text, it doesn't count. */ 2731 while (match->cp_next != NULL && match->cp_next != compl_first_match) 2732 { 2733 match = match->cp_next; 2734 ++count; 2735 } 2736 match->cp_next = compl_first_match; 2737 compl_first_match->cp_prev = match; 2738 } 2739 return count; 2740 } 2741 2742 /* 2743 * Start completion for the complete() function. 2744 * "startcol" is where the matched text starts (1 is first column). 2745 * "list" is the list of matches. 2746 */ 2747 void 2748 set_completion(startcol, list) 2749 colnr_T startcol; 2750 list_T *list; 2751 { 2752 /* If already doing completions stop it. */ 2753 if (ctrl_x_mode != 0) 2754 ins_compl_prep(' '); 2755 ins_compl_clear(); 2756 2757 if (stop_arrow() == FAIL) 2758 return; 2759 2760 compl_direction = FORWARD; 2761 if (startcol > curwin->w_cursor.col) 2762 startcol = curwin->w_cursor.col; 2763 compl_col = startcol; 2764 compl_length = (int)curwin->w_cursor.col - (int)startcol; 2765 /* compl_pattern doesn't need to be set */ 2766 compl_orig_text = vim_strnsave(ml_get_curline() + compl_col, compl_length); 2767 if (compl_orig_text == NULL || ins_compl_add(compl_orig_text, 2768 -1, p_ic, NULL, NULL, 0, ORIGINAL_TEXT, FALSE) != OK) 2769 return; 2770 2771 /* Handle like dictionary completion. */ 2772 ctrl_x_mode = CTRL_X_WHOLE_LINE; 2773 2774 ins_compl_add_list(list); 2775 compl_matches = ins_compl_make_cyclic(); 2776 compl_started = TRUE; 2777 compl_used_match = TRUE; 2778 compl_cont_status = 0; 2779 2780 compl_curr_match = compl_first_match; 2781 ins_complete(Ctrl_N); 2782 out_flush(); 2783 } 2784 2785 2786 /* "compl_match_array" points the currently displayed list of entries in the 2787 * popup menu. It is NULL when there is no popup menu. */ 2788 static pumitem_T *compl_match_array = NULL; 2789 static int compl_match_arraysize; 2790 2791 /* 2792 * Update the screen and when there is any scrolling remove the popup menu. 2793 */ 2794 static void 2795 ins_compl_upd_pum() 2796 { 2797 int h; 2798 2799 if (compl_match_array != NULL) 2800 { 2801 h = curwin->w_cline_height; 2802 update_screen(0); 2803 if (h != curwin->w_cline_height) 2804 ins_compl_del_pum(); 2805 } 2806 } 2807 2808 /* 2809 * Remove any popup menu. 2810 */ 2811 static void 2812 ins_compl_del_pum() 2813 { 2814 if (compl_match_array != NULL) 2815 { 2816 pum_undisplay(); 2817 vim_free(compl_match_array); 2818 compl_match_array = NULL; 2819 } 2820 } 2821 2822 /* 2823 * Return TRUE if the popup menu should be displayed. 2824 */ 2825 static int 2826 pum_wanted() 2827 { 2828 /* 'completeopt' must contain "menu" or "menuone" */ 2829 if (vim_strchr(p_cot, 'm') == NULL) 2830 return FALSE; 2831 2832 /* The display looks bad on a B&W display. */ 2833 if (t_colors < 8 2834 #ifdef FEAT_GUI 2835 && !gui.in_use 2836 #endif 2837 ) 2838 return FALSE; 2839 return TRUE; 2840 } 2841 2842 /* 2843 * Return TRUE if there are two or more matches to be shown in the popup menu. 2844 * One if 'completopt' contains "menuone". 2845 */ 2846 static int 2847 pum_enough_matches() 2848 { 2849 compl_T *compl; 2850 int i; 2851 2852 /* Don't display the popup menu if there are no matches or there is only 2853 * one (ignoring the original text). */ 2854 compl = compl_first_match; 2855 i = 0; 2856 do 2857 { 2858 if (compl == NULL 2859 || ((compl->cp_flags & ORIGINAL_TEXT) == 0 && ++i == 2)) 2860 break; 2861 compl = compl->cp_next; 2862 } while (compl != compl_first_match); 2863 2864 if (strstr((char *)p_cot, "menuone") != NULL) 2865 return (i >= 1); 2866 return (i >= 2); 2867 } 2868 2869 /* 2870 * Show the popup menu for the list of matches. 2871 * Also adjusts "compl_shown_match" to an entry that is actually displayed. 2872 */ 2873 void 2874 ins_compl_show_pum() 2875 { 2876 compl_T *compl; 2877 compl_T *shown_compl = NULL; 2878 int did_find_shown_match = FALSE; 2879 int shown_match_ok = FALSE; 2880 int i; 2881 int cur = -1; 2882 colnr_T col; 2883 int lead_len = 0; 2884 2885 if (!pum_wanted() || !pum_enough_matches()) 2886 return; 2887 2888 #if defined(FEAT_EVAL) 2889 /* Dirty hard-coded hack: remove any matchparen highlighting. */ 2890 do_cmdline_cmd((char_u *)"if exists('g:loaded_matchparen')|3match none|endif"); 2891 #endif 2892 2893 /* Update the screen before drawing the popup menu over it. */ 2894 update_screen(0); 2895 2896 if (compl_match_array == NULL) 2897 { 2898 /* Need to build the popup menu list. */ 2899 compl_match_arraysize = 0; 2900 compl = compl_first_match; 2901 if (compl_leader != NULL) 2902 lead_len = (int)STRLEN(compl_leader); 2903 do 2904 { 2905 if ((compl->cp_flags & ORIGINAL_TEXT) == 0 2906 && (compl_leader == NULL 2907 || ins_compl_equal(compl, compl_leader, lead_len))) 2908 ++compl_match_arraysize; 2909 compl = compl->cp_next; 2910 } while (compl != NULL && compl != compl_first_match); 2911 if (compl_match_arraysize == 0) 2912 return; 2913 compl_match_array = (pumitem_T *)alloc_clear( 2914 (unsigned)(sizeof(pumitem_T) 2915 * compl_match_arraysize)); 2916 if (compl_match_array != NULL) 2917 { 2918 /* If the current match is the original text don't find the first 2919 * match after it, don't highlight anything. */ 2920 if (compl_shown_match->cp_flags & ORIGINAL_TEXT) 2921 shown_match_ok = TRUE; 2922 2923 i = 0; 2924 compl = compl_first_match; 2925 do 2926 { 2927 if ((compl->cp_flags & ORIGINAL_TEXT) == 0 2928 && (compl_leader == NULL 2929 || ins_compl_equal(compl, compl_leader, lead_len))) 2930 { 2931 if (!shown_match_ok) 2932 { 2933 if (compl == compl_shown_match || did_find_shown_match) 2934 { 2935 /* This item is the shown match or this is the 2936 * first displayed item after the shown match. */ 2937 compl_shown_match = compl; 2938 did_find_shown_match = TRUE; 2939 shown_match_ok = TRUE; 2940 } 2941 else 2942 /* Remember this displayed match for when the 2943 * shown match is just below it. */ 2944 shown_compl = compl; 2945 cur = i; 2946 } 2947 2948 if (compl->cp_text[CPT_ABBR] != NULL) 2949 compl_match_array[i].pum_text = 2950 compl->cp_text[CPT_ABBR]; 2951 else 2952 compl_match_array[i].pum_text = compl->cp_str; 2953 compl_match_array[i].pum_kind = compl->cp_text[CPT_KIND]; 2954 compl_match_array[i].pum_info = compl->cp_text[CPT_INFO]; 2955 if (compl->cp_text[CPT_MENU] != NULL) 2956 compl_match_array[i++].pum_extra = 2957 compl->cp_text[CPT_MENU]; 2958 else 2959 compl_match_array[i++].pum_extra = compl->cp_fname; 2960 } 2961 2962 if (compl == compl_shown_match) 2963 { 2964 did_find_shown_match = TRUE; 2965 2966 /* When the original text is the shown match don't set 2967 * compl_shown_match. */ 2968 if (compl->cp_flags & ORIGINAL_TEXT) 2969 shown_match_ok = TRUE; 2970 2971 if (!shown_match_ok && shown_compl != NULL) 2972 { 2973 /* The shown match isn't displayed, set it to the 2974 * previously displayed match. */ 2975 compl_shown_match = shown_compl; 2976 shown_match_ok = TRUE; 2977 } 2978 } 2979 compl = compl->cp_next; 2980 } while (compl != NULL && compl != compl_first_match); 2981 2982 if (!shown_match_ok) /* no displayed match at all */ 2983 cur = -1; 2984 } 2985 } 2986 else 2987 { 2988 /* popup menu already exists, only need to find the current item.*/ 2989 for (i = 0; i < compl_match_arraysize; ++i) 2990 if (compl_match_array[i].pum_text == compl_shown_match->cp_str 2991 || compl_match_array[i].pum_text 2992 == compl_shown_match->cp_text[CPT_ABBR]) 2993 { 2994 cur = i; 2995 break; 2996 } 2997 } 2998 2999 if (compl_match_array != NULL) 3000 { 3001 /* Compute the screen column of the start of the completed text. 3002 * Use the cursor to get all wrapping and other settings right. */ 3003 col = curwin->w_cursor.col; 3004 curwin->w_cursor.col = compl_col; 3005 pum_display(compl_match_array, compl_match_arraysize, cur); 3006 curwin->w_cursor.col = col; 3007 } 3008 } 3009 3010 #define DICT_FIRST (1) /* use just first element in "dict" */ 3011 #define DICT_EXACT (2) /* "dict" is the exact name of a file */ 3012 3013 /* 3014 * Add any identifiers that match the given pattern in the list of dictionary 3015 * files "dict_start" to the list of completions. 3016 */ 3017 static void 3018 ins_compl_dictionaries(dict_start, pat, flags, thesaurus) 3019 char_u *dict_start; 3020 char_u *pat; 3021 int flags; /* DICT_FIRST and/or DICT_EXACT */ 3022 int thesaurus; /* Thesaurus completion */ 3023 { 3024 char_u *dict = dict_start; 3025 char_u *ptr; 3026 char_u *buf; 3027 regmatch_T regmatch; 3028 char_u **files; 3029 int count; 3030 int save_p_scs; 3031 int dir = compl_direction; 3032 3033 if (*dict == NUL) 3034 { 3035 #ifdef FEAT_SPELL 3036 /* When 'dictionary' is empty and spell checking is enabled use 3037 * "spell". */ 3038 if (!thesaurus && curwin->w_p_spell) 3039 dict = (char_u *)"spell"; 3040 else 3041 #endif 3042 return; 3043 } 3044 3045 buf = alloc(LSIZE); 3046 if (buf == NULL) 3047 return; 3048 regmatch.regprog = NULL; /* so that we can goto theend */ 3049 3050 /* If 'infercase' is set, don't use 'smartcase' here */ 3051 save_p_scs = p_scs; 3052 if (curbuf->b_p_inf) 3053 p_scs = FALSE; 3054 3055 /* When invoked to match whole lines for CTRL-X CTRL-L adjust the pattern 3056 * to only match at the start of a line. Otherwise just match the 3057 * pattern. Also need to double backslashes. */ 3058 if (ctrl_x_mode == CTRL_X_WHOLE_LINE) 3059 { 3060 char_u *pat_esc = vim_strsave_escaped(pat, (char_u *)"\\"); 3061 size_t len; 3062 3063 if (pat_esc == NULL) 3064 goto theend; 3065 len = STRLEN(pat_esc) + 10; 3066 ptr = alloc((unsigned)len); 3067 if (ptr == NULL) 3068 { 3069 vim_free(pat_esc); 3070 goto theend; 3071 } 3072 vim_snprintf((char *)ptr, len, "^\\s*\\zs\\V%s", pat_esc); 3073 regmatch.regprog = vim_regcomp(ptr, RE_MAGIC); 3074 vim_free(pat_esc); 3075 vim_free(ptr); 3076 } 3077 else 3078 { 3079 regmatch.regprog = vim_regcomp(pat, p_magic ? RE_MAGIC : 0); 3080 if (regmatch.regprog == NULL) 3081 goto theend; 3082 } 3083 3084 /* ignore case depends on 'ignorecase', 'smartcase' and "pat" */ 3085 regmatch.rm_ic = ignorecase(pat); 3086 while (*dict != NUL && !got_int && !compl_interrupted) 3087 { 3088 /* copy one dictionary file name into buf */ 3089 if (flags == DICT_EXACT) 3090 { 3091 count = 1; 3092 files = &dict; 3093 } 3094 else 3095 { 3096 /* Expand wildcards in the dictionary name, but do not allow 3097 * backticks (for security, the 'dict' option may have been set in 3098 * a modeline). */ 3099 copy_option_part(&dict, buf, LSIZE, ","); 3100 # ifdef FEAT_SPELL 3101 if (!thesaurus && STRCMP(buf, "spell") == 0) 3102 count = -1; 3103 else 3104 # endif 3105 if (vim_strchr(buf, '`') != NULL 3106 || expand_wildcards(1, &buf, &count, &files, 3107 EW_FILE|EW_SILENT) != OK) 3108 count = 0; 3109 } 3110 3111 # ifdef FEAT_SPELL 3112 if (count == -1) 3113 { 3114 /* Complete from active spelling. Skip "\<" in the pattern, we 3115 * don't use it as a RE. */ 3116 if (pat[0] == '\\' && pat[1] == '<') 3117 ptr = pat + 2; 3118 else 3119 ptr = pat; 3120 spell_dump_compl(ptr, regmatch.rm_ic, &dir, 0); 3121 } 3122 else 3123 # endif 3124 if (count > 0) /* avoid warning for using "files" uninit */ 3125 { 3126 ins_compl_files(count, files, thesaurus, flags, 3127 ®match, buf, &dir); 3128 if (flags != DICT_EXACT) 3129 FreeWild(count, files); 3130 } 3131 if (flags != 0) 3132 break; 3133 } 3134 3135 theend: 3136 p_scs = save_p_scs; 3137 vim_regfree(regmatch.regprog); 3138 vim_free(buf); 3139 } 3140 3141 static void 3142 ins_compl_files(count, files, thesaurus, flags, regmatch, buf, dir) 3143 int count; 3144 char_u **files; 3145 int thesaurus; 3146 int flags; 3147 regmatch_T *regmatch; 3148 char_u *buf; 3149 int *dir; 3150 { 3151 char_u *ptr; 3152 int i; 3153 FILE *fp; 3154 int add_r; 3155 3156 for (i = 0; i < count && !got_int && !compl_interrupted; i++) 3157 { 3158 fp = mch_fopen((char *)files[i], "r"); /* open dictionary file */ 3159 if (flags != DICT_EXACT) 3160 { 3161 vim_snprintf((char *)IObuff, IOSIZE, 3162 _("Scanning dictionary: %s"), (char *)files[i]); 3163 (void)msg_trunc_attr(IObuff, TRUE, hl_attr(HLF_R)); 3164 } 3165 3166 if (fp != NULL) 3167 { 3168 /* 3169 * Read dictionary file line by line. 3170 * Check each line for a match. 3171 */ 3172 while (!got_int && !compl_interrupted 3173 && !vim_fgets(buf, LSIZE, fp)) 3174 { 3175 ptr = buf; 3176 while (vim_regexec(regmatch, buf, (colnr_T)(ptr - buf))) 3177 { 3178 ptr = regmatch->startp[0]; 3179 if (ctrl_x_mode == CTRL_X_WHOLE_LINE) 3180 ptr = find_line_end(ptr); 3181 else 3182 ptr = find_word_end(ptr); 3183 add_r = ins_compl_add_infercase(regmatch->startp[0], 3184 (int)(ptr - regmatch->startp[0]), 3185 p_ic, files[i], *dir, 0); 3186 if (thesaurus) 3187 { 3188 char_u *wstart; 3189 3190 /* 3191 * Add the other matches on the line 3192 */ 3193 ptr = buf; 3194 while (!got_int) 3195 { 3196 /* Find start of the next word. Skip white 3197 * space and punctuation. */ 3198 ptr = find_word_start(ptr); 3199 if (*ptr == NUL || *ptr == NL) 3200 break; 3201 wstart = ptr; 3202 3203 /* Find end of the word. */ 3204 #ifdef FEAT_MBYTE 3205 if (has_mbyte) 3206 /* Japanese words may have characters in 3207 * different classes, only separate words 3208 * with single-byte non-word characters. */ 3209 while (*ptr != NUL) 3210 { 3211 int l = (*mb_ptr2len)(ptr); 3212 3213 if (l < 2 && !vim_iswordc(*ptr)) 3214 break; 3215 ptr += l; 3216 } 3217 else 3218 #endif 3219 ptr = find_word_end(ptr); 3220 3221 /* Add the word. Skip the regexp match. */ 3222 if (wstart != regmatch->startp[0]) 3223 add_r = ins_compl_add_infercase(wstart, 3224 (int)(ptr - wstart), 3225 p_ic, files[i], *dir, 0); 3226 } 3227 } 3228 if (add_r == OK) 3229 /* if dir was BACKWARD then honor it just once */ 3230 *dir = FORWARD; 3231 else if (add_r == FAIL) 3232 break; 3233 /* avoid expensive call to vim_regexec() when at end 3234 * of line */ 3235 if (*ptr == '\n' || got_int) 3236 break; 3237 } 3238 line_breakcheck(); 3239 ins_compl_check_keys(50); 3240 } 3241 fclose(fp); 3242 } 3243 } 3244 } 3245 3246 /* 3247 * Find the start of the next word. 3248 * Returns a pointer to the first char of the word. Also stops at a NUL. 3249 */ 3250 char_u * 3251 find_word_start(ptr) 3252 char_u *ptr; 3253 { 3254 #ifdef FEAT_MBYTE 3255 if (has_mbyte) 3256 while (*ptr != NUL && *ptr != '\n' && mb_get_class(ptr) <= 1) 3257 ptr += (*mb_ptr2len)(ptr); 3258 else 3259 #endif 3260 while (*ptr != NUL && *ptr != '\n' && !vim_iswordc(*ptr)) 3261 ++ptr; 3262 return ptr; 3263 } 3264 3265 /* 3266 * Find the end of the word. Assumes it starts inside a word. 3267 * Returns a pointer to just after the word. 3268 */ 3269 char_u * 3270 find_word_end(ptr) 3271 char_u *ptr; 3272 { 3273 #ifdef FEAT_MBYTE 3274 int start_class; 3275 3276 if (has_mbyte) 3277 { 3278 start_class = mb_get_class(ptr); 3279 if (start_class > 1) 3280 while (*ptr != NUL) 3281 { 3282 ptr += (*mb_ptr2len)(ptr); 3283 if (mb_get_class(ptr) != start_class) 3284 break; 3285 } 3286 } 3287 else 3288 #endif 3289 while (vim_iswordc(*ptr)) 3290 ++ptr; 3291 return ptr; 3292 } 3293 3294 /* 3295 * Find the end of the line, omitting CR and NL at the end. 3296 * Returns a pointer to just after the line. 3297 */ 3298 static char_u * 3299 find_line_end(ptr) 3300 char_u *ptr; 3301 { 3302 char_u *s; 3303 3304 s = ptr + STRLEN(ptr); 3305 while (s > ptr && (s[-1] == CAR || s[-1] == NL)) 3306 --s; 3307 return s; 3308 } 3309 3310 /* 3311 * Free the list of completions 3312 */ 3313 static void 3314 ins_compl_free() 3315 { 3316 compl_T *match; 3317 int i; 3318 3319 vim_free(compl_pattern); 3320 compl_pattern = NULL; 3321 vim_free(compl_leader); 3322 compl_leader = NULL; 3323 3324 if (compl_first_match == NULL) 3325 return; 3326 3327 ins_compl_del_pum(); 3328 pum_clear(); 3329 3330 compl_curr_match = compl_first_match; 3331 do 3332 { 3333 match = compl_curr_match; 3334 compl_curr_match = compl_curr_match->cp_next; 3335 vim_free(match->cp_str); 3336 /* several entries may use the same fname, free it just once. */ 3337 if (match->cp_flags & FREE_FNAME) 3338 vim_free(match->cp_fname); 3339 for (i = 0; i < CPT_COUNT; ++i) 3340 vim_free(match->cp_text[i]); 3341 vim_free(match); 3342 } while (compl_curr_match != NULL && compl_curr_match != compl_first_match); 3343 compl_first_match = compl_curr_match = NULL; 3344 compl_shown_match = NULL; 3345 } 3346 3347 static void 3348 ins_compl_clear() 3349 { 3350 compl_cont_status = 0; 3351 compl_started = FALSE; 3352 compl_matches = 0; 3353 vim_free(compl_pattern); 3354 compl_pattern = NULL; 3355 vim_free(compl_leader); 3356 compl_leader = NULL; 3357 edit_submode_extra = NULL; 3358 vim_free(compl_orig_text); 3359 compl_orig_text = NULL; 3360 compl_enter_selects = FALSE; 3361 } 3362 3363 /* 3364 * Return TRUE when Insert completion is active. 3365 */ 3366 int 3367 ins_compl_active() 3368 { 3369 return compl_started; 3370 } 3371 3372 /* 3373 * Delete one character before the cursor and show the subset of the matches 3374 * that match the word that is now before the cursor. 3375 * Returns the character to be used, NUL if the work is done and another char 3376 * to be got from the user. 3377 */ 3378 static int 3379 ins_compl_bs() 3380 { 3381 char_u *line; 3382 char_u *p; 3383 3384 line = ml_get_curline(); 3385 p = line + curwin->w_cursor.col; 3386 mb_ptr_back(line, p); 3387 3388 /* Stop completion when the whole word was deleted. For Omni completion 3389 * allow the word to be deleted, we won't match everything. */ 3390 if ((int)(p - line) - (int)compl_col < 0 3391 || ((int)(p - line) - (int)compl_col == 0 3392 && (ctrl_x_mode & CTRL_X_OMNI) == 0)) 3393 return K_BS; 3394 3395 /* Deleted more than what was used to find matches or didn't finish 3396 * finding all matches: need to look for matches all over again. */ 3397 if (curwin->w_cursor.col <= compl_col + compl_length 3398 || ins_compl_need_restart()) 3399 ins_compl_restart(); 3400 3401 vim_free(compl_leader); 3402 compl_leader = vim_strnsave(line + compl_col, (int)(p - line) - compl_col); 3403 if (compl_leader != NULL) 3404 { 3405 ins_compl_new_leader(); 3406 if (compl_shown_match != NULL) 3407 /* Make sure current match is not a hidden item. */ 3408 compl_curr_match = compl_shown_match; 3409 return NUL; 3410 } 3411 return K_BS; 3412 } 3413 3414 /* 3415 * Return TRUE when we need to find matches again, ins_compl_restart() is to 3416 * be called. 3417 */ 3418 static int 3419 ins_compl_need_restart() 3420 { 3421 /* Return TRUE if we didn't complete finding matches or when the 3422 * 'completefunc' returned "always" in the "refresh" dictionary item. */ 3423 return compl_was_interrupted 3424 || ((ctrl_x_mode == CTRL_X_FUNCTION || ctrl_x_mode == CTRL_X_OMNI) 3425 && compl_opt_refresh_always); 3426 } 3427 3428 /* 3429 * Called after changing "compl_leader". 3430 * Show the popup menu with a different set of matches. 3431 * May also search for matches again if the previous search was interrupted. 3432 */ 3433 static void 3434 ins_compl_new_leader() 3435 { 3436 ins_compl_del_pum(); 3437 ins_compl_delete(); 3438 ins_bytes(compl_leader + ins_compl_len()); 3439 compl_used_match = FALSE; 3440 3441 if (compl_started) 3442 ins_compl_set_original_text(compl_leader); 3443 else 3444 { 3445 #ifdef FEAT_SPELL 3446 spell_bad_len = 0; /* need to redetect bad word */ 3447 #endif 3448 /* 3449 * Matches were cleared, need to search for them now. First display 3450 * the changed text before the cursor. Set "compl_restarting" to 3451 * avoid that the first match is inserted. 3452 */ 3453 update_screen(0); 3454 #ifdef FEAT_GUI 3455 if (gui.in_use) 3456 { 3457 /* Show the cursor after the match, not after the redrawn text. */ 3458 setcursor(); 3459 out_flush(); 3460 gui_update_cursor(FALSE, FALSE); 3461 } 3462 #endif 3463 compl_restarting = TRUE; 3464 if (ins_complete(Ctrl_N) == FAIL) 3465 compl_cont_status = 0; 3466 compl_restarting = FALSE; 3467 } 3468 3469 compl_enter_selects = !compl_used_match; 3470 3471 /* Show the popup menu with a different set of matches. */ 3472 ins_compl_show_pum(); 3473 3474 /* Don't let Enter select the original text when there is no popup menu. */ 3475 if (compl_match_array == NULL) 3476 compl_enter_selects = FALSE; 3477 } 3478 3479 /* 3480 * Return the length of the completion, from the completion start column to 3481 * the cursor column. Making sure it never goes below zero. 3482 */ 3483 static int 3484 ins_compl_len() 3485 { 3486 int off = (int)curwin->w_cursor.col - (int)compl_col; 3487 3488 if (off < 0) 3489 return 0; 3490 return off; 3491 } 3492 3493 /* 3494 * Append one character to the match leader. May reduce the number of 3495 * matches. 3496 */ 3497 static void 3498 ins_compl_addleader(c) 3499 int c; 3500 { 3501 #ifdef FEAT_MBYTE 3502 int cc; 3503 3504 if (has_mbyte && (cc = (*mb_char2len)(c)) > 1) 3505 { 3506 char_u buf[MB_MAXBYTES + 1]; 3507 3508 (*mb_char2bytes)(c, buf); 3509 buf[cc] = NUL; 3510 ins_char_bytes(buf, cc); 3511 if (compl_opt_refresh_always) 3512 AppendToRedobuff(buf); 3513 } 3514 else 3515 #endif 3516 { 3517 ins_char(c); 3518 if (compl_opt_refresh_always) 3519 AppendCharToRedobuff(c); 3520 } 3521 3522 /* If we didn't complete finding matches we must search again. */ 3523 if (ins_compl_need_restart()) 3524 ins_compl_restart(); 3525 3526 /* When 'always' is set, don't reset compl_leader. While completing, 3527 * cursor doesn't point original position, changing compl_leader would 3528 * break redo. */ 3529 if (!compl_opt_refresh_always) 3530 { 3531 vim_free(compl_leader); 3532 compl_leader = vim_strnsave(ml_get_curline() + compl_col, 3533 (int)(curwin->w_cursor.col - compl_col)); 3534 if (compl_leader != NULL) 3535 ins_compl_new_leader(); 3536 } 3537 } 3538 3539 /* 3540 * Setup for finding completions again without leaving CTRL-X mode. Used when 3541 * BS or a key was typed while still searching for matches. 3542 */ 3543 static void 3544 ins_compl_restart() 3545 { 3546 ins_compl_free(); 3547 compl_started = FALSE; 3548 compl_matches = 0; 3549 compl_cont_status = 0; 3550 compl_cont_mode = 0; 3551 } 3552 3553 /* 3554 * Set the first match, the original text. 3555 */ 3556 static void 3557 ins_compl_set_original_text(str) 3558 char_u *str; 3559 { 3560 char_u *p; 3561 3562 /* Replace the original text entry. */ 3563 if (compl_first_match->cp_flags & ORIGINAL_TEXT) /* safety check */ 3564 { 3565 p = vim_strsave(str); 3566 if (p != NULL) 3567 { 3568 vim_free(compl_first_match->cp_str); 3569 compl_first_match->cp_str = p; 3570 } 3571 } 3572 } 3573 3574 /* 3575 * Append one character to the match leader. May reduce the number of 3576 * matches. 3577 */ 3578 static void 3579 ins_compl_addfrommatch() 3580 { 3581 char_u *p; 3582 int len = (int)curwin->w_cursor.col - (int)compl_col; 3583 int c; 3584 compl_T *cp; 3585 3586 p = compl_shown_match->cp_str; 3587 if ((int)STRLEN(p) <= len) /* the match is too short */ 3588 { 3589 /* When still at the original match use the first entry that matches 3590 * the leader. */ 3591 if (compl_shown_match->cp_flags & ORIGINAL_TEXT) 3592 { 3593 p = NULL; 3594 for (cp = compl_shown_match->cp_next; cp != NULL 3595 && cp != compl_first_match; cp = cp->cp_next) 3596 { 3597 if (compl_leader == NULL 3598 || ins_compl_equal(cp, compl_leader, 3599 (int)STRLEN(compl_leader))) 3600 { 3601 p = cp->cp_str; 3602 break; 3603 } 3604 } 3605 if (p == NULL || (int)STRLEN(p) <= len) 3606 return; 3607 } 3608 else 3609 return; 3610 } 3611 p += len; 3612 c = PTR2CHAR(p); 3613 ins_compl_addleader(c); 3614 } 3615 3616 /* 3617 * Prepare for Insert mode completion, or stop it. 3618 * Called just after typing a character in Insert mode. 3619 * Returns TRUE when the character is not to be inserted; 3620 */ 3621 static int 3622 ins_compl_prep(c) 3623 int c; 3624 { 3625 char_u *ptr; 3626 int want_cindent; 3627 int retval = FALSE; 3628 3629 /* Forget any previous 'special' messages if this is actually 3630 * a ^X mode key - bar ^R, in which case we wait to see what it gives us. 3631 */ 3632 if (c != Ctrl_R && vim_is_ctrl_x_key(c)) 3633 edit_submode_extra = NULL; 3634 3635 /* Ignore end of Select mode mapping and mouse scroll buttons. */ 3636 if (c == K_SELECT || c == K_MOUSEDOWN || c == K_MOUSEUP 3637 || c == K_MOUSELEFT || c == K_MOUSERIGHT) 3638 return retval; 3639 3640 /* Set "compl_get_longest" when finding the first matches. */ 3641 if (ctrl_x_mode == CTRL_X_NOT_DEFINED_YET 3642 || (ctrl_x_mode == 0 && !compl_started)) 3643 { 3644 compl_get_longest = (vim_strchr(p_cot, 'l') != NULL); 3645 compl_used_match = TRUE; 3646 } 3647 3648 if (ctrl_x_mode == CTRL_X_NOT_DEFINED_YET) 3649 { 3650 /* 3651 * We have just typed CTRL-X and aren't quite sure which CTRL-X mode 3652 * it will be yet. Now we decide. 3653 */ 3654 switch (c) 3655 { 3656 case Ctrl_E: 3657 case Ctrl_Y: 3658 ctrl_x_mode = CTRL_X_SCROLL; 3659 if (!(State & REPLACE_FLAG)) 3660 edit_submode = (char_u *)_(" (insert) Scroll (^E/^Y)"); 3661 else 3662 edit_submode = (char_u *)_(" (replace) Scroll (^E/^Y)"); 3663 edit_submode_pre = NULL; 3664 showmode(); 3665 break; 3666 case Ctrl_L: 3667 ctrl_x_mode = CTRL_X_WHOLE_LINE; 3668 break; 3669 case Ctrl_F: 3670 ctrl_x_mode = CTRL_X_FILES; 3671 break; 3672 case Ctrl_K: 3673 ctrl_x_mode = CTRL_X_DICTIONARY; 3674 break; 3675 case Ctrl_R: 3676 /* Simply allow ^R to happen without affecting ^X mode */ 3677 break; 3678 case Ctrl_T: 3679 ctrl_x_mode = CTRL_X_THESAURUS; 3680 break; 3681 #ifdef FEAT_COMPL_FUNC 3682 case Ctrl_U: 3683 ctrl_x_mode = CTRL_X_FUNCTION; 3684 break; 3685 case Ctrl_O: 3686 ctrl_x_mode = CTRL_X_OMNI; 3687 break; 3688 #endif 3689 case 's': 3690 case Ctrl_S: 3691 ctrl_x_mode = CTRL_X_SPELL; 3692 #ifdef FEAT_SPELL 3693 ++emsg_off; /* Avoid getting the E756 error twice. */ 3694 spell_back_to_badword(); 3695 --emsg_off; 3696 #endif 3697 break; 3698 case Ctrl_RSB: 3699 ctrl_x_mode = CTRL_X_TAGS; 3700 break; 3701 #ifdef FEAT_FIND_ID 3702 case Ctrl_I: 3703 case K_S_TAB: 3704 ctrl_x_mode = CTRL_X_PATH_PATTERNS; 3705 break; 3706 case Ctrl_D: 3707 ctrl_x_mode = CTRL_X_PATH_DEFINES; 3708 break; 3709 #endif 3710 case Ctrl_V: 3711 case Ctrl_Q: 3712 ctrl_x_mode = CTRL_X_CMDLINE; 3713 break; 3714 case Ctrl_P: 3715 case Ctrl_N: 3716 /* ^X^P means LOCAL expansion if nothing interrupted (eg we 3717 * just started ^X mode, or there were enough ^X's to cancel 3718 * the previous mode, say ^X^F^X^X^P or ^P^X^X^X^P, see below) 3719 * do normal expansion when interrupting a different mode (say 3720 * ^X^F^X^P or ^P^X^X^P, see below) 3721 * nothing changes if interrupting mode 0, (eg, the flag 3722 * doesn't change when going to ADDING mode -- Acevedo */ 3723 if (!(compl_cont_status & CONT_INTRPT)) 3724 compl_cont_status |= CONT_LOCAL; 3725 else if (compl_cont_mode != 0) 3726 compl_cont_status &= ~CONT_LOCAL; 3727 /* FALLTHROUGH */ 3728 default: 3729 /* If we have typed at least 2 ^X's... for modes != 0, we set 3730 * compl_cont_status = 0 (eg, as if we had just started ^X 3731 * mode). 3732 * For mode 0, we set "compl_cont_mode" to an impossible 3733 * value, in both cases ^X^X can be used to restart the same 3734 * mode (avoiding ADDING mode). 3735 * Undocumented feature: In a mode != 0 ^X^P and ^X^X^P start 3736 * 'complete' and local ^P expansions respectively. 3737 * In mode 0 an extra ^X is needed since ^X^P goes to ADDING 3738 * mode -- Acevedo */ 3739 if (c == Ctrl_X) 3740 { 3741 if (compl_cont_mode != 0) 3742 compl_cont_status = 0; 3743 else 3744 compl_cont_mode = CTRL_X_NOT_DEFINED_YET; 3745 } 3746 ctrl_x_mode = 0; 3747 edit_submode = NULL; 3748 showmode(); 3749 break; 3750 } 3751 } 3752 else if (ctrl_x_mode != 0) 3753 { 3754 /* We're already in CTRL-X mode, do we stay in it? */ 3755 if (!vim_is_ctrl_x_key(c)) 3756 { 3757 if (ctrl_x_mode == CTRL_X_SCROLL) 3758 ctrl_x_mode = 0; 3759 else 3760 ctrl_x_mode = CTRL_X_FINISHED; 3761 edit_submode = NULL; 3762 } 3763 showmode(); 3764 } 3765 3766 if (compl_started || ctrl_x_mode == CTRL_X_FINISHED) 3767 { 3768 /* Show error message from attempted keyword completion (probably 3769 * 'Pattern not found') until another key is hit, then go back to 3770 * showing what mode we are in. */ 3771 showmode(); 3772 if ((ctrl_x_mode == 0 && c != Ctrl_N && c != Ctrl_P && c != Ctrl_R 3773 && !ins_compl_pum_key(c)) 3774 || ctrl_x_mode == CTRL_X_FINISHED) 3775 { 3776 /* Get here when we have finished typing a sequence of ^N and 3777 * ^P or other completion characters in CTRL-X mode. Free up 3778 * memory that was used, and make sure we can redo the insert. */ 3779 if (compl_curr_match != NULL || compl_leader != NULL || c == Ctrl_E) 3780 { 3781 /* 3782 * If any of the original typed text has been changed, eg when 3783 * ignorecase is set, we must add back-spaces to the redo 3784 * buffer. We add as few as necessary to delete just the part 3785 * of the original text that has changed. 3786 * When using the longest match, edited the match or used 3787 * CTRL-E then don't use the current match. 3788 */ 3789 if (compl_curr_match != NULL && compl_used_match && c != Ctrl_E) 3790 ptr = compl_curr_match->cp_str; 3791 else 3792 ptr = NULL; 3793 ins_compl_fixRedoBufForLeader(ptr); 3794 } 3795 3796 #ifdef FEAT_CINDENT 3797 want_cindent = (can_cindent && cindent_on()); 3798 #endif 3799 /* 3800 * When completing whole lines: fix indent for 'cindent'. 3801 * Otherwise, break line if it's too long. 3802 */ 3803 if (compl_cont_mode == CTRL_X_WHOLE_LINE) 3804 { 3805 #ifdef FEAT_CINDENT 3806 /* re-indent the current line */ 3807 if (want_cindent) 3808 { 3809 do_c_expr_indent(); 3810 want_cindent = FALSE; /* don't do it again */ 3811 } 3812 #endif 3813 } 3814 else 3815 { 3816 int prev_col = curwin->w_cursor.col; 3817 3818 /* put the cursor on the last char, for 'tw' formatting */ 3819 if (prev_col > 0) 3820 dec_cursor(); 3821 if (stop_arrow() == OK) 3822 insertchar(NUL, 0, -1); 3823 if (prev_col > 0 3824 && ml_get_curline()[curwin->w_cursor.col] != NUL) 3825 inc_cursor(); 3826 } 3827 3828 /* If the popup menu is displayed pressing CTRL-Y means accepting 3829 * the selection without inserting anything. When 3830 * compl_enter_selects is set the Enter key does the same. */ 3831 if ((c == Ctrl_Y || (compl_enter_selects 3832 && (c == CAR || c == K_KENTER || c == NL))) 3833 && pum_visible()) 3834 retval = TRUE; 3835 3836 /* CTRL-E means completion is Ended, go back to the typed text. */ 3837 if (c == Ctrl_E) 3838 { 3839 ins_compl_delete(); 3840 if (compl_leader != NULL) 3841 ins_bytes(compl_leader + ins_compl_len()); 3842 else if (compl_first_match != NULL) 3843 ins_bytes(compl_orig_text + ins_compl_len()); 3844 retval = TRUE; 3845 } 3846 3847 auto_format(FALSE, TRUE); 3848 3849 ins_compl_free(); 3850 compl_started = FALSE; 3851 compl_matches = 0; 3852 msg_clr_cmdline(); /* necessary for "noshowmode" */ 3853 ctrl_x_mode = 0; 3854 compl_enter_selects = FALSE; 3855 if (edit_submode != NULL) 3856 { 3857 edit_submode = NULL; 3858 showmode(); 3859 } 3860 3861 #ifdef FEAT_CINDENT 3862 /* 3863 * Indent now if a key was typed that is in 'cinkeys'. 3864 */ 3865 if (want_cindent && in_cinkeys(KEY_COMPLETE, ' ', inindent(0))) 3866 do_c_expr_indent(); 3867 #endif 3868 #ifdef FEAT_AUTOCMD 3869 /* Trigger the CompleteDone event to give scripts a chance to act 3870 * upon the completion. */ 3871 apply_autocmds(EVENT_COMPLETEDONE, NULL, NULL, FALSE, curbuf); 3872 #endif 3873 } 3874 } 3875 #ifdef FEAT_AUTOCMD 3876 else if (ctrl_x_mode == CTRL_X_LOCAL_MSG) 3877 /* Trigger the CompleteDone event to give scripts a chance to act 3878 * upon the (possibly failed) completion. */ 3879 apply_autocmds(EVENT_COMPLETEDONE, NULL, NULL, FALSE, curbuf); 3880 #endif 3881 3882 /* reset continue_* if we left expansion-mode, if we stay they'll be 3883 * (re)set properly in ins_complete() */ 3884 if (!vim_is_ctrl_x_key(c)) 3885 { 3886 compl_cont_status = 0; 3887 compl_cont_mode = 0; 3888 } 3889 3890 return retval; 3891 } 3892 3893 /* 3894 * Fix the redo buffer for the completion leader replacing some of the typed 3895 * text. This inserts backspaces and appends the changed text. 3896 * "ptr" is the known leader text or NUL. 3897 */ 3898 static void 3899 ins_compl_fixRedoBufForLeader(ptr_arg) 3900 char_u *ptr_arg; 3901 { 3902 int len; 3903 char_u *p; 3904 char_u *ptr = ptr_arg; 3905 3906 if (ptr == NULL) 3907 { 3908 if (compl_leader != NULL) 3909 ptr = compl_leader; 3910 else 3911 return; /* nothing to do */ 3912 } 3913 if (compl_orig_text != NULL) 3914 { 3915 p = compl_orig_text; 3916 for (len = 0; p[len] != NUL && p[len] == ptr[len]; ++len) 3917 ; 3918 #ifdef FEAT_MBYTE 3919 if (len > 0) 3920 len -= (*mb_head_off)(p, p + len); 3921 #endif 3922 for (p += len; *p != NUL; mb_ptr_adv(p)) 3923 AppendCharToRedobuff(K_BS); 3924 } 3925 else 3926 len = 0; 3927 if (ptr != NULL) 3928 AppendToRedobuffLit(ptr + len, -1); 3929 } 3930 3931 /* 3932 * Loops through the list of windows, loaded-buffers or non-loaded-buffers 3933 * (depending on flag) starting from buf and looking for a non-scanned 3934 * buffer (other than curbuf). curbuf is special, if it is called with 3935 * buf=curbuf then it has to be the first call for a given flag/expansion. 3936 * 3937 * Returns the buffer to scan, if any, otherwise returns curbuf -- Acevedo 3938 */ 3939 static buf_T * 3940 ins_compl_next_buf(buf, flag) 3941 buf_T *buf; 3942 int flag; 3943 { 3944 #ifdef FEAT_WINDOWS 3945 static win_T *wp; 3946 #endif 3947 3948 if (flag == 'w') /* just windows */ 3949 { 3950 #ifdef FEAT_WINDOWS 3951 if (buf == curbuf) /* first call for this flag/expansion */ 3952 wp = curwin; 3953 while ((wp = (wp->w_next != NULL ? wp->w_next : firstwin)) != curwin 3954 && wp->w_buffer->b_scanned) 3955 ; 3956 buf = wp->w_buffer; 3957 #else 3958 buf = curbuf; 3959 #endif 3960 } 3961 else 3962 /* 'b' (just loaded buffers), 'u' (just non-loaded buffers) or 'U' 3963 * (unlisted buffers) 3964 * When completing whole lines skip unloaded buffers. */ 3965 while ((buf = (buf->b_next != NULL ? buf->b_next : firstbuf)) != curbuf 3966 && ((flag == 'U' 3967 ? buf->b_p_bl 3968 : (!buf->b_p_bl 3969 || (buf->b_ml.ml_mfp == NULL) != (flag == 'u'))) 3970 || buf->b_scanned)) 3971 ; 3972 return buf; 3973 } 3974 3975 #ifdef FEAT_COMPL_FUNC 3976 static void expand_by_function __ARGS((int type, char_u *base)); 3977 3978 /* 3979 * Execute user defined complete function 'completefunc' or 'omnifunc', and 3980 * get matches in "matches". 3981 */ 3982 static void 3983 expand_by_function(type, base) 3984 int type; /* CTRL_X_OMNI or CTRL_X_FUNCTION */ 3985 char_u *base; 3986 { 3987 list_T *matchlist = NULL; 3988 dict_T *matchdict = NULL; 3989 char_u *args[2]; 3990 char_u *funcname; 3991 pos_T pos; 3992 win_T *curwin_save; 3993 buf_T *curbuf_save; 3994 typval_T rettv; 3995 3996 funcname = (type == CTRL_X_FUNCTION) ? curbuf->b_p_cfu : curbuf->b_p_ofu; 3997 if (*funcname == NUL) 3998 return; 3999 4000 /* Call 'completefunc' to obtain the list of matches. */ 4001 args[0] = (char_u *)"0"; 4002 args[1] = base; 4003 4004 pos = curwin->w_cursor; 4005 curwin_save = curwin; 4006 curbuf_save = curbuf; 4007 4008 /* Call a function, which returns a list or dict. */ 4009 if (call_vim_function(funcname, 2, args, FALSE, FALSE, &rettv) == OK) 4010 { 4011 switch (rettv.v_type) 4012 { 4013 case VAR_LIST: 4014 matchlist = rettv.vval.v_list; 4015 break; 4016 case VAR_DICT: 4017 matchdict = rettv.vval.v_dict; 4018 break; 4019 default: 4020 /* TODO: Give error message? */ 4021 clear_tv(&rettv); 4022 break; 4023 } 4024 } 4025 4026 if (curwin_save != curwin || curbuf_save != curbuf) 4027 { 4028 EMSG(_(e_complwin)); 4029 goto theend; 4030 } 4031 curwin->w_cursor = pos; /* restore the cursor position */ 4032 check_cursor(); 4033 if (!equalpos(curwin->w_cursor, pos)) 4034 { 4035 EMSG(_(e_compldel)); 4036 goto theend; 4037 } 4038 4039 if (matchlist != NULL) 4040 ins_compl_add_list(matchlist); 4041 else if (matchdict != NULL) 4042 ins_compl_add_dict(matchdict); 4043 4044 theend: 4045 if (matchdict != NULL) 4046 dict_unref(matchdict); 4047 if (matchlist != NULL) 4048 list_unref(matchlist); 4049 } 4050 #endif /* FEAT_COMPL_FUNC */ 4051 4052 #if defined(FEAT_COMPL_FUNC) || defined(FEAT_EVAL) || defined(PROTO) 4053 /* 4054 * Add completions from a list. 4055 */ 4056 static void 4057 ins_compl_add_list(list) 4058 list_T *list; 4059 { 4060 listitem_T *li; 4061 int dir = compl_direction; 4062 4063 /* Go through the List with matches and add each of them. */ 4064 for (li = list->lv_first; li != NULL; li = li->li_next) 4065 { 4066 if (ins_compl_add_tv(&li->li_tv, dir) == OK) 4067 /* if dir was BACKWARD then honor it just once */ 4068 dir = FORWARD; 4069 else if (did_emsg) 4070 break; 4071 } 4072 } 4073 4074 /* 4075 * Add completions from a dict. 4076 */ 4077 static void 4078 ins_compl_add_dict(dict) 4079 dict_T *dict; 4080 { 4081 dictitem_T *di_refresh; 4082 dictitem_T *di_words; 4083 4084 /* Check for optional "refresh" item. */ 4085 compl_opt_refresh_always = FALSE; 4086 di_refresh = dict_find(dict, (char_u *)"refresh", 7); 4087 if (di_refresh != NULL && di_refresh->di_tv.v_type == VAR_STRING) 4088 { 4089 char_u *v = di_refresh->di_tv.vval.v_string; 4090 4091 if (v != NULL && STRCMP(v, (char_u *)"always") == 0) 4092 compl_opt_refresh_always = TRUE; 4093 } 4094 4095 /* Add completions from a "words" list. */ 4096 di_words = dict_find(dict, (char_u *)"words", 5); 4097 if (di_words != NULL && di_words->di_tv.v_type == VAR_LIST) 4098 ins_compl_add_list(di_words->di_tv.vval.v_list); 4099 } 4100 4101 /* 4102 * Add a match to the list of matches from a typeval_T. 4103 * If the given string is already in the list of completions, then return 4104 * NOTDONE, otherwise add it to the list and return OK. If there is an error, 4105 * maybe because alloc() returns NULL, then FAIL is returned. 4106 */ 4107 int 4108 ins_compl_add_tv(tv, dir) 4109 typval_T *tv; 4110 int dir; 4111 { 4112 char_u *word; 4113 int icase = FALSE; 4114 int adup = FALSE; 4115 int aempty = FALSE; 4116 char_u *(cptext[CPT_COUNT]); 4117 4118 if (tv->v_type == VAR_DICT && tv->vval.v_dict != NULL) 4119 { 4120 word = get_dict_string(tv->vval.v_dict, (char_u *)"word", FALSE); 4121 cptext[CPT_ABBR] = get_dict_string(tv->vval.v_dict, 4122 (char_u *)"abbr", FALSE); 4123 cptext[CPT_MENU] = get_dict_string(tv->vval.v_dict, 4124 (char_u *)"menu", FALSE); 4125 cptext[CPT_KIND] = get_dict_string(tv->vval.v_dict, 4126 (char_u *)"kind", FALSE); 4127 cptext[CPT_INFO] = get_dict_string(tv->vval.v_dict, 4128 (char_u *)"info", FALSE); 4129 if (get_dict_string(tv->vval.v_dict, (char_u *)"icase", FALSE) != NULL) 4130 icase = get_dict_number(tv->vval.v_dict, (char_u *)"icase"); 4131 if (get_dict_string(tv->vval.v_dict, (char_u *)"dup", FALSE) != NULL) 4132 adup = get_dict_number(tv->vval.v_dict, (char_u *)"dup"); 4133 if (get_dict_string(tv->vval.v_dict, (char_u *)"empty", FALSE) != NULL) 4134 aempty = get_dict_number(tv->vval.v_dict, (char_u *)"empty"); 4135 } 4136 else 4137 { 4138 word = get_tv_string_chk(tv); 4139 vim_memset(cptext, 0, sizeof(cptext)); 4140 } 4141 if (word == NULL || (!aempty && *word == NUL)) 4142 return FAIL; 4143 return ins_compl_add(word, -1, icase, NULL, cptext, dir, 0, adup); 4144 } 4145 #endif 4146 4147 /* 4148 * Get the next expansion(s), using "compl_pattern". 4149 * The search starts at position "ini" in curbuf and in the direction 4150 * compl_direction. 4151 * When "compl_started" is FALSE start at that position, otherwise continue 4152 * where we stopped searching before. 4153 * This may return before finding all the matches. 4154 * Return the total number of matches or -1 if still unknown -- Acevedo 4155 */ 4156 static int 4157 ins_compl_get_exp(ini) 4158 pos_T *ini; 4159 { 4160 static pos_T first_match_pos; 4161 static pos_T last_match_pos; 4162 static char_u *e_cpt = (char_u *)""; /* curr. entry in 'complete' */ 4163 static int found_all = FALSE; /* Found all matches of a 4164 certain type. */ 4165 static buf_T *ins_buf = NULL; /* buffer being scanned */ 4166 4167 pos_T *pos; 4168 char_u **matches; 4169 int save_p_scs; 4170 int save_p_ws; 4171 int save_p_ic; 4172 int i; 4173 int num_matches; 4174 int len; 4175 int found_new_match; 4176 int type = ctrl_x_mode; 4177 char_u *ptr; 4178 char_u *dict = NULL; 4179 int dict_f = 0; 4180 compl_T *old_match; 4181 4182 if (!compl_started) 4183 { 4184 for (ins_buf = firstbuf; ins_buf != NULL; ins_buf = ins_buf->b_next) 4185 ins_buf->b_scanned = 0; 4186 found_all = FALSE; 4187 ins_buf = curbuf; 4188 e_cpt = (compl_cont_status & CONT_LOCAL) 4189 ? (char_u *)"." : curbuf->b_p_cpt; 4190 last_match_pos = first_match_pos = *ini; 4191 } 4192 4193 old_match = compl_curr_match; /* remember the last current match */ 4194 pos = (compl_direction == FORWARD) ? &last_match_pos : &first_match_pos; 4195 /* For ^N/^P loop over all the flags/windows/buffers in 'complete' */ 4196 for (;;) 4197 { 4198 found_new_match = FAIL; 4199 4200 /* For ^N/^P pick a new entry from e_cpt if compl_started is off, 4201 * or if found_all says this entry is done. For ^X^L only use the 4202 * entries from 'complete' that look in loaded buffers. */ 4203 if ((ctrl_x_mode == 0 || ctrl_x_mode == CTRL_X_WHOLE_LINE) 4204 && (!compl_started || found_all)) 4205 { 4206 found_all = FALSE; 4207 while (*e_cpt == ',' || *e_cpt == ' ') 4208 e_cpt++; 4209 if (*e_cpt == '.' && !curbuf->b_scanned) 4210 { 4211 ins_buf = curbuf; 4212 first_match_pos = *ini; 4213 /* So that ^N can match word immediately after cursor */ 4214 if (ctrl_x_mode == 0) 4215 dec(&first_match_pos); 4216 last_match_pos = first_match_pos; 4217 type = 0; 4218 } 4219 else if (vim_strchr((char_u *)"buwU", *e_cpt) != NULL 4220 && (ins_buf = ins_compl_next_buf(ins_buf, *e_cpt)) != curbuf) 4221 { 4222 /* Scan a buffer, but not the current one. */ 4223 if (ins_buf->b_ml.ml_mfp != NULL) /* loaded buffer */ 4224 { 4225 compl_started = TRUE; 4226 first_match_pos.col = last_match_pos.col = 0; 4227 first_match_pos.lnum = ins_buf->b_ml.ml_line_count + 1; 4228 last_match_pos.lnum = 0; 4229 type = 0; 4230 } 4231 else /* unloaded buffer, scan like dictionary */ 4232 { 4233 found_all = TRUE; 4234 if (ins_buf->b_fname == NULL) 4235 continue; 4236 type = CTRL_X_DICTIONARY; 4237 dict = ins_buf->b_fname; 4238 dict_f = DICT_EXACT; 4239 } 4240 vim_snprintf((char *)IObuff, IOSIZE, _("Scanning: %s"), 4241 ins_buf->b_fname == NULL 4242 ? buf_spname(ins_buf) 4243 : ins_buf->b_sfname == NULL 4244 ? ins_buf->b_fname 4245 : ins_buf->b_sfname); 4246 (void)msg_trunc_attr(IObuff, TRUE, hl_attr(HLF_R)); 4247 } 4248 else if (*e_cpt == NUL) 4249 break; 4250 else 4251 { 4252 if (ctrl_x_mode == CTRL_X_WHOLE_LINE) 4253 type = -1; 4254 else if (*e_cpt == 'k' || *e_cpt == 's') 4255 { 4256 if (*e_cpt == 'k') 4257 type = CTRL_X_DICTIONARY; 4258 else 4259 type = CTRL_X_THESAURUS; 4260 if (*++e_cpt != ',' && *e_cpt != NUL) 4261 { 4262 dict = e_cpt; 4263 dict_f = DICT_FIRST; 4264 } 4265 } 4266 #ifdef FEAT_FIND_ID 4267 else if (*e_cpt == 'i') 4268 type = CTRL_X_PATH_PATTERNS; 4269 else if (*e_cpt == 'd') 4270 type = CTRL_X_PATH_DEFINES; 4271 #endif 4272 else if (*e_cpt == ']' || *e_cpt == 't') 4273 { 4274 type = CTRL_X_TAGS; 4275 vim_snprintf((char *)IObuff, IOSIZE, _("Scanning tags.")); 4276 (void)msg_trunc_attr(IObuff, TRUE, hl_attr(HLF_R)); 4277 } 4278 else 4279 type = -1; 4280 4281 /* in any case e_cpt is advanced to the next entry */ 4282 (void)copy_option_part(&e_cpt, IObuff, IOSIZE, ","); 4283 4284 found_all = TRUE; 4285 if (type == -1) 4286 continue; 4287 } 4288 } 4289 4290 switch (type) 4291 { 4292 case -1: 4293 break; 4294 #ifdef FEAT_FIND_ID 4295 case CTRL_X_PATH_PATTERNS: 4296 case CTRL_X_PATH_DEFINES: 4297 find_pattern_in_path(compl_pattern, compl_direction, 4298 (int)STRLEN(compl_pattern), FALSE, FALSE, 4299 (type == CTRL_X_PATH_DEFINES 4300 && !(compl_cont_status & CONT_SOL)) 4301 ? FIND_DEFINE : FIND_ANY, 1L, ACTION_EXPAND, 4302 (linenr_T)1, (linenr_T)MAXLNUM); 4303 break; 4304 #endif 4305 4306 case CTRL_X_DICTIONARY: 4307 case CTRL_X_THESAURUS: 4308 ins_compl_dictionaries( 4309 dict != NULL ? dict 4310 : (type == CTRL_X_THESAURUS 4311 ? (*curbuf->b_p_tsr == NUL 4312 ? p_tsr 4313 : curbuf->b_p_tsr) 4314 : (*curbuf->b_p_dict == NUL 4315 ? p_dict 4316 : curbuf->b_p_dict)), 4317 compl_pattern, 4318 dict != NULL ? dict_f 4319 : 0, type == CTRL_X_THESAURUS); 4320 dict = NULL; 4321 break; 4322 4323 case CTRL_X_TAGS: 4324 /* set p_ic according to p_ic, p_scs and pat for find_tags(). */ 4325 save_p_ic = p_ic; 4326 p_ic = ignorecase(compl_pattern); 4327 4328 /* Find up to TAG_MANY matches. Avoids that an enormous number 4329 * of matches is found when compl_pattern is empty */ 4330 if (find_tags(compl_pattern, &num_matches, &matches, 4331 TAG_REGEXP | TAG_NAMES | TAG_NOIC | 4332 TAG_INS_COMP | (ctrl_x_mode ? TAG_VERBOSE : 0), 4333 TAG_MANY, curbuf->b_ffname) == OK && num_matches > 0) 4334 { 4335 ins_compl_add_matches(num_matches, matches, p_ic); 4336 } 4337 p_ic = save_p_ic; 4338 break; 4339 4340 case CTRL_X_FILES: 4341 if (expand_wildcards(1, &compl_pattern, &num_matches, &matches, 4342 EW_FILE|EW_DIR|EW_ADDSLASH|EW_SILENT) == OK) 4343 { 4344 4345 /* May change home directory back to "~". */ 4346 tilde_replace(compl_pattern, num_matches, matches); 4347 ins_compl_add_matches(num_matches, matches, p_fic || p_wic); 4348 } 4349 break; 4350 4351 case CTRL_X_CMDLINE: 4352 if (expand_cmdline(&compl_xp, compl_pattern, 4353 (int)STRLEN(compl_pattern), 4354 &num_matches, &matches) == EXPAND_OK) 4355 ins_compl_add_matches(num_matches, matches, FALSE); 4356 break; 4357 4358 #ifdef FEAT_COMPL_FUNC 4359 case CTRL_X_FUNCTION: 4360 case CTRL_X_OMNI: 4361 expand_by_function(type, compl_pattern); 4362 break; 4363 #endif 4364 4365 case CTRL_X_SPELL: 4366 #ifdef FEAT_SPELL 4367 num_matches = expand_spelling(first_match_pos.lnum, 4368 compl_pattern, &matches); 4369 if (num_matches > 0) 4370 ins_compl_add_matches(num_matches, matches, p_ic); 4371 #endif 4372 break; 4373 4374 default: /* normal ^P/^N and ^X^L */ 4375 /* 4376 * If 'infercase' is set, don't use 'smartcase' here 4377 */ 4378 save_p_scs = p_scs; 4379 if (ins_buf->b_p_inf) 4380 p_scs = FALSE; 4381 4382 /* buffers other than curbuf are scanned from the beginning or the 4383 * end but never from the middle, thus setting nowrapscan in this 4384 * buffers is a good idea, on the other hand, we always set 4385 * wrapscan for curbuf to avoid missing matches -- Acevedo,Webb */ 4386 save_p_ws = p_ws; 4387 if (ins_buf != curbuf) 4388 p_ws = FALSE; 4389 else if (*e_cpt == '.') 4390 p_ws = TRUE; 4391 for (;;) 4392 { 4393 int flags = 0; 4394 4395 ++msg_silent; /* Don't want messages for wrapscan. */ 4396 4397 /* ctrl_x_mode == CTRL_X_WHOLE_LINE || word-wise search that 4398 * has added a word that was at the beginning of the line */ 4399 if ( ctrl_x_mode == CTRL_X_WHOLE_LINE 4400 || (compl_cont_status & CONT_SOL)) 4401 found_new_match = search_for_exact_line(ins_buf, pos, 4402 compl_direction, compl_pattern); 4403 else 4404 found_new_match = searchit(NULL, ins_buf, pos, 4405 compl_direction, 4406 compl_pattern, 1L, SEARCH_KEEP + SEARCH_NFMSG, 4407 RE_LAST, (linenr_T)0, NULL); 4408 --msg_silent; 4409 if (!compl_started) 4410 { 4411 /* set "compl_started" even on fail */ 4412 compl_started = TRUE; 4413 first_match_pos = *pos; 4414 last_match_pos = *pos; 4415 } 4416 else if (first_match_pos.lnum == last_match_pos.lnum 4417 && first_match_pos.col == last_match_pos.col) 4418 found_new_match = FAIL; 4419 if (found_new_match == FAIL) 4420 { 4421 if (ins_buf == curbuf) 4422 found_all = TRUE; 4423 break; 4424 } 4425 4426 /* when ADDING, the text before the cursor matches, skip it */ 4427 if ( (compl_cont_status & CONT_ADDING) && ins_buf == curbuf 4428 && ini->lnum == pos->lnum 4429 && ini->col == pos->col) 4430 continue; 4431 ptr = ml_get_buf(ins_buf, pos->lnum, FALSE) + pos->col; 4432 if (ctrl_x_mode == CTRL_X_WHOLE_LINE) 4433 { 4434 if (compl_cont_status & CONT_ADDING) 4435 { 4436 if (pos->lnum >= ins_buf->b_ml.ml_line_count) 4437 continue; 4438 ptr = ml_get_buf(ins_buf, pos->lnum + 1, FALSE); 4439 if (!p_paste) 4440 ptr = skipwhite(ptr); 4441 } 4442 len = (int)STRLEN(ptr); 4443 } 4444 else 4445 { 4446 char_u *tmp_ptr = ptr; 4447 4448 if (compl_cont_status & CONT_ADDING) 4449 { 4450 tmp_ptr += compl_length; 4451 /* Skip if already inside a word. */ 4452 if (vim_iswordp(tmp_ptr)) 4453 continue; 4454 /* Find start of next word. */ 4455 tmp_ptr = find_word_start(tmp_ptr); 4456 } 4457 /* Find end of this word. */ 4458 tmp_ptr = find_word_end(tmp_ptr); 4459 len = (int)(tmp_ptr - ptr); 4460 4461 if ((compl_cont_status & CONT_ADDING) 4462 && len == compl_length) 4463 { 4464 if (pos->lnum < ins_buf->b_ml.ml_line_count) 4465 { 4466 /* Try next line, if any. the new word will be 4467 * "join" as if the normal command "J" was used. 4468 * IOSIZE is always greater than 4469 * compl_length, so the next STRNCPY always 4470 * works -- Acevedo */ 4471 STRNCPY(IObuff, ptr, len); 4472 ptr = ml_get_buf(ins_buf, pos->lnum + 1, FALSE); 4473 tmp_ptr = ptr = skipwhite(ptr); 4474 /* Find start of next word. */ 4475 tmp_ptr = find_word_start(tmp_ptr); 4476 /* Find end of next word. */ 4477 tmp_ptr = find_word_end(tmp_ptr); 4478 if (tmp_ptr > ptr) 4479 { 4480 if (*ptr != ')' && IObuff[len - 1] != TAB) 4481 { 4482 if (IObuff[len - 1] != ' ') 4483 IObuff[len++] = ' '; 4484 /* IObuf =~ "\k.* ", thus len >= 2 */ 4485 if (p_js 4486 && (IObuff[len - 2] == '.' 4487 || (vim_strchr(p_cpo, CPO_JOINSP) 4488 == NULL 4489 && (IObuff[len - 2] == '?' 4490 || IObuff[len - 2] == '!')))) 4491 IObuff[len++] = ' '; 4492 } 4493 /* copy as much as possible of the new word */ 4494 if (tmp_ptr - ptr >= IOSIZE - len) 4495 tmp_ptr = ptr + IOSIZE - len - 1; 4496 STRNCPY(IObuff + len, ptr, tmp_ptr - ptr); 4497 len += (int)(tmp_ptr - ptr); 4498 flags |= CONT_S_IPOS; 4499 } 4500 IObuff[len] = NUL; 4501 ptr = IObuff; 4502 } 4503 if (len == compl_length) 4504 continue; 4505 } 4506 } 4507 if (ins_compl_add_infercase(ptr, len, p_ic, 4508 ins_buf == curbuf ? NULL : ins_buf->b_sfname, 4509 0, flags) != NOTDONE) 4510 { 4511 found_new_match = OK; 4512 break; 4513 } 4514 } 4515 p_scs = save_p_scs; 4516 p_ws = save_p_ws; 4517 } 4518 4519 /* check if compl_curr_match has changed, (e.g. other type of 4520 * expansion added something) */ 4521 if (type != 0 && compl_curr_match != old_match) 4522 found_new_match = OK; 4523 4524 /* break the loop for specialized modes (use 'complete' just for the 4525 * generic ctrl_x_mode == 0) or when we've found a new match */ 4526 if ((ctrl_x_mode != 0 && ctrl_x_mode != CTRL_X_WHOLE_LINE) 4527 || found_new_match != FAIL) 4528 { 4529 if (got_int) 4530 break; 4531 /* Fill the popup menu as soon as possible. */ 4532 if (type != -1) 4533 ins_compl_check_keys(0); 4534 4535 if ((ctrl_x_mode != 0 && ctrl_x_mode != CTRL_X_WHOLE_LINE) 4536 || compl_interrupted) 4537 break; 4538 compl_started = TRUE; 4539 } 4540 else 4541 { 4542 /* Mark a buffer scanned when it has been scanned completely */ 4543 if (type == 0 || type == CTRL_X_PATH_PATTERNS) 4544 ins_buf->b_scanned = TRUE; 4545 4546 compl_started = FALSE; 4547 } 4548 } 4549 compl_started = TRUE; 4550 4551 if ((ctrl_x_mode == 0 || ctrl_x_mode == CTRL_X_WHOLE_LINE) 4552 && *e_cpt == NUL) /* Got to end of 'complete' */ 4553 found_new_match = FAIL; 4554 4555 i = -1; /* total of matches, unknown */ 4556 if (found_new_match == FAIL 4557 || (ctrl_x_mode != 0 && ctrl_x_mode != CTRL_X_WHOLE_LINE)) 4558 i = ins_compl_make_cyclic(); 4559 4560 /* If several matches were added (FORWARD) or the search failed and has 4561 * just been made cyclic then we have to move compl_curr_match to the next 4562 * or previous entry (if any) -- Acevedo */ 4563 compl_curr_match = compl_direction == FORWARD ? old_match->cp_next 4564 : old_match->cp_prev; 4565 if (compl_curr_match == NULL) 4566 compl_curr_match = old_match; 4567 return i; 4568 } 4569 4570 /* Delete the old text being completed. */ 4571 static void 4572 ins_compl_delete() 4573 { 4574 int i; 4575 4576 /* 4577 * In insert mode: Delete the typed part. 4578 * In replace mode: Put the old characters back, if any. 4579 */ 4580 i = compl_col + (compl_cont_status & CONT_ADDING ? compl_length : 0); 4581 backspace_until_column(i); 4582 changed_cline_bef_curs(); 4583 } 4584 4585 /* Insert the new text being completed. */ 4586 static void 4587 ins_compl_insert() 4588 { 4589 ins_bytes(compl_shown_match->cp_str + ins_compl_len()); 4590 if (compl_shown_match->cp_flags & ORIGINAL_TEXT) 4591 compl_used_match = FALSE; 4592 else 4593 compl_used_match = TRUE; 4594 } 4595 4596 /* 4597 * Fill in the next completion in the current direction. 4598 * If "allow_get_expansion" is TRUE, then we may call ins_compl_get_exp() to 4599 * get more completions. If it is FALSE, then we just do nothing when there 4600 * are no more completions in a given direction. The latter case is used when 4601 * we are still in the middle of finding completions, to allow browsing 4602 * through the ones found so far. 4603 * Return the total number of matches, or -1 if still unknown -- webb. 4604 * 4605 * compl_curr_match is currently being used by ins_compl_get_exp(), so we use 4606 * compl_shown_match here. 4607 * 4608 * Note that this function may be called recursively once only. First with 4609 * "allow_get_expansion" TRUE, which calls ins_compl_get_exp(), which in turn 4610 * calls this function with "allow_get_expansion" FALSE. 4611 */ 4612 static int 4613 ins_compl_next(allow_get_expansion, count, insert_match) 4614 int allow_get_expansion; 4615 int count; /* repeat completion this many times; should 4616 be at least 1 */ 4617 int insert_match; /* Insert the newly selected match */ 4618 { 4619 int num_matches = -1; 4620 int i; 4621 int todo = count; 4622 compl_T *found_compl = NULL; 4623 int found_end = FALSE; 4624 int advance; 4625 4626 /* When user complete function return -1 for findstart which is next 4627 * time of 'always', compl_shown_match become NULL. */ 4628 if (compl_shown_match == NULL) 4629 return -1; 4630 4631 if (compl_leader != NULL 4632 && (compl_shown_match->cp_flags & ORIGINAL_TEXT) == 0) 4633 { 4634 /* Set "compl_shown_match" to the actually shown match, it may differ 4635 * when "compl_leader" is used to omit some of the matches. */ 4636 while (!ins_compl_equal(compl_shown_match, 4637 compl_leader, (int)STRLEN(compl_leader)) 4638 && compl_shown_match->cp_next != NULL 4639 && compl_shown_match->cp_next != compl_first_match) 4640 compl_shown_match = compl_shown_match->cp_next; 4641 4642 /* If we didn't find it searching forward, and compl_shows_dir is 4643 * backward, find the last match. */ 4644 if (compl_shows_dir == BACKWARD 4645 && !ins_compl_equal(compl_shown_match, 4646 compl_leader, (int)STRLEN(compl_leader)) 4647 && (compl_shown_match->cp_next == NULL 4648 || compl_shown_match->cp_next == compl_first_match)) 4649 { 4650 while (!ins_compl_equal(compl_shown_match, 4651 compl_leader, (int)STRLEN(compl_leader)) 4652 && compl_shown_match->cp_prev != NULL 4653 && compl_shown_match->cp_prev != compl_first_match) 4654 compl_shown_match = compl_shown_match->cp_prev; 4655 } 4656 } 4657 4658 if (allow_get_expansion && insert_match 4659 && (!(compl_get_longest || compl_restarting) || compl_used_match)) 4660 /* Delete old text to be replaced */ 4661 ins_compl_delete(); 4662 4663 /* When finding the longest common text we stick at the original text, 4664 * don't let CTRL-N or CTRL-P move to the first match. */ 4665 advance = count != 1 || !allow_get_expansion || !compl_get_longest; 4666 4667 /* When restarting the search don't insert the first match either. */ 4668 if (compl_restarting) 4669 { 4670 advance = FALSE; 4671 compl_restarting = FALSE; 4672 } 4673 4674 /* Repeat this for when <PageUp> or <PageDown> is typed. But don't wrap 4675 * around. */ 4676 while (--todo >= 0) 4677 { 4678 if (compl_shows_dir == FORWARD && compl_shown_match->cp_next != NULL) 4679 { 4680 compl_shown_match = compl_shown_match->cp_next; 4681 found_end = (compl_first_match != NULL 4682 && (compl_shown_match->cp_next == compl_first_match 4683 || compl_shown_match == compl_first_match)); 4684 } 4685 else if (compl_shows_dir == BACKWARD 4686 && compl_shown_match->cp_prev != NULL) 4687 { 4688 found_end = (compl_shown_match == compl_first_match); 4689 compl_shown_match = compl_shown_match->cp_prev; 4690 found_end |= (compl_shown_match == compl_first_match); 4691 } 4692 else 4693 { 4694 if (!allow_get_expansion) 4695 { 4696 if (advance) 4697 { 4698 if (compl_shows_dir == BACKWARD) 4699 compl_pending -= todo + 1; 4700 else 4701 compl_pending += todo + 1; 4702 } 4703 return -1; 4704 } 4705 4706 if (advance) 4707 { 4708 if (compl_shows_dir == BACKWARD) 4709 --compl_pending; 4710 else 4711 ++compl_pending; 4712 } 4713 4714 /* Find matches. */ 4715 num_matches = ins_compl_get_exp(&compl_startpos); 4716 4717 /* handle any pending completions */ 4718 while (compl_pending != 0 && compl_direction == compl_shows_dir 4719 && advance) 4720 { 4721 if (compl_pending > 0 && compl_shown_match->cp_next != NULL) 4722 { 4723 compl_shown_match = compl_shown_match->cp_next; 4724 --compl_pending; 4725 } 4726 if (compl_pending < 0 && compl_shown_match->cp_prev != NULL) 4727 { 4728 compl_shown_match = compl_shown_match->cp_prev; 4729 ++compl_pending; 4730 } 4731 else 4732 break; 4733 } 4734 found_end = FALSE; 4735 } 4736 if ((compl_shown_match->cp_flags & ORIGINAL_TEXT) == 0 4737 && compl_leader != NULL 4738 && !ins_compl_equal(compl_shown_match, 4739 compl_leader, (int)STRLEN(compl_leader))) 4740 ++todo; 4741 else 4742 /* Remember a matching item. */ 4743 found_compl = compl_shown_match; 4744 4745 /* Stop at the end of the list when we found a usable match. */ 4746 if (found_end) 4747 { 4748 if (found_compl != NULL) 4749 { 4750 compl_shown_match = found_compl; 4751 break; 4752 } 4753 todo = 1; /* use first usable match after wrapping around */ 4754 } 4755 } 4756 4757 /* Insert the text of the new completion, or the compl_leader. */ 4758 if (insert_match) 4759 { 4760 if (!compl_get_longest || compl_used_match) 4761 ins_compl_insert(); 4762 else 4763 ins_bytes(compl_leader + ins_compl_len()); 4764 } 4765 else 4766 compl_used_match = FALSE; 4767 4768 if (!allow_get_expansion) 4769 { 4770 /* may undisplay the popup menu first */ 4771 ins_compl_upd_pum(); 4772 4773 /* redraw to show the user what was inserted */ 4774 update_screen(0); 4775 4776 /* display the updated popup menu */ 4777 ins_compl_show_pum(); 4778 #ifdef FEAT_GUI 4779 if (gui.in_use) 4780 { 4781 /* Show the cursor after the match, not after the redrawn text. */ 4782 setcursor(); 4783 out_flush(); 4784 gui_update_cursor(FALSE, FALSE); 4785 } 4786 #endif 4787 4788 /* Delete old text to be replaced, since we're still searching and 4789 * don't want to match ourselves! */ 4790 ins_compl_delete(); 4791 } 4792 4793 /* Enter will select a match when the match wasn't inserted and the popup 4794 * menu is visible. */ 4795 compl_enter_selects = !insert_match && compl_match_array != NULL; 4796 4797 /* 4798 * Show the file name for the match (if any) 4799 * Truncate the file name to avoid a wait for return. 4800 */ 4801 if (compl_shown_match->cp_fname != NULL) 4802 { 4803 STRCPY(IObuff, "match in file "); 4804 i = (vim_strsize(compl_shown_match->cp_fname) + 16) - sc_col; 4805 if (i <= 0) 4806 i = 0; 4807 else 4808 STRCAT(IObuff, "<"); 4809 STRCAT(IObuff, compl_shown_match->cp_fname + i); 4810 msg(IObuff); 4811 redraw_cmdline = FALSE; /* don't overwrite! */ 4812 } 4813 4814 return num_matches; 4815 } 4816 4817 /* 4818 * Call this while finding completions, to check whether the user has hit a key 4819 * that should change the currently displayed completion, or exit completion 4820 * mode. Also, when compl_pending is not zero, show a completion as soon as 4821 * possible. -- webb 4822 * "frequency" specifies out of how many calls we actually check. 4823 */ 4824 void 4825 ins_compl_check_keys(frequency) 4826 int frequency; 4827 { 4828 static int count = 0; 4829 4830 int c; 4831 4832 /* Don't check when reading keys from a script. That would break the test 4833 * scripts */ 4834 if (using_script()) 4835 return; 4836 4837 /* Only do this at regular intervals */ 4838 if (++count < frequency) 4839 return; 4840 count = 0; 4841 4842 /* Check for a typed key. Do use mappings, otherwise vim_is_ctrl_x_key() 4843 * can't do its work correctly. */ 4844 c = vpeekc_any(); 4845 if (c != NUL) 4846 { 4847 if (vim_is_ctrl_x_key(c) && c != Ctrl_X && c != Ctrl_R) 4848 { 4849 c = safe_vgetc(); /* Eat the character */ 4850 compl_shows_dir = ins_compl_key2dir(c); 4851 (void)ins_compl_next(FALSE, ins_compl_key2count(c), 4852 c != K_UP && c != K_DOWN); 4853 } 4854 else 4855 { 4856 /* Need to get the character to have KeyTyped set. We'll put it 4857 * back with vungetc() below. But skip K_IGNORE. */ 4858 c = safe_vgetc(); 4859 if (c != K_IGNORE) 4860 { 4861 /* Don't interrupt completion when the character wasn't typed, 4862 * e.g., when doing @q to replay keys. */ 4863 if (c != Ctrl_R && KeyTyped) 4864 compl_interrupted = TRUE; 4865 4866 vungetc(c); 4867 } 4868 } 4869 } 4870 if (compl_pending != 0 && !got_int) 4871 { 4872 int todo = compl_pending > 0 ? compl_pending : -compl_pending; 4873 4874 compl_pending = 0; 4875 (void)ins_compl_next(FALSE, todo, TRUE); 4876 } 4877 } 4878 4879 /* 4880 * Decide the direction of Insert mode complete from the key typed. 4881 * Returns BACKWARD or FORWARD. 4882 */ 4883 static int 4884 ins_compl_key2dir(c) 4885 int c; 4886 { 4887 if (c == Ctrl_P || c == Ctrl_L 4888 || (pum_visible() && (c == K_PAGEUP || c == K_KPAGEUP 4889 || c == K_S_UP || c == K_UP))) 4890 return BACKWARD; 4891 return FORWARD; 4892 } 4893 4894 /* 4895 * Return TRUE for keys that are used for completion only when the popup menu 4896 * is visible. 4897 */ 4898 static int 4899 ins_compl_pum_key(c) 4900 int c; 4901 { 4902 return pum_visible() && (c == K_PAGEUP || c == K_KPAGEUP || c == K_S_UP 4903 || c == K_PAGEDOWN || c == K_KPAGEDOWN || c == K_S_DOWN 4904 || c == K_UP || c == K_DOWN); 4905 } 4906 4907 /* 4908 * Decide the number of completions to move forward. 4909 * Returns 1 for most keys, height of the popup menu for page-up/down keys. 4910 */ 4911 static int 4912 ins_compl_key2count(c) 4913 int c; 4914 { 4915 int h; 4916 4917 if (ins_compl_pum_key(c) && c != K_UP && c != K_DOWN) 4918 { 4919 h = pum_get_height(); 4920 if (h > 3) 4921 h -= 2; /* keep some context */ 4922 return h; 4923 } 4924 return 1; 4925 } 4926 4927 /* 4928 * Return TRUE if completion with "c" should insert the match, FALSE if only 4929 * to change the currently selected completion. 4930 */ 4931 static int 4932 ins_compl_use_match(c) 4933 int c; 4934 { 4935 switch (c) 4936 { 4937 case K_UP: 4938 case K_DOWN: 4939 case K_PAGEDOWN: 4940 case K_KPAGEDOWN: 4941 case K_S_DOWN: 4942 case K_PAGEUP: 4943 case K_KPAGEUP: 4944 case K_S_UP: 4945 return FALSE; 4946 } 4947 return TRUE; 4948 } 4949 4950 /* 4951 * Do Insert mode completion. 4952 * Called when character "c" was typed, which has a meaning for completion. 4953 * Returns OK if completion was done, FAIL if something failed (out of mem). 4954 */ 4955 static int 4956 ins_complete(c) 4957 int c; 4958 { 4959 char_u *line; 4960 int startcol = 0; /* column where searched text starts */ 4961 colnr_T curs_col; /* cursor column */ 4962 int n; 4963 int save_w_wrow; 4964 4965 compl_direction = ins_compl_key2dir(c); 4966 if (!compl_started) 4967 { 4968 /* First time we hit ^N or ^P (in a row, I mean) */ 4969 4970 did_ai = FALSE; 4971 #ifdef FEAT_SMARTINDENT 4972 did_si = FALSE; 4973 can_si = FALSE; 4974 can_si_back = FALSE; 4975 #endif 4976 if (stop_arrow() == FAIL) 4977 return FAIL; 4978 4979 line = ml_get(curwin->w_cursor.lnum); 4980 curs_col = curwin->w_cursor.col; 4981 compl_pending = 0; 4982 4983 /* If this same ctrl_x_mode has been interrupted use the text from 4984 * "compl_startpos" to the cursor as a pattern to add a new word 4985 * instead of expand the one before the cursor, in word-wise if 4986 * "compl_startpos" is not in the same line as the cursor then fix it 4987 * (the line has been split because it was longer than 'tw'). if SOL 4988 * is set then skip the previous pattern, a word at the beginning of 4989 * the line has been inserted, we'll look for that -- Acevedo. */ 4990 if ((compl_cont_status & CONT_INTRPT) == CONT_INTRPT 4991 && compl_cont_mode == ctrl_x_mode) 4992 { 4993 /* 4994 * it is a continued search 4995 */ 4996 compl_cont_status &= ~CONT_INTRPT; /* remove INTRPT */ 4997 if (ctrl_x_mode == 0 || ctrl_x_mode == CTRL_X_PATH_PATTERNS 4998 || ctrl_x_mode == CTRL_X_PATH_DEFINES) 4999 { 5000 if (compl_startpos.lnum != curwin->w_cursor.lnum) 5001 { 5002 /* line (probably) wrapped, set compl_startpos to the 5003 * first non_blank in the line, if it is not a wordchar 5004 * include it to get a better pattern, but then we don't 5005 * want the "\\<" prefix, check it bellow */ 5006 compl_col = (colnr_T)(skipwhite(line) - line); 5007 compl_startpos.col = compl_col; 5008 compl_startpos.lnum = curwin->w_cursor.lnum; 5009 compl_cont_status &= ~CONT_SOL; /* clear SOL if present */ 5010 } 5011 else 5012 { 5013 /* S_IPOS was set when we inserted a word that was at the 5014 * beginning of the line, which means that we'll go to SOL 5015 * mode but first we need to redefine compl_startpos */ 5016 if (compl_cont_status & CONT_S_IPOS) 5017 { 5018 compl_cont_status |= CONT_SOL; 5019 compl_startpos.col = (colnr_T)(skipwhite( 5020 line + compl_length 5021 + compl_startpos.col) - line); 5022 } 5023 compl_col = compl_startpos.col; 5024 } 5025 compl_length = curwin->w_cursor.col - (int)compl_col; 5026 /* IObuff is used to add a "word from the next line" would we 5027 * have enough space? just being paranoid */ 5028 #define MIN_SPACE 75 5029 if (compl_length > (IOSIZE - MIN_SPACE)) 5030 { 5031 compl_cont_status &= ~CONT_SOL; 5032 compl_length = (IOSIZE - MIN_SPACE); 5033 compl_col = curwin->w_cursor.col - compl_length; 5034 } 5035 compl_cont_status |= CONT_ADDING | CONT_N_ADDS; 5036 if (compl_length < 1) 5037 compl_cont_status &= CONT_LOCAL; 5038 } 5039 else if (ctrl_x_mode == CTRL_X_WHOLE_LINE) 5040 compl_cont_status = CONT_ADDING | CONT_N_ADDS; 5041 else 5042 compl_cont_status = 0; 5043 } 5044 else 5045 compl_cont_status &= CONT_LOCAL; 5046 5047 if (!(compl_cont_status & CONT_ADDING)) /* normal expansion */ 5048 { 5049 compl_cont_mode = ctrl_x_mode; 5050 if (ctrl_x_mode != 0) /* Remove LOCAL if ctrl_x_mode != 0 */ 5051 compl_cont_status = 0; 5052 compl_cont_status |= CONT_N_ADDS; 5053 compl_startpos = curwin->w_cursor; 5054 startcol = (int)curs_col; 5055 compl_col = 0; 5056 } 5057 5058 /* Work out completion pattern and original text -- webb */ 5059 if (ctrl_x_mode == 0 || (ctrl_x_mode & CTRL_X_WANT_IDENT)) 5060 { 5061 if ((compl_cont_status & CONT_SOL) 5062 || ctrl_x_mode == CTRL_X_PATH_DEFINES) 5063 { 5064 if (!(compl_cont_status & CONT_ADDING)) 5065 { 5066 while (--startcol >= 0 && vim_isIDc(line[startcol])) 5067 ; 5068 compl_col += ++startcol; 5069 compl_length = curs_col - startcol; 5070 } 5071 if (p_ic) 5072 compl_pattern = str_foldcase(line + compl_col, 5073 compl_length, NULL, 0); 5074 else 5075 compl_pattern = vim_strnsave(line + compl_col, 5076 compl_length); 5077 if (compl_pattern == NULL) 5078 return FAIL; 5079 } 5080 else if (compl_cont_status & CONT_ADDING) 5081 { 5082 char_u *prefix = (char_u *)"\\<"; 5083 5084 /* we need up to 2 extra chars for the prefix */ 5085 compl_pattern = alloc(quote_meta(NULL, line + compl_col, 5086 compl_length) + 2); 5087 if (compl_pattern == NULL) 5088 return FAIL; 5089 if (!vim_iswordp(line + compl_col) 5090 || (compl_col > 0 5091 && ( 5092 #ifdef FEAT_MBYTE 5093 vim_iswordp(mb_prevptr(line, line + compl_col)) 5094 #else 5095 vim_iswordc(line[compl_col - 1]) 5096 #endif 5097 ))) 5098 prefix = (char_u *)""; 5099 STRCPY((char *)compl_pattern, prefix); 5100 (void)quote_meta(compl_pattern + STRLEN(prefix), 5101 line + compl_col, compl_length); 5102 } 5103 else if (--startcol < 0 || 5104 #ifdef FEAT_MBYTE 5105 !vim_iswordp(mb_prevptr(line, line + startcol + 1)) 5106 #else 5107 !vim_iswordc(line[startcol]) 5108 #endif 5109 ) 5110 { 5111 /* Match any word of at least two chars */ 5112 compl_pattern = vim_strsave((char_u *)"\\<\\k\\k"); 5113 if (compl_pattern == NULL) 5114 return FAIL; 5115 compl_col += curs_col; 5116 compl_length = 0; 5117 } 5118 else 5119 { 5120 #ifdef FEAT_MBYTE 5121 /* Search the point of change class of multibyte character 5122 * or not a word single byte character backward. */ 5123 if (has_mbyte) 5124 { 5125 int base_class; 5126 int head_off; 5127 5128 startcol -= (*mb_head_off)(line, line + startcol); 5129 base_class = mb_get_class(line + startcol); 5130 while (--startcol >= 0) 5131 { 5132 head_off = (*mb_head_off)(line, line + startcol); 5133 if (base_class != mb_get_class(line + startcol 5134 - head_off)) 5135 break; 5136 startcol -= head_off; 5137 } 5138 } 5139 else 5140 #endif 5141 while (--startcol >= 0 && vim_iswordc(line[startcol])) 5142 ; 5143 compl_col += ++startcol; 5144 compl_length = (int)curs_col - startcol; 5145 if (compl_length == 1) 5146 { 5147 /* Only match word with at least two chars -- webb 5148 * there's no need to call quote_meta, 5149 * alloc(7) is enough -- Acevedo 5150 */ 5151 compl_pattern = alloc(7); 5152 if (compl_pattern == NULL) 5153 return FAIL; 5154 STRCPY((char *)compl_pattern, "\\<"); 5155 (void)quote_meta(compl_pattern + 2, line + compl_col, 1); 5156 STRCAT((char *)compl_pattern, "\\k"); 5157 } 5158 else 5159 { 5160 compl_pattern = alloc(quote_meta(NULL, line + compl_col, 5161 compl_length) + 2); 5162 if (compl_pattern == NULL) 5163 return FAIL; 5164 STRCPY((char *)compl_pattern, "\\<"); 5165 (void)quote_meta(compl_pattern + 2, line + compl_col, 5166 compl_length); 5167 } 5168 } 5169 } 5170 else if (ctrl_x_mode == CTRL_X_WHOLE_LINE) 5171 { 5172 compl_col = (colnr_T)(skipwhite(line) - line); 5173 compl_length = (int)curs_col - (int)compl_col; 5174 if (compl_length < 0) /* cursor in indent: empty pattern */ 5175 compl_length = 0; 5176 if (p_ic) 5177 compl_pattern = str_foldcase(line + compl_col, compl_length, 5178 NULL, 0); 5179 else 5180 compl_pattern = vim_strnsave(line + compl_col, compl_length); 5181 if (compl_pattern == NULL) 5182 return FAIL; 5183 } 5184 else if (ctrl_x_mode == CTRL_X_FILES) 5185 { 5186 while (--startcol >= 0 && vim_isfilec(line[startcol])) 5187 ; 5188 compl_col += ++startcol; 5189 compl_length = (int)curs_col - startcol; 5190 compl_pattern = addstar(line + compl_col, compl_length, 5191 EXPAND_FILES); 5192 if (compl_pattern == NULL) 5193 return FAIL; 5194 } 5195 else if (ctrl_x_mode == CTRL_X_CMDLINE) 5196 { 5197 compl_pattern = vim_strnsave(line, curs_col); 5198 if (compl_pattern == NULL) 5199 return FAIL; 5200 set_cmd_context(&compl_xp, compl_pattern, 5201 (int)STRLEN(compl_pattern), curs_col); 5202 if (compl_xp.xp_context == EXPAND_UNSUCCESSFUL 5203 || compl_xp.xp_context == EXPAND_NOTHING) 5204 /* No completion possible, use an empty pattern to get a 5205 * "pattern not found" message. */ 5206 compl_col = curs_col; 5207 else 5208 compl_col = (int)(compl_xp.xp_pattern - compl_pattern); 5209 compl_length = curs_col - compl_col; 5210 } 5211 else if (ctrl_x_mode == CTRL_X_FUNCTION || ctrl_x_mode == CTRL_X_OMNI) 5212 { 5213 #ifdef FEAT_COMPL_FUNC 5214 /* 5215 * Call user defined function 'completefunc' with "a:findstart" 5216 * set to 1 to obtain the length of text to use for completion. 5217 */ 5218 char_u *args[2]; 5219 int col; 5220 char_u *funcname; 5221 pos_T pos; 5222 win_T *curwin_save; 5223 buf_T *curbuf_save; 5224 5225 /* Call 'completefunc' or 'omnifunc' and get pattern length as a 5226 * string */ 5227 funcname = ctrl_x_mode == CTRL_X_FUNCTION 5228 ? curbuf->b_p_cfu : curbuf->b_p_ofu; 5229 if (*funcname == NUL) 5230 { 5231 EMSG2(_(e_notset), ctrl_x_mode == CTRL_X_FUNCTION 5232 ? "completefunc" : "omnifunc"); 5233 return FAIL; 5234 } 5235 5236 args[0] = (char_u *)"1"; 5237 args[1] = NULL; 5238 pos = curwin->w_cursor; 5239 curwin_save = curwin; 5240 curbuf_save = curbuf; 5241 col = call_func_retnr(funcname, 2, args, FALSE); 5242 if (curwin_save != curwin || curbuf_save != curbuf) 5243 { 5244 EMSG(_(e_complwin)); 5245 return FAIL; 5246 } 5247 curwin->w_cursor = pos; /* restore the cursor position */ 5248 check_cursor(); 5249 if (!equalpos(curwin->w_cursor, pos)) 5250 { 5251 EMSG(_(e_compldel)); 5252 return FAIL; 5253 } 5254 5255 /* Return value -2 means the user complete function wants to 5256 * cancel the complete without an error. 5257 * Return value -3 does the same as -2 and leaves CTRL-X mode.*/ 5258 if (col == -2) 5259 return FAIL; 5260 if (col == -3) 5261 { 5262 ctrl_x_mode = 0; 5263 edit_submode = NULL; 5264 msg_clr_cmdline(); 5265 return FAIL; 5266 } 5267 5268 /* 5269 * Reset extended parameters of completion, when start new 5270 * completion. 5271 */ 5272 compl_opt_refresh_always = FALSE; 5273 5274 if (col < 0) 5275 col = curs_col; 5276 compl_col = col; 5277 if (compl_col > curs_col) 5278 compl_col = curs_col; 5279 5280 /* Setup variables for completion. Need to obtain "line" again, 5281 * it may have become invalid. */ 5282 line = ml_get(curwin->w_cursor.lnum); 5283 compl_length = curs_col - compl_col; 5284 compl_pattern = vim_strnsave(line + compl_col, compl_length); 5285 if (compl_pattern == NULL) 5286 #endif 5287 return FAIL; 5288 } 5289 else if (ctrl_x_mode == CTRL_X_SPELL) 5290 { 5291 #ifdef FEAT_SPELL 5292 if (spell_bad_len > 0) 5293 compl_col = curs_col - spell_bad_len; 5294 else 5295 compl_col = spell_word_start(startcol); 5296 if (compl_col >= (colnr_T)startcol) 5297 { 5298 compl_length = 0; 5299 compl_col = curs_col; 5300 } 5301 else 5302 { 5303 spell_expand_check_cap(compl_col); 5304 compl_length = (int)curs_col - compl_col; 5305 } 5306 /* Need to obtain "line" again, it may have become invalid. */ 5307 line = ml_get(curwin->w_cursor.lnum); 5308 compl_pattern = vim_strnsave(line + compl_col, compl_length); 5309 if (compl_pattern == NULL) 5310 #endif 5311 return FAIL; 5312 } 5313 else 5314 { 5315 EMSG2(_(e_intern2), "ins_complete()"); 5316 return FAIL; 5317 } 5318 5319 if (compl_cont_status & CONT_ADDING) 5320 { 5321 edit_submode_pre = (char_u *)_(" Adding"); 5322 if (ctrl_x_mode == CTRL_X_WHOLE_LINE) 5323 { 5324 /* Insert a new line, keep indentation but ignore 'comments' */ 5325 #ifdef FEAT_COMMENTS 5326 char_u *old = curbuf->b_p_com; 5327 5328 curbuf->b_p_com = (char_u *)""; 5329 #endif 5330 compl_startpos.lnum = curwin->w_cursor.lnum; 5331 compl_startpos.col = compl_col; 5332 ins_eol('\r'); 5333 #ifdef FEAT_COMMENTS 5334 curbuf->b_p_com = old; 5335 #endif 5336 compl_length = 0; 5337 compl_col = curwin->w_cursor.col; 5338 } 5339 } 5340 else 5341 { 5342 edit_submode_pre = NULL; 5343 compl_startpos.col = compl_col; 5344 } 5345 5346 if (compl_cont_status & CONT_LOCAL) 5347 edit_submode = (char_u *)_(ctrl_x_msgs[CTRL_X_LOCAL_MSG]); 5348 else 5349 edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode)); 5350 5351 /* If any of the original typed text has been changed we need to fix 5352 * the redo buffer. */ 5353 ins_compl_fixRedoBufForLeader(NULL); 5354 5355 /* Always add completion for the original text. */ 5356 vim_free(compl_orig_text); 5357 compl_orig_text = vim_strnsave(line + compl_col, compl_length); 5358 if (compl_orig_text == NULL || ins_compl_add(compl_orig_text, 5359 -1, p_ic, NULL, NULL, 0, ORIGINAL_TEXT, FALSE) != OK) 5360 { 5361 vim_free(compl_pattern); 5362 compl_pattern = NULL; 5363 vim_free(compl_orig_text); 5364 compl_orig_text = NULL; 5365 return FAIL; 5366 } 5367 5368 /* showmode might reset the internal line pointers, so it must 5369 * be called before line = ml_get(), or when this address is no 5370 * longer needed. -- Acevedo. 5371 */ 5372 edit_submode_extra = (char_u *)_("-- Searching..."); 5373 edit_submode_highl = HLF_COUNT; 5374 showmode(); 5375 edit_submode_extra = NULL; 5376 out_flush(); 5377 } 5378 5379 compl_shown_match = compl_curr_match; 5380 compl_shows_dir = compl_direction; 5381 5382 /* 5383 * Find next match (and following matches). 5384 */ 5385 save_w_wrow = curwin->w_wrow; 5386 n = ins_compl_next(TRUE, ins_compl_key2count(c), ins_compl_use_match(c)); 5387 5388 /* may undisplay the popup menu */ 5389 ins_compl_upd_pum(); 5390 5391 if (n > 1) /* all matches have been found */ 5392 compl_matches = n; 5393 compl_curr_match = compl_shown_match; 5394 compl_direction = compl_shows_dir; 5395 5396 /* Eat the ESC that vgetc() returns after a CTRL-C to avoid leaving Insert 5397 * mode. */ 5398 if (got_int && !global_busy) 5399 { 5400 (void)vgetc(); 5401 got_int = FALSE; 5402 } 5403 5404 /* we found no match if the list has only the "compl_orig_text"-entry */ 5405 if (compl_first_match == compl_first_match->cp_next) 5406 { 5407 edit_submode_extra = (compl_cont_status & CONT_ADDING) 5408 && compl_length > 1 5409 ? (char_u *)_(e_hitend) : (char_u *)_(e_patnotf); 5410 edit_submode_highl = HLF_E; 5411 /* remove N_ADDS flag, so next ^X<> won't try to go to ADDING mode, 5412 * because we couldn't expand anything at first place, but if we used 5413 * ^P, ^N, ^X^I or ^X^D we might want to add-expand a single-char-word 5414 * (such as M in M'exico) if not tried already. -- Acevedo */ 5415 if ( compl_length > 1 5416 || (compl_cont_status & CONT_ADDING) 5417 || (ctrl_x_mode != 0 5418 && ctrl_x_mode != CTRL_X_PATH_PATTERNS 5419 && ctrl_x_mode != CTRL_X_PATH_DEFINES)) 5420 compl_cont_status &= ~CONT_N_ADDS; 5421 } 5422 5423 if (compl_curr_match->cp_flags & CONT_S_IPOS) 5424 compl_cont_status |= CONT_S_IPOS; 5425 else 5426 compl_cont_status &= ~CONT_S_IPOS; 5427 5428 if (edit_submode_extra == NULL) 5429 { 5430 if (compl_curr_match->cp_flags & ORIGINAL_TEXT) 5431 { 5432 edit_submode_extra = (char_u *)_("Back at original"); 5433 edit_submode_highl = HLF_W; 5434 } 5435 else if (compl_cont_status & CONT_S_IPOS) 5436 { 5437 edit_submode_extra = (char_u *)_("Word from other line"); 5438 edit_submode_highl = HLF_COUNT; 5439 } 5440 else if (compl_curr_match->cp_next == compl_curr_match->cp_prev) 5441 { 5442 edit_submode_extra = (char_u *)_("The only match"); 5443 edit_submode_highl = HLF_COUNT; 5444 } 5445 else 5446 { 5447 /* Update completion sequence number when needed. */ 5448 if (compl_curr_match->cp_number == -1) 5449 { 5450 int number = 0; 5451 compl_T *match; 5452 5453 if (compl_direction == FORWARD) 5454 { 5455 /* search backwards for the first valid (!= -1) number. 5456 * This should normally succeed already at the first loop 5457 * cycle, so it's fast! */ 5458 for (match = compl_curr_match->cp_prev; match != NULL 5459 && match != compl_first_match; 5460 match = match->cp_prev) 5461 if (match->cp_number != -1) 5462 { 5463 number = match->cp_number; 5464 break; 5465 } 5466 if (match != NULL) 5467 /* go up and assign all numbers which are not assigned 5468 * yet */ 5469 for (match = match->cp_next; 5470 match != NULL && match->cp_number == -1; 5471 match = match->cp_next) 5472 match->cp_number = ++number; 5473 } 5474 else /* BACKWARD */ 5475 { 5476 /* search forwards (upwards) for the first valid (!= -1) 5477 * number. This should normally succeed already at the 5478 * first loop cycle, so it's fast! */ 5479 for (match = compl_curr_match->cp_next; match != NULL 5480 && match != compl_first_match; 5481 match = match->cp_next) 5482 if (match->cp_number != -1) 5483 { 5484 number = match->cp_number; 5485 break; 5486 } 5487 if (match != NULL) 5488 /* go down and assign all numbers which are not 5489 * assigned yet */ 5490 for (match = match->cp_prev; match 5491 && match->cp_number == -1; 5492 match = match->cp_prev) 5493 match->cp_number = ++number; 5494 } 5495 } 5496 5497 /* The match should always have a sequence number now, this is 5498 * just a safety check. */ 5499 if (compl_curr_match->cp_number != -1) 5500 { 5501 /* Space for 10 text chars. + 2x10-digit no.s = 31. 5502 * Translations may need more than twice that. */ 5503 static char_u match_ref[81]; 5504 5505 if (compl_matches > 0) 5506 vim_snprintf((char *)match_ref, sizeof(match_ref), 5507 _("match %d of %d"), 5508 compl_curr_match->cp_number, compl_matches); 5509 else 5510 vim_snprintf((char *)match_ref, sizeof(match_ref), 5511 _("match %d"), 5512 compl_curr_match->cp_number); 5513 edit_submode_extra = match_ref; 5514 edit_submode_highl = HLF_R; 5515 if (dollar_vcol >= 0) 5516 curs_columns(FALSE); 5517 } 5518 } 5519 } 5520 5521 /* Show a message about what (completion) mode we're in. */ 5522 showmode(); 5523 if (edit_submode_extra != NULL) 5524 { 5525 if (!p_smd) 5526 msg_attr(edit_submode_extra, 5527 edit_submode_highl < HLF_COUNT 5528 ? hl_attr(edit_submode_highl) : 0); 5529 } 5530 else 5531 msg_clr_cmdline(); /* necessary for "noshowmode" */ 5532 5533 /* Show the popup menu, unless we got interrupted. */ 5534 if (!compl_interrupted) 5535 { 5536 /* RedrawingDisabled may be set when invoked through complete(). */ 5537 n = RedrawingDisabled; 5538 RedrawingDisabled = 0; 5539 5540 /* If the cursor moved we need to remove the pum first. */ 5541 setcursor(); 5542 if (save_w_wrow != curwin->w_wrow) 5543 ins_compl_del_pum(); 5544 5545 ins_compl_show_pum(); 5546 setcursor(); 5547 RedrawingDisabled = n; 5548 } 5549 compl_was_interrupted = compl_interrupted; 5550 compl_interrupted = FALSE; 5551 5552 return OK; 5553 } 5554 5555 /* 5556 * Looks in the first "len" chars. of "src" for search-metachars. 5557 * If dest is not NULL the chars. are copied there quoting (with 5558 * a backslash) the metachars, and dest would be NUL terminated. 5559 * Returns the length (needed) of dest 5560 */ 5561 static unsigned 5562 quote_meta(dest, src, len) 5563 char_u *dest; 5564 char_u *src; 5565 int len; 5566 { 5567 unsigned m = (unsigned)len + 1; /* one extra for the NUL */ 5568 5569 for ( ; --len >= 0; src++) 5570 { 5571 switch (*src) 5572 { 5573 case '.': 5574 case '*': 5575 case '[': 5576 if (ctrl_x_mode == CTRL_X_DICTIONARY 5577 || ctrl_x_mode == CTRL_X_THESAURUS) 5578 break; 5579 case '~': 5580 if (!p_magic) /* quote these only if magic is set */ 5581 break; 5582 case '\\': 5583 if (ctrl_x_mode == CTRL_X_DICTIONARY 5584 || ctrl_x_mode == CTRL_X_THESAURUS) 5585 break; 5586 case '^': /* currently it's not needed. */ 5587 case '$': 5588 m++; 5589 if (dest != NULL) 5590 *dest++ = '\\'; 5591 break; 5592 } 5593 if (dest != NULL) 5594 *dest++ = *src; 5595 # ifdef FEAT_MBYTE 5596 /* Copy remaining bytes of a multibyte character. */ 5597 if (has_mbyte) 5598 { 5599 int i, mb_len; 5600 5601 mb_len = (*mb_ptr2len)(src) - 1; 5602 if (mb_len > 0 && len >= mb_len) 5603 for (i = 0; i < mb_len; ++i) 5604 { 5605 --len; 5606 ++src; 5607 if (dest != NULL) 5608 *dest++ = *src; 5609 } 5610 } 5611 # endif 5612 } 5613 if (dest != NULL) 5614 *dest = NUL; 5615 5616 return m; 5617 } 5618 #endif /* FEAT_INS_EXPAND */ 5619 5620 /* 5621 * Next character is interpreted literally. 5622 * A one, two or three digit decimal number is interpreted as its byte value. 5623 * If one or two digits are entered, the next character is given to vungetc(). 5624 * For Unicode a character > 255 may be returned. 5625 */ 5626 int 5627 get_literal() 5628 { 5629 int cc; 5630 int nc; 5631 int i; 5632 int hex = FALSE; 5633 int octal = FALSE; 5634 #ifdef FEAT_MBYTE 5635 int unicode = 0; 5636 #endif 5637 5638 if (got_int) 5639 return Ctrl_C; 5640 5641 #ifdef FEAT_GUI 5642 /* 5643 * In GUI there is no point inserting the internal code for a special key. 5644 * It is more useful to insert the string "<KEY>" instead. This would 5645 * probably be useful in a text window too, but it would not be 5646 * vi-compatible (maybe there should be an option for it?) -- webb 5647 */ 5648 if (gui.in_use) 5649 ++allow_keys; 5650 #endif 5651 #ifdef USE_ON_FLY_SCROLL 5652 dont_scroll = TRUE; /* disallow scrolling here */ 5653 #endif 5654 ++no_mapping; /* don't map the next key hits */ 5655 cc = 0; 5656 i = 0; 5657 for (;;) 5658 { 5659 nc = plain_vgetc(); 5660 #ifdef FEAT_CMDL_INFO 5661 if (!(State & CMDLINE) 5662 # ifdef FEAT_MBYTE 5663 && MB_BYTE2LEN_CHECK(nc) == 1 5664 # endif 5665 ) 5666 add_to_showcmd(nc); 5667 #endif 5668 if (nc == 'x' || nc == 'X') 5669 hex = TRUE; 5670 else if (nc == 'o' || nc == 'O') 5671 octal = TRUE; 5672 #ifdef FEAT_MBYTE 5673 else if (nc == 'u' || nc == 'U') 5674 unicode = nc; 5675 #endif 5676 else 5677 { 5678 if (hex 5679 #ifdef FEAT_MBYTE 5680 || unicode != 0 5681 #endif 5682 ) 5683 { 5684 if (!vim_isxdigit(nc)) 5685 break; 5686 cc = cc * 16 + hex2nr(nc); 5687 } 5688 else if (octal) 5689 { 5690 if (nc < '0' || nc > '7') 5691 break; 5692 cc = cc * 8 + nc - '0'; 5693 } 5694 else 5695 { 5696 if (!VIM_ISDIGIT(nc)) 5697 break; 5698 cc = cc * 10 + nc - '0'; 5699 } 5700 5701 ++i; 5702 } 5703 5704 if (cc > 255 5705 #ifdef FEAT_MBYTE 5706 && unicode == 0 5707 #endif 5708 ) 5709 cc = 255; /* limit range to 0-255 */ 5710 nc = 0; 5711 5712 if (hex) /* hex: up to two chars */ 5713 { 5714 if (i >= 2) 5715 break; 5716 } 5717 #ifdef FEAT_MBYTE 5718 else if (unicode) /* Unicode: up to four or eight chars */ 5719 { 5720 if ((unicode == 'u' && i >= 4) || (unicode == 'U' && i >= 8)) 5721 break; 5722 } 5723 #endif 5724 else if (i >= 3) /* decimal or octal: up to three chars */ 5725 break; 5726 } 5727 if (i == 0) /* no number entered */ 5728 { 5729 if (nc == K_ZERO) /* NUL is stored as NL */ 5730 { 5731 cc = '\n'; 5732 nc = 0; 5733 } 5734 else 5735 { 5736 cc = nc; 5737 nc = 0; 5738 } 5739 } 5740 5741 if (cc == 0) /* NUL is stored as NL */ 5742 cc = '\n'; 5743 #ifdef FEAT_MBYTE 5744 if (enc_dbcs && (cc & 0xff) == 0) 5745 cc = '?'; /* don't accept an illegal DBCS char, the NUL in the 5746 second byte will cause trouble! */ 5747 #endif 5748 5749 --no_mapping; 5750 #ifdef FEAT_GUI 5751 if (gui.in_use) 5752 --allow_keys; 5753 #endif 5754 if (nc) 5755 vungetc(nc); 5756 got_int = FALSE; /* CTRL-C typed after CTRL-V is not an interrupt */ 5757 return cc; 5758 } 5759 5760 /* 5761 * Insert character, taking care of special keys and mod_mask 5762 */ 5763 static void 5764 insert_special(c, allow_modmask, ctrlv) 5765 int c; 5766 int allow_modmask; 5767 int ctrlv; /* c was typed after CTRL-V */ 5768 { 5769 char_u *p; 5770 int len; 5771 5772 /* 5773 * Special function key, translate into "<Key>". Up to the last '>' is 5774 * inserted with ins_str(), so as not to replace characters in replace 5775 * mode. 5776 * Only use mod_mask for special keys, to avoid things like <S-Space>, 5777 * unless 'allow_modmask' is TRUE. 5778 */ 5779 #ifdef MACOS 5780 /* Command-key never produces a normal key */ 5781 if (mod_mask & MOD_MASK_CMD) 5782 allow_modmask = TRUE; 5783 #endif 5784 if (IS_SPECIAL(c) || (mod_mask && allow_modmask)) 5785 { 5786 p = get_special_key_name(c, mod_mask); 5787 len = (int)STRLEN(p); 5788 c = p[len - 1]; 5789 if (len > 2) 5790 { 5791 if (stop_arrow() == FAIL) 5792 return; 5793 p[len - 1] = NUL; 5794 ins_str(p); 5795 AppendToRedobuffLit(p, -1); 5796 ctrlv = FALSE; 5797 } 5798 } 5799 if (stop_arrow() == OK) 5800 insertchar(c, ctrlv ? INSCHAR_CTRLV : 0, -1); 5801 } 5802 5803 /* 5804 * Special characters in this context are those that need processing other 5805 * than the simple insertion that can be performed here. This includes ESC 5806 * which terminates the insert, and CR/NL which need special processing to 5807 * open up a new line. This routine tries to optimize insertions performed by 5808 * the "redo", "undo" or "put" commands, so it needs to know when it should 5809 * stop and defer processing to the "normal" mechanism. 5810 * '0' and '^' are special, because they can be followed by CTRL-D. 5811 */ 5812 #ifdef EBCDIC 5813 # define ISSPECIAL(c) ((c) < ' ' || (c) == '0' || (c) == '^') 5814 #else 5815 # define ISSPECIAL(c) ((c) < ' ' || (c) >= DEL || (c) == '0' || (c) == '^') 5816 #endif 5817 5818 #ifdef FEAT_MBYTE 5819 # define WHITECHAR(cc) (vim_iswhite(cc) && (!enc_utf8 || !utf_iscomposing(utf_ptr2char(ml_get_cursor() + 1)))) 5820 #else 5821 # define WHITECHAR(cc) vim_iswhite(cc) 5822 #endif 5823 5824 /* 5825 * "flags": INSCHAR_FORMAT - force formatting 5826 * INSCHAR_CTRLV - char typed just after CTRL-V 5827 * INSCHAR_NO_FEX - don't use 'formatexpr' 5828 * 5829 * NOTE: passes the flags value straight through to internal_format() which, 5830 * beside INSCHAR_FORMAT (above), is also looking for these: 5831 * INSCHAR_DO_COM - format comments 5832 * INSCHAR_COM_LIST - format comments with num list or 2nd line indent 5833 */ 5834 void 5835 insertchar(c, flags, second_indent) 5836 int c; /* character to insert or NUL */ 5837 int flags; /* INSCHAR_FORMAT, etc. */ 5838 int second_indent; /* indent for second line if >= 0 */ 5839 { 5840 int textwidth; 5841 #ifdef FEAT_COMMENTS 5842 char_u *p; 5843 #endif 5844 int fo_ins_blank; 5845 5846 textwidth = comp_textwidth(flags & INSCHAR_FORMAT); 5847 fo_ins_blank = has_format_option(FO_INS_BLANK); 5848 5849 /* 5850 * Try to break the line in two or more pieces when: 5851 * - Always do this if we have been called to do formatting only. 5852 * - Always do this when 'formatoptions' has the 'a' flag and the line 5853 * ends in white space. 5854 * - Otherwise: 5855 * - Don't do this if inserting a blank 5856 * - Don't do this if an existing character is being replaced, unless 5857 * we're in VREPLACE mode. 5858 * - Do this if the cursor is not on the line where insert started 5859 * or - 'formatoptions' doesn't have 'l' or the line was not too long 5860 * before the insert. 5861 * - 'formatoptions' doesn't have 'b' or a blank was inserted at or 5862 * before 'textwidth' 5863 */ 5864 if (textwidth > 0 5865 && ((flags & INSCHAR_FORMAT) 5866 || (!vim_iswhite(c) 5867 && !((State & REPLACE_FLAG) 5868 #ifdef FEAT_VREPLACE 5869 && !(State & VREPLACE_FLAG) 5870 #endif 5871 && *ml_get_cursor() != NUL) 5872 && (curwin->w_cursor.lnum != Insstart.lnum 5873 || ((!has_format_option(FO_INS_LONG) 5874 || Insstart_textlen <= (colnr_T)textwidth) 5875 && (!fo_ins_blank 5876 || Insstart_blank_vcol <= (colnr_T)textwidth 5877 )))))) 5878 { 5879 /* Format with 'formatexpr' when it's set. Use internal formatting 5880 * when 'formatexpr' isn't set or it returns non-zero. */ 5881 #if defined(FEAT_EVAL) 5882 int do_internal = TRUE; 5883 5884 if (*curbuf->b_p_fex != NUL && (flags & INSCHAR_NO_FEX) == 0) 5885 { 5886 do_internal = (fex_format(curwin->w_cursor.lnum, 1L, c) != 0); 5887 /* It may be required to save for undo again, e.g. when setline() 5888 * was called. */ 5889 ins_need_undo = TRUE; 5890 } 5891 if (do_internal) 5892 #endif 5893 internal_format(textwidth, second_indent, flags, c == NUL, c); 5894 } 5895 5896 if (c == NUL) /* only formatting was wanted */ 5897 return; 5898 5899 #ifdef FEAT_COMMENTS 5900 /* Check whether this character should end a comment. */ 5901 if (did_ai && (int)c == end_comment_pending) 5902 { 5903 char_u *line; 5904 char_u lead_end[COM_MAX_LEN]; /* end-comment string */ 5905 int middle_len, end_len; 5906 int i; 5907 5908 /* 5909 * Need to remove existing (middle) comment leader and insert end 5910 * comment leader. First, check what comment leader we can find. 5911 */ 5912 i = get_leader_len(line = ml_get_curline(), &p, FALSE, TRUE); 5913 if (i > 0 && vim_strchr(p, COM_MIDDLE) != NULL) /* Just checking */ 5914 { 5915 /* Skip middle-comment string */ 5916 while (*p && p[-1] != ':') /* find end of middle flags */ 5917 ++p; 5918 middle_len = copy_option_part(&p, lead_end, COM_MAX_LEN, ","); 5919 /* Don't count trailing white space for middle_len */ 5920 while (middle_len > 0 && vim_iswhite(lead_end[middle_len - 1])) 5921 --middle_len; 5922 5923 /* Find the end-comment string */ 5924 while (*p && p[-1] != ':') /* find end of end flags */ 5925 ++p; 5926 end_len = copy_option_part(&p, lead_end, COM_MAX_LEN, ","); 5927 5928 /* Skip white space before the cursor */ 5929 i = curwin->w_cursor.col; 5930 while (--i >= 0 && vim_iswhite(line[i])) 5931 ; 5932 i++; 5933 5934 /* Skip to before the middle leader */ 5935 i -= middle_len; 5936 5937 /* Check some expected things before we go on */ 5938 if (i >= 0 && lead_end[end_len - 1] == end_comment_pending) 5939 { 5940 /* Backspace over all the stuff we want to replace */ 5941 backspace_until_column(i); 5942 5943 /* 5944 * Insert the end-comment string, except for the last 5945 * character, which will get inserted as normal later. 5946 */ 5947 ins_bytes_len(lead_end, end_len - 1); 5948 } 5949 } 5950 } 5951 end_comment_pending = NUL; 5952 #endif 5953 5954 did_ai = FALSE; 5955 #ifdef FEAT_SMARTINDENT 5956 did_si = FALSE; 5957 can_si = FALSE; 5958 can_si_back = FALSE; 5959 #endif 5960 5961 /* 5962 * If there's any pending input, grab up to INPUT_BUFLEN at once. 5963 * This speeds up normal text input considerably. 5964 * Don't do this when 'cindent' or 'indentexpr' is set, because we might 5965 * need to re-indent at a ':', or any other character (but not what 5966 * 'paste' is set).. 5967 * Don't do this when there an InsertCharPre autocommand is defined, 5968 * because we need to fire the event for every character. 5969 */ 5970 #ifdef USE_ON_FLY_SCROLL 5971 dont_scroll = FALSE; /* allow scrolling here */ 5972 #endif 5973 5974 if ( !ISSPECIAL(c) 5975 #ifdef FEAT_MBYTE 5976 && (!has_mbyte || (*mb_char2len)(c) == 1) 5977 #endif 5978 && vpeekc() != NUL 5979 && !(State & REPLACE_FLAG) 5980 #ifdef FEAT_CINDENT 5981 && !cindent_on() 5982 #endif 5983 #ifdef FEAT_RIGHTLEFT 5984 && !p_ri 5985 #endif 5986 #ifdef FEAT_AUTOCMD 5987 && !has_insertcharpre() 5988 #endif 5989 ) 5990 { 5991 #define INPUT_BUFLEN 100 5992 char_u buf[INPUT_BUFLEN + 1]; 5993 int i; 5994 colnr_T virtcol = 0; 5995 5996 buf[0] = c; 5997 i = 1; 5998 if (textwidth > 0) 5999 virtcol = get_nolist_virtcol(); 6000 /* 6001 * Stop the string when: 6002 * - no more chars available 6003 * - finding a special character (command key) 6004 * - buffer is full 6005 * - running into the 'textwidth' boundary 6006 * - need to check for abbreviation: A non-word char after a word-char 6007 */ 6008 while ( (c = vpeekc()) != NUL 6009 && !ISSPECIAL(c) 6010 #ifdef FEAT_MBYTE 6011 && (!has_mbyte || MB_BYTE2LEN_CHECK(c) == 1) 6012 #endif 6013 && i < INPUT_BUFLEN 6014 && (textwidth == 0 6015 || (virtcol += byte2cells(buf[i - 1])) < (colnr_T)textwidth) 6016 && !(!no_abbr && !vim_iswordc(c) && vim_iswordc(buf[i - 1]))) 6017 { 6018 #ifdef FEAT_RIGHTLEFT 6019 c = vgetc(); 6020 if (p_hkmap && KeyTyped) 6021 c = hkmap(c); /* Hebrew mode mapping */ 6022 # ifdef FEAT_FKMAP 6023 if (p_fkmap && KeyTyped) 6024 c = fkmap(c); /* Farsi mode mapping */ 6025 # endif 6026 buf[i++] = c; 6027 #else 6028 buf[i++] = vgetc(); 6029 #endif 6030 } 6031 6032 #ifdef FEAT_DIGRAPHS 6033 do_digraph(-1); /* clear digraphs */ 6034 do_digraph(buf[i-1]); /* may be the start of a digraph */ 6035 #endif 6036 buf[i] = NUL; 6037 ins_str(buf); 6038 if (flags & INSCHAR_CTRLV) 6039 { 6040 redo_literal(*buf); 6041 i = 1; 6042 } 6043 else 6044 i = 0; 6045 if (buf[i] != NUL) 6046 AppendToRedobuffLit(buf + i, -1); 6047 } 6048 else 6049 { 6050 #ifdef FEAT_MBYTE 6051 int cc; 6052 6053 if (has_mbyte && (cc = (*mb_char2len)(c)) > 1) 6054 { 6055 char_u buf[MB_MAXBYTES + 1]; 6056 6057 (*mb_char2bytes)(c, buf); 6058 buf[cc] = NUL; 6059 ins_char_bytes(buf, cc); 6060 AppendCharToRedobuff(c); 6061 } 6062 else 6063 #endif 6064 { 6065 ins_char(c); 6066 if (flags & INSCHAR_CTRLV) 6067 redo_literal(c); 6068 else 6069 AppendCharToRedobuff(c); 6070 } 6071 } 6072 } 6073 6074 /* 6075 * Format text at the current insert position. 6076 * 6077 * If the INSCHAR_COM_LIST flag is present, then the value of second_indent 6078 * will be the comment leader length sent to open_line(). 6079 */ 6080 static void 6081 internal_format(textwidth, second_indent, flags, format_only, c) 6082 int textwidth; 6083 int second_indent; 6084 int flags; 6085 int format_only; 6086 int c; /* character to be inserted (can be NUL) */ 6087 { 6088 int cc; 6089 int save_char = NUL; 6090 int haveto_redraw = FALSE; 6091 int fo_ins_blank = has_format_option(FO_INS_BLANK); 6092 #ifdef FEAT_MBYTE 6093 int fo_multibyte = has_format_option(FO_MBYTE_BREAK); 6094 #endif 6095 int fo_white_par = has_format_option(FO_WHITE_PAR); 6096 int first_line = TRUE; 6097 #ifdef FEAT_COMMENTS 6098 colnr_T leader_len; 6099 int no_leader = FALSE; 6100 int do_comments = (flags & INSCHAR_DO_COM); 6101 #endif 6102 6103 /* 6104 * When 'ai' is off we don't want a space under the cursor to be 6105 * deleted. Replace it with an 'x' temporarily. 6106 */ 6107 if (!curbuf->b_p_ai 6108 #ifdef FEAT_VREPLACE 6109 && !(State & VREPLACE_FLAG) 6110 #endif 6111 ) 6112 { 6113 cc = gchar_cursor(); 6114 if (vim_iswhite(cc)) 6115 { 6116 save_char = cc; 6117 pchar_cursor('x'); 6118 } 6119 } 6120 6121 /* 6122 * Repeat breaking lines, until the current line is not too long. 6123 */ 6124 while (!got_int) 6125 { 6126 int startcol; /* Cursor column at entry */ 6127 int wantcol; /* column at textwidth border */ 6128 int foundcol; /* column for start of spaces */ 6129 int end_foundcol = 0; /* column for start of word */ 6130 colnr_T len; 6131 colnr_T virtcol; 6132 #ifdef FEAT_VREPLACE 6133 int orig_col = 0; 6134 char_u *saved_text = NULL; 6135 #endif 6136 colnr_T col; 6137 colnr_T end_col; 6138 6139 virtcol = get_nolist_virtcol() 6140 + char2cells(c != NUL ? c : gchar_cursor()); 6141 if (virtcol <= (colnr_T)textwidth) 6142 break; 6143 6144 #ifdef FEAT_COMMENTS 6145 if (no_leader) 6146 do_comments = FALSE; 6147 else if (!(flags & INSCHAR_FORMAT) 6148 && has_format_option(FO_WRAP_COMS)) 6149 do_comments = TRUE; 6150 6151 /* Don't break until after the comment leader */ 6152 if (do_comments) 6153 leader_len = get_leader_len(ml_get_curline(), NULL, FALSE, TRUE); 6154 else 6155 leader_len = 0; 6156 6157 /* If the line doesn't start with a comment leader, then don't 6158 * start one in a following broken line. Avoids that a %word 6159 * moved to the start of the next line causes all following lines 6160 * to start with %. */ 6161 if (leader_len == 0) 6162 no_leader = TRUE; 6163 #endif 6164 if (!(flags & INSCHAR_FORMAT) 6165 #ifdef FEAT_COMMENTS 6166 && leader_len == 0 6167 #endif 6168 && !has_format_option(FO_WRAP)) 6169 6170 break; 6171 if ((startcol = curwin->w_cursor.col) == 0) 6172 break; 6173 6174 /* find column of textwidth border */ 6175 coladvance((colnr_T)textwidth); 6176 wantcol = curwin->w_cursor.col; 6177 6178 curwin->w_cursor.col = startcol; 6179 foundcol = 0; 6180 6181 /* 6182 * Find position to break at. 6183 * Stop at first entered white when 'formatoptions' has 'v' 6184 */ 6185 while ((!fo_ins_blank && !has_format_option(FO_INS_VI)) 6186 || (flags & INSCHAR_FORMAT) 6187 || curwin->w_cursor.lnum != Insstart.lnum 6188 || curwin->w_cursor.col >= Insstart.col) 6189 { 6190 if (curwin->w_cursor.col == startcol && c != NUL) 6191 cc = c; 6192 else 6193 cc = gchar_cursor(); 6194 if (WHITECHAR(cc)) 6195 { 6196 /* remember position of blank just before text */ 6197 end_col = curwin->w_cursor.col; 6198 6199 /* find start of sequence of blanks */ 6200 while (curwin->w_cursor.col > 0 && WHITECHAR(cc)) 6201 { 6202 dec_cursor(); 6203 cc = gchar_cursor(); 6204 } 6205 if (curwin->w_cursor.col == 0 && WHITECHAR(cc)) 6206 break; /* only spaces in front of text */ 6207 #ifdef FEAT_COMMENTS 6208 /* Don't break until after the comment leader */ 6209 if (curwin->w_cursor.col < leader_len) 6210 break; 6211 #endif 6212 if (has_format_option(FO_ONE_LETTER)) 6213 { 6214 /* do not break after one-letter words */ 6215 if (curwin->w_cursor.col == 0) 6216 break; /* one-letter word at begin */ 6217 #ifdef FEAT_COMMENTS 6218 /* do not break "#a b" when 'tw' is 2 */ 6219 if (curwin->w_cursor.col <= leader_len) 6220 break; 6221 #endif 6222 col = curwin->w_cursor.col; 6223 dec_cursor(); 6224 cc = gchar_cursor(); 6225 6226 if (WHITECHAR(cc)) 6227 continue; /* one-letter, continue */ 6228 curwin->w_cursor.col = col; 6229 } 6230 6231 inc_cursor(); 6232 6233 end_foundcol = end_col + 1; 6234 foundcol = curwin->w_cursor.col; 6235 if (curwin->w_cursor.col <= (colnr_T)wantcol) 6236 break; 6237 } 6238 #ifdef FEAT_MBYTE 6239 else if (cc >= 0x100 && fo_multibyte) 6240 { 6241 /* Break after or before a multi-byte character. */ 6242 if (curwin->w_cursor.col != startcol) 6243 { 6244 #ifdef FEAT_COMMENTS 6245 /* Don't break until after the comment leader */ 6246 if (curwin->w_cursor.col < leader_len) 6247 break; 6248 #endif 6249 col = curwin->w_cursor.col; 6250 inc_cursor(); 6251 /* Don't change end_foundcol if already set. */ 6252 if (foundcol != curwin->w_cursor.col) 6253 { 6254 foundcol = curwin->w_cursor.col; 6255 end_foundcol = foundcol; 6256 if (curwin->w_cursor.col <= (colnr_T)wantcol) 6257 break; 6258 } 6259 curwin->w_cursor.col = col; 6260 } 6261 6262 if (curwin->w_cursor.col == 0) 6263 break; 6264 6265 col = curwin->w_cursor.col; 6266 6267 dec_cursor(); 6268 cc = gchar_cursor(); 6269 6270 if (WHITECHAR(cc)) 6271 continue; /* break with space */ 6272 #ifdef FEAT_COMMENTS 6273 /* Don't break until after the comment leader */ 6274 if (curwin->w_cursor.col < leader_len) 6275 break; 6276 #endif 6277 6278 curwin->w_cursor.col = col; 6279 6280 foundcol = curwin->w_cursor.col; 6281 end_foundcol = foundcol; 6282 if (curwin->w_cursor.col <= (colnr_T)wantcol) 6283 break; 6284 } 6285 #endif 6286 if (curwin->w_cursor.col == 0) 6287 break; 6288 dec_cursor(); 6289 } 6290 6291 if (foundcol == 0) /* no spaces, cannot break line */ 6292 { 6293 curwin->w_cursor.col = startcol; 6294 break; 6295 } 6296 6297 /* Going to break the line, remove any "$" now. */ 6298 undisplay_dollar(); 6299 6300 /* 6301 * Offset between cursor position and line break is used by replace 6302 * stack functions. VREPLACE does not use this, and backspaces 6303 * over the text instead. 6304 */ 6305 #ifdef FEAT_VREPLACE 6306 if (State & VREPLACE_FLAG) 6307 orig_col = startcol; /* Will start backspacing from here */ 6308 else 6309 #endif 6310 replace_offset = startcol - end_foundcol; 6311 6312 /* 6313 * adjust startcol for spaces that will be deleted and 6314 * characters that will remain on top line 6315 */ 6316 curwin->w_cursor.col = foundcol; 6317 while ((cc = gchar_cursor(), WHITECHAR(cc)) 6318 && (!fo_white_par || curwin->w_cursor.col < startcol)) 6319 inc_cursor(); 6320 startcol -= curwin->w_cursor.col; 6321 if (startcol < 0) 6322 startcol = 0; 6323 6324 #ifdef FEAT_VREPLACE 6325 if (State & VREPLACE_FLAG) 6326 { 6327 /* 6328 * In VREPLACE mode, we will backspace over the text to be 6329 * wrapped, so save a copy now to put on the next line. 6330 */ 6331 saved_text = vim_strsave(ml_get_cursor()); 6332 curwin->w_cursor.col = orig_col; 6333 if (saved_text == NULL) 6334 break; /* Can't do it, out of memory */ 6335 saved_text[startcol] = NUL; 6336 6337 /* Backspace over characters that will move to the next line */ 6338 if (!fo_white_par) 6339 backspace_until_column(foundcol); 6340 } 6341 else 6342 #endif 6343 { 6344 /* put cursor after pos. to break line */ 6345 if (!fo_white_par) 6346 curwin->w_cursor.col = foundcol; 6347 } 6348 6349 /* 6350 * Split the line just before the margin. 6351 * Only insert/delete lines, but don't really redraw the window. 6352 */ 6353 open_line(FORWARD, OPENLINE_DELSPACES + OPENLINE_MARKFIX 6354 + (fo_white_par ? OPENLINE_KEEPTRAIL : 0) 6355 #ifdef FEAT_COMMENTS 6356 + (do_comments ? OPENLINE_DO_COM : 0) 6357 + ((flags & INSCHAR_COM_LIST) ? OPENLINE_COM_LIST : 0) 6358 #endif 6359 , ((flags & INSCHAR_COM_LIST) ? second_indent : old_indent)); 6360 if (!(flags & INSCHAR_COM_LIST)) 6361 old_indent = 0; 6362 6363 replace_offset = 0; 6364 if (first_line) 6365 { 6366 if (!(flags & INSCHAR_COM_LIST)) 6367 { 6368 /* 6369 * This section is for auto-wrap of numeric lists. When not 6370 * in insert mode (i.e. format_lines()), the INSCHAR_COM_LIST 6371 * flag will be set and open_line() will handle it (as seen 6372 * above). The code here (and in get_number_indent()) will 6373 * recognize comments if needed... 6374 */ 6375 if (second_indent < 0 && has_format_option(FO_Q_NUMBER)) 6376 second_indent = 6377 get_number_indent(curwin->w_cursor.lnum - 1); 6378 if (second_indent >= 0) 6379 { 6380 #ifdef FEAT_VREPLACE 6381 if (State & VREPLACE_FLAG) 6382 change_indent(INDENT_SET, second_indent, 6383 FALSE, NUL, TRUE); 6384 else 6385 #endif 6386 #ifdef FEAT_COMMENTS 6387 if (leader_len > 0 && second_indent - leader_len > 0) 6388 { 6389 int i; 6390 int padding = second_indent - leader_len; 6391 6392 /* We started at the first_line of a numbered list 6393 * that has a comment. the open_line() function has 6394 * inserted the proper comment leader and positioned 6395 * the cursor at the end of the split line. Now we 6396 * add the additional whitespace needed after the 6397 * comment leader for the numbered list. */ 6398 for (i = 0; i < padding; i++) 6399 ins_str((char_u *)" "); 6400 changed_bytes(curwin->w_cursor.lnum, leader_len); 6401 } 6402 else 6403 { 6404 #endif 6405 (void)set_indent(second_indent, SIN_CHANGED); 6406 #ifdef FEAT_COMMENTS 6407 } 6408 #endif 6409 } 6410 } 6411 first_line = FALSE; 6412 } 6413 6414 #ifdef FEAT_VREPLACE 6415 if (State & VREPLACE_FLAG) 6416 { 6417 /* 6418 * In VREPLACE mode we have backspaced over the text to be 6419 * moved, now we re-insert it into the new line. 6420 */ 6421 ins_bytes(saved_text); 6422 vim_free(saved_text); 6423 } 6424 else 6425 #endif 6426 { 6427 /* 6428 * Check if cursor is not past the NUL off the line, cindent 6429 * may have added or removed indent. 6430 */ 6431 curwin->w_cursor.col += startcol; 6432 len = (colnr_T)STRLEN(ml_get_curline()); 6433 if (curwin->w_cursor.col > len) 6434 curwin->w_cursor.col = len; 6435 } 6436 6437 haveto_redraw = TRUE; 6438 #ifdef FEAT_CINDENT 6439 can_cindent = TRUE; 6440 #endif 6441 /* moved the cursor, don't autoindent or cindent now */ 6442 did_ai = FALSE; 6443 #ifdef FEAT_SMARTINDENT 6444 did_si = FALSE; 6445 can_si = FALSE; 6446 can_si_back = FALSE; 6447 #endif 6448 line_breakcheck(); 6449 } 6450 6451 if (save_char != NUL) /* put back space after cursor */ 6452 pchar_cursor(save_char); 6453 6454 if (!format_only && haveto_redraw) 6455 { 6456 update_topline(); 6457 redraw_curbuf_later(VALID); 6458 } 6459 } 6460 6461 /* 6462 * Called after inserting or deleting text: When 'formatoptions' includes the 6463 * 'a' flag format from the current line until the end of the paragraph. 6464 * Keep the cursor at the same position relative to the text. 6465 * The caller must have saved the cursor line for undo, following ones will be 6466 * saved here. 6467 */ 6468 void 6469 auto_format(trailblank, prev_line) 6470 int trailblank; /* when TRUE also format with trailing blank */ 6471 int prev_line; /* may start in previous line */ 6472 { 6473 pos_T pos; 6474 colnr_T len; 6475 char_u *old; 6476 char_u *new, *pnew; 6477 int wasatend; 6478 int cc; 6479 6480 if (!has_format_option(FO_AUTO)) 6481 return; 6482 6483 pos = curwin->w_cursor; 6484 old = ml_get_curline(); 6485 6486 /* may remove added space */ 6487 check_auto_format(FALSE); 6488 6489 /* Don't format in Insert mode when the cursor is on a trailing blank, the 6490 * user might insert normal text next. Also skip formatting when "1" is 6491 * in 'formatoptions' and there is a single character before the cursor. 6492 * Otherwise the line would be broken and when typing another non-white 6493 * next they are not joined back together. */ 6494 wasatend = (pos.col == (colnr_T)STRLEN(old)); 6495 if (*old != NUL && !trailblank && wasatend) 6496 { 6497 dec_cursor(); 6498 cc = gchar_cursor(); 6499 if (!WHITECHAR(cc) && curwin->w_cursor.col > 0 6500 && has_format_option(FO_ONE_LETTER)) 6501 dec_cursor(); 6502 cc = gchar_cursor(); 6503 if (WHITECHAR(cc)) 6504 { 6505 curwin->w_cursor = pos; 6506 return; 6507 } 6508 curwin->w_cursor = pos; 6509 } 6510 6511 #ifdef FEAT_COMMENTS 6512 /* With the 'c' flag in 'formatoptions' and 't' missing: only format 6513 * comments. */ 6514 if (has_format_option(FO_WRAP_COMS) && !has_format_option(FO_WRAP) 6515 && get_leader_len(old, NULL, FALSE, TRUE) == 0) 6516 return; 6517 #endif 6518 6519 /* 6520 * May start formatting in a previous line, so that after "x" a word is 6521 * moved to the previous line if it fits there now. Only when this is not 6522 * the start of a paragraph. 6523 */ 6524 if (prev_line && !paragraph_start(curwin->w_cursor.lnum)) 6525 { 6526 --curwin->w_cursor.lnum; 6527 if (u_save_cursor() == FAIL) 6528 return; 6529 } 6530 6531 /* 6532 * Do the formatting and restore the cursor position. "saved_cursor" will 6533 * be adjusted for the text formatting. 6534 */ 6535 saved_cursor = pos; 6536 format_lines((linenr_T)-1, FALSE); 6537 curwin->w_cursor = saved_cursor; 6538 saved_cursor.lnum = 0; 6539 6540 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) 6541 { 6542 /* "cannot happen" */ 6543 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; 6544 coladvance((colnr_T)MAXCOL); 6545 } 6546 else 6547 check_cursor_col(); 6548 6549 /* Insert mode: If the cursor is now after the end of the line while it 6550 * previously wasn't, the line was broken. Because of the rule above we 6551 * need to add a space when 'w' is in 'formatoptions' to keep a paragraph 6552 * formatted. */ 6553 if (!wasatend && has_format_option(FO_WHITE_PAR)) 6554 { 6555 new = ml_get_curline(); 6556 len = (colnr_T)STRLEN(new); 6557 if (curwin->w_cursor.col == len) 6558 { 6559 pnew = vim_strnsave(new, len + 2); 6560 pnew[len] = ' '; 6561 pnew[len + 1] = NUL; 6562 ml_replace(curwin->w_cursor.lnum, pnew, FALSE); 6563 /* remove the space later */ 6564 did_add_space = TRUE; 6565 } 6566 else 6567 /* may remove added space */ 6568 check_auto_format(FALSE); 6569 } 6570 6571 check_cursor(); 6572 } 6573 6574 /* 6575 * When an extra space was added to continue a paragraph for auto-formatting, 6576 * delete it now. The space must be under the cursor, just after the insert 6577 * position. 6578 */ 6579 static void 6580 check_auto_format(end_insert) 6581 int end_insert; /* TRUE when ending Insert mode */ 6582 { 6583 int c = ' '; 6584 int cc; 6585 6586 if (did_add_space) 6587 { 6588 cc = gchar_cursor(); 6589 if (!WHITECHAR(cc)) 6590 /* Somehow the space was removed already. */ 6591 did_add_space = FALSE; 6592 else 6593 { 6594 if (!end_insert) 6595 { 6596 inc_cursor(); 6597 c = gchar_cursor(); 6598 dec_cursor(); 6599 } 6600 if (c != NUL) 6601 { 6602 /* The space is no longer at the end of the line, delete it. */ 6603 del_char(FALSE); 6604 did_add_space = FALSE; 6605 } 6606 } 6607 } 6608 } 6609 6610 /* 6611 * Find out textwidth to be used for formatting: 6612 * if 'textwidth' option is set, use it 6613 * else if 'wrapmargin' option is set, use W_WIDTH(curwin) - 'wrapmargin' 6614 * if invalid value, use 0. 6615 * Set default to window width (maximum 79) for "gq" operator. 6616 */ 6617 int 6618 comp_textwidth(ff) 6619 int ff; /* force formatting (for "gq" command) */ 6620 { 6621 int textwidth; 6622 6623 textwidth = curbuf->b_p_tw; 6624 if (textwidth == 0 && curbuf->b_p_wm) 6625 { 6626 /* The width is the window width minus 'wrapmargin' minus all the 6627 * things that add to the margin. */ 6628 textwidth = W_WIDTH(curwin) - curbuf->b_p_wm; 6629 #ifdef FEAT_CMDWIN 6630 if (cmdwin_type != 0) 6631 textwidth -= 1; 6632 #endif 6633 #ifdef FEAT_FOLDING 6634 textwidth -= curwin->w_p_fdc; 6635 #endif 6636 #ifdef FEAT_SIGNS 6637 if (curwin->w_buffer->b_signlist != NULL 6638 # ifdef FEAT_NETBEANS_INTG 6639 || netbeans_active() 6640 # endif 6641 ) 6642 textwidth -= 1; 6643 #endif 6644 if (curwin->w_p_nu || curwin->w_p_rnu) 6645 textwidth -= 8; 6646 } 6647 if (textwidth < 0) 6648 textwidth = 0; 6649 if (ff && textwidth == 0) 6650 { 6651 textwidth = W_WIDTH(curwin) - 1; 6652 if (textwidth > 79) 6653 textwidth = 79; 6654 } 6655 return textwidth; 6656 } 6657 6658 /* 6659 * Put a character in the redo buffer, for when just after a CTRL-V. 6660 */ 6661 static void 6662 redo_literal(c) 6663 int c; 6664 { 6665 char_u buf[10]; 6666 6667 /* Only digits need special treatment. Translate them into a string of 6668 * three digits. */ 6669 if (VIM_ISDIGIT(c)) 6670 { 6671 vim_snprintf((char *)buf, sizeof(buf), "%03d", c); 6672 AppendToRedobuff(buf); 6673 } 6674 else 6675 AppendCharToRedobuff(c); 6676 } 6677 6678 /* 6679 * start_arrow() is called when an arrow key is used in insert mode. 6680 * For undo/redo it resembles hitting the <ESC> key. 6681 */ 6682 static void 6683 start_arrow(end_insert_pos) 6684 pos_T *end_insert_pos; /* can be NULL */ 6685 { 6686 if (!arrow_used) /* something has been inserted */ 6687 { 6688 AppendToRedobuff(ESC_STR); 6689 stop_insert(end_insert_pos, FALSE); 6690 arrow_used = TRUE; /* this means we stopped the current insert */ 6691 } 6692 #ifdef FEAT_SPELL 6693 check_spell_redraw(); 6694 #endif 6695 } 6696 6697 #ifdef FEAT_SPELL 6698 /* 6699 * If we skipped highlighting word at cursor, do it now. 6700 * It may be skipped again, thus reset spell_redraw_lnum first. 6701 */ 6702 static void 6703 check_spell_redraw() 6704 { 6705 if (spell_redraw_lnum != 0) 6706 { 6707 linenr_T lnum = spell_redraw_lnum; 6708 6709 spell_redraw_lnum = 0; 6710 redrawWinline(lnum, FALSE); 6711 } 6712 } 6713 6714 /* 6715 * Called when starting CTRL_X_SPELL mode: Move backwards to a previous badly 6716 * spelled word, if there is one. 6717 */ 6718 static void 6719 spell_back_to_badword() 6720 { 6721 pos_T tpos = curwin->w_cursor; 6722 6723 spell_bad_len = spell_move_to(curwin, BACKWARD, TRUE, TRUE, NULL); 6724 if (curwin->w_cursor.col != tpos.col) 6725 start_arrow(&tpos); 6726 } 6727 #endif 6728 6729 /* 6730 * stop_arrow() is called before a change is made in insert mode. 6731 * If an arrow key has been used, start a new insertion. 6732 * Returns FAIL if undo is impossible, shouldn't insert then. 6733 */ 6734 int 6735 stop_arrow() 6736 { 6737 if (arrow_used) 6738 { 6739 if (u_save_cursor() == OK) 6740 { 6741 arrow_used = FALSE; 6742 ins_need_undo = FALSE; 6743 } 6744 Insstart = curwin->w_cursor; /* new insertion starts here */ 6745 Insstart_textlen = (colnr_T)linetabsize(ml_get_curline()); 6746 ai_col = 0; 6747 #ifdef FEAT_VREPLACE 6748 if (State & VREPLACE_FLAG) 6749 { 6750 orig_line_count = curbuf->b_ml.ml_line_count; 6751 vr_lines_changed = 1; 6752 } 6753 #endif 6754 ResetRedobuff(); 6755 AppendToRedobuff((char_u *)"1i"); /* pretend we start an insertion */ 6756 new_insert_skip = 2; 6757 } 6758 else if (ins_need_undo) 6759 { 6760 if (u_save_cursor() == OK) 6761 ins_need_undo = FALSE; 6762 } 6763 6764 #ifdef FEAT_FOLDING 6765 /* Always open fold at the cursor line when inserting something. */ 6766 foldOpenCursor(); 6767 #endif 6768 6769 return (arrow_used || ins_need_undo ? FAIL : OK); 6770 } 6771 6772 /* 6773 * Do a few things to stop inserting. 6774 * "end_insert_pos" is where insert ended. It is NULL when we already jumped 6775 * to another window/buffer. 6776 */ 6777 static void 6778 stop_insert(end_insert_pos, esc) 6779 pos_T *end_insert_pos; 6780 int esc; /* called by ins_esc() */ 6781 { 6782 int cc; 6783 char_u *ptr; 6784 6785 stop_redo_ins(); 6786 replace_flush(); /* abandon replace stack */ 6787 6788 /* 6789 * Save the inserted text for later redo with ^@ and CTRL-A. 6790 * Don't do it when "restart_edit" was set and nothing was inserted, 6791 * otherwise CTRL-O w and then <Left> will clear "last_insert". 6792 */ 6793 ptr = get_inserted(); 6794 if (did_restart_edit == 0 || (ptr != NULL 6795 && (int)STRLEN(ptr) > new_insert_skip)) 6796 { 6797 vim_free(last_insert); 6798 last_insert = ptr; 6799 last_insert_skip = new_insert_skip; 6800 } 6801 else 6802 vim_free(ptr); 6803 6804 if (!arrow_used && end_insert_pos != NULL) 6805 { 6806 /* Auto-format now. It may seem strange to do this when stopping an 6807 * insertion (or moving the cursor), but it's required when appending 6808 * a line and having it end in a space. But only do it when something 6809 * was actually inserted, otherwise undo won't work. */ 6810 if (!ins_need_undo && has_format_option(FO_AUTO)) 6811 { 6812 pos_T tpos = curwin->w_cursor; 6813 6814 /* When the cursor is at the end of the line after a space the 6815 * formatting will move it to the following word. Avoid that by 6816 * moving the cursor onto the space. */ 6817 cc = 'x'; 6818 if (curwin->w_cursor.col > 0 && gchar_cursor() == NUL) 6819 { 6820 dec_cursor(); 6821 cc = gchar_cursor(); 6822 if (!vim_iswhite(cc)) 6823 curwin->w_cursor = tpos; 6824 } 6825 6826 auto_format(TRUE, FALSE); 6827 6828 if (vim_iswhite(cc)) 6829 { 6830 if (gchar_cursor() != NUL) 6831 inc_cursor(); 6832 #ifdef FEAT_VIRTUALEDIT 6833 /* If the cursor is still at the same character, also keep 6834 * the "coladd". */ 6835 if (gchar_cursor() == NUL 6836 && curwin->w_cursor.lnum == tpos.lnum 6837 && curwin->w_cursor.col == tpos.col) 6838 curwin->w_cursor.coladd = tpos.coladd; 6839 #endif 6840 } 6841 } 6842 6843 /* If a space was inserted for auto-formatting, remove it now. */ 6844 check_auto_format(TRUE); 6845 6846 /* If we just did an auto-indent, remove the white space from the end 6847 * of the line, and put the cursor back. 6848 * Do this when ESC was used or moving the cursor up/down. 6849 * Check for the old position still being valid, just in case the text 6850 * got changed unexpectedly. */ 6851 if (did_ai && (esc || (vim_strchr(p_cpo, CPO_INDENT) == NULL 6852 && curwin->w_cursor.lnum != end_insert_pos->lnum)) 6853 && end_insert_pos->lnum <= curbuf->b_ml.ml_line_count) 6854 { 6855 pos_T tpos = curwin->w_cursor; 6856 6857 curwin->w_cursor = *end_insert_pos; 6858 check_cursor_col(); /* make sure it is not past the line */ 6859 for (;;) 6860 { 6861 if (gchar_cursor() == NUL && curwin->w_cursor.col > 0) 6862 --curwin->w_cursor.col; 6863 cc = gchar_cursor(); 6864 if (!vim_iswhite(cc)) 6865 break; 6866 if (del_char(TRUE) == FAIL) 6867 break; /* should not happen */ 6868 } 6869 if (curwin->w_cursor.lnum != tpos.lnum) 6870 curwin->w_cursor = tpos; 6871 else if (cc != NUL) 6872 ++curwin->w_cursor.col; /* put cursor back on the NUL */ 6873 6874 #ifdef FEAT_VISUAL 6875 /* <C-S-Right> may have started Visual mode, adjust the position for 6876 * deleted characters. */ 6877 if (VIsual_active && VIsual.lnum == curwin->w_cursor.lnum) 6878 { 6879 int len = (int)STRLEN(ml_get_curline()); 6880 6881 if (VIsual.col > len) 6882 { 6883 VIsual.col = len; 6884 # ifdef FEAT_VIRTUALEDIT 6885 VIsual.coladd = 0; 6886 # endif 6887 } 6888 } 6889 #endif 6890 } 6891 } 6892 did_ai = FALSE; 6893 #ifdef FEAT_SMARTINDENT 6894 did_si = FALSE; 6895 can_si = FALSE; 6896 can_si_back = FALSE; 6897 #endif 6898 6899 /* Set '[ and '] to the inserted text. When end_insert_pos is NULL we are 6900 * now in a different buffer. */ 6901 if (end_insert_pos != NULL) 6902 { 6903 curbuf->b_op_start = Insstart; 6904 curbuf->b_op_end = *end_insert_pos; 6905 } 6906 } 6907 6908 /* 6909 * Set the last inserted text to a single character. 6910 * Used for the replace command. 6911 */ 6912 void 6913 set_last_insert(c) 6914 int c; 6915 { 6916 char_u *s; 6917 6918 vim_free(last_insert); 6919 last_insert = alloc(MB_MAXBYTES * 3 + 5); 6920 if (last_insert != NULL) 6921 { 6922 s = last_insert; 6923 /* Use the CTRL-V only when entering a special char */ 6924 if (c < ' ' || c == DEL) 6925 *s++ = Ctrl_V; 6926 s = add_char2buf(c, s); 6927 *s++ = ESC; 6928 *s++ = NUL; 6929 last_insert_skip = 0; 6930 } 6931 } 6932 6933 #if defined(EXITFREE) || defined(PROTO) 6934 void 6935 free_last_insert() 6936 { 6937 vim_free(last_insert); 6938 last_insert = NULL; 6939 # ifdef FEAT_INS_EXPAND 6940 vim_free(compl_orig_text); 6941 compl_orig_text = NULL; 6942 # endif 6943 } 6944 #endif 6945 6946 /* 6947 * Add character "c" to buffer "s". Escape the special meaning of K_SPECIAL 6948 * and CSI. Handle multi-byte characters. 6949 * Returns a pointer to after the added bytes. 6950 */ 6951 char_u * 6952 add_char2buf(c, s) 6953 int c; 6954 char_u *s; 6955 { 6956 #ifdef FEAT_MBYTE 6957 char_u temp[MB_MAXBYTES + 1]; 6958 int i; 6959 int len; 6960 6961 len = (*mb_char2bytes)(c, temp); 6962 for (i = 0; i < len; ++i) 6963 { 6964 c = temp[i]; 6965 #endif 6966 /* Need to escape K_SPECIAL and CSI like in the typeahead buffer. */ 6967 if (c == K_SPECIAL) 6968 { 6969 *s++ = K_SPECIAL; 6970 *s++ = KS_SPECIAL; 6971 *s++ = KE_FILLER; 6972 } 6973 #ifdef FEAT_GUI 6974 else if (c == CSI) 6975 { 6976 *s++ = CSI; 6977 *s++ = KS_EXTRA; 6978 *s++ = (int)KE_CSI; 6979 } 6980 #endif 6981 else 6982 *s++ = c; 6983 #ifdef FEAT_MBYTE 6984 } 6985 #endif 6986 return s; 6987 } 6988 6989 /* 6990 * move cursor to start of line 6991 * if flags & BL_WHITE move to first non-white 6992 * if flags & BL_SOL move to first non-white if startofline is set, 6993 * otherwise keep "curswant" column 6994 * if flags & BL_FIX don't leave the cursor on a NUL. 6995 */ 6996 void 6997 beginline(flags) 6998 int flags; 6999 { 7000 if ((flags & BL_SOL) && !p_sol) 7001 coladvance(curwin->w_curswant); 7002 else 7003 { 7004 curwin->w_cursor.col = 0; 7005 #ifdef FEAT_VIRTUALEDIT 7006 curwin->w_cursor.coladd = 0; 7007 #endif 7008 7009 if (flags & (BL_WHITE | BL_SOL)) 7010 { 7011 char_u *ptr; 7012 7013 for (ptr = ml_get_curline(); vim_iswhite(*ptr) 7014 && !((flags & BL_FIX) && ptr[1] == NUL); ++ptr) 7015 ++curwin->w_cursor.col; 7016 } 7017 curwin->w_set_curswant = TRUE; 7018 } 7019 } 7020 7021 /* 7022 * oneright oneleft cursor_down cursor_up 7023 * 7024 * Move one char {right,left,down,up}. 7025 * Doesn't move onto the NUL past the end of the line, unless it is allowed. 7026 * Return OK when successful, FAIL when we hit a line of file boundary. 7027 */ 7028 7029 int 7030 oneright() 7031 { 7032 char_u *ptr; 7033 int l; 7034 7035 #ifdef FEAT_VIRTUALEDIT 7036 if (virtual_active()) 7037 { 7038 pos_T prevpos = curwin->w_cursor; 7039 7040 /* Adjust for multi-wide char (excluding TAB) */ 7041 ptr = ml_get_cursor(); 7042 coladvance(getviscol() + ((*ptr != TAB && vim_isprintc( 7043 # ifdef FEAT_MBYTE 7044 (*mb_ptr2char)(ptr) 7045 # else 7046 *ptr 7047 # endif 7048 )) 7049 ? ptr2cells(ptr) : 1)); 7050 curwin->w_set_curswant = TRUE; 7051 /* Return OK if the cursor moved, FAIL otherwise (at window edge). */ 7052 return (prevpos.col != curwin->w_cursor.col 7053 || prevpos.coladd != curwin->w_cursor.coladd) ? OK : FAIL; 7054 } 7055 #endif 7056 7057 ptr = ml_get_cursor(); 7058 if (*ptr == NUL) 7059 return FAIL; /* already at the very end */ 7060 7061 #ifdef FEAT_MBYTE 7062 if (has_mbyte) 7063 l = (*mb_ptr2len)(ptr); 7064 else 7065 #endif 7066 l = 1; 7067 7068 /* move "l" bytes right, but don't end up on the NUL, unless 'virtualedit' 7069 * contains "onemore". */ 7070 if (ptr[l] == NUL 7071 #ifdef FEAT_VIRTUALEDIT 7072 && (ve_flags & VE_ONEMORE) == 0 7073 #endif 7074 ) 7075 return FAIL; 7076 curwin->w_cursor.col += l; 7077 7078 curwin->w_set_curswant = TRUE; 7079 return OK; 7080 } 7081 7082 int 7083 oneleft() 7084 { 7085 #ifdef FEAT_VIRTUALEDIT 7086 if (virtual_active()) 7087 { 7088 int width; 7089 int v = getviscol(); 7090 7091 if (v == 0) 7092 return FAIL; 7093 7094 # ifdef FEAT_LINEBREAK 7095 /* We might get stuck on 'showbreak', skip over it. */ 7096 width = 1; 7097 for (;;) 7098 { 7099 coladvance(v - width); 7100 /* getviscol() is slow, skip it when 'showbreak' is empty and 7101 * there are no multi-byte characters */ 7102 if ((*p_sbr == NUL 7103 # ifdef FEAT_MBYTE 7104 && !has_mbyte 7105 # endif 7106 ) || getviscol() < v) 7107 break; 7108 ++width; 7109 } 7110 # else 7111 coladvance(v - 1); 7112 # endif 7113 7114 if (curwin->w_cursor.coladd == 1) 7115 { 7116 char_u *ptr; 7117 7118 /* Adjust for multi-wide char (not a TAB) */ 7119 ptr = ml_get_cursor(); 7120 if (*ptr != TAB && vim_isprintc( 7121 # ifdef FEAT_MBYTE 7122 (*mb_ptr2char)(ptr) 7123 # else 7124 *ptr 7125 # endif 7126 ) && ptr2cells(ptr) > 1) 7127 curwin->w_cursor.coladd = 0; 7128 } 7129 7130 curwin->w_set_curswant = TRUE; 7131 return OK; 7132 } 7133 #endif 7134 7135 if (curwin->w_cursor.col == 0) 7136 return FAIL; 7137 7138 curwin->w_set_curswant = TRUE; 7139 --curwin->w_cursor.col; 7140 7141 #ifdef FEAT_MBYTE 7142 /* if the character on the left of the current cursor is a multi-byte 7143 * character, move to its first byte */ 7144 if (has_mbyte) 7145 mb_adjust_cursor(); 7146 #endif 7147 return OK; 7148 } 7149 7150 int 7151 cursor_up(n, upd_topline) 7152 long n; 7153 int upd_topline; /* When TRUE: update topline */ 7154 { 7155 linenr_T lnum; 7156 7157 if (n > 0) 7158 { 7159 lnum = curwin->w_cursor.lnum; 7160 /* This fails if the cursor is already in the first line or the count 7161 * is larger than the line number and '-' is in 'cpoptions' */ 7162 if (lnum <= 1 || (n >= lnum && vim_strchr(p_cpo, CPO_MINUS) != NULL)) 7163 return FAIL; 7164 if (n >= lnum) 7165 lnum = 1; 7166 else 7167 #ifdef FEAT_FOLDING 7168 if (hasAnyFolding(curwin)) 7169 { 7170 /* 7171 * Count each sequence of folded lines as one logical line. 7172 */ 7173 /* go to the start of the current fold */ 7174 (void)hasFolding(lnum, &lnum, NULL); 7175 7176 while (n--) 7177 { 7178 /* move up one line */ 7179 --lnum; 7180 if (lnum <= 1) 7181 break; 7182 /* If we entered a fold, move to the beginning, unless in 7183 * Insert mode or when 'foldopen' contains "all": it will open 7184 * in a moment. */ 7185 if (n > 0 || !((State & INSERT) || (fdo_flags & FDO_ALL))) 7186 (void)hasFolding(lnum, &lnum, NULL); 7187 } 7188 if (lnum < 1) 7189 lnum = 1; 7190 } 7191 else 7192 #endif 7193 lnum -= n; 7194 curwin->w_cursor.lnum = lnum; 7195 } 7196 7197 /* try to advance to the column we want to be at */ 7198 coladvance(curwin->w_curswant); 7199 7200 if (upd_topline) 7201 update_topline(); /* make sure curwin->w_topline is valid */ 7202 7203 return OK; 7204 } 7205 7206 /* 7207 * Cursor down a number of logical lines. 7208 */ 7209 int 7210 cursor_down(n, upd_topline) 7211 long n; 7212 int upd_topline; /* When TRUE: update topline */ 7213 { 7214 linenr_T lnum; 7215 7216 if (n > 0) 7217 { 7218 lnum = curwin->w_cursor.lnum; 7219 #ifdef FEAT_FOLDING 7220 /* Move to last line of fold, will fail if it's the end-of-file. */ 7221 (void)hasFolding(lnum, NULL, &lnum); 7222 #endif 7223 /* This fails if the cursor is already in the last line or would move 7224 * beyond the last line and '-' is in 'cpoptions' */ 7225 if (lnum >= curbuf->b_ml.ml_line_count 7226 || (lnum + n > curbuf->b_ml.ml_line_count 7227 && vim_strchr(p_cpo, CPO_MINUS) != NULL)) 7228 return FAIL; 7229 if (lnum + n >= curbuf->b_ml.ml_line_count) 7230 lnum = curbuf->b_ml.ml_line_count; 7231 else 7232 #ifdef FEAT_FOLDING 7233 if (hasAnyFolding(curwin)) 7234 { 7235 linenr_T last; 7236 7237 /* count each sequence of folded lines as one logical line */ 7238 while (n--) 7239 { 7240 if (hasFolding(lnum, NULL, &last)) 7241 lnum = last + 1; 7242 else 7243 ++lnum; 7244 if (lnum >= curbuf->b_ml.ml_line_count) 7245 break; 7246 } 7247 if (lnum > curbuf->b_ml.ml_line_count) 7248 lnum = curbuf->b_ml.ml_line_count; 7249 } 7250 else 7251 #endif 7252 lnum += n; 7253 curwin->w_cursor.lnum = lnum; 7254 } 7255 7256 /* try to advance to the column we want to be at */ 7257 coladvance(curwin->w_curswant); 7258 7259 if (upd_topline) 7260 update_topline(); /* make sure curwin->w_topline is valid */ 7261 7262 return OK; 7263 } 7264 7265 /* 7266 * Stuff the last inserted text in the read buffer. 7267 * Last_insert actually is a copy of the redo buffer, so we 7268 * first have to remove the command. 7269 */ 7270 int 7271 stuff_inserted(c, count, no_esc) 7272 int c; /* Command character to be inserted */ 7273 long count; /* Repeat this many times */ 7274 int no_esc; /* Don't add an ESC at the end */ 7275 { 7276 char_u *esc_ptr; 7277 char_u *ptr; 7278 char_u *last_ptr; 7279 char_u last = NUL; 7280 7281 ptr = get_last_insert(); 7282 if (ptr == NULL) 7283 { 7284 EMSG(_(e_noinstext)); 7285 return FAIL; 7286 } 7287 7288 /* may want to stuff the command character, to start Insert mode */ 7289 if (c != NUL) 7290 stuffcharReadbuff(c); 7291 if ((esc_ptr = (char_u *)vim_strrchr(ptr, ESC)) != NULL) 7292 *esc_ptr = NUL; /* remove the ESC */ 7293 7294 /* when the last char is either "0" or "^" it will be quoted if no ESC 7295 * comes after it OR if it will inserted more than once and "ptr" 7296 * starts with ^D. -- Acevedo 7297 */ 7298 last_ptr = (esc_ptr ? esc_ptr : ptr + STRLEN(ptr)) - 1; 7299 if (last_ptr >= ptr && (*last_ptr == '0' || *last_ptr == '^') 7300 && (no_esc || (*ptr == Ctrl_D && count > 1))) 7301 { 7302 last = *last_ptr; 7303 *last_ptr = NUL; 7304 } 7305 7306 do 7307 { 7308 stuffReadbuff(ptr); 7309 /* a trailing "0" is inserted as "<C-V>048", "^" as "<C-V>^" */ 7310 if (last) 7311 stuffReadbuff((char_u *)(last == '0' 7312 ? IF_EB("\026\060\064\070", CTRL_V_STR "xf0") 7313 : IF_EB("\026^", CTRL_V_STR "^"))); 7314 } 7315 while (--count > 0); 7316 7317 if (last) 7318 *last_ptr = last; 7319 7320 if (esc_ptr != NULL) 7321 *esc_ptr = ESC; /* put the ESC back */ 7322 7323 /* may want to stuff a trailing ESC, to get out of Insert mode */ 7324 if (!no_esc) 7325 stuffcharReadbuff(ESC); 7326 7327 return OK; 7328 } 7329 7330 char_u * 7331 get_last_insert() 7332 { 7333 if (last_insert == NULL) 7334 return NULL; 7335 return last_insert + last_insert_skip; 7336 } 7337 7338 /* 7339 * Get last inserted string, and remove trailing <Esc>. 7340 * Returns pointer to allocated memory (must be freed) or NULL. 7341 */ 7342 char_u * 7343 get_last_insert_save() 7344 { 7345 char_u *s; 7346 int len; 7347 7348 if (last_insert == NULL) 7349 return NULL; 7350 s = vim_strsave(last_insert + last_insert_skip); 7351 if (s != NULL) 7352 { 7353 len = (int)STRLEN(s); 7354 if (len > 0 && s[len - 1] == ESC) /* remove trailing ESC */ 7355 s[len - 1] = NUL; 7356 } 7357 return s; 7358 } 7359 7360 /* 7361 * Check the word in front of the cursor for an abbreviation. 7362 * Called when the non-id character "c" has been entered. 7363 * When an abbreviation is recognized it is removed from the text and 7364 * the replacement string is inserted in typebuf.tb_buf[], followed by "c". 7365 */ 7366 static int 7367 echeck_abbr(c) 7368 int c; 7369 { 7370 /* Don't check for abbreviation in paste mode, when disabled and just 7371 * after moving around with cursor keys. */ 7372 if (p_paste || no_abbr || arrow_used) 7373 return FALSE; 7374 7375 return check_abbr(c, ml_get_curline(), curwin->w_cursor.col, 7376 curwin->w_cursor.lnum == Insstart.lnum ? Insstart.col : 0); 7377 } 7378 7379 /* 7380 * replace-stack functions 7381 * 7382 * When replacing characters, the replaced characters are remembered for each 7383 * new character. This is used to re-insert the old text when backspacing. 7384 * 7385 * There is a NUL headed list of characters for each character that is 7386 * currently in the file after the insertion point. When BS is used, one NUL 7387 * headed list is put back for the deleted character. 7388 * 7389 * For a newline, there are two NUL headed lists. One contains the characters 7390 * that the NL replaced. The extra one stores the characters after the cursor 7391 * that were deleted (always white space). 7392 * 7393 * Replace_offset is normally 0, in which case replace_push will add a new 7394 * character at the end of the stack. If replace_offset is not 0, that many 7395 * characters will be left on the stack above the newly inserted character. 7396 */ 7397 7398 static char_u *replace_stack = NULL; 7399 static long replace_stack_nr = 0; /* next entry in replace stack */ 7400 static long replace_stack_len = 0; /* max. number of entries */ 7401 7402 void 7403 replace_push(c) 7404 int c; /* character that is replaced (NUL is none) */ 7405 { 7406 char_u *p; 7407 7408 if (replace_stack_nr < replace_offset) /* nothing to do */ 7409 return; 7410 if (replace_stack_len <= replace_stack_nr) 7411 { 7412 replace_stack_len += 50; 7413 p = lalloc(sizeof(char_u) * replace_stack_len, TRUE); 7414 if (p == NULL) /* out of memory */ 7415 { 7416 replace_stack_len -= 50; 7417 return; 7418 } 7419 if (replace_stack != NULL) 7420 { 7421 mch_memmove(p, replace_stack, 7422 (size_t)(replace_stack_nr * sizeof(char_u))); 7423 vim_free(replace_stack); 7424 } 7425 replace_stack = p; 7426 } 7427 p = replace_stack + replace_stack_nr - replace_offset; 7428 if (replace_offset) 7429 mch_memmove(p + 1, p, (size_t)(replace_offset * sizeof(char_u))); 7430 *p = c; 7431 ++replace_stack_nr; 7432 } 7433 7434 #if defined(FEAT_MBYTE) || defined(PROTO) 7435 /* 7436 * Push a character onto the replace stack. Handles a multi-byte character in 7437 * reverse byte order, so that the first byte is popped off first. 7438 * Return the number of bytes done (includes composing characters). 7439 */ 7440 int 7441 replace_push_mb(p) 7442 char_u *p; 7443 { 7444 int l = (*mb_ptr2len)(p); 7445 int j; 7446 7447 for (j = l - 1; j >= 0; --j) 7448 replace_push(p[j]); 7449 return l; 7450 } 7451 #endif 7452 7453 /* 7454 * Pop one item from the replace stack. 7455 * return -1 if stack empty 7456 * return replaced character or NUL otherwise 7457 */ 7458 static int 7459 replace_pop() 7460 { 7461 if (replace_stack_nr == 0) 7462 return -1; 7463 return (int)replace_stack[--replace_stack_nr]; 7464 } 7465 7466 /* 7467 * Join the top two items on the replace stack. This removes to "off"'th NUL 7468 * encountered. 7469 */ 7470 static void 7471 replace_join(off) 7472 int off; /* offset for which NUL to remove */ 7473 { 7474 int i; 7475 7476 for (i = replace_stack_nr; --i >= 0; ) 7477 if (replace_stack[i] == NUL && off-- <= 0) 7478 { 7479 --replace_stack_nr; 7480 mch_memmove(replace_stack + i, replace_stack + i + 1, 7481 (size_t)(replace_stack_nr - i)); 7482 return; 7483 } 7484 } 7485 7486 /* 7487 * Pop bytes from the replace stack until a NUL is found, and insert them 7488 * before the cursor. Can only be used in REPLACE or VREPLACE mode. 7489 */ 7490 static void 7491 replace_pop_ins() 7492 { 7493 int cc; 7494 int oldState = State; 7495 7496 State = NORMAL; /* don't want REPLACE here */ 7497 while ((cc = replace_pop()) > 0) 7498 { 7499 #ifdef FEAT_MBYTE 7500 mb_replace_pop_ins(cc); 7501 #else 7502 ins_char(cc); 7503 #endif 7504 dec_cursor(); 7505 } 7506 State = oldState; 7507 } 7508 7509 #ifdef FEAT_MBYTE 7510 /* 7511 * Insert bytes popped from the replace stack. "cc" is the first byte. If it 7512 * indicates a multi-byte char, pop the other bytes too. 7513 */ 7514 static void 7515 mb_replace_pop_ins(cc) 7516 int cc; 7517 { 7518 int n; 7519 char_u buf[MB_MAXBYTES + 1]; 7520 int i; 7521 int c; 7522 7523 if (has_mbyte && (n = MB_BYTE2LEN(cc)) > 1) 7524 { 7525 buf[0] = cc; 7526 for (i = 1; i < n; ++i) 7527 buf[i] = replace_pop(); 7528 ins_bytes_len(buf, n); 7529 } 7530 else 7531 ins_char(cc); 7532 7533 if (enc_utf8) 7534 /* Handle composing chars. */ 7535 for (;;) 7536 { 7537 c = replace_pop(); 7538 if (c == -1) /* stack empty */ 7539 break; 7540 if ((n = MB_BYTE2LEN(c)) == 1) 7541 { 7542 /* Not a multi-byte char, put it back. */ 7543 replace_push(c); 7544 break; 7545 } 7546 else 7547 { 7548 buf[0] = c; 7549 for (i = 1; i < n; ++i) 7550 buf[i] = replace_pop(); 7551 if (utf_iscomposing(utf_ptr2char(buf))) 7552 ins_bytes_len(buf, n); 7553 else 7554 { 7555 /* Not a composing char, put it back. */ 7556 for (i = n - 1; i >= 0; --i) 7557 replace_push(buf[i]); 7558 break; 7559 } 7560 } 7561 } 7562 } 7563 #endif 7564 7565 /* 7566 * make the replace stack empty 7567 * (called when exiting replace mode) 7568 */ 7569 static void 7570 replace_flush() 7571 { 7572 vim_free(replace_stack); 7573 replace_stack = NULL; 7574 replace_stack_len = 0; 7575 replace_stack_nr = 0; 7576 } 7577 7578 /* 7579 * Handle doing a BS for one character. 7580 * cc < 0: replace stack empty, just move cursor 7581 * cc == 0: character was inserted, delete it 7582 * cc > 0: character was replaced, put cc (first byte of original char) back 7583 * and check for more characters to be put back 7584 * When "limit_col" is >= 0, don't delete before this column. Matters when 7585 * using composing characters, use del_char_after_col() instead of del_char(). 7586 */ 7587 static void 7588 replace_do_bs(limit_col) 7589 int limit_col; 7590 { 7591 int cc; 7592 #ifdef FEAT_VREPLACE 7593 int orig_len = 0; 7594 int ins_len; 7595 int orig_vcols = 0; 7596 colnr_T start_vcol; 7597 char_u *p; 7598 int i; 7599 int vcol; 7600 #endif 7601 7602 cc = replace_pop(); 7603 if (cc > 0) 7604 { 7605 #ifdef FEAT_VREPLACE 7606 if (State & VREPLACE_FLAG) 7607 { 7608 /* Get the number of screen cells used by the character we are 7609 * going to delete. */ 7610 getvcol(curwin, &curwin->w_cursor, NULL, &start_vcol, NULL); 7611 orig_vcols = chartabsize(ml_get_cursor(), start_vcol); 7612 } 7613 #endif 7614 #ifdef FEAT_MBYTE 7615 if (has_mbyte) 7616 { 7617 (void)del_char_after_col(limit_col); 7618 # ifdef FEAT_VREPLACE 7619 if (State & VREPLACE_FLAG) 7620 orig_len = (int)STRLEN(ml_get_cursor()); 7621 # endif 7622 replace_push(cc); 7623 } 7624 else 7625 #endif 7626 { 7627 pchar_cursor(cc); 7628 #ifdef FEAT_VREPLACE 7629 if (State & VREPLACE_FLAG) 7630 orig_len = (int)STRLEN(ml_get_cursor()) - 1; 7631 #endif 7632 } 7633 replace_pop_ins(); 7634 7635 #ifdef FEAT_VREPLACE 7636 if (State & VREPLACE_FLAG) 7637 { 7638 /* Get the number of screen cells used by the inserted characters */ 7639 p = ml_get_cursor(); 7640 ins_len = (int)STRLEN(p) - orig_len; 7641 vcol = start_vcol; 7642 for (i = 0; i < ins_len; ++i) 7643 { 7644 vcol += chartabsize(p + i, vcol); 7645 #ifdef FEAT_MBYTE 7646 i += (*mb_ptr2len)(p) - 1; 7647 #endif 7648 } 7649 vcol -= start_vcol; 7650 7651 /* Delete spaces that were inserted after the cursor to keep the 7652 * text aligned. */ 7653 curwin->w_cursor.col += ins_len; 7654 while (vcol > orig_vcols && gchar_cursor() == ' ') 7655 { 7656 del_char(FALSE); 7657 ++orig_vcols; 7658 } 7659 curwin->w_cursor.col -= ins_len; 7660 } 7661 #endif 7662 7663 /* mark the buffer as changed and prepare for displaying */ 7664 changed_bytes(curwin->w_cursor.lnum, curwin->w_cursor.col); 7665 } 7666 else if (cc == 0) 7667 (void)del_char_after_col(limit_col); 7668 } 7669 7670 #ifdef FEAT_CINDENT 7671 /* 7672 * Return TRUE if C-indenting is on. 7673 */ 7674 static int 7675 cindent_on() 7676 { 7677 return (!p_paste && (curbuf->b_p_cin 7678 # ifdef FEAT_EVAL 7679 || *curbuf->b_p_inde != NUL 7680 # endif 7681 )); 7682 } 7683 #endif 7684 7685 #if defined(FEAT_LISP) || defined(FEAT_CINDENT) || defined(PROTO) 7686 /* 7687 * Re-indent the current line, based on the current contents of it and the 7688 * surrounding lines. Fixing the cursor position seems really easy -- I'm very 7689 * confused what all the part that handles Control-T is doing that I'm not. 7690 * "get_the_indent" should be get_c_indent, get_expr_indent or get_lisp_indent. 7691 */ 7692 7693 void 7694 fixthisline(get_the_indent) 7695 int (*get_the_indent) __ARGS((void)); 7696 { 7697 change_indent(INDENT_SET, get_the_indent(), FALSE, 0, TRUE); 7698 if (linewhite(curwin->w_cursor.lnum)) 7699 did_ai = TRUE; /* delete the indent if the line stays empty */ 7700 } 7701 7702 void 7703 fix_indent() 7704 { 7705 if (p_paste) 7706 return; 7707 # ifdef FEAT_LISP 7708 if (curbuf->b_p_lisp && curbuf->b_p_ai) 7709 fixthisline(get_lisp_indent); 7710 # endif 7711 # if defined(FEAT_LISP) && defined(FEAT_CINDENT) 7712 else 7713 # endif 7714 # ifdef FEAT_CINDENT 7715 if (cindent_on()) 7716 do_c_expr_indent(); 7717 # endif 7718 } 7719 7720 #endif 7721 7722 #ifdef FEAT_CINDENT 7723 /* 7724 * return TRUE if 'cinkeys' contains the key "keytyped", 7725 * when == '*': Only if key is preceded with '*' (indent before insert) 7726 * when == '!': Only if key is preceded with '!' (don't insert) 7727 * when == ' ': Only if key is not preceded with '*'(indent afterwards) 7728 * 7729 * "keytyped" can have a few special values: 7730 * KEY_OPEN_FORW 7731 * KEY_OPEN_BACK 7732 * KEY_COMPLETE just finished completion. 7733 * 7734 * If line_is_empty is TRUE accept keys with '0' before them. 7735 */ 7736 int 7737 in_cinkeys(keytyped, when, line_is_empty) 7738 int keytyped; 7739 int when; 7740 int line_is_empty; 7741 { 7742 char_u *look; 7743 int try_match; 7744 int try_match_word; 7745 char_u *p; 7746 char_u *line; 7747 int icase; 7748 int i; 7749 7750 if (keytyped == NUL) 7751 /* Can happen with CTRL-Y and CTRL-E on a short line. */ 7752 return FALSE; 7753 7754 #ifdef FEAT_EVAL 7755 if (*curbuf->b_p_inde != NUL) 7756 look = curbuf->b_p_indk; /* 'indentexpr' set: use 'indentkeys' */ 7757 else 7758 #endif 7759 look = curbuf->b_p_cink; /* 'indentexpr' empty: use 'cinkeys' */ 7760 while (*look) 7761 { 7762 /* 7763 * Find out if we want to try a match with this key, depending on 7764 * 'when' and a '*' or '!' before the key. 7765 */ 7766 switch (when) 7767 { 7768 case '*': try_match = (*look == '*'); break; 7769 case '!': try_match = (*look == '!'); break; 7770 default: try_match = (*look != '*'); break; 7771 } 7772 if (*look == '*' || *look == '!') 7773 ++look; 7774 7775 /* 7776 * If there is a '0', only accept a match if the line is empty. 7777 * But may still match when typing last char of a word. 7778 */ 7779 if (*look == '0') 7780 { 7781 try_match_word = try_match; 7782 if (!line_is_empty) 7783 try_match = FALSE; 7784 ++look; 7785 } 7786 else 7787 try_match_word = FALSE; 7788 7789 /* 7790 * does it look like a control character? 7791 */ 7792 if (*look == '^' 7793 #ifdef EBCDIC 7794 && (Ctrl_chr(look[1]) != 0) 7795 #else 7796 && look[1] >= '?' && look[1] <= '_' 7797 #endif 7798 ) 7799 { 7800 if (try_match && keytyped == Ctrl_chr(look[1])) 7801 return TRUE; 7802 look += 2; 7803 } 7804 /* 7805 * 'o' means "o" command, open forward. 7806 * 'O' means "O" command, open backward. 7807 */ 7808 else if (*look == 'o') 7809 { 7810 if (try_match && keytyped == KEY_OPEN_FORW) 7811 return TRUE; 7812 ++look; 7813 } 7814 else if (*look == 'O') 7815 { 7816 if (try_match && keytyped == KEY_OPEN_BACK) 7817 return TRUE; 7818 ++look; 7819 } 7820 7821 /* 7822 * 'e' means to check for "else" at start of line and just before the 7823 * cursor. 7824 */ 7825 else if (*look == 'e') 7826 { 7827 if (try_match && keytyped == 'e' && curwin->w_cursor.col >= 4) 7828 { 7829 p = ml_get_curline(); 7830 if (skipwhite(p) == p + curwin->w_cursor.col - 4 && 7831 STRNCMP(p + curwin->w_cursor.col - 4, "else", 4) == 0) 7832 return TRUE; 7833 } 7834 ++look; 7835 } 7836 7837 /* 7838 * ':' only causes an indent if it is at the end of a label or case 7839 * statement, or when it was before typing the ':' (to fix 7840 * class::method for C++). 7841 */ 7842 else if (*look == ':') 7843 { 7844 if (try_match && keytyped == ':') 7845 { 7846 p = ml_get_curline(); 7847 if (cin_iscase(p, FALSE) || cin_isscopedecl(p) 7848 || cin_islabel(30)) 7849 return TRUE; 7850 /* Need to get the line again after cin_islabel(). */ 7851 p = ml_get_curline(); 7852 if (curwin->w_cursor.col > 2 7853 && p[curwin->w_cursor.col - 1] == ':' 7854 && p[curwin->w_cursor.col - 2] == ':') 7855 { 7856 p[curwin->w_cursor.col - 1] = ' '; 7857 i = (cin_iscase(p, FALSE) || cin_isscopedecl(p) 7858 || cin_islabel(30)); 7859 p = ml_get_curline(); 7860 p[curwin->w_cursor.col - 1] = ':'; 7861 if (i) 7862 return TRUE; 7863 } 7864 } 7865 ++look; 7866 } 7867 7868 7869 /* 7870 * Is it a key in <>, maybe? 7871 */ 7872 else if (*look == '<') 7873 { 7874 if (try_match) 7875 { 7876 /* 7877 * make up some named keys <o>, <O>, <e>, <0>, <>>, <<>, <*>, 7878 * <:> and <!> so that people can re-indent on o, O, e, 0, <, 7879 * >, *, : and ! keys if they really really want to. 7880 */ 7881 if (vim_strchr((char_u *)"<>!*oOe0:", look[1]) != NULL 7882 && keytyped == look[1]) 7883 return TRUE; 7884 7885 if (keytyped == get_special_key_code(look + 1)) 7886 return TRUE; 7887 } 7888 while (*look && *look != '>') 7889 look++; 7890 while (*look == '>') 7891 look++; 7892 } 7893 7894 /* 7895 * Is it a word: "=word"? 7896 */ 7897 else if (*look == '=' && look[1] != ',' && look[1] != NUL) 7898 { 7899 ++look; 7900 if (*look == '~') 7901 { 7902 icase = TRUE; 7903 ++look; 7904 } 7905 else 7906 icase = FALSE; 7907 p = vim_strchr(look, ','); 7908 if (p == NULL) 7909 p = look + STRLEN(look); 7910 if ((try_match || try_match_word) 7911 && curwin->w_cursor.col >= (colnr_T)(p - look)) 7912 { 7913 int match = FALSE; 7914 7915 #ifdef FEAT_INS_EXPAND 7916 if (keytyped == KEY_COMPLETE) 7917 { 7918 char_u *s; 7919 7920 /* Just completed a word, check if it starts with "look". 7921 * search back for the start of a word. */ 7922 line = ml_get_curline(); 7923 # ifdef FEAT_MBYTE 7924 if (has_mbyte) 7925 { 7926 char_u *n; 7927 7928 for (s = line + curwin->w_cursor.col; s > line; s = n) 7929 { 7930 n = mb_prevptr(line, s); 7931 if (!vim_iswordp(n)) 7932 break; 7933 } 7934 } 7935 else 7936 # endif 7937 for (s = line + curwin->w_cursor.col; s > line; --s) 7938 if (!vim_iswordc(s[-1])) 7939 break; 7940 if (s + (p - look) <= line + curwin->w_cursor.col 7941 && (icase 7942 ? MB_STRNICMP(s, look, p - look) 7943 : STRNCMP(s, look, p - look)) == 0) 7944 match = TRUE; 7945 } 7946 else 7947 #endif 7948 /* TODO: multi-byte */ 7949 if (keytyped == (int)p[-1] || (icase && keytyped < 256 7950 && TOLOWER_LOC(keytyped) == TOLOWER_LOC((int)p[-1]))) 7951 { 7952 line = ml_get_cursor(); 7953 if ((curwin->w_cursor.col == (colnr_T)(p - look) 7954 || !vim_iswordc(line[-(p - look) - 1])) 7955 && (icase 7956 ? MB_STRNICMP(line - (p - look), look, p - look) 7957 : STRNCMP(line - (p - look), look, p - look)) 7958 == 0) 7959 match = TRUE; 7960 } 7961 if (match && try_match_word && !try_match) 7962 { 7963 /* "0=word": Check if there are only blanks before the 7964 * word. */ 7965 line = ml_get_curline(); 7966 if ((int)(skipwhite(line) - line) != 7967 (int)(curwin->w_cursor.col - (p - look))) 7968 match = FALSE; 7969 } 7970 if (match) 7971 return TRUE; 7972 } 7973 look = p; 7974 } 7975 7976 /* 7977 * ok, it's a boring generic character. 7978 */ 7979 else 7980 { 7981 if (try_match && *look == keytyped) 7982 return TRUE; 7983 ++look; 7984 } 7985 7986 /* 7987 * Skip over ", ". 7988 */ 7989 look = skip_to_option_part(look); 7990 } 7991 return FALSE; 7992 } 7993 #endif /* FEAT_CINDENT */ 7994 7995 #if defined(FEAT_RIGHTLEFT) || defined(PROTO) 7996 /* 7997 * Map Hebrew keyboard when in hkmap mode. 7998 */ 7999 int 8000 hkmap(c) 8001 int c; 8002 { 8003 if (p_hkmapp) /* phonetic mapping, by Ilya Dogolazky */ 8004 { 8005 enum {hALEF=0, BET, GIMEL, DALET, HEI, VAV, ZAIN, HET, TET, IUD, 8006 KAFsofit, hKAF, LAMED, MEMsofit, MEM, NUNsofit, NUN, SAMEH, AIN, 8007 PEIsofit, PEI, ZADIsofit, ZADI, KOF, RESH, hSHIN, TAV}; 8008 static char_u map[26] = 8009 {(char_u)hALEF/*a*/, (char_u)BET /*b*/, (char_u)hKAF /*c*/, 8010 (char_u)DALET/*d*/, (char_u)-1 /*e*/, (char_u)PEIsofit/*f*/, 8011 (char_u)GIMEL/*g*/, (char_u)HEI /*h*/, (char_u)IUD /*i*/, 8012 (char_u)HET /*j*/, (char_u)KOF /*k*/, (char_u)LAMED /*l*/, 8013 (char_u)MEM /*m*/, (char_u)NUN /*n*/, (char_u)SAMEH /*o*/, 8014 (char_u)PEI /*p*/, (char_u)-1 /*q*/, (char_u)RESH /*r*/, 8015 (char_u)ZAIN /*s*/, (char_u)TAV /*t*/, (char_u)TET /*u*/, 8016 (char_u)VAV /*v*/, (char_u)hSHIN/*w*/, (char_u)-1 /*x*/, 8017 (char_u)AIN /*y*/, (char_u)ZADI /*z*/}; 8018 8019 if (c == 'N' || c == 'M' || c == 'P' || c == 'C' || c == 'Z') 8020 return (int)(map[CharOrd(c)] - 1 + p_aleph); 8021 /* '-1'='sofit' */ 8022 else if (c == 'x') 8023 return 'X'; 8024 else if (c == 'q') 8025 return '\''; /* {geresh}={'} */ 8026 else if (c == 246) 8027 return ' '; /* \"o --> ' ' for a german keyboard */ 8028 else if (c == 228) 8029 return ' '; /* \"a --> ' ' -- / -- */ 8030 else if (c == 252) 8031 return ' '; /* \"u --> ' ' -- / -- */ 8032 #ifdef EBCDIC 8033 else if (islower(c)) 8034 #else 8035 /* NOTE: islower() does not do the right thing for us on Linux so we 8036 * do this the same was as 5.7 and previous, so it works correctly on 8037 * all systems. Specifically, the e.g. Delete and Arrow keys are 8038 * munged and won't work if e.g. searching for Hebrew text. 8039 */ 8040 else if (c >= 'a' && c <= 'z') 8041 #endif 8042 return (int)(map[CharOrdLow(c)] + p_aleph); 8043 else 8044 return c; 8045 } 8046 else 8047 { 8048 switch (c) 8049 { 8050 case '`': return ';'; 8051 case '/': return '.'; 8052 case '\'': return ','; 8053 case 'q': return '/'; 8054 case 'w': return '\''; 8055 8056 /* Hebrew letters - set offset from 'a' */ 8057 case ',': c = '{'; break; 8058 case '.': c = 'v'; break; 8059 case ';': c = 't'; break; 8060 default: { 8061 static char str[] = "zqbcxlsjphmkwonu ydafe rig"; 8062 8063 #ifdef EBCDIC 8064 /* see note about islower() above */ 8065 if (!islower(c)) 8066 #else 8067 if (c < 'a' || c > 'z') 8068 #endif 8069 return c; 8070 c = str[CharOrdLow(c)]; 8071 break; 8072 } 8073 } 8074 8075 return (int)(CharOrdLow(c) + p_aleph); 8076 } 8077 } 8078 #endif 8079 8080 static void 8081 ins_reg() 8082 { 8083 int need_redraw = FALSE; 8084 int regname; 8085 int literally = 0; 8086 #ifdef FEAT_VISUAL 8087 int vis_active = VIsual_active; 8088 #endif 8089 8090 /* 8091 * If we are going to wait for a character, show a '"'. 8092 */ 8093 pc_status = PC_STATUS_UNSET; 8094 if (redrawing() && !char_avail()) 8095 { 8096 /* may need to redraw when no more chars available now */ 8097 ins_redraw(FALSE); 8098 8099 edit_putchar('"', TRUE); 8100 #ifdef FEAT_CMDL_INFO 8101 add_to_showcmd_c(Ctrl_R); 8102 #endif 8103 } 8104 8105 #ifdef USE_ON_FLY_SCROLL 8106 dont_scroll = TRUE; /* disallow scrolling here */ 8107 #endif 8108 8109 /* 8110 * Don't map the register name. This also prevents the mode message to be 8111 * deleted when ESC is hit. 8112 */ 8113 ++no_mapping; 8114 regname = plain_vgetc(); 8115 LANGMAP_ADJUST(regname, TRUE); 8116 if (regname == Ctrl_R || regname == Ctrl_O || regname == Ctrl_P) 8117 { 8118 /* Get a third key for literal register insertion */ 8119 literally = regname; 8120 #ifdef FEAT_CMDL_INFO 8121 add_to_showcmd_c(literally); 8122 #endif 8123 regname = plain_vgetc(); 8124 LANGMAP_ADJUST(regname, TRUE); 8125 } 8126 --no_mapping; 8127 8128 #ifdef FEAT_EVAL 8129 /* Don't call u_sync() while typing the expression or giving an error 8130 * message for it. Only call it explicitly. */ 8131 ++no_u_sync; 8132 if (regname == '=') 8133 { 8134 # ifdef USE_IM_CONTROL 8135 int im_on = im_get_status(); 8136 # endif 8137 regname = get_expr_register(); 8138 # ifdef USE_IM_CONTROL 8139 /* Restore the Input Method. */ 8140 if (im_on) 8141 im_set_active(TRUE); 8142 # endif 8143 if (regname == '=') 8144 /* sync undo, so the effect of e.g., setline() can be undone */ 8145 u_sync(TRUE); 8146 } 8147 if (regname == NUL || !valid_yank_reg(regname, FALSE)) 8148 { 8149 vim_beep(); 8150 need_redraw = TRUE; /* remove the '"' */ 8151 } 8152 else 8153 { 8154 #endif 8155 if (literally == Ctrl_O || literally == Ctrl_P) 8156 { 8157 /* Append the command to the redo buffer. */ 8158 AppendCharToRedobuff(Ctrl_R); 8159 AppendCharToRedobuff(literally); 8160 AppendCharToRedobuff(regname); 8161 8162 do_put(regname, BACKWARD, 1L, 8163 (literally == Ctrl_P ? PUT_FIXINDENT : 0) | PUT_CURSEND); 8164 } 8165 else if (insert_reg(regname, literally) == FAIL) 8166 { 8167 vim_beep(); 8168 need_redraw = TRUE; /* remove the '"' */ 8169 } 8170 else if (stop_insert_mode) 8171 /* When the '=' register was used and a function was invoked that 8172 * did ":stopinsert" then stuff_empty() returns FALSE but we won't 8173 * insert anything, need to remove the '"' */ 8174 need_redraw = TRUE; 8175 8176 #ifdef FEAT_EVAL 8177 } 8178 --no_u_sync; 8179 #endif 8180 #ifdef FEAT_CMDL_INFO 8181 clear_showcmd(); 8182 #endif 8183 8184 /* If the inserted register is empty, we need to remove the '"' */ 8185 if (need_redraw || stuff_empty()) 8186 edit_unputchar(); 8187 8188 #ifdef FEAT_VISUAL 8189 /* Disallow starting Visual mode here, would get a weird mode. */ 8190 if (!vis_active && VIsual_active) 8191 end_visual_mode(); 8192 #endif 8193 } 8194 8195 /* 8196 * CTRL-G commands in Insert mode. 8197 */ 8198 static void 8199 ins_ctrl_g() 8200 { 8201 int c; 8202 8203 #ifdef FEAT_INS_EXPAND 8204 /* Right after CTRL-X the cursor will be after the ruler. */ 8205 setcursor(); 8206 #endif 8207 8208 /* 8209 * Don't map the second key. This also prevents the mode message to be 8210 * deleted when ESC is hit. 8211 */ 8212 ++no_mapping; 8213 c = plain_vgetc(); 8214 --no_mapping; 8215 switch (c) 8216 { 8217 /* CTRL-G k and CTRL-G <Up>: cursor up to Insstart.col */ 8218 case K_UP: 8219 case Ctrl_K: 8220 case 'k': ins_up(TRUE); 8221 break; 8222 8223 /* CTRL-G j and CTRL-G <Down>: cursor down to Insstart.col */ 8224 case K_DOWN: 8225 case Ctrl_J: 8226 case 'j': ins_down(TRUE); 8227 break; 8228 8229 /* CTRL-G u: start new undoable edit */ 8230 case 'u': u_sync(TRUE); 8231 ins_need_undo = TRUE; 8232 8233 /* Need to reset Insstart, esp. because a BS that joins 8234 * a line to the previous one must save for undo. */ 8235 Insstart = curwin->w_cursor; 8236 break; 8237 8238 /* Unknown CTRL-G command, reserved for future expansion. */ 8239 default: vim_beep(); 8240 } 8241 } 8242 8243 /* 8244 * CTRL-^ in Insert mode. 8245 */ 8246 static void 8247 ins_ctrl_hat() 8248 { 8249 if (map_to_exists_mode((char_u *)"", LANGMAP, FALSE)) 8250 { 8251 /* ":lmap" mappings exists, Toggle use of ":lmap" mappings. */ 8252 if (State & LANGMAP) 8253 { 8254 curbuf->b_p_iminsert = B_IMODE_NONE; 8255 State &= ~LANGMAP; 8256 } 8257 else 8258 { 8259 curbuf->b_p_iminsert = B_IMODE_LMAP; 8260 State |= LANGMAP; 8261 #ifdef USE_IM_CONTROL 8262 im_set_active(FALSE); 8263 #endif 8264 } 8265 } 8266 #ifdef USE_IM_CONTROL 8267 else 8268 { 8269 /* There are no ":lmap" mappings, toggle IM */ 8270 if (im_get_status()) 8271 { 8272 curbuf->b_p_iminsert = B_IMODE_NONE; 8273 im_set_active(FALSE); 8274 } 8275 else 8276 { 8277 curbuf->b_p_iminsert = B_IMODE_IM; 8278 State &= ~LANGMAP; 8279 im_set_active(TRUE); 8280 } 8281 } 8282 #endif 8283 set_iminsert_global(); 8284 showmode(); 8285 #ifdef FEAT_GUI 8286 /* may show different cursor shape or color */ 8287 if (gui.in_use) 8288 gui_update_cursor(TRUE, FALSE); 8289 #endif 8290 #if defined(FEAT_WINDOWS) && defined(FEAT_KEYMAP) 8291 /* Show/unshow value of 'keymap' in status lines. */ 8292 status_redraw_curbuf(); 8293 #endif 8294 } 8295 8296 /* 8297 * Handle ESC in insert mode. 8298 * Returns TRUE when leaving insert mode, FALSE when going to repeat the 8299 * insert. 8300 */ 8301 static int 8302 ins_esc(count, cmdchar, nomove) 8303 long *count; 8304 int cmdchar; 8305 int nomove; /* don't move cursor */ 8306 { 8307 int temp; 8308 static int disabled_redraw = FALSE; 8309 8310 #ifdef FEAT_SPELL 8311 check_spell_redraw(); 8312 #endif 8313 #if defined(FEAT_HANGULIN) 8314 # if defined(ESC_CHG_TO_ENG_MODE) 8315 hangul_input_state_set(0); 8316 # endif 8317 if (composing_hangul) 8318 { 8319 push_raw_key(composing_hangul_buffer, 2); 8320 composing_hangul = 0; 8321 } 8322 #endif 8323 8324 temp = curwin->w_cursor.col; 8325 if (disabled_redraw) 8326 { 8327 --RedrawingDisabled; 8328 disabled_redraw = FALSE; 8329 } 8330 if (!arrow_used) 8331 { 8332 /* 8333 * Don't append the ESC for "r<CR>" and "grx". 8334 * When 'insertmode' is set only CTRL-L stops Insert mode. Needed for 8335 * when "count" is non-zero. 8336 */ 8337 if (cmdchar != 'r' && cmdchar != 'v') 8338 AppendToRedobuff(p_im ? (char_u *)"\014" : ESC_STR); 8339 8340 /* 8341 * Repeating insert may take a long time. Check for 8342 * interrupt now and then. 8343 */ 8344 if (*count > 0) 8345 { 8346 line_breakcheck(); 8347 if (got_int) 8348 *count = 0; 8349 } 8350 8351 if (--*count > 0) /* repeat what was typed */ 8352 { 8353 /* Vi repeats the insert without replacing characters. */ 8354 if (vim_strchr(p_cpo, CPO_REPLCNT) != NULL) 8355 State &= ~REPLACE_FLAG; 8356 8357 (void)start_redo_ins(); 8358 if (cmdchar == 'r' || cmdchar == 'v') 8359 stuffReadbuff(ESC_STR); /* no ESC in redo buffer */ 8360 ++RedrawingDisabled; 8361 disabled_redraw = TRUE; 8362 return FALSE; /* repeat the insert */ 8363 } 8364 stop_insert(&curwin->w_cursor, TRUE); 8365 undisplay_dollar(); 8366 } 8367 8368 /* When an autoindent was removed, curswant stays after the 8369 * indent */ 8370 if (restart_edit == NUL && (colnr_T)temp == curwin->w_cursor.col) 8371 curwin->w_set_curswant = TRUE; 8372 8373 /* Remember the last Insert position in the '^ mark. */ 8374 if (!cmdmod.keepjumps) 8375 curbuf->b_last_insert = curwin->w_cursor; 8376 8377 /* 8378 * The cursor should end up on the last inserted character. 8379 * Don't do it for CTRL-O, unless past the end of the line. 8380 */ 8381 if (!nomove 8382 && (curwin->w_cursor.col != 0 8383 #ifdef FEAT_VIRTUALEDIT 8384 || curwin->w_cursor.coladd > 0 8385 #endif 8386 ) 8387 && (restart_edit == NUL 8388 || (gchar_cursor() == NUL 8389 #ifdef FEAT_VISUAL 8390 && !VIsual_active 8391 #endif 8392 )) 8393 #ifdef FEAT_RIGHTLEFT 8394 && !revins_on 8395 #endif 8396 ) 8397 { 8398 #ifdef FEAT_VIRTUALEDIT 8399 if (curwin->w_cursor.coladd > 0 || ve_flags == VE_ALL) 8400 { 8401 oneleft(); 8402 if (restart_edit != NUL) 8403 ++curwin->w_cursor.coladd; 8404 } 8405 else 8406 #endif 8407 { 8408 --curwin->w_cursor.col; 8409 #ifdef FEAT_MBYTE 8410 /* Correct cursor for multi-byte character. */ 8411 if (has_mbyte) 8412 mb_adjust_cursor(); 8413 #endif 8414 } 8415 } 8416 8417 #ifdef USE_IM_CONTROL 8418 /* Disable IM to allow typing English directly for Normal mode commands. 8419 * When ":lmap" is enabled don't change 'iminsert' (IM can be enabled as 8420 * well). */ 8421 if (!(State & LANGMAP)) 8422 im_save_status(&curbuf->b_p_iminsert); 8423 im_set_active(FALSE); 8424 #endif 8425 8426 State = NORMAL; 8427 /* need to position cursor again (e.g. when on a TAB ) */ 8428 changed_cline_bef_curs(); 8429 8430 #ifdef FEAT_MOUSE 8431 setmouse(); 8432 #endif 8433 #ifdef CURSOR_SHAPE 8434 ui_cursor_shape(); /* may show different cursor shape */ 8435 #endif 8436 8437 /* 8438 * When recording or for CTRL-O, need to display the new mode. 8439 * Otherwise remove the mode message. 8440 */ 8441 if (Recording || restart_edit != NUL) 8442 showmode(); 8443 else if (p_smd) 8444 MSG(""); 8445 8446 return TRUE; /* exit Insert mode */ 8447 } 8448 8449 #ifdef FEAT_RIGHTLEFT 8450 /* 8451 * Toggle language: hkmap and revins_on. 8452 * Move to end of reverse inserted text. 8453 */ 8454 static void 8455 ins_ctrl_() 8456 { 8457 if (revins_on && revins_chars && revins_scol >= 0) 8458 { 8459 while (gchar_cursor() != NUL && revins_chars--) 8460 ++curwin->w_cursor.col; 8461 } 8462 p_ri = !p_ri; 8463 revins_on = (State == INSERT && p_ri); 8464 if (revins_on) 8465 { 8466 revins_scol = curwin->w_cursor.col; 8467 revins_legal++; 8468 revins_chars = 0; 8469 undisplay_dollar(); 8470 } 8471 else 8472 revins_scol = -1; 8473 #ifdef FEAT_FKMAP 8474 if (p_altkeymap) 8475 { 8476 /* 8477 * to be consistent also for redo command, using '.' 8478 * set arrow_used to true and stop it - causing to redo 8479 * characters entered in one mode (normal/reverse insert). 8480 */ 8481 arrow_used = TRUE; 8482 (void)stop_arrow(); 8483 p_fkmap = curwin->w_p_rl ^ p_ri; 8484 if (p_fkmap && p_ri) 8485 State = INSERT; 8486 } 8487 else 8488 #endif 8489 p_hkmap = curwin->w_p_rl ^ p_ri; /* be consistent! */ 8490 showmode(); 8491 } 8492 #endif 8493 8494 #ifdef FEAT_VISUAL 8495 /* 8496 * If 'keymodel' contains "startsel", may start selection. 8497 * Returns TRUE when a CTRL-O and other keys stuffed. 8498 */ 8499 static int 8500 ins_start_select(c) 8501 int c; 8502 { 8503 if (km_startsel) 8504 switch (c) 8505 { 8506 case K_KHOME: 8507 case K_KEND: 8508 case K_PAGEUP: 8509 case K_KPAGEUP: 8510 case K_PAGEDOWN: 8511 case K_KPAGEDOWN: 8512 # ifdef MACOS 8513 case K_LEFT: 8514 case K_RIGHT: 8515 case K_UP: 8516 case K_DOWN: 8517 case K_END: 8518 case K_HOME: 8519 # endif 8520 if (!(mod_mask & MOD_MASK_SHIFT)) 8521 break; 8522 /* FALLTHROUGH */ 8523 case K_S_LEFT: 8524 case K_S_RIGHT: 8525 case K_S_UP: 8526 case K_S_DOWN: 8527 case K_S_END: 8528 case K_S_HOME: 8529 /* Start selection right away, the cursor can move with 8530 * CTRL-O when beyond the end of the line. */ 8531 start_selection(); 8532 8533 /* Execute the key in (insert) Select mode. */ 8534 stuffcharReadbuff(Ctrl_O); 8535 if (mod_mask) 8536 { 8537 char_u buf[4]; 8538 8539 buf[0] = K_SPECIAL; 8540 buf[1] = KS_MODIFIER; 8541 buf[2] = mod_mask; 8542 buf[3] = NUL; 8543 stuffReadbuff(buf); 8544 } 8545 stuffcharReadbuff(c); 8546 return TRUE; 8547 } 8548 return FALSE; 8549 } 8550 #endif 8551 8552 /* 8553 * <Insert> key in Insert mode: toggle insert/replace mode. 8554 */ 8555 static void 8556 ins_insert(replaceState) 8557 int replaceState; 8558 { 8559 #ifdef FEAT_FKMAP 8560 if (p_fkmap && p_ri) 8561 { 8562 beep_flush(); 8563 EMSG(farsi_text_3); /* encoded in Farsi */ 8564 return; 8565 } 8566 #endif 8567 8568 #ifdef FEAT_AUTOCMD 8569 # ifdef FEAT_EVAL 8570 set_vim_var_string(VV_INSERTMODE, 8571 (char_u *)((State & REPLACE_FLAG) ? "i" : 8572 # ifdef FEAT_VREPLACE 8573 replaceState == VREPLACE ? "v" : 8574 # endif 8575 "r"), 1); 8576 # endif 8577 apply_autocmds(EVENT_INSERTCHANGE, NULL, NULL, FALSE, curbuf); 8578 #endif 8579 if (State & REPLACE_FLAG) 8580 State = INSERT | (State & LANGMAP); 8581 else 8582 State = replaceState | (State & LANGMAP); 8583 AppendCharToRedobuff(K_INS); 8584 showmode(); 8585 #ifdef CURSOR_SHAPE 8586 ui_cursor_shape(); /* may show different cursor shape */ 8587 #endif 8588 } 8589 8590 /* 8591 * Pressed CTRL-O in Insert mode. 8592 */ 8593 static void 8594 ins_ctrl_o() 8595 { 8596 #ifdef FEAT_VREPLACE 8597 if (State & VREPLACE_FLAG) 8598 restart_edit = 'V'; 8599 else 8600 #endif 8601 if (State & REPLACE_FLAG) 8602 restart_edit = 'R'; 8603 else 8604 restart_edit = 'I'; 8605 #ifdef FEAT_VIRTUALEDIT 8606 if (virtual_active()) 8607 ins_at_eol = FALSE; /* cursor always keeps its column */ 8608 else 8609 #endif 8610 ins_at_eol = (gchar_cursor() == NUL); 8611 } 8612 8613 /* 8614 * If the cursor is on an indent, ^T/^D insert/delete one 8615 * shiftwidth. Otherwise ^T/^D behave like a "<<" or ">>". 8616 * Always round the indent to 'shiftwidth', this is compatible 8617 * with vi. But vi only supports ^T and ^D after an 8618 * autoindent, we support it everywhere. 8619 */ 8620 static void 8621 ins_shift(c, lastc) 8622 int c; 8623 int lastc; 8624 { 8625 if (stop_arrow() == FAIL) 8626 return; 8627 AppendCharToRedobuff(c); 8628 8629 /* 8630 * 0^D and ^^D: remove all indent. 8631 */ 8632 if (c == Ctrl_D && (lastc == '0' || lastc == '^') 8633 && curwin->w_cursor.col > 0) 8634 { 8635 --curwin->w_cursor.col; 8636 (void)del_char(FALSE); /* delete the '^' or '0' */ 8637 /* In Replace mode, restore the characters that '^' or '0' replaced. */ 8638 if (State & REPLACE_FLAG) 8639 replace_pop_ins(); 8640 if (lastc == '^') 8641 old_indent = get_indent(); /* remember curr. indent */ 8642 change_indent(INDENT_SET, 0, TRUE, 0, TRUE); 8643 } 8644 else 8645 change_indent(c == Ctrl_D ? INDENT_DEC : INDENT_INC, 0, TRUE, 0, TRUE); 8646 8647 if (did_ai && *skipwhite(ml_get_curline()) != NUL) 8648 did_ai = FALSE; 8649 #ifdef FEAT_SMARTINDENT 8650 did_si = FALSE; 8651 can_si = FALSE; 8652 can_si_back = FALSE; 8653 #endif 8654 #ifdef FEAT_CINDENT 8655 can_cindent = FALSE; /* no cindenting after ^D or ^T */ 8656 #endif 8657 } 8658 8659 static void 8660 ins_del() 8661 { 8662 int temp; 8663 8664 if (stop_arrow() == FAIL) 8665 return; 8666 if (gchar_cursor() == NUL) /* delete newline */ 8667 { 8668 temp = curwin->w_cursor.col; 8669 if (!can_bs(BS_EOL) /* only if "eol" included */ 8670 || do_join(2, FALSE, TRUE, FALSE) == FAIL) 8671 vim_beep(); 8672 else 8673 curwin->w_cursor.col = temp; 8674 } 8675 else if (del_char(FALSE) == FAIL) /* delete char under cursor */ 8676 vim_beep(); 8677 did_ai = FALSE; 8678 #ifdef FEAT_SMARTINDENT 8679 did_si = FALSE; 8680 can_si = FALSE; 8681 can_si_back = FALSE; 8682 #endif 8683 AppendCharToRedobuff(K_DEL); 8684 } 8685 8686 static void ins_bs_one __ARGS((colnr_T *vcolp)); 8687 8688 /* 8689 * Delete one character for ins_bs(). 8690 */ 8691 static void 8692 ins_bs_one(vcolp) 8693 colnr_T *vcolp; 8694 { 8695 dec_cursor(); 8696 getvcol(curwin, &curwin->w_cursor, vcolp, NULL, NULL); 8697 if (State & REPLACE_FLAG) 8698 { 8699 /* Don't delete characters before the insert point when in 8700 * Replace mode */ 8701 if (curwin->w_cursor.lnum != Insstart.lnum 8702 || curwin->w_cursor.col >= Insstart.col) 8703 replace_do_bs(-1); 8704 } 8705 else 8706 (void)del_char(FALSE); 8707 } 8708 8709 /* 8710 * Handle Backspace, delete-word and delete-line in Insert mode. 8711 * Return TRUE when backspace was actually used. 8712 */ 8713 static int 8714 ins_bs(c, mode, inserted_space_p) 8715 int c; 8716 int mode; 8717 int *inserted_space_p; 8718 { 8719 linenr_T lnum; 8720 int cc; 8721 int temp = 0; /* init for GCC */ 8722 colnr_T save_col; 8723 colnr_T mincol; 8724 int did_backspace = FALSE; 8725 int in_indent; 8726 int oldState; 8727 #ifdef FEAT_MBYTE 8728 int cpc[MAX_MCO]; /* composing characters */ 8729 #endif 8730 8731 /* 8732 * can't delete anything in an empty file 8733 * can't backup past first character in buffer 8734 * can't backup past starting point unless 'backspace' > 1 8735 * can backup to a previous line if 'backspace' == 0 8736 */ 8737 if ( bufempty() 8738 || ( 8739 #ifdef FEAT_RIGHTLEFT 8740 !revins_on && 8741 #endif 8742 ((curwin->w_cursor.lnum == 1 && curwin->w_cursor.col == 0) 8743 || (!can_bs(BS_START) 8744 && (arrow_used 8745 || (curwin->w_cursor.lnum == Insstart.lnum 8746 && curwin->w_cursor.col <= Insstart.col))) 8747 || (!can_bs(BS_INDENT) && !arrow_used && ai_col > 0 8748 && curwin->w_cursor.col <= ai_col) 8749 || (!can_bs(BS_EOL) && curwin->w_cursor.col == 0)))) 8750 { 8751 vim_beep(); 8752 return FALSE; 8753 } 8754 8755 if (stop_arrow() == FAIL) 8756 return FALSE; 8757 in_indent = inindent(0); 8758 #ifdef FEAT_CINDENT 8759 if (in_indent) 8760 can_cindent = FALSE; 8761 #endif 8762 #ifdef FEAT_COMMENTS 8763 end_comment_pending = NUL; /* After BS, don't auto-end comment */ 8764 #endif 8765 #ifdef FEAT_RIGHTLEFT 8766 if (revins_on) /* put cursor after last inserted char */ 8767 inc_cursor(); 8768 #endif 8769 8770 #ifdef FEAT_VIRTUALEDIT 8771 /* Virtualedit: 8772 * BACKSPACE_CHAR eats a virtual space 8773 * BACKSPACE_WORD eats all coladd 8774 * BACKSPACE_LINE eats all coladd and keeps going 8775 */ 8776 if (curwin->w_cursor.coladd > 0) 8777 { 8778 if (mode == BACKSPACE_CHAR) 8779 { 8780 --curwin->w_cursor.coladd; 8781 return TRUE; 8782 } 8783 if (mode == BACKSPACE_WORD) 8784 { 8785 curwin->w_cursor.coladd = 0; 8786 return TRUE; 8787 } 8788 curwin->w_cursor.coladd = 0; 8789 } 8790 #endif 8791 8792 /* 8793 * delete newline! 8794 */ 8795 if (curwin->w_cursor.col == 0) 8796 { 8797 lnum = Insstart.lnum; 8798 if (curwin->w_cursor.lnum == Insstart.lnum 8799 #ifdef FEAT_RIGHTLEFT 8800 || revins_on 8801 #endif 8802 ) 8803 { 8804 if (u_save((linenr_T)(curwin->w_cursor.lnum - 2), 8805 (linenr_T)(curwin->w_cursor.lnum + 1)) == FAIL) 8806 return FALSE; 8807 --Insstart.lnum; 8808 Insstart.col = MAXCOL; 8809 } 8810 /* 8811 * In replace mode: 8812 * cc < 0: NL was inserted, delete it 8813 * cc >= 0: NL was replaced, put original characters back 8814 */ 8815 cc = -1; 8816 if (State & REPLACE_FLAG) 8817 cc = replace_pop(); /* returns -1 if NL was inserted */ 8818 /* 8819 * In replace mode, in the line we started replacing, we only move the 8820 * cursor. 8821 */ 8822 if ((State & REPLACE_FLAG) && curwin->w_cursor.lnum <= lnum) 8823 { 8824 dec_cursor(); 8825 } 8826 else 8827 { 8828 #ifdef FEAT_VREPLACE 8829 if (!(State & VREPLACE_FLAG) 8830 || curwin->w_cursor.lnum > orig_line_count) 8831 #endif 8832 { 8833 temp = gchar_cursor(); /* remember current char */ 8834 --curwin->w_cursor.lnum; 8835 8836 /* When "aw" is in 'formatoptions' we must delete the space at 8837 * the end of the line, otherwise the line will be broken 8838 * again when auto-formatting. */ 8839 if (has_format_option(FO_AUTO) 8840 && has_format_option(FO_WHITE_PAR)) 8841 { 8842 char_u *ptr = ml_get_buf(curbuf, curwin->w_cursor.lnum, 8843 TRUE); 8844 int len; 8845 8846 len = (int)STRLEN(ptr); 8847 if (len > 0 && ptr[len - 1] == ' ') 8848 ptr[len - 1] = NUL; 8849 } 8850 8851 (void)do_join(2, FALSE, FALSE, FALSE); 8852 if (temp == NUL && gchar_cursor() != NUL) 8853 inc_cursor(); 8854 } 8855 #ifdef FEAT_VREPLACE 8856 else 8857 dec_cursor(); 8858 #endif 8859 8860 /* 8861 * In REPLACE mode we have to put back the text that was replaced 8862 * by the NL. On the replace stack is first a NUL-terminated 8863 * sequence of characters that were deleted and then the 8864 * characters that NL replaced. 8865 */ 8866 if (State & REPLACE_FLAG) 8867 { 8868 /* 8869 * Do the next ins_char() in NORMAL state, to 8870 * prevent ins_char() from replacing characters and 8871 * avoiding showmatch(). 8872 */ 8873 oldState = State; 8874 State = NORMAL; 8875 /* 8876 * restore characters (blanks) deleted after cursor 8877 */ 8878 while (cc > 0) 8879 { 8880 save_col = curwin->w_cursor.col; 8881 #ifdef FEAT_MBYTE 8882 mb_replace_pop_ins(cc); 8883 #else 8884 ins_char(cc); 8885 #endif 8886 curwin->w_cursor.col = save_col; 8887 cc = replace_pop(); 8888 } 8889 /* restore the characters that NL replaced */ 8890 replace_pop_ins(); 8891 State = oldState; 8892 } 8893 } 8894 did_ai = FALSE; 8895 } 8896 else 8897 { 8898 /* 8899 * Delete character(s) before the cursor. 8900 */ 8901 #ifdef FEAT_RIGHTLEFT 8902 if (revins_on) /* put cursor on last inserted char */ 8903 dec_cursor(); 8904 #endif 8905 mincol = 0; 8906 /* keep indent */ 8907 if (mode == BACKSPACE_LINE 8908 && (curbuf->b_p_ai 8909 #ifdef FEAT_CINDENT 8910 || cindent_on() 8911 #endif 8912 ) 8913 #ifdef FEAT_RIGHTLEFT 8914 && !revins_on 8915 #endif 8916 ) 8917 { 8918 save_col = curwin->w_cursor.col; 8919 beginline(BL_WHITE); 8920 if (curwin->w_cursor.col < save_col) 8921 mincol = curwin->w_cursor.col; 8922 curwin->w_cursor.col = save_col; 8923 } 8924 8925 /* 8926 * Handle deleting one 'shiftwidth' or 'softtabstop'. 8927 */ 8928 if ( mode == BACKSPACE_CHAR 8929 && ((p_sta && in_indent) 8930 || (get_sts_value() != 0 8931 && curwin->w_cursor.col > 0 8932 && (*(ml_get_cursor() - 1) == TAB 8933 || (*(ml_get_cursor() - 1) == ' ' 8934 && (!*inserted_space_p 8935 || arrow_used)))))) 8936 { 8937 int ts; 8938 colnr_T vcol; 8939 colnr_T want_vcol; 8940 colnr_T start_vcol; 8941 8942 *inserted_space_p = FALSE; 8943 if (p_sta && in_indent) 8944 ts = (int)get_sw_value(); 8945 else 8946 ts = (int)get_sts_value(); 8947 /* Compute the virtual column where we want to be. Since 8948 * 'showbreak' may get in the way, need to get the last column of 8949 * the previous character. */ 8950 getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL); 8951 start_vcol = vcol; 8952 dec_cursor(); 8953 getvcol(curwin, &curwin->w_cursor, NULL, NULL, &want_vcol); 8954 inc_cursor(); 8955 want_vcol = (want_vcol / ts) * ts; 8956 8957 /* delete characters until we are at or before want_vcol */ 8958 while (vcol > want_vcol 8959 && (cc = *(ml_get_cursor() - 1), vim_iswhite(cc))) 8960 ins_bs_one(&vcol); 8961 8962 /* insert extra spaces until we are at want_vcol */ 8963 while (vcol < want_vcol) 8964 { 8965 /* Remember the first char we inserted */ 8966 if (curwin->w_cursor.lnum == Insstart.lnum 8967 && curwin->w_cursor.col < Insstart.col) 8968 Insstart.col = curwin->w_cursor.col; 8969 8970 #ifdef FEAT_VREPLACE 8971 if (State & VREPLACE_FLAG) 8972 ins_char(' '); 8973 else 8974 #endif 8975 { 8976 ins_str((char_u *)" "); 8977 if ((State & REPLACE_FLAG)) 8978 replace_push(NUL); 8979 } 8980 getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL); 8981 } 8982 8983 /* If we are now back where we started delete one character. Can 8984 * happen when using 'sts' and 'linebreak'. */ 8985 if (vcol >= start_vcol) 8986 ins_bs_one(&vcol); 8987 } 8988 8989 /* 8990 * Delete upto starting point, start of line or previous word. 8991 */ 8992 else do 8993 { 8994 #ifdef FEAT_RIGHTLEFT 8995 if (!revins_on) /* put cursor on char to be deleted */ 8996 #endif 8997 dec_cursor(); 8998 8999 /* start of word? */ 9000 if (mode == BACKSPACE_WORD && !vim_isspace(gchar_cursor())) 9001 { 9002 mode = BACKSPACE_WORD_NOT_SPACE; 9003 temp = vim_iswordc(gchar_cursor()); 9004 } 9005 /* end of word? */ 9006 else if (mode == BACKSPACE_WORD_NOT_SPACE 9007 && (vim_isspace(cc = gchar_cursor()) 9008 || vim_iswordc(cc) != temp)) 9009 { 9010 #ifdef FEAT_RIGHTLEFT 9011 if (!revins_on) 9012 #endif 9013 inc_cursor(); 9014 #ifdef FEAT_RIGHTLEFT 9015 else if (State & REPLACE_FLAG) 9016 dec_cursor(); 9017 #endif 9018 break; 9019 } 9020 if (State & REPLACE_FLAG) 9021 replace_do_bs(-1); 9022 else 9023 { 9024 #ifdef FEAT_MBYTE 9025 if (enc_utf8 && p_deco) 9026 (void)utfc_ptr2char(ml_get_cursor(), cpc); 9027 #endif 9028 (void)del_char(FALSE); 9029 #ifdef FEAT_MBYTE 9030 /* 9031 * If there are combining characters and 'delcombine' is set 9032 * move the cursor back. Don't back up before the base 9033 * character. 9034 */ 9035 if (enc_utf8 && p_deco && cpc[0] != NUL) 9036 inc_cursor(); 9037 #endif 9038 #ifdef FEAT_RIGHTLEFT 9039 if (revins_chars) 9040 { 9041 revins_chars--; 9042 revins_legal++; 9043 } 9044 if (revins_on && gchar_cursor() == NUL) 9045 break; 9046 #endif 9047 } 9048 /* Just a single backspace?: */ 9049 if (mode == BACKSPACE_CHAR) 9050 break; 9051 } while ( 9052 #ifdef FEAT_RIGHTLEFT 9053 revins_on || 9054 #endif 9055 (curwin->w_cursor.col > mincol 9056 && (curwin->w_cursor.lnum != Insstart.lnum 9057 || curwin->w_cursor.col != Insstart.col))); 9058 did_backspace = TRUE; 9059 } 9060 #ifdef FEAT_SMARTINDENT 9061 did_si = FALSE; 9062 can_si = FALSE; 9063 can_si_back = FALSE; 9064 #endif 9065 if (curwin->w_cursor.col <= 1) 9066 did_ai = FALSE; 9067 /* 9068 * It's a little strange to put backspaces into the redo 9069 * buffer, but it makes auto-indent a lot easier to deal 9070 * with. 9071 */ 9072 AppendCharToRedobuff(c); 9073 9074 /* If deleted before the insertion point, adjust it */ 9075 if (curwin->w_cursor.lnum == Insstart.lnum 9076 && curwin->w_cursor.col < Insstart.col) 9077 Insstart.col = curwin->w_cursor.col; 9078 9079 /* vi behaviour: the cursor moves backward but the character that 9080 * was there remains visible 9081 * Vim behaviour: the cursor moves backward and the character that 9082 * was there is erased from the screen. 9083 * We can emulate the vi behaviour by pretending there is a dollar 9084 * displayed even when there isn't. 9085 * --pkv Sun Jan 19 01:56:40 EST 2003 */ 9086 if (vim_strchr(p_cpo, CPO_BACKSPACE) != NULL && dollar_vcol == -1) 9087 dollar_vcol = curwin->w_virtcol; 9088 9089 #ifdef FEAT_FOLDING 9090 /* When deleting a char the cursor line must never be in a closed fold. 9091 * E.g., when 'foldmethod' is indent and deleting the first non-white 9092 * char before a Tab. */ 9093 if (did_backspace) 9094 foldOpenCursor(); 9095 #endif 9096 9097 return did_backspace; 9098 } 9099 9100 #ifdef FEAT_MOUSE 9101 static void 9102 ins_mouse(c) 9103 int c; 9104 { 9105 pos_T tpos; 9106 win_T *old_curwin = curwin; 9107 9108 # ifdef FEAT_GUI 9109 /* When GUI is active, also move/paste when 'mouse' is empty */ 9110 if (!gui.in_use) 9111 # endif 9112 if (!mouse_has(MOUSE_INSERT)) 9113 return; 9114 9115 undisplay_dollar(); 9116 tpos = curwin->w_cursor; 9117 if (do_mouse(NULL, c, BACKWARD, 1L, 0)) 9118 { 9119 #ifdef FEAT_WINDOWS 9120 win_T *new_curwin = curwin; 9121 9122 if (curwin != old_curwin && win_valid(old_curwin)) 9123 { 9124 /* Mouse took us to another window. We need to go back to the 9125 * previous one to stop insert there properly. */ 9126 curwin = old_curwin; 9127 curbuf = curwin->w_buffer; 9128 } 9129 #endif 9130 start_arrow(curwin == old_curwin ? &tpos : NULL); 9131 #ifdef FEAT_WINDOWS 9132 if (curwin != new_curwin && win_valid(new_curwin)) 9133 { 9134 curwin = new_curwin; 9135 curbuf = curwin->w_buffer; 9136 } 9137 #endif 9138 # ifdef FEAT_CINDENT 9139 can_cindent = TRUE; 9140 # endif 9141 } 9142 9143 #ifdef FEAT_WINDOWS 9144 /* redraw status lines (in case another window became active) */ 9145 redraw_statuslines(); 9146 #endif 9147 } 9148 9149 static void 9150 ins_mousescroll(dir) 9151 int dir; 9152 { 9153 pos_T tpos; 9154 # if defined(FEAT_WINDOWS) 9155 win_T *old_curwin = curwin; 9156 # endif 9157 # ifdef FEAT_INS_EXPAND 9158 int did_scroll = FALSE; 9159 # endif 9160 9161 tpos = curwin->w_cursor; 9162 9163 # ifdef FEAT_WINDOWS 9164 if (mouse_row >= 0 && mouse_col >= 0) 9165 { 9166 int row, col; 9167 9168 row = mouse_row; 9169 col = mouse_col; 9170 9171 /* find the window at the pointer coordinates */ 9172 curwin = mouse_find_win(&row, &col); 9173 curbuf = curwin->w_buffer; 9174 } 9175 if (curwin == old_curwin) 9176 # endif 9177 undisplay_dollar(); 9178 9179 # ifdef FEAT_INS_EXPAND 9180 /* Don't scroll the window in which completion is being done. */ 9181 if (!pum_visible() 9182 # if defined(FEAT_WINDOWS) 9183 || curwin != old_curwin 9184 # endif 9185 ) 9186 # endif 9187 { 9188 if (dir == MSCR_DOWN || dir == MSCR_UP) 9189 { 9190 if (mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)) 9191 scroll_redraw(dir, 9192 (long)(curwin->w_botline - curwin->w_topline)); 9193 else 9194 scroll_redraw(dir, 3L); 9195 } 9196 #ifdef FEAT_GUI 9197 else 9198 { 9199 int val, step = 6; 9200 9201 if (mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)) 9202 step = W_WIDTH(curwin); 9203 val = curwin->w_leftcol + (dir == MSCR_RIGHT ? -step : step); 9204 if (val < 0) 9205 val = 0; 9206 gui_do_horiz_scroll(val, TRUE); 9207 } 9208 #endif 9209 # ifdef FEAT_INS_EXPAND 9210 did_scroll = TRUE; 9211 # endif 9212 } 9213 9214 # ifdef FEAT_WINDOWS 9215 curwin->w_redr_status = TRUE; 9216 9217 curwin = old_curwin; 9218 curbuf = curwin->w_buffer; 9219 # endif 9220 9221 # ifdef FEAT_INS_EXPAND 9222 /* The popup menu may overlay the window, need to redraw it. 9223 * TODO: Would be more efficient to only redraw the windows that are 9224 * overlapped by the popup menu. */ 9225 if (pum_visible() && did_scroll) 9226 { 9227 redraw_all_later(NOT_VALID); 9228 ins_compl_show_pum(); 9229 } 9230 # endif 9231 9232 if (!equalpos(curwin->w_cursor, tpos)) 9233 { 9234 start_arrow(&tpos); 9235 # ifdef FEAT_CINDENT 9236 can_cindent = TRUE; 9237 # endif 9238 } 9239 } 9240 #endif 9241 9242 #if defined(FEAT_GUI_TABLINE) || defined(PROTO) 9243 static void 9244 ins_tabline(c) 9245 int c; 9246 { 9247 /* We will be leaving the current window, unless closing another tab. */ 9248 if (c != K_TABMENU || current_tabmenu != TABLINE_MENU_CLOSE 9249 || (current_tab != 0 && current_tab != tabpage_index(curtab))) 9250 { 9251 undisplay_dollar(); 9252 start_arrow(&curwin->w_cursor); 9253 # ifdef FEAT_CINDENT 9254 can_cindent = TRUE; 9255 # endif 9256 } 9257 9258 if (c == K_TABLINE) 9259 goto_tabpage(current_tab); 9260 else 9261 { 9262 handle_tabmenu(); 9263 redraw_statuslines(); /* will redraw the tabline when needed */ 9264 } 9265 } 9266 #endif 9267 9268 #if defined(FEAT_GUI) || defined(PROTO) 9269 void 9270 ins_scroll() 9271 { 9272 pos_T tpos; 9273 9274 undisplay_dollar(); 9275 tpos = curwin->w_cursor; 9276 if (gui_do_scroll()) 9277 { 9278 start_arrow(&tpos); 9279 # ifdef FEAT_CINDENT 9280 can_cindent = TRUE; 9281 # endif 9282 } 9283 } 9284 9285 void 9286 ins_horscroll() 9287 { 9288 pos_T tpos; 9289 9290 undisplay_dollar(); 9291 tpos = curwin->w_cursor; 9292 if (gui_do_horiz_scroll(scrollbar_value, FALSE)) 9293 { 9294 start_arrow(&tpos); 9295 # ifdef FEAT_CINDENT 9296 can_cindent = TRUE; 9297 # endif 9298 } 9299 } 9300 #endif 9301 9302 static void 9303 ins_left() 9304 { 9305 pos_T tpos; 9306 9307 #ifdef FEAT_FOLDING 9308 if ((fdo_flags & FDO_HOR) && KeyTyped) 9309 foldOpenCursor(); 9310 #endif 9311 undisplay_dollar(); 9312 tpos = curwin->w_cursor; 9313 if (oneleft() == OK) 9314 { 9315 #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK) 9316 /* Only call start_arrow() when not busy with preediting, it will 9317 * break undo. K_LEFT is inserted in im_correct_cursor(). */ 9318 if (!im_is_preediting()) 9319 #endif 9320 start_arrow(&tpos); 9321 #ifdef FEAT_RIGHTLEFT 9322 /* If exit reversed string, position is fixed */ 9323 if (revins_scol != -1 && (int)curwin->w_cursor.col >= revins_scol) 9324 revins_legal++; 9325 revins_chars++; 9326 #endif 9327 } 9328 9329 /* 9330 * if 'whichwrap' set for cursor in insert mode may go to 9331 * previous line 9332 */ 9333 else if (vim_strchr(p_ww, '[') != NULL && curwin->w_cursor.lnum > 1) 9334 { 9335 start_arrow(&tpos); 9336 --(curwin->w_cursor.lnum); 9337 coladvance((colnr_T)MAXCOL); 9338 curwin->w_set_curswant = TRUE; /* so we stay at the end */ 9339 } 9340 else 9341 vim_beep(); 9342 } 9343 9344 static void 9345 ins_home(c) 9346 int c; 9347 { 9348 pos_T tpos; 9349 9350 #ifdef FEAT_FOLDING 9351 if ((fdo_flags & FDO_HOR) && KeyTyped) 9352 foldOpenCursor(); 9353 #endif 9354 undisplay_dollar(); 9355 tpos = curwin->w_cursor; 9356 if (c == K_C_HOME) 9357 curwin->w_cursor.lnum = 1; 9358 curwin->w_cursor.col = 0; 9359 #ifdef FEAT_VIRTUALEDIT 9360 curwin->w_cursor.coladd = 0; 9361 #endif 9362 curwin->w_curswant = 0; 9363 start_arrow(&tpos); 9364 } 9365 9366 static void 9367 ins_end(c) 9368 int c; 9369 { 9370 pos_T tpos; 9371 9372 #ifdef FEAT_FOLDING 9373 if ((fdo_flags & FDO_HOR) && KeyTyped) 9374 foldOpenCursor(); 9375 #endif 9376 undisplay_dollar(); 9377 tpos = curwin->w_cursor; 9378 if (c == K_C_END) 9379 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; 9380 coladvance((colnr_T)MAXCOL); 9381 curwin->w_curswant = MAXCOL; 9382 9383 start_arrow(&tpos); 9384 } 9385 9386 static void 9387 ins_s_left() 9388 { 9389 #ifdef FEAT_FOLDING 9390 if ((fdo_flags & FDO_HOR) && KeyTyped) 9391 foldOpenCursor(); 9392 #endif 9393 undisplay_dollar(); 9394 if (curwin->w_cursor.lnum > 1 || curwin->w_cursor.col > 0) 9395 { 9396 start_arrow(&curwin->w_cursor); 9397 (void)bck_word(1L, FALSE, FALSE); 9398 curwin->w_set_curswant = TRUE; 9399 } 9400 else 9401 vim_beep(); 9402 } 9403 9404 static void 9405 ins_right() 9406 { 9407 #ifdef FEAT_FOLDING 9408 if ((fdo_flags & FDO_HOR) && KeyTyped) 9409 foldOpenCursor(); 9410 #endif 9411 undisplay_dollar(); 9412 if (gchar_cursor() != NUL 9413 #ifdef FEAT_VIRTUALEDIT 9414 || virtual_active() 9415 #endif 9416 ) 9417 { 9418 start_arrow(&curwin->w_cursor); 9419 curwin->w_set_curswant = TRUE; 9420 #ifdef FEAT_VIRTUALEDIT 9421 if (virtual_active()) 9422 oneright(); 9423 else 9424 #endif 9425 { 9426 #ifdef FEAT_MBYTE 9427 if (has_mbyte) 9428 curwin->w_cursor.col += (*mb_ptr2len)(ml_get_cursor()); 9429 else 9430 #endif 9431 ++curwin->w_cursor.col; 9432 } 9433 9434 #ifdef FEAT_RIGHTLEFT 9435 revins_legal++; 9436 if (revins_chars) 9437 revins_chars--; 9438 #endif 9439 } 9440 /* if 'whichwrap' set for cursor in insert mode, may move the 9441 * cursor to the next line */ 9442 else if (vim_strchr(p_ww, ']') != NULL 9443 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) 9444 { 9445 start_arrow(&curwin->w_cursor); 9446 curwin->w_set_curswant = TRUE; 9447 ++curwin->w_cursor.lnum; 9448 curwin->w_cursor.col = 0; 9449 } 9450 else 9451 vim_beep(); 9452 } 9453 9454 static void 9455 ins_s_right() 9456 { 9457 #ifdef FEAT_FOLDING 9458 if ((fdo_flags & FDO_HOR) && KeyTyped) 9459 foldOpenCursor(); 9460 #endif 9461 undisplay_dollar(); 9462 if (curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count 9463 || gchar_cursor() != NUL) 9464 { 9465 start_arrow(&curwin->w_cursor); 9466 (void)fwd_word(1L, FALSE, 0); 9467 curwin->w_set_curswant = TRUE; 9468 } 9469 else 9470 vim_beep(); 9471 } 9472 9473 static void 9474 ins_up(startcol) 9475 int startcol; /* when TRUE move to Insstart.col */ 9476 { 9477 pos_T tpos; 9478 linenr_T old_topline = curwin->w_topline; 9479 #ifdef FEAT_DIFF 9480 int old_topfill = curwin->w_topfill; 9481 #endif 9482 9483 undisplay_dollar(); 9484 tpos = curwin->w_cursor; 9485 if (cursor_up(1L, TRUE) == OK) 9486 { 9487 if (startcol) 9488 coladvance(getvcol_nolist(&Insstart)); 9489 if (old_topline != curwin->w_topline 9490 #ifdef FEAT_DIFF 9491 || old_topfill != curwin->w_topfill 9492 #endif 9493 ) 9494 redraw_later(VALID); 9495 start_arrow(&tpos); 9496 #ifdef FEAT_CINDENT 9497 can_cindent = TRUE; 9498 #endif 9499 } 9500 else 9501 vim_beep(); 9502 } 9503 9504 static void 9505 ins_pageup() 9506 { 9507 pos_T tpos; 9508 9509 undisplay_dollar(); 9510 9511 #ifdef FEAT_WINDOWS 9512 if (mod_mask & MOD_MASK_CTRL) 9513 { 9514 /* <C-PageUp>: tab page back */ 9515 if (first_tabpage->tp_next != NULL) 9516 { 9517 start_arrow(&curwin->w_cursor); 9518 goto_tabpage(-1); 9519 } 9520 return; 9521 } 9522 #endif 9523 9524 tpos = curwin->w_cursor; 9525 if (onepage(BACKWARD, 1L) == OK) 9526 { 9527 start_arrow(&tpos); 9528 #ifdef FEAT_CINDENT 9529 can_cindent = TRUE; 9530 #endif 9531 } 9532 else 9533 vim_beep(); 9534 } 9535 9536 static void 9537 ins_down(startcol) 9538 int startcol; /* when TRUE move to Insstart.col */ 9539 { 9540 pos_T tpos; 9541 linenr_T old_topline = curwin->w_topline; 9542 #ifdef FEAT_DIFF 9543 int old_topfill = curwin->w_topfill; 9544 #endif 9545 9546 undisplay_dollar(); 9547 tpos = curwin->w_cursor; 9548 if (cursor_down(1L, TRUE) == OK) 9549 { 9550 if (startcol) 9551 coladvance(getvcol_nolist(&Insstart)); 9552 if (old_topline != curwin->w_topline 9553 #ifdef FEAT_DIFF 9554 || old_topfill != curwin->w_topfill 9555 #endif 9556 ) 9557 redraw_later(VALID); 9558 start_arrow(&tpos); 9559 #ifdef FEAT_CINDENT 9560 can_cindent = TRUE; 9561 #endif 9562 } 9563 else 9564 vim_beep(); 9565 } 9566 9567 static void 9568 ins_pagedown() 9569 { 9570 pos_T tpos; 9571 9572 undisplay_dollar(); 9573 9574 #ifdef FEAT_WINDOWS 9575 if (mod_mask & MOD_MASK_CTRL) 9576 { 9577 /* <C-PageDown>: tab page forward */ 9578 if (first_tabpage->tp_next != NULL) 9579 { 9580 start_arrow(&curwin->w_cursor); 9581 goto_tabpage(0); 9582 } 9583 return; 9584 } 9585 #endif 9586 9587 tpos = curwin->w_cursor; 9588 if (onepage(FORWARD, 1L) == OK) 9589 { 9590 start_arrow(&tpos); 9591 #ifdef FEAT_CINDENT 9592 can_cindent = TRUE; 9593 #endif 9594 } 9595 else 9596 vim_beep(); 9597 } 9598 9599 #ifdef FEAT_DND 9600 static void 9601 ins_drop() 9602 { 9603 do_put('~', BACKWARD, 1L, PUT_CURSEND); 9604 } 9605 #endif 9606 9607 /* 9608 * Handle TAB in Insert or Replace mode. 9609 * Return TRUE when the TAB needs to be inserted like a normal character. 9610 */ 9611 static int 9612 ins_tab() 9613 { 9614 int ind; 9615 int i; 9616 int temp; 9617 9618 if (Insstart_blank_vcol == MAXCOL && curwin->w_cursor.lnum == Insstart.lnum) 9619 Insstart_blank_vcol = get_nolist_virtcol(); 9620 if (echeck_abbr(TAB + ABBR_OFF)) 9621 return FALSE; 9622 9623 ind = inindent(0); 9624 #ifdef FEAT_CINDENT 9625 if (ind) 9626 can_cindent = FALSE; 9627 #endif 9628 9629 /* 9630 * When nothing special, insert TAB like a normal character 9631 */ 9632 if (!curbuf->b_p_et 9633 && !(p_sta && ind && curbuf->b_p_ts != get_sw_value()) 9634 && get_sts_value() == 0) 9635 return TRUE; 9636 9637 if (stop_arrow() == FAIL) 9638 return TRUE; 9639 9640 did_ai = FALSE; 9641 #ifdef FEAT_SMARTINDENT 9642 did_si = FALSE; 9643 can_si = FALSE; 9644 can_si_back = FALSE; 9645 #endif 9646 AppendToRedobuff((char_u *)"\t"); 9647 9648 if (p_sta && ind) /* insert tab in indent, use 'shiftwidth' */ 9649 temp = (int)get_sw_value(); 9650 else if (curbuf->b_p_sts != 0) /* use 'softtabstop' when set */ 9651 temp = (int)get_sts_value(); 9652 else /* otherwise use 'tabstop' */ 9653 temp = (int)curbuf->b_p_ts; 9654 temp -= get_nolist_virtcol() % temp; 9655 9656 /* 9657 * Insert the first space with ins_char(). It will delete one char in 9658 * replace mode. Insert the rest with ins_str(); it will not delete any 9659 * chars. For VREPLACE mode, we use ins_char() for all characters. 9660 */ 9661 ins_char(' '); 9662 while (--temp > 0) 9663 { 9664 #ifdef FEAT_VREPLACE 9665 if (State & VREPLACE_FLAG) 9666 ins_char(' '); 9667 else 9668 #endif 9669 { 9670 ins_str((char_u *)" "); 9671 if (State & REPLACE_FLAG) /* no char replaced */ 9672 replace_push(NUL); 9673 } 9674 } 9675 9676 /* 9677 * When 'expandtab' not set: Replace spaces by TABs where possible. 9678 */ 9679 if (!curbuf->b_p_et && (get_sts_value() || (p_sta && ind))) 9680 { 9681 char_u *ptr; 9682 #ifdef FEAT_VREPLACE 9683 char_u *saved_line = NULL; /* init for GCC */ 9684 pos_T pos; 9685 #endif 9686 pos_T fpos; 9687 pos_T *cursor; 9688 colnr_T want_vcol, vcol; 9689 int change_col = -1; 9690 int save_list = curwin->w_p_list; 9691 9692 /* 9693 * Get the current line. For VREPLACE mode, don't make real changes 9694 * yet, just work on a copy of the line. 9695 */ 9696 #ifdef FEAT_VREPLACE 9697 if (State & VREPLACE_FLAG) 9698 { 9699 pos = curwin->w_cursor; 9700 cursor = &pos; 9701 saved_line = vim_strsave(ml_get_curline()); 9702 if (saved_line == NULL) 9703 return FALSE; 9704 ptr = saved_line + pos.col; 9705 } 9706 else 9707 #endif 9708 { 9709 ptr = ml_get_cursor(); 9710 cursor = &curwin->w_cursor; 9711 } 9712 9713 /* When 'L' is not in 'cpoptions' a tab always takes up 'ts' spaces. */ 9714 if (vim_strchr(p_cpo, CPO_LISTWM) == NULL) 9715 curwin->w_p_list = FALSE; 9716 9717 /* Find first white before the cursor */ 9718 fpos = curwin->w_cursor; 9719 while (fpos.col > 0 && vim_iswhite(ptr[-1])) 9720 { 9721 --fpos.col; 9722 --ptr; 9723 } 9724 9725 /* In Replace mode, don't change characters before the insert point. */ 9726 if ((State & REPLACE_FLAG) 9727 && fpos.lnum == Insstart.lnum 9728 && fpos.col < Insstart.col) 9729 { 9730 ptr += Insstart.col - fpos.col; 9731 fpos.col = Insstart.col; 9732 } 9733 9734 /* compute virtual column numbers of first white and cursor */ 9735 getvcol(curwin, &fpos, &vcol, NULL, NULL); 9736 getvcol(curwin, cursor, &want_vcol, NULL, NULL); 9737 9738 /* Use as many TABs as possible. Beware of 'showbreak' and 9739 * 'linebreak' adding extra virtual columns. */ 9740 while (vim_iswhite(*ptr)) 9741 { 9742 i = lbr_chartabsize((char_u *)"\t", vcol); 9743 if (vcol + i > want_vcol) 9744 break; 9745 if (*ptr != TAB) 9746 { 9747 *ptr = TAB; 9748 if (change_col < 0) 9749 { 9750 change_col = fpos.col; /* Column of first change */ 9751 /* May have to adjust Insstart */ 9752 if (fpos.lnum == Insstart.lnum && fpos.col < Insstart.col) 9753 Insstart.col = fpos.col; 9754 } 9755 } 9756 ++fpos.col; 9757 ++ptr; 9758 vcol += i; 9759 } 9760 9761 if (change_col >= 0) 9762 { 9763 int repl_off = 0; 9764 9765 /* Skip over the spaces we need. */ 9766 while (vcol < want_vcol && *ptr == ' ') 9767 { 9768 vcol += lbr_chartabsize(ptr, vcol); 9769 ++ptr; 9770 ++repl_off; 9771 } 9772 if (vcol > want_vcol) 9773 { 9774 /* Must have a char with 'showbreak' just before it. */ 9775 --ptr; 9776 --repl_off; 9777 } 9778 fpos.col += repl_off; 9779 9780 /* Delete following spaces. */ 9781 i = cursor->col - fpos.col; 9782 if (i > 0) 9783 { 9784 STRMOVE(ptr, ptr + i); 9785 /* correct replace stack. */ 9786 if ((State & REPLACE_FLAG) 9787 #ifdef FEAT_VREPLACE 9788 && !(State & VREPLACE_FLAG) 9789 #endif 9790 ) 9791 for (temp = i; --temp >= 0; ) 9792 replace_join(repl_off); 9793 } 9794 #ifdef FEAT_NETBEANS_INTG 9795 if (netbeans_active()) 9796 { 9797 netbeans_removed(curbuf, fpos.lnum, cursor->col, (long)(i + 1)); 9798 netbeans_inserted(curbuf, fpos.lnum, cursor->col, 9799 (char_u *)"\t", 1); 9800 } 9801 #endif 9802 cursor->col -= i; 9803 9804 #ifdef FEAT_VREPLACE 9805 /* 9806 * In VREPLACE mode, we haven't changed anything yet. Do it now by 9807 * backspacing over the changed spacing and then inserting the new 9808 * spacing. 9809 */ 9810 if (State & VREPLACE_FLAG) 9811 { 9812 /* Backspace from real cursor to change_col */ 9813 backspace_until_column(change_col); 9814 9815 /* Insert each char in saved_line from changed_col to 9816 * ptr-cursor */ 9817 ins_bytes_len(saved_line + change_col, 9818 cursor->col - change_col); 9819 } 9820 #endif 9821 } 9822 9823 #ifdef FEAT_VREPLACE 9824 if (State & VREPLACE_FLAG) 9825 vim_free(saved_line); 9826 #endif 9827 curwin->w_p_list = save_list; 9828 } 9829 9830 return FALSE; 9831 } 9832 9833 /* 9834 * Handle CR or NL in insert mode. 9835 * Return TRUE when out of memory or can't undo. 9836 */ 9837 static int 9838 ins_eol(c) 9839 int c; 9840 { 9841 int i; 9842 9843 if (echeck_abbr(c + ABBR_OFF)) 9844 return FALSE; 9845 if (stop_arrow() == FAIL) 9846 return TRUE; 9847 undisplay_dollar(); 9848 9849 /* 9850 * Strange Vi behaviour: In Replace mode, typing a NL will not delete the 9851 * character under the cursor. Only push a NUL on the replace stack, 9852 * nothing to put back when the NL is deleted. 9853 */ 9854 if ((State & REPLACE_FLAG) 9855 #ifdef FEAT_VREPLACE 9856 && !(State & VREPLACE_FLAG) 9857 #endif 9858 ) 9859 replace_push(NUL); 9860 9861 /* 9862 * In VREPLACE mode, a NL replaces the rest of the line, and starts 9863 * replacing the next line, so we push all of the characters left on the 9864 * line onto the replace stack. This is not done here though, it is done 9865 * in open_line(). 9866 */ 9867 9868 #ifdef FEAT_VIRTUALEDIT 9869 /* Put cursor on NUL if on the last char and coladd is 1 (happens after 9870 * CTRL-O). */ 9871 if (virtual_active() && curwin->w_cursor.coladd > 0) 9872 coladvance(getviscol()); 9873 #endif 9874 9875 #ifdef FEAT_RIGHTLEFT 9876 # ifdef FEAT_FKMAP 9877 if (p_altkeymap && p_fkmap) 9878 fkmap(NL); 9879 # endif 9880 /* NL in reverse insert will always start in the end of 9881 * current line. */ 9882 if (revins_on) 9883 curwin->w_cursor.col += (colnr_T)STRLEN(ml_get_cursor()); 9884 #endif 9885 9886 AppendToRedobuff(NL_STR); 9887 i = open_line(FORWARD, 9888 #ifdef FEAT_COMMENTS 9889 has_format_option(FO_RET_COMS) ? OPENLINE_DO_COM : 9890 #endif 9891 0, old_indent); 9892 old_indent = 0; 9893 #ifdef FEAT_CINDENT 9894 can_cindent = TRUE; 9895 #endif 9896 #ifdef FEAT_FOLDING 9897 /* When inserting a line the cursor line must never be in a closed fold. */ 9898 foldOpenCursor(); 9899 #endif 9900 9901 return (!i); 9902 } 9903 9904 #ifdef FEAT_DIGRAPHS 9905 /* 9906 * Handle digraph in insert mode. 9907 * Returns character still to be inserted, or NUL when nothing remaining to be 9908 * done. 9909 */ 9910 static int 9911 ins_digraph() 9912 { 9913 int c; 9914 int cc; 9915 int did_putchar = FALSE; 9916 9917 pc_status = PC_STATUS_UNSET; 9918 if (redrawing() && !char_avail()) 9919 { 9920 /* may need to redraw when no more chars available now */ 9921 ins_redraw(FALSE); 9922 9923 edit_putchar('?', TRUE); 9924 did_putchar = TRUE; 9925 #ifdef FEAT_CMDL_INFO 9926 add_to_showcmd_c(Ctrl_K); 9927 #endif 9928 } 9929 9930 #ifdef USE_ON_FLY_SCROLL 9931 dont_scroll = TRUE; /* disallow scrolling here */ 9932 #endif 9933 9934 /* don't map the digraph chars. This also prevents the 9935 * mode message to be deleted when ESC is hit */ 9936 ++no_mapping; 9937 ++allow_keys; 9938 c = plain_vgetc(); 9939 --no_mapping; 9940 --allow_keys; 9941 if (did_putchar) 9942 /* when the line fits in 'columns' the '?' is at the start of the next 9943 * line and will not be removed by the redraw */ 9944 edit_unputchar(); 9945 9946 if (IS_SPECIAL(c) || mod_mask) /* special key */ 9947 { 9948 #ifdef FEAT_CMDL_INFO 9949 clear_showcmd(); 9950 #endif 9951 insert_special(c, TRUE, FALSE); 9952 return NUL; 9953 } 9954 if (c != ESC) 9955 { 9956 did_putchar = FALSE; 9957 if (redrawing() && !char_avail()) 9958 { 9959 /* may need to redraw when no more chars available now */ 9960 ins_redraw(FALSE); 9961 9962 if (char2cells(c) == 1) 9963 { 9964 ins_redraw(FALSE); 9965 edit_putchar(c, TRUE); 9966 did_putchar = TRUE; 9967 } 9968 #ifdef FEAT_CMDL_INFO 9969 add_to_showcmd_c(c); 9970 #endif 9971 } 9972 ++no_mapping; 9973 ++allow_keys; 9974 cc = plain_vgetc(); 9975 --no_mapping; 9976 --allow_keys; 9977 if (did_putchar) 9978 /* when the line fits in 'columns' the '?' is at the start of the 9979 * next line and will not be removed by a redraw */ 9980 edit_unputchar(); 9981 if (cc != ESC) 9982 { 9983 AppendToRedobuff((char_u *)CTRL_V_STR); 9984 c = getdigraph(c, cc, TRUE); 9985 #ifdef FEAT_CMDL_INFO 9986 clear_showcmd(); 9987 #endif 9988 return c; 9989 } 9990 } 9991 #ifdef FEAT_CMDL_INFO 9992 clear_showcmd(); 9993 #endif 9994 return NUL; 9995 } 9996 #endif 9997 9998 /* 9999 * Handle CTRL-E and CTRL-Y in Insert mode: copy char from other line. 10000 * Returns the char to be inserted, or NUL if none found. 10001 */ 10002 int 10003 ins_copychar(lnum) 10004 linenr_T lnum; 10005 { 10006 int c; 10007 int temp; 10008 char_u *ptr, *prev_ptr; 10009 10010 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) 10011 { 10012 vim_beep(); 10013 return NUL; 10014 } 10015 10016 /* try to advance to the cursor column */ 10017 temp = 0; 10018 ptr = ml_get(lnum); 10019 prev_ptr = ptr; 10020 validate_virtcol(); 10021 while ((colnr_T)temp < curwin->w_virtcol && *ptr != NUL) 10022 { 10023 prev_ptr = ptr; 10024 temp += lbr_chartabsize_adv(&ptr, (colnr_T)temp); 10025 } 10026 if ((colnr_T)temp > curwin->w_virtcol) 10027 ptr = prev_ptr; 10028 10029 #ifdef FEAT_MBYTE 10030 c = (*mb_ptr2char)(ptr); 10031 #else 10032 c = *ptr; 10033 #endif 10034 if (c == NUL) 10035 vim_beep(); 10036 return c; 10037 } 10038 10039 /* 10040 * CTRL-Y or CTRL-E typed in Insert mode. 10041 */ 10042 static int 10043 ins_ctrl_ey(tc) 10044 int tc; 10045 { 10046 int c = tc; 10047 10048 #ifdef FEAT_INS_EXPAND 10049 if (ctrl_x_mode == CTRL_X_SCROLL) 10050 { 10051 if (c == Ctrl_Y) 10052 scrolldown_clamp(); 10053 else 10054 scrollup_clamp(); 10055 redraw_later(VALID); 10056 } 10057 else 10058 #endif 10059 { 10060 c = ins_copychar(curwin->w_cursor.lnum + (c == Ctrl_Y ? -1 : 1)); 10061 if (c != NUL) 10062 { 10063 long tw_save; 10064 10065 /* The character must be taken literally, insert like it 10066 * was typed after a CTRL-V, and pretend 'textwidth' 10067 * wasn't set. Digits, 'o' and 'x' are special after a 10068 * CTRL-V, don't use it for these. */ 10069 if (c < 256 && !isalnum(c)) 10070 AppendToRedobuff((char_u *)CTRL_V_STR); /* CTRL-V */ 10071 tw_save = curbuf->b_p_tw; 10072 curbuf->b_p_tw = -1; 10073 insert_special(c, TRUE, FALSE); 10074 curbuf->b_p_tw = tw_save; 10075 #ifdef FEAT_RIGHTLEFT 10076 revins_chars++; 10077 revins_legal++; 10078 #endif 10079 c = Ctrl_V; /* pretend CTRL-V is last character */ 10080 auto_format(FALSE, TRUE); 10081 } 10082 } 10083 return c; 10084 } 10085 10086 #ifdef FEAT_SMARTINDENT 10087 /* 10088 * Try to do some very smart auto-indenting. 10089 * Used when inserting a "normal" character. 10090 */ 10091 static void 10092 ins_try_si(c) 10093 int c; 10094 { 10095 pos_T *pos, old_pos; 10096 char_u *ptr; 10097 int i; 10098 int temp; 10099 10100 /* 10101 * do some very smart indenting when entering '{' or '}' 10102 */ 10103 if (((did_si || can_si_back) && c == '{') || (can_si && c == '}')) 10104 { 10105 /* 10106 * for '}' set indent equal to indent of line containing matching '{' 10107 */ 10108 if (c == '}' && (pos = findmatch(NULL, '{')) != NULL) 10109 { 10110 old_pos = curwin->w_cursor; 10111 /* 10112 * If the matching '{' has a ')' immediately before it (ignoring 10113 * white-space), then line up with the start of the line 10114 * containing the matching '(' if there is one. This handles the 10115 * case where an "if (..\n..) {" statement continues over multiple 10116 * lines -- webb 10117 */ 10118 ptr = ml_get(pos->lnum); 10119 i = pos->col; 10120 if (i > 0) /* skip blanks before '{' */ 10121 while (--i > 0 && vim_iswhite(ptr[i])) 10122 ; 10123 curwin->w_cursor.lnum = pos->lnum; 10124 curwin->w_cursor.col = i; 10125 if (ptr[i] == ')' && (pos = findmatch(NULL, '(')) != NULL) 10126 curwin->w_cursor = *pos; 10127 i = get_indent(); 10128 curwin->w_cursor = old_pos; 10129 #ifdef FEAT_VREPLACE 10130 if (State & VREPLACE_FLAG) 10131 change_indent(INDENT_SET, i, FALSE, NUL, TRUE); 10132 else 10133 #endif 10134 (void)set_indent(i, SIN_CHANGED); 10135 } 10136 else if (curwin->w_cursor.col > 0) 10137 { 10138 /* 10139 * when inserting '{' after "O" reduce indent, but not 10140 * more than indent of previous line 10141 */ 10142 temp = TRUE; 10143 if (c == '{' && can_si_back && curwin->w_cursor.lnum > 1) 10144 { 10145 old_pos = curwin->w_cursor; 10146 i = get_indent(); 10147 while (curwin->w_cursor.lnum > 1) 10148 { 10149 ptr = skipwhite(ml_get(--(curwin->w_cursor.lnum))); 10150 10151 /* ignore empty lines and lines starting with '#'. */ 10152 if (*ptr != '#' && *ptr != NUL) 10153 break; 10154 } 10155 if (get_indent() >= i) 10156 temp = FALSE; 10157 curwin->w_cursor = old_pos; 10158 } 10159 if (temp) 10160 shift_line(TRUE, FALSE, 1, TRUE); 10161 } 10162 } 10163 10164 /* 10165 * set indent of '#' always to 0 10166 */ 10167 if (curwin->w_cursor.col > 0 && can_si && c == '#') 10168 { 10169 /* remember current indent for next line */ 10170 old_indent = get_indent(); 10171 (void)set_indent(0, SIN_CHANGED); 10172 } 10173 10174 /* Adjust ai_col, the char at this position can be deleted. */ 10175 if (ai_col > curwin->w_cursor.col) 10176 ai_col = curwin->w_cursor.col; 10177 } 10178 #endif 10179 10180 /* 10181 * Get the value that w_virtcol would have when 'list' is off. 10182 * Unless 'cpo' contains the 'L' flag. 10183 */ 10184 static colnr_T 10185 get_nolist_virtcol() 10186 { 10187 if (curwin->w_p_list && vim_strchr(p_cpo, CPO_LISTWM) == NULL) 10188 return getvcol_nolist(&curwin->w_cursor); 10189 validate_virtcol(); 10190 return curwin->w_virtcol; 10191 } 10192 10193 #ifdef FEAT_AUTOCMD 10194 /* 10195 * Handle the InsertCharPre autocommand. 10196 * "c" is the character that was typed. 10197 * Return a pointer to allocated memory with the replacement string. 10198 * Return NULL to continue inserting "c". 10199 */ 10200 static char_u * 10201 do_insert_char_pre(c) 10202 int c; 10203 { 10204 char_u *res; 10205 char_u buf[MB_MAXBYTES + 1]; 10206 10207 /* Return quickly when there is nothing to do. */ 10208 if (!has_insertcharpre()) 10209 return NULL; 10210 10211 #ifdef FEAT_MBYTE 10212 if (has_mbyte) 10213 buf[(*mb_char2bytes)(c, buf)] = NUL; 10214 else 10215 #endif 10216 { 10217 buf[0] = c; 10218 buf[1] = NUL; 10219 } 10220 10221 /* Lock the text to avoid weird things from happening. */ 10222 ++textlock; 10223 set_vim_var_string(VV_CHAR, buf, -1); /* set v:char */ 10224 10225 res = NULL; 10226 if (apply_autocmds(EVENT_INSERTCHARPRE, NULL, NULL, FALSE, curbuf)) 10227 { 10228 /* Get the value of v:char. It may be empty or more than one 10229 * character. Only use it when changed, otherwise continue with the 10230 * original character to avoid breaking autoindent. */ 10231 if (STRCMP(buf, get_vim_var_str(VV_CHAR)) != 0) 10232 res = vim_strsave(get_vim_var_str(VV_CHAR)); 10233 } 10234 10235 set_vim_var_string(VV_CHAR, NULL, -1); /* clear v:char */ 10236 --textlock; 10237 10238 return res; 10239 } 10240 #endif 10241