/* vi:set ts=8 sts=4 sw=4:
*
* VIM - Vi IMproved by Bram Moolenaar
*
* Do ":help uganda" in Vim to read copying and usage conditions.
* Do ":help credits" in Vim to see a list of people who contributed.
* See README.txt for an overview of the Vim source code.
*/
/*
* ex_getln.c: Functions for entering and editing an Ex command line.
*/
#include "vim.h"
/*
* Variables shared between getcmdline(), redrawcmdline() and others.
* These need to be saved when using CTRL-R |, that's why they are in a
* structure.
*/
struct cmdline_info
{
char_u *cmdbuff; /* pointer to command line buffer */
int cmdbufflen; /* length of cmdbuff */
int cmdlen; /* number of chars in command line */
int cmdpos; /* current cursor position */
int cmdspos; /* cursor column on screen */
int cmdfirstc; /* ':', '/', '?', '=' or NUL */
int cmdindent; /* number of spaces before cmdline */
char_u *cmdprompt; /* message in front of cmdline */
int cmdattr; /* attributes for prompt */
int overstrike; /* Typing mode on the command line. Shared by
getcmdline() and put_on_cmdline(). */
int xp_context; /* type of expansion */
# ifdef FEAT_EVAL
char_u *xp_arg; /* user-defined expansion arg */
int input_fn; /* when TRUE Invoked for input() function */
# endif
};
static struct cmdline_info ccline; /* current cmdline_info */
static int cmd_showtail; /* Only show path tail in lists ? */
#ifdef FEAT_EVAL
static int new_cmdpos; /* position set by set_cmdline_pos() */
#endif
#ifdef FEAT_CMDHIST
typedef struct hist_entry
{
int hisnum; /* identifying number */
char_u *hisstr; /* actual entry, separator char after the NUL */
} histentry_T;
static histentry_T *(history[HIST_COUNT]) = {NULL, NULL, NULL, NULL, NULL};
static int hisidx[HIST_COUNT] = {-1, -1, -1, -1, -1}; /* lastused entry */
static int hisnum[HIST_COUNT] = {0, 0, 0, 0, 0};
/* identifying (unique) number of newest history entry */
static int hislen = 0; /* actual length of history tables */
static int hist_char2type __ARGS((int c));
static int in_history __ARGS((int, char_u *, int));
# ifdef FEAT_EVAL
static int calc_hist_idx __ARGS((int histype, int num));
# endif
#endif
#ifdef FEAT_RIGHTLEFT
static int cmd_hkmap = 0; /* Hebrew mapping during command line */
#endif
#ifdef FEAT_FKMAP
static int cmd_fkmap = 0; /* Farsi mapping during command line */
#endif
static int cmdline_charsize __ARGS((int idx));
static void set_cmdspos __ARGS((void));
static void set_cmdspos_cursor __ARGS((void));
#ifdef FEAT_MBYTE
static void correct_cmdspos __ARGS((int idx, int cells));
#endif
static void alloc_cmdbuff __ARGS((int len));
static int realloc_cmdbuff __ARGS((int len));
static void draw_cmdline __ARGS((int start, int len));
static void save_cmdline __ARGS((struct cmdline_info *ccp));
static void restore_cmdline __ARGS((struct cmdline_info *ccp));
static int cmdline_paste __ARGS((int regname, int literally, int remcr));
#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
static void redrawcmd_preedit __ARGS((void));
#endif
#ifdef FEAT_WILDMENU
static void cmdline_del __ARGS((int from));
#endif
static void redrawcmdprompt __ARGS((void));
static void cursorcmd __ARGS((void));
static int ccheck_abbr __ARGS((int));
static int nextwild __ARGS((expand_T *xp, int type, int options));
static void escape_fname __ARGS((char_u **pp));
static int showmatches __ARGS((expand_T *xp, int wildmenu));
static void set_expand_context __ARGS((expand_T *xp));
static int ExpandFromContext __ARGS((expand_T *xp, char_u *, int *, char_u ***, int));
static int expand_showtail __ARGS((expand_T *xp));
#ifdef FEAT_CMDL_COMPL
static int expand_shellcmd __ARGS((char_u *filepat, int *num_file, char_u ***file, int flagsarg));
static int ExpandRTDir __ARGS((char_u *pat, int *num_file, char_u ***file, char *dirname));
# if defined(FEAT_USR_CMDS) && defined(FEAT_EVAL)
static int ExpandUserDefined __ARGS((expand_T *xp, regmatch_T *regmatch, int *num_file, char_u ***file));
static int ExpandUserList __ARGS((expand_T *xp, int *num_file, char_u ***file));
# endif
#endif
#ifdef FEAT_CMDWIN
static int ex_window __ARGS((void));
#endif
/*
* getcmdline() - accept a command line starting with firstc.
*
* firstc == ':' get ":" command line.
* firstc == '/' or '?' get search pattern
* firstc == '=' get expression
* firstc == '@' get text for input() function
* firstc == '>' get text for debug mode
* firstc == NUL get text for :insert command
* firstc == -1 like NUL, and break on CTRL-C
*
* The line is collected in ccline.cmdbuff, which is reallocated to fit the
* command line.
*
* Careful: getcmdline() can be called recursively!
*
* Return pointer to allocated string if there is a commandline, NULL
* otherwise.
*/
/*ARGSUSED*/
char_u *
getcmdline(firstc, count, indent)
int firstc;
long count; /* only used for incremental search */
int indent; /* indent for inside conditionals */
{
int c;
int i;
int j;
int gotesc = FALSE; /* TRUE when <ESC> just typed */
int do_abbr; /* when TRUE check for abbr. */
#ifdef FEAT_CMDHIST
char_u *lookfor = NULL; /* string to match */
int hiscnt; /* current history line in use */
int histype; /* history type to be used */
#endif
#ifdef FEAT_SEARCH_EXTRA
pos_T old_cursor;
colnr_T old_curswant;
colnr_T old_leftcol;
linenr_T old_topline;
# ifdef FEAT_DIFF
int old_topfill;
# endif
linenr_T old_botline;
int did_incsearch = FALSE;
int incsearch_postponed = FALSE;
#endif
int did_wild_list = FALSE; /* did wild_list() recently */
int wim_index = 0; /* index in wim_flags[] */
int res;
int save_msg_scroll = msg_scroll;
int save_State = State; /* remember State when called */
int some_key_typed = FALSE; /* one of the keys was typed */
#ifdef FEAT_MOUSE
/* mouse drag and release events are ignored, unless they are
* preceded with a mouse down event */
int ignore_drag_release = TRUE;
#endif
#ifdef FEAT_EVAL
int break_ctrl_c = FALSE;
#endif
expand_T xpc;
long *b_im_ptr = NULL;
#if defined(FEAT_WILDMENU) || defined(FEAT_EVAL) || defined(FEAT_SEARCH_EXTRA)
/* Everything that may work recursively should save and restore the
* current command line in save_ccline. That includes update_screen(), a
* custom status line may invoke ":normal". */
struct cmdline_info save_ccline;
#endif
#ifdef FEAT_SNIFF
want_sniff_request = 0;
#endif
#ifdef FEAT_EVAL
if (firstc == -1)
{
firstc = NUL;
break_ctrl_c = TRUE;
}
#endif
#ifdef FEAT_RIGHTLEFT
/* start without Hebrew mapping for a command line */
if (firstc == ':' || firstc == '=' || firstc == '>')
cmd_hkmap = 0;
#endif
ccline.overstrike = FALSE; /* always start in insert mode */
#ifdef FEAT_SEARCH_EXTRA
old_cursor = curwin->w_cursor; /* needs to be restored later */
old_curswant = curwin->w_curswant;
old_leftcol = curwin->w_leftcol;
old_topline = curwin->w_topline;
# ifdef FEAT_DIFF
old_topfill = curwin->w_topfill;
# endif
old_botline = curwin->w_botline;
#endif
/*
* set some variables for redrawcmd()
*/
ccline.cmdfirstc = (firstc == '@' ? 0 : firstc);
ccline.cmdindent = (firstc > 0 ? indent : 0);
/* alloc initial ccline.cmdbuff */
alloc_cmdbuff(exmode_active ? 250 : indent + 1);
if (ccline.cmdbuff == NULL)
return NULL; /* out of memory */
ccline.cmdlen = ccline.cmdpos = 0;
ccline.cmdbuff[0] = NUL;
/* autoindent for :insert and :append */
if (firstc <= 0)
{
copy_spaces(ccline.cmdbuff, indent);
ccline.cmdbuff[indent] = NUL;
ccline.cmdpos = indent;
ccline.cmdspos = indent;
ccline.cmdlen = indent;
}
ExpandInit(&xpc);
#ifdef FEAT_RIGHTLEFT
if (curwin->w_p_rl && *curwin->w_p_rlc == 's'
&& (firstc == '/' || firstc == '?'))
cmdmsg_rl = TRUE;
else
cmdmsg_rl = FALSE;
#endif
redir_off = TRUE; /* don't redirect the typed command */
if (!cmd_silent)
{
i = msg_scrolled;
msg_scrolled = 0; /* avoid wait_return message */
gotocmdline(TRUE);
msg_scrolled += i;
redrawcmdprompt(); /* draw prompt or indent */
set_cmdspos();
}
xpc.xp_context = EXPAND_NOTHING;
xpc.xp_backslash = XP_BS_NONE;
#ifndef BACKSLASH_IN_FILENAME
xpc.xp_shell = FALSE;
#endif
#if defined(FEAT_EVAL)
if (ccline.input_fn)
{
xpc.xp_context = ccline.xp_context;
xpc.xp_pattern = ccline.cmdbuff;
xpc.xp_arg = ccline.xp_arg;
}
#endif
/*
* Avoid scrolling when called by a recursive do_cmdline(), e.g. when
* doing ":@0" when register 0 doesn't contain a CR.
*/
msg_scroll = FALSE;
State = CMDLINE;
if (firstc == '/' || firstc == '?' || firstc == '@')
{
/* Use ":lmap" mappings for search pattern and input(). */
if (curbuf->b_p_imsearch == B_IMODE_USE_INSERT)
b_im_ptr = &curbuf->b_p_iminsert;
else
b_im_ptr = &curbuf->b_p_imsearch;
if (*b_im_ptr == B_IMODE_LMAP)
State |= LANGMAP;
#ifdef USE_IM_CONTROL
im_set_active(*b_im_ptr == B_IMODE_IM);
#endif
}
#ifdef USE_IM_CONTROL
else if (p_imcmdline)
im_set_active(TRUE);
#endif
#ifdef FEAT_MOUSE
setmouse();
#endif
#ifdef CURSOR_SHAPE
ui_cursor_shape(); /* may show different cursor shape */
#endif
/* When inside an autocommand for writing "exiting" may be set and
* terminal mode set to cooked. Need to set raw mode here then. */
settmode(TMODE_RAW);
#ifdef FEAT_CMDHIST
init_history();
hiscnt = hislen; /* set hiscnt to impossible history value */
histype = hist_char2type(firstc);
#endif
#ifdef FEAT_DIGRAPHS
do_digraph(-1); /* init digraph typahead */
#endif
/*
* Collect the command string, handling editing keys.
*/
for (;;)
{
redir_off = TRUE; /* Don't redirect the typed command.
Repeated, because a ":redir" inside
completion may switch it on. */
#ifdef USE_ON_FLY_SCROLL
dont_scroll = FALSE; /* allow scrolling here */
#endif
quit_more = FALSE; /* reset after CTRL-D which had a more-prompt */
cursorcmd(); /* set the cursor on the right spot */
c = safe_vgetc();
if (KeyTyped)
{
some_key_typed = TRUE;
#ifdef FEAT_RIGHTLEFT
if (cmd_hkmap)
c = hkmap(c);
# ifdef FEAT_FKMAP
if (cmd_fkmap)
c = cmdl_fkmap(c);
# endif
if (cmdmsg_rl && !KeyStuffed)
{
/* Invert horizontal movements and operations. Only when
* typed by the user directly, not when the result of a
* mapping. */
switch (c)
{
case K_RIGHT: c = K_LEFT; break;
case K_S_RIGHT: c = K_S_LEFT; break;
case K_C_RIGHT: c = K_C_LEFT; break;
case K_LEFT: c = K_RIGHT; break;
case K_S_LEFT: c = K_S_RIGHT; break;
case K_C_LEFT: c = K_C_RIGHT; break;
}
}
#endif
}
/*
* Ignore got_int when CTRL-C was typed here.
* Don't ignore it in :global, we really need to break then, e.g., for
* ":g/pat/normal /pat" (without the <CR>).
* Don't ignore it for the input() function.
*/
if ((c == Ctrl_C
#ifdef UNIX
|| c == intr_char
#endif
)
#if defined(FEAT_EVAL) || defined(FEAT_CRYPT)
&& firstc != '@'
#endif
#ifdef FEAT_EVAL
&& !break_ctrl_c
#endif
&& !global_busy)
got_int = FALSE;
#ifdef FEAT_CMDHIST
/* free old command line when finished moving around in the history
* list */
if (lookfor != NULL
&& c != K_S_DOWN && c != K_S_UP
&& c != K_DOWN && c != K_UP
&& c != K_PAGEDOWN && c != K_PAGEUP
&& c != K_KPAGEDOWN && c != K_KPAGEUP
&& c != K_LEFT && c != K_RIGHT
&& (xpc.xp_numfiles > 0 || (c != Ctrl_P && c != Ctrl_N)))
{
vim_free(lookfor);
lookfor = NULL;
}
#endif
/*
* <S-Tab> works like CTRL-P (unless 'wc' is <S-Tab>).
*/
if (c != p_wc && c == K_S_TAB && xpc.xp_numfiles != -1)
c = Ctrl_P;
#ifdef FEAT_WILDMENU
/* Special translations for 'wildmenu' */
if (did_wild_list && p_wmnu)
{
if (c == K_LEFT)
c = Ctrl_P;
else if (c == K_RIGHT)
c = Ctrl_N;
}
/* Hitting CR after "emenu Name.": complete submenu */
if (xpc.xp_context == EXPAND_MENUNAMES && p_wmnu
&& ccline.cmdpos > 1
&& ccline.cmdbuff[ccline.cmdpos - 1] == '.'
&& ccline.cmdbuff[ccline.cmdpos - 2] != '\\'
&& (c == '\n' || c == '\r' || c == K_KENTER))
c = K_DOWN;
#endif
/* free expanded names when finished walking through matches */
if (xpc.xp_numfiles != -1
&& !(c == p_wc && KeyTyped) && c != p_wcm
&& c != Ctrl_N && c != Ctrl_P && c != Ctrl_A
&& c != Ctrl_L)
{
(void)ExpandOne(&xpc, NULL, NULL, 0, WILD_FREE);
did_wild_list = FALSE;
#ifdef FEAT_WILDMENU
if (!p_wmnu || (c != K_UP && c != K_DOWN))
#endif
xpc.xp_context = EXPAND_NOTHING;
wim_index = 0;
#ifdef FEAT_WILDMENU
if (p_wmnu && wild_menu_showing != 0)
{
int skt = KeyTyped;
int old_RedrawingDisabled = RedrawingDisabled;
if (ccline.input_fn)
RedrawingDisabled = 0;
if (wild_menu_showing == WM_SCROLLED)
{
/* Entered command line, move it up */
cmdline_row--;
redrawcmd();
}
else if (save_p_ls != -1)
{
/* restore 'laststatus' and 'winminheight' */
p_ls = save_p_ls;
p_wmh = save_p_wmh;
last_status(FALSE);
save_cmdline(&save_ccline);
update_screen(VALID); /* redraw the screen NOW */
restore_cmdline(&save_ccline);
redrawcmd();
save_p_ls = -1;
}
else
{
# ifdef FEAT_VERTSPLIT
win_redraw_last_status(topframe);
# else
lastwin->w_redr_status = TRUE;
# endif
redraw_statuslines();
}
KeyTyped = skt;
wild_menu_showing = 0;
if (ccline.input_fn)
RedrawingDisabled = old_RedrawingDisabled;
}
#endif
}
#ifdef FEAT_WILDMENU
/* Special translations for 'wildmenu' */
if (xpc.xp_context == EXPAND_MENUNAMES && p_wmnu)
{
/* Hitting <Down> after "emenu Name.": complete submenu */
if (ccline.cmdbuff[ccline.cmdpos - 1] == '.' && c == K_DOWN)
c = p_wc;
else if (c == K_UP)
{
/* Hitting <Up>: Remove one submenu name in front of the
* cursor */
int found = FALSE;
j = (int)(xpc.xp_pattern - ccline.cmdbuff);
i = 0;
while (--j > 0)
{
/* check for start of menu name */
if (ccline.cmdbuff[j] == ' '
&& ccline.cmdbuff[j - 1] != '\\')
{
i = j + 1;
break;
}
/* check for start of submenu name */
if (ccline.cmdbuff[j] == '.'
&& ccline.cmdbuff[j - 1] != '\\')
{
if (found)
{
i = j + 1;
break;
}
else
found = TRUE;
}
}
if (i > 0)
cmdline_del(i);
c = p_wc;
xpc.xp_context = EXPAND_NOTHING;
}
}
if ((xpc.xp_context == EXPAND_FILES
|| xpc.xp_context == EXPAND_SHELLCMD) && p_wmnu)
{
char_u upseg[5];
upseg[0] = PATHSEP;
upseg[1] = '.';
upseg[2] = '.';
upseg[3] = PATHSEP;
upseg[4] = NUL;
if (ccline.cmdbuff[ccline.cmdpos - 1] == PATHSEP
&& c == K_DOWN
&& (ccline.cmdbuff[ccline.cmdpos - 2] != '.'
|| ccline.cmdbuff[ccline.cmdpos - 3] != '.'))
{
/* go down a directory */
c = p_wc;
}
else if (STRNCMP(xpc.xp_pattern, upseg + 1, 3) == 0 && c == K_DOWN)
{
/* If in a direct ancestor, strip off one ../ to go down */
int found = FALSE;
j = ccline.cmdpos;
i = (int)(xpc.xp_pattern - ccline.cmdbuff);
while (--j > i)
{
#ifdef FEAT_MBYTE
if (has_mbyte)
j -= (*mb_head_off)(ccline.cmdbuff, ccline.cmdbuff + j);
#endif
if (vim_ispathsep(ccline.cmdbuff[j]))
{
found = TRUE;
break;
}
}
if (found
&& ccline.cmdbuff[j - 1] == '.'
&& ccline.cmdbuff[j - 2] == '.'
&& (vim_ispathsep(ccline.cmdbuff[j - 3]) || j == i + 2))
{
cmdline_del(j - 2);
c = p_wc;
}
}
else if (c == K_UP)
{
/* go up a directory */
int found = FALSE;
j = ccline.cmdpos - 1;
i = (int)(xpc.xp_pattern - ccline.cmdbuff);
while (--j > i)
{
#ifdef FEAT_MBYTE
if (has_mbyte)
j -= (*mb_head_off)(ccline.cmdbuff, ccline.cmdbuff + j);
#endif
if (vim_ispathsep(ccline.cmdbuff[j])
#ifdef BACKSLASH_IN_FILENAME
&& vim_strchr(" *?[{`$%#", ccline.cmdbuff[j + 1])
== NULL
#endif
)
{
if (found)
{
i = j + 1;
break;
}
else
found = TRUE;
}
}
if (!found)
j = i;
else if (STRNCMP(ccline.cmdbuff + j, upseg, 4) == 0)
j += 4;
else if (STRNCMP(ccline.cmdbuff + j, upseg + 1, 3) == 0
&& j == i)
j += 3;
else
j = 0;
if (j > 0)
{
/* TODO this is only for DOS/UNIX systems - need to put in
* machine-specific stuff here and in upseg init */
cmdline_del(j);
put_on_cmdline(upseg + 1, 3, FALSE);
}
else if (ccline.cmdpos > i)
cmdline_del(i);
c = p_wc;
}
}
#if 0 /* If enabled <Down> on a file takes you _completely_ out of wildmenu */
if (p_wmnu
&& (xpc.xp_context == EXPAND_FILES
|| xpc.xp_context == EXPAND_MENUNAMES)
&& (c == K_UP || c == K_DOWN))
xpc.xp_context = EXPAND_NOTHING;
#endif
#endif /* FEAT_WILDMENU */
/* CTRL-\ CTRL-N goes to Normal mode, CTRL-\ CTRL-G goes to Insert
* mode when 'insertmode' is set, CTRL-\ e prompts for an expression. */
if (c == Ctrl_BSL)
{
++no_mapping;
++allow_keys;
c = safe_vgetc();
--no_mapping;
--allow_keys;
/* CTRL-\ e doesn't work when obtaining an expression. */
if (c != Ctrl_N && c != Ctrl_G
&& (c != 'e' || ccline.cmdfirstc == '='))
{
vungetc(c);
c = Ctrl_BSL;
}
#ifdef FEAT_EVAL
else if (c == 'e')
{
char_u *p = NULL;
/*
* Replace the command line with the result of an expression.
* Need to save and restore the current command line, to be
* able to enter a new one...
*/
if (ccline.cmdpos == ccline.cmdlen)
new_cmdpos = 99999; /* keep it at the end */
else
new_cmdpos = ccline.cmdpos;
save_cmdline(&save_ccline);
c = get_expr_register();
restore_cmdline(&save_ccline);
if (c == '=')
{
/* Need to save and restore ccline. And set "textlock"
* to avoid nasty things like going to another buffer when
* evaluating an expression. */
save_cmdline(&save_ccline);
++textlock;
p = get_expr_line();
--textlock;
restore_cmdline(&save_ccline);
if (p != NULL && realloc_cmdbuff((int)STRLEN(p) + 1) == OK)
{
ccline.cmdlen = (int)STRLEN(p);
STRCPY(ccline.cmdbuff, p);
vim_free(p);
/* Restore the cursor or use the position set with
* set_cmdline_pos(). */
if (new_cmdpos > ccline.cmdlen)
ccline.cmdpos = ccline.cmdlen;
else
ccline.cmdpos = new_cmdpos;
KeyTyped = FALSE; /* Don't do p_wc completion. */
redrawcmd();
goto cmdline_changed;
}
}
beep_flush();
c = ESC;
}
#endif
else
{
if (c == Ctrl_G && p_im && restart_edit == 0)
restart_edit = 'a';
gotesc = TRUE; /* will free ccline.cmdbuff after putting it
in history */
goto returncmd; /* back to Normal mode */
}
}
#ifdef FEAT_CMDWIN
if (c == cedit_key || c == K_CMDWIN)
{
/*
* Open a window to edit the command line (and history).
*/
c = ex_window();
some_key_typed = TRUE;
}
# ifdef FEAT_DIGRAPHS
else
# endif
#endif
#ifdef FEAT_DIGRAPHS
c = do_digraph(c);
#endif
if (c == '\n' || c == '\r' || c == K_KENTER || (c == ESC
&& (!KeyTyped || vim_strchr(p_cpo, CPO_ESC) != NULL)))
{
/* In Ex mode a backslash escapes a newline. */
if (exmode_active
&& c != ESC
&& ccline.cmdpos > 0
&& ccline.cmdpos == ccline.cmdlen
&& ccline.cmdbuff[ccline.cmdpos - 1] == '\\')
{
if (c == K_KENTER)
c = '\n';
}
else
{
gotesc = FALSE; /* Might have typed ESC previously, don't
truncate the cmdline now. */
if (ccheck_abbr(c + ABBR_OFF))
goto cmdline_changed;
if (!cmd_silent)
{
windgoto(msg_row, 0);
out_flush();
}
break;
}
}
/*
* Completion for 'wildchar' or 'wildcharm' key.
* - hitting <ESC> twice means: abandon command line.
* - wildcard expansion is only done when the 'wildchar' key is really
* typed, not when it comes from a macro
*/
if ((c == p_wc && !gotesc && KeyTyped) || c == p_wcm)
{
if (xpc.xp_numfiles > 0) /* typed p_wc at least twice */
{
/* if 'wildmode' contains "list" may still need to list */
if (xpc.xp_numfiles > 1
&& !did_wild_list
&& (wim_flags[wim_index] & WIM_LIST))
{
(void)showmatches(&xpc, FALSE);
redrawcmd();
did_wild_list = TRUE;
}
if (wim_flags[wim_index] & WIM_LONGEST)
res = nextwild(&xpc, WILD_LONGEST, WILD_NO_BEEP);
else if (wim_flags[wim_index] & WIM_FULL)
res = nextwild(&xpc, WILD_NEXT, WILD_NO_BEEP);
else
res = OK; /* don't insert 'wildchar' now */
}
else /* typed p_wc first time */
{
wim_index = 0;
j = ccline.cmdpos;
/* if 'wildmode' first contains "longest", get longest
* common part */
if (wim_flags[0] & WIM_LONGEST)
res = nextwild(&xpc, WILD_LONGEST, WILD_NO_BEEP);
else
res = nextwild(&xpc, WILD_EXPAND_KEEP, WILD_NO_BEEP);
/* if interrupted while completing, behave like it failed */
if (got_int)
{
(void)vpeekc(); /* remove <C-C> from input stream */
got_int = FALSE; /* don't abandon the command line */
(void)ExpandOne(&xpc, NULL, NULL, 0, WILD_FREE);
#ifdef FEAT_WILDMENU
xpc.xp_context = EXPAND_NOTHING;
#endif
goto cmdline_changed;
}
/* when more than one match, and 'wildmode' first contains
* "list", or no change and 'wildmode' contains "longest,list",
* list all matches */
if (res == OK && xpc.xp_numfiles > 1)
{
/* a "longest" that didn't do anything is skipped (but not
* "list:longest") */
if (wim_flags[0] == WIM_LONGEST && ccline.cmdpos == j)
wim_index = 1;
if ((wim_flags[wim_index] & WIM_LIST)
#ifdef FEAT_WILDMENU
|| (p_wmnu && (wim_flags[wim_index] & WIM_FULL) != 0)
#endif
)
{
if (!(wim_flags[0] & WIM_LONGEST))
{
#ifdef FEAT_WILDMENU
int p_wmnu_save = p_wmnu;
p_wmnu = 0;
#endif
nextwild(&xpc, WILD_PREV, 0); /* remove match */
#ifdef FEAT_WILDMENU
p_wmnu = p_wmnu_save;
#endif
}
#ifdef FEAT_WILDMENU
(void)showmatches(&xpc, p_wmnu
&& ((wim_flags[wim_index] & WIM_LIST) == 0));
#else
(void)showmatches(&xpc, FALSE);
#endif
redrawcmd();
did_wild_list = TRUE;
if (wim_flags[wim_index] & WIM_LONGEST)
nextwild(&xpc, WILD_LONGEST, WILD_NO_BEEP);
else if (wim_flags[wim_index] & WIM_FULL)
nextwild(&xpc, WILD_NEXT, WILD_NO_BEEP);
}
else
vim_beep();
}
#ifdef FEAT_WILDMENU
else if (xpc.xp_numfiles == -1)
xpc.xp_context = EXPAND_NOTHING;
#endif
}
if (wim_index < 3)
++wim_index;
if (c == ESC)
gotesc = TRUE;
if (res == OK)
goto cmdline_changed;
}
gotesc = FALSE;
/* <S-Tab> goes to last match, in a clumsy way */
if (c == K_S_TAB && KeyTyped)
{
if (nextwild(&xpc, WILD_EXPAND_KEEP, 0) == OK
&& nextwild(&xpc, WILD_PREV, 0) == OK
&& nextwild(&xpc, WILD_PREV, 0) == OK)
goto cmdline_changed;
}
if (c == NUL || c == K_ZERO) /* NUL is stored as NL */
c = NL;
do_abbr = TRUE; /* default: check for abbreviation */
/*
* Big switch for a typed command line character.
*/
switch (c)
{
case K_BS:
case Ctrl_H:
case K_DEL:
case K_KDEL:
case Ctrl_W:
#ifdef FEAT_FKMAP
if (cmd_fkmap && c == K_BS)
c = K_DEL;
#endif
if (c == K_KDEL)
c = K_DEL;
/*
* delete current character is the same as backspace on next
* character, except at end of line
*/
if (c == K_DEL && ccline.cmdpos != ccline.cmdlen)
++ccline.cmdpos;
#ifdef FEAT_MBYTE
if (has_mbyte && c == K_DEL)
ccline.cmdpos += mb_off_next(ccline.cmdbuff,
ccline.cmdbuff + ccline.cmdpos);
#endif
if (ccline.cmdpos > 0)
{
char_u *p;
j = ccline.cmdpos;
p = ccline.cmdbuff + j;
#ifdef FEAT_MBYTE
if (has_mbyte)
{
p = mb_prevptr(ccline.cmdbuff, p);
if (c == Ctrl_W)
{
while (p > ccline.cmdbuff && vim_isspace(*p))
p = mb_prevptr(ccline.cmdbuff, p);
i = mb_get_class(p);
while (p > ccline.cmdbuff && mb_get_class(p) == i)
p = mb_prevptr(ccline.cmdbuff, p);
if (mb_get_class(p) != i)
p += (*mb_ptr2len)(p);
}
}
else
#endif
if (c == Ctrl_W)
{
while (p > ccline.cmdbuff && vim_isspace(p[-1]))
--p;
i = vim_iswordc(p[-1]);
while (p > ccline.cmdbuff && !vim_isspace(p[-1])
&& vim_iswordc(p[-1]) == i)
--p;
}
else
--p;
ccline.cmdpos = (int)(p - ccline.cmdbuff);
ccline.cmdlen -= j - ccline.cmdpos;
i = ccline.cmdpos;
while (i < ccline.cmdlen)
ccline.cmdbuff[i++] = ccline.cmdbuff[j++];
/* Truncate at the end, required for multi-byte chars. */
ccline.cmdbuff[ccline.cmdlen] = NUL;
redrawcmd();
}
else if (ccline.cmdlen == 0 && c != Ctrl_W
&& ccline.cmdprompt == NULL && indent == 0)
{
/* In ex and debug mode it doesn't make sense to return. */
if (exmode_active
#ifdef FEAT_EVAL
|| ccline.cmdfirstc == '>'
#endif
)
goto cmdline_not_changed;
vim_free(ccline.cmdbuff); /* no commandline to return */
ccline.cmdbuff = NULL;
if (!cmd_silent)
{
#ifdef FEAT_RIGHTLEFT
if (cmdmsg_rl)
msg_col = Columns;
else
#endif
msg_col = 0;
msg_putchar(' '); /* delete ':' */
}
redraw_cmdline = TRUE;
goto returncmd; /* back to cmd mode */
}
goto cmdline_changed;
case K_INS:
case K_KINS:
#ifdef FEAT_FKMAP
/* if Farsi mode set, we are in reverse insert mode -
Do not change the mode */
if (cmd_fkmap)
beep_flush();
else
#endif
ccline.overstrike = !ccline.overstrike;
#ifdef CURSOR_SHAPE
ui_cursor_shape(); /* may show different cursor shape */
#endif
goto cmdline_not_changed;
case Ctrl_HAT:
if (map_to_exists_mode((char_u *)"", LANGMAP, FALSE))
{
/* ":lmap" mappings exists, toggle use of mappings. */
State ^= LANGMAP;
#ifdef USE_IM_CONTROL
im_set_active(FALSE); /* Disable input method */
#endif
if (b_im_ptr != NULL)
{
if (State & LANGMAP)
*b_im_ptr = B_IMODE_LMAP;
else
*b_im_ptr = B_IMODE_NONE;
}
}
#ifdef USE_IM_CONTROL
else
{
/* There are no ":lmap" mappings, toggle IM. When
* 'imdisable' is set don't try getting the status, it's
* always off. */
if ((p_imdisable && b_im_ptr != NULL)
? *b_im_ptr == B_IMODE_IM : im_get_status())
{
im_set_active(FALSE); /* Disable input method */
if (b_im_ptr != NULL)
*b_im_ptr = B_IMODE_NONE;
}
else
{
im_set_active(TRUE); /* Enable input method */
if (b_im_ptr != NULL)
*b_im_ptr = B_IMODE_IM;
}
}
#endif
if (b_im_ptr != NULL)
{
if (b_im_ptr == &curbuf->b_p_iminsert)
set_iminsert_global();
else
set_imsearch_global();
}
#ifdef CURSOR_SHAPE
ui_cursor_shape(); /* may show different cursor shape */
#endif
#if defined(FEAT_WINDOWS) && defined(FEAT_KEYMAP)
/* Show/unshow value of 'keymap' in status lines later. */
status_redraw_curbuf();
#endif
goto cmdline_not_changed;
/* case '@': only in very old vi */
case Ctrl_U:
/* delete all characters left of the cursor */
j = ccline.cmdpos;
ccline.cmdlen -= j;
i = ccline.cmdpos = 0;
while (i < ccline.cmdlen)
ccline.cmdbuff[i++] = ccline.cmdbuff[j++];
/* Truncate at the end, required for multi-byte chars. */
ccline.cmdbuff[ccline.cmdlen] = NUL;
redrawcmd();
goto cmdline_changed;
#ifdef FEAT_CLIPBOARD
case Ctrl_Y:
/* Copy the modeless selection, if there is one. */
if (clip_star.state != SELECT_CLEARED)
{
if (clip_star.state == SELECT_DONE)
clip_copy_modeless_selection(TRUE);
goto cmdline_not_changed;
}
break;
#endif
case ESC: /* get here if p_wc != ESC or when ESC typed twice */
case Ctrl_C:
/* In exmode it doesn't make sense to return. Except when
* ":normal" runs out of characters. */
if (exmode_active
#ifdef FEAT_EX_EXTRA
&& (ex_normal_busy == 0 || typebuf.tb_len > 0)
#endif
)
goto cmdline_not_changed;
gotesc = TRUE; /* will free ccline.cmdbuff after
putting it in history */
goto returncmd; /* back to cmd mode */
case Ctrl_R: /* insert register */
#ifdef USE_ON_FLY_SCROLL
dont_scroll = TRUE; /* disallow scrolling here */
#endif
putcmdline('"', TRUE);
++no_mapping;
i = c = safe_vgetc(); /* CTRL-R <char> */
if (i == Ctrl_O)
i = Ctrl_R; /* CTRL-R CTRL-O == CTRL-R CTRL-R */
if (i == Ctrl_R)
c = safe_vgetc(); /* CTRL-R CTRL-R <char> */
--no_mapping;
#ifdef FEAT_EVAL
/*
* Insert the result of an expression.
* Need to save the current command line, to be able to enter
* a new one...
*/
new_cmdpos = -1;
if (c == '=')
{
if (ccline.cmdfirstc == '=')/* can't do this recursively */
{
beep_flush();
c = ESC;
}
else
{
save_cmdline(&save_ccline);
c = get_expr_register();
restore_cmdline(&save_ccline);
}
}
#endif
if (c != ESC) /* use ESC to cancel inserting register */
{
cmdline_paste(c, i == Ctrl_R, FALSE);
#ifdef FEAT_EVAL
/* When there was a serious error abort getting the
* command line. */
if (aborting())
{
gotesc = TRUE; /* will free ccline.cmdbuff after
putting it in history */
goto returncmd; /* back to cmd mode */
}
#endif
KeyTyped = FALSE; /* Don't do p_wc completion. */
#ifdef FEAT_EVAL
if (new_cmdpos >= 0)
{
/* set_cmdline_pos() was used */
if (new_cmdpos > ccline.cmdlen)
ccline.cmdpos = ccline.cmdlen;
else
ccline.cmdpos = new_cmdpos;
}
#endif
}
redrawcmd();
goto cmdline_changed;
case Ctrl_D:
if (showmatches(&xpc, FALSE) == EXPAND_NOTHING)
break; /* Use ^D as normal char instead */
redrawcmd();
continue; /* don't do incremental search now */
case K_RIGHT:
case K_S_RIGHT:
case K_C_RIGHT:
do
{
if (ccline.cmdpos >= ccline.cmdlen)
break;
i = cmdline_charsize(ccline.cmdpos);
if (KeyTyped && ccline.cmdspos + i >= Columns * Rows)
break;
ccline.cmdspos += i;
#ifdef FEAT_MBYTE
if (has_mbyte)
ccline.cmdpos += (*mb_ptr2len)(ccline.cmdbuff
+ ccline.cmdpos);
else
#endif
++ccline.cmdpos;
}
while ((c == K_S_RIGHT || c == K_C_RIGHT
|| (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL)))
&& ccline.cmdbuff[ccline.cmdpos] != ' ');
#ifdef FEAT_MBYTE
if (has_mbyte)
set_cmdspos_cursor();
#endif
goto cmdline_not_changed;
case K_LEFT:
case K_S_LEFT:
case K_C_LEFT:
do
{
if (ccline.cmdpos == 0)
break;
--ccline.cmdpos;
#ifdef FEAT_MBYTE
if (has_mbyte) /* move to first byte of char */
ccline.cmdpos -= (*mb_head_off)(ccline.cmdbuff,
ccline.cmdbuff + ccline.cmdpos);
#endif
ccline.cmdspos -= cmdline_charsize(ccline.cmdpos);
}
while ((c == K_S_LEFT || c == K_C_LEFT
|| (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL)))
&& ccline.cmdbuff[ccline.cmdpos - 1] != ' ');
#ifdef FEAT_MBYTE
if (has_mbyte)
set_cmdspos_cursor();
#endif
goto cmdline_not_changed;
case K_IGNORE:
goto cmdline_not_changed; /* Ignore mouse */
#ifdef FEAT_GUI_W32
/* On Win32 ignore <M-F4>, we get it when closing the window was
* cancelled. */
case K_F4:
if (mod_mask == MOD_MASK_ALT)
{
redrawcmd(); /* somehow the cmdline is cleared */
goto cmdline_not_changed;
}
break;
#endif
#ifdef FEAT_MOUSE
case K_MIDDLEDRAG:
case K_MIDDLERELEASE:
goto cmdline_not_changed; /* Ignore mouse */
case K_MIDDLEMOUSE:
# ifdef FEAT_GUI
/* When GUI is active, also paste when 'mouse' is empty */
if (!gui.in_use)
# endif
if (!mouse_has(MOUSE_COMMAND))
goto cmdline_not_changed; /* Ignore mouse */
# ifdef FEAT_CLIPBOARD
if (clip_star.available)
cmdline_paste('*', TRUE, TRUE);
else
# endif
cmdline_paste(0, TRUE, TRUE);
redrawcmd();
goto cmdline_changed;
# ifdef FEAT_DND
case K_DROP:
cmdline_paste('~', TRUE, FALSE);
redrawcmd();
goto cmdline_changed;
# endif
case K_LEFTDRAG:
case K_LEFTRELEASE:
case K_RIGHTDRAG:
case K_RIGHTRELEASE:
/* Ignore drag and release events when the button-down wasn't
* seen before. */
if (ignore_drag_release)
goto cmdline_not_changed;
/* FALLTHROUGH */
case K_LEFTMOUSE:
case K_RIGHTMOUSE:
if (c == K_LEFTRELEASE || c == K_RIGHTRELEASE)
ignore_drag_release = TRUE;
else
ignore_drag_release = FALSE;
# ifdef FEAT_GUI
/* When GUI is active, also move when 'mouse' is empty */
if (!gui.in_use)
# endif
if (!mouse_has(MOUSE_COMMAND))
goto cmdline_not_changed; /* Ignore mouse */
# ifdef FEAT_CLIPBOARD
if (mouse_row < cmdline_row && clip_star.available)
{
int button, is_click, is_drag;
/*
* Handle modeless selection.
*/
button = get_mouse_button(KEY2TERMCAP1(c),
&is_click, &is_drag);
if (mouse_model_popup() && button == MOUSE_LEFT
&& (mod_mask & MOD_MASK_SHIFT))
{
/* Translate shift-left to right button. */
button = MOUSE_RIGHT;
mod_mask &= ~MOD_MASK_SHIFT;
}
clip_modeless(button, is_click, is_drag);
goto cmdline_not_changed;
}
# endif
set_cmdspos();
for (ccline.cmdpos = 0; ccline.cmdpos < ccline.cmdlen;
++ccline.cmdpos)
{
i = cmdline_charsize(ccline.cmdpos);
if (mouse_row <= cmdline_row + ccline.cmdspos / Columns
&& mouse_col < ccline.cmdspos % Columns + i)
break;
# ifdef FEAT_MBYTE
if (has_mbyte)
{
/* Count ">" for double-wide char that doesn't fit. */
correct_cmdspos(ccline.cmdpos, i);
ccline.cmdpos += (*mb_ptr2len)(ccline.cmdbuff
+ ccline.cmdpos) - 1;
}
# endif
ccline.cmdspos += i;
}
goto cmdline_not_changed;
/* Mouse scroll wheel: ignored here */
case K_MOUSEDOWN:
case K_MOUSEUP:
/* Alternate buttons ignored here */
case K_X1MOUSE:
case K_X1DRAG:
case K_X1RELEASE:
case K_X2MOUSE:
case K_X2DRAG:
case K_X2RELEASE:
goto cmdline_not_changed;
#endif /* FEAT_MOUSE */
#ifdef FEAT_GUI
case K_LEFTMOUSE_NM: /* mousefocus click, ignored */
case K_LEFTRELEASE_NM:
goto cmdline_not_changed;
case K_VER_SCROLLBAR:
if (msg_scrolled == 0)
{
gui_do_scroll();
redrawcmd();
}
goto cmdline_not_changed;
case K_HOR_SCROLLBAR:
if (msg_scrolled == 0)
{
gui_do_horiz_scroll();
redrawcmd();
}
goto cmdline_not_changed;
#endif
#ifdef FEAT_GUI_TABLINE
case K_TABLINE:
case K_TABMENU:
/* Don't want to change any tabs here. Make sure the same tab
* is still selected. */
if (gui_use_tabline())
gui_mch_set_curtab(tabpage_index(curtab));
goto cmdline_not_changed;
#endif
case K_SELECT: /* end of Select mode mapping - ignore */
goto cmdline_not_changed;
case Ctrl_B: /* begin of command line */
case K_HOME:
case K_KHOME:
case K_S_HOME:
case K_C_HOME:
ccline.cmdpos = 0;
set_cmdspos();
goto cmdline_not_changed;
case Ctrl_E: /* end of command line */
case K_END:
case K_KEND:
case K_S_END:
case K_C_END:
ccline.cmdpos = ccline.cmdlen;
set_cmdspos_cursor();
goto cmdline_not_changed;
case Ctrl_A: /* all matches */
if (nextwild(&xpc, WILD_ALL, 0) == FAIL)
break;
goto cmdline_changed;
case Ctrl_L:
#ifdef FEAT_SEARCH_EXTRA
if (p_is && !cmd_silent && (firstc == '/' || firstc == '?'))
{
/* Add a character from under the cursor for 'incsearch' */
if (did_incsearch
&& !equalpos(curwin->w_cursor, old_cursor))
{
c = gchar_cursor();
if (c != NUL)
{
if (c == firstc || vim_strchr((char_u *)(
p_magic ? "\\^$.*[" : "\\^$"), c)
!= NULL)
{
/* put a backslash before special characters */
stuffcharReadbuff(c);
c = '\\';
}
break;
}
}
goto cmdline_not_changed;
}
#endif
/* completion: longest common part */
if (nextwild(&xpc, WILD_LONGEST, 0) == FAIL)
break;
goto cmdline_changed;
case Ctrl_N: /* next match */
case Ctrl_P: /* previous match */
if (xpc.xp_numfiles > 0)
{
if (nextwild(&xpc, (c == Ctrl_P) ? WILD_PREV : WILD_NEXT, 0)
== FAIL)
break;
goto cmdline_changed;
}
#ifdef FEAT_CMDHIST
case K_UP:
case K_DOWN:
case K_S_UP:
case K_S_DOWN:
case K_PAGEUP:
case K_KPAGEUP:
case K_PAGEDOWN:
case K_KPAGEDOWN:
if (hislen == 0 || firstc == NUL) /* no history */
goto cmdline_not_changed;
i = hiscnt;
/* save current command string so it can be restored later */
if (lookfor == NULL)
{
if ((lookfor = vim_strsave(ccline.cmdbuff)) == NULL)
goto cmdline_not_changed;
lookfor[ccline.cmdpos] = NUL;
}
j = (int)STRLEN(lookfor);
for (;;)
{
/* one step backwards */
if (c == K_UP|| c == K_S_UP || c == Ctrl_P
|| c == K_PAGEUP || c == K_KPAGEUP)
{
if (hiscnt == hislen) /* first time */
hiscnt = hisidx[histype];
else if (hiscnt == 0 && hisidx[histype] != hislen - 1)
hiscnt = hislen - 1;
else if (hiscnt != hisidx[histype] + 1)
--hiscnt;
else /* at top of list */
{
hiscnt = i;
break;
}
}
else /* one step forwards */
{
/* on last entry, clear the line */
if (hiscnt == hisidx[histype])
{
hiscnt = hislen;
break;
}
/* not on a history line, nothing to do */
if (hiscnt == hislen)
break;
if (hiscnt == hislen - 1) /* wrap around */
hiscnt = 0;
else
++hiscnt;
}
if (hiscnt < 0 || history[histype][hiscnt].hisstr == NULL)
{
hiscnt = i;
break;
}
if ((c != K_UP && c != K_DOWN)
|| hiscnt == i
|| STRNCMP(history[histype][hiscnt].hisstr,
lookfor, (size_t)j) == 0)
break;
}
if (hiscnt != i) /* jumped to other entry */
{
char_u *p;
int len;
int old_firstc;
vim_free(ccline.cmdbuff);
if (hiscnt == hislen)
p = lookfor; /* back to the old one */
else
p = history[histype][hiscnt].hisstr;
if (histype == HIST_SEARCH
&& p != lookfor
&& (old_firstc = p[STRLEN(p) + 1]) != firstc)
{
/* Correct for the separator character used when
* adding the history entry vs the one used now.
* First loop: count length.
* Second loop: copy the characters. */
for (i = 0; i <= 1; ++i)
{
len = 0;
for (j = 0; p[j] != NUL; ++j)
{
/* Replace old sep with new sep, unless it is
* escaped. */
if (p[j] == old_firstc
&& (j == 0 || p[j - 1] != '\\'))
{
if (i > 0)
ccline.cmdbuff[len] = firstc;
}
else
{
/* Escape new sep, unless it is already
* escaped. */
if (p[j] == firstc
&& (j == 0 || p[j - 1] != '\\'))
{
if (i > 0)
ccline.cmdbuff[len] = '\\';
++len;
}
if (i > 0)
ccline.cmdbuff[len] = p[j];
}
++len;
}
if (i == 0)
{
alloc_cmdbuff(len);
if (ccline.cmdbuff == NULL)
goto returncmd;
}
}
ccline.cmdbuff[len] = NUL;
}
else
{
alloc_cmdbuff((int)STRLEN(p));
if (ccline.cmdbuff == NULL)
goto returncmd;
STRCPY(ccline.cmdbuff, p);
}
ccline.cmdpos = ccline.cmdlen = (int)STRLEN(ccline.cmdbuff);
redrawcmd();
goto cmdline_changed;
}
beep_flush();
goto cmdline_not_changed;
#endif
case Ctrl_V:
case Ctrl_Q:
#ifdef FEAT_MOUSE
ignore_drag_release = TRUE;
#endif
putcmdline('^', TRUE);
c = get_literal(); /* get next (two) character(s) */
do_abbr = FALSE; /* don't do abbreviation now */
#ifdef FEAT_MBYTE
/* may need to remove ^ when composing char was typed */
if (enc_utf8 && utf_iscomposing(c) && !cmd_silent)
{
draw_cmdline(ccline.cmdpos, ccline.cmdlen - ccline.cmdpos);
msg_putchar(' ');
cursorcmd();
}
#endif
break;
#ifdef FEAT_DIGRAPHS
case Ctrl_K:
#ifdef FEAT_MOUSE
ignore_drag_release = TRUE;
#endif
putcmdline('?', TRUE);
#ifdef USE_ON_FLY_SCROLL
dont_scroll = TRUE; /* disallow scrolling here */
#endif
c = get_digraph(TRUE);
if (c != NUL)
break;
redrawcmd();
goto cmdline_not_changed;
#endif /* FEAT_DIGRAPHS */
#ifdef FEAT_RIGHTLEFT
case Ctrl__: /* CTRL-_: switch language mode */
if (!p_ari)
break;
#ifdef FEAT_FKMAP
if (p_altkeymap)
{
cmd_fkmap = !cmd_fkmap;
if (cmd_fkmap) /* in Farsi always in Insert mode */
ccline.overstrike = FALSE;
}
else /* Hebrew is default */
#endif
cmd_hkmap = !cmd_hkmap;
goto cmdline_not_changed;
#endif
default:
#ifdef UNIX
if (c == intr_char)
{
gotesc = TRUE; /* will free ccline.cmdbuff after
putting it in history */
goto returncmd; /* back to Normal mode */
}
#endif
/*
* Normal character with no special meaning. Just set mod_mask
* to 0x0 so that typing Shift-Space in the GUI doesn't enter
* the string <S-Space>. This should only happen after ^V.
*/
if (!IS_SPECIAL(c))
mod_mask = 0x0;
break;
}
/*
* End of switch on command line character.
* We come here if we have a normal character.
*/
if (do_abbr && (IS_SPECIAL(c) || !vim_iswordc(c)) && ccheck_abbr(
#ifdef FEAT_MBYTE
/* Add ABBR_OFF for characters above 0x100, this is
* what check_abbr() expects. */
(has_mbyte && c >= 0x100) ? (c + ABBR_OFF) :
#endif
c))
goto cmdline_changed;
/*
* put the character in the command line
*/
if (IS_SPECIAL(c) || mod_mask != 0)
put_on_cmdline(get_special_key_name(c, mod_mask), -1, TRUE);
else
{
#ifdef FEAT_MBYTE
if (has_mbyte)
{
j = (*mb_char2bytes)(c, IObuff);
IObuff[j] = NUL; /* exclude composing chars */
put_on_cmdline(IObuff, j, TRUE);
}
else
#endif
{
IObuff[0] = c;
put_on_cmdline(IObuff, 1, TRUE);
}
}
goto cmdline_changed;
/*
* This part implements incremental searches for "/" and "?"
* Jump to cmdline_not_changed when a character has been read but the command
* line did not change. Then we only search and redraw if something changed in
* the past.
* Jump to cmdline_changed when the command line did change.
* (Sorry for the goto's, I know it is ugly).
*/
cmdline_not_changed:
#ifdef FEAT_SEARCH_EXTRA
if (!incsearch_postponed)
continue;
#endif
cmdline_changed:
#ifdef FEAT_SEARCH_EXTRA
/*
* 'incsearch' highlighting.
*/
if (p_is && !cmd_silent && (firstc == '/' || firstc == '?'))
{
pos_T end_pos;
/* if there is a character waiting, search and redraw later */
if (char_avail())
{
incsearch_postponed = TRUE;
continue;
}
incsearch_postponed = FALSE;
curwin->w_cursor = old_cursor; /* start at old position */
/* If there is no command line, don't do anything */
if (ccline.cmdlen == 0)
i = 0;
else
{
cursor_off(); /* so the user knows we're busy */
out_flush();
++emsg_off; /* So it doesn't beep if bad expr */
i = do_search(NULL, firstc, ccline.cmdbuff, count,
SEARCH_KEEP + SEARCH_OPT + SEARCH_NOOF + SEARCH_PEEK);
--emsg_off;
/* if interrupted while searching, behave like it failed */
if (got_int)
{
(void)vpeekc(); /* remove <C-C> from input stream */
got_int = FALSE; /* don't abandon the command line */
i = 0;
}
else if (char_avail())
/* cancelled searching because a char was typed */
incsearch_postponed = TRUE;
}
if (i != 0)
highlight_match = TRUE; /* highlight position */
else
highlight_match = FALSE; /* remove highlight */
/* first restore the old curwin values, so the screen is
* positioned in the same way as the actual search command */
curwin->w_leftcol = old_leftcol;
curwin->w_topline = old_topline;
# ifdef FEAT_DIFF
curwin->w_topfill = old_topfill;
# endif
curwin->w_botline = old_botline;
changed_cline_bef_curs();
update_topline();
if (i != 0)
{
pos_T save_pos = curwin->w_cursor;
/*
* First move cursor to end of match, then to the start. This
* moves the whole match onto the screen when 'nowrap' is set.
*/
curwin->w_cursor.lnum += search_match_lines;
curwin->w_cursor.col = search_match_endcol;
if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
{
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
coladvance((colnr_T)MAXCOL);
}
validate_cursor();
end_pos = curwin->w_cursor;
curwin->w_cursor = save_pos;
}
else
end_pos = curwin->w_cursor; /* shutup gcc 4 */
validate_cursor();
# ifdef FEAT_WINDOWS
/* May redraw the status line to show the cursor position. */
if (p_ru && curwin->w_status_height > 0)
curwin->w_redr_status = TRUE;
# endif
save_cmdline(&save_ccline);
update_screen(SOME_VALID);
restore_cmdline(&save_ccline);
/* Leave it at the end to make CTRL-R CTRL-W work. */
if (i != 0)
curwin->w_cursor = end_pos;
msg_starthere();
redrawcmdline();
did_incsearch = TRUE;
}
#else /* FEAT_SEARCH_EXTRA */
;
#endif
#ifdef FEAT_RIGHTLEFT
if (cmdmsg_rl
# ifdef FEAT_ARABIC
|| (p_arshape && !p_tbidi && enc_utf8)
# endif
)
/* Always redraw the whole command line to fix shaping and
* right-left typing. Not efficient, but it works. */
redrawcmd();
#endif
}
returncmd:
#ifdef FEAT_RIGHTLEFT
cmdmsg_rl = FALSE;
#endif
#ifdef FEAT_FKMAP
cmd_fkmap = 0;
#endif
ExpandCleanup(&xpc);
#ifdef FEAT_SEARCH_EXTRA
if (did_incsearch)
{
curwin->w_cursor = old_cursor;
curwin->w_curswant = old_curswant;
curwin->w_leftcol = old_leftcol;
curwin->w_topline = old_topline;
# ifdef FEAT_DIFF
curwin->w_topfill = old_topfill;
# endif
curwin->w_botline = old_botline;
highlight_match = FALSE;
validate_cursor(); /* needed for TAB */
redraw_later(SOME_VALID);
}
#endif
if (ccline.cmdbuff != NULL)
{
/*
* Put line in history buffer (":" and "=" only when it was typed).
*/
#ifdef FEAT_CMDHIST
if (ccline.cmdlen && firstc != NUL
&& (some_key_typed || histype == HIST_SEARCH))
{
add_to_history(histype, ccline.cmdbuff, TRUE,
histype == HIST_SEARCH ? firstc : NUL);
if (firstc == ':')
{
vim_free(new_last_cmdline);
new_last_cmdline = vim_strsave(ccline.cmdbuff);
}
}
#endif
if (gotesc) /* abandon command line */
{
vim_free(ccline.cmdbuff);
ccline.cmdbuff = NULL;
if (msg_scrolled == 0)
compute_cmdrow();
MSG("");
redraw_cmdline = TRUE;
}
}
/*
* If the screen was shifted up, redraw the whole screen (later).
* If the line is too long, clear it, so ruler and shown command do
* not get printed in the middle of it.
*/
msg_check();
msg_scroll = save_msg_scroll;
redir_off = FALSE;
/* When the command line was typed, no need for a wait-return prompt. */
if (some_key_typed)
need_wait_return = FALSE;
State = save_State;
#ifdef USE_IM_CONTROL
if (b_im_ptr != NULL && *b_im_ptr != B_IMODE_LMAP)
im_save_status(b_im_ptr);
im_set_active(FALSE);
#endif
#ifdef FEAT_MOUSE
setmouse();
#endif
#ifdef CURSOR_SHAPE
ui_cursor_shape(); /* may show different cursor shape */
#endif
{
char_u *p = ccline.cmdbuff;
/* Make ccline empty, getcmdline() may try to use it. */
ccline.cmdbuff = NULL;
return p;
}
}
#if (defined(FEAT_CRYPT) || defined(FEAT_EVAL)) || defined(PROTO)
/*
* Get a command line with a prompt.
* This is prepared to be called recursively from getcmdline() (e.g. by
* f_input() when evaluating an expression from CTRL-R =).
* Returns the command line in allocated memory, or NULL.
*/
char_u *
getcmdline_prompt(firstc, prompt, attr, xp_context, xp_arg)
int firstc;
char_u *prompt; /* command line prompt */
int attr; /* attributes for prompt */
int xp_context; /* type of expansion */
char_u *xp_arg; /* user-defined expansion argument */
{
char_u *s;
struct cmdline_info save_ccline;
int msg_col_save = msg_col;
save_cmdline(&save_ccline);
ccline.cmdprompt = prompt;
ccline.cmdattr = attr;
# ifdef FEAT_EVAL
ccline.xp_context = xp_context;
ccline.xp_arg = xp_arg;
ccline.input_fn = (firstc == '@');
# endif
s = getcmdline(firstc, 1L, 0);
restore_cmdline(&save_ccline);
/* Restore msg_col, the prompt from input() may have changed it. */
msg_col = msg_col_save;
return s;
}
#endif
/*
* Return TRUE when the text must not be changed and we can't switch to
* another window or buffer. Used when editing the command line, evaluating
* 'balloonexpr', etc.
*/
int
text_locked()
{
#ifdef FEAT_CMDWIN
if (cmdwin_type != 0)
return TRUE;
#endif
return textlock != 0;
}
/*
* Give an error message for a command that isn't allowed while the cmdline
* window is open or editing the cmdline in another way.
*/
void
text_locked_msg()
{
#ifdef FEAT_CMDWIN
if (cmdwin_type != 0)
EMSG(_(e_cmdwin));
else
#endif
EMSG(_(e_secure));
}
#if defined(FEAT_AUTOCMD) || defined(PROTO)
/*
* Check if "curbuf_lock" is set and return TRUE when it is and give an error
* message.
*/
int
curbuf_locked()
{
if (curbuf_lock > 0)
{
EMSG(_("E788: Not allowed to edit another buffer now"));
return TRUE;
}
return FALSE;
}
#endif
static int
cmdline_charsize(idx)
int idx;
{
#if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
if (cmdline_star > 0) /* showing '*', always 1 position */
return 1;
#endif
return ptr2cells(ccline.cmdbuff + idx);
}
/*
* Compute the offset of the cursor on the command line for the prompt and
* indent.
*/
static void
set_cmdspos()
{
if (ccline.cmdfirstc != NUL)
ccline.cmdspos = 1 + ccline.cmdindent;
else
ccline.cmdspos = 0 + ccline.cmdindent;
}
/*
* Compute the screen position for the cursor on the command line.
*/
static void
set_cmdspos_cursor()
{
int i, m, c;
set_cmdspos();
if (KeyTyped)
{
m = Columns * Rows;
if (m < 0) /* overflow, Columns or Rows at weird value */
m = MAXCOL;
}
else
m = MAXCOL;
for (i = 0; i < ccline.cmdlen && i < ccline.cmdpos; ++i)
{
c = cmdline_charsize(i);
#ifdef FEAT_MBYTE
/* Count ">" for double-wide multi-byte char that doesn't fit. */
if (has_mbyte)
correct_cmdspos(i, c);
#endif
/* If the cmdline doesn't fit, put cursor on last visible char. */
if ((ccline.cmdspos += c) >= m)
{
ccline.cmdpos = i - 1;
ccline.cmdspos -= c;
break;
}
#ifdef FEAT_MBYTE
if (has_mbyte)
i += (*mb_ptr2len)(ccline.cmdbuff + i) - 1;
#endif
}
}
#ifdef FEAT_MBYTE
/*
* Check if the character at "idx", which is "cells" wide, is a multi-byte
* character that doesn't fit, so that a ">" must be displayed.
*/
static void
correct_cmdspos(idx, cells)
int idx;
int cells;
{
if ((*mb_ptr2len)(ccline.cmdbuff + idx) > 1
&& (*mb_ptr2cells)(ccline.cmdbuff + idx) > 1
&& ccline.cmdspos % Columns + cells > Columns)
ccline.cmdspos++;
}
#endif
/*
* Get an Ex command line for the ":" command.
*/
/* ARGSUSED */
char_u *
getexline(c, dummy, indent)
int c; /* normally ':', NUL for ":append" */
void *dummy; /* cookie not used */
int indent; /* indent for inside conditionals */
{
/* When executing a register, remove ':' that's in front of each line. */
if (exec_from_reg && vpeekc() == ':')
(void)vgetc();
return getcmdline(c, 1L, indent);
}
/*
* Get an Ex command line for Ex mode.
* In Ex mode we only use the OS supplied line editing features and no
* mappings or abbreviations.
* Returns a string in allocated memory or NULL.
*/
/* ARGSUSED */
char_u *
getexmodeline(promptc, dummy, indent)
int promptc; /* normally ':', NUL for ":append" and '?' for
:s prompt */
void *dummy; /* cookie not used */
int indent; /* indent for inside conditionals */
{
garray_T line_ga;
char_u *pend;
int startcol = 0;
int c1;
int escaped = FALSE; /* CTRL-V typed */
int vcol = 0;
char_u *p;
int prev_char = 0;
/* Switch cursor on now. This avoids that it happens after the "\n", which
* confuses the system function that computes tabstops. */
cursor_on();
/* always start in column 0; write a newline if necessary */
compute_cmdrow();
if ((msg_col || msg_didout) && promptc != '?')
msg_putchar('\n');
if (promptc == ':')
{
/* indent that is only displayed, not in the line itself */
if (p_prompt)
msg_putchar(':');
while (indent-- > 0)
msg_putchar(' ');
startcol = msg_col;
}
ga_init2(&line_ga, 1, 30);
/* autoindent for :insert and :append is in the line itself */
if (promptc <= 0)
{
vcol = indent;
while (indent >= 8)
{
ga_append(&line_ga, TAB);
msg_puts((char_u *)" ");
indent -= 8;
}
while (indent-- > 0)
{
ga_append(&line_ga, ' ');
msg_putchar(' ');
}
}
++no_mapping;
++allow_keys;
/*
* Get the line, one character at a time.
*/
got_int = FALSE;
while (!got_int)
{
if (ga_grow(&line_ga, 40) == FAIL)
break;
pend = (char_u *)line_ga.ga_data + line_ga.ga_len;
/* Get one character at a time. Don't use inchar(), it can't handle
* special characters. */
c1 = vgetc();
/*
* Handle line editing.
* Previously this was left to the system, putting the terminal in
* cooked mode, but then CTRL-D and CTRL-T can't be used properly.
*/
if (got_int)
{
msg_putchar('\n');
break;
}
if (!escaped)
{
/* CR typed means "enter", which is NL */
if (c1 == '\r')
c1 = '\n';
if (c1 == BS || c1 == K_BS
|| c1 == DEL || c1 == K_DEL || c1 == K_KDEL)
{
if (line_ga.ga_len > 0)
{
--line_ga.ga_len;
goto redraw;
}
continue;
}
if (c1 == Ctrl_U)
{
msg_col = startcol;
msg_clr_eos();
line_ga.ga_len = 0;
continue;
}
if (c1 == Ctrl_T)
{
p = (char_u *)line_ga.ga_data;
p[line_ga.ga_len] = NUL;
indent = get_indent_str(p, 8);
indent += curbuf->b_p_sw - indent % curbuf->b_p_sw;
add_indent:
while (get_indent_str(p, 8) < indent)
{
char_u *s = skipwhite(p);
ga_grow(&line_ga, 1);
mch_memmove(s + 1, s, line_ga.ga_len - (s - p) + 1);
*s = ' ';
++line_ga.ga_len;
}
redraw:
/* redraw the line */
msg_col = startcol;
windgoto(msg_row, msg_col);
vcol = 0;
for (p = (char_u *)line_ga.ga_data;
p < (char_u *)line_ga.ga_data + line_ga.ga_len; ++p)
{
if (*p == TAB)
{
do
{
msg_putchar(' ');
} while (++vcol % 8);
}
else
{
msg_outtrans_len(p, 1);
vcol += char2cells(*p);
}
}
msg_clr_eos();
continue;
}
if (c1 == Ctrl_D)
{
/* Delete one shiftwidth. */
p = (char_u *)line_ga.ga_data;
if (prev_char == '0' || prev_char == '^')
{
if (prev_char == '^')
ex_keep_indent = TRUE;
indent = 0;
p[--line_ga.ga_len] = NUL;
}
else
{
p[line_ga.ga_len] = NUL;
indent = get_indent_str(p, 8);
--indent;
indent -= indent % curbuf->b_p_sw;
}
while (get_indent_str(p, 8) > indent)
{
char_u *s = skipwhite(p);
mch_memmove(s - 1, s, line_ga.ga_len - (s - p) + 1);
--line_ga.ga_len;
}
goto add_indent;
}
if (c1 == Ctrl_V || c1 == Ctrl_Q)
{
escaped = TRUE;
continue;
}
/* Ignore special key codes: mouse movement, K_IGNORE, etc. */
if (IS_SPECIAL(c1))
continue;
}
if (IS_SPECIAL(c1))
c1 = '?';
((char_u *)line_ga.ga_data)[line_ga.ga_len] = c1;
prev_char = c1;
if (c1 == '\n')
msg_putchar('\n');
else if (c1 == TAB)
{
/* Don't use chartabsize(), 'ts' can be different */
do
{
msg_putchar(' ');
} while (++vcol % 8);
}
else
{
msg_outtrans_len(
((char_u *)line_ga.ga_data) + line_ga.ga_len, 1);
vcol += char2cells(c1);
}
++line_ga.ga_len;
escaped = FALSE;
windgoto(msg_row, msg_col);
pend = (char_u *)(line_ga.ga_data) + line_ga.ga_len;
/* we are done when a NL is entered, but not when it comes after a
* backslash */
if (line_ga.ga_len > 0 && pend[-1] == '\n'
&& (line_ga.ga_len <= 1 || pend[-2] != '\\'))
{
--line_ga.ga_len;
--pend;
*pend = NUL;
break;
}
}
--no_mapping;
--allow_keys;
/* make following messages go to the next line */
msg_didout = FALSE;
msg_col = 0;
if (msg_row < Rows - 1)
++msg_row;
emsg_on_display = FALSE; /* don't want ui_delay() */
if (got_int)
ga_clear(&line_ga);
return (char_u *)line_ga.ga_data;
}
# if defined(MCH_CURSOR_SHAPE) || defined(FEAT_GUI) \
|| defined(FEAT_MOUSESHAPE) || defined(PROTO)
/*
* Return TRUE if ccline.overstrike is on.
*/
int
cmdline_overstrike()
{
return ccline.overstrike;
}
/*
* Return TRUE if the cursor is at the end of the cmdline.
*/
int
cmdline_at_end()
{
return (ccline.cmdpos >= ccline.cmdlen);
}
#endif
#if (defined(FEAT_XIM) && (defined(FEAT_GUI_GTK))) || defined(PROTO)
/*
* Return the virtual column number at the current cursor position.
* This is used by the IM code to obtain the start of the preedit string.
*/
colnr_T
cmdline_getvcol_cursor()
{
if (ccline.cmdbuff == NULL || ccline.cmdpos > ccline.cmdlen)
return MAXCOL;
# ifdef FEAT_MBYTE
if (has_mbyte)
{
colnr_T col;
int i = 0;
for (col = 0; i < ccline.cmdpos; ++col)
i += (*mb_ptr2len)(ccline.cmdbuff + i);
return col;
}
else
# endif
return ccline.cmdpos;
}
#endif
#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
/*
* If part of the command line is an IM preedit string, redraw it with
* IM feedback attributes. The cursor position is restored after drawing.
*/
static void
redrawcmd_preedit()
{
if ((State & CMDLINE)
&& xic != NULL
/* && im_get_status() doesn't work when using SCIM */
&& !p_imdisable
&& im_is_preediting())
{
int cmdpos = 0;
int cmdspos;
int old_row;
int old_col;
colnr_T col;
old_row = msg_row;
old_col = msg_col;
cmdspos = ((ccline.cmdfirstc != NUL) ? 1 : 0) + ccline.cmdindent;
# ifdef FEAT_MBYTE
if (has_mbyte)
{
for (col = 0; col < preedit_start_col
&& cmdpos < ccline.cmdlen; ++col)
{
cmdspos += (*mb_ptr2cells)(ccline.cmdbuff + cmdpos);
cmdpos += (*mb_ptr2len)(ccline.cmdbuff + cmdpos);
}
}
else
# endif
{
cmdspos += preedit_start_col;
cmdpos += preedit_start_col;
}
msg_row = cmdline_row + (cmdspos / (int)Columns);
msg_col = cmdspos % (int)Columns;
if (msg_row >= Rows)
msg_row = Rows - 1;
for (col = 0; cmdpos < ccline.cmdlen; ++col)
{
int char_len;
int char_attr;
char_attr = im_get_feedback_attr(col);
if (char_attr < 0)
break; /* end of preedit string */
# ifdef FEAT_MBYTE
if (has_mbyte)
char_len = (*mb_ptr2len)(ccline.cmdbuff + cmdpos);
else
# endif
char_len = 1;
msg_outtrans_len_attr(ccline.cmdbuff + cmdpos, char_len, char_attr);
cmdpos += char_len;
}
msg_row = old_row;
msg_col = old_col;
}
}
#endif /* FEAT_XIM && FEAT_GUI_GTK */
/*
* Allocate a new command line buffer.
* Assigns the new buffer to ccline.cmdbuff and ccline.cmdbufflen.
* Returns the new value of ccline.cmdbuff and ccline.cmdbufflen.
*/
static void
alloc_cmdbuff(len)
int len;
{
/*
* give some extra space to avoid having to allocate all the time
*/
if (len < 80)
len = 100;
else
len += 20;
ccline.cmdbuff = alloc(len); /* caller should check for out-of-memory */
ccline.cmdbufflen = len;
}
/*
* Re-allocate the command line to length len + something extra.
* return FAIL for failure, OK otherwise
*/
static int
realloc_cmdbuff(len)
int len;
{
char_u *p;
p = ccline.cmdbuff;
alloc_cmdbuff(len); /* will get some more */
if (ccline.cmdbuff == NULL) /* out of memory */
{
ccline.cmdbuff = p; /* keep the old one */
return FAIL;
}
mch_memmove(ccline.cmdbuff, p, (size_t)ccline.cmdlen + 1);
vim_free(p);
return OK;
}
#if defined(FEAT_ARABIC) || defined(PROTO)
static char_u *arshape_buf = NULL;
# if defined(EXITFREE) || defined(PROTO)
void
free_cmdline_buf()
{
vim_free(arshape_buf);
}
# endif
#endif
/*
* Draw part of the cmdline at the current cursor position. But draw stars
* when cmdline_star is TRUE.
*/
static void
draw_cmdline(start, len)
int start;
int len;
{
#if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
int i;
if (cmdline_star > 0)
for (i = 0; i < len; ++i)
{
msg_putchar('*');
# ifdef FEAT_MBYTE
if (has_mbyte)
i += (*mb_ptr2len)(ccline.cmdbuff + start + i) - 1;
# endif
}
else
#endif
#ifdef FEAT_ARABIC
if (p_arshape && !p_tbidi && enc_utf8 && len > 0)
{
static int buflen = 0;
char_u *p;
int j;
int newlen = 0;
int mb_l;
int pc, pc1 = 0;
int prev_c = 0;
int prev_c1 = 0;
int u8c;
int u8cc[MAX_MCO];
int nc = 0;
/*
* Do arabic shaping into a temporary buffer. This is very
* inefficient!
*/
if (len * 2 + 2 > buflen)
{
/* Re-allocate the buffer. We keep it around to avoid a lot of
* alloc()/free() calls. */
vim_free(arshape_buf);
buflen = len * 2 + 2;
arshape_buf = alloc(buflen);
if (arshape_buf == NULL)
return; /* out of memory */
}
if (utf_iscomposing(utf_ptr2char(ccline.cmdbuff + start)))
{
/* Prepend a space to draw the leading composing char on. */
arshape_buf[0] = ' ';
newlen = 1;
}
for (j = start; j < start + len; j += mb_l)
{
p = ccline.cmdbuff + j;
u8c = utfc_ptr2char_len(p, u8cc, start + len - j);
mb_l = utfc_ptr2len_len(p, start + len - j);
if (ARABIC_CHAR(u8c))
{
/* Do Arabic shaping. */
if (cmdmsg_rl)
{
/* displaying from right to left */
pc = prev_c;
pc1 = prev_c1;
prev_c1 = u8cc[0];
if (j + mb_l >= start + len)
nc = NUL;
else
nc = utf_ptr2char(p + mb_l);
}
else
{
/* displaying from left to right */
if (j + mb_l >= start + len)
pc = NUL;
else
{
int pcc[MAX_MCO];
pc = utfc_ptr2char_len(p + mb_l, pcc,
start + len - j - mb_l);
pc1 = pcc[0];
}
nc = prev_c;
}
prev_c = u8c;
u8c = arabic_shape(u8c, NULL, &u8cc[0], pc, pc1, nc);
newlen += (*mb_char2bytes)(u8c, arshape_buf + newlen);
if (u8cc[0] != 0)
{
newlen += (*mb_char2bytes)(u8cc[0], arshape_buf + newlen);
if (u8cc[1] != 0)
newlen += (*mb_char2bytes)(u8cc[1],
arshape_buf + newlen);
}
}
else
{
prev_c = u8c;
mch_memmove(arshape_buf + newlen, p, mb_l);
newlen += mb_l;
}
}
msg_outtrans_len(arshape_buf, newlen);
}
else
#endif
msg_outtrans_len(ccline.cmdbuff + start, len);
}
/*
* Put a character on the command line. Shifts the following text to the
* right when "shift" is TRUE. Used for CTRL-V, CTRL-K, etc.
* "c" must be printable (fit in one display cell)!
*/
void
putcmdline(c, shift)
int c;
int shift;
{
if (cmd_silent)
return;
msg_no_more = TRUE;
msg_putchar(c);
if (shift)
draw_cmdline(ccline.cmdpos, ccline.cmdlen - ccline.cmdpos);
msg_no_more = FALSE;
cursorcmd();
}
/*
* Undo a putcmdline(c, FALSE).
*/
void
unputcmdline()
{
if (cmd_silent)
return;
msg_no_more = TRUE;
if (ccline.cmdlen == ccline.cmdpos)
msg_putchar(' ');
else
draw_cmdline(ccline.cmdpos, 1);
msg_no_more = FALSE;
cursorcmd();
}
/*
* Put the given string, of the given length, onto the command line.
* If len is -1, then STRLEN() is used to calculate the length.
* If 'redraw' is TRUE then the new part of the command line, and the remaining
* part will be redrawn, otherwise it will not. If this function is called
* twice in a row, then 'redraw' should be FALSE and redrawcmd() should be
* called afterwards.
*/
int
put_on_cmdline(str, len, redraw)
char_u *str;
int len;
int redraw;
{
int retval;
int i;
int m;
int c;
if (len < 0)
len = (int)STRLEN(str);
/* Check if ccline.cmdbuff needs to be longer */
if (ccline.cmdlen + len + 1 >= ccline.cmdbufflen)
retval = realloc_cmdbuff(ccline.cmdlen + len);
else
retval = OK;
if (retval == OK)
{
if (!ccline.overstrike)
{
mch_memmove(ccline.cmdbuff + ccline.cmdpos + len,
ccline.cmdbuff + ccline.cmdpos,
(size_t)(ccline.cmdlen - ccline.cmdpos));
ccline.cmdlen += len;
}
else
{
#ifdef FEAT_MBYTE
if (has_mbyte)
{
/* Count nr of characters in the new string. */
m = 0;
for (i = 0; i < len; i += (*mb_ptr2len)(str + i))
++m;
/* Count nr of bytes in cmdline that are overwritten by these
* characters. */
for (i = ccline.cmdpos; i < ccline.cmdlen && m > 0;
i += (*mb_ptr2len)(ccline.cmdbuff + i))
--m;
if (i < ccline.cmdlen)
{
mch_memmove(ccline.cmdbuff + ccline.cmdpos + len,
ccline.cmdbuff + i, (size_t)(ccline.cmdlen - i));
ccline.cmdlen += ccline.cmdpos + len - i;
}
else
ccline.cmdlen = ccline.cmdpos + len;
}
else
#endif
if (ccline.cmdpos + len > ccline.cmdlen)
ccline.cmdlen = ccline.cmdpos + len;
}
mch_memmove(ccline.cmdbuff + ccline.cmdpos, str, (size_t)len);
ccline.cmdbuff[ccline.cmdlen] = NUL;
#ifdef FEAT_MBYTE
if (enc_utf8)
{
/* When the inserted text starts with a composing character,
* backup to the character before it. There could be two of them.
*/
i = 0;
c = utf_ptr2char(ccline.cmdbuff + ccline.cmdpos);
while (ccline.cmdpos > 0 && utf_iscomposing(c))
{
i = (*mb_head_off)(ccline.cmdbuff,
ccline.cmdbuff + ccline.cmdpos - 1) + 1;
ccline.cmdpos -= i;
len += i;
c = utf_ptr2char(ccline.cmdbuff + ccline.cmdpos);
}
# ifdef FEAT_ARABIC
if (i == 0 && ccline.cmdpos > 0 && arabic_maycombine(c))
{
/* Check the previous character for Arabic combining pair. */
i = (*mb_head_off)(ccline.cmdbuff,
ccline.cmdbuff + ccline.cmdpos - 1) + 1;
if (arabic_combine(utf_ptr2char(ccline.cmdbuff
+ ccline.cmdpos - i), c))
{
ccline.cmdpos -= i;
len += i;
}
else
i = 0;
}
# endif
if (i != 0)
{
/* Also backup the cursor position. */
i = ptr2cells(ccline.cmdbuff + ccline.cmdpos);
ccline.cmdspos -= i;
msg_col -= i;
if (msg_col < 0)
{
msg_col += Columns;
--msg_row;
}
}
}
#endif
if (redraw && !cmd_silent)
{
msg_no_more = TRUE;
i = cmdline_row;
draw_cmdline(ccline.cmdpos, ccline.cmdlen - ccline.cmdpos);
/* Avoid clearing the rest of the line too often. */
if (cmdline_row != i || ccline.overstrike)
msg_clr_eos();
msg_no_more = FALSE;
}
#ifdef FEAT_FKMAP
/*
* If we are in Farsi command mode, the character input must be in
* Insert mode. So do not advance the cmdpos.
*/
if (!cmd_fkmap)
#endif
{
if (KeyTyped)
{
m = Columns * Rows;
if (m < 0) /* overflow, Columns or Rows at weird value */
m = MAXCOL;
}
else
m = MAXCOL;
for (i = 0; i < len; ++i)
{
c = cmdline_charsize(ccline.cmdpos);
#ifdef FEAT_MBYTE
/* count ">" for a double-wide char that doesn't fit. */
if (has_mbyte)
correct_cmdspos(ccline.cmdpos, c);
#endif
/* Stop cursor at the end of the screen */
if (ccline.cmdspos + c >= m)
break;
ccline.cmdspos += c;
#ifdef FEAT_MBYTE
if (has_mbyte)
{
c = (*mb_ptr2len)(ccline.cmdbuff + ccline.cmdpos) - 1;
if (c > len - i - 1)
c = len - i - 1;
ccline.cmdpos += c;
i += c;
}
#endif
++ccline.cmdpos;
}
}
}
if (redraw)
msg_check();
return retval;
}
static struct cmdline_info prev_ccline;
static int prev_ccline_used = FALSE;
/*
* Save ccline, because obtaining the "=" register may execute "normal :cmd"
* and overwrite it. But get_cmdline_str() may need it, thus make it
* available globally in prev_ccline.
*/
static void
save_cmdline(ccp)
struct cmdline_info *ccp;
{
if (!prev_ccline_used)
{
vim_memset(&prev_ccline, 0, sizeof(struct cmdline_info));
prev_ccline_used = TRUE;
}
*ccp = prev_ccline;
prev_ccline = ccline;
ccline.cmdbuff = NULL;
ccline.cmdprompt = NULL;
}
/*
* Restore ccline after it has been saved with save_cmdline().
*/
static void
restore_cmdline(ccp)
struct cmdline_info *ccp;
{
ccline = prev_ccline;
prev_ccline = *ccp;
}
#if defined(FEAT_EVAL) || defined(PROTO)
/*
* Save the command line into allocated memory. Returns a pointer to be
* passed to restore_cmdline_alloc() later.
* Returns NULL when failed.
*/
char_u *
save_cmdline_alloc()
{
struct cmdline_info *p;
p = (struct cmdline_info *)alloc((unsigned)sizeof(struct cmdline_info));
if (p != NULL)
save_cmdline(p);
return (char_u *)p;
}
/*
* Restore the command line from the return value of save_cmdline_alloc().
*/
void
restore_cmdline_alloc(p)
char_u *p;
{
if (p != NULL)
{
restore_cmdline((struct cmdline_info *)p);
vim_free(p);
}
}
#endif
/*
* paste a yank register into the command line.
* used by CTRL-R command in command-line mode
* insert_reg() can't be used here, because special characters from the
* register contents will be interpreted as commands.
*
* return FAIL for failure, OK otherwise
*/
static int
cmdline_paste(regname, literally, remcr)
int regname;
int literally; /* Insert text literally instead of "as typed" */
int remcr; /* remove trailing CR */
{
long i;
char_u *arg;
char_u *p;
int allocated;
struct cmdline_info save_ccline;
/* check for valid regname; also accept special characters for CTRL-R in
* the command line */
if (regname != Ctrl_F && regname != Ctrl_P && regname != Ctrl_W
&& regname != Ctrl_A && !valid_yank_reg(regname, FALSE))
return FAIL;
/* A register containing CTRL-R can cause an endless loop. Allow using
* CTRL-C to break the loop. */
line_breakcheck();
if (got_int)
return FAIL;
#ifdef FEAT_CLIPBOARD
regname = may_get_selection(regname);
#endif
/* Need to save and restore ccline. And set "textlock" to avoid nasty
* things like going to another buffer when evaluating an expression. */
save_cmdline(&save_ccline);
++textlock;
i = get_spec_reg(regname, &arg, &allocated, TRUE);
--textlock;
restore_cmdline(&save_ccline);
if (i)
{
/* Got the value of a special register in "arg". */
if (arg == NULL)
return FAIL;
/* When 'incsearch' is set and CTRL-R CTRL-W used: skip the duplicate
* part of the word. */
p = arg;
if (p_is && regname == Ctrl_W)
{
char_u *w;
int len;
/* Locate start of last word in the cmd buffer. */
for (w = ccline.cmdbuff + ccline.cmdlen; w > ccline.cmdbuff; )
{
#ifdef FEAT_MBYTE
if (has_mbyte)
{
len = (*mb_head_off)(ccline.cmdbuff, w - 1) + 1;
if (!vim_iswordc(mb_ptr2char(w - len)))
break;
w -= len;
}
else
#endif
{
if (!vim_iswordc(w[-1]))
break;
--w;
}
}
len = (int)((ccline.cmdbuff + ccline.cmdlen) - w);
if (p_ic ? STRNICMP(w, arg, len) == 0 : STRNCMP(w, arg, len) == 0)
p += len;
}
cmdline_paste_str(p, literally);
if (allocated)
vim_free(arg);
return OK;
}
return cmdline_paste_reg(regname, literally, remcr);
}
/*
* Put a string on the command line.
* When "literally" is TRUE, insert literally.
* When "literally" is FALSE, insert as typed, but don't leave the command
* line.
*/
void
cmdline_paste_str(s, literally)
char_u *s;
int literally;
{
int c, cv;
if (literally)
put_on_cmdline(s, -1, TRUE);
else
while (*s != NUL)
{
cv = *s;
if (cv == Ctrl_V && s[1])
++s;
#ifdef FEAT_MBYTE
if (has_mbyte)
{
c = mb_ptr2char(s);
s += mb_char2len(c);
}
else
#endif
c = *s++;
if (cv == Ctrl_V || c == ESC || c == Ctrl_C || c == CAR || c == NL
#ifdef UNIX
|| c == intr_char
#endif
|| (c == Ctrl_BSL && *s == Ctrl_N))
stuffcharReadbuff(Ctrl_V);
stuffcharReadbuff(c);
}
}
#ifdef FEAT_WILDMENU
/*
* Delete characters on the command line, from "from" to the current
* position.
*/
static void
cmdline_del(from)
int from;
{
mch_memmove(ccline.cmdbuff + from, ccline.cmdbuff + ccline.cmdpos,
(size_t)(ccline.cmdlen - ccline.cmdpos + 1));
ccline.cmdlen -= ccline.cmdpos - from;
ccline.cmdpos = from;
}
#endif
/*
* this function is called when the screen size changes and with incremental
* search
*/
void
redrawcmdline()
{
if (cmd_silent)
return;
need_wait_return = FALSE;
compute_cmdrow();
redrawcmd();
cursorcmd();
}
static void
redrawcmdprompt()
{
int i;
if (cmd_silent)
return;
if (ccline.cmdfirstc != NUL)
msg_putchar(ccline.cmdfirstc);
if (ccline.cmdprompt != NULL)
{
msg_puts_attr(ccline.cmdprompt, ccline.cmdattr);
ccline.cmdindent = msg_col + (msg_row - cmdline_row) * Columns;
/* do the reverse of set_cmdspos() */
if (ccline.cmdfirstc != NUL)
--ccline.cmdindent;
}
else
for (i = ccline.cmdindent; i > 0; --i)
msg_putchar(' ');
}
/*
* Redraw what is currently on the command line.
*/
void
redrawcmd()
{
if (cmd_silent)
return;
/* when 'incsearch' is set there may be no command line while redrawing */
if (ccline.cmdbuff == NULL)
{
windgoto(cmdline_row, 0);
msg_clr_eos();
return;
}
msg_start();
redrawcmdprompt();
/* Don't use more prompt, truncate the cmdline if it doesn't fit. */
msg_no_more = TRUE;
draw_cmdline(0, ccline.cmdlen);
msg_clr_eos();
msg_no_more = FALSE;
set_cmdspos_cursor();
/*
* An emsg() before may have set msg_scroll. This is used in normal mode,
* in cmdline mode we can reset them now.
*/
msg_scroll = FALSE; /* next message overwrites cmdline */
/* Typing ':' at the more prompt may set skip_redraw. We don't want this
* in cmdline mode */
skip_redraw = FALSE;
}
void
compute_cmdrow()
{
if (exmode_active || msg_scrolled != 0)
cmdline_row = Rows - 1;
else
cmdline_row = W_WINROW(lastwin) + lastwin->w_height
+ W_STATUS_HEIGHT(lastwin);
}
static void
cursorcmd()
{
if (cmd_silent)
return;
#ifdef FEAT_RIGHTLEFT
if (cmdmsg_rl)
{
msg_row = cmdline_row + (ccline.cmdspos / (int)(Columns - 1));
msg_col = (int)Columns - (ccline.cmdspos % (int)(Columns - 1)) - 1;
if (msg_row <= 0)
msg_row = Rows - 1;
}
else
#endif
{
msg_row = cmdline_row + (ccline.cmdspos / (int)Columns);
msg_col = ccline.cmdspos % (int)Columns;
if (msg_row >= Rows)
msg_row = Rows - 1;
}
windgoto(msg_row, msg_col);
#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
redrawcmd_preedit();
#endif
#ifdef MCH_CURSOR_SHAPE
mch_update_cursor();
#endif
}
void
gotocmdline(clr)
int clr;
{
msg_start();
#ifdef FEAT_RIGHTLEFT
if (cmdmsg_rl)
msg_col = Columns - 1;
else
#endif
msg_col = 0; /* always start in column 0 */
if (clr) /* clear the bottom line(s) */
msg_clr_eos(); /* will reset clear_cmdline */
windgoto(cmdline_row, 0);
}
/*
* Check the word in front of the cursor for an abbreviation.
* Called when the non-id character "c" has been entered.
* When an abbreviation is recognized it is removed from the text with
* backspaces and the replacement string is inserted, followed by "c".
*/
static int
ccheck_abbr(c)
int c;
{
if (p_paste || no_abbr) /* no abbreviations or in paste mode */
return FALSE;
return check_abbr(c, ccline.cmdbuff, ccline.cmdpos, 0);
}
/*
* Return FAIL if this is not an appropriate context in which to do
* completion of anything, return OK if it is (even if there are no matches).
* For the caller, this means that the character is just passed through like a
* normal character (instead of being expanded). This allows :s/^I^D etc.
*/
static int
nextwild(xp, type, options)
expand_T *xp;
int type;
int options; /* extra options for ExpandOne() */
{
int i, j;
char_u *p1;
char_u *p2;
int oldlen;
int difflen;
int v;
if (xp->xp_numfiles == -1)
{
set_expand_context(xp);
cmd_showtail = expand_showtail(xp);
}
if (xp->xp_context == EXPAND_UNSUCCESSFUL)
{
beep_flush();
return OK; /* Something illegal on command line */
}
if (xp->xp_context == EXPAND_NOTHING)
{
/* Caller can use the character as a normal char instead */
return FAIL;
}
MSG_PUTS("..."); /* show that we are busy */
out_flush();
i = (int)(xp->xp_pattern - ccline.cmdbuff);
oldlen = ccline.cmdpos - i;
if (type == WILD_NEXT || type == WILD_PREV)
{
/*
* Get next/previous match for a previous expanded pattern.
*/
p2 = ExpandOne(xp, NULL, NULL, 0, type);
}
else
{
/*
* Translate string into pattern and expand it.
*/
if ((p1 = addstar(&ccline.cmdbuff[i], oldlen, xp->xp_context)) == NULL)
p2 = NULL;
else
{
p2 = ExpandOne(xp, p1, vim_strnsave(&ccline.cmdbuff[i], oldlen),
WILD_HOME_REPLACE|WILD_ADD_SLASH|WILD_SILENT|WILD_ESCAPE
|options, type);
vim_free(p1);
/* longest match: make sure it is not shorter (happens with :help */
if (p2 != NULL && type == WILD_LONGEST)
{
for (j = 0; j < oldlen; ++j)
if (ccline.cmdbuff[i + j] == '*'
|| ccline.cmdbuff[i + j] == '?')
break;
if ((int)STRLEN(p2) < j)
{
vim_free(p2);
p2 = NULL;
}
}
}
}
if (p2 != NULL && !got_int)
{
difflen = (int)STRLEN(p2) - oldlen;
if (ccline.cmdlen + difflen > ccline.cmdbufflen - 4)
{
v = realloc_cmdbuff(ccline.cmdlen + difflen);
xp->xp_pattern = ccline.cmdbuff + i;
}
else
v = OK;
if (v == OK)
{
mch_memmove(&ccline.cmdbuff[ccline.cmdpos + difflen],
&ccline.cmdbuff[ccline.cmdpos],
(size_t)(ccline.cmdlen - ccline.cmdpos + 1));
mch_memmove(&ccline.cmdbuff[i], p2, STRLEN(p2));
ccline.cmdlen += difflen;
ccline.cmdpos += difflen;
}
}
vim_free(p2);
redrawcmd();
cursorcmd();
/* When expanding a ":map" command and no matches are found, assume that
* the key is supposed to be inserted literally */
if (xp->xp_context == EXPAND_MAPPINGS && p2 == NULL)
return FAIL;
if (xp->xp_numfiles <= 0 && p2 == NULL)
beep_flush();
else if (xp->xp_numfiles == 1)
/* free expanded pattern */
(void)ExpandOne(xp, NULL, NULL, 0, WILD_FREE);
return OK;
}
/*
* Do wildcard expansion on the string 'str'.
* Chars that should not be expanded must be preceded with a backslash.
* Return a pointer to alloced memory containing the new string.
* Return NULL for failure.
*
* Results are cached in xp->xp_files and xp->xp_numfiles, except when "mode"
* is WILD_EXPAND_FREE or WILD_ALL.
*
* mode = WILD_FREE: just free previously expanded matches
* mode = WILD_EXPAND_FREE: normal expansion, do not keep matches
* mode = WILD_EXPAND_KEEP: normal expansion, keep matches
* mode = WILD_NEXT: use next match in multiple match, wrap to first
* mode = WILD_PREV: use previous match in multiple match, wrap to first
* mode = WILD_ALL: return all matches concatenated
* mode = WILD_LONGEST: return longest matched part
*
* options = WILD_LIST_NOTFOUND: list entries without a match
* options = WILD_HOME_REPLACE: do home_replace() for buffer names
* options = WILD_USE_NL: Use '\n' for WILD_ALL
* options = WILD_NO_BEEP: Don't beep for multiple matches
* options = WILD_ADD_SLASH: add a slash after directory names
* options = WILD_KEEP_ALL: don't remove 'wildignore' entries
* options = WILD_SILENT: don't print warning messages
* options = WILD_ESCAPE: put backslash before special chars
*
* The variables xp->xp_context and xp->xp_backslash must have been set!
*/
char_u *
ExpandOne(xp, str, orig, options, mode)
expand_T *xp;
char_u *str;
char_u *orig; /* allocated copy of original of expanded string */
int options;
int mode;
{
char_u *ss = NULL;
static int findex;
static char_u *orig_save = NULL; /* kept value of orig */
int i;
long_u len;
int non_suf_match; /* number without matching suffix */
/*
* first handle the case of using an old match
*/
if (mode == WILD_NEXT || mode == WILD_PREV)
{
if (xp->xp_numfiles > 0)
{
if (mode == WILD_PREV)
{
if (findex == -1)
findex = xp->xp_numfiles;
--findex;
}
else /* mode == WILD_NEXT */
++findex;
/*
* When wrapping around, return the original string, set findex to
* -1.
*/
if (findex < 0)
{
if (orig_save == NULL)
findex = xp->xp_numfiles - 1;
else
findex = -1;
}
if (findex >= xp->xp_numfiles)
{
if (orig_save == NULL)
findex = 0;
else
findex = -1;
}
#ifdef FEAT_WILDMENU
if (p_wmnu)
win_redr_status_matches(xp, xp->xp_numfiles, xp->xp_files,
findex, cmd_showtail);
#endif
if (findex == -1)
return vim_strsave(orig_save);
return vim_strsave(xp->xp_files[findex]);
}
else
return NULL;
}
/* free old names */
if (xp->xp_numfiles != -1 && mode != WILD_ALL && mode != WILD_LONGEST)
{
FreeWild(xp->xp_numfiles, xp->xp_files);
xp->xp_numfiles = -1;
vim_free(orig_save);
orig_save = NULL;
}
findex = 0;
if (mode == WILD_FREE) /* only release file name */
return NULL;
if (xp->xp_numfiles == -1)
{
vim_free(orig_save);
orig_save = orig;
/*
* Do the expansion.
*/
if (ExpandFromContext(xp, str, &xp->xp_numfiles, &xp->xp_files,
options) == FAIL)
{
#ifdef FNAME_ILLEGAL
/* Illegal file name has been silently skipped. But when there
* are wildcards, the real problem is that there was no match,
* causing the pattern to be added, which has illegal characters.
*/
if (!(options & WILD_SILENT) && (options & WILD_LIST_NOTFOUND))
EMSG2(_(e_nomatch2), str);
#endif
}
else if (xp->xp_numfiles == 0)
{
if (!(options & WILD_SILENT))
EMSG2(_(e_nomatch2), str);
}
else
{
/* Escape the matches for use on the command line. */
ExpandEscape(xp, str, xp->xp_numfiles, xp->xp_files, options);
/*
* Check for matching suffixes in file names.
*/
if (mode != WILD_ALL && mode != WILD_LONGEST)
{
if (xp->xp_numfiles)
non_suf_match = xp->xp_numfiles;
else
non_suf_match = 1;
if ((xp->xp_context == EXPAND_FILES
|| xp->xp_context == EXPAND_DIRECTORIES)
&& xp->xp_numfiles > 1)
{
/*
* More than one match; check suffix.
* The files will have been sorted on matching suffix in
* expand_wildcards, only need to check the first two.
*/
non_suf_match = 0;
for (i = 0; i < 2; ++i)
if (match_suffix(xp->xp_files[i]))
++non_suf_match;
}
if (non_suf_match != 1)
{
/* Can we ever get here unless it's while expanding
* interactively? If not, we can get rid of this all
* together. Don't really want to wait for this message
* (and possibly have to hit return to continue!).
*/
if (!(options & WILD_SILENT))
EMSG(_(e_toomany));
else if (!(options & WILD_NO_BEEP))
beep_flush();
}
if (!(non_suf_match != 1 && mode == WILD_EXPAND_FREE))
ss = vim_strsave(xp->xp_files[0]);
}
}
}
/* Find longest common part */
if (mode == WILD_LONGEST && xp->xp_numfiles > 0)
{
for (len = 0; xp->xp_files[0][len]; ++len)
{
for (i = 0; i < xp->xp_numfiles; ++i)
{
#ifdef CASE_INSENSITIVE_FILENAME
if (xp->xp_context == EXPAND_DIRECTORIES
|| xp->xp_context == EXPAND_FILES
|| xp->xp_context == EXPAND_SHELLCMD
|| xp->xp_context == EXPAND_BUFFERS)
{
if (TOLOWER_LOC(xp->xp_files[i][len]) !=
TOLOWER_LOC(xp->xp_files[0][len]))
break;
}
else
#endif
if (xp->xp_files[i][len] != xp->xp_files[0][len])
break;
}
if (i < xp->xp_numfiles)
{
if (!(options & WILD_NO_BEEP))
vim_beep();
break;
}
}
ss = alloc((unsigned)len + 1);
if (ss)
vim_strncpy(ss, xp->xp_files[0], (size_t)len);
findex = -1; /* next p_wc gets first one */
}
/* Concatenate all matching names */
if (mode == WILD_ALL && xp->xp_numfiles > 0)
{
len = 0;
for (i = 0; i < xp->xp_numfiles; ++i)
len += (long_u)STRLEN(xp->xp_files[i]) + 1;
ss = lalloc(len, TRUE);
if (ss != NULL)
{
*ss = NUL;
for (i = 0; i < xp->xp_numfiles; ++i)
{
STRCAT(ss, xp->xp_files[i]);
if (i != xp->xp_numfiles - 1)
STRCAT(ss, (options & WILD_USE_NL) ? "\n" : " ");
}
}
}
if (mode == WILD_EXPAND_FREE || mode == WILD_ALL)
ExpandCleanup(xp);
return ss;
}
/*
* Prepare an expand structure for use.
*/
void
ExpandInit(xp)
expand_T *xp;
{
xp->xp_backslash = XP_BS_NONE;
#ifndef BACKSLASH_IN_FILENAME
xp->xp_shell = FALSE;
#endif
xp->xp_numfiles = -1;
xp->xp_files = NULL;
#if defined(FEAT_USR_CMDS) && defined(FEAT_EVAL) && defined(FEAT_CMDL_COMPL)
xp->xp_arg = NULL;
#endif
}
/*
* Cleanup an expand structure after use.
*/
void
ExpandCleanup(xp)
expand_T *xp;
{
if (xp->xp_numfiles >= 0)
{
FreeWild(xp->xp_numfiles, xp->xp_files);
xp->xp_numfiles = -1;
}
}
void
ExpandEscape(xp, str, numfiles, files, options)
expand_T *xp;
char_u *str;
int numfiles;
char_u **files;
int options;
{
int i;
char_u *p;
/*
* May change home directory back to "~"
*/
if (options & WILD_HOME_REPLACE)
tilde_replace(str, numfiles, files);
if (options & WILD_ESCAPE)
{
if (xp->xp_context == EXPAND_FILES
|| xp->xp_context == EXPAND_SHELLCMD
|| xp->xp_context == EXPAND_BUFFERS
|| xp->xp_context == EXPAND_DIRECTORIES)
{
/*
* Insert a backslash into a file name before a space, \, %, #
* and wildmatch characters, except '~'.
*/
for (i = 0; i < numfiles; ++i)
{
/* for ":set path=" we need to escape spaces twice */
if (xp->xp_backslash == XP_BS_THREE)
{
p = vim_strsave_escaped(files[i], (char_u *)" ");
if (p != NULL)
{
vim_free(files[i]);
files[i] = p;
#if defined(BACKSLASH_IN_FILENAME)
p = vim_strsave_escaped(files[i], (char_u *)" ");
if (p != NULL)
{
vim_free(files[i]);
files[i] = p;
}
#endif
}
}
#ifdef BACKSLASH_IN_FILENAME
{
char_u buf[20];
int j = 0;
/* Don't escape '[' and '{' if they are in 'isfname'. */
for (p = PATH_ESC_CHARS; *p != NUL; ++p)
if ((*p != '[' && *p != '{') || !vim_isfilec(*p))
buf[j++] = *p;
buf[j] = NUL;
p = vim_strsave_escaped(files[i], buf);
}
#else
p = vim_strsave_escaped(files[i],
xp->xp_shell ? SHELL_ESC_CHARS : PATH_ESC_CHARS);
#endif
if (p != NULL)
{
vim_free(files[i]);
files[i] = p;
}
/* If 'str' starts with "\~", replace "~" at start of
* files[i] with "\~". */
if (str[0] == '\\' && str[1] == '~' && files[i][0] == '~')
escape_fname(&files[i]);
}
xp->xp_backslash = XP_BS_NONE;
/* If the first file starts with a '+' escape it. Otherwise it
* could be seen as "+cmd". */
if (*files[0] == '+')
escape_fname(&files[0]);
}
else if (xp->xp_context == EXPAND_TAGS)
{
/*
* Insert a backslash before characters in a tag name that
* would terminate the ":tag" command.
*/
for (i = 0; i < numfiles; ++i)
{
p = vim_strsave_escaped(files[i], (char_u *)"\\|\"");
if (p != NULL)
{
vim_free(files[i]);
files[i] = p;
}
}
}
}
}
/*
* Put a backslash before the file name in "pp", which is in allocated memory.
*/
static void
escape_fname(pp)
char_u **pp;
{
char_u *p;
p = alloc((unsigned)(STRLEN(*pp) + 2));
if (p != NULL)
{
p[0] = '\\';
STRCPY(p + 1, *pp);
vim_free(*pp);
*pp = p;
}
}
/*
* For each file name in files[num_files]:
* If 'orig_pat' starts with "~/", replace the home directory with "~".
*/
void
tilde_replace(orig_pat, num_files, files)
char_u *orig_pat;
int num_files;
char_u **files;
{
int i;
char_u *p;
if (orig_pat[0] == '~' && vim_ispathsep(orig_pat[1]))
{
for (i = 0; i < num_files; ++i)
{
p = home_replace_save(NULL, files[i]);
if (p != NULL)
{
vim_free(files[i]);
files[i] = p;
}
}
}
}
/*
* Show all matches for completion on the command line.
* Returns EXPAND_NOTHING when the character that triggered expansion should
* be inserted like a normal character.
*/
/*ARGSUSED*/
static int
showmatches(xp, wildmenu)
expand_T *xp;
int wildmenu;
{
#define L_SHOWFILE(m) (showtail ? sm_gettail(files_found[m]) : files_found[m])
int num_files;
char_u **files_found;
int i, j, k;
int maxlen;
int lines;
int columns;
char_u *p;
int lastlen;
int attr;
int showtail;
if (xp->xp_numfiles == -1)
{
set_expand_context(xp);
i = expand_cmdline(xp, ccline.cmdbuff, ccline.cmdpos,
&num_files, &files_found);
showtail = expand_showtail(xp);
if (i != EXPAND_OK)
return i;
}
else
{
num_files = xp->xp_numfiles;
files_found = xp->xp_files;
showtail = cmd_showtail;
}
#ifdef FEAT_WILDMENU
if (!wildmenu)
{
#endif
msg_didany = FALSE; /* lines_left will be set */
msg_start(); /* prepare for paging */
msg_putchar('\n');
out_flush();
cmdline_row = msg_row;
msg_didany = FALSE; /* lines_left will be set again */
msg_start(); /* prepare for paging */
#ifdef FEAT_WILDMENU
}
#endif
if (got_int)
got_int = FALSE; /* only int. the completion, not the cmd line */
#ifdef FEAT_WILDMENU
else if (wildmenu)
win_redr_status_matches(xp, num_files, files_found, 0, showtail);
#endif
else
{
/* find the length of the longest file name */
maxlen = 0;
for (i = 0; i < num_files; ++i)
{
if (!showtail && (xp->xp_context == EXPAND_FILES
|| xp->xp_context == EXPAND_SHELLCMD
|| xp->xp_context == EXPAND_BUFFERS))
{
home_replace(NULL, files_found[i], NameBuff, MAXPATHL, TRUE);
j = vim_strsize(NameBuff);
}
else
j = vim_strsize(L_SHOWFILE(i));
if (j > maxlen)
maxlen = j;
}
if (xp->xp_context == EXPAND_TAGS_LISTFILES)
lines = num_files;
else
{
/* compute the number of columns and lines for the listing */
maxlen += 2; /* two spaces between file names */
columns = ((int)Columns + 2) / maxlen;
if (columns < 1)
columns = 1;
lines = (num_files + columns - 1) / columns;
}
attr = hl_attr(HLF_D); /* find out highlighting for directories */
if (xp->xp_context == EXPAND_TAGS_LISTFILES)
{
MSG_PUTS_ATTR(_("tagname"), hl_attr(HLF_T));
msg_clr_eos();
msg_advance(maxlen - 3);
MSG_PUTS_ATTR(_(" kind file\n"), hl_attr(HLF_T));
}
/* list the files line by line */
for (i = 0; i < lines; ++i)
{
lastlen = 999;
for (k = i; k < num_files; k += lines)
{
if (xp->xp_context == EXPAND_TAGS_LISTFILES)
{
msg_outtrans_attr(files_found[k], hl_attr(HLF_D));
p = files_found[k] + STRLEN(files_found[k]) + 1;
msg_advance(maxlen + 1);
msg_puts(p);
msg_advance(maxlen + 3);
msg_puts_long_attr(p + 2, hl_attr(HLF_D));
break;
}
for (j = maxlen - lastlen; --j >= 0; )
msg_putchar(' ');
if (xp->xp_context == EXPAND_FILES
|| xp->xp_context == EXPAND_SHELLCMD
|| xp->xp_context == EXPAND_BUFFERS)
{
/* highlight directories */
j = (mch_isdir(files_found[k]));
if (showtail)
p = L_SHOWFILE(k);
else
{
home_replace(NULL, files_found[k], NameBuff, MAXPATHL,
TRUE);
p = NameBuff;
}
}
else
{
j = FALSE;
p = L_SHOWFILE(k);
}
lastlen = msg_outtrans_attr(p, j ? attr : 0);
}
if (msg_col > 0) /* when not wrapped around */
{
msg_clr_eos();
msg_putchar('\n');
}
out_flush(); /* show one line at a time */
if (got_int)
{
got_int = FALSE;
break;
}
}
/*
* we redraw the command below the lines that we have just listed
* This is a bit tricky, but it saves a lot of screen updating.
*/
cmdline_row = msg_row; /* will put it back later */
}
if (xp->xp_numfiles == -1)
FreeWild(num_files, files_found);
return EXPAND_OK;
}
/*
* Private gettail for showmatches() (and win_redr_status_matches()):
* Find tail of file name path, but ignore trailing "/".
*/
char_u *
sm_gettail(s)
char_u *s;
{
char_u *p;
char_u *t = s;
int had_sep = FALSE;
for (p = s; *p != NUL; )
{
if (vim_ispathsep(*p)
#ifdef BACKSLASH_IN_FILENAME
&& !rem_backslash(p)
#endif
)
had_sep = TRUE;
else if (had_sep)
{
t = p;
had_sep = FALSE;
}
mb_ptr_adv(p);
}
return t;
}
/*
* Return TRUE if we only need to show the tail of completion matches.
* When not completing file names or there is a wildcard in the path FALSE is
* returned.
*/
static int
expand_showtail(xp)
expand_T *xp;
{
char_u *s;
char_u *end;
/* When not completing file names a "/" may mean something different. */
if (xp->xp_context != EXPAND_FILES
&& xp->xp_context != EXPAND_SHELLCMD
&& xp->xp_context != EXPAND_DIRECTORIES)
return FALSE;
end = gettail(xp->xp_pattern);
if (end == xp->xp_pattern) /* there is no path separator */
return FALSE;
for (s = xp->xp_pattern; s < end; s++)
{
/* Skip escaped wildcards. Only when the backslash is not a path
* separator, on DOS the '*' "path\*\file" must not be skipped. */
if (rem_backslash(s))
++s;
else if (vim_strchr((char_u *)"*?[", *s) != NULL)
return FALSE;
}
return TRUE;
}
/*
* Prepare a string for expansion.
* When expanding file names: The string will be used with expand_wildcards().
* Copy the file name into allocated memory and add a '*' at the end.
* When expanding other names: The string will be used with regcomp(). Copy
* the name into allocated memory and prepend "^".
*/
char_u *
addstar(fname, len, context)
char_u *fname;
int len;
int context; /* EXPAND_FILES etc. */
{
char_u *retval;
int i, j;
int new_len;
char_u *tail;
if (context != EXPAND_FILES
&& context != EXPAND_SHELLCMD
&& context != EXPAND_DIRECTORIES)
{
/*
* Matching will be done internally (on something other than files).
* So we convert the file-matching-type wildcards into our kind for
* use with vim_regcomp(). First work out how long it will be:
*/
/* For help tags the translation is done in find_help_tags().
* For a tag pattern starting with "/" no translation is needed. */
if (context == EXPAND_HELP
|| context == EXPAND_COLORS
|| context == EXPAND_COMPILER
|| (context == EXPAND_TAGS && fname[0] == '/'))
retval = vim_strnsave(fname, len);
else
{
new_len = len + 2; /* +2 for '^' at start, NUL at end */
for (i = 0; i < len; i++)
{
if (fname[i] == '*' || fname[i] == '~')
new_len++; /* '*' needs to be replaced by ".*"
'~' needs to be replaced by "\~" */
/* Buffer names are like file names. "." should be literal */
if (context == EXPAND_BUFFERS && fname[i] == '.')
new_len++; /* "." becomes "\." */
/* Custom expansion takes care of special things, match
* backslashes literally (perhaps also for other types?) */
if ((context == EXPAND_USER_DEFINED
|| context == EXPAND_USER_LIST) && fname[i] == '\\')
new_len++; /* '\' becomes "\\" */
}
retval = alloc(new_len);
if (retval != NULL)
{
retval[0] = '^';
j = 1;
for (i = 0; i < len; i++, j++)
{
/* Skip backslash. But why? At least keep it for custom
* expansion. */
if (context != EXPAND_USER_DEFINED
&& context != EXPAND_USER_LIST
&& fname[i] == '\\'
&& ++i == len)
break;
switch (fname[i])
{
case '*': retval[j++] = '.';
break;
case '~': retval[j++] = '\\';
break;
case '?': retval[j] = '.';
continue;
case '.': if (context == EXPAND_BUFFERS)
retval[j++] = '\\';
break;
case '\\': if (context == EXPAND_USER_DEFINED
|| context == EXPAND_USER_LIST)
retval[j++] = '\\';
break;
}
retval[j] = fname[i];
}
retval[j] = NUL;
}
}
}
else
{
retval = alloc(len + 4);
if (retval != NULL)
{
vim_strncpy(retval, fname, len);
/*
* Don't add a star to *, ~, ~user, $var or `cmd`.
* * would become **, which walks the whole tree.
* ~ would be at the start of the file name, but not the tail.
* $ could be anywhere in the tail.
* ` could be anywhere in the file name.
*/
tail = gettail(retval);
if ((*retval != '~' || tail != retval)
&& (len == 0 || retval[len - 1] != '*')
&& vim_strchr(tail, '$') == NULL
&& vim_strchr(retval, '`') == NULL)
retval[len++] = '*';
retval[len] = NUL;
}
}
return retval;
}
/*
* Must parse the command line so far to work out what context we are in.
* Completion can then be done based on that context.
* This routine sets the variables:
* xp->xp_pattern The start of the pattern to be expanded within
* the command line (ends at the cursor).
* xp->xp_context The type of thing to expand. Will be one of:
*
* EXPAND_UNSUCCESSFUL Used sometimes when there is something illegal on
* the command line, like an unknown command. Caller
* should beep.
* EXPAND_NOTHING Unrecognised context for completion, use char like
* a normal char, rather than for completion. eg
* :s/^I/
* EXPAND_COMMANDS Cursor is still touching the command, so complete
* it.
* EXPAND_BUFFERS Complete file names for :buf and :sbuf commands.
* EXPAND_FILES After command with XFILE set, or after setting
* with P_EXPAND set. eg :e ^I, :w>>^I
* EXPAND_DIRECTORIES In some cases this is used instead of the latter
* when we know only directories are of interest. eg
* :set dir=^I
* EXPAND_SHELLCMD After ":!cmd", ":r !cmd" or ":w !cmd".
* EXPAND_SETTINGS Complete variable names. eg :set d^I
* EXPAND_BOOL_SETTINGS Complete boolean variables only, eg :set no^I
* EXPAND_TAGS Complete tags from the files in p_tags. eg :ta a^I
* EXPAND_TAGS_LISTFILES As above, but list filenames on ^D, after :tselect
* EXPAND_HELP Complete tags from the file 'helpfile'/tags
* EXPAND_EVENTS Complete event names
* EXPAND_SYNTAX Complete :syntax command arguments
* EXPAND_HIGHLIGHT Complete highlight (syntax) group names
* EXPAND_AUGROUP Complete autocommand group names
* EXPAND_USER_VARS Complete user defined variable names, eg :unlet a^I
* EXPAND_MAPPINGS Complete mapping and abbreviation names,
* eg :unmap a^I , :cunab x^I
* EXPAND_FUNCTIONS Complete internal or user defined function names,
* eg :call sub^I
* EXPAND_USER_FUNC Complete user defined function names, eg :delf F^I
* EXPAND_EXPRESSION Complete internal or user defined function/variable
* names in expressions, eg :while s^I
* EXPAND_ENV_VARS Complete environment variable names
*/
static void
set_expand_context(xp)
expand_T *xp;
{
/* only expansion for ':', '>' and '=' command-lines */
if (ccline.cmdfirstc != ':'
#ifdef FEAT_EVAL
&& ccline.cmdfirstc != '>' && ccline.cmdfirstc != '='
&& !ccline.input_fn
#endif
)
{
xp->xp_context = EXPAND_NOTHING;
return;
}
set_cmd_context(xp, ccline.cmdbuff, ccline.cmdlen, ccline.cmdpos);
}
void
set_cmd_context(xp, str, len, col)
expand_T *xp;
char_u *str; /* start of command line */
int len; /* length of command line (excl. NUL) */
int col; /* position of cursor */
{
int old_char = NUL;
char_u *nextcomm;
/*
* Avoid a UMR warning from Purify, only save the character if it has been
* written before.
*/
if (col < len)
old_char = str[col];
str[col] = NUL;
nextcomm = str;
#ifdef FEAT_EVAL
if (ccline.cmdfirstc == '=')
/* pass CMD_SIZE because there is no real command */
set_context_for_expression(xp, str, CMD_SIZE);
else if (ccline.input_fn)
{
xp->xp_context = ccline.xp_context;
xp->xp_pattern = ccline.cmdbuff;
xp->xp_arg = ccline.xp_arg;
}
else
#endif
while (nextcomm != NULL)
nextcomm = set_one_cmd_context(xp, nextcomm);
str[col] = old_char;
}
/*
* Expand the command line "str" from context "xp".
* "xp" must have been set by set_cmd_context().
* xp->xp_pattern points into "str", to where the text that is to be expanded
* starts.
* Returns EXPAND_UNSUCCESSFUL when there is something illegal before the
* cursor.
* Returns EXPAND_NOTHING when there is nothing to expand, might insert the
* key that triggered expansion literally.
* Returns EXPAND_OK otherwise.
*/
int
expand_cmdline(xp, str, col, matchcount, matches)
expand_T *xp;
char_u *str; /* start of command line */
int col; /* position of cursor */
int *matchcount; /* return: nr of matches */
char_u ***matches; /* return: array of pointers to matches */
{
char_u *file_str = NULL;
if (xp->xp_context == EXPAND_UNSUCCESSFUL)
{
beep_flush();
return EXPAND_UNSUCCESSFUL; /* Something illegal on command line */
}
if (xp->xp_context == EXPAND_NOTHING)
{
/* Caller can use the character as a normal char instead */
return EXPAND_NOTHING;
}
/* add star to file name, or convert to regexp if not exp. files. */
file_str = addstar(xp->xp_pattern,
(int)(str + col - xp->xp_pattern), xp->xp_context);
if (file_str == NULL)
return EXPAND_UNSUCCESSFUL;
/* find all files that match the description */
if (ExpandFromContext(xp, file_str, matchcount, matches,
WILD_ADD_SLASH|WILD_SILENT) == FAIL)
{
*matchcount = 0;
*matches = NULL;
}
vim_free(file_str);
return EXPAND_OK;
}
#ifdef FEAT_MULTI_LANG
/*
* Cleanup matches for help tags: remove "@en" if "en" is the only language.
*/
static void cleanup_help_tags __ARGS((int num_file, char_u **file));
static void
cleanup_help_tags(num_file, file)
int num_file;
char_u **file;
{
int i, j;
int len;
for (i = 0; i < num_file; ++i)
{
len = (int)STRLEN(file[i]) - 3;
if (len > 0 && STRCMP(file[i] + len, "@en") == 0)
{
/* Sorting on priority means the same item in another language may
* be anywhere. Search all items for a match up to the "@en". */
for (j = 0; j < num_file; ++j)
if (j != i
&& (int)STRLEN(file[j]) == len + 3
&& STRNCMP(file[i], file[j], len + 1) == 0)
break;
if (j == num_file)
file[i][len] = NUL;
}
}
}
#endif
/*
* Do the expansion based on xp->xp_context and "pat".
*/
static int
ExpandFromContext(xp, pat, num_file, file, options)
expand_T *xp;
char_u *pat;
int *num_file;
char_u ***file;
int options;
{
#ifdef FEAT_CMDL_COMPL
regmatch_T regmatch;
#endif
int ret;
int flags;
flags = EW_DIR; /* include directories */
if (options & WILD_LIST_NOTFOUND)
flags |= EW_NOTFOUND;
if (options & WILD_ADD_SLASH)
flags |= EW_ADDSLASH;
if (options & WILD_KEEP_ALL)
flags |= EW_KEEPALL;
if (options & WILD_SILENT)
flags |= EW_SILENT;
if (xp->xp_context == EXPAND_FILES || xp->xp_context == EXPAND_DIRECTORIES)
{
/*
* Expand file or directory names.
*/
int free_pat = FALSE;
int i;
/* for ":set path=" and ":set tags=" halve backslashes for escaped
* space */
if (xp->xp_backslash != XP_BS_NONE)
{
free_pat = TRUE;
pat = vim_strsave(pat);
for (i = 0; pat[i]; ++i)
if (pat[i] == '\\')
{
if (xp->xp_backslash == XP_BS_THREE
&& pat[i + 1] == '\\'
&& pat[i + 2] == '\\'
&& pat[i + 3] == ' ')
STRCPY(pat + i, pat + i + 3);
if (xp->xp_backslash == XP_BS_ONE
&& pat[i + 1] == ' ')
STRCPY(pat + i, pat + i + 1);
}
}
if (xp->xp_context == EXPAND_FILES)
flags |= EW_FILE;
else
flags = (flags | EW_DIR) & ~EW_FILE;
ret = expand_wildcards(1, &pat, num_file, file, flags);
if (free_pat)
vim_free(pat);
return ret;
}
*file = (char_u **)"";
*num_file = 0;
if (xp->xp_context == EXPAND_HELP)
{
if (find_help_tags(pat, num_file, file, FALSE) == OK)
{
#ifdef FEAT_MULTI_LANG
cleanup_help_tags(*num_file, *file);
#endif
return OK;
}
return FAIL;
}
#ifndef FEAT_CMDL_COMPL
return FAIL;
#else
if (xp->xp_context == EXPAND_SHELLCMD)
return expand_shellcmd(pat, num_file, file, flags);
if (xp->xp_context == EXPAND_OLD_SETTING)
return ExpandOldSetting(num_file, file);
if (xp->xp_context == EXPAND_BUFFERS)
return ExpandBufnames(pat, num_file, file, options);
if (xp->xp_context == EXPAND_TAGS
|| xp->xp_context == EXPAND_TAGS_LISTFILES)
return expand_tags(xp->xp_context == EXPAND_TAGS, pat, num_file, file);
if (xp->xp_context == EXPAND_COLORS)
return ExpandRTDir(pat, num_file, file, "colors");
if (xp->xp_context == EXPAND_COMPILER)
return ExpandRTDir(pat, num_file, file, "compiler");
# if defined(FEAT_USR_CMDS) && defined(FEAT_EVAL)
if (xp->xp_context == EXPAND_USER_LIST)
return ExpandUserList(xp, num_file, file);
# endif
regmatch.regprog = vim_regcomp(pat, p_magic ? RE_MAGIC : 0);
if (regmatch.regprog == NULL)
return FAIL;
/* set ignore-case according to p_ic, p_scs and pat */
regmatch.rm_ic = ignorecase(pat);
if (xp->xp_context == EXPAND_SETTINGS
|| xp->xp_context == EXPAND_BOOL_SETTINGS)
ret = ExpandSettings(xp, ®match, num_file, file);
else if (xp->xp_context == EXPAND_MAPPINGS)
ret = ExpandMappings(®match, num_file, file);
# if defined(FEAT_USR_CMDS) && defined(FEAT_EVAL)
else if (xp->xp_context == EXPAND_USER_DEFINED)
ret = ExpandUserDefined(xp, ®match, num_file, file);
# endif
else
{
static struct expgen
{
int context;
char_u *((*func)__ARGS((expand_T *, int)));
int ic;
} tab[] =
{
{EXPAND_COMMANDS, get_command_name, FALSE},
#ifdef FEAT_USR_CMDS
{EXPAND_USER_COMMANDS, get_user_commands, FALSE},
{EXPAND_USER_CMD_FLAGS, get_user_cmd_flags, FALSE},
{EXPAND_USER_NARGS, get_user_cmd_nargs, FALSE},
{EXPAND_USER_COMPLETE, get_user_cmd_complete, FALSE},
#endif
#ifdef FEAT_EVAL
{EXPAND_USER_VARS, get_user_var_name, FALSE},
{EXPAND_FUNCTIONS, get_function_name, FALSE},
{EXPAND_USER_FUNC, get_user_func_name, FALSE},
{EXPAND_EXPRESSION, get_expr_name, FALSE},
#endif
#ifdef FEAT_MENU
{EXPAND_MENUS, get_menu_name, FALSE},
{EXPAND_MENUNAMES, get_menu_names, FALSE},
#endif
#ifdef FEAT_SYN_HL
{EXPAND_SYNTAX, get_syntax_name, TRUE},
#endif
{EXPAND_HIGHLIGHT, get_highlight_name, TRUE},
#ifdef FEAT_AUTOCMD
{EXPAND_EVENTS, get_event_name, TRUE},
{EXPAND_AUGROUP, get_augroup_name, TRUE},
#endif
#if (defined(HAVE_LOCALE_H) || defined(X_LOCALE)) \
&& (defined(FEAT_GETTEXT) || defined(FEAT_MBYTE))
{EXPAND_LANGUAGE, get_lang_arg, TRUE},
#endif
{EXPAND_ENV_VARS, get_env_name, TRUE},
};
int i;
/*
* Find a context in the table and call the ExpandGeneric() with the
* right function to do the expansion.
*/
ret = FAIL;
for (i = 0; i < sizeof(tab) / sizeof(struct expgen); ++i)
if (xp->xp_context == tab[i].context)
{
if (tab[i].ic)
regmatch.rm_ic = TRUE;
ret = ExpandGeneric(xp, ®match, num_file, file, tab[i].func);
break;
}
}
vim_free(regmatch.regprog);
return ret;
#endif /* FEAT_CMDL_COMPL */
}
#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
/*
* Expand a list of names.
*
* Generic function for command line completion. It calls a function to
* obtain strings, one by one. The strings are matched against a regexp
* program. Matching strings are copied into an array, which is returned.
*
* Returns OK when no problems encountered, FAIL for error (out of memory).
*/
int
ExpandGeneric(xp, regmatch, num_file, file, func)
expand_T *xp;
regmatch_T *regmatch;
int *num_file;
char_u ***file;
char_u *((*func)__ARGS((expand_T *, int)));
/* returns a string from the list */
{
int i;
int count = 0;
int round;
char_u *str;
/* do this loop twice:
* round == 0: count the number of matching names
* round == 1: copy the matching names into allocated memory
*/
for (round = 0; round <= 1; ++round)
{
for (i = 0; ; ++i)
{
str = (*func)(xp, i);
if (str == NULL) /* end of list */
break;
if (*str == NUL) /* skip empty strings */
continue;
if (vim_regexec(regmatch, str, (colnr_T)0))
{
if (round)
{
str = vim_strsave_escaped(str, (char_u *)" \t\\.");
(*file)[count] = str;
#ifdef FEAT_MENU
if (func == get_menu_names && str != NULL)
{
/* test for separator added by get_menu_names() */
str += STRLEN(str) - 1;
if (*str == '\001')
*str = '.';
}
#endif
}
++count;
}
}
if (round == 0)
{
if (count == 0)
return OK;
*num_file = count;
*file = (char_u **)alloc((unsigned)(count * sizeof(char_u *)));
if (*file == NULL)
{
*file = (char_u **)"";
return FAIL;
}
count = 0;
}
}
/* Sort the results. Keep menu's in the specified order. */
if (xp->xp_context != EXPAND_MENUNAMES && xp->xp_context != EXPAND_MENUS)
sort_strings(*file, *num_file);
return OK;
}
/*
* Complete a shell command.
* Returns FAIL or OK;
*/
static int
expand_shellcmd(filepat, num_file, file, flagsarg)
char_u *filepat; /* pattern to match with command names */
int *num_file; /* return: number of matches */
char_u ***file; /* return: array with matches */
int flagsarg; /* EW_ flags */
{
char_u *pat;
int i;
char_u *path;
int mustfree = FALSE;
garray_T ga;
char_u *buf = alloc(MAXPATHL);
size_t l;
char_u *s, *e;
int flags = flagsarg;
int ret;
if (buf == NULL)
return FAIL;
/* for ":set path=" and ":set tags=" halve backslashes for escaped
* space */
pat = vim_strsave(filepat);
for (i = 0; pat[i]; ++i)
if (pat[i] == '\\' && pat[i + 1] == ' ')
STRCPY(pat + i, pat + i + 1);
flags |= EW_FILE | EW_EXEC;
/* For an absolute name we don't use $PATH. */
if (mch_isFullName(pat))
path = (char_u *)" ";
else if ((pat[0] == '.' && (vim_ispathsep(pat[1])
|| (pat[1] == '.' && vim_ispathsep(pat[2])))))
path = (char_u *)".";
else
path = vim_getenv((char_u *)"PATH", &mustfree);
/*
* Go over all directories in $PATH. Expand matches in that directory and
* collect them in "ga".
*/
ga_init2(&ga, (int)sizeof(char *), 10);
for (s = path; *s != NUL; s = e)
{
if (*s == ' ')
++s; /* Skip space used for absolute path name. */
#if defined(MSDOS) || defined(MSWIN) || defined(OS2)
e = vim_strchr(s, ';');
#else
e = vim_strchr(s, ':');
#endif
if (e == NULL)
e = s + STRLEN(s);
l = e - s;
if (l > MAXPATHL - 5)
break;
vim_strncpy(buf, s, l);
add_pathsep(buf);
l = STRLEN(buf);
vim_strncpy(buf + l, pat, MAXPATHL - 1 - l);
/* Expand matches in one directory of $PATH. */
ret = expand_wildcards(1, &buf, num_file, file, flags);
if (ret == OK)
{
if (ga_grow(&ga, *num_file) == FAIL)
FreeWild(*num_file, *file);
else
{
for (i = 0; i < *num_file; ++i)
{
s = (*file)[i];
if (STRLEN(s) > l)
{
/* Remove the path again. */
mch_memmove(s, s + l, STRLEN(s + l) + 1);
((char_u **)ga.ga_data)[ga.ga_len++] = s;
}
else
vim_free(s);
}
vim_free(*file);
}
}
if (*e != NUL)
++e;
}
*file = ga.ga_data;
*num_file = ga.ga_len;
vim_free(buf);
vim_free(pat);
if (mustfree)
vim_free(path);
return OK;
}
# if defined(FEAT_USR_CMDS) && defined(FEAT_EVAL)
static void * call_user_expand_func __ARGS((void *(*user_expand_func) __ARGS((char_u *, int, char_u **, int)), expand_T *xp, int *num_file, char_u ***file));
/*
* call "user_expand_func()" to invoke a user defined VimL function and return
* the result (either a string or a List).
*/
static void *
call_user_expand_func(user_expand_func, xp, num_file, file)
void *(*user_expand_func) __ARGS((char_u *, int, char_u **, int));
expand_T *xp;
int *num_file;
char_u ***file;
{
char_u keep;
char_u num[50];
char_u *args[3];
int save_current_SID = current_SID;
void *ret;
struct cmdline_info save_ccline;
if (xp->xp_arg == NULL || xp->xp_arg[0] == '\0')
return NULL;
*num_file = 0;
*file = NULL;
keep = ccline.cmdbuff[ccline.cmdlen];
ccline.cmdbuff[ccline.cmdlen] = 0;
sprintf((char *)num, "%d", ccline.cmdpos);
args[0] = xp->xp_pattern;
args[1] = ccline.cmdbuff;
args[2] = num;
/* Save the cmdline, we don't know what the function may do. */
save_ccline = ccline;
ccline.cmdbuff = NULL;
ccline.cmdprompt = NULL;
current_SID = xp->xp_scriptID;
ret = user_expand_func(xp->xp_arg, 3, args, FALSE);
ccline = save_ccline;
current_SID = save_current_SID;
ccline.cmdbuff[ccline.cmdlen] = keep;
return ret;
}
/*
* Expand names with a function defined by the user.
*/
static int
ExpandUserDefined(xp, regmatch, num_file, file)
expand_T *xp;
regmatch_T *regmatch;
int *num_file;
char_u ***file;
{
char_u *retstr;
char_u *s;
char_u *e;
char_u keep;
garray_T ga;
retstr = call_user_expand_func(call_func_retstr, xp, num_file, file);
if (retstr == NULL)
return FAIL;
ga_init2(&ga, (int)sizeof(char *), 3);
for (s = retstr; *s != NUL; s = e)
{
e = vim_strchr(s, '\n');
if (e == NULL)
e = s + STRLEN(s);
keep = *e;
*e = 0;
if (xp->xp_pattern[0] && vim_regexec(regmatch, s, (colnr_T)0) == 0)
{
*e = keep;
if (*e != NUL)
++e;
continue;
}
if (ga_grow(&ga, 1) == FAIL)
break;
((char_u **)ga.ga_data)[ga.ga_len] = vim_strnsave(s, (int)(e - s));
++ga.ga_len;
*e = keep;
if (*e != NUL)
++e;
}
vim_free(retstr);
*file = ga.ga_data;
*num_file = ga.ga_len;
return OK;
}
/*
* Expand names with a list returned by a function defined by the user.
*/
static int
ExpandUserList(xp, num_file, file)
expand_T *xp;
int *num_file;
char_u ***file;
{
list_T *retlist;
listitem_T *li;
garray_T ga;
retlist = call_user_expand_func(call_func_retlist, xp, num_file, file);
if (retlist == NULL)
return FAIL;
ga_init2(&ga, (int)sizeof(char *), 3);
/* Loop over the items in the list. */
for (li = retlist->lv_first; li != NULL; li = li->li_next)
{
if (li->li_tv.v_type != VAR_STRING)
continue; /* Skip non-string items */
if (ga_grow(&ga, 1) == FAIL)
break;
((char_u **)ga.ga_data)[ga.ga_len] =
vim_strsave(li->li_tv.vval.v_string);
++ga.ga_len;
}
list_unref(retlist);
*file = ga.ga_data;
*num_file = ga.ga_len;
return OK;
}
#endif
/*
* Expand color scheme names: 'runtimepath'/colors/{pat}.vim
* or compiler names.
*/
static int
ExpandRTDir(pat, num_file, file, dirname)
char_u *pat;
int *num_file;
char_u ***file;
char *dirname; /* "colors" or "compiler" */
{
char_u *all;
char_u *s;
char_u *e;
garray_T ga;
*num_file = 0;
*file = NULL;
s = alloc((unsigned)(STRLEN(pat) + STRLEN(dirname) + 7));
if (s == NULL)
return FAIL;
sprintf((char *)s, "%s/%s*.vim", dirname, pat);
all = globpath(p_rtp, s);
vim_free(s);
if (all == NULL)
return FAIL;
ga_init2(&ga, (int)sizeof(char *), 3);
for (s = all; *s != NUL; s = e)
{
e = vim_strchr(s, '\n');
if (e == NULL)
e = s + STRLEN(s);
if (ga_grow(&ga, 1) == FAIL)
break;
if (e - 4 > s && STRNICMP(e - 4, ".vim", 4) == 0)
{
for (s = e - 4; s > all; mb_ptr_back(all, s))
if (*s == '\n' || vim_ispathsep(*s))
break;
++s;
((char_u **)ga.ga_data)[ga.ga_len] =
vim_strnsave(s, (int)(e - s - 4));
++ga.ga_len;
}
if (*e != NUL)
++e;
}
vim_free(all);
*file = ga.ga_data;
*num_file = ga.ga_len;
return OK;
}
#endif
#if defined(FEAT_CMDL_COMPL) || defined(FEAT_EVAL) || defined(PROTO)
/*
* Expand "file" for all comma-separated directories in "path".
* Returns an allocated string with all matches concatenated, separated by
* newlines. Returns NULL for an error or no matches.
*/
char_u *
globpath(path, file)
char_u *path;
char_u *file;
{
expand_T xpc;
char_u *buf;
garray_T ga;
int i;
int len;
int num_p;
char_u **p;
char_u *cur = NULL;
buf = alloc(MAXPATHL);
if (buf == NULL)
return NULL;
ExpandInit(&xpc);
xpc.xp_context = EXPAND_FILES;
ga_init2(&ga, 1, 100);
/* Loop over all entries in {path}. */
while (*path != NUL)
{
/* Copy one item of the path to buf[] and concatenate the file name. */
copy_option_part(&path, buf, MAXPATHL, ",");
if (STRLEN(buf) + STRLEN(file) + 2 < MAXPATHL)
{
add_pathsep(buf);
STRCAT(buf, file);
if (ExpandFromContext(&xpc, buf, &num_p, &p, WILD_SILENT) != FAIL
&& num_p > 0)
{
ExpandEscape(&xpc, buf, num_p, p, WILD_SILENT);
for (len = 0, i = 0; i < num_p; ++i)
len += (int)STRLEN(p[i]) + 1;
/* Concatenate new results to previous ones. */
if (ga_grow(&ga, len) == OK)
{
cur = (char_u *)ga.ga_data + ga.ga_len;
for (i = 0; i < num_p; ++i)
{
STRCPY(cur, p[i]);
cur += STRLEN(p[i]);
*cur++ = '\n';
}
ga.ga_len += len;
}
FreeWild(num_p, p);
}
}
}
if (cur != NULL)
*--cur = 0; /* Replace trailing newline with NUL */
vim_free(buf);
return (char_u *)ga.ga_data;
}
#endif
#if defined(FEAT_CMDHIST) || defined(PROTO)
/*********************************
* Command line history stuff *
*********************************/
/*
* Translate a history character to the associated type number.
*/
static int
hist_char2type(c)
int c;
{
if (c == ':')
return HIST_CMD;
if (c == '=')
return HIST_EXPR;
if (c == '@')
return HIST_INPUT;
if (c == '>')
return HIST_DEBUG;
return HIST_SEARCH; /* must be '?' or '/' */
}
/*
* Table of history names.
* These names are used in :history and various hist...() functions.
* It is sufficient to give the significant prefix of a history name.
*/
static char *(history_names[]) =
{
"cmd",
"search",
"expr",
"input",
"debug",
NULL
};
/*
* init_history() - Initialize the command line history.
* Also used to re-allocate the history when the size changes.
*/
void
init_history()
{
int newlen; /* new length of history table */
histentry_T *temp;
int i;
int j;
int type;
/*
* If size of history table changed, reallocate it
*/
newlen = (int)p_hi;
if (newlen != hislen) /* history length changed */
{
for (type = 0; type < HIST_COUNT; ++type) /* adjust the tables */
{
if (newlen)
{
temp = (histentry_T *)lalloc(
(long_u)(newlen * sizeof(histentry_T)), TRUE);
if (temp == NULL) /* out of memory! */
{
if (type == 0) /* first one: just keep the old length */
{
newlen = hislen;
break;
}
/* Already changed one table, now we can only have zero
* length for all tables. */
newlen = 0;
type = -1;
continue;
}
}
else
temp = NULL;
if (newlen == 0 || temp != NULL)
{
if (hisidx[type] < 0) /* there are no entries yet */
{
for (i = 0; i < newlen; ++i)
{
temp[i].hisnum = 0;
temp[i].hisstr = NULL;
}
}
else if (newlen > hislen) /* array becomes bigger */
{
for (i = 0; i <= hisidx[type]; ++i)
temp[i] = history[type][i];
j = i;
for ( ; i <= newlen - (hislen - hisidx[type]); ++i)
{
temp[i].hisnum = 0;
temp[i].hisstr = NULL;
}
for ( ; j < hislen; ++i, ++j)
temp[i] = history[type][j];
}
else /* array becomes smaller or 0 */
{
j = hisidx[type];
for (i = newlen - 1; ; --i)
{
if (i >= 0) /* copy newest entries */
temp[i] = history[type][j];
else /* remove older entries */
vim_free(history[type][j].hisstr);
if (--j < 0)
j = hislen - 1;
if (j == hisidx[type])
break;
}
hisidx[type] = newlen - 1;
}
vim_free(history[type]);
history[type] = temp;
}
}
hislen = newlen;
}
}
/*
* Check if command line 'str' is already in history.
* If 'move_to_front' is TRUE, matching entry is moved to end of history.
*/
static int
in_history(type, str, move_to_front)
int type;
char_u *str;
int move_to_front; /* Move the entry to the front if it exists */
{
int i;
int last_i = -1;
if (hisidx[type] < 0)
return FALSE;
i = hisidx[type];
do
{
if (history[type][i].hisstr == NULL)
return FALSE;
if (STRCMP(str, history[type][i].hisstr) == 0)
{
if (!move_to_front)
return TRUE;
last_i = i;
break;
}
if (--i < 0)
i = hislen - 1;
} while (i != hisidx[type]);
if (last_i >= 0)
{
str = history[type][i].hisstr;
while (i != hisidx[type])
{
if (++i >= hislen)
i = 0;
history[type][last_i] = history[type][i];
last_i = i;
}
history[type][i].hisstr = str;
history[type][i].hisnum = ++hisnum[type];
return TRUE;
}
return FALSE;
}
/*
* Convert history name (from table above) to its HIST_ equivalent.
* When "name" is empty, return "cmd" history.
* Returns -1 for unknown history name.
*/
int
get_histtype(name)
char_u *name;
{
int i;
int len = (int)STRLEN(name);
/* No argument: use current history. */
if (len == 0)
return hist_char2type(ccline.cmdfirstc);
for (i = 0; history_names[i] != NULL; ++i)
if (STRNICMP(name, history_names[i], len) == 0)
return i;
if (vim_strchr((char_u *)":=@>?/", name[0]) != NULL && name[1] == NUL)
return hist_char2type(name[0]);
return -1;
}
static int last_maptick = -1; /* last seen maptick */
/*
* Add the given string to the given history. If the string is already in the
* history then it is moved to the front. "histype" may be one of he HIST_
* values.
*/
void
add_to_history(histype, new_entry, in_map, sep)
int histype;
char_u *new_entry;
int in_map; /* consider maptick when inside a mapping */
int sep; /* separator character used (search hist) */
{
histentry_T *hisptr;
int len;
if (hislen == 0) /* no history */
return;
/*
* Searches inside the same mapping overwrite each other, so that only
* the last line is kept. Be careful not to remove a line that was moved
* down, only lines that were added.
*/
if (histype == HIST_SEARCH && in_map)
{
if (maptick == last_maptick)
{
/* Current line is from the same mapping, remove it */
hisptr = &history[HIST_SEARCH][hisidx[HIST_SEARCH]];
vim_free(hisptr->hisstr);
hisptr->hisstr = NULL;
hisptr->hisnum = 0;
--hisnum[histype];
if (--hisidx[HIST_SEARCH] < 0)
hisidx[HIST_SEARCH] = hislen - 1;
}
last_maptick = -1;
}
if (!in_history(histype, new_entry, TRUE))
{
if (++hisidx[histype] == hislen)
hisidx[histype] = 0;
hisptr = &history[histype][hisidx[histype]];
vim_free(hisptr->hisstr);
/* Store the separator after the NUL of the string. */
len = (int)STRLEN(new_entry);
hisptr->hisstr = vim_strnsave(new_entry, len + 2);
if (hisptr->hisstr != NULL)
hisptr->hisstr[len + 1] = sep;
hisptr->hisnum = ++hisnum[histype];
if (histype == HIST_SEARCH && in_map)
last_maptick = maptick;
}
}
#if defined(FEAT_EVAL) || defined(PROTO)
/*
* Get identifier of newest history entry.
* "histype" may be one of the HIST_ values.
*/
int
get_history_idx(histype)
int histype;
{
if (hislen == 0 || histype < 0 || histype >= HIST_COUNT
|| hisidx[histype] < 0)
return -1;
return history[histype][hisidx[histype]].hisnum;
}
static struct cmdline_info *get_ccline_ptr __ARGS((void));
/*
* Get pointer to the command line info to use. cmdline_paste() may clear
* ccline and put the previous value in prev_ccline.
*/
static struct cmdline_info *
get_ccline_ptr()
{
if ((State & CMDLINE) == 0)
return NULL;
if (ccline.cmdbuff != NULL)
return &ccline;
if (prev_ccline_used && prev_ccline.cmdbuff != NULL)
return &prev_ccline;
return NULL;
}
/*
* Get the current command line in allocated memory.
* Only works when the command line is being edited.
* Returns NULL when something is wrong.
*/
char_u *
get_cmdline_str()
{
struct cmdline_info *p = get_ccline_ptr();
if (p == NULL)
return NULL;
return vim_strnsave(p->cmdbuff, p->cmdlen);
}
/*
* Get the current command line position, counted in bytes.
* Zero is the first position.
* Only works when the command line is being edited.
* Returns -1 when something is wrong.
*/
int
get_cmdline_pos()
{
struct cmdline_info *p = get_ccline_ptr();
if (p == NULL)
return -1;
return p->cmdpos;
}
/*
* Set the command line byte position to "pos". Zero is the first position.
* Only works when the command line is being edited.
* Returns 1 when failed, 0 when OK.
*/
int
set_cmdline_pos(pos)
int pos;
{
struct cmdline_info *p = get_ccline_ptr();
if (p == NULL)
return 1;
/* The position is not set directly but after CTRL-\ e or CTRL-R = has
* changed the command line. */
if (pos < 0)
new_cmdpos = 0;
else
new_cmdpos = pos;
return 0;
}
/*
* Get the current command-line type.
* Returns ':' or '/' or '?' or '@' or '>' or '-'
* Only works when the command line is being edited.
* Returns NUL when something is wrong.
*/
int
get_cmdline_type()
{
struct cmdline_info *p = get_ccline_ptr();
if (p == NULL)
return NUL;
if (p->cmdfirstc == NUL)
return (p->input_fn) ? '@' : '-';
return p->cmdfirstc;
}
/*
* Calculate history index from a number:
* num > 0: seen as identifying number of a history entry
* num < 0: relative position in history wrt newest entry
* "histype" may be one of the HIST_ values.
*/
static int
calc_hist_idx(histype, num)
int histype;
int num;
{
int i;
histentry_T *hist;
int wrapped = FALSE;
if (hislen == 0 || histype < 0 || histype >= HIST_COUNT
|| (i = hisidx[histype]) < 0 || num == 0)
return -1;
hist = history[histype];
if (num > 0)
{
while (hist[i].hisnum > num)
if (--i < 0)
{
if (wrapped)
break;
i += hislen;
wrapped = TRUE;
}
if (hist[i].hisnum == num && hist[i].hisstr != NULL)
return i;
}
else if (-num <= hislen)
{
i += num + 1;
if (i < 0)
i += hislen;
if (hist[i].hisstr != NULL)
return i;
}
return -1;
}
/*
* Get a history entry by its index.
* "histype" may be one of the HIST_ values.
*/
char_u *
get_history_entry(histype, idx)
int histype;
int idx;
{
idx = calc_hist_idx(histype, idx);
if (idx >= 0)
return history[histype][idx].hisstr;
else
return (char_u *)"";
}
/*
* Clear all entries of a history.
* "histype" may be one of the HIST_ values.
*/
int
clr_history(histype)
int histype;
{
int i;
histentry_T *hisptr;
if (hislen != 0 && histype >= 0 && histype < HIST_COUNT)
{
hisptr = history[histype];
for (i = hislen; i--;)
{
vim_free(hisptr->hisstr);
hisptr->hisnum = 0;
hisptr++->hisstr = NULL;
}
hisidx[histype] = -1; /* mark history as cleared */
hisnum[histype] = 0; /* reset identifier counter */
return OK;
}
return FAIL;
}
/*
* Remove all entries matching {str} from a history.
* "histype" may be one of the HIST_ values.
*/
int
del_history_entry(histype, str)
int histype;
char_u *str;
{
regmatch_T regmatch;
histentry_T *hisptr;
int idx;
int i;
int last;
int found = FALSE;
regmatch.regprog = NULL;
regmatch.rm_ic = FALSE; /* always match case */
if (hislen != 0
&& histype >= 0
&& histype < HIST_COUNT
&& *str != NUL
&& (idx = hisidx[histype]) >= 0
&& (regmatch.regprog = vim_regcomp(str, RE_MAGIC + RE_STRING))
!= NULL)
{
i = last = idx;
do
{
hisptr = &history[histype][i];
if (hisptr->hisstr == NULL)
break;
if (vim_regexec(®match, hisptr->hisstr, (colnr_T)0))
{
found = TRUE;
vim_free(hisptr->hisstr);
hisptr->hisstr = NULL;
hisptr->hisnum = 0;
}
else
{
if (i != last)
{
history[histype][last] = *hisptr;
hisptr->hisstr = NULL;
hisptr->hisnum = 0;
}
if (--last < 0)
last += hislen;
}
if (--i < 0)
i += hislen;
} while (i != idx);
if (history[histype][idx].hisstr == NULL)
hisidx[histype] = -1;
}
vim_free(regmatch.regprog);
return found;
}
/*
* Remove an indexed entry from a history.
* "histype" may be one of the HIST_ values.
*/
int
del_history_idx(histype, idx)
int histype;
int idx;
{
int i, j;
i = calc_hist_idx(histype, idx);
if (i < 0)
return FALSE;
idx = hisidx[histype];
vim_free(history[histype][i].hisstr);
/* When deleting the last added search string in a mapping, reset
* last_maptick, so that the last added search string isn't deleted again.
*/
if (histype == HIST_SEARCH && maptick == last_maptick && i == idx)
last_maptick = -1;
while (i != idx)
{
j = (i + 1) % hislen;
history[histype][i] = history[histype][j];
i = j;
}
history[histype][i].hisstr = NULL;
history[histype][i].hisnum = 0;
if (--i < 0)
i += hislen;
hisidx[histype] = i;
return TRUE;
}
#endif /* FEAT_EVAL */
#if defined(FEAT_CRYPT) || defined(PROTO)
/*
* Very specific function to remove the value in ":set key=val" from the
* history.
*/
void
remove_key_from_history()
{
char_u *p;
int i;
i = hisidx[HIST_CMD];
if (i < 0)
return;
p = history[HIST_CMD][i].hisstr;
if (p != NULL)
for ( ; *p; ++p)
if (STRNCMP(p, "key", 3) == 0 && !isalpha(p[3]))
{
p = vim_strchr(p + 3, '=');
if (p == NULL)
break;
++p;
for (i = 0; p[i] && !vim_iswhite(p[i]); ++i)
if (p[i] == '\\' && p[i + 1])
++i;
mch_memmove(p, p + i, STRLEN(p + i) + 1);
--p;
}
}
#endif
#endif /* FEAT_CMDHIST */
#if defined(FEAT_QUICKFIX) || defined(FEAT_CMDHIST) || defined(PROTO)
/*
* Get indices "num1,num2" that specify a range within a list (not a range of
* text lines in a buffer!) from a string. Used for ":history" and ":clist".
* Returns OK if parsed successfully, otherwise FAIL.
*/
int
get_list_range(str, num1, num2)
char_u **str;
int *num1;
int *num2;
{
int len;
int first = FALSE;
long num;
*str = skipwhite(*str);
if (**str == '-' || vim_isdigit(**str)) /* parse "from" part of range */
{
vim_str2nr(*str, NULL, &len, FALSE, FALSE, &num, NULL);
*str += len;
*num1 = (int)num;
first = TRUE;
}
*str = skipwhite(*str);
if (**str == ',') /* parse "to" part of range */
{
*str = skipwhite(*str + 1);
vim_str2nr(*str, NULL, &len, FALSE, FALSE, &num, NULL);
if (len > 0)
{
*num2 = (int)num;
*str = skipwhite(*str + len);
}
else if (!first) /* no number given at all */
return FAIL;
}
else if (first) /* only one number given */
*num2 = *num1;
return OK;
}
#endif
#if defined(FEAT_CMDHIST) || defined(PROTO)
/*
* :history command - print a history
*/
void
ex_history(eap)
exarg_T *eap;
{
histentry_T *hist;
int histype1 = HIST_CMD;
int histype2 = HIST_CMD;
int hisidx1 = 1;
int hisidx2 = -1;
int idx;
int i, j, k;
char_u *end;
char_u *arg = eap->arg;
if (hislen == 0)
{
MSG(_("'history' option is zero"));
return;
}
if (!(VIM_ISDIGIT(*arg) || *arg == '-' || *arg == ','))
{
end = arg;
while (ASCII_ISALPHA(*end)
|| vim_strchr((char_u *)":=@>/?", *end) != NULL)
end++;
i = *end;
*end = NUL;
histype1 = get_histtype(arg);
if (histype1 == -1)
{
if (STRICMP(arg, "all") == 0)
{
histype1 = 0;
histype2 = HIST_COUNT-1;
}
else
{
*end = i;
EMSG(_(e_trailing));
return;
}
}
else
histype2 = histype1;
*end = i;
}
else
end = arg;
if (!get_list_range(&end, &hisidx1, &hisidx2) || *end != NUL)
{
EMSG(_(e_trailing));
return;
}
for (; !got_int && histype1 <= histype2; ++histype1)
{
STRCPY(IObuff, "\n # ");
STRCAT(STRCAT(IObuff, history_names[histype1]), " history");
MSG_PUTS_TITLE(IObuff);
idx = hisidx[histype1];
hist = history[histype1];
j = hisidx1;
k = hisidx2;
if (j < 0)
j = (-j > hislen) ? 0 : hist[(hislen+j+idx+1) % hislen].hisnum;
if (k < 0)
k = (-k > hislen) ? 0 : hist[(hislen+k+idx+1) % hislen].hisnum;
if (idx >= 0 && j <= k)
for (i = idx + 1; !got_int; ++i)
{
if (i == hislen)
i = 0;
if (hist[i].hisstr != NULL
&& hist[i].hisnum >= j && hist[i].hisnum <= k)
{
msg_putchar('\n');
sprintf((char *)IObuff, "%c%6d ", i == idx ? '>' : ' ',
hist[i].hisnum);
if (vim_strsize(hist[i].hisstr) > (int)Columns - 10)
trunc_string(hist[i].hisstr, IObuff + STRLEN(IObuff),
(int)Columns - 10);
else
STRCAT(IObuff, hist[i].hisstr);
msg_outtrans(IObuff);
out_flush();
}
if (i == idx)
break;
}
}
}
#endif
#if (defined(FEAT_VIMINFO) && defined(FEAT_CMDHIST)) || defined(PROTO)
static char_u **viminfo_history[HIST_COUNT] = {NULL, NULL, NULL, NULL};
static int viminfo_hisidx[HIST_COUNT] = {0, 0, 0, 0};
static int viminfo_hislen[HIST_COUNT] = {0, 0, 0, 0};
static int viminfo_add_at_front = FALSE;
static int hist_type2char __ARGS((int type, int use_question));
/*
* Translate a history type number to the associated character.
*/
static int
hist_type2char(type, use_question)
int type;
int use_question; /* use '?' instead of '/' */
{
if (type == HIST_CMD)
return ':';
if (type == HIST_SEARCH)
{
if (use_question)
return '?';
else
return '/';
}
if (type == HIST_EXPR)
return '=';
return '@';
}
/*
* Prepare for reading the history from the viminfo file.
* This allocates history arrays to store the read history lines.
*/
void
prepare_viminfo_history(asklen)
int asklen;
{
int i;
int num;
int type;
int len;
init_history();
viminfo_add_at_front = (asklen != 0);
if (asklen > hislen)
asklen = hislen;
for (type = 0; type < HIST_COUNT; ++type)
{
/*
* Count the number of empty spaces in the history list. If there are
* more spaces available than we request, then fill them up.
*/
for (i = 0, num = 0; i < hislen; i++)
if (history[type][i].hisstr == NULL)
num++;
len = asklen;
if (num > len)
len = num;
if (len <= 0)
viminfo_history[type] = NULL;
else
viminfo_history[type] =
(char_u **)lalloc((long_u)(len * sizeof(char_u *)), FALSE);
if (viminfo_history[type] == NULL)
len = 0;
viminfo_hislen[type] = len;
viminfo_hisidx[type] = 0;
}
}
/*
* Accept a line from the viminfo, store it in the history array when it's
* new.
*/
int
read_viminfo_history(virp)
vir_T *virp;
{
int type;
long_u len;
char_u *val;
char_u *p;
type = hist_char2type(virp->vir_line[0]);
if (viminfo_hisidx[type] < viminfo_hislen[type])
{
val = viminfo_readstring(virp, 1, TRUE);
if (val != NULL && *val != NUL)
{
if (!in_history(type, val + (type == HIST_SEARCH),
viminfo_add_at_front))
{
/* Need to re-allocate to append the separator byte. */
len = STRLEN(val);
p = lalloc(len + 2, TRUE);
if (p != NULL)
{
if (type == HIST_SEARCH)
{
/* Search entry: Move the separator from the first
* column to after the NUL. */
mch_memmove(p, val + 1, (size_t)len);
p[len] = (*val == ' ' ? NUL : *val);
}
else
{
/* Not a search entry: No separator in the viminfo
* file, add a NUL separator. */
mch_memmove(p, val, (size_t)len + 1);
p[len + 1] = NUL;
}
viminfo_history[type][viminfo_hisidx[type]++] = p;
}
}
}
vim_free(val);
}
return viminfo_readline(virp);
}
void
finish_viminfo_history()
{
int idx;
int i;
int type;
for (type = 0; type < HIST_COUNT; ++type)
{
if (history[type] == NULL)
return;
idx = hisidx[type] + viminfo_hisidx[type];
if (idx >= hislen)
idx -= hislen;
else if (idx < 0)
idx = hislen - 1;
if (viminfo_add_at_front)
hisidx[type] = idx;
else
{
if (hisidx[type] == -1)
hisidx[type] = hislen - 1;
do
{
if (history[type][idx].hisstr != NULL)
break;
if (++idx == hislen)
idx = 0;
} while (idx != hisidx[type]);
if (idx != hisidx[type] && --idx < 0)
idx = hislen - 1;
}
for (i = 0; i < viminfo_hisidx[type]; i++)
{
vim_free(history[type][idx].hisstr);
history[type][idx].hisstr = viminfo_history[type][i];
if (--idx < 0)
idx = hislen - 1;
}
idx += 1;
idx %= hislen;
for (i = 0; i < viminfo_hisidx[type]; i++)
{
history[type][idx++].hisnum = ++hisnum[type];
idx %= hislen;
}
vim_free(viminfo_history[type]);
viminfo_history[type] = NULL;
}
}
void
write_viminfo_history(fp)
FILE *fp;
{
int i;
int type;
int num_saved;
char_u *p;
int c;
init_history();
if (hislen == 0)
return;
for (type = 0; type < HIST_COUNT; ++type)
{
num_saved = get_viminfo_parameter(hist_type2char(type, FALSE));
if (num_saved == 0)
continue;
if (num_saved < 0) /* Use default */
num_saved = hislen;
fprintf(fp, _("\n# %s History (newest to oldest):\n"),
type == HIST_CMD ? _("Command Line") :
type == HIST_SEARCH ? _("Search String") :
type == HIST_EXPR ? _("Expression") :
_("Input Line"));
if (num_saved > hislen)
num_saved = hislen;
i = hisidx[type];
if (i >= 0)
while (num_saved--)
{
p = history[type][i].hisstr;
if (p != NULL)
{
fputc(hist_type2char(type, TRUE), fp);
/* For the search history: put the separator in the second
* column; use a space if there isn't one. */
if (type == HIST_SEARCH)
{
c = p[STRLEN(p) + 1];
putc(c == NUL ? ' ' : c, fp);
}
viminfo_writestring(fp, p);
}
if (--i < 0)
i = hislen - 1;
}
}
}
#endif /* FEAT_VIMINFO */
#if defined(FEAT_FKMAP) || defined(PROTO)
/*
* Write a character at the current cursor+offset position.
* It is directly written into the command buffer block.
*/
void
cmd_pchar(c, offset)
int c, offset;
{
if (ccline.cmdpos + offset >= ccline.cmdlen || ccline.cmdpos + offset < 0)
{
EMSG(_("E198: cmd_pchar beyond the command length"));
return;
}
ccline.cmdbuff[ccline.cmdpos + offset] = (char_u)c;
ccline.cmdbuff[ccline.cmdlen] = NUL;
}
int
cmd_gchar(offset)
int offset;
{
if (ccline.cmdpos + offset >= ccline.cmdlen || ccline.cmdpos + offset < 0)
{
/* EMSG(_("cmd_gchar beyond the command length")); */
return NUL;
}
return (int)ccline.cmdbuff[ccline.cmdpos + offset];
}
#endif
#if defined(FEAT_CMDWIN) || defined(PROTO)
/*
* Open a window on the current command line and history. Allow editing in
* the window. Returns when the window is closed.
* Returns:
* CR if the command is to be executed
* Ctrl_C if it is to be abandoned
* K_IGNORE if editing continues
*/
static int
ex_window()
{
struct cmdline_info save_ccline;
buf_T *old_curbuf = curbuf;
win_T *old_curwin = curwin;
buf_T *bp;
win_T *wp;
int i;
linenr_T lnum;
int histtype;
garray_T winsizes;
char_u typestr0[2];
int save_restart_edit = restart_edit;
int save_State = State;
int save_exmode = exmode_active;
#ifdef FEAT_RIGHTLEFT
int save_cmdmsg_rl = cmdmsg_rl;
#endif
/* Can't do this recursively. Can't do it when typing a password. */
if (cmdwin_type != 0
# if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
|| cmdline_star > 0
# endif
)
{
beep_flush();
return K_IGNORE;
}
/* Save current window sizes. */
win_size_save(&winsizes);
# ifdef FEAT_AUTOCMD
/* Don't execute autocommands while creating the window. */
++autocmd_block;
# endif
/* don't use a new tab page */
cmdmod.tab = 0;
/* Create a window for the command-line buffer. */
if (win_split((int)p_cwh, WSP_BOT) == FAIL)
{
beep_flush();
return K_IGNORE;
}
cmdwin_type = ccline.cmdfirstc;
if (cmdwin_type == NUL)
cmdwin_type = '-';
/* Create the command-line buffer empty. */
(void)do_ecmd(0, NULL, NULL, NULL, ECMD_ONE, ECMD_HIDE);
(void)setfname(curbuf, (char_u *)"command-line", NULL, TRUE);
set_option_value((char_u *)"bt", 0L, (char_u *)"nofile", OPT_LOCAL);
set_option_value((char_u *)"swf", 0L, NULL, OPT_LOCAL);
curbuf->b_p_ma = TRUE;
# ifdef FEAT_RIGHTLEFT
curwin->w_p_rl = cmdmsg_rl;
cmdmsg_rl = FALSE;
# endif
# ifdef FEAT_SCROLLBIND
curwin->w_p_scb = FALSE;
# endif
# ifdef FEAT_AUTOCMD
/* Do execute autocommands for setting the filetype (load syntax). */
--autocmd_block;
# endif
/* Showing the prompt may have set need_wait_return, reset it. */
need_wait_return = FALSE;
histtype = hist_char2type(ccline.cmdfirstc);
if (histtype == HIST_CMD || histtype == HIST_DEBUG)
{
if (p_wc == TAB)
{
add_map((char_u *)"<buffer> <Tab> <C-X><C-V>", INSERT);
add_map((char_u *)"<buffer> <Tab> a<C-X><C-V>", NORMAL);
}
set_option_value((char_u *)"ft", 0L, (char_u *)"vim", OPT_LOCAL);
}
/* Reset 'textwidth' after setting 'filetype' (the Vim filetype plugin
* sets 'textwidth' to 78). */
curbuf->b_p_tw = 0;
/* Fill the buffer with the history. */
init_history();
if (hislen > 0)
{
i = hisidx[histtype];
if (i >= 0)
{
lnum = 0;
do
{
if (++i == hislen)
i = 0;
if (history[histtype][i].hisstr != NULL)
ml_append(lnum++, history[histtype][i].hisstr,
(colnr_T)0, FALSE);
}
while (i != hisidx[histtype]);
}
}
/* Replace the empty last line with the current command-line and put the
* cursor there. */
ml_replace(curbuf->b_ml.ml_line_count, ccline.cmdbuff, TRUE);
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
curwin->w_cursor.col = ccline.cmdpos;
changed_line_abv_curs();
invalidate_botline();
redraw_later(SOME_VALID);
/* Save the command line info, can be used recursively. */
save_ccline = ccline;
ccline.cmdbuff = NULL;
ccline.cmdprompt = NULL;
/* No Ex mode here! */
exmode_active = 0;
State = NORMAL;
# ifdef FEAT_MOUSE
setmouse();
# endif
# ifdef FEAT_AUTOCMD
/* Trigger CmdwinEnter autocommands. */
typestr0[0] = cmdwin_type;
typestr0[1] = NUL;
apply_autocmds(EVENT_CMDWINENTER, typestr0, typestr0, FALSE, curbuf);
if (restart_edit != 0) /* autocmd with ":startinsert" */
stuffcharReadbuff(K_NOP);
# endif
i = RedrawingDisabled;
RedrawingDisabled = 0;
/*
* Call the main loop until <CR> or CTRL-C is typed.
*/
cmdwin_result = 0;
main_loop(TRUE, FALSE);
RedrawingDisabled = i;
# ifdef FEAT_AUTOCMD
/* Trigger CmdwinLeave autocommands. */
apply_autocmds(EVENT_CMDWINLEAVE, typestr0, typestr0, FALSE, curbuf);
# endif
/* Restore the command line info. */
ccline = save_ccline;
cmdwin_type = 0;
exmode_active = save_exmode;
/* Safety check: The old window or buffer was deleted: It's a a bug when
* this happens! */
if (!win_valid(old_curwin) || !buf_valid(old_curbuf))
{
cmdwin_result = Ctrl_C;
EMSG(_("E199: Active window or buffer deleted"));
}
else
{
# if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
/* autocmds may abort script processing */
if (aborting() && cmdwin_result != K_IGNORE)
cmdwin_result = Ctrl_C;
# endif
/* Set the new command line from the cmdline buffer. */
vim_free(ccline.cmdbuff);
if (cmdwin_result == K_XF1 || cmdwin_result == K_XF2) /* :qa[!] typed */
{
char *p = (cmdwin_result == K_XF2) ? "qa" : "qa!";
if (histtype == HIST_CMD)
{
/* Execute the command directly. */
ccline.cmdbuff = vim_strsave((char_u *)p);
cmdwin_result = CAR;
}
else
{
/* First need to cancel what we were doing. */
ccline.cmdbuff = NULL;
stuffcharReadbuff(':');
stuffReadbuff((char_u *)p);
stuffcharReadbuff(CAR);
}
}
else if (cmdwin_result == K_XF2) /* :qa typed */
{
ccline.cmdbuff = vim_strsave((char_u *)"qa");
cmdwin_result = CAR;
}
else
ccline.cmdbuff = vim_strsave(ml_get_curline());
if (ccline.cmdbuff == NULL)
cmdwin_result = Ctrl_C;
else
{
ccline.cmdlen = (int)STRLEN(ccline.cmdbuff);
ccline.cmdbufflen = ccline.cmdlen + 1;
ccline.cmdpos = curwin->w_cursor.col;
if (ccline.cmdpos > ccline.cmdlen)
ccline.cmdpos = ccline.cmdlen;
if (cmdwin_result == K_IGNORE)
{
set_cmdspos_cursor();
redrawcmd();
}
}
# ifdef FEAT_AUTOCMD
/* Don't execute autocommands while deleting the window. */
++autocmd_block;
# endif
wp = curwin;
bp = curbuf;
win_goto(old_curwin);
win_close(wp, TRUE);
close_buffer(NULL, bp, DOBUF_WIPE);
/* Restore window sizes. */
win_size_restore(&winsizes);
# ifdef FEAT_AUTOCMD
--autocmd_block;
# endif
}
ga_clear(&winsizes);
restart_edit = save_restart_edit;
# ifdef FEAT_RIGHTLEFT
cmdmsg_rl = save_cmdmsg_rl;
# endif
State = save_State;
# ifdef FEAT_MOUSE
setmouse();
# endif
return cmdwin_result;
}
#endif /* FEAT_CMDWIN */
/*
* Used for commands that either take a simple command string argument, or:
* cmd << endmarker
* {script}
* endmarker
* Returns a pointer to allocated memory with {script} or NULL.
*/
char_u *
script_get(eap, cmd)
exarg_T *eap;
char_u *cmd;
{
char_u *theline;
char *end_pattern = NULL;
char dot[] = ".";
garray_T ga;
if (cmd[0] != '<' || cmd[1] != '<' || eap->getline == NULL)
return NULL;
ga_init2(&ga, 1, 0x400);
if (cmd[2] != NUL)
end_pattern = (char *)skipwhite(cmd + 2);
else
end_pattern = dot;
for (;;)
{
theline = eap->getline(
#ifdef FEAT_EVAL
eap->cstack->cs_looplevel > 0 ? -1 :
#endif
NUL, eap->cookie, 0);
if (theline == NULL || STRCMP(end_pattern, theline) == 0)
break;
ga_concat(&ga, theline);
ga_append(&ga, '\n');
vim_free(theline);
}
ga_append(&ga, NUL);
return (char_u *)ga.ga_data;
}
|
