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

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

编辑器/阅读器

开发平台：

DOS

ex_getln.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.  * ex_getln.c: Functions for entering and editing an Ex command line.
  11.  */
  13. #include "vim.h"
  15. /*
  16.  * Variables shared between getcmdline(), redrawcmdline() and others.
  17.  * These need to be saved when using CTRL-R |, that's why they are in a
  18.  * structure.
  19.  */
  20. struct cmdline_info
  21. {
  22.     char_u *cmdbuff; /* pointer to command line buffer */
  23.     int cmdbufflen; /* length of cmdbuff */
  24.     int cmdlen; /* number of chars on command line */
  25.     int cmdpos; /* current cursor position */
  26.     int cmdspos; /* cursor column on screen */
  27.     int cmdfirstc; /* ':', '/', '?', '=' or NUL */
  28.     int cmdindent; /* number of spaces before cmdline */
  29.     char_u *cmdprompt; /* message in front of cmdline */
  30.     int cmdattr; /* attributes for prompt */
  31.     int overstrike; /* Typing mode on the command line.  Shared by
  32.    getcmdline() and put_on_cmdline(). */
  33. };
  35. static struct cmdline_info ccline; /* current cmdline_info */
  37. static int cmd_numfiles = -1; /* number of files found by
  38.     file name completion */
  39. static char_u **(history[HIST_COUNT]) = {NULL, NULL, NULL, NULL};
  40. static int hisidx[HIST_COUNT] = {-1, -1, -1, -1};  /* last entered entry */
  41. static int hislen = 0; /* actual length of history tables */
  43. #ifdef RIGHTLEFT
  44. static int cmd_hkmap = 0;     /* Hebrew mapping during command line */
  45. #endif
  47. #ifdef FKMAP
  48. static int     cmd_fkmap = 0; /* Farsi mapping during command line */
  49. #endif
  51. static int hist_char2type __ARGS((int c));
  52. static void init_history __ARGS((void));
  54. static int in_history __ARGS((int, char_u *, int));
  55. static void set_cmdspos __ARGS((void));
  56. static void alloc_cmdbuff __ARGS((int len));
  57. static int realloc_cmdbuff __ARGS((int len));
  58. static void putcmdline __ARGS((int));
  59. static void redrawcmdprompt __ARGS((void));
  60. static void redrawcmd __ARGS((void));
  61. static void cursorcmd __ARGS((void));
  62. static int ccheck_abbr __ARGS((int));
  63. static int nextwild __ARGS((int, int));
  64. static int showmatches __ARGS((void));
  65. static void set_expand_context __ARGS((void));
  66. static int ExpandFromContext __ARGS((char_u *, int *, char_u ***, int, int));
  68. /*
  69.  * getcmdline() - accept a command line starting with firstc.
  70.  *
  71.  * firstc == ':'     get ":" command line.
  72.  * firstc == '/' or '?'     get search pattern
  73.  * firstc == '='     get expression
  74.  * firstc == '@'     get text for input() function
  75.  * firstc == NUL     get text for :insert command
  76.  *
  77.  * The line is collected in ccline.cmdbuff, which is reallocated to fit the
  78.  * command line.
  79.  *
  80.  * Careful: getcmdline() can be called recursively!
  81.  *
  82.  * Return pointer to allocated string if there is a commandline, NULL
  83.  * otherwise.
  84.  */
  85.     char_u *
  86. getcmdline(firstc, count, indent)
  87.     int firstc;
  88.     long count; /* only used for incremental search */
  89.     int indent; /* indent for inside conditionals */
  90. {
  91.     int c;
  92. #ifdef DIGRAPHS
  93.     int cc;
  94. #endif
  95.     int i;
  96.     int j;
  97.     char_u *p;
  98.     int hiscnt; /* current history line in use */
  99.     char_u *lookfor = NULL; /* string to match */
  100.     int gotesc = FALSE; /* TRUE when <ESC> just typed */
  101.     int do_abbr; /* when TRUE check for abbr. */
  102.     int histype; /* history type to be used */
  103. #ifdef EXTRA_SEARCH
  104.     FPOS old_cursor;
  105.     colnr_t old_curswant;
  106.     colnr_t old_leftcol;
  107.     linenr_t old_topline;
  108.     linenr_t old_botline;
  109.     int did_incsearch = FALSE;
  110.     int incsearch_postponed = FALSE;
  111. #endif
  112.     int did_wild_list = FALSE; /* did wild_list() recently */
  113.     int wim_index = 0; /* index in wim_flags[] */
  114.     int res;
  115.     int save_msg_scroll = msg_scroll;
  116.     int save_State = State; /* remember State when called */
  117.     int some_key_typed = FALSE; /* one of the keys was typed */
  118. #ifdef USE_MOUSE
  119.     /* mouse drag and release events are ignored, unless they are
  120.      * preceded with a mouse down event */
  121.     int ignore_drag_release = TRUE;
  122. #endif
  123. #ifdef USE_SNIFF
  124.     want_sniff_request = 0;
  125. #endif
  127.     ccline.overstrike = FALSE;     /* always start in insert mode */
  128. #ifdef EXTRA_SEARCH
  129.     old_cursor = curwin->w_cursor;     /* needs to be restored later */
  130.     old_curswant = curwin->w_curswant;
  131.     old_leftcol = curwin->w_leftcol;
  132.     old_topline = curwin->w_topline;
  133.     old_botline = curwin->w_botline;
  134. #endif
  136.     /*
  137.      * set some variables for redrawcmd()
  138.      */
  139.     ccline.cmdfirstc = (firstc == '@' ? 0 : firstc);
  140.     ccline.cmdindent = indent;
  141.     alloc_cmdbuff(exmode_active ? 250 : 0); /* alloc initial ccline.cmdbuff */
  142.     if (ccline.cmdbuff == NULL)
  143. return NULL;     /* out of memory */
  144.     ccline.cmdlen = ccline.cmdpos = 0;
  146.     redir_off = TRUE; /* don't redirect the typed command */
  147.     i = msg_scrolled;
  148.     msg_scrolled = 0; /* avoid wait_return message */
  149.     gotocmdline(TRUE);
  150.     msg_scrolled += i;
  151.     redrawcmdprompt(); /* draw prompt or indent */
  152.     set_cmdspos();
  154.     /*
  155.      * Avoid scrolling when called by a recursive do_cmdline(), e.g. when doing
  156.      * ":@0" when register 0 doesn't contain a CR.
  157.      */
  158.     msg_scroll = FALSE;
  160.     State = CMDLINE;
  161. #ifdef USE_MOUSE
  162.     setmouse();
  163. #endif
  165.     init_history();
  166.     hiscnt = hislen; /* set hiscnt to impossible history value */
  167.     histype = hist_char2type(firstc);
  169. #ifdef DIGRAPHS
  170.     do_digraph(-1); /* init digraph typahead */
  171. #endif
  173.     /* collect the command string, handling editing keys */
  174.     for (;;)
  175.     {
  176. #ifdef USE_GUI_WIN32
  177. dont_scroll = FALSE; /* allow scrolling here */
  178. #endif
  179. quit_more = FALSE; /* reset after CTRL-D which had a more-prompt */
  181. cursorcmd(); /* set the cursor on the right spot */
  182. c = vgetc();
  183. if (KeyTyped)
  184. {
  185.     some_key_typed = TRUE;
  186. #ifdef RIGHTLEFT
  187.     if (cmd_hkmap)
  188. c = hkmap(c);
  189. # ifdef FKMAP
  190.     if (cmd_fkmap)
  191. c = cmdl_fkmap(c);
  192. # endif
  193. #endif
  194. }
  196. /*
  197.  * Ignore got_int when CTRL-C was typed here.
  198.  * Don't ignore it in :global, we really need to break then, e.g., for
  199.  * ":g/pat/normal /pat" (without the <CR>).
  200.  * Don't ignore it for the input() function.
  201.  */
  202. if ((c == Ctrl('C')
  203. #ifdef UNIX
  204. || c == intr_char
  205. #endif
  206. )
  207. #ifdef WANT_EVAL
  208. && firstc != '@'
  209. #endif
  210. && !global_busy)
  211.     got_int = FALSE;
  213. /* free old command line when finished moving around in the history
  214.  * list */
  215. if (lookfor
  216. && c != K_S_DOWN && c != K_S_UP && c != K_DOWN && c != K_UP
  217. && c != K_PAGEDOWN && c != K_PAGEUP
  218. && c != K_KPAGEDOWN && c != K_KPAGEUP
  219. && c != K_LEFT && c != K_RIGHT
  220. && (cmd_numfiles > 0 || (c != Ctrl('P') && c != Ctrl('N'))))
  221. {
  222.     vim_free(lookfor);
  223.     lookfor = NULL;
  224. }
  226. /*
  227.  * <S-Tab> works like CTRL-P (unless 'wc' is <S-Tab>).
  228.  */
  229. if (c != p_wc && c == K_S_TAB && cmd_numfiles != -1)
  230.     c = Ctrl('P');
  232. /* free expanded names when finished walking through matches */
  233. if (cmd_numfiles != -1 && !(c == p_wc && KeyTyped)
  234. && c != Ctrl('N') && c != Ctrl('P') && c != Ctrl('A')
  235. && c != Ctrl('L'))
  236. {
  237.     (void)ExpandOne(NULL, NULL, 0, WILD_FREE);
  238.     did_wild_list = FALSE;
  239.     wim_index = 0;
  240. }
  242. #ifdef DIGRAPHS
  243. c = do_digraph(c);
  244. #endif
  246. if (c == 'n' || c == 'r' || c == K_KENTER || (c == ESC
  247. && (!KeyTyped || vim_strchr(p_cpo, CPO_ESC) != NULL)))
  248. {
  249.     gotesc = FALSE; /* Might have typed ESC previously, don't
  250.    truncate the cmdline now. */
  251.     if (ccheck_abbr(c + ABBR_OFF))
  252. goto cmdline_changed;
  253.     windgoto(msg_row, 0);
  254.     out_flush();
  255.     break;
  256. }
  258. /*
  259.  * Completion for 'wildchar' key.
  260.  * - hitting <ESC> twice means: abandon command line.
  261.  * - wildcard expansion is only done when the key is really typed, not
  262.  *   when it comes from a macro
  263.  */
  264. if (c == p_wc && !gotesc && KeyTyped)
  265. {
  266.     if (cmd_numfiles > 0)   /* typed p_wc at least twice */
  267.     {
  268. /* if 'wildmode' contains "list", may still need to list */
  269. if (cmd_numfiles > 1
  270. && !did_wild_list
  271. && (wim_flags[wim_index] & WIM_LIST))
  272. {
  273.     showmatches();
  274.     redrawcmd();
  275.     did_wild_list = TRUE;
  276. }
  277. if (wim_flags[wim_index] & WIM_LONGEST)
  278.     res = nextwild(WILD_LONGEST, WILD_NO_BEEP);
  279. else if (wim_flags[wim_index] & WIM_FULL)
  280.     res = nextwild(WILD_NEXT, WILD_NO_BEEP);
  281. else
  282.     res = OK;     /* don't insert 'wildchar' now */
  283.     }
  284.     else     /* typed p_wc first time */
  285.     {
  286. j = ccline.cmdpos;
  287. /* if 'wildmode' first contains "longest", get longest
  288.  * common part */
  289. if (wim_flags[0] & WIM_LONGEST)
  290.     res = nextwild(WILD_LONGEST, WILD_NO_BEEP);
  291. else
  292.     res = nextwild(WILD_EXPAND_KEEP, WILD_NO_BEEP);
  293. /* when more than one match, and 'wildmode' first contains
  294.  * "list", or no change and 'wildmode' contains "longest,list",
  295.  * list all matches */
  296. if (res == OK && cmd_numfiles > 1)
  297. {
  298.     /* a "longest" that didn't do anything is skipped (but not
  299.      * "list:longest") */
  300.     if (wim_flags[0] == WIM_LONGEST && ccline.cmdpos == j)
  301. wim_index = 1;
  302.     if (wim_flags[wim_index] & WIM_LIST)
  303.     {
  304. if (!(wim_flags[0] & WIM_LONGEST))
  305.     nextwild(WILD_PREV, 0); /* remove match */
  306. showmatches();
  307. redrawcmd();
  308. did_wild_list = TRUE;
  309. if (wim_flags[wim_index] & WIM_LONGEST)
  310.     nextwild(WILD_LONGEST, WILD_NO_BEEP);
  311. else if (wim_flags[wim_index] & WIM_FULL)
  312.     nextwild(WILD_NEXT, WILD_NO_BEEP);
  313.     }
  314.     else
  315. vim_beep();
  316. }
  317.     }
  318.     if (wim_index < 3)
  319. ++wim_index;
  320.     if (c == ESC)
  321. gotesc = TRUE;
  322.     if (res == OK)
  323. goto cmdline_changed;
  324. }
  325. gotesc = FALSE;
  327. /* <S-Tab> goes to last match, in a clumsy way */
  328. if (c == K_S_TAB && KeyTyped)
  329. {
  330.     if (nextwild(WILD_EXPAND_KEEP, 0) == OK
  331.     && nextwild(WILD_PREV, 0) == OK
  332.     && nextwild(WILD_PREV, 0) == OK)
  333. goto cmdline_changed;
  334. }
  336. if (c == NUL || c == K_ZERO)     /* NUL is stored as NL */
  337.     c = NL;
  339. do_abbr = TRUE; /* default: check for abbreviation */
  340. switch (c)
  341. {
  342. case K_BS:
  343. case Ctrl('H'):
  344. case K_DEL:
  345. case Ctrl('W'):
  346. #ifdef FKMAP
  347. if (cmd_fkmap && c == K_BS)
  348.     c = K_DEL;
  349. #endif
  350. /*
  351.  * delete current character is the same as backspace on next
  352.  * character, except at end of line
  353.  */
  354. if (c == K_DEL && ccline.cmdpos != ccline.cmdlen)
  355.     ++ccline.cmdpos;
  356. if (ccline.cmdpos > 0)
  357. {
  358.     j = ccline.cmdpos;
  359.     if (c == Ctrl('W'))
  360.     {
  361. while (ccline.cmdpos &&
  362.        vim_isspace(ccline.cmdbuff[ccline.cmdpos - 1]))
  363.     --ccline.cmdpos;
  364. i = vim_iswordc(ccline.cmdbuff[ccline.cmdpos - 1]);
  365. while (ccline.cmdpos && !vim_isspace(
  366.  ccline.cmdbuff[ccline.cmdpos - 1]) &&
  367. vim_iswordc(
  368.       ccline.cmdbuff[ccline.cmdpos - 1]) == i)
  369.     --ccline.cmdpos;
  370.     }
  371.     else
  372. --ccline.cmdpos;
  373.     ccline.cmdlen -= j - ccline.cmdpos;
  374.     i = ccline.cmdpos;
  375.     while (i < ccline.cmdlen)
  376. ccline.cmdbuff[i++] = ccline.cmdbuff[j++];
  377.     redrawcmd();
  378. }
  379. else if (ccline.cmdlen == 0 && c != Ctrl('W')
  380.    && ccline.cmdprompt == NULL && indent == 0)
  381. {
  382.     vim_free(ccline.cmdbuff); /* no commandline to return */
  383.     ccline.cmdbuff = NULL;
  384.     msg_col = 0;
  385.     msg_putchar(' '); /* delete ':' */
  386.     redraw_cmdline = TRUE;
  387.     goto returncmd; /* back to cmd mode */
  388. }
  389. goto cmdline_changed;
  391. case K_INS:
  392. #ifdef FKMAP
  393. /* if Farsi mode set, we are in reverse insert mode -
  394.    Do not change the mode */
  395. if (cmd_fkmap)
  396.     beep_flush();
  397. else
  398. #endif
  399. ccline.overstrike = !ccline.overstrike;
  400. #ifdef CURSOR_SHAPE
  401. ui_cursor_shape(); /* may show different cursor shape */
  402. #endif
  403. goto cmdline_not_changed;
  405. /* case '@':   only in very old vi */
  406. case Ctrl('U'):
  407. ccline.cmdpos = 0;
  408. ccline.cmdlen = 0;
  409. set_cmdspos();
  410. redrawcmd();
  411. goto cmdline_changed;
  413. case ESC: /* get here if p_wc != ESC or when ESC typed twice */
  414. case Ctrl('C'):
  415. gotesc = TRUE;     /* will free ccline.cmdbuff after putting
  416.        it in history */
  417. goto returncmd;     /* back to cmd mode */
  419. case Ctrl('R'):     /* insert register */
  420. #ifdef USE_GUI_WIN32
  421. dont_scroll = TRUE; /* disallow scrolling here */
  422. #endif
  423. putcmdline('"');
  424. ++no_mapping;
  425. c = vgetc();
  426. --no_mapping;
  427. #ifdef WANT_EVAL
  428. /*
  429.  * Insert the result of an expression.
  430.  * Need to save the current command line, to be able to enter
  431.  * a new one...
  432.  */
  433. if (c == '=')
  434. {
  435.     struct cmdline_info     save_ccline;
  437.     if (ccline.cmdfirstc == '=')/* can't do this recursively */
  438.     {
  439. beep_flush();
  440. c = ESC;
  441.     }
  442.     else
  443.     {
  444. save_ccline = ccline;
  445. c = get_expr_register();
  446. ccline = save_ccline;
  447.     }
  448. }
  449. #endif
  450. if (c != ESC)     /* use ESC to cancel inserting register */
  451.     cmdline_paste(c);
  452. redrawcmd();
  453. goto cmdline_changed;
  455. case Ctrl('D'):
  456. if (showmatches() == FAIL)
  457.     break; /* Use ^D as normal char instead */
  459. redrawcmd();
  460. continue; /* don't do incremental search now */
  462. case K_RIGHT:
  463. case K_S_RIGHT:
  464. do
  465. {
  466.     if (ccline.cmdpos >= ccline.cmdlen)
  467. break;
  468.     ccline.cmdspos += charsize(ccline.cmdbuff[ccline.cmdpos]);
  469.     ++ccline.cmdpos;
  470. }
  471. while ((c == K_S_RIGHT || (mod_mask & MOD_MASK_CTRL))
  472. && ccline.cmdbuff[ccline.cmdpos] != ' ');
  473. goto cmdline_not_changed;
  475. case K_LEFT:
  476. case K_S_LEFT:
  477. do
  478. {
  479.     if (ccline.cmdpos <= 0)
  480. break;
  481.     --ccline.cmdpos;
  482.     ccline.cmdspos -= charsize(ccline.cmdbuff[ccline.cmdpos]);
  483. }
  484. while ((c == K_S_LEFT || (mod_mask & MOD_MASK_CTRL))
  485. && ccline.cmdbuff[ccline.cmdpos - 1] != ' ');
  486. goto cmdline_not_changed;
  488. #if defined(USE_MOUSE) || defined(FKMAP)
  489. case K_IGNORE:
  490. #endif
  491. #ifdef USE_MOUSE
  492. case K_MIDDLEDRAG:
  493. case K_MIDDLERELEASE:
  494. goto cmdline_not_changed;   /* Ignore mouse */
  496. case K_MIDDLEMOUSE:
  497. # ifdef USE_GUI
  498. /* When GUI is active, also paste when 'mouse' is empty */
  499. if (!gui.in_use)
  500. # endif
  501.     if (!mouse_has(MOUSE_COMMAND))
  502. goto cmdline_not_changed;   /* Ignore mouse */
  503. # ifdef USE_GUI
  504. if (gui.in_use)
  505.     cmdline_paste('*');
  506. else
  507. # endif
  508.     cmdline_paste(0);
  509. redrawcmd();
  510. goto cmdline_changed;
  512. case K_LEFTDRAG:
  513. case K_LEFTRELEASE:
  514. case K_RIGHTDRAG:
  515. case K_RIGHTRELEASE:
  516. if (ignore_drag_release)
  517.     goto cmdline_not_changed;
  518. /* FALLTHROUGH */
  519. case K_LEFTMOUSE:
  520. case K_RIGHTMOUSE:
  521. if (c == K_LEFTRELEASE || c == K_RIGHTRELEASE)
  522.     ignore_drag_release = TRUE;
  523. else
  524.     ignore_drag_release = FALSE;
  525. # ifdef USE_GUI
  526. /* When GUI is active, also move when 'mouse' is empty */
  527. if (!gui.in_use)
  528. # endif
  529.     if (!mouse_has(MOUSE_COMMAND))
  530. goto cmdline_not_changed;   /* Ignore mouse */
  531. set_cmdspos();
  532. for (ccline.cmdpos = 0; ccline.cmdpos < ccline.cmdlen;
  533.       ++ccline.cmdpos)
  534. {
  535.     i = charsize(ccline.cmdbuff[ccline.cmdpos]);
  536.     if (mouse_row <= cmdline_row + ccline.cmdspos / Columns &&
  537.      mouse_col < ccline.cmdspos % Columns + i)
  538. break;
  539.     ccline.cmdspos += i;
  540. }
  541. goto cmdline_not_changed;
  542. #endif /* USE_MOUSE */
  544. #ifdef USE_GUI
  545. case K_SCROLLBAR:
  546. if (!msg_scrolled)
  547. {
  548.     gui_do_scroll();
  549.     redrawcmd();
  550. }
  551. goto cmdline_not_changed;
  553. case K_HORIZ_SCROLLBAR:
  554. if (!msg_scrolled)
  555. {
  556.     gui_do_horiz_scroll();
  557.     redrawcmd();
  558. }
  559. goto cmdline_not_changed;
  560. #endif
  561. case K_SELECT:     /* end of Select mode mapping - ignore */
  562. goto cmdline_not_changed;
  564. case Ctrl('B'):     /* begin of command line */
  565. case K_HOME:
  566. case K_KHOME:
  567. case K_S_HOME:
  568. ccline.cmdpos = 0;
  569. set_cmdspos();
  570. goto cmdline_not_changed;
  572. case Ctrl('E'):     /* end of command line */
  573. case K_END:
  574. case K_KEND:
  575. case K_S_END:
  576. ccline.cmdpos = ccline.cmdlen;
  577. ccline.cmdbuff[ccline.cmdlen] = NUL;
  578. set_cmdspos();
  579. ccline.cmdspos += vim_strsize(ccline.cmdbuff);
  580. goto cmdline_not_changed;
  582. case Ctrl('A'):     /* all matches */
  583. if (nextwild(WILD_ALL, 0) == FAIL)
  584.     break;
  585. goto cmdline_changed;
  587. case Ctrl('L'):     /* longest common part */
  588. if (nextwild(WILD_LONGEST, 0) == FAIL)
  589.     break;
  590. goto cmdline_changed;
  592. case Ctrl('N'):     /* next match */
  593. case Ctrl('P'):     /* previous match */
  594. if (cmd_numfiles > 0)
  595. {
  596.     if (nextwild((c == Ctrl('P')) ? WILD_PREV : WILD_NEXT, 0)
  597.       == FAIL)
  598. break;
  599.     goto cmdline_changed;
  600. }
  602. case K_UP:
  603. case K_DOWN:
  604. case K_S_UP:
  605. case K_S_DOWN:
  606. case K_PAGEUP:
  607. case K_KPAGEUP:
  608. case K_PAGEDOWN:
  609. case K_KPAGEDOWN:
  610. if (hislen == 0 || firstc == NUL) /* no history */
  611.     goto cmdline_not_changed;
  613. i = hiscnt;
  615. /* save current command string so it can be restored later */
  616. ccline.cmdbuff[ccline.cmdlen] = NUL;
  617. if (lookfor == NULL)
  618. {
  619.     if ((lookfor = vim_strsave(ccline.cmdbuff)) == NULL)
  620. goto cmdline_not_changed;
  621.     lookfor[ccline.cmdpos] = NUL;
  622. }
  624. j = STRLEN(lookfor);
  625. for (;;)
  626. {
  627.     /* one step backwards */
  628.     if (c == K_UP || c == K_S_UP || c == Ctrl('P') ||
  629.     c == K_PAGEUP || c == K_KPAGEUP)
  630.     {
  631. if (hiscnt == hislen) /* first time */
  632.     hiscnt = hisidx[histype];
  633. else if (hiscnt == 0 && hisidx[histype] != hislen - 1)
  634.     hiscnt = hislen - 1;
  635. else if (hiscnt != hisidx[histype] + 1)
  636.     --hiscnt;
  637. else /* at top of list */
  638. {
  639.     hiscnt = i;
  640.     break;
  641. }
  642.     }
  643.     else    /* one step forwards */
  644.     {
  645. /* on last entry, clear the line */
  646. if (hiscnt == hisidx[histype])
  647. {
  648.     hiscnt = hislen;
  649.     break;
  650. }
  652. /* not on a history line, nothing to do */
  653. if (hiscnt == hislen)
  654.     break;
  655. if (hiscnt == hislen - 1)   /* wrap around */
  656.     hiscnt = 0;
  657. else
  658.     ++hiscnt;
  659.     }
  660.     if (hiscnt < 0 || history[histype][hiscnt] == NULL)
  661.     {
  662. hiscnt = i;
  663. break;
  664.     }
  665.     if ((c != K_UP && c != K_DOWN) || hiscnt == i ||
  666.     STRNCMP(history[histype][hiscnt],
  667.     lookfor, (size_t)j) == 0)
  668. break;
  669. }
  671. if (hiscnt != i) /* jumped to other entry */
  672. {
  673.     vim_free(ccline.cmdbuff);
  674.     if (hiscnt == hislen)
  675. p = lookfor; /* back to the old one */
  676.     else
  677. p = history[histype][hiscnt];
  679.     alloc_cmdbuff((int)STRLEN(p));
  680.     if (ccline.cmdbuff == NULL)
  681. goto returncmd;
  682.     STRCPY(ccline.cmdbuff, p);
  684.     ccline.cmdpos = ccline.cmdlen = STRLEN(ccline.cmdbuff);
  685.     redrawcmd();
  686.     goto cmdline_changed;
  687. }
  688. beep_flush();
  689. goto cmdline_not_changed;
  691. case Ctrl('V'):
  692. case Ctrl('Q'):
  693. #ifdef USE_MOUSE
  694. ignore_drag_release = TRUE;
  695. #endif
  696. putcmdline('^');
  697. c = get_literal();     /* get next (two) character(s) */
  698. do_abbr = FALSE;     /* don't do abbreviation now */
  699. break;
  701. #ifdef DIGRAPHS
  702. case Ctrl('K'):
  703. #ifdef USE_MOUSE
  704. ignore_drag_release = TRUE;
  705. #endif
  706. putcmdline('?');
  707. #ifdef USE_GUI_WIN32
  708. dont_scroll = TRUE;     /* disallow scrolling here */
  709. #endif
  710. ++no_mapping;
  711. ++allow_keys;
  712. c = vgetc();
  713. --no_mapping;
  714. --allow_keys;
  715. if (c != ESC)     /* ESC cancels CTRL-K */
  716. {
  717.     if (IS_SPECIAL(c))     /* insert special key code */
  718. break;
  719.     if (charsize(c) == 1)
  720. putcmdline(c);
  721.     ++no_mapping;
  722.     ++allow_keys;
  723.     cc = vgetc();
  724.     --no_mapping;
  725.     --allow_keys;
  726.     if (cc != ESC)     /* ESC cancels CTRL-K */
  727.     {
  728. c = getdigraph(c, cc, TRUE);
  729. break;
  730.     }
  731. }
  732. redrawcmd();
  733. goto cmdline_not_changed;
  734. #endif /* DIGRAPHS */
  736. #ifdef RIGHTLEFT
  737. case Ctrl('_'):     /* CTRL-_: switch language mode */
  738. if (!p_ari)
  739.     break;
  740. #ifdef FKMAP
  741. if (p_altkeymap)
  742. {
  743.     cmd_fkmap = !cmd_fkmap;
  744.     if (cmd_fkmap) /* in Farsi always in Insert mode */
  745. ccline.overstrike = FALSE;
  746. }
  747. else     /* Hebrew is default */
  748. #endif
  749.     cmd_hkmap = !cmd_hkmap;
  750. goto cmdline_not_changed;
  751. #endif
  753.     /* keypad keys: When not mapped they produce a normal char */
  754. case K_KPLUS: c = '+'; break;
  755. case K_KMINUS: c = '-'; break;
  756. case K_KDIVIDE: c = '/'; break;
  757. case K_KMULTIPLY: c = '*'; break;
  759. default:
  760. #ifdef UNIX
  761. if (c == intr_char)
  762. {
  763.     gotesc = TRUE; /* will free ccline.cmdbuff after
  764.    putting it in history */
  765.     goto returncmd; /* back to cmd mode */
  766. }
  767. #endif
  768. /*
  769.  * Normal character with no special meaning.  Just set mod_mask
  770.  * to 0x0 so that typing Shift-Space in the GUI doesn't enter
  771.  * the string <S-Space>.  This should only happen after ^V.
  772.  */
  773. if (!IS_SPECIAL(c))
  774.     mod_mask = 0x0;
  775. break;
  776. }
  778. /* we come here if we have a normal character */
  780. if (do_abbr && (IS_SPECIAL(c) || !vim_iswordc(c)) && ccheck_abbr(c))
  781.     goto cmdline_changed;
  783. /*
  784.  * put the character in the command line
  785.  */
  786. if (IS_SPECIAL(c) || mod_mask != 0x0)
  787.     put_on_cmdline(get_special_key_name(c, mod_mask), -1, TRUE);
  788. else
  789. {
  790.     IObuff[0] = c;
  792. #ifdef MULTI_BYTE
  793.     /* prevent from splitting a multi-byte character into two
  794.        indivisual characters in command line. */
  795.     if (is_dbcs && IsLeadByte(c))
  796.     {
  797. IObuff[1] = vgetc();
  798. put_on_cmdline(IObuff, 2, TRUE);
  799.     }
  800.     else
  801. put_on_cmdline(IObuff, 1, TRUE);
  802. #else
  803.     put_on_cmdline(IObuff, 1, TRUE);
  804. #endif
  805. }
  806. goto cmdline_changed;
  808. /*
  809.  * This part implements incremental searches for "/" and "?"
  810.  * Jump to cmdline_not_changed when a character has been read but the command
  811.  * line did not change. Then we only search and redraw if something changed in
  812.  * the past.
  813.  * Jump to cmdline_changed when the command line did change.
  814.  * (Sorry for the goto's, I know it is ugly).
  815.  */
  816. cmdline_not_changed:
  817. #ifdef EXTRA_SEARCH
  818. if (!incsearch_postponed)
  819.     continue;
  820. #endif
  822. cmdline_changed:
  823. #ifdef EXTRA_SEARCH
  824. if (p_is && (firstc == '/' || firstc == '?'))
  825. {
  826.     /* if there is a character waiting, search and redraw later */
  827.     if (char_avail())
  828.     {
  829. incsearch_postponed = TRUE;
  830. continue;
  831.     }
  832.     incsearch_postponed = FALSE;
  833.     curwin->w_cursor = old_cursor;  /* start at old position */
  835.     /* If there is no command line, don't do anything */
  836.     if (ccline.cmdlen == 0)
  837. i = 0;
  838.     else
  839.     {
  840. ccline.cmdbuff[ccline.cmdlen] = NUL;
  841. emsg_off = TRUE;    /* So it doesn't beep if bad expr */
  842. i = do_search(NULL, firstc, ccline.cmdbuff, count,
  843.       SEARCH_KEEP + SEARCH_OPT + SEARCH_NOOF);
  844. emsg_off = FALSE;
  845.     }
  846.     if (i)
  847. highlight_match = TRUE; /* highlight position */
  848.     else
  849. highlight_match = FALSE;     /* don't highlight */
  851.     /* first restore the old curwin values, so the screen is
  852.      * positioned in the same way as the actual search command */
  853.     curwin->w_leftcol = old_leftcol;
  854.     curwin->w_topline = old_topline;
  855.     curwin->w_botline = old_botline;
  856.     update_topline();
  857.     /*
  858.      * First move cursor to end of match, then to start.  This moves
  859.      * the whole match onto the screen when 'nowrap' is set.
  860.      */
  861.     curwin->w_cursor.col += search_match_len;
  862.     validate_cursor();
  863.     curwin->w_cursor.col -= search_match_len;
  864.     validate_cursor();
  866.     update_screen(NOT_VALID);
  867.     redrawcmdline();
  868.     did_incsearch = TRUE;
  869. }
  870. #else
  871. ;
  872. #endif
  873.     }
  875. returncmd:
  877. #ifdef FKMAP
  878.     cmd_fkmap = 0;
  879. #endif
  881. #ifdef EXTRA_SEARCH
  882.     if (did_incsearch)
  883.     {
  884. curwin->w_cursor = old_cursor;
  885. curwin->w_curswant = old_curswant;
  886. curwin->w_leftcol = old_leftcol;
  887. curwin->w_topline = old_topline;
  888. curwin->w_botline = old_botline;
  889. highlight_match = FALSE;
  890. validate_cursor(); /* needed for TAB */
  891. redraw_later(NOT_VALID);
  892.     }
  893. #endif
  895.     if (ccline.cmdbuff != NULL)
  896.     {
  897. /*
  898.  * Put line in history buffer (":" and "=" only when it was typed).
  899.  */
  900. ccline.cmdbuff[ccline.cmdlen] = NUL;
  901. if (ccline.cmdlen && firstc &&
  902.    (some_key_typed || histype == HIST_SEARCH))
  903. {
  904.     add_to_history(histype, ccline.cmdbuff);
  905.     if (firstc == ':')
  906.     {
  907. vim_free(new_last_cmdline);
  908. new_last_cmdline = vim_strsave(ccline.cmdbuff);
  909.     }
  910. }
  912. if (gotesc)     /* abandon command line */
  913. {
  914.     vim_free(ccline.cmdbuff);
  915.     ccline.cmdbuff = NULL;
  916.     MSG("");
  917.     redraw_cmdline = TRUE;
  918. }
  919.     }
  921.     /*
  922.      * If the screen was shifted up, redraw the whole screen (later).
  923.      * If the line is too long, clear it, so ruler and shown command do
  924.      * not get printed in the middle of it.
  925.      */
  926.     msg_check();
  927.     msg_scroll = save_msg_scroll;
  928.     redir_off = FALSE;
  930.     State = save_State;
  931. #ifdef USE_MOUSE
  932.     setmouse();
  933. #endif
  935.     return ccline.cmdbuff;
  936. }
  938.     static void
  939. set_cmdspos()
  940. {
  941.     if (ccline.cmdfirstc)
  942. ccline.cmdspos = 1 + ccline.cmdindent;
  943.     else
  944. ccline.cmdspos = 0 + ccline.cmdindent;
  945. }
  947. /*
  948.  * Get an Ex command line for the ":" command.
  949.  */
  950. /* ARGSUSED */
  951.     char_u *
  952. getexline(c, dummy, indent)
  953.     int c; /* normally ':', NUL for ":append" */
  954.     void *dummy; /* cookie not used */
  955.     int indent; /* indent for inside conditionals */
  956. {
  957.     return getcmdline(c, 1L, indent);
  958. }
  960. /*
  961.  * Get an Ex command line for Ex mode.
  962.  * In Ex mode we only use the OS supplied line editing features and no
  963.  * mappings or abbreviations.
  964.  */
  965. /* ARGSUSED */
  966.     char_u *
  967. getexmodeline(c, dummy, indent)
  968.     int c; /* normally ':', NUL for ":append" */
  969.     void *dummy; /* cookie not used */
  970.     int indent; /* indent for inside conditionals */
  971. {
  972.     struct growarray line_ga;
  973.     int len;
  974.     int off = 0;
  975.     char_u *p;
  976.     int finished = FALSE;
  977. #if defined(USE_GUI) || defined(NO_COOKED_INPUT)
  978.     int startcol = 0;
  979.     int c1;
  980.     int escaped = FALSE; /* CTRL-V typed */
  981.     int vcol = 0;
  982. #endif
  984.     /* always start in column 0; write a newline if necessary */
  985.     compute_cmdrow();
  986.     if (msg_col)
  987. msg_putchar('n');
  988.     if (c == ':')
  989.     {
  990. msg_putchar(':');
  991. while (indent-- > 0)
  992.     msg_putchar(' ');
  993. #if defined(USE_GUI) || defined(NO_COOKED_INPUT)
  994. startcol = msg_col;
  995. #endif
  996.     }
  998.     ga_init2(&line_ga, 1, 30);
  1000.     /*
  1001.      * Get the line, one character at a time.
  1002.      */
  1003.     got_int = FALSE;
  1004.     while (!got_int && !finished)
  1005.     {
  1006. if (ga_grow(&line_ga, 40) == FAIL)
  1007.     break;
  1008. p = (char_u *)line_ga.ga_data + line_ga.ga_len;
  1010. /* Get one character (inchar gets a third of maxlen characters!) */
  1011. len = inchar(p + off, 3, -1L);
  1012. if (len < 0)
  1013.     continue;     /* end of input script reached */
  1014. /* for a special character, we need at least three characters */
  1015. if ((*p == K_SPECIAL || *p == CSI) && off + len < 3)
  1016. {
  1017.     off += len;
  1018.     continue;
  1019. }
  1020. len += off;
  1021. off = 0;
  1023. /*
  1024.  * When using the GUI, and for systems that don't have cooked input,
  1025.  * handle line editing here.
  1026.  */
  1027. #if defined(USE_GUI) || defined(NO_COOKED_INPUT)
  1028. # ifndef NO_COOKED_INPUT
  1029. if (gui.in_use)
  1030. # endif
  1031. {
  1032.     if (got_int)
  1033.     {
  1034. msg_putchar('n');
  1035. break;
  1036.     }
  1038.     while (len > 0)
  1039.     {
  1040. c1 = *p++;
  1041. --len;
  1042. # ifndef NO_COOKED_INPUT
  1043. if ((c1 == K_SPECIAL || c1 == CSI) && len >= 2)
  1044. # else
  1045. #  ifdef USE_GUI
  1046. if ((c1 == K_SPECIAL || (c1 == CSI && gui.in_use)) && len >= 2)
  1047. #  else
  1048. if (c1 == K_SPECIAL && len >= 2)
  1049. #  endif
  1050. # endif
  1051. {
  1052.     c1 = TO_SPECIAL(p[0], p[1]);
  1053.     p += 2;
  1054.     len -= 2;
  1055. }
  1057. if (!escaped)
  1058. {
  1059.     if (c1 == BS || c1 == K_BS || c1 == DEL || c1 == K_DEL)
  1060.     {
  1061. if (line_ga.ga_len > 0)
  1062. {
  1063.     int i, v;
  1064.     char_u *q;
  1066.     --line_ga.ga_len;
  1067.     ++line_ga.ga_room;
  1068.     /* compute column that cursor should be in */
  1069.     v = 0;
  1070.     q = ((char_u *)line_ga.ga_data);
  1071.     for (i = 0; i < line_ga.ga_len; ++i)
  1072.     {
  1073. if (*q == TAB)
  1074.     v += 8 - v % 8;
  1075. else
  1076.     v += charsize(*q);
  1077. ++q;
  1078.     }
  1079.     /* erase characters to position cursor */
  1080.     while (vcol > v)
  1081.     {
  1082. msg_putchar('b');
  1083. msg_putchar(' ');
  1084. msg_putchar('b');
  1085. --vcol;
  1086.     }
  1087. }
  1088. continue;
  1089.     }
  1091.     if (c1 == Ctrl('U'))
  1092.     {
  1093. msg_col = startcol;
  1094. msg_clr_eos();
  1095. line_ga.ga_room += line_ga.ga_len;
  1096. line_ga.ga_len = 0;
  1097. continue;
  1098.     }
  1100.     if (c1 == Ctrl('V'))
  1101.     {
  1102. escaped = TRUE;
  1103. continue;
  1104.     }
  1105. }
  1107. ((char_u *)line_ga.ga_data)[line_ga.ga_len] = c1;
  1108. if (c1 == 'r')
  1109.     msg_putchar('n');
  1110. else if (c1 == TAB)
  1111. {
  1112.     /* Don't use chartabsize(), 'ts' can be different */
  1113.     do
  1114.     {
  1115. msg_putchar(' ');
  1116.     } while (++vcol % 8);
  1117. }
  1118. else
  1119. {
  1120.     msg_outtrans_len(
  1121.      ((char_u *)line_ga.ga_data) + line_ga.ga_len, 1);
  1122.     vcol += charsize(c1);
  1123. }
  1124. ++line_ga.ga_len;
  1125. --line_ga.ga_room;
  1126. escaped = FALSE;
  1127.     }
  1128.     windgoto(msg_row, msg_col);
  1129. }
  1130. # ifndef NO_COOKED_INPUT
  1131. else
  1132. # endif
  1133. #endif
  1134. #ifndef NO_COOKED_INPUT
  1135. {
  1136.     line_ga.ga_len += len;
  1137.     line_ga.ga_room -= len;
  1138. }
  1139. #endif
  1140. p = (char_u *)(line_ga.ga_data) + line_ga.ga_len;
  1141. while (line_ga.ga_len && (p[-1] == 'n' || p[-1] == 'r'))
  1142. {
  1143.     finished = TRUE;
  1144.     --line_ga.ga_len;
  1145.     --p;
  1146.     *p = NUL;
  1147. }
  1148.     }
  1150.     /* note that cursor has moved, because of the echoed <CR> */
  1151.     screen_down();
  1152.     /* make following messages go to the next line */
  1153.     msg_didout = FALSE;
  1154.     msg_col = 0;
  1155.     if (msg_row < Rows - 1)
  1156. ++msg_row;
  1157.     emsg_on_display = FALSE; /* don't want ui_delay() */
  1159.     if (got_int)
  1160. ga_clear(&line_ga);
  1162.     return (char_u *)line_ga.ga_data;
  1163. }
  1165. #ifdef CURSOR_SHAPE
  1166. /*
  1167.  * Return TRUE if ccline.overstrike is on.
  1168.  */
  1169.     int
  1170. cmdline_overstrike()
  1171. {
  1172.     return ccline.overstrike;
  1173. }
  1175. /*
  1176.  * Return TRUE if the cursor is at the end of the cmdline.
  1177.  */
  1178.     int
  1179. cmdline_at_end()
  1180. {
  1181.     return (ccline.cmdpos >= ccline.cmdlen);
  1182. }
  1183. #endif
  1185. /*
  1186.  * Allocate a new command line buffer.
  1187.  * Assigns the new buffer to ccline.cmdbuff and ccline.cmdbufflen.
  1188.  * Returns the new value of ccline.cmdbuff and ccline.cmdbufflen.
  1189.  */
  1190.     static void
  1191. alloc_cmdbuff(len)
  1192.     int     len;
  1193. {
  1194.     /*
  1195.      * give some extra space to avoid having to allocate all the time
  1196.      */
  1197.     if (len < 80)
  1198. len = 100;
  1199.     else
  1200. len += 20;
  1202.     ccline.cmdbuff = alloc(len);    /* caller should check for out-of-memory */
  1203.     ccline.cmdbufflen = len;
  1204. }
  1206. /*
  1207.  * Re-allocate the command line to length len + something extra.
  1208.  * return FAIL for failure, OK otherwise
  1209.  */
  1210.     static int
  1211. realloc_cmdbuff(len)
  1212.     int     len;
  1213. {
  1214.     char_u *p;
  1216.     p = ccline.cmdbuff;
  1217.     alloc_cmdbuff(len); /* will get some more */
  1218.     if (ccline.cmdbuff == NULL) /* out of memory */
  1219.     {
  1220. ccline.cmdbuff = p; /* keep the old one */
  1221. return FAIL;
  1222.     }
  1223.     mch_memmove(ccline.cmdbuff, p, (size_t)ccline.cmdlen);
  1224.     vim_free(p);
  1225.     return OK;
  1226. }
  1228. /*
  1229.  * put a character on the command line.
  1230.  * Used for CTRL-V and CTRL-K
  1231.  */
  1232.     static void
  1233. putcmdline(c)
  1234.     int     c;
  1235. {
  1236.     char_u  buf[1];
  1238.     buf[0] = c;
  1239.     msg_outtrans_len(buf, 1);
  1240.     msg_outtrans_len(ccline.cmdbuff + ccline.cmdpos,
  1241.        ccline.cmdlen - ccline.cmdpos);
  1242.     cursorcmd();
  1243. }
  1245. /*
  1246.  * Put the given string, of the given length, onto the command line.
  1247.  * If len is -1, then STRLEN() is used to calculate the length.
  1248.  * If 'redraw' is TRUE then the new part of the command line, and the remaining
  1249.  * part will be redrawn, otherwise it will not.  If this function is called
  1250.  * twice in a row, then 'redraw' should be FALSE and redrawcmd() should be
  1251.  * called afterwards.
  1252.  */
  1253.     int
  1254. put_on_cmdline(str, len, redraw)
  1255.     char_u  *str;
  1256.     int     len;
  1257.     int     redraw;
  1258. {
  1259.     int     i;
  1261.     if (len < 0)
  1262. len = STRLEN(str);
  1264.     /* Check if ccline.cmdbuff needs to be longer */
  1265.     if (ccline.cmdlen + len + 1 >= ccline.cmdbufflen)
  1266. i = realloc_cmdbuff(ccline.cmdlen + len);
  1267.     else
  1268. i = OK;
  1269.     if (i == OK)
  1270.     {
  1271. if (!ccline.overstrike)
  1272. {
  1273.     mch_memmove(ccline.cmdbuff + ccline.cmdpos + len,
  1274.        ccline.cmdbuff + ccline.cmdpos,
  1275.      (size_t)(ccline.cmdlen - ccline.cmdpos));
  1276.     ccline.cmdlen += len;
  1277. }
  1278. else if (ccline.cmdpos + len > ccline.cmdlen)
  1279.     ccline.cmdlen = ccline.cmdpos + len;
  1280. mch_memmove(ccline.cmdbuff + ccline.cmdpos, str, (size_t)len);
  1281. if (redraw)
  1282.     msg_outtrans_len(ccline.cmdbuff + ccline.cmdpos,
  1283.        ccline.cmdlen - ccline.cmdpos);
  1284. #ifdef FKMAP
  1285. /*
  1286.  ** If we are in Farsi command mode, the character input must be in
  1287.  ** insert mode. So do not advance the cmdpos.
  1288.  */
  1289. if (!cmd_fkmap)
  1290. #endif
  1291. {
  1292.     ccline.cmdpos += len;
  1293.     while (len--)
  1294. ccline.cmdspos += charsize(str[len]);
  1295. }
  1296.     }
  1297.     if (redraw)
  1298. msg_check();
  1299.     return i;
  1300. }
  1302. /*
  1303.  * this fuction is called when the screen size changes and with incremental
  1304.  * search
  1305.  */
  1306.     void
  1307. redrawcmdline()
  1308. {
  1309.     msg_scrolled = 0;
  1310.     need_wait_return = FALSE;
  1311.     compute_cmdrow();
  1312.     redrawcmd();
  1313.     cursorcmd();
  1314. }
  1316.     static void
  1317. redrawcmdprompt()
  1318. {
  1319.     int i;
  1321.     if (ccline.cmdfirstc)
  1322. msg_putchar(ccline.cmdfirstc);
  1323.     if (ccline.cmdprompt != NULL)
  1324.     {
  1325. msg_puts_attr(ccline.cmdprompt, ccline.cmdattr);
  1326. ccline.cmdindent = msg_col;
  1327.     }
  1328.     else
  1329. for (i = ccline.cmdindent; i > 0; --i)
  1330.     msg_putchar(' ');
  1331. }
  1333. /*
  1334.  * Redraw what is currently on the command line.
  1335.  */
  1336.     static void
  1337. redrawcmd()
  1338. {
  1339.     int     i;
  1341.     msg_start();
  1342.     redrawcmdprompt();
  1343.     msg_outtrans_len(ccline.cmdbuff, ccline.cmdlen);
  1344.     msg_clr_eos();
  1346.     set_cmdspos();
  1347.     for (i = 0; i < ccline.cmdlen && i < ccline.cmdpos; ++i)
  1348. ccline.cmdspos += charsize(ccline.cmdbuff[i]);
  1349.     /*
  1350.      * An emsg() before may have set msg_scroll. This is used in normal mode,
  1351.      * in cmdline mode we can reset them now.
  1352.      */
  1353.     msg_scroll = FALSE; /* next message overwrites cmdline */
  1355.     /* Typing ':' at the more prompt may set skip_redraw.  We don't want this
  1356.      * in cmdline mode */
  1357.     skip_redraw = FALSE;
  1358. }
  1360. /*
  1361.  * Set prompt in front of cmdline.
  1362.  */
  1363.     void
  1364. cmdline_prompt(cmsg, attr)
  1365.     char_u *cmsg;
  1366.     int attr;
  1367. {
  1368.     ccline.cmdprompt = cmsg;
  1369.     ccline.cmdattr = attr;
  1370. }
  1372.     void
  1373. compute_cmdrow()
  1374. {
  1375.     if (exmode_active)
  1376. cmdline_row = Rows - 1;
  1377.     else
  1378. cmdline_row = lastwin->w_winpos + lastwin->w_height +
  1379. lastwin->w_status_height;
  1380. }
  1382.     static void
  1383. cursorcmd()
  1384. {
  1385.     msg_row = cmdline_row + (ccline.cmdspos / (int)Columns);
  1386.     msg_col = ccline.cmdspos % (int)Columns;
  1387.     if (msg_row >= Rows)
  1388. msg_row = Rows - 1;
  1389.     windgoto(msg_row, msg_col);
  1390. #if defined(MSDOS) || (defined(WIN32) && !defined(USE_GUI_WIN32))
  1391.     mch_update_cursor();
  1392. #endif
  1393. }
  1395.     void
  1396. gotocmdline(clr)
  1397.     int     clr;
  1398. {
  1399.     msg_start();
  1400.     msg_col = 0;     /* always start in column 0 */
  1401.     if (clr)     /* clear the bottom line(s) */
  1402. msg_clr_eos();     /* will reset clear_cmdline */
  1403.     windgoto(cmdline_row, 0);
  1404. }
  1406. /*
  1407.  * Check the word in front of the cursor for an abbreviation.
  1408.  * Called when the non-id character "c" has been entered.
  1409.  * When an abbreviation is recognized it is removed from the text with
  1410.  * backspaces and the replacement string is inserted, followed by "c".
  1411.  */
  1412.     static int
  1413. ccheck_abbr(c)
  1414.     int c;
  1415. {
  1416.     if (p_paste || no_abbr)     /* no abbreviations or in paste mode */
  1417. return FALSE;
  1419.     return check_abbr(c, ccline.cmdbuff, ccline.cmdpos, 0);
  1420. }
  1422. /*
  1423.  * Return FAIL if this is not an appropriate context in which to do
  1424.  * completion of anything, return OK if it is (even if there are no matches).
  1425.  * For the caller, this means that the character is just passed through like a
  1426.  * normal character (instead of being expanded).  This allows :s/^I^D etc.
  1427.  */
  1428.     static int
  1429. nextwild(type, options)
  1430.     int     type;
  1431.     int     options;     /* extra options for ExpandOne() */
  1432. {
  1433.     int     i, j;
  1434.     char_u  *p1;
  1435.     char_u  *p2;
  1436.     int     oldlen;
  1437.     int     difflen;
  1438.     int     v;
  1440.     if (cmd_numfiles == -1)
  1441. set_expand_context();
  1442.     if (expand_context == EXPAND_UNSUCCESSFUL)
  1443.     {
  1444. beep_flush();
  1445. return OK;  /* Something illegal on command line */
  1446.     }
  1447.     if (expand_context == EXPAND_NOTHING)
  1448.     {
  1449. /* Caller can use the character as a normal char instead */
  1450. return FAIL;
  1451.     }
  1452.     expand_interactively = TRUE;
  1454.     MSG_PUTS("...");     /* show that we are busy */
  1455.     out_flush();
  1457.     i = expand_pattern - ccline.cmdbuff;
  1458.     oldlen = ccline.cmdpos - i;
  1460.     if (type == WILD_NEXT || type == WILD_PREV)
  1461.     {
  1462. /*
  1463.  * Get next/previous match for a previous expanded pattern.
  1464.  */
  1465. p2 = ExpandOne(NULL, NULL, 0, type);
  1466.     }
  1467.     else
  1468.     {
  1469. /*
  1470.  * Translate string into pattern and expand it.
  1471.  */
  1472. if ((p1 = addstar(&ccline.cmdbuff[i], oldlen)) == NULL)
  1473.     p2 = NULL;
  1474. else
  1475. {
  1476.     p2 = ExpandOne(p1, vim_strnsave(&ccline.cmdbuff[i], oldlen),
  1477.    WILD_HOME_REPLACE | options, type);
  1478.     vim_free(p1);
  1479.     /* longest match: make sure it is not shorter (happens with :help */
  1480.     if (p2 != NULL && type == WILD_LONGEST)
  1481.     {
  1482. for (j = 0; j < oldlen; ++j)
  1483.      if (ccline.cmdbuff[i + j] == '*'
  1484.      || ccline.cmdbuff[i + j] == '?')
  1485.  break;
  1486. if ((int)STRLEN(p2) < j)
  1487. {
  1488.     vim_free(p2);
  1489.     p2 = NULL;
  1490. }
  1491.     }
  1492. }
  1493.     }
  1495.     if (p2 != NULL)
  1496.     {
  1497. if (ccline.cmdlen + (difflen = STRLEN(p2) - oldlen) >
  1498. ccline.cmdbufflen - 4)
  1499. {
  1500.     v = realloc_cmdbuff(ccline.cmdlen + difflen);
  1501.     expand_pattern = ccline.cmdbuff + i;
  1502. }
  1503. else
  1504.     v = OK;
  1505. if (v == OK)
  1506. {
  1507.     vim_strncpy(&ccline.cmdbuff[ccline.cmdpos + difflen],
  1508.        &ccline.cmdbuff[ccline.cmdpos],
  1509.     ccline.cmdlen - ccline.cmdpos);
  1510.     STRNCPY(&ccline.cmdbuff[i], p2, STRLEN(p2));
  1511.     ccline.cmdlen += difflen;
  1512.     ccline.cmdpos += difflen;
  1513. }
  1514. vim_free(p2);
  1515.     }
  1517.     redrawcmd();
  1518.     if (cmd_numfiles <= 0 && p2 == NULL)
  1519. beep_flush();
  1520.     else if (cmd_numfiles == 1)
  1521. (void)ExpandOne(NULL, NULL, 0, WILD_FREE);  /* free expanded pattern */
  1523.     expand_interactively = FALSE;     /* reset for next call */
  1524.     return OK;
  1525. }
  1527. /*
  1528.  * Do wildcard expansion on the string 'str'.
  1529.  * Return a pointer to alloced memory containing the new string.
  1530.  * Return NULL for failure.
  1531.  *
  1532.  * mode = WILD_FREE:     just free previously expanded matches
  1533.  * mode = WILD_EXPAND_FREE: normal expansion, do not keep matches
  1534.  * mode = WILD_EXPAND_KEEP: normal expansion, keep matches
  1535.  * mode = WILD_NEXT:     use next match in multiple match, wrap to first
  1536.  * mode = WILD_PREV:     use previous match in multiple match, wrap to first
  1537.  * mode = WILD_ALL:     return all matches concatenated
  1538.  * mode = WILD_LONGEST:     return longest matched part
  1539.  *
  1540.  * options = WILD_LIST_NOTFOUND:    list entries without a match
  1541.  * options = WILD_HOME_REPLACE:     do home_replace() for buffer names
  1542.  * options = WILD_USE_NL:     Use 'n' for WILD_ALL
  1543.  * options = WILD_NO_BEEP:     Don't beep for multiple matches
  1544.  */
  1545.     char_u *
  1546. ExpandOne(str, orig, options, mode)
  1547.     char_u  *str;
  1548.     char_u  *orig;     /* original string which is expanded */
  1549.     int     options;
  1550.     int     mode;
  1551. {
  1552.     char_u *ss = NULL;
  1553.     static char_u **cmd_files = NULL; /* list of input files */
  1554.     static int findex;
  1555.     static char_u *orig_save = NULL; /* kept value of orig */
  1556.     int i;
  1557.     int non_suf_match; /* number without matching suffix */
  1558.     long_u len;
  1559.     char_u *p;
  1561. /*
  1562.  * first handle the case of using an old match
  1563.  */
  1564.     if (mode == WILD_NEXT || mode == WILD_PREV)
  1565.     {
  1566. if (cmd_numfiles > 0)
  1567. {
  1568.     if (mode == WILD_PREV)
  1569.     {
  1570. if (findex == -1)
  1571.     findex = cmd_numfiles;
  1572. --findex;
  1573.     }
  1574.     else    /* mode == WILD_NEXT */
  1575. ++findex;
  1577.     /*
  1578.      * When wrapping around, return the original string, set findex to
  1579.      * -1.
  1580.      */
  1581.     if (findex < 0)
  1582.     {
  1583. if (orig_save == NULL)
  1584.     findex = cmd_numfiles - 1;
  1585. else
  1586.     findex = -1;
  1587.     }
  1588.     if (findex >= cmd_numfiles)
  1589.     {
  1590. if (orig_save == NULL)
  1591.     findex = 0;
  1592. else
  1593.     findex = -1;
  1594.     }
  1595.     if (findex == -1)
  1596. return vim_strsave(orig_save);
  1597.     return vim_strsave(cmd_files[findex]);
  1598. }
  1599. else
  1600.     return NULL;
  1601.     }
  1603. /* free old names */
  1604.     if (cmd_numfiles != -1 && mode != WILD_ALL && mode != WILD_LONGEST)
  1605.     {
  1606. FreeWild(cmd_numfiles, cmd_files);
  1607. cmd_numfiles = -1;
  1608. vim_free(orig_save);
  1609. orig_save = NULL;
  1610.     }
  1611.     findex = 0;
  1613.     if (mode == WILD_FREE) /* only release file name */
  1614. return NULL;
  1616.     if (cmd_numfiles == -1)
  1617.     {
  1618. vim_free(orig_save);
  1619. orig_save = orig;
  1621. /*
  1622.  * Do the expansion.
  1623.  */
  1624. if (ExpandFromContext(str, &cmd_numfiles, &cmd_files, FALSE,
  1625.      options) == FAIL)
  1626.     /* error: do nothing */;
  1627. else if (cmd_numfiles == 0)
  1628. {
  1629.     if (!expand_interactively)
  1630. emsg2(e_nomatch2, str);
  1631. }
  1632. else
  1633. {
  1634.     /*
  1635.      * May change home directory back to "~"
  1636.      */
  1637.     if (options & WILD_HOME_REPLACE)
  1638. tilde_replace(str, cmd_numfiles, cmd_files);
  1640.     /*
  1641.      * Insert backslashes into a file name before a space, , %, # and
  1642.      * wildmatch characters, except '~'.
  1643.      */
  1644.     if (expand_interactively &&
  1645.     (expand_context == EXPAND_FILES ||
  1646.      expand_context == EXPAND_BUFFERS ||
  1647.      expand_context == EXPAND_DIRECTORIES))
  1648.     {
  1649. for (i = 0; i < cmd_numfiles; ++i)
  1650. {
  1651.     /* for ":set path=" we need to escape spaces twice */
  1652.     if (expand_set_path)
  1653.     {
  1654. p = vim_strsave_escaped(cmd_files[i], (char_u *)" ");
  1655. if (p != NULL)
  1656. {
  1657.     vim_free(cmd_files[i]);
  1658.     cmd_files[i] = p;
  1659. #if defined(BACKSLASH_IN_FILENAME) || defined(COLON_AS_PATHSEP)
  1660.     p = vim_strsave_escaped(cmd_files[i],
  1661.        (char_u *)" ");
  1662.     if (p != NULL)
  1663.     {
  1664. vim_free(cmd_files[i]);
  1665. cmd_files[i] = p;
  1666.     }
  1667. #endif
  1668. }
  1669.     }
  1670.     p = vim_strsave_escaped(cmd_files[i],
  1671. #ifdef BACKSLASH_IN_FILENAME
  1672.     (char_u *)" *?[{`$%#"
  1673. #else
  1674. # ifdef COLON_AS_PATHSEP
  1675.     (char_u *)" *?[{`$%#/"
  1676. # else
  1677.     (char_u *)" *?[{`$\%#"
  1678. # endif
  1679. #endif
  1680.     );
  1681.     if (p != NULL)
  1682.     {
  1683. vim_free(cmd_files[i]);
  1684. cmd_files[i] = p;
  1685.     }
  1686. }
  1687. expand_set_path = FALSE;
  1688.     }
  1690.     /*
  1691.      * Check for matching suffixes in file names.
  1692.      */
  1693.     if (mode != WILD_ALL && mode != WILD_LONGEST)
  1694.     {
  1695. if (cmd_numfiles)
  1696.     non_suf_match = cmd_numfiles;
  1697. else
  1698.     non_suf_match = 1;
  1699. if ((!expand_interactively
  1700.     || expand_context == EXPAND_FILES
  1701.     || expand_context == EXPAND_DIRECTORIES)
  1702. && cmd_numfiles > 1) /* more than one match; check suffix */
  1703. {
  1704.     /*
  1705.      * The files will have been sorted on matching suffix in
  1706.      * expand_wildcards, only need to check the first two.
  1707.      */
  1708.     non_suf_match = 0;
  1709.     for (i = 0; i < 2; ++i)
  1710. if (match_suffix(cmd_files[i]))
  1711.     ++non_suf_match;
  1712. }
  1713. if (non_suf_match != 1)
  1714. {
  1715.     /* Can we ever get here unless it's while expanding
  1716.      * interactively?  If not, we can get rid of this all
  1717.      * together. Don't really want to wait for this message
  1718.      * (and possibly have to hit return to continue!).
  1719.      */
  1720.     if (!expand_interactively)
  1721. emsg(e_toomany);
  1722.     else if (!(options & WILD_NO_BEEP))
  1723. beep_flush();
  1724. }
  1725. if (!(non_suf_match != 1 && mode == WILD_EXPAND_FREE))
  1726.     ss = vim_strsave(cmd_files[0]);
  1727.     }
  1728. }
  1729.     }
  1731.     /* Find longest common part */
  1732.     if (mode == WILD_LONGEST && cmd_numfiles > 0)
  1733.     {
  1734. for (len = 0; cmd_files[0][len]; ++len)
  1735. {
  1736.     for (i = 0; i < cmd_numfiles; ++i)
  1737.     {
  1738. #ifdef CASE_INSENSITIVE_FILENAME
  1739. if (expand_context == EXPAND_DIRECTORIES
  1740. || expand_context == EXPAND_FILES
  1741. || expand_context == EXPAND_BUFFERS)
  1742. {
  1743.     if (TO_LOWER(cmd_files[i][len]) !=
  1744.    TO_LOWER(cmd_files[0][len]))
  1745. break;
  1746. }
  1747. else
  1748. #endif
  1749.      if (cmd_files[i][len] != cmd_files[0][len])
  1750.     break;
  1751.     }
  1752.     if (i < cmd_numfiles)
  1753.     {
  1754. if (!(options & WILD_NO_BEEP))
  1755.     vim_beep();
  1756. break;
  1757.     }
  1758. }
  1759. ss = alloc((unsigned)len + 1);
  1760. if (ss)
  1761. {
  1762.     STRNCPY(ss, cmd_files[0], len);
  1763.     ss[len] = NUL;
  1764. }
  1765. findex = -1;     /* next p_wc gets first one */
  1766.     }
  1768.     /* Concatenate all matching names */
  1769.     if (mode == WILD_ALL && cmd_numfiles > 0)
  1770.     {
  1771. len = 0;
  1772. for (i = 0; i < cmd_numfiles; ++i)
  1773.     len += STRLEN(cmd_files[i]) + 1;
  1774. ss = lalloc(len, TRUE);
  1775. if (ss != NULL)
  1776. {
  1777.     *ss = NUL;
  1778.     for (i = 0; i < cmd_numfiles; ++i)
  1779.     {
  1780. STRCAT(ss, cmd_files[i]);
  1781. if (i != cmd_numfiles - 1)
  1782.     STRCAT(ss, (options & WILD_USE_NL) ? "n" : " ");
  1783.     }
  1784. }
  1785.     }
  1787.     if (mode == WILD_EXPAND_FREE || mode == WILD_ALL)
  1788.     {
  1789. FreeWild(cmd_numfiles, cmd_files);
  1790. cmd_numfiles = -1;
  1791.     }
  1793.     return ss;
  1794. }
  1796. /*
  1797.  * For each file name in files[num_files]:
  1798.  * If 'orig_pat' starts with "~/", replace the home directory with "~".
  1799.  */
  1800.     void
  1801. tilde_replace(orig_pat, num_files, files)
  1802.     char_u  *orig_pat;
  1803.     int     num_files;
  1804.     char_u  **files;
  1805. {
  1806.     int     i;
  1807.     char_u  *p;
  1809.     if (orig_pat[0] == '~' && vim_ispathsep(orig_pat[1]))
  1810.     {
  1811. for (i = 0; i < num_files; ++i)
  1812. {
  1813.     p = home_replace_save(NULL, files[i]);
  1814.     if (p != NULL)
  1815.     {
  1816. vim_free(files[i]);
  1817. files[i] = p;
  1818.     }
  1819. }
  1820.     }
  1821. }
  1823. /*
  1824.  * show all matches for completion on the command line
  1825.  */
  1826.     static int
  1827. showmatches()
  1828. {
  1829.     char_u *file_str;
  1830.     int num_files;
  1831.     char_u **files_found;
  1832.     int i, j, k;
  1833.     int maxlen;
  1834.     int lines;
  1835.     int columns;
  1836.     char_u *p;
  1837.     int lastlen;
  1838.     int attr;
  1840.     set_expand_context();
  1841.     if (expand_context == EXPAND_UNSUCCESSFUL)
  1842.     {
  1843. beep_flush();
  1844. return OK;  /* Something illegal on command line */
  1845.     }
  1846.     if (expand_context == EXPAND_NOTHING)
  1847.     {
  1848. /* Caller can use the character as a normal char instead */
  1849. return FAIL;
  1850.     }
  1851.     expand_interactively = TRUE;
  1853.     /* add star to file name, or convert to regexp if not expanding files! */
  1854.     file_str = addstar(expand_pattern,
  1855.       (int)(ccline.cmdbuff + ccline.cmdpos - expand_pattern));
  1856.     if (file_str == NULL)
  1857.     {
  1858. expand_interactively = FALSE;
  1859. return OK;
  1860.     }
  1862.     msg_didany = FALSE; /* lines_left will be set */
  1863.     msg_start(); /* prepare for paging */
  1864.     msg_putchar('n');
  1865.     out_flush();
  1866.     cmdline_row = msg_row;
  1867.     msg_didany = FALSE; /* lines_left will be set again */
  1868.     msg_start(); /* prepare for paging */
  1870.     /* find all files that match the description */
  1871.     if (ExpandFromContext(file_str, &num_files, &files_found, FALSE, 0) == FAIL)
  1872.     {
  1873. num_files = 0;
  1874. files_found = (char_u **)"";
  1875.     }
  1877.     /* find the length of the longest file name */
  1878.     maxlen = 0;
  1879.     for (i = 0; i < num_files; ++i)
  1880.     {
  1881. if (expand_context == EXPAND_FILES || expand_context == EXPAND_BUFFERS)
  1882. {
  1883.     home_replace(NULL, files_found[i], NameBuff, MAXPATHL, TRUE);
  1884.     j = vim_strsize(NameBuff);
  1885. }
  1886. else
  1887.     j = vim_strsize(files_found[i]);
  1888. if (j > maxlen)
  1889.     maxlen = j;
  1890.     }
  1892.     /* compute the number of columns and lines for the listing */
  1893.     maxlen += 2;    /* two spaces between file names */
  1894.     columns = ((int)Columns + 2) / maxlen;
  1895.     if (columns < 1)
  1896. columns = 1;
  1897.     lines = (num_files + columns - 1) / columns;
  1899.     attr = hl_attr(HLF_D); /* find out highlighting for directories */
  1901.     /* list the files line by line */
  1902.     for (i = 0; i < lines; ++i)
  1903.     {
  1904. lastlen = 999;
  1905. for (k = i; k < num_files; k += lines)
  1906. {
  1907.     for (j = maxlen - lastlen; --j >= 0; )
  1908. msg_putchar(' ');
  1909.     if (expand_context == EXPAND_FILES ||
  1910.      expand_context == EXPAND_BUFFERS)
  1911.     {
  1912. /* highlight directories */
  1913. j = (mch_isdir(files_found[k]));
  1914. home_replace(NULL, files_found[k], NameBuff, MAXPATHL, TRUE);
  1915. p = NameBuff;
  1916.     }
  1917.     else
  1918.     {
  1919. j = FALSE;
  1920. p = files_found[k];
  1921.     }
  1922.     lastlen = msg_outtrans_attr(p, j ? attr : 0);
  1923. }
  1924. msg_clr_eos();
  1925. msg_putchar('n');
  1926. out_flush();     /* show one line at a time */
  1927. if (got_int)
  1928. {
  1929.     got_int = FALSE;
  1930.     break;
  1931. }
  1932.     }
  1933.     vim_free(file_str);
  1934.     FreeWild(num_files, files_found);
  1936. /*
  1937.  * we redraw the command below the lines that we have just listed
  1938.  * This is a bit tricky, but it saves a lot of screen updating.
  1939.  */
  1940.     cmdline_row = msg_row; /* will put it back later */
  1942.     expand_interactively = FALSE;
  1943.     return OK;
  1944. }
  1946. /*
  1947.  * Prepare a string for expansion.
  1948.  * When expanding file names:  The string will be used with expand_wildcards().
  1949.  * Copy the file name into allocated memory and add a '*' at the end.
  1950.  * When expanding other names: The string will be used with regcomp().  Copy
  1951.  * the name into allocated memory and add ".*" at the end.
  1952.  */
  1953.     char_u *
  1954. addstar(fname, len)
  1955.     char_u  *fname;
  1956.     int     len;
  1957. {
  1958.     char_u  *retval;
  1959.     int     i, j;
  1960.     int     new_len;
  1961.     char_u  *tail;
  1963.     if (expand_interactively && expand_context != EXPAND_FILES &&
  1964.  expand_context != EXPAND_DIRECTORIES)
  1965.     {
  1966. /*
  1967.  * Matching will be done internally (on something other than files).
  1968.  * So we convert the file-matching-type wildcards into our kind for
  1969.  * use with vim_regcomp().  First work out how long it will be:
  1970.  */
  1972. /* for help tags the translation is done in find_help_tags() */
  1973. if (expand_context == EXPAND_HELP)
  1974.     retval = vim_strnsave(fname, len);
  1975. else
  1976. {
  1977.     new_len = len + 2; /* +2 for '^' at start, NUL at end */
  1978.     for (i = 0; i < len; i++)
  1979.     {
  1980. if (fname[i] == '*' || fname[i] == '~')
  1981.     new_len++; /* '*' needs to be replaced by ".*"
  1982.    '~' needs to be replaced by "~" */
  1984. /* Buffer names are like file names.  "." should be literal */
  1985. if (expand_context == EXPAND_BUFFERS && fname[i] == '.')
  1986.     new_len++; /* "." becomes "." */
  1987.     }
  1988.     retval = alloc(new_len);
  1989.     if (retval != NULL)
  1990.     {
  1991. retval[0] = '^';
  1992. j = 1;
  1993. for (i = 0; i < len; i++, j++)
  1994. {
  1995.     if (fname[i] == '\' && ++i == len) /* skip backslash */
  1996. break;
  1998.     switch (fname[i])
  1999.     {
  2000. case '*':   retval[j++] = '.';
  2001.     break;
  2002. case '~':   retval[j++] = '\';
  2003.     break;
  2004. case '?':   retval[j] = '.';
  2005.     continue;
  2006. case '.':   if (expand_context == EXPAND_BUFFERS)
  2007. retval[j++] = '\';
  2008.     break;
  2009.     }
  2010.     retval[j] = fname[i];
  2011. }
  2012. retval[j] = NUL;
  2013.     }
  2014. }
  2015.     }
  2016.     else
  2017.     {
  2018. retval = alloc(len + 4);
  2019. if (retval != NULL)
  2020. {
  2021.     STRNCPY(retval, fname, len);
  2022.     retval[len] = NUL;
  2023. #ifndef macintosh
  2024.     if (!expand_set_path)
  2025. backslash_halve(retval, TRUE); /* remove some backslashes */
  2026. #endif
  2027.     len = STRLEN(retval);
  2029.     /*
  2030.      * Don't add a star to ~, ~user, $var or `cmd`.
  2031.      * ~ would be at the start of the tail.
  2032.      * $ could be anywhere in the tail.
  2033.      * ` could be anywhere in the file name.
  2034.      */
  2035.     tail = gettail(retval);
  2036.     if (*tail != '~' && vim_strchr(tail, '$') == NULL
  2037.    && vim_strchr(retval, '`') == NULL)
  2038.     {
  2039. #ifdef MSDOS
  2040. /*
  2041.  * if there is no dot in the file name, add "*.*" instead of
  2042.  * "*".
  2043.  */
  2044. for (i = len - 1; i >= 0; --i)
  2045.     if (vim_strchr((char_u *)".\/:", retval[i]) != NULL)
  2046. break;
  2047. if (i < 0 || retval[i] != '.')
  2048. {
  2049.     retval[len++] = '*';
  2050.     retval[len++] = '.';
  2051. }
  2052. #endif
  2053. retval[len++] = '*';
  2054.     }
  2055.     retval[len] = NUL;
  2056. }
  2057.     }
  2058.     return retval;
  2059. }
  2061. /*
  2062.  * Must parse the command line so far to work out what context we are in.
  2063.  * Completion can then be done based on that context.
  2064.  * This routine sets two global variables:
  2065.  *  char_u *expand_pattern  The start of the pattern to be expanded within
  2066.  * the command line (ends at the cursor).
  2067.  *  int expand_context     The type of thing to expand.  Will be one of:
  2068.  *
  2069.  *  EXPAND_UNSUCCESSFUL     Used sometimes when there is something illegal on
  2070.  *     the command line, like an unknown command. Caller
  2071.  *     should beep.
  2072.  *  EXPAND_NOTHING     Unrecognised context for completion, use char like
  2073.  *     a normal char, rather than for completion. eg
  2074.  *     :s/^I/
  2075.  *  EXPAND_COMMANDS     Cursor is still touching the command, so complete
  2076.  *     it.
  2077.  *  EXPAND_BUFFERS     Complete file names for :buf and :sbuf commands.
  2078.  *  EXPAND_FILES     After command with XFILE set, or after setting
  2079.  *     with P_EXPAND set. eg :e ^I, :w>>^I
  2080.  *  EXPAND_DIRECTORIES     In some cases this is used instead of the latter
  2081.  *     when we know only directories are of interest.  eg
  2082.  *     :set dir=^I
  2083.  *  EXPAND_SETTINGS     Complete variable names.  eg :set d^I
  2084.  *  EXPAND_BOOL_SETTINGS    Complete boolean variables only,  eg :set no^I
  2085.  *  EXPAND_TAGS     Complete tags from the files in p_tags.  eg :ta a^I
  2086.  *  EXPAND_HELP     Complete tags from the file 'helpfile'/tags
  2087.  *  EXPAND_EVENTS     Complete event names
  2088.  *  EXPAND_SYNTAX     Complete :syntax command arguments
  2089.  *  EXPAND_HIGHLIGHT     Complete highlight (syntax) group names
  2090.  *  EXPAND_AUGROUP     Complete autocommand group names
  2091.  *  EXPAND_USER_VARS     Complete user defined variable names, eg :unlet a^I
  2092.  *
  2093.  * -- webb.
  2094.  */
  2095.     static void
  2096. set_expand_context()
  2097. {
  2098.     char_u *nextcomm;
  2099.     int old_char = NUL;
  2101.     if (ccline.cmdfirstc != ':') /* only expansion for ':' commands */
  2102.     {
  2103. expand_context = EXPAND_NOTHING;
  2104. return;
  2105.     }
  2107.     /*
  2108.      * Avoid a UMR warning from Purify, only save the character if it has been
  2109.      * written before.
  2110.      */
  2111.     if (ccline.cmdpos < ccline.cmdlen)
  2112. old_char = ccline.cmdbuff[ccline.cmdpos];
  2113.     ccline.cmdbuff[ccline.cmdpos] = NUL;
  2114.     nextcomm = ccline.cmdbuff;
  2115.     while (nextcomm != NULL)
  2116. nextcomm = set_one_cmd_context(nextcomm);
  2117.     ccline.cmdbuff[ccline.cmdpos] = old_char;
  2118. }
  2120. /*
  2121.  * Do the expansion based on the global variables expand_context and
  2122.  * expand_pattern -- webb.
  2123.  */
  2124.     static int
  2125. ExpandFromContext(pat, num_file, file, files_only, options)
  2126.     char_u  *pat;
  2127.     int     *num_file;
  2128.     char_u  ***file;
  2129.     int     files_only;
  2130.     int     options;
  2131. {
  2132.     vim_regexp *prog;
  2133.     int ret;
  2134.     int flags;
  2135.     flags = 0;
  2136.     if (!files_only)
  2137. flags |= EW_DIR;
  2138.     if (options & WILD_LIST_NOTFOUND)
  2139. flags |= EW_NOTFOUND;
  2141.     if (!expand_interactively || expand_context == EXPAND_FILES)
  2142.     {
  2143. /*
  2144.  * Expand file names.
  2145.  */
  2146. return expand_wildcards(1, &pat, num_file, file, flags|EW_FILE);
  2147.     }
  2148.     else if (expand_context == EXPAND_DIRECTORIES)
  2149.     {
  2150. /*
  2151.  * Expand directory names.
  2152.  */
  2153. int free_pat = FALSE;
  2154. int i;
  2156. /* for ":set path=" we need to remove backslashes for escaped space */
  2157. if (expand_set_path)
  2158. {
  2159.     free_pat = TRUE;
  2160.     pat = vim_strsave(pat);
  2161.     for (i = 0; pat[i]; ++i)
  2162. if (pat[i] == '\' && pat[i + 1] == '\' &&
  2163.       pat[i + 2] == '\' && pat[i + 3] == ' ')
  2164.     STRCPY(pat + i, pat + i + 3);
  2165. }
  2167. ret = expand_wildcards(1, &pat, num_file, file,
  2168.  (flags | EW_DIR) & ~EW_FILE);
  2169. if (free_pat)
  2170.     vim_free(pat);
  2171. return ret;
  2172.     }
  2174.     *file = (char_u **)"";
  2175.     *num_file = 0;
  2176.     if (expand_context == EXPAND_OLD_SETTING)
  2177. return ExpandOldSetting(num_file, file);
  2179.     if (expand_context == EXPAND_HELP)
  2180. return find_help_tags(pat, num_file, file);
  2182.     set_reg_ic(pat);     /* set reg_ic according to p_ic, p_scs and pat */
  2184.     if (expand_context == EXPAND_BUFFERS)
  2185. return ExpandBufnames(pat, num_file, file, options);
  2186.     else if (expand_context == EXPAND_TAGS)
  2187.     {
  2188. if (pat[0] == '^' && pat[1] == '/')
  2189.     return find_tags(pat + 2, num_file, file,
  2190. TAG_REGEXP | TAG_NAMES | TAG_VERBOSE, MAXCOL);
  2191. return find_tags(pat, num_file, file,
  2192.      TAG_REGEXP | TAG_NAMES | TAG_VERBOSE | TAG_NOIC, MAXCOL);
  2193.     }
  2195.     prog = vim_regcomp(pat, (int)p_magic);
  2196.     if (prog == NULL)
  2197. return FAIL;
  2199.     if (expand_context == EXPAND_COMMANDS)
  2200. ret = ExpandGeneric(prog, num_file, file, get_command_name);
  2201.     else if (expand_context == EXPAND_SETTINGS ||
  2202.        expand_context == EXPAND_BOOL_SETTINGS)
  2203. ret = ExpandSettings(prog, num_file, file);
  2204. #ifdef WANT_EVAL
  2205.     else if (expand_context == EXPAND_USER_VARS)
  2206. ret = ExpandGeneric(prog, num_file, file, get_user_var_name);
  2207. #endif
  2208. #ifdef USE_GUI
  2209.     else if (expand_context == EXPAND_MENUS)
  2210. ret = ExpandGeneric(prog, num_file, file, get_menu_name);
  2211. #endif
  2212. #ifdef SYNTAX_HL
  2213.     else if (expand_context == EXPAND_SYNTAX)
  2214.     {
  2215. reg_ic = TRUE;
  2216. ret = ExpandGeneric(prog, num_file, file, get_syntax_name);
  2217.     }
  2218. #endif
  2219.     else if (expand_context == EXPAND_HIGHLIGHT)
  2220.     {
  2221. reg_ic = TRUE;
  2222. ret = ExpandGeneric(prog, num_file, file, get_highlight_name);
  2223.     }
  2224. #ifdef AUTOCMD
  2225.     else if (expand_context == EXPAND_EVENTS)
  2226.     {
  2227. reg_ic = TRUE;
  2228. ret = ExpandGeneric(prog, num_file, file, get_event_name);
  2229.     }
  2230.     else if (expand_context == EXPAND_AUGROUP)
  2231.     {
  2232. reg_ic = TRUE;
  2233. ret = ExpandGeneric(prog, num_file, file, get_augroup_name);
  2234.     }
  2235. #endif
  2236.     else
  2237. ret = FAIL;
  2239.     vim_free(prog);
  2240.     return ret;
  2241. }
  2243. /*
  2244.  * Expand a list of names.
  2245.  *
  2246.  * Generic function for command line completion.  It calls a function to
  2247.  * obtain strings, one by one. The strings are matched against a regexp
  2248.  * program.  Matching strings are copied into an array, which is returned.
  2249.  *
  2250.  * Returns OK when no problems encountered, FAIL for error (out of memory).
  2251.  */
  2252.     int
  2253. ExpandGeneric(prog, num_file, file, func)
  2254.     vim_regexp *prog;
  2255.     int *num_file;
  2256.     char_u ***file;
  2257.     char_u *((*func)__ARGS((int))); /* returns a string from the list */
  2258. {
  2259.     int i;
  2260.     int count = 0;
  2261.     int loop;
  2262.     char_u  *str;
  2264.     /* do this loop twice:
  2265.      * loop == 0: count the number of matching names
  2266.      * loop == 1: copy the matching names into allocated memory
  2267.      */
  2268.     for (loop = 0; loop <= 1; ++loop)
  2269.     {
  2270. for (i = 0; ; ++i)
  2271. {
  2272.     str = (*func)(i);
  2273.     if (str == NULL)     /* end of list */
  2274. break;
  2275.     if (*str == NUL)     /* skip empty strings */
  2276. continue;
  2278.     if (vim_regexec(prog, str, TRUE))
  2279.     {
  2280. if (loop)
  2281.     (*file)[count] = vim_strsave_escaped(str,
  2282.   (char_u *)" t\.");
  2283. ++count;
  2284.     }
  2285. }
  2286. if (loop == 0)
  2287. {
  2288.     if (count == 0)
  2289. return OK;
  2290.     *num_file = count;
  2291.     *file = (char_u **)alloc((unsigned)(count * sizeof(char_u *)));
  2292.     if (*file == NULL)
  2293.     {
  2294. *file = (char_u **)"";
  2295. return FAIL;
  2296.     }
  2297.     count = 0;
  2298. }
  2299.     }
  2300.     return OK;
  2301. }
  2303. /*********************************
  2304.  *  Command line history stuff  *
  2305.  *********************************/
  2307. /*
  2308.  * Translate a history character to the associated type number.
  2309.  */
  2310.     static int
  2311. hist_char2type(c)
  2312.     int     c;
  2313. {
  2314.     if (c == ':')
  2315. return HIST_CMD;
  2316.     if (c == '=')
  2317. return HIST_EXPR;
  2318.     if (c == '@')
  2319. return HIST_INPUT;
  2320.     return HIST_SEARCH;     /* must be '?' or '/' */
  2321. }
  2323. /*
  2324.  * init_history() - Initialize the command line history.
  2325.  * Also used to re-allocate the history when the size changes.
  2326.  */
  2327.     static void
  2328. init_history()
  2329. {
  2330.     int     newlen;     /* new length of history table */
  2331.     char_u  **temp;
  2332.     int     i;
  2333.     int     j;
  2334.     int     type;
  2336.     /*
  2337.      * If size of history table changed, reallocate it
  2338.      */
  2339.     newlen = (int)p_hi;
  2340.     if (newlen != hislen) /* history length changed */
  2341.     {
  2342. for (type = 0; type < HIST_COUNT; ++type)   /* adjust the tables */
  2343. {
  2344.     if (newlen)
  2345.     {
  2346. temp = (char_u **)lalloc((long_u)(newlen * sizeof(char_u *)),
  2347. TRUE);
  2348. if (temp == NULL)   /* out of memory! */
  2349. {
  2350.     if (type == 0)  /* first one: just keep the old length */
  2351.     {
  2352. newlen = hislen;
  2353. break;
  2354.     }
  2355.     /* Already changed one table, now we can only have zero
  2356.      * length for all tables. */
  2357.     newlen = 0;
  2358.     type = -1;
  2359.     continue;
  2360. }
  2361.     }
  2362.     else
  2363. temp = NULL;
  2364.     if (newlen == 0 || temp != NULL)
  2365.     {
  2366. if (hisidx[type] < 0) /* there are no entries yet */
  2367. {
  2368.     for (i = 0; i < newlen; ++i)
  2369. temp[i] = NULL;
  2370. }
  2371. else if (newlen > hislen) /* array becomes bigger */
  2372. {
  2373.     for (i = 0; i <= hisidx[type]; ++i)
  2374. temp[i] = history[type][i];
  2375.     j = i;
  2376.     for ( ; i <= newlen - (hislen - hisidx[type]); ++i)
  2377. temp[i] = NULL;
  2378.     for ( ; j < hislen; ++i, ++j)
  2379. temp[i] = history[type][j];
  2380. }
  2381. else /* array becomes smaller or 0 */
  2382. {
  2383.     j = hisidx[type];
  2384.     for (i = newlen - 1; ; --i)
  2385.     {
  2386. if (i >= 0) /* copy newest entries */
  2387.     temp[i] = history[type][j];
  2388. else /* remove older entries */
  2389.     vim_free(history[type][j]);
  2390. if (--j < 0)
  2391.     j = hislen - 1;
  2392. if (j == hisidx[type])
  2393.     break;
  2394.     }
  2395.     hisidx[type] = newlen - 1;
  2396. }
  2397. vim_free(history[type]);
  2398. history[type] = temp;
  2399.     }
  2400. }
  2401. hislen = newlen;
  2402.     }
  2403. }
  2405. /*
  2406.  * Check if command line 'str' is already in history.
  2407.  * If 'move_to_front' is TRUE, matching entry is moved to end of history.
  2408.  */
  2409.     static int
  2410. in_history(type, str, move_to_front)
  2411.     int     type;
  2412.     char_u  *str;
  2413.     int     move_to_front; /* Move the entry to the front if it exists */
  2414. {
  2415.     int     i;
  2416.     int     last_i = -1;
  2418.     if (hisidx[type] < 0)
  2419. return FALSE;
  2420.     i = hisidx[type];
  2421.     do
  2422.     {
  2423. if (history[type][i] == NULL)
  2424.     return FALSE;
  2425. if (STRCMP(str, history[type][i]) == 0)
  2426. {
  2427.     if (!move_to_front)
  2428. return TRUE;
  2429.     last_i = i;
  2430.     break;
  2431. }
  2432. if (--i < 0)
  2433.     i = hislen - 1;
  2434.     } while (i != hisidx[type]);
  2436.     if (last_i >= 0)
  2437.     {
  2438. str = history[type][i];
  2439. while (i != hisidx[type])
  2440. {
  2441.     if (++i >= hislen)
  2442. i = 0;
  2443.     history[type][last_i] = history[type][i];
  2444.     last_i = i;
  2445. }
  2446. history[type][i] = str;
  2447. return TRUE;
  2448.     }
  2449.     return FALSE;
  2450. }
  2452. /*
  2453.  * Add the given string to the given history.  If the string is already in the
  2454.  * history then it is moved to the front.  "histype" may be HIST_CMD,
  2455.  * HIST_SEARCH, HIST_EXPR or HIST_INPUT.
  2456.  */
  2457.     void
  2458. add_to_history(histype, new_entry)
  2459.     int histype;
  2460.     char_u *new_entry;
  2461. {
  2462.     static int last_maptick = -1; /* last seen maptick */
  2464.     if (hislen == 0) /* no history */
  2465. return;
  2467.     /*
  2468.      * Searches inside the same mapping overwrite each other, so that only
  2469.      * the last line is kept.  Be careful not to remove a line that was moved
  2470.      * down, only lines that were added.
  2471.      */
  2472.     if (histype == HIST_SEARCH)
  2473.     {
  2474. if (maptick == last_maptick)
  2475. {
  2476.     /* Current line is from the same mapping, remove it */
  2477.     vim_free(history[HIST_SEARCH][hisidx[HIST_SEARCH]]);
  2478.     history[HIST_SEARCH][hisidx[HIST_SEARCH]] = NULL;
  2479.     if (--hisidx[HIST_SEARCH] < 0)
  2480. hisidx[HIST_SEARCH] = hislen - 1;
  2481. }
  2482. last_maptick = -1;
  2483.     }
  2484.     if (!in_history(histype, new_entry, TRUE))
  2485.     {
  2486. if (++hisidx[histype] == hislen)
  2487.     hisidx[histype] = 0;
  2488. vim_free(history[histype][hisidx[histype]]);
  2489. history[histype][hisidx[histype]] = vim_strsave(new_entry);
  2490. if (histype == HIST_SEARCH)
  2491.     last_maptick = maptick;
  2492.     }
  2493. }
  2495. #ifdef VIMINFO
  2496. static char_u **viminfo_history[HIST_COUNT] = {NULL, NULL, NULL, NULL};
  2497. static int viminfo_hisidx[HIST_COUNT] = {0, 0, 0, 0};
  2498. static int viminfo_hislen[HIST_COUNT] = {0, 0, 0, 0};
  2499. static int viminfo_add_at_front = FALSE;
  2501. static int hist_type2char __ARGS((int type, int use_question));
  2503. /*
  2504.  * Translate a history type number to the associated character.
  2505.  */
  2506.     static int
  2507. hist_type2char(type, use_question)
  2508.     int     type;
  2509.     int     use_question;     /* use '?' instead of '/' */
  2510. {
  2511.     if (type == HIST_CMD)
  2512. return ':';
  2513.     if (type == HIST_SEARCH)
  2514.     {
  2515. if (use_question)
  2516.     return '?';
  2517. else
  2518.     return '/';
  2519.     }
  2520.     if (type == HIST_EXPR)
  2521. return '=';
  2522.     return '@';
  2523. }
  2525. /*
  2526.  * Prepare for reading the history from the viminfo file.
  2527.  * This allocates history arrays to store the read history lines.
  2528.  */
  2529.     void
  2530. prepare_viminfo_history(asklen)
  2531.     int     asklen;
  2532. {
  2533.     int     i;
  2534.     int     num;
  2535.     int     type;
  2536.     int     len;
  2538.     init_history();
  2539.     viminfo_add_at_front = (asklen != 0);
  2540.     if (asklen > hislen)
  2541. asklen = hislen;
  2543.     for (type = 0; type < HIST_COUNT; ++type)
  2544.     {
  2545. /*
  2546.  * Count the number of empty spaces in the history list.  If there are
  2547.  * more spaces available than we request, then fill them up.
  2548.  */
  2549. for (i = 0, num = 0; i < hislen; i++)
  2550.     if (history[type][i] == NULL)
  2551. num++;
  2552. len = asklen;
  2553. if (num > len)
  2554.     len = num;
  2555. if (len <= 0)
  2556.     viminfo_history[type] = NULL;
  2557. else
  2558.     viminfo_history[type] =
  2559.    (char_u **)lalloc((long_u)(len * sizeof(char_u *)), FALSE);
  2560. if (viminfo_history[type] == NULL)
  2561.     len = 0;
  2562. viminfo_hislen[type] = len;
  2563. viminfo_hisidx[type] = 0;
  2564.     }
  2565. }
  2567. /*
  2568.  * Accept a line from the viminfo, store it in the history array when it's
  2569.  * new.
  2570.  */
  2571.     int
  2572. read_viminfo_history(line, fp)
  2573.     char_u  *line;
  2574.     FILE    *fp;
  2575. {
  2576.     int     type;
  2578.     type = hist_char2type(line[0]);
  2579.     if (viminfo_hisidx[type] < viminfo_hislen[type])
  2580.     {
  2581. viminfo_readstring(line);
  2582. if (!in_history(type, line + 1, viminfo_add_at_front))
  2583.     viminfo_history[type][viminfo_hisidx[type]++] =
  2584. vim_strsave(line + 1);
  2585.     }
  2586.     return vim_fgets(line, LSIZE, fp);
  2587. }
  2589.     void
  2590. finish_viminfo_history()
  2591. {
  2592.     int idx;
  2593.     int i;
  2594.     int type;
  2596.     for (type = 0; type < HIST_COUNT; ++type)
  2597.     {
  2598. if (history[type] == NULL)
  2599.     return;
  2600. idx = hisidx[type] + viminfo_hisidx[type];
  2601. if (idx >= hislen)
  2602.     idx -= hislen;
  2603. else if (idx < 0)
  2604.     idx = hislen - 1;
  2605. if (viminfo_add_at_front)
  2606.     hisidx[type] = idx;
  2607. else
  2608. {
  2609.     if (hisidx[type] == -1)
  2610. hisidx[type] = hislen - 1;
  2611.     do
  2612.     {
  2613. if (history[type][idx] != NULL)
  2614.     break;
  2615. if (++idx == hislen)
  2616.     idx = 0;
  2617.     } while (idx != hisidx[type]);
  2618.     if (idx != hisidx[type] && --idx < 0)
  2619. idx = hislen - 1;
  2620. }
  2621. for (i = 0; i < viminfo_hisidx[type]; i++)
  2622. {
  2623.     vim_free(history[type][idx]);
  2624.     history[type][idx] = viminfo_history[type][i];
  2625.     if (--idx < 0)
  2626. idx = hislen - 1;
  2627. }
  2628. vim_free(viminfo_history[type]);
  2629. viminfo_history[type] = NULL;
  2630.     }
  2631. }
  2633.     void
  2634. write_viminfo_history(fp)
  2635.     FILE    *fp;
  2636. {
  2637.     int     i;
  2638.     int     type;
  2639.     int     num_saved;
  2641.     init_history();
  2642.     if (hislen == 0)
  2643. return;
  2644.     for (type = 0; type < HIST_COUNT; ++type)
  2645.     {
  2646. num_saved = get_viminfo_parameter(hist_type2char(type, FALSE));
  2647. if (num_saved == 0)
  2648.     continue;
  2649. if (num_saved < 0)  /* Use default */
  2650.     num_saved = hislen;
  2651. fprintf(fp, "n# %s History (newest to oldest):n",
  2652.     type == HIST_CMD ? "Command Line" :
  2653.     type == HIST_SEARCH ? "Search String" :
  2654.     type == HIST_EXPR ?  "Expression" :
  2655. "Input Line");
  2656. if (num_saved > hislen)
  2657.     num_saved = hislen;
  2658. i = hisidx[type];
  2659. if (i >= 0)
  2660.     while (num_saved--)
  2661.     {
  2662. if (history[type][i] != NULL)
  2663. {
  2664.     putc(hist_type2char(type, TRUE), fp);
  2665.     viminfo_writestring(fp, history[type][i]);
  2666. }
  2667. if (--i < 0)
  2668.     i = hislen - 1;
  2669.     }
  2670.     }
  2671. }
  2672. #endif /* VIMINFO */
  2674. #if defined(FKMAP) || defined(PROTO)
  2675. /*
  2676.  * Write a character at the current cursor+offset position.
  2677.  * It is directly written into the command buffer block.
  2678.  */
  2679.     void
  2680. cmd_pchar(c, offset)
  2681.     int     c, offset;
  2682. {
  2683.     if (ccline.cmdpos + offset >= ccline.cmdlen || ccline.cmdpos + offset < 0)
  2684.     {
  2685. EMSG("cmd_pchar beyond the command length");
  2686. return;
  2687.     }
  2688.     ccline.cmdbuff[ccline.cmdpos + offset] = (char_u)c;
  2689. }
  2691.     int
  2692. cmd_gchar(offset)
  2693.     int     offset;
  2694. {
  2695.     if (ccline.cmdpos + offset >= ccline.cmdlen || ccline.cmdpos + offset < 0)
  2696.     {
  2697. /*  EMSG("cmd_gchar beyond the command length"); */
  2698. return NUL;
  2699.     }
  2700.     return (int)ccline.cmdbuff[ccline.cmdpos + offset];
  2701. }
  2702. #endif