1 /* Tags file maker to go with GNU Emacs -*- coding: latin-1 -*-
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
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
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-2012
32 Free Software 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
39 (at 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
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. */
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ì.
72 * Francesco Potortì <pot@gnu.org> has maintained and improved it since 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";
91 # define NDEBUG /* disable assert */
97 # define _GNU_SOURCE 1 /* enables some compiler checks on GNU */
100 /* WIN32_NATIVE is for XEmacs.
101 MSDOS, WINDOWSNT, DOS_NT are for Emacs. */
106 #endif /* WIN32_NATIVE */
112 # include <sys/param.h>
122 # define MAXPATHLEN _MAX_PATH
126 #endif /* WINDOWSNT */
135 #include <sys/types.h>
136 #include <sys/stat.h>
137 #include <c-strcase.h>
141 # undef assert /* some systems have a buggy assert.h */
142 # define assert(x) ((void) 0)
148 /* Define CTAGS to make the program "ctags" compatible with the usual one.
149 Leave it undefined to make the program "etags", which makes emacs-style
150 tag tables and tags typedefs, #defines and struct/union/enum by default. */
158 #define streq(s,t) (assert ((s)!=NULL || (t)!=NULL), !strcmp (s, t))
159 #define strcaseeq(s,t) (assert ((s)!=NULL && (t)!=NULL), !c_strcasecmp (s, t))
160 #define strneq(s,t,n) (assert ((s)!=NULL || (t)!=NULL), !strncmp (s, t, n))
161 #define strncaseeq(s,t,n) (assert ((s)!=NULL && (t)!=NULL), !c_strncasecmp (s, t, n))
163 #define CHARS 256 /* 2^sizeof(char) */
164 #define CHAR(x) ((unsigned int)(x) & (CHARS - 1))
165 #define iswhite(c) (_wht[CHAR (c)]) /* c is white (see white) */
166 #define notinname(c) (_nin[CHAR (c)]) /* c is not in a name (see nonam) */
167 #define begtoken(c) (_btk[CHAR (c)]) /* c can start token (see begtk) */
168 #define intoken(c) (_itk[CHAR (c)]) /* c can be in token (see midtk) */
169 #define endtoken(c) (_etk[CHAR (c)]) /* c ends tokens (see endtk) */
171 #define ISALNUM(c) isalnum (CHAR (c))
172 #define ISALPHA(c) isalpha (CHAR (c))
173 #define ISDIGIT(c) isdigit (CHAR (c))
174 #define ISLOWER(c) islower (CHAR (c))
176 #define lowcase(c) tolower (CHAR (c))
180 * xnew, xrnew -- allocate, reallocate storage
182 * SYNOPSIS: Type *xnew (int n, Type);
183 * void xrnew (OldPointer, int n, Type);
186 # include "chkmalloc.h"
187 # define xnew(n,Type) ((Type *) trace_malloc (__FILE__, __LINE__, \
188 (n) * sizeof (Type)))
189 # define xrnew(op,n,Type) ((op) = (Type *) trace_realloc (__FILE__, __LINE__, \
190 (char *) (op), (n) * sizeof (Type)))
192 # define xnew(n,Type) ((Type *) xmalloc ((n) * sizeof (Type)))
193 # define xrnew(op,n,Type) ((op) = (Type *) xrealloc ( \
194 (char *) (op), (n) * sizeof (Type)))
199 typedef void Lang_function (FILE *);
203 const char *suffix
; /* file name suffix for this compressor */
204 const char *command
; /* takes one arg and decompresses to stdout */
209 const char *name
; /* language name */
210 const char *help
; /* detailed help for the language */
211 Lang_function
*function
; /* parse function */
212 const char **suffixes
; /* name suffixes of this language's files */
213 const char **filenames
; /* names of this language's files */
214 const char **interpreters
; /* interpreters for this language */
215 bool metasource
; /* source used to generate other sources */
220 struct fdesc
*next
; /* for the linked list */
221 char *infname
; /* uncompressed input file name */
222 char *infabsname
; /* absolute uncompressed input file name */
223 char *infabsdir
; /* absolute dir of input file */
224 char *taggedfname
; /* file name to write in tagfile */
225 language
*lang
; /* language of file */
226 char *prop
; /* file properties to write in tagfile */
227 bool usecharno
; /* etags tags shall contain char number */
228 bool written
; /* entry written in the tags file */
231 typedef struct node_st
232 { /* sorting structure */
233 struct node_st
*left
, *right
; /* left and right sons */
234 fdesc
*fdp
; /* description of file to whom tag belongs */
235 char *name
; /* tag name */
236 char *regex
; /* search regexp */
237 bool valid
; /* write this tag on the tag file */
238 bool is_func
; /* function tag: use regexp in CTAGS mode */
239 bool been_warned
; /* warning already given for duplicated tag */
240 int lno
; /* line number tag is on */
241 long cno
; /* character number line starts on */
245 * A `linebuffer' is a structure which holds a line of text.
246 * `readline_internal' reads a line from a stream into a linebuffer
247 * and works regardless of the length of the line.
248 * SIZE is the size of BUFFER, LEN is the length of the string in
249 * BUFFER after readline reads it.
258 /* Used to support mixing of --lang and file names. */
262 at_language
, /* a language specification */
263 at_regexp
, /* a regular expression */
264 at_filename
, /* a file name */
265 at_stdin
, /* read from stdin here */
266 at_end
/* stop parsing the list */
267 } arg_type
; /* argument type */
268 language
*lang
; /* language associated with the argument */
269 char *what
; /* the argument itself */
272 /* Structure defining a regular expression. */
273 typedef struct regexp
275 struct regexp
*p_next
; /* pointer to next in list */
276 language
*lang
; /* if set, use only for this language */
277 char *pattern
; /* the regexp pattern */
278 char *name
; /* tag name */
279 struct re_pattern_buffer
*pat
; /* the compiled pattern */
280 struct re_registers regs
; /* re registers */
281 bool error_signaled
; /* already signaled for this regexp */
282 bool force_explicit_name
; /* do not allow implicit tag name */
283 bool ignore_case
; /* ignore case when matching */
284 bool multi_line
; /* do a multi-line match on the whole file */
288 /* Many compilers barf on this:
289 Lang_function Ada_funcs;
290 so let's write it this way */
291 static void Ada_funcs (FILE *);
292 static void Asm_labels (FILE *);
293 static void C_entries (int c_ext
, FILE *);
294 static void default_C_entries (FILE *);
295 static void plain_C_entries (FILE *);
296 static void Cjava_entries (FILE *);
297 static void Cobol_paragraphs (FILE *);
298 static void Cplusplus_entries (FILE *);
299 static void Cstar_entries (FILE *);
300 static void Erlang_functions (FILE *);
301 static void Forth_words (FILE *);
302 static void Fortran_functions (FILE *);
303 static void HTML_labels (FILE *);
304 static void Lisp_functions (FILE *);
305 static void Lua_functions (FILE *);
306 static void Makefile_targets (FILE *);
307 static void Pascal_functions (FILE *);
308 static void Perl_functions (FILE *);
309 static void PHP_functions (FILE *);
310 static void PS_functions (FILE *);
311 static void Prolog_functions (FILE *);
312 static void Python_functions (FILE *);
313 static void Scheme_functions (FILE *);
314 static void TeX_commands (FILE *);
315 static void Texinfo_nodes (FILE *);
316 static void Yacc_entries (FILE *);
317 static void just_read_file (FILE *);
319 static void print_language_names (void);
320 static void print_version (void);
321 static void print_help (argument
*);
322 int main (int, char **);
324 static compressor
*get_compressor_from_suffix (char *, char **);
325 static language
*get_language_from_langname (const char *);
326 static language
*get_language_from_interpreter (char *);
327 static language
*get_language_from_filename (char *, bool);
328 static void readline (linebuffer
*, FILE *);
329 static long readline_internal (linebuffer
*, FILE *);
330 static bool nocase_tail (const char *);
331 static void get_tag (char *, char **);
333 static void analyse_regex (char *);
334 static void free_regexps (void);
335 static void regex_tag_multiline (void);
336 static void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
337 static _Noreturn
void suggest_asking_for_help (void);
338 _Noreturn
void fatal (const char *, const char *);
339 static _Noreturn
void pfatal (const char *);
340 static void add_node (node
*, node
**);
342 static void init (void);
343 static void process_file_name (char *, language
*);
344 static void process_file (FILE *, char *, language
*);
345 static void find_entries (FILE *);
346 static void free_tree (node
*);
347 static void free_fdesc (fdesc
*);
348 static void pfnote (char *, bool, char *, int, int, long);
349 static void make_tag (const char *, int, bool, char *, int, int, long);
350 static void invalidate_nodes (fdesc
*, node
**);
351 static void put_entries (node
*);
353 static char *concat (const char *, const char *, const char *);
354 static char *skip_spaces (char *);
355 static char *skip_non_spaces (char *);
356 static char *savenstr (const char *, int);
357 static char *savestr (const char *);
358 static char *etags_strchr (const char *, int);
359 static char *etags_strrchr (const char *, int);
360 static char *etags_getcwd (void);
361 static char *relative_filename (char *, char *);
362 static char *absolute_filename (char *, char *);
363 static char *absolute_dirname (char *, char *);
364 static bool filename_is_absolute (char *f
);
365 static void canonicalize_filename (char *);
366 static void linebuffer_init (linebuffer
*);
367 static void linebuffer_setlen (linebuffer
*, int);
368 static void *xmalloc (size_t);
369 static void *xrealloc (char *, size_t);
372 static char searchar
= '/'; /* use /.../ searches */
374 static char *tagfile
; /* output file */
375 static char *progname
; /* name this program was invoked with */
376 static char *cwd
; /* current working directory */
377 static char *tagfiledir
; /* directory of tagfile */
378 static FILE *tagf
; /* ioptr for tags file */
379 static ptrdiff_t whatlen_max
; /* maximum length of any 'what' member */
381 static fdesc
*fdhead
; /* head of file description list */
382 static fdesc
*curfdp
; /* current file description */
383 static int lineno
; /* line number of current line */
384 static long charno
; /* current character number */
385 static long linecharno
; /* charno of start of current line */
386 static char *dbp
; /* pointer to start of current tag */
388 static const int invalidcharno
= -1;
390 static node
*nodehead
; /* the head of the binary tree of tags */
391 static node
*last_node
; /* the last node created */
393 static linebuffer lb
; /* the current line */
394 static linebuffer filebuf
; /* a buffer containing the whole file */
395 static linebuffer token_name
; /* a buffer containing a tag name */
397 /* boolean "functions" (see init) */
398 static bool _wht
[CHARS
], _nin
[CHARS
], _itk
[CHARS
], _btk
[CHARS
], _etk
[CHARS
];
401 *white
= " \f\t\n\r\v",
403 *nonam
= " \f\t\n\r()=,;", /* look at make_tag before modifying! */
404 /* token ending chars */
405 *endtk
= " \t\n\r\"'#()[]{}=-+%*/&|^~!<>;,.:?",
406 /* token starting chars */
407 *begtk
= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$~@",
408 /* valid in-token chars */
409 *midtk
= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$0123456789";
411 static bool append_to_tagfile
; /* -a: append to tags */
412 /* The next five default to TRUE in C and derived languages. */
413 static bool typedefs
; /* -t: create tags for C and Ada typedefs */
414 static bool typedefs_or_cplusplus
; /* -T: create tags for C typedefs, level */
415 /* 0 struct/enum/union decls, and C++ */
416 /* member functions. */
417 static bool constantypedefs
; /* -d: create tags for C #define, enum */
418 /* constants and variables. */
419 /* -D: opposite of -d. Default under ctags. */
420 static bool globals
; /* create tags for global variables */
421 static bool members
; /* create tags for C member variables */
422 static bool declarations
; /* --declarations: tag them and extern in C&Co*/
423 static bool no_line_directive
; /* ignore #line directives (undocumented) */
424 static bool no_duplicates
; /* no duplicate tags for ctags (undocumented) */
425 static bool update
; /* -u: update tags */
426 static bool vgrind_style
; /* -v: create vgrind style index output */
427 static bool no_warnings
; /* -w: suppress warnings (undocumented) */
428 static bool cxref_style
; /* -x: create cxref style output */
429 static bool cplusplus
; /* .[hc] means C++, not C (undocumented) */
430 static bool ignoreindent
; /* -I: ignore indentation in C */
431 static bool packages_only
; /* --packages-only: in Ada, only tag packages*/
433 /* STDIN is defined in LynxOS system headers */
438 #define STDIN 0x1001 /* returned by getopt_long on --parse-stdin */
439 static bool parsing_stdin
; /* --parse-stdin used */
441 static regexp
*p_head
; /* list of all regexps */
442 static bool need_filebuf
; /* some regexes are multi-line */
444 static struct option longopts
[] =
446 { "append", no_argument
, NULL
, 'a' },
447 { "packages-only", no_argument
, &packages_only
, TRUE
},
448 { "c++", no_argument
, NULL
, 'C' },
449 { "declarations", no_argument
, &declarations
, TRUE
},
450 { "no-line-directive", no_argument
, &no_line_directive
, TRUE
},
451 { "no-duplicates", no_argument
, &no_duplicates
, TRUE
},
452 { "help", no_argument
, NULL
, 'h' },
453 { "help", no_argument
, NULL
, 'H' },
454 { "ignore-indentation", no_argument
, NULL
, 'I' },
455 { "language", required_argument
, NULL
, 'l' },
456 { "members", no_argument
, &members
, TRUE
},
457 { "no-members", no_argument
, &members
, FALSE
},
458 { "output", required_argument
, NULL
, 'o' },
459 { "regex", required_argument
, NULL
, 'r' },
460 { "no-regex", no_argument
, NULL
, 'R' },
461 { "ignore-case-regex", required_argument
, NULL
, 'c' },
462 { "parse-stdin", required_argument
, NULL
, STDIN
},
463 { "version", no_argument
, NULL
, 'V' },
465 #if CTAGS /* Ctags options */
466 { "backward-search", no_argument
, NULL
, 'B' },
467 { "cxref", no_argument
, NULL
, 'x' },
468 { "defines", no_argument
, NULL
, 'd' },
469 { "globals", no_argument
, &globals
, TRUE
},
470 { "typedefs", no_argument
, NULL
, 't' },
471 { "typedefs-and-c++", no_argument
, NULL
, 'T' },
472 { "update", no_argument
, NULL
, 'u' },
473 { "vgrind", no_argument
, NULL
, 'v' },
474 { "no-warn", no_argument
, NULL
, 'w' },
476 #else /* Etags options */
477 { "no-defines", no_argument
, NULL
, 'D' },
478 { "no-globals", no_argument
, &globals
, FALSE
},
479 { "include", required_argument
, NULL
, 'i' },
484 static compressor compressors
[] =
486 { "z", "gzip -d -c"},
487 { "Z", "gzip -d -c"},
488 { "gz", "gzip -d -c"},
489 { "GZ", "gzip -d -c"},
490 { "bz2", "bzip2 -d -c" },
491 { "xz", "xz -d -c" },
500 static const char *Ada_suffixes
[] =
501 { "ads", "adb", "ada", NULL
};
502 static const char Ada_help
[] =
503 "In Ada code, functions, procedures, packages, tasks and types are\n\
504 tags. Use the `--packages-only' option to create tags for\n\
506 Ada tag names have suffixes indicating the type of entity:\n\
507 Entity type: Qualifier:\n\
508 ------------ ----------\n\
515 Thus, `M-x find-tag <RET> bidule/b <RET>' will go directly to the\n\
516 body of the package `bidule', while `M-x find-tag <RET> bidule <RET>'\n\
517 will just search for any tag `bidule'.";
520 static const char *Asm_suffixes
[] =
521 { "a", /* Unix assembler */
522 "asm", /* Microcontroller assembly */
523 "def", /* BSO/Tasking definition includes */
524 "inc", /* Microcontroller include files */
525 "ins", /* Microcontroller include files */
526 "s", "sa", /* Unix assembler */
527 "S", /* cpp-processed Unix assembler */
528 "src", /* BSO/Tasking C compiler output */
531 static const char Asm_help
[] =
532 "In assembler code, labels appearing at the beginning of a line,\n\
533 followed by a colon, are tags.";
536 /* Note that .c and .h can be considered C++, if the --c++ flag was
537 given, or if the `class' or `template' keywords are met inside the file.
538 That is why default_C_entries is called for these. */
539 static const char *default_C_suffixes
[] =
541 #if CTAGS /* C help for Ctags */
542 static const char default_C_help
[] =
543 "In C code, any C function is a tag. Use -t to tag typedefs.\n\
544 Use -T to tag definitions of `struct', `union' and `enum'.\n\
545 Use -d to tag `#define' macro definitions and `enum' constants.\n\
546 Use --globals to tag global variables.\n\
547 You can tag function declarations and external variables by\n\
548 using `--declarations', and struct members by using `--members'.";
549 #else /* C help for Etags */
550 static const char default_C_help
[] =
551 "In C code, any C function or typedef is a tag, and so are\n\
552 definitions of `struct', `union' and `enum'. `#define' macro\n\
553 definitions and `enum' constants are tags unless you specify\n\
554 `--no-defines'. Global variables are tags unless you specify\n\
555 `--no-globals' and so are struct members unless you specify\n\
556 `--no-members'. Use of `--no-globals', `--no-defines' and\n\
557 `--no-members' can make the tags table file much smaller.\n\
558 You can tag function declarations and external variables by\n\
559 using `--declarations'.";
560 #endif /* C help for Ctags and Etags */
562 static const char *Cplusplus_suffixes
[] =
563 { "C", "c++", "cc", "cpp", "cxx", "H", "h++", "hh", "hpp", "hxx",
564 "M", /* Objective C++ */
565 "pdb", /* PostScript with C syntax */
567 static const char Cplusplus_help
[] =
568 "In C++ code, all the tag constructs of C code are tagged. (Use\n\
569 --help --lang=c --lang=c++ for full help.)\n\
570 In addition to C tags, member functions are also recognized. Member\n\
571 variables are recognized unless you use the `--no-members' option.\n\
572 Tags for variables and functions in classes are named `CLASS::VARIABLE'\n\
573 and `CLASS::FUNCTION'. `operator' definitions have tag names like\n\
576 static const char *Cjava_suffixes
[] =
578 static char Cjava_help
[] =
579 "In Java code, all the tags constructs of C and C++ code are\n\
580 tagged. (Use --help --lang=c --lang=c++ --lang=java for full help.)";
583 static const char *Cobol_suffixes
[] =
584 { "COB", "cob", NULL
};
585 static char Cobol_help
[] =
586 "In Cobol code, tags are paragraph names; that is, any word\n\
587 starting in column 8 and followed by a period.";
589 static const char *Cstar_suffixes
[] =
590 { "cs", "hs", NULL
};
592 static const char *Erlang_suffixes
[] =
593 { "erl", "hrl", NULL
};
594 static const char Erlang_help
[] =
595 "In Erlang code, the tags are the functions, records and macros\n\
596 defined in the file.";
598 const char *Forth_suffixes
[] =
599 { "fth", "tok", NULL
};
600 static const char Forth_help
[] =
601 "In Forth code, tags are words defined by `:',\n\
602 constant, code, create, defer, value, variable, buffer:, field.";
604 static const char *Fortran_suffixes
[] =
605 { "F", "f", "f90", "for", NULL
};
606 static const char Fortran_help
[] =
607 "In Fortran code, functions, subroutines and block data are tags.";
609 static const char *HTML_suffixes
[] =
610 { "htm", "html", "shtml", NULL
};
611 static const char HTML_help
[] =
612 "In HTML input files, the tags are the `title' and the `h1', `h2',\n\
613 `h3' headers. Also, tags are `name=' in anchors and all\n\
614 occurrences of `id='.";
616 static const char *Lisp_suffixes
[] =
617 { "cl", "clisp", "el", "l", "lisp", "LSP", "lsp", "ml", NULL
};
618 static const char Lisp_help
[] =
619 "In Lisp code, any function defined with `defun', any variable\n\
620 defined with `defvar' or `defconst', and in general the first\n\
621 argument of any expression that starts with `(def' in column zero\n\
624 static const char *Lua_suffixes
[] =
625 { "lua", "LUA", NULL
};
626 static const char Lua_help
[] =
627 "In Lua scripts, all functions are tags.";
629 static const char *Makefile_filenames
[] =
630 { "Makefile", "makefile", "GNUMakefile", "Makefile.in", "Makefile.am", NULL
};
631 static const char Makefile_help
[] =
632 "In makefiles, targets are tags; additionally, variables are tags\n\
633 unless you specify `--no-globals'.";
635 static const char *Objc_suffixes
[] =
636 { "lm", /* Objective lex file */
637 "m", /* Objective C file */
639 static const char Objc_help
[] =
640 "In Objective C code, tags include Objective C definitions for classes,\n\
641 class categories, methods and protocols. Tags for variables and\n\
642 functions in classes are named `CLASS::VARIABLE' and `CLASS::FUNCTION'.\n\
643 (Use --help --lang=c --lang=objc --lang=java for full help.)";
645 static const char *Pascal_suffixes
[] =
646 { "p", "pas", NULL
};
647 static const char Pascal_help
[] =
648 "In Pascal code, the tags are the functions and procedures defined\n\
650 /* " // this is for working around an Emacs highlighting bug... */
652 static const char *Perl_suffixes
[] =
653 { "pl", "pm", NULL
};
654 static const char *Perl_interpreters
[] =
655 { "perl", "@PERL@", NULL
};
656 static const char Perl_help
[] =
657 "In Perl code, the tags are the packages, subroutines and variables\n\
658 defined by the `package', `sub', `my' and `local' keywords. Use\n\
659 `--globals' if you want to tag global variables. Tags for\n\
660 subroutines are named `PACKAGE::SUB'. The name for subroutines\n\
661 defined in the default package is `main::SUB'.";
663 static const char *PHP_suffixes
[] =
664 { "php", "php3", "php4", NULL
};
665 static const char PHP_help
[] =
666 "In PHP code, tags are functions, classes and defines. Unless you use\n\
667 the `--no-members' option, vars are tags too.";
669 static const char *plain_C_suffixes
[] =
670 { "pc", /* Pro*C file */
673 static const char *PS_suffixes
[] =
674 { "ps", "psw", NULL
}; /* .psw is for PSWrap */
675 static const char PS_help
[] =
676 "In PostScript code, the tags are the functions.";
678 static const char *Prolog_suffixes
[] =
680 static const char Prolog_help
[] =
681 "In Prolog code, tags are predicates and rules at the beginning of\n\
684 static const char *Python_suffixes
[] =
686 static const char Python_help
[] =
687 "In Python code, `def' or `class' at the beginning of a line\n\
690 /* Can't do the `SCM' or `scm' prefix with a version number. */
691 static const char *Scheme_suffixes
[] =
692 { "oak", "sch", "scheme", "SCM", "scm", "SM", "sm", "ss", "t", NULL
};
693 static const char Scheme_help
[] =
694 "In Scheme code, tags include anything defined with `def' or with a\n\
695 construct whose name starts with `def'. They also include\n\
696 variables set with `set!' at top level in the file.";
698 static const char *TeX_suffixes
[] =
699 { "bib", "clo", "cls", "ltx", "sty", "TeX", "tex", NULL
};
700 static const char TeX_help
[] =
701 "In LaTeX text, the argument of any of the commands `\\chapter',\n\
702 `\\section', `\\subsection', `\\subsubsection', `\\eqno', `\\label',\n\
703 `\\ref', `\\cite', `\\bibitem', `\\part', `\\appendix', `\\entry',\n\
704 `\\index', `\\def', `\\newcommand', `\\renewcommand',\n\
705 `\\newenvironment' or `\\renewenvironment' is a tag.\n\
707 Other commands can be specified by setting the environment variable\n\
708 `TEXTAGS' to a colon-separated list like, for example,\n\
709 TEXTAGS=\"mycommand:myothercommand\".";
712 static const char *Texinfo_suffixes
[] =
713 { "texi", "texinfo", "txi", NULL
};
714 static const char Texinfo_help
[] =
715 "for texinfo files, lines starting with @node are tagged.";
717 static const char *Yacc_suffixes
[] =
718 { "y", "y++", "ym", "yxx", "yy", NULL
}; /* .ym is Objective yacc file */
719 static const char Yacc_help
[] =
720 "In Bison or Yacc input files, each rule defines as a tag the\n\
721 nonterminal it constructs. The portions of the file that contain\n\
722 C code are parsed as C code (use --help --lang=c --lang=yacc\n\
725 static const char auto_help
[] =
726 "`auto' is not a real language, it indicates to use\n\
727 a default language for files base on file name suffix and file contents.";
729 static const char none_help
[] =
730 "`none' is not a real language, it indicates to only do\n\
731 regexp processing on files.";
733 static const char no_lang_help
[] =
734 "No detailed help available for this language.";
738 * Table of languages.
740 * It is ok for a given function to be listed under more than one
741 * name. I just didn't.
744 static language lang_names
[] =
746 { "ada", Ada_help
, Ada_funcs
, Ada_suffixes
},
747 { "asm", Asm_help
, Asm_labels
, Asm_suffixes
},
748 { "c", default_C_help
, default_C_entries
, default_C_suffixes
},
749 { "c++", Cplusplus_help
, Cplusplus_entries
, Cplusplus_suffixes
},
750 { "c*", no_lang_help
, Cstar_entries
, Cstar_suffixes
},
751 { "cobol", Cobol_help
, Cobol_paragraphs
, Cobol_suffixes
},
752 { "erlang", Erlang_help
, Erlang_functions
, Erlang_suffixes
},
753 { "forth", Forth_help
, Forth_words
, Forth_suffixes
},
754 { "fortran", Fortran_help
, Fortran_functions
, Fortran_suffixes
},
755 { "html", HTML_help
, HTML_labels
, HTML_suffixes
},
756 { "java", Cjava_help
, Cjava_entries
, Cjava_suffixes
},
757 { "lisp", Lisp_help
, Lisp_functions
, Lisp_suffixes
},
758 { "lua", Lua_help
, Lua_functions
, Lua_suffixes
},
759 { "makefile", Makefile_help
,Makefile_targets
,NULL
,Makefile_filenames
},
760 { "objc", Objc_help
, plain_C_entries
, Objc_suffixes
},
761 { "pascal", Pascal_help
, Pascal_functions
, Pascal_suffixes
},
762 { "perl",Perl_help
,Perl_functions
,Perl_suffixes
,NULL
,Perl_interpreters
},
763 { "php", PHP_help
, PHP_functions
, PHP_suffixes
},
764 { "postscript",PS_help
, PS_functions
, PS_suffixes
},
765 { "proc", no_lang_help
, plain_C_entries
, plain_C_suffixes
},
766 { "prolog", Prolog_help
, Prolog_functions
, Prolog_suffixes
},
767 { "python", Python_help
, Python_functions
, Python_suffixes
},
768 { "scheme", Scheme_help
, Scheme_functions
, Scheme_suffixes
},
769 { "tex", TeX_help
, TeX_commands
, TeX_suffixes
},
770 { "texinfo", Texinfo_help
, Texinfo_nodes
, Texinfo_suffixes
},
771 { "yacc", Yacc_help
,Yacc_entries
,Yacc_suffixes
,NULL
,NULL
,TRUE
},
772 { "auto", auto_help
}, /* default guessing scheme */
773 { "none", none_help
, just_read_file
}, /* regexp matching only */
774 { NULL
} /* end of list */
779 print_language_names (void)
782 const char **name
, **ext
;
784 puts ("\nThese are the currently supported languages, along with the\n\
785 default file names and dot suffixes:");
786 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
788 printf (" %-*s", 10, lang
->name
);
789 if (lang
->filenames
!= NULL
)
790 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
791 printf (" %s", *name
);
792 if (lang
->suffixes
!= NULL
)
793 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
794 printf (" .%s", *ext
);
797 puts ("where `auto' means use default language for files based on file\n\
798 name suffix, and `none' means only do regexp processing on files.\n\
799 If no language is specified and no matching suffix is found,\n\
800 the first line of the file is read for a sharp-bang (#!) sequence\n\
801 followed by the name of an interpreter. If no such sequence is found,\n\
802 Fortran is tried first; if no tags are found, C is tried next.\n\
803 When parsing any C file, a \"class\" or \"template\" keyword\n\
805 puts ("Compressed files are supported using gzip, bzip2, and xz.\n\
807 For detailed help on a given language use, for example,\n\
808 etags --help --lang=ada.");
812 # define EMACS_NAME "standalone"
815 # define VERSION "17.38.1.4"
820 char emacs_copyright
[] = COPYRIGHT
;
822 printf ("%s (%s %s)\n", (CTAGS
) ? "ctags" : "etags", EMACS_NAME
, VERSION
);
823 puts (emacs_copyright
);
824 puts ("This program is distributed under the terms in ETAGS.README");
829 #ifndef PRINT_UNDOCUMENTED_OPTIONS_HELP
830 # define PRINT_UNDOCUMENTED_OPTIONS_HELP FALSE
834 print_help (argument
*argbuffer
)
836 bool help_for_lang
= FALSE
;
838 for (; argbuffer
->arg_type
!= at_end
; argbuffer
++)
839 if (argbuffer
->arg_type
== at_language
)
843 puts (argbuffer
->lang
->help
);
844 help_for_lang
= TRUE
;
850 printf ("Usage: %s [options] [[regex-option ...] file-name] ...\n\
852 These are the options accepted by %s.\n", progname
, progname
);
853 puts ("You may use unambiguous abbreviations for the long option names.");
854 puts (" A - as file name means read names from stdin (one per line).\n\
855 Absolute names are stored in the output file as they are.\n\
856 Relative ones are stored relative to the output file's directory.\n");
858 puts ("-a, --append\n\
859 Append tag entries to existing tags file.");
861 puts ("--packages-only\n\
862 For Ada files, only generate tags for packages.");
865 puts ("-B, --backward-search\n\
866 Write the search commands for the tag entries using '?', the\n\
867 backward-search command instead of '/', the forward-search command.");
869 /* This option is mostly obsolete, because etags can now automatically
870 detect C++. Retained for backward compatibility and for debugging and
871 experimentation. In principle, we could want to tag as C++ even
872 before any "class" or "template" keyword.
874 Treat files whose name suffix defaults to C language as C++ files.");
877 puts ("--declarations\n\
878 In C and derived languages, create tags for function declarations,");
880 puts ("\tand create tags for extern variables if --globals is used.");
883 ("\tand create tags for extern variables unless --no-globals is used.");
886 puts ("-d, --defines\n\
887 Create tag entries for C #define constants and enum constants, too.");
889 puts ("-D, --no-defines\n\
890 Don't create tag entries for C #define constants and enum constants.\n\
891 This makes the tags file smaller.");
894 puts ("-i FILE, --include=FILE\n\
895 Include a note in tag file indicating that, when searching for\n\
896 a tag, one should also consult the tags file FILE after\n\
897 checking the current file.");
899 puts ("-l LANG, --language=LANG\n\
900 Force the following files to be considered as written in the\n\
901 named language up to the next --language=LANG option.");
905 Create tag entries for global variables in some languages.");
907 puts ("--no-globals\n\
908 Do not create tag entries for global variables in some\n\
909 languages. This makes the tags file smaller.");
911 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
912 puts ("--no-line-directive\n\
913 Ignore #line preprocessor directives in C and derived languages.");
917 Create tag entries for members of structures in some languages.");
919 puts ("--no-members\n\
920 Do not create tag entries for members of structures\n\
921 in some languages.");
923 puts ("-r REGEXP, --regex=REGEXP or --regex=@regexfile\n\
924 Make a tag for each line matching a regular expression pattern\n\
925 in the following files. {LANGUAGE}REGEXP uses REGEXP for LANGUAGE\n\
926 files only. REGEXFILE is a file containing one REGEXP per line.\n\
927 REGEXP takes the form /TAGREGEXP/TAGNAME/MODS, where TAGNAME/ is\n\
928 optional. The TAGREGEXP pattern is anchored (as if preceded by ^).");
929 puts (" If TAGNAME/ is present, the tags created are named.\n\
930 For example Tcl named tags can be created with:\n\
931 --regex=\"/proc[ \\t]+\\([^ \\t]+\\)/\\1/.\".\n\
932 MODS are optional one-letter modifiers: `i' means to ignore case,\n\
933 `m' means to allow multi-line matches, `s' implies `m' and\n\
934 causes dot to match any character, including newline.");
936 puts ("-R, --no-regex\n\
937 Don't create tags from regexps for the following files.");
939 puts ("-I, --ignore-indentation\n\
940 In C and C++ do not assume that a closing brace in the first\n\
941 column is the final brace of a function or structure definition.");
943 puts ("-o FILE, --output=FILE\n\
944 Write the tags to FILE.");
946 puts ("--parse-stdin=NAME\n\
947 Read from standard input and record tags as belonging to file NAME.");
951 puts ("-t, --typedefs\n\
952 Generate tag entries for C and Ada typedefs.");
953 puts ("-T, --typedefs-and-c++\n\
954 Generate tag entries for C typedefs, C struct/enum/union tags,\n\
955 and C++ member functions.");
959 puts ("-u, --update\n\
960 Update the tag entries for the given files, leaving tag\n\
961 entries for other files in place. Currently, this is\n\
962 implemented by deleting the existing entries for the given\n\
963 files and then rewriting the new entries at the end of the\n\
964 tags file. It is often faster to simply rebuild the entire\n\
965 tag file than to use this.");
969 puts ("-v, --vgrind\n\
970 Print on the standard output an index of items intended for\n\
971 human consumption, similar to the output of vgrind. The index\n\
972 is sorted, and gives the page number of each item.");
974 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
975 puts ("-w, --no-duplicates\n\
976 Do not create duplicate tag entries, for compatibility with\n\
977 traditional ctags.");
979 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
980 puts ("-w, --no-warn\n\
981 Suppress warning messages about duplicate tag entries.");
983 puts ("-x, --cxref\n\
984 Like --vgrind, but in the style of cxref, rather than vgrind.\n\
985 The output uses line numbers instead of page numbers, but\n\
986 beyond that the differences are cosmetic; try both to see\n\
990 puts ("-V, --version\n\
991 Print the version of the program.\n\
993 Print this help message.\n\
994 Followed by one or more `--language' options prints detailed\n\
995 help about tag generation for the specified languages.");
997 print_language_names ();
1000 puts ("Report bugs to bug-gnu-emacs@gnu.org");
1002 exit (EXIT_SUCCESS
);
1007 main (int argc
, char **argv
)
1010 unsigned int nincluded_files
;
1011 char **included_files
;
1012 argument
*argbuffer
;
1013 int current_arg
, file_count
;
1014 linebuffer filename_lb
;
1015 bool help_asked
= FALSE
;
1022 _fmode
= O_BINARY
; /* all of files are treated as binary files */
1026 nincluded_files
= 0;
1027 included_files
= xnew (argc
, char *);
1031 /* Allocate enough no matter what happens. Overkill, but each one
1033 argbuffer
= xnew (argc
, argument
);
1036 * Always find typedefs and structure tags.
1037 * Also default to find macro constants, enum constants, struct
1038 * members and global variables. Do it for both etags and ctags.
1040 typedefs
= typedefs_or_cplusplus
= constantypedefs
= TRUE
;
1041 globals
= members
= TRUE
;
1043 /* When the optstring begins with a '-' getopt_long does not rearrange the
1044 non-options arguments to be at the end, but leaves them alone. */
1045 optstring
= concat ("-ac:Cf:Il:o:r:RSVhH",
1046 (CTAGS
) ? "BxdtTuvw" : "Di:",
1049 while ((opt
= getopt_long (argc
, argv
, optstring
, longopts
, NULL
)) != EOF
)
1053 /* If getopt returns 0, then it has already processed a
1054 long-named option. We should do nothing. */
1058 /* This means that a file name has been seen. Record it. */
1059 argbuffer
[current_arg
].arg_type
= at_filename
;
1060 argbuffer
[current_arg
].what
= optarg
;
1061 len
= strlen (optarg
);
1062 if (whatlen_max
< len
)
1069 /* Parse standard input. Idea by Vivek <vivek@etla.org>. */
1070 argbuffer
[current_arg
].arg_type
= at_stdin
;
1071 argbuffer
[current_arg
].what
= optarg
;
1072 len
= strlen (optarg
);
1073 if (whatlen_max
< len
)
1078 fatal ("cannot parse standard input more than once", (char *)NULL
);
1079 parsing_stdin
= TRUE
;
1082 /* Common options. */
1083 case 'a': append_to_tagfile
= TRUE
; break;
1084 case 'C': cplusplus
= TRUE
; break;
1085 case 'f': /* for compatibility with old makefiles */
1089 error ("-o option may only be given once.");
1090 suggest_asking_for_help ();
1096 case 'S': /* for backward compatibility */
1097 ignoreindent
= TRUE
;
1101 language
*lang
= get_language_from_langname (optarg
);
1104 argbuffer
[current_arg
].lang
= lang
;
1105 argbuffer
[current_arg
].arg_type
= at_language
;
1111 /* Backward compatibility: support obsolete --ignore-case-regexp. */
1112 optarg
= concat (optarg
, "i", ""); /* memory leak here */
1115 argbuffer
[current_arg
].arg_type
= at_regexp
;
1116 argbuffer
[current_arg
].what
= optarg
;
1117 len
= strlen (optarg
);
1118 if (whatlen_max
< len
)
1123 argbuffer
[current_arg
].arg_type
= at_regexp
;
1124 argbuffer
[current_arg
].what
= NULL
;
1136 case 'D': constantypedefs
= FALSE
; break;
1137 case 'i': included_files
[nincluded_files
++] = optarg
; break;
1139 /* Ctags options. */
1140 case 'B': searchar
= '?'; break;
1141 case 'd': constantypedefs
= TRUE
; break;
1142 case 't': typedefs
= TRUE
; break;
1143 case 'T': typedefs
= typedefs_or_cplusplus
= TRUE
; break;
1144 case 'u': update
= TRUE
; break;
1145 case 'v': vgrind_style
= TRUE
; /*FALLTHRU*/
1146 case 'x': cxref_style
= TRUE
; break;
1147 case 'w': no_warnings
= TRUE
; break;
1149 suggest_asking_for_help ();
1153 /* No more options. Store the rest of arguments. */
1154 for (; optind
< argc
; optind
++)
1156 argbuffer
[current_arg
].arg_type
= at_filename
;
1157 argbuffer
[current_arg
].what
= argv
[optind
];
1158 len
= strlen (argv
[optind
]);
1159 if (whatlen_max
< len
)
1165 argbuffer
[current_arg
].arg_type
= at_end
;
1168 print_help (argbuffer
);
1171 if (nincluded_files
== 0 && file_count
== 0)
1173 error ("no input files specified.");
1174 suggest_asking_for_help ();
1178 if (tagfile
== NULL
)
1179 tagfile
= savestr (CTAGS
? "tags" : "TAGS");
1180 cwd
= etags_getcwd (); /* the current working directory */
1181 if (cwd
[strlen (cwd
) - 1] != '/')
1184 cwd
= concat (oldcwd
, "/", "");
1188 /* Compute base directory for relative file names. */
1189 if (streq (tagfile
, "-")
1190 || strneq (tagfile
, "/dev/", 5))
1191 tagfiledir
= cwd
; /* relative file names are relative to cwd */
1194 canonicalize_filename (tagfile
);
1195 tagfiledir
= absolute_dirname (tagfile
, cwd
);
1198 init (); /* set up boolean "functions" */
1200 linebuffer_init (&lb
);
1201 linebuffer_init (&filename_lb
);
1202 linebuffer_init (&filebuf
);
1203 linebuffer_init (&token_name
);
1207 if (streq (tagfile
, "-"))
1211 /* Switch redirected `stdout' to binary mode (setting `_fmode'
1212 doesn't take effect until after `stdout' is already open). */
1213 if (!isatty (fileno (stdout
)))
1214 setmode (fileno (stdout
), O_BINARY
);
1218 tagf
= fopen (tagfile
, append_to_tagfile
? "a" : "w");
1224 * Loop through files finding functions.
1226 for (i
= 0; i
< current_arg
; i
++)
1228 static language
*lang
; /* non-NULL if language is forced */
1231 switch (argbuffer
[i
].arg_type
)
1234 lang
= argbuffer
[i
].lang
;
1237 analyse_regex (argbuffer
[i
].what
);
1240 this_file
= argbuffer
[i
].what
;
1241 /* Input file named "-" means read file names from stdin
1242 (one per line) and use them. */
1243 if (streq (this_file
, "-"))
1246 fatal ("cannot parse standard input AND read file names from it",
1248 while (readline_internal (&filename_lb
, stdin
) > 0)
1249 process_file_name (filename_lb
.buffer
, lang
);
1252 process_file_name (this_file
, lang
);
1255 this_file
= argbuffer
[i
].what
;
1256 process_file (stdin
, this_file
, lang
);
1263 free (filebuf
.buffer
);
1264 free (token_name
.buffer
);
1266 if (!CTAGS
|| cxref_style
)
1268 /* Write the remaining tags to tagf (ETAGS) or stdout (CXREF). */
1269 put_entries (nodehead
);
1270 free_tree (nodehead
);
1276 /* Output file entries that have no tags. */
1277 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1279 fprintf (tagf
, "\f\n%s,0\n", fdp
->taggedfname
);
1281 while (nincluded_files
-- > 0)
1282 fprintf (tagf
, "\f\n%s,include\n", *included_files
++);
1284 if (fclose (tagf
) == EOF
)
1288 exit (EXIT_SUCCESS
);
1291 /* From here on, we are in (CTAGS && !cxref_style) */
1295 xmalloc (strlen (tagfile
) + whatlen_max
+
1296 sizeof "mv..OTAGS;fgrep -v '\t\t' OTAGS >;rm OTAGS");
1297 for (i
= 0; i
< current_arg
; ++i
)
1299 switch (argbuffer
[i
].arg_type
)
1305 continue; /* the for loop */
1307 strcpy (cmd
, "mv ");
1308 strcat (cmd
, tagfile
);
1309 strcat (cmd
, " OTAGS;fgrep -v '\t");
1310 strcat (cmd
, argbuffer
[i
].what
);
1311 strcat (cmd
, "\t' OTAGS >");
1312 strcat (cmd
, tagfile
);
1313 strcat (cmd
, ";rm OTAGS");
1314 if (system (cmd
) != EXIT_SUCCESS
)
1315 fatal ("failed to execute shell command", (char *)NULL
);
1318 append_to_tagfile
= TRUE
;
1321 tagf
= fopen (tagfile
, append_to_tagfile
? "a" : "w");
1324 put_entries (nodehead
); /* write all the tags (CTAGS) */
1325 free_tree (nodehead
);
1327 if (fclose (tagf
) == EOF
)
1331 if (append_to_tagfile
|| update
)
1333 char *cmd
= xmalloc (2 * strlen (tagfile
) + sizeof "sort -u -o..");
1334 /* Maybe these should be used:
1335 setenv ("LC_COLLATE", "C", 1);
1336 setenv ("LC_ALL", "C", 1); */
1337 strcpy (cmd
, "sort -u -o ");
1338 strcat (cmd
, tagfile
);
1340 strcat (cmd
, tagfile
);
1341 exit (system (cmd
));
1343 return EXIT_SUCCESS
;
1348 * Return a compressor given the file name. If EXTPTR is non-zero,
1349 * return a pointer into FILE where the compressor-specific
1350 * extension begins. If no compressor is found, NULL is returned
1351 * and EXTPTR is not significant.
1352 * Idea by Vladimir Alexiev <vladimir@cs.ualberta.ca> (1998)
1355 get_compressor_from_suffix (char *file
, char **extptr
)
1358 char *slash
, *suffix
;
1360 /* File has been processed by canonicalize_filename,
1361 so we don't need to consider backslashes on DOS_NT. */
1362 slash
= etags_strrchr (file
, '/');
1363 suffix
= etags_strrchr (file
, '.');
1364 if (suffix
== NULL
|| suffix
< slash
)
1369 /* Let those poor souls who live with DOS 8+3 file name limits get
1370 some solace by treating foo.cgz as if it were foo.c.gz, etc.
1371 Only the first do loop is run if not MSDOS */
1374 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1375 if (streq (compr
->suffix
, suffix
))
1378 break; /* do it only once: not really a loop */
1381 } while (*suffix
!= '\0');
1388 * Return a language given the name.
1391 get_language_from_langname (const char *name
)
1396 error ("empty language name");
1399 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1400 if (streq (name
, lang
->name
))
1402 error ("unknown language \"%s\"", name
);
1410 * Return a language given the interpreter name.
1413 get_language_from_interpreter (char *interpreter
)
1418 if (interpreter
== NULL
)
1420 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1421 if (lang
->interpreters
!= NULL
)
1422 for (iname
= lang
->interpreters
; *iname
!= NULL
; iname
++)
1423 if (streq (*iname
, interpreter
))
1432 * Return a language given the file name.
1435 get_language_from_filename (char *file
, int case_sensitive
)
1438 const char **name
, **ext
, *suffix
;
1440 /* Try whole file name first. */
1441 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1442 if (lang
->filenames
!= NULL
)
1443 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
1444 if ((case_sensitive
)
1445 ? streq (*name
, file
)
1446 : strcaseeq (*name
, file
))
1449 /* If not found, try suffix after last dot. */
1450 suffix
= etags_strrchr (file
, '.');
1454 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1455 if (lang
->suffixes
!= NULL
)
1456 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
1457 if ((case_sensitive
)
1458 ? streq (*ext
, suffix
)
1459 : strcaseeq (*ext
, suffix
))
1466 * This routine is called on each file argument.
1469 process_file_name (char *file
, language
*lang
)
1471 struct stat stat_buf
;
1475 char *compressed_name
, *uncompressed_name
;
1476 char *ext
, *real_name
;
1479 canonicalize_filename (file
);
1480 if (streq (file
, tagfile
) && !streq (tagfile
, "-"))
1482 error ("skipping inclusion of %s in self.", file
);
1485 if ((compr
= get_compressor_from_suffix (file
, &ext
)) == NULL
)
1487 compressed_name
= NULL
;
1488 real_name
= uncompressed_name
= savestr (file
);
1492 real_name
= compressed_name
= savestr (file
);
1493 uncompressed_name
= savenstr (file
, ext
- file
);
1496 /* If the canonicalized uncompressed name
1497 has already been dealt with, skip it silently. */
1498 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1500 assert (fdp
->infname
!= NULL
);
1501 if (streq (uncompressed_name
, fdp
->infname
))
1505 if (stat (real_name
, &stat_buf
) != 0)
1507 /* Reset real_name and try with a different name. */
1509 if (compressed_name
!= NULL
) /* try with the given suffix */
1511 if (stat (uncompressed_name
, &stat_buf
) == 0)
1512 real_name
= uncompressed_name
;
1514 else /* try all possible suffixes */
1516 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1518 compressed_name
= concat (file
, ".", compr
->suffix
);
1519 if (stat (compressed_name
, &stat_buf
) != 0)
1523 char *suf
= compressed_name
+ strlen (file
);
1524 size_t suflen
= strlen (compr
->suffix
) + 1;
1525 for ( ; suf
[1]; suf
++, suflen
--)
1527 memmove (suf
, suf
+ 1, suflen
);
1528 if (stat (compressed_name
, &stat_buf
) == 0)
1530 real_name
= compressed_name
;
1534 if (real_name
!= NULL
)
1537 free (compressed_name
);
1538 compressed_name
= NULL
;
1542 real_name
= compressed_name
;
1547 if (real_name
== NULL
)
1552 } /* try with a different name */
1554 if (!S_ISREG (stat_buf
.st_mode
))
1556 error ("skipping %s: it is not a regular file.", real_name
);
1559 if (real_name
== compressed_name
)
1561 char *cmd
= concat (compr
->command
, " ", real_name
);
1562 inf
= (FILE *) popen (cmd
, "r");
1566 inf
= fopen (real_name
, "r");
1573 process_file (inf
, uncompressed_name
, lang
);
1575 if (real_name
== compressed_name
)
1576 retval
= pclose (inf
);
1578 retval
= fclose (inf
);
1583 free (compressed_name
);
1584 free (uncompressed_name
);
1591 process_file (FILE *fh
, char *fn
, language
*lang
)
1593 static const fdesc emptyfdesc
;
1596 /* Create a new input file description entry. */
1597 fdp
= xnew (1, fdesc
);
1600 fdp
->infname
= savestr (fn
);
1602 fdp
->infabsname
= absolute_filename (fn
, cwd
);
1603 fdp
->infabsdir
= absolute_dirname (fn
, cwd
);
1604 if (filename_is_absolute (fn
))
1606 /* An absolute file name. Canonicalize it. */
1607 fdp
->taggedfname
= absolute_filename (fn
, NULL
);
1611 /* A file name relative to cwd. Make it relative
1612 to the directory of the tags file. */
1613 fdp
->taggedfname
= relative_filename (fn
, tagfiledir
);
1615 fdp
->usecharno
= TRUE
; /* use char position when making tags */
1617 fdp
->written
= FALSE
; /* not written on tags file yet */
1620 curfdp
= fdhead
; /* the current file description */
1624 /* If not Ctags, and if this is not metasource and if it contained no #line
1625 directives, we can write the tags and free all nodes pointing to
1628 && curfdp
->usecharno
/* no #line directives in this file */
1629 && !curfdp
->lang
->metasource
)
1633 /* Look for the head of the sublist relative to this file. See add_node
1634 for the structure of the node tree. */
1636 for (np
= nodehead
; np
!= NULL
; prev
= np
, np
= np
->left
)
1637 if (np
->fdp
== curfdp
)
1640 /* If we generated tags for this file, write and delete them. */
1643 /* This is the head of the last sublist, if any. The following
1644 instructions depend on this being true. */
1645 assert (np
->left
== NULL
);
1647 assert (fdhead
== curfdp
);
1648 assert (last_node
->fdp
== curfdp
);
1649 put_entries (np
); /* write tags for file curfdp->taggedfname */
1650 free_tree (np
); /* remove the written nodes */
1652 nodehead
= NULL
; /* no nodes left */
1654 prev
->left
= NULL
; /* delete the pointer to the sublist */
1660 * This routine sets up the boolean pseudo-functions which work
1661 * by setting boolean flags dependent upon the corresponding character.
1662 * Every char which is NOT in that string is not a white char. Therefore,
1663 * all of the array "_wht" is set to FALSE, and then the elements
1664 * subscripted by the chars in "white" are set to TRUE. Thus "_wht"
1665 * of a char is TRUE if it is the string "white", else FALSE.
1670 register const char *sp
;
1673 for (i
= 0; i
< CHARS
; i
++)
1674 iswhite (i
) = notinname (i
) = begtoken (i
) = intoken (i
) = endtoken (i
) = FALSE
;
1675 for (sp
= white
; *sp
!= '\0'; sp
++) iswhite (*sp
) = TRUE
;
1676 for (sp
= nonam
; *sp
!= '\0'; sp
++) notinname (*sp
) = TRUE
;
1677 notinname ('\0') = notinname ('\n');
1678 for (sp
= begtk
; *sp
!= '\0'; sp
++) begtoken (*sp
) = TRUE
;
1679 begtoken ('\0') = begtoken ('\n');
1680 for (sp
= midtk
; *sp
!= '\0'; sp
++) intoken (*sp
) = TRUE
;
1681 intoken ('\0') = intoken ('\n');
1682 for (sp
= endtk
; *sp
!= '\0'; sp
++) endtoken (*sp
) = TRUE
;
1683 endtoken ('\0') = endtoken ('\n');
1687 * This routine opens the specified file and calls the function
1688 * which finds the function and type definitions.
1691 find_entries (FILE *inf
)
1694 language
*lang
= curfdp
->lang
;
1695 Lang_function
*parser
= NULL
;
1697 /* If user specified a language, use it. */
1698 if (lang
!= NULL
&& lang
->function
!= NULL
)
1700 parser
= lang
->function
;
1703 /* Else try to guess the language given the file name. */
1706 lang
= get_language_from_filename (curfdp
->infname
, TRUE
);
1707 if (lang
!= NULL
&& lang
->function
!= NULL
)
1709 curfdp
->lang
= lang
;
1710 parser
= lang
->function
;
1714 /* Else look for sharp-bang as the first two characters. */
1716 && readline_internal (&lb
, inf
) > 0
1718 && lb
.buffer
[0] == '#'
1719 && lb
.buffer
[1] == '!')
1723 /* Set lp to point at the first char after the last slash in the
1724 line or, if no slashes, at the first nonblank. Then set cp to
1725 the first successive blank and terminate the string. */
1726 lp
= etags_strrchr (lb
.buffer
+2, '/');
1730 lp
= skip_spaces (lb
.buffer
+ 2);
1731 cp
= skip_non_spaces (lp
);
1734 if (strlen (lp
) > 0)
1736 lang
= get_language_from_interpreter (lp
);
1737 if (lang
!= NULL
&& lang
->function
!= NULL
)
1739 curfdp
->lang
= lang
;
1740 parser
= lang
->function
;
1745 /* We rewind here, even if inf may be a pipe. We fail if the
1746 length of the first line is longer than the pipe block size,
1747 which is unlikely. */
1750 /* Else try to guess the language given the case insensitive file name. */
1753 lang
= get_language_from_filename (curfdp
->infname
, FALSE
);
1754 if (lang
!= NULL
&& lang
->function
!= NULL
)
1756 curfdp
->lang
= lang
;
1757 parser
= lang
->function
;
1761 /* Else try Fortran or C. */
1764 node
*old_last_node
= last_node
;
1766 curfdp
->lang
= get_language_from_langname ("fortran");
1769 if (old_last_node
== last_node
)
1770 /* No Fortran entries found. Try C. */
1772 /* We do not tag if rewind fails.
1773 Only the file name will be recorded in the tags file. */
1775 curfdp
->lang
= get_language_from_langname (cplusplus
? "c++" : "c");
1781 if (!no_line_directive
1782 && curfdp
->lang
!= NULL
&& curfdp
->lang
->metasource
)
1783 /* It may be that this is a bingo.y file, and we already parsed a bingo.c
1784 file, or anyway we parsed a file that is automatically generated from
1785 this one. If this is the case, the bingo.c file contained #line
1786 directives that generated tags pointing to this file. Let's delete
1787 them all before parsing this file, which is the real source. */
1789 fdesc
**fdpp
= &fdhead
;
1790 while (*fdpp
!= NULL
)
1792 && streq ((*fdpp
)->taggedfname
, curfdp
->taggedfname
))
1793 /* We found one of those! We must delete both the file description
1794 and all tags referring to it. */
1796 fdesc
*badfdp
= *fdpp
;
1798 /* Delete the tags referring to badfdp->taggedfname
1799 that were obtained from badfdp->infname. */
1800 invalidate_nodes (badfdp
, &nodehead
);
1802 *fdpp
= badfdp
->next
; /* remove the bad description from the list */
1803 free_fdesc (badfdp
);
1806 fdpp
= &(*fdpp
)->next
; /* advance the list pointer */
1809 assert (parser
!= NULL
);
1811 /* Generic initializations before reading from file. */
1812 linebuffer_setlen (&filebuf
, 0); /* reset the file buffer */
1814 /* Generic initializations before parsing file with readline. */
1815 lineno
= 0; /* reset global line number */
1816 charno
= 0; /* reset global char number */
1817 linecharno
= 0; /* reset global char number of line start */
1821 regex_tag_multiline ();
1826 * Check whether an implicitly named tag should be created,
1827 * then call `pfnote'.
1828 * NAME is a string that is internally copied by this function.
1830 * TAGS format specification
1831 * Idea by Sam Kendall <kendall@mv.mv.com> (1997)
1832 * The following is explained in some more detail in etc/ETAGS.EBNF.
1834 * make_tag creates tags with "implicit tag names" (unnamed tags)
1835 * if the following are all true, assuming NONAM=" \f\t\n\r()=,;":
1836 * 1. NAME does not contain any of the characters in NONAM;
1837 * 2. LINESTART contains name as either a rightmost, or rightmost but
1838 * one character, substring;
1839 * 3. the character, if any, immediately before NAME in LINESTART must
1840 * be a character in NONAM;
1841 * 4. the character, if any, immediately after NAME in LINESTART must
1842 * also be a character in NONAM.
1844 * The implementation uses the notinname() macro, which recognizes the
1845 * characters stored in the string `nonam'.
1846 * etags.el needs to use the same characters that are in NONAM.
1849 make_tag (const char *name
, /* tag name, or NULL if unnamed */
1850 int namelen
, /* tag length */
1851 int is_func
, /* tag is a function */
1852 char *linestart
, /* start of the line where tag is */
1853 int linelen
, /* length of the line where tag is */
1854 int lno
, /* line number */
1855 long int cno
) /* character number */
1857 bool named
= (name
!= NULL
&& namelen
> 0);
1860 if (!CTAGS
&& named
) /* maybe set named to false */
1861 /* Let's try to make an implicit tag name, that is, create an unnamed tag
1862 such that etags.el can guess a name from it. */
1865 register const char *cp
= name
;
1867 for (i
= 0; i
< namelen
; i
++)
1868 if (notinname (*cp
++))
1870 if (i
== namelen
) /* rule #1 */
1872 cp
= linestart
+ linelen
- namelen
;
1873 if (notinname (linestart
[linelen
-1]))
1874 cp
-= 1; /* rule #4 */
1875 if (cp
>= linestart
/* rule #2 */
1877 || notinname (cp
[-1])) /* rule #3 */
1878 && strneq (name
, cp
, namelen
)) /* rule #2 */
1879 named
= FALSE
; /* use implicit tag name */
1884 nname
= savenstr (name
, namelen
);
1886 pfnote (nname
, is_func
, linestart
, linelen
, lno
, cno
);
1891 pfnote (char *name
, int is_func
, char *linestart
, int linelen
, int lno
, long int cno
)
1892 /* tag name, or NULL if unnamed */
1893 /* tag is a function */
1894 /* start of the line where tag is */
1895 /* length of the line where tag is */
1897 /* character number */
1901 assert (name
== NULL
|| name
[0] != '\0');
1902 if (CTAGS
&& name
== NULL
)
1905 np
= xnew (1, node
);
1907 /* If ctags mode, change name "main" to M<thisfilename>. */
1908 if (CTAGS
&& !cxref_style
&& streq (name
, "main"))
1910 register char *fp
= etags_strrchr (curfdp
->taggedfname
, '/');
1911 np
->name
= concat ("M", fp
== NULL
? curfdp
->taggedfname
: fp
+ 1, "");
1912 fp
= etags_strrchr (np
->name
, '.');
1913 if (fp
!= NULL
&& fp
[1] != '\0' && fp
[2] == '\0')
1919 np
->been_warned
= FALSE
;
1921 np
->is_func
= is_func
;
1923 if (np
->fdp
->usecharno
)
1924 /* Our char numbers are 0-base, because of C language tradition?
1925 ctags compatibility? old versions compatibility? I don't know.
1926 Anyway, since emacs's are 1-base we expect etags.el to take care
1927 of the difference. If we wanted to have 1-based numbers, we would
1928 uncomment the +1 below. */
1929 np
->cno
= cno
/* + 1 */ ;
1931 np
->cno
= invalidcharno
;
1932 np
->left
= np
->right
= NULL
;
1933 if (CTAGS
&& !cxref_style
)
1935 if (strlen (linestart
) < 50)
1936 np
->regex
= concat (linestart
, "$", "");
1938 np
->regex
= savenstr (linestart
, 50);
1941 np
->regex
= savenstr (linestart
, linelen
);
1943 add_node (np
, &nodehead
);
1948 * recurse on left children, iterate on right children.
1951 free_tree (register node
*np
)
1955 register node
*node_right
= np
->right
;
1956 free_tree (np
->left
);
1966 * delete a file description
1969 free_fdesc (register fdesc
*fdp
)
1971 free (fdp
->infname
);
1972 free (fdp
->infabsname
);
1973 free (fdp
->infabsdir
);
1974 free (fdp
->taggedfname
);
1981 * Adds a node to the tree of nodes. In etags mode, sort by file
1982 * name. In ctags mode, sort by tag name. Make no attempt at
1985 * add_node is the only function allowed to add nodes, so it can
1989 add_node (node
*np
, node
**cur_node_p
)
1992 register node
*cur_node
= *cur_node_p
;
1994 if (cur_node
== NULL
)
2004 /* For each file name, tags are in a linked sublist on the right
2005 pointer. The first tags of different files are a linked list
2006 on the left pointer. last_node points to the end of the last
2008 if (last_node
!= NULL
&& last_node
->fdp
== np
->fdp
)
2010 /* Let's use the same sublist as the last added node. */
2011 assert (last_node
->right
== NULL
);
2012 last_node
->right
= np
;
2015 else if (cur_node
->fdp
== np
->fdp
)
2017 /* Scanning the list we found the head of a sublist which is
2018 good for us. Let's scan this sublist. */
2019 add_node (np
, &cur_node
->right
);
2022 /* The head of this sublist is not good for us. Let's try the
2024 add_node (np
, &cur_node
->left
);
2025 } /* if ETAGS mode */
2030 dif
= strcmp (np
->name
, cur_node
->name
);
2033 * If this tag name matches an existing one, then
2034 * do not add the node, but maybe print a warning.
2036 if (no_duplicates
&& !dif
)
2038 if (np
->fdp
== cur_node
->fdp
)
2042 fprintf (stderr
, "Duplicate entry in file %s, line %d: %s\n",
2043 np
->fdp
->infname
, lineno
, np
->name
);
2044 fprintf (stderr
, "Second entry ignored\n");
2047 else if (!cur_node
->been_warned
&& !no_warnings
)
2051 "Duplicate entry in files %s and %s: %s (Warning only)\n",
2052 np
->fdp
->infname
, cur_node
->fdp
->infname
, np
->name
);
2053 cur_node
->been_warned
= TRUE
;
2058 /* Actually add the node */
2059 add_node (np
, dif
< 0 ? &cur_node
->left
: &cur_node
->right
);
2060 } /* if CTAGS mode */
2064 * invalidate_nodes ()
2065 * Scan the node tree and invalidate all nodes pointing to the
2066 * given file description (CTAGS case) or free them (ETAGS case).
2069 invalidate_nodes (fdesc
*badfdp
, node
**npp
)
2078 if (np
->left
!= NULL
)
2079 invalidate_nodes (badfdp
, &np
->left
);
2080 if (np
->fdp
== badfdp
)
2082 if (np
->right
!= NULL
)
2083 invalidate_nodes (badfdp
, &np
->right
);
2087 assert (np
->fdp
!= NULL
);
2088 if (np
->fdp
== badfdp
)
2090 *npp
= np
->left
; /* detach the sublist from the list */
2091 np
->left
= NULL
; /* isolate it */
2092 free_tree (np
); /* free it */
2093 invalidate_nodes (badfdp
, npp
);
2096 invalidate_nodes (badfdp
, &np
->left
);
2101 static int total_size_of_entries (node
*);
2102 static int number_len (long) ATTRIBUTE_CONST
;
2104 /* Length of a non-negative number's decimal representation. */
2106 number_len (long int num
)
2109 while ((num
/= 10) > 0)
2115 * Return total number of characters that put_entries will output for
2116 * the nodes in the linked list at the right of the specified node.
2117 * This count is irrelevant with etags.el since emacs 19.34 at least,
2118 * but is still supplied for backward compatibility.
2121 total_size_of_entries (register node
*np
)
2123 register int total
= 0;
2125 for (; np
!= NULL
; np
= np
->right
)
2128 total
+= strlen (np
->regex
) + 1; /* pat\177 */
2129 if (np
->name
!= NULL
)
2130 total
+= strlen (np
->name
) + 1; /* name\001 */
2131 total
+= number_len ((long) np
->lno
) + 1; /* lno, */
2132 if (np
->cno
!= invalidcharno
) /* cno */
2133 total
+= number_len (np
->cno
);
2134 total
+= 1; /* newline */
2141 put_entries (register node
*np
)
2144 static fdesc
*fdp
= NULL
;
2149 /* Output subentries that precede this one */
2151 put_entries (np
->left
);
2153 /* Output this entry */
2162 fprintf (tagf
, "\f\n%s,%d\n",
2163 fdp
->taggedfname
, total_size_of_entries (np
));
2164 fdp
->written
= TRUE
;
2166 fputs (np
->regex
, tagf
);
2167 fputc ('\177', tagf
);
2168 if (np
->name
!= NULL
)
2170 fputs (np
->name
, tagf
);
2171 fputc ('\001', tagf
);
2173 fprintf (tagf
, "%d,", np
->lno
);
2174 if (np
->cno
!= invalidcharno
)
2175 fprintf (tagf
, "%ld", np
->cno
);
2181 if (np
->name
== NULL
)
2182 error ("internal error: NULL name in ctags mode.");
2187 fprintf (stdout
, "%s %s %d\n",
2188 np
->name
, np
->fdp
->taggedfname
, (np
->lno
+ 63) / 64);
2190 fprintf (stdout
, "%-16s %3d %-16s %s\n",
2191 np
->name
, np
->lno
, np
->fdp
->taggedfname
, np
->regex
);
2195 fprintf (tagf
, "%s\t%s\t", np
->name
, np
->fdp
->taggedfname
);
2198 { /* function or #define macro with args */
2199 putc (searchar
, tagf
);
2202 for (sp
= np
->regex
; *sp
; sp
++)
2204 if (*sp
== '\\' || *sp
== searchar
)
2208 putc (searchar
, tagf
);
2211 { /* anything else; text pattern inadequate */
2212 fprintf (tagf
, "%d", np
->lno
);
2217 } /* if this node contains a valid tag */
2219 /* Output subentries that follow this one */
2220 put_entries (np
->right
);
2222 put_entries (np
->left
);
2227 #define C_EXT 0x00fff /* C extensions */
2228 #define C_PLAIN 0x00000 /* C */
2229 #define C_PLPL 0x00001 /* C++ */
2230 #define C_STAR 0x00003 /* C* */
2231 #define C_JAVA 0x00005 /* JAVA */
2232 #define C_AUTO 0x01000 /* C, but switch to C++ if `class' is met */
2233 #define YACC 0x10000 /* yacc file */
2236 * The C symbol tables.
2241 st_C_objprot
, st_C_objimpl
, st_C_objend
,
2243 st_C_ignore
, st_C_attribute
,
2246 st_C_class
, st_C_template
,
2247 st_C_struct
, st_C_extern
, st_C_enum
, st_C_define
, st_C_typedef
2250 static unsigned int hash (const char *, unsigned int);
2251 static struct C_stab_entry
* in_word_set (const char *, unsigned int);
2252 static enum sym_type
C_symtype (char *, int, int);
2254 /* Feed stuff between (but not including) %[ and %] lines to:
2260 struct C_stab_entry { char *name; int c_ext; enum sym_type type; }
2264 while, 0, st_C_ignore
2265 switch, 0, st_C_ignore
2266 return, 0, st_C_ignore
2267 __attribute__, 0, st_C_attribute
2268 GTY, 0, st_C_attribute
2269 @interface, 0, st_C_objprot
2270 @protocol, 0, st_C_objprot
2271 @implementation,0, st_C_objimpl
2272 @end, 0, st_C_objend
2273 import, (C_JAVA & ~C_PLPL), st_C_ignore
2274 package, (C_JAVA & ~C_PLPL), st_C_ignore
2275 friend, C_PLPL, st_C_ignore
2276 extends, (C_JAVA & ~C_PLPL), st_C_javastruct
2277 implements, (C_JAVA & ~C_PLPL), st_C_javastruct
2278 interface, (C_JAVA & ~C_PLPL), st_C_struct
2279 class, 0, st_C_class
2280 namespace, C_PLPL, st_C_struct
2281 domain, C_STAR, st_C_struct
2282 union, 0, st_C_struct
2283 struct, 0, st_C_struct
2284 extern, 0, st_C_extern
2286 typedef, 0, st_C_typedef
2287 define, 0, st_C_define
2288 undef, 0, st_C_define
2289 operator, C_PLPL, st_C_operator
2290 template, 0, st_C_template
2291 # DEFUN used in emacs, the next three used in glibc (SYSCALL only for mach).
2292 DEFUN, 0, st_C_gnumacro
2293 SYSCALL, 0, st_C_gnumacro
2294 ENTRY, 0, st_C_gnumacro
2295 PSEUDO, 0, st_C_gnumacro
2296 # These are defined inside C functions, so currently they are not met.
2297 # EXFUN used in glibc, DEFVAR_* in emacs.
2298 #EXFUN, 0, st_C_gnumacro
2299 #DEFVAR_, 0, st_C_gnumacro
2301 and replace lines between %< and %> with its output, then:
2302 - remove the #if characterset check
2303 - make in_word_set static and not inline. */
2305 /* C code produced by gperf version 3.0.1 */
2306 /* Command-line: gperf -m 5 */
2307 /* Computed positions: -k'2-3' */
2309 struct C_stab_entry
{ const char *name
; int c_ext
; enum sym_type type
; };
2310 /* maximum key range = 33, duplicates = 0 */
2312 static inline unsigned int
2313 hash (register const char *str
, register unsigned int len
)
2315 static unsigned char asso_values
[] =
2317 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2318 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2319 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2320 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2321 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2322 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2323 35, 35, 35, 35, 35, 35, 35, 35, 35, 3,
2324 26, 35, 35, 35, 35, 35, 35, 35, 27, 35,
2325 35, 35, 35, 24, 0, 35, 35, 35, 35, 0,
2326 35, 35, 35, 35, 35, 1, 35, 16, 35, 6,
2327 23, 0, 0, 35, 22, 0, 35, 35, 5, 0,
2328 0, 15, 1, 35, 6, 35, 8, 19, 35, 16,
2329 4, 5, 35, 35, 35, 35, 35, 35, 35, 35,
2330 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2331 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2332 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2333 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2334 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2335 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2336 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2337 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2338 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2339 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2340 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2341 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2342 35, 35, 35, 35, 35, 35
2344 register int hval
= len
;
2349 hval
+= asso_values
[(unsigned char)str
[2]];
2352 hval
+= asso_values
[(unsigned char)str
[1]];
2358 static struct C_stab_entry
*
2359 in_word_set (register const char *str
, register unsigned int len
)
2363 TOTAL_KEYWORDS
= 33,
2364 MIN_WORD_LENGTH
= 2,
2365 MAX_WORD_LENGTH
= 15,
2370 static struct C_stab_entry wordlist
[] =
2373 {"if", 0, st_C_ignore
},
2374 {"GTY", 0, st_C_attribute
},
2375 {"@end", 0, st_C_objend
},
2376 {"union", 0, st_C_struct
},
2377 {"define", 0, st_C_define
},
2378 {"import", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2379 {"template", 0, st_C_template
},
2380 {"operator", C_PLPL
, st_C_operator
},
2381 {"@interface", 0, st_C_objprot
},
2382 {"implements", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2383 {"friend", C_PLPL
, st_C_ignore
},
2384 {"typedef", 0, st_C_typedef
},
2385 {"return", 0, st_C_ignore
},
2386 {"@implementation",0, st_C_objimpl
},
2387 {"@protocol", 0, st_C_objprot
},
2388 {"interface", (C_JAVA
& ~C_PLPL
), st_C_struct
},
2389 {"extern", 0, st_C_extern
},
2390 {"extends", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2391 {"struct", 0, st_C_struct
},
2392 {"domain", C_STAR
, st_C_struct
},
2393 {"switch", 0, st_C_ignore
},
2394 {"enum", 0, st_C_enum
},
2395 {"for", 0, st_C_ignore
},
2396 {"namespace", C_PLPL
, st_C_struct
},
2397 {"class", 0, st_C_class
},
2398 {"while", 0, st_C_ignore
},
2399 {"undef", 0, st_C_define
},
2400 {"package", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2401 {"__attribute__", 0, st_C_attribute
},
2402 {"SYSCALL", 0, st_C_gnumacro
},
2403 {"ENTRY", 0, st_C_gnumacro
},
2404 {"PSEUDO", 0, st_C_gnumacro
},
2405 {"DEFUN", 0, st_C_gnumacro
}
2408 if (len
<= MAX_WORD_LENGTH
&& len
>= MIN_WORD_LENGTH
)
2410 register int key
= hash (str
, len
);
2412 if (key
<= MAX_HASH_VALUE
&& key
>= 0)
2414 register const char *s
= wordlist
[key
].name
;
2416 if (*str
== *s
&& !strncmp (str
+ 1, s
+ 1, len
- 1) && s
[len
] == '\0')
2417 return &wordlist
[key
];
2424 static enum sym_type
2425 C_symtype (char *str
, int len
, int c_ext
)
2427 register struct C_stab_entry
*se
= in_word_set (str
, len
);
2429 if (se
== NULL
|| (se
->c_ext
&& !(c_ext
& se
->c_ext
)))
2436 * Ignoring __attribute__ ((list))
2438 static bool inattribute
; /* looking at an __attribute__ construct */
2441 * C functions and variables are recognized using a simple
2442 * finite automaton. fvdef is its state variable.
2446 fvnone
, /* nothing seen */
2447 fdefunkey
, /* Emacs DEFUN keyword seen */
2448 fdefunname
, /* Emacs DEFUN name seen */
2449 foperator
, /* func: operator keyword seen (cplpl) */
2450 fvnameseen
, /* function or variable name seen */
2451 fstartlist
, /* func: just after open parenthesis */
2452 finlist
, /* func: in parameter list */
2453 flistseen
, /* func: after parameter list */
2454 fignore
, /* func: before open brace */
2455 vignore
/* var-like: ignore until ';' */
2458 static bool fvextern
; /* func or var: extern keyword seen; */
2461 * typedefs are recognized using a simple finite automaton.
2462 * typdef is its state variable.
2466 tnone
, /* nothing seen */
2467 tkeyseen
, /* typedef keyword seen */
2468 ttypeseen
, /* defined type seen */
2469 tinbody
, /* inside typedef body */
2470 tend
, /* just before typedef tag */
2471 tignore
/* junk after typedef tag */
2475 * struct-like structures (enum, struct and union) are recognized
2476 * using another simple finite automaton. `structdef' is its state
2481 snone
, /* nothing seen yet,
2482 or in struct body if bracelev > 0 */
2483 skeyseen
, /* struct-like keyword seen */
2484 stagseen
, /* struct-like tag seen */
2485 scolonseen
/* colon seen after struct-like tag */
2489 * When objdef is different from onone, objtag is the name of the class.
2491 static const char *objtag
= "<uninited>";
2494 * Yet another little state machine to deal with preprocessor lines.
2498 dnone
, /* nothing seen */
2499 dsharpseen
, /* '#' seen as first char on line */
2500 ddefineseen
, /* '#' and 'define' seen */
2501 dignorerest
/* ignore rest of line */
2505 * State machine for Objective C protocols and implementations.
2506 * Idea by Tom R.Hageman <tom@basil.icce.rug.nl> (1995)
2510 onone
, /* nothing seen */
2511 oprotocol
, /* @interface or @protocol seen */
2512 oimplementation
, /* @implementations seen */
2513 otagseen
, /* class name seen */
2514 oparenseen
, /* parenthesis before category seen */
2515 ocatseen
, /* category name seen */
2516 oinbody
, /* in @implementation body */
2517 omethodsign
, /* in @implementation body, after +/- */
2518 omethodtag
, /* after method name */
2519 omethodcolon
, /* after method colon */
2520 omethodparm
, /* after method parameter */
2521 oignore
/* wait for @end */
2526 * Use this structure to keep info about the token read, and how it
2527 * should be tagged. Used by the make_C_tag function to build a tag.
2531 char *line
; /* string containing the token */
2532 int offset
; /* where the token starts in LINE */
2533 int length
; /* token length */
2535 The previous members can be used to pass strings around for generic
2536 purposes. The following ones specifically refer to creating tags. In this
2537 case the token contained here is the pattern that will be used to create a
2540 bool valid
; /* do not create a tag; the token should be
2541 invalidated whenever a state machine is
2542 reset prematurely */
2543 bool named
; /* create a named tag */
2544 int lineno
; /* source line number of tag */
2545 long linepos
; /* source char number of tag */
2546 } token
; /* latest token read */
2549 * Variables and functions for dealing with nested structures.
2550 * Idea by Mykola Dzyuba <mdzyuba@yahoo.com> (2001)
2552 static void pushclass_above (int, char *, int);
2553 static void popclass_above (int);
2554 static void write_classname (linebuffer
*, const char *qualifier
);
2557 char **cname
; /* nested class names */
2558 int *bracelev
; /* nested class brace level */
2559 int nl
; /* class nesting level (elements used) */
2560 int size
; /* length of the array */
2561 } cstack
; /* stack for nested declaration tags */
2562 /* Current struct nesting depth (namespace, class, struct, union, enum). */
2563 #define nestlev (cstack.nl)
2564 /* After struct keyword or in struct body, not inside a nested function. */
2565 #define instruct (structdef == snone && nestlev > 0 \
2566 && bracelev == cstack.bracelev[nestlev-1] + 1)
2569 pushclass_above (int bracelev
, char *str
, int len
)
2573 popclass_above (bracelev
);
2575 if (nl
>= cstack
.size
)
2577 int size
= cstack
.size
*= 2;
2578 xrnew (cstack
.cname
, size
, char *);
2579 xrnew (cstack
.bracelev
, size
, int);
2581 assert (nl
== 0 || cstack
.bracelev
[nl
-1] < bracelev
);
2582 cstack
.cname
[nl
] = (str
== NULL
) ? NULL
: savenstr (str
, len
);
2583 cstack
.bracelev
[nl
] = bracelev
;
2588 popclass_above (int bracelev
)
2592 for (nl
= cstack
.nl
- 1;
2593 nl
>= 0 && cstack
.bracelev
[nl
] >= bracelev
;
2596 free (cstack
.cname
[nl
]);
2602 write_classname (linebuffer
*cn
, const char *qualifier
)
2605 int qlen
= strlen (qualifier
);
2607 if (cstack
.nl
== 0 || cstack
.cname
[0] == NULL
)
2611 cn
->buffer
[0] = '\0';
2615 len
= strlen (cstack
.cname
[0]);
2616 linebuffer_setlen (cn
, len
);
2617 strcpy (cn
->buffer
, cstack
.cname
[0]);
2619 for (i
= 1; i
< cstack
.nl
; i
++)
2621 char *s
= cstack
.cname
[i
];
2624 linebuffer_setlen (cn
, len
+ qlen
+ strlen (s
));
2625 len
+= sprintf (cn
->buffer
+ len
, "%s%s", qualifier
, s
);
2630 static bool consider_token (char *, int, int, int *, int, int, bool *);
2631 static void make_C_tag (bool);
2635 * checks to see if the current token is at the start of a
2636 * function or variable, or corresponds to a typedef, or
2637 * is a struct/union/enum tag, or #define, or an enum constant.
2639 * *IS_FUNC gets TRUE if the token is a function or #define macro
2640 * with args. C_EXTP points to which language we are looking at.
2651 consider_token (register char *str
, register int len
, register int c
, int *c_extp
, int bracelev
, int parlev
, int *is_func_or_var
)
2652 /* IN: token pointer */
2653 /* IN: token length */
2654 /* IN: first char after the token */
2655 /* IN, OUT: C extensions mask */
2656 /* IN: brace level */
2657 /* IN: parenthesis level */
2658 /* OUT: function or variable found */
2660 /* When structdef is stagseen, scolonseen, or snone with bracelev > 0,
2661 structtype is the type of the preceding struct-like keyword, and
2662 structbracelev is the brace level where it has been seen. */
2663 static enum sym_type structtype
;
2664 static int structbracelev
;
2665 static enum sym_type toktype
;
2668 toktype
= C_symtype (str
, len
, *c_extp
);
2671 * Skip __attribute__
2673 if (toktype
== st_C_attribute
)
2680 * Advance the definedef state machine.
2685 /* We're not on a preprocessor line. */
2686 if (toktype
== st_C_gnumacro
)
2693 if (toktype
== st_C_define
)
2695 definedef
= ddefineseen
;
2699 definedef
= dignorerest
;
2704 * Make a tag for any macro, unless it is a constant
2705 * and constantypedefs is FALSE.
2707 definedef
= dignorerest
;
2708 *is_func_or_var
= (c
== '(');
2709 if (!*is_func_or_var
&& !constantypedefs
)
2716 error ("internal error: definedef value.");
2725 if (toktype
== st_C_typedef
)
2745 if (structdef
== snone
&& fvdef
== fvnone
)
2764 case st_C_javastruct
:
2765 if (structdef
== stagseen
)
2766 structdef
= scolonseen
;
2770 if ((*c_extp
& C_AUTO
) /* automatic detection of C++ language */
2772 && definedef
== dnone
&& structdef
== snone
2773 && typdef
== tnone
&& fvdef
== fvnone
)
2774 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
2775 if (toktype
== st_C_template
)
2782 && (typdef
== tkeyseen
2783 || (typedefs_or_cplusplus
&& structdef
== snone
)))
2785 structdef
= skeyseen
;
2786 structtype
= toktype
;
2787 structbracelev
= bracelev
;
2788 if (fvdef
== fvnameseen
)
2794 if (structdef
== skeyseen
)
2796 structdef
= stagseen
;
2800 if (typdef
!= tnone
)
2803 /* Detect Objective C constructs. */
2813 objdef
= oimplementation
;
2817 case oimplementation
:
2818 /* Save the class tag for functions or variables defined inside. */
2819 objtag
= savenstr (str
, len
);
2823 /* Save the class tag for categories. */
2824 objtag
= savenstr (str
, len
);
2826 *is_func_or_var
= TRUE
;
2830 *is_func_or_var
= TRUE
;
2838 objdef
= omethodtag
;
2839 linebuffer_setlen (&token_name
, len
);
2840 memcpy (token_name
.buffer
, str
, len
);
2841 token_name
.buffer
[len
] = '\0';
2847 objdef
= omethodparm
;
2852 int oldlen
= token_name
.len
;
2854 objdef
= omethodtag
;
2855 linebuffer_setlen (&token_name
, oldlen
+ len
);
2856 memcpy (token_name
.buffer
+ oldlen
, str
, len
);
2857 token_name
.buffer
[oldlen
+ len
] = '\0';
2862 if (toktype
== st_C_objend
)
2864 /* Memory leakage here: the string pointed by objtag is
2865 never released, because many tests would be needed to
2866 avoid breaking on incorrect input code. The amount of
2867 memory leaked here is the sum of the lengths of the
2875 /* A function, variable or enum constant? */
2897 *is_func_or_var
= TRUE
;
2901 && structdef
== snone
2902 && structtype
== st_C_enum
&& bracelev
> structbracelev
)
2903 return TRUE
; /* enum constant */
2909 fvdef
= fdefunname
; /* GNU macro */
2910 *is_func_or_var
= TRUE
;
2918 if ((strneq (str
, "asm", 3) && endtoken (str
[3]))
2919 || (strneq (str
, "__asm__", 7) && endtoken (str
[7])))
2928 if (len
>= 10 && strneq (str
+len
-10, "::operator", 10))
2930 if (*c_extp
& C_AUTO
) /* automatic detection of C++ */
2931 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
2933 *is_func_or_var
= TRUE
;
2936 if (bracelev
> 0 && !instruct
)
2938 fvdef
= fvnameseen
; /* function or variable */
2939 *is_func_or_var
= TRUE
;
2950 * C_entries often keeps pointers to tokens or lines which are older than
2951 * the line currently read. By keeping two line buffers, and switching
2952 * them at end of line, it is possible to use those pointers.
2960 #define current_lb_is_new (newndx == curndx)
2961 #define switch_line_buffers() (curndx = 1 - curndx)
2963 #define curlb (lbs[curndx].lb)
2964 #define newlb (lbs[newndx].lb)
2965 #define curlinepos (lbs[curndx].linepos)
2966 #define newlinepos (lbs[newndx].linepos)
2968 #define plainc ((c_ext & C_EXT) == C_PLAIN)
2969 #define cplpl (c_ext & C_PLPL)
2970 #define cjava ((c_ext & C_JAVA) == C_JAVA)
2972 #define CNL_SAVE_DEFINEDEF() \
2974 curlinepos = charno; \
2975 readline (&curlb, inf); \
2976 lp = curlb.buffer; \
2983 CNL_SAVE_DEFINEDEF(); \
2984 if (savetoken.valid) \
2986 token = savetoken; \
2987 savetoken.valid = FALSE; \
2989 definedef = dnone; \
2994 make_C_tag (int isfun
)
2996 /* This function is never called when token.valid is FALSE, but
2997 we must protect against invalid input or internal errors. */
2999 make_tag (token_name
.buffer
, token_name
.len
, isfun
, token
.line
,
3000 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3002 { /* this branch is optimized away if !DEBUG */
3003 make_tag (concat ("INVALID TOKEN:-->", token_name
.buffer
, ""),
3004 token_name
.len
+ 17, isfun
, token
.line
,
3005 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3006 error ("INVALID TOKEN");
3009 token
.valid
= FALSE
;
3015 * This routine finds functions, variables, typedefs,
3016 * #define's, enum constants and struct/union/enum definitions in
3017 * C syntax and adds them to the list.
3020 C_entries (int c_ext
, FILE *inf
)
3021 /* extension of C */
3024 register char c
; /* latest char read; '\0' for end of line */
3025 register char *lp
; /* pointer one beyond the character `c' */
3026 int curndx
, newndx
; /* indices for current and new lb */
3027 register int tokoff
; /* offset in line of start of current token */
3028 register int toklen
; /* length of current token */
3029 const char *qualifier
; /* string used to qualify names */
3030 int qlen
; /* length of qualifier */
3031 int bracelev
; /* current brace level */
3032 int bracketlev
; /* current bracket level */
3033 int parlev
; /* current parenthesis level */
3034 int attrparlev
; /* __attribute__ parenthesis level */
3035 int templatelev
; /* current template level */
3036 int typdefbracelev
; /* bracelev where a typedef struct body begun */
3037 bool incomm
, inquote
, inchar
, quotednl
, midtoken
;
3038 bool yacc_rules
; /* in the rules part of a yacc file */
3039 struct tok savetoken
= {0}; /* token saved during preprocessor handling */
3042 linebuffer_init (&lbs
[0].lb
);
3043 linebuffer_init (&lbs
[1].lb
);
3044 if (cstack
.size
== 0)
3046 cstack
.size
= (DEBUG
) ? 1 : 4;
3048 cstack
.cname
= xnew (cstack
.size
, char *);
3049 cstack
.bracelev
= xnew (cstack
.size
, int);
3052 tokoff
= toklen
= typdefbracelev
= 0; /* keep compiler quiet */
3053 curndx
= newndx
= 0;
3057 fvdef
= fvnone
; fvextern
= FALSE
; typdef
= tnone
;
3058 structdef
= snone
; definedef
= dnone
; objdef
= onone
;
3060 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
3061 token
.valid
= savetoken
.valid
= FALSE
;
3062 bracelev
= bracketlev
= parlev
= attrparlev
= templatelev
= 0;
3064 { qualifier
= "."; qlen
= 1; }
3066 { qualifier
= "::"; qlen
= 2; }
3074 /* If we are at the end of the line, the next character is a
3075 '\0'; do not skip it, because it is what tells us
3076 to read the next line. */
3097 /* Newlines inside comments do not end macro definitions in
3099 CNL_SAVE_DEFINEDEF ();
3112 /* Newlines inside strings do not end macro definitions
3113 in traditional cpp, even though compilers don't
3114 usually accept them. */
3115 CNL_SAVE_DEFINEDEF ();
3125 /* Hmmm, something went wrong. */
3161 if (fvdef
!= finlist
&& fvdef
!= fignore
&& fvdef
!= vignore
)
3176 else if (/* cplpl && */ *lp
== '/')
3182 if ((c_ext
& YACC
) && *lp
== '%')
3184 /* Entering or exiting rules section in yacc file. */
3186 definedef
= dnone
; fvdef
= fvnone
; fvextern
= FALSE
;
3187 typdef
= tnone
; structdef
= snone
;
3188 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
3190 yacc_rules
= !yacc_rules
;
3196 if (definedef
== dnone
)
3199 bool cpptoken
= TRUE
;
3201 /* Look back on this line. If all blanks, or nonblanks
3202 followed by an end of comment, this is a preprocessor
3204 for (cp
= newlb
.buffer
; cp
< lp
-1; cp
++)
3207 if (*cp
== '*' && cp
[1] == '/')
3216 definedef
= dsharpseen
;
3217 } /* if (definedef == dnone) */
3228 CNL_SAVE_DEFINEDEF ();
3235 /* Consider token only if some involved conditions are satisfied. */
3236 if (typdef
!= tignore
3237 && definedef
!= dignorerest
3240 && (definedef
!= dnone
3241 || structdef
!= scolonseen
)
3248 if (c
== ':' && *lp
== ':' && begtoken (lp
[1]))
3249 /* This handles :: in the middle,
3250 but not at the beginning of an identifier.
3251 Also, space-separated :: is not recognized. */
3253 if (c_ext
& C_AUTO
) /* automatic detection of C++ */
3254 c_ext
= (c_ext
| C_PLPL
) & ~C_AUTO
;
3258 goto still_in_token
;
3262 bool funorvar
= FALSE
;
3265 || consider_token (newlb
.buffer
+ tokoff
, toklen
, c
,
3266 &c_ext
, bracelev
, parlev
,
3269 if (fvdef
== foperator
)
3272 lp
= skip_spaces (lp
-1);
3276 && !iswhite (*lp
) && *lp
!= '(')
3279 toklen
+= lp
- oldlp
;
3281 token
.named
= FALSE
;
3283 && nestlev
> 0 && definedef
== dnone
)
3284 /* in struct body */
3287 write_classname (&token_name
, qualifier
);
3288 len
= token_name
.len
;
3289 linebuffer_setlen (&token_name
, len
+qlen
+toklen
);
3290 sprintf (token_name
.buffer
+ len
, "%s%.*s",
3291 qualifier
, toklen
, newlb
.buffer
+ tokoff
);
3294 else if (objdef
== ocatseen
)
3295 /* Objective C category */
3297 int len
= strlen (objtag
) + 2 + toklen
;
3298 linebuffer_setlen (&token_name
, len
);
3299 sprintf (token_name
.buffer
, "%s(%.*s)",
3300 objtag
, toklen
, newlb
.buffer
+ tokoff
);
3303 else if (objdef
== omethodtag
3304 || objdef
== omethodparm
)
3305 /* Objective C method */
3309 else if (fvdef
== fdefunname
)
3310 /* GNU DEFUN and similar macros */
3312 bool defun
= (newlb
.buffer
[tokoff
] == 'F');
3316 /* Rewrite the tag so that emacs lisp DEFUNs
3317 can be found by their elisp name */
3323 linebuffer_setlen (&token_name
, len
);
3324 memcpy (token_name
.buffer
,
3325 newlb
.buffer
+ off
, len
);
3326 token_name
.buffer
[len
] = '\0';
3329 if (token_name
.buffer
[len
] == '_')
3330 token_name
.buffer
[len
] = '-';
3331 token
.named
= defun
;
3335 linebuffer_setlen (&token_name
, toklen
);
3336 memcpy (token_name
.buffer
,
3337 newlb
.buffer
+ tokoff
, toklen
);
3338 token_name
.buffer
[toklen
] = '\0';
3339 /* Name macros and members. */
3340 token
.named
= (structdef
== stagseen
3341 || typdef
== ttypeseen
3344 && definedef
== dignorerest
)
3346 && definedef
== dnone
3347 && structdef
== snone
3350 token
.lineno
= lineno
;
3351 token
.offset
= tokoff
;
3352 token
.length
= toklen
;
3353 token
.line
= newlb
.buffer
;
3354 token
.linepos
= newlinepos
;
3357 if (definedef
== dnone
3358 && (fvdef
== fvnameseen
3359 || fvdef
== foperator
3360 || structdef
== stagseen
3362 || typdef
== ttypeseen
3363 || objdef
!= onone
))
3365 if (current_lb_is_new
)
3366 switch_line_buffers ();
3368 else if (definedef
!= dnone
3369 || fvdef
== fdefunname
3371 make_C_tag (funorvar
);
3373 else /* not yacc and consider_token failed */
3375 if (inattribute
&& fvdef
== fignore
)
3377 /* We have just met __attribute__ after a
3378 function parameter list: do not tag the
3385 } /* if (endtoken (c)) */
3386 else if (intoken (c
))
3392 } /* if (midtoken) */
3393 else if (begtoken (c
))
3401 /* This prevents tagging fb in
3402 void (__attribute__((noreturn)) *fb) (void);
3403 Fixing this is not easy and not very important. */
3407 if (plainc
|| declarations
)
3409 make_C_tag (TRUE
); /* a function */
3414 if (structdef
== stagseen
&& !cjava
)
3416 popclass_above (bracelev
);
3424 if (!yacc_rules
|| lp
== newlb
.buffer
+ 1)
3426 tokoff
= lp
- 1 - newlb
.buffer
;
3431 } /* if (begtoken) */
3432 } /* if must look at token */
3435 /* Detect end of line, colon, comma, semicolon and various braces
3436 after having handled a token.*/
3442 if (yacc_rules
&& token
.offset
== 0 && token
.valid
)
3444 make_C_tag (FALSE
); /* a yacc function */
3447 if (definedef
!= dnone
)
3453 make_C_tag (TRUE
); /* an Objective C class */
3457 objdef
= omethodcolon
;
3458 linebuffer_setlen (&token_name
, token_name
.len
+ 1);
3459 strcat (token_name
.buffer
, ":");
3462 if (structdef
== stagseen
)
3464 structdef
= scolonseen
;
3467 /* Should be useless, but may be work as a safety net. */
3468 if (cplpl
&& fvdef
== flistseen
)
3470 make_C_tag (TRUE
); /* a function */
3476 if (definedef
!= dnone
|| inattribute
)
3482 make_C_tag (FALSE
); /* a typedef */
3492 if (typdef
== tignore
|| cplpl
)
3496 if ((globals
&& bracelev
== 0 && (!fvextern
|| declarations
))
3497 || (members
&& instruct
))
3498 make_C_tag (FALSE
); /* a variable */
3501 token
.valid
= FALSE
;
3505 && (cplpl
|| !instruct
)
3506 && (typdef
== tnone
|| (typdef
!= tignore
&& instruct
)))
3508 && plainc
&& instruct
))
3509 make_C_tag (TRUE
); /* a function */
3515 && cplpl
&& structdef
== stagseen
)
3516 make_C_tag (FALSE
); /* forward declaration */
3518 token
.valid
= FALSE
;
3519 } /* switch (fvdef) */
3525 if (structdef
== stagseen
)
3529 if (definedef
!= dnone
|| inattribute
)
3535 make_C_tag (TRUE
); /* an Objective C method */
3556 && (!fvextern
|| declarations
))
3557 || (members
&& instruct
)))
3558 make_C_tag (FALSE
); /* a variable */
3561 if ((declarations
&& typdef
== tnone
&& !instruct
)
3562 || (members
&& typdef
!= tignore
&& instruct
))
3564 make_C_tag (TRUE
); /* a function */
3567 else if (!declarations
)
3569 token
.valid
= FALSE
;
3574 if (structdef
== stagseen
)
3578 if (definedef
!= dnone
|| inattribute
)
3580 if (structdef
== stagseen
)
3587 make_C_tag (FALSE
); /* a typedef */
3599 if ((members
&& bracelev
== 1)
3600 || (globals
&& bracelev
== 0
3601 && (!fvextern
|| declarations
)))
3602 make_C_tag (FALSE
); /* a variable */
3616 if (definedef
!= dnone
)
3618 if (objdef
== otagseen
&& parlev
== 0)
3619 objdef
= oparenseen
;
3623 if (typdef
== ttypeseen
3627 /* This handles constructs like:
3628 typedef void OperatorFun (int fun); */
3647 if (--attrparlev
== 0)
3648 inattribute
= FALSE
;
3651 if (definedef
!= dnone
)
3653 if (objdef
== ocatseen
&& parlev
== 1)
3655 make_C_tag (TRUE
); /* an Objective C category */
3669 || typdef
== ttypeseen
))
3672 make_C_tag (FALSE
); /* a typedef */
3675 else if (parlev
< 0) /* can happen due to ill-conceived #if's. */
3679 if (definedef
!= dnone
)
3681 if (typdef
== ttypeseen
)
3683 /* Whenever typdef is set to tinbody (currently only
3684 here), typdefbracelev should be set to bracelev. */
3686 typdefbracelev
= bracelev
;
3691 make_C_tag (TRUE
); /* a function */
3700 make_C_tag (TRUE
); /* an Objective C class */
3705 make_C_tag (TRUE
); /* an Objective C method */
3709 /* Neutralize `extern "C" {' grot. */
3710 if (bracelev
== 0 && structdef
== snone
&& nestlev
== 0
3718 case skeyseen
: /* unnamed struct */
3719 pushclass_above (bracelev
, NULL
, 0);
3722 case stagseen
: /* named struct or enum */
3723 case scolonseen
: /* a class */
3724 pushclass_above (bracelev
,token
.line
+token
.offset
, token
.length
);
3726 make_C_tag (FALSE
); /* a struct or enum */
3732 if (definedef
!= dnone
)
3734 if (fvdef
== fstartlist
)
3736 fvdef
= fvnone
; /* avoid tagging `foo' in `foo (*bar()) ()' */
3737 token
.valid
= FALSE
;
3741 if (definedef
!= dnone
)
3744 if (!ignoreindent
&& lp
== newlb
.buffer
+ 1)
3747 token
.valid
= FALSE
; /* unexpected value, token unreliable */
3748 bracelev
= 0; /* reset brace level if first column */
3749 parlev
= 0; /* also reset paren level, just in case... */
3751 else if (bracelev
< 0)
3753 token
.valid
= FALSE
; /* something gone amiss, token unreliable */
3756 if (bracelev
== 0 && fvdef
== vignore
)
3757 fvdef
= fvnone
; /* end of function */
3758 popclass_above (bracelev
);
3760 /* Only if typdef == tinbody is typdefbracelev significant. */
3761 if (typdef
== tinbody
&& bracelev
<= typdefbracelev
)
3763 assert (bracelev
== typdefbracelev
);
3768 if (definedef
!= dnone
)
3778 if ((members
&& bracelev
== 1)
3779 || (globals
&& bracelev
== 0 && (!fvextern
|| declarations
)))
3780 make_C_tag (FALSE
); /* a variable */
3788 && (structdef
== stagseen
|| fvdef
== fvnameseen
))
3795 if (templatelev
> 0)
3803 if (objdef
== oinbody
&& bracelev
== 0)
3805 objdef
= omethodsign
;
3810 case '#': case '~': case '&': case '%': case '/':
3811 case '|': case '^': case '!': case '.': case '?':
3812 if (definedef
!= dnone
)
3814 /* These surely cannot follow a function tag in C. */
3827 if (objdef
== otagseen
)
3829 make_C_tag (TRUE
); /* an Objective C class */
3832 /* If a macro spans multiple lines don't reset its state. */
3834 CNL_SAVE_DEFINEDEF ();
3840 } /* while not eof */
3842 free (lbs
[0].lb
.buffer
);
3843 free (lbs
[1].lb
.buffer
);
3847 * Process either a C++ file or a C file depending on the setting
3851 default_C_entries (FILE *inf
)
3853 C_entries (cplusplus
? C_PLPL
: C_AUTO
, inf
);
3856 /* Always do plain C. */
3858 plain_C_entries (FILE *inf
)
3863 /* Always do C++. */
3865 Cplusplus_entries (FILE *inf
)
3867 C_entries (C_PLPL
, inf
);
3870 /* Always do Java. */
3872 Cjava_entries (FILE *inf
)
3874 C_entries (C_JAVA
, inf
);
3879 Cstar_entries (FILE *inf
)
3881 C_entries (C_STAR
, inf
);
3884 /* Always do Yacc. */
3886 Yacc_entries (FILE *inf
)
3888 C_entries (YACC
, inf
);
3892 /* Useful macros. */
3893 #define LOOP_ON_INPUT_LINES(file_pointer, line_buffer, char_pointer) \
3894 for (; /* loop initialization */ \
3895 !feof (file_pointer) /* loop test */ \
3896 && /* instructions at start of loop */ \
3897 (readline (&line_buffer, file_pointer), \
3898 char_pointer = line_buffer.buffer, \
3902 #define LOOKING_AT(cp, kw) /* kw is the keyword, a literal string */ \
3903 ((assert ("" kw), TRUE) /* syntax error if not a literal string */ \
3904 && strneq ((cp), kw, sizeof (kw)-1) /* cp points at kw */ \
3905 && notinname ((cp)[sizeof (kw)-1]) /* end of kw */ \
3906 && ((cp) = skip_spaces ((cp)+sizeof (kw)-1))) /* skip spaces */
3908 /* Similar to LOOKING_AT but does not use notinname, does not skip */
3909 #define LOOKING_AT_NOCASE(cp, kw) /* the keyword is a literal string */ \
3910 ((assert ("" kw), TRUE) /* syntax error if not a literal string */ \
3911 && strncaseeq ((cp), kw, sizeof (kw)-1) /* cp points at kw */ \
3912 && ((cp) += sizeof (kw)-1)) /* skip spaces */
3915 * Read a file, but do no processing. This is used to do regexp
3916 * matching on files that have no language defined.
3919 just_read_file (FILE *inf
)
3922 readline (&lb
, inf
);
3926 /* Fortran parsing */
3928 static void F_takeprec (void);
3929 static void F_getit (FILE *);
3934 dbp
= skip_spaces (dbp
);
3938 dbp
= skip_spaces (dbp
);
3939 if (strneq (dbp
, "(*)", 3))
3944 if (!ISDIGIT (*dbp
))
3946 --dbp
; /* force failure */
3951 while (ISDIGIT (*dbp
));
3959 dbp
= skip_spaces (dbp
);
3962 readline (&lb
, inf
);
3967 dbp
= skip_spaces (dbp
);
3969 if (!ISALPHA (*dbp
) && *dbp
!= '_' && *dbp
!= '$')
3971 for (cp
= dbp
+ 1; *cp
!= '\0' && intoken (*cp
); cp
++)
3973 make_tag (dbp
, cp
-dbp
, TRUE
,
3974 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
3979 Fortran_functions (FILE *inf
)
3981 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
3984 dbp
++; /* Ratfor escape to fortran */
3985 dbp
= skip_spaces (dbp
);
3989 if (LOOKING_AT_NOCASE (dbp
, "recursive"))
3990 dbp
= skip_spaces (dbp
);
3992 if (LOOKING_AT_NOCASE (dbp
, "pure"))
3993 dbp
= skip_spaces (dbp
);
3995 if (LOOKING_AT_NOCASE (dbp
, "elemental"))
3996 dbp
= skip_spaces (dbp
);
3998 switch (lowcase (*dbp
))
4001 if (nocase_tail ("integer"))
4005 if (nocase_tail ("real"))
4009 if (nocase_tail ("logical"))
4013 if (nocase_tail ("complex") || nocase_tail ("character"))
4017 if (nocase_tail ("double"))
4019 dbp
= skip_spaces (dbp
);
4022 if (nocase_tail ("precision"))
4028 dbp
= skip_spaces (dbp
);
4031 switch (lowcase (*dbp
))
4034 if (nocase_tail ("function"))
4038 if (nocase_tail ("subroutine"))
4042 if (nocase_tail ("entry"))
4046 if (nocase_tail ("blockdata") || nocase_tail ("block data"))
4048 dbp
= skip_spaces (dbp
);
4049 if (*dbp
== '\0') /* assume un-named */
4050 make_tag ("blockdata", 9, TRUE
,
4051 lb
.buffer
, dbp
- lb
.buffer
, lineno
, linecharno
);
4053 F_getit (inf
); /* look for name */
4064 * Philippe Waroquiers (1998)
4067 /* Once we are positioned after an "interesting" keyword, let's get
4068 the real tag value necessary. */
4070 Ada_getit (FILE *inf
, const char *name_qualifier
)
4078 dbp
= skip_spaces (dbp
);
4080 || (dbp
[0] == '-' && dbp
[1] == '-'))
4082 readline (&lb
, inf
);
4085 switch (lowcase (*dbp
))
4088 if (nocase_tail ("body"))
4090 /* Skipping body of procedure body or package body or ....
4091 resetting qualifier to body instead of spec. */
4092 name_qualifier
= "/b";
4097 /* Skipping type of task type or protected type ... */
4098 if (nocase_tail ("type"))
4105 for (cp
= dbp
; *cp
!= '\0' && *cp
!= '"'; cp
++)
4110 dbp
= skip_spaces (dbp
);
4113 && (ISALPHA (*cp
) || ISDIGIT (*cp
) || *cp
== '_' || *cp
== '.'));
4121 name
= concat (dbp
, name_qualifier
, "");
4123 make_tag (name
, strlen (name
), TRUE
,
4124 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4133 Ada_funcs (FILE *inf
)
4135 bool inquote
= FALSE
;
4136 bool skip_till_semicolumn
= FALSE
;
4138 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4140 while (*dbp
!= '\0')
4142 /* Skip a string i.e. "abcd". */
4143 if (inquote
|| (*dbp
== '"'))
4145 dbp
= etags_strchr (dbp
+ !inquote
, '"');
4150 continue; /* advance char */
4155 break; /* advance line */
4159 /* Skip comments. */
4160 if (dbp
[0] == '-' && dbp
[1] == '-')
4161 break; /* advance line */
4163 /* Skip character enclosed in single quote i.e. 'a'
4164 and skip single quote starting an attribute i.e. 'Image. */
4173 if (skip_till_semicolumn
)
4176 skip_till_semicolumn
= FALSE
;
4178 continue; /* advance char */
4181 /* Search for beginning of a token. */
4182 if (!begtoken (*dbp
))
4185 continue; /* advance char */
4188 /* We are at the beginning of a token. */
4189 switch (lowcase (*dbp
))
4192 if (!packages_only
&& nocase_tail ("function"))
4193 Ada_getit (inf
, "/f");
4195 break; /* from switch */
4196 continue; /* advance char */
4198 if (!packages_only
&& nocase_tail ("procedure"))
4199 Ada_getit (inf
, "/p");
4200 else if (nocase_tail ("package"))
4201 Ada_getit (inf
, "/s");
4202 else if (nocase_tail ("protected")) /* protected type */
4203 Ada_getit (inf
, "/t");
4205 break; /* from switch */
4206 continue; /* advance char */
4209 if (typedefs
&& !packages_only
&& nocase_tail ("use"))
4211 /* when tagging types, avoid tagging use type Pack.Typename;
4212 for this, we will skip everything till a ; */
4213 skip_till_semicolumn
= TRUE
;
4214 continue; /* advance char */
4218 if (!packages_only
&& nocase_tail ("task"))
4219 Ada_getit (inf
, "/k");
4220 else if (typedefs
&& !packages_only
&& nocase_tail ("type"))
4222 Ada_getit (inf
, "/t");
4223 while (*dbp
!= '\0')
4227 break; /* from switch */
4228 continue; /* advance char */
4231 /* Look for the end of the token. */
4232 while (!endtoken (*dbp
))
4235 } /* advance char */
4236 } /* advance line */
4241 * Unix and microcontroller assembly tag handling
4242 * Labels: /^[a-zA-Z_.$][a-zA_Z0-9_.$]*[: ^I^J]/
4243 * Idea by Bob Weiner, Motorola Inc. (1994)
4246 Asm_labels (FILE *inf
)
4250 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4252 /* If first char is alphabetic or one of [_.$], test for colon
4253 following identifier. */
4254 if (ISALPHA (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4256 /* Read past label. */
4258 while (ISALNUM (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4260 if (*cp
== ':' || iswhite (*cp
))
4261 /* Found end of label, so copy it and add it to the table. */
4262 make_tag (lb
.buffer
, cp
- lb
.buffer
, TRUE
,
4263 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4271 * Perl sub names: /^sub[ \t\n]+[^ \t\n{]+/
4272 * Perl variable names: /^(my|local).../
4273 * Original code by Bart Robinson <lomew@cs.utah.edu> (1995)
4274 * Additions by Michael Ernst <mernst@alum.mit.edu> (1997)
4275 * Ideas by Kai Großjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE> (2001)
4278 Perl_functions (FILE *inf
)
4280 char *package
= savestr ("main"); /* current package name */
4283 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4285 cp
= skip_spaces (cp
);
4287 if (LOOKING_AT (cp
, "package"))
4290 get_tag (cp
, &package
);
4292 else if (LOOKING_AT (cp
, "sub"))
4297 while (!notinname (*cp
))
4300 continue; /* nothing found */
4301 if ((pos
= etags_strchr (sp
, ':')) != NULL
4302 && pos
< cp
&& pos
[1] == ':')
4303 /* The name is already qualified. */
4304 make_tag (sp
, cp
- sp
, TRUE
,
4305 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4309 char savechar
, *name
;
4313 name
= concat (package
, "::", sp
);
4315 make_tag (name
, strlen (name
), TRUE
,
4316 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4320 else if (globals
) /* only if we are tagging global vars */
4322 /* Skip a qualifier, if any. */
4323 bool qual
= LOOKING_AT (cp
, "my") || LOOKING_AT (cp
, "local");
4324 /* After "my" or "local", but before any following paren or space. */
4325 char *varstart
= cp
;
4327 if (qual
/* should this be removed? If yes, how? */
4328 && (*cp
== '$' || *cp
== '@' || *cp
== '%'))
4333 while (ISALNUM (*cp
) || *cp
== '_');
4337 /* Should be examining a variable list at this point;
4338 could insist on seeing an open parenthesis. */
4339 while (*cp
!= '\0' && *cp
!= ';' && *cp
!= '=' && *cp
!= ')')
4345 make_tag (varstart
, cp
- varstart
, FALSE
,
4346 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4355 * Look for /^[\t]*def[ \t\n]+[^ \t\n(:]+/ or /^class[ \t\n]+[^ \t\n(:]+/
4356 * Idea by Eric S. Raymond <esr@thyrsus.com> (1997)
4357 * More ideas by seb bacon <seb@jamkit.com> (2002)
4360 Python_functions (FILE *inf
)
4364 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4366 cp
= skip_spaces (cp
);
4367 if (LOOKING_AT (cp
, "def") || LOOKING_AT (cp
, "class"))
4370 while (!notinname (*cp
) && *cp
!= ':')
4372 make_tag (name
, cp
- name
, TRUE
,
4373 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4382 * - /^[ \t]*function[ \t\n]+[^ \t\n(]+/
4383 * - /^[ \t]*class[ \t\n]+[^ \t\n]+/
4384 * - /^[ \t]*define\(\"[^\"]+/
4385 * Only with --members:
4386 * - /^[ \t]*var[ \t\n]+\$[^ \t\n=;]/
4387 * Idea by Diez B. Roggisch (2001)
4390 PHP_functions (FILE *inf
)
4392 register char *cp
, *name
;
4393 bool search_identifier
= FALSE
;
4395 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4397 cp
= skip_spaces (cp
);
4399 if (search_identifier
4402 while (!notinname (*cp
))
4404 make_tag (name
, cp
- name
, TRUE
,
4405 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4406 search_identifier
= FALSE
;
4408 else if (LOOKING_AT (cp
, "function"))
4411 cp
= skip_spaces (cp
+1);
4415 while (!notinname (*cp
))
4417 make_tag (name
, cp
- name
, TRUE
,
4418 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4421 search_identifier
= TRUE
;
4423 else if (LOOKING_AT (cp
, "class"))
4428 while (*cp
!= '\0' && !iswhite (*cp
))
4430 make_tag (name
, cp
- name
, FALSE
,
4431 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4434 search_identifier
= TRUE
;
4436 else if (strneq (cp
, "define", 6)
4437 && (cp
= skip_spaces (cp
+6))
4439 && (*cp
== '"' || *cp
== '\''))
4443 while (*cp
!= quote
&& *cp
!= '\0')
4445 make_tag (name
, cp
- name
, FALSE
,
4446 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4449 && LOOKING_AT (cp
, "var")
4453 while (!notinname (*cp
))
4455 make_tag (name
, cp
- name
, FALSE
,
4456 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4463 * Cobol tag functions
4464 * We could look for anything that could be a paragraph name.
4465 * i.e. anything that starts in column 8 is one word and ends in a full stop.
4466 * Idea by Corny de Souza (1993)
4469 Cobol_paragraphs (FILE *inf
)
4471 register char *bp
, *ep
;
4473 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4479 /* If eoln, compiler option or comment ignore whole line. */
4480 if (bp
[-1] != ' ' || !ISALNUM (bp
[0]))
4483 for (ep
= bp
; ISALNUM (*ep
) || *ep
== '-'; ep
++)
4486 make_tag (bp
, ep
- bp
, TRUE
,
4487 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4494 * Ideas by Assar Westerlund <assar@sics.se> (2001)
4497 Makefile_targets (FILE *inf
)
4501 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4503 if (*bp
== '\t' || *bp
== '#')
4505 while (*bp
!= '\0' && *bp
!= '=' && *bp
!= ':')
4507 if (*bp
== ':' || (globals
&& *bp
== '='))
4509 /* We should detect if there is more than one tag, but we do not.
4510 We just skip initial and final spaces. */
4511 char * namestart
= skip_spaces (lb
.buffer
);
4512 while (--bp
> namestart
)
4513 if (!notinname (*bp
))
4515 make_tag (namestart
, bp
- namestart
+ 1, TRUE
,
4516 lb
.buffer
, bp
- lb
.buffer
+ 2, lineno
, linecharno
);
4524 * Original code by Mosur K. Mohan (1989)
4526 * Locates tags for procedures & functions. Doesn't do any type- or
4527 * var-definitions. It does look for the keyword "extern" or
4528 * "forward" immediately following the procedure statement; if found,
4529 * the tag is skipped.
4532 Pascal_functions (FILE *inf
)
4534 linebuffer tline
; /* mostly copied from C_entries */
4536 int save_lineno
, namelen
, taglen
;
4539 bool /* each of these flags is TRUE if: */
4540 incomment
, /* point is inside a comment */
4541 inquote
, /* point is inside '..' string */
4542 get_tagname
, /* point is after PROCEDURE/FUNCTION
4543 keyword, so next item = potential tag */
4544 found_tag
, /* point is after a potential tag */
4545 inparms
, /* point is within parameter-list */
4546 verify_tag
; /* point has passed the parm-list, so the
4547 next token will determine whether this
4548 is a FORWARD/EXTERN to be ignored, or
4549 whether it is a real tag */
4551 save_lcno
= save_lineno
= namelen
= taglen
= 0; /* keep compiler quiet */
4552 name
= NULL
; /* keep compiler quiet */
4555 linebuffer_init (&tline
);
4557 incomment
= inquote
= FALSE
;
4558 found_tag
= FALSE
; /* have a proc name; check if extern */
4559 get_tagname
= FALSE
; /* found "procedure" keyword */
4560 inparms
= FALSE
; /* found '(' after "proc" */
4561 verify_tag
= FALSE
; /* check if "extern" is ahead */
4564 while (!feof (inf
)) /* long main loop to get next char */
4567 if (c
== '\0') /* if end of line */
4569 readline (&lb
, inf
);
4573 if (!((found_tag
&& verify_tag
)
4575 c
= *dbp
++; /* only if don't need *dbp pointing
4576 to the beginning of the name of
4577 the procedure or function */
4581 if (c
== '}') /* within { } comments */
4583 else if (c
== '*' && *dbp
== ')') /* within (* *) comments */
4600 inquote
= TRUE
; /* found first quote */
4602 case '{': /* found open { comment */
4606 if (*dbp
== '*') /* found open (* comment */
4611 else if (found_tag
) /* found '(' after tag, i.e., parm-list */
4614 case ')': /* end of parms list */
4619 if (found_tag
&& !inparms
) /* end of proc or fn stmt */
4626 if (found_tag
&& verify_tag
&& (*dbp
!= ' '))
4628 /* Check if this is an "extern" declaration. */
4631 if (lowcase (*dbp
) == 'e')
4633 if (nocase_tail ("extern")) /* superfluous, really! */
4639 else if (lowcase (*dbp
) == 'f')
4641 if (nocase_tail ("forward")) /* check for forward reference */
4647 if (found_tag
&& verify_tag
) /* not external proc, so make tag */
4651 make_tag (name
, namelen
, TRUE
,
4652 tline
.buffer
, taglen
, save_lineno
, save_lcno
);
4656 if (get_tagname
) /* grab name of proc or fn */
4663 /* Find block name. */
4664 for (cp
= dbp
+ 1; *cp
!= '\0' && !endtoken (*cp
); cp
++)
4667 /* Save all values for later tagging. */
4668 linebuffer_setlen (&tline
, lb
.len
);
4669 strcpy (tline
.buffer
, lb
.buffer
);
4670 save_lineno
= lineno
;
4671 save_lcno
= linecharno
;
4672 name
= tline
.buffer
+ (dbp
- lb
.buffer
);
4674 taglen
= cp
- lb
.buffer
+ 1;
4676 dbp
= cp
; /* set dbp to e-o-token */
4677 get_tagname
= FALSE
;
4681 /* And proceed to check for "extern". */
4683 else if (!incomment
&& !inquote
&& !found_tag
)
4685 /* Check for proc/fn keywords. */
4686 switch (lowcase (c
))
4689 if (nocase_tail ("rocedure")) /* c = 'p', dbp has advanced */
4693 if (nocase_tail ("unction"))
4698 } /* while not eof */
4700 free (tline
.buffer
);
4705 * Lisp tag functions
4706 * look for (def or (DEF, quote or QUOTE
4709 static void L_getit (void);
4714 if (*dbp
== '\'') /* Skip prefix quote */
4716 else if (*dbp
== '(')
4719 /* Try to skip "(quote " */
4720 if (!LOOKING_AT (dbp
, "quote") && !LOOKING_AT (dbp
, "QUOTE"))
4721 /* Ok, then skip "(" before name in (defstruct (foo)) */
4722 dbp
= skip_spaces (dbp
);
4724 get_tag (dbp
, NULL
);
4728 Lisp_functions (FILE *inf
)
4730 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4735 if (strneq (dbp
+1, "def", 3) || strneq (dbp
+1, "DEF", 3))
4737 dbp
= skip_non_spaces (dbp
);
4738 dbp
= skip_spaces (dbp
);
4743 /* Check for (foo::defmumble name-defined ... */
4746 while (!notinname (*dbp
) && *dbp
!= ':');
4751 while (*dbp
== ':');
4753 if (strneq (dbp
, "def", 3) || strneq (dbp
, "DEF", 3))
4755 dbp
= skip_non_spaces (dbp
);
4756 dbp
= skip_spaces (dbp
);
4766 * Lua script language parsing
4767 * Original code by David A. Capello <dacap@users.sourceforge.net> (2004)
4769 * "function" and "local function" are tags if they start at column 1.
4772 Lua_functions (FILE *inf
)
4776 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4778 if (bp
[0] != 'f' && bp
[0] != 'l')
4781 (void)LOOKING_AT (bp
, "local"); /* skip possible "local" */
4783 if (LOOKING_AT (bp
, "function"))
4791 * Just look for lines where the first character is '/'
4792 * Also look at "defineps" for PSWrap
4794 * Richard Mlynarik <mly@adoc.xerox.com> (1997)
4795 * Masatake Yamato <masata-y@is.aist-nara.ac.jp> (1999)
4798 PS_functions (FILE *inf
)
4800 register char *bp
, *ep
;
4802 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4807 *ep
!= '\0' && *ep
!= ' ' && *ep
!= '{';
4810 make_tag (bp
, ep
- bp
, TRUE
,
4811 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4813 else if (LOOKING_AT (bp
, "defineps"))
4821 * Ignore anything after \ followed by space or in ( )
4822 * Look for words defined by :
4823 * Look for constant, code, create, defer, value, and variable
4824 * OBP extensions: Look for buffer:, field,
4825 * Ideas by Eduardo Horvath <eeh@netbsd.org> (2004)
4828 Forth_words (FILE *inf
)
4832 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4833 while ((bp
= skip_spaces (bp
))[0] != '\0')
4834 if (bp
[0] == '\\' && iswhite (bp
[1]))
4835 break; /* read next line */
4836 else if (bp
[0] == '(' && iswhite (bp
[1]))
4837 do /* skip to ) or eol */
4839 while (*bp
!= ')' && *bp
!= '\0');
4840 else if ((bp
[0] == ':' && iswhite (bp
[1]) && bp
++)
4841 || LOOKING_AT_NOCASE (bp
, "constant")
4842 || LOOKING_AT_NOCASE (bp
, "code")
4843 || LOOKING_AT_NOCASE (bp
, "create")
4844 || LOOKING_AT_NOCASE (bp
, "defer")
4845 || LOOKING_AT_NOCASE (bp
, "value")
4846 || LOOKING_AT_NOCASE (bp
, "variable")
4847 || LOOKING_AT_NOCASE (bp
, "buffer:")
4848 || LOOKING_AT_NOCASE (bp
, "field"))
4849 get_tag (skip_spaces (bp
), NULL
); /* Yay! A definition! */
4851 bp
= skip_non_spaces (bp
);
4856 * Scheme tag functions
4857 * look for (def... xyzzy
4859 * (def ... ((...(xyzzy ....
4861 * Original code by Ken Haase (1985?)
4864 Scheme_functions (FILE *inf
)
4868 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4870 if (strneq (bp
, "(def", 4) || strneq (bp
, "(DEF", 4))
4872 bp
= skip_non_spaces (bp
+4);
4873 /* Skip over open parens and white space. Don't continue past
4875 while (*bp
&& notinname (*bp
))
4879 if (LOOKING_AT (bp
, "(SET!") || LOOKING_AT (bp
, "(set!"))
4885 /* Find tags in TeX and LaTeX input files. */
4887 /* TEX_toktab is a table of TeX control sequences that define tags.
4888 * Each entry records one such control sequence.
4890 * Original code from who knows whom.
4892 * Stefan Monnier (2002)
4895 static linebuffer
*TEX_toktab
= NULL
; /* Table with tag tokens */
4897 /* Default set of control sequences to put into TEX_toktab.
4898 The value of environment var TEXTAGS is prepended to this. */
4899 static const char *TEX_defenv
= "\
4900 :chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem\
4901 :part:appendix:entry:index:def\
4902 :newcommand:renewcommand:newenvironment:renewenvironment";
4904 static void TEX_mode (FILE *);
4905 static void TEX_decode_env (const char *, const char *);
4907 static char TEX_esc
= '\\';
4908 static char TEX_opgrp
= '{';
4909 static char TEX_clgrp
= '}';
4912 * TeX/LaTeX scanning loop.
4915 TeX_commands (FILE *inf
)
4920 /* Select either \ or ! as escape character. */
4923 /* Initialize token table once from environment. */
4924 if (TEX_toktab
== NULL
)
4925 TEX_decode_env ("TEXTAGS", TEX_defenv
);
4927 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4929 /* Look at each TEX keyword in line. */
4932 /* Look for a TEX escape. */
4933 while (*cp
++ != TEX_esc
)
4934 if (cp
[-1] == '\0' || cp
[-1] == '%')
4937 for (key
= TEX_toktab
; key
->buffer
!= NULL
; key
++)
4938 if (strneq (cp
, key
->buffer
, key
->len
))
4941 int namelen
, linelen
;
4944 cp
= skip_spaces (cp
+ key
->len
);
4945 if (*cp
== TEX_opgrp
)
4951 (!iswhite (*p
) && *p
!= '#' &&
4952 *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
);
4957 if (!opgrp
|| *p
== TEX_clgrp
)
4959 while (*p
!= '\0' && *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
)
4961 linelen
= p
- lb
.buffer
+ 1;
4963 make_tag (cp
, namelen
, TRUE
,
4964 lb
.buffer
, linelen
, lineno
, linecharno
);
4965 goto tex_next_line
; /* We only tag a line once */
4973 #define TEX_LESC '\\'
4974 #define TEX_SESC '!'
4976 /* Figure out whether TeX's escapechar is '\\' or '!' and set grouping
4977 chars accordingly. */
4979 TEX_mode (FILE *inf
)
4983 while ((c
= getc (inf
)) != EOF
)
4985 /* Skip to next line if we hit the TeX comment char. */
4987 while (c
!= '\n' && c
!= EOF
)
4989 else if (c
== TEX_LESC
|| c
== TEX_SESC
)
5005 /* If the input file is compressed, inf is a pipe, and rewind may fail.
5006 No attempt is made to correct the situation. */
5010 /* Read environment and prepend it to the default string.
5011 Build token table. */
5013 TEX_decode_env (const char *evarname
, const char *defenv
)
5015 register const char *env
, *p
;
5018 /* Append default string to environment. */
5019 env
= getenv (evarname
);
5023 env
= concat (env
, defenv
, "");
5025 /* Allocate a token table */
5026 for (len
= 1, p
= env
; p
;)
5027 if ((p
= etags_strchr (p
, ':')) && *++p
!= '\0')
5029 TEX_toktab
= xnew (len
, linebuffer
);
5031 /* Unpack environment string into token table. Be careful about */
5032 /* zero-length strings (leading ':', "::" and trailing ':') */
5033 for (i
= 0; *env
!= '\0';)
5035 p
= etags_strchr (env
, ':');
5036 if (!p
) /* End of environment string. */
5037 p
= env
+ strlen (env
);
5039 { /* Only non-zero strings. */
5040 TEX_toktab
[i
].buffer
= savenstr (env
, p
- env
);
5041 TEX_toktab
[i
].len
= p
- env
;
5048 TEX_toktab
[i
].buffer
= NULL
; /* Mark end of table. */
5049 TEX_toktab
[i
].len
= 0;
5056 /* Texinfo support. Dave Love, Mar. 2000. */
5058 Texinfo_nodes (FILE *inf
)
5061 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5062 if (LOOKING_AT (cp
, "@node"))
5065 while (*cp
!= '\0' && *cp
!= ',')
5067 make_tag (start
, cp
- start
, TRUE
,
5068 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
5075 * Contents of <title>, <h1>, <h2>, <h3> are tags.
5076 * Contents of <a name=xxx> are tags with name xxx.
5078 * Francesco Potortì, 2002.
5081 HTML_labels (FILE *inf
)
5083 bool getnext
= FALSE
; /* next text outside of HTML tags is a tag */
5084 bool skiptag
= FALSE
; /* skip to the end of the current HTML tag */
5085 bool intag
= FALSE
; /* inside an html tag, looking for ID= */
5086 bool inanchor
= FALSE
; /* when INTAG, is an anchor, look for NAME= */
5090 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5092 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
5093 for (;;) /* loop on the same line */
5095 if (skiptag
) /* skip HTML tag */
5097 while (*dbp
!= '\0' && *dbp
!= '>')
5103 continue; /* look on the same line */
5105 break; /* go to next line */
5108 else if (intag
) /* look for "name=" or "id=" */
5110 while (*dbp
!= '\0' && *dbp
!= '>'
5111 && lowcase (*dbp
) != 'n' && lowcase (*dbp
) != 'i')
5114 break; /* go to next line */
5119 continue; /* look on the same line */
5121 if ((inanchor
&& LOOKING_AT_NOCASE (dbp
, "name="))
5122 || LOOKING_AT_NOCASE (dbp
, "id="))
5124 bool quoted
= (dbp
[0] == '"');
5127 for (end
= ++dbp
; *end
!= '\0' && *end
!= '"'; end
++)
5130 for (end
= dbp
; *end
!= '\0' && intoken (*end
); end
++)
5132 linebuffer_setlen (&token_name
, end
- dbp
);
5133 memcpy (token_name
.buffer
, dbp
, end
- dbp
);
5134 token_name
.buffer
[end
- dbp
] = '\0';
5137 intag
= FALSE
; /* we found what we looked for */
5138 skiptag
= TRUE
; /* skip to the end of the tag */
5139 getnext
= TRUE
; /* then grab the text */
5140 continue; /* look on the same line */
5145 else if (getnext
) /* grab next tokens and tag them */
5147 dbp
= skip_spaces (dbp
);
5149 break; /* go to next line */
5153 inanchor
= (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]));
5154 continue; /* look on the same line */
5157 for (end
= dbp
+ 1; *end
!= '\0' && *end
!= '<'; end
++)
5159 make_tag (token_name
.buffer
, token_name
.len
, TRUE
,
5160 dbp
, end
- dbp
, lineno
, linecharno
);
5161 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5163 break; /* go to next line */
5166 else /* look for an interesting HTML tag */
5168 while (*dbp
!= '\0' && *dbp
!= '<')
5171 break; /* go to next line */
5173 if (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]))
5176 continue; /* look on the same line */
5178 else if (LOOKING_AT_NOCASE (dbp
, "<title>")
5179 || LOOKING_AT_NOCASE (dbp
, "<h1>")
5180 || LOOKING_AT_NOCASE (dbp
, "<h2>")
5181 || LOOKING_AT_NOCASE (dbp
, "<h3>"))
5185 continue; /* look on the same line */
5196 * Assumes that the predicate or rule starts at column 0.
5197 * Only the first clause of a predicate or rule is added.
5198 * Original code by Sunichirou Sugou (1989)
5199 * Rewritten by Anders Lindgren (1996)
5201 static size_t prolog_pr (char *, char *);
5202 static void prolog_skip_comment (linebuffer
*, FILE *);
5203 static size_t prolog_atom (char *, size_t);
5206 Prolog_functions (FILE *inf
)
5216 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5218 if (cp
[0] == '\0') /* Empty line */
5220 else if (iswhite (cp
[0])) /* Not a predicate */
5222 else if (cp
[0] == '/' && cp
[1] == '*') /* comment. */
5223 prolog_skip_comment (&lb
, inf
);
5224 else if ((len
= prolog_pr (cp
, last
)) > 0)
5226 /* Predicate or rule. Store the function name so that we
5227 only generate a tag for the first clause. */
5229 last
= xnew (len
+ 1, char);
5230 else if (len
+ 1 > allocated
)
5231 xrnew (last
, len
+ 1, char);
5232 allocated
= len
+ 1;
5233 memcpy (last
, cp
, len
);
5242 prolog_skip_comment (linebuffer
*plb
, FILE *inf
)
5248 for (cp
= plb
->buffer
; *cp
!= '\0'; cp
++)
5249 if (cp
[0] == '*' && cp
[1] == '/')
5251 readline (plb
, inf
);
5253 while (!feof (inf
));
5257 * A predicate or rule definition is added if it matches:
5258 * <beginning of line><Prolog Atom><whitespace>(
5259 * or <beginning of line><Prolog Atom><whitespace>:-
5261 * It is added to the tags database if it doesn't match the
5262 * name of the previous clause header.
5264 * Return the size of the name of the predicate or rule, or 0 if no
5268 prolog_pr (char *s
, char *last
)
5270 /* Name of last clause. */
5275 pos
= prolog_atom (s
, 0);
5280 pos
= skip_spaces (s
+ pos
) - s
;
5283 || (s
[pos
] == '(' && (pos
+= 1))
5284 || (s
[pos
] == ':' && s
[pos
+ 1] == '-' && (pos
+= 2)))
5285 && (last
== NULL
/* save only the first clause */
5286 || len
!= strlen (last
)
5287 || !strneq (s
, last
, len
)))
5289 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5297 * Consume a Prolog atom.
5298 * Return the number of bytes consumed, or 0 if there was an error.
5300 * A prolog atom, in this context, could be one of:
5301 * - An alphanumeric sequence, starting with a lower case letter.
5302 * - A quoted arbitrary string. Single quotes can escape themselves.
5303 * Backslash quotes everything.
5306 prolog_atom (char *s
, size_t pos
)
5312 if (ISLOWER (s
[pos
]) || (s
[pos
] == '_'))
5314 /* The atom is unquoted. */
5316 while (ISALNUM (s
[pos
]) || (s
[pos
] == '_'))
5320 return pos
- origpos
;
5322 else if (s
[pos
] == '\'')
5333 pos
++; /* A double quote */
5335 else if (s
[pos
] == '\0')
5336 /* Multiline quoted atoms are ignored. */
5338 else if (s
[pos
] == '\\')
5340 if (s
[pos
+1] == '\0')
5347 return pos
- origpos
;
5355 * Support for Erlang
5357 * Generates tags for functions, defines, and records.
5358 * Assumes that Erlang functions start at column 0.
5359 * Original code by Anders Lindgren (1996)
5361 static int erlang_func (char *, char *);
5362 static void erlang_attribute (char *);
5363 static int erlang_atom (char *);
5366 Erlang_functions (FILE *inf
)
5376 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5378 if (cp
[0] == '\0') /* Empty line */
5380 else if (iswhite (cp
[0])) /* Not function nor attribute */
5382 else if (cp
[0] == '%') /* comment */
5384 else if (cp
[0] == '"') /* Sometimes, strings start in column one */
5386 else if (cp
[0] == '-') /* attribute, e.g. "-define" */
5388 erlang_attribute (cp
);
5395 else if ((len
= erlang_func (cp
, last
)) > 0)
5398 * Function. Store the function name so that we only
5399 * generates a tag for the first clause.
5402 last
= xnew (len
+ 1, char);
5403 else if (len
+ 1 > allocated
)
5404 xrnew (last
, len
+ 1, char);
5405 allocated
= len
+ 1;
5406 memcpy (last
, cp
, len
);
5415 * A function definition is added if it matches:
5416 * <beginning of line><Erlang Atom><whitespace>(
5418 * It is added to the tags database if it doesn't match the
5419 * name of the previous clause header.
5421 * Return the size of the name of the function, or 0 if no function
5425 erlang_func (char *s
, char *last
)
5427 /* Name of last clause. */
5432 pos
= erlang_atom (s
);
5437 pos
= skip_spaces (s
+ pos
) - s
;
5439 /* Save only the first clause. */
5442 || len
!= (int)strlen (last
)
5443 || !strneq (s
, last
, len
)))
5445 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5454 * Handle attributes. Currently, tags are generated for defines
5457 * They are on the form:
5458 * -define(foo, bar).
5459 * -define(Foo(M, N), M+N).
5460 * -record(graph, {vtab = notable, cyclic = true}).
5463 erlang_attribute (char *s
)
5467 if ((LOOKING_AT (cp
, "-define") || LOOKING_AT (cp
, "-record"))
5470 int len
= erlang_atom (skip_spaces (cp
));
5472 make_tag (cp
, len
, TRUE
, s
, cp
+ len
- s
, lineno
, linecharno
);
5479 * Consume an Erlang atom (or variable).
5480 * Return the number of bytes consumed, or -1 if there was an error.
5483 erlang_atom (char *s
)
5487 if (ISALPHA (s
[pos
]) || s
[pos
] == '_')
5489 /* The atom is unquoted. */
5492 while (ISALNUM (s
[pos
]) || s
[pos
] == '_');
5494 else if (s
[pos
] == '\'')
5496 for (pos
++; s
[pos
] != '\''; pos
++)
5497 if (s
[pos
] == '\0' /* multiline quoted atoms are ignored */
5498 || (s
[pos
] == '\\' && s
[++pos
] == '\0'))
5507 static char *scan_separators (char *);
5508 static void add_regex (char *, language
*);
5509 static char *substitute (char *, char *, struct re_registers
*);
5512 * Take a string like "/blah/" and turn it into "blah", verifying
5513 * that the first and last characters are the same, and handling
5514 * quoted separator characters. Actually, stops on the occurrence of
5515 * an unquoted separator. Also process \t, \n, etc. and turn into
5516 * appropriate characters. Works in place. Null terminates name string.
5517 * Returns pointer to terminating separator, or NULL for
5518 * unterminated regexps.
5521 scan_separators (char *name
)
5524 char *copyto
= name
;
5525 bool quoted
= FALSE
;
5527 for (++name
; *name
!= '\0'; ++name
)
5533 case 'a': *copyto
++ = '\007'; break; /* BEL (bell) */
5534 case 'b': *copyto
++ = '\b'; break; /* BS (back space) */
5535 case 'd': *copyto
++ = 0177; break; /* DEL (delete) */
5536 case 'e': *copyto
++ = 033; break; /* ESC (delete) */
5537 case 'f': *copyto
++ = '\f'; break; /* FF (form feed) */
5538 case 'n': *copyto
++ = '\n'; break; /* NL (new line) */
5539 case 'r': *copyto
++ = '\r'; break; /* CR (carriage return) */
5540 case 't': *copyto
++ = '\t'; break; /* TAB (horizontal tab) */
5541 case 'v': *copyto
++ = '\v'; break; /* VT (vertical tab) */
5547 /* Something else is quoted, so preserve the quote. */
5555 else if (*name
== '\\')
5557 else if (*name
== sep
)
5563 name
= NULL
; /* signal unterminated regexp */
5565 /* Terminate copied string. */
5570 /* Look at the argument of --regex or --no-regex and do the right
5571 thing. Same for each line of a regexp file. */
5573 analyse_regex (char *regex_arg
)
5575 if (regex_arg
== NULL
)
5577 free_regexps (); /* --no-regex: remove existing regexps */
5581 /* A real --regexp option or a line in a regexp file. */
5582 switch (regex_arg
[0])
5584 /* Comments in regexp file or null arg to --regex. */
5590 /* Read a regex file. This is recursive and may result in a
5591 loop, which will stop when the file descriptors are exhausted. */
5595 linebuffer regexbuf
;
5596 char *regexfile
= regex_arg
+ 1;
5598 /* regexfile is a file containing regexps, one per line. */
5599 regexfp
= fopen (regexfile
, "r");
5600 if (regexfp
== NULL
)
5605 linebuffer_init (®exbuf
);
5606 while (readline_internal (®exbuf
, regexfp
) > 0)
5607 analyse_regex (regexbuf
.buffer
);
5608 free (regexbuf
.buffer
);
5613 /* Regexp to be used for a specific language only. */
5617 char *lang_name
= regex_arg
+ 1;
5620 for (cp
= lang_name
; *cp
!= '}'; cp
++)
5623 error ("unterminated language name in regex: %s", regex_arg
);
5627 lang
= get_language_from_langname (lang_name
);
5630 add_regex (cp
, lang
);
5634 /* Regexp to be used for any language. */
5636 add_regex (regex_arg
, NULL
);
5641 /* Separate the regexp pattern, compile it,
5642 and care for optional name and modifiers. */
5644 add_regex (char *regexp_pattern
, language
*lang
)
5646 static struct re_pattern_buffer zeropattern
;
5647 char sep
, *pat
, *name
, *modifiers
;
5650 struct re_pattern_buffer
*patbuf
;
5653 force_explicit_name
= TRUE
, /* do not use implicit tag names */
5654 ignore_case
= FALSE
, /* case is significant */
5655 multi_line
= FALSE
, /* matches are done one line at a time */
5656 single_line
= FALSE
; /* dot does not match newline */
5659 if (strlen (regexp_pattern
) < 3)
5661 error ("null regexp");
5664 sep
= regexp_pattern
[0];
5665 name
= scan_separators (regexp_pattern
);
5668 error ("%s: unterminated regexp", regexp_pattern
);
5673 error ("null name for regexp \"%s\"", regexp_pattern
);
5676 modifiers
= scan_separators (name
);
5677 if (modifiers
== NULL
) /* no terminating separator --> no name */
5683 modifiers
+= 1; /* skip separator */
5685 /* Parse regex modifiers. */
5686 for (; modifiers
[0] != '\0'; modifiers
++)
5687 switch (modifiers
[0])
5690 if (modifiers
== name
)
5691 error ("forcing explicit tag name but no name, ignoring");
5692 force_explicit_name
= TRUE
;
5702 need_filebuf
= TRUE
;
5705 error ("invalid regexp modifier `%c', ignoring", modifiers
[0]);
5709 patbuf
= xnew (1, struct re_pattern_buffer
);
5710 *patbuf
= zeropattern
;
5713 static char lc_trans
[CHARS
];
5715 for (i
= 0; i
< CHARS
; i
++)
5716 lc_trans
[i
] = lowcase (i
);
5717 patbuf
->translate
= lc_trans
; /* translation table to fold case */
5721 pat
= concat ("^", regexp_pattern
, ""); /* anchor to beginning of line */
5723 pat
= regexp_pattern
;
5726 re_set_syntax (RE_SYNTAX_EMACS
| RE_DOT_NEWLINE
);
5728 re_set_syntax (RE_SYNTAX_EMACS
);
5730 err
= re_compile_pattern (pat
, strlen (pat
), patbuf
);
5735 error ("%s while compiling pattern", err
);
5740 p_head
= xnew (1, regexp
);
5741 p_head
->pattern
= savestr (regexp_pattern
);
5742 p_head
->p_next
= rp
;
5743 p_head
->lang
= lang
;
5744 p_head
->pat
= patbuf
;
5745 p_head
->name
= savestr (name
);
5746 p_head
->error_signaled
= FALSE
;
5747 p_head
->force_explicit_name
= force_explicit_name
;
5748 p_head
->ignore_case
= ignore_case
;
5749 p_head
->multi_line
= multi_line
;
5753 * Do the substitutions indicated by the regular expression and
5757 substitute (char *in
, char *out
, struct re_registers
*regs
)
5760 int size
, dig
, diglen
;
5763 size
= strlen (out
);
5765 /* Pass 1: figure out how much to allocate by finding all \N strings. */
5766 if (out
[size
- 1] == '\\')
5767 fatal ("pattern error in \"%s\"", out
);
5768 for (t
= etags_strchr (out
, '\\');
5770 t
= etags_strchr (t
+ 2, '\\'))
5774 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
5780 /* Allocate space and do the substitutions. */
5782 result
= xnew (size
+ 1, char);
5784 for (t
= result
; *out
!= '\0'; out
++)
5785 if (*out
== '\\' && ISDIGIT (*++out
))
5788 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
5789 memcpy (t
, in
+ regs
->start
[dig
], diglen
);
5796 assert (t
<= result
+ size
);
5797 assert (t
- result
== (int)strlen (result
));
5802 /* Deallocate all regexps. */
5807 while (p_head
!= NULL
)
5809 rp
= p_head
->p_next
;
5810 free (p_head
->pattern
);
5811 free (p_head
->name
);
5819 * Reads the whole file as a single string from `filebuf' and looks for
5820 * multi-line regular expressions, creating tags on matches.
5821 * readline already dealt with normal regexps.
5823 * Idea by Ben Wing <ben@666.com> (2002).
5826 regex_tag_multiline (void)
5828 char *buffer
= filebuf
.buffer
;
5832 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
5836 if (!rp
->multi_line
)
5837 continue; /* skip normal regexps */
5839 /* Generic initializations before parsing file from memory. */
5840 lineno
= 1; /* reset global line number */
5841 charno
= 0; /* reset global char number */
5842 linecharno
= 0; /* reset global char number of line start */
5844 /* Only use generic regexps or those for the current language. */
5845 if (rp
->lang
!= NULL
&& rp
->lang
!= curfdp
->lang
)
5848 while (match
>= 0 && match
< filebuf
.len
)
5850 match
= re_search (rp
->pat
, buffer
, filebuf
.len
, charno
,
5851 filebuf
.len
- match
, &rp
->regs
);
5856 if (!rp
->error_signaled
)
5858 error ("regexp stack overflow while matching \"%s\"",
5860 rp
->error_signaled
= TRUE
;
5867 if (match
== rp
->regs
.end
[0])
5869 if (!rp
->error_signaled
)
5871 error ("regexp matches the empty string: \"%s\"",
5873 rp
->error_signaled
= TRUE
;
5875 match
= -3; /* exit from while loop */
5879 /* Match occurred. Construct a tag. */
5880 while (charno
< rp
->regs
.end
[0])
5881 if (buffer
[charno
++] == '\n')
5882 lineno
++, linecharno
= charno
;
5884 if (name
[0] == '\0')
5886 else /* make a named tag */
5887 name
= substitute (buffer
, rp
->name
, &rp
->regs
);
5888 if (rp
->force_explicit_name
)
5889 /* Force explicit tag name, if a name is there. */
5890 pfnote (name
, TRUE
, buffer
+ linecharno
,
5891 charno
- linecharno
+ 1, lineno
, linecharno
);
5893 make_tag (name
, strlen (name
), TRUE
, buffer
+ linecharno
,
5894 charno
- linecharno
+ 1, lineno
, linecharno
);
5903 nocase_tail (const char *cp
)
5905 register int len
= 0;
5907 while (*cp
!= '\0' && lowcase (*cp
) == lowcase (dbp
[len
]))
5909 if (*cp
== '\0' && !intoken (dbp
[len
]))
5918 get_tag (register char *bp
, char **namepp
)
5920 register char *cp
= bp
;
5924 /* Go till you get to white space or a syntactic break */
5925 for (cp
= bp
+ 1; !notinname (*cp
); cp
++)
5927 make_tag (bp
, cp
- bp
, TRUE
,
5928 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
5932 *namepp
= savenstr (bp
, cp
- bp
);
5936 * Read a line of text from `stream' into `lbp', excluding the
5937 * newline or CR-NL, if any. Return the number of characters read from
5938 * `stream', which is the length of the line including the newline.
5940 * On DOS or Windows we do not count the CR character, if any before the
5941 * NL, in the returned length; this mirrors the behavior of Emacs on those
5942 * platforms (for text files, it translates CR-NL to NL as it reads in the
5945 * If multi-line regular expressions are requested, each line read is
5946 * appended to `filebuf'.
5949 readline_internal (linebuffer
*lbp
, register FILE *stream
)
5951 char *buffer
= lbp
->buffer
;
5952 register char *p
= lbp
->buffer
;
5953 register char *pend
;
5956 pend
= p
+ lbp
->size
; /* Separate to avoid 386/IX compiler bug. */
5960 register int c
= getc (stream
);
5963 /* We're at the end of linebuffer: expand it. */
5965 xrnew (buffer
, lbp
->size
, char);
5966 p
+= buffer
- lbp
->buffer
;
5967 pend
= buffer
+ lbp
->size
;
5968 lbp
->buffer
= buffer
;
5978 if (p
> buffer
&& p
[-1] == '\r')
5982 /* Assume CRLF->LF translation will be performed by Emacs
5983 when loading this file, so CRs won't appear in the buffer.
5984 It would be cleaner to compensate within Emacs;
5985 however, Emacs does not know how many CRs were deleted
5986 before any given point in the file. */
6001 lbp
->len
= p
- buffer
;
6003 if (need_filebuf
/* we need filebuf for multi-line regexps */
6004 && chars_deleted
> 0) /* not at EOF */
6006 while (filebuf
.size
<= filebuf
.len
+ lbp
->len
+ 1) /* +1 for \n */
6008 /* Expand filebuf. */
6010 xrnew (filebuf
.buffer
, filebuf
.size
, char);
6012 memcpy (filebuf
.buffer
+ filebuf
.len
, lbp
->buffer
, lbp
->len
);
6013 filebuf
.len
+= lbp
->len
;
6014 filebuf
.buffer
[filebuf
.len
++] = '\n';
6015 filebuf
.buffer
[filebuf
.len
] = '\0';
6018 return lbp
->len
+ chars_deleted
;
6022 * Like readline_internal, above, but in addition try to match the
6023 * input line against relevant regular expressions and manage #line
6027 readline (linebuffer
*lbp
, FILE *stream
)
6031 linecharno
= charno
; /* update global char number of line start */
6032 result
= readline_internal (lbp
, stream
); /* read line */
6033 lineno
+= 1; /* increment global line number */
6034 charno
+= result
; /* increment global char number */
6036 /* Honor #line directives. */
6037 if (!no_line_directive
)
6039 static bool discard_until_line_directive
;
6041 /* Check whether this is a #line directive. */
6042 if (result
> 12 && strneq (lbp
->buffer
, "#line ", 6))
6047 if (sscanf (lbp
->buffer
, "#line %u \"%n", &lno
, &start
) >= 1
6048 && start
> 0) /* double quote character found */
6050 char *endp
= lbp
->buffer
+ start
;
6052 while ((endp
= etags_strchr (endp
, '"')) != NULL
6053 && endp
[-1] == '\\')
6056 /* Ok, this is a real #line directive. Let's deal with it. */
6058 char *taggedabsname
; /* absolute name of original file */
6059 char *taggedfname
; /* name of original file as given */
6060 char *name
; /* temp var */
6062 discard_until_line_directive
= FALSE
; /* found it */
6063 name
= lbp
->buffer
+ start
;
6065 canonicalize_filename (name
);
6066 taggedabsname
= absolute_filename (name
, tagfiledir
);
6067 if (filename_is_absolute (name
)
6068 || filename_is_absolute (curfdp
->infname
))
6069 taggedfname
= savestr (taggedabsname
);
6071 taggedfname
= relative_filename (taggedabsname
,tagfiledir
);
6073 if (streq (curfdp
->taggedfname
, taggedfname
))
6074 /* The #line directive is only a line number change. We
6075 deal with this afterwards. */
6078 /* The tags following this #line directive should be
6079 attributed to taggedfname. In order to do this, set
6080 curfdp accordingly. */
6082 fdesc
*fdp
; /* file description pointer */
6084 /* Go look for a file description already set up for the
6085 file indicated in the #line directive. If there is
6086 one, use it from now until the next #line
6088 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6089 if (streq (fdp
->infname
, curfdp
->infname
)
6090 && streq (fdp
->taggedfname
, taggedfname
))
6091 /* If we remove the second test above (after the &&)
6092 then all entries pertaining to the same file are
6093 coalesced in the tags file. If we use it, then
6094 entries pertaining to the same file but generated
6095 from different files (via #line directives) will
6096 go into separate sections in the tags file. These
6097 alternatives look equivalent. The first one
6098 destroys some apparently useless information. */
6104 /* Else, if we already tagged the real file, skip all
6105 input lines until the next #line directive. */
6106 if (fdp
== NULL
) /* not found */
6107 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6108 if (streq (fdp
->infabsname
, taggedabsname
))
6110 discard_until_line_directive
= TRUE
;
6114 /* Else create a new file description and use that from
6115 now on, until the next #line directive. */
6116 if (fdp
== NULL
) /* not found */
6119 fdhead
= xnew (1, fdesc
);
6120 *fdhead
= *curfdp
; /* copy curr. file description */
6122 fdhead
->infname
= savestr (curfdp
->infname
);
6123 fdhead
->infabsname
= savestr (curfdp
->infabsname
);
6124 fdhead
->infabsdir
= savestr (curfdp
->infabsdir
);
6125 fdhead
->taggedfname
= taggedfname
;
6126 fdhead
->usecharno
= FALSE
;
6127 fdhead
->prop
= NULL
;
6128 fdhead
->written
= FALSE
;
6132 free (taggedabsname
);
6134 readline (lbp
, stream
);
6136 } /* if a real #line directive */
6137 } /* if #line is followed by a number */
6138 } /* if line begins with "#line " */
6140 /* If we are here, no #line directive was found. */
6141 if (discard_until_line_directive
)
6145 /* Do a tail recursion on ourselves, thus discarding the contents
6146 of the line buffer. */
6147 readline (lbp
, stream
);
6151 discard_until_line_directive
= FALSE
;
6154 } /* if #line directives should be considered */
6161 /* Match against relevant regexps. */
6163 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6165 /* Only use generic regexps or those for the current language.
6166 Also do not use multiline regexps, which is the job of
6167 regex_tag_multiline. */
6168 if ((rp
->lang
!= NULL
&& rp
->lang
!= fdhead
->lang
)
6172 match
= re_match (rp
->pat
, lbp
->buffer
, lbp
->len
, 0, &rp
->regs
);
6177 if (!rp
->error_signaled
)
6179 error ("regexp stack overflow while matching \"%s\"",
6181 rp
->error_signaled
= TRUE
;
6188 /* Empty string matched. */
6189 if (!rp
->error_signaled
)
6191 error ("regexp matches the empty string: \"%s\"", rp
->pattern
);
6192 rp
->error_signaled
= TRUE
;
6196 /* Match occurred. Construct a tag. */
6198 if (name
[0] == '\0')
6200 else /* make a named tag */
6201 name
= substitute (lbp
->buffer
, rp
->name
, &rp
->regs
);
6202 if (rp
->force_explicit_name
)
6203 /* Force explicit tag name, if a name is there. */
6204 pfnote (name
, TRUE
, lbp
->buffer
, match
, lineno
, linecharno
);
6206 make_tag (name
, strlen (name
), TRUE
,
6207 lbp
->buffer
, match
, lineno
, linecharno
);
6216 * Return a pointer to a space of size strlen(cp)+1 allocated
6217 * with xnew where the string CP has been copied.
6220 savestr (const char *cp
)
6222 return savenstr (cp
, strlen (cp
));
6226 * Return a pointer to a space of size LEN+1 allocated with xnew where
6227 * the string CP has been copied for at most the first LEN characters.
6230 savenstr (const char *cp
, int len
)
6234 dp
= xnew (len
+ 1, char);
6235 memcpy (dp
, cp
, len
);
6241 * Return the ptr in sp at which the character c last
6242 * appears; NULL if not found
6244 * Identical to POSIX strrchr, included for portability.
6247 etags_strrchr (register const char *sp
, register int c
)
6249 register const char *r
;
6261 * Return the ptr in sp at which the character c first
6262 * appears; NULL if not found
6264 * Identical to POSIX strchr, included for portability.
6267 etags_strchr (register const char *sp
, register int c
)
6277 /* Skip spaces (end of string is not space), return new pointer. */
6279 skip_spaces (char *cp
)
6281 while (iswhite (*cp
))
6286 /* Skip non spaces, except end of string, return new pointer. */
6288 skip_non_spaces (char *cp
)
6290 while (*cp
!= '\0' && !iswhite (*cp
))
6295 /* Print error message and exit. */
6297 fatal (const char *s1
, const char *s2
)
6300 exit (EXIT_FAILURE
);
6304 pfatal (const char *s1
)
6307 exit (EXIT_FAILURE
);
6311 suggest_asking_for_help (void)
6313 fprintf (stderr
, "\tTry `%s --help' for a complete list of options.\n",
6315 exit (EXIT_FAILURE
);
6318 /* Output a diagnostic with printf-style FORMAT and args. */
6320 error (const char *format
, ...)
6323 va_start (ap
, format
);
6324 fprintf (stderr
, "%s: ", progname
);
6325 vfprintf (stderr
, format
, ap
);
6326 fprintf (stderr
, "\n");
6330 /* Return a newly-allocated string whose contents
6331 concatenate those of s1, s2, s3. */
6333 concat (const char *s1
, const char *s2
, const char *s3
)
6335 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
6336 char *result
= xnew (len1
+ len2
+ len3
+ 1, char);
6338 strcpy (result
, s1
);
6339 strcpy (result
+ len1
, s2
);
6340 strcpy (result
+ len1
+ len2
, s3
);
6341 result
[len1
+ len2
+ len3
] = '\0';
6347 /* Does the same work as the system V getcwd, but does not need to
6348 guess the buffer size in advance. */
6353 char *path
= xnew (bufsize
, char);
6355 while (getcwd (path
, bufsize
) == NULL
)
6357 if (errno
!= ERANGE
)
6361 path
= xnew (bufsize
, char);
6364 canonicalize_filename (path
);
6368 /* Return a newly allocated string containing the file name of FILE
6369 relative to the absolute directory DIR (which should end with a slash). */
6371 relative_filename (char *file
, char *dir
)
6373 char *fp
, *dp
, *afn
, *res
;
6376 /* Find the common root of file and dir (with a trailing slash). */
6377 afn
= absolute_filename (file
, cwd
);
6380 while (*fp
++ == *dp
++)
6382 fp
--, dp
--; /* back to the first differing char */
6384 if (fp
== afn
&& afn
[0] != '/') /* cannot build a relative name */
6387 do /* look at the equal chars until '/' */
6391 /* Build a sequence of "../" strings for the resulting relative file name. */
6393 while ((dp
= etags_strchr (dp
+ 1, '/')) != NULL
)
6395 res
= xnew (3*i
+ strlen (fp
+ 1) + 1, char);
6398 strcat (res
, "../");
6400 /* Add the file name relative to the common root of file and dir. */
6401 strcat (res
, fp
+ 1);
6407 /* Return a newly allocated string containing the absolute file name
6408 of FILE given DIR (which should end with a slash). */
6410 absolute_filename (char *file
, char *dir
)
6412 char *slashp
, *cp
, *res
;
6414 if (filename_is_absolute (file
))
6415 res
= savestr (file
);
6417 /* We don't support non-absolute file names with a drive
6418 letter, like `d:NAME' (it's too much hassle). */
6419 else if (file
[1] == ':')
6420 fatal ("%s: relative file names with drive letters not supported", file
);
6423 res
= concat (dir
, file
, "");
6425 /* Delete the "/dirname/.." and "/." substrings. */
6426 slashp
= etags_strchr (res
, '/');
6427 while (slashp
!= NULL
&& slashp
[0] != '\0')
6429 if (slashp
[1] == '.')
6431 if (slashp
[2] == '.'
6432 && (slashp
[3] == '/' || slashp
[3] == '\0'))
6437 while (cp
>= res
&& !filename_is_absolute (cp
));
6439 cp
= slashp
; /* the absolute name begins with "/.." */
6441 /* Under MSDOS and NT we get `d:/NAME' as absolute
6442 file name, so the luser could say `d:/../NAME'.
6443 We silently treat this as `d:/NAME'. */
6444 else if (cp
[0] != '/')
6447 memmove (cp
, slashp
+ 3, strlen (slashp
+ 2));
6451 else if (slashp
[2] == '/' || slashp
[2] == '\0')
6453 memmove (slashp
, slashp
+ 2, strlen (slashp
+ 1));
6458 slashp
= etags_strchr (slashp
+ 1, '/');
6461 if (res
[0] == '\0') /* just a safety net: should never happen */
6464 return savestr ("/");
6470 /* Return a newly allocated string containing the absolute
6471 file name of dir where FILE resides given DIR (which should
6472 end with a slash). */
6474 absolute_dirname (char *file
, char *dir
)
6479 slashp
= etags_strrchr (file
, '/');
6481 return savestr (dir
);
6484 res
= absolute_filename (file
, dir
);
6490 /* Whether the argument string is an absolute file name. The argument
6491 string must have been canonicalized with canonicalize_filename. */
6493 filename_is_absolute (char *fn
)
6495 return (fn
[0] == '/'
6497 || (ISALPHA (fn
[0]) && fn
[1] == ':' && fn
[2] == '/')
6502 /* Downcase DOS drive letter and collapse separators into single slashes.
6505 canonicalize_filename (register char *fn
)
6511 /* Canonicalize drive letter case. */
6512 # define ISUPPER(c) isupper (CHAR (c))
6513 if (fn
[0] != '\0' && fn
[1] == ':' && ISUPPER (fn
[0]))
6514 fn
[0] = lowcase (fn
[0]);
6519 /* Collapse multiple separators into a single slash. */
6520 for (cp
= fn
; *cp
!= '\0'; cp
++, fn
++)
6524 while (cp
[1] == sep
)
6533 /* Initialize a linebuffer for use. */
6535 linebuffer_init (linebuffer
*lbp
)
6537 lbp
->size
= (DEBUG
) ? 3 : 200;
6538 lbp
->buffer
= xnew (lbp
->size
, char);
6539 lbp
->buffer
[0] = '\0';
6543 /* Set the minimum size of a string contained in a linebuffer. */
6545 linebuffer_setlen (linebuffer
*lbp
, int toksize
)
6547 while (lbp
->size
<= toksize
)
6550 xrnew (lbp
->buffer
, lbp
->size
, char);
6555 /* Like malloc but get fatal error if memory is exhausted. */
6557 xmalloc (size_t size
)
6559 void *result
= malloc (size
);
6561 fatal ("virtual memory exhausted", (char *)NULL
);
6566 xrealloc (char *ptr
, size_t size
)
6568 void *result
= realloc (ptr
, size
);
6570 fatal ("virtual memory exhausted", (char *)NULL
);
6576 * indent-tabs-mode: t
6579 * c-font-lock-extra-types: ("FILE" "bool" "language" "linebuffer" "fdesc" "node" "regexp")
6580 * c-file-style: "gnu"
6584 /* etags.c ends here */