Return to tag.c CVS log

Up to [local] / src / usr.bin / vim

Initial import of vim 4.2.

This is meant to replace nvi in the tree.  Vim, in general, works better,
provides more features, and does not suffer from the license problems
being imposed upon nvi.

On the other hand, vim lacks a non-visual ex mode, in addition to open mode.

This includes the GUI (X11) code, but doesn't try to compile it.

/*	$OpenBSD: tag.c,v 1.1.1.1 1996/09/07 21:40:24 downsj Exp $	*/
/* vi:set ts=4 sw=4:
 *
 * VIM - Vi IMproved		by Bram Moolenaar
 *
 * Do ":help uganda"  in Vim to read copying and usage conditions.
 * Do ":help credits" in Vim to see a list of people who contributed.
 */

/*
 * Code to handle tags and the tag stack
 */

#include "vim.h"
#include "globals.h"
#include "proto.h"
#include "option.h"

static int get_tagfname __ARGS((int, char_u	*));

#ifdef EMACS_TAGS
static int parse_tag_line __ARGS((char_u *, int,
					  char_u **, char_u **, char_u **, char_u **, char_u **));
static int jumpto_tag __ARGS((char_u *, int, char_u *, char_u *));
#else
static int parse_tag_line __ARGS((char_u *,
					  char_u **, char_u **, char_u **, char_u **, char_u **));
static int jumpto_tag __ARGS((char_u *, char_u *));
#endif
static int test_for_static __ARGS((char_u **, char_u *, char_u *, char_u *));
static char_u *expand_rel_name __ARGS((char_u *fname, char_u *tag_fname));
static void simplify_filename __ARGS((char_u *filename));
#ifdef EMACS_TAGS
static int test_for_current __ARGS((int, char_u *, char_u *, char_u *));
#else
static int test_for_current __ARGS((char_u *, char_u *, char_u *));
#endif

static char_u *bottommsg = (char_u *)"at bottom of tag stack";
static char_u *topmsg = (char_u *)"at top of tag stack";

/*
 * Jump to tag; handling of tag stack
 *
 * *tag != NUL (:tag): jump to new tag, add to tag stack
 * type == 1 (:pop) || type == 2 (CTRL-T): jump to old position
 * type == 0 (:tag): jump to old tag
 */
	void
do_tag(tag, type, count)
	char_u	*tag;
	int		type;
	int		count;
{
	int 			i;
	struct taggy	*tagstack = curwin->w_tagstack;
	int				tagstackidx = curwin->w_tagstackidx;
	int				tagstacklen = curwin->w_tagstacklen;
	int				oldtagstackidx = tagstackidx;

	if (*tag != NUL)						/* new pattern, add to the stack */
	{
		/*
		 * if last used entry is not at the top, delete all tag stack entries
		 * above it.
		 */
		while (tagstackidx < tagstacklen)
			vim_free(tagstack[--tagstacklen].tagname);

				/* if tagstack is full: remove oldest entry */
		if (++tagstacklen > TAGSTACKSIZE)
		{
			tagstacklen = TAGSTACKSIZE;
			vim_free(tagstack[0].tagname);
			for (i = 1; i < tagstacklen; ++i)
				tagstack[i - 1] = tagstack[i];
			--tagstackidx;
		}

		/*
		 * put the tag name in the tag stack
		 * the position is added below
		 */
		tagstack[tagstackidx].tagname = strsave(tag);
	}
	else if (tagstacklen == 0)					/* empty stack */
	{
		EMSG("tag stack empty");
		goto end_do_tag;
	}
	else if (type)								/* go to older position */
	{
		if ((tagstackidx -= count) < 0)
		{
			emsg(bottommsg);
			if (tagstackidx + count == 0)
			{
				/* We did ^T (or <num>^T) from the bottom of the stack */
				tagstackidx = 0;
				goto end_do_tag;
			}
			/* We weren't at the bottom of the stack, so jump all the way to
			 * the bottom.
			 */
			tagstackidx = 0;
		}
		else if (tagstackidx >= tagstacklen)	/* must have been count == 0 */
		{
			emsg(topmsg);
			goto end_do_tag;
		}
		if (tagstack[tagstackidx].fmark.fnum != curbuf->b_fnum)
		{
			/*
			 * Jump to other file. If this fails (e.g. because the file was
			 * changed) keep original position in tag stack.
			 */
			if (buflist_getfile(tagstack[tagstackidx].fmark.fnum,
				 tagstack[tagstackidx].fmark.mark.lnum, GETF_SETMARK) == FAIL)
			{
				tagstackidx = oldtagstackidx;	/* back to old position */
				goto end_do_tag;
			}
		}
		else
			curwin->w_cursor.lnum = tagstack[tagstackidx].fmark.mark.lnum;
		curwin->w_cursor.col = tagstack[tagstackidx].fmark.mark.col;
		curwin->w_set_curswant = TRUE;
		goto end_do_tag;
	}
	else									/* go to newer pattern */
	{
		if ((tagstackidx += count - 1) >= tagstacklen)
		{
			/*
			 * beyond the last one, just give an error message and go to the
			 * last one
			 */
			tagstackidx = tagstacklen - 1;
			emsg(topmsg);
		}
		else if (tagstackidx < 0)			/* must have been count == 0 */
		{
			emsg(bottommsg);
			tagstackidx = 0;
			goto end_do_tag;
		}
	}
	/*
	 * For :tag [arg], remember position before the jump
	 */
	if (type == 0)
	{
		tagstack[tagstackidx].fmark.mark = curwin->w_cursor;
		tagstack[tagstackidx].fmark.fnum = curbuf->b_fnum;
	}
	/* curwin will change in the call to find_tags() if ^W^] was used -- webb */
	curwin->w_tagstackidx = tagstackidx;
	curwin->w_tagstacklen = tagstacklen;
	if (find_tags(tagstack[tagstackidx].tagname, NULL, NULL, NULL, FALSE) > 0)
		++tagstackidx;

end_do_tag:
	curwin->w_tagstackidx = tagstackidx;
	curwin->w_tagstacklen = tagstacklen;
}

