diff --git a/usr.bin/ctags/C.c b/usr.bin/ctags/C.c index aca50c67226b..e36b60de4a55 100644 --- a/usr.bin/ctags/C.c +++ b/usr.bin/ctags/C.c @@ -1,534 +1,565 @@ /*- * 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 __FBSDID("$FreeBSD$"); #include +#include #include #include #include "ctags.h" static int func_entry(void); static void hash_entry(void); static void skip_string(int); static int 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 */ 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; 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; sp = tok; } else token = NO; 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; 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_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 *sp++ = c; token = YES; } continue; } sp = tok; token = NO; } } /* * func_entry -- * handle a function reference */ static int 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); 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 (;;) { + for (anext = maybe_attribute;;) { while (GETC(!=, EOF) && iswhite(c)) if (c == '\n') SETLINE; + if (c == EOF) + return NO; + /* + * 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 + < (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; + } + break; + } + } if (intoken(c) || c == '{') break; if (c == '/' && (GETC(==, '*') || c == '/')) skip_comment(c); else { /* don't ever "read" '/' */ (void)ungetc(c, inf); return (NO); } } if (c != '{') (void)skip_key('{'); return (YES); } /* * 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 *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 *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 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); if (c == '{') /* it was "struct {" */ return (YES); for (sp = tok;;) { /* get next token */ if (sp == tok + sizeof tok - 1) /* Too long -- truncate it */ *sp = EOS; else *sp++ = c; if (GETC(==, EOF)) return (NO); 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); } } *sp = EOS; pfnote(tok, curline); return (YES); } /* * 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; break; case '/': if (star && t == '*') return; break; case '\n': + SETLINE; if (t == '/') return; - SETLINE; /*FALLTHROUGH*/ default: star = NO; 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); ) 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_key -- * skip to next char "key" */ int skip_key(int key) { int c, skip, retval; for (skip = retval = NO; 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 */ 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; } return (retval); } diff --git a/usr.bin/ctags/ctags.1 b/usr.bin/ctags/ctags.1 index 9b68f669202e..40c502b3ecdd 100644 --- a/usr.bin/ctags/ctags.1 +++ b/usr.bin/ctags/ctags.1 @@ -1,251 +1,261 @@ .\" Copyright (c) 1987, 1990, 1993 .\" 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.1 8.1 (Berkeley) 6/6/93 .\" $FreeBSD$ .\" -.Dd June 6, 1993 +.Dd May 23, 2023 .Dt CTAGS 1 .Os .Sh NAME .Nm ctags .Nd create a .Pa tags file .Sh SYNOPSIS .Nm .Op Fl BFTaduwvx .Op Fl f Ar tagsfile .Ar .Sh DESCRIPTION The .Nm utility makes a .Pa tags file for .Xr ex 1 from the specified C, Pascal, Fortran, .Xr yacc 1 , .Xr lex 1 , and Lisp sources. A tags file gives the locations of specified objects in a group of files. Each line of the tags file contains the object name, the file in which it is defined, and a search pattern for the object definition, separated by white-space. Using the .Pa tags file, .Xr ex 1 can quickly locate these object definitions. Depending upon the options provided to .Nm , objects will consist of subroutines, typedefs, defines, structs, enums and unions. .Pp The following options are available: .Bl -tag -width indent .It Fl B Use backward searching patterns .Pq Li ?...? . .It Fl F Use forward searching patterns .Pq Li /.../ (the default). .It Fl T Do not create tags for typedefs, structs, unions, and enums. .It Fl a Append to .Pa tags file. .It Fl d Create tags for .Li #defines that do not take arguments; .Li #defines that take arguments are tagged automatically. .It Fl f Place the tag descriptions in a file called .Ar tagsfile . The default behaviour is to place them in a file called .Pa tags . +If +.Ar tagsfile +is +.Dq - , +the tags will be written to standard output instead. .It Fl u Update the specified files in the .Pa tags file, that is, all references to them are deleted, and the new values are appended to the file. -(Beware: this option is implemented in a way which is rather +This is ignored if the tags file does not exist or is not a regular +file (e.g. +.Fl f Ns - +was used to write to standard output). +.Pp +Beware: this option is implemented in a way which is rather slow; it is usually faster to simply rebuild the .Pa tags -file.) +file. .It Fl v An index of the form expected by .Xr vgrind 1 is produced on the standard output. This listing contains the object name, file name, and page number (assuming 64 line pages). Since the output will be sorted into lexicographic order, it may be desired to run the output through .Xr sort 1 . Sample use: .Bd -literal -offset indent ctags -v files | sort -f > index vgrind -x index .Ed .It Fl w Suppress warning diagnostics. .It Fl x .Nm produces a list of object names, the line number and file name on which each is defined, as well as the text of that line and prints this on the standard output. This is a simple index which can be printed out as an off-line readable function index. .El .Pp Files whose names end in .Pa .c or .Pa .h are assumed to be C source files and are searched for C style routine and macro definitions. Files whose names end in .Pa .y are assumed to be .Xr yacc 1 source files. Files whose names end in .Pa .l are assumed to be Lisp files if their first non-blank character is .Ql \&; , .Ql \&( , or .Ql \&[ , otherwise, they are treated as .Xr lex 1 files. Other files are first examined to see if they contain any Pascal or Fortran routine definitions, and, if not, are searched for C style definitions. .Pp The tag .Dq Li main is treated specially in C programs. The tag formed is created by prepending .Ql M to the name of the file, with the trailing .Pa .c and any leading pathname components removed. This makes use of .Nm practical in directories with more than one program. .Pp The .Xr yacc 1 and .Xr lex 1 files each have a special tag. .Dq Li yyparse is the start of the second section of the .Xr yacc 1 file, and .Dq Li yylex is the start of the second section of the .Xr lex 1 file. .Sh FILES .Bl -tag -width ".Pa tags" -compact .It Pa tags default output tags file .El .Sh EXIT STATUS The .Nm utility exits with a value of 1 if an error occurred, 0 otherwise. Duplicate objects are not considered errors. .Sh COMPATIBILITY The .Fl t option is a no-op for compatibility with previous versions of .Nm that did not create tags for typedefs, enums, structs and unions by default. .Sh SEE ALSO .Xr ex 1 , .Xr vi 1 .Sh STANDARDS The .Nm utility conforms to .St -p1003.1-2001 . .Sh HISTORY The .Nm utility appeared in .Bx 3.0 . .Sh BUGS Recognition of functions, subroutines and procedures for Fortran and Pascal is done in a very simpleminded way. No attempt is made to deal with block structure; if you have two Pascal procedures in different blocks with the same name you lose. The .Nm utility does not understand about Pascal types. .Pp The method of deciding whether to look for C, Pascal or Fortran functions is a hack. .Pp The .Nm utility relies on the input being well formed, and any syntactical errors will completely confuse it. It also finds some legal syntax confusing; for example, since it does not understand .Li #ifdef Ns 's (incidentally, that is a feature, not a bug), any code with unbalanced braces inside .Li #ifdef Ns 's will cause it to become somewhat disoriented. In a similar fashion, multiple line changes within a definition will cause it to enter the last line of the object, rather than the first, as the searching pattern. The last line of multiple line .Li typedef Ns 's will similarly be noted. diff --git a/usr.bin/ctags/ctags.c b/usr.bin/ctags/ctags.c index 3e933f033b3f..7bdf5922a634 100644 --- a/usr.bin/ctags/ctags.c +++ b/usr.bin/ctags/ctags.c @@ -1,324 +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 +__FBSDID("$FreeBSD$"); + #include +#include #include -__FBSDID("$FreeBSD$"); #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); 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; while ((ch = getopt(argc, argv, "BFTadf:tuwvx")) != -1) switch(ch) { case 'B': searchar = '?'; break; case 'F': searchar = '/'; break; case 'T': tflag = NO; break; case 'a': aflag++; break; case 'd': dflag++; break; case 'f': outfile = optarg; break; case 't': tflag = YES; 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 ((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); } } } 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; } #define CWHITE " \f\t\n" for (sp = CWHITE; *sp; sp++) /* white space chars */ _wht[*sp] = YES; #define CTOKEN " \t\n\"'#()[]{}=-+%*/&|^~!<>;,.:?" for (sp = CTOKEN; *sp; sp++) /* token ending chars */ _etk[*sp] = YES; #define CINTOK "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz0123456789" for (sp = CINTOK; *sp; sp++) /* valid in-token chars */ _itk[*sp] = YES; #define CBEGIN "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz" for (sp = CBEGIN; *sp; sp++) /* token starting chars */ _btk[*sp] = YES; #define CNOTGD ",;" for (sp = CNOTGD; *sp; sp++) /* invalid after-function chars */ _gd[*sp] = NO; } /* * 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(); }