mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-10-08 02:46:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

vim-patch:8.1.1869: code for the argument list is spread out (#19791)

Browse Source 
Problem:    Code for the argument list is spread out.
Solution:   Put argument list code in arglist.c. (Yegappan Lakshmanan,
            closes vim/vim#4819)
4ad62155a1
This commit is contained in:
zeertzjq
2022-08-16 14:16:03 +08:00
committed by GitHub
parent d5d6ed311b
commit 5e98a41872
16 changed files with 1159 additions and 1099 deletions
Download Patch File Download Diff File Expand all files Collapse all files

527
src/nvim/ex_cmds2.c
View File

@@ -11,6 +11,7 @@
#include <stdbool.h>
#include <string.h>
#include "nvim/arglist.h"
#include "nvim/ascii.h"
#include "nvim/autocmd.h"
#include "nvim/globals.h"
@@ -42,11 +43,9 @@
#include "nvim/os_unix.h"
#include "nvim/path.h"
#include "nvim/quickfix.h"
#include "nvim/regexp.h"
#include "nvim/runtime.h"
#include "nvim/strings.h"
#include "nvim/undo.h"
#include "nvim/version.h"
#include "nvim/window.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS
@@ -445,483 +444,6 @@ int buf_write_all(buf_T *buf, int forceit)
return retval;
}
/// Code to handle the argument list.
#define AL_SET 1
#define AL_ADD 2
#define AL_DEL 3
/// Isolate one argument, taking backticks.
/// Changes the argument in-place, puts a NUL after it. Backticks remain.
///
/// @return a pointer to the start of the next argument.
static char *do_one_arg(char *str)
{
char *p;
bool inbacktick;
inbacktick = false;
for (p = str; *str; str++) {
// When the backslash is used for escaping the special meaning of a
// character we need to keep it until wildcard expansion.
if (rem_backslash((char_u *)str)) {
*p++ = *str++;
*p++ = *str;
} else {
// An item ends at a space not in backticks
if (!inbacktick && ascii_isspace(*str)) {
break;
}
if (*str == '`') {
inbacktick ^= true;
}
*p++ = *str;
}
}
str = skipwhite(str);
*p = NUL;
return str;
}
/// Separate the arguments in "str" and return a list of pointers in the
/// growarray "gap".
static void get_arglist(garray_T *gap, char *str, int escaped)
{
ga_init(gap, (int)sizeof(char_u *), 20);
while (*str != NUL) {
GA_APPEND(char *, gap, str);
// If str is escaped, don't handle backslashes or spaces
if (!escaped) {
return;
}
// Isolate one argument, change it in-place, put a NUL after it.
str = do_one_arg(str);
}
}
/// Parse a list of arguments (file names), expand them and return in
/// "fnames[fcountp]". When "wig" is true, removes files matching 'wildignore'.
///
/// @return FAIL or OK.
int get_arglist_exp(char_u *str, int *fcountp, char ***fnamesp, bool wig)
{
garray_T ga;
int i;
get_arglist(&ga, (char *)str, true);
if (wig) {
i = expand_wildcards(ga.ga_len, ga.ga_data,
fcountp, fnamesp, EW_FILE|EW_NOTFOUND|EW_NOTWILD);
} else {
i = gen_expand_wildcards(ga.ga_len, ga.ga_data,
fcountp, fnamesp, EW_FILE|EW_NOTFOUND|EW_NOTWILD);
}
ga_clear(&ga);
return i;
}
/// @param str
/// @param what
/// AL_SET: Redefine the argument list to 'str'.
/// AL_ADD: add files in 'str' to the argument list after "after".
/// AL_DEL: remove files in 'str' from the argument list.
/// @param after
/// 0 means before first one
/// @param will_edit will edit added argument
///
/// @return FAIL for failure, OK otherwise.
static int do_arglist(char *str, int what, int after, bool will_edit)
FUNC_ATTR_NONNULL_ALL
{
garray_T new_ga;
int exp_count;
char **exp_files;
char *p;
int match;
int arg_escaped = true;
// Set default argument for ":argadd" command.
if (what == AL_ADD && *str == NUL) {
if (curbuf->b_ffname == NULL) {
return FAIL;
}
str = curbuf->b_fname;
arg_escaped = false;
}
// Collect all file name arguments in "new_ga".
get_arglist(&new_ga, str, arg_escaped);
if (what == AL_DEL) {
regmatch_T regmatch;
bool didone;
// Delete the items: use each item as a regexp and find a match in the
// argument list.
regmatch.rm_ic = p_fic; // ignore case when 'fileignorecase' is set
for (int i = 0; i < new_ga.ga_len && !got_int; i++) {
p = ((char **)new_ga.ga_data)[i];
p = file_pat_to_reg_pat(p, NULL, NULL, false);
if (p == NULL) {
break;
}
regmatch.regprog = vim_regcomp(p, p_magic ? RE_MAGIC : 0);
if (regmatch.regprog == NULL) {
xfree(p);
break;
}
didone = false;
for (match = 0; match < ARGCOUNT; match++) {
if (vim_regexec(&regmatch, alist_name(&ARGLIST[match]), (colnr_T)0)) {
didone = true;
xfree(ARGLIST[match].ae_fname);
memmove(ARGLIST + match, ARGLIST + match + 1,
(size_t)(ARGCOUNT - match - 1) * sizeof(aentry_T));
ALIST(curwin)->al_ga.ga_len--;
if (curwin->w_arg_idx > match) {
curwin->w_arg_idx--;
}
match--;
}
}
vim_regfree(regmatch.regprog);
xfree(p);
if (!didone) {
semsg(_(e_nomatch2), ((char_u **)new_ga.ga_data)[i]);
}
}
ga_clear(&new_ga);
} else {
int i = expand_wildcards(new_ga.ga_len, new_ga.ga_data,
&exp_count, &exp_files,
EW_DIR|EW_FILE|EW_ADDSLASH|EW_NOTFOUND);
ga_clear(&new_ga);
if (i == FAIL || exp_count == 0) {
emsg(_(e_nomatch));
return FAIL;
}
if (what == AL_ADD) {
alist_add_list(exp_count, exp_files, after, will_edit);
xfree(exp_files);
} else {
assert(what == AL_SET);
alist_set(ALIST(curwin), exp_count, exp_files, will_edit, NULL, 0);
}
}
alist_check_arg_idx();
return OK;
}
/// Check the validity of the arg_idx for each other window.
static void alist_check_arg_idx(void)
{
FOR_ALL_TAB_WINDOWS(tp, win) {
if (win->w_alist == curwin->w_alist) {
check_arg_idx(win);
}
}
}
/// @return true if window "win" is editing the file at the current argument
/// index.
static bool editing_arg_idx(win_T *win)
{
return !(win->w_arg_idx >= WARGCOUNT(win)
|| (win->w_buffer->b_fnum
!= WARGLIST(win)[win->w_arg_idx].ae_fnum
&& (win->w_buffer->b_ffname == NULL
|| !(path_full_compare(alist_name(&WARGLIST(win)[win->w_arg_idx]),
win->w_buffer->b_ffname, true,
true) & kEqualFiles))));
}
/// Check if window "win" is editing the w_arg_idx file in its argument list.
void check_arg_idx(win_T *win)
{
if (WARGCOUNT(win) > 1 && !editing_arg_idx(win)) {
// We are not editing the current entry in the argument list.
// Set "arg_had_last" if we are editing the last one.
win->w_arg_idx_invalid = true;
if (win->w_arg_idx != WARGCOUNT(win) - 1
&& arg_had_last == false
&& ALIST(win) == &global_alist
&& GARGCOUNT > 0
&& win->w_arg_idx < GARGCOUNT
&& (win->w_buffer->b_fnum == GARGLIST[GARGCOUNT - 1].ae_fnum
|| (win->w_buffer->b_ffname != NULL
&& (path_full_compare(alist_name(&GARGLIST[GARGCOUNT - 1]),
win->w_buffer->b_ffname, true, true)
& kEqualFiles)))) {
arg_had_last = true;
}
} else {
// We are editing the current entry in the argument list.
// Set "arg_had_last" if it's also the last one
win->w_arg_idx_invalid = false;
if (win->w_arg_idx == WARGCOUNT(win) - 1 && win->w_alist == &global_alist) {
arg_had_last = true;
}
}
}
/// ":args", ":argslocal" and ":argsglobal".
void ex_args(exarg_T *eap)
{
if (eap->cmdidx != CMD_args) {
alist_unlink(ALIST(curwin));
if (eap->cmdidx == CMD_argglobal) {
ALIST(curwin) = &global_alist;
} else { // eap->cmdidx == CMD_arglocal
alist_new();
}
}
if (*eap->arg != NUL) {
// ":args file ..": define new argument list, handle like ":next"
// Also for ":argslocal file .." and ":argsglobal file ..".
ex_next(eap);
} else if (eap->cmdidx == CMD_args) {
// ":args": list arguments.
if (ARGCOUNT > 0) {
char **items = xmalloc(sizeof(char_u *) * (size_t)ARGCOUNT);
// Overwrite the command, for a short list there is no scrolling
// required and no wait_return().
gotocmdline(true);
for (int i = 0; i < ARGCOUNT; i++) {
items[i] = alist_name(&ARGLIST[i]);
}
list_in_columns(items, ARGCOUNT, curwin->w_arg_idx);
xfree(items);
}
} else if (eap->cmdidx == CMD_arglocal) {
garray_T *gap = &curwin->w_alist->al_ga;
// ":argslocal": make a local copy of the global argument list.
ga_grow(gap, GARGCOUNT);
for (int i = 0; i < GARGCOUNT; i++) {
if (GARGLIST[i].ae_fname != NULL) {
AARGLIST(curwin->w_alist)[gap->ga_len].ae_fname =
vim_strsave(GARGLIST[i].ae_fname);
AARGLIST(curwin->w_alist)[gap->ga_len].ae_fnum =
GARGLIST[i].ae_fnum;
gap->ga_len++;
}
}
}
}
/// ":previous", ":sprevious", ":Next" and ":sNext".
void ex_previous(exarg_T *eap)
{
// If past the last one already, go to the last one.
if (curwin->w_arg_idx - (int)eap->line2 >= ARGCOUNT) {
do_argfile(eap, ARGCOUNT - 1);
} else {
do_argfile(eap, curwin->w_arg_idx - (int)eap->line2);
}
}
/// ":rewind", ":first", ":sfirst" and ":srewind".
void ex_rewind(exarg_T *eap)
{
do_argfile(eap, 0);
}
/// ":last" and ":slast".
void ex_last(exarg_T *eap)
{
do_argfile(eap, ARGCOUNT - 1);
}
/// ":argument" and ":sargument".
void ex_argument(exarg_T *eap)
{
int i;
if (eap->addr_count > 0) {
i = (int)eap->line2 - 1;
} else {
i = curwin->w_arg_idx;
}
do_argfile(eap, i);
}
/// Edit file "argn" of the argument lists.
void do_argfile(exarg_T *eap, int argn)
{
int other;
char *p;
int old_arg_idx = curwin->w_arg_idx;
if (argn < 0 || argn >= ARGCOUNT) {
if (ARGCOUNT <= 1) {
emsg(_("E163: There is only one file to edit"));
} else if (argn < 0) {
emsg(_("E164: Cannot go before first file"));
} else {
emsg(_("E165: Cannot go beyond last file"));
}
} else {
setpcmark();
// split window or create new tab page first
if (*eap->cmd == 's' || cmdmod.cmod_tab != 0) {
if (win_split(0, 0) == FAIL) {
return;
}
RESET_BINDING(curwin);
} else {
// if 'hidden' set, only check for changed file when re-editing
// the same buffer
other = true;
if (buf_hide(curbuf)) {
p = fix_fname(alist_name(&ARGLIST[argn]));
other = otherfile(p);
xfree(p);
}
if ((!buf_hide(curbuf) || !other)
&& check_changed(curbuf, CCGD_AW
| (other ? 0 : CCGD_MULTWIN)
| (eap->forceit ? CCGD_FORCEIT : 0)
| CCGD_EXCMD)) {
return;
}
}
curwin->w_arg_idx = argn;
if (argn == ARGCOUNT - 1 && curwin->w_alist == &global_alist) {
arg_had_last = true;
}
// Edit the file; always use the last known line number.
// When it fails (e.g. Abort for already edited file) restore the
// argument index.
if (do_ecmd(0, alist_name(&ARGLIST[curwin->w_arg_idx]), NULL,
eap, ECMD_LAST,
(buf_hide(curwin->w_buffer) ? ECMD_HIDE : 0)
+ (eap->forceit ? ECMD_FORCEIT : 0), curwin) == FAIL) {
curwin->w_arg_idx = old_arg_idx;
} else if (eap->cmdidx != CMD_argdo) {
// like Vi: set the mark where the cursor is in the file.
setmark('\'');
}
}
}
/// ":next", and commands that behave like it.
void ex_next(exarg_T *eap)
{
int i;
// check for changed buffer now, if this fails the argument list is not
// redefined.
if (buf_hide(curbuf)
|| eap->cmdidx == CMD_snext
|| !check_changed(curbuf, CCGD_AW
| (eap->forceit ? CCGD_FORCEIT : 0)
| CCGD_EXCMD)) {
if (*eap->arg != NUL) { // redefine file list
if (do_arglist(eap->arg, AL_SET, 0, true) == FAIL) {
return;
}
i = 0;
} else {
i = curwin->w_arg_idx + (int)eap->line2;
}
do_argfile(eap, i);
}
}
/// ":argedit"
void ex_argedit(exarg_T *eap)
{
int i = eap->addr_count ? (int)eap->line2 : curwin->w_arg_idx + 1;
// Whether curbuf will be reused, curbuf->b_ffname will be set.
bool curbuf_is_reusable = curbuf_reusable();
if (do_arglist(eap->arg, AL_ADD, i, true) == FAIL) {
return;
}
maketitle();
if (curwin->w_arg_idx == 0
&& (curbuf->b_ml.ml_flags & ML_EMPTY)
&& (curbuf->b_ffname == NULL || curbuf_is_reusable)) {
i = 0;
}
// Edit the argument.
if (i < ARGCOUNT) {
do_argfile(eap, i);
}
}
/// ":argadd"
void ex_argadd(exarg_T *eap)
{
do_arglist(eap->arg, AL_ADD,
eap->addr_count > 0 ? (int)eap->line2 : curwin->w_arg_idx + 1,
false);
maketitle();
}
/// ":argdelete"
void ex_argdelete(exarg_T *eap)
{
if (eap->addr_count > 0 || *eap->arg == NUL) {
// ":argdel" works like ":.argdel"
if (eap->addr_count == 0) {
if (curwin->w_arg_idx >= ARGCOUNT) {
emsg(_("E610: No argument to delete"));
return;
}
eap->line1 = eap->line2 = curwin->w_arg_idx + 1;
} else if (eap->line2 > ARGCOUNT) {
// ":1,4argdel": Delete all arguments in the range.
eap->line2 = ARGCOUNT;
}
linenr_T n = eap->line2 - eap->line1 + 1;
if (*eap->arg != NUL) {
// Can't have both a range and an argument.
emsg(_(e_invarg));
} else if (n <= 0) {
// Don't give an error for ":%argdel" if the list is empty.
if (eap->line1 != 1 || eap->line2 != 0) {
emsg(_(e_invrange));
}
} else {
for (linenr_T i = eap->line1; i <= eap->line2; i++) {
xfree(ARGLIST[i - 1].ae_fname);
}
memmove(ARGLIST + eap->line1 - 1, ARGLIST + eap->line2,
(size_t)(ARGCOUNT - eap->line2) * sizeof(aentry_T));
ALIST(curwin)->al_ga.ga_len -= (int)n;
if (curwin->w_arg_idx >= eap->line2) {
curwin->w_arg_idx -= (int)n;
} else if (curwin->w_arg_idx > eap->line1) {
curwin->w_arg_idx = (int)eap->line1;
}
if (ARGCOUNT == 0) {
curwin->w_arg_idx = 0;
} else if (curwin->w_arg_idx >= ARGCOUNT) {
curwin->w_arg_idx = ARGCOUNT - 1;
}
}
} else {
do_arglist(eap->arg, AL_DEL, 0, false);
}
maketitle();
}
/// ":argdo", ":windo", ":bufdo", ":tabdo", ":cdo", ":ldo", ":cfdo" and ":lfdo"
void ex_listdo(exarg_T *eap)
{
@@ -1173,51 +695,6 @@ void ex_listdo(exarg_T *eap)
}
}
/// Add files[count] to the arglist of the current window after arg "after".
/// The file names in files[count] must have been allocated and are taken over.
/// Files[] itself is not taken over.
///
/// @param after: where to add: 0 = before first one
/// @param will_edit will edit adding argument
static void alist_add_list(int count, char **files, int after, bool will_edit)
FUNC_ATTR_NONNULL_ALL
{
int old_argcount = ARGCOUNT;
ga_grow(&ALIST(curwin)->al_ga, count);
{
if (after < 0) {
after = 0;
}
if (after > ARGCOUNT) {
after = ARGCOUNT;
}
if (after < ARGCOUNT) {
memmove(&(ARGLIST[after + count]), &(ARGLIST[after]),
(size_t)(ARGCOUNT - after) * sizeof(aentry_T));
}
for (int i = 0; i < count; i++) {
const int flags = BLN_LISTED | (will_edit ? BLN_CURBUF : 0);
ARGLIST[after + i].ae_fname = (char_u *)files[i];
ARGLIST[after + i].ae_fnum = buflist_add(files[i], flags);
}
ALIST(curwin)->al_ga.ga_len += count;
if (old_argcount > 0 && curwin->w_arg_idx >= after) {
curwin->w_arg_idx += count;
}
return;
}
}
// Function given to ExpandGeneric() to obtain the possible arguments of the
// argedit and argdelete commands.
char *get_arglist_name(expand_T *xp FUNC_ATTR_UNUSED, int idx)
{
if (idx >= ARGCOUNT) {
return NULL;
}
return alist_name(&ARGLIST[idx]);
}
/// ":compiler[!] {name}"
void ex_compiler(exarg_T *eap)
{
@@ -1675,7 +1152,7 @@ void ex_drop(exarg_T *eap)
// and mostly only one file is dropped.
// This also ignores wildcards, since it is very unlikely the user is
// editing a file name with a wildcard character.
do_arglist(eap->arg, AL_SET, 0, false);
set_arglist(eap->arg);
// Expanding wildcards may result in an empty argument list. E.g. when
// editing "foo.pyc" and ".pyc" is in 'wildignore'. Assume that we