/* vi:set ts=8 sts=4 sw=4 noet:

*

* 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"

// Return value when handling keys in command-line mode.

#define CMDLINE_NOT_CHANGED 1

#define CMDLINE_CHANGED 2

#define GOTO_NORMAL_MODE 3

#define PROCESS_NEXT_KEY 4

// The current cmdline_info. It is initialized in getcmdline() and after that

// used by other functions. When invoking getcmdline() recursively it needs

// to be saved with save_cmdline() and restored with restore_cmdline().

static cmdline_info_T ccline;

#ifdef FEAT_EVAL

static int new_cmdpos; // position set by set_cmdline_pos()

#endif

static int extra_char = NUL; // extra character to display when redrawing

// the command line

static int extra_char_shift;

#ifdef FEAT_RIGHTLEFT

static int cmd_hkmap = 0; // Hebrew mapping during command line

#endif

static char_u *getcmdline_int(int firstc, long count, int indent, int clear_ccline);

static int cmdline_charsize(int idx);

static void set_cmdspos(void);

static void set_cmdspos_cursor(void);

static void correct_cmdspos(int idx, int cells);

static void dealloc_cmdbuff(void);

static void alloc_cmdbuff(size_t len);

static void draw_cmdline(int start, int len);

static void save_cmdline(cmdline_info_T *ccp);

static void restore_cmdline(cmdline_info_T *ccp);

static int cmdline_paste(int regname, int literally, int remcr);

static void redrawcmdprompt(void);

static int ccheck_abbr(int);

static int open_cmdwin(void);

#ifdef FEAT_SEARCH_EXTRA

static int empty_pattern_magic(char_u *pat, size_t len, magic_T magic_val);

#endif

static int cedit_key = -1; // key value of 'cedit' option

static void

trigger_cmd_autocmd(int typechar, int evt)

{

char_u typestr[2];

typestr[0] = typechar;

typestr[1] = NUL;

apply_autocmds(evt, typestr, typestr, FALSE, curbuf);

}

/*

* Abandon the command line.

*/

static void

abandon_cmdline(void)

{

dealloc_cmdbuff();

if (msg_scrolled == 0)

compute_cmdrow();

msg("");

redraw_cmdline = TRUE;

}

#ifdef FEAT_SEARCH_EXTRA

/*

* Guess that the pattern matches everything. Only finds specific cases, such

* as a trailing \|, which can happen while typing a pattern.

*/

static int

empty_pattern(char_u *p, size_t len, int delim)

{

magic_T magic_val = MAGIC_ON;

if (len > 0)

(void) skip_regexp_ex(p, delim, magic_isset(), NULL, NULL, &magic_val);

else

return TRUE;

return empty_pattern_magic(p, len, magic_val);

}

static int

empty_pattern_magic(char_u *p, size_t len, magic_T magic_val)

{

// remove trailing \v and the like

while (len >= 2 && p[len - 2] == '\\'

&& vim_strchr((char_u *)"mMvVcCZ", p[len - 1]) != NULL)

len -= 2;

// true, if the pattern is empty, or the pattern ends with \| and magic is

// set (or it ends with '|' and very magic is set)

return len == 0

|| (

len > 1 && p[len - 1] == '|'

&& (

(p[len - 2] == '\\' && magic_val == MAGIC_ON) ||

(p[len - 2] != '\\' && magic_val == MAGIC_ALL)

)

);

}

// Struct to store the viewstate during 'incsearch' highlighting.

typedef struct {

colnr_T vs_curswant;

colnr_T vs_leftcol;

colnr_T vs_skipcol;

linenr_T vs_topline;

# ifdef FEAT_DIFF

int vs_topfill;

# endif

linenr_T vs_botline;

linenr_T vs_empty_rows;

} viewstate_T;

static void

save_viewstate(viewstate_T *vs)