/*
 * Print the tag stack
 */
	void
do_tags()
{
	int				i;
	char_u			*name;
	struct taggy	*tagstack = curwin->w_tagstack;
	int				tagstackidx = curwin->w_tagstackidx;
	int				tagstacklen = curwin->w_tagstacklen;

	set_highlight('t');		/* Highlight title */
	start_highlight();
	MSG_OUTSTR("\n  # TO tag      FROM line in file");
	stop_highlight();
	for (i = 0; i < tagstacklen; ++i)
	{
		if (tagstack[i].tagname != NULL)
		{
			name = fm_getname(&(tagstack[i].fmark));
			if (name == NULL)		/* file name not available */
				continue;

			msg_outchar('\n');
			sprintf((char *)IObuff, "%c%2d %-15s %4ld  %s",
				i == tagstackidx ? '>' : ' ',
				i + 1,
				tagstack[i].tagname,
				tagstack[i].fmark.mark.lnum,
				name);
			msg_outtrans(IObuff);
		}
		flushbuf();					/* show one line at a time */
	}
	if (tagstackidx == tagstacklen)		/* idx at top of stack */
		MSG_OUTSTR("\n>");
}

/*
 * find_tags() - goto tag or search for tags in tags files
 *
 * If "tag" is not NULL, search for a single tag and jump to it.
 *   return FAIL for failure, OK for success
 * If "tag" is NULL, find all tags matching the regexp given with 'prog'.
 *   return FAIL if search completely failed, OK otherwise.
 *
 * There is a priority in which type of tag is recognized. It is computed
 * from the PRI_ defines below.
 *
 *  6.  A static or global tag with a full matching tag for the current file.
 *  5.  A global tag with a full matching tag for another file.
 *  4.  A static tag with a full matching tag for another file.
 *  2.  A static or global tag with an ignore-case matching tag for the
 *  	current file.
 *  1.  A global tag with an ignore-case matching tag for another file.
 *  0.  A static tag with an ignore-case matching tag for another file.
 *
 *  Tags in an emacs-style tags file are always global.
 */
#define PRI_GLOBAL			1		/* global or emacs tag */
#define PRI_CURRENT			2		/* tag for current file */
#define PRI_FULL_MATCH		4		/* case of tag matches */

	int
