/*
 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*	Copyright (c) 1988 AT&T	*/
/*	All Rights Reserved	*/

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

/*
 *   Modify ctags to handle C++ in C_entries(), etc:
 *	-  Handles C++ comment token "//"
 *	-  Handles C++ scope operator "::".
 *		This helps to distinguish between xyz()
 *	   definition and X::xyz() definition.
 *	-  Recognizes C++ reserved word "class" in typedef processing
 *		(for "-t" option)
 *	-  Handles Sun C++ special file name extensions: .c, .C, .cc, and .cxx.
 *	-  Handles overloaded unary/binary operator names
 *   Doesn't handle yet:
 *	-  inline functions in class definition (currently they get
 *		swallowed within a class definition)
 *	-  Tags with scope operator :: with spaces in between,
 *		e.g. classz ::afunc
 *
 *   Enhance operator functions support:
 *	-  Control flow involving operator tokens scanning are
 *	   consistent with that of other function tokens - original
 *	   hacking method for 2.0 is removed.  This will accurately
 *	   identify tags for declarations of the form 'operator+()'
 *	   (bugid 1027806) as well as allowing spaces in between
 *	   'operator' and 'oprtk', e.g. 'operator + ()'.
 *
 */

#ifndef lint
char copyright[] = "@(#) Copyright (c) 1980 Regents of the University of "
			"California.\nAll rights reserved.\n";
#endif

#include <stdio.h>
#include <ctype.h>
#include <locale.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>

/*
 * ctags: create a tags file
 */

#define	bool	char

#define	TRUE	(1)
#define	FALSE	(0)

#define	CPFLAG	3			/* # of bytes in a flag		*/

#define	iswhite(arg)	(_wht[arg])	/* T if char is white		*/
#define	begtoken(arg)	(_btk[arg])	/* T if char can start token	*/
#define	intoken(arg)	(_itk[arg])	/* T if char can be in token	*/
#define	endtoken(arg)	(_etk[arg])	/* T if char ends tokens	*/
#define	isgood(arg)	(_gd[arg])	/* T if char can be after ')'	*/

#define	optoken(arg)	(_opr[arg])	/* T if char can be		*/
					/* an overloaded operator token	*/

#define	max(I1, I2)	(I1 > I2 ? I1 : I2)

struct	nd_st {			/* sorting structure			*/
	char	*entry;			/* function or type name	*/
	char	*file;			/* file name			*/
	bool	f;			/* use pattern or line no	*/
	int	lno;			/* for -x option		*/
	char	*pat;			/* search pattern		*/
	bool	been_warned;		/* set if noticed dup		*/
	struct	nd_st	*left, *right;	/* left and right sons		*/
};

long	ftell();
typedef	struct	nd_st	NODE;

static bool
	number,				/* T if on line starting with #	*/
	gotone,				/* found a func already on line	*/
					/* boolean "func" (see init)	*/
	_wht[0177], _etk[0177], _itk[0177], _btk[0177], _gd[0177];

/* boolean array for overloadable operator symbols			*/
static bool	_opr[0177];

	/*
	 * typedefs are recognized using a simple finite automata,
	 * tydef is its state variable.
	 */
typedef enum {none, begin, begin_rec, begin_tag, middle, end } TYST;

static TYST tydef = none;

static char	searchar = '/';		/* use /.../ searches		*/

#define	LINEBUFSIZ	4*BUFSIZ

static int	lineno;			/* line number of current line */
static char
	line[LINEBUFSIZ],	/* current input line			*/
	*curfile,		/* current input file name		*/
	*outfile = "tags",	/* output file				*/
	*white	= " \f\t\n",	/* white chars				*/
	*endtk	= " \t\n\"'#()[]{}=-+%*/&|^~!<>;,.:?",
				/* token ending chars			*/
	*begtk	= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz",
				/* token starting chars			*/
	*intk	= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
		    "0123456789",
				/* valid in-token chars			*/
	*notgd	= ",;";		/* non-valid after-function chars	*/

static char	*oprtk	= " =-+%*/&|^~!<>[]()";	/* overloadable operators */

static int	file_num;	/* current file number			*/
static int	aflag;		/* -a: append to tags */

#ifndef XPG4			/* XPG4: handle typedefs by default	*/
static int	tflag;		/* -t: create tags for typedefs		*/
#endif /*  !XPG4 */

static int	uflag;		/* -u: update tags			*/
static int	wflag;		/* -w: suppress warnings		*/
static int	vflag;		/* -v: create vgrind style index output */
static int	xflag;		/* -x: create cxref style output	*/

static char	lbuf[LINEBUFSIZ];

static FILE
	*inf,			/* ioptr for current input file		*/
	*outf;			/* ioptr for tags file			*/

static long	lineftell;	/* ftell after getc( inf ) == '\n'	*/

static NODE	*head;		/* the head of the sorted binary tree	*/

static int	infile_fail;	/* Count of bad opens. Fix bug ID #1082298 */

