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

#ifndef MAX

# define MAX(x,y) ((x) > (y) ? (x) : (y))

#endif

// 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 init_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 alloc_cmdbuff(int 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);

#ifdef FEAT_WILDMENU

static void cmdline_del(int from);

#endif

static void redrawcmdprompt(void);

static int ccheck_abbr(int);

#ifdef FEAT_CMDWIN

static int open_cmdwin(void);

#endif

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)

{

VIM_CLEAR(ccline.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 n = STRLEN(p);

/* remove trailing \v and the like */

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

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

n -= 2;

return n == 0 || (n >= 2 && p[n - 2] == '\\' && p[n - 1] == '|');

}

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

typedef struct {

colnr_T vs_curswant;

colnr_T vs_leftcol;

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_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_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;

viewstate_T init_viewstate;

viewstate_T old_viewstate;

pos_T match_start;

pos_T match_end;

int did_incsearch;

int incsearch_postponed;

int magic_save;

} incsearch_state_T;

static void

init_incsearch_state(incsearch_state_T *is_state)

{

is_state->match_start = curwin->w_cursor;

is_state->did_incsearch = FALSE;

is_state->incsearch_postponed = FALSE;

is_state->magic_save = p_magic;

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

}

}

/*

* 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, incsearch_state_T *is_state,

int *skiplen, int *patlen)

{

char_u *cmd;

cmdmod_T save_cmdmod = cmdmod;

char_u *p;

int delim_optional = FALSE;

int delim;

char_u *end;

char *dummy;

exarg_T ea;

pos_T save_cursor;

int use_last_pat;

*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 == '?')

return TRUE;

if (firstc != ':')

return FALSE;

vim_memset(&ea, 0, sizeof(ea));

ea.line1 = 1;

ea.line2 = 1;

ea.cmd = ccline.cmdbuff;

ea.addr_type = ADDR_LINES;

parse_command_modifiers(&ea, &dummy, TRUE);

cmdmod = save_cmdmod;

cmd = skip_range(ea.cmd, NULL);

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

return FALSE;

// Skip over "substitute" to find the 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')

p_magic = TRUE;

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

p_magic = FALSE;

}

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

{

// skip over flags

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 over "!"

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++;

end = skip_regexp(p, delim, p_magic, NULL);

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

if (end == p && !use_last_pat)

return FALSE;

// Don't do 'hlsearch' highlighting if the pattern matches everything.

if (!use_last_pat)

{

char c = *end;

int empty;

*end = NUL;

empty = empty_pattern(p);

*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 = is_state->search_start;

parse_cmd_address(&ea, &dummy, TRUE);

if (ea.addr_count > 0)

{

// Allow for reverse match.

if (ea.line2 < ea.line1)

{

search_first_line = ea.line2;

search_last_line = ea.line1;

}

else

{

search_first_line = ea.line1;

search_last_line = ea.line2;

}

}

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

{

// :s defaults to the current line

search_first_line = curwin->w_cursor.lnum;

search_last_line = curwin->w_cursor.lnum;

}

curwin->w_cursor = save_cursor;

return TRUE;

}

static void

finish_incsearch_highlighting(

int gotesc,

incsearch_state_T *is_state,

int call_update_screen)

{

if (is_state->did_incsearch)

{

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;

p_magic = is_state->magic_save;

validate_cursor(); /* needed for TAB */

redraw_all_later(SOME_VALID);

if (call_update_screen)

update_screen(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

proftime_T tm;

searchit_arg_T sia;

#endif

int next_char;

int use_last_pat;

int did_do_incsearch = is_state->did_incsearch;

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

#ifdef FEAT_RELTIME

// Set the time limit to half a second.

profile_setlimit(500L, &tm);

#endif

if (!p_hls)

search_flags += SEARCH_KEEP;

if (search_first_line != 0)

search_flags += SEARCH_START;

ccline.cmdbuff[skiplen + patlen] = NUL;

#ifdef FEAT_RELTIME

vim_memset(&sia, 0, sizeof(sia));

sia.sa_tm = &tm;

#endif

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

ccline.cmdbuff + skiplen, 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) && !no_hlsearch)