find_tags(tag, prog, num_file, file, help_only)
	char_u		*tag;				/* NULL or tag to search for */
	regexp		*prog;				/* regexp program or NULL */
	int			*num_file;			/* return value: number of matches found */
	char_u		***file;			/* return value: array of matches found */
	int			help_only;			/* if TRUE: only tags for help files */
{
	FILE	   *fp;
	char_u	   *lbuf;					/* line buffer */
	char_u	   *tag_fname;				/* name of tag file */
	int			first_file;				/* trying first tag file */
	char_u	   *tagname, *tagname_end;	/* name of tag in current line */
	char_u	   *fname, *fname_end;		/* fname in current line */
	int			did_open = FALSE;		/* did open a tag file */
	int			stop_searching = FALSE;	/* stop when match found or error */
	int			retval = FAIL;			/* return value */
	int			is_static;				/* current tag line is static */
	int			is_current;				/* file name matches */
	register char_u	*p;
#ifdef EMACS_TAGS
	char_u	   *ebuf;					/* aditional buffer for etag fname */
	int			is_etag;				/* current file is emaces style */
#endif

/*
 * Variables used only when "tag" != NULL
 */
	int			taglen = 0;				/* init for GCC */
	int			cmplen;
	int			full_match;
	int			icase_match;
	int			priority;				/* priority of current line */

	char_u		*bestmatch_line = NULL;	/* saved line for best match found so
											far */
	char_u		*bestmatch_tag_fname = NULL;
										/* copy of tag_fname for best match */
	int			bestmatch_priority = 0; /* best match priority */

#ifdef EMACS_TAGS
	/*
	 * Stack for included emacs-tags file.
	 * It has a fixed size, to truncate cyclic includes. jw
	 */
# define INCSTACK_SIZE 42
	struct
	{
	    FILE	*fp;
		char_u	*tag_fname;
	} incstack[INCSTACK_SIZE];

	int			incstack_idx = 0;			/* index in incstack */
	char_u	   *bestmatch_ebuf = NULL;		/* copy of ebuf for best match */
	int			bestmatch_is_etag = FALSE;	/* copy of is_etag for best match */
#endif

/*
 * Variables used when "tag" == NULL
 */
	char_u	**matches = NULL;			/* array of matches found */
	char_u	**new_matches;
	int		match_limit = 100;			/* max. number of matches stored */
	int		match_count = 0;			/* number of matches found */
	int		i;
	int		help_save;

	help_save = curbuf->b_help;
/*
 * Allocate memory for the buffers that are used
 */
	lbuf = alloc(LSIZE);
#ifdef EMACS_TAGS
	ebuf = alloc(LSIZE);
#endif
	tag_fname = alloc(LSIZE + 1);
									/* check for out of memory situation */
	if ((tag == NULL && prog == NULL) || lbuf == NULL || tag_fname == NULL
#ifdef EMACS_TAGS
														 || ebuf == NULL
#endif
																		)
		goto findtag_end;
	if (tag == NULL)
	{
		matches = (char_u **)alloc((unsigned)(match_limit * sizeof(char_u *)));
		if (matches == NULL)
			goto findtag_end;
	}

/*
 * Initialize a few variables
 */
	if (tag != NULL)
	{
		taglen = STRLEN(tag);
		if (p_tl != 0 && taglen > p_tl)		/* adjust for 'taglength' */
			taglen = p_tl;
	}
	else if (help_only)				/* want tags from help file */
		curbuf->b_help = TRUE;

/*
 * Try tag file names from tags option one by one.
 */
	for (first_file = TRUE; get_tagfname(first_file, tag_fname) == OK;
															first_file = FALSE)
	{
		/*
		 * A file that doesn't exist is silently ignored.
		 */
		if ((fp = fopen((char *)tag_fname, "r")) == NULL)
			continue;
		did_open = TRUE;	/* remember that we found at least one file */

#ifdef EMACS_TAGS
		is_etag = 0;		/* default is: not emacs style */
#endif
		/*
		 * Read and parse the lines in the file one by one
		 */
		while (!got_int)
		{
			line_breakcheck();

			if (vim_fgets(lbuf, LSIZE, fp))
#ifdef EMACS_TAGS
				if (incstack_idx)		/* this was an included file */
				{
					--incstack_idx;
					fclose(fp);			/* end of this file ... */
					fp = incstack[incstack_idx].fp;
					STRCPY(tag_fname, incstack[incstack_idx].tag_fname);
					vim_free(incstack[incstack_idx].tag_fname);
					is_etag = 1;		/* (only etags can include) */
					continue;			/* ... continue with parent file */
				}
				else
#endif
					break;							/* end of file */

#ifdef EMACS_TAGS
			/*
			 * Emacs tags line with CTRL-L: New file name on next line.
			 * The file name is followed by a ','.
			 */
			if (*lbuf == Ctrl('L'))		/* remember etag filename in ebuf */
			{
				is_etag = 1;	
				if (!vim_fgets(ebuf, LSIZE, fp))
				{
					for (p = ebuf; *p && *p != ','; p++)
						;
					*p = NUL;

					/* 
					 * atoi(p+1) is the number of bytes before the next ^L
					 * unless it is an include statement.
					 */
					if (STRNCMP(p + 1, "include", 7) == 0 &&
												 incstack_idx < INCSTACK_SIZE)
					{
						if ((incstack[incstack_idx].tag_fname =
												  strsave(tag_fname)) != NULL)
						{
							incstack[incstack_idx].fp = fp;
							if ((fp = fopen((char *)ebuf, "r")) == NULL)
							{
								fp = incstack[incstack_idx].fp;
								vim_free(incstack[incstack_idx].tag_fname);
							}
							else
							{
								STRCPY(tag_fname, ebuf);
								++incstack_idx;
							}
							is_etag = 0;	/* we can include anything */
						}
					}
				}
				continue;
			}
#endif

			/*
			 * Figure out where the different strings are in this line.
			 * For "normal" tags: Do a quick check if the tag matches.
			 * This speeds up tag searching a lot!
			 */
			if (tag != NULL
#ifdef EMACS_TAGS
							&& !is_etag
#endif
										)
			{
				tagname = lbuf;
				fname = NULL;
				for (tagname_end = lbuf; *tagname_end &&
									!vim_iswhite(*tagname_end); ++tagname_end)
				{
					if (*tagname_end == ':')
					{
						if (fname == NULL)
							fname = skipwhite(skiptowhite(tagname_end));
						if (fnamencmp(lbuf, fname, tagname_end - lbuf) == 0 &&
									   vim_iswhite(fname[tagname_end - lbuf]))
							tagname = tagname_end + 1;
					}
				}

				/*
				 * Skip this line if the lenght of the tag is different.
				 */
				cmplen = tagname_end - tagname;
				if (p_tl != 0 && cmplen > p_tl)		/* adjust for 'taglength' */
					cmplen = p_tl;
				if (taglen != cmplen)
					continue;

				/*
				 * Skip this line if the tag does not match (ignoring case).
				 */
				if (vim_strnicmp(tagname, tag, (size_t)cmplen))
					continue;

				/*
				 * This is a useful tag, isolate the filename.
				 */
				if (fname == NULL)
					fname = skipwhite(skiptowhite(tagname_end));
				fname_end = skiptowhite(fname);
				if (*fname_end == NUL)
					i = FAIL;
				else
					i = OK;
			}
			else
				i = parse_tag_line(lbuf,
#ifdef EMACS_TAGS
								   is_etag,
#endif
							&tagname, &tagname_end, &fname, &fname_end, NULL);
			if (i == FAIL)
			{
				EMSG2("Format error in tags file \"%s\"", tag_fname);
				stop_searching = TRUE;
				break;
			}

#ifdef EMACS_TAGS
			is_static = FALSE;
			if (!is_etag)		/* emacs tags are never static */
#endif
				is_static = test_for_static(&tagname, tagname_end, 
															fname, fname_end);
#ifdef EMACS_TAGS
			if (is_etag)
				fname = ebuf;
#endif
			/*
			 * "tag" == NULL: find tags matching regexp "prog"
			 */
			if (tag == NULL)
			{
				*tagname_end = NUL;
				if (vim_regexec(prog, tagname, TRUE))
				{
					is_current = test_for_current(
#ifdef EMACS_TAGS
							is_etag,
#endif
									 fname, fname_end, tag_fname);
					if (!is_static || is_current)
					{
						/*
						 * Found a match, add it to matches[].
						 * May need to make matches[] larger.
						 */
						if (match_count == match_limit)
						{
							match_limit += 100;
							new_matches = (char_u **)alloc(
									(unsigned)(match_limit * sizeof(char_u *)));
							if (new_matches == NULL)
							{
								/* Out of memory! Just forget about the rest
								 * of the matches. */
								retval = OK;
								stop_searching = TRUE;
								break;
							}
							for (i = 0; i < match_count; i++)
								new_matches[i] = matches[i];
							vim_free(matches);
							matches = new_matches;
						}
						if (help_only)
						{
							int		len;

							/*
							 * Append the help-heuristic number after the
							 * tagname, for sorting it later.
							 */
							len = STRLEN(tagname);
							p = alloc(len + 10);
							if (p != NULL)
							{
								STRCPY(p, tagname);
								sprintf((char *)p + len + 1, "%06d",
													   help_heuristic(tagname,
										   (int)(prog->startp[0] - tagname)));
							}
							matches[match_count++] = p;
						}
						else
							matches[match_count++] = strsave(tagname);
					}
				}
			}
			/*
			 * "tag" != NULL: find tag and jump to it
			 */
			else
			{
				/*
				 * If tag length does not match, skip the rest
				 */
				cmplen = tagname_end - tagname;
				if (p_tl != 0 && cmplen > p_tl)		/* adjust for 'taglength' */
					cmplen = p_tl;
				if (taglen == cmplen)
				{
					/*
					 * Check for match (ignoring case).
					 */
					icase_match = (vim_strnicmp(tagname, tag,
														(size_t)cmplen) == 0);
					if (icase_match)	/* Tag matches somehow */
					{
						/*
						 * If it's a full match for the current file, jump to
						 * it now.
						 */
						full_match = (STRNCMP(tagname, tag, cmplen) == 0);
						is_current = test_for_current(
#ifdef EMACS_TAGS
								is_etag,
#endif
										 fname, fname_end, tag_fname);
						if (full_match && is_current)
						{
							retval = jumpto_tag(lbuf,
#ifdef EMACS_TAGS
													is_etag, ebuf,
#endif
																   tag_fname);
							stop_searching = TRUE;
							break;
						}

						/*
						 * If the priority of the current line is higher than
						 * the best match so far, store it as the best match
						 */
						if (full_match)
							priority = PRI_FULL_MATCH;
						else
							priority = 0;
						if (is_current)
							priority += PRI_CURRENT;
						if (!is_static)
							priority += PRI_GLOBAL;

						if (priority > bestmatch_priority)
						{
							vim_free(bestmatch_line);
							bestmatch_line = strsave(lbuf);
							vim_free(bestmatch_tag_fname);
							bestmatch_tag_fname = strsave(tag_fname);
							bestmatch_priority = priority;
#ifdef EMACS_TAGS
							bestmatch_is_etag = is_etag;
							if (is_etag)
							{
								vim_free(bestmatch_ebuf);
								bestmatch_ebuf = strsave(ebuf);
							}
#endif
						}
					}
				}
			}
		}
		fclose(fp);
#ifdef EMACS_TAGS
		while (incstack_idx)
		{
			--incstack_idx;
			fclose(incstack[incstack_idx].fp);
			vim_free(incstack[incstack_idx].tag_fname);
		}
#endif
		if (stop_searching)
			break;

		/*
		 * Stop searching if a tag was found in the current tags file and
		 * we got a global match with matching case or 'ignorecase' is set.
		 */
		if (tag != NULL && bestmatch_line != NULL &&
			   bestmatch_priority >= (p_ic ? 0 : PRI_FULL_MATCH) + PRI_GLOBAL)
			break;
	}

	if (!stop_searching)
	{
		if (!did_open)						/* never opened any tags file */
			EMSG("No tags file");
		else if (tag == NULL)
		{
			retval = OK;		/* It's OK even when no tag found */
		}
		else
		{
			/*
			 * If we didn't find a static full match, use the best match found.
			 */
			if (bestmatch_line != NULL)
			{
				if (bestmatch_priority < PRI_FULL_MATCH)
				{
					MSG("Only found tag with different case!");
					if (!msg_scrolled)
					{
						flushbuf();
						mch_delay(1000L, TRUE);
					}
				}
				retval = jumpto_tag(bestmatch_line,
#ifdef EMACS_TAGS
						bestmatch_is_etag, bestmatch_ebuf,
#endif
						bestmatch_tag_fname);
			}
			else
				EMSG("tag not found");
		}
	}

findtag_end:
	vim_free(lbuf);
	vim_free(tag_fname);
	vim_free(bestmatch_line);
	vim_free(bestmatch_tag_fname);
#ifdef EMACS_TAGS
	vim_free(ebuf);
	vim_free(bestmatch_ebuf);
#endif

	if (tag == NULL)
	{
		if (retval == FAIL)			/* free all matches found */
			while (match_count > 0)
				vim_free(matches[--match_count]);
		if (match_count == 0)		/* nothing found, free matches[] */
		{
			vim_free(matches);
			matches = NULL;
		}
		*file = matches;
		*num_file = match_count;
	}
	curbuf->b_help = help_save;

	return retval;
}

