Mercurial > vim
annotate src/tag.c @ 26268:3aa48d4e3dc8 v8.2.3665
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Commit: https://github.com/vim/vim/commit/19916a8c8920b6a1fd737ffa6d4e363fc7a96319
Author: Yegappan Lakshmanan <yegappan@yahoo.com>
Date: Wed Nov 24 16:32:55 2021 +0000
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Problem: Cannot use a lambda for 'tagfunc'.
Solution: Use 'tagfunc' like 'opfunc'. (Yegappan Lakshmanan, closes https://github.com/vim/vim/issues/9204)
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Wed, 24 Nov 2021 17:45:03 +0100 |
| parents | 336e2d9924e6 |
| children | 8aba638e91eb |
| rev | line source |
|---|---|
|
10042
4aead6a9b7a9
commit https://github.com/vim/vim/commit/edf3f97ae2af024708ebb4ac614227327033ca47
Christian Brabandt <cb@256bit.org>
parents:
9949
diff
changeset
|
1 /* vi:set ts=8 sts=4 sw=4 noet: |
| 7 | 2 * |
| 3 * VIM - Vi IMproved by Bram Moolenaar | |
| 4 * | |
| 5 * Do ":help uganda" in Vim to read copying and usage conditions. | |
| 6 * Do ":help credits" in Vim to see a list of people who contributed. | |
| 7 * See README.txt for an overview of the Vim source code. | |
| 8 */ | |
| 9 | |
| 10 /* | |
| 11 * Code to handle tags and the tag stack | |
| 12 */ | |
| 13 | |
| 14 #include "vim.h" | |
| 15 | |
| 16 /* | |
| 17 * Structure to hold pointers to various items in a tag line. | |
| 18 */ | |
| 19 typedef struct tag_pointers | |
| 20 { | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
21 // filled in by parse_tag_line(): |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
22 char_u *tagname; // start of tag name (skip "file:") |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
23 char_u *tagname_end; // char after tag name |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
24 char_u *fname; // first char of file name |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
25 char_u *fname_end; // char after file name |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
26 char_u *command; // first char of command |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
27 // filled in by parse_match(): |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
28 char_u *command_end; // first char after command |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
29 char_u *tag_fname; // file name of the tags file. This is used |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
30 // when 'tr' is set. |
| 7 | 31 #ifdef FEAT_EMACS_TAGS |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
32 int is_etag; // TRUE for emacs tag |
| 7 | 33 #endif |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
34 char_u *tagkind; // "kind:" value |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
35 char_u *tagkind_end; // end of tagkind |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
36 char_u *user_data; // user_data string |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
37 char_u *user_data_end; // end of user_data |
|
18640
b9240fe40dd4
patch 8.1.2312: "line:" field in tags file not used
Bram Moolenaar <Bram@vim.org>
parents:
18554
diff
changeset
|
38 linenr_T tagline; // "line:" value |
| 7 | 39 } tagptrs_T; |
| 40 | |
| 41 /* | |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
42 * The matching tags are first stored in one of the hash tables. In |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
43 * which one depends on the priority of the match. |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
44 * ht_match[] is used to find duplicates, ga_match[] to keep them in sequence. |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
45 * At the end, all the matches from ga_match[] are concatenated, to make a list |
| 7 | 46 * sorted on priority. |
| 47 */ | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
48 #define MT_ST_CUR 0 // static match in current file |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
49 #define MT_GL_CUR 1 // global match in current file |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
50 #define MT_GL_OTH 2 // global match in other file |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
51 #define MT_ST_OTH 3 // static match in other file |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
52 #define MT_IC_OFF 4 // add for icase match |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
53 #define MT_RE_OFF 8 // add for regexp match |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
54 #define MT_MASK 7 // mask for printing priority |
| 7 | 55 #define MT_COUNT 16 |
| 56 | |
| 57 static char *mt_names[MT_COUNT/2] = | |
| 58 {"FSC", "F C", "F ", "FS ", " SC", " C", " ", " S "}; | |
| 59 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
60 #define NOTAGFILE 99 // return value for jumpto_tag |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
61 static char_u *nofile_fname = NULL; // fname for NOTAGFILE error |
| 7 | 62 |
|
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
63 static void taglen_advance(int l); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
64 |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
65 static int jumpto_tag(char_u *lbuf, int forceit, int keep_help); |
| 7 | 66 #ifdef FEAT_EMACS_TAGS |
|
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
67 static int parse_tag_line(char_u *lbuf, int is_etag, tagptrs_T *tagp); |
| 7 | 68 #else |
|
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
69 static int parse_tag_line(char_u *lbuf, tagptrs_T *tagp); |
| 7 | 70 #endif |
|
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
71 static int test_for_static(tagptrs_T *); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
72 static int parse_match(char_u *lbuf, tagptrs_T *tagp); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
73 static char_u *tag_full_fname(tagptrs_T *tagp); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
74 static char_u *expand_tag_fname(char_u *fname, char_u *tag_fname, int expand); |
| 7 | 75 #ifdef FEAT_EMACS_TAGS |
|
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
76 static int test_for_current(int, char_u *, char_u *, char_u *, char_u *); |
| 7 | 77 #else |
|
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
78 static int test_for_current(char_u *, char_u *, char_u *, char_u *); |
| 7 | 79 #endif |
|
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7266
diff
changeset
|
80 static int find_extra(char_u **pp); |
|
16188
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
81 static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char_u **matches); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
82 #if defined(FEAT_QUICKFIX) && defined(FEAT_EVAL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
83 static int add_llist_tags(char_u *tag, int num_matches, char_u **matches); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
84 #endif |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
85 static void tagstack_clear_entry(taggy_T *item); |
| 7 | 86 |
| 87 static char_u *bottommsg = (char_u *)N_("E555: at bottom of tag stack"); | |
| 88 static char_u *topmsg = (char_u *)N_("E556: at top of tag stack"); | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
89 #ifdef FEAT_EVAL |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
90 static char_u *recurmsg = (char_u *)N_("E986: cannot modify the tag stack within tagfunc"); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
91 static char_u *tfu_inv_ret_msg = (char_u *)N_("E987: invalid return value from tagfunc"); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
92 #endif |
| 7 | 93 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
94 static char_u *tagmatchname = NULL; // name of last used tag |
| 7 | 95 |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
96 #if defined(FEAT_QUICKFIX) |
| 7 | 97 /* |
| 98 * Tag for preview window is remembered separately, to avoid messing up the | |
| 99 * normal tagstack. | |
| 100 */ | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
101 static taggy_T ptag_entry = {NULL, {{0, 0, 0}, 0}, 0, 0, NULL}; |
| 7 | 102 #endif |
| 103 | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
104 #ifdef FEAT_EVAL |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
105 static int tfu_in_use = FALSE; // disallow recursive call of tagfunc |
|
26268
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
106 static callback_T tfu_cb; // 'tagfunc' callback function |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
107 #endif |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
108 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
109 // Used instead of NUL to separate tag fields in the growarrays. |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
110 #define TAG_SEP 0x02 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
111 |
| 7 | 112 /* |
|
26268
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
113 * Reads the 'tagfunc' option value and convert that to a callback value. |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
114 * Invoked when the 'tagfunc' option is set. The option value can be a name of |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
115 * a function (string), or function(<name>) or funcref(<name>) or a lambda. |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
116 */ |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
117 int |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
118 set_tagfunc_option() |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
119 { |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
120 #ifdef FEAT_EVAL |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
121 free_callback(&tfu_cb); |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
122 free_callback(&curbuf->b_tfu_cb); |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
123 |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
124 if (*curbuf->b_p_tfu == NUL) |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
125 return OK; |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
126 |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
127 if (option_set_callback_func(curbuf->b_p_tfu, &tfu_cb) == FAIL) |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
128 return FAIL; |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
129 |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
130 copy_callback(&curbuf->b_tfu_cb, &tfu_cb); |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
131 #endif |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
132 |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
133 return OK; |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
134 } |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
135 |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
136 # if defined(EXITFREE) || defined(PROTO) |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
137 void |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
138 free_tagfunc_option(void) |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
139 { |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
140 # ifdef FEAT_EVAL |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
141 free_callback(&tfu_cb); |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
142 # endif |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
143 } |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
144 # endif |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
145 |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
146 /* |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
147 * Copy the global 'tagfunc' callback function to the buffer-local 'tagfunc' |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
148 * callback for 'buf'. |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
149 */ |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
150 void |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
151 buf_set_tfu_callback(buf_T *buf UNUSED) |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
152 { |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
153 #ifdef FEAT_EVAL |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
154 free_callback(&buf->b_tfu_cb); |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
155 if (tfu_cb.cb_name != NULL && *tfu_cb.cb_name != NUL) |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
156 copy_callback(&buf->b_tfu_cb, &tfu_cb); |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
157 #endif |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
158 } |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
159 |
|
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
160 /* |
| 7 | 161 * Jump to tag; handling of tag commands and tag stack |
| 162 * | |
| 163 * *tag != NUL: ":tag {tag}", jump to new tag, add to tag stack | |
| 164 * | |
| 165 * type == DT_TAG: ":tag [tag]", jump to newer position or same tag again | |
| 166 * type == DT_HELP: like DT_TAG, but don't use regexp. | |
| 167 * type == DT_POP: ":pop" or CTRL-T, jump to old position | |
| 168 * type == DT_NEXT: jump to next match of same tag | |
| 169 * type == DT_PREV: jump to previous match of same tag | |
| 170 * type == DT_FIRST: jump to first match of same tag | |
| 171 * type == DT_LAST: jump to last match of same tag | |
| 172 * type == DT_SELECT: ":tselect [tag]", select tag from a list of all matches | |
| 173 * type == DT_JUMP: ":tjump [tag]", jump to tag or select tag from a list | |
| 359 | 174 * type == DT_CSCOPE: use cscope to find the tag |
| 649 | 175 * type == DT_LTAG: use location list for displaying tag matches |
| 359 | 176 * type == DT_FREE: free cached matches |
| 7 | 177 * |
| 178 * for cscope, returns TRUE if we jumped to tag or aborted, FALSE otherwise | |
| 179 */ | |
| 180 int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
181 do_tag( |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
182 char_u *tag, // tag (pattern) to jump to |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
183 int type, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
184 int count, |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
185 int forceit, // :ta with ! |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
186 int verbose) // print "tag not found" message |
| 7 | 187 { |
| 188 taggy_T *tagstack = curwin->w_tagstack; | |
| 189 int tagstackidx = curwin->w_tagstackidx; | |
| 190 int tagstacklen = curwin->w_tagstacklen; | |
| 191 int cur_match = 0; | |
| 192 int cur_fnum = curbuf->b_fnum; | |
| 193 int oldtagstackidx = tagstackidx; | |
| 194 int prevtagstackidx = tagstackidx; | |
| 195 int prev_num_matches; | |
| 196 int new_tag = FALSE; | |
|
16188
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
197 int i; |
| 7 | 198 int ic; |
| 199 int no_regexp = FALSE; | |
| 200 int error_cur_match = 0; | |
| 201 int save_pos = FALSE; | |
| 202 fmark_T saved_fmark; | |
| 203 #ifdef FEAT_CSCOPE | |
| 204 int jumped_to_tag = FALSE; | |
| 205 #endif | |
| 206 int new_num_matches; | |
| 207 char_u **new_matches; | |
| 208 int use_tagstack; | |
| 209 int skip_msg = FALSE; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
210 char_u *buf_ffname = curbuf->b_ffname; // name to use for |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
211 // priority computation |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
212 int use_tfu = 1; |
| 7 | 213 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
214 // remember the matches for the last used tag |
| 7 | 215 static int num_matches = 0; |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
216 static int max_num_matches = 0; // limit used for match search |
| 7 | 217 static char_u **matches = NULL; |
| 218 static int flags; | |
| 219 | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
220 #ifdef FEAT_EVAL |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
221 if (tfu_in_use) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
222 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
223 emsg(_(recurmsg)); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
224 return FALSE; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
225 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
226 #endif |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
227 |
| 359 | 228 #ifdef EXITFREE |
| 229 if (type == DT_FREE) | |
| 230 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
231 // remove the list of matches |
| 359 | 232 FreeWild(num_matches, matches); |
| 233 # ifdef FEAT_CSCOPE | |
| 234 cs_free_tags(); | |
| 235 # endif | |
| 236 num_matches = 0; | |
| 237 return FALSE; | |
| 238 } | |
| 239 #endif | |
| 240 | |
| 7 | 241 if (type == DT_HELP) |
| 242 { | |
| 243 type = DT_TAG; | |
| 244 no_regexp = TRUE; | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
245 use_tfu = 0; |
| 7 | 246 } |
| 247 | |
| 248 prev_num_matches = num_matches; | |
| 249 free_string_option(nofile_fname); | |
| 250 nofile_fname = NULL; | |
| 251 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
252 CLEAR_POS(&saved_fmark.mark); // shutup gcc 4.0 |
| 698 | 253 saved_fmark.fnum = 0; |
| 254 | |
| 7 | 255 /* |
| 256 * Don't add a tag to the tagstack if 'tagstack' has been reset. | |
| 257 */ | |
| 258 if ((!p_tgst && *tag != NUL)) | |
| 259 { | |
| 260 use_tagstack = FALSE; | |
| 261 new_tag = TRUE; | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
262 #if defined(FEAT_QUICKFIX) |
|
8930
a2aca019ba48
commit https://github.com/vim/vim/commit/def5abe0a2727041ecee69afdccfca405333bd24
Christian Brabandt <cb@256bit.org>
parents:
8863
diff
changeset
|
263 if (g_do_tagpreview != 0) |
|
a2aca019ba48
commit https://github.com/vim/vim/commit/def5abe0a2727041ecee69afdccfca405333bd24
Christian Brabandt <cb@256bit.org>
parents:
8863
diff
changeset
|
264 { |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
265 tagstack_clear_entry(&ptag_entry); |
|
8930
a2aca019ba48
commit https://github.com/vim/vim/commit/def5abe0a2727041ecee69afdccfca405333bd24
Christian Brabandt <cb@256bit.org>
parents:
8863
diff
changeset
|
266 if ((ptag_entry.tagname = vim_strsave(tag)) == NULL) |
|
a2aca019ba48
commit https://github.com/vim/vim/commit/def5abe0a2727041ecee69afdccfca405333bd24
Christian Brabandt <cb@256bit.org>
parents:
8863
diff
changeset
|
267 goto end_do_tag; |
|
a2aca019ba48
commit https://github.com/vim/vim/commit/def5abe0a2727041ecee69afdccfca405333bd24
Christian Brabandt <cb@256bit.org>
parents:
8863
diff
changeset
|
268 } |
|
a2aca019ba48
commit https://github.com/vim/vim/commit/def5abe0a2727041ecee69afdccfca405333bd24
Christian Brabandt <cb@256bit.org>
parents:
8863
diff
changeset
|
269 #endif |
| 7 | 270 } |
| 271 else | |
| 272 { | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
273 #if defined(FEAT_QUICKFIX) |
| 2713 | 274 if (g_do_tagpreview != 0) |
| 7 | 275 use_tagstack = FALSE; |
| 276 else | |
| 277 #endif | |
| 278 use_tagstack = TRUE; | |
| 279 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
280 // new pattern, add to the tag stack |
| 845 | 281 if (*tag != NUL |
| 282 && (type == DT_TAG || type == DT_SELECT || type == DT_JUMP | |
| 649 | 283 #ifdef FEAT_QUICKFIX |
| 284 || type == DT_LTAG | |
| 285 #endif | |
| 7 | 286 #ifdef FEAT_CSCOPE |
| 287 || type == DT_CSCOPE | |
| 288 #endif | |
| 289 )) | |
| 290 { | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
291 #if defined(FEAT_QUICKFIX) |
| 2713 | 292 if (g_do_tagpreview != 0) |
| 7 | 293 { |
| 294 if (ptag_entry.tagname != NULL | |
| 295 && STRCMP(ptag_entry.tagname, tag) == 0) | |
| 296 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
297 // Jumping to same tag: keep the current match, so that |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
298 // the CursorHold autocommand example works. |
| 7 | 299 cur_match = ptag_entry.cur_match; |
| 300 cur_fnum = ptag_entry.cur_fnum; | |
| 301 } | |
| 302 else | |
| 303 { | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
304 tagstack_clear_entry(&ptag_entry); |
| 7 | 305 if ((ptag_entry.tagname = vim_strsave(tag)) == NULL) |
| 306 goto end_do_tag; | |
| 307 } | |
| 308 } | |
| 309 else | |
| 310 #endif | |
| 311 { | |
| 312 /* | |
| 313 * If the last used entry is not at the top, delete all tag | |
| 314 * stack entries above it. | |
| 315 */ | |
| 316 while (tagstackidx < tagstacklen) | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
317 tagstack_clear_entry(&tagstack[--tagstacklen]); |
| 7 | 318 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
319 // if the tagstack is full: remove oldest entry |
| 7 | 320 if (++tagstacklen > TAGSTACKSIZE) |
| 321 { | |
| 322 tagstacklen = TAGSTACKSIZE; | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
323 tagstack_clear_entry(&tagstack[0]); |
| 7 | 324 for (i = 1; i < tagstacklen; ++i) |
| 325 tagstack[i - 1] = tagstack[i]; | |
| 326 --tagstackidx; | |
| 327 } | |
| 328 | |
| 329 /* | |
| 330 * put the tag name in the tag stack | |
| 331 */ | |
| 332 if ((tagstack[tagstackidx].tagname = vim_strsave(tag)) == NULL) | |
| 333 { | |
| 334 curwin->w_tagstacklen = tagstacklen - 1; | |
| 335 goto end_do_tag; | |
| 336 } | |
| 337 curwin->w_tagstacklen = tagstacklen; | |
| 338 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
339 save_pos = TRUE; // save the cursor position below |
| 7 | 340 } |
| 341 | |
| 342 new_tag = TRUE; | |
| 343 } | |
| 344 else | |
| 345 { | |
| 346 if ( | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
347 #if defined(FEAT_QUICKFIX) |
| 2713 | 348 g_do_tagpreview != 0 ? ptag_entry.tagname == NULL : |
| 7 | 349 #endif |
| 350 tagstacklen == 0) | |
| 351 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
352 // empty stack |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
353 emsg(_(e_tagstack)); |
| 7 | 354 goto end_do_tag; |
| 355 } | |
| 356 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
357 if (type == DT_POP) // go to older position |
| 7 | 358 { |
| 359 #ifdef FEAT_FOLDING | |
| 360 int old_KeyTyped = KeyTyped; | |
| 361 #endif | |
| 362 if ((tagstackidx -= count) < 0) | |
| 363 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
364 emsg(_(bottommsg)); |
| 7 | 365 if (tagstackidx + count == 0) |
| 366 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
367 // We did [num]^T from the bottom of the stack |
| 7 | 368 tagstackidx = 0; |
| 369 goto end_do_tag; | |
| 370 } | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
371 // We weren't at the bottom of the stack, so jump all the |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
372 // way to the bottom now. |
| 7 | 373 tagstackidx = 0; |
| 374 } | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
375 else if (tagstackidx >= tagstacklen) // count == 0? |
| 7 | 376 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
377 emsg(_(topmsg)); |
| 7 | 378 goto end_do_tag; |
| 379 } | |
| 380 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
381 // Make a copy of the fmark, autocommands may invalidate the |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
382 // tagstack before it's used. |
| 7 | 383 saved_fmark = tagstack[tagstackidx].fmark; |
| 384 if (saved_fmark.fnum != curbuf->b_fnum) | |
| 385 { | |
| 386 /* | |
| 387 * Jump to other file. If this fails (e.g. because the | |
| 388 * file was changed) keep original position in tag stack. | |
| 389 */ | |
| 390 if (buflist_getfile(saved_fmark.fnum, saved_fmark.mark.lnum, | |
| 391 GETF_SETMARK, forceit) == FAIL) | |
| 392 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
393 tagstackidx = oldtagstackidx; // back to old posn |
| 7 | 394 goto end_do_tag; |
| 395 } | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
396 // An BufReadPost autocommand may jump to the '" mark, but |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
397 // we don't what that here. |
| 7 | 398 curwin->w_cursor.lnum = saved_fmark.mark.lnum; |
| 399 } | |
| 400 else | |
| 401 { | |
| 402 setpcmark(); | |
| 403 curwin->w_cursor.lnum = saved_fmark.mark.lnum; | |
| 404 } | |
| 405 curwin->w_cursor.col = saved_fmark.mark.col; | |
| 406 curwin->w_set_curswant = TRUE; | |
| 407 check_cursor(); | |
| 408 #ifdef FEAT_FOLDING | |
| 409 if ((fdo_flags & FDO_TAG) && old_KeyTyped) | |
| 410 foldOpenCursor(); | |
| 411 #endif | |
| 412 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
413 // remove the old list of matches |
| 7 | 414 FreeWild(num_matches, matches); |
| 415 #ifdef FEAT_CSCOPE | |
| 416 cs_free_tags(); | |
| 417 #endif | |
| 418 num_matches = 0; | |
| 845 | 419 tag_freematch(); |
| 7 | 420 goto end_do_tag; |
| 421 } | |
| 422 | |
| 692 | 423 if (type == DT_TAG |
| 424 #if defined(FEAT_QUICKFIX) | |
| 845 | 425 || type == DT_LTAG |
| 692 | 426 #endif |
| 845 | 427 ) |
| 7 | 428 { |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
429 #if defined(FEAT_QUICKFIX) |
| 2713 | 430 if (g_do_tagpreview != 0) |
| 7 | 431 { |
| 432 cur_match = ptag_entry.cur_match; | |
| 433 cur_fnum = ptag_entry.cur_fnum; | |
| 434 } | |
| 435 else | |
| 436 #endif | |
| 437 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
438 // ":tag" (no argument): go to newer pattern |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
439 save_pos = TRUE; // save the cursor position below |
| 7 | 440 if ((tagstackidx += count - 1) >= tagstacklen) |
| 441 { | |
| 442 /* | |
| 443 * Beyond the last one, just give an error message and | |
| 444 * go to the last one. Don't store the cursor | |
| 1204 | 445 * position. |
| 7 | 446 */ |
| 447 tagstackidx = tagstacklen - 1; | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
448 emsg(_(topmsg)); |
| 7 | 449 save_pos = FALSE; |
| 450 } | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
451 else if (tagstackidx < 0) // must have been count == 0 |
| 7 | 452 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
453 emsg(_(bottommsg)); |
| 7 | 454 tagstackidx = 0; |
| 455 goto end_do_tag; | |
| 456 } | |
| 457 cur_match = tagstack[tagstackidx].cur_match; | |
| 458 cur_fnum = tagstack[tagstackidx].cur_fnum; | |
| 459 } | |
| 460 new_tag = TRUE; | |
| 461 } | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
462 else // go to other matching tag |
| 7 | 463 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
464 // Save index for when selection is cancelled. |
| 7 | 465 prevtagstackidx = tagstackidx; |
| 466 | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
467 #if defined(FEAT_QUICKFIX) |
| 2713 | 468 if (g_do_tagpreview != 0) |
| 7 | 469 { |
| 470 cur_match = ptag_entry.cur_match; | |
| 471 cur_fnum = ptag_entry.cur_fnum; | |
| 472 } | |
| 473 else | |
| 474 #endif | |
| 475 { | |
| 476 if (--tagstackidx < 0) | |
| 477 tagstackidx = 0; | |
| 478 cur_match = tagstack[tagstackidx].cur_match; | |
| 479 cur_fnum = tagstack[tagstackidx].cur_fnum; | |
| 480 } | |
| 481 switch (type) | |
| 482 { | |
| 483 case DT_FIRST: cur_match = count - 1; break; | |
| 484 case DT_SELECT: | |
| 485 case DT_JUMP: | |
| 486 #ifdef FEAT_CSCOPE | |
| 487 case DT_CSCOPE: | |
| 488 #endif | |
| 489 case DT_LAST: cur_match = MAXCOL - 1; break; | |
| 490 case DT_NEXT: cur_match += count; break; | |
| 491 case DT_PREV: cur_match -= count; break; | |
| 492 } | |
| 493 if (cur_match >= MAXCOL) | |
| 494 cur_match = MAXCOL - 1; | |
| 495 else if (cur_match < 0) | |
| 496 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
497 emsg(_("E425: Cannot go before first matching tag")); |
| 7 | 498 skip_msg = TRUE; |
| 499 cur_match = 0; | |
| 500 cur_fnum = curbuf->b_fnum; | |
| 501 } | |
| 502 } | |
| 503 } | |
| 504 | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
505 #if defined(FEAT_QUICKFIX) |
| 2713 | 506 if (g_do_tagpreview != 0) |
| 7 | 507 { |
| 508 if (type != DT_SELECT && type != DT_JUMP) | |
| 509 { | |
| 510 ptag_entry.cur_match = cur_match; | |
| 511 ptag_entry.cur_fnum = cur_fnum; | |
| 512 } | |
| 513 } | |
| 514 else | |
| 515 #endif | |
| 516 { | |
| 517 /* | |
| 518 * For ":tag [arg]" or ":tselect" remember position before the jump. | |
| 519 */ | |
| 520 saved_fmark = tagstack[tagstackidx].fmark; | |
| 521 if (save_pos) | |
| 522 { | |
| 523 tagstack[tagstackidx].fmark.mark = curwin->w_cursor; | |
| 524 tagstack[tagstackidx].fmark.fnum = curbuf->b_fnum; | |
| 525 } | |
| 526 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
527 // Curwin will change in the call to jumpto_tag() if ":stag" was |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
528 // used or an autocommand jumps to another window; store value of |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
529 // tagstackidx now. |
| 7 | 530 curwin->w_tagstackidx = tagstackidx; |
| 531 if (type != DT_SELECT && type != DT_JUMP) | |
| 532 { | |
| 533 curwin->w_tagstack[tagstackidx].cur_match = cur_match; | |
| 534 curwin->w_tagstack[tagstackidx].cur_fnum = cur_fnum; | |
| 535 } | |
| 536 } | |
| 537 } | |
| 538 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
539 // When not using the current buffer get the name of buffer "cur_fnum". |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
540 // Makes sure that the tag order doesn't change when using a remembered |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
541 // position for "cur_match". |
| 7 | 542 if (cur_fnum != curbuf->b_fnum) |
| 543 { | |
| 544 buf_T *buf = buflist_findnr(cur_fnum); | |
| 545 | |
| 546 if (buf != NULL) | |
| 547 buf_ffname = buf->b_ffname; | |
| 548 } | |
| 549 | |
| 550 /* | |
| 551 * Repeat searching for tags, when a file has not been found. | |
| 552 */ | |
| 553 for (;;) | |
| 554 { | |
|
16188
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
555 int other_name; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
556 char_u *name; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
557 |
| 7 | 558 /* |
| 559 * When desired match not found yet, try to find it (and others). | |
| 560 */ | |
| 561 if (use_tagstack) | |
| 562 name = tagstack[tagstackidx].tagname; | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
563 #if defined(FEAT_QUICKFIX) |
| 2713 | 564 else if (g_do_tagpreview != 0) |
| 7 | 565 name = ptag_entry.tagname; |
| 566 #endif | |
| 567 else | |
| 568 name = tag; | |
| 569 other_name = (tagmatchname == NULL || STRCMP(tagmatchname, name) != 0); | |
| 570 if (new_tag | |
| 571 || (cur_match >= num_matches && max_num_matches != MAXCOL) | |
| 572 || other_name) | |
| 573 { | |
| 574 if (other_name) | |
| 575 { | |
| 576 vim_free(tagmatchname); | |
| 577 tagmatchname = vim_strsave(name); | |
| 578 } | |
| 579 | |
|
16164
213b88f89597
patch 8.1.1087: tag stack is incorrect after CTRL-T and then :tag
Bram Moolenaar <Bram@vim.org>
parents:
16142
diff
changeset
|
580 if (type == DT_SELECT || type == DT_JUMP |
| 692 | 581 #if defined(FEAT_QUICKFIX) |
| 582 || type == DT_LTAG | |
| 583 #endif | |
| 584 ) | |
| 7 | 585 cur_match = MAXCOL - 1; |
|
16164
213b88f89597
patch 8.1.1087: tag stack is incorrect after CTRL-T and then :tag
Bram Moolenaar <Bram@vim.org>
parents:
16142
diff
changeset
|
586 if (type == DT_TAG) |
|
213b88f89597
patch 8.1.1087: tag stack is incorrect after CTRL-T and then :tag
Bram Moolenaar <Bram@vim.org>
parents:
16142
diff
changeset
|
587 max_num_matches = MAXCOL; |
|
213b88f89597
patch 8.1.1087: tag stack is incorrect after CTRL-T and then :tag
Bram Moolenaar <Bram@vim.org>
parents:
16142
diff
changeset
|
588 else |
|
213b88f89597
patch 8.1.1087: tag stack is incorrect after CTRL-T and then :tag
Bram Moolenaar <Bram@vim.org>
parents:
16142
diff
changeset
|
589 max_num_matches = cur_match + 1; |
| 7 | 590 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
591 // when the argument starts with '/', use it as a regexp |
| 7 | 592 if (!no_regexp && *name == '/') |
| 593 { | |
| 594 flags = TAG_REGEXP; | |
| 595 ++name; | |
| 596 } | |
| 597 else | |
| 598 flags = TAG_NOIC; | |
| 599 | |
| 600 #ifdef FEAT_CSCOPE | |
| 601 if (type == DT_CSCOPE) | |
| 602 flags = TAG_CSCOPE; | |
| 603 #endif | |
| 604 if (verbose) | |
| 605 flags |= TAG_VERBOSE; | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
606 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
607 if (!use_tfu) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
608 flags |= TAG_NO_TAGFUNC; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
609 |
| 7 | 610 if (find_tags(name, &new_num_matches, &new_matches, flags, |
| 611 max_num_matches, buf_ffname) == OK | |
| 612 && new_num_matches < max_num_matches) | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
613 max_num_matches = MAXCOL; // If less than max_num_matches |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
614 // found: all matches found. |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
615 |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
616 // If there already were some matches for the same name, move them |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
617 // to the start. Avoids that the order changes when using |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
618 // ":tnext" and jumping to another file. |
| 7 | 619 if (!new_tag && !other_name) |
| 620 { | |
|
16188
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
621 int j, k; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
622 int idx = 0; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
623 tagptrs_T tagp, tagp2; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
624 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
625 // Find the position of each old match in the new list. Need |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
626 // to use parse_match() to find the tag line. |
| 7 | 627 for (j = 0; j < num_matches; ++j) |
| 628 { | |
| 629 parse_match(matches[j], &tagp); | |
| 630 for (i = idx; i < new_num_matches; ++i) | |
| 631 { | |
| 632 parse_match(new_matches[i], &tagp2); | |
| 633 if (STRCMP(tagp.tagname, tagp2.tagname) == 0) | |
| 634 { | |
|
16188
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
635 char_u *p = new_matches[i]; |
| 7 | 636 for (k = i; k > idx; --k) |
| 637 new_matches[k] = new_matches[k - 1]; | |
| 638 new_matches[idx++] = p; | |
| 639 break; | |
| 640 } | |
| 641 } | |
| 642 } | |
| 643 } | |
| 644 FreeWild(num_matches, matches); | |
| 645 num_matches = new_num_matches; | |
| 646 matches = new_matches; | |
| 647 } | |
| 648 | |
| 649 if (num_matches <= 0) | |
| 650 { | |
| 651 if (verbose) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
652 semsg(_("E426: tag not found: %s"), name); |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
653 #if defined(FEAT_QUICKFIX) |
| 7 | 654 g_do_tagpreview = 0; |
| 655 #endif | |
| 656 } | |
| 657 else | |
| 658 { | |
| 659 int ask_for_selection = FALSE; | |
| 660 | |
| 661 #ifdef FEAT_CSCOPE | |
| 662 if (type == DT_CSCOPE && num_matches > 1) | |
| 663 { | |
| 664 cs_print_tags(); | |
| 665 ask_for_selection = TRUE; | |
| 666 } | |
| 667 else | |
| 668 #endif | |
|
16164
213b88f89597
patch 8.1.1087: tag stack is incorrect after CTRL-T and then :tag
Bram Moolenaar <Bram@vim.org>
parents:
16142
diff
changeset
|
669 if (type == DT_TAG && *tag != NUL) |
|
16188
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
670 // If a count is supplied to the ":tag <name>" command, then |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
671 // jump to count'th matching tag. |
| 6851 | 672 cur_match = count > 0 ? count - 1 : 0; |
| 673 else if (type == DT_SELECT || (type == DT_JUMP && num_matches > 1)) | |
| 7 | 674 { |
|
16188
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
675 print_tag_list(new_tag, use_tagstack, num_matches, matches); |
| 7 | 676 ask_for_selection = TRUE; |
| 677 } | |
| 649 | 678 #if defined(FEAT_QUICKFIX) && defined(FEAT_EVAL) |
| 692 | 679 else if (type == DT_LTAG) |
| 649 | 680 { |
|
16188
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
681 if (add_llist_tags(tag, num_matches, matches) == FAIL) |
| 649 | 682 goto end_do_tag; |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
683 cur_match = 0; // Jump to the first tag |
| 649 | 684 } |
| 685 #endif | |
| 7 | 686 |
| 687 if (ask_for_selection == TRUE) | |
| 688 { | |
| 689 /* | |
| 690 * Ask to select a tag from the list. | |
| 691 */ | |
| 373 | 692 i = prompt_for_number(NULL); |
| 7 | 693 if (i <= 0 || i > num_matches || got_int) |
| 694 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
695 // no valid choice: don't change anything |
| 7 | 696 if (use_tagstack) |
| 697 { | |
| 698 tagstack[tagstackidx].fmark = saved_fmark; | |
| 699 tagstackidx = prevtagstackidx; | |
| 700 } | |
| 701 #ifdef FEAT_CSCOPE | |
| 702 cs_free_tags(); | |
| 703 jumped_to_tag = TRUE; | |
| 704 #endif | |
| 705 break; | |
| 706 } | |
| 707 cur_match = i - 1; | |
| 708 } | |
| 709 | |
| 710 if (cur_match >= num_matches) | |
| 711 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
712 // Avoid giving this error when a file wasn't found and we're |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
713 // looking for a match in another file, which wasn't found. |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
714 // There will be an emsg("file doesn't exist") below then. |
| 7 | 715 if ((type == DT_NEXT || type == DT_FIRST) |
| 716 && nofile_fname == NULL) | |
| 717 { | |
| 718 if (num_matches == 1) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
719 emsg(_("E427: There is only one matching tag")); |
| 7 | 720 else |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
721 emsg(_("E428: Cannot go beyond last matching tag")); |
| 7 | 722 skip_msg = TRUE; |
| 723 } | |
| 724 cur_match = num_matches - 1; | |
| 725 } | |
| 726 if (use_tagstack) | |
| 727 { | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
728 tagptrs_T tagp; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
729 |
| 7 | 730 tagstack[tagstackidx].cur_match = cur_match; |
| 731 tagstack[tagstackidx].cur_fnum = cur_fnum; | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
732 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
733 // store user-provided data originating from tagfunc |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
734 if (use_tfu && parse_match(matches[cur_match], &tagp) == OK |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
735 && tagp.user_data) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
736 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
737 VIM_CLEAR(tagstack[tagstackidx].user_data); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
738 tagstack[tagstackidx].user_data = vim_strnsave( |
|
21996
808edde1e97d
patch 8.2.1547: various comment problems
Bram Moolenaar <Bram@vim.org>
parents:
20384
diff
changeset
|
739 tagp.user_data, tagp.user_data_end - tagp.user_data); |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
740 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
741 |
| 7 | 742 ++tagstackidx; |
| 743 } | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
744 #if defined(FEAT_QUICKFIX) |
| 2713 | 745 else if (g_do_tagpreview != 0) |
| 7 | 746 { |
| 747 ptag_entry.cur_match = cur_match; | |
| 748 ptag_entry.cur_fnum = cur_fnum; | |
| 749 } | |
| 750 #endif | |
| 751 | |
| 752 /* | |
| 753 * Only when going to try the next match, report that the previous | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
754 * file didn't exist. Otherwise an emsg() is given below. |
| 7 | 755 */ |
| 756 if (nofile_fname != NULL && error_cur_match != cur_match) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
757 smsg(_("File \"%s\" does not exist"), nofile_fname); |
| 7 | 758 |
| 759 | |
| 760 ic = (matches[cur_match][0] & MT_IC_OFF); | |
| 6851 | 761 if (type != DT_TAG && type != DT_SELECT && type != DT_JUMP |
| 7 | 762 #ifdef FEAT_CSCOPE |
| 763 && type != DT_CSCOPE | |
| 764 #endif | |
| 765 && (num_matches > 1 || ic) | |
| 766 && !skip_msg) | |
| 767 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
768 // Give an indication of the number of matching tags |
| 7 | 769 sprintf((char *)IObuff, _("tag %d of %d%s"), |
| 770 cur_match + 1, | |
| 771 num_matches, | |
| 772 max_num_matches != MAXCOL ? _(" or more") : ""); | |
| 773 if (ic) | |
| 774 STRCAT(IObuff, _(" Using tag with different case!")); | |
| 775 if ((num_matches > prev_num_matches || new_tag) | |
| 776 && num_matches > 1) | |
| 777 { | |
| 778 if (ic) | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
779 msg_attr((char *)IObuff, HL_ATTR(HLF_W)); |
| 7 | 780 else |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
781 msg((char *)IObuff); |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
782 msg_scroll = TRUE; // don't overwrite this message |
| 7 | 783 } |
| 784 else | |
| 785 give_warning(IObuff, ic); | |
| 786 if (ic && !msg_scrolled && msg_silent == 0) | |
| 787 { | |
| 788 out_flush(); | |
|
18642
bbea1f108187
patch 8.1.2313: debugging where a delay comes from is not easy
Bram Moolenaar <Bram@vim.org>
parents:
18640
diff
changeset
|
789 ui_delay(1007L, TRUE); |
| 7 | 790 } |
| 791 } | |
| 792 | |
|
13380
69517d67421f
patch 8.0.1564: too many #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
793 #if defined(FEAT_EVAL) |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
794 // Let the SwapExists event know what tag we are jumping to. |
| 589 | 795 vim_snprintf((char *)IObuff, IOSIZE, ":ta %s\r", name); |
| 796 set_vim_var_string(VV_SWAPCOMMAND, IObuff, -1); | |
| 797 #endif | |
| 798 | |
| 7 | 799 /* |
| 800 * Jump to the desired match. | |
| 801 */ | |
| 589 | 802 i = jumpto_tag(matches[cur_match], forceit, type != DT_CSCOPE); |
| 803 | |
|
13380
69517d67421f
patch 8.0.1564: too many #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
804 #if defined(FEAT_EVAL) |
| 589 | 805 set_vim_var_string(VV_SWAPCOMMAND, NULL, -1); |
| 806 #endif | |
| 807 | |
| 808 if (i == NOTAGFILE) | |
| 7 | 809 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
810 // File not found: try again with another matching tag |
| 7 | 811 if ((type == DT_PREV && cur_match > 0) |
| 812 || ((type == DT_TAG || type == DT_NEXT | |
| 813 || type == DT_FIRST) | |
| 814 && (max_num_matches != MAXCOL | |
| 815 || cur_match < num_matches - 1))) | |
| 816 { | |
| 817 error_cur_match = cur_match; | |
| 818 if (use_tagstack) | |
| 819 --tagstackidx; | |
| 820 if (type == DT_PREV) | |
| 821 --cur_match; | |
| 822 else | |
| 823 { | |
| 824 type = DT_NEXT; | |
| 825 ++cur_match; | |
| 826 } | |
| 827 continue; | |
| 828 } | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
829 semsg(_("E429: File \"%s\" does not exist"), nofile_fname); |
| 7 | 830 } |
| 831 else | |
| 832 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
833 // We may have jumped to another window, check that |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
834 // tagstackidx is still valid. |
| 7 | 835 if (use_tagstack && tagstackidx > curwin->w_tagstacklen) |
| 836 tagstackidx = curwin->w_tagstackidx; | |
| 837 #ifdef FEAT_CSCOPE | |
| 838 jumped_to_tag = TRUE; | |
| 839 #endif | |
| 840 } | |
| 841 } | |
| 842 break; | |
| 843 } | |
| 844 | |
| 845 end_do_tag: | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
846 // Only store the new index when using the tagstack and it's valid. |
| 7 | 847 if (use_tagstack && tagstackidx <= curwin->w_tagstacklen) |
| 848 curwin->w_tagstackidx = tagstackidx; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
849 postponed_split = 0; // don't split next time |
|
9949
30be4b26a37e
commit https://github.com/vim/vim/commit/358308dd99abdd56c6540339e505585d8db7bdfe
Christian Brabandt <cb@256bit.org>
parents:
9913
diff
changeset
|
850 # ifdef FEAT_QUICKFIX |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
851 g_do_tagpreview = 0; // don't do tag preview next time |
|
9949
30be4b26a37e
commit https://github.com/vim/vim/commit/358308dd99abdd56c6540339e505585d8db7bdfe
Christian Brabandt <cb@256bit.org>
parents:
9913
diff
changeset
|
852 # endif |
| 7 | 853 |
| 854 #ifdef FEAT_CSCOPE | |
| 855 return jumped_to_tag; | |
| 856 #else | |
| 857 return FALSE; | |
| 858 #endif | |
| 859 } | |
| 860 | |
| 861 /* | |
|
16188
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
862 * List all the matching tags. |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
863 */ |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
864 static void |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
865 print_tag_list( |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
866 int new_tag, |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
867 int use_tagstack, |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
868 int num_matches, |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
869 char_u **matches) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
870 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
871 taggy_T *tagstack = curwin->w_tagstack; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
872 int tagstackidx = curwin->w_tagstackidx; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
873 int i; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
874 char_u *p; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
875 char_u *command_end; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
876 tagptrs_T tagp; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
877 int taglen; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
878 int attr; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
879 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
880 /* |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
881 * Assume that the first match indicates how long the tags can |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
882 * be, and align the file names to that. |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
883 */ |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
884 parse_match(matches[0], &tagp); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
885 taglen = (int)(tagp.tagname_end - tagp.tagname + 2); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
886 if (taglen < 18) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
887 taglen = 18; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
888 if (taglen > Columns - 25) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
889 taglen = MAXCOL; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
890 if (msg_col == 0) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
891 msg_didout = FALSE; // overwrite previous message |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
892 msg_start(); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
893 msg_puts_attr(_(" # pri kind tag"), HL_ATTR(HLF_T)); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
894 msg_clr_eos(); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
895 taglen_advance(taglen); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
896 msg_puts_attr(_("file\n"), HL_ATTR(HLF_T)); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
897 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
898 for (i = 0; i < num_matches && !got_int; ++i) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
899 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
900 parse_match(matches[i], &tagp); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
901 if (!new_tag && ( |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
902 #if defined(FEAT_QUICKFIX) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
903 (g_do_tagpreview != 0 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
904 && i == ptag_entry.cur_match) || |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
905 #endif |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
906 (use_tagstack |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
907 && i == tagstack[tagstackidx].cur_match))) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
908 *IObuff = '>'; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
909 else |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
910 *IObuff = ' '; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
911 vim_snprintf((char *)IObuff + 1, IOSIZE - 1, |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
912 "%2d %s ", i + 1, |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
913 mt_names[matches[i][0] & MT_MASK]); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
914 msg_puts((char *)IObuff); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
915 if (tagp.tagkind != NULL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
916 msg_outtrans_len(tagp.tagkind, |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
917 (int)(tagp.tagkind_end - tagp.tagkind)); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
918 msg_advance(13); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
919 msg_outtrans_len_attr(tagp.tagname, |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
920 (int)(tagp.tagname_end - tagp.tagname), |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
921 HL_ATTR(HLF_T)); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
922 msg_putchar(' '); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
923 taglen_advance(taglen); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
924 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
925 // Find out the actual file name. If it is long, truncate |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
926 // it and put "..." in the middle |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
927 p = tag_full_fname(&tagp); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
928 if (p != NULL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
929 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
930 msg_outtrans_long_attr(p, HL_ATTR(HLF_D)); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
931 vim_free(p); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
932 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
933 if (msg_col > 0) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
934 msg_putchar('\n'); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
935 if (got_int) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
936 break; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
937 msg_advance(15); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
938 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
939 // print any extra fields |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
940 command_end = tagp.command_end; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
941 if (command_end != NULL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
942 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
943 p = command_end + 3; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
944 while (*p && *p != '\r' && *p != '\n') |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
945 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
946 while (*p == TAB) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
947 ++p; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
948 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
949 // skip "file:" without a value (static tag) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
950 if (STRNCMP(p, "file:", 5) == 0 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
951 && vim_isspace(p[5])) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
952 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
953 p += 5; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
954 continue; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
955 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
956 // skip "kind:<kind>" and "<kind>" |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
957 if (p == tagp.tagkind |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
958 || (p + 5 == tagp.tagkind |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
959 && STRNCMP(p, "kind:", 5) == 0)) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
960 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
961 p = tagp.tagkind_end; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
962 continue; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
963 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
964 // print all other extra fields |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
965 attr = HL_ATTR(HLF_CM); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
966 while (*p && *p != '\r' && *p != '\n') |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
967 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
968 if (msg_col + ptr2cells(p) >= Columns) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
969 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
970 msg_putchar('\n'); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
971 if (got_int) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
972 break; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
973 msg_advance(15); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
974 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
975 p = msg_outtrans_one(p, attr); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
976 if (*p == TAB) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
977 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
978 msg_puts_attr(" ", attr); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
979 break; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
980 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
981 if (*p == ':') |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
982 attr = 0; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
983 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
984 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
985 if (msg_col > 15) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
986 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
987 msg_putchar('\n'); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
988 if (got_int) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
989 break; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
990 msg_advance(15); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
991 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
992 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
993 else |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
994 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
995 for (p = tagp.command; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
996 *p && *p != '\r' && *p != '\n'; ++p) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
997 ; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
998 command_end = p; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
999 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1000 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1001 // Put the info (in several lines) at column 15. |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1002 // Don't display "/^" and "?^". |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1003 p = tagp.command; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1004 if (*p == '/' || *p == '?') |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1005 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1006 ++p; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1007 if (*p == '^') |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1008 ++p; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1009 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1010 // Remove leading whitespace from pattern |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1011 while (p != command_end && vim_isspace(*p)) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1012 ++p; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1013 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1014 while (p != command_end) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1015 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1016 if (msg_col + (*p == TAB ? 1 : ptr2cells(p)) > Columns) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1017 msg_putchar('\n'); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1018 if (got_int) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1019 break; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1020 msg_advance(15); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1021 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1022 // skip backslash used for escaping a command char or |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1023 // a backslash |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1024 if (*p == '\\' && (*(p + 1) == *tagp.command |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1025 || *(p + 1) == '\\')) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1026 ++p; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1027 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1028 if (*p == TAB) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1029 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1030 msg_putchar(' '); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1031 ++p; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1032 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1033 else |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1034 p = msg_outtrans_one(p, 0); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1035 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1036 // don't display the "$/;\"" and "$?;\"" |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1037 if (p == command_end - 2 && *p == '$' |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1038 && *(p + 1) == *tagp.command) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1039 break; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1040 // don't display matching '/' or '?' |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1041 if (p == command_end - 1 && *p == *tagp.command |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1042 && (*p == '/' || *p == '?')) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1043 break; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1044 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1045 if (msg_col) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1046 msg_putchar('\n'); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1047 ui_breakcheck(); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1048 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1049 if (got_int) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1050 got_int = FALSE; // only stop the listing |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1051 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1052 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1053 #if defined(FEAT_QUICKFIX) && defined(FEAT_EVAL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1054 /* |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1055 * Add the matching tags to the location list for the current |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1056 * window. |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1057 */ |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1058 static int |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1059 add_llist_tags( |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1060 char_u *tag, |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1061 int num_matches, |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1062 char_u **matches) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1063 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1064 list_T *list; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1065 char_u tag_name[128 + 1]; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1066 char_u *fname; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1067 char_u *cmd; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1068 int i; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1069 char_u *p; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1070 tagptrs_T tagp; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1071 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1072 fname = alloc(MAXPATHL + 1); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1073 cmd = alloc(CMDBUFFSIZE + 1); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1074 list = list_alloc(); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1075 if (list == NULL || fname == NULL || cmd == NULL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1076 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1077 vim_free(cmd); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1078 vim_free(fname); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1079 if (list != NULL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1080 list_free(list); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1081 return FAIL; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1082 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1083 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1084 for (i = 0; i < num_matches; ++i) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1085 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1086 int len, cmd_len; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1087 long lnum; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1088 dict_T *dict; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1089 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1090 parse_match(matches[i], &tagp); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1091 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1092 // Save the tag name |
|
16188
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1093 len = (int)(tagp.tagname_end - tagp.tagname); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1094 if (len > 128) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1095 len = 128; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1096 vim_strncpy(tag_name, tagp.tagname, len); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1097 tag_name[len] = NUL; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1098 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1099 // Save the tag file name |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1100 p = tag_full_fname(&tagp); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1101 if (p == NULL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1102 continue; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1103 vim_strncpy(fname, p, MAXPATHL); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1104 vim_free(p); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1105 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1106 // Get the line number or the search pattern used to locate |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1107 // the tag. |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1108 lnum = 0; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1109 if (isdigit(*tagp.command)) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1110 // Line number is used to locate the tag |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1111 lnum = atol((char *)tagp.command); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1112 else |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1113 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1114 char_u *cmd_start, *cmd_end; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1115 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1116 // Search pattern is used to locate the tag |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1117 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1118 // Locate the end of the command |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1119 cmd_start = tagp.command; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1120 cmd_end = tagp.command_end; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1121 if (cmd_end == NULL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1122 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1123 for (p = tagp.command; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1124 *p && *p != '\r' && *p != '\n'; ++p) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1125 ; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1126 cmd_end = p; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1127 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1128 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1129 // Now, cmd_end points to the character after the |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1130 // command. Adjust it to point to the last |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1131 // character of the command. |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1132 cmd_end--; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1133 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1134 // Skip the '/' and '?' characters at the |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1135 // beginning and end of the search pattern. |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1136 if (*cmd_start == '/' || *cmd_start == '?') |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1137 cmd_start++; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1138 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1139 if (*cmd_end == '/' || *cmd_end == '?') |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1140 cmd_end--; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1141 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1142 len = 0; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1143 cmd[0] = NUL; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1144 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1145 // If "^" is present in the tag search pattern, then |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1146 // copy it first. |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1147 if (*cmd_start == '^') |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1148 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1149 STRCPY(cmd, "^"); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1150 cmd_start++; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1151 len++; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1152 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1153 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1154 // Precede the tag pattern with \V to make it very |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1155 // nomagic. |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1156 STRCAT(cmd, "\\V"); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1157 len += 2; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1158 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1159 cmd_len = (int)(cmd_end - cmd_start + 1); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1160 if (cmd_len > (CMDBUFFSIZE - 5)) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1161 cmd_len = CMDBUFFSIZE - 5; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1162 STRNCAT(cmd, cmd_start, cmd_len); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1163 len += cmd_len; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1164 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1165 if (cmd[len - 1] == '$') |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1166 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1167 // Replace '$' at the end of the search pattern |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1168 // with '\$' |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1169 cmd[len - 1] = '\\'; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1170 cmd[len] = '$'; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1171 len++; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1172 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1173 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1174 cmd[len] = NUL; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1175 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1176 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1177 if ((dict = dict_alloc()) == NULL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1178 continue; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1179 if (list_append_dict(list, dict) == FAIL) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1180 { |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1181 vim_free(dict); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1182 continue; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1183 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1184 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1185 dict_add_string(dict, "text", tag_name); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1186 dict_add_string(dict, "filename", fname); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1187 dict_add_number(dict, "lnum", lnum); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1188 if (lnum == 0) |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1189 dict_add_string(dict, "pattern", cmd); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1190 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1191 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1192 vim_snprintf((char *)IObuff, IOSIZE, "ltag %s", tag); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1193 set_errorlist(curwin, list, ' ', IObuff, NULL); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1194 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1195 list_free(list); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1196 vim_free(fname); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1197 vim_free(cmd); |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1198 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1199 return OK; |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1200 } |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1201 #endif |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1202 |
|
848d4c6e391e
patch 8.1.1099: the do_tag() function is too long
Bram Moolenaar <Bram@vim.org>
parents:
16178
diff
changeset
|
1203 /* |
| 7 | 1204 * Free cached tags. |
| 1205 */ | |
| 1206 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1207 tag_freematch(void) |
| 7 | 1208 { |
|
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
13227
diff
changeset
|
1209 VIM_CLEAR(tagmatchname); |
| 7 | 1210 } |
| 1211 | |
| 1212 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1213 taglen_advance(int l) |
| 7 | 1214 { |
| 1215 if (l == MAXCOL) | |
| 1216 { | |
| 1217 msg_putchar('\n'); | |
| 1218 msg_advance(24); | |
| 1219 } | |
| 1220 else | |
| 1221 msg_advance(13 + l); | |
| 1222 } | |
| 1223 | |
| 1224 /* | |
| 1225 * Print the tag stack | |
| 1226 */ | |
| 1227 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1228 do_tags(exarg_T *eap UNUSED) |
| 7 | 1229 { |
| 1230 int i; | |
| 1231 char_u *name; | |
| 1232 taggy_T *tagstack = curwin->w_tagstack; | |
| 1233 int tagstackidx = curwin->w_tagstackidx; | |
| 1234 int tagstacklen = curwin->w_tagstacklen; | |
| 1235 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1236 // Highlight title |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1237 msg_puts_title(_("\n # TO tag FROM line in file/text")); |
| 7 | 1238 for (i = 0; i < tagstacklen; ++i) |
| 1239 { | |
| 1240 if (tagstack[i].tagname != NULL) | |
| 1241 { | |
| 1242 name = fm_getname(&(tagstack[i].fmark), 30); | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1243 if (name == NULL) // file name not available |
| 7 | 1244 continue; |
| 1245 | |
| 1246 msg_putchar('\n'); | |
|
13068
63fdea6e9c6c
patch 8.0.1409: buffer overflow in :tags command
Christian Brabandt <cb@256bit.org>
parents:
12680
diff
changeset
|
1247 vim_snprintf((char *)IObuff, IOSIZE, "%c%2d %2d %-15s %5ld ", |
| 7 | 1248 i == tagstackidx ? '>' : ' ', |
| 1249 i + 1, | |
| 1250 tagstack[i].cur_match + 1, | |
| 1251 tagstack[i].tagname, | |
| 1252 tagstack[i].fmark.mark.lnum); | |
| 1253 msg_outtrans(IObuff); | |
| 1254 msg_outtrans_attr(name, tagstack[i].fmark.fnum == curbuf->b_fnum | |
|
11158
501f46f7644c
patch 8.0.0466: still macros that should be all-caps
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
1255 ? HL_ATTR(HLF_D) : 0); |
| 7 | 1256 vim_free(name); |
| 1257 } | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1258 out_flush(); // show one line at a time |
| 7 | 1259 } |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1260 if (tagstackidx == tagstacklen) // idx at top of stack |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1261 msg_puts("\n>"); |
| 7 | 1262 } |
| 1263 | |
| 1264 #ifdef FEAT_TAG_BINS | |
| 1265 /* | |
| 1266 * Compare two strings, for length "len", ignoring case the ASCII way. | |
| 1267 * return 0 for match, < 0 for smaller, > 0 for bigger | |
| 1268 * Make sure case is folded to uppercase in comparison (like for 'sort -f') | |
| 1269 */ | |
| 1270 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1271 tag_strnicmp(char_u *s1, char_u *s2, size_t len) |
| 7 | 1272 { |
| 1273 int i; | |
| 1274 | |
| 1275 while (len > 0) | |
| 1276 { | |
| 1277 i = (int)TOUPPER_ASC(*s1) - (int)TOUPPER_ASC(*s2); | |
| 1278 if (i != 0) | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1279 return i; // this character different |
| 7 | 1280 if (*s1 == NUL) |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1281 break; // strings match until NUL |
| 7 | 1282 ++s1; |
| 1283 ++s2; | |
| 1284 --len; | |
| 1285 } | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1286 return 0; // strings match |
| 7 | 1287 } |
| 1288 #endif | |
| 1289 | |
| 1290 /* | |
| 1291 * Structure to hold info about the tag pattern being used. | |
| 1292 */ | |
| 1293 typedef struct | |
| 1294 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1295 char_u *pat; // the pattern |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1296 int len; // length of pat[] |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1297 char_u *head; // start of pattern head |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1298 int headlen; // length of head[] |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1299 regmatch_T regmatch; // regexp program, may be NULL |
| 7 | 1300 } pat_T; |
| 1301 | |
| 1302 /* | |
| 1303 * Extract info from the tag search pattern "pats->pat". | |
| 1304 */ | |
| 1305 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1306 prepare_pats(pat_T *pats, int has_re) |
| 7 | 1307 { |
| 1308 pats->head = pats->pat; | |
| 1309 pats->headlen = pats->len; | |
| 1310 if (has_re) | |
| 1311 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1312 // When the pattern starts with '^' or "\\<", binary searching can be |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1313 // used (much faster). |
| 7 | 1314 if (pats->pat[0] == '^') |
| 1315 pats->head = pats->pat + 1; | |
| 1316 else if (pats->pat[0] == '\\' && pats->pat[1] == '<') | |
| 1317 pats->head = pats->pat + 2; | |
| 1318 if (pats->head == pats->pat) | |
| 1319 pats->headlen = 0; | |
| 1320 else | |
| 1321 for (pats->headlen = 0; pats->head[pats->headlen] != NUL; | |
| 1322 ++pats->headlen) | |
|
23272
a84e7abb0c92
patch 8.2.2182: Vim9: value of 'magic' is still relevant
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1323 if (vim_strchr((char_u *)(magic_isset() ? ".[~*\\$" : "\\$"), |
| 7 | 1324 pats->head[pats->headlen]) != NULL) |
| 1325 break; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1326 if (p_tl != 0 && pats->headlen > p_tl) // adjust for 'taglength' |
| 7 | 1327 pats->headlen = p_tl; |
| 1328 } | |
| 1329 | |
| 1330 if (has_re) | |
|
23272
a84e7abb0c92
patch 8.2.2182: Vim9: value of 'magic' is still relevant
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1331 pats->regmatch.regprog = vim_regcomp(pats->pat, |
|
a84e7abb0c92
patch 8.2.2182: Vim9: value of 'magic' is still relevant
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1332 magic_isset() ? RE_MAGIC : 0); |
| 7 | 1333 else |
| 1334 pats->regmatch.regprog = NULL; | |
| 1335 } | |
| 1336 | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1337 #ifdef FEAT_EVAL |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1338 /* |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1339 * Call the user-defined function to generate a list of tags used by |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1340 * find_tags(). |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1341 * |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1342 * Return OK if at least 1 tag has been successfully found, |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1343 * NOTDONE if the function returns v:null, and FAIL otherwise. |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1344 */ |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1345 static int |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1346 find_tagfunc_tags( |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1347 char_u *pat, // pattern supplied to the user-defined function |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1348 garray_T *ga, // the tags will be placed here |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1349 int *match_count, // here the number of tags found will be placed |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1350 int flags, // flags from find_tags (TAG_*) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1351 char_u *buf_ffname) // name of buffer for priority |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1352 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1353 pos_T save_pos; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1354 list_T *taglist; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1355 listitem_T *item; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1356 int ntags = 0; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1357 int result = FAIL; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1358 typval_T args[4]; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1359 typval_T rettv; |
|
24186
4902263c302e
patch 8.2.2634: 'tagfunc' does not indicate using a pattern
Bram Moolenaar <Bram@vim.org>
parents:
24053
diff
changeset
|
1360 char_u flagString[4]; |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1361 dict_T *d; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1362 taggy_T *tag = &curwin->w_tagstack[curwin->w_tagstackidx]; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1363 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1364 if (*curbuf->b_p_tfu == NUL) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1365 return FAIL; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1366 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1367 args[0].v_type = VAR_STRING; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1368 args[0].vval.v_string = pat; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1369 args[1].v_type = VAR_STRING; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1370 args[1].vval.v_string = flagString; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1371 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1372 // create 'info' dict argument |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1373 if ((d = dict_alloc_lock(VAR_FIXED)) == NULL) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1374 return FAIL; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1375 if (tag->user_data != NULL) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1376 dict_add_string(d, "user_data", tag->user_data); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1377 if (buf_ffname != NULL) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1378 dict_add_string(d, "buf_ffname", buf_ffname); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1379 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1380 ++d->dv_refcount; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1381 args[2].v_type = VAR_DICT; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1382 args[2].vval.v_dict = d; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1383 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1384 args[3].v_type = VAR_UNKNOWN; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1385 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1386 vim_snprintf((char *)flagString, sizeof(flagString), |
|
24186
4902263c302e
patch 8.2.2634: 'tagfunc' does not indicate using a pattern
Bram Moolenaar <Bram@vim.org>
parents:
24053
diff
changeset
|
1387 "%s%s%s", |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1388 g_tag_at_cursor ? "c": "", |
|
24186
4902263c302e
patch 8.2.2634: 'tagfunc' does not indicate using a pattern
Bram Moolenaar <Bram@vim.org>
parents:
24053
diff
changeset
|
1389 flags & TAG_INS_COMP ? "i": "", |
|
4902263c302e
patch 8.2.2634: 'tagfunc' does not indicate using a pattern
Bram Moolenaar <Bram@vim.org>
parents:
24053
diff
changeset
|
1390 flags & TAG_REGEXP ? "r": ""); |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1391 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1392 save_pos = curwin->w_cursor; |
|
26268
3aa48d4e3dc8
patch 8.2.3665: cannot use a lambda for 'tagfunc'
Bram Moolenaar <Bram@vim.org>
parents:
25852
diff
changeset
|
1393 result = call_callback(&curbuf->b_tfu_cb, 0, &rettv, 3, args); |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1394 curwin->w_cursor = save_pos; // restore the cursor position |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1395 --d->dv_refcount; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1396 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1397 if (result == FAIL) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1398 return FAIL; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1399 if (rettv.v_type == VAR_SPECIAL && rettv.vval.v_number == VVAL_NULL) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1400 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1401 clear_tv(&rettv); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1402 return NOTDONE; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1403 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1404 if (rettv.v_type != VAR_LIST || !rettv.vval.v_list) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1405 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1406 clear_tv(&rettv); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1407 emsg(_(tfu_inv_ret_msg)); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1408 return FAIL; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1409 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1410 taglist = rettv.vval.v_list; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1411 |
|
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
19617
diff
changeset
|
1412 FOR_ALL_LIST_ITEMS(taglist, item) |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1413 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1414 char_u *mfp; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1415 char_u *res_name, *res_fname, *res_cmd, *res_kind; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1416 int len; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1417 dict_iterator_T iter; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1418 char_u *dict_key; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1419 typval_T *tv; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1420 int has_extra = 0; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1421 int name_only = flags & TAG_NAMES; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1422 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1423 if (item->li_tv.v_type != VAR_DICT) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1424 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1425 emsg(_(tfu_inv_ret_msg)); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1426 break; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1427 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1428 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1429 #ifdef FEAT_EMACS_TAGS |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1430 len = 3; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1431 #else |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1432 len = 2; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1433 #endif |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1434 res_name = NULL; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1435 res_fname = NULL; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1436 res_cmd = NULL; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1437 res_kind = NULL; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1438 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1439 dict_iterate_start(&item->li_tv, &iter); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1440 while (NULL != (dict_key = dict_iterate_next(&iter, &tv))) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1441 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1442 if (tv->v_type != VAR_STRING || tv->vval.v_string == NULL) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1443 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1444 |
|
16461
826ad48af5e3
patch 8.1.1235: compiler warnings for using STRLEN() value
Bram Moolenaar <Bram@vim.org>
parents:
16447
diff
changeset
|
1445 len += (int)STRLEN(tv->vval.v_string) + 1; // Space for "\tVALUE" |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1446 if (!STRCMP(dict_key, "name")) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1447 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1448 res_name = tv->vval.v_string; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1449 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1450 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1451 if (!STRCMP(dict_key, "filename")) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1452 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1453 res_fname = tv->vval.v_string; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1454 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1455 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1456 if (!STRCMP(dict_key, "cmd")) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1457 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1458 res_cmd = tv->vval.v_string; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1459 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1460 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1461 has_extra = 1; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1462 if (!STRCMP(dict_key, "kind")) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1463 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1464 res_kind = tv->vval.v_string; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1465 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1466 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1467 // Other elements will be stored as "\tKEY:VALUE" |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1468 // Allocate space for the key and the colon |
|
16461
826ad48af5e3
patch 8.1.1235: compiler warnings for using STRLEN() value
Bram Moolenaar <Bram@vim.org>
parents:
16447
diff
changeset
|
1469 len += (int)STRLEN(dict_key) + 1; |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1470 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1471 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1472 if (has_extra) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1473 len += 2; // need space for ;" |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1474 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1475 if (!res_name || !res_fname || !res_cmd) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1476 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1477 emsg(_(tfu_inv_ret_msg)); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1478 break; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1479 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1480 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1481 if (name_only) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1482 mfp = vim_strsave(res_name); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1483 else |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
1484 mfp = alloc(sizeof(char_u) + len + 1); |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1485 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1486 if (mfp == NULL) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1487 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1488 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1489 if (!name_only) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1490 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1491 char_u *p = mfp; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1492 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1493 *p++ = MT_GL_OTH + 1; // mtt |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1494 *p++ = TAG_SEP; // no tag file name |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1495 #ifdef FEAT_EMACS_TAGS |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1496 *p++ = TAG_SEP; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1497 #endif |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1498 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1499 STRCPY(p, res_name); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1500 p += STRLEN(p); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1501 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1502 *p++ = TAB; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1503 STRCPY(p, res_fname); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1504 p += STRLEN(p); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1505 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1506 *p++ = TAB; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1507 STRCPY(p, res_cmd); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1508 p += STRLEN(p); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1509 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1510 if (has_extra) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1511 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1512 STRCPY(p, ";\""); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1513 p += STRLEN(p); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1514 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1515 if (res_kind) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1516 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1517 *p++ = TAB; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1518 STRCPY(p, res_kind); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1519 p += STRLEN(p); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1520 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1521 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1522 dict_iterate_start(&item->li_tv, &iter); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1523 while (NULL != (dict_key = dict_iterate_next(&iter, &tv))) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1524 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1525 if (tv->v_type != VAR_STRING || tv->vval.v_string == NULL) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1526 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1527 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1528 if (!STRCMP(dict_key, "name")) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1529 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1530 if (!STRCMP(dict_key, "filename")) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1531 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1532 if (!STRCMP(dict_key, "cmd")) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1533 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1534 if (!STRCMP(dict_key, "kind")) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1535 continue; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1536 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1537 *p++ = TAB; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1538 STRCPY(p, dict_key); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1539 p += STRLEN(p); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1540 STRCPY(p, ":"); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1541 p += STRLEN(p); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1542 STRCPY(p, tv->vval.v_string); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1543 p += STRLEN(p); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1544 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1545 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1546 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1547 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1548 // Add all matches because tagfunc should do filtering. |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1549 if (ga_grow(ga, 1) == OK) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1550 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1551 ((char_u **)(ga->ga_data))[ga->ga_len++] = mfp; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1552 ++ntags; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1553 result = OK; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1554 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1555 else |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1556 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1557 vim_free(mfp); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1558 break; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1559 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1560 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1561 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1562 clear_tv(&rettv); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1563 |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1564 *match_count = ntags; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1565 return result; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1566 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1567 #endif |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1568 |
| 7 | 1569 /* |
| 1570 * find_tags() - search for tags in tags files | |
| 1571 * | |
| 1572 * Return FAIL if search completely failed (*num_matches will be 0, *matchesp | |
| 1573 * will be NULL), OK otherwise. | |
| 1574 * | |
| 1575 * There is a priority in which type of tag is recognized. | |
| 1576 * | |
| 1577 * 6. A static or global tag with a full matching tag for the current file. | |
| 1578 * 5. A global tag with a full matching tag for another file. | |
| 1579 * 4. A static tag with a full matching tag for another file. | |
| 1580 * 3. A static or global tag with an ignore-case matching tag for the | |
| 1581 * current file. | |
| 1582 * 2. A global tag with an ignore-case matching tag for another file. | |
| 1583 * 1. A static tag with an ignore-case matching tag for another file. | |
| 1584 * | |
| 1585 * Tags in an emacs-style tags file are always global. | |
| 1586 * | |
| 1587 * flags: | |
| 1588 * TAG_HELP only search for help tags | |
| 1589 * TAG_NAMES only return name of tag | |
| 1590 * TAG_REGEXP use "pat" as a regexp | |
| 1591 * TAG_NOIC don't always ignore case | |
| 1592 * TAG_KEEP_LANG keep language | |
|
10666
ed6f03535745
patch 8.0.0223: Coverity warns for an uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
10654
diff
changeset
|
1593 * TAG_CSCOPE use cscope results for tags |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1594 * TAG_NO_TAGFUNC do not call the 'tagfunc' function |
| 7 | 1595 */ |
| 1596 int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1597 find_tags( |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1598 char_u *pat, // pattern to search for |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1599 int *num_matches, // return: number of matches found |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1600 char_u ***matchesp, // return: array of matches found |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1601 int flags, |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1602 int mincount, // MAXCOL: find all matches |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1603 // other: minimal number of matches |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1604 char_u *buf_ffname) // name of buffer for priority |
| 7 | 1605 { |
| 1606 FILE *fp; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1607 char_u *lbuf; // line buffer |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1608 int lbuf_size = LSIZE; // length of lbuf |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1609 char_u *tag_fname; // name of tag file |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1610 tagname_T tn; // info for get_tagfname() |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1611 int first_file; // trying first tag file |
| 7 | 1612 tagptrs_T tagp; |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1613 int did_open = FALSE; // did open a tag file |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1614 int stop_searching = FALSE; // stop when match found or error |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1615 int retval = FAIL; // return value |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1616 int is_static; // current tag line is static |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1617 int is_current; // file name matches |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1618 int eof = FALSE; // found end-of-file |
| 7 | 1619 char_u *p; |
| 1620 char_u *s; | |
| 1621 int i; | |
| 1622 #ifdef FEAT_TAG_BINS | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1623 int tag_file_sorted = NUL; // !_TAG_FILE_SORTED value |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1624 struct tag_search_info // Binary search file offsets |
| 7 | 1625 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1626 off_T low_offset; // offset for first char of first line that |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1627 // could match |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1628 off_T high_offset; // offset of char after last line that could |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1629 // match |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1630 off_T curr_offset; // Current file offset in search range |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1631 off_T curr_offset_used; // curr_offset used when skipping back |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1632 off_T match_offset; // Where the binary search found a tag |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1633 int low_char; // first char at low_offset |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1634 int high_char; // first char at high_offset |
| 7 | 1635 } search_info; |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
9068
diff
changeset
|
1636 off_T filesize; |
| 7 | 1637 int tagcmp; |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
9068
diff
changeset
|
1638 off_T offset; |
| 7 | 1639 int round; |
| 1640 #endif | |
| 1641 enum | |
| 1642 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1643 TS_START, // at start of file |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1644 TS_LINEAR // linear searching forward, till EOF |
| 7 | 1645 #ifdef FEAT_TAG_BINS |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1646 , TS_BINARY, // binary searching |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1647 TS_SKIP_BACK, // skipping backwards |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1648 TS_STEP_FORWARD // stepping forwards |
| 7 | 1649 #endif |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1650 } state; // Current search state |
| 7 | 1651 |
| 1652 int cmplen; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1653 int match; // matches |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1654 int match_no_ic = 0;// matches with rm_ic == FALSE |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1655 int match_re; // match with regexp |
| 7 | 1656 int matchoff = 0; |
| 5513 | 1657 int save_emsg_off; |
| 7 | 1658 |
| 1659 #ifdef FEAT_EMACS_TAGS | |
| 1660 /* | |
| 1661 * Stack for included emacs-tags file. | |
| 1662 * It has a fixed size, to truncate cyclic includes. jw | |
| 1663 */ | |
| 1664 # define INCSTACK_SIZE 42 | |
| 1665 struct | |
| 1666 { | |
| 1667 FILE *fp; | |
| 1668 char_u *etag_fname; | |
| 1669 } incstack[INCSTACK_SIZE]; | |
| 1670 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1671 int incstack_idx = 0; // index in incstack |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1672 char_u *ebuf; // additional buffer for etag fname |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1673 int is_etag; // current file is emaces style |
| 7 | 1674 #endif |
| 1675 | |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
1676 char_u *mfp; |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1677 garray_T ga_match[MT_COUNT]; // stores matches in sequence |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1678 hashtab_T ht_match[MT_COUNT]; // stores matches by key |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
1679 hash_T hash = 0; |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1680 int match_count = 0; // number of matches found |
| 7 | 1681 char_u **matches; |
| 1682 int mtt; | |
| 1683 int help_save; | |
| 1684 #ifdef FEAT_MULTI_LANG | |
| 1685 int help_pri = 0; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1686 char_u *help_lang_find = NULL; // lang to be found |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1687 char_u help_lang[3]; // lang of current tags file |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1688 char_u *saved_pat = NULL; // copy of pat[] |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1689 int is_txt = FALSE; // flag of file extension |
| 7 | 1690 #endif |
| 1691 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1692 pat_T orgpat; // holds unconverted pattern info |
| 7 | 1693 vimconv_T vimconv; |
| 1694 | |
| 1695 #ifdef FEAT_TAG_BINS | |
| 1696 int findall = (mincount == MAXCOL || mincount == TAG_MANY); | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1697 // find all matching tags |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1698 int sort_error = FALSE; // tags file not sorted |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1699 int linear; // do a linear search |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1700 int sortic = FALSE; // tag file sorted in nocase |
| 7 | 1701 #endif |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1702 int line_error = FALSE; // syntax error |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1703 int has_re = (flags & TAG_REGEXP); // regexp used |
| 7 | 1704 int help_only = (flags & TAG_HELP); |
| 1705 int name_only = (flags & TAG_NAMES); | |
| 1706 int noic = (flags & TAG_NOIC); | |
| 1707 int get_it_again = FALSE; | |
| 1708 #ifdef FEAT_CSCOPE | |
| 1709 int use_cscope = (flags & TAG_CSCOPE); | |
| 1710 #endif | |
| 1711 int verbose = (flags & TAG_VERBOSE); | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1712 #ifdef FEAT_EVAL |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1713 int use_tfu = ((flags & TAG_NO_TAGFUNC) == 0); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1714 #endif |
|
7266
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
1715 int save_p_ic = p_ic; |
|
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
1716 |
|
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
1717 /* |
|
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
1718 * Change the value of 'ignorecase' according to 'tagcase' for the |
|
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
1719 * duration of this function. |
|
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
1720 */ |
|
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
1721 switch (curbuf->b_tc_flags ? curbuf->b_tc_flags : tc_flags) |
|
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
1722 { |
|
10444
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1723 case TC_FOLLOWIC: break; |
|
9913
bb00c661b3a4
commit https://github.com/vim/vim/commit/66e29d7112e437b2b50efe1f82c7e892736d23e4
Christian Brabandt <cb@256bit.org>
parents:
9850
diff
changeset
|
1724 case TC_IGNORE: p_ic = TRUE; break; |
|
bb00c661b3a4
commit https://github.com/vim/vim/commit/66e29d7112e437b2b50efe1f82c7e892736d23e4
Christian Brabandt <cb@256bit.org>
parents:
9850
diff
changeset
|
1725 case TC_MATCH: p_ic = FALSE; break; |
|
bb00c661b3a4
commit https://github.com/vim/vim/commit/66e29d7112e437b2b50efe1f82c7e892736d23e4
Christian Brabandt <cb@256bit.org>
parents:
9850
diff
changeset
|
1726 case TC_FOLLOWSCS: p_ic = ignorecase(pat); break; |
|
bb00c661b3a4
commit https://github.com/vim/vim/commit/66e29d7112e437b2b50efe1f82c7e892736d23e4
Christian Brabandt <cb@256bit.org>
parents:
9850
diff
changeset
|
1727 case TC_SMART: p_ic = ignorecase_opt(pat, TRUE, TRUE); break; |
|
7266
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
1728 } |
| 7 | 1729 |
| 1730 help_save = curbuf->b_help; | |
| 1731 orgpat.pat = pat; | |
|
25587
35562f3207d1
patch 8.2.3330: Coverity reports using uninitialized field
Bram Moolenaar <Bram@vim.org>
parents:
25262
diff
changeset
|
1732 orgpat.regmatch.regprog = NULL; |
| 7 | 1733 vimconv.vc_type = CONV_NONE; |
| 1734 | |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
1735 /* |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
1736 * Allocate memory for the buffers that are used |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
1737 */ |
| 3131 | 1738 lbuf = alloc(lbuf_size); |
| 7 | 1739 tag_fname = alloc(MAXPATHL + 1); |
| 1740 #ifdef FEAT_EMACS_TAGS | |
| 1741 ebuf = alloc(LSIZE); | |
| 1742 #endif | |
| 1743 for (mtt = 0; mtt < MT_COUNT; ++mtt) | |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
1744 { |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
1745 ga_init2(&ga_match[mtt], (int)sizeof(char_u *), 100); |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
1746 hash_init(&ht_match[mtt]); |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
1747 } |
| 7 | 1748 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1749 // check for out of memory situation |
| 7 | 1750 if (lbuf == NULL || tag_fname == NULL |
| 1751 #ifdef FEAT_EMACS_TAGS | |
| 1752 || ebuf == NULL | |
| 1753 #endif | |
| 1754 ) | |
| 1755 goto findtag_end; | |
| 1756 | |
| 1757 #ifdef FEAT_CSCOPE | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1758 STRCPY(tag_fname, "from cscope"); // for error messages |
| 7 | 1759 #endif |
| 1760 | |
| 1761 /* | |
| 1762 * Initialize a few variables | |
| 1763 */ | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1764 if (help_only) // want tags from help file |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1765 curbuf->b_help = TRUE; // will be restored later |
|
10666
ed6f03535745
patch 8.0.0223: Coverity warns for an uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
10654
diff
changeset
|
1766 #ifdef FEAT_CSCOPE |
|
ed6f03535745
patch 8.0.0223: Coverity warns for an uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
10654
diff
changeset
|
1767 else if (use_cscope) |
|
ed6f03535745
patch 8.0.0223: Coverity warns for an uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
10654
diff
changeset
|
1768 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1769 // Make sure we don't mix help and cscope, confuses Coverity. |
|
10666
ed6f03535745
patch 8.0.0223: Coverity warns for an uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
10654
diff
changeset
|
1770 help_only = FALSE; |
|
ed6f03535745
patch 8.0.0223: Coverity warns for an uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
10654
diff
changeset
|
1771 curbuf->b_help = FALSE; |
|
ed6f03535745
patch 8.0.0223: Coverity warns for an uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
10654
diff
changeset
|
1772 } |
|
ed6f03535745
patch 8.0.0223: Coverity warns for an uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
10654
diff
changeset
|
1773 #endif |
| 7 | 1774 |
| 3131 | 1775 orgpat.len = (int)STRLEN(pat); |
| 7 | 1776 #ifdef FEAT_MULTI_LANG |
| 1777 if (curbuf->b_help) | |
| 1778 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1779 // When "@ab" is specified use only the "ab" language, otherwise |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1780 // search all languages. |
| 3131 | 1781 if (orgpat.len > 3 && pat[orgpat.len - 3] == '@' |
| 1782 && ASCII_ISALPHA(pat[orgpat.len - 2]) | |
| 1783 && ASCII_ISALPHA(pat[orgpat.len - 1])) | |
| 7 | 1784 { |
| 3131 | 1785 saved_pat = vim_strnsave(pat, orgpat.len - 3); |
| 7 | 1786 if (saved_pat != NULL) |
| 1787 { | |
| 3131 | 1788 help_lang_find = &pat[orgpat.len - 2]; |
| 1789 orgpat.pat = saved_pat; | |
| 1790 orgpat.len -= 3; | |
| 7 | 1791 } |
| 1792 } | |
| 1793 } | |
| 1794 #endif | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1795 if (p_tl != 0 && orgpat.len > p_tl) // adjust for 'taglength' |
| 3131 | 1796 orgpat.len = p_tl; |
| 1797 | |
| 5513 | 1798 save_emsg_off = emsg_off; |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1799 emsg_off = TRUE; // don't want error for invalid RE here |
| 3131 | 1800 prepare_pats(&orgpat, has_re); |
| 5513 | 1801 emsg_off = save_emsg_off; |
| 3784 | 1802 if (has_re && orgpat.regmatch.regprog == NULL) |
| 1803 goto findtag_end; | |
| 7 | 1804 |
| 1805 #ifdef FEAT_TAG_BINS | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1806 // This is only to avoid a compiler warning for using search_info |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1807 // uninitialised. |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19892
diff
changeset
|
1808 CLEAR_FIELD(search_info); |
| 7 | 1809 #endif |
| 1810 | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1811 #ifdef FEAT_EVAL |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1812 if (*curbuf->b_p_tfu != NUL && use_tfu && !tfu_in_use) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1813 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1814 tfu_in_use = TRUE; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1815 retval = find_tagfunc_tags(pat, &ga_match[0], &match_count, |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1816 flags, buf_ffname); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1817 tfu_in_use = FALSE; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1818 if (retval != NOTDONE) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1819 goto findtag_end; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1820 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1821 #endif |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
1822 |
| 413 | 1823 /* |
| 1824 * When finding a specified number of matches, first try with matching | |
| 1825 * case, so binary search can be used, and try ignore-case matches in a | |
| 1826 * second loop. | |
| 1827 * When finding all matches, 'tagbsearch' is off, or there is no fixed | |
| 1828 * string to look for, ignore case right away to avoid going though the | |
| 1829 * tags files twice. | |
| 1830 * When the tag file is case-fold sorted, it is either one or the other. | |
| 1831 * Only ignore case when TAG_NOIC not used or 'ignorecase' set. | |
| 1832 */ | |
|
10444
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1833 #ifdef FEAT_MULTI_LANG |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1834 // Set a flag if the file extension is .txt |
|
10444
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1835 if ((flags & TAG_KEEP_LANG) |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1836 && help_lang_find == NULL |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1837 && curbuf->b_fname != NULL |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1838 && (i = (int)STRLEN(curbuf->b_fname)) > 4 |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1839 && STRICMP(curbuf->b_fname + i - 4, ".txt") == 0) |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1840 is_txt = TRUE; |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1841 #endif |
| 7 | 1842 #ifdef FEAT_TAG_BINS |
| 3131 | 1843 orgpat.regmatch.rm_ic = ((p_ic || !noic) |
| 1844 && (findall || orgpat.headlen == 0 || !p_tbs)); | |
| 7 | 1845 for (round = 1; round <= 2; ++round) |
| 1846 { | |
| 3131 | 1847 linear = (orgpat.headlen == 0 || !p_tbs || round == 2); |
| 7 | 1848 #else |
| 3131 | 1849 orgpat.regmatch.rm_ic = (p_ic || !noic); |
| 7 | 1850 #endif |
| 1851 | |
| 1852 /* | |
| 1853 * Try tag file names from tags option one by one. | |
| 1854 */ | |
| 1855 for (first_file = TRUE; | |
| 1856 #ifdef FEAT_CSCOPE | |
| 1857 use_cscope || | |
| 1858 #endif | |
| 692 | 1859 get_tagfname(&tn, first_file, tag_fname) == OK; |
| 1860 first_file = FALSE) | |
| 7 | 1861 { |
| 1862 /* | |
| 1863 * A file that doesn't exist is silently ignored. Only when not a | |
| 1864 * single file is found, an error message is given (further on). | |
| 1865 */ | |
| 1866 #ifdef FEAT_CSCOPE | |
| 1867 if (use_cscope) | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1868 fp = NULL; // avoid GCC warning |
| 7 | 1869 else |
| 1870 #endif | |
| 1871 { | |
| 1872 #ifdef FEAT_MULTI_LANG | |
| 1873 if (curbuf->b_help) | |
| 1874 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1875 // Keep en if the file extension is .txt |
|
10444
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1876 if (is_txt) |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1877 STRCPY(help_lang, "en"); |
| 7 | 1878 else |
|
10444
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1879 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1880 // Prefer help tags according to 'helplang'. Put the |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1881 // two-letter language name in help_lang[]. |
|
10444
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1882 i = (int)STRLEN(tag_fname); |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1883 if (i > 3 && tag_fname[i - 3] == '-') |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1884 STRCPY(help_lang, tag_fname + i - 2); |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1885 else |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1886 STRCPY(help_lang, "en"); |
|
2edda415c28a
commit https://github.com/vim/vim/commit/6dbf66aa3e2197ce41f2b1cc7602bb9c15840548
Christian Brabandt <cb@256bit.org>
parents:
10430
diff
changeset
|
1887 } |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1888 // When searching for a specific language skip tags files |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1889 // for other languages. |
| 7 | 1890 if (help_lang_find != NULL |
| 1891 && STRICMP(help_lang, help_lang_find) != 0) | |
| 1892 continue; | |
| 1893 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1894 // For CTRL-] in a help file prefer a match with the same |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1895 // language. |
| 7 | 1896 if ((flags & TAG_KEEP_LANG) |
| 1897 && help_lang_find == NULL | |
| 1898 && curbuf->b_fname != NULL | |
| 835 | 1899 && (i = (int)STRLEN(curbuf->b_fname)) > 4 |
| 7 | 1900 && curbuf->b_fname[i - 1] == 'x' |
| 1901 && curbuf->b_fname[i - 4] == '.' | |
| 1902 && STRNICMP(curbuf->b_fname + i - 3, help_lang, 2) == 0) | |
| 1903 help_pri = 0; | |
| 1904 else | |
| 1905 { | |
| 1906 help_pri = 1; | |
| 1907 for (s = p_hlg; *s != NUL; ++s) | |
| 1908 { | |
| 1909 if (STRNICMP(s, help_lang, 2) == 0) | |
| 1910 break; | |
| 1911 ++help_pri; | |
| 1912 if ((s = vim_strchr(s, ',')) == NULL) | |
| 1913 break; | |
| 1914 } | |
| 1915 if (s == NULL || *s == NUL) | |
| 1916 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1917 // Language not in 'helplang': use last, prefer English, |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1918 // unless found already. |
| 7 | 1919 ++help_pri; |
| 1920 if (STRICMP(help_lang, "en") != 0) | |
| 1921 ++help_pri; | |
| 1922 } | |
| 1923 } | |
| 1924 } | |
| 1925 #endif | |
| 1926 | |
| 1927 if ((fp = mch_fopen((char *)tag_fname, "r")) == NULL) | |
| 1928 continue; | |
| 1929 | |
| 1930 if (p_verbose >= 5) | |
| 292 | 1931 { |
| 1932 verbose_enter(); | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
1933 smsg(_("Searching tags file %s"), tag_fname); |
| 292 | 1934 verbose_leave(); |
| 1935 } | |
| 7 | 1936 } |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1937 did_open = TRUE; // remember that we found at least one file |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1938 |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1939 state = TS_START; // we're at the start of the file |
| 7 | 1940 #ifdef FEAT_EMACS_TAGS |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1941 is_etag = 0; // default is: not emacs style |
| 7 | 1942 #endif |
| 1943 | |
| 1944 /* | |
| 1945 * Read and parse the lines in the file one by one | |
| 1946 */ | |
| 1947 for (;;) | |
| 1948 { | |
|
10134
95e9be4bc490
commit https://github.com/vim/vim/commit/7947312871e7d01cdba058199904c212ec32f1c0
Christian Brabandt <cb@256bit.org>
parents:
10132
diff
changeset
|
1949 #ifdef FEAT_TAG_BINS |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1950 // check for CTRL-C typed, more often when jumping around |
|
10128
98ddc760e8d5
commit https://github.com/vim/vim/commit/72b4b870fcc445c14faf282e0595b5f9406b101d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
1951 if (state == TS_BINARY || state == TS_SKIP_BACK) |
|
98ddc760e8d5
commit https://github.com/vim/vim/commit/72b4b870fcc445c14faf282e0595b5f9406b101d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
1952 line_breakcheck(); |
|
98ddc760e8d5
commit https://github.com/vim/vim/commit/72b4b870fcc445c14faf282e0595b5f9406b101d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
1953 else |
|
10134
95e9be4bc490
commit https://github.com/vim/vim/commit/7947312871e7d01cdba058199904c212ec32f1c0
Christian Brabandt <cb@256bit.org>
parents:
10132
diff
changeset
|
1954 #endif |
|
10128
98ddc760e8d5
commit https://github.com/vim/vim/commit/72b4b870fcc445c14faf282e0595b5f9406b101d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
1955 fast_breakcheck(); |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1956 if ((flags & TAG_INS_COMP)) // Double brackets for gcc |
|
10277
154d5a2e7395
commit https://github.com/vim/vim/commit/472e85970ee3a80abd824bef510df12e9cfe9e96
Christian Brabandt <cb@256bit.org>
parents:
10134
diff
changeset
|
1957 ins_compl_check_keys(30, FALSE); |
|
16142
570a296aa0b4
patch 8.1.1076: file for Insert mode is much too big
Bram Moolenaar <Bram@vim.org>
parents:
16070
diff
changeset
|
1958 if (got_int || ins_compl_interrupted()) |
| 7 | 1959 { |
| 1960 stop_searching = TRUE; | |
| 1961 break; | |
| 1962 } | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1963 // When mincount is TAG_MANY, stop when enough matches have been |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1964 // found (for completion). |
| 7 | 1965 if (mincount == TAG_MANY && match_count >= TAG_MANY) |
| 1966 { | |
| 1967 stop_searching = TRUE; | |
| 1968 retval = OK; | |
| 1969 break; | |
| 1970 } | |
| 1971 if (get_it_again) | |
| 1972 goto line_read_in; | |
| 1973 #ifdef FEAT_TAG_BINS | |
| 1974 /* | |
| 1975 * For binary search: compute the next offset to use. | |
| 1976 */ | |
| 1977 if (state == TS_BINARY) | |
| 1978 { | |
| 1979 offset = search_info.low_offset + ((search_info.high_offset | |
| 1980 - search_info.low_offset) / 2); | |
| 1981 if (offset == search_info.curr_offset) | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
1982 break; // End the binary search without a match. |
| 7 | 1983 else |
| 1984 search_info.curr_offset = offset; | |
| 1985 } | |
| 1986 | |
| 1987 /* | |
| 1988 * Skipping back (after a match during binary search). | |
| 1989 */ | |
| 1990 else if (state == TS_SKIP_BACK) | |
| 1991 { | |
|
18550
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
1992 search_info.curr_offset -= lbuf_size * 2; |
| 7 | 1993 if (search_info.curr_offset < 0) |
| 1994 { | |
| 1995 search_info.curr_offset = 0; | |
| 1996 rewind(fp); | |
| 1997 state = TS_STEP_FORWARD; | |
| 1998 } | |
| 1999 } | |
| 2000 | |
| 2001 /* | |
| 2002 * When jumping around in the file, first read a line to find the | |
| 2003 * start of the next line. | |
| 2004 */ | |
| 2005 if (state == TS_BINARY || state == TS_SKIP_BACK) | |
| 2006 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2007 // Adjust the search file offset to the correct position |
| 7 | 2008 search_info.curr_offset_used = search_info.curr_offset; |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
9068
diff
changeset
|
2009 vim_fseek(fp, search_info.curr_offset, SEEK_SET); |
|
18550
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2010 eof = vim_fgets(lbuf, lbuf_size, fp); |
| 7 | 2011 if (!eof && search_info.curr_offset != 0) |
| 2012 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2013 // The explicit cast is to work around a bug in gcc 3.4.2 |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2014 // (repeated below). |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
9068
diff
changeset
|
2015 search_info.curr_offset = vim_ftell(fp); |
| 7 | 2016 if (search_info.curr_offset == search_info.high_offset) |
| 2017 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2018 // oops, gone a bit too far; try from low offset |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
9068
diff
changeset
|
2019 vim_fseek(fp, search_info.low_offset, SEEK_SET); |
| 7 | 2020 search_info.curr_offset = search_info.low_offset; |
| 2021 } | |
|
18550
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2022 eof = vim_fgets(lbuf, lbuf_size, fp); |
| 7 | 2023 } |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2024 // skip empty and blank lines |
| 7 | 2025 while (!eof && vim_isblankline(lbuf)) |
| 2026 { | |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
9068
diff
changeset
|
2027 search_info.curr_offset = vim_ftell(fp); |
|
18550
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2028 eof = vim_fgets(lbuf, lbuf_size, fp); |
| 7 | 2029 } |
| 2030 if (eof) | |
| 2031 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2032 // Hit end of file. Skip backwards. |
| 7 | 2033 state = TS_SKIP_BACK; |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
9068
diff
changeset
|
2034 search_info.match_offset = vim_ftell(fp); |
| 7 | 2035 search_info.curr_offset = search_info.curr_offset_used; |
| 2036 continue; | |
| 2037 } | |
| 2038 } | |
| 2039 | |
| 2040 /* | |
| 2041 * Not jumping around in the file: Read the next line. | |
| 2042 */ | |
| 2043 else | |
| 2044 #endif | |
| 2045 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2046 // skip empty and blank lines |
| 7 | 2047 do |
| 2048 { | |
| 2049 #ifdef FEAT_CSCOPE | |
| 2050 if (use_cscope) | |
|
18550
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2051 eof = cs_fgets(lbuf, lbuf_size); |
| 7 | 2052 else |
| 2053 #endif | |
|
18550
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2054 eof = vim_fgets(lbuf, lbuf_size, fp); |
| 7 | 2055 } while (!eof && vim_isblankline(lbuf)); |
| 2056 | |
| 2057 if (eof) | |
| 2058 { | |
| 2059 #ifdef FEAT_EMACS_TAGS | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2060 if (incstack_idx) // this was an included file |
| 7 | 2061 { |
| 2062 --incstack_idx; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2063 fclose(fp); // end of this file ... |
| 7 | 2064 fp = incstack[incstack_idx].fp; |
| 2065 STRCPY(tag_fname, incstack[incstack_idx].etag_fname); | |
| 2066 vim_free(incstack[incstack_idx].etag_fname); | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2067 is_etag = 1; // (only etags can include) |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2068 continue; // ... continue with parent file |
| 7 | 2069 } |
| 2070 else | |
| 2071 #endif | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2072 break; // end of file |
| 7 | 2073 } |
| 2074 } | |
| 2075 line_read_in: | |
| 2076 | |
| 3131 | 2077 if (vimconv.vc_type != CONV_NONE) |
| 2078 { | |
| 2079 char_u *conv_line; | |
| 2080 int len; | |
| 2081 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2082 // Convert every line. Converting the pattern from 'enc' to |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2083 // the tags file encoding doesn't work, because characters are |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2084 // not recognized. |
| 3131 | 2085 conv_line = string_convert(&vimconv, lbuf, NULL); |
| 2086 if (conv_line != NULL) | |
| 2087 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2088 // Copy or swap lbuf and conv_line. |
| 3131 | 2089 len = (int)STRLEN(conv_line) + 1; |
| 2090 if (len > lbuf_size) | |
| 2091 { | |
| 2092 vim_free(lbuf); | |
| 2093 lbuf = conv_line; | |
| 2094 lbuf_size = len; | |
| 2095 } | |
| 2096 else | |
| 2097 { | |
| 2098 STRCPY(lbuf, conv_line); | |
| 2099 vim_free(conv_line); | |
| 2100 } | |
| 2101 } | |
| 2102 } | |
| 2103 | |
| 2104 | |
| 7 | 2105 #ifdef FEAT_EMACS_TAGS |
| 2106 /* | |
| 2107 * Emacs tags line with CTRL-L: New file name on next line. | |
| 2108 * The file name is followed by a ','. | |
|
10650
5ca7e3ec1263
patch 8.0.0215: NULL pointer use if cscope line looks like emacs tag
Christian Brabandt <cb@256bit.org>
parents:
10611
diff
changeset
|
2109 * Remember etag file name in ebuf. |
| 7 | 2110 */ |
|
10654
f0df81ef971a
patch 8.0.0217: build fails without cscope feature
Christian Brabandt <cb@256bit.org>
parents:
10650
diff
changeset
|
2111 if (*lbuf == Ctrl_L |
|
f0df81ef971a
patch 8.0.0217: build fails without cscope feature
Christian Brabandt <cb@256bit.org>
parents:
10650
diff
changeset
|
2112 # ifdef FEAT_CSCOPE |
|
f0df81ef971a
patch 8.0.0217: build fails without cscope feature
Christian Brabandt <cb@256bit.org>
parents:
10650
diff
changeset
|
2113 && !use_cscope |
|
f0df81ef971a
patch 8.0.0217: build fails without cscope feature
Christian Brabandt <cb@256bit.org>
parents:
10650
diff
changeset
|
2114 # endif |
|
f0df81ef971a
patch 8.0.0217: build fails without cscope feature
Christian Brabandt <cb@256bit.org>
parents:
10650
diff
changeset
|
2115 ) |
| 7 | 2116 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2117 is_etag = 1; // in case at the start |
| 7 | 2118 state = TS_LINEAR; |
|
15840
734b1928a5aa
patch 8.1.0927: USE_CR is never defined
Bram Moolenaar <Bram@vim.org>
parents:
15808
diff
changeset
|
2119 if (!vim_fgets(ebuf, LSIZE, fp)) |
| 7 | 2120 { |
| 2121 for (p = ebuf; *p && *p != ','; p++) | |
| 2122 ; | |
| 2123 *p = NUL; | |
| 2124 | |
| 2125 /* | |
| 2126 * atoi(p+1) is the number of bytes before the next ^L | |
| 2127 * unless it is an include statement. | |
| 2128 */ | |
| 2129 if (STRNCMP(p + 1, "include", 7) == 0 | |
| 2130 && incstack_idx < INCSTACK_SIZE) | |
| 2131 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2132 // Save current "fp" and "tag_fname" in the stack. |
| 7 | 2133 if ((incstack[incstack_idx].etag_fname = |
| 2134 vim_strsave(tag_fname)) != NULL) | |
| 2135 { | |
| 2136 char_u *fullpath_ebuf; | |
| 2137 | |
| 2138 incstack[incstack_idx].fp = fp; | |
| 2139 fp = NULL; | |
| 2140 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2141 // Figure out "tag_fname" and "fp" to use for |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2142 // included file. |
| 7 | 2143 fullpath_ebuf = expand_tag_fname(ebuf, |
| 2144 tag_fname, FALSE); | |
| 2145 if (fullpath_ebuf != NULL) | |
| 2146 { | |
| 2147 fp = mch_fopen((char *)fullpath_ebuf, "r"); | |
| 2148 if (fp != NULL) | |
| 2149 { | |
| 2150 if (STRLEN(fullpath_ebuf) > LSIZE) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2151 semsg(_("E430: Tag file path truncated for %s\n"), ebuf); |
| 418 | 2152 vim_strncpy(tag_fname, fullpath_ebuf, |
| 2153 MAXPATHL); | |
| 7 | 2154 ++incstack_idx; |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2155 is_etag = 0; // we can include anything |
| 7 | 2156 } |
| 2157 vim_free(fullpath_ebuf); | |
| 2158 } | |
| 2159 if (fp == NULL) | |
| 2160 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2161 // Can't open the included file, skip it and |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2162 // restore old value of "fp". |
| 7 | 2163 fp = incstack[incstack_idx].fp; |
| 2164 vim_free(incstack[incstack_idx].etag_fname); | |
| 2165 } | |
| 2166 } | |
| 2167 } | |
| 2168 } | |
| 2169 continue; | |
| 2170 } | |
| 2171 #endif | |
| 2172 | |
| 2173 /* | |
| 2174 * When still at the start of the file, check for Emacs tags file | |
| 2175 * format, and for "not sorted" flag. | |
| 2176 */ | |
| 2177 if (state == TS_START) | |
| 2178 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2179 // The header ends when the line sorts below "!_TAG_". When |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2180 // case is folded lower case letters sort before "_". |
|
4914
1707ddb6f5ae
updated for version 7.3.1202
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
2181 if (STRNCMP(lbuf, "!_TAG_", 6) <= 0 |
|
1707ddb6f5ae
updated for version 7.3.1202
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
2182 || (lbuf[0] == '!' && ASCII_ISLOWER(lbuf[1]))) |
| 3131 | 2183 { |
| 5328 | 2184 if (STRNCMP(lbuf, "!_TAG_", 6) != 0) |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2185 // Non-header item before the header, e.g. "!" itself. |
| 5328 | 2186 goto parse_line; |
| 2187 | |
| 3131 | 2188 /* |
| 2189 * Read header line. | |
| 2190 */ | |
| 2191 #ifdef FEAT_TAG_BINS | |
| 2192 if (STRNCMP(lbuf, "!_TAG_FILE_SORTED\t", 18) == 0) | |
| 2193 tag_file_sorted = lbuf[18]; | |
| 2194 #endif | |
| 2195 if (STRNCMP(lbuf, "!_TAG_FILE_ENCODING\t", 20) == 0) | |
| 2196 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2197 // Prepare to convert every line from the specified |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2198 // encoding to 'encoding'. |
| 3131 | 2199 for (p = lbuf + 20; *p > ' ' && *p < 127; ++p) |
| 2200 ; | |
| 2201 *p = NUL; | |
| 2202 convert_setup(&vimconv, lbuf + 20, p_enc); | |
| 2203 } | |
| 2204 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2205 // Read the next line. Unrecognized flags are ignored. |
| 3131 | 2206 continue; |
| 2207 } | |
| 2208 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2209 // Headers ends. |
| 3131 | 2210 |
| 7 | 2211 #ifdef FEAT_TAG_BINS |
| 2212 /* | |
| 2213 * When there is no tag head, or ignoring case, need to do a | |
| 2214 * linear search. | |
| 2215 * When no "!_TAG_" is found, default to binary search. If | |
| 2216 * the tag file isn't sorted, the second loop will find it. | |
| 2217 * When "!_TAG_FILE_SORTED" found: start binary search if | |
| 2218 * flag set. | |
| 2219 * For cscope, it's always linear. | |
| 2220 */ | |
| 2221 # ifdef FEAT_CSCOPE | |
| 2222 if (linear || use_cscope) | |
| 2223 # else | |
| 2224 if (linear) | |
| 2225 # endif | |
| 2226 state = TS_LINEAR; | |
| 3131 | 2227 else if (tag_file_sorted == NUL) |
| 7 | 2228 state = TS_BINARY; |
| 3131 | 2229 else if (tag_file_sorted == '1') |
| 7 | 2230 state = TS_BINARY; |
| 3131 | 2231 else if (tag_file_sorted == '2') |
| 2232 { | |
| 2233 state = TS_BINARY; | |
| 2234 sortic = TRUE; | |
| 2235 orgpat.regmatch.rm_ic = (p_ic || !noic); | |
| 7 | 2236 } |
| 3131 | 2237 else |
| 2238 state = TS_LINEAR; | |
| 2239 | |
| 2240 if (state == TS_BINARY && orgpat.regmatch.rm_ic && !sortic) | |
| 7 | 2241 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2242 // Binary search won't work for ignoring case, use linear |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2243 // search. |
| 7 | 2244 linear = TRUE; |
| 2245 state = TS_LINEAR; | |
| 2246 } | |
| 2247 #else | |
| 2248 state = TS_LINEAR; | |
| 2249 #endif | |
| 2250 | |
| 2251 #ifdef FEAT_TAG_BINS | |
|
18315
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2252 // When starting a binary search, get the size of the file and |
|
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2253 // compute the first offset. |
| 7 | 2254 if (state == TS_BINARY) |
| 2255 { | |
|
18315
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2256 if (vim_fseek(fp, 0L, SEEK_END) != 0) |
|
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2257 // can't seek, don't use binary search |
| 7 | 2258 state = TS_LINEAR; |
| 2259 else | |
| 2260 { | |
|
18315
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2261 // Get the tag file size (don't use mch_fstat(), it's |
|
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2262 // not portable). Don't use lseek(), it doesn't work |
|
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2263 // properly on MacOS Catalina. |
|
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2264 filesize = vim_ftell(fp); |
|
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2265 vim_fseek(fp, 0L, SEEK_SET); |
|
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2266 |
|
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2267 // Calculate the first read offset in the file. Start |
|
6e8b7c58c526
patch 8.1.2152: problems navigating tags file on MacOS Catalina
Bram Moolenaar <Bram@vim.org>
parents:
17809
diff
changeset
|
2268 // the search in the middle of the file. |
| 7 | 2269 search_info.low_offset = 0; |
| 2270 search_info.low_char = 0; | |
| 2271 search_info.high_offset = filesize; | |
| 2272 search_info.curr_offset = 0; | |
| 2273 search_info.high_char = 0xff; | |
| 2274 } | |
| 2275 continue; | |
| 2276 } | |
| 2277 #endif | |
| 2278 } | |
| 2279 | |
| 5328 | 2280 parse_line: |
|
16190
d863beec391a
patch 8.1.1100: tag file without trailing newline no longer works
Bram Moolenaar <Bram@vim.org>
parents:
16188
diff
changeset
|
2281 // When the line is too long the NUL will not be in the |
|
d863beec391a
patch 8.1.1100: tag file without trailing newline no longer works
Bram Moolenaar <Bram@vim.org>
parents:
16188
diff
changeset
|
2282 // last-but-one byte (see vim_fgets()). |
|
d863beec391a
patch 8.1.1100: tag file without trailing newline no longer works
Bram Moolenaar <Bram@vim.org>
parents:
16188
diff
changeset
|
2283 // Has been reported for Mozilla JS with extremely long names. |
|
18550
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2284 // In that case we need to increase lbuf_size. |
|
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2285 if (lbuf[lbuf_size - 2] != NUL |
|
16178
a8689ea2e869
patch 8.1.1094: long line in tags file causes error
Bram Moolenaar <Bram@vim.org>
parents:
16176
diff
changeset
|
2286 #ifdef FEAT_CSCOPE |
|
a8689ea2e869
patch 8.1.1094: long line in tags file causes error
Bram Moolenaar <Bram@vim.org>
parents:
16176
diff
changeset
|
2287 && !use_cscope |
|
a8689ea2e869
patch 8.1.1094: long line in tags file causes error
Bram Moolenaar <Bram@vim.org>
parents:
16176
diff
changeset
|
2288 #endif |
|
a8689ea2e869
patch 8.1.1094: long line in tags file causes error
Bram Moolenaar <Bram@vim.org>
parents:
16176
diff
changeset
|
2289 ) |
|
a8689ea2e869
patch 8.1.1094: long line in tags file causes error
Bram Moolenaar <Bram@vim.org>
parents:
16176
diff
changeset
|
2290 { |
|
18550
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2291 lbuf_size *= 2; |
|
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2292 vim_free(lbuf); |
|
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2293 lbuf = alloc(lbuf_size); |
|
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2294 if (lbuf == NULL) |
|
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2295 goto findtag_end; |
|
18554
60c46cd053db
patch 8.1.2271: build error if FEAT_TAG_BINS is not defined
Bram Moolenaar <Bram@vim.org>
parents:
18550
diff
changeset
|
2296 #ifdef FEAT_TAG_BINS |
|
18550
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2297 // this will try the same thing again, make sure the offset is |
|
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2298 // different |
|
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
2299 search_info.curr_offset = 0; |
|
18554
60c46cd053db
patch 8.1.2271: build error if FEAT_TAG_BINS is not defined
Bram Moolenaar <Bram@vim.org>
parents:
18550
diff
changeset
|
2300 #endif |
|
16178
a8689ea2e869
patch 8.1.1094: long line in tags file causes error
Bram Moolenaar <Bram@vim.org>
parents:
16176
diff
changeset
|
2301 continue; |
|
a8689ea2e869
patch 8.1.1094: long line in tags file causes error
Bram Moolenaar <Bram@vim.org>
parents:
16176
diff
changeset
|
2302 } |
|
a8689ea2e869
patch 8.1.1094: long line in tags file causes error
Bram Moolenaar <Bram@vim.org>
parents:
16176
diff
changeset
|
2303 |
| 7 | 2304 /* |
| 2305 * Figure out where the different strings are in this line. | |
| 2306 * For "normal" tags: Do a quick check if the tag matches. | |
| 2307 * This speeds up tag searching a lot! | |
| 2308 */ | |
| 3131 | 2309 if (orgpat.headlen |
| 7 | 2310 #ifdef FEAT_EMACS_TAGS |
| 2311 && !is_etag | |
| 2312 #endif | |
| 2313 ) | |
| 2314 { | |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19892
diff
changeset
|
2315 CLEAR_FIELD(tagp); |
| 7 | 2316 tagp.tagname = lbuf; |
| 2317 tagp.tagname_end = vim_strchr(lbuf, TAB); | |
| 3192 | 2318 if (tagp.tagname_end == NULL) |
| 7 | 2319 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2320 // Corrupted tag line. |
| 7 | 2321 line_error = TRUE; |
| 2322 break; | |
| 2323 } | |
| 2324 | |
| 2325 /* | |
| 2326 * Skip this line if the length of the tag is different and | |
| 2327 * there is no regexp, or the tag is too short. | |
| 2328 */ | |
| 2329 cmplen = (int)(tagp.tagname_end - tagp.tagname); | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2330 if (p_tl != 0 && cmplen > p_tl) // adjust for 'taglength' |
| 7 | 2331 cmplen = p_tl; |
| 3131 | 2332 if (has_re && orgpat.headlen < cmplen) |
| 2333 cmplen = orgpat.headlen; | |
| 2334 else if (state == TS_LINEAR && orgpat.headlen != cmplen) | |
| 7 | 2335 continue; |
| 2336 | |
| 2337 #ifdef FEAT_TAG_BINS | |
| 2338 if (state == TS_BINARY) | |
| 2339 { | |
| 2340 /* | |
| 2341 * Simplistic check for unsorted tags file. | |
| 2342 */ | |
| 2343 i = (int)tagp.tagname[0]; | |
| 2344 if (sortic) | |
| 2345 i = (int)TOUPPER_ASC(tagp.tagname[0]); | |
| 2346 if (i < search_info.low_char || i > search_info.high_char) | |
| 2347 sort_error = TRUE; | |
| 2348 | |
| 2349 /* | |
| 2350 * Compare the current tag with the searched tag. | |
| 2351 */ | |
| 2352 if (sortic) | |
| 3131 | 2353 tagcmp = tag_strnicmp(tagp.tagname, orgpat.head, |
| 7 | 2354 (size_t)cmplen); |
| 2355 else | |
| 3131 | 2356 tagcmp = STRNCMP(tagp.tagname, orgpat.head, cmplen); |
| 7 | 2357 |
| 2358 /* | |
| 2359 * A match with a shorter tag means to search forward. | |
| 2360 * A match with a longer tag means to search backward. | |
| 2361 */ | |
| 2362 if (tagcmp == 0) | |
| 2363 { | |
| 3131 | 2364 if (cmplen < orgpat.headlen) |
| 7 | 2365 tagcmp = -1; |
| 3131 | 2366 else if (cmplen > orgpat.headlen) |
| 7 | 2367 tagcmp = 1; |
| 2368 } | |
| 2369 | |
| 2370 if (tagcmp == 0) | |
| 2371 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2372 // We've located the tag, now skip back and search |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2373 // forward until the first matching tag is found. |
| 7 | 2374 state = TS_SKIP_BACK; |
| 2375 search_info.match_offset = search_info.curr_offset; | |
| 2376 continue; | |
| 2377 } | |
| 2378 if (tagcmp < 0) | |
| 2379 { | |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
9068
diff
changeset
|
2380 search_info.curr_offset = vim_ftell(fp); |
| 7 | 2381 if (search_info.curr_offset < search_info.high_offset) |
| 2382 { | |
| 2383 search_info.low_offset = search_info.curr_offset; | |
| 2384 if (sortic) | |
| 2385 search_info.low_char = | |
| 2386 TOUPPER_ASC(tagp.tagname[0]); | |
| 2387 else | |
| 2388 search_info.low_char = tagp.tagname[0]; | |
| 2389 continue; | |
| 2390 } | |
| 2391 } | |
| 2392 if (tagcmp > 0 | |
| 2393 && search_info.curr_offset != search_info.high_offset) | |
| 2394 { | |
| 2395 search_info.high_offset = search_info.curr_offset; | |
| 2396 if (sortic) | |
| 2397 search_info.high_char = | |
| 2398 TOUPPER_ASC(tagp.tagname[0]); | |
| 2399 else | |
| 2400 search_info.high_char = tagp.tagname[0]; | |
| 2401 continue; | |
| 2402 } | |
| 2403 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2404 // No match yet and are at the end of the binary search. |
| 7 | 2405 break; |
| 2406 } | |
| 2407 else if (state == TS_SKIP_BACK) | |
| 2408 { | |
| 3131 | 2409 if (MB_STRNICMP(tagp.tagname, orgpat.head, cmplen) != 0) |
| 7 | 2410 state = TS_STEP_FORWARD; |
| 2411 else | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2412 // Have to skip back more. Restore the curr_offset |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2413 // used, otherwise we get stuck at a long line. |
| 7 | 2414 search_info.curr_offset = search_info.curr_offset_used; |
| 2415 continue; | |
| 2416 } | |
| 2417 else if (state == TS_STEP_FORWARD) | |
| 2418 { | |
| 3131 | 2419 if (MB_STRNICMP(tagp.tagname, orgpat.head, cmplen) != 0) |
| 7 | 2420 { |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
9068
diff
changeset
|
2421 if ((off_T)vim_ftell(fp) > search_info.match_offset) |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2422 break; // past last match |
| 7 | 2423 else |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2424 continue; // before first match |
| 7 | 2425 } |
| 2426 } | |
| 2427 else | |
| 2428 #endif | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2429 // skip this match if it can't match |
| 3131 | 2430 if (MB_STRNICMP(tagp.tagname, orgpat.head, cmplen) != 0) |
| 7 | 2431 continue; |
| 2432 | |
| 2433 /* | |
| 2434 * Can be a matching tag, isolate the file name and command. | |
| 2435 */ | |
|
16176
4d7ee5609652
patch 8.1.1093: support for outdated tags format slows down tag parsing
Bram Moolenaar <Bram@vim.org>
parents:
16164
diff
changeset
|
2436 tagp.fname = tagp.tagname_end + 1; |
| 7 | 2437 tagp.fname_end = vim_strchr(tagp.fname, TAB); |
| 2438 tagp.command = tagp.fname_end + 1; | |
| 2439 if (tagp.fname_end == NULL) | |
| 2440 i = FAIL; | |
| 2441 else | |
| 2442 i = OK; | |
| 2443 } | |
| 2444 else | |
| 2445 i = parse_tag_line(lbuf, | |
| 2446 #ifdef FEAT_EMACS_TAGS | |
| 2447 is_etag, | |
| 2448 #endif | |
| 2449 &tagp); | |
| 2450 if (i == FAIL) | |
| 2451 { | |
| 2452 line_error = TRUE; | |
| 2453 break; | |
| 2454 } | |
| 2455 | |
| 2456 #ifdef FEAT_EMACS_TAGS | |
| 2457 if (is_etag) | |
| 2458 tagp.fname = ebuf; | |
| 2459 #endif | |
| 2460 /* | |
| 2461 * First try matching with the pattern literally (also when it is | |
| 2462 * a regexp). | |
| 2463 */ | |
| 2464 cmplen = (int)(tagp.tagname_end - tagp.tagname); | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2465 if (p_tl != 0 && cmplen > p_tl) // adjust for 'taglength' |
| 7 | 2466 cmplen = p_tl; |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2467 // if tag length does not match, don't try comparing |
| 3131 | 2468 if (orgpat.len != cmplen) |
| 7 | 2469 match = FALSE; |
| 2470 else | |
| 2471 { | |
| 3131 | 2472 if (orgpat.regmatch.rm_ic) |
| 7 | 2473 { |
| 3131 | 2474 match = (MB_STRNICMP(tagp.tagname, orgpat.pat, cmplen) == 0); |
| 7 | 2475 if (match) |
| 3131 | 2476 match_no_ic = (STRNCMP(tagp.tagname, orgpat.pat, |
| 7 | 2477 cmplen) == 0); |
| 2478 } | |
| 2479 else | |
| 3131 | 2480 match = (STRNCMP(tagp.tagname, orgpat.pat, cmplen) == 0); |
| 7 | 2481 } |
| 2482 | |
| 2483 /* | |
| 2484 * Has a regexp: Also find tags matching regexp. | |
| 2485 */ | |
| 2486 match_re = FALSE; | |
| 3131 | 2487 if (!match && orgpat.regmatch.regprog != NULL) |
| 7 | 2488 { |
| 2489 int cc; | |
| 2490 | |
| 2491 cc = *tagp.tagname_end; | |
| 2492 *tagp.tagname_end = NUL; | |
| 3131 | 2493 match = vim_regexec(&orgpat.regmatch, tagp.tagname, (colnr_T)0); |
| 7 | 2494 if (match) |
| 2495 { | |
| 3131 | 2496 matchoff = (int)(orgpat.regmatch.startp[0] - tagp.tagname); |
| 2497 if (orgpat.regmatch.rm_ic) | |
| 7 | 2498 { |
| 3131 | 2499 orgpat.regmatch.rm_ic = FALSE; |
| 2500 match_no_ic = vim_regexec(&orgpat.regmatch, tagp.tagname, | |
| 7 | 2501 (colnr_T)0); |
| 3131 | 2502 orgpat.regmatch.rm_ic = TRUE; |
| 7 | 2503 } |
| 2504 } | |
| 2505 *tagp.tagname_end = cc; | |
| 2506 match_re = TRUE; | |
| 2507 } | |
| 2508 | |
| 2509 /* | |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2510 * If a match is found, add it to ht_match[] and ga_match[]. |
| 7 | 2511 */ |
| 2512 if (match) | |
| 2513 { | |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2514 int len = 0; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2515 |
| 7 | 2516 #ifdef FEAT_CSCOPE |
| 2517 if (use_cscope) | |
| 2518 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2519 // Don't change the ordering, always use the same table. |
| 7 | 2520 mtt = MT_GL_OTH; |
| 2521 } | |
| 2522 else | |
| 2523 #endif | |
| 2524 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2525 // Decide in which array to store this match. |
| 7 | 2526 is_current = test_for_current( |
| 2527 #ifdef FEAT_EMACS_TAGS | |
| 2528 is_etag, | |
| 2529 #endif | |
| 2530 tagp.fname, tagp.fname_end, tag_fname, | |
| 2531 buf_ffname); | |
| 2532 #ifdef FEAT_EMACS_TAGS | |
| 2533 is_static = FALSE; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2534 if (!is_etag) // emacs tags are never static |
| 7 | 2535 #endif |
|
16176
4d7ee5609652
patch 8.1.1093: support for outdated tags format slows down tag parsing
Bram Moolenaar <Bram@vim.org>
parents:
16164
diff
changeset
|
2536 is_static = test_for_static(&tagp); |
| 7 | 2537 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2538 // decide in which of the sixteen tables to store this |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2539 // match |
| 7 | 2540 if (is_static) |
| 2541 { | |
| 2542 if (is_current) | |
| 2543 mtt = MT_ST_CUR; | |
| 2544 else | |
| 2545 mtt = MT_ST_OTH; | |
| 2546 } | |
| 2547 else | |
| 2548 { | |
| 2549 if (is_current) | |
| 2550 mtt = MT_GL_CUR; | |
| 2551 else | |
| 2552 mtt = MT_GL_OTH; | |
| 2553 } | |
| 3131 | 2554 if (orgpat.regmatch.rm_ic && !match_no_ic) |
| 7 | 2555 mtt += MT_IC_OFF; |
| 2556 if (match_re) | |
| 2557 mtt += MT_RE_OFF; | |
| 2558 } | |
| 2559 | |
| 2560 /* | |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2561 * Add the found match in ht_match[mtt] and ga_match[mtt]. |
| 7 | 2562 * Store the info we need later, which depends on the kind of |
| 2563 * tags we are dealing with. | |
| 2564 */ | |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2565 if (help_only) |
| 7 | 2566 { |
| 2567 #ifdef FEAT_MULTI_LANG | |
| 2568 # define ML_EXTRA 3 | |
| 2569 #else | |
| 2570 # define ML_EXTRA 0 | |
| 2571 #endif | |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2572 /* |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2573 * Append the help-heuristic number after the tagname, for |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2574 * sorting it later. The heuristic is ignored for |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2575 * detecting duplicates. |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2576 * The format is {tagname}@{lang}NUL{heuristic}NUL |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2577 */ |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2578 *tagp.tagname_end = NUL; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2579 len = (int)(tagp.tagname_end - tagp.tagname); |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
2580 mfp = alloc(sizeof(char_u) + len + 10 + ML_EXTRA + 1); |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2581 if (mfp != NULL) |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2582 { |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2583 int heuristic; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2584 |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2585 p = mfp; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2586 STRCPY(p, tagp.tagname); |
| 7 | 2587 #ifdef FEAT_MULTI_LANG |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2588 p[len] = '@'; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2589 STRCPY(p + len + 1, help_lang); |
| 7 | 2590 #endif |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2591 |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2592 heuristic = help_heuristic(tagp.tagname, |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2593 match_re ? matchoff : 0, !match_no_ic); |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2594 #ifdef FEAT_MULTI_LANG |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2595 heuristic += help_pri; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2596 #endif |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2597 sprintf((char *)p + len + 1 + ML_EXTRA, "%06d", |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2598 heuristic); |
| 7 | 2599 } |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2600 *tagp.tagname_end = TAB; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2601 } |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2602 else if (name_only) |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2603 { |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2604 if (get_it_again) |
| 7 | 2605 { |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2606 char_u *temp_end = tagp.command; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2607 |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2608 if (*temp_end == '/') |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2609 while (*temp_end && *temp_end != '\r' |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2610 && *temp_end != '\n' |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2611 && *temp_end != '$') |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2612 temp_end++; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2613 |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2614 if (tagp.command + 2 < temp_end) |
| 7 | 2615 { |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2616 len = (int)(temp_end - tagp.command - 2); |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
2617 mfp = alloc(len + 2); |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2618 if (mfp != NULL) |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2619 vim_strncpy(mfp, tagp.command + 2, len); |
| 7 | 2620 } |
| 2621 else | |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2622 mfp = NULL; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2623 get_it_again = FALSE; |
| 7 | 2624 } |
| 2625 else | |
| 2626 { | |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2627 len = (int)(tagp.tagname_end - tagp.tagname); |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
2628 mfp = alloc(sizeof(char_u) + len + 1); |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2629 if (mfp != NULL) |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2630 vim_strncpy(mfp, tagp.tagname, len); |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2631 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2632 // if wanted, re-read line to get long form too |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2633 if (State & INSERT) |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2634 get_it_again = p_sft; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2635 } |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2636 } |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2637 else |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2638 { |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2639 size_t tag_fname_len = STRLEN(tag_fname); |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2640 #ifdef FEAT_EMACS_TAGS |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2641 size_t ebuf_len = 0; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2642 #endif |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2643 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2644 // Save the tag in a buffer. |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2645 // Use 0x02 to separate fields (Can't use NUL because the |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2646 // hash key is terminated by NUL, or Ctrl_A because that is |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2647 // part of some Emacs tag files -- see parse_tag_line). |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2648 // Emacs tag: <mtt><tag_fname><0x02><ebuf><0x02><lbuf><NUL> |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2649 // other tag: <mtt><tag_fname><0x02><0x02><lbuf><NUL> |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2650 // without Emacs tags: <mtt><tag_fname><0x02><lbuf><NUL> |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2651 // Here <mtt> is the "mtt" value plus 1 to avoid NUL. |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2652 len = (int)tag_fname_len + (int)STRLEN(lbuf) + 3; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2653 #ifdef FEAT_EMACS_TAGS |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2654 if (is_etag) |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2655 { |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2656 ebuf_len = STRLEN(ebuf); |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2657 len += (int)ebuf_len + 1; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2658 } |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2659 else |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2660 ++len; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2661 #endif |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
2662 mfp = alloc(sizeof(char_u) + len + 1); |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2663 if (mfp != NULL) |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2664 { |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2665 p = mfp; |
|
10611
6bff81438f27
patch 8.0.0195: fail to jump to static tag in current file
Christian Brabandt <cb@256bit.org>
parents:
10601
diff
changeset
|
2666 p[0] = mtt + 1; |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2667 STRCPY(p + 1, tag_fname); |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2668 #ifdef BACKSLASH_IN_FILENAME |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2669 // Ignore differences in slashes, avoid adding |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2670 // both path/file and path\file. |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2671 slash_adjust(p + 1); |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2672 #endif |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2673 p[tag_fname_len + 1] = TAG_SEP; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2674 s = p + 1 + tag_fname_len + 1; |
| 7 | 2675 #ifdef FEAT_EMACS_TAGS |
| 2676 if (is_etag) | |
| 2677 { | |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2678 STRCPY(s, ebuf); |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2679 s[ebuf_len] = TAG_SEP; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2680 s += ebuf_len + 1; |
| 7 | 2681 } |
| 2682 else | |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2683 *s++ = TAG_SEP; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2684 #endif |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2685 STRCPY(s, lbuf); |
| 7 | 2686 } |
| 2687 } | |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2688 |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2689 if (mfp != NULL) |
| 7 | 2690 { |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2691 hashitem_T *hi; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2692 |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2693 /* |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2694 * Don't add identical matches. |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2695 * Add all cscope tags, because they are all listed. |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2696 * "mfp" is used as a hash key, there is a NUL byte to end |
|
16378
3d6b282e2d6e
patch 8.1.1194: typos and small problems in source files
Bram Moolenaar <Bram@vim.org>
parents:
16190
diff
changeset
|
2697 * the part that matters for comparing, more bytes may |
|
3d6b282e2d6e
patch 8.1.1194: typos and small problems in source files
Bram Moolenaar <Bram@vim.org>
parents:
16190
diff
changeset
|
2698 * follow after it. E.g. help tags store the priority |
|
3d6b282e2d6e
patch 8.1.1194: typos and small problems in source files
Bram Moolenaar <Bram@vim.org>
parents:
16190
diff
changeset
|
2699 * after the NUL. |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2700 */ |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2701 #ifdef FEAT_CSCOPE |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2702 if (use_cscope) |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2703 hash++; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2704 else |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2705 #endif |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2706 hash = hash_hash(mfp); |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2707 hi = hash_lookup(&ht_match[mtt], mfp, hash); |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2708 if (HASHITEM_EMPTY(hi)) |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2709 { |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2710 if (hash_add_item(&ht_match[mtt], hi, mfp, hash) |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2711 == FAIL |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2712 || ga_grow(&ga_match[mtt], 1) != OK) |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2713 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2714 // Out of memory! Just forget about the rest. |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2715 retval = OK; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2716 stop_searching = TRUE; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2717 break; |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2718 } |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2719 else |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2720 { |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2721 ((char_u **)(ga_match[mtt].ga_data)) |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2722 [ga_match[mtt].ga_len++] = mfp; |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2723 ++match_count; |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2724 } |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2725 } |
|
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2726 else |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2727 // duplicate tag, drop it |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2728 vim_free(mfp); |
| 7 | 2729 } |
| 2730 } | |
| 2731 #ifdef FEAT_CSCOPE | |
| 2732 if (use_cscope && eof) | |
| 2733 break; | |
| 2734 #endif | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2735 } // forever |
| 7 | 2736 |
| 2737 if (line_error) | |
| 2738 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2739 semsg(_("E431: Format error in tags file \"%s\""), tag_fname); |
| 7 | 2740 #ifdef FEAT_CSCOPE |
| 2741 if (!use_cscope) | |
| 2742 #endif | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2743 semsg(_("Before byte %ld"), (long)vim_ftell(fp)); |
| 7 | 2744 stop_searching = TRUE; |
| 2745 line_error = FALSE; | |
| 2746 } | |
| 2747 | |
| 2748 #ifdef FEAT_CSCOPE | |
| 2749 if (!use_cscope) | |
| 2750 #endif | |
| 2751 fclose(fp); | |
| 2752 #ifdef FEAT_EMACS_TAGS | |
| 2753 while (incstack_idx) | |
| 2754 { | |
| 2755 --incstack_idx; | |
| 2756 fclose(incstack[incstack_idx].fp); | |
| 2757 vim_free(incstack[incstack_idx].etag_fname); | |
| 2758 } | |
| 2759 #endif | |
| 2760 if (vimconv.vc_type != CONV_NONE) | |
| 2761 convert_setup(&vimconv, NULL, NULL); | |
| 2762 | |
| 2763 #ifdef FEAT_TAG_BINS | |
| 3131 | 2764 tag_file_sorted = NUL; |
| 7 | 2765 if (sort_error) |
| 2766 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2767 semsg(_("E432: Tags file not sorted: %s"), tag_fname); |
| 7 | 2768 sort_error = FALSE; |
| 2769 } | |
| 2770 #endif | |
| 2771 | |
| 2772 /* | |
| 2773 * Stop searching if sufficient tags have been found. | |
| 2774 */ | |
| 2775 if (match_count >= mincount) | |
| 2776 { | |
| 2777 retval = OK; | |
| 2778 stop_searching = TRUE; | |
| 2779 } | |
| 2780 | |
| 2781 #ifdef FEAT_CSCOPE | |
| 2782 if (stop_searching || use_cscope) | |
| 2783 #else | |
| 2784 if (stop_searching) | |
| 2785 #endif | |
| 2786 break; | |
| 2787 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2788 } // end of for-each-file loop |
| 7 | 2789 |
| 692 | 2790 #ifdef FEAT_CSCOPE |
| 2791 if (!use_cscope) | |
| 2792 #endif | |
| 2793 tagname_free(&tn); | |
| 2794 | |
| 7 | 2795 #ifdef FEAT_TAG_BINS |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2796 // stop searching when already did a linear search, or when TAG_NOIC |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2797 // used, and 'ignorecase' not set or already did case-ignore search |
| 3131 | 2798 if (stop_searching || linear || (!p_ic && noic) || orgpat.regmatch.rm_ic) |
| 7 | 2799 break; |
| 2800 # ifdef FEAT_CSCOPE | |
| 2801 if (use_cscope) | |
| 2802 break; | |
| 2803 # endif | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2804 orgpat.regmatch.rm_ic = TRUE; // try another time while ignoring case |
| 7 | 2805 } |
| 2806 #endif | |
| 2807 | |
| 2808 if (!stop_searching) | |
| 2809 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2810 if (!did_open && verbose) // never opened any tags file |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2811 emsg(_("E433: No tags file")); |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2812 retval = OK; // It's OK even when no tag found |
| 7 | 2813 } |
| 2814 | |
| 2815 findtag_end: | |
| 2816 vim_free(lbuf); | |
|
4805
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
3804
diff
changeset
|
2817 vim_regfree(orgpat.regmatch.regprog); |
| 7 | 2818 vim_free(tag_fname); |
| 2819 #ifdef FEAT_EMACS_TAGS | |
| 2820 vim_free(ebuf); | |
| 2821 #endif | |
| 2822 | |
| 2823 /* | |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2824 * Move the matches from the ga_match[] arrays into one list of |
| 7 | 2825 * matches. When retval == FAIL, free the matches. |
| 2826 */ | |
| 2827 if (retval == FAIL) | |
| 2828 match_count = 0; | |
| 2829 | |
| 2830 if (match_count > 0) | |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16782
diff
changeset
|
2831 matches = ALLOC_MULT(char_u *, match_count); |
| 7 | 2832 else |
| 2833 matches = NULL; | |
| 2834 match_count = 0; | |
| 2835 for (mtt = 0; mtt < MT_COUNT; ++mtt) | |
| 2836 { | |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2837 for (i = 0; i < ga_match[mtt].ga_len; ++i) |
| 7 | 2838 { |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2839 mfp = ((char_u **)(ga_match[mtt].ga_data))[i]; |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2840 if (matches == NULL) |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2841 vim_free(mfp); |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2842 else |
| 7 | 2843 { |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2844 if (!name_only) |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2845 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2846 // Change mtt back to zero-based. |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2847 *mfp = *mfp - 1; |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2848 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2849 // change the TAG_SEP back to NUL |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2850 for (p = mfp + 1; *p != NUL; ++p) |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2851 if (*p == TAG_SEP) |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2852 *p = NUL; |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2853 } |
|
25852
336e2d9924e6
patch 8.2.3460: some type casts are not needed
Bram Moolenaar <Bram@vim.org>
parents:
25652
diff
changeset
|
2854 matches[match_count++] = mfp; |
| 7 | 2855 } |
| 2856 } | |
|
11008
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2857 |
|
0ecd07cd2e43
patch 8.0.0393: order of duplicate tags is not preserved
Christian Brabandt <cb@256bit.org>
parents:
10666
diff
changeset
|
2858 ga_clear(&ga_match[mtt]); |
|
10601
1b09db809d3f
patch 8.0.0190: finding duplicate tags uses a slow linear search
Christian Brabandt <cb@256bit.org>
parents:
10444
diff
changeset
|
2859 hash_clear(&ht_match[mtt]); |
| 7 | 2860 } |
| 2861 | |
| 2862 *matchesp = matches; | |
| 2863 *num_matches = match_count; | |
| 2864 | |
| 2865 curbuf->b_help = help_save; | |
| 2866 #ifdef FEAT_MULTI_LANG | |
| 2867 vim_free(saved_pat); | |
| 2868 #endif | |
| 2869 | |
|
7266
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
2870 p_ic = save_p_ic; |
|
6ba7182fb7bd
commit https://github.com/vim/vim/commit/0f6562e9036f889185dff49a75c7fc5ffb28b307
Christian Brabandt <cb@256bit.org>
parents:
6851
diff
changeset
|
2871 |
| 7 | 2872 return retval; |
| 2873 } | |
| 2874 | |
| 2875 static garray_T tag_fnames = GA_EMPTY; | |
| 2876 | |
| 2877 /* | |
| 2878 * Callback function for finding all "tags" and "tags-??" files in | |
| 2879 * 'runtimepath' doc directories. | |
| 2880 */ | |
| 2881 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2882 found_tagfile_cb(char_u *fname, void *cookie UNUSED) |
| 7 | 2883 { |
| 2884 if (ga_grow(&tag_fnames, 1) == OK) | |
|
14232
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2885 { |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2886 char_u *tag_fname = vim_strsave(fname); |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2887 |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2888 #ifdef BACKSLASH_IN_FILENAME |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2889 slash_adjust(tag_fname); |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2890 #endif |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2891 simplify_filename(tag_fname); |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2892 ((char_u **)(tag_fnames.ga_data))[tag_fnames.ga_len++] = tag_fname; |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2893 } |
| 7 | 2894 } |
| 2895 | |
| 359 | 2896 #if defined(EXITFREE) || defined(PROTO) |
| 2897 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2898 free_tag_stuff(void) |
| 359 | 2899 { |
| 692 | 2900 ga_clear_strings(&tag_fnames); |
|
16511
4182f74e2965
patch 8.1.1259: crash when exiting early
Bram Moolenaar <Bram@vim.org>
parents:
16461
diff
changeset
|
2901 if (curwin != NULL) |
|
4182f74e2965
patch 8.1.1259: crash when exiting early
Bram Moolenaar <Bram@vim.org>
parents:
16461
diff
changeset
|
2902 do_tag(NULL, DT_FREE, 0, 0, 0); |
| 1818 | 2903 tag_freematch(); |
| 2904 | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
2905 # if defined(FEAT_QUICKFIX) |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
2906 tagstack_clear_entry(&ptag_entry); |
| 1818 | 2907 # endif |
| 359 | 2908 } |
| 2909 #endif | |
| 2910 | |
| 7 | 2911 /* |
| 2912 * Get the next name of a tag file from the tag file list. | |
| 2913 * For help files, use "tags" file only. | |
| 2914 * | |
| 2915 * Return FAIL if no more tag file names, OK otherwise. | |
| 2916 */ | |
| 514 | 2917 int |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2918 get_tagfname( |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2919 tagname_T *tnp, // holds status info |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2920 int first, // TRUE when first file name is wanted |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2921 char_u *buf) // pointer to buffer of MAXPATHL chars |
| 7 | 2922 { |
| 2923 char_u *fname = NULL; | |
| 2924 char_u *r_ptr; | |
|
14232
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2925 int i; |
| 7 | 2926 |
| 692 | 2927 if (first) |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19892
diff
changeset
|
2928 CLEAR_POINTER(tnp); |
| 692 | 2929 |
| 514 | 2930 if (curbuf->b_help) |
| 7 | 2931 { |
| 514 | 2932 /* |
| 2933 * For help files it's done in a completely different way: | |
| 2934 * Find "doc/tags" and "doc/tags-??" in all directories in | |
| 2935 * 'runtimepath'. | |
| 2936 */ | |
| 2937 if (first) | |
| 7 | 2938 { |
| 2939 ga_clear_strings(&tag_fnames); | |
| 2940 ga_init2(&tag_fnames, (int)sizeof(char_u *), 10); | |
| 2941 do_in_runtimepath((char_u *) | |
| 2942 #ifdef FEAT_MULTI_LANG | |
| 36 | 2943 # ifdef VMS |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2944 // Functions decc$to_vms() and decc$translate_vms() crash |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2945 // on some VMS systems with wildcards "??". Seems ECO |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2946 // patches do fix the problem in C RTL, but we can't use |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2947 // an #ifdef for that. |
| 36 | 2948 "doc/tags doc/tags-*" |
| 2949 # else | |
| 7 | 2950 "doc/tags doc/tags-??" |
| 36 | 2951 # endif |
| 7 | 2952 #else |
| 2953 "doc/tags" | |
| 2954 #endif | |
|
8524
2f57bbe870ea
commit https://github.com/vim/vim/commit/7f8989dd8a627af2185df381195351a913f3777f
Christian Brabandt <cb@256bit.org>
parents:
7835
diff
changeset
|
2955 , DIP_ALL, found_tagfile_cb, NULL); |
| 7 | 2956 } |
| 602 | 2957 |
| 692 | 2958 if (tnp->tn_hf_idx >= tag_fnames.ga_len) |
| 7 | 2959 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2960 // Not found in 'runtimepath', use 'helpfile', if it exists and |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2961 // wasn't used yet, replacing "help.txt" with "tags". |
| 692 | 2962 if (tnp->tn_hf_idx > tag_fnames.ga_len || *p_hf == NUL) |
| 7 | 2963 return FAIL; |
| 692 | 2964 ++tnp->tn_hf_idx; |
| 7 | 2965 STRCPY(buf, p_hf); |
| 2966 STRCPY(gettail(buf), "tags"); | |
|
14232
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2967 #ifdef BACKSLASH_IN_FILENAME |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2968 slash_adjust(buf); |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2969 #endif |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2970 simplify_filename(buf); |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2971 |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2972 for (i = 0; i < tag_fnames.ga_len; ++i) |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2973 if (STRCMP(buf, ((char_u **)(tag_fnames.ga_data))[i]) == 0) |
|
4afe2386aae8
patch 8.1.0133: tagfiles() can have duplicate entries
Christian Brabandt <cb@256bit.org>
parents:
13792
diff
changeset
|
2974 return FAIL; // avoid duplicate file names |
| 7 | 2975 } |
| 2976 else | |
| 692 | 2977 vim_strncpy(buf, ((char_u **)(tag_fnames.ga_data))[ |
| 2978 tnp->tn_hf_idx++], MAXPATHL - 1); | |
| 514 | 2979 return OK; |
| 2980 } | |
| 2981 | |
| 2982 if (first) | |
| 2983 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2984 // Init. We make a copy of 'tags', because autocommands may change |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
2985 // the value without notifying us. |
| 692 | 2986 tnp->tn_tags = vim_strsave((*curbuf->b_p_tags != NUL) |
| 2987 ? curbuf->b_p_tags : p_tags); | |
| 2988 if (tnp->tn_tags == NULL) | |
| 2989 return FAIL; | |
| 2990 tnp->tn_np = tnp->tn_tags; | |
| 7 | 2991 } |
| 692 | 2992 |
| 2993 /* | |
| 2994 * Loop until we have found a file name that can be used. | |
| 2995 * There are two states: | |
| 2996 * tnp->tn_did_filefind_init == FALSE: setup for next part in 'tags'. | |
| 2997 * tnp->tn_did_filefind_init == TRUE: find next file in this part. | |
| 2998 */ | |
| 2999 for (;;) | |
| 7 | 3000 { |
| 692 | 3001 if (tnp->tn_did_filefind_init) |
| 7 | 3002 { |
| 692 | 3003 fname = vim_findfile(tnp->tn_search_ctx); |
| 3004 if (fname != NULL) | |
| 3005 break; | |
| 3006 | |
| 3007 tnp->tn_did_filefind_init = FALSE; | |
| 3008 } | |
| 3009 else | |
| 3010 { | |
| 3011 char_u *filename = NULL; | |
| 3012 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3013 // Stop when used all parts of 'tags'. |
| 692 | 3014 if (*tnp->tn_np == NUL) |
| 7 | 3015 { |
| 692 | 3016 vim_findfile_cleanup(tnp->tn_search_ctx); |
| 3017 tnp->tn_search_ctx = NULL; | |
| 3018 return FAIL; | |
| 7 | 3019 } |
| 692 | 3020 |
| 3021 /* | |
| 3022 * Copy next file name into buf. | |
| 3023 */ | |
| 3024 buf[0] = NUL; | |
| 3025 (void)copy_option_part(&tnp->tn_np, buf, MAXPATHL - 1, " ,"); | |
| 7 | 3026 |
| 3027 #ifdef FEAT_PATH_EXTRA | |
| 692 | 3028 r_ptr = vim_findfile_stopdir(buf); |
| 7 | 3029 #else |
| 692 | 3030 r_ptr = NULL; |
| 7 | 3031 #endif |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3032 // move the filename one char forward and truncate the |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3033 // filepath with a NUL |
| 692 | 3034 filename = gettail(buf); |
| 1620 | 3035 STRMOVE(filename + 1, filename); |
| 692 | 3036 *filename++ = NUL; |
| 3037 | |
| 3038 tnp->tn_search_ctx = vim_findfile_init(buf, filename, | |
| 3039 r_ptr, 100, | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3040 FALSE, // don't free visited list |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3041 FINDFILE_FILE, // we search for a file |
| 692 | 3042 tnp->tn_search_ctx, TRUE, curbuf->b_ffname); |
| 3043 if (tnp->tn_search_ctx != NULL) | |
| 3044 tnp->tn_did_filefind_init = TRUE; | |
| 7 | 3045 } |
| 3046 } | |
| 3047 | |
| 692 | 3048 STRCPY(buf, fname); |
| 3049 vim_free(fname); | |
| 7 | 3050 return OK; |
| 3051 } | |
| 3052 | |
| 3053 /* | |
| 692 | 3054 * Free the contents of a tagname_T that was filled by get_tagfname(). |
| 3055 */ | |
| 3056 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3057 tagname_free(tagname_T *tnp) |
| 692 | 3058 { |
| 3059 vim_free(tnp->tn_tags); | |
| 3060 vim_findfile_cleanup(tnp->tn_search_ctx); | |
| 1541 | 3061 tnp->tn_search_ctx = NULL; |
| 692 | 3062 ga_clear_strings(&tag_fnames); |
| 3063 } | |
| 3064 | |
| 3065 /* | |
| 7 | 3066 * Parse one line from the tags file. Find start/end of tag name, start/end of |
| 3067 * file name and start of search pattern. | |
| 3068 * | |
| 3069 * If is_etag is TRUE, tagp->fname and tagp->fname_end are not set. | |
| 3070 * | |
| 3071 * Return FAIL if there is a format error in this line, OK otherwise. | |
| 3072 */ | |
| 3073 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3074 parse_tag_line( |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3075 char_u *lbuf, // line to be parsed |
| 7 | 3076 #ifdef FEAT_EMACS_TAGS |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3077 int is_etag, |
| 7 | 3078 #endif |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3079 tagptrs_T *tagp) |
| 7 | 3080 { |
| 3081 char_u *p; | |
| 3082 | |
| 3083 #ifdef FEAT_EMACS_TAGS | |
| 3084 char_u *p_7f; | |
| 3085 | |
| 3086 if (is_etag) | |
| 3087 { | |
| 3088 /* | |
| 3089 * There are two formats for an emacs tag line: | |
| 3090 * 1: struct EnvBase ^?EnvBase^A139,4627 | |
| 3091 * 2: #define ARPB_WILD_WORLD ^?153,5194 | |
| 3092 */ | |
| 3093 p_7f = vim_strchr(lbuf, 0x7f); | |
| 3094 if (p_7f == NULL) | |
| 1770 | 3095 { |
| 3096 etag_fail: | |
| 3097 if (vim_strchr(lbuf, '\n') == NULL) | |
| 3098 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3099 // Truncated line. Ignore it. |
| 1770 | 3100 if (p_verbose >= 5) |
| 3101 { | |
| 3102 verbose_enter(); | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
3103 msg(_("Ignoring long line in tags file")); |
| 1770 | 3104 verbose_leave(); |
| 3105 } | |
| 3106 tagp->command = lbuf; | |
| 3107 tagp->tagname = lbuf; | |
| 3108 tagp->tagname_end = lbuf; | |
| 3109 return OK; | |
| 3110 } | |
| 7 | 3111 return FAIL; |
| 1770 | 3112 } |
| 7 | 3113 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3114 // Find ^A. If not found the line number is after the 0x7f |
| 7 | 3115 p = vim_strchr(p_7f, Ctrl_A); |
| 3116 if (p == NULL) | |
| 3117 p = p_7f + 1; | |
| 3118 else | |
| 3119 ++p; | |
| 3120 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3121 if (!VIM_ISDIGIT(*p)) // check for start of line number |
| 1770 | 3122 goto etag_fail; |
| 7 | 3123 tagp->command = p; |
| 3124 | |
| 3125 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3126 if (p[-1] == Ctrl_A) // first format: explicit tagname given |
| 7 | 3127 { |
| 3128 tagp->tagname = p_7f + 1; | |
| 3129 tagp->tagname_end = p - 1; | |
| 3130 } | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3131 else // second format: isolate tagname |
| 7 | 3132 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3133 // find end of tagname |
| 7 | 3134 for (p = p_7f - 1; !vim_iswordc(*p); --p) |
| 3135 if (p == lbuf) | |
| 1770 | 3136 goto etag_fail; |
| 7 | 3137 tagp->tagname_end = p + 1; |
| 3138 while (p >= lbuf && vim_iswordc(*p)) | |
| 3139 --p; | |
| 3140 tagp->tagname = p + 1; | |
| 3141 } | |
| 3142 } | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3143 else // not an Emacs tag |
| 7 | 3144 { |
| 3145 #endif | |
|
16070
c435843c7535
patch 8.1.1040: FEAT_TAG_ANYWHITE is not enabled in any build
Bram Moolenaar <Bram@vim.org>
parents:
15840
diff
changeset
|
3146 // Isolate the tagname, from lbuf up to the first white |
| 7 | 3147 tagp->tagname = lbuf; |
| 3148 p = vim_strchr(lbuf, TAB); | |
| 3149 if (p == NULL) | |
| 3150 return FAIL; | |
| 3151 tagp->tagname_end = p; | |
| 3152 | |
|
16070
c435843c7535
patch 8.1.1040: FEAT_TAG_ANYWHITE is not enabled in any build
Bram Moolenaar <Bram@vim.org>
parents:
15840
diff
changeset
|
3153 // Isolate file name, from first to second white space |
| 7 | 3154 if (*p != NUL) |
| 3155 ++p; | |
| 3156 tagp->fname = p; | |
| 3157 p = vim_strchr(p, TAB); | |
| 3158 if (p == NULL) | |
| 3159 return FAIL; | |
| 3160 tagp->fname_end = p; | |
| 3161 | |
|
16070
c435843c7535
patch 8.1.1040: FEAT_TAG_ANYWHITE is not enabled in any build
Bram Moolenaar <Bram@vim.org>
parents:
15840
diff
changeset
|
3162 // find start of search command, after second white space |
| 7 | 3163 if (*p != NUL) |
| 3164 ++p; | |
| 3165 if (*p == NUL) | |
| 3166 return FAIL; | |
| 3167 tagp->command = p; | |
| 3168 #ifdef FEAT_EMACS_TAGS | |
| 3169 } | |
| 3170 #endif | |
| 3171 | |
| 3172 return OK; | |
| 3173 } | |
| 3174 | |
| 3175 /* | |
| 3176 * Check if tagname is a static tag | |
| 3177 * | |
| 3178 * Static tags produced by the older ctags program have the format: | |
| 3179 * 'file:tag file /pattern'. | |
| 1204 | 3180 * This is only recognized when both occurrence of 'file' are the same, to |
| 7 | 3181 * avoid recognizing "string::string" or ":exit". |
| 3182 * | |
| 3183 * Static tags produced by the new ctags program have the format: | |
| 3184 * 'tag file /pattern/;"<Tab>file:' " | |
| 3185 * | |
| 3186 * Return TRUE if it is a static tag and adjust *tagname to the real tag. | |
| 3187 * Return FALSE if it is not a static tag. | |
| 3188 */ | |
| 3189 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3190 test_for_static(tagptrs_T *tagp) |
| 7 | 3191 { |
| 3192 char_u *p; | |
| 3193 | |
| 3194 /* | |
| 3195 * Check for new style static tag ":...<Tab>file:[<Tab>...]" | |
| 3196 */ | |
| 3197 p = tagp->command; | |
| 3198 while ((p = vim_strchr(p, '\t')) != NULL) | |
| 3199 { | |
| 3200 ++p; | |
| 3201 if (STRNCMP(p, "file:", 5) == 0) | |
| 3202 return TRUE; | |
| 3203 } | |
| 3204 | |
| 3205 return FALSE; | |
| 3206 } | |
| 3207 | |
| 3208 /* | |
|
12680
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3209 * Returns the length of a matching tag line. |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3210 */ |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3211 static size_t |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3212 matching_line_len(char_u *lbuf) |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3213 { |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3214 char_u *p = lbuf + 1; |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3215 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3216 // does the same thing as parse_match() |
|
13227
b88fa651c824
patch 8.0.1488: emacs tags no longer work
Christian Brabandt <cb@256bit.org>
parents:
13068
diff
changeset
|
3217 p += STRLEN(p) + 1; |
|
12680
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3218 #ifdef FEAT_EMACS_TAGS |
|
13227
b88fa651c824
patch 8.0.1488: emacs tags no longer work
Christian Brabandt <cb@256bit.org>
parents:
13068
diff
changeset
|
3219 p += STRLEN(p) + 1; |
|
12680
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3220 #endif |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3221 return (p - lbuf) + STRLEN(p); |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3222 } |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3223 |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3224 /* |
| 7 | 3225 * Parse a line from a matching tag. Does not change the line itself. |
| 3226 * | |
| 3227 * The line that we get looks like this: | |
| 3228 * Emacs tag: <mtt><tag_fname><NUL><ebuf><NUL><lbuf> | |
| 3229 * other tag: <mtt><tag_fname><NUL><NUL><lbuf> | |
| 3230 * without Emacs tags: <mtt><tag_fname><NUL><lbuf> | |
| 3231 * | |
| 3232 * Return OK or FAIL. | |
| 3233 */ | |
| 3234 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3235 parse_match( |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3236 char_u *lbuf, // input: matching line |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3237 tagptrs_T *tagp) // output: pointers into the line |
| 7 | 3238 { |
| 3239 int retval; | |
| 3240 char_u *p; | |
| 3241 char_u *pc, *pt; | |
| 3242 | |
| 3243 tagp->tag_fname = lbuf + 1; | |
| 3244 lbuf += STRLEN(tagp->tag_fname) + 2; | |
| 3245 #ifdef FEAT_EMACS_TAGS | |
| 3246 if (*lbuf) | |
| 3247 { | |
| 3248 tagp->is_etag = TRUE; | |
| 3249 tagp->fname = lbuf; | |
| 3250 lbuf += STRLEN(lbuf); | |
| 3251 tagp->fname_end = lbuf++; | |
| 3252 } | |
| 3253 else | |
| 3254 { | |
| 3255 tagp->is_etag = FALSE; | |
| 3256 ++lbuf; | |
| 3257 } | |
| 3258 #endif | |
| 3259 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3260 // Find search pattern and the file name for non-etags. |
| 7 | 3261 retval = parse_tag_line(lbuf, |
| 3262 #ifdef FEAT_EMACS_TAGS | |
| 3263 tagp->is_etag, | |
| 3264 #endif | |
| 3265 tagp); | |
| 3266 | |
| 3267 tagp->tagkind = NULL; | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3268 tagp->user_data = NULL; |
|
18640
b9240fe40dd4
patch 8.1.2312: "line:" field in tags file not used
Bram Moolenaar <Bram@vim.org>
parents:
18554
diff
changeset
|
3269 tagp->tagline = 0; |
| 7 | 3270 tagp->command_end = NULL; |
| 3271 | |
| 3272 if (retval == OK) | |
| 3273 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3274 // Try to find a kind field: "kind:<kind>" or just "<kind>" |
| 7 | 3275 p = tagp->command; |
| 3276 if (find_extra(&p) == OK) | |
| 3277 { | |
|
15808
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3278 if (p > tagp->command && p[-1] == '|') |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3279 tagp->command_end = p - 1; // drop trailing bar |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3280 else |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3281 tagp->command_end = p; |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3282 p += 2; // skip ";\"" |
| 7 | 3283 if (*p++ == TAB) |
|
19617
5ce724c60c4c
patch 8.2.0365: tag kind can't be a multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
19475
diff
changeset
|
3284 // Accept ASCII alphabetic kind characters and any multi-byte |
|
5ce724c60c4c
patch 8.2.0365: tag kind can't be a multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
19475
diff
changeset
|
3285 // character. |
|
5ce724c60c4c
patch 8.2.0365: tag kind can't be a multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
19475
diff
changeset
|
3286 while (ASCII_ISALPHA(*p) || mb_ptr2len(p) > 1) |
| 7 | 3287 { |
| 3288 if (STRNCMP(p, "kind:", 5) == 0) | |
| 3289 tagp->tagkind = p + 5; | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3290 else if (STRNCMP(p, "user_data:", 10) == 0) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3291 tagp->user_data = p + 10; |
|
18640
b9240fe40dd4
patch 8.1.2312: "line:" field in tags file not used
Bram Moolenaar <Bram@vim.org>
parents:
18554
diff
changeset
|
3292 else if (STRNCMP(p, "line:", 5) == 0) |
|
b9240fe40dd4
patch 8.1.2312: "line:" field in tags file not used
Bram Moolenaar <Bram@vim.org>
parents:
18554
diff
changeset
|
3293 tagp->tagline = atoi((char *)p + 5); |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3294 if (tagp->tagkind != NULL && tagp->user_data != NULL) |
| 7 | 3295 break; |
| 3296 pc = vim_strchr(p, ':'); | |
| 3297 pt = vim_strchr(p, '\t'); | |
| 3298 if (pc == NULL || (pt != NULL && pc > pt)) | |
| 3299 tagp->tagkind = p; | |
| 3300 if (pt == NULL) | |
| 3301 break; | |
|
19617
5ce724c60c4c
patch 8.2.0365: tag kind can't be a multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
19475
diff
changeset
|
3302 p = pt; |
|
5ce724c60c4c
patch 8.2.0365: tag kind can't be a multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
19475
diff
changeset
|
3303 MB_PTR_ADV(p); |
| 7 | 3304 } |
| 3305 } | |
| 3306 if (tagp->tagkind != NULL) | |
| 3307 { | |
| 3308 for (p = tagp->tagkind; | |
|
19617
5ce724c60c4c
patch 8.2.0365: tag kind can't be a multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
19475
diff
changeset
|
3309 *p && *p != '\t' && *p != '\r' && *p != '\n'; MB_PTR_ADV(p)) |
| 7 | 3310 ; |
| 3311 tagp->tagkind_end = p; | |
| 3312 } | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3313 if (tagp->user_data != NULL) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3314 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3315 for (p = tagp->user_data; |
|
19617
5ce724c60c4c
patch 8.2.0365: tag kind can't be a multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
19475
diff
changeset
|
3316 *p && *p != '\t' && *p != '\r' && *p != '\n'; MB_PTR_ADV(p)) |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3317 ; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3318 tagp->user_data_end = p; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3319 } |
| 7 | 3320 } |
| 3321 return retval; | |
| 3322 } | |
| 3323 | |
| 3324 /* | |
| 3325 * Find out the actual file name of a tag. Concatenate the tags file name | |
| 3326 * with the matching tag file name. | |
| 3327 * Returns an allocated string or NULL (out of memory). | |
| 3328 */ | |
| 3329 static char_u * | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3330 tag_full_fname(tagptrs_T *tagp) |
| 7 | 3331 { |
| 3332 char_u *fullname; | |
| 3333 int c; | |
| 3334 | |
| 3335 #ifdef FEAT_EMACS_TAGS | |
| 3336 if (tagp->is_etag) | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3337 c = 0; // to shut up GCC |
| 7 | 3338 else |
| 3339 #endif | |
| 3340 { | |
| 3341 c = *tagp->fname_end; | |
| 3342 *tagp->fname_end = NUL; | |
| 3343 } | |
| 3344 fullname = expand_tag_fname(tagp->fname, tagp->tag_fname, FALSE); | |
| 3345 | |
| 3346 #ifdef FEAT_EMACS_TAGS | |
| 3347 if (!tagp->is_etag) | |
| 3348 #endif | |
| 3349 *tagp->fname_end = c; | |
| 3350 | |
| 3351 return fullname; | |
| 3352 } | |
| 3353 | |
| 3354 /* | |
| 3355 * Jump to a tag that has been found in one of the tag files | |
| 3356 * | |
| 3357 * returns OK for success, NOTAGFILE when file not found, FAIL otherwise. | |
| 3358 */ | |
| 3359 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3360 jumpto_tag( |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3361 char_u *lbuf_arg, // line from the tags file for this tag |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3362 int forceit, // :ta with ! |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3363 int keep_help) // keep help flag (FALSE for cscope) |
| 7 | 3364 { |
|
23505
bb29b09902d5
patch 8.2.2295: incsearch does not detect empty pattern properly
Bram Moolenaar <Bram@vim.org>
parents:
23272
diff
changeset
|
3365 optmagic_T save_magic_overruled; |
| 7 | 3366 int save_p_ws, save_p_scs, save_p_ic; |
| 3367 linenr_T save_lnum; | |
| 3368 char_u *str; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3369 char_u *pbuf; // search pattern buffer |
| 7 | 3370 char_u *pbuf_end; |
| 3371 char_u *tofree_fname = NULL; | |
| 3372 char_u *fname; | |
| 3373 tagptrs_T tagp; | |
| 3374 int retval = FAIL; | |
|
11476
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3375 int getfile_result = GETFILE_UNUSED; |
| 7 | 3376 int search_options; |
| 3377 #ifdef FEAT_SEARCH_EXTRA | |
| 3378 int save_no_hlsearch; | |
| 3379 #endif | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
3380 #if defined(FEAT_QUICKFIX) |
| 7 | 3381 win_T *curwin_save = NULL; |
| 3382 #endif | |
| 3383 char_u *full_fname = NULL; | |
| 3384 #ifdef FEAT_FOLDING | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3385 int old_KeyTyped = KeyTyped; // getting the file may reset it |
| 7 | 3386 #endif |
|
12680
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3387 size_t len; |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3388 char_u *lbuf; |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3389 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3390 // Make a copy of the line, it can become invalid when an autocommand calls |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3391 // back here recursively. |
|
12680
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3392 len = matching_line_len(lbuf_arg) + 1; |
|
16782
fc58fee685e2
patch 8.1.1393: unnecessary type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
3393 lbuf = alloc(len); |
|
12680
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3394 if (lbuf != NULL) |
|
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3395 mch_memmove(lbuf, lbuf_arg, len); |
| 7 | 3396 |
| 3397 pbuf = alloc(LSIZE); | |
| 3398 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3399 // parse the match line into the tagp structure |
|
12680
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3400 if (pbuf == NULL || lbuf == NULL || parse_match(lbuf, &tagp) == FAIL) |
| 7 | 3401 { |
| 3402 tagp.fname_end = NULL; | |
| 3403 goto erret; | |
| 3404 } | |
| 3405 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3406 // truncate the file name, so it can be used as a string |
| 7 | 3407 *tagp.fname_end = NUL; |
| 3408 fname = tagp.fname; | |
| 3409 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3410 // copy the command to pbuf[], remove trailing CR/NL |
| 7 | 3411 str = tagp.command; |
| 3412 for (pbuf_end = pbuf; *str && *str != '\n' && *str != '\r'; ) | |
| 3413 { | |
| 3414 #ifdef FEAT_EMACS_TAGS | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3415 if (tagp.is_etag && *str == ',')// stop at ',' after line number |
| 7 | 3416 break; |
| 3417 #endif | |
| 3418 *pbuf_end++ = *str++; | |
|
18550
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
3419 if (pbuf_end - pbuf + 1 >= LSIZE) |
|
90e5812af76b
patch 8.1.2269: tags file with very long line stops using binary search
Bram Moolenaar <Bram@vim.org>
parents:
18358
diff
changeset
|
3420 break; |
| 7 | 3421 } |
| 3422 *pbuf_end = NUL; | |
| 3423 | |
| 3424 #ifdef FEAT_EMACS_TAGS | |
| 3425 if (!tagp.is_etag) | |
| 3426 #endif | |
| 3427 { | |
| 3428 /* | |
| 3429 * Remove the "<Tab>fieldname:value" stuff; we don't need it here. | |
| 3430 */ | |
| 3431 str = pbuf; | |
| 3432 if (find_extra(&str) == OK) | |
| 3433 { | |
| 3434 pbuf_end = str; | |
| 3435 *pbuf_end = NUL; | |
| 3436 } | |
| 3437 } | |
| 3438 | |
| 3439 /* | |
| 3440 * Expand file name, when needed (for environment variables). | |
| 3441 * If 'tagrelative' option set, may change file name. | |
| 3442 */ | |
| 3443 fname = expand_tag_fname(fname, tagp.tag_fname, TRUE); | |
| 3444 if (fname == NULL) | |
| 3445 goto erret; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3446 tofree_fname = fname; // free() it later |
| 7 | 3447 |
| 3448 /* | |
| 3449 * Check if the file with the tag exists before abandoning the current | |
| 3450 * file. Also accept a file name for which there is a matching BufReadCmd | |
| 3451 * autocommand event (e.g., http://sys/file). | |
| 3452 */ | |
|
13380
69517d67421f
patch 8.0.1564: too many #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
3453 if (mch_getperm(fname) < 0 && !has_autocmd(EVENT_BUFREADCMD, fname, NULL)) |
| 7 | 3454 { |
| 3455 retval = NOTAGFILE; | |
| 3456 vim_free(nofile_fname); | |
| 3457 nofile_fname = vim_strsave(fname); | |
| 3458 if (nofile_fname == NULL) | |
| 3459 nofile_fname = empty_option; | |
| 3460 goto erret; | |
| 3461 } | |
| 3462 | |
| 3463 ++RedrawingDisabled; | |
| 3464 | |
| 3465 #ifdef FEAT_GUI | |
| 3466 need_mouse_correct = TRUE; | |
| 3467 #endif | |
| 3468 | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
3469 #if defined(FEAT_QUICKFIX) |
| 2713 | 3470 if (g_do_tagpreview != 0) |
| 7 | 3471 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3472 postponed_split = 0; // don't split again below |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3473 curwin_save = curwin; // Save current window |
| 728 | 3474 |
| 7 | 3475 /* |
| 3476 * If we are reusing a window, we may change dir when | |
| 3477 * entering it (autocommands) so turn the tag filename | |
| 3478 * into a fullpath | |
| 3479 */ | |
| 3480 if (!curwin->w_p_pvw) | |
| 3481 { | |
| 3482 full_fname = FullName_save(fname, FALSE); | |
| 3483 fname = full_fname; | |
| 3484 | |
| 3485 /* | |
| 3486 * Make the preview window the current window. | |
| 3487 * Open a preview window when needed. | |
| 3488 */ | |
|
17767
c75da1064e33
patch 8.1.1880: cannot show extra info for completion in a popup window
Bram Moolenaar <Bram@vim.org>
parents:
17652
diff
changeset
|
3489 prepare_tagpreview(TRUE, TRUE, FALSE); |
| 7 | 3490 } |
| 3491 } | |
| 3492 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3493 // If it was a CTRL-W CTRL-] command split window now. For ":tab tag" |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3494 // open a new tab page. |
|
11476
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3495 if (postponed_split && (swb_flags & (SWB_USEOPEN | SWB_USETAB))) |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3496 { |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3497 buf_T *existing_buf = buflist_findname_exp(fname); |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3498 |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3499 if (existing_buf != NULL) |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3500 { |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3501 win_T *wp = NULL; |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3502 |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3503 if (swb_flags & SWB_USEOPEN) |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3504 wp = buf_jump_open_win(existing_buf); |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3505 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3506 // If 'switchbuf' contains "usetab": jump to first window in any tab |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3507 // page containing "existing_buf" if one exists |
|
11476
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3508 if (wp == NULL && (swb_flags & SWB_USETAB)) |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3509 wp = buf_jump_open_tab(existing_buf); |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3510 // We've switched to the buffer, the usual loading of the file must |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3511 // be skipped. |
|
11476
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3512 if (wp != NULL) |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3513 getfile_result = GETFILE_SAME_FILE; |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3514 } |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3515 } |
|
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3516 if (getfile_result == GETFILE_UNUSED |
|
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
21996
diff
changeset
|
3517 && (postponed_split || cmdmod.cmod_tab != 0)) |
| 7 | 3518 { |
|
11238
5b524c2286ce
patch 8.0.0505: failed window split for :stag not handled
Christian Brabandt <cb@256bit.org>
parents:
11225
diff
changeset
|
3519 if (win_split(postponed_split > 0 ? postponed_split : 0, |
|
5b524c2286ce
patch 8.0.0505: failed window split for :stag not handled
Christian Brabandt <cb@256bit.org>
parents:
11225
diff
changeset
|
3520 postponed_split_flags) == FAIL) |
|
5b524c2286ce
patch 8.0.0505: failed window split for :stag not handled
Christian Brabandt <cb@256bit.org>
parents:
11225
diff
changeset
|
3521 { |
|
5b524c2286ce
patch 8.0.0505: failed window split for :stag not handled
Christian Brabandt <cb@256bit.org>
parents:
11225
diff
changeset
|
3522 --RedrawingDisabled; |
|
5b524c2286ce
patch 8.0.0505: failed window split for :stag not handled
Christian Brabandt <cb@256bit.org>
parents:
11225
diff
changeset
|
3523 goto erret; |
|
5b524c2286ce
patch 8.0.0505: failed window split for :stag not handled
Christian Brabandt <cb@256bit.org>
parents:
11225
diff
changeset
|
3524 } |
| 2583 | 3525 RESET_BINDING(curwin); |
| 7 | 3526 } |
| 3527 #endif | |
| 3528 | |
| 3529 if (keep_help) | |
| 3530 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3531 // A :ta from a help file will keep the b_help flag set. For ":ptag" |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3532 // we need to use the flag from the window where we came from. |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
3533 #if defined(FEAT_QUICKFIX) |
| 2713 | 3534 if (g_do_tagpreview != 0) |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
3535 keep_help_flag = bt_help(curwin_save->w_buffer); |
| 7 | 3536 else |
| 3537 #endif | |
| 3538 keep_help_flag = curbuf->b_help; | |
| 3539 } | |
|
12680
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3540 |
|
11476
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3541 if (getfile_result == GETFILE_UNUSED) |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3542 // Careful: getfile() may trigger autocommands and call jumpto_tag() |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3543 // recursively. |
|
11476
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3544 getfile_result = getfile(0, fname, NULL, TRUE, (linenr_T)0, forceit); |
| 7 | 3545 keep_help_flag = FALSE; |
| 3546 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3547 if (GETFILE_SUCCESS(getfile_result)) // got to the right file |
| 7 | 3548 { |
| 3549 curwin->w_set_curswant = TRUE; | |
| 3550 postponed_split = 0; | |
| 3551 | |
|
23272
a84e7abb0c92
patch 8.2.2182: Vim9: value of 'magic' is still relevant
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
3552 save_magic_overruled = magic_overruled; |
|
23505
bb29b09902d5
patch 8.2.2295: incsearch does not detect empty pattern properly
Bram Moolenaar <Bram@vim.org>
parents:
23272
diff
changeset
|
3553 magic_overruled = OPTION_MAGIC_OFF; // always execute with 'nomagic' |
| 7 | 3554 #ifdef FEAT_SEARCH_EXTRA |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3555 // Save value of no_hlsearch, jumping to a tag is not a real search |
| 7 | 3556 save_no_hlsearch = no_hlsearch; |
| 3557 #endif | |
|
24594
5c456a88f651
patch 8.2.2836: build failure without the +quickfix feature
Bram Moolenaar <Bram@vim.org>
parents:
24186
diff
changeset
|
3558 #if defined(FEAT_PROP_POPUP) && defined(FEAT_QUICKFIX) |
|
24053
bcf16185be60
patch 8.2.2568: second time a preview popup is opened highlight is not set
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
3559 // getfile() may have cleared options, apply 'previewpopup' again. |
|
bcf16185be60
patch 8.2.2568: second time a preview popup is opened highlight is not set
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
3560 if (g_do_tagpreview != 0 && *p_pvp != NUL) |
|
bcf16185be60
patch 8.2.2568: second time a preview popup is opened highlight is not set
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
3561 parse_previewpopup(curwin); |
|
bcf16185be60
patch 8.2.2568: second time a preview popup is opened highlight is not set
Bram Moolenaar <Bram@vim.org>
parents:
23563
diff
changeset
|
3562 #endif |
| 7 | 3563 |
| 3564 /* | |
| 3565 * If 'cpoptions' contains 't', store the search pattern for the "n" | |
| 3566 * command. If 'cpoptions' does not contain 't', the search pattern | |
| 3567 * is not stored. | |
| 3568 */ | |
| 3569 if (vim_strchr(p_cpo, CPO_TAGPAT) != NULL) | |
| 3570 search_options = 0; | |
| 3571 else | |
| 3572 search_options = SEARCH_KEEP; | |
| 3573 | |
| 3574 /* | |
| 3575 * If the command is a search, try here. | |
| 3576 * | |
| 3577 * Reset 'smartcase' for the search, since the search pattern was not | |
| 3578 * typed by the user. | |
| 3579 * Only use do_search() when there is a full search command, without | |
| 3580 * anything following. | |
| 3581 */ | |
| 3582 str = pbuf; | |
| 3583 if (pbuf[0] == '/' || pbuf[0] == '?') | |
|
19892
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
3584 str = skip_regexp(pbuf + 1, pbuf[0], FALSE) + 1; |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3585 if (str > pbuf_end - 1) // search command with nothing following |
| 7 | 3586 { |
| 3587 save_p_ws = p_ws; | |
| 3588 save_p_ic = p_ic; | |
| 3589 save_p_scs = p_scs; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3590 p_ws = TRUE; // need 'wrapscan' for backward searches |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3591 p_ic = FALSE; // don't ignore case now |
| 7 | 3592 p_scs = FALSE; |
| 3593 save_lnum = curwin->w_cursor.lnum; | |
|
18640
b9240fe40dd4
patch 8.1.2312: "line:" field in tags file not used
Bram Moolenaar <Bram@vim.org>
parents:
18554
diff
changeset
|
3594 if (tagp.tagline > 0) |
|
b9240fe40dd4
patch 8.1.2312: "line:" field in tags file not used
Bram Moolenaar <Bram@vim.org>
parents:
18554
diff
changeset
|
3595 // start search before line from "line:" field |
|
b9240fe40dd4
patch 8.1.2312: "line:" field in tags file not used
Bram Moolenaar <Bram@vim.org>
parents:
18554
diff
changeset
|
3596 curwin->w_cursor.lnum = tagp.tagline - 1; |
|
b9240fe40dd4
patch 8.1.2312: "line:" field in tags file not used
Bram Moolenaar <Bram@vim.org>
parents:
18554
diff
changeset
|
3597 else |
|
b9240fe40dd4
patch 8.1.2312: "line:" field in tags file not used
Bram Moolenaar <Bram@vim.org>
parents:
18554
diff
changeset
|
3598 // start search before first line |
|
b9240fe40dd4
patch 8.1.2312: "line:" field in tags file not used
Bram Moolenaar <Bram@vim.org>
parents:
18554
diff
changeset
|
3599 curwin->w_cursor.lnum = 0; |
|
19475
5512aa74cb62
patch 8.2.0295: highlighting for :s wrong when using different separator
Bram Moolenaar <Bram@vim.org>
parents:
19241
diff
changeset
|
3600 if (do_search(NULL, pbuf[0], pbuf[0], pbuf + 1, (long)1, |
|
18358
34d5cd432cac
patch 8.1.2173: searchit() has too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
18315
diff
changeset
|
3601 search_options, NULL)) |
| 7 | 3602 retval = OK; |
| 3603 else | |
| 3604 { | |
| 3605 int found = 1; | |
| 3606 int cc; | |
| 3607 | |
| 3608 /* | |
| 3609 * try again, ignore case now | |
| 3610 */ | |
| 3611 p_ic = TRUE; | |
|
19475
5512aa74cb62
patch 8.2.0295: highlighting for :s wrong when using different separator
Bram Moolenaar <Bram@vim.org>
parents:
19241
diff
changeset
|
3612 if (!do_search(NULL, pbuf[0], pbuf[0], pbuf + 1, (long)1, |
|
18358
34d5cd432cac
patch 8.1.2173: searchit() has too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
18315
diff
changeset
|
3613 search_options, NULL)) |
| 7 | 3614 { |
| 3615 /* | |
| 3616 * Failed to find pattern, take a guess: "^func (" | |
| 3617 */ | |
| 3618 found = 2; | |
| 3619 (void)test_for_static(&tagp); | |
| 3620 cc = *tagp.tagname_end; | |
| 3621 *tagp.tagname_end = NUL; | |
| 3622 sprintf((char *)pbuf, "^%s\\s\\*(", tagp.tagname); | |
|
19475
5512aa74cb62
patch 8.2.0295: highlighting for :s wrong when using different separator
Bram Moolenaar <Bram@vim.org>
parents:
19241
diff
changeset
|
3623 if (!do_search(NULL, '/', '/', pbuf, (long)1, |
|
18358
34d5cd432cac
patch 8.1.2173: searchit() has too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
18315
diff
changeset
|
3624 search_options, NULL)) |
| 7 | 3625 { |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3626 // Guess again: "^char * \<func (" |
| 7 | 3627 sprintf((char *)pbuf, "^\\[#a-zA-Z_]\\.\\*\\<%s\\s\\*(", |
| 3628 tagp.tagname); | |
|
19475
5512aa74cb62
patch 8.2.0295: highlighting for :s wrong when using different separator
Bram Moolenaar <Bram@vim.org>
parents:
19241
diff
changeset
|
3629 if (!do_search(NULL, '/', '/', pbuf, (long)1, |
|
18358
34d5cd432cac
patch 8.1.2173: searchit() has too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
18315
diff
changeset
|
3630 search_options, NULL)) |
| 7 | 3631 found = 0; |
| 3632 } | |
| 3633 *tagp.tagname_end = cc; | |
| 3634 } | |
| 3635 if (found == 0) | |
| 3636 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
3637 emsg(_("E434: Can't find tag pattern")); |
| 7 | 3638 curwin->w_cursor.lnum = save_lnum; |
| 3639 } | |
| 3640 else | |
| 3641 { | |
| 3642 /* | |
| 3643 * Only give a message when really guessed, not when 'ic' | |
| 3644 * is set and match found while ignoring case. | |
| 3645 */ | |
| 3646 if (found == 2 || !save_p_ic) | |
| 3647 { | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
3648 msg(_("E435: Couldn't find tag, just guessing!")); |
| 7 | 3649 if (!msg_scrolled && msg_silent == 0) |
| 3650 { | |
| 3651 out_flush(); | |
|
18642
bbea1f108187
patch 8.1.2313: debugging where a delay comes from is not easy
Bram Moolenaar <Bram@vim.org>
parents:
18640
diff
changeset
|
3652 ui_delay(1010L, TRUE); |
| 7 | 3653 } |
| 3654 } | |
| 3655 retval = OK; | |
| 3656 } | |
| 3657 } | |
| 3658 p_ws = save_p_ws; | |
| 3659 p_ic = save_p_ic; | |
| 3660 p_scs = save_p_scs; | |
| 3661 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3662 // A search command may have positioned the cursor beyond the end |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3663 // of the line. May need to correct that here. |
| 7 | 3664 check_cursor(); |
| 3665 } | |
| 3666 else | |
| 3667 { | |
|
25262
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3668 int save_secure = secure; |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3669 |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3670 // Setup the sandbox for executing the command from the tags file. |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3671 secure = 1; |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3672 #ifdef HAVE_SANDBOX |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3673 ++sandbox; |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3674 #endif |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3675 curwin->w_cursor.lnum = 1; // start command in line 1 |
| 7 | 3676 do_cmdline_cmd(pbuf); |
| 3677 retval = OK; | |
|
25262
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3678 |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3679 // When the command has done something that is not allowed make |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3680 // sure the error message can be seen. |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3681 if (secure == 2) |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3682 wait_return(TRUE); |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3683 secure = save_secure; |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3684 #ifdef HAVE_SANDBOX |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3685 --sandbox; |
|
e9065d299e9b
patch 8.2.3167: get E12 in a job callback when searching for tags
Bram Moolenaar <Bram@vim.org>
parents:
24665
diff
changeset
|
3686 #endif |
| 7 | 3687 } |
| 3688 | |
|
23272
a84e7abb0c92
patch 8.2.2182: Vim9: value of 'magic' is still relevant
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
3689 magic_overruled = save_magic_overruled; |
| 7 | 3690 #ifdef FEAT_SEARCH_EXTRA |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3691 // restore no_hlsearch when keeping the old search pattern |
| 7 | 3692 if (search_options) |
|
13792
0e9b2971d7c3
patch 8.0.1768: SET_NO_HLSEARCH() used in a wrong way
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
3693 set_no_hlsearch(save_no_hlsearch); |
| 7 | 3694 #endif |
| 3695 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3696 // Return OK if jumped to another file (at least we found the file!). |
|
11476
c45fb081391c
patch 8.0.0621: :stag does not respect 'switchbuf'
Christian Brabandt <cb@256bit.org>
parents:
11329
diff
changeset
|
3697 if (getfile_result == GETFILE_OPEN_OTHER) |
| 7 | 3698 retval = OK; |
| 3699 | |
| 3700 if (retval == OK) | |
| 3701 { | |
| 3702 /* | |
| 3703 * For a help buffer: Put the cursor line at the top of the window, | |
| 3704 * the help subject will be below it. | |
| 3705 */ | |
| 3706 if (curbuf->b_help) | |
| 3707 set_topline(curwin, curwin->w_cursor.lnum); | |
| 3708 #ifdef FEAT_FOLDING | |
| 3709 if ((fdo_flags & FDO_TAG) && old_KeyTyped) | |
| 3710 foldOpenCursor(); | |
| 3711 #endif | |
| 3712 } | |
| 3713 | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
3714 #if defined(FEAT_QUICKFIX) |
| 2713 | 3715 if (g_do_tagpreview != 0 |
| 3716 && curwin != curwin_save && win_valid(curwin_save)) | |
| 7 | 3717 { |
|
17632
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3718 // Return cursor to where we were |
| 7 | 3719 validate_cursor(); |
| 3720 redraw_later(VALID); | |
| 3721 win_enter(curwin_save, TRUE); | |
| 3722 } | |
| 3723 #endif | |
| 3724 | |
| 3725 --RedrawingDisabled; | |
| 3726 } | |
| 3727 else | |
| 3728 { | |
| 3729 --RedrawingDisabled; | |
|
17632
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3730 got_int = FALSE; // don't want entering window to fail |
|
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3731 |
|
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3732 if (postponed_split) // close the window |
| 7 | 3733 { |
| 3734 win_close(curwin, FALSE); | |
| 3735 postponed_split = 0; | |
| 3736 } | |
|
18763
49b78d6465e5
patch 8.1.2371: FEAT_TEXT_PROP is a confusing name
Bram Moolenaar <Bram@vim.org>
parents:
18642
diff
changeset
|
3737 #if defined(FEAT_QUICKFIX) && defined(FEAT_PROP_POPUP) |
|
17632
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3738 else if (WIN_IS_POPUP(curwin)) |
|
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3739 { |
|
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3740 win_T *wp = curwin; |
|
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3741 |
|
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3742 if (win_valid(curwin_save)) |
|
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3743 win_enter(curwin_save, TRUE); |
|
20384
42ab4d40e78f
patch 8.2.0747: cannot forcefully close all popups
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
3744 popup_close(wp->w_id, FALSE); |
|
17632
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3745 } |
|
5278e5a2a4e3
patch 8.1.1813: ATTENTION prompt for a preview popup window
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
3746 #endif |
| 7 | 3747 } |
|
18763
49b78d6465e5
patch 8.1.2371: FEAT_TEXT_PROP is a confusing name
Bram Moolenaar <Bram@vim.org>
parents:
18642
diff
changeset
|
3748 #if defined(FEAT_QUICKFIX) && defined(FEAT_PROP_POPUP) |
|
17644
daa1dea1c1b3
patch 8.1.1819: :pedit does not work with a popup preview window
Bram Moolenaar <Bram@vim.org>
parents:
17632
diff
changeset
|
3749 if (WIN_IS_POPUP(curwin)) |
|
daa1dea1c1b3
patch 8.1.1819: :pedit does not work with a popup preview window
Bram Moolenaar <Bram@vim.org>
parents:
17632
diff
changeset
|
3750 // something went wrong, still in popup, but it can't have focus |
|
daa1dea1c1b3
patch 8.1.1819: :pedit does not work with a popup preview window
Bram Moolenaar <Bram@vim.org>
parents:
17632
diff
changeset
|
3751 win_enter(firstwin, TRUE); |
|
daa1dea1c1b3
patch 8.1.1819: :pedit does not work with a popup preview window
Bram Moolenaar <Bram@vim.org>
parents:
17632
diff
changeset
|
3752 #endif |
| 7 | 3753 |
| 3754 erret: | |
|
12477
68d7bc045dbe
patch 8.0.1118: FEAT_WINDOWS adds a lot of #ifdefs
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
3755 #if defined(FEAT_QUICKFIX) |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3756 g_do_tagpreview = 0; // For next time |
| 7 | 3757 #endif |
|
12680
429bf1b9292f
patch 8.0.1218: writing to freed memory in autocmd
Christian Brabandt <cb@256bit.org>
parents:
12477
diff
changeset
|
3758 vim_free(lbuf); |
| 7 | 3759 vim_free(pbuf); |
| 3760 vim_free(tofree_fname); | |
| 3761 vim_free(full_fname); | |
| 3762 | |
| 3763 return retval; | |
| 3764 } | |
| 3765 | |
| 3766 /* | |
| 3767 * If "expand" is TRUE, expand wildcards in fname. | |
| 3768 * If 'tagrelative' option set, change fname (name of file containing tag) | |
| 3769 * according to tag_fname (name of tag file containing fname). | |
| 3770 * Returns a pointer to allocated memory (or NULL when out of memory). | |
| 3771 */ | |
| 3772 static char_u * | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3773 expand_tag_fname(char_u *fname, char_u *tag_fname, int expand) |
| 7 | 3774 { |
| 3775 char_u *p; | |
| 3776 char_u *retval; | |
| 3777 char_u *expanded_fname = NULL; | |
| 3778 expand_T xpc; | |
| 3779 | |
| 3780 /* | |
| 3781 * Expand file name (for environment variables) when needed. | |
| 3782 */ | |
| 3783 if (expand && mch_has_wildcard(fname)) | |
| 3784 { | |
| 3785 ExpandInit(&xpc); | |
| 3786 xpc.xp_context = EXPAND_FILES; | |
| 3787 expanded_fname = ExpandOne(&xpc, (char_u *)fname, NULL, | |
| 3788 WILD_LIST_NOTFOUND|WILD_SILENT, WILD_EXPAND_FREE); | |
| 3789 if (expanded_fname != NULL) | |
| 3790 fname = expanded_fname; | |
| 3791 } | |
| 3792 | |
| 3793 if ((p_tr || curbuf->b_help) | |
| 3794 && !vim_isAbsName(fname) | |
| 3795 && (p = gettail(tag_fname)) != tag_fname) | |
| 3796 { | |
| 3797 retval = alloc(MAXPATHL); | |
| 3798 if (retval != NULL) | |
| 3799 { | |
| 3800 STRCPY(retval, tag_fname); | |
| 418 | 3801 vim_strncpy(retval + (p - tag_fname), fname, |
| 3802 MAXPATHL - (p - tag_fname) - 1); | |
| 7 | 3803 /* |
| 3804 * Translate names like "src/a/../b/file.c" into "src/b/file.c". | |
| 3805 */ | |
| 3806 simplify_filename(retval); | |
| 3807 } | |
| 3808 } | |
| 3809 else | |
| 3810 retval = vim_strsave(fname); | |
| 3811 | |
| 3812 vim_free(expanded_fname); | |
| 3813 | |
| 3814 return retval; | |
| 3815 } | |
| 3816 | |
| 3817 /* | |
| 3818 * Check if we have a tag for the buffer with name "buf_ffname". | |
| 3819 * This is a bit slow, because of the full path compare in fullpathcmp(). | |
| 3820 * Return TRUE if tag for file "fname" if tag file "tag_fname" is for current | |
| 3821 * file. | |
| 3822 */ | |
| 3823 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3824 test_for_current( |
| 7 | 3825 #ifdef FEAT_EMACS_TAGS |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3826 int is_etag, |
| 7 | 3827 #endif |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3828 char_u *fname, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3829 char_u *fname_end, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3830 char_u *tag_fname, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3831 char_u *buf_ffname) |
| 7 | 3832 { |
| 3833 int c; | |
| 3834 int retval = FALSE; | |
| 3835 char_u *fullname; | |
| 3836 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3837 if (buf_ffname != NULL) // if the buffer has a name |
| 7 | 3838 { |
| 3839 #ifdef FEAT_EMACS_TAGS | |
| 3840 if (is_etag) | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3841 c = 0; // to shut up GCC |
| 7 | 3842 else |
| 3843 #endif | |
| 3844 { | |
| 3845 c = *fname_end; | |
| 3846 *fname_end = NUL; | |
| 3847 } | |
| 3848 fullname = expand_tag_fname(fname, tag_fname, TRUE); | |
| 3849 if (fullname != NULL) | |
| 3850 { | |
|
16738
b52ea9c5f1db
patch 8.1.1371: cannot recover from a swap file
Bram Moolenaar <Bram@vim.org>
parents:
16511
diff
changeset
|
3851 retval = (fullpathcmp(fullname, buf_ffname, TRUE, TRUE) & FPC_SAME); |
| 7 | 3852 vim_free(fullname); |
| 3853 } | |
| 3854 #ifdef FEAT_EMACS_TAGS | |
| 3855 if (!is_etag) | |
| 3856 #endif | |
| 3857 *fname_end = c; | |
| 3858 } | |
| 3859 | |
| 3860 return retval; | |
| 3861 } | |
| 3862 | |
| 3863 /* | |
| 3864 * Find the end of the tagaddress. | |
| 3865 * Return OK if ";\"" is following, FAIL otherwise. | |
| 3866 */ | |
| 3867 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3868 find_extra(char_u **pp) |
| 7 | 3869 { |
| 3870 char_u *str = *pp; | |
|
19055
8645b73b3645
patch 8.2.0088: insufficient tests for tags; bug in using extra tag field
Bram Moolenaar <Bram@vim.org>
parents:
19033
diff
changeset
|
3871 char_u first_char = **pp; |
| 7 | 3872 |
|
15808
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3873 // Repeat for addresses separated with ';' |
| 7 | 3874 for (;;) |
| 3875 { | |
| 3876 if (VIM_ISDIGIT(*str)) | |
|
24665
661d15592d3c
patch 8.2.2871: unnessary VIM_ISDIGIT() calls, badly indented code
Bram Moolenaar <Bram@vim.org>
parents:
24594
diff
changeset
|
3877 str = skipdigits(str + 1); |
| 7 | 3878 else if (*str == '/' || *str == '?') |
| 3879 { | |
|
19892
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
3880 str = skip_regexp(str + 1, *str, FALSE); |
|
19055
8645b73b3645
patch 8.2.0088: insufficient tests for tags; bug in using extra tag field
Bram Moolenaar <Bram@vim.org>
parents:
19033
diff
changeset
|
3881 if (*str != first_char) |
| 7 | 3882 str = NULL; |
| 3883 else | |
| 3884 ++str; | |
| 3885 } | |
| 3886 else | |
|
15808
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3887 { |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3888 // not a line number or search string, look for terminator. |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3889 str = (char_u *)strstr((char *)str, "|;\""); |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3890 if (str != NULL) |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3891 { |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3892 ++str; |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3893 break; |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3894 } |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3895 |
|
37d31fc37a5a
patch 8.1.0911: tag line with Ex command cannot have extra fields
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
3896 } |
| 7 | 3897 if (str == NULL || *str != ';' |
| 3898 || !(VIM_ISDIGIT(str[1]) || str[1] == '/' || str[1] == '?')) | |
| 3899 break; | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3900 ++str; // skip ';' |
|
19055
8645b73b3645
patch 8.2.0088: insufficient tests for tags; bug in using extra tag field
Bram Moolenaar <Bram@vim.org>
parents:
19033
diff
changeset
|
3901 first_char = *str; |
| 7 | 3902 } |
| 3903 | |
| 3904 if (str != NULL && STRNCMP(str, ";\"", 2) == 0) | |
| 3905 { | |
| 3906 *pp = str; | |
| 3907 return OK; | |
| 3908 } | |
| 3909 return FAIL; | |
| 3910 } | |
| 3911 | |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3912 /* |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3913 * Free a single entry in a tag stack |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3914 */ |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3915 static void |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3916 tagstack_clear_entry(taggy_T *item) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3917 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3918 VIM_CLEAR(item->tagname); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3919 VIM_CLEAR(item->user_data); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3920 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
3921 |
| 7 | 3922 int |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3923 expand_tags( |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3924 int tagnames, // expand tag names |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3925 char_u *pat, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3926 int *num_file, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3927 char_u ***file) |
| 7 | 3928 { |
| 3929 int i; | |
|
25652
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3930 int extra_flag; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3931 char_u *name_buf; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3932 size_t name_buf_size = 100; |
| 7 | 3933 tagptrs_T t_p; |
| 3934 int ret; | |
| 3935 | |
|
25652
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3936 name_buf = alloc(name_buf_size); |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3937 if (name_buf == NULL) |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3938 return FAIL; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3939 |
| 7 | 3940 if (tagnames) |
|
25652
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3941 extra_flag = TAG_NAMES; |
| 7 | 3942 else |
|
25652
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3943 extra_flag = 0; |
| 7 | 3944 if (pat[0] == '/') |
| 3945 ret = find_tags(pat + 1, num_file, file, | |
|
25652
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3946 TAG_REGEXP | extra_flag | TAG_VERBOSE | TAG_NO_TAGFUNC, |
| 7 | 3947 TAG_MANY, curbuf->b_ffname); |
| 3948 else | |
| 3949 ret = find_tags(pat, num_file, file, | |
|
25652
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3950 TAG_REGEXP | extra_flag | TAG_VERBOSE | TAG_NO_TAGFUNC | TAG_NOIC, |
| 7 | 3951 TAG_MANY, curbuf->b_ffname); |
| 3952 if (ret == OK && !tagnames) | |
| 3953 { | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3954 // Reorganize the tags for display and matching as strings of: |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
3955 // "<tagname>\0<kind>\0<filename>\0" |
| 7 | 3956 for (i = 0; i < *num_file; i++) |
| 3957 { | |
|
25652
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3958 size_t len; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3959 |
| 7 | 3960 parse_match((*file)[i], &t_p); |
|
25652
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3961 len = t_p.tagname_end - t_p.tagname; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3962 if (len > name_buf_size - 3) |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3963 { |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3964 char_u *buf; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3965 |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3966 name_buf_size = len + 3; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3967 buf = vim_realloc(name_buf, name_buf_size); |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3968 if (buf == NULL) |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3969 { |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3970 vim_free(name_buf); |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3971 return FAIL; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3972 } |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3973 name_buf = buf; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3974 } |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3975 |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3976 mch_memmove(name_buf, t_p.tagname, len); |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3977 name_buf[len++] = 0; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3978 name_buf[len++] = (t_p.tagkind != NULL && *t_p.tagkind) |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3979 ? *t_p.tagkind : 'f'; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3980 name_buf[len++] = 0; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3981 mch_memmove((*file)[i] + len, t_p.fname, |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3982 t_p.fname_end - t_p.fname); |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3983 (*file)[i][len + (t_p.fname_end - t_p.fname)] = 0; |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3984 mch_memmove((*file)[i], name_buf, len); |
| 7 | 3985 } |
| 3986 } | |
|
25652
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3987 |
|
ca61340ac1b9
patch 8.2.3362: buffer overflow when completing long tag name
Bram Moolenaar <Bram@vim.org>
parents:
25587
diff
changeset
|
3988 vim_free(name_buf); |
| 7 | 3989 return ret; |
| 3990 } | |
| 179 | 3991 |
| 3992 #if defined(FEAT_EVAL) || defined(PROTO) | |
| 3993 /* | |
| 2185 | 3994 * Add a tag field to the dictionary "dict". |
| 3995 * Return OK or FAIL. | |
| 179 | 3996 */ |
| 3997 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3998 add_tag_field( |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3999 dict_T *dict, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
4000 char *field_name, |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4001 char_u *start, // start of the value |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4002 char_u *end) // after the value; can be NULL |
| 179 | 4003 { |
| 2770 | 4004 char_u *buf; |
| 188 | 4005 int len = 0; |
| 2770 | 4006 int retval; |
| 179 | 4007 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4008 // check that the field name doesn't exist yet |
| 2185 | 4009 if (dict_find(dict, (char_u *)field_name, -1) != NULL) |
| 4010 { | |
| 4011 if (p_verbose > 0) | |
| 4012 { | |
| 4013 verbose_enter(); | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
4014 smsg(_("Duplicate field name: %s"), field_name); |
| 2185 | 4015 verbose_leave(); |
| 4016 } | |
| 4017 return FAIL; | |
| 4018 } | |
| 2770 | 4019 buf = alloc(MAXPATHL); |
| 4020 if (buf == NULL) | |
| 4021 return FAIL; | |
| 188 | 4022 if (start != NULL) |
| 4023 { | |
| 211 | 4024 if (end == NULL) |
| 4025 { | |
| 4026 end = start + STRLEN(start); | |
| 4027 while (end > start && (end[-1] == '\r' || end[-1] == '\n')) | |
| 4028 --end; | |
| 4029 } | |
| 835 | 4030 len = (int)(end - start); |
| 2770 | 4031 if (len > MAXPATHL - 1) |
| 4032 len = MAXPATHL - 1; | |
| 418 | 4033 vim_strncpy(buf, start, len); |
| 188 | 4034 } |
| 179 | 4035 buf[len] = NUL; |
|
14301
3c80092eb211
patch 8.1.0166: using dict_add_nr_str() is clumsy
Christian Brabandt <cb@256bit.org>
parents:
14232
diff
changeset
|
4036 retval = dict_add_string(dict, field_name, buf); |
| 2770 | 4037 vim_free(buf); |
| 4038 return retval; | |
| 179 | 4039 } |
| 4040 | |
| 4041 /* | |
|
11225
d3415ec1cdaf
patch 8.0.0499: taglist() does not prioritize tags for a buffer
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
4042 * Add the tags matching the specified pattern "pat" to the list "list" |
|
d3415ec1cdaf
patch 8.0.0499: taglist() does not prioritize tags for a buffer
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
4043 * as a dictionary. Use "buf_fname" for priority, unless NULL. |
| 179 | 4044 */ |
| 4045 int | |
|
11225
d3415ec1cdaf
patch 8.0.0499: taglist() does not prioritize tags for a buffer
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
4046 get_tags(list_T *list, char_u *pat, char_u *buf_fname) |
| 179 | 4047 { |
| 4048 int num_matches, i, ret; | |
| 4049 char_u **matches, *p; | |
| 970 | 4050 char_u *full_fname; |
| 179 | 4051 dict_T *dict; |
| 4052 tagptrs_T tp; | |
| 4053 long is_static; | |
| 4054 | |
| 4055 ret = find_tags(pat, &num_matches, &matches, | |
|
11225
d3415ec1cdaf
patch 8.0.0499: taglist() does not prioritize tags for a buffer
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
4056 TAG_REGEXP | TAG_NOIC, (int)MAXCOL, buf_fname); |
| 179 | 4057 if (ret == OK && num_matches > 0) |
| 4058 { | |
| 4059 for (i = 0; i < num_matches; ++i) | |
| 4060 { | |
| 188 | 4061 parse_match(matches[i], &tp); |
| 4062 is_static = test_for_static(&tp); | |
| 4063 | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4064 // Skip pseudo-tag lines. |
| 188 | 4065 if (STRNCMP(tp.tagname, "!_TAG_", 6) == 0) |
|
19237
1a3ebc75cf39
patch 8.2.0177: memory leak in get_tags()
Bram Moolenaar <Bram@vim.org>
parents:
19195
diff
changeset
|
4066 { |
|
1a3ebc75cf39
patch 8.2.0177: memory leak in get_tags()
Bram Moolenaar <Bram@vim.org>
parents:
19195
diff
changeset
|
4067 vim_free(matches[i]); |
| 188 | 4068 continue; |
|
19237
1a3ebc75cf39
patch 8.2.0177: memory leak in get_tags()
Bram Moolenaar <Bram@vim.org>
parents:
19195
diff
changeset
|
4069 } |
| 188 | 4070 |
| 179 | 4071 if ((dict = dict_alloc()) == NULL) |
| 4072 ret = FAIL; | |
| 4073 if (list_append_dict(list, dict) == FAIL) | |
| 4074 ret = FAIL; | |
| 4075 | |
| 970 | 4076 full_fname = tag_full_fname(&tp); |
| 179 | 4077 if (add_tag_field(dict, "name", tp.tagname, tp.tagname_end) == FAIL |
| 970 | 4078 || add_tag_field(dict, "filename", full_fname, |
| 4079 NULL) == FAIL | |
| 179 | 4080 || add_tag_field(dict, "cmd", tp.command, |
| 4081 tp.command_end) == FAIL | |
| 4082 || add_tag_field(dict, "kind", tp.tagkind, | |
| 4083 tp.tagkind_end) == FAIL | |
|
14301
3c80092eb211
patch 8.1.0166: using dict_add_nr_str() is clumsy
Christian Brabandt <cb@256bit.org>
parents:
14232
diff
changeset
|
4084 || dict_add_number(dict, "static", is_static) == FAIL) |
| 179 | 4085 ret = FAIL; |
| 4086 | |
| 970 | 4087 vim_free(full_fname); |
| 4088 | |
| 179 | 4089 if (tp.command_end != NULL) |
| 4090 { | |
| 4091 for (p = tp.command_end + 3; | |
|
19617
5ce724c60c4c
patch 8.2.0365: tag kind can't be a multi-byte character
Bram Moolenaar <Bram@vim.org>
parents:
19475
diff
changeset
|
4092 *p != NUL && *p != '\n' && *p != '\r'; MB_PTR_ADV(p)) |
| 179 | 4093 { |
| 4094 if (p == tp.tagkind || (p + 5 == tp.tagkind | |
| 4095 && STRNCMP(p, "kind:", 5) == 0)) | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4096 // skip "kind:<kind>" and "<kind>" |
| 179 | 4097 p = tp.tagkind_end - 1; |
| 4098 else if (STRNCMP(p, "file:", 5) == 0) | |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4099 // skip "file:" (static tag) |
| 179 | 4100 p += 4; |
|
11129
f4ea50924c6d
patch 8.0.0452: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11127
diff
changeset
|
4101 else if (!VIM_ISWHITE(*p)) |
| 179 | 4102 { |
| 4103 char_u *s, *n; | |
| 188 | 4104 int len; |
| 179 | 4105 |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4106 // Add extra field as a dict entry. Fields are |
|
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4107 // separated by Tabs. |
| 179 | 4108 n = p; |
| 799 | 4109 while (*p != NUL && *p >= ' ' && *p < 127 && *p != ':') |
| 179 | 4110 ++p; |
| 835 | 4111 len = (int)(p - n); |
| 188 | 4112 if (*p == ':' && len > 0) |
| 4113 { | |
| 4114 s = ++p; | |
| 836 | 4115 while (*p != NUL && *p >= ' ') |
| 188 | 4116 ++p; |
| 4117 n[len] = NUL; | |
| 4118 if (add_tag_field(dict, (char *)n, s, p) == FAIL) | |
| 4119 ret = FAIL; | |
| 4120 n[len] = ':'; | |
| 4121 } | |
| 836 | 4122 else |
|
18814
7e7ec935e7c8
patch 8.1.2395: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18763
diff
changeset
|
4123 // Skip field without colon. |
| 836 | 4124 while (*p != NUL && *p >= ' ') |
| 4125 ++p; | |
| 1674 | 4126 if (*p == NUL) |
| 4127 break; | |
| 179 | 4128 } |
| 4129 } | |
| 4130 } | |
| 4131 | |
| 4132 vim_free(matches[i]); | |
| 4133 } | |
| 4134 vim_free(matches); | |
| 4135 } | |
| 4136 return ret; | |
| 4137 } | |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4138 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4139 /* |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4140 * Return information about 'tag' in dict 'retdict'. |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4141 */ |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4142 static void |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4143 get_tag_details(taggy_T *tag, dict_T *retdict) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4144 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4145 list_T *pos; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4146 fmark_T *fmark; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4147 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4148 dict_add_string(retdict, "tagname", tag->tagname); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4149 dict_add_number(retdict, "matchnr", tag->cur_match + 1); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4150 dict_add_number(retdict, "bufnr", tag->cur_fnum); |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4151 if (tag->user_data) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4152 dict_add_string(retdict, "user_data", tag->user_data); |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4153 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4154 if ((pos = list_alloc_id(aid_tagstack_from)) == NULL) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4155 return; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4156 dict_add_list(retdict, "from", pos); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4157 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4158 fmark = &tag->fmark; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4159 list_append_number(pos, |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4160 (varnumber_T)(fmark->fnum != -1 ? fmark->fnum : 0)); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4161 list_append_number(pos, (varnumber_T)fmark->mark.lnum); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4162 list_append_number(pos, (varnumber_T)(fmark->mark.col == MAXCOL ? |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4163 MAXCOL : fmark->mark.col + 1)); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4164 list_append_number(pos, (varnumber_T)fmark->mark.coladd); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4165 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4166 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4167 /* |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4168 * Return the tag stack entries of the specified window 'wp' in dictionary |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4169 * 'retdict'. |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4170 */ |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4171 void |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4172 get_tagstack(win_T *wp, dict_T *retdict) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4173 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4174 list_T *l; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4175 int i; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4176 dict_T *d; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4177 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4178 dict_add_number(retdict, "length", wp->w_tagstacklen); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4179 dict_add_number(retdict, "curidx", wp->w_tagstackidx + 1); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4180 l = list_alloc_id(aid_tagstack_items); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4181 if (l == NULL) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4182 return; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4183 dict_add_list(retdict, "items", l); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4184 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4185 for (i = 0; i < wp->w_tagstacklen; i++) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4186 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4187 if ((d = dict_alloc_id(aid_tagstack_details)) == NULL) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4188 return; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4189 list_append_dict(l, d); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4190 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4191 get_tag_details(&wp->w_tagstack[i], d); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4192 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4193 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4194 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4195 /* |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4196 * Free all the entries in the tag stack of the specified window |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4197 */ |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4198 static void |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4199 tagstack_clear(win_T *wp) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4200 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4201 int i; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4202 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4203 // Free the current tag stack |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4204 for (i = 0; i < wp->w_tagstacklen; ++i) |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4205 tagstack_clear_entry(&wp->w_tagstack[i]); |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4206 wp->w_tagstacklen = 0; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4207 wp->w_tagstackidx = 0; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4208 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4209 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4210 /* |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4211 * Remove the oldest entry from the tag stack and shift the rest of |
|
19195
2ef19eed524a
patch 8.2.0156: various typos in source files and tests
Bram Moolenaar <Bram@vim.org>
parents:
19055
diff
changeset
|
4212 * the entries to free up the top of the stack. |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4213 */ |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4214 static void |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4215 tagstack_shift(win_T *wp) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4216 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4217 taggy_T *tagstack = wp->w_tagstack; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4218 int i; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4219 |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4220 tagstack_clear_entry(&tagstack[0]); |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4221 for (i = 1; i < wp->w_tagstacklen; ++i) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4222 tagstack[i - 1] = tagstack[i]; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4223 wp->w_tagstacklen--; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4224 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4225 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4226 /* |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4227 * Push a new item to the tag stack |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4228 */ |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4229 static void |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4230 tagstack_push_item( |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4231 win_T *wp, |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4232 char_u *tagname, |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4233 int cur_fnum, |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4234 int cur_match, |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4235 pos_T mark, |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4236 int fnum, |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4237 char_u *user_data) |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4238 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4239 taggy_T *tagstack = wp->w_tagstack; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4240 int idx = wp->w_tagstacklen; // top of the stack |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4241 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4242 // if the tagstack is full: remove the oldest entry |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4243 if (idx >= TAGSTACKSIZE) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4244 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4245 tagstack_shift(wp); |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4246 idx = TAGSTACKSIZE - 1; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4247 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4248 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4249 wp->w_tagstacklen++; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4250 tagstack[idx].tagname = tagname; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4251 tagstack[idx].cur_fnum = cur_fnum; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4252 tagstack[idx].cur_match = cur_match; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4253 if (tagstack[idx].cur_match < 0) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4254 tagstack[idx].cur_match = 0; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4255 tagstack[idx].fmark.mark = mark; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4256 tagstack[idx].fmark.fnum = fnum; |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4257 tagstack[idx].user_data = user_data; |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4258 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4259 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4260 /* |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4261 * Add a list of items to the tag stack in the specified window |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4262 */ |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4263 static void |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4264 tagstack_push_items(win_T *wp, list_T *l) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4265 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4266 listitem_T *li; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4267 dictitem_T *di; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4268 dict_T *itemdict; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4269 char_u *tagname; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4270 pos_T mark; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4271 int fnum; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4272 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4273 // Add one entry at a time to the tag stack |
|
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
19617
diff
changeset
|
4274 FOR_ALL_LIST_ITEMS(l, li) |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4275 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4276 if (li->li_tv.v_type != VAR_DICT || li->li_tv.vval.v_dict == NULL) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4277 continue; // Skip non-dict items |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4278 itemdict = li->li_tv.vval.v_dict; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4279 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4280 // parse 'from' for the cursor position before the tag jump |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4281 if ((di = dict_find(itemdict, (char_u *)"from", -1)) == NULL) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4282 continue; |
|
23563
87671ccc6c6b
patch 8.2.2324: not easy to get mark en cursor posotion by character count
Bram Moolenaar <Bram@vim.org>
parents:
23505
diff
changeset
|
4283 if (list2fpos(&di->di_tv, &mark, &fnum, NULL, FALSE) != OK) |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4284 continue; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4285 if ((tagname = |
|
15146
7903dce131d4
patch 8.1.0583: using illogical name for get_dict_number()/get_dict_string()
Bram Moolenaar <Bram@vim.org>
parents:
15016
diff
changeset
|
4286 dict_get_string(itemdict, (char_u *)"tagname", TRUE)) == NULL) |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4287 continue; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4288 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4289 if (mark.col > 0) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4290 mark.col--; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4291 tagstack_push_item(wp, tagname, |
|
15146
7903dce131d4
patch 8.1.0583: using illogical name for get_dict_number()/get_dict_string()
Bram Moolenaar <Bram@vim.org>
parents:
15016
diff
changeset
|
4292 (int)dict_get_number(itemdict, (char_u *)"bufnr"), |
|
7903dce131d4
patch 8.1.0583: using illogical name for get_dict_number()/get_dict_string()
Bram Moolenaar <Bram@vim.org>
parents:
15016
diff
changeset
|
4293 (int)dict_get_number(itemdict, (char_u *)"matchnr") - 1, |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4294 mark, fnum, |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4295 dict_get_string(itemdict, (char_u *)"user_data", TRUE)); |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4296 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4297 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4298 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4299 /* |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4300 * Set the current index in the tag stack. Valid values are between 0 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4301 * and the stack length (inclusive). |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4302 */ |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4303 static void |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4304 tagstack_set_curidx(win_T *wp, int curidx) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4305 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4306 wp->w_tagstackidx = curidx; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4307 if (wp->w_tagstackidx < 0) // sanity check |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4308 wp->w_tagstackidx = 0; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4309 if (wp->w_tagstackidx > wp->w_tagstacklen) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4310 wp->w_tagstackidx = wp->w_tagstacklen; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4311 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4312 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4313 /* |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4314 * Set the tag stack entries of the specified window. |
|
19033
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4315 * 'action' is set to one of: |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4316 * 'a' for append |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4317 * 'r' for replace |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4318 * 't' for truncate |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4319 */ |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4320 int |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4321 set_tagstack(win_T *wp, dict_T *d, int action) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4322 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4323 dictitem_T *di; |
|
19033
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4324 list_T *l = NULL; |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4325 |
|
16447
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4326 #ifdef FEAT_EVAL |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4327 // not allowed to alter the tag stack entries from inside tagfunc |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4328 if (tfu_in_use) |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4329 { |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4330 emsg(_(recurmsg)); |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4331 return FAIL; |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4332 } |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4333 #endif |
|
54ffc82f38a8
patch 8.1.1228: not possible to process tags with a function
Bram Moolenaar <Bram@vim.org>
parents:
16378
diff
changeset
|
4334 |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4335 if ((di = dict_find(d, (char_u *)"items", -1)) != NULL) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4336 { |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4337 if (di->di_tv.v_type != VAR_LIST) |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4338 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
4339 emsg(_(e_listreq)); |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4340 return FAIL; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4341 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4342 l = di->di_tv.vval.v_list; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4343 } |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4344 |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4345 if ((di = dict_find(d, (char_u *)"curidx", -1)) != NULL) |
|
15211
de63593896b3
patch 8.1.0615: get_tv function names are not consistent
Bram Moolenaar <Bram@vim.org>
parents:
15146
diff
changeset
|
4346 tagstack_set_curidx(wp, (int)tv_get_number(&di->di_tv) - 1); |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4347 |
|
19033
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4348 if (action == 't') // truncate the stack |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4349 { |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4350 taggy_T *tagstack = wp->w_tagstack; |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4351 int tagstackidx = wp->w_tagstackidx; |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4352 int tagstacklen = wp->w_tagstacklen; |
|
19241
c53dbbf3229b
patch 8.2.0179: still a few places where range() does not work
Bram Moolenaar <Bram@vim.org>
parents:
19237
diff
changeset
|
4353 |
|
19033
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4354 // delete all the tag stack entries above the current entry |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4355 while (tagstackidx < tagstacklen) |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4356 tagstack_clear_entry(&tagstack[--tagstacklen]); |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4357 wp->w_tagstacklen = tagstacklen; |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4358 } |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4359 |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4360 if (l != NULL) |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4361 { |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4362 if (action == 'r') // replace the stack |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4363 tagstack_clear(wp); |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4364 |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4365 tagstack_push_items(wp, l); |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4366 // set the current index after the last entry |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4367 wp->w_tagstackidx = wp->w_tagstacklen; |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4368 } |
|
f0312cf3c792
patch 8.2.0077: settagstack() cannot truncate at current index
Bram Moolenaar <Bram@vim.org>
parents:
18814
diff
changeset
|
4369 |
|
15016
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4370 return OK; |
|
c338c91086b9
patch 8.1.0519: cannot save and restore the tag stack
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
4371 } |
| 179 | 4372 #endif |