{

vs->vs_curswant = curwin->w_curswant;

vs->vs_leftcol = curwin->w_leftcol;

vs->vs_skipcol = curwin->w_skipcol;

vs->vs_topline = curwin->w_topline;

# ifdef FEAT_DIFF

vs->vs_topfill = curwin->w_topfill;

# endif

vs->vs_botline = curwin->w_botline;

vs->vs_empty_rows = curwin->w_empty_rows;

}

static void

restore_viewstate(viewstate_T *vs)

{

curwin->w_curswant = vs->vs_curswant;

curwin->w_leftcol = vs->vs_leftcol;

curwin->w_skipcol = vs->vs_skipcol;

curwin->w_topline = vs->vs_topline;

# ifdef FEAT_DIFF

curwin->w_topfill = vs->vs_topfill;

# endif

curwin->w_botline = vs->vs_botline;

curwin->w_empty_rows = vs->vs_empty_rows;

}

// Struct to store the state of 'incsearch' highlighting.

typedef struct {

pos_T search_start; // where 'incsearch' starts searching

pos_T save_cursor;

int winid; // window where this state is valid

viewstate_T init_viewstate;

viewstate_T old_viewstate;

pos_T match_start;

pos_T match_end;

int did_incsearch;

int incsearch_postponed;

optmagic_T magic_overruled_save;

} incsearch_state_T;

static void

init_incsearch_state(incsearch_state_T *is_state)

{

is_state->winid = curwin->w_id;

is_state->match_start = curwin->w_cursor;

is_state->did_incsearch = FALSE;

is_state->incsearch_postponed = FALSE;

is_state->magic_overruled_save = magic_overruled;

CLEAR_POS(&is_state->match_end);

is_state->save_cursor = curwin->w_cursor; // may be restored later

is_state->search_start = curwin->w_cursor;

save_viewstate(&is_state->init_viewstate);

save_viewstate(&is_state->old_viewstate);

}

/*

* First move cursor to end of match, then to the start. This

* moves the whole match onto the screen when 'nowrap' is set.

*/

static void

set_search_match(pos_T *t)

{

t->lnum += search_match_lines;

t->col = search_match_endcol;

if (t->lnum > curbuf->b_ml.ml_line_count)

{

t->lnum = curbuf->b_ml.ml_line_count;

coladvance((colnr_T)MAXCOL);

}

}

/*

* Parses the :[range]s/foo like commands and returns details needed for

* incsearch and wildmenu completion.

* Returns TRUE if pattern is valid.

* Sets skiplen, patlen, search_first_line, and search_last_line.

*/

int

parse_pattern_and_range(

pos_T *incsearch_start,

int *search_delim,

int *skiplen,

int *patlen)