/*
 * Get the next name of a tag file from the tag file list.
 * For help files, use "vim_tags" file only.
 *
 * Return FAIL if no more tag file names, OK otherwise.
 */
	static int
get_tagfname(first, buf)
	int		first;			/* TRUE when first file name is wanted */
	char_u	*buf;			/* pointer to buffer of LSIZE chars */
{
	static char_u	*np = NULL;
	char_u			*fname;
	size_t			path_len, fname_len;
	/*
	 * A list is made of the files that have been visited.
	 */
	struct visited
	{
		struct visited	*v_next;
#if defined(UNIX)
		struct stat		v_st;
#else
		char_u			v_fname[1];		/* actually longer */
#endif
	};
	static struct visited	*first_visited = NULL;
	struct visited			*vp;
#if defined(UNIX)
	struct stat				st;
#endif

	if (first)
	{
		np = p_tags;
		while (first_visited != NULL)
		{
			vp = first_visited->v_next;
			vim_free(first_visited);
			first_visited = vp;
		}
	}

	if (np == NULL)			/* tried allready (or bogus call) */
		return FAIL;

	/*
	 * For a help window only try the file 'vim_tags' in the same
	 * directory as 'helpfile'.
	 */
	if (curbuf->b_help)
	{
		path_len = gettail(p_hf) - p_hf;
		if (path_len + 9 >= LSIZE)
			return FAIL;
		vim_memmove(buf, p_hf, path_len);
		STRCPY(buf + path_len, "vim_tags");

		np = NULL;				/* try only once */
	}

	else
	{
		/*
		 * Loop until we have found a file name that can be used.
		 */
		for (;;)
		{
			if (*np == NUL)			/* tried all possibilities */
				return FAIL;

			/*
			 * Copy next file name into buf.
			 */
			(void)copy_option_part(&np, buf, LSIZE, " ,");

			/*
			 * Tag file name starting with "./": Replace '.' with path of
			 * current file.
			 */
			if (buf[0] == '.' && ispathsep(buf[1]))
			{
				if (curbuf->b_filename == NULL)	/* skip if no filename */
					continue;

				path_len = gettail(curbuf->b_filename) - curbuf->b_filename;
				fname = buf + 1;
				while (ispathsep(*fname))		/* skip '/' and the like */
					++fname;
				fname_len = STRLEN(fname);
				if (fname_len + path_len + 1 > LSIZE)
					continue;
				vim_memmove(buf + path_len, fname, fname_len + 1);
				vim_memmove(buf, curbuf->b_filename, path_len);
			}

			/*
			 * Check if this tags file has been used already.
			 * If file doesn't exist, skip it.
			 */
#if defined(UNIX)
			if (stat((char *)buf, &st) < 0)
#else
			if (FullName(buf, NameBuff, MAXPATHL, TRUE) == FAIL)
#endif
				continue;

			for (vp = first_visited; vp != NULL; vp = vp->v_next)
#if defined(UNIX)
				if (vp->v_st.st_dev == st.st_dev &&
												 vp->v_st.st_ino == st.st_ino)
#else
				if (fnamecmp(vp->v_fname, NameBuff) == 0)
#endif
					break;

			if (vp != NULL)			/* already visited, skip it */
				continue;

			/*
			 * Found the next name.  Add it to the list of visited files.
			 */
#if defined(UNIX)
			vp = (struct visited *)alloc((unsigned)sizeof(struct visited));
#else
			vp = (struct visited *)alloc((unsigned)(sizeof(struct visited) +
														   STRLEN(NameBuff)));
#endif
			if (vp != NULL)
			{
#if defined(UNIX)
				vp->v_st = st;
#else
				STRCPY(vp->v_fname, NameBuff);
#endif
				vp->v_next = first_visited;
				first_visited = vp;
			}
			break;
		}
	}
	return OK;
}

