vim: src/insexpand.c comparison

comparison src/insexpand.c @ 26944:8dbdd68627bd v8.2.4001

patch 8.2.4001: insert complete code uses global variables Commit: https://github.com/vim/vim/commit/d94fbfc74a8b8073e7a256c95fa6f39fc527c726 Author: Yegappan Lakshmanan <yegappan@yahoo.com> Date: Tue Jan 4 17:01:44 2022 +0000 patch 8.2.4001: insert complete code uses global variables Problem: Insert complete code uses global variables. Solution: Make variables local to the file and use accessor functions. (Yegappan Lakshmanan, closes #9470)

author	Bram Moolenaar <Bram@vim.org>
date	Tue, 04 Jan 2022 18:15:03 +0100
parents	b975b7c16ba1
children	d92e0d85923f

comparison

equal deleted inserted replaced

-:61f686b38df9
+:8dbdd68627bd
 static int	  compl_started = FALSE;
 // Which Ctrl-X mode are we in?
 static int	  ctrl_x_mode = CTRL_X_NORMAL;
-static int	  compl_matches = 0;
+static int	  compl_matches = 0;	    // number of completion matches
 static char_u	  *compl_pattern = NULL;
 static int	  compl_direction = FORWARD;
 static int	  compl_shows_dir = FORWARD;
 static int	  compl_pending = 0;	    // > 1 for postponed CTRL-N
 static pos_T	  compl_startpos;
+// Length in bytes of the text being completed (this is deleted to be replaced
+// by the match.)
+static int	  compl_length = 0;
 static colnr_T	  compl_col = 0;	    // column where the text starts
 					    // that is being completed
 static char_u	  *compl_orig_text = NULL;  // text as it was before
 					    // completion started
 static int	  compl_cont_mode = 0;
 static expand_T	  compl_xp;
+// List of flags for method of completion.
+static int	  compl_cont_status = 0;
+# define CONT_ADDING	1	// "normal" or "adding" expansion
+# define CONT_INTRPT	(2 + 4)	// a ^X interrupted the current expansion
+				// it's set only iff N_ADDS is set
+# define CONT_N_ADDS	4	// next ^X<> will add-new or expand-current
+# define CONT_S_IPOS	8	// next ^X<> will set initial_pos?
+				// if so, word-wise-expansion will set SOL
+# define CONT_SOL	16	// pattern includes start of line, just for
+				// word-wise expansion, not set for ^X^L
+# define CONT_LOCAL	32	// for ctrl_x_mode 0, ^X^P/^X^N do a local
+				// expansion, (eg use complete=.)
 static int	  compl_opt_refresh_always = FALSE;
 static int	  compl_opt_suppress_empty = FALSE;
 static int ins_compl_add(char_u *str, int len, char_u *fname, char_u **cptext, typval_T *user_data, int cdir, int flags, int adup);
 static void ins_compl_files(int count, char_u **files, int thesaurus, int flags, regmatch_T *regmatch, char_u *buf, int *dir);
 static char_u *find_line_end(char_u *ptr);
 static void ins_compl_free(void);
 static int  ins_compl_need_restart(void);
 static void ins_compl_new_leader(void);
-static int  ins_compl_len(void);
+static int  get_compl_len(void);
 static void ins_compl_restart(void);
 static void ins_compl_set_original_text(char_u *str);
 static void ins_compl_fixRedoBufForLeader(char_u *ptr_arg);
 # if defined(FEAT_COMPL_FUNC) || defined(FEAT_EVAL)
 static void ins_compl_add_list(list_T *list);
 	return ctrl_x_mode == CTRL_X_CMDLINE
 		|| ctrl_x_mode == CTRL_X_CMDLINE_CTRL_X; }
 int ctrl_x_mode_function(void) { return ctrl_x_mode == CTRL_X_FUNCTION; }
 int ctrl_x_mode_omni(void) { return ctrl_x_mode == CTRL_X_OMNI; }
 int ctrl_x_mode_spell(void) { return ctrl_x_mode == CTRL_X_SPELL; }