{

char_u *cmd, *p, *end;

cmdmod_T dummy_cmdmod;

exarg_T ea;

pos_T save_cursor;

int delim_optional = FALSE;

int delim;

int use_last_pat;

magic_T magic = 0;

char *dummy;

*skiplen = 0;

*patlen = ccline.cmdlen;

// Default range

search_first_line = 0;

search_last_line = MAXLNUM;

CLEAR_FIELD(ea);

ea.line1 = 1;

ea.line2 = 1;

ea.cmd = ccline.cmdbuff;

ea.addr_type = ADDR_LINES;

// Skip over command modifiers

parse_command_modifiers(&ea, &dummy, &dummy_cmdmod, TRUE);

// Skip over the range to find the command.

cmd = skip_range(ea.cmd, TRUE, NULL);

if (vim_strchr((char_u *)"sgvlu", *cmd) == NULL)

return FALSE;

// Skip over command name to find pattern separator

for (p = cmd; ASCII_ISALPHA(*p); ++p)

;

if (*skipwhite(p) == NUL)

return FALSE;

if (STRNCMP(cmd, "substitute", p - cmd) == 0

|| STRNCMP(cmd, "smagic", p - cmd) == 0

|| STRNCMP(cmd, "snomagic", MAX(p - cmd, 3)) == 0

|| STRNCMP(cmd, "vglobal", p - cmd) == 0)

{

if (*cmd == 's' && cmd[1] == 'm')

magic_overruled = OPTION_MAGIC_ON;

else if (*cmd == 's' && cmd[1] == 'n')

magic_overruled = OPTION_MAGIC_OFF;

}

else if (STRNCMP(cmd, "sort", MAX(p - cmd, 3)) == 0

|| STRNCMP(cmd, "uniq", MAX(p - cmd, 3)) == 0)

{

// skip over ! and flags

if (*p == '!')

p = skipwhite(p + 1);

while (ASCII_ISALPHA(*(p = skipwhite(p))))

++p;

if (*p == NUL)

return FALSE;

}

else if (STRNCMP(cmd, "vimgrep", MAX(p - cmd, 3)) == 0

|| STRNCMP(cmd, "vimgrepadd", MAX(p - cmd, 8)) == 0

|| STRNCMP(cmd, "lvimgrep", MAX(p - cmd, 2)) == 0

|| STRNCMP(cmd, "lvimgrepadd", MAX(p - cmd, 9)) == 0

|| STRNCMP(cmd, "global", p - cmd) == 0)

{

// skip optional "!"

if (*p == '!')

{

p++;

if (*skipwhite(p) == NUL)

return FALSE;

}

if (*cmd != 'g')

delim_optional = TRUE;

}

else

return FALSE;

p = skipwhite(p);

delim = (delim_optional && vim_isIDc(*p)) ? ' ' : *p++;

*search_delim = delim;

end = skip_regexp_ex(p, delim, magic_isset(), NULL, NULL, &magic);

use_last_pat = end == p && *end == delim;

if (end == p && !use_last_pat)

return FALSE;

// Skip if the pattern matches everything (e.g., for 'hlsearch')

if (!use_last_pat)

{

char c = *end;

int empty;

*end = NUL;

empty = empty_pattern_magic(p, (size_t)(end - p), magic);

*end = c;

if (empty)

return FALSE;

}

// Found a non-empty pattern or //

*skiplen = (int)(p - ccline.cmdbuff);

*patlen = (int)(end - p);

// Parse the address range

save_cursor = curwin->w_cursor;

curwin->w_cursor = *incsearch_start;

parse_cmd_address(&ea, &dummy, TRUE);

if (ea.addr_count > 0)

{

int reverse_match = ea.line2 < ea.line1;

search_first_line = reverse_match ? ea.line2 : ea.line1;

search_last_line = reverse_match ? ea.line1 : ea.line2;

}

else if (cmd[0] == 's' && cmd[1] != 'o')

// :s defaults to the current line

search_first_line = search_last_line = curwin->w_cursor.lnum;

curwin->w_cursor = save_cursor;

return TRUE;

}

/*

* Return TRUE when 'incsearch' highlighting is to be done.

* Sets search_first_line and search_last_line to the address range.

* May change the last search pattern.

*/

static int

do_incsearch_highlighting(

int firstc,

int *search_delim,

incsearch_state_T *is_state,

int *skiplen,

int *patlen)

{

int retval = FALSE;

*skiplen = 0;

*patlen = ccline.cmdlen;

if (!p_is || cmd_silent)

return FALSE;

// By default search all lines

search_first_line = 0;

search_last_line = MAXLNUM;

if (firstc == '/' || firstc == '?')

{

*search_delim = firstc;

return TRUE;

}

if (firstc != ':')

return FALSE;

++emsg_off;

retval = parse_pattern_and_range(&is_state->search_start, search_delim,

skiplen, patlen);

--emsg_off;

return retval;

}

static void

finish_incsearch_highlighting(

int gotesc,

incsearch_state_T *is_state,

int call_update_screen)

