Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/mg/tags.c	Lines:	0	231	0.0 %
Date:	2016-12-06	Branches:	0	332	0.0 %


/*	$OpenBSD: tags.c,v 1.13 2016/01/19 11:39:06 sunil Exp $	*/

/*
 * This file is in the public domain.
 *
 * Author: Sunil Nimmagadda <sunil@openbsd.org>
 */

#include <sys/queue.h>
#include <sys/stat.h>
#include <sys/tree.h>
#include <sys/types.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <util.h>

#include "def.h"

struct ctag;

static int               addctag(char *);
static int               atbow(void);
void                     closetags(void);
static int               ctagcmp(struct ctag *, struct ctag *);
static int               loadbuffer(char *);
static int               loadtags(const char *);
static int               pushtag(char *);
static int               searchpat(char *);
static struct ctag       *searchtag(char *);
static char              *strip(char *, size_t);
static void              unloadtags(void);

#define DEFAULTFN "tags"

char *tagsfn = NULL;
int  loaded  = FALSE;

/* ctags(1) entries are parsed and maintained in a tree. */
struct ctag {
	RB_ENTRY(ctag) entry;
	char *tag;
	char *fname;
	char *pat;
};
RB_HEAD(tagtree, ctag) tags = RB_INITIALIZER(&tags);
RB_GENERATE(tagtree, ctag, entry, ctagcmp);

struct tagpos {
	SLIST_ENTRY(tagpos) entry;
	int    doto;
	int    dotline;
	char   *bname;
};
SLIST_HEAD(tagstack, tagpos) shead = SLIST_HEAD_INITIALIZER(shead);

int
ctagcmp(struct ctag *s, struct ctag *t)
{
	return strcmp(s->tag, t->tag);
}

/*
 * Record the filename that contain tags to be used while loading them
 * on first use. If a filename is already recorded, ask user to retain
 * already loaded tags (if any) and unload them if user chooses not to.
 */
/* ARGSUSED */
int
tagsvisit(int f, int n)
{
	char fname[NFILEN], *bufp, *temp;
	struct stat sb;

	if (getbufcwd(fname, sizeof(fname)) == FALSE)
		fname[0] = '\0';

	if (strlcat(fname, DEFAULTFN, sizeof(fname)) >= sizeof(fname)) {
		dobeep();
		ewprintf("Filename too long");
		return (FALSE);
	}

	bufp = eread("visit tags table (default %s): ", fname,
	    NFILEN, EFFILE | EFCR | EFNEW | EFDEF, DEFAULTFN);

	if (stat(bufp, &sb) == -1) {
		dobeep();
		ewprintf("stat: %s", strerror(errno));
		return (FALSE);
	} else if (S_ISREG(sb.st_mode) == 0) {
		dobeep();
		ewprintf("Not a regular file");
		return (FALSE);
	} else if (access(bufp, R_OK) == -1) {
		dobeep();
		ewprintf("Cannot access file %s", bufp);
		return (FALSE);
	}

	if (tagsfn == NULL) {
		if (bufp == NULL)
			return (ABORT);
		else if (bufp[0] == '\0') {
			if ((tagsfn = strdup(fname)) == NULL) {
				dobeep();
				ewprintf("Out of memory");
				return (FALSE);
			}
		} else {
			/* bufp points to local variable, so duplicate. */
			if ((tagsfn = strdup(bufp)) == NULL) {
				dobeep();
				ewprintf("Out of memory");
				return (FALSE);
			}
		}
	} else {
		if ((temp = strdup(bufp)) == NULL) {
			dobeep();
			ewprintf("Out of memory");
			return (FALSE);
		}
		free(tagsfn);
		tagsfn = temp;
		if (eyorn("Keep current list of tags table also") == FALSE) {
			ewprintf("Starting a new list of tags table");
			unloadtags();
		}
		loaded = FALSE;
	}
	return (TRUE);
}

/*
 * Ask user for a tag while treating word at dot as default. Visit tags
 * file if not yet done, load tags and jump to definition of the tag.
 */
