diff options
Diffstat (limited to 'mnv/src/insexpand.c')
| -rw-r--r-- | mnv/src/insexpand.c | 7711 |
1 files changed, 7711 insertions, 0 deletions
diff --git a/mnv/src/insexpand.c b/mnv/src/insexpand.c new file mode 100644 index 0000000000..ffe34278fb --- /dev/null +++ b/mnv/src/insexpand.c @@ -0,0 +1,7711 @@ +/* vi:set ts=8 sts=4 sw=4 noet: + * + * MNV - MNV is not Vim by Bram Moolenaar + * + * Do ":help uganda" in MNV to read copying and usage conditions. + * Do ":help credits" in MNV to see a list of people who contributed. + * See README.txt for an overview of the MNV source code. + */ + +/* + * insexpand.c: functions for Insert mode completion + */ + +#include "mnv.h" + +/* + * Definitions used for CTRL-X submode. + * Note: If you change CTRL-X submode, you must also maintain ctrl_x_msgs[] and + * ctrl_x_mode_names[] below. + */ +#define CTRL_X_WANT_IDENT 0x100 + +#define CTRL_X_NORMAL 0 // CTRL-N CTRL-P completion, default +#define CTRL_X_NOT_DEFINED_YET 1 +#define CTRL_X_SCROLL 2 +#define CTRL_X_WHOLE_LINE 3 +#define CTRL_X_FILES 4 +#define CTRL_X_TAGS (5 + CTRL_X_WANT_IDENT) +#define CTRL_X_PATH_PATTERNS (6 + CTRL_X_WANT_IDENT) +#define CTRL_X_PATH_DEFINES (7 + CTRL_X_WANT_IDENT) +#define CTRL_X_FINISHED 8 +#define CTRL_X_DICTIONARY (9 + CTRL_X_WANT_IDENT) +#define CTRL_X_THESAURUS (10 + CTRL_X_WANT_IDENT) +#define CTRL_X_CMDLINE 11 +#define CTRL_X_FUNCTION 12 +#define CTRL_X_OMNI 13 +#define CTRL_X_SPELL 14 +#define CTRL_X_LOCAL_MSG 15 // only used in "ctrl_x_msgs" +#define CTRL_X_EVAL 16 // for builtin function complete() +#define CTRL_X_CMDLINE_CTRL_X 17 // CTRL-X typed in CTRL_X_CMDLINE +#define CTRL_X_REGISTER 18 // complete words from registers + +#define CTRL_X_MSG(i) ctrl_x_msgs[(i) & ~CTRL_X_WANT_IDENT] + +// Message for CTRL-X mode, index is ctrl_x_mode. +static char *ctrl_x_msgs[] = +{ + N_(" Keyword completion (^N^P)"), // CTRL_X_NORMAL, ^P/^N compl. + N_(" ^X mode (^]^D^E^F^I^K^L^N^O^P^Rs^U^V^Y)"), + NULL, // CTRL_X_SCROLL: depends on state + N_(" Whole line completion (^L^N^P)"), + N_(" File name completion (^F^N^P)"), + N_(" Tag completion (^]^N^P)"), + N_(" Path pattern completion (^N^P)"), + N_(" Definition completion (^D^N^P)"), + NULL, // CTRL_X_FINISHED + N_(" Dictionary completion (^K^N^P)"), + N_(" Thesaurus completion (^T^N^P)"), + N_(" Command-line completion (^V^N^P)"), + N_(" User defined completion (^U^N^P)"), + N_(" Omni completion (^O^N^P)"), + N_(" Spelling suggestion (^S^N^P)"), + N_(" Keyword Local completion (^N^P)"), + NULL, // CTRL_X_EVAL doesn't use msg. + N_(" Command-line completion (^V^N^P)"), + N_(" Register completion (^N^P)"), +}; + +#if defined(FEAT_COMPL_FUNC) || defined(FEAT_EVAL) +static char *ctrl_x_mode_names[] = { + "keyword", + "ctrl_x", + "scroll", + "whole_line", + "files", + "tags", + "path_patterns", + "path_defines", + "unknown", // CTRL_X_FINISHED + "dictionary", + "thesaurus", + "cmdline", + "function", + "omni", + "spell", + NULL, // CTRL_X_LOCAL_MSG only used in "ctrl_x_msgs" + "eval", + "cmdline", + "register", +}; +#endif + +/* + * Structure used to store one match for insert completion. + */ +typedef struct compl_S compl_T; +struct compl_S +{ + compl_T *cp_next; + compl_T *cp_prev; + compl_T *cp_match_next; // matched next compl_T + string_T cp_str; // matched text + char_u *(cp_text[CPT_COUNT]); // text for the menu +#ifdef FEAT_EVAL + typval_T cp_user_data; +#endif + char_u *cp_fname; // file containing the match, allocated when + // cp_flags has CP_FREE_FNAME + int cp_flags; // CP_ values + int cp_number; // sequence number + int cp_score; // fuzzy match score or proximity score + int cp_in_match_array; // collected by compl_match_array + int cp_user_abbr_hlattr; // highlight attribute for abbr + int cp_user_kind_hlattr; // highlight attribute for kind + int cp_cpt_source_idx; // index of this match's source in 'cpt' option +}; + +// values for cp_flags +#define CP_ORIGINAL_TEXT 1 // the original text when the expansion begun +#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 +#define CP_FAST 32 // use fast_breakcheck instead of ui_breakcheck + +/* + * All the current matches are stored in a list. + * "compl_first_match" points to the start of the list. + * "compl_curr_match" points to the currently selected entry. + * "compl_shown_match" is different from compl_curr_match during + * ins_compl_get_exp(), when new matches are added to the list. + * "compl_old_match" points to previous "compl_curr_match". + */ +static compl_T *compl_first_match = NULL; +static compl_T *compl_curr_match = NULL; +static compl_T *compl_shown_match = NULL; +static compl_T *compl_old_match = NULL; + +// list used to store the compl_T which have the max score +static compl_T **compl_best_matches = NULL; +static int compl_num_bests = 0; + +// After using a cursor key <Enter> selects a match in the popup menu, +// otherwise it inserts a line break. +static int compl_enter_selects = FALSE; + +// When "compl_leader" is not NULL only matches that start with this string +// are used. +static string_T compl_leader = {NULL, 0}; + +static int compl_get_longest = FALSE; // put longest common string + // in compl_leader + +// This flag is FALSE when no match is selected (by ^N/^P) or the match was +// edited or using the longest common string. +static int compl_used_match; + +// didn't finish finding completions. +static int compl_was_interrupted = FALSE; + +// Set when character typed while looking for matches and it means we should +// stop looking for matches. +static int compl_interrupted = FALSE; + +static int compl_restarting = FALSE; // don't insert match + +// When the first completion is done "compl_started" is set. When it's +// FALSE the word to be completed must be located. +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; // number of completion matches +static string_T compl_pattern = {NULL, 0}; // search pattern for matching items +#ifdef FEAT_COMPL_FUNC +static string_T cpt_compl_pattern = {NULL, 0}; // pattern returned by func in 'cpt' +#endif +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 linenr_T compl_lnum = 0; // lnum where the completion start +static colnr_T compl_col = 0; // column where the text starts + // that is being completed +static colnr_T compl_ins_end_col = 0; +static string_T compl_orig_text = {NULL, 0}; // text as it was before + // completion started +static int compl_cont_mode = 0; +static expand_T compl_xp; + +static win_T *compl_curr_win = NULL; // win where completion is active +static buf_T *compl_curr_buf = NULL; // buf where completion is active + +#define COMPL_INITIAL_TIMEOUT_MS 80 +// Autocomplete uses a decaying timeout: starting from COMPL_INITIAL_TIMEOUT_MS, +// if the current source exceeds its timeout, it is interrupted and the next +// begins with half the time. A small minimum timeout ensures every source +// gets at least a brief chance. +// Special case: when 'complete' contains "F" or "o" (function sources), a +// longer fixed timeout is used (COMPL_FUNC_TIMEOUT_MS or +// COMPL_FUNC_TIMEOUT_NON_KW_MS). - girish +static int compl_autocomplete = FALSE; // whether autocompletion is active +static int compl_timeout_ms = COMPL_INITIAL_TIMEOUT_MS; +static int compl_time_slice_expired = FALSE; // time budget exceeded for current source +static int compl_from_nonkeyword = FALSE; // completion started from non-keyword +static int compl_hi_on_autocompl_longest = FALSE; // apply "PreInsert" highlight + +// Halve the current completion timeout, simulating exponential decay. +#define COMPL_MIN_TIMEOUT_MS 5 +#define DECAY_COMPL_TIMEOUT() \ + do { \ + if (compl_timeout_ms > COMPL_MIN_TIMEOUT_MS) \ + compl_timeout_ms /= 2; \ + } while (0) + +// Timeout values for F{func}, F and o values in 'complete' +#define COMPL_FUNC_TIMEOUT_MS 300 +#define COMPL_FUNC_TIMEOUT_NON_KW_MS 1000 + +// 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 compl_selected_item = -1; + +static int *compl_fuzzy_scores; + +// Define the structure for completion source (in 'cpt' option) information +typedef struct cpt_source_T +{ + int cs_refresh_always; // Whether 'refresh:always' is set for func + int cs_startcol; // Start column returned by func + int cs_max_matches; // Max items to display from this source +#ifdef ELAPSED_FUNC + elapsed_T compl_start_tv; // Timestamp when match collection starts +#endif + char_u cs_flag; // flag indicating the type of source +} cpt_source_T; + +static cpt_source_T *cpt_sources_array; // Pointer to the array of completion sources +static int cpt_sources_count; // Total number of completion sources specified in the 'cpt' option +static int cpt_sources_index = -1; // Index of the current completion source being expanded + +// "compl_match_array" points the currently displayed list of entries in the +// popup menu. It is NULL when there is no popup menu. +static pumitem_T *compl_match_array = NULL; +static int compl_match_arraysize; + +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, int *user_hl, int score); +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 void ins_compl_free(void); +static int ins_compl_need_restart(void); +static void ins_compl_new_leader(void); +static int get_compl_len(void); +static void ins_compl_restart(void); +static void ins_compl_set_original_text(char_u *str, size_t len); +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); +static void ins_compl_add_dict(dict_T *dict); +static int get_userdefined_compl_info(colnr_T curs_col, callback_T *cb, int *startcol); +static void get_cpt_func_completion_matches(callback_T *cb); +static callback_T *get_callback_if_cpt_func(char_u *p, int idx); +#endif +static int setup_cpt_sources(void); +static int is_cpt_func_refresh_always(void); +static void cpt_sources_clear(void); +static void cpt_compl_refresh(void); +static int ins_compl_key2dir(int c); +static int ins_compl_pum_key(int c); +static int ins_compl_key2count(int c); +static void show_pum(int prev_w_wrow, int prev_w_leftcol); +static unsigned quote_meta(char_u *dest, char_u *str, int len); +static int ins_compl_has_multiple(void); +static void ins_compl_expand_multiple(char_u *str); +static void ins_compl_longest_insert(char_u *prefix); +static void ins_compl_make_linear(void); +static int ins_compl_make_cyclic(void); + +#ifdef FEAT_SPELL +static void spell_back_to_badword(void); +static int spell_bad_len = 0; // length of located bad word +#endif + +/* + * CTRL-X pressed in Insert mode. + */ + void +ins_ctrl_x(void) +{ + if (!ctrl_x_mode_cmdline()) + { + // if the next ^X<> won't ADD nothing, then reset compl_cont_status + if (compl_cont_status & CONT_N_ADDS) + compl_cont_status |= CONT_INTRPT; + else + compl_cont_status = 0; + // We're not sure which CTRL-X mode it will be yet + ctrl_x_mode = CTRL_X_NOT_DEFINED_YET; + edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode)); + edit_submode_pre = NULL; + showmode(); + } + else + // CTRL-X in CTRL-X CTRL-V mode behaves differently to make CTRL-X + // CTRL-V look like CTRL-N + ctrl_x_mode = CTRL_X_CMDLINE_CTRL_X; + + may_trigger_modechanged(); +} + +/* + * Functions to check the current CTRL-X mode. + */ +int ctrl_x_mode_none(void) + { return ctrl_x_mode == 0; } +int ctrl_x_mode_normal(void) + { return ctrl_x_mode == CTRL_X_NORMAL; } +int ctrl_x_mode_scroll(void) + { return ctrl_x_mode == CTRL_X_SCROLL; } +int ctrl_x_mode_whole_line(void) + { return ctrl_x_mode == CTRL_X_WHOLE_LINE; } +int ctrl_x_mode_files(void) + { return ctrl_x_mode == CTRL_X_FILES; } +int ctrl_x_mode_tags(void) + { return ctrl_x_mode == CTRL_X_TAGS; } +int ctrl_x_mode_path_patterns(void) + { return ctrl_x_mode == CTRL_X_PATH_PATTERNS; } +int ctrl_x_mode_path_defines(void) + { return ctrl_x_mode == CTRL_X_PATH_DEFINES; } +int ctrl_x_mode_dictionary(void) + { return ctrl_x_mode == CTRL_X_DICTIONARY; } +int ctrl_x_mode_thesaurus(void) + { return ctrl_x_mode == CTRL_X_THESAURUS; } +int ctrl_x_mode_cmdline(void) + { 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; } +int ctrl_x_mode_register(void) + { return ctrl_x_mode == CTRL_X_REGISTER; } + +/* + * Whether other than default completion has been selected. + */ + int +ctrl_x_mode_not_default(void) +{ + return ctrl_x_mode != CTRL_X_NORMAL; +} + +/* + * Whether CTRL-X was typed without a following character, + * not including when in CTRL-X CTRL-V mode. + */ + int +ctrl_x_mode_not_defined_yet(void) +{ + return ctrl_x_mode == CTRL_X_NOT_DEFINED_YET; +} + +/* + * 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 +#ifdef FEAT_SPELL + && !curwin->w_p_spell +#endif + ) + : (*curbuf->b_p_tsr == NUL && *p_tsr == NUL +#ifdef FEAT_COMPL_FUNC + && *curbuf->b_p_tsrfu == NUL && *p_tsrfu == NUL +#endif + )) + { + ctrl_x_mode = CTRL_X_NORMAL; + edit_submode = NULL; + msg_attr(dict_opt ? _("'dictionary' option is empty") + : _("'thesaurus' option is empty"), + HL_ATTR(HLF_E)); + if (emsg_silent == 0 && !in_assert_fails) + { + mnv_beep(BO_COMPL); + setcursor(); + out_flush(); +#ifdef FEAT_EVAL + if (!get_mnv_var_nr(VV_TESTING)) +#endif + ui_delay(2004L, FALSE); + } + return FALSE; + } + return TRUE; +} + +/* + * Is the character "c" a valid key to go to or keep us in CTRL-X mode? + * This depends on the current mode. + */ + int +mnv_is_ctrl_x_key(int c) +{ + // Always allow ^R - let its results then be checked + if (c == Ctrl_R && ctrl_x_mode != CTRL_X_REGISTER) + return TRUE; + + // Accept <PageUp> and <PageDown> if the popup menu is visible. + if (ins_compl_pum_key(c)) + return TRUE; + + switch (ctrl_x_mode) + { + case 0: // Not in any CTRL-X mode + return (c == Ctrl_N || c == Ctrl_P || c == Ctrl_X); + case CTRL_X_NOT_DEFINED_YET: + case CTRL_X_CMDLINE_CTRL_X: + return ( c == Ctrl_X || c == Ctrl_Y || c == Ctrl_E + || c == Ctrl_L || c == Ctrl_F || c == Ctrl_RSB + || c == Ctrl_I || c == Ctrl_D || c == Ctrl_P + || c == Ctrl_N || c == Ctrl_T || c == Ctrl_V + || c == Ctrl_Q || c == Ctrl_U || c == Ctrl_O + || c == Ctrl_S || c == Ctrl_K || c == 's' + || c == Ctrl_Z || c == Ctrl_R); + case CTRL_X_SCROLL: + return (c == Ctrl_Y || c == Ctrl_E); + case CTRL_X_WHOLE_LINE: + return (c == Ctrl_L || c == Ctrl_P || c == Ctrl_N); + case CTRL_X_FILES: + return (c == Ctrl_F || c == Ctrl_P || c == Ctrl_N); + case CTRL_X_DICTIONARY: + return (c == Ctrl_K || c == Ctrl_P || c == Ctrl_N); + case CTRL_X_THESAURUS: + return (c == Ctrl_T || c == Ctrl_P || c == Ctrl_N); + case CTRL_X_TAGS: + return (c == Ctrl_RSB || c == Ctrl_P || c == Ctrl_N); +#ifdef FEAT_FIND_ID + case CTRL_X_PATH_PATTERNS: + return (c == Ctrl_P || c == Ctrl_N); + case CTRL_X_PATH_DEFINES: + return (c == Ctrl_D || c == Ctrl_P || c == Ctrl_N); +#endif + case CTRL_X_CMDLINE: + return (c == Ctrl_V || c == Ctrl_Q || c == Ctrl_P || c == Ctrl_N + || c == Ctrl_X); +#ifdef FEAT_COMPL_FUNC + case CTRL_X_FUNCTION: + return (c == Ctrl_U || c == Ctrl_P || c == Ctrl_N); + case CTRL_X_OMNI: + return (c == Ctrl_O || c == Ctrl_P || c == Ctrl_N); +#endif + case CTRL_X_SPELL: + return (c == Ctrl_S || c == Ctrl_P || c == Ctrl_N); + case CTRL_X_EVAL: + return (c == Ctrl_P || c == Ctrl_N); + case CTRL_X_REGISTER: + return (c == Ctrl_R || c == Ctrl_P || c == Ctrl_N); + } + internal_error("mnv_is_ctrl_x_key()"); + return FALSE; +} + +/* + * Return TRUE if "match" is the original text when the completion began. + */ + static int +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 + * is visible. + */ + int +ins_compl_accept_char(int c) +{ + if (compl_autocomplete && compl_from_nonkeyword) + return FALSE; + + if (ctrl_x_mode & CTRL_X_WANT_IDENT) + // When expanding an identifier only accept identifier chars. + return mnv_isIDc(c); + + switch (ctrl_x_mode) + { + case CTRL_X_FILES: + // When expanding file name only accept file name chars. But not + // path separators, so that "proto/<Tab>" expands files in + // "proto", not "proto/" as a whole + return mnv_isfilec(c) && !mnv_ispathsep(c); + + case CTRL_X_CMDLINE: + case CTRL_X_CMDLINE_CTRL_X: + case CTRL_X_OMNI: + // Command line and Omni completion can work with just about any + // printable character, but do stop at white space. + return mnv_isprintc(c) && !MNV_ISWHITE(c); + + case CTRL_X_WHOLE_LINE: + // For while line completion a space can be part of the line. + return mnv_isprintc(c); + } + return mnv_iswordc(c); +} + +/* + * Get the completed text by inferring the case of the originally typed text. + * If the result is in allocated memory "tofree" is set to it. + */ + static char_u * +ins_compl_infercase_gettext( + char_u *str, + int char_len, + int compl_char_len, + int min_len, + char_u **tofree) +{ + int *wca; // Wide character array. + char_u *p; + int i, c; + int has_lower = FALSE; + int was_letter = FALSE; + garray_T gap; + + IObuff[0] = NUL; + + // Allocate wide character array for the completion and fill it. + wca = ALLOC_MULT(int, char_len); + if (wca == NULL) + return IObuff; + + p = str; + for (i = 0; i < char_len; ++i) + { + if (has_mbyte) + wca[i] = mb_ptr2char_adv(&p); + else + wca[i] = *(p++); + } + + // Rule 1: Were any chars converted to lower? + p = compl_orig_text.string; + for (i = 0; i < min_len; ++i) + { + c = has_mbyte ? mb_ptr2char_adv(&p) : *(p++); + if (MB_ISLOWER(c)) + { + has_lower = TRUE; + if (MB_ISUPPER(wca[i])) + { + // Rule 1 is satisfied. + for (i = compl_char_len; i < char_len; ++i) + wca[i] = MB_TOLOWER(wca[i]); + break; + } + } + } + + // Rule 2: No lower case, 2nd consecutive letter converted to + // upper case. + if (!has_lower) + { + p = compl_orig_text.string; + for (i = 0; i < min_len; ++i) + { + c = has_mbyte ? mb_ptr2char_adv(&p) : *(p++); + if (was_letter && MB_ISUPPER(c) && MB_ISLOWER(wca[i])) + { + // Rule 2 is satisfied. + for (i = compl_char_len; i < char_len; ++i) + wca[i] = MB_TOUPPER(wca[i]); + break; + } + was_letter = MB_ISLOWER(c) || MB_ISUPPER(c); + } + } + + // Copy the original case of the part we typed. + p = compl_orig_text.string; + for (i = 0; i < min_len; ++i) + { + c = has_mbyte ? mb_ptr2char_adv(&p) : *(p++); + if (MB_ISLOWER(c)) + wca[i] = MB_TOLOWER(wca[i]); + else if (MB_ISUPPER(c)) + wca[i] = MB_TOUPPER(wca[i]); + } + + // Generate encoding specific output from wide character array. + p = IObuff; + i = 0; + ga_init2(&gap, 1, 500); + while (i < char_len) + { + if (gap.ga_data != NULL) + { + if (ga_grow(&gap, 10) == FAIL) + { + ga_clear(&gap); + return (char_u *)"[failed]"; + } + p = (char_u *)gap.ga_data + gap.ga_len; + if (has_mbyte) + gap.ga_len += (*mb_char2bytes)(wca[i++], p); + else + { + *p = wca[i++]; + ++gap.ga_len; + } + } + else if ((p - IObuff) + 6 >= IOSIZE) + { + // Multi-byte characters can occupy up to five bytes more than + // ASCII characters, and we also need one byte for NUL, so when + // getting to six bytes from the edge of IObuff switch to using a + // growarray. Add the character in the next round. + if (ga_grow(&gap, IOSIZE) == FAIL) + { + mnv_free(wca); + return (char_u *)"[failed]"; + } + *p = NUL; + STRCPY(gap.ga_data, IObuff); + gap.ga_len = (int)(p - IObuff); + } + else if (has_mbyte) + p += (*mb_char2bytes)(wca[i++], p); + else + *(p++) = wca[i++]; + } + mnv_free(wca); + + if (gap.ga_data != NULL) + { + *tofree = gap.ga_data; + return gap.ga_data; + } + + *p = NUL; + return IObuff; +} + +/* + * This is like ins_compl_add(), but if 'ic' and 'inf' are set, then the + * case of the originally typed text is used, and the case of the completed + * text is inferred, ie this tries to work out what case you probably wanted + * the rest of the word to be in -- webb + */ + int +ins_compl_add_infercase( + char_u *str_arg, + int len, + int icase, + char_u *fname, + int dir, + int cont_s_ipos, // next ^X<> will set initial_pos + int score) +{ + char_u *str = str_arg; + char_u *p; + int char_len; // count multi-byte characters + int compl_char_len; + int min_len; + int flags = 0; + int res; + char_u *tofree = NULL; + + if (p_ic && curbuf->b_p_inf && len > 0) + { + // Infer case of completed part. + + // Find actual length of completion. + if (has_mbyte) + { + p = str; + char_len = 0; + while (*p != NUL) + { + MB_PTR_ADV(p); + ++char_len; + } + } + else + { + char_len = len; + } + + // Find actual length of original text. + if (has_mbyte) + { + p = compl_orig_text.string; + compl_char_len = 0; + while (*p != NUL) + { + MB_PTR_ADV(p); + ++compl_char_len; + } + } + else + { + compl_char_len = compl_length; + } + + // "char_len" may be smaller than "compl_char_len" when using + // thesaurus, only use the minimum when comparing. + min_len = MIN(char_len, compl_char_len); + + str = ins_compl_infercase_gettext(str, char_len, + compl_char_len, min_len, &tofree); + } + if (cont_s_ipos) + flags |= CP_CONT_S_IPOS; + if (icase) + flags |= CP_ICASE; + + res = ins_compl_add(str, len, fname, NULL, NULL, dir, flags, FALSE, NULL, score); + mnv_free(tofree); + return res; +} + +/* + * Check if fuzzy matching is enabled + */ + static int +cot_fuzzy(void) +{ + return (get_cot_flags() & COT_FUZZY) != 0 && !ctrl_x_mode_thesaurus(); +} + +/* + * Returns TRUE if matches should be sorted based on proximity to the cursor. + */ + static int +is_nearest_active(void) +{ + return (compl_autocomplete || (get_cot_flags() & COT_NEAREST)) + && !cot_fuzzy(); +} + +/* + * TRUE if a match is selected (even if it is not inserted). + */ + int +ins_compl_is_match_selected(void) +{ + return compl_shown_match != NULL && !is_first_match(compl_shown_match); +} + +/* + * Returns TRUE if autocomplete is active and the pre-insert effect targets the + * longest prefix. + */ + int +ins_compl_preinsert_longest(void) +{ + return compl_autocomplete + && (get_cot_flags() & (COT_LONGEST | COT_PREINSERT | COT_FUZZY)) + == COT_LONGEST; +} + +/* + * Add a match to the list of matches. The arguments are: + * str - text of the match to add + * len - length of "str". If -1, then the length of "str" is + * computed. + * fname - file name to associate with this match. + * cptext - list of strings to use with this match (for abbr, menu, info + * and kind) + * user_data - user supplied data (any mnv type) for this match + * cdir - match direction. If 0, use "compl_direction". + * flags_arg - match flags (cp_flags) + * adup - accept this match even if it is already present. + * *user_hl - list of extra highlight attributes for abbr kind. + * If "cdir" is FORWARD, then the match is added after the current match. + * Otherwise, it is added before the current match. + * + * If the given string is already in the list of completions, then return + * NOTDONE, otherwise add it to the list and return OK. If there is an error, + * maybe because alloc() returns NULL, then FAIL is returned. + */ + static int +ins_compl_add( + char_u *str, + int len, + char_u *fname, + char_u **cptext, // extra text for popup menu or NULL + typval_T *user_data UNUSED, // "user_data" entry or NULL + int cdir, + int flags_arg, + int adup, // accept duplicate match + int *user_hl, // user abbr/kind hlattr + int score) +{ + compl_T *match, *current, *prev; + int dir = (cdir == 0 ? compl_direction : cdir); + int flags = flags_arg; + int inserted = FALSE; + + if (flags & CP_FAST) + fast_breakcheck(); + else + ui_breakcheck(); + if (got_int) + return FAIL; + if (len < 0) + len = (int)STRLEN(str); + + // If the same match is already present, don't add it. + if (compl_first_match != NULL && !adup) + { + match = compl_first_match; + do + { + if (!match_at_original_text(match) + && STRNCMP(match->cp_str.string, str, len) == 0 + && ((int)match->cp_str.length <= len + || match->cp_str.string[len] == NUL)) + { + if (is_nearest_active() && score > 0 && score < match->cp_score) + match->cp_score = score; + return NOTDONE; + } + match = match->cp_next; + } while (match != NULL && !is_first_match(match)); + } + + // Remove any popup menu before changing the list of matches. + ins_compl_del_pum(); + + // Allocate a new match structure. + // Copy the values to the new match structure. + match = ALLOC_CLEAR_ONE(compl_T); + if (match == NULL) + return FAIL; + match->cp_number = flags & CP_ORIGINAL_TEXT ? 0 : -1; + if ((match->cp_str.string = mnv_strnsave(str, len)) == NULL) + { + mnv_free(match); + return FAIL; + } + + match->cp_str.length = len; + + // match-fname is: + // - compl_curr_match->cp_fname if it is a string equal to fname. + // - 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 = mnv_strsave(fname); + flags |= CP_FREE_FNAME; + } + else + match->cp_fname = NULL; + match->cp_flags = flags; + match->cp_user_abbr_hlattr = user_hl ? user_hl[0] : -1; + match->cp_user_kind_hlattr = user_hl ? user_hl[1] : -1; + match->cp_score = score; + match->cp_cpt_source_idx = cpt_sources_index; + + if (cptext != NULL) + { + for (int i = 0; i < CPT_COUNT; ++i) + { + if (cptext[i] != NULL && *cptext[i] != NUL) + match->cp_text[i] = mnv_strsave(cptext[i]); + } + } +#ifdef FEAT_EVAL + if (user_data != NULL) + match->cp_user_data = *user_data; +#endif + + // Link the new match structure after (FORWARD) or before (BACKWARD) the + // current match in the list of matches . + if (compl_first_match == NULL) + match->cp_next = match->cp_prev = NULL; + else if (cot_fuzzy() && score != FUZZY_SCORE_NONE && compl_get_longest) + { + current = compl_first_match->cp_next; + prev = compl_first_match; + inserted = FALSE; + // The direction is ignored when using longest and fuzzy match, because + // matches are inserted and sorted by score. + while (current != NULL && current != compl_first_match) + { + if (current->cp_score < score) + { + match->cp_next = current; + match->cp_prev = current->cp_prev; + if (current->cp_prev) + current->cp_prev->cp_next = match; + current->cp_prev = match; + inserted = TRUE; + break; + } + prev = current; + current = current->cp_next; + } + if (!inserted) + { + prev->cp_next = match; + match->cp_prev = prev; + match->cp_next = compl_first_match; + compl_first_match->cp_prev = match; + } + } + else if (dir == FORWARD) + { + match->cp_next = compl_curr_match->cp_next; + match->cp_prev = compl_curr_match; + } + else // BACKWARD + { + match->cp_next = compl_curr_match; + match->cp_prev = compl_curr_match->cp_prev; + } + if (match->cp_next) + match->cp_next->cp_prev = match; + if (match->cp_prev) + match->cp_prev->cp_next = match; + 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 & CP_ORIGINAL_TEXT) == 0 && !cot_fuzzy() + && !ins_compl_preinsert_longest() && !ctrl_x_mode_thesaurus()) + ins_compl_longest_match(match); + + return OK; +} + +/* + * Return TRUE if "str[len]" matches with match->cp_str, considering + * match->cp_flags. + */ + static int +ins_compl_equal(compl_T *match, char_u *str, int len) +{ + if (match->cp_flags & CP_EQUAL) + return TRUE; + if (match->cp_flags & CP_ICASE) + return STRNICMP(match->cp_str.string, str, (size_t)len) == 0; + return STRNCMP(match->cp_str.string, str, (size_t)len) == 0; +} + +/* + * when len is -1 mean use whole length of p otherwise part of p + */ + static void +ins_compl_insert_bytes(char_u *p, int len) +{ + if (len == -1) + len = (int)STRLEN(p); + ins_bytes_len(p, len); + compl_ins_end_col = curwin->w_cursor.col; +} + +/* + * Get current completion leader + */ + char_u * +ins_compl_leader(void) +{ + return compl_leader.string != NULL ? compl_leader.string : compl_orig_text.string; +} + +/* + * Get current completion leader length + */ + static size_t +ins_compl_leader_len(void) +{ + return compl_leader.string != NULL ? compl_leader.length : compl_orig_text.length; +} + +/* + * Checks if the column is within the currently inserted completion text + * column range. If it is, it returns a special highlight attribute. + * -1 means normal item. + */ + int +ins_compl_col_range_attr(linenr_T lnum, int col) +{ + int start_col; + int has_preinsert = ins_compl_has_preinsert() + || ins_compl_preinsert_longest(); + int attr; + + if (cot_fuzzy() + || (!compl_hi_on_autocompl_longest && ins_compl_preinsert_longest()) + || (attr = syn_name2attr(has_preinsert + ? (char_u *)"PreInsert" : (char_u *)"ComplMatchIns")) == 0) + return -1; + + start_col = compl_col + (int)ins_compl_leader_len(); + if (!ins_compl_has_multiple()) + return (col >= start_col && col < compl_ins_end_col) ? attr : -1; + + // Multiple lines + if ((lnum == compl_lnum && col >= start_col && col < MAXCOL) || + (lnum > compl_lnum && lnum < curwin->w_cursor.lnum) || + (lnum == curwin->w_cursor.lnum && col <= compl_ins_end_col)) + return attr; + + return -1; +} + +/* + * Returns TRUE if the current completion string contains newline characters, + * indicating it's a multi-line completion. + */ + static int +ins_compl_has_multiple(void) +{ + return mnv_strchr(compl_shown_match->cp_str.string, '\n') != NULL; +} + +/* + * Returns TRUE if the given line number falls within the range of a multi-line + * completion, i.e. between the starting line (compl_lnum) and current cursor + * line. Always returns FALSE for single-line completions. + */ + int +ins_compl_lnum_in_range(linenr_T lnum) +{ + if (!ins_compl_has_multiple()) + return FALSE; + return lnum >= compl_lnum && lnum <= curwin->w_cursor.lnum; +} + +/* + * Reduce the longest common string for match "match". + */ + static void +ins_compl_longest_match(compl_T *match) +{ + char_u *p, *s; + int c1, c2; + int had_match; + + if (compl_leader.string == NULL) + { + // First match, use it as a whole. + compl_leader.string = mnv_strnsave(match->cp_str.string, match->cp_str.length); + if (compl_leader.string == NULL) + return; + + compl_leader.length = match->cp_str.length; + had_match = (curwin->w_cursor.col > compl_col); + ins_compl_longest_insert(compl_leader.string); + + // When the match isn't there (to avoid matching itself) remove it + // again after redrawing. + if (!had_match) + ins_compl_delete(); + compl_used_match = FALSE; + + return; + } + + // Reduce the text if this match differs from compl_leader. + p = compl_leader.string; + s = match->cp_str.string; + while (*p != NUL) + { + if (has_mbyte) + { + c1 = mb_ptr2char(p); + c2 = mb_ptr2char(s); + } + else + { + c1 = *p; + c2 = *s; + } + if ((match->cp_flags & CP_ICASE) + ? (MB_TOLOWER(c1) != MB_TOLOWER(c2)) : (c1 != c2)) + break; + if (has_mbyte) + { + MB_PTR_ADV(p); + MB_PTR_ADV(s); + } + else + { + ++p; + ++s; + } + } + + if (*p != NUL) + { + // Leader was shortened, need to change the inserted text. + *p = NUL; + compl_leader.length = (size_t)(p - compl_leader.string); + + had_match = (curwin->w_cursor.col > compl_col); + ins_compl_longest_insert(compl_leader.string); + + // When the match isn't there (to avoid matching itself) remove it + // again after redrawing. + if (!had_match) + ins_compl_delete(); + } + + compl_used_match = FALSE; +} + +/* + * Add an array of matches to the list of matches. + * Frees matches[]. + */ + static void +ins_compl_add_matches( + int num_matches, + char_u **matches, + int icase) +{ + int add_r = OK; + int dir = compl_direction; + + for (int i = 0; i < num_matches && add_r != FAIL; i++) + { + add_r = ins_compl_add(matches[i], -1, NULL, NULL, NULL, dir, + CP_FAST | (icase ? CP_ICASE : 0), FALSE, NULL, + FUZZY_SCORE_NONE); + if (add_r == OK) + // if dir was BACKWARD then honor it just once + dir = FORWARD; + } + FreeWild(num_matches, matches); +} + +/* + * Make the completion list cyclic. + * Return the number of matches (excluding the original). + */ + static int +ins_compl_make_cyclic(void) +{ + compl_T *match; + int count = 0; + + if (compl_first_match == NULL) + 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 && !is_first_match(match->cp_next)) + { + match = match->cp_next; + ++count; + } + match->cp_next = compl_first_match; + compl_first_match->cp_prev = match; + + return count; +} + +/* + * Return whether there currently is a shown match. + */ + int +ins_compl_has_shown_match(void) +{ + return compl_shown_match == NULL + || compl_shown_match != compl_shown_match->cp_next; +} + +/* + * Return whether the shown match is long enough. + */ + int +ins_compl_long_shown_match(void) +{ + return (int)compl_shown_match->cp_str.length + > curwin->w_cursor.col - compl_col; +} + +/* + * Get the local or global value of 'completeopt' flags. + */ + unsigned int +get_cot_flags(void) +{ + return curbuf->b_cot_flags != 0 ? curbuf->b_cot_flags : cot_flags; +} + +/* + * Update the screen and when there is any scrolling remove the popup menu. + */ + static void +ins_compl_upd_pum(void) +{ + if (compl_match_array == NULL) + return; + + int h = curwin->w_cline_height; + // Update the screen later, before drawing the popup menu over it. + pum_call_update_screen(); + if (h != curwin->w_cline_height) + ins_compl_del_pum(); +} + +/* + * Remove any popup menu. + */ + static void +ins_compl_del_pum(void) +{ + if (compl_match_array == NULL) + return; + + pum_undisplay(); + MNV_CLEAR(compl_match_array); +} + +/* + * Return TRUE if the popup menu should be displayed. + */ + int +pum_wanted(void) +{ + // 'completeopt' must contain "menu" or "menuone" + if ((get_cot_flags() & COT_ANY_MENU) == 0 && !compl_autocomplete) + return FALSE; + + // The display looks bad on a B&W display. + if (t_colors < 8 +#ifdef FEAT_GUI + && !gui.in_use +#endif + ) + return FALSE; + return TRUE; +} + +/* + * Return TRUE if there are two or more matches to be shown in the popup menu. + * One if 'completopt' contains "menuone". + */ + static int +pum_enough_matches(void) +{ + compl_T *compl; + int i = 0; + + // Don't display the popup menu if there are no matches or there is only + // one (ignoring the original text). + compl = compl_first_match; + do + { + if (compl == NULL || (!match_at_original_text(compl) && ++i == 2)) + break; + compl = compl->cp_next; + } while (!is_first_match(compl)); + + if ((get_cot_flags() & COT_MENUONE) || compl_autocomplete) + return (i >= 1); + return (i >= 2); +} + +#if defined(FEAT_EVAL) +/* + * Allocate Dict for the completed item. + * { word, abbr, menu, kind, info } + */ + static dict_T * +ins_compl_dict_alloc(compl_T *match) +{ + dict_T *dict = dict_alloc_lock(VAR_FIXED); + + if (dict == NULL) + return NULL; + + dict_add_string(dict, "word", match->cp_str.string); + dict_add_string(dict, "abbr", match->cp_text[CPT_ABBR]); + dict_add_string(dict, "menu", match->cp_text[CPT_MENU]); + dict_add_string(dict, "kind", match->cp_text[CPT_KIND]); + dict_add_string(dict, "info", match->cp_text[CPT_INFO]); + if (match->cp_user_data.v_type == VAR_UNKNOWN) + dict_add_string(dict, "user_data", (char_u *)""); + else + dict_add_tv(dict, "user_data", &match->cp_user_data); + + return dict; +} + +/* + * Trigger the CompleteChanged autocmd event. Invoked each time the Insert mode + * completion menu is changed. + */ + static void +trigger_complete_changed_event(int cur) +{ + dict_T *v_event; + dict_T *item; + static int recursive = FALSE; + save_v_event_T save_v_event; + + if (recursive) + return; + + item = cur < 0 ? dict_alloc() : ins_compl_dict_alloc(compl_curr_match); + if (item == NULL) + return; + v_event = get_v_event(&save_v_event); + dict_add_dict(v_event, "completed_item", item); + pum_set_event_info(v_event); + dict_set_items_ro(v_event); + + recursive = TRUE; + textlock++; + apply_autocmds(EVENT_COMPLETECHANGED, NULL, NULL, FALSE, curbuf); + textlock--; + recursive = FALSE; + + restore_v_event(v_event, &save_v_event); +} +#endif + +/* + * Helper functions for mergesort_list(). + */ + static void* +cp_get_next(void *node) +{ + return ((compl_T*)node)->cp_next; +} + + static void +cp_set_next(void *node, void *next) +{ + ((compl_T*)node)->cp_next = (compl_T*)next; +} + + static void* +cp_get_prev(void* node) +{ + return ((compl_T*)node)->cp_prev; +} + + static void +cp_set_prev(void* node, void* prev) +{ + ((compl_T*)node)->cp_prev = (compl_T*)prev; +} + + static int +cp_compare_fuzzy(const void* a, const void* b) +{ + int score_a = ((compl_T*)a)->cp_score; + int score_b = ((compl_T*)b)->cp_score; + return (score_b > score_a) ? 1 : (score_b < score_a) ? -1 : 0; +} + + static int +cp_compare_nearest(const void* a, const void* b) +{ + int score_a = ((compl_T*)a)->cp_score; + int score_b = ((compl_T*)b)->cp_score; + if (score_a == FUZZY_SCORE_NONE || score_b == FUZZY_SCORE_NONE) + return 0; + return (score_a > score_b) ? 1 : (score_a < score_b) ? -1 : 0; +} + +/* + * Constructs a new string by prepending text from the current line (from + * startcol to compl_col) to the given source string. Stores the result in + * dest. Returns OK or FAIL. + */ + static int +prepend_startcol_text(string_T *dest, string_T *src, int startcol) +{ + int prepend_len = compl_col - startcol; + int new_length = prepend_len + (int)src->length; + + dest->length = (size_t)new_length; + dest->string = alloc(new_length + 1); // +1 for NUL + if (dest->string == NULL) + { + dest->length = 0; + return FAIL; + } + + char_u *line = ml_get(curwin->w_cursor.lnum); + + mch_memmove(dest->string, line + startcol, prepend_len); + mch_memmove(dest->string + prepend_len, src->string, src->length); + dest->string[new_length] = NUL; + return OK; +} + +/* + * Returns the completion leader string adjusted for a specific source's + * startcol. If the source's startcol is before compl_col, prepends text from + * the buffer line to the original compl_leader. + */ + static string_T * +get_leader_for_startcol(compl_T *match, int cached) +{ + static string_T adjusted_leader = {NULL, 0}; + + if (match == NULL) + { + MNV_CLEAR_STRING(adjusted_leader); + return NULL; + } + + if (cpt_sources_array == NULL) + goto theend; + + int cpt_idx = match->cp_cpt_source_idx; + if (cpt_idx < 0) + goto theend; + int startcol = cpt_sources_array[cpt_idx].cs_startcol; + + if (compl_leader.string == NULL) + { + // When leader is not set (e.g. 'autocomplete' first fires before + // compl_leader is initialised), fall back to compl_orig_text for + // matches starting at or after compl_col. Matches starting before + // compl_col carry pre-compl_col text and must not be compared with + // compl_orig_text, so return &compl_leader (NULL string) to signal + // "pass through" (no prefix filter). + if (startcol < 0 || startcol >= compl_col) + return &compl_orig_text; + return &compl_leader; // pass through (startcol < compl_col) + } + + if (compl_col <= 0) + goto theend; + + if (startcol >= 0 && startcol < compl_col) + { + int prepend_len = compl_col - startcol; + int new_length = prepend_len + (int)compl_leader.length; + if (cached && (size_t)new_length == adjusted_leader.length + && adjusted_leader.string != NULL) + return &adjusted_leader; + + MNV_CLEAR_STRING(adjusted_leader); + if (prepend_startcol_text(&adjusted_leader, &compl_leader, + startcol) != OK) + goto theend; + + return &adjusted_leader; + } +theend: + return &compl_leader; +} + +/* + * Set fuzzy score for completion matches. + */ + static void +set_fuzzy_score(void) +{ + compl_T *compl; + char_u *pattern; + int use_leader; + + if (compl_first_match == NULL) + return; + + /* Determine the pattern to match against */ + use_leader = (compl_leader.string != NULL && compl_leader.length > 0); + if (!use_leader) + { + if (compl_orig_text.string == NULL || compl_orig_text.length == 0) + return; + pattern = compl_orig_text.string; + } + else + { + /* Clear the leader cache once before the loop */ + (void)get_leader_for_startcol(NULL, TRUE); + pattern = NULL; /* Will be computed per-completion */ + } + + /* Score all completion matches */ + compl = compl_first_match; + do + { + if (use_leader) + pattern = get_leader_for_startcol(compl, TRUE)->string; + + compl->cp_score = fuzzy_match_str(compl->cp_str.string, pattern); + compl = compl->cp_next; + } while (compl != NULL && !is_first_match(compl)); +} + +/* + * Sort completion matches, excluding the node that contains the leader. + */ + static void +sort_compl_match_list(int (*compare)(const void *, const void *)) +{ + compl_T *compl; + + if (!compl_first_match || is_first_match(compl_first_match->cp_next)) + return; + + compl = compl_first_match->cp_prev; + ins_compl_make_linear(); + if (compl_shows_dir_forward()) + { + compl_first_match->cp_next->cp_prev = NULL; + compl_first_match->cp_next = mergesort_list(compl_first_match->cp_next, + cp_get_next, cp_set_next, cp_get_prev, cp_set_prev, compare); + compl_first_match->cp_next->cp_prev = compl_first_match; + } + else + { + compl->cp_prev->cp_next = NULL; + compl_first_match = mergesort_list(compl_first_match, cp_get_next, + cp_set_next, cp_get_prev, cp_set_prev, compare); + compl_T *tail = compl_first_match; + while (tail->cp_next != NULL) + tail = tail->cp_next; + tail->cp_next = compl; + compl->cp_prev = tail; + } + (void)ins_compl_make_cyclic(); +} + +/* + * Build a popup menu to show the completion matches. + * Returns the popup menu entry that should be selected. Returns -1 if nothing + * should be selected. + */ + static int +ins_compl_build_pum(void) +{ + compl_T *compl; + compl_T *shown_compl = NULL; + int did_find_shown_match = FALSE; + int shown_match_ok = FALSE; + int i = 0; + int cur = -1; + int compl_no_select = (get_cot_flags() & COT_NOSELECT) != 0 + || (compl_autocomplete && !ins_compl_has_preinsert()); + compl_T *match_head = NULL; + compl_T *match_tail = NULL; + compl_T *match_next = NULL; + int *match_count = NULL; + int is_forward = compl_shows_dir_forward(); + int is_cpt_completion = (cpt_sources_array != NULL); + string_T *leader; + + // Need to build the popup menu list. + compl_match_arraysize = 0; + + // If the current match is the original text don't find the first + // match after it, don't highlight anything. + if (match_at_original_text(compl_shown_match)) + shown_match_ok = TRUE; + + if (compl_leader.string != NULL + && STRCMP(compl_leader.string, compl_orig_text.string) == 0 + && shown_match_ok == FALSE) + compl_shown_match = compl_no_select ? compl_first_match + : compl_first_match->cp_next; + + if (is_cpt_completion) + { + match_count = ALLOC_CLEAR_MULT(int, cpt_sources_count); + if (match_count == NULL) + return -1; + } + + (void)get_leader_for_startcol(NULL, TRUE); // Clear the cache + + compl = compl_first_match; + do + { + compl->cp_in_match_array = FALSE; + + leader = get_leader_for_startcol(compl, TRUE); + + // Apply 'smartcase' behavior during normal mode + if (ctrl_x_mode_normal() && !p_inf && leader->string + && !ignorecase(leader->string) && !cot_fuzzy()) + compl->cp_flags &= ~CP_ICASE; + + if (!match_at_original_text(compl) + && (leader->string == NULL + || ins_compl_equal(compl, leader->string, + (int)leader->length) + || (cot_fuzzy() && compl->cp_score != FUZZY_SCORE_NONE))) + { + // Limit number of items from each source if max_items is set. + int match_limit_exceeded = FALSE; + int cur_source = compl->cp_cpt_source_idx; + if (is_forward && cur_source != -1 && is_cpt_completion) + { + match_count[cur_source]++; + int max_matches = cpt_sources_array[cur_source].cs_max_matches; + if (max_matches > 0 && match_count[cur_source] > max_matches) + match_limit_exceeded = TRUE; + } + + if (!match_limit_exceeded) + { + ++compl_match_arraysize; + compl->cp_in_match_array = TRUE; + if (match_head == NULL) + match_head = compl; + else + match_tail->cp_match_next = compl; + match_tail = compl; + + if (!shown_match_ok && !cot_fuzzy()) + { + if (compl == compl_shown_match || did_find_shown_match) + { + // This item is the shown match or this is the + // first displayed item after the shown match. + compl_shown_match = compl; + did_find_shown_match = TRUE; + shown_match_ok = TRUE; + } + else + // Remember this displayed match for when the + // shown match is just below it. + shown_compl = compl; + cur = i; + } + else if (cot_fuzzy()) + { + if (i == 0) + shown_compl = compl; + + if (!shown_match_ok && compl == compl_shown_match) + { + cur = i; + shown_match_ok = TRUE; + } + } + i++; + } + } + + if (compl == compl_shown_match && !cot_fuzzy()) + { + did_find_shown_match = TRUE; + + // When the original text is the shown match don't set + // compl_shown_match. + 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 + // previously displayed match. + compl_shown_match = shown_compl; + shown_match_ok = TRUE; + } + } + compl = compl->cp_next; + } while (compl != NULL && !is_first_match(compl)); + + mnv_free(match_count); + + if (compl_match_arraysize == 0) + return -1; + + if (cot_fuzzy() && !compl_no_select && !shown_match_ok) + { + compl_shown_match = shown_compl; + shown_match_ok = TRUE; + cur = 0; + } + + compl_match_array = ALLOC_CLEAR_MULT(pumitem_T, compl_match_arraysize); + if (compl_match_array == NULL) + return -1; + + compl = match_head; + i = 0; + while (compl != NULL) + { + compl_match_array[i].pum_text = compl->cp_text[CPT_ABBR] != NULL + ? compl->cp_text[CPT_ABBR] : compl->cp_str.string; + compl_match_array[i].pum_kind = compl->cp_text[CPT_KIND]; + compl_match_array[i].pum_info = compl->cp_text[CPT_INFO]; + compl_match_array[i].pum_cpt_source_idx = compl->cp_cpt_source_idx; + compl_match_array[i].pum_user_abbr_hlattr = compl->cp_user_abbr_hlattr; + compl_match_array[i].pum_user_kind_hlattr = compl->cp_user_kind_hlattr; + compl_match_array[i++].pum_extra = compl->cp_text[CPT_MENU] != NULL + ? compl->cp_text[CPT_MENU] : compl->cp_fname; + match_next = compl->cp_match_next; + compl->cp_match_next = NULL; + compl = match_next; + } + + if (!shown_match_ok) // no displayed match at all + cur = -1; + + return cur; +} + +/* + * Show the popup menu for the list of matches. + * Also adjusts "compl_shown_match" to an entry that is actually displayed. + */ + void +ins_compl_show_pum(void) +{ + int i; + int cur = -1; + colnr_T col; + + if (!pum_wanted() || !pum_enough_matches()) + return; + + // Update the screen later, before drawing the popup menu over it. + pum_call_update_screen(); + + if (compl_match_array == NULL) + // Need to build the popup menu list. + cur = ins_compl_build_pum(); + else + { + // popup menu already exists, only need to find the current item. + for (i = 0; i < compl_match_arraysize; ++i) + { + if (compl_match_array[i].pum_text == compl_shown_match->cp_str.string + || compl_match_array[i].pum_text + == compl_shown_match->cp_text[CPT_ABBR]) + { + cur = i; + break; + } + } + } + + if (compl_match_array == NULL) + { +#ifdef FEAT_EVAL + if (compl_started && has_completechanged()) + trigger_complete_changed_event(cur); +#endif + return; + } + + // In Replace mode when a $ is displayed at the end of the line only + // part of the screen would be updated. We do need to redraw here. + dollar_vcol = -1; + + // Compute the screen column of the start of the completed text. + // Use the cursor to get all wrapping and other settings right. + col = curwin->w_cursor.col; + curwin->w_cursor.col = compl_col; + compl_selected_item = cur; + pum_display(compl_match_array, compl_match_arraysize, cur); + curwin->w_cursor.col = col; + + // After adding leader, set the current match to shown match. + if (compl_started && compl_curr_match != compl_shown_match) + compl_curr_match = compl_shown_match; + +#ifdef FEAT_EVAL + if (has_completechanged()) + trigger_complete_changed_event(cur); +#endif +} + +#define DICT_FIRST (1) // use just first element in "dict" +#define DICT_EXACT (2) // "dict" is the exact name of a file + +/* + * Add any identifiers that match the given pattern "pat" in the list of + * dictionary files "dict_start" to the list of completions. + */ + static void +ins_compl_dictionaries( + char_u *dict_start, + char_u *pat, + int flags, // DICT_FIRST and/or DICT_EXACT + int thesaurus) // Thesaurus completion +{ + char_u *dict = dict_start; + char_u *ptr; + char_u *buf; + regmatch_T regmatch; + char_u **files; + int count; + int save_p_scs; + int dir = compl_direction; + + if (*dict == NUL) + { +#ifdef FEAT_SPELL + // When 'dictionary' is empty and spell checking is enabled use + // "spell". + if (!thesaurus && curwin->w_p_spell) + dict = (char_u *)"spell"; + else +#endif + return; + } + + buf = alloc(LSIZE); + if (buf == NULL) + return; + regmatch.regprog = NULL; // so that we can goto theend + + // If 'infercase' is set, don't use 'smartcase' here + save_p_scs = p_scs; + if (curbuf->b_p_inf) + p_scs = FALSE; + + // When invoked to match whole lines for CTRL-X CTRL-L adjust the pattern + // to only match at the start of a line. Otherwise just match the + // pattern. Also need to double backslashes. + if (ctrl_x_mode_line_or_eval()) + { + char_u *pat_esc = mnv_strsave_escaped(pat, (char_u *)"\\"); + + if (pat_esc == NULL) + goto theend; + size_t len = STRLEN(pat_esc) + 10; + ptr = alloc(len); + if (ptr == NULL) + { + mnv_free(pat_esc); + goto theend; + } + mnv_snprintf((char *)ptr, len, "^\\s*\\zs\\V%s", pat_esc); + regmatch.regprog = mnv_regcomp(ptr, RE_MAGIC); + mnv_free(pat_esc); + mnv_free(ptr); + } + else + { + regmatch.regprog = mnv_regcomp(pat, magic_isset() ? RE_MAGIC : 0); + if (regmatch.regprog == NULL) + goto theend; + } + + // ignore case depends on 'ignorecase', 'smartcase' and "pat" + regmatch.rm_ic = ignorecase(pat); + while (*dict != NUL && !got_int && !compl_interrupted) + { + // copy one dictionary file name into buf + if (flags == DICT_EXACT) + { + count = 1; + files = &dict; + } + else + { + // Expand wildcards in the dictionary name, but do not allow + // backticks (for security, the 'dict' option may have been set in + // a modeline). + copy_option_part(&dict, buf, LSIZE, ","); +#ifdef FEAT_SPELL + if (!thesaurus && STRCMP(buf, "spell") == 0) + count = -1; + else +#endif + if (mnv_strchr(buf, '`') != NULL + || expand_wildcards(1, &buf, &count, &files, + EW_FILE|EW_SILENT) != OK) + count = 0; + } + +#ifdef FEAT_SPELL + if (count == -1) + { + // Complete from active spelling. Skip "\<" in the pattern, we + // don't use it as a RE. + if (pat[0] == '\\' && pat[1] == '<') + ptr = pat + 2; + else + ptr = pat; + spell_dump_compl(ptr, regmatch.rm_ic, &dir, 0); + } + else +#endif + if (count > 0) // avoid warning for using "files" uninit + { + ins_compl_files(count, files, thesaurus, flags, ®match, buf, + &dir); + if (flags != DICT_EXACT) + FreeWild(count, files); + } + if (flags != 0) + break; + } + +theend: + p_scs = save_p_scs; + mnv_regfree(regmatch.regprog); + mnv_free(buf); +} + +/* + * Add all the words in the line "*buf_arg" from the thesaurus file "fname" + * skipping the word at 'skip_word'. Returns OK on success. + */ + static int +thesaurus_add_words_in_line( + char_u *fname, + char_u **buf_arg, + int dir, + char_u *skip_word) +{ + int status = OK; + char_u *ptr; + char_u *wstart; + + // Add the other matches on the line + ptr = *buf_arg; + while (!got_int) + { + // Find start of the next word. Skip white + // space and punctuation. + ptr = find_word_start(ptr); + if (*ptr == NUL || *ptr == NL) + break; + wstart = ptr; + + // Find end of the word. + if (has_mbyte) + // Japanese words may have characters in + // different classes, only separate words + // with single-byte non-word characters. + while (*ptr != NUL) + { + int l = (*mb_ptr2len)(ptr); + + if (l < 2 && !mnv_iswordc(*ptr)) + break; + ptr += l; + } + else + ptr = find_word_end(ptr); + + // Add the word. Skip the regexp match. + if (wstart != skip_word) + { + status = ins_compl_add_infercase(wstart, (int)(ptr - wstart), p_ic, + fname, dir, FALSE, FUZZY_SCORE_NONE); + if (status == FAIL) + break; + } + } + + *buf_arg = ptr; + return status; +} + +/* + * Process "count" dictionary/thesaurus "files" and add the text matching + * "regmatch". + */ + static void +ins_compl_files( + int count, + char_u **files, + int thesaurus, + int flags, + regmatch_T *regmatch, + char_u *buf, + int *dir) +{ + char_u *ptr; + int i; + FILE *fp; + int add_r; + char_u *leader = NULL; + int leader_len = 0; + int score = 0; + int len = 0; + char_u *line_end = NULL; + + if (cot_fuzzy()) + { + leader = ins_compl_leader(); + leader_len = (int)ins_compl_leader_len(); + } + + for (i = 0; i < count && !got_int && !ins_compl_interrupted(); i++) + { + fp = mch_fopen((char *)files[i], "r"); // open dictionary file + if (flags != DICT_EXACT && !shortmess(SHM_COMPLETIONSCAN) + && !compl_autocomplete) + { + msg_hist_off = TRUE; // reset in msg_trunc_attr() + mnv_snprintf((char *)IObuff, IOSIZE, + _("Scanning dictionary: %s"), (char *)files[i]); + (void)msg_trunc_attr((char *)IObuff, TRUE, HL_ATTR(HLF_R)); + } + + if (fp == NULL) + continue; + + // Read dictionary file line by line. + // Check each line for a match. + while (!got_int && !ins_compl_interrupted() + && !mnv_fgets(buf, LSIZE, fp)) + { + ptr = buf; + if (cot_fuzzy() && leader_len > 0) + { + line_end = find_line_end(ptr); + while (ptr < line_end) + { + if (fuzzy_match_str_in_line(&ptr, leader, &len, NULL, &score)) + { + char_u *end_ptr = ctrl_x_mode_line_or_eval() + ? find_line_end(ptr) : find_word_end(ptr); + add_r = ins_compl_add_infercase(ptr, (int)(end_ptr - ptr), + p_ic, files[i], *dir, FALSE, score); + if (add_r == FAIL) + break; + ptr = end_ptr; // start from next word + if (compl_get_longest && ctrl_x_mode_normal() + && compl_first_match->cp_next + && score == compl_first_match->cp_next->cp_score) + compl_num_bests++; + } + } + } + else if (regmatch != NULL) + { + while (mnv_regexec(regmatch, buf, (colnr_T)(ptr - buf))) + { + ptr = regmatch->startp[0]; + ptr = ctrl_x_mode_line_or_eval() ? find_line_end(ptr) + : find_word_end(ptr); + add_r = ins_compl_add_infercase(regmatch->startp[0], + (int)(ptr - regmatch->startp[0]), + p_ic, files[i], *dir, FALSE, FUZZY_SCORE_NONE); + if (thesaurus) + { + // For a thesaurus, add all the words in the line + ptr = buf; + add_r = thesaurus_add_words_in_line(files[i], &ptr, *dir, + regmatch->startp[0]); + } + if (add_r == OK) + // if dir was BACKWARD then honor it just once + *dir = FORWARD; + else if (add_r == FAIL) + break; + // avoid expensive call to mnv_regexec() when at end + // of line + if (*ptr == '\n' || got_int) + break; + } + } + line_breakcheck(); + ins_compl_check_keys(50, FALSE); + } + fclose(fp); + } +} + +/* + * Find the start of the next word. + * Returns a pointer to the first char of the word. Also stops at a NUL. + */ + char_u * +find_word_start(char_u *ptr) +{ + if (has_mbyte) + { + while (*ptr != NUL && *ptr != '\n' && mb_get_class(ptr) <= 1) + ptr += (*mb_ptr2len)(ptr); + } + else + { + while (*ptr != NUL && *ptr != '\n' && !mnv_iswordc(*ptr)) + ++ptr; + } + return ptr; +} + +/* + * Find the end of the word. Assumes it starts inside a word. + * Returns a pointer to just after the word. + */ + char_u * +find_word_end(char_u *ptr) +{ + if (has_mbyte) + { + int start_class = mb_get_class(ptr); + if (start_class > 1) + while (*ptr != NUL) + { + ptr += (*mb_ptr2len)(ptr); + if (mb_get_class(ptr) != start_class) + break; + } + } + else + while (mnv_iswordc(*ptr)) + ++ptr; + return ptr; +} + +/* + * Find the end of the line, omitting CR and NL at the end. + * Returns a pointer to just after the line. + */ + char_u * +find_line_end(char_u *ptr) +{ + char_u *s = ptr + STRLEN(ptr); + while (s > ptr && (s[-1] == CAR || s[-1] == NL)) + --s; + return s; +} + +/* + * Free a completion item in the list + */ + static void +ins_compl_item_free(compl_T *match) +{ + MNV_CLEAR_STRING(match->cp_str); + // several entries may use the same fname, free it just once. + if (match->cp_flags & CP_FREE_FNAME) + mnv_free(match->cp_fname); + for (int i = 0; i < CPT_COUNT; ++i) + mnv_free(match->cp_text[i]); +#ifdef FEAT_EVAL + clear_tv(&match->cp_user_data); +#endif + mnv_free(match); +} + +/* + * Free the list of completions + */ + static void +ins_compl_free(void) +{ + compl_T *match; + + MNV_CLEAR_STRING(compl_pattern); + MNV_CLEAR_STRING(compl_leader); + + if (compl_first_match == NULL) + return; + + ins_compl_del_pum(); + pum_clear(); + + compl_curr_match = compl_first_match; + do + { + match = compl_curr_match; + compl_curr_match = compl_curr_match->cp_next; + ins_compl_item_free(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; + compl_matches = 0; + compl_selected_item = -1; + compl_ins_end_col = 0; + compl_curr_win = NULL; + compl_curr_buf = NULL; + MNV_CLEAR_STRING(compl_pattern); + MNV_CLEAR_STRING(compl_leader); + edit_submode_extra = NULL; + MNV_CLEAR_STRING(compl_orig_text); + compl_enter_selects = FALSE; + cpt_sources_clear(); + compl_autocomplete = FALSE; + compl_from_nonkeyword = FALSE; + compl_num_bests = 0; +#ifdef FEAT_EVAL + // clear v:completed_item + set_mnv_var_dict(VV_COMPLETED_ITEM, dict_alloc_lock(VAR_FIXED)); +#endif +} + +/* + * Return TRUE when Insert completion is active. + */ + int +ins_compl_active(void) +{ + return compl_started; +} + +/* + * Return True when wp is the actual completion window + */ + int +ins_compl_win_active(win_T *wp) +{ + return ins_compl_active() && wp == compl_curr_win + && wp->w_buffer == compl_curr_buf; +} + +/* + * Selected one of the matches. When FALSE, the match was either edited or + * using the longest common string. + */ + int +ins_compl_used_match(void) +{ + return compl_used_match; +} + +/* + * Initialize get longest common string. + */ + void +ins_compl_init_get_longest(void) +{ + compl_get_longest = FALSE; +} + +/* + * Returns TRUE when insert completion is interrupted. + */ + int +ins_compl_interrupted(void) +{ + return compl_interrupted || compl_time_slice_expired; +} + +/* + * Returns TRUE if the <Enter> key selects a match in the completion popup + * menu. + */ + int +ins_compl_enter_selects(void) +{ + return compl_enter_selects; +} + +/* + * Return the column where the text starts that is being completed + */ + colnr_T +ins_compl_col(void) +{ + return compl_col; +} + +/* + * Return the length in bytes of the text being completed + */ + int +ins_compl_len(void) +{ + return compl_length; +} + +/* + * Return TRUE when the 'completeopt' "preinsert" flag is in effect, + * otherwise return FALSE. + */ + int +ins_compl_has_preinsert(void) +{ + int cur_cot_flags = get_cot_flags(); + if (compl_autocomplete && p_ic && !p_inf) + return FALSE; + return !compl_autocomplete + ? (cur_cot_flags & (COT_PREINSERT | COT_FUZZY | COT_MENUONE)) + == (COT_PREINSERT | COT_MENUONE) + : (cur_cot_flags & (COT_PREINSERT | COT_FUZZY)) == COT_PREINSERT; +} + +/* + * Returns TRUE if the pre-insert effect is valid and the cursor is within + * the `compl_ins_end_col` range. + */ + int +ins_compl_preinsert_effect(void) +{ + if (!ins_compl_has_preinsert() && !ins_compl_preinsert_longest()) + return FALSE; + + return curwin->w_cursor.col < compl_ins_end_col; +} + +/* + * 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. + */ + int +ins_compl_bs(void) +{ + char_u *line; + char_u *p; + + if (ins_compl_preinsert_effect()) + ins_compl_delete(); + + line = ml_get_curline(); + p = line + curwin->w_cursor.col; + MB_PTR_BACK(line, p); + + // 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 && !ctrl_x_mode_omni()) + || ctrl_x_mode_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 + // finding all matches: need to look for matches all over again. + if (curwin->w_cursor.col <= compl_col + compl_length + || ins_compl_need_restart()) + ins_compl_restart(); + + MNV_CLEAR_STRING(compl_leader); + compl_leader.length = (size_t)((p - line) - compl_col); + compl_leader.string = mnv_strnsave(line + compl_col, compl_leader.length); + if (compl_leader.string == NULL) + { + compl_leader.length = 0; + return K_BS; + } + + // Clear selection if a menu item is currently selected in autocompletion + if (compl_autocomplete && compl_first_match && !ins_compl_has_preinsert()) + compl_shown_match = compl_first_match; + + ins_compl_new_leader(); + if (compl_shown_match != NULL) + // Make sure current match is not a hidden item. + compl_curr_match = compl_shown_match; + return NUL; +} + +/* + * Return TRUE when we need to find matches again, ins_compl_restart() is to + * be called. + */ + static int +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_function() || ctrl_x_mode_omni()) + && compl_opt_refresh_always); +} + +/* + * Return TRUE if 'autocomplete' option is set + */ + int +ins_compl_has_autocomplete(void) +{ + // Use buffer-local setting if defined (>= 0), otherwise use global + return curbuf->b_p_ac >= 0 ? curbuf->b_p_ac : p_ac; +} + +/* + * Calculate fuzzy score and sort completion matches unless sorting is disabled. + */ + static void +ins_compl_fuzzy_sort(void) +{ + int cur_cot_flags = get_cot_flags(); + + // Set the fuzzy score in cp_score and sort + set_fuzzy_score(); + if (!(cur_cot_flags & COT_NOSORT)) + { + sort_compl_match_list(cp_compare_fuzzy); + // Reset the shown item since sorting reorders items + if ((cur_cot_flags & (COT_NOINSERT | COT_NOSELECT)) == COT_NOINSERT) + { + int none_selected = compl_shown_match == (compl_shows_dir_forward() + ? compl_first_match : compl_first_match->cp_prev); + if (!none_selected) + compl_shown_match + = (!compl_autocomplete && compl_shows_dir_forward()) + ? compl_first_match->cp_next : compl_first_match; + } + } +} + +/* + * Called after changing "compl_leader". + * Show the popup menu with a different set of matches. + * May also search for matches again if the previous search was interrupted. + */ + static void +ins_compl_new_leader(void) +{ + int save_w_wrow = curwin->w_wrow; + int save_w_leftcol = curwin->w_leftcol; + + ins_compl_del_pum(); + ins_compl_delete(); + ins_compl_insert_bytes(compl_leader.string + get_compl_len(), -1); + compl_used_match = FALSE; + + if (p_acl > 0) + { + update_screen(UPD_VALID); // Show char (deletion) immediately + out_flush(); + } + + if (compl_started) + { + ins_compl_set_original_text(compl_leader.string, compl_leader.length); + if (is_cpt_func_refresh_always()) + cpt_compl_refresh(); + if (cot_fuzzy()) + ins_compl_fuzzy_sort(); + } + else + { +#ifdef FEAT_SPELL + spell_bad_len = 0; // need to redetect bad word +#endif + // Matches were cleared, need to search for them now. Before drawing + // the popup menu display the changed text before the cursor. Set + // "compl_restarting" to avoid that the first match is inserted. + pum_call_update_screen(); +#ifdef FEAT_GUI + if (gui.in_use) + { + // Show the cursor after the match, not after the redrawn text. + setcursor(); + out_flush_cursor(FALSE, FALSE); + } +#endif + save_w_wrow = curwin->w_wrow; + save_w_leftcol = curwin->w_leftcol; + compl_restarting = TRUE; + if (ins_compl_has_autocomplete()) + ins_compl_enable_autocomplete(); + else + compl_autocomplete = FALSE; + if (ins_complete(Ctrl_N, FALSE) == FAIL) + compl_cont_status = 0; + compl_restarting = FALSE; + } + + compl_enter_selects = !compl_used_match && compl_selected_item != -1; + + // Show the popup menu with a different set of matches. + if (!compl_interrupted) + show_pum(save_w_wrow, save_w_leftcol); + + // Don't let Enter select the original text when there is no popup menu. + if (compl_match_array == NULL) + compl_enter_selects = FALSE; + else if (ins_compl_has_preinsert() && compl_leader.length > 0) + ins_compl_insert(TRUE, FALSE); + else if (compl_started && ins_compl_preinsert_longest() + && compl_leader.length > 0 && !ins_compl_preinsert_effect()) + ins_compl_insert(TRUE, TRUE); +} + +/* + * Return the length of the completion, from the completion start column to + * the cursor column. Making sure it never goes below zero. + */ + static int +get_compl_len(void) +{ + int off = (int)curwin->w_cursor.col - (int)compl_col; + return MAX(0, off); +} + +/* + * Append one character to the match leader. May reduce the number of + * matches. + */ + void +ins_compl_addleader(int c) +{ + int cc; + + if (ins_compl_preinsert_effect()) + ins_compl_delete(); + + if (stop_arrow() == FAIL) + return; + if (has_mbyte && (cc = (*mb_char2len)(c)) > 1) + { + char_u buf[MB_MAXBYTES + 1]; + + (*mb_char2bytes)(c, buf); + buf[cc] = NUL; + ins_char_bytes(buf, cc); + if (compl_opt_refresh_always) + AppendToRedobuff(buf); + } + else + { + ins_char(c); + if (compl_opt_refresh_always) + AppendCharToRedobuff(c); + } + + // If we didn't complete finding matches we must search again. + if (ins_compl_need_restart()) + ins_compl_restart(); + + // When 'always' is set, don't reset compl_leader. While completing, + // cursor doesn't point to the original position, changing compl_leader + // would break redo. + if (!compl_opt_refresh_always) + { + MNV_CLEAR_STRING(compl_leader); + compl_leader.length = (size_t)(curwin->w_cursor.col - compl_col); + compl_leader.string = mnv_strnsave(ml_get_curline() + compl_col, + compl_leader.length); + if (compl_leader.string == NULL) + { + compl_leader.length = 0; + return; + } + + ins_compl_new_leader(); + } +} + +/* + * Setup for finding completions again without leaving CTRL-X mode. Used when + * BS or a key was typed while still searching for matches. + */ + static void +ins_compl_restart(void) +{ + ins_compl_free(); + compl_started = FALSE; + compl_matches = 0; + compl_cont_status = 0; + compl_cont_mode = 0; + cpt_sources_clear(); + compl_autocomplete = FALSE; + compl_from_nonkeyword = FALSE; + compl_num_bests = 0; +} + +/* + * Set the first match, the original text. + */ + static void +ins_compl_set_original_text(char_u *str, size_t len) +{ + // 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 (match_at_original_text(compl_first_match)) // safety check + { + char_u *p = mnv_strnsave(str, len); + if (p != NULL) + { + MNV_CLEAR_STRING(compl_first_match->cp_str); + compl_first_match->cp_str.string = p; + compl_first_match->cp_str.length = len; + } + } + else if (compl_first_match->cp_prev != NULL + && match_at_original_text(compl_first_match->cp_prev)) + { + char_u *p = mnv_strnsave(str, len); + if (p != NULL) + { + MNV_CLEAR_STRING(compl_first_match->cp_prev->cp_str); + compl_first_match->cp_prev->cp_str.string = p; + compl_first_match->cp_prev->cp_str.length = len; + } + } +} + +/* + * Append one character to the match leader. May reduce the number of + * matches. + */ + void +ins_compl_addfrommatch(void) +{ + char_u *p; + int len = (int)curwin->w_cursor.col - (int)compl_col; + int c; + + p = compl_shown_match->cp_str.string; + if ((int)compl_shown_match->cp_str.length <= len) // the match is too short + { + size_t plen; + compl_T *cp; + + // When still at the original match use the first entry that matches + // the leader. + if (!match_at_original_text(compl_shown_match)) + return; + + p = NULL; + plen = 0; + for (cp = compl_shown_match->cp_next; cp != NULL + && !is_first_match(cp); cp = cp->cp_next) + { + if (compl_leader.string == NULL + || ins_compl_equal(cp, compl_leader.string, + (int)compl_leader.length)) + { + p = cp->cp_str.string; + plen = cp->cp_str.length; + break; + } + } + if (p == NULL || (int)plen <= len) + return; + } + p += len; + c = PTR2CHAR(p); + ins_compl_addleader(c); +} + +/* + * 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 +set_ctrl_x_mode(int c) +{ + int retval = FALSE; + + switch (c) + { + case Ctrl_E: + case Ctrl_Y: + // scroll the window one line up or down + ctrl_x_mode = CTRL_X_SCROLL; + if (!(State & REPLACE_FLAG)) + edit_submode = (char_u *)_(" (insert) Scroll (^E/^Y)"); + else + edit_submode = (char_u *)_(" (replace) Scroll (^E/^Y)"); + edit_submode_pre = NULL; + showmode(); + break; + case Ctrl_L: + // complete whole line + ctrl_x_mode = CTRL_X_WHOLE_LINE; + break; + case Ctrl_F: + // complete filenames + ctrl_x_mode = CTRL_X_FILES; + break; + case Ctrl_K: + // complete words from a dictionary + ctrl_x_mode = CTRL_X_DICTIONARY; + break; + case Ctrl_R: + // When CTRL-R is followed by '=', don't trigger register completion + // This allows expressions like <C-R>=func()<CR> to work normally + if (vpeekc() == '=') + break; + ctrl_x_mode = CTRL_X_REGISTER; + break; + case Ctrl_T: + // complete words from a thesaurus + ctrl_x_mode = CTRL_X_THESAURUS; + break; +#ifdef FEAT_COMPL_FUNC + case Ctrl_U: + // user defined completion + ctrl_x_mode = CTRL_X_FUNCTION; + break; + case Ctrl_O: + // omni completion + ctrl_x_mode = CTRL_X_OMNI; + break; +#endif + case 's': + case Ctrl_S: + // complete spelling suggestions + ctrl_x_mode = CTRL_X_SPELL; +#ifdef FEAT_SPELL + ++emsg_off; // Avoid getting the E756 error twice. + spell_back_to_badword(); + --emsg_off; +#endif + break; + case Ctrl_RSB: + // complete tag names + ctrl_x_mode = CTRL_X_TAGS; + break; +#ifdef FEAT_FIND_ID + case Ctrl_I: + case K_S_TAB: + // complete keywords from included files + ctrl_x_mode = CTRL_X_PATH_PATTERNS; + break; + case Ctrl_D: + // complete definitions from included files + ctrl_x_mode = CTRL_X_PATH_DEFINES; + break; +#endif + case Ctrl_V: + case Ctrl_Q: + // complete mnv commands + ctrl_x_mode = CTRL_X_CMDLINE; + break; + case Ctrl_Z: + // stop completion + ctrl_x_mode = CTRL_X_NORMAL; + edit_submode = NULL; + showmode(); + retval = TRUE; + break; + case Ctrl_P: + case Ctrl_N: + // ^X^P means LOCAL expansion if nothing interrupted (eg we + // just started ^X mode, or there were enough ^X's to cancel + // the previous mode, say ^X^F^X^X^P or ^P^X^X^X^P, see below) + // do normal expansion when interrupting a different mode (say + // ^X^F^X^P or ^P^X^X^P, see below) + // nothing changes if interrupting mode 0, (eg, the flag + // doesn't change when going to ADDING mode -- Acevedo + if (!(compl_cont_status & CONT_INTRPT)) + compl_cont_status |= CONT_LOCAL; + else if (compl_cont_mode != 0) + compl_cont_status &= ~CONT_LOCAL; + // FALLTHROUGH + default: + // If we have typed at least 2 ^X's... for modes != 0, we set + // compl_cont_status = 0 (eg, as if we had just started ^X + // mode). + // For mode 0, we set "compl_cont_mode" to an impossible + // value, in both cases ^X^X can be used to restart the same + // mode (avoiding ADDING mode). + // Undocumented feature: In a mode != 0 ^X^P and ^X^X^P start + // 'complete' and local ^P expansions respectively. + // In mode 0 an extra ^X is needed since ^X^P goes to ADDING + // mode -- Acevedo + if (c == Ctrl_X) + { + if (compl_cont_mode != 0) + compl_cont_status = 0; + else + compl_cont_mode = CTRL_X_NOT_DEFINED_YET; + } + ctrl_x_mode = CTRL_X_NORMAL; + edit_submode = NULL; + showmode(); + break; + } + + return retval; +} + +/* + * Trigger CompleteDone event and adds relevant information to v:event + */ + static void +trigger_complete_done_event(int mode UNUSED, char_u *word UNUSED) +{ +#if defined(FEAT_EVAL) + save_v_event_T save_v_event; + dict_T *v_event = get_v_event(&save_v_event); + char_u *mode_str = NULL; + + mode = mode & ~CTRL_X_WANT_IDENT; + if (ctrl_x_mode_names[mode]) + mode_str = (char_u *)ctrl_x_mode_names[mode]; + + (void)dict_add_string(v_event, "complete_word", + word == NULL ? (char_u *)"" : word); + (void)dict_add_string(v_event, "complete_type", + mode_str != NULL ? mode_str : (char_u *)""); + + dict_set_items_ro(v_event); +#endif + ins_apply_autocmds(EVENT_COMPLETEDONE); + +#if defined(FEAT_EVAL) + restore_v_event(v_event, &save_v_event); +#endif +} + +/* + * Stop insert completion mode + */ + static int +ins_compl_stop(int c, int prev_mode, int retval) +{ + int want_cindent; + char_u *word = NULL; + + // Remove pre-inserted text when present. + if (ins_compl_preinsert_effect() && ins_compl_win_active(curwin)) + ins_compl_delete(); + + // Get here when we have finished typing a sequence of ^N and + // ^P or other completion characters in CTRL-X mode. Free up + // memory that was used, and make sure we can redo the insert. + if (compl_curr_match != NULL || compl_leader.string != NULL || c == Ctrl_E) + { + char_u *ptr = NULL; + + // If any of the original typed text has been changed, eg when + // ignorecase is set, we must add back-spaces to the redo + // buffer. We add as few as necessary to delete just the part + // of the original text that has changed. + // When using the longest match, edited the match or used + // CTRL-E then don't use the current match. + if (compl_curr_match != NULL && compl_used_match && c != Ctrl_E) + ptr = compl_curr_match->cp_str.string; + ins_compl_fixRedoBufForLeader(ptr); + } + + want_cindent = (get_can_cindent() && cindent_on()); + + // When completing whole lines: fix indent for 'cindent'. + // Otherwise, break line if it's too long. + if (compl_cont_mode == CTRL_X_WHOLE_LINE) + { + // re-indent the current line + if (want_cindent) + { + do_c_expr_indent(); + want_cindent = FALSE; // don't do it again + } + } + else + { + int prev_col = curwin->w_cursor.col; + + // put the cursor on the last char, for 'tw' formatting + if (prev_col > 0) + dec_cursor(); + // only format when something was inserted + if (!arrow_used && !ins_need_undo_get() && c != Ctrl_E) + insertchar(NUL, 0, -1); + if (prev_col > 0 + && ml_get_curline()[curwin->w_cursor.col] != NUL) + inc_cursor(); + } + + // If the popup menu is displayed pressing CTRL-Y means accepting + // the selection without inserting anything. When + // compl_enter_selects is set the Enter key does the same. + if ((c == Ctrl_Y || (compl_enter_selects + && (c == CAR || c == K_KENTER || c == NL))) + && pum_visible()) + { + word = mnv_strsave(compl_shown_match->cp_str.string); + retval = TRUE; + } + + // CTRL-E means completion is Ended, go back to the typed text. + // but only do this, if the Popup is still visible + if (c == Ctrl_E) + { + char_u *p = NULL; + size_t plen = 0; + + ins_compl_delete(); + if (compl_leader.string != NULL) + { + p = compl_leader.string; + plen = compl_leader.length; + } + else if (compl_first_match != NULL) + { + p = compl_orig_text.string; + plen = compl_orig_text.length; + } + if (p != NULL) + { + int compl_len = get_compl_len(); + + if ((int)plen > compl_len) + ins_compl_insert_bytes(p + compl_len, (int)plen - compl_len); + } + retval = TRUE; + } + + auto_format(FALSE, TRUE); + + // Trigger the CompleteDonePre event to give scripts a chance to + // act upon the completion before clearing the info, and restore + // ctrl_x_mode, so that complete_info() can be used. + ctrl_x_mode = prev_mode; + ins_apply_autocmds(EVENT_COMPLETEDONEPRE); + + ins_compl_free(); + compl_started = FALSE; + compl_matches = 0; + if (!shortmess(SHM_COMPLETIONMENU)) + msg_clr_cmdline(); // necessary for "noshowmode" + ctrl_x_mode = CTRL_X_NORMAL; + compl_enter_selects = FALSE; + if (edit_submode != NULL) + { + edit_submode = NULL; + showmode(); + } + compl_autocomplete = FALSE; + compl_from_nonkeyword = FALSE; + compl_best_matches = 0; + compl_ins_end_col = 0; + + if (c == Ctrl_C && cmdwin_type != 0) + // Avoid the popup menu remains displayed when leaving the + // command line window. + update_screen(0); + // Indent now if a key was typed that is in 'cinkeys'. + if (want_cindent && in_cinkeys(KEY_COMPLETE, ' ', inindent(0))) + do_c_expr_indent(); + // Trigger the CompleteDone event to give scripts a chance to act + // upon the end of completion. + trigger_complete_done_event(prev_mode, word); + mnv_free(word); + + return retval; +} + +/* + * Cancel completion. + */ + int +ins_compl_cancel(void) +{ + return ins_compl_stop(' ', ctrl_x_mode, TRUE); +} + +/* + * Prepare for Insert mode completion, or stop it. + * Called just after typing a character in Insert mode. + * Returns TRUE when the character is not to be inserted; + */ + int +ins_compl_prep(int c) +{ + int retval = FALSE; + int prev_mode = ctrl_x_mode; + + // Forget any previous 'special' messages if this is actually + // a ^X mode key - bar ^R, in which case we wait to see what it gives us. + if (c != Ctrl_R && mnv_is_ctrl_x_key(c)) + edit_submode_extra = NULL; + + // Ignore end of Select mode mapping and mouse scroll/movement. + if (c == K_SELECT || c == K_MOUSEDOWN || c == K_MOUSEUP + || c == K_MOUSELEFT || c == K_MOUSERIGHT || c == K_MOUSEMOVE + || c == K_COMMAND || c == K_SCRIPT_COMMAND) + return retval; + +#ifdef FEAT_PROP_POPUP + // Ignore mouse events in a popup window + if (is_mouse_key(c)) + { + // Ignore drag and release events, the position does not need to be in + // the popup and it may have just closed. + if (c == K_LEFTRELEASE + || c == K_LEFTRELEASE_NM + || c == K_MIDDLERELEASE + || c == K_RIGHTRELEASE + || c == K_X1RELEASE + || c == K_X2RELEASE + || c == K_LEFTDRAG + || c == K_MIDDLEDRAG + || c == K_RIGHTDRAG + || c == K_X1DRAG + || c == K_X2DRAG) + return retval; + if (popup_visible) + { + int row = mouse_row; + int col = mouse_col; + win_T *wp = mouse_find_win(&row, &col, FIND_POPUP); + + if (wp != NULL && WIN_IS_POPUP(wp)) + return retval; + } + } +#endif + + if (ctrl_x_mode == CTRL_X_CMDLINE_CTRL_X && c != Ctrl_X) + { + if (c == Ctrl_V || c == Ctrl_Q || c == Ctrl_Z || ins_compl_pum_key(c) + || !mnv_is_ctrl_x_key(c)) + { + // Not starting another completion mode. + ctrl_x_mode = CTRL_X_CMDLINE; + + // CTRL-X CTRL-Z should stop completion without inserting anything + if (c == Ctrl_Z) + retval = TRUE; + } + else + { + ctrl_x_mode = CTRL_X_CMDLINE; + + // Other CTRL-X keys first stop completion, then start another + // completion mode. + ins_compl_prep(' '); + ctrl_x_mode = CTRL_X_NOT_DEFINED_YET; + } + } + + // Set "compl_get_longest" when finding the first matches. + if (ctrl_x_mode_not_defined_yet() + || (ctrl_x_mode_normal() && !compl_started)) + { + compl_get_longest = (get_cot_flags() & COT_LONGEST); + compl_used_match = TRUE; + } + + 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_not_default()) + { + // We're already in CTRL-X mode, do we stay in it? + if (!mnv_is_ctrl_x_key(c)) + { + ctrl_x_mode = ctrl_x_mode_scroll() ? CTRL_X_NORMAL : CTRL_X_FINISHED; + edit_submode = NULL; + } + showmode(); + } + + if (compl_started || ctrl_x_mode == CTRL_X_FINISHED) + { + // 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_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) + // Trigger the CompleteDone event to give scripts a chance to act + // upon the (possibly failed) completion. + trigger_complete_done_event(ctrl_x_mode, NULL); + + may_trigger_modechanged(); + + // reset continue_* if we left expansion-mode, if we stay they'll be + // (re)set properly in ins_complete() + if (!mnv_is_ctrl_x_key(c)) + { + compl_cont_status = 0; + compl_cont_mode = 0; + } + + return retval; +} + +/* + * Fix the redo buffer for the completion leader replacing some of the typed + * text. This inserts backspaces and appends the changed text. + * "ptr" is the known leader text or NUL. + */ + static void +ins_compl_fixRedoBufForLeader(char_u *ptr_arg) +{ + int len = 0; + char_u *p; + char_u *ptr = ptr_arg; + + if (ptr == NULL) + { + if (compl_leader.string != NULL) + ptr = compl_leader.string; + else + return; // nothing to do + } + if (compl_orig_text.string != NULL) + { + p = compl_orig_text.string; + // Find length of common prefix between original text and new completion + while (p[len] != NUL && p[len] == ptr[len]) + len++; + // Adjust length to not break inside a multi-byte character + if (len > 0) + len -= (*mb_head_off)(p, p + len); + // Add backspace characters for each remaining character in + // original text + for (p += len; *p != NUL; MB_PTR_ADV(p)) + AppendCharToRedobuff(K_BS); + } + if (ptr != NULL) + AppendToRedobuffLit(ptr + len, -1); +} + +/* + * Loops through the list of windows, loaded-buffers or non-loaded-buffers + * (depending on flag) starting from buf and looking for a non-scanned + * buffer (other than curbuf). curbuf is special, if it is called with + * buf=curbuf then it has to be the first call for a given flag/expansion. + * + * Returns the buffer to scan, if any, otherwise returns curbuf -- Acevedo + */ + static buf_T * +ins_compl_next_buf(buf_T *buf, int flag) +{ + static win_T *wp = NULL; + int skip_buffer; + + if (flag == 'w') // just windows + { + if (buf == curbuf || !win_valid(wp)) + // first call for this flag/expansion or window was closed + wp = curwin; + + while (TRUE) + { + // Move to next window (wrap to first window if at the end) + wp = (wp->w_next != NULL) ? wp->w_next : firstwin; + // Break if we're back at start or found an unscanned buffer + if (wp == curwin || !wp->w_buffer->b_scanned) + break; + } + buf = wp->w_buffer; + } + else + { + // 'b' (just loaded buffers), 'u' (just non-loaded buffers) or 'U' + // (unlisted buffers) + // When completing whole lines skip unloaded buffers. + while (TRUE) + { + // Move to next buffer (wrap to first buffer if at the end) + buf = (buf->b_next != NULL) ? buf->b_next : firstbuf; + // Break if we're back at start buffer + if (buf == curbuf) + break; + + // Check buffer conditions based on flag + if (flag == 'U') + skip_buffer = buf->b_p_bl; + else + skip_buffer = !buf->b_p_bl || + (buf->b_ml.ml_mfp == NULL) != (flag == 'u'); + + // Break if we found a buffer that matches our criteria + if (!skip_buffer && !buf->b_scanned) + break; + } + } + return buf; +} + +/* + * Count the number of entries in the 'complete' option (curbuf->b_p_cpt). + * Each non-empty, comma-separated segment is counted as one entry. + */ + static int +get_cpt_sources_count(void) +{ + char_u dummy[LSIZE]; + int count = 0; + char_u *p; + + for (p = curbuf->b_p_cpt; *p != NUL; ) + { + while (*p == ',' || *p == ' ') + p++; // Skip delimiters + + if (*p != NUL) + { + (void)copy_option_part(&p, dummy, LSIZE, ","); // Advance p + count++; + } + } + + return count; +} + +#ifdef FEAT_COMPL_FUNC + +# ifdef FEAT_EVAL +static callback_T cfu_cb; // 'completefunc' callback function +static callback_T ofu_cb; // 'omnifunc' callback function +static callback_T tsrfu_cb; // 'thesaurusfunc' callback function +static callback_T *cpt_cb; // Callback functions associated with F{func} +static int cpt_cb_count; // Number of cpt callbacks +# endif + +/* + * Copy a global callback function to a buffer local callback. + */ + static void +copy_global_to_buflocal_cb(callback_T *globcb, callback_T *bufcb) +{ + free_callback(bufcb); + if (globcb->cb_name != NULL && *globcb->cb_name != NUL) + copy_callback(bufcb, globcb); +} + +/* + * Parse the 'completefunc' option value and set the callback function. + * Invoked when the 'completefunc' option is set. The option value can be a + * name of a function (string), or function(<name>) or funcref(<name>) or a + * lambda expression. + */ + char * +did_set_completefunc(optset_T *args) +{ + int retval; + + if (args->os_flags & OPT_LOCAL) + retval = option_set_callback_func(args->os_newval.string, + &curbuf->b_cfu_cb); + else + { + retval = option_set_callback_func(args->os_newval.string, &cfu_cb); + if (retval == OK && !(args->os_flags & OPT_GLOBAL)) + set_buflocal_cfu_callback(curbuf); + } + + return retval == FAIL ? e_invalid_argument : NULL; +} + +/* + * Copy the global 'completefunc' callback function to the buffer-local + * 'completefunc' callback for "buf". + */ + void +set_buflocal_cfu_callback(buf_T *buf UNUSED) +{ +# ifdef FEAT_EVAL + copy_global_to_buflocal_cb(&cfu_cb, &buf->b_cfu_cb); +# endif +} + +/* + * Parse the 'omnifunc' option value and set the callback function. + * Invoked when the 'omnifunc' option is set. The option value can be a + * name of a function (string), or function(<name>) or funcref(<name>) or a + * lambda expression. + */ + char * +did_set_omnifunc(optset_T *args) +{ + int retval; + + if (args->os_flags & OPT_LOCAL) + retval = option_set_callback_func(args->os_newval.string, + &curbuf->b_ofu_cb); + else + { + retval = option_set_callback_func(args->os_newval.string, &ofu_cb); + if (retval == OK && !(args->os_flags & OPT_GLOBAL)) + set_buflocal_ofu_callback(curbuf); + } + + return retval == FAIL ? e_invalid_argument : NULL; +} + +/* + * Copy the global 'omnifunc' callback function to the buffer-local 'omnifunc' + * callback for "buf". + */ + void +set_buflocal_ofu_callback(buf_T *buf UNUSED) +{ +# ifdef FEAT_EVAL + copy_global_to_buflocal_cb(&ofu_cb, &buf->b_ofu_cb); +# endif +} + +/* + * Free an array of 'complete' F{func} callbacks and set the pointer to NULL. + */ + void +clear_cpt_callbacks(callback_T **callbacks, int count) +{ + if (callbacks == NULL || *callbacks == NULL) + return; + + for (int i = 0; i < count; i++) + free_callback(&(*callbacks)[i]); + + MNV_CLEAR(*callbacks); +} + +/* + * Copies a list of callback_T structs from src to *dest, clearing any existing + * entries and allocating memory for the destination. + */ + static int +copy_cpt_callbacks(callback_T **dest, int *dest_cnt, callback_T *src, int cnt) +{ + if (cnt == 0) + return OK; + + clear_cpt_callbacks(dest, *dest_cnt); + *dest_cnt = 0; + + *dest = ALLOC_CLEAR_MULT(callback_T, cnt); + if (*dest == NULL) + return FAIL; + + *dest_cnt = cnt; + + for (int i = 0; i < cnt; i++) + if (src[i].cb_name != NULL && *(src[i].cb_name) != NUL) + copy_callback(&(*dest)[i], &src[i]); + + return OK; +} + +/* + * Copy global 'complete' F{func} callbacks into the given buffer's local + * callback array. Clears any existing buffer-local callbacks first. + */ + void +set_buflocal_cpt_callbacks(buf_T *buf UNUSED) +{ +# ifdef FEAT_EVAL + if (buf == NULL || cpt_cb_count == 0) + return; + (void)copy_cpt_callbacks(&buf->b_p_cpt_cb, &buf->b_p_cpt_count, cpt_cb, + cpt_cb_count); +# endif +} + +/* + * Parse 'complete' option and initialize F{func} callbacks. + * Frees any existing callbacks and allocates new ones. + * Only F{func} entries are processed; others are ignored. + */ + int +set_cpt_callbacks(optset_T *args) +{ + char_u buf[LSIZE]; + char_u *p; + int idx = 0; + int slen; + int count; + int local = (args->os_flags & OPT_LOCAL) != 0; + + if (curbuf == NULL) + return FAIL; + + clear_cpt_callbacks(&curbuf->b_p_cpt_cb, curbuf->b_p_cpt_count); + curbuf->b_p_cpt_count = 0; + + count = get_cpt_sources_count(); + if (count == 0) + return OK; + + curbuf->b_p_cpt_cb = ALLOC_CLEAR_MULT(callback_T, count); + if (curbuf->b_p_cpt_cb == NULL) + return FAIL; + curbuf->b_p_cpt_count = count; + + for (p = curbuf->b_p_cpt; *p != NUL; ) + { + while (*p == ',' || *p == ' ') + p++; // Skip delimiters + + if (*p != NUL) + { + slen = copy_option_part(&p, buf, LSIZE, ","); // Advance p + if (slen > 0 && buf[0] == 'F' && buf[1] != NUL) + { + char_u *caret; + caret = mnv_strchr(buf, '^'); + if (caret != NULL) + *caret = NUL; + + if (option_set_callback_func(buf + 1, &curbuf->b_p_cpt_cb[idx]) + != OK) + curbuf->b_p_cpt_cb[idx].cb_name = NULL; + } + idx++; + } + } + + if (!local) // ':set' used instead of ':setlocal' + // Cache the callback array + if (copy_cpt_callbacks(&cpt_cb, &cpt_cb_count, curbuf->b_p_cpt_cb, + curbuf->b_p_cpt_count) != OK) + return FAIL; + + return OK; +} + +/* + * Parse the 'thesaurusfunc' option value and set the callback function. + * Invoked when the 'thesaurusfunc' option is set. The option value can be a + * name of a function (string), or function(<name>) or funcref(<name>) or a + * lambda expression. + */ + char * +did_set_thesaurusfunc(optset_T *args UNUSED) +{ + int retval; + + if (args->os_flags & OPT_LOCAL) + // buffer-local option set + retval = option_set_callback_func(curbuf->b_p_tsrfu, + &curbuf->b_tsrfu_cb); + else + { + // global option set + retval = option_set_callback_func(p_tsrfu, &tsrfu_cb); + // when using :set, free the local callback + if (!(args->os_flags & OPT_GLOBAL)) + free_callback(&curbuf->b_tsrfu_cb); + } + + return retval == FAIL ? e_invalid_argument : NULL; +} + +/* + * Mark "copyID" references in an array of F{func} callbacks so that they are + * not garbage collected. + */ + int +set_ref_in_cpt_callbacks(callback_T *callbacks, int count, int copyID) +{ + int abort = FALSE; + + if (callbacks == NULL) + return FALSE; + + for (int i = 0; i < count; i++) + abort = abort || set_ref_in_callback(&callbacks[i], copyID); + return abort; +} + +/* + * Mark the global 'completefunc' 'omnifunc' and 'thesaurusfunc' callbacks with + * "copyID" so that they are not garbage collected. + */ + int +set_ref_in_insexpand_funcs(int copyID) +{ + int abort = set_ref_in_callback(&cfu_cb, copyID); + abort = abort || set_ref_in_callback(&ofu_cb, copyID); + abort = abort || set_ref_in_callback(&tsrfu_cb, copyID); + abort = abort || set_ref_in_cpt_callbacks(cpt_cb, cpt_cb_count, copyID); + + return abort; +} + +/* + * Get the user-defined completion function name for completion "type" + */ + static char_u * +get_complete_funcname(int type) +{ + switch (type) + { + case CTRL_X_FUNCTION: + return curbuf->b_p_cfu; + case CTRL_X_OMNI: + return curbuf->b_p_ofu; + case CTRL_X_THESAURUS: + return *curbuf->b_p_tsrfu == NUL ? p_tsrfu : curbuf->b_p_tsrfu; + default: + return (char_u *)""; + } +} + +/* + * Get the callback to use for insert mode completion. + */ + static callback_T * +get_insert_callback(int type) +{ + if (type == CTRL_X_FUNCTION) + return &curbuf->b_cfu_cb; + if (type == CTRL_X_OMNI) + return &curbuf->b_ofu_cb; + // CTRL_X_THESAURUS + return (*curbuf->b_p_tsrfu != NUL) ? &curbuf->b_tsrfu_cb : &tsrfu_cb; +} + +/* + * Execute user defined complete function 'completefunc', 'omnifunc' or + * 'thesaurusfunc', and get matches in "matches". + * "type" can be one of CTRL_X_OMNI, CTRL_X_FUNCTION, or CTRL_X_THESAURUS. + * Callback function "cb" is set if triggered by a function in the 'cpt' + * option; otherwise, it is NULL. + */ + static void +expand_by_function(int type, char_u *base, callback_T *cb) +{ + list_T *matchlist = NULL; + dict_T *matchdict = NULL; + typval_T args[3]; + char_u *funcname; + pos_T pos; + typval_T rettv; + int save_State = State; + int retval; + int is_cpt_function = (cb != NULL); + + if (!is_cpt_function) + { + funcname = get_complete_funcname(type); + if (*funcname == NUL) + return; + cb = get_insert_callback(type); + } + + // Call 'completefunc' to obtain the list of matches. + args[0].v_type = VAR_NUMBER; + args[0].vval.v_number = 0; + args[1].v_type = VAR_STRING; + args[1].vval.v_string = base != NULL ? base : (char_u *)""; + args[2].v_type = VAR_UNKNOWN; + + pos = curwin->w_cursor; + // Lock the text to avoid weird things from happening. Also disallow + // switching to another window, it should not be needed and may end up in + // Insert mode in another buffer. + ++textlock; + + retval = call_callback(cb, 0, &rettv, 2, args); + + // Call a function, which returns a list or dict. + if (retval == OK) + { + switch (rettv.v_type) + { + case VAR_LIST: + matchlist = rettv.vval.v_list; + break; + case VAR_DICT: + matchdict = rettv.vval.v_dict; + break; + case VAR_SPECIAL: + if (rettv.vval.v_number == VVAL_NONE) + compl_opt_suppress_empty = TRUE; + // FALLTHROUGH + default: + // TODO: Give error message? + clear_tv(&rettv); + break; + } + } + --textlock; + + curwin->w_cursor = pos; // restore the cursor position + check_cursor(); // make sure cursor position is valid, just in case + validate_cursor(); + if (!EQUAL_POS(curwin->w_cursor, pos)) + { + emsg(_(e_complete_function_deleted_text)); + goto theend; + } + + if (matchlist != NULL) + ins_compl_add_list(matchlist); + else if (matchdict != NULL) + ins_compl_add_dict(matchdict); + +theend: + // Restore State, it might have been changed. + State = save_State; + + if (matchdict != NULL) + dict_unref(matchdict); + if (matchlist != NULL) + list_unref(matchlist); +} +#endif // FEAT_COMPL_FUNC + +#if defined(FEAT_COMPL_FUNC) || defined(FEAT_EVAL) + + static inline int +get_user_highlight_attr(char_u *hlname) +{ + if (hlname != NULL && *hlname != NUL) + return syn_name2attr(hlname); + return -1; +} +/* + * Add a match to the list of matches from a typeval_T. + * If the given string is already in the list of completions, then return + * NOTDONE, otherwise add it to the list and return OK. If there is an error, + * maybe because alloc() returns NULL, then FAIL is returned. + * When "fast" is TRUE use fast_breakcheck() instead of ui_breakcheck(). + */ + static int +ins_compl_add_tv(typval_T *tv, int dir, int fast) +{ + char_u *word; + int dup = FALSE; + int empty = FALSE; + int flags = fast ? CP_FAST : 0; + char_u *(cptext[CPT_COUNT]); + typval_T user_data; + int status; + char_u *user_abbr_hlname; + char_u *user_kind_hlname; + int user_hl[2] = { -1, -1 }; + + user_data.v_type = VAR_UNKNOWN; + if (tv->v_type == VAR_DICT && tv->vval.v_dict != NULL) + { + word = dict_get_string(tv->vval.v_dict, "word", FALSE); + cptext[CPT_ABBR] = dict_get_string(tv->vval.v_dict, "abbr", FALSE); + cptext[CPT_MENU] = dict_get_string(tv->vval.v_dict, "menu", FALSE); + cptext[CPT_KIND] = dict_get_string(tv->vval.v_dict, "kind", FALSE); + cptext[CPT_INFO] = dict_get_string(tv->vval.v_dict, "info", FALSE); + + user_abbr_hlname = dict_get_string(tv->vval.v_dict, "abbr_hlgroup", FALSE); + user_hl[0] = get_user_highlight_attr(user_abbr_hlname); + + user_kind_hlname = dict_get_string(tv->vval.v_dict, "kind_hlgroup", FALSE); + user_hl[1] = get_user_highlight_attr(user_kind_hlname); + + dict_get_tv(tv->vval.v_dict, "user_data", &user_data); + if (dict_get_string(tv->vval.v_dict, "icase", FALSE) != NULL + && dict_get_number(tv->vval.v_dict, "icase")) + flags |= CP_ICASE; + if (dict_get_string(tv->vval.v_dict, "dup", FALSE) != NULL) + dup = dict_get_number(tv->vval.v_dict, "dup"); + if (dict_get_string(tv->vval.v_dict, "empty", FALSE) != NULL) + empty = dict_get_number(tv->vval.v_dict, "empty"); + if (dict_get_string(tv->vval.v_dict, "equal", FALSE) != NULL + && dict_get_number(tv->vval.v_dict, "equal")) + flags |= CP_EQUAL; + } + else + { + word = tv_get_string_chk(tv); + CLEAR_FIELD(cptext); + } + if (word == NULL || (!empty && *word == NUL)) + { + clear_tv(&user_data); + return FAIL; + } + status = ins_compl_add(word, -1, NULL, cptext, + &user_data, dir, flags, dup, user_hl, FUZZY_SCORE_NONE); + if (status != OK) + clear_tv(&user_data); + return status; +} + +/* + * Add completions from a list. + */ + static void +ins_compl_add_list(list_T *list) +{ + listitem_T *li; + int dir = compl_direction; + + // Go through the List with matches and add each of them. + CHECK_LIST_MATERIALIZE(list); + FOR_ALL_LIST_ITEMS(list, li) + { + if (ins_compl_add_tv(&li->li_tv, dir, TRUE) == OK) + // if dir was BACKWARD then honor it just once + dir = FORWARD; + else if (did_emsg) + break; + } +} + +/* + * Add completions from a dict. + */ + static void +ins_compl_add_dict(dict_T *dict) +{ + dictitem_T *di_refresh; + dictitem_T *di_words; + + // Check for optional "refresh" item. + compl_opt_refresh_always = FALSE; + di_refresh = dict_find(dict, (char_u *)"refresh", 7); + if (di_refresh != NULL && di_refresh->di_tv.v_type == VAR_STRING) + { + char_u *v = di_refresh->di_tv.vval.v_string; + + if (v != NULL && STRCMP(v, (char_u *)"always") == 0) + compl_opt_refresh_always = TRUE; + } + + // Add completions from a "words" list. + di_words = dict_find(dict, (char_u *)"words", 5); + if (di_words != NULL && di_words->di_tv.v_type == VAR_LIST) + ins_compl_add_list(di_words->di_tv.vval.v_list); +} + +/* + * Start completion for the complete() function. + * "startcol" is where the matched text starts (1 is first column). + * "list" is the list of matches. + */ + static 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; + unsigned int cur_cot_flags = get_cot_flags(); + int compl_longest = (cur_cot_flags & COT_LONGEST) != 0; + int compl_no_insert = (cur_cot_flags & COT_NOINSERT) != 0; + int compl_no_select = (cur_cot_flags & COT_NOSELECT) != 0; + + // If already doing completions stop it. + if (ctrl_x_mode_not_default()) + ins_compl_prep(' '); + ins_compl_clear(); + ins_compl_free(); + compl_get_longest = compl_longest; + + compl_direction = FORWARD; + if (startcol > curwin->w_cursor.col) + startcol = curwin->w_cursor.col; + compl_col = startcol; + compl_lnum = curwin->w_cursor.lnum; + compl_length = (int)curwin->w_cursor.col - (int)startcol; + // compl_pattern doesn't need to be set + compl_orig_text.string = mnv_strnsave(ml_get_curline() + compl_col, + (size_t)compl_length); + if (p_ic) + flags |= CP_ICASE; + if (compl_orig_text.string == NULL) + { + compl_orig_text.length = 0; + return; + } + compl_orig_text.length = (size_t)compl_length; + if (ins_compl_add(compl_orig_text.string, + (int)compl_orig_text.length, NULL, NULL, NULL, 0, + flags | CP_FAST, FALSE, NULL, FUZZY_SCORE_NONE) != OK) + return; + + ctrl_x_mode = CTRL_X_EVAL; + + ins_compl_add_list(list); + compl_matches = ins_compl_make_cyclic(); + compl_started = TRUE; + compl_used_match = TRUE; + compl_cont_status = 0; + + compl_curr_match = compl_first_match; + int no_select = compl_no_select || compl_longest; + if (compl_no_insert || no_select) + { + ins_complete(K_DOWN, FALSE); + if (no_select) + // Down/Up has no real effect. + ins_complete(K_UP, FALSE); + } + else + ins_complete(Ctrl_N, FALSE); + compl_enter_selects = compl_no_insert; + + // Lazily show the popup menu, unless we got interrupted. + if (!compl_interrupted) + show_pum(save_w_wrow, save_w_leftcol); + may_trigger_modechanged(); + out_flush(); +} + +/* + * "complete()" function + */ + void +f_complete(typval_T *argvars, typval_T *rettv UNUSED) +{ + if (in_mnv9script() + && (check_for_number_arg(argvars, 0) == FAIL + || check_for_list_arg(argvars, 1) == FAIL)) + return; + + if ((State & MODE_INSERT) == 0) + { + emsg(_(e_complete_can_only_be_used_in_insert_mode)); + return; + } + + // Check for undo allowed here, because if something was already inserted + // the line was already saved for undo and this check isn't done. + if (!undo_allowed()) + return; + + if (check_for_nonnull_list_arg(argvars, 1) != FAIL) + { + int startcol = (int)tv_get_number_chk(&argvars[0], NULL); + if (startcol > 0) + set_completion(startcol - 1, argvars[1].vval.v_list); + } +} + +/* + * "complete_add()" function + */ + void +f_complete_add(typval_T *argvars, typval_T *rettv) +{ + if (in_mnv9script() && check_for_string_or_dict_arg(argvars, 0) == FAIL) + return; + + rettv->vval.v_number = ins_compl_add_tv(&argvars[0], 0, FALSE); +} + +/* + * "complete_check()" function + */ + void +f_complete_check(typval_T *argvars UNUSED, typval_T *rettv) +{ + int save_RedrawingDisabled = RedrawingDisabled; + RedrawingDisabled = 0; + + ins_compl_check_keys(0, TRUE); + rettv->vval.v_number = ins_compl_interrupted(); + + RedrawingDisabled = save_RedrawingDisabled; +} + +/* + * Return Insert completion mode name string + */ + static char_u * +ins_compl_mode(void) +{ + if (ctrl_x_mode_not_defined_yet() || ctrl_x_mode_scroll() || compl_started) + return (char_u *)ctrl_x_mode_names[ctrl_x_mode & ~CTRL_X_WANT_IDENT]; + + return (char_u *)""; +} + +/* + * Assign the sequence number to all the completion matches which don't have + * one assigned yet. + */ + static void +ins_compl_update_sequence_numbers(void) +{ + int number = 0; + compl_T *match; + + 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 + && !is_first_match(match); match = match->cp_prev) + if (match->cp_number != -1) + { + number = match->cp_number; + break; + } + if (match != NULL) + // go up and assign all numbers which are not assigned yet + for (match = match->cp_next; + match != NULL && match->cp_number == -1; + match = match->cp_next) + match->cp_number = ++number; + } + else // BACKWARD + { + // 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 + && !is_first_match(match); match = match->cp_next) + { + if (match->cp_number != -1) + { + number = match->cp_number; + break; + } + } + if (match != NULL) + { + // go down and assign all numbers which are not assigned yet + for (match = match->cp_prev; match + && match->cp_number == -1; + match = match->cp_prev) + match->cp_number = ++number; + } + } +} + +/* + * Fill the dict of complete_info + */ + static void +fill_complete_info_dict(dict_T *di, compl_T *match, int add_match) +{ + dict_add_string(di, "word", match->cp_str.string); + dict_add_string(di, "abbr", match->cp_text[CPT_ABBR]); + dict_add_string(di, "menu", match->cp_text[CPT_MENU]); + dict_add_string(di, "kind", match->cp_text[CPT_KIND]); + dict_add_string(di, "info", match->cp_text[CPT_INFO]); + if (add_match) + dict_add_bool(di, "match", match->cp_in_match_array); + if (match->cp_user_data.v_type == VAR_UNKNOWN) + // Add an empty string for backwards compatibility + dict_add_string(di, "user_data", (char_u *)""); + else + dict_add_tv(di, "user_data", &match->cp_user_data); +} + +/* + * Get complete information + */ + static void +get_complete_info(list_T *what_list, dict_T *retdict) +{ + int ret = OK; + listitem_T *item; +# define CI_WHAT_MODE 0x01 +# define CI_WHAT_PUM_VISIBLE 0x02 +# define CI_WHAT_ITEMS 0x04 +# define CI_WHAT_SELECTED 0x08 +# define CI_WHAT_COMPLETED 0x10 +# define CI_WHAT_MATCHES 0x20 +# define CI_WHAT_PREINSERTED_TEXT 0x40 +# define CI_WHAT_ALL 0xff + int what_flag; + + if (what_list == NULL) + what_flag = CI_WHAT_ALL & ~(CI_WHAT_MATCHES | CI_WHAT_COMPLETED); + else + { + what_flag = 0; + CHECK_LIST_MATERIALIZE(what_list); + FOR_ALL_LIST_ITEMS(what_list, item) + { + char_u *what = tv_get_string(&item->li_tv); + + if (STRCMP(what, "mode") == 0) + what_flag |= CI_WHAT_MODE; + else if (STRCMP(what, "pum_visible") == 0) + what_flag |= CI_WHAT_PUM_VISIBLE; + else if (STRCMP(what, "items") == 0) + what_flag |= CI_WHAT_ITEMS; + else if (STRCMP(what, "selected") == 0) + what_flag |= CI_WHAT_SELECTED; + else if (STRCMP(what, "completed") == 0) + what_flag |= CI_WHAT_COMPLETED; + else if (STRCMP(what, "preinserted_text") == 0) + what_flag |= CI_WHAT_PREINSERTED_TEXT; + else if (STRCMP(what, "matches") == 0) + what_flag |= CI_WHAT_MATCHES; + } + } + + if (ret == OK && (what_flag & CI_WHAT_MODE)) + ret = dict_add_string(retdict, "mode", ins_compl_mode()); + + if (ret == OK && (what_flag & CI_WHAT_PUM_VISIBLE)) + ret = dict_add_number(retdict, "pum_visible", pum_visible()); + + if (ret == OK && (what_flag & CI_WHAT_PREINSERTED_TEXT)) + { + char_u *line = ml_get_curline(); + int len = compl_ins_end_col - curwin->w_cursor.col; + + ret = dict_add_string_len(retdict, "preinserted_text", + (len > 0) ? line + curwin->w_cursor.col : (char_u *)"", (len > 0) ? len : 0); + } + + if (ret == OK && (what_flag & (CI_WHAT_ITEMS | CI_WHAT_SELECTED + | CI_WHAT_MATCHES | CI_WHAT_COMPLETED))) + { + list_T *li = NULL; + dict_T *di; + compl_T *match; + int selected_idx = -1; + int has_items = what_flag & CI_WHAT_ITEMS; + int has_matches = what_flag & CI_WHAT_MATCHES; + int has_completed = what_flag & CI_WHAT_COMPLETED; + + if (has_items || has_matches) + { + li = list_alloc(); + if (li == NULL) + return; + ret = dict_add_list(retdict, (has_matches && !has_items) + ? "matches" : "items", li); + } + if (ret == OK && what_flag & CI_WHAT_SELECTED) + if (compl_curr_match != NULL && compl_curr_match->cp_number == -1) + ins_compl_update_sequence_numbers(); + if (ret == OK && compl_first_match != NULL) + { + int list_idx = 0; + match = compl_first_match; + do + { + if (!match_at_original_text(match)) + { + if (has_items + || (has_matches && match->cp_in_match_array)) + { + di = dict_alloc(); + if (di == NULL) + return; + ret = list_append_dict(li, di); + if (ret != OK) + return; + fill_complete_info_dict(di, match, has_matches && has_items); + } + if (compl_curr_match != NULL + && compl_curr_match->cp_number == match->cp_number) + selected_idx = list_idx; + if (!has_matches || match->cp_in_match_array) + list_idx++; + } + match = match->cp_next; + } + while (match != NULL && !is_first_match(match)); + } + if (ret == OK && (what_flag & CI_WHAT_SELECTED)) + ret = dict_add_number(retdict, "selected", selected_idx); + + if (ret == OK && selected_idx != -1 && has_completed) + { + di = dict_alloc(); + if (di == NULL) + return; + fill_complete_info_dict(di, compl_curr_match, FALSE); + ret = dict_add_dict(retdict, "completed", di); + } + } +} + +/* + * "complete_info()" function + */ + void +f_complete_info(typval_T *argvars, typval_T *rettv) +{ + list_T *what_list = NULL; + + if (rettv_dict_alloc(rettv) == FAIL) + return; + + if (in_mnv9script() && check_for_opt_list_arg(argvars, 0) == FAIL) + return; + + if (argvars[0].v_type != VAR_UNKNOWN) + { + if (check_for_list_arg(argvars, 0) == FAIL) + return; + what_list = argvars[0].vval.v_list; + } + get_complete_info(what_list, rettv->vval.v_dict); +} +#endif + +/* + * Returns TRUE when using a user-defined function for thesaurus completion. + */ + static int +thesaurus_func_complete(int type UNUSED) +{ +#ifdef FEAT_COMPL_FUNC + return type == CTRL_X_THESAURUS + && (*curbuf->b_p_tsrfu != NUL || *p_tsrfu != NUL); +#else + return FALSE; +#endif +} + +/* + * Check if 'cpt' list index can be advanced to the next completion source. + */ + static int +may_advance_cpt_index(char_u *cpt) +{ + char_u *p = cpt; + + if (cpt_sources_index == -1) + return FALSE; + while (*p == ',' || *p == ' ') // Skip delimiters + p++; + return (*p != NUL); +} + +/* + * Return value of process_next_cpt_value() + */ +enum +{ + INS_COMPL_CPT_OK = 1, + INS_COMPL_CPT_CONT, + INS_COMPL_CPT_END +}; + +/* + * state information used for getting the next set of insert completion + * matches. + */ +typedef struct +{ + char_u *e_cpt_copy; // copy of 'complete' + char_u *e_cpt; // current entry in "e_cpt_copy" + buf_T *ins_buf; // buffer being scanned + pos_T *cur_match_pos; // current match position + pos_T prev_match_pos; // previous match position + int set_match_pos; // save first_match_pos/last_match_pos + pos_T first_match_pos; // first match position + pos_T last_match_pos; // last match position + int found_all; // found all matches of a certain type. + char_u *dict; // dictionary file to search + int dict_f; // "dict" is an exact file name or not + callback_T *func_cb; // callback of function in 'cpt' option +} ins_compl_next_state_T; + +/* + * Process the next 'complete' option value in st->e_cpt. + * + * If successful, the arguments are set as below: + * st->cpt - pointer to the next option value in "st->cpt" + * compl_type_arg - type of insert mode completion to use + * st->found_all - all matches of this type are found + * st->ins_buf - search for completions in this buffer + * st->first_match_pos - position of the first completion match + * st->last_match_pos - position of the last completion match + * st->set_match_pos - TRUE if the first match position should be saved to + * avoid loops after the search wraps around. + * st->dict - name of the dictionary or thesaurus file to search + * st->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 completion source matching + * the "st->e_cpt" option value and process the next matching source. + * Returns INS_COMPL_CPT_END if all the values in "st->e_cpt" are processed. + */ + static int +process_next_cpt_value( + ins_compl_next_state_T *st, + int *compl_type_arg, + pos_T *start_match_pos, + int fuzzy_collect, + int *advance_cpt_idx) +{ + int compl_type = -1; + int status = INS_COMPL_CPT_OK; + int skip_source = compl_autocomplete && compl_from_nonkeyword; + + st->found_all = FALSE; + *advance_cpt_idx = FALSE; + + while (*st->e_cpt == ',' || *st->e_cpt == ' ') + st->e_cpt++; + + if (*st->e_cpt == '.' && !curbuf->b_scanned && !skip_source + && !compl_time_slice_expired) + { + 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_normal() && (!fuzzy_collect && 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; + st->first_match_pos.col = ml_get_len(st->first_match_pos.lnum); + } + st->last_match_pos = st->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. + st->set_match_pos = TRUE; + } + else if (!skip_source && !compl_time_slice_expired + && mnv_strchr((char_u *)"buwU", *st->e_cpt) != NULL + && (st->ins_buf = ins_compl_next_buf( + st->ins_buf, *st->e_cpt)) != curbuf) + { + // Scan a buffer, but not the current one. + if (st->ins_buf->b_ml.ml_mfp != NULL) // loaded buffer + { + compl_started = TRUE; + st->first_match_pos.col = st->last_match_pos.col = 0; + st->first_match_pos.lnum = st->ins_buf->b_ml.ml_line_count + 1; + st->last_match_pos.lnum = 0; + compl_type = 0; + } + else // unloaded buffer, scan like dictionary + { + st->found_all = TRUE; + if (st->ins_buf->b_fname == NULL) + { + status = INS_COMPL_CPT_CONT; + goto done; + } + compl_type = CTRL_X_DICTIONARY; + st->dict = st->ins_buf->b_fname; + st->dict_f = DICT_EXACT; + } + if (!shortmess(SHM_COMPLETIONSCAN) && !compl_autocomplete) + { + msg_hist_off = TRUE; // reset in msg_trunc_attr() + mnv_snprintf((char *)IObuff, IOSIZE, _("Scanning: %s"), + st->ins_buf->b_fname == NULL + ? buf_spname(st->ins_buf) + : st->ins_buf->b_sfname == NULL + ? st->ins_buf->b_fname + : st->ins_buf->b_sfname); + (void)msg_trunc_attr((char *)IObuff, TRUE, HL_ATTR(HLF_R)); + } + } + else if (*st->e_cpt == NUL) + status = INS_COMPL_CPT_END; + else + { + if (ctrl_x_mode_line_or_eval()) + compl_type = -1; +#ifdef FEAT_COMPL_FUNC + else if (*st->e_cpt == 'F' || *st->e_cpt == 'o') + { + compl_type = CTRL_X_FUNCTION; + st->func_cb = get_callback_if_cpt_func(st->e_cpt, cpt_sources_index); + if (!st->func_cb) + compl_type = -1; + } +#endif + else if (!skip_source) + { + if (*st->e_cpt == 'k' || *st->e_cpt == 's') + { + if (*st->e_cpt == 'k') + compl_type = CTRL_X_DICTIONARY; + else + compl_type = CTRL_X_THESAURUS; + if (*++st->e_cpt != ',' && *st->e_cpt != NUL) + { + st->dict = st->e_cpt; + st->dict_f = DICT_FIRST; + } + } +#ifdef FEAT_FIND_ID + else if (*st->e_cpt == 'i') + compl_type = CTRL_X_PATH_PATTERNS; + else if (*st->e_cpt == 'd') + compl_type = CTRL_X_PATH_DEFINES; +#endif + else if (*st->e_cpt == ']' || *st->e_cpt == 't') + { + compl_type = CTRL_X_TAGS; + if (!shortmess(SHM_COMPLETIONSCAN) && !compl_autocomplete) + { + msg_hist_off = TRUE; // reset in msg_trunc_attr() + mnv_snprintf((char *)IObuff, IOSIZE, _("Scanning tags.")); + (void)msg_trunc_attr((char *)IObuff, TRUE, HL_ATTR(HLF_R)); + } + } + else + compl_type = -1; + } + + // in any case e_cpt is advanced to the next entry + (void)copy_option_part(&st->e_cpt, IObuff, IOSIZE, ","); + *advance_cpt_idx = may_advance_cpt_index(st->e_cpt); + + st->found_all = TRUE; + if (compl_type == -1) + status = INS_COMPL_CPT_CONT; + } + +done: + *compl_type_arg = compl_type; + return status; +} + +#ifdef FEAT_FIND_ID +/* + * 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.string, compl_direction, + (int)compl_pattern.length, FALSE, FALSE, + (compl_type == CTRL_X_PATH_DEFINES + && !(compl_cont_status & CONT_SOL)) + ? FIND_DEFINE : FIND_ANY, 1L, ACTION_EXPAND, + (linenr_T)1, (linenr_T)MAXLNUM, FALSE, compl_autocomplete); +} +#endif + +/* + * 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(compl_type)) + expand_by_function(compl_type, compl_pattern.string, NULL); + else +#endif + ins_compl_dictionaries( + 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.string, + dict != NULL ? dict_f : 0, + compl_type == CTRL_X_THESAURUS); +} + +/* + * 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; + + // set p_ic according to p_ic, p_scs and pat for find_tags(). + save_p_ic = p_ic; + p_ic = ignorecase(compl_pattern.string); + + // 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.string, &num_matches, &matches, + TAG_REGEXP | TAG_NAMES | TAG_NOIC | TAG_INS_COMP + | (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; +} + +/* + * Compare function for qsort + */ + static int +compare_scores(const void *a, const void *b) +{ + int idx_a = *(const int *)a; + int idx_b = *(const int *)b; + int score_a = compl_fuzzy_scores[idx_a]; + int score_b = compl_fuzzy_scores[idx_b]; + return score_a == score_b ? (idx_a == idx_b ? 0 : (idx_a < idx_b ? -1 : 1)) + : (score_a > score_b ? -1 : 1); +} + +/* + * insert prefix with redraw + */ + static void +ins_compl_longest_insert(char_u *prefix) +{ + ins_compl_delete(); + ins_compl_insert_bytes(prefix + get_compl_len(), -1); + ins_redraw(FALSE); +} + +/* + * Calculate the longest common prefix among the best fuzzy matches + * stored in compl_best_matches, and insert it as the longest. + */ + static void +fuzzy_longest_match(void) +{ + char_u *prefix = NULL; + int prefix_len = 0; + int i = 0; + int j = 0; + char_u *match_str = NULL; + char_u *prefix_ptr = NULL; + char_u *match_ptr = NULL; + char_u *leader = NULL; + size_t leader_len = 0; + compl_T *compl = NULL; + int more_candidates = FALSE; + compl_T *nn_compl = NULL; + + if (compl_num_bests == 0) + return; + + nn_compl = compl_first_match->cp_next->cp_next; + if (nn_compl && nn_compl != compl_first_match) + more_candidates = TRUE; + + compl = ctrl_x_mode_whole_line() ? compl_first_match + : compl_first_match->cp_next; + if (compl_num_bests == 1) + { + // no more candidates insert the match str + if (!more_candidates) + { + ins_compl_longest_insert(compl->cp_str.string); + compl_num_bests = 0; + } + compl_num_bests = 0; + return; + } + + compl_best_matches = (compl_T **)alloc(compl_num_bests * sizeof(compl_T *)); + if (compl_best_matches == NULL) + return; + while (compl != NULL && i < compl_num_bests) + { + compl_best_matches[i] = compl; + compl = compl->cp_next; + i++; + } + + prefix = compl_best_matches[0]->cp_str.string; + prefix_len = (int)compl_best_matches[0]->cp_str.length; + + for (i = 1; i < compl_num_bests; i++) + { + match_str = compl_best_matches[i]->cp_str.string; + prefix_ptr = prefix; + match_ptr = match_str; + j = 0; + + while (j < prefix_len && *match_ptr != NUL && *prefix_ptr != NUL) + { + if (STRNCMP(prefix_ptr, match_ptr, mb_ptr2len(prefix_ptr)) != 0) + break; + + MB_PTR_ADV(prefix_ptr); + MB_PTR_ADV(match_ptr); + j++; + } + + if (j > 0) + prefix_len = j; + } + + leader = ins_compl_leader(); + leader_len = ins_compl_leader_len(); + + // skip non-consecutive prefixes + if (leader_len > 0 && STRNCMP(prefix, leader, leader_len) != 0) + goto end; + + prefix = mnv_strnsave(prefix, prefix_len); + if (prefix != NULL) + { + ins_compl_longest_insert(prefix); + mnv_free(prefix); + } + +end: + mnv_free(compl_best_matches); + compl_best_matches = NULL; + compl_num_bests = 0; +} + +/* + * Get the next set of filename matching "compl_pattern". + */ + static void +get_next_filename_completion(void) +{ + char_u **matches; + int num_matches; + char_u *ptr; + garray_T fuzzy_indices; + int i; + int score; + char_u *leader = ins_compl_leader(); + size_t leader_len = ins_compl_leader_len(); + int in_fuzzy_collect = (cot_fuzzy() && leader_len > 0); + int *fuzzy_indices_data; + char_u *last_sep = NULL; + int need_collect_bests = in_fuzzy_collect && compl_get_longest; + int max_score = 0; + int current_score = 0; + int dir = compl_direction; + +#ifdef BACKSLASH_IN_FILENAME + char pathsep = (curbuf->b_p_csl[0] == 's') ? + '/' : (curbuf->b_p_csl[0] == 'b') ? '\\' : PATHSEP; +#else + char pathsep = PATHSEP; +#endif + + if (in_fuzzy_collect) + { +#ifdef BACKSLASH_IN_FILENAME + if (curbuf->b_p_csl[0] == 's') + { + for (i = 0; i < (int)leader_len; i++) + { + if (leader[i] == '\\') + leader[i] = '/'; + } + } + else if (curbuf->b_p_csl[0] == 'b') + { + for (i = 0; i < (int)leader_len; i++) + { + if (leader[i] == '/') + leader[i] = '\\'; + } + } +#endif + last_sep = mnv_strrchr(leader, pathsep); + if (last_sep == NULL) + { + // No path separator or separator is the last character, + // fuzzy match the whole leader + MNV_CLEAR_STRING(compl_pattern); + compl_pattern.string = mnv_strnsave((char_u *)"*", 1); + if (compl_pattern.string == NULL) + return; + compl_pattern.length = 1; + } + else if (*(last_sep + 1) == '\0') + in_fuzzy_collect = FALSE; + else + { + // Split leader into path and file parts + int path_len = last_sep - leader + 1; + char_u *path_with_wildcard; + + path_with_wildcard = alloc(path_len + 2); + if (path_with_wildcard != NULL) + { + mnv_snprintf((char *)path_with_wildcard, path_len + 2, "%*.*s*", path_len, path_len, leader); + MNV_CLEAR_STRING(compl_pattern); + compl_pattern.string = path_with_wildcard; + compl_pattern.length = path_len + 1; + + // Move leader to the file part + leader = last_sep + 1; + leader_len -= path_len; + } + } + } + + if (expand_wildcards(1, &compl_pattern.string, &num_matches, &matches, + EW_FILE|EW_DIR|EW_ADDSLASH|EW_SILENT) != OK) + return; + + // May change home directory back to "~". + tilde_replace(compl_pattern.string, num_matches, matches); +#ifdef BACKSLASH_IN_FILENAME + if (curbuf->b_p_csl[0] != NUL) + { + for (i = 0; i < num_matches; ++i) + { + ptr = matches[i]; + while (*ptr != NUL) + { + if (curbuf->b_p_csl[0] == 's' && *ptr == '\\') + *ptr = '/'; + else if (curbuf->b_p_csl[0] == 'b' && *ptr == '/') + *ptr = '\\'; + ptr += (*mb_ptr2len)(ptr); + } + } + } +#endif + + if (in_fuzzy_collect) + { + ga_init2(&fuzzy_indices, sizeof(int), 10); + compl_fuzzy_scores = (int *)alloc(sizeof(int) * num_matches); + + for (i = 0; i < num_matches; i++) + { + ptr = matches[i]; + score = fuzzy_match_str(ptr, leader); + if (score != FUZZY_SCORE_NONE) + { + if (ga_grow(&fuzzy_indices, 1) == OK) + { + ((int *)fuzzy_indices.ga_data)[fuzzy_indices.ga_len] = i; + compl_fuzzy_scores[i] = score; + fuzzy_indices.ga_len++; + } + } + } + + // prevent qsort from deref NULL pointer + if (fuzzy_indices.ga_len > 0) + { + char_u *match = NULL; + fuzzy_indices_data = (int *)fuzzy_indices.ga_data; + qsort(fuzzy_indices_data, fuzzy_indices.ga_len, sizeof(int), compare_scores); + + for (i = 0; i < fuzzy_indices.ga_len; ++i) + { + match = matches[fuzzy_indices_data[i]]; + current_score = compl_fuzzy_scores[fuzzy_indices_data[i]]; + if (ins_compl_add(match, -1, NULL, NULL, NULL, dir, + CP_FAST | ((p_fic || p_wic) ? CP_ICASE : 0), + FALSE, NULL, current_score) == OK) + dir = FORWARD; + + if (need_collect_bests) + { + if (i == 0 || current_score == max_score) + { + compl_num_bests++; + max_score = current_score; + } + } + } + + FreeWild(num_matches, matches); + } + else if (leader_len > 0) + { + FreeWild(num_matches, matches); + num_matches = 0; + } + + mnv_free(compl_fuzzy_scores); + ga_clear(&fuzzy_indices); + + if (compl_num_bests > 0 && compl_get_longest) + fuzzy_longest_match(); + return; + } + + if (num_matches > 0) + ins_compl_add_matches(num_matches, matches, p_fic || p_wic); +} + +/* + * Get the next set of command-line completions matching "compl_pattern". + */ + static void +get_next_cmdline_completion(void) +{ + char_u **matches; + int num_matches; + + if (expand_cmdline(&compl_xp, compl_pattern.string, + (int)compl_pattern.length, &num_matches, &matches) == EXPAND_OK) + ins_compl_add_matches(num_matches, matches, FALSE); +} + +/* + * Get the next set of spell suggestions matching "compl_pattern". + */ + static void +get_next_spell_completion(linenr_T lnum UNUSED) +{ +#ifdef FEAT_SPELL + char_u **matches; + int num_matches; + + num_matches = expand_spelling(lnum, compl_pattern.string, &matches); + if (num_matches > 0) + ins_compl_add_matches(num_matches, matches, p_ic); + else + mnv_free(matches); +#endif +} + +/* + * Return the next word or line from buffer "ins_buf" at position + * "cur_match_pos" for completion. The length of the match is set in "len". + */ + static char_u * +ins_compl_get_next_word_or_line( + buf_T *ins_buf, // buffer being scanned + pos_T *cur_match_pos, // current match position + int *match_len, + int *cont_s_ipos) // next ^X<> will set initial_pos +{ + char_u *ptr; + int len; + + *match_len = 0; + ptr = ml_get_buf(ins_buf, cur_match_pos->lnum, FALSE) + + cur_match_pos->col; + len = (int)ml_get_buf_len(ins_buf, cur_match_pos->lnum) - cur_match_pos->col; + if (ctrl_x_mode_line_or_eval()) + { + 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); + len = ml_get_buf_len(ins_buf, cur_match_pos->lnum + 1); + if (!p_paste) + { + char_u *tmp_ptr = ptr; + + ptr = skipwhite(tmp_ptr); + len -= (int)(ptr - tmp_ptr); + } + } + } + else + { + char_u *tmp_ptr = ptr; + + if (compl_status_adding() && compl_length <= len) + { + tmp_ptr += compl_length; + // Skip if already inside a word. + if (mnv_iswordp(tmp_ptr)) + return NULL; + // Find start of next word. + tmp_ptr = find_word_start(tmp_ptr); + } + // Find end of this word. + tmp_ptr = find_word_end(tmp_ptr); + len = (int)(tmp_ptr - ptr); + + 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. + // IOSIZE is always greater than + // compl_length, so the next STRNCPY always + // works -- Acevedo + STRNCPY(IObuff, ptr, len); + 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); + // Find end of next word. + tmp_ptr = find_word_end(tmp_ptr); + if (tmp_ptr > ptr) + { + if (*ptr != ')' && IObuff[len - 1] != TAB) + { + if (IObuff[len - 1] != ' ') + IObuff[len++] = ' '; + // IObuf =~ "\k.* ", thus len >= 2 + if (p_js + && (IObuff[len - 2] == '.' + || (mnv_strchr(p_cpo, CPO_JOINSP) + == NULL + && (IObuff[len - 2] == '?' + || IObuff[len - 2] == '!')))) + IObuff[len++] = ' '; + } + // 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); + *cont_s_ipos = TRUE; + } + IObuff[len] = NUL; + ptr = IObuff; + } + if (len == compl_length) + return NULL; + } + } + + *match_len = len; + return ptr; +} + +/* + * 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 "st->ins_buf" starting from the + * position "st->start_pos" in the "compl_direction" direction. If + * "st->set_match_pos" is TRUE, then set the "st->first_match_pos" and + * "st->last_match_pos". + * Returns OK if a new next match is found, otherwise returns FAIL. + */ + static int +get_next_default_completion(ins_compl_next_state_T *st, pos_T *start_pos) +{ + int found_new_match = FAIL; + int save_p_scs; + int save_p_ws; + int looped_around = FALSE; + char_u *ptr = NULL; + int len = 0; + int in_fuzzy_collect = !compl_status_adding() + && cot_fuzzy() && compl_length > 0; + char_u *leader = ins_compl_leader(); + int score = FUZZY_SCORE_NONE; + int in_curbuf = st->ins_buf == curbuf; + + // If 'infercase' is set, don't use 'smartcase' here + save_p_scs = p_scs; + if (st->ins_buf->b_p_inf) + p_scs = FALSE; + + // Buffers other than curbuf are scanned from the beginning or the + // end but never from the middle, thus setting nowrapscan in this + // buffer is a good idea, on the other hand, we always set + // wrapscan for curbuf to avoid missing matches -- Acevedo,Webb + save_p_ws = p_ws; + if (!in_curbuf) + p_ws = FALSE; + else if (*st->e_cpt == '.') + p_ws = TRUE; + looped_around = FALSE; + for (;;) + { + int cont_s_ipos = FALSE; + + ++msg_silent; // Don't want messages for wrapscan. + + if (in_fuzzy_collect) + { + found_new_match = search_for_fuzzy_match(st->ins_buf, + st->cur_match_pos, leader, compl_direction, + start_pos, &len, &ptr, &score); + } + // ctrl_x_mode_line_or_eval() || word-wise search that + // has added a word that was at the beginning of the line + else if (ctrl_x_mode_whole_line() || ctrl_x_mode_eval() || (compl_cont_status & CONT_SOL)) + found_new_match = search_for_exact_line(st->ins_buf, + st->cur_match_pos, compl_direction, compl_pattern.string); + else + found_new_match = searchit(NULL, st->ins_buf, st->cur_match_pos, + NULL, compl_direction, compl_pattern.string, (int)compl_pattern.length, + 1L, SEARCH_KEEP + SEARCH_NFMSG, RE_LAST, NULL); + --msg_silent; + if (!compl_started || st->set_match_pos) + { + // set "compl_started" even on fail + compl_started = TRUE; + st->first_match_pos = *st->cur_match_pos; + st->last_match_pos = *st->cur_match_pos; + st->set_match_pos = FALSE; + } + 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_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_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; + } + 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_status_adding() && in_curbuf + && start_pos->lnum == st->cur_match_pos->lnum + && start_pos->col == st->cur_match_pos->col) + continue; + + if (!in_fuzzy_collect) + ptr = ins_compl_get_next_word_or_line(st->ins_buf, + st->cur_match_pos, &len, &cont_s_ipos); + if (ptr == NULL || (ins_compl_has_preinsert() + && STRCMP(ptr, ins_compl_leader()) == 0)) + continue; + + if (is_nearest_active() && in_curbuf) + { + score = st->cur_match_pos->lnum - curwin->w_cursor.lnum; + if (score < 0) + score = -score; + } + + if (ins_compl_add_infercase(ptr, len, p_ic, + in_curbuf ? NULL : st->ins_buf->b_sfname, + 0, cont_s_ipos, score) != NOTDONE) + { + if (in_fuzzy_collect && score == compl_first_match->cp_next->cp_score) + compl_num_bests++; + found_new_match = OK; + break; + } + } + p_scs = save_p_scs; + p_ws = save_p_ws; + + return found_new_match; +} + +#ifdef FEAT_COMPL_FUNC +/* + * Return the callback function associated with "p" if it refers to a + * user-defined function in the 'complete' option. + * The "idx" parameter is used for indexing callback entries. + */ + static callback_T * +get_callback_if_cpt_func(char_u *p, int idx) +{ + if (*p == 'o') + return &curbuf->b_ofu_cb; + + if (*p == 'F') + { + if (*++p != ',' && *p != NUL) + { + // 'F{func}' case + return curbuf->b_p_cpt_cb[idx].cb_name != NULL + ? &curbuf->b_p_cpt_cb[idx] : NULL; + } + else + return &curbuf->b_cfu_cb; // 'cfu' + } + + return NULL; +} +#endif + +/* + * Get completion matches from register contents. + * Extracts words from all available registers and adds them to the completion list. + */ + static void +get_register_completion(void) +{ + int dir = compl_direction; + yankreg_T *reg = NULL; + void *reg_ptr = NULL; + int adding_mode = compl_status_adding(); + + for (int i = 0; i < NUM_REGISTERS; i++) + { + int regname = 0; + if (i == 0) + regname = '"'; // unnamed register + else if (i < 10) + regname = '0' + i; + else if (i == DELETION_REGISTER) + regname = '-'; +#ifdef FEAT_CLIPBOARD + else if (i == STAR_REGISTER) + regname = '*'; + else if (i == PLUS_REGISTER) + regname = '+'; +#endif + else + regname = 'a' + i - 10; + + // Skip invalid or black hole register + if (!valid_yank_reg(regname, FALSE) || regname == '_') + continue; + + reg_ptr = get_register(regname, FALSE); + if (reg_ptr == NULL) + continue; + + reg = (yankreg_T *)reg_ptr; + + for (int j = 0; j < reg->y_size; j++) + { + char_u *str = reg->y_array[j].string; + if (str == NULL) + continue; + + if (adding_mode) + { + int str_len = (int)STRLEN(str); + if (str_len == 0) + continue; + + if (!compl_orig_text.string + || (p_ic ? STRNICMP(str, compl_orig_text.string, + compl_orig_text.length) == 0 + : STRNCMP(str, compl_orig_text.string, + compl_orig_text.length) == 0)) + { + if (ins_compl_add_infercase(str, str_len, p_ic, NULL, + dir, FALSE, FUZZY_SCORE_NONE) == OK) + dir = FORWARD; + } + } + else + { + // Calculate the safe end of string to avoid null byte issues + char_u *str_end = str + STRLEN(str); + char_u *p = str; + + // Safely iterate through the string + while (p < str_end && *p != NUL) + { + char_u *old_p = p; + p = find_word_start(p); + if (p >= str_end || *p == NUL) + break; + + char_u *word_end = find_word_end(p); + + if (word_end <= p) + { + if (has_mbyte) + word_end = p + (*mb_ptr2len)(p); + else + word_end = p + 1; + } + + if (word_end > str_end) + word_end = str_end; + + int len = (int)(word_end - p); + if (len > 0 && (!compl_orig_text.string + || (p_ic ? STRNICMP(p, compl_orig_text.string, + compl_orig_text.length) == 0 + : STRNCMP(p, compl_orig_text.string, + compl_orig_text.length) == 0))) + { + if (ins_compl_add_infercase(p, len, p_ic, NULL, + dir, FALSE, FUZZY_SCORE_NONE) == OK) + dir = FORWARD; + } + + p = word_end; + + if (p <= old_p) + { + p = old_p + 1; + if (has_mbyte && p < str_end) + p = old_p + (*mb_ptr2len)(old_p); + } + } + } + } + + // Free the register copy + put_register(regname, reg_ptr); + } +} + +/* + * 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) +{ + int found_new_match = FALSE; + + 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, st->dict, st->dict_f); + st->dict = NULL; + 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: + if (ctrl_x_mode_normal()) // Invoked by a func in 'cpt' option + get_cpt_func_completion_matches(st->func_cb); + else + expand_by_function(type, compl_pattern.string, NULL); + break; + case CTRL_X_OMNI: + expand_by_function(type, compl_pattern.string, NULL); + break; +#endif + + case CTRL_X_SPELL: + get_next_spell_completion(st->first_match_pos.lnum); + break; + + case CTRL_X_REGISTER: + get_register_completion(); + break; + + default: // normal ^P/^N and ^X^L + found_new_match = get_next_default_completion(st, ini); + if (found_new_match == FAIL && st->ins_buf == curbuf) + st->found_all = TRUE; + } + + // check if compl_curr_match has changed, (e.g. other type of + // expansion added something) + if (type != 0 && compl_curr_match != compl_old_match) + found_new_match = OK; + + return found_new_match; +} + +/* + * Strips carets followed by numbers. This suffix typically represents the + * max_matches setting. + */ + static void +strip_caret_numbers_in_place(char_u *str) +{ + char_u *read = str, *write = str, *p; + + if (str == NULL) + return; + + while (*read) + { + if (*read == '^') + { + p = read + 1; + while (mnv_isdigit(*p)) + p++; + if ((*p == ',' || *p == '\0') && p != read + 1) + { + read = p; + continue; + } + else + *write++ = *read++; + } + else + *write++ = *read++; + } + *write = '\0'; +} + +/* + * Call functions specified in the 'cpt' option with findstart=1, + * and retrieve the startcol. + */ + static int +prepare_cpt_compl_funcs(void) +{ +#ifdef FEAT_COMPL_FUNC + char_u *cpt; + char_u *p; + callback_T *cb = NULL; + int idx = 0; + int startcol; + + // Make a copy of 'cpt' in case the buffer gets wiped out + cpt = mnv_strsave(curbuf->b_p_cpt); + if (cpt == NULL) + return FAIL; + strip_caret_numbers_in_place(cpt); + + for (p = cpt; *p;) + { + while (*p == ',' || *p == ' ') // Skip delimiters + p++; + if (*p == NUL) + break; + + cb = get_callback_if_cpt_func(p, idx); + if (cb) + { + if (get_userdefined_compl_info(curwin->w_cursor.col, cb, &startcol) + == FAIL) + { + if (startcol == -3) + cpt_sources_array[idx].cs_refresh_always = FALSE; + else + startcol = -2; + } + else if (startcol < 0 || startcol > curwin->w_cursor.col) + startcol = curwin->w_cursor.col; + cpt_sources_array[idx].cs_startcol = startcol; + } + else + cpt_sources_array[idx].cs_startcol = -3; + + (void)copy_option_part(&p, IObuff, IOSIZE, ","); // Advance p + idx++; + } + + mnv_free(cpt); + return OK; +#endif + return FAIL; +} + +/* + * Start the timer for the current completion source. + */ + static void +compl_source_start_timer(int source_idx UNUSED) +{ +#ifdef ELAPSED_FUNC + if (compl_autocomplete || p_cto > 0) + { + ELAPSED_INIT(cpt_sources_array[source_idx].compl_start_tv); + compl_time_slice_expired = FALSE; + } +#endif +} + +/* + * Safely advance the cpt_sources_index by one. + */ + static int +advance_cpt_sources_index_safe(void) +{ + if (cpt_sources_index >= 0 && cpt_sources_index < cpt_sources_count - 1) + { + cpt_sources_index++; + return OK; + } +#ifdef FEAT_EVAL + semsg(_(e_list_index_out_of_range_nr), cpt_sources_index); +#endif + return FAIL; +} + +/* + * 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 ins_compl_next_state_T st; + static int st_cleared = FALSE; + int match_count; + int found_new_match; + int type = ctrl_x_mode; + int may_advance_cpt_idx = FALSE; + pos_T start_pos = *ini; + int normal_mode_strict = FALSE; + long compl_timeout_save = 0; + + if (!compl_started) + { + buf_T *buf; + + FOR_ALL_BUFFERS(buf) + buf->b_scanned = 0; + if (!st_cleared) + { + CLEAR_FIELD(st); + st_cleared = TRUE; + } + st.found_all = FALSE; + st.ins_buf = curbuf; + mnv_free(st.e_cpt_copy); + // Make a copy of 'complete', in case the buffer is wiped out. + st.e_cpt_copy = mnv_strsave((compl_cont_status & CONT_LOCAL) + ? (char_u *)"." : curbuf->b_p_cpt); + strip_caret_numbers_in_place(st.e_cpt_copy); + st.e_cpt = st.e_cpt_copy == NULL ? (char_u *)"" : st.e_cpt_copy; + + // In large buffers, timeout may miss nearby matches — search above cursor +#define LOOKBACK_LINE_COUNT 1000 + if (compl_autocomplete && is_nearest_active()) + { + start_pos.lnum = MAX(1, start_pos.lnum - LOOKBACK_LINE_COUNT); + start_pos.col = 0; + } + st.last_match_pos = st.first_match_pos = start_pos; + } + 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_dir_forward()) + ? &st.last_match_pos : &st.first_match_pos; + + normal_mode_strict = ctrl_x_mode_normal() && !ctrl_x_mode_line_or_eval() + && !(compl_cont_status & CONT_LOCAL) && cpt_sources_array != NULL; + if (normal_mode_strict) + { + cpt_sources_index = 0; + if (compl_autocomplete || p_cto > 0) + { + compl_source_start_timer(0); + compl_time_slice_expired = FALSE; + compl_timeout_ms = compl_autocomplete + ? MAX(COMPL_INITIAL_TIMEOUT_MS, p_act) + : p_cto; + } + } + + // For ^N/^P loop over all the flags/windows/buffers in 'complete'. + for (;;) + { + found_new_match = FAIL; + 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_normal() || ctrl_x_mode_line_or_eval()) + && (!compl_started || st.found_all)) + { + int status = process_next_cpt_value(&st, &type, &start_pos, + cot_fuzzy(), &may_advance_cpt_idx); + + if (status == INS_COMPL_CPT_END) + break; + if (status == INS_COMPL_CPT_CONT) + { + if (may_advance_cpt_idx) + { + if (!advance_cpt_sources_index_safe()) + break; + compl_source_start_timer(cpt_sources_index); + } + continue; + } + } + + if (normal_mode_strict && type == CTRL_X_FUNCTION + && (compl_autocomplete || p_cto > 0)) + { + // LSP servers may sporadically take >1s to respond (e.g., while + // loading modules), but other sources might already have matches. + // To show results quickly use a short timeout for keyword + // completion. Allow longer timeout for non-keyword completion + // where only function based sources (e.g. LSP) are active. + compl_timeout_save = compl_timeout_ms; + compl_timeout_ms = compl_from_nonkeyword + ? COMPL_FUNC_TIMEOUT_NON_KW_MS : COMPL_FUNC_TIMEOUT_MS; + } + + // get the next set of completion matches + found_new_match = get_next_completion_match(type, &st, &start_pos); + + // If complete() was called then compl_pattern has been reset. The + // following won't work then, bail out. + if (compl_pattern.string == NULL) + break; + + if (may_advance_cpt_idx) + { + if (!advance_cpt_sources_index_safe()) + break; + compl_source_start_timer(cpt_sources_index); + } + + // 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_not_default() && !ctrl_x_mode_line_or_eval()) + || 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_not_default() + && !ctrl_x_mode_line_or_eval()) || compl_interrupted) + break; + compl_started = compl_time_slice_expired ? FALSE : TRUE; + } + else + { + // Mark a buffer scanned when it has been scanned completely + if (buf_valid(st.ins_buf) && (type == 0 || type == CTRL_X_PATH_PATTERNS)) + st.ins_buf->b_scanned = TRUE; + + compl_started = FALSE; + } + + // Restore the timeout after collecting matches from function source + if (normal_mode_strict && type == CTRL_X_FUNCTION + && (compl_autocomplete || p_cto > 0)) + compl_timeout_ms = compl_timeout_save; + + // For `^P` completion, reset `compl_curr_match` to the head to avoid + // mixing matches from different sources. + if (!compl_dir_forward()) + while (compl_curr_match->cp_prev + && !match_at_original_text(compl_curr_match->cp_prev)) + compl_curr_match = compl_curr_match->cp_prev; + } + cpt_sources_index = -1; + compl_started = TRUE; + + if ((ctrl_x_mode_normal() || ctrl_x_mode_line_or_eval()) + && *st.e_cpt == NUL) // Got to end of 'complete' + found_new_match = FAIL; + + match_count = -1; // total of matches, unknown + if (found_new_match == FAIL || (ctrl_x_mode_not_default() + && !ctrl_x_mode_line_or_eval())) + match_count = ins_compl_make_cyclic(); + + if (cot_fuzzy() && compl_get_longest && compl_num_bests > 0) + fuzzy_longest_match(); + + 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_dir_forward() ? compl_old_match->cp_next + : compl_old_match->cp_prev; + if (compl_curr_match == NULL) + compl_curr_match = compl_old_match; + } + may_trigger_modechanged(); + + if (match_count > 0 && !ctrl_x_mode_spell()) + { + if (is_nearest_active() && !ins_compl_has_preinsert()) + sort_compl_match_list(cp_compare_nearest); + + if (cot_fuzzy() && ins_compl_leader_len() > 0) + ins_compl_fuzzy_sort(); + } + + return match_count; +} + +/* + * Update "compl_shown_match" to the actually shown match, it may differ when + * "compl_leader" is used to omit some of the matches. + */ + static void +ins_compl_update_shown_match(void) +{ + string_T *leader; + + (void)get_leader_for_startcol(NULL, TRUE); // Clear the cache + leader = get_leader_for_startcol(compl_shown_match, TRUE); + + while (!ins_compl_equal(compl_shown_match, + leader->string, (int)leader->length) + && compl_shown_match->cp_next != NULL + && !is_first_match(compl_shown_match->cp_next)) + { + compl_shown_match = compl_shown_match->cp_next; + leader = get_leader_for_startcol(compl_shown_match, TRUE); + } + + // If we didn't find it searching forward, and compl_shows_dir is + // backward, find the last match. + if (compl_shows_dir_backward() + && !ins_compl_equal(compl_shown_match, + leader->string, (int)leader->length) + && (compl_shown_match->cp_next == NULL + || is_first_match(compl_shown_match->cp_next))) + { + while (!ins_compl_equal(compl_shown_match, + leader->string, (int)leader->length) + && compl_shown_match->cp_prev != NULL + && !is_first_match(compl_shown_match->cp_prev)) + { + compl_shown_match = compl_shown_match->cp_prev; + leader = get_leader_for_startcol(compl_shown_match, TRUE); + } + } +} + +/* + * Delete the old text being completed. + */ + void +ins_compl_delete(void) +{ + // In insert mode: Delete the typed part. + // In replace mode: Put the old characters back, if any. + int col = compl_col + (compl_status_adding() ? compl_length : 0); + string_T remaining = {NULL, 0}; + int orig_col; + + if (ins_compl_preinsert_effect()) + { + col += (int)ins_compl_leader_len(); + curwin->w_cursor.col = compl_ins_end_col; + } + + if (curwin->w_cursor.lnum > compl_lnum) + { + if (curwin->w_cursor.col < ml_get_curline_len()) + { + char_u *line = ml_get_cursor(); + remaining.length = ml_get_cursor_len(); + remaining.string = mnv_strnsave(line, remaining.length); + if (remaining.string == NULL) + return; + } + while (curwin->w_cursor.lnum > compl_lnum) + { + if (ml_delete(curwin->w_cursor.lnum) == FAIL) + { + if (remaining.string) + mnv_free(remaining.string); + return; + } + deleted_lines_mark(curwin->w_cursor.lnum, 1L); + curwin->w_cursor.lnum--; + } + // move cursor to end of line + curwin->w_cursor.col = ml_get_curline_len(); + } + + if ((int)curwin->w_cursor.col > col) + { + if (stop_arrow() == FAIL) + { + if (remaining.string) + mnv_free(remaining.string); + return; + } + backspace_until_column(col); + compl_ins_end_col = curwin->w_cursor.col; + } + + if (remaining.string != NULL) + { + orig_col = curwin->w_cursor.col; + ins_str(remaining.string, remaining.length); + curwin->w_cursor.col = orig_col; + mnv_free(remaining.string); + } + // TODO: is this sufficient for redrawing? Redrawing everything causes + // flicker, thus we can't do that. + changed_cline_bef_curs(); +#ifdef FEAT_EVAL + // clear v:completed_item + set_mnv_var_dict(VV_COMPLETED_ITEM, dict_alloc_lock(VAR_FIXED)); +#endif +} + +/* + * Insert a completion string that contains newlines. + * The string is split and inserted line by line. + */ + static void +ins_compl_expand_multiple(char_u *str) +{ + char_u *start = str; + char_u *curr = str; + int base_indent = get_indent(); + + while (*curr != NUL) + { + if (*curr == '\n') + { + // Insert the text chunk before newline + if (curr > start) + ins_char_bytes(start, (int)(curr - start)); + + // Handle newline + open_line(FORWARD, OPENLINE_KEEPTRAIL | OPENLINE_FORCE_INDENT, base_indent, NULL); + start = curr + 1; + } + curr++; + } + + // Handle remaining text after last newline (if any) + if (curr > start) + ins_char_bytes(start, (int)(curr - start)); + + compl_ins_end_col = curwin->w_cursor.col; +} + +/* + * Find the longest common prefix among the current completion matches. + * Returns a pointer to the first match string, with *prefix_len set to + * the length of the common prefix. + * If "curbuf_only" is TRUE, restrict matches to the current buffer + * ('.' source in 'complete'). + */ + static char_u * +find_common_prefix(size_t *prefix_len, int curbuf_only) +{ + compl_T *compl; + int *match_count; + char_u *first = NULL; + int len = -1; + int is_cpt_completion = (cpt_sources_array != NULL); + + if (!is_cpt_completion) + return NULL; + + match_count = ALLOC_CLEAR_MULT(int, cpt_sources_count); + if (match_count == NULL) + return NULL; + + (void)get_leader_for_startcol(NULL, TRUE); // Clear the cache + + compl = compl_first_match; + do + { + string_T *leader = get_leader_for_startcol(compl, TRUE); + + // Apply 'smartcase' behavior during normal mode + if (ctrl_x_mode_normal() && !p_inf && leader->string + && !ignorecase(leader->string)) + compl->cp_flags &= ~CP_ICASE; + + if (!match_at_original_text(compl) + && (leader->string == NULL + || ins_compl_equal(compl, leader->string, + (int)leader->length))) + { + // Limit number of items from each source if max_items is set. + int match_limit_exceeded = FALSE; + int cur_source = compl->cp_cpt_source_idx; + + if (cur_source != -1) + { + match_count[cur_source]++; + int max_matches = cpt_sources_array[cur_source].cs_max_matches; + if (max_matches > 0 && match_count[cur_source] > max_matches) + match_limit_exceeded = TRUE; + } + + if (!match_limit_exceeded && (!curbuf_only + || cpt_sources_array[cur_source].cs_flag == '.')) + { + if (first == NULL && STRNCMP(ins_compl_leader(), + compl->cp_str.string, ins_compl_leader_len()) == 0) + { + first = compl->cp_str.string; + len = (int)STRLEN(first); + } + else if (first != NULL) + { + int j = 0; // count in bytes + char_u *s1 = first; + char_u *s2 = compl->cp_str.string; + + while (j < len && *s1 != NUL && *s2 != NUL) + { + if (MB_BYTE2LEN(*s1) != MB_BYTE2LEN(*s2) + || memcmp(s1, s2, MB_BYTE2LEN(*s1)) != 0) + break; + + j += MB_BYTE2LEN(*s1); + MB_PTR_ADV(s1); + MB_PTR_ADV(s2); + } + len = j; + + if (len == 0) + break; + } + } + } + compl = compl->cp_next; + } while (compl != NULL && !is_first_match(compl)); + + mnv_free(match_count); + + if (len > (int)ins_compl_leader_len()) + { + // Avoid inserting text that duplicates the text already present + // after the cursor. + if (len == (int)STRLEN(first)) + { + char_u *line = ml_get_curline(); + char_u *p = line + curwin->w_cursor.col; + if (p && !IS_WHITE_OR_NUL(*p)) + { + char_u *end = find_word_end(p); + int text_len = end - p; + if (text_len > 0 + && text_len < (len - (int)ins_compl_leader_len()) + && STRNCMP(first + len - text_len, p, text_len) == 0) + len -= text_len; + } + } + *prefix_len = (size_t)len; + return first; + } + return NULL; +} + +/* + * Insert the new text being completed. + * "move_cursor" is used when 'completeopt' includes "preinsert" and when TRUE + * cursor needs to move back from the inserted text to the compl_leader. + * When "insert_prefix" is TRUE the longest common prefix is inserted instead + * of shown match. + */ + void +ins_compl_insert(int move_cursor, int insert_prefix) +{ + int compl_len = get_compl_len(); + int preinsert = ins_compl_has_preinsert(); + char_u *cp_str = compl_shown_match->cp_str.string; + size_t cp_str_len = compl_shown_match->cp_str.length; + size_t leader_len = ins_compl_leader_len(); + char_u *has_multiple = mnv_strchr(cp_str, '\n'); + + if (insert_prefix) + { + cp_str = find_common_prefix(&cp_str_len, FALSE); + if (cp_str == NULL) + { + cp_str = find_common_prefix(&cp_str_len, TRUE); + if (cp_str == NULL) + { + cp_str = compl_shown_match->cp_str.string; + cp_str_len = compl_shown_match->cp_str.length; + } + } + } + // Since completion sources may provide matches with varying start + // positions, insert only the portion of the match that corresponds to the + // intended replacement range. + else if (cpt_sources_array != NULL) + { + int cpt_idx = compl_shown_match->cp_cpt_source_idx; + if (cpt_idx >= 0 && compl_col >= 0) + { + int startcol = cpt_sources_array[cpt_idx].cs_startcol; + if (startcol >= 0 && startcol < (int)compl_col) + { + int skip = (int)compl_col - startcol; + if ((size_t)skip <= cp_str_len) + { + cp_str_len -= skip; + cp_str += skip; + } + } + } + } + + // Make sure we don't go over the end of the string, this can happen with + // illegal bytes. + if (compl_len < (int)cp_str_len) + { + if (has_multiple) + ins_compl_expand_multiple(cp_str + compl_len); + else + { + ins_compl_insert_bytes(cp_str + compl_len, + insert_prefix ? (int)cp_str_len - compl_len : -1); + if ((preinsert || insert_prefix) && move_cursor) + curwin->w_cursor.col -= (colnr_T)(cp_str_len - leader_len); + } + } + if (match_at_original_text(compl_shown_match) + || (preinsert && !insert_prefix)) + compl_used_match = FALSE; + else + compl_used_match = TRUE; +#ifdef FEAT_EVAL + { + dict_T *dict = ins_compl_dict_alloc(compl_shown_match); + + set_mnv_var_dict(VV_COMPLETED_ITEM, dict); + } +#endif + compl_hi_on_autocompl_longest = insert_prefix && move_cursor; +} + +/* + * show the file name for the completion match (if any). Truncate the file + * name to avoid a wait for return. + */ + static void +ins_compl_show_filename(void) +{ + char *lead = _("match in file"); + int space = sc_col - mnv_strsize((char_u *)lead) - 2; + char_u *s; + char_u *e; + + if (space <= 0) + return; + + // We need the tail that fits. With double-byte encoding going + // back from the end is very slow, thus go from the start and keep + // the text that fits in "space" between "s" and "e". + for (s = e = compl_shown_match->cp_fname; *e != NUL; MB_PTR_ADV(e)) + { + space -= ptr2cells(e); + while (space < 0) + { + space += ptr2cells(s); + MB_PTR_ADV(s); + } + } + if (!compl_autocomplete) + { + msg_hist_off = TRUE; + mnv_snprintf((char *)IObuff, IOSIZE, "%s %s%s", lead, + s > compl_shown_match->cp_fname ? "<" : "", s); + msg((char *)IObuff); + msg_hist_off = FALSE; + redraw_cmdline = FALSE; // don't overwrite! + } +} + +/* + * Find the appropriate completion item when 'complete' ('cpt') includes + * a 'max_matches' postfix. In this case, we search for a match where + * 'cp_in_match_array' is set, indicating that the match is also present + * in 'compl_match_array'. + */ + static compl_T * +find_next_match_in_menu(void) +{ + int is_forward = compl_shows_dir_forward(); + compl_T *match = compl_shown_match; + + do + match = is_forward ? match->cp_next : match->cp_prev; + while (match->cp_next && !match->cp_in_match_array + && !match_at_original_text(match)); + return match; +} + +/* + * 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. + * + * If "advance" is TRUE, then completion will move to the first match. + * Otherwise, the original text will be shown. + * + * Returns OK on success and -1 if the number of matches are unknown. + */ + static int +find_next_completion_match( + int allow_get_expansion, + int todo, // repeat completion this many times + int advance, + int *num_matches) +{ + int found_end = FALSE; + compl_T *found_compl = NULL; + unsigned int cur_cot_flags = get_cot_flags(); + int compl_no_select = (cur_cot_flags & COT_NOSELECT) != 0 + || (compl_autocomplete && !ins_compl_has_preinsert()); + string_T *leader; + + + while (--todo >= 0) + { + if (compl_shows_dir_forward() && compl_shown_match->cp_next != NULL) + { + if (compl_match_array != NULL) + compl_shown_match = find_next_match_in_menu(); + else + compl_shown_match = compl_shown_match->cp_next; + found_end = (compl_first_match != NULL + && (is_first_match(compl_shown_match->cp_next) + || is_first_match(compl_shown_match))); + } + else if (compl_shows_dir_backward() + && compl_shown_match->cp_prev != NULL) + { + found_end = is_first_match(compl_shown_match); + if (compl_match_array != NULL) + compl_shown_match = find_next_match_in_menu(); + else + compl_shown_match = compl_shown_match->cp_prev; + found_end |= is_first_match(compl_shown_match); + } + else + { + if (!allow_get_expansion) + { + if (advance) + { + 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()) + --compl_pending; + else + ++compl_pending; + } + + // Find matches. + *num_matches = ins_compl_get_exp(&compl_startpos); + + // handle any pending completions + while (compl_pending != 0 && compl_direction == compl_shows_dir + && advance) + { + if (compl_pending > 0 && compl_shown_match->cp_next != NULL) + { + compl_shown_match = compl_shown_match->cp_next; + --compl_pending; + } + if (compl_pending < 0 && compl_shown_match->cp_prev != NULL) + { + compl_shown_match = compl_shown_match->cp_prev; + ++compl_pending; + } + else + break; + } + found_end = FALSE; + } + + leader = get_leader_for_startcol(compl_shown_match, FALSE); + + if (!match_at_original_text(compl_shown_match) + && leader->string != NULL + && !ins_compl_equal(compl_shown_match, + leader->string, (int)leader->length) + && !(cot_fuzzy() + && compl_shown_match->cp_score != FUZZY_SCORE_NONE)) + ++todo; + else + // Remember a matching item. + found_compl = compl_shown_match; + + // Stop at the end of the list when we found a usable match. + if (found_end) + { + if (found_compl != NULL) + { + compl_shown_match = found_compl; + break; + } + todo = 1; // use first usable match after wrapping around + } + } + + return OK; +} + +/* + * Fill in the next completion in the current direction. + * If "allow_get_expansion" is TRUE, then we may call ins_compl_get_exp() to + * get more completions. If it is FALSE, then we just do nothing when there + * are no more completions in a given direction. The latter case is used when + * we are still in the middle of finding completions, to allow browsing + * through the ones found so far. + * Return the total number of matches, or -1 if still unknown -- webb. + * + * compl_curr_match is currently being used by ins_compl_get_exp(), so we use + * compl_shown_match here. + * + * Note that this function may be called recursively once only. First with + * "allow_get_expansion" TRUE, which calls ins_compl_get_exp(), which in turn + * calls this function with "allow_get_expansion" FALSE. + */ + static int +ins_compl_next( + int allow_get_expansion, + int count, // repeat completion this many times; should + // be at least 1 + int insert_match) // Insert the newly selected match +{ + int num_matches = -1; + int todo = count; + int advance; + int started = compl_started; + buf_T *orig_curbuf = curbuf; + unsigned int cur_cot_flags = get_cot_flags(); + int compl_no_insert = (cur_cot_flags & COT_NOINSERT) != 0 + || (compl_autocomplete && !ins_compl_has_preinsert()); + int compl_preinsert = ins_compl_has_preinsert(); + int has_autocomplete_delay = (compl_autocomplete && p_acl > 0); + + // 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.string != NULL + && !match_at_original_text(compl_shown_match) + && !cot_fuzzy()) + // Update "compl_shown_match" to the actually shown match + ins_compl_update_shown_match(); + + if (allow_get_expansion && insert_match + && (!compl_get_longest || compl_used_match)) + // Delete old text to be replaced + ins_compl_delete(); + + // When finding the longest common text we stick at the original text, + // don't let CTRL-N or CTRL-P move to the first match. + advance = count != 1 || !allow_get_expansion || !compl_get_longest; + + // When restarting the search don't insert the first match either. + if (compl_restarting) + { + advance = FALSE; + compl_restarting = FALSE; + } + + // Repeat this for when <PageUp> or <PageDown> is typed. But don't wrap + // around. + if (find_next_completion_match(allow_get_expansion, todo, advance, + &num_matches) == -1) + return -1; + + if (curbuf != orig_curbuf) + { + // In case some completion function switched buffer, don't want to + // insert the completion elsewhere. + return -1; + } + + // Insert the text of the new completion, or the compl_leader. + if (!started && ins_compl_preinsert_longest()) + { + ins_compl_insert(TRUE, TRUE); + if (has_autocomplete_delay) + update_screen(0); // Show the inserted text right away + } + else if (compl_no_insert && !started && !compl_preinsert) + { + ins_compl_insert_bytes(compl_orig_text.string + get_compl_len(), -1); + compl_used_match = FALSE; + } + else if (insert_match) + { + if (!compl_get_longest || compl_used_match) + { + int preinsert_longest = ins_compl_preinsert_longest() + && match_at_original_text(compl_shown_match); // none selected + ins_compl_insert(compl_preinsert || preinsert_longest, + preinsert_longest); + } + else + ins_compl_insert_bytes(compl_leader.string + get_compl_len(), -1); + } + else + compl_used_match = FALSE; + + if (!allow_get_expansion) + { + // may undisplay the popup menu first + ins_compl_upd_pum(); + + if (pum_enough_matches() && !has_autocomplete_delay) + // Will display the popup menu, don't redraw yet to avoid flicker. + pum_call_update_screen(); + else + // Not showing the popup menu yet, redraw to show the user what was + // inserted. + update_screen(0); + + if (!has_autocomplete_delay) + { + // display the updated popup menu + ins_compl_show_pum(); +#ifdef FEAT_GUI + if (gui.in_use) + { + // Show the cursor after the match, not after the redrawn text. + setcursor(); + out_flush_cursor(FALSE, FALSE); + } +#endif + } + + // Delete old text to be replaced, since we're still searching and + // don't want to match ourselves! + ins_compl_delete(); + } + + // Enter will select a match when the match wasn't inserted and the popup + // menu is visible. + if (compl_no_insert && !started + && !match_at_original_text(compl_shown_match)) + compl_enter_selects = TRUE; + else + compl_enter_selects = !insert_match && compl_match_array != NULL; + + // Show the file name for the match (if any) + if (compl_shown_match->cp_fname != NULL) + ins_compl_show_filename(); + + return num_matches; +} + +/* + * Check if the current completion source exceeded its timeout. If so, stop + * collecting, and halve the timeout. + */ + static void +check_elapsed_time(void) +{ +#ifdef ELAPSED_FUNC + elapsed_T *start_tv + = &cpt_sources_array[cpt_sources_index].compl_start_tv; + long elapsed_ms = ELAPSED_FUNC(*start_tv); + + if (elapsed_ms > compl_timeout_ms) + { + compl_time_slice_expired = TRUE; + DECAY_COMPL_TIMEOUT(); + } +#endif +} + +/* + * Call this while finding completions, to check whether the user has hit a key + * that should change the currently displayed completion, or exit completion + * mode. Also, when compl_pending is not zero, show a completion as soon as + * possible. -- webb + * "frequency" specifies out of how many calls we actually check. + * "in_compl_func" is TRUE when called from complete_check(), don't set + * compl_curr_match. + */ + void +ins_compl_check_keys(int frequency, int in_compl_func) +{ + static int count = 0; + int c; + + // Don't check when reading keys from a script, :normal or feedkeys(). + // That would break the test scripts. But do check for keys when called + // from complete_check(). + if (!in_compl_func && (using_script() || ex_normal_busy)) + return; + + // Only do this at regular intervals + if (++count < frequency) + return; + count = 0; + + // Check for a typed key. Do use mappings, otherwise mnv_is_ctrl_x_key() + // can't do its work correctly. + c = vpeekc_any(); + if (c != NUL +#ifdef FEAT_EVAL + // If test_override("char_avail", 1) was called, ignore characters + // waiting in the typeahead buffer. + && !disable_char_avail_for_testing +#endif + ) + { + if (mnv_is_ctrl_x_key(c) && c != Ctrl_X && c != Ctrl_R) + { + c = safe_vgetc(); // Eat the character + compl_shows_dir = ins_compl_key2dir(c); + (void)ins_compl_next(FALSE, ins_compl_key2count(c), + c != K_UP && c != K_DOWN); + } + else + { + // Need to get the character to have KeyTyped set. We'll put it + // back with vungetc() below. But skip K_IGNORE. + c = safe_vgetc(); + if (c != K_IGNORE) + { + // Don't interrupt completion when the character wasn't typed, + // e.g., when doing @q to replay keys. + if (c != Ctrl_R && KeyTyped) + compl_interrupted = TRUE; + + vungetc(c); + } + } + } + else + { + int normal_mode_strict = ctrl_x_mode_normal() + && !ctrl_x_mode_line_or_eval() && !(compl_cont_status & CONT_LOCAL) + && cpt_sources_array != NULL && cpt_sources_index >= 0; + if (normal_mode_strict && (compl_autocomplete || p_cto > 0)) + check_elapsed_time(); + } + + if (compl_pending + && !got_int + && !(cot_flags & (COT_NOINSERT | COT_FUZZY)) + && (!compl_autocomplete || ins_compl_has_preinsert())) + { + // Insert the first match immediately and advance compl_shown_match, + // before finding other matches. + int todo = compl_pending > 0 ? compl_pending : -compl_pending; + + compl_pending = 0; + (void)ins_compl_next(FALSE, todo, TRUE); + } +} + +/* + * Decide the direction of Insert mode complete from the key typed. + * Returns BACKWARD or FORWARD. + */ + static int +ins_compl_key2dir(int c) +{ + if (c == Ctrl_P || c == Ctrl_L + || c == K_PAGEUP || c == K_KPAGEUP || c == K_S_UP || c == K_UP) + return BACKWARD; + return FORWARD; +} + +/* + * Return TRUE for keys that are used for completion only when the popup menu + * is visible. + */ + static int +ins_compl_pum_key(int c) +{ + return pum_visible() && (c == K_PAGEUP || c == K_KPAGEUP || c == K_S_UP + || c == K_PAGEDOWN || c == K_KPAGEDOWN || c == K_S_DOWN + || c == K_UP || c == K_DOWN); +} + +/* + * Decide the number of completions to move forward. + * Returns 1 for most keys, height of the popup menu for page-up/down keys. + */ + static int +ins_compl_key2count(int c) +{ + if (ins_compl_pum_key(c) && c != K_UP && c != K_DOWN) + { + int h = pum_get_height(); + if (h > 3) + h -= 2; // keep some context + return h; + } + return 1; +} + +/* + * Return TRUE if completion with "c" should insert the match, FALSE if only + * to change the currently selected completion. + */ + static int +ins_compl_use_match(int c) +{ + switch (c) + { + case K_UP: + case K_DOWN: + case K_PAGEDOWN: + case K_KPAGEDOWN: + case K_S_DOWN: + case K_PAGEUP: + case K_KPAGEUP: + case K_S_UP: + return FALSE; + } + return TRUE; +} + +/* + * Get the pattern, column and length for normal completion (CTRL-N CTRL-P + * completion) + * Sets the global variables: compl_col, compl_length and compl_pattern. + * 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_path_defines()) + { + if (!compl_status_adding()) + { + while (--startcol >= 0 && mnv_isIDc(line[startcol])) + ; + compl_col += ++startcol; + compl_length = curs_col - startcol; + } + if (p_ic) + { + compl_pattern.string = str_foldcase(line + compl_col, + compl_length, NULL, 0); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + compl_pattern.length = STRLEN(compl_pattern.string); + } + else + { + compl_pattern.string = mnv_strnsave(line + compl_col, (size_t)compl_length); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + compl_pattern.length = (size_t)compl_length; + } + } + else if (compl_status_adding()) + { + char_u *prefix = (char_u *)"\\<"; + size_t prefixlen = STRLEN_LITERAL("\\<"); + size_t n; + + if (!mnv_iswordp(line + compl_col) + || (compl_col > 0 + && (mnv_iswordp(mb_prevptr(line, line + compl_col))))) + { + prefix = (char_u *)""; + prefixlen = 0; + } + + // we need up to 2 extra chars for the prefix + n = quote_meta(NULL, line + compl_col, compl_length) + prefixlen; + compl_pattern.string = alloc(n); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + STRCPY((char *)compl_pattern.string, prefix); + (void)quote_meta(compl_pattern.string + prefixlen, + line + compl_col, compl_length); + compl_pattern.length = n - 1; + } + else if (--startcol < 0 + || !mnv_iswordp(mb_prevptr(line, line + startcol + 1))) + { + size_t len = STRLEN_LITERAL("\\<\\k\\k"); + + // Match any word of at least two chars + compl_pattern.string = mnv_strnsave((char_u *)"\\<\\k\\k", len); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + compl_pattern.length = len; + compl_col += curs_col; + compl_length = 0; + compl_from_nonkeyword = TRUE; + } + else + { + // Search the point of change class of multibyte character + // or not a word single byte character backward. + if (has_mbyte) + { + int base_class; + int head_off; + + startcol -= (*mb_head_off)(line, line + startcol); + base_class = mb_get_class(line + startcol); + while (--startcol >= 0) + { + head_off = (*mb_head_off)(line, line + startcol); + if (base_class != mb_get_class(line + startcol + - head_off)) + break; + startcol -= head_off; + } + } + else + { + while (--startcol >= 0 && mnv_iswordc(line[startcol])) + ; + } + + compl_col += ++startcol; + compl_length = (int)curs_col - startcol; + if (compl_length == 1) + { + // Only match word with at least two chars -- webb + // there's no need to call quote_meta, + // alloc(7) is enough -- Acevedo + compl_pattern.string = alloc(7); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + STRCPY((char *)compl_pattern.string, "\\<"); + (void)quote_meta(compl_pattern.string + 2, line + compl_col, 1); + STRCAT((char *)compl_pattern.string, "\\k"); + compl_pattern.length = STRLEN(compl_pattern.string); + } + else + { + size_t n = quote_meta(NULL, line + compl_col, compl_length) + 2; + + compl_pattern.string = alloc(n); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + STRCPY((char *)compl_pattern.string, "\\<"); + (void)quote_meta(compl_pattern.string + 2, line + compl_col, + compl_length); + compl_pattern.length = n - 1; + } + } + + // Call functions in 'complete' with 'findstart=1' + if (ctrl_x_mode_normal() && !(compl_cont_status & CONT_LOCAL)) + { + // ^N completion, not complete() or ^X^N + if (setup_cpt_sources() == FAIL || prepare_cpt_compl_funcs() == FAIL) + return FAIL; + } + + return OK; +} + +/* + * Get the pattern, column and length for whole line completion or for the + * complete() function. + * Sets the global variables: compl_col, compl_length and compl_pattern. + */ + static int +get_wholeline_compl_info(char_u *line, colnr_T curs_col) +{ + compl_col = (colnr_T)getwhitecols(line); + compl_length = (int)curs_col - (int)compl_col; + if (compl_length < 0) // cursor in indent: empty pattern + compl_length = 0; + if (p_ic) + { + compl_pattern.string = str_foldcase(line + compl_col, compl_length, + NULL, 0); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + compl_pattern.length = STRLEN(compl_pattern.string); + } + else + { + compl_pattern.string = mnv_strnsave(line + compl_col, (size_t)compl_length); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + compl_pattern.length = (size_t)compl_length; + } + + return OK; +} + +/* + * Get the pattern, column and length for filename completion. + * Sets the global variables: compl_col, compl_length and compl_pattern. + */ + static int +get_filename_compl_info(char_u *line, int startcol, colnr_T curs_col) +{ + // Go back to just before the first filename character. + if (startcol > 0) + { + char_u *p = line + startcol; + + MB_PTR_BACK(line, p); + while (p > line && mnv_isfilec(PTR2CHAR(p))) + MB_PTR_BACK(line, p); + if (p == line && mnv_isfilec(PTR2CHAR(p))) + startcol = 0; + else + startcol = (int)(p - line) + 1; + } + + compl_col += startcol; + compl_length = (int)curs_col - startcol; + compl_pattern.string = addstar(line + compl_col, compl_length, EXPAND_FILES); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + + compl_pattern.length = STRLEN(compl_pattern.string); + + return OK; +} + +/* + * Get the pattern, column and length for command-line completion. + * Sets the global variables: compl_col, compl_length and compl_pattern. + */ + static int +get_cmdline_compl_info(char_u *line, colnr_T curs_col) +{ + compl_pattern.string = mnv_strnsave(line, curs_col); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + compl_pattern.length = curs_col; + set_cmd_context(&compl_xp, compl_pattern.string, + (int)compl_pattern.length, curs_col, FALSE); + if (compl_xp.xp_context == EXPAND_UNSUCCESSFUL + || compl_xp.xp_context == EXPAND_NOTHING) + // No completion possible, use an empty pattern to get a + // "pattern not found" message. + compl_col = curs_col; + else + compl_col = (int)(compl_xp.xp_pattern - compl_pattern.string); + compl_length = curs_col - compl_col; + + return OK; +} + +#ifdef FEAT_COMPL_FUNC +/* + * Set global variables related to completion: + * compl_col, compl_length, compl_pattern, and cpt_compl_pattern. + */ + static int +set_compl_globals( + int startcol UNUSED, + colnr_T curs_col UNUSED, + int is_cpt_compl UNUSED) +{ + if (is_cpt_compl) + { + MNV_CLEAR_STRING(cpt_compl_pattern); + if (startcol < compl_col) + return prepend_startcol_text(&cpt_compl_pattern, &compl_orig_text, + startcol); + else + { + cpt_compl_pattern.string = mnv_strnsave(compl_orig_text.string, + compl_orig_text.length); + cpt_compl_pattern.length = compl_orig_text.length; + } + } + else + { + if (startcol < 0 || startcol > curs_col) + startcol = curs_col; + + // Re-obtain line in case it has changed + char_u *line = ml_get(curwin->w_cursor.lnum); + int len = curs_col - startcol; + + compl_pattern.string = mnv_strnsave(line + startcol, (size_t)len); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + compl_pattern.length = (size_t)len; + compl_col = startcol; + compl_length = len; + } + + return OK; +} +#endif + +/* + * Get the pattern, column and length for user defined completion ('omnifunc', + * 'completefunc' and 'thesaurusfunc') + * Uses the global variable: spell_bad_len + * Callback function "cb" is set if triggered by a function in the 'cpt' + * option; otherwise, it is NULL. + * "startcol", when not NULL, contains the column returned by function. + */ + static int +get_userdefined_compl_info( + colnr_T curs_col UNUSED, + callback_T *cb UNUSED, + int *startcol UNUSED) +{ + int ret = FAIL; + +#ifdef FEAT_COMPL_FUNC + // Call user defined function 'completefunc' with "a:findstart" + // set to 1 to obtain the length of text to use for completion. + typval_T args[3]; + int col; + char_u *funcname = NULL; + pos_T pos; + int save_State = State; + int is_cpt_function = (cb != NULL); + + if (!is_cpt_function) + { + // 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_function() + ? "completefunc" : "omnifunc"); + return FAIL; + } + cb = get_insert_callback(ctrl_x_mode); + } + + args[0].v_type = VAR_NUMBER; + args[0].vval.v_number = 1; + args[1].v_type = VAR_STRING; + args[1].vval.v_string = (char_u *)""; + args[2].v_type = VAR_UNKNOWN; + pos = curwin->w_cursor; + ++textlock; + col = call_callback_retnr(cb, 2, args); + --textlock; + + State = save_State; + curwin->w_cursor = pos; // restore the cursor position + check_cursor(); // make sure cursor position is valid, just in case + validate_cursor(); + if (!EQUAL_POS(curwin->w_cursor, pos)) + { + emsg(_(e_complete_function_deleted_text)); + return FAIL; + } + + if (startcol != NULL) + *startcol = col; + + // Return value -2 means the user complete function wants to cancel the + // complete without an error, do the same if the function did not execute + // successfully. + if (col == -2 || aborting()) + return FAIL; + + // Return value -3 does the same as -2 and leaves CTRL-X mode. + if (col == -3) + { + if (is_cpt_function) + return FAIL; + ctrl_x_mode = CTRL_X_NORMAL; + edit_submode = NULL; + if (!shortmess(SHM_COMPLETIONMENU)) + msg_clr_cmdline(); + return FAIL; + } + + // Reset extended parameters of completion, when starting new + // completion. + compl_opt_refresh_always = FALSE; + compl_opt_suppress_empty = FALSE; + + ret = !is_cpt_function ? set_compl_globals(col, curs_col, FALSE) : OK; +#endif + + return ret; +} + +/* + * Get the pattern, column and length for spell completion. + * Sets the global variables: compl_col, compl_length and compl_pattern. + * Uses the global variable: spell_bad_len + */ + static int +get_spell_compl_info(int startcol UNUSED, colnr_T curs_col UNUSED) +{ + int ret = FAIL; +#ifdef FEAT_SPELL + char_u *line = NULL; + + if (spell_bad_len > 0) + compl_col = curs_col - spell_bad_len; + else + compl_col = spell_word_start(startcol); + + if (compl_col >= (colnr_T)startcol) + { + compl_length = 0; + compl_col = curs_col; + } + else + { + spell_expand_check_cap(compl_col); + compl_length = (int)curs_col - compl_col; + } + // Need to obtain "line" again, it may have become invalid. + line = ml_get(curwin->w_cursor.lnum); + compl_pattern.string = mnv_strnsave(line + compl_col, (size_t)compl_length); + if (compl_pattern.string == NULL) + { + compl_pattern.length = 0; + return FAIL; + } + + compl_pattern.length = (size_t)compl_length; + ret = OK; +#endif + + 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_normal() || ctrl_x_mode_register() + || (ctrl_x_mode & CTRL_X_WANT_IDENT + && !thesaurus_func_complete(ctrl_x_mode))) + { + if (get_normal_compl_info(line, startcol, curs_col) != OK) + return FAIL; + *line_invalid = TRUE; // 'cpt' func may have invalidated "line" + } + else if (ctrl_x_mode_line_or_eval()) + { + return get_wholeline_compl_info(line, curs_col); + } + 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_function() || ctrl_x_mode_omni() + || thesaurus_func_complete(ctrl_x_mode)) + { + if (get_userdefined_compl_info(curs_col, NULL, NULL) != OK) + return FAIL; + *line_invalid = TRUE; // "line" may have become invalid + } + 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 + } + else + { + internal_error("ins_complete()"); + return FAIL; + } + + return OK; +} + +/* + * Continue an interrupted completion mode search in "line". + * + * If this same ctrl_x_mode has been interrupted use the text from + * "compl_startpos" to the cursor as a pattern to add a new word instead of + * expand the one before the cursor, in word-wise if "compl_startpos" is not in + * the same line as the cursor then fix it (the line has been split because it + * was longer than 'tw'). if SOL is set then skip the previous pattern, a word + * at the beginning of the line has been inserted, we'll look for that. + */ + 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_normal() || ctrl_x_mode_path_patterns() + || ctrl_x_mode_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 + // include it to get a better pattern, but then we don't + // want the "\\<" prefix, check it below + compl_col = (colnr_T)getwhitecols(line); + compl_startpos.col = compl_col; + compl_startpos.lnum = curwin->w_cursor.lnum; + compl_cont_status &= ~CONT_SOL; // clear SOL if present + } + else + { + // S_IPOS was set when we inserted a word that was at the + // beginning of the line, which means that we'll go to SOL + // mode but first we need to redefine compl_startpos + if (compl_cont_status & CONT_S_IPOS) + { + compl_cont_status |= CONT_SOL; + compl_startpos.col = (colnr_T)(skipwhite( + line + compl_length + + compl_startpos.col) - line); + } + compl_col = compl_startpos.col; + } + compl_length = curwin->w_cursor.col - (int)compl_col; + // IObuff is used to add a "word from the next line" would we + // have enough space? just being paranoid +#define MIN_SPACE 75 + if (compl_length > (IOSIZE - MIN_SPACE)) + { + compl_cont_status &= ~CONT_SOL; + compl_length = (IOSIZE - MIN_SPACE); + compl_col = curwin->w_cursor.col - compl_length; + } + compl_cont_status |= CONT_ADDING | CONT_N_ADDS; + if (compl_length < 1) + compl_cont_status &= CONT_LOCAL; + } + else if (ctrl_x_mode_line_or_eval() || ctrl_x_mode_register()) + compl_cont_status = CONT_ADDING | CONT_N_ADDS; + else + compl_cont_status = 0; +} + +/* + * start insert mode completion + */ + static int +ins_compl_start(void) +{ + char_u *line = NULL; + int startcol = 0; // column where searched text starts + colnr_T curs_col; // cursor column + int line_invalid = FALSE; + int save_did_ai = did_ai; + int flags = CP_ORIGINAL_TEXT; + + // First time we hit ^N or ^P (in a row, I mean) + did_ai = FALSE; + did_si = FALSE; + can_si = FALSE; + can_si_back = FALSE; + if (stop_arrow() == FAIL) + { + did_ai = save_did_ai; + return FAIL; + } + + line = ml_get(curwin->w_cursor.lnum); + curs_col = curwin->w_cursor.col; + compl_pending = 0; + compl_lnum = curwin->w_cursor.lnum; + + if ((compl_cont_status & CONT_INTRPT) == CONT_INTRPT + && compl_cont_mode == ctrl_x_mode) + // this same ctrl-x_mode was interrupted previously. Continue the + // completion. + ins_compl_continue_search(line); + else + compl_cont_status &= CONT_LOCAL; + + if (!compl_status_adding()) // normal expansion + { + compl_cont_mode = ctrl_x_mode; + 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; + compl_col = 0; + } + + // Work out completion pattern and original text -- webb + if (compl_get_info(line, startcol, curs_col, &line_invalid) == FAIL) + { + if (ctrl_x_mode_function() || ctrl_x_mode_omni() + || 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_status_adding()) + { + if (!shortmess(SHM_COMPLETIONMENU)) + edit_submode_pre = (char_u *)_(" Adding"); + if (ctrl_x_mode_line_or_eval()) + { + // Insert a new line, keep indentation but ignore 'comments'. + char_u *old = curbuf->b_p_com; + + curbuf->b_p_com = (char_u *)""; + compl_startpos.lnum = curwin->w_cursor.lnum; + compl_startpos.col = compl_col; + ins_eol('\r'); + curbuf->b_p_com = old; + compl_length = 0; + compl_col = curwin->w_cursor.col; + compl_lnum = curwin->w_cursor.lnum; + } + } + else + { + edit_submode_pre = NULL; + compl_startpos.col = compl_col; + } + + if (!shortmess(SHM_COMPLETIONMENU) && !compl_autocomplete) + { + if (compl_cont_status & CONT_LOCAL) + edit_submode = (char_u *)_(ctrl_x_msgs[CTRL_X_LOCAL_MSG]); + else + edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode)); + } + + // If any of the original typed text has been changed we need to fix + // the redo buffer. + ins_compl_fixRedoBufForLeader(NULL); + + // Always add completion for the original text. + MNV_CLEAR_STRING(compl_orig_text); + compl_orig_text.length = (size_t)compl_length; + compl_orig_text.string = mnv_strnsave(line + compl_col, (size_t)compl_length); + if (p_ic) + flags |= CP_ICASE; + if (compl_orig_text.string == NULL + || ins_compl_add(compl_orig_text.string, + (int)compl_orig_text.length, + NULL, NULL, NULL, 0, flags, FALSE, NULL, FUZZY_SCORE_NONE) != OK) + { + MNV_CLEAR_STRING(compl_pattern); + MNV_CLEAR_STRING(compl_orig_text); + did_ai = save_did_ai; + return FAIL; + } + + // showmode might reset the internal line pointers, so it must + // be called before line = ml_get(), or when this address is no + // longer needed. -- Acevedo. + if (!shortmess(SHM_COMPLETIONMENU) && !compl_autocomplete) + { + edit_submode_extra = (char_u *)_("-- Searching..."); + edit_submode_highl = HLF_COUNT; + showmode(); + edit_submode_extra = NULL; + out_flush(); + } + + did_ai = save_did_ai; + return OK; +} + +/* + * display the completion status message + */ + static void +ins_compl_show_statusmsg(void) +{ + // we found no match if the list has only the "compl_orig_text"-entry + if (is_first_match(compl_first_match->cp_next)) + { + edit_submode_extra = compl_status_adding() && compl_length > 1 + ? (char_u *)_("Hit end of paragraph") + : (char_u *)_("Pattern not found"); + edit_submode_highl = HLF_E; + } + + if (edit_submode_extra == NULL) + { + 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) + { + edit_submode_extra = (char_u *)_("Word from other line"); + edit_submode_highl = HLF_COUNT; + } + else if (compl_curr_match->cp_next == compl_curr_match->cp_prev) + { + edit_submode_extra = (char_u *)_("The only match"); + edit_submode_highl = HLF_COUNT; + compl_curr_match->cp_number = 1; + } + else + { +#if defined(FEAT_COMPL_FUNC) || defined(FEAT_EVAL) + // Update completion sequence number when needed. + if (compl_curr_match->cp_number == -1) + ins_compl_update_sequence_numbers(); +#endif + // The match should always have a sequence number now, this is + // just a safety check. + if (compl_curr_match->cp_number != -1) + { + // Space for 10 text chars. + 2x10-digit no.s = 31. + // Translations may need more than twice that. + static char_u match_ref[81]; + + if (compl_matches > 0) + mnv_snprintf((char *)match_ref, sizeof(match_ref), + _("match %d of %d"), + compl_curr_match->cp_number, compl_matches); + else + mnv_snprintf((char *)match_ref, sizeof(match_ref), + _("match %d"), + compl_curr_match->cp_number); + edit_submode_extra = match_ref; + edit_submode_highl = HLF_R; + if (dollar_vcol >= 0) + curs_columns(FALSE); + } + } + } + + // Show a message about what (completion) mode we're in. + if (!compl_opt_suppress_empty) + { + showmode(); + if (!shortmess(SHM_COMPLETIONMENU)) + { + if (edit_submode_extra != NULL) + { + if (!p_smd) + { + msg_hist_off = TRUE; + msg_attr((char *)edit_submode_extra, + edit_submode_highl < HLF_COUNT + ? HL_ATTR(edit_submode_highl) : 0); + msg_hist_off = FALSE; + } + } + else + msg_clr_cmdline(); // necessary for "noshowmode" + } + } +} + +/* + * Do Insert mode completion. + * Called when character "c" was typed, which has a meaning for completion. + * Returns OK if completion was done, FAIL if something failed (out of mem). + */ + int +ins_complete(int c, int enable_pum) +{ + int n; + int save_w_wrow; + int save_w_leftcol; + int insert_match; + int no_matches_found; +#ifdef ELAPSED_FUNC + elapsed_T compl_start_tv = {0}; // Time when match collection starts + int disable_ac_delay; + + disable_ac_delay = compl_started && ctrl_x_mode_normal() + && (c == Ctrl_N || c == Ctrl_P || c == Ctrl_R || ins_compl_pum_key(c)); +#endif + + compl_direction = ins_compl_key2dir(c); + insert_match = ins_compl_use_match(c); + + if (!compl_started) + { + if (ins_compl_start() == FAIL) + return FAIL; + } + else if (insert_match && stop_arrow() == FAIL) + return FAIL; + +#ifdef ELAPSED_FUNC + if (compl_autocomplete && p_acl > 0 && !disable_ac_delay) + ELAPSED_INIT(compl_start_tv); +#endif + compl_curr_win = curwin; + compl_curr_buf = curwin->w_buffer; + compl_shown_match = compl_curr_match; + compl_shows_dir = compl_direction; + compl_num_bests = 0; + + // Find next match (and following matches). + save_w_wrow = curwin->w_wrow; + save_w_leftcol = curwin->w_leftcol; + n = ins_compl_next(TRUE, ins_compl_key2count(c), insert_match); + + // Reset autocompletion timer expiry flag + if (compl_autocomplete) + compl_time_slice_expired = FALSE; + + // may undisplay the popup menu + ins_compl_upd_pum(); + + if (n > 1) // all matches have been found + compl_matches = n; + compl_curr_match = compl_shown_match; + compl_direction = compl_shows_dir; + + // Eat the ESC that vgetc() returns after a CTRL-C to avoid leaving Insert + // mode. + if (got_int && !global_busy) + { + (void)vgetc(); + got_int = FALSE; + } + + // we found no match if the list has only the "compl_orig_text"-entry + no_matches_found = is_first_match(compl_first_match->cp_next); + if (no_matches_found) + { + // 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_status_adding() + || (ctrl_x_mode_not_default() + && !ctrl_x_mode_path_patterns() + && !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; + else + compl_cont_status &= ~CONT_S_IPOS; + + if (!shortmess(SHM_COMPLETIONMENU) && !compl_autocomplete) + ins_compl_show_statusmsg(); + + // Wait for the autocompletion delay to expire +#ifdef ELAPSED_FUNC + if (compl_autocomplete && p_acl > 0 && !disable_ac_delay + && !no_matches_found && ELAPSED_FUNC(compl_start_tv) < p_acl) + { + cursor_on(); + setcursor(); + out_flush_cursor(FALSE, FALSE); + do + { + if (char_avail()) + { + if (ins_compl_preinsert_effect() + && ins_compl_win_active(curwin)) + { + ins_compl_delete(); // Remove pre-inserted text + compl_ins_end_col = compl_col; + } + ins_compl_restart(); + compl_interrupted = TRUE; + break; + } + else + ui_delay(2L, TRUE); + } while (ELAPSED_FUNC(compl_start_tv) < p_acl); + } +#endif + + // Show the popup menu, unless we got interrupted. + if (enable_pum && !compl_interrupted) + show_pum(save_w_wrow, save_w_leftcol); + + compl_was_interrupted = compl_interrupted; + compl_interrupted = FALSE; + + return OK; +} + +/* + * Enable autocompletion + */ + void +ins_compl_enable_autocomplete(void) +{ +#ifdef ELAPSED_FUNC + compl_autocomplete = TRUE; + compl_get_longest = FALSE; +#endif +} + +/* + * Remove (if needed) and show the popup menu + */ + static void +show_pum(int prev_w_wrow, int prev_w_leftcol) +{ + // RedrawingDisabled may be set when invoked through complete(). + int save_RedrawingDisabled = RedrawingDisabled; + RedrawingDisabled = 0; + + // If the cursor moved or the display scrolled we need to remove the pum + // first. + setcursor(); + if (prev_w_wrow != curwin->w_wrow || prev_w_leftcol != curwin->w_leftcol) + ins_compl_del_pum(); + + ins_compl_show_pum(); + setcursor(); + + RedrawingDisabled = save_RedrawingDisabled; +} + +/* + * Looks in the first "len" chars. of "src" for search-metachars. + * If dest is not NULL the chars. are copied there quoting (with + * a backslash) the metachars, and dest would be NUL terminated. + * Returns the length (needed) of dest + */ + static unsigned +quote_meta(char_u *dest, char_u *src, int len) +{ + unsigned m = (unsigned)len + 1; // one extra for the NUL + + for ( ; --len >= 0; src++) + { + switch (*src) + { + case '.': + case '*': + case '[': + if (ctrl_x_mode_dictionary() || ctrl_x_mode_thesaurus()) + break; + // FALLTHROUGH + case '~': + if (!magic_isset()) // quote these only if magic is set + break; + // FALLTHROUGH + case '\\': + if (ctrl_x_mode_dictionary() || ctrl_x_mode_thesaurus()) + break; + // FALLTHROUGH + case '^': // currently it's not needed. + case '$': + m++; + if (dest != NULL) + *dest++ = '\\'; + break; + } + if (dest != NULL) + *dest++ = *src; + // Copy remaining bytes of a multibyte character. + if (has_mbyte) + { + int mb_len = (*mb_ptr2len)(src) - 1; + if (mb_len > 0 && len >= mb_len) + for (int i = 0; i < mb_len; ++i) + { + --len; + ++src; + if (dest != NULL) + *dest++ = *src; + } + } + } + if (dest != NULL) + *dest = NUL; + + return m; +} + +#if defined(EXITFREE) + void +free_insexpand_stuff(void) +{ + MNV_CLEAR_STRING(compl_orig_text); +# ifdef FEAT_EVAL + free_callback(&cfu_cb); + free_callback(&ofu_cb); + free_callback(&tsrfu_cb); + clear_cpt_callbacks(&cpt_cb, cpt_cb_count); +# endif +} +#endif + +#ifdef FEAT_SPELL +/* + * Called when starting CTRL_X_SPELL mode: Move backwards to a previous badly + * spelled word, if there is one. + */ + static void +spell_back_to_badword(void) +{ + pos_T tpos = curwin->w_cursor; + + spell_bad_len = spell_move_to(curwin, BACKWARD, SMT_ALL, TRUE, NULL); + if (curwin->w_cursor.col != tpos.col) + start_arrow(&tpos); +} +#endif + +/* + * Reset the info associated with completion sources. + */ + static void +cpt_sources_clear(void) +{ + MNV_CLEAR(cpt_sources_array); + cpt_sources_index = -1; + cpt_sources_count = 0; +} + +/* + * Setup completion sources. + */ + static int +setup_cpt_sources(void) +{ + char_u buf[LSIZE]; + int slen; + int idx = 0; + int count; + char_u *p; + + cpt_sources_clear(); + + count = get_cpt_sources_count(); + if (count == 0) + return OK; + + cpt_sources_array = ALLOC_CLEAR_MULT(cpt_source_T, count); + if (cpt_sources_array == NULL) + return FAIL; + + for (p = curbuf->b_p_cpt; *p;) + { + while (*p == ',' || *p == ' ') // Skip delimiters + p++; + if (*p) // If not end of string, count this segment + { + cpt_sources_array[idx].cs_flag = *p; + slen = copy_option_part(&p, buf, LSIZE, ","); // Advance p + if (slen > 0) + { + char_u *caret = mnv_strchr(buf, '^'); + if (caret != NULL) + cpt_sources_array[idx].cs_max_matches + = atoi((char *)caret + 1); + } + idx++; + } + } + + cpt_sources_count = count; + return OK; +} + +/* + * Return TRUE if any of the completion sources have 'refresh' set to 'always'. + */ + static int +is_cpt_func_refresh_always(void) +{ +#ifdef FEAT_COMPL_FUNC + for (int i = 0; i < cpt_sources_count; i++) + if (cpt_sources_array[i].cs_refresh_always) + return TRUE; +#endif + return FALSE; +} + +/* + * Make the completion list non-cyclic. + */ + static void +ins_compl_make_linear(void) +{ + compl_T *m; + + if (compl_first_match == NULL || compl_first_match->cp_prev == NULL) + return; + m = compl_first_match->cp_prev; + m->cp_next = NULL; + compl_first_match->cp_prev = NULL; +} + +/* + * Remove the matches linked to the current completion source (as indicated by + * cpt_sources_index) from the completion list. + */ +#ifdef FEAT_COMPL_FUNC + static void +remove_old_matches(void) +{ + compl_T *current; + int shown_match_removed = FALSE; + int forward = (compl_first_match->cp_cpt_source_idx < 0); + + if (cpt_sources_index < 0) + return; + + compl_direction = forward ? FORWARD : BACKWARD; + compl_shows_dir = compl_direction; + + // When 'fuzzy' is enabled, items are not ordered by their original source + // order (cpt_sources_index). So, remove items one by one. + for (current = compl_first_match; current != NULL; ) + { + if (current->cp_cpt_source_idx == cpt_sources_index) + { + compl_T *to_delete = current; + + if (!shown_match_removed && compl_shown_match == current) + shown_match_removed = TRUE; + + current = current->cp_next; + + if (to_delete == compl_first_match) // node to remove is at head + { + compl_first_match = to_delete->cp_next; + compl_first_match->cp_prev = NULL; + } + else if (to_delete->cp_next == NULL) // node to remove is at tail + to_delete->cp_prev->cp_next = NULL; + else // node is in the moddle + { + to_delete->cp_prev->cp_next = to_delete->cp_next; + to_delete->cp_next->cp_prev = to_delete->cp_prev; + } + ins_compl_item_free(to_delete); + } + else + current = current->cp_next; + } + + // Re-assign compl_shown_match if necessary + if (shown_match_removed) + { + if (forward) + compl_shown_match = compl_first_match; + else + { // Last node will have the prefix that is being completed + for (current = compl_first_match; current->cp_next != NULL; + current = current->cp_next) + ; + compl_shown_match = current; + } + } + + // Re-assign compl_curr_match + compl_curr_match = compl_first_match; + for (current = compl_first_match; current != NULL; ) + { + if ((forward ? current->cp_cpt_source_idx < cpt_sources_index + : current->cp_cpt_source_idx > cpt_sources_index)) + { + compl_curr_match = forward ? current : current->cp_next; + current = current->cp_next; + } + else + break; + } +} +#endif + +/* + * Retrieve completion matches using the callback function "cb" and store the + * 'refresh:always' flag. + */ +#ifdef FEAT_COMPL_FUNC + static void +get_cpt_func_completion_matches(callback_T *cb UNUSED) +{ + cpt_source_T *cpt_src = &cpt_sources_array[cpt_sources_index]; + int startcol = cpt_src->cs_startcol; + + if (startcol == -2 || startcol == -3) + return; + + if (set_compl_globals(startcol, curwin->w_cursor.col, TRUE) == OK) + { + // Insert the leader string (previously removed) before expansion. + // This prevents flicker when `func` (e.g. an LSP client) is slow and + // calls 'sleep', which triggers out_flush(). + if (!cpt_src->cs_refresh_always) + ins_compl_insert_bytes(ins_compl_leader(), -1); + + expand_by_function(0, cpt_compl_pattern.string, cb); + + if (!cpt_src->cs_refresh_always) + ins_compl_delete(); + + cpt_src->cs_refresh_always = compl_opt_refresh_always; + compl_opt_refresh_always = FALSE; + } +} +#endif + +/* + * Retrieve completion matches from functions in the 'cpt' option where the + * 'refresh:always' flag is set. + */ + static void +cpt_compl_refresh(void) +{ +#ifdef FEAT_COMPL_FUNC + char_u *cpt; + char_u *p; + callback_T *cb = NULL; + int startcol, ret; + + // Make the completion list linear (non-cyclic) + ins_compl_make_linear(); + // Make a copy of 'cpt' in case the buffer gets wiped out + cpt = mnv_strsave(curbuf->b_p_cpt); + strip_caret_numbers_in_place(cpt); + + cpt_sources_index = 0; + for (p = cpt; *p;) + { + while (*p == ',' || *p == ' ') // Skip delimiters + p++; + if (*p == NUL) + break; + + if (cpt_sources_array[cpt_sources_index].cs_refresh_always) + { + cb = get_callback_if_cpt_func(p, cpt_sources_index); + if (cb) + { + remove_old_matches(); + ret = get_userdefined_compl_info(curwin->w_cursor.col, cb, + &startcol); + if (ret == FAIL) + { + if (startcol == -3) + cpt_sources_array[cpt_sources_index].cs_refresh_always + = FALSE; + else + startcol = -2; + } + else if (startcol < 0 || startcol > curwin->w_cursor.col) + startcol = curwin->w_cursor.col; + cpt_sources_array[cpt_sources_index].cs_startcol = startcol; + if (ret == OK) + { + compl_source_start_timer(cpt_sources_index); + get_cpt_func_completion_matches(cb); + } + } + } + + (void)copy_option_part(&p, IObuff, IOSIZE, ","); // Advance p + if (may_advance_cpt_index(p)) + (void)advance_cpt_sources_index_safe(); + } + cpt_sources_index = -1; + + mnv_free(cpt); + // Make the list cyclic + compl_matches = ins_compl_make_cyclic(); +#endif +} + +/* + * "preinserted()" function + */ + void +f_preinserted(typval_T *argvars UNUSED, typval_T *rettv UNUSED) +{ + if (ins_compl_preinsert_effect()) + rettv->vval.v_number = 1; +} |