{

if (!is_state->did_incsearch)

return;

is_state->did_incsearch = FALSE;

if (gotesc)

curwin->w_cursor = is_state->save_cursor;

else

{

if (!EQUAL_POS(is_state->save_cursor, is_state->search_start))

{

// put the '" mark at the original position

curwin->w_cursor = is_state->save_cursor;

setpcmark();

}

curwin->w_cursor = is_state->search_start;

}

restore_viewstate(&is_state->old_viewstate);

highlight_match = FALSE;

// by default search all lines

search_first_line = 0;

search_last_line = MAXLNUM;

magic_overruled = is_state->magic_overruled_save;

validate_cursor(); // needed for TAB

status_redraw_all();

redraw_all_later(UPD_SOME_VALID);

if (call_update_screen)

update_screen(UPD_SOME_VALID);

}

/*

* Do 'incsearch' highlighting if desired.

*/

static void

may_do_incsearch_highlighting(

int firstc,

long count,

incsearch_state_T *is_state)

{

int skiplen, patlen;

int found; // do_search() result

pos_T end_pos;

# ifdef FEAT_RELTIME

searchit_arg_T sia;

# endif

int next_char;

int use_last_pat;

int did_do_incsearch = is_state->did_incsearch;

int search_delim;

// Parsing range may already set the last search pattern.

// NOTE: must call restore_last_search_pattern() before returning!

save_last_search_pattern();

if (!do_incsearch_highlighting(firstc, &search_delim, is_state,

&skiplen, &patlen))

{

restore_last_search_pattern();

finish_incsearch_highlighting(FALSE, is_state, TRUE);

if (did_do_incsearch && vpeekc() == NUL)

// may have skipped a redraw, do it now

redrawcmd();

return;

}

// If there is a character waiting, search and redraw later.

if (char_avail())

{

restore_last_search_pattern();

is_state->incsearch_postponed = TRUE;

return;

}

is_state->incsearch_postponed = FALSE;

if (search_first_line == 0)

// start at the original cursor position

curwin->w_cursor = is_state->search_start;

else if (search_first_line > curbuf->b_ml.ml_line_count)

{

// start after the last line

curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;

curwin->w_cursor.col = MAXCOL;

}

else

{

// start at the first line in the range

curwin->w_cursor.lnum = search_first_line;

curwin->w_cursor.col = 0;

}

// Use the previous pattern for ":s//".

next_char = ccline.cmdbuff[skiplen + patlen];

use_last_pat = patlen == 0 && skiplen > 0

&& ccline.cmdbuff[skiplen - 1] == next_char;

// If there is no pattern, don't do anything.

if (patlen == 0 && !use_last_pat)

{

found = 0;

set_no_hlsearch(TRUE); // turn off previous highlight

redraw_all_later(UPD_SOME_VALID);

}

else

{

int search_flags = SEARCH_OPT + SEARCH_NOOF + SEARCH_PEEK;

cursor_off(); // so the user knows we're busy

out_flush();

++emsg_off; // so it doesn't beep if bad expr

if (!p_hls)

search_flags += SEARCH_KEEP;

if (search_first_line != 0)

search_flags += SEARCH_START;

ccline.cmdbuff[skiplen + patlen] = NUL;

# ifdef FEAT_RELTIME

CLEAR_FIELD(sia);

// Set the time limit to half a second.

sia.sa_tm = 500;

# endif

found = do_search(NULL, firstc == ':' ? '/' : firstc, search_delim,

ccline.cmdbuff + skiplen, patlen, count, search_flags,

# ifdef FEAT_RELTIME

&sia

# else

NULL

# endif

);

ccline.cmdbuff[skiplen + patlen] = next_char;

--emsg_off;

if (curwin->w_cursor.lnum < search_first_line

|| curwin->w_cursor.lnum > search_last_line)

{

// match outside of address range

found = 0;

curwin->w_cursor = is_state->search_start;

}

// 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

found = 0;

}

else if (char_avail())

// cancelled searching because a char was typed

is_state->incsearch_postponed = TRUE;

}

