mirror of
https://github.com/vim/vim
synced 2025-03-16 06:47:52 +01:00
Problem: too many strlen() calls in cmdhist.c Solution: refactor code and remove strlen() calls (John Marriott) closes: #15888 Signed-off-by: John Marriott <basilisk@internode.on.net> Signed-off-by: Christian Brabandt <cb@256bit.org>
812 lines
18 KiB
C
812 lines
18 KiB
C
/* vi:set ts=8 sts=4 sw=4 noet:
|
|
*
|
|
* VIM - Vi IMproved by Bram Moolenaar
|
|
*
|
|
* Do ":help uganda" in Vim to read copying and usage conditions.
|
|
* Do ":help credits" in Vim to see a list of people who contributed.
|
|
* See README.txt for an overview of the Vim source code.
|
|
*/
|
|
|
|
/*
|
|
* cmdhist.c: Functions for the history of the command-line.
|
|
*/
|
|
|
|
#include "vim.h"
|
|
|
|
static histentry_T *(history[HIST_COUNT]) = {NULL, NULL, NULL, NULL, NULL};
|
|
static int hisidx[HIST_COUNT] = {-1, -1, -1, -1, -1}; // lastused entry
|
|
static int hisnum[HIST_COUNT] = {0, 0, 0, 0, 0};
|
|
// identifying (unique) number of newest history entry
|
|
static int hislen = 0; // actual length of history tables
|
|
|
|
/*
|
|
* Return the length of the history tables
|
|
*/
|
|
int
|
|
get_hislen(void)
|
|
{
|
|
return hislen;
|
|
}
|
|
|
|
/*
|
|
* Return a pointer to a specified history table
|
|
*/
|
|
histentry_T *
|
|
get_histentry(int hist_type)
|
|
{
|
|
return history[hist_type];
|
|
}
|
|
|
|
#if defined(FEAT_VIMINFO) || defined(PROTO)
|
|
void
|
|
set_histentry(int hist_type, histentry_T *entry)
|
|
{
|
|
history[hist_type] = entry;
|
|
}
|
|
#endif
|
|
|
|
int *
|
|
get_hisidx(int hist_type)
|
|
{
|
|
return &hisidx[hist_type];
|
|
}
|
|
|
|
#if defined(FEAT_VIMINFO) || defined(PROTO)
|
|
int *
|
|
get_hisnum(int hist_type)
|
|
{
|
|
return &hisnum[hist_type];
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Translate a history character to the associated type number.
|
|
*/
|
|
int
|
|
hist_char2type(int c)
|
|
{
|
|
if (c == ':')
|
|
return HIST_CMD;
|
|
if (c == '=')
|
|
return HIST_EXPR;
|
|
if (c == '@')
|
|
return HIST_INPUT;
|
|
if (c == '>')
|
|
return HIST_DEBUG;
|
|
return HIST_SEARCH; // must be '?' or '/'
|
|
}
|
|
|
|
/*
|
|
* Table of history names.
|
|
* These names are used in :history and various hist...() functions.
|
|
* It is sufficient to give the significant prefix of a history name.
|
|
*/
|
|
|
|
static char *(history_names[]) =
|
|
{
|
|
"cmd",
|
|
"search",
|
|
"expr",
|
|
"input",
|
|
"debug",
|
|
NULL
|
|
};
|
|
|
|
/*
|
|
* Function given to ExpandGeneric() to obtain the possible first
|
|
* arguments of the ":history command.
|
|
*/
|
|
char_u *
|
|
get_history_arg(expand_T *xp UNUSED, int idx)
|
|
{
|
|
char *short_names = ":=@>?/";
|
|
int short_names_count = (int)STRLEN(short_names);
|
|
int history_name_count = ARRAY_LENGTH(history_names) - 1;
|
|
|
|
if (idx < short_names_count)
|
|
{
|
|
xp->xp_buf[0] = (char_u)short_names[idx];
|
|
xp->xp_buf[1] = NUL;
|
|
return xp->xp_buf;
|
|
}
|
|
if (idx < short_names_count + history_name_count)
|
|
return (char_u *)history_names[idx - short_names_count];
|
|
if (idx == short_names_count + history_name_count)
|
|
return (char_u *)"all";
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* init_history() - Initialize the command line history.
|
|
* Also used to re-allocate the history when the size changes.
|
|
*/
|
|
void
|
|
init_history(void)
|
|
{
|
|
int newlen; // new length of history table
|
|
histentry_T *temp;
|
|
int type;
|
|
|
|
// If size of history table changed, reallocate it
|
|
newlen = (int)p_hi;
|
|
if (newlen == hislen) // history length didn't change
|
|
return;
|
|
|
|
// history length changed
|
|
for (type = 0; type < HIST_COUNT; ++type) // adjust the tables
|
|
{
|
|
if (newlen > 0)
|
|
{
|
|
temp = ALLOC_MULT(histentry_T, newlen);
|
|
if (temp == NULL) // out of memory!
|
|
{
|
|
if (type == 0) // first one: just keep the old length
|
|
{
|
|
newlen = hislen;
|
|
break;
|
|
}
|
|
// Already changed one table, now we can only have zero
|
|
// length for all tables.
|
|
newlen = 0;
|
|
type = -1;
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
temp = NULL;
|
|
|
|
if (hisidx[type] < 0) // there are no entries yet
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < newlen; ++i)
|
|
clear_hist_entry(&temp[i]);
|
|
}
|
|
else if (newlen > hislen) // array becomes bigger
|
|
{
|
|
int i;
|
|
int j;
|
|
|
|
for (i = 0; i <= hisidx[type]; ++i)
|
|
temp[i] = history[type][i];
|
|
j = i;
|
|
for ( ; i <= newlen - (hislen - hisidx[type]); ++i)
|
|
clear_hist_entry(&temp[i]);
|
|
for ( ; j < hislen; ++i, ++j)
|
|
temp[i] = history[type][j];
|
|
}
|
|
else // array becomes smaller or 0
|
|
{
|
|
int i;
|
|
int j;
|
|
|
|
j = hisidx[type];
|
|
for (i = newlen - 1; ; --i)
|
|
{
|
|
if (i >= 0) // copy newest entries
|
|
temp[i] = history[type][j];
|
|
else // remove older entries
|
|
{
|
|
vim_free(history[type][j].hisstr);
|
|
history[type][j].hisstrlen = 0;
|
|
}
|
|
if (--j < 0)
|
|
j = hislen - 1;
|
|
if (j == hisidx[type])
|
|
break;
|
|
}
|
|
hisidx[type] = newlen - 1;
|
|
}
|
|
vim_free(history[type]);
|
|
history[type] = temp;
|
|
}
|
|
hislen = newlen;
|
|
}
|
|
|
|
void
|
|
clear_hist_entry(histentry_T *hisptr)
|
|
{
|
|
hisptr->hisnum = 0;
|
|
hisptr->viminfo = FALSE;
|
|
hisptr->hisstr = NULL;
|
|
hisptr->hisstrlen = 0;
|
|
hisptr->time_set = 0;
|
|
}
|
|
|
|
/*
|
|
* Check if command line 'str' is already in history.
|
|
* If 'move_to_front' is TRUE, matching entry is moved to end of history.
|
|
*/
|
|
int
|
|
in_history(
|
|
int type,
|
|
char_u *str,
|
|
int move_to_front, // Move the entry to the front if it exists
|
|
int sep,
|
|
int writing) // ignore entries read from viminfo
|
|
{
|
|
int i;
|
|
int last_i = -1;
|
|
char_u *p;
|
|
size_t len;
|
|
|
|
if (hisidx[type] < 0)
|
|
return FALSE;
|
|
i = hisidx[type];
|
|
do
|
|
{
|
|
if (history[type][i].hisstr == NULL)
|
|
return FALSE;
|
|
|
|
// For search history, check that the separator character matches as
|
|
// well.
|
|
p = history[type][i].hisstr;
|
|
if (STRCMP(str, p) == 0
|
|
&& !(writing && history[type][i].viminfo)
|
|
&& (type != HIST_SEARCH || sep == p[history[type][i].hisstrlen + 1]))
|
|
{
|
|
if (!move_to_front)
|
|
return TRUE;
|
|
last_i = i;
|
|
break;
|
|
}
|
|
if (--i < 0)
|
|
i = hislen - 1;
|
|
} while (i != hisidx[type]);
|
|
|
|
if (last_i < 0)
|
|
return FALSE;
|
|
|
|
str = history[type][i].hisstr;
|
|
len = history[type][i].hisstrlen;
|
|
while (i != hisidx[type])
|
|
{
|
|
if (++i >= hislen)
|
|
i = 0;
|
|
history[type][last_i] = history[type][i];
|
|
last_i = i;
|
|
}
|
|
history[type][i].hisnum = ++hisnum[type];
|
|
history[type][i].viminfo = FALSE;
|
|
history[type][i].hisstr = str;
|
|
history[type][i].hisstrlen = len;
|
|
history[type][i].time_set = vim_time();
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Convert history name (from table above) to its HIST_ equivalent.
|
|
* When "name" is empty, return "cmd" history.
|
|
* Returns -1 for unknown history name.
|
|
*/
|
|
static int
|
|
get_histtype(char_u *name)
|
|
{
|
|
int i;
|
|
int len = (int)STRLEN(name);
|
|
|
|
// No argument: use current history.
|
|
if (len == 0)
|
|
return hist_char2type(get_cmdline_firstc());
|
|
|
|
for (i = 0; history_names[i] != NULL; ++i)
|
|
if (STRNICMP(name, history_names[i], len) == 0)
|
|
return i;
|
|
|
|
if (vim_strchr((char_u *)":=@>?/", name[0]) != NULL && name[1] == NUL)
|
|
return hist_char2type(name[0]);
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int last_maptick = -1; // last seen maptick
|
|
|
|
/*
|
|
* Add the given string to the given history. If the string is already in the
|
|
* history then it is moved to the front. "histype" may be one of he HIST_
|
|
* values.
|
|
*/
|
|
void
|
|
add_to_history(
|
|
int histype,
|
|
char_u *new_entry,
|
|
size_t new_entrylen,
|
|
int in_map, // consider maptick when inside a mapping
|
|
int sep) // separator character used (search hist)
|
|
{
|
|
histentry_T *hisptr;
|
|
|
|
if (hislen == 0) // no history
|
|
return;
|
|
|
|
if ((cmdmod.cmod_flags & CMOD_KEEPPATTERNS) && histype == HIST_SEARCH)
|
|
return;
|
|
|
|
// Searches inside the same mapping overwrite each other, so that only
|
|
// the last line is kept. Be careful not to remove a line that was moved
|
|
// down, only lines that were added.
|
|
if (histype == HIST_SEARCH && in_map)
|
|
{
|
|
if (maptick == last_maptick && hisidx[HIST_SEARCH] >= 0)
|
|
{
|
|
// Current line is from the same mapping, remove it
|
|
hisptr = &history[HIST_SEARCH][hisidx[HIST_SEARCH]];
|
|
vim_free(hisptr->hisstr);
|
|
clear_hist_entry(hisptr);
|
|
--hisnum[histype];
|
|
if (--hisidx[HIST_SEARCH] < 0)
|
|
hisidx[HIST_SEARCH] = hislen - 1;
|
|
}
|
|
last_maptick = -1;
|
|
}
|
|
|
|
if (in_history(histype, new_entry, TRUE, sep, FALSE))
|
|
return;
|
|
|
|
if (++hisidx[histype] == hislen)
|
|
hisidx[histype] = 0;
|
|
hisptr = &history[histype][hisidx[histype]];
|
|
vim_free(hisptr->hisstr);
|
|
|
|
// Store the separator after the NUL of the string.
|
|
hisptr->hisstr = vim_strnsave(new_entry, new_entrylen + 2);
|
|
if (hisptr->hisstr == NULL)
|
|
hisptr->hisstrlen = 0;
|
|
else
|
|
{
|
|
hisptr->hisstr[new_entrylen + 1] = sep;
|
|
hisptr->hisstrlen = new_entrylen;
|
|
}
|
|
|
|
hisptr->hisnum = ++hisnum[histype];
|
|
hisptr->viminfo = FALSE;
|
|
hisptr->time_set = vim_time();
|
|
if (histype == HIST_SEARCH && in_map)
|
|
last_maptick = maptick;
|
|
}
|
|
|
|
#if defined(FEAT_EVAL) || defined(PROTO)
|
|
|
|
/*
|
|
* Get identifier of newest history entry.
|
|
* "histype" may be one of the HIST_ values.
|
|
*/
|
|
static int
|
|
get_history_idx(int histype)
|
|
{
|
|
if (hislen == 0 || histype < 0 || histype >= HIST_COUNT
|
|
|| hisidx[histype] < 0)
|
|
return -1;
|
|
|
|
return history[histype][hisidx[histype]].hisnum;
|
|
}
|
|
|
|
/*
|
|
* Calculate history index from a number:
|
|
* num > 0: seen as identifying number of a history entry
|
|
* num < 0: relative position in history wrt newest entry
|
|
* "histype" may be one of the HIST_ values.
|
|
*/
|
|
static int
|
|
calc_hist_idx(int histype, int num)
|
|
{
|
|
int i;
|
|
histentry_T *hist;
|
|
int wrapped = FALSE;
|
|
|
|
if (hislen == 0 || histype < 0 || histype >= HIST_COUNT
|
|
|| (i = hisidx[histype]) < 0 || num == 0)
|
|
return -1;
|
|
|
|
hist = history[histype];
|
|
if (num > 0)
|
|
{
|
|
while (hist[i].hisnum > num)
|
|
if (--i < 0)
|
|
{
|
|
if (wrapped)
|
|
break;
|
|
i += hislen;
|
|
wrapped = TRUE;
|
|
}
|
|
if (i >= 0 && hist[i].hisnum == num && hist[i].hisstr != NULL)
|
|
return i;
|
|
}
|
|
else if (-num <= hislen)
|
|
{
|
|
i += num + 1;
|
|
if (i < 0)
|
|
i += hislen;
|
|
if (hist[i].hisstr != NULL)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Clear all entries of a history.
|
|
* "histype" may be one of the HIST_ values.
|
|
*/
|
|
static int
|
|
clr_history(int histype)
|
|
{
|
|
int i;
|
|
histentry_T *hisptr;
|
|
|
|
if (hislen != 0 && histype >= 0 && histype < HIST_COUNT)
|
|
{
|
|
hisptr = history[histype];
|
|
for (i = hislen; i--;)
|
|
{
|
|
vim_free(hisptr->hisstr);
|
|
clear_hist_entry(hisptr);
|
|
hisptr++;
|
|
}
|
|
hisidx[histype] = -1; // mark history as cleared
|
|
hisnum[histype] = 0; // reset identifier counter
|
|
return OK;
|
|
}
|
|
return FAIL;
|
|
}
|
|
|
|
/*
|
|
* Remove all entries matching {str} from a history.
|
|
* "histype" may be one of the HIST_ values.
|
|
*/
|
|
static int
|
|
del_history_entry(int histype, char_u *str)
|
|
{
|
|
regmatch_T regmatch;
|
|
histentry_T *hisptr;
|
|
int idx;
|
|
int i;
|
|
int last;
|
|
int found = FALSE;
|
|
|
|
if (hislen == 0 || histype < 0 || histype >= HIST_COUNT || *str == NUL
|
|
|| hisidx[histype] < 0)
|
|
return FALSE;
|
|
|
|
idx = hisidx[histype];
|
|
regmatch.regprog = vim_regcomp(str, RE_MAGIC + RE_STRING);
|
|
if (regmatch.regprog == NULL)
|
|
return FALSE;
|
|
|
|
regmatch.rm_ic = FALSE; // always match case
|
|
|
|
i = last = idx;
|
|
do
|
|
{
|
|
hisptr = &history[histype][i];
|
|
if (hisptr->hisstr == NULL)
|
|
break;
|
|
if (vim_regexec(®match, hisptr->hisstr, (colnr_T)0))
|
|
{
|
|
found = TRUE;
|
|
vim_free(hisptr->hisstr);
|
|
clear_hist_entry(hisptr);
|
|
}
|
|
else
|
|
{
|
|
if (i != last)
|
|
{
|
|
history[histype][last] = *hisptr;
|
|
clear_hist_entry(hisptr);
|
|
}
|
|
if (--last < 0)
|
|
last += hislen;
|
|
}
|
|
if (--i < 0)
|
|
i += hislen;
|
|
} while (i != idx);
|
|
|
|
if (history[histype][idx].hisstr == NULL)
|
|
hisidx[histype] = -1;
|
|
|
|
vim_regfree(regmatch.regprog);
|
|
return found;
|
|
}
|
|
|
|
/*
|
|
* Remove an indexed entry from a history.
|
|
* "histype" may be one of the HIST_ values.
|
|
*/
|
|
static int
|
|
del_history_idx(int histype, int idx)
|
|
{
|
|
int i, j;
|
|
|
|
i = calc_hist_idx(histype, idx);
|
|
if (i < 0)
|
|
return FALSE;
|
|
idx = hisidx[histype];
|
|
vim_free(history[histype][i].hisstr);
|
|
history[histype][i].hisstrlen = 0;
|
|
|
|
// When deleting the last added search string in a mapping, reset
|
|
// last_maptick, so that the last added search string isn't deleted again.
|
|
if (histype == HIST_SEARCH && maptick == last_maptick && i == idx)
|
|
last_maptick = -1;
|
|
|
|
while (i != idx)
|
|
{
|
|
j = (i + 1) % hislen;
|
|
history[histype][i] = history[histype][j];
|
|
i = j;
|
|
}
|
|
clear_hist_entry(&history[histype][i]);
|
|
if (--i < 0)
|
|
i += hislen;
|
|
hisidx[histype] = i;
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* "histadd()" function
|
|
*/
|
|
void
|
|
f_histadd(typval_T *argvars UNUSED, typval_T *rettv)
|
|
{
|
|
int histype;
|
|
char_u *str;
|
|
char_u buf[NUMBUFLEN];
|
|
|
|
rettv->vval.v_number = FALSE;
|
|
if (check_secure())
|
|
return;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_string_arg(argvars, 0) == FAIL
|
|
|| check_for_string_arg(argvars, 1) == FAIL))
|
|
return;
|
|
|
|
str = tv_get_string_chk(&argvars[0]); // NULL on type error
|
|
histype = str != NULL ? get_histtype(str) : -1;
|
|
if (histype < 0)
|
|
return;
|
|
|
|
str = tv_get_string_buf(&argvars[1], buf);
|
|
if (*str == NUL)
|
|
return;
|
|
|
|
init_history();
|
|
add_to_history(histype, str, STRLEN(str), FALSE, NUL);
|
|
rettv->vval.v_number = TRUE;
|
|
}
|
|
|
|
/*
|
|
* "histdel()" function
|
|
*/
|
|
void
|
|
f_histdel(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
|
|
{
|
|
int n;
|
|
char_u *str;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_string_arg(argvars, 0) == FAIL
|
|
|| check_for_opt_string_or_number_arg(argvars, 1) == FAIL))
|
|
return;
|
|
|
|
str = tv_get_string_chk(&argvars[0]); // NULL on type error
|
|
if (str == NULL)
|
|
n = 0;
|
|
else if (argvars[1].v_type == VAR_UNKNOWN)
|
|
// only one argument: clear entire history
|
|
n = clr_history(get_histtype(str));
|
|
else if (argvars[1].v_type == VAR_NUMBER)
|
|
// index given: remove that entry
|
|
n = del_history_idx(get_histtype(str),
|
|
(int)tv_get_number(&argvars[1]));
|
|
else
|
|
{
|
|
char_u buf[NUMBUFLEN];
|
|
|
|
// string given: remove all matching entries
|
|
n = del_history_entry(get_histtype(str),
|
|
tv_get_string_buf(&argvars[1], buf));
|
|
}
|
|
|
|
rettv->vval.v_number = n;
|
|
}
|
|
|
|
/*
|
|
* "histget()" function
|
|
*/
|
|
void
|
|
f_histget(typval_T *argvars UNUSED, typval_T *rettv)
|
|
{
|
|
char_u *str;
|
|
|
|
if (in_vim9script()
|
|
&& (check_for_string_arg(argvars, 0) == FAIL
|
|
|| check_for_opt_number_arg(argvars, 1) == FAIL))
|
|
return;
|
|
|
|
str = tv_get_string_chk(&argvars[0]); // NULL on type error
|
|
if (str == NULL)
|
|
rettv->vval.v_string = NULL;
|
|
else
|
|
{
|
|
int type;
|
|
int idx;
|
|
|
|
type = get_histtype(str);
|
|
if (argvars[1].v_type == VAR_UNKNOWN)
|
|
idx = get_history_idx(type);
|
|
else
|
|
idx = (int)tv_get_number_chk(&argvars[1], NULL);
|
|
// -1 on type error
|
|
|
|
idx = calc_hist_idx(type, idx);
|
|
if (idx < 0)
|
|
rettv->vval.v_string = vim_strnsave((char_u *)"", 0);
|
|
else
|
|
rettv->vval.v_string = vim_strnsave(history[type][idx].hisstr, history[type][idx].hisstrlen);
|
|
}
|
|
rettv->v_type = VAR_STRING;
|
|
}
|
|
|
|
/*
|
|
* "histnr()" function
|
|
*/
|
|
void
|
|
f_histnr(typval_T *argvars UNUSED, typval_T *rettv)
|
|
{
|
|
int i;
|
|
char_u *histname;
|
|
|
|
if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
|
|
return;
|
|
|
|
histname = tv_get_string_chk(&argvars[0]);
|
|
i = histname == NULL ? HIST_CMD - 1 : get_histtype(histname);
|
|
if (i >= HIST_CMD && i < HIST_COUNT)
|
|
rettv->vval.v_number = get_history_idx(i);
|
|
else
|
|
rettv->vval.v_number = -1;
|
|
}
|
|
#endif // FEAT_EVAL
|
|
|
|
#if defined(FEAT_CRYPT) || defined(PROTO)
|
|
/*
|
|
* Very specific function to remove the value in ":set key=val" from the
|
|
* history.
|
|
*/
|
|
void
|
|
remove_key_from_history(void)
|
|
{
|
|
char_u *p_start;
|
|
char_u *p_end;
|
|
char_u *p;
|
|
int i;
|
|
|
|
i = hisidx[HIST_CMD];
|
|
if (i < 0)
|
|
return;
|
|
p_start = history[HIST_CMD][i].hisstr;
|
|
if (p_start == NULL)
|
|
return;
|
|
|
|
p_end = p_start + history[HIST_CMD][i].hisstrlen;
|
|
for (p = p_start; *p; ++p)
|
|
{
|
|
if (STRNCMP(p, "key", 3) == 0 && !SAFE_isalpha(p[3]))
|
|
{
|
|
p = vim_strchr(p + 3, '=');
|
|
if (p == NULL)
|
|
break;
|
|
++p;
|
|
for (i = 0; p[i] && !VIM_ISWHITE(p[i]); ++i)
|
|
if (p[i] == '\\' && p[i + 1])
|
|
++i;
|
|
|
|
mch_memmove(p, p + i, (p_end - (p + i)) + 1); // +1 for the NUL
|
|
p_end -= i; // adjust p_end for shortened string
|
|
--p;
|
|
}
|
|
}
|
|
|
|
history[HIST_CMD][i].hisstrlen = (size_t)(p_end - p_start);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* :history command - print a history
|
|
*/
|
|
void
|
|
ex_history(exarg_T *eap)
|
|
{
|
|
histentry_T *hist;
|
|
int histype1 = HIST_CMD;
|
|
int histype2 = HIST_CMD;
|
|
int hisidx1 = 1;
|
|
int hisidx2 = -1;
|
|
int idx;
|
|
int i, j, k;
|
|
char_u *end;
|
|
char_u *arg = eap->arg;
|
|
|
|
if (hislen == 0)
|
|
{
|
|
msg(_("'history' option is zero"));
|
|
return;
|
|
}
|
|
|
|
if (!(VIM_ISDIGIT(*arg) || *arg == '-' || *arg == ','))
|
|
{
|
|
end = arg;
|
|
while (ASCII_ISALPHA(*end)
|
|
|| vim_strchr((char_u *)":=@>/?", *end) != NULL)
|
|
end++;
|
|
i = *end;
|
|
*end = NUL;
|
|
histype1 = get_histtype(arg);
|
|
if (histype1 == -1)
|
|
{
|
|
if (STRNICMP(arg, "all", STRLEN(arg)) == 0)
|
|
{
|
|
histype1 = 0;
|
|
histype2 = HIST_COUNT-1;
|
|
}
|
|
else
|
|
{
|
|
*end = i;
|
|
semsg(_(e_trailing_characters_str), arg);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
histype2 = histype1;
|
|
*end = i;
|
|
}
|
|
else
|
|
end = arg;
|
|
if (!get_list_range(&end, &hisidx1, &hisidx2) || *end != NUL)
|
|
{
|
|
if (*end != NUL)
|
|
semsg(_(e_trailing_characters_str), end);
|
|
else
|
|
semsg(_(e_val_too_large), arg);
|
|
return;
|
|
}
|
|
|
|
for (; !got_int && histype1 <= histype2; ++histype1)
|
|
{
|
|
vim_snprintf((char *)IObuff, IOSIZE, "\n # %s history", history_names[histype1]);
|
|
msg_puts_title((char *)IObuff);
|
|
idx = hisidx[histype1];
|
|
hist = history[histype1];
|
|
j = hisidx1;
|
|
k = hisidx2;
|
|
if (j < 0)
|
|
j = (-j > hislen) ? 0 : hist[(hislen + j + idx + 1) % hislen].hisnum;
|
|
if (k < 0)
|
|
k = (-k > hislen) ? 0 : hist[(hislen + k + idx + 1) % hislen].hisnum;
|
|
if (idx >= 0 && j <= k)
|
|
for (i = idx + 1; !got_int; ++i)
|
|
{
|
|
if (i == hislen)
|
|
i = 0;
|
|
if (hist[i].hisstr != NULL
|
|
&& hist[i].hisnum >= j && hist[i].hisnum <= k
|
|
&& !message_filtered(hist[i].hisstr))
|
|
{
|
|
int len;
|
|
|
|
msg_putchar('\n');
|
|
len = vim_snprintf((char *)IObuff, IOSIZE,
|
|
"%c%6d ", i == idx ? '>' : ' ', hist[i].hisnum);
|
|
if (vim_strsize(hist[i].hisstr) > (int)Columns - 10)
|
|
trunc_string(hist[i].hisstr, IObuff + len,
|
|
(int)Columns - 10, IOSIZE - (int)len);
|
|
else
|
|
STRCPY(IObuff + len, hist[i].hisstr);
|
|
msg_outtrans(IObuff);
|
|
out_flush();
|
|
}
|
|
if (i == idx)
|
|
break;
|
|
}
|
|
}
|
|
}
|