开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
edit.c
资源名称：vim53src.zip　[点击查看]
上传用户：gddssl
上传日期：2007-01-06
资源大小：1003k
文件大小：128k
源码类别：

编辑器/阅读器

开发平台：

DOS

edit.c：源码内容
  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.  */
  9. /*
  10.  * edit.c: functions for Insert mode
  11.  */
  13. #include "vim.h"
  15. #ifdef INSERT_EXPAND
  16. /*
  17.  * definitions used for CTRL-X submode
  18.  */
  19. #define CTRL_X_WANT_IDENT 0x100
  21. #define CTRL_X_NOT_DEFINED_YET (1)
  22. #define CTRL_X_SCROLL (2)
  23. #define CTRL_X_WHOLE_LINE (3)
  24. #define CTRL_X_FILES (4)
  25. #define CTRL_X_TAGS (5 + CTRL_X_WANT_IDENT)
  26. #define CTRL_X_PATH_PATTERNS (6 + CTRL_X_WANT_IDENT)
  27. #define CTRL_X_PATH_DEFINES (7 + CTRL_X_WANT_IDENT)
  28. #define CTRL_X_FINISHED (8)
  29. #define CTRL_X_DICTIONARY (9 + CTRL_X_WANT_IDENT)
  31. #define C_X_SKIP (7) /* length of " Adding" */
  32. char *ctrl_x_msgs[] =
  33. {
  34.     " Adding Keyword completion (^N/^P)", /* ctrl_x_mode == 0, ^P/^N compl. */
  35.     " ^X mode (^E/^Y/^L/^]/^F/^I/^K/^D/^N/^P)",
  36.     /* Scroll has it's own msgs, in it's place there is the msg for local
  37.      * ctrl_x_mode = 0 (eg continue_status & CONT_LOCAL)  -- Acevedo */
  38.     " Adding Keyword Local completion (^N/^P)",
  39.     " Adding Whole line completion (^L/^N/^P)",
  40.     " Adding File name completion (^F/^N/^P)",
  41.     " Adding Tag completion (^]/^N/^P)",
  42.     " Adding Path pattern completion (^N/^P)",
  43.     " Adding Definition completion (^D/^N/^P)",
  44.     NULL,
  45.     " Adding Dictionary completion (^K/^N/^P)"
  46. };
  48. char_u e_hitend[] = "Hit end of paragraph";
  49. char_u e_hitend_f[] = "Hit end of paragraph (forward)";
  50. char_u e_hitend_b[] = "Hit end of paragraph (backward)";
  51. char_u e_patnotf_f[] = "Pattern not found (forward)";
  52. char_u e_patnotf_b[] = "Pattern not found (backward)";
  54. /*
  55.  * Structure used to store one match for insert completion.
  56.  */
  57. struct Completion
  58. {
  59.     struct Completion *next;
  60.     struct Completion *prev;
  61.     char_u *str;   /* matched text */
  62.     char_u *fname;   /* file containing the match */
  63.     int original; /* ORIGINAL_TEXT, CONT_S_IPOS or FREE_FNAME */
  64. };
  66. /* the original text when the expansion begun */
  67. #define ORIGINAL_TEXT (1)
  68. #define FREE_FNAME (2)
  69. /*
  70.  * All the current matches are stored in a list.
  71.  * "first_match" points to the start of the list.
  72.  * "curr_match" points to the currently selected entry.
  73.  */
  74. static struct Completion    *first_match = NULL;
  75. static struct Completion    *curr_match = NULL;
  76. static int     started_completion;
  77. static char_u     *complete_pat;
  78. static int     save_sm;
  79. static char_u     *original_text = NULL;  /* text before completion */
  80. static int     continue_mode = 0;
  82. static int  add_completion __ARGS((char_u *str, int len, char_u *, int dir, int reuse));
  83. static int  make_cyclic __ARGS((void));
  84. static void complete_dictionaries __ARGS((char_u *dict, char_u *pat, int dir, int flags));
  85. static void free_completions __ARGS((void));
  86. static void clear_insexp __ARGS((void));
  87. static int  ins_expand_pre __ARGS((int c));
  88. static BUF  *next_buf __ARGS((BUF *buf, int flag));
  89. static int  get_expansion __ARGS((FPOS *ini, int dir));
  90. static int  ins_complete __ARGS((int c));
  91. static int  quote_meta __ARGS((char_u *dest, char_u *str, int len));
  92. #endif /* INSERT_EXPAND */
  94. #define BACKSPACE_CHAR     1
  95. #define BACKSPACE_WORD     2
  96. #define BACKSPACE_WORD_NOT_SPACE    3
  97. #define BACKSPACE_LINE     4
  99. static void edit_putchar __ARGS((int c, int highlight));
  100. static void undisplay_dollar __ARGS((void));
  101. static void change_indent __ARGS((int type, int amount, int round, int replaced));
  102. static void insert_special __ARGS((int, int, int));
  103. static void redo_literal __ARGS((int c));
  104. static void start_arrow __ARGS((FPOS *end_insert_pos));
  105. static void stop_insert __ARGS((FPOS *end_insert_pos));
  106. static int  echeck_abbr __ARGS((int));
  107. static void replace_push_off __ARGS((int c));
  108. static int  replace_pop __ARGS((void));
  109. static void replace_join __ARGS((int off));
  110. static void replace_pop_ins __ARGS((void));
  111. static void replace_flush __ARGS((void));
  112. static void replace_do_bs __ARGS((void));
  113. static int  ins_reg __ARGS((void));
  114. static int  ins_esc __ARGS((long *count, int need_redraw, int cmdchar));
  115. #ifdef RIGHTLEFT
  116. static void ins_ctrl_ __ARGS((void));
  117. #endif
  118. static void ins_shift __ARGS((int c, int lastc));
  119. static void ins_del __ARGS((void));
  120. static int  ins_bs __ARGS((int c, int mode, int *inserted_space_p));
  121. #ifdef USE_MOUSE
  122. static void ins_mouse __ARGS((int c));
  123. #endif
  124. static void ins_left __ARGS((void));
  125. static void ins_home __ARGS((void));
  126. static void ins_end __ARGS((void));
  127. static void ins_s_left __ARGS((void));
  128. static void ins_right __ARGS((void));
  129. static void ins_s_right __ARGS((void));
  130. static void ins_up __ARGS((void));
  131. static void ins_pageup __ARGS((void));
  132. static void ins_down __ARGS((void));
  133. static void ins_pagedown __ARGS((void));
  134. static int  ins_tab __ARGS((void));
  135. static int  ins_eol __ARGS((int c));
  136. #ifdef DIGRAPHS
  137. static int  ins_digraph __ARGS((void));
  138. #endif
  139. static int  ins_copychar __ARGS((linenr_t lnum));
  140. #ifdef SMARTINDENT
  141. static void ins_try_si __ARGS((int c));
  142. #endif
  143. static colnr_t get_nolist_virtcol __ARGS((void));
  145. static FPOS Insstart; /* This is where the latest
  146.  * insert/append mode started. */
  147. static colnr_t Insstart_textlen; /* length of line when insert started */
  148. static colnr_t Insstart_blank_vcol; /* vcol for first inserted blank */
  150. static char_u *last_insert = NULL; /* the text of the previous insert */
  151. static int last_insert_skip; /* nr of chars in front of previous insert */
  152. static int new_insert_skip;  /* nr of chars in front of current insert */
  154. #ifdef CINDENT
  155. static int can_cindent; /* may do cindenting on this line */
  156. #endif
  158. static int old_indent = 0; /* for ^^D command in insert mode */
  160. #ifdef RIGHTLEFT
  161. int     revins_on;     /* reverse insert mode on */
  162. int     revins_chars;     /* how much to skip after edit */
  163. int     revins_legal;     /* was the last char 'legal'? */
  164. int     revins_scol;     /* start column of revins session */
  165. #endif
  167. /*
  168.  * edit(): Start insering text.
  169.  *
  170.  * "cmdchar" can be:
  171.  * 'i' normal insert command
  172.  * 'a' normal append command
  173.  * 'R' replace command
  174.  * 'r' "r<CR>" command: insert one <CR>.  Note: count can be > 1, for redo,
  175.  * but still only one <CR> is inserted.  The <Esc> is not used for redo.
  176.  * 'g' "gI" command.
  177.  *
  178.  * This function is not called recursively.  For CTRL-O commands, it returns
  179.  * and lets the caller handle the Normal-mode command.
  180.  *
  181.  * Return TRUE if a CTRL-O command caused the return (insert mode pending).
  182.  */
  183.     int
  184. edit(cmdchar, startln, count)
  185.     int cmdchar;
  186.     int startln; /* if set, insert at start of line */
  187.     long count;
  188. {
  189.     int  c = 0;
  190.     char_u *ptr;
  191.     int  lastc;
  192.     colnr_t  mincol;
  193.     static linenr_t o_lnum = 0;
  194.     static int  o_eol = FALSE;
  195.     int  need_redraw = FALSE;
  196.     int  i;
  197.     int  did_backspace = TRUE;     /* previous char was backspace */
  198. #ifdef CINDENT
  199.     int  line_is_white = FALSE;     /* line is empty before insert */
  200. #endif
  201.     linenr_t  old_topline = 0;     /* topline before insertion */
  202.     int  inserted_space = FALSE;    /* just inserted a space */
  203.     int  has_startsel;     /* may start selection */
  205.     /* sleep before redrawing, needed for "CTRL-O :" that results in an
  206.      * error message */
  207.     check_for_delay(TRUE);
  209. #ifdef INSERT_EXPAND
  210.     clear_insexp();     /* clear stuff for ctrl-x mode */
  211. #endif
  213. #ifdef USE_MOUSE
  214.     /*
  215.      * When doing a paste with the middle mouse button, Insstart is set to
  216.      * where the paste started.
  217.      */
  218.     if (where_paste_started.lnum != 0)
  219. Insstart = where_paste_started;
  220.     else
  221. #endif
  222.     {
  223. Insstart = curwin->w_cursor;
  224. if (startln)
  225.     Insstart.col = 0;
  226.     }
  227.     Insstart_textlen = linetabsize(ml_get_curline());
  228.     Insstart_blank_vcol = MAXCOL;
  230.     if (cmdchar != NUL && !restart_edit)
  231.     {
  232. ResetRedobuff();
  233. AppendNumberToRedobuff(count);
  234. AppendCharToRedobuff(cmdchar);
  235. if (cmdchar == 'g')     /* "gI" command */
  236.     AppendCharToRedobuff('I');
  237. else if (cmdchar == 'r')     /* "r<CR>" command */
  238.     count = 1;     /* insert only one <CR> */
  239.     }
  241.     if (cmdchar == 'R')
  242.     {
  243. #ifdef FKMAP
  244. if (p_fkmap && p_ri)
  245. {
  246.     beep_flush();
  247.     EMSG(farsi_text_3);     /* encoded in Farsi */
  248.     State = INSERT;
  249. }
  250. else
  251. #endif
  252. State = REPLACE;
  253.     }
  254.     else
  255. State = INSERT;
  256. #if defined(USE_GUI_WIN32) && defined(MULTI_BYTE_IME)
  257.     ImeSetOriginMode();
  258. #endif
  260.     /*
  261.      * Need to recompute the cursor position, it might move when the cursor is
  262.      * on a TAB or special character.
  263.      */
  264.     curs_columns(TRUE);
  266. #ifdef USE_MOUSE
  267.     setmouse();
  268. #endif
  269. #ifdef SHOWCMD
  270.     clear_showcmd();
  271. #endif
  272. #ifdef RIGHTLEFT
  273.     /* there is no reverse replace mode */
  274.     revins_on = (State == INSERT && p_ri);
  275.     if (revins_on)
  276. undisplay_dollar();
  277.     revins_chars = 0;
  278.     revins_legal = 0;
  279.     revins_scol = -1;
  280. #endif
  282.     /* if 'keymodel' contains "startsel", may start selection on shifted
  283.      * special key */
  284.     has_startsel = (vim_strchr(p_km, 'a') != NULL);
  286.     /*
  287.      * Handle restarting Insert mode.
  288.      * Don't do this for CTRL-O . (repeat an insert): we get here with
  289.      * restart_edit non-zero, and something in the stuff buffer.
  290.      */
  291.     if (restart_edit && stuff_empty())
  292.     {
  293. #ifdef USE_MOUSE
  294. /*
  295.  * After a paste we consider text typed to be part of the insert for
  296.  * the pasted text. You can backspace over the paste text too.
  297.  */
  298. if (where_paste_started.lnum)
  299.     arrow_used = FALSE;
  300. else
  301. #endif
  302.     arrow_used = TRUE;
  303. restart_edit = 0;
  305. /*
  306.  * If the cursor was after the end-of-line before the CTRL-O and it is
  307.  * now at the end-of-line, put it after the end-of-line (this is not
  308.  * correct in very rare cases).
  309.  * Also do this if curswant is greater than the current virtual
  310.  * column.  Eg after "^O$" or "^O80|".
  311.  */
  312. validate_virtcol();
  313. update_curswant();
  314. if (    ((o_eol && curwin->w_cursor.lnum == o_lnum)
  315.     || curwin->w_curswant > curwin->w_virtcol)
  316. && *(ptr = ml_get_curline() + curwin->w_cursor.col) != NUL
  317. && *(ptr + 1) == NUL)
  318.     ++curwin->w_cursor.col;
  319.     }
  320.     else
  321.     {
  322. arrow_used = FALSE;
  323. o_eol = FALSE;
  324.     }
  325. #ifdef USE_MOUSE
  326.     where_paste_started.lnum = 0;
  327. #endif
  328. #ifdef CINDENT
  329.     can_cindent = TRUE;
  330. #endif
  332.     /*
  333.      * If 'showmode' is set, show the current (insert/replace/..) mode.
  334.      * A warning message for changing a readonly file is given here, before
  335.      * actually changing anything.  It's put after the mode, if any.
  336.      */
  337.     i = 0;
  338.     if (p_smd)
  339. i = showmode();
  341.     if (!p_im)
  342. change_warning(i + 1);
  344. #ifdef CURSOR_SHAPE
  345.     ui_cursor_shape(); /* may show different cursor shape */
  346. #endif
  347. #ifdef DIGRAPHS
  348.     do_digraph(-1); /* clear digraphs */
  349. #endif
  351. /*
  352.  * Get the current length of the redo buffer, those characters have to be
  353.  * skipped if we want to get to the inserted characters.
  354.  */
  355.     ptr = get_inserted();
  356.     if (ptr == NULL)
  357. new_insert_skip = 0;
  358.     else
  359.     {
  360. new_insert_skip = STRLEN(ptr);
  361. vim_free(ptr);
  362.     }
  364.     old_indent = 0;
  366.     for (;;)
  367.     {
  368. #ifdef RIGHTLEFT
  369. if (!revins_legal)
  370.     revins_scol = -1;     /* reset on illegal motions */
  371. else
  372.     revins_legal = 0;
  373. #endif
  374. if (arrow_used)     /* don't repeat insert when arrow key used */
  375.     count = 0;
  377.     /* set curwin->w_curswant for next K_DOWN or K_UP */
  378. if (!arrow_used)
  379.     curwin->w_set_curswant = TRUE;
  381. /*
  382.  * When emsg() was called msg_scroll will have been set.
  383.  */
  384. msg_scroll = FALSE;
  386. /*
  387.  * If we inserted a character at the last position of the last line in
  388.  * the window, scroll the window one line up. This avoids an extra
  389.  * redraw.
  390.  * This is detected when the cursor column is smaller after inserting
  391.  * something.
  392.  * Don't do this when the topline changed already, it has
  393.  * already been adjusted (by insertchar() calling open_line())).
  394.  */
  395. if (need_redraw && curwin->w_p_wrap && !did_backspace &&
  396.      curwin->w_topline == old_topline)
  397. {
  398.     mincol = curwin->w_wcol;
  399.     validate_cursor_col();
  401.     if ((int)curwin->w_wcol < (int)mincol - curbuf->b_p_ts &&
  402.     curwin->w_wrow == curwin->w_winpos +
  403. curwin->w_height - 1 - p_so &&
  404.     curwin->w_cursor.lnum != curwin->w_topline)
  405.     {
  406. set_topline(curwin, curwin->w_topline + 1);
  407. update_topline();
  408. #ifdef SYNTAX_HL
  409. /* recompute syntax hl., starting with current line */
  410. syn_changed(curwin->w_cursor.lnum);
  411. #endif
  412. update_screen(VALID_TO_CURSCHAR);
  413. need_redraw = FALSE;
  414.     }
  415.     else
  416. update_topline();
  417. }
  418. else
  419.     update_topline();
  420. did_backspace = FALSE;
  422. /*
  423.  * redraw is postponed until here to make 'dollar' option work
  424.  * correctly.
  425.  */
  426. validate_cursor(); /* may set must_redraw */
  427. if (need_redraw || must_redraw)
  428. {
  429.     update_screenline();
  430.     if (curwin->w_redr_status == TRUE)
  431. win_redr_status(curwin); /* display [+] if required */
  432.     need_redraw = FALSE;
  433. }
  434. else if (clear_cmdline || redraw_cmdline)
  435.     showmode();     /* clear cmdline, show mode and ruler */
  437. showruler(FALSE);
  438. setcursor();
  439. update_curswant();
  440. emsg_on_display = FALSE; /* may remove error message now */
  441. old_topline = curwin->w_topline;
  443. #ifdef USE_GUI_WIN32
  444. dont_scroll = FALSE; /* allow scrolling here */
  445. #endif
  446. lastc = c; /* remember previous char for CTRL-D */
  447. c = vgetc();
  449. #ifdef RIGHTLEFT
  450. if (p_hkmap && KeyTyped)
  451.     c = hkmap(c); /* Hebrew mode mapping */
  452. #endif
  453. #ifdef FKMAP
  454. if (p_fkmap && KeyTyped)
  455.     c = fkmap(c); /* Farsi mode mapping */
  456. #endif
  458. #ifdef INSERT_EXPAND
  459. /*
  460.  * Prepare for or stop ctrl-x mode.
  461.  */
  462. need_redraw |= ins_expand_pre(c);
  463. #endif
  465. #ifdef DIGRAPHS
  466. c = do_digraph(c);
  467. #endif
  469. if (c == Ctrl('V') || c == Ctrl('Q'))
  470. {
  471.     if (redrawing() && !char_avail())
  472. edit_putchar('^', TRUE);
  473.     AppendToRedobuff((char_u *)"26"); /* CTRL-V */
  475. #ifdef SHOWCMD
  476.     add_to_showcmd_c(c);
  477. #endif
  479.     c = get_literal();
  480. #ifdef SHOWCMD
  481.     clear_showcmd();
  482. #endif
  483.     insert_special(c, FALSE, TRUE);
  484.     need_redraw = TRUE;
  485. #ifdef RIGHTLEFT
  486.     revins_chars++;
  487.     revins_legal++;
  488. #endif
  489.     c = Ctrl('V'); /* pretend CTRL-V is last typed character */
  490.     continue;
  491. }
  492. #ifdef MULTI_BYTE
  493. # if defined(USE_GUI) && !defined(USE_GUI_WIN32)
  494. if (!gui.in_use)
  495. # endif
  496. if (is_dbcs && IsLeadByte(c))
  497. {
  498.     int c2;
  500.     c2 = get_literal();
  501.     insert_special(c, FALSE, FALSE);
  502.     insert_special(c2, FALSE, FALSE);
  503.     need_redraw = TRUE;
  504.     continue;
  505. }
  506. #endif
  508. #ifdef CINDENT
  509. if (curbuf->b_p_cin
  510. # ifdef INSERT_EXPAND
  511.     && !ctrl_x_mode
  512. # endif
  513.        )
  514. {
  515.     line_is_white = inindent(0);
  517.     /*
  518.      * A key name preceded by a bang means that this
  519.      * key wasn't destined to be inserted.  Skip ahead
  520.      * to the re-indenting if we find one.
  521.      */
  522.     if (in_cinkeys(c, '!', line_is_white))
  523. goto force_cindent;
  525.     /*
  526.      * A key name preceded by a star means that indenting
  527.      * has to be done before inserting the key.
  528.      */
  529.     if (can_cindent && in_cinkeys(c, '*', line_is_white))
  530.     {
  531. stop_arrow();
  533. /* re-indent the current line */
  534. fixthisline(get_c_indent);
  536. /* draw the changes on the screen later */
  537. need_redraw = TRUE;
  538.     }
  539. }
  540. #endif /* CINDENT */
  542. #ifdef RIGHTLEFT
  543. if (curwin->w_p_rl)
  544.     switch (c)
  545.     {
  546. case K_LEFT: c = K_RIGHT; break;
  547. case K_S_LEFT: c = K_S_RIGHT; break;
  548. case K_RIGHT: c = K_LEFT; break;
  549. case K_S_RIGHT: c = K_S_LEFT; break;
  550.     }
  551. #endif
  553. /* if 'keymodel' contains "startsel", may start selection */
  554. if (has_startsel)
  555.     switch (c)
  556.     {
  557. case K_KHOME:
  558. case K_KEND:
  559. case K_PAGEUP:
  560. case K_KPAGEUP:
  561. case K_PAGEDOWN:
  562. case K_KPAGEDOWN:
  563.     if (!(mod_mask & MOD_MASK_SHIFT))
  564. break;
  565.     /* FALLTHROUGH */
  566. case K_S_LEFT:
  567. case K_S_RIGHT:
  568. case K_S_UP:
  569. case K_S_DOWN:
  570. case K_S_END:
  571. case K_S_HOME:
  572.     /* Start selection right away, the cursor can move with
  573.      * CTRL-O when beyond the end of the line. */
  574.     start_selection();
  576.     /* Execute the key in (insert) Select mode, unless it's
  577.      * shift-left and beyond the end of the line (the CTRL-O
  578.      * will move the cursor left already). */
  579.     stuffcharReadbuff(Ctrl('O'));
  580.     if (c != K_S_LEFT || gchar_cursor() != NUL)
  581.     {
  582. if (mod_mask)
  583. {
  584.     char_u     buf[4];
  586.     buf[0] = K_SPECIAL;
  587.     buf[1] = KS_MODIFIER;
  588.     buf[2] = mod_mask;
  589.     buf[3] = NUL;
  590.     stuffReadbuff(buf);
  591. }
  592. stuffcharReadbuff(c);
  593.     }
  594.     continue;
  595.     }
  597. /*
  598.  * The big switch to handle a character in insert mode.
  599.  */
  600. switch (c)
  601. {
  602. case K_INS:     /* toggle insert/replace mode */
  603. #ifdef FKMAP
  604.     if (p_fkmap && p_ri)
  605.     {
  606. beep_flush();
  607. EMSG(farsi_text_3); /* encoded in Farsi */
  608. break;
  609.     }
  610. #endif
  611.     if (State == REPLACE)
  612. State = INSERT;
  613.     else
  614. State = REPLACE;
  615.     AppendCharToRedobuff(K_INS);
  616.     showmode();
  617. #ifdef CURSOR_SHAPE
  618.     ui_cursor_shape(); /* may show different cursor shape */
  619. #endif
  620.     break;
  622. #ifdef INSERT_EXPAND
  623. case Ctrl('X'):     /* Enter ctrl-x mode */
  624.     /* if the next ^X<> won't ADD nothing, then reset continue_status */
  625.     continue_status = continue_status & CONT_N_ADDS ?
  626. continue_status | CONT_INTRPT : 0;
  627.     /* We're not sure which ctrl-x mode it will be yet */
  628.     ctrl_x_mode = CTRL_X_NOT_DEFINED_YET;
  629.     edit_submode = (char_u *)ctrl_x_msgs[ctrl_x_mode & 15];
  630.     showmode();
  631.     break;
  632. #endif
  634. case K_SELECT:     /* end of Select mode mapping - ignore */
  635.     break;
  637. case Ctrl('Z'):     /* suspend when 'insertmode' set */
  638.     if (!p_im)
  639. goto normalchar; /* insert CTRL-Z as normal char */
  640.     stuffReadbuff((char_u *)":str");
  641.     c = Ctrl('O');
  642.     /*FALLTHROUGH*/
  644. case Ctrl('O'):     /* execute one command */
  645.     if (echeck_abbr(Ctrl('O') + ABBR_OFF))
  646. break;
  647.     count = 0;
  648.     if (State == INSERT)
  649. restart_edit = 'I';
  650.     else
  651. restart_edit = 'R';
  652.     o_lnum = curwin->w_cursor.lnum;
  653.     o_eol = (gchar_cursor() == NUL);
  654.     goto doESCkey;
  656. #ifdef USE_SNIFF
  657. case K_SNIFF:
  658.     stuffcharReadbuff(K_SNIFF);
  659.     goto doESCkey;
  660. #endif
  662.   /* Hitting the help key in insert mode is like <ESC> <Help> */
  663. case K_HELP:
  664. case K_F1:
  665.     stuffcharReadbuff(K_HELP);
  666.     if (p_im)
  667. stuffcharReadbuff('i');
  668.     goto doESCkey;
  670. case ESC:     /* an escape ends input mode */
  671.     if (echeck_abbr(ESC + ABBR_OFF))
  672. break;
  673.     /*FALLTHROUGH*/
  675. case Ctrl('C'):
  676. #ifdef UNIX
  677. do_intr:
  678. #endif
  679.     /* when 'insertmode' set, and not halfway a mapping, don't leave
  680.      * Insert mode */
  681.     if (goto_im())
  682.     {
  683. if (got_int)
  684. {
  685.     (void)vgetc(); /* flush all buffers */
  686.     got_int = FALSE;
  687. }
  688. else
  689.     vim_beep();
  690. break;
  691.     }
  692. doESCkey:
  693.     /*
  694.      * This is the ONLY return from edit()!
  695.      */
  696.     if (ins_esc(&count, need_redraw, cmdchar))
  697. return (c == Ctrl('O'));
  698.     continue;
  700.     /*
  701.      * Insert the previously inserted text.
  702.      * For ^@ the trailing ESC will end the insert, unless there
  703.      * is an error.
  704.      */
  705. case K_ZERO:
  706. case NUL:
  707. case Ctrl('A'):
  708.     if (stuff_inserted(NUL, 1L, (c == Ctrl('A'))) == FAIL
  709.    && c != Ctrl('A') && !p_im)
  710. goto doESCkey; /* quit insert mode */
  711.     break;
  713. /*
  714.  * insert the contents of a register
  715.  */
  716. case Ctrl('R'):
  717.     need_redraw |= ins_reg();
  718.     break;
  720. #ifdef RIGHTLEFT
  721. case Ctrl('_'):
  722.     if (!p_ari)
  723. goto normalchar;
  724.     ins_ctrl_();
  725.     break;
  726. #endif
  728. /* Make indent one shiftwidth smaller. */
  729. case Ctrl('D'):
  730. #if defined(INSERT_EXPAND) && defined(FIND_IN_PATH)
  731.     if (ctrl_x_mode == CTRL_X_PATH_DEFINES)
  732. goto docomplete;
  733. #endif
  734.     /* FALLTHROUGH */
  736. /* Make indent one shiftwidth greater. */
  737. case Ctrl('T'):
  738.     ins_shift(c, lastc);
  739.     need_redraw = TRUE;
  740.     break;
  742. /* delete character under the cursor */
  743. case K_DEL:
  744.     ins_del();
  745.     need_redraw = TRUE;
  746.     break;
  748. /* delete character before the cursor */
  749. case K_BS:
  750. case Ctrl('H'):
  751.     did_backspace = ins_bs(c, BACKSPACE_CHAR, &inserted_space);
  752.     need_redraw = TRUE;
  753.     break;
  755. /* delete word before the cursor */
  756. case Ctrl('W'):
  757.     did_backspace = ins_bs(c, BACKSPACE_WORD, &inserted_space);
  758.     need_redraw = TRUE;
  759.     break;
  761. /* delete all inserted text in current line */
  762. case Ctrl('U'):
  763.     did_backspace = ins_bs(c, BACKSPACE_LINE, &inserted_space);
  764.     need_redraw = TRUE;
  765.     break;
  767. #ifdef USE_MOUSE
  768. case K_LEFTMOUSE:
  769. case K_LEFTDRAG:
  770. case K_LEFTRELEASE:
  771. case K_MIDDLEMOUSE:
  772. case K_MIDDLEDRAG:
  773. case K_MIDDLERELEASE:
  774. case K_RIGHTMOUSE:
  775. case K_RIGHTDRAG:
  776. case K_RIGHTRELEASE:
  777.     ins_mouse(c);
  778.     break;
  780. case K_IGNORE:
  781.     break;
  782. #endif
  784. #ifdef USE_GUI
  785. case K_SCROLLBAR:
  786.     ins_scroll();
  787.     break;
  789. case K_HORIZ_SCROLLBAR:
  790.     ins_horscroll();
  791.     break;
  792. #endif
  794. case K_HOME:
  795. case K_KHOME:
  796. case K_S_HOME:
  797.     ins_home();
  798.     break;
  800. case K_END:
  801. case K_KEND:
  802. case K_S_END:
  803.     ins_end();
  804.     break;
  806. case K_LEFT:
  807.     if (mod_mask & MOD_MASK_CTRL)
  808. ins_s_left();
  809.     else
  810. ins_left();
  811.     break;
  813. case K_S_LEFT:
  814.     ins_s_left();
  815.     break;
  817. case K_RIGHT:
  818.     if (mod_mask & MOD_MASK_CTRL)
  819. ins_s_right();
  820.     else
  821. ins_right();
  822.     break;
  824. case K_S_RIGHT:
  825.     ins_s_right();
  826.     break;
  828. case K_UP:
  829.     ins_up();
  830.     break;
  832. case K_S_UP:
  833. case K_PAGEUP:
  834. case K_KPAGEUP:
  835.     ins_pageup();
  836.     break;
  838. case K_DOWN:
  839.     ins_down();
  840.     break;
  842. case K_S_DOWN:
  843. case K_PAGEDOWN:
  844. case K_KPAGEDOWN:
  845.     ins_pagedown();
  846.     break;
  848.     /* keypad keys: When not mapped they produce a normal char */
  849. case K_KPLUS: c = '+'; goto normalchar;
  850. case K_KMINUS: c = '-'; goto normalchar;
  851. case K_KDIVIDE: c = '/'; goto normalchar;
  852. case K_KMULTIPLY: c = '*'; goto normalchar;
  854.     /* When <S-Tab> isn't mapped, use it like a normal TAB */
  855. case K_S_TAB:
  856.     c = TAB;
  857.     /* FALLTHROUGH */
  859. /* TAB or Complete patterns along path */
  860. case TAB:
  861. #if defined(INSERT_EXPAND) && defined(FIND_IN_PATH)
  862.     if (ctrl_x_mode == CTRL_X_PATH_PATTERNS)
  863. goto docomplete;
  864. #endif
  865.     inserted_space = FALSE;
  866.     if (ins_tab())
  867. goto normalchar; /* insert TAB as a normal char */
  868.     need_redraw = TRUE;
  869.     break;
  871. case K_KENTER:
  872.     c = CR;
  873.     /* FALLTHROUGH */
  874. case CR:
  875. case NL:
  876.     if (ins_eol(c) && !p_im)
  877. goto doESCkey;     /* out of memory */
  878.     break;
  880. #if defined(DIGRAPHS) || defined (INSERT_EXPAND)
  881. case Ctrl('K'):
  882. # ifdef INSERT_EXPAND
  883.     if (ctrl_x_mode == CTRL_X_DICTIONARY)
  884.     {
  885. if (*p_dict == NUL)
  886. {
  887.     ctrl_x_mode = 0;
  888.     msg_attr((char_u *)"'dictionary' option is empty",
  889.      hl_attr(HLF_E));
  890.     vim_beep();
  891.     setcursor();
  892.     out_flush();
  893.     ui_delay(2000L, FALSE);
  894.     break;
  895. }
  896. goto docomplete;
  897.     }
  898. # endif
  899. # ifdef DIGRAPHS
  900.     c = ins_digraph();
  901.     if (c == NUL)
  902.     {
  903. need_redraw = TRUE;
  904. break;
  905.     }
  906. # endif
  907.     goto normalchar;
  908. #endif /* DIGRAPHS || INSERT_EXPAND */
  910. #ifdef INSERT_EXPAND
  911. case Ctrl(']'): /* Tag name completion after ^X */
  912.     if (ctrl_x_mode != CTRL_X_TAGS)
  913. goto normalchar;
  914.     goto docomplete;
  916. case Ctrl('F'): /* File name completion after ^X */
  917.     if (ctrl_x_mode != CTRL_X_FILES)
  918. goto normalchar;
  919.     goto docomplete;
  920. #endif
  922. case Ctrl('L'): /* Whole line completion after ^X */
  923. #ifdef INSERT_EXPAND
  924.     if (ctrl_x_mode != CTRL_X_WHOLE_LINE)
  925. #endif
  926.     {
  927. /* CTRL-L with 'insertmode' set: Leave Insert mode */
  928. if (p_im)
  929. {
  930.     if (echeck_abbr(Ctrl('L') + ABBR_OFF))
  931. break;
  932.     goto doESCkey;
  933. }
  934. goto normalchar;
  935.     }
  936. #ifdef INSERT_EXPAND
  937.     /* FALLTHROUGH */
  939. case Ctrl('P'): /* Do previous pattern completion */
  940. case Ctrl('N'): /* Do next pattern completion */
  941.     /* if 'complete' is empty then plain ^P is no longer special,
  942.      * but it is under other ^X modes */
  943.     if (    *curbuf->b_p_cpt == NUL && !ctrl_x_mode
  944.     && !(continue_status & CONT_LOCAL))
  945. goto normalchar;
  946. docomplete:
  947.     i = ins_complete(c);
  948.     if (i)
  949. need_redraw |= i;
  950.     else
  951. continue_status = 0;
  952.     break;
  953. #endif /* INSERT_EXPAND */
  955. case Ctrl('Y'): /* copy from previous line or scroll down */
  956. case Ctrl('E'): /* copy from next line    or scroll up */
  957. #ifdef INSERT_EXPAND
  958.     if (ctrl_x_mode == CTRL_X_SCROLL)
  959.     {
  960. if (c == Ctrl('Y'))
  961.     scrolldown_clamp();
  962. else
  963.     scrollup_clamp();
  964. update_screen(VALID);
  965.     }
  966.     else
  967. #endif
  968.     {
  969. c = ins_copychar(curwin->w_cursor.lnum
  970.  + (c == Ctrl('Y') ? -1 : 1));
  971. if (c != NUL)
  972. {
  973.     long tw_save;
  975.     /* The character must be taken literally, insert like it
  976.      * was typed after a CTRL-V, and pretend 'textwidth'
  977.      * wasn't set.  Digits, 'o' and 'x' are special after a
  978.      * CTRL-V, don't use it for these. */
  979.     if (!isalnum(c))
  980. AppendToRedobuff((char_u *)"26"); /* CTRL-V */
  981.     tw_save = curbuf->b_p_tw;
  982.     curbuf->b_p_tw = -1;
  983.     insert_special(c, TRUE, TRUE);
  984.     curbuf->b_p_tw = tw_save;
  985.     need_redraw = TRUE;
  986. #ifdef RIGHTLEFT
  987.     revins_chars++;
  988.     revins_legal++;
  989. #endif
  990.     c = Ctrl('V'); /* pretend CTRL-V is last character */
  991. }
  992.     }
  993.     break;
  995.   default:
  996. #ifdef UNIX
  997.     if (c == intr_char) /* special interrupt char */
  998. goto do_intr;
  999. #endif
  1001. normalchar:
  1002. #ifdef SMARTINDENT
  1003.     /*
  1004.      * Try to perform smart-indenting.
  1005.      */
  1006.     ins_try_si(c);
  1007. #endif
  1009.     if (c == ' ')
  1010.     {
  1011. inserted_space = TRUE;
  1012. #ifdef CINDENT
  1013. if (inindent(0))
  1014.     can_cindent = FALSE;
  1015. #endif
  1016. if (Insstart_blank_vcol == MAXCOL
  1017. && curwin->w_cursor.lnum == Insstart.lnum)
  1018.     Insstart_blank_vcol = get_nolist_virtcol();
  1019.     }
  1021.     if (vim_iswordc(c) || !echeck_abbr(c))
  1022.     {
  1023. insert_special(c, FALSE, FALSE);
  1024. need_redraw = TRUE;
  1025. #ifdef RIGHTLEFT
  1026. revins_legal++;
  1027. revins_chars++;
  1028. #endif
  1029.     }
  1030.     break;
  1031. }   /* end of switch (c) */
  1033. #ifdef CINDENT
  1034. if (curbuf->b_p_cin && can_cindent
  1035. # ifdef INSERT_EXPAND
  1036.     && !ctrl_x_mode
  1037. # endif
  1038.        )
  1039. {
  1040. force_cindent:
  1041.     /*
  1042.      * Indent now if a key was typed that is in 'cinkeys'.
  1043.      */
  1044.     if (in_cinkeys(c, ' ', line_is_white))
  1045.     {
  1046. stop_arrow();
  1048. /* re-indent the current line */
  1049. fixthisline(get_c_indent);
  1051. /* draw the changes on the screen later */
  1052. need_redraw = TRUE;
  1053.     }
  1054. }
  1055. #endif /* CINDENT */
  1057.     } /* for (;;) */
  1058.     /* NOTREACHED */
  1059. }
  1061. /*
  1062.  * Put a character directly onto the screen.  It's not stored in a buffer.
  1063.  * Used while handling CTRL-K, CTRL-V, etc. in Insert mode.
  1064.  */
  1065.     static void
  1066. edit_putchar(c, highlight)
  1067.     int     c;
  1068.     int     highlight;
  1069. {
  1070.     int     attr;
  1072.     if (NextScreen != NULL)
  1073.     {
  1074. update_topline(); /* just in case w_topline isn't valid */
  1075. validate_cursor();
  1076. if (highlight)
  1077.     attr = hl_attr(HLF_8);
  1078. else
  1079.     attr = 0;
  1080. screen_putchar(c, curwin->w_winpos + curwin->w_wrow,
  1081. #ifdef RIGHTLEFT
  1082.     curwin->w_p_rl ? (int)Columns - 1 - curwin->w_wcol :
  1083. #endif
  1084.  curwin->w_wcol, attr);
  1085.     }
  1086. }
  1088. /*
  1089.  * Called when p_dollar is set: display a '$' at the end of the changed text
  1090.  * Only works when cursor is in the line that changes.
  1091.  */
  1092.     void
  1093. display_dollar(col)
  1094.     colnr_t col;
  1095. {
  1096.     colnr_t save_col;
  1098.     if (!redrawing())
  1099. return;
  1101.     cursor_off();
  1102.     save_col = curwin->w_cursor.col;
  1103.     curwin->w_cursor.col = col;
  1104.     curs_columns(FALSE);     /* recompute w_wrow and w_wcol */
  1105.     if (curwin->w_wcol < Columns)
  1106.     {
  1107. edit_putchar('$', FALSE);
  1108. dollar_vcol = curwin->w_virtcol;
  1109.     }
  1110.     curwin->w_cursor.col = save_col;
  1111. }
  1113. /*
  1114.  * Call this function before moving the cursor from the normal insert position
  1115.  * in insert mode.
  1116.  */
  1117.     static void
  1118. undisplay_dollar()
  1119. {
  1120.     if (dollar_vcol)
  1121.     {
  1122. dollar_vcol = 0;
  1123. update_screenline();
  1124.     }
  1125. }
  1127. /*
  1128.  * Insert an indent (for <Tab> or CTRL-T) or delete an indent (for CTRL-D).
  1129.  * Keep the cursor on the same character.
  1130.  * type == INDENT_INC increase indent (for CTRL-T or <Tab>)
  1131.  * type == INDENT_DEC decrease indent (for CTRL-D)
  1132.  * type == INDENT_SET set indent to "amount"
  1133.  * if round is TRUE, round the indent to 'shiftwidth' (only with _INC and _Dec).
  1134.  */
  1135.     static void
  1136. change_indent(type, amount, round, replaced)
  1137.     int     type;
  1138.     int     amount;
  1139.     int     round;
  1140.     int     replaced; /* replaced character, put on replace stack */
  1141. {
  1142.     int vcol;
  1143.     int last_vcol;
  1144.     int insstart_less; /* reduction for Insstart.col */
  1145.     int new_cursor_col;
  1146.     int i;
  1147.     char_u *ptr;
  1148.     int save_p_list;
  1149.     int start_col;
  1150.     colnr_t vc;
  1152.     /* for the following tricks we don't want list mode */
  1153.     save_p_list = curwin->w_p_list;
  1154.     curwin->w_p_list = FALSE;
  1155.     getvcol(curwin, &curwin->w_cursor, NULL, &vc, NULL);
  1156.     vcol = vc;
  1158.     /*
  1159.      * For Replace mode we need to fix the replace stack later, which is only
  1160.      * possible when the cursor is in the indent.  Remember the number of
  1161.      * characters before the cursor if it's possible.
  1162.      */
  1163.     start_col = curwin->w_cursor.col;
  1165.     /* determine offset from first non-blank */
  1166.     new_cursor_col = curwin->w_cursor.col;
  1167.     beginline(BL_WHITE);
  1168.     new_cursor_col -= curwin->w_cursor.col;
  1170.     insstart_less = curwin->w_cursor.col;
  1172.     /*
  1173.      * If the cursor is in the indent, compute how many screen columns the
  1174.      * cursor is to the left of the first non-blank.
  1175.      */
  1176.     if (new_cursor_col < 0)
  1177. vcol = get_indent() - vcol;
  1179.     if (new_cursor_col > 0)     /* can't fix replace stack */
  1180. start_col = -1;
  1182.     /*
  1183.      * Set the new indent.  The cursor will be put on the first non-blank.
  1184.      */
  1185.     if (type == INDENT_SET)
  1186. set_indent(amount, TRUE);
  1187.     else
  1188. shift_line(type == INDENT_DEC, round, 1);
  1189.     insstart_less -= curwin->w_cursor.col;
  1191.     /*
  1192.      * Try to put cursor on same character.
  1193.      * If the cursor is at or after the first non-blank in the line,
  1194.      * compute the cursor column relative to the column of the first
  1195.      * non-blank character.
  1196.      * If we are not in insert mode, leave the cursor on the first non-blank.
  1197.      * If the cursor is before the first non-blank, position it relative
  1198.      * to the first non-blank, counted in screen columns.
  1199.      */
  1200.     if (new_cursor_col >= 0)
  1201. new_cursor_col += curwin->w_cursor.col;
  1202.     else if (!(State & INSERT))
  1203. new_cursor_col = curwin->w_cursor.col;
  1204.     else
  1205.     {
  1206. /*
  1207.  * Compute the screen column where the cursor should be.
  1208.  */
  1209. vcol = get_indent() - vcol;
  1210. curwin->w_virtcol = (vcol < 0) ? 0 : vcol;
  1212. /*
  1213.  * Advance the cursor until we reach the right screen column.
  1214.  */
  1215. vcol = last_vcol = 0;
  1216. new_cursor_col = -1;
  1217. ptr = ml_get_curline();
  1218. while (vcol <= (int)curwin->w_virtcol)
  1219. {
  1220.     last_vcol = vcol;
  1221.     ++new_cursor_col;
  1222.     vcol += lbr_chartabsize(ptr + new_cursor_col, (colnr_t)vcol);
  1223. }
  1224. vcol = last_vcol;
  1226. /*
  1227.  * May need to insert spaces to be able to position the cursor on
  1228.  * the right screen column.
  1229.  */
  1230. if (vcol != (int)curwin->w_virtcol)
  1231. {
  1232.     curwin->w_cursor.col = new_cursor_col;
  1233.     i = (int)curwin->w_virtcol - vcol;
  1234.     ptr = alloc(i + 1);
  1235.     if (ptr != NULL)
  1236.     {
  1237. new_cursor_col += i;
  1238. ptr[i] = NUL;
  1239. while (--i >= 0)
  1240.     ptr[i] = ' ';
  1241. ins_str(ptr);
  1242. vim_free(ptr);
  1243.     }
  1244. }
  1246. /*
  1247.  * When changing the indent while the cursor is in it, reset
  1248.  * Insstart_col to 0.
  1249.  */
  1250. insstart_less = Insstart.col;
  1251.     }
  1253.     curwin->w_p_list = save_p_list;
  1255.     if (new_cursor_col <= 0)
  1256. curwin->w_cursor.col = 0;
  1257.     else
  1258. curwin->w_cursor.col = new_cursor_col;
  1259.     curwin->w_set_curswant = TRUE;
  1260.     changed_cline_bef_curs();
  1262.     /*
  1263.      * May have to adjust the start of the insert.
  1264.      */
  1265.     if ((State & INSERT) && curwin->w_cursor.lnum == Insstart.lnum &&
  1266.     Insstart.col != 0)
  1267.     {
  1268. if ((int)Insstart.col <= insstart_less)
  1269.     Insstart.col = 0;
  1270. else
  1271.     Insstart.col -= insstart_less;
  1272.     }
  1274.     /*
  1275.      * May have to fix the replace stack, if it's possible.
  1276.      * If the number of characters before the cursor decreased, need to pop a
  1277.      * few characters from the replace stack.
  1278.      * If the number of characters before the cursor increased, need to push a
  1279.      * few NULs onto the replace stack.
  1280.      */
  1281.     if (State == REPLACE && start_col >= 0)
  1282.     {
  1283. while (start_col > (int)curwin->w_cursor.col)
  1284. {
  1285.     replace_join(0);     /* remove a NUL from the replace stack */
  1286.     --start_col;
  1287. }
  1288. while (start_col < (int)curwin->w_cursor.col || replaced)
  1289. {
  1290.     replace_push(NUL);
  1291.     if (replaced)
  1292.     {
  1293. replace_push(replaced);
  1294. replaced = NUL;
  1295.     }
  1296.     ++start_col;
  1297. }
  1298.     }
  1299. }
  1301. #ifdef INSERT_EXPAND
  1302. /*
  1303.  * Is the character 'c' a valid key to keep us in the current ctrl-x mode?
  1304.  * -- webb
  1305.  */
  1306.     int
  1307. vim_is_ctrl_x_key(c)
  1308.     int     c;
  1309. {
  1310.     switch (ctrl_x_mode)
  1311.     {
  1312. case 0:     /* Not in any ctrl-x mode */
  1313.     break;
  1314. case CTRL_X_NOT_DEFINED_YET:
  1315.     if (       c == Ctrl('X') || c == Ctrl('Y') || c == Ctrl('E')
  1316.     || c == Ctrl('L') || c == Ctrl('F') || c == Ctrl(']')
  1317.     || c == Ctrl('I') || c == Ctrl('D') || c == Ctrl('P')
  1318.     || c == Ctrl('N'))
  1319. return TRUE;
  1320.     break;
  1321. case CTRL_X_SCROLL:
  1322.     if (c == Ctrl('Y') || c == Ctrl('E'))
  1323. return TRUE;
  1324.     break;
  1325. case CTRL_X_WHOLE_LINE:
  1326.     if (c == Ctrl('L') || c == Ctrl('P') || c == Ctrl('N'))
  1327. return TRUE;
  1328.     break;
  1329. case CTRL_X_FILES:
  1330.     if (c == Ctrl('F') || c == Ctrl('P') || c == Ctrl('N'))
  1331. return TRUE;
  1332.     break;
  1333. case CTRL_X_DICTIONARY:
  1334.     if (c == Ctrl('K') || c == Ctrl('P') || c == Ctrl('N'))
  1335. return TRUE;
  1336.     break;
  1337. case CTRL_X_TAGS:
  1338.     if (c == Ctrl(']') || c == Ctrl('P') || c == Ctrl('N'))
  1339. return TRUE;
  1340.     break;
  1341. #ifdef FIND_IN_PATH
  1342. case CTRL_X_PATH_PATTERNS:
  1343.     if (c == Ctrl('P') || c == Ctrl('N'))
  1344. return TRUE;
  1345.     break;
  1346. case CTRL_X_PATH_DEFINES:
  1347.     if (c == Ctrl('D') || c == Ctrl('P') || c == Ctrl('N'))
  1348. return TRUE;
  1349.     break;
  1350. #endif
  1351. default:
  1352.     emsg(e_internal);
  1353.     break;
  1354.     }
  1355.     return FALSE;
  1356. }
  1358. /*
  1359.  * This is like add_completion(), but if ic and inf are set, then the
  1360.  * case of the originally typed text is used, and the case of the completed
  1361.  * text is infered, ie this tries to work out what case you probably wanted
  1362.  * the rest of the word to be in -- webb
  1363.  */
  1364.     int
  1365. add_completion_and_infercase(str, len, fname, dir, reuse)
  1366.     char_u  *str;
  1367.     int     len;
  1368.     char_u  *fname;
  1369.     int     dir;
  1370.     int     reuse;
  1371. {
  1372.     int has_lower = FALSE;
  1373.     int was_letter = FALSE;
  1374.     int idx;
  1376.     if (p_ic && curbuf->b_p_inf && len < IOSIZE)
  1377.     {
  1378. /* Infer case of completed part -- webb */
  1379. /* Use IObuff, str would change text in buffer! */
  1380. STRNCPY(IObuff, str, len);
  1381. IObuff[len] = NUL;
  1383. /* Rule 1: Were any chars converted to lower? */
  1384. for (idx = 0; idx < completion_length; ++idx)
  1385. {
  1386.     if (islower(original_text[idx]))
  1387.     {
  1388. has_lower = TRUE;
  1389. if (isupper(IObuff[idx]))
  1390. {
  1391.     /* Rule 1 is satisfied */
  1392.     for (idx = completion_length; idx < len; ++idx)
  1393. IObuff[idx] = TO_LOWER(IObuff[idx]);
  1394.     break;
  1395. }
  1396.     }
  1397. }
  1399. /*
  1400.  * Rule 2: No lower case, 2nd consecutive letter converted to
  1401.  * upper case.
  1402.  */
  1403. if (!has_lower)
  1404. {
  1405.     for (idx = 0; idx < completion_length; ++idx)
  1406.     {
  1407. if (was_letter && isupper(original_text[idx]) &&
  1408.     islower(IObuff[idx]))
  1409. {
  1410.     /* Rule 2 is satisfied */
  1411.     for (idx = completion_length; idx < len; ++idx)
  1412. IObuff[idx] = TO_UPPER(IObuff[idx]);
  1413.     break;
  1414. }
  1415. was_letter = isalpha(original_text[idx]);
  1416.     }
  1417. }
  1419. /* Copy the original case of the part we typed */
  1420. STRNCPY(IObuff, original_text, completion_length);
  1422. return add_completion(IObuff, len, fname, dir, reuse);
  1423.     }
  1424.     return add_completion(str, len, fname, dir, reuse);
  1425. }
  1427. /*
  1428.  * Add a match to the list of matches.
  1429.  * If the given string is already in the list of completions, then return
  1430.  * FAIL, otherwise add it to the list and return OK.  If there is an error,
  1431.  * maybe because alloc returns NULL, then RET_ERROR is returned -- webb.
  1432.  */
  1433.     static int
  1434. add_completion(str, len, fname, dir, reuse)
  1435.     char_u  *str;
  1436.     int     len;
  1437.     char_u  *fname;
  1438.     int     dir;
  1439.     int     reuse;
  1440. {
  1441.     struct Completion *match;
  1443.     ui_breakcheck();
  1444.     if (got_int)
  1445. return RET_ERROR;
  1446.     if (len < 0)
  1447. len = STRLEN(str);
  1449.     /*
  1450.      * If the same match is already present, don't add it.
  1451.      */
  1452.     if (first_match != NULL)
  1453.     {
  1454. match = first_match;
  1455. do
  1456. {
  1457.     if (    !(match->original & ORIGINAL_TEXT)
  1458.     && STRNCMP(match->str, str, (size_t)len) == 0
  1459.     && match->str[len] == NUL)
  1460. return FAIL;
  1461.     match = match->next;
  1462. } while (match != NULL && match != first_match);
  1463.     }
  1465.     /*
  1466.      * Allocate a new match structure.
  1467.      * Copy the values to the new match structure.
  1468.      */
  1469.     match = (struct Completion *)alloc((unsigned)sizeof(struct Completion));
  1470.     if (match == NULL)
  1471. return RET_ERROR;
  1472.     if (reuse & ORIGINAL_TEXT)
  1473. match->str = original_text;
  1474.     else if ((match->str = vim_strnsave(str, len)) == NULL)
  1475.     {
  1476. vim_free(match);
  1477. return RET_ERROR;
  1478.     }
  1479.     /* match-fname is:
  1480.      * - curr_match->fname if it is a string equal to fname.
  1481.      * - a copy of fname, FREE_FNAME is set to free later THE allocated mem.
  1482.      * - NULL otherwise. --Acevedo */
  1483.     if (fname && curr_match && curr_match->fname
  1484.       && STRCMP(fname, curr_match->fname) == 0)
  1485. match->fname = curr_match->fname;
  1486.     else if (fname && (match->fname = vim_strsave(fname)) != NULL)
  1487. reuse |= FREE_FNAME;
  1488.     else
  1489. match->fname = NULL;
  1490.     match->original = reuse;
  1492.     /*
  1493.      * Link the new match structure in the list of matches.
  1494.      */
  1495.     if (first_match == NULL)
  1496. match->next = match->prev = NULL;
  1497.     else if (dir == FORWARD)
  1498.     {
  1499. match->next = curr_match->next;
  1500. match->prev = curr_match;
  1501.     }
  1502.     else /* BACKWARD */
  1503.     {
  1504. match->next = curr_match;
  1505. match->prev = curr_match->prev;
  1506.     }
  1507.     if (match->next)
  1508. match->next->prev = match;
  1509.     if (match->prev)
  1510. match->prev->next = match;
  1511.     else /* if there's nothing before, it is the first match */
  1512. first_match = match;
  1513.     curr_match = match;
  1515.     return OK;
  1516. }
  1518. /* Make the completion list cyclic.
  1519.  * Return the number of matches (excluding the original).
  1520.  */
  1521.     static int
  1522. make_cyclic()
  1523. {
  1524.     struct Completion *match;
  1525.     int     count = 0;
  1527.     if (first_match != NULL)
  1528.     {
  1529. /*
  1530.  * Find the end of the list.
  1531.  */
  1532. match = first_match;
  1533. /* there's always an entry for the original_text, it doesn't count. */
  1534. while (match->next != NULL && match->next != first_match)
  1535. {
  1536.     match = match->next;
  1537.     ++count;
  1538. }
  1539. match->next = first_match;
  1540. first_match->prev = match;
  1541.     }
  1542.     return count;
  1543. }
  1545. #define DICT_FIRST (1) /* use just first element in "dict" */
  1546. #define DICT_EXACT (2) /* "dict" is the exact name of a file */
  1547. /*
  1548.  * Add any identifiers that match the given pattern to the list of
  1549.  * completions.
  1550.  */
  1551.     static void
  1552. complete_dictionaries(dict, pat, dir, flags)
  1553.     char_u  *dict;
  1554.     char_u  *pat;
  1555.     int      dir;
  1556.     int      flags;
  1557. {
  1558.     char_u *ptr;
  1559.     char_u *buf;
  1560.     int at_start;
  1561.     FILE *fp;
  1562.     vim_regexp *prog;
  1563.     int add_r;
  1564.     char_u **files;
  1565.     int count;
  1566.     int i;
  1568.     buf = alloc(LSIZE);
  1569.     set_reg_ic(pat); /* set reg_ic according to p_ic, p_scs and pat */
  1570.     prog = vim_regcomp(pat, (int)p_magic);
  1571.     expand_interactively = TRUE;
  1572.     while (buf && prog && *dict != NUL && !got_int)
  1573.     {
  1574. /* copy one dictionary file name into buf */
  1575. if (flags == DICT_EXACT)
  1576. {
  1577.     count = 1;
  1578.     files = &dict;
  1579. }
  1580. else
  1581. {
  1582.     copy_option_part(&dict, buf, LSIZE, ",");
  1583.     if (expand_wildcards(1, &buf, &count, &files, EW_FILE|EW_DIR) != OK)
  1584. count = 0;
  1585. }
  1587. for (i = 0; i < count && !got_int; i++)
  1588. {
  1589.     fp = fopen((char *)files[i], "r"); /* open dictionary file */
  1590.     if (flags != DICT_EXACT)
  1591.     {
  1592. sprintf((char*)IObuff, "Scanning dictionary: %s",
  1593.     (char *)files[i]);
  1594. msg_trunc_attr(IObuff, TRUE, hl_attr(HLF_R));
  1595.     }
  1597.     if (fp != NULL)
  1598.     {
  1599. /*
  1600.  * Read dictionary file line by line.
  1601.  * Check each line for a match.
  1602.  */
  1603. while (!got_int && !vim_fgets(buf, LSIZE, fp))
  1604. {
  1605.     ptr = buf;
  1606.     at_start = TRUE;
  1607.     while (vim_regexec(prog, ptr, at_start))
  1608.     {
  1609. at_start = FALSE;
  1610. ptr = prog->startp[0];
  1611. while (vim_iswordc(*ptr))
  1612.     ++ptr;
  1613. add_r = add_completion_and_infercase(prog->startp[0],
  1614. (int)(ptr - prog->startp[0]), files[i], dir, 0);
  1615. if (add_r == OK)
  1616.     /* if dir was BACKWARD then honor it just once */
  1617.     dir = FORWARD;
  1618. else if (add_r == RET_ERROR)
  1619.     break;
  1620.     }
  1621.     line_breakcheck();
  1622. }
  1623. fclose(fp);
  1624.     }
  1625. }
  1626. if (flags != DICT_EXACT && count > 0)
  1627.     FreeWild(count, files);
  1628. if (flags)
  1629.     break;
  1630.     }
  1631.     expand_interactively = FALSE;
  1632.     vim_free(prog);
  1633.     vim_free(buf);
  1634. }
  1636. /*
  1637.  * Free the list of completions
  1638.  */
  1639.     static void
  1640. free_completions()
  1641. {
  1642.     struct Completion *match;
  1644.     if (first_match == NULL)
  1645. return;
  1646.     curr_match = first_match;
  1647.     do
  1648.     {
  1649. match = curr_match;
  1650. curr_match = curr_match->next;
  1651. vim_free(match->str);
  1652. /* several entries may use the same fname, free it just once. */
  1653. if (match->original & FREE_FNAME)
  1654.     vim_free(match->fname);
  1655. vim_free(match);
  1656.     } while (curr_match != NULL && curr_match != first_match);
  1657.     first_match = curr_match = NULL;
  1658. }
  1660.     static void
  1661. clear_insexp()
  1662. {
  1663.     continue_status = 0;
  1664.     started_completion = FALSE;
  1665.     complete_pat = NULL;
  1666.     save_sm = -1;
  1667. }
  1669. /*
  1670.  * Prepare for insert-expand, or stop it.
  1671.  */
  1672.     static int
  1673. ins_expand_pre(c)
  1674.     int     c;
  1675. {
  1676.     char_u *ptr;
  1677.     char_u *tmp_ptr;
  1678.     int temp;
  1679.     linenr_t lnum;
  1680.     int need_redraw = FALSE;
  1682.     if (ctrl_x_mode == CTRL_X_NOT_DEFINED_YET)
  1683.     {
  1684. /*
  1685.  * We have just entered ctrl-x mode and aren't quite sure which
  1686.  * ctrl-x mode it will be yet. Now we decide -- webb
  1687.  */
  1688. switch (c)
  1689. {
  1690.     case Ctrl('E'):
  1691.     case Ctrl('Y'):
  1692. ctrl_x_mode = CTRL_X_SCROLL;
  1693. if (State == INSERT)
  1694.     edit_submode = (char_u *)" (insert) Scroll (^E/^Y)";
  1695. else
  1696.     edit_submode = (char_u *)" (replace) Scroll (^E/^Y)";
  1697. showmode();
  1698. break;
  1699.     case Ctrl('L'):
  1700. ctrl_x_mode = CTRL_X_WHOLE_LINE;
  1701. break;
  1702.     case Ctrl('F'):
  1703. ctrl_x_mode = CTRL_X_FILES;
  1704. break;
  1705.     case Ctrl('K'):
  1706. ctrl_x_mode = CTRL_X_DICTIONARY;
  1707. break;
  1708.     case Ctrl(']'):
  1709. ctrl_x_mode = CTRL_X_TAGS;
  1710. break;
  1711. #ifdef FIND_IN_PATH
  1712.     case Ctrl('I'):
  1713.     case K_S_TAB:
  1714. ctrl_x_mode = CTRL_X_PATH_PATTERNS;
  1715. break;
  1716.     case Ctrl('D'):
  1717. ctrl_x_mode = CTRL_X_PATH_DEFINES;
  1718. break;
  1719. #endif
  1720.     case Ctrl('P'):
  1721.     case Ctrl('N'):
  1722. /* ^X^P means LOCAL expansion if nothing interrupted (eg we
  1723.  * just started ^X mode, or there were enough ^X's to cancel
  1724.  * the previous mode, say ^X^F^X^X^P or ^P^X^X^X^P, see below)
  1725.  * do normal expansion when interrupting a different mode (say
  1726.  * ^X^F^X^P or ^P^X^X^P, see below)
  1727.  * nothing changes if interrupting mode 0, (eg, the flag
  1728.  * doesn't change when going to ADDING mode  -- Acevedo */
  1729. if (!(continue_status & CONT_INTRPT))
  1730.     continue_status |= CONT_LOCAL;
  1731. else if (continue_mode)
  1732.     continue_status &=~CONT_LOCAL;
  1733. /* FALLTHROUGH */
  1734.     default:
  1735. /* if we have typed at least 2 ^X's... for modes != 0, we set
  1736.  * continue_status = 0 (eg, as if we had just started ^X mode)
  1737.  * for mode 0, we set continue_mode to an impossible value, in
  1738.  * both cases ^X^X can be used to restart the same mode
  1739.  * (avoiding ADDING mode).   Undocumented feature:
  1740.  * In a mode != 0 ^X^P and ^X^X^P start 'complete' and local
  1741.  * ^P expansions respectively. In mode 0 an extra ^X is
  1742.  * needed since ^X^P goes to ADDING mode  -- Acevedo */
  1743. if (c == Ctrl('X'))
  1744. {
  1745.     if (continue_mode)
  1746. continue_status = 0;
  1747.     else
  1748. continue_mode = CTRL_X_NOT_DEFINED_YET;
  1749. }
  1750. ctrl_x_mode = 0;
  1751. edit_submode = NULL;
  1752. showmode();
  1753. break;
  1754. }
  1755.     }
  1756.     else if (ctrl_x_mode)
  1757.     {
  1758. /* We we're already in ctrl-x mode, do we stay in it? */
  1759. if (!vim_is_ctrl_x_key(c))
  1760. {
  1761.     if (ctrl_x_mode == CTRL_X_SCROLL)
  1762. ctrl_x_mode = 0;
  1763.     else
  1764. ctrl_x_mode = CTRL_X_FINISHED;
  1765.     edit_submode = NULL;
  1766. }
  1767. showmode();
  1768.     }
  1769.     if (started_completion || ctrl_x_mode == CTRL_X_FINISHED)
  1770.     {
  1771. /* Show error message from attempted keyword completion (probably
  1772.  * 'Pattern not found') until another key is hit, then go back to
  1773.  * showing what mode we are in.
  1774.  */
  1775. showmode();
  1776. if ((ctrl_x_mode == 0 && c != Ctrl('N') && c != Ctrl('P')) ||
  1777.     ctrl_x_mode == CTRL_X_FINISHED)
  1778. {
  1779.     /* Get here when we have finished typing a sequence of ^N and
  1780.      * ^P or other completion characters in CTRL-X mode. Free up
  1781.      * memory that was used, and make sure we can redo the insert
  1782.      * -- webb.
  1783.      */
  1784.     if (curr_match != NULL)
  1785.     {
  1786. /*
  1787.  * If any of the original typed text has been changed,
  1788.  * eg when ignorecase is set, we must add back-spaces to
  1789.  * the redo buffer.  We add as few as necessary to delete
  1790.  * just the part of the original text that has changed
  1791.  * -- webb
  1792.  */
  1793. ptr = curr_match->str;
  1794. tmp_ptr = original_text;
  1795. while (*tmp_ptr && *tmp_ptr == *ptr)
  1796. {
  1797.     ++tmp_ptr;
  1798.     ++ptr;
  1799. }
  1800. for (temp = 0; tmp_ptr[temp]; ++temp)
  1801.     AppendCharToRedobuff(K_BS);
  1802. while (*ptr)
  1803. {
  1804.     /* Put a string of normal characters in the redo buffer */
  1805.     tmp_ptr = ptr;
  1806.     while (*ptr >= ' ' && *ptr < DEL)
  1807. ++ptr;
  1808.     /* Don't put '0' or '^' as last character, just in case a
  1809.      * CTRL-D is typed next */
  1810.     if (*ptr == NUL && (ptr[-1] == '0' || ptr[-1] == '^'))
  1811. --ptr;
  1812.     if (ptr > tmp_ptr)
  1813.     {
  1814. temp = *ptr;
  1815. *ptr = NUL;
  1816. AppendToRedobuff(tmp_ptr);
  1817. *ptr = temp;
  1818.     }
  1819.     if (*ptr)
  1820.     {
  1821. /* quote special chars with a CTRL-V */
  1822. AppendCharToRedobuff(Ctrl('V'));
  1823. AppendCharToRedobuff(*ptr);
  1824. /* CTRL-V '0' must be inserted as CTRL-V 048 */
  1825. if (*ptr++ == '0')
  1826.     AppendToRedobuff((char_u *)"48");
  1827.     }
  1828. }
  1829.     }
  1831.     /*
  1832.      * When completing whole lines: fix indent for 'cindent'.
  1833.      * Otherwise, break line if it's too long.
  1834.      */
  1835.     lnum = curwin->w_cursor.lnum;
  1836.     if (continue_mode == CTRL_X_WHOLE_LINE)
  1837.     {
  1838. #ifdef CINDENT
  1839. /* re-indent the current line */
  1840. if (curbuf->b_p_cin)
  1841.     fixthisline(get_c_indent);
  1842. #endif
  1843.     }
  1844.     else
  1845.     {
  1846. /* put the cursor on the last char, for 'tw' formatting */
  1847. curwin->w_cursor.col--;
  1848. insertchar(NUL, FALSE, -1, FALSE);
  1849. curwin->w_cursor.col++;
  1850.     }
  1851.     if (lnum != curwin->w_cursor.lnum)
  1852.     {
  1853. update_topline();
  1854. update_screen(NOT_VALID);
  1855.     }
  1856.     else
  1857. need_redraw = TRUE;
  1859.     vim_free(complete_pat);
  1860.     complete_pat = NULL;
  1861.     free_completions();
  1862.     started_completion = FALSE;
  1863.     ctrl_x_mode = 0;
  1864.     p_sm = save_sm;
  1865.     if (edit_submode != NULL)
  1866.     {
  1867. edit_submode = NULL;
  1868. showmode();
  1869.     }
  1870. }
  1871.     }
  1873.     /* reset continue_* if we left expansion-mode, if we stay they'll be
  1874.      * (re)set properly in ins_complete */
  1875.     if (!ctrl_x_mode && c != Ctrl('P') && c != Ctrl('N') && c != Ctrl('X'))
  1876. continue_status = continue_mode = 0;
  1878.     return need_redraw;
  1879. }
  1881. /*
  1882.  * Loops through the list of windows, loaded-buffers or non-loaded-buffers
  1883.  * (depending on flag) starting from buf and looking for a non-scanned
  1884.  * buffer (other than curbuf). curbuf is special, if it is called with
  1885.  * buf=curbuf then it has to be the first call for a given flag/expansion.
  1886.  *
  1887.  * Returns the buffer to scan, if any, otherwise returns curbuf -- Acevedo
  1888.  */
  1889.     static BUF*
  1890. next_buf(buf, flag)
  1891.     BUF *buf;
  1892.     int flag;
  1893. {
  1894.     static WIN *w;
  1896.     if (flag == 'w') /* just windows */
  1897.     {
  1898. if (buf == curbuf) /* first call for this flag/expansion */
  1899.     w = curwin;
  1900. while ((w = w->w_next ? w->w_next : firstwin) != curwin
  1901. && w->w_buffer->b_scanned)
  1902.     ;
  1903. buf = w->w_buffer;
  1904.     }
  1905.     else /* 'b' (just loaded buffers) or 'u' (just non-loaded buffers) */
  1906. while ((buf = buf->b_next ? buf->b_next : firstbuf) != curbuf
  1907. && ((buf->b_ml.ml_mfp == NULL) != (flag == 'u')
  1908.     || buf->b_scanned))
  1909.     ;
  1910.     return buf;
  1911. }
  1913. /*
  1914.  * Get the next expansion(s) for the text starting at the initial curbuf
  1915.  * position "ini" and in the direction dir.
  1916.  * Return the total of matches or -1 if still unknown -- Acevedo
  1917.  */
  1918.     static int
  1919. get_expansion(ini, dir)
  1920.     FPOS *ini;
  1921.     int dir;
  1922. {
  1923.     static FPOS first_match_pos;
  1924.     static FPOS last_match_pos;
  1925.     static char_u *e_cpt = (char_u *)""; /* curr. entry in 'complete' */
  1926.     static int done_info = 0; /* Found all matches in this dir. */
  1927.     static BUF *ins_buf = NULL;
  1929.     FPOS *pos;
  1930.     char_u **matches;
  1931.     int save_p_scs;
  1932.     int save_p_ws;
  1933.     int i;
  1934.     int temp;
  1935.     int type = ctrl_x_mode;
  1936.     char_u *ptr;
  1937.     char_u *tmp_ptr;
  1938.     char_u *dict = NULL;
  1939.     int dict_f = 0;
  1940.     struct Completion *old_match;
  1942.     if (!started_completion)
  1943.     {
  1944. for (ins_buf = firstbuf; ins_buf; ins_buf = ins_buf->b_next)
  1945.     ins_buf->b_scanned = 0;
  1946. done_info = 0;
  1947. ins_buf = curbuf;
  1948. e_cpt = continue_status & CONT_LOCAL ? (char_u *)"." : curbuf->b_p_cpt;
  1949. last_match_pos = first_match_pos = *ini;
  1950.     }
  1952.     old_match = curr_match; /* remember the last current match */
  1953.     pos = (dir == FORWARD) ? &last_match_pos : &first_match_pos;
  1954.     /* For ^N/^P loop over all the flags/windows/buffers in 'complete' */
  1955.     for (;;)
  1956.     {
  1957. temp = FAIL;
  1958. /* in mode 0 pick a new entry from e_cpt if started_completion is off,
  1959.  * or if done_info says this entry is done  -- Acevedo */
  1960. if (!ctrl_x_mode && (!started_completion || done_info == 6))
  1961. {
  1962.     done_info = 0;
  1963.     while (*e_cpt == ',' || *e_cpt == ' ')
  1964. e_cpt++;
  1965.     if (*e_cpt == '.' && !curbuf->b_scanned)
  1966.     {
  1967. ins_buf = curbuf;
  1968. first_match_pos = *ini;
  1969. /* So that ^N can match word immediately after cursor */
  1970. if (ctrl_x_mode == 0)
  1971.     dec(&first_match_pos);
  1972. last_match_pos = first_match_pos;
  1973. type = 0;
  1974.     }
  1975.     else if (vim_strchr((char_u *)"buw", *e_cpt) != NULL
  1976.     && (ins_buf = next_buf(ins_buf, *e_cpt)) != curbuf)
  1977.     {
  1978. if (*e_cpt != 'u')
  1979. {
  1980.     started_completion = TRUE;
  1981.     first_match_pos.col = last_match_pos.col = 0;
  1982.     first_match_pos.lnum = ins_buf->b_ml.ml_line_count + 1;
  1983.     last_match_pos.lnum = 0;
  1984.     type = 0;
  1985. }
  1986. else
  1987. {
  1988.     done_info = 6;
  1989.     if (ins_buf->b_fname == NULL)
  1990. continue;
  1991.     type = CTRL_X_DICTIONARY;
  1992.     dict = ins_buf->b_fname;
  1993.     dict_f = DICT_EXACT;
  1994. }
  1995. sprintf((char*)IObuff, "Scanning: %s",
  1996. ins_buf->b_sfname == NULL ? "No File"
  1997.   : (char *)ins_buf->b_sfname);
  1998. msg_trunc_attr(IObuff, TRUE, hl_attr(HLF_R));
  1999.     }
  2000.     else if (*e_cpt == NUL)
  2001. break;
  2002.     else
  2003.     {
  2004. if (*e_cpt == 'k')
  2005. {
  2006.     type = CTRL_X_DICTIONARY;
  2007.     if (*++e_cpt != ',' && *e_cpt != NUL)
  2008.     {
  2009. dict = e_cpt;
  2010. dict_f = DICT_FIRST;
  2011.     }
  2012. }
  2013. #ifdef FIND_IN_PATH
  2014. else if (*e_cpt == 'i')
  2015.     type = CTRL_X_PATH_PATTERNS;
  2016. #endif
  2017. else if (*e_cpt == ']' || *e_cpt == 't')
  2018. {
  2019.     type = CTRL_X_TAGS;
  2020.     sprintf((char*)IObuff, "Scanning tags.");
  2021.     msg_trunc_attr(IObuff, TRUE, hl_attr(HLF_R));
  2022. }
  2023. else
  2024.     type = -1;
  2026. /* in any case e_cpt is advanced to the next entry */
  2027. (void)copy_option_part(&e_cpt, IObuff, IOSIZE, ",");
  2029. done_info = 6;
  2030. if (type == -1)
  2031.     continue;
  2032.     }
  2033. }
  2035. switch (type)
  2036. {
  2037. case -1:
  2038.     break;
  2039. #ifdef FIND_IN_PATH
  2040. case CTRL_X_PATH_PATTERNS:
  2041. case CTRL_X_PATH_DEFINES:
  2042.     find_pattern_in_path(complete_pat, dir,
  2043.  (int)STRLEN(complete_pat), FALSE, FALSE,
  2044.  (type == CTRL_X_PATH_DEFINES
  2045.   && !(continue_status & CONT_SOL))
  2046.  ? FIND_DEFINE : FIND_ANY, 1L, ACTION_EXPAND,
  2047.  (linenr_t)1, (linenr_t)MAXLNUM);
  2048.     break;
  2049. #endif
  2051. case CTRL_X_DICTIONARY:
  2052.     complete_dictionaries(dict ? dict : p_dict, complete_pat, dir,
  2053.   dict ? dict_f : 0);
  2054.     dict = NULL;
  2055.     break;
  2057. case CTRL_X_TAGS:
  2058.     /* set reg_ic according to p_ic, p_scs and pat */
  2059.     set_reg_ic(complete_pat);
  2060.     if (find_tags(complete_pat, &temp, &matches,
  2061.     TAG_REGEXP | TAG_NAMES | (ctrl_x_mode ? TAG_VERBOSE : 0),
  2062.     MAXCOL) == OK && temp > 0)
  2063.     {
  2064. int add_r = OK;
  2065. int ldir = dir;
  2067. for (i = 0; i < temp && add_r != RET_ERROR; i++)
  2068.     if ((add_r = add_completion(matches[i], -1, NULL, ldir, 0))
  2069.     == OK)
  2070. /* if dir was BACKWARD then honor it just once */
  2071. ldir = FORWARD;
  2072. FreeWild(temp, matches);
  2073.     }
  2074.     break;
  2076. case CTRL_X_FILES:
  2077.     expand_interactively = TRUE;
  2078.     if (expand_wildcards(1, &complete_pat, &temp, &matches,
  2079. EW_FILE|EW_DIR) == OK)
  2080.     {
  2081. int add_r = OK;
  2082. int ldir = dir;
  2084. /* May change home directory back to "~". */
  2085. tilde_replace(complete_pat, temp, matches);
  2086. for (i = 0; i < temp && add_r != RET_ERROR; i++)
  2087.     if ((add_r = add_completion(matches[i], -1, NULL, ldir, 0))
  2088.     == OK)
  2089. /* if dir was BACKWARD then honor it just once */
  2090. ldir = FORWARD;
  2091. FreeWild(temp, matches);
  2092.     }
  2093.     expand_interactively = FALSE;
  2094.     break;
  2096. default: /* normal ^P/^N and ^X^L */
  2097.     /*
  2098.      * If 'infercase' is set, don't use 'smartcase' here
  2099.      */
  2100.     save_p_scs = p_scs;
  2101.     if (ins_buf->b_p_inf)
  2102. p_scs = FALSE;
  2103.     /* buffers other than curbuf are scanned from the beginning or the
  2104.      * end but never from the middle, thus setting nowrapscan in this
  2105.      * buffers is a good idea -- Acevedo */
  2106.     save_p_ws = p_ws;
  2107.     if (ins_buf != curbuf)
  2108. p_ws = FALSE;
  2109.     for (;;)
  2110.     {
  2111. int reuse = 0;
  2113. /* ctrl_x_mode == CTRL_X_WHOLE_LINE || word-wise search that has
  2114.  * added a word that was at the beginning of the line */
  2115. if ( ctrl_x_mode == CTRL_X_WHOLE_LINE
  2116. || (continue_status & CONT_SOL))
  2117.     temp = search_for_exact_line(ins_buf, pos,
  2118.    dir, complete_pat);
  2119. else
  2120.     temp = searchit(ins_buf, pos, dir, complete_pat, 1L,
  2121.     SEARCH_KEEP + SEARCH_NFMSG, RE_LAST);
  2122. if (!started_completion)
  2123. {
  2124.     /* set started_completion even on fail */
  2125.     started_completion = TRUE;
  2126.     first_match_pos = *pos;
  2127.     last_match_pos = *pos;
  2128. }
  2129. else if (first_match_pos.lnum == last_match_pos.lnum
  2130.  && first_match_pos.col == last_match_pos.col)
  2131.     temp = FAIL;
  2132. if (   temp == FAIL && ins_buf == curbuf
  2133.        && (done_info |= p_ws ? 6 : dir + 3) < 6)
  2134.     /* With nowrapscan, we haven't finished looking in the
  2135.      * other direction yet -- webb */
  2136.     temp = -OK;
  2137. if (temp != OK)
  2138.     break;
  2140. /* when ADDING, the text before the cursor matches, skip it */
  2141. if ( (continue_status & CONT_ADDING) && ins_buf == curbuf
  2142. && ini->lnum == pos->lnum
  2143. && ini->col  == pos->col)
  2144.     continue;
  2145. ptr = ml_get_buf(ins_buf, pos->lnum, FALSE) + pos->col;
  2146. if (ctrl_x_mode == CTRL_X_WHOLE_LINE)
  2147. {
  2148.     if (continue_status & CONT_ADDING)
  2149.     {
  2150. if (pos->lnum >= ins_buf->b_ml.ml_line_count)
  2151.     continue;
  2152. ptr = ml_get_buf(ins_buf, pos->lnum + 1, FALSE);
  2153. if (!p_paste)
  2154.     ptr = skipwhite(ptr);
  2155.     }
  2156.     temp = STRLEN(ptr);
  2157. }
  2158. else
  2159. {
  2160.     tmp_ptr = ptr;
  2161.     if (continue_status & CONT_ADDING)
  2162.     {
  2163. tmp_ptr += completion_length;
  2164. if (vim_iswordc(*tmp_ptr))
  2165.     continue;
  2166. while (*tmp_ptr && !vim_iswordc(*tmp_ptr++))
  2167.     ;
  2168.     }
  2169.     while (vim_iswordc(*tmp_ptr))
  2170. tmp_ptr++;
  2171.     temp = tmp_ptr - ptr;
  2172.     if ((continue_status & CONT_ADDING)
  2173. && temp == completion_length)
  2174.     {
  2175. if (pos->lnum < ins_buf->b_ml.ml_line_count)
  2176. {
  2177.     /* Try next line, if any. the new word will be
  2178.      * "join" as if the normal command "J" was used.
  2179.      * IOSIZE is always greater than
  2180.      * completion_length, so the next STRNCPY always
  2181.      * works -- Acevedo */
  2182.     STRNCPY(IObuff, ptr, temp);
  2183.     ptr = ml_get_buf(ins_buf, pos->lnum + 1, FALSE);
  2184.     tmp_ptr = ptr = skipwhite(ptr);
  2185.     while (*tmp_ptr && !vim_iswordc(*tmp_ptr++))
  2186. ;
  2187.     while (vim_iswordc(*tmp_ptr))
  2188. tmp_ptr++;
  2189.     if (tmp_ptr > ptr)
  2190.     {
  2191. if (*ptr != ')' && IObuff[temp-1] != TAB)
  2192. {
  2193.     if (IObuff[temp-1] != ' ')
  2194. IObuff[temp++] = ' ';
  2195.     /* IObuf =~ "k.* ", thus temp >= 2 */
  2196.     if (p_js
  2197. && (IObuff[temp-2] == '.'
  2198.     || (vim_strchr(p_cpo, CPO_JOINSP)
  2199.        == NULL
  2200. && (IObuff[temp-2] == '?'
  2201.     || IObuff[temp-2] == '!'))))
  2202. IObuff[temp++] = ' ';
  2203. }
  2204. /* copy as much as posible of the new word */
  2205. if (tmp_ptr - ptr >= IOSIZE - temp)
  2206.     tmp_ptr = ptr + IOSIZE - temp - 1;
  2207. STRNCPY(IObuff + temp, ptr, tmp_ptr - ptr);
  2208. temp += tmp_ptr - ptr;
  2209. reuse |= CONT_S_IPOS;
  2210.     }
  2211.     IObuff[temp] = NUL;
  2212.     ptr = IObuff;
  2213. }
  2214. if (temp == completion_length)
  2215.     continue;
  2216.     }
  2217. }
  2218. if (add_completion_and_infercase(ptr, temp, ins_buf == curbuf ?
  2219. NULL : ins_buf->b_sfname, dir, reuse) != FAIL)
  2220. {
  2221.     temp = OK;
  2222.     break;
  2223. }
  2224.     }
  2225.     p_scs = save_p_scs;
  2226.     p_ws = save_p_ws;
  2227. }
  2228. /* check if curr_match has changed, (e.g. other type of expansion
  2229.  * added somenthing) */
  2230. if (curr_match != old_match)
  2231.     temp = OK;
  2232. /* break the loop for specialized modes (use 'complete' just for the
  2233.  * generic ctrl_x_mode == 0) and when temp != FAIL */
  2234. if (ctrl_x_mode || temp)
  2235.     break;
  2236. if (type == 0 || type == CTRL_X_PATH_PATTERNS)
  2237.     ins_buf->b_scanned = TRUE;
  2239. started_completion = FALSE;
  2240.     }
  2241.     started_completion = TRUE;
  2243.     i = -1; /* total of matches, unknown */
  2244.     if (temp == FAIL || (ctrl_x_mode != 0 && ctrl_x_mode != CTRL_X_WHOLE_LINE))
  2245. i = make_cyclic();
  2246.     else if (temp == -OK && (curr_match->original & ORIGINAL_TEXT))
  2247.     {
  2248. edit_submode_extra = (continue_status & CONT_ADDING)
  2249.     && completion_length > 1
  2250. ? (dir == FORWARD ? e_hitend_f : e_hitend_b)
  2251. : (dir == FORWARD ? e_patnotf_f : e_patnotf_b);
  2252. edit_submode_highl = HLF_E;
  2253.     }
  2254.     /* If several matches were added (FORWARD) or the search failed and has
  2255.      * just been made cyclic then we have to move curr_match to the next or
  2256.      * previous entry (if any, when search failed with 'nows') -- Acevedo */
  2257.     curr_match = dir == FORWARD ? old_match->next : old_match->prev;
  2258.     if (curr_match == NULL)
  2259. curr_match = old_match;
  2260.     return i;
  2261. }
  2263.     static int
  2264. ins_complete(c)
  2265.     int     c;
  2266. {
  2267.     int     complete_direction;
  2268.     char_u     *ptr;
  2269.     char_u     *tmp_ptr = NULL; /* init for gcc */
  2270.     static colnr_t  complete_col = 0; /* init for gcc */
  2271.     int     temp = 0;
  2272.     int     i;
  2273.     int     cc;
  2274.     static FPOS     initial_pos;
  2276.     if (c == Ctrl('P') || c == Ctrl('L'))
  2277. complete_direction = BACKWARD;
  2278.     else
  2279. complete_direction = FORWARD;
  2280.     if (!started_completion)
  2281.     {
  2282. /* First time we hit ^N or ^P (in a row, I mean) */
  2284. /* Turn off 'sm' so we don't show matches with ^X^L */
  2285. save_sm = p_sm;
  2286. p_sm = FALSE;
  2288. did_ai = FALSE;
  2289. #ifdef SMARTINDENT
  2290. did_si = FALSE;
  2291. can_si = FALSE;
  2292. can_si_back = FALSE;
  2293. #endif
  2294. stop_arrow();
  2295. ptr = ml_get(curwin->w_cursor.lnum);
  2296. complete_col = curwin->w_cursor.col;
  2298. /* if this same ctrl_x_mode has been interrupted use the text from
  2299.  * initial_pos to the cursor as a pattern to add a new word instead of
  2300.  * expand the one before the cursor, in word-wise if "initial_pos" is
  2301.  * not in the same line as the cursor then fix it (the line has been
  2302.  * split because it was longer than 'tw').  if SOL is set then skip
  2303.  * the previous pattern, a word at the beginning of the line has been
  2304.  * inserted, we'll look for that  -- Acevedo. */
  2305. if ((continue_status & CONT_INTRPT) && continue_mode == ctrl_x_mode)
  2306. { /* it is a continued search */
  2307.     continue_status &= ~CONT_INTRPT; /* remove INTRPT */
  2308.     if (ctrl_x_mode == 0 || ctrl_x_mode == CTRL_X_PATH_PATTERNS
  2309. || ctrl_x_mode == CTRL_X_PATH_DEFINES)
  2310.     {
  2311. if (initial_pos.lnum != curwin->w_cursor.lnum)
  2312. {
  2313.     /* line (probably) wrapped, set initial_pos to the first
  2314.      * non_blank in the line, if it is not a wordchar include
  2315.      * it to get a better pattern, but then we don't want the
  2316.      * "\<" prefix, check it bellow */
  2317.     tmp_ptr = skipwhite(ptr);
  2318.     initial_pos.col = tmp_ptr - ptr;
  2319.     initial_pos.lnum = curwin->w_cursor.lnum;
  2320.     continue_status &= ~CONT_SOL;    /* clear SOL if present */
  2321. }
  2322. else
  2323. {
  2324.     /* S_IPOS was set when we inserted a word that was at the
  2325.      * beginning of the line, which means that we'll go to SOL
  2326.      * mode but first we need to redefine initial_pos */
  2327.     if (continue_status & CONT_S_IPOS)
  2328.     {
  2329. continue_status |= CONT_SOL;
  2330. initial_pos.col = skipwhite(ptr + completion_length +
  2331.     initial_pos.col) - ptr;
  2332.     }
  2333.     tmp_ptr = ptr + initial_pos.col;
  2334. }
  2335. temp = curwin->w_cursor.col - (tmp_ptr-ptr);
  2336. /* IObuf is used to add a "word from the next line" would we
  2337.  * have enough space?  just being paranoic */
  2338. #define MIN_SPACE 75
  2339. if (temp > (IOSIZE - MIN_SPACE))
  2340. {
  2341.     continue_status &= ~CONT_SOL;
  2342.     temp = (IOSIZE - MIN_SPACE);
  2343.     tmp_ptr = curwin->w_cursor.col - temp + ptr;
  2344. }
  2345. continue_status |= CONT_ADDING | CONT_N_ADDS;
  2346. if (temp < 1)
  2347.     continue_status &= CONT_LOCAL;
  2348.     }
  2349.     else if (ctrl_x_mode == CTRL_X_WHOLE_LINE)
  2350. continue_status = CONT_ADDING | CONT_N_ADDS;
  2351.     else
  2352. continue_status = 0;
  2353. }
  2354. else
  2355.     continue_status &= CONT_LOCAL;
  2357. if (!(continue_status & CONT_ADDING)) /* normal expansion */
  2358. {
  2359.     continue_mode = ctrl_x_mode;
  2360.     if (ctrl_x_mode) /* Remove LOCAL iff ctrl_x_mode != 0 */
  2361. continue_status = 0;
  2362.     continue_status |= CONT_N_ADDS;
  2363.     initial_pos = curwin->w_cursor;
  2364.     temp = (int)complete_col;
  2365.     tmp_ptr = ptr;
  2366. }
  2368. /* Work out completion pattern and original text -- webb */
  2369. if (ctrl_x_mode == 0 || (ctrl_x_mode & CTRL_X_WANT_IDENT))
  2370. {
  2371.     if (       (continue_status & CONT_SOL)
  2372.     || ctrl_x_mode == CTRL_X_PATH_DEFINES)
  2373.     {
  2374. if (!(continue_status & CONT_ADDING))
  2375. {
  2376.     while (--temp >= 0 && vim_isIDc(ptr[temp]))
  2377. ;
  2378.     tmp_ptr += ++temp;
  2379.     temp = complete_col - temp;
  2380. }
  2381. complete_pat = vim_strnsave(tmp_ptr, temp);
  2382. if (complete_pat == NULL)
  2383.     return FALSE;
  2384. if (p_ic)
  2385.     for (i = 0; i < temp; i++)
  2386. complete_pat[i] = TO_LOWER(complete_pat[i]);
  2387.     }
  2388.     else if (continue_status & CONT_ADDING)
  2389.     {
  2390. char_u     *prefix = (char_u *)"\<";
  2392. /* we need 3 extra chars, 1 for the NUL and
  2393.  * 2 >= strlen(prefix) -- Acevedo */
  2394. complete_pat = alloc(quote_meta(NULL, tmp_ptr, temp) + 3);
  2395. if (complete_pat == NULL)
  2396.     return FALSE;
  2397. if (!vim_iswordc(*tmp_ptr) ||
  2398. (tmp_ptr > ptr && vim_iswordc(*(tmp_ptr-1))))
  2399.     prefix = (char_u *)"";
  2400. STRCPY((char *)complete_pat, prefix);
  2401. (void)quote_meta(complete_pat + STRLEN(prefix), tmp_ptr, temp);
  2402.     }
  2403.     else if (--temp < 0 || !vim_iswordc(ptr[temp]))
  2404.     {
  2405. /* Match any word of at least two chars */
  2406. complete_pat = vim_strsave((char_u *)"\<\k\k");
  2407. if (complete_pat == NULL)
  2408.     return FALSE;
  2409. tmp_ptr += complete_col;
  2410. temp = 0;
  2411.     }
  2412.     else
  2413.     {
  2414. while (--temp >= 0 && vim_iswordc(ptr[temp]))
  2415.     ;
  2416. tmp_ptr += ++temp;
  2417. if ((temp = (int)complete_col - temp) == 1)
  2418. {
  2419.     /* Only match word with at least two chars -- webb
  2420.      * there's no need to call quote_meta,
  2421.      * alloc(7) is enough  -- Acevedo
  2422.      */
  2423.     complete_pat = alloc(7);
  2424.     if (complete_pat == NULL)
  2425. return FALSE;
  2426.     STRCPY((char *)complete_pat, "\<");
  2427.     (void)quote_meta(complete_pat + 2, tmp_ptr, 1);
  2428.     STRCAT((char *)complete_pat, "\k");
  2429. }
  2430. else
  2431. {
  2432.     complete_pat = alloc(quote_meta(NULL, tmp_ptr, temp) + 3);
  2433.     if (complete_pat == NULL)
  2434. return FALSE;
  2435.     STRCPY((char *)complete_pat, "\<");
  2436.     (void)quote_meta(complete_pat + 2, tmp_ptr, temp);
  2437. }
  2438.     }
  2439. }
  2440. else if (ctrl_x_mode == CTRL_X_WHOLE_LINE)
  2441. {
  2442.     tmp_ptr = skipwhite(ptr);
  2443.     temp = (int)complete_col - (tmp_ptr - ptr);
  2444.     complete_pat = vim_strnsave(tmp_ptr, temp);
  2445.     if (complete_pat == NULL)
  2446. return FALSE;
  2447.     if (p_ic)
  2448. for (i = 0; i < temp; i ++)
  2449.     complete_pat[i] = TO_LOWER(complete_pat[i]);
  2450. }
  2451. else if (ctrl_x_mode == CTRL_X_FILES)
  2452. {
  2453.     while (--temp >= 0 && vim_isfilec(ptr[temp]))
  2454. ;
  2455.     tmp_ptr += ++temp;
  2456.     temp = (int)complete_col - temp;
  2457.     complete_pat = addstar(tmp_ptr, temp);
  2458.     if (complete_pat == NULL)
  2459. return FALSE;
  2460. }
  2461. complete_col = tmp_ptr - ptr;
  2463. if (continue_status & CONT_ADDING)
  2464. {
  2465.     if (continue_status & CONT_LOCAL)
  2466. edit_submode = (char_u *)ctrl_x_msgs[2];
  2467.     else
  2468. edit_submode = (char_u *)ctrl_x_msgs[ctrl_x_mode & 15];
  2469.     if (ctrl_x_mode == CTRL_X_WHOLE_LINE)
  2470.     {
  2471. /* Insert a new line, keep indentation but ignore 'comments' */
  2472. char_u *old = curbuf->b_p_com;
  2474. initial_pos.lnum = curwin->w_cursor.lnum;
  2475. initial_pos.col = complete_col;
  2476. curbuf->b_p_com = (char_u *)"";
  2477. ins_eol('r');
  2478. curbuf->b_p_com = old;
  2479. tmp_ptr = (char_u *)"";
  2480. temp = 0;
  2481. complete_col = curwin->w_cursor.col;
  2482.     }
  2483. }
  2484. else
  2485. {
  2486.     /* msg. without the " Adding" part. */
  2487.     if (continue_status & CONT_LOCAL)
  2488. edit_submode = (char_u *)ctrl_x_msgs[2] + C_X_SKIP;
  2489.     else
  2490. edit_submode = (char_u *)ctrl_x_msgs[ctrl_x_mode & 15] + C_X_SKIP;
  2491.     initial_pos.col = complete_col;
  2492. }
  2494. completion_length = temp;
  2495. /* Always "add completion" for the "original text", it uses
  2496.  * "original_text" not a copy -- Acevedo */
  2497. if ((original_text = vim_strnsave(tmp_ptr, temp)) == NULL
  2498.     || add_completion(original_text, -1, NULL, 0, ORIGINAL_TEXT) != OK)
  2499. {
  2500.     vim_free(complete_pat);
  2501.     complete_pat = NULL;
  2502.     return FALSE;
  2503. }
  2504. /* showmode might reset the internal line pointers, so it must
  2505.  * be called before ptr = ml_get, or when this address is no
  2506.  * longer needed.  -- Acevedo.
  2507.  */
  2508. edit_submode_extra = (char_u *)"-- Searching...";
  2509. edit_submode_highl = HLF_COUNT;
  2510. showmode();
  2511. edit_submode_extra = NULL;
  2512. out_flush();
  2513.     }
  2515.     /*
  2516.      * In insert mode: Delete the typed part.
  2517.      * In replace mode: Put the old characters back, if any.
  2518.      */
  2519.     i = complete_col + (continue_status & CONT_ADDING ? completion_length : 0);
  2520.     while ((int)curwin->w_cursor.col > i)
  2521.     {
  2522. curwin->w_cursor.col--;
  2523. if (State == REPLACE)
  2524. {
  2525.     /*
  2526.      * First character popped from the replace stack replaces a
  2527.      * character that's already there. Further popped characters need
  2528.      * to be inserted.
  2529.      */
  2530.     if ((cc = replace_pop()) > 0)
  2531.     {
  2532. pchar(curwin->w_cursor, cc);
  2533. replace_pop_ins();
  2534.     }
  2535. }
  2536. else
  2537.     (void)del_char(FALSE);
  2538.     }
  2539.     changed_cline_bef_curs();
  2540.     if (complete_direction == FORWARD && curr_match->next != NULL)
  2541. curr_match = curr_match->next;
  2542.     else if (complete_direction == BACKWARD && curr_match->prev != NULL)
  2543. curr_match = curr_match->prev;
  2544.     else
  2545. temp = get_expansion(&initial_pos, complete_direction);
  2547.     /* we found no match if the list has only the original_text-entry */
  2548.     if (first_match == first_match->next)
  2549.     {
  2550. edit_submode_extra = (continue_status & CONT_ADDING)
  2551.       && completion_length > 1 ? e_hitend : e_patnotf;
  2552. edit_submode_highl = HLF_E;
  2553. /* remove N_ADDS flag, so next ^X<> won't try to go to ADDING mode,
  2554.  * because we couldn't expand anything at first place, but if we used
  2555.  * ^P, ^N, ^X^I or ^X^D we might want to add-expand a single-char-word
  2556.  * (such as M in M'exico) if not tried already.  -- Acevedo */
  2557. if (    completion_length > 1
  2558. || (continue_status & CONT_ADDING)
  2559. || (ctrl_x_mode != 0
  2560.     && ctrl_x_mode != CTRL_X_PATH_PATTERNS
  2561.     && ctrl_x_mode != CTRL_X_PATH_DEFINES))
  2562.     continue_status &= ~CONT_N_ADDS;
  2563.     }
  2565.     /* eat the ESC to avoid leaving insert mode */
  2566.     if (got_int && !global_busy)
  2567.     {
  2568. (void)vgetc();
  2569. got_int = FALSE;
  2570.     }
  2572.     if (curr_match->original & CONT_S_IPOS)
  2573. continue_status |= CONT_S_IPOS;
  2574.     else
  2575. continue_status &= ~CONT_S_IPOS;
  2577.     if (edit_submode_extra == NULL)
  2578.     {
  2579. if (curr_match->original & ORIGINAL_TEXT)
  2580. {
  2581.     edit_submode_extra = (char_u *)"Back at original";
  2582.     edit_submode_highl = HLF_W;
  2583. }
  2584. else if (continue_status & CONT_S_IPOS)
  2585. {
  2586.     edit_submode_extra = (char_u *)"Word from other line";
  2587.     edit_submode_highl = HLF_COUNT;
  2588. }
  2589. else if (curr_match->next == curr_match->prev)
  2590. {
  2591.     edit_submode_extra = (char_u *)"The only match";
  2592.     edit_submode_highl = HLF_COUNT;
  2593. }
  2594.     }
  2596.     /*