int
findtag(int f, int n)
{
	char utok[MAX_TOKEN], dtok[MAX_TOKEN];
	char *tok, *bufp;
	int  ret;

	if (curtoken(f, n, dtok) == FALSE) {
		dtok[0] = '\0';
		bufp = eread("Find tag:", utok, MAX_TOKEN, EFNUL | EFNEW);
	} else
		bufp = eread("Find tag (default %s):", utok, MAX_TOKEN,
		    EFNUL | EFNEW, dtok);

	if (bufp == NULL)
		return (ABORT);
	else if	(bufp[0] == '\0')
		tok = dtok;
	else
		tok = utok;

	if (tok[0] == '\0') {
		dobeep();
		ewprintf("There is no default tag");
		return (FALSE);
	}

	if (tagsfn == NULL)
		if ((ret = tagsvisit(f, n)) != TRUE)
			return (ret);
	if (!loaded) {
		if (loadtags(tagsfn) == FALSE) {
			free(tagsfn);
			tagsfn = NULL;
			return (FALSE);
		}
		loaded = TRUE;
	}
	return pushtag(tok);
}

/*
 * Free tags tree.
 */
void
unloadtags(void)
{
	struct ctag *var, *nxt;

	for (var = RB_MIN(tagtree, &tags); var != NULL; var = nxt) {
		nxt = RB_NEXT(tagtree, &tags, var);
		RB_REMOVE(tagtree, &tags, var);
		/* line parsed with fparseln needs to be freed */
		free(var->tag);
		free(var);
	}
}

/*
 * Lookup tag passed in tree and if found, push current location and
 * buffername onto stack, load the file with tag definition into a new
 * buffer and position dot at the pattern.
 */
/*ARGSUSED */
int
pushtag(char *tok)
{
	struct ctag *res;
	struct tagpos *s;
	char bname[NFILEN];
	int doto, dotline;

	if ((res = searchtag(tok)) == NULL)
		return (FALSE);

	doto = curwp->w_doto;
	dotline = curwp->w_dotline;
	/* record absolute filenames. Fixes issues when mg's cwd is not the
	 * same as buffer's directory.
	 */
	if (strlcpy(bname, curbp->b_cwd, sizeof(bname)) >= sizeof(bname)) {
		dobeep();
		ewprintf("filename too long");
		return (FALSE);
	}
	if (strlcat(bname, curbp->b_bname, sizeof(bname)) >= sizeof(bname)) {
		dobeep();
		ewprintf("filename too long");
		return (FALSE);
	}

	if (loadbuffer(res->fname) == FALSE)
		return (FALSE);

	if (searchpat(res->pat) == TRUE) {
		if ((s = malloc(sizeof(struct tagpos))) == NULL) {
			dobeep();
			ewprintf("Out of memory");
			return (FALSE);
		}
		if ((s->bname = strdup(bname)) == NULL) {
			dobeep();
			ewprintf("Out of memory");
			free(s);
			return (FALSE);
		}
		s->doto = doto;
		s->dotline = dotline;
		SLIST_INSERT_HEAD(&shead, s, entry);
		return (TRUE);
	} else {
		dobeep();
		ewprintf("%s: pattern not found", res->tag);
		return (FALSE);
	}
	/* NOTREACHED */
	return (FALSE);
}

/*
 * If tag stack is not empty pop stack and jump to recorded buffer, dot.
 */
/* ARGSUSED */
int
poptag(int f, int n)
{
	struct line *dotp;
	struct tagpos *s;

	if (SLIST_EMPTY(&shead)) {
		dobeep();
		ewprintf("No previous location for find-tag invocation");
		return (FALSE);
	}
	s = SLIST_FIRST(&shead);
	SLIST_REMOVE_HEAD(&shead, entry);
	if (loadbuffer(s->bname) == FALSE)
		return (FALSE);
	curwp->w_dotline = s->dotline;
	curwp->w_doto = s->doto;

	/* storing of dotp in tagpos wouldn't work out in cases when
	 * that buffer is killed by user(dangling pointer). Explicitly
	 * traverse till dotline for correct handling.
	 */
	dotp = curwp->w_bufp->b_headp;
	while (s->dotline--)
		dotp = dotp->l_fp;

	curwp->w_dotp = dotp;
	free(s->bname);
	free(s);
	return (TRUE);
}