+static int ctrl_x_mode_eval(void) { return ctrl_x_mode == CTRL_X_EVAL; }
 int ctrl_x_mode_line_or_eval(void) {
 return ctrl_x_mode == CTRL_X_WHOLE_LINE || ctrl_x_mode == CTRL_X_EVAL; }
 /*
 * Whether other than default completion has been selected.
 {
 return ctrl_x_mode == CTRL_X_NOT_DEFINED_YET;
 }
 /*
-* Return TRUE if the 'dict' or 'tsr' option can be used.
+* Return TRUE if currently in "normal" or "adding" insert completion matches
+* state
+*/
+int
+compl_status_adding(void)
+{
+return compl_cont_status & CONT_ADDING;
+}
+/*
+* Return TRUE if the completion pattern includes start of line, just for
+* word-wise expansion.
+*/
+int
+compl_status_sol(void)
+{
+return compl_cont_status & CONT_SOL;
+}
+/*
+* Return TRUE if ^X^P/^X^N will do a local completion (i.e. use complete=.)
+*/
+int
+compl_status_local(void)
+{
+return compl_cont_status & CONT_LOCAL;
+}
+/*
+* Clear the completion status flags
+*/
+void
+compl_status_clear(void)
+{
+compl_cont_status = 0;
+}
+/*
+* Return TRUE if completion is using the forward direction matches
+*/
+static int
+compl_dir_forward(void)
+{
+return compl_direction == FORWARD;
+}
+/*
+* Return TRUE if currently showing forward completion matches
+*/
+static int
+compl_shows_dir_forward(void)
+{
+return compl_shows_dir == FORWARD;
+}
+/*
+* Return TRUE if currently showing backward completion matches
+*/
+static int
+compl_shows_dir_backward(void)
+{
+return compl_shows_dir == BACKWARD;
+}
+/*
+* Return TRUE if the 'dictionary' or 'thesaurus' option can be used.
 */
 int
 has_compl_option(int dict_opt)
 {
 if (dict_opt ? (*curbuf->b_p_dict == NUL && *p_dict == NUL
 }
 return TRUE;
 }
 /*
-* Is the character 'c' a valid key to go to or keep us in CTRL-X mode?
+* Is the character "c" a valid key to go to or keep us in CTRL-X mode?
 * This depends on the current mode.
 */
 int
 vim_is_ctrl_x_key(int c)
 {
 internal_error("vim_is_ctrl_x_key()");
 return FALSE;
 }
 /*
-* Returns TRUE if the currently shown text is the original text when the
+* Return TRUE if "match" is the original text when the completion began.
-* completion began.
 */
 static int
-ins_compl_at_original_text(compl_T *match)
+match_at_original_text(compl_T *match)
 {
 return match->cp_flags & CP_ORIGINAL_TEXT;
+}
+/*
+* Returns TRUE if "match" is the first match in the completion list.
+*/
+static int
+is_first_match(compl_T *match)
+{
+return match == compl_first_match;
 }
 /*
 * Return TRUE when character "c" is part of the item currently being
 * completed.  Used to decide whether to abandon complete mode when the menu
 if (compl_first_match != NULL && !adup)
 {
 	match = compl_first_match;
 	do
 	{
-	    if (!ins_compl_at_original_text(match)
+	    if (!match_at_original_text(match)
 		    && STRNCMP(match->cp_str, str, len) == 0
 		    && match->cp_str[len] == NUL)
 		return NOTDONE;
 	    match = match->cp_next;
-	} while (match != NULL && match != compl_first_match);
+	} while (match != NULL && !is_first_match(match));
 }
 // Remove any popup menu before changing the list of matches.
 ins_compl_del_pum();
 	if (compl_leader == NULL)
 	    return;
 	had_match = (curwin->w_cursor.col > compl_col);
 	ins_compl_delete();
-	ins_bytes(compl_leader + ins_compl_len());
+	ins_bytes(compl_leader + get_compl_len());
 	ins_redraw(FALSE);
 	// When the match isn't there (to avoid matching itself) remove it
 	// again after redrawing.
 	if (!had_match)
 {
 	// Leader was shortened, need to change the inserted text.
 	*p = NUL;
 	had_match = (curwin->w_cursor.col > compl_col);
 	ins_compl_delete();
-	ins_bytes(compl_leader + ins_compl_len());
+	ins_bytes(compl_leader + get_compl_len());
 	ins_redraw(FALSE);
 	// When the match isn't there (to avoid matching itself) remove it
 	// again after redrawing.
 	if (!had_match)
 	return 0;
 // Find the end of the list.
 match = compl_first_match;
 // there's always an entry for the compl_orig_text, it doesn't count.
-while (match->cp_next != NULL && match->cp_next != compl_first_match)
+while (match->cp_next != NULL && !is_first_match(match->cp_next))
 {
 	match = match->cp_next;
 	++count;
 }
 match->cp_next = compl_first_match;
 // one (ignoring the original text).
 compl = compl_first_match;
 i = 0;
 do
 {
-	if (compl == NULL
+	if (compl == NULL || (!match_at_original_text(compl) && ++i == 2))
-		      || (!ins_compl_at_original_text(compl) && ++i == 2))
 	    break;
 	compl = compl->cp_next;
-} while (compl != compl_first_match);
+} while (!is_first_match(compl));
 if (strstr((char *)p_cot, "menuone") != NULL)
 	return (i >= 1);
 return (i >= 2);
 }
 if (compl_leader != NULL)
 	lead_len = (int)STRLEN(compl_leader);
 do
 {
-	if (!ins_compl_at_original_text(compl)
+	if (!match_at_original_text(compl)
 		&& (compl_leader == NULL
 		    || ins_compl_equal(compl, compl_leader, lead_len)))
 	    ++compl_match_arraysize;
 	compl = compl->cp_next;
-} while (compl != NULL && compl != compl_first_match);
+} while (compl != NULL && !is_first_match(compl));
 if (compl_match_arraysize == 0)
 	return -1;
 compl_match_array = ALLOC_CLEAR_MULT(pumitem_T, compl_match_arraysize);
 if (compl_match_array == NULL)
 	return -1;
 // If the current match is the original text don't find the first
 // match after it, don't highlight anything.
-if (ins_compl_at_original_text(compl_shown_match))
+if (match_at_original_text(compl_shown_match))
 	shown_match_ok = TRUE;
 i = 0;
 compl = compl_first_match;
 do
 {
-	if (!ins_compl_at_original_text(compl)
+	if (!match_at_original_text(compl)
 		&& (compl_leader == NULL
 		    || ins_compl_equal(compl, compl_leader, lead_len)))
 	{
 	    if (!shown_match_ok)
 	    {
 	{
 	    did_find_shown_match = TRUE;
 	    // When the original text is the shown match don't set
 	    // compl_shown_match.
-	    if (ins_compl_at_original_text(compl))
+	    if (match_at_original_text(compl))
 		shown_match_ok = TRUE;
 	    if (!shown_match_ok && shown_compl != NULL)
 	    {
 		// The shown match isn't displayed, set it to the
 		compl_shown_match = shown_compl;
 		shown_match_ok = TRUE;
 	    }
 	}
 	compl = compl->cp_next;
-} while (compl != NULL && compl != compl_first_match);
+} while (compl != NULL && !is_first_match(compl));
 if (!shown_match_ok)    // no displayed match at all
 	cur = -1;
 return cur;
 	    vim_free(match->cp_text[i]);
 #ifdef FEAT_EVAL
 	clear_tv(&match->cp_user_data);
 #endif
 	vim_free(match);
-} while (compl_curr_match != NULL && compl_curr_match != compl_first_match);
+} while (compl_curr_match != NULL && !is_first_match(compl_curr_match));
 compl_first_match = compl_curr_match = NULL;
 compl_shown_match = NULL;
 compl_old_match = NULL;
 }
+/*
+* Reset/clear the completion state.
+*/
 void
 ins_compl_clear(void)
 {
 compl_cont_status = 0;
 compl_started = FALSE;
 {
 return compl_col;
 }
 /*
+* Return the length in bytes of the text being completed
+*/
+int
+ins_compl_len(void)
+{
+return compl_length;
+}
+/*
 * Delete one character before the cursor and show the subset of the matches
 * that match the word that is now before the cursor.
 * Returns the character to be used, NUL if the work is done and another char
 * to be got from the user.
 */
 // Stop completion when the whole word was deleted.  For Omni completion
 // allow the word to be deleted, we won't match everything.
 // Respect the 'backspace' option.
 if ((int)(p - line) - (int)compl_col < 0
-	    || ((int)(p - line) - (int)compl_col == 0
+	    || ((int)(p - line) - (int)compl_col == 0 && !ctrl_x_mode_omni())
-						 && ctrl_x_mode != CTRL_X_OMNI)
+	    || ctrl_x_mode_eval()
-	    || ctrl_x_mode == CTRL_X_EVAL
 	    || (!can_bs(BS_START) && (int)(p - line) - (int)compl_col
 							- compl_length < 0))
 	return K_BS;
 // Deleted more than what was used to find matches or didn't finish
 ins_compl_need_restart(void)
 {
 // Return TRUE if we didn't complete finding matches or when the
 // 'completefunc' returned "always" in the "refresh" dictionary item.
 return compl_was_interrupted
-	|| ((ctrl_x_mode == CTRL_X_FUNCTION || ctrl_x_mode == CTRL_X_OMNI)
+	|| ((ctrl_x_mode_function() || ctrl_x_mode_omni())
 						  && compl_opt_refresh_always);
 }
 /*
 * Called after changing "compl_leader".
 static void
 ins_compl_new_leader(void)
 {
 ins_compl_del_pum();
 ins_compl_delete();
-ins_bytes(compl_leader + ins_compl_len());
+ins_bytes(compl_leader + get_compl_len());
 compl_used_match = FALSE;
 if (compl_started)
 	ins_compl_set_original_text(compl_leader);
 else
 /*
 * Return the length of the completion, from the completion start column to
 * the cursor column.  Making sure it never goes below zero.
 */
 static int
-ins_compl_len(void)
+get_compl_len(void)
 {
 int off = (int)curwin->w_cursor.col - (int)compl_col;
 if (off < 0)
 	return 0;
 char_u	*p;
 // Replace the original text entry.
 // The CP_ORIGINAL_TEXT flag is either at the first item or might possibly
 // be at the last item for backward completion
-if (ins_compl_at_original_text(compl_first_match))	// safety check
+if (match_at_original_text(compl_first_match))	// safety check
 {
 	p = vim_strsave(str);
 	if (p != NULL)
 	{
 	    vim_free(compl_first_match->cp_str);
 	    compl_first_match->cp_str = p;
 	}
 }
 else if (compl_first_match->cp_prev != NULL
-	    && ins_compl_at_original_text(compl_first_match->cp_prev))
+	    && match_at_original_text(compl_first_match->cp_prev))
 {
 p = vim_strsave(str);
 if (p != NULL)
 {
 vim_free(compl_first_match->cp_prev->cp_str);
 p = compl_shown_match->cp_str;
 if ((int)STRLEN(p) <= len)   // the match is too short
 {
 	// When still at the original match use the first entry that matches
 	// the leader.
-	if (!ins_compl_at_original_text(compl_shown_match))
+	if (!match_at_original_text(compl_shown_match))
 	    return;
 	p = NULL;
 	for (cp = compl_shown_match->cp_next; cp != NULL
-		&& cp != compl_first_match; cp = cp->cp_next)
+		&& !is_first_match(cp); cp = cp->cp_next)
 	{
 	    if (compl_leader == NULL
 		    || ins_compl_equal(cp, compl_leader,
 			(int)STRLEN(compl_leader)))
 	    {
 c = PTR2CHAR(p);
 ins_compl_addleader(c);
 }
 /*
-* Set the CTRL-X completion mode based on the key 'c' typed after a CTRL-X.
+* Set the CTRL-X completion mode based on the key "c" typed after a CTRL-X.
 * Uses the global variables: ctrl_x_mode, edit_submode, edit_submode_pre,
 * compl_cont_mode and compl_cont_status.
 * Returns TRUE when the character is not to be inserted.
 */
 static int
 // but only do this, if the Popup is still visible
 if (c == Ctrl_E)
 {
 	ins_compl_delete();
 	if (compl_leader != NULL)
-	    ins_bytes(compl_leader + ins_compl_len());
+	    ins_bytes(compl_leader + get_compl_len());
 	else if (compl_first_match != NULL)
-	    ins_bytes(compl_orig_text + ins_compl_len());
+	    ins_bytes(compl_orig_text + get_compl_len());
 	retval = TRUE;
 }
 auto_format(FALSE, TRUE);
 	    ctrl_x_mode = CTRL_X_NOT_DEFINED_YET;
 	}
 }
 // Set "compl_get_longest" when finding the first matches.
-if (ctrl_x_mode == CTRL_X_NOT_DEFINED_YET
+if (ctrl_x_mode_not_defined_yet()
-			   || (ctrl_x_mode == CTRL_X_NORMAL && !compl_started))
+			   || (ctrl_x_mode_normal() && !compl_started))
 {
 	compl_get_longest = (strstr((char *)p_cot, "longest") != NULL);
 	compl_used_match = TRUE;
 }
-if (ctrl_x_mode == CTRL_X_NOT_DEFINED_YET)
+if (ctrl_x_mode_not_defined_yet())
 	// We have just typed CTRL-X and aren't quite sure which CTRL-X mode
 	// it will be yet.  Now we decide.
 	retval = set_ctrl_x_mode(c);
-else if (ctrl_x_mode != CTRL_X_NORMAL)
+else if (ctrl_x_mode_not_default())
 {
 	// We're already in CTRL-X mode, do we stay in it?
 	if (!vim_is_ctrl_x_key(c))
 	{
-	    if (ctrl_x_mode == CTRL_X_SCROLL)
+	    if (ctrl_x_mode_scroll())
 		ctrl_x_mode = CTRL_X_NORMAL;
 	    else
 		ctrl_x_mode = CTRL_X_FINISHED;
 	    edit_submode = NULL;
 	}
 {
 	// Show error message from attempted keyword completion (probably
 	// 'Pattern not found') until another key is hit, then go back to
 	// showing what mode we are in.
 	showmode();
-	if ((ctrl_x_mode == CTRL_X_NORMAL && c != Ctrl_N && c != Ctrl_P
+	if ((ctrl_x_mode_normal() && c != Ctrl_N && c != Ctrl_P
 				       && c != Ctrl_R && !ins_compl_pum_key(c))
 		|| ctrl_x_mode == CTRL_X_FINISHED)
 	    retval = ins_compl_stop(c, prev_mode, retval);
 }
 else if (ctrl_x_mode == CTRL_X_LOCAL_MSG)
 return retval;
 }
 /*
 * Copy the global 'completefunc' callback function to the buffer-local
-* 'completefunc' callback for 'buf'.
+* 'completefunc' callback for "buf".
 */
 void
 set_buflocal_cfu_callback(buf_T *buf UNUSED)
 {
 # ifdef FEAT_EVAL
 return retval;
 }
 /*
 * Copy the global 'omnifunc' callback function to the buffer-local 'omnifunc'
-* callback for 'buf'.
+* callback for "buf".
 */
 void
 set_buflocal_ofu_callback(buf_T *buf UNUSED)
 {
 # ifdef FEAT_EVAL
 return retval;
 }
 /*
 * Mark the global 'completefunc' 'omnifunc' and 'thesaurusfunc' callbacks with
-* 'copyID' so that they are not garbage collected.
+* "copyID" so that they are not garbage collected.
 */
 int
 set_ref_in_insexpand_funcs(int copyID)
 {
 int abort = FALSE;
 return abort;
 }
 /*
-* Get the user-defined completion function name for completion 'type'
+* Get the user-defined completion function name for completion "type"
 */
 static char_u *
 get_complete_funcname(int type)
 {
 switch (type)
 }
 /*
 * Get the callback to use for insert mode completion.
 */
-callback_T *
+static callback_T *
 get_insert_callback(int type)
 {
 if (type == CTRL_X_FUNCTION)
 	return &curbuf->b_cfu_cb;
 if (type == CTRL_X_OMNI)
 int save_w_wrow = curwin->w_wrow;
 int save_w_leftcol = curwin->w_leftcol;
 int flags = CP_ORIGINAL_TEXT;
 // If already doing completions stop it.
-if (ctrl_x_mode != CTRL_X_NORMAL)
+if (ctrl_x_mode_not_default())
 	ins_compl_prep(' ');
 ins_compl_clear();
 ins_compl_free();
 compl_direction = FORWARD;
 * Return Insert completion mode name string
 */
 static char_u *
 ins_compl_mode(void)
 {
-if (ctrl_x_mode == CTRL_X_NOT_DEFINED_YET || ctrl_x_mode == CTRL_X_SCROLL
+if (ctrl_x_mode_not_defined_yet() || ctrl_x_mode_scroll() || compl_started)
-	    || compl_started)
 	return (char_u *)ctrl_x_mode_names[ctrl_x_mode & ~CTRL_X_WANT_IDENT];
 return (char_u *)"";
 }
 ins_compl_update_sequence_numbers()
 {
 int		number = 0;
 compl_T	*match;
-if (compl_direction == FORWARD)
+if (compl_dir_forward())
 {
 	// search backwards for the first valid (!= -1) number.
 	// This should normally succeed already at the first loop
 	// cycle, so it's fast!
 	for (match = compl_curr_match->cp_prev; match != NULL
-		&& match != compl_first_match;
+		&& !is_first_match(match); match = match->cp_prev)
-					   match = match->cp_prev)
 	    if (match->cp_number != -1)
 	    {
 		number = match->cp_number;
 		break;
 	    }
 {
 	// search forwards (upwards) for the first valid (!= -1)
 	// number.  This should normally succeed already at the
 	// first loop cycle, so it's fast!
 	for (match = compl_curr_match->cp_next; match != NULL
-		&& match != compl_first_match;
+		&& !is_first_match(match); match = match->cp_next)
-					   match = match->cp_next)
 	    if (match->cp_number != -1)
 	    {
 		number = match->cp_number;
 		break;
 	    }
 	if (ret == OK && compl_first_match != NULL)
 	{
 	    match = compl_first_match;
 	    do
 	    {
-		if (!ins_compl_at_original_text(match))
+		if (!match_at_original_text(match))
 		{
 		    di = dict_alloc();
 		    if (di == NULL)
 			return;
 		    ret = list_append_dict(li, di);
 		    else
 			dict_add_tv(di, "user_data", &match->cp_user_data);
 		}
 		match = match->cp_next;
 	    }
-	    while (match != NULL && match != compl_first_match);
+	    while (match != NULL && !is_first_match(match));
 	}
 }
 if (ret == OK && (what_flag & CI_WHAT_SELECTED))
 {
 {
 	st->ins_buf = curbuf;
 	st->first_match_pos = *start_match_pos;
 	// Move the cursor back one character so that ^N can match the
 	// word immediately after the cursor.
-	if (ctrl_x_mode == CTRL_X_NORMAL && dec(&st->first_match_pos) < 0)
+	if (ctrl_x_mode_normal() && dec(&st->first_match_pos) < 0)
 	{
 	    // Move the cursor to after the last character in the
 	    // buffer, so that word at start of buffer is found
 	    // correctly.
 	    st->first_match_pos.lnum = st->ins_buf->b_ml.ml_line_count;
 // Find up to TAG_MANY matches.  Avoids that an enormous number
 // of matches is found when compl_pattern is empty
 g_tag_at_cursor = TRUE;
 if (find_tags(compl_pattern, &num_matches, &matches,
 		TAG_REGEXP | TAG_NAMES | TAG_NOIC | TAG_INS_COMP
-		| (ctrl_x_mode != CTRL_X_NORMAL ? TAG_VERBOSE : 0),
+		| (ctrl_x_mode_not_default() ? TAG_VERBOSE : 0),
 		TAG_MANY, curbuf->b_ffname) == OK && num_matches > 0)
 	ins_compl_add_matches(num_matches, matches, p_ic);
 g_tag_at_cursor = FALSE;
 p_ic = save_p_ic;
 }
 *match_len = 0;
 ptr = ml_get_buf(ins_buf, cur_match_pos->lnum, FALSE) +
 	cur_match_pos->col;
 if (ctrl_x_mode_line_or_eval())
 {
-	if (compl_cont_status & CONT_ADDING)
+	if (compl_status_adding())
 	{
 	    if (cur_match_pos->lnum >= ins_buf->b_ml.ml_line_count)
 		return NULL;
 	    ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, FALSE);
 	    if (!p_paste)
 }
 else
 {
 	char_u	*tmp_ptr = ptr;
-	if (compl_cont_status & CONT_ADDING)
+	if (compl_status_adding())
 	{
 	    tmp_ptr += compl_length;
 	    // Skip if already inside a word.
 	    if (vim_iswordp(tmp_ptr))
 		return NULL;
 	}
 	// Find end of this word.
 	tmp_ptr = find_word_end(tmp_ptr);
 	len = (int)(tmp_ptr - ptr);
-	if ((compl_cont_status & CONT_ADDING) && len == compl_length)
+	if (compl_status_adding() && len == compl_length)
 	{
 	    if (cur_match_pos->lnum < ins_buf->b_ml.ml_line_count)
 	    {
 		// Try next line, if any. the new word will be
 		// "join" as if the normal command "J" was used.
 	++msg_silent;  // Don't want messages for wrapscan.
 	// ctrl_x_mode_line_or_eval() || word-wise search that
 	// has added a word that was at the beginning of the line
-	if (ctrl_x_mode_line_or_eval()
+	if (ctrl_x_mode_line_or_eval() || (compl_cont_status & CONT_SOL))
-		|| (compl_cont_status & CONT_SOL))
 	    found_new_match = search_for_exact_line(st->ins_buf,
 			    st->cur_match_pos, compl_direction, compl_pattern);
 	else
 	    found_new_match = searchit(NULL, st->ins_buf, st->cur_match_pos,
 				NULL, compl_direction, compl_pattern, 1L,
 	else if (st->first_match_pos.lnum == st->last_match_pos.lnum
 		&& st->first_match_pos.col == st->last_match_pos.col)
 	{
 	    found_new_match = FAIL;
 	}
-	else if ((compl_direction == FORWARD)
+	else if (compl_dir_forward()
 		&& (st->prev_match_pos.lnum > st->cur_match_pos->lnum
 		    || (st->prev_match_pos.lnum == st->cur_match_pos->lnum
 			&& st->prev_match_pos.col >= st->cur_match_pos->col)))
 	{
 	    if (looped_around)
 		found_new_match = FAIL;
 	    else
 		looped_around = TRUE;
 	}
-	else if ((compl_direction != FORWARD)
+	else if (!compl_dir_forward()
 		&& (st->prev_match_pos.lnum < st->cur_match_pos->lnum
 		    || (st->prev_match_pos.lnum == st->cur_match_pos->lnum
 			&& st->prev_match_pos.col <= st->cur_match_pos->col)))
 	{
 	    if (looped_around)
 	st->prev_match_pos = *st->cur_match_pos;
 	if (found_new_match == FAIL)
 	    break;
 	// when ADDING, the text before the cursor matches, skip it
-	if ((compl_cont_status & CONT_ADDING) && st->ins_buf == curbuf
+	if (compl_status_adding() && st->ins_buf == curbuf
 		&& start_pos->lnum == st->cur_match_pos->lnum
 		&& start_pos->col  == st->cur_match_pos->col)
 	    continue;
 	ptr = ins_comp_get_next_word_or_line(st->ins_buf, st->cur_match_pos,
 return found_new_match;
 }
 /*
-* get the next set of completion matches for 'type'.
+* get the next set of completion matches for "type".
 * Returns TRUE if a new match is found. Otherwise returns FALSE.
 */
 static int
 get_next_completion_match(int type, ins_compl_next_state_T *st, pos_T *ini)
 {
 }
 else if (st.ins_buf != curbuf && !buf_valid(st.ins_buf))
 	st.ins_buf = curbuf;  // In case the buffer was wiped out.
 compl_old_match = compl_curr_match;	// remember the last current match
-st.cur_match_pos = (compl_direction == FORWARD)
+st.cur_match_pos = (compl_dir_forward())
 				? &st.last_match_pos : &st.first_match_pos;
 // For ^N/^P loop over all the flags/windows/buffers in 'complete'.
 for (;;)
 {
 	st.set_match_pos = FALSE;
 	// For ^N/^P pick a new entry from e_cpt if compl_started is off,
 	// or if found_all says this entry is done.  For ^X^L only use the
 	// entries from 'complete' that look in loaded buffers.
-	if ((ctrl_x_mode == CTRL_X_NORMAL
+	if ((ctrl_x_mode_normal() || ctrl_x_mode_line_or_eval())
-		    || ctrl_x_mode_line_or_eval())
 					&& (!compl_started || st.found_all))
 	{
 	    int status = process_next_cpt_value(&st, &type, ini);
 	    if (status == INS_COMPL_CPT_END)
 	found_new_match = get_next_completion_match(type, &st, ini);
 	// break the loop for specialized modes (use 'complete' just for the
 	// generic ctrl_x_mode == CTRL_X_NORMAL) or when we've found a new
 	// match
-	if ((ctrl_x_mode != CTRL_X_NORMAL
+	if ((ctrl_x_mode_not_default() && !ctrl_x_mode_line_or_eval())
-		    && !ctrl_x_mode_line_or_eval()) || found_new_match != FAIL)
+						|| found_new_match != FAIL)
 	{
 	    if (got_int)
 		break;
 	    // Fill the popup menu as soon as possible.
 	    if (type != -1)
 		ins_compl_check_keys(0, FALSE);
-	    if ((ctrl_x_mode != CTRL_X_NORMAL
+	    if ((ctrl_x_mode_not_default()
 			&& !ctrl_x_mode_line_or_eval()) || compl_interrupted)
 		break;
 	    compl_started = TRUE;
 	}
 	else
 	    compl_started = FALSE;
 	}
 }
 compl_started = TRUE;
-if ((ctrl_x_mode == CTRL_X_NORMAL || ctrl_x_mode_line_or_eval())
+if ((ctrl_x_mode_normal() || ctrl_x_mode_line_or_eval())
 	    && *st.e_cpt == NUL)		// Got to end of 'complete'
 	found_new_match = FAIL;
 i = -1;		// total of matches, unknown
-if (found_new_match == FAIL || (ctrl_x_mode != CTRL_X_NORMAL
+if (found_new_match == FAIL || (ctrl_x_mode_not_default()
 					       && !ctrl_x_mode_line_or_eval()))
 	i = ins_compl_make_cyclic();
 if (compl_old_match != NULL)
 {
 	// If several matches were added (FORWARD) or the search failed and has
 	// just been made cyclic then we have to move compl_curr_match to the
 	// next or previous entry (if any) -- Acevedo
-	compl_curr_match = compl_direction == FORWARD ? compl_old_match->cp_next
+	compl_curr_match = compl_dir_forward() ? compl_old_match->cp_next
 						    : compl_old_match->cp_prev;
 	if (compl_curr_match == NULL)
 	    compl_curr_match = compl_old_match;
 }
 trigger_modechanged();
 ins_compl_update_shown_match(void)
 {
 while (!ins_compl_equal(compl_shown_match,
 		compl_leader, (int)STRLEN(compl_leader))
 	    && compl_shown_match->cp_next != NULL
-	    && compl_shown_match->cp_next != compl_first_match)
+	    && !is_first_match(compl_shown_match->cp_next))
 	compl_shown_match = compl_shown_match->cp_next;
 // If we didn't find it searching forward, and compl_shows_dir is
 // backward, find the last match.
-if (compl_shows_dir == BACKWARD
+if (compl_shows_dir_backward()
 	    && !ins_compl_equal(compl_shown_match,
 		compl_leader, (int)STRLEN(compl_leader))
 	    && (compl_shown_match->cp_next == NULL
-		|| compl_shown_match->cp_next == compl_first_match))
+		|| is_first_match(compl_shown_match->cp_next)))
 {
 	while (!ins_compl_equal(compl_shown_match,
 		    compl_leader, (int)STRLEN(compl_leader))
 		&& compl_shown_match->cp_prev != NULL
-		&& compl_shown_match->cp_prev != compl_first_match)
+		&& !is_first_match(compl_shown_match->cp_prev))
 	    compl_shown_match = compl_shown_match->cp_prev;
 }
 }
 /*
 {
 int	    col;
 // In insert mode: Delete the typed part.
 // In replace mode: Put the old characters back, if any.
-col = compl_col + (compl_cont_status & CONT_ADDING ? compl_length : 0);
+col = compl_col + (compl_status_adding() ? compl_length : 0);
 if ((int)curwin->w_cursor.col > col)
 {
 	if (stop_arrow() == FAIL)
 	    return;
 	backspace_until_column(col);
 * "in_compl_func" is TRUE when called from complete_check().
 */
 void
 ins_compl_insert(int in_compl_func)
 {
-int compl_len = ins_compl_len();
+int compl_len = get_compl_len();
 // Make sure we don't go over the end of the string, this can happen with
 // illegal bytes.
 if (compl_len < (int)STRLEN(compl_shown_match->cp_str))
 	ins_bytes(compl_shown_match->cp_str + compl_len);
-if (ins_compl_at_original_text(compl_shown_match))
+if (match_at_original_text(compl_shown_match))
 	compl_used_match = FALSE;
 else
 	compl_used_match = TRUE;
 #ifdef FEAT_EVAL
 {
 msg_hist_off = FALSE;
 redraw_cmdline = FALSE;	    // don't overwrite!
 }
 /*
-* Find the next set of matches for completion. Repeat the completion 'todo'
+* Find the next set of matches for completion. Repeat the completion "todo"
 * times.  The number of matches found is returned in 'num_matches'.
 *
 * If "allow_get_expansion" is TRUE, then ins_compl_get_exp() may be called to
 * get more completions. If it is FALSE, then do nothing when there are no more
 * completions in the given direction.
 int	    found_end = FALSE;
 compl_T *found_compl = NULL;
 while (--todo >= 0)
 {
-	if (compl_shows_dir == FORWARD && compl_shown_match->cp_next != NULL)
+	if (compl_shows_dir_forward() && compl_shown_match->cp_next != NULL)
 	{
 	    compl_shown_match = compl_shown_match->cp_next;
 	    found_end = (compl_first_match != NULL
-		    && (compl_shown_match->cp_next == compl_first_match
+		    && (is_first_match(compl_shown_match->cp_next)
-			|| compl_shown_match == compl_first_match));
+			|| is_first_match(compl_shown_match)));
 	}
-	else if (compl_shows_dir == BACKWARD
+	else if (compl_shows_dir_backward()
 		&& compl_shown_match->cp_prev != NULL)
 	{
-	    found_end = (compl_shown_match == compl_first_match);
+	    found_end = is_first_match(compl_shown_match);
 	    compl_shown_match = compl_shown_match->cp_prev;
-	    found_end |= (compl_shown_match == compl_first_match);
+	    found_end |= is_first_match(compl_shown_match);
 	}
 	else
 	{
 	    if (!allow_get_expansion)
 	    {
 		if (advance)
 		{
-		    if (compl_shows_dir == BACKWARD)
+		    if (compl_shows_dir_backward())
 			compl_pending -= todo + 1;
 		    else
 			compl_pending += todo + 1;
 		}
 		return -1;
 	    }
 	    if (!compl_no_select && advance)
 	    {
-		if (compl_shows_dir == BACKWARD)
+		if (compl_shows_dir_backward())
 		    --compl_pending;
 		else
 		    ++compl_pending;
 	    }
 		else
 		    break;
 	    }
 	    found_end = FALSE;
 	}
-	if (!ins_compl_at_original_text(compl_shown_match)
+	if (!match_at_original_text(compl_shown_match)
 		&& compl_leader != NULL
 		&& !ins_compl_equal(compl_shown_match,
 		    compl_leader, (int)STRLEN(compl_leader)))
 	    ++todo;
 	else
 // When user complete function return -1 for findstart which is next
 // time of 'always', compl_shown_match become NULL.
 if (compl_shown_match == NULL)
 	return -1;
-if (compl_leader != NULL
+if (compl_leader != NULL && !match_at_original_text(compl_shown_match))
-		      && !ins_compl_at_original_text(compl_shown_match))
 	// Update "compl_shown_match" to the actually shown match
 	ins_compl_update_shown_match();
 if (allow_get_expansion && insert_match
 	    && (!(compl_get_longest || compl_restarting) || compl_used_match))
 	return -1;
 // Insert the text of the new completion, or the compl_leader.
 if (compl_no_insert && !started)
 {
-	ins_bytes(compl_orig_text + ins_compl_len());
+	ins_bytes(compl_orig_text + get_compl_len());
 	compl_used_match = FALSE;
 }
 else if (insert_match)
 {
 	if (!compl_get_longest || compl_used_match)
 	    ins_compl_insert(in_compl_func);
 	else
-	    ins_bytes(compl_leader + ins_compl_len());
+	    ins_bytes(compl_leader + get_compl_len());
 }
 else
 	compl_used_match = FALSE;
 if (!allow_get_expansion)
 * Uses the global variables: compl_cont_status and ctrl_x_mode
 */
 static int
 get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
 {
-if ((compl_cont_status & CONT_SOL) || ctrl_x_mode == CTRL_X_PATH_DEFINES)
+if ((compl_cont_status & CONT_SOL) || ctrl_x_mode_path_defines())
 {
-	if (!(compl_cont_status & CONT_ADDING))
+	if (!compl_status_adding())
 	{
 	    while (--startcol >= 0 && vim_isIDc(line[startcol]))
 		;
 	    compl_col += ++startcol;
 	    compl_length = curs_col - startcol;
 	else
 	    compl_pattern = vim_strnsave(line + compl_col, compl_length);
 	if (compl_pattern == NULL)
 	    return FAIL;
 }
-else if (compl_cont_status & CONT_ADDING)
+else if (compl_status_adding())
 {
 	char_u	    *prefix = (char_u *)"\\<";
 	// we need up to 2 extra chars for the prefix
 	compl_pattern = alloc(quote_meta(NULL, line + compl_col,
 // Call 'completefunc' or 'omnifunc' or 'thesaurusfunc' and get pattern
 // length as a string
 funcname = get_complete_funcname(ctrl_x_mode);
 if (*funcname == NUL)
 {
-	semsg(_(e_option_str_is_not_set), ctrl_x_mode == CTRL_X_FUNCTION
+	semsg(_(e_option_str_is_not_set), ctrl_x_mode_function()
 		? "completefunc" : "omnifunc");
 	return FAIL;
 }
 args[0].v_type = VAR_NUMBER;
 return ret;
 }
 /*
 * Get the completion pattern, column and length.
+* "startcol" - start column number of the completion pattern/text
+* "cur_col" - current cursor column
+* On return, "line_invalid" is set to TRUE, if the current line may have
+* become invalid and needs to be fetched again.
+* Returns OK on success.
 */
 static int
 compl_get_info(char_u *line, int startcol, colnr_T curs_col, int *line_invalid)
 {
-if (ctrl_x_mode == CTRL_X_NORMAL
+if (ctrl_x_mode_normal()
 	    || (ctrl_x_mode & CTRL_X_WANT_IDENT
 		&& !thesaurus_func_complete(ctrl_x_mode)))
 {
 	return get_normal_compl_info(line, startcol, curs_col);
 }
 else if (ctrl_x_mode_line_or_eval())
 {
 	return get_wholeline_compl_info(line, curs_col);
 }
-else if (ctrl_x_mode == CTRL_X_FILES)
+else if (ctrl_x_mode_files())
 {
 	return get_filename_compl_info(line, startcol, curs_col);
 }
 else if (ctrl_x_mode == CTRL_X_CMDLINE)
 {
 	return get_cmdline_compl_info(line, curs_col);
 }
-else if (ctrl_x_mode == CTRL_X_FUNCTION || ctrl_x_mode == CTRL_X_OMNI
+else if (ctrl_x_mode_function() || ctrl_x_mode_omni()
 	    || thesaurus_func_complete(ctrl_x_mode))
 {
 	if (get_userdefined_compl_info(curs_col) == FAIL)
 	    return FAIL;
-	*line_invalid = TRUE;	// 'line' may have become invalid
+	*line_invalid = TRUE;	// "line" may have become invalid
 }
-else if (ctrl_x_mode == CTRL_X_SPELL)
+else if (ctrl_x_mode_spell())
 {
 	if (get_spell_compl_info(startcol, curs_col) == FAIL)
 	    return FAIL;
-	*line_invalid = TRUE;	// 'line' may have become invalid
+	*line_invalid = TRUE;	// "line" may have become invalid
 }
 else
 {
 	internal_error("ins_complete()");
 	return FAIL;
 static void
 ins_compl_continue_search(char_u *line)
 {
 // it is a continued search
 compl_cont_status &= ~CONT_INTRPT;	// remove INTRPT
-if (ctrl_x_mode == CTRL_X_NORMAL
+if (ctrl_x_mode_normal() || ctrl_x_mode_path_patterns()
-	    || ctrl_x_mode == CTRL_X_PATH_PATTERNS
+						|| ctrl_x_mode_path_defines())
-	    || ctrl_x_mode == CTRL_X_PATH_DEFINES)
 {
 	if (compl_startpos.lnum != curwin->w_cursor.lnum)
 	{
 	    // line (probably) wrapped, set compl_startpos to the
 	    // first non_blank in the line, if it is not a wordchar
 	// completion.
 	ins_compl_continue_search(line);
 else
 	compl_cont_status &= CONT_LOCAL;
-if (!(compl_cont_status & CONT_ADDING))	// normal expansion
+if (!compl_status_adding())	// normal expansion
 {
 	compl_cont_mode = ctrl_x_mode;
-	if (ctrl_x_mode != CTRL_X_NORMAL)
+	if (ctrl_x_mode_not_default())
 	    // Remove LOCAL if ctrl_x_mode != CTRL_X_NORMAL
 	    compl_cont_status = 0;
 	compl_cont_status |= CONT_N_ADDS;
 	compl_startpos = curwin->w_cursor;
 	startcol = (int)curs_col;
 }
 // Work out completion pattern and original text -- webb
 if (compl_get_info(line, startcol, curs_col, &line_invalid) == FAIL)
 {
-	if (ctrl_x_mode == CTRL_X_FUNCTION || ctrl_x_mode == CTRL_X_OMNI
+	if (ctrl_x_mode_function() || ctrl_x_mode_omni()
-		|| thesaurus_func_complete(ctrl_x_mode))
+				|| thesaurus_func_complete(ctrl_x_mode))
 	    // restore did_ai, so that adding comment leader works
 	    did_ai = save_did_ai;
 	return FAIL;
 }
 // If "line" was changed while getting completion info get it again.
 if (line_invalid)
 	line = ml_get(curwin->w_cursor.lnum);
-if (compl_cont_status & CONT_ADDING)
+if (compl_status_adding())
 {
 	edit_submode_pre = (char_u *)_(" Adding");
 	if (ctrl_x_mode_line_or_eval())
 	{
 	    // Insert a new line, keep indentation but ignore 'comments'.
 */
 static void
 ins_compl_show_statusmsg(void)
 {
 // we found no match if the list has only the "compl_orig_text"-entry
-if (compl_first_match == compl_first_match->cp_next)
+if (is_first_match(compl_first_match->cp_next))
 {
-	edit_submode_extra = (compl_cont_status & CONT_ADDING)
+	edit_submode_extra = compl_status_adding() && compl_length > 1
-			&& compl_length > 1
 				? (char_u *)_(e_hitend)
 				: (char_u *)_(e_pattern_not_found);
 	edit_submode_highl = HLF_E;
 }
 if (edit_submode_extra == NULL)
 {
-	if (ins_compl_at_original_text(compl_curr_match))
+	if (match_at_original_text(compl_curr_match))
 	{
 	    edit_submode_extra = (char_u *)_("Back at original");
 	    edit_submode_highl = HLF_W;
 	}
 	else if (compl_cont_status & CONT_S_IPOS)
 	(void)vgetc();
 	got_int = FALSE;
 }
 // we found no match if the list has only the "compl_orig_text"-entry
-if (compl_first_match == compl_first_match->cp_next)
+if (is_first_match(compl_first_match->cp_next))
 {
 	// remove N_ADDS flag, so next ^X<> won't try to go to ADDING mode,
 	// because we couldn't expand anything at first place, but if we used
 	// ^P, ^N, ^X^I or ^X^D we might want to add-expand a single-char-word
 	// (such as M in M'exico) if not tried already.  -- Acevedo
 	if (compl_length > 1
-		|| (compl_cont_status & CONT_ADDING)
+		|| compl_status_adding()
-		|| (ctrl_x_mode != CTRL_X_NORMAL
+		|| (ctrl_x_mode_not_default()
-		    && ctrl_x_mode != CTRL_X_PATH_PATTERNS
+		    && !ctrl_x_mode_path_patterns()
-		    && ctrl_x_mode != CTRL_X_PATH_DEFINES))
+		    && !ctrl_x_mode_path_defines()))
 	    compl_cont_status &= ~CONT_N_ADDS;
 }
 if (compl_curr_match->cp_flags & CP_CONT_S_IPOS)
 	compl_cont_status |= CONT_S_IPOS;
 	switch (*src)
 	{
 	    case '.':
 	    case '*':
 	    case '[':
-		if (ctrl_x_mode == CTRL_X_DICTIONARY
+		if (ctrl_x_mode_dictionary() || ctrl_x_mode_thesaurus())
-					   || ctrl_x_mode == CTRL_X_THESAURUS)
 		    break;
 		// FALLTHROUGH
 	    case '~':
 		if (!magic_isset())	// quote these only if magic is set
 		    break;
 		// FALLTHROUGH
 	    case '\\':
-		if (ctrl_x_mode == CTRL_X_DICTIONARY
+		if (ctrl_x_mode_dictionary() || ctrl_x_mode_thesaurus())
-					   || ctrl_x_mode == CTRL_X_THESAURUS)
 		    break;
 		// FALLTHROUGH
 	    case '^':		// currently it's not needed.
 	    case '$':
 		m++;

Mercurial > vim

comparison src/insexpand.c @ 26944:8dbdd68627bd v8.2.4001