* Gnu Emacs TAGS format and modifications by RMS?
* Sam Kendall added C++.
*
- * Francesco Potorti` (pot@cnuce.cnr.it) is the current maintainer. 9.7
+ * Francesco Potorti` (pot@cnuce.cnr.it) is the current maintainer. 10.6
*/
+#ifdef MSDOS
+#include <fcntl.h>
+#endif /* MSDOS */
+
#ifdef HAVE_CONFIG_H
#include <../src/config.h>
#endif
void add_node ();
void error ();
void fatal ();
-void find_entries ();
+logical find_entries ();
void free_tree ();
void getit ();
-void getline ();
void init ();
void initbuffer ();
void initbuffer ();
* Type *xnew (int n, Type);
*/
#define xnew(n, Type) ((Type *) xmalloc ((n) * sizeof (Type)))
-\f
-
/*
- * Symbol table stuff.
- *
- * Should probably be implemented with hash table; linked list for now.
+ * Symbol table types.
*/
-
enum sym_type
{
st_none, st_C_struct, st_C_enum, st_C_define, st_C_typedef, st_C_typespec
};
-
-struct stab_entry
-{
- char *sym;
- int symlen;
- enum sym_type type;
- struct stab_entry *next;
-};
-
-typedef struct stab_entry Stab_entry;
-typedef Stab_entry *Stab;
-
-/*
- * NAME
- * Stab, Stab_entry, stab_create, stab_search, stab_find -- symbol table
- *
- * SYNOPSIS
- * Types: Stab, Stab_entry, enum sym_type
- *
- * Stab * stab_create ()
- *
- * Stab_entry * stab_find (stab, sym)
- * Stab *stab;
- * char *sym;
- *
- * Stab_entry * stab_search (stab, sym)
- * Stab *stab;
- * char *sym;
- *
- * DESCRIPTION
- * stab_create creates a Stab, a symbol table object, and returns a
- * pointer to it. stab_find finds a symbol in a Stab; it returns a
- * pointer to the Stab_entry if found, otherwise NULL. stab_search
- * is like stab_find, except that it creates a new Stab_entry,
- * initialized with type = st_none, if one did not exist already
- * (it never returns NULL).
- *
- * A Stab_entry is a structure that contains at least the following
- * members:
- *
- * char *name; // must not be modified
- * enum sym_type type; // should be set
- *
- * The type field is initially set to st_none; it should be set to
- * something else by the caller of stab_search. Other possible values
- * of an enum sym_type can be added.
- */
-
-Stab *
-stab_create ()
-{
- Stab *sp;
- sp = xnew (1, Stab);
- *sp = NULL; /* a Stab starts out as a null Stab_entry* */
- return sp;
-}
-
-Stab_entry *
-stab_find (stab, sym, symlen)
- Stab *stab;
- register char *sym;
- register int symlen;
-{
- register Stab_entry *se;
- for (se = *stab; se != NULL; se = se->next)
- {
- if (se->symlen == symlen && strneq (se->sym, sym, symlen))
- return se;
- }
-
- return NULL;
-}
-
-Stab_entry *
-stab_search (stab, sym, symlen)
- register Stab *stab;
- char *sym;
- int symlen;
-{
- register Stab_entry *se;
- se = stab_find (stab, sym, symlen);
-
- if (se == NULL)
- {
- /* make a new one */
- se = xnew (1, Stab_entry);
- se->sym = savenstr (sym, symlen);
- se->symlen = symlen;
- se->type = st_none;
- se->next = *stab;
- *stab = se;
- }
-
- return se;
-}
-
-/*
- * NAME
- * stab_type -- type of a symbol table entry
- *
- * SYNOPSIS
- * enum sym_type stab_type (Stab_entry *se);
- *
- * WARNING
- * May evaluate its argument more than once.
- */
-
-#define stab_type(se) ((se)==NULL ? st_none : (se)->type)
\f
*white = " \f\t\n", /* white chars */
*endtk = " \t\n\"'#()[]{}=-+%*/&|^~!<>;,.:?", /* token ending chars */
/* token starting chars */
- *begtk = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$",
+ *begtk = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$~",
/* valid in-token chars */
*intk = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$0123456789";
extern char *massage_name ();
#endif
+#ifdef MSDOS
+ _fmode = O_BINARY; /* all of files are treated as binary files */
+#endif /* MSDOS */
+
progname = argv[0];
#ifndef CTAGS
for (; optind < argc; optind++)
{
this_file = argv[optind];
- if (1)
- {
#endif
- /* Input file named "-" means read file names from stdin
- and use them. */
+ /* Input file named "-" means read file names from stdin and use them. */
if (streq (this_file, "-"))
{
while (!feof (stdin))
else
process_file (this_file);
}
- }
if (emacs_tags_format)
{
{
struct stat stat_buf;
- if (stat (file, &stat_buf) || !S_ISREG (stat_buf.st_mode))
+ if (stat (file, &stat_buf) == 0 && !S_ISREG (stat_buf.st_mode))
{
fprintf (stderr, "Skipping %s: it is not a regular file.\n", file);
return;
}
-
if (streq (file, outfile) && !streq (outfile, "-"))
{
fprintf (stderr, "Skipping inclusion of %s in self.\n", file);
return;
}
- find_entries (file);
+ if (!find_entries (file))
+ {
+ return;
+ }
if (emacs_tags_format)
{
fprintf (outf, "\f\n%s,%d\n", file, total_size_of_entries (head));
* This routine opens the specified file and calls the function
* which finds the function and type definitions.
*/
-void
+logical
find_entries (file)
char *file;
{
if (inf == NULL)
{
perror (file);
- return;
+ return FALSE;
}
curfile = savestr (file);
cp = etags_rindex (file, '.');
&& string_numeric_p (cp + 1))))
{
Scheme_funcs (inf);
- fclose (inf);
- return;
+ goto close_and_return;
}
/* Assume that ".s" or ".a" is assembly code. -wolfgang.
Or even ".sa". */
|| streq (cp + 1, "sa")))
{
Asm_funcs (inf);
- fclose (inf);
- return;
+ goto close_and_return;
}
/* .C or .H or .cxx or .hxx or .cc: a C++ file */
if (cp && (streq (cp + 1, "C")
if (cp && (streq (cp + 1, "f")
|| streq (cp + 1, "for")))
{
- PF_funcs (inf);
+ (void) PF_funcs (inf);
goto close_and_return;
}
/* if not a .c or .h or .y file, try fortran */
close_and_return:
(void) fclose (inf);
+ return TRUE;
}
/* Nonzero if string STR is composed of digits. */
* The C symbol tables.
*/
-Stab *C_stab, *C_PLPL_stab, *C_STAR_stab;
-
+/* Feed stuff between (but not including) %[ and %] lines to:
+ gperf -c -k1,3 -o -p -r -t
+%[
+struct C_stab_entry { char *name; int c_ext; enum sym_type type; }
+%%
+class, C_PLPL, st_C_struct
+domain, C_STAR, st_C_struct
+union, 0, st_C_struct
+struct, 0, st_C_struct
+enum, 0, st_C_enum
+typedef, 0, st_C_typedef
+define, 0, st_C_define
+long, 0, st_C_typespec
+short, 0, st_C_typespec
+int, 0, st_C_typespec
+char, 0, st_C_typespec
+float, 0, st_C_typespec
+double, 0, st_C_typespec
+signed, 0, st_C_typespec
+unsigned, 0, st_C_typespec
+auto, 0, st_C_typespec
+void, 0, st_C_typespec
+extern, 0, st_C_typespec
+static, 0, st_C_typespec
+const, 0, st_C_typespec
+volatile, 0, st_C_typespec
+%]
+and replace lines between %< and %> with its output. */
+/*%<*/
+/* C code produced by gperf version 1.8.1 (K&R C version) */
+/* Command-line: gperf -c -k1,3 -o -p -r -t */
+
+
+struct C_stab_entry { char *name; int c_ext; enum sym_type type; };
+
+#define MIN_WORD_LENGTH 3
+#define MAX_WORD_LENGTH 8
+#define MIN_HASH_VALUE 10
+#define MAX_HASH_VALUE 62
/*
- * SYNOPSIS
- * Stab *get_C_stab (int c_ext);
- */
-#define get_C_stab(c_ext) ((c_ext & C_STAR) ? C_STAR_stab : \
- (c_ext & C_PLPL) ? C_PLPL_stab : \
- C_stab)
+ 21 keywords
+ 53 is the maximum key range
+*/
+
+static int
+hash (str, len)
+ register char *str;
+ register int len;
+{
+ static unsigned char hash_table[] =
+ {
+ 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+ 62, 62, 62, 62, 62, 62, 62, 2, 62, 7,
+ 6, 9, 15, 30, 62, 24, 62, 62, 1, 24,
+ 7, 27, 13, 62, 19, 26, 18, 27, 1, 62,
+ 62, 62, 62, 62, 62, 62, 62, 62,
+ };
+ return len + hash_table[str[2]] + hash_table[str[0]];
+}
-void
-add_keyword (stab, sym, type)
- Stab *stab;
- char *sym;
- enum sym_type type;
-{
- stab_search (stab, sym, strlen (sym))->type = type;
+struct C_stab_entry *
+in_word_set (str, len)
+ register char *str;
+ register int len;
+{
+
+ static struct C_stab_entry wordlist[] =
+ {
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"",},
+ {"volatile", 0, st_C_typespec},
+ {"",},
+ {"long", 0, st_C_typespec},
+ {"char", 0, st_C_typespec},
+ {"class", C_PLPL, st_C_struct},
+ {"",}, {"",}, {"",}, {"",},
+ {"const", 0, st_C_typespec},
+ {"",}, {"",}, {"",}, {"",},
+ {"auto", 0, st_C_typespec},
+ {"",}, {"",},
+ {"define", 0, st_C_define},
+ {"",},
+ {"void", 0, st_C_typespec},
+ {"",}, {"",}, {"",},
+ {"extern", 0, st_C_typespec},
+ {"static", 0, st_C_typespec},
+ {"",},
+ {"domain", C_STAR, st_C_struct},
+ {"",},
+ {"typedef", 0, st_C_typedef},
+ {"double", 0, st_C_typespec},
+ {"enum", 0, st_C_enum},
+ {"",}, {"",}, {"",}, {"",},
+ {"int", 0, st_C_typespec},
+ {"",},
+ {"float", 0, st_C_typespec},
+ {"",}, {"",}, {"",},
+ {"struct", 0, st_C_struct},
+ {"",}, {"",}, {"",}, {"",},
+ {"union", 0, st_C_struct},
+ {"",},
+ {"short", 0, st_C_typespec},
+ {"",}, {"",},
+ {"unsigned", 0, st_C_typespec},
+ {"signed", 0, st_C_typespec},
+ };
+
+ if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+ {
+ register int key = hash (str, len);
+
+ if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
+ {
+ register char *s = wordlist[key].name;
+
+ if (*s == *str && !strncmp (str + 1, s + 1, len - 1))
+ return &wordlist[key];
+ }
+ }
+ return 0;
}
+/*%>*/
-Stab *
-C_create_stab (c_ext)
+enum sym_type
+C_symtype(str, len, c_ext)
+ char *str;
+ int len;
int c_ext;
{
- Stab *stab;
-
- stab = stab_create ();
-
- /* C, C++ and C* */
- if (c_ext & C_PLPL)
- add_keyword (stab, "class", st_C_struct);
- if (c_ext & C_STAR)
- add_keyword (stab, "domain", st_C_struct);
- add_keyword (stab, "union", st_C_struct);
- add_keyword (stab, "struct", st_C_struct);
- add_keyword (stab, "enum", st_C_enum);
- add_keyword (stab, "typedef", st_C_typedef);
- add_keyword (stab, "define", st_C_define);
- add_keyword (stab, "long", st_C_typespec);
- add_keyword (stab, "short", st_C_typespec);
- add_keyword (stab, "int", st_C_typespec);
- add_keyword (stab, "char", st_C_typespec);
- add_keyword (stab, "float", st_C_typespec);
- add_keyword (stab, "double", st_C_typespec);
- add_keyword (stab, "signed", st_C_typespec);
- add_keyword (stab, "unsigned", st_C_typespec);
- add_keyword (stab, "auto", st_C_typespec);
- add_keyword (stab, "void", st_C_typespec);
- add_keyword (stab, "extern", st_C_typespec);
- add_keyword (stab, "static", st_C_typespec);
- add_keyword (stab, "const", st_C_typespec);
- add_keyword (stab, "volatile", st_C_typespec);
-
- return stab;
-}
+ register struct C_stab_entry *se = in_word_set(str, len);
-void
-C_create_stabs ()
-{
- C_stab = C_create_stab (0);
- C_PLPL_stab = C_create_stab (C_PLPL);
- C_STAR_stab = C_create_stab (C_STAR | C_PLPL);
+ if (se == NULL || (se->c_ext && !(c_ext & se->c_ext)))
+ return st_none;
+ return se->type;
}
\f
/*
{
fnone, /* nothing seen */
ftagseen, /* function-like tag seen */
+ fstartlist, /* just after open parenthesis */
finlist, /* in parameter list */
flistseen, /* after parameter list */
- fignore, /* before open brace */
+ fignore /* before open brace */
} FUNCST;
FUNCST funcdef;
tnone, /* nothing seen */
ttypedseen, /* typedef keyword seen */
tinbody, /* inside typedef body */
- tend, /* just before typedef tag */
+ 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 struct body: recognize member func defs*/
+ sinbody /* in struct body: recognize member func defs*/
} STRUCTST;
STRUCTST structdef;
/*
* When structdef is stagseen, scolonseen, or sinbody, structtag is the
- * struct tag, and structkey is the preceding struct-like keyword.
+ * struct tag, and structtype is the type of the preceding struct-like
+ * keyword.
*/
char structtag[BUFSIZ];
-Stab_entry *structkey;
+enum sym_type structtype;
/*
* Yet another little state machine to deal with preprocessor lines.
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;
#define othlinepos (lbs[1-curndx].linepos)
#define newlinepos (lbs[newndx].linepos)
+/* Save and restore token state. This is used when preprocessor defines
+ are handled, to avoid disturbing active function/typedef/struct states. */
+#define TOKEN_SAVED_P (savetok.lineno > 0)
+#define SAVE_TOKEN (savetok = tok, savetok.p = (char *) tokoff, \
+ savetok.len = toklen, strcpy(savenameb, nameb))
+#define RESTORE_TOKEN (tok = savetok, tokoff = (int) tok.p, \
+ toklen = tok.len, strcpy(nameb, savenameb), \
+ savetok.lineno = 0)
+
#define CNL_SAVE_DEFINEDEF \
do { \
SET_FILEPOS (curlinepos, inf, charno); \
#define CNL \
do { \
CNL_SAVE_DEFINEDEF; \
+ if (TOKEN_SAVED_P) \
+ RESTORE_TOKEN; \
definedef = dnone; \
} while (FALSE)
register int tokoff; /* offset in line of start of latest token */
register int toklen; /* length of latest token */
int cblev; /* current curly brace level */
+ int parlev; /* current parenthesis level */
logical incomm, inquote, inchar, quotednl, midtoken;
logical cplpl;
+ TOKEN savetok; /* saved token during preprocessor handling */
+ char savenameb[BUFSIZ]; /* ouch! */
+ savetok.lineno = 0;
curndx = newndx = 0;
lineno = 0;
charno = 0;
next_token_is_func = yacc_rules = FALSE;
midtoken = inquote = inchar = incomm = quotednl = FALSE;
cblev = 0;
+ parlev = 0;
cplpl = c_ext & C_PLPL;
- C_create_stabs ();
-
while (!feof (inf))
{
c = *lp++;
inquote = FALSE;
break;
case '\0':
- /* Newlines inside strings, do not end macro definitions
+ /* Newlines inside strings do not end macro definitions
in traditional cpp, even though compilers don't
usually accept them. */
CNL_SAVE_DEFINEDEF;
}
else if (inchar)
{
- if (c == '\'')
+ switch (c)
+ {
+ case '\0':
+ /* Hmmm, something went wrong. */
+ CNL;
+ /* FALLTHRU */
+ case '\'':
inchar = FALSE;
+ break;
+ }
continue;
}
else
{
case '"':
inquote = TRUE;
+ if (funcdef != finlist && funcdef != fignore)
+ funcdef = fnone;
continue;
case '\'':
inchar = TRUE;
+ if (funcdef != finlist && funcdef != fignore)
+ funcdef = fnone;
continue;
case '/':
if (*lp == '*')
c = 0;
break;
}
- continue;
+ else
+ break;
case '%':
if ((c_ext & YACC) && *lp == '%')
{
yacc_rules = !yacc_rules;
continue;
}
+ else
+ break;
case '#':
if (lp == newlb.buffer + 1 && definedef == dnone)
definedef = dsharpseen;
if (((cblev == 0 && structdef != scolonseen)
|| (cblev == 1 && cplpl && structdef == sinbody))
&& definedef != dignorerest
- && funcdef != finlist)
+ && (funcdef != finlist
+ || (definedef != dnone && definedef != dignorerest)))
{
if (midtoken)
{
if (endtoken (c))
{
- if (cplpl && c == ':' && *lp == ':' && intoken (*(lp + 1)))
+ if (cplpl && c == ':' && *lp == ':' && begtoken(*(lp + 1)))
{
/*
* This handles :: in the middle, but not at beginning
tok.len = toklen;
tok.named = FALSE;
if (yacc_rules
- || consider_token (c, lp, &tok,
- c_ext, cblev, &is_func))
+ || consider_token (c, &tok, c_ext, cblev, &is_func))
{
if (structdef == sinbody
&& definedef == dnone
|| typdef == tend)
tok.named = TRUE;
- if (funcdef == ftagseen
- || structdef == stagseen
- || typdef == tend)
+ if (definedef == dnone
+ && (funcdef == ftagseen
+ || structdef == stagseen
+ || typdef == tend))
{
if (newndx == curndx)
curndx = 1 - curndx; /* switch line buffers */
} /* if (midtoken) */
else if (begtoken (c))
{
- switch (funcdef)
+ switch (definedef)
{
- case flistseen:
- MAKE_TAG_FROM_OTH_LB (TRUE);
- funcdef = fignore;
- break;
- case ftagseen:
- funcdef = fnone;
+ case dnone:
+ switch (funcdef)
+ {
+ case fstartlist:
+ funcdef = finlist;
+ continue;
+ case flistseen:
+ MAKE_TAG_FROM_OTH_LB (TRUE);
+ funcdef = fignore;
+ break;
+ case ftagseen:
+ funcdef = fnone;
+ break;
+ }
+ if (structdef == stagseen)
+ structdef = snone;
break;
+ case dsharpseen:
+ /* Take a quick peek ahead for define directive,
+ so we can avoid saving the token when not absolutely
+ necessary. [This is a speed hack.] */
+ if (c == 'd' && strneq(lp, "efine", 5)
+ && iswhite(*(lp + 5)))
+ {
+ SAVE_TOKEN;
+ definedef = ddefineseen;
+ lp += 6;
+ }
+ else
+ definedef = dignorerest;
+ continue;
}
- if (structdef == stagseen)
- structdef = snone;
if (!yacc_rules || lp == newlb.buffer + 1)
{
tokoff = lp - 1 - newlb.buffer;
/* Detect end of line, colon, comma, semicolon and various braces
- after having handled the last token on the line.*/
+ after having handled a token.*/
switch (c)
{
case ':':
+ if (definedef != dnone)
+ break;
if (structdef == stagseen)
structdef = scolonseen;
- else if (yacc_rules && funcdef == ftagseen)
- {
- MAKE_TAG_FROM_OTH_LB (FALSE);
- funcdef = fignore;
- }
+ else
+ switch (funcdef)
+ {
+ case ftagseen:
+ if (yacc_rules)
+ {
+ MAKE_TAG_FROM_OTH_LB (FALSE);
+ funcdef = fignore;
+ }
+ break;
+ case fstartlist:
+ funcdef = fnone;
+ break;
+ }
break;
case ';':
+ if (definedef != dnone)
+ break;
if (cblev == 0 && typdef == tend)
{
typdef = tnone;
case ',':
/* FALLTHRU */
case '[':
+ if (definedef != dnone)
+ break;
if (funcdef != finlist && funcdef != fignore)
funcdef = fnone;
if (structdef == stagseen)
structdef = snone;
break;
case '(':
+ if (definedef != dnone)
+ break;
switch (funcdef)
{
case ftagseen:
- funcdef = finlist;
+ funcdef = fstartlist;
break;
- case finlist:
case flistseen:
- funcdef = fnone;
+ funcdef = finlist;
break;
}
+ parlev++;
break;
case ')':
- if (funcdef == finlist)
- funcdef = flistseen;
+ if (definedef != dnone)
+ break;
+ if (--parlev == 0)
+ {
+ switch (funcdef)
+ {
+ case fstartlist:
+ case finlist:
+ funcdef = flistseen;
+ break;
+ }
+ }
+ else if (parlev < 0) /* can happen due to ill-conceived #if's. */
+ parlev = 0;
break;
case '{':
+ if (definedef != dnone)
+ break;
if (typdef == ttypedseen)
typdef = tinbody;
switch (structdef)
cblev++;
break;
case '*':
- if (funcdef == flistseen)
- {
- MAKE_TAG_FROM_OTH_LB (TRUE);
- funcdef = fignore;
- }
+ if (definedef != dnone)
+ break;
+ if (funcdef == fstartlist)
+ funcdef = fnone; /* avoid tagging `foo' in `foo (*bar()) ()' */
break;
case '}':
+ if (definedef != dnone)
+ break;
if (!noindentypedefs && lp == newlb.buffer + 1)
- cblev = 0; /* reset curly brace level if first column */
+ {
+ cblev = 0; /* reset curly brace level if first column */
+ parlev = 0; /* also reset paren level, just in case... */
+ }
else if (cblev > 0)
cblev--;
if (cblev == 0)
(void) strcpy (structtag, "<error 2>");
}
break;
+ case '=':
+ case '#': case '+': case '-': case '~': case '&': case '%': case '/':
+ case '|': case '^': case '!': case '<': case '>': case '.': case '?':
+ if (definedef != dnone)
+ break;
+ /* These surely cannot follow a function tag. */
+ if (funcdef != finlist && funcdef != fignore)
+ funcdef = fnone;
+ break;
case '\0':
/* If a macro spans multiple lines don't reset its state. */
if (quotednl)
*/
logical
-consider_token (c, lp, tokp, c_ext, cblev, is_func)
+consider_token (c, 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: token pointer */
int c_ext; /* IN: C extensions mask */
int cblev; /* IN: curly brace level */
logical *is_func; /* OUT */
{
- Stab_entry *tokse = stab_find (get_C_stab (c_ext), tokp->p, tokp->len);
- enum sym_type toktype = stab_type (tokse);
+ enum sym_type toktype = C_symtype(tokp->p, tokp->len, c_ext);
/*
* Advance the definedef state machine.
|| (typedefs_and_cplusplus && cblev == 0 && structdef == snone))
{
structdef = skeyseen;
- structkey = tokse;
+ structtype = toktype;
}
return (FALSE);
}
if (structdef == skeyseen)
{
- if (stab_type (structkey) == st_C_struct)
+ if (structtype == st_C_struct)
{
(void) strncpy (structtag, tokp->p, tokp->len);
structtag[tokp->len] = '\0'; /* for struct/union/class */
{
case 'f':
if (tail ("function"))
- getit ();
+ getit (fi);
continue;
case 's':
if (tail ("subroutine"))
- getit ();
+ getit (fi);
continue;
case 'e':
if (tail ("entry"))
- getit ();
+ getit (fi);
continue;
case 'p':
if (tail ("program"))
{
- getit ();
+ getit (fi);
continue;
}
if (tail ("procedure"))
- getit ();
+ getit (fi);
continue;
}
}
{
register int len = 0;
- while (*cp && (*cp & ~' ') == ((*(dbp + len)) & ~' '))
+ while (*cp && (*cp | ' ') == (dbp[len] | ' '))
cp++, len++;
if (*cp == 0)
{
dbp += len;
- return (1);
+ return (TRUE);
}
- return (0);
+ return (FALSE);
}
void
}
void
-getit ()
+getit (fi)
+ FILE *fi;
{
register char *cp;
char c;
while (isspace (*dbp))
dbp++;
- if (*dbp == 0
- || (!isalpha (*dbp)
+ if (*dbp == '\0')
+ {
+ lineno++;
+ linecharno = charno;
+ charno += readline (&lb, fi);
+ dbp = lb.buffer;
+ if (dbp[5] != '&')
+ return;
+ dbp += 6;
+ while (isspace (*dbp))
+ dbp++;
+ }
+ if (!isalpha (*dbp)
&& *dbp != '_'
- && *dbp != '$'))
+ && *dbp != '$')
return;
- for (cp = dbp + 1; *cp && (isalpha (*cp) || isdigit (*cp)
- || (*cp == '_') || (*cp == '$')); cp++)
+ for (cp = dbp + 1;
+ (*cp
+ && (isalpha (*cp) || isdigit (*cp) || (*cp == '_') || (*cp == '$')));
+ cp++)
continue;
- c = cp[0];
- cp[0] = 0;
+ c = *cp;
+ *cp = '\0';
(void) strcpy (nambuf, dbp);
- cp[0] = c;
- pfnote (nambuf, TRUE, FALSE, lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
+ *cp = c;
+ pfnote (nambuf, TRUE, FALSE, lb.buffer,
+ cp - lb.buffer + 1, lineno, linecharno);
pfcnt++;
}
;
if ((i > 0) && (c == ':'))
- getit ();
+ getit (fi);
}
}
\f
pend = buffer + linebuffer->size;
linebuffer->buffer = buffer;
}
- if (c < 0 || c == '\n')
+ if (c == EOF || c == '\n')
{
*p = 0;
- newline = (c == '\n' ? 1 : 0);
+ newline = (c == '\n') ? 1 : 0;
break;
}
*p++ = c;
char *
xmalloc (size)
- int size;
+ unsigned int size;
{
char *result = malloc (size);
if (!result)
char *
xrealloc (ptr, size)
char *ptr;
- int size;
+ unsigned int size;
{
char *result = realloc (ptr, size);
if (!result)