/*
 * Parse the tags file and construct the tags tree. Remove escape
 * characters while parsing the file.
 */
int
loadtags(const char *fn)
{
	char *l;
	FILE *fd;

	if ((fd = fopen(fn, "r")) == NULL) {
		dobeep();
		ewprintf("Unable to open tags file: %s", fn);
		return (FALSE);
	}
	while ((l = fparseln(fd, NULL, NULL, "\\\\\0",
	    FPARSELN_UNESCCONT | FPARSELN_UNESCREST)) != NULL) {
		if (addctag(l) == FALSE) {
			fclose(fd);
			return (FALSE);
		}
	}
	fclose(fd);
	return (TRUE);
}

/*
 * Cleanup and destroy tree and stack.
 */
void
closetags(void)
{
	struct tagpos *s;

	while (!SLIST_EMPTY(&shead)) {
		s = SLIST_FIRST(&shead);
		SLIST_REMOVE_HEAD(&shead, entry);
		free(s->bname);
		free(s);
	}
	unloadtags();
	free(tagsfn);
}

/*
 * Strip away any special characters in pattern.
 * The pattern in ctags isn't a true regular expression. Its of the form
 * /^xxx$/ or ?^xxx$? and in some cases the "$" would be missing. Strip
 * the leading and trailing special characters so the pattern matching
 * would be a simple string compare. Escape character is taken care by
 * fparseln.
 */
char *
strip(char *s, size_t len)
{
	/* first strip trailing special chars */
	s[len - 1] = '\0';
	if (s[len - 2] == '$')
		s[len - 2] = '\0';

	/* then strip leading special chars */
	s++;
	if (*s == '^')
		s++;

	return s;
}

/*
 * tags line is of the format "<tag>\t<filename>\t<pattern>". Split them
 * by replacing '\t' with '\0'. This wouldn't alter the size of malloc'ed
 * l, and can be freed during cleanup.
 */
int
addctag(char *l)
{
	struct ctag *t;

	if ((t = malloc(sizeof(struct ctag))) == NULL) {
		dobeep();
		ewprintf("Out of memory");
		return (FALSE);
	}
	t->tag = l;
	if ((l = strchr(l, '\t')) == NULL)
		goto cleanup;
	*l++ = '\0';
	t->fname = l;
	if ((l = strchr(l, '\t')) == NULL)
		goto cleanup;
	*l++ = '\0';
	if (*l == '\0')
		goto cleanup;
	t->pat = strip(l, strlen(l));
	RB_INSERT(tagtree, &tags, t);
	return (TRUE);
cleanup:
	free(t);
	free(l);
	return (FALSE);
}

/*
 * Search through each line of buffer for pattern.
 */
int
searchpat(char *pat)
{
	struct line *lp;
	int dotline;
	size_t plen;

	plen = strlen(pat);
	dotline = 1;
	lp = lforw(curbp->b_headp);
	while (lp != curbp->b_headp) {
		if (ltext(lp) != NULL && plen <= llength(lp) &&
		    (strncmp(pat, ltext(lp), plen) == 0)) {
			curwp->w_doto = 0;
			curwp->w_dotp = lp;
			curwp->w_dotline = dotline;
			return (TRUE);
		} else {
			lp = lforw(lp);
			dotline++;
		}
	}
	return (FALSE);
}

/*
 * Return TRUE if dot is at beginning of a word or at beginning
 * of line, else FALSE.
 */
int
atbow(void)
{
	if (curwp->w_doto == 0)
		return (TRUE);
	if (ISWORD(curwp->w_dotp->l_text[curwp->w_doto]) &&
	    !ISWORD(curwp->w_dotp->l_text[curwp->w_doto - 1]))
	    	return (TRUE);
	return (FALSE);
}