if (found != 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.

restore_viewstate(&is_state->old_viewstate);

changed_cline_bef_curs();

update_topline();

if (found != 0)

{

pos_T save_pos = curwin->w_cursor;

is_state->match_start = curwin->w_cursor;

set_search_match(&curwin->w_cursor);

validate_cursor();

end_pos = curwin->w_cursor;

is_state->match_end = end_pos;

curwin->w_cursor = save_pos;

}

else

end_pos = curwin->w_cursor; // shutup gcc 4

// Disable 'hlsearch' highlighting if the pattern matches everything.

// Avoids a flash when typing "foo\|".

if (!use_last_pat)

{

next_char = ccline.cmdbuff[skiplen + patlen];

ccline.cmdbuff[skiplen + patlen] = NUL;

if (empty_pattern(ccline.cmdbuff + skiplen, (size_t)patlen, search_delim)

&& !no_hlsearch)

{

redraw_all_later(UPD_SOME_VALID);

set_no_hlsearch(TRUE);

}

ccline.cmdbuff[skiplen + patlen] = next_char;

}

validate_cursor();

// May redraw the status line to show the cursor position.

if (p_ru && curwin->w_status_height > 0)

curwin->w_redr_status = true;

update_screen(UPD_SOME_VALID);

highlight_match = FALSE;

restore_last_search_pattern();

// Leave it at the end to make CTRL-R CTRL-W work. But not when beyond the

// end of the pattern, e.g. for ":s/pat/".

if (ccline.cmdbuff[skiplen + patlen] != NUL)

curwin->w_cursor = is_state->search_start;

else if (found != 0)

curwin->w_cursor = end_pos;

msg_starthere();

redrawcmdline();

is_state->did_incsearch = TRUE;

}

/*

* May adjust 'incsearch' highlighting for typing CTRL-G and CTRL-T, go to next

* or previous match.

* Returns FAIL when jumping to cmdline_not_changed;

*/

static int

may_adjust_incsearch_highlighting(

int firstc,

long count,

incsearch_state_T *is_state,

int c)

{

int skiplen, patlen;

pos_T t;

char_u *pat;

char_u *dircp = NULL;

char_u *searchstr;

char_u *strcopy = NULL;

size_t searchstrlen;

size_t patlen_s;

soffset_T offset;

int search_flags = SEARCH_NOOF;

int i;

int search_delim;

// Parsing range may already set the last search pattern.

// NOTE: must call restore_last_search_pattern() before returning!

save_last_search_pattern();

if (!do_incsearch_highlighting(firstc, &search_delim, is_state,

&skiplen, &patlen))

{

restore_last_search_pattern();

return OK;

}

if (patlen == 0 && ccline.cmdbuff[skiplen] == NUL)

{

restore_last_search_pattern();

return FAIL;

}

pat = ccline.cmdbuff + skiplen;

searchstr = pat;

searchstrlen = (size_t)patlen;

patlen_s = (size_t)(ccline.cmdlen - skiplen);

// do not search for the search end delimiter,

// unless it is part of the pattern

(void)parse_search_pattern_offset(&pat, &patlen_s, search_delim,

SEARCH_OPT, &strcopy, &searchstr,

&searchstrlen, &dircp, &offset);

cursor_off();

out_flush();

if (c == Ctrl_G)

{

t = is_state->match_end;

if (LT_POS(is_state->match_start, is_state->match_end))

// Start searching at the end of the match not at the beginning of

// the next column.

(void)decl(&t);

search_flags += SEARCH_COL;

}

else

t = is_state->match_start;

if (!p_hls)

search_flags += SEARCH_KEEP;

++emsg_off;

i = searchit(curwin, curbuf, &t, NULL,

c == Ctrl_G ? FORWARD : BACKWARD,

searchstr, searchstrlen, count, search_flags, RE_SEARCH, NULL);

--emsg_off;

if (dircp != NULL)

*dircp = search_delim;

if (i)

{

pos_T match_start = is_state->match_start;

pos_T match_end = is_state->match_end;

long off = offset.off;

is_state->search_start = match_start;

if (!offset.line && (offset.end || off != 0))

{

if (offset.end)

{

is_state->search_start = match_end;

(void)decl(&is_state->search_start);

}

while (off > 0)

{

if (incl(&is_state->search_start) == -1)

break;

--off;

}

while (off < 0)

{

if (decl(&is_state->search_start) == -1)

break;

++off;

}

}

is_state->match_end = t;

is_state->match_start = t;

if (c == Ctrl_T && firstc != '?')

{

// Move just before the current match, so that when nv_search

// finishes the cursor will be put back on the match.

is_state->search_start = t;

(void)decl(&is_state->search_start);

}

else if (c == Ctrl_G && firstc == '?')

{

// Move just after the current match, so that when nv_search

// finishes the cursor will be put back on the match.

is_state->search_start = t;

(void)incl(&is_state->search_start);

}

if (LT_POS(t, is_state->search_start) && c == Ctrl_G)

{

// wrap around

is_state->search_start = t;

if (firstc == '?')

(void)incl(&is_state->search_start);

else

(void)decl(&is_state->search_start);

}

set_search_match(&is_state->match_end);

curwin->w_cursor = is_state->match_start;

changed_cline_bef_curs();

update_topline();

validate_cursor();

highlight_match = TRUE;

save_viewstate(&is_state->old_viewstate);

update_screen(UPD_NOT_VALID);

highlight_match = FALSE;

redrawcmdline();

curwin->w_cursor = is_state->match_end;

}

else

vim_beep(BO_ERROR);

vim_free(strcopy);

restore_last_search_pattern();

return FAIL;

}

