vim: src/tag.c comparison

comparison src/tag.c @ 16447:54ffc82f38a8 v8.1.1228

patch 8.1.1228: not possible to process tags with a function commit https://github.com/vim/vim/commit/45e18cbdc40afd8144d20dcc07ad2d981636f4c9 Author: Bram Moolenaar <Bram@vim.org> Date: Sun Apr 28 18:05:35 2019 +0200 patch 8.1.1228: not possible to process tags with a function Problem: Not possible to process tags with a function. Solution: Add tagfunc() (Christian Brabandt, Andy Massimino, closes https://github.com/vim/vim/issues/4010)

author	Bram Moolenaar <Bram@vim.org>
date	Sun, 28 Apr 2019 18:15:07 +0200
parents	3d6b282e2d6e
children	826ad48af5e3

comparison

equal deleted inserted replaced

-:cee0719a1b4b
+:54ffc82f38a8
 /*
 * Structure to hold pointers to various items in a tag line.
 */
 typedef struct tag_pointers
 {
-/* filled in by parse_tag_line(): */
+// filled in by parse_tag_line():
-char_u	*tagname;	/* start of tag name (skip "file:") */
+char_u	*tagname;	// start of tag name (skip "file:")
-char_u	*tagname_end;	/* char after tag name */
+char_u	*tagname_end;	// char after tag name
-char_u	*fname;		/* first char of file name */
+char_u	*fname;		// first char of file name
-char_u	*fname_end;	/* char after file name */
+char_u	*fname_end;	// char after file name
-char_u	*command;	/* first char of command */
+char_u	*command;	// first char of command
-/* filled in by parse_match(): */
+// filled in by parse_match():
-char_u	*command_end;	/* first char after command */
+char_u	*command_end;	// first char after command
-char_u	*tag_fname;	/* file name of the tags file */
+char_u	*tag_fname;	// file name of the tags file. This is used
+				// when 'tr' is set.
 #ifdef FEAT_EMACS_TAGS
-int		is_etag;	/* TRUE for emacs tag */
+int		is_etag;	// TRUE for emacs tag
 #endif
-char_u	*tagkind;	/* "kind:" value */
+char_u	*tagkind;	// "kind:" value
-char_u	*tagkind_end;	/* end of tagkind */
+char_u	*tagkind_end;	// end of tagkind
+char_u	*user_data;	// user_data string
+char_u	*user_data_end;	// end of user_data
 } tagptrs_T;
 /*
 * The matching tags are first stored in one of the hash tables.  In
 * which one depends on the priority of the match.
 static int find_extra(char_u **pp);
 static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char_u **matches);
 #if defined(FEAT_QUICKFIX) && defined(FEAT_EVAL)
 static int add_llist_tags(char_u *tag, int num_matches, char_u **matches);
 #endif
+static void tagstack_clear_entry(taggy_T *item);
 static char_u *bottommsg = (char_u *)N_("E555: at bottom of tag stack");
 static char_u *topmsg = (char_u *)N_("E556: at top of tag stack");
+#ifdef FEAT_EVAL
+static char_u *recurmsg = (char_u *)N_("E986: cannot modify the tag stack within tagfunc");
+static char_u *tfu_inv_ret_msg = (char_u *)N_("E987: invalid return value from tagfunc");
+#endif
 static char_u	*tagmatchname = NULL;	/* name of last used tag */
 #if defined(FEAT_QUICKFIX)
 /*
 * Tag for preview window is remembered separately, to avoid messing up the
 * normal tagstack.
 */
-static taggy_T ptag_entry = {NULL, {{0, 0, 0}, 0}, 0, 0};
+static taggy_T ptag_entry = {NULL, {{0, 0, 0}, 0}, 0, 0, NULL};
 #endif