/*
 * Extract the word at dot without changing dot position.
 */
int
curtoken(int f, int n, char *token)
{
	struct line *odotp;
	int odoto, tdoto, odotline, size, r;
	char c;

	/* Underscore character is to be treated as "inword" while
	 * processing tokens unlike mg's default word traversal. Save
	 * and restore it's cinfo value so that tag matching works for
	 * identifier with underscore.
	 */
	c = cinfo['_'];
	cinfo['_'] = _MG_W;

	odotp = curwp->w_dotp;
	odoto = curwp->w_doto;
	odotline = curwp->w_dotline;

	/* Move backword unless we are at the beginning of a word or at
	 * beginning of line.
	 */
	if (!atbow())
		if ((r = backword(f, n)) == FALSE)
			goto cleanup;

	tdoto = curwp->w_doto;

	if ((r = forwword(f, n)) == FALSE)
		goto cleanup;

	/* strip away leading whitespace if any like emacs. */
	while (ltext(curwp->w_dotp) &&
	    isspace(lgetc(curwp->w_dotp, tdoto)))
		tdoto++;

	size = curwp->w_doto - tdoto;
	if (size <= 0 || size >= MAX_TOKEN ||
	    ltext(curwp->w_dotp) == NULL) {
		r = FALSE;
		goto cleanup;
	}
	strncpy(token, ltext(curwp->w_dotp) + tdoto, size);
	token[size] = '\0';
	r = TRUE;

cleanup:
	cinfo['_'] = c;
	curwp->w_dotp = odotp;
	curwp->w_doto = odoto;
	curwp->w_dotline = odotline;
	return (r);
}

/*
 * Search tagstree for a given token.
 */
struct ctag *
searchtag(char *tok)
{
	struct ctag t, *res;

	t.tag = tok;
	if ((res = RB_FIND(tagtree, &tags, &t)) == NULL) {
		dobeep();
		ewprintf("No tag containing %s", tok);
		return (NULL);
	}
	return res;
}

/*
 * This is equivalent to filevisit from file.c.
 * Look around to see if we can find the file in another buffer; if we
 * can't find it, create a new buffer, read in the text, and switch to
 * the new buffer. *scratch*, *grep*, *compile* needs to be handled
 * differently from other buffers which have "filenames".
 */
