aniani/vim
0
0
Fork 1
mirror of https://github.com/vim/vim.git synced 2025-07-04 23:07:33 -04:00
Code

patch 9.1.0685: too many strlen() calls in usercmd.c

Browse Source 
Problem:  too many strlen() calls in usercmd.c
Solution: refactor code to reduce the number or strlen() calls
          (John Marriott)

closes: #15516

Signed-off-by: John Marriott <basilisk@internode.on.net>
Signed-off-by: Christian Brabandt <cb@256bit.org>
This commit is contained in:
John Marriott 2024-08-20 20:57:23 +02:00 committed by Christian Brabandt
parent e44e64492c
commit 9e795852f3
No known key found for this signature in database
GPG Key ID: F3F92DA383FDDE09
3 changed files with 307 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/testdir/test_usercommands.vim
View File

@ -133,6 +133,10 @@ function Test_cmdmods()
\ 'silent verbose aboveleft belowright botright tab topleft vertical', \ 'silent verbose aboveleft belowright botright tab topleft vertical',
\ g:mods) \ g:mods)
kee keep keepm keepma keepmar keepmarks keepa keepalt keepj keepjumps
\ keepp keeppatterns MyCmd
call assert_equal('keepalt keepjumps keepmarks keeppatterns', g:mods)
let g:mods = '' let g:mods = ''
command! -nargs=* MyQCmd let g:mods .= '<q-mods> ' command! -nargs=* MyQCmd let g:mods .= '<q-mods> '

495
src/usercmd.c
View File

