vim: src/insexpand.c comparison

comparison src/insexpand.c @ 16239:5df26b29e809 v8.1.1124

patch 8.1.1124: insert completion flags are mixed up commit https://github.com/vim/vim/commit/d9eefe3155277cec71105f52d34a76f7a3237e7f Author: Bram Moolenaar <Bram@vim.org> Date: Sat Apr 6 14:22:21 2019 +0200 patch 8.1.1124: insert completion flags are mixed up Problem: Insert completion flags are mixed up. Solution: Clean up flags use of ins_compl_add() and cp_flags.

author	Bram Moolenaar <Bram@vim.org>
date	Sat, 06 Apr 2019 14:30:04 +0200
parents	56451a2677dc
children	0f65f2808470

comparison

equal deleted inserted replaced

-:85f58c613efc
+:5df26b29e809
 struct compl_S
 {
 compl_T	*cp_next;
 compl_T	*cp_prev;
 char_u	*cp_str;	// matched text
-char	cp_icase;	// TRUE or FALSE: ignore case
-char	cp_equal;       // TRUE or FALSE: ins_compl_equal always ok
 char_u	*(cp_text[CPT_COUNT]);	// text for the menu
 char_u	*cp_fname;	// file containing the match, allocated when
-				// cp_flags has FREE_FNAME
+				// cp_flags has CP_FREE_FNAME
-int		cp_flags;	// ORIGINAL_TEXT, CONT_S_IPOS or FREE_FNAME
+int		cp_flags;	// CP_ values
 int		cp_number;	// sequence number
 };
-// flags for ins_compl_add()
+// values for cp_flags
-# define ORIGINAL_TEXT	(1)   // the original text when the expansion begun
+# define CP_ORIGINAL_TEXT   1	// the original text when the expansion begun
-# define FREE_FNAME	(2)
+# define CP_FREE_FNAME	    2	// cp_fname is allocated
+# define CP_CONT_S_IPOS	    4	// use CONT_S_IPOS for compl_cont_status
+# define CP_EQUAL	    8	// ins_compl_equal() always returns TRUE
+# define CP_ICASE	    16	// ins_compl_equal() ignores case
 static char e_hitend[] = N_("Hit end of paragraph");
 # ifdef FEAT_COMPL_FUNC
 static char e_complwin[] = N_("E839: Completion function changed window");
 static char e_compldel[] = N_("E840: Completion function deleted text");
 static expand_T	  compl_xp;
 static int	  compl_opt_refresh_always = FALSE;
 static int	  compl_opt_suppress_empty = FALSE;
-static int ins_compl_add(char_u *str, int len, int icase, char_u *fname, char_u **cptext, int cdir, int flags, int adup, int equal);
+static int ins_compl_add(char_u *str, int len, char_u *fname, char_u **cptext, int cdir, int flags, int adup);
 static void ins_compl_longest_match(compl_T *match);
 static void ins_compl_del_pum(void);
 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);
 char_u	*str_arg,
 int		len,
 int		icase,
 char_u	*fname,
 int		dir,
-int		flags)
+int		cont_s_ipos)  // next ^X<> will set initial_pos
 {
 char_u	*str = str_arg;
 char_u	*p;
 int		i, c;
 int		actual_len;		// Take multi-byte characters
 int		actual_compl_length;	// into account.
 int		min_len;
 int		*wca;			// Wide character array.
 int		has_lower = FALSE;
 int		was_letter = FALSE;
+int		flags = 0;
 if (p_ic && curbuf->b_p_inf && len > 0)
 {
 	// Infer case of completed part.
 	    vim_free(wca);
 	}
 	str = IObuff;
 }
