diff --git a/usr.bin/ctags/C.c b/usr.bin/ctags/C.c index 25c5db5d405b..725336d33e01 100644 --- a/usr.bin/ctags/C.c +++ b/usr.bin/ctags/C.c @@ -1,563 +1,563 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1987, 1993, 1994 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #if 0 #ifndef lint static char sccsid[] = "@(#)C.c 8.4 (Berkeley) 4/2/94"; #endif #endif #include #include #include #include #include #include "ctags.h" -static int func_entry(void); +static bool func_entry(void); static void hash_entry(void); static void skip_string(int); -static int str_entry(int); +static bool str_entry(int); /* * c_entries -- * read .c and .h files and call appropriate routines */ void c_entries(void) { int c; /* current character */ int level; /* brace level */ int token; /* if reading a token */ - int t_def; /* if reading a typedef */ + bool t_def; /* if reading a typedef */ int t_level; /* typedef's brace level */ char *sp; /* buffer pointer */ char tok[MAXTOKEN]; /* token buffer */ lineftell = ftell(inf); - sp = tok; token = t_def = NO; t_level = -1; level = 0; lineno = 1; + sp = tok; token = t_def = false; t_level = -1; level = 0; lineno = 1; while (GETC(!=, EOF)) { switch (c) { /* * Here's where it DOESN'T handle: { * foo(a) * { * #ifdef notdef * } * #endif * if (a) * puts("hello, world"); * } */ case '{': ++level; goto endtok; case '}': /* * if level goes below zero, try and fix * it, even though we've already messed up */ if (--level < 0) level = 0; goto endtok; case '\n': SETLINE; /* * the above 3 cases are similar in that they * are special characters that also end tokens. */ endtok: if (sp > tok) { *sp = EOS; - token = YES; + token = true; sp = tok; } else - token = NO; + token = false; continue; /* * We ignore quoted strings and character constants * completely. */ case '"': case '\'': skip_string(c); break; /* * comments can be fun; note the state is unchanged after * return, in case we found: * "foo() XX comment XX { int bar; }" */ case '/': if (GETC(==, '*') || c == '/') { skip_comment(c); continue; } (void)ungetc(c, inf); c = '/'; goto storec; /* hash marks flag #define's. */ case '#': if (sp == tok) { hash_entry(); break; } goto storec; /* * if we have a current token, parenthesis on * level zero indicates a function. */ case '(': if (!level && token) { int curline; if (sp != tok) *sp = EOS; /* * grab the line immediately, we may * already be wrong, for example, * foo\n * (arg1, */ get_line(); curline = lineno; if (func_entry()) { ++level; pfnote(tok, curline); } break; } goto storec; /* * semi-colons indicate the end of a typedef; if we find a * typedef we search for the next semi-colon of the same * level as the typedef. Ignoring "structs", they are * tricky, since you can find: * * "typedef long time_t;" * "typedef unsigned int u_int;" * "typedef unsigned int u_int [10];" * * If looking at a typedef, we save a copy of the last token * found. Then, when we find the ';' we take the current * token if it starts with a valid token name, else we take * the one we saved. There's probably some reasonable * alternative to this... */ case ';': if (t_def && level == t_level) { - t_def = NO; + t_def = false; get_line(); if (sp != tok) *sp = EOS; pfnote(tok, lineno); break; } goto storec; /* * store characters until one that can't be part of a token * comes along; check the current token against certain * reserved words. */ default: /* ignore whitespace */ if (c == ' ' || c == '\t') { int save = c; while (GETC(!=, EOF) && (c == ' ' || c == '\t')) ; if (c == EOF) return; (void)ungetc(c, inf); c = save; } storec: if (!intoken(c)) { if (sp == tok) break; *sp = EOS; if (tflag) { /* no typedefs inside typedefs */ if (!t_def && !memcmp(tok, "typedef",8)) { - t_def = YES; + t_def = true; t_level = level; break; } /* catch "typedef struct" */ if ((!t_def || t_level < level) && (!memcmp(tok, "struct", 7) || !memcmp(tok, "union", 6) || !memcmp(tok, "enum", 5))) { /* * get line immediately; * may change before '{' */ get_line(); if (str_entry(c)) ++level; break; /* } */ } } sp = tok; } else if (sp != tok || begtoken(c)) { if (sp == tok + sizeof tok - 1) /* Too long -- truncate it */ *sp = EOS; - else + else *sp++ = c; - token = YES; + token = true; } continue; } sp = tok; - token = NO; + token = false; } } /* * func_entry -- * handle a function reference */ -static int +static bool func_entry(void) { int c; /* current character */ int level = 0; /* for matching '()' */ static char attribute[] = "__attribute__"; char maybe_attribute[sizeof attribute + 1], *anext; /* * Find the end of the assumed function declaration. * Note that ANSI C functions can have type definitions so keep * track of the parentheses nesting level. */ while (GETC(!=, EOF)) { switch (c) { case '\'': case '"': /* skip strings and character constants */ skip_string(c); break; case '/': /* skip comments */ if (GETC(==, '*') || c == '/') skip_comment(c); break; case '(': level++; break; case ')': if (level == 0) goto fnd; level--; break; case '\n': SETLINE; } } - return (NO); + return (false); fnd: /* * we assume that the character after a function's right paren * is a token character if it's a function and a non-token * character if it's a declaration. Comments don't count... */ for (anext = maybe_attribute;;) { while (GETC(!=, EOF) && iswhite(c)) if (c == '\n') SETLINE; if (c == EOF) - return NO; + return false; /* * Recognize the gnu __attribute__ extension, which would * otherwise make the heuristic test DTWT */ if (anext == maybe_attribute) { if (intoken(c)) { *anext++ = c; continue; } } else { if (intoken(c)) { - if (anext - maybe_attribute + if (anext - maybe_attribute < (ptrdiff_t)(sizeof attribute - 1)) *anext++ = c; else break; continue; } else { *anext++ = '\0'; if (strcmp(maybe_attribute, attribute) == 0) { (void)ungetc(c, inf); - return NO; + return false; } break; } } if (intoken(c) || c == '{') break; if (c == '/' && (GETC(==, '*') || c == '/')) skip_comment(c); else { /* don't ever "read" '/' */ (void)ungetc(c, inf); - return (NO); + return (false); } } if (c != '{') (void)skip_key('{'); - return (YES); + return (true); } /* * hash_entry -- * handle a line starting with a '#' */ static void hash_entry(void) { int c; /* character read */ int curline; /* line started on */ char *sp; /* buffer pointer */ char tok[MAXTOKEN]; /* storage buffer */ /* ignore leading whitespace */ while (GETC(!=, EOF) && (c == ' ' || c == '\t')) ; (void)ungetc(c, inf); curline = lineno; for (sp = tok;;) { /* get next token */ if (GETC(==, EOF)) return; if (iswhite(c)) break; if (sp == tok + sizeof tok - 1) /* Too long -- truncate it */ *sp = EOS; - else + else *sp++ = c; } *sp = EOS; if (memcmp(tok, "define", 6)) /* only interested in #define's */ goto skip; for (;;) { /* this doesn't handle "#define \n" */ if (GETC(==, EOF)) return; if (!iswhite(c)) break; } for (sp = tok;;) { /* get next token */ if (sp == tok + sizeof tok - 1) /* Too long -- truncate it */ *sp = EOS; - else + else *sp++ = c; if (GETC(==, EOF)) return; /* * this is where it DOESN'T handle * "#define \n" */ if (!intoken(c)) break; } *sp = EOS; if (dflag || c == '(') { /* only want macros */ get_line(); pfnote(tok, curline); } skip: if (c == '\n') { /* get rid of rest of define */ SETLINE if (*(sp - 1) != '\\') return; } (void)skip_key('\n'); } /* * str_entry -- * handle a struct, union or enum entry */ -static int +static bool str_entry(int c) /* c is current character */ { int curline; /* line started on */ char *sp; /* buffer pointer */ char tok[LINE_MAX]; /* storage buffer */ curline = lineno; while (iswhite(c)) if (GETC(==, EOF)) - return (NO); + return (false); if (c == '{') /* it was "struct {" */ - return (YES); + return (true); for (sp = tok;;) { /* get next token */ if (sp == tok + sizeof tok - 1) /* Too long -- truncate it */ *sp = EOS; - else + else *sp++ = c; if (GETC(==, EOF)) - return (NO); + return (false); if (!intoken(c)) break; } switch (c) { case '{': /* it was "struct foo{" */ --sp; break; case '\n': /* it was "struct foo\n" */ SETLINE; /*FALLTHROUGH*/ default: /* probably "struct foo " */ while (GETC(!=, EOF)) if (!iswhite(c)) break; if (c != '{') { (void)ungetc(c, inf); - return (NO); + return (false); } } *sp = EOS; pfnote(tok, curline); - return (YES); + return (true); } /* * skip_comment -- * skip over comment */ void skip_comment(int t) /* t is comment character */ { int c; /* character read */ int star; /* '*' flag */ for (star = 0; GETC(!=, EOF);) switch(c) { /* comments don't nest, nor can they be escaped. */ case '*': - star = YES; + star = true; break; case '/': if (star && t == '*') return; break; case '\n': SETLINE; if (t == '/') return; /*FALLTHROUGH*/ default: - star = NO; + star = false; break; } } /* * skip_string -- * skip to the end of a string or character constant. */ void skip_string(int key) { int c, skip; - for (skip = NO; GETC(!=, EOF); ) + for (skip = false; GETC(!=, EOF); ) switch (c) { case '\\': /* a backslash escapes anything */ skip = !skip; /* we toggle in case it's "\\" */ break; case '\n': SETLINE; /*FALLTHROUGH*/ default: if (c == key && !skip) return; - skip = NO; + skip = false; } } /* * skip_key -- * skip to next char "key" */ -int +bool skip_key(int key) { - int c, - skip, - retval; + int c; + bool skip; + bool retval; - for (skip = retval = NO; GETC(!=, EOF);) + for (skip = retval = false; GETC(!=, EOF);) switch(c) { case '\\': /* a backslash escapes anything */ skip = !skip; /* we toggle in case it's "\\" */ break; case ';': /* special case for yacc; if one */ case '|': /* of these chars occurs, we may */ - retval = YES; /* have moved out of the rule */ + retval = true; /* have moved out of the rule */ break; /* not used by C */ case '\'': case '"': /* skip strings and character constants */ skip_string(c); break; case '/': /* skip comments */ if (GETC(==, '*') || c == '/') { skip_comment(c); break; } (void)ungetc(c, inf); c = '/'; goto norm; case '\n': SETLINE; /*FALLTHROUGH*/ default: norm: if (c == key && !skip) return (retval); - skip = NO; + skip = false; } return (retval); } diff --git a/usr.bin/ctags/ctags.c b/usr.bin/ctags/ctags.c index 6053a52f32da..686acd0f9cdf 100644 --- a/usr.bin/ctags/ctags.c +++ b/usr.bin/ctags/ctags.c @@ -1,343 +1,343 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1987, 1993, 1994, 1995 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef lint static const char copyright[] = "@(#) Copyright (c) 1987, 1993, 1994, 1995\n\ The Regents of the University of California. All rights reserved.\n"; #endif #if 0 #ifndef lint static char sccsid[] = "@(#)ctags.c 8.4 (Berkeley) 2/7/95"; #endif #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ctags.h" /* * ctags: create a tags file */ NODE *head; /* head of the sorted binary tree */ /* boolean "func" (see init()) */ bool _wht[256], _etk[256], _itk[256], _btk[256], _gd[256]; FILE *inf; /* ioptr for current input file */ FILE *outf; /* ioptr for tags file */ long lineftell; /* ftell after getc( inf ) == '\n' */ int lineno; /* line number of current line */ int dflag; /* -d: non-macro defines */ int tflag; /* -t: create tags for typedefs */ int vflag; /* -v: vgrind style index output */ int wflag; /* -w: suppress warnings */ int xflag; /* -x: cxref style output */ char *curfile; /* current input file name */ char searchar = '/'; /* use /.../ searches by default */ char lbuf[LINE_MAX]; void init(void); void find_entries(char *); static void usage(void) __dead2; int main(int argc, char **argv) { static const char *outfile = "tags"; /* output file */ int aflag; /* -a: append to tags */ int uflag; /* -u: update tags */ int exit_val; /* exit value */ int step; /* step through args */ int ch; /* getopts char */ setlocale(LC_ALL, ""); - aflag = uflag = NO; - tflag = YES; + aflag = uflag = false; + tflag = true; while ((ch = getopt(argc, argv, "BFTadf:tuwvx")) != -1) switch(ch) { case 'B': searchar = '?'; break; case 'F': searchar = '/'; break; case 'T': - tflag = NO; + tflag = false; break; case 'a': aflag++; break; case 'd': dflag++; break; case 'f': outfile = optarg; break; case 't': - tflag = YES; + tflag = true; break; case 'u': uflag++; break; case 'w': wflag++; break; case 'v': vflag++; case 'x': xflag++; break; case '?': default: usage(); } argv += optind; argc -= optind; if (!argc) usage(); if (strcmp(outfile, "-") == 0) outfile = "/dev/stdout"; if (!xflag) setlocale(LC_COLLATE, "C"); init(); for (exit_val = step = 0; step < argc; ++step) if (!(inf = fopen(argv[step], "r"))) { warn("%s", argv[step]); exit_val = 1; } else { curfile = argv[step]; find_entries(argv[step]); (void)fclose(inf); } if (head) { if (xflag) put_entries(head); else { if (uflag) { struct stat sb; FILE *oldf; regex_t *regx; if ((oldf = fopen(outfile, "r")) == NULL) { if (errno == ENOENT) { uflag = 0; goto udone; } err(1, "opening %s", outfile); } if (fstat(fileno(oldf), &sb) != 0 || !S_ISREG(sb.st_mode)) { fclose(oldf); uflag = 0; goto udone; } if (unlink(outfile)) err(1, "unlinking %s", outfile); if ((outf = fopen(outfile, "w")) == NULL) err(1, "recreating %s", outfile); if ((regx = calloc(argc, sizeof(regex_t))) == NULL) err(1, "RE alloc"); for (step = 0; step < argc; step++) { (void)strcpy(lbuf, "\t"); (void)strlcat(lbuf, argv[step], LINE_MAX); (void)strlcat(lbuf, "\t", LINE_MAX); if (regcomp(regx + step, lbuf, REG_NOSPEC)) warn("RE compilation failed"); } nextline: while (fgets(lbuf, LINE_MAX, oldf)) { for (step = 0; step < argc; step++) if (regexec(regx + step, lbuf, 0, NULL, 0) == 0) goto nextline; fputs(lbuf, outf); } for (step = 0; step < argc; step++) regfree(regx + step); free(regx); fclose(oldf); fclose(outf); ++aflag; } udone: if (!(outf = fopen(outfile, aflag ? "a" : "w"))) err(1, "%s", outfile); put_entries(head); (void)fclose(outf); if (uflag) { pid_t pid; if ((pid = fork()) == -1) err(1, "fork failed"); else if (pid == 0) { execlp("sort", "sort", "-o", outfile, outfile, NULL); err(1, "exec of sort failed"); } /* Just assume the sort went OK. The old code did not do any checks either. */ (void)wait(NULL); } } } if (ferror(stdout) != 0 || fflush(stdout) != 0) err(1, "stdout"); exit(exit_val); } static void usage(void) { (void)fprintf(stderr, "usage: ctags [-BFTaduwvx] [-f tagsfile] file ...\n"); exit(1); } /* * init -- * 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 false with respect to * the pseudo-function. Therefore, all of the array "_wht" is NO * by default and then the elements subscripted by the chars in * CWHITE are set to YES. Thus, "_wht" of a char is YES if it is in * the string CWHITE, else NO. */ void init(void) { int i; const unsigned char *sp; for (i = 0; i < 256; i++) { - _wht[i] = _etk[i] = _itk[i] = _btk[i] = NO; - _gd[i] = YES; + _wht[i] = _etk[i] = _itk[i] = _btk[i] = false; + _gd[i] = true; } #define CWHITE " \f\t\n" for (sp = CWHITE; *sp; sp++) /* white space chars */ - _wht[*sp] = YES; + _wht[*sp] = true; #define CTOKEN " \t\n\"'#()[]{}=-+%*/&|^~!<>;,.:?" for (sp = CTOKEN; *sp; sp++) /* token ending chars */ - _etk[*sp] = YES; + _etk[*sp] = true; #define CINTOK "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz0123456789" for (sp = CINTOK; *sp; sp++) /* valid in-token chars */ - _itk[*sp] = YES; + _itk[*sp] = true; #define CBEGIN "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz" for (sp = CBEGIN; *sp; sp++) /* token starting chars */ - _btk[*sp] = YES; + _btk[*sp] = true; #define CNOTGD ",;" for (sp = CNOTGD; *sp; sp++) /* invalid after-function chars */ - _gd[*sp] = NO; + _gd[*sp] = false; } /* * find_entries -- * this routine opens the specified file and calls the function * which searches the file. */ void find_entries(char *file) { char *cp; lineno = 0; /* should be 1 ?? KB */ if ((cp = strrchr(file, '.'))) { if (cp[1] == 'l' && !cp[2]) { int c; for (;;) { if (GETC(==, EOF)) return; if (!iswhite(c)) { rewind(inf); break; } } #define LISPCHR ";([" /* lisp */ if (strchr(LISPCHR, c)) { l_entries(); return; } /* lex */ else { /* * we search all 3 parts of a lex file * for C references. This may be wrong. */ toss_yysec(); (void)strcpy(lbuf, "%%$"); pfnote("yylex", lineno); rewind(inf); } } /* yacc */ else if (cp[1] == 'y' && !cp[2]) { /* * we search only the 3rd part of a yacc file * for C references. This may be wrong. */ toss_yysec(); (void)strcpy(lbuf, "%%$"); pfnote("yyparse", lineno); y_entries(); } /* fortran */ else if ((cp[1] != 'c' && cp[1] != 'h') && !cp[2]) { if (PF_funcs()) return; rewind(inf); } } /* C */ c_entries(); } diff --git a/usr.bin/ctags/ctags.h b/usr.bin/ctags/ctags.h index 8892733d650f..5079353a8136 100644 --- a/usr.bin/ctags/ctags.h +++ b/usr.bin/ctags/ctags.h @@ -1,96 +1,95 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1987, 1993, 1994 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)ctags.h 8.3 (Berkeley) 4/2/94 * */ -#define bool char +/* This header requires bool for some externed symbols. */ +#include -#define YES 1 -#define NO 0 #define EOS '\0' #define ENDLINE 50 /* max length of pattern */ #define MAXTOKEN 250 /* max size of single token */ #define SETLINE {++lineno;lineftell = ftell(inf);} #define GETC(op,exp) ((c = getc(inf)) op (int)exp) /* * These character classification macros assume that the (EOF & 0xff) element * of the arrays is always 'NO', as the EOF return from getc() gets masked * to that value. Masking with 0xff has no effect for normal characters * returned by getc() provided chars have 8 bits. */ #define iswhite(arg) _wht[arg & 0xff] /* T if char is white */ #define begtoken(arg) _btk[arg & 0xff] /* T if char can start token */ #define intoken(arg) _itk[arg & 0xff] /* T if char can be in token */ #define endtoken(arg) _etk[arg & 0xff] /* T if char ends tokens */ #define isgood(arg) _gd[arg & 0xff] /* T if char can be after ')' */ typedef struct nd_st { /* sorting structure */ struct nd_st *left, *right; /* left and right sons */ char *entry, /* function or type name */ *file, /* file name */ *pat; /* search pattern */ int lno; /* for -x option */ bool been_warned; /* set if noticed dup */ } NODE; extern char *curfile; /* current input file name */ extern NODE *head; /* head of the sorted binary tree */ extern FILE *inf; /* ioptr for current input file */ extern FILE *outf; /* ioptr for current output file */ extern long lineftell; /* ftell after getc( inf ) == '\n' */ extern int lineno; /* line number of current line */ extern int dflag; /* -d: non-macro defines */ extern int tflag; /* -t: create tags for typedefs */ extern int vflag; /* -v: vgrind style index output */ extern int wflag; /* -w: suppress warnings */ extern int xflag; /* -x: cxref style output */ extern bool _wht[], _etk[], _itk[], _btk[], _gd[]; extern char lbuf[LINE_MAX]; extern char *lbp; extern char searchar; /* ex search character */ -extern int cicmp(const char *); +extern bool cicmp(const char *); extern void get_line(void); extern void pfnote(const char *, int); -extern int skip_key(int); +extern bool skip_key(int); extern void put_entries(NODE *); extern void toss_yysec(void); extern void l_entries(void); extern void y_entries(void); -extern int PF_funcs(void); +extern bool PF_funcs(void); extern void c_entries(void); extern void skip_comment(int); diff --git a/usr.bin/ctags/fortran.c b/usr.bin/ctags/fortran.c index 7fa6ec3823d9..56ae3b66458b 100644 --- a/usr.bin/ctags/fortran.c +++ b/usr.bin/ctags/fortran.c @@ -1,168 +1,168 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1987, 1993, 1994 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #if 0 #ifndef lint static char sccsid[] = "@(#)fortran.c 8.3 (Berkeley) 4/2/94"; #endif #endif #include #include #include #include #include #include "ctags.h" static void takeprec(void); char *lbp; /* line buffer pointer */ -int +bool PF_funcs(void) { bool pfcnt; /* pascal/fortran functions found */ char *cp; char tok[MAXTOKEN]; - for (pfcnt = NO;;) { + for (pfcnt = false;;) { lineftell = ftell(inf); if (!fgets(lbuf, sizeof(lbuf), inf)) return (pfcnt); ++lineno; lbp = lbuf; if (*lbp == '%') /* Ratfor escape to fortran */ ++lbp; for (; isspace(*lbp); ++lbp) continue; if (!*lbp) continue; switch (*lbp | ' ') { /* convert to lower-case */ case 'c': if (cicmp("complex") || cicmp("character")) takeprec(); break; case 'd': if (cicmp("double")) { for (; isspace(*lbp); ++lbp) continue; if (!*lbp) continue; if (cicmp("precision")) break; continue; } break; case 'i': if (cicmp("integer")) takeprec(); break; case 'l': if (cicmp("logical")) takeprec(); break; case 'r': if (cicmp("real")) takeprec(); break; } for (; isspace(*lbp); ++lbp) continue; if (!*lbp) continue; switch (*lbp | ' ') { case 'f': if (cicmp("function")) break; continue; case 'p': if (cicmp("program") || cicmp("procedure")) break; continue; case 's': if (cicmp("subroutine")) break; default: continue; } for (; isspace(*lbp); ++lbp) continue; if (!*lbp) continue; for (cp = lbp + 1; *cp && intoken(*cp); ++cp) continue; if (cp == lbp + 1) continue; *cp = EOS; (void)strlcpy(tok, lbp, sizeof(tok)); /* possible trunc */ get_line(); /* process line for ex(1) */ pfnote(tok, lineno); - pfcnt = YES; + pfcnt = true; } /*NOTREACHED*/ } /* * cicmp -- * do case-independent strcmp */ -int +bool cicmp(const char *cp) { int len; char *bp; for (len = 0, bp = lbp; *cp && (*cp &~ ' ') == (*bp++ &~ ' '); ++cp, ++len) continue; if (!*cp) { lbp += len; - return (YES); + return (true); } - return (NO); + return (false); } static void takeprec(void) { for (; isspace(*lbp); ++lbp) continue; if (*lbp == '*') { for (++lbp; isspace(*lbp); ++lbp) continue; if (!isdigit(*lbp)) --lbp; /* force failure */ else while (isdigit(*++lbp)) continue; } } diff --git a/usr.bin/ctags/lisp.c b/usr.bin/ctags/lisp.c index d167c82e7c69..bd6100709299 100644 --- a/usr.bin/ctags/lisp.c +++ b/usr.bin/ctags/lisp.c @@ -1,106 +1,106 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1987, 1993, 1994 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #if 0 #ifndef lint static char sccsid[] = "@(#)lisp.c 8.3 (Berkeley) 4/2/94"; #endif #endif #include #include #include #include #include #include "ctags.h" /* * lisp tag functions * just look for (def or (DEF */ void l_entries(void) { - int special; + bool special; char *cp; char savedc; char tok[MAXTOKEN]; for (;;) { lineftell = ftell(inf); if (!fgets(lbuf, sizeof(lbuf), inf)) return; ++lineno; lbp = lbuf; if (!cicmp("(def")) continue; - special = NO; + special = false; switch(*lbp | ' ') { case 'm': if (cicmp("method")) - special = YES; + special = true; break; case 'w': if (cicmp("wrapper") || cicmp("whopper")) - special = YES; + special = true; } for (; !isspace(*lbp); ++lbp) continue; for (; isspace(*lbp); ++lbp) continue; for (cp = lbp; *cp && *cp != '\n'; ++cp) continue; *cp = EOS; if (special) { if (!(cp = strchr(lbp, ')'))) continue; for (; cp >= lbp && *cp != ':'; --cp) continue; if (cp < lbp) continue; lbp = cp; for (; *cp && *cp != ')' && *cp != ' '; ++cp) continue; } else for (cp = lbp + 1; *cp && *cp != '(' && *cp != ' '; ++cp) continue; savedc = *cp; *cp = EOS; (void)strlcpy(tok, lbp, sizeof(tok)); /* possible trunc */ *cp = savedc; get_line(); pfnote(tok, lineno); } /*NOTREACHED*/ } diff --git a/usr.bin/ctags/tree.c b/usr.bin/ctags/tree.c index 15291f4a5e80..c3cfabc6e25f 100644 --- a/usr.bin/ctags/tree.c +++ b/usr.bin/ctags/tree.c @@ -1,133 +1,133 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1987, 1993, 1994 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #if 0 #ifndef lint static char sccsid[] = "@(#)tree.c 8.3 (Berkeley) 4/2/94"; #endif #endif #include #include #include #include #include #include #include "ctags.h" static void add_node(NODE *, NODE *); static void free_tree(NODE *); /* * pfnote -- * enter a new node in the tree */ void pfnote(const char *name, int ln) { NODE *np; char *fp; char nbuf[MAXTOKEN]; /*NOSTRICT*/ if (!(np = (NODE *)malloc(sizeof(NODE)))) { warnx("too many entries to sort"); put_entries(head); free_tree(head); /*NOSTRICT*/ if (!(head = np = (NODE *)malloc(sizeof(NODE)))) errx(1, "out of space"); } if (!xflag && !strcmp(name, "main")) { if (!(fp = strrchr(curfile, '/'))) fp = curfile; else ++fp; (void)snprintf(nbuf, sizeof(nbuf), "M%s", fp); fp = strrchr(nbuf, '.'); if (fp && !fp[2]) *fp = EOS; name = nbuf; } if (!(np->entry = strdup(name))) err(1, NULL); np->file = curfile; np->lno = ln; np->left = np->right = 0; if (!(np->pat = strdup(lbuf))) err(1, NULL); if (!head) head = np; else add_node(np, head); } static void add_node(NODE *node, NODE *cur_node) { int dif; dif = strcoll(node->entry, cur_node->entry); if (!dif) { if (node->file == cur_node->file) { if (!wflag) fprintf(stderr, "Duplicate entry in file %s, line %d: %s\nSecond entry ignored\n", node->file, lineno, node->entry); return; } if (!cur_node->been_warned) if (!wflag) fprintf(stderr, "Duplicate entry in files %s and %s: %s (Warning only)\n", node->file, cur_node->file, node->entry); - cur_node->been_warned = YES; + cur_node->been_warned = true; } else if (dif < 0) if (cur_node->left) add_node(node, cur_node->left); else cur_node->left = node; else if (cur_node->right) add_node(node, cur_node->right); else cur_node->right = node; } static void free_tree(NODE *node) { NODE *node_next; while (node) { if (node->right) free_tree(node->right); node_next = node->left; free(node); node = node_next; } } diff --git a/usr.bin/ctags/yacc.c b/usr.bin/ctags/yacc.c index 0fd8537fb74f..e30ea0eacad0 100644 --- a/usr.bin/ctags/yacc.c +++ b/usr.bin/ctags/yacc.c @@ -1,151 +1,151 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1987, 1993, 1994 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #if 0 #ifndef lint static char sccsid[] = "@(#)yacc.c 8.3 (Berkeley) 4/2/94"; #endif #endif #include #include #include #include #include "ctags.h" /* * y_entries: * find the yacc tags and put them in. */ void y_entries(void) { int c; char *sp; bool in_rule; char tok[MAXTOKEN]; - in_rule = NO; + in_rule = false; while (GETC(!=, EOF)) switch (c) { case '\n': SETLINE; /* FALLTHROUGH */ case ' ': case '\f': case '\r': case '\t': break; case '{': if (skip_key('}')) - in_rule = NO; + in_rule = false; break; case '\'': case '"': if (skip_key(c)) - in_rule = NO; + in_rule = false; break; case '%': if (GETC(==, '%')) return; (void)ungetc(c, inf); break; case '/': if (GETC(==, '*') || c == '/') skip_comment(c); else (void)ungetc(c, inf); break; case '|': case ';': - in_rule = NO; + in_rule = false; break; default: if (in_rule || (!isalpha(c) && c != '.' && c != '_')) break; sp = tok; *sp++ = c; while (GETC(!=, EOF) && (intoken(c) || c == '.')) *sp++ = c; *sp = EOS; get_line(); /* may change before ':' */ while (iswhite(c)) { if (c == '\n') SETLINE; if (GETC(==, EOF)) return; } if (c == ':') { pfnote(tok, lineno); - in_rule = YES; + in_rule = true; } else (void)ungetc(c, inf); } } /* * toss_yysec -- * throw away lines up to the next "\n%%\n" */ void toss_yysec(void) { int c; /* read character */ int state; /* * state == 0 : waiting * state == 1 : received a newline * state == 2 : received first % * state == 3 : received second % */ lineftell = ftell(inf); for (state = 0; GETC(!=, EOF);) switch (c) { case '\n': ++lineno; lineftell = ftell(inf); if (state == 3) /* done! */ return; state = 1; /* start over */ break; case '%': if (state) /* if 1 or 2 */ ++state; /* goto 3 */ break; default: state = 0; /* reset */ break; } }