@ -16,6 +16,7 @@
typedef struct ucmd typedef struct ucmd
{ {
char_u *uc_name; // The command name char_u *uc_name; // The command name
size_t uc_namelen; // The length of the command name (excluding the NUL)
long_u uc_argt; // The argument type long_u uc_argt; // The argument type
char_u *uc_rep; // The command's replacement string char_u *uc_rep; // The command's replacement string
long uc_def; // The default value for a range/count long uc_def; // The default value for a range/count
@ -39,94 +40,100 @@ static int ucmd_locked = 0;
/* /*
* List of names for completion for ":command" with the EXPAND_ flag. * List of names for completion for ":command" with the EXPAND_ flag.
* Must be alphabetical for completion. * Must be alphabetical on the 'value' field for completion and because
* it is used by bsearch()!
*/ */
static struct static keyvalue_T command_complete_tab[] =
{ {
int expand; KEYVALUE_ENTRY(EXPAND_ARGLIST, "arglist"),
char *name; KEYVALUE_ENTRY(EXPAND_AUGROUP, "augroup"),
} command_complete[] = KEYVALUE_ENTRY(EXPAND_BEHAVE, "behave"),
{ #if defined(FEAT_EVAL)
{EXPAND_ARGLIST, "arglist"}, KEYVALUE_ENTRY(EXPAND_BREAKPOINT, "breakpoint"),
{EXPAND_AUGROUP, "augroup"}, #endif
{EXPAND_BEHAVE, "behave"}, KEYVALUE_ENTRY(EXPAND_BUFFERS, "buffer"),
{EXPAND_BUFFERS, "buffer"}, KEYVALUE_ENTRY(EXPAND_COLORS, "color"),
{EXPAND_COLORS, "color"}, KEYVALUE_ENTRY(EXPAND_COMMANDS, "command"),
{EXPAND_COMMANDS, "command"}, KEYVALUE_ENTRY(EXPAND_COMPILER, "compiler"),
{EXPAND_COMPILER, "compiler"},
#if defined(FEAT_CSCOPE) #if defined(FEAT_CSCOPE)
{EXPAND_CSCOPE, "cscope"}, KEYVALUE_ENTRY(EXPAND_CSCOPE, "cscope"),
#endif #endif
#if defined(FEAT_EVAL) #if defined(FEAT_EVAL)
{EXPAND_USER_DEFINED, "custom"}, KEYVALUE_ENTRY(EXPAND_USER_DEFINED, "custom"),
{EXPAND_USER_LIST, "customlist"}, KEYVALUE_ENTRY(EXPAND_USER_LIST, "customlist"),
#endif #endif
{EXPAND_DIFF_BUFFERS, "diff_buffer"}, KEYVALUE_ENTRY(EXPAND_DIFF_BUFFERS, "diff_buffer"),
{EXPAND_DIRECTORIES, "dir"}, KEYVALUE_ENTRY(EXPAND_DIRECTORIES, "dir"),
{EXPAND_ENV_VARS, "environment"}, KEYVALUE_ENTRY(EXPAND_DIRS_IN_CDPATH, "dir_in_path"),
{EXPAND_EVENTS, "event"}, KEYVALUE_ENTRY(EXPAND_ENV_VARS, "environment"),
{EXPAND_EXPRESSION, "expression"}, KEYVALUE_ENTRY(EXPAND_EVENTS, "event"),
{EXPAND_FILES, "file"}, KEYVALUE_ENTRY(EXPAND_EXPRESSION, "expression"),
{EXPAND_FILES_IN_PATH, "file_in_path"}, KEYVALUE_ENTRY(EXPAND_FILES, "file"),
{EXPAND_FILETYPE, "filetype"}, KEYVALUE_ENTRY(EXPAND_FILES_IN_PATH, "file_in_path"),
{EXPAND_FUNCTIONS, "function"}, KEYVALUE_ENTRY(EXPAND_FILETYPE, "filetype"),
{EXPAND_HELP, "help"}, KEYVALUE_ENTRY(EXPAND_FUNCTIONS, "function"),
{EXPAND_HIGHLIGHT, "highlight"}, KEYVALUE_ENTRY(EXPAND_HELP, "help"),
{EXPAND_HISTORY, "history"}, KEYVALUE_ENTRY(EXPAND_HIGHLIGHT, "highlight"),
KEYVALUE_ENTRY(EXPAND_HISTORY, "history"),
#if defined(FEAT_KEYMAP) #if defined(FEAT_KEYMAP)
{EXPAND_KEYMAP, "keymap"}, KEYVALUE_ENTRY(EXPAND_KEYMAP, "keymap"),
#endif #endif
#if defined(HAVE_LOCALE_H) || defined(X_LOCALE) #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
{EXPAND_LOCALES, "locale"}, KEYVALUE_ENTRY(EXPAND_LOCALES, "locale"),
#endif #endif
{EXPAND_MAPCLEAR, "mapclear"}, KEYVALUE_ENTRY(EXPAND_MAPCLEAR, "mapclear"),
{EXPAND_MAPPINGS, "mapping"}, KEYVALUE_ENTRY(EXPAND_MAPPINGS, "mapping"),
{EXPAND_MENUS, "menu"}, KEYVALUE_ENTRY(EXPAND_MENUS, "menu"),
{EXPAND_MESSAGES, "messages"}, KEYVALUE_ENTRY(EXPAND_MESSAGES, "messages"),
{EXPAND_OWNSYNTAX, "syntax"}, KEYVALUE_ENTRY(EXPAND_SETTINGS, "option"),
#if defined(FEAT_PROFILE) KEYVALUE_ENTRY(EXPAND_PACKADD, "packadd"),
{EXPAND_SYNTIME, "syntime"}, KEYVALUE_ENTRY(EXPAND_RUNTIME, "runtime"),
#endif
{EXPAND_SETTINGS, "option"},
{EXPAND_PACKADD, "packadd"},
{EXPAND_RUNTIME, "runtime"},
{EXPAND_SHELLCMD, "shellcmd"},
#if defined(FEAT_SIGNS)
{EXPAND_SIGN, "sign"},
#endif
{EXPAND_TAGS, "tag"},
{EXPAND_TAGS_LISTFILES, "tag_listfiles"},
{EXPAND_USER, "user"},
{EXPAND_USER_VARS, "var"},
#if defined(FEAT_EVAL) #if defined(FEAT_EVAL)
{EXPAND_BREAKPOINT, "breakpoint"}, KEYVALUE_ENTRY(EXPAND_SCRIPTNAMES, "scriptnames"),
{EXPAND_SCRIPTNAMES, "scriptnames"},
#endif #endif
{EXPAND_DIRS_IN_CDPATH, "dir_in_path"}, KEYVALUE_ENTRY(EXPAND_SHELLCMD, "shellcmd"),
{0, NULL} #if defined(FEAT_SIGNS)
KEYVALUE_ENTRY(EXPAND_SIGN, "sign"),
#endif
KEYVALUE_ENTRY(EXPAND_OWNSYNTAX, "syntax"),
#if defined(FEAT_PROFILE)
KEYVALUE_ENTRY(EXPAND_SYNTIME, "syntime"),
#endif
KEYVALUE_ENTRY(EXPAND_TAGS, "tag"),
KEYVALUE_ENTRY(EXPAND_TAGS_LISTFILES, "tag_listfiles"),
KEYVALUE_ENTRY(EXPAND_USER, "user"),
KEYVALUE_ENTRY(EXPAND_USER_VARS, "var")
}; };
typedef struct
{
cmd_addr_T key;
char *fullname;
size_t fullnamelen;
char *shortname;
size_t shortnamelen;
} addrtype_T;
/* /*
* List of names of address types. Must be alphabetical for completion. * List of names of address types. Must be alphabetical for completion.
* Must be sorted by the 'fullname' field because it is used by bsearch()!
*/ */
static struct #define ADDRTYPE_ENTRY(k, fn, sn) \
{(k), (fn), STRLEN_LITERAL(fn), (sn), STRLEN_LITERAL(sn)}
static addrtype_T addr_type_complete_tab[] =
{ {
cmd_addr_T expand; ADDRTYPE_ENTRY(ADDR_ARGUMENTS, "arguments", "arg"),
char *name; ADDRTYPE_ENTRY(ADDR_BUFFERS, "buffers", "buf"),
char *shortname; ADDRTYPE_ENTRY(ADDR_LINES, "lines", "line"),
} addr_type_complete[] = ADDRTYPE_ENTRY(ADDR_LOADED_BUFFERS, "loaded_buffers", "load"),
{ ADDRTYPE_ENTRY(ADDR_OTHER, "other", "?"),
{ADDR_ARGUMENTS, "arguments", "arg"}, ADDRTYPE_ENTRY(ADDR_QUICKFIX, "quickfix", "qf"),
{ADDR_LINES, "lines", "line"}, ADDRTYPE_ENTRY(ADDR_TABS, "tabs", "tab"),
{ADDR_LOADED_BUFFERS, "loaded_buffers", "load"}, ADDRTYPE_ENTRY(ADDR_WINDOWS, "windows", "win")
{ADDR_TABS, "tabs", "tab"},
{ADDR_BUFFERS, "buffers", "buf"},
{ADDR_WINDOWS, "windows", "win"},
{ADDR_QUICKFIX, "quickfix", "qf"},
{ADDR_OTHER, "other", "?"},
{ADDR_NONE, NULL, NULL}
}; };
static int cmp_addr_type(const void *a, const void *b);
/* /*
* Search for a user command that matches "eap->cmd". * Search for a user command that matches "eap->cmd".
* Return cmdidx in "eap->cmdidx", flags in "eap->argt", idx in "eap->useridx". * Return cmdidx in "eap->cmdidx", flags in "eap->argt", idx in "eap->useridx".
@ -272,19 +279,16 @@ set_context_in_user_cmd(expand_T *xp, char_u *arg_in)
{ {
xp->xp_context = EXPAND_USER_COMPLETE; xp->xp_context = EXPAND_USER_COMPLETE;
xp->xp_pattern = p + 1; xp->xp_pattern = p + 1;
return NULL;
} }
else if (STRNICMP(arg, "nargs", p - arg) == 0) else if (STRNICMP(arg, "nargs", p - arg) == 0)
{ {
xp->xp_context = EXPAND_USER_NARGS; xp->xp_context = EXPAND_USER_NARGS;
xp->xp_pattern = p + 1; xp->xp_pattern = p + 1;
return NULL;
} }
else if (STRNICMP(arg, "addr", p - arg) == 0) else if (STRNICMP(arg, "addr", p - arg) == 0)
{ {
xp->xp_context = EXPAND_USER_ADDR_TYPE; xp->xp_context = EXPAND_USER_ADDR_TYPE;
xp->xp_pattern = p + 1; xp->xp_pattern = p + 1;
return NULL;
} }
return NULL; return NULL;
} }
@ -417,7 +421,9 @@ get_user_command_name(int idx, int cmdidx)
char_u * char_u *
get_user_cmd_addr_type(expand_T *xp UNUSED, int idx) get_user_cmd_addr_type(expand_T *xp UNUSED, int idx)
{ {
return (char_u *)addr_type_complete[idx].name; if (idx < 0 || idx >= (int)ARRAY_LENGTH(addr_type_complete_tab))
return NULL;
return (char_u *)addr_type_complete_tab[idx].fullname;
} }
/* /*
@ -432,7 +438,7 @@ get_user_cmd_flags(expand_T *xp UNUSED, int idx)
"count", "nargs", "range", "register", "keepscript" "count", "nargs", "range", "register", "keepscript"
}; };
if (idx >= (int)ARRAY_LENGTH(user_cmd_flags)) if (idx < 0 || idx >= (int)ARRAY_LENGTH(user_cmd_flags))
return NULL; return NULL;
return (char_u *)user_cmd_flags[idx]; return (char_u *)user_cmd_flags[idx];
} }
@ -445,7 +451,7 @@ get_user_cmd_nargs(expand_T *xp UNUSED, int idx)
{ {
static char *user_cmd_nargs[] = {"0", "1", "*", "?", "+"}; static char *user_cmd_nargs[] = {"0", "1", "*", "?", "+"};
if (idx >= (int)ARRAY_LENGTH(user_cmd_nargs)) if (idx < 0 || idx >= (int)ARRAY_LENGTH(user_cmd_nargs))
return NULL; return NULL;
return (char_u *)user_cmd_nargs[idx]; return (char_u *)user_cmd_nargs[idx];
} }
@ -457,7 +463,24 @@ get_user_cmd_nargs(expand_T *xp UNUSED, int idx)
char_u * char_u *
get_user_cmd_complete(expand_T *xp UNUSED, int idx) get_user_cmd_complete(expand_T *xp UNUSED, int idx)
{ {
return (char_u *)command_complete[idx].name; if (idx < 0 || idx >= (int)ARRAY_LENGTH(command_complete_tab))
return NULL;
return (char_u *)command_complete_tab[idx].value;
}
/*
* Return the row in the command_complete_tab table that contains the given key.
*/
static keyvalue_T *
get_commandtype(int expand)
{
int i;
for (i = 0; i < (int)ARRAY_LENGTH(command_complete_tab); ++i)
if (command_complete_tab[i].key == expand)
return &command_complete_tab[i];
return NULL;
} }
#ifdef FEAT_EVAL #ifdef FEAT_EVAL
@ -467,13 +490,11 @@ get_user_cmd_complete(expand_T *xp UNUSED, int idx)
char_u * char_u *
cmdcomplete_type_to_str(int expand) cmdcomplete_type_to_str(int expand)
{ {
int i; keyvalue_T *kv;
for (i = 0; command_complete[i].expand != 0; i++) kv = get_commandtype(expand);
if (command_complete[i].expand == expand)
return (char_u *)command_complete[i].name;
return NULL; return (kv == NULL) ? NULL : (char_u *)kv->value;
} }
/* /*
@ -483,18 +504,35 @@ cmdcomplete_type_to_str(int expand)
int int
cmdcomplete_str_to_type(char_u *complete_str) cmdcomplete_str_to_type(char_u *complete_str)
{ {
int i; keyvalue_T target;
keyvalue_T *entry;
static keyvalue_T *last_entry = NULL; // cached result
if (STRNCMP(complete_str, "custom,", 7) == 0) if (STRNCMP(complete_str, "custom,", 7) == 0)
return EXPAND_USER_DEFINED; return EXPAND_USER_DEFINED;
if (STRNCMP(complete_str, "customlist,", 11) == 0) if (STRNCMP(complete_str, "customlist,", 11) == 0)
return EXPAND_USER_LIST; return EXPAND_USER_LIST;
for (i = 0; command_complete[i].expand != 0; ++i) target.key = 0;
if (STRCMP(complete_str, command_complete[i].name) == 0) target.value = (char *)complete_str;
return command_complete[i].expand; target.length = 0; // not used, see cmp_keyvalue_value()
if (last_entry != NULL && cmp_keyvalue_value(&target, last_entry) == 0)
entry = last_entry;
else
{
entry = (keyvalue_T *)bsearch(&target,
&command_complete_tab,
ARRAY_LENGTH(command_complete_tab),
sizeof(command_complete_tab[0]),
cmp_keyvalue_value);
if (entry == NULL)
return EXPAND_NOTHING; return EXPAND_NOTHING;
last_entry = entry;
}
return entry->key;
} }
#endif #endif
@ -511,6 +549,7 @@ uc_list(char_u *name, size_t name_len)
int over; int over;
long a; long a;
garray_T *gap; garray_T *gap;
keyvalue_T *entry;
// don't allow for adding or removing user commands here // don't allow for adding or removing user commands here
++ucmd_locked; ++ucmd_locked;
@ -564,7 +603,7 @@ uc_list(char_u *name, size_t name_len)
msg_putchar(' '); msg_putchar(' ');
msg_outtrans_attr(cmd->uc_name, HL_ATTR(HLF_D)); msg_outtrans_attr(cmd->uc_name, HL_ATTR(HLF_D));
len = (int)STRLEN(cmd->uc_name) + 4; len = (int)cmd->uc_namelen + 4;
do { do {
msg_putchar(' '); msg_putchar(' ');
@ -596,16 +635,14 @@ uc_list(char_u *name, size_t name_len)
if (a & EX_COUNT) if (a & EX_COUNT)
{ {
// -count=N // -count=N
sprintf((char *)IObuff + len, "%ldc", cmd->uc_def); len += vim_snprintf((char *)IObuff + len, IOSIZE - len, "%ldc", cmd->uc_def);
len += (int)STRLEN(IObuff + len);
} }
else if (a & EX_DFLALL) else if (a & EX_DFLALL)
IObuff[len++] = '%'; IObuff[len++] = '%';
else if (cmd->uc_def >= 0) else if (cmd->uc_def >= 0)
{ {
// -range=N // -range=N
sprintf((char *)IObuff + len, "%ld", cmd->uc_def); len += vim_snprintf((char *)IObuff + len, IOSIZE - len, "%ld", cmd->uc_def);
len += (int)STRLEN(IObuff + len);
} }
else else
IObuff[len++] = '.'; IObuff[len++] = '.';
@ -616,12 +653,12 @@ uc_list(char_u *name, size_t name_len)
} while (len < 8 - over); } while (len < 8 - over);
// Address Type // Address Type
for (j = 0; addr_type_complete[j].expand != ADDR_NONE; ++j) for (j = 0; j < (int)ARRAY_LENGTH(addr_type_complete_tab); ++j)
if (addr_type_complete[j].expand != ADDR_LINES if (addr_type_complete_tab[j].key != ADDR_LINES
&& addr_type_complete[j].expand == cmd->uc_addr_type) && addr_type_complete_tab[j].key == cmd->uc_addr_type)
{ {
STRCPY(IObuff + len, addr_type_complete[j].shortname); STRCPY(IObuff + len, addr_type_complete_tab[j].shortname);
len += (int)STRLEN(IObuff + len); len += (int)addr_type_complete_tab[j].shortnamelen;
break; break;
} }
@ -630,28 +667,31 @@ uc_list(char_u *name, size_t name_len)
} while (len < 13 - over); } while (len < 13 - over);
// Completion // Completion
for (j = 0; command_complete[j].expand != 0; ++j) entry = get_commandtype(cmd->uc_compl);
if (command_complete[j].expand == cmd->uc_compl) if (entry != NULL)
{ {
STRCPY(IObuff + len, command_complete[j].name); STRCPY(IObuff + len, entry->value);
len += (int)STRLEN(IObuff + len); len += entry->length;
#ifdef FEAT_EVAL #ifdef FEAT_EVAL
if (p_verbose > 0 && cmd->uc_compl_arg != NULL if (p_verbose > 0 && cmd->uc_compl_arg != NULL)
&& STRLEN(cmd->uc_compl_arg) < 200)
{ {
IObuff[len] = ','; size_t uc_compl_arglen = STRLEN(cmd->uc_compl_arg);
STRCPY(IObuff + len + 1, cmd->uc_compl_arg);
len += (int)STRLEN(IObuff + len); if (uc_compl_arglen < 200)
{
IObuff[len++] = ',';
STRCPY(IObuff + len, cmd->uc_compl_arg);
len += uc_compl_arglen;
}
} }
#endif #endif
break;
} }
do { do {
IObuff[len++] = ' '; IObuff[len++] = ' ';
} while (len < 25 - over); } while (len < 25 - over);
IObuff[len] = '\0'; IObuff[len] = NUL;
msg_outtrans(IObuff); msg_outtrans(IObuff);
msg_outtrans_special(cmd->uc_rep, FALSE, msg_outtrans_special(cmd->uc_rep, FALSE,
@ -687,7 +727,7 @@ uc_fun_cmd(void)
for (i = 0; fcmd[i]; ++i) for (i = 0; fcmd[i]; ++i)
IObuff[i] = fcmd[i] - 0x40; IObuff[i] = fcmd[i] - 0x40;
IObuff[i] = 0; IObuff[i] = NUL;
return (char *)IObuff; return (char *)IObuff;
} }
@ -700,21 +740,26 @@ parse_addr_type_arg(
int vallen, int vallen,
cmd_addr_T *addr_type_arg) cmd_addr_T *addr_type_arg)
{ {
int i, a, b; addrtype_T target;
addrtype_T *entry;
static addrtype_T *last_entry; // cached result
for (i = 0; addr_type_complete[i].expand != ADDR_NONE; ++i) target.key = 0;
{ target.fullname = (char *)value;
a = (int)STRLEN(addr_type_complete[i].name) == vallen; target.fullnamelen = vallen;
b = STRNCMP(value, addr_type_complete[i].name, vallen) == 0;
if (a && b)
{
*addr_type_arg = addr_type_complete[i].expand;
break;
}
}
if (addr_type_complete[i].expand == ADDR_NONE) if (last_entry != NULL && cmp_addr_type(&target, last_entry) == 0)
entry = last_entry;
else
{ {
entry = (addrtype_T *)bsearch(&target,
&addr_type_complete_tab,
ARRAY_LENGTH(addr_type_complete_tab),
sizeof(addr_type_complete_tab[0]),
cmp_addr_type);
if (entry == NULL)
{
int i;
char_u *err = value; char_u *err = value;
for (i = 0; err[i] != NUL && !VIM_ISWHITE(err[i]); i++) for (i = 0; err[i] != NUL && !VIM_ISWHITE(err[i]); i++)
@ -724,9 +769,23 @@ parse_addr_type_arg(
return FAIL; return FAIL;
} }
last_entry = entry;
}
*addr_type_arg = entry->key;
return OK; return OK;
} }
static int
cmp_addr_type(const void *a, const void *b)
{
addrtype_T *at1 = (addrtype_T *)a;
addrtype_T *at2 = (addrtype_T *)b;
return STRNCMP(at1->fullname, at2->fullname, MAX(at1->fullnamelen, at2->fullnamelen));
}
/* /*
* Parse a completion argument "value[vallen]". * Parse a completion argument "value[vallen]".
* The detected completion goes in "*complp", argument type in "*argt". * The detected completion goes in "*complp", argument type in "*argt".
@ -748,6 +807,9 @@ parse_compl_arg(
# endif # endif
int i; int i;
int valend = vallen; int valend = vallen;
keyvalue_T target;
keyvalue_T *entry;
static keyvalue_T *last_entry = NULL; // cached result
// Look for any argument part - which is the part after any ',' // Look for any argument part - which is the part after any ','
for (i = 0; i < vallen; ++i) for (i = 0; i < vallen; ++i)
@ -763,33 +825,40 @@ parse_compl_arg(
} }
} }
for (i = 0; command_complete[i].expand != 0; ++i) target.key = 0;
{ target.value = (char *)value;
if ((int)STRLEN(command_complete[i].name) == valend target.length = valend;
&& STRNCMP(value, command_complete[i].name, valend) == 0)
{
*complp = command_complete[i].expand;
if (command_complete[i].expand == EXPAND_BUFFERS)
*argt |= EX_BUFNAME;
else if (command_complete[i].expand == EXPAND_DIRECTORIES
|| command_complete[i].expand == EXPAND_FILES)
*argt |= EX_XFILE;
break;
}
}
if (command_complete[i].expand == 0) if (last_entry != NULL && cmp_keyvalue_value_n(&target, last_entry) == 0)
entry = last_entry;
else
{
entry = (keyvalue_T *)bsearch(&target,
&command_complete_tab,
ARRAY_LENGTH(command_complete_tab),
sizeof(command_complete_tab[0]),
cmp_keyvalue_value_n);
if (entry == NULL)
{ {
semsg(_(e_invalid_complete_value_str), value); semsg(_(e_invalid_complete_value_str), value);
return FAIL; return FAIL;
} }
last_entry = entry;
}
*complp = entry->key;
if (*complp == EXPAND_BUFFERS)
*argt |= EX_BUFNAME;
else if (*complp == EXPAND_DIRECTORIES || *complp == EXPAND_FILES)
*argt |= EX_XFILE;
if (
# if defined(FEAT_EVAL) # if defined(FEAT_EVAL)
if (*complp != EXPAND_USER_DEFINED && *complp != EXPAND_USER_LIST *complp != EXPAND_USER_DEFINED && *complp != EXPAND_USER_LIST
&& arg != NULL) &&
# else
if (arg != NULL)
# endif # endif
arg != NULL)
{ {
emsg(_(e_completion_argument_only_allowed_for_custom_completion)); emsg(_(e_completion_argument_only_allowed_for_custom_completion));
return FAIL; return FAIL;
@ -806,6 +875,7 @@ parse_compl_arg(
if (arg != NULL) if (arg != NULL)
*compl_arg = vim_strnsave(arg, arglen); *compl_arg = vim_strnsave(arg, arglen);
# endif # endif
return OK; return OK;
} }
@ -1023,16 +1093,13 @@ uc_add_command(
// Search for the command in the already defined commands. // Search for the command in the already defined commands.
for (i = 0; i < gap->ga_len; ++i) for (i = 0; i < gap->ga_len; ++i)
{ {
size_t len;
cmd = USER_CMD_GA(gap, i); cmd = USER_CMD_GA(gap, i);
len = STRLEN(cmd->uc_name);
cmp = STRNCMP(name, cmd->uc_name, name_len); cmp = STRNCMP(name, cmd->uc_name, name_len);
if (cmp == 0) if (cmp == 0)
{ {
if (name_len < len) if (name_len < cmd->uc_namelen)
cmp = -1; cmp = -1;
else if (name_len > len) else if (name_len > cmd->uc_namelen)
cmp = 1; cmp = 1;
} }
@ -1078,6 +1145,7 @@ uc_add_command(
++gap->ga_len; ++gap->ga_len;
cmd->uc_name = p; cmd->uc_name = p;
cmd->uc_namelen = name_len;
} }
cmd->uc_rep = rep_buf; cmd->uc_rep = rep_buf;
@ -1199,7 +1267,7 @@ ex_command(exarg_T *eap)
p = skipwhite(end); p = skipwhite(end);
if (!has_attr && ends_excmd2(eap->arg, p)) if (!has_attr && ends_excmd2(eap->arg, p))
{ {
uc_list(name, end - name); uc_list(name, name_len);
} }
else if (!ASCII_ISUPPER(*name)) else if (!ASCII_ISUPPER(*name))
{ {
@ -1282,6 +1350,7 @@ uc_clear(garray_T *gap)
{ {
cmd = USER_CMD_GA(gap, i); cmd = USER_CMD_GA(gap, i);
vim_free(cmd->uc_name); vim_free(cmd->uc_name);
cmd->uc_namelen = 0;
vim_free(cmd->uc_rep); vim_free(cmd->uc_rep);
# if defined(FEAT_EVAL) # if defined(FEAT_EVAL)
vim_free(cmd->uc_compl_arg); vim_free(cmd->uc_compl_arg);
@ -1439,30 +1508,31 @@ uc_split_args(char_u *arg, size_t *lenp)
} }
} }
*q++ = '"'; *q++ = '"';
*q = 0; *q = NUL;
*lenp = len; *lenp = len;
return buf; return buf;
} }
static size_t static size_t
add_cmd_modifier(char_u *buf, char *mod_str, int *multi_mods) add_cmd_modifier(char_u *buf, size_t buflen, char *mod_str, size_t mod_strlen, int *multi_mods)
{ {
size_t result;
result = STRLEN(mod_str);
if (*multi_mods)
result += 1;
if (buf != NULL) if (buf != NULL)
{ {
if (*multi_mods) if (*multi_mods)
STRCAT(buf, " "); {
STRCAT(buf, mod_str); STRCPY(buf + buflen, " "); // the separating space
++buflen;
}
STRCPY(buf + buflen, mod_str);
} }
if (*multi_mods)
++mod_strlen; // +1 for the separating space
else
*multi_mods = 1; *multi_mods = 1;
return result; return mod_strlen;
} }
/* /*
@ -1472,17 +1542,17 @@ add_cmd_modifier(char_u *buf, char *mod_str, int *multi_mods)
size_t size_t
add_win_cmd_modifiers(char_u *buf, cmdmod_T *cmod, int *multi_mods) add_win_cmd_modifiers(char_u *buf, cmdmod_T *cmod, int *multi_mods)
{ {
size_t result = 0; size_t buflen = 0;
// :aboveleft and :leftabove // :aboveleft and :leftabove
if (cmod->cmod_split & WSP_ABOVE) if (cmod->cmod_split & WSP_ABOVE)
result += add_cmd_modifier(buf, "aboveleft", multi_mods); buflen += add_cmd_modifier(buf, buflen, "aboveleft", STRLEN_LITERAL("aboveleft"), multi_mods);
// :belowright and :rightbelow // :belowright and :rightbelow
if (cmod->cmod_split & WSP_BELOW) if (cmod->cmod_split & WSP_BELOW)
result += add_cmd_modifier(buf, "belowright", multi_mods); buflen += add_cmd_modifier(buf, buflen, "belowright", STRLEN_LITERAL("belowright"), multi_mods);
// :botright // :botright
if (cmod->cmod_split & WSP_BOT) if (cmod->cmod_split & WSP_BOT)
result += add_cmd_modifier(buf, "botright", multi_mods); buflen += add_cmd_modifier(buf, buflen, "botright", STRLEN_LITERAL("botright"), multi_mods);
// :tab // :tab
if (cmod->cmod_tab > 0) if (cmod->cmod_tab > 0)
@ -1493,27 +1563,29 @@ add_win_cmd_modifiers(char_u *buf, cmdmod_T *cmod, int *multi_mods)
{ {
// For compatibility, don't add a tabpage number if it is the same // For compatibility, don't add a tabpage number if it is the same
// as the default number for :tab. // as the default number for :tab.
result += add_cmd_modifier(buf, "tab", multi_mods); buflen += add_cmd_modifier(buf, buflen, "tab", STRLEN_LITERAL("tab"), multi_mods);
} }
else else
{ {
char tab_buf[NUMBUFLEN + 3]; char tab_buf[NUMBUFLEN + 3];
size_t tab_buflen;
sprintf(tab_buf, "%dtab", tabnr); tab_buflen = vim_snprintf(tab_buf, sizeof(tab_buf), "%dtab", tabnr);
result += add_cmd_modifier(buf, tab_buf, multi_mods); buflen += add_cmd_modifier(buf, buflen, tab_buf, tab_buflen, multi_mods);
} }
} }
// :topleft // :topleft
if (cmod->cmod_split & WSP_TOP) if (cmod->cmod_split & WSP_TOP)
result += add_cmd_modifier(buf, "topleft", multi_mods); buflen += add_cmd_modifier(buf, buflen, "topleft", STRLEN_LITERAL("topleft"), multi_mods);
// :vertical // :vertical
if (cmod->cmod_split & WSP_VERT) if (cmod->cmod_split & WSP_VERT)
result += add_cmd_modifier(buf, "vertical", multi_mods); buflen += add_cmd_modifier(buf, buflen, "vertical", STRLEN_LITERAL("vertical"), multi_mods);
// :horizontal // :horizontal
if (cmod->cmod_split & WSP_HOR) if (cmod->cmod_split & WSP_HOR)
result += add_cmd_modifier(buf, "horizontal", multi_mods); buflen += add_cmd_modifier(buf, buflen, "horizontal", STRLEN_LITERAL("horizontal"), multi_mods);
return result;
return buflen;
} }
/* /*
@ -1523,78 +1595,92 @@ add_win_cmd_modifiers(char_u *buf, cmdmod_T *cmod, int *multi_mods)
size_t size_t
produce_cmdmods(char_u *buf, cmdmod_T *cmod, int quote) produce_cmdmods(char_u *buf, cmdmod_T *cmod, int quote)
{ {
size_t result = 0; size_t buflen = 0;
int multi_mods = 0; int multi_mods = 0;
int i; int i;
typedef struct { static keyvalue_T mod_entry_tab[] =
int flag; {
char *name;
} mod_entry_T;
static mod_entry_T mod_entries[] = {
#ifdef FEAT_BROWSE_CMD #ifdef FEAT_BROWSE_CMD
{CMOD_BROWSE, "browse"}, KEYVALUE_ENTRY(CMOD_BROWSE, "browse"),
#endif #endif
#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
{CMOD_CONFIRM, "confirm"}, KEYVALUE_ENTRY(CMOD_CONFIRM, "confirm"),
#endif #endif
{CMOD_HIDE, "hide"}, KEYVALUE_ENTRY(CMOD_HIDE, "hide"),
{CMOD_KEEPALT, "keepalt"}, KEYVALUE_ENTRY(CMOD_KEEPALT, "keepalt"),
{CMOD_KEEPJUMPS, "keepjumps"}, KEYVALUE_ENTRY(CMOD_KEEPJUMPS, "keepjumps"),
{CMOD_KEEPMARKS, "keepmarks"}, KEYVALUE_ENTRY(CMOD_KEEPMARKS, "keepmarks"),
{CMOD_KEEPPATTERNS, "keeppatterns"}, KEYVALUE_ENTRY(CMOD_KEEPPATTERNS, "keeppatterns"),
{CMOD_LOCKMARKS, "lockmarks"}, KEYVALUE_ENTRY(CMOD_LOCKMARKS, "lockmarks"),
{CMOD_NOSWAPFILE, "noswapfile"}, KEYVALUE_ENTRY(CMOD_NOSWAPFILE, "noswapfile"),
{CMOD_UNSILENT, "unsilent"}, KEYVALUE_ENTRY(CMOD_UNSILENT, "unsilent"),
{CMOD_NOAUTOCMD, "noautocmd"}, KEYVALUE_ENTRY(CMOD_NOAUTOCMD, "noautocmd"),
#ifdef HAVE_SANDBOX #ifdef HAVE_SANDBOX
{CMOD_SANDBOX, "sandbox"}, KEYVALUE_ENTRY(CMOD_SANDBOX, "sandbox"),
#endif #endif
{CMOD_LEGACY, "legacy"}, KEYVALUE_ENTRY(CMOD_LEGACY, "legacy")
{0, NULL}
}; };
result = quote ? 2 : 0; if (quote)
{
++buflen;
if (buf != NULL) if (buf != NULL)
{ {
if (quote) *buf = '"';
*buf++ = '"'; *(buf + buflen) = NUL;
*buf = '\0';
} }
}
else
if (buf != NULL)
*buf = NUL;
// the modifiers that are simple flags // the modifiers that are simple flags
for (i = 0; mod_entries[i].name != NULL; ++i) for (i = 0; i < (int)ARRAY_LENGTH(mod_entry_tab); ++i)
if (cmod->cmod_flags & mod_entries[i].flag) if (cmod->cmod_flags & mod_entry_tab[i].key)
result += add_cmd_modifier(buf, mod_entries[i].name, &multi_mods); buflen += add_cmd_modifier(buf, buflen, mod_entry_tab[i].value, mod_entry_tab[i].length, &multi_mods);
// :silent // :silent
if (cmod->cmod_flags & CMOD_SILENT) if (cmod->cmod_flags & CMOD_SILENT)
result += add_cmd_modifier(buf, {
(cmod->cmod_flags & CMOD_ERRSILENT) ? "silent!" if (cmod->cmod_flags & CMOD_ERRSILENT)
: "silent", &multi_mods); buflen += add_cmd_modifier(buf, buflen, "silent!", STRLEN_LITERAL("silent!"), &multi_mods);
else
buflen += add_cmd_modifier(buf, buflen, "silent", STRLEN_LITERAL("silent"), &multi_mods);
}
// :verbose // :verbose
if (cmod->cmod_verbose > 0) if (cmod->cmod_verbose > 0)
{ {
int verbose_value = cmod->cmod_verbose - 1; int verbose_value = cmod->cmod_verbose - 1;
if (verbose_value == 1) if (verbose_value == 1)
result += add_cmd_modifier(buf, "verbose", &multi_mods); buflen += add_cmd_modifier(buf, buflen, "verbose", STRLEN_LITERAL("verbose"), &multi_mods);
else else
{ {
char verbose_buf[NUMBUFLEN]; char verbose_buf[NUMBUFLEN];
size_t verbose_buflen;
sprintf(verbose_buf, "%dverbose", verbose_value); verbose_buflen = vim_snprintf(verbose_buf, sizeof(verbose_buf), "%dverbose", verbose_value);
result += add_cmd_modifier(buf, verbose_buf, &multi_mods); buflen += add_cmd_modifier(buf, buflen, verbose_buf, verbose_buflen, &multi_mods);
} }
} }
// flags from cmod->cmod_split // flags from cmod->cmod_split
result += add_win_cmd_modifiers(buf, cmod, &multi_mods); buflen += add_win_cmd_modifiers((buf == NULL) ? NULL : buf + buflen, cmod, &multi_mods);
if (quote && buf != NULL) if (quote)
{ {
buf += result - 2; if (buf == NULL)
*buf = '"'; ++buflen;
else
{
*(buf + buflen) = '"';
++buflen;
*(buf + buflen) = NUL;
} }
return result; }
return buflen;
} }
/* /*
@ -1755,15 +1841,14 @@ uc_check_code(
case ct_RANGE: case ct_RANGE:
case ct_COUNT: case ct_COUNT:
{ {
char num_buf[20]; char num_buf[NUMBUFLEN];
long num = (type == ct_LINE1) ? eap->line1 : long num = (type == ct_LINE1) ? eap->line1 :
(type == ct_LINE2) ? eap->line2 : (type == ct_LINE2) ? eap->line2 :
(type == ct_RANGE) ? eap->addr_count : (type == ct_RANGE) ? eap->addr_count :
(eap->addr_count > 0) ? eap->line2 : cmd->uc_def; (eap->addr_count > 0) ? eap->line2 : cmd->uc_def;
size_t num_len; size_t num_len;
sprintf(num_buf, "%ld", num); num_len = vim_snprintf(num_buf, sizeof(num_buf), "%ld", num);
num_len = STRLEN(num_buf);
result = num_len; result = num_len;
if (quote) if (quote)

2
src/version.c
View File

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