static char	*dbp = lbuf;
static int	pfcnt;

static int	mac;		/* our modified argc, after parseargs() */
static char	**mav;		/* our modified argv, after parseargs() */


/* our local functions:							*/
static void	init(void);
static void	find_entries(char *);
static void	pfnote(char *, int, bool);
static void	C_entries(void);
static int	start_entry(char **, char *, int *);
static void	Y_entries(void);
static char	*toss_comment(char *);
static void	getaline(long int);
static void	free_tree(NODE *);
static void	add_node(NODE *, NODE *);
static void	put_entries(NODE *);
static int	PF_funcs(FILE *);
static int	tail(char *);
static void	takeprec(void);
static void	getit(void);
static char	*savestr(char *);
static void	L_funcs(FILE *);
static void	L_getit(int);
static int	striccmp(char *, char *);
static int	first_char(void);
static void	toss_yysec(void);
static void	Usage(void);
static void	parseargs(int, char **);

int
main(int ac, char *av[])
{
	int i;
	char cmd[100];

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	parseargs(ac, av);

	while ((i = getopt(mac, mav, "aBFtuvwxf:")) != EOF) {
		switch (i) {
		case 'a':	/* -a: Append output to existing tags file */
			aflag++;
			break;

		case 'B':	/* -B: Use backward search patterns (?...?) */
			searchar = '?';
			break;

		case 'F':	/* -F: Use forward search patterns (/.../) */
			searchar = '/';
			break;

		case 't':	/* -t: Create tags for typedefs.	*/
				/* for XPG4 , we silently ignore "-t".	*/
#ifndef XPG4
			tflag++;
#endif /*  !XPG4 */
			break;

		case 'u':	/* -u: Update the specified tags file	*/
			uflag++;
			break;

		case 'v':	/* -v: Index listing on stdout		*/
			vflag++;
			xflag++;
			break;

		case 'w':	/* -w: Suppress warnings		*/
			wflag++;
			break;

		case 'x':	/* -x: Produce a simple index		*/
			xflag++;
			break;

		case 'f':	/* -f tagsfile: output to tagsfile	*/
			outfile = strdup(optarg);
			break;

		default:
			Usage();	/* never returns		*/
			break;
		}
	}

	/* if we didn't specify any source code to parse, complain and die. */
	if (optind == mac) {
		Usage();	/* never returns		*/
	}


	init();			/* set up boolean "functions"		*/
	/*
	 * loop through files finding functions
	 */
	for (file_num = optind; file_num < mac; file_num++)
		find_entries(mav[file_num]);

	if (xflag) {
		put_entries(head);
		exit(infile_fail > 0 ? 2 : 0); /* Fix for 1082298 */
	}
	if (uflag) {
		for (i = 1; i < mac; i++) {
			(void) sprintf(cmd,
			"mv %s OTAGS;fgrep -v '\t%s\t' OTAGS >%s;rm OTAGS",
				outfile, mav[i], outfile);
			(void) system(cmd);
		}
		aflag++;
	}
	outf = fopen(outfile, aflag ? "a" : "w");
	if (outf == NULL) {
		perror(outfile);
		exit(1);
	}
	put_entries(head);
	(void) fclose(outf);
	if (uflag) {
		(void) sprintf(cmd, "sort %s -o %s", outfile, outfile);
		(void) system(cmd);
	}
	return (infile_fail > 0 ? 2 : 0); /* Fix for #1082298 */
}

/*
 * This routine sets up the boolean psuedo-functions which work
 * by seting boolean flags dependent upon the corresponding character
 * Every char which is NOT in that string is not a white char.  Therefore,
 * all of the array "_wht" is set to FALSE, and then the elements
 * subscripted by the chars in "white" are set to TRUE.  Thus "_wht"
 * of a char is TRUE if it is the string "white", else FALSE.
 */
static void
init(void)
{
	char	*sp;
	int	i;

	for (i = 0; i < 0177; i++) {
		_wht[i] = _etk[i] = _itk[i] = _btk[i] = FALSE;
		_opr[i] = FALSE;	/* initialize boolean		*/
					/* array of operator symbols	*/
		_gd[i] = TRUE;
	}
	for (sp = white; *sp; sp++)
		_wht[*sp] = TRUE;
	for (sp = endtk; *sp; sp++)
		_etk[*sp] = TRUE;
	for (sp = intk; *sp; sp++)
		_itk[*sp] = TRUE;
	for (sp = begtk; *sp; sp++)
		_btk[*sp] = TRUE;

	/* mark overloadable operator symbols				*/
	for (sp = oprtk; *sp; sp++)
		_opr[*sp] = TRUE;

	for (sp = notgd; *sp; sp++)
		_gd[*sp] = FALSE;
}

/*
 * This routine opens the specified file and calls the function
 * which finds the function and type definitions.
 */