/*
 * Parse one line from the tags file. Find start/end of tag name, start/end of
 * file name and start of search pattern.
 *
 * If is_etag is TRUE, fname and fname_end are not set.
 * If command == NULL it is not set.
 *
 * Return FAIL if there is a format error in this line, OK otherwise.
 */
	static int
parse_tag_line(lbuf,
#ifdef EMACS_TAGS
					is_etag,
#endif
							  tagname, tagname_end, fname, fname_end, command)
	char_u		*lbuf;
#ifdef EMACS_TAGS
	int			is_etag;
#endif
	char_u		**tagname;
	char_u		**tagname_end;
	char_u		**fname;
	char_u		**fname_end;
	char_u		**command;
{
	char_u		*p;

#ifdef EMACS_TAGS
	char_u		*p_7f;

	if (is_etag)
	{
		/*
		 * There are two formats for an emacs tag line:
		 * 1:  struct EnvBase ^?EnvBase^A139,4627
		 * 2: #define	ARPB_WILD_WORLD ^?153,5194
		 */
		p_7f = vim_strchr(lbuf, 0x7f);
		if (p_7f == NULL)
			return FAIL;
										/* find start of line number */
		for (p = p_7f + 1; *p < '0' || *p > '9'; ++p)
			if (*p == NUL)
				return FAIL;
		if (command != NULL)
			*command = p;

								/* first format: explicit tagname given */
		if (p[-1] == Ctrl('A'))
		{
			*tagname = p_7f + 1;
			*tagname_end = p - 1;
		}
		else
								/* second format: isolate tagname */
		{
			/* find end of tagname */
			for (p = p_7f - 1; *p == ' ' || *p == '\t' || 
												  *p == '(' || *p == ';'; --p)
				if (p == lbuf)
					return FAIL;
			*tagname_end = p + 1;
			while (p >= lbuf && *p != ' ' && *p != '\t')
				--p;
			*tagname = p + 1;
		}
	}
	else
	{
#endif
			/* Isolate the tagname, from lbuf up to the first white */
		*tagname = lbuf;
		p = skiptowhite(lbuf);
		if (*p == NUL)
			return FAIL;
		*tagname_end = p;

			/* Isolate file name, from first to second white space */
		p = skipwhite(p);
		*fname = p;
		p = skiptowhite(p);
		if (*p == NUL)
			return FAIL;
		*fname_end = p;

			/* find start of search command, after second white space */
		if (command != NULL)
		{
			p = skipwhite(p);
			if (*p == NUL)
				return FAIL;
			*command = p;
		}
#ifdef EMACS_TAGS
	}
#endif

	return OK;
}

