* Ed Pelegri-Llopart added C typedefs.
* Gnu Emacs TAGS format and modifications by RMS?
* Sam Kendall added C++.
+ *
+ * Francesco Potorti` (pot@cnuce.cnr.it) is the current maintainer. 9.7
*/
+#ifdef HAVE_CONFIG_H
+#include <../src/config.h>
+#endif
+
#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
-#include "getopt.h"
-
-#ifdef __GNUC__
-#define alloca __builtin_alloca
-#else
-#ifdef sparc
-#include <alloca.h>
-#else
-extern char *alloca ();
-#endif
+#if !defined (S_ISREG) && defined (S_IFREG)
+# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
#endif
+#include "getopt.h"
+
extern char *malloc (), *realloc ();
extern char *getenv ();
extern char *strcpy (), *strncpy ();
char *name; /* function or type name */
char *file; /* file name */
logical is_func; /* use pattern or line no */
- logical rewritten; /* list name separately */
+ logical named; /* list name separately */
logical been_warned; /* set if noticed dup */
int lno; /* line number tag is on */
long cno; /* character number line starts on */
char *savestr ();
char *xmalloc ();
char *xrealloc ();
-int L_isdef ();
+int L_isdef (), L_isquote ();
int PF_funcs ();
int total_size_of_entries ();
logical consider_token ();
char *p;
int len;
LINENO lineno;
- logical rewritten;
+ logical named;
} TOKEN;
/* C extensions.
#ifdef ETAGS
printf ("ETAGS ");
#endif
- printf ("for Emacs version 19.0.\n");
+ printf ("for Emacs version 19.\n");
exit (0);
}
printf ("These are the options accepted by %s. You may use unambiguous\n\
abbreviations for the long option names.\n\n", progname);
- fputs ("\
--a, --append\n\
- Append tag entries to existing tags file.\n\
--C, --c++\n\
+ puts ("-a, --append\n\
+ Append tag entries to existing tags file.");
+ puts ("-C, --c++\n\
Treat files with `.c' and `.h' extensions as C++ code, not C\n\
code. Files with `.C', `.H', `.cxx', `.hxx', or `.cc'\n\
- extensions are always assumed to be C++ code.\n\
--d, --defines\n\
+ extensions are always assumed to be C++ code.");
+ fputs ("-d, --defines\n\
Create tag entries for #defines, too.", stdout);
#ifdef ETAGS
Don't rely on indentation quite as much as normal. Currently,\n\
this means not to assume that a closing brace in the first\n\
column is the final brace of a function or structure\n\
- definition.\n\
--t, --typedefs\n\
+ definition.");
+ puts ("-t, --typedefs\n\
Generate tag entries for typedefs. This is the default\n\
- behavior.\n\
--T, --typedefs-and-c++\n\
+ behavior.");
+ puts ("-T, --typedefs-and-c++\n\
Generate tag entries for typedefs, struct/enum/union tags, and\n\
C++ member functions.");
#ifdef CTAGS
puts ("-B, --backward-search\n\
Write the search commands for the tag entries using '?', the\n\
- backward-search command.\n\
--F, --forward-search\n\
+ backward-search command.");
+ puts ("-F, --forward-search\n\
Write the search commands for the tag entries using '/', the\n\
- forward-search command.\n\
--u, --update\n\
+ forward-search command.");
+ puts ("-u, --update\n\
Update the tag entries for the given files, leaving tag\n\
entries for other files in place. Currently, this is\n\
implemented by deleting the existing entries for the given\n\
files and then rewriting the new entries at the end of the\n\
tags file. It is often faster to simply rebuild the entire\n\
- tag file than to use this.\n\
--v, --vgrind\n\
+ tag file than to use this.");
+ puts ("-v, --vgrind\n\
Generates an index of items intended for human consumption,\n\
similar to the output of vgrind. The index is sorted, and\n\
- gives the page number of each item.\n\
--x, --cxref\n\
+ gives the page number of each item.");
+ puts ("-x, --cxref\n\
Like --vgrind, but in the style of cxref, rather than vgrind.\n\
The output uses line numbers instead of page numbers, but\n\
beyond that the differences are cosmetic; try both to see\n\
- which you like.\n\
--w, --no-warn\n\
+ which you like.");
+ puts ("-w, --no-warn\n\
Suppress warning messages about entries defined in multiple\n\
files.");
#endif
char cmd[100];
int i;
unsigned int nincluded_files = 0;
- char **included_files = (char **) alloca (argc * sizeof (char *));
+ char **included_files = xnew (argc, char *);
char *this_file;
#ifdef VMS
char got_err;
for (;;)
{
int opt;
- opt = getopt_long (argc, argv, "aCdDo:StTi:BFuvxwVH", longopts, 0);
+ opt = getopt_long (argc, argv, "aCdDo:f:StTi:BFuvxwVH", longopts, 0);
if (opt == EOF)
break;
case 'D':
constantypedefs = 0;
break;
+ case 'f':
case 'o':
if (outfile)
{
fprintf (stderr,
- "%s: -o flag may only be given once\n", progname);
+ "%s: -%c flag may only be given once\n", progname, opt);
goto usage;
}
outfile = optarg;
{
struct stat stat_buf;
- stat (file, &stat_buf);
- if (!(stat_buf.st_mode & S_IFREG)
-#ifdef S_IFLNK
- || !(stat_buf.st_mode & S_IFLNK)
-#endif
- )
+ if (stat (file, &stat_buf) || !S_ISREG (stat_buf.st_mode))
{
fprintf (stderr, "Skipping %s: it is not a regular file.\n", file);
return;
fprintf (stderr, "Skipping inclusion of %s in self.\n", file);
return;
}
- if (emacs_tags_format)
- {
- char *cp = etags_rindex (file, '/');
- if (cp)
- ++cp;
- else
- cp = file;
- }
find_entries (file);
if (emacs_tags_format)
{
- fprintf (outf, "\f\n%s,%d\n",
- file, total_size_of_entries (head));
+ fprintf (outf, "\f\n%s,%d\n", file, total_size_of_entries (head));
put_entries (head);
free_tree (head);
head = NULL;
}
/*
- * This routine sets up the boolean psuedo-functions which work
+ * This routine sets up the boolean pseudo-functions which work
* by setting 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
/* Record a tag. */
/* Should take a TOKEN* instead!! */
void
-pfnote (name, is_func, rewritten, linestart, linelen, lno, cno)
+pfnote (name, is_func, named, linestart, linelen, lno, cno)
char *name; /* tag name */
logical is_func; /* function or type name? */
- logical rewritten; /* tag different from text of definition? */
+ logical named; /* tag different from text of definition? */
char *linestart;
int linelen;
int lno;
fp = etags_rindex (name, '.');
if (fp && fp[1] != '\0' && fp[2] == '\0')
*fp = 0;
- rewritten = TRUE;
+ named = TRUE;
}
np->name = savestr (name);
np->file = curfile;
np->is_func = is_func;
- np->rewritten = rewritten;
+ np->named = named;
np->lno = lno;
/* UNCOMMENT THE +1 HERE: */
np->cno = cno /* + 1 */ ; /* our char numbers are 0-base; emacs's are 1-base */
* add_node is the only function allowed to add nodes, so it can
* maintain state.
*/
+/* Must avoid static vars within functions since some systems
+ #define static as nothing. */
+static NODE *last_node = NULL;
+
void
add_node (node, cur_node_p)
NODE *node, **cur_node_p;
{
register int dif;
register NODE *cur_node = *cur_node_p;
- static NODE *last_node = NULL;/* careful */
if (cur_node == NULL)
{
if (emacs_tags_format)
{
- if (node->rewritten)
+ if (node->named)
{
fprintf (outf, "%s\177%s\001%d,%d\n",
- node->name, node->pat, node->lno, node->cno);
+ node->pat, node->name,
+ node->lno, node->cno);
}
else
{
fprintf (outf, "%s\177%d,%d\n",
- node->pat, node->lno, node->cno);
+ node->pat,
+ node->lno, node->cno);
}
}
else if (!cxref_style)
/* Count this entry */
total += strlen (node->pat) + 1;
total += number_len ((long) node->lno) + 1 + number_len (node->cno) + 1;
- if (node->rewritten)
+ if (node->named)
total += 1 + strlen (node->name); /* \001name */
}
}
\f
/*
- * etags.c 4.2 1993/03/22 12:13:40 pot Exp
* C functions are recognized using a simple finite automaton.
* funcdef is its state variable.
*/
typedef enum
{
- fnone, ftagseen, finlist, flistseen
+ fnone, /* nothing seen */
+ ftagseen, /* function-like tag seen */
+ finlist, /* in parameter list */
+ flistseen, /* after parameter list */
+ fignore, /* before open brace */
} FUNCST;
FUNCST funcdef;
*/
typedef enum
{
- tnone, ttypedseen, tinbody, tend
+ tnone, /* nothing seen */
+ ttypedseen, /* typedef keyword seen */
+ tinbody, /* inside typedef body */
+ tend, /* just before typedef tag */
} TYPEDST;
TYPEDST typdef;
skeyseen, /* struct-like keyword seen */
stagseen, /* struct-like tag seen */
scolonseen, /* colon seen after struct-like tag */
- sinbody /* in class body: recognize member func defs */
+ sinbody, /* in struct body: recognize member func defs*/
} STRUCTST;
STRUCTST structdef;
/*
dnone, /* nothing seen */
dsharpseen, /* '#' seen as first char on line */
ddefineseen, /* '#' and 'define' seen */
- dignorerest /* ignore rest of line */
+ dignorerest, /* ignore rest of line */
} DEFINEST;
DEFINEST definedef;
* to the list.
*/
-/*
- * LEVEL_OK_FOR_FUNCDEF allows C++ function definition within class body.
- * Currently typdef and structdef stuff (typedefs and struct
- * definitions) are only noticed when level==0, but that may change.
- */
-#define LEVEL_OK_FOR_FUNCDEF() \
- (level==0 || (cplpl && level==1 && structdef==sinbody))
-
#define curlb (lbs[curndx].lb)
#define othlb (lbs[1-curndx].lb)
#define newlb (lbs[newndx].lb)
definedef = dnone; \
} while (FALSE)
-#define MAKE_TAG_FROM_NEW_LB(isfun) pfnote (tokb, isfun, tok.rewritten, \
+#define MAKE_TAG_FROM_NEW_LB(isfun) pfnote (nameb, isfun, tok.named, \
newlb.buffer, tokoff + toklen + 1, tok.lineno, GET_CHARNO (newlinepos))
-#define MAKE_TAG_FROM_OTH_LB(isfun) pfnote (tokb, isfun, tok.rewritten, \
+#define MAKE_TAG_FROM_OTH_LB(isfun) pfnote (nameb, isfun, tok.named, \
othlb.buffer, tokoff + toklen + 1, tok.lineno, GET_CHARNO (othlinepos))
void
register char *lp; /* pointer one beyond the character `c' */
int curndx, newndx; /* indices for current and new lb */
TOKEN tok; /* latest token read for funcdef & structdef */
- char tokb[BUFSIZ]; /* latest token name for funcdef & structdef */
+ char nameb[BUFSIZ]; /* latest token name for funcdef & structdef */
register int tokoff; /* offset in line of start of latest token */
register int toklen; /* length of latest token */
- int level; /* current curly brace level */
+ int cblev; /* current curly brace level */
logical incomm, inquote, inchar, quotednl, midtoken;
logical cplpl;
definedef = dnone; funcdef = fnone; typdef= tnone; structdef= snone;
next_token_is_func = yacc_rules = FALSE;
midtoken = inquote = inchar = incomm = quotednl = FALSE;
- level = 0;
+ cblev = 0;
cplpl = c_ext & C_PLPL;
C_create_stabs ();
typdef= tnone; structdef= snone;
next_token_is_func = FALSE;
midtoken = inquote = inchar = incomm = quotednl = FALSE;
- level = 0;
+ cblev = 0;
yacc_rules = !yacc_rules;
continue;
- }
+ }
case '#':
if (lp == newlb.buffer + 1 && definedef == dnone)
definedef = dsharpseen;
} /* switch (c) */
- if (LEVEL_OK_FOR_FUNCDEF ()
+ /* Consider token only if some complicated conditions are satisfied. */
+ if (((cblev == 0 && structdef != scolonseen)
+ || (cblev == 1 && cplpl && structdef == sinbody))
&& definedef != dignorerest
- && structdef != scolonseen
&& funcdef != finlist)
{
if (midtoken)
}
else
{
- logical is_func;
+ logical is_func = FALSE;
tok.lineno = lineno;
tok.p = newlb.buffer + tokoff;
tok.len = toklen;
- tok.rewritten = FALSE;
+ tok.named = FALSE;
if (yacc_rules
|| consider_token (c, lp, &tok,
- c_ext, level, &is_func))
+ c_ext, cblev, &is_func))
{
if (structdef == sinbody
- && definedef == dnone && is_func)
- { /* function defined in C++ class body */
- sprintf (tokb, "%s::%.*s",
+ && definedef == dnone
+ && is_func)
+ /* function defined in C++ class body */
+ {
+ tok.named = TRUE;
+ sprintf (nameb, "%s::%.*s",
((structtag[0] == '\0')
? "_anonymous_" : structtag),
tok.len, tok.p);
- tok.rewritten = TRUE;
}
else
{
- sprintf (tokb, "%.*s", tok.len, tok.p);
+ sprintf (nameb, "%.*s", tok.len, tok.p);
}
- if (funcdef == ftagseen || structdef == stagseen)
+ if (structdef == stagseen
+ || typdef == tend)
+ tok.named = TRUE;
+
+ if (funcdef == ftagseen
+ || structdef == stagseen
+ || typdef == tend)
{
if (newndx == curndx)
curndx = 1 - curndx; /* switch line buffers */
{
case flistseen:
MAKE_TAG_FROM_OTH_LB (TRUE);
- /* FALLTHRU */
+ funcdef = fignore;
+ break;
case ftagseen:
funcdef = fnone;
break;
else if (yacc_rules && funcdef == ftagseen)
{
MAKE_TAG_FROM_OTH_LB (FALSE);
- funcdef == fnone;
+ funcdef = fignore;
}
break;
case ';':
- funcdef = fnone;
+ if (cblev == 0 && typdef == tend)
+ {
+ typdef = tnone;
+ MAKE_TAG_FROM_OTH_LB (FALSE);
+ }
+ if (funcdef != fignore)
+ funcdef = fnone;
/* FALLTHRU */
case ',':
- if (funcdef != finlist)
- funcdef = fnone;
- if (level == 0 && typdef == tend)
- typdef = tnone;
/* FALLTHRU */
case '[':
- if (funcdef != finlist)
+ if (funcdef != finlist && funcdef != fignore)
funcdef = fnone;
if (structdef == stagseen)
structdef = snone;
MAKE_TAG_FROM_OTH_LB (FALSE);
break;
}
- level++;
- /* FALLTHRU */
+ switch (funcdef)
+ {
+ case flistseen:
+ MAKE_TAG_FROM_OTH_LB (TRUE);
+ /* FALLTHRU */
+ case fignore:
+ funcdef = fnone;
+ }
+ cblev++;
+ break;
case '*':
if (funcdef == flistseen)
{
MAKE_TAG_FROM_OTH_LB (TRUE);
- funcdef = fnone;
+ funcdef = fignore;
}
break;
case '}':
if (!noindentypedefs && lp == newlb.buffer + 1)
- level = 0; /* reset level if first column */
- else if (level > 0)
- level--;
- if (level == 0)
+ cblev = 0; /* reset curly brace level if first column */
+ else if (cblev > 0)
+ cblev--;
+ if (cblev == 0)
{
if (typdef == tinbody)
typdef = tend;
*/
logical
-consider_token (c, lp, tokp, c_ext, level, is_func)
+consider_token (c, lp, tokp, c_ext, cblev, is_func)
register char c; /* IN: first char after the token */
register char *lp; /* IN: lp points to 2nd char after the token */
- register TOKEN *tokp; /* IN */
- int c_ext; /* IN */
- int level; /* IN */
+ register TOKEN *tokp; /* IN: token pointer */
+ int c_ext; /* IN: C extensions mask */
+ int cblev; /* IN: curly brace level */
logical *is_func; /* OUT */
{
- logical firsttok; /* TRUE if have seen first token in ()'s */
Stab_entry *tokse = stab_find (get_C_stab (c_ext), tokp->p, tokp->len);
enum sym_type toktype = stab_type (tokse);
- *is_func = FALSE; /* not a function */
-
/*
* Advance the definedef state machine.
*/
}
/*
- * This structdef business is currently only invoked when level==0.
- * It should be recursively invoked whatever the level, and a stack of
- * states kept, to allow for definitions of structs within structs.
+ * This structdef business is currently only invoked when cblev==0.
+ * It should be recursively invoked whatever the curly brace level,
+ * and a stack of states kept, to allow for definitions of structs
+ * within structs.
*
* This structdef business is NOT invoked when we are ctags and the
* file is plain C. This is because a struct tag may have the same
case st_C_struct:
case st_C_enum:
if (typdef == ttypedseen
- || (typedefs_and_cplusplus && level == 0 && structdef == snone))
+ || (typedefs_and_cplusplus && cblev == 0 && structdef == snone))
{
structdef = skeyseen;
structkey = tokse;
if (next_token_is_func)
{
next_token_is_func = FALSE;
+ funcdef = fnone;
+ *is_func = TRUE; /* to force search string in ctags */
return (TRUE);
}
switch (toktype)
{
case st_C_typespec:
- funcdef == fnone; /* should be useless */
+ funcdef = fnone; /* should be useless */
return (FALSE);
default:
- funcdef = ftagseen;
- *is_func = TRUE;
- return (TRUE);
+ if (funcdef == fnone)
+ {
+ funcdef = ftagseen;
+ *is_func = TRUE;
+ return (TRUE);
+ }
}
+
+ return (FALSE);
}
\f
/* Fortran parsing */
else
{
/* Check for (foo::defmumble name-defined ... */
- while (*dbp && *dbp != ':' && !isspace (*dbp)
- && *dbp != '(' && *dbp != ')')
+ do
dbp++;
+ while (*dbp && !isspace (*dbp)
+ && *dbp != ':' && *dbp != '(' && *dbp != ')');
if (*dbp == ':')
{
- while (*dbp == ':')
+ do
dbp++;
+ while (*dbp == ':');
- if (L_isdef (dbp))
+ if (L_isdef (dbp - 1))
{
while (!isspace (*dbp))
dbp++;
int
L_isdef (dbp)
- char *dbp;
+ register char *dbp;
{
- return ((dbp[1] == 'D' || dbp[1] == 'd') &&
- (dbp[2] == 'E' || dbp[2] == 'e') &&
- (dbp[3] == 'F' || dbp[3] == 'f'));
+ return ((dbp[1] == 'd' || dbp[1] == 'D')
+ && (dbp[2] == 'e' || dbp[2] == 'E')
+ && (dbp[3] == 'f' || dbp[3] == 'F'));
+}
+
+int
+L_isquote (dbp)
+ register char *dbp;
+{
+ return ((*(++dbp) == 'q' || *dbp == 'Q')
+ && (*(++dbp) == 'u' || *dbp == 'U')
+ && (*(++dbp) == 'o' || *dbp == 'O')
+ && (*(++dbp) == 't' || *dbp == 'T')
+ && (*(++dbp) == 'e' || *dbp == 'E')
+ && isspace(*(++dbp)));
}
void
char c;
char nambuf[BUFSIZ];
- if (*dbp == 0)
- return;
- for (cp = dbp + 1; *cp && *cp != '(' && *cp != ' '; cp++)
+ if (*dbp == '\'') /* Skip prefix quote */
+ dbp++;
+ else if (*dbp == '(' && L_isquote (dbp)) /* Skip "(quote " */
+ {
+ dbp += 7;
+ while (isspace(*dbp))
+ dbp++;
+ }
+ for (cp = dbp /*+1*/; *cp && *cp != '(' && *cp != ' ' && *cp != ')'; cp++)
continue;
+ if (cp == dbp)
+ return;
+
c = cp[0];
cp[0] = 0;
(void) strcpy (nambuf, dbp);
cp[0] = c;
- pfnote (nambuf, TRUE, FALSE, lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
+ pfnote (nambuf, TRUE, FALSE, lb.buffer,
+ cp - lb.buffer + 1, lineno, linecharno);
pfcnt++;
}
\f
*s = '\0';
strcpy (nambuf, save_s);
*s = tmpc;
- pfnote (nambuf, TRUE, save_s, strlen (nambuf), lineno, linecharno);
+ pfnote (nambuf, TRUE, FALSE, save_s, strlen (nambuf), lineno, linecharno);
}
/* It is assumed that prolog predicate starts from column 0. */
register char *pend;
int newline; /* 1 if ended with newline, 0 if ended with EOF */
- pend = p + linebuffer->size; /* Separate to avoind 386/IX compiler bug. */
+ pend = p + linebuffer->size; /* Separate to avoid 386/IX compiler bug. */
while (1)
{
HCoop / bpt / emacs.git / blobdiff