int
loadbuffer(char *bname)
{
	struct buffer *bufp;
	char *adjf;

	/* check for special buffers which begin with '*' */
	if (bname[0] == '*') {
		if ((bufp = bfind(bname, FALSE)) != NULL) {
			curbp = bufp;
			return (showbuffer(bufp, curwp, WFFULL));
		} else {
			return (FALSE);
		}
	} else {
		if ((adjf = adjustname(bname, TRUE)) == NULL)
			return (FALSE);
		if ((bufp = findbuffer(adjf)) == NULL)
			return (FALSE);
	}
	curbp = bufp;
	if (showbuffer(bufp, curwp, WFFULL) != TRUE)
		return (FALSE);
	if (bufp->b_fname[0] == '\0') {
		if (readin(adjf) != TRUE) {
			killbuffer(bufp);
			return (FALSE);
		}
	}
	return (TRUE);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: tags.c,v 1.13 2016/01/19 11:39:06 sunil Exp $ */
2
3			/*
4			* This file is in the public domain.
5			*
6			* Author: Sunil Nimmagadda <sunil@openbsd.org>
7			*/
8
9			#include <sys/queue.h>
10			#include <sys/stat.h>
11			#include <sys/tree.h>
12			#include <sys/types.h>
13			#include <ctype.h>
14			#include <err.h>
15			#include <errno.h>
16			#include <signal.h>
17			#include <stdio.h>
18			#include <stdlib.h>
19			#include <string.h>
20			#include <unistd.h>
21			#include <util.h>
22
23			#include "def.h"
24
25			struct ctag;
26
27			static int addctag(char *);
28			static int atbow(void);
29			void closetags(void);
30			static int ctagcmp(struct ctag , struct ctag );
31			static int loadbuffer(char *);
32			static int loadtags(const char *);
33			static int pushtag(char *);
34			static int searchpat(char *);
35			static struct ctag searchtag(char );
36			static char strip(char , size_t);
37			static void unloadtags(void);
38
39			#define DEFAULTFN "tags"
40
41			char *tagsfn = NULL;
42			int loaded = FALSE;
43
44			/* ctags(1) entries are parsed and maintained in a tree. */
45			struct ctag {
46			RB_ENTRY(ctag) entry;
47			char *tag;
48			char *fname;
49			char *pat;
50			};
51			RB_HEAD(tagtree, ctag) tags = RB_INITIALIZER(&tags);
52			RB_GENERATE(tagtree, ctag, entry, ctagcmp);
53
54			struct tagpos {
55			SLIST_ENTRY(tagpos) entry;
56			int doto;
57			int dotline;
58			char *bname;
59			};
60			SLIST_HEAD(tagstack, tagpos) shead = SLIST_HEAD_INITIALIZER(shead);
61
62			int
63			ctagcmp(struct ctag s, struct ctag t)
64			{
65			return strcmp(s->tag, t->tag);
66			}
67
68			/*
69			* Record the filename that contain tags to be used while loading them
70			* on first use. If a filename is already recorded, ask user to retain
71			* already loaded tags (if any) and unload them if user chooses not to.
72			*/
73			/* ARGSUSED */
74			int
75			tagsvisit(int f, int n)
76			{
77			char fname[NFILEN], bufp, temp;
78			struct stat sb;
79
80			if (getbufcwd(fname, sizeof(fname)) == FALSE)
81			fname[0] = '\0';
82
83			if (strlcat(fname, DEFAULTFN, sizeof(fname)) >= sizeof(fname)) {
84			dobeep();
85			ewprintf("Filename too long");
86			return (FALSE);
87			}
88
89			bufp = eread("visit tags table (default %s): ", fname,
90			NFILEN, EFFILE \| EFCR \| EFNEW \| EFDEF, DEFAULTFN);
91
92			if (stat(bufp, &sb) == -1) {
93			dobeep();
94			ewprintf("stat: %s", strerror(errno));
95			return (FALSE);
96			} else if (S_ISREG(sb.st_mode) == 0) {
97			dobeep();
98			ewprintf("Not a regular file");
99			return (FALSE);
100			} else if (access(bufp, R_OK) == -1) {
101			dobeep();
102			ewprintf("Cannot access file %s", bufp);
103			return (FALSE);
104			}
105
106			if (tagsfn == NULL) {
107			if (bufp == NULL)
108			return (ABORT);
109			else if (bufp[0] == '\0') {
110			if ((tagsfn = strdup(fname)) == NULL) {
111			dobeep();
112			ewprintf("Out of memory");
113			return (FALSE);
114			}
115			} else {
116			/* bufp points to local variable, so duplicate. */
117			if ((tagsfn = strdup(bufp)) == NULL) {
118			dobeep();
119			ewprintf("Out of memory");
120			return (FALSE);
121			}
122			}
123			} else {
124			if ((temp = strdup(bufp)) == NULL) {
125			dobeep();
126			ewprintf("Out of memory");
127			return (FALSE);
128			}
129			free(tagsfn);
130			tagsfn = temp;
131			if (eyorn("Keep current list of tags table also") == FALSE) {
132			ewprintf("Starting a new list of tags table");
133			unloadtags();
134			}
135			loaded = FALSE;
136			}
137			return (TRUE);
138			}
139
140			/*
141			* Ask user for a tag while treating word at dot as default. Visit tags
142			* file if not yet done, load tags and jump to definition of the tag.
143			*/
144			int
145			findtag(int f, int n)
146			{
147			char utok[MAX_TOKEN], dtok[MAX_TOKEN];
148			char tok, bufp;
149			int ret;
150
151			if (curtoken(f, n, dtok) == FALSE) {
152			dtok[0] = '\0';
153			bufp = eread("Find tag:", utok, MAX_TOKEN, EFNUL \| EFNEW);
154			} else
155			bufp = eread("Find tag (default %s):", utok, MAX_TOKEN,
156			EFNUL \| EFNEW, dtok);
157
158			if (bufp == NULL)
159			return (ABORT);
160			else if (bufp[0] == '\0')
161			tok = dtok;
162			else
163			tok = utok;
164
165			if (tok[0] == '\0') {
166			dobeep();
167			ewprintf("There is no default tag");
168			return (FALSE);
169			}
170
171			if (tagsfn == NULL)
172			if ((ret = tagsvisit(f, n)) != TRUE)
173			return (ret);
174			if (!loaded) {
175			if (loadtags(tagsfn) == FALSE) {
176			free(tagsfn);
177			tagsfn = NULL;
178			return (FALSE);
179			}
180			loaded = TRUE;
181			}
182			return pushtag(tok);
183			}
184
185			/*
186			* Free tags tree.
187			*/
188			void
189			unloadtags(void)
190			{
191			struct ctag var, nxt;
192
193			for (var = RB_MIN(tagtree, &tags); var != NULL; var = nxt) {
194			nxt = RB_NEXT(tagtree, &tags, var);
195			RB_REMOVE(tagtree, &tags, var);
196			/* line parsed with fparseln needs to be freed */
197			free(var->tag);
198			free(var);
199			}
200			}
201
202			/*
203			* Lookup tag passed in tree and if found, push current location and
204			* buffername onto stack, load the file with tag definition into a new
205			* buffer and position dot at the pattern.
206			*/
207			/ARGSUSED /
208			int
209			pushtag(char *tok)
210			{
211			struct ctag *res;
212			struct tagpos *s;
213			char bname[NFILEN];
214			int doto, dotline;
215
216			if ((res = searchtag(tok)) == NULL)
217			return (FALSE);
218
219			doto = curwp->w_doto;
220			dotline = curwp->w_dotline;
221			/* record absolute filenames. Fixes issues when mg's cwd is not the
222			* same as buffer's directory.
223			*/
224			if (strlcpy(bname, curbp->b_cwd, sizeof(bname)) >= sizeof(bname)) {
225			dobeep();
226			ewprintf("filename too long");
227			return (FALSE);
228			}
229			if (strlcat(bname, curbp->b_bname, sizeof(bname)) >= sizeof(bname)) {
230			dobeep();
231			ewprintf("filename too long");
232			return (FALSE);
233			}
234
235			if (loadbuffer(res->fname) == FALSE)
236			return (FALSE);
237
238			if (searchpat(res->pat) == TRUE) {
239			if ((s = malloc(sizeof(struct tagpos))) == NULL) {
240			dobeep();
241			ewprintf("Out of memory");
242			return (FALSE);
243			}
244			if ((s->bname = strdup(bname)) == NULL) {
245			dobeep();
246			ewprintf("Out of memory");
247			free(s);
248			return (FALSE);
249			}
250			s->doto = doto;
251			s->dotline = dotline;
252			SLIST_INSERT_HEAD(&shead, s, entry);
253			return (TRUE);
254			} else {
255			dobeep();
256			ewprintf("%s: pattern not found", res->tag);
257			return (FALSE);
258			}
259			/* NOTREACHED */
260			return (FALSE);
261			}
262
263			/*
264			* If tag stack is not empty pop stack and jump to recorded buffer, dot.
265			*/
266			/* ARGSUSED */
267			int
268			poptag(int f, int n)
269			{
270			struct line *dotp;
271			struct tagpos *s;
272
273			if (SLIST_EMPTY(&shead)) {
274			dobeep();
275			ewprintf("No previous location for find-tag invocation");
276			return (FALSE);
277			}
278			s = SLIST_FIRST(&shead);
279			SLIST_REMOVE_HEAD(&shead, entry);
280			if (loadbuffer(s->bname) == FALSE)
281			return (FALSE);
282			curwp->w_dotline = s->dotline;
283			curwp->w_doto = s->doto;
284
285			/* storing of dotp in tagpos wouldn't work out in cases when
286			* that buffer is killed by user(dangling pointer). Explicitly
287			* traverse till dotline for correct handling.
288			*/
289			dotp = curwp->w_bufp->b_headp;
290			while (s->dotline--)
291			dotp = dotp->l_fp;
292
293			curwp->w_dotp = dotp;
294			free(s->bname);
295			free(s);
296			return (TRUE);
297			}
298
299			/*
300			* Parse the tags file and construct the tags tree. Remove escape
301			* characters while parsing the file.
302			*/
303			int
304			loadtags(const char *fn)
305			{
306			char *l;
307			FILE *fd;
308
309			if ((fd = fopen(fn, "r")) == NULL) {
310			dobeep();
311			ewprintf("Unable to open tags file: %s", fn);
312			return (FALSE);
313			}
314			while ((l = fparseln(fd, NULL, NULL, "\\\\\0",
315			FPARSELN_UNESCCONT \| FPARSELN_UNESCREST)) != NULL) {
316			if (addctag(l) == FALSE) {
317			fclose(fd);
318			return (FALSE);
319			}
320			}
321			fclose(fd);
322			return (TRUE);
323			}
324
325			/*
326			* Cleanup and destroy tree and stack.
327			*/
328			void
329			closetags(void)
330			{
331			struct tagpos *s;
332
333			while (!SLIST_EMPTY(&shead)) {
334			s = SLIST_FIRST(&shead);
335			SLIST_REMOVE_HEAD(&shead, entry);
336			free(s->bname);
337			free(s);
338			}
339			unloadtags();
340			free(tagsfn);
341			}
342
343			/*
344			* Strip away any special characters in pattern.
345			* The pattern in ctags isn't a true regular expression. Its of the form
346			* /^xxx$/ or ?^xxx$? and in some cases the "$" would be missing. Strip
347			* the leading and trailing special characters so the pattern matching
348			* would be a simple string compare. Escape character is taken care by
349			* fparseln.
350			*/
351			char *
352			strip(char *s, size_t len)
353			{
354			/* first strip trailing special chars */
355			s[len - 1] = '\0';
356			if (s[len - 2] == '$')
357			s[len - 2] = '\0';
358
359			/* then strip leading special chars */
360			s++;
361			if (*s == '^')
362			s++;
363
364			return s;
365			}
366
367			/*
368			* tags line is of the format "<tag>\t<filename>\t<pattern>". Split them
369			* by replacing '\t' with '\0'. This wouldn't alter the size of malloc'ed
370			* l, and can be freed during cleanup.
371			*/
372			int
373			addctag(char *l)
374			{
375			struct ctag *t;
376
377			if ((t = malloc(sizeof(struct ctag))) == NULL) {
378			dobeep();
379			ewprintf("Out of memory");
380			return (FALSE);
381			}
382			t->tag = l;
383			if ((l = strchr(l, '\t')) == NULL)
384			goto cleanup;
385			*l++ = '\0';
386			t->fname = l;
387			if ((l = strchr(l, '\t')) == NULL)
388			goto cleanup;
389			*l++ = '\0';
390			if (*l == '\0')
391			goto cleanup;
392			t->pat = strip(l, strlen(l));
393			RB_INSERT(tagtree, &tags, t);
394			return (TRUE);
395			cleanup:
396			free(t);
397			free(l);
398			return (FALSE);
399			}
400
401			/*
402			* Search through each line of buffer for pattern.
403			*/
404			int
405			searchpat(char *pat)
406			{
407			struct line *lp;
408			int dotline;
409			size_t plen;
410
411			plen = strlen(pat);
412			dotline = 1;
413			lp = lforw(curbp->b_headp);
414			while (lp != curbp->b_headp) {
415			if (ltext(lp) != NULL && plen <= llength(lp) &&
416			(strncmp(pat, ltext(lp), plen) == 0)) {
417			curwp->w_doto = 0;
418			curwp->w_dotp = lp;
419			curwp->w_dotline = dotline;
420			return (TRUE);
421			} else {
422			lp = lforw(lp);
423			dotline++;
424			}
425			}
426			return (FALSE);
427			}
428
429			/*
430			* Return TRUE if dot is at beginning of a word or at beginning
431			* of line, else FALSE.
432			*/
433			int
434			atbow(void)
435			{
436			if (curwp->w_doto == 0)
437			return (TRUE);
438			if (ISWORD(curwp->w_dotp->l_text[curwp->w_doto]) &&
439			!ISWORD(curwp->w_dotp->l_text[curwp->w_doto - 1]))
440			return (TRUE);
441			return (FALSE);
442			}
443
444			/*
445			* Extract the word at dot without changing dot position.
446			*/
447			int
448			curtoken(int f, int n, char *token)
449			{
450			struct line *odotp;
451			int odoto, tdoto, odotline, size, r;
452			char c;
453
454			/* Underscore character is to be treated as "inword" while
455			* processing tokens unlike mg's default word traversal. Save
456			* and restore it's cinfo value so that tag matching works for
457			* identifier with underscore.
458			*/
459			c = cinfo['_'];
460			cinfo['_'] = _MG_W;
461
462			odotp = curwp->w_dotp;
463			odoto = curwp->w_doto;
464			odotline = curwp->w_dotline;
465
466			/* Move backword unless we are at the beginning of a word or at
467			* beginning of line.
468			*/
469			if (!atbow())
470			if ((r = backword(f, n)) == FALSE)
471			goto cleanup;
472
473			tdoto = curwp->w_doto;
474
475			if ((r = forwword(f, n)) == FALSE)
476			goto cleanup;
477
478			/* strip away leading whitespace if any like emacs. */
479			while (ltext(curwp->w_dotp) &&
480			isspace(lgetc(curwp->w_dotp, tdoto)))
481			tdoto++;
482
483			size = curwp->w_doto - tdoto;
484			if (size <= 0 \|\| size >= MAX_TOKEN \|\|
485			ltext(curwp->w_dotp) == NULL) {
486			r = FALSE;
487			goto cleanup;
488			}
489			strncpy(token, ltext(curwp->w_dotp) + tdoto, size);
490			token[size] = '\0';
491			r = TRUE;
492
493			cleanup:
494			cinfo['_'] = c;
495			curwp->w_dotp = odotp;
496			curwp->w_doto = odoto;
497			curwp->w_dotline = odotline;
498			return (r);
499			}
500
501			/*
502			* Search tagstree for a given token.
503			*/
504			struct ctag *
505			searchtag(char *tok)
506			{
507			struct ctag t, *res;
508
509			t.tag = tok;
510			if ((res = RB_FIND(tagtree, &tags, &t)) == NULL) {
511			dobeep();
512			ewprintf("No tag containing %s", tok);
513			return (NULL);
514			}
515			return res;
516			}
517
518			/*
519			* This is equivalent to filevisit from file.c.
520			* Look around to see if we can find the file in another buffer; if we
521			* can't find it, create a new buffer, read in the text, and switch to
522			* the new buffer. scratch, grep, compile needs to be handled
523			* differently from other buffers which have "filenames".
524			*/
525			int
526			loadbuffer(char *bname)
527			{
528			struct buffer *bufp;
529			char *adjf;
530
531			/* check for special buffers which begin with '' /
532			if (bname[0] == '*') {
533			if ((bufp = bfind(bname, FALSE)) != NULL) {
534			curbp = bufp;
535			return (showbuffer(bufp, curwp, WFFULL));
536			} else {
537			return (FALSE);
538			}
539			} else {
540			if ((adjf = adjustname(bname, TRUE)) == NULL)
541			return (FALSE);
542			if ((bufp = findbuffer(adjf)) == NULL)
543			return (FALSE);
544			}
545			curbp = bufp;
546			if (showbuffer(bufp, curwp, WFFULL) != TRUE)
547			return (FALSE);
548			if (bufp->b_fname[0] == '\0') {
549			if (readin(adjf) != TRUE) {
550			killbuffer(bufp);
551			return (FALSE);
552			}
553			}
554			return (TRUE);
555			}