/*
 * Check if tagname is a static tag
 *
 * Static tags produced by the ctags program have the
 * format: 'file:tag  file  /pattern'.
 * This is only recognized when both occurences of 'file'
 * are the same, to avoid recognizing "string::string" or
 * ":exit".
 *
 * Return TRUE if it is a static tag and adjust *tagname to the real tag.
 * Return FALSE if it is not a static tag.
 */
	static int
test_for_static(tagname, tagname_end, fname, fname_end)
	char_u		**tagname;
	char_u		*tagname_end;
	char_u		*fname;
	char_u		*fname_end;
{
	char_u		*p;

	p = *tagname + (fname_end - fname);
	if (p < tagname_end && *p == ':' &&
							fnamencmp(*tagname, fname, fname_end - fname) == 0)
	{
		*tagname = p + 1;
		return TRUE;
	}
	return FALSE;
}

/*
 * Jump to a tag that has been found in one of the tag files
 */
	static int
jumpto_tag(lbuf,
#ifdef EMACS_TAGS
				is_etag, etag_fname,
#endif
									tag_fname)
	char_u		*lbuf;			/* line from the tags file for this tag */
#ifdef EMACS_TAGS
	int			is_etag;		/* TRUE if it's from an emacs tags file */
	char_u		*etag_fname;	/* file name for tag if is_etag is TRUE */
