kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-20 11:15:14 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #21101 from zeertzjq/vim-8.2.4494

Browse Source 
vim-patch:8.2.{4494,4496}: find_tags() function is too long
This commit is contained in:
zeertzjq 2022-11-18 15:24:39 +08:00 committed by GitHub
commit f70963f838
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 807 additions and 748 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/nvim/quickfix.c
View File

@ -4308,10 +4308,17 @@ void ex_make(exarg_T *eap)
incr_quickfix_busy();
int res = qf_init(wp, fname, (eap->cmdidx != CMD_make
&& eap->cmdidx != CMD_lmake) ? p_gefm : p_efm,
(eap->cmdidx != CMD_grepadd && eap->cmdidx != CMD_lgrepadd),
qf_cmdtitle(*eap->cmdlinep), enc);
char *errorformat = p_efm;
bool newlist = true;
if (eap->cmdidx != CMD_make && eap->cmdidx != CMD_lmake) {
errorformat = p_gefm;
}
if (eap->cmdidx == CMD_grepadd || eap->cmdidx == CMD_lgrepadd) {
newlist = false;
}
int res = qf_init(wp, fname, errorformat, newlist, qf_cmdtitle(*eap->cmdlinep), enc);
qf_info_T *qi = &ql_info;
if (wp != NULL) {

657
src/nvim/tag.c
View File

@ -110,6 +110,24 @@ static char *mt_names[MT_COUNT/2] =
#define NOTAGFILE 99 // return value for jumpto_tag
static char *nofile_fname = NULL; // fname for NOTAGFILE error
/// State information used during a tag search
typedef struct {
char *tag_fname; ///< name of tag file
pat_T orgpat; ///< holds unconverted pattern info
char *help_lang_find; ///< lang to be found
bool is_txt; ///< flag of file extension
bool did_open; ///< did open a tag file
int mincount; ///< MAXCOL: find all matches
///< other: minimal number of matches
bool linear; ///< do a linear search
char *lbuf; ///< line buffer
int lbuf_size; ///< length of lbuf
int match_count; ///< number of matches found
garray_T ga_match[MT_COUNT]; ///< stores matches in sequence
hashtab_T ht_match[MT_COUNT]; ///< stores matches by key
bool stop_searching; ///< stop when match found or error
} findtags_state_T;
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "tag.c.generated.h"
#endif
@ -1355,56 +1373,53 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
return result;
}
/// find_tags() - search for tags in tags files
///
/// Return FAIL if search completely failed (*num_matches will be 0, *matchesp
/// will be NULL), OK otherwise.
///
/// There is a priority in which type of tag is recognized.
///
/// 6. A static or global tag with a full matching tag for the current file.
/// 5. A global tag with a full matching tag for another file.
/// 4. A static tag with a full matching tag for another file.
/// 3. A static or global tag with an ignore-case matching tag for the
/// current file.
/// 2. A global tag with an ignore-case matching tag for another file.
/// 1. A static tag with an ignore-case matching tag for another file.
///
/// Tags in an emacs-style tags file are always global.
///
/// flags:
/// TAG_HELP only search for help tags
/// TAG_NAMES only return name of tag
/// TAG_REGEXP use "pat" as a regexp
/// TAG_NOIC don't always ignore case
/// TAG_KEEP_LANG keep language
/// TAG_NO_TAGFUNC do not call the 'tagfunc' function
///
/// @param pat pattern to search for
/// @param num_matches return: number of matches found
/// @param matchesp return: array of matches found
/// @param mincount MAXCOL: find all matches other: minimal number of matches */
/// @param buf_ffname name of buffer for priority
int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int mincount,
char *buf_ffname)
/// Initialize the state used by find_tags()
static void findtags_state_init(findtags_state_T *st, char *pat, int mincount)
{
FILE *fp;
char *lbuf; // line buffer
int lbuf_size = LSIZE; // length of lbuf
char *tag_fname; // name of tag file
tagname_T tn; // info for get_tagfname()
int first_file; // trying first tag file
st->tag_fname = xmalloc(MAXPATHL + 1);
st->orgpat.pat = (char_u *)pat;
st->orgpat.len = (int)strlen(pat);
st->orgpat.regmatch.regprog = NULL;
st->help_lang_find = NULL;
st->is_txt = false;
st->did_open = false;
st->mincount = mincount;
st->lbuf_size = LSIZE;
st->lbuf = xmalloc((size_t)st->lbuf_size);
st->match_count = 0;
st->stop_searching = false;
for (int mtt = 0; mtt < MT_COUNT; mtt++) {
ga_init(&st->ga_match[mtt], sizeof(char *), 100);
hash_init(&st->ht_match[mtt]);
}
}
/// Search for tags matching "st->orgpat.pat" in the "st->tag_fname" tags file.
/// Information needed to search for the tags is in the "st" state structure.
/// The matching tags are returned in "st".
static void find_tags_in_file(findtags_state_T *st, int flags, char *buf_ffname)
{
FILE *fp = NULL;
tagptrs_T tagp;
bool did_open = false; // did open a tag file
bool stop_searching = false; // stop when match found or error
int retval = FAIL; // return value
int is_static; // current tag line is static
int is_current; // file name matches
bool eof = false; // found end-of-file
char *p;
char_u *s;
int i;
int help_pri = 0;
char_u help_lang[3] = ""; // lang of current tags file
int tag_file_sorted = NUL; // !_TAG_FILE_SORTED value
int tagcmp;
off_T offset;
enum {
TS_START, ///< at start of file
TS_LINEAR, ///< linear searching forward, till EOF
TS_BINARY, ///< binary searching
TS_SKIP_BACK, ///< skipping backwards
TS_STEP_FORWARD, ///< stepping forwards
} state; // Current search state
struct tag_search_info { // Binary search file offsets
off_T low_offset; // offset for first char of first line that
// could match
@ -1416,172 +1431,45 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
int low_char; // first char at low_offset
int high_char; // first char at high_offset
} search_info;
int tagcmp;
off_T offset;
int round;
enum {
TS_START, // at start of file
TS_LINEAR, // linear searching forward, till EOF
TS_BINARY, // binary searching
TS_SKIP_BACK, // skipping backwards
TS_STEP_FORWARD, // stepping forwards
} state; // Current search state
int cmplen;
int match; // matches
int match_no_ic = 0; // matches with rm_ic == false
int match_re; // match with regexp
int matchoff = 0;
int save_emsg_off;
char *mfp;
garray_T ga_match[MT_COUNT]; // stores matches in sequence
hashtab_T ht_match[MT_COUNT]; // stores matches by key
hash_T hash = 0;
int match_count = 0; // number of matches found
char **matches;
int mtt;
int help_save;
int help_pri = 0;
char_u *help_lang_find = NULL; // lang to be found
char_u help_lang[3]; // lang of current tags file
char *saved_pat = NULL; // copy of pat[]
bool is_txt = false;
hash_T hash = 0;
pat_T orgpat; // holds unconverted pattern info
vimconv_T vimconv;
int findall = (mincount == MAXCOL || mincount == TAG_MANY);
// find all matching tags
bool sort_error = false; // tags file not sorted
int linear; // do a linear search
bool sortic = false; // tag file sorted in nocase
int noic = (flags & TAG_NOIC);
bool line_error = false; // syntax error
int has_re = (flags & TAG_REGEXP); // regexp used
int help_only = (flags & TAG_HELP);
int name_only = (flags & TAG_NAMES);
int noic = (flags & TAG_NOIC);
int get_it_again = false;
int verbose = (flags & TAG_VERBOSE);
int use_tfu = ((flags & TAG_NO_TAGFUNC) == 0);
int save_p_ic = p_ic;
vimconv_T vimconv;
// Change the value of 'ignorecase' according to 'tagcase' for the
// duration of this function.
switch (curbuf->b_tc_flags ? curbuf->b_tc_flags : tc_flags) {
case TC_FOLLOWIC:
break;
case TC_IGNORE:
p_ic = true;
break;
case TC_MATCH:
p_ic = false;
break;
case TC_FOLLOWSCS:
p_ic = ignorecase((char_u *)pat);
break;
case TC_SMART:
p_ic = ignorecase_opt((char_u *)pat, true, true);
break;
default:
abort();
}
help_save = curbuf->b_help;
orgpat.pat = (char_u *)pat;
orgpat.regmatch.regprog = NULL;
vimconv.vc_type = CONV_NONE;
// Allocate memory for the buffers that are used
lbuf = xmalloc((size_t)lbuf_size);
tag_fname = xmalloc(MAXPATHL + 1);
for (mtt = 0; mtt < MT_COUNT; mtt++) {
ga_init(&ga_match[mtt], sizeof(char *), 100);
hash_init(&ht_match[mtt]);
}
// Initialize a few variables
if (help_only) { // want tags from help file
curbuf->b_help = true; // will be restored later
}
orgpat.len = (int)strlen(pat);
if (curbuf->b_help) {
// When "@ab" is specified use only the "ab" language, otherwise
// search all languages.
if (orgpat.len > 3 && pat[orgpat.len - 3] == '@'
&& ASCII_ISALPHA(pat[orgpat.len - 2])
&& ASCII_ISALPHA(pat[orgpat.len - 1])) {
saved_pat = xstrnsave(pat, (size_t)orgpat.len - 3);
help_lang_find = (char_u *)&pat[orgpat.len - 2];
orgpat.pat = (char_u *)saved_pat;
orgpat.len -= 3;
}
}
if (p_tl != 0 && orgpat.len > p_tl) { // adjust for 'taglength'
orgpat.len = (int)p_tl;
}
save_emsg_off = emsg_off;
emsg_off = true; // don't want error for invalid RE here
prepare_pats(&orgpat, has_re);
emsg_off = save_emsg_off;
if (has_re && orgpat.regmatch.regprog == NULL) {
goto findtag_end;
}
// This is only to avoid a compiler warning for using search_info
// uninitialised.
CLEAR_FIELD(search_info);
if (*curbuf->b_p_tfu != NUL && use_tfu && !tfu_in_use) {
tfu_in_use = true;
retval = find_tagfunc_tags((char_u *)pat, &ga_match[0], &match_count, flags,
(char_u *)buf_ffname);
tfu_in_use = false;
if (retval != NOTDONE) {
goto findtag_end;
}
}
// When finding a specified number of matches, first try with matching
// case, so binary search can be used, and try ignore-case matches in a
// second loop.
// When finding all matches, 'tagbsearch' is off, or there is no fixed
// string to look for, ignore case right away to avoid going though the
// tags files twice.
// When the tag file is case-fold sorted, it is either one or the other.
// Only ignore case when TAG_NOIC not used or 'ignorecase' set.
// Set a flag if the file extension is .txt
if ((flags & TAG_KEEP_LANG)
&& help_lang_find == NULL
&& curbuf->b_fname != NULL
&& (i = (int)strlen(curbuf->b_fname)) > 4
&& STRICMP(curbuf->b_fname + i - 4, ".txt") == 0) {
is_txt = true;
}
orgpat.regmatch.rm_ic = ((p_ic || !noic)
&& (findall || orgpat.headlen == 0 || !p_tbs));
for (round = 1; round <= 2; round++) {
linear = (orgpat.headlen == 0 || !p_tbs || round == 2);
// Try tag file names from tags option one by one.
for (first_file = true;
get_tagfname(&tn, first_file, tag_fname) == OK;
first_file = false) {
// A file that doesn't exist is silently ignored. Only when not a
// single file is found, an error message is given (further on).
if (curbuf->b_help) {
// Keep en if the file extension is .txt
if (is_txt) {
if (st->is_txt) {
STRCPY(help_lang, "en");
} else {
// Prefer help tags according to 'helplang'. Put the
// two-letter language name in help_lang[].
i = (int)STRLEN(tag_fname);
if (i > 3 && tag_fname[i - 3] == '-') {
STRCPY(help_lang, tag_fname + i - 2);
i = (int)STRLEN(st->tag_fname);
if (i > 3 && st->tag_fname[i - 3] == '-') {
STRCPY(help_lang, st->tag_fname + i - 2);
} else {
STRCPY(help_lang, "en");
}
@ -1589,15 +1477,15 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
// When searching for a specific language skip tags files
// for other languages.
if (help_lang_find != NULL
&& STRICMP(help_lang, help_lang_find) != 0) {
continue;
if (st->help_lang_find != NULL
&& STRICMP(help_lang, st->help_lang_find) != 0) {
return;
}
// For CTRL-] in a help file prefer a match with the same
// language.
if ((flags & TAG_KEEP_LANG)
&& help_lang_find == NULL
&& st->help_lang_find == NULL
&& curbuf->b_fname != NULL
&& (i = (int)strlen(curbuf->b_fname)) > 4
&& curbuf->b_fname[i - 1] == 'x'
@ -1626,17 +1514,17 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
}
}
if ((fp = os_fopen(tag_fname, "r")) == NULL) {
continue;
if ((fp = os_fopen(st->tag_fname, "r")) == NULL) {
return;
}
if (p_verbose >= 5) {
verbose_enter();
smsg(_("Searching tags file %s"), tag_fname);
smsg(_("Searching tags file %s"), st->tag_fname);
verbose_leave();
}
did_open = true; // remember that we found at least one file
st->did_open = true; // remember that we found at least one file
state = TS_START; // we're at the start of the file
@ -1652,15 +1540,14 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
ins_compl_check_keys(30, false);
}
if (got_int || ins_compl_interrupted()) {
stop_searching = true;
st->stop_searching = true;
break;
}
// When mincount is TAG_MANY, stop when enough matches have been
// found (for completion).
if (mincount == TAG_MANY && match_count >= TAG_MANY) {
stop_searching = true;
retval = OK;
break;
if (st->mincount == TAG_MANY && st->match_count >= TAG_MANY) {
st->stop_searching = true;
return;
}
if (get_it_again) {
goto line_read_in;
@ -1675,7 +1562,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
search_info.curr_offset = offset;
} else if (state == TS_SKIP_BACK) {
// Skipping back (after a match during binary search).
search_info.curr_offset -= lbuf_size * 2;
search_info.curr_offset -= st->lbuf_size * 2;
if (search_info.curr_offset < 0) {
search_info.curr_offset = 0;
rewind(fp);
@ -1689,7 +1576,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
// Adjust the search file offset to the correct position
search_info.curr_offset_used = search_info.curr_offset;
vim_fseek(fp, search_info.curr_offset, SEEK_SET);
eof = vim_fgets((char_u *)lbuf, lbuf_size, fp);
eof = vim_fgets((char_u *)st->lbuf, st->lbuf_size, fp);
if (!eof && search_info.curr_offset != 0) {
search_info.curr_offset = vim_ftell(fp);
if (search_info.curr_offset == search_info.high_offset) {
@ -1697,12 +1584,12 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
vim_fseek(fp, search_info.low_offset, SEEK_SET);
search_info.curr_offset = search_info.low_offset;
}
eof = vim_fgets((char_u *)lbuf, lbuf_size, fp);
eof = vim_fgets((char_u *)st->lbuf, st->lbuf_size, fp);
}
// skip empty and blank lines
while (!eof && vim_isblankline(lbuf)) {
while (!eof && vim_isblankline(st->lbuf)) {
search_info.curr_offset = vim_ftell(fp);
eof = vim_fgets((char_u *)lbuf, lbuf_size, fp);
eof = vim_fgets((char_u *)st->lbuf, st->lbuf_size, fp);
}
if (eof) {
// Hit end of file. Skip backwards.
@ -1717,8 +1604,8 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
// skip empty and blank lines
do {
search_info.curr_offset = vim_ftell(fp);
eof = vim_fgets((char_u *)lbuf, lbuf_size, fp);
} while (!eof && vim_isblankline(lbuf));
eof = vim_fgets((char_u *)st->lbuf, st->lbuf_size, fp);
} while (!eof && vim_isblankline(st->lbuf));
if (eof) {
break; // end of file
@ -1733,16 +1620,16 @@ line_read_in:
// Convert every line. Converting the pattern from 'enc' to
// the tags file encoding doesn't work, because characters are
// not recognized.
conv_line = string_convert(&vimconv, lbuf, NULL);
conv_line = string_convert(&vimconv, st->lbuf, NULL);
if (conv_line != NULL) {
// Copy or swap lbuf and conv_line.
len = (int)strlen(conv_line) + 1;
if (len > lbuf_size) {
xfree(lbuf);
lbuf = conv_line;
lbuf_size = len;
if (len > st->lbuf_size) {
xfree(st->lbuf);
st->lbuf = conv_line;
st->lbuf_size = len;
} else {
STRCPY(lbuf, conv_line);
STRCPY(st->lbuf, conv_line);
xfree(conv_line);
}
}
@ -1753,23 +1640,23 @@ line_read_in:
if (state == TS_START) {
// The header ends when the line sorts below "!_TAG_". When
// case is folded lower case letters sort before "_".
if (STRNCMP(lbuf, "!_TAG_", 6) <= 0
|| (lbuf[0] == '!' && ASCII_ISLOWER(lbuf[1]))) {
if (STRNCMP(lbuf, "!_TAG_", 6) != 0) {
if (strncmp(st->lbuf, "!_TAG_", 6) <= 0
|| (st->lbuf[0] == '!' && ASCII_ISLOWER(st->lbuf[1]))) {
if (strncmp(st->lbuf, "!_TAG_", 6) != 0) {
// Non-header item before the header, e.g. "!" itself.
goto parse_line;
}
// Read header line.
if (STRNCMP(lbuf, "!_TAG_FILE_SORTED\t", 18) == 0) {
tag_file_sorted = (uint8_t)lbuf[18];
if (strncmp(st->lbuf, "!_TAG_FILE_SORTED\t", 18) == 0) {
tag_file_sorted = (uint8_t)st->lbuf[18];
}
if (STRNCMP(lbuf, "!_TAG_FILE_ENCODING\t", 20) == 0) {
if (strncmp(st->lbuf, "!_TAG_FILE_ENCODING\t", 20) == 0) {
// Prepare to convert every line from the specified
// encoding to 'encoding'.
for (p = lbuf + 20; *p > ' ' && *p < 127; p++) {}
for (p = st->lbuf + 20; *p > ' ' && *p < 127; p++) {}
*p = NUL;
convert_setup(&vimconv, lbuf + 20, p_enc);
convert_setup(&vimconv, st->lbuf + 20, p_enc);
}
// Read the next line. Unrecognized flags are ignored.
@ -1784,7 +1671,7 @@ line_read_in:
// the tag file isn't sorted, the second loop will find it.
// When "!_TAG_FILE_SORTED" found: start binary search if
// flag set.
if (linear) {
if (st->linear) {
state = TS_LINEAR;
} else if (tag_file_sorted == NUL) {
state = TS_BINARY;
@ -1793,15 +1680,15 @@ line_read_in:
} else if (tag_file_sorted == '2') {
state = TS_BINARY;
sortic = true;
orgpat.regmatch.rm_ic = (p_ic || !noic);
st->orgpat.regmatch.rm_ic = (p_ic || !noic);
} else {
state = TS_LINEAR;
}
if (state == TS_BINARY && orgpat.regmatch.rm_ic && !sortic) {
if (state == TS_BINARY && st->orgpat.regmatch.rm_ic && !sortic) {
// Binary search won't work for ignoring case, use linear
// search.
linear = true;
st->linear = true;
state = TS_LINEAR;
}
@ -1835,10 +1722,10 @@ parse_line:
// last-but-one byte (see vim_fgets()).
// Has been reported for Mozilla JS with extremely long names.
// In that case we need to increase lbuf_size.
if (lbuf[lbuf_size - 2] != NUL) {
lbuf_size *= 2;
xfree(lbuf);
lbuf = xmalloc((size_t)lbuf_size);
if (st->lbuf[st->lbuf_size - 2] != NUL) {
st->lbuf_size *= 2;
xfree(st->lbuf);
st->lbuf = xmalloc((size_t)st->lbuf_size);
if (state == TS_STEP_FORWARD) {
// Seek to the same position to read the same line again
@ -1853,10 +1740,10 @@ parse_line:
// Figure out where the different strings are in this line.
// For "normal" tags: Do a quick check if the tag matches.
// This speeds up tag searching a lot!
if (orgpat.headlen) {
if (st->orgpat.headlen) {
CLEAR_FIELD(tagp);
tagp.tagname = lbuf;
tagp.tagname_end = (char_u *)vim_strchr(lbuf, TAB);
tagp.tagname = st->lbuf;
tagp.tagname_end = (char_u *)vim_strchr(st->lbuf, TAB);
if (tagp.tagname_end == NULL) {
// Corrupted tag line.
line_error = true;
@ -1869,9 +1756,9 @@ parse_line:
if (p_tl != 0 && cmplen > p_tl) { // adjust for 'taglength'
cmplen = (int)p_tl;
}
if (has_re && orgpat.headlen < cmplen) {
cmplen = orgpat.headlen;
} else if (state == TS_LINEAR && orgpat.headlen != cmplen) {
if (has_re && st->orgpat.headlen < cmplen) {
cmplen = st->orgpat.headlen;
} else if (state == TS_LINEAR && st->orgpat.headlen != cmplen) {
continue;
}
@ -1887,18 +1774,18 @@ parse_line:
// Compare the current tag with the searched tag.
if (sortic) {
tagcmp = tag_strnicmp((char_u *)tagp.tagname, orgpat.head,
tagcmp = tag_strnicmp((char_u *)tagp.tagname, st->orgpat.head,
(size_t)cmplen);
} else {
tagcmp = STRNCMP(tagp.tagname, orgpat.head, cmplen);
tagcmp = STRNCMP(tagp.tagname, st->orgpat.head, cmplen);
}
// A match with a shorter tag means to search forward.
// A match with a longer tag means to search backward.
if (tagcmp == 0) {
if (cmplen < orgpat.headlen) {
if (cmplen < st->orgpat.headlen) {
tagcmp = -1;
} else if (cmplen > orgpat.headlen) {
} else if (cmplen > st->orgpat.headlen) {
tagcmp = 1;
}
}
@ -1939,7 +1826,7 @@ parse_line:
break;
} else if (state == TS_SKIP_BACK) {
assert(cmplen >= 0);
if (mb_strnicmp(tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
if (mb_strnicmp(tagp.tagname, (char *)st->orgpat.head, (size_t)cmplen) != 0) {
state = TS_STEP_FORWARD;
} else {
// Have to skip back more. Restore the curr_offset
@ -1949,7 +1836,7 @@ parse_line:
continue;
} else if (state == TS_STEP_FORWARD) {
assert(cmplen >= 0);
if (mb_strnicmp(tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
if (mb_strnicmp(tagp.tagname, (char *)st->orgpat.head, (size_t)cmplen) != 0) {
if ((off_T)vim_ftell(fp) > search_info.match_offset) {
break; // past last match
} else {
@ -1959,10 +1846,10 @@ parse_line:
} else {
// skip this match if it can't match
assert(cmplen >= 0);
}
if (mb_strnicmp(tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
if (mb_strnicmp(tagp.tagname, (char *)st->orgpat.head, (size_t)cmplen) != 0) {
continue;
}
}
// Can be a matching tag, isolate the file name and command.
tagp.fname = tagp.tagname_end + 1;
@ -1974,7 +1861,7 @@ parse_line:
i = OK;
}
} else {
i = parse_tag_line((char_u *)lbuf, &tagp);
i = parse_tag_line((char_u *)st->lbuf, &tagp);
}
if (i == FAIL) {
line_error = true;
@ -1988,35 +1875,35 @@ parse_line:
cmplen = (int)p_tl;
}
// if tag length does not match, don't try comparing
if (orgpat.len != cmplen) {
if (st->orgpat.len != cmplen) {
match = false;
} else {
if (orgpat.regmatch.rm_ic) {
if (st->orgpat.regmatch.rm_ic) {
assert(cmplen >= 0);
match = mb_strnicmp(tagp.tagname, (char *)orgpat.pat, (size_t)cmplen) == 0;
match = mb_strnicmp(tagp.tagname, (char *)st->orgpat.pat, (size_t)cmplen) == 0;
if (match) {
match_no_ic = (STRNCMP(tagp.tagname, orgpat.pat,
match_no_ic = (STRNCMP(tagp.tagname, st->orgpat.pat,
cmplen) == 0);
}
} else {
match = (STRNCMP(tagp.tagname, orgpat.pat, cmplen) == 0);
match = (STRNCMP(tagp.tagname, st->orgpat.pat, cmplen) == 0);
}
}
// Has a regexp: Also find tags matching regexp.
match_re = false;
if (!match && orgpat.regmatch.regprog != NULL) {
if (!match && st->orgpat.regmatch.regprog != NULL) {
int cc;
cc = *tagp.tagname_end;
*tagp.tagname_end = NUL;
match = vim_regexec(&orgpat.regmatch, tagp.tagname, (colnr_T)0);
match = vim_regexec(&st->orgpat.regmatch, tagp.tagname, (colnr_T)0);
if (match) {
matchoff = (int)(orgpat.regmatch.startp[0] - tagp.tagname);
if (orgpat.regmatch.rm_ic) {
orgpat.regmatch.rm_ic = false;
match_no_ic = vim_regexec(&orgpat.regmatch, tagp.tagname, (colnr_T)0);
orgpat.regmatch.rm_ic = true;
matchoff = (int)(st->orgpat.regmatch.startp[0] - tagp.tagname);
if (st->orgpat.regmatch.rm_ic) {
st->orgpat.regmatch.rm_ic = false;
match_no_ic = vim_regexec(&st->orgpat.regmatch, tagp.tagname, (colnr_T)0);
st->orgpat.regmatch.rm_ic = true;
}
}
*tagp.tagname_end = (char_u)cc;
@ -2029,7 +1916,7 @@ parse_line:
// Decide in which array to store this match.
is_current = test_for_current((char *)tagp.fname, (char *)tagp.fname_end,
tag_fname,
st->tag_fname,
buf_ffname);
is_static = test_for_static(&tagp);
@ -2047,7 +1934,7 @@ parse_line:
mtt = MT_GL_OTH;
}
}
if (orgpat.regmatch.rm_ic && !match_no_ic) {
if (st->orgpat.regmatch.rm_ic && !match_no_ic) {
mtt += MT_IC_OFF;
}
if (match_re) {
@ -2073,8 +1960,7 @@ parse_line:
STRCPY(p + len + 1, help_lang);
snprintf(p + len + 1 + ML_EXTRA, strlen(p) + len + 1 + ML_EXTRA, "%06d",
help_heuristic(tagp.tagname,
match_re ? matchoff : 0, !match_no_ic)
+ help_pri);
match_re ? matchoff : 0, !match_no_ic) + help_pri);
*tagp.tagname_end = TAB;
} else if (name_only) {
@ -2108,7 +1994,7 @@ parse_line:
}
}
} else {
size_t tag_fname_len = strlen(tag_fname);
size_t tag_fname_len = strlen(st->tag_fname);
// Save the tag in a buffer.
// Use 0x02 to separate fields (Can't use NUL, because the
// hash key is terminated by NUL).
@ -2116,11 +2002,11 @@ parse_line:
// other tag: <mtt><tag_fname><0x02><0x02><lbuf><NUL>
// without Emacs tags: <mtt><tag_fname><0x02><lbuf><NUL>
// Here <mtt> is the "mtt" value plus 1 to avoid NUL.
len = tag_fname_len + strlen(lbuf) + 3;
len = tag_fname_len + strlen(st->lbuf) + 3;
mfp = xmalloc(sizeof(char) + len + 1);
p = mfp;
p[0] = (char)(mtt + 1);
STRCPY(p + 1, tag_fname);
STRCPY(p + 1, st->tag_fname);
#ifdef BACKSLASH_IN_FILENAME
// Ignore differences in slashes, avoid adding
// both path/file and path\file.
@ -2128,7 +2014,7 @@ parse_line:
#endif
p[tag_fname_len + 1] = TAG_SEP;
s = (char_u *)p + 1 + tag_fname_len + 1;
STRCPY(s, lbuf);
STRCPY(s, st->lbuf);
}
if (mfp != NULL) {
@ -2140,13 +2026,11 @@ parse_line:
// follow after it. E.g. help tags store the priority
// after the NUL.
hash = hash_hash((char_u *)mfp);
hi = hash_lookup(&ht_match[mtt], (const char *)mfp,
strlen(mfp), hash);
hi = hash_lookup(&st->ht_match[mtt], (const char *)mfp, strlen(mfp), hash);
if (HASHITEM_EMPTY(hi)) {
hash_add_item(&ht_match[mtt], hi, (char_u *)mfp, hash);
ga_grow(&ga_match[mtt], 1);
((char **)(ga_match[mtt].ga_data))[ga_match[mtt].ga_len++] = mfp;
match_count++;
hash_add_item(&st->ht_match[mtt], hi, (char_u *)mfp, hash);
GA_APPEND(char *, &st->ga_match[mtt], mfp);
st->match_count++;
} else {
// duplicate tag, drop it
xfree(mfp);
@ -2156,9 +2040,9 @@ parse_line:
} // forever
if (line_error) {
semsg(_("E431: Format error in tags file \"%s\""), tag_fname);
semsg(_("E431: Format error in tags file \"%s\""), st->tag_fname);
semsg(_("Before byte %" PRId64), (int64_t)vim_ftell(fp));
stop_searching = true;
st->stop_searching = true;
line_error = false;
}
@ -2169,58 +2053,35 @@ parse_line:
tag_file_sorted = NUL;
if (sort_error) {
semsg(_("E432: Tags file not sorted: %s"), tag_fname);
semsg(_("E432: Tags file not sorted: %s"), st->tag_fname);
sort_error = false;
}
// Stop searching if sufficient tags have been found.
if (match_count >= mincount) {
retval = OK;
stop_searching = true;
if (st->match_count >= st->mincount) {
st->stop_searching = true;
}
}
if (stop_searching) {
break;
}
} // end of for-each-file loop
/// Copy the tags found by find_tags() to "matchesp".
static void findtags_copy_matches(findtags_state_T *st, char ***matchesp, int *num_matches,
int name_only)
{
char **matches;
int mtt;
int i;
char *mfp;
char *p;
tagname_free(&tn);
// stop searching when already did a linear search, or when TAG_NOIC
// used, and 'ignorecase' not set or already did case-ignore search
if (stop_searching || linear || (!p_ic && noic) || orgpat.regmatch.rm_ic) {
break;
}
orgpat.regmatch.rm_ic = true; // try another time while ignoring case
}
if (!stop_searching) {
if (!did_open && verbose) { // never opened any tags file
emsg(_("E433: No tags file"));
}
retval = OK; // It's OK even when no tag found
}
findtag_end:
xfree(lbuf);
vim_regfree(orgpat.regmatch.regprog);
xfree(tag_fname);
// Move the matches from the ga_match[] arrays into one list of
// matches. When retval == FAIL, free the matches.
if (retval == FAIL) {
match_count = 0;
}
if (match_count > 0) {
matches = xmalloc((size_t)match_count * sizeof(char *));
if (st->match_count > 0) {
matches = xmalloc((size_t)st->match_count * sizeof(char *));
} else {
matches = NULL;
}
match_count = 0;
st->match_count = 0;
for (mtt = 0; mtt < MT_COUNT; mtt++) {
for (i = 0; i < ga_match[mtt].ga_len; i++) {
mfp = ((char **)(ga_match[mtt].ga_data))[i];
for (i = 0; i < st->ga_match[mtt].ga_len; i++) {
mfp = ((char **)(st->ga_match[mtt].ga_data))[i];
if (matches == NULL) {
xfree(mfp);
} else {
@ -2235,16 +2096,202 @@ findtag_end:
}
}
}
matches[match_count++] = mfp;
matches[st->match_count++] = mfp;
}
}
ga_clear(&ga_match[mtt]);
hash_clear(&ht_match[mtt]);
ga_clear(&st->ga_match[mtt]);
hash_clear(&st->ht_match[mtt]);
}
*matchesp = matches;
*num_matches = match_count;
*num_matches = st->match_count;
}
/// find_tags() - search for tags in tags files
///
/// Return FAIL if search completely failed (*num_matches will be 0, *matchesp
/// will be NULL), OK otherwise.
///
/// There is a priority in which type of tag is recognized.
///
/// 6. A static or global tag with a full matching tag for the current file.
/// 5. A global tag with a full matching tag for another file.
/// 4. A static tag with a full matching tag for another file.
/// 3. A static or global tag with an ignore-case matching tag for the
/// current file.
/// 2. A global tag with an ignore-case matching tag for another file.
/// 1. A static tag with an ignore-case matching tag for another file.
///
/// Tags in an emacs-style tags file are always global.
///
/// flags:
/// TAG_HELP only search for help tags
/// TAG_NAMES only return name of tag
/// TAG_REGEXP use "pat" as a regexp
/// TAG_NOIC don't always ignore case
/// TAG_KEEP_LANG keep language
/// TAG_NO_TAGFUNC do not call the 'tagfunc' function
///
/// @param pat pattern to search for
/// @param num_matches return: number of matches found
/// @param matchesp return: array of matches found
/// @param mincount MAXCOL: find all matches
/// other: minimal number of matches
/// @param buf_ffname name of buffer for priority
int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int mincount,
char *buf_ffname)
{
findtags_state_T st;
tagname_T tn; // info for get_tagfname()
int first_file; // trying first tag file
int retval = FAIL; // return value
int round;
int save_emsg_off;
int help_save;
int i;
char *saved_pat = NULL; // copy of pat[]
int findall = (mincount == MAXCOL || mincount == TAG_MANY); // find all matching tags
int has_re = (flags & TAG_REGEXP); // regexp used
int help_only = (flags & TAG_HELP);
int name_only = (flags & TAG_NAMES);
int noic = (flags & TAG_NOIC);
int verbose = (flags & TAG_VERBOSE);
int use_tfu = ((flags & TAG_NO_TAGFUNC) == 0);
int save_p_ic = p_ic;
// Change the value of 'ignorecase' according to 'tagcase' for the
// duration of this function.
switch (curbuf->b_tc_flags ? curbuf->b_tc_flags : tc_flags) {
case TC_FOLLOWIC:
break;
case TC_IGNORE:
p_ic = true;
break;
case TC_MATCH:
p_ic = false;
break;
case TC_FOLLOWSCS:
p_ic = ignorecase((char_u *)pat);
break;
case TC_SMART:
p_ic = ignorecase_opt((char_u *)pat, true, true);
break;
default:
abort();
}
help_save = curbuf->b_help;
findtags_state_init(&st, pat, mincount);
// Initialize a few variables
if (help_only) { // want tags from help file
curbuf->b_help = true; // will be restored later
}
if (curbuf->b_help) {
// When "@ab" is specified use only the "ab" language, otherwise
// search all languages.
if (st.orgpat.len > 3 && pat[st.orgpat.len - 3] == '@'
&& ASCII_ISALPHA(pat[st.orgpat.len - 2])
&& ASCII_ISALPHA(pat[st.orgpat.len - 1])) {
saved_pat = xstrnsave(pat, (size_t)st.orgpat.len - 3);
st.help_lang_find = &pat[st.orgpat.len - 2];
st.orgpat.pat = (char_u *)saved_pat;
st.orgpat.len -= 3;
}
}
if (p_tl != 0 && st.orgpat.len > p_tl) { // adjust for 'taglength'
st.orgpat.len = (int)p_tl;
}
save_emsg_off = emsg_off;
emsg_off = true; // don't want error for invalid RE here
prepare_pats(&st.orgpat, has_re);
emsg_off = save_emsg_off;
if (has_re && st.orgpat.regmatch.regprog == NULL) {
goto findtag_end;
}
if (*curbuf->b_p_tfu != NUL && use_tfu && !tfu_in_use) {
tfu_in_use = true;
retval = find_tagfunc_tags((char_u *)pat, &st.ga_match[0], &st.match_count, flags,
(char_u *)buf_ffname);
tfu_in_use = false;
if (retval != NOTDONE) {
goto findtag_end;
}
}
// When finding a specified number of matches, first try with matching
// case, so binary search can be used, and try ignore-case matches in a
// second loop.
// When finding all matches, 'tagbsearch' is off, or there is no fixed
// string to look for, ignore case right away to avoid going though the
// tags files twice.
// When the tag file is case-fold sorted, it is either one or the other.
// Only ignore case when TAG_NOIC not used or 'ignorecase' set.
// Set a flag if the file extension is .txt
if ((flags & TAG_KEEP_LANG)
&& st.help_lang_find == NULL
&& curbuf->b_fname != NULL
&& (i = (int)strlen(curbuf->b_fname)) > 4
&& STRICMP(curbuf->b_fname + i - 4, ".txt") == 0) {
st.is_txt = true;
}
st.orgpat.regmatch.rm_ic = ((p_ic || !noic)
&& (findall || st.orgpat.headlen == 0 || !p_tbs));
for (round = 1; round <= 2; round++) {
st.linear = (st.orgpat.headlen == 0 || !p_tbs || round == 2);
// Try tag file names from tags option one by one.
for (first_file = true;
get_tagfname(&tn, first_file, st.tag_fname) == OK;
first_file = false) {
find_tags_in_file(&st, flags, buf_ffname);
if (st.stop_searching) {
retval = OK;
break;
}
} // end of for-each-file loop
tagname_free(&tn);
// stop searching when already did a linear search, or when TAG_NOIC
// used, and 'ignorecase' not set or already did case-ignore search
if (st.stop_searching || st.linear || (!p_ic && noic)
|| st.orgpat.regmatch.rm_ic) {
break;
}
// try another time while ignoring case
st.orgpat.regmatch.rm_ic = true;
}
if (!st.stop_searching) {
if (!st.did_open && verbose) { // never opened any tags file
emsg(_("E433: No tags file"));
}
retval = OK; // It's OK even when no tag found
}
findtag_end:
xfree(st.tag_fname);
xfree(st.lbuf);
vim_regfree(st.orgpat.regmatch.regprog);
// Move the matches from the ga_match[] arrays into one list of
// matches. When retval == FAIL, free the matches.
if (retval == FAIL) {
st.match_count = 0;
}
findtags_copy_matches(&st, matchesp, num_matches, name_only);
curbuf->b_help = help_save;
xfree(saved_pat);

5
src/nvim/testdir/test_tagjump.vim
View File

@ -1448,6 +1448,11 @@ func Test_tagfile_errors()
endtry
call assert_equal(v:true, caught_431)
" tag name and file name are not separated by a tab
call writefile(["!_TAG_FILE_ENCODING\tutf-8\t//",
\ "foo Xfile 1"], 'Xtags')
call assert_fails('tag foo', 'E431:')
call delete('Xtags')
call delete('Xfile')
set tags&