/*

* When CTRL-L typed: add character from the match to the pattern.

* May set "*c" to the added character.

* Return OK when jumping to cmdline_not_changed.

*/

static int

may_add_char_to_search(int firstc, int *c, incsearch_state_T *is_state)

{

int skiplen, patlen, search_delim;

// Parsing range may already set the last search pattern.

// NOTE: must call restore_last_search_pattern() before returning!

save_last_search_pattern();

if (!do_incsearch_highlighting(firstc, &search_delim, is_state,

&skiplen, &patlen))

{

restore_last_search_pattern();

return FAIL;

}

restore_last_search_pattern();

// Add a character from under the cursor for 'incsearch'.

if (is_state->did_incsearch)

{

curwin->w_cursor = is_state->match_end;

*c = gchar_cursor();

if (*c != NUL)

{

// If 'ignorecase' and 'smartcase' are set and the

// command line has no uppercase characters, convert

// the character to lowercase.

if (p_ic && p_scs && !pat_has_uppercase(ccline.cmdbuff + skiplen))

*c = MB_TOLOWER(*c);

if (*c == search_delim || vim_strchr((char_u *)(

magic_isset() ? "\\~^$.*[" : "\\^$"), *c) != NULL)

{

// put a backslash before special characters

stuffcharReadbuff(*c);

*c = '\\';

}

// add any composing characters

if (mb_char2len(*c) != mb_ptr2len(ml_get_cursor()))

{

int save_c = *c;

while (mb_char2len(*c) != mb_ptr2len(ml_get_cursor()))

{

curwin->w_cursor.col += mb_char2len(*c);

*c = gchar_cursor();

stuffcharReadbuff(*c);

}

*c = save_c;

}

return FAIL;

}

}

return OK;

}

#endif

#ifdef FEAT_ARABIC

/*

* Return TRUE if the command line has an Arabic character at or after "start"

* for "len" bytes.

*/

static int

cmdline_has_arabic(int start, int len)

{

int j;

int mb_l;

int u8c;

char_u *p;

int u8cc[MAX_MCO];

if (!enc_utf8)

return FALSE;

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))

return TRUE;

}

return FALSE;

}

#endif

void

cmdline_init(void)

{

CLEAR_FIELD(ccline);

}

/*

* Handle CTRL-\ pressed in Command-line mode:

* - CTRL-\ CTRL-N goes to Normal mode

* - CTRL-\ CTRL-G goes to Insert mode when 'insertmode' is set

* - CTRL-\ e prompts for an expression.

*/

