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 * /^use constant[ \t\n]+[^ \t\n{=,;]+/
4273 * Perl variable names: /^(my|local).../
4274 * Original code by Bart Robinson <lomew@cs.utah.edu> (1995)
4275 * Additions by Michael Ernst <mernst@alum.mit.edu> (1997)
4276 * Ideas by Kai Großjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE> (2001)
4279 Perl_functions (FILE *inf
)
4281 char *package
= savestr ("main"); /* current package name */
4284 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4286 cp
= skip_spaces (cp
);
4288 if (LOOKING_AT (cp
, "package"))
4291 get_tag (cp
, &package
);
4293 else if (LOOKING_AT (cp
, "sub"))
4299 while (!notinname (*cp
))
4302 continue; /* nothing found */
4303 if ((pos
= etags_strchr (sp
, ':')) != NULL
4304 && pos
< cp
&& pos
[1] == ':')
4305 /* The name is already qualified. */
4306 make_tag (sp
, cp
- sp
, TRUE
,
4307 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4311 char savechar
, *name
;
4315 name
= concat (package
, "::", sp
);
4317 make_tag (name
, strlen (name
), TRUE
,
4318 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4322 else if (LOOKING_AT (cp
, "use constant")
4323 || LOOKING_AT (cp
, "use constant::defer"))
4325 /* For hash style multi-constant like
4326 use constant { FOO => 123,
4328 only the first FOO is picked up. Parsing across the value
4329 expressions would be difficult in general, due to possible nested
4330 hashes, here-documents, etc. */
4332 cp
= skip_spaces (cp
+1);
4335 else if (globals
) /* only if we are tagging global vars */
4337 /* Skip a qualifier, if any. */
4338 bool qual
= LOOKING_AT (cp
, "my") || LOOKING_AT (cp
, "local");
4339 /* After "my" or "local", but before any following paren or space. */
4340 char *varstart
= cp
;
4342 if (qual
/* should this be removed? If yes, how? */
4343 && (*cp
== '$' || *cp
== '@' || *cp
== '%'))
4348 while (ISALNUM (*cp
) || *cp
== '_');
4352 /* Should be examining a variable list at this point;
4353 could insist on seeing an open parenthesis. */
4354 while (*cp
!= '\0' && *cp
!= ';' && *cp
!= '=' && *cp
!= ')')
4360 make_tag (varstart
, cp
- varstart
, FALSE
,
4361 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4370 * Look for /^[\t]*def[ \t\n]+[^ \t\n(:]+/ or /^class[ \t\n]+[^ \t\n(:]+/
4371 * Idea by Eric S. Raymond <esr@thyrsus.com> (1997)
4372 * More ideas by seb bacon <seb@jamkit.com> (2002)
4375 Python_functions (FILE *inf
)
4379 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4381 cp
= skip_spaces (cp
);
4382 if (LOOKING_AT (cp
, "def") || LOOKING_AT (cp
, "class"))
4385 while (!notinname (*cp
) && *cp
!= ':')
4387 make_tag (name
, cp
- name
, TRUE
,
4388 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4397 * - /^[ \t]*function[ \t\n]+[^ \t\n(]+/
4398 * - /^[ \t]*class[ \t\n]+[^ \t\n]+/
4399 * - /^[ \t]*define\(\"[^\"]+/
4400 * Only with --members:
4401 * - /^[ \t]*var[ \t\n]+\$[^ \t\n=;]/
4402 * Idea by Diez B. Roggisch (2001)
4405 PHP_functions (FILE *inf
)
4407 register char *cp
, *name
;
4408 bool search_identifier
= FALSE
;
4410 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4412 cp
= skip_spaces (cp
);
4414 if (search_identifier
4417 while (!notinname (*cp
))
4419 make_tag (name
, cp
- name
, TRUE
,
4420 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4421 search_identifier
= FALSE
;
4423 else if (LOOKING_AT (cp
, "function"))
4426 cp
= skip_spaces (cp
+1);
4430 while (!notinname (*cp
))
4432 make_tag (name
, cp
- name
, TRUE
,
4433 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4436 search_identifier
= TRUE
;
4438 else if (LOOKING_AT (cp
, "class"))
4443 while (*cp
!= '\0' && !iswhite (*cp
))
4445 make_tag (name
, cp
- name
, FALSE
,
4446 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4449 search_identifier
= TRUE
;
4451 else if (strneq (cp
, "define", 6)
4452 && (cp
= skip_spaces (cp
+6))
4454 && (*cp
== '"' || *cp
== '\''))
4458 while (*cp
!= quote
&& *cp
!= '\0')
4460 make_tag (name
, cp
- name
, FALSE
,
4461 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4464 && LOOKING_AT (cp
, "var")
4468 while (!notinname (*cp
))
4470 make_tag (name
, cp
- name
, FALSE
,
4471 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4478 * Cobol tag functions
4479 * We could look for anything that could be a paragraph name.
4480 * i.e. anything that starts in column 8 is one word and ends in a full stop.
4481 * Idea by Corny de Souza (1993)
4484 Cobol_paragraphs (FILE *inf
)
4486 register char *bp
, *ep
;
4488 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4494 /* If eoln, compiler option or comment ignore whole line. */
4495 if (bp
[-1] != ' ' || !ISALNUM (bp
[0]))
4498 for (ep
= bp
; ISALNUM (*ep
) || *ep
== '-'; ep
++)
4501 make_tag (bp
, ep
- bp
, TRUE
,
4502 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4509 * Ideas by Assar Westerlund <assar@sics.se> (2001)
4512 Makefile_targets (FILE *inf
)
4516 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4518 if (*bp
== '\t' || *bp
== '#')
4520 while (*bp
!= '\0' && *bp
!= '=' && *bp
!= ':')
4522 if (*bp
== ':' || (globals
&& *bp
== '='))
4524 /* We should detect if there is more than one tag, but we do not.
4525 We just skip initial and final spaces. */
4526 char * namestart
= skip_spaces (lb
.buffer
);
4527 while (--bp
> namestart
)
4528 if (!notinname (*bp
))
4530 make_tag (namestart
, bp
- namestart
+ 1, TRUE
,
4531 lb
.buffer
, bp
- lb
.buffer
+ 2, lineno
, linecharno
);
4539 * Original code by Mosur K. Mohan (1989)
4541 * Locates tags for procedures & functions. Doesn't do any type- or
4542 * var-definitions. It does look for the keyword "extern" or
4543 * "forward" immediately following the procedure statement; if found,
4544 * the tag is skipped.
4547 Pascal_functions (FILE *inf
)
4549 linebuffer tline
; /* mostly copied from C_entries */
4551 int save_lineno
, namelen
, taglen
;
4554 bool /* each of these flags is TRUE if: */
4555 incomment
, /* point is inside a comment */
4556 inquote
, /* point is inside '..' string */
4557 get_tagname
, /* point is after PROCEDURE/FUNCTION
4558 keyword, so next item = potential tag */
4559 found_tag
, /* point is after a potential tag */
4560 inparms
, /* point is within parameter-list */
4561 verify_tag
; /* point has passed the parm-list, so the
4562 next token will determine whether this
4563 is a FORWARD/EXTERN to be ignored, or
4564 whether it is a real tag */
4566 save_lcno
= save_lineno
= namelen
= taglen
= 0; /* keep compiler quiet */
4567 name
= NULL
; /* keep compiler quiet */
4570 linebuffer_init (&tline
);
4572 incomment
= inquote
= FALSE
;
4573 found_tag
= FALSE
; /* have a proc name; check if extern */
4574 get_tagname
= FALSE
; /* found "procedure" keyword */
4575 inparms
= FALSE
; /* found '(' after "proc" */
4576 verify_tag
= FALSE
; /* check if "extern" is ahead */
4579 while (!feof (inf
)) /* long main loop to get next char */
4582 if (c
== '\0') /* if end of line */
4584 readline (&lb
, inf
);
4588 if (!((found_tag
&& verify_tag
)
4590 c
= *dbp
++; /* only if don't need *dbp pointing
4591 to the beginning of the name of
4592 the procedure or function */
4596 if (c
== '}') /* within { } comments */
4598 else if (c
== '*' && *dbp
== ')') /* within (* *) comments */
4615 inquote
= TRUE
; /* found first quote */
4617 case '{': /* found open { comment */
4621 if (*dbp
== '*') /* found open (* comment */
4626 else if (found_tag
) /* found '(' after tag, i.e., parm-list */
4629 case ')': /* end of parms list */
4634 if (found_tag
&& !inparms
) /* end of proc or fn stmt */
4641 if (found_tag
&& verify_tag
&& (*dbp
!= ' '))
4643 /* Check if this is an "extern" declaration. */
4646 if (lowcase (*dbp
) == 'e')
4648 if (nocase_tail ("extern")) /* superfluous, really! */
4654 else if (lowcase (*dbp
) == 'f')
4656 if (nocase_tail ("forward")) /* check for forward reference */
4662 if (found_tag
&& verify_tag
) /* not external proc, so make tag */
4666 make_tag (name
, namelen
, TRUE
,
4667 tline
.buffer
, taglen
, save_lineno
, save_lcno
);
4671 if (get_tagname
) /* grab name of proc or fn */
4678 /* Find block name. */
4679 for (cp
= dbp
+ 1; *cp
!= '\0' && !endtoken (*cp
); cp
++)
4682 /* Save all values for later tagging. */
4683 linebuffer_setlen (&tline
, lb
.len
);
4684 strcpy (tline
.buffer
, lb
.buffer
);
4685 save_lineno
= lineno
;
4686 save_lcno
= linecharno
;
4687 name
= tline
.buffer
+ (dbp
- lb
.buffer
);
4689 taglen
= cp
- lb
.buffer
+ 1;
4691 dbp
= cp
; /* set dbp to e-o-token */
4692 get_tagname
= FALSE
;
4696 /* And proceed to check for "extern". */
4698 else if (!incomment
&& !inquote
&& !found_tag
)
4700 /* Check for proc/fn keywords. */
4701 switch (lowcase (c
))
4704 if (nocase_tail ("rocedure")) /* c = 'p', dbp has advanced */
4708 if (nocase_tail ("unction"))
4713 } /* while not eof */
4715 free (tline
.buffer
);
4720 * Lisp tag functions
4721 * look for (def or (DEF, quote or QUOTE
4724 static void L_getit (void);
4729 if (*dbp
== '\'') /* Skip prefix quote */
4731 else if (*dbp
== '(')
4734 /* Try to skip "(quote " */
4735 if (!LOOKING_AT (dbp
, "quote") && !LOOKING_AT (dbp
, "QUOTE"))
4736 /* Ok, then skip "(" before name in (defstruct (foo)) */
4737 dbp
= skip_spaces (dbp
);
4739 get_tag (dbp
, NULL
);
4743 Lisp_functions (FILE *inf
)
4745 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4750 if (strneq (dbp
+1, "def", 3) || strneq (dbp
+1, "DEF", 3))
4752 dbp
= skip_non_spaces (dbp
);
4753 dbp
= skip_spaces (dbp
);
4758 /* Check for (foo::defmumble name-defined ... */
4761 while (!notinname (*dbp
) && *dbp
!= ':');
4766 while (*dbp
== ':');
4768 if (strneq (dbp
, "def", 3) || strneq (dbp
, "DEF", 3))
4770 dbp
= skip_non_spaces (dbp
);
4771 dbp
= skip_spaces (dbp
);
4781 * Lua script language parsing
4782 * Original code by David A. Capello <dacap@users.sourceforge.net> (2004)
4784 * "function" and "local function" are tags if they start at column 1.
4787 Lua_functions (FILE *inf
)
4791 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4793 if (bp
[0] != 'f' && bp
[0] != 'l')
4796 (void)LOOKING_AT (bp
, "local"); /* skip possible "local" */
4798 if (LOOKING_AT (bp
, "function"))
4806 * Just look for lines where the first character is '/'
4807 * Also look at "defineps" for PSWrap
4809 * Richard Mlynarik <mly@adoc.xerox.com> (1997)
4810 * Masatake Yamato <masata-y@is.aist-nara.ac.jp> (1999)
4813 PS_functions (FILE *inf
)
4815 register char *bp
, *ep
;
4817 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4822 *ep
!= '\0' && *ep
!= ' ' && *ep
!= '{';
4825 make_tag (bp
, ep
- bp
, TRUE
,
4826 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4828 else if (LOOKING_AT (bp
, "defineps"))
4836 * Ignore anything after \ followed by space or in ( )
4837 * Look for words defined by :
4838 * Look for constant, code, create, defer, value, and variable
4839 * OBP extensions: Look for buffer:, field,
4840 * Ideas by Eduardo Horvath <eeh@netbsd.org> (2004)
4843 Forth_words (FILE *inf
)
4847 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4848 while ((bp
= skip_spaces (bp
))[0] != '\0')
4849 if (bp
[0] == '\\' && iswhite (bp
[1]))
4850 break; /* read next line */
4851 else if (bp
[0] == '(' && iswhite (bp
[1]))
4852 do /* skip to ) or eol */
4854 while (*bp
!= ')' && *bp
!= '\0');
4855 else if ((bp
[0] == ':' && iswhite (bp
[1]) && bp
++)
4856 || LOOKING_AT_NOCASE (bp
, "constant")
4857 || LOOKING_AT_NOCASE (bp
, "code")
4858 || LOOKING_AT_NOCASE (bp
, "create")
4859 || LOOKING_AT_NOCASE (bp
, "defer")
4860 || LOOKING_AT_NOCASE (bp
, "value")
4861 || LOOKING_AT_NOCASE (bp
, "variable")
4862 || LOOKING_AT_NOCASE (bp
, "buffer:")
4863 || LOOKING_AT_NOCASE (bp
, "field"))
4864 get_tag (skip_spaces (bp
), NULL
); /* Yay! A definition! */
4866 bp
= skip_non_spaces (bp
);
4871 * Scheme tag functions
4872 * look for (def... xyzzy
4874 * (def ... ((...(xyzzy ....
4876 * Original code by Ken Haase (1985?)
4879 Scheme_functions (FILE *inf
)
4883 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4885 if (strneq (bp
, "(def", 4) || strneq (bp
, "(DEF", 4))
4887 bp
= skip_non_spaces (bp
+4);
4888 /* Skip over open parens and white space. Don't continue past
4890 while (*bp
&& notinname (*bp
))
4894 if (LOOKING_AT (bp
, "(SET!") || LOOKING_AT (bp
, "(set!"))
4900 /* Find tags in TeX and LaTeX input files. */
4902 /* TEX_toktab is a table of TeX control sequences that define tags.
4903 * Each entry records one such control sequence.
4905 * Original code from who knows whom.
4907 * Stefan Monnier (2002)
4910 static linebuffer
*TEX_toktab
= NULL
; /* Table with tag tokens */
4912 /* Default set of control sequences to put into TEX_toktab.
4913 The value of environment var TEXTAGS is prepended to this. */
4914 static const char *TEX_defenv
= "\
4915 :chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem\
4916 :part:appendix:entry:index:def\
4917 :newcommand:renewcommand:newenvironment:renewenvironment";
4919 static void TEX_mode (FILE *);
4920 static void TEX_decode_env (const char *, const char *);
4922 static char TEX_esc
= '\\';
4923 static char TEX_opgrp
= '{';
4924 static char TEX_clgrp
= '}';
4927 * TeX/LaTeX scanning loop.
4930 TeX_commands (FILE *inf
)
4935 /* Select either \ or ! as escape character. */
4938 /* Initialize token table once from environment. */
4939 if (TEX_toktab
== NULL
)
4940 TEX_decode_env ("TEXTAGS", TEX_defenv
);
4942 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4944 /* Look at each TEX keyword in line. */
4947 /* Look for a TEX escape. */
4948 while (*cp
++ != TEX_esc
)
4949 if (cp
[-1] == '\0' || cp
[-1] == '%')
4952 for (key
= TEX_toktab
; key
->buffer
!= NULL
; key
++)
4953 if (strneq (cp
, key
->buffer
, key
->len
))
4956 int namelen
, linelen
;
4959 cp
= skip_spaces (cp
+ key
->len
);
4960 if (*cp
== TEX_opgrp
)
4966 (!iswhite (*p
) && *p
!= '#' &&
4967 *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
);
4972 if (!opgrp
|| *p
== TEX_clgrp
)
4974 while (*p
!= '\0' && *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
)
4976 linelen
= p
- lb
.buffer
+ 1;
4978 make_tag (cp
, namelen
, TRUE
,
4979 lb
.buffer
, linelen
, lineno
, linecharno
);
4980 goto tex_next_line
; /* We only tag a line once */
4988 #define TEX_LESC '\\'
4989 #define TEX_SESC '!'
4991 /* Figure out whether TeX's escapechar is '\\' or '!' and set grouping
4992 chars accordingly. */
4994 TEX_mode (FILE *inf
)
4998 while ((c
= getc (inf
)) != EOF
)
5000 /* Skip to next line if we hit the TeX comment char. */
5002 while (c
!= '\n' && c
!= EOF
)
5004 else if (c
== TEX_LESC
|| c
== TEX_SESC
)
5020 /* If the input file is compressed, inf is a pipe, and rewind may fail.
5021 No attempt is made to correct the situation. */
5025 /* Read environment and prepend it to the default string.
5026 Build token table. */
5028 TEX_decode_env (const char *evarname
, const char *defenv
)
5030 register const char *env
, *p
;
5033 /* Append default string to environment. */
5034 env
= getenv (evarname
);
5038 env
= concat (env
, defenv
, "");
5040 /* Allocate a token table */
5041 for (len
= 1, p
= env
; p
;)
5042 if ((p
= etags_strchr (p
, ':')) && *++p
!= '\0')
5044 TEX_toktab
= xnew (len
, linebuffer
);
5046 /* Unpack environment string into token table. Be careful about */
5047 /* zero-length strings (leading ':', "::" and trailing ':') */
5048 for (i
= 0; *env
!= '\0';)
5050 p
= etags_strchr (env
, ':');
5051 if (!p
) /* End of environment string. */
5052 p
= env
+ strlen (env
);
5054 { /* Only non-zero strings. */
5055 TEX_toktab
[i
].buffer
= savenstr (env
, p
- env
);
5056 TEX_toktab
[i
].len
= p
- env
;
5063 TEX_toktab
[i
].buffer
= NULL
; /* Mark end of table. */
5064 TEX_toktab
[i
].len
= 0;
5071 /* Texinfo support. Dave Love, Mar. 2000. */
5073 Texinfo_nodes (FILE *inf
)
5076 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5077 if (LOOKING_AT (cp
, "@node"))
5080 while (*cp
!= '\0' && *cp
!= ',')
5082 make_tag (start
, cp
- start
, TRUE
,
5083 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
5090 * Contents of <title>, <h1>, <h2>, <h3> are tags.
5091 * Contents of <a name=xxx> are tags with name xxx.
5093 * Francesco Potortì, 2002.
5096 HTML_labels (FILE *inf
)
5098 bool getnext
= FALSE
; /* next text outside of HTML tags is a tag */
5099 bool skiptag
= FALSE
; /* skip to the end of the current HTML tag */
5100 bool intag
= FALSE
; /* inside an html tag, looking for ID= */
5101 bool inanchor
= FALSE
; /* when INTAG, is an anchor, look for NAME= */
5105 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5107 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
5108 for (;;) /* loop on the same line */
5110 if (skiptag
) /* skip HTML tag */
5112 while (*dbp
!= '\0' && *dbp
!= '>')
5118 continue; /* look on the same line */
5120 break; /* go to next line */
5123 else if (intag
) /* look for "name=" or "id=" */
5125 while (*dbp
!= '\0' && *dbp
!= '>'
5126 && lowcase (*dbp
) != 'n' && lowcase (*dbp
) != 'i')
5129 break; /* go to next line */
5134 continue; /* look on the same line */
5136 if ((inanchor
&& LOOKING_AT_NOCASE (dbp
, "name="))
5137 || LOOKING_AT_NOCASE (dbp
, "id="))
5139 bool quoted
= (dbp
[0] == '"');
5142 for (end
= ++dbp
; *end
!= '\0' && *end
!= '"'; end
++)
5145 for (end
= dbp
; *end
!= '\0' && intoken (*end
); end
++)
5147 linebuffer_setlen (&token_name
, end
- dbp
);
5148 memcpy (token_name
.buffer
, dbp
, end
- dbp
);
5149 token_name
.buffer
[end
- dbp
] = '\0';
5152 intag
= FALSE
; /* we found what we looked for */
5153 skiptag
= TRUE
; /* skip to the end of the tag */
5154 getnext
= TRUE
; /* then grab the text */
5155 continue; /* look on the same line */
5160 else if (getnext
) /* grab next tokens and tag them */
5162 dbp
= skip_spaces (dbp
);
5164 break; /* go to next line */
5168 inanchor
= (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]));
5169 continue; /* look on the same line */
5172 for (end
= dbp
+ 1; *end
!= '\0' && *end
!= '<'; end
++)
5174 make_tag (token_name
.buffer
, token_name
.len
, TRUE
,
5175 dbp
, end
- dbp
, lineno
, linecharno
);
5176 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5178 break; /* go to next line */
5181 else /* look for an interesting HTML tag */
5183 while (*dbp
!= '\0' && *dbp
!= '<')
5186 break; /* go to next line */
5188 if (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]))
5191 continue; /* look on the same line */
5193 else if (LOOKING_AT_NOCASE (dbp
, "<title>")
5194 || LOOKING_AT_NOCASE (dbp
, "<h1>")
5195 || LOOKING_AT_NOCASE (dbp
, "<h2>")
5196 || LOOKING_AT_NOCASE (dbp
, "<h3>"))
5200 continue; /* look on the same line */
5211 * Assumes that the predicate or rule starts at column 0.
5212 * Only the first clause of a predicate or rule is added.
5213 * Original code by Sunichirou Sugou (1989)
5214 * Rewritten by Anders Lindgren (1996)
5216 static size_t prolog_pr (char *, char *);
5217 static void prolog_skip_comment (linebuffer
*, FILE *);
5218 static size_t prolog_atom (char *, size_t);
5221 Prolog_functions (FILE *inf
)
5231 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5233 if (cp
[0] == '\0') /* Empty line */
5235 else if (iswhite (cp
[0])) /* Not a predicate */
5237 else if (cp
[0] == '/' && cp
[1] == '*') /* comment. */
5238 prolog_skip_comment (&lb
, inf
);
5239 else if ((len
= prolog_pr (cp
, last
)) > 0)
5241 /* Predicate or rule. Store the function name so that we
5242 only generate a tag for the first clause. */
5244 last
= xnew (len
+ 1, char);
5245 else if (len
+ 1 > allocated
)
5246 xrnew (last
, len
+ 1, char);
5247 allocated
= len
+ 1;
5248 memcpy (last
, cp
, len
);
5257 prolog_skip_comment (linebuffer
*plb
, FILE *inf
)
5263 for (cp
= plb
->buffer
; *cp
!= '\0'; cp
++)
5264 if (cp
[0] == '*' && cp
[1] == '/')
5266 readline (plb
, inf
);
5268 while (!feof (inf
));
5272 * A predicate or rule definition is added if it matches:
5273 * <beginning of line><Prolog Atom><whitespace>(
5274 * or <beginning of line><Prolog Atom><whitespace>:-
5276 * It is added to the tags database if it doesn't match the
5277 * name of the previous clause header.
5279 * Return the size of the name of the predicate or rule, or 0 if no
5283 prolog_pr (char *s
, char *last
)
5285 /* Name of last clause. */
5290 pos
= prolog_atom (s
, 0);
5295 pos
= skip_spaces (s
+ pos
) - s
;
5298 || (s
[pos
] == '(' && (pos
+= 1))
5299 || (s
[pos
] == ':' && s
[pos
+ 1] == '-' && (pos
+= 2)))
5300 && (last
== NULL
/* save only the first clause */
5301 || len
!= strlen (last
)
5302 || !strneq (s
, last
, len
)))
5304 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5312 * Consume a Prolog atom.
5313 * Return the number of bytes consumed, or 0 if there was an error.
5315 * A prolog atom, in this context, could be one of:
5316 * - An alphanumeric sequence, starting with a lower case letter.
5317 * - A quoted arbitrary string. Single quotes can escape themselves.
5318 * Backslash quotes everything.
5321 prolog_atom (char *s
, size_t pos
)
5327 if (ISLOWER (s
[pos
]) || (s
[pos
] == '_'))
5329 /* The atom is unquoted. */
5331 while (ISALNUM (s
[pos
]) || (s
[pos
] == '_'))
5335 return pos
- origpos
;
5337 else if (s
[pos
] == '\'')
5348 pos
++; /* A double quote */
5350 else if (s
[pos
] == '\0')
5351 /* Multiline quoted atoms are ignored. */
5353 else if (s
[pos
] == '\\')
5355 if (s
[pos
+1] == '\0')
5362 return pos
- origpos
;
5370 * Support for Erlang
5372 * Generates tags for functions, defines, and records.
5373 * Assumes that Erlang functions start at column 0.
5374 * Original code by Anders Lindgren (1996)
5376 static int erlang_func (char *, char *);
5377 static void erlang_attribute (char *);
5378 static int erlang_atom (char *);
5381 Erlang_functions (FILE *inf
)
5391 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5393 if (cp
[0] == '\0') /* Empty line */
5395 else if (iswhite (cp
[0])) /* Not function nor attribute */
5397 else if (cp
[0] == '%') /* comment */
5399 else if (cp
[0] == '"') /* Sometimes, strings start in column one */
5401 else if (cp
[0] == '-') /* attribute, e.g. "-define" */
5403 erlang_attribute (cp
);
5410 else if ((len
= erlang_func (cp
, last
)) > 0)
5413 * Function. Store the function name so that we only
5414 * generates a tag for the first clause.
5417 last
= xnew (len
+ 1, char);
5418 else if (len
+ 1 > allocated
)
5419 xrnew (last
, len
+ 1, char);
5420 allocated
= len
+ 1;
5421 memcpy (last
, cp
, len
);
5430 * A function definition is added if it matches:
5431 * <beginning of line><Erlang Atom><whitespace>(
5433 * It is added to the tags database if it doesn't match the
5434 * name of the previous clause header.
5436 * Return the size of the name of the function, or 0 if no function
5440 erlang_func (char *s
, char *last
)
5442 /* Name of last clause. */
5447 pos
= erlang_atom (s
);
5452 pos
= skip_spaces (s
+ pos
) - s
;
5454 /* Save only the first clause. */
5457 || len
!= (int)strlen (last
)
5458 || !strneq (s
, last
, len
)))
5460 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5469 * Handle attributes. Currently, tags are generated for defines
5472 * They are on the form:
5473 * -define(foo, bar).
5474 * -define(Foo(M, N), M+N).
5475 * -record(graph, {vtab = notable, cyclic = true}).
5478 erlang_attribute (char *s
)
5482 if ((LOOKING_AT (cp
, "-define") || LOOKING_AT (cp
, "-record"))
5485 int len
= erlang_atom (skip_spaces (cp
));
5487 make_tag (cp
, len
, TRUE
, s
, cp
+ len
- s
, lineno
, linecharno
);
5494 * Consume an Erlang atom (or variable).
5495 * Return the number of bytes consumed, or -1 if there was an error.
5498 erlang_atom (char *s
)
5502 if (ISALPHA (s
[pos
]) || s
[pos
] == '_')
5504 /* The atom is unquoted. */
5507 while (ISALNUM (s
[pos
]) || s
[pos
] == '_');
5509 else if (s
[pos
] == '\'')
5511 for (pos
++; s
[pos
] != '\''; pos
++)
5512 if (s
[pos
] == '\0' /* multiline quoted atoms are ignored */
5513 || (s
[pos
] == '\\' && s
[++pos
] == '\0'))
5522 static char *scan_separators (char *);
5523 static void add_regex (char *, language
*);
5524 static char *substitute (char *, char *, struct re_registers
*);
5527 * Take a string like "/blah/" and turn it into "blah", verifying
5528 * that the first and last characters are the same, and handling
5529 * quoted separator characters. Actually, stops on the occurrence of
5530 * an unquoted separator. Also process \t, \n, etc. and turn into
5531 * appropriate characters. Works in place. Null terminates name string.
5532 * Returns pointer to terminating separator, or NULL for
5533 * unterminated regexps.
5536 scan_separators (char *name
)
5539 char *copyto
= name
;
5540 bool quoted
= FALSE
;
5542 for (++name
; *name
!= '\0'; ++name
)
5548 case 'a': *copyto
++ = '\007'; break; /* BEL (bell) */
5549 case 'b': *copyto
++ = '\b'; break; /* BS (back space) */
5550 case 'd': *copyto
++ = 0177; break; /* DEL (delete) */
5551 case 'e': *copyto
++ = 033; break; /* ESC (delete) */
5552 case 'f': *copyto
++ = '\f'; break; /* FF (form feed) */
5553 case 'n': *copyto
++ = '\n'; break; /* NL (new line) */
5554 case 'r': *copyto
++ = '\r'; break; /* CR (carriage return) */
5555 case 't': *copyto
++ = '\t'; break; /* TAB (horizontal tab) */
5556 case 'v': *copyto
++ = '\v'; break; /* VT (vertical tab) */
5562 /* Something else is quoted, so preserve the quote. */
5570 else if (*name
== '\\')
5572 else if (*name
== sep
)
5578 name
= NULL
; /* signal unterminated regexp */
5580 /* Terminate copied string. */
5585 /* Look at the argument of --regex or --no-regex and do the right
5586 thing. Same for each line of a regexp file. */
5588 analyse_regex (char *regex_arg
)
5590 if (regex_arg
== NULL
)
5592 free_regexps (); /* --no-regex: remove existing regexps */
5596 /* A real --regexp option or a line in a regexp file. */
5597 switch (regex_arg
[0])
5599 /* Comments in regexp file or null arg to --regex. */
5605 /* Read a regex file. This is recursive and may result in a
5606 loop, which will stop when the file descriptors are exhausted. */
5610 linebuffer regexbuf
;
5611 char *regexfile
= regex_arg
+ 1;
5613 /* regexfile is a file containing regexps, one per line. */
5614 regexfp
= fopen (regexfile
, "r");
5615 if (regexfp
== NULL
)
5620 linebuffer_init (®exbuf
);
5621 while (readline_internal (®exbuf
, regexfp
) > 0)
5622 analyse_regex (regexbuf
.buffer
);
5623 free (regexbuf
.buffer
);
5628 /* Regexp to be used for a specific language only. */
5632 char *lang_name
= regex_arg
+ 1;
5635 for (cp
= lang_name
; *cp
!= '}'; cp
++)
5638 error ("unterminated language name in regex: %s", regex_arg
);
5642 lang
= get_language_from_langname (lang_name
);
5645 add_regex (cp
, lang
);
5649 /* Regexp to be used for any language. */
5651 add_regex (regex_arg
, NULL
);
5656 /* Separate the regexp pattern, compile it,
5657 and care for optional name and modifiers. */
5659 add_regex (char *regexp_pattern
, language
*lang
)
5661 static struct re_pattern_buffer zeropattern
;
5662 char sep
, *pat
, *name
, *modifiers
;
5665 struct re_pattern_buffer
*patbuf
;
5668 force_explicit_name
= TRUE
, /* do not use implicit tag names */
5669 ignore_case
= FALSE
, /* case is significant */
5670 multi_line
= FALSE
, /* matches are done one line at a time */
5671 single_line
= FALSE
; /* dot does not match newline */
5674 if (strlen (regexp_pattern
) < 3)
5676 error ("null regexp");
5679 sep
= regexp_pattern
[0];
5680 name
= scan_separators (regexp_pattern
);
5683 error ("%s: unterminated regexp", regexp_pattern
);
5688 error ("null name for regexp \"%s\"", regexp_pattern
);
5691 modifiers
= scan_separators (name
);
5692 if (modifiers
== NULL
) /* no terminating separator --> no name */
5698 modifiers
+= 1; /* skip separator */
5700 /* Parse regex modifiers. */
5701 for (; modifiers
[0] != '\0'; modifiers
++)
5702 switch (modifiers
[0])
5705 if (modifiers
== name
)
5706 error ("forcing explicit tag name but no name, ignoring");
5707 force_explicit_name
= TRUE
;
5717 need_filebuf
= TRUE
;
5720 error ("invalid regexp modifier `%c', ignoring", modifiers
[0]);
5724 patbuf
= xnew (1, struct re_pattern_buffer
);
5725 *patbuf
= zeropattern
;
5728 static char lc_trans
[CHARS
];
5730 for (i
= 0; i
< CHARS
; i
++)
5731 lc_trans
[i
] = lowcase (i
);
5732 patbuf
->translate
= lc_trans
; /* translation table to fold case */
5736 pat
= concat ("^", regexp_pattern
, ""); /* anchor to beginning of line */
5738 pat
= regexp_pattern
;
5741 re_set_syntax (RE_SYNTAX_EMACS
| RE_DOT_NEWLINE
);
5743 re_set_syntax (RE_SYNTAX_EMACS
);
5745 err
= re_compile_pattern (pat
, strlen (pat
), patbuf
);
5750 error ("%s while compiling pattern", err
);
5755 p_head
= xnew (1, regexp
);
5756 p_head
->pattern
= savestr (regexp_pattern
);
5757 p_head
->p_next
= rp
;
5758 p_head
->lang
= lang
;
5759 p_head
->pat
= patbuf
;
5760 p_head
->name
= savestr (name
);
5761 p_head
->error_signaled
= FALSE
;
5762 p_head
->force_explicit_name
= force_explicit_name
;
5763 p_head
->ignore_case
= ignore_case
;
5764 p_head
->multi_line
= multi_line
;
5768 * Do the substitutions indicated by the regular expression and
5772 substitute (char *in
, char *out
, struct re_registers
*regs
)
5775 int size
, dig
, diglen
;
5778 size
= strlen (out
);
5780 /* Pass 1: figure out how much to allocate by finding all \N strings. */
5781 if (out
[size
- 1] == '\\')
5782 fatal ("pattern error in \"%s\"", out
);
5783 for (t
= etags_strchr (out
, '\\');
5785 t
= etags_strchr (t
+ 2, '\\'))
5789 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
5795 /* Allocate space and do the substitutions. */
5797 result
= xnew (size
+ 1, char);
5799 for (t
= result
; *out
!= '\0'; out
++)
5800 if (*out
== '\\' && ISDIGIT (*++out
))
5803 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
5804 memcpy (t
, in
+ regs
->start
[dig
], diglen
);
5811 assert (t
<= result
+ size
);
5812 assert (t
- result
== (int)strlen (result
));
5817 /* Deallocate all regexps. */
5822 while (p_head
!= NULL
)
5824 rp
= p_head
->p_next
;
5825 free (p_head
->pattern
);
5826 free (p_head
->name
);
5834 * Reads the whole file as a single string from `filebuf' and looks for
5835 * multi-line regular expressions, creating tags on matches.
5836 * readline already dealt with normal regexps.
5838 * Idea by Ben Wing <ben@666.com> (2002).
5841 regex_tag_multiline (void)
5843 char *buffer
= filebuf
.buffer
;
5847 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
5851 if (!rp
->multi_line
)
5852 continue; /* skip normal regexps */
5854 /* Generic initializations before parsing file from memory. */
5855 lineno
= 1; /* reset global line number */
5856 charno
= 0; /* reset global char number */
5857 linecharno
= 0; /* reset global char number of line start */
5859 /* Only use generic regexps or those for the current language. */
5860 if (rp
->lang
!= NULL
&& rp
->lang
!= curfdp
->lang
)
5863 while (match
>= 0 && match
< filebuf
.len
)
5865 match
= re_search (rp
->pat
, buffer
, filebuf
.len
, charno
,
5866 filebuf
.len
- match
, &rp
->regs
);
5871 if (!rp
->error_signaled
)
5873 error ("regexp stack overflow while matching \"%s\"",
5875 rp
->error_signaled
= TRUE
;
5882 if (match
== rp
->regs
.end
[0])
5884 if (!rp
->error_signaled
)
5886 error ("regexp matches the empty string: \"%s\"",
5888 rp
->error_signaled
= TRUE
;
5890 match
= -3; /* exit from while loop */
5894 /* Match occurred. Construct a tag. */
5895 while (charno
< rp
->regs
.end
[0])
5896 if (buffer
[charno
++] == '\n')
5897 lineno
++, linecharno
= charno
;
5899 if (name
[0] == '\0')
5901 else /* make a named tag */
5902 name
= substitute (buffer
, rp
->name
, &rp
->regs
);
5903 if (rp
->force_explicit_name
)
5904 /* Force explicit tag name, if a name is there. */
5905 pfnote (name
, TRUE
, buffer
+ linecharno
,
5906 charno
- linecharno
+ 1, lineno
, linecharno
);
5908 make_tag (name
, strlen (name
), TRUE
, buffer
+ linecharno
,
5909 charno
- linecharno
+ 1, lineno
, linecharno
);
5918 nocase_tail (const char *cp
)
5920 register int len
= 0;
5922 while (*cp
!= '\0' && lowcase (*cp
) == lowcase (dbp
[len
]))
5924 if (*cp
== '\0' && !intoken (dbp
[len
]))
5933 get_tag (register char *bp
, char **namepp
)
5935 register char *cp
= bp
;
5939 /* Go till you get to white space or a syntactic break */
5940 for (cp
= bp
+ 1; !notinname (*cp
); cp
++)
5942 make_tag (bp
, cp
- bp
, TRUE
,
5943 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
5947 *namepp
= savenstr (bp
, cp
- bp
);
5951 * Read a line of text from `stream' into `lbp', excluding the
5952 * newline or CR-NL, if any. Return the number of characters read from
5953 * `stream', which is the length of the line including the newline.
5955 * On DOS or Windows we do not count the CR character, if any before the
5956 * NL, in the returned length; this mirrors the behavior of Emacs on those
5957 * platforms (for text files, it translates CR-NL to NL as it reads in the
5960 * If multi-line regular expressions are requested, each line read is
5961 * appended to `filebuf'.
5964 readline_internal (linebuffer
*lbp
, register FILE *stream
)
5966 char *buffer
= lbp
->buffer
;
5967 register char *p
= lbp
->buffer
;
5968 register char *pend
;
5971 pend
= p
+ lbp
->size
; /* Separate to avoid 386/IX compiler bug. */
5975 register int c
= getc (stream
);
5978 /* We're at the end of linebuffer: expand it. */
5980 xrnew (buffer
, lbp
->size
, char);
5981 p
+= buffer
- lbp
->buffer
;
5982 pend
= buffer
+ lbp
->size
;
5983 lbp
->buffer
= buffer
;
5993 if (p
> buffer
&& p
[-1] == '\r')
5997 /* Assume CRLF->LF translation will be performed by Emacs
5998 when loading this file, so CRs won't appear in the buffer.
5999 It would be cleaner to compensate within Emacs;
6000 however, Emacs does not know how many CRs were deleted
6001 before any given point in the file. */
6016 lbp
->len
= p
- buffer
;
6018 if (need_filebuf
/* we need filebuf for multi-line regexps */
6019 && chars_deleted
> 0) /* not at EOF */
6021 while (filebuf
.size
<= filebuf
.len
+ lbp
->len
+ 1) /* +1 for \n */
6023 /* Expand filebuf. */
6025 xrnew (filebuf
.buffer
, filebuf
.size
, char);
6027 memcpy (filebuf
.buffer
+ filebuf
.len
, lbp
->buffer
, lbp
->len
);
6028 filebuf
.len
+= lbp
->len
;
6029 filebuf
.buffer
[filebuf
.len
++] = '\n';
6030 filebuf
.buffer
[filebuf
.len
] = '\0';
6033 return lbp
->len
+ chars_deleted
;
6037 * Like readline_internal, above, but in addition try to match the
6038 * input line against relevant regular expressions and manage #line
6042 readline (linebuffer
*lbp
, FILE *stream
)
6046 linecharno
= charno
; /* update global char number of line start */
6047 result
= readline_internal (lbp
, stream
); /* read line */
6048 lineno
+= 1; /* increment global line number */
6049 charno
+= result
; /* increment global char number */
6051 /* Honor #line directives. */
6052 if (!no_line_directive
)
6054 static bool discard_until_line_directive
;
6056 /* Check whether this is a #line directive. */
6057 if (result
> 12 && strneq (lbp
->buffer
, "#line ", 6))
6062 if (sscanf (lbp
->buffer
, "#line %u \"%n", &lno
, &start
) >= 1
6063 && start
> 0) /* double quote character found */
6065 char *endp
= lbp
->buffer
+ start
;
6067 while ((endp
= etags_strchr (endp
, '"')) != NULL
6068 && endp
[-1] == '\\')
6071 /* Ok, this is a real #line directive. Let's deal with it. */
6073 char *taggedabsname
; /* absolute name of original file */
6074 char *taggedfname
; /* name of original file as given */
6075 char *name
; /* temp var */
6077 discard_until_line_directive
= FALSE
; /* found it */
6078 name
= lbp
->buffer
+ start
;
6080 canonicalize_filename (name
);
6081 taggedabsname
= absolute_filename (name
, tagfiledir
);
6082 if (filename_is_absolute (name
)
6083 || filename_is_absolute (curfdp
->infname
))
6084 taggedfname
= savestr (taggedabsname
);
6086 taggedfname
= relative_filename (taggedabsname
,tagfiledir
);
6088 if (streq (curfdp
->taggedfname
, taggedfname
))
6089 /* The #line directive is only a line number change. We
6090 deal with this afterwards. */
6093 /* The tags following this #line directive should be
6094 attributed to taggedfname. In order to do this, set
6095 curfdp accordingly. */
6097 fdesc
*fdp
; /* file description pointer */
6099 /* Go look for a file description already set up for the
6100 file indicated in the #line directive. If there is
6101 one, use it from now until the next #line
6103 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6104 if (streq (fdp
->infname
, curfdp
->infname
)
6105 && streq (fdp
->taggedfname
, taggedfname
))
6106 /* If we remove the second test above (after the &&)
6107 then all entries pertaining to the same file are
6108 coalesced in the tags file. If we use it, then
6109 entries pertaining to the same file but generated
6110 from different files (via #line directives) will
6111 go into separate sections in the tags file. These
6112 alternatives look equivalent. The first one
6113 destroys some apparently useless information. */
6119 /* Else, if we already tagged the real file, skip all
6120 input lines until the next #line directive. */
6121 if (fdp
== NULL
) /* not found */
6122 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6123 if (streq (fdp
->infabsname
, taggedabsname
))
6125 discard_until_line_directive
= TRUE
;
6129 /* Else create a new file description and use that from
6130 now on, until the next #line directive. */
6131 if (fdp
== NULL
) /* not found */
6134 fdhead
= xnew (1, fdesc
);
6135 *fdhead
= *curfdp
; /* copy curr. file description */
6137 fdhead
->infname
= savestr (curfdp
->infname
);
6138 fdhead
->infabsname
= savestr (curfdp
->infabsname
);
6139 fdhead
->infabsdir
= savestr (curfdp
->infabsdir
);
6140 fdhead
->taggedfname
= taggedfname
;
6141 fdhead
->usecharno
= FALSE
;
6142 fdhead
->prop
= NULL
;
6143 fdhead
->written
= FALSE
;
6147 free (taggedabsname
);
6149 readline (lbp
, stream
);
6151 } /* if a real #line directive */
6152 } /* if #line is followed by a number */
6153 } /* if line begins with "#line " */
6155 /* If we are here, no #line directive was found. */
6156 if (discard_until_line_directive
)
6160 /* Do a tail recursion on ourselves, thus discarding the contents
6161 of the line buffer. */
6162 readline (lbp
, stream
);
6166 discard_until_line_directive
= FALSE
;
6169 } /* if #line directives should be considered */
6176 /* Match against relevant regexps. */
6178 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6180 /* Only use generic regexps or those for the current language.
6181 Also do not use multiline regexps, which is the job of
6182 regex_tag_multiline. */
6183 if ((rp
->lang
!= NULL
&& rp
->lang
!= fdhead
->lang
)
6187 match
= re_match (rp
->pat
, lbp
->buffer
, lbp
->len
, 0, &rp
->regs
);
6192 if (!rp
->error_signaled
)
6194 error ("regexp stack overflow while matching \"%s\"",
6196 rp
->error_signaled
= TRUE
;
6203 /* Empty string matched. */
6204 if (!rp
->error_signaled
)
6206 error ("regexp matches the empty string: \"%s\"", rp
->pattern
);
6207 rp
->error_signaled
= TRUE
;
6211 /* Match occurred. Construct a tag. */
6213 if (name
[0] == '\0')
6215 else /* make a named tag */
6216 name
= substitute (lbp
->buffer
, rp
->name
, &rp
->regs
);
6217 if (rp
->force_explicit_name
)
6218 /* Force explicit tag name, if a name is there. */
6219 pfnote (name
, TRUE
, lbp
->buffer
, match
, lineno
, linecharno
);
6221 make_tag (name
, strlen (name
), TRUE
,
6222 lbp
->buffer
, match
, lineno
, linecharno
);
6231 * Return a pointer to a space of size strlen(cp)+1 allocated
6232 * with xnew where the string CP has been copied.
6235 savestr (const char *cp
)
6237 return savenstr (cp
, strlen (cp
));
6241 * Return a pointer to a space of size LEN+1 allocated with xnew where
6242 * the string CP has been copied for at most the first LEN characters.
6245 savenstr (const char *cp
, int len
)
6249 dp
= xnew (len
+ 1, char);
6250 memcpy (dp
, cp
, len
);
6256 * Return the ptr in sp at which the character c last
6257 * appears; NULL if not found
6259 * Identical to POSIX strrchr, included for portability.
6262 etags_strrchr (register const char *sp
, register int c
)
6264 register const char *r
;
6276 * Return the ptr in sp at which the character c first
6277 * appears; NULL if not found
6279 * Identical to POSIX strchr, included for portability.
6282 etags_strchr (register const char *sp
, register int c
)
6292 /* Skip spaces (end of string is not space), return new pointer. */
6294 skip_spaces (char *cp
)
6296 while (iswhite (*cp
))
6301 /* Skip non spaces, except end of string, return new pointer. */
6303 skip_non_spaces (char *cp
)
6305 while (*cp
!= '\0' && !iswhite (*cp
))
6310 /* Print error message and exit. */
6312 fatal (const char *s1
, const char *s2
)
6315 exit (EXIT_FAILURE
);
6319 pfatal (const char *s1
)
6322 exit (EXIT_FAILURE
);
6326 suggest_asking_for_help (void)
6328 fprintf (stderr
, "\tTry `%s --help' for a complete list of options.\n",
6330 exit (EXIT_FAILURE
);
6333 /* Output a diagnostic with printf-style FORMAT and args. */
6335 error (const char *format
, ...)
6338 va_start (ap
, format
);
6339 fprintf (stderr
, "%s: ", progname
);
6340 vfprintf (stderr
, format
, ap
);
6341 fprintf (stderr
, "\n");
6345 /* Return a newly-allocated string whose contents
6346 concatenate those of s1, s2, s3. */
6348 concat (const char *s1
, const char *s2
, const char *s3
)
6350 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
6351 char *result
= xnew (len1
+ len2
+ len3
+ 1, char);
6353 strcpy (result
, s1
);
6354 strcpy (result
+ len1
, s2
);
6355 strcpy (result
+ len1
+ len2
, s3
);
6356 result
[len1
+ len2
+ len3
] = '\0';
6362 /* Does the same work as the system V getcwd, but does not need to
6363 guess the buffer size in advance. */
6368 char *path
= xnew (bufsize
, char);
6370 while (getcwd (path
, bufsize
) == NULL
)
6372 if (errno
!= ERANGE
)
6376 path
= xnew (bufsize
, char);
6379 canonicalize_filename (path
);
6383 /* Return a newly allocated string containing the file name of FILE
6384 relative to the absolute directory DIR (which should end with a slash). */
6386 relative_filename (char *file
, char *dir
)
6388 char *fp
, *dp
, *afn
, *res
;
6391 /* Find the common root of file and dir (with a trailing slash). */
6392 afn
= absolute_filename (file
, cwd
);
6395 while (*fp
++ == *dp
++)
6397 fp
--, dp
--; /* back to the first differing char */
6399 if (fp
== afn
&& afn
[0] != '/') /* cannot build a relative name */
6402 do /* look at the equal chars until '/' */
6406 /* Build a sequence of "../" strings for the resulting relative file name. */
6408 while ((dp
= etags_strchr (dp
+ 1, '/')) != NULL
)
6410 res
= xnew (3*i
+ strlen (fp
+ 1) + 1, char);
6413 strcat (res
, "../");
6415 /* Add the file name relative to the common root of file and dir. */
6416 strcat (res
, fp
+ 1);
6422 /* Return a newly allocated string containing the absolute file name
6423 of FILE given DIR (which should end with a slash). */
6425 absolute_filename (char *file
, char *dir
)
6427 char *slashp
, *cp
, *res
;
6429 if (filename_is_absolute (file
))
6430 res
= savestr (file
);
6432 /* We don't support non-absolute file names with a drive
6433 letter, like `d:NAME' (it's too much hassle). */
6434 else if (file
[1] == ':')
6435 fatal ("%s: relative file names with drive letters not supported", file
);
6438 res
= concat (dir
, file
, "");
6440 /* Delete the "/dirname/.." and "/." substrings. */
6441 slashp
= etags_strchr (res
, '/');
6442 while (slashp
!= NULL
&& slashp
[0] != '\0')
6444 if (slashp
[1] == '.')
6446 if (slashp
[2] == '.'
6447 && (slashp
[3] == '/' || slashp
[3] == '\0'))
6452 while (cp
>= res
&& !filename_is_absolute (cp
));
6454 cp
= slashp
; /* the absolute name begins with "/.." */
6456 /* Under MSDOS and NT we get `d:/NAME' as absolute
6457 file name, so the luser could say `d:/../NAME'.
6458 We silently treat this as `d:/NAME'. */
6459 else if (cp
[0] != '/')
6462 memmove (cp
, slashp
+ 3, strlen (slashp
+ 2));
6466 else if (slashp
[2] == '/' || slashp
[2] == '\0')
6468 memmove (slashp
, slashp
+ 2, strlen (slashp
+ 1));
6473 slashp
= etags_strchr (slashp
+ 1, '/');
6476 if (res
[0] == '\0') /* just a safety net: should never happen */
6479 return savestr ("/");
6485 /* Return a newly allocated string containing the absolute
6486 file name of dir where FILE resides given DIR (which should
6487 end with a slash). */
6489 absolute_dirname (char *file
, char *dir
)
6494 slashp
= etags_strrchr (file
, '/');
6496 return savestr (dir
);
6499 res
= absolute_filename (file
, dir
);
6505 /* Whether the argument string is an absolute file name. The argument
6506 string must have been canonicalized with canonicalize_filename. */
6508 filename_is_absolute (char *fn
)
6510 return (fn
[0] == '/'
6512 || (ISALPHA (fn
[0]) && fn
[1] == ':' && fn
[2] == '/')
6517 /* Downcase DOS drive letter and collapse separators into single slashes.
6520 canonicalize_filename (register char *fn
)
6526 /* Canonicalize drive letter case. */
6527 # define ISUPPER(c) isupper (CHAR (c))
6528 if (fn
[0] != '\0' && fn
[1] == ':' && ISUPPER (fn
[0]))
6529 fn
[0] = lowcase (fn
[0]);
6534 /* Collapse multiple separators into a single slash. */
6535 for (cp
= fn
; *cp
!= '\0'; cp
++, fn
++)
6539 while (cp
[1] == sep
)
6548 /* Initialize a linebuffer for use. */
6550 linebuffer_init (linebuffer
*lbp
)
6552 lbp
->size
= (DEBUG
) ? 3 : 200;
6553 lbp
->buffer
= xnew (lbp
->size
, char);
6554 lbp
->buffer
[0] = '\0';
6558 /* Set the minimum size of a string contained in a linebuffer. */
6560 linebuffer_setlen (linebuffer
*lbp
, int toksize
)
6562 while (lbp
->size
<= toksize
)
6565 xrnew (lbp
->buffer
, lbp
->size
, char);
6570 /* Like malloc but get fatal error if memory is exhausted. */
6572 xmalloc (size_t size
)
6574 void *result
= malloc (size
);
6576 fatal ("virtual memory exhausted", (char *)NULL
);
6581 xrealloc (char *ptr
, size_t size
)
6583 void *result
= realloc (ptr
, size
);
6585 fatal ("virtual memory exhausted", (char *)NULL
);
6591 * indent-tabs-mode: t
6594 * c-font-lock-extra-types: ("FILE" "bool" "language" "linebuffer" "fdesc" "node" "regexp")
6595 * c-file-style: "gnu"
6599 /* etags.c ends here */