#endif
	char_u		*tag_fname;		/* file name of the tags file itself */
{
	int			save_secure;
	int			save_p_ws, save_p_scs, save_p_ic;
	char_u		*str;
	char_u		*pbuf;					/* search pattern buffer */
	char_u		*p;
	char_u		*expanded_fname = NULL;
	char_u		*tagname, *tagname_end;
	char_u		*fname, *fname_end;
	char_u		*orig_fname;
	int			retval = FAIL;
	int			getfile_result;
	int			search_options;

	pbuf = alloc(LSIZE);

	if (pbuf == NULL
#ifdef EMACS_TAGS
					|| (is_etag && etag_fname == NULL)
#endif
														|| tag_fname == NULL)
		goto erret;

	/*
	 * find the search pattern (caller should check it is there)
	 */
	if (parse_tag_line(lbuf,
#ifdef EMACS_TAGS
							   is_etag,
#endif
					&tagname, &tagname_end, &fname, &fname_end, &str) == FAIL)
		goto erret;
	orig_fname = fname;		/* remember for test_for_static() below */

#ifdef EMACS_TAGS
	if (is_etag)
		fname = etag_fname;
	else
#endif
		*fname_end = NUL;

	/*
	 * If the command is a string like "/^function fname"
	 * scan through the search string. If we see a magic
	 * char, we have to quote it. This lets us use "real"
	 * implementations of ctags.
	 */
	if (*str == '/' || *str == '?')
	{
		p = pbuf;
		*p++ = *str++;			/* copy the '/' or '?' */
		if (*str == '^')
			*p++ = *str++;			/* copy the '^' */

		while (*str)
		{
			switch (*str)
			{
						/* Always remove '\' before '('.
						 * Remove a '\' befor '*' if 'nomagic'.
						 * Otherwise just copy the '\' and don't look at the
						 * next character
						 */
			case '\\':	if (str[1] == '(' || (!p_magic && str[1] == '*'))
							++str;
						else
							*p++ = *str++;
						break;

			case '\r':
			case '\n':	*str = pbuf[0];	/* copy '/' or '?' */
						str[1] = NUL;	/* delete NL after CR */
						break;

						/*
						 * if string ends in search character: skip it
						 * else escape it with '\'
						 */
			case '/':
			case '?':	if (*str != pbuf[0])	/* not the search char */
							break;
												/* last char */
						if (str[1] == '\n' || str[1] == '\r')
						{
							++str;
							continue;
						}
			case '[':
						if (!p_magic)
							break;
			case '^':
			case '*':
			case '~':
			case '.':	*p++ = '\\';
						break;
			}
			*p++ = *str++;
		}
	}
	else		/* not a search command, just copy it */
	{
		for (p = pbuf; *str && *str != '\n'; )
		{
#ifdef EMACS_TAGS
			if (is_etag && *str == ',')		/* stop at ',' after line number */
				break;
#endif
			*p++ = *str++;
		}
	}
	*p = NUL;

	/*
	 * expand filename (for environment variables)
	 */
	expanded_fname = ExpandOne((char_u *)fname, NULL, WILD_LIST_NOTFOUND,
															WILD_EXPAND_FREE);
	if (expanded_fname != NULL)
		fname = expanded_fname;

	/*
	 * if 'tagrelative' option set, may change file name
	 */
	fname = expand_rel_name(fname, tag_fname);

	/*
	 * check if file for tag exists before abandoning current file
	 */
	if (getperm(fname) < 0)
	{
		EMSG2("File \"%s\" does not exist", fname);
		goto erret;
	}

	++RedrawingDisabled;
	/*
	 * if it was a CTRL-W CTRL-] command split window now
	 */
	if (postponed_split)
		win_split(0, FALSE);
	/*
	 * A :ta from a help file will keep the b_help flag set.
	 */
	keep_help_flag = curbuf->b_help;
	getfile_result = getfile(0, fname, NULL, TRUE, (linenr_t)0);

	if (getfile_result <= 0)			/* got to the right file */
	{
		curwin->w_set_curswant = TRUE;
		postponed_split = FALSE;

		save_secure = secure;
		secure = 1;
		/*
		 * If 'cpoptions' contains 't', store the search pattern for the "n"
		 * command.  If 'cpoptions' does not contain 't', the search pattern
		 * is not stored.
		 */
		if (vim_strchr(p_cpo, CPO_TAGPAT) != NULL)
			search_options = 0;
		else
			search_options = SEARCH_KEEP;

		/*
		 * if the command is a search, try here
		 *
		 * Rather than starting at line one, just turn wrap-scan
		 * on temporarily, this ensures that tags on line 1 will
		 * be found, and makes sure our guess searches search the
		 * whole file when repeated -- webb.
		 * Also reset 'smartcase' for the search, since the search
		 * pattern was not typed by the user.
		 */
		if (pbuf[0] == '/' || pbuf[0] == '?')
		{
			save_p_ws = p_ws;
			save_p_ic = p_ic;
			save_p_scs = p_scs;
			p_ws = TRUE;	/* Switch wrap-scan on temporarily */
			p_ic = FALSE;	/* don't ignore case now */
			p_scs = FALSE;
			add_to_history(1, pbuf + 1);	/* put pattern in search history */

			if (do_search(pbuf[0], pbuf + 1, (long)1, search_options))
				retval = OK;
			else
			{
				register int notfound = FALSE;

				/*
				 * try again, ignore case now
				 */
				p_ic = TRUE;
				if (!do_search(pbuf[0], pbuf + 1, (long)1, search_options))
				{
					/*
					 * Failed to find pattern, take a guess: "^func  ("
					 */
					(void)test_for_static(&tagname, tagname_end,
														orig_fname, fname_end);
					*tagname_end = NUL;
					sprintf((char *)pbuf, "^%s[ \t]*(", tagname);
					if (!do_search('/', pbuf, (long)1, search_options))
					{
						/* Guess again: "^char * func  (" */
						sprintf((char *)pbuf, "^[#a-zA-Z_].*%s[ \t]*(",
																	 tagname);
						if (!do_search('/', pbuf, (long)1, search_options))
							notfound = TRUE;
					}
				}
				if (notfound)
					EMSG("Can't find tag pattern");
				else
				{
					MSG("Couldn't find tag, just guessing!");
					if (!msg_scrolled)
					{
						flushbuf();
						mch_delay(1000L, TRUE);
					}
					retval = OK;
				}
			}
			p_ws = save_p_ws;
			p_ic = save_p_ic;
			p_scs = save_p_scs;
		}
		else
		{							/* start command in line 1 */
			curwin->w_cursor.lnum = 1;
			do_cmdline(pbuf, TRUE, TRUE);
			retval = OK;
		}

		if (secure == 2)			/* done something that is not allowed */
			wait_return(TRUE);
		secure = save_secure;

		/*
		 * Print the file message after redraw if jumped to another file.
		 * Don't do this for help files (avoid a hit-return message).
		 */
		if (getfile_result == -1)
		{
			if (!curbuf->b_help)
				need_fileinfo = TRUE;
			retval = OK;			/* always return OK if jumped to another
									   file (at least we found the file!) */
		}

		/*
		 * For a help buffer: Put the cursor line at the top of the window,
		 * the help subject will be below it.
		 */
		if (curbuf->b_help)
		{
			curwin->w_topline = curwin->w_cursor.lnum;
			comp_Botline(curwin);
			cursupdate();		/* take care of 'scrolloff' */
			updateScreen(NOT_VALID);
		}
		--RedrawingDisabled;
	}
	else
	{
		--RedrawingDisabled;
		if (postponed_split)			/* close the window */
		{
			close_window(curwin, FALSE);
			postponed_split = FALSE;
		}
	}

erret:
	vim_free(pbuf);
	vim_free(expanded_fname);

	return retval;
}