+if (cont_s_ipos)
-return ins_compl_add(str, len, icase, fname, NULL, dir,
+	flags |= CP_CONT_S_IPOS;
-							  flags, FALSE, FALSE);
+if (icase)
+	flags |= CP_ICASE;
+return ins_compl_add(str, len, fname, NULL, dir, flags, FALSE);
 }
 /*
 * Add a match to the list of matches.
 * If the given string is already in the list of completions, then return
 */
 static int
 ins_compl_add(
 char_u	*str,
 int		len,
-int		icase,
 char_u	*fname,
 char_u	**cptext,   // extra text for popup menu or NULL
 int		cdir,
-int		flags,
+int		flags_arg,
-int		adup,	    // accept duplicate match
+int		adup)	    // accept duplicate match
-int		equal)      // match is always accepted by ins_compl_equal
 {
 compl_T	*match;
 int		dir = (cdir == 0 ? compl_direction : cdir);
+int		flags = flags_arg;
 ui_breakcheck();
 if (got_int)
 	return FAIL;
 if (len < 0)
 if (compl_first_match != NULL && !adup)
 {
 	match = compl_first_match;
 	do
 	{
-	    if (    !(match->cp_flags & ORIGINAL_TEXT)
+	    if (    !(match->cp_flags & CP_ORIGINAL_TEXT)
 		    && 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);
 // Copy the values to the new match structure.
 match = (compl_T *)alloc_clear((unsigned)sizeof(compl_T));
 if (match == NULL)
 	return FAIL;
 match->cp_number = -1;
-if (flags & ORIGINAL_TEXT)
+if (flags & CP_ORIGINAL_TEXT)
 	match->cp_number = 0;
 if ((match->cp_str = vim_strnsave(str, len)) == NULL)
 {
 	vim_free(match);
 	return FAIL;
 }
-match->cp_icase = icase;
-match->cp_equal = equal;
 // match-fname is:
 // - compl_curr_match->cp_fname if it is a string equal to fname.
-// - a copy of fname, FREE_FNAME is set to free later THE allocated mem.
+// - a copy of fname, CP_FREE_FNAME is set to free later THE allocated mem.
 // - NULL otherwise.	--Acevedo
 if (fname != NULL
 	    && compl_curr_match != NULL
 	    && compl_curr_match->cp_fname != NULL
 	    && STRCMP(fname, compl_curr_match->cp_fname) == 0)
 	match->cp_fname = compl_curr_match->cp_fname;
 else if (fname != NULL)
 {
 	match->cp_fname = vim_strsave(fname);
-	flags |= FREE_FNAME;
+	flags |= CP_FREE_FNAME;
 }
 else
 	match->cp_fname = NULL;
 match->cp_flags = flags;
 else	// if there's nothing before, it is the first match
 	compl_first_match = match;
 compl_curr_match = match;
 // Find the longest common string if still doing that.
-if (compl_get_longest && (flags & ORIGINAL_TEXT) == 0)
+if (compl_get_longest && (flags & CP_ORIGINAL_TEXT) == 0)
 	ins_compl_longest_match(match);
 return OK;
 }
 /*
 * Return TRUE if "str[len]" matches with match->cp_str, considering
-* match->cp_icase.
+* match->cp_flags.
 */
 static int
 ins_compl_equal(compl_T *match, char_u *str, int len)
 {
-if (match->cp_equal)
+if (match->cp_flags & CP_EQUAL)
 	return TRUE;
-if (match->cp_icase)
+if (match->cp_flags & CP_ICASE)
 	return STRNICMP(match->cp_str, str, (size_t)len) == 0;
 return STRNCMP(match->cp_str, str, (size_t)len) == 0;
 }
 /*
 	    else
 	    {
 		c1 = *p;
 		c2 = *s;
 	    }
-	    if (match->cp_icase ? (MB_TOLOWER(c1) != MB_TOLOWER(c2))
+	    if ((match->cp_flags & CP_ICASE)
-								 : (c1 != c2))
+			     ? (MB_TOLOWER(c1) != MB_TOLOWER(c2)) : (c1 != c2))
 		break;
 	    if (has_mbyte)
 	    {
 		MB_PTR_ADV(p);
 		MB_PTR_ADV(s);
 int		i;
 int		add_r = OK;
 int		dir = compl_direction;
 for (i = 0; i < num_matches && add_r != FAIL; i++)
-	if ((add_r = ins_compl_add(matches[i], -1, icase,
+	if ((add_r = ins_compl_add(matches[i], -1, NULL, NULL, dir,
-				      NULL, NULL, dir, 0, FALSE, FALSE)) == OK)
+					   icase ? CP_ICASE : 0, FALSE)) == OK)
 	    // if dir was BACKWARD then honor it just once
 	    dir = FORWARD;
 FreeWild(num_matches, matches);
 }
 void
 set_completion(colnr_T startcol, list_T *list)
 {
 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)
 	ins_compl_prep(' ');
 ins_compl_clear();
 	startcol = curwin->w_cursor.col;
 compl_col = startcol;
 compl_length = (int)curwin->w_cursor.col - (int)startcol;
 // compl_pattern doesn't need to be set
 compl_orig_text = vim_strnsave(ml_get_curline() + compl_col, compl_length);
+if (p_ic)
+	flags |= CP_ICASE;
 if (compl_orig_text == NULL || ins_compl_add(compl_orig_text,
-		   -1, p_ic, NULL, NULL, 0, ORIGINAL_TEXT, FALSE, FALSE) != OK)
+					-1, NULL, NULL, 0, flags, FALSE) != OK)
 	return;
 ctrl_x_mode = CTRL_X_EVAL;
 ins_compl_add_list(list);
 compl = compl_first_match;
 i = 0;
 do
 {
 	if (compl == NULL
-		      || ((compl->cp_flags & ORIGINAL_TEXT) == 0 && ++i == 2))
+		      || ((compl->cp_flags & CP_ORIGINAL_TEXT) == 0 && ++i == 2))
 	    break;
 	compl = compl->cp_next;
 } while (compl != compl_first_match);
 if (strstr((char *)p_cot, "menuone") != NULL)
 	compl = compl_first_match;
 	if (compl_leader != NULL)
 	    lead_len = (int)STRLEN(compl_leader);
 	do
 	{
-	    if ((compl->cp_flags & ORIGINAL_TEXT) == 0
+	    if ((compl->cp_flags & CP_ORIGINAL_TEXT) == 0
 		    && (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);
 						    * compl_match_arraysize));
 	if (compl_match_array != NULL)
 	{
 	    // If the current match is the original text don't find the first
 	    // match after it, don't highlight anything.
-	    if (compl_shown_match->cp_flags & ORIGINAL_TEXT)
+	    if (compl_shown_match->cp_flags & CP_ORIGINAL_TEXT)
 		shown_match_ok = TRUE;
 	    i = 0;
 	    compl = compl_first_match;
 	    do
 	    {
-		if ((compl->cp_flags & ORIGINAL_TEXT) == 0
+		if ((compl->cp_flags & CP_ORIGINAL_TEXT) == 0
 			&& (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 (compl->cp_flags & ORIGINAL_TEXT)
+		    if (compl->cp_flags & CP_ORIGINAL_TEXT)
 			shown_match_ok = TRUE;
 		    if (!shown_match_ok && shown_compl != NULL)
 		    {
 			// The shown match isn't displayed, set it to the
 			ptr = find_line_end(ptr);
 		    else
 			ptr = find_word_end(ptr);
 		    add_r = ins_compl_add_infercase(regmatch->startp[0],
 					  (int)(ptr - regmatch->startp[0]),
-						     p_ic, files[i], *dir, 0);
+						  p_ic, files[i], *dir, FALSE);
 		    if (thesaurus)
 		    {
 			char_u *wstart;
 			// Add the other matches on the line
 			    // Add the word. Skip the regexp match.
 			    if (wstart != regmatch->startp[0])
 				add_r = ins_compl_add_infercase(wstart,
 					(int)(ptr - wstart),
-					p_ic, files[i], *dir, 0);
+					p_ic, files[i], *dir, FALSE);
 			}
 		    }
 		    if (add_r == OK)
 			// if dir was BACKWARD then honor it just once
 			*dir = FORWARD;
 {
 	match = compl_curr_match;
 	compl_curr_match = compl_curr_match->cp_next;
 	vim_free(match->cp_str);
 	// several entries may use the same fname, free it just once.
-	if (match->cp_flags & FREE_FNAME)
+	if (match->cp_flags & CP_FREE_FNAME)
 	    vim_free(match->cp_fname);
 	for (i = 0; i < CPT_COUNT; ++i)
 	    vim_free(match->cp_text[i]);
 	vim_free(match);
 } while (compl_curr_match != NULL && compl_curr_match != compl_first_match);
 	if (ret == OK && compl_first_match != NULL)
 	{
 	    match = compl_first_match;
 	    do
 	    {
-		if (!(match->cp_flags & ORIGINAL_TEXT))
+		if (!(match->cp_flags & CP_ORIGINAL_TEXT))
 		{
 		    di = dict_alloc();
 		    if (di == NULL)
 			return;
 		    ret = list_append_dict(li, di);
 ins_compl_set_original_text(char_u *str)
 {
 char_u	*p;
 // Replace the original text entry.
-// The ORIGINAL_TEXT flag is either at the first item or might possibly be
+// The CP_ORIGINAL_TEXT flag is either at the first item or might possibly be
 // at the last item for backward completion
-if (compl_first_match->cp_flags & ORIGINAL_TEXT)	// safety check
+if (compl_first_match->cp_flags & CP_ORIGINAL_TEXT)	// 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
-	    && (compl_first_match->cp_prev->cp_flags & ORIGINAL_TEXT))
+	    && (compl_first_match->cp_prev->cp_flags & CP_ORIGINAL_TEXT))
 {
 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 (compl_shown_match->cp_flags & ORIGINAL_TEXT)
+	if (compl_shown_match->cp_flags & CP_ORIGINAL_TEXT)
 	{
 	    p = NULL;
 	    for (cp = compl_shown_match->cp_next; cp != NULL
 				 && cp != compl_first_match; cp = cp->cp_next)
 	    {
 */
 int
 ins_compl_add_tv(typval_T *tv, int dir)
 {
 char_u	*word;
-int		icase = FALSE;
+int		dup = FALSE;
-int		adup = FALSE;
+int		empty = FALSE;
-int		aempty = FALSE;
+int		flags = 0;
-int		aequal = FALSE;
 char_u	*(cptext[CPT_COUNT]);
 if (tv->v_type == VAR_DICT && tv->vval.v_dict != NULL)
 {
 	word = dict_get_string(tv->vval.v_dict, (char_u *)"word", FALSE);
 						     (char_u *)"kind", FALSE);
 	cptext[CPT_INFO] = dict_get_string(tv->vval.v_dict,
 						     (char_u *)"info", FALSE);
 	cptext[CPT_USER_DATA] = dict_get_string(tv->vval.v_dict,
 						 (char_u *)"user_data", FALSE);
-	if (dict_get_string(tv->vval.v_dict, (char_u *)"icase", FALSE) != NULL)
+	if (dict_get_string(tv->vval.v_dict, (char_u *)"icase", FALSE) != NULL
-	    icase = dict_get_number(tv->vval.v_dict, (char_u *)"icase");
+			&& dict_get_number(tv->vval.v_dict, (char_u *)"icase"))
+	    flags |= CP_ICASE;
 	if (dict_get_string(tv->vval.v_dict, (char_u *)"dup", FALSE) != NULL)
-	    adup = dict_get_number(tv->vval.v_dict, (char_u *)"dup");
+	    dup = dict_get_number(tv->vval.v_dict, (char_u *)"dup");
 	if (dict_get_string(tv->vval.v_dict, (char_u *)"empty", FALSE) != NULL)
-	    aempty = dict_get_number(tv->vval.v_dict, (char_u *)"empty");
+	    empty = dict_get_number(tv->vval.v_dict, (char_u *)"empty");
-	if (dict_get_string(tv->vval.v_dict, (char_u *)"equal", FALSE) != NULL)
+	if (dict_get_string(tv->vval.v_dict, (char_u *)"equal", FALSE) != NULL
-	    aequal = dict_get_number(tv->vval.v_dict, (char_u *)"equal");
+			&& dict_get_number(tv->vval.v_dict, (char_u *)"equal"))
+	    flags |= CP_EQUAL;
 }
 else
 {
 	word = tv_get_string_chk(tv);
 	vim_memset(cptext, 0, sizeof(cptext));
 }
-if (word == NULL || (!aempty && *word == NUL))
+if (word == NULL || (!empty && *word == NUL))
 	return FAIL;
-return ins_compl_add(word, -1, icase, NULL, cptext, dir, 0, adup, aequal);
+return ins_compl_add(word, -1, NULL, cptext, dir, flags, dup);
 }
 #endif
 /*
 * Get the next expansion(s), using "compl_pattern".
 		p_ws = FALSE;
 	    else if (*e_cpt == '.')
 		p_ws = TRUE;
 	    for (;;)
 	    {
-		int	flags = 0;
+		int	cont_s_ipos = FALSE;
 		++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
 				// copy as much as possible of the new word
 				if (tmp_ptr - ptr >= IOSIZE - len)
 				    tmp_ptr = ptr + IOSIZE - len - 1;
 				STRNCPY(IObuff + len, ptr, tmp_ptr - ptr);
 				len += (int)(tmp_ptr - ptr);
-				flags |= CONT_S_IPOS;
+				cont_s_ipos = TRUE;
 			    }
 			    IObuff[len] = NUL;
 			    ptr = IObuff;
 			}
 			if (len == compl_length)
 			    continue;
 		    }
 		}
 		if (ins_compl_add_infercase(ptr, len, p_ic,
 				 ins_buf == curbuf ? NULL : ins_buf->b_sfname,
-					   0, flags) != NOTDONE)
+					   0, cont_s_ipos) != NOTDONE)
 		{
 		    found_new_match = OK;
 		    break;
 		}
 	    }
 ins_compl_insert(int in_compl_func)
 {
 dict_T	*dict;
 ins_bytes(compl_shown_match->cp_str + ins_compl_len());
-if (compl_shown_match->cp_flags & ORIGINAL_TEXT)
+if (compl_shown_match->cp_flags & CP_ORIGINAL_TEXT)
 	compl_used_match = FALSE;
 else
 	compl_used_match = TRUE;
 // Set completed item.
 // time of 'always', compl_shown_match become NULL.
 if (compl_shown_match == NULL)
 	return -1;
 if (compl_leader != NULL
-			&& (compl_shown_match->cp_flags & ORIGINAL_TEXT) == 0)
+			&& (compl_shown_match->cp_flags & CP_ORIGINAL_TEXT) == 0)
 {
 	// Set "compl_shown_match" to the actually shown match, it may differ
 	// when "compl_leader" is used to omit some of the matches.
 	while (!ins_compl_equal(compl_shown_match,
 				      compl_leader, (int)STRLEN(compl_leader))
 		else
 		    break;
 	    }
 	    found_end = FALSE;
 	}
-	if ((compl_shown_match->cp_flags & ORIGINAL_TEXT) == 0
+	if ((compl_shown_match->cp_flags & CP_ORIGINAL_TEXT) == 0
 		&& compl_leader != NULL
 		&& !ins_compl_equal(compl_shown_match,
 				     compl_leader, (int)STRLEN(compl_leader)))
 	    ++todo;
 	else
 int		n;
 int		save_w_wrow;
 int		save_w_leftcol;
 int		insert_match;
 int		save_did_ai = did_ai;
+int		flags = CP_ORIGINAL_TEXT;
 compl_direction = ins_compl_key2dir(c);
 insert_match = ins_compl_use_match(c);
 if (!compl_started)
 	ins_compl_fixRedoBufForLeader(NULL);
 	// Always add completion for the original text.
 	vim_free(compl_orig_text);
 	compl_orig_text = vim_strnsave(line + compl_col, compl_length);
+	if (p_ic)
+	    flags |= CP_ICASE;
 	if (compl_orig_text == NULL || ins_compl_add(compl_orig_text,
-		   -1, p_ic, NULL, NULL, 0, ORIGINAL_TEXT, FALSE, FALSE) != OK)
+					-1, NULL, NULL, 0, flags, FALSE) != OK)
 	{
 	    VIM_CLEAR(compl_pattern);
 	    VIM_CLEAR(compl_orig_text);
 	    return FAIL;
 	}
 		    && ctrl_x_mode != CTRL_X_PATH_PATTERNS
 		    && ctrl_x_mode != CTRL_X_PATH_DEFINES))
 	    compl_cont_status &= ~CONT_N_ADDS;
 }
-if (compl_curr_match->cp_flags & CONT_S_IPOS)
+if (compl_curr_match->cp_flags & CP_CONT_S_IPOS)
 	compl_cont_status |= CONT_S_IPOS;
 else
 	compl_cont_status &= ~CONT_S_IPOS;
 if (edit_submode_extra == NULL)
 {
-	if (compl_curr_match->cp_flags & ORIGINAL_TEXT)
+	if (compl_curr_match->cp_flags & CP_ORIGINAL_TEXT)
 	{
 	    edit_submode_extra = (char_u *)_("Back at original");
 	    edit_submode_highl = HLF_W;
 	}
 	else if (compl_cont_status & CONT_S_IPOS)

Mercurial > vim

comparison src/insexpand.c @ 16239:5df26b29e809 v8.1.1124