Problem: The mode #defines are not clearly named.
Solution: Prepend MODE_. Renumber them to put the mapped modes first.
static int
has_cursorhold(void)
{
- return (first_autopat[(int)(get_real_state() == NORMAL_BUSY
+ return (first_autopat[(int)(get_real_state() == MODE_NORMAL_BUSY
? EVENT_CURSORHOLD : EVENT_CURSORHOLDI)] != NULL);
}
&& !ins_compl_active())
{
state = get_real_state();
- if (state == NORMAL_BUSY || (state & INSERT) != 0)
+ if (state == MODE_NORMAL_BUSY || (state & MODE_INSERT) != 0)
return TRUE;
}
return FALSE;
// another window, might be a timer doing something in another
// window.
if (prevbuf == curbuf
- && ((State & INSERT) == 0 || curbuf->b_nwindows <= 1))
+ && ((State & MODE_INSERT) == 0 || curbuf->b_nwindows <= 1))
u_sync(FALSE);
close_buffer(prevbuf == curwin->w_buffer ? curwin : NULL, prevbuf,
unload ? action : (action == DOBUF_GOTO
break;
case STL_COLUMN:
- num = !(State & INSERT) && empty_line
- ? 0 : (int)wp->w_cursor.col + 1;
+ num = (State & MODE_INSERT) == 0 && empty_line
+ ? 0 : (int)wp->w_cursor.col + 1;
break;
case STL_VIRTCOL:
virtcol = wp->w_virtcol + 1;
// Don't display %V if it's the same as %c.
if (opt == STL_VIRTCOL_ALT
- && (virtcol == (colnr_T)(!(State & INSERT) && empty_line
- ? 0 : (int)wp->w_cursor.col + 1)))
+ && (virtcol == (colnr_T)((State & MODE_INSERT) == 0
+ && empty_line ? 0 : (int)wp->w_cursor.col + 1)))
break;
num = (long)virtcol;
break;
case STL_OFFSET:
#ifdef FEAT_BYTEOFF
l = ml_find_line_or_offset(wp->w_buffer, wp->w_cursor.lnum, NULL);
- num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) || l < 0 ?
- 0L : l + 1 + (!(State & INSERT) && empty_line ?
- 0 : (int)wp->w_cursor.col);
+ num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) || l < 0
+ ? 0L : l + 1 + ((State & MODE_INSERT) == 0 && empty_line
+ ? 0 : (int)wp->w_cursor.col);
#endif
break;
/*
* Insert or replace a single character at the cursor position.
- * When in REPLACE or VREPLACE mode, replace any existing character.
+ * When in MODE_REPLACE or MODE_VREPLACE state, replace any existing character.
* Caller must have prepared for undo.
* For multi-byte characters we get the whole character, the caller must
* convert bytes to a character.
// If we're in Insert or Replace mode and 'showmatch' is set, then briefly
// show the match for right parens and braces.
- if (p_sm && (State & INSERT)
+ if (p_sm && (State & MODE_INSERT)
&& msg_silent == 0
&& !ins_compl_active())
{
/*
* open_line: Add a new line below or above the current line.
*
- * For VREPLACE mode, we only add a new line when we get to the end of the
- * file, otherwise we just start replacing the next line.
+ * For MODE_VREPLACE state, we only add a new line when we get to the end of
+ * the file, otherwise we just start replacing the next line.
*
- * Caller must take care of undo. Since VREPLACE may affect any number of
+ * Caller must take care of undo. Since MODE_VREPLACE may affect any number of
* lines however, it may call u_save_cursor() again when starting to change a
* new line.
* "flags": OPENLINE_DELSPACES delete spaces after cursor
if (State & VREPLACE_FLAG)
{
- // With VREPLACE we make a copy of the next line, which we will be
+ // With MODE_VREPLACE we make a copy of the next line, which we will be
// starting to replace. First make the new line empty and let vim play
// with the indenting and comment leader to its heart's content. Then
// we grab what it ended up putting on the new line, put back the
if (next_line == NULL) // out of memory!
goto theend;
- // In VREPLACE mode, a NL replaces the rest of the line, and starts
- // replacing the next line, so push all of the characters left on the
- // line onto the replace stack. We'll push any other characters that
- // might be replaced at the start of the next line (due to autoindent
- // etc) a bit later.
+ // In MODE_VREPLACE state, a NL replaces the rest of the line, and
+ // starts replacing the next line, so push all of the characters left
+ // on the line onto the replace stack. We'll push any other characters
+ // that might be replaced at the start of the next line (due to
+ // autoindent etc) a bit later.
replace_push(NUL); // Call twice because BS over NL expects it
replace_push(NUL);
p = saved_line + curwin->w_cursor.col;
saved_line[curwin->w_cursor.col] = NUL;
}
- if ((State & INSERT) && !(State & VREPLACE_FLAG))
+ if ((State & MODE_INSERT) && (State & VREPLACE_FLAG) == 0)
{
p_extra = saved_line + curwin->w_cursor.col;
#ifdef FEAT_SMARTINDENT
}
}
- // (State == INSERT || State == REPLACE), only when dir == FORWARD
+ // (State == MODE_INSERT || State == MODE_REPLACE), only when dir == FORWARD
if (p_extra != NULL)
{
*p_extra = saved_char; // restore char that NUL replaced
// When 'ai' set or "flags" has OPENLINE_DELSPACES, skip to the first
// non-blank.
//
- // When in REPLACE mode, put the deleted blanks on the replace stack,
- // preceded by a NUL, so they can be put back when a BS is entered.
+ // When in MODE_REPLACE state, put the deleted blanks on the replace
+ // stack, preceded by a NUL, so they can be put back when a BS is
+ // entered.
if (REPLACE_NORMAL(State))
replace_push(NUL); // end of extra blanks
if (curbuf->b_p_ai || (flags & OPENLINE_DELSPACES))
mark_adjust(curwin->w_cursor.lnum + 1, (linenr_T)MAXLNUM, 1L, 0L);
did_append = TRUE;
#ifdef FEAT_PROP_POPUP
- if ((State & INSERT) && !(State & VREPLACE_FLAG))
+ if ((State & MODE_INSERT) && (State & VREPLACE_FLAG) == 0)
// properties after the split move to the next line
adjust_props_for_split(curwin->w_cursor.lnum, curwin->w_cursor.lnum,
curwin->w_cursor.col + 1, 0);
}
else
{
- // In VREPLACE mode we are starting to replace the next line.
+ // In MODE_VREPLACE state we are starting to replace the next line.
curwin->w_cursor.lnum++;
if (curwin->w_cursor.lnum >= Insstart.lnum + vr_lines_changed)
{
ai_col = curwin->w_cursor.col;
- // In REPLACE mode, for each character in the new indent, there must
- // be a NUL on the replace stack, for when it is deleted with BS
+ // In MODE_REPLACE state, for each character in the new indent, there
+ // must be a NUL on the replace stack, for when it is deleted with BS
if (REPLACE_NORMAL(State))
for (n = 0; n < (int)curwin->w_cursor.col; ++n)
replace_push(NUL);
#endif
}
- // In REPLACE mode, for each character in the extra leader, there must be
- // a NUL on the replace stack, for when it is deleted with BS.
+ // In MODE_REPLACE state, for each character in the extra leader, there
+ // must be a NUL on the replace stack, for when it is deleted with BS.
if (REPLACE_NORMAL(State))
while (lead_len-- > 0)
replace_push(NUL);
if (dir == FORWARD)
{
- if (trunc_line || (State & INSERT))
+ if (trunc_line || (State & MODE_INSERT))
{
// truncate current line at cursor
saved_line[curwin->w_cursor.col] = NUL;
curwin->w_cursor.coladd = 0;
#if defined(FEAT_LISP) || defined(FEAT_CINDENT)
- // In VREPLACE mode, we are handling the replace stack ourselves, so stop
- // fixthisline() from doing it (via change_indent()) by telling it we're in
- // normal INSERT mode.
+ // In MODE_VREPLACE state, we are handling the replace stack ourselves, so
+ // stop fixthisline() from doing it (via change_indent()) by telling it
+ // we're in normal MODE_INSERT state.
if (State & VREPLACE_FLAG)
{
vreplace_mode = State; // So we know to put things right later
- State = INSERT;
+ State = MODE_INSERT;
}
else
vreplace_mode = 0;
State = vreplace_mode;
#endif
- // Finally, VREPLACE gets the stuff on the new line, then puts back the
- // original line, and inserts the new stuff char by char, pushing old stuff
- // onto the replace stack (via ins_char()).
+ // Finally, MODE_VREPLACE gets the stuff on the new line, then puts back
+ // the original line, and inserts the new stuff char by char, pushing old
+ // stuff onto the replace stack (via ins_char()).
if (State & VREPLACE_FLAG)
{
// Put new line in p_extra
if (cursor != NULL)
{
if (*ptr == TAB
- && (State & NORMAL)
+ && (State & MODE_NORMAL)
&& !wp->w_p_list
&& !virtual_active()
&& !(VIsual_active
// inserting new stuff.
// For unknown reasons the cursor might be past the end of the line, thus
// check for that.
- if ((State & INSERT)
+ if ((State & MODE_INSERT)
&& curwin->w_cursor.col < (colnr_T)STRLEN(linecopy)
&& linecopy[curwin->w_cursor.col] == ')')
linecopy[curwin->w_cursor.col] = NUL;
pos_T start, end;
// If visual mode is only due to a redo command ("."), then ignore it
- if (!redo_VIsual_busy && VIsual_active && (State & NORMAL))
+ if (!redo_VIsual_busy && VIsual_active && (State & MODE_NORMAL))
{
if (LT_POS(VIsual, curwin->w_cursor))
{
// selected area. There is no specific redraw command for this,
// just redraw all windows on the current buffer.
if (cbd->owned
- && (get_real_state() == VISUAL
- || get_real_state() == SELECTMODE)
+ && (get_real_state() == MODE_VISUAL
+ || get_real_state() == MODE_SELECT)
&& (cbd == &clip_star ? clip_isautosel_star()
: clip_isautosel_plus())
&& HL_ATTR(HLF_V) != HL_ATTR(HLF_VNC))
// area. There is no specific redraw command for this, just redraw all
// windows on the current buffer.
if (was_owned
- && (get_real_state() == VISUAL
- || get_real_state() == SELECTMODE)
+ && (get_real_state() == MODE_VISUAL
+ || get_real_state() == MODE_SELECT)
&& (cbd == &clip_star ?
clip_isautosel_star() : clip_isautosel_plus())
&& HL_ATTR(HLF_V) != HL_ATTR(HLF_VNC)
static void
clip_copy_selection(Clipboard_T *clip)
{
- if (VIsual_active && (State & NORMAL) && clip->available)
+ if (VIsual_active && (State & MODE_NORMAL) && clip->available)
{
clip_update_selection(clip);
clip_free_selection(clip);
emsg_silent = FALSE; // display error messages
redir_off = TRUE; // don't redirect debug commands
- State = NORMAL;
+ State = MODE_NORMAL;
debug_mode = TRUE;
if (!debug_did_msg)
vim_snprintf((char *)buf, sizeof(buf), "<buffer> %s %s",
((kmap_T *)curbuf->b_kmap_ga.ga_data)[i].from,
((kmap_T *)curbuf->b_kmap_ga.ga_data)[i].to);
- (void)do_map(2, buf, LANGMAP, FALSE);
+ (void)do_map(2, buf, MODE_LANGMAP, FALSE);
}
p_cpo = save_cpo;
for (i = 0; i < curbuf->b_kmap_ga.ga_len; ++i)
{
vim_snprintf((char *)buf, sizeof(buf), "<buffer> %s", kp[i].from);
- (void)do_map(1, buf, LANGMAP, FALSE);
+ (void)do_map(1, buf, MODE_LANGMAP, FALSE);
}
keymap_clear(&curbuf->b_kmap_ga);
// In Insert mode only highlight a word that
// doesn't touch the cursor.
if (spell_hlf != HLF_COUNT
- && (State & INSERT) != 0
+ && (State & MODE_INSERT)
&& wp->w_cursor.lnum == lnum
&& wp->w_cursor.col >=
(colnr_T)(prev_ptr - line)
if (p_imst == IM_ON_THE_SPOT
&& xic != NULL
&& lnum == wp->w_cursor.lnum
- && (State & INSERT)
+ && (State & MODE_INSERT)
&& !p_imdisable
&& im_is_preediting()
&& draw_state == WL_LINE)
/*
* Check if not in Insert mode and the line is empty (will show "0-1").
*/
- if (!(State & INSERT)
+ if ((State & MODE_INSERT) == 0
&& *ml_get_buf(wp->w_buffer, wp->w_cursor.lnum, FALSE) == NUL)
empty_line = TRUE;
// Return when there is nothing to do, screen updating is already
// happening (recursive call), messages on the screen or still starting up.
if (!doit || updating_screen
- || State == ASKMORE || State == HITRETURN
+ || State == MODE_ASKMORE || State == MODE_HITRETURN
|| msg_scrolled
#ifdef FEAT_GUI
|| gui.starting
schar_T *screenline2 = NULL; // copy from ScreenLines2[]
redraw_later(type);
- if (msg_scrolled || (State != NORMAL && State != NORMAL_BUSY) || exiting)
+ if (msg_scrolled || (State != MODE_NORMAL && State != MODE_NORMAL_BUSY)
+ || exiting)
return ret;
// Allocate space to save the text displayed in the command line area.
{
++redrawing_for_callback;
- if (State == HITRETURN || State == ASKMORE || State == SETWSIZE
- || State == EXTERNCMD || State == CONFIRM || exmode_active)
+ if (State == MODE_HITRETURN || State == MODE_ASKMORE
+ || State == MODE_SETWSIZE || State == MODE_EXTERNCMD
+ || State == MODE_CONFIRM || exmode_active)
{
if (do_message)
repeat_message();
}
- else if (State & CMDLINE)
+ else if (State & MODE_CMDLINE)
{
#ifdef FEAT_WILDMENU
if (pum_visible())
redrawcmdline_ex(FALSE);
}
}
- else if (State & (NORMAL | INSERT | TERMINAL))
+ else if (State & (MODE_NORMAL | MODE_INSERT | MODE_TERMINAL))
{
update_topline();
validate_cursor();
int old_topfill = -1;
#endif
int inserted_space = FALSE; // just inserted a space
- int replaceState = REPLACE;
+ int replaceState = MODE_REPLACE;
int nomove = FALSE; // don't move cursor on return
#ifdef FEAT_JOB_CHANNEL
int cmdchar_todo = cmdchar;
int save_state = State;
curwin->w_cursor = save_cursor;
- State = INSERT;
+ State = MODE_INSERT;
check_cursor_col();
State = save_state;
}
if (cmdchar == 'R')
{
- State = REPLACE;
+ State = MODE_REPLACE;
}
else if (cmdchar == 'V' || cmdchar == 'v')
{
- State = VREPLACE;
- replaceState = VREPLACE;
+ State = MODE_VREPLACE;
+ replaceState = MODE_VREPLACE;
orig_line_count = curbuf->b_ml.ml_line_count;
vr_lines_changed = 1;
}
else
- State = INSERT;
+ State = MODE_INSERT;
may_trigger_modechanged();
stop_insert_mode = FALSE;
* when hitting <Esc>.
*/
if (curbuf->b_p_iminsert == B_IMODE_LMAP)
- State |= LANGMAP;
+ State |= MODE_LANGMAP;
#ifdef HAVE_INPUT_METHOD
im_set_active(curbuf->b_p_iminsert == B_IMODE_IM);
#endif
#endif
#ifdef FEAT_RIGHTLEFT
// there is no reverse replace mode
- revins_on = (State == INSERT && p_ri);
+ revins_on = (State == MODE_INSERT && p_ri);
if (revins_on)
undisplay_dollar();
revins_chars = 0;
/*
* Truncate the space at the end of a line. This is to be used only in an
- * insert mode. It handles fixing the replace stack for REPLACE and VREPLACE
- * modes.
+ * insert mode. It handles fixing the replace stack for MODE_REPLACE and
+ * MODE_VREPLACE modes.
*/
void
truncate_spaces(char_u *line)
}
/*
- * Backspace the cursor until the given column. Handles REPLACE and VREPLACE
- * modes correctly. May also be used when not in insert mode at all.
- * Will attempt not to go before "col" even when there is a composing
+ * Backspace the cursor until the given column. Handles MODE_REPLACE and
+ * MODE_VREPLACE modes correctly. May also be used when not in insert mode at
+ * all. Will attempt not to go before "col" even when there is a composing
* character.
*/
void
break;
#ifdef FEAT_CMDL_INFO
- if (!(State & CMDLINE) && MB_BYTE2LEN_CHECK(nc) == 1)
+ if ((State & MODE_CMDLINE) == 0 && MB_BYTE2LEN_CHECK(nc) == 1)
add_to_showcmd(nc);
#endif
if (nc == 'x' || nc == 'X')
* - Otherwise:
* - Don't do this if inserting a blank
* - Don't do this if an existing character is being replaced, unless
- * we're in VREPLACE mode.
+ * we're in MODE_VREPLACE state.
* - Do this if the cursor is not on the line where insert started
* or - 'formatoptions' doesn't have 'l' or the line was not too long
* before the insert.
// If we entered a fold, move to the beginning, unless in
// Insert mode or when 'foldopen' contains "all": it will open
// in a moment.
- if (n > 0 || !((State & INSERT) || (fdo_flags & FDO_ALL)))
+ if (n > 0 || !((State & MODE_INSERT) || (fdo_flags & FDO_ALL)))
(void)hasFolding(lnum, &lnum, NULL);
}
if (lnum < 1)
/*
* Pop bytes from the replace stack until a NUL is found, and insert them
- * before the cursor. Can only be used in REPLACE or VREPLACE mode.
+ * before the cursor. Can only be used in MODE_REPLACE or MODE_VREPLACE state.
*/
static void
replace_pop_ins(void)
int cc;
int oldState = State;
- State = NORMAL; // don't want REPLACE here
+ State = MODE_NORMAL; // don't want MODE_REPLACE here
while ((cc = replace_pop()) > 0)
{
mb_replace_pop_ins(cc);
static void
ins_ctrl_hat(void)
{
- if (map_to_exists_mode((char_u *)"", LANGMAP, FALSE))
+ if (map_to_exists_mode((char_u *)"", MODE_LANGMAP, FALSE))
{
// ":lmap" mappings exists, Toggle use of ":lmap" mappings.
- if (State & LANGMAP)
+ if (State & MODE_LANGMAP)
{
curbuf->b_p_iminsert = B_IMODE_NONE;
- State &= ~LANGMAP;
+ State &= ~MODE_LANGMAP;
}
else
{
curbuf->b_p_iminsert = B_IMODE_LMAP;
- State |= LANGMAP;
+ State |= MODE_LANGMAP;
#ifdef HAVE_INPUT_METHOD
im_set_active(FALSE);
#endif
else
{
curbuf->b_p_iminsert = B_IMODE_IM;
- State &= ~LANGMAP;
+ State &= ~MODE_LANGMAP;
im_set_active(TRUE);
}
}
// Disable IM to allow typing English directly for Normal mode commands.
// When ":lmap" is enabled don't change 'iminsert' (IM can be enabled as
// well).
- if (!(State & LANGMAP))
+ if (!(State & MODE_LANGMAP))
im_save_status(&curbuf->b_p_iminsert);
im_set_active(FALSE);
#endif
- State = NORMAL;
+ State = MODE_NORMAL;
may_trigger_modechanged();
// need to position cursor again when on a TAB
if (gchar_cursor() == TAB)
++curwin->w_cursor.col;
}
p_ri = !p_ri;
- revins_on = (State == INSERT && p_ri);
+ revins_on = (State == MODE_INSERT && p_ri);
if (revins_on)
{
revins_scol = curwin->w_cursor.col;
#ifdef FEAT_EVAL
set_vim_var_string(VV_INSERTMODE,
(char_u *)((State & REPLACE_FLAG) ? "i"
- : replaceState == VREPLACE ? "v"
+ : replaceState == MODE_VREPLACE ? "v"
: "r"), 1);
#endif
ins_apply_autocmds(EVENT_INSERTCHANGE);
if (State & REPLACE_FLAG)
- State = INSERT | (State & LANGMAP);
+ State = MODE_INSERT | (State & MODE_LANGMAP);
else
- State = replaceState | (State & LANGMAP);
+ State = replaceState | (State & MODE_LANGMAP);
may_trigger_modechanged();
AppendCharToRedobuff(K_INS);
showmode();
dec_cursor();
/*
- * In REPLACE mode we have to put back the text that was replaced
- * by the NL. On the replace stack is first a NUL-terminated
- * sequence of characters that were deleted and then the
- * characters that NL replaced.
+ * In MODE_REPLACE mode we have to put back the text that was
+ * replaced by the NL. On the replace stack is first a
+ * NUL-terminated sequence of characters that were deleted and then
+ * the characters that NL replaced.
*/
if (State & REPLACE_FLAG)
{
/*
- * Do the next ins_char() in NORMAL state, to
+ * Do the next ins_char() in MODE_NORMAL state, to
* prevent ins_char() from replacing characters and
* avoiding showmatch().
*/
oldState = State;
- State = NORMAL;
+ State = MODE_NORMAL;
/*
* restore characters (blanks) deleted after cursor
*/
/*
* Insert the first space with ins_char(). It will delete one char in
* replace mode. Insert the rest with ins_str(); it will not delete any
- * chars. For VREPLACE mode, we use ins_char() for all characters.
+ * chars. For MODE_VREPLACE state, we use ins_char() for all characters.
*/
ins_char(' ');
while (--temp > 0)
int save_list = curwin->w_p_list;
/*
- * Get the current line. For VREPLACE mode, don't make real changes
- * yet, just work on a copy of the line.
+ * Get the current line. For MODE_VREPLACE state, don't make real
+ * changes yet, just work on a copy of the line.
*/
if (State & VREPLACE_FLAG)
{
cursor->col -= i;
/*
- * In VREPLACE mode, we haven't changed anything yet. Do it now by
- * backspacing over the changed spacing and then inserting the new
- * spacing.
+ * In MODE_VREPLACE state, we haven't changed anything yet. Do it
+ * now by backspacing over the changed spacing and then inserting
+ * the new spacing.
*/
if (State & VREPLACE_FLAG)
{
replace_push(NUL);
/*
- * In VREPLACE mode, a NL replaces the rest of the line, and starts
+ * In MODE_VREPLACE state, a NL replaces the rest of the line, and starts
* replacing the next line, so we push all of the characters left on the
* line onto the replace stack. This is not done here though, it is done
* in open_line().
f_wildmenumode(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
{
#ifdef FEAT_WILDMENU
- if (wild_menu_showing || ((State & CMDLINE) && cmdline_pum_active()))
+ if (wild_menu_showing || ((State & MODE_CMDLINE) && cmdline_pum_active()))
rettv->vval.v_number = 1;
#endif
}
redraw_curbuf_later(NOT_VALID); // redraw this buffer later
}
- if (p_im && (State & INSERT) == 0)
+ if (p_im && (State & MODE_INSERT) == 0)
need_start_insertmode = TRUE;
#ifdef FEAT_AUTOCHDIR
if (empty && lnum == 1)
lnum = 0;
- State = INSERT; // behave like in Insert mode
+ State = MODE_INSERT; // behave like in Insert mode
if (curbuf->b_p_iminsert == B_IMODE_LMAP)
- State |= LANGMAP;
+ State |= MODE_LANGMAP;
for (;;)
{
{
int save_State = State;
- // Set State to avoid the cursor shape to be set to INSERT mode
- // when getline() returns.
- State = CMDLINE;
+ // Set State to avoid the cursor shape to be set to MODE_INSERT
+ // state when getline() returns.
+ State = MODE_CMDLINE;
theline = eap->getline(
#ifdef FEAT_EVAL
eap->cstack->cs_looplevel > 0 ? -1 :
empty = FALSE;
}
}
- State = NORMAL;
+ State = MODE_NORMAL;
if (eap->forceit)
curbuf->b_p_ai = !curbuf->b_p_ai;
{
int typed = 0;
- // change State to CONFIRM, so that the mouse works
+ // change State to MODE_CONFIRM, so that the mouse works
// properly
save_State = State;
- State = CONFIRM;
+ State = MODE_CONFIRM;
setmouse(); // disable mouse in xterm
curwin->w_cursor.col = regmatch.startpos[0].col;
if (curwin->w_p_crb)
exmode_active = EXMODE_VIM;
else
exmode_active = EXMODE_NORMAL;
- State = NORMAL;
+ State = MODE_NORMAL;
may_trigger_modechanged();
// When using ":global /pat/ visual" and then "Q" we return to continue
need_wait_return = FALSE;
// When invoked from a callback or autocmd the command line may be active.
- if (State & CMDLINE)
+ if (State & MODE_CMDLINE)
redrawcmdline();
out_flush();
// Ignore the command when already in Insert mode. Inserting an
// expression register that invokes a function can do this.
- if (State & INSERT)
+ if (State & MODE_INSERT)
return;
if (eap->cmdidx == CMD_startinsert)
static void
cmdline_toggle_langmap(long *b_im_ptr)
{
- if (map_to_exists_mode((char_u *)"", LANGMAP, FALSE))
+ if (map_to_exists_mode((char_u *)"", MODE_LANGMAP, FALSE))
{
// ":lmap" mappings exists, toggle use of mappings.
- State ^= LANGMAP;
+ State ^= MODE_LANGMAP;
#ifdef HAVE_INPUT_METHOD
im_set_active(FALSE); // Disable input method
#endif
if (b_im_ptr != NULL)
{
- if (State & LANGMAP)
+ if (State & MODE_LANGMAP)
*b_im_ptr = B_IMODE_LMAP;
else
*b_im_ptr = B_IMODE_NONE;
*/
msg_scroll = FALSE;
- State = CMDLINE;
+ State = MODE_CMDLINE;
if (firstc == '/' || firstc == '?' || firstc == '@')
{
else
b_im_ptr = &curbuf->b_p_imsearch;
if (*b_im_ptr == B_IMODE_LMAP)
- State |= LANGMAP;
+ State |= MODE_LANGMAP;
#ifdef HAVE_INPUT_METHOD
im_set_active(*b_im_ptr == B_IMODE_IM);
#endif
static void
redrawcmd_preedit(void)
{
- if ((State & CMDLINE)
+ if ((State & MODE_CMDLINE)
&& xic != NULL
// && im_get_status() doesn't work when using SCIM
&& !p_imdisable
static cmdline_info_T *
get_ccline_ptr(void)
{
- if ((State & CMDLINE) == 0)
+ if ((State & MODE_CMDLINE) == 0)
return NULL;
if (ccline.cmdbuff != NULL)
return &ccline;
{
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);
+ add_map((char_u *)"<buffer> <Tab> <C-X><C-V>", MODE_INSERT);
+ add_map((char_u *)"<buffer> <Tab> a<C-X><C-V>", MODE_NORMAL);
}
set_option_value_give_err((char_u *)"ft",
0L, (char_u *)"vim", OPT_LOCAL);
// No Ex mode here!
exmode_active = 0;
- State = NORMAL;
+ State = MODE_NORMAL;
setmouse();
// Reset here so it can be set by a CmdWinEnter autocommand.
// When starting to edit a new file which does not have encryption, clear
// the 'key' option, except when starting up (called with -x argument)
else if (newfile && *curbuf->b_p_key != NUL && !starting)
- set_option_value((char_u *)"key", 0L, (char_u *)"", OPT_LOCAL);
+ set_option_value_give_err((char_u *)"key", 0L, (char_u *)"", OPT_LOCAL);
return cryptkey;
}
}
else
#endif
- if (State > NORMAL_BUSY || (State & CMDLINE) || already_warned)
+ if (State > MODE_NORMAL_BUSY || (State & MODE_CMDLINE)
+ || already_warned)
{
if (*mesg2 != NUL)
{
line2 = line1 - amount_after - 1;
// If appending a line in Insert mode, it should be included in the fold
// just above the line.
- if ((State & INSERT) && amount == (linenr_T)1 && line2 == MAXLNUM)
+ if ((State & MODE_INSERT) && amount == (linenr_T)1 && line2 == MAXLNUM)
--line1;
foldMarkAdjustRecurse(&wp->w_folds, line1, line2, amount, amount_after);
}
// In Insert mode an inserted line at the top of a fold is considered part
// of the fold, otherwise it isn't.
- if ((State & INSERT) && amount == (linenr_T)1 && line2 == MAXLNUM)
+ if ((State & MODE_INSERT) && amount == (linenr_T)1 && line2 == MAXLNUM)
top = line1 + 1;
else
top = line1;
static void
may_sync_undo(void)
{
- if ((!(State & (INSERT + CMDLINE)) || arrow_used)
+ if ((!(State & (MODE_INSERT | MODE_CMDLINE)) || arrow_used)
&& scriptin[curscript] == NULL)
u_sync(FALSE);
}
int save_finish_op = finish_op;
int save_msg_scroll = msg_scroll;
- State = NORMAL;
+ State = MODE_NORMAL;
msg_scroll = FALSE; // no msg scrolling in Normal mode
restart_edit = 0; // don't go to Insert mode
p_im = FALSE; // don't use 'insertmode'
|| (p_remap
&& (typebuf.tb_noremap[typebuf.tb_off]
& (RM_NONE|RM_ABBR)) == 0))
- && !(p_paste && (State & (INSERT + CMDLINE)))
- && !(State == HITRETURN && (tb_c1 == CAR || tb_c1 == ' '))
- && State != ASKMORE
- && State != CONFIRM
+ && !(p_paste && (State & (MODE_INSERT | MODE_CMDLINE)))
+ && !(State == MODE_HITRETURN && (tb_c1 == CAR || tb_c1 == ' '))
+ && State != MODE_ASKMORE
+ && State != MODE_CONFIRM
&& !at_ins_compl_key())
{
#ifdef FEAT_GUI
nolmaplen = 2;
else
{
- LANGMAP_ADJUST(tb_c1, (State & (CMDLINE | INSERT)) == 0
- && get_real_state() != SELECTMODE);
+ LANGMAP_ADJUST(tb_c1, (State & (MODE_CMDLINE | MODE_INSERT)) == 0
+ && get_real_state() != MODE_SELECT);
nolmaplen = 0;
}
#endif
&& (mp->m_mode & local_State)
&& !(mp->m_simplified && seenModifyOtherKeys
&& typebuf.tb_maplen == 0)
- && ((mp->m_mode & LANGMAP) == 0 || typebuf.tb_maplen == 0))
+ && ((mp->m_mode & MODE_LANGMAP) == 0 || typebuf.tb_maplen == 0))
{
#ifdef FEAT_LANGMAP
int nomap = nolmaplen;
/*
* Check for match with 'pastetoggle'
*/
- if (*p_pt != NUL && mp == NULL && (State & (INSERT|NORMAL)))
+ if (*p_pt != NUL && mp == NULL && (State & (MODE_INSERT | MODE_NORMAL)))
{
for (mlen = 0; mlen < typebuf.tb_len && p_pt[mlen]; ++mlen)
if (p_pt[mlen] != typebuf.tb_buf[typebuf.tb_off + mlen])
del_typebuf(mlen, 0); // remove the chars
set_option_value_give_err((char_u *)"paste",
(long)!p_paste, NULL, 0);
- if (!(State & INSERT))
+ if (!(State & MODE_INSERT))
{
msg_col = 0;
msg_row = Rows - 1;
// to Visual mode temporarily. Append K_SELECT to switch
// back to Select mode.
if (VIsual_active && VIsual_select
- && (current_menu->modes & VISUAL))
+ && (current_menu->modes & MODE_VISUAL))
{
VIsual_select = FALSE;
(void)ins_typebuf(K_SELECT_STRING,
if (++*mapdepth >= p_mmd)
{
emsg(_(e_recursive_mapping));
- if (State & CMDLINE)
+ if (State & MODE_CMDLINE)
redrawcmdline();
else
setcursor();
* In Select mode and a Visual mode mapping is used: Switch to Visual
* mode temporarily. Append K_SELECT to switch back to Select mode.
*/
- if (VIsual_active && VIsual_select && (mp->m_mode & VISUAL))
+ if (VIsual_active && VIsual_select && (mp->m_mode & MODE_VISUAL))
{
VIsual_select = FALSE;
(void)ins_typebuf(K_SELECT_STRING, REMAP_NONE, 0, TRUE, FALSE);
buf[2] = KE_IGNORE;
buf[3] = NUL;
map_str = vim_strsave(buf);
- if (State & CMDLINE)
+ if (State & MODE_CMDLINE)
{
// redraw the command below the error
msg_didout = TRUE;
* really insert a CTRL-C.
*/
if ((c || typebuf.tb_maplen)
- && (State & (INSERT + CMDLINE)))
+ && (State & (MODE_INSERT | MODE_CMDLINE)))
c = ESC;
else
c = Ctrl_C;
&& !no_mapping
&& ex_normal_busy == 0
&& typebuf.tb_maplen == 0
- && (State & INSERT)
+ && (State & MODE_INSERT)
&& (p_timeout
|| (keylen == KEYLEN_PART_KEY && p_ttimeout))
&& (c = inchar(typebuf.tb_buf + typebuf.tb_off
}
#ifdef FEAT_GUI
// may show a different cursor shape
- if (gui.in_use && State != NORMAL && !cmd_silent)
+ if (gui.in_use && State != MODE_NORMAL && !cmd_silent)
{
int save_State;
save_State = State;
- State = NORMAL;
+ State = MODE_NORMAL;
gui_update_cursor(TRUE, FALSE);
State = save_State;
shape_changed = TRUE;
// For the cmdline window: Alternate between ESC and
// CTRL-C: ESC for most situations and CTRL-C to close the
// cmdline window.
- if (p_im && (State & INSERT))
+ if (p_im && (State & MODE_INSERT))
c = Ctrl_L;
#ifdef FEAT_TERMINAL
else if (terminal_is_active())
c = K_CANCEL;
#endif
- else if ((State & CMDLINE)
+ else if ((State & MODE_CMDLINE)
#ifdef FEAT_CMDWIN
|| (cmdwin_type > 0 && tc == ESC)
#endif
// changed text so far. Also for when 'lazyredraw' is set and
// redrawing was postponed because there was something in the
// input buffer (e.g., termresponse).
- if (((State & INSERT) != 0 || p_lz) && (State & CMDLINE) == 0
- && advance && must_redraw != 0 && !need_wait_return)
+ if (((State & MODE_INSERT) != 0 || p_lz)
+ && (State & MODE_CMDLINE) == 0
+ && advance && must_redraw != 0 && !need_wait_return)
{
update_screen(0);
setcursor(); // put cursor back where it belongs
c1 = 0;
if (typebuf.tb_len > 0 && advance && !exmode_active)
{
- if (((State & (NORMAL | INSERT)) || State == LANGMAP)
- && State != HITRETURN)
+ if (((State & (MODE_NORMAL | MODE_INSERT))
+ || State == MODE_LANGMAP)
+ && State != MODE_HITRETURN)
{
// this looks nice when typing a dead character map
- if (State & INSERT
+ if (State & MODE_INSERT
&& ptr2cells(typebuf.tb_buf + typebuf.tb_off
+ typebuf.tb_len - 1) == 1)
{
}
// this looks nice when typing a dead character map
- if ((State & CMDLINE)
+ if ((State & MODE_CMDLINE)
#if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
&& cmdline_star == 0
#endif
#endif
if (c1 == 1)
{
- if (State & INSERT)
+ if (State & MODE_INSERT)
edit_unputchar();
- if (State & CMDLINE)
+ if (State & MODE_CMDLINE)
unputcmdline();
else
setcursor(); // put cursor back where it belongs
* if we return an ESC to exit insert mode, the message is deleted
* if we don't return an ESC but deleted the message before, redisplay it
*/
- if (advance && p_smd && msg_silent == 0 && (State & INSERT))
+ if (advance && p_smd && msg_silent == 0 && (State & MODE_INSERT))
{
if (c == ESC && !mode_deleted && !no_mapping && mode_displayed)
{
* recursive loop may result (write error in swapfile, hit-return, timeout
* on char wait, flush swapfile, write error....).
*/
- if (State != HITRETURN)
+ if (State != MODE_HITRETURN)
{
did_outofmem_msg = FALSE; // display out of memory message (again)
did_swapwrite_msg = FALSE; // display swap file write error again
EXTERN pos_T Insstart_orig;
/*
- * Stuff for VREPLACE mode.
+ * Stuff for MODE_VREPLACE state.
*/
EXTERN int orig_line_count INIT(= 0); // Line count when "gR" started
EXTERN int vr_lines_changed INIT(= 0); // #Lines changed by "gR" so far
/*
* "State" is the main state of Vim.
* There are other variables that modify the state:
- * "Visual_mode" When State is NORMAL or INSERT.
- * "finish_op" When State is NORMAL, after typing the operator and before
- * typing the motion command.
+ * "Visual_mode" When State is MODE_NORMAL or MODE_INSERT.
+ * "finish_op" When State is MODE_NORMAL, after typing the operator and
+ * before typing the motion command.
* "motion_force" Last motion_force from do_pending_operator()
* "debug_mode" Debug mode.
*/
-EXTERN int State INIT(= NORMAL); // This is the current state of the
- // command interpreter.
+EXTERN int State INIT(= MODE_NORMAL);
+
#ifdef FEAT_EVAL
EXTERN int debug_mode INIT(= FALSE);
#endif
else
#endif
shape = &shape_table[get_shape_idx(FALSE)];
- if (State & LANGMAP)
+ if (State & MODE_LANGMAP)
id = shape->id_lm;
else
id = shape->id;
* At the "more" and ":confirm" prompt there is no redraw, put the cursor
* at the last line here (why does it have to be one row too low?).
*/
- if (State == ASKMORE || State == CONFIRM)
+ if (State == MODE_ASKMORE || State == MODE_CONFIRM)
gui.row = gui.num_rows;
// Only comparing Rows and Columns may be sufficient, but let's stay on
// Determine which mouse settings to look for based on the current mode
switch (get_real_state())
{
- case NORMAL_BUSY:
- case OP_PENDING:
+ case MODE_NORMAL_BUSY:
+ case MODE_OP_PENDING:
# ifdef FEAT_TERMINAL
- case TERMINAL:
+ case MODE_TERMINAL:
# endif
- case NORMAL: checkfor = MOUSE_NORMAL; break;
- case VISUAL: checkfor = MOUSE_VISUAL; break;
- case SELECTMODE: checkfor = MOUSE_VISUAL; break;
- case REPLACE:
- case REPLACE+LANGMAP:
- case VREPLACE:
- case VREPLACE+LANGMAP:
- case INSERT:
- case INSERT+LANGMAP: checkfor = MOUSE_INSERT; break;
- case ASKMORE:
- case HITRETURN: // At the more- and hit-enter prompt pass the
+ case MODE_NORMAL: checkfor = MOUSE_NORMAL; break;
+ case MODE_VISUAL: checkfor = MOUSE_VISUAL; break;
+ case MODE_SELECT: checkfor = MOUSE_VISUAL; break;
+ case MODE_REPLACE:
+ case MODE_REPLACE | MODE_LANGMAP:
+ case MODE_VREPLACE:
+ case MODE_VREPLACE | MODE_LANGMAP:
+ case MODE_INSERT:
+ case MODE_INSERT | MODE_LANGMAP:
+ checkfor = MOUSE_INSERT; break;
+ case MODE_ASKMORE:
+ case MODE_HITRETURN: // At the more- and hit-enter prompt pass the
// mouse event for a click on or below the
// message line.
if (Y_2_ROW(y) >= msg_row)
* On the command line, use the clipboard selection on all lines
* but the command line. But not when pasting.
*/
- case CMDLINE:
- case CMDLINE+LANGMAP:
+ case MODE_CMDLINE:
+ case MODE_CMDLINE | MODE_LANGMAP:
if (Y_2_ROW(y) < cmdline_row && button != MOUSE_MIDDLE)
checkfor = MOUSE_NONE;
else
* modes. Don't do this when dragging the status line, or extending a
* Visual selection.
*/
- if ((State == NORMAL || State == NORMAL_BUSY || (State & INSERT))
+ if ((State == MODE_NORMAL || State == MODE_NORMAL_BUSY
+ || (State & MODE_INSERT))
&& Y_2_ROW(y) >= topframe->fr_height + firstwin->w_winrow
&& button != MOUSE_DRAG
# ifdef FEAT_MOUSESHAPE
if (!mouse_has(checkfor) || checkfor == MOUSE_COMMAND)
{
// Don't do modeless selection in Visual mode.
- if (checkfor != MOUSE_NONEF && VIsual_active && (State & NORMAL))
+ if (checkfor != MOUSE_NONEF && VIsual_active && (State & MODE_NORMAL))
return;
/*
{
if (clip_star.state == SELECT_CLEARED)
{
- if (State & CMDLINE)
+ if (State & MODE_CMDLINE)
{
col = msg_col;
row = msg_row;
#ifdef USE_ON_FLY_SCROLL
current_scrollbar = sb_num;
scrollbar_value = value;
- if (State & NORMAL)
+ if (State & MODE_NORMAL)
{
gui_do_scroll();
setcursor();
}
- else if (State & INSERT)
+ else if (State & MODE_INSERT)
{
ins_scroll();
setcursor();
}
- else if (State & CMDLINE)
+ else if (State & MODE_CMDLINE)
{
if (msg_scrolled == 0)
{
#ifdef USE_ON_FLY_SCROLL
scrollbar_value = value;
- if (State & NORMAL)
+ if (State & MODE_NORMAL)
gui_do_horiz_scroll(scrollbar_value, FALSE);
- else if (State & INSERT)
+ else if (State & MODE_INSERT)
ins_horscroll();
- else if (State & CMDLINE)
+ else if (State & MODE_CMDLINE)
{
if (msg_scrolled == 0)
{
// Only handle this when 'mousefocus' set and ...
if (p_mousef
&& !hold_gui_events // not holding events
- && (State & (NORMAL|INSERT))// Normal/Visual/Insert mode
- && State != HITRETURN // but not hit-return prompt
+ && (State & (MODE_NORMAL | MODE_INSERT))// Normal/Visual/Insert mode
+ && State != MODE_HITRETURN // but not hit-return prompt
&& msg_scrolled == 0 // no scrolled message
&& !need_mouse_correct // not moving the pointer
&& gui.in_focus) // gvim in focus
if (wp == NULL)
return NULL;
#ifdef FEAT_MOUSESHAPE
- if (State == HITRETURN || State == ASKMORE)
+ if (State == MODE_HITRETURN || State == MODE_ASKMORE)
{
if (Y_2_ROW(y) >= msg_row)
update_mouseshape(SHAPE_IDX_MOREL);
}
else if (row > wp->w_height) // below status line
update_mouseshape(SHAPE_IDX_CLINE);
- else if (!(State & CMDLINE) && wp->w_vsep_width > 0 && col == wp->w_width
+ else if (!(State & MODE_CMDLINE) && wp->w_vsep_width > 0 && col == wp->w_width
&& (row != wp->w_height || !stl_connected(wp)) && msg_scrolled == 0)
update_mouseshape(SHAPE_IDX_VSEP);
- else if (!(State & CMDLINE) && wp->w_status_height > 0
+ else if (!(State & MODE_CMDLINE) && wp->w_status_height > 0
&& row == wp->w_height && msg_scrolled == 0)
update_mouseshape(SHAPE_IDX_STATUS);
else
// syntax HL if we were busy redrawing.
did_emsg = save_did_emsg;
- if (State & (NORMAL | INSERT))
+ if (State & (MODE_NORMAL | MODE_INSERT))
{
gui_update_screen(); // update the screen
msg_didout = 0; // overwrite any message
* When the cursor is at the command line, add the file names to the
* command line, don't edit the files.
*/
- if (State & CMDLINE)
+ if (State & MODE_CMDLINE)
{
shorten_filenames(fnames, count);
for (i = 0; i < count; ++i)
char_u *tooltip;
static int did_msg = FALSE;
- if (State & CMDLINE)
+ if (State & MODE_CMDLINE)
return;
menu = (vimmenu_T *)data;
tooltip = CONVERT_TO_UTF8(menu->strings[MENU_INDEX_TIP]);
}
// In modes where we are not typing, dead keys should behave
// normally
- else if (!(get_real_state() & (INSERT | CMDLINE | SELECTMODE)))
+ else if ((get_real_state()
+ & (MODE_INSERT | MODE_CMDLINE | MODE_SELECT)) == 0)
{
outputDeadKey_rePost(msg);
return;
if (((UINT) HIWORD(wParam)
& (0xffff ^ (MF_MOUSESELECT + MF_BITMAP + MF_POPUP)))
== MF_HILITE
- && (State & CMDLINE) == 0)
+ && (State & MODE_CMDLINE) == 0)
{
UINT idButton;
vimmenu_T *pMenu;
im_set_position(gui.row, gui.col);
// Disable langmap
- State &= ~LANGMAP;
- if (State & INSERT)
+ State &= ~MODE_LANGMAP;
+ if (State & MODE_INSERT)
{
# if defined(FEAT_KEYMAP)
// Unshown 'keymap' in status lines
static void
init_preedit_start_col(void)
{
- if (State & CMDLINE)
+ if (State & MODE_CMDLINE)
preedit_start_col = cmdline_getvcol_cursor();
else if (curwin != NULL && curwin->w_buffer != NULL)
getvcol(curwin, &curwin->w_cursor, &preedit_start_col, NULL, NULL);
return;
}
- if (State & NORMAL
+ if (State & MODE_NORMAL
#ifdef FEAT_TERMINAL
&& !term_use_loop()
#endif
{
char_u backkey[] = {CSI, 'k', 'l'};
- if (State & NORMAL)
+ if (State & MODE_NORMAL)
return;
# ifdef FEAT_RIGHTLEFT
- if ((State & CMDLINE) == 0 && curwin != NULL && curwin->w_p_rl)
+ if ((State & MODE_CMDLINE) == 0 && curwin != NULL && curwin->w_p_rl)
backkey[2] = 'r';
# endif
for (; num_move_back > 0; --num_move_back)
vgetc_busy = TRUE;
showmode();
vgetc_busy = old_vgetc_busy;
- if ((State & NORMAL) || (State & INSERT))
+ if ((State & MODE_NORMAL) || (State & MODE_INSERT))
setcursor();
out_flush();
}
// gtk_im_context_filter_keypress() in Normal mode.
// And while doing :sh too.
if (xic != NULL && !p_imdisable
- && (State & (INSERT | CMDLINE | NORMAL | EXTERNCMD)) != 0)
+ && (State & (MODE_INSERT | MODE_CMDLINE
+ | MODE_NORMAL | MODE_EXTERNCMD)))
{
// Filter 'imactivatekey' and map it to CTRL-^. This way, Vim is
// always aware of the current status of IM, and can even emulate
if (event->type != GDK_KEY_PRESS)
return TRUE;
- if (map_to_exists_mode((char_u *)"", LANGMAP, FALSE))
+ if (map_to_exists_mode((char_u *)"", MODE_LANGMAP, FALSE))
{
im_set_active(FALSE);
// ":lmap" mappings exists, toggle use of mappings.
- State ^= LANGMAP;
- if (State & LANGMAP)
+ State ^= MODE_LANGMAP;
+ if (State & MODE_LANGMAP)
{
curbuf->b_p_iminsert = B_IMODE_NONE;
- State &= ~LANGMAP;
+ State &= ~MODE_LANGMAP;
}
else
{
curbuf->b_p_iminsert = B_IMODE_LMAP;
- State |= LANGMAP;
+ State |= MODE_LANGMAP;
}
return TRUE;
}
pos.lnum = 0;
// In format_lines() (i.e. not insert mode), fo+=q is needed too...
- if ((State & INSERT) || has_format_option(FO_Q_COMS))
+ if ((State & MODE_INSERT) || has_format_option(FO_Q_COMS))
lead_len = get_leader_len(ml_get(lnum), NULL, FALSE, TRUE);
regmatch.regprog = vim_regcomp(curbuf->b_p_flp, RE_MAGIC);
colnr_T orig_col = 0; // init for GCC
char_u *new_line, *orig_line = NULL; // init for GCC
- // VREPLACE mode needs to know what the line was like before changing
+ // MODE_VREPLACE state needs to know what the line was like before changing
if (State & VREPLACE_FLAG)
{
orig_line = vim_strsave(ml_get_curline()); // Deal with NULL below
// Avoid being called recursively.
if (State & VREPLACE_FLAG)
- State = INSERT;
+ State = MODE_INSERT;
shift_line(type == INDENT_DEC, round, 1, call_changed_bytes);
State = save_State;
}
insstart_less = MAXCOL;
new_cursor_col += curwin->w_cursor.col;
}
- else if (!(State & INSERT))
+ else if (!(State & MODE_INSERT))
new_cursor_col = curwin->w_cursor.col;
else
{
changed_cline_bef_curs();
// May have to adjust the start of the insert.
- if (State & INSERT)
+ if (State & MODE_INSERT)
{
if (curwin->w_cursor.lnum == Insstart.lnum && Insstart.col != 0)
{
ai_col -= insstart_less;
}
- // For REPLACE mode, may have to fix the replace stack, if it's possible.
- // If the number of characters before the cursor decreased, need to pop a
- // few characters from the replace stack.
+ // For MODE_REPLACE state, may have to fix the replace stack, if it's
+ // possible. If the number of characters before the cursor decreased, need
+ // to pop a few characters from the replace stack.
// If the number of characters before the cursor increased, need to push a
// few NULs onto the replace stack.
if (REPLACE_NORMAL(State) && start_col >= 0)
}
}
- // For VREPLACE mode, we also have to fix the replace stack. In this case
- // it is always possible because we backspace over the whole line and then
- // put it back again the way we wanted it.
+ // For MODE_VREPLACE state, we also have to fix the replace stack. In this
+ // case it is always possible because we backspace over the whole line and
+ // then put it back again the way we wanted it.
if (State & VREPLACE_FLAG)
{
// If orig_line didn't allocate, just return. At least we did the job,
// Pretend to be in Insert mode, allow cursor past end of line for "o"
// command.
save_State = State;
- State = INSERT;
+ State = MODE_INSERT;
curwin->w_cursor = save_pos;
curwin->w_curswant = save_curswant;
curwin->w_set_curswant = save_set_curswant;
|| check_for_list_arg(argvars, 1) == FAIL))
return;
- if ((State & INSERT) == 0)
+ if ((State & MODE_INSERT) == 0)
{
emsg(_(e_complete_can_only_be_used_in_insert_mode));
return;
#ifdef FEAT_RIGHTLEFT
// Whether to draw the vertical bar on the right side of the cell.
-# define CURSOR_BAR_RIGHT (curwin->w_p_rl && (!(State & CMDLINE) || cmdmsg_rl))
+# define CURSOR_BAR_RIGHT (curwin->w_p_rl && (!(State & MODE_CMDLINE) || cmdmsg_rl))
#endif
/*
// exits while Vim is running in a console.
if (!cmdwin && !noexmode && SETJMP(x_jump_env))
{
- State = NORMAL;
+ State = MODE_NORMAL;
VIsual_active = FALSE;
got_int = TRUE;
need_wait_return = FALSE;
// Typed two CTRL-C in a row: go back to ex mode as if "Q" was
// used and keep "got_int" set, so that it aborts ":g".
exmode_active = EXMODE_NORMAL;
- State = NORMAL;
+ State = MODE_NORMAL;
}
else if (!global_busy || !exmode_active)
{
* Returns a value between 0 and 255, index in maphash.
* Put Normal/Visual mode mappings mostly separately from Insert/Cmdline mode.
*/
-#define MAP_HASH(mode, c1) (((mode) & (NORMAL + VISUAL + SELECTMODE + OP_PENDING + TERMINAL)) ? (c1) : ((c1) ^ 0x80))
+#define MAP_HASH(mode, c1) (((mode) & (MODE_NORMAL | MODE_VISUAL | MODE_SELECT | MODE_OP_PENDING | MODE_TERMINAL)) ? (c1) : ((c1) ^ 0x80))
/*
* Get the start of the hashed map list for "state" and first character "c".
ga_init2(&mapmode, 1, 7);
- if ((mode & (INSERT + CMDLINE)) == INSERT + CMDLINE)
+ if ((mode & (MODE_INSERT | MODE_CMDLINE)) == (MODE_INSERT | MODE_CMDLINE))
ga_append(&mapmode, '!'); // :map!
- else if (mode & INSERT)
+ else if (mode & MODE_INSERT)
ga_append(&mapmode, 'i'); // :imap
- else if (mode & LANGMAP)
+ else if (mode & MODE_LANGMAP)
ga_append(&mapmode, 'l'); // :lmap
- else if (mode & CMDLINE)
+ else if (mode & MODE_CMDLINE)
ga_append(&mapmode, 'c'); // :cmap
- else if ((mode & (NORMAL + VISUAL + SELECTMODE + OP_PENDING))
- == NORMAL + VISUAL + SELECTMODE + OP_PENDING)
+ else if ((mode
+ & (MODE_NORMAL | MODE_VISUAL | MODE_SELECT | MODE_OP_PENDING))
+ == (MODE_NORMAL | MODE_VISUAL | MODE_SELECT | MODE_OP_PENDING))
ga_append(&mapmode, ' '); // :map
else
{
- if (mode & NORMAL)
+ if (mode & MODE_NORMAL)
ga_append(&mapmode, 'n'); // :nmap
- if (mode & OP_PENDING)
+ if (mode & MODE_OP_PENDING)
ga_append(&mapmode, 'o'); // :omap
- if (mode & TERMINAL)
+ if (mode & MODE_TERMINAL)
ga_append(&mapmode, 't'); // :tmap
- if ((mode & (VISUAL + SELECTMODE)) == VISUAL + SELECTMODE)
+ if ((mode & (MODE_VISUAL | MODE_SELECT)) == (MODE_VISUAL | MODE_SELECT))
ga_append(&mapmode, 'v'); // :vmap
else
{
- if (mode & VISUAL)
+ if (mode & MODE_VISUAL)
ga_append(&mapmode, 'x'); // :xmap
- if (mode & SELECTMODE)
+ if (mode & MODE_SELECT)
ga_append(&mapmode, 's'); // :smap
}
}
* arg is pointer to any arguments. Note: arg cannot be a read-only string,
* it will be modified.
*
- * for :map mode is NORMAL + VISUAL + SELECTMODE + OP_PENDING
- * for :map! mode is INSERT + CMDLINE
- * for :cmap mode is CMDLINE
- * for :imap mode is INSERT
- * for :lmap mode is LANGMAP
- * for :nmap mode is NORMAL
- * for :vmap mode is VISUAL + SELECTMODE
- * for :xmap mode is VISUAL
- * for :smap mode is SELECTMODE
- * for :omap mode is OP_PENDING
- * for :tmap mode is TERMINAL
+ * for :map mode is MODE_NORMAL | MODE_VISUAL | MODE_SELECT | MODE_OP_PENDING
+ * for :map! mode is MODE_INSERT | MODE_CMDLINE
+ * for :cmap mode is MODE_CMDLINE
+ * for :imap mode is MODE_INSERT
+ * for :lmap mode is MODE_LANGMAP
+ * for :nmap mode is MODE_NORMAL
+ * for :vmap mode is MODE_VISUAL | MODE_SELECT
+ * for :xmap mode is MODE_VISUAL
+ * for :smap mode is MODE_SELECT
+ * for :omap mode is MODE_OP_PENDING
+ * for :tmap mode is MODE_TERMINAL
*
- * for :abbr mode is INSERT + CMDLINE
- * for :iabbr mode is INSERT
- * for :cabbr mode is CMDLINE
+ * for :abbr mode is MODE_INSERT | MODE_CMDLINE
+ * for :iabbr mode is MODE_INSERT
+ * for :cabbr mode is MODE_CMDLINE
*
* Return 0 for success
* 1 for invalid arguments
p = *cmdp;
modec = *p++;
if (modec == 'i')
- mode = INSERT; // :imap
+ mode = MODE_INSERT; // :imap
else if (modec == 'l')
- mode = LANGMAP; // :lmap
+ mode = MODE_LANGMAP; // :lmap
else if (modec == 'c')
- mode = CMDLINE; // :cmap
+ mode = MODE_CMDLINE; // :cmap
else if (modec == 'n' && *p != 'o') // avoid :noremap
- mode = NORMAL; // :nmap
+ mode = MODE_NORMAL; // :nmap
else if (modec == 'v')
- mode = VISUAL + SELECTMODE; // :vmap
+ mode = MODE_VISUAL | MODE_SELECT; // :vmap
else if (modec == 'x')
- mode = VISUAL; // :xmap
+ mode = MODE_VISUAL; // :xmap
else if (modec == 's')
- mode = SELECTMODE; // :smap
+ mode = MODE_SELECT; // :smap
else if (modec == 'o')
- mode = OP_PENDING; // :omap
+ mode = MODE_OP_PENDING; // :omap
else if (modec == 't')
- mode = TERMINAL; // :tmap
+ mode = MODE_TERMINAL; // :tmap
else
{
--p;
if (forceit)
- mode = INSERT + CMDLINE; // :map !
+ mode = MODE_INSERT | MODE_CMDLINE; // :map !
else
- mode = VISUAL + SELECTMODE + NORMAL + OP_PENDING;// :map
+ mode = MODE_VISUAL | MODE_SELECT | MODE_NORMAL | MODE_OP_PENDING;
+ // :map
}
*cmdp = p;
int mode = 0;
if (vim_strchr(modechars, 'n') != NULL)
- mode |= NORMAL;
+ mode |= MODE_NORMAL;
if (vim_strchr(modechars, 'v') != NULL)
- mode |= VISUAL + SELECTMODE;
+ mode |= MODE_VISUAL | MODE_SELECT;
if (vim_strchr(modechars, 'x') != NULL)
- mode |= VISUAL;
+ mode |= MODE_VISUAL;
if (vim_strchr(modechars, 's') != NULL)
- mode |= SELECTMODE;
+ mode |= MODE_SELECT;
if (vim_strchr(modechars, 'o') != NULL)
- mode |= OP_PENDING;
+ mode |= MODE_OP_PENDING;
if (vim_strchr(modechars, 'i') != NULL)
- mode |= INSERT;
+ mode |= MODE_INSERT;
if (vim_strchr(modechars, 'l') != NULL)
- mode |= LANGMAP;
+ mode |= MODE_LANGMAP;
if (vim_strchr(modechars, 'c') != NULL)
- mode |= CMDLINE;
+ mode |= MODE_CMDLINE;
return mode;
}
expand_mapmodes = get_map_mode(&cmd, forceit || isabbrev);
else
{
- expand_mapmodes = INSERT + CMDLINE;
+ expand_mapmodes = MODE_INSERT | MODE_CMDLINE;
if (!isabbrev)
- expand_mapmodes += VISUAL + SELECTMODE + NORMAL + OP_PENDING;
+ expand_mapmodes += MODE_VISUAL | MODE_SELECT | MODE_NORMAL
+ | MODE_OP_PENDING;
}
expand_isabbrev = isabbrev;
xp->xp_context = EXPAND_MAPPINGS;
cmd = "map";
switch (mp->m_mode)
{
- case NORMAL + VISUAL + SELECTMODE + OP_PENDING:
+ case MODE_NORMAL | MODE_VISUAL | MODE_SELECT
+ | MODE_OP_PENDING:
break;
- case NORMAL:
+ case MODE_NORMAL:
c1 = 'n';
break;
- case VISUAL:
+ case MODE_VISUAL:
c1 = 'x';
break;
- case SELECTMODE:
+ case MODE_SELECT:
c1 = 's';
break;
- case OP_PENDING:
+ case MODE_OP_PENDING:
c1 = 'o';
break;
- case NORMAL + VISUAL:
+ case MODE_NORMAL | MODE_VISUAL:
c1 = 'n';
c2 = 'x';
break;
- case NORMAL + SELECTMODE:
+ case MODE_NORMAL | MODE_SELECT:
c1 = 'n';
c2 = 's';
break;
- case NORMAL + OP_PENDING:
+ case MODE_NORMAL | MODE_OP_PENDING:
c1 = 'n';
c2 = 'o';
break;
- case VISUAL + SELECTMODE:
+ case MODE_VISUAL | MODE_SELECT:
c1 = 'v';
break;
- case VISUAL + OP_PENDING:
+ case MODE_VISUAL | MODE_OP_PENDING:
c1 = 'x';
c2 = 'o';
break;
- case SELECTMODE + OP_PENDING:
+ case MODE_SELECT | MODE_OP_PENDING:
c1 = 's';
c2 = 'o';
break;
- case NORMAL + VISUAL + SELECTMODE:
+ case MODE_NORMAL | MODE_VISUAL | MODE_SELECT:
c1 = 'n';
c2 = 'v';
break;
- case NORMAL + VISUAL + OP_PENDING:
+ case MODE_NORMAL | MODE_VISUAL | MODE_OP_PENDING:
c1 = 'n';
c2 = 'x';
c3 = 'o';
break;
- case NORMAL + SELECTMODE + OP_PENDING:
+ case MODE_NORMAL | MODE_SELECT | MODE_OP_PENDING:
c1 = 'n';
c2 = 's';
c3 = 'o';
break;
- case VISUAL + SELECTMODE + OP_PENDING:
+ case MODE_VISUAL | MODE_SELECT | MODE_OP_PENDING:
c1 = 'v';
c2 = 'o';
break;
- case CMDLINE + INSERT:
+ case MODE_CMDLINE | MODE_INSERT:
if (!abbr)
cmd = "map!";
break;
- case CMDLINE:
+ case MODE_CMDLINE:
c1 = 'c';
break;
- case INSERT:
+ case MODE_INSERT:
c1 = 'i';
break;
- case LANGMAP:
+ case MODE_LANGMAP:
c1 = 'l';
break;
- case TERMINAL:
+ case MODE_TERMINAL:
c1 = 't';
break;
default:
int mode = 0;
int tmode;
int modec;
- const int MASK_V = VISUAL + SELECTMODE;
- const int MASK_MAP = VISUAL + SELECTMODE + NORMAL + OP_PENDING;
- const int MASK_BANG = INSERT + CMDLINE;
+ const int MASK_V = MODE_VISUAL | MODE_SELECT;
+ const int MASK_MAP = MODE_VISUAL | MODE_SELECT | MODE_NORMAL
+ | MODE_OP_PENDING;
+ const int MASK_BANG = MODE_INSERT | MODE_CMDLINE;
if (*p == NUL)
p = (char_u *)" "; // compatibility
{
switch (modec)
{
- case 'i': tmode = INSERT; break;
- case 'l': tmode = LANGMAP; break;
- case 'c': tmode = CMDLINE; break;
- case 'n': tmode = NORMAL; break;
- case 'x': tmode = VISUAL; break;
- case 's': tmode = SELECTMODE; break;
- case 'o': tmode = OP_PENDING; break;
- case 't': tmode = TERMINAL; break;
+ case 'i': tmode = MODE_INSERT; break;
+ case 'l': tmode = MODE_LANGMAP; break;
+ case 'c': tmode = MODE_CMDLINE; break;
+ case 'n': tmode = MODE_NORMAL; break;
+ case 'x': tmode = MODE_VISUAL; break;
+ case 's': tmode = MODE_SELECT; break;
+ case 'o': tmode = MODE_OP_PENDING; break;
+ case 't': tmode = MODE_TERMINAL; break;
case 'v': tmode = MASK_V; break;
case '!': tmode = MASK_BANG; break;
case ' ': tmode = MASK_MAP; break;
#if defined(MSWIN) || defined(MACOS_X)
-# define VIS_SEL (VISUAL+SELECTMODE) // abbreviation
+# define VIS_SEL (MODE_VISUAL | MODE_SELECT) // abbreviation
/*
* Default mappings for some often used keys.
static struct initmap initmappings[] =
{
// paste, copy and cut
- {(char_u *)"<S-Insert> \"*P", NORMAL},
+ {(char_u *)"<S-Insert> \"*P", MODE_NORMAL},
{(char_u *)"<S-Insert> \"-d\"*P", VIS_SEL},
- {(char_u *)"<S-Insert> <C-R><C-O>*", INSERT+CMDLINE},
+ {(char_u *)"<S-Insert> <C-R><C-O>*", MODE_INSERT | MODE_CMDLINE},
{(char_u *)"<C-Insert> \"*y", VIS_SEL},
{(char_u *)"<S-Del> \"*d", VIS_SEL},
{(char_u *)"<C-Del> \"*d", VIS_SEL},
// Use the Windows (CUA) keybindings. (Console)
static struct initmap cinitmappings[] =
{
- {(char_u *)"\316w <C-Home>", NORMAL+VIS_SEL},
- {(char_u *)"\316w <C-Home>", INSERT+CMDLINE},
- {(char_u *)"\316u <C-End>", NORMAL+VIS_SEL},
- {(char_u *)"\316u <C-End>", INSERT+CMDLINE},
+ {(char_u *)"\316w <C-Home>", MODE_NORMAL | VIS_SEL},
+ {(char_u *)"\316w <C-Home>", MODE_INSERT | MODE_CMDLINE},
+ {(char_u *)"\316u <C-End>", MODE_NORMAL | VIS_SEL},
+ {(char_u *)"\316u <C-End>", MODE_INSERT | MODE_CMDLINE},
// paste, copy and cut
# ifdef FEAT_CLIPBOARD
- {(char_u *)"\316\324 \"*P", NORMAL}, // SHIFT-Insert is "*P
+ {(char_u *)"\316\324 \"*P", MODE_NORMAL}, // SHIFT-Insert is "*P
{(char_u *)"\316\324 \"-d\"*P", VIS_SEL}, // SHIFT-Insert is "-d"*P
- {(char_u *)"\316\324 \022\017*", INSERT}, // SHIFT-Insert is ^R^O*
+ {(char_u *)"\316\324 \022\017*", MODE_INSERT}, // SHIFT-Insert is ^R^O*
{(char_u *)"\316\325 \"*y", VIS_SEL}, // CTRL-Insert is "*y
{(char_u *)"\316\327 \"*d", VIS_SEL}, // SHIFT-Del is "*d
{(char_u *)"\316\330 \"*d", VIS_SEL}, // CTRL-Del is "*d
{(char_u *)"\030 \"*d", VIS_SEL}, // CTRL-X is "*d
# else
- {(char_u *)"\316\324 P", NORMAL}, // SHIFT-Insert is P
+ {(char_u *)"\316\324 P", MODE_NORMAL}, // SHIFT-Insert is P
{(char_u *)"\316\324 \"-dP", VIS_SEL}, // SHIFT-Insert is "-dP
- {(char_u *)"\316\324 \022\017\"", INSERT}, // SHIFT-Insert is ^R^O"
+ {(char_u *)"\316\324 \022\017\"", MODE_INSERT}, // SHIFT-Insert is ^R^O"
{(char_u *)"\316\325 y", VIS_SEL}, // CTRL-Insert is y
{(char_u *)"\316\327 d", VIS_SEL}, // SHIFT-Del is d
{(char_u *)"\316\330 d", VIS_SEL}, // CTRL-Del is d
{
// Use the Standard MacOS binding.
// paste, copy and cut
- {(char_u *)"<D-v> \"*P", NORMAL},
+ {(char_u *)"<D-v> \"*P", MODE_NORMAL},
{(char_u *)"<D-v> \"-d\"*P", VIS_SEL},
- {(char_u *)"<D-v> <C-R>*", INSERT+CMDLINE},
+ {(char_u *)"<D-v> <C-R>*", MODE_INSERT | MODE_CMDLINE},
{(char_u *)"<D-c> \"*y", VIS_SEL},
{(char_u *)"<D-x> \"*d", VIS_SEL},
{(char_u *)"<Backspace> \"-d", VIS_SEL},
{
int idx;
- if ((state & INSERT))
+ if ((state & MODE_INSERT))
idx = MENU_INDEX_INSERT;
- else if (state & CMDLINE)
+ else if (state & MODE_CMDLINE)
idx = MENU_INDEX_CMDLINE;
#ifdef FEAT_TERMINAL
else if (term_use_loop())
else
idx = MENU_INDEX_VISUAL;
}
- else if (state == HITRETURN || state == ASKMORE)
+ else if (state == MODE_HITRETURN || state == MODE_ASKMORE)
idx = MENU_INDEX_CMDLINE;
else if (finish_op)
idx = MENU_INDEX_OP_PENDING;
- else if ((state & NORMAL))
+ else if ((state & MODE_NORMAL))
idx = MENU_INDEX_NORMAL;
else
idx = MENU_INDEX_INVALID;
return MENU_INDEX_SELECT;
return MENU_INDEX_VISUAL;
}
- if (State & INSERT)
+ if (State & MODE_INSERT)
return MENU_INDEX_INSERT;
- if ((State & CMDLINE) || State == ASKMORE || State == HITRETURN)
+ if ((State & MODE_CMDLINE) || State == MODE_ASKMORE
+ || State == MODE_HITRETURN)
return MENU_INDEX_CMDLINE;
if (finish_op)
return MENU_INDEX_OP_PENDING;
- if (State & NORMAL)
+ if (State & MODE_NORMAL)
return MENU_INDEX_NORMAL;
- if (State & LANGMAP) // must be a "r" command, like Insert mode
+ if (State & MODE_LANGMAP) // must be a "r" command, like Insert mode
return MENU_INDEX_INSERT;
return MENU_INDEX_INVALID;
}
// just changed.
screenalloc(FALSE);
- State = HITRETURN;
+ State = MODE_HITRETURN;
setmouse();
#ifdef USE_ON_FLY_SCROLL
dont_scroll = TRUE; // disallow scrolling here
(Rows - cmdline_row - 1) * Columns + sc_col)
VIM_CLEAR(keep_msg); // don't redisplay message, it's too long
- if (tmpState == SETWSIZE) // got resize event while in vgetc()
+ if (tmpState == MODE_SETWSIZE) // got resize event while in vgetc()
{
starttermcap(); // start termcap before redrawing
shell_resized();
set_keep_msg_from_hist(void)
{
if (keep_msg == NULL && last_msg_hist != NULL && msg_scrolled == 0
- && (State & NORMAL))
+ && (State & MODE_NORMAL))
set_keep_msg(last_msg_hist->msg, last_msg_hist->attr);
}
#endif
*/
if (lines_left > 0)
--lines_left;
- if (p_more && lines_left == 0 && State != HITRETURN
+ if (p_more && lines_left == 0 && State != MODE_HITRETURN
&& !msg_no_more && !exmode_active)
{
#ifdef FEAT_CON_DIALOG
// We get called recursively when a timer callback outputs a message. In
// that case don't show another prompt. Also when at the hit-Enter prompt
// and nothing was typed.
- if (entered || (State == HITRETURN && typed_char == 0))
+ if (entered || (State == MODE_HITRETURN && typed_char == 0))
return FALSE;
entered = TRUE;
mp_last = msg_sb_start(mp_last->sb_prev);
}
- State = ASKMORE;
+ State = MODE_ASKMORE;
setmouse();
if (typed_char == NUL)
msg_moremsg(FALSE);
#if defined(FEAT_MENU) && defined(FEAT_GUI)
if (c == K_MENU)
{
- int idx = get_menu_index(current_menu, ASKMORE);
+ int idx = get_menu_index(current_menu, MODE_ASKMORE);
// Used a menu. If it starts with CTRL-Y, it must
// be a "Copy" for the clipboard. Otherwise
}
/*
- * Repeat the message for the current mode: ASKMORE, EXTERNCMD, CONFIRM or
- * exmode_active.
+ * Repeat the message for the current mode: MODE_ASKMORE, MODE_EXTERNCMD,
+ * MODE_CONFIRM or exmode_active.
*/
void
repeat_message(void)
{
- if (State == ASKMORE)
+ if (State == MODE_ASKMORE)
{
msg_moremsg(TRUE); // display --more-- message again
msg_row = Rows - 1;
}
#ifdef FEAT_CON_DIALOG
- else if (State == CONFIRM)
+ else if (State == MODE_CONFIRM)
{
display_confirm_msg(); // display ":confirm" message again
msg_row = Rows - 1;
}
#endif
- else if (State == EXTERNCMD)
+ else if (State == MODE_EXTERNCMD)
{
windgoto(msg_row, msg_col); // put cursor back
}
- else if (State == HITRETURN || State == SETWSIZE)
+ else if (State == MODE_HITRETURN || State == MODE_SETWSIZE)
{
if (msg_row == Rows - 1)
{
* we have to redraw the window.
* Do not do this if we are abandoning the file or editing the command line.
*/
- if (!exiting && need_wait_return && !(State & CMDLINE))
+ if (!exiting && need_wait_return && !(State & MODE_CMDLINE))
{
wait_return(FALSE);
return FALSE;
#endif
oldState = State;
- State = CONFIRM;
+ State = MODE_CONFIRM;
setmouse();
// Ensure raw mode here.
/*
* If *s is a TAB, and the TAB is not displayed as ^I, and we're not in
- * INSERT mode, then col must be adjusted so that it represents the last
- * screen position of the TAB. This only fixes an error when the TAB wraps
- * from one screen line to the next (when 'columns' is not a multiple of
- * 'ts') -- webb.
+ * MODE_INSERT state, then col must be adjusted so that it represents the
+ * last screen position of the TAB. This only fixes an error when the TAB
+ * wraps from one screen line to the next (when 'columns' is not a multiple
+ * of 'ts') -- webb.
*/
- if (*s == TAB && (State & NORMAL) && (!wp->w_p_list ||
- wp->w_lcs_chars.tab1))
+ if (*s == TAB && (State & MODE_NORMAL)
+ && (!wp->w_p_list || wp->w_lcs_chars.tab1))
col += win_lbr_chartabsize(wp, line, s, (colnr_T)col, NULL) - 1;
/*
#ifdef USE_ON_FLY_SCROLL
dont_scroll = TRUE; // disallow scrolling here
#endif
- State = CONFIRM; // mouse behaves like with :confirm
+ State = MODE_CONFIRM; // mouse behaves like with :confirm
setmouse(); // disables mouse for xterm
++no_mapping;
++allow_keys; // no mapping here, but recognize keys
buf[i++] = 's';
}
}
- else if (State == HITRETURN || State == ASKMORE || State == SETWSIZE
- || State == CONFIRM)
+ else if (State == MODE_HITRETURN || State == MODE_ASKMORE
+ || State == MODE_SETWSIZE
+ || State == MODE_CONFIRM)
{
buf[i++] = 'r';
- if (State == ASKMORE)
+ if (State == MODE_ASKMORE)
buf[i++] = 'm';
- else if (State == CONFIRM)
+ else if (State == MODE_CONFIRM)
buf[i++] = '?';
}
- else if (State == EXTERNCMD)
+ else if (State == MODE_EXTERNCMD)
buf[i++] = '!';
- else if (State & INSERT)
+ else if (State & MODE_INSERT)
{
if (State & VREPLACE_FLAG)
{
else if (ctrl_x_mode_not_defined_yet())
buf[i++] = 'x';
}
- else if ((State & CMDLINE) || exmode_active)
+ else if ((State & MODE_CMDLINE) || exmode_active)
{
buf[i++] = 'c';
if (exmode_active == EXMODE_VIM)
if (n == KEYLEN_REMOVED) // key code removed
{
- if (must_redraw != 0 && !need_wait_return
- && (State & (CMDLINE|HITRETURN|ASKMORE)) == 0)
+ if (must_redraw != 0 && !need_wait_return && (State
+ & (MODE_CMDLINE | MODE_HITRETURN | MODE_ASKMORE)) == 0)
{
// Redrawing was postponed, do it now.
update_screen(0);
save_cmdline_row = cmdline_row;
cmdline_row = 0;
save_State = State;
- State = CMDLINE;
+ State = MODE_CMDLINE;
// May show different mouse shape.
setmouse();
if (virtual_op != MAYBE)
return virtual_op;
return (cur_ve_flags == VE_ALL
- || ((cur_ve_flags & VE_BLOCK) && VIsual_active && VIsual_mode == Ctrl_V)
- || ((cur_ve_flags & VE_INSERT) && (State & INSERT)));
+ || ((cur_ve_flags & VE_BLOCK) && VIsual_active
+ && VIsual_mode == Ctrl_V)
+ || ((cur_ve_flags & VE_INSERT) && (State & MODE_INSERT)));
}
/*
int head = 0;
#endif
- one_more = (State & INSERT)
+ one_more = (State & MODE_INSERT)
|| restart_edit != NUL
|| (VIsual_active && *p_sel != 'o')
|| ((get_ve_flags() & VE_ONEMORE) && wcol < MAXCOL);
csize--;
if (wcol / width > (colnr_T)csize / width
- && ((State & INSERT) == 0 || (int)wcol > csize + 1))
+ && ((State & MODE_INSERT) == 0 || (int)wcol > csize + 1))
{
// In case of line wrapping don't move the cursor beyond the
// right screen edge. In Insert mode allow going just beyond
// - in Insert mode or restarting Insert mode
// - in Visual mode and 'selection' isn't "old"
// - 'virtualedit' is set
- if ((State & INSERT) || restart_edit
+ if ((State & MODE_INSERT) || restart_edit
|| (VIsual_active && *p_sel != 'o')
|| (cur_ve_flags & VE_ONEMORE)
|| virtual_active())
}
/*
- * VISUAL, SELECTMODE and OP_PENDING State are never set, they are equal to
- * NORMAL State with a condition. This function returns the real State.
+ * MODE_VISUAL, MODE_SELECT and MODE_OP_PENDING State are never set, they are
+ * equal to MODE_NORMAL State with a condition. This function returns the real
+ * State.
*/
int
get_real_state(void)
{
- if (State & NORMAL)
+ if (State & MODE_NORMAL)
{
if (VIsual_active)
{
if (VIsual_select)
- return SELECTMODE;
- return VISUAL;
+ return MODE_SELECT;
+ return MODE_VISUAL;
}
else if (finish_op)
- return OP_PENDING;
+ return MODE_OP_PENDING;
}
return State;
}
get_shape_idx(int mouse)
{
#ifdef FEAT_MOUSESHAPE
- if (mouse && (State == HITRETURN || State == ASKMORE))
+ if (mouse && (State == MODE_HITRETURN || State == MODE_ASKMORE))
{
# ifdef FEAT_GUI
int x, y;
if (mouse && drag_sep_line)
return SHAPE_IDX_VDRAG;
#endif
- if (!mouse && State == SHOWMATCH)
+ if (!mouse && State == MODE_SHOWMATCH)
return SHAPE_IDX_SM;
if (State & VREPLACE_FLAG)
return SHAPE_IDX_R;
if (State & REPLACE_FLAG)
return SHAPE_IDX_R;
- if (State & INSERT)
+ if (State & MODE_INSERT)
return SHAPE_IDX_I;
- if (State & CMDLINE)
+ if (State & MODE_CMDLINE)
{
if (cmdline_at_end())
return SHAPE_IDX_C;
if (!mouse_has(MOUSE_VISUAL))
return FALSE;
}
- else if (State == NORMAL && !mouse_has(MOUSE_NORMAL))
+ else if (State == MODE_NORMAL && !mouse_has(MOUSE_NORMAL))
return FALSE;
}
// CTRL right mouse button does CTRL-T
if (is_click && (mod_mask & MOD_MASK_CTRL) && which_button == MOUSE_RIGHT)
{
- if (State & INSERT)
+ if (State & MODE_INSERT)
stuffcharReadbuff(Ctrl_O);
if (count > 1)
stuffnumReadbuff(count);
// Middle mouse button does a 'put' of the selected text
if (which_button == MOUSE_MIDDLE)
{
- if (State == NORMAL)
+ if (State == MODE_NORMAL)
{
// If an operator was pending, we don't know what the user wanted
// to do. Go back to normal mode: Clear the operator and beep().
// The rest is below jump_to_mouse()
}
- else if ((State & INSERT) == 0)
+ else if ((State & MODE_INSERT) == 0)
return FALSE;
// Middle click in insert mode doesn't move the mouse, just insert the
// with do_put().
// Also paste at the cursor if the current mode isn't in 'mouse' (only
// happens for the GUI).
- if ((State & INSERT) || !mouse_has(MOUSE_NORMAL))
+ if ((State & MODE_INSERT) || !mouse_has(MOUSE_NORMAL))
{
if (regname == '.')
insert_reg(regname, TRUE);
}
}
- if ((State & (NORMAL | INSERT))
+ if ((State & (MODE_NORMAL | MODE_INSERT))
&& !(mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)))
{
if (which_button == MOUSE_LEFT)
}
}
// If Visual mode started in insert mode, execute "CTRL-O"
- else if ((State & INSERT) && VIsual_active)
+ else if ((State & MODE_INSERT) && VIsual_active)
stuffcharReadbuff(Ctrl_O);
// Middle mouse click: Put text before cursor.
else if ((mod_mask & MOD_MASK_CTRL) || (curbuf->b_help
&& (mod_mask & MOD_MASK_MULTI_CLICK) == MOD_MASK_2CLICK))
{
- if (State & INSERT)
+ if (State & MODE_INSERT)
stuffcharReadbuff(Ctrl_O);
stuffcharReadbuff(Ctrl_RSB);
got_click = FALSE; // ignore drag&release now
// the mouse pointer
else if ((mod_mask & MOD_MASK_SHIFT))
{
- if ((State & INSERT) || (VIsual_active && VIsual_select))
+ if ((State & MODE_INSERT) || (VIsual_active && VIsual_select))
stuffcharReadbuff(Ctrl_O);
if (which_button == MOUSE_LEFT)
stuffcharReadbuff('*');
}
#endif
}
- else if ((mod_mask & MOD_MASK_MULTI_CLICK) && (State & (NORMAL | INSERT))
+ else if ((mod_mask & MOD_MASK_MULTI_CLICK)
+ && (State & (MODE_NORMAL | MODE_INSERT))
&& mouse_has(MOUSE_VISUAL))
{
if (is_click || !VIsual_active)
if (VIsual_active)
checkfor = MOUSE_VISUAL;
- else if (State == HITRETURN || State == ASKMORE || State == SETWSIZE)
+ else if (State == MODE_HITRETURN || State == MODE_ASKMORE
+ || State == MODE_SETWSIZE)
checkfor = MOUSE_RETURN;
- else if (State & INSERT)
+ else if (State & MODE_INSERT)
checkfor = MOUSE_INSERT;
- else if (State & CMDLINE)
+ else if (State & MODE_CMDLINE)
checkfor = MOUSE_COMMAND;
- else if (State == CONFIRM || State == EXTERNCMD)
+ else if (State == MODE_CONFIRM || State == MODE_EXTERNCMD)
checkfor = ' '; // don't use mouse for ":confirm" or ":!cmd"
else
checkfor = MOUSE_NORMAL; // assume normal mode
out_flush_cursor(TRUE, FALSE);
// Quit a hit-return or more prompt.
- if (State == HITRETURN || State == ASKMORE)
+ if (State == MODE_HITRETURN || State == MODE_ASKMORE)
{
#ifdef FEAT_GUI_GTK
if (gui.in_use && gtk_main_level() > 0)
out_flush_cursor(TRUE, FALSE);
// Quit a hit-return or more prompt.
- if (State == HITRETURN || State == ASKMORE)
+ if (State == MODE_HITRETURN || State == MODE_ASKMORE)
{
#ifdef FEAT_GUI_GTK
if (gui.in_use && gtk_main_level() > 0)
strcpy(&keybuf[i], tok);
vim_snprintf(cmdbuf, sizeof(cmdbuf),
"<silent><%s> :nbkey %s<CR>", keybuf, keybuf);
- do_map(0, (char_u *)cmdbuf, NORMAL, FALSE);
+ do_map(0, (char_u *)cmdbuf, MODE_NORMAL, FALSE);
}
tok = strtok(NULL, " ");
}
{
if (repl)
{
- State = REPLACE; // pretend Replace mode
+ State = MODE_REPLACE; // pretend Replace mode
#ifdef CURSOR_SHAPE
ui_cursor_shape(); // show different cursor shape
#endif
--no_mapping;
--allow_keys;
if (repl)
- State = LREPLACE;
+ State = MODE_LREPLACE;
else
- State = LANGMAP;
+ State = MODE_LANGMAP;
langmap_active = TRUE;
}
#ifdef HAVE_INPUT_METHOD
if (lang && curbuf->b_p_iminsert == B_IMODE_IM)
im_set_active(TRUE);
#endif
- if ((State & INSERT) && !p_ek)
+ if ((State & MODE_INSERT) && !p_ek)
{
#ifdef FEAT_JOB_CHANNEL
ch_log_output = TRUE;
*cp = plain_vgetc();
- if ((State & INSERT) && !p_ek)
+ if ((State & MODE_INSERT) && !p_ek)
{
#ifdef FEAT_JOB_CHANNEL
ch_log_output = TRUE;
// Undo the decrement done above
++no_mapping;
++allow_keys;
- State = NORMAL_BUSY;
+ State = MODE_NORMAL_BUSY;
}
#ifdef HAVE_INPUT_METHOD
if (lang)
}
p_smd = save_smd;
#endif
- State = NORMAL_BUSY;
+ State = MODE_NORMAL_BUSY;
#ifdef FEAT_CMDL_INFO
*need_flushbuf |= add_to_showcmd(*cp);
#endif
// Draw the cursor with the right shape here
if (restart_edit != 0)
- State = INSERT;
+ State = MODE_INSERT;
// If need to redraw, and there is a "keep_msg", redraw before the
// delay
mapped_len = typebuf_maplen();
- State = NORMAL_BUSY;
+ State = MODE_NORMAL_BUSY;
#ifdef USE_ON_FLY_SCROLL
dont_scroll = FALSE; // allow scrolling here
#endif
* Get the command character from the user.
*/
c = safe_vgetc();
- LANGMAP_ADJUST(c, get_real_state() != SELECTMODE);
+ LANGMAP_ADJUST(c, get_real_state() != MODE_SELECT);
// If a mapping was started in Visual or Select mode, remember the length
// of the mapping. This is used below to not return to Insert mode for as
did_cursorhold = FALSE;
}
- State = NORMAL;
+ State = MODE_NORMAL;
if (ca.nchar == ESC)
{
// composing characters for utf-8.
for (n = cap->count1; n > 0; --n)
{
- State = REPLACE;
+ State = MODE_REPLACE;
if (cap->nchar == Ctrl_E || cap->nchar == Ctrl_Y)
{
int c = ins_copychar(curwin->w_cursor.lnum
// Pretend Insert mode here to allow the cursor on the
// character past the end of the line
- State = INSERT;
+ State = MODE_INSERT;
coladvance((colnr_T)MAXCOL);
State = save_State;
}
// Pretend Insert mode here to allow the cursor on the
// character past the end of the line
- State = INSERT;
+ State = MODE_INSERT;
coladvance(getviscol());
State = save_State;
}
p_ri = 0; // don't want revins in indent
#endif
- State = INSERT; // don't want REPLACE for State
+ State = MODE_INSERT; // don't want MODE_REPLACE for State
block_prep(oap, &bd, curwin->w_cursor.lnum, TRUE);
if (bd.is_short)
return;
linenr_T lnum; // loop var
int oldstate = State;
- State = INSERT; // don't want REPLACE for State
+ State = MODE_INSERT; // don't want MODE_REPLACE for State
s_len = (unsigned)STRLEN(s);
for (lnum = oap->start.lnum + 1; lnum <= oap->end.lnum; lnum++)
{
int n = State;
- State = REPLACE;
+ State = MODE_REPLACE;
ins_char(c);
State = n;
// Backup to the replaced character.
if (curwin->w_cursor.col > 0
&& gchar_cursor() == NUL
&& (cur_ve_flags & VE_ONEMORE) == 0
- && !(restart_edit || (State & INSERT)))
+ && !(restart_edit || (State & MODE_INSERT)))
{
// Put the cursor on the last character in the line.
dec_cursor();
{
if (p_im)
{
- if ((State & INSERT) == 0)
+ if ((State & MODE_INSERT) == 0)
need_start_insertmode = TRUE;
stop_insert_mode = FALSE;
}
// Only de-activate it here, it will be enabled when changing mode.
if (p_imdisable)
im_set_active(FALSE);
- else if (State & INSERT)
+ else if (State & MODE_INSERT)
// When the option is set from an autocommand, it may need to take
// effect right away.
im_set_active(curbuf->b_p_iminsert == B_IMODE_IM);
p_more_save = p_more;
p_more = FALSE;
old_State = State;
- State = EXTERNCMD; // don't redraw at window resize
+ State = MODE_EXTERNCMD; // don't redraw at window resize
if ((options & SHELL_WRITE) && toshell_fd >= 0)
{
# ifdef FEAT_MBYTE_IME
// May have to redraw if the cursor ends up in the wrong place.
// Only when not peeking.
- if (State & CMDLINE && msg_row == Rows - 1 && msec != 0)
+ if (State == MODE_CMDLINE && msg_row == Rows - 1 && msec != 0)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
win_T *pvwin;
#endif
#ifdef FEAT_RIGHTLEFT
- int right_left = State == CMDLINE ? FALSE : curwin->w_p_rl;
+ int right_left = State == MODE_CMDLINE ? FALSE : curwin->w_p_rl;
#endif
do
// Remember the essential parts of the window position and size, so we
// can decide when to reposition the popup menu.
pum_window = curwin;
- if (State == CMDLINE)
+ if (State == MODE_CMDLINE)
// cmdline completion popup menu
pum_win_row = cmdline_row;
else
{
// pum above "pum_win_row"
- if (State == CMDLINE)
+ if (State == MODE_CMDLINE)
// for cmdline pum, no need for context lines
context_lines = 0;
else
{
// pum below "pum_win_row"
- if (State == CMDLINE)
+ if (State == MODE_CMDLINE)
// for cmdline pum, no need for context lines
context_lines = 0;
else
// Calculate column
#ifdef FEAT_WILDMENU
- if (State == CMDLINE)
+ if (State == MODE_CMDLINE)
// cmdline completion popup menu
cursor_col = cmdline_compl_startcol();
else
if (*wp->w_p_cocu == NUL)
return FALSE;
- if (get_real_state() & VISUAL)
+ if (get_real_state() & MODE_VISUAL)
c = 'v';
- else if (State & INSERT)
+ else if (State & MODE_INSERT)
c = 'i';
- else if (State & NORMAL)
+ else if (State & MODE_NORMAL)
c = 'n';
- else if (State & CMDLINE)
+ else if (State & MODE_CMDLINE)
c = 'c';
else
return FALSE;
int sub_attr;
do_mode = ((p_smd && msg_silent == 0)
- && ((State & INSERT)
+ && ((State & MODE_INSERT)
|| restart_edit != NUL
|| VIsual_active));
if (do_mode || reg_recording != 0)
msg_puts_attr(_(" VREPLACE"), attr);
else if (State & REPLACE_FLAG)
msg_puts_attr(_(" REPLACE"), attr);
- else if (State & INSERT)
+ else if (State & MODE_INSERT)
{
#ifdef FEAT_RIGHTLEFT
if (p_ri)
msg_puts_attr(_(" Hebrew"), attr);
#endif
#ifdef FEAT_KEYMAP
- if (State & LANGMAP)
+ if (State & MODE_LANGMAP)
{
# ifdef FEAT_ARABIC
if (curwin->w_p_arab)
msg_puts_attr((char *)NameBuff, attr);
}
#endif
- if ((State & INSERT) && p_paste)
+ if ((State & MODE_INSERT) && p_paste)
msg_puts_attr(_(" (paste)"), attr);
if (VIsual_active)
save_dollar_vcol = dollar_vcol;
#ifdef CURSOR_SHAPE
save_state = State;
- State = SHOWMATCH;
+ State = MODE_SHOWMATCH;
ui_cursor_shape(); // may show different cursor shape
#endif
curwin->w_cursor = mpos; // move to matching char
vim_strncpy(mfp, tagpp->tagname, len);
// if wanted, re-read line to get long form too
- if (State & INSERT)
+ if (State & MODE_INSERT)
st->get_searchpat = p_sft;
}
}
#if defined(EXITFREE) || defined(PROTO)
# ifdef HAVE_DEL_CURTERM
-# undef TERMINAL // name clash in term.h
# include <term.h> // declares cur_term
# endif
if (width < 0 || height < 0) // just checking...
return;
- if (State == HITRETURN || State == SETWSIZE)
+ if (State == MODE_HITRETURN || State == MODE_SETWSIZE)
{
// postpone the resizing
- State = SETWSIZE;
+ State = MODE_SETWSIZE;
return;
}
// screenalloc() (also invoked from screenclear()). That is because the
// "busy" check above may skip this, but not screenalloc().
- if (State != ASKMORE && State != EXTERNCMD && State != CONFIRM)
+ if (State != MODE_ASKMORE && State != MODE_EXTERNCMD
+ && State != MODE_CONFIRM)
screenclear();
else
screen_start(); // don't know where cursor is now
* Always need to call update_screen() or screenalloc(), to make
* sure Rows/Columns and the size of ScreenLines[] is correct!
*/
- if (State == ASKMORE || State == EXTERNCMD || State == CONFIRM
- || exmode_active)
+ if (State == MODE_ASKMORE || State == MODE_EXTERNCMD
+ || State == MODE_CONFIRM || exmode_active)
{
screenalloc(FALSE);
repeat_message();
{
if (curwin->w_p_scb)
do_check_scrollbind(TRUE);
- if (State & CMDLINE)
+ if (State & MODE_CMDLINE)
{
update_screen(NOT_VALID);
redrawcmdline();
return;
}
- if ((State & REPLACE) == REPLACE)
+ if ((State & MODE_REPLACE) == MODE_REPLACE)
{
- if (forced || showing_mode != REPLACE)
+ if (forced || showing_mode != MODE_REPLACE)
{
if (*T_CSR != NUL)
p = T_CSR; // Replace mode cursor
if (*p != NUL)
{
out_str(p);
- showing_mode = REPLACE;
+ showing_mode = MODE_REPLACE;
}
}
}
- else if (State & INSERT)
+ else if (State & MODE_INSERT)
{
- if ((forced || showing_mode != INSERT) && *T_CSI != NUL)
+ if ((forced || showing_mode != MODE_INSERT) && *T_CSI != NUL)
{
out_str(T_CSI); // Insert mode cursor
- showing_mode = INSERT;
+ showing_mode = MODE_INSERT;
}
}
- else if (forced || showing_mode != NORMAL)
+ else if (forced || showing_mode != MODE_NORMAL)
{
out_str(T_CEI); // non-Insert mode cursor
- showing_mode = NORMAL;
+ showing_mode = MODE_NORMAL;
}
}
* Skip this position if p_ek is not set and tp[0] is an ESC and we
* are in Insert mode.
*/
- if (*tp == ESC && !p_ek && (State & INSERT))
+ if (*tp == ESC && !p_ek && (State & MODE_INSERT))
continue;
key_name[0] = NUL; // no key name found yet
// cleared.
// TODO: only update once in a while.
ch_log(term->tl_job->jv_channel, "updating screen");
- if (buffer == curbuf && (State & CMDLINE) == 0)
+ if (buffer == curbuf && (State & MODE_CMDLINE) == 0)
{
update_screen(VALID_NO_UPDATE);
// update_screen() can be slow, check the terminal wasn't closed
int modify_other_keys = curbuf->b_term->tl_vterm == NULL ? FALSE
: vterm_is_modify_other_keys(curbuf->b_term->tl_vterm);
- State = TERMINAL;
+ State = MODE_TERMINAL;
got_int = FALSE;
#ifdef MSWIN
ctrl_break_was_pressed = FALSE;
if (term_use_loop_check(TRUE))
{
reset_VIsual_and_resel();
- if (State & INSERT)
+ if (State & MODE_INSERT)
stop_insert_mode = TRUE;
}
mouse_was_outside = FALSE;
undisplay_dollar();
// Offset between cursor position and line break is used by replace
- // stack functions. VREPLACE does not use this, and backspaces
+ // stack functions. MODE_VREPLACE does not use this, and backspaces
// over the text instead.
if (State & VREPLACE_FLAG)
orig_col = startcol; // Will start backspacing from here
if (State & VREPLACE_FLAG)
{
- // In VREPLACE mode, we will backspace over the text to be
+ // In MODE_VREPLACE state, we will backspace over the text to be
// wrapped, so save a copy now to put on the next line.
saved_text = vim_strsave(ml_get_cursor());
curwin->w_cursor.col = orig_col;
if (State & VREPLACE_FLAG)
{
- // In VREPLACE mode we have backspaced over the text to be
+ // In MODE_VREPLACE state we have backspaced over the text to be
// moved, now we re-insert it into the new line.
ins_bytes(saved_text);
vim_free(saved_text);
}
// put cursor on last non-space
- State = NORMAL; // don't go past end-of-line
+ State = MODE_NORMAL; // don't go past end-of-line
coladvance((colnr_T)MAXCOL);
while (curwin->w_cursor.col && vim_isspace(gchar_cursor()))
dec_cursor();
// do the formatting, without 'showmode'
- State = INSERT; // for open_line()
+ State = MODE_INSERT; // for open_line()
smd_save = p_smd;
p_smd = FALSE;
insertchar(NUL, INSCHAR_FORMAT
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 4911,
/**/
4910,
/**/
#define MSG_HIST 0x1000
/*
- * values for State
+ * Values for State.
*
- * The lower bits up to 0x20 are used to distinguish normal/visual/op_pending
- * and cmdline/insert+replace mode. This is used for mapping. If none of
- * these bits are set, no mapping is done.
- * The upper bits are used to distinguish between other states.
+ * The lower bits up to 0x80 are used to distinguish normal/visual/op_pending
+ * /cmdline/insert/replace/terminal mode. This is used for mapping. If none
+ * of these bits are set, no mapping is done. See the comment above do_map().
+ * The upper bits are used to distinguish between other states and variants of
+ * the base modes.
*/
-#define NORMAL 0x01 // Normal mode, command expected
-#define VISUAL 0x02 // Visual mode - use get_real_state()
-#define OP_PENDING 0x04 // Normal mode, operator is pending - use
+#define MODE_NORMAL 0x01 // Normal mode, command expected
+#define MODE_VISUAL 0x02 // Visual mode - use get_real_state()
+#define MODE_OP_PENDING 0x04 // Normal mode, operator is pending - use
// get_real_state()
-#define CMDLINE 0x08 // Editing command line
-#define INSERT 0x10 // Insert mode
-#define LANGMAP 0x20 // Language mapping, can be combined with
- // INSERT and CMDLINE
-
-#define REPLACE_FLAG 0x40 // Replace mode flag
-#define REPLACE (REPLACE_FLAG + INSERT)
-#define VREPLACE_FLAG 0x80 // Virtual-replace mode flag
-#define VREPLACE (REPLACE_FLAG + VREPLACE_FLAG + INSERT)
-#define LREPLACE (REPLACE_FLAG + LANGMAP)
-
-#define NORMAL_BUSY (0x100 + NORMAL) // Normal mode, busy with a command
-#define HITRETURN (0x200 + NORMAL) // waiting for return or command
-#define ASKMORE 0x300 // Asking if you want --more--
-#define SETWSIZE 0x400 // window size has changed
-#define ABBREV 0x500 // abbreviation instead of mapping
-#define EXTERNCMD 0x600 // executing an external command
-#define SHOWMATCH (0x700 + INSERT) // show matching paren
-#define CONFIRM 0x800 // ":confirm" prompt
-#define SELECTMODE 0x1000 // Select mode, only for mappings
-#define TERMINAL 0x2000 // Terminal mode
+#define MODE_CMDLINE 0x08 // Editing the command line
+#define MODE_INSERT 0x10 // Insert mode, also for Replace mode
+#define MODE_LANGMAP 0x20 // Language mapping, can be combined with
+ // MODE_INSERT and MODE_CMDLINE
+#define MODE_SELECT 0x40 // Select mode, use get_real_state()
+#define MODE_TERMINAL 0x80 // Terminal mode
+
+#define MAP_ALL_MODES 0xff // all mode bits used for mapping
+
+#define REPLACE_FLAG 0x100 // Replace mode flag
+#define MODE_REPLACE (REPLACE_FLAG | MODE_INSERT)
+#define VREPLACE_FLAG 0x200 // Virtual-replace mode flag
+#define MODE_VREPLACE (REPLACE_FLAG | VREPLACE_FLAG | MODE_INSERT)
+#define MODE_LREPLACE (REPLACE_FLAG | MODE_LANGMAP)
+
+#define MODE_NORMAL_BUSY (0x1000 | MODE_NORMAL)
+ // Normal mode, busy with a command
+#define MODE_HITRETURN (0x2000 | MODE_NORMAL)
+ // waiting for return or command
+#define MODE_ASKMORE 0x3000 // Asking if you want --more--
+#define MODE_SETWSIZE 0x4000 // window size has changed
+#define MODE_EXTERNCMD 0x5000 // executing an external command
+#define MODE_SHOWMATCH (0x6000 | MODE_INSERT) // show matching paren
+#define MODE_CONFIRM 0x7000 // ":confirm" prompt
#define MODE_ALL 0xffff
-#define MODE_MAX_LENGTH 4 // max mode length returned in mode()
-
-// all mode bits used for mapping
-#define MAP_ALL_MODES (0x3f | SELECTMODE | TERMINAL)
+#define MODE_MAX_LENGTH 4 // max mode length used by get_mode(),
+ // including the terminating NUL
// directions
#define FORWARD 1
/*
* Avoid clashes between Perl and Vim namespace.
*/
-# undef NORMAL
# undef STRLEN
# undef FF
# undef OP_DELETE
// When leaving the window (or closing the window) was done from a
// callback we need to break out of the Insert mode loop and restart Insert
// mode when entering the window again.
- if (State & INSERT)
+ if (State & MODE_INSERT)
{
stop_insert_mode = TRUE;
if (win->w_buffer->b_prompt_insert == NUL)
// When entering the prompt window restart Insert mode if we were in Insert
// mode when we left it and not already in Insert mode.
- if ((State & INSERT) == 0)
+ if ((State & MODE_INSERT) == 0)
restart_edit = win->w_buffer->b_prompt_insert;
}
#endif
projects / vim / commitdiff