/*
 * If 'tagrelative' option set, change fname (name of file containing tag)
 * according to tag_fname (name of tag file containing fname).
 */
	static char_u *
expand_rel_name(fname, tag_fname)
	char_u		*fname;
	char_u		*tag_fname;
{
	char_u		*p;

	if ((p_tr || curbuf->b_help) && !isFullName(fname) &&
									   (p = gettail(tag_fname)) != tag_fname)
	{
		STRCPY(NameBuff, tag_fname);
		STRNCPY(NameBuff + (p - tag_fname), fname,
												 MAXPATHL - (p - tag_fname));
		/*
		 * Translate names like "src/a/../b/file.c" into "src/b/file.c".
		 */
		simplify_filename(NameBuff);
		fname = NameBuff;
	}
	return fname;
}

/*
 * Moves the tail part of the path (including the terminating NUL) pointed to
 * by "tail" to the new location pointed to by "here". This should accomodate
 * an overlapping move.
 */
#define movetail(here, tail)  vim_memmove(here, tail, STRLEN(tail) + (size_t)1)

/*
 * For MS-DOS we should check for backslash too, but that is complicated.
 */
#define DIR_SEP		'/'			/* the directory separator character */

/*
 * Converts a filename into a canonical form. It simplifies a filename into
 * its simplest form by stripping out unneeded components, if any.  The
 * resulting filename is simplified in place and will either be the same
 * length as that supplied, or shorter.
 */
	static void
simplify_filename(filename)
	char_u *filename;
{
	int		absolute = FALSE;
	int		components = 0;
	char_u	*p, *tail;

	p = filename;
	if (*p == DIR_SEP)
	{
		absolute = TRUE;
		++p;
	}
	do
	{
		/*  Always leave "p" pointing to character following next "/". */
		if (*p == DIR_SEP)
			movetail(p, p+1);				/* strip duplicate "/" */
		else if (STRNCMP(p, "./", 2) == 0)
			movetail(p, p+2);				/* strip "./" */
		else if (STRNCMP(p, "../", 3) == 0)
		{
			if (components > 0)				/* strip any prev. component */
			{
				*(p - 1) = 0;				/* delete "/" before  "../" */
				tail  = p + 2;				/* skip to "/" of "../" */
				p = vim_strrchr(filename, DIR_SEP);	 /* find preceding sep. */
				if (p != NULL)				/* none found */
					++p;					/* skip to char after "/" */
				else
				{
					++tail;					/* strip leading "/" from tail*/
					p = filename;			/* go back to beginning */
					if (absolute)			/* skip over any leading "/" */
						++p;
				}
				movetail(p, tail);			/* strip previous component */
				--components;
			}
			else if (absolute)				/* no parent to root... */
				movetail(p, p+3);			/*   so strip "../" */
			else							/* leading series of "../" */
			{
				p = vim_strchr(p, DIR_SEP);	/* skip to next "/" */
				if (p != NULL)
					++p;					/* skip to char after "/" */
			}
		}
		else
		{
			++components;					/* simple path component */
			p = vim_strchr(p, DIR_SEP);			/* skip to next "/" */
			if (p != NULL)
				++p;						/* skip to char after "/" */
		}
	} while (p != NULL && *p != NUL);
}

/*
 * Check if we have a tag for the current file.
 * This is a bit slow, because of the full path compare in fullpathcmp().
 * Return TRUE if tag for file "fname" if tag file "tag_fname" is for current
 * file.
 */
	static int
#ifdef EMACS_TAGS
test_for_current(is_etag, fname, fname_end, tag_fname)
	int		is_etag;
#else
test_for_current(fname, fname_end, tag_fname)
#endif
	char_u	*fname;
	char_u	*fname_end;
	char_u	*tag_fname;
{
	int		c;
	int		retval;

	if (curbuf->b_filename == NULL)
		retval = FALSE;
	else
	{
#ifdef EMACS_TAGS
		if (is_etag)
			c = 0;			/* to shut up GCC */
		else
#endif
		{
			c = *fname_end;
			*fname_end = NUL;
		}
		retval = (fullpathcmp(expand_rel_name(fname, tag_fname),
											curbuf->b_xfilename) == FPC_SAME);
#ifdef EMACS_TAGS
		if (!is_etag)
#endif
			*fname_end = c;
	}

	return retval;
}