adam/vim
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

patch 8.2.3937: Insert mode completion function is too long

Browse Source 
Problem:    Insert mode completion function is too long.
Solution:   Refactor into multiple functions. (Yegappan Lakshmanan,
            closes #9423)
This commit is contained in:
Yegappan Lakshmanan
2021-12-29 17:38:46 +00:00
committed by Bram Moolenaar
parent ccc1644f95
commit edc6f10390
3 changed files with 552 additions and 346 deletions
Download Patch File Download Diff File Expand all files Collapse all files

508
src/insexpand.c
View File

@ -2901,137 +2901,126 @@ thesaurus_func_complete(int type UNUSED)
}
/*
* Get the next expansion(s), using "compl_pattern".
* The search starts at position "ini" in curbuf and in the direction
* compl_direction.
* When "compl_started" is FALSE start at that position, otherwise continue
* where we stopped searching before.
* This may return before finding all the matches.
* Return the total number of matches or -1 if still unknown -- Acevedo
* Return value of process_next_cpt_value()
*/
enum
{
INS_COMPL_CPT_OK = 1,
INS_COMPL_CPT_CONT,
INS_COMPL_CPT_END
};
/*
* Process the next 'complete' option value in "e_cpt_arg".
*
* If successful, the arguments are set as below:
* e_cpt_arg - pointer to the next option value in 'e_cpt_arg'
* compl_type_arg - type of insert mode completion to use
* found_all_arg - all matches of this type are found
* buf_arg - search for completions in this buffer
* first_match_pos - position of the first completion match
* last_match_pos - position of the last completion match
* set_match_pos - TRUE if the first match position should be saved to avoid
* loops after the search wraps around.
* dict - name of the dictionary or thesaurus file to search
* dict_f - flag specifying whether "dict" is an exact file name or not
*
* Returns INS_COMPL_CPT_OK if the next value is processed successfully.
* Returns INS_COMPL_CPT_CONT to skip the current value and process the next
* option value.
* Returns INS_COMPL_CPT_END if all the values in "e_cpt" are processed.
*/
static int
ins_compl_get_exp(pos_T *ini)
process_next_cpt_value(
char_u **e_cpt_arg,
int *compl_type_arg,
int *found_all_arg,
buf_T **buf_arg,
pos_T *start_match_pos,
pos_T *first_match_pos,
pos_T *last_match_pos,
int *set_match_pos,
char_u **dict_arg,
int *dict_flag)
{
static pos_T first_match_pos;
static pos_T last_match_pos;
static char_u *e_cpt = (char_u *)""; // curr. entry in 'complete'
static int found_all = FALSE; // Found all matches of a
// certain type.
static buf_T *ins_buf = NULL; // buffer being scanned
pos_T *pos;
char_u **matches;
int save_p_scs;
int save_p_ws;
int save_p_ic;
int i;
int num_matches;
int len;
int found_new_match;
int type = ctrl_x_mode;
char_u *ptr;
char_u *e_cpt = *e_cpt_arg;
int compl_type = -1;
int status = INS_COMPL_CPT_OK;
buf_T *buf = *buf_arg;
int found_all = FALSE;
char_u *dict = NULL;
int dict_f = 0;
int set_match_pos;
pos_T prev_pos = {0, 0, 0};
int looped_around = FALSE;
if (!compl_started)
{
FOR_ALL_BUFFERS(ins_buf)
ins_buf->b_scanned = 0;
found_all = FALSE;
ins_buf = curbuf;
e_cpt = (compl_cont_status & CONT_LOCAL)
? (char_u *)"." : curbuf->b_p_cpt;
last_match_pos = first_match_pos = *ini;
}
else if (ins_buf != curbuf && !buf_valid(ins_buf))
ins_buf = curbuf; // In case the buffer was wiped out.
compl_old_match = compl_curr_match; // remember the last current match
pos = (compl_direction == FORWARD) ? &last_match_pos : &first_match_pos;
// For ^N/^P loop over all the flags/windows/buffers in 'complete'.
for (;;)
{
found_new_match = FAIL;
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
|| ctrl_x_mode_line_or_eval())
&& (!compl_started || found_all))
{
found_all = FALSE;
while (*e_cpt == ',' || *e_cpt == ' ')
e_cpt++;
if (*e_cpt == '.' && !curbuf->b_scanned)
{
ins_buf = curbuf;
first_match_pos = *ini;
buf = curbuf;
*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(&first_match_pos) < 0)
if (ctrl_x_mode == CTRL_X_NORMAL && dec(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.
first_match_pos.lnum = ins_buf->b_ml.ml_line_count;
first_match_pos.col =
(colnr_T)STRLEN(ml_get(first_match_pos.lnum));
first_match_pos->lnum = buf->b_ml.ml_line_count;
first_match_pos->col =
(colnr_T)STRLEN(ml_get(first_match_pos->lnum));
}
last_match_pos = first_match_pos;
type = 0;
*last_match_pos = *first_match_pos;
compl_type = 0;
// Remember the first match so that the loop stops when we
// wrap and come back there a second time.
set_match_pos = TRUE;
*set_match_pos = TRUE;
}
else if (vim_strchr((char_u *)"buwU", *e_cpt) != NULL
&& (ins_buf = ins_compl_next_buf(ins_buf, *e_cpt)) != curbuf)
&& (buf = ins_compl_next_buf(buf, *e_cpt)) != curbuf)
{
// Scan a buffer, but not the current one.
if (ins_buf->b_ml.ml_mfp != NULL) // loaded buffer
if (buf->b_ml.ml_mfp != NULL) // loaded buffer
{
compl_started = TRUE;
first_match_pos.col = last_match_pos.col = 0;
first_match_pos.lnum = ins_buf->b_ml.ml_line_count + 1;
last_match_pos.lnum = 0;
type = 0;
first_match_pos->col = last_match_pos->col = 0;
first_match_pos->lnum = buf->b_ml.ml_line_count + 1;
last_match_pos->lnum = 0;
compl_type = 0;
}
else // unloaded buffer, scan like dictionary
{
found_all = TRUE;
if (ins_buf->b_fname == NULL)
continue;
type = CTRL_X_DICTIONARY;
dict = ins_buf->b_fname;
if (buf->b_fname == NULL)
{
status = INS_COMPL_CPT_CONT;
goto done;
}
compl_type = CTRL_X_DICTIONARY;
dict = buf->b_fname;
dict_f = DICT_EXACT;
}
msg_hist_off = TRUE; // reset in msg_trunc_attr()
vim_snprintf((char *)IObuff, IOSIZE, _("Scanning: %s"),
ins_buf->b_fname == NULL
? buf_spname(ins_buf)
: ins_buf->b_sfname == NULL
? ins_buf->b_fname
: ins_buf->b_sfname);
buf->b_fname == NULL
? buf_spname(buf)
: buf->b_sfname == NULL
? buf->b_fname
: buf->b_sfname);
(void)msg_trunc_attr((char *)IObuff, TRUE, HL_ATTR(HLF_R));
}
else if (*e_cpt == NUL)
break;
status = INS_COMPL_CPT_END;
else
{
if (ctrl_x_mode_line_or_eval())
type = -1;
compl_type = -1;
else if (*e_cpt == 'k' || *e_cpt == 's')
{
if (*e_cpt == 'k')
type = CTRL_X_DICTIONARY;
compl_type = CTRL_X_DICTIONARY;
else
type = CTRL_X_THESAURUS;
compl_type = CTRL_X_THESAURUS;
if (*++e_cpt != ',' && *e_cpt != NUL)
{
dict = e_cpt;
@ -3040,73 +3029,88 @@ ins_compl_get_exp(pos_T *ini)
}
#ifdef FEAT_FIND_ID
else if (*e_cpt == 'i')
type = CTRL_X_PATH_PATTERNS;
compl_type = CTRL_X_PATH_PATTERNS;
else if (*e_cpt == 'd')
type = CTRL_X_PATH_DEFINES;
compl_type = CTRL_X_PATH_DEFINES;
#endif
else if (*e_cpt == ']' || *e_cpt == 't')
{
msg_hist_off = TRUE; // reset in msg_trunc_attr()
type = CTRL_X_TAGS;
compl_type = CTRL_X_TAGS;
vim_snprintf((char *)IObuff, IOSIZE, _("Scanning tags."));
(void)msg_trunc_attr((char *)IObuff, TRUE, HL_ATTR(HLF_R));
}
else
type = -1;
compl_type = -1;
// in any case e_cpt is advanced to the next entry
(void)copy_option_part(&e_cpt, IObuff, IOSIZE, ",");
found_all = TRUE;
if (type == -1)
continue;
}
if (compl_type == -1)
status = INS_COMPL_CPT_CONT;
}
// If complete() was called then compl_pattern has been reset. The
// following won't work then, bail out.
if (compl_pattern == NULL)
break;
done:
*e_cpt_arg = e_cpt;
*compl_type_arg = compl_type;
*found_all_arg = found_all;
*buf_arg = buf;
*dict_arg = dict;
*dict_flag = dict_f;
return status;
}
switch (type)
{
case -1:
break;
#ifdef FEAT_FIND_ID
case CTRL_X_PATH_PATTERNS:
case CTRL_X_PATH_DEFINES:
/*
* Get the next set of identifiers or defines matching "compl_pattern" in
* included files.
*/
static void
get_next_include_file_completion(int compl_type)
{
find_pattern_in_path(compl_pattern, compl_direction,
(int)STRLEN(compl_pattern), FALSE, FALSE,
(type == CTRL_X_PATH_DEFINES
(compl_type == CTRL_X_PATH_DEFINES
&& !(compl_cont_status & CONT_SOL))
? FIND_DEFINE : FIND_ANY, 1L, ACTION_EXPAND,
(linenr_T)1, (linenr_T)MAXLNUM);
break;
}
#endif
case CTRL_X_DICTIONARY:
case CTRL_X_THESAURUS:
/*
* Get the next set of words matching "compl_pattern" in dictionary or
* thesaurus files.
*/
static void
get_next_dict_tsr_completion(int compl_type, char_u **dict, int dict_f)
{
#ifdef FEAT_COMPL_FUNC
if (thesaurus_func_complete(type))
expand_by_function(type, compl_pattern);
if (thesaurus_func_complete(compl_type))
expand_by_function(compl_type, compl_pattern);
else
#endif
ins_compl_dictionaries(
dict != NULL ? dict
: (type == CTRL_X_THESAURUS
? (*curbuf->b_p_tsr == NUL
? p_tsr
: curbuf->b_p_tsr)
: (*curbuf->b_p_dict == NUL
? p_dict
: curbuf->b_p_dict)),
*dict != NULL ? *dict
: (compl_type == CTRL_X_THESAURUS
? (*curbuf->b_p_tsr == NUL ? p_tsr : curbuf->b_p_tsr)
: (*curbuf->b_p_dict == NUL ? p_dict : curbuf->b_p_dict)),
compl_pattern,
dict != NULL ? dict_f
: 0, type == CTRL_X_THESAURUS);
dict = NULL;
break;
*dict != NULL ? dict_f : 0,
compl_type == CTRL_X_THESAURUS);
*dict = NULL;
}
/*
* Get the next set of tag names matching "compl_pattern".
*/
static void
get_next_tag_completion(void)
{
int save_p_ic;
char_u **matches;
int num_matches;
case CTRL_X_TAGS:
// set p_ic according to p_ic, p_scs and pat for find_tags().
save_p_ic = p_ic;
p_ic = ignorecase(compl_pattern);
@ -3121,12 +3125,20 @@ ins_compl_get_exp(pos_T *ini)
ins_compl_add_matches(num_matches, matches, p_ic);
g_tag_at_cursor = FALSE;
p_ic = save_p_ic;
break;
}
case CTRL_X_FILES:
if (expand_wildcards(1, &compl_pattern, &num_matches, &matches,
EW_FILE|EW_DIR|EW_ADDSLASH|EW_SILENT) == OK)
/*
* Get the next set of filename matching "compl_pattern".
*/
static void
get_next_filename_completion(void)
{
char_u **matches;
int num_matches;
if (expand_wildcards(1, &compl_pattern, &num_matches, &matches,
EW_FILE|EW_DIR|EW_ADDSLASH|EW_SILENT) != OK)
return;
// May change home directory back to "~".
tilde_replace(compl_pattern, num_matches, matches);
@ -3152,33 +3164,64 @@ ins_compl_get_exp(pos_T *ini)
#endif
ins_compl_add_matches(num_matches, matches, p_fic || p_wic);
}
break;
case CTRL_X_CMDLINE:
case CTRL_X_CMDLINE_CTRL_X:
/*
* Get the next set of command-line completions matching "compl_pattern".
*/
static void
get_next_cmdline_completion()
{
char_u **matches;
int num_matches;
if (expand_cmdline(&compl_xp, compl_pattern,
(int)STRLEN(compl_pattern),
&num_matches, &matches) == EXPAND_OK)
ins_compl_add_matches(num_matches, matches, FALSE);
break;
}
#ifdef FEAT_COMPL_FUNC
case CTRL_X_FUNCTION:
case CTRL_X_OMNI:
expand_by_function(type, compl_pattern);
break;
#endif
case CTRL_X_SPELL:
/*
* Get the next set of spell suggestions matching "compl_pattern".
*/
static void
get_next_spell_completion(linenr_T lnum UNUSED)
{
#ifdef FEAT_SPELL
num_matches = expand_spelling(first_match_pos.lnum,
compl_pattern, &matches);
char_u **matches;
int num_matches;
num_matches = expand_spelling(lnum, compl_pattern, &matches);
if (num_matches > 0)
ins_compl_add_matches(num_matches, matches, p_ic);
#endif
break;
}
/*
* Get the next set of words matching "compl_pattern" for default completion(s)
* (normal ^P/^N and ^X^L).
* Search for "compl_pattern" in the buffer "ins_buf" starting from the
* position "start_pos" in the "compl_direction" direction. If "save_match_pos"
* is TRUE, then set the "first_match_pos" and "last_match_pos".
* Returns OK if a new next match is found, otherwise returns FAIL.
*/
static int
get_next_default_completion(
buf_T *ins_buf, // buffer being scanned
pos_T *start_pos, // search start position
pos_T *cur_match_pos, // current match position
pos_T *prev_match_pos, // previous match position
int *save_match_pos, // set first_match_pos/last_match_pos
pos_T *first_match_pos, // first match position
pos_T *last_match_pos, // last match position
int scan_curbuf) // scan current buffer for completion
{
int found_new_match = FAIL;
int save_p_scs;
int save_p_ws;
int looped_around = FALSE;
char_u *ptr;
int len;
default: // normal ^P/^N and ^X^L
// If 'infercase' is set, don't use 'smartcase' here
save_p_scs = p_scs;
if (ins_buf->b_p_inf)
@ -3191,7 +3234,7 @@ ins_compl_get_exp(pos_T *ini)
save_p_ws = p_ws;
if (ins_buf != curbuf)
p_ws = FALSE;
else if (*e_cpt == '.')
else if (scan_curbuf)
p_ws = TRUE;
looped_around = FALSE;
for (;;)
@ -3204,31 +3247,31 @@ ins_compl_get_exp(pos_T *ini)
// has added a word that was at the beginning of the line
if (ctrl_x_mode_line_or_eval()
|| (compl_cont_status & CONT_SOL))
found_new_match = search_for_exact_line(ins_buf, pos,
found_new_match = search_for_exact_line(ins_buf, cur_match_pos,
compl_direction, compl_pattern);
else
found_new_match = searchit(NULL, ins_buf, pos, NULL,
found_new_match = searchit(NULL, ins_buf, cur_match_pos, NULL,
compl_direction,
compl_pattern, 1L, SEARCH_KEEP + SEARCH_NFMSG,
RE_LAST, NULL);
--msg_silent;
if (!compl_started || set_match_pos)
if (!compl_started || *save_match_pos)
{
// set "compl_started" even on fail
compl_started = TRUE;
first_match_pos = *pos;
last_match_pos = *pos;
set_match_pos = FALSE;
*first_match_pos = *cur_match_pos;
*last_match_pos = *cur_match_pos;
*save_match_pos = FALSE;
}
else if (first_match_pos.lnum == last_match_pos.lnum
&& first_match_pos.col == last_match_pos.col)
else if (first_match_pos->lnum == last_match_pos->lnum
&& first_match_pos->col == last_match_pos->col)
{
found_new_match = FAIL;
}
else if ((compl_direction == FORWARD)
&& (prev_pos.lnum > pos->lnum
|| (prev_pos.lnum == pos->lnum
&& prev_pos.col >= pos->col)))
&& (prev_match_pos->lnum > cur_match_pos->lnum
|| (prev_match_pos->lnum == cur_match_pos->lnum
&& prev_match_pos->col >= cur_match_pos->col)))
{
if (looped_around)
found_new_match = FAIL;
@ -3236,36 +3279,33 @@ ins_compl_get_exp(pos_T *ini)
looped_around = TRUE;
}
else if ((compl_direction != FORWARD)
&& (prev_pos.lnum < pos->lnum
|| (prev_pos.lnum == pos->lnum
&& prev_pos.col <= pos->col)))
&& (prev_match_pos->lnum < cur_match_pos->lnum
|| (prev_match_pos->lnum == cur_match_pos->lnum
&& prev_match_pos->col <= cur_match_pos->col)))
{
if (looped_around)
found_new_match = FAIL;
else
looped_around = TRUE;
}
prev_pos = *pos;
*prev_match_pos = *cur_match_pos;
if (found_new_match == FAIL)
{
if (ins_buf == curbuf)
found_all = TRUE;
break;
}
// when ADDING, the text before the cursor matches, skip it
if ((compl_cont_status & CONT_ADDING) && ins_buf == curbuf
&& ini->lnum == pos->lnum
&& ini->col == pos->col)
&& start_pos->lnum == cur_match_pos->lnum
&& start_pos->col == cur_match_pos->col)
continue;
ptr = ml_get_buf(ins_buf, pos->lnum, FALSE) + pos->col;
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 (pos->lnum >= ins_buf->b_ml.ml_line_count)
if (cur_match_pos->lnum >= ins_buf->b_ml.ml_line_count)
continue;
ptr = ml_get_buf(ins_buf, pos->lnum + 1, FALSE);
ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, FALSE);
if (!p_paste)
ptr = skipwhite(ptr);
}
@ -3288,10 +3328,9 @@ ins_compl_get_exp(pos_T *ini)
tmp_ptr = find_word_end(tmp_ptr);
len = (int)(tmp_ptr - ptr);
if ((compl_cont_status & CONT_ADDING)
&& len == compl_length)
if ((compl_cont_status & CONT_ADDING) && len == compl_length)
{
if (pos->lnum < ins_buf->b_ml.ml_line_count)
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.
@ -3299,7 +3338,7 @@ ins_compl_get_exp(pos_T *ini)
// compl_length, so the next STRNCPY always
// works -- Acevedo
STRNCPY(IObuff, ptr, len);
ptr = ml_get_buf(ins_buf, pos->lnum + 1, FALSE);
ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, FALSE);
tmp_ptr = ptr = skipwhite(ptr);
// Find start of next word.
tmp_ptr = find_word_start(tmp_ptr);
@ -3344,6 +3383,128 @@ ins_compl_get_exp(pos_T *ini)
}
p_scs = save_p_scs;
p_ws = save_p_ws;
return found_new_match;
}
/*
* Get the next expansion(s), using "compl_pattern".
* The search starts at position "ini" in curbuf and in the direction
* compl_direction.
* When "compl_started" is FALSE start at that position, otherwise continue
* where we stopped searching before.
* This may return before finding all the matches.
* Return the total number of matches or -1 if still unknown -- Acevedo
*/
static int
ins_compl_get_exp(pos_T *ini)
{
static pos_T first_match_pos;
static pos_T last_match_pos;
static char_u *e_cpt = (char_u *)""; // curr. entry in 'complete'
static int found_all = FALSE; // Found all matches of a
// certain type.
static buf_T *ins_buf = NULL; // buffer being scanned
pos_T *pos;
int i;
int found_new_match;
int type = ctrl_x_mode;
char_u *dict = NULL;
int dict_f = 0;
int set_match_pos;
pos_T prev_pos = {0, 0, 0};
if (!compl_started)
{
FOR_ALL_BUFFERS(ins_buf)
ins_buf->b_scanned = 0;
found_all = FALSE;
ins_buf = curbuf;
e_cpt = (compl_cont_status & CONT_LOCAL)
? (char_u *)"." : curbuf->b_p_cpt;
last_match_pos = first_match_pos = *ini;
}
else if (ins_buf != curbuf && !buf_valid(ins_buf))
ins_buf = curbuf; // In case the buffer was wiped out.
compl_old_match = compl_curr_match; // remember the last current match
pos = (compl_direction == FORWARD) ? &last_match_pos : &first_match_pos;
// For ^N/^P loop over all the flags/windows/buffers in 'complete'.
for (;;)
{
found_new_match = FAIL;
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
|| ctrl_x_mode_line_or_eval())
&& (!compl_started || found_all))
{
int status = process_next_cpt_value(&e_cpt, &type, &found_all,
&ins_buf, ini, &first_match_pos, &last_match_pos,
&set_match_pos, &dict, &dict_f);
if (status == INS_COMPL_CPT_END)
break;
if (status == INS_COMPL_CPT_CONT)
continue;
}
// If complete() was called then compl_pattern has been reset. The
// following won't work then, bail out.
if (compl_pattern == NULL)
break;
switch (type)
{
case -1:
break;
#ifdef FEAT_FIND_ID
case CTRL_X_PATH_PATTERNS:
case CTRL_X_PATH_DEFINES:
get_next_include_file_completion(type);
break;
#endif
case CTRL_X_DICTIONARY:
case CTRL_X_THESAURUS:
get_next_dict_tsr_completion(type, &dict, dict_f);
break;
case CTRL_X_TAGS:
get_next_tag_completion();
break;
case CTRL_X_FILES:
get_next_filename_completion();
break;
case CTRL_X_CMDLINE:
case CTRL_X_CMDLINE_CTRL_X:
get_next_cmdline_completion();
break;
#ifdef FEAT_COMPL_FUNC
case CTRL_X_FUNCTION:
case CTRL_X_OMNI:
expand_by_function(type, compl_pattern);
break;
#endif
case CTRL_X_SPELL:
get_next_spell_completion(first_match_pos.lnum);
break;
default: // normal ^P/^N and ^X^L
found_new_match = get_next_default_completion(ins_buf, ini, pos,
&prev_pos, &set_match_pos, &first_match_pos,
&last_match_pos, (*e_cpt == '.'));
if (found_new_match == FAIL && ins_buf == curbuf)
found_all = TRUE;
}
// check if compl_curr_match has changed, (e.g. other type of
@ -3845,8 +4006,7 @@ ins_compl_use_match(int c)
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 == CTRL_X_PATH_DEFINES)
{
if (!(compl_cont_status & CONT_ADDING))
{

46
src/testdir/test_ins_complete.vim
View File

@ -47,7 +47,7 @@ func Test_ins_complete()
exe "normal o\<C-X>\<C-P>\<C-P>\<C-X>\<C-X>\<C-N>\<C-X>\<C-N>\<C-N>"
call assert_equal('run1 run2', getline('.'))
set cpt=.,w,i
set cpt=.,\ ,w,i
" i-add-expands and switches to local
exe "normal OM\<C-N>\<C-X>\<C-N>\<C-X>\<C-N>\<C-X>\<C-X>\<C-X>\<C-P>"
call assert_equal("Makefile\tto\trun3", getline('.'))
@ -748,6 +748,17 @@ func Test_complete_across_line()
close!
endfunc
" Test for completing words with a '.' at the end of a word.
func Test_complete_joinspaces()
new
call setline(1, ['one two.', 'three. four'])
set joinspaces
exe "normal Goon\<C-P>\<C-X>\<C-P>\<C-X>\<C-P>\<C-X>\<C-P>\<C-X>\<C-P>"
call assert_equal("one two. three. four", getline(3))
set joinspaces&
bw!
endfunc
" Test for using CTRL-L to add one character when completing matching
func Test_complete_add_onechar()
new
@ -768,6 +779,39 @@ func Test_complete_add_onechar()
close!
endfunc
" Test for using CTRL-X CTRL-L to complete whole lines lines
func Test_complete_wholeline()
new
" complete one-line
call setline(1, ['a1', 'a2'])
exe "normal ggoa\<C-X>\<C-L>"
call assert_equal(['a1', 'a1', 'a2'], getline(1, '$'))
" go to the next match (wrapping around the buffer)
exe "normal 2GCa\<C-X>\<C-L>\<C-N>"
call assert_equal(['a1', 'a', 'a2'], getline(1, '$'))
" go to the next match
exe "normal 2GCa\<C-X>\<C-L>\<C-N>\<C-N>"
call assert_equal(['a1', 'a2', 'a2'], getline(1, '$'))
exe "normal 2GCa\<C-X>\<C-L>\<C-N>\<C-N>\<C-N>"
call assert_equal(['a1', 'a1', 'a2'], getline(1, '$'))
" repeat the test using CTRL-L
" go to the next match (wrapping around the buffer)
exe "normal 2GCa\<C-X>\<C-L>\<C-L>"
call assert_equal(['a1', 'a2', 'a2'], getline(1, '$'))
" go to the next match
exe "normal 2GCa\<C-X>\<C-L>\<C-L>\<C-L>"
call assert_equal(['a1', 'a', 'a2'], getline(1, '$'))
exe "normal 2GCa\<C-X>\<C-L>\<C-L>\<C-L>\<C-L>"
call assert_equal(['a1', 'a1', 'a2'], getline(1, '$'))
%d
" use CTRL-X CTRL-L to add one more line
call setline(1, ['a1', 'b1'])
setlocal complete=.
exe "normal ggOa\<C-X>\<C-L>\<C-X>\<C-L>\<C-X>\<C-L>"
call assert_equal(['a1', 'b1', '', 'a1', 'b1'], getline(1, '$'))
bw!
endfunc
" Test insert completion with 'cindent' (adjust the indent)
func Test_complete_with_cindent()
new

2
src/version.c
View File

@ -749,6 +749,8 @@ static char *(features[]) =
static int included_patches[] =
{ /* Add new patch number below this line */
/**/
3937,
/**/
3936,
/**/