1 /* Tags file maker to go with GNU Emacs -*- coding: latin-1 -*-
3 Copyright (C) 1984 The Regents of the University of California
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are
8 1. Redistributions of source code must retain the above copyright
9 notice, this list of conditions and the following disclaimer.
10 2. Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the
14 3. Neither the name of the University nor the names of its
15 contributors may be used to endorse or promote products derived
16 from this software without specific prior written permission.
18 THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS''
19 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS
22 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
27 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
28 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 Copyright (C) 1984, 1987, 1988, 1989, 1993, 1994, 1995, 1998, 1999,
32 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
33 Free Software Foundation, Inc.
35 This file is not considered part of GNU Emacs.
37 This program is free software: you can redistribute it and/or modify
38 it under the terms of the GNU General Public License as published by
39 the Free Software Foundation, either version 3 of the License, or
40 (at your option) any later version.
42 This program is distributed in the hope that it will be useful,
43 but WITHOUT ANY WARRANTY; without even the implied warranty of
44 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
45 GNU General Public License for more details.
47 You should have received a copy of the GNU General Public License
48 along with this program. If not, see <http://www.gnu.org/licenses/>. */
51 /* NB To comply with the above BSD license, copyright information is
52 reproduced in etc/ETAGS.README. That file should be updated when the
55 To the best of our knowledge, this code was originally based on the
56 ctags.c distributed with BSD4.2, which was copyrighted by the
57 University of California, as described above. */
62 * 1983 Ctags originally by Ken Arnold.
63 * 1984 Fortran added by Jim Kleckner.
64 * 1984 Ed Pelegri-Llopart added C typedefs.
65 * 1985 Emacs TAGS format by Richard Stallman.
66 * 1989 Sam Kendall added C++.
67 * 1992 Joseph B. Wells improved C and C++ parsing.
68 * 1993 Francesco Potortì reorganized C and C++.
69 * 1994 Line-by-line regexp tags by Tom Tromey.
70 * 2001 Nested classes by Francesco Potortì (concept by Mykola Dzyuba).
71 * 2002 #line directives by Francesco Potortì.
73 * Francesco Potortì <pot@gnu.org> has maintained and improved it since 1993.
77 * If you want to add support for a new language, start by looking at the LUA
78 * language, which is the simplest. Alternatively, consider distributing etags
79 * together with a configuration file containing regexp definitions for etags.
82 char pot_etags_version
[] = "@(#) pot revision number is 17.38.1.3";
92 # define NDEBUG /* disable assert */
97 /* On some systems, Emacs defines static as nothing for the sake
98 of unexec. We don't want that here since we don't use unexec. */
100 # ifndef PTR /* for XEmacs */
103 # ifndef __P /* for XEmacs */
104 # define __P(args) args
106 #else /* no config.h */
107 # if defined(__STDC__) && (__STDC__ || defined(__SUNPRO_C))
108 # define __P(args) args /* use prototypes */
109 # define PTR void * /* for generic pointers */
110 # else /* not standard C */
111 # define __P(args) () /* no prototypes */
112 # define const /* remove const for old compilers' sake */
113 # define PTR long * /* don't use void* */
115 #endif /* !HAVE_CONFIG_H */
118 # define _GNU_SOURCE 1 /* enables some compiler checks on GNU */
121 /* WIN32_NATIVE is for XEmacs.
122 MSDOS, WINDOWSNT, DOS_NT are for Emacs. */
127 #endif /* WIN32_NATIVE */
133 # include <sys/param.h>
135 # ifndef HAVE_CONFIG_H
137 # include <sys/config.h>
149 # define MAXPATHLEN _MAX_PATH
155 # endif /* undef HAVE_GETCWD */
156 #else /* not WINDOWSNT */
160 # else /* no standard C headers */
161 extern char *getenv
__P((const char *));
162 extern char *strcpy
__P((char *, const char *));
163 extern char *strncpy
__P((char *, const char *, unsigned long));
164 extern char *strcat
__P((char *, const char *));
165 extern char *strncat
__P((char *, const char *, unsigned long));
166 extern int strcmp
__P((const char *, const char *));
167 extern int strncmp
__P((const char *, const char *, unsigned long));
168 extern int system
__P((const char *));
169 extern unsigned long strlen
__P((const char *));
170 extern void *malloc
__P((unsigned long));
171 extern void *realloc
__P((void *, unsigned long));
172 extern void exit
__P((int));
173 extern void free
__P((void *));
174 extern void *memmove
__P((void *, const void *, unsigned long));
175 # define EXIT_SUCCESS 0
176 # define EXIT_FAILURE 1
178 #endif /* !WINDOWSNT */
183 # if defined (HAVE_GETCWD) && !defined (WINDOWSNT)
184 extern char *getcwd (char *buf
, size_t size
);
186 #endif /* HAVE_UNISTD_H */
194 #include <sys/types.h>
195 #include <sys/stat.h>
199 # undef assert /* some systems have a buggy assert.h */
200 # define assert(x) ((void) 0)
203 #if !defined (S_ISREG) && defined (S_IFREG)
204 # define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
207 #ifdef NO_LONG_OPTIONS /* define this if you don't have GNU getopt */
208 # define NO_LONG_OPTIONS TRUE
209 # define getopt_long(argc,argv,optstr,lopts,lind) getopt (argc, argv, optstr)
211 extern int optind
, opterr
;
213 # define NO_LONG_OPTIONS FALSE
215 #endif /* NO_LONG_OPTIONS */
217 #ifndef HAVE_CONFIG_H /* this is a standalone compilation */
218 # ifdef __CYGWIN__ /* compiling on Cygwin */
220 the regex
.h distributed with Cygwin is
not compatible with etags
, alas
!
221 If you want regular expression support
, you should
delete this notice
and
222 arrange to use the GNU regex
.h
and regex
.c
.
227 /* Define CTAGS to make the program "ctags" compatible with the usual one.
228 Leave it undefined to make the program "etags", which makes emacs-style
229 tag tables and tags typedefs, #defines and struct/union/enum by default. */
237 #define streq(s,t) (assert((s)!=NULL || (t)!=NULL), !strcmp (s, t))
238 #define strcaseeq(s,t) (assert((s)!=NULL && (t)!=NULL), !etags_strcasecmp (s, t))
239 #define strneq(s,t,n) (assert((s)!=NULL || (t)!=NULL), !strncmp (s, t, n))
240 #define strncaseeq(s,t,n) (assert((s)!=NULL && (t)!=NULL), !etags_strncasecmp (s, t, n))
242 #define CHARS 256 /* 2^sizeof(char) */
243 #define CHAR(x) ((unsigned int)(x) & (CHARS - 1))
244 #define iswhite(c) (_wht[CHAR(c)]) /* c is white (see white) */
245 #define notinname(c) (_nin[CHAR(c)]) /* c is not in a name (see nonam) */
246 #define begtoken(c) (_btk[CHAR(c)]) /* c can start token (see begtk) */
247 #define intoken(c) (_itk[CHAR(c)]) /* c can be in token (see midtk) */
248 #define endtoken(c) (_etk[CHAR(c)]) /* c ends tokens (see endtk) */
250 #define ISALNUM(c) isalnum (CHAR(c))
251 #define ISALPHA(c) isalpha (CHAR(c))
252 #define ISDIGIT(c) isdigit (CHAR(c))
253 #define ISLOWER(c) islower (CHAR(c))
255 #define lowcase(c) tolower (CHAR(c))
256 #define upcase(c) toupper (CHAR(c))
260 * xnew, xrnew -- allocate, reallocate storage
262 * SYNOPSIS: Type *xnew (int n, Type);
263 * void xrnew (OldPointer, int n, Type);
266 # include "chkmalloc.h"
267 # define xnew(n,Type) ((Type *) trace_malloc (__FILE__, __LINE__, \
268 (n) * sizeof (Type)))
269 # define xrnew(op,n,Type) ((op) = (Type *) trace_realloc (__FILE__, __LINE__, \
270 (char *) (op), (n) * sizeof (Type)))
272 # define xnew(n,Type) ((Type *) xmalloc ((n) * sizeof (Type)))
273 # define xrnew(op,n,Type) ((op) = (Type *) xrealloc ( \
274 (char *) (op), (n) * sizeof (Type)))
279 typedef void Lang_function
__P((FILE *));
283 char *suffix
; /* file name suffix for this compressor */
284 char *command
; /* takes one arg and decompresses to stdout */
289 char *name
; /* language name */
290 char *help
; /* detailed help for the language */
291 Lang_function
*function
; /* parse function */
292 char **suffixes
; /* name suffixes of this language's files */
293 char **filenames
; /* names of this language's files */
294 char **interpreters
; /* interpreters for this language */
295 bool metasource
; /* source used to generate other sources */
300 struct fdesc
*next
; /* for the linked list */
301 char *infname
; /* uncompressed input file name */
302 char *infabsname
; /* absolute uncompressed input file name */
303 char *infabsdir
; /* absolute dir of input file */
304 char *taggedfname
; /* file name to write in tagfile */
305 language
*lang
; /* language of file */
306 char *prop
; /* file properties to write in tagfile */
307 bool usecharno
; /* etags tags shall contain char number */
308 bool written
; /* entry written in the tags file */
311 typedef struct node_st
312 { /* sorting structure */
313 struct node_st
*left
, *right
; /* left and right sons */
314 fdesc
*fdp
; /* description of file to whom tag belongs */
315 char *name
; /* tag name */
316 char *regex
; /* search regexp */
317 bool valid
; /* write this tag on the tag file */
318 bool is_func
; /* function tag: use regexp in CTAGS mode */
319 bool been_warned
; /* warning already given for duplicated tag */
320 int lno
; /* line number tag is on */
321 long cno
; /* character number line starts on */
325 * A `linebuffer' is a structure which holds a line of text.
326 * `readline_internal' reads a line from a stream into a linebuffer
327 * and works regardless of the length of the line.
328 * SIZE is the size of BUFFER, LEN is the length of the string in
329 * BUFFER after readline reads it.
338 /* Used to support mixing of --lang and file names. */
342 at_language
, /* a language specification */
343 at_regexp
, /* a regular expression */
344 at_filename
, /* a file name */
345 at_stdin
, /* read from stdin here */
346 at_end
/* stop parsing the list */
347 } arg_type
; /* argument type */
348 language
*lang
; /* language associated with the argument */
349 char *what
; /* the argument itself */
352 /* Structure defining a regular expression. */
353 typedef struct regexp
355 struct regexp
*p_next
; /* pointer to next in list */
356 language
*lang
; /* if set, use only for this language */
357 char *pattern
; /* the regexp pattern */
358 char *name
; /* tag name */
359 struct re_pattern_buffer
*pat
; /* the compiled pattern */
360 struct re_registers regs
; /* re registers */
361 bool error_signaled
; /* already signaled for this regexp */
362 bool force_explicit_name
; /* do not allow implict tag name */
363 bool ignore_case
; /* ignore case when matching */
364 bool multi_line
; /* do a multi-line match on the whole file */
368 /* Many compilers barf on this:
369 Lang_function Ada_funcs;
370 so let's write it this way */
371 static void Ada_funcs
__P((FILE *));
372 static void Asm_labels
__P((FILE *));
373 static void C_entries
__P((int c_ext
, FILE *));
374 static void default_C_entries
__P((FILE *));
375 static void plain_C_entries
__P((FILE *));
376 static void Cjava_entries
__P((FILE *));
377 static void Cobol_paragraphs
__P((FILE *));
378 static void Cplusplus_entries
__P((FILE *));
379 static void Cstar_entries
__P((FILE *));
380 static void Erlang_functions
__P((FILE *));
381 static void Forth_words
__P((FILE *));
382 static void Fortran_functions
__P((FILE *));
383 static void HTML_labels
__P((FILE *));
384 static void Lisp_functions
__P((FILE *));
385 static void Lua_functions
__P((FILE *));
386 static void Makefile_targets
__P((FILE *));
387 static void Pascal_functions
__P((FILE *));
388 static void Perl_functions
__P((FILE *));
389 static void PHP_functions
__P((FILE *));
390 static void PS_functions
__P((FILE *));
391 static void Prolog_functions
__P((FILE *));
392 static void Python_functions
__P((FILE *));
393 static void Scheme_functions
__P((FILE *));
394 static void TeX_commands
__P((FILE *));
395 static void Texinfo_nodes
__P((FILE *));
396 static void Yacc_entries
__P((FILE *));
397 static void just_read_file
__P((FILE *));
399 static void print_language_names
__P((void));
400 static void print_version
__P((void));
401 static void print_help
__P((argument
*));
402 int main
__P((int, char **));
404 static compressor
*get_compressor_from_suffix
__P((char *, char **));
405 static language
*get_language_from_langname
__P((const char *));
406 static language
*get_language_from_interpreter
__P((char *));
407 static language
*get_language_from_filename
__P((char *, bool));
408 static void readline
__P((linebuffer
*, FILE *));
409 static long readline_internal
__P((linebuffer
*, FILE *));
410 static bool nocase_tail
__P((char *));
411 static void get_tag
__P((char *, char **));
413 static void analyse_regex
__P((char *));
414 static void free_regexps
__P((void));
415 static void regex_tag_multiline
__P((void));
416 static void error
__P((const char *, const char *));
417 static void suggest_asking_for_help
__P((void));
418 void fatal
__P((char *, char *));
419 static void pfatal
__P((char *));
420 static void add_node
__P((node
*, node
**));
422 static void init
__P((void));
423 static void process_file_name
__P((char *, language
*));
424 static void process_file
__P((FILE *, char *, language
*));
425 static void find_entries
__P((FILE *));
426 static void free_tree
__P((node
*));
427 static void free_fdesc
__P((fdesc
*));
428 static void pfnote
__P((char *, bool, char *, int, int, long));
429 static void make_tag
__P((char *, int, bool, char *, int, int, long));
430 static void invalidate_nodes
__P((fdesc
*, node
**));
431 static void put_entries
__P((node
*));
433 static char *concat
__P((char *, char *, char *));
434 static char *skip_spaces
__P((char *));
435 static char *skip_non_spaces
__P((char *));
436 static char *savenstr
__P((char *, int));
437 static char *savestr
__P((char *));
438 static char *etags_strchr
__P((const char *, int));
439 static char *etags_strrchr
__P((const char *, int));
440 static int etags_strcasecmp
__P((const char *, const char *));
441 static int etags_strncasecmp
__P((const char *, const char *, int));
442 static char *etags_getcwd
__P((void));
443 static char *relative_filename
__P((char *, char *));
444 static char *absolute_filename
__P((char *, char *));
445 static char *absolute_dirname
__P((char *, char *));
446 static bool filename_is_absolute
__P((char *f
));
447 static void canonicalize_filename
__P((char *));
448 static void linebuffer_init
__P((linebuffer
*));
449 static void linebuffer_setlen
__P((linebuffer
*, int));
450 static PTR xmalloc
__P((unsigned int));
451 static PTR xrealloc
__P((char *, unsigned int));
454 static char searchar
= '/'; /* use /.../ searches */
456 static char *tagfile
; /* output file */
457 static char *progname
; /* name this program was invoked with */
458 static char *cwd
; /* current working directory */
459 static char *tagfiledir
; /* directory of tagfile */
460 static FILE *tagf
; /* ioptr for tags file */
462 static fdesc
*fdhead
; /* head of file description list */
463 static fdesc
*curfdp
; /* current file description */
464 static int lineno
; /* line number of current line */
465 static long charno
; /* current character number */
466 static long linecharno
; /* charno of start of current line */
467 static char *dbp
; /* pointer to start of current tag */
469 static const int invalidcharno
= -1;
471 static node
*nodehead
; /* the head of the binary tree of tags */
472 static node
*last_node
; /* the last node created */
474 static linebuffer lb
; /* the current line */
475 static linebuffer filebuf
; /* a buffer containing the whole file */
476 static linebuffer token_name
; /* a buffer containing a tag name */
478 /* boolean "functions" (see init) */
479 static bool _wht
[CHARS
], _nin
[CHARS
], _itk
[CHARS
], _btk
[CHARS
], _etk
[CHARS
];
482 *white
= " \f\t\n\r\v",
484 *nonam
= " \f\t\n\r()=,;", /* look at make_tag before modifying! */
485 /* token ending chars */
486 *endtk
= " \t\n\r\"'#()[]{}=-+%*/&|^~!<>;,.:?",
487 /* token starting chars */
488 *begtk
= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$~@",
489 /* valid in-token chars */
490 *midtk
= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$0123456789";
492 static bool append_to_tagfile
; /* -a: append to tags */
493 /* The next five default to TRUE in C and derived languages. */
494 static bool typedefs
; /* -t: create tags for C and Ada typedefs */
495 static bool typedefs_or_cplusplus
; /* -T: create tags for C typedefs, level */
496 /* 0 struct/enum/union decls, and C++ */
497 /* member functions. */
498 static bool constantypedefs
; /* -d: create tags for C #define, enum */
499 /* constants and variables. */
500 /* -D: opposite of -d. Default under ctags. */
501 static bool globals
; /* create tags for global variables */
502 static bool members
; /* create tags for C member variables */
503 static bool declarations
; /* --declarations: tag them and extern in C&Co*/
504 static bool no_line_directive
; /* ignore #line directives (undocumented) */
505 static bool no_duplicates
; /* no duplicate tags for ctags (undocumented) */
506 static bool update
; /* -u: update tags */
507 static bool vgrind_style
; /* -v: create vgrind style index output */
508 static bool no_warnings
; /* -w: suppress warnings (undocumented) */
509 static bool cxref_style
; /* -x: create cxref style output */
510 static bool cplusplus
; /* .[hc] means C++, not C (undocumented) */
511 static bool ignoreindent
; /* -I: ignore indentation in C */
512 static bool packages_only
; /* --packages-only: in Ada, only tag packages*/
514 /* STDIN is defined in LynxOS system headers */
519 #define STDIN 0x1001 /* returned by getopt_long on --parse-stdin */
520 static bool parsing_stdin
; /* --parse-stdin used */
522 static regexp
*p_head
; /* list of all regexps */
523 static bool need_filebuf
; /* some regexes are multi-line */
525 static struct option longopts
[] =
527 { "append", no_argument
, NULL
, 'a' },
528 { "packages-only", no_argument
, &packages_only
, TRUE
},
529 { "c++", no_argument
, NULL
, 'C' },
530 { "declarations", no_argument
, &declarations
, TRUE
},
531 { "no-line-directive", no_argument
, &no_line_directive
, TRUE
},
532 { "no-duplicates", no_argument
, &no_duplicates
, TRUE
},
533 { "help", no_argument
, NULL
, 'h' },
534 { "help", no_argument
, NULL
, 'H' },
535 { "ignore-indentation", no_argument
, NULL
, 'I' },
536 { "language", required_argument
, NULL
, 'l' },
537 { "members", no_argument
, &members
, TRUE
},
538 { "no-members", no_argument
, &members
, FALSE
},
539 { "output", required_argument
, NULL
, 'o' },
540 { "regex", required_argument
, NULL
, 'r' },
541 { "no-regex", no_argument
, NULL
, 'R' },
542 { "ignore-case-regex", required_argument
, NULL
, 'c' },
543 { "parse-stdin", required_argument
, NULL
, STDIN
},
544 { "version", no_argument
, NULL
, 'V' },
546 #if CTAGS /* Ctags options */
547 { "backward-search", no_argument
, NULL
, 'B' },
548 { "cxref", no_argument
, NULL
, 'x' },
549 { "defines", no_argument
, NULL
, 'd' },
550 { "globals", no_argument
, &globals
, TRUE
},
551 { "typedefs", no_argument
, NULL
, 't' },
552 { "typedefs-and-c++", no_argument
, NULL
, 'T' },
553 { "update", no_argument
, NULL
, 'u' },
554 { "vgrind", no_argument
, NULL
, 'v' },
555 { "no-warn", no_argument
, NULL
, 'w' },
557 #else /* Etags options */
558 { "no-defines", no_argument
, NULL
, 'D' },
559 { "no-globals", no_argument
, &globals
, FALSE
},
560 { "include", required_argument
, NULL
, 'i' },
565 static compressor compressors
[] =
567 { "z", "gzip -d -c"},
568 { "Z", "gzip -d -c"},
569 { "gz", "gzip -d -c"},
570 { "GZ", "gzip -d -c"},
571 { "bz2", "bzip2 -d -c" },
580 static char *Ada_suffixes
[] =
581 { "ads", "adb", "ada", NULL
};
582 static char Ada_help
[] =
583 "In Ada code, functions, procedures, packages, tasks and types are\n\
584 tags. Use the `--packages-only' option to create tags for\n\
586 Ada tag names have suffixes indicating the type of entity:\n\
587 Entity type: Qualifier:\n\
588 ------------ ----------\n\
595 Thus, `M-x find-tag <RET> bidule/b <RET>' will go directly to the\n\
596 body of the package `bidule', while `M-x find-tag <RET> bidule <RET>'\n\
597 will just search for any tag `bidule'.";
600 static char *Asm_suffixes
[] =
601 { "a", /* Unix assembler */
602 "asm", /* Microcontroller assembly */
603 "def", /* BSO/Tasking definition includes */
604 "inc", /* Microcontroller include files */
605 "ins", /* Microcontroller include files */
606 "s", "sa", /* Unix assembler */
607 "S", /* cpp-processed Unix assembler */
608 "src", /* BSO/Tasking C compiler output */
611 static char Asm_help
[] =
612 "In assembler code, labels appearing at the beginning of a line,\n\
613 followed by a colon, are tags.";
616 /* Note that .c and .h can be considered C++, if the --c++ flag was
617 given, or if the `class' or `template' keywords are met inside the file.
618 That is why default_C_entries is called for these. */
619 static char *default_C_suffixes
[] =
621 #if CTAGS /* C help for Ctags */
622 static char default_C_help
[] =
623 "In C code, any C function is a tag. Use -t to tag typedefs.\n\
624 Use -T to tag definitions of `struct', `union' and `enum'.\n\
625 Use -d to tag `#define' macro definitions and `enum' constants.\n\
626 Use --globals to tag global variables.\n\
627 You can tag function declarations and external variables by\n\
628 using `--declarations', and struct members by using `--members'.";
629 #else /* C help for Etags */
630 static char default_C_help
[] =
631 "In C code, any C function or typedef is a tag, and so are\n\
632 definitions of `struct', `union' and `enum'. `#define' macro\n\
633 definitions and `enum' constants are tags unless you specify\n\
634 `--no-defines'. Global variables are tags unless you specify\n\
635 `--no-globals' and so are struct members unless you specify\n\
636 `--no-members'. Use of `--no-globals', `--no-defines' and\n\
637 `--no-members' can make the tags table file much smaller.\n\
638 You can tag function declarations and external variables by\n\
639 using `--declarations'.";
640 #endif /* C help for Ctags and Etags */
642 static char *Cplusplus_suffixes
[] =
643 { "C", "c++", "cc", "cpp", "cxx", "H", "h++", "hh", "hpp", "hxx",
644 "M", /* Objective C++ */
645 "pdb", /* Postscript with C syntax */
647 static char Cplusplus_help
[] =
648 "In C++ code, all the tag constructs of C code are tagged. (Use\n\
649 --help --lang=c --lang=c++ for full help.)\n\
650 In addition to C tags, member functions are also recognized. Member\n\
651 variables are recognized unless you use the `--no-members' option.\n\
652 Tags for variables and functions in classes are named `CLASS::VARIABLE'\n\
653 and `CLASS::FUNCTION'. `operator' definitions have tag names like\n\
656 static char *Cjava_suffixes
[] =
658 static char Cjava_help
[] =
659 "In Java code, all the tags constructs of C and C++ code are\n\
660 tagged. (Use --help --lang=c --lang=c++ --lang=java for full help.)";
663 static char *Cobol_suffixes
[] =
664 { "COB", "cob", NULL
};
665 static char Cobol_help
[] =
666 "In Cobol code, tags are paragraph names; that is, any word\n\
667 starting in column 8 and followed by a period.";
669 static char *Cstar_suffixes
[] =
670 { "cs", "hs", NULL
};
672 static char *Erlang_suffixes
[] =
673 { "erl", "hrl", NULL
};
674 static char Erlang_help
[] =
675 "In Erlang code, the tags are the functions, records and macros\n\
676 defined in the file.";
678 char *Forth_suffixes
[] =
679 { "fth", "tok", NULL
};
680 static char Forth_help
[] =
681 "In Forth code, tags are words defined by `:',\n\
682 constant, code, create, defer, value, variable, buffer:, field.";
684 static char *Fortran_suffixes
[] =
685 { "F", "f", "f90", "for", NULL
};
686 static char Fortran_help
[] =
687 "In Fortran code, functions, subroutines and block data are tags.";
689 static char *HTML_suffixes
[] =
690 { "htm", "html", "shtml", NULL
};
691 static char HTML_help
[] =
692 "In HTML input files, the tags are the `title' and the `h1', `h2',\n\
693 `h3' headers. Also, tags are `name=' in anchors and all\n\
694 occurrences of `id='.";
696 static char *Lisp_suffixes
[] =
697 { "cl", "clisp", "el", "l", "lisp", "LSP", "lsp", "ml", NULL
};
698 static char Lisp_help
[] =
699 "In Lisp code, any function defined with `defun', any variable\n\
700 defined with `defvar' or `defconst', and in general the first\n\
701 argument of any expression that starts with `(def' in column zero\n\
704 static char *Lua_suffixes
[] =
705 { "lua", "LUA", NULL
};
706 static char Lua_help
[] =
707 "In Lua scripts, all functions are tags.";
709 static char *Makefile_filenames
[] =
710 { "Makefile", "makefile", "GNUMakefile", "Makefile.in", "Makefile.am", NULL
};
711 static char Makefile_help
[] =
712 "In makefiles, targets are tags; additionally, variables are tags\n\
713 unless you specify `--no-globals'.";
715 static char *Objc_suffixes
[] =
716 { "lm", /* Objective lex file */
717 "m", /* Objective C file */
719 static char Objc_help
[] =
720 "In Objective C code, tags include Objective C definitions for classes,\n\
721 class categories, methods and protocols. Tags for variables and\n\
722 functions in classes are named `CLASS::VARIABLE' and `CLASS::FUNCTION'.\n\
723 (Use --help --lang=c --lang=objc --lang=java for full help.)";
725 static char *Pascal_suffixes
[] =
726 { "p", "pas", NULL
};
727 static char Pascal_help
[] =
728 "In Pascal code, the tags are the functions and procedures defined\n\
730 /* " // this is for working around an Emacs highlighting bug... */
732 static char *Perl_suffixes
[] =
733 { "pl", "pm", NULL
};
734 static char *Perl_interpreters
[] =
735 { "perl", "@PERL@", NULL
};
736 static char Perl_help
[] =
737 "In Perl code, the tags are the packages, subroutines and variables\n\
738 defined by the `package', `sub', `my' and `local' keywords. Use\n\
739 `--globals' if you want to tag global variables. Tags for\n\
740 subroutines are named `PACKAGE::SUB'. The name for subroutines\n\
741 defined in the default package is `main::SUB'.";
743 static char *PHP_suffixes
[] =
744 { "php", "php3", "php4", NULL
};
745 static char PHP_help
[] =
746 "In PHP code, tags are functions, classes and defines. Unless you use\n\
747 the `--no-members' option, vars are tags too.";
749 static char *plain_C_suffixes
[] =
750 { "pc", /* Pro*C file */
753 static char *PS_suffixes
[] =
754 { "ps", "psw", NULL
}; /* .psw is for PSWrap */
755 static char PS_help
[] =
756 "In PostScript code, the tags are the functions.";
758 static char *Prolog_suffixes
[] =
760 static char Prolog_help
[] =
761 "In Prolog code, tags are predicates and rules at the beginning of\n\
764 static char *Python_suffixes
[] =
766 static char Python_help
[] =
767 "In Python code, `def' or `class' at the beginning of a line\n\
770 /* Can't do the `SCM' or `scm' prefix with a version number. */
771 static char *Scheme_suffixes
[] =
772 { "oak", "sch", "scheme", "SCM", "scm", "SM", "sm", "ss", "t", NULL
};
773 static char Scheme_help
[] =
774 "In Scheme code, tags include anything defined with `def' or with a\n\
775 construct whose name starts with `def'. They also include\n\
776 variables set with `set!' at top level in the file.";
778 static char *TeX_suffixes
[] =
779 { "bib", "clo", "cls", "ltx", "sty", "TeX", "tex", NULL
};
780 static char TeX_help
[] =
781 "In LaTeX text, the argument of any of the commands `\\chapter',\n\
782 `\\section', `\\subsection', `\\subsubsection', `\\eqno', `\\label',\n\
783 `\\ref', `\\cite', `\\bibitem', `\\part', `\\appendix', `\\entry',\n\
784 `\\index', `\\def', `\\newcommand', `\\renewcommand',\n\
785 `\\newenvironment' or `\\renewenvironment' is a tag.\n\
787 Other commands can be specified by setting the environment variable\n\
788 `TEXTAGS' to a colon-separated list like, for example,\n\
789 TEXTAGS=\"mycommand:myothercommand\".";
792 static char *Texinfo_suffixes
[] =
793 { "texi", "texinfo", "txi", NULL
};
794 static char Texinfo_help
[] =
795 "for texinfo files, lines starting with @node are tagged.";
797 static char *Yacc_suffixes
[] =
798 { "y", "y++", "ym", "yxx", "yy", NULL
}; /* .ym is Objective yacc file */
799 static char Yacc_help
[] =
800 "In Bison or Yacc input files, each rule defines as a tag the\n\
801 nonterminal it constructs. The portions of the file that contain\n\
802 C code are parsed as C code (use --help --lang=c --lang=yacc\n\
805 static char auto_help
[] =
806 "`auto' is not a real language, it indicates to use\n\
807 a default language for files base on file name suffix and file contents.";
809 static char none_help
[] =
810 "`none' is not a real language, it indicates to only do\n\
811 regexp processing on files.";
813 static char no_lang_help
[] =
814 "No detailed help available for this language.";
818 * Table of languages.
820 * It is ok for a given function to be listed under more than one
821 * name. I just didn't.
824 static language lang_names
[] =
826 { "ada", Ada_help
, Ada_funcs
, Ada_suffixes
},
827 { "asm", Asm_help
, Asm_labels
, Asm_suffixes
},
828 { "c", default_C_help
, default_C_entries
, default_C_suffixes
},
829 { "c++", Cplusplus_help
, Cplusplus_entries
, Cplusplus_suffixes
},
830 { "c*", no_lang_help
, Cstar_entries
, Cstar_suffixes
},
831 { "cobol", Cobol_help
, Cobol_paragraphs
, Cobol_suffixes
},
832 { "erlang", Erlang_help
, Erlang_functions
, Erlang_suffixes
},
833 { "forth", Forth_help
, Forth_words
, Forth_suffixes
},
834 { "fortran", Fortran_help
, Fortran_functions
, Fortran_suffixes
},
835 { "html", HTML_help
, HTML_labels
, HTML_suffixes
},
836 { "java", Cjava_help
, Cjava_entries
, Cjava_suffixes
},
837 { "lisp", Lisp_help
, Lisp_functions
, Lisp_suffixes
},
838 { "lua", Lua_help
, Lua_functions
, Lua_suffixes
},
839 { "makefile", Makefile_help
,Makefile_targets
,NULL
,Makefile_filenames
},
840 { "objc", Objc_help
, plain_C_entries
, Objc_suffixes
},
841 { "pascal", Pascal_help
, Pascal_functions
, Pascal_suffixes
},
842 { "perl",Perl_help
,Perl_functions
,Perl_suffixes
,NULL
,Perl_interpreters
},
843 { "php", PHP_help
, PHP_functions
, PHP_suffixes
},
844 { "postscript",PS_help
, PS_functions
, PS_suffixes
},
845 { "proc", no_lang_help
, plain_C_entries
, plain_C_suffixes
},
846 { "prolog", Prolog_help
, Prolog_functions
, Prolog_suffixes
},
847 { "python", Python_help
, Python_functions
, Python_suffixes
},
848 { "scheme", Scheme_help
, Scheme_functions
, Scheme_suffixes
},
849 { "tex", TeX_help
, TeX_commands
, TeX_suffixes
},
850 { "texinfo", Texinfo_help
, Texinfo_nodes
, Texinfo_suffixes
},
851 { "yacc", Yacc_help
,Yacc_entries
,Yacc_suffixes
,NULL
,NULL
,TRUE
},
852 { "auto", auto_help
}, /* default guessing scheme */
853 { "none", none_help
, just_read_file
}, /* regexp matching only */
854 { NULL
} /* end of list */
859 print_language_names ()
864 puts ("\nThese are the currently supported languages, along with the\n\
865 default file names and dot suffixes:");
866 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
868 printf (" %-*s", 10, lang
->name
);
869 if (lang
->filenames
!= NULL
)
870 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
871 printf (" %s", *name
);
872 if (lang
->suffixes
!= NULL
)
873 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
874 printf (" .%s", *ext
);
877 puts ("where `auto' means use default language for files based on file\n\
878 name suffix, and `none' means only do regexp processing on files.\n\
879 If no language is specified and no matching suffix is found,\n\
880 the first line of the file is read for a sharp-bang (#!) sequence\n\
881 followed by the name of an interpreter. If no such sequence is found,\n\
882 Fortran is tried first; if no tags are found, C is tried next.\n\
883 When parsing any C file, a \"class\" or \"template\" keyword\n\
885 puts ("Compressed files are supported using gzip and bzip2.\n\
887 For detailed help on a given language use, for example,\n\
888 etags --help --lang=ada.");
892 # define EMACS_NAME "standalone"
895 # define VERSION "17.38.1.3"
900 /* Makes it easier to update automatically. */
901 char emacs_copyright
[] = "Copyright (C) 2008 Free Software Foundation, Inc.";
903 printf ("%s (%s %s)\n", (CTAGS
) ? "ctags" : "etags", EMACS_NAME
, VERSION
);
904 puts (emacs_copyright
);
905 puts ("This program is distributed under the terms in ETAGS.README");
910 #ifndef PRINT_UNDOCUMENTED_OPTIONS_HELP
911 # define PRINT_UNDOCUMENTED_OPTIONS_HELP FALSE
915 print_help (argbuffer
)
918 bool help_for_lang
= FALSE
;
920 for (; argbuffer
->arg_type
!= at_end
; argbuffer
++)
921 if (argbuffer
->arg_type
== at_language
)
925 puts (argbuffer
->lang
->help
);
926 help_for_lang
= TRUE
;
932 printf ("Usage: %s [options] [[regex-option ...] file-name] ...\n\
934 These are the options accepted by %s.\n", progname
, progname
);
936 puts ("WARNING: long option names do not work with this executable,\n\
937 as it is not linked with GNU getopt.");
939 puts ("You may use unambiguous abbreviations for the long option names.");
940 puts (" A - as file name means read names from stdin (one per line).\n\
941 Absolute names are stored in the output file as they are.\n\
942 Relative ones are stored relative to the output file's directory.\n");
944 puts ("-a, --append\n\
945 Append tag entries to existing tags file.");
947 puts ("--packages-only\n\
948 For Ada files, only generate tags for packages.");
951 puts ("-B, --backward-search\n\
952 Write the search commands for the tag entries using '?', the\n\
953 backward-search command instead of '/', the forward-search command.");
955 /* This option is mostly obsolete, because etags can now automatically
956 detect C++. Retained for backward compatibility and for debugging and
957 experimentation. In principle, we could want to tag as C++ even
958 before any "class" or "template" keyword.
960 Treat files whose name suffix defaults to C language as C++ files.");
963 puts ("--declarations\n\
964 In C and derived languages, create tags for function declarations,");
966 puts ("\tand create tags for extern variables if --globals is used.");
969 ("\tand create tags for extern variables unless --no-globals is used.");
972 puts ("-d, --defines\n\
973 Create tag entries for C #define constants and enum constants, too.");
975 puts ("-D, --no-defines\n\
976 Don't create tag entries for C #define constants and enum constants.\n\
977 This makes the tags file smaller.");
980 puts ("-i FILE, --include=FILE\n\
981 Include a note in tag file indicating that, when searching for\n\
982 a tag, one should also consult the tags file FILE after\n\
983 checking the current file.");
985 puts ("-l LANG, --language=LANG\n\
986 Force the following files to be considered as written in the\n\
987 named language up to the next --language=LANG option.");
991 Create tag entries for global variables in some languages.");
993 puts ("--no-globals\n\
994 Do not create tag entries for global variables in some\n\
995 languages. This makes the tags file smaller.");
997 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
998 puts ("--no-line-directive\n\
999 Ignore #line preprocessor directives in C and derived languages.");
1003 Create tag entries for members of structures in some languages.");
1005 puts ("--no-members\n\
1006 Do not create tag entries for members of structures\n\
1007 in some languages.");
1009 puts ("-r REGEXP, --regex=REGEXP or --regex=@regexfile\n\
1010 Make a tag for each line matching a regular expression pattern\n\
1011 in the following files. {LANGUAGE}REGEXP uses REGEXP for LANGUAGE\n\
1012 files only. REGEXFILE is a file containing one REGEXP per line.\n\
1013 REGEXP takes the form /TAGREGEXP/TAGNAME/MODS, where TAGNAME/ is\n\
1014 optional. The TAGREGEXP pattern is anchored (as if preceded by ^).");
1015 puts (" If TAGNAME/ is present, the tags created are named.\n\
1016 For example Tcl named tags can be created with:\n\
1017 --regex=\"/proc[ \\t]+\\([^ \\t]+\\)/\\1/.\".\n\
1018 MODS are optional one-letter modifiers: `i' means to ignore case,\n\
1019 `m' means to allow multi-line matches, `s' implies `m' and\n\
1020 causes dot to match any character, including newline.");
1022 puts ("-R, --no-regex\n\
1023 Don't create tags from regexps for the following files.");
1025 puts ("-I, --ignore-indentation\n\
1026 In C and C++ do not assume that a closing brace in the first\n\
1027 column is the final brace of a function or structure definition.");
1029 puts ("-o FILE, --output=FILE\n\
1030 Write the tags to FILE.");
1032 puts ("--parse-stdin=NAME\n\
1033 Read from standard input and record tags as belonging to file NAME.");
1037 puts ("-t, --typedefs\n\
1038 Generate tag entries for C and Ada typedefs.");
1039 puts ("-T, --typedefs-and-c++\n\
1040 Generate tag entries for C typedefs, C struct/enum/union tags,\n\
1041 and C++ member functions.");
1045 puts ("-u, --update\n\
1046 Update the tag entries for the given files, leaving tag\n\
1047 entries for other files in place. Currently, this is\n\
1048 implemented by deleting the existing entries for the given\n\
1049 files and then rewriting the new entries at the end of the\n\
1050 tags file. It is often faster to simply rebuild the entire\n\
1051 tag file than to use this.");
1055 puts ("-v, --vgrind\n\
1056 Print on the standard output an index of items intended for\n\
1057 human consumption, similar to the output of vgrind. The index\n\
1058 is sorted, and gives the page number of each item.");
1060 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
1061 puts ("-w, --no-duplicates\n\
1062 Do not create duplicate tag entries, for compatibility with\n\
1063 traditional ctags.");
1065 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
1066 puts ("-w, --no-warn\n\
1067 Suppress warning messages about duplicate tag entries.");
1069 puts ("-x, --cxref\n\
1070 Like --vgrind, but in the style of cxref, rather than vgrind.\n\
1071 The output uses line numbers instead of page numbers, but\n\
1072 beyond that the differences are cosmetic; try both to see\n\
1076 puts ("-V, --version\n\
1077 Print the version of the program.\n\
1079 Print this help message.\n\
1080 Followed by one or more `--language' options prints detailed\n\
1081 help about tag generation for the specified languages.");
1083 print_language_names ();
1086 puts ("Report bugs to bug-gnu-emacs@gnu.org");
1088 exit (EXIT_SUCCESS
);
1098 unsigned int nincluded_files
;
1099 char **included_files
;
1100 argument
*argbuffer
;
1101 int current_arg
, file_count
;
1102 linebuffer filename_lb
;
1103 bool help_asked
= FALSE
;
1109 _fmode
= O_BINARY
; /* all of files are treated as binary files */
1113 nincluded_files
= 0;
1114 included_files
= xnew (argc
, char *);
1118 /* Allocate enough no matter what happens. Overkill, but each one
1120 argbuffer
= xnew (argc
, argument
);
1123 * Always find typedefs and structure tags.
1124 * Also default to find macro constants, enum constants, struct
1125 * members and global variables. Do it for both etags and ctags.
1127 typedefs
= typedefs_or_cplusplus
= constantypedefs
= TRUE
;
1128 globals
= members
= TRUE
;
1130 /* When the optstring begins with a '-' getopt_long does not rearrange the
1131 non-options arguments to be at the end, but leaves them alone. */
1132 optstring
= concat (NO_LONG_OPTIONS
? "" : "-",
1133 "ac:Cf:Il:o:r:RSVhH",
1134 (CTAGS
) ? "BxdtTuvw" : "Di:");
1136 while ((opt
= getopt_long (argc
, argv
, optstring
, longopts
, NULL
)) != EOF
)
1140 /* If getopt returns 0, then it has already processed a
1141 long-named option. We should do nothing. */
1145 /* This means that a file name has been seen. Record it. */
1146 argbuffer
[current_arg
].arg_type
= at_filename
;
1147 argbuffer
[current_arg
].what
= optarg
;
1153 /* Parse standard input. Idea by Vivek <vivek@etla.org>. */
1154 argbuffer
[current_arg
].arg_type
= at_stdin
;
1155 argbuffer
[current_arg
].what
= optarg
;
1159 fatal ("cannot parse standard input more than once", (char *)NULL
);
1160 parsing_stdin
= TRUE
;
1163 /* Common options. */
1164 case 'a': append_to_tagfile
= TRUE
; break;
1165 case 'C': cplusplus
= TRUE
; break;
1166 case 'f': /* for compatibility with old makefiles */
1170 error ("-o option may only be given once.", (char *)NULL
);
1171 suggest_asking_for_help ();
1177 case 'S': /* for backward compatibility */
1178 ignoreindent
= TRUE
;
1182 language
*lang
= get_language_from_langname (optarg
);
1185 argbuffer
[current_arg
].lang
= lang
;
1186 argbuffer
[current_arg
].arg_type
= at_language
;
1192 /* Backward compatibility: support obsolete --ignore-case-regexp. */
1193 optarg
= concat (optarg
, "i", ""); /* memory leak here */
1196 argbuffer
[current_arg
].arg_type
= at_regexp
;
1197 argbuffer
[current_arg
].what
= optarg
;
1201 argbuffer
[current_arg
].arg_type
= at_regexp
;
1202 argbuffer
[current_arg
].what
= NULL
;
1214 case 'D': constantypedefs
= FALSE
; break;
1215 case 'i': included_files
[nincluded_files
++] = optarg
; break;
1217 /* Ctags options. */
1218 case 'B': searchar
= '?'; break;
1219 case 'd': constantypedefs
= TRUE
; break;
1220 case 't': typedefs
= TRUE
; break;
1221 case 'T': typedefs
= typedefs_or_cplusplus
= TRUE
; break;
1222 case 'u': update
= TRUE
; break;
1223 case 'v': vgrind_style
= TRUE
; /*FALLTHRU*/
1224 case 'x': cxref_style
= TRUE
; break;
1225 case 'w': no_warnings
= TRUE
; break;
1227 suggest_asking_for_help ();
1231 /* No more options. Store the rest of arguments. */
1232 for (; optind
< argc
; optind
++)
1234 argbuffer
[current_arg
].arg_type
= at_filename
;
1235 argbuffer
[current_arg
].what
= argv
[optind
];
1240 argbuffer
[current_arg
].arg_type
= at_end
;
1243 print_help (argbuffer
);
1246 if (nincluded_files
== 0 && file_count
== 0)
1248 error ("no input files specified.", (char *)NULL
);
1249 suggest_asking_for_help ();
1253 if (tagfile
== NULL
)
1254 tagfile
= CTAGS
? "tags" : "TAGS";
1255 cwd
= etags_getcwd (); /* the current working directory */
1256 if (cwd
[strlen (cwd
) - 1] != '/')
1259 cwd
= concat (oldcwd
, "/", "");
1262 /* Relative file names are made relative to the current directory. */
1263 if (streq (tagfile
, "-")
1264 || strneq (tagfile
, "/dev/", 5))
1268 canonicalize_filename (tagfile
);
1269 tagfiledir
= absolute_dirname (tagfile
, cwd
);
1272 init (); /* set up boolean "functions" */
1274 linebuffer_init (&lb
);
1275 linebuffer_init (&filename_lb
);
1276 linebuffer_init (&filebuf
);
1277 linebuffer_init (&token_name
);
1281 if (streq (tagfile
, "-"))
1285 /* Switch redirected `stdout' to binary mode (setting `_fmode'
1286 doesn't take effect until after `stdout' is already open). */
1287 if (!isatty (fileno (stdout
)))
1288 setmode (fileno (stdout
), O_BINARY
);
1292 tagf
= fopen (tagfile
, append_to_tagfile
? "a" : "w");
1298 * Loop through files finding functions.
1300 for (i
= 0; i
< current_arg
; i
++)
1302 static language
*lang
; /* non-NULL if language is forced */
1305 switch (argbuffer
[i
].arg_type
)
1308 lang
= argbuffer
[i
].lang
;
1311 analyse_regex (argbuffer
[i
].what
);
1314 this_file
= argbuffer
[i
].what
;
1315 /* Input file named "-" means read file names from stdin
1316 (one per line) and use them. */
1317 if (streq (this_file
, "-"))
1320 fatal ("cannot parse standard input AND read file names from it",
1322 while (readline_internal (&filename_lb
, stdin
) > 0)
1323 process_file_name (filename_lb
.buffer
, lang
);
1326 process_file_name (this_file
, lang
);
1329 this_file
= argbuffer
[i
].what
;
1330 process_file (stdin
, this_file
, lang
);
1337 free (filebuf
.buffer
);
1338 free (token_name
.buffer
);
1340 if (!CTAGS
|| cxref_style
)
1342 /* Write the remaining tags to tagf (ETAGS) or stdout (CXREF). */
1343 put_entries (nodehead
);
1344 free_tree (nodehead
);
1350 /* Output file entries that have no tags. */
1351 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1353 fprintf (tagf
, "\f\n%s,0\n", fdp
->taggedfname
);
1355 while (nincluded_files
-- > 0)
1356 fprintf (tagf
, "\f\n%s,include\n", *included_files
++);
1358 if (fclose (tagf
) == EOF
)
1362 exit (EXIT_SUCCESS
);
1365 /* From here on, we are in (CTAGS && !cxref_style) */
1369 for (i
= 0; i
< current_arg
; ++i
)
1371 switch (argbuffer
[i
].arg_type
)
1377 continue; /* the for loop */
1380 "mv %s OTAGS;fgrep -v '\t%s\t' OTAGS >%s;rm OTAGS",
1381 tagfile
, argbuffer
[i
].what
, tagfile
);
1382 if (system (cmd
) != EXIT_SUCCESS
)
1383 fatal ("failed to execute shell command", (char *)NULL
);
1385 append_to_tagfile
= TRUE
;
1388 tagf
= fopen (tagfile
, append_to_tagfile
? "a" : "w");
1391 put_entries (nodehead
); /* write all the tags (CTAGS) */
1392 free_tree (nodehead
);
1394 if (fclose (tagf
) == EOF
)
1398 if (append_to_tagfile
|| update
)
1400 char cmd
[2*BUFSIZ
+20];
1401 /* Maybe these should be used:
1402 setenv ("LC_COLLATE", "C", 1);
1403 setenv ("LC_ALL", "C", 1); */
1404 sprintf (cmd
, "sort -u -o %.*s %.*s", BUFSIZ
, tagfile
, BUFSIZ
, tagfile
);
1405 exit (system (cmd
));
1407 return EXIT_SUCCESS
;
1412 * Return a compressor given the file name. If EXTPTR is non-zero,
1413 * return a pointer into FILE where the compressor-specific
1414 * extension begins. If no compressor is found, NULL is returned
1415 * and EXTPTR is not significant.
1416 * Idea by Vladimir Alexiev <vladimir@cs.ualberta.ca> (1998)
1419 get_compressor_from_suffix (file
, extptr
)
1424 char *slash
, *suffix
;
1426 /* File has been processed by canonicalize_filename,
1427 so we don't need to consider backslashes on DOS_NT. */
1428 slash
= etags_strrchr (file
, '/');
1429 suffix
= etags_strrchr (file
, '.');
1430 if (suffix
== NULL
|| suffix
< slash
)
1435 /* Let those poor souls who live with DOS 8+3 file name limits get
1436 some solace by treating foo.cgz as if it were foo.c.gz, etc.
1437 Only the first do loop is run if not MSDOS */
1440 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1441 if (streq (compr
->suffix
, suffix
))
1444 break; /* do it only once: not really a loop */
1447 } while (*suffix
!= '\0');
1454 * Return a language given the name.
1457 get_language_from_langname (name
)
1463 error ("empty language name", (char *)NULL
);
1466 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1467 if (streq (name
, lang
->name
))
1469 error ("unknown language \"%s\"", name
);
1477 * Return a language given the interpreter name.
1480 get_language_from_interpreter (interpreter
)
1486 if (interpreter
== NULL
)
1488 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1489 if (lang
->interpreters
!= NULL
)
1490 for (iname
= lang
->interpreters
; *iname
!= NULL
; iname
++)
1491 if (streq (*iname
, interpreter
))
1500 * Return a language given the file name.
1503 get_language_from_filename (file
, case_sensitive
)
1505 bool case_sensitive
;
1508 char **name
, **ext
, *suffix
;
1510 /* Try whole file name first. */
1511 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1512 if (lang
->filenames
!= NULL
)
1513 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
1514 if ((case_sensitive
)
1515 ? streq (*name
, file
)
1516 : strcaseeq (*name
, file
))
1519 /* If not found, try suffix after last dot. */
1520 suffix
= etags_strrchr (file
, '.');
1524 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1525 if (lang
->suffixes
!= NULL
)
1526 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
1527 if ((case_sensitive
)
1528 ? streq (*ext
, suffix
)
1529 : strcaseeq (*ext
, suffix
))
1536 * This routine is called on each file argument.
1539 process_file_name (file
, lang
)
1543 struct stat stat_buf
;
1547 char *compressed_name
, *uncompressed_name
;
1548 char *ext
, *real_name
;
1551 canonicalize_filename (file
);
1552 if (streq (file
, tagfile
) && !streq (tagfile
, "-"))
1554 error ("skipping inclusion of %s in self.", file
);
1557 if ((compr
= get_compressor_from_suffix (file
, &ext
)) == NULL
)
1559 compressed_name
= NULL
;
1560 real_name
= uncompressed_name
= savestr (file
);
1564 real_name
= compressed_name
= savestr (file
);
1565 uncompressed_name
= savenstr (file
, ext
- file
);
1568 /* If the canonicalized uncompressed name
1569 has already been dealt with, skip it silently. */
1570 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1572 assert (fdp
->infname
!= NULL
);
1573 if (streq (uncompressed_name
, fdp
->infname
))
1577 if (stat (real_name
, &stat_buf
) != 0)
1579 /* Reset real_name and try with a different name. */
1581 if (compressed_name
!= NULL
) /* try with the given suffix */
1583 if (stat (uncompressed_name
, &stat_buf
) == 0)
1584 real_name
= uncompressed_name
;
1586 else /* try all possible suffixes */
1588 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1590 compressed_name
= concat (file
, ".", compr
->suffix
);
1591 if (stat (compressed_name
, &stat_buf
) != 0)
1595 char *suf
= compressed_name
+ strlen (file
);
1596 size_t suflen
= strlen (compr
->suffix
) + 1;
1597 for ( ; suf
[1]; suf
++, suflen
--)
1599 memmove (suf
, suf
+ 1, suflen
);
1600 if (stat (compressed_name
, &stat_buf
) == 0)
1602 real_name
= compressed_name
;
1606 if (real_name
!= NULL
)
1609 free (compressed_name
);
1610 compressed_name
= NULL
;
1614 real_name
= compressed_name
;
1619 if (real_name
== NULL
)
1624 } /* try with a different name */
1626 if (!S_ISREG (stat_buf
.st_mode
))
1628 error ("skipping %s: it is not a regular file.", real_name
);
1631 if (real_name
== compressed_name
)
1633 char *cmd
= concat (compr
->command
, " ", real_name
);
1634 inf
= (FILE *) popen (cmd
, "r");
1638 inf
= fopen (real_name
, "r");
1645 process_file (inf
, uncompressed_name
, lang
);
1647 if (real_name
== compressed_name
)
1648 retval
= pclose (inf
);
1650 retval
= fclose (inf
);
1655 free (compressed_name
);
1656 free (uncompressed_name
);
1663 process_file (fh
, fn
, lang
)
1668 static const fdesc emptyfdesc
;
1671 /* Create a new input file description entry. */
1672 fdp
= xnew (1, fdesc
);
1675 fdp
->infname
= savestr (fn
);
1677 fdp
->infabsname
= absolute_filename (fn
, cwd
);
1678 fdp
->infabsdir
= absolute_dirname (fn
, cwd
);
1679 if (filename_is_absolute (fn
))
1681 /* An absolute file name. Canonicalize it. */
1682 fdp
->taggedfname
= absolute_filename (fn
, NULL
);
1686 /* A file name relative to cwd. Make it relative
1687 to the directory of the tags file. */
1688 fdp
->taggedfname
= relative_filename (fn
, tagfiledir
);
1690 fdp
->usecharno
= TRUE
; /* use char position when making tags */
1692 fdp
->written
= FALSE
; /* not written on tags file yet */
1695 curfdp
= fdhead
; /* the current file description */
1699 /* If not Ctags, and if this is not metasource and if it contained no #line
1700 directives, we can write the tags and free all nodes pointing to
1703 && curfdp
->usecharno
/* no #line directives in this file */
1704 && !curfdp
->lang
->metasource
)
1708 /* Look for the head of the sublist relative to this file. See add_node
1709 for the structure of the node tree. */
1711 for (np
= nodehead
; np
!= NULL
; prev
= np
, np
= np
->left
)
1712 if (np
->fdp
== curfdp
)
1715 /* If we generated tags for this file, write and delete them. */
1718 /* This is the head of the last sublist, if any. The following
1719 instructions depend on this being true. */
1720 assert (np
->left
== NULL
);
1722 assert (fdhead
== curfdp
);
1723 assert (last_node
->fdp
== curfdp
);
1724 put_entries (np
); /* write tags for file curfdp->taggedfname */
1725 free_tree (np
); /* remove the written nodes */
1727 nodehead
= NULL
; /* no nodes left */
1729 prev
->left
= NULL
; /* delete the pointer to the sublist */
1735 * This routine sets up the boolean pseudo-functions which work
1736 * by setting boolean flags dependent upon the corresponding character.
1737 * Every char which is NOT in that string is not a white char. Therefore,
1738 * all of the array "_wht" is set to FALSE, and then the elements
1739 * subscripted by the chars in "white" are set to TRUE. Thus "_wht"
1740 * of a char is TRUE if it is the string "white", else FALSE.
1748 for (i
= 0; i
< CHARS
; i
++)
1749 iswhite(i
) = notinname(i
) = begtoken(i
) = intoken(i
) = endtoken(i
) = FALSE
;
1750 for (sp
= white
; *sp
!= '\0'; sp
++) iswhite (*sp
) = TRUE
;
1751 for (sp
= nonam
; *sp
!= '\0'; sp
++) notinname (*sp
) = TRUE
;
1752 notinname('\0') = notinname('\n');
1753 for (sp
= begtk
; *sp
!= '\0'; sp
++) begtoken (*sp
) = TRUE
;
1754 begtoken('\0') = begtoken('\n');
1755 for (sp
= midtk
; *sp
!= '\0'; sp
++) intoken (*sp
) = TRUE
;
1756 intoken('\0') = intoken('\n');
1757 for (sp
= endtk
; *sp
!= '\0'; sp
++) endtoken (*sp
) = TRUE
;
1758 endtoken('\0') = endtoken('\n');
1762 * This routine opens the specified file and calls the function
1763 * which finds the function and type definitions.
1770 language
*lang
= curfdp
->lang
;
1771 Lang_function
*parser
= NULL
;
1773 /* If user specified a language, use it. */
1774 if (lang
!= NULL
&& lang
->function
!= NULL
)
1776 parser
= lang
->function
;
1779 /* Else try to guess the language given the file name. */
1782 lang
= get_language_from_filename (curfdp
->infname
, TRUE
);
1783 if (lang
!= NULL
&& lang
->function
!= NULL
)
1785 curfdp
->lang
= lang
;
1786 parser
= lang
->function
;
1790 /* Else look for sharp-bang as the first two characters. */
1792 && readline_internal (&lb
, inf
) > 0
1794 && lb
.buffer
[0] == '#'
1795 && lb
.buffer
[1] == '!')
1799 /* Set lp to point at the first char after the last slash in the
1800 line or, if no slashes, at the first nonblank. Then set cp to
1801 the first successive blank and terminate the string. */
1802 lp
= etags_strrchr (lb
.buffer
+2, '/');
1806 lp
= skip_spaces (lb
.buffer
+ 2);
1807 cp
= skip_non_spaces (lp
);
1810 if (strlen (lp
) > 0)
1812 lang
= get_language_from_interpreter (lp
);
1813 if (lang
!= NULL
&& lang
->function
!= NULL
)
1815 curfdp
->lang
= lang
;
1816 parser
= lang
->function
;
1821 /* We rewind here, even if inf may be a pipe. We fail if the
1822 length of the first line is longer than the pipe block size,
1823 which is unlikely. */
1826 /* Else try to guess the language given the case insensitive file name. */
1829 lang
= get_language_from_filename (curfdp
->infname
, FALSE
);
1830 if (lang
!= NULL
&& lang
->function
!= NULL
)
1832 curfdp
->lang
= lang
;
1833 parser
= lang
->function
;
1837 /* Else try Fortran or C. */
1840 node
*old_last_node
= last_node
;
1842 curfdp
->lang
= get_language_from_langname ("fortran");
1845 if (old_last_node
== last_node
)
1846 /* No Fortran entries found. Try C. */
1848 /* We do not tag if rewind fails.
1849 Only the file name will be recorded in the tags file. */
1851 curfdp
->lang
= get_language_from_langname (cplusplus
? "c++" : "c");
1857 if (!no_line_directive
1858 && curfdp
->lang
!= NULL
&& curfdp
->lang
->metasource
)
1859 /* It may be that this is a bingo.y file, and we already parsed a bingo.c
1860 file, or anyway we parsed a file that is automatically generated from
1861 this one. If this is the case, the bingo.c file contained #line
1862 directives that generated tags pointing to this file. Let's delete
1863 them all before parsing this file, which is the real source. */
1865 fdesc
**fdpp
= &fdhead
;
1866 while (*fdpp
!= NULL
)
1868 && streq ((*fdpp
)->taggedfname
, curfdp
->taggedfname
))
1869 /* We found one of those! We must delete both the file description
1870 and all tags referring to it. */
1872 fdesc
*badfdp
= *fdpp
;
1874 /* Delete the tags referring to badfdp->taggedfname
1875 that were obtained from badfdp->infname. */
1876 invalidate_nodes (badfdp
, &nodehead
);
1878 *fdpp
= badfdp
->next
; /* remove the bad description from the list */
1879 free_fdesc (badfdp
);
1882 fdpp
= &(*fdpp
)->next
; /* advance the list pointer */
1885 assert (parser
!= NULL
);
1887 /* Generic initialisations before reading from file. */
1888 linebuffer_setlen (&filebuf
, 0); /* reset the file buffer */
1890 /* Generic initialisations before parsing file with readline. */
1891 lineno
= 0; /* reset global line number */
1892 charno
= 0; /* reset global char number */
1893 linecharno
= 0; /* reset global char number of line start */
1897 regex_tag_multiline ();
1902 * Check whether an implicitly named tag should be created,
1903 * then call `pfnote'.
1904 * NAME is a string that is internally copied by this function.
1906 * TAGS format specification
1907 * Idea by Sam Kendall <kendall@mv.mv.com> (1997)
1908 * The following is explained in some more detail in etc/ETAGS.EBNF.
1910 * make_tag creates tags with "implicit tag names" (unnamed tags)
1911 * if the following are all true, assuming NONAM=" \f\t\n\r()=,;":
1912 * 1. NAME does not contain any of the characters in NONAM;
1913 * 2. LINESTART contains name as either a rightmost, or rightmost but
1914 * one character, substring;
1915 * 3. the character, if any, immediately before NAME in LINESTART must
1916 * be a character in NONAM;
1917 * 4. the character, if any, immediately after NAME in LINESTART must
1918 * also be a character in NONAM.
1920 * The implementation uses the notinname() macro, which recognises the
1921 * characters stored in the string `nonam'.
1922 * etags.el needs to use the same characters that are in NONAM.
1925 make_tag (name
, namelen
, is_func
, linestart
, linelen
, lno
, cno
)
1926 char *name
; /* tag name, or NULL if unnamed */
1927 int namelen
; /* tag length */
1928 bool is_func
; /* tag is a function */
1929 char *linestart
; /* start of the line where tag is */
1930 int linelen
; /* length of the line where tag is */
1931 int lno
; /* line number */
1932 long cno
; /* character number */
1934 bool named
= (name
!= NULL
&& namelen
> 0);
1936 if (!CTAGS
&& named
) /* maybe set named to false */
1937 /* Let's try to make an implicit tag name, that is, create an unnamed tag
1938 such that etags.el can guess a name from it. */
1941 register char *cp
= name
;
1943 for (i
= 0; i
< namelen
; i
++)
1944 if (notinname (*cp
++))
1946 if (i
== namelen
) /* rule #1 */
1948 cp
= linestart
+ linelen
- namelen
;
1949 if (notinname (linestart
[linelen
-1]))
1950 cp
-= 1; /* rule #4 */
1951 if (cp
>= linestart
/* rule #2 */
1953 || notinname (cp
[-1])) /* rule #3 */
1954 && strneq (name
, cp
, namelen
)) /* rule #2 */
1955 named
= FALSE
; /* use implicit tag name */
1960 name
= savenstr (name
, namelen
);
1963 pfnote (name
, is_func
, linestart
, linelen
, lno
, cno
);
1968 pfnote (name
, is_func
, linestart
, linelen
, lno
, cno
)
1969 char *name
; /* tag name, or NULL if unnamed */
1970 bool is_func
; /* tag is a function */
1971 char *linestart
; /* start of the line where tag is */
1972 int linelen
; /* length of the line where tag is */
1973 int lno
; /* line number */
1974 long cno
; /* character number */
1978 assert (name
== NULL
|| name
[0] != '\0');
1979 if (CTAGS
&& name
== NULL
)
1982 np
= xnew (1, node
);
1984 /* If ctags mode, change name "main" to M<thisfilename>. */
1985 if (CTAGS
&& !cxref_style
&& streq (name
, "main"))
1987 register char *fp
= etags_strrchr (curfdp
->taggedfname
, '/');
1988 np
->name
= concat ("M", fp
== NULL
? curfdp
->taggedfname
: fp
+ 1, "");
1989 fp
= etags_strrchr (np
->name
, '.');
1990 if (fp
!= NULL
&& fp
[1] != '\0' && fp
[2] == '\0')
1996 np
->been_warned
= FALSE
;
1998 np
->is_func
= is_func
;
2000 if (np
->fdp
->usecharno
)
2001 /* Our char numbers are 0-base, because of C language tradition?
2002 ctags compatibility? old versions compatibility? I don't know.
2003 Anyway, since emacs's are 1-base we expect etags.el to take care
2004 of the difference. If we wanted to have 1-based numbers, we would
2005 uncomment the +1 below. */
2006 np
->cno
= cno
/* + 1 */ ;
2008 np
->cno
= invalidcharno
;
2009 np
->left
= np
->right
= NULL
;
2010 if (CTAGS
&& !cxref_style
)
2012 if (strlen (linestart
) < 50)
2013 np
->regex
= concat (linestart
, "$", "");
2015 np
->regex
= savenstr (linestart
, 50);
2018 np
->regex
= savenstr (linestart
, linelen
);
2020 add_node (np
, &nodehead
);
2025 * recurse on left children, iterate on right children.
2033 register node
*node_right
= np
->right
;
2034 free_tree (np
->left
);
2044 * delete a file description
2048 register fdesc
*fdp
;
2050 free (fdp
->infname
);
2051 free (fdp
->infabsname
);
2052 free (fdp
->infabsdir
);
2053 free (fdp
->taggedfname
);
2060 * Adds a node to the tree of nodes. In etags mode, sort by file
2061 * name. In ctags mode, sort by tag name. Make no attempt at
2064 * add_node is the only function allowed to add nodes, so it can
2068 add_node (np
, cur_node_p
)
2069 node
*np
, **cur_node_p
;
2072 register node
*cur_node
= *cur_node_p
;
2074 if (cur_node
== NULL
)
2084 /* For each file name, tags are in a linked sublist on the right
2085 pointer. The first tags of different files are a linked list
2086 on the left pointer. last_node points to the end of the last
2088 if (last_node
!= NULL
&& last_node
->fdp
== np
->fdp
)
2090 /* Let's use the same sublist as the last added node. */
2091 assert (last_node
->right
== NULL
);
2092 last_node
->right
= np
;
2095 else if (cur_node
->fdp
== np
->fdp
)
2097 /* Scanning the list we found the head of a sublist which is
2098 good for us. Let's scan this sublist. */
2099 add_node (np
, &cur_node
->right
);
2102 /* The head of this sublist is not good for us. Let's try the
2104 add_node (np
, &cur_node
->left
);
2105 } /* if ETAGS mode */
2110 dif
= strcmp (np
->name
, cur_node
->name
);
2113 * If this tag name matches an existing one, then
2114 * do not add the node, but maybe print a warning.
2116 if (no_duplicates
&& !dif
)
2118 if (np
->fdp
== cur_node
->fdp
)
2122 fprintf (stderr
, "Duplicate entry in file %s, line %d: %s\n",
2123 np
->fdp
->infname
, lineno
, np
->name
);
2124 fprintf (stderr
, "Second entry ignored\n");
2127 else if (!cur_node
->been_warned
&& !no_warnings
)
2131 "Duplicate entry in files %s and %s: %s (Warning only)\n",
2132 np
->fdp
->infname
, cur_node
->fdp
->infname
, np
->name
);
2133 cur_node
->been_warned
= TRUE
;
2138 /* Actually add the node */
2139 add_node (np
, dif
< 0 ? &cur_node
->left
: &cur_node
->right
);
2140 } /* if CTAGS mode */
2144 * invalidate_nodes ()
2145 * Scan the node tree and invalidate all nodes pointing to the
2146 * given file description (CTAGS case) or free them (ETAGS case).
2149 invalidate_nodes (badfdp
, npp
)
2160 if (np
->left
!= NULL
)
2161 invalidate_nodes (badfdp
, &np
->left
);
2162 if (np
->fdp
== badfdp
)
2164 if (np
->right
!= NULL
)
2165 invalidate_nodes (badfdp
, &np
->right
);
2169 assert (np
->fdp
!= NULL
);
2170 if (np
->fdp
== badfdp
)
2172 *npp
= np
->left
; /* detach the sublist from the list */
2173 np
->left
= NULL
; /* isolate it */
2174 free_tree (np
); /* free it */
2175 invalidate_nodes (badfdp
, npp
);
2178 invalidate_nodes (badfdp
, &np
->left
);
2183 static int total_size_of_entries
__P((node
*));
2184 static int number_len
__P((long));
2186 /* Length of a non-negative number's decimal representation. */
2192 while ((num
/= 10) > 0)
2198 * Return total number of characters that put_entries will output for
2199 * the nodes in the linked list at the right of the specified node.
2200 * This count is irrelevant with etags.el since emacs 19.34 at least,
2201 * but is still supplied for backward compatibility.
2204 total_size_of_entries (np
)
2207 register int total
= 0;
2209 for (; np
!= NULL
; np
= np
->right
)
2212 total
+= strlen (np
->regex
) + 1; /* pat\177 */
2213 if (np
->name
!= NULL
)
2214 total
+= strlen (np
->name
) + 1; /* name\001 */
2215 total
+= number_len ((long) np
->lno
) + 1; /* lno, */
2216 if (np
->cno
!= invalidcharno
) /* cno */
2217 total
+= number_len (np
->cno
);
2218 total
+= 1; /* newline */
2229 static fdesc
*fdp
= NULL
;
2234 /* Output subentries that precede this one */
2236 put_entries (np
->left
);
2238 /* Output this entry */
2247 fprintf (tagf
, "\f\n%s,%d\n",
2248 fdp
->taggedfname
, total_size_of_entries (np
));
2249 fdp
->written
= TRUE
;
2251 fputs (np
->regex
, tagf
);
2252 fputc ('\177', tagf
);
2253 if (np
->name
!= NULL
)
2255 fputs (np
->name
, tagf
);
2256 fputc ('\001', tagf
);
2258 fprintf (tagf
, "%d,", np
->lno
);
2259 if (np
->cno
!= invalidcharno
)
2260 fprintf (tagf
, "%ld", np
->cno
);
2266 if (np
->name
== NULL
)
2267 error ("internal error: NULL name in ctags mode.", (char *)NULL
);
2272 fprintf (stdout
, "%s %s %d\n",
2273 np
->name
, np
->fdp
->taggedfname
, (np
->lno
+ 63) / 64);
2275 fprintf (stdout
, "%-16s %3d %-16s %s\n",
2276 np
->name
, np
->lno
, np
->fdp
->taggedfname
, np
->regex
);
2280 fprintf (tagf
, "%s\t%s\t", np
->name
, np
->fdp
->taggedfname
);
2283 { /* function or #define macro with args */
2284 putc (searchar
, tagf
);
2287 for (sp
= np
->regex
; *sp
; sp
++)
2289 if (*sp
== '\\' || *sp
== searchar
)
2293 putc (searchar
, tagf
);
2296 { /* anything else; text pattern inadequate */
2297 fprintf (tagf
, "%d", np
->lno
);
2302 } /* if this node contains a valid tag */
2304 /* Output subentries that follow this one */
2305 put_entries (np
->right
);
2307 put_entries (np
->left
);
2312 #define C_EXT 0x00fff /* C extensions */
2313 #define C_PLAIN 0x00000 /* C */
2314 #define C_PLPL 0x00001 /* C++ */
2315 #define C_STAR 0x00003 /* C* */
2316 #define C_JAVA 0x00005 /* JAVA */
2317 #define C_AUTO 0x01000 /* C, but switch to C++ if `class' is met */
2318 #define YACC 0x10000 /* yacc file */
2321 * The C symbol tables.
2326 st_C_objprot
, st_C_objimpl
, st_C_objend
,
2328 st_C_ignore
, st_C_attribute
,
2331 st_C_class
, st_C_template
,
2332 st_C_struct
, st_C_extern
, st_C_enum
, st_C_define
, st_C_typedef
2335 static unsigned int hash
__P((const char *, unsigned int));
2336 static struct C_stab_entry
* in_word_set
__P((const char *, unsigned int));
2337 static enum sym_type C_symtype
__P((char *, int, int));
2339 /* Feed stuff between (but not including) %[ and %] lines to:
2345 struct C_stab_entry { char *name; int c_ext; enum sym_type type; }
2349 while, 0, st_C_ignore
2350 switch, 0, st_C_ignore
2351 return, 0, st_C_ignore
2352 __attribute__, 0, st_C_attribute
2353 GTY, 0, st_C_attribute
2354 @interface, 0, st_C_objprot
2355 @protocol, 0, st_C_objprot
2356 @implementation,0, st_C_objimpl
2357 @end, 0, st_C_objend
2358 import, (C_JAVA & ~C_PLPL), st_C_ignore
2359 package, (C_JAVA & ~C_PLPL), st_C_ignore
2360 friend, C_PLPL, st_C_ignore
2361 extends, (C_JAVA & ~C_PLPL), st_C_javastruct
2362 implements, (C_JAVA & ~C_PLPL), st_C_javastruct
2363 interface, (C_JAVA & ~C_PLPL), st_C_struct
2364 class, 0, st_C_class
2365 namespace, C_PLPL, st_C_struct
2366 domain, C_STAR, st_C_struct
2367 union, 0, st_C_struct
2368 struct, 0, st_C_struct
2369 extern, 0, st_C_extern
2371 typedef, 0, st_C_typedef
2372 define, 0, st_C_define
2373 undef, 0, st_C_define
2374 operator, C_PLPL, st_C_operator
2375 template, 0, st_C_template
2376 # DEFUN used in emacs, the next three used in glibc (SYSCALL only for mach).
2377 DEFUN, 0, st_C_gnumacro
2378 SYSCALL, 0, st_C_gnumacro
2379 ENTRY, 0, st_C_gnumacro
2380 PSEUDO, 0, st_C_gnumacro
2381 # These are defined inside C functions, so currently they are not met.
2382 # EXFUN used in glibc, DEFVAR_* in emacs.
2383 #EXFUN, 0, st_C_gnumacro
2384 #DEFVAR_, 0, st_C_gnumacro
2386 and replace lines between %< and %> with its output, then:
2387 - remove the #if characterset check
2388 - make in_word_set static and not inline. */
2390 /* C code produced by gperf version 3.0.1 */
2391 /* Command-line: gperf -m 5 */
2392 /* Computed positions: -k'2-3' */
2394 struct C_stab_entry
{ char *name
; int c_ext
; enum sym_type type
; };
2395 /* maximum key range = 33, duplicates = 0 */
2406 register const char *str
;
2407 register unsigned int len
;
2409 static unsigned char asso_values
[] =
2411 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2412 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2413 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2414 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2415 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2416 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2417 35, 35, 35, 35, 35, 35, 35, 35, 35, 3,
2418 26, 35, 35, 35, 35, 35, 35, 35, 27, 35,
2419 35, 35, 35, 24, 0, 35, 35, 35, 35, 0,
2420 35, 35, 35, 35, 35, 1, 35, 16, 35, 6,
2421 23, 0, 0, 35, 22, 0, 35, 35, 5, 0,
2422 0, 15, 1, 35, 6, 35, 8, 19, 35, 16,
2423 4, 5, 35, 35, 35, 35, 35, 35, 35, 35,
2424 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2425 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2426 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2427 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2428 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2429 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2430 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2431 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2432 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2433 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2434 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2435 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2436 35, 35, 35, 35, 35, 35
2438 register int hval
= len
;
2443 hval
+= asso_values
[(unsigned char)str
[2]];
2446 hval
+= asso_values
[(unsigned char)str
[1]];
2452 static struct C_stab_entry
*
2453 in_word_set (str
, len
)
2454 register const char *str
;
2455 register unsigned int len
;
2459 TOTAL_KEYWORDS
= 33,
2460 MIN_WORD_LENGTH
= 2,
2461 MAX_WORD_LENGTH
= 15,
2466 static struct C_stab_entry wordlist
[] =
2469 {"if", 0, st_C_ignore
},
2470 {"GTY", 0, st_C_attribute
},
2471 {"@end", 0, st_C_objend
},
2472 {"union", 0, st_C_struct
},
2473 {"define", 0, st_C_define
},
2474 {"import", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2475 {"template", 0, st_C_template
},
2476 {"operator", C_PLPL
, st_C_operator
},
2477 {"@interface", 0, st_C_objprot
},
2478 {"implements", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2479 {"friend", C_PLPL
, st_C_ignore
},
2480 {"typedef", 0, st_C_typedef
},
2481 {"return", 0, st_C_ignore
},
2482 {"@implementation",0, st_C_objimpl
},
2483 {"@protocol", 0, st_C_objprot
},
2484 {"interface", (C_JAVA
& ~C_PLPL
), st_C_struct
},
2485 {"extern", 0, st_C_extern
},
2486 {"extends", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2487 {"struct", 0, st_C_struct
},
2488 {"domain", C_STAR
, st_C_struct
},
2489 {"switch", 0, st_C_ignore
},
2490 {"enum", 0, st_C_enum
},
2491 {"for", 0, st_C_ignore
},
2492 {"namespace", C_PLPL
, st_C_struct
},
2493 {"class", 0, st_C_class
},
2494 {"while", 0, st_C_ignore
},
2495 {"undef", 0, st_C_define
},
2496 {"package", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2497 {"__attribute__", 0, st_C_attribute
},
2498 {"SYSCALL", 0, st_C_gnumacro
},
2499 {"ENTRY", 0, st_C_gnumacro
},
2500 {"PSEUDO", 0, st_C_gnumacro
},
2501 {"DEFUN", 0, st_C_gnumacro
}
2504 if (len
<= MAX_WORD_LENGTH
&& len
>= MIN_WORD_LENGTH
)
2506 register int key
= hash (str
, len
);
2508 if (key
<= MAX_HASH_VALUE
&& key
>= 0)
2510 register const char *s
= wordlist
[key
].name
;
2512 if (*str
== *s
&& !strncmp (str
+ 1, s
+ 1, len
- 1) && s
[len
] == '\0')
2513 return &wordlist
[key
];
2520 static enum sym_type
2521 C_symtype (str
, len
, c_ext
)
2526 register struct C_stab_entry
*se
= in_word_set (str
, len
);
2528 if (se
== NULL
|| (se
->c_ext
&& !(c_ext
& se
->c_ext
)))
2535 * Ignoring __attribute__ ((list))
2537 static bool inattribute
; /* looking at an __attribute__ construct */
2540 * C functions and variables are recognized using a simple
2541 * finite automaton. fvdef is its state variable.
2545 fvnone
, /* nothing seen */
2546 fdefunkey
, /* Emacs DEFUN keyword seen */
2547 fdefunname
, /* Emacs DEFUN name seen */
2548 foperator
, /* func: operator keyword seen (cplpl) */
2549 fvnameseen
, /* function or variable name seen */
2550 fstartlist
, /* func: just after open parenthesis */
2551 finlist
, /* func: in parameter list */
2552 flistseen
, /* func: after parameter list */
2553 fignore
, /* func: before open brace */
2554 vignore
/* var-like: ignore until ';' */
2557 static bool fvextern
; /* func or var: extern keyword seen; */
2560 * typedefs are recognized using a simple finite automaton.
2561 * typdef is its state variable.
2565 tnone
, /* nothing seen */
2566 tkeyseen
, /* typedef keyword seen */
2567 ttypeseen
, /* defined type seen */
2568 tinbody
, /* inside typedef body */
2569 tend
, /* just before typedef tag */
2570 tignore
/* junk after typedef tag */
2574 * struct-like structures (enum, struct and union) are recognized
2575 * using another simple finite automaton. `structdef' is its state
2580 snone
, /* nothing seen yet,
2581 or in struct body if bracelev > 0 */
2582 skeyseen
, /* struct-like keyword seen */
2583 stagseen
, /* struct-like tag seen */
2584 scolonseen
/* colon seen after struct-like tag */
2588 * When objdef is different from onone, objtag is the name of the class.
2590 static char *objtag
= "<uninited>";
2593 * Yet another little state machine to deal with preprocessor lines.
2597 dnone
, /* nothing seen */
2598 dsharpseen
, /* '#' seen as first char on line */
2599 ddefineseen
, /* '#' and 'define' seen */
2600 dignorerest
/* ignore rest of line */
2604 * State machine for Objective C protocols and implementations.
2605 * Idea by Tom R.Hageman <tom@basil.icce.rug.nl> (1995)
2609 onone
, /* nothing seen */
2610 oprotocol
, /* @interface or @protocol seen */
2611 oimplementation
, /* @implementations seen */
2612 otagseen
, /* class name seen */
2613 oparenseen
, /* parenthesis before category seen */
2614 ocatseen
, /* category name seen */
2615 oinbody
, /* in @implementation body */
2616 omethodsign
, /* in @implementation body, after +/- */
2617 omethodtag
, /* after method name */
2618 omethodcolon
, /* after method colon */
2619 omethodparm
, /* after method parameter */
2620 oignore
/* wait for @end */
2625 * Use this structure to keep info about the token read, and how it
2626 * should be tagged. Used by the make_C_tag function to build a tag.
2630 char *line
; /* string containing the token */
2631 int offset
; /* where the token starts in LINE */
2632 int length
; /* token length */
2634 The previous members can be used to pass strings around for generic
2635 purposes. The following ones specifically refer to creating tags. In this
2636 case the token contained here is the pattern that will be used to create a
2639 bool valid
; /* do not create a tag; the token should be
2640 invalidated whenever a state machine is
2641 reset prematurely */
2642 bool named
; /* create a named tag */
2643 int lineno
; /* source line number of tag */
2644 long linepos
; /* source char number of tag */
2645 } token
; /* latest token read */
2648 * Variables and functions for dealing with nested structures.
2649 * Idea by Mykola Dzyuba <mdzyuba@yahoo.com> (2001)
2651 static void pushclass_above
__P((int, char *, int));
2652 static void popclass_above
__P((int));
2653 static void write_classname
__P((linebuffer
*, char *qualifier
));
2656 char **cname
; /* nested class names */
2657 int *bracelev
; /* nested class brace level */
2658 int nl
; /* class nesting level (elements used) */
2659 int size
; /* length of the array */
2660 } cstack
; /* stack for nested declaration tags */
2661 /* Current struct nesting depth (namespace, class, struct, union, enum). */
2662 #define nestlev (cstack.nl)
2663 /* After struct keyword or in struct body, not inside a nested function. */
2664 #define instruct (structdef == snone && nestlev > 0 \
2665 && bracelev == cstack.bracelev[nestlev-1] + 1)
2668 pushclass_above (bracelev
, str
, len
)
2675 popclass_above (bracelev
);
2677 if (nl
>= cstack
.size
)
2679 int size
= cstack
.size
*= 2;
2680 xrnew (cstack
.cname
, size
, char *);
2681 xrnew (cstack
.bracelev
, size
, int);
2683 assert (nl
== 0 || cstack
.bracelev
[nl
-1] < bracelev
);
2684 cstack
.cname
[nl
] = (str
== NULL
) ? NULL
: savenstr (str
, len
);
2685 cstack
.bracelev
[nl
] = bracelev
;
2690 popclass_above (bracelev
)
2695 for (nl
= cstack
.nl
- 1;
2696 nl
>= 0 && cstack
.bracelev
[nl
] >= bracelev
;
2699 free (cstack
.cname
[nl
]);
2705 write_classname (cn
, qualifier
)
2710 int qlen
= strlen (qualifier
);
2712 if (cstack
.nl
== 0 || cstack
.cname
[0] == NULL
)
2716 cn
->buffer
[0] = '\0';
2720 len
= strlen (cstack
.cname
[0]);
2721 linebuffer_setlen (cn
, len
);
2722 strcpy (cn
->buffer
, cstack
.cname
[0]);
2724 for (i
= 1; i
< cstack
.nl
; i
++)
2729 s
= cstack
.cname
[i
];
2734 linebuffer_setlen (cn
, len
);
2735 strncat (cn
->buffer
, qualifier
, qlen
);
2736 strncat (cn
->buffer
, s
, slen
);
2741 static bool consider_token
__P((char *, int, int, int *, int, int, bool *));
2742 static void make_C_tag
__P((bool));
2746 * checks to see if the current token is at the start of a
2747 * function or variable, or corresponds to a typedef, or
2748 * is a struct/union/enum tag, or #define, or an enum constant.
2750 * *IS_FUNC gets TRUE if the token is a function or #define macro
2751 * with args. C_EXTP points to which language we are looking at.
2762 consider_token (str
, len
, c
, c_extp
, bracelev
, parlev
, is_func_or_var
)
2763 register char *str
; /* IN: token pointer */
2764 register int len
; /* IN: token length */
2765 register int c
; /* IN: first char after the token */
2766 int *c_extp
; /* IN, OUT: C extensions mask */
2767 int bracelev
; /* IN: brace level */
2768 int parlev
; /* IN: parenthesis level */
2769 bool *is_func_or_var
; /* OUT: function or variable found */
2771 /* When structdef is stagseen, scolonseen, or snone with bracelev > 0,
2772 structtype is the type of the preceding struct-like keyword, and
2773 structbracelev is the brace level where it has been seen. */
2774 static enum sym_type structtype
;
2775 static int structbracelev
;
2776 static enum sym_type toktype
;
2779 toktype
= C_symtype (str
, len
, *c_extp
);
2782 * Skip __attribute__
2784 if (toktype
== st_C_attribute
)
2791 * Advance the definedef state machine.
2796 /* We're not on a preprocessor line. */
2797 if (toktype
== st_C_gnumacro
)
2804 if (toktype
== st_C_define
)
2806 definedef
= ddefineseen
;
2810 definedef
= dignorerest
;
2815 * Make a tag for any macro, unless it is a constant
2816 * and constantypedefs is FALSE.
2818 definedef
= dignorerest
;
2819 *is_func_or_var
= (c
== '(');
2820 if (!*is_func_or_var
&& !constantypedefs
)
2827 error ("internal error: definedef value.", (char *)NULL
);
2836 if (toktype
== st_C_typedef
)
2856 if (structdef
== snone
&& fvdef
== fvnone
)
2875 case st_C_javastruct
:
2876 if (structdef
== stagseen
)
2877 structdef
= scolonseen
;
2881 if ((*c_extp
& C_AUTO
) /* automatic detection of C++ language */
2883 && definedef
== dnone
&& structdef
== snone
2884 && typdef
== tnone
&& fvdef
== fvnone
)
2885 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
2886 if (toktype
== st_C_template
)
2893 && (typdef
== tkeyseen
2894 || (typedefs_or_cplusplus
&& structdef
== snone
)))
2896 structdef
= skeyseen
;
2897 structtype
= toktype
;
2898 structbracelev
= bracelev
;
2899 if (fvdef
== fvnameseen
)
2905 if (structdef
== skeyseen
)
2907 structdef
= stagseen
;
2911 if (typdef
!= tnone
)
2914 /* Detect Objective C constructs. */
2924 objdef
= oimplementation
;
2928 case oimplementation
:
2929 /* Save the class tag for functions or variables defined inside. */
2930 objtag
= savenstr (str
, len
);
2934 /* Save the class tag for categories. */
2935 objtag
= savenstr (str
, len
);
2937 *is_func_or_var
= TRUE
;
2941 *is_func_or_var
= TRUE
;
2949 objdef
= omethodtag
;
2950 linebuffer_setlen (&token_name
, len
);
2951 strncpy (token_name
.buffer
, str
, len
);
2952 token_name
.buffer
[len
] = '\0';
2958 objdef
= omethodparm
;
2964 objdef
= omethodtag
;
2965 linebuffer_setlen (&token_name
, token_name
.len
+ len
);
2966 strncat (token_name
.buffer
, str
, len
);
2971 if (toktype
== st_C_objend
)
2973 /* Memory leakage here: the string pointed by objtag is
2974 never released, because many tests would be needed to
2975 avoid breaking on incorrect input code. The amount of
2976 memory leaked here is the sum of the lengths of the
2984 /* A function, variable or enum constant? */
3006 *is_func_or_var
= TRUE
;
3010 && structdef
== snone
3011 && structtype
== st_C_enum
&& bracelev
> structbracelev
)
3012 return TRUE
; /* enum constant */
3018 fvdef
= fdefunname
; /* GNU macro */
3019 *is_func_or_var
= TRUE
;
3027 if ((strneq (str
, "asm", 3) && endtoken (str
[3]))
3028 || (strneq (str
, "__asm__", 7) && endtoken (str
[7])))
3037 if (len
>= 10 && strneq (str
+len
-10, "::operator", 10))
3039 if (*c_extp
& C_AUTO
) /* automatic detection of C++ */
3040 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
3042 *is_func_or_var
= TRUE
;
3045 if (bracelev
> 0 && !instruct
)
3047 fvdef
= fvnameseen
; /* function or variable */
3048 *is_func_or_var
= TRUE
;
3059 * C_entries often keeps pointers to tokens or lines which are older than
3060 * the line currently read. By keeping two line buffers, and switching
3061 * them at end of line, it is possible to use those pointers.
3069 #define current_lb_is_new (newndx == curndx)
3070 #define switch_line_buffers() (curndx = 1 - curndx)
3072 #define curlb (lbs[curndx].lb)
3073 #define newlb (lbs[newndx].lb)
3074 #define curlinepos (lbs[curndx].linepos)
3075 #define newlinepos (lbs[newndx].linepos)
3077 #define plainc ((c_ext & C_EXT) == C_PLAIN)
3078 #define cplpl (c_ext & C_PLPL)
3079 #define cjava ((c_ext & C_JAVA) == C_JAVA)
3081 #define CNL_SAVE_DEFINEDEF() \
3083 curlinepos = charno; \
3084 readline (&curlb, inf); \
3085 lp = curlb.buffer; \
3092 CNL_SAVE_DEFINEDEF(); \
3093 if (savetoken.valid) \
3095 token = savetoken; \
3096 savetoken.valid = FALSE; \
3098 definedef = dnone; \
3106 /* This function is never called when token.valid is FALSE, but
3107 we must protect against invalid input or internal errors. */
3109 make_tag (token_name
.buffer
, token_name
.len
, isfun
, token
.line
,
3110 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3112 { /* this branch is optimised away if !DEBUG */
3113 make_tag (concat ("INVALID TOKEN:-->", token_name
.buffer
, ""),
3114 token_name
.len
+ 17, isfun
, token
.line
,
3115 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3116 error ("INVALID TOKEN", NULL
);
3119 token
.valid
= FALSE
;
3125 * This routine finds functions, variables, typedefs,
3126 * #define's, enum constants and struct/union/enum definitions in
3127 * C syntax and adds them to the list.
3130 C_entries (c_ext
, inf
)
3131 int c_ext
; /* extension of C */
3132 FILE *inf
; /* input file */
3134 register char c
; /* latest char read; '\0' for end of line */
3135 register char *lp
; /* pointer one beyond the character `c' */
3136 int curndx
, newndx
; /* indices for current and new lb */
3137 register int tokoff
; /* offset in line of start of current token */
3138 register int toklen
; /* length of current token */
3139 char *qualifier
; /* string used to qualify names */
3140 int qlen
; /* length of qualifier */
3141 int bracelev
; /* current brace level */
3142 int bracketlev
; /* current bracket level */
3143 int parlev
; /* current parenthesis level */
3144 int attrparlev
; /* __attribute__ parenthesis level */
3145 int templatelev
; /* current template level */
3146 int typdefbracelev
; /* bracelev where a typedef struct body begun */
3147 bool incomm
, inquote
, inchar
, quotednl
, midtoken
;
3148 bool yacc_rules
; /* in the rules part of a yacc file */
3149 struct tok savetoken
= {0}; /* token saved during preprocessor handling */
3152 linebuffer_init (&lbs
[0].lb
);
3153 linebuffer_init (&lbs
[1].lb
);
3154 if (cstack
.size
== 0)
3156 cstack
.size
= (DEBUG
) ? 1 : 4;
3158 cstack
.cname
= xnew (cstack
.size
, char *);
3159 cstack
.bracelev
= xnew (cstack
.size
, int);
3162 tokoff
= toklen
= typdefbracelev
= 0; /* keep compiler quiet */
3163 curndx
= newndx
= 0;
3167 fvdef
= fvnone
; fvextern
= FALSE
; typdef
= tnone
;
3168 structdef
= snone
; definedef
= dnone
; objdef
= onone
;
3170 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
3171 token
.valid
= savetoken
.valid
= FALSE
;
3172 bracelev
= bracketlev
= parlev
= attrparlev
= templatelev
= 0;
3174 { qualifier
= "."; qlen
= 1; }
3176 { qualifier
= "::"; qlen
= 2; }
3184 /* If we are at the end of the line, the next character is a
3185 '\0'; do not skip it, because it is what tells us
3186 to read the next line. */
3207 /* Newlines inside comments do not end macro definitions in
3209 CNL_SAVE_DEFINEDEF ();
3222 /* Newlines inside strings do not end macro definitions
3223 in traditional cpp, even though compilers don't
3224 usually accept them. */
3225 CNL_SAVE_DEFINEDEF ();
3235 /* Hmmm, something went wrong. */
3244 else if (bracketlev
> 0)
3249 if (--bracketlev
> 0)
3253 CNL_SAVE_DEFINEDEF ();
3281 if (fvdef
!= finlist
&& fvdef
!= fignore
&& fvdef
!=vignore
)
3294 else if (/* cplpl && */ *lp
== '/')
3300 if ((c_ext
& YACC
) && *lp
== '%')
3302 /* Entering or exiting rules section in yacc file. */
3304 definedef
= dnone
; fvdef
= fvnone
; fvextern
= FALSE
;
3305 typdef
= tnone
; structdef
= snone
;
3306 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
3308 yacc_rules
= !yacc_rules
;
3314 if (definedef
== dnone
)
3317 bool cpptoken
= TRUE
;
3319 /* Look back on this line. If all blanks, or nonblanks
3320 followed by an end of comment, this is a preprocessor
3322 for (cp
= newlb
.buffer
; cp
< lp
-1; cp
++)
3325 if (*cp
== '*' && *(cp
+1) == '/')
3334 definedef
= dsharpseen
;
3335 } /* if (definedef == dnone) */
3343 /* Consider token only if some involved conditions are satisfied. */
3344 if (typdef
!= tignore
3345 && definedef
!= dignorerest
3348 && (definedef
!= dnone
3349 || structdef
!= scolonseen
)
3356 if (c
== ':' && *lp
== ':' && begtoken (lp
[1]))
3357 /* This handles :: in the middle,
3358 but not at the beginning of an identifier.
3359 Also, space-separated :: is not recognised. */
3361 if (c_ext
& C_AUTO
) /* automatic detection of C++ */
3362 c_ext
= (c_ext
| C_PLPL
) & ~C_AUTO
;
3366 goto still_in_token
;
3370 bool funorvar
= FALSE
;
3373 || consider_token (newlb
.buffer
+ tokoff
, toklen
, c
,
3374 &c_ext
, bracelev
, parlev
,
3377 if (fvdef
== foperator
)
3380 lp
= skip_spaces (lp
-1);
3384 && !iswhite (*lp
) && *lp
!= '(')
3387 toklen
+= lp
- oldlp
;
3389 token
.named
= FALSE
;
3391 && nestlev
> 0 && definedef
== dnone
)
3392 /* in struct body */
3394 write_classname (&token_name
, qualifier
);
3395 linebuffer_setlen (&token_name
,
3396 token_name
.len
+qlen
+toklen
);
3397 strcat (token_name
.buffer
, qualifier
);
3398 strncat (token_name
.buffer
,
3399 newlb
.buffer
+ tokoff
, toklen
);
3402 else if (objdef
== ocatseen
)
3403 /* Objective C category */
3405 int len
= strlen (objtag
) + 2 + toklen
;
3406 linebuffer_setlen (&token_name
, len
);
3407 strcpy (token_name
.buffer
, objtag
);
3408 strcat (token_name
.buffer
, "(");
3409 strncat (token_name
.buffer
,
3410 newlb
.buffer
+ tokoff
, toklen
);
3411 strcat (token_name
.buffer
, ")");
3414 else if (objdef
== omethodtag
3415 || objdef
== omethodparm
)
3416 /* Objective C method */
3420 else if (fvdef
== fdefunname
)
3421 /* GNU DEFUN and similar macros */
3423 bool defun
= (newlb
.buffer
[tokoff
] == 'F');
3427 /* Rewrite the tag so that emacs lisp DEFUNs
3428 can be found by their elisp name */
3434 linebuffer_setlen (&token_name
, len
);
3435 strncpy (token_name
.buffer
,
3436 newlb
.buffer
+ off
, len
);
3437 token_name
.buffer
[len
] = '\0';
3440 if (token_name
.buffer
[len
] == '_')
3441 token_name
.buffer
[len
] = '-';
3442 token
.named
= defun
;
3446 linebuffer_setlen (&token_name
, toklen
);
3447 strncpy (token_name
.buffer
,
3448 newlb
.buffer
+ tokoff
, toklen
);
3449 token_name
.buffer
[toklen
] = '\0';
3450 /* Name macros and members. */
3451 token
.named
= (structdef
== stagseen
3452 || typdef
== ttypeseen
3455 && definedef
== dignorerest
)
3457 && definedef
== dnone
3458 && structdef
== snone
3461 token
.lineno
= lineno
;
3462 token
.offset
= tokoff
;
3463 token
.length
= toklen
;
3464 token
.line
= newlb
.buffer
;
3465 token
.linepos
= newlinepos
;
3468 if (definedef
== dnone
3469 && (fvdef
== fvnameseen
3470 || fvdef
== foperator
3471 || structdef
== stagseen
3473 || typdef
== ttypeseen
3474 || objdef
!= onone
))
3476 if (current_lb_is_new
)
3477 switch_line_buffers ();
3479 else if (definedef
!= dnone
3480 || fvdef
== fdefunname
3482 make_C_tag (funorvar
);
3484 else /* not yacc and consider_token failed */
3486 if (inattribute
&& fvdef
== fignore
)
3488 /* We have just met __attribute__ after a
3489 function parameter list: do not tag the
3496 } /* if (endtoken (c)) */
3497 else if (intoken (c
))
3503 } /* if (midtoken) */
3504 else if (begtoken (c
))
3512 /* This prevents tagging fb in
3513 void (__attribute__((noreturn)) *fb) (void);
3514 Fixing this is not easy and not very important. */
3518 if (plainc
|| declarations
)
3520 make_C_tag (TRUE
); /* a function */
3525 if (structdef
== stagseen
&& !cjava
)
3527 popclass_above (bracelev
);
3535 if (!yacc_rules
|| lp
== newlb
.buffer
+ 1)
3537 tokoff
= lp
- 1 - newlb
.buffer
;
3542 } /* if (begtoken) */
3543 } /* if must look at token */
3546 /* Detect end of line, colon, comma, semicolon and various braces
3547 after having handled a token.*/
3553 if (yacc_rules
&& token
.offset
== 0 && token
.valid
)
3555 make_C_tag (FALSE
); /* a yacc function */
3558 if (definedef
!= dnone
)
3564 make_C_tag (TRUE
); /* an Objective C class */
3568 objdef
= omethodcolon
;
3569 linebuffer_setlen (&token_name
, token_name
.len
+ 1);
3570 strcat (token_name
.buffer
, ":");
3573 if (structdef
== stagseen
)
3575 structdef
= scolonseen
;
3578 /* Should be useless, but may be work as a safety net. */
3579 if (cplpl
&& fvdef
== flistseen
)
3581 make_C_tag (TRUE
); /* a function */
3587 if (definedef
!= dnone
|| inattribute
)
3593 make_C_tag (FALSE
); /* a typedef */
3603 if (typdef
== tignore
|| cplpl
)
3607 if ((globals
&& bracelev
== 0 && (!fvextern
|| declarations
))
3608 || (members
&& instruct
))
3609 make_C_tag (FALSE
); /* a variable */
3612 token
.valid
= FALSE
;
3616 && (cplpl
|| !instruct
)
3617 && (typdef
== tnone
|| (typdef
!= tignore
&& instruct
)))
3619 && plainc
&& instruct
))
3620 make_C_tag (TRUE
); /* a function */
3626 && cplpl
&& structdef
== stagseen
)
3627 make_C_tag (FALSE
); /* forward declaration */
3629 token
.valid
= FALSE
;
3630 } /* switch (fvdef) */
3636 if (structdef
== stagseen
)
3640 if (definedef
!= dnone
|| inattribute
)
3646 make_C_tag (TRUE
); /* an Objective C method */
3667 && (!fvextern
|| declarations
))
3668 || (members
&& instruct
)))
3669 make_C_tag (FALSE
); /* a variable */
3672 if ((declarations
&& typdef
== tnone
&& !instruct
)
3673 || (members
&& typdef
!= tignore
&& instruct
))
3675 make_C_tag (TRUE
); /* a function */
3678 else if (!declarations
)
3680 token
.valid
= FALSE
;
3685 if (structdef
== stagseen
)
3689 if (definedef
!= dnone
|| inattribute
)
3691 if (structdef
== stagseen
)
3698 make_C_tag (FALSE
); /* a typedef */
3710 if ((members
&& bracelev
== 1)
3711 || (globals
&& bracelev
== 0
3712 && (!fvextern
|| declarations
)))
3713 make_C_tag (FALSE
); /* a variable */
3727 if (definedef
!= dnone
)
3729 if (objdef
== otagseen
&& parlev
== 0)
3730 objdef
= oparenseen
;
3734 if (typdef
== ttypeseen
3738 /* This handles constructs like:
3739 typedef void OperatorFun (int fun); */
3758 if (--attrparlev
== 0)
3759 inattribute
= FALSE
;
3762 if (definedef
!= dnone
)
3764 if (objdef
== ocatseen
&& parlev
== 1)
3766 make_C_tag (TRUE
); /* an Objective C category */
3780 || typdef
== ttypeseen
))
3783 make_C_tag (FALSE
); /* a typedef */
3786 else if (parlev
< 0) /* can happen due to ill-conceived #if's. */
3790 if (definedef
!= dnone
)
3792 if (typdef
== ttypeseen
)
3794 /* Whenever typdef is set to tinbody (currently only
3795 here), typdefbracelev should be set to bracelev. */
3797 typdefbracelev
= bracelev
;
3802 make_C_tag (TRUE
); /* a function */
3811 make_C_tag (TRUE
); /* an Objective C class */
3816 make_C_tag (TRUE
); /* an Objective C method */
3820 /* Neutralize `extern "C" {' grot. */
3821 if (bracelev
== 0 && structdef
== snone
&& nestlev
== 0
3829 case skeyseen
: /* unnamed struct */
3830 pushclass_above (bracelev
, NULL
, 0);
3833 case stagseen
: /* named struct or enum */
3834 case scolonseen
: /* a class */
3835 pushclass_above (bracelev
,token
.line
+token
.offset
, token
.length
);
3837 make_C_tag (FALSE
); /* a struct or enum */
3843 if (definedef
!= dnone
)
3845 if (fvdef
== fstartlist
)
3847 fvdef
= fvnone
; /* avoid tagging `foo' in `foo (*bar()) ()' */
3848 token
.valid
= FALSE
;
3852 if (definedef
!= dnone
)
3855 if (!ignoreindent
&& lp
== newlb
.buffer
+ 1)
3858 token
.valid
= FALSE
; /* unexpected value, token unreliable */
3859 bracelev
= 0; /* reset brace level if first column */
3860 parlev
= 0; /* also reset paren level, just in case... */
3862 else if (bracelev
< 0)
3864 token
.valid
= FALSE
; /* something gone amiss, token unreliable */
3867 if (bracelev
== 0 && fvdef
== vignore
)
3868 fvdef
= fvnone
; /* end of function */
3869 popclass_above (bracelev
);
3871 /* Only if typdef == tinbody is typdefbracelev significant. */
3872 if (typdef
== tinbody
&& bracelev
<= typdefbracelev
)
3874 assert (bracelev
== typdefbracelev
);
3879 if (definedef
!= dnone
)
3889 if ((members
&& bracelev
== 1)
3890 || (globals
&& bracelev
== 0 && (!fvextern
|| declarations
)))
3891 make_C_tag (FALSE
); /* a variable */
3899 && (structdef
== stagseen
|| fvdef
== fvnameseen
))
3906 if (templatelev
> 0)
3914 if (objdef
== oinbody
&& bracelev
== 0)
3916 objdef
= omethodsign
;
3921 case '#': case '~': case '&': case '%': case '/':
3922 case '|': case '^': case '!': case '.': case '?':
3923 if (definedef
!= dnone
)
3925 /* These surely cannot follow a function tag in C. */
3938 if (objdef
== otagseen
)
3940 make_C_tag (TRUE
); /* an Objective C class */
3943 /* If a macro spans multiple lines don't reset its state. */
3945 CNL_SAVE_DEFINEDEF ();
3951 } /* while not eof */
3953 free (lbs
[0].lb
.buffer
);
3954 free (lbs
[1].lb
.buffer
);
3958 * Process either a C++ file or a C file depending on the setting
3962 default_C_entries (inf
)
3965 C_entries (cplusplus
? C_PLPL
: C_AUTO
, inf
);
3968 /* Always do plain C. */
3970 plain_C_entries (inf
)
3976 /* Always do C++. */
3978 Cplusplus_entries (inf
)
3981 C_entries (C_PLPL
, inf
);
3984 /* Always do Java. */
3989 C_entries (C_JAVA
, inf
);
3997 C_entries (C_STAR
, inf
);
4000 /* Always do Yacc. */
4005 C_entries (YACC
, inf
);
4009 /* Useful macros. */
4010 #define LOOP_ON_INPUT_LINES(file_pointer, line_buffer, char_pointer) \
4011 for (; /* loop initialization */ \
4012 !feof (file_pointer) /* loop test */ \
4013 && /* instructions at start of loop */ \
4014 (readline (&line_buffer, file_pointer), \
4015 char_pointer = line_buffer.buffer, \
4019 #define LOOKING_AT(cp, kw) /* kw is the keyword, a literal string */ \
4020 ((assert("" kw), TRUE) /* syntax error if not a literal string */ \
4021 && strneq ((cp), kw, sizeof(kw)-1) /* cp points at kw */ \
4022 && notinname ((cp)[sizeof(kw)-1]) /* end of kw */ \
4023 && ((cp) = skip_spaces((cp)+sizeof(kw)-1))) /* skip spaces */
4025 /* Similar to LOOKING_AT but does not use notinname, does not skip */
4026 #define LOOKING_AT_NOCASE(cp, kw) /* the keyword is a literal string */ \
4027 ((assert("" kw), TRUE) /* syntax error if not a literal string */ \
4028 && strncaseeq ((cp), kw, sizeof(kw)-1) /* cp points at kw */ \
4029 && ((cp) += sizeof(kw)-1)) /* skip spaces */
4032 * Read a file, but do no processing. This is used to do regexp
4033 * matching on files that have no language defined.
4036 just_read_file (inf
)
4039 register char *dummy
;
4041 LOOP_ON_INPUT_LINES (inf
, lb
, dummy
)
4046 /* Fortran parsing */
4048 static void F_takeprec
__P((void));
4049 static void F_getit
__P((FILE *));
4054 dbp
= skip_spaces (dbp
);
4058 dbp
= skip_spaces (dbp
);
4059 if (strneq (dbp
, "(*)", 3))
4064 if (!ISDIGIT (*dbp
))
4066 --dbp
; /* force failure */
4071 while (ISDIGIT (*dbp
));
4080 dbp
= skip_spaces (dbp
);
4083 readline (&lb
, inf
);
4088 dbp
= skip_spaces (dbp
);
4090 if (!ISALPHA (*dbp
) && *dbp
!= '_' && *dbp
!= '$')
4092 for (cp
= dbp
+ 1; *cp
!= '\0' && intoken (*cp
); cp
++)
4094 make_tag (dbp
, cp
-dbp
, TRUE
,
4095 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4100 Fortran_functions (inf
)
4103 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4106 dbp
++; /* Ratfor escape to fortran */
4107 dbp
= skip_spaces (dbp
);
4110 switch (lowcase (*dbp
))
4113 if (nocase_tail ("integer"))
4117 if (nocase_tail ("real"))
4121 if (nocase_tail ("logical"))
4125 if (nocase_tail ("complex") || nocase_tail ("character"))
4129 if (nocase_tail ("double"))
4131 dbp
= skip_spaces (dbp
);
4134 if (nocase_tail ("precision"))
4140 dbp
= skip_spaces (dbp
);
4143 switch (lowcase (*dbp
))
4146 if (nocase_tail ("function"))
4150 if (nocase_tail ("subroutine"))
4154 if (nocase_tail ("entry"))
4158 if (nocase_tail ("blockdata") || nocase_tail ("block data"))
4160 dbp
= skip_spaces (dbp
);
4161 if (*dbp
== '\0') /* assume un-named */
4162 make_tag ("blockdata", 9, TRUE
,
4163 lb
.buffer
, dbp
- lb
.buffer
, lineno
, linecharno
);
4165 F_getit (inf
); /* look for name */
4176 * Philippe Waroquiers (1998)
4179 static void Ada_getit
__P((FILE *, char *));
4181 /* Once we are positioned after an "interesting" keyword, let's get
4182 the real tag value necessary. */
4184 Ada_getit (inf
, name_qualifier
)
4186 char *name_qualifier
;
4194 dbp
= skip_spaces (dbp
);
4196 || (dbp
[0] == '-' && dbp
[1] == '-'))
4198 readline (&lb
, inf
);
4201 switch (lowcase(*dbp
))
4204 if (nocase_tail ("body"))
4206 /* Skipping body of procedure body or package body or ....
4207 resetting qualifier to body instead of spec. */
4208 name_qualifier
= "/b";
4213 /* Skipping type of task type or protected type ... */
4214 if (nocase_tail ("type"))
4221 for (cp
= dbp
; *cp
!= '\0' && *cp
!= '"'; cp
++)
4226 dbp
= skip_spaces (dbp
);
4229 && (ISALPHA (*cp
) || ISDIGIT (*cp
) || *cp
== '_' || *cp
== '.'));
4237 name
= concat (dbp
, name_qualifier
, "");
4239 make_tag (name
, strlen (name
), TRUE
,
4240 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4252 bool inquote
= FALSE
;
4253 bool skip_till_semicolumn
= FALSE
;
4255 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4257 while (*dbp
!= '\0')
4259 /* Skip a string i.e. "abcd". */
4260 if (inquote
|| (*dbp
== '"'))
4262 dbp
= etags_strchr ((inquote
) ? dbp
: dbp
+1, '"');
4267 continue; /* advance char */
4272 break; /* advance line */
4276 /* Skip comments. */
4277 if (dbp
[0] == '-' && dbp
[1] == '-')
4278 break; /* advance line */
4280 /* Skip character enclosed in single quote i.e. 'a'
4281 and skip single quote starting an attribute i.e. 'Image. */
4290 if (skip_till_semicolumn
)
4293 skip_till_semicolumn
= FALSE
;
4295 continue; /* advance char */
4298 /* Search for beginning of a token. */
4299 if (!begtoken (*dbp
))
4302 continue; /* advance char */
4305 /* We are at the beginning of a token. */
4306 switch (lowcase(*dbp
))
4309 if (!packages_only
&& nocase_tail ("function"))
4310 Ada_getit (inf
, "/f");
4312 break; /* from switch */
4313 continue; /* advance char */
4315 if (!packages_only
&& nocase_tail ("procedure"))
4316 Ada_getit (inf
, "/p");
4317 else if (nocase_tail ("package"))
4318 Ada_getit (inf
, "/s");
4319 else if (nocase_tail ("protected")) /* protected type */
4320 Ada_getit (inf
, "/t");
4322 break; /* from switch */
4323 continue; /* advance char */
4326 if (typedefs
&& !packages_only
&& nocase_tail ("use"))
4328 /* when tagging types, avoid tagging use type Pack.Typename;
4329 for this, we will skip everything till a ; */
4330 skip_till_semicolumn
= TRUE
;
4331 continue; /* advance char */
4335 if (!packages_only
&& nocase_tail ("task"))
4336 Ada_getit (inf
, "/k");
4337 else if (typedefs
&& !packages_only
&& nocase_tail ("type"))
4339 Ada_getit (inf
, "/t");
4340 while (*dbp
!= '\0')
4344 break; /* from switch */
4345 continue; /* advance char */
4348 /* Look for the end of the token. */
4349 while (!endtoken (*dbp
))
4352 } /* advance char */
4353 } /* advance line */
4358 * Unix and microcontroller assembly tag handling
4359 * Labels: /^[a-zA-Z_.$][a-zA_Z0-9_.$]*[: ^I^J]/
4360 * Idea by Bob Weiner, Motorola Inc. (1994)
4368 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4370 /* If first char is alphabetic or one of [_.$], test for colon
4371 following identifier. */
4372 if (ISALPHA (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4374 /* Read past label. */
4376 while (ISALNUM (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4378 if (*cp
== ':' || iswhite (*cp
))
4379 /* Found end of label, so copy it and add it to the table. */
4380 make_tag (lb
.buffer
, cp
- lb
.buffer
, TRUE
,
4381 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4389 * Perl sub names: /^sub[ \t\n]+[^ \t\n{]+/
4390 * Perl variable names: /^(my|local).../
4391 * Original code by Bart Robinson <lomew@cs.utah.edu> (1995)
4392 * Additions by Michael Ernst <mernst@alum.mit.edu> (1997)
4393 * Ideas by Kai Großjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE> (2001)
4396 Perl_functions (inf
)
4399 char *package
= savestr ("main"); /* current package name */
4402 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4404 cp
= skip_spaces (cp
);
4406 if (LOOKING_AT (cp
, "package"))
4409 get_tag (cp
, &package
);
4411 else if (LOOKING_AT (cp
, "sub"))
4416 while (!notinname (*cp
))
4419 continue; /* nothing found */
4420 if ((pos
= etags_strchr (sp
, ':')) != NULL
4421 && pos
< cp
&& pos
[1] == ':')
4422 /* The name is already qualified. */
4423 make_tag (sp
, cp
- sp
, TRUE
,
4424 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4428 char savechar
, *name
;
4432 name
= concat (package
, "::", sp
);
4434 make_tag (name
, strlen(name
), TRUE
,
4435 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4439 else if (globals
) /* only if we are tagging global vars */
4441 /* Skip a qualifier, if any. */
4442 bool qual
= LOOKING_AT (cp
, "my") || LOOKING_AT (cp
, "local");
4443 /* After "my" or "local", but before any following paren or space. */
4444 char *varstart
= cp
;
4446 if (qual
/* should this be removed? If yes, how? */
4447 && (*cp
== '$' || *cp
== '@' || *cp
== '%'))
4452 while (ISALNUM (*cp
) || *cp
== '_');
4456 /* Should be examining a variable list at this point;
4457 could insist on seeing an open parenthesis. */
4458 while (*cp
!= '\0' && *cp
!= ';' && *cp
!= '=' && *cp
!= ')')
4464 make_tag (varstart
, cp
- varstart
, FALSE
,
4465 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4474 * Look for /^[\t]*def[ \t\n]+[^ \t\n(:]+/ or /^class[ \t\n]+[^ \t\n(:]+/
4475 * Idea by Eric S. Raymond <esr@thyrsus.com> (1997)
4476 * More ideas by seb bacon <seb@jamkit.com> (2002)
4479 Python_functions (inf
)
4484 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4486 cp
= skip_spaces (cp
);
4487 if (LOOKING_AT (cp
, "def") || LOOKING_AT (cp
, "class"))
4490 while (!notinname (*cp
) && *cp
!= ':')
4492 make_tag (name
, cp
- name
, TRUE
,
4493 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4502 * - /^[ \t]*function[ \t\n]+[^ \t\n(]+/
4503 * - /^[ \t]*class[ \t\n]+[^ \t\n]+/
4504 * - /^[ \t]*define\(\"[^\"]+/
4505 * Only with --members:
4506 * - /^[ \t]*var[ \t\n]+\$[^ \t\n=;]/
4507 * Idea by Diez B. Roggisch (2001)
4513 register char *cp
, *name
;
4514 bool search_identifier
= FALSE
;
4516 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4518 cp
= skip_spaces (cp
);
4520 if (search_identifier
4523 while (!notinname (*cp
))
4525 make_tag (name
, cp
- name
, TRUE
,
4526 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4527 search_identifier
= FALSE
;
4529 else if (LOOKING_AT (cp
, "function"))
4532 cp
= skip_spaces (cp
+1);
4536 while (!notinname (*cp
))
4538 make_tag (name
, cp
- name
, TRUE
,
4539 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4542 search_identifier
= TRUE
;
4544 else if (LOOKING_AT (cp
, "class"))
4549 while (*cp
!= '\0' && !iswhite (*cp
))
4551 make_tag (name
, cp
- name
, FALSE
,
4552 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4555 search_identifier
= TRUE
;
4557 else if (strneq (cp
, "define", 6)
4558 && (cp
= skip_spaces (cp
+6))
4560 && (*cp
== '"' || *cp
== '\''))
4564 while (*cp
!= quote
&& *cp
!= '\0')
4566 make_tag (name
, cp
- name
, FALSE
,
4567 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4570 && LOOKING_AT (cp
, "var")
4574 while (!notinname(*cp
))
4576 make_tag (name
, cp
- name
, FALSE
,
4577 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4584 * Cobol tag functions
4585 * We could look for anything that could be a paragraph name.
4586 * i.e. anything that starts in column 8 is one word and ends in a full stop.
4587 * Idea by Corny de Souza (1993)
4590 Cobol_paragraphs (inf
)
4593 register char *bp
, *ep
;
4595 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4601 /* If eoln, compiler option or comment ignore whole line. */
4602 if (bp
[-1] != ' ' || !ISALNUM (bp
[0]))
4605 for (ep
= bp
; ISALNUM (*ep
) || *ep
== '-'; ep
++)
4608 make_tag (bp
, ep
- bp
, TRUE
,
4609 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4616 * Ideas by Assar Westerlund <assar@sics.se> (2001)
4619 Makefile_targets (inf
)
4624 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4626 if (*bp
== '\t' || *bp
== '#')
4628 while (*bp
!= '\0' && *bp
!= '=' && *bp
!= ':')
4630 if (*bp
== ':' || (globals
&& *bp
== '='))
4632 /* We should detect if there is more than one tag, but we do not.
4633 We just skip initial and final spaces. */
4634 char * namestart
= skip_spaces (lb
.buffer
);
4635 while (--bp
> namestart
)
4636 if (!notinname (*bp
))
4638 make_tag (namestart
, bp
- namestart
+ 1, TRUE
,
4639 lb
.buffer
, bp
- lb
.buffer
+ 2, lineno
, linecharno
);
4647 * Original code by Mosur K. Mohan (1989)
4649 * Locates tags for procedures & functions. Doesn't do any type- or
4650 * var-definitions. It does look for the keyword "extern" or
4651 * "forward" immediately following the procedure statement; if found,
4652 * the tag is skipped.
4655 Pascal_functions (inf
)
4658 linebuffer tline
; /* mostly copied from C_entries */
4660 int save_lineno
, namelen
, taglen
;
4663 bool /* each of these flags is TRUE if: */
4664 incomment
, /* point is inside a comment */
4665 inquote
, /* point is inside '..' string */
4666 get_tagname
, /* point is after PROCEDURE/FUNCTION
4667 keyword, so next item = potential tag */
4668 found_tag
, /* point is after a potential tag */
4669 inparms
, /* point is within parameter-list */
4670 verify_tag
; /* point has passed the parm-list, so the
4671 next token will determine whether this
4672 is a FORWARD/EXTERN to be ignored, or
4673 whether it is a real tag */
4675 save_lcno
= save_lineno
= namelen
= taglen
= 0; /* keep compiler quiet */
4676 name
= NULL
; /* keep compiler quiet */
4679 linebuffer_init (&tline
);
4681 incomment
= inquote
= FALSE
;
4682 found_tag
= FALSE
; /* have a proc name; check if extern */
4683 get_tagname
= FALSE
; /* found "procedure" keyword */
4684 inparms
= FALSE
; /* found '(' after "proc" */
4685 verify_tag
= FALSE
; /* check if "extern" is ahead */
4688 while (!feof (inf
)) /* long main loop to get next char */
4691 if (c
== '\0') /* if end of line */
4693 readline (&lb
, inf
);
4697 if (!((found_tag
&& verify_tag
)
4699 c
= *dbp
++; /* only if don't need *dbp pointing
4700 to the beginning of the name of
4701 the procedure or function */
4705 if (c
== '}') /* within { } comments */
4707 else if (c
== '*' && *dbp
== ')') /* within (* *) comments */
4724 inquote
= TRUE
; /* found first quote */
4726 case '{': /* found open { comment */
4730 if (*dbp
== '*') /* found open (* comment */
4735 else if (found_tag
) /* found '(' after tag, i.e., parm-list */
4738 case ')': /* end of parms list */
4743 if (found_tag
&& !inparms
) /* end of proc or fn stmt */
4750 if (found_tag
&& verify_tag
&& (*dbp
!= ' '))
4752 /* Check if this is an "extern" declaration. */
4755 if (lowcase (*dbp
== 'e'))
4757 if (nocase_tail ("extern")) /* superfluous, really! */
4763 else if (lowcase (*dbp
) == 'f')
4765 if (nocase_tail ("forward")) /* check for forward reference */
4771 if (found_tag
&& verify_tag
) /* not external proc, so make tag */
4775 make_tag (name
, namelen
, TRUE
,
4776 tline
.buffer
, taglen
, save_lineno
, save_lcno
);
4780 if (get_tagname
) /* grab name of proc or fn */
4787 /* Find block name. */
4788 for (cp
= dbp
+ 1; *cp
!= '\0' && !endtoken (*cp
); cp
++)
4791 /* Save all values for later tagging. */
4792 linebuffer_setlen (&tline
, lb
.len
);
4793 strcpy (tline
.buffer
, lb
.buffer
);
4794 save_lineno
= lineno
;
4795 save_lcno
= linecharno
;
4796 name
= tline
.buffer
+ (dbp
- lb
.buffer
);
4798 taglen
= cp
- lb
.buffer
+ 1;
4800 dbp
= cp
; /* set dbp to e-o-token */
4801 get_tagname
= FALSE
;
4805 /* And proceed to check for "extern". */
4807 else if (!incomment
&& !inquote
&& !found_tag
)
4809 /* Check for proc/fn keywords. */
4810 switch (lowcase (c
))
4813 if (nocase_tail ("rocedure")) /* c = 'p', dbp has advanced */
4817 if (nocase_tail ("unction"))
4822 } /* while not eof */
4824 free (tline
.buffer
);
4829 * Lisp tag functions
4830 * look for (def or (DEF, quote or QUOTE
4833 static void L_getit
__P((void));
4838 if (*dbp
== '\'') /* Skip prefix quote */
4840 else if (*dbp
== '(')
4843 /* Try to skip "(quote " */
4844 if (!LOOKING_AT (dbp
, "quote") && !LOOKING_AT (dbp
, "QUOTE"))
4845 /* Ok, then skip "(" before name in (defstruct (foo)) */
4846 dbp
= skip_spaces (dbp
);
4848 get_tag (dbp
, NULL
);
4852 Lisp_functions (inf
)
4855 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4860 if (strneq (dbp
+1, "def", 3) || strneq (dbp
+1, "DEF", 3))
4862 dbp
= skip_non_spaces (dbp
);
4863 dbp
= skip_spaces (dbp
);
4868 /* Check for (foo::defmumble name-defined ... */
4871 while (!notinname (*dbp
) && *dbp
!= ':');
4876 while (*dbp
== ':');
4878 if (strneq (dbp
, "def", 3) || strneq (dbp
, "DEF", 3))
4880 dbp
= skip_non_spaces (dbp
);
4881 dbp
= skip_spaces (dbp
);
4891 * Lua script language parsing
4892 * Original code by David A. Capello <dacap@users.sourceforge.net> (2004)
4894 * "function" and "local function" are tags if they start at column 1.
4902 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4904 if (bp
[0] != 'f' && bp
[0] != 'l')
4907 (void)LOOKING_AT (bp
, "local"); /* skip possible "local" */
4909 if (LOOKING_AT (bp
, "function"))
4917 * Just look for lines where the first character is '/'
4918 * Also look at "defineps" for PSWrap
4920 * Richard Mlynarik <mly@adoc.xerox.com> (1997)
4921 * Masatake Yamato <masata-y@is.aist-nara.ac.jp> (1999)
4927 register char *bp
, *ep
;
4929 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4934 *ep
!= '\0' && *ep
!= ' ' && *ep
!= '{';
4937 make_tag (bp
, ep
- bp
, TRUE
,
4938 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4940 else if (LOOKING_AT (bp
, "defineps"))
4948 * Ignore anything after \ followed by space or in ( )
4949 * Look for words defined by :
4950 * Look for constant, code, create, defer, value, and variable
4951 * OBP extensions: Look for buffer:, field,
4952 * Ideas by Eduardo Horvath <eeh@netbsd.org> (2004)
4960 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4961 while ((bp
= skip_spaces (bp
))[0] != '\0')
4962 if (bp
[0] == '\\' && iswhite(bp
[1]))
4963 break; /* read next line */
4964 else if (bp
[0] == '(' && iswhite(bp
[1]))
4965 do /* skip to ) or eol */
4967 while (*bp
!= ')' && *bp
!= '\0');
4968 else if ((bp
[0] == ':' && iswhite(bp
[1]) && bp
++)
4969 || LOOKING_AT_NOCASE (bp
, "constant")
4970 || LOOKING_AT_NOCASE (bp
, "code")
4971 || LOOKING_AT_NOCASE (bp
, "create")
4972 || LOOKING_AT_NOCASE (bp
, "defer")
4973 || LOOKING_AT_NOCASE (bp
, "value")
4974 || LOOKING_AT_NOCASE (bp
, "variable")
4975 || LOOKING_AT_NOCASE (bp
, "buffer:")
4976 || LOOKING_AT_NOCASE (bp
, "field"))
4977 get_tag (skip_spaces (bp
), NULL
); /* Yay! A definition! */
4979 bp
= skip_non_spaces (bp
);
4984 * Scheme tag functions
4985 * look for (def... xyzzy
4987 * (def ... ((...(xyzzy ....
4989 * Original code by Ken Haase (1985?)
4992 Scheme_functions (inf
)
4997 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4999 if (strneq (bp
, "(def", 4) || strneq (bp
, "(DEF", 4))
5001 bp
= skip_non_spaces (bp
+4);
5002 /* Skip over open parens and white space */
5003 while (notinname (*bp
))
5007 if (LOOKING_AT (bp
, "(SET!") || LOOKING_AT (bp
, "(set!"))
5013 /* Find tags in TeX and LaTeX input files. */
5015 /* TEX_toktab is a table of TeX control sequences that define tags.
5016 * Each entry records one such control sequence.
5018 * Original code from who knows whom.
5020 * Stefan Monnier (2002)
5023 static linebuffer
*TEX_toktab
= NULL
; /* Table with tag tokens */
5025 /* Default set of control sequences to put into TEX_toktab.
5026 The value of environment var TEXTAGS is prepended to this. */
5027 static char *TEX_defenv
= "\
5028 :chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem\
5029 :part:appendix:entry:index:def\
5030 :newcommand:renewcommand:newenvironment:renewenvironment";
5032 static void TEX_mode
__P((FILE *));
5033 static void TEX_decode_env
__P((char *, char *));
5035 static char TEX_esc
= '\\';
5036 static char TEX_opgrp
= '{';
5037 static char TEX_clgrp
= '}';
5040 * TeX/LaTeX scanning loop.
5049 /* Select either \ or ! as escape character. */
5052 /* Initialize token table once from environment. */
5053 if (TEX_toktab
== NULL
)
5054 TEX_decode_env ("TEXTAGS", TEX_defenv
);
5056 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5058 /* Look at each TEX keyword in line. */
5061 /* Look for a TEX escape. */
5062 while (*cp
++ != TEX_esc
)
5063 if (cp
[-1] == '\0' || cp
[-1] == '%')
5066 for (key
= TEX_toktab
; key
->buffer
!= NULL
; key
++)
5067 if (strneq (cp
, key
->buffer
, key
->len
))
5070 int namelen
, linelen
;
5073 cp
= skip_spaces (cp
+ key
->len
);
5074 if (*cp
== TEX_opgrp
)
5080 (!iswhite (*p
) && *p
!= '#' &&
5081 *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
);
5086 if (!opgrp
|| *p
== TEX_clgrp
)
5088 while (*p
!= '\0' && *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
)
5090 linelen
= p
- lb
.buffer
+ 1;
5092 make_tag (cp
, namelen
, TRUE
,
5093 lb
.buffer
, linelen
, lineno
, linecharno
);
5094 goto tex_next_line
; /* We only tag a line once */
5102 #define TEX_LESC '\\'
5103 #define TEX_SESC '!'
5105 /* Figure out whether TeX's escapechar is '\\' or '!' and set grouping
5106 chars accordingly. */
5113 while ((c
= getc (inf
)) != EOF
)
5115 /* Skip to next line if we hit the TeX comment char. */
5117 while (c
!= '\n' && c
!= EOF
)
5119 else if (c
== TEX_LESC
|| c
== TEX_SESC
)
5135 /* If the input file is compressed, inf is a pipe, and rewind may fail.
5136 No attempt is made to correct the situation. */
5140 /* Read environment and prepend it to the default string.
5141 Build token table. */
5143 TEX_decode_env (evarname
, defenv
)
5147 register char *env
, *p
;
5150 /* Append default string to environment. */
5151 env
= getenv (evarname
);
5157 env
= concat (oldenv
, defenv
, "");
5160 /* Allocate a token table */
5161 for (len
= 1, p
= env
; p
;)
5162 if ((p
= etags_strchr (p
, ':')) && *++p
!= '\0')
5164 TEX_toktab
= xnew (len
, linebuffer
);
5166 /* Unpack environment string into token table. Be careful about */
5167 /* zero-length strings (leading ':', "::" and trailing ':') */
5168 for (i
= 0; *env
!= '\0';)
5170 p
= etags_strchr (env
, ':');
5171 if (!p
) /* End of environment string. */
5172 p
= env
+ strlen (env
);
5174 { /* Only non-zero strings. */
5175 TEX_toktab
[i
].buffer
= savenstr (env
, p
- env
);
5176 TEX_toktab
[i
].len
= p
- env
;
5183 TEX_toktab
[i
].buffer
= NULL
; /* Mark end of table. */
5184 TEX_toktab
[i
].len
= 0;
5191 /* Texinfo support. Dave Love, Mar. 2000. */
5197 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5198 if (LOOKING_AT (cp
, "@node"))
5201 while (*cp
!= '\0' && *cp
!= ',')
5203 make_tag (start
, cp
- start
, TRUE
,
5204 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
5211 * Contents of <title>, <h1>, <h2>, <h3> are tags.
5212 * Contents of <a name=xxx> are tags with name xxx.
5214 * Francesco Potortì, 2002.
5220 bool getnext
= FALSE
; /* next text outside of HTML tags is a tag */
5221 bool skiptag
= FALSE
; /* skip to the end of the current HTML tag */
5222 bool intag
= FALSE
; /* inside an html tag, looking for ID= */
5223 bool inanchor
= FALSE
; /* when INTAG, is an anchor, look for NAME= */
5227 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5229 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
5230 for (;;) /* loop on the same line */
5232 if (skiptag
) /* skip HTML tag */
5234 while (*dbp
!= '\0' && *dbp
!= '>')
5240 continue; /* look on the same line */
5242 break; /* go to next line */
5245 else if (intag
) /* look for "name=" or "id=" */
5247 while (*dbp
!= '\0' && *dbp
!= '>'
5248 && lowcase (*dbp
) != 'n' && lowcase (*dbp
) != 'i')
5251 break; /* go to next line */
5256 continue; /* look on the same line */
5258 if ((inanchor
&& LOOKING_AT_NOCASE (dbp
, "name="))
5259 || LOOKING_AT_NOCASE (dbp
, "id="))
5261 bool quoted
= (dbp
[0] == '"');
5264 for (end
= ++dbp
; *end
!= '\0' && *end
!= '"'; end
++)
5267 for (end
= dbp
; *end
!= '\0' && intoken (*end
); end
++)
5269 linebuffer_setlen (&token_name
, end
- dbp
);
5270 strncpy (token_name
.buffer
, dbp
, end
- dbp
);
5271 token_name
.buffer
[end
- dbp
] = '\0';
5274 intag
= FALSE
; /* we found what we looked for */
5275 skiptag
= TRUE
; /* skip to the end of the tag */
5276 getnext
= TRUE
; /* then grab the text */
5277 continue; /* look on the same line */
5282 else if (getnext
) /* grab next tokens and tag them */
5284 dbp
= skip_spaces (dbp
);
5286 break; /* go to next line */
5290 inanchor
= (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]));
5291 continue; /* look on the same line */
5294 for (end
= dbp
+ 1; *end
!= '\0' && *end
!= '<'; end
++)
5296 make_tag (token_name
.buffer
, token_name
.len
, TRUE
,
5297 dbp
, end
- dbp
, lineno
, linecharno
);
5298 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5300 break; /* go to next line */
5303 else /* look for an interesting HTML tag */
5305 while (*dbp
!= '\0' && *dbp
!= '<')
5308 break; /* go to next line */
5310 if (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]))
5313 continue; /* look on the same line */
5315 else if (LOOKING_AT_NOCASE (dbp
, "<title>")
5316 || LOOKING_AT_NOCASE (dbp
, "<h1>")
5317 || LOOKING_AT_NOCASE (dbp
, "<h2>")
5318 || LOOKING_AT_NOCASE (dbp
, "<h3>"))
5322 continue; /* look on the same line */
5333 * Assumes that the predicate or rule starts at column 0.
5334 * Only the first clause of a predicate or rule is added.
5335 * Original code by Sunichirou Sugou (1989)
5336 * Rewritten by Anders Lindgren (1996)
5338 static int prolog_pr
__P((char *, char *));
5339 static void prolog_skip_comment
__P((linebuffer
*, FILE *));
5340 static int prolog_atom
__P((char *, int));
5343 Prolog_functions (inf
)
5354 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5356 if (cp
[0] == '\0') /* Empty line */
5358 else if (iswhite (cp
[0])) /* Not a predicate */
5360 else if (cp
[0] == '/' && cp
[1] == '*') /* comment. */
5361 prolog_skip_comment (&lb
, inf
);
5362 else if ((len
= prolog_pr (cp
, last
)) > 0)
5364 /* Predicate or rule. Store the function name so that we
5365 only generate a tag for the first clause. */
5367 last
= xnew(len
+ 1, char);
5368 else if (len
+ 1 > allocated
)
5369 xrnew (last
, len
+ 1, char);
5370 allocated
= len
+ 1;
5371 strncpy (last
, cp
, len
);
5380 prolog_skip_comment (plb
, inf
)
5388 for (cp
= plb
->buffer
; *cp
!= '\0'; cp
++)
5389 if (cp
[0] == '*' && cp
[1] == '/')
5391 readline (plb
, inf
);
5397 * A predicate or rule definition is added if it matches:
5398 * <beginning of line><Prolog Atom><whitespace>(
5399 * or <beginning of line><Prolog Atom><whitespace>:-
5401 * It is added to the tags database if it doesn't match the
5402 * name of the previous clause header.
5404 * Return the size of the name of the predicate or rule, or 0 if no
5410 char *last
; /* Name of last clause. */
5415 pos
= prolog_atom (s
, 0);
5420 pos
= skip_spaces (s
+ pos
) - s
;
5423 || (s
[pos
] == '(' && (pos
+= 1))
5424 || (s
[pos
] == ':' && s
[pos
+ 1] == '-' && (pos
+= 2)))
5425 && (last
== NULL
/* save only the first clause */
5426 || len
!= (int)strlen (last
)
5427 || !strneq (s
, last
, len
)))
5429 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5437 * Consume a Prolog atom.
5438 * Return the number of bytes consumed, or -1 if there was an error.
5440 * A prolog atom, in this context, could be one of:
5441 * - An alphanumeric sequence, starting with a lower case letter.
5442 * - A quoted arbitrary string. Single quotes can escape themselves.
5443 * Backslash quotes everything.
5446 prolog_atom (s
, pos
)
5454 if (ISLOWER(s
[pos
]) || (s
[pos
] == '_'))
5456 /* The atom is unquoted. */
5458 while (ISALNUM(s
[pos
]) || (s
[pos
] == '_'))
5462 return pos
- origpos
;
5464 else if (s
[pos
] == '\'')
5475 pos
++; /* A double quote */
5477 else if (s
[pos
] == '\0')
5478 /* Multiline quoted atoms are ignored. */
5480 else if (s
[pos
] == '\\')
5482 if (s
[pos
+1] == '\0')
5489 return pos
- origpos
;
5497 * Support for Erlang
5499 * Generates tags for functions, defines, and records.
5500 * Assumes that Erlang functions start at column 0.
5501 * Original code by Anders Lindgren (1996)
5503 static int erlang_func
__P((char *, char *));
5504 static void erlang_attribute
__P((char *));
5505 static int erlang_atom
__P((char *));
5508 Erlang_functions (inf
)
5519 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5521 if (cp
[0] == '\0') /* Empty line */
5523 else if (iswhite (cp
[0])) /* Not function nor attribute */
5525 else if (cp
[0] == '%') /* comment */
5527 else if (cp
[0] == '"') /* Sometimes, strings start in column one */
5529 else if (cp
[0] == '-') /* attribute, e.g. "-define" */
5531 erlang_attribute (cp
);
5538 else if ((len
= erlang_func (cp
, last
)) > 0)
5541 * Function. Store the function name so that we only
5542 * generates a tag for the first clause.
5545 last
= xnew (len
+ 1, char);
5546 else if (len
+ 1 > allocated
)
5547 xrnew (last
, len
+ 1, char);
5548 allocated
= len
+ 1;
5549 strncpy (last
, cp
, len
);
5558 * A function definition is added if it matches:
5559 * <beginning of line><Erlang Atom><whitespace>(
5561 * It is added to the tags database if it doesn't match the
5562 * name of the previous clause header.
5564 * Return the size of the name of the function, or 0 if no function
5568 erlang_func (s
, last
)
5570 char *last
; /* Name of last clause. */
5575 pos
= erlang_atom (s
);
5580 pos
= skip_spaces (s
+ pos
) - s
;
5582 /* Save only the first clause. */
5585 || len
!= (int)strlen (last
)
5586 || !strneq (s
, last
, len
)))
5588 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5597 * Handle attributes. Currently, tags are generated for defines
5600 * They are on the form:
5601 * -define(foo, bar).
5602 * -define(Foo(M, N), M+N).
5603 * -record(graph, {vtab = notable, cyclic = true}).
5606 erlang_attribute (s
)
5611 if ((LOOKING_AT (cp
, "-define") || LOOKING_AT (cp
, "-record"))
5614 int len
= erlang_atom (skip_spaces (cp
));
5616 make_tag (cp
, len
, TRUE
, s
, cp
+ len
- s
, lineno
, linecharno
);
5623 * Consume an Erlang atom (or variable).
5624 * Return the number of bytes consumed, or -1 if there was an error.
5632 if (ISALPHA (s
[pos
]) || s
[pos
] == '_')
5634 /* The atom is unquoted. */
5637 while (ISALNUM (s
[pos
]) || s
[pos
] == '_');
5639 else if (s
[pos
] == '\'')
5641 for (pos
++; s
[pos
] != '\''; pos
++)
5642 if (s
[pos
] == '\0' /* multiline quoted atoms are ignored */
5643 || (s
[pos
] == '\\' && s
[++pos
] == '\0'))
5652 static char *scan_separators
__P((char *));
5653 static void add_regex
__P((char *, language
*));
5654 static char *substitute
__P((char *, char *, struct re_registers
*));
5657 * Take a string like "/blah/" and turn it into "blah", verifying
5658 * that the first and last characters are the same, and handling
5659 * quoted separator characters. Actually, stops on the occurrence of
5660 * an unquoted separator. Also process \t, \n, etc. and turn into
5661 * appropriate characters. Works in place. Null terminates name string.
5662 * Returns pointer to terminating separator, or NULL for
5663 * unterminated regexps.
5666 scan_separators (name
)
5670 char *copyto
= name
;
5671 bool quoted
= FALSE
;
5673 for (++name
; *name
!= '\0'; ++name
)
5679 case 'a': *copyto
++ = '\007'; break; /* BEL (bell) */
5680 case 'b': *copyto
++ = '\b'; break; /* BS (back space) */
5681 case 'd': *copyto
++ = 0177; break; /* DEL (delete) */
5682 case 'e': *copyto
++ = 033; break; /* ESC (delete) */
5683 case 'f': *copyto
++ = '\f'; break; /* FF (form feed) */
5684 case 'n': *copyto
++ = '\n'; break; /* NL (new line) */
5685 case 'r': *copyto
++ = '\r'; break; /* CR (carriage return) */
5686 case 't': *copyto
++ = '\t'; break; /* TAB (horizontal tab) */
5687 case 'v': *copyto
++ = '\v'; break; /* VT (vertical tab) */
5693 /* Something else is quoted, so preserve the quote. */
5701 else if (*name
== '\\')
5703 else if (*name
== sep
)
5709 name
= NULL
; /* signal unterminated regexp */
5711 /* Terminate copied string. */
5716 /* Look at the argument of --regex or --no-regex and do the right
5717 thing. Same for each line of a regexp file. */
5719 analyse_regex (regex_arg
)
5722 if (regex_arg
== NULL
)
5724 free_regexps (); /* --no-regex: remove existing regexps */
5728 /* A real --regexp option or a line in a regexp file. */
5729 switch (regex_arg
[0])
5731 /* Comments in regexp file or null arg to --regex. */
5737 /* Read a regex file. This is recursive and may result in a
5738 loop, which will stop when the file descriptors are exhausted. */
5742 linebuffer regexbuf
;
5743 char *regexfile
= regex_arg
+ 1;
5745 /* regexfile is a file containing regexps, one per line. */
5746 regexfp
= fopen (regexfile
, "r");
5747 if (regexfp
== NULL
)
5752 linebuffer_init (®exbuf
);
5753 while (readline_internal (®exbuf
, regexfp
) > 0)
5754 analyse_regex (regexbuf
.buffer
);
5755 free (regexbuf
.buffer
);
5760 /* Regexp to be used for a specific language only. */
5764 char *lang_name
= regex_arg
+ 1;
5767 for (cp
= lang_name
; *cp
!= '}'; cp
++)
5770 error ("unterminated language name in regex: %s", regex_arg
);
5774 lang
= get_language_from_langname (lang_name
);
5777 add_regex (cp
, lang
);
5781 /* Regexp to be used for any language. */
5783 add_regex (regex_arg
, NULL
);
5788 /* Separate the regexp pattern, compile it,
5789 and care for optional name and modifiers. */
5791 add_regex (regexp_pattern
, lang
)
5792 char *regexp_pattern
;
5795 static struct re_pattern_buffer zeropattern
;
5796 char sep
, *pat
, *name
, *modifiers
;
5798 struct re_pattern_buffer
*patbuf
;
5801 force_explicit_name
= TRUE
, /* do not use implicit tag names */
5802 ignore_case
= FALSE
, /* case is significant */
5803 multi_line
= FALSE
, /* matches are done one line at a time */
5804 single_line
= FALSE
; /* dot does not match newline */
5807 if (strlen(regexp_pattern
) < 3)
5809 error ("null regexp", (char *)NULL
);
5812 sep
= regexp_pattern
[0];
5813 name
= scan_separators (regexp_pattern
);
5816 error ("%s: unterminated regexp", regexp_pattern
);
5821 error ("null name for regexp \"%s\"", regexp_pattern
);
5824 modifiers
= scan_separators (name
);
5825 if (modifiers
== NULL
) /* no terminating separator --> no name */
5831 modifiers
+= 1; /* skip separator */
5833 /* Parse regex modifiers. */
5834 for (; modifiers
[0] != '\0'; modifiers
++)
5835 switch (modifiers
[0])
5838 if (modifiers
== name
)
5839 error ("forcing explicit tag name but no name, ignoring", NULL
);
5840 force_explicit_name
= TRUE
;
5850 need_filebuf
= TRUE
;
5855 wrongmod
[0] = modifiers
[0];
5857 error ("invalid regexp modifier `%s', ignoring", wrongmod
);
5862 patbuf
= xnew (1, struct re_pattern_buffer
);
5863 *patbuf
= zeropattern
;
5866 static char lc_trans
[CHARS
];
5868 for (i
= 0; i
< CHARS
; i
++)
5869 lc_trans
[i
] = lowcase (i
);
5870 patbuf
->translate
= lc_trans
; /* translation table to fold case */
5874 pat
= concat ("^", regexp_pattern
, ""); /* anchor to beginning of line */
5876 pat
= regexp_pattern
;
5879 re_set_syntax (RE_SYNTAX_EMACS
| RE_DOT_NEWLINE
);
5881 re_set_syntax (RE_SYNTAX_EMACS
);
5883 err
= re_compile_pattern (pat
, strlen (regexp_pattern
), patbuf
);
5888 error ("%s while compiling pattern", err
);
5893 p_head
= xnew (1, regexp
);
5894 p_head
->pattern
= savestr (regexp_pattern
);
5895 p_head
->p_next
= rp
;
5896 p_head
->lang
= lang
;
5897 p_head
->pat
= patbuf
;
5898 p_head
->name
= savestr (name
);
5899 p_head
->error_signaled
= FALSE
;
5900 p_head
->force_explicit_name
= force_explicit_name
;
5901 p_head
->ignore_case
= ignore_case
;
5902 p_head
->multi_line
= multi_line
;
5906 * Do the substitutions indicated by the regular expression and
5910 substitute (in
, out
, regs
)
5912 struct re_registers
*regs
;
5915 int size
, dig
, diglen
;
5918 size
= strlen (out
);
5920 /* Pass 1: figure out how much to allocate by finding all \N strings. */
5921 if (out
[size
- 1] == '\\')
5922 fatal ("pattern error in \"%s\"", out
);
5923 for (t
= etags_strchr (out
, '\\');
5925 t
= etags_strchr (t
+ 2, '\\'))
5929 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
5935 /* Allocate space and do the substitutions. */
5937 result
= xnew (size
+ 1, char);
5939 for (t
= result
; *out
!= '\0'; out
++)
5940 if (*out
== '\\' && ISDIGIT (*++out
))
5943 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
5944 strncpy (t
, in
+ regs
->start
[dig
], diglen
);
5951 assert (t
<= result
+ size
);
5952 assert (t
- result
== (int)strlen (result
));
5957 /* Deallocate all regexps. */
5962 while (p_head
!= NULL
)
5964 rp
= p_head
->p_next
;
5965 free (p_head
->pattern
);
5966 free (p_head
->name
);
5974 * Reads the whole file as a single string from `filebuf' and looks for
5975 * multi-line regular expressions, creating tags on matches.
5976 * readline already dealt with normal regexps.
5978 * Idea by Ben Wing <ben@666.com> (2002).
5981 regex_tag_multiline ()
5983 char *buffer
= filebuf
.buffer
;
5987 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
5991 if (!rp
->multi_line
)
5992 continue; /* skip normal regexps */
5994 /* Generic initialisations before parsing file from memory. */
5995 lineno
= 1; /* reset global line number */
5996 charno
= 0; /* reset global char number */
5997 linecharno
= 0; /* reset global char number of line start */
5999 /* Only use generic regexps or those for the current language. */
6000 if (rp
->lang
!= NULL
&& rp
->lang
!= curfdp
->lang
)
6003 while (match
>= 0 && match
< filebuf
.len
)
6005 match
= re_search (rp
->pat
, buffer
, filebuf
.len
, charno
,
6006 filebuf
.len
- match
, &rp
->regs
);
6011 if (!rp
->error_signaled
)
6013 error ("regexp stack overflow while matching \"%s\"",
6015 rp
->error_signaled
= TRUE
;
6022 if (match
== rp
->regs
.end
[0])
6024 if (!rp
->error_signaled
)
6026 error ("regexp matches the empty string: \"%s\"",
6028 rp
->error_signaled
= TRUE
;
6030 match
= -3; /* exit from while loop */
6034 /* Match occurred. Construct a tag. */
6035 while (charno
< rp
->regs
.end
[0])
6036 if (buffer
[charno
++] == '\n')
6037 lineno
++, linecharno
= charno
;
6039 if (name
[0] == '\0')
6041 else /* make a named tag */
6042 name
= substitute (buffer
, rp
->name
, &rp
->regs
);
6043 if (rp
->force_explicit_name
)
6044 /* Force explicit tag name, if a name is there. */
6045 pfnote (name
, TRUE
, buffer
+ linecharno
,
6046 charno
- linecharno
+ 1, lineno
, linecharno
);
6048 make_tag (name
, strlen (name
), TRUE
, buffer
+ linecharno
,
6049 charno
- linecharno
+ 1, lineno
, linecharno
);
6061 register int len
= 0;
6063 while (*cp
!= '\0' && lowcase (*cp
) == lowcase (dbp
[len
]))
6065 if (*cp
== '\0' && !intoken (dbp
[len
]))
6074 get_tag (bp
, namepp
)
6078 register char *cp
= bp
;
6082 /* Go till you get to white space or a syntactic break */
6083 for (cp
= bp
+ 1; !notinname (*cp
); cp
++)
6085 make_tag (bp
, cp
- bp
, TRUE
,
6086 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
6090 *namepp
= savenstr (bp
, cp
- bp
);
6094 * Read a line of text from `stream' into `lbp', excluding the
6095 * newline or CR-NL, if any. Return the number of characters read from
6096 * `stream', which is the length of the line including the newline.
6098 * On DOS or Windows we do not count the CR character, if any before the
6099 * NL, in the returned length; this mirrors the behavior of Emacs on those
6100 * platforms (for text files, it translates CR-NL to NL as it reads in the
6103 * If multi-line regular expressions are requested, each line read is
6104 * appended to `filebuf'.
6107 readline_internal (lbp
, stream
)
6109 register FILE *stream
;
6111 char *buffer
= lbp
->buffer
;
6112 register char *p
= lbp
->buffer
;
6113 register char *pend
;
6116 pend
= p
+ lbp
->size
; /* Separate to avoid 386/IX compiler bug. */
6120 register int c
= getc (stream
);
6123 /* We're at the end of linebuffer: expand it. */
6125 xrnew (buffer
, lbp
->size
, char);
6126 p
+= buffer
- lbp
->buffer
;
6127 pend
= buffer
+ lbp
->size
;
6128 lbp
->buffer
= buffer
;
6138 if (p
> buffer
&& p
[-1] == '\r')
6142 /* Assume CRLF->LF translation will be performed by Emacs
6143 when loading this file, so CRs won't appear in the buffer.
6144 It would be cleaner to compensate within Emacs;
6145 however, Emacs does not know how many CRs were deleted
6146 before any given point in the file. */
6161 lbp
->len
= p
- buffer
;
6163 if (need_filebuf
/* we need filebuf for multi-line regexps */
6164 && chars_deleted
> 0) /* not at EOF */
6166 while (filebuf
.size
<= filebuf
.len
+ lbp
->len
+ 1) /* +1 for \n */
6168 /* Expand filebuf. */
6170 xrnew (filebuf
.buffer
, filebuf
.size
, char);
6172 strncpy (filebuf
.buffer
+ filebuf
.len
, lbp
->buffer
, lbp
->len
);
6173 filebuf
.len
+= lbp
->len
;
6174 filebuf
.buffer
[filebuf
.len
++] = '\n';
6175 filebuf
.buffer
[filebuf
.len
] = '\0';
6178 return lbp
->len
+ chars_deleted
;
6182 * Like readline_internal, above, but in addition try to match the
6183 * input line against relevant regular expressions and manage #line
6187 readline (lbp
, stream
)
6193 linecharno
= charno
; /* update global char number of line start */
6194 result
= readline_internal (lbp
, stream
); /* read line */
6195 lineno
+= 1; /* increment global line number */
6196 charno
+= result
; /* increment global char number */
6198 /* Honour #line directives. */
6199 if (!no_line_directive
)
6201 static bool discard_until_line_directive
;
6203 /* Check whether this is a #line directive. */
6204 if (result
> 12 && strneq (lbp
->buffer
, "#line ", 6))
6209 if (sscanf (lbp
->buffer
, "#line %u \"%n", &lno
, &start
) >= 1
6210 && start
> 0) /* double quote character found */
6212 char *endp
= lbp
->buffer
+ start
;
6214 while ((endp
= etags_strchr (endp
, '"')) != NULL
6215 && endp
[-1] == '\\')
6218 /* Ok, this is a real #line directive. Let's deal with it. */
6220 char *taggedabsname
; /* absolute name of original file */
6221 char *taggedfname
; /* name of original file as given */
6222 char *name
; /* temp var */
6224 discard_until_line_directive
= FALSE
; /* found it */
6225 name
= lbp
->buffer
+ start
;
6227 canonicalize_filename (name
);
6228 taggedabsname
= absolute_filename (name
, tagfiledir
);
6229 if (filename_is_absolute (name
)
6230 || filename_is_absolute (curfdp
->infname
))
6231 taggedfname
= savestr (taggedabsname
);
6233 taggedfname
= relative_filename (taggedabsname
,tagfiledir
);
6235 if (streq (curfdp
->taggedfname
, taggedfname
))
6236 /* The #line directive is only a line number change. We
6237 deal with this afterwards. */
6240 /* The tags following this #line directive should be
6241 attributed to taggedfname. In order to do this, set
6242 curfdp accordingly. */
6244 fdesc
*fdp
; /* file description pointer */
6246 /* Go look for a file description already set up for the
6247 file indicated in the #line directive. If there is
6248 one, use it from now until the next #line
6250 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6251 if (streq (fdp
->infname
, curfdp
->infname
)
6252 && streq (fdp
->taggedfname
, taggedfname
))
6253 /* If we remove the second test above (after the &&)
6254 then all entries pertaining to the same file are
6255 coalesced in the tags file. If we use it, then
6256 entries pertaining to the same file but generated
6257 from different files (via #line directives) will
6258 go into separate sections in the tags file. These
6259 alternatives look equivalent. The first one
6260 destroys some apparently useless information. */
6266 /* Else, if we already tagged the real file, skip all
6267 input lines until the next #line directive. */
6268 if (fdp
== NULL
) /* not found */
6269 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6270 if (streq (fdp
->infabsname
, taggedabsname
))
6272 discard_until_line_directive
= TRUE
;
6276 /* Else create a new file description and use that from
6277 now on, until the next #line directive. */
6278 if (fdp
== NULL
) /* not found */
6281 fdhead
= xnew (1, fdesc
);
6282 *fdhead
= *curfdp
; /* copy curr. file description */
6284 fdhead
->infname
= savestr (curfdp
->infname
);
6285 fdhead
->infabsname
= savestr (curfdp
->infabsname
);
6286 fdhead
->infabsdir
= savestr (curfdp
->infabsdir
);
6287 fdhead
->taggedfname
= taggedfname
;
6288 fdhead
->usecharno
= FALSE
;
6289 fdhead
->prop
= NULL
;
6290 fdhead
->written
= FALSE
;
6294 free (taggedabsname
);
6296 readline (lbp
, stream
);
6298 } /* if a real #line directive */
6299 } /* if #line is followed by a a number */
6300 } /* if line begins with "#line " */
6302 /* If we are here, no #line directive was found. */
6303 if (discard_until_line_directive
)
6307 /* Do a tail recursion on ourselves, thus discarding the contents
6308 of the line buffer. */
6309 readline (lbp
, stream
);
6313 discard_until_line_directive
= FALSE
;
6316 } /* if #line directives should be considered */
6323 /* Match against relevant regexps. */
6325 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6327 /* Only use generic regexps or those for the current language.
6328 Also do not use multiline regexps, which is the job of
6329 regex_tag_multiline. */
6330 if ((rp
->lang
!= NULL
&& rp
->lang
!= fdhead
->lang
)
6334 match
= re_match (rp
->pat
, lbp
->buffer
, lbp
->len
, 0, &rp
->regs
);
6339 if (!rp
->error_signaled
)
6341 error ("regexp stack overflow while matching \"%s\"",
6343 rp
->error_signaled
= TRUE
;
6350 /* Empty string matched. */
6351 if (!rp
->error_signaled
)
6353 error ("regexp matches the empty string: \"%s\"", rp
->pattern
);
6354 rp
->error_signaled
= TRUE
;
6358 /* Match occurred. Construct a tag. */
6360 if (name
[0] == '\0')
6362 else /* make a named tag */
6363 name
= substitute (lbp
->buffer
, rp
->name
, &rp
->regs
);
6364 if (rp
->force_explicit_name
)
6365 /* Force explicit tag name, if a name is there. */
6366 pfnote (name
, TRUE
, lbp
->buffer
, match
, lineno
, linecharno
);
6368 make_tag (name
, strlen (name
), TRUE
,
6369 lbp
->buffer
, match
, lineno
, linecharno
);
6378 * Return a pointer to a space of size strlen(cp)+1 allocated
6379 * with xnew where the string CP has been copied.
6385 return savenstr (cp
, strlen (cp
));
6389 * Return a pointer to a space of size LEN+1 allocated with xnew where
6390 * the string CP has been copied for at most the first LEN characters.
6399 dp
= xnew (len
+ 1, char);
6400 strncpy (dp
, cp
, len
);
6406 * Return the ptr in sp at which the character c last
6407 * appears; NULL if not found
6409 * Identical to POSIX strrchr, included for portability.
6412 etags_strrchr (sp
, c
)
6413 register const char *sp
;
6416 register const char *r
;
6428 * Return the ptr in sp at which the character c first
6429 * appears; NULL if not found
6431 * Identical to POSIX strchr, included for portability.
6434 etags_strchr (sp
, c
)
6435 register const char *sp
;
6447 * Compare two strings, ignoring case for alphabetic characters.
6449 * Same as BSD's strcasecmp, included for portability.
6452 etags_strcasecmp (s1
, s2
)
6453 register const char *s1
;
6454 register const char *s2
;
6457 && (ISALPHA (*s1
) && ISALPHA (*s2
)
6458 ? lowcase (*s1
) == lowcase (*s2
)
6462 return (ISALPHA (*s1
) && ISALPHA (*s2
)
6463 ? lowcase (*s1
) - lowcase (*s2
)
6468 * Compare two strings, ignoring case for alphabetic characters.
6469 * Stop after a given number of characters
6471 * Same as BSD's strncasecmp, included for portability.
6474 etags_strncasecmp (s1
, s2
, n
)
6475 register const char *s1
;
6476 register const char *s2
;
6479 while (*s1
!= '\0' && n
-- > 0
6480 && (ISALPHA (*s1
) && ISALPHA (*s2
)
6481 ? lowcase (*s1
) == lowcase (*s2
)
6488 return (ISALPHA (*s1
) && ISALPHA (*s2
)
6489 ? lowcase (*s1
) - lowcase (*s2
)
6493 /* Skip spaces (end of string is not space), return new pointer. */
6498 while (iswhite (*cp
))
6503 /* Skip non spaces, except end of string, return new pointer. */
6505 skip_non_spaces (cp
)
6508 while (*cp
!= '\0' && !iswhite (*cp
))
6513 /* Print error message and exit. */
6519 exit (EXIT_FAILURE
);
6527 exit (EXIT_FAILURE
);
6531 suggest_asking_for_help ()
6533 fprintf (stderr
, "\tTry `%s %s' for a complete list of options.\n",
6534 progname
, NO_LONG_OPTIONS
? "-h" : "--help");
6535 exit (EXIT_FAILURE
);
6538 /* Print error message. `s1' is printf control string, `s2' is arg for it. */
6541 const char *s1
, *s2
;
6543 fprintf (stderr
, "%s: ", progname
);
6544 fprintf (stderr
, s1
, s2
);
6545 fprintf (stderr
, "\n");
6548 /* Return a newly-allocated string whose contents
6549 concatenate those of s1, s2, s3. */
6554 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
6555 char *result
= xnew (len1
+ len2
+ len3
+ 1, char);
6557 strcpy (result
, s1
);
6558 strcpy (result
+ len1
, s2
);
6559 strcpy (result
+ len1
+ len2
, s3
);
6560 result
[len1
+ len2
+ len3
] = '\0';
6566 /* Does the same work as the system V getcwd, but does not need to
6567 guess the buffer size in advance. */
6573 char *path
= xnew (bufsize
, char);
6575 while (getcwd (path
, bufsize
) == NULL
)
6577 if (errno
!= ERANGE
)
6581 path
= xnew (bufsize
, char);
6584 canonicalize_filename (path
);
6587 #else /* not HAVE_GETCWD */
6590 char *p
, path
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
6594 for (p
= path
; *p
!= '\0'; p
++)
6600 return strdup (path
);
6601 #else /* not MSDOS */
6605 linebuffer_init (&path
);
6606 pipe
= (FILE *) popen ("pwd 2>/dev/null", "r");
6607 if (pipe
== NULL
|| readline_internal (&path
, pipe
) == 0)
6612 #endif /* not MSDOS */
6613 #endif /* not HAVE_GETCWD */
6616 /* Return a newly allocated string containing the file name of FILE
6617 relative to the absolute directory DIR (which should end with a slash). */
6619 relative_filename (file
, dir
)
6622 char *fp
, *dp
, *afn
, *res
;
6625 /* Find the common root of file and dir (with a trailing slash). */
6626 afn
= absolute_filename (file
, cwd
);
6629 while (*fp
++ == *dp
++)
6631 fp
--, dp
--; /* back to the first differing char */
6633 if (fp
== afn
&& afn
[0] != '/') /* cannot build a relative name */
6636 do /* look at the equal chars until '/' */
6640 /* Build a sequence of "../" strings for the resulting relative file name. */
6642 while ((dp
= etags_strchr (dp
+ 1, '/')) != NULL
)
6644 res
= xnew (3*i
+ strlen (fp
+ 1) + 1, char);
6647 strcat (res
, "../");
6649 /* Add the file name relative to the common root of file and dir. */
6650 strcat (res
, fp
+ 1);
6656 /* Return a newly allocated string containing the absolute file name
6657 of FILE given DIR (which should end with a slash). */
6659 absolute_filename (file
, dir
)
6662 char *slashp
, *cp
, *res
;
6664 if (filename_is_absolute (file
))
6665 res
= savestr (file
);
6667 /* We don't support non-absolute file names with a drive
6668 letter, like `d:NAME' (it's too much hassle). */
6669 else if (file
[1] == ':')
6670 fatal ("%s: relative file names with drive letters not supported", file
);
6673 res
= concat (dir
, file
, "");
6675 /* Delete the "/dirname/.." and "/." substrings. */
6676 slashp
= etags_strchr (res
, '/');
6677 while (slashp
!= NULL
&& slashp
[0] != '\0')
6679 if (slashp
[1] == '.')
6681 if (slashp
[2] == '.'
6682 && (slashp
[3] == '/' || slashp
[3] == '\0'))
6687 while (cp
>= res
&& !filename_is_absolute (cp
));
6689 cp
= slashp
; /* the absolute name begins with "/.." */
6691 /* Under MSDOS and NT we get `d:/NAME' as absolute
6692 file name, so the luser could say `d:/../NAME'.
6693 We silently treat this as `d:/NAME'. */
6694 else if (cp
[0] != '/')
6697 strcpy (cp
, slashp
+ 3);
6701 else if (slashp
[2] == '/' || slashp
[2] == '\0')
6703 strcpy (slashp
, slashp
+ 2);
6708 slashp
= etags_strchr (slashp
+ 1, '/');
6711 if (res
[0] == '\0') /* just a safety net: should never happen */
6714 return savestr ("/");
6720 /* Return a newly allocated string containing the absolute
6721 file name of dir where FILE resides given DIR (which should
6722 end with a slash). */
6724 absolute_dirname (file
, dir
)
6730 slashp
= etags_strrchr (file
, '/');
6732 return savestr (dir
);
6735 res
= absolute_filename (file
, dir
);
6741 /* Whether the argument string is an absolute file name. The argument
6742 string must have been canonicalized with canonicalize_filename. */
6744 filename_is_absolute (fn
)
6747 return (fn
[0] == '/'
6749 || (ISALPHA(fn
[0]) && fn
[1] == ':' && fn
[2] == '/')
6754 /* Upcase DOS drive letter and collapse separators into single slashes.
6757 canonicalize_filename (fn
)
6764 /* Canonicalize drive letter case. */
6765 if (fn
[0] != '\0' && fn
[1] == ':' && ISLOWER (fn
[0]))
6766 fn
[0] = upcase (fn
[0]);
6771 /* Collapse multiple separators into a single slash. */
6772 for (cp
= fn
; *cp
!= '\0'; cp
++, fn
++)
6776 while (cp
[1] == sep
)
6785 /* Initialize a linebuffer for use. */
6787 linebuffer_init (lbp
)
6790 lbp
->size
= (DEBUG
) ? 3 : 200;
6791 lbp
->buffer
= xnew (lbp
->size
, char);
6792 lbp
->buffer
[0] = '\0';
6796 /* Set the minimum size of a string contained in a linebuffer. */
6798 linebuffer_setlen (lbp
, toksize
)
6802 while (lbp
->size
<= toksize
)
6805 xrnew (lbp
->buffer
, lbp
->size
, char);
6810 /* Like malloc but get fatal error if memory is exhausted. */
6815 PTR result
= (PTR
) malloc (size
);
6817 fatal ("virtual memory exhausted", (char *)NULL
);
6822 xrealloc (ptr
, size
)
6826 PTR result
= (PTR
) realloc (ptr
, size
);
6828 fatal ("virtual memory exhausted", (char *)NULL
);
6834 * indent-tabs-mode: t
6837 * c-font-lock-extra-types: ("FILE" "bool" "language" "linebuffer" "fdesc" "node" "regexp")
6838 * c-file-style: "gnu"
6842 /* arch-tag: 8a9b748d-390c-4922-99db-2eeefa921051
6843 (do not change this comment) */
6845 /* etags.c ends here */