static void
find_entries(char *file)
{
	char *cp;
	struct stat st;

	/* skip anything that isn't a regular file */
	if (stat(file, &st) == 0 && !S_ISREG(st.st_mode))
		return;

	if ((inf = fopen(file, "r")) == NULL) {
		perror(file);
		infile_fail++;		/* Count bad opens. ID #1082298 */
		return;
	}
	curfile = savestr(file);
	lineno = 0;
	cp = strrchr(file, '.');
	/* .l implies lisp or lex source code */
	if (cp && cp[1] == 'l' && cp[2] == '\0') {
		if (strchr(";([", first_char()) != NULL)	/* lisp */
		{
			L_funcs(inf);
			(void) fclose(inf);
			return;
		} else {					/* lex */
			/*
			 * throw away all the code before the second "%%"
			 */
			toss_yysec();
			getaline(lineftell);
			pfnote("yylex", lineno, TRUE);
			toss_yysec();
			C_entries();
			(void) fclose(inf);
			return;
		}
	}
	/* .y implies a yacc file */
	if (cp && cp[1] == 'y' && cp[2] == '\0') {
		toss_yysec();
		Y_entries();
		C_entries();
		(void) fclose(inf);
		return;
	}

	/*
	 * Add in file name extension support for Sun C++ which
	 * permits .C/.c (AT&T), .cc (G++) and .cxx (Gloksp.)
	 */

	/* if not a .c, .C, .cc, .cxx or .h file, try fortran */
	if (cp && (cp[1] != 'C' && cp[1] != 'c' && cp[1] != 'h') &&
	    cp[2] == '\0' && (strcmp(cp, ".cc") == 0) &&
	    (strcmp(cp, ".cxx") == 0)) {
		if (PF_funcs(inf) != 0) {
			(void) fclose(inf);
			return;
		}
		rewind(inf);	/* no fortran tags found, try C */
	}
	C_entries();
	(void) fclose(inf);
}

static void
pfnote(char *name, int ln, bool f)
{
	char *fp;
	NODE *np;
	char *nametk;	/* hold temporary tokens from name */
	char nbuf[BUFSIZ];

	if ((np = malloc(sizeof (NODE))) == NULL) {
		(void) fprintf(stderr,
				gettext("ctags: too many entries to sort\n"));
		put_entries(head);
		free_tree(head);
		head = np = (NODE *) malloc(sizeof (NODE));
	}
	if (xflag == 0 && (strcmp(name, "main") == 0)) {
		fp = strrchr(curfile, '/');

		if (fp == 0)
			fp = curfile;
		else
			fp++;
		(void) sprintf(nbuf, "M%s", fp);
		fp = strrchr(nbuf, '.');
		/* Chop off .cc and .cxx as well as .c, .h, etc		*/
		if (fp && ((fp[2] == 0) || (fp[2] == 'c' && fp[3] == 0) ||
			    (fp[3] == 'x' && fp[4] == 0)))
			*fp = 0;
		name = nbuf;
	}

	/* remove in-between blanks operator function tags */
	if (strchr(name, ' ') != NULL)
	{
		(void) strcpy(name, strtok(name, " "));
		while ((nametk = strtok(0, " ")) != NULL)
			(void) strcat(name, nametk);
	}
	np->entry = savestr(name);
	np->file = curfile;
	np->f = f;
	np->lno = ln;
	np->left = np->right = 0;
	if (xflag == 0) {
		lbuf[50] = 0;
		(void) strcat(lbuf, "$");
		lbuf[50] = 0;
	}
	np->pat = savestr(lbuf);
	if (head == NULL)
		head = np;
	else
		add_node(np, head);
}

/*
 * This routine finds functions and typedefs in C syntax and adds them
 * to the list.
 */
