1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
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.
11 * Code to handle tags and the tag stack
14 #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64)
15 # include "vimio.h" /* for lseek(), must be before vim.h */
21 * Structure to hold pointers to various items in a tag line.
23 typedef struct tag_pointers
25 /* filled in by parse_tag_line(): */
26 char_u
*tagname
; /* start of tag name (skip "file:") */
27 char_u
*tagname_end
; /* char after tag name */
28 char_u
*fname
; /* first char of file name */
29 char_u
*fname_end
; /* char after file name */
30 char_u
*command
; /* first char of command */
31 /* filled in by parse_match(): */
32 char_u
*command_end
; /* first char after command */
33 char_u
*tag_fname
; /* file name of the tags file. This is used
34 * when 'tr' is set. */
35 #ifdef FEAT_EMACS_TAGS
36 int is_etag
; /* TRUE for emacs tag */
38 char_u
*tagkind
; /* "kind:" value */
39 char_u
*tagkind_end
; /* end of tagkind */
43 * The matching tags are first stored in ga_match[]. In which one depends on
44 * the priority of the match.
45 * At the end, the matches from ga_match[] are concatenated, to make a list
48 #define MT_ST_CUR 0 /* static match in current file */
49 #define MT_GL_CUR 1 /* global match in current file */
50 #define MT_GL_OTH 2 /* global match in other file */
51 #define MT_ST_OTH 3 /* static match in other file */
52 #define MT_IC_ST_CUR 4 /* icase static match in current file */
53 #define MT_IC_GL_CUR 5 /* icase global match in current file */
54 #define MT_IC_GL_OTH 6 /* icase global match in other file */
55 #define MT_IC_ST_OTH 7 /* icase static match in other file */
56 #define MT_IC_OFF 4 /* add for icase match */
57 #define MT_RE_OFF 8 /* add for regexp match */
58 #define MT_MASK 7 /* mask for printing priority */
61 static char *mt_names
[MT_COUNT
/2] =
62 {"FSC", "F C", "F ", "FS ", " SC", " C", " ", " S "};
64 #define NOTAGFILE 99 /* return value for jumpto_tag */
65 static char_u
*nofile_fname
= NULL
; /* fname for NOTAGFILE error */
67 static void taglen_advance
__ARGS((int l
));
69 static int jumpto_tag
__ARGS((char_u
*lbuf
, int forceit
, int keep_help
));
70 #ifdef FEAT_EMACS_TAGS
71 static int parse_tag_line
__ARGS((char_u
*lbuf
, int is_etag
, tagptrs_T
*tagp
));
73 static int parse_tag_line
__ARGS((char_u
*lbuf
, tagptrs_T
*tagp
));
75 static int test_for_static
__ARGS((tagptrs_T
*));
76 static int parse_match
__ARGS((char_u
*lbuf
, tagptrs_T
*tagp
));
77 static char_u
*tag_full_fname
__ARGS((tagptrs_T
*tagp
));
78 static char_u
*expand_tag_fname
__ARGS((char_u
*fname
, char_u
*tag_fname
, int expand
));
79 #ifdef FEAT_EMACS_TAGS
80 static int test_for_current
__ARGS((int, char_u
*, char_u
*, char_u
*, char_u
*));
82 static int test_for_current
__ARGS((char_u
*, char_u
*, char_u
*, char_u
*));
84 static int find_extra
__ARGS((char_u
**pp
));
86 static char_u
*bottommsg
= (char_u
*)N_("E555: at bottom of tag stack");
87 static char_u
*topmsg
= (char_u
*)N_("E556: at top of tag stack");
89 static char_u
*tagmatchname
= NULL
; /* name of last used tag */
92 * We use ftello() here, if available. It returns off_t instead of long,
93 * which helps if long is 32 bit and off_t is 64 bit.
94 * We assume that when fseeko() is available then ftello() is too.
100 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
102 * Tag for preview window is remembered separately, to avoid messing up the
105 static taggy_T ptag_entry
= {NULL
, {INIT_POS_T(0, 0, 0), 0}, 0, 0};
109 * Jump to tag; handling of tag commands and tag stack
111 * *tag != NUL: ":tag {tag}", jump to new tag, add to tag stack
113 * type == DT_TAG: ":tag [tag]", jump to newer position or same tag again
114 * type == DT_HELP: like DT_TAG, but don't use regexp.
115 * type == DT_POP: ":pop" or CTRL-T, jump to old position
116 * type == DT_NEXT: jump to next match of same tag
117 * type == DT_PREV: jump to previous match of same tag
118 * type == DT_FIRST: jump to first match of same tag
119 * type == DT_LAST: jump to last match of same tag
120 * type == DT_SELECT: ":tselect [tag]", select tag from a list of all matches
121 * type == DT_JUMP: ":tjump [tag]", jump to tag or select tag from a list
122 * type == DT_CSCOPE: use cscope to find the tag
123 * type == DT_LTAG: use location list for displaying tag matches
124 * type == DT_FREE: free cached matches
126 * for cscope, returns TRUE if we jumped to tag or aborted, FALSE otherwise
129 do_tag(tag
, type
, count
, forceit
, verbose
)
130 char_u
*tag
; /* tag (pattern) to jump to */
133 int forceit
; /* :ta with ! */
134 int verbose
; /* print "tag not found" message */
136 taggy_T
*tagstack
= curwin
->w_tagstack
;
137 int tagstackidx
= curwin
->w_tagstackidx
;
138 int tagstacklen
= curwin
->w_tagstacklen
;
140 int cur_fnum
= curbuf
->b_fnum
;
141 int oldtagstackidx
= tagstackidx
;
142 int prevtagstackidx
= tagstackidx
;
143 int prev_num_matches
;
151 int no_regexp
= FALSE
;
152 int error_cur_match
= 0;
154 int save_pos
= FALSE
;
158 int jumped_to_tag
= FALSE
;
160 tagptrs_T tagp
, tagp2
;
162 char_u
**new_matches
;
165 int skip_msg
= FALSE
;
166 char_u
*buf_ffname
= curbuf
->b_ffname
; /* name to use for
167 priority computation */
170 /* remember the matches for the last used tag */
171 static int num_matches
= 0;
172 static int max_num_matches
= 0; /* limit used for match search */
173 static char_u
**matches
= NULL
;
179 /* remove the list of matches */
180 FreeWild(num_matches
, matches
);
196 prev_num_matches
= num_matches
;
197 free_string_option(nofile_fname
);
200 clearpos(&saved_fmark
.mark
); /* shutup gcc 4.0 */
201 saved_fmark
.fnum
= 0;
204 * Don't add a tag to the tagstack if 'tagstack' has been reset.
206 if ((!p_tgst
&& *tag
!= NUL
))
208 use_tagstack
= FALSE
;
213 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
215 use_tagstack
= FALSE
;
220 /* new pattern, add to the tag stack */
222 && (type
== DT_TAG
|| type
== DT_SELECT
|| type
== DT_JUMP
231 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
234 if (ptag_entry
.tagname
!= NULL
235 && STRCMP(ptag_entry
.tagname
, tag
) == 0)
237 /* Jumping to same tag: keep the current match, so that
238 * the CursorHold autocommand example works. */
239 cur_match
= ptag_entry
.cur_match
;
240 cur_fnum
= ptag_entry
.cur_fnum
;
244 vim_free(ptag_entry
.tagname
);
245 if ((ptag_entry
.tagname
= vim_strsave(tag
)) == NULL
)
253 * If the last used entry is not at the top, delete all tag
254 * stack entries above it.
256 while (tagstackidx
< tagstacklen
)
257 vim_free(tagstack
[--tagstacklen
].tagname
);
259 /* if the tagstack is full: remove oldest entry */
260 if (++tagstacklen
> TAGSTACKSIZE
)
262 tagstacklen
= TAGSTACKSIZE
;
263 vim_free(tagstack
[0].tagname
);
264 for (i
= 1; i
< tagstacklen
; ++i
)
265 tagstack
[i
- 1] = tagstack
[i
];
270 * put the tag name in the tag stack
272 if ((tagstack
[tagstackidx
].tagname
= vim_strsave(tag
)) == NULL
)
274 curwin
->w_tagstacklen
= tagstacklen
- 1;
277 curwin
->w_tagstacklen
= tagstacklen
;
279 save_pos
= TRUE
; /* save the cursor position below */
287 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
288 g_do_tagpreview
? ptag_entry
.tagname
== NULL
:
297 if (type
== DT_POP
) /* go to older position */
300 int old_KeyTyped
= KeyTyped
;
302 if ((tagstackidx
-= count
) < 0)
305 if (tagstackidx
+ count
== 0)
307 /* We did [num]^T from the bottom of the stack */
311 /* We weren't at the bottom of the stack, so jump all the
312 * way to the bottom now.
316 else if (tagstackidx
>= tagstacklen
) /* count == 0? */
322 /* Make a copy of the fmark, autocommands may invalidate the
323 * tagstack before it's used. */
324 saved_fmark
= tagstack
[tagstackidx
].fmark
;
325 if (saved_fmark
.fnum
!= curbuf
->b_fnum
)
328 * Jump to other file. If this fails (e.g. because the
329 * file was changed) keep original position in tag stack.
331 if (buflist_getfile(saved_fmark
.fnum
, saved_fmark
.mark
.lnum
,
332 GETF_SETMARK
, forceit
) == FAIL
)
334 tagstackidx
= oldtagstackidx
; /* back to old posn */
337 /* An BufReadPost autocommand may jump to the '" mark, but
338 * we don't what that here. */
339 curwin
->w_cursor
.lnum
= saved_fmark
.mark
.lnum
;
344 curwin
->w_cursor
.lnum
= saved_fmark
.mark
.lnum
;
346 curwin
->w_cursor
.col
= saved_fmark
.mark
.col
;
347 curwin
->w_set_curswant
= TRUE
;
350 if ((fdo_flags
& FDO_TAG
) && old_KeyTyped
)
354 /* remove the old list of matches */
355 FreeWild(num_matches
, matches
);
365 #if defined(FEAT_QUICKFIX)
370 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
373 cur_match
= ptag_entry
.cur_match
;
374 cur_fnum
= ptag_entry
.cur_fnum
;
379 /* ":tag" (no argument): go to newer pattern */
380 save_pos
= TRUE
; /* save the cursor position below */
381 if ((tagstackidx
+= count
- 1) >= tagstacklen
)
384 * Beyond the last one, just give an error message and
385 * go to the last one. Don't store the cursor
388 tagstackidx
= tagstacklen
- 1;
392 else if (tagstackidx
< 0) /* must have been count == 0 */
398 cur_match
= tagstack
[tagstackidx
].cur_match
;
399 cur_fnum
= tagstack
[tagstackidx
].cur_fnum
;
403 else /* go to other matching tag */
405 /* Save index for when selection is cancelled. */
406 prevtagstackidx
= tagstackidx
;
408 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
411 cur_match
= ptag_entry
.cur_match
;
412 cur_fnum
= ptag_entry
.cur_fnum
;
417 if (--tagstackidx
< 0)
419 cur_match
= tagstack
[tagstackidx
].cur_match
;
420 cur_fnum
= tagstack
[tagstackidx
].cur_fnum
;
424 case DT_FIRST
: cur_match
= count
- 1; break;
430 case DT_LAST
: cur_match
= MAXCOL
- 1; break;
431 case DT_NEXT
: cur_match
+= count
; break;
432 case DT_PREV
: cur_match
-= count
; break;
434 if (cur_match
>= MAXCOL
)
435 cur_match
= MAXCOL
- 1;
436 else if (cur_match
< 0)
438 EMSG(_("E425: Cannot go before first matching tag"));
441 cur_fnum
= curbuf
->b_fnum
;
446 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
449 if (type
!= DT_SELECT
&& type
!= DT_JUMP
)
451 ptag_entry
.cur_match
= cur_match
;
452 ptag_entry
.cur_fnum
= cur_fnum
;
459 * For ":tag [arg]" or ":tselect" remember position before the jump.
461 saved_fmark
= tagstack
[tagstackidx
].fmark
;
464 tagstack
[tagstackidx
].fmark
.mark
= curwin
->w_cursor
;
465 tagstack
[tagstackidx
].fmark
.fnum
= curbuf
->b_fnum
;
468 /* Curwin will change in the call to jumpto_tag() if ":stag" was
469 * used or an autocommand jumps to another window; store value of
470 * tagstackidx now. */
471 curwin
->w_tagstackidx
= tagstackidx
;
472 if (type
!= DT_SELECT
&& type
!= DT_JUMP
)
474 curwin
->w_tagstack
[tagstackidx
].cur_match
= cur_match
;
475 curwin
->w_tagstack
[tagstackidx
].cur_fnum
= cur_fnum
;
480 /* When not using the current buffer get the name of buffer "cur_fnum".
481 * Makes sure that the tag order doesn't change when using a remembered
482 * position for "cur_match". */
483 if (cur_fnum
!= curbuf
->b_fnum
)
485 buf_T
*buf
= buflist_findnr(cur_fnum
);
488 buf_ffname
= buf
->b_ffname
;
492 * Repeat searching for tags, when a file has not been found.
497 * When desired match not found yet, try to find it (and others).
500 name
= tagstack
[tagstackidx
].tagname
;
501 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
502 else if (g_do_tagpreview
)
503 name
= ptag_entry
.tagname
;
507 other_name
= (tagmatchname
== NULL
|| STRCMP(tagmatchname
, name
) != 0);
509 || (cur_match
>= num_matches
&& max_num_matches
!= MAXCOL
)
514 vim_free(tagmatchname
);
515 tagmatchname
= vim_strsave(name
);
519 * If a count is supplied to the ":tag <name>" command, then
520 * jump to count'th matching tag.
522 if (type
== DT_TAG
&& *tag
!= NUL
&& count
> 0)
523 cur_match
= count
- 1;
525 if (type
== DT_SELECT
|| type
== DT_JUMP
526 #if defined(FEAT_QUICKFIX)
530 cur_match
= MAXCOL
- 1;
531 max_num_matches
= cur_match
+ 1;
533 /* when the argument starts with '/', use it as a regexp */
534 if (!no_regexp
&& *name
== '/')
543 if (type
== DT_CSCOPE
)
547 flags
|= TAG_VERBOSE
;
549 flags
|= TAG_DONT_USE_TFU
;
551 if (find_tags(name
, &new_num_matches
, &new_matches
, flags
,
552 max_num_matches
, buf_ffname
) == OK
553 && new_num_matches
< max_num_matches
)
554 max_num_matches
= MAXCOL
; /* If less than max_num_matches
555 found: all matches found. */
557 /* If there already were some matches for the same name, move them
558 * to the start. Avoids that the order changes when using
559 * ":tnext" and jumping to another file. */
560 if (!new_tag
&& !other_name
)
562 /* Find the position of each old match in the new list. Need
563 * to use parse_match() to find the tag line. */
565 for (j
= 0; j
< num_matches
; ++j
)
567 parse_match(matches
[j
], &tagp
);
568 for (i
= idx
; i
< new_num_matches
; ++i
)
570 parse_match(new_matches
[i
], &tagp2
);
571 if (STRCMP(tagp
.tagname
, tagp2
.tagname
) == 0)
574 for (k
= i
; k
> idx
; --k
)
575 new_matches
[k
] = new_matches
[k
- 1];
576 new_matches
[idx
++] = p
;
582 FreeWild(num_matches
, matches
);
583 num_matches
= new_num_matches
;
584 matches
= new_matches
;
587 if (num_matches
<= 0)
590 EMSG2(_("E426: tag not found: %s"), name
);
591 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
597 int ask_for_selection
= FALSE
;
600 if (type
== DT_CSCOPE
&& num_matches
> 1)
603 ask_for_selection
= TRUE
;
607 if (type
== DT_SELECT
|| (type
== DT_JUMP
&& num_matches
> 1))
610 * List all the matching tags.
611 * Assume that the first match indicates how long the tags can
612 * be, and align the file names to that.
614 parse_match(matches
[0], &tagp
);
615 taglen
= (int)(tagp
.tagname_end
- tagp
.tagname
+ 2);
618 if (taglen
> Columns
- 25)
621 msg_didout
= FALSE
; /* overwrite previous message */
623 MSG_PUTS_ATTR(_(" # pri kind tag"), hl_attr(HLF_T
));
625 taglen_advance(taglen
);
626 MSG_PUTS_ATTR(_("file\n"), hl_attr(HLF_T
));
628 for (i
= 0; i
< num_matches
&& !got_int
; ++i
)
630 parse_match(matches
[i
], &tagp
);
632 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
634 && i
== ptag_entry
.cur_match
) ||
637 && i
== tagstack
[tagstackidx
].cur_match
)))
641 vim_snprintf((char *)IObuff
+ 1, IOSIZE
- 1,
643 mt_names
[matches
[i
][0] & MT_MASK
]);
645 if (tagp
.tagkind
!= NULL
)
646 msg_outtrans_len(tagp
.tagkind
,
647 (int)(tagp
.tagkind_end
- tagp
.tagkind
));
649 msg_outtrans_len_attr(tagp
.tagname
,
650 (int)(tagp
.tagname_end
- tagp
.tagname
),
653 taglen_advance(taglen
);
655 /* Find out the actual file name. If it is long, truncate
656 * it and put "..." in the middle */
657 p
= tag_full_fname(&tagp
);
660 msg_puts_long_attr(p
, hl_attr(HLF_D
));
669 /* print any extra fields */
670 command_end
= tagp
.command_end
;
671 if (command_end
!= NULL
)
674 while (*p
&& *p
!= '\r' && *p
!= '\n')
679 /* skip "file:" without a value (static tag) */
680 if (STRNCMP(p
, "file:", 5) == 0
681 && vim_isspace(p
[5]))
686 /* skip "kind:<kind>" and "<kind>" */
687 if (p
== tagp
.tagkind
688 || (p
+ 5 == tagp
.tagkind
689 && STRNCMP(p
, "kind:", 5) == 0))
691 p
= tagp
.tagkind_end
;
694 /* print all other extra fields */
695 attr
= hl_attr(HLF_CM
);
696 while (*p
&& *p
!= '\r' && *p
!= '\n')
698 if (msg_col
+ ptr2cells(p
) >= Columns
)
705 p
= msg_outtrans_one(p
, attr
);
708 msg_puts_attr((char_u
*)" ", attr
);
725 for (p
= tagp
.command
;
726 *p
&& *p
!= '\r' && *p
!= '\n'; ++p
)
732 * Put the info (in several lines) at column 15.
733 * Don't display "/^" and "?^".
736 if (*p
== '/' || *p
== '?')
742 /* Remove leading whitespace from pattern */
743 while (p
!= command_end
&& vim_isspace(*p
))
746 while (p
!= command_end
)
748 if (msg_col
+ (*p
== TAB
? 1 : ptr2cells(p
)) > Columns
)
754 /* skip backslash used for escaping command char */
755 if (*p
== '\\' && *(p
+ 1) == *tagp
.command
)
764 p
= msg_outtrans_one(p
, 0);
766 /* don't display the "$/;\"" and "$?;\"" */
767 if (p
== command_end
- 2 && *p
== '$'
768 && *(p
+ 1) == *tagp
.command
)
770 /* don't display matching '/' or '?' */
771 if (p
== command_end
- 1 && *p
== *tagp
.command
772 && (*p
== '/' || *p
== '?'))
780 got_int
= FALSE
; /* only stop the listing */
781 ask_for_selection
= TRUE
;
783 #if defined(FEAT_QUICKFIX) && defined(FEAT_EVAL)
784 else if (type
== DT_LTAG
)
787 char_u tag_name
[128 + 1];
788 char_u fname
[MAXPATHL
+ 1];
789 char_u cmd
[CMDBUFFSIZE
+ 1];
792 * Add the matching tags to the location list for the current
800 for (i
= 0; i
< num_matches
; ++i
)
806 parse_match(matches
[i
], &tagp
);
808 /* Save the tag name */
809 len
= (int)(tagp
.tagname_end
- tagp
.tagname
);
812 vim_strncpy(tag_name
, tagp
.tagname
, len
);
815 /* Save the tag file name */
816 p
= tag_full_fname(&tagp
);
823 * Get the line number or the search pattern used to locate
827 if (isdigit(*tagp
.command
))
828 /* Line number is used to locate the tag */
829 lnum
= atol((char *)tagp
.command
);
832 char_u
*cmd_start
, *cmd_end
;
834 /* Search pattern is used to locate the tag */
836 /* Locate the end of the command */
837 cmd_start
= tagp
.command
;
838 cmd_end
= tagp
.command_end
;
841 for (p
= tagp
.command
;
842 *p
&& *p
!= '\r' && *p
!= '\n'; ++p
)
848 * Now, cmd_end points to the character after the
849 * command. Adjust it to point to the last
850 * character of the command.
855 * Skip the '/' and '?' characters at the
856 * beginning and end of the search pattern.
858 if (*cmd_start
== '/' || *cmd_start
== '?')
861 if (*cmd_end
== '/' || *cmd_end
== '?')
868 * If "^" is present in the tag search pattern, then
871 if (*cmd_start
== '^')
879 * Precede the tag pattern with \V to make it very
885 cmd_len
= (int)(cmd_end
- cmd_start
+ 1);
886 if (cmd_len
> (CMDBUFFSIZE
- 5))
887 cmd_len
= CMDBUFFSIZE
- 5;
888 STRNCAT(cmd
, cmd_start
, cmd_len
);
891 if (cmd
[len
- 1] == '$')
894 * Replace '$' at the end of the search pattern
905 if ((dict
= dict_alloc()) == NULL
)
907 if (list_append_dict(list
, dict
) == FAIL
)
913 dict_add_nr_str(dict
, "text", 0L, tag_name
);
914 dict_add_nr_str(dict
, "filename", 0L, fname
);
915 dict_add_nr_str(dict
, "lnum", lnum
, NULL
);
917 dict_add_nr_str(dict
, "pattern", 0L, cmd
);
920 set_errorlist(curwin
, list
, ' ');
922 list_free(list
, TRUE
);
924 cur_match
= 0; /* Jump to the first tag */
928 if (ask_for_selection
== TRUE
)
931 * Ask to select a tag from the list.
933 i
= prompt_for_number(NULL
);
934 if (i
<= 0 || i
> num_matches
|| got_int
)
936 /* no valid choice: don't change anything */
939 tagstack
[tagstackidx
].fmark
= saved_fmark
;
940 tagstackidx
= prevtagstackidx
;
944 jumped_to_tag
= TRUE
;
951 if (cur_match
>= num_matches
)
953 /* Avoid giving this error when a file wasn't found and we're
954 * looking for a match in another file, which wasn't found.
955 * There will be an EMSG("file doesn't exist") below then. */
956 if ((type
== DT_NEXT
|| type
== DT_FIRST
)
957 && nofile_fname
== NULL
)
959 if (num_matches
== 1)
960 EMSG(_("E427: There is only one matching tag"));
962 EMSG(_("E428: Cannot go beyond last matching tag"));
965 cur_match
= num_matches
- 1;
969 tagstack
[tagstackidx
].cur_match
= cur_match
;
970 tagstack
[tagstackidx
].cur_fnum
= cur_fnum
;
973 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
974 else if (g_do_tagpreview
)
976 ptag_entry
.cur_match
= cur_match
;
977 ptag_entry
.cur_fnum
= cur_fnum
;
982 * Only when going to try the next match, report that the previous
983 * file didn't exist. Otherwise an EMSG() is given below.
985 if (nofile_fname
!= NULL
&& error_cur_match
!= cur_match
)
986 smsg((char_u
*)_("File \"%s\" does not exist"), nofile_fname
);
989 ic
= (matches
[cur_match
][0] & MT_IC_OFF
);
990 if (type
!= DT_SELECT
&& type
!= DT_JUMP
994 && (num_matches
> 1 || ic
)
997 /* Give an indication of the number of matching tags */
998 sprintf((char *)IObuff
, _("tag %d of %d%s"),
1001 max_num_matches
!= MAXCOL
? _(" or more") : "");
1003 STRCAT(IObuff
, _(" Using tag with different case!"));
1004 if ((num_matches
> prev_num_matches
|| new_tag
)
1008 msg_attr(IObuff
, hl_attr(HLF_W
));
1011 msg_scroll
= TRUE
; /* don't overwrite this message */
1014 give_warning(IObuff
, ic
);
1015 if (ic
&& !msg_scrolled
&& msg_silent
== 0)
1018 ui_delay(1000L, TRUE
);
1023 /* Let the SwapExists event know what tag we are jumping to. */
1024 vim_snprintf((char *)IObuff
, IOSIZE
, ":ta %s\r", name
);
1025 set_vim_var_string(VV_SWAPCOMMAND
, IObuff
, -1);
1029 * Jump to the desired match.
1031 i
= jumpto_tag(matches
[cur_match
], forceit
, type
!= DT_CSCOPE
);
1034 set_vim_var_string(VV_SWAPCOMMAND
, NULL
, -1);
1039 /* File not found: try again with another matching tag */
1040 if ((type
== DT_PREV
&& cur_match
> 0)
1041 || ((type
== DT_TAG
|| type
== DT_NEXT
1042 || type
== DT_FIRST
)
1043 && (max_num_matches
!= MAXCOL
1044 || cur_match
< num_matches
- 1)))
1046 error_cur_match
= cur_match
;
1049 if (type
== DT_PREV
)
1058 EMSG2(_("E429: File \"%s\" does not exist"), nofile_fname
);
1062 /* We may have jumped to another window, check that
1063 * tagstackidx is still valid. */
1064 if (use_tagstack
&& tagstackidx
> curwin
->w_tagstacklen
)
1065 tagstackidx
= curwin
->w_tagstackidx
;
1067 jumped_to_tag
= TRUE
;
1075 /* Only store the new index when using the tagstack and it's valid. */
1076 if (use_tagstack
&& tagstackidx
<= curwin
->w_tagstacklen
)
1077 curwin
->w_tagstackidx
= tagstackidx
;
1079 postponed_split
= 0; /* don't split next time */
1083 return jumped_to_tag
;
1095 vim_free(tagmatchname
);
1096 tagmatchname
= NULL
;
1109 msg_advance(13 + l
);
1113 * Print the tag stack
1117 exarg_T
*eap UNUSED
;
1121 taggy_T
*tagstack
= curwin
->w_tagstack
;
1122 int tagstackidx
= curwin
->w_tagstackidx
;
1123 int tagstacklen
= curwin
->w_tagstacklen
;
1125 /* Highlight title */
1126 MSG_PUTS_TITLE(_("\n # TO tag FROM line in file/text"));
1127 for (i
= 0; i
< tagstacklen
; ++i
)
1129 if (tagstack
[i
].tagname
!= NULL
)
1131 name
= fm_getname(&(tagstack
[i
].fmark
), 30);
1132 if (name
== NULL
) /* file name not available */
1136 sprintf((char *)IObuff
, "%c%2d %2d %-15s %5ld ",
1137 i
== tagstackidx
? '>' : ' ',
1139 tagstack
[i
].cur_match
+ 1,
1140 tagstack
[i
].tagname
,
1141 tagstack
[i
].fmark
.mark
.lnum
);
1142 msg_outtrans(IObuff
);
1143 msg_outtrans_attr(name
, tagstack
[i
].fmark
.fnum
== curbuf
->b_fnum
1144 ? hl_attr(HLF_D
) : 0);
1147 out_flush(); /* show one line at a time */
1149 if (tagstackidx
== tagstacklen
) /* idx at top of stack */
1153 /* When not using a CR for line separator, use vim_fgets() to read tag lines.
1154 * For the Mac use tag_fgets(). It can handle any line separator, but is much
1155 * slower than vim_fgets().
1158 # define tag_fgets vim_fgets
1161 #ifdef FEAT_TAG_BINS
1162 static int tag_strnicmp
__ARGS((char_u
*s1
, char_u
*s2
, size_t len
));
1165 * Compare two strings, for length "len", ignoring case the ASCII way.
1166 * return 0 for match, < 0 for smaller, > 0 for bigger
1167 * Make sure case is folded to uppercase in comparison (like for 'sort -f')
1170 tag_strnicmp(s1
, s2
, len
)
1179 i
= (int)TOUPPER_ASC(*s1
) - (int)TOUPPER_ASC(*s2
);
1181 return i
; /* this character different */
1183 break; /* strings match until NUL */
1188 return 0; /* strings match */
1193 * Structure to hold info about the tag pattern being used.
1197 char_u
*pat
; /* the pattern */
1198 int len
; /* length of pat[] */
1199 char_u
*head
; /* start of pattern head */
1200 int headlen
; /* length of head[] */
1201 regmatch_T regmatch
; /* regexp program, may be NULL */
1204 static void prepare_pats
__ARGS((pat_T
*pats
, int has_re
));
1207 * Extract info from the tag search pattern "pats->pat".
1210 prepare_pats(pats
, has_re
)
1214 pats
->head
= pats
->pat
;
1215 pats
->headlen
= pats
->len
;
1218 /* When the pattern starts with '^' or "\\<", binary searching can be
1219 * used (much faster). */
1220 if (pats
->pat
[0] == '^')
1221 pats
->head
= pats
->pat
+ 1;
1222 else if (pats
->pat
[0] == '\\' && pats
->pat
[1] == '<')
1223 pats
->head
= pats
->pat
+ 2;
1224 if (pats
->head
== pats
->pat
)
1227 for (pats
->headlen
= 0; pats
->head
[pats
->headlen
] != NUL
;
1229 if (vim_strchr((char_u
*)(p_magic
? ".[~*\\$" : "\\$"),
1230 pats
->head
[pats
->headlen
]) != NULL
)
1232 if (p_tl
!= 0 && pats
->headlen
> p_tl
) /* adjust for 'taglength' */
1233 pats
->headlen
= p_tl
;
1237 pats
->regmatch
.regprog
= vim_regcomp(pats
->pat
, p_magic
? RE_MAGIC
: 0);
1239 pats
->regmatch
.regprog
= NULL
;
1244 int len
; /* nr of chars of match[] to be compared */
1245 char_u match
[1]; /* actually longer */
1249 * find_tfu_tags() - call the user-defined function to generate a list of tags
1250 * used by find_tags().
1252 * Return OK if at least 1 tag has been successfully found, FAIL otherwise.
1253 * pat - used as the pattern supplied to the user-defined function,
1254 * ga - the tags will be placed here,
1255 * match_count - here the number of tags found will be placed,
1256 * flags - used to compose a string containing flags passed to the function.
1259 find_tfu_tags(pat
, ga
, match_count
, flags
)
1271 char_u flagString
[3];
1273 if (*curbuf
->b_p_tfu
== NUL
)
1277 args
[1] = flagString
;
1279 vim_snprintf((char *)flagString
, sizeof(flagString
),
1281 g_tag_at_cursor
? "c": "",
1282 flags
& TAG_INS_COMP
? "i": "");
1284 pos
= curwin
->w_cursor
;
1285 taglist
= call_func_retlist(curbuf
->b_p_tfu
, 2, args
, FALSE
);
1286 curwin
->w_cursor
= pos
; /* restore the cursor position */
1288 if (taglist
== NULL
)
1291 for (item
= taglist
->lv_first
; item
!= NULL
; item
= item
->li_next
)
1293 struct match_found
*mfp
;
1294 char_u
*res_name
, *res_fname
, *res_cmd
, *res_kind
;
1296 struct dict_iterator_S iter
;
1301 if (item
->li_tv
.v_type
!= VAR_DICT
)
1304 #ifdef FEAT_EMACS_TAGS
1315 dict_iterate_start(&item
->li_tv
, &iter
);
1316 while (NULL
!= (dict_key
= dict_iterate_next(&iter
, &tv
)))
1318 if (tv
->v_type
!= VAR_STRING
)
1321 len
+= STRLEN(tv
->vval
.v_string
) + 1; /* Space for "\tVALUE". */
1322 if (!STRCMP(dict_key
, "name"))
1324 res_name
= tv
->vval
.v_string
;
1327 if (!STRCMP(dict_key
, "filename"))
1329 res_fname
= tv
->vval
.v_string
;
1332 if (!STRCMP(dict_key
, "cmd"))
1334 res_cmd
= tv
->vval
.v_string
;
1338 if (!STRCMP(dict_key
, "kind"))
1340 res_kind
= tv
->vval
.v_string
;
1343 len
+= STRLEN(dict_key
) + 1; /* Other elements will be stored as "\tKEY:VALUE".
1344 * Allocate space for the key and the colon. */
1348 len
+= 2; /* need space for ;" */
1350 if (!res_name
|| !res_fname
|| !res_cmd
)
1353 mfp
= (struct match_found
*)alloc(
1354 (int)sizeof(struct match_found
) + len
);
1361 p
[1] = NUL
; /* no tag file name */
1363 #ifdef FEAT_EMACS_TAGS
1368 STRCPY(p
, res_name
);
1372 STRCPY(p
, res_fname
);
1387 STRCPY(p
, res_kind
);
1391 dict_iterate_start(&item
->li_tv
, &iter
);
1392 while (NULL
!= (dict_key
= dict_iterate_next(&iter
, &tv
)))
1394 if (tv
->v_type
!= VAR_STRING
)
1397 if (!STRCMP(dict_key
, "name"))
1399 if (!STRCMP(dict_key
, "filename"))
1401 if (!STRCMP(dict_key
, "cmd"))
1403 if (!STRCMP(dict_key
, "kind"))
1407 STRCPY(p
, dict_key
);
1411 STRCPY(p
, tv
->vval
.v_string
);
1416 /* FIXME:2010-04-24:llorens: Don't add identical matches. */
1417 if (ga_grow(ga
, 1) == OK
)
1419 ((struct match_found
**)(ga
->ga_data
)) [ga
->ga_len
++] = mfp
;
1428 list_free(taglist
, TRUE
);
1430 *match_count
= ntags
;
1435 * find_tags() - search for tags in tags files
1437 * Return FAIL if search completely failed (*num_matches will be 0, *matchesp
1438 * will be NULL), OK otherwise.
1440 * There is a priority in which type of tag is recognized.
1442 * 6. A static or global tag with a full matching tag for the current file.
1443 * 5. A global tag with a full matching tag for another file.
1444 * 4. A static tag with a full matching tag for another file.
1445 * 3. A static or global tag with an ignore-case matching tag for the
1447 * 2. A global tag with an ignore-case matching tag for another file.
1448 * 1. A static tag with an ignore-case matching tag for another file.
1450 * Tags in an emacs-style tags file are always global.
1453 * TAG_HELP only search for help tags
1454 * TAG_NAMES only return name of tag
1455 * TAG_REGEXP use "pat" as a regexp
1456 * TAG_NOIC don't always ignore case
1457 * TAG_KEEP_LANG keep language
1458 * TAG_DONT_USE_TFU do not invoke the 'tagfunc' command
1461 find_tags(pat
, num_matches
, matchesp
, flags
, mincount
, buf_ffname
)
1462 char_u
*pat
; /* pattern to search for */
1463 int *num_matches
; /* return: number of matches found */
1464 char_u
***matchesp
; /* return: array of matches found */
1466 int mincount
; /* MAXCOL: find all matches
1467 other: minimal number of matches */
1468 char_u
*buf_ffname
; /* name of buffer for priority */
1471 char_u
*lbuf
; /* line buffer */
1472 char_u
*tag_fname
; /* name of tag file */
1473 tagname_T tn
; /* info for get_tagfname() */
1474 int first_file
; /* trying first tag file */
1476 int did_open
= FALSE
; /* did open a tag file */
1477 int stop_searching
= FALSE
; /* stop when match found or error */
1478 int retval
= FAIL
; /* return value */
1479 int is_static
; /* current tag line is static */
1480 int is_current
; /* file name matches */
1481 int eof
= FALSE
; /* found end-of-file */
1485 #ifdef FEAT_TAG_BINS
1486 struct tag_search_info
/* Binary search file offsets */
1488 off_t low_offset
; /* offset for first char of first line that
1490 off_t high_offset
; /* offset of char after last line that could
1492 off_t curr_offset
; /* Current file offset in search range */
1493 off_t curr_offset_used
; /* curr_offset used when skipping back */
1494 off_t match_offset
; /* Where the binary search found a tag */
1495 int low_char
; /* first char at low_offset */
1496 int high_char
; /* first char at high_offset */
1505 TS_START
, /* at start of file */
1506 TS_LINEAR
/* linear searching forward, till EOF */
1507 #ifdef FEAT_TAG_BINS
1508 , TS_BINARY
, /* binary searching */
1509 TS_SKIP_BACK
, /* skipping backwards */
1510 TS_STEP_FORWARD
/* stepping forwards */
1512 } state
; /* Current search state */
1515 int match
; /* matches */
1516 int match_no_ic
= 0;/* matches with rm_ic == FALSE */
1517 int match_re
; /* match with regexp */
1520 #ifdef FEAT_EMACS_TAGS
1522 * Stack for included emacs-tags file.
1523 * It has a fixed size, to truncate cyclic includes. jw
1525 # define INCSTACK_SIZE 42
1530 } incstack
[INCSTACK_SIZE
];
1532 int incstack_idx
= 0; /* index in incstack */
1533 char_u
*ebuf
; /* additional buffer for etag fname */
1534 int is_etag
; /* current file is emaces style */
1537 struct match_found
*mfp
, *mfp2
;
1538 garray_T ga_match
[MT_COUNT
];
1539 int match_count
= 0; /* number of matches found */
1544 #ifdef FEAT_MULTI_LANG
1546 char_u
*help_lang_find
= NULL
; /* lang to be found */
1547 char_u help_lang
[3]; /* lang of current tags file */
1548 char_u
*saved_pat
= NULL
; /* copy of pat[] */
1551 /* Use two sets of variables for the pattern: "orgpat" holds the values
1552 * for the original pattern and "convpat" converted from 'encoding' to
1553 * encoding of the tags file. "pats" point to either one of these. */
1555 pat_T orgpat
; /* holds unconverted pattern info */
1557 pat_T convpat
; /* holds converted pattern info */
1561 #ifdef FEAT_TAG_BINS
1562 int findall
= (mincount
== MAXCOL
|| mincount
== TAG_MANY
);
1563 /* find all matching tags */
1564 int sort_error
= FALSE
; /* tags file not sorted */
1565 int linear
; /* do a linear search */
1566 int sortic
= FALSE
; /* tag file sorted in nocase */
1568 int line_error
= FALSE
; /* syntax error */
1569 int has_re
= (flags
& TAG_REGEXP
); /* regexp used */
1570 int help_only
= (flags
& TAG_HELP
);
1571 int name_only
= (flags
& TAG_NAMES
);
1572 int noic
= (flags
& TAG_NOIC
);
1573 int get_it_again
= FALSE
;
1575 int use_cscope
= (flags
& TAG_CSCOPE
);
1577 int verbose
= (flags
& TAG_VERBOSE
);
1578 int use_tfu
= ((flags
& TAG_DONT_USE_TFU
) == 0);
1579 static int tfu_call_level
= 0;
1581 help_save
= curbuf
->b_help
;
1585 vimconv
.vc_type
= CONV_NONE
;
1589 * Allocate memory for the buffers that are used
1591 lbuf
= alloc(LSIZE
);
1592 tag_fname
= alloc(MAXPATHL
+ 1);
1593 #ifdef FEAT_EMACS_TAGS
1594 ebuf
= alloc(LSIZE
);
1596 for (mtt
= 0; mtt
< MT_COUNT
; ++mtt
)
1597 ga_init2(&ga_match
[mtt
], (int)sizeof(struct match_found
*), 100);
1599 /* check for out of memory situation */
1600 if (lbuf
== NULL
|| tag_fname
== NULL
1601 #ifdef FEAT_EMACS_TAGS
1608 STRCPY(tag_fname
, "from cscope"); /* for error messages */
1612 * Initialize a few variables
1614 if (help_only
) /* want tags from help file */
1615 curbuf
->b_help
= TRUE
; /* will be restored later */
1617 pats
->len
= (int)STRLEN(pat
);
1618 #ifdef FEAT_MULTI_LANG
1621 /* When "@ab" is specified use only the "ab" language, otherwise
1622 * search all languages. */
1623 if (pats
->len
> 3 && pat
[pats
->len
- 3] == '@'
1624 && ASCII_ISALPHA(pat
[pats
->len
- 2])
1625 && ASCII_ISALPHA(pat
[pats
->len
- 1]))
1627 saved_pat
= vim_strnsave(pat
, pats
->len
- 3);
1628 if (saved_pat
!= NULL
)
1630 help_lang_find
= &pat
[pats
->len
- 2];
1631 pats
->pat
= saved_pat
;
1637 if (p_tl
!= 0 && pats
->len
> p_tl
) /* adjust for 'taglength' */
1640 prepare_pats(pats
, has_re
);
1642 #ifdef FEAT_TAG_BINS
1643 /* This is only to avoid a compiler warning for using search_info
1645 vim_memset(&search_info
, 0, (size_t)1);
1648 if (*curbuf
->b_p_tfu
!= NUL
&& use_tfu
&& tfu_call_level
== 0)
1651 retval
= find_tfu_tags(pat
, &ga_match
[0], &match_count
, flags
);
1657 * When finding a specified number of matches, first try with matching
1658 * case, so binary search can be used, and try ignore-case matches in a
1660 * When finding all matches, 'tagbsearch' is off, or there is no fixed
1661 * string to look for, ignore case right away to avoid going though the
1663 * When the tag file is case-fold sorted, it is either one or the other.
1664 * Only ignore case when TAG_NOIC not used or 'ignorecase' set.
1666 #ifdef FEAT_TAG_BINS
1667 pats
->regmatch
.rm_ic
= ((p_ic
|| !noic
)
1668 && (findall
|| pats
->headlen
== 0 || !p_tbs
));
1669 for (round
= 1; round
<= 2; ++round
)
1671 linear
= (pats
->headlen
== 0 || !p_tbs
|| round
== 2);
1673 pats
->regmatch
.rm_ic
= (p_ic
|| !noic
);
1677 * Try tag file names from tags option one by one.
1679 for (first_file
= TRUE
;
1683 get_tagfname(&tn
, first_file
, tag_fname
) == OK
;
1687 * A file that doesn't exist is silently ignored. Only when not a
1688 * single file is found, an error message is given (further on).
1692 fp
= NULL
; /* avoid GCC warning */
1696 #ifdef FEAT_MULTI_LANG
1699 /* Prefer help tags according to 'helplang'. Put the
1700 * two-letter language name in help_lang[]. */
1701 i
= (int)STRLEN(tag_fname
);
1702 if (i
> 3 && tag_fname
[i
- 3] == '-')
1703 STRCPY(help_lang
, tag_fname
+ i
- 2);
1705 STRCPY(help_lang
, "en");
1707 /* When searching for a specific language skip tags files
1708 * for other languages. */
1709 if (help_lang_find
!= NULL
1710 && STRICMP(help_lang
, help_lang_find
) != 0)
1713 /* For CTRL-] in a help file prefer a match with the same
1715 if ((flags
& TAG_KEEP_LANG
)
1716 && help_lang_find
== NULL
1717 && curbuf
->b_fname
!= NULL
1718 && (i
= (int)STRLEN(curbuf
->b_fname
)) > 4
1719 && curbuf
->b_fname
[i
- 1] == 'x'
1720 && curbuf
->b_fname
[i
- 4] == '.'
1721 && STRNICMP(curbuf
->b_fname
+ i
- 3, help_lang
, 2) == 0)
1726 for (s
= p_hlg
; *s
!= NUL
; ++s
)
1728 if (STRNICMP(s
, help_lang
, 2) == 0)
1731 if ((s
= vim_strchr(s
, ',')) == NULL
)
1734 if (s
== NULL
|| *s
== NUL
)
1736 /* Language not in 'helplang': use last, prefer English,
1737 * unless found already. */
1739 if (STRICMP(help_lang
, "en") != 0)
1746 if ((fp
= mch_fopen((char *)tag_fname
, "r")) == NULL
)
1752 smsg((char_u
*)_("Searching tags file %s"), tag_fname
);
1756 did_open
= TRUE
; /* remember that we found at least one file */
1758 state
= TS_START
; /* we're at the start of the file */
1759 #ifdef FEAT_EMACS_TAGS
1760 is_etag
= 0; /* default is: not emacs style */
1764 * Read and parse the lines in the file one by one
1768 line_breakcheck(); /* check for CTRL-C typed */
1769 #ifdef FEAT_INS_EXPAND
1770 if ((flags
& TAG_INS_COMP
)) /* Double brackets for gcc */
1771 ins_compl_check_keys(30);
1772 if (got_int
|| compl_interrupted
)
1777 stop_searching
= TRUE
;
1780 /* When mincount is TAG_MANY, stop when enough matches have been
1781 * found (for completion). */
1782 if (mincount
== TAG_MANY
&& match_count
>= TAG_MANY
)
1784 stop_searching
= TRUE
;
1790 #ifdef FEAT_TAG_BINS
1792 * For binary search: compute the next offset to use.
1794 if (state
== TS_BINARY
)
1796 offset
= search_info
.low_offset
+ ((search_info
.high_offset
1797 - search_info
.low_offset
) / 2);
1798 if (offset
== search_info
.curr_offset
)
1799 break; /* End the binary search without a match. */
1801 search_info
.curr_offset
= offset
;
1805 * Skipping back (after a match during binary search).
1807 else if (state
== TS_SKIP_BACK
)
1809 search_info
.curr_offset
-= LSIZE
* 2;
1810 if (search_info
.curr_offset
< 0)
1812 search_info
.curr_offset
= 0;
1814 state
= TS_STEP_FORWARD
;
1819 * When jumping around in the file, first read a line to find the
1820 * start of the next line.
1822 if (state
== TS_BINARY
|| state
== TS_SKIP_BACK
)
1824 /* Adjust the search file offset to the correct position */
1825 search_info
.curr_offset_used
= search_info
.curr_offset
;
1827 fseeko(fp
, search_info
.curr_offset
, SEEK_SET
);
1829 fseek(fp
, (long)search_info
.curr_offset
, SEEK_SET
);
1831 eof
= tag_fgets(lbuf
, LSIZE
, fp
);
1832 if (!eof
&& search_info
.curr_offset
!= 0)
1834 /* The explicit cast is to work around a bug in gcc 3.4.2
1835 * (repeated below). */
1836 search_info
.curr_offset
= ftell(fp
);
1837 if (search_info
.curr_offset
== search_info
.high_offset
)
1839 /* oops, gone a bit too far; try from low offset */
1841 fseeko(fp
, search_info
.low_offset
, SEEK_SET
);
1843 fseek(fp
, (long)search_info
.low_offset
, SEEK_SET
);
1845 search_info
.curr_offset
= search_info
.low_offset
;
1847 eof
= tag_fgets(lbuf
, LSIZE
, fp
);
1849 /* skip empty and blank lines */
1850 while (!eof
&& vim_isblankline(lbuf
))
1852 search_info
.curr_offset
= ftell(fp
);
1853 eof
= tag_fgets(lbuf
, LSIZE
, fp
);
1857 /* Hit end of file. Skip backwards. */
1858 state
= TS_SKIP_BACK
;
1859 search_info
.match_offset
= ftell(fp
);
1860 search_info
.curr_offset
= search_info
.curr_offset_used
;
1866 * Not jumping around in the file: Read the next line.
1871 /* skip empty and blank lines */
1876 eof
= cs_fgets(lbuf
, LSIZE
);
1879 eof
= tag_fgets(lbuf
, LSIZE
, fp
);
1880 } while (!eof
&& vim_isblankline(lbuf
));
1884 #ifdef FEAT_EMACS_TAGS
1885 if (incstack_idx
) /* this was an included file */
1888 fclose(fp
); /* end of this file ... */
1889 fp
= incstack
[incstack_idx
].fp
;
1890 STRCPY(tag_fname
, incstack
[incstack_idx
].etag_fname
);
1891 vim_free(incstack
[incstack_idx
].etag_fname
);
1892 is_etag
= 1; /* (only etags can include) */
1893 continue; /* ... continue with parent file */
1897 break; /* end of file */
1902 #ifdef FEAT_EMACS_TAGS
1904 * Emacs tags line with CTRL-L: New file name on next line.
1905 * The file name is followed by a ','.
1907 if (*lbuf
== Ctrl_L
) /* remember etag file name in ebuf */
1909 is_etag
= 1; /* in case at the start */
1911 if (!tag_fgets(ebuf
, LSIZE
, fp
))
1913 for (p
= ebuf
; *p
&& *p
!= ','; p
++)
1918 * atoi(p+1) is the number of bytes before the next ^L
1919 * unless it is an include statement.
1921 if (STRNCMP(p
+ 1, "include", 7) == 0
1922 && incstack_idx
< INCSTACK_SIZE
)
1924 /* Save current "fp" and "tag_fname" in the stack. */
1925 if ((incstack
[incstack_idx
].etag_fname
=
1926 vim_strsave(tag_fname
)) != NULL
)
1928 char_u
*fullpath_ebuf
;
1930 incstack
[incstack_idx
].fp
= fp
;
1933 /* Figure out "tag_fname" and "fp" to use for
1935 fullpath_ebuf
= expand_tag_fname(ebuf
,
1937 if (fullpath_ebuf
!= NULL
)
1939 fp
= mch_fopen((char *)fullpath_ebuf
, "r");
1942 if (STRLEN(fullpath_ebuf
) > LSIZE
)
1943 EMSG2(_("E430: Tag file path truncated for %s\n"), ebuf
);
1944 vim_strncpy(tag_fname
, fullpath_ebuf
,
1947 is_etag
= 0; /* we can include anything */
1949 vim_free(fullpath_ebuf
);
1953 /* Can't open the included file, skip it and
1954 * restore old value of "fp". */
1955 fp
= incstack
[incstack_idx
].fp
;
1956 vim_free(incstack
[incstack_idx
].etag_fname
);
1966 * When still at the start of the file, check for Emacs tags file
1967 * format, and for "not sorted" flag.
1969 if (state
== TS_START
)
1971 #ifdef FEAT_TAG_BINS
1973 * When there is no tag head, or ignoring case, need to do a
1975 * When no "!_TAG_" is found, default to binary search. If
1976 * the tag file isn't sorted, the second loop will find it.
1977 * When "!_TAG_FILE_SORTED" found: start binary search if
1979 * For cscope, it's always linear.
1982 if (linear
|| use_cscope
)
1987 else if (STRNCMP(lbuf
, "!_TAG_", 6) > 0)
1989 else if (STRNCMP(lbuf
, "!_TAG_FILE_SORTED\t", 18) == 0)
1991 /* Check sorted flag */
1992 if (lbuf
[18] == '1')
1994 else if (lbuf
[18] == '2')
1998 pats
->regmatch
.rm_ic
= (p_ic
|| !noic
);
2004 if (state
== TS_BINARY
&& pats
->regmatch
.rm_ic
&& !sortic
)
2006 /* binary search won't work for ignoring case, use linear
2015 #ifdef FEAT_TAG_BINS
2017 * When starting a binary search, get the size of the file and
2018 * compute the first offset.
2020 if (state
== TS_BINARY
)
2022 /* Get the tag file size (don't use mch_fstat(), it's not
2024 if ((filesize
= lseek(fileno(fp
),
2025 (off_t
)0L, SEEK_END
)) <= 0)
2029 lseek(fileno(fp
), (off_t
)0L, SEEK_SET
);
2031 /* Calculate the first read offset in the file. Start
2032 * the search in the middle of the file. */
2033 search_info
.low_offset
= 0;
2034 search_info
.low_char
= 0;
2035 search_info
.high_offset
= filesize
;
2036 search_info
.curr_offset
= 0;
2037 search_info
.high_char
= 0xff;
2045 if (lbuf
[0] == '!' && pats
== &orgpat
2046 && STRNCMP(lbuf
, "!_TAG_FILE_ENCODING\t", 20) == 0)
2048 /* Convert the search pattern from 'encoding' to the
2049 * specified encoding. */
2050 for (p
= lbuf
+ 20; *p
> ' ' && *p
< 127; ++p
)
2053 convert_setup(&vimconv
, p_enc
, lbuf
+ 20);
2054 if (vimconv
.vc_type
!= CONV_NONE
)
2056 convpat
.pat
= string_convert(&vimconv
, pats
->pat
, NULL
);
2057 if (convpat
.pat
!= NULL
)
2060 pats
->len
= (int)STRLEN(pats
->pat
);
2061 prepare_pats(pats
, has_re
);
2062 pats
->regmatch
.rm_ic
= orgpat
.regmatch
.rm_ic
;
2066 /* Prepare for converting a match the other way around. */
2067 convert_setup(&vimconv
, lbuf
+ 20, p_enc
);
2073 * Figure out where the different strings are in this line.
2074 * For "normal" tags: Do a quick check if the tag matches.
2075 * This speeds up tag searching a lot!
2078 #ifdef FEAT_EMACS_TAGS
2083 tagp
.tagname
= lbuf
;
2084 #ifdef FEAT_TAG_ANYWHITE
2085 tagp
.tagname_end
= skiptowhite(lbuf
);
2086 if (*tagp
.tagname_end
== NUL
) /* corrupted tag line */
2088 tagp
.tagname_end
= vim_strchr(lbuf
, TAB
);
2089 if (tagp
.tagname_end
== NULL
) /* corrupted tag line */
2096 #ifdef FEAT_TAG_OLDSTATIC
2098 * Check for old style static tag: "file:tag file .."
2101 for (p
= lbuf
; p
< tagp
.tagname_end
; ++p
)
2105 if (tagp
.fname
== NULL
)
2106 #ifdef FEAT_TAG_ANYWHITE
2107 tagp
.fname
= skipwhite(tagp
.tagname_end
);
2109 tagp
.fname
= tagp
.tagname_end
+ 1;
2111 if ( fnamencmp(lbuf
, tagp
.fname
, p
- lbuf
) == 0
2112 #ifdef FEAT_TAG_ANYWHITE
2113 && vim_iswhite(tagp
.fname
[p
- lbuf
])
2115 && tagp
.fname
[p
- lbuf
] == TAB
2120 tagp
.tagname
= p
+ 1;
2128 * Skip this line if the length of the tag is different and
2129 * there is no regexp, or the tag is too short.
2131 cmplen
= (int)(tagp
.tagname_end
- tagp
.tagname
);
2132 if (p_tl
!= 0 && cmplen
> p_tl
) /* adjust for 'taglength' */
2134 if (has_re
&& pats
->headlen
< cmplen
)
2135 cmplen
= pats
->headlen
;
2136 else if (state
== TS_LINEAR
&& pats
->headlen
!= cmplen
)
2139 #ifdef FEAT_TAG_BINS
2140 if (state
== TS_BINARY
)
2143 * Simplistic check for unsorted tags file.
2145 i
= (int)tagp
.tagname
[0];
2147 i
= (int)TOUPPER_ASC(tagp
.tagname
[0]);
2148 if (i
< search_info
.low_char
|| i
> search_info
.high_char
)
2152 * Compare the current tag with the searched tag.
2155 tagcmp
= tag_strnicmp(tagp
.tagname
, pats
->head
,
2158 tagcmp
= STRNCMP(tagp
.tagname
, pats
->head
, cmplen
);
2161 * A match with a shorter tag means to search forward.
2162 * A match with a longer tag means to search backward.
2166 if (cmplen
< pats
->headlen
)
2168 else if (cmplen
> pats
->headlen
)
2174 /* We've located the tag, now skip back and search
2175 * forward until the first matching tag is found.
2177 state
= TS_SKIP_BACK
;
2178 search_info
.match_offset
= search_info
.curr_offset
;
2183 search_info
.curr_offset
= ftell(fp
);
2184 if (search_info
.curr_offset
< search_info
.high_offset
)
2186 search_info
.low_offset
= search_info
.curr_offset
;
2188 search_info
.low_char
=
2189 TOUPPER_ASC(tagp
.tagname
[0]);
2191 search_info
.low_char
= tagp
.tagname
[0];
2196 && search_info
.curr_offset
!= search_info
.high_offset
)
2198 search_info
.high_offset
= search_info
.curr_offset
;
2200 search_info
.high_char
=
2201 TOUPPER_ASC(tagp
.tagname
[0]);
2203 search_info
.high_char
= tagp
.tagname
[0];
2207 /* No match yet and are at the end of the binary search. */
2210 else if (state
== TS_SKIP_BACK
)
2212 if (MB_STRNICMP(tagp
.tagname
, pats
->head
, cmplen
) != 0)
2213 state
= TS_STEP_FORWARD
;
2215 /* Have to skip back more. Restore the curr_offset
2216 * used, otherwise we get stuck at a long line. */
2217 search_info
.curr_offset
= search_info
.curr_offset_used
;
2220 else if (state
== TS_STEP_FORWARD
)
2222 if (MB_STRNICMP(tagp
.tagname
, pats
->head
, cmplen
) != 0)
2224 if ((off_t
)ftell(fp
) > search_info
.match_offset
)
2225 break; /* past last match */
2227 continue; /* before first match */
2232 /* skip this match if it can't match */
2233 if (MB_STRNICMP(tagp
.tagname
, pats
->head
, cmplen
) != 0)
2237 * Can be a matching tag, isolate the file name and command.
2239 #ifdef FEAT_TAG_OLDSTATIC
2240 if (tagp
.fname
== NULL
)
2242 #ifdef FEAT_TAG_ANYWHITE
2243 tagp
.fname
= skipwhite(tagp
.tagname_end
);
2245 tagp
.fname
= tagp
.tagname_end
+ 1;
2247 #ifdef FEAT_TAG_ANYWHITE
2248 tagp
.fname_end
= skiptowhite(tagp
.fname
);
2249 tagp
.command
= skipwhite(tagp
.fname_end
);
2250 if (*tagp
.command
== NUL
)
2252 tagp
.fname_end
= vim_strchr(tagp
.fname
, TAB
);
2253 tagp
.command
= tagp
.fname_end
+ 1;
2254 if (tagp
.fname_end
== NULL
)
2261 i
= parse_tag_line(lbuf
,
2262 #ifdef FEAT_EMACS_TAGS
2272 #ifdef FEAT_EMACS_TAGS
2277 * First try matching with the pattern literally (also when it is
2280 cmplen
= (int)(tagp
.tagname_end
- tagp
.tagname
);
2281 if (p_tl
!= 0 && cmplen
> p_tl
) /* adjust for 'taglength' */
2283 /* if tag length does not match, don't try comparing */
2284 if (pats
->len
!= cmplen
)
2288 if (pats
->regmatch
.rm_ic
)
2290 match
= (MB_STRNICMP(tagp
.tagname
, pats
->pat
, cmplen
) == 0);
2292 match_no_ic
= (STRNCMP(tagp
.tagname
, pats
->pat
,
2296 match
= (STRNCMP(tagp
.tagname
, pats
->pat
, cmplen
) == 0);
2300 * Has a regexp: Also find tags matching regexp.
2303 if (!match
&& pats
->regmatch
.regprog
!= NULL
)
2307 cc
= *tagp
.tagname_end
;
2308 *tagp
.tagname_end
= NUL
;
2309 match
= vim_regexec(&pats
->regmatch
, tagp
.tagname
, (colnr_T
)0);
2312 matchoff
= (int)(pats
->regmatch
.startp
[0] - tagp
.tagname
);
2313 if (pats
->regmatch
.rm_ic
)
2315 pats
->regmatch
.rm_ic
= FALSE
;
2316 match_no_ic
= vim_regexec(&pats
->regmatch
, tagp
.tagname
,
2318 pats
->regmatch
.rm_ic
= TRUE
;
2321 *tagp
.tagname_end
= cc
;
2326 * If a match is found, add it to ga_match[].
2333 /* Don't change the ordering, always use the same table. */
2339 /* Decide in which array to store this match. */
2340 is_current
= test_for_current(
2341 #ifdef FEAT_EMACS_TAGS
2344 tagp
.fname
, tagp
.fname_end
, tag_fname
,
2346 #ifdef FEAT_EMACS_TAGS
2348 if (!is_etag
) /* emacs tags are never static */
2351 #ifdef FEAT_TAG_OLDSTATIC
2352 if (tagp
.tagname
!= lbuf
)
2353 is_static
= TRUE
; /* detected static tag before */
2356 is_static
= test_for_static(&tagp
);
2359 /* decide in which of the sixteen tables to store this
2375 if (pats
->regmatch
.rm_ic
&& !match_no_ic
)
2382 * Add the found match in ga_match[mtt], avoiding duplicates.
2383 * Store the info we need later, which depends on the kind of
2384 * tags we are dealing with.
2386 if (ga_grow(&ga_match
[mtt
], 1) == OK
)
2389 char_u
*conv_line
= NULL
;
2390 char_u
*lbuf_line
= lbuf
;
2392 if (vimconv
.vc_type
!= CONV_NONE
)
2394 /* Convert the tag line from the encoding of the tags
2395 * file to 'encoding'. Then parse the line again. */
2396 conv_line
= string_convert(&vimconv
, lbuf
, NULL
);
2397 if (conv_line
!= NULL
)
2399 if (parse_tag_line(conv_line
,
2400 #ifdef FEAT_EMACS_TAGS
2404 lbuf_line
= conv_line
;
2406 /* doesn't work, go back to unconverted line. */
2407 (void)parse_tag_line(lbuf
,
2408 #ifdef FEAT_EMACS_TAGS
2415 # define lbuf_line lbuf
2419 #ifdef FEAT_MULTI_LANG
2425 * Append the help-heuristic number after the
2426 * tagname, for sorting it later.
2428 *tagp
.tagname_end
= NUL
;
2429 len
= (int)(tagp
.tagname_end
- tagp
.tagname
);
2430 mfp
= (struct match_found
*)
2431 alloc((int)sizeof(struct match_found
) + len
2435 /* "len" includes the language and the NUL, but
2436 * not the priority. */
2437 mfp
->len
= len
+ ML_EXTRA
+ 1;
2438 #define ML_HELP_LEN 6
2440 STRCPY(p
, tagp
.tagname
);
2441 #ifdef FEAT_MULTI_LANG
2443 STRCPY(p
+ len
+ 1, help_lang
);
2445 sprintf((char *)p
+ len
+ 1 + ML_EXTRA
, "%06d",
2446 help_heuristic(tagp
.tagname
,
2447 match_re
? matchoff
: 0, !match_no_ic
)
2448 #ifdef FEAT_MULTI_LANG
2453 *tagp
.tagname_end
= TAB
;
2459 char_u
*temp_end
= tagp
.command
;
2461 if (*temp_end
== '/')
2462 while (*temp_end
&& *temp_end
!= '\r'
2463 && *temp_end
!= '\n'
2464 && *temp_end
!= '$')
2467 if (tagp
.command
+ 2 < temp_end
)
2469 len
= (int)(temp_end
- tagp
.command
- 2);
2470 mfp
= (struct match_found
*)alloc(
2471 (int)sizeof(struct match_found
) + len
);
2474 mfp
->len
= len
+ 1; /* include the NUL */
2476 vim_strncpy(p
, tagp
.command
+ 2, len
);
2481 get_it_again
= FALSE
;
2485 len
= (int)(tagp
.tagname_end
- tagp
.tagname
);
2486 mfp
= (struct match_found
*)alloc(
2487 (int)sizeof(struct match_found
) + len
);
2490 mfp
->len
= len
+ 1; /* include the NUL */
2492 vim_strncpy(p
, tagp
.tagname
, len
);
2495 /* if wanted, re-read line to get long form too */
2497 get_it_again
= p_sft
;
2502 /* Save the tag in a buffer.
2503 * Emacs tag: <mtt><tag_fname><NUL><ebuf><NUL><lbuf>
2504 * other tag: <mtt><tag_fname><NUL><NUL><lbuf>
2505 * without Emacs tags: <mtt><tag_fname><NUL><lbuf>
2507 len
= (int)STRLEN(tag_fname
)
2508 + (int)STRLEN(lbuf_line
) + 3;
2509 #ifdef FEAT_EMACS_TAGS
2511 len
+= (int)STRLEN(ebuf
) + 1;
2515 mfp
= (struct match_found
*)alloc(
2516 (int)sizeof(struct match_found
) + len
);
2522 STRCPY(p
+ 1, tag_fname
);
2523 #ifdef BACKSLASH_IN_FILENAME
2524 /* Ignore differences in slashes, avoid adding
2525 * both path/file and path\file. */
2526 slash_adjust(p
+ 1);
2528 s
= p
+ 1 + STRLEN(tag_fname
) + 1;
2529 #ifdef FEAT_EMACS_TAGS
2533 s
+= STRLEN(ebuf
) + 1;
2538 STRCPY(s
, lbuf_line
);
2545 * Don't add identical matches.
2546 * This can take a lot of time when finding many
2547 * matches, check for CTRL-C now and then.
2548 * Add all cscope tags, because they are all listed.
2555 for (i
= ga_match
[mtt
].ga_len
; --i
>= 0 && !got_int
; )
2557 mfp2
= ((struct match_found
**)
2558 (ga_match
[mtt
].ga_data
))[i
];
2559 if (mfp2
->len
== mfp
->len
2560 && vim_memcmp(mfp2
->match
, mfp
->match
,
2561 (size_t)mfp
->len
) == 0)
2567 ((struct match_found
**)(ga_match
[mtt
].ga_data
))
2568 [ga_match
[mtt
].ga_len
++] = mfp
;
2575 /* Note: this makes the values in "tagp" invalid! */
2576 vim_free(conv_line
);
2579 else /* Out of memory! Just forget about the rest. */
2582 stop_searching
= TRUE
;
2587 if (use_cscope
&& eof
)
2594 EMSG2(_("E431: Format error in tags file \"%s\""), tag_fname
);
2598 EMSGN(_("Before byte %ld"), (long)ftell(fp
));
2599 stop_searching
= TRUE
;
2607 #ifdef FEAT_EMACS_TAGS
2608 while (incstack_idx
)
2611 fclose(incstack
[incstack_idx
].fp
);
2612 vim_free(incstack
[incstack_idx
].etag_fname
);
2616 if (pats
== &convpat
)
2618 /* Go back from converted pattern to original pattern. */
2619 vim_free(pats
->pat
);
2620 vim_free(pats
->regmatch
.regprog
);
2621 orgpat
.regmatch
.rm_ic
= pats
->regmatch
.rm_ic
;
2624 if (vimconv
.vc_type
!= CONV_NONE
)
2625 convert_setup(&vimconv
, NULL
, NULL
);
2628 #ifdef FEAT_TAG_BINS
2631 EMSG2(_("E432: Tags file not sorted: %s"), tag_fname
);
2637 * Stop searching if sufficient tags have been found.
2639 if (match_count
>= mincount
)
2642 stop_searching
= TRUE
;
2646 if (stop_searching
|| use_cscope
)
2652 } /* end of for-each-file loop */
2659 #ifdef FEAT_TAG_BINS
2660 /* stop searching when already did a linear search, or when TAG_NOIC
2661 * used, and 'ignorecase' not set or already did case-ignore search */
2662 if (stop_searching
|| linear
|| (!p_ic
&& noic
) || pats
->regmatch
.rm_ic
)
2668 pats
->regmatch
.rm_ic
= TRUE
; /* try another time while ignoring case */
2672 if (!stop_searching
)
2674 if (!did_open
&& verbose
) /* never opened any tags file */
2675 EMSG(_("E433: No tags file"));
2676 retval
= OK
; /* It's OK even when no tag found */
2681 vim_free(pats
->regmatch
.regprog
);
2682 vim_free(tag_fname
);
2683 #ifdef FEAT_EMACS_TAGS
2688 * Move the matches from the ga_match[] arrays into one list of
2689 * matches. When retval == FAIL, free the matches.
2694 if (match_count
> 0)
2695 matches
= (char_u
**)lalloc((long_u
)(match_count
* sizeof(char_u
*)),
2700 for (mtt
= 0; mtt
< MT_COUNT
; ++mtt
)
2702 for (i
= 0; i
< ga_match
[mtt
].ga_len
; ++i
)
2704 mfp
= ((struct match_found
**)(ga_match
[mtt
].ga_data
))[i
];
2705 if (matches
== NULL
)
2709 /* To avoid allocating memory again we turn the struct
2710 * match_found into a string. For help the priority was not
2711 * included in the length. */
2712 mch_memmove(mfp
, mfp
->match
,
2713 (size_t)(mfp
->len
+ (help_only
? ML_HELP_LEN
: 0)));
2714 matches
[match_count
++] = (char_u
*)mfp
;
2717 ga_clear(&ga_match
[mtt
]);
2720 *matchesp
= matches
;
2721 *num_matches
= match_count
;
2723 curbuf
->b_help
= help_save
;
2724 #ifdef FEAT_MULTI_LANG
2725 vim_free(saved_pat
);
2731 static garray_T tag_fnames
= GA_EMPTY
;
2732 static void found_tagfile_cb
__ARGS((char_u
*fname
, void *cookie
));
2735 * Callback function for finding all "tags" and "tags-??" files in
2736 * 'runtimepath' doc directories.
2739 found_tagfile_cb(fname
, cookie
)
2741 void *cookie UNUSED
;
2743 if (ga_grow(&tag_fnames
, 1) == OK
)
2744 ((char_u
**)(tag_fnames
.ga_data
))[tag_fnames
.ga_len
++] =
2748 #if defined(EXITFREE) || defined(PROTO)
2752 ga_clear_strings(&tag_fnames
);
2753 do_tag(NULL
, DT_FREE
, 0, 0, 0);
2756 # if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
2757 if (ptag_entry
.tagname
)
2759 vim_free(ptag_entry
.tagname
);
2760 ptag_entry
.tagname
= NULL
;
2767 * Get the next name of a tag file from the tag file list.
2768 * For help files, use "tags" file only.
2770 * Return FAIL if no more tag file names, OK otherwise.
2773 get_tagfname(tnp
, first
, buf
)
2774 tagname_T
*tnp
; /* holds status info */
2775 int first
; /* TRUE when first file name is wanted */
2776 char_u
*buf
; /* pointer to buffer of MAXPATHL chars */
2778 char_u
*fname
= NULL
;
2782 vim_memset(tnp
, 0, sizeof(tagname_T
));
2787 * For help files it's done in a completely different way:
2788 * Find "doc/tags" and "doc/tags-??" in all directories in
2793 ga_clear_strings(&tag_fnames
);
2794 ga_init2(&tag_fnames
, (int)sizeof(char_u
*), 10);
2795 do_in_runtimepath((char_u
*)
2796 #ifdef FEAT_MULTI_LANG
2798 /* Functions decc$to_vms() and decc$translate_vms() crash
2799 * on some VMS systems with wildcards "??". Seems ECO
2800 * patches do fix the problem in C RTL, but we can't use
2801 * an #ifdef for that. */
2802 "doc/tags doc/tags-*"
2804 "doc/tags doc/tags-??"
2809 , TRUE
, found_tagfile_cb
, NULL
);
2812 if (tnp
->tn_hf_idx
>= tag_fnames
.ga_len
)
2814 /* Not found in 'runtimepath', use 'helpfile', if it exists and
2815 * wasn't used yet, replacing "help.txt" with "tags". */
2816 if (tnp
->tn_hf_idx
> tag_fnames
.ga_len
|| *p_hf
== NUL
)
2820 STRCPY(gettail(buf
), "tags");
2823 vim_strncpy(buf
, ((char_u
**)(tag_fnames
.ga_data
))[
2824 tnp
->tn_hf_idx
++], MAXPATHL
- 1);
2830 /* Init. We make a copy of 'tags', because autocommands may change
2831 * the value without notifying us. */
2832 tnp
->tn_tags
= vim_strsave((*curbuf
->b_p_tags
!= NUL
)
2833 ? curbuf
->b_p_tags
: p_tags
);
2834 if (tnp
->tn_tags
== NULL
)
2836 tnp
->tn_np
= tnp
->tn_tags
;
2840 * Loop until we have found a file name that can be used.
2841 * There are two states:
2842 * tnp->tn_did_filefind_init == FALSE: setup for next part in 'tags'.
2843 * tnp->tn_did_filefind_init == TRUE: find next file in this part.
2847 if (tnp
->tn_did_filefind_init
)
2849 fname
= vim_findfile(tnp
->tn_search_ctx
);
2853 tnp
->tn_did_filefind_init
= FALSE
;
2857 char_u
*filename
= NULL
;
2859 /* Stop when used all parts of 'tags'. */
2860 if (*tnp
->tn_np
== NUL
)
2862 vim_findfile_cleanup(tnp
->tn_search_ctx
);
2863 tnp
->tn_search_ctx
= NULL
;
2868 * Copy next file name into buf.
2871 (void)copy_option_part(&tnp
->tn_np
, buf
, MAXPATHL
- 1, " ,");
2873 #ifdef FEAT_PATH_EXTRA
2874 r_ptr
= vim_findfile_stopdir(buf
);
2878 /* move the filename one char forward and truncate the
2879 * filepath with a NUL */
2880 filename
= gettail(buf
);
2881 STRMOVE(filename
+ 1, filename
);
2884 tnp
->tn_search_ctx
= vim_findfile_init(buf
, filename
,
2886 FALSE
, /* don't free visited list */
2887 FINDFILE_FILE
, /* we search for a file */
2888 tnp
->tn_search_ctx
, TRUE
, curbuf
->b_ffname
);
2889 if (tnp
->tn_search_ctx
!= NULL
)
2890 tnp
->tn_did_filefind_init
= TRUE
;
2900 * Free the contents of a tagname_T that was filled by get_tagfname().
2906 vim_free(tnp
->tn_tags
);
2907 vim_findfile_cleanup(tnp
->tn_search_ctx
);
2908 tnp
->tn_search_ctx
= NULL
;
2909 ga_clear_strings(&tag_fnames
);
2913 * Parse one line from the tags file. Find start/end of tag name, start/end of
2914 * file name and start of search pattern.
2916 * If is_etag is TRUE, tagp->fname and tagp->fname_end are not set.
2918 * Return FAIL if there is a format error in this line, OK otherwise.
2921 parse_tag_line(lbuf
,
2922 #ifdef FEAT_EMACS_TAGS
2926 char_u
*lbuf
; /* line to be parsed */
2927 #ifdef FEAT_EMACS_TAGS
2934 #ifdef FEAT_EMACS_TAGS
2940 * There are two formats for an emacs tag line:
2941 * 1: struct EnvBase ^?EnvBase^A139,4627
2942 * 2: #define ARPB_WILD_WORLD ^?153,5194
2944 p_7f
= vim_strchr(lbuf
, 0x7f);
2948 if (vim_strchr(lbuf
, '\n') == NULL
)
2950 /* Truncated line. Ignore it. */
2954 MSG(_("Ignoring long line in tags file"));
2957 tagp
->command
= lbuf
;
2958 tagp
->tagname
= lbuf
;
2959 tagp
->tagname_end
= lbuf
;
2965 /* Find ^A. If not found the line number is after the 0x7f */
2966 p
= vim_strchr(p_7f
, Ctrl_A
);
2972 if (!VIM_ISDIGIT(*p
)) /* check for start of line number */
2977 if (p
[-1] == Ctrl_A
) /* first format: explicit tagname given */
2979 tagp
->tagname
= p_7f
+ 1;
2980 tagp
->tagname_end
= p
- 1;
2982 else /* second format: isolate tagname */
2984 /* find end of tagname */
2985 for (p
= p_7f
- 1; !vim_iswordc(*p
); --p
)
2988 tagp
->tagname_end
= p
+ 1;
2989 while (p
>= lbuf
&& vim_iswordc(*p
))
2991 tagp
->tagname
= p
+ 1;
2994 else /* not an Emacs tag */
2997 /* Isolate the tagname, from lbuf up to the first white */
2998 tagp
->tagname
= lbuf
;
2999 #ifdef FEAT_TAG_ANYWHITE
3000 p
= skiptowhite(lbuf
);
3002 p
= vim_strchr(lbuf
, TAB
);
3006 tagp
->tagname_end
= p
;
3008 /* Isolate file name, from first to second white space */
3009 #ifdef FEAT_TAG_ANYWHITE
3016 #ifdef FEAT_TAG_ANYWHITE
3019 p
= vim_strchr(p
, TAB
);
3023 tagp
->fname_end
= p
;
3025 /* find start of search command, after second white space */
3026 #ifdef FEAT_TAG_ANYWHITE
3035 #ifdef FEAT_EMACS_TAGS
3043 * Check if tagname is a static tag
3045 * Static tags produced by the older ctags program have the format:
3046 * 'file:tag file /pattern'.
3047 * This is only recognized when both occurrence of 'file' are the same, to
3048 * avoid recognizing "string::string" or ":exit".
3050 * Static tags produced by the new ctags program have the format:
3051 * 'tag file /pattern/;"<Tab>file:' "
3053 * Return TRUE if it is a static tag and adjust *tagname to the real tag.
3054 * Return FALSE if it is not a static tag.
3057 test_for_static(tagp
)
3062 #ifdef FEAT_TAG_OLDSTATIC
3066 * Check for old style static tag: "file:tag file .."
3068 len
= (int)(tagp
->fname_end
- tagp
->fname
);
3069 p
= tagp
->tagname
+ len
;
3070 if ( p
< tagp
->tagname_end
3072 && fnamencmp(tagp
->tagname
, tagp
->fname
, len
) == 0)
3074 tagp
->tagname
= p
+ 1;
3080 * Check for new style static tag ":...<Tab>file:[<Tab>...]"
3083 while ((p
= vim_strchr(p
, '\t')) != NULL
)
3086 if (STRNCMP(p
, "file:", 5) == 0)
3094 * Parse a line from a matching tag. Does not change the line itself.
3096 * The line that we get looks like this:
3097 * Emacs tag: <mtt><tag_fname><NUL><ebuf><NUL><lbuf>
3098 * other tag: <mtt><tag_fname><NUL><NUL><lbuf>
3099 * without Emacs tags: <mtt><tag_fname><NUL><lbuf>
3101 * Return OK or FAIL.
3104 parse_match(lbuf
, tagp
)
3105 char_u
*lbuf
; /* input: matching line */
3106 tagptrs_T
*tagp
; /* output: pointers into the line */
3112 tagp
->tag_fname
= lbuf
+ 1;
3113 lbuf
+= STRLEN(tagp
->tag_fname
) + 2;
3114 #ifdef FEAT_EMACS_TAGS
3117 tagp
->is_etag
= TRUE
;
3119 lbuf
+= STRLEN(lbuf
);
3120 tagp
->fname_end
= lbuf
++;
3124 tagp
->is_etag
= FALSE
;
3129 /* Find search pattern and the file name for non-etags. */
3130 retval
= parse_tag_line(lbuf
,
3131 #ifdef FEAT_EMACS_TAGS
3136 tagp
->tagkind
= NULL
;
3137 tagp
->command_end
= NULL
;
3141 /* Try to find a kind field: "kind:<kind>" or just "<kind>"*/
3143 if (find_extra(&p
) == OK
)
3145 tagp
->command_end
= p
;
3146 p
+= 2; /* skip ";\"" */
3148 while (ASCII_ISALPHA(*p
))
3150 if (STRNCMP(p
, "kind:", 5) == 0)
3152 tagp
->tagkind
= p
+ 5;
3155 pc
= vim_strchr(p
, ':');
3156 pt
= vim_strchr(p
, '\t');
3157 if (pc
== NULL
|| (pt
!= NULL
&& pc
> pt
))
3167 if (tagp
->tagkind
!= NULL
)
3169 for (p
= tagp
->tagkind
;
3170 *p
&& *p
!= '\t' && *p
!= '\r' && *p
!= '\n'; ++p
)
3172 tagp
->tagkind_end
= p
;
3179 * Find out the actual file name of a tag. Concatenate the tags file name
3180 * with the matching tag file name.
3181 * Returns an allocated string or NULL (out of memory).
3184 tag_full_fname(tagp
)
3190 #ifdef FEAT_EMACS_TAGS
3192 c
= 0; /* to shut up GCC */
3196 c
= *tagp
->fname_end
;
3197 *tagp
->fname_end
= NUL
;
3199 fullname
= expand_tag_fname(tagp
->fname
, tagp
->tag_fname
, FALSE
);
3201 #ifdef FEAT_EMACS_TAGS
3204 *tagp
->fname_end
= c
;
3210 * Jump to a tag that has been found in one of the tag files
3212 * returns OK for success, NOTAGFILE when file not found, FAIL otherwise.
3215 jumpto_tag(lbuf
, forceit
, keep_help
)
3216 char_u
*lbuf
; /* line from the tags file for this tag */
3217 int forceit
; /* :ta with ! */
3218 int keep_help
; /* keep help flag (FALSE for cscope) */
3222 int save_p_ws
, save_p_scs
, save_p_ic
;
3226 char_u
*pbuf
; /* search pattern buffer */
3228 char_u
*tofree_fname
= NULL
;
3234 #ifdef FEAT_SEARCH_EXTRA
3235 int save_no_hlsearch
;
3237 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
3238 win_T
*curwin_save
= NULL
;
3240 char_u
*full_fname
= NULL
;
3242 int old_KeyTyped
= KeyTyped
; /* getting the file may reset it */
3245 pbuf
= alloc(LSIZE
);
3247 /* parse the match line into the tagp structure */
3248 if (pbuf
== NULL
|| parse_match(lbuf
, &tagp
) == FAIL
)
3250 tagp
.fname_end
= NULL
;
3254 /* truncate the file name, so it can be used as a string */
3255 csave
= *tagp
.fname_end
;
3256 *tagp
.fname_end
= NUL
;
3259 /* copy the command to pbuf[], remove trailing CR/NL */
3261 for (pbuf_end
= pbuf
; *str
&& *str
!= '\n' && *str
!= '\r'; )
3263 #ifdef FEAT_EMACS_TAGS
3264 if (tagp
.is_etag
&& *str
== ',')/* stop at ',' after line number */
3267 *pbuf_end
++ = *str
++;
3271 #ifdef FEAT_EMACS_TAGS
3276 * Remove the "<Tab>fieldname:value" stuff; we don't need it here.
3279 if (find_extra(&str
) == OK
)
3287 * Expand file name, when needed (for environment variables).
3288 * If 'tagrelative' option set, may change file name.
3290 fname
= expand_tag_fname(fname
, tagp
.tag_fname
, TRUE
);
3293 tofree_fname
= fname
; /* free() it later */
3296 * Check if the file with the tag exists before abandoning the current
3297 * file. Also accept a file name for which there is a matching BufReadCmd
3298 * autocommand event (e.g., http://sys/file).
3300 if (mch_getperm(fname
) < 0
3302 && !has_autocmd(EVENT_BUFREADCMD
, fname
, NULL
)
3307 vim_free(nofile_fname
);
3308 nofile_fname
= vim_strsave(fname
);
3309 if (nofile_fname
== NULL
)
3310 nofile_fname
= empty_option
;
3314 ++RedrawingDisabled
;
3317 need_mouse_correct
= TRUE
;
3320 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
3321 if (g_do_tagpreview
)
3323 postponed_split
= 0; /* don't split again below */
3324 curwin_save
= curwin
; /* Save current window */
3327 * If we are reusing a window, we may change dir when
3328 * entering it (autocommands) so turn the tag filename
3331 if (!curwin
->w_p_pvw
)
3333 full_fname
= FullName_save(fname
, FALSE
);
3337 * Make the preview window the current window.
3338 * Open a preview window when needed.
3340 prepare_tagpreview(TRUE
);
3344 /* If it was a CTRL-W CTRL-] command split window now. For ":tab tag"
3345 * open a new tab page. */
3346 if (postponed_split
|| cmdmod
.tab
!= 0)
3348 win_split(postponed_split
> 0 ? postponed_split
: 0,
3349 postponed_split_flags
);
3350 # ifdef FEAT_SCROLLBIND
3351 curwin
->w_p_scb
= FALSE
;
3358 /* A :ta from a help file will keep the b_help flag set. For ":ptag"
3359 * we need to use the flag from the window where we came from. */
3360 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
3361 if (g_do_tagpreview
)
3362 keep_help_flag
= curwin_save
->w_buffer
->b_help
;
3365 keep_help_flag
= curbuf
->b_help
;
3367 getfile_result
= getfile(0, fname
, NULL
, TRUE
, (linenr_T
)0, forceit
);
3368 keep_help_flag
= FALSE
;
3370 if (getfile_result
<= 0) /* got to the right file */
3372 curwin
->w_set_curswant
= TRUE
;
3374 postponed_split
= 0;
3377 save_secure
= secure
;
3382 save_magic
= p_magic
;
3383 p_magic
= FALSE
; /* always execute with 'nomagic' */
3384 #ifdef FEAT_SEARCH_EXTRA
3385 /* Save value of no_hlsearch, jumping to a tag is not a real search */
3386 save_no_hlsearch
= no_hlsearch
;
3390 * If 'cpoptions' contains 't', store the search pattern for the "n"
3391 * command. If 'cpoptions' does not contain 't', the search pattern
3394 if (vim_strchr(p_cpo
, CPO_TAGPAT
) != NULL
)
3397 search_options
= SEARCH_KEEP
;
3400 * If the command is a search, try here.
3402 * Reset 'smartcase' for the search, since the search pattern was not
3403 * typed by the user.
3404 * Only use do_search() when there is a full search command, without
3405 * anything following.
3408 if (pbuf
[0] == '/' || pbuf
[0] == '?')
3409 str
= skip_regexp(pbuf
+ 1, pbuf
[0], FALSE
, NULL
) + 1;
3410 if (str
> pbuf_end
- 1) /* search command with nothing following */
3415 p_ws
= TRUE
; /* need 'wrapscan' for backward searches */
3416 p_ic
= FALSE
; /* don't ignore case now */
3418 #if 0 /* disabled for now */
3420 /* put pattern in search history */
3421 add_to_history(HIST_SEARCH
, pbuf
+ 1, TRUE
, pbuf
[0]);
3424 save_lnum
= curwin
->w_cursor
.lnum
;
3425 curwin
->w_cursor
.lnum
= 0; /* start search before first line */
3426 if (do_search(NULL
, pbuf
[0], pbuf
+ 1, (long)1,
3427 search_options
, NULL
))
3435 * try again, ignore case now
3438 if (!do_search(NULL
, pbuf
[0], pbuf
+ 1, (long)1,
3439 search_options
, NULL
))
3442 * Failed to find pattern, take a guess: "^func ("
3445 (void)test_for_static(&tagp
);
3446 cc
= *tagp
.tagname_end
;
3447 *tagp
.tagname_end
= NUL
;
3448 sprintf((char *)pbuf
, "^%s\\s\\*(", tagp
.tagname
);
3449 if (!do_search(NULL
, '/', pbuf
, (long)1,
3450 search_options
, NULL
))
3452 /* Guess again: "^char * \<func (" */
3453 sprintf((char *)pbuf
, "^\\[#a-zA-Z_]\\.\\*\\<%s\\s\\*(",
3455 if (!do_search(NULL
, '/', pbuf
, (long)1,
3456 search_options
, NULL
))
3459 *tagp
.tagname_end
= cc
;
3463 EMSG(_("E434: Can't find tag pattern"));
3464 curwin
->w_cursor
.lnum
= save_lnum
;
3469 * Only give a message when really guessed, not when 'ic'
3470 * is set and match found while ignoring case.
3472 if (found
== 2 || !save_p_ic
)
3474 MSG(_("E435: Couldn't find tag, just guessing!"));
3475 if (!msg_scrolled
&& msg_silent
== 0)
3478 ui_delay(1000L, TRUE
);
3488 /* A search command may have positioned the cursor beyond the end
3489 * of the line. May need to correct that here. */
3494 curwin
->w_cursor
.lnum
= 1; /* start command in line 1 */
3495 do_cmdline_cmd(pbuf
);
3500 * When the command has done something that is not allowed make sure
3501 * the error message can be seen.
3505 secure
= save_secure
;
3506 p_magic
= save_magic
;
3510 #ifdef FEAT_SEARCH_EXTRA
3511 /* restore no_hlsearch when keeping the old search pattern */
3513 no_hlsearch
= save_no_hlsearch
;
3516 /* Return OK if jumped to another file (at least we found the file!). */
3517 if (getfile_result
== -1)
3523 * For a help buffer: Put the cursor line at the top of the window,
3524 * the help subject will be below it.
3527 set_topline(curwin
, curwin
->w_cursor
.lnum
);
3529 if ((fdo_flags
& FDO_TAG
) && old_KeyTyped
)
3534 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
3535 if (g_do_tagpreview
&& curwin
!= curwin_save
&& win_valid(curwin_save
))
3537 /* Return cursor to where we were */
3539 redraw_later(VALID
);
3540 win_enter(curwin_save
, TRUE
);
3544 --RedrawingDisabled
;
3548 --RedrawingDisabled
;
3550 if (postponed_split
) /* close the window */
3552 win_close(curwin
, FALSE
);
3553 postponed_split
= 0;
3559 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
3560 g_do_tagpreview
= 0; /* For next time */
3562 if (tagp
.fname_end
!= NULL
)
3563 *tagp
.fname_end
= csave
;
3565 vim_free(tofree_fname
);
3566 vim_free(full_fname
);
3572 * If "expand" is TRUE, expand wildcards in fname.
3573 * If 'tagrelative' option set, change fname (name of file containing tag)
3574 * according to tag_fname (name of tag file containing fname).
3575 * Returns a pointer to allocated memory (or NULL when out of memory).
3578 expand_tag_fname(fname
, tag_fname
, expand
)
3585 char_u
*expanded_fname
= NULL
;
3589 * Expand file name (for environment variables) when needed.
3591 if (expand
&& mch_has_wildcard(fname
))
3594 xpc
.xp_context
= EXPAND_FILES
;
3595 expanded_fname
= ExpandOne(&xpc
, (char_u
*)fname
, NULL
,
3596 WILD_LIST_NOTFOUND
|WILD_SILENT
, WILD_EXPAND_FREE
);
3597 if (expanded_fname
!= NULL
)
3598 fname
= expanded_fname
;
3601 if ((p_tr
|| curbuf
->b_help
)
3602 && !vim_isAbsName(fname
)
3603 && (p
= gettail(tag_fname
)) != tag_fname
)
3605 retval
= alloc(MAXPATHL
);
3608 STRCPY(retval
, tag_fname
);
3609 vim_strncpy(retval
+ (p
- tag_fname
), fname
,
3610 MAXPATHL
- (p
- tag_fname
) - 1);
3612 * Translate names like "src/a/../b/file.c" into "src/b/file.c".
3614 simplify_filename(retval
);
3618 retval
= vim_strsave(fname
);
3620 vim_free(expanded_fname
);
3626 * Converts a file name into a canonical form. It simplifies a file name into
3627 * its simplest form by stripping out unneeded components, if any. The
3628 * resulting file name is simplified in place and will either be the same
3629 * length as that supplied, or shorter.
3632 simplify_filename(filename
)
3635 #ifndef AMIGA /* Amiga doesn't have "..", it uses "/" */
3637 char_u
*p
, *tail
, *start
;
3638 int stripping_disabled
= FALSE
;
3639 int relative
= TRUE
;
3642 #ifdef BACKSLASH_IN_FILENAME
3643 if (p
[1] == ':') /* skip "x:" */
3647 if (vim_ispathsep(*p
))
3652 while (vim_ispathsep(*p
));
3654 start
= p
; /* remember start after "c:/" or "/" or "///" */
3658 /* At this point "p" is pointing to the char following a single "/"
3659 * or "p" is at the "start" of the (absolute or relative) path name. */
3661 /* VMS allows device:[path] - don't strip the [ in directory */
3662 if ((*p
== '[' || *p
== '<') && p
> filename
&& p
[-1] == ':')
3664 /* :[ or :< composition: vms directory component */
3666 p
= getnextcomp(p
+ 1);
3668 /* allow remote calls as host"user passwd"::device:[path] */
3669 else if (p
[0] == ':' && p
[1] == ':' && p
> filename
&& p
[-1] == '"' )
3671 /* ":: composition: vms host/passwd component */
3673 p
= getnextcomp(p
+ 2);
3677 if (vim_ispathsep(*p
))
3678 STRMOVE(p
, p
+ 1); /* remove duplicate "/" */
3679 else if (p
[0] == '.' && (vim_ispathsep(p
[1]) || p
[1] == NUL
))
3681 if (p
== start
&& relative
)
3682 p
+= 1 + (p
[1] != NUL
); /* keep single "." or leading "./" */
3685 /* Strip "./" or ".///". If we are at the end of the file name
3686 * and there is no trailing path separator, either strip "/." if
3687 * we are after "start", or strip "." if we are at the beginning
3688 * of an absolute path name . */
3691 while (vim_ispathsep(*tail
))
3694 --p
; /* strip preceding path separator */
3698 else if (p
[0] == '.' && p
[1] == '.' &&
3699 (vim_ispathsep(p
[2]) || p
[2] == NUL
))
3701 /* Skip to after ".." or "../" or "..///". */
3703 while (vim_ispathsep(*tail
))
3706 if (components
> 0) /* strip one preceding component */
3708 int do_strip
= FALSE
;
3712 /* Don't strip for an erroneous file name. */
3713 if (!stripping_disabled
)
3715 /* If the preceding component does not exist in the file
3716 * system, we strip it. On Unix, we don't accept a symbolic
3717 * link that refers to a non-existent file. */
3721 if (mch_lstat((char *)filename
, &st
) < 0)
3723 if (mch_stat((char *)filename
, &st
) < 0)
3729 /* Skip back to after previous '/'. */
3730 while (p
> start
&& !after_pathsep(start
, p
))
3731 mb_ptr_back(start
, p
);
3735 /* If the component exists in the file system, check
3736 * that stripping it won't change the meaning of the
3737 * file name. First get information about the
3738 * unstripped file name. This may fail if the component
3739 * to strip is not a searchable directory (but a regular
3740 * file, for instance), since the trailing "/.." cannot
3741 * be applied then. We don't strip it then since we
3742 * don't want to replace an erroneous file name by
3743 * a valid one, and we disable stripping of later
3747 if (mch_stat((char *)filename
, &st
) >= 0)
3750 stripping_disabled
= TRUE
;
3757 /* On Unix, the check for the unstripped file name
3758 * above works also for a symbolic link pointing to
3759 * a searchable directory. But then the parent of
3760 * the directory pointed to by the link must be the
3761 * same as the stripped file name. (The latter
3762 * exists in the file system since it is the
3763 * component's parent directory.) */
3764 if (p
== start
&& relative
)
3765 (void)mch_stat(".", &new_st
);
3770 (void)mch_stat((char *)filename
, &new_st
);
3774 if (new_st
.st_ino
!= st
.st_ino
||
3775 new_st
.st_dev
!= st
.st_dev
)
3778 /* We don't disable stripping of later
3779 * components since the unstripped path name is
3789 /* Skip the ".." or "../" and reset the counter for the
3790 * components that might be stripped later on. */
3796 /* Strip previous component. If the result would get empty
3797 * and there is no trailing path separator, leave a single
3798 * "." instead. If we are at the end of the file name and
3799 * there is no trailing path separator and a preceding
3800 * component is left after stripping, strip its trailing
3801 * path separator as well. */
3802 if (p
== start
&& relative
&& tail
[-1] == '.')
3809 if (p
> start
&& tail
[-1] == '.')
3811 STRMOVE(p
, tail
); /* strip previous component */
3817 else if (p
== start
&& !relative
) /* leading "/.." or "/../" */
3818 STRMOVE(p
, tail
); /* strip ".." or "../" */
3821 if (p
== start
+ 2 && p
[-2] == '.') /* leading "./../" */
3823 STRMOVE(p
- 2, p
); /* strip leading "./" */
3826 p
= tail
; /* skip to char after ".." or "../" */
3831 ++components
; /* simple path component */
3834 } while (*p
!= NUL
);
3839 * Check if we have a tag for the buffer with name "buf_ffname".
3840 * This is a bit slow, because of the full path compare in fullpathcmp().
3841 * Return TRUE if tag for file "fname" if tag file "tag_fname" is for current
3845 #ifdef FEAT_EMACS_TAGS
3846 test_for_current(is_etag
, fname
, fname_end
, tag_fname
, buf_ffname
)
3849 test_for_current(fname
, fname_end
, tag_fname
, buf_ffname
)
3860 if (buf_ffname
!= NULL
) /* if the buffer has a name */
3862 #ifdef FEAT_EMACS_TAGS
3864 c
= 0; /* to shut up GCC */
3871 fullname
= expand_tag_fname(fname
, tag_fname
, TRUE
);
3872 if (fullname
!= NULL
)
3874 retval
= (fullpathcmp(fullname
, buf_ffname
, TRUE
) & FPC_SAME
);
3877 #ifdef FEAT_EMACS_TAGS
3887 * Find the end of the tagaddress.
3888 * Return OK if ";\"" is following, FAIL otherwise.
3896 /* Repeat for addresses separated with ';' */
3899 if (VIM_ISDIGIT(*str
))
3900 str
= skipdigits(str
);
3901 else if (*str
== '/' || *str
== '?')
3903 str
= skip_regexp(str
+ 1, *str
, FALSE
, NULL
);
3911 if (str
== NULL
|| *str
!= ';'
3912 || !(VIM_ISDIGIT(str
[1]) || str
[1] == '/' || str
[1] == '?'))
3914 ++str
; /* skip ';' */
3917 if (str
!= NULL
&& STRNCMP(str
, ";\"", 2) == 0)
3925 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3927 expand_tags(tagnames
, pat
, num_file
, file
)
3928 int tagnames
; /* expand tag names */
3941 tagnmflag
= TAG_NAMES
;
3945 ret
= find_tags(pat
+ 1, num_file
, file
,
3946 TAG_REGEXP
| tagnmflag
| TAG_VERBOSE
| TAG_DONT_USE_TFU
,
3947 TAG_MANY
, curbuf
->b_ffname
);
3949 ret
= find_tags(pat
, num_file
, file
,
3950 TAG_REGEXP
| tagnmflag
| TAG_VERBOSE
| TAG_DONT_USE_TFU
| TAG_NOIC
,
3951 TAG_MANY
, curbuf
->b_ffname
);
3952 if (ret
== OK
&& !tagnames
)
3954 /* Reorganize the tags for display and matching as strings of:
3955 * "<tagname>\0<kind>\0<filename>\0"
3957 for (i
= 0; i
< *num_file
; i
++)
3959 parse_match((*file
)[i
], &t_p
);
3960 c
= (int)(t_p
.tagname_end
- t_p
.tagname
);
3961 mch_memmove(tagnm
, t_p
.tagname
, (size_t)c
);
3963 tagnm
[c
++] = (t_p
.tagkind
!= NULL
&& *t_p
.tagkind
)
3964 ? *t_p
.tagkind
: 'f';
3966 mch_memmove((*file
)[i
] + c
, t_p
.fname
, t_p
.fname_end
- t_p
.fname
);
3967 (*file
)[i
][c
+ (t_p
.fname_end
- t_p
.fname
)] = 0;
3968 mch_memmove((*file
)[i
], tagnm
, (size_t)c
);
3975 #if defined(FEAT_EVAL) || defined(PROTO)
3976 static int add_tag_field
__ARGS((dict_T
*dict
, char *field_name
, char_u
*start
, char_u
*end
));
3979 * Add a tag field to the dictionary "dict".
3980 * Return OK or FAIL.
3983 add_tag_field(dict
, field_name
, start
, end
)
3986 char_u
*start
; /* start of the value */
3987 char_u
*end
; /* after the value; can be NULL */
3989 char_u buf
[MAXPATHL
];
3992 /* check that the field name doesn't exist yet */
3993 if (dict_find(dict
, (char_u
*)field_name
, -1) != NULL
)
3998 smsg((char_u
*)_("Duplicate field name: %s"), field_name
);
4007 end
= start
+ STRLEN(start
);
4008 while (end
> start
&& (end
[-1] == '\r' || end
[-1] == '\n'))
4011 len
= (int)(end
- start
);
4012 if (len
> (int)sizeof(buf
) - 1)
4013 len
= sizeof(buf
) - 1;
4014 vim_strncpy(buf
, start
, len
);
4017 return dict_add_nr_str(dict
, field_name
, 0L, buf
);
4021 * Add the tags matching the specified pattern to the list "list"
4029 int num_matches
, i
, ret
;
4030 char_u
**matches
, *p
;
4036 ret
= find_tags(pat
, &num_matches
, &matches
,
4037 TAG_REGEXP
| TAG_NOIC
, (int)MAXCOL
, NULL
);
4038 if (ret
== OK
&& num_matches
> 0)
4040 for (i
= 0; i
< num_matches
; ++i
)
4042 parse_match(matches
[i
], &tp
);
4043 is_static
= test_for_static(&tp
);
4045 /* Skip pseudo-tag lines. */
4046 if (STRNCMP(tp
.tagname
, "!_TAG_", 6) == 0)
4049 if ((dict
= dict_alloc()) == NULL
)
4051 if (list_append_dict(list
, dict
) == FAIL
)
4054 full_fname
= tag_full_fname(&tp
);
4055 if (add_tag_field(dict
, "name", tp
.tagname
, tp
.tagname_end
) == FAIL
4056 || add_tag_field(dict
, "filename", full_fname
,
4058 || add_tag_field(dict
, "cmd", tp
.command
,
4059 tp
.command_end
) == FAIL
4060 || add_tag_field(dict
, "kind", tp
.tagkind
,
4061 tp
.tagkind_end
) == FAIL
4062 || dict_add_nr_str(dict
, "static", is_static
, NULL
) == FAIL
)
4065 vim_free(full_fname
);
4067 if (tp
.command_end
!= NULL
)
4069 for (p
= tp
.command_end
+ 3;
4070 *p
!= NUL
&& *p
!= '\n' && *p
!= '\r'; ++p
)
4072 if (p
== tp
.tagkind
|| (p
+ 5 == tp
.tagkind
4073 && STRNCMP(p
, "kind:", 5) == 0))
4074 /* skip "kind:<kind>" and "<kind>" */
4075 p
= tp
.tagkind_end
- 1;
4076 else if (STRNCMP(p
, "file:", 5) == 0)
4077 /* skip "file:" (static tag) */
4079 else if (!vim_iswhite(*p
))
4084 /* Add extra field as a dict entry. Fields are
4085 * separated by Tabs. */
4087 while (*p
!= NUL
&& *p
>= ' ' && *p
< 127 && *p
!= ':')
4090 if (*p
== ':' && len
> 0)
4093 while (*p
!= NUL
&& *p
>= ' ')
4096 if (add_tag_field(dict
, (char *)n
, s
, p
) == FAIL
)
4101 /* Skip field without colon. */
4102 while (*p
!= NUL
&& *p
>= ' ')
4110 vim_free(matches
[i
]);