1 /* Tags file maker to go with GNU Emacs -*- coding: latin-1 -*-
2 Copyright (C) 1984, 1987, 1988, 1989, 1993, 1994, 1995,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006 Free Software Foundation, Inc. and Ken Arnold
6 This file is not considered part of GNU Emacs.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software Foundation,
20 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
24 * Ctags originally by Ken Arnold.
25 * Fortran added by Jim Kleckner.
26 * Ed Pelegri-Llopart added C typedefs.
27 * Gnu Emacs TAGS format and modifications by RMS?
28 * 1989 Sam Kendall added C++.
29 * 1992 Joseph B. Wells improved C and C++ parsing.
30 * 1993 Francesco Potortì reorganised C and C++.
31 * 1994 Line-by-line regexp tags by Tom Tromey.
32 * 2001 Nested classes by Francesco Potortì (concept by Mykola Dzyuba).
33 * 2002 #line directives by Francesco Potortì.
35 * Francesco Potortì <pot@gnu.org> has maintained and improved it since 1993.
39 * If you want to add support for a new language, start by looking at the LUA
40 * language, which is the simplest. Alternatively, consider shipping a
41 * configuration file containing regexp definitions for etags.
44 char pot_etags_version
[] = "@(#) pot revision number is 17.18";
54 # define NDEBUG /* disable assert */
59 /* On some systems, Emacs defines static as nothing for the sake
60 of unexec. We don't want that here since we don't use unexec. */
62 # define ETAGS_REGEXPS /* use the regexp features */
63 # define LONG_OPTIONS /* accept long options */
64 # ifndef PTR /* for Xemacs */
67 # ifndef __P /* for Xemacs */
68 # define __P(args) args
70 #else /* no config.h */
71 # if defined(__STDC__) && (__STDC__ || defined(__SUNPRO_C))
72 # define __P(args) args /* use prototypes */
73 # define PTR void * /* for generic pointers */
74 # else /* not standard C */
75 # define __P(args) () /* no prototypes */
76 # define const /* remove const for old compilers' sake */
77 # define PTR long * /* don't use void* */
79 #endif /* !HAVE_CONFIG_H */
82 # define _GNU_SOURCE 1 /* enables some compiler checks on GNU */
87 # define LONG_OPTIONS TRUE
89 # define LONG_OPTIONS FALSE
92 /* WIN32_NATIVE is for Xemacs.
93 MSDOS, WINDOWSNT, DOS_NT are for Emacs. */
98 #endif /* WIN32_NATIVE */
104 # include <sys/param.h>
106 # ifndef HAVE_CONFIG_H
108 # include <sys/config.h>
120 # define MAXPATHLEN _MAX_PATH
126 # endif /* undef HAVE_GETCWD */
127 #else /* not WINDOWSNT */
131 # else /* no standard C headers */
132 extern char *getenv ();
134 # define EXIT_SUCCESS 1
135 # define EXIT_FAILURE 0
137 # define EXIT_SUCCESS 0
138 # define EXIT_FAILURE 1
141 #endif /* !WINDOWSNT */
146 # if defined (HAVE_GETCWD) && !defined (WINDOWSNT)
147 extern char *getcwd (char *buf
, size_t size
);
149 #endif /* HAVE_UNISTD_H */
157 #include <sys/types.h>
158 #include <sys/stat.h>
162 # undef assert /* some systems have a buggy assert.h */
163 # define assert(x) ((void) 0)
166 #if !defined (S_ISREG) && defined (S_IFREG)
167 # define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
173 # define getopt_long(argc,argv,optstr,lopts,lind) getopt (argc, argv, optstr)
175 extern int optind
, opterr
;
176 #endif /* LONG_OPTIONS */
179 # ifndef HAVE_CONFIG_H /* this is a standalone compilation */
180 # ifdef __CYGWIN__ /* compiling on Cygwin */
182 the regex
.h distributed with Cygwin is
not compatible with etags
, alas
!
183 If you want regular expression support
, you should
delete this notice
and
184 arrange to use the GNU regex
.h
and regex
.c
.
188 #endif /* ETAGS_REGEXPS */
190 /* Define CTAGS to make the program "ctags" compatible with the usual one.
191 Leave it undefined to make the program "etags", which makes emacs-style
192 tag tables and tags typedefs, #defines and struct/union/enum by default. */
200 #define streq(s,t) (assert((s)!=NULL || (t)!=NULL), !strcmp (s, t))
201 #define strcaseeq(s,t) (assert((s)!=NULL && (t)!=NULL), !etags_strcasecmp (s, t))
202 #define strneq(s,t,n) (assert((s)!=NULL || (t)!=NULL), !strncmp (s, t, n))
203 #define strncaseeq(s,t,n) (assert((s)!=NULL && (t)!=NULL), !etags_strncasecmp (s, t, n))
205 #define CHARS 256 /* 2^sizeof(char) */
206 #define CHAR(x) ((unsigned int)(x) & (CHARS - 1))
207 #define iswhite(c) (_wht[CHAR(c)]) /* c is white (see white) */
208 #define notinname(c) (_nin[CHAR(c)]) /* c is not in a name (see nonam) */
209 #define begtoken(c) (_btk[CHAR(c)]) /* c can start token (see begtk) */
210 #define intoken(c) (_itk[CHAR(c)]) /* c can be in token (see midtk) */
211 #define endtoken(c) (_etk[CHAR(c)]) /* c ends tokens (see endtk) */
213 #define ISALNUM(c) isalnum (CHAR(c))
214 #define ISALPHA(c) isalpha (CHAR(c))
215 #define ISDIGIT(c) isdigit (CHAR(c))
216 #define ISLOWER(c) islower (CHAR(c))
218 #define lowcase(c) tolower (CHAR(c))
219 #define upcase(c) toupper (CHAR(c))
223 * xnew, xrnew -- allocate, reallocate storage
225 * SYNOPSIS: Type *xnew (int n, Type);
226 * void xrnew (OldPointer, int n, Type);
229 # include "chkmalloc.h"
230 # define xnew(n,Type) ((Type *) trace_malloc (__FILE__, __LINE__, \
231 (n) * sizeof (Type)))
232 # define xrnew(op,n,Type) ((op) = (Type *) trace_realloc (__FILE__, __LINE__, \
233 (char *) (op), (n) * sizeof (Type)))
235 # define xnew(n,Type) ((Type *) xmalloc ((n) * sizeof (Type)))
236 # define xrnew(op,n,Type) ((op) = (Type *) xrealloc ( \
237 (char *) (op), (n) * sizeof (Type)))
242 typedef void Lang_function
__P((FILE *));
246 char *suffix
; /* file name suffix for this compressor */
247 char *command
; /* takes one arg and decompresses to stdout */
252 char *name
; /* language name */
253 char *help
; /* detailed help for the language */
254 Lang_function
*function
; /* parse function */
255 char **suffixes
; /* name suffixes of this language's files */
256 char **filenames
; /* names of this language's files */
257 char **interpreters
; /* interpreters for this language */
258 bool metasource
; /* source used to generate other sources */
263 struct fdesc
*next
; /* for the linked list */
264 char *infname
; /* uncompressed input file name */
265 char *infabsname
; /* absolute uncompressed input file name */
266 char *infabsdir
; /* absolute dir of input file */
267 char *taggedfname
; /* file name to write in tagfile */
268 language
*lang
; /* language of file */
269 char *prop
; /* file properties to write in tagfile */
270 bool usecharno
; /* etags tags shall contain char number */
271 bool written
; /* entry written in the tags file */
274 typedef struct node_st
275 { /* sorting structure */
276 struct node_st
*left
, *right
; /* left and right sons */
277 fdesc
*fdp
; /* description of file to whom tag belongs */
278 char *name
; /* tag name */
279 char *regex
; /* search regexp */
280 bool valid
; /* write this tag on the tag file */
281 bool is_func
; /* function tag: use regexp in CTAGS mode */
282 bool been_warned
; /* warning already given for duplicated tag */
283 int lno
; /* line number tag is on */
284 long cno
; /* character number line starts on */
288 * A `linebuffer' is a structure which holds a line of text.
289 * `readline_internal' reads a line from a stream into a linebuffer
290 * and works regardless of the length of the line.
291 * SIZE is the size of BUFFER, LEN is the length of the string in
292 * BUFFER after readline reads it.
301 /* Used to support mixing of --lang and file names. */
305 at_language
, /* a language specification */
306 at_regexp
, /* a regular expression */
307 at_filename
, /* a file name */
308 at_stdin
, /* read from stdin here */
309 at_end
/* stop parsing the list */
310 } arg_type
; /* argument type */
311 language
*lang
; /* language associated with the argument */
312 char *what
; /* the argument itself */
316 /* Structure defining a regular expression. */
317 typedef struct regexp
319 struct regexp
*p_next
; /* pointer to next in list */
320 language
*lang
; /* if set, use only for this language */
321 char *pattern
; /* the regexp pattern */
322 char *name
; /* tag name */
323 struct re_pattern_buffer
*pat
; /* the compiled pattern */
324 struct re_registers regs
; /* re registers */
325 bool error_signaled
; /* already signaled for this regexp */
326 bool force_explicit_name
; /* do not allow implict tag name */
327 bool ignore_case
; /* ignore case when matching */
328 bool multi_line
; /* do a multi-line match on the whole file */
330 #endif /* ETAGS_REGEXPS */
333 /* Many compilers barf on this:
334 Lang_function Ada_funcs;
335 so let's write it this way */
336 static void Ada_funcs
__P((FILE *));
337 static void Asm_labels
__P((FILE *));
338 static void C_entries
__P((int c_ext
, FILE *));
339 static void default_C_entries
__P((FILE *));
340 static void plain_C_entries
__P((FILE *));
341 static void Cjava_entries
__P((FILE *));
342 static void Cobol_paragraphs
__P((FILE *));
343 static void Cplusplus_entries
__P((FILE *));
344 static void Cstar_entries
__P((FILE *));
345 static void Erlang_functions
__P((FILE *));
346 static void Forth_words
__P((FILE *));
347 static void Fortran_functions
__P((FILE *));
348 static void HTML_labels
__P((FILE *));
349 static void Lisp_functions
__P((FILE *));
350 static void Lua_functions
__P((FILE *));
351 static void Makefile_targets
__P((FILE *));
352 static void Pascal_functions
__P((FILE *));
353 static void Perl_functions
__P((FILE *));
354 static void PHP_functions
__P((FILE *));
355 static void PS_functions
__P((FILE *));
356 static void Prolog_functions
__P((FILE *));
357 static void Python_functions
__P((FILE *));
358 static void Scheme_functions
__P((FILE *));
359 static void TeX_commands
__P((FILE *));
360 static void Texinfo_nodes
__P((FILE *));
361 static void Yacc_entries
__P((FILE *));
362 static void just_read_file
__P((FILE *));
364 static void print_language_names
__P((void));
365 static void print_version
__P((void));
366 static void print_help
__P((argument
*));
367 int main
__P((int, char **));
369 static compressor
*get_compressor_from_suffix
__P((char *, char **));
370 static language
*get_language_from_langname
__P((const char *));
371 static language
*get_language_from_interpreter
__P((char *));
372 static language
*get_language_from_filename
__P((char *, bool));
373 static void readline
__P((linebuffer
*, FILE *));
374 static long readline_internal
__P((linebuffer
*, FILE *));
375 static bool nocase_tail
__P((char *));
376 static void get_tag
__P((char *, char **));
379 static void analyse_regex
__P((char *));
380 static void free_regexps
__P((void));
381 static void regex_tag_multiline
__P((void));
382 #endif /* ETAGS_REGEXPS */
383 static void error
__P((const char *, const char *));
384 static void suggest_asking_for_help
__P((void));
385 void fatal
__P((char *, char *));
386 static void pfatal
__P((char *));
387 static void add_node
__P((node
*, node
**));
389 static void init
__P((void));
390 static void process_file_name
__P((char *, language
*));
391 static void process_file
__P((FILE *, char *, language
*));
392 static void find_entries
__P((FILE *));
393 static void free_tree
__P((node
*));
394 static void free_fdesc
__P((fdesc
*));
395 static void pfnote
__P((char *, bool, char *, int, int, long));
396 static void make_tag
__P((char *, int, bool, char *, int, int, long));
397 static void invalidate_nodes
__P((fdesc
*, node
**));
398 static void put_entries
__P((node
*));
400 static char *concat
__P((char *, char *, char *));
401 static char *skip_spaces
__P((char *));
402 static char *skip_non_spaces
__P((char *));
403 static char *savenstr
__P((char *, int));
404 static char *savestr
__P((char *));
405 static char *etags_strchr
__P((const char *, int));
406 static char *etags_strrchr
__P((const char *, int));
407 static int etags_strcasecmp
__P((const char *, const char *));
408 static int etags_strncasecmp
__P((const char *, const char *, int));
409 static char *etags_getcwd
__P((void));
410 static char *relative_filename
__P((char *, char *));
411 static char *absolute_filename
__P((char *, char *));
412 static char *absolute_dirname
__P((char *, char *));
413 static bool filename_is_absolute
__P((char *f
));
414 static void canonicalize_filename
__P((char *));
415 static void linebuffer_init
__P((linebuffer
*));
416 static void linebuffer_setlen
__P((linebuffer
*, int));
417 static PTR xmalloc
__P((unsigned int));
418 static PTR xrealloc
__P((char *, unsigned int));
421 static char searchar
= '/'; /* use /.../ searches */
423 static char *tagfile
; /* output file */
424 static char *progname
; /* name this program was invoked with */
425 static char *cwd
; /* current working directory */
426 static char *tagfiledir
; /* directory of tagfile */
427 static FILE *tagf
; /* ioptr for tags file */
429 static fdesc
*fdhead
; /* head of file description list */
430 static fdesc
*curfdp
; /* current file description */
431 static int lineno
; /* line number of current line */
432 static long charno
; /* current character number */
433 static long linecharno
; /* charno of start of current line */
434 static char *dbp
; /* pointer to start of current tag */
436 static const int invalidcharno
= -1;
438 static node
*nodehead
; /* the head of the binary tree of tags */
439 static node
*last_node
; /* the last node created */
441 static linebuffer lb
; /* the current line */
442 static linebuffer filebuf
; /* a buffer containing the whole file */
443 static linebuffer token_name
; /* a buffer containing a tag name */
445 /* boolean "functions" (see init) */
446 static bool _wht
[CHARS
], _nin
[CHARS
], _itk
[CHARS
], _btk
[CHARS
], _etk
[CHARS
];
449 *white
= " \f\t\n\r\v",
451 *nonam
= " \f\t\n\r()=,;", /* look at make_tag before modifying! */
452 /* token ending chars */
453 *endtk
= " \t\n\r\"'#()[]{}=-+%*/&|^~!<>;,.:?",
454 /* token starting chars */
455 *begtk
= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$~@",
456 /* valid in-token chars */
457 *midtk
= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$0123456789";
459 static bool append_to_tagfile
; /* -a: append to tags */
460 /* The next four default to TRUE for etags, but to FALSE for ctags. */
461 static bool typedefs
; /* -t: create tags for C and Ada typedefs */
462 static bool typedefs_or_cplusplus
; /* -T: create tags for C typedefs, level */
463 /* 0 struct/enum/union decls, and C++ */
464 /* member functions. */
465 static bool constantypedefs
; /* -d: create tags for C #define, enum */
466 /* constants and variables. */
467 /* -D: opposite of -d. Default under ctags. */
468 static bool globals
; /* create tags for global variables */
469 static bool declarations
; /* --declarations: tag them and extern in C&Co*/
470 static bool members
; /* create tags for C member variables */
471 static bool no_line_directive
; /* ignore #line directives (undocumented) */
472 static bool update
; /* -u: update tags */
473 static bool vgrind_style
; /* -v: create vgrind style index output */
474 static bool no_warnings
; /* -w: suppress warnings */
475 static bool cxref_style
; /* -x: create cxref style output */
476 static bool cplusplus
; /* .[hc] means C++, not C */
477 static bool ignoreindent
; /* -I: ignore indentation in C */
478 static bool packages_only
; /* --packages-only: in Ada, only tag packages*/
480 /* STDIN is defined in LynxOS system headers */
485 #define STDIN 0x1001 /* returned by getopt_long on --parse-stdin */
486 static bool parsing_stdin
; /* --parse-stdin used */
489 static regexp
*p_head
; /* list of all regexps */
490 static bool need_filebuf
; /* some regexes are multi-line */
492 # define need_filebuf FALSE
493 #endif /* ETAGS_REGEXPS */
496 static struct option longopts
[] =
498 { "append", no_argument
, NULL
, 'a' },
499 { "packages-only", no_argument
, &packages_only
, TRUE
},
500 { "c++", no_argument
, NULL
, 'C' },
501 { "declarations", no_argument
, &declarations
, TRUE
},
502 { "no-line-directive", no_argument
, &no_line_directive
, TRUE
},
503 { "help", no_argument
, NULL
, 'h' },
504 { "help", no_argument
, NULL
, 'H' },
505 { "ignore-indentation", no_argument
, NULL
, 'I' },
506 { "language", required_argument
, NULL
, 'l' },
507 { "members", no_argument
, &members
, TRUE
},
508 { "no-members", no_argument
, &members
, FALSE
},
509 { "output", required_argument
, NULL
, 'o' },
511 { "regex", required_argument
, NULL
, 'r' },
512 { "no-regex", no_argument
, NULL
, 'R' },
513 { "ignore-case-regex", required_argument
, NULL
, 'c' },
514 #endif /* ETAGS_REGEXPS */
515 { "parse-stdin", required_argument
, NULL
, STDIN
},
516 { "version", no_argument
, NULL
, 'V' },
518 #if CTAGS /* Ctags options */
519 { "backward-search", no_argument
, NULL
, 'B' },
520 { "cxref", no_argument
, NULL
, 'x' },
521 { "defines", no_argument
, NULL
, 'd' },
522 { "globals", no_argument
, &globals
, TRUE
},
523 { "typedefs", no_argument
, NULL
, 't' },
524 { "typedefs-and-c++", no_argument
, NULL
, 'T' },
525 { "update", no_argument
, NULL
, 'u' },
526 { "vgrind", no_argument
, NULL
, 'v' },
527 { "no-warn", no_argument
, NULL
, 'w' },
529 #else /* Etags options */
530 { "no-defines", no_argument
, NULL
, 'D' },
531 { "no-globals", no_argument
, &globals
, FALSE
},
532 { "include", required_argument
, NULL
, 'i' },
536 #endif /* LONG_OPTIONS */
538 static compressor compressors
[] =
540 { "z", "gzip -d -c"},
541 { "Z", "gzip -d -c"},
542 { "gz", "gzip -d -c"},
543 { "GZ", "gzip -d -c"},
544 { "bz2", "bzip2 -d -c" },
553 static char *Ada_suffixes
[] =
554 { "ads", "adb", "ada", NULL
};
555 static char Ada_help
[] =
556 "In Ada code, functions, procedures, packages, tasks and types are\n\
557 tags. Use the `--packages-only' option to create tags for\n\
559 Ada tag names have suffixes indicating the type of entity:\n\
560 Entity type: Qualifier:\n\
561 ------------ ----------\n\
568 Thus, `M-x find-tag <RET> bidule/b <RET>' will go directly to the\n\
569 body of the package `bidule', while `M-x find-tag <RET> bidule <RET>'\n\
570 will just search for any tag `bidule'.";
573 static char *Asm_suffixes
[] =
574 { "a", /* Unix assembler */
575 "asm", /* Microcontroller assembly */
576 "def", /* BSO/Tasking definition includes */
577 "inc", /* Microcontroller include files */
578 "ins", /* Microcontroller include files */
579 "s", "sa", /* Unix assembler */
580 "S", /* cpp-processed Unix assembler */
581 "src", /* BSO/Tasking C compiler output */
584 static char Asm_help
[] =
585 "In assembler code, labels appearing at the beginning of a line,\n\
586 followed by a colon, are tags.";
589 /* Note that .c and .h can be considered C++, if the --c++ flag was
590 given, or if the `class' or `template' keyowrds are met inside the file.
591 That is why default_C_entries is called for these. */
592 static char *default_C_suffixes
[] =
594 static char default_C_help
[] =
595 "In C code, any C function or typedef is a tag, and so are\n\
596 definitions of `struct', `union' and `enum'. `#define' macro\n\
597 definitions and `enum' constants are tags unless you specify\n\
598 `--no-defines'. Global variables are tags unless you specify\n\
599 `--no-globals'. Use of `--no-globals' and `--no-defines'\n\
600 can make the tags table file much smaller.\n\
601 You can tag function declarations and external variables by\n\
602 using `--declarations', and struct members by using `--members'.";
604 static char *Cplusplus_suffixes
[] =
605 { "C", "c++", "cc", "cpp", "cxx", "H", "h++", "hh", "hpp", "hxx",
606 "M", /* Objective C++ */
607 "pdb", /* Postscript with C syntax */
609 static char Cplusplus_help
[] =
610 "In C++ code, all the tag constructs of C code are tagged. (Use\n\
611 --help --lang=c --lang=c++ for full help.)\n\
612 In addition to C tags, member functions are also recognized, and\n\
613 optionally member variables if you use the `--members' option.\n\
614 Tags for variables and functions in classes are named `CLASS::VARIABLE'\n\
615 and `CLASS::FUNCTION'. `operator' definitions have tag names like\n\
618 static char *Cjava_suffixes
[] =
620 static char Cjava_help
[] =
621 "In Java code, all the tags constructs of C and C++ code are\n\
622 tagged. (Use --help --lang=c --lang=c++ --lang=java for full help.)";
625 static char *Cobol_suffixes
[] =
626 { "COB", "cob", NULL
};
627 static char Cobol_help
[] =
628 "In Cobol code, tags are paragraph names; that is, any word\n\
629 starting in column 8 and followed by a period.";
631 static char *Cstar_suffixes
[] =
632 { "cs", "hs", NULL
};
634 static char *Erlang_suffixes
[] =
635 { "erl", "hrl", NULL
};
636 static char Erlang_help
[] =
637 "In Erlang code, the tags are the functions, records and macros\n\
638 defined in the file.";
640 char *Forth_suffixes
[] =
641 { "fth", "tok", NULL
};
642 static char Forth_help
[] =
643 "In Forth code, tags are words defined by `:',\n\
644 constant, code, create, defer, value, variable, buffer:, field.";
646 static char *Fortran_suffixes
[] =
647 { "F", "f", "f90", "for", NULL
};
648 static char Fortran_help
[] =
649 "In Fortran code, functions, subroutines and block data are tags.";
651 static char *HTML_suffixes
[] =
652 { "htm", "html", "shtml", NULL
};
653 static char HTML_help
[] =
654 "In HTML input files, the tags are the `title' and the `h1', `h2',\n\
655 `h3' headers. Also, tags are `name=' in anchors and all\n\
656 occurrences of `id='.";
658 static char *Lisp_suffixes
[] =
659 { "cl", "clisp", "el", "l", "lisp", "LSP", "lsp", "ml", NULL
};
660 static char Lisp_help
[] =
661 "In Lisp code, any function defined with `defun', any variable\n\
662 defined with `defvar' or `defconst', and in general the first\n\
663 argument of any expression that starts with `(def' in column zero\n\
666 static char *Lua_suffixes
[] =
667 { "lua", "LUA", NULL
};
668 static char Lua_help
[] =
669 "In Lua scripts, all functions are tags.";
671 static char *Makefile_filenames
[] =
672 { "Makefile", "makefile", "GNUMakefile", "Makefile.in", "Makefile.am", NULL
};
673 static char Makefile_help
[] =
674 "In makefiles, targets are tags; additionally, variables are tags\n\
675 unless you specify `--no-globals'.";
677 static char *Objc_suffixes
[] =
678 { "lm", /* Objective lex file */
679 "m", /* Objective C file */
681 static char Objc_help
[] =
682 "In Objective C code, tags include Objective C definitions for classes,\n\
683 class categories, methods and protocols. Tags for variables and\n\
684 functions in classes are named `CLASS::VARIABLE' and `CLASS::FUNCTION'.";
686 static char *Pascal_suffixes
[] =
687 { "p", "pas", NULL
};
688 static char Pascal_help
[] =
689 "In Pascal code, the tags are the functions and procedures defined\n\
692 static char *Perl_suffixes
[] =
693 { "pl", "pm", NULL
};
694 static char *Perl_interpreters
[] =
695 { "perl", "@PERL@", NULL
};
696 static char Perl_help
[] =
697 "In Perl code, the tags are the packages, subroutines and variables\n\
698 defined by the `package', `sub', `my' and `local' keywords. Use\n\
699 `--globals' if you want to tag global variables. Tags for\n\
700 subroutines are named `PACKAGE::SUB'. The name for subroutines\n\
701 defined in the default package is `main::SUB'.";
703 static char *PHP_suffixes
[] =
704 { "php", "php3", "php4", NULL
};
705 static char PHP_help
[] =
706 "In PHP code, tags are functions, classes and defines. When using\n\
707 the `--members' option, vars are tags too.";
709 static char *plain_C_suffixes
[] =
710 { "pc", /* Pro*C file */
713 static char *PS_suffixes
[] =
714 { "ps", "psw", NULL
}; /* .psw is for PSWrap */
715 static char PS_help
[] =
716 "In PostScript code, the tags are the functions.";
718 static char *Prolog_suffixes
[] =
720 static char Prolog_help
[] =
721 "In Prolog code, tags are predicates and rules at the beginning of\n\
724 static char *Python_suffixes
[] =
726 static char Python_help
[] =
727 "In Python code, `def' or `class' at the beginning of a line\n\
730 /* Can't do the `SCM' or `scm' prefix with a version number. */
731 static char *Scheme_suffixes
[] =
732 { "oak", "sch", "scheme", "SCM", "scm", "SM", "sm", "ss", "t", NULL
};
733 static char Scheme_help
[] =
734 "In Scheme code, tags include anything defined with `def' or with a\n\
735 construct whose name starts with `def'. They also include\n\
736 variables set with `set!' at top level in the file.";
738 static char *TeX_suffixes
[] =
739 { "bib", "clo", "cls", "ltx", "sty", "TeX", "tex", NULL
};
740 static char TeX_help
[] =
741 "In LaTeX text, the argument of any of the commands `\\chapter',\n\
742 `\\section', `\\subsection', `\\subsubsection', `\\eqno', `\\label',\n\
743 `\\ref', `\\cite', `\\bibitem', `\\part', `\\appendix', `\\entry',\n\
744 `\\index', `\\def', `\\newcommand', `\\renewcommand',\n\
745 `\\newenvironment' or `\\renewenvironment' is a tag.\n\
747 Other commands can be specified by setting the environment variable\n\
748 `TEXTAGS' to a colon-separated list like, for example,\n\
749 TEXTAGS=\"mycommand:myothercommand\".";
752 static char *Texinfo_suffixes
[] =
753 { "texi", "texinfo", "txi", NULL
};
754 static char Texinfo_help
[] =
755 "for texinfo files, lines starting with @node are tagged.";
757 static char *Yacc_suffixes
[] =
758 { "y", "y++", "ym", "yxx", "yy", NULL
}; /* .ym is Objective yacc file */
759 static char Yacc_help
[] =
760 "In Bison or Yacc input files, each rule defines as a tag the\n\
761 nonterminal it constructs. The portions of the file that contain\n\
762 C code are parsed as C code (use --help --lang=c --lang=yacc\n\
765 static char auto_help
[] =
766 "`auto' is not a real language, it indicates to use\n\
767 a default language for files base on file name suffix and file contents.";
769 static char none_help
[] =
770 "`none' is not a real language, it indicates to only do\n\
771 regexp processing on files.";
773 static char no_lang_help
[] =
774 "No detailed help available for this language.";
778 * Table of languages.
780 * It is ok for a given function to be listed under more than one
781 * name. I just didn't.
784 static language lang_names
[] =
786 { "ada", Ada_help
, Ada_funcs
, Ada_suffixes
},
787 { "asm", Asm_help
, Asm_labels
, Asm_suffixes
},
788 { "c", default_C_help
, default_C_entries
, default_C_suffixes
},
789 { "c++", Cplusplus_help
, Cplusplus_entries
, Cplusplus_suffixes
},
790 { "c*", no_lang_help
, Cstar_entries
, Cstar_suffixes
},
791 { "cobol", Cobol_help
, Cobol_paragraphs
, Cobol_suffixes
},
792 { "erlang", Erlang_help
, Erlang_functions
, Erlang_suffixes
},
793 { "forth", Forth_help
, Forth_words
, Forth_suffixes
},
794 { "fortran", Fortran_help
, Fortran_functions
, Fortran_suffixes
},
795 { "html", HTML_help
, HTML_labels
, HTML_suffixes
},
796 { "java", Cjava_help
, Cjava_entries
, Cjava_suffixes
},
797 { "lisp", Lisp_help
, Lisp_functions
, Lisp_suffixes
},
798 { "lua", Lua_help
, Lua_functions
, Lua_suffixes
},
799 { "makefile", Makefile_help
,Makefile_targets
,NULL
,Makefile_filenames
},
800 { "objc", Objc_help
, plain_C_entries
, Objc_suffixes
},
801 { "pascal", Pascal_help
, Pascal_functions
, Pascal_suffixes
},
802 { "perl",Perl_help
,Perl_functions
,Perl_suffixes
,NULL
,Perl_interpreters
},
803 { "php", PHP_help
, PHP_functions
, PHP_suffixes
},
804 { "postscript",PS_help
, PS_functions
, PS_suffixes
},
805 { "proc", no_lang_help
, plain_C_entries
, plain_C_suffixes
},
806 { "prolog", Prolog_help
, Prolog_functions
, Prolog_suffixes
},
807 { "python", Python_help
, Python_functions
, Python_suffixes
},
808 { "scheme", Scheme_help
, Scheme_functions
, Scheme_suffixes
},
809 { "tex", TeX_help
, TeX_commands
, TeX_suffixes
},
810 { "texinfo", Texinfo_help
, Texinfo_nodes
, Texinfo_suffixes
},
811 { "yacc", Yacc_help
,Yacc_entries
,Yacc_suffixes
,NULL
,NULL
,TRUE
},
812 { "auto", auto_help
}, /* default guessing scheme */
813 { "none", none_help
, just_read_file
}, /* regexp matching only */
814 { NULL
} /* end of list */
819 print_language_names ()
824 puts ("\nThese are the currently supported languages, along with the\n\
825 default file names and dot suffixes:");
826 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
828 printf (" %-*s", 10, lang
->name
);
829 if (lang
->filenames
!= NULL
)
830 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
831 printf (" %s", *name
);
832 if (lang
->suffixes
!= NULL
)
833 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
834 printf (" .%s", *ext
);
837 puts ("where `auto' means use default language for files based on file\n\
838 name suffix, and `none' means only do regexp processing on files.\n\
839 If no language is specified and no matching suffix is found,\n\
840 the first line of the file is read for a sharp-bang (#!) sequence\n\
841 followed by the name of an interpreter. If no such sequence is found,\n\
842 Fortran is tried first; if no tags are found, C is tried next.\n\
843 When parsing any C file, a \"class\" or \"template\" keyword\n\
845 puts ("Compressed files are supported using gzip and bzip2.\n\
847 For detailed help on a given language use, for example,\n\
848 etags --help --lang=ada.");
852 # define EMACS_NAME "standalone"
855 # define VERSION "version"
860 printf ("%s (%s %s)\n", (CTAGS
) ? "ctags" : "etags", EMACS_NAME
, VERSION
);
861 puts ("Copyright (C) 2006 Free Software Foundation, Inc. and Ken Arnold");
862 puts ("This program is distributed under the same terms as Emacs");
868 print_help (argbuffer
)
871 bool help_for_lang
= FALSE
;
873 for (; argbuffer
->arg_type
!= at_end
; argbuffer
++)
874 if (argbuffer
->arg_type
== at_language
)
878 puts (argbuffer
->lang
->help
);
879 help_for_lang
= TRUE
;
885 printf ("Usage: %s [options] [[regex-option ...] file-name] ...\n\
887 These are the options accepted by %s.\n", progname
, progname
);
889 puts ("You may use unambiguous abbreviations for the long option names.");
891 puts ("Long option names do not work with this executable, as it is not\n\
892 linked with GNU getopt.");
893 puts (" A - as file name means read names from stdin (one per line).\n\
894 Absolute names are stored in the output file as they are.\n\
895 Relative ones are stored relative to the output file's directory.\n");
897 puts ("-a, --append\n\
898 Append tag entries to existing tags file.");
900 puts ("--packages-only\n\
901 For Ada files, only generate tags for packages.");
904 puts ("-B, --backward-search\n\
905 Write the search commands for the tag entries using '?', the\n\
906 backward-search command instead of '/', the forward-search command.");
908 /* This option is mostly obsolete, because etags can now automatically
909 detect C++. Retained for backward compatibility and for debugging and
910 experimentation. In principle, we could want to tag as C++ even
911 before any "class" or "template" keyword.
913 Treat files whose name suffix defaults to C language as C++ files.");
916 puts ("--declarations\n\
917 In C and derived languages, create tags for function declarations,");
919 puts ("\tand create tags for extern variables if --globals is used.");
922 ("\tand create tags for extern variables unless --no-globals is used.");
925 puts ("-d, --defines\n\
926 Create tag entries for C #define constants and enum constants, too.");
928 puts ("-D, --no-defines\n\
929 Don't create tag entries for C #define constants and enum constants.\n\
930 This makes the tags file smaller.");
933 puts ("-i FILE, --include=FILE\n\
934 Include a note in tag file indicating that, when searching for\n\
935 a tag, one should also consult the tags file FILE after\n\
936 checking the current file.");
938 puts ("-l LANG, --language=LANG\n\
939 Force the following files to be considered as written in the\n\
940 named language up to the next --language=LANG option.");
944 Create tag entries for global variables in some languages.");
946 puts ("--no-globals\n\
947 Do not create tag entries for global variables in some\n\
948 languages. This makes the tags file smaller.");
950 Create tag entries for members of structures in some languages.");
953 puts ("-r REGEXP, --regex=REGEXP or --regex=@regexfile\n\
954 Make a tag for each line matching a regular expression pattern\n\
955 in the following files. {LANGUAGE}REGEXP uses REGEXP for LANGUAGE\n\
956 files only. REGEXFILE is a file containing one REGEXP per line.\n\
957 REGEXP takes the form /TAGREGEXP/TAGNAME/MODS, where TAGNAME/ is\n\
958 optional. The TAGREGEXP pattern is anchored (as if preceded by ^).");
959 puts (" If TAGNAME/ is present, the tags created are named.\n\
960 For example Tcl named tags can be created with:\n\
961 --regex=\"/proc[ \\t]+\\([^ \\t]+\\)/\\1/.\".\n\
962 MODS are optional one-letter modifiers: `i' means to ignore case,\n\
963 `m' means to allow multi-line matches, `s' implies `m' and\n\
964 causes dot to match any character, including newline.");
965 puts ("-R, --no-regex\n\
966 Don't create tags from regexps for the following files.");
967 #endif /* ETAGS_REGEXPS */
968 puts ("-I, --ignore-indentation\n\
969 In C and C++ do not assume that a closing brace in the first\n\
970 column is the final brace of a function or structure definition.");
971 puts ("-o FILE, --output=FILE\n\
972 Write the tags to FILE.");
973 puts ("--parse-stdin=NAME\n\
974 Read from standard input and record tags as belonging to file NAME.");
978 puts ("-t, --typedefs\n\
979 Generate tag entries for C and Ada typedefs.");
980 puts ("-T, --typedefs-and-c++\n\
981 Generate tag entries for C typedefs, C struct/enum/union tags,\n\
982 and C++ member functions.");
986 puts ("-u, --update\n\
987 Update the tag entries for the given files, leaving tag\n\
988 entries for other files in place. Currently, this is\n\
989 implemented by deleting the existing entries for the given\n\
990 files and then rewriting the new entries at the end of the\n\
991 tags file. It is often faster to simply rebuild the entire\n\
992 tag file than to use this.");
996 puts ("-v, --vgrind\n\
997 Print on the standard output an index of items intended for\n\
998 human consumption, similar to the output of vgrind. The index\n\
999 is sorted, and gives the page number of each item.");
1000 puts ("-w, --no-warn\n\
1001 Suppress warning messages about entries defined in multiple\n\
1003 puts ("-x, --cxref\n\
1004 Like --vgrind, but in the style of cxref, rather than vgrind.\n\
1005 The output uses line numbers instead of page numbers, but\n\
1006 beyond that the differences are cosmetic; try both to see\n\
1010 puts ("-V, --version\n\
1011 Print the version of the program.\n\
1013 Print this help message.\n\
1014 Followed by one or more `--language' options prints detailed\n\
1015 help about tag generation for the specified languages.");
1017 print_language_names ();
1020 puts ("Report bugs to bug-gnu-emacs@gnu.org");
1022 exit (EXIT_SUCCESS
);
1026 #ifdef VMS /* VMS specific functions */
1030 /* This is a BUG! ANY arbitrary limit is a BUG!
1031 Won't someone please fix this? */
1032 #define MAX_FILE_SPEC_LEN 255
1035 char body
[MAX_FILE_SPEC_LEN
+ 1];
1039 v1.05 nmm 26-Jun-86 fn_exp - expand specification of list of file names
1040 returning in each successive call the next file name matching the input
1041 spec. The function expects that each in_spec passed
1042 to it will be processed to completion; in particular, up to and
1043 including the call following that in which the last matching name
1044 is returned, the function ignores the value of in_spec, and will
1045 only start processing a new spec with the following call.
1046 If an error occurs, on return out_spec contains the value
1047 of in_spec when the error occurred.
1049 With each successive file name returned in out_spec, the
1050 function's return value is one. When there are no more matching
1051 names the function returns zero. If on the first call no file
1052 matches in_spec, or there is any other error, -1 is returned.
1056 #include <descrip.h>
1057 #define OUTSIZE MAX_FILE_SPEC_LEN
1063 static long context
= 0;
1064 static struct dsc$descriptor_s o
;
1065 static struct dsc$descriptor_s i
;
1066 static bool pass1
= TRUE
;
1073 o
.dsc$a_pointer
= (char *) out
;
1074 o
.dsc$w_length
= (short)OUTSIZE
;
1075 i
.dsc$a_pointer
= in
;
1076 i
.dsc$w_length
= (short)strlen(in
);
1077 i
.dsc$b_dtype
= DSC$K_DTYPE_T
;
1078 i
.dsc$b_class
= DSC$K_CLASS_S
;
1079 o
.dsc$b_dtype
= DSC$K_DTYPE_VT
;
1080 o
.dsc$b_class
= DSC$K_CLASS_VS
;
1082 if ((status
= lib$
find_file(&i
, &o
, &context
, 0, 0)) == RMS$_NORMAL
)
1084 out
->body
[out
->curlen
] = EOS
;
1087 else if (status
== RMS$_NMF
)
1091 strcpy(out
->body
, in
);
1094 lib$
find_file_end(&context
);
1100 v1.01 nmm 19-Aug-85 gfnames - return in successive calls the
1101 name of each file specified by the provided arg expanding wildcards.
1104 gfnames (arg
, p_error
)
1108 static vspec filename
= {MAX_FILE_SPEC_LEN
, "\0"};
1110 switch (fn_exp (&filename
, arg
))
1114 return filename
.body
;
1120 return filename
.body
;
1124 #ifndef OLD /* Newer versions of VMS do provide `system'. */
1128 error ("%s", "system() function not implemented under VMS");
1132 #define VERSION_DELIM ';'
1133 char *massage_name (s
)
1139 if (*s
== VERSION_DELIM
)
1157 unsigned int nincluded_files
;
1158 char **included_files
;
1159 argument
*argbuffer
;
1160 int current_arg
, file_count
;
1161 linebuffer filename_lb
;
1162 bool help_asked
= FALSE
;
1171 _fmode
= O_BINARY
; /* all of files are treated as binary files */
1175 nincluded_files
= 0;
1176 included_files
= xnew (argc
, char *);
1180 /* Allocate enough no matter what happens. Overkill, but each one
1182 argbuffer
= xnew (argc
, argument
);
1185 * If etags, always find typedefs and structure tags. Why not?
1186 * Also default to find macro constants, enum constants and
1191 typedefs
= typedefs_or_cplusplus
= constantypedefs
= TRUE
;
1195 /* When the optstring begins with a '-' getopt_long does not rearrange the
1196 non-options arguments to be at the end, but leaves them alone. */
1198 #ifdef ETAGS_REGEXPS
1199 optstring
= "-r:Rc:";
1200 #endif /* ETAGS_REGEXPS */
1202 optstring
+= 1; /* remove the initial '-' */
1203 optstring
= concat (optstring
,
1205 (CTAGS
) ? "BxdtTuvw" : "Di:");
1207 while ((opt
= getopt_long (argc
, argv
, optstring
, longopts
, NULL
)) != EOF
)
1211 /* If getopt returns 0, then it has already processed a
1212 long-named option. We should do nothing. */
1216 /* This means that a file name has been seen. Record it. */
1217 argbuffer
[current_arg
].arg_type
= at_filename
;
1218 argbuffer
[current_arg
].what
= optarg
;
1224 /* Parse standard input. Idea by Vivek <vivek@etla.org>. */
1225 argbuffer
[current_arg
].arg_type
= at_stdin
;
1226 argbuffer
[current_arg
].what
= optarg
;
1230 fatal ("cannot parse standard input more than once", (char *)NULL
);
1231 parsing_stdin
= TRUE
;
1234 /* Common options. */
1235 case 'a': append_to_tagfile
= TRUE
; break;
1236 case 'C': cplusplus
= TRUE
; break;
1237 case 'f': /* for compatibility with old makefiles */
1241 error ("-o option may only be given once.", (char *)NULL
);
1242 suggest_asking_for_help ();
1248 case 'S': /* for backward compatibility */
1249 ignoreindent
= TRUE
;
1253 language
*lang
= get_language_from_langname (optarg
);
1256 argbuffer
[current_arg
].lang
= lang
;
1257 argbuffer
[current_arg
].arg_type
= at_language
;
1263 /* Backward compatibility: support obsolete --ignore-case-regexp. */
1264 optarg
= concat (optarg
, "i", ""); /* memory leak here */
1267 argbuffer
[current_arg
].arg_type
= at_regexp
;
1268 argbuffer
[current_arg
].what
= optarg
;
1272 argbuffer
[current_arg
].arg_type
= at_regexp
;
1273 argbuffer
[current_arg
].what
= NULL
;
1285 case 'D': constantypedefs
= FALSE
; break;
1286 case 'i': included_files
[nincluded_files
++] = optarg
; break;
1288 /* Ctags options. */
1289 case 'B': searchar
= '?'; break;
1290 case 'd': constantypedefs
= TRUE
; break;
1291 case 't': typedefs
= TRUE
; break;
1292 case 'T': typedefs
= typedefs_or_cplusplus
= TRUE
; break;
1293 case 'u': update
= TRUE
; break;
1294 case 'v': vgrind_style
= TRUE
; /*FALLTHRU*/
1295 case 'x': cxref_style
= TRUE
; break;
1296 case 'w': no_warnings
= TRUE
; break;
1298 suggest_asking_for_help ();
1302 /* No more options. Store the rest of arguments. */
1303 for (; optind
< argc
; optind
++)
1305 argbuffer
[current_arg
].arg_type
= at_filename
;
1306 argbuffer
[current_arg
].what
= argv
[optind
];
1311 argbuffer
[current_arg
].arg_type
= at_end
;
1314 print_help (argbuffer
);
1317 if (nincluded_files
== 0 && file_count
== 0)
1319 error ("no input files specified.", (char *)NULL
);
1320 suggest_asking_for_help ();
1324 if (tagfile
== NULL
)
1325 tagfile
= CTAGS
? "tags" : "TAGS";
1326 cwd
= etags_getcwd (); /* the current working directory */
1327 if (cwd
[strlen (cwd
) - 1] != '/')
1330 cwd
= concat (oldcwd
, "/", "");
1333 /* Relative file names are made relative to the current directory. */
1334 if (streq (tagfile
, "-")
1335 || strneq (tagfile
, "/dev/", 5))
1338 tagfiledir
= absolute_dirname (tagfile
, cwd
);
1340 init (); /* set up boolean "functions" */
1342 linebuffer_init (&lb
);
1343 linebuffer_init (&filename_lb
);
1344 linebuffer_init (&filebuf
);
1345 linebuffer_init (&token_name
);
1349 if (streq (tagfile
, "-"))
1353 /* Switch redirected `stdout' to binary mode (setting `_fmode'
1354 doesn't take effect until after `stdout' is already open). */
1355 if (!isatty (fileno (stdout
)))
1356 setmode (fileno (stdout
), O_BINARY
);
1360 tagf
= fopen (tagfile
, append_to_tagfile
? "a" : "w");
1366 * Loop through files finding functions.
1368 for (i
= 0; i
< current_arg
; i
++)
1370 static language
*lang
; /* non-NULL if language is forced */
1373 switch (argbuffer
[i
].arg_type
)
1376 lang
= argbuffer
[i
].lang
;
1378 #ifdef ETAGS_REGEXPS
1380 analyse_regex (argbuffer
[i
].what
);
1385 while ((this_file
= gfnames (argbuffer
[i
].what
, &got_err
)) != NULL
)
1389 error ("can't find file %s\n", this_file
);
1394 this_file
= massage_name (this_file
);
1397 this_file
= argbuffer
[i
].what
;
1399 /* Input file named "-" means read file names from stdin
1400 (one per line) and use them. */
1401 if (streq (this_file
, "-"))
1404 fatal ("cannot parse standard input AND read file names from it",
1406 while (readline_internal (&filename_lb
, stdin
) > 0)
1407 process_file_name (filename_lb
.buffer
, lang
);
1410 process_file_name (this_file
, lang
);
1416 this_file
= argbuffer
[i
].what
;
1417 process_file (stdin
, this_file
, lang
);
1422 #ifdef ETAGS_REGEXPS
1424 #endif /* ETAGS_REGEXPS */
1426 free (filebuf
.buffer
);
1427 free (token_name
.buffer
);
1429 if (!CTAGS
|| cxref_style
)
1431 /* Write the remaining tags to tagf (ETAGS) or stdout (CXREF). */
1432 put_entries (nodehead
);
1433 free_tree (nodehead
);
1439 /* Output file entries that have no tags. */
1440 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1442 fprintf (tagf
, "\f\n%s,0\n", fdp
->taggedfname
);
1444 while (nincluded_files
-- > 0)
1445 fprintf (tagf
, "\f\n%s,include\n", *included_files
++);
1447 if (fclose (tagf
) == EOF
)
1451 exit (EXIT_SUCCESS
);
1457 for (i
= 0; i
< current_arg
; ++i
)
1459 switch (argbuffer
[i
].arg_type
)
1465 continue; /* the for loop */
1468 "mv %s OTAGS;fgrep -v '\t%s\t' OTAGS >%s;rm OTAGS",
1469 tagfile
, argbuffer
[i
].what
, tagfile
);
1470 if (system (cmd
) != EXIT_SUCCESS
)
1471 fatal ("failed to execute shell command", (char *)NULL
);
1473 append_to_tagfile
= TRUE
;
1476 tagf
= fopen (tagfile
, append_to_tagfile
? "a" : "w");
1479 put_entries (nodehead
); /* write all the tags (CTAGS) */
1480 free_tree (nodehead
);
1482 if (fclose (tagf
) == EOF
)
1486 if (append_to_tagfile
|| update
)
1488 char cmd
[2*BUFSIZ
+10];
1489 sprintf (cmd
, "sort -o %.*s %.*s", BUFSIZ
, tagfile
, BUFSIZ
, tagfile
);
1490 exit (system (cmd
));
1492 return EXIT_SUCCESS
;
1497 * Return a compressor given the file name. If EXTPTR is non-zero,
1498 * return a pointer into FILE where the compressor-specific
1499 * extension begins. If no compressor is found, NULL is returned
1500 * and EXTPTR is not significant.
1501 * Idea by Vladimir Alexiev <vladimir@cs.ualberta.ca> (1998)
1504 get_compressor_from_suffix (file
, extptr
)
1509 char *slash
, *suffix
;
1511 /* This relies on FN to be after canonicalize_filename,
1512 so we don't need to consider backslashes on DOS_NT. */
1513 slash
= etags_strrchr (file
, '/');
1514 suffix
= etags_strrchr (file
, '.');
1515 if (suffix
== NULL
|| suffix
< slash
)
1520 /* Let those poor souls who live with DOS 8+3 file name limits get
1521 some solace by treating foo.cgz as if it were foo.c.gz, etc.
1522 Only the first do loop is run if not MSDOS */
1525 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1526 if (streq (compr
->suffix
, suffix
))
1529 break; /* do it only once: not really a loop */
1532 } while (*suffix
!= '\0');
1539 * Return a language given the name.
1542 get_language_from_langname (name
)
1548 error ("empty language name", (char *)NULL
);
1551 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1552 if (streq (name
, lang
->name
))
1554 error ("unknown language \"%s\"", name
);
1562 * Return a language given the interpreter name.
1565 get_language_from_interpreter (interpreter
)
1571 if (interpreter
== NULL
)
1573 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1574 if (lang
->interpreters
!= NULL
)
1575 for (iname
= lang
->interpreters
; *iname
!= NULL
; iname
++)
1576 if (streq (*iname
, interpreter
))
1585 * Return a language given the file name.
1588 get_language_from_filename (file
, case_sensitive
)
1590 bool case_sensitive
;
1593 char **name
, **ext
, *suffix
;
1595 /* Try whole file name first. */
1596 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1597 if (lang
->filenames
!= NULL
)
1598 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
1599 if ((case_sensitive
)
1600 ? streq (*name
, file
)
1601 : strcaseeq (*name
, file
))
1604 /* If not found, try suffix after last dot. */
1605 suffix
= etags_strrchr (file
, '.');
1609 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1610 if (lang
->suffixes
!= NULL
)
1611 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
1612 if ((case_sensitive
)
1613 ? streq (*ext
, suffix
)
1614 : strcaseeq (*ext
, suffix
))
1621 * This routine is called on each file argument.
1624 process_file_name (file
, lang
)
1628 struct stat stat_buf
;
1632 char *compressed_name
, *uncompressed_name
;
1633 char *ext
, *real_name
;
1636 canonicalize_filename (file
);
1637 if (streq (file
, tagfile
) && !streq (tagfile
, "-"))
1639 error ("skipping inclusion of %s in self.", file
);
1642 if ((compr
= get_compressor_from_suffix (file
, &ext
)) == NULL
)
1644 compressed_name
= NULL
;
1645 real_name
= uncompressed_name
= savestr (file
);
1649 real_name
= compressed_name
= savestr (file
);
1650 uncompressed_name
= savenstr (file
, ext
- file
);
1653 /* If the canonicalized uncompressed name
1654 has already been dealt with, skip it silently. */
1655 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1657 assert (fdp
->infname
!= NULL
);
1658 if (streq (uncompressed_name
, fdp
->infname
))
1662 if (stat (real_name
, &stat_buf
) != 0)
1664 /* Reset real_name and try with a different name. */
1666 if (compressed_name
!= NULL
) /* try with the given suffix */
1668 if (stat (uncompressed_name
, &stat_buf
) == 0)
1669 real_name
= uncompressed_name
;
1671 else /* try all possible suffixes */
1673 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1675 compressed_name
= concat (file
, ".", compr
->suffix
);
1676 if (stat (compressed_name
, &stat_buf
) != 0)
1680 char *suf
= compressed_name
+ strlen (file
);
1681 size_t suflen
= strlen (compr
->suffix
) + 1;
1682 for ( ; suf
[1]; suf
++, suflen
--)
1684 memmove (suf
, suf
+ 1, suflen
);
1685 if (stat (compressed_name
, &stat_buf
) == 0)
1687 real_name
= compressed_name
;
1691 if (real_name
!= NULL
)
1694 free (compressed_name
);
1695 compressed_name
= NULL
;
1699 real_name
= compressed_name
;
1704 if (real_name
== NULL
)
1709 } /* try with a different name */
1711 if (!S_ISREG (stat_buf
.st_mode
))
1713 error ("skipping %s: it is not a regular file.", real_name
);
1716 if (real_name
== compressed_name
)
1718 char *cmd
= concat (compr
->command
, " ", real_name
);
1719 inf
= (FILE *) popen (cmd
, "r");
1723 inf
= fopen (real_name
, "r");
1730 process_file (inf
, uncompressed_name
, lang
);
1732 if (real_name
== compressed_name
)
1733 retval
= pclose (inf
);
1735 retval
= fclose (inf
);
1740 if (compressed_name
) free (compressed_name
);
1741 if (uncompressed_name
) free (uncompressed_name
);
1748 process_file (fh
, fn
, lang
)
1753 static const fdesc emptyfdesc
;
1756 /* Create a new input file description entry. */
1757 fdp
= xnew (1, fdesc
);
1760 fdp
->infname
= savestr (fn
);
1762 fdp
->infabsname
= absolute_filename (fn
, cwd
);
1763 fdp
->infabsdir
= absolute_dirname (fn
, cwd
);
1764 if (filename_is_absolute (fn
))
1766 /* An absolute file name. Canonicalize it. */
1767 fdp
->taggedfname
= absolute_filename (fn
, NULL
);
1771 /* A file name relative to cwd. Make it relative
1772 to the directory of the tags file. */
1773 fdp
->taggedfname
= relative_filename (fn
, tagfiledir
);
1775 fdp
->usecharno
= TRUE
; /* use char position when making tags */
1777 fdp
->written
= FALSE
; /* not written on tags file yet */
1780 curfdp
= fdhead
; /* the current file description */
1784 /* If not Ctags, and if this is not metasource and if it contained no #line
1785 directives, we can write the tags and free all nodes pointing to
1788 && curfdp
->usecharno
/* no #line directives in this file */
1789 && !curfdp
->lang
->metasource
)
1793 /* Look for the head of the sublist relative to this file. See add_node
1794 for the structure of the node tree. */
1796 for (np
= nodehead
; np
!= NULL
; prev
= np
, np
= np
->left
)
1797 if (np
->fdp
== curfdp
)
1800 /* If we generated tags for this file, write and delete them. */
1803 /* This is the head of the last sublist, if any. The following
1804 instructions depend on this being true. */
1805 assert (np
->left
== NULL
);
1807 assert (fdhead
== curfdp
);
1808 assert (last_node
->fdp
== curfdp
);
1809 put_entries (np
); /* write tags for file curfdp->taggedfname */
1810 free_tree (np
); /* remove the written nodes */
1812 nodehead
= NULL
; /* no nodes left */
1814 prev
->left
= NULL
; /* delete the pointer to the sublist */
1820 * This routine sets up the boolean pseudo-functions which work
1821 * by setting boolean flags dependent upon the corresponding character.
1822 * Every char which is NOT in that string is not a white char. Therefore,
1823 * all of the array "_wht" is set to FALSE, and then the elements
1824 * subscripted by the chars in "white" are set to TRUE. Thus "_wht"
1825 * of a char is TRUE if it is the string "white", else FALSE.
1833 for (i
= 0; i
< CHARS
; i
++)
1834 iswhite(i
) = notinname(i
) = begtoken(i
) = intoken(i
) = endtoken(i
) = FALSE
;
1835 for (sp
= white
; *sp
!= '\0'; sp
++) iswhite (*sp
) = TRUE
;
1836 for (sp
= nonam
; *sp
!= '\0'; sp
++) notinname (*sp
) = TRUE
;
1837 notinname('\0') = notinname('\n');
1838 for (sp
= begtk
; *sp
!= '\0'; sp
++) begtoken (*sp
) = TRUE
;
1839 begtoken('\0') = begtoken('\n');
1840 for (sp
= midtk
; *sp
!= '\0'; sp
++) intoken (*sp
) = TRUE
;
1841 intoken('\0') = intoken('\n');
1842 for (sp
= endtk
; *sp
!= '\0'; sp
++) endtoken (*sp
) = TRUE
;
1843 endtoken('\0') = endtoken('\n');
1847 * This routine opens the specified file and calls the function
1848 * which finds the function and type definitions.
1855 language
*lang
= curfdp
->lang
;
1856 Lang_function
*parser
= NULL
;
1858 /* If user specified a language, use it. */
1859 if (lang
!= NULL
&& lang
->function
!= NULL
)
1861 parser
= lang
->function
;
1864 /* Else try to guess the language given the file name. */
1867 lang
= get_language_from_filename (curfdp
->infname
, TRUE
);
1868 if (lang
!= NULL
&& lang
->function
!= NULL
)
1870 curfdp
->lang
= lang
;
1871 parser
= lang
->function
;
1875 /* Else look for sharp-bang as the first two characters. */
1877 && readline_internal (&lb
, inf
) > 0
1879 && lb
.buffer
[0] == '#'
1880 && lb
.buffer
[1] == '!')
1884 /* Set lp to point at the first char after the last slash in the
1885 line or, if no slashes, at the first nonblank. Then set cp to
1886 the first successive blank and terminate the string. */
1887 lp
= etags_strrchr (lb
.buffer
+2, '/');
1891 lp
= skip_spaces (lb
.buffer
+ 2);
1892 cp
= skip_non_spaces (lp
);
1895 if (strlen (lp
) > 0)
1897 lang
= get_language_from_interpreter (lp
);
1898 if (lang
!= NULL
&& lang
->function
!= NULL
)
1900 curfdp
->lang
= lang
;
1901 parser
= lang
->function
;
1906 /* We rewind here, even if inf may be a pipe. We fail if the
1907 length of the first line is longer than the pipe block size,
1908 which is unlikely. */
1911 /* Else try to guess the language given the case insensitive file name. */
1914 lang
= get_language_from_filename (curfdp
->infname
, FALSE
);
1915 if (lang
!= NULL
&& lang
->function
!= NULL
)
1917 curfdp
->lang
= lang
;
1918 parser
= lang
->function
;
1922 /* Else try Fortran or C. */
1925 node
*old_last_node
= last_node
;
1927 curfdp
->lang
= get_language_from_langname ("fortran");
1930 if (old_last_node
== last_node
)
1931 /* No Fortran entries found. Try C. */
1933 /* We do not tag if rewind fails.
1934 Only the file name will be recorded in the tags file. */
1936 curfdp
->lang
= get_language_from_langname (cplusplus
? "c++" : "c");
1942 if (!no_line_directive
1943 && curfdp
->lang
!= NULL
&& curfdp
->lang
->metasource
)
1944 /* It may be that this is a bingo.y file, and we already parsed a bingo.c
1945 file, or anyway we parsed a file that is automatically generated from
1946 this one. If this is the case, the bingo.c file contained #line
1947 directives that generated tags pointing to this file. Let's delete
1948 them all before parsing this file, which is the real source. */
1950 fdesc
**fdpp
= &fdhead
;
1951 while (*fdpp
!= NULL
)
1953 && streq ((*fdpp
)->taggedfname
, curfdp
->taggedfname
))
1954 /* We found one of those! We must delete both the file description
1955 and all tags referring to it. */
1957 fdesc
*badfdp
= *fdpp
;
1959 /* Delete the tags referring to badfdp->taggedfname
1960 that were obtained from badfdp->infname. */
1961 invalidate_nodes (badfdp
, &nodehead
);
1963 *fdpp
= badfdp
->next
; /* remove the bad description from the list */
1964 free_fdesc (badfdp
);
1967 fdpp
= &(*fdpp
)->next
; /* advance the list pointer */
1970 assert (parser
!= NULL
);
1972 /* Generic initialisations before reading from file. */
1973 linebuffer_setlen (&filebuf
, 0); /* reset the file buffer */
1975 /* Generic initialisations before parsing file with readline. */
1976 lineno
= 0; /* reset global line number */
1977 charno
= 0; /* reset global char number */
1978 linecharno
= 0; /* reset global char number of line start */
1982 #ifdef ETAGS_REGEXPS
1983 regex_tag_multiline ();
1984 #endif /* ETAGS_REGEXPS */
1989 * Check whether an implicitly named tag should be created,
1990 * then call `pfnote'.
1991 * NAME is a string that is internally copied by this function.
1993 * TAGS format specification
1994 * Idea by Sam Kendall <kendall@mv.mv.com> (1997)
1995 * The following is explained in some more detail in etc/ETAGS.EBNF.
1997 * make_tag creates tags with "implicit tag names" (unnamed tags)
1998 * if the following are all true, assuming NONAM=" \f\t\n\r()=,;":
1999 * 1. NAME does not contain any of the characters in NONAM;
2000 * 2. LINESTART contains name as either a rightmost, or rightmost but
2001 * one character, substring;
2002 * 3. the character, if any, immediately before NAME in LINESTART must
2003 * be a character in NONAM;
2004 * 4. the character, if any, immediately after NAME in LINESTART must
2005 * also be a character in NONAM.
2007 * The implementation uses the notinname() macro, which recognises the
2008 * characters stored in the string `nonam'.
2009 * etags.el needs to use the same characters that are in NONAM.
2012 make_tag (name
, namelen
, is_func
, linestart
, linelen
, lno
, cno
)
2013 char *name
; /* tag name, or NULL if unnamed */
2014 int namelen
; /* tag length */
2015 bool is_func
; /* tag is a function */
2016 char *linestart
; /* start of the line where tag is */
2017 int linelen
; /* length of the line where tag is */
2018 int lno
; /* line number */
2019 long cno
; /* character number */
2021 bool named
= (name
!= NULL
&& namelen
> 0);
2023 if (!CTAGS
&& named
) /* maybe set named to false */
2024 /* Let's try to make an implicit tag name, that is, create an unnamed tag
2025 such that etags.el can guess a name from it. */
2028 register char *cp
= name
;
2030 for (i
= 0; i
< namelen
; i
++)
2031 if (notinname (*cp
++))
2033 if (i
== namelen
) /* rule #1 */
2035 cp
= linestart
+ linelen
- namelen
;
2036 if (notinname (linestart
[linelen
-1]))
2037 cp
-= 1; /* rule #4 */
2038 if (cp
>= linestart
/* rule #2 */
2040 || notinname (cp
[-1])) /* rule #3 */
2041 && strneq (name
, cp
, namelen
)) /* rule #2 */
2042 named
= FALSE
; /* use implicit tag name */
2047 name
= savenstr (name
, namelen
);
2050 pfnote (name
, is_func
, linestart
, linelen
, lno
, cno
);
2055 pfnote (name
, is_func
, linestart
, linelen
, lno
, cno
)
2056 char *name
; /* tag name, or NULL if unnamed */
2057 bool is_func
; /* tag is a function */
2058 char *linestart
; /* start of the line where tag is */
2059 int linelen
; /* length of the line where tag is */
2060 int lno
; /* line number */
2061 long cno
; /* character number */
2065 assert (name
== NULL
|| name
[0] != '\0');
2066 if (CTAGS
&& name
== NULL
)
2069 np
= xnew (1, node
);
2071 /* If ctags mode, change name "main" to M<thisfilename>. */
2072 if (CTAGS
&& !cxref_style
&& streq (name
, "main"))
2074 register char *fp
= etags_strrchr (curfdp
->taggedfname
, '/');
2075 np
->name
= concat ("M", fp
== NULL
? curfdp
->taggedfname
: fp
+ 1, "");
2076 fp
= etags_strrchr (np
->name
, '.');
2077 if (fp
!= NULL
&& fp
[1] != '\0' && fp
[2] == '\0')
2083 np
->been_warned
= FALSE
;
2085 np
->is_func
= is_func
;
2087 if (np
->fdp
->usecharno
)
2088 /* Our char numbers are 0-base, because of C language tradition?
2089 ctags compatibility? old versions compatibility? I don't know.
2090 Anyway, since emacs's are 1-base we expect etags.el to take care
2091 of the difference. If we wanted to have 1-based numbers, we would
2092 uncomment the +1 below. */
2093 np
->cno
= cno
/* + 1 */ ;
2095 np
->cno
= invalidcharno
;
2096 np
->left
= np
->right
= NULL
;
2097 if (CTAGS
&& !cxref_style
)
2099 if (strlen (linestart
) < 50)
2100 np
->regex
= concat (linestart
, "$", "");
2102 np
->regex
= savenstr (linestart
, 50);
2105 np
->regex
= savenstr (linestart
, linelen
);
2107 add_node (np
, &nodehead
);
2112 * recurse on left children, iterate on right children.
2120 register node
*node_right
= np
->right
;
2121 free_tree (np
->left
);
2122 if (np
->name
!= NULL
)
2132 * delete a file description
2136 register fdesc
*fdp
;
2138 if (fdp
->infname
!= NULL
) free (fdp
->infname
);
2139 if (fdp
->infabsname
!= NULL
) free (fdp
->infabsname
);
2140 if (fdp
->infabsdir
!= NULL
) free (fdp
->infabsdir
);
2141 if (fdp
->taggedfname
!= NULL
) free (fdp
->taggedfname
);
2142 if (fdp
->prop
!= NULL
) free (fdp
->prop
);
2148 * Adds a node to the tree of nodes. In etags mode, sort by file
2149 * name. In ctags mode, sort by tag name. Make no attempt at
2152 * add_node is the only function allowed to add nodes, so it can
2156 add_node (np
, cur_node_p
)
2157 node
*np
, **cur_node_p
;
2160 register node
*cur_node
= *cur_node_p
;
2162 if (cur_node
== NULL
)
2172 /* For each file name, tags are in a linked sublist on the right
2173 pointer. The first tags of different files are a linked list
2174 on the left pointer. last_node points to the end of the last
2176 if (last_node
!= NULL
&& last_node
->fdp
== np
->fdp
)
2178 /* Let's use the same sublist as the last added node. */
2179 assert (last_node
->right
== NULL
);
2180 last_node
->right
= np
;
2183 else if (cur_node
->fdp
== np
->fdp
)
2185 /* Scanning the list we found the head of a sublist which is
2186 good for us. Let's scan this sublist. */
2187 add_node (np
, &cur_node
->right
);
2190 /* The head of this sublist is not good for us. Let's try the
2192 add_node (np
, &cur_node
->left
);
2193 } /* if ETAGS mode */
2198 dif
= strcmp (np
->name
, cur_node
->name
);
2201 * If this tag name matches an existing one, then
2202 * do not add the node, but maybe print a warning.
2206 if (np
->fdp
== cur_node
->fdp
)
2210 fprintf (stderr
, "Duplicate entry in file %s, line %d: %s\n",
2211 np
->fdp
->infname
, lineno
, np
->name
);
2212 fprintf (stderr
, "Second entry ignored\n");
2215 else if (!cur_node
->been_warned
&& !no_warnings
)
2219 "Duplicate entry in files %s and %s: %s (Warning only)\n",
2220 np
->fdp
->infname
, cur_node
->fdp
->infname
, np
->name
);
2221 cur_node
->been_warned
= TRUE
;
2226 /* Actually add the node */
2227 add_node (np
, dif
< 0 ? &cur_node
->left
: &cur_node
->right
);
2228 } /* if CTAGS mode */
2232 * invalidate_nodes ()
2233 * Scan the node tree and invalidate all nodes pointing to the
2234 * given file description (CTAGS case) or free them (ETAGS case).
2237 invalidate_nodes (badfdp
, npp
)
2248 if (np
->left
!= NULL
)
2249 invalidate_nodes (badfdp
, &np
->left
);
2250 if (np
->fdp
== badfdp
)
2252 if (np
->right
!= NULL
)
2253 invalidate_nodes (badfdp
, &np
->right
);
2257 assert (np
->fdp
!= NULL
);
2258 if (np
->fdp
== badfdp
)
2260 *npp
= np
->left
; /* detach the sublist from the list */
2261 np
->left
= NULL
; /* isolate it */
2262 free_tree (np
); /* free it */
2263 invalidate_nodes (badfdp
, npp
);
2266 invalidate_nodes (badfdp
, &np
->left
);
2271 static int total_size_of_entries
__P((node
*));
2272 static int number_len
__P((long));
2274 /* Length of a non-negative number's decimal representation. */
2280 while ((num
/= 10) > 0)
2286 * Return total number of characters that put_entries will output for
2287 * the nodes in the linked list at the right of the specified node.
2288 * This count is irrelevant with etags.el since emacs 19.34 at least,
2289 * but is still supplied for backward compatibility.
2292 total_size_of_entries (np
)
2295 register int total
= 0;
2297 for (; np
!= NULL
; np
= np
->right
)
2300 total
+= strlen (np
->regex
) + 1; /* pat\177 */
2301 if (np
->name
!= NULL
)
2302 total
+= strlen (np
->name
) + 1; /* name\001 */
2303 total
+= number_len ((long) np
->lno
) + 1; /* lno, */
2304 if (np
->cno
!= invalidcharno
) /* cno */
2305 total
+= number_len (np
->cno
);
2306 total
+= 1; /* newline */
2317 static fdesc
*fdp
= NULL
;
2322 /* Output subentries that precede this one */
2324 put_entries (np
->left
);
2326 /* Output this entry */
2335 fprintf (tagf
, "\f\n%s,%d\n",
2336 fdp
->taggedfname
, total_size_of_entries (np
));
2337 fdp
->written
= TRUE
;
2339 fputs (np
->regex
, tagf
);
2340 fputc ('\177', tagf
);
2341 if (np
->name
!= NULL
)
2343 fputs (np
->name
, tagf
);
2344 fputc ('\001', tagf
);
2346 fprintf (tagf
, "%d,", np
->lno
);
2347 if (np
->cno
!= invalidcharno
)
2348 fprintf (tagf
, "%ld", np
->cno
);
2354 if (np
->name
== NULL
)
2355 error ("internal error: NULL name in ctags mode.", (char *)NULL
);
2360 fprintf (stdout
, "%s %s %d\n",
2361 np
->name
, np
->fdp
->taggedfname
, (np
->lno
+ 63) / 64);
2363 fprintf (stdout
, "%-16s %3d %-16s %s\n",
2364 np
->name
, np
->lno
, np
->fdp
->taggedfname
, np
->regex
);
2368 fprintf (tagf
, "%s\t%s\t", np
->name
, np
->fdp
->taggedfname
);
2371 { /* function or #define macro with args */
2372 putc (searchar
, tagf
);
2375 for (sp
= np
->regex
; *sp
; sp
++)
2377 if (*sp
== '\\' || *sp
== searchar
)
2381 putc (searchar
, tagf
);
2384 { /* anything else; text pattern inadequate */
2385 fprintf (tagf
, "%d", np
->lno
);
2390 } /* if this node contains a valid tag */
2392 /* Output subentries that follow this one */
2393 put_entries (np
->right
);
2395 put_entries (np
->left
);
2400 #define C_EXT 0x00fff /* C extensions */
2401 #define C_PLAIN 0x00000 /* C */
2402 #define C_PLPL 0x00001 /* C++ */
2403 #define C_STAR 0x00003 /* C* */
2404 #define C_JAVA 0x00005 /* JAVA */
2405 #define C_AUTO 0x01000 /* C, but switch to C++ if `class' is met */
2406 #define YACC 0x10000 /* yacc file */
2409 * The C symbol tables.
2414 st_C_objprot
, st_C_objimpl
, st_C_objend
,
2416 st_C_ignore
, st_C_attribute
,
2419 st_C_class
, st_C_template
,
2420 st_C_struct
, st_C_extern
, st_C_enum
, st_C_define
, st_C_typedef
2423 static unsigned int hash
__P((const char *, unsigned int));
2424 static struct C_stab_entry
* in_word_set
__P((const char *, unsigned int));
2425 static enum sym_type C_symtype
__P((char *, int, int));
2427 /* Feed stuff between (but not including) %[ and %] lines to:
2433 struct C_stab_entry { char *name; int c_ext; enum sym_type type; }
2437 while, 0, st_C_ignore
2438 switch, 0, st_C_ignore
2439 return, 0, st_C_ignore
2440 __attribute__, 0, st_C_attribute
2441 @interface, 0, st_C_objprot
2442 @protocol, 0, st_C_objprot
2443 @implementation,0, st_C_objimpl
2444 @end, 0, st_C_objend
2445 import, (C_JAVA & !C_PLPL), st_C_ignore
2446 package, (C_JAVA & !C_PLPL), st_C_ignore
2447 friend, C_PLPL, st_C_ignore
2448 extends, (C_JAVA & !C_PLPL), st_C_javastruct
2449 implements, (C_JAVA & !C_PLPL), st_C_javastruct
2450 interface, (C_JAVA & !C_PLPL), st_C_struct
2451 class, 0, st_C_class
2452 namespace, C_PLPL, st_C_struct
2453 domain, C_STAR, st_C_struct
2454 union, 0, st_C_struct
2455 struct, 0, st_C_struct
2456 extern, 0, st_C_extern
2458 typedef, 0, st_C_typedef
2459 define, 0, st_C_define
2460 undef, 0, st_C_define
2461 operator, C_PLPL, st_C_operator
2462 template, 0, st_C_template
2463 # DEFUN used in emacs, the next three used in glibc (SYSCALL only for mach).
2464 DEFUN, 0, st_C_gnumacro
2465 SYSCALL, 0, st_C_gnumacro
2466 ENTRY, 0, st_C_gnumacro
2467 PSEUDO, 0, st_C_gnumacro
2468 # These are defined inside C functions, so currently they are not met.
2469 # EXFUN used in glibc, DEFVAR_* in emacs.
2470 #EXFUN, 0, st_C_gnumacro
2471 #DEFVAR_, 0, st_C_gnumacro
2473 and replace lines between %< and %> with its output, then:
2474 - remove the #if characterset check
2475 - make in_word_set static and not inline. */
2477 /* C code produced by gperf version 3.0.1 */
2478 /* Command-line: gperf -m 5 */
2479 /* Computed positions: -k'2-3' */
2481 struct C_stab_entry
{ char *name
; int c_ext
; enum sym_type type
; };
2482 /* maximum key range = 33, duplicates = 0 */
2493 register const char *str
;
2494 register unsigned int len
;
2496 static unsigned char asso_values
[] =
2498 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2499 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2500 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2501 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2502 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2503 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2504 35, 35, 35, 35, 35, 35, 35, 35, 35, 15,
2505 14, 35, 35, 35, 35, 35, 35, 35, 14, 35,
2506 35, 35, 35, 12, 13, 35, 35, 35, 35, 12,
2507 35, 35, 35, 35, 35, 1, 35, 16, 35, 6,
2508 23, 0, 0, 35, 22, 0, 35, 35, 5, 0,
2509 0, 15, 1, 35, 6, 35, 8, 19, 35, 16,
2510 4, 5, 35, 35, 35, 35, 35, 35, 35, 35,
2511 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2512 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2513 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2514 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2515 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2516 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2517 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2518 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2519 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2520 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2521 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2522 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2523 35, 35, 35, 35, 35, 35
2525 register int hval
= len
;
2530 hval
+= asso_values
[(unsigned char)str
[2]];
2533 hval
+= asso_values
[(unsigned char)str
[1]];
2539 static struct C_stab_entry
*
2540 in_word_set (str
, len
)
2541 register const char *str
;
2542 register unsigned int len
;
2546 TOTAL_KEYWORDS
= 32,
2547 MIN_WORD_LENGTH
= 2,
2548 MAX_WORD_LENGTH
= 15,
2553 static struct C_stab_entry wordlist
[] =
2556 {"if", 0, st_C_ignore
},
2558 {"@end", 0, st_C_objend
},
2559 {"union", 0, st_C_struct
},
2560 {"define", 0, st_C_define
},
2561 {"import", (C_JAVA
& !C_PLPL
), st_C_ignore
},
2562 {"template", 0, st_C_template
},
2563 {"operator", C_PLPL
, st_C_operator
},
2564 {"@interface", 0, st_C_objprot
},
2565 {"implements", (C_JAVA
& !C_PLPL
), st_C_javastruct
},
2566 {"friend", C_PLPL
, st_C_ignore
},
2567 {"typedef", 0, st_C_typedef
},
2568 {"return", 0, st_C_ignore
},
2569 {"@implementation",0, st_C_objimpl
},
2570 {"@protocol", 0, st_C_objprot
},
2571 {"interface", (C_JAVA
& !C_PLPL
), st_C_struct
},
2572 {"extern", 0, st_C_extern
},
2573 {"extends", (C_JAVA
& !C_PLPL
), st_C_javastruct
},
2574 {"struct", 0, st_C_struct
},
2575 {"domain", C_STAR
, st_C_struct
},
2576 {"switch", 0, st_C_ignore
},
2577 {"enum", 0, st_C_enum
},
2578 {"for", 0, st_C_ignore
},
2579 {"namespace", C_PLPL
, st_C_struct
},
2580 {"class", 0, st_C_class
},
2581 {"while", 0, st_C_ignore
},
2582 {"undef", 0, st_C_define
},
2583 {"package", (C_JAVA
& !C_PLPL
), st_C_ignore
},
2584 {"__attribute__", 0, st_C_attribute
},
2585 {"SYSCALL", 0, st_C_gnumacro
},
2586 {"ENTRY", 0, st_C_gnumacro
},
2587 {"PSEUDO", 0, st_C_gnumacro
},
2588 {"DEFUN", 0, st_C_gnumacro
}
2591 if (len
<= MAX_WORD_LENGTH
&& len
>= MIN_WORD_LENGTH
)
2593 register int key
= hash (str
, len
);
2595 if (key
<= MAX_HASH_VALUE
&& key
>= 0)
2597 register const char *s
= wordlist
[key
].name
;
2599 if (*str
== *s
&& !strncmp (str
+ 1, s
+ 1, len
- 1) && s
[len
] == '\0')
2600 return &wordlist
[key
];
2607 static enum sym_type
2608 C_symtype (str
, len
, c_ext
)
2613 register struct C_stab_entry
*se
= in_word_set (str
, len
);
2615 if (se
== NULL
|| (se
->c_ext
&& !(c_ext
& se
->c_ext
)))
2622 * Ignoring __attribute__ ((list))
2624 static bool inattribute
; /* looking at an __attribute__ construct */
2627 * C functions and variables are recognized using a simple
2628 * finite automaton. fvdef is its state variable.
2632 fvnone
, /* nothing seen */
2633 fdefunkey
, /* Emacs DEFUN keyword seen */
2634 fdefunname
, /* Emacs DEFUN name seen */
2635 foperator
, /* func: operator keyword seen (cplpl) */
2636 fvnameseen
, /* function or variable name seen */
2637 fstartlist
, /* func: just after open parenthesis */
2638 finlist
, /* func: in parameter list */
2639 flistseen
, /* func: after parameter list */
2640 fignore
, /* func: before open brace */
2641 vignore
/* var-like: ignore until ';' */
2644 static bool fvextern
; /* func or var: extern keyword seen; */
2647 * typedefs are recognized using a simple finite automaton.
2648 * typdef is its state variable.
2652 tnone
, /* nothing seen */
2653 tkeyseen
, /* typedef keyword seen */
2654 ttypeseen
, /* defined type seen */
2655 tinbody
, /* inside typedef body */
2656 tend
, /* just before typedef tag */
2657 tignore
/* junk after typedef tag */
2661 * struct-like structures (enum, struct and union) are recognized
2662 * using another simple finite automaton. `structdef' is its state
2667 snone
, /* nothing seen yet,
2668 or in struct body if bracelev > 0 */
2669 skeyseen
, /* struct-like keyword seen */
2670 stagseen
, /* struct-like tag seen */
2671 scolonseen
/* colon seen after struct-like tag */
2675 * When objdef is different from onone, objtag is the name of the class.
2677 static char *objtag
= "<uninited>";
2680 * Yet another little state machine to deal with preprocessor lines.
2684 dnone
, /* nothing seen */
2685 dsharpseen
, /* '#' seen as first char on line */
2686 ddefineseen
, /* '#' and 'define' seen */
2687 dignorerest
/* ignore rest of line */
2691 * State machine for Objective C protocols and implementations.
2692 * Idea by Tom R.Hageman <tom@basil.icce.rug.nl> (1995)
2696 onone
, /* nothing seen */
2697 oprotocol
, /* @interface or @protocol seen */
2698 oimplementation
, /* @implementations seen */
2699 otagseen
, /* class name seen */
2700 oparenseen
, /* parenthesis before category seen */
2701 ocatseen
, /* category name seen */
2702 oinbody
, /* in @implementation body */
2703 omethodsign
, /* in @implementation body, after +/- */
2704 omethodtag
, /* after method name */
2705 omethodcolon
, /* after method colon */
2706 omethodparm
, /* after method parameter */
2707 oignore
/* wait for @end */
2712 * Use this structure to keep info about the token read, and how it
2713 * should be tagged. Used by the make_C_tag function to build a tag.
2717 char *line
; /* string containing the token */
2718 int offset
; /* where the token starts in LINE */
2719 int length
; /* token length */
2721 The previous members can be used to pass strings around for generic
2722 purposes. The following ones specifically refer to creating tags. In this
2723 case the token contained here is the pattern that will be used to create a
2726 bool valid
; /* do not create a tag; the token should be
2727 invalidated whenever a state machine is
2728 reset prematurely */
2729 bool named
; /* create a named tag */
2730 int lineno
; /* source line number of tag */
2731 long linepos
; /* source char number of tag */
2732 } token
; /* latest token read */
2735 * Variables and functions for dealing with nested structures.
2736 * Idea by Mykola Dzyuba <mdzyuba@yahoo.com> (2001)
2738 static void pushclass_above
__P((int, char *, int));
2739 static void popclass_above
__P((int));
2740 static void write_classname
__P((linebuffer
*, char *qualifier
));
2743 char **cname
; /* nested class names */
2744 int *bracelev
; /* nested class brace level */
2745 int nl
; /* class nesting level (elements used) */
2746 int size
; /* length of the array */
2747 } cstack
; /* stack for nested declaration tags */
2748 /* Current struct nesting depth (namespace, class, struct, union, enum). */
2749 #define nestlev (cstack.nl)
2750 /* After struct keyword or in struct body, not inside a nested function. */
2751 #define instruct (structdef == snone && nestlev > 0 \
2752 && bracelev == cstack.bracelev[nestlev-1] + 1)
2755 pushclass_above (bracelev
, str
, len
)
2762 popclass_above (bracelev
);
2764 if (nl
>= cstack
.size
)
2766 int size
= cstack
.size
*= 2;
2767 xrnew (cstack
.cname
, size
, char *);
2768 xrnew (cstack
.bracelev
, size
, int);
2770 assert (nl
== 0 || cstack
.bracelev
[nl
-1] < bracelev
);
2771 cstack
.cname
[nl
] = (str
== NULL
) ? NULL
: savenstr (str
, len
);
2772 cstack
.bracelev
[nl
] = bracelev
;
2777 popclass_above (bracelev
)
2782 for (nl
= cstack
.nl
- 1;
2783 nl
>= 0 && cstack
.bracelev
[nl
] >= bracelev
;
2786 if (cstack
.cname
[nl
] != NULL
)
2787 free (cstack
.cname
[nl
]);
2793 write_classname (cn
, qualifier
)
2798 int qlen
= strlen (qualifier
);
2800 if (cstack
.nl
== 0 || cstack
.cname
[0] == NULL
)
2804 cn
->buffer
[0] = '\0';
2808 len
= strlen (cstack
.cname
[0]);
2809 linebuffer_setlen (cn
, len
);
2810 strcpy (cn
->buffer
, cstack
.cname
[0]);
2812 for (i
= 1; i
< cstack
.nl
; i
++)
2817 s
= cstack
.cname
[i
];
2822 linebuffer_setlen (cn
, len
);
2823 strncat (cn
->buffer
, qualifier
, qlen
);
2824 strncat (cn
->buffer
, s
, slen
);
2829 static bool consider_token
__P((char *, int, int, int *, int, int, bool *));
2830 static void make_C_tag
__P((bool));
2834 * checks to see if the current token is at the start of a
2835 * function or variable, or corresponds to a typedef, or
2836 * is a struct/union/enum tag, or #define, or an enum constant.
2838 * *IS_FUNC gets TRUE iff the token is a function or #define macro
2839 * with args. C_EXTP points to which language we are looking at.
2850 consider_token (str
, len
, c
, c_extp
, bracelev
, parlev
, is_func_or_var
)
2851 register char *str
; /* IN: token pointer */
2852 register int len
; /* IN: token length */
2853 register int c
; /* IN: first char after the token */
2854 int *c_extp
; /* IN, OUT: C extensions mask */
2855 int bracelev
; /* IN: brace level */
2856 int parlev
; /* IN: parenthesis level */
2857 bool *is_func_or_var
; /* OUT: function or variable found */
2859 /* When structdef is stagseen, scolonseen, or snone with bracelev > 0,
2860 structtype is the type of the preceding struct-like keyword, and
2861 structbracelev is the brace level where it has been seen. */
2862 static enum sym_type structtype
;
2863 static int structbracelev
;
2864 static enum sym_type toktype
;
2867 toktype
= C_symtype (str
, len
, *c_extp
);
2870 * Skip __attribute__
2872 if (toktype
== st_C_attribute
)
2879 * Advance the definedef state machine.
2884 /* We're not on a preprocessor line. */
2885 if (toktype
== st_C_gnumacro
)
2892 if (toktype
== st_C_define
)
2894 definedef
= ddefineseen
;
2898 definedef
= dignorerest
;
2903 * Make a tag for any macro, unless it is a constant
2904 * and constantypedefs is FALSE.
2906 definedef
= dignorerest
;
2907 *is_func_or_var
= (c
== '(');
2908 if (!*is_func_or_var
&& !constantypedefs
)
2915 error ("internal error: definedef value.", (char *)NULL
);
2924 if (toktype
== st_C_typedef
)
2944 if (structdef
== snone
&& fvdef
== fvnone
)
2962 * This structdef business is NOT invoked when we are ctags and the
2963 * file is plain C. This is because a struct tag may have the same
2964 * name as another tag, and this loses with ctags.
2968 case st_C_javastruct
:
2969 if (structdef
== stagseen
)
2970 structdef
= scolonseen
;
2974 if ((*c_extp
& C_AUTO
) /* automatic detection of C++ language */
2976 && definedef
== dnone
&& structdef
== snone
2977 && typdef
== tnone
&& fvdef
== fvnone
)
2978 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
2979 if (toktype
== st_C_template
)
2986 && (typdef
== tkeyseen
2987 || (typedefs_or_cplusplus
&& structdef
== snone
)))
2989 structdef
= skeyseen
;
2990 structtype
= toktype
;
2991 structbracelev
= bracelev
;
2992 if (fvdef
== fvnameseen
)
2998 if (structdef
== skeyseen
)
3000 structdef
= stagseen
;
3004 if (typdef
!= tnone
)
3007 /* Detect Objective C constructs. */
3017 objdef
= oimplementation
;
3021 case oimplementation
:
3022 /* Save the class tag for functions or variables defined inside. */
3023 objtag
= savenstr (str
, len
);
3027 /* Save the class tag for categories. */
3028 objtag
= savenstr (str
, len
);
3030 *is_func_or_var
= TRUE
;
3034 *is_func_or_var
= TRUE
;
3042 objdef
= omethodtag
;
3043 linebuffer_setlen (&token_name
, len
);
3044 strncpy (token_name
.buffer
, str
, len
);
3045 token_name
.buffer
[len
] = '\0';
3051 objdef
= omethodparm
;
3057 objdef
= omethodtag
;
3058 linebuffer_setlen (&token_name
, token_name
.len
+ len
);
3059 strncat (token_name
.buffer
, str
, len
);
3064 if (toktype
== st_C_objend
)
3066 /* Memory leakage here: the string pointed by objtag is
3067 never released, because many tests would be needed to
3068 avoid breaking on incorrect input code. The amount of
3069 memory leaked here is the sum of the lengths of the
3077 /* A function, variable or enum constant? */
3099 *is_func_or_var
= TRUE
;
3103 && structdef
== snone
3104 && structtype
== st_C_enum
&& bracelev
> structbracelev
)
3105 return TRUE
; /* enum constant */
3111 fvdef
= fdefunname
; /* GNU macro */
3112 *is_func_or_var
= TRUE
;
3120 if ((strneq (str
, "asm", 3) && endtoken (str
[3]))
3121 || (strneq (str
, "__asm__", 7) && endtoken (str
[7])))
3130 if (len
>= 10 && strneq (str
+len
-10, "::operator", 10))
3132 if (*c_extp
& C_AUTO
) /* automatic detection of C++ */
3133 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
3135 *is_func_or_var
= TRUE
;
3138 if (bracelev
> 0 && !instruct
)
3140 fvdef
= fvnameseen
; /* function or variable */
3141 *is_func_or_var
= TRUE
;
3152 * C_entries often keeps pointers to tokens or lines which are older than
3153 * the line currently read. By keeping two line buffers, and switching
3154 * them at end of line, it is possible to use those pointers.
3162 #define current_lb_is_new (newndx == curndx)
3163 #define switch_line_buffers() (curndx = 1 - curndx)
3165 #define curlb (lbs[curndx].lb)
3166 #define newlb (lbs[newndx].lb)
3167 #define curlinepos (lbs[curndx].linepos)
3168 #define newlinepos (lbs[newndx].linepos)
3170 #define plainc ((c_ext & C_EXT) == C_PLAIN)
3171 #define cplpl (c_ext & C_PLPL)
3172 #define cjava ((c_ext & C_JAVA) == C_JAVA)
3174 #define CNL_SAVE_DEFINEDEF() \
3176 curlinepos = charno; \
3177 readline (&curlb, inf); \
3178 lp = curlb.buffer; \
3185 CNL_SAVE_DEFINEDEF(); \
3186 if (savetoken.valid) \
3188 token = savetoken; \
3189 savetoken.valid = FALSE; \
3191 definedef = dnone; \
3199 /* This function should never be called when token.valid is FALSE, but
3200 we must protect against invalid input or internal errors. */
3201 if (!DEBUG
&& !token
.valid
)
3205 make_tag (token_name
.buffer
, token_name
.len
, isfun
, token
.line
,
3206 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3207 else /* this case is optimised away if !DEBUG */
3208 make_tag (concat ("INVALID TOKEN:-->", token_name
.buffer
, ""),
3209 token_name
.len
+ 17, isfun
, token
.line
,
3210 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3212 token
.valid
= FALSE
;
3218 * This routine finds functions, variables, typedefs,
3219 * #define's, enum constants and struct/union/enum definitions in
3220 * C syntax and adds them to the list.
3223 C_entries (c_ext
, inf
)
3224 int c_ext
; /* extension of C */
3225 FILE *inf
; /* input file */
3227 register char c
; /* latest char read; '\0' for end of line */
3228 register char *lp
; /* pointer one beyond the character `c' */
3229 int curndx
, newndx
; /* indices for current and new lb */
3230 register int tokoff
; /* offset in line of start of current token */
3231 register int toklen
; /* length of current token */
3232 char *qualifier
; /* string used to qualify names */
3233 int qlen
; /* length of qualifier */
3234 int bracelev
; /* current brace level */
3235 int bracketlev
; /* current bracket level */
3236 int parlev
; /* current parenthesis level */
3237 int attrparlev
; /* __attribute__ parenthesis level */
3238 int templatelev
; /* current template level */
3239 int typdefbracelev
; /* bracelev where a typedef struct body begun */
3240 bool incomm
, inquote
, inchar
, quotednl
, midtoken
;
3241 bool yacc_rules
; /* in the rules part of a yacc file */
3242 struct tok savetoken
; /* token saved during preprocessor handling */
3245 linebuffer_init (&lbs
[0].lb
);
3246 linebuffer_init (&lbs
[1].lb
);
3247 if (cstack
.size
== 0)
3249 cstack
.size
= (DEBUG
) ? 1 : 4;
3251 cstack
.cname
= xnew (cstack
.size
, char *);
3252 cstack
.bracelev
= xnew (cstack
.size
, int);
3255 tokoff
= toklen
= typdefbracelev
= 0; /* keep compiler quiet */
3256 curndx
= newndx
= 0;
3260 fvdef
= fvnone
; fvextern
= FALSE
; typdef
= tnone
;
3261 structdef
= snone
; definedef
= dnone
; objdef
= onone
;
3263 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
3264 token
.valid
= savetoken
.valid
= FALSE
;
3265 bracelev
= bracketlev
= parlev
= attrparlev
= templatelev
= 0;
3267 { qualifier
= "."; qlen
= 1; }
3269 { qualifier
= "::"; qlen
= 2; }
3277 /* If we are at the end of the line, the next character is a
3278 '\0'; do not skip it, because it is what tells us
3279 to read the next line. */
3300 /* Newlines inside comments do not end macro definitions in
3302 CNL_SAVE_DEFINEDEF ();
3315 /* Newlines inside strings do not end macro definitions
3316 in traditional cpp, even though compilers don't
3317 usually accept them. */
3318 CNL_SAVE_DEFINEDEF ();
3328 /* Hmmm, something went wrong. */
3337 else if (bracketlev
> 0)
3342 if (--bracketlev
> 0)
3346 CNL_SAVE_DEFINEDEF ();
3374 if (fvdef
!= finlist
&& fvdef
!= fignore
&& fvdef
!=vignore
)
3387 else if (/* cplpl && */ *lp
== '/')
3395 if ((c_ext
& YACC
) && *lp
== '%')
3397 /* Entering or exiting rules section in yacc file. */
3399 definedef
= dnone
; fvdef
= fvnone
; fvextern
= FALSE
;
3400 typdef
= tnone
; structdef
= snone
;
3401 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
3403 yacc_rules
= !yacc_rules
;
3409 if (definedef
== dnone
)
3412 bool cpptoken
= TRUE
;
3414 /* Look back on this line. If all blanks, or nonblanks
3415 followed by an end of comment, this is a preprocessor
3417 for (cp
= newlb
.buffer
; cp
< lp
-1; cp
++)
3420 if (*cp
== '*' && *(cp
+1) == '/')
3429 definedef
= dsharpseen
;
3430 } /* if (definedef == dnone) */
3438 /* Consider token only if some involved conditions are satisfied. */
3439 if (typdef
!= tignore
3440 && definedef
!= dignorerest
3443 && (definedef
!= dnone
3444 || structdef
!= scolonseen
)
3451 if (c
== ':' && *lp
== ':' && begtoken (lp
[1]))
3452 /* This handles :: in the middle,
3453 but not at the beginning of an identifier.
3454 Also, space-separated :: is not recognised. */
3456 if (c_ext
& C_AUTO
) /* automatic detection of C++ */
3457 c_ext
= (c_ext
| C_PLPL
) & ~C_AUTO
;
3461 goto still_in_token
;
3465 bool funorvar
= FALSE
;
3468 || consider_token (newlb
.buffer
+ tokoff
, toklen
, c
,
3469 &c_ext
, bracelev
, parlev
,
3472 if (fvdef
== foperator
)
3475 lp
= skip_spaces (lp
-1);
3479 && !iswhite (*lp
) && *lp
!= '(')
3482 toklen
+= lp
- oldlp
;
3484 token
.named
= FALSE
;
3486 && nestlev
> 0 && definedef
== dnone
)
3487 /* in struct body */
3489 write_classname (&token_name
, qualifier
);
3490 linebuffer_setlen (&token_name
,
3491 token_name
.len
+qlen
+toklen
);
3492 strcat (token_name
.buffer
, qualifier
);
3493 strncat (token_name
.buffer
,
3494 newlb
.buffer
+ tokoff
, toklen
);
3497 else if (objdef
== ocatseen
)
3498 /* Objective C category */
3500 int len
= strlen (objtag
) + 2 + toklen
;
3501 linebuffer_setlen (&token_name
, len
);
3502 strcpy (token_name
.buffer
, objtag
);
3503 strcat (token_name
.buffer
, "(");
3504 strncat (token_name
.buffer
,
3505 newlb
.buffer
+ tokoff
, toklen
);
3506 strcat (token_name
.buffer
, ")");
3509 else if (objdef
== omethodtag
3510 || objdef
== omethodparm
)
3511 /* Objective C method */
3515 else if (fvdef
== fdefunname
)
3516 /* GNU DEFUN and similar macros */
3518 bool defun
= (newlb
.buffer
[tokoff
] == 'F');
3522 /* Rewrite the tag so that emacs lisp DEFUNs
3523 can be found by their elisp name */
3530 linebuffer_setlen (&token_name
, len
);
3531 strncpy (token_name
.buffer
,
3532 newlb
.buffer
+ off
, len
);
3533 token_name
.buffer
[len
] = '\0';
3536 if (token_name
.buffer
[len
] == '_')
3537 token_name
.buffer
[len
] = '-';
3538 token
.named
= defun
;
3542 linebuffer_setlen (&token_name
, toklen
);
3543 strncpy (token_name
.buffer
,
3544 newlb
.buffer
+ tokoff
, toklen
);
3545 token_name
.buffer
[toklen
] = '\0';
3546 /* Name macros and members. */
3547 token
.named
= (structdef
== stagseen
3548 || typdef
== ttypeseen
3551 && definedef
== dignorerest
)
3553 && definedef
== dnone
3554 && structdef
== snone
3557 token
.lineno
= lineno
;
3558 token
.offset
= tokoff
;
3559 token
.length
= toklen
;
3560 token
.line
= newlb
.buffer
;
3561 token
.linepos
= newlinepos
;
3564 if (definedef
== dnone
3565 && (fvdef
== fvnameseen
3566 || fvdef
== foperator
3567 || structdef
== stagseen
3569 || typdef
== ttypeseen
3570 || objdef
!= onone
))
3572 if (current_lb_is_new
)
3573 switch_line_buffers ();
3575 else if (definedef
!= dnone
3576 || fvdef
== fdefunname
3578 make_C_tag (funorvar
);
3580 else /* not yacc and consider_token failed */
3582 if (inattribute
&& fvdef
== fignore
)
3584 /* We have just met __attribute__ after a
3585 function parameter list: do not tag the
3592 } /* if (endtoken (c)) */
3593 else if (intoken (c
))
3599 } /* if (midtoken) */
3600 else if (begtoken (c
))
3608 /* This prevents tagging fb in
3609 void (__attribute__((noreturn)) *fb) (void);
3610 Fixing this is not easy and not very important. */
3614 if (plainc
|| declarations
)
3616 make_C_tag (TRUE
); /* a function */
3621 if (structdef
== stagseen
&& !cjava
)
3623 popclass_above (bracelev
);
3631 if (!yacc_rules
|| lp
== newlb
.buffer
+ 1)
3633 tokoff
= lp
- 1 - newlb
.buffer
;
3638 } /* if (begtoken) */
3639 } /* if must look at token */
3642 /* Detect end of line, colon, comma, semicolon and various braces
3643 after having handled a token.*/
3649 if (yacc_rules
&& token
.offset
== 0 && token
.valid
)
3651 make_C_tag (FALSE
); /* a yacc function */
3654 if (definedef
!= dnone
)
3660 make_C_tag (TRUE
); /* an Objective C class */
3664 objdef
= omethodcolon
;
3665 linebuffer_setlen (&token_name
, token_name
.len
+ 1);
3666 strcat (token_name
.buffer
, ":");
3669 if (structdef
== stagseen
)
3671 structdef
= scolonseen
;
3674 /* Should be useless, but may be work as a safety net. */
3675 if (cplpl
&& fvdef
== flistseen
)
3677 make_C_tag (TRUE
); /* a function */
3683 if (definedef
!= dnone
|| inattribute
)
3689 make_C_tag (FALSE
); /* a typedef */
3699 if (typdef
== tignore
|| cplpl
)
3703 if ((globals
&& bracelev
== 0 && (!fvextern
|| declarations
))
3704 || (members
&& instruct
))
3705 make_C_tag (FALSE
); /* a variable */
3708 token
.valid
= FALSE
;
3712 && (cplpl
|| !instruct
)
3713 && (typdef
== tnone
|| (typdef
!= tignore
&& instruct
)))
3715 && plainc
&& instruct
))
3716 make_C_tag (TRUE
); /* a function */
3722 && cplpl
&& structdef
== stagseen
)
3723 make_C_tag (FALSE
); /* forward declaration */
3725 token
.valid
= FALSE
;
3726 } /* switch (fvdef) */
3732 if (structdef
== stagseen
)
3736 if (definedef
!= dnone
|| inattribute
)
3742 make_C_tag (TRUE
); /* an Objective C method */
3763 && (!fvextern
|| declarations
))
3764 || (members
&& instruct
)))
3765 make_C_tag (FALSE
); /* a variable */
3768 if ((declarations
&& typdef
== tnone
&& !instruct
)
3769 || (members
&& typdef
!= tignore
&& instruct
))
3771 make_C_tag (TRUE
); /* a function */
3774 else if (!declarations
)
3776 token
.valid
= FALSE
;
3781 if (structdef
== stagseen
)
3785 if (definedef
!= dnone
|| inattribute
)
3787 if (structdef
== stagseen
)
3794 make_C_tag (FALSE
); /* a typedef */
3806 if ((members
&& bracelev
== 1)
3807 || (globals
&& bracelev
== 0
3808 && (!fvextern
|| declarations
)))
3809 make_C_tag (FALSE
); /* a variable */
3823 if (definedef
!= dnone
)
3825 if (objdef
== otagseen
&& parlev
== 0)
3826 objdef
= oparenseen
;
3830 if (typdef
== ttypeseen
3834 /* This handles constructs like:
3835 typedef void OperatorFun (int fun); */
3854 if (--attrparlev
== 0)
3855 inattribute
= FALSE
;
3858 if (definedef
!= dnone
)
3860 if (objdef
== ocatseen
&& parlev
== 1)
3862 make_C_tag (TRUE
); /* an Objective C category */
3876 || typdef
== ttypeseen
))
3879 make_C_tag (FALSE
); /* a typedef */
3882 else if (parlev
< 0) /* can happen due to ill-conceived #if's. */
3886 if (definedef
!= dnone
)
3888 if (typdef
== ttypeseen
)
3890 /* Whenever typdef is set to tinbody (currently only
3891 here), typdefbracelev should be set to bracelev. */
3893 typdefbracelev
= bracelev
;
3898 make_C_tag (TRUE
); /* a function */
3907 make_C_tag (TRUE
); /* an Objective C class */
3912 make_C_tag (TRUE
); /* an Objective C method */
3916 /* Neutralize `extern "C" {' grot. */
3917 if (bracelev
== 0 && structdef
== snone
&& nestlev
== 0
3925 case skeyseen
: /* unnamed struct */
3926 pushclass_above (bracelev
, NULL
, 0);
3929 case stagseen
: /* named struct or enum */
3930 case scolonseen
: /* a class */
3931 pushclass_above (bracelev
,token
.line
+token
.offset
, token
.length
);
3933 make_C_tag (FALSE
); /* a struct or enum */
3939 if (definedef
!= dnone
)
3941 if (fvdef
== fstartlist
)
3943 fvdef
= fvnone
; /* avoid tagging `foo' in `foo (*bar()) ()' */
3944 token
.valid
= FALSE
;
3948 if (definedef
!= dnone
)
3950 if (!ignoreindent
&& lp
== newlb
.buffer
+ 1)
3953 token
.valid
= FALSE
;
3954 bracelev
= 0; /* reset brace level if first column */
3955 parlev
= 0; /* also reset paren level, just in case... */
3957 else if (bracelev
> 0)
3960 token
.valid
= FALSE
; /* something gone amiss, token unreliable */
3961 popclass_above (bracelev
);
3963 /* Only if typdef == tinbody is typdefbracelev significant. */
3964 if (typdef
== tinbody
&& bracelev
<= typdefbracelev
)
3966 assert (bracelev
== typdefbracelev
);
3971 if (definedef
!= dnone
)
3981 if ((members
&& bracelev
== 1)
3982 || (globals
&& bracelev
== 0 && (!fvextern
|| declarations
)))
3983 make_C_tag (FALSE
); /* a variable */
3991 && (structdef
== stagseen
|| fvdef
== fvnameseen
))
3998 if (templatelev
> 0)
4006 if (objdef
== oinbody
&& bracelev
== 0)
4008 objdef
= omethodsign
;
4013 case '#': case '~': case '&': case '%': case '/':
4014 case '|': case '^': case '!': case '.': case '?':
4015 if (definedef
!= dnone
)
4017 /* These surely cannot follow a function tag in C. */
4030 if (objdef
== otagseen
)
4032 make_C_tag (TRUE
); /* an Objective C class */
4035 /* If a macro spans multiple lines don't reset its state. */
4037 CNL_SAVE_DEFINEDEF ();
4043 } /* while not eof */
4045 free (lbs
[0].lb
.buffer
);
4046 free (lbs
[1].lb
.buffer
);
4050 * Process either a C++ file or a C file depending on the setting
4054 default_C_entries (inf
)
4057 C_entries (cplusplus
? C_PLPL
: C_AUTO
, inf
);
4060 /* Always do plain C. */
4062 plain_C_entries (inf
)
4068 /* Always do C++. */
4070 Cplusplus_entries (inf
)
4073 C_entries (C_PLPL
, inf
);
4076 /* Always do Java. */
4081 C_entries (C_JAVA
, inf
);
4089 C_entries (C_STAR
, inf
);
4092 /* Always do Yacc. */
4097 C_entries (YACC
, inf
);
4101 /* Useful macros. */
4102 #define LOOP_ON_INPUT_LINES(file_pointer, line_buffer, char_pointer) \
4103 for (; /* loop initialization */ \
4104 !feof (file_pointer) /* loop test */ \
4105 && /* instructions at start of loop */ \
4106 (readline (&line_buffer, file_pointer), \
4107 char_pointer = line_buffer.buffer, \
4111 #define LOOKING_AT(cp, kw) /* kw is the keyword, a literal string */ \
4112 ((assert("" kw), TRUE) /* syntax error if not a literal string */ \
4113 && strneq ((cp), kw, sizeof(kw)-1) /* cp points at kw */ \
4114 && notinname ((cp)[sizeof(kw)-1]) /* end of kw */ \
4115 && ((cp) = skip_spaces((cp)+sizeof(kw)-1))) /* skip spaces */
4117 /* Similar to LOOKING_AT but does not use notinname, does not skip */
4118 #define LOOKING_AT_NOCASE(cp, kw) /* the keyword is a literal string */ \
4119 ((assert("" kw), TRUE) /* syntax error if not a literal string */ \
4120 && strncaseeq ((cp), kw, sizeof(kw)-1) /* cp points at kw */ \
4121 && ((cp) += sizeof(kw)-1)) /* skip spaces */
4124 * Read a file, but do no processing. This is used to do regexp
4125 * matching on files that have no language defined.
4128 just_read_file (inf
)
4131 register char *dummy
;
4133 LOOP_ON_INPUT_LINES (inf
, lb
, dummy
)
4138 /* Fortran parsing */
4140 static void F_takeprec
__P((void));
4141 static void F_getit
__P((FILE *));
4146 dbp
= skip_spaces (dbp
);
4150 dbp
= skip_spaces (dbp
);
4151 if (strneq (dbp
, "(*)", 3))
4156 if (!ISDIGIT (*dbp
))
4158 --dbp
; /* force failure */
4163 while (ISDIGIT (*dbp
));
4172 dbp
= skip_spaces (dbp
);
4175 readline (&lb
, inf
);
4180 dbp
= skip_spaces (dbp
);
4182 if (!ISALPHA (*dbp
) && *dbp
!= '_' && *dbp
!= '$')
4184 for (cp
= dbp
+ 1; *cp
!= '\0' && intoken (*cp
); cp
++)
4186 make_tag (dbp
, cp
-dbp
, TRUE
,
4187 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4192 Fortran_functions (inf
)
4195 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4198 dbp
++; /* Ratfor escape to fortran */
4199 dbp
= skip_spaces (dbp
);
4202 switch (lowcase (*dbp
))
4205 if (nocase_tail ("integer"))
4209 if (nocase_tail ("real"))
4213 if (nocase_tail ("logical"))
4217 if (nocase_tail ("complex") || nocase_tail ("character"))
4221 if (nocase_tail ("double"))
4223 dbp
= skip_spaces (dbp
);
4226 if (nocase_tail ("precision"))
4232 dbp
= skip_spaces (dbp
);
4235 switch (lowcase (*dbp
))
4238 if (nocase_tail ("function"))
4242 if (nocase_tail ("subroutine"))
4246 if (nocase_tail ("entry"))
4250 if (nocase_tail ("blockdata") || nocase_tail ("block data"))
4252 dbp
= skip_spaces (dbp
);
4253 if (*dbp
== '\0') /* assume un-named */
4254 make_tag ("blockdata", 9, TRUE
,
4255 lb
.buffer
, dbp
- lb
.buffer
, lineno
, linecharno
);
4257 F_getit (inf
); /* look for name */
4268 * Philippe Waroquiers (1998)
4271 static void Ada_getit
__P((FILE *, char *));
4273 /* Once we are positioned after an "interesting" keyword, let's get
4274 the real tag value necessary. */
4276 Ada_getit (inf
, name_qualifier
)
4278 char *name_qualifier
;
4286 dbp
= skip_spaces (dbp
);
4288 || (dbp
[0] == '-' && dbp
[1] == '-'))
4290 readline (&lb
, inf
);
4293 switch (lowcase(*dbp
))
4296 if (nocase_tail ("body"))
4298 /* Skipping body of procedure body or package body or ....
4299 resetting qualifier to body instead of spec. */
4300 name_qualifier
= "/b";
4305 /* Skipping type of task type or protected type ... */
4306 if (nocase_tail ("type"))
4313 for (cp
= dbp
; *cp
!= '\0' && *cp
!= '"'; cp
++)
4318 dbp
= skip_spaces (dbp
);
4321 && (ISALPHA (*cp
) || ISDIGIT (*cp
) || *cp
== '_' || *cp
== '.'));
4329 name
= concat (dbp
, name_qualifier
, "");
4331 make_tag (name
, strlen (name
), TRUE
,
4332 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4344 bool inquote
= FALSE
;
4345 bool skip_till_semicolumn
= FALSE
;
4347 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4349 while (*dbp
!= '\0')
4351 /* Skip a string i.e. "abcd". */
4352 if (inquote
|| (*dbp
== '"'))
4354 dbp
= etags_strchr ((inquote
) ? dbp
: dbp
+1, '"');
4359 continue; /* advance char */
4364 break; /* advance line */
4368 /* Skip comments. */
4369 if (dbp
[0] == '-' && dbp
[1] == '-')
4370 break; /* advance line */
4372 /* Skip character enclosed in single quote i.e. 'a'
4373 and skip single quote starting an attribute i.e. 'Image. */
4382 if (skip_till_semicolumn
)
4385 skip_till_semicolumn
= FALSE
;
4387 continue; /* advance char */
4390 /* Search for beginning of a token. */
4391 if (!begtoken (*dbp
))
4394 continue; /* advance char */
4397 /* We are at the beginning of a token. */
4398 switch (lowcase(*dbp
))
4401 if (!packages_only
&& nocase_tail ("function"))
4402 Ada_getit (inf
, "/f");
4404 break; /* from switch */
4405 continue; /* advance char */
4407 if (!packages_only
&& nocase_tail ("procedure"))
4408 Ada_getit (inf
, "/p");
4409 else if (nocase_tail ("package"))
4410 Ada_getit (inf
, "/s");
4411 else if (nocase_tail ("protected")) /* protected type */
4412 Ada_getit (inf
, "/t");
4414 break; /* from switch */
4415 continue; /* advance char */
4418 if (typedefs
&& !packages_only
&& nocase_tail ("use"))
4420 /* when tagging types, avoid tagging use type Pack.Typename;
4421 for this, we will skip everything till a ; */
4422 skip_till_semicolumn
= TRUE
;
4423 continue; /* advance char */
4427 if (!packages_only
&& nocase_tail ("task"))
4428 Ada_getit (inf
, "/k");
4429 else if (typedefs
&& !packages_only
&& nocase_tail ("type"))
4431 Ada_getit (inf
, "/t");
4432 while (*dbp
!= '\0')
4436 break; /* from switch */
4437 continue; /* advance char */
4440 /* Look for the end of the token. */
4441 while (!endtoken (*dbp
))
4444 } /* advance char */
4445 } /* advance line */
4450 * Unix and microcontroller assembly tag handling
4451 * Labels: /^[a-zA-Z_.$][a-zA_Z0-9_.$]*[: ^I^J]/
4452 * Idea by Bob Weiner, Motorola Inc. (1994)
4460 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4462 /* If first char is alphabetic or one of [_.$], test for colon
4463 following identifier. */
4464 if (ISALPHA (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4466 /* Read past label. */
4468 while (ISALNUM (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4470 if (*cp
== ':' || iswhite (*cp
))
4471 /* Found end of label, so copy it and add it to the table. */
4472 make_tag (lb
.buffer
, cp
- lb
.buffer
, TRUE
,
4473 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4481 * Perl sub names: /^sub[ \t\n]+[^ \t\n{]+/
4482 * Perl variable names: /^(my|local).../
4483 * Original code by Bart Robinson <lomew@cs.utah.edu> (1995)
4484 * Additions by Michael Ernst <mernst@alum.mit.edu> (1997)
4485 * Ideas by Kai Großjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE> (2001)
4488 Perl_functions (inf
)
4491 char *package
= savestr ("main"); /* current package name */
4494 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4498 if (LOOKING_AT (cp
, "package"))
4501 get_tag (cp
, &package
);
4503 else if (LOOKING_AT (cp
, "sub"))
4508 while (!notinname (*cp
))
4511 continue; /* nothing found */
4512 if ((pos
= etags_strchr (sp
, ':')) != NULL
4513 && pos
< cp
&& pos
[1] == ':')
4514 /* The name is already qualified. */
4515 make_tag (sp
, cp
- sp
, TRUE
,
4516 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4520 char savechar
, *name
;
4524 name
= concat (package
, "::", sp
);
4526 make_tag (name
, strlen(name
), TRUE
,
4527 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4531 else if (globals
) /* only if we are tagging global vars */
4533 /* Skip a qualifier, if any. */
4534 bool qual
= LOOKING_AT (cp
, "my") || LOOKING_AT (cp
, "local");
4535 /* After "my" or "local", but before any following paren or space. */
4536 char *varstart
= cp
;
4538 if (qual
/* should this be removed? If yes, how? */
4539 && (*cp
== '$' || *cp
== '@' || *cp
== '%'))
4544 while (ISALNUM (*cp
) || *cp
== '_');
4548 /* Should be examining a variable list at this point;
4549 could insist on seeing an open parenthesis. */
4550 while (*cp
!= '\0' && *cp
!= ';' && *cp
!= '=' && *cp
!= ')')
4556 make_tag (varstart
, cp
- varstart
, FALSE
,
4557 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4566 * Look for /^[\t]*def[ \t\n]+[^ \t\n(:]+/ or /^class[ \t\n]+[^ \t\n(:]+/
4567 * Idea by Eric S. Raymond <esr@thyrsus.com> (1997)
4568 * More ideas by seb bacon <seb@jamkit.com> (2002)
4571 Python_functions (inf
)
4576 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4578 cp
= skip_spaces (cp
);
4579 if (LOOKING_AT (cp
, "def") || LOOKING_AT (cp
, "class"))
4582 while (!notinname (*cp
) && *cp
!= ':')
4584 make_tag (name
, cp
- name
, TRUE
,
4585 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4594 * - /^[ \t]*function[ \t\n]+[^ \t\n(]+/
4595 * - /^[ \t]*class[ \t\n]+[^ \t\n]+/
4596 * - /^[ \t]*define\(\"[^\"]+/
4597 * Only with --members:
4598 * - /^[ \t]*var[ \t\n]+\$[^ \t\n=;]/
4599 * Idea by Diez B. Roggisch (2001)
4605 register char *cp
, *name
;
4606 bool search_identifier
= FALSE
;
4608 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4610 cp
= skip_spaces (cp
);
4612 if (search_identifier
4615 while (!notinname (*cp
))
4617 make_tag (name
, cp
- name
, TRUE
,
4618 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4619 search_identifier
= FALSE
;
4621 else if (LOOKING_AT (cp
, "function"))
4624 cp
= skip_spaces (cp
+1);
4628 while (!notinname (*cp
))
4630 make_tag (name
, cp
- name
, TRUE
,
4631 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4634 search_identifier
= TRUE
;
4636 else if (LOOKING_AT (cp
, "class"))
4641 while (*cp
!= '\0' && !iswhite (*cp
))
4643 make_tag (name
, cp
- name
, FALSE
,
4644 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4647 search_identifier
= TRUE
;
4649 else if (strneq (cp
, "define", 6)
4650 && (cp
= skip_spaces (cp
+6))
4652 && (*cp
== '"' || *cp
== '\''))
4656 while (*cp
!= quote
&& *cp
!= '\0')
4658 make_tag (name
, cp
- name
, FALSE
,
4659 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4662 && LOOKING_AT (cp
, "var")
4666 while (!notinname(*cp
))
4668 make_tag (name
, cp
- name
, FALSE
,
4669 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4676 * Cobol tag functions
4677 * We could look for anything that could be a paragraph name.
4678 * i.e. anything that starts in column 8 is one word and ends in a full stop.
4679 * Idea by Corny de Souza (1993)
4682 Cobol_paragraphs (inf
)
4685 register char *bp
, *ep
;
4687 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4693 /* If eoln, compiler option or comment ignore whole line. */
4694 if (bp
[-1] != ' ' || !ISALNUM (bp
[0]))
4697 for (ep
= bp
; ISALNUM (*ep
) || *ep
== '-'; ep
++)
4700 make_tag (bp
, ep
- bp
, TRUE
,
4701 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4708 * Ideas by Assar Westerlund <assar@sics.se> (2001)
4711 Makefile_targets (inf
)
4716 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4718 if (*bp
== '\t' || *bp
== '#')
4720 while (*bp
!= '\0' && *bp
!= '=' && *bp
!= ':')
4722 if (*bp
== ':' || (globals
&& *bp
== '='))
4723 make_tag (lb
.buffer
, bp
- lb
.buffer
, TRUE
,
4724 lb
.buffer
, bp
- lb
.buffer
+ 1, lineno
, linecharno
);
4731 * Original code by Mosur K. Mohan (1989)
4733 * Locates tags for procedures & functions. Doesn't do any type- or
4734 * var-definitions. It does look for the keyword "extern" or
4735 * "forward" immediately following the procedure statement; if found,
4736 * the tag is skipped.
4739 Pascal_functions (inf
)
4742 linebuffer tline
; /* mostly copied from C_entries */
4744 int save_lineno
, namelen
, taglen
;
4747 bool /* each of these flags is TRUE iff: */
4748 incomment
, /* point is inside a comment */
4749 inquote
, /* point is inside '..' string */
4750 get_tagname
, /* point is after PROCEDURE/FUNCTION
4751 keyword, so next item = potential tag */
4752 found_tag
, /* point is after a potential tag */
4753 inparms
, /* point is within parameter-list */
4754 verify_tag
; /* point has passed the parm-list, so the
4755 next token will determine whether this
4756 is a FORWARD/EXTERN to be ignored, or
4757 whether it is a real tag */
4759 save_lcno
= save_lineno
= namelen
= taglen
= 0; /* keep compiler quiet */
4760 name
= NULL
; /* keep compiler quiet */
4763 linebuffer_init (&tline
);
4765 incomment
= inquote
= FALSE
;
4766 found_tag
= FALSE
; /* have a proc name; check if extern */
4767 get_tagname
= FALSE
; /* found "procedure" keyword */
4768 inparms
= FALSE
; /* found '(' after "proc" */
4769 verify_tag
= FALSE
; /* check if "extern" is ahead */
4772 while (!feof (inf
)) /* long main loop to get next char */
4775 if (c
== '\0') /* if end of line */
4777 readline (&lb
, inf
);
4781 if (!((found_tag
&& verify_tag
)
4783 c
= *dbp
++; /* only if don't need *dbp pointing
4784 to the beginning of the name of
4785 the procedure or function */
4789 if (c
== '}') /* within { } comments */
4791 else if (c
== '*' && *dbp
== ')') /* within (* *) comments */
4808 inquote
= TRUE
; /* found first quote */
4810 case '{': /* found open { comment */
4814 if (*dbp
== '*') /* found open (* comment */
4819 else if (found_tag
) /* found '(' after tag, i.e., parm-list */
4822 case ')': /* end of parms list */
4827 if (found_tag
&& !inparms
) /* end of proc or fn stmt */
4834 if (found_tag
&& verify_tag
&& (*dbp
!= ' '))
4836 /* Check if this is an "extern" declaration. */
4839 if (lowcase (*dbp
== 'e'))
4841 if (nocase_tail ("extern")) /* superfluous, really! */
4847 else if (lowcase (*dbp
) == 'f')
4849 if (nocase_tail ("forward")) /* check for forward reference */
4855 if (found_tag
&& verify_tag
) /* not external proc, so make tag */
4859 make_tag (name
, namelen
, TRUE
,
4860 tline
.buffer
, taglen
, save_lineno
, save_lcno
);
4864 if (get_tagname
) /* grab name of proc or fn */
4871 /* Find block name. */
4872 for (cp
= dbp
+ 1; *cp
!= '\0' && !endtoken (*cp
); cp
++)
4875 /* Save all values for later tagging. */
4876 linebuffer_setlen (&tline
, lb
.len
);
4877 strcpy (tline
.buffer
, lb
.buffer
);
4878 save_lineno
= lineno
;
4879 save_lcno
= linecharno
;
4880 name
= tline
.buffer
+ (dbp
- lb
.buffer
);
4882 taglen
= cp
- lb
.buffer
+ 1;
4884 dbp
= cp
; /* set dbp to e-o-token */
4885 get_tagname
= FALSE
;
4889 /* And proceed to check for "extern". */
4891 else if (!incomment
&& !inquote
&& !found_tag
)
4893 /* Check for proc/fn keywords. */
4894 switch (lowcase (c
))
4897 if (nocase_tail ("rocedure")) /* c = 'p', dbp has advanced */
4901 if (nocase_tail ("unction"))
4906 } /* while not eof */
4908 free (tline
.buffer
);
4913 * Lisp tag functions
4914 * look for (def or (DEF, quote or QUOTE
4917 static void L_getit
__P((void));
4922 if (*dbp
== '\'') /* Skip prefix quote */
4924 else if (*dbp
== '(')
4927 /* Try to skip "(quote " */
4928 if (!LOOKING_AT (dbp
, "quote") && !LOOKING_AT (dbp
, "QUOTE"))
4929 /* Ok, then skip "(" before name in (defstruct (foo)) */
4930 dbp
= skip_spaces (dbp
);
4932 get_tag (dbp
, NULL
);
4936 Lisp_functions (inf
)
4939 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4944 if (strneq (dbp
+1, "def", 3) || strneq (dbp
+1, "DEF", 3))
4946 dbp
= skip_non_spaces (dbp
);
4947 dbp
= skip_spaces (dbp
);
4952 /* Check for (foo::defmumble name-defined ... */
4955 while (!notinname (*dbp
) && *dbp
!= ':');
4960 while (*dbp
== ':');
4962 if (strneq (dbp
, "def", 3) || strneq (dbp
, "DEF", 3))
4964 dbp
= skip_non_spaces (dbp
);
4965 dbp
= skip_spaces (dbp
);
4975 * Lua script language parsing
4976 * Original code by David A. Capello <dacap@users.sourceforge.net> (2004)
4978 * "function" and "local function" are tags if they start at column 1.
4986 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4988 if (bp
[0] != 'f' && bp
[0] != 'l')
4991 LOOKING_AT (bp
, "local"); /* skip possible "local" */
4993 if (LOOKING_AT (bp
, "function"))
5001 * Just look for lines where the first character is '/'
5002 * Also look at "defineps" for PSWrap
5004 * Richard Mlynarik <mly@adoc.xerox.com> (1997)
5005 * Masatake Yamato <masata-y@is.aist-nara.ac.jp> (1999)
5011 register char *bp
, *ep
;
5013 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5018 *ep
!= '\0' && *ep
!= ' ' && *ep
!= '{';
5021 make_tag (bp
, ep
- bp
, TRUE
,
5022 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
5024 else if (LOOKING_AT (bp
, "defineps"))
5032 * Ignore anything after \ followed by space or in ( )
5033 * Look for words defined by :
5034 * Look for constant, code, create, defer, value, and variable
5035 * OBP extensions: Look for buffer:, field,
5036 * Ideas by Eduardo Horvath <eeh@netbsd.org> (2004)
5044 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5045 while ((bp
= skip_spaces (bp
))[0] != '\0')
5046 if (bp
[0] == '\\' && iswhite(bp
[1]))
5047 break; /* read next line */
5048 else if (bp
[0] == '(' && iswhite(bp
[1]))
5049 do /* skip to ) or eol */
5051 while (*bp
!= ')' && *bp
!= '\0');
5052 else if ((bp
[0] == ':' && iswhite(bp
[1]) && bp
++)
5053 || LOOKING_AT_NOCASE (bp
, "constant")
5054 || LOOKING_AT_NOCASE (bp
, "code")
5055 || LOOKING_AT_NOCASE (bp
, "create")
5056 || LOOKING_AT_NOCASE (bp
, "defer")
5057 || LOOKING_AT_NOCASE (bp
, "value")
5058 || LOOKING_AT_NOCASE (bp
, "variable")
5059 || LOOKING_AT_NOCASE (bp
, "buffer:")
5060 || LOOKING_AT_NOCASE (bp
, "field"))
5061 get_tag (skip_spaces (bp
), NULL
); /* Yay! A definition! */
5063 bp
= skip_non_spaces (bp
);
5068 * Scheme tag functions
5069 * look for (def... xyzzy
5071 * (def ... ((...(xyzzy ....
5073 * Original code by Ken Haase (1985?)
5076 Scheme_functions (inf
)
5081 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5083 if (strneq (bp
, "(def", 4) || strneq (bp
, "(DEF", 4))
5085 bp
= skip_non_spaces (bp
+4);
5086 /* Skip over open parens and white space */
5087 while (notinname (*bp
))
5091 if (LOOKING_AT (bp
, "(SET!") || LOOKING_AT (bp
, "(set!"))
5097 /* Find tags in TeX and LaTeX input files. */
5099 /* TEX_toktab is a table of TeX control sequences that define tags.
5100 * Each entry records one such control sequence.
5102 * Original code from who knows whom.
5104 * Stefan Monnier (2002)
5107 static linebuffer
*TEX_toktab
= NULL
; /* Table with tag tokens */
5109 /* Default set of control sequences to put into TEX_toktab.
5110 The value of environment var TEXTAGS is prepended to this. */
5111 static char *TEX_defenv
= "\
5112 :chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem\
5113 :part:appendix:entry:index:def\
5114 :newcommand:renewcommand:newenvironment:renewenvironment";
5116 static void TEX_mode
__P((FILE *));
5117 static void TEX_decode_env
__P((char *, char *));
5119 static char TEX_esc
= '\\';
5120 static char TEX_opgrp
= '{';
5121 static char TEX_clgrp
= '}';
5124 * TeX/LaTeX scanning loop.
5133 /* Select either \ or ! as escape character. */
5136 /* Initialize token table once from environment. */
5137 if (TEX_toktab
== NULL
)
5138 TEX_decode_env ("TEXTAGS", TEX_defenv
);
5140 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5142 /* Look at each TEX keyword in line. */
5145 /* Look for a TEX escape. */
5146 while (*cp
++ != TEX_esc
)
5147 if (cp
[-1] == '\0' || cp
[-1] == '%')
5150 for (key
= TEX_toktab
; key
->buffer
!= NULL
; key
++)
5151 if (strneq (cp
, key
->buffer
, key
->len
))
5154 int namelen
, linelen
;
5157 cp
= skip_spaces (cp
+ key
->len
);
5158 if (*cp
== TEX_opgrp
)
5164 (!iswhite (*p
) && *p
!= '#' &&
5165 *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
);
5170 if (!opgrp
|| *p
== TEX_clgrp
)
5172 while (*p
!= '\0' && *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
)
5174 linelen
= p
- lb
.buffer
+ 1;
5176 make_tag (cp
, namelen
, TRUE
,
5177 lb
.buffer
, linelen
, lineno
, linecharno
);
5178 goto tex_next_line
; /* We only tag a line once */
5186 #define TEX_LESC '\\'
5187 #define TEX_SESC '!'
5189 /* Figure out whether TeX's escapechar is '\\' or '!' and set grouping
5190 chars accordingly. */
5197 while ((c
= getc (inf
)) != EOF
)
5199 /* Skip to next line if we hit the TeX comment char. */
5203 else if (c
== TEX_LESC
|| c
== TEX_SESC
)
5219 /* If the input file is compressed, inf is a pipe, and rewind may fail.
5220 No attempt is made to correct the situation. */
5224 /* Read environment and prepend it to the default string.
5225 Build token table. */
5227 TEX_decode_env (evarname
, defenv
)
5231 register char *env
, *p
;
5234 /* Append default string to environment. */
5235 env
= getenv (evarname
);
5241 env
= concat (oldenv
, defenv
, "");
5244 /* Allocate a token table */
5245 for (len
= 1, p
= env
; p
;)
5246 if ((p
= etags_strchr (p
, ':')) && *++p
!= '\0')
5248 TEX_toktab
= xnew (len
, linebuffer
);
5250 /* Unpack environment string into token table. Be careful about */
5251 /* zero-length strings (leading ':', "::" and trailing ':') */
5252 for (i
= 0; *env
!= '\0';)
5254 p
= etags_strchr (env
, ':');
5255 if (!p
) /* End of environment string. */
5256 p
= env
+ strlen (env
);
5258 { /* Only non-zero strings. */
5259 TEX_toktab
[i
].buffer
= savenstr (env
, p
- env
);
5260 TEX_toktab
[i
].len
= p
- env
;
5267 TEX_toktab
[i
].buffer
= NULL
; /* Mark end of table. */
5268 TEX_toktab
[i
].len
= 0;
5275 /* Texinfo support. Dave Love, Mar. 2000. */
5281 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5282 if (LOOKING_AT (cp
, "@node"))
5285 while (*cp
!= '\0' && *cp
!= ',')
5287 make_tag (start
, cp
- start
, TRUE
,
5288 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
5295 * Contents of <title>, <h1>, <h2>, <h3> are tags.
5296 * Contents of <a name=xxx> are tags with name xxx.
5298 * Francesco Potortì, 2002.
5304 bool getnext
= FALSE
; /* next text outside of HTML tags is a tag */
5305 bool skiptag
= FALSE
; /* skip to the end of the current HTML tag */
5306 bool intag
= FALSE
; /* inside an html tag, looking for ID= */
5307 bool inanchor
= FALSE
; /* when INTAG, is an anchor, look for NAME= */
5311 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5313 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
5314 for (;;) /* loop on the same line */
5316 if (skiptag
) /* skip HTML tag */
5318 while (*dbp
!= '\0' && *dbp
!= '>')
5324 continue; /* look on the same line */
5326 break; /* go to next line */
5329 else if (intag
) /* look for "name=" or "id=" */
5331 while (*dbp
!= '\0' && *dbp
!= '>'
5332 && lowcase (*dbp
) != 'n' && lowcase (*dbp
) != 'i')
5335 break; /* go to next line */
5340 continue; /* look on the same line */
5342 if ((inanchor
&& LOOKING_AT_NOCASE (dbp
, "name="))
5343 || LOOKING_AT_NOCASE (dbp
, "id="))
5345 bool quoted
= (dbp
[0] == '"');
5348 for (end
= ++dbp
; *end
!= '\0' && *end
!= '"'; end
++)
5351 for (end
= dbp
; *end
!= '\0' && intoken (*end
); end
++)
5353 linebuffer_setlen (&token_name
, end
- dbp
);
5354 strncpy (token_name
.buffer
, dbp
, end
- dbp
);
5355 token_name
.buffer
[end
- dbp
] = '\0';
5358 intag
= FALSE
; /* we found what we looked for */
5359 skiptag
= TRUE
; /* skip to the end of the tag */
5360 getnext
= TRUE
; /* then grab the text */
5361 continue; /* look on the same line */
5366 else if (getnext
) /* grab next tokens and tag them */
5368 dbp
= skip_spaces (dbp
);
5370 break; /* go to next line */
5374 inanchor
= (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]));
5375 continue; /* look on the same line */
5378 for (end
= dbp
+ 1; *end
!= '\0' && *end
!= '<'; end
++)
5380 make_tag (token_name
.buffer
, token_name
.len
, TRUE
,
5381 dbp
, end
- dbp
, lineno
, linecharno
);
5382 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5384 break; /* go to next line */
5387 else /* look for an interesting HTML tag */
5389 while (*dbp
!= '\0' && *dbp
!= '<')
5392 break; /* go to next line */
5394 if (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]))
5397 continue; /* look on the same line */
5399 else if (LOOKING_AT_NOCASE (dbp
, "<title>")
5400 || LOOKING_AT_NOCASE (dbp
, "<h1>")
5401 || LOOKING_AT_NOCASE (dbp
, "<h2>")
5402 || LOOKING_AT_NOCASE (dbp
, "<h3>"))
5406 continue; /* look on the same line */
5417 * Assumes that the predicate or rule starts at column 0.
5418 * Only the first clause of a predicate or rule is added.
5419 * Original code by Sunichirou Sugou (1989)
5420 * Rewritten by Anders Lindgren (1996)
5422 static int prolog_pr
__P((char *, char *));
5423 static void prolog_skip_comment
__P((linebuffer
*, FILE *));
5424 static int prolog_atom
__P((char *, int));
5427 Prolog_functions (inf
)
5438 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5440 if (cp
[0] == '\0') /* Empty line */
5442 else if (iswhite (cp
[0])) /* Not a predicate */
5444 else if (cp
[0] == '/' && cp
[1] == '*') /* comment. */
5445 prolog_skip_comment (&lb
, inf
);
5446 else if ((len
= prolog_pr (cp
, last
)) > 0)
5448 /* Predicate or rule. Store the function name so that we
5449 only generate a tag for the first clause. */
5451 last
= xnew(len
+ 1, char);
5452 else if (len
+ 1 > allocated
)
5453 xrnew (last
, len
+ 1, char);
5454 allocated
= len
+ 1;
5455 strncpy (last
, cp
, len
);
5465 prolog_skip_comment (plb
, inf
)
5473 for (cp
= plb
->buffer
; *cp
!= '\0'; cp
++)
5474 if (cp
[0] == '*' && cp
[1] == '/')
5476 readline (plb
, inf
);
5482 * A predicate or rule definition is added if it matches:
5483 * <beginning of line><Prolog Atom><whitespace>(
5484 * or <beginning of line><Prolog Atom><whitespace>:-
5486 * It is added to the tags database if it doesn't match the
5487 * name of the previous clause header.
5489 * Return the size of the name of the predicate or rule, or 0 if no
5495 char *last
; /* Name of last clause. */
5500 pos
= prolog_atom (s
, 0);
5505 pos
= skip_spaces (s
+ pos
) - s
;
5508 || (s
[pos
] == '(' && (pos
+= 1))
5509 || (s
[pos
] == ':' && s
[pos
+ 1] == '-' && (pos
+= 2)))
5510 && (last
== NULL
/* save only the first clause */
5511 || len
!= (int)strlen (last
)
5512 || !strneq (s
, last
, len
)))
5514 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5522 * Consume a Prolog atom.
5523 * Return the number of bytes consumed, or -1 if there was an error.
5525 * A prolog atom, in this context, could be one of:
5526 * - An alphanumeric sequence, starting with a lower case letter.
5527 * - A quoted arbitrary string. Single quotes can escape themselves.
5528 * Backslash quotes everything.
5531 prolog_atom (s
, pos
)
5539 if (ISLOWER(s
[pos
]) || (s
[pos
] == '_'))
5541 /* The atom is unquoted. */
5543 while (ISALNUM(s
[pos
]) || (s
[pos
] == '_'))
5547 return pos
- origpos
;
5549 else if (s
[pos
] == '\'')
5560 pos
++; /* A double quote */
5562 else if (s
[pos
] == '\0')
5563 /* Multiline quoted atoms are ignored. */
5565 else if (s
[pos
] == '\\')
5567 if (s
[pos
+1] == '\0')
5574 return pos
- origpos
;
5582 * Support for Erlang
5584 * Generates tags for functions, defines, and records.
5585 * Assumes that Erlang functions start at column 0.
5586 * Original code by Anders Lindgren (1996)
5588 static int erlang_func
__P((char *, char *));
5589 static void erlang_attribute
__P((char *));
5590 static int erlang_atom
__P((char *));
5593 Erlang_functions (inf
)
5604 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5606 if (cp
[0] == '\0') /* Empty line */
5608 else if (iswhite (cp
[0])) /* Not function nor attribute */
5610 else if (cp
[0] == '%') /* comment */
5612 else if (cp
[0] == '"') /* Sometimes, strings start in column one */
5614 else if (cp
[0] == '-') /* attribute, e.g. "-define" */
5616 erlang_attribute (cp
);
5623 else if ((len
= erlang_func (cp
, last
)) > 0)
5626 * Function. Store the function name so that we only
5627 * generates a tag for the first clause.
5630 last
= xnew (len
+ 1, char);
5631 else if (len
+ 1 > allocated
)
5632 xrnew (last
, len
+ 1, char);
5633 allocated
= len
+ 1;
5634 strncpy (last
, cp
, len
);
5644 * A function definition is added if it matches:
5645 * <beginning of line><Erlang Atom><whitespace>(
5647 * It is added to the tags database if it doesn't match the
5648 * name of the previous clause header.
5650 * Return the size of the name of the function, or 0 if no function
5654 erlang_func (s
, last
)
5656 char *last
; /* Name of last clause. */
5661 pos
= erlang_atom (s
);
5666 pos
= skip_spaces (s
+ pos
) - s
;
5668 /* Save only the first clause. */
5671 || len
!= (int)strlen (last
)
5672 || !strneq (s
, last
, len
)))
5674 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5683 * Handle attributes. Currently, tags are generated for defines
5686 * They are on the form:
5687 * -define(foo, bar).
5688 * -define(Foo(M, N), M+N).
5689 * -record(graph, {vtab = notable, cyclic = true}).
5692 erlang_attribute (s
)
5697 if ((LOOKING_AT (cp
, "-define") || LOOKING_AT (cp
, "-record"))
5700 int len
= erlang_atom (skip_spaces (cp
));
5702 make_tag (cp
, len
, TRUE
, s
, cp
+ len
- s
, lineno
, linecharno
);
5709 * Consume an Erlang atom (or variable).
5710 * Return the number of bytes consumed, or -1 if there was an error.
5718 if (ISALPHA (s
[pos
]) || s
[pos
] == '_')
5720 /* The atom is unquoted. */
5723 while (ISALNUM (s
[pos
]) || s
[pos
] == '_');
5725 else if (s
[pos
] == '\'')
5727 for (pos
++; s
[pos
] != '\''; pos
++)
5728 if (s
[pos
] == '\0' /* multiline quoted atoms are ignored */
5729 || (s
[pos
] == '\\' && s
[++pos
] == '\0'))
5738 #ifdef ETAGS_REGEXPS
5740 static char *scan_separators
__P((char *));
5741 static void add_regex
__P((char *, language
*));
5742 static char *substitute
__P((char *, char *, struct re_registers
*));
5745 * Take a string like "/blah/" and turn it into "blah", verifying
5746 * that the first and last characters are the same, and handling
5747 * quoted separator characters. Actually, stops on the occurrence of
5748 * an unquoted separator. Also process \t, \n, etc. and turn into
5749 * appropriate characters. Works in place. Null terminates name string.
5750 * Returns pointer to terminating separator, or NULL for
5751 * unterminated regexps.
5754 scan_separators (name
)
5758 char *copyto
= name
;
5759 bool quoted
= FALSE
;
5761 for (++name
; *name
!= '\0'; ++name
)
5767 case 'a': *copyto
++ = '\007'; break; /* BEL (bell) */
5768 case 'b': *copyto
++ = '\b'; break; /* BS (back space) */
5769 case 'd': *copyto
++ = 0177; break; /* DEL (delete) */
5770 case 'e': *copyto
++ = 033; break; /* ESC (delete) */
5771 case 'f': *copyto
++ = '\f'; break; /* FF (form feed) */
5772 case 'n': *copyto
++ = '\n'; break; /* NL (new line) */
5773 case 'r': *copyto
++ = '\r'; break; /* CR (carriage return) */
5774 case 't': *copyto
++ = '\t'; break; /* TAB (horizontal tab) */
5775 case 'v': *copyto
++ = '\v'; break; /* VT (vertical tab) */
5781 /* Something else is quoted, so preserve the quote. */
5789 else if (*name
== '\\')
5791 else if (*name
== sep
)
5797 name
= NULL
; /* signal unterminated regexp */
5799 /* Terminate copied string. */
5804 /* Look at the argument of --regex or --no-regex and do the right
5805 thing. Same for each line of a regexp file. */
5807 analyse_regex (regex_arg
)
5810 if (regex_arg
== NULL
)
5812 free_regexps (); /* --no-regex: remove existing regexps */
5816 /* A real --regexp option or a line in a regexp file. */
5817 switch (regex_arg
[0])
5819 /* Comments in regexp file or null arg to --regex. */
5825 /* Read a regex file. This is recursive and may result in a
5826 loop, which will stop when the file descriptors are exhausted. */
5830 linebuffer regexbuf
;
5831 char *regexfile
= regex_arg
+ 1;
5833 /* regexfile is a file containing regexps, one per line. */
5834 regexfp
= fopen (regexfile
, "r");
5835 if (regexfp
== NULL
)
5840 linebuffer_init (®exbuf
);
5841 while (readline_internal (®exbuf
, regexfp
) > 0)
5842 analyse_regex (regexbuf
.buffer
);
5843 free (regexbuf
.buffer
);
5848 /* Regexp to be used for a specific language only. */
5852 char *lang_name
= regex_arg
+ 1;
5855 for (cp
= lang_name
; *cp
!= '}'; cp
++)
5858 error ("unterminated language name in regex: %s", regex_arg
);
5862 lang
= get_language_from_langname (lang_name
);
5865 add_regex (cp
, lang
);
5869 /* Regexp to be used for any language. */
5871 add_regex (regex_arg
, NULL
);
5876 /* Separate the regexp pattern, compile it,
5877 and care for optional name and modifiers. */
5879 add_regex (regexp_pattern
, lang
)
5880 char *regexp_pattern
;
5883 static struct re_pattern_buffer zeropattern
;
5884 char sep
, *pat
, *name
, *modifiers
;
5886 struct re_pattern_buffer
*patbuf
;
5889 force_explicit_name
= TRUE
, /* do not use implicit tag names */
5890 ignore_case
= FALSE
, /* case is significant */
5891 multi_line
= FALSE
, /* matches are done one line at a time */
5892 single_line
= FALSE
; /* dot does not match newline */
5895 if (strlen(regexp_pattern
) < 3)
5897 error ("null regexp", (char *)NULL
);
5900 sep
= regexp_pattern
[0];
5901 name
= scan_separators (regexp_pattern
);
5904 error ("%s: unterminated regexp", regexp_pattern
);
5909 error ("null name for regexp \"%s\"", regexp_pattern
);
5912 modifiers
= scan_separators (name
);
5913 if (modifiers
== NULL
) /* no terminating separator --> no name */
5919 modifiers
+= 1; /* skip separator */
5921 /* Parse regex modifiers. */
5922 for (; modifiers
[0] != '\0'; modifiers
++)
5923 switch (modifiers
[0])
5926 if (modifiers
== name
)
5927 error ("forcing explicit tag name but no name, ignoring", NULL
);
5928 force_explicit_name
= TRUE
;
5938 need_filebuf
= TRUE
;
5943 wrongmod
[0] = modifiers
[0];
5945 error ("invalid regexp modifier `%s', ignoring", wrongmod
);
5950 patbuf
= xnew (1, struct re_pattern_buffer
);
5951 *patbuf
= zeropattern
;
5954 static char lc_trans
[CHARS
];
5956 for (i
= 0; i
< CHARS
; i
++)
5957 lc_trans
[i
] = lowcase (i
);
5958 patbuf
->translate
= lc_trans
; /* translation table to fold case */
5962 pat
= concat ("^", regexp_pattern
, ""); /* anchor to beginning of line */
5964 pat
= regexp_pattern
;
5967 re_set_syntax (RE_SYNTAX_EMACS
| RE_DOT_NEWLINE
);
5969 re_set_syntax (RE_SYNTAX_EMACS
);
5971 err
= re_compile_pattern (pat
, strlen (regexp_pattern
), patbuf
);
5976 error ("%s while compiling pattern", err
);
5981 p_head
= xnew (1, regexp
);
5982 p_head
->pattern
= savestr (regexp_pattern
);
5983 p_head
->p_next
= rp
;
5984 p_head
->lang
= lang
;
5985 p_head
->pat
= patbuf
;
5986 p_head
->name
= savestr (name
);
5987 p_head
->error_signaled
= FALSE
;
5988 p_head
->force_explicit_name
= force_explicit_name
;
5989 p_head
->ignore_case
= ignore_case
;
5990 p_head
->multi_line
= multi_line
;
5994 * Do the substitutions indicated by the regular expression and
5998 substitute (in
, out
, regs
)
6000 struct re_registers
*regs
;
6003 int size
, dig
, diglen
;
6006 size
= strlen (out
);
6008 /* Pass 1: figure out how much to allocate by finding all \N strings. */
6009 if (out
[size
- 1] == '\\')
6010 fatal ("pattern error in \"%s\"", out
);
6011 for (t
= etags_strchr (out
, '\\');
6013 t
= etags_strchr (t
+ 2, '\\'))
6017 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
6023 /* Allocate space and do the substitutions. */
6025 result
= xnew (size
+ 1, char);
6027 for (t
= result
; *out
!= '\0'; out
++)
6028 if (*out
== '\\' && ISDIGIT (*++out
))
6031 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
6032 strncpy (t
, in
+ regs
->start
[dig
], diglen
);
6039 assert (t
<= result
+ size
);
6040 assert (t
- result
== (int)strlen (result
));
6045 /* Deallocate all regexps. */
6050 while (p_head
!= NULL
)
6052 rp
= p_head
->p_next
;
6053 free (p_head
->pattern
);
6054 free (p_head
->name
);
6062 * Reads the whole file as a single string from `filebuf' and looks for
6063 * multi-line regular expressions, creating tags on matches.
6064 * readline already dealt with normal regexps.
6066 * Idea by Ben Wing <ben@666.com> (2002).
6069 regex_tag_multiline ()
6071 char *buffer
= filebuf
.buffer
;
6075 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6079 if (!rp
->multi_line
)
6080 continue; /* skip normal regexps */
6082 /* Generic initialisations before parsing file from memory. */
6083 lineno
= 1; /* reset global line number */
6084 charno
= 0; /* reset global char number */
6085 linecharno
= 0; /* reset global char number of line start */
6087 /* Only use generic regexps or those for the current language. */
6088 if (rp
->lang
!= NULL
&& rp
->lang
!= curfdp
->lang
)
6091 while (match
>= 0 && match
< filebuf
.len
)
6093 match
= re_search (rp
->pat
, buffer
, filebuf
.len
, charno
,
6094 filebuf
.len
- match
, &rp
->regs
);
6099 if (!rp
->error_signaled
)
6101 error ("regexp stack overflow while matching \"%s\"",
6103 rp
->error_signaled
= TRUE
;
6110 if (match
== rp
->regs
.end
[0])
6112 if (!rp
->error_signaled
)
6114 error ("regexp matches the empty string: \"%s\"",
6116 rp
->error_signaled
= TRUE
;
6118 match
= -3; /* exit from while loop */
6122 /* Match occurred. Construct a tag. */
6123 while (charno
< rp
->regs
.end
[0])
6124 if (buffer
[charno
++] == '\n')
6125 lineno
++, linecharno
= charno
;
6127 if (name
[0] == '\0')
6129 else /* make a named tag */
6130 name
= substitute (buffer
, rp
->name
, &rp
->regs
);
6131 if (rp
->force_explicit_name
)
6132 /* Force explicit tag name, if a name is there. */
6133 pfnote (name
, TRUE
, buffer
+ linecharno
,
6134 charno
- linecharno
+ 1, lineno
, linecharno
);
6136 make_tag (name
, strlen (name
), TRUE
, buffer
+ linecharno
,
6137 charno
- linecharno
+ 1, lineno
, linecharno
);
6144 #endif /* ETAGS_REGEXPS */
6151 register int len
= 0;
6153 while (*cp
!= '\0' && lowcase (*cp
) == lowcase (dbp
[len
]))
6155 if (*cp
== '\0' && !intoken (dbp
[len
]))
6164 get_tag (bp
, namepp
)
6168 register char *cp
= bp
;
6172 /* Go till you get to white space or a syntactic break */
6173 for (cp
= bp
+ 1; !notinname (*cp
); cp
++)
6175 make_tag (bp
, cp
- bp
, TRUE
,
6176 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
6180 *namepp
= savenstr (bp
, cp
- bp
);
6184 * Read a line of text from `stream' into `lbp', excluding the
6185 * newline or CR-NL, if any. Return the number of characters read from
6186 * `stream', which is the length of the line including the newline.
6188 * On DOS or Windows we do not count the CR character, if any before the
6189 * NL, in the returned length; this mirrors the behavior of Emacs on those
6190 * platforms (for text files, it translates CR-NL to NL as it reads in the
6193 * If multi-line regular expressions are requested, each line read is
6194 * appended to `filebuf'.
6197 readline_internal (lbp
, stream
)
6199 register FILE *stream
;
6201 char *buffer
= lbp
->buffer
;
6202 register char *p
= lbp
->buffer
;
6203 register char *pend
;
6206 pend
= p
+ lbp
->size
; /* Separate to avoid 386/IX compiler bug. */
6210 register int c
= getc (stream
);
6213 /* We're at the end of linebuffer: expand it. */
6215 xrnew (buffer
, lbp
->size
, char);
6216 p
+= buffer
- lbp
->buffer
;
6217 pend
= buffer
+ lbp
->size
;
6218 lbp
->buffer
= buffer
;
6228 if (p
> buffer
&& p
[-1] == '\r')
6232 /* Assume CRLF->LF translation will be performed by Emacs
6233 when loading this file, so CRs won't appear in the buffer.
6234 It would be cleaner to compensate within Emacs;
6235 however, Emacs does not know how many CRs were deleted
6236 before any given point in the file. */
6251 lbp
->len
= p
- buffer
;
6253 if (need_filebuf
/* we need filebuf for multi-line regexps */
6254 && chars_deleted
> 0) /* not at EOF */
6256 while (filebuf
.size
<= filebuf
.len
+ lbp
->len
+ 1) /* +1 for \n */
6258 /* Expand filebuf. */
6260 xrnew (filebuf
.buffer
, filebuf
.size
, char);
6262 strncpy (filebuf
.buffer
+ filebuf
.len
, lbp
->buffer
, lbp
->len
);
6263 filebuf
.len
+= lbp
->len
;
6264 filebuf
.buffer
[filebuf
.len
++] = '\n';
6265 filebuf
.buffer
[filebuf
.len
] = '\0';
6268 return lbp
->len
+ chars_deleted
;
6272 * Like readline_internal, above, but in addition try to match the
6273 * input line against relevant regular expressions and manage #line
6277 readline (lbp
, stream
)
6283 linecharno
= charno
; /* update global char number of line start */
6284 result
= readline_internal (lbp
, stream
); /* read line */
6285 lineno
+= 1; /* increment global line number */
6286 charno
+= result
; /* increment global char number */
6288 /* Honour #line directives. */
6289 if (!no_line_directive
)
6291 static bool discard_until_line_directive
;
6293 /* Check whether this is a #line directive. */
6294 if (result
> 12 && strneq (lbp
->buffer
, "#line ", 6))
6298 if (DEBUG
) start
= 0; /* shut up the compiler */
6299 if (sscanf (lbp
->buffer
, "#line %d \"%n", &lno
, &start
) == 1)
6301 char *endp
= lbp
->buffer
+ start
;
6304 while ((endp
= etags_strchr (endp
, '"')) != NULL
6305 && endp
[-1] == '\\')
6308 /* Ok, this is a real #line directive. Let's deal with it. */
6310 char *taggedabsname
; /* absolute name of original file */
6311 char *taggedfname
; /* name of original file as given */
6312 char *name
; /* temp var */
6314 discard_until_line_directive
= FALSE
; /* found it */
6315 name
= lbp
->buffer
+ start
;
6317 canonicalize_filename (name
); /* for DOS */
6318 taggedabsname
= absolute_filename (name
, curfdp
->infabsdir
);
6319 if (filename_is_absolute (name
)
6320 || filename_is_absolute (curfdp
->infname
))
6321 taggedfname
= savestr (taggedabsname
);
6323 taggedfname
= relative_filename (taggedabsname
,tagfiledir
);
6325 if (streq (curfdp
->taggedfname
, taggedfname
))
6326 /* The #line directive is only a line number change. We
6327 deal with this afterwards. */
6330 /* The tags following this #line directive should be
6331 attributed to taggedfname. In order to do this, set
6332 curfdp accordingly. */
6334 fdesc
*fdp
; /* file description pointer */
6336 /* Go look for a file description already set up for the
6337 file indicated in the #line directive. If there is
6338 one, use it from now until the next #line
6340 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6341 if (streq (fdp
->infname
, curfdp
->infname
)
6342 && streq (fdp
->taggedfname
, taggedfname
))
6343 /* If we remove the second test above (after the &&)
6344 then all entries pertaining to the same file are
6345 coalesced in the tags file. If we use it, then
6346 entries pertaining to the same file but generated
6347 from different files (via #line directives) will
6348 go into separate sections in the tags file. These
6349 alternatives look equivalent. The first one
6350 destroys some apparently useless information. */
6356 /* Else, if we already tagged the real file, skip all
6357 input lines until the next #line directive. */
6358 if (fdp
== NULL
) /* not found */
6359 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6360 if (streq (fdp
->infabsname
, taggedabsname
))
6362 discard_until_line_directive
= TRUE
;
6366 /* Else create a new file description and use that from
6367 now on, until the next #line directive. */
6368 if (fdp
== NULL
) /* not found */
6371 fdhead
= xnew (1, fdesc
);
6372 *fdhead
= *curfdp
; /* copy curr. file description */
6374 fdhead
->infname
= savestr (curfdp
->infname
);
6375 fdhead
->infabsname
= savestr (curfdp
->infabsname
);
6376 fdhead
->infabsdir
= savestr (curfdp
->infabsdir
);
6377 fdhead
->taggedfname
= taggedfname
;
6378 fdhead
->usecharno
= FALSE
;
6379 fdhead
->prop
= NULL
;
6380 fdhead
->written
= FALSE
;
6384 free (taggedabsname
);
6386 readline (lbp
, stream
);
6388 } /* if a real #line directive */
6389 } /* if #line is followed by a a number */
6390 } /* if line begins with "#line " */
6392 /* If we are here, no #line directive was found. */
6393 if (discard_until_line_directive
)
6397 /* Do a tail recursion on ourselves, thus discarding the contents
6398 of the line buffer. */
6399 readline (lbp
, stream
);
6403 discard_until_line_directive
= FALSE
;
6406 } /* if #line directives should be considered */
6408 #ifdef ETAGS_REGEXPS
6414 /* Match against relevant regexps. */
6416 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6418 /* Only use generic regexps or those for the current language.
6419 Also do not use multiline regexps, which is the job of
6420 regex_tag_multiline. */
6421 if ((rp
->lang
!= NULL
&& rp
->lang
!= fdhead
->lang
)
6425 match
= re_match (rp
->pat
, lbp
->buffer
, lbp
->len
, 0, &rp
->regs
);
6430 if (!rp
->error_signaled
)
6432 error ("regexp stack overflow while matching \"%s\"",
6434 rp
->error_signaled
= TRUE
;
6441 /* Empty string matched. */
6442 if (!rp
->error_signaled
)
6444 error ("regexp matches the empty string: \"%s\"", rp
->pattern
);
6445 rp
->error_signaled
= TRUE
;
6449 /* Match occurred. Construct a tag. */
6451 if (name
[0] == '\0')
6453 else /* make a named tag */
6454 name
= substitute (lbp
->buffer
, rp
->name
, &rp
->regs
);
6455 if (rp
->force_explicit_name
)
6456 /* Force explicit tag name, if a name is there. */
6457 pfnote (name
, TRUE
, lbp
->buffer
, match
, lineno
, linecharno
);
6459 make_tag (name
, strlen (name
), TRUE
,
6460 lbp
->buffer
, match
, lineno
, linecharno
);
6465 #endif /* ETAGS_REGEXPS */
6470 * Return a pointer to a space of size strlen(cp)+1 allocated
6471 * with xnew where the string CP has been copied.
6477 return savenstr (cp
, strlen (cp
));
6481 * Return a pointer to a space of size LEN+1 allocated with xnew where
6482 * the string CP has been copied for at most the first LEN characters.
6491 dp
= xnew (len
+ 1, char);
6492 strncpy (dp
, cp
, len
);
6498 * Return the ptr in sp at which the character c last
6499 * appears; NULL if not found
6501 * Identical to POSIX strrchr, included for portability.
6504 etags_strrchr (sp
, c
)
6505 register const char *sp
;
6508 register const char *r
;
6520 * Return the ptr in sp at which the character c first
6521 * appears; NULL if not found
6523 * Identical to POSIX strchr, included for portability.
6526 etags_strchr (sp
, c
)
6527 register const char *sp
;
6539 * Compare two strings, ignoring case for alphabetic characters.
6541 * Same as BSD's strcasecmp, included for portability.
6544 etags_strcasecmp (s1
, s2
)
6545 register const char *s1
;
6546 register const char *s2
;
6549 && (ISALPHA (*s1
) && ISALPHA (*s2
)
6550 ? lowcase (*s1
) == lowcase (*s2
)
6554 return (ISALPHA (*s1
) && ISALPHA (*s2
)
6555 ? lowcase (*s1
) - lowcase (*s2
)
6560 * Compare two strings, ignoring case for alphabetic characters.
6561 * Stop after a given number of characters
6563 * Same as BSD's strncasecmp, included for portability.
6566 etags_strncasecmp (s1
, s2
, n
)
6567 register const char *s1
;
6568 register const char *s2
;
6571 while (*s1
!= '\0' && n
-- > 0
6572 && (ISALPHA (*s1
) && ISALPHA (*s2
)
6573 ? lowcase (*s1
) == lowcase (*s2
)
6580 return (ISALPHA (*s1
) && ISALPHA (*s2
)
6581 ? lowcase (*s1
) - lowcase (*s2
)
6585 /* Skip spaces (end of string is not space), return new pointer. */
6590 while (iswhite (*cp
))
6595 /* Skip non spaces, except end of string, return new pointer. */
6597 skip_non_spaces (cp
)
6600 while (*cp
!= '\0' && !iswhite (*cp
))
6605 /* Print error message and exit. */
6611 exit (EXIT_FAILURE
);
6619 exit (EXIT_FAILURE
);
6623 suggest_asking_for_help ()
6625 fprintf (stderr
, "\tTry `%s %s' for a complete list of options.\n",
6626 progname
, LONG_OPTIONS
? "--help" : "-h");
6627 exit (EXIT_FAILURE
);
6630 /* Print error message. `s1' is printf control string, `s2' is arg for it. */
6633 const char *s1
, *s2
;
6635 fprintf (stderr
, "%s: ", progname
);
6636 fprintf (stderr
, s1
, s2
);
6637 fprintf (stderr
, "\n");
6640 /* Return a newly-allocated string whose contents
6641 concatenate those of s1, s2, s3. */
6646 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
6647 char *result
= xnew (len1
+ len2
+ len3
+ 1, char);
6649 strcpy (result
, s1
);
6650 strcpy (result
+ len1
, s2
);
6651 strcpy (result
+ len1
+ len2
, s3
);
6652 result
[len1
+ len2
+ len3
] = '\0';
6658 /* Does the same work as the system V getcwd, but does not need to
6659 guess the buffer size in advance. */
6665 char *path
= xnew (bufsize
, char);
6667 while (getcwd (path
, bufsize
) == NULL
)
6669 if (errno
!= ERANGE
)
6673 path
= xnew (bufsize
, char);
6676 canonicalize_filename (path
);
6679 #else /* not HAVE_GETCWD */
6682 char *p
, path
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
6686 for (p
= path
; *p
!= '\0'; p
++)
6692 return strdup (path
);
6693 #else /* not MSDOS */
6697 linebuffer_init (&path
);
6698 pipe
= (FILE *) popen ("pwd 2>/dev/null", "r");
6699 if (pipe
== NULL
|| readline_internal (&path
, pipe
) == 0)
6704 #endif /* not MSDOS */
6705 #endif /* not HAVE_GETCWD */
6708 /* Return a newly allocated string containing the file name of FILE
6709 relative to the absolute directory DIR (which should end with a slash). */
6711 relative_filename (file
, dir
)
6714 char *fp
, *dp
, *afn
, *res
;
6717 /* Find the common root of file and dir (with a trailing slash). */
6718 afn
= absolute_filename (file
, cwd
);
6721 while (*fp
++ == *dp
++)
6723 fp
--, dp
--; /* back to the first differing char */
6725 if (fp
== afn
&& afn
[0] != '/') /* cannot build a relative name */
6728 do /* look at the equal chars until '/' */
6732 /* Build a sequence of "../" strings for the resulting relative file name. */
6734 while ((dp
= etags_strchr (dp
+ 1, '/')) != NULL
)
6736 res
= xnew (3*i
+ strlen (fp
+ 1) + 1, char);
6739 strcat (res
, "../");
6741 /* Add the file name relative to the common root of file and dir. */
6742 strcat (res
, fp
+ 1);
6748 /* Return a newly allocated string containing the absolute file name
6749 of FILE given DIR (which should end with a slash). */
6751 absolute_filename (file
, dir
)
6754 char *slashp
, *cp
, *res
;
6756 if (filename_is_absolute (file
))
6757 res
= savestr (file
);
6759 /* We don't support non-absolute file names with a drive
6760 letter, like `d:NAME' (it's too much hassle). */
6761 else if (file
[1] == ':')
6762 fatal ("%s: relative file names with drive letters not supported", file
);
6765 res
= concat (dir
, file
, "");
6767 /* Delete the "/dirname/.." and "/." substrings. */
6768 slashp
= etags_strchr (res
, '/');
6769 while (slashp
!= NULL
&& slashp
[0] != '\0')
6771 if (slashp
[1] == '.')
6773 if (slashp
[2] == '.'
6774 && (slashp
[3] == '/' || slashp
[3] == '\0'))
6779 while (cp
>= res
&& !filename_is_absolute (cp
));
6781 cp
= slashp
; /* the absolute name begins with "/.." */
6783 /* Under MSDOS and NT we get `d:/NAME' as absolute
6784 file name, so the luser could say `d:/../NAME'.
6785 We silently treat this as `d:/NAME'. */
6786 else if (cp
[0] != '/')
6789 strcpy (cp
, slashp
+ 3);
6793 else if (slashp
[2] == '/' || slashp
[2] == '\0')
6795 strcpy (slashp
, slashp
+ 2);
6800 slashp
= etags_strchr (slashp
+ 1, '/');
6803 if (res
[0] == '\0') /* just a safety net: should never happen */
6806 return savestr ("/");
6812 /* Return a newly allocated string containing the absolute
6813 file name of dir where FILE resides given DIR (which should
6814 end with a slash). */
6816 absolute_dirname (file
, dir
)
6822 canonicalize_filename (file
);
6823 slashp
= etags_strrchr (file
, '/');
6825 return savestr (dir
);
6828 res
= absolute_filename (file
, dir
);
6834 /* Whether the argument string is an absolute file name. The argument
6835 string must have been canonicalized with canonicalize_filename. */
6837 filename_is_absolute (fn
)
6840 return (fn
[0] == '/'
6842 || (ISALPHA(fn
[0]) && fn
[1] == ':' && fn
[2] == '/')
6847 /* Translate backslashes into slashes. Works in place. */
6849 canonicalize_filename (fn
)
6853 /* Canonicalize drive letter case. */
6854 if (fn
[0] != '\0' && fn
[1] == ':' && ISLOWER (fn
[0]))
6855 fn
[0] = upcase (fn
[0]);
6856 /* Convert backslashes to slashes. */
6857 for (; *fn
!= '\0'; fn
++)
6862 fn
= NULL
; /* shut up the compiler */
6867 /* Initialize a linebuffer for use */
6869 linebuffer_init (lbp
)
6872 lbp
->size
= (DEBUG
) ? 3 : 200;
6873 lbp
->buffer
= xnew (lbp
->size
, char);
6874 lbp
->buffer
[0] = '\0';
6878 /* Set the minimum size of a string contained in a linebuffer. */
6880 linebuffer_setlen (lbp
, toksize
)
6884 while (lbp
->size
<= toksize
)
6887 xrnew (lbp
->buffer
, lbp
->size
, char);
6892 /* Like malloc but get fatal error if memory is exhausted. */
6897 PTR result
= (PTR
) malloc (size
);
6899 fatal ("virtual memory exhausted", (char *)NULL
);
6904 xrealloc (ptr
, size
)
6908 PTR result
= (PTR
) realloc (ptr
, size
);
6910 fatal ("virtual memory exhausted", (char *)NULL
);
6916 * indent-tabs-mode: t
6919 * c-font-lock-extra-types: ("FILE" "bool" "language" "linebuffer" "fdesc" "node" "regexp")
6923 /* arch-tag: 8a9b748d-390c-4922-99db-2eeefa921051
6924 (do not change this comment) */
6926 /* etags.c ends here */