+#ifdef FEAT_EVAL
+static int  tfu_in_use = FALSE;	    // disallow recursive call of tagfunc
+#endif
+// Used instead of NUL to separate tag fields in the growarrays.
+#define TAG_SEP 0x02
 /*
 * Jump to tag; handling of tag commands and tag stack
 *
 * *tag != NUL: ":tag {tag}", jump to new tag, add to tag stack
 char_u	**new_matches;
 int		use_tagstack;
 int		skip_msg = FALSE;
 char_u	*buf_ffname = curbuf->b_ffname;	    /* name to use for
 						       priority computation */
+int         use_tfu = 1;
 /* remember the matches for the last used tag */
 static int		num_matches = 0;
 static int		max_num_matches = 0;  /* limit used for match search */
 static char_u	**matches = NULL;
 static int		flags;
+#ifdef FEAT_EVAL
+if (tfu_in_use)
+{
+	emsg(_(recurmsg));
+	return FALSE;
+}
+#endif
 #ifdef EXITFREE
 if (type == DT_FREE)
 {
 	/* remove the list of matches */
 if (type == DT_HELP)
 {
 	type = DT_TAG;
 	no_regexp = TRUE;
+	use_tfu = 0;
 }
 prev_num_matches = num_matches;
 free_string_option(nofile_fname);
 nofile_fname = NULL;
 	use_tagstack = FALSE;
 	new_tag = TRUE;
 #if defined(FEAT_QUICKFIX)
 	if (g_do_tagpreview != 0)
 	{
-	    vim_free(ptag_entry.tagname);
+	    tagstack_clear_entry(&ptag_entry);
 	    if ((ptag_entry.tagname = vim_strsave(tag)) == NULL)
 		goto end_do_tag;
 	}
 #endif
 }
 		    cur_match = ptag_entry.cur_match;
 		    cur_fnum = ptag_entry.cur_fnum;
 		}
 		else
 		{
-		    vim_free(ptag_entry.tagname);
+		    tagstack_clear_entry(&ptag_entry);
 		    if ((ptag_entry.tagname = vim_strsave(tag)) == NULL)
 			goto end_do_tag;
 		}
 	    }
 	    else
 		/*
 		 * If the last used entry is not at the top, delete all tag
 		 * stack entries above it.
 		 */
 		while (tagstackidx < tagstacklen)
-		    vim_free(tagstack[--tagstacklen].tagname);
+		    tagstack_clear_entry(&tagstack[--tagstacklen]);
 		/* if the tagstack is full: remove oldest entry */
 		if (++tagstacklen > TAGSTACKSIZE)
 		{
 		    tagstacklen = TAGSTACKSIZE;
-		    vim_free(tagstack[0].tagname);
+		    tagstack_clear_entry(&tagstack[0]);
 		    for (i = 1; i < tagstacklen; ++i)
 			tagstack[i - 1] = tagstack[i];
 		    --tagstackidx;
 		}
 	    if (type == DT_CSCOPE)
 		flags = TAG_CSCOPE;
 #endif
 	    if (verbose)
 		flags |= TAG_VERBOSE;
+	    if (!use_tfu)
+		flags |= TAG_NO_TAGFUNC;
 	    if (find_tags(name, &new_num_matches, &new_matches, flags,
 					    max_num_matches, buf_ffname) == OK
 		    && new_num_matches < max_num_matches)
 		max_num_matches = MAXCOL; /* If less than max_num_matches
 					     found: all matches found. */
 		}
 		cur_match = num_matches - 1;
 	    }
 	    if (use_tagstack)
 	    {
+		tagptrs_T   tagp;
 		tagstack[tagstackidx].cur_match = cur_match;
 		tagstack[tagstackidx].cur_fnum = cur_fnum;
+		// store user-provided data originating from tagfunc
+		if (use_tfu && parse_match(matches[cur_match], &tagp) == OK
+			&& tagp.user_data)
+		{
+		    VIM_CLEAR(tagstack[tagstackidx].user_data);
+		    tagstack[tagstackidx].user_data = vim_strnsave(
+			    tagp.user_data, tagp.user_data_end - tagp.user_data);
+		}
 		++tagstackidx;
 	    }
 #if defined(FEAT_QUICKFIX)
 	    else if (g_do_tagpreview != 0)
 	    {
 if (has_re)
 	pats->regmatch.regprog = vim_regcomp(pats->pat, p_magic ? RE_MAGIC : 0);
 else
 	pats->regmatch.regprog = NULL;
 }