static void
C_entries(void)
{
	int c;
	char *token, *tp;
	bool incomm, inquote, inchar, midtoken, isoperator, optfound;
	int level;
	char *sp;
	char tok[BUFSIZ];
	long int tokftell;

	number = gotone = midtoken = inquote = inchar =
	incomm = isoperator = optfound = FALSE;

	level = 0;
	sp = tp = token = line;
	lineno++;
	lineftell = tokftell = ftell(inf);
	for (;;) {
		*sp = c = getc(inf);
		if (feof(inf))
			break;
		if (c == '\n') {
			lineftell = ftell(inf);
			lineno++;
		} else if (c == '\\') {
			c = *++sp = getc(inf);
			if ((c == '\n') || (c == EOF)) { /* c == EOF, 1091005 */
				lineftell = ftell(inf);
				lineno++;
				c = ' ';
			}
		} else if (incomm) {
			if (c == '*') {
				while ((*++sp = c = getc(inf)) == '*')
					continue;

				/* c == EOF 1091005			*/
				if ((c == '\n') || (c == EOF)) {
					lineftell = ftell(inf);
					lineno++;
				}

				if (c == '/')
					incomm = FALSE;
			}
		} else if (inquote) {
			/*
			 * Too dumb to know about \" not being magic, but
			 * they usually occur in pairs anyway.
			 */
			if (c == '"')
				inquote = FALSE;
			continue;
		} else if (inchar) {
			if (c == '\'')
				inchar = FALSE;
			continue;
		} else if (midtoken == TRUE) {	/* if white space omitted */
			goto dotoken;
		} else switch (c) {
		    case '"':
			inquote = TRUE;
			continue;
		    case '\'':
			inchar = TRUE;
			continue;
		    case '/':
			*++sp = c = getc(inf);
			/* Handles the C++ comment token "//"		*/
			if (c == '*')
				incomm = TRUE;
			else if (c == '/') {
				/*
				 * Skip over all the characters after
				 * "//" until a newline character. Now also
				 * includes fix for 1091005, check for EOF.
				 */
				do  {
					c = getc(inf);
				/* 1091005:				*/
				} while ((c != '\n') && (c != EOF));


				/*
				 * Fixed bugid 1030014
				 * Return the current position of the
				 * file after the newline.
				 */
				lineftell = ftell(inf);
				lineno++;
				*--sp = c;
			}
			else
				(void) ungetc(*sp, inf);
			continue;
		    case '#':
			if (sp == line)
				number = TRUE;
			continue;
		    case '{':
			if ((tydef == begin_rec) || (tydef == begin_tag)) {
				tydef = middle;
			}
			level++;
			continue;
		    case '}':
			/*
			 * Heuristic for function or structure end;
			 * common for #ifdef/#else blocks to add extra "{"
			 */
			if (sp == line)
				level = 0;	/* reset */
			else
				level--;
			if (!level && tydef == middle) {
				tydef = end;
			}
			if (!level && tydef == none) /* Fix for #1034126 */
				goto dotoken;
			continue;
		}

dotoken:


		if (!level && !inquote && !incomm && gotone == FALSE) {
			if (midtoken) {
				if (endtoken(c)) {

				/*
				 *
				 *    ':'  +---> ':' -> midtok
				 *
				 *    +---> operator{+,-, etc} -> midtok
				 *		(continue)
				 *    +---> endtok
				 */
		/*
		 * Enhance operator function support and
		 *	fix bugid 1027806
		 *
		 *  For operator token, scanning will continue until
		 *  '(' is found.  Spaces between 'operater' and
		 *  'oprtk' are allowed (e.g. 'operator + ()'), but
		 *  will be removed when the actual entry for the tag
		 *  is made.
		 *  Note that functions of the form 'operator ()(int)'
		 *  will be recognized, but 'operator ()' will not,
		 *  even though this is legitimate in C.
		 */

					if (optoken(c)) {
					    if (isoperator) {
					    if (optfound) {
						    if (c != '(') {
						    tp++;
						    goto next_char;
						    }
					    } else {
						    if (c != ' ') {
						    optfound = TRUE;
						    }
						    tp++;
						    goto next_char;
					    }
					    } else {
				/* start: this code shifted left for cstyle */
				char *backptr = tp - 7;
				if (strncmp(backptr, "operator", 8) == 0) {
					/* This is an overloaded operator */
					isoperator = TRUE;
					if (c != ' ') {
						optfound = TRUE;
					}

					tp++;
					goto next_char;
				} else if (c == '~') {
					/* This is a destructor		*/
					tp++;
					goto next_char;
				}
				/* end: above code shifted left for cstyle */
					}
					} else if (c == ':') {
					    if ((*++sp = getc(inf)) == ':') {
						tp += 2;
						c = *sp;
						goto next_char;
					    } else {
						(void) ungetc (*sp, inf);
						--sp;
					    }
					}

				/* start: this code shifted left for cstyle */
				{
				int f;
				int pfline = lineno;

				if (start_entry(&sp, token, &f)) {
					(void) strncpy(tok, token, tp-token+1);
					tok[tp-token+1] = 0;
					getaline(tokftell);
					pfnote(tok, pfline, f);
					gotone = f;	/* function */
				}

				isoperator = optfound = midtoken = FALSE;
				token = sp;
				}
				/* end: above code shifted left for cstyle */
				} else if (intoken(c))
					tp++;
			} else if (begtoken(c)) {
				token = tp = sp;
				midtoken = TRUE;
				tokftell = lineftell;
			}
		}
	next_char:
		if (c == ';' && tydef == end)	/* clean with typedefs */
			tydef = none;
		sp++;
			/* The "c == }" was added to fix #1034126 */
		if (c == '\n' ||c == '}'|| sp > &line[sizeof (line) - BUFSIZ]) {
			tp = token = sp = line;
			number = gotone = midtoken = inquote =
			inchar = isoperator = optfound = FALSE;
		}
	}
}

/*
 * This routine  checks to see if the current token is
 * at the start of a function, or corresponds to a typedef
 * It updates the input line * so that the '(' will be
 * in it when it returns.
 */