{

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

int search_flags = SEARCH_NOOF;

int i;

int save;

// 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, is_state, &skiplen, &patlen))

{

restore_last_search_pattern();

return OK;

}

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

{

restore_last_search_pattern();

return FAIL;

}

if (firstc == ccline.cmdbuff[skiplen])

{

pat = last_search_pattern();

skiplen = 0;

patlen = (int)STRLEN(pat);

}

else

pat = ccline.cmdbuff + skiplen;

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;

save = pat[patlen];

pat[patlen] = NUL;

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

c == Ctrl_G ? FORWARD : BACKWARD,

pat, count, search_flags, RE_SEARCH, NULL);

--emsg_off;

pat[patlen] = save;

if (i)

{

is_state->search_start = is_state->match_start;

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

highlight_match = FALSE;

redrawcmdline();

curwin->w_cursor = is_state->match_end;

}

else

vim_beep(BO_ERROR);

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;

// 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, 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 == firstc || vim_strchr((char_u *)(

p_magic ? "\\~^$.*[" : "\\^$"), *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)

{

vim_memset(&ccline, 0, sizeof(cmdline_info_T));

}

/*

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

*/

char_u *

getcmdline(

int firstc,

long count, // only used for incremental search

int indent, // indent for inside conditionals

int do_concat UNUSED)

{

return getcmdline_int(firstc, count, indent, TRUE);

}

static char_u *

getcmdline_int(

int firstc,

long count UNUSED, // only used for incremental search

int indent, // indent for inside conditionals

int init_ccline) // clear ccline first

{

int c;

int i;

int j;

int gotesc = FALSE; /* TRUE when <ESC> just typed */

int do_abbr; /* when TRUE check for abbr. */

char_u *lookfor = NULL; /* string to match */

int hiscnt; /* current history line in use */

int histype; /* history type to be used */

#ifdef FEAT_SEARCH_EXTRA

incsearch_state_T is_state;

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

/* mouse drag and release events are ignored, unless they are

* preceded with a mouse down event */

int ignore_drag_release = TRUE;

#ifdef FEAT_EVAL

int break_ctrl_c = FALSE;

#endif

expand_T xpc;

long *b_im_ptr = NULL;

cmdline_info_T save_ccline;

int did_save_ccline = FALSE;

int cmdline_type;

if (ccline.cmdbuff != NULL)

{

// Being called recursively. Since ccline is global, we need to save

// the current buffer and restore it when returning.

save_cmdline(&save_ccline);

did_save_ccline = TRUE;

}

if (init_ccline)

vim_memset(&ccline, 0, sizeof(cmdline_info_T));

#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

init_incsearch_state(&is_state);

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

goto theend; // out of memory

ccline.cmdlen = ccline.cmdpos = 0;

ccline.cmdbuff[0] = NUL;

sb_text_start_cmdline();

/* autoindent for :insert and :append */

if (firstc <= 0)

{

vim_memset(ccline.cmdbuff, ' ', indent);

ccline.cmdbuff[indent] = NUL;

ccline.cmdpos = indent;

ccline.cmdspos = indent;

ccline.cmdlen = indent;

}

ExpandInit(&xpc);

ccline.xpc = &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 HAVE_INPUT_METHOD

im_set_active(*b_im_ptr == B_IMODE_IM);

#endif

}

#ifdef HAVE_INPUT_METHOD

else if (p_imcmdline)

im_set_active(TRUE);

#endif

setmouse();

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

/* Trigger CmdlineEnter autocommands. */

cmdline_type = firstc == NUL ? '-' : firstc;

trigger_cmd_autocmd(cmdline_type, EVENT_CMDLINEENTER);

init_history();

hiscnt = get_hislen(); /* set hiscnt to impossible history value */

histype = hist_char2type(firstc);

#ifdef FEAT_DIGRAPHS

do_digraph(-1); /* init digraph typeahead */

#endif

/* If something above caused an error, reset the flags, we do want to type

* and execute commands. Display may be messed up a bit. */

if (did_emsg)

redrawcmd();

did_emsg = FALSE;

got_int = FALSE;

/*

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

did_emsg = FALSE; /* There can't really be a reason why an error

that occurs while typing a command should

cause the command not to be executed. */

// Trigger SafeState if nothing is pending.

may_trigger_safestate(xpc.xp_numfiles <= 0);

cursorcmd(); /* set the cursor on the right spot */

/* Get a character. Ignore K_IGNORE and K_NOP, they should not do

* anything, such as stop completion. */

do

c = safe_vgetc();

while (c == K_IGNORE || c == K_NOP);

if (KeyTyped)

{

some_key_typed = TRUE;

#ifdef FEAT_RIGHTLEFT

if (cmd_hkmap)

c = hkmap(c);

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;