+#ifdef FEAT_EVAL
+/*
+* Call the user-defined function to generate a list of tags used by
+* find_tags().
+*
+* Return OK if at least 1 tag has been successfully found,
+* NOTDONE if the function returns v:null, and FAIL otherwise.
+*/
+static int
+find_tagfunc_tags(
+char_u	*pat,		// pattern supplied to the user-defined function
+garray_T	*ga,		// the tags will be placed here
+int		*match_count,	// here the number of tags found will be placed
+int		flags,		// flags from find_tags (TAG_*)
+char_u	*buf_ffname)	// name of buffer for priority
+{
+pos_T       save_pos;
+list_T      *taglist;
+listitem_T  *item;
+int         ntags = 0;
+int         result = FAIL;
+typval_T	args[4];
+typval_T	rettv;
+char_u      flagString[3];
+dict_T	*d;
+taggy_T	*tag = &curwin->w_tagstack[curwin->w_tagstackidx];
+if (*curbuf->b_p_tfu == NUL)
+	return FAIL;
+args[0].v_type = VAR_STRING;
+args[0].vval.v_string = pat;
+args[1].v_type = VAR_STRING;
+args[1].vval.v_string = flagString;
+// create 'info' dict argument
+if ((d = dict_alloc_lock(VAR_FIXED)) == NULL)
+	return FAIL;
+if (tag->user_data != NULL)
+	dict_add_string(d, "user_data", tag->user_data);
+if (buf_ffname != NULL)
+	dict_add_string(d, "buf_ffname", buf_ffname);
+++d->dv_refcount;
+args[2].v_type = VAR_DICT;
+args[2].vval.v_dict = d;
+args[3].v_type = VAR_UNKNOWN;
+vim_snprintf((char *)flagString, sizeof(flagString),
+		 "%s%s",
+		 g_tag_at_cursor      ? "c": "",
+		 flags & TAG_INS_COMP ? "i": "");
+save_pos = curwin->w_cursor;
+result = call_vim_function(curbuf->b_p_tfu, 3, args, &rettv);
+curwin->w_cursor = save_pos;	// restore the cursor position
+--d->dv_refcount;
+if (result == FAIL)
+	return FAIL;
+if (rettv.v_type == VAR_SPECIAL && rettv.vval.v_number == VVAL_NULL)
+{
+	clear_tv(&rettv);
+	return NOTDONE;
+}
+if (rettv.v_type != VAR_LIST || !rettv.vval.v_list)
+{
+	clear_tv(&rettv);
+	emsg(_(tfu_inv_ret_msg));
+	return FAIL;
+}
+taglist = rettv.vval.v_list;
+for (item = taglist->lv_first; item != NULL; item = item->li_next)
+{
+	char_u		*mfp;
+	char_u		*res_name, *res_fname, *res_cmd, *res_kind;
+	int		len;
+	dict_iterator_T	iter;
+	char_u		*dict_key;
+	typval_T	*tv;
+	int		has_extra = 0;
+	int		name_only = flags & TAG_NAMES;
+	if (item->li_tv.v_type != VAR_DICT)
+	{
+	    emsg(_(tfu_inv_ret_msg));
+	    break;
+	}
+#ifdef FEAT_EMACS_TAGS
+	len = 3;
+#else
+	len = 2;
+#endif
+	res_name = NULL;
+	res_fname = NULL;
+	res_cmd = NULL;
+	res_kind = NULL;
+	dict_iterate_start(&item->li_tv, &iter);
+	while (NULL != (dict_key = dict_iterate_next(&iter, &tv)))
+	{
+	    if (tv->v_type != VAR_STRING || tv->vval.v_string == NULL)
+		continue;
+	    len += STRLEN(tv->vval.v_string) + 1;   // Space for "\tVALUE"
+	    if (!STRCMP(dict_key, "name"))
+	    {
+		res_name = tv->vval.v_string;
+		continue;
+	    }
+	    if (!STRCMP(dict_key, "filename"))
+	    {
+		res_fname = tv->vval.v_string;
+		continue;
+	    }
+	    if (!STRCMP(dict_key, "cmd"))
+	    {
+		res_cmd = tv->vval.v_string;
+		continue;
+	    }
+	    has_extra = 1;
+	    if (!STRCMP(dict_key, "kind"))
+	    {
+		res_kind = tv->vval.v_string;
+		continue;
+	    }
+	    // Other elements will be stored as "\tKEY:VALUE"
+	    // Allocate space for the key and the colon
+	    len += STRLEN(dict_key) + 1;
+	}
+	if (has_extra)
+	    len += 2;	// need space for ;"
+	if (!res_name || !res_fname || !res_cmd)
+	{
+	    emsg(_(tfu_inv_ret_msg));
+	    break;
+	}
+	if (name_only)
+	    mfp = vim_strsave(res_name);
+	else
+	    mfp = (char_u *)alloc((int)sizeof(char_u) + len + 1);
+	if (mfp == NULL)
+	    continue;
+	if (!name_only)
+	{
+	    char_u *p = mfp;
+	    *p++ = MT_GL_OTH + 1;   // mtt
+	    *p++ = TAG_SEP;	    // no tag file name
+#ifdef FEAT_EMACS_TAGS
+	    *p++ = TAG_SEP;
+#endif
+	    STRCPY(p, res_name);
+	    p += STRLEN(p);
+	    *p++ = TAB;
+	    STRCPY(p, res_fname);
+	    p += STRLEN(p);
+	    *p++ = TAB;
+	    STRCPY(p, res_cmd);
+	    p += STRLEN(p);
+	    if (has_extra)
+	    {
+		STRCPY(p, ";\"");
+		p += STRLEN(p);
+		if (res_kind)
+		{
+		    *p++ = TAB;
+		    STRCPY(p, res_kind);
+		    p += STRLEN(p);
+		}
+		dict_iterate_start(&item->li_tv, &iter);
+		while (NULL != (dict_key = dict_iterate_next(&iter, &tv)))
+		{
+		    if (tv->v_type != VAR_STRING || tv->vval.v_string == NULL)
+			continue;
+		    if (!STRCMP(dict_key, "name"))
+			continue;
+		    if (!STRCMP(dict_key, "filename"))
+			continue;
+		    if (!STRCMP(dict_key, "cmd"))
+			continue;
+		    if (!STRCMP(dict_key, "kind"))
+			continue;
+		    *p++ = TAB;
+		    STRCPY(p, dict_key);
+		    p += STRLEN(p);
+		    STRCPY(p, ":");
+		    p += STRLEN(p);
+		    STRCPY(p, tv->vval.v_string);
+		    p += STRLEN(p);
+		}
+	    }
+	}
+	// Add all matches because tagfunc should do filtering.
+	if (ga_grow(ga, 1) == OK)
+	{
+	    ((char_u **)(ga->ga_data))[ga->ga_len++] = mfp;
+	    ++ntags;
+	    result = OK;
+	}
+	else
+	{
+	    vim_free(mfp);
+	    break;
+	}
+}
+clear_tv(&rettv);
+*match_count = ntags;
+return result;
+}
+#endif
 /*
 * find_tags() - search for tags in tags files
 *
 * Return FAIL if search completely failed (*num_matches will be 0, *matchesp
 * TAG_NAMES	  only return name of tag
 * TAG_REGEXP	  use "pat" as a regexp
 * TAG_NOIC	  don't always ignore case
 * TAG_KEEP_LANG  keep language
 * TAG_CSCOPE	  use cscope results for tags
+* TAG_NO_TAGFUNC do not call the 'tagfunc' function
 */
 int
 find_tags(
 char_u	*pat,			/* pattern to search for */
 int		*num_matches,		/* return: number of matches found */
 int		get_it_again = FALSE;
 #ifdef FEAT_CSCOPE
 int		use_cscope = (flags & TAG_CSCOPE);
 #endif
 int		verbose = (flags & TAG_VERBOSE);
+#ifdef FEAT_EVAL
+int         use_tfu = ((flags & TAG_NO_TAGFUNC) == 0);
+#endif
 int		save_p_ic = p_ic;
 /*
 * Change the value of 'ignorecase' according to 'tagcase' for the
 * duration of this function.
 #ifdef FEAT_TAG_BINS
 /* This is only to avoid a compiler warning for using search_info
 * uninitialised. */
 vim_memset(&search_info, 0, (size_t)1);
+#endif
+#ifdef FEAT_EVAL
+if (*curbuf->b_p_tfu != NUL && use_tfu && !tfu_in_use)
+{
+	tfu_in_use = TRUE;
+	retval = find_tagfunc_tags(pat, &ga_match[0], &match_count,
+							   flags, buf_ffname);
+	tfu_in_use = FALSE;
+	if (retval != NOTDONE)
+	    goto findtag_end;
+}
 #endif
 /*
 * When finding a specified number of matches, first try with matching
 * case, so binary search can be used, and try ignore-case matches in a
 			    get_it_again = p_sft;
 		    }
 		}
 		else
 		{
-#define TAG_SEP 0x02
 		    size_t tag_fname_len = STRLEN(tag_fname);
 #ifdef FEAT_EMACS_TAGS
 		    size_t ebuf_len = 0;
 #endif
 ga_clear_strings(&tag_fnames);
 do_tag(NULL, DT_FREE, 0, 0, 0);
 tag_freematch();
 # if defined(FEAT_QUICKFIX)
-if (ptag_entry.tagname)
+tagstack_clear_entry(&ptag_entry);
-	VIM_CLEAR(ptag_entry.tagname);
 # endif
 }
 #endif
 /*
 			tagp->is_etag,
 #endif
 			tagp);
 tagp->tagkind = NULL;
+tagp->user_data = NULL;
 tagp->command_end = NULL;
 if (retval == OK)
 {
 	/* Try to find a kind field: "kind:<kind>" or just "<kind>"*/
 	    p += 2;	/* skip ";\"" */
 	    if (*p++ == TAB)
 		while (ASCII_ISALPHA(*p))
 		{
 		    if (STRNCMP(p, "kind:", 5) == 0)
-		    {
 			tagp->tagkind = p + 5;
+		    else if (STRNCMP(p, "user_data:", 10) == 0)
+			tagp->user_data = p + 10;
+		    if (tagp->tagkind != NULL && tagp->user_data != NULL)
 			break;
-		    }
 		    pc = vim_strchr(p, ':');
 		    pt = vim_strchr(p, '\t');
 		    if (pc == NULL || (pt != NULL && pc > pt))
-		    {
 			tagp->tagkind = p;
-			break;
-		    }
 		    if (pt == NULL)
 			break;
 		    p = pt + 1;
 		}
 	}
 	{
 	    for (p = tagp->tagkind;
 			    *p && *p != '\t' && *p != '\r' && *p != '\n'; ++p)
 		;
 	    tagp->tagkind_end = p;
+	}
+	if (tagp->user_data != NULL)
+	{
+	    for (p = tagp->user_data;
+			    *p && *p != '\t' && *p != '\r' && *p != '\n'; ++p)
+		;
+	    tagp->user_data_end = p;
 	}
 }
 return retval;
 }
 	return OK;
 }
 return FAIL;
 }
