In M-%, avoid making buffer-local binding of text-property-default-nonsticky
[emacs.git] / lib-src / etags.c
blob01e230206ac8419e6b9e31e03f00955a88b39f06
1 /* Tags file maker to go with GNU Emacs -*- coding: utf-8 -*-
3 Copyright (C) 1984 The Regents of the University of California
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are
7 met:
8 1. Redistributions of source code must retain the above copyright
9 notice, this list of conditions and the following disclaimer.
10 2. Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the
13 distribution.
14 3. Neither the name of the University nor the names of its
15 contributors may be used to endorse or promote products derived
16 from this software without specific prior written permission.
18 THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS''
19 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS
22 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
27 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
28 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 Copyright (C) 1984, 1987-1989, 1993-1995, 1998-2016 Free Software
32 Foundation, Inc.
34 This file is not considered part of GNU Emacs.
36 This program is free software: you can redistribute it and/or modify
37 it under the terms of the GNU General Public License as published by
38 the Free Software Foundation, either version 3 of the License, or (at
39 your option) any later version.
41 This program is distributed in the hope that it will be useful,
42 but WITHOUT ANY WARRANTY; without even the implied warranty of
43 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
44 GNU General Public License for more details.
46 You should have received a copy of the GNU General Public License
47 along with this program. If not, see <http://www.gnu.org/licenses/>. */
50 /* NB To comply with the above BSD license, copyright information is
51 reproduced in etc/ETAGS.README. That file should be updated when the
52 above notices are.
54 To the best of our knowledge, this code was originally based on the
55 ctags.c distributed with BSD4.2, which was copyrighted by the
56 University of California, as described above. */
60 * Authors:
61 * 1983 Ctags originally by Ken Arnold.
62 * 1984 Fortran added by Jim Kleckner.
63 * 1984 Ed Pelegri-Llopart added C typedefs.
64 * 1985 Emacs TAGS format by Richard Stallman.
65 * 1989 Sam Kendall added C++.
66 * 1992 Joseph B. Wells improved C and C++ parsing.
67 * 1993 Francesco Potortì reorganized C and C++.
68 * 1994 Line-by-line regexp tags by Tom Tromey.
69 * 2001 Nested classes by Francesco Potortì (concept by Mykola Dzyuba).
70 * 2002 #line directives by Francesco Potortì.
71 * Francesco Potortì maintained and improved it for many years
72 starting in 1993.
76 * If you want to add support for a new language, start by looking at the LUA
77 * language, which is the simplest. Alternatively, consider distributing etags
78 * together with a configuration file containing regexp definitions for etags.
81 char pot_etags_version[] = "@(#) pot revision number is 17.38.1.4";
83 #ifdef DEBUG
84 # undef DEBUG
85 # define DEBUG true
86 #else
87 # define DEBUG false
88 # define NDEBUG /* disable assert */
89 #endif
91 #include <config.h>
93 #ifndef _GNU_SOURCE
94 # define _GNU_SOURCE 1 /* enables some compiler checks on GNU */
95 #endif
97 /* WIN32_NATIVE is for XEmacs.
98 MSDOS, WINDOWSNT, DOS_NT are for Emacs. */
99 #ifdef WIN32_NATIVE
100 # undef MSDOS
101 # undef WINDOWSNT
102 # define WINDOWSNT
103 #endif /* WIN32_NATIVE */
105 #ifdef MSDOS
106 # undef MSDOS
107 # define MSDOS true
108 # include <sys/param.h>
109 #else
110 # define MSDOS false
111 #endif /* MSDOS */
113 #ifdef WINDOWSNT
114 # include <direct.h>
115 # define MAXPATHLEN _MAX_PATH
116 # undef HAVE_NTGUI
117 # undef DOS_NT
118 # define DOS_NT
119 # define O_CLOEXEC O_NOINHERIT
120 #endif /* WINDOWSNT */
122 #include <limits.h>
123 #include <unistd.h>
124 #include <stdarg.h>
125 #include <stdlib.h>
126 #include <string.h>
127 #include <sysstdio.h>
128 #include <errno.h>
129 #include <fcntl.h>
130 #include <binary-io.h>
131 #include <c-ctype.h>
132 #include <c-strcase.h>
134 #include <assert.h>
135 #ifdef NDEBUG
136 # undef assert /* some systems have a buggy assert.h */
137 # define assert(x) ((void) 0)
138 #endif
140 #include <getopt.h>
141 #include <regex.h>
143 /* Define CTAGS to make the program "ctags" compatible with the usual one.
144 Leave it undefined to make the program "etags", which makes emacs-style
145 tag tables and tags typedefs, #defines and struct/union/enum by default. */
146 #ifdef CTAGS
147 # undef CTAGS
148 # define CTAGS true
149 #else
150 # define CTAGS false
151 #endif
153 static bool
154 streq (char const *s, char const *t)
156 return strcmp (s, t) == 0;
159 static bool
160 strcaseeq (char const *s, char const *t)
162 return c_strcasecmp (s, t) == 0;
165 static bool
166 strneq (char const *s, char const *t, size_t n)
168 return strncmp (s, t, n) == 0;
171 static bool
172 strncaseeq (char const *s, char const *t, size_t n)
174 return c_strncasecmp (s, t, n) == 0;
177 /* C is not in a name. */
178 static bool
179 notinname (unsigned char c)
181 /* Look at make_tag before modifying! */
182 static bool const table[UCHAR_MAX + 1] = {
183 ['\0']=1, ['\t']=1, ['\n']=1, ['\f']=1, ['\r']=1, [' ']=1,
184 ['(']=1, [')']=1, [',']=1, [';']=1, ['=']=1
186 return table[c];
189 /* C can start a token. */
190 static bool
191 begtoken (unsigned char c)
193 static bool const table[UCHAR_MAX + 1] = {
194 ['$']=1, ['@']=1,
195 ['A']=1, ['B']=1, ['C']=1, ['D']=1, ['E']=1, ['F']=1, ['G']=1, ['H']=1,
196 ['I']=1, ['J']=1, ['K']=1, ['L']=1, ['M']=1, ['N']=1, ['O']=1, ['P']=1,
197 ['Q']=1, ['R']=1, ['S']=1, ['T']=1, ['U']=1, ['V']=1, ['W']=1, ['X']=1,
198 ['Y']=1, ['Z']=1,
199 ['_']=1,
200 ['a']=1, ['b']=1, ['c']=1, ['d']=1, ['e']=1, ['f']=1, ['g']=1, ['h']=1,
201 ['i']=1, ['j']=1, ['k']=1, ['l']=1, ['m']=1, ['n']=1, ['o']=1, ['p']=1,
202 ['q']=1, ['r']=1, ['s']=1, ['t']=1, ['u']=1, ['v']=1, ['w']=1, ['x']=1,
203 ['y']=1, ['z']=1,
204 ['~']=1
206 return table[c];
209 /* C can be in the middle of a token. */
210 static bool
211 intoken (unsigned char c)
213 static bool const table[UCHAR_MAX + 1] = {
214 ['$']=1,
215 ['0']=1, ['1']=1, ['2']=1, ['3']=1, ['4']=1,
216 ['5']=1, ['6']=1, ['7']=1, ['8']=1, ['9']=1,
217 ['A']=1, ['B']=1, ['C']=1, ['D']=1, ['E']=1, ['F']=1, ['G']=1, ['H']=1,
218 ['I']=1, ['J']=1, ['K']=1, ['L']=1, ['M']=1, ['N']=1, ['O']=1, ['P']=1,
219 ['Q']=1, ['R']=1, ['S']=1, ['T']=1, ['U']=1, ['V']=1, ['W']=1, ['X']=1,
220 ['Y']=1, ['Z']=1,
221 ['_']=1,
222 ['a']=1, ['b']=1, ['c']=1, ['d']=1, ['e']=1, ['f']=1, ['g']=1, ['h']=1,
223 ['i']=1, ['j']=1, ['k']=1, ['l']=1, ['m']=1, ['n']=1, ['o']=1, ['p']=1,
224 ['q']=1, ['r']=1, ['s']=1, ['t']=1, ['u']=1, ['v']=1, ['w']=1, ['x']=1,
225 ['y']=1, ['z']=1
227 return table[c];
230 /* C can end a token. */
231 static bool
232 endtoken (unsigned char c)
234 static bool const table[UCHAR_MAX + 1] = {
235 ['\0']=1, ['\t']=1, ['\n']=1, ['\r']=1, [' ']=1,
236 ['!']=1, ['"']=1, ['#']=1, ['%']=1, ['&']=1, ['\'']=1, ['(']=1, [')']=1,
237 ['*']=1, ['+']=1, [',']=1, ['-']=1, ['.']=1, ['/']=1, [':']=1, [';']=1,
238 ['<']=1, ['=']=1, ['>']=1, ['?']=1, ['[']=1, [']']=1, ['^']=1,
239 ['{']=1, ['|']=1, ['}']=1, ['~']=1
241 return table[c];
245 * xnew, xrnew -- allocate, reallocate storage
247 * SYNOPSIS: Type *xnew (int n, Type);
248 * void xrnew (OldPointer, int n, Type);
250 #define xnew(n, Type) ((Type *) xmalloc ((n) * sizeof (Type)))
251 #define xrnew(op, n, Type) ((op) = (Type *) xrealloc (op, (n) * sizeof (Type)))
253 typedef void Lang_function (FILE *);
255 typedef struct
257 const char *suffix; /* file name suffix for this compressor */
258 const char *command; /* takes one arg and decompresses to stdout */
259 } compressor;
261 typedef struct
263 const char *name; /* language name */
264 const char *help; /* detailed help for the language */
265 Lang_function *function; /* parse function */
266 const char **suffixes; /* name suffixes of this language's files */
267 const char **filenames; /* names of this language's files */
268 const char **interpreters; /* interpreters for this language */
269 bool metasource; /* source used to generate other sources */
270 } language;
272 typedef struct fdesc
274 struct fdesc *next; /* for the linked list */
275 char *infname; /* uncompressed input file name */
276 char *infabsname; /* absolute uncompressed input file name */
277 char *infabsdir; /* absolute dir of input file */
278 char *taggedfname; /* file name to write in tagfile */
279 language *lang; /* language of file */
280 char *prop; /* file properties to write in tagfile */
281 bool usecharno; /* etags tags shall contain char number */
282 bool written; /* entry written in the tags file */
283 } fdesc;
285 typedef struct node_st
286 { /* sorting structure */
287 struct node_st *left, *right; /* left and right sons */
288 fdesc *fdp; /* description of file to whom tag belongs */
289 char *name; /* tag name */
290 char *regex; /* search regexp */
291 bool valid; /* write this tag on the tag file */
292 bool is_func; /* function tag: use regexp in CTAGS mode */
293 bool been_warned; /* warning already given for duplicated tag */
294 int lno; /* line number tag is on */
295 long cno; /* character number line starts on */
296 } node;
299 * A `linebuffer' is a structure which holds a line of text.
300 * `readline_internal' reads a line from a stream into a linebuffer
301 * and works regardless of the length of the line.
302 * SIZE is the size of BUFFER, LEN is the length of the string in
303 * BUFFER after readline reads it.
305 typedef struct
307 long size;
308 int len;
309 char *buffer;
310 } linebuffer;
312 /* Used to support mixing of --lang and file names. */
313 typedef struct
315 enum {
316 at_language, /* a language specification */
317 at_regexp, /* a regular expression */
318 at_filename, /* a file name */
319 at_stdin, /* read from stdin here */
320 at_end /* stop parsing the list */
321 } arg_type; /* argument type */
322 language *lang; /* language associated with the argument */
323 char *what; /* the argument itself */
324 } argument;
326 /* Structure defining a regular expression. */
327 typedef struct regexp
329 struct regexp *p_next; /* pointer to next in list */
330 language *lang; /* if set, use only for this language */
331 char *pattern; /* the regexp pattern */
332 char *name; /* tag name */
333 struct re_pattern_buffer *pat; /* the compiled pattern */
334 struct re_registers regs; /* re registers */
335 bool error_signaled; /* already signaled for this regexp */
336 bool force_explicit_name; /* do not allow implicit tag name */
337 bool ignore_case; /* ignore case when matching */
338 bool multi_line; /* do a multi-line match on the whole file */
339 } regexp;
342 /* Many compilers barf on this:
343 Lang_function Ada_funcs;
344 so let's write it this way */
345 static void Ada_funcs (FILE *);
346 static void Asm_labels (FILE *);
347 static void C_entries (int c_ext, FILE *);
348 static void default_C_entries (FILE *);
349 static void plain_C_entries (FILE *);
350 static void Cjava_entries (FILE *);
351 static void Cobol_paragraphs (FILE *);
352 static void Cplusplus_entries (FILE *);
353 static void Cstar_entries (FILE *);
354 static void Erlang_functions (FILE *);
355 static void Forth_words (FILE *);
356 static void Fortran_functions (FILE *);
357 static void Go_functions (FILE *);
358 static void HTML_labels (FILE *);
359 static void Lisp_functions (FILE *);
360 static void Lua_functions (FILE *);
361 static void Makefile_targets (FILE *);
362 static void Pascal_functions (FILE *);
363 static void Perl_functions (FILE *);
364 static void PHP_functions (FILE *);
365 static void PS_functions (FILE *);
366 static void Prolog_functions (FILE *);
367 static void Python_functions (FILE *);
368 static void Ruby_functions (FILE *);
369 static void Scheme_functions (FILE *);
370 static void TeX_commands (FILE *);
371 static void Texinfo_nodes (FILE *);
372 static void Yacc_entries (FILE *);
373 static void just_read_file (FILE *);
375 static language *get_language_from_langname (const char *);
376 static void readline (linebuffer *, FILE *);
377 static long readline_internal (linebuffer *, FILE *, char const *);
378 static bool nocase_tail (const char *);
379 static void get_tag (char *, char **);
381 static void analyze_regex (char *);
382 static void free_regexps (void);
383 static void regex_tag_multiline (void);
384 static void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
385 static void verror (char const *, va_list) ATTRIBUTE_FORMAT_PRINTF (1, 0);
386 static _Noreturn void suggest_asking_for_help (void);
387 static _Noreturn void fatal (char const *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
388 static _Noreturn void pfatal (const char *);
389 static void add_node (node *, node **);
391 static void process_file_name (char *, language *);
392 static void process_file (FILE *, char *, language *);
393 static void find_entries (FILE *);
394 static void free_tree (node *);
395 static void free_fdesc (fdesc *);
396 static void pfnote (char *, bool, char *, int, int, long);
397 static void invalidate_nodes (fdesc *, node **);
398 static void put_entries (node *);
400 static char *concat (const char *, const char *, const char *);
401 static char *skip_spaces (char *);
402 static char *skip_non_spaces (char *);
403 static char *skip_name (char *);
404 static char *savenstr (const char *, int);
405 static char *savestr (const char *);
406 static char *etags_getcwd (void);
407 static char *relative_filename (char *, char *);
408 static char *absolute_filename (char *, char *);
409 static char *absolute_dirname (char *, char *);
410 static bool filename_is_absolute (char *f);
411 static void canonicalize_filename (char *);
412 static char *etags_mktmp (void);
413 static void linebuffer_init (linebuffer *);
414 static void linebuffer_setlen (linebuffer *, int);
415 static void *xmalloc (size_t);
416 static void *xrealloc (void *, size_t);
419 static char searchar = '/'; /* use /.../ searches */
421 static char *tagfile; /* output file */
422 static char *progname; /* name this program was invoked with */
423 static char *cwd; /* current working directory */
424 static char *tagfiledir; /* directory of tagfile */
425 static FILE *tagf; /* ioptr for tags file */
426 static ptrdiff_t whatlen_max; /* maximum length of any 'what' member */
428 static fdesc *fdhead; /* head of file description list */
429 static fdesc *curfdp; /* current file description */
430 static char *infilename; /* current input file name */
431 static int lineno; /* line number of current line */
432 static long charno; /* current character number */
433 static long linecharno; /* charno of start of current line */
434 static char *dbp; /* pointer to start of current tag */
436 static const int invalidcharno = -1;
438 static node *nodehead; /* the head of the binary tree of tags */
439 static node *last_node; /* the last node created */
441 static linebuffer lb; /* the current line */
442 static linebuffer filebuf; /* a buffer containing the whole file */
443 static linebuffer token_name; /* a buffer containing a tag name */
445 static bool append_to_tagfile; /* -a: append to tags */
446 /* The next five default to true in C and derived languages. */
447 static bool typedefs; /* -t: create tags for C and Ada typedefs */
448 static bool typedefs_or_cplusplus; /* -T: create tags for C typedefs, level */
449 /* 0 struct/enum/union decls, and C++ */
450 /* member functions. */
451 static bool constantypedefs; /* -d: create tags for C #define, enum */
452 /* constants and variables. */
453 /* -D: opposite of -d. Default under ctags. */
454 static int globals; /* create tags for global variables */
455 static int members; /* create tags for C member variables */
456 static int declarations; /* --declarations: tag them and extern in C&Co*/
457 static int no_line_directive; /* ignore #line directives (undocumented) */
458 static int no_duplicates; /* no duplicate tags for ctags (undocumented) */
459 static bool update; /* -u: update tags */
460 static bool vgrind_style; /* -v: create vgrind style index output */
461 static bool no_warnings; /* -w: suppress warnings (undocumented) */
462 static bool cxref_style; /* -x: create cxref style output */
463 static bool cplusplus; /* .[hc] means C++, not C (undocumented) */
464 static bool ignoreindent; /* -I: ignore indentation in C */
465 static int packages_only; /* --packages-only: in Ada, only tag packages*/
466 static int class_qualify; /* -Q: produce class-qualified tags in C++/Java */
468 /* STDIN is defined in LynxOS system headers */
469 #ifdef STDIN
470 # undef STDIN
471 #endif
473 #define STDIN 0x1001 /* returned by getopt_long on --parse-stdin */
474 static bool parsing_stdin; /* --parse-stdin used */
476 static regexp *p_head; /* list of all regexps */
477 static bool need_filebuf; /* some regexes are multi-line */
479 static struct option longopts[] =
481 { "append", no_argument, NULL, 'a' },
482 { "packages-only", no_argument, &packages_only, 1 },
483 { "c++", no_argument, NULL, 'C' },
484 { "declarations", no_argument, &declarations, 1 },
485 { "no-line-directive", no_argument, &no_line_directive, 1 },
486 { "no-duplicates", no_argument, &no_duplicates, 1 },
487 { "help", no_argument, NULL, 'h' },
488 { "help", no_argument, NULL, 'H' },
489 { "ignore-indentation", no_argument, NULL, 'I' },
490 { "language", required_argument, NULL, 'l' },
491 { "members", no_argument, &members, 1 },
492 { "no-members", no_argument, &members, 0 },
493 { "output", required_argument, NULL, 'o' },
494 { "class-qualify", no_argument, &class_qualify, 'Q' },
495 { "regex", required_argument, NULL, 'r' },
496 { "no-regex", no_argument, NULL, 'R' },
497 { "ignore-case-regex", required_argument, NULL, 'c' },
498 { "parse-stdin", required_argument, NULL, STDIN },
499 { "version", no_argument, NULL, 'V' },
501 #if CTAGS /* Ctags options */
502 { "backward-search", no_argument, NULL, 'B' },
503 { "cxref", no_argument, NULL, 'x' },
504 { "defines", no_argument, NULL, 'd' },
505 { "globals", no_argument, &globals, 1 },
506 { "typedefs", no_argument, NULL, 't' },
507 { "typedefs-and-c++", no_argument, NULL, 'T' },
508 { "update", no_argument, NULL, 'u' },
509 { "vgrind", no_argument, NULL, 'v' },
510 { "no-warn", no_argument, NULL, 'w' },
512 #else /* Etags options */
513 { "no-defines", no_argument, NULL, 'D' },
514 { "no-globals", no_argument, &globals, 0 },
515 { "include", required_argument, NULL, 'i' },
516 #endif
517 { NULL }
520 static compressor compressors[] =
522 { "z", "gzip -d -c"},
523 { "Z", "gzip -d -c"},
524 { "gz", "gzip -d -c"},
525 { "GZ", "gzip -d -c"},
526 { "bz2", "bzip2 -d -c" },
527 { "xz", "xz -d -c" },
528 { NULL }
532 * Language stuff.
535 /* Ada code */
536 static const char *Ada_suffixes [] =
537 { "ads", "adb", "ada", NULL };
538 static const char Ada_help [] =
539 "In Ada code, functions, procedures, packages, tasks and types are\n\
540 tags. Use the '--packages-only' option to create tags for\n\
541 packages only.\n\
542 Ada tag names have suffixes indicating the type of entity:\n\
543 Entity type: Qualifier:\n\
544 ------------ ----------\n\
545 function /f\n\
546 procedure /p\n\
547 package spec /s\n\
548 package body /b\n\
549 type /t\n\
550 task /k\n\
551 Thus, 'M-x find-tag <RET> bidule/b <RET>' will go directly to the\n\
552 body of the package 'bidule', while 'M-x find-tag <RET> bidule <RET>'\n\
553 will just search for any tag 'bidule'.";
555 /* Assembly code */
556 static const char *Asm_suffixes [] =
557 { "a", /* Unix assembler */
558 "asm", /* Microcontroller assembly */
559 "def", /* BSO/Tasking definition includes */
560 "inc", /* Microcontroller include files */
561 "ins", /* Microcontroller include files */
562 "s", "sa", /* Unix assembler */
563 "S", /* cpp-processed Unix assembler */
564 "src", /* BSO/Tasking C compiler output */
565 NULL
567 static const char Asm_help [] =
568 "In assembler code, labels appearing at the beginning of a line,\n\
569 followed by a colon, are tags.";
572 /* Note that .c and .h can be considered C++, if the --c++ flag was
573 given, or if the `class' or `template' keywords are met inside the file.
574 That is why default_C_entries is called for these. */
575 static const char *default_C_suffixes [] =
576 { "c", "h", NULL };
577 #if CTAGS /* C help for Ctags */
578 static const char default_C_help [] =
579 "In C code, any C function is a tag. Use -t to tag typedefs.\n\
580 Use -T to tag definitions of 'struct', 'union' and 'enum'.\n\
581 Use -d to tag '#define' macro definitions and 'enum' constants.\n\
582 Use --globals to tag global variables.\n\
583 You can tag function declarations and external variables by\n\
584 using '--declarations', and struct members by using '--members'.";
585 #else /* C help for Etags */
586 static const char default_C_help [] =
587 "In C code, any C function or typedef is a tag, and so are\n\
588 definitions of 'struct', 'union' and 'enum'. '#define' macro\n\
589 definitions and 'enum' constants are tags unless you specify\n\
590 '--no-defines'. Global variables are tags unless you specify\n\
591 '--no-globals' and so are struct members unless you specify\n\
592 '--no-members'. Use of '--no-globals', '--no-defines' and\n\
593 '--no-members' can make the tags table file much smaller.\n\
594 You can tag function declarations and external variables by\n\
595 using '--declarations'.";
596 #endif /* C help for Ctags and Etags */
598 static const char *Cplusplus_suffixes [] =
599 { "C", "c++", "cc", "cpp", "cxx", "H", "h++", "hh", "hpp", "hxx",
600 "M", /* Objective C++ */
601 "pdb", /* PostScript with C syntax */
602 NULL };
603 static const char Cplusplus_help [] =
604 "In C++ code, all the tag constructs of C code are tagged. (Use\n\
605 --help --lang=c --lang=c++ for full help.)\n\
606 In addition to C tags, member functions are also recognized. Member\n\
607 variables are recognized unless you use the '--no-members' option.\n\
608 Tags for variables and functions in classes are named 'CLASS::VARIABLE'\n\
609 and 'CLASS::FUNCTION'. 'operator' definitions have tag names like\n\
610 'operator+'.";
612 static const char *Cjava_suffixes [] =
613 { "java", NULL };
614 static char Cjava_help [] =
615 "In Java code, all the tags constructs of C and C++ code are\n\
616 tagged. (Use --help --lang=c --lang=c++ --lang=java for full help.)";
619 static const char *Cobol_suffixes [] =
620 { "COB", "cob", NULL };
621 static char Cobol_help [] =
622 "In Cobol code, tags are paragraph names; that is, any word\n\
623 starting in column 8 and followed by a period.";
625 static const char *Cstar_suffixes [] =
626 { "cs", "hs", NULL };
628 static const char *Erlang_suffixes [] =
629 { "erl", "hrl", NULL };
630 static const char Erlang_help [] =
631 "In Erlang code, the tags are the functions, records and macros\n\
632 defined in the file.";
634 const char *Forth_suffixes [] =
635 { "fth", "tok", NULL };
636 static const char Forth_help [] =
637 "In Forth code, tags are words defined by ':',\n\
638 constant, code, create, defer, value, variable, buffer:, field.";
640 static const char *Fortran_suffixes [] =
641 { "F", "f", "f90", "for", NULL };
642 static const char Fortran_help [] =
643 "In Fortran code, functions, subroutines and block data are tags.";
645 static const char *Go_suffixes [] = {"go", NULL};
646 static const char Go_help [] =
647 "In Go code, functions, interfaces and packages are tags.";
649 static const char *HTML_suffixes [] =
650 { "htm", "html", "shtml", NULL };
651 static const char HTML_help [] =
652 "In HTML input files, the tags are the 'title' and the 'h1', 'h2',\n\
653 'h3' headers. Also, tags are 'name=' in anchors and all\n\
654 occurrences of 'id='.";
656 static const char *Lisp_suffixes [] =
657 { "cl", "clisp", "el", "l", "lisp", "LSP", "lsp", "ml", NULL };
658 static const char Lisp_help [] =
659 "In Lisp code, any function defined with 'defun', any variable\n\
660 defined with 'defvar' or 'defconst', and in general the first\n\
661 argument of any expression that starts with '(def' in column zero\n\
662 is a tag.\n\
663 The '--declarations' option tags \"(defvar foo)\" constructs too.";
665 static const char *Lua_suffixes [] =
666 { "lua", "LUA", NULL };
667 static const char Lua_help [] =
668 "In Lua scripts, all functions are tags.";
670 static const char *Makefile_filenames [] =
671 { "Makefile", "makefile", "GNUMakefile", "Makefile.in", "Makefile.am", NULL};
672 static const char Makefile_help [] =
673 "In makefiles, targets are tags; additionally, variables are tags\n\
674 unless you specify '--no-globals'.";
676 static const char *Objc_suffixes [] =
677 { "lm", /* Objective lex file */
678 "m", /* Objective C file */
679 NULL };
680 static const char Objc_help [] =
681 "In Objective C code, tags include Objective C definitions for classes,\n\
682 class categories, methods and protocols. Tags for variables and\n\
683 functions in classes are named 'CLASS::VARIABLE' and 'CLASS::FUNCTION'.\
684 \n(Use --help --lang=c --lang=objc --lang=java for full help.)";
686 static const char *Pascal_suffixes [] =
687 { "p", "pas", NULL };
688 static const char Pascal_help [] =
689 "In Pascal code, the tags are the functions and procedures defined\n\
690 in the file.";
691 /* " // this is for working around an Emacs highlighting bug... */
693 static const char *Perl_suffixes [] =
694 { "pl", "pm", NULL };
695 static const char *Perl_interpreters [] =
696 { "perl", "@PERL@", NULL };
697 static const char Perl_help [] =
698 "In Perl code, the tags are the packages, subroutines and variables\n\
699 defined by the 'package', 'sub', 'my' and 'local' keywords. Use\n\
700 '--globals' if you want to tag global variables. Tags for\n\
701 subroutines are named 'PACKAGE::SUB'. The name for subroutines\n\
702 defined in the default package is 'main::SUB'.";
704 static const char *PHP_suffixes [] =
705 { "php", "php3", "php4", NULL };
706 static const char PHP_help [] =
707 "In PHP code, tags are functions, classes and defines. Unless you use\n\
708 the '--no-members' option, vars are tags too.";
710 static const char *plain_C_suffixes [] =
711 { "pc", /* Pro*C file */
712 NULL };
714 static const char *PS_suffixes [] =
715 { "ps", "psw", NULL }; /* .psw is for PSWrap */
716 static const char PS_help [] =
717 "In PostScript code, the tags are the functions.";
719 static const char *Prolog_suffixes [] =
720 { "prolog", NULL };
721 static const char Prolog_help [] =
722 "In Prolog code, tags are predicates and rules at the beginning of\n\
723 line.";
725 static const char *Python_suffixes [] =
726 { "py", NULL };
727 static const char Python_help [] =
728 "In Python code, 'def' or 'class' at the beginning of a line\n\
729 generate a tag.";
731 static const char *Ruby_suffixes [] =
732 { "rb", "ru", "rbw", NULL };
733 static const char *Ruby_filenames [] =
734 { "Rakefile", "Thorfile", NULL };
735 static const char Ruby_help [] =
736 "In Ruby code, 'def' or 'class' or 'module' at the beginning of\n\
737 a line generate a tag. Constants also generate a tag.";
739 /* Can't do the `SCM' or `scm' prefix with a version number. */
740 static const char *Scheme_suffixes [] =
741 { "oak", "sch", "scheme", "SCM", "scm", "SM", "sm", "ss", "t", NULL };
742 static const char Scheme_help [] =
743 "In Scheme code, tags include anything defined with 'def' or with a\n\
744 construct whose name starts with 'def'. They also include\n\
745 variables set with 'set!' at top level in the file.";
747 static const char *TeX_suffixes [] =
748 { "bib", "clo", "cls", "ltx", "sty", "TeX", "tex", NULL };
749 static const char TeX_help [] =
750 "In LaTeX text, the argument of any of the commands '\\chapter',\n\
751 '\\section', '\\subsection', '\\subsubsection', '\\eqno', '\\label',\n\
752 '\\ref', '\\cite', '\\bibitem', '\\part', '\\appendix', '\\entry',\n\
753 '\\index', '\\def', '\\newcommand', '\\renewcommand',\n\
754 '\\newenvironment' or '\\renewenvironment' is a tag.\n\
756 Other commands can be specified by setting the environment variable\n\
757 'TEXTAGS' to a colon-separated list like, for example,\n\
758 TEXTAGS=\"mycommand:myothercommand\".";
761 static const char *Texinfo_suffixes [] =
762 { "texi", "texinfo", "txi", NULL };
763 static const char Texinfo_help [] =
764 "for texinfo files, lines starting with @node are tagged.";
766 static const char *Yacc_suffixes [] =
767 { "y", "y++", "ym", "yxx", "yy", NULL }; /* .ym is Objective yacc file */
768 static const char Yacc_help [] =
769 "In Bison or Yacc input files, each rule defines as a tag the\n\
770 nonterminal it constructs. The portions of the file that contain\n\
771 C code are parsed as C code (use --help --lang=c --lang=yacc\n\
772 for full help).";
774 static const char auto_help [] =
775 "'auto' is not a real language, it indicates to use\n\
776 a default language for files base on file name suffix and file contents.";
778 static const char none_help [] =
779 "'none' is not a real language, it indicates to only do\n\
780 regexp processing on files.";
782 static const char no_lang_help [] =
783 "No detailed help available for this language.";
787 * Table of languages.
789 * It is ok for a given function to be listed under more than one
790 * name. I just didn't.
793 static language lang_names [] =
795 { "ada", Ada_help, Ada_funcs, Ada_suffixes },
796 { "asm", Asm_help, Asm_labels, Asm_suffixes },
797 { "c", default_C_help, default_C_entries, default_C_suffixes },
798 { "c++", Cplusplus_help, Cplusplus_entries, Cplusplus_suffixes },
799 { "c*", no_lang_help, Cstar_entries, Cstar_suffixes },
800 { "cobol", Cobol_help, Cobol_paragraphs, Cobol_suffixes },
801 { "erlang", Erlang_help, Erlang_functions, Erlang_suffixes },
802 { "forth", Forth_help, Forth_words, Forth_suffixes },
803 { "fortran", Fortran_help, Fortran_functions, Fortran_suffixes },
804 { "go", Go_help, Go_functions, Go_suffixes },
805 { "html", HTML_help, HTML_labels, HTML_suffixes },
806 { "java", Cjava_help, Cjava_entries, Cjava_suffixes },
807 { "lisp", Lisp_help, Lisp_functions, Lisp_suffixes },
808 { "lua", Lua_help, Lua_functions, Lua_suffixes },
809 { "makefile", Makefile_help,Makefile_targets,NULL,Makefile_filenames},
810 { "objc", Objc_help, plain_C_entries, Objc_suffixes },
811 { "pascal", Pascal_help, Pascal_functions, Pascal_suffixes },
812 { "perl",Perl_help,Perl_functions,Perl_suffixes,NULL,Perl_interpreters},
813 { "php", PHP_help, PHP_functions, PHP_suffixes },
814 { "postscript",PS_help, PS_functions, PS_suffixes },
815 { "proc", no_lang_help, plain_C_entries, plain_C_suffixes },
816 { "prolog", Prolog_help, Prolog_functions, Prolog_suffixes },
817 { "python", Python_help, Python_functions, Python_suffixes },
818 { "ruby", Ruby_help,Ruby_functions,Ruby_suffixes,Ruby_filenames },
819 { "scheme", Scheme_help, Scheme_functions, Scheme_suffixes },
820 { "tex", TeX_help, TeX_commands, TeX_suffixes },
821 { "texinfo", Texinfo_help, Texinfo_nodes, Texinfo_suffixes },
822 { "yacc", Yacc_help,Yacc_entries,Yacc_suffixes,NULL,NULL,true},
823 { "auto", auto_help }, /* default guessing scheme */
824 { "none", none_help, just_read_file }, /* regexp matching only */
825 { NULL } /* end of list */
829 static void
830 print_language_names (void)
832 language *lang;
833 const char **name, **ext;
835 puts ("\nThese are the currently supported languages, along with the\n\
836 default file names and dot suffixes:");
837 for (lang = lang_names; lang->name != NULL; lang++)
839 printf (" %-*s", 10, lang->name);
840 if (lang->filenames != NULL)
841 for (name = lang->filenames; *name != NULL; name++)
842 printf (" %s", *name);
843 if (lang->suffixes != NULL)
844 for (ext = lang->suffixes; *ext != NULL; ext++)
845 printf (" .%s", *ext);
846 puts ("");
848 puts ("where 'auto' means use default language for files based on file\n\
849 name suffix, and 'none' means only do regexp processing on files.\n\
850 If no language is specified and no matching suffix is found,\n\
851 the first line of the file is read for a sharp-bang (#!) sequence\n\
852 followed by the name of an interpreter. If no such sequence is found,\n\
853 Fortran is tried first; if no tags are found, C is tried next.\n\
854 When parsing any C file, a \"class\" or \"template\" keyword\n\
855 switches to C++.");
856 puts ("Compressed files are supported using gzip, bzip2, and xz.\n\
858 For detailed help on a given language use, for example,\n\
859 etags --help --lang=ada.");
862 #ifndef EMACS_NAME
863 # define EMACS_NAME "standalone"
864 #endif
865 #ifndef VERSION
866 # define VERSION "17.38.1.4"
867 #endif
868 static _Noreturn void
869 print_version (void)
871 char emacs_copyright[] = COPYRIGHT;
873 printf ("%s (%s %s)\n", (CTAGS) ? "ctags" : "etags", EMACS_NAME, VERSION);
874 puts (emacs_copyright);
875 puts ("This program is distributed under the terms in ETAGS.README");
877 exit (EXIT_SUCCESS);
880 #ifndef PRINT_UNDOCUMENTED_OPTIONS_HELP
881 # define PRINT_UNDOCUMENTED_OPTIONS_HELP false
882 #endif
884 static _Noreturn void
885 print_help (argument *argbuffer)
887 bool help_for_lang = false;
889 for (; argbuffer->arg_type != at_end; argbuffer++)
890 if (argbuffer->arg_type == at_language)
892 if (help_for_lang)
893 puts ("");
894 puts (argbuffer->lang->help);
895 help_for_lang = true;
898 if (help_for_lang)
899 exit (EXIT_SUCCESS);
901 printf ("Usage: %s [options] [[regex-option ...] file-name] ...\n\
903 These are the options accepted by %s.\n", progname, progname);
904 puts ("You may use unambiguous abbreviations for the long option names.");
905 puts (" A - as file name means read names from stdin (one per line).\n\
906 Absolute names are stored in the output file as they are.\n\
907 Relative ones are stored relative to the output file's directory.\n");
909 puts ("-a, --append\n\
910 Append tag entries to existing tags file.");
912 puts ("--packages-only\n\
913 For Ada files, only generate tags for packages.");
915 if (CTAGS)
916 puts ("-B, --backward-search\n\
917 Write the search commands for the tag entries using '?', the\n\
918 backward-search command instead of '/', the forward-search command.");
920 /* This option is mostly obsolete, because etags can now automatically
921 detect C++. Retained for backward compatibility and for debugging and
922 experimentation. In principle, we could want to tag as C++ even
923 before any "class" or "template" keyword.
924 puts ("-C, --c++\n\
925 Treat files whose name suffix defaults to C language as C++ files.");
928 puts ("--declarations\n\
929 In C and derived languages, create tags for function declarations,");
930 if (CTAGS)
931 puts ("\tand create tags for extern variables if --globals is used.");
932 else
933 puts
934 ("\tand create tags for extern variables unless --no-globals is used.");
936 if (CTAGS)
937 puts ("-d, --defines\n\
938 Create tag entries for C #define constants and enum constants, too.");
939 else
940 puts ("-D, --no-defines\n\
941 Don't create tag entries for C #define constants and enum constants.\n\
942 This makes the tags file smaller.");
944 if (!CTAGS)
945 puts ("-i FILE, --include=FILE\n\
946 Include a note in tag file indicating that, when searching for\n\
947 a tag, one should also consult the tags file FILE after\n\
948 checking the current file.");
950 puts ("-l LANG, --language=LANG\n\
951 Force the following files to be considered as written in the\n\
952 named language up to the next --language=LANG option.");
954 if (CTAGS)
955 puts ("--globals\n\
956 Create tag entries for global variables in some languages.");
957 else
958 puts ("--no-globals\n\
959 Do not create tag entries for global variables in some\n\
960 languages. This makes the tags file smaller.");
962 puts ("--no-line-directive\n\
963 Ignore #line preprocessor directives in C and derived languages.");
965 if (CTAGS)
966 puts ("--members\n\
967 Create tag entries for members of structures in some languages.");
968 else
969 puts ("--no-members\n\
970 Do not create tag entries for members of structures\n\
971 in some languages.");
973 puts ("-Q, --class-qualify\n\
974 Qualify tag names with their class name in C++, ObjC, Java, and Perl.\n\
975 This produces tag names of the form \"class::member\" for C++,\n\
976 \"class(category)\" for Objective C, and \"class.member\" for Java.\n\
977 For Objective C, this also produces class methods qualified with\n\
978 their arguments, as in \"foo:bar:baz:more\".\n\
979 For Perl, this produces \"package::member\".");
980 puts ("-r REGEXP, --regex=REGEXP or --regex=@regexfile\n\
981 Make a tag for each line matching a regular expression pattern\n\
982 in the following files. {LANGUAGE}REGEXP uses REGEXP for LANGUAGE\n\
983 files only. REGEXFILE is a file containing one REGEXP per line.\n\
984 REGEXP takes the form /TAGREGEXP/TAGNAME/MODS, where TAGNAME/ is\n\
985 optional. The TAGREGEXP pattern is anchored (as if preceded by ^).");
986 puts (" If TAGNAME/ is present, the tags created are named.\n\
987 For example Tcl named tags can be created with:\n\
988 --regex=\"/proc[ \\t]+\\([^ \\t]+\\)/\\1/.\".\n\
989 MODS are optional one-letter modifiers: 'i' means to ignore case,\n\
990 'm' means to allow multi-line matches, 's' implies 'm' and\n\
991 causes dot to match any character, including newline.");
993 puts ("-R, --no-regex\n\
994 Don't create tags from regexps for the following files.");
996 puts ("-I, --ignore-indentation\n\
997 In C and C++ do not assume that a closing brace in the first\n\
998 column is the final brace of a function or structure definition.");
1000 puts ("-o FILE, --output=FILE\n\
1001 Write the tags to FILE.");
1003 puts ("--parse-stdin=NAME\n\
1004 Read from standard input and record tags as belonging to file NAME.");
1006 if (CTAGS)
1008 puts ("-t, --typedefs\n\
1009 Generate tag entries for C and Ada typedefs.");
1010 puts ("-T, --typedefs-and-c++\n\
1011 Generate tag entries for C typedefs, C struct/enum/union tags,\n\
1012 and C++ member functions.");
1015 if (CTAGS)
1016 puts ("-u, --update\n\
1017 Update the tag entries for the given files, leaving tag\n\
1018 entries for other files in place. Currently, this is\n\
1019 implemented by deleting the existing entries for the given\n\
1020 files and then rewriting the new entries at the end of the\n\
1021 tags file. It is often faster to simply rebuild the entire\n\
1022 tag file than to use this.");
1024 if (CTAGS)
1026 puts ("-v, --vgrind\n\
1027 Print on the standard output an index of items intended for\n\
1028 human consumption, similar to the output of vgrind. The index\n\
1029 is sorted, and gives the page number of each item.");
1031 if (PRINT_UNDOCUMENTED_OPTIONS_HELP)
1032 puts ("-w, --no-duplicates\n\
1033 Do not create duplicate tag entries, for compatibility with\n\
1034 traditional ctags.");
1036 if (PRINT_UNDOCUMENTED_OPTIONS_HELP)
1037 puts ("-w, --no-warn\n\
1038 Suppress warning messages about duplicate tag entries.");
1040 puts ("-x, --cxref\n\
1041 Like --vgrind, but in the style of cxref, rather than vgrind.\n\
1042 The output uses line numbers instead of page numbers, but\n\
1043 beyond that the differences are cosmetic; try both to see\n\
1044 which you like.");
1047 puts ("-V, --version\n\
1048 Print the version of the program.\n\
1049 -h, --help\n\
1050 Print this help message.\n\
1051 Followed by one or more '--language' options prints detailed\n\
1052 help about tag generation for the specified languages.");
1054 print_language_names ();
1056 puts ("");
1057 puts ("Report bugs to bug-gnu-emacs@gnu.org");
1059 exit (EXIT_SUCCESS);
1064 main (int argc, char **argv)
1066 int i;
1067 unsigned int nincluded_files;
1068 char **included_files;
1069 argument *argbuffer;
1070 int current_arg, file_count;
1071 linebuffer filename_lb;
1072 bool help_asked = false;
1073 ptrdiff_t len;
1074 char *optstring;
1075 int opt;
1077 progname = argv[0];
1078 nincluded_files = 0;
1079 included_files = xnew (argc, char *);
1080 current_arg = 0;
1081 file_count = 0;
1083 /* Allocate enough no matter what happens. Overkill, but each one
1084 is small. */
1085 argbuffer = xnew (argc, argument);
1088 * Always find typedefs and structure tags.
1089 * Also default to find macro constants, enum constants, struct
1090 * members and global variables. Do it for both etags and ctags.
1092 typedefs = typedefs_or_cplusplus = constantypedefs = true;
1093 globals = members = true;
1095 /* When the optstring begins with a '-' getopt_long does not rearrange the
1096 non-options arguments to be at the end, but leaves them alone. */
1097 optstring = concat ("-ac:Cf:Il:o:Qr:RSVhH",
1098 (CTAGS) ? "BxdtTuvw" : "Di:",
1099 "");
1101 while ((opt = getopt_long (argc, argv, optstring, longopts, NULL)) != EOF)
1102 switch (opt)
1104 case 0:
1105 /* If getopt returns 0, then it has already processed a
1106 long-named option. We should do nothing. */
1107 break;
1109 case 1:
1110 /* This means that a file name has been seen. Record it. */
1111 argbuffer[current_arg].arg_type = at_filename;
1112 argbuffer[current_arg].what = optarg;
1113 len = strlen (optarg);
1114 if (whatlen_max < len)
1115 whatlen_max = len;
1116 ++current_arg;
1117 ++file_count;
1118 break;
1120 case STDIN:
1121 /* Parse standard input. Idea by Vivek <vivek@etla.org>. */
1122 argbuffer[current_arg].arg_type = at_stdin;
1123 argbuffer[current_arg].what = optarg;
1124 len = strlen (optarg);
1125 if (whatlen_max < len)
1126 whatlen_max = len;
1127 ++current_arg;
1128 ++file_count;
1129 if (parsing_stdin)
1130 fatal ("cannot parse standard input more than once");
1131 parsing_stdin = true;
1132 break;
1134 /* Common options. */
1135 case 'a': append_to_tagfile = true; break;
1136 case 'C': cplusplus = true; break;
1137 case 'f': /* for compatibility with old makefiles */
1138 case 'o':
1139 if (tagfile)
1141 error ("-o option may only be given once.");
1142 suggest_asking_for_help ();
1143 /* NOTREACHED */
1145 tagfile = optarg;
1146 break;
1147 case 'I':
1148 case 'S': /* for backward compatibility */
1149 ignoreindent = true;
1150 break;
1151 case 'l':
1153 language *lang = get_language_from_langname (optarg);
1154 if (lang != NULL)
1156 argbuffer[current_arg].lang = lang;
1157 argbuffer[current_arg].arg_type = at_language;
1158 ++current_arg;
1161 break;
1162 case 'c':
1163 /* Backward compatibility: support obsolete --ignore-case-regexp. */
1164 optarg = concat (optarg, "i", ""); /* memory leak here */
1165 /* FALLTHRU */
1166 case 'r':
1167 argbuffer[current_arg].arg_type = at_regexp;
1168 argbuffer[current_arg].what = optarg;
1169 len = strlen (optarg);
1170 if (whatlen_max < len)
1171 whatlen_max = len;
1172 ++current_arg;
1173 break;
1174 case 'R':
1175 argbuffer[current_arg].arg_type = at_regexp;
1176 argbuffer[current_arg].what = NULL;
1177 ++current_arg;
1178 break;
1179 case 'V':
1180 print_version ();
1181 break;
1182 case 'h':
1183 case 'H':
1184 help_asked = true;
1185 break;
1186 case 'Q':
1187 class_qualify = 1;
1188 break;
1190 /* Etags options */
1191 case 'D': constantypedefs = false; break;
1192 case 'i': included_files[nincluded_files++] = optarg; break;
1194 /* Ctags options. */
1195 case 'B': searchar = '?'; break;
1196 case 'd': constantypedefs = true; break;
1197 case 't': typedefs = true; break;
1198 case 'T': typedefs = typedefs_or_cplusplus = true; break;
1199 case 'u': update = true; break;
1200 case 'v': vgrind_style = true; /*FALLTHRU*/
1201 case 'x': cxref_style = true; break;
1202 case 'w': no_warnings = true; break;
1203 default:
1204 suggest_asking_for_help ();
1205 /* NOTREACHED */
1208 /* No more options. Store the rest of arguments. */
1209 for (; optind < argc; optind++)
1211 argbuffer[current_arg].arg_type = at_filename;
1212 argbuffer[current_arg].what = argv[optind];
1213 len = strlen (argv[optind]);
1214 if (whatlen_max < len)
1215 whatlen_max = len;
1216 ++current_arg;
1217 ++file_count;
1220 argbuffer[current_arg].arg_type = at_end;
1222 if (help_asked)
1223 print_help (argbuffer);
1224 /* NOTREACHED */
1226 if (nincluded_files == 0 && file_count == 0)
1228 error ("no input files specified.");
1229 suggest_asking_for_help ();
1230 /* NOTREACHED */
1233 if (tagfile == NULL)
1234 tagfile = savestr (CTAGS ? "tags" : "TAGS");
1235 cwd = etags_getcwd (); /* the current working directory */
1236 if (cwd[strlen (cwd) - 1] != '/')
1238 char *oldcwd = cwd;
1239 cwd = concat (oldcwd, "/", "");
1240 free (oldcwd);
1243 /* Compute base directory for relative file names. */
1244 if (streq (tagfile, "-")
1245 || strneq (tagfile, "/dev/", 5))
1246 tagfiledir = cwd; /* relative file names are relative to cwd */
1247 else
1249 canonicalize_filename (tagfile);
1250 tagfiledir = absolute_dirname (tagfile, cwd);
1253 linebuffer_init (&lb);
1254 linebuffer_init (&filename_lb);
1255 linebuffer_init (&filebuf);
1256 linebuffer_init (&token_name);
1258 if (!CTAGS)
1260 if (streq (tagfile, "-"))
1262 tagf = stdout;
1263 SET_BINARY (fileno (stdout));
1265 else
1266 tagf = fopen (tagfile, append_to_tagfile ? "ab" : "wb");
1267 if (tagf == NULL)
1268 pfatal (tagfile);
1272 * Loop through files finding functions.
1274 for (i = 0; i < current_arg; i++)
1276 static language *lang; /* non-NULL if language is forced */
1277 char *this_file;
1279 switch (argbuffer[i].arg_type)
1281 case at_language:
1282 lang = argbuffer[i].lang;
1283 break;
1284 case at_regexp:
1285 analyze_regex (argbuffer[i].what);
1286 break;
1287 case at_filename:
1288 this_file = argbuffer[i].what;
1289 /* Input file named "-" means read file names from stdin
1290 (one per line) and use them. */
1291 if (streq (this_file, "-"))
1293 if (parsing_stdin)
1294 fatal ("cannot parse standard input "
1295 "AND read file names from it");
1296 while (readline_internal (&filename_lb, stdin, "-") > 0)
1297 process_file_name (filename_lb.buffer, lang);
1299 else
1300 process_file_name (this_file, lang);
1301 break;
1302 case at_stdin:
1303 this_file = argbuffer[i].what;
1304 process_file (stdin, this_file, lang);
1305 break;
1306 default:
1307 error ("internal error: arg_type");
1311 free_regexps ();
1312 free (lb.buffer);
1313 free (filebuf.buffer);
1314 free (token_name.buffer);
1316 if (!CTAGS || cxref_style)
1318 /* Write the remaining tags to tagf (ETAGS) or stdout (CXREF). */
1319 put_entries (nodehead);
1320 free_tree (nodehead);
1321 nodehead = NULL;
1322 if (!CTAGS)
1324 fdesc *fdp;
1326 /* Output file entries that have no tags. */
1327 for (fdp = fdhead; fdp != NULL; fdp = fdp->next)
1328 if (!fdp->written)
1329 fprintf (tagf, "\f\n%s,0\n", fdp->taggedfname);
1331 while (nincluded_files-- > 0)
1332 fprintf (tagf, "\f\n%s,include\n", *included_files++);
1334 if (fclose (tagf) == EOF)
1335 pfatal (tagfile);
1338 exit (EXIT_SUCCESS);
1341 /* From here on, we are in (CTAGS && !cxref_style) */
1342 if (update)
1344 char *cmd =
1345 xmalloc (strlen (tagfile) + whatlen_max +
1346 sizeof "mv..OTAGS;fgrep -v '\t\t' OTAGS >;rm OTAGS");
1347 for (i = 0; i < current_arg; ++i)
1349 switch (argbuffer[i].arg_type)
1351 case at_filename:
1352 case at_stdin:
1353 break;
1354 default:
1355 continue; /* the for loop */
1357 char *z = stpcpy (cmd, "mv ");
1358 z = stpcpy (z, tagfile);
1359 z = stpcpy (z, " OTAGS;fgrep -v '\t");
1360 z = stpcpy (z, argbuffer[i].what);
1361 z = stpcpy (z, "\t' OTAGS >");
1362 z = stpcpy (z, tagfile);
1363 strcpy (z, ";rm OTAGS");
1364 if (system (cmd) != EXIT_SUCCESS)
1365 fatal ("failed to execute shell command");
1367 free (cmd);
1368 append_to_tagfile = true;
1371 tagf = fopen (tagfile, append_to_tagfile ? "ab" : "wb");
1372 if (tagf == NULL)
1373 pfatal (tagfile);
1374 put_entries (nodehead); /* write all the tags (CTAGS) */
1375 free_tree (nodehead);
1376 nodehead = NULL;
1377 if (fclose (tagf) == EOF)
1378 pfatal (tagfile);
1380 if (CTAGS)
1381 if (append_to_tagfile || update)
1383 char *cmd = xmalloc (2 * strlen (tagfile) + sizeof "sort -u -o..");
1384 /* Maybe these should be used:
1385 setenv ("LC_COLLATE", "C", 1);
1386 setenv ("LC_ALL", "C", 1); */
1387 char *z = stpcpy (cmd, "sort -u -o ");
1388 z = stpcpy (z, tagfile);
1389 *z++ = ' ';
1390 strcpy (z, tagfile);
1391 exit (system (cmd));
1393 return EXIT_SUCCESS;
1398 * Return a compressor given the file name. If EXTPTR is non-zero,
1399 * return a pointer into FILE where the compressor-specific
1400 * extension begins. If no compressor is found, NULL is returned
1401 * and EXTPTR is not significant.
1402 * Idea by Vladimir Alexiev <vladimir@cs.ualberta.ca> (1998)
1404 static compressor *
1405 get_compressor_from_suffix (char *file, char **extptr)
1407 compressor *compr;
1408 char *slash, *suffix;
1410 /* File has been processed by canonicalize_filename,
1411 so we don't need to consider backslashes on DOS_NT. */
1412 slash = strrchr (file, '/');
1413 suffix = strrchr (file, '.');
1414 if (suffix == NULL || suffix < slash)
1415 return NULL;
1416 if (extptr != NULL)
1417 *extptr = suffix;
1418 suffix += 1;
1419 /* Let those poor souls who live with DOS 8+3 file name limits get
1420 some solace by treating foo.cgz as if it were foo.c.gz, etc.
1421 Only the first do loop is run if not MSDOS */
1424 for (compr = compressors; compr->suffix != NULL; compr++)
1425 if (streq (compr->suffix, suffix))
1426 return compr;
1427 if (!MSDOS)
1428 break; /* do it only once: not really a loop */
1429 if (extptr != NULL)
1430 *extptr = ++suffix;
1431 } while (*suffix != '\0');
1432 return NULL;
1438 * Return a language given the name.
1440 static language *
1441 get_language_from_langname (const char *name)
1443 language *lang;
1445 if (name == NULL)
1446 error ("empty language name");
1447 else
1449 for (lang = lang_names; lang->name != NULL; lang++)
1450 if (streq (name, lang->name))
1451 return lang;
1452 error ("unknown language \"%s\"", name);
1455 return NULL;
1460 * Return a language given the interpreter name.
1462 static language *
1463 get_language_from_interpreter (char *interpreter)
1465 language *lang;
1466 const char **iname;
1468 if (interpreter == NULL)
1469 return NULL;
1470 for (lang = lang_names; lang->name != NULL; lang++)
1471 if (lang->interpreters != NULL)
1472 for (iname = lang->interpreters; *iname != NULL; iname++)
1473 if (streq (*iname, interpreter))
1474 return lang;
1476 return NULL;
1482 * Return a language given the file name.
1484 static language *
1485 get_language_from_filename (char *file, int case_sensitive)
1487 language *lang;
1488 const char **name, **ext, *suffix;
1489 char *slash;
1491 /* Try whole file name first. */
1492 slash = strrchr (file, '/');
1493 if (slash != NULL)
1494 file = slash + 1;
1495 #ifdef DOS_NT
1496 else if (file[0] && file[1] == ':')
1497 file += 2;
1498 #endif
1499 for (lang = lang_names; lang->name != NULL; lang++)
1500 if (lang->filenames != NULL)
1501 for (name = lang->filenames; *name != NULL; name++)
1502 if ((case_sensitive)
1503 ? streq (*name, file)
1504 : strcaseeq (*name, file))
1505 return lang;
1507 /* If not found, try suffix after last dot. */
1508 suffix = strrchr (file, '.');
1509 if (suffix == NULL)
1510 return NULL;
1511 suffix += 1;
1512 for (lang = lang_names; lang->name != NULL; lang++)
1513 if (lang->suffixes != NULL)
1514 for (ext = lang->suffixes; *ext != NULL; ext++)
1515 if ((case_sensitive)
1516 ? streq (*ext, suffix)
1517 : strcaseeq (*ext, suffix))
1518 return lang;
1519 return NULL;
1524 * This routine is called on each file argument.
1526 static void
1527 process_file_name (char *file, language *lang)
1529 FILE *inf;
1530 fdesc *fdp;
1531 compressor *compr;
1532 char *compressed_name, *uncompressed_name;
1533 char *ext, *real_name, *tmp_name;
1534 int retval;
1536 canonicalize_filename (file);
1537 if (streq (file, tagfile) && !streq (tagfile, "-"))
1539 error ("skipping inclusion of %s in self.", file);
1540 return;
1542 compr = get_compressor_from_suffix (file, &ext);
1543 if (compr)
1545 compressed_name = file;
1546 uncompressed_name = savenstr (file, ext - file);
1548 else
1550 compressed_name = NULL;
1551 uncompressed_name = file;
1554 /* If the canonicalized uncompressed name
1555 has already been dealt with, skip it silently. */
1556 for (fdp = fdhead; fdp != NULL; fdp = fdp->next)
1558 assert (fdp->infname != NULL);
1559 if (streq (uncompressed_name, fdp->infname))
1560 goto cleanup;
1563 inf = fopen (file, "r" FOPEN_BINARY);
1564 if (inf)
1565 real_name = file;
1566 else
1568 int file_errno = errno;
1569 if (compressed_name)
1571 /* Try with the given suffix. */
1572 inf = fopen (uncompressed_name, "r" FOPEN_BINARY);
1573 if (inf)
1574 real_name = uncompressed_name;
1576 else
1578 /* Try all possible suffixes. */
1579 for (compr = compressors; compr->suffix != NULL; compr++)
1581 compressed_name = concat (file, ".", compr->suffix);
1582 inf = fopen (compressed_name, "r" FOPEN_BINARY);
1583 if (inf)
1585 real_name = compressed_name;
1586 break;
1588 if (MSDOS)
1590 char *suf = compressed_name + strlen (file);
1591 size_t suflen = strlen (compr->suffix) + 1;
1592 for ( ; suf[1]; suf++, suflen--)
1594 memmove (suf, suf + 1, suflen);
1595 inf = fopen (compressed_name, "r" FOPEN_BINARY);
1596 if (inf)
1598 real_name = compressed_name;
1599 break;
1602 if (inf)
1603 break;
1605 free (compressed_name);
1606 compressed_name = NULL;
1609 if (! inf)
1611 errno = file_errno;
1612 perror (file);
1613 goto cleanup;
1617 if (real_name == compressed_name)
1619 fclose (inf);
1620 tmp_name = etags_mktmp ();
1621 if (!tmp_name)
1622 inf = NULL;
1623 else
1625 #if MSDOS || defined (DOS_NT)
1626 char *cmd1 = concat (compr->command, " \"", real_name);
1627 char *cmd = concat (cmd1, "\" > ", tmp_name);
1628 #else
1629 char *cmd1 = concat (compr->command, " '", real_name);
1630 char *cmd = concat (cmd1, "' > ", tmp_name);
1631 #endif
1632 free (cmd1);
1633 int tmp_errno;
1634 if (system (cmd) == -1)
1636 inf = NULL;
1637 tmp_errno = EINVAL;
1639 else
1641 inf = fopen (tmp_name, "r" FOPEN_BINARY);
1642 tmp_errno = errno;
1644 free (cmd);
1645 errno = tmp_errno;
1648 if (!inf)
1650 perror (real_name);
1651 goto cleanup;
1655 process_file (inf, uncompressed_name, lang);
1657 retval = fclose (inf);
1658 if (real_name == compressed_name)
1660 remove (tmp_name);
1661 free (tmp_name);
1663 if (retval < 0)
1664 pfatal (file);
1666 cleanup:
1667 if (compressed_name != file)
1668 free (compressed_name);
1669 if (uncompressed_name != file)
1670 free (uncompressed_name);
1671 last_node = NULL;
1672 curfdp = NULL;
1673 return;
1676 static void
1677 process_file (FILE *fh, char *fn, language *lang)
1679 static const fdesc emptyfdesc;
1680 fdesc *fdp;
1682 infilename = fn;
1683 /* Create a new input file description entry. */
1684 fdp = xnew (1, fdesc);
1685 *fdp = emptyfdesc;
1686 fdp->next = fdhead;
1687 fdp->infname = savestr (fn);
1688 fdp->lang = lang;
1689 fdp->infabsname = absolute_filename (fn, cwd);
1690 fdp->infabsdir = absolute_dirname (fn, cwd);
1691 if (filename_is_absolute (fn))
1693 /* An absolute file name. Canonicalize it. */
1694 fdp->taggedfname = absolute_filename (fn, NULL);
1696 else
1698 /* A file name relative to cwd. Make it relative
1699 to the directory of the tags file. */
1700 fdp->taggedfname = relative_filename (fn, tagfiledir);
1702 fdp->usecharno = true; /* use char position when making tags */
1703 fdp->prop = NULL;
1704 fdp->written = false; /* not written on tags file yet */
1706 fdhead = fdp;
1707 curfdp = fdhead; /* the current file description */
1709 find_entries (fh);
1711 /* If not Ctags, and if this is not metasource and if it contained no #line
1712 directives, we can write the tags and free all nodes pointing to
1713 curfdp. */
1714 if (!CTAGS
1715 && curfdp->usecharno /* no #line directives in this file */
1716 && !curfdp->lang->metasource)
1718 node *np, *prev;
1720 /* Look for the head of the sublist relative to this file. See add_node
1721 for the structure of the node tree. */
1722 prev = NULL;
1723 for (np = nodehead; np != NULL; prev = np, np = np->left)
1724 if (np->fdp == curfdp)
1725 break;
1727 /* If we generated tags for this file, write and delete them. */
1728 if (np != NULL)
1730 /* This is the head of the last sublist, if any. The following
1731 instructions depend on this being true. */
1732 assert (np->left == NULL);
1734 assert (fdhead == curfdp);
1735 assert (last_node->fdp == curfdp);
1736 put_entries (np); /* write tags for file curfdp->taggedfname */
1737 free_tree (np); /* remove the written nodes */
1738 if (prev == NULL)
1739 nodehead = NULL; /* no nodes left */
1740 else
1741 prev->left = NULL; /* delete the pointer to the sublist */
1746 static void
1747 reset_input (FILE *inf)
1749 if (fseek (inf, 0, SEEK_SET) != 0)
1750 perror (infilename);
1754 * This routine opens the specified file and calls the function
1755 * which finds the function and type definitions.
1757 static void
1758 find_entries (FILE *inf)
1760 char *cp;
1761 language *lang = curfdp->lang;
1762 Lang_function *parser = NULL;
1764 /* If user specified a language, use it. */
1765 if (lang != NULL && lang->function != NULL)
1767 parser = lang->function;
1770 /* Else try to guess the language given the file name. */
1771 if (parser == NULL)
1773 lang = get_language_from_filename (curfdp->infname, true);
1774 if (lang != NULL && lang->function != NULL)
1776 curfdp->lang = lang;
1777 parser = lang->function;
1781 /* Else look for sharp-bang as the first two characters. */
1782 if (parser == NULL
1783 && readline_internal (&lb, inf, infilename) > 0
1784 && lb.len >= 2
1785 && lb.buffer[0] == '#'
1786 && lb.buffer[1] == '!')
1788 char *lp;
1790 /* Set lp to point at the first char after the last slash in the
1791 line or, if no slashes, at the first nonblank. Then set cp to
1792 the first successive blank and terminate the string. */
1793 lp = strrchr (lb.buffer+2, '/');
1794 if (lp != NULL)
1795 lp += 1;
1796 else
1797 lp = skip_spaces (lb.buffer + 2);
1798 cp = skip_non_spaces (lp);
1799 *cp = '\0';
1801 if (strlen (lp) > 0)
1803 lang = get_language_from_interpreter (lp);
1804 if (lang != NULL && lang->function != NULL)
1806 curfdp->lang = lang;
1807 parser = lang->function;
1812 reset_input (inf);
1814 /* Else try to guess the language given the case insensitive file name. */
1815 if (parser == NULL)
1817 lang = get_language_from_filename (curfdp->infname, false);
1818 if (lang != NULL && lang->function != NULL)
1820 curfdp->lang = lang;
1821 parser = lang->function;
1825 /* Else try Fortran or C. */
1826 if (parser == NULL)
1828 node *old_last_node = last_node;
1830 curfdp->lang = get_language_from_langname ("fortran");
1831 find_entries (inf);
1833 if (old_last_node == last_node)
1834 /* No Fortran entries found. Try C. */
1836 reset_input (inf);
1837 curfdp->lang = get_language_from_langname (cplusplus ? "c++" : "c");
1838 find_entries (inf);
1840 return;
1843 if (!no_line_directive
1844 && curfdp->lang != NULL && curfdp->lang->metasource)
1845 /* It may be that this is a bingo.y file, and we already parsed a bingo.c
1846 file, or anyway we parsed a file that is automatically generated from
1847 this one. If this is the case, the bingo.c file contained #line
1848 directives that generated tags pointing to this file. Let's delete
1849 them all before parsing this file, which is the real source. */
1851 fdesc **fdpp = &fdhead;
1852 while (*fdpp != NULL)
1853 if (*fdpp != curfdp
1854 && streq ((*fdpp)->taggedfname, curfdp->taggedfname))
1855 /* We found one of those! We must delete both the file description
1856 and all tags referring to it. */
1858 fdesc *badfdp = *fdpp;
1860 /* Delete the tags referring to badfdp->taggedfname
1861 that were obtained from badfdp->infname. */
1862 invalidate_nodes (badfdp, &nodehead);
1864 *fdpp = badfdp->next; /* remove the bad description from the list */
1865 free_fdesc (badfdp);
1867 else
1868 fdpp = &(*fdpp)->next; /* advance the list pointer */
1871 assert (parser != NULL);
1873 /* Generic initializations before reading from file. */
1874 linebuffer_setlen (&filebuf, 0); /* reset the file buffer */
1876 /* Generic initializations before parsing file with readline. */
1877 lineno = 0; /* reset global line number */
1878 charno = 0; /* reset global char number */
1879 linecharno = 0; /* reset global char number of line start */
1881 parser (inf);
1883 regex_tag_multiline ();
1888 * Check whether an implicitly named tag should be created,
1889 * then call `pfnote'.
1890 * NAME is a string that is internally copied by this function.
1892 * TAGS format specification
1893 * Idea by Sam Kendall <kendall@mv.mv.com> (1997)
1894 * The following is explained in some more detail in etc/ETAGS.EBNF.
1896 * make_tag creates tags with "implicit tag names" (unnamed tags)
1897 * if the following are all true, assuming NONAM=" \f\t\n\r()=,;":
1898 * 1. NAME does not contain any of the characters in NONAM;
1899 * 2. LINESTART contains name as either a rightmost, or rightmost but
1900 * one character, substring;
1901 * 3. the character, if any, immediately before NAME in LINESTART must
1902 * be a character in NONAM;
1903 * 4. the character, if any, immediately after NAME in LINESTART must
1904 * also be a character in NONAM.
1906 * The implementation uses the notinname() macro, which recognizes the
1907 * characters stored in the string `nonam'.
1908 * etags.el needs to use the same characters that are in NONAM.
1910 static void
1911 make_tag (const char *name, /* tag name, or NULL if unnamed */
1912 int namelen, /* tag length */
1913 bool is_func, /* tag is a function */
1914 char *linestart, /* start of the line where tag is */
1915 int linelen, /* length of the line where tag is */
1916 int lno, /* line number */
1917 long int cno) /* character number */
1919 bool named = (name != NULL && namelen > 0);
1920 char *nname = NULL;
1922 if (!CTAGS && named) /* maybe set named to false */
1923 /* Let's try to make an implicit tag name, that is, create an unnamed tag
1924 such that etags.el can guess a name from it. */
1926 int i;
1927 register const char *cp = name;
1929 for (i = 0; i < namelen; i++)
1930 if (notinname (*cp++))
1931 break;
1932 if (i == namelen) /* rule #1 */
1934 cp = linestart + linelen - namelen;
1935 if (notinname (linestart[linelen-1]))
1936 cp -= 1; /* rule #4 */
1937 if (cp >= linestart /* rule #2 */
1938 && (cp == linestart
1939 || notinname (cp[-1])) /* rule #3 */
1940 && strneq (name, cp, namelen)) /* rule #2 */
1941 named = false; /* use implicit tag name */
1945 if (named)
1946 nname = savenstr (name, namelen);
1948 pfnote (nname, is_func, linestart, linelen, lno, cno);
1951 /* Record a tag. */
1952 static void
1953 pfnote (char *name, bool is_func, char *linestart, int linelen, int lno,
1954 long int cno)
1955 /* tag name, or NULL if unnamed */
1956 /* tag is a function */
1957 /* start of the line where tag is */
1958 /* length of the line where tag is */
1959 /* line number */
1960 /* character number */
1962 register node *np;
1964 assert (name == NULL || name[0] != '\0');
1965 if (CTAGS && name == NULL)
1966 return;
1968 np = xnew (1, node);
1970 /* If ctags mode, change name "main" to M<thisfilename>. */
1971 if (CTAGS && !cxref_style && streq (name, "main"))
1973 char *fp = strrchr (curfdp->taggedfname, '/');
1974 np->name = concat ("M", fp == NULL ? curfdp->taggedfname : fp + 1, "");
1975 fp = strrchr (np->name, '.');
1976 if (fp != NULL && fp[1] != '\0' && fp[2] == '\0')
1977 fp[0] = '\0';
1979 else
1980 np->name = name;
1981 np->valid = true;
1982 np->been_warned = false;
1983 np->fdp = curfdp;
1984 np->is_func = is_func;
1985 np->lno = lno;
1986 if (np->fdp->usecharno)
1987 /* Our char numbers are 0-base, because of C language tradition?
1988 ctags compatibility? old versions compatibility? I don't know.
1989 Anyway, since emacs's are 1-base we expect etags.el to take care
1990 of the difference. If we wanted to have 1-based numbers, we would
1991 uncomment the +1 below. */
1992 np->cno = cno /* + 1 */ ;
1993 else
1994 np->cno = invalidcharno;
1995 np->left = np->right = NULL;
1996 if (CTAGS && !cxref_style)
1998 if (strlen (linestart) < 50)
1999 np->regex = concat (linestart, "$", "");
2000 else
2001 np->regex = savenstr (linestart, 50);
2003 else
2004 np->regex = savenstr (linestart, linelen);
2006 add_node (np, &nodehead);
2010 * free_tree ()
2011 * recurse on left children, iterate on right children.
2013 static void
2014 free_tree (register node *np)
2016 while (np)
2018 register node *node_right = np->right;
2019 free_tree (np->left);
2020 free (np->name);
2021 free (np->regex);
2022 free (np);
2023 np = node_right;
2028 * free_fdesc ()
2029 * delete a file description
2031 static void
2032 free_fdesc (register fdesc *fdp)
2034 free (fdp->infname);
2035 free (fdp->infabsname);
2036 free (fdp->infabsdir);
2037 free (fdp->taggedfname);
2038 free (fdp->prop);
2039 free (fdp);
2043 * add_node ()
2044 * Adds a node to the tree of nodes. In etags mode, sort by file
2045 * name. In ctags mode, sort by tag name. Make no attempt at
2046 * balancing.
2048 * add_node is the only function allowed to add nodes, so it can
2049 * maintain state.
2051 static void
2052 add_node (node *np, node **cur_node_p)
2054 register int dif;
2055 register node *cur_node = *cur_node_p;
2057 if (cur_node == NULL)
2059 *cur_node_p = np;
2060 last_node = np;
2061 return;
2064 if (!CTAGS)
2065 /* Etags Mode */
2067 /* For each file name, tags are in a linked sublist on the right
2068 pointer. The first tags of different files are a linked list
2069 on the left pointer. last_node points to the end of the last
2070 used sublist. */
2071 if (last_node != NULL && last_node->fdp == np->fdp)
2073 /* Let's use the same sublist as the last added node. */
2074 assert (last_node->right == NULL);
2075 last_node->right = np;
2076 last_node = np;
2078 else if (cur_node->fdp == np->fdp)
2080 /* Scanning the list we found the head of a sublist which is
2081 good for us. Let's scan this sublist. */
2082 add_node (np, &cur_node->right);
2084 else
2085 /* The head of this sublist is not good for us. Let's try the
2086 next one. */
2087 add_node (np, &cur_node->left);
2088 } /* if ETAGS mode */
2090 else
2092 /* Ctags Mode */
2093 dif = strcmp (np->name, cur_node->name);
2096 * If this tag name matches an existing one, then
2097 * do not add the node, but maybe print a warning.
2099 if (no_duplicates && !dif)
2101 if (np->fdp == cur_node->fdp)
2103 if (!no_warnings)
2105 fprintf (stderr, "Duplicate entry in file %s, line %d: %s\n",
2106 np->fdp->infname, lineno, np->name);
2107 fprintf (stderr, "Second entry ignored\n");
2110 else if (!cur_node->been_warned && !no_warnings)
2112 fprintf
2113 (stderr,
2114 "Duplicate entry in files %s and %s: %s (Warning only)\n",
2115 np->fdp->infname, cur_node->fdp->infname, np->name);
2116 cur_node->been_warned = true;
2118 return;
2121 /* Actually add the node */
2122 add_node (np, dif < 0 ? &cur_node->left : &cur_node->right);
2123 } /* if CTAGS mode */
2127 * invalidate_nodes ()
2128 * Scan the node tree and invalidate all nodes pointing to the
2129 * given file description (CTAGS case) or free them (ETAGS case).
2131 static void
2132 invalidate_nodes (fdesc *badfdp, node **npp)
2134 node *np = *npp;
2136 if (np == NULL)
2137 return;
2139 if (CTAGS)
2141 if (np->left != NULL)
2142 invalidate_nodes (badfdp, &np->left);
2143 if (np->fdp == badfdp)
2144 np->valid = false;
2145 if (np->right != NULL)
2146 invalidate_nodes (badfdp, &np->right);
2148 else
2150 assert (np->fdp != NULL);
2151 if (np->fdp == badfdp)
2153 *npp = np->left; /* detach the sublist from the list */
2154 np->left = NULL; /* isolate it */
2155 free_tree (np); /* free it */
2156 invalidate_nodes (badfdp, npp);
2158 else
2159 invalidate_nodes (badfdp, &np->left);
2164 static int total_size_of_entries (node *);
2165 static int number_len (long) ATTRIBUTE_CONST;
2167 /* Length of a non-negative number's decimal representation. */
2168 static int
2169 number_len (long int num)
2171 int len = 1;
2172 while ((num /= 10) > 0)
2173 len += 1;
2174 return len;
2178 * Return total number of characters that put_entries will output for
2179 * the nodes in the linked list at the right of the specified node.
2180 * This count is irrelevant with etags.el since emacs 19.34 at least,
2181 * but is still supplied for backward compatibility.
2183 static int
2184 total_size_of_entries (register node *np)
2186 register int total = 0;
2188 for (; np != NULL; np = np->right)
2189 if (np->valid)
2191 total += strlen (np->regex) + 1; /* pat\177 */
2192 if (np->name != NULL)
2193 total += strlen (np->name) + 1; /* name\001 */
2194 total += number_len ((long) np->lno) + 1; /* lno, */
2195 if (np->cno != invalidcharno) /* cno */
2196 total += number_len (np->cno);
2197 total += 1; /* newline */
2200 return total;
2203 static void
2204 put_entries (register node *np)
2206 register char *sp;
2207 static fdesc *fdp = NULL;
2209 if (np == NULL)
2210 return;
2212 /* Output subentries that precede this one */
2213 if (CTAGS)
2214 put_entries (np->left);
2216 /* Output this entry */
2217 if (np->valid)
2219 if (!CTAGS)
2221 /* Etags mode */
2222 if (fdp != np->fdp)
2224 fdp = np->fdp;
2225 fprintf (tagf, "\f\n%s,%d\n",
2226 fdp->taggedfname, total_size_of_entries (np));
2227 fdp->written = true;
2229 fputs (np->regex, tagf);
2230 fputc ('\177', tagf);
2231 if (np->name != NULL)
2233 fputs (np->name, tagf);
2234 fputc ('\001', tagf);
2236 fprintf (tagf, "%d,", np->lno);
2237 if (np->cno != invalidcharno)
2238 fprintf (tagf, "%ld", np->cno);
2239 fputs ("\n", tagf);
2241 else
2243 /* Ctags mode */
2244 if (np->name == NULL)
2245 error ("internal error: NULL name in ctags mode.");
2247 if (cxref_style)
2249 if (vgrind_style)
2250 fprintf (stdout, "%s %s %d\n",
2251 np->name, np->fdp->taggedfname, (np->lno + 63) / 64);
2252 else
2253 fprintf (stdout, "%-16s %3d %-16s %s\n",
2254 np->name, np->lno, np->fdp->taggedfname, np->regex);
2256 else
2258 fprintf (tagf, "%s\t%s\t", np->name, np->fdp->taggedfname);
2260 if (np->is_func)
2261 { /* function or #define macro with args */
2262 putc (searchar, tagf);
2263 putc ('^', tagf);
2265 for (sp = np->regex; *sp; sp++)
2267 if (*sp == '\\' || *sp == searchar)
2268 putc ('\\', tagf);
2269 putc (*sp, tagf);
2271 putc (searchar, tagf);
2273 else
2274 { /* anything else; text pattern inadequate */
2275 fprintf (tagf, "%d", np->lno);
2277 putc ('\n', tagf);
2280 } /* if this node contains a valid tag */
2282 /* Output subentries that follow this one */
2283 put_entries (np->right);
2284 if (!CTAGS)
2285 put_entries (np->left);
2289 /* C extensions. */
2290 #define C_EXT 0x00fff /* C extensions */
2291 #define C_PLAIN 0x00000 /* C */
2292 #define C_PLPL 0x00001 /* C++ */
2293 #define C_STAR 0x00003 /* C* */
2294 #define C_JAVA 0x00005 /* JAVA */
2295 #define C_AUTO 0x01000 /* C, but switch to C++ if `class' is met */
2296 #define YACC 0x10000 /* yacc file */
2299 * The C symbol tables.
2301 enum sym_type
2303 st_none,
2304 st_C_objprot, st_C_objimpl, st_C_objend,
2305 st_C_gnumacro,
2306 st_C_ignore, st_C_attribute,
2307 st_C_javastruct,
2308 st_C_operator,
2309 st_C_class, st_C_template,
2310 st_C_struct, st_C_extern, st_C_enum, st_C_define, st_C_typedef
2313 /* Feed stuff between (but not including) %[ and %] lines to:
2314 gperf -m 5
2316 %compare-strncmp
2317 %enum
2318 %struct-type
2319 struct C_stab_entry { char *name; int c_ext; enum sym_type type; }
2321 if, 0, st_C_ignore
2322 for, 0, st_C_ignore
2323 while, 0, st_C_ignore
2324 switch, 0, st_C_ignore
2325 return, 0, st_C_ignore
2326 __attribute__, 0, st_C_attribute
2327 GTY, 0, st_C_attribute
2328 @interface, 0, st_C_objprot
2329 @protocol, 0, st_C_objprot
2330 @implementation,0, st_C_objimpl
2331 @end, 0, st_C_objend
2332 import, (C_JAVA & ~C_PLPL), st_C_ignore
2333 package, (C_JAVA & ~C_PLPL), st_C_ignore
2334 friend, C_PLPL, st_C_ignore
2335 extends, (C_JAVA & ~C_PLPL), st_C_javastruct
2336 implements, (C_JAVA & ~C_PLPL), st_C_javastruct
2337 interface, (C_JAVA & ~C_PLPL), st_C_struct
2338 class, 0, st_C_class
2339 namespace, C_PLPL, st_C_struct
2340 domain, C_STAR, st_C_struct
2341 union, 0, st_C_struct
2342 struct, 0, st_C_struct
2343 extern, 0, st_C_extern
2344 enum, 0, st_C_enum
2345 typedef, 0, st_C_typedef
2346 define, 0, st_C_define
2347 undef, 0, st_C_define
2348 operator, C_PLPL, st_C_operator
2349 template, 0, st_C_template
2350 # DEFUN used in emacs, the next three used in glibc (SYSCALL only for mach).
2351 DEFUN, 0, st_C_gnumacro
2352 SYSCALL, 0, st_C_gnumacro
2353 ENTRY, 0, st_C_gnumacro
2354 PSEUDO, 0, st_C_gnumacro
2355 # These are defined inside C functions, so currently they are not met.
2356 # EXFUN used in glibc, DEFVAR_* in emacs.
2357 #EXFUN, 0, st_C_gnumacro
2358 #DEFVAR_, 0, st_C_gnumacro
2360 and replace lines between %< and %> with its output, then:
2361 - remove the #if characterset check
2362 - make in_word_set static and not inline. */
2363 /*%<*/
2364 /* C code produced by gperf version 3.0.1 */
2365 /* Command-line: gperf -m 5 */
2366 /* Computed positions: -k'2-3' */
2368 struct C_stab_entry { const char *name; int c_ext; enum sym_type type; };
2369 /* maximum key range = 33, duplicates = 0 */
2371 static int
2372 hash (const char *str, int len)
2374 static char const asso_values[] =
2376 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2377 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2378 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2379 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2380 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2381 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2382 35, 35, 35, 35, 35, 35, 35, 35, 35, 3,
2383 26, 35, 35, 35, 35, 35, 35, 35, 27, 35,
2384 35, 35, 35, 24, 0, 35, 35, 35, 35, 0,
2385 35, 35, 35, 35, 35, 1, 35, 16, 35, 6,
2386 23, 0, 0, 35, 22, 0, 35, 35, 5, 0,
2387 0, 15, 1, 35, 6, 35, 8, 19, 35, 16,
2388 4, 5, 35, 35, 35, 35, 35, 35, 35, 35,
2389 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2390 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2391 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2392 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2393 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2394 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2395 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2396 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2397 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2398 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2399 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2400 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2401 35, 35, 35, 35, 35, 35
2403 int hval = len;
2405 switch (hval)
2407 default:
2408 hval += asso_values[(unsigned char) str[2]];
2409 /*FALLTHROUGH*/
2410 case 2:
2411 hval += asso_values[(unsigned char) str[1]];
2412 break;
2414 return hval;
2417 static struct C_stab_entry *
2418 in_word_set (register const char *str, register unsigned int len)
2420 enum
2422 TOTAL_KEYWORDS = 33,
2423 MIN_WORD_LENGTH = 2,
2424 MAX_WORD_LENGTH = 15,
2425 MIN_HASH_VALUE = 2,
2426 MAX_HASH_VALUE = 34
2429 static struct C_stab_entry wordlist[] =
2431 {""}, {""},
2432 {"if", 0, st_C_ignore},
2433 {"GTY", 0, st_C_attribute},
2434 {"@end", 0, st_C_objend},
2435 {"union", 0, st_C_struct},
2436 {"define", 0, st_C_define},
2437 {"import", (C_JAVA & ~C_PLPL), st_C_ignore},
2438 {"template", 0, st_C_template},
2439 {"operator", C_PLPL, st_C_operator},
2440 {"@interface", 0, st_C_objprot},
2441 {"implements", (C_JAVA & ~C_PLPL), st_C_javastruct},
2442 {"friend", C_PLPL, st_C_ignore},
2443 {"typedef", 0, st_C_typedef},
2444 {"return", 0, st_C_ignore},
2445 {"@implementation",0, st_C_objimpl},
2446 {"@protocol", 0, st_C_objprot},
2447 {"interface", (C_JAVA & ~C_PLPL), st_C_struct},
2448 {"extern", 0, st_C_extern},
2449 {"extends", (C_JAVA & ~C_PLPL), st_C_javastruct},
2450 {"struct", 0, st_C_struct},
2451 {"domain", C_STAR, st_C_struct},
2452 {"switch", 0, st_C_ignore},
2453 {"enum", 0, st_C_enum},
2454 {"for", 0, st_C_ignore},
2455 {"namespace", C_PLPL, st_C_struct},
2456 {"class", 0, st_C_class},
2457 {"while", 0, st_C_ignore},
2458 {"undef", 0, st_C_define},
2459 {"package", (C_JAVA & ~C_PLPL), st_C_ignore},
2460 {"__attribute__", 0, st_C_attribute},
2461 {"SYSCALL", 0, st_C_gnumacro},
2462 {"ENTRY", 0, st_C_gnumacro},
2463 {"PSEUDO", 0, st_C_gnumacro},
2464 {"DEFUN", 0, st_C_gnumacro}
2467 if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
2469 int key = hash (str, len);
2471 if (key <= MAX_HASH_VALUE && key >= 0)
2473 const char *s = wordlist[key].name;
2475 if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
2476 return &wordlist[key];
2479 return 0;
2481 /*%>*/
2483 static enum sym_type
2484 C_symtype (char *str, int len, int c_ext)
2486 register struct C_stab_entry *se = in_word_set (str, len);
2488 if (se == NULL || (se->c_ext && !(c_ext & se->c_ext)))
2489 return st_none;
2490 return se->type;
2495 * Ignoring __attribute__ ((list))
2497 static bool inattribute; /* looking at an __attribute__ construct */
2500 * C functions and variables are recognized using a simple
2501 * finite automaton. fvdef is its state variable.
2503 static enum
2505 fvnone, /* nothing seen */
2506 fdefunkey, /* Emacs DEFUN keyword seen */
2507 fdefunname, /* Emacs DEFUN name seen */
2508 foperator, /* func: operator keyword seen (cplpl) */
2509 fvnameseen, /* function or variable name seen */
2510 fstartlist, /* func: just after open parenthesis */
2511 finlist, /* func: in parameter list */
2512 flistseen, /* func: after parameter list */
2513 fignore, /* func: before open brace */
2514 vignore /* var-like: ignore until ';' */
2515 } fvdef;
2517 static bool fvextern; /* func or var: extern keyword seen; */
2520 * typedefs are recognized using a simple finite automaton.
2521 * typdef is its state variable.
2523 static enum
2525 tnone, /* nothing seen */
2526 tkeyseen, /* typedef keyword seen */
2527 ttypeseen, /* defined type seen */
2528 tinbody, /* inside typedef body */
2529 tend, /* just before typedef tag */
2530 tignore /* junk after typedef tag */
2531 } typdef;
2534 * struct-like structures (enum, struct and union) are recognized
2535 * using another simple finite automaton. `structdef' is its state
2536 * variable.
2538 static enum
2540 snone, /* nothing seen yet,
2541 or in struct body if bracelev > 0 */
2542 skeyseen, /* struct-like keyword seen */
2543 stagseen, /* struct-like tag seen */
2544 scolonseen /* colon seen after struct-like tag */
2545 } structdef;
2548 * When objdef is different from onone, objtag is the name of the class.
2550 static const char *objtag = "<uninited>";
2553 * Yet another little state machine to deal with preprocessor lines.
2555 static enum
2557 dnone, /* nothing seen */
2558 dsharpseen, /* '#' seen as first char on line */
2559 ddefineseen, /* '#' and 'define' seen */
2560 dignorerest /* ignore rest of line */
2561 } definedef;
2564 * State machine for Objective C protocols and implementations.
2565 * Idea by Tom R.Hageman <tom@basil.icce.rug.nl> (1995)
2567 static enum
2569 onone, /* nothing seen */
2570 oprotocol, /* @interface or @protocol seen */
2571 oimplementation, /* @implementations seen */
2572 otagseen, /* class name seen */
2573 oparenseen, /* parenthesis before category seen */
2574 ocatseen, /* category name seen */
2575 oinbody, /* in @implementation body */
2576 omethodsign, /* in @implementation body, after +/- */
2577 omethodtag, /* after method name */
2578 omethodcolon, /* after method colon */
2579 omethodparm, /* after method parameter */
2580 oignore /* wait for @end */
2581 } objdef;
2585 * Use this structure to keep info about the token read, and how it
2586 * should be tagged. Used by the make_C_tag function to build a tag.
2588 static struct tok
2590 char *line; /* string containing the token */
2591 int offset; /* where the token starts in LINE */
2592 int length; /* token length */
2594 The previous members can be used to pass strings around for generic
2595 purposes. The following ones specifically refer to creating tags. In this
2596 case the token contained here is the pattern that will be used to create a
2597 tag.
2599 bool valid; /* do not create a tag; the token should be
2600 invalidated whenever a state machine is
2601 reset prematurely */
2602 bool named; /* create a named tag */
2603 int lineno; /* source line number of tag */
2604 long linepos; /* source char number of tag */
2605 } token; /* latest token read */
2608 * Variables and functions for dealing with nested structures.
2609 * Idea by Mykola Dzyuba <mdzyuba@yahoo.com> (2001)
2611 static void pushclass_above (int, char *, int);
2612 static void popclass_above (int);
2613 static void write_classname (linebuffer *, const char *qualifier);
2615 static struct {
2616 char **cname; /* nested class names */
2617 int *bracelev; /* nested class brace level */
2618 int nl; /* class nesting level (elements used) */
2619 int size; /* length of the array */
2620 } cstack; /* stack for nested declaration tags */
2621 /* Current struct nesting depth (namespace, class, struct, union, enum). */
2622 #define nestlev (cstack.nl)
2623 /* After struct keyword or in struct body, not inside a nested function. */
2624 #define instruct (structdef == snone && nestlev > 0 \
2625 && bracelev == cstack.bracelev[nestlev-1] + 1)
2627 static void
2628 pushclass_above (int bracelev, char *str, int len)
2630 int nl;
2632 popclass_above (bracelev);
2633 nl = cstack.nl;
2634 if (nl >= cstack.size)
2636 int size = cstack.size *= 2;
2637 xrnew (cstack.cname, size, char *);
2638 xrnew (cstack.bracelev, size, int);
2640 assert (nl == 0 || cstack.bracelev[nl-1] < bracelev);
2641 cstack.cname[nl] = (str == NULL) ? NULL : savenstr (str, len);
2642 cstack.bracelev[nl] = bracelev;
2643 cstack.nl = nl + 1;
2646 static void
2647 popclass_above (int bracelev)
2649 int nl;
2651 for (nl = cstack.nl - 1;
2652 nl >= 0 && cstack.bracelev[nl] >= bracelev;
2653 nl--)
2655 free (cstack.cname[nl]);
2656 cstack.nl = nl;
2660 static void
2661 write_classname (linebuffer *cn, const char *qualifier)
2663 int i, len;
2664 int qlen = strlen (qualifier);
2666 if (cstack.nl == 0 || cstack.cname[0] == NULL)
2668 len = 0;
2669 cn->len = 0;
2670 cn->buffer[0] = '\0';
2672 else
2674 len = strlen (cstack.cname[0]);
2675 linebuffer_setlen (cn, len);
2676 strcpy (cn->buffer, cstack.cname[0]);
2678 for (i = 1; i < cstack.nl; i++)
2680 char *s = cstack.cname[i];
2681 if (s == NULL)
2682 continue;
2683 linebuffer_setlen (cn, len + qlen + strlen (s));
2684 len += sprintf (cn->buffer + len, "%s%s", qualifier, s);
2689 static bool consider_token (char *, int, int, int *, int, int, bool *);
2690 static void make_C_tag (bool);
2693 * consider_token ()
2694 * checks to see if the current token is at the start of a
2695 * function or variable, or corresponds to a typedef, or
2696 * is a struct/union/enum tag, or #define, or an enum constant.
2698 * *IS_FUNC_OR_VAR gets true if the token is a function or #define macro
2699 * with args. C_EXTP points to which language we are looking at.
2701 * Globals
2702 * fvdef IN OUT
2703 * structdef IN OUT
2704 * definedef IN OUT
2705 * typdef IN OUT
2706 * objdef IN OUT
2709 static bool
2710 consider_token (char *str, int len, int c, int *c_extp,
2711 int bracelev, int parlev, bool *is_func_or_var)
2712 /* IN: token pointer */
2713 /* IN: token length */
2714 /* IN: first char after the token */
2715 /* IN, OUT: C extensions mask */
2716 /* IN: brace level */
2717 /* IN: parenthesis level */
2718 /* OUT: function or variable found */
2720 /* When structdef is stagseen, scolonseen, or snone with bracelev > 0,
2721 structtype is the type of the preceding struct-like keyword, and
2722 structbracelev is the brace level where it has been seen. */
2723 static enum sym_type structtype;
2724 static int structbracelev;
2725 static enum sym_type toktype;
2728 toktype = C_symtype (str, len, *c_extp);
2731 * Skip __attribute__
2733 if (toktype == st_C_attribute)
2735 inattribute = true;
2736 return false;
2740 * Advance the definedef state machine.
2742 switch (definedef)
2744 case dnone:
2745 /* We're not on a preprocessor line. */
2746 if (toktype == st_C_gnumacro)
2748 fvdef = fdefunkey;
2749 return false;
2751 break;
2752 case dsharpseen:
2753 if (toktype == st_C_define)
2755 definedef = ddefineseen;
2757 else
2759 definedef = dignorerest;
2761 return false;
2762 case ddefineseen:
2764 * Make a tag for any macro, unless it is a constant
2765 * and constantypedefs is false.
2767 definedef = dignorerest;
2768 *is_func_or_var = (c == '(');
2769 if (!*is_func_or_var && !constantypedefs)
2770 return false;
2771 else
2772 return true;
2773 case dignorerest:
2774 return false;
2775 default:
2776 error ("internal error: definedef value.");
2780 * Now typedefs
2782 switch (typdef)
2784 case tnone:
2785 if (toktype == st_C_typedef)
2787 if (typedefs)
2788 typdef = tkeyseen;
2789 fvextern = false;
2790 fvdef = fvnone;
2791 return false;
2793 break;
2794 case tkeyseen:
2795 switch (toktype)
2797 case st_none:
2798 case st_C_class:
2799 case st_C_struct:
2800 case st_C_enum:
2801 typdef = ttypeseen;
2802 break;
2803 default:
2804 break;
2806 break;
2807 case ttypeseen:
2808 if (structdef == snone && fvdef == fvnone)
2810 fvdef = fvnameseen;
2811 return true;
2813 break;
2814 case tend:
2815 switch (toktype)
2817 case st_C_class:
2818 case st_C_struct:
2819 case st_C_enum:
2820 return false;
2821 default:
2822 return true;
2824 default:
2825 break;
2828 switch (toktype)
2830 case st_C_javastruct:
2831 if (structdef == stagseen)
2832 structdef = scolonseen;
2833 return false;
2834 case st_C_template:
2835 case st_C_class:
2836 if ((*c_extp & C_AUTO) /* automatic detection of C++ language */
2837 && bracelev == 0
2838 && definedef == dnone && structdef == snone
2839 && typdef == tnone && fvdef == fvnone)
2840 *c_extp = (*c_extp | C_PLPL) & ~C_AUTO;
2841 if (toktype == st_C_template)
2842 break;
2843 /* FALLTHRU */
2844 case st_C_struct:
2845 case st_C_enum:
2846 if (parlev == 0
2847 && fvdef != vignore
2848 && (typdef == tkeyseen
2849 || (typedefs_or_cplusplus && structdef == snone)))
2851 structdef = skeyseen;
2852 structtype = toktype;
2853 structbracelev = bracelev;
2854 if (fvdef == fvnameseen)
2855 fvdef = fvnone;
2857 return false;
2858 default:
2859 break;
2862 if (structdef == skeyseen)
2864 structdef = stagseen;
2865 return true;
2868 if (typdef != tnone)
2869 definedef = dnone;
2871 /* Detect Objective C constructs. */
2872 switch (objdef)
2874 case onone:
2875 switch (toktype)
2877 case st_C_objprot:
2878 objdef = oprotocol;
2879 return false;
2880 case st_C_objimpl:
2881 objdef = oimplementation;
2882 return false;
2883 default:
2884 break;
2886 break;
2887 case oimplementation:
2888 /* Save the class tag for functions or variables defined inside. */
2889 objtag = savenstr (str, len);
2890 objdef = oinbody;
2891 return false;
2892 case oprotocol:
2893 /* Save the class tag for categories. */
2894 objtag = savenstr (str, len);
2895 objdef = otagseen;
2896 *is_func_or_var = true;
2897 return true;
2898 case oparenseen:
2899 objdef = ocatseen;
2900 *is_func_or_var = true;
2901 return true;
2902 case oinbody:
2903 break;
2904 case omethodsign:
2905 if (parlev == 0)
2907 fvdef = fvnone;
2908 objdef = omethodtag;
2909 linebuffer_setlen (&token_name, len);
2910 memcpy (token_name.buffer, str, len);
2911 token_name.buffer[len] = '\0';
2912 return true;
2914 return false;
2915 case omethodcolon:
2916 if (parlev == 0)
2917 objdef = omethodparm;
2918 return false;
2919 case omethodparm:
2920 if (parlev == 0)
2922 objdef = omethodtag;
2923 if (class_qualify)
2925 int oldlen = token_name.len;
2926 fvdef = fvnone;
2927 linebuffer_setlen (&token_name, oldlen + len);
2928 memcpy (token_name.buffer + oldlen, str, len);
2929 token_name.buffer[oldlen + len] = '\0';
2931 return true;
2933 return false;
2934 case oignore:
2935 if (toktype == st_C_objend)
2937 /* Memory leakage here: the string pointed by objtag is
2938 never released, because many tests would be needed to
2939 avoid breaking on incorrect input code. The amount of
2940 memory leaked here is the sum of the lengths of the
2941 class tags.
2942 free (objtag); */
2943 objdef = onone;
2945 return false;
2946 default:
2947 break;
2950 /* A function, variable or enum constant? */
2951 switch (toktype)
2953 case st_C_extern:
2954 fvextern = true;
2955 switch (fvdef)
2957 case finlist:
2958 case flistseen:
2959 case fignore:
2960 case vignore:
2961 break;
2962 default:
2963 fvdef = fvnone;
2965 return false;
2966 case st_C_ignore:
2967 fvextern = false;
2968 fvdef = vignore;
2969 return false;
2970 case st_C_operator:
2971 fvdef = foperator;
2972 *is_func_or_var = true;
2973 return true;
2974 case st_none:
2975 if (constantypedefs
2976 && structdef == snone
2977 && structtype == st_C_enum && bracelev > structbracelev
2978 /* Don't tag tokens in expressions that assign values to enum
2979 constants. */
2980 && fvdef != vignore)
2981 return true; /* enum constant */
2982 switch (fvdef)
2984 case fdefunkey:
2985 if (bracelev > 0)
2986 break;
2987 fvdef = fdefunname; /* GNU macro */
2988 *is_func_or_var = true;
2989 return true;
2990 case fvnone:
2991 switch (typdef)
2993 case ttypeseen:
2994 return false;
2995 case tnone:
2996 if ((strneq (str, "asm", 3) && endtoken (str[3]))
2997 || (strneq (str, "__asm__", 7) && endtoken (str[7])))
2999 fvdef = vignore;
3000 return false;
3002 break;
3003 default:
3004 break;
3006 /* FALLTHRU */
3007 case fvnameseen:
3008 if (len >= 10 && strneq (str+len-10, "::operator", 10))
3010 if (*c_extp & C_AUTO) /* automatic detection of C++ */
3011 *c_extp = (*c_extp | C_PLPL) & ~C_AUTO;
3012 fvdef = foperator;
3013 *is_func_or_var = true;
3014 return true;
3016 if (bracelev > 0 && !instruct)
3017 break;
3018 fvdef = fvnameseen; /* function or variable */
3019 *is_func_or_var = true;
3020 return true;
3021 default:
3022 break;
3024 break;
3025 default:
3026 break;
3029 return false;
3034 * C_entries often keeps pointers to tokens or lines which are older than
3035 * the line currently read. By keeping two line buffers, and switching
3036 * them at end of line, it is possible to use those pointers.
3038 static struct
3040 long linepos;
3041 linebuffer lb;
3042 } lbs[2];
3044 #define current_lb_is_new (newndx == curndx)
3045 #define switch_line_buffers() (curndx = 1 - curndx)
3047 #define curlb (lbs[curndx].lb)
3048 #define newlb (lbs[newndx].lb)
3049 #define curlinepos (lbs[curndx].linepos)
3050 #define newlinepos (lbs[newndx].linepos)
3052 #define plainc ((c_ext & C_EXT) == C_PLAIN)
3053 #define cplpl (c_ext & C_PLPL)
3054 #define cjava ((c_ext & C_JAVA) == C_JAVA)
3056 #define CNL_SAVE_DEFINEDEF() \
3057 do { \
3058 curlinepos = charno; \
3059 readline (&curlb, inf); \
3060 lp = curlb.buffer; \
3061 quotednl = false; \
3062 newndx = curndx; \
3063 } while (0)
3065 #define CNL() \
3066 do { \
3067 CNL_SAVE_DEFINEDEF (); \
3068 if (savetoken.valid) \
3070 token = savetoken; \
3071 savetoken.valid = false; \
3073 definedef = dnone; \
3074 } while (0)
3077 static void
3078 make_C_tag (bool isfun)
3080 /* This function is never called when token.valid is false, but
3081 we must protect against invalid input or internal errors. */
3082 if (token.valid)
3083 make_tag (token_name.buffer, token_name.len, isfun, token.line,
3084 token.offset+token.length+1, token.lineno, token.linepos);
3085 else if (DEBUG)
3086 { /* this branch is optimized away if !DEBUG */
3087 make_tag (concat ("INVALID TOKEN:-->", token_name.buffer, ""),
3088 token_name.len + 17, isfun, token.line,
3089 token.offset+token.length+1, token.lineno, token.linepos);
3090 error ("INVALID TOKEN");
3093 token.valid = false;
3096 static bool
3097 perhaps_more_input (FILE *inf)
3099 return !feof (inf) && !ferror (inf);
3104 * C_entries ()
3105 * This routine finds functions, variables, typedefs,
3106 * #define's, enum constants and struct/union/enum definitions in
3107 * C syntax and adds them to the list.
3109 static void
3110 C_entries (int c_ext, FILE *inf)
3111 /* extension of C */
3112 /* input file */
3114 register char c; /* latest char read; '\0' for end of line */
3115 register char *lp; /* pointer one beyond the character `c' */
3116 int curndx, newndx; /* indices for current and new lb */
3117 register int tokoff; /* offset in line of start of current token */
3118 register int toklen; /* length of current token */
3119 const char *qualifier; /* string used to qualify names */
3120 int qlen; /* length of qualifier */
3121 int bracelev; /* current brace level */
3122 int bracketlev; /* current bracket level */
3123 int parlev; /* current parenthesis level */
3124 int attrparlev; /* __attribute__ parenthesis level */
3125 int templatelev; /* current template level */
3126 int typdefbracelev; /* bracelev where a typedef struct body begun */
3127 bool incomm, inquote, inchar, quotednl, midtoken;
3128 bool yacc_rules; /* in the rules part of a yacc file */
3129 struct tok savetoken = {0}; /* token saved during preprocessor handling */
3132 linebuffer_init (&lbs[0].lb);
3133 linebuffer_init (&lbs[1].lb);
3134 if (cstack.size == 0)
3136 cstack.size = (DEBUG) ? 1 : 4;
3137 cstack.nl = 0;
3138 cstack.cname = xnew (cstack.size, char *);
3139 cstack.bracelev = xnew (cstack.size, int);
3142 tokoff = toklen = typdefbracelev = 0; /* keep compiler quiet */
3143 curndx = newndx = 0;
3144 lp = curlb.buffer;
3145 *lp = 0;
3147 fvdef = fvnone; fvextern = false; typdef = tnone;
3148 structdef = snone; definedef = dnone; objdef = onone;
3149 yacc_rules = false;
3150 midtoken = inquote = inchar = incomm = quotednl = false;
3151 token.valid = savetoken.valid = false;
3152 bracelev = bracketlev = parlev = attrparlev = templatelev = 0;
3153 if (cjava)
3154 { qualifier = "."; qlen = 1; }
3155 else
3156 { qualifier = "::"; qlen = 2; }
3159 while (perhaps_more_input (inf))
3161 c = *lp++;
3162 if (c == '\\')
3164 /* If we are at the end of the line, the next character is a
3165 '\0'; do not skip it, because it is what tells us
3166 to read the next line. */
3167 if (*lp == '\0')
3169 quotednl = true;
3170 continue;
3172 lp++;
3173 c = ' ';
3175 else if (incomm)
3177 switch (c)
3179 case '*':
3180 if (*lp == '/')
3182 c = *lp++;
3183 incomm = false;
3185 break;
3186 case '\0':
3187 /* Newlines inside comments do not end macro definitions in
3188 traditional cpp. */
3189 CNL_SAVE_DEFINEDEF ();
3190 break;
3192 continue;
3194 else if (inquote)
3196 switch (c)
3198 case '"':
3199 inquote = false;
3200 break;
3201 case '\0':
3202 /* Newlines inside strings do not end macro definitions
3203 in traditional cpp, even though compilers don't
3204 usually accept them. */
3205 CNL_SAVE_DEFINEDEF ();
3206 break;
3208 continue;
3210 else if (inchar)
3212 switch (c)
3214 case '\0':
3215 /* Hmmm, something went wrong. */
3216 CNL ();
3217 /* FALLTHRU */
3218 case '\'':
3219 inchar = false;
3220 break;
3222 continue;
3224 else switch (c)
3226 case '"':
3227 inquote = true;
3228 if (bracketlev > 0)
3229 continue;
3230 if (inattribute)
3231 break;
3232 switch (fvdef)
3234 case fdefunkey:
3235 case fstartlist:
3236 case finlist:
3237 case fignore:
3238 case vignore:
3239 break;
3240 default:
3241 fvextern = false;
3242 fvdef = fvnone;
3244 continue;
3245 case '\'':
3246 inchar = true;
3247 if (bracketlev > 0)
3248 continue;
3249 if (inattribute)
3250 break;
3251 if (fvdef != finlist && fvdef != fignore && fvdef != vignore)
3253 fvextern = false;
3254 fvdef = fvnone;
3256 continue;
3257 case '/':
3258 if (*lp == '*')
3260 incomm = true;
3261 lp++;
3262 c = ' ';
3263 if (bracketlev > 0)
3264 continue;
3266 else if (/* cplpl && */ *lp == '/')
3268 c = '\0';
3270 break;
3271 case '%':
3272 if ((c_ext & YACC) && *lp == '%')
3274 /* Entering or exiting rules section in yacc file. */
3275 lp++;
3276 definedef = dnone; fvdef = fvnone; fvextern = false;
3277 typdef = tnone; structdef = snone;
3278 midtoken = inquote = inchar = incomm = quotednl = false;
3279 bracelev = 0;
3280 yacc_rules = !yacc_rules;
3281 continue;
3283 else
3284 break;
3285 case '#':
3286 if (definedef == dnone)
3288 char *cp;
3289 bool cpptoken = true;
3291 /* Look back on this line. If all blanks, or nonblanks
3292 followed by an end of comment, this is a preprocessor
3293 token. */
3294 for (cp = newlb.buffer; cp < lp-1; cp++)
3295 if (!c_isspace (*cp))
3297 if (*cp == '*' && cp[1] == '/')
3299 cp++;
3300 cpptoken = true;
3302 else
3303 cpptoken = false;
3305 if (cpptoken)
3307 definedef = dsharpseen;
3308 /* This is needed for tagging enum values: when there are
3309 preprocessor conditionals inside the enum, we need to
3310 reset the value of fvdef so that the next enum value is
3311 tagged even though the one before it did not end in a
3312 comma. */
3313 if (fvdef == vignore && instruct && parlev == 0)
3315 if (strneq (cp, "#if", 3) || strneq (cp, "#el", 3))
3316 fvdef = fvnone;
3319 } /* if (definedef == dnone) */
3320 continue;
3321 case '[':
3322 bracketlev++;
3323 continue;
3324 default:
3325 if (bracketlev > 0)
3327 if (c == ']')
3328 --bracketlev;
3329 else if (c == '\0')
3330 CNL_SAVE_DEFINEDEF ();
3331 continue;
3333 break;
3334 } /* switch (c) */
3337 /* Consider token only if some involved conditions are satisfied. */
3338 if (typdef != tignore
3339 && definedef != dignorerest
3340 && fvdef != finlist
3341 && templatelev == 0
3342 && (definedef != dnone
3343 || structdef != scolonseen)
3344 && !inattribute)
3346 if (midtoken)
3348 if (endtoken (c))
3350 if (c == ':' && *lp == ':' && begtoken (lp[1]))
3351 /* This handles :: in the middle,
3352 but not at the beginning of an identifier.
3353 Also, space-separated :: is not recognized. */
3355 if (c_ext & C_AUTO) /* automatic detection of C++ */
3356 c_ext = (c_ext | C_PLPL) & ~C_AUTO;
3357 lp += 2;
3358 toklen += 2;
3359 c = lp[-1];
3360 goto still_in_token;
3362 else
3364 bool funorvar = false;
3366 if (yacc_rules
3367 || consider_token (newlb.buffer + tokoff, toklen, c,
3368 &c_ext, bracelev, parlev,
3369 &funorvar))
3371 if (fvdef == foperator)
3373 char *oldlp = lp;
3374 lp = skip_spaces (lp-1);
3375 if (*lp != '\0')
3376 lp += 1;
3377 while (*lp != '\0'
3378 && !c_isspace (*lp) && *lp != '(')
3379 lp += 1;
3380 c = *lp++;
3381 toklen += lp - oldlp;
3383 token.named = false;
3384 if (!plainc
3385 && nestlev > 0 && definedef == dnone)
3386 /* in struct body */
3388 if (class_qualify)
3390 int len;
3391 write_classname (&token_name, qualifier);
3392 len = token_name.len;
3393 linebuffer_setlen (&token_name,
3394 len + qlen + toklen);
3395 sprintf (token_name.buffer + len, "%s%.*s",
3396 qualifier, toklen,
3397 newlb.buffer + tokoff);
3399 else
3401 linebuffer_setlen (&token_name, toklen);
3402 sprintf (token_name.buffer, "%.*s",
3403 toklen, newlb.buffer + tokoff);
3405 token.named = true;
3407 else if (objdef == ocatseen)
3408 /* Objective C category */
3410 if (class_qualify)
3412 int len = strlen (objtag) + 2 + toklen;
3413 linebuffer_setlen (&token_name, len);
3414 sprintf (token_name.buffer, "%s(%.*s)",
3415 objtag, toklen,
3416 newlb.buffer + tokoff);
3418 else
3420 linebuffer_setlen (&token_name, toklen);
3421 sprintf (token_name.buffer, "%.*s",
3422 toklen, newlb.buffer + tokoff);
3424 token.named = true;
3426 else if (objdef == omethodtag
3427 || objdef == omethodparm)
3428 /* Objective C method */
3430 token.named = true;
3432 else if (fvdef == fdefunname)
3433 /* GNU DEFUN and similar macros */
3435 bool defun = (newlb.buffer[tokoff] == 'F');
3436 int off = tokoff;
3437 int len = toklen;
3439 /* Rewrite the tag so that emacs lisp DEFUNs
3440 can be found by their elisp name */
3441 if (defun)
3443 off += 1;
3444 len -= 1;
3446 linebuffer_setlen (&token_name, len);
3447 memcpy (token_name.buffer,
3448 newlb.buffer + off, len);
3449 token_name.buffer[len] = '\0';
3450 if (defun)
3451 while (--len >= 0)
3452 if (token_name.buffer[len] == '_')
3453 token_name.buffer[len] = '-';
3454 token.named = defun;
3456 else
3458 linebuffer_setlen (&token_name, toklen);
3459 memcpy (token_name.buffer,
3460 newlb.buffer + tokoff, toklen);
3461 token_name.buffer[toklen] = '\0';
3462 /* Name macros and members. */
3463 token.named = (structdef == stagseen
3464 || typdef == ttypeseen
3465 || typdef == tend
3466 || (funorvar
3467 && definedef == dignorerest)
3468 || (funorvar
3469 && definedef == dnone
3470 && structdef == snone
3471 && bracelev > 0));
3473 token.lineno = lineno;
3474 token.offset = tokoff;
3475 token.length = toklen;
3476 token.line = newlb.buffer;
3477 token.linepos = newlinepos;
3478 token.valid = true;
3480 if (definedef == dnone
3481 && (fvdef == fvnameseen
3482 || fvdef == foperator
3483 || structdef == stagseen
3484 || typdef == tend
3485 || typdef == ttypeseen
3486 || objdef != onone))
3488 if (current_lb_is_new)
3489 switch_line_buffers ();
3491 else if (definedef != dnone
3492 || fvdef == fdefunname
3493 || instruct)
3494 make_C_tag (funorvar);
3496 else /* not yacc and consider_token failed */
3498 if (inattribute && fvdef == fignore)
3500 /* We have just met __attribute__ after a
3501 function parameter list: do not tag the
3502 function again. */
3503 fvdef = fvnone;
3506 midtoken = false;
3508 } /* if (endtoken (c)) */
3509 else if (intoken (c))
3510 still_in_token:
3512 toklen++;
3513 continue;
3515 } /* if (midtoken) */
3516 else if (begtoken (c))
3518 switch (definedef)
3520 case dnone:
3521 switch (fvdef)
3523 case fstartlist:
3524 /* This prevents tagging fb in
3525 void (__attribute__((noreturn)) *fb) (void);
3526 Fixing this is not easy and not very important. */
3527 fvdef = finlist;
3528 continue;
3529 case flistseen:
3530 if (plainc || declarations)
3532 make_C_tag (true); /* a function */
3533 fvdef = fignore;
3535 break;
3536 default:
3537 break;
3539 if (structdef == stagseen && !cjava)
3541 popclass_above (bracelev);
3542 structdef = snone;
3544 break;
3545 case dsharpseen:
3546 savetoken = token;
3547 break;
3548 default:
3549 break;
3551 if (!yacc_rules || lp == newlb.buffer + 1)
3553 tokoff = lp - 1 - newlb.buffer;
3554 toklen = 1;
3555 midtoken = true;
3557 continue;
3558 } /* if (begtoken) */
3559 } /* if must look at token */
3562 /* Detect end of line, colon, comma, semicolon and various braces
3563 after having handled a token.*/
3564 switch (c)
3566 case ':':
3567 if (inattribute)
3568 break;
3569 if (yacc_rules && token.offset == 0 && token.valid)
3571 make_C_tag (false); /* a yacc function */
3572 break;
3574 if (definedef != dnone)
3575 break;
3576 switch (objdef)
3578 case otagseen:
3579 objdef = oignore;
3580 make_C_tag (true); /* an Objective C class */
3581 break;
3582 case omethodtag:
3583 case omethodparm:
3584 objdef = omethodcolon;
3585 if (class_qualify)
3587 int toklen = token_name.len;
3588 linebuffer_setlen (&token_name, toklen + 1);
3589 strcpy (token_name.buffer + toklen, ":");
3591 break;
3592 default:
3593 break;
3595 if (structdef == stagseen)
3597 structdef = scolonseen;
3598 break;
3600 /* Should be useless, but may be work as a safety net. */
3601 if (cplpl && fvdef == flistseen)
3603 make_C_tag (true); /* a function */
3604 fvdef = fignore;
3605 break;
3607 break;
3608 case ';':
3609 if (definedef != dnone || inattribute)
3610 break;
3611 switch (typdef)
3613 case tend:
3614 case ttypeseen:
3615 make_C_tag (false); /* a typedef */
3616 typdef = tnone;
3617 fvdef = fvnone;
3618 break;
3619 case tnone:
3620 case tinbody:
3621 case tignore:
3622 switch (fvdef)
3624 case fignore:
3625 if (typdef == tignore || cplpl)
3626 fvdef = fvnone;
3627 break;
3628 case fvnameseen:
3629 if ((globals && bracelev == 0 && (!fvextern || declarations))
3630 || (members && instruct))
3631 make_C_tag (false); /* a variable */
3632 fvextern = false;
3633 fvdef = fvnone;
3634 token.valid = false;
3635 break;
3636 case flistseen:
3637 if ((declarations
3638 && (cplpl || !instruct)
3639 && (typdef == tnone || (typdef != tignore && instruct)))
3640 || (members
3641 && plainc && instruct))
3642 make_C_tag (true); /* a function */
3643 /* FALLTHRU */
3644 default:
3645 fvextern = false;
3646 fvdef = fvnone;
3647 if (declarations
3648 && cplpl && structdef == stagseen)
3649 make_C_tag (false); /* forward declaration */
3650 else
3651 token.valid = false;
3652 } /* switch (fvdef) */
3653 /* FALLTHRU */
3654 default:
3655 if (!instruct)
3656 typdef = tnone;
3658 if (structdef == stagseen)
3659 structdef = snone;
3660 break;
3661 case ',':
3662 if (definedef != dnone || inattribute)
3663 break;
3664 switch (objdef)
3666 case omethodtag:
3667 case omethodparm:
3668 make_C_tag (true); /* an Objective C method */
3669 objdef = oinbody;
3670 break;
3671 default:
3672 break;
3674 switch (fvdef)
3676 case fdefunkey:
3677 case foperator:
3678 case fstartlist:
3679 case finlist:
3680 case fignore:
3681 break;
3682 case vignore:
3683 if (instruct && parlev == 0)
3684 fvdef = fvnone;
3685 break;
3686 case fdefunname:
3687 fvdef = fignore;
3688 break;
3689 case fvnameseen:
3690 if (parlev == 0
3691 && ((globals
3692 && bracelev == 0
3693 && templatelev == 0
3694 && (!fvextern || declarations))
3695 || (members && instruct)))
3696 make_C_tag (false); /* a variable */
3697 break;
3698 case flistseen:
3699 if ((declarations && typdef == tnone && !instruct)
3700 || (members && typdef != tignore && instruct))
3702 make_C_tag (true); /* a function */
3703 fvdef = fvnameseen;
3705 else if (!declarations)
3706 fvdef = fvnone;
3707 token.valid = false;
3708 break;
3709 default:
3710 fvdef = fvnone;
3712 if (structdef == stagseen)
3713 structdef = snone;
3714 break;
3715 case ']':
3716 if (definedef != dnone || inattribute)
3717 break;
3718 if (structdef == stagseen)
3719 structdef = snone;
3720 switch (typdef)
3722 case ttypeseen:
3723 case tend:
3724 typdef = tignore;
3725 make_C_tag (false); /* a typedef */
3726 break;
3727 case tnone:
3728 case tinbody:
3729 switch (fvdef)
3731 case foperator:
3732 case finlist:
3733 case fignore:
3734 case vignore:
3735 break;
3736 case fvnameseen:
3737 if ((members && bracelev == 1)
3738 || (globals && bracelev == 0
3739 && (!fvextern || declarations)))
3740 make_C_tag (false); /* a variable */
3741 /* FALLTHRU */
3742 default:
3743 fvdef = fvnone;
3745 break;
3746 default:
3747 break;
3749 break;
3750 case '(':
3751 if (inattribute)
3753 attrparlev++;
3754 break;
3756 if (definedef != dnone)
3757 break;
3758 if (objdef == otagseen && parlev == 0)
3759 objdef = oparenseen;
3760 switch (fvdef)
3762 case fvnameseen:
3763 if (typdef == ttypeseen
3764 && *lp != '*'
3765 && !instruct)
3767 /* This handles constructs like:
3768 typedef void OperatorFun (int fun); */
3769 make_C_tag (false);
3770 typdef = tignore;
3771 fvdef = fignore;
3772 break;
3774 /* FALLTHRU */
3775 case foperator:
3776 fvdef = fstartlist;
3777 break;
3778 case flistseen:
3779 fvdef = finlist;
3780 break;
3781 default:
3782 break;
3784 parlev++;
3785 break;
3786 case ')':
3787 if (inattribute)
3789 if (--attrparlev == 0)
3790 inattribute = false;
3791 break;
3793 if (definedef != dnone)
3794 break;
3795 if (objdef == ocatseen && parlev == 1)
3797 make_C_tag (true); /* an Objective C category */
3798 objdef = oignore;
3800 if (--parlev == 0)
3802 switch (fvdef)
3804 case fstartlist:
3805 case finlist:
3806 fvdef = flistseen;
3807 break;
3808 default:
3809 break;
3811 if (!instruct
3812 && (typdef == tend
3813 || typdef == ttypeseen))
3815 typdef = tignore;
3816 make_C_tag (false); /* a typedef */
3819 else if (parlev < 0) /* can happen due to ill-conceived #if's. */
3820 parlev = 0;
3821 break;
3822 case '{':
3823 if (definedef != dnone)
3824 break;
3825 if (typdef == ttypeseen)
3827 /* Whenever typdef is set to tinbody (currently only
3828 here), typdefbracelev should be set to bracelev. */
3829 typdef = tinbody;
3830 typdefbracelev = bracelev;
3832 switch (fvdef)
3834 case flistseen:
3835 if (cplpl && !class_qualify)
3837 /* Remove class and namespace qualifiers from the token,
3838 leaving only the method/member name. */
3839 char *cc, *uqname = token_name.buffer;
3840 char *tok_end = token_name.buffer + token_name.len;
3842 for (cc = token_name.buffer; cc < tok_end; cc++)
3844 if (*cc == ':' && cc[1] == ':')
3846 uqname = cc + 2;
3847 cc++;
3850 if (uqname > token_name.buffer)
3852 int uqlen = strlen (uqname);
3853 linebuffer_setlen (&token_name, uqlen);
3854 memmove (token_name.buffer, uqname, uqlen + 1);
3857 make_C_tag (true); /* a function */
3858 /* FALLTHRU */
3859 case fignore:
3860 fvdef = fvnone;
3861 break;
3862 case fvnone:
3863 switch (objdef)
3865 case otagseen:
3866 make_C_tag (true); /* an Objective C class */
3867 objdef = oignore;
3868 break;
3869 case omethodtag:
3870 case omethodparm:
3871 make_C_tag (true); /* an Objective C method */
3872 objdef = oinbody;
3873 break;
3874 default:
3875 /* Neutralize `extern "C" {' grot. */
3876 if (bracelev == 0 && structdef == snone && nestlev == 0
3877 && typdef == tnone)
3878 bracelev = -1;
3880 break;
3881 default:
3882 break;
3884 switch (structdef)
3886 case skeyseen: /* unnamed struct */
3887 pushclass_above (bracelev, NULL, 0);
3888 structdef = snone;
3889 break;
3890 case stagseen: /* named struct or enum */
3891 case scolonseen: /* a class */
3892 pushclass_above (bracelev,token.line+token.offset, token.length);
3893 structdef = snone;
3894 make_C_tag (false); /* a struct or enum */
3895 break;
3896 default:
3897 break;
3899 bracelev += 1;
3900 break;
3901 case '*':
3902 if (definedef != dnone)
3903 break;
3904 if (fvdef == fstartlist)
3906 fvdef = fvnone; /* avoid tagging `foo' in `foo (*bar()) ()' */
3907 token.valid = false;
3909 break;
3910 case '}':
3911 if (definedef != dnone)
3912 break;
3913 bracelev -= 1;
3914 if (!ignoreindent && lp == newlb.buffer + 1)
3916 if (bracelev != 0)
3917 token.valid = false; /* unexpected value, token unreliable */
3918 bracelev = 0; /* reset brace level if first column */
3919 parlev = 0; /* also reset paren level, just in case... */
3921 else if (bracelev < 0)
3923 token.valid = false; /* something gone amiss, token unreliable */
3924 bracelev = 0;
3926 if (bracelev == 0 && fvdef == vignore)
3927 fvdef = fvnone; /* end of function */
3928 popclass_above (bracelev);
3929 structdef = snone;
3930 /* Only if typdef == tinbody is typdefbracelev significant. */
3931 if (typdef == tinbody && bracelev <= typdefbracelev)
3933 assert (bracelev == typdefbracelev);
3934 typdef = tend;
3936 break;
3937 case '=':
3938 if (definedef != dnone)
3939 break;
3940 switch (fvdef)
3942 case foperator:
3943 case finlist:
3944 case fignore:
3945 case vignore:
3946 break;
3947 case fvnameseen:
3948 if ((members && bracelev == 1)
3949 || (globals && bracelev == 0 && (!fvextern || declarations)))
3950 make_C_tag (false); /* a variable */
3951 /* FALLTHRU */
3952 default:
3953 fvdef = vignore;
3955 break;
3956 case '<':
3957 if (cplpl
3958 && (structdef == stagseen || fvdef == fvnameseen))
3960 templatelev++;
3961 break;
3963 goto resetfvdef;
3964 case '>':
3965 if (templatelev > 0)
3967 templatelev--;
3968 break;
3970 goto resetfvdef;
3971 case '+':
3972 case '-':
3973 if (objdef == oinbody && bracelev == 0)
3975 objdef = omethodsign;
3976 break;
3978 /* FALLTHRU */
3979 resetfvdef:
3980 case '#': case '~': case '&': case '%': case '/':
3981 case '|': case '^': case '!': case '.': case '?':
3982 if (definedef != dnone)
3983 break;
3984 /* These surely cannot follow a function tag in C. */
3985 switch (fvdef)
3987 case foperator:
3988 case finlist:
3989 case fignore:
3990 case vignore:
3991 break;
3992 default:
3993 fvdef = fvnone;
3995 break;
3996 case '\0':
3997 if (objdef == otagseen)
3999 make_C_tag (true); /* an Objective C class */
4000 objdef = oignore;
4002 /* If a macro spans multiple lines don't reset its state. */
4003 if (quotednl)
4004 CNL_SAVE_DEFINEDEF ();
4005 else
4006 CNL ();
4007 break;
4008 } /* switch (c) */
4010 } /* while not eof */
4012 free (lbs[0].lb.buffer);
4013 free (lbs[1].lb.buffer);
4017 * Process either a C++ file or a C file depending on the setting
4018 * of a global flag.
4020 static void
4021 default_C_entries (FILE *inf)
4023 C_entries (cplusplus ? C_PLPL : C_AUTO, inf);
4026 /* Always do plain C. */
4027 static void
4028 plain_C_entries (FILE *inf)
4030 C_entries (0, inf);
4033 /* Always do C++. */
4034 static void
4035 Cplusplus_entries (FILE *inf)
4037 C_entries (C_PLPL, inf);
4040 /* Always do Java. */
4041 static void
4042 Cjava_entries (FILE *inf)
4044 C_entries (C_JAVA, inf);
4047 /* Always do C*. */
4048 static void
4049 Cstar_entries (FILE *inf)
4051 C_entries (C_STAR, inf);
4054 /* Always do Yacc. */
4055 static void
4056 Yacc_entries (FILE *inf)
4058 C_entries (YACC, inf);
4062 /* Useful macros. */
4063 #define LOOP_ON_INPUT_LINES(file_pointer, line_buffer, char_pointer) \
4064 while (perhaps_more_input (file_pointer) \
4065 && (readline (&(line_buffer), file_pointer), \
4066 (char_pointer) = (line_buffer).buffer, \
4067 true)) \
4069 #define LOOKING_AT(cp, kw) /* kw is the keyword, a literal string */ \
4070 ((assert ("" kw), true) /* syntax error if not a literal string */ \
4071 && strneq ((cp), kw, sizeof (kw)-1) /* cp points at kw */ \
4072 && notinname ((cp)[sizeof (kw)-1]) /* end of kw */ \
4073 && ((cp) = skip_spaces ((cp)+sizeof (kw)-1))) /* skip spaces */
4075 /* Similar to LOOKING_AT but does not use notinname, does not skip */
4076 #define LOOKING_AT_NOCASE(cp, kw) /* the keyword is a literal string */ \
4077 ((assert ("" kw), true) /* syntax error if not a literal string */ \
4078 && strncaseeq ((cp), kw, sizeof (kw)-1) /* cp points at kw */ \
4079 && ((cp) += sizeof (kw)-1)) /* skip spaces */
4082 * Read a file, but do no processing. This is used to do regexp
4083 * matching on files that have no language defined.
4085 static void
4086 just_read_file (FILE *inf)
4088 while (perhaps_more_input (inf))
4089 readline (&lb, inf);
4093 /* Fortran parsing */
4095 static void F_takeprec (void);
4096 static void F_getit (FILE *);
4098 static void
4099 F_takeprec (void)
4101 dbp = skip_spaces (dbp);
4102 if (*dbp != '*')
4103 return;
4104 dbp++;
4105 dbp = skip_spaces (dbp);
4106 if (strneq (dbp, "(*)", 3))
4108 dbp += 3;
4109 return;
4111 if (!c_isdigit (*dbp))
4113 --dbp; /* force failure */
4114 return;
4117 dbp++;
4118 while (c_isdigit (*dbp));
4121 static void
4122 F_getit (FILE *inf)
4124 register char *cp;
4126 dbp = skip_spaces (dbp);
4127 if (*dbp == '\0')
4129 readline (&lb, inf);
4130 dbp = lb.buffer;
4131 if (dbp[5] != '&')
4132 return;
4133 dbp += 6;
4134 dbp = skip_spaces (dbp);
4136 if (!c_isalpha (*dbp) && *dbp != '_' && *dbp != '$')
4137 return;
4138 for (cp = dbp + 1; *cp != '\0' && intoken (*cp); cp++)
4139 continue;
4140 make_tag (dbp, cp-dbp, true,
4141 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4145 static void
4146 Fortran_functions (FILE *inf)
4148 LOOP_ON_INPUT_LINES (inf, lb, dbp)
4150 if (*dbp == '%')
4151 dbp++; /* Ratfor escape to fortran */
4152 dbp = skip_spaces (dbp);
4153 if (*dbp == '\0')
4154 continue;
4156 if (LOOKING_AT_NOCASE (dbp, "recursive"))
4157 dbp = skip_spaces (dbp);
4159 if (LOOKING_AT_NOCASE (dbp, "pure"))
4160 dbp = skip_spaces (dbp);
4162 if (LOOKING_AT_NOCASE (dbp, "elemental"))
4163 dbp = skip_spaces (dbp);
4165 switch (c_tolower (*dbp))
4167 case 'i':
4168 if (nocase_tail ("integer"))
4169 F_takeprec ();
4170 break;
4171 case 'r':
4172 if (nocase_tail ("real"))
4173 F_takeprec ();
4174 break;
4175 case 'l':
4176 if (nocase_tail ("logical"))
4177 F_takeprec ();
4178 break;
4179 case 'c':
4180 if (nocase_tail ("complex") || nocase_tail ("character"))
4181 F_takeprec ();
4182 break;
4183 case 'd':
4184 if (nocase_tail ("double"))
4186 dbp = skip_spaces (dbp);
4187 if (*dbp == '\0')
4188 continue;
4189 if (nocase_tail ("precision"))
4190 break;
4191 continue;
4193 break;
4195 dbp = skip_spaces (dbp);
4196 if (*dbp == '\0')
4197 continue;
4198 switch (c_tolower (*dbp))
4200 case 'f':
4201 if (nocase_tail ("function"))
4202 F_getit (inf);
4203 continue;
4204 case 's':
4205 if (nocase_tail ("subroutine"))
4206 F_getit (inf);
4207 continue;
4208 case 'e':
4209 if (nocase_tail ("entry"))
4210 F_getit (inf);
4211 continue;
4212 case 'b':
4213 if (nocase_tail ("blockdata") || nocase_tail ("block data"))
4215 dbp = skip_spaces (dbp);
4216 if (*dbp == '\0') /* assume un-named */
4217 make_tag ("blockdata", 9, true,
4218 lb.buffer, dbp - lb.buffer, lineno, linecharno);
4219 else
4220 F_getit (inf); /* look for name */
4222 continue;
4229 * Go language support
4230 * Original code by Xi Lu <lx@shellcodes.org> (2016)
4232 static void
4233 Go_functions(FILE *inf)
4235 char *cp, *name;
4237 LOOP_ON_INPUT_LINES(inf, lb, cp)
4239 cp = skip_spaces (cp);
4241 if (LOOKING_AT (cp, "package"))
4243 name = cp;
4244 while (!notinname (*cp) && *cp != '\0')
4245 cp++;
4246 make_tag (name, cp - name, false, lb.buffer,
4247 cp - lb.buffer + 1, lineno, linecharno);
4249 else if (LOOKING_AT (cp, "func"))
4251 /* Go implementation of interface, such as:
4252 func (n *Integer) Add(m Integer) ...
4253 skip `(n *Integer)` part.
4255 if (*cp == '(')
4257 while (*cp != ')')
4258 cp++;
4259 cp = skip_spaces (cp+1);
4262 if (*cp)
4264 name = cp;
4266 while (!notinname (*cp))
4267 cp++;
4269 make_tag (name, cp - name, true, lb.buffer,
4270 cp - lb.buffer + 1, lineno, linecharno);
4273 else if (members && LOOKING_AT (cp, "type"))
4275 name = cp;
4277 /* Ignore the likes of the following:
4278 type (
4282 if (*cp == '(')
4283 return;
4285 while (!notinname (*cp) && *cp != '\0')
4286 cp++;
4288 make_tag (name, cp - name, false, lb.buffer,
4289 cp - lb.buffer + 1, lineno, linecharno);
4296 * Ada parsing
4297 * Original code by
4298 * Philippe Waroquiers (1998)
4301 /* Once we are positioned after an "interesting" keyword, let's get
4302 the real tag value necessary. */
4303 static void
4304 Ada_getit (FILE *inf, const char *name_qualifier)
4306 register char *cp;
4307 char *name;
4308 char c;
4310 while (perhaps_more_input (inf))
4312 dbp = skip_spaces (dbp);
4313 if (*dbp == '\0'
4314 || (dbp[0] == '-' && dbp[1] == '-'))
4316 readline (&lb, inf);
4317 dbp = lb.buffer;
4319 switch (c_tolower (*dbp))
4321 case 'b':
4322 if (nocase_tail ("body"))
4324 /* Skipping body of procedure body or package body or ....
4325 resetting qualifier to body instead of spec. */
4326 name_qualifier = "/b";
4327 continue;
4329 break;
4330 case 't':
4331 /* Skipping type of task type or protected type ... */
4332 if (nocase_tail ("type"))
4333 continue;
4334 break;
4336 if (*dbp == '"')
4338 dbp += 1;
4339 for (cp = dbp; *cp != '\0' && *cp != '"'; cp++)
4340 continue;
4342 else
4344 dbp = skip_spaces (dbp);
4345 for (cp = dbp;
4346 c_isalnum (*cp) || *cp == '_' || *cp == '.';
4347 cp++)
4348 continue;
4349 if (cp == dbp)
4350 return;
4352 c = *cp;
4353 *cp = '\0';
4354 name = concat (dbp, name_qualifier, "");
4355 *cp = c;
4356 make_tag (name, strlen (name), true,
4357 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4358 free (name);
4359 if (c == '"')
4360 dbp = cp + 1;
4361 return;
4365 static void
4366 Ada_funcs (FILE *inf)
4368 bool inquote = false;
4369 bool skip_till_semicolumn = false;
4371 LOOP_ON_INPUT_LINES (inf, lb, dbp)
4373 while (*dbp != '\0')
4375 /* Skip a string i.e. "abcd". */
4376 if (inquote || (*dbp == '"'))
4378 dbp = strchr (dbp + !inquote, '"');
4379 if (dbp != NULL)
4381 inquote = false;
4382 dbp += 1;
4383 continue; /* advance char */
4385 else
4387 inquote = true;
4388 break; /* advance line */
4392 /* Skip comments. */
4393 if (dbp[0] == '-' && dbp[1] == '-')
4394 break; /* advance line */
4396 /* Skip character enclosed in single quote i.e. 'a'
4397 and skip single quote starting an attribute i.e. 'Image. */
4398 if (*dbp == '\'')
4400 dbp++ ;
4401 if (*dbp != '\0')
4402 dbp++;
4403 continue;
4406 if (skip_till_semicolumn)
4408 if (*dbp == ';')
4409 skip_till_semicolumn = false;
4410 dbp++;
4411 continue; /* advance char */
4414 /* Search for beginning of a token. */
4415 if (!begtoken (*dbp))
4417 dbp++;
4418 continue; /* advance char */
4421 /* We are at the beginning of a token. */
4422 switch (c_tolower (*dbp))
4424 case 'f':
4425 if (!packages_only && nocase_tail ("function"))
4426 Ada_getit (inf, "/f");
4427 else
4428 break; /* from switch */
4429 continue; /* advance char */
4430 case 'p':
4431 if (!packages_only && nocase_tail ("procedure"))
4432 Ada_getit (inf, "/p");
4433 else if (nocase_tail ("package"))
4434 Ada_getit (inf, "/s");
4435 else if (nocase_tail ("protected")) /* protected type */
4436 Ada_getit (inf, "/t");
4437 else
4438 break; /* from switch */
4439 continue; /* advance char */
4441 case 'u':
4442 if (typedefs && !packages_only && nocase_tail ("use"))
4444 /* when tagging types, avoid tagging use type Pack.Typename;
4445 for this, we will skip everything till a ; */
4446 skip_till_semicolumn = true;
4447 continue; /* advance char */
4450 case 't':
4451 if (!packages_only && nocase_tail ("task"))
4452 Ada_getit (inf, "/k");
4453 else if (typedefs && !packages_only && nocase_tail ("type"))
4455 Ada_getit (inf, "/t");
4456 while (*dbp != '\0')
4457 dbp += 1;
4459 else
4460 break; /* from switch */
4461 continue; /* advance char */
4464 /* Look for the end of the token. */
4465 while (!endtoken (*dbp))
4466 dbp++;
4468 } /* advance char */
4469 } /* advance line */
4474 * Unix and microcontroller assembly tag handling
4475 * Labels: /^[a-zA-Z_.$][a-zA_Z0-9_.$]*[: ^I^J]/
4476 * Idea by Bob Weiner, Motorola Inc. (1994)
4478 static void
4479 Asm_labels (FILE *inf)
4481 register char *cp;
4483 LOOP_ON_INPUT_LINES (inf, lb, cp)
4485 /* If first char is alphabetic or one of [_.$], test for colon
4486 following identifier. */
4487 if (c_isalpha (*cp) || *cp == '_' || *cp == '.' || *cp == '$')
4489 /* Read past label. */
4490 cp++;
4491 while (c_isalnum (*cp) || *cp == '_' || *cp == '.' || *cp == '$')
4492 cp++;
4493 if (*cp == ':' || c_isspace (*cp))
4494 /* Found end of label, so copy it and add it to the table. */
4495 make_tag (lb.buffer, cp - lb.buffer, true,
4496 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4503 * Perl support
4504 * Perl sub names: /^sub[ \t\n]+[^ \t\n{]+/
4505 * /^use constant[ \t\n]+[^ \t\n{=,;]+/
4506 * Perl variable names: /^(my|local).../
4507 * Original code by Bart Robinson <lomew@cs.utah.edu> (1995)
4508 * Additions by Michael Ernst <mernst@alum.mit.edu> (1997)
4509 * Ideas by Kai Großjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE> (2001)
4511 static void
4512 Perl_functions (FILE *inf)
4514 char *package = savestr ("main"); /* current package name */
4515 register char *cp;
4517 LOOP_ON_INPUT_LINES (inf, lb, cp)
4519 cp = skip_spaces (cp);
4521 if (LOOKING_AT (cp, "package"))
4523 free (package);
4524 get_tag (cp, &package);
4526 else if (LOOKING_AT (cp, "sub"))
4528 char *pos, *sp;
4530 subr:
4531 sp = cp;
4532 while (!notinname (*cp))
4533 cp++;
4534 if (cp == sp)
4535 continue; /* nothing found */
4536 pos = strchr (sp, ':');
4537 if (pos && pos < cp && pos[1] == ':')
4539 /* The name is already qualified. */
4540 if (!class_qualify)
4542 char *q = pos + 2, *qpos;
4543 while ((qpos = strchr (q, ':')) != NULL
4544 && qpos < cp
4545 && qpos[1] == ':')
4546 q = qpos + 2;
4547 sp = q;
4549 make_tag (sp, cp - sp, true,
4550 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4552 else if (class_qualify)
4553 /* Qualify it. */
4555 char savechar, *name;
4557 savechar = *cp;
4558 *cp = '\0';
4559 name = concat (package, "::", sp);
4560 *cp = savechar;
4561 make_tag (name, strlen (name), true,
4562 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4563 free (name);
4565 else
4566 make_tag (sp, cp - sp, true,
4567 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4569 else if (LOOKING_AT (cp, "use constant")
4570 || LOOKING_AT (cp, "use constant::defer"))
4572 /* For hash style multi-constant like
4573 use constant { FOO => 123,
4574 BAR => 456 };
4575 only the first FOO is picked up. Parsing across the value
4576 expressions would be difficult in general, due to possible nested
4577 hashes, here-documents, etc. */
4578 if (*cp == '{')
4579 cp = skip_spaces (cp+1);
4580 goto subr;
4582 else if (globals) /* only if we are tagging global vars */
4584 /* Skip a qualifier, if any. */
4585 bool qual = LOOKING_AT (cp, "my") || LOOKING_AT (cp, "local");
4586 /* After "my" or "local", but before any following paren or space. */
4587 char *varstart = cp;
4589 if (qual /* should this be removed? If yes, how? */
4590 && (*cp == '$' || *cp == '@' || *cp == '%'))
4592 varstart += 1;
4594 cp++;
4595 while (c_isalnum (*cp) || *cp == '_');
4597 else if (qual)
4599 /* Should be examining a variable list at this point;
4600 could insist on seeing an open parenthesis. */
4601 while (*cp != '\0' && *cp != ';' && *cp != '=' && *cp != ')')
4602 cp++;
4604 else
4605 continue;
4607 make_tag (varstart, cp - varstart, false,
4608 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4611 free (package);
4616 * Python support
4617 * Look for /^[\t]*def[ \t\n]+[^ \t\n(:]+/ or /^class[ \t\n]+[^ \t\n(:]+/
4618 * Idea by Eric S. Raymond <esr@thyrsus.com> (1997)
4619 * More ideas by seb bacon <seb@jamkit.com> (2002)
4621 static void
4622 Python_functions (FILE *inf)
4624 register char *cp;
4626 LOOP_ON_INPUT_LINES (inf, lb, cp)
4628 cp = skip_spaces (cp);
4629 if (LOOKING_AT (cp, "def") || LOOKING_AT (cp, "class"))
4631 char *name = cp;
4632 while (!notinname (*cp) && *cp != ':')
4633 cp++;
4634 make_tag (name, cp - name, true,
4635 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4641 * Ruby support
4642 * Original code by Xi Lu <lx@shellcodes.org> (2015)
4644 static void
4645 Ruby_functions (FILE *inf)
4647 char *cp = NULL;
4648 bool reader = false, writer = false, alias = false, continuation = false;
4650 LOOP_ON_INPUT_LINES (inf, lb, cp)
4652 bool is_class = false;
4653 bool is_method = false;
4654 char *name;
4656 cp = skip_spaces (cp);
4657 if (!continuation
4658 /* Constants. */
4659 && c_isalpha (*cp) && c_isupper (*cp))
4661 char *bp, *colon = NULL;
4663 name = cp;
4665 for (cp++; c_isalnum (*cp) || *cp == '_' || *cp == ':'; cp++)
4667 if (*cp == ':')
4668 colon = cp;
4670 if (cp > name + 1)
4672 bp = skip_spaces (cp);
4673 if (*bp == '=' && !(bp[1] == '=' || bp[1] == '>'))
4675 if (colon && !c_isspace (colon[1]))
4676 name = colon + 1;
4677 make_tag (name, cp - name, false,
4678 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4682 else if (!continuation
4683 /* Modules, classes, methods. */
4684 && ((is_method = LOOKING_AT (cp, "def"))
4685 || (is_class = LOOKING_AT (cp, "class"))
4686 || LOOKING_AT (cp, "module")))
4688 const char self_name[] = "self.";
4689 const size_t self_size1 = sizeof (self_name) - 1;
4691 name = cp;
4693 /* Ruby method names can end in a '='. Also, operator overloading can
4694 define operators whose names include '='. */
4695 while (!notinname (*cp) || *cp == '=')
4696 cp++;
4698 /* Remove "self." from the method name. */
4699 if (cp - name > self_size1
4700 && strneq (name, self_name, self_size1))
4701 name += self_size1;
4703 /* Remove the class/module qualifiers from method names. */
4704 if (is_method)
4706 char *q;
4708 for (q = name; q < cp && *q != '.'; q++)
4710 if (q < cp - 1) /* punt if we see just "FOO." */
4711 name = q + 1;
4714 /* Don't tag singleton classes. */
4715 if (is_class && strneq (name, "<<", 2) && cp == name + 2)
4716 continue;
4718 make_tag (name, cp - name, true,
4719 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4721 else
4723 /* Tag accessors and aliases. */
4725 if (!continuation)
4726 reader = writer = alias = false;
4728 while (*cp && *cp != '#')
4730 if (!continuation)
4732 reader = writer = alias = false;
4733 if (LOOKING_AT (cp, "attr_reader"))
4734 reader = true;
4735 else if (LOOKING_AT (cp, "attr_writer"))
4736 writer = true;
4737 else if (LOOKING_AT (cp, "attr_accessor"))
4739 reader = true;
4740 writer = true;
4742 else if (LOOKING_AT (cp, "alias_method"))
4743 alias = true;
4745 if (reader || writer || alias)
4747 do {
4748 char *np;
4750 cp = skip_spaces (cp);
4751 if (*cp == '(')
4752 cp = skip_spaces (cp + 1);
4753 np = cp;
4754 cp = skip_name (cp);
4755 if (*np != ':')
4756 continue;
4757 np++;
4758 if (reader)
4760 make_tag (np, cp - np, true,
4761 lb.buffer, cp - lb.buffer + 1,
4762 lineno, linecharno);
4763 continuation = false;
4765 if (writer)
4767 size_t name_len = cp - np + 1;
4768 char *wr_name = xnew (name_len + 1, char);
4770 memcpy (wr_name, np, name_len - 1);
4771 memcpy (wr_name + name_len - 1, "=", 2);
4772 pfnote (wr_name, true, lb.buffer, cp - lb.buffer + 1,
4773 lineno, linecharno);
4774 continuation = false;
4776 if (alias)
4778 if (!continuation)
4779 make_tag (np, cp - np, true,
4780 lb.buffer, cp - lb.buffer + 1,
4781 lineno, linecharno);
4782 continuation = false;
4783 while (*cp && *cp != '#' && *cp != ';')
4785 if (*cp == ',')
4786 continuation = true;
4787 else if (!c_isspace (*cp))
4788 continuation = false;
4789 cp++;
4791 if (*cp == ';')
4792 continuation = false;
4794 cp = skip_spaces (cp);
4795 } while ((alias
4796 ? (*cp == ',')
4797 : (continuation = (*cp == ',')))
4798 && (cp = skip_spaces (cp + 1), *cp && *cp != '#'));
4800 if (*cp != '#')
4801 cp = skip_name (cp);
4802 while (*cp && *cp != '#' && notinname (*cp))
4803 cp++;
4811 * PHP support
4812 * Look for:
4813 * - /^[ \t]*function[ \t\n]+[^ \t\n(]+/
4814 * - /^[ \t]*class[ \t\n]+[^ \t\n]+/
4815 * - /^[ \t]*define\(\"[^\"]+/
4816 * Only with --members:
4817 * - /^[ \t]*var[ \t\n]+\$[^ \t\n=;]/
4818 * Idea by Diez B. Roggisch (2001)
4820 static void
4821 PHP_functions (FILE *inf)
4823 char *cp, *name;
4824 bool search_identifier = false;
4826 LOOP_ON_INPUT_LINES (inf, lb, cp)
4828 cp = skip_spaces (cp);
4829 name = cp;
4830 if (search_identifier
4831 && *cp != '\0')
4833 while (!notinname (*cp))
4834 cp++;
4835 make_tag (name, cp - name, true,
4836 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4837 search_identifier = false;
4839 else if (LOOKING_AT (cp, "function"))
4841 if (*cp == '&')
4842 cp = skip_spaces (cp+1);
4843 if (*cp != '\0')
4845 name = cp;
4846 while (!notinname (*cp))
4847 cp++;
4848 make_tag (name, cp - name, true,
4849 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4851 else
4852 search_identifier = true;
4854 else if (LOOKING_AT (cp, "class"))
4856 if (*cp != '\0')
4858 name = cp;
4859 while (*cp != '\0' && !c_isspace (*cp))
4860 cp++;
4861 make_tag (name, cp - name, false,
4862 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4864 else
4865 search_identifier = true;
4867 else if (strneq (cp, "define", 6)
4868 && (cp = skip_spaces (cp+6))
4869 && *cp++ == '('
4870 && (*cp == '"' || *cp == '\''))
4872 char quote = *cp++;
4873 name = cp;
4874 while (*cp != quote && *cp != '\0')
4875 cp++;
4876 make_tag (name, cp - name, false,
4877 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4879 else if (members
4880 && LOOKING_AT (cp, "var")
4881 && *cp == '$')
4883 name = cp;
4884 while (!notinname (*cp))
4885 cp++;
4886 make_tag (name, cp - name, false,
4887 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
4894 * Cobol tag functions
4895 * We could look for anything that could be a paragraph name.
4896 * i.e. anything that starts in column 8 is one word and ends in a full stop.
4897 * Idea by Corny de Souza (1993)
4899 static void
4900 Cobol_paragraphs (FILE *inf)
4902 register char *bp, *ep;
4904 LOOP_ON_INPUT_LINES (inf, lb, bp)
4906 if (lb.len < 9)
4907 continue;
4908 bp += 8;
4910 /* If eoln, compiler option or comment ignore whole line. */
4911 if (bp[-1] != ' ' || !c_isalnum (bp[0]))
4912 continue;
4914 for (ep = bp; c_isalnum (*ep) || *ep == '-'; ep++)
4915 continue;
4916 if (*ep++ == '.')
4917 make_tag (bp, ep - bp, true,
4918 lb.buffer, ep - lb.buffer + 1, lineno, linecharno);
4924 * Makefile support
4925 * Ideas by Assar Westerlund <assar@sics.se> (2001)
4927 static void
4928 Makefile_targets (FILE *inf)
4930 register char *bp;
4932 LOOP_ON_INPUT_LINES (inf, lb, bp)
4934 if (*bp == '\t' || *bp == '#')
4935 continue;
4936 while (*bp != '\0' && *bp != '=' && *bp != ':')
4937 bp++;
4938 if (*bp == ':' || (globals && *bp == '='))
4940 /* We should detect if there is more than one tag, but we do not.
4941 We just skip initial and final spaces. */
4942 char * namestart = skip_spaces (lb.buffer);
4943 while (--bp > namestart)
4944 if (!notinname (*bp))
4945 break;
4946 make_tag (namestart, bp - namestart + 1, true,
4947 lb.buffer, bp - lb.buffer + 2, lineno, linecharno);
4954 * Pascal parsing
4955 * Original code by Mosur K. Mohan (1989)
4957 * Locates tags for procedures & functions. Doesn't do any type- or
4958 * var-definitions. It does look for the keyword "extern" or
4959 * "forward" immediately following the procedure statement; if found,
4960 * the tag is skipped.
4962 static void
4963 Pascal_functions (FILE *inf)
4965 linebuffer tline; /* mostly copied from C_entries */
4966 long save_lcno;
4967 int save_lineno, namelen, taglen;
4968 char c, *name;
4970 bool /* each of these flags is true if: */
4971 incomment, /* point is inside a comment */
4972 inquote, /* point is inside '..' string */
4973 get_tagname, /* point is after PROCEDURE/FUNCTION
4974 keyword, so next item = potential tag */
4975 found_tag, /* point is after a potential tag */
4976 inparms, /* point is within parameter-list */
4977 verify_tag; /* point has passed the parm-list, so the
4978 next token will determine whether this
4979 is a FORWARD/EXTERN to be ignored, or
4980 whether it is a real tag */
4982 save_lcno = save_lineno = namelen = taglen = 0; /* keep compiler quiet */
4983 name = NULL; /* keep compiler quiet */
4984 dbp = lb.buffer;
4985 *dbp = '\0';
4986 linebuffer_init (&tline);
4988 incomment = inquote = false;
4989 found_tag = false; /* have a proc name; check if extern */
4990 get_tagname = false; /* found "procedure" keyword */
4991 inparms = false; /* found '(' after "proc" */
4992 verify_tag = false; /* check if "extern" is ahead */
4995 while (perhaps_more_input (inf)) /* long main loop to get next char */
4997 c = *dbp++;
4998 if (c == '\0') /* if end of line */
5000 readline (&lb, inf);
5001 dbp = lb.buffer;
5002 if (*dbp == '\0')
5003 continue;
5004 if (!((found_tag && verify_tag)
5005 || get_tagname))
5006 c = *dbp++; /* only if don't need *dbp pointing
5007 to the beginning of the name of
5008 the procedure or function */
5010 if (incomment)
5012 if (c == '}') /* within { } comments */
5013 incomment = false;
5014 else if (c == '*' && *dbp == ')') /* within (* *) comments */
5016 dbp++;
5017 incomment = false;
5019 continue;
5021 else if (inquote)
5023 if (c == '\'')
5024 inquote = false;
5025 continue;
5027 else
5028 switch (c)
5030 case '\'':
5031 inquote = true; /* found first quote */
5032 continue;
5033 case '{': /* found open { comment */
5034 incomment = true;
5035 continue;
5036 case '(':
5037 if (*dbp == '*') /* found open (* comment */
5039 incomment = true;
5040 dbp++;
5042 else if (found_tag) /* found '(' after tag, i.e., parm-list */
5043 inparms = true;
5044 continue;
5045 case ')': /* end of parms list */
5046 if (inparms)
5047 inparms = false;
5048 continue;
5049 case ';':
5050 if (found_tag && !inparms) /* end of proc or fn stmt */
5052 verify_tag = true;
5053 break;
5055 continue;
5057 if (found_tag && verify_tag && (*dbp != ' '))
5059 /* Check if this is an "extern" declaration. */
5060 if (*dbp == '\0')
5061 continue;
5062 if (c_tolower (*dbp) == 'e')
5064 if (nocase_tail ("extern")) /* superfluous, really! */
5066 found_tag = false;
5067 verify_tag = false;
5070 else if (c_tolower (*dbp) == 'f')
5072 if (nocase_tail ("forward")) /* check for forward reference */
5074 found_tag = false;
5075 verify_tag = false;
5078 if (found_tag && verify_tag) /* not external proc, so make tag */
5080 found_tag = false;
5081 verify_tag = false;
5082 make_tag (name, namelen, true,
5083 tline.buffer, taglen, save_lineno, save_lcno);
5084 continue;
5087 if (get_tagname) /* grab name of proc or fn */
5089 char *cp;
5091 if (*dbp == '\0')
5092 continue;
5094 /* Find block name. */
5095 for (cp = dbp + 1; *cp != '\0' && !endtoken (*cp); cp++)
5096 continue;
5098 /* Save all values for later tagging. */
5099 linebuffer_setlen (&tline, lb.len);
5100 strcpy (tline.buffer, lb.buffer);
5101 save_lineno = lineno;
5102 save_lcno = linecharno;
5103 name = tline.buffer + (dbp - lb.buffer);
5104 namelen = cp - dbp;
5105 taglen = cp - lb.buffer + 1;
5107 dbp = cp; /* set dbp to e-o-token */
5108 get_tagname = false;
5109 found_tag = true;
5110 continue;
5112 /* And proceed to check for "extern". */
5114 else if (!incomment && !inquote && !found_tag)
5116 /* Check for proc/fn keywords. */
5117 switch (c_tolower (c))
5119 case 'p':
5120 if (nocase_tail ("rocedure")) /* c = 'p', dbp has advanced */
5121 get_tagname = true;
5122 continue;
5123 case 'f':
5124 if (nocase_tail ("unction"))
5125 get_tagname = true;
5126 continue;
5129 } /* while not eof */
5131 free (tline.buffer);
5136 * Lisp tag functions
5137 * look for (def or (DEF, quote or QUOTE
5140 static void L_getit (void);
5142 static void
5143 L_getit (void)
5145 if (*dbp == '\'') /* Skip prefix quote */
5146 dbp++;
5147 else if (*dbp == '(')
5149 dbp++;
5150 /* Try to skip "(quote " */
5151 if (!LOOKING_AT (dbp, "quote") && !LOOKING_AT (dbp, "QUOTE"))
5152 /* Ok, then skip "(" before name in (defstruct (foo)) */
5153 dbp = skip_spaces (dbp);
5155 get_tag (dbp, NULL);
5158 static void
5159 Lisp_functions (FILE *inf)
5161 LOOP_ON_INPUT_LINES (inf, lb, dbp)
5163 if (dbp[0] != '(')
5164 continue;
5166 /* "(defvar foo)" is a declaration rather than a definition. */
5167 if (! declarations)
5169 char *p = dbp + 1;
5170 if (LOOKING_AT (p, "defvar"))
5172 p = skip_name (p); /* past var name */
5173 p = skip_spaces (p);
5174 if (*p == ')')
5175 continue;
5179 if (strneq (dbp + 1, "cl-", 3) || strneq (dbp + 1, "CL-", 3))
5180 dbp += 3;
5182 if (strneq (dbp+1, "def", 3) || strneq (dbp+1, "DEF", 3))
5184 dbp = skip_non_spaces (dbp);
5185 dbp = skip_spaces (dbp);
5186 L_getit ();
5188 else
5190 /* Check for (foo::defmumble name-defined ... */
5192 dbp++;
5193 while (!notinname (*dbp) && *dbp != ':');
5194 if (*dbp == ':')
5197 dbp++;
5198 while (*dbp == ':');
5200 if (strneq (dbp, "def", 3) || strneq (dbp, "DEF", 3))
5202 dbp = skip_non_spaces (dbp);
5203 dbp = skip_spaces (dbp);
5204 L_getit ();
5213 * Lua script language parsing
5214 * Original code by David A. Capello <dacap@users.sourceforge.net> (2004)
5216 * "function" and "local function" are tags if they start at column 1.
5218 static void
5219 Lua_functions (FILE *inf)
5221 register char *bp;
5223 LOOP_ON_INPUT_LINES (inf, lb, bp)
5225 bp = skip_spaces (bp);
5226 if (bp[0] != 'f' && bp[0] != 'l')
5227 continue;
5229 (void)LOOKING_AT (bp, "local"); /* skip possible "local" */
5231 if (LOOKING_AT (bp, "function"))
5233 char *tag_name, *tp_dot, *tp_colon;
5235 get_tag (bp, &tag_name);
5236 /* If the tag ends with ".foo" or ":foo", make an additional tag for
5237 "foo". */
5238 tp_dot = strrchr (tag_name, '.');
5239 tp_colon = strrchr (tag_name, ':');
5240 if (tp_dot || tp_colon)
5242 char *p = tp_dot > tp_colon ? tp_dot : tp_colon;
5243 int len_add = p - tag_name + 1;
5245 get_tag (bp + len_add, NULL);
5253 * PostScript tags
5254 * Just look for lines where the first character is '/'
5255 * Also look at "defineps" for PSWrap
5256 * Ideas by:
5257 * Richard Mlynarik <mly@adoc.xerox.com> (1997)
5258 * Masatake Yamato <masata-y@is.aist-nara.ac.jp> (1999)
5260 static void
5261 PS_functions (FILE *inf)
5263 register char *bp, *ep;
5265 LOOP_ON_INPUT_LINES (inf, lb, bp)
5267 if (bp[0] == '/')
5269 for (ep = bp+1;
5270 *ep != '\0' && *ep != ' ' && *ep != '{';
5271 ep++)
5272 continue;
5273 make_tag (bp, ep - bp, true,
5274 lb.buffer, ep - lb.buffer + 1, lineno, linecharno);
5276 else if (LOOKING_AT (bp, "defineps"))
5277 get_tag (bp, NULL);
5283 * Forth tags
5284 * Ignore anything after \ followed by space or in ( )
5285 * Look for words defined by :
5286 * Look for constant, code, create, defer, value, and variable
5287 * OBP extensions: Look for buffer:, field,
5288 * Ideas by Eduardo Horvath <eeh@netbsd.org> (2004)
5290 static void
5291 Forth_words (FILE *inf)
5293 register char *bp;
5295 LOOP_ON_INPUT_LINES (inf, lb, bp)
5296 while ((bp = skip_spaces (bp))[0] != '\0')
5297 if (bp[0] == '\\' && c_isspace (bp[1]))
5298 break; /* read next line */
5299 else if (bp[0] == '(' && c_isspace (bp[1]))
5300 do /* skip to ) or eol */
5301 bp++;
5302 while (*bp != ')' && *bp != '\0');
5303 else if ((bp[0] == ':' && c_isspace (bp[1]) && bp++)
5304 || LOOKING_AT_NOCASE (bp, "constant")
5305 || LOOKING_AT_NOCASE (bp, "code")
5306 || LOOKING_AT_NOCASE (bp, "create")
5307 || LOOKING_AT_NOCASE (bp, "defer")
5308 || LOOKING_AT_NOCASE (bp, "value")
5309 || LOOKING_AT_NOCASE (bp, "variable")
5310 || LOOKING_AT_NOCASE (bp, "buffer:")
5311 || LOOKING_AT_NOCASE (bp, "field"))
5312 get_tag (skip_spaces (bp), NULL); /* Yay! A definition! */
5313 else
5314 bp = skip_non_spaces (bp);
5319 * Scheme tag functions
5320 * look for (def... xyzzy
5321 * (def... (xyzzy
5322 * (def ... ((...(xyzzy ....
5323 * (set! xyzzy
5324 * Original code by Ken Haase (1985?)
5326 static void
5327 Scheme_functions (FILE *inf)
5329 register char *bp;
5331 LOOP_ON_INPUT_LINES (inf, lb, bp)
5333 if (strneq (bp, "(def", 4) || strneq (bp, "(DEF", 4))
5335 bp = skip_non_spaces (bp+4);
5336 /* Skip over open parens and white space. Don't continue past
5337 '\0'. */
5338 while (*bp && notinname (*bp))
5339 bp++;
5340 get_tag (bp, NULL);
5342 if (LOOKING_AT (bp, "(SET!") || LOOKING_AT (bp, "(set!"))
5343 get_tag (bp, NULL);
5348 /* Find tags in TeX and LaTeX input files. */
5350 /* TEX_toktab is a table of TeX control sequences that define tags.
5351 * Each entry records one such control sequence.
5353 * Original code from who knows whom.
5354 * Ideas by:
5355 * Stefan Monnier (2002)
5358 static linebuffer *TEX_toktab = NULL; /* Table with tag tokens */
5360 /* Default set of control sequences to put into TEX_toktab.
5361 The value of environment var TEXTAGS is prepended to this. */
5362 static const char *TEX_defenv = "\
5363 :chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem\
5364 :part:appendix:entry:index:def\
5365 :newcommand:renewcommand:newenvironment:renewenvironment";
5367 static void TEX_decode_env (const char *, const char *);
5370 * TeX/LaTeX scanning loop.
5372 static void
5373 TeX_commands (FILE *inf)
5375 char *cp;
5376 linebuffer *key;
5378 char TEX_esc = '\0';
5379 char TEX_opgrp, TEX_clgrp;
5381 /* Initialize token table once from environment. */
5382 if (TEX_toktab == NULL)
5383 TEX_decode_env ("TEXTAGS", TEX_defenv);
5385 LOOP_ON_INPUT_LINES (inf, lb, cp)
5387 /* Look at each TEX keyword in line. */
5388 for (;;)
5390 /* Look for a TEX escape. */
5391 while (true)
5393 char c = *cp++;
5394 if (c == '\0' || c == '%')
5395 goto tex_next_line;
5397 /* Select either \ or ! as escape character, whichever comes
5398 first outside a comment. */
5399 if (!TEX_esc)
5400 switch (c)
5402 case '\\':
5403 TEX_esc = c;
5404 TEX_opgrp = '{';
5405 TEX_clgrp = '}';
5406 break;
5408 case '!':
5409 TEX_esc = c;
5410 TEX_opgrp = '<';
5411 TEX_clgrp = '>';
5412 break;
5415 if (c == TEX_esc)
5416 break;
5419 for (key = TEX_toktab; key->buffer != NULL; key++)
5420 if (strneq (cp, key->buffer, key->len))
5422 char *p;
5423 int namelen, linelen;
5424 bool opgrp = false;
5426 cp = skip_spaces (cp + key->len);
5427 if (*cp == TEX_opgrp)
5429 opgrp = true;
5430 cp++;
5432 for (p = cp;
5433 (!c_isspace (*p) && *p != '#' &&
5434 *p != TEX_opgrp && *p != TEX_clgrp);
5435 p++)
5436 continue;
5437 namelen = p - cp;
5438 linelen = lb.len;
5439 if (!opgrp || *p == TEX_clgrp)
5441 while (*p != '\0' && *p != TEX_opgrp && *p != TEX_clgrp)
5442 p++;
5443 linelen = p - lb.buffer + 1;
5445 make_tag (cp, namelen, true,
5446 lb.buffer, linelen, lineno, linecharno);
5447 goto tex_next_line; /* We only tag a line once */
5450 tex_next_line:
5455 /* Read environment and prepend it to the default string.
5456 Build token table. */
5457 static void
5458 TEX_decode_env (const char *evarname, const char *defenv)
5460 register const char *env, *p;
5461 int i, len;
5463 /* Append default string to environment. */
5464 env = getenv (evarname);
5465 if (!env)
5466 env = defenv;
5467 else
5468 env = concat (env, defenv, "");
5470 /* Allocate a token table */
5471 for (len = 1, p = env; (p = strchr (p, ':')); )
5472 if (*++p)
5473 len++;
5474 TEX_toktab = xnew (len, linebuffer);
5476 /* Unpack environment string into token table. Be careful about */
5477 /* zero-length strings (leading ':', "::" and trailing ':') */
5478 for (i = 0; *env != '\0';)
5480 p = strchr (env, ':');
5481 if (!p) /* End of environment string. */
5482 p = env + strlen (env);
5483 if (p - env > 0)
5484 { /* Only non-zero strings. */
5485 TEX_toktab[i].buffer = savenstr (env, p - env);
5486 TEX_toktab[i].len = p - env;
5487 i++;
5489 if (*p)
5490 env = p + 1;
5491 else
5493 TEX_toktab[i].buffer = NULL; /* Mark end of table. */
5494 TEX_toktab[i].len = 0;
5495 break;
5501 /* Texinfo support. Dave Love, Mar. 2000. */
5502 static void
5503 Texinfo_nodes (FILE *inf)
5505 char *cp, *start;
5506 LOOP_ON_INPUT_LINES (inf, lb, cp)
5507 if (LOOKING_AT (cp, "@node"))
5509 start = cp;
5510 while (*cp != '\0' && *cp != ',')
5511 cp++;
5512 make_tag (start, cp - start, true,
5513 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
5519 * HTML support.
5520 * Contents of <title>, <h1>, <h2>, <h3> are tags.
5521 * Contents of <a name=xxx> are tags with name xxx.
5523 * Francesco Potortì, 2002.
5525 static void
5526 HTML_labels (FILE *inf)
5528 bool getnext = false; /* next text outside of HTML tags is a tag */
5529 bool skiptag = false; /* skip to the end of the current HTML tag */
5530 bool intag = false; /* inside an html tag, looking for ID= */
5531 bool inanchor = false; /* when INTAG, is an anchor, look for NAME= */
5532 char *end;
5535 linebuffer_setlen (&token_name, 0); /* no name in buffer */
5537 LOOP_ON_INPUT_LINES (inf, lb, dbp)
5538 for (;;) /* loop on the same line */
5540 if (skiptag) /* skip HTML tag */
5542 while (*dbp != '\0' && *dbp != '>')
5543 dbp++;
5544 if (*dbp == '>')
5546 dbp += 1;
5547 skiptag = false;
5548 continue; /* look on the same line */
5550 break; /* go to next line */
5553 else if (intag) /* look for "name=" or "id=" */
5555 while (*dbp != '\0' && *dbp != '>'
5556 && c_tolower (*dbp) != 'n' && c_tolower (*dbp) != 'i')
5557 dbp++;
5558 if (*dbp == '\0')
5559 break; /* go to next line */
5560 if (*dbp == '>')
5562 dbp += 1;
5563 intag = false;
5564 continue; /* look on the same line */
5566 if ((inanchor && LOOKING_AT_NOCASE (dbp, "name="))
5567 || LOOKING_AT_NOCASE (dbp, "id="))
5569 bool quoted = (dbp[0] == '"');
5571 if (quoted)
5572 for (end = ++dbp; *end != '\0' && *end != '"'; end++)
5573 continue;
5574 else
5575 for (end = dbp; *end != '\0' && intoken (*end); end++)
5576 continue;
5577 linebuffer_setlen (&token_name, end - dbp);
5578 memcpy (token_name.buffer, dbp, end - dbp);
5579 token_name.buffer[end - dbp] = '\0';
5581 dbp = end;
5582 intag = false; /* we found what we looked for */
5583 skiptag = true; /* skip to the end of the tag */
5584 getnext = true; /* then grab the text */
5585 continue; /* look on the same line */
5587 dbp += 1;
5590 else if (getnext) /* grab next tokens and tag them */
5592 dbp = skip_spaces (dbp);
5593 if (*dbp == '\0')
5594 break; /* go to next line */
5595 if (*dbp == '<')
5597 intag = true;
5598 inanchor = (c_tolower (dbp[1]) == 'a' && !intoken (dbp[2]));
5599 continue; /* look on the same line */
5602 for (end = dbp + 1; *end != '\0' && *end != '<'; end++)
5603 continue;
5604 make_tag (token_name.buffer, token_name.len, true,
5605 dbp, end - dbp, lineno, linecharno);
5606 linebuffer_setlen (&token_name, 0); /* no name in buffer */
5607 getnext = false;
5608 break; /* go to next line */
5611 else /* look for an interesting HTML tag */
5613 while (*dbp != '\0' && *dbp != '<')
5614 dbp++;
5615 if (*dbp == '\0')
5616 break; /* go to next line */
5617 intag = true;
5618 if (c_tolower (dbp[1]) == 'a' && !intoken (dbp[2]))
5620 inanchor = true;
5621 continue; /* look on the same line */
5623 else if (LOOKING_AT_NOCASE (dbp, "<title>")
5624 || LOOKING_AT_NOCASE (dbp, "<h1>")
5625 || LOOKING_AT_NOCASE (dbp, "<h2>")
5626 || LOOKING_AT_NOCASE (dbp, "<h3>"))
5628 intag = false;
5629 getnext = true;
5630 continue; /* look on the same line */
5632 dbp += 1;
5639 * Prolog support
5641 * Assumes that the predicate or rule starts at column 0.
5642 * Only the first clause of a predicate or rule is added.
5643 * Original code by Sunichirou Sugou (1989)
5644 * Rewritten by Anders Lindgren (1996)
5646 static size_t prolog_pr (char *, char *);
5647 static void prolog_skip_comment (linebuffer *, FILE *);
5648 static size_t prolog_atom (char *, size_t);
5650 static void
5651 Prolog_functions (FILE *inf)
5653 char *cp, *last;
5654 size_t len;
5655 size_t allocated;
5657 allocated = 0;
5658 len = 0;
5659 last = NULL;
5661 LOOP_ON_INPUT_LINES (inf, lb, cp)
5663 if (cp[0] == '\0') /* Empty line */
5664 continue;
5665 else if (c_isspace (cp[0])) /* Not a predicate */
5666 continue;
5667 else if (cp[0] == '/' && cp[1] == '*') /* comment. */
5668 prolog_skip_comment (&lb, inf);
5669 else if ((len = prolog_pr (cp, last)) > 0)
5671 /* Predicate or rule. Store the function name so that we
5672 only generate a tag for the first clause. */
5673 if (last == NULL)
5674 last = xnew (len + 1, char);
5675 else if (len + 1 > allocated)
5676 xrnew (last, len + 1, char);
5677 allocated = len + 1;
5678 memcpy (last, cp, len);
5679 last[len] = '\0';
5682 free (last);
5686 static void
5687 prolog_skip_comment (linebuffer *plb, FILE *inf)
5689 char *cp;
5693 for (cp = plb->buffer; *cp != '\0'; cp++)
5694 if (cp[0] == '*' && cp[1] == '/')
5695 return;
5696 readline (plb, inf);
5698 while (perhaps_more_input (inf));
5702 * A predicate or rule definition is added if it matches:
5703 * <beginning of line><Prolog Atom><whitespace>(
5704 * or <beginning of line><Prolog Atom><whitespace>:-
5706 * It is added to the tags database if it doesn't match the
5707 * name of the previous clause header.
5709 * Return the size of the name of the predicate or rule, or 0 if no
5710 * header was found.
5712 static size_t
5713 prolog_pr (char *s, char *last)
5715 /* Name of last clause. */
5717 size_t pos;
5718 size_t len;
5720 pos = prolog_atom (s, 0);
5721 if (! pos)
5722 return 0;
5724 len = pos;
5725 pos = skip_spaces (s + pos) - s;
5727 if ((s[pos] == '.'
5728 || (s[pos] == '(' && (pos += 1))
5729 || (s[pos] == ':' && s[pos + 1] == '-' && (pos += 2)))
5730 && (last == NULL /* save only the first clause */
5731 || len != strlen (last)
5732 || !strneq (s, last, len)))
5734 make_tag (s, len, true, s, pos, lineno, linecharno);
5735 return len;
5737 else
5738 return 0;
5742 * Consume a Prolog atom.
5743 * Return the number of bytes consumed, or 0 if there was an error.
5745 * A prolog atom, in this context, could be one of:
5746 * - An alphanumeric sequence, starting with a lower case letter.
5747 * - A quoted arbitrary string. Single quotes can escape themselves.
5748 * Backslash quotes everything.
5750 static size_t
5751 prolog_atom (char *s, size_t pos)
5753 size_t origpos;
5755 origpos = pos;
5757 if (c_islower (s[pos]) || s[pos] == '_')
5759 /* The atom is unquoted. */
5760 pos++;
5761 while (c_isalnum (s[pos]) || s[pos] == '_')
5763 pos++;
5765 return pos - origpos;
5767 else if (s[pos] == '\'')
5769 pos++;
5771 for (;;)
5773 if (s[pos] == '\'')
5775 pos++;
5776 if (s[pos] != '\'')
5777 break;
5778 pos++; /* A double quote */
5780 else if (s[pos] == '\0')
5781 /* Multiline quoted atoms are ignored. */
5782 return 0;
5783 else if (s[pos] == '\\')
5785 if (s[pos+1] == '\0')
5786 return 0;
5787 pos += 2;
5789 else
5790 pos++;
5792 return pos - origpos;
5794 else
5795 return 0;
5800 * Support for Erlang
5802 * Generates tags for functions, defines, and records.
5803 * Assumes that Erlang functions start at column 0.
5804 * Original code by Anders Lindgren (1996)
5806 static int erlang_func (char *, char *);
5807 static void erlang_attribute (char *);
5808 static int erlang_atom (char *);
5810 static void
5811 Erlang_functions (FILE *inf)
5813 char *cp, *last;
5814 int len;
5815 int allocated;
5817 allocated = 0;
5818 len = 0;
5819 last = NULL;
5821 LOOP_ON_INPUT_LINES (inf, lb, cp)
5823 if (cp[0] == '\0') /* Empty line */
5824 continue;
5825 else if (c_isspace (cp[0])) /* Not function nor attribute */
5826 continue;
5827 else if (cp[0] == '%') /* comment */
5828 continue;
5829 else if (cp[0] == '"') /* Sometimes, strings start in column one */
5830 continue;
5831 else if (cp[0] == '-') /* attribute, e.g. "-define" */
5833 erlang_attribute (cp);
5834 if (last != NULL)
5836 free (last);
5837 last = NULL;
5840 else if ((len = erlang_func (cp, last)) > 0)
5843 * Function. Store the function name so that we only
5844 * generates a tag for the first clause.
5846 if (last == NULL)
5847 last = xnew (len + 1, char);
5848 else if (len + 1 > allocated)
5849 xrnew (last, len + 1, char);
5850 allocated = len + 1;
5851 memcpy (last, cp, len);
5852 last[len] = '\0';
5855 free (last);
5860 * A function definition is added if it matches:
5861 * <beginning of line><Erlang Atom><whitespace>(
5863 * It is added to the tags database if it doesn't match the
5864 * name of the previous clause header.
5866 * Return the size of the name of the function, or 0 if no function
5867 * was found.
5869 static int
5870 erlang_func (char *s, char *last)
5872 /* Name of last clause. */
5874 int pos;
5875 int len;
5877 pos = erlang_atom (s);
5878 if (pos < 1)
5879 return 0;
5881 len = pos;
5882 pos = skip_spaces (s + pos) - s;
5884 /* Save only the first clause. */
5885 if (s[pos++] == '('
5886 && (last == NULL
5887 || len != (int)strlen (last)
5888 || !strneq (s, last, len)))
5890 make_tag (s, len, true, s, pos, lineno, linecharno);
5891 return len;
5894 return 0;
5899 * Handle attributes. Currently, tags are generated for defines
5900 * and records.
5902 * They are on the form:
5903 * -define(foo, bar).
5904 * -define(Foo(M, N), M+N).
5905 * -record(graph, {vtab = notable, cyclic = true}).
5907 static void
5908 erlang_attribute (char *s)
5910 char *cp = s;
5912 if ((LOOKING_AT (cp, "-define") || LOOKING_AT (cp, "-record"))
5913 && *cp++ == '(')
5915 int len = erlang_atom (skip_spaces (cp));
5916 if (len > 0)
5917 make_tag (cp, len, true, s, cp + len - s, lineno, linecharno);
5919 return;
5924 * Consume an Erlang atom (or variable).
5925 * Return the number of bytes consumed, or -1 if there was an error.
5927 static int
5928 erlang_atom (char *s)
5930 int pos = 0;
5932 if (c_isalpha (s[pos]) || s[pos] == '_')
5934 /* The atom is unquoted. */
5936 pos++;
5937 while (c_isalnum (s[pos]) || s[pos] == '_');
5939 else if (s[pos] == '\'')
5941 for (pos++; s[pos] != '\''; pos++)
5942 if (s[pos] == '\0' /* multiline quoted atoms are ignored */
5943 || (s[pos] == '\\' && s[++pos] == '\0'))
5944 return 0;
5945 pos++;
5948 return pos;
5952 static char *scan_separators (char *);
5953 static void add_regex (char *, language *);
5954 static char *substitute (char *, char *, struct re_registers *);
5957 * Take a string like "/blah/" and turn it into "blah", verifying
5958 * that the first and last characters are the same, and handling
5959 * quoted separator characters. Actually, stops on the occurrence of
5960 * an unquoted separator. Also process \t, \n, etc. and turn into
5961 * appropriate characters. Works in place. Null terminates name string.
5962 * Returns pointer to terminating separator, or NULL for
5963 * unterminated regexps.
5965 static char *
5966 scan_separators (char *name)
5968 char sep = name[0];
5969 char *copyto = name;
5970 bool quoted = false;
5972 for (++name; *name != '\0'; ++name)
5974 if (quoted)
5976 switch (*name)
5978 case 'a': *copyto++ = '\007'; break; /* BEL (bell) */
5979 case 'b': *copyto++ = '\b'; break; /* BS (back space) */
5980 case 'd': *copyto++ = 0177; break; /* DEL (delete) */
5981 case 'e': *copyto++ = 033; break; /* ESC (delete) */
5982 case 'f': *copyto++ = '\f'; break; /* FF (form feed) */
5983 case 'n': *copyto++ = '\n'; break; /* NL (new line) */
5984 case 'r': *copyto++ = '\r'; break; /* CR (carriage return) */
5985 case 't': *copyto++ = '\t'; break; /* TAB (horizontal tab) */
5986 case 'v': *copyto++ = '\v'; break; /* VT (vertical tab) */
5987 default:
5988 if (*name == sep)
5989 *copyto++ = sep;
5990 else
5992 /* Something else is quoted, so preserve the quote. */
5993 *copyto++ = '\\';
5994 *copyto++ = *name;
5996 break;
5998 quoted = false;
6000 else if (*name == '\\')
6001 quoted = true;
6002 else if (*name == sep)
6003 break;
6004 else
6005 *copyto++ = *name;
6007 if (*name != sep)
6008 name = NULL; /* signal unterminated regexp */
6010 /* Terminate copied string. */
6011 *copyto = '\0';
6012 return name;
6015 /* Look at the argument of --regex or --no-regex and do the right
6016 thing. Same for each line of a regexp file. */
6017 static void
6018 analyze_regex (char *regex_arg)
6020 if (regex_arg == NULL)
6022 free_regexps (); /* --no-regex: remove existing regexps */
6023 return;
6026 /* A real --regexp option or a line in a regexp file. */
6027 switch (regex_arg[0])
6029 /* Comments in regexp file or null arg to --regex. */
6030 case '\0':
6031 case ' ':
6032 case '\t':
6033 break;
6035 /* Read a regex file. This is recursive and may result in a
6036 loop, which will stop when the file descriptors are exhausted. */
6037 case '@':
6039 FILE *regexfp;
6040 linebuffer regexbuf;
6041 char *regexfile = regex_arg + 1;
6043 /* regexfile is a file containing regexps, one per line. */
6044 regexfp = fopen (regexfile, "r" FOPEN_BINARY);
6045 if (regexfp == NULL)
6046 pfatal (regexfile);
6047 linebuffer_init (&regexbuf);
6048 while (readline_internal (&regexbuf, regexfp, regexfile) > 0)
6049 analyze_regex (regexbuf.buffer);
6050 free (regexbuf.buffer);
6051 if (fclose (regexfp) != 0)
6052 pfatal (regexfile);
6054 break;
6056 /* Regexp to be used for a specific language only. */
6057 case '{':
6059 language *lang;
6060 char *lang_name = regex_arg + 1;
6061 char *cp;
6063 for (cp = lang_name; *cp != '}'; cp++)
6064 if (*cp == '\0')
6066 error ("unterminated language name in regex: %s", regex_arg);
6067 return;
6069 *cp++ = '\0';
6070 lang = get_language_from_langname (lang_name);
6071 if (lang == NULL)
6072 return;
6073 add_regex (cp, lang);
6075 break;
6077 /* Regexp to be used for any language. */
6078 default:
6079 add_regex (regex_arg, NULL);
6080 break;
6084 /* Separate the regexp pattern, compile it,
6085 and care for optional name and modifiers. */
6086 static void
6087 add_regex (char *regexp_pattern, language *lang)
6089 static struct re_pattern_buffer zeropattern;
6090 char sep, *pat, *name, *modifiers;
6091 char empty = '\0';
6092 const char *err;
6093 struct re_pattern_buffer *patbuf;
6094 regexp *rp;
6095 bool
6096 force_explicit_name = true, /* do not use implicit tag names */
6097 ignore_case = false, /* case is significant */
6098 multi_line = false, /* matches are done one line at a time */
6099 single_line = false; /* dot does not match newline */
6102 if (strlen (regexp_pattern) < 3)
6104 error ("null regexp");
6105 return;
6107 sep = regexp_pattern[0];
6108 name = scan_separators (regexp_pattern);
6109 if (name == NULL)
6111 error ("%s: unterminated regexp", regexp_pattern);
6112 return;
6114 if (name[1] == sep)
6116 error ("null name for regexp \"%s\"", regexp_pattern);
6117 return;
6119 modifiers = scan_separators (name);
6120 if (modifiers == NULL) /* no terminating separator --> no name */
6122 modifiers = name;
6123 name = &empty;
6125 else
6126 modifiers += 1; /* skip separator */
6128 /* Parse regex modifiers. */
6129 for (; modifiers[0] != '\0'; modifiers++)
6130 switch (modifiers[0])
6132 case 'N':
6133 if (modifiers == name)
6134 error ("forcing explicit tag name but no name, ignoring");
6135 force_explicit_name = true;
6136 break;
6137 case 'i':
6138 ignore_case = true;
6139 break;
6140 case 's':
6141 single_line = true;
6142 /* FALLTHRU */
6143 case 'm':
6144 multi_line = true;
6145 need_filebuf = true;
6146 break;
6147 default:
6148 error ("invalid regexp modifier '%c', ignoring", modifiers[0]);
6149 break;
6152 patbuf = xnew (1, struct re_pattern_buffer);
6153 *patbuf = zeropattern;
6154 if (ignore_case)
6156 static char lc_trans[UCHAR_MAX + 1];
6157 int i;
6158 for (i = 0; i < UCHAR_MAX + 1; i++)
6159 lc_trans[i] = c_tolower (i);
6160 patbuf->translate = lc_trans; /* translation table to fold case */
6163 if (multi_line)
6164 pat = concat ("^", regexp_pattern, ""); /* anchor to beginning of line */
6165 else
6166 pat = regexp_pattern;
6168 if (single_line)
6169 re_set_syntax (RE_SYNTAX_EMACS | RE_DOT_NEWLINE);
6170 else
6171 re_set_syntax (RE_SYNTAX_EMACS);
6173 err = re_compile_pattern (pat, strlen (pat), patbuf);
6174 if (multi_line)
6175 free (pat);
6176 if (err != NULL)
6178 error ("%s while compiling pattern", err);
6179 return;
6182 rp = p_head;
6183 p_head = xnew (1, regexp);
6184 p_head->pattern = savestr (regexp_pattern);
6185 p_head->p_next = rp;
6186 p_head->lang = lang;
6187 p_head->pat = patbuf;
6188 p_head->name = savestr (name);
6189 p_head->error_signaled = false;
6190 p_head->force_explicit_name = force_explicit_name;
6191 p_head->ignore_case = ignore_case;
6192 p_head->multi_line = multi_line;
6196 * Do the substitutions indicated by the regular expression and
6197 * arguments.
6199 static char *
6200 substitute (char *in, char *out, struct re_registers *regs)
6202 char *result, *t;
6203 int size, dig, diglen;
6205 result = NULL;
6206 size = strlen (out);
6208 /* Pass 1: figure out how much to allocate by finding all \N strings. */
6209 if (out[size - 1] == '\\')
6210 fatal ("pattern error in \"%s\"", out);
6211 for (t = strchr (out, '\\');
6212 t != NULL;
6213 t = strchr (t + 2, '\\'))
6214 if (c_isdigit (t[1]))
6216 dig = t[1] - '0';
6217 diglen = regs->end[dig] - regs->start[dig];
6218 size += diglen - 2;
6220 else
6221 size -= 1;
6223 /* Allocate space and do the substitutions. */
6224 assert (size >= 0);
6225 result = xnew (size + 1, char);
6227 for (t = result; *out != '\0'; out++)
6228 if (*out == '\\' && c_isdigit (*++out))
6230 dig = *out - '0';
6231 diglen = regs->end[dig] - regs->start[dig];
6232 memcpy (t, in + regs->start[dig], diglen);
6233 t += diglen;
6235 else
6236 *t++ = *out;
6237 *t = '\0';
6239 assert (t <= result + size);
6240 assert (t - result == (int)strlen (result));
6242 return result;
6245 /* Deallocate all regexps. */
6246 static void
6247 free_regexps (void)
6249 regexp *rp;
6250 while (p_head != NULL)
6252 rp = p_head->p_next;
6253 free (p_head->pattern);
6254 free (p_head->name);
6255 free (p_head);
6256 p_head = rp;
6258 return;
6262 * Reads the whole file as a single string from `filebuf' and looks for
6263 * multi-line regular expressions, creating tags on matches.
6264 * readline already dealt with normal regexps.
6266 * Idea by Ben Wing <ben@666.com> (2002).
6268 static void
6269 regex_tag_multiline (void)
6271 char *buffer = filebuf.buffer;
6272 regexp *rp;
6273 char *name;
6275 for (rp = p_head; rp != NULL; rp = rp->p_next)
6277 int match = 0;
6279 if (!rp->multi_line)
6280 continue; /* skip normal regexps */
6282 /* Generic initializations before parsing file from memory. */
6283 lineno = 1; /* reset global line number */
6284 charno = 0; /* reset global char number */
6285 linecharno = 0; /* reset global char number of line start */
6287 /* Only use generic regexps or those for the current language. */
6288 if (rp->lang != NULL && rp->lang != curfdp->lang)
6289 continue;
6291 while (match >= 0 && match < filebuf.len)
6293 match = re_search (rp->pat, buffer, filebuf.len, charno,
6294 filebuf.len - match, &rp->regs);
6295 switch (match)
6297 case -2:
6298 /* Some error. */
6299 if (!rp->error_signaled)
6301 error ("regexp stack overflow while matching \"%s\"",
6302 rp->pattern);
6303 rp->error_signaled = true;
6305 break;
6306 case -1:
6307 /* No match. */
6308 break;
6309 default:
6310 if (match == rp->regs.end[0])
6312 if (!rp->error_signaled)
6314 error ("regexp matches the empty string: \"%s\"",
6315 rp->pattern);
6316 rp->error_signaled = true;
6318 match = -3; /* exit from while loop */
6319 break;
6322 /* Match occurred. Construct a tag. */
6323 while (charno < rp->regs.end[0])
6324 if (buffer[charno++] == '\n')
6325 lineno++, linecharno = charno;
6326 name = rp->name;
6327 if (name[0] == '\0')
6328 name = NULL;
6329 else /* make a named tag */
6330 name = substitute (buffer, rp->name, &rp->regs);
6331 if (rp->force_explicit_name)
6332 /* Force explicit tag name, if a name is there. */
6333 pfnote (name, true, buffer + linecharno,
6334 charno - linecharno + 1, lineno, linecharno);
6335 else
6336 make_tag (name, strlen (name), true, buffer + linecharno,
6337 charno - linecharno + 1, lineno, linecharno);
6338 break;
6345 static bool
6346 nocase_tail (const char *cp)
6348 int len = 0;
6350 while (*cp != '\0' && c_tolower (*cp) == c_tolower (dbp[len]))
6351 cp++, len++;
6352 if (*cp == '\0' && !intoken (dbp[len]))
6354 dbp += len;
6355 return true;
6357 return false;
6360 static void
6361 get_tag (register char *bp, char **namepp)
6363 register char *cp = bp;
6365 if (*bp != '\0')
6367 /* Go till you get to white space or a syntactic break */
6368 for (cp = bp + 1; !notinname (*cp); cp++)
6369 continue;
6370 make_tag (bp, cp - bp, true,
6371 lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
6374 if (namepp != NULL)
6375 *namepp = savenstr (bp, cp - bp);
6379 * Read a line of text from `stream' into `lbp', excluding the
6380 * newline or CR-NL, if any. Return the number of characters read from
6381 * `stream', which is the length of the line including the newline.
6383 * On DOS or Windows we do not count the CR character, if any before the
6384 * NL, in the returned length; this mirrors the behavior of Emacs on those
6385 * platforms (for text files, it translates CR-NL to NL as it reads in the
6386 * file).
6388 * If multi-line regular expressions are requested, each line read is
6389 * appended to `filebuf'.
6391 static long
6392 readline_internal (linebuffer *lbp, FILE *stream, char const *filename)
6394 char *buffer = lbp->buffer;
6395 char *p = lbp->buffer;
6396 char *pend;
6397 int chars_deleted;
6399 pend = p + lbp->size; /* Separate to avoid 386/IX compiler bug. */
6401 for (;;)
6403 register int c = getc (stream);
6404 if (p == pend)
6406 /* We're at the end of linebuffer: expand it. */
6407 lbp->size *= 2;
6408 xrnew (buffer, lbp->size, char);
6409 p += buffer - lbp->buffer;
6410 pend = buffer + lbp->size;
6411 lbp->buffer = buffer;
6413 if (c == EOF)
6415 if (ferror (stream))
6416 perror (filename);
6417 *p = '\0';
6418 chars_deleted = 0;
6419 break;
6421 if (c == '\n')
6423 if (p > buffer && p[-1] == '\r')
6425 p -= 1;
6426 chars_deleted = 2;
6428 else
6430 chars_deleted = 1;
6432 *p = '\0';
6433 break;
6435 *p++ = c;
6437 lbp->len = p - buffer;
6439 if (need_filebuf /* we need filebuf for multi-line regexps */
6440 && chars_deleted > 0) /* not at EOF */
6442 while (filebuf.size <= filebuf.len + lbp->len + 1) /* +1 for \n */
6444 /* Expand filebuf. */
6445 filebuf.size *= 2;
6446 xrnew (filebuf.buffer, filebuf.size, char);
6448 memcpy (filebuf.buffer + filebuf.len, lbp->buffer, lbp->len);
6449 filebuf.len += lbp->len;
6450 filebuf.buffer[filebuf.len++] = '\n';
6451 filebuf.buffer[filebuf.len] = '\0';
6454 return lbp->len + chars_deleted;
6458 * Like readline_internal, above, but in addition try to match the
6459 * input line against relevant regular expressions and manage #line
6460 * directives.
6462 static void
6463 readline (linebuffer *lbp, FILE *stream)
6465 long result;
6467 linecharno = charno; /* update global char number of line start */
6468 result = readline_internal (lbp, stream, infilename); /* read line */
6469 lineno += 1; /* increment global line number */
6470 charno += result; /* increment global char number */
6472 /* Honor #line directives. */
6473 if (!no_line_directive)
6475 static bool discard_until_line_directive;
6477 /* Check whether this is a #line directive. */
6478 if (result > 12 && strneq (lbp->buffer, "#line ", 6))
6480 unsigned int lno;
6481 int start = 0;
6483 if (sscanf (lbp->buffer, "#line %u \"%n", &lno, &start) >= 1
6484 && start > 0) /* double quote character found */
6486 char *endp = lbp->buffer + start;
6488 while ((endp = strchr (endp, '"')) != NULL
6489 && endp[-1] == '\\')
6490 endp++;
6491 if (endp != NULL)
6492 /* Ok, this is a real #line directive. Let's deal with it. */
6494 char *taggedabsname; /* absolute name of original file */
6495 char *taggedfname; /* name of original file as given */
6496 char *name; /* temp var */
6498 discard_until_line_directive = false; /* found it */
6499 name = lbp->buffer + start;
6500 *endp = '\0';
6501 canonicalize_filename (name);
6502 taggedabsname = absolute_filename (name, tagfiledir);
6503 if (filename_is_absolute (name)
6504 || filename_is_absolute (curfdp->infname))
6505 taggedfname = savestr (taggedabsname);
6506 else
6507 taggedfname = relative_filename (taggedabsname,tagfiledir);
6509 if (streq (curfdp->taggedfname, taggedfname))
6510 /* The #line directive is only a line number change. We
6511 deal with this afterwards. */
6512 free (taggedfname);
6513 else
6514 /* The tags following this #line directive should be
6515 attributed to taggedfname. In order to do this, set
6516 curfdp accordingly. */
6518 fdesc *fdp; /* file description pointer */
6520 /* Go look for a file description already set up for the
6521 file indicated in the #line directive. If there is
6522 one, use it from now until the next #line
6523 directive. */
6524 for (fdp = fdhead; fdp != NULL; fdp = fdp->next)
6525 if (streq (fdp->infname, curfdp->infname)
6526 && streq (fdp->taggedfname, taggedfname))
6527 /* If we remove the second test above (after the &&)
6528 then all entries pertaining to the same file are
6529 coalesced in the tags file. If we use it, then
6530 entries pertaining to the same file but generated
6531 from different files (via #line directives) will
6532 go into separate sections in the tags file. These
6533 alternatives look equivalent. The first one
6534 destroys some apparently useless information. */
6536 curfdp = fdp;
6537 free (taggedfname);
6538 break;
6540 /* Else, if we already tagged the real file, skip all
6541 input lines until the next #line directive. */
6542 if (fdp == NULL) /* not found */
6543 for (fdp = fdhead; fdp != NULL; fdp = fdp->next)
6544 if (streq (fdp->infabsname, taggedabsname))
6546 discard_until_line_directive = true;
6547 free (taggedfname);
6548 break;
6550 /* Else create a new file description and use that from
6551 now on, until the next #line directive. */
6552 if (fdp == NULL) /* not found */
6554 fdp = fdhead;
6555 fdhead = xnew (1, fdesc);
6556 *fdhead = *curfdp; /* copy curr. file description */
6557 fdhead->next = fdp;
6558 fdhead->infname = savestr (curfdp->infname);
6559 fdhead->infabsname = savestr (curfdp->infabsname);
6560 fdhead->infabsdir = savestr (curfdp->infabsdir);
6561 fdhead->taggedfname = taggedfname;
6562 fdhead->usecharno = false;
6563 fdhead->prop = NULL;
6564 fdhead->written = false;
6565 curfdp = fdhead;
6568 free (taggedabsname);
6569 lineno = lno - 1;
6570 readline (lbp, stream);
6571 return;
6572 } /* if a real #line directive */
6573 } /* if #line is followed by a number */
6574 } /* if line begins with "#line " */
6576 /* If we are here, no #line directive was found. */
6577 if (discard_until_line_directive)
6579 if (result > 0)
6581 /* Do a tail recursion on ourselves, thus discarding the contents
6582 of the line buffer. */
6583 readline (lbp, stream);
6584 return;
6586 /* End of file. */
6587 discard_until_line_directive = false;
6588 return;
6590 } /* if #line directives should be considered */
6593 int match;
6594 regexp *rp;
6595 char *name;
6597 /* Match against relevant regexps. */
6598 if (lbp->len > 0)
6599 for (rp = p_head; rp != NULL; rp = rp->p_next)
6601 /* Only use generic regexps or those for the current language.
6602 Also do not use multiline regexps, which is the job of
6603 regex_tag_multiline. */
6604 if ((rp->lang != NULL && rp->lang != fdhead->lang)
6605 || rp->multi_line)
6606 continue;
6608 match = re_match (rp->pat, lbp->buffer, lbp->len, 0, &rp->regs);
6609 switch (match)
6611 case -2:
6612 /* Some error. */
6613 if (!rp->error_signaled)
6615 error ("regexp stack overflow while matching \"%s\"",
6616 rp->pattern);
6617 rp->error_signaled = true;
6619 break;
6620 case -1:
6621 /* No match. */
6622 break;
6623 case 0:
6624 /* Empty string matched. */
6625 if (!rp->error_signaled)
6627 error ("regexp matches the empty string: \"%s\"", rp->pattern);
6628 rp->error_signaled = true;
6630 break;
6631 default:
6632 /* Match occurred. Construct a tag. */
6633 name = rp->name;
6634 if (name[0] == '\0')
6635 name = NULL;
6636 else /* make a named tag */
6637 name = substitute (lbp->buffer, rp->name, &rp->regs);
6638 if (rp->force_explicit_name)
6639 /* Force explicit tag name, if a name is there. */
6640 pfnote (name, true, lbp->buffer, match, lineno, linecharno);
6641 else
6642 make_tag (name, strlen (name), true,
6643 lbp->buffer, match, lineno, linecharno);
6644 break;
6652 * Return a pointer to a space of size strlen(cp)+1 allocated
6653 * with xnew where the string CP has been copied.
6655 static char *
6656 savestr (const char *cp)
6658 return savenstr (cp, strlen (cp));
6662 * Return a pointer to a space of size LEN+1 allocated with xnew where
6663 * the string CP has been copied for at most the first LEN characters.
6665 static char *
6666 savenstr (const char *cp, int len)
6668 char *dp = xnew (len + 1, char);
6669 dp[len] = '\0';
6670 return memcpy (dp, cp, len);
6673 /* Skip spaces (end of string is not space), return new pointer. */
6674 static char *
6675 skip_spaces (char *cp)
6677 while (c_isspace (*cp))
6678 cp++;
6679 return cp;
6682 /* Skip non spaces, except end of string, return new pointer. */
6683 static char *
6684 skip_non_spaces (char *cp)
6686 while (*cp != '\0' && !c_isspace (*cp))
6687 cp++;
6688 return cp;
6691 /* Skip any chars in the "name" class.*/
6692 static char *
6693 skip_name (char *cp)
6695 /* '\0' is a notinname() so loop stops there too */
6696 while (! notinname (*cp))
6697 cp++;
6698 return cp;
6701 /* Print error message and exit. */
6702 static void
6703 fatal (char const *format, ...)
6705 va_list ap;
6706 va_start (ap, format);
6707 verror (format, ap);
6708 va_end (ap);
6709 exit (EXIT_FAILURE);
6712 static void
6713 pfatal (const char *s1)
6715 perror (s1);
6716 exit (EXIT_FAILURE);
6719 static void
6720 suggest_asking_for_help (void)
6722 fprintf (stderr, "\tTry '%s --help' for a complete list of options.\n",
6723 progname);
6724 exit (EXIT_FAILURE);
6727 /* Output a diagnostic with printf-style FORMAT and args. */
6728 static void
6729 error (const char *format, ...)
6731 va_list ap;
6732 va_start (ap, format);
6733 verror (format, ap);
6734 va_end (ap);
6737 static void
6738 verror (char const *format, va_list ap)
6740 fprintf (stderr, "%s: ", progname);
6741 vfprintf (stderr, format, ap);
6742 fprintf (stderr, "\n");
6745 /* Return a newly-allocated string whose contents
6746 concatenate those of s1, s2, s3. */
6747 static char *
6748 concat (const char *s1, const char *s2, const char *s3)
6750 int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
6751 char *result = xnew (len1 + len2 + len3 + 1, char);
6753 strcpy (result, s1);
6754 strcpy (result + len1, s2);
6755 strcpy (result + len1 + len2, s3);
6757 return result;
6761 /* Does the same work as the system V getcwd, but does not need to
6762 guess the buffer size in advance. */
6763 static char *
6764 etags_getcwd (void)
6766 int bufsize = 200;
6767 char *path = xnew (bufsize, char);
6769 while (getcwd (path, bufsize) == NULL)
6771 if (errno != ERANGE)
6772 pfatal ("getcwd");
6773 bufsize *= 2;
6774 free (path);
6775 path = xnew (bufsize, char);
6778 canonicalize_filename (path);
6779 return path;
6782 /* Return a newly allocated string containing a name of a temporary file. */
6783 static char *
6784 etags_mktmp (void)
6786 const char *tmpdir = getenv ("TMPDIR");
6787 const char *slash = "/";
6789 #if MSDOS || defined (DOS_NT)
6790 if (!tmpdir)
6791 tmpdir = getenv ("TEMP");
6792 if (!tmpdir)
6793 tmpdir = getenv ("TMP");
6794 if (!tmpdir)
6795 tmpdir = ".";
6796 if (tmpdir[strlen (tmpdir) - 1] == '/'
6797 || tmpdir[strlen (tmpdir) - 1] == '\\')
6798 slash = "";
6799 #else
6800 if (!tmpdir)
6801 tmpdir = "/tmp";
6802 if (tmpdir[strlen (tmpdir) - 1] == '/')
6803 slash = "";
6804 #endif
6806 char *templt = concat (tmpdir, slash, "etXXXXXX");
6807 int fd = mkostemp (templt, O_CLOEXEC);
6808 if (fd < 0 || close (fd) != 0)
6810 int temp_errno = errno;
6811 free (templt);
6812 errno = temp_errno;
6813 templt = NULL;
6816 #if defined (DOS_NT)
6817 /* The file name will be used in shell redirection, so it needs to have
6818 DOS-style backslashes, or else the Windows shell will barf. */
6819 char *p;
6820 for (p = templt; *p; p++)
6821 if (*p == '/')
6822 *p = '\\';
6823 #endif
6825 return templt;
6828 /* Return a newly allocated string containing the file name of FILE
6829 relative to the absolute directory DIR (which should end with a slash). */
6830 static char *
6831 relative_filename (char *file, char *dir)
6833 char *fp, *dp, *afn, *res;
6834 int i;
6836 /* Find the common root of file and dir (with a trailing slash). */
6837 afn = absolute_filename (file, cwd);
6838 fp = afn;
6839 dp = dir;
6840 while (*fp++ == *dp++)
6841 continue;
6842 fp--, dp--; /* back to the first differing char */
6843 #ifdef DOS_NT
6844 if (fp == afn && afn[0] != '/') /* cannot build a relative name */
6845 return afn;
6846 #endif
6847 do /* look at the equal chars until '/' */
6848 fp--, dp--;
6849 while (*fp != '/');
6851 /* Build a sequence of "../" strings for the resulting relative file name. */
6852 i = 0;
6853 while ((dp = strchr (dp + 1, '/')) != NULL)
6854 i += 1;
6855 res = xnew (3*i + strlen (fp + 1) + 1, char);
6856 char *z = res;
6857 while (i-- > 0)
6858 z = stpcpy (z, "../");
6860 /* Add the file name relative to the common root of file and dir. */
6861 strcpy (z, fp + 1);
6862 free (afn);
6864 return res;
6867 /* Return a newly allocated string containing the absolute file name
6868 of FILE given DIR (which should end with a slash). */
6869 static char *
6870 absolute_filename (char *file, char *dir)
6872 char *slashp, *cp, *res;
6874 if (filename_is_absolute (file))
6875 res = savestr (file);
6876 #ifdef DOS_NT
6877 /* We don't support non-absolute file names with a drive
6878 letter, like `d:NAME' (it's too much hassle). */
6879 else if (file[1] == ':')
6880 fatal ("%s: relative file names with drive letters not supported", file);
6881 #endif
6882 else
6883 res = concat (dir, file, "");
6885 /* Delete the "/dirname/.." and "/." substrings. */
6886 slashp = strchr (res, '/');
6887 while (slashp != NULL && slashp[0] != '\0')
6889 if (slashp[1] == '.')
6891 if (slashp[2] == '.'
6892 && (slashp[3] == '/' || slashp[3] == '\0'))
6894 cp = slashp;
6896 cp--;
6897 while (cp >= res && !filename_is_absolute (cp));
6898 if (cp < res)
6899 cp = slashp; /* the absolute name begins with "/.." */
6900 #ifdef DOS_NT
6901 /* Under MSDOS and NT we get `d:/NAME' as absolute
6902 file name, so the luser could say `d:/../NAME'.
6903 We silently treat this as `d:/NAME'. */
6904 else if (cp[0] != '/')
6905 cp = slashp;
6906 #endif
6907 memmove (cp, slashp + 3, strlen (slashp + 2));
6908 slashp = cp;
6909 continue;
6911 else if (slashp[2] == '/' || slashp[2] == '\0')
6913 memmove (slashp, slashp + 2, strlen (slashp + 1));
6914 continue;
6918 slashp = strchr (slashp + 1, '/');
6921 if (res[0] == '\0') /* just a safety net: should never happen */
6923 free (res);
6924 return savestr ("/");
6926 else
6927 return res;
6930 /* Return a newly allocated string containing the absolute
6931 file name of dir where FILE resides given DIR (which should
6932 end with a slash). */
6933 static char *
6934 absolute_dirname (char *file, char *dir)
6936 char *slashp, *res;
6937 char save;
6939 slashp = strrchr (file, '/');
6940 if (slashp == NULL)
6941 return savestr (dir);
6942 save = slashp[1];
6943 slashp[1] = '\0';
6944 res = absolute_filename (file, dir);
6945 slashp[1] = save;
6947 return res;
6950 /* Whether the argument string is an absolute file name. The argument
6951 string must have been canonicalized with canonicalize_filename. */
6952 static bool
6953 filename_is_absolute (char *fn)
6955 return (fn[0] == '/'
6956 #ifdef DOS_NT
6957 || (c_isalpha (fn[0]) && fn[1] == ':' && fn[2] == '/')
6958 #endif
6962 /* Downcase DOS drive letter and collapse separators into single slashes.
6963 Works in place. */
6964 static void
6965 canonicalize_filename (register char *fn)
6967 register char* cp;
6969 #ifdef DOS_NT
6970 /* Canonicalize drive letter case. */
6971 if (c_isupper (fn[0]) && fn[1] == ':')
6972 fn[0] = c_tolower (fn[0]);
6974 /* Collapse multiple forward- and back-slashes into a single forward
6975 slash. */
6976 for (cp = fn; *cp != '\0'; cp++, fn++)
6977 if (*cp == '/' || *cp == '\\')
6979 *fn = '/';
6980 while (cp[1] == '/' || cp[1] == '\\')
6981 cp++;
6983 else
6984 *fn = *cp;
6986 #else /* !DOS_NT */
6988 /* Collapse multiple slashes into a single slash. */
6989 for (cp = fn; *cp != '\0'; cp++, fn++)
6990 if (*cp == '/')
6992 *fn = '/';
6993 while (cp[1] == '/')
6994 cp++;
6996 else
6997 *fn = *cp;
6999 #endif /* !DOS_NT */
7001 *fn = '\0';
7005 /* Initialize a linebuffer for use. */
7006 static void
7007 linebuffer_init (linebuffer *lbp)
7009 lbp->size = (DEBUG) ? 3 : 200;
7010 lbp->buffer = xnew (lbp->size, char);
7011 lbp->buffer[0] = '\0';
7012 lbp->len = 0;
7015 /* Set the minimum size of a string contained in a linebuffer. */
7016 static void
7017 linebuffer_setlen (linebuffer *lbp, int toksize)
7019 while (lbp->size <= toksize)
7021 lbp->size *= 2;
7022 xrnew (lbp->buffer, lbp->size, char);
7024 lbp->len = toksize;
7027 /* Like malloc but get fatal error if memory is exhausted. */
7028 static void *
7029 xmalloc (size_t size)
7031 void *result = malloc (size);
7032 if (result == NULL)
7033 fatal ("virtual memory exhausted");
7034 return result;
7037 static void *
7038 xrealloc (void *ptr, size_t size)
7040 void *result = realloc (ptr, size);
7041 if (result == NULL)
7042 fatal ("virtual memory exhausted");
7043 return result;
7047 * Local Variables:
7048 * indent-tabs-mode: t
7049 * tab-width: 8
7050 * fill-column: 79
7051 * c-font-lock-extra-types: ("FILE" "bool" "language" "linebuffer" "fdesc" "node" "regexp")
7052 * c-file-style: "gnu"
7053 * End:
7056 /* etags.c ends here */