static int

cmdline_handle_ctrl_bsl(int c, int *gotesc)

{

++no_mapping;

++allow_keys;

c = plain_vgetc();

--no_mapping;

--allow_keys;

// CTRL-\ e doesn't work when obtaining an expression, unless it

// is in a mapping.

if (c != Ctrl_N && c != Ctrl_G && (c != 'e'

|| (ccline.cmdfirstc == '=' && KeyTyped)

#ifdef FEAT_EVAL

|| cmdline_star > 0

#endif

))

{

vungetc(c);

return PROCESS_NEXT_KEY;

}

#ifdef FEAT_EVAL

if (c == 'e')

{

/*

* Replace the command line with the result of an expression.

* This will call getcmdline() recursively in get_expr_register().

*/

if (ccline.cmdpos == ccline.cmdlen)

new_cmdpos = 99999; // keep it at the end

else

new_cmdpos = ccline.cmdpos;

c = get_expr_register();

if (c == '=')

{

char_u *p = NULL;

// Evaluate the expression. Set "textlock" to avoid nasty things

// like going to another buffer.

++textlock;

p = get_expr_line();

--textlock;

if (p != NULL)

{

int len = (int)STRLEN(p);

if (realloc_cmdbuff(len + 1) == OK)

{

ccline.cmdlen = len;

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();

return CMDLINE_CHANGED;

}

vim_free(p);

}

}

beep_flush();

got_int = FALSE; // don't abandon the command line

did_emsg = FALSE;

emsg_on_display = FALSE;

redrawcmd();

return CMDLINE_NOT_CHANGED;

}

#endif

if (c == Ctrl_G && p_im && restart_edit == 0)

restart_edit = 'a';

*gotesc = TRUE; // will free ccline.cmdbuff after putting it

// in history

return GOTO_NORMAL_MODE;

}

/*

* 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

* Returns CMDLINE_CHANGED if command line is changed or CMDLINE_NOT_CHANGED.

*/

static int

cmdline_wildchar_complete(

int c,

int escape,

int *did_wild_list,

int *wim_index_p,

expand_T *xp,

int *gotesc,

int redraw_if_menu_empty,

pos_T *pre_incsearch_pos)

{

int wim_index = *wim_index_p;

int res;

int cmdpos_before;

int options = WILD_NO_BEEP;

int wim_noselect = p_wmnu && (wim_flags[0] & WIM_NOSELECT);

if (wim_flags[wim_index] & WIM_BUFLASTUSED)

options |= WILD_BUFLASTUSED;

if (xp->xp_numfiles > 0) // typed p_wc at least twice

{

// If "list" is present, list matches unless already listed

if (xp->xp_numfiles > 1

&& !*did_wild_list

&& (wim_flags[wim_index] & WIM_LIST))

{

(void)showmatches(xp, FALSE, TRUE, wim_noselect);

redrawcmd();

*did_wild_list = TRUE;

}

if (wim_flags[wim_index] & WIM_LONGEST)

res = nextwild(xp, WILD_LONGEST, options, escape);

else if (wim_flags[wim_index] & WIM_FULL)

res = nextwild(xp, WILD_NEXT, options, escape);

else

res = OK; // don't insert 'wildchar' now

}

else // typed p_wc first time

{

int wim_longest = (wim_flags[0] & WIM_LONGEST);

int wim_list = (wim_flags[0] & WIM_LIST);

int wim_full = (wim_flags[0] & WIM_FULL);

wim_index = 0;

if (c == p_wc || c == p_wcm || c == K_WILD)

{

options |= WILD_MAY_EXPAND_PATTERN;

if (c == K_WILD)

options |= WILD_FUNC_TRIGGER;

if (pre_incsearch_pos)

xp->xp_pre_incsearch_pos = *pre_incsearch_pos;

else

xp->xp_pre_incsearch_pos = curwin->w_cursor;

}

cmdpos_before = ccline.cmdpos;