+/*
+* Free a single entry in a tag stack
+*/
+static void
+tagstack_clear_entry(taggy_T *item)
+{
+VIM_CLEAR(item->tagname);
+VIM_CLEAR(item->user_data);
+}
 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
 int
 expand_tags(
 int		tagnames,	/* expand tag names */
 char_u	*pat,
 	tagnmflag = TAG_NAMES;
 else
 	tagnmflag = 0;
 if (pat[0] == '/')
 	ret = find_tags(pat + 1, num_file, file,
-		TAG_REGEXP | tagnmflag | TAG_VERBOSE,
+		TAG_REGEXP | tagnmflag | TAG_VERBOSE | TAG_NO_TAGFUNC,
 		TAG_MANY, curbuf->b_ffname);
 else
 	ret = find_tags(pat, num_file, file,
-		TAG_REGEXP | tagnmflag | TAG_VERBOSE | TAG_NOIC,
+	      TAG_REGEXP | tagnmflag | TAG_VERBOSE | TAG_NO_TAGFUNC | TAG_NOIC,
 		TAG_MANY, curbuf->b_ffname);
 if (ret == OK && !tagnames)
 {
 	 /* Reorganize the tags for display and matching as strings of:
 	  * "<tagname>\0<kind>\0<filename>\0"
 fmark_T	*fmark;
 dict_add_string(retdict, "tagname", tag->tagname);
 dict_add_number(retdict, "matchnr", tag->cur_match + 1);
 dict_add_number(retdict, "bufnr", tag->cur_fnum);
+if (tag->user_data)
+	dict_add_string(retdict, "user_data", tag->user_data);
 if ((pos = list_alloc_id(aid_tagstack_from)) == NULL)
 	return;
 dict_add_list(retdict, "from", pos);
 {
 int i;
 // Free the current tag stack
 for (i = 0; i < wp->w_tagstacklen; ++i)
-	vim_free(wp->w_tagstack[i].tagname);
+	tagstack_clear_entry(&wp->w_tagstack[i]);
 wp->w_tagstacklen = 0;
 wp->w_tagstackidx = 0;
 }
 /*
 tagstack_shift(win_T *wp)
 {
 taggy_T	*tagstack = wp->w_tagstack;
 int		i;
-vim_free(tagstack[0].tagname);
+tagstack_clear_entry(&tagstack[0]);
 for (i = 1; i < wp->w_tagstacklen; ++i)
 	tagstack[i - 1] = tagstack[i];
 wp->w_tagstacklen--;
 }
 	win_T	*wp,
 	char_u	*tagname,
 	int	cur_fnum,
 	int	cur_match,
 	pos_T	mark,
-	int	fnum)
+	int	fnum,
+	char_u  *user_data)
 {
 taggy_T	*tagstack = wp->w_tagstack;
 int		idx = wp->w_tagstacklen;	// top of the stack
 // if the tagstack is full: remove the oldest entry
 tagstack[idx].cur_match = cur_match;
 if (tagstack[idx].cur_match < 0)
 	tagstack[idx].cur_match = 0;
 tagstack[idx].fmark.mark = mark;
 tagstack[idx].fmark.fnum = fnum;
+tagstack[idx].user_data = user_data;
 }
 /*
 * Add a list of items to the tag stack in the specified window
 */
 	if (mark.col > 0)
 	    mark.col--;
 	tagstack_push_item(wp, tagname,
 		(int)dict_get_number(itemdict, (char_u *)"bufnr"),
 		(int)dict_get_number(itemdict, (char_u *)"matchnr") - 1,
-		mark, fnum);
+		mark, fnum,
+		dict_get_string(itemdict, (char_u *)"user_data", TRUE));
 }
 }
 /*
 * Set the current index in the tag stack. Valid values are between 0
 set_tagstack(win_T *wp, dict_T *d, int action)
 {
 dictitem_T	*di;
 list_T	*l;
+#ifdef FEAT_EVAL
+// not allowed to alter the tag stack entries from inside tagfunc
+if (tfu_in_use)
+{
+	emsg(_(recurmsg));
+	return FAIL;
+}
+#endif
 if ((di = dict_find(d, (char_u *)"items", -1)) != NULL)
 {
 	if (di->di_tv.v_type != VAR_LIST)
 	{
 	    emsg(_(e_listreq));

Mercurial > vim

comparison src/tag.c @ 16447:54ffc82f38a8 v8.1.1228