static int
start_entry(char **lp, char *token, int *f)
{
	char	*sp;
	int	c;
	static	bool	found;
	bool	firsttok;	/* T if have seen first token in ()'s	*/
	int	bad;

	*f = 1;			/* a function */
	sp = *lp;
	c = *sp;
	bad = FALSE;
	if (!number) {		/* space is not allowed in macro defs	*/
		while (iswhite(c)) {
			*++sp = c = getc(inf);
			if ((c == '\n') || (c == EOF)) { /* c==EOF, #1091005 */
				lineno++;
				lineftell = ftell(inf);
				if (sp > &line[sizeof (line) - BUFSIZ])
					goto ret;
			}
		}
	/* the following tries to make it so that a #define	a b(c)	*/
	/* doesn't count as a define of b.				*/
	} else {
		if (strncmp(token, "define", 6) == 0)
			found = 0;
		else
			found++;
		if (found >= 2) {
			gotone = TRUE;
badone:			bad = TRUE;
			goto ret;
		}
	}
	/* check for the typedef cases		*/
#ifdef XPG4
	if (strncmp(token, "typedef", 7) == 0) {
#else /*  !XPG4 */
	if (tflag && (strncmp(token, "typedef", 7) == 0)) {
#endif /*  XPG4 */
		tydef = begin;
		goto badone;
	}
	/* Handles 'class' besides 'struct' etc.			*/
	if (tydef == begin && ((strncmp(token, "struct", 6) == 0) ||
			    (strncmp(token, "class", 5) == 0) ||
			    (strncmp(token, "union", 5) == 0)||
			    (strncmp(token, "enum", 4) == 0))) {
		tydef = begin_rec;
		goto badone;
	}
	if (tydef == begin) {
		tydef = end;
		goto badone;
	}
	if (tydef == begin_rec) {
		tydef = begin_tag;
		goto badone;
	}
	if (tydef == begin_tag) {
		tydef = end;
		goto gottydef;	/* Fall through to "tydef==end" */
	}

gottydef:
	if (tydef == end) {
		*f = 0;
		goto ret;
	}
	if (c != '(')
		goto badone;
	firsttok = FALSE;
	while ((*++sp = c = getc(inf)) != ')') {
		if ((c == '\n') || (c == EOF)) { /* c == EOF Fix for #1091005 */
			lineftell = ftell(inf);
			lineno++;
			if (sp > &line[sizeof (line) - BUFSIZ])
				goto ret;
		}
		/*
		 * This line used to confuse ctags:
		 *	int	(*oldhup)();
		 * This fixes it. A nonwhite char before the first
		 * token, other than a / (in case of a comment in there)
		 * makes this not a declaration.
		 */
		if (begtoken(c) || c == '/')
			firsttok = TRUE;
		else if (!iswhite(c) && !firsttok)
			goto badone;
	}
	while (iswhite(*++sp = c = getc(inf)))
		if ((c == '\n') || (c == EOF)) { /* c == EOF fix for #1091005 */
			lineno++;
			lineftell = ftell(inf);
			if (sp > &line[sizeof (line) - BUFSIZ])
				break;
		}
ret:
	*lp = --sp;
	if (c == '\n')
		lineno--;
	(void) ungetc(c, inf);
	return (!bad && (!*f || isgood(c)));
					/* hack for typedefs */
}

/*
 * Y_entries:
 *	Find the yacc tags and put them in.
 */
static void
Y_entries(void)
{
	char	*sp, *orig_sp;
	int	brace;
	bool	in_rule = FALSE;
	size_t	toklen;
	char	tok[LINEBUFSIZ];

	brace = 0;
	getaline(lineftell);
	pfnote("yyparse", lineno, TRUE);
	while (fgets(line, sizeof (line), inf) != NULL) {
		for (sp = line; *sp; sp++) {
			switch (*sp) {
			case '\n':
				lineno++;
				/* FALLTHROUGH */
			case ' ':
			case '\t':
			case '\f':
			case '\r':
				break;
			case '"':
			case '\'': {
				char start = *sp;
				sp++;

				while ((*sp != '\0') && (*sp != start)) {
					if (*sp == '\\')
						sp++; /* Skip escaped thing */
					sp++;
				}

				if (*sp == '\0')
					sp--;
				break;
			}
			case '/':
				if (*++sp == '*')
					sp = toss_comment(sp);
				else
					--sp;
				break;
			case '{':
				brace++;
				break;
			case '}':
				brace--;
				break;
			case '%':
				if (sp[1] == '%' && sp == line)
					return;
				break;
			case '|':
			case ';':
				in_rule = FALSE;
				break;
			default:
				if (brace == 0 && !in_rule && (isalpha(*sp) ||
				    *sp == '.' ||
				    *sp == '_')) {
					orig_sp = sp;
					++sp;
					while (isalnum(*sp) || *sp == '_' ||
					    *sp == '.')
						sp++;
					toklen = sp - orig_sp;
					while (isspace(*sp))
						sp++;
					if (*sp == ':' || (*sp == '\0' &&
					    first_char() == ':')) {
						(void) strncpy(tok,
						    orig_sp, toklen);
						tok[toklen] = '\0';
						(void) strcpy(lbuf, line);
						lbuf[strlen(lbuf) - 1] = '\0';
						pfnote(tok, lineno, TRUE);
						in_rule = TRUE;
						/*
						 * if we read NUL, leave it so
						 * we read the next line
						 */
						if (*sp == '\0')
							sp--;
					} else {
						sp--;
					}
				}
				break;
			}
		}
	}
}

static char *
toss_comment(char *start)
{
	char	*sp;

	/*
	 * first, see if the end-of-comment is on the same line
	 */
	do {
		while ((sp = strchr(start, '*')) != NULL)
			if (sp[1] == '/')
				return (++sp);
			else
				start = (++sp);
		start = line;
		lineno++;
	} while (fgets(line, sizeof (line), inf) != NULL);

	/*
	 * running this through lint revealed that the original version
	 * of this routine didn't explicitly return something; while
	 * the return value was always used!. so i've added this
	 * next line.
	 */
	return (sp);
}

static void
getaline(long int where)
{
	long saveftell = ftell(inf);
	char *cp;

	(void) fseek(inf, where, 0);
	(void) fgets(lbuf, sizeof (lbuf), inf);
	cp = strrchr(lbuf, '\n');
	if (cp)
		*cp = 0;
	(void) fseek(inf, saveftell, 0);
}

static void
free_tree(NODE *node)
{
	NODE *next;
	while (node) {
		free_tree(node->right);
		next = node->left;
		free(node);
		node = next;
	}
}

static void
add_node(NODE *node, NODE *cur_node)
{
	int dif;

	dif = strcmp(node->entry, cur_node->entry);
	if (dif == 0) {
		if (node->file == cur_node->file) {
			if (!wflag) {
			(void) fprintf(stderr,
			gettext("Duplicate entry in file %s, line %d: %s\n"),
			node->file, lineno, node->entry);
			(void) fprintf(stderr,
					gettext("Second entry ignored\n"));
			}
			return;
		}
		if (!cur_node->been_warned)
			if (!wflag) {
				(void) fprintf(stderr, gettext("Duplicate "
					    "entry in files %s and %s: %s "
					    "(Warning only)\n"),
					    node->file, cur_node->file,
					    node->entry);
			}
		cur_node->been_warned = TRUE;
		return;
	}

	if (dif < 0) {
		if (cur_node->left != NULL)
			add_node(node, cur_node->left);
		else
			cur_node->left = node;
		return;
	}
	if (cur_node->right != NULL)
		add_node(node, cur_node->right);
	else
		cur_node->right = node;
}

static void
put_entries(NODE *node)
{
	char	*sp;

	if (node == NULL)
		return;
	put_entries(node->left);

	/*
	 * while the code in the following #ifdef section could be combined,
	 * it's explicitly separated here to make maintainance easier.
	 */
#ifdef XPG4
	/*
	 * POSIX 2003: we no longer have a "-t" flag; the logic is
	 * automatically assumed to be "turned on" here.
	 */
	if (xflag == 0) {
			(void) fprintf(outf, "%s\t%s\t%c^",
				node->entry, node->file, searchar);
			for (sp = node->pat; *sp; sp++)
				if (*sp == '\\')
					(void) fprintf(outf, "\\\\");
				else if (*sp == searchar)
					(void) fprintf(outf, "\\%c", searchar);
				else
					(void) putc(*sp, outf);
			(void) fprintf(outf, "%c\n", searchar);
	} else if (vflag)
		(void) fprintf(stdout, "%s %s %d\n",
				node->entry, node->file, (node->lno+63)/64);
	else
		(void) fprintf(stdout, "%-16s %4d %-16s %s\n",
			node->entry, node->lno, node->file, node->pat);
#else /* XPG4 */
	/*
	 * original way of doing things. "-t" logic is only turned on
	 * when the user has specified it via a command-line argument.
	 */
	if (xflag == 0)
		if (node->f) {		/* a function */
			(void) fprintf(outf, "%s\t%s\t%c^",
				node->entry, node->file, searchar);
			for (sp = node->pat; *sp; sp++)
				if (*sp == '\\')
					(void) fprintf(outf, "\\\\");
				else if (*sp == searchar)
					(void) fprintf(outf, "\\%c", searchar);
				else
					(void) putc(*sp, outf);
			(void) fprintf(outf, "%c\n", searchar);
		} else {		/* a typedef; text pattern inadequate */
			(void) fprintf(outf, "%s\t%s\t%d\n",
				node->entry, node->file, node->lno);
		} else if (vflag)
		(void) fprintf(stdout, "%s %s %d\n",
				node->entry, node->file, (node->lno+63)/64);
	else
		(void) fprintf(stdout, "%-16s %4d %-16s %s\n",
			node->entry, node->lno, node->file, node->pat);
#endif /* XPG4 */
	put_entries(node->right);
}


static int
PF_funcs(FILE *fi)
{

	pfcnt = 0;
	while (fgets(lbuf, sizeof (lbuf), fi)) {
		lineno++;
		dbp = lbuf;
		if (*dbp == '%') dbp++;	/* Ratfor escape to fortran */
		while (isspace(*dbp))
			dbp++;
		if (*dbp == 0)
			continue;
		switch (*dbp |' ') {

		    case 'i':
			if (tail("integer"))
				takeprec();
			break;
		    case 'r':
			if (tail("real"))
				takeprec();
			break;
		    case 'l':
			if (tail("logical"))
				takeprec();
			break;
		    case 'c':
			if (tail("complex") || tail("character"))
				takeprec();
			break;
		    case 'd':
			if (tail("double")) {
				while (isspace(*dbp))
					dbp++;
				if (*dbp == 0)
					continue;
				if (tail("precision"))
					break;
				continue;
			}
			break;
		}
		while (isspace(*dbp))
			dbp++;
		if (*dbp == 0)
			continue;
		switch (*dbp|' ') {

		    case 'f':
			if (tail("function"))
				getit();
			continue;
		    case 's':
			if (tail("subroutine"))
				getit();
			continue;
		    case 'p':
			if (tail("program")) {
				getit();
				continue;
			}
			if (tail("procedure"))
				getit();
			continue;
		}
	}
	return (pfcnt);
}

static int
tail(char *cp)
{
	int len = 0;

	while (*cp && (*cp&~' ') == ((*(dbp+len))&~' '))
		cp++, len++;
	if (*cp == 0) {
		dbp += len;
		return (1);
	}
	return (0);
}

static void
takeprec(void)
{
	while (isspace(*dbp))
		dbp++;
	if (*dbp != '*')
		return;
	dbp++;
	while (isspace(*dbp))
		dbp++;
	if (!isdigit(*dbp)) {
		--dbp;		/* force failure */
		return;
	}
	do
		dbp++;
	while (isdigit(*dbp));
}

static void
getit(void)
{
	char *cp;
	char c;
	char nambuf[LINEBUFSIZ];

	for (cp = lbuf; *cp; cp++)
		;
	*--cp = 0;	/* zap newline */
	while (isspace(*dbp))
		dbp++;
	if (*dbp == 0 || !isalpha(*dbp) || !isascii(*dbp))
		return;
	for (cp = dbp+1; *cp && (isalpha(*cp) || isdigit(*cp)); cp++)
		continue;
	c = cp[0];
	cp[0] = 0;
	(void) strcpy(nambuf, dbp);
	cp[0] = c;
	pfnote(nambuf, lineno, TRUE);
	pfcnt++;
}

static char *
savestr(char *cp)
{
	int len;
	char *dp;

	len = strlen(cp);
	dp = (char *)malloc(len+1);
	(void) strcpy(dp, cp);

	return (dp);
}

/*
 * lisp tag functions
 * just look for (def or (DEF
 */

static void
L_funcs(FILE *fi)
{
	int	special;

	pfcnt = 0;
	while (fgets(lbuf, sizeof (lbuf), fi)) {
		lineno++;
		dbp = lbuf;
		if (dbp[0] == '(' &&
		    (dbp[1] == 'D' || dbp[1] == 'd') &&
		    (dbp[2] == 'E' || dbp[2] == 'e') &&
		    (dbp[3] == 'F' || dbp[3] == 'f')) {
			dbp += 4;
			if (striccmp(dbp, "method") == 0 ||
			    striccmp(dbp, "wrapper") == 0 ||
			    striccmp(dbp, "whopper") == 0)
				special = TRUE;
			else
				special = FALSE;
			while (!isspace(*dbp))
				dbp++;
			while (isspace(*dbp))
				dbp++;
			L_getit(special);
		}
	}
}

static void
L_getit(int special)
{
	char	*cp;
	char	c;
	char	nambuf[LINEBUFSIZ];

	for (cp = lbuf; *cp; cp++)
		continue;
	*--cp = 0;		/* zap newline */
	if (*dbp == 0)
		return;
	if (special) {
		if ((cp = strchr(dbp, ')')) == NULL)
			return;
		while (cp >= dbp && *cp != ':')
			cp--;
		if (cp < dbp)
			return;
		dbp = cp;
		while (*cp && *cp != ')' && *cp != ' ')
			cp++;
	}
	else
		for (cp = dbp + 1; *cp && *cp != '(' && *cp != ' '; cp++)
			continue;
	c = cp[0];
	cp[0] = 0;
	(void) strcpy(nambuf, dbp);
	cp[0] = c;
	pfnote(nambuf, lineno, TRUE);
	pfcnt++;
}

/*
 * striccmp:
 *	Compare two strings over the length of the second, ignoring
 *	case distinctions.  If they are the same, return 0.  If they
 *	are different, return the difference of the first two different
 *	characters.  It is assumed that the pattern (second string) is
 *	completely lower case.
 */
static int
striccmp(char *str, char *pat)
{
	int	c1;

	while (*pat) {
		if (isupper(*str))
			c1 = tolower(*str);
		else
			c1 = *str;
		if (c1 != *pat)
			return (c1 - *pat);
		pat++;
		str++;
	}
	return (0);
}

/*
 * first_char:
 *	Return the first non-blank character in the file.  After
 *	finding it, rewind the input file so we start at the beginning
 *	again.
 */
static int
first_char(void)
{
	int	c;
	long	off;

	off = ftell(inf);
	while ((c = getc(inf)) != EOF)
		if (!isspace(c) && c != '\r') {
			(void) fseek(inf, off, 0);
			return (c);
		}
	(void) fseek(inf, off, 0);
	return (EOF);
}

/*
 * toss_yysec:
 *	Toss away code until the next "%%" line.
 */
static void
toss_yysec(void)
{
	char		buf[BUFSIZ];

	for (;;) {
		lineftell = ftell(inf);
		if (fgets(buf, BUFSIZ, inf) == NULL)
			return;
		lineno++;
		if (strncmp(buf, "%%", 2) == 0)
			return;
	}
}

static void
Usage(void)
{
#ifdef XPG4
	(void) fprintf(stderr, gettext("Usage:\tctags [-aBFuvw] "
#else /*  !XPG4 */
	(void) fprintf(stderr, gettext("Usage:\tctags [-aBFtuvw] "
#endif /*  XPG4 */
		    "[-f tagsfile] file ...\n"));
	(void) fprintf(stderr, gettext("OR:\tctags [-x] file ...\n"));
	exit(1);
}


/*
 * parseargs():		modify the args
 *	the purpose of this routine is to transform any ancient argument
 *	usage into a format which is acceptable to getopt(3C), so that we
 *	retain backwards Solaris 2.[0-4] compatibility.
 *
 *	This routine allows us to make full use of getopts, without any
 *	funny argument processing in main().
 *
 *	The other alternative would be to hand-craft the processed arguments
 *	during and after getopt(3C) - which usually leads to uglier code
 *	in main(). I've opted to keep the ugliness isolated down here,
 *	instead of in main().
 *
 *	In a nutshell, if the user has used the old Solaris syntax of:
 *		ctags [-aBFtuvwx] [-f tagsfile] filename ...
 *	We simply change this into:
 *		ctags [-a] [-B] [-F] [-t] [-u] [-v] [-w] [-x] [-f tags] file...
 *
 *	If the user has specified the new getopt(3C) syntax, we merely
 *	copy that into our modified argument space.
 */
static void
parseargs(int ac, char **av)
{
	int i;			/* current argument			*/
	int a;			/* used to parse combined arguments	*/
	int fflag;		/* 1 = we're only parsing filenames	*/
	size_t sz;		/* size of the argument			*/
	size_t mav_sz;		/* size of our psuedo argument space	*/

	i = mac = fflag = 0;	/* proper initializations */

	mav_sz = ((ac + 1) * sizeof (char *));
	if ((mav = malloc(mav_sz)) == (char **)NULL) {
		perror("Can't malloc argument space");
		exit(1);
	}

	/* for each argument, see if we need to change things:		*/
	for (; (av[i] != NULL) && (av[i][0] != '\0'); i++) {

		if (strcmp(av[i], "--") == 0) {
			fflag = 1;	/* just handle filenames now	*/
		}

		sz = strlen(&av[i][0]);	/* get this arg's size		*/

		/*
		 * if the argument starts with a "-", and has more than
		 * 1 flag, then we have to search through each character,
		 * and separate any flags which have been combined.
		 *
		 * so, if we've found a "-" string which needs separating:
		 */
		if (fflag == 0 &&	/* not handling filename args	*/
		    av[i][0] == '-' &&	/* and this is a flag		*/
		    sz > 2) {		/* and there's more than 1 flag	*/
			/* then for each flag after the "-" sign:	*/
			for (a = 1; av[i][a]; a++) {
				/* copy the flag into mav space.	*/
				if (a > 1) {
					/*
					 * we need to call realloc() after the
					 * 1st combined flag, because "ac"
					 * doesn't include combined args.
					 */
					mav_sz += sizeof (char *);
					if ((mav = realloc(mav, mav_sz)) ==
					    (char **)NULL) {
						perror("Can't realloc "
							"argument space");
						exit(1);
					}
				}

				if ((mav[mac] = malloc((size_t)CPFLAG)) ==
				    (char *)NULL) {
					perror("Can't malloc argument space");
					exit(1);
				}
				(void) sprintf(mav[mac], "-%c", av[i][a]);
				++mac;
			}
		} else {
			/* otherwise, just copy the argument:		*/
			if ((mav[mac] = malloc(sz + 1)) == (char *)NULL) {
				perror("Can't malloc argument space");
				exit(1);
			}
			(void) strcpy(mav[mac], av[i]);
			++mac;
		}
	}

	mav[mac] = (char *)NULL;
}