1 /* Tags file maker to go with GNU Emacs -*- coding: utf-8 -*-
3 Copyright (C) 1984 The Regents of the University of California
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are
8 1. Redistributions of source code must retain the above copyright
9 notice, this list of conditions and the following disclaimer.
10 2. Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the
14 3. Neither the name of the University nor the names of its
15 contributors may be used to endorse or promote products derived
16 from this software without specific prior written permission.
18 THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS''
19 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS
22 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
27 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
28 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 Copyright (C) 1984, 1987-1989, 1993-1995, 1998-2016 Free Software
34 This file is not considered part of GNU Emacs.
36 This program is free software: you can redistribute it and/or modify
37 it under the terms of the GNU General Public License as published by
38 the Free Software Foundation, either version 3 of the License, or
39 (at your option) any later version.
41 This program is distributed in the hope that it will be useful,
42 but WITHOUT ANY WARRANTY; without even the implied warranty of
43 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
44 GNU General Public License for more details.
46 You should have received a copy of the GNU General Public License
47 along with this program. If not, see <http://www.gnu.org/licenses/>. */
50 /* NB To comply with the above BSD license, copyright information is
51 reproduced in etc/ETAGS.README. That file should be updated when the
54 To the best of our knowledge, this code was originally based on the
55 ctags.c distributed with BSD4.2, which was copyrighted by the
56 University of California, as described above. */
61 * 1983 Ctags originally by Ken Arnold.
62 * 1984 Fortran added by Jim Kleckner.
63 * 1984 Ed Pelegri-Llopart added C typedefs.
64 * 1985 Emacs TAGS format by Richard Stallman.
65 * 1989 Sam Kendall added C++.
66 * 1992 Joseph B. Wells improved C and C++ parsing.
67 * 1993 Francesco Potortì reorganized C and C++.
68 * 1994 Line-by-line regexp tags by Tom Tromey.
69 * 2001 Nested classes by Francesco Potortì (concept by Mykola Dzyuba).
70 * 2002 #line directives by Francesco Potortì.
71 * Francesco Potortì maintained and improved it for many years
76 * If you want to add support for a new language, start by looking at the LUA
77 * language, which is the simplest. Alternatively, consider distributing etags
78 * together with a configuration file containing regexp definitions for etags.
81 char pot_etags_version
[] = "@(#) pot revision number is 17.38.1.4";
88 # define NDEBUG /* disable assert */
94 # define _GNU_SOURCE 1 /* enables some compiler checks on GNU */
97 /* WIN32_NATIVE is for XEmacs.
98 MSDOS, WINDOWSNT, DOS_NT are for Emacs. */
103 #endif /* WIN32_NATIVE */
108 # include <sys/param.h>
115 # define MAXPATHLEN _MAX_PATH
119 # define O_CLOEXEC O_NOINHERIT
120 #endif /* WINDOWSNT */
127 #include <sysstdio.h>
130 #include <binary-io.h>
132 #include <c-strcase.h>
136 # undef assert /* some systems have a buggy assert.h */
137 # define assert(x) ((void) 0)
143 /* Define CTAGS to make the program "ctags" compatible with the usual one.
144 Leave it undefined to make the program "etags", which makes emacs-style
145 tag tables and tags typedefs, #defines and struct/union/enum by default. */
154 streq (char const *s
, char const *t
)
156 return strcmp (s
, t
) == 0;
160 strcaseeq (char const *s
, char const *t
)
162 return c_strcasecmp (s
, t
) == 0;
166 strneq (char const *s
, char const *t
, size_t n
)
168 return strncmp (s
, t
, n
) == 0;
172 strncaseeq (char const *s
, char const *t
, size_t n
)
174 return c_strncasecmp (s
, t
, n
) == 0;
177 /* C is not in a name. */
179 notinname (unsigned char c
)
181 /* Look at make_tag before modifying! */
182 static bool const table
[UCHAR_MAX
+ 1] = {
183 ['\0']=1, ['\t']=1, ['\n']=1, ['\f']=1, ['\r']=1, [' ']=1,
184 ['(']=1, [')']=1, [',']=1, [';']=1, ['=']=1
189 /* C can start a token. */
191 begtoken (unsigned char c
)
193 static bool const table
[UCHAR_MAX
+ 1] = {
195 ['A']=1, ['B']=1, ['C']=1, ['D']=1, ['E']=1, ['F']=1, ['G']=1, ['H']=1,
196 ['I']=1, ['J']=1, ['K']=1, ['L']=1, ['M']=1, ['N']=1, ['O']=1, ['P']=1,
197 ['Q']=1, ['R']=1, ['S']=1, ['T']=1, ['U']=1, ['V']=1, ['W']=1, ['X']=1,
200 ['a']=1, ['b']=1, ['c']=1, ['d']=1, ['e']=1, ['f']=1, ['g']=1, ['h']=1,
201 ['i']=1, ['j']=1, ['k']=1, ['l']=1, ['m']=1, ['n']=1, ['o']=1, ['p']=1,
202 ['q']=1, ['r']=1, ['s']=1, ['t']=1, ['u']=1, ['v']=1, ['w']=1, ['x']=1,
209 /* C can be in the middle of a token. */
211 intoken (unsigned char c
)
213 static bool const table
[UCHAR_MAX
+ 1] = {
215 ['0']=1, ['1']=1, ['2']=1, ['3']=1, ['4']=1,
216 ['5']=1, ['6']=1, ['7']=1, ['8']=1, ['9']=1,
217 ['A']=1, ['B']=1, ['C']=1, ['D']=1, ['E']=1, ['F']=1, ['G']=1, ['H']=1,
218 ['I']=1, ['J']=1, ['K']=1, ['L']=1, ['M']=1, ['N']=1, ['O']=1, ['P']=1,
219 ['Q']=1, ['R']=1, ['S']=1, ['T']=1, ['U']=1, ['V']=1, ['W']=1, ['X']=1,
222 ['a']=1, ['b']=1, ['c']=1, ['d']=1, ['e']=1, ['f']=1, ['g']=1, ['h']=1,
223 ['i']=1, ['j']=1, ['k']=1, ['l']=1, ['m']=1, ['n']=1, ['o']=1, ['p']=1,
224 ['q']=1, ['r']=1, ['s']=1, ['t']=1, ['u']=1, ['v']=1, ['w']=1, ['x']=1,
230 /* C can end a token. */
232 endtoken (unsigned char c
)
234 static bool const table
[UCHAR_MAX
+ 1] = {
235 ['\0']=1, ['\t']=1, ['\n']=1, ['\r']=1, [' ']=1,
236 ['!']=1, ['"']=1, ['#']=1, ['%']=1, ['&']=1, ['\'']=1, ['(']=1, [')']=1,
237 ['*']=1, ['+']=1, [',']=1, ['-']=1, ['.']=1, ['/']=1, [':']=1, [';']=1,
238 ['<']=1, ['=']=1, ['>']=1, ['?']=1, ['[']=1, [']']=1, ['^']=1,
239 ['{']=1, ['|']=1, ['}']=1, ['~']=1
245 * xnew, xrnew -- allocate, reallocate storage
247 * SYNOPSIS: Type *xnew (int n, Type);
248 * void xrnew (OldPointer, int n, Type);
250 #define xnew(n, Type) ((Type *) xmalloc ((n) * sizeof (Type)))
251 #define xrnew(op, n, Type) ((op) = (Type *) xrealloc (op, (n) * sizeof (Type)))
253 typedef void Lang_function (FILE *);
257 const char *suffix
; /* file name suffix for this compressor */
258 const char *command
; /* takes one arg and decompresses to stdout */
263 const char *name
; /* language name */
264 const char *help
; /* detailed help for the language */
265 Lang_function
*function
; /* parse function */
266 const char **suffixes
; /* name suffixes of this language's files */
267 const char **filenames
; /* names of this language's files */
268 const char **interpreters
; /* interpreters for this language */
269 bool metasource
; /* source used to generate other sources */
274 struct fdesc
*next
; /* for the linked list */
275 char *infname
; /* uncompressed input file name */
276 char *infabsname
; /* absolute uncompressed input file name */
277 char *infabsdir
; /* absolute dir of input file */
278 char *taggedfname
; /* file name to write in tagfile */
279 language
*lang
; /* language of file */
280 char *prop
; /* file properties to write in tagfile */
281 bool usecharno
; /* etags tags shall contain char number */
282 bool written
; /* entry written in the tags file */
285 typedef struct node_st
286 { /* sorting structure */
287 struct node_st
*left
, *right
; /* left and right sons */
288 fdesc
*fdp
; /* description of file to whom tag belongs */
289 char *name
; /* tag name */
290 char *regex
; /* search regexp */
291 bool valid
; /* write this tag on the tag file */
292 bool is_func
; /* function tag: use regexp in CTAGS mode */
293 bool been_warned
; /* warning already given for duplicated tag */
294 int lno
; /* line number tag is on */
295 long cno
; /* character number line starts on */
299 * A `linebuffer' is a structure which holds a line of text.
300 * `readline_internal' reads a line from a stream into a linebuffer
301 * and works regardless of the length of the line.
302 * SIZE is the size of BUFFER, LEN is the length of the string in
303 * BUFFER after readline reads it.
312 /* Used to support mixing of --lang and file names. */
316 at_language
, /* a language specification */
317 at_regexp
, /* a regular expression */
318 at_filename
, /* a file name */
319 at_stdin
, /* read from stdin here */
320 at_end
/* stop parsing the list */
321 } arg_type
; /* argument type */
322 language
*lang
; /* language associated with the argument */
323 char *what
; /* the argument itself */
326 /* Structure defining a regular expression. */
327 typedef struct regexp
329 struct regexp
*p_next
; /* pointer to next in list */
330 language
*lang
; /* if set, use only for this language */
331 char *pattern
; /* the regexp pattern */
332 char *name
; /* tag name */
333 struct re_pattern_buffer
*pat
; /* the compiled pattern */
334 struct re_registers regs
; /* re registers */
335 bool error_signaled
; /* already signaled for this regexp */
336 bool force_explicit_name
; /* do not allow implicit tag name */
337 bool ignore_case
; /* ignore case when matching */
338 bool multi_line
; /* do a multi-line match on the whole file */
342 /* Many compilers barf on this:
343 Lang_function Ada_funcs;
344 so let's write it this way */
345 static void Ada_funcs (FILE *);
346 static void Asm_labels (FILE *);
347 static void C_entries (int c_ext
, FILE *);
348 static void default_C_entries (FILE *);
349 static void plain_C_entries (FILE *);
350 static void Cjava_entries (FILE *);
351 static void Cobol_paragraphs (FILE *);
352 static void Cplusplus_entries (FILE *);
353 static void Cstar_entries (FILE *);
354 static void Erlang_functions (FILE *);
355 static void Forth_words (FILE *);
356 static void Fortran_functions (FILE *);
357 static void Go_functions (FILE *);
358 static void HTML_labels (FILE *);
359 static void Lisp_functions (FILE *);
360 static void Lua_functions (FILE *);
361 static void Makefile_targets (FILE *);
362 static void Pascal_functions (FILE *);
363 static void Perl_functions (FILE *);
364 static void PHP_functions (FILE *);
365 static void PS_functions (FILE *);
366 static void Prolog_functions (FILE *);
367 static void Python_functions (FILE *);
368 static void Ruby_functions (FILE *);
369 static void Scheme_functions (FILE *);
370 static void TeX_commands (FILE *);
371 static void Texinfo_nodes (FILE *);
372 static void Yacc_entries (FILE *);
373 static void just_read_file (FILE *);
375 static language
*get_language_from_langname (const char *);
376 static void readline (linebuffer
*, FILE *);
377 static long readline_internal (linebuffer
*, FILE *, char const *);
378 static bool nocase_tail (const char *);
379 static void get_tag (char *, char **);
381 static void analyze_regex (char *);
382 static void free_regexps (void);
383 static void regex_tag_multiline (void);
384 static void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
385 static void verror (char const *, va_list) ATTRIBUTE_FORMAT_PRINTF (1, 0);
386 static _Noreturn
void suggest_asking_for_help (void);
387 static _Noreturn
void fatal (char const *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
388 static _Noreturn
void pfatal (const char *);
389 static void add_node (node
*, node
**);
391 static void process_file_name (char *, language
*);
392 static void process_file (FILE *, char *, language
*);
393 static void find_entries (FILE *);
394 static void free_tree (node
*);
395 static void free_fdesc (fdesc
*);
396 static void pfnote (char *, bool, char *, int, int, long);
397 static void invalidate_nodes (fdesc
*, node
**);
398 static void put_entries (node
*);
400 static char *concat (const char *, const char *, const char *);
401 static char *skip_spaces (char *);
402 static char *skip_non_spaces (char *);
403 static char *skip_name (char *);
404 static char *savenstr (const char *, int);
405 static char *savestr (const char *);
406 static char *etags_getcwd (void);
407 static char *relative_filename (char *, char *);
408 static char *absolute_filename (char *, char *);
409 static char *absolute_dirname (char *, char *);
410 static bool filename_is_absolute (char *f
);
411 static void canonicalize_filename (char *);
412 static char *etags_mktmp (void);
413 static void linebuffer_init (linebuffer
*);
414 static void linebuffer_setlen (linebuffer
*, int);
415 static void *xmalloc (size_t);
416 static void *xrealloc (void *, size_t);
419 static char searchar
= '/'; /* use /.../ searches */
421 static char *tagfile
; /* output file */
422 static char *progname
; /* name this program was invoked with */
423 static char *cwd
; /* current working directory */
424 static char *tagfiledir
; /* directory of tagfile */
425 static FILE *tagf
; /* ioptr for tags file */
426 static ptrdiff_t whatlen_max
; /* maximum length of any 'what' member */
428 static fdesc
*fdhead
; /* head of file description list */
429 static fdesc
*curfdp
; /* current file description */
430 static char *infilename
; /* current input file name */
431 static int lineno
; /* line number of current line */
432 static long charno
; /* current character number */
433 static long linecharno
; /* charno of start of current line */
434 static char *dbp
; /* pointer to start of current tag */
436 static const int invalidcharno
= -1;
438 static node
*nodehead
; /* the head of the binary tree of tags */
439 static node
*last_node
; /* the last node created */
441 static linebuffer lb
; /* the current line */
442 static linebuffer filebuf
; /* a buffer containing the whole file */
443 static linebuffer token_name
; /* a buffer containing a tag name */
445 static bool append_to_tagfile
; /* -a: append to tags */
446 /* The next five default to true in C and derived languages. */
447 static bool typedefs
; /* -t: create tags for C and Ada typedefs */
448 static bool typedefs_or_cplusplus
; /* -T: create tags for C typedefs, level */
449 /* 0 struct/enum/union decls, and C++ */
450 /* member functions. */
451 static bool constantypedefs
; /* -d: create tags for C #define, enum */
452 /* constants and variables. */
453 /* -D: opposite of -d. Default under ctags. */
454 static int globals
; /* create tags for global variables */
455 static int members
; /* create tags for C member variables */
456 static int declarations
; /* --declarations: tag them and extern in C&Co*/
457 static int no_line_directive
; /* ignore #line directives (undocumented) */
458 static int no_duplicates
; /* no duplicate tags for ctags (undocumented) */
459 static bool update
; /* -u: update tags */
460 static bool vgrind_style
; /* -v: create vgrind style index output */
461 static bool no_warnings
; /* -w: suppress warnings (undocumented) */
462 static bool cxref_style
; /* -x: create cxref style output */
463 static bool cplusplus
; /* .[hc] means C++, not C (undocumented) */
464 static bool ignoreindent
; /* -I: ignore indentation in C */
465 static int packages_only
; /* --packages-only: in Ada, only tag packages*/
466 static int class_qualify
; /* -Q: produce class-qualified tags in C++/Java */
468 /* STDIN is defined in LynxOS system headers */
473 #define STDIN 0x1001 /* returned by getopt_long on --parse-stdin */
474 static bool parsing_stdin
; /* --parse-stdin used */
476 static regexp
*p_head
; /* list of all regexps */
477 static bool need_filebuf
; /* some regexes are multi-line */
479 static struct option longopts
[] =
481 { "append", no_argument
, NULL
, 'a' },
482 { "packages-only", no_argument
, &packages_only
, 1 },
483 { "c++", no_argument
, NULL
, 'C' },
484 { "declarations", no_argument
, &declarations
, 1 },
485 { "no-line-directive", no_argument
, &no_line_directive
, 1 },
486 { "no-duplicates", no_argument
, &no_duplicates
, 1 },
487 { "help", no_argument
, NULL
, 'h' },
488 { "help", no_argument
, NULL
, 'H' },
489 { "ignore-indentation", no_argument
, NULL
, 'I' },
490 { "language", required_argument
, NULL
, 'l' },
491 { "members", no_argument
, &members
, 1 },
492 { "no-members", no_argument
, &members
, 0 },
493 { "output", required_argument
, NULL
, 'o' },
494 { "class-qualify", no_argument
, &class_qualify
, 'Q' },
495 { "regex", required_argument
, NULL
, 'r' },
496 { "no-regex", no_argument
, NULL
, 'R' },
497 { "ignore-case-regex", required_argument
, NULL
, 'c' },
498 { "parse-stdin", required_argument
, NULL
, STDIN
},
499 { "version", no_argument
, NULL
, 'V' },
501 #if CTAGS /* Ctags options */
502 { "backward-search", no_argument
, NULL
, 'B' },
503 { "cxref", no_argument
, NULL
, 'x' },
504 { "defines", no_argument
, NULL
, 'd' },
505 { "globals", no_argument
, &globals
, 1 },
506 { "typedefs", no_argument
, NULL
, 't' },
507 { "typedefs-and-c++", no_argument
, NULL
, 'T' },
508 { "update", no_argument
, NULL
, 'u' },
509 { "vgrind", no_argument
, NULL
, 'v' },
510 { "no-warn", no_argument
, NULL
, 'w' },
512 #else /* Etags options */
513 { "no-defines", no_argument
, NULL
, 'D' },
514 { "no-globals", no_argument
, &globals
, 0 },
515 { "include", required_argument
, NULL
, 'i' },
520 static compressor compressors
[] =
522 { "z", "gzip -d -c"},
523 { "Z", "gzip -d -c"},
524 { "gz", "gzip -d -c"},
525 { "GZ", "gzip -d -c"},
526 { "bz2", "bzip2 -d -c" },
527 { "xz", "xz -d -c" },
536 static const char *Ada_suffixes
[] =
537 { "ads", "adb", "ada", NULL
};
538 static const char Ada_help
[] =
539 "In Ada code, functions, procedures, packages, tasks and types are\n\
540 tags. Use the '--packages-only' option to create tags for\n\
542 Ada tag names have suffixes indicating the type of entity:\n\
543 Entity type: Qualifier:\n\
544 ------------ ----------\n\
551 Thus, 'M-x find-tag <RET> bidule/b <RET>' will go directly to the\n\
552 body of the package 'bidule', while 'M-x find-tag <RET> bidule <RET>'\n\
553 will just search for any tag 'bidule'.";
556 static const char *Asm_suffixes
[] =
557 { "a", /* Unix assembler */
558 "asm", /* Microcontroller assembly */
559 "def", /* BSO/Tasking definition includes */
560 "inc", /* Microcontroller include files */
561 "ins", /* Microcontroller include files */
562 "s", "sa", /* Unix assembler */
563 "S", /* cpp-processed Unix assembler */
564 "src", /* BSO/Tasking C compiler output */
567 static const char Asm_help
[] =
568 "In assembler code, labels appearing at the beginning of a line,\n\
569 followed by a colon, are tags.";
572 /* Note that .c and .h can be considered C++, if the --c++ flag was
573 given, or if the `class' or `template' keywords are met inside the file.
574 That is why default_C_entries is called for these. */
575 static const char *default_C_suffixes
[] =
577 #if CTAGS /* C help for Ctags */
578 static const char default_C_help
[] =
579 "In C code, any C function is a tag. Use -t to tag typedefs.\n\
580 Use -T to tag definitions of 'struct', 'union' and 'enum'.\n\
581 Use -d to tag '#define' macro definitions and 'enum' constants.\n\
582 Use --globals to tag global variables.\n\
583 You can tag function declarations and external variables by\n\
584 using '--declarations', and struct members by using '--members'.";
585 #else /* C help for Etags */
586 static const char default_C_help
[] =
587 "In C code, any C function or typedef is a tag, and so are\n\
588 definitions of 'struct', 'union' and 'enum'. '#define' macro\n\
589 definitions and 'enum' constants are tags unless you specify\n\
590 '--no-defines'. Global variables are tags unless you specify\n\
591 '--no-globals' and so are struct members unless you specify\n\
592 '--no-members'. Use of '--no-globals', '--no-defines' and\n\
593 '--no-members' can make the tags table file much smaller.\n\
594 You can tag function declarations and external variables by\n\
595 using '--declarations'.";
596 #endif /* C help for Ctags and Etags */
598 static const char *Cplusplus_suffixes
[] =
599 { "C", "c++", "cc", "cpp", "cxx", "H", "h++", "hh", "hpp", "hxx",
600 "M", /* Objective C++ */
601 "pdb", /* PostScript with C syntax */
603 static const char Cplusplus_help
[] =
604 "In C++ code, all the tag constructs of C code are tagged. (Use\n\
605 --help --lang=c --lang=c++ for full help.)\n\
606 In addition to C tags, member functions are also recognized. Member\n\
607 variables are recognized unless you use the '--no-members' option.\n\
608 Tags for variables and functions in classes are named 'CLASS::VARIABLE'\n\
609 and 'CLASS::FUNCTION'. 'operator' definitions have tag names like\n\
612 static const char *Cjava_suffixes
[] =
614 static char Cjava_help
[] =
615 "In Java code, all the tags constructs of C and C++ code are\n\
616 tagged. (Use --help --lang=c --lang=c++ --lang=java for full help.)";
619 static const char *Cobol_suffixes
[] =
620 { "COB", "cob", NULL
};
621 static char Cobol_help
[] =
622 "In Cobol code, tags are paragraph names; that is, any word\n\
623 starting in column 8 and followed by a period.";
625 static const char *Cstar_suffixes
[] =
626 { "cs", "hs", NULL
};
628 static const char *Erlang_suffixes
[] =
629 { "erl", "hrl", NULL
};
630 static const char Erlang_help
[] =
631 "In Erlang code, the tags are the functions, records and macros\n\
632 defined in the file.";
634 const char *Forth_suffixes
[] =
635 { "fth", "tok", NULL
};
636 static const char Forth_help
[] =
637 "In Forth code, tags are words defined by ':',\n\
638 constant, code, create, defer, value, variable, buffer:, field.";
640 static const char *Fortran_suffixes
[] =
641 { "F", "f", "f90", "for", NULL
};
642 static const char Fortran_help
[] =
643 "In Fortran code, functions, subroutines and block data are tags.";
645 static const char *Go_suffixes
[] = {"go", NULL
};
646 static const char Go_help
[] =
647 "In Go code, functions, interfaces and packages are tags.";
649 static const char *HTML_suffixes
[] =
650 { "htm", "html", "shtml", NULL
};
651 static const char HTML_help
[] =
652 "In HTML input files, the tags are the 'title' and the 'h1', 'h2',\n\
653 'h3' headers. Also, tags are 'name=' in anchors and all\n\
654 occurrences of 'id='.";
656 static const char *Lisp_suffixes
[] =
657 { "cl", "clisp", "el", "l", "lisp", "LSP", "lsp", "ml", NULL
};
658 static const char Lisp_help
[] =
659 "In Lisp code, any function defined with 'defun', any variable\n\
660 defined with 'defvar' or 'defconst', and in general the first\n\
661 argument of any expression that starts with '(def' in column zero\n\
663 The '--declarations' option tags \"(defvar foo)\" constructs too.";
665 static const char *Lua_suffixes
[] =
666 { "lua", "LUA", NULL
};
667 static const char Lua_help
[] =
668 "In Lua scripts, all functions are tags.";
670 static const char *Makefile_filenames
[] =
671 { "Makefile", "makefile", "GNUMakefile", "Makefile.in", "Makefile.am", NULL
};
672 static const char Makefile_help
[] =
673 "In makefiles, targets are tags; additionally, variables are tags\n\
674 unless you specify '--no-globals'.";
676 static const char *Objc_suffixes
[] =
677 { "lm", /* Objective lex file */
678 "m", /* Objective C file */
680 static const char Objc_help
[] =
681 "In Objective C code, tags include Objective C definitions for classes,\n\
682 class categories, methods and protocols. Tags for variables and\n\
683 functions in classes are named 'CLASS::VARIABLE' and 'CLASS::FUNCTION'.\n\
684 (Use --help --lang=c --lang=objc --lang=java for full help.)";
686 static const char *Pascal_suffixes
[] =
687 { "p", "pas", NULL
};
688 static const char Pascal_help
[] =
689 "In Pascal code, the tags are the functions and procedures defined\n\
691 /* " // this is for working around an Emacs highlighting bug... */
693 static const char *Perl_suffixes
[] =
694 { "pl", "pm", NULL
};
695 static const char *Perl_interpreters
[] =
696 { "perl", "@PERL@", NULL
};
697 static const char Perl_help
[] =
698 "In Perl code, the tags are the packages, subroutines and variables\n\
699 defined by the 'package', 'sub', 'my' and 'local' keywords. Use\n\
700 '--globals' if you want to tag global variables. Tags for\n\
701 subroutines are named 'PACKAGE::SUB'. The name for subroutines\n\
702 defined in the default package is 'main::SUB'.";
704 static const char *PHP_suffixes
[] =
705 { "php", "php3", "php4", NULL
};
706 static const char PHP_help
[] =
707 "In PHP code, tags are functions, classes and defines. Unless you use\n\
708 the '--no-members' option, vars are tags too.";
710 static const char *plain_C_suffixes
[] =
711 { "pc", /* Pro*C file */
714 static const char *PS_suffixes
[] =
715 { "ps", "psw", NULL
}; /* .psw is for PSWrap */
716 static const char PS_help
[] =
717 "In PostScript code, the tags are the functions.";
719 static const char *Prolog_suffixes
[] =
721 static const char Prolog_help
[] =
722 "In Prolog code, tags are predicates and rules at the beginning of\n\
725 static const char *Python_suffixes
[] =
727 static const char Python_help
[] =
728 "In Python code, 'def' or 'class' at the beginning of a line\n\
731 static const char *Ruby_suffixes
[] =
732 { "rb", "ru", "rbw", NULL
};
733 static const char *Ruby_filenames
[] =
734 { "Rakefile", "Thorfile", NULL
};
735 static const char Ruby_help
[] =
736 "In Ruby code, 'def' or 'class' or 'module' at the beginning of\n\
737 a line generate a tag. Constants also generate a tag.";
739 /* Can't do the `SCM' or `scm' prefix with a version number. */
740 static const char *Scheme_suffixes
[] =
741 { "oak", "sch", "scheme", "SCM", "scm", "SM", "sm", "ss", "t", NULL
};
742 static const char Scheme_help
[] =
743 "In Scheme code, tags include anything defined with 'def' or with a\n\
744 construct whose name starts with 'def'. They also include\n\
745 variables set with 'set!' at top level in the file.";
747 static const char *TeX_suffixes
[] =
748 { "bib", "clo", "cls", "ltx", "sty", "TeX", "tex", NULL
};
749 static const char TeX_help
[] =
750 "In LaTeX text, the argument of any of the commands '\\chapter',\n\
751 '\\section', '\\subsection', '\\subsubsection', '\\eqno', '\\label',\n\
752 '\\ref', '\\cite', '\\bibitem', '\\part', '\\appendix', '\\entry',\n\
753 '\\index', '\\def', '\\newcommand', '\\renewcommand',\n\
754 '\\newenvironment' or '\\renewenvironment' is a tag.\n\
756 Other commands can be specified by setting the environment variable\n\
757 'TEXTAGS' to a colon-separated list like, for example,\n\
758 TEXTAGS=\"mycommand:myothercommand\".";
761 static const char *Texinfo_suffixes
[] =
762 { "texi", "texinfo", "txi", NULL
};
763 static const char Texinfo_help
[] =
764 "for texinfo files, lines starting with @node are tagged.";
766 static const char *Yacc_suffixes
[] =
767 { "y", "y++", "ym", "yxx", "yy", NULL
}; /* .ym is Objective yacc file */
768 static const char Yacc_help
[] =
769 "In Bison or Yacc input files, each rule defines as a tag the\n\
770 nonterminal it constructs. The portions of the file that contain\n\
771 C code are parsed as C code (use --help --lang=c --lang=yacc\n\
774 static const char auto_help
[] =
775 "'auto' is not a real language, it indicates to use\n\
776 a default language for files base on file name suffix and file contents.";
778 static const char none_help
[] =
779 "'none' is not a real language, it indicates to only do\n\
780 regexp processing on files.";
782 static const char no_lang_help
[] =
783 "No detailed help available for this language.";
787 * Table of languages.
789 * It is ok for a given function to be listed under more than one
790 * name. I just didn't.
793 static language lang_names
[] =
795 { "ada", Ada_help
, Ada_funcs
, Ada_suffixes
},
796 { "asm", Asm_help
, Asm_labels
, Asm_suffixes
},
797 { "c", default_C_help
, default_C_entries
, default_C_suffixes
},
798 { "c++", Cplusplus_help
, Cplusplus_entries
, Cplusplus_suffixes
},
799 { "c*", no_lang_help
, Cstar_entries
, Cstar_suffixes
},
800 { "cobol", Cobol_help
, Cobol_paragraphs
, Cobol_suffixes
},
801 { "erlang", Erlang_help
, Erlang_functions
, Erlang_suffixes
},
802 { "forth", Forth_help
, Forth_words
, Forth_suffixes
},
803 { "fortran", Fortran_help
, Fortran_functions
, Fortran_suffixes
},
804 { "go", Go_help
, Go_functions
, Go_suffixes
},
805 { "html", HTML_help
, HTML_labels
, HTML_suffixes
},
806 { "java", Cjava_help
, Cjava_entries
, Cjava_suffixes
},
807 { "lisp", Lisp_help
, Lisp_functions
, Lisp_suffixes
},
808 { "lua", Lua_help
, Lua_functions
, Lua_suffixes
},
809 { "makefile", Makefile_help
,Makefile_targets
,NULL
,Makefile_filenames
},
810 { "objc", Objc_help
, plain_C_entries
, Objc_suffixes
},
811 { "pascal", Pascal_help
, Pascal_functions
, Pascal_suffixes
},
812 { "perl",Perl_help
,Perl_functions
,Perl_suffixes
,NULL
,Perl_interpreters
},
813 { "php", PHP_help
, PHP_functions
, PHP_suffixes
},
814 { "postscript",PS_help
, PS_functions
, PS_suffixes
},
815 { "proc", no_lang_help
, plain_C_entries
, plain_C_suffixes
},
816 { "prolog", Prolog_help
, Prolog_functions
, Prolog_suffixes
},
817 { "python", Python_help
, Python_functions
, Python_suffixes
},
818 { "ruby", Ruby_help
,Ruby_functions
,Ruby_suffixes
,Ruby_filenames
},
819 { "scheme", Scheme_help
, Scheme_functions
, Scheme_suffixes
},
820 { "tex", TeX_help
, TeX_commands
, TeX_suffixes
},
821 { "texinfo", Texinfo_help
, Texinfo_nodes
, Texinfo_suffixes
},
822 { "yacc", Yacc_help
,Yacc_entries
,Yacc_suffixes
,NULL
,NULL
,true},
823 { "auto", auto_help
}, /* default guessing scheme */
824 { "none", none_help
, just_read_file
}, /* regexp matching only */
825 { NULL
} /* end of list */
830 print_language_names (void)
833 const char **name
, **ext
;
835 puts ("\nThese are the currently supported languages, along with the\n\
836 default file names and dot suffixes:");
837 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
839 printf (" %-*s", 10, lang
->name
);
840 if (lang
->filenames
!= NULL
)
841 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
842 printf (" %s", *name
);
843 if (lang
->suffixes
!= NULL
)
844 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
845 printf (" .%s", *ext
);
848 puts ("where 'auto' means use default language for files based on file\n\
849 name suffix, and 'none' means only do regexp processing on files.\n\
850 If no language is specified and no matching suffix is found,\n\
851 the first line of the file is read for a sharp-bang (#!) sequence\n\
852 followed by the name of an interpreter. If no such sequence is found,\n\
853 Fortran is tried first; if no tags are found, C is tried next.\n\
854 When parsing any C file, a \"class\" or \"template\" keyword\n\
856 puts ("Compressed files are supported using gzip, bzip2, and xz.\n\
858 For detailed help on a given language use, for example,\n\
859 etags --help --lang=ada.");
863 # define EMACS_NAME "standalone"
866 # define VERSION "17.38.1.4"
868 static _Noreturn
void
871 char emacs_copyright
[] = COPYRIGHT
;
873 printf ("%s (%s %s)\n", (CTAGS
) ? "ctags" : "etags", EMACS_NAME
, VERSION
);
874 puts (emacs_copyright
);
875 puts ("This program is distributed under the terms in ETAGS.README");
880 #ifndef PRINT_UNDOCUMENTED_OPTIONS_HELP
881 # define PRINT_UNDOCUMENTED_OPTIONS_HELP false
884 static _Noreturn
void
885 print_help (argument
*argbuffer
)
887 bool help_for_lang
= false;
889 for (; argbuffer
->arg_type
!= at_end
; argbuffer
++)
890 if (argbuffer
->arg_type
== at_language
)
894 puts (argbuffer
->lang
->help
);
895 help_for_lang
= true;
901 printf ("Usage: %s [options] [[regex-option ...] file-name] ...\n\
903 These are the options accepted by %s.\n", progname
, progname
);
904 puts ("You may use unambiguous abbreviations for the long option names.");
905 puts (" A - as file name means read names from stdin (one per line).\n\
906 Absolute names are stored in the output file as they are.\n\
907 Relative ones are stored relative to the output file's directory.\n");
909 puts ("-a, --append\n\
910 Append tag entries to existing tags file.");
912 puts ("--packages-only\n\
913 For Ada files, only generate tags for packages.");
916 puts ("-B, --backward-search\n\
917 Write the search commands for the tag entries using '?', the\n\
918 backward-search command instead of '/', the forward-search command.");
920 /* This option is mostly obsolete, because etags can now automatically
921 detect C++. Retained for backward compatibility and for debugging and
922 experimentation. In principle, we could want to tag as C++ even
923 before any "class" or "template" keyword.
925 Treat files whose name suffix defaults to C language as C++ files.");
928 puts ("--declarations\n\
929 In C and derived languages, create tags for function declarations,");
931 puts ("\tand create tags for extern variables if --globals is used.");
934 ("\tand create tags for extern variables unless --no-globals is used.");
937 puts ("-d, --defines\n\
938 Create tag entries for C #define constants and enum constants, too.");
940 puts ("-D, --no-defines\n\
941 Don't create tag entries for C #define constants and enum constants.\n\
942 This makes the tags file smaller.");
945 puts ("-i FILE, --include=FILE\n\
946 Include a note in tag file indicating that, when searching for\n\
947 a tag, one should also consult the tags file FILE after\n\
948 checking the current file.");
950 puts ("-l LANG, --language=LANG\n\
951 Force the following files to be considered as written in the\n\
952 named language up to the next --language=LANG option.");
956 Create tag entries for global variables in some languages.");
958 puts ("--no-globals\n\
959 Do not create tag entries for global variables in some\n\
960 languages. This makes the tags file smaller.");
962 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
963 puts ("--no-line-directive\n\
964 Ignore #line preprocessor directives in C and derived languages.");
968 Create tag entries for members of structures in some languages.");
970 puts ("--no-members\n\
971 Do not create tag entries for members of structures\n\
972 in some languages.");
974 puts ("-Q, --class-qualify\n\
975 Qualify tag names with their class name in C++, ObjC, and Java.\n\
976 This produces tag names of the form \"class::member\" for C++,\n\
977 \"class(category)\" for Objective C, and \"class.member\" for Java.\n\
978 For Objective C, this also produces class methods qualified with\n\
979 their arguments, as in \"foo:bar:baz:more\".");
980 puts ("-r REGEXP, --regex=REGEXP or --regex=@regexfile\n\
981 Make a tag for each line matching a regular expression pattern\n\
982 in the following files. {LANGUAGE}REGEXP uses REGEXP for LANGUAGE\n\
983 files only. REGEXFILE is a file containing one REGEXP per line.\n\
984 REGEXP takes the form /TAGREGEXP/TAGNAME/MODS, where TAGNAME/ is\n\
985 optional. The TAGREGEXP pattern is anchored (as if preceded by ^).");
986 puts (" If TAGNAME/ is present, the tags created are named.\n\
987 For example Tcl named tags can be created with:\n\
988 --regex=\"/proc[ \\t]+\\([^ \\t]+\\)/\\1/.\".\n\
989 MODS are optional one-letter modifiers: 'i' means to ignore case,\n\
990 'm' means to allow multi-line matches, 's' implies 'm' and\n\
991 causes dot to match any character, including newline.");
993 puts ("-R, --no-regex\n\
994 Don't create tags from regexps for the following files.");
996 puts ("-I, --ignore-indentation\n\
997 In C and C++ do not assume that a closing brace in the first\n\
998 column is the final brace of a function or structure definition.");
1000 puts ("-o FILE, --output=FILE\n\
1001 Write the tags to FILE.");
1003 puts ("--parse-stdin=NAME\n\
1004 Read from standard input and record tags as belonging to file NAME.");
1008 puts ("-t, --typedefs\n\
1009 Generate tag entries for C and Ada typedefs.");
1010 puts ("-T, --typedefs-and-c++\n\
1011 Generate tag entries for C typedefs, C struct/enum/union tags,\n\
1012 and C++ member functions.");
1016 puts ("-u, --update\n\
1017 Update the tag entries for the given files, leaving tag\n\
1018 entries for other files in place. Currently, this is\n\
1019 implemented by deleting the existing entries for the given\n\
1020 files and then rewriting the new entries at the end of the\n\
1021 tags file. It is often faster to simply rebuild the entire\n\
1022 tag file than to use this.");
1026 puts ("-v, --vgrind\n\
1027 Print on the standard output an index of items intended for\n\
1028 human consumption, similar to the output of vgrind. The index\n\
1029 is sorted, and gives the page number of each item.");
1031 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
1032 puts ("-w, --no-duplicates\n\
1033 Do not create duplicate tag entries, for compatibility with\n\
1034 traditional ctags.");
1036 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
1037 puts ("-w, --no-warn\n\
1038 Suppress warning messages about duplicate tag entries.");
1040 puts ("-x, --cxref\n\
1041 Like --vgrind, but in the style of cxref, rather than vgrind.\n\
1042 The output uses line numbers instead of page numbers, but\n\
1043 beyond that the differences are cosmetic; try both to see\n\
1047 puts ("-V, --version\n\
1048 Print the version of the program.\n\
1050 Print this help message.\n\
1051 Followed by one or more '--language' options prints detailed\n\
1052 help about tag generation for the specified languages.");
1054 print_language_names ();
1057 puts ("Report bugs to bug-gnu-emacs@gnu.org");
1059 exit (EXIT_SUCCESS
);
1064 main (int argc
, char **argv
)
1067 unsigned int nincluded_files
;
1068 char **included_files
;
1069 argument
*argbuffer
;
1070 int current_arg
, file_count
;
1071 linebuffer filename_lb
;
1072 bool help_asked
= false;
1078 nincluded_files
= 0;
1079 included_files
= xnew (argc
, char *);
1083 /* Allocate enough no matter what happens. Overkill, but each one
1085 argbuffer
= xnew (argc
, argument
);
1088 * Always find typedefs and structure tags.
1089 * Also default to find macro constants, enum constants, struct
1090 * members and global variables. Do it for both etags and ctags.
1092 typedefs
= typedefs_or_cplusplus
= constantypedefs
= true;
1093 globals
= members
= true;
1095 /* When the optstring begins with a '-' getopt_long does not rearrange the
1096 non-options arguments to be at the end, but leaves them alone. */
1097 optstring
= concat ("-ac:Cf:Il:o:Qr:RSVhH",
1098 (CTAGS
) ? "BxdtTuvw" : "Di:",
1101 while ((opt
= getopt_long (argc
, argv
, optstring
, longopts
, NULL
)) != EOF
)
1105 /* If getopt returns 0, then it has already processed a
1106 long-named option. We should do nothing. */
1110 /* This means that a file name has been seen. Record it. */
1111 argbuffer
[current_arg
].arg_type
= at_filename
;
1112 argbuffer
[current_arg
].what
= optarg
;
1113 len
= strlen (optarg
);
1114 if (whatlen_max
< len
)
1121 /* Parse standard input. Idea by Vivek <vivek@etla.org>. */
1122 argbuffer
[current_arg
].arg_type
= at_stdin
;
1123 argbuffer
[current_arg
].what
= optarg
;
1124 len
= strlen (optarg
);
1125 if (whatlen_max
< len
)
1130 fatal ("cannot parse standard input more than once");
1131 parsing_stdin
= true;
1134 /* Common options. */
1135 case 'a': append_to_tagfile
= true; break;
1136 case 'C': cplusplus
= true; break;
1137 case 'f': /* for compatibility with old makefiles */
1141 error ("-o option may only be given once.");
1142 suggest_asking_for_help ();
1148 case 'S': /* for backward compatibility */
1149 ignoreindent
= true;
1153 language
*lang
= get_language_from_langname (optarg
);
1156 argbuffer
[current_arg
].lang
= lang
;
1157 argbuffer
[current_arg
].arg_type
= at_language
;
1163 /* Backward compatibility: support obsolete --ignore-case-regexp. */
1164 optarg
= concat (optarg
, "i", ""); /* memory leak here */
1167 argbuffer
[current_arg
].arg_type
= at_regexp
;
1168 argbuffer
[current_arg
].what
= optarg
;
1169 len
= strlen (optarg
);
1170 if (whatlen_max
< len
)
1175 argbuffer
[current_arg
].arg_type
= at_regexp
;
1176 argbuffer
[current_arg
].what
= NULL
;
1191 case 'D': constantypedefs
= false; break;
1192 case 'i': included_files
[nincluded_files
++] = optarg
; break;
1194 /* Ctags options. */
1195 case 'B': searchar
= '?'; break;
1196 case 'd': constantypedefs
= true; break;
1197 case 't': typedefs
= true; break;
1198 case 'T': typedefs
= typedefs_or_cplusplus
= true; break;
1199 case 'u': update
= true; break;
1200 case 'v': vgrind_style
= true; /*FALLTHRU*/
1201 case 'x': cxref_style
= true; break;
1202 case 'w': no_warnings
= true; break;
1204 suggest_asking_for_help ();
1208 /* No more options. Store the rest of arguments. */
1209 for (; optind
< argc
; optind
++)
1211 argbuffer
[current_arg
].arg_type
= at_filename
;
1212 argbuffer
[current_arg
].what
= argv
[optind
];
1213 len
= strlen (argv
[optind
]);
1214 if (whatlen_max
< len
)
1220 argbuffer
[current_arg
].arg_type
= at_end
;
1223 print_help (argbuffer
);
1226 if (nincluded_files
== 0 && file_count
== 0)
1228 error ("no input files specified.");
1229 suggest_asking_for_help ();
1233 if (tagfile
== NULL
)
1234 tagfile
= savestr (CTAGS
? "tags" : "TAGS");
1235 cwd
= etags_getcwd (); /* the current working directory */
1236 if (cwd
[strlen (cwd
) - 1] != '/')
1239 cwd
= concat (oldcwd
, "/", "");
1243 /* Compute base directory for relative file names. */
1244 if (streq (tagfile
, "-")
1245 || strneq (tagfile
, "/dev/", 5))
1246 tagfiledir
= cwd
; /* relative file names are relative to cwd */
1249 canonicalize_filename (tagfile
);
1250 tagfiledir
= absolute_dirname (tagfile
, cwd
);
1253 linebuffer_init (&lb
);
1254 linebuffer_init (&filename_lb
);
1255 linebuffer_init (&filebuf
);
1256 linebuffer_init (&token_name
);
1260 if (streq (tagfile
, "-"))
1263 SET_BINARY (fileno (stdout
));
1266 tagf
= fopen (tagfile
, append_to_tagfile
? "ab" : "wb");
1272 * Loop through files finding functions.
1274 for (i
= 0; i
< current_arg
; i
++)
1276 static language
*lang
; /* non-NULL if language is forced */
1279 switch (argbuffer
[i
].arg_type
)
1282 lang
= argbuffer
[i
].lang
;
1285 analyze_regex (argbuffer
[i
].what
);
1288 this_file
= argbuffer
[i
].what
;
1289 /* Input file named "-" means read file names from stdin
1290 (one per line) and use them. */
1291 if (streq (this_file
, "-"))
1294 fatal ("cannot parse standard input "
1295 "AND read file names from it");
1296 while (readline_internal (&filename_lb
, stdin
, "-") > 0)
1297 process_file_name (filename_lb
.buffer
, lang
);
1300 process_file_name (this_file
, lang
);
1303 this_file
= argbuffer
[i
].what
;
1304 process_file (stdin
, this_file
, lang
);
1307 error ("internal error: arg_type");
1313 free (filebuf
.buffer
);
1314 free (token_name
.buffer
);
1316 if (!CTAGS
|| cxref_style
)
1318 /* Write the remaining tags to tagf (ETAGS) or stdout (CXREF). */
1319 put_entries (nodehead
);
1320 free_tree (nodehead
);
1326 /* Output file entries that have no tags. */
1327 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1329 fprintf (tagf
, "\f\n%s,0\n", fdp
->taggedfname
);
1331 while (nincluded_files
-- > 0)
1332 fprintf (tagf
, "\f\n%s,include\n", *included_files
++);
1334 if (fclose (tagf
) == EOF
)
1338 exit (EXIT_SUCCESS
);
1341 /* From here on, we are in (CTAGS && !cxref_style) */
1345 xmalloc (strlen (tagfile
) + whatlen_max
+
1346 sizeof "mv..OTAGS;fgrep -v '\t\t' OTAGS >;rm OTAGS");
1347 for (i
= 0; i
< current_arg
; ++i
)
1349 switch (argbuffer
[i
].arg_type
)
1355 continue; /* the for loop */
1357 char *z
= stpcpy (cmd
, "mv ");
1358 z
= stpcpy (z
, tagfile
);
1359 z
= stpcpy (z
, " OTAGS;fgrep -v '\t");
1360 z
= stpcpy (z
, argbuffer
[i
].what
);
1361 z
= stpcpy (z
, "\t' OTAGS >");
1362 z
= stpcpy (z
, tagfile
);
1363 strcpy (z
, ";rm OTAGS");
1364 if (system (cmd
) != EXIT_SUCCESS
)
1365 fatal ("failed to execute shell command");
1368 append_to_tagfile
= true;
1371 tagf
= fopen (tagfile
, append_to_tagfile
? "ab" : "wb");
1374 put_entries (nodehead
); /* write all the tags (CTAGS) */
1375 free_tree (nodehead
);
1377 if (fclose (tagf
) == EOF
)
1381 if (append_to_tagfile
|| update
)
1383 char *cmd
= xmalloc (2 * strlen (tagfile
) + sizeof "sort -u -o..");
1384 /* Maybe these should be used:
1385 setenv ("LC_COLLATE", "C", 1);
1386 setenv ("LC_ALL", "C", 1); */
1387 char *z
= stpcpy (cmd
, "sort -u -o ");
1388 z
= stpcpy (z
, tagfile
);
1390 strcpy (z
, tagfile
);
1391 exit (system (cmd
));
1393 return EXIT_SUCCESS
;
1398 * Return a compressor given the file name. If EXTPTR is non-zero,
1399 * return a pointer into FILE where the compressor-specific
1400 * extension begins. If no compressor is found, NULL is returned
1401 * and EXTPTR is not significant.
1402 * Idea by Vladimir Alexiev <vladimir@cs.ualberta.ca> (1998)
1405 get_compressor_from_suffix (char *file
, char **extptr
)
1408 char *slash
, *suffix
;
1410 /* File has been processed by canonicalize_filename,
1411 so we don't need to consider backslashes on DOS_NT. */
1412 slash
= strrchr (file
, '/');
1413 suffix
= strrchr (file
, '.');
1414 if (suffix
== NULL
|| suffix
< slash
)
1419 /* Let those poor souls who live with DOS 8+3 file name limits get
1420 some solace by treating foo.cgz as if it were foo.c.gz, etc.
1421 Only the first do loop is run if not MSDOS */
1424 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1425 if (streq (compr
->suffix
, suffix
))
1428 break; /* do it only once: not really a loop */
1431 } while (*suffix
!= '\0');
1438 * Return a language given the name.
1441 get_language_from_langname (const char *name
)
1446 error ("empty language name");
1449 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1450 if (streq (name
, lang
->name
))
1452 error ("unknown language \"%s\"", name
);
1460 * Return a language given the interpreter name.
1463 get_language_from_interpreter (char *interpreter
)
1468 if (interpreter
== NULL
)
1470 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1471 if (lang
->interpreters
!= NULL
)
1472 for (iname
= lang
->interpreters
; *iname
!= NULL
; iname
++)
1473 if (streq (*iname
, interpreter
))
1482 * Return a language given the file name.
1485 get_language_from_filename (char *file
, int case_sensitive
)
1488 const char **name
, **ext
, *suffix
;
1491 /* Try whole file name first. */
1492 slash
= strrchr (file
, '/');
1496 else if (file
[0] && file
[1] == ':')
1499 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1500 if (lang
->filenames
!= NULL
)
1501 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
1502 if ((case_sensitive
)
1503 ? streq (*name
, file
)
1504 : strcaseeq (*name
, file
))
1507 /* If not found, try suffix after last dot. */
1508 suffix
= strrchr (file
, '.');
1512 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1513 if (lang
->suffixes
!= NULL
)
1514 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
1515 if ((case_sensitive
)
1516 ? streq (*ext
, suffix
)
1517 : strcaseeq (*ext
, suffix
))
1524 * This routine is called on each file argument.
1527 process_file_name (char *file
, language
*lang
)
1532 char *compressed_name
, *uncompressed_name
;
1533 char *ext
, *real_name
, *tmp_name
;
1536 canonicalize_filename (file
);
1537 if (streq (file
, tagfile
) && !streq (tagfile
, "-"))
1539 error ("skipping inclusion of %s in self.", file
);
1542 compr
= get_compressor_from_suffix (file
, &ext
);
1545 compressed_name
= file
;
1546 uncompressed_name
= savenstr (file
, ext
- file
);
1550 compressed_name
= NULL
;
1551 uncompressed_name
= file
;
1554 /* If the canonicalized uncompressed name
1555 has already been dealt with, skip it silently. */
1556 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1558 assert (fdp
->infname
!= NULL
);
1559 if (streq (uncompressed_name
, fdp
->infname
))
1563 inf
= fopen (file
, "r" FOPEN_BINARY
);
1568 int file_errno
= errno
;
1569 if (compressed_name
)
1571 /* Try with the given suffix. */
1572 inf
= fopen (uncompressed_name
, "r" FOPEN_BINARY
);
1574 real_name
= uncompressed_name
;
1578 /* Try all possible suffixes. */
1579 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1581 compressed_name
= concat (file
, ".", compr
->suffix
);
1582 inf
= fopen (compressed_name
, "r" FOPEN_BINARY
);
1585 real_name
= compressed_name
;
1590 char *suf
= compressed_name
+ strlen (file
);
1591 size_t suflen
= strlen (compr
->suffix
) + 1;
1592 for ( ; suf
[1]; suf
++, suflen
--)
1594 memmove (suf
, suf
+ 1, suflen
);
1595 inf
= fopen (compressed_name
, "r" FOPEN_BINARY
);
1598 real_name
= compressed_name
;
1605 free (compressed_name
);
1606 compressed_name
= NULL
;
1617 if (real_name
== compressed_name
)
1620 tmp_name
= etags_mktmp ();
1625 #if MSDOS || defined (DOS_NT)
1626 char *cmd1
= concat (compr
->command
, " \"", real_name
);
1627 char *cmd
= concat (cmd1
, "\" > ", tmp_name
);
1629 char *cmd1
= concat (compr
->command
, " '", real_name
);
1630 char *cmd
= concat (cmd1
, "' > ", tmp_name
);
1634 if (system (cmd
) == -1)
1641 inf
= fopen (tmp_name
, "r" FOPEN_BINARY
);
1655 process_file (inf
, uncompressed_name
, lang
);
1657 retval
= fclose (inf
);
1658 if (real_name
== compressed_name
)
1667 if (compressed_name
!= file
)
1668 free (compressed_name
);
1669 if (uncompressed_name
!= file
)
1670 free (uncompressed_name
);
1677 process_file (FILE *fh
, char *fn
, language
*lang
)
1679 static const fdesc emptyfdesc
;
1683 /* Create a new input file description entry. */
1684 fdp
= xnew (1, fdesc
);
1687 fdp
->infname
= savestr (fn
);
1689 fdp
->infabsname
= absolute_filename (fn
, cwd
);
1690 fdp
->infabsdir
= absolute_dirname (fn
, cwd
);
1691 if (filename_is_absolute (fn
))
1693 /* An absolute file name. Canonicalize it. */
1694 fdp
->taggedfname
= absolute_filename (fn
, NULL
);
1698 /* A file name relative to cwd. Make it relative
1699 to the directory of the tags file. */
1700 fdp
->taggedfname
= relative_filename (fn
, tagfiledir
);
1702 fdp
->usecharno
= true; /* use char position when making tags */
1704 fdp
->written
= false; /* not written on tags file yet */
1707 curfdp
= fdhead
; /* the current file description */
1711 /* If not Ctags, and if this is not metasource and if it contained no #line
1712 directives, we can write the tags and free all nodes pointing to
1715 && curfdp
->usecharno
/* no #line directives in this file */
1716 && !curfdp
->lang
->metasource
)
1720 /* Look for the head of the sublist relative to this file. See add_node
1721 for the structure of the node tree. */
1723 for (np
= nodehead
; np
!= NULL
; prev
= np
, np
= np
->left
)
1724 if (np
->fdp
== curfdp
)
1727 /* If we generated tags for this file, write and delete them. */
1730 /* This is the head of the last sublist, if any. The following
1731 instructions depend on this being true. */
1732 assert (np
->left
== NULL
);
1734 assert (fdhead
== curfdp
);
1735 assert (last_node
->fdp
== curfdp
);
1736 put_entries (np
); /* write tags for file curfdp->taggedfname */
1737 free_tree (np
); /* remove the written nodes */
1739 nodehead
= NULL
; /* no nodes left */
1741 prev
->left
= NULL
; /* delete the pointer to the sublist */
1747 reset_input (FILE *inf
)
1749 if (fseek (inf
, 0, SEEK_SET
) != 0)
1750 perror (infilename
);
1754 * This routine opens the specified file and calls the function
1755 * which finds the function and type definitions.
1758 find_entries (FILE *inf
)
1761 language
*lang
= curfdp
->lang
;
1762 Lang_function
*parser
= NULL
;
1764 /* If user specified a language, use it. */
1765 if (lang
!= NULL
&& lang
->function
!= NULL
)
1767 parser
= lang
->function
;
1770 /* Else try to guess the language given the file name. */
1773 lang
= get_language_from_filename (curfdp
->infname
, true);
1774 if (lang
!= NULL
&& lang
->function
!= NULL
)
1776 curfdp
->lang
= lang
;
1777 parser
= lang
->function
;
1781 /* Else look for sharp-bang as the first two characters. */
1783 && readline_internal (&lb
, inf
, infilename
) > 0
1785 && lb
.buffer
[0] == '#'
1786 && lb
.buffer
[1] == '!')
1790 /* Set lp to point at the first char after the last slash in the
1791 line or, if no slashes, at the first nonblank. Then set cp to
1792 the first successive blank and terminate the string. */
1793 lp
= strrchr (lb
.buffer
+2, '/');
1797 lp
= skip_spaces (lb
.buffer
+ 2);
1798 cp
= skip_non_spaces (lp
);
1801 if (strlen (lp
) > 0)
1803 lang
= get_language_from_interpreter (lp
);
1804 if (lang
!= NULL
&& lang
->function
!= NULL
)
1806 curfdp
->lang
= lang
;
1807 parser
= lang
->function
;
1814 /* Else try to guess the language given the case insensitive file name. */
1817 lang
= get_language_from_filename (curfdp
->infname
, false);
1818 if (lang
!= NULL
&& lang
->function
!= NULL
)
1820 curfdp
->lang
= lang
;
1821 parser
= lang
->function
;
1825 /* Else try Fortran or C. */
1828 node
*old_last_node
= last_node
;
1830 curfdp
->lang
= get_language_from_langname ("fortran");
1833 if (old_last_node
== last_node
)
1834 /* No Fortran entries found. Try C. */
1837 curfdp
->lang
= get_language_from_langname (cplusplus
? "c++" : "c");
1843 if (!no_line_directive
1844 && curfdp
->lang
!= NULL
&& curfdp
->lang
->metasource
)
1845 /* It may be that this is a bingo.y file, and we already parsed a bingo.c
1846 file, or anyway we parsed a file that is automatically generated from
1847 this one. If this is the case, the bingo.c file contained #line
1848 directives that generated tags pointing to this file. Let's delete
1849 them all before parsing this file, which is the real source. */
1851 fdesc
**fdpp
= &fdhead
;
1852 while (*fdpp
!= NULL
)
1854 && streq ((*fdpp
)->taggedfname
, curfdp
->taggedfname
))
1855 /* We found one of those! We must delete both the file description
1856 and all tags referring to it. */
1858 fdesc
*badfdp
= *fdpp
;
1860 /* Delete the tags referring to badfdp->taggedfname
1861 that were obtained from badfdp->infname. */
1862 invalidate_nodes (badfdp
, &nodehead
);
1864 *fdpp
= badfdp
->next
; /* remove the bad description from the list */
1865 free_fdesc (badfdp
);
1868 fdpp
= &(*fdpp
)->next
; /* advance the list pointer */
1871 assert (parser
!= NULL
);
1873 /* Generic initializations before reading from file. */
1874 linebuffer_setlen (&filebuf
, 0); /* reset the file buffer */
1876 /* Generic initializations before parsing file with readline. */
1877 lineno
= 0; /* reset global line number */
1878 charno
= 0; /* reset global char number */
1879 linecharno
= 0; /* reset global char number of line start */
1883 regex_tag_multiline ();
1888 * Check whether an implicitly named tag should be created,
1889 * then call `pfnote'.
1890 * NAME is a string that is internally copied by this function.
1892 * TAGS format specification
1893 * Idea by Sam Kendall <kendall@mv.mv.com> (1997)
1894 * The following is explained in some more detail in etc/ETAGS.EBNF.
1896 * make_tag creates tags with "implicit tag names" (unnamed tags)
1897 * if the following are all true, assuming NONAM=" \f\t\n\r()=,;":
1898 * 1. NAME does not contain any of the characters in NONAM;
1899 * 2. LINESTART contains name as either a rightmost, or rightmost but
1900 * one character, substring;
1901 * 3. the character, if any, immediately before NAME in LINESTART must
1902 * be a character in NONAM;
1903 * 4. the character, if any, immediately after NAME in LINESTART must
1904 * also be a character in NONAM.
1906 * The implementation uses the notinname() macro, which recognizes the
1907 * characters stored in the string `nonam'.
1908 * etags.el needs to use the same characters that are in NONAM.
1911 make_tag (const char *name
, /* tag name, or NULL if unnamed */
1912 int namelen
, /* tag length */
1913 bool is_func
, /* tag is a function */
1914 char *linestart
, /* start of the line where tag is */
1915 int linelen
, /* length of the line where tag is */
1916 int lno
, /* line number */
1917 long int cno
) /* character number */
1919 bool named
= (name
!= NULL
&& namelen
> 0);
1922 if (!CTAGS
&& named
) /* maybe set named to false */
1923 /* Let's try to make an implicit tag name, that is, create an unnamed tag
1924 such that etags.el can guess a name from it. */
1927 register const char *cp
= name
;
1929 for (i
= 0; i
< namelen
; i
++)
1930 if (notinname (*cp
++))
1932 if (i
== namelen
) /* rule #1 */
1934 cp
= linestart
+ linelen
- namelen
;
1935 if (notinname (linestart
[linelen
-1]))
1936 cp
-= 1; /* rule #4 */
1937 if (cp
>= linestart
/* rule #2 */
1939 || notinname (cp
[-1])) /* rule #3 */
1940 && strneq (name
, cp
, namelen
)) /* rule #2 */
1941 named
= false; /* use implicit tag name */
1946 nname
= savenstr (name
, namelen
);
1948 pfnote (nname
, is_func
, linestart
, linelen
, lno
, cno
);
1953 pfnote (char *name
, bool is_func
, char *linestart
, int linelen
, int lno
,
1955 /* tag name, or NULL if unnamed */
1956 /* tag is a function */
1957 /* start of the line where tag is */
1958 /* length of the line where tag is */
1960 /* character number */
1964 assert (name
== NULL
|| name
[0] != '\0');
1965 if (CTAGS
&& name
== NULL
)
1968 np
= xnew (1, node
);
1970 /* If ctags mode, change name "main" to M<thisfilename>. */
1971 if (CTAGS
&& !cxref_style
&& streq (name
, "main"))
1973 char *fp
= strrchr (curfdp
->taggedfname
, '/');
1974 np
->name
= concat ("M", fp
== NULL
? curfdp
->taggedfname
: fp
+ 1, "");
1975 fp
= strrchr (np
->name
, '.');
1976 if (fp
!= NULL
&& fp
[1] != '\0' && fp
[2] == '\0')
1982 np
->been_warned
= false;
1984 np
->is_func
= is_func
;
1986 if (np
->fdp
->usecharno
)
1987 /* Our char numbers are 0-base, because of C language tradition?
1988 ctags compatibility? old versions compatibility? I don't know.
1989 Anyway, since emacs's are 1-base we expect etags.el to take care
1990 of the difference. If we wanted to have 1-based numbers, we would
1991 uncomment the +1 below. */
1992 np
->cno
= cno
/* + 1 */ ;
1994 np
->cno
= invalidcharno
;
1995 np
->left
= np
->right
= NULL
;
1996 if (CTAGS
&& !cxref_style
)
1998 if (strlen (linestart
) < 50)
1999 np
->regex
= concat (linestart
, "$", "");
2001 np
->regex
= savenstr (linestart
, 50);
2004 np
->regex
= savenstr (linestart
, linelen
);
2006 add_node (np
, &nodehead
);
2011 * recurse on left children, iterate on right children.
2014 free_tree (register node
*np
)
2018 register node
*node_right
= np
->right
;
2019 free_tree (np
->left
);
2029 * delete a file description
2032 free_fdesc (register fdesc
*fdp
)
2034 free (fdp
->infname
);
2035 free (fdp
->infabsname
);
2036 free (fdp
->infabsdir
);
2037 free (fdp
->taggedfname
);
2044 * Adds a node to the tree of nodes. In etags mode, sort by file
2045 * name. In ctags mode, sort by tag name. Make no attempt at
2048 * add_node is the only function allowed to add nodes, so it can
2052 add_node (node
*np
, node
**cur_node_p
)
2055 register node
*cur_node
= *cur_node_p
;
2057 if (cur_node
== NULL
)
2067 /* For each file name, tags are in a linked sublist on the right
2068 pointer. The first tags of different files are a linked list
2069 on the left pointer. last_node points to the end of the last
2071 if (last_node
!= NULL
&& last_node
->fdp
== np
->fdp
)
2073 /* Let's use the same sublist as the last added node. */
2074 assert (last_node
->right
== NULL
);
2075 last_node
->right
= np
;
2078 else if (cur_node
->fdp
== np
->fdp
)
2080 /* Scanning the list we found the head of a sublist which is
2081 good for us. Let's scan this sublist. */
2082 add_node (np
, &cur_node
->right
);
2085 /* The head of this sublist is not good for us. Let's try the
2087 add_node (np
, &cur_node
->left
);
2088 } /* if ETAGS mode */
2093 dif
= strcmp (np
->name
, cur_node
->name
);
2096 * If this tag name matches an existing one, then
2097 * do not add the node, but maybe print a warning.
2099 if (no_duplicates
&& !dif
)
2101 if (np
->fdp
== cur_node
->fdp
)
2105 fprintf (stderr
, "Duplicate entry in file %s, line %d: %s\n",
2106 np
->fdp
->infname
, lineno
, np
->name
);
2107 fprintf (stderr
, "Second entry ignored\n");
2110 else if (!cur_node
->been_warned
&& !no_warnings
)
2114 "Duplicate entry in files %s and %s: %s (Warning only)\n",
2115 np
->fdp
->infname
, cur_node
->fdp
->infname
, np
->name
);
2116 cur_node
->been_warned
= true;
2121 /* Actually add the node */
2122 add_node (np
, dif
< 0 ? &cur_node
->left
: &cur_node
->right
);
2123 } /* if CTAGS mode */
2127 * invalidate_nodes ()
2128 * Scan the node tree and invalidate all nodes pointing to the
2129 * given file description (CTAGS case) or free them (ETAGS case).
2132 invalidate_nodes (fdesc
*badfdp
, node
**npp
)
2141 if (np
->left
!= NULL
)
2142 invalidate_nodes (badfdp
, &np
->left
);
2143 if (np
->fdp
== badfdp
)
2145 if (np
->right
!= NULL
)
2146 invalidate_nodes (badfdp
, &np
->right
);
2150 assert (np
->fdp
!= NULL
);
2151 if (np
->fdp
== badfdp
)
2153 *npp
= np
->left
; /* detach the sublist from the list */
2154 np
->left
= NULL
; /* isolate it */
2155 free_tree (np
); /* free it */
2156 invalidate_nodes (badfdp
, npp
);
2159 invalidate_nodes (badfdp
, &np
->left
);
2164 static int total_size_of_entries (node
*);
2165 static int number_len (long) ATTRIBUTE_CONST
;
2167 /* Length of a non-negative number's decimal representation. */
2169 number_len (long int num
)
2172 while ((num
/= 10) > 0)
2178 * Return total number of characters that put_entries will output for
2179 * the nodes in the linked list at the right of the specified node.
2180 * This count is irrelevant with etags.el since emacs 19.34 at least,
2181 * but is still supplied for backward compatibility.
2184 total_size_of_entries (register node
*np
)
2186 register int total
= 0;
2188 for (; np
!= NULL
; np
= np
->right
)
2191 total
+= strlen (np
->regex
) + 1; /* pat\177 */
2192 if (np
->name
!= NULL
)
2193 total
+= strlen (np
->name
) + 1; /* name\001 */
2194 total
+= number_len ((long) np
->lno
) + 1; /* lno, */
2195 if (np
->cno
!= invalidcharno
) /* cno */
2196 total
+= number_len (np
->cno
);
2197 total
+= 1; /* newline */
2204 put_entries (register node
*np
)
2207 static fdesc
*fdp
= NULL
;
2212 /* Output subentries that precede this one */
2214 put_entries (np
->left
);
2216 /* Output this entry */
2225 fprintf (tagf
, "\f\n%s,%d\n",
2226 fdp
->taggedfname
, total_size_of_entries (np
));
2227 fdp
->written
= true;
2229 fputs (np
->regex
, tagf
);
2230 fputc ('\177', tagf
);
2231 if (np
->name
!= NULL
)
2233 fputs (np
->name
, tagf
);
2234 fputc ('\001', tagf
);
2236 fprintf (tagf
, "%d,", np
->lno
);
2237 if (np
->cno
!= invalidcharno
)
2238 fprintf (tagf
, "%ld", np
->cno
);
2244 if (np
->name
== NULL
)
2245 error ("internal error: NULL name in ctags mode.");
2250 fprintf (stdout
, "%s %s %d\n",
2251 np
->name
, np
->fdp
->taggedfname
, (np
->lno
+ 63) / 64);
2253 fprintf (stdout
, "%-16s %3d %-16s %s\n",
2254 np
->name
, np
->lno
, np
->fdp
->taggedfname
, np
->regex
);
2258 fprintf (tagf
, "%s\t%s\t", np
->name
, np
->fdp
->taggedfname
);
2261 { /* function or #define macro with args */
2262 putc (searchar
, tagf
);
2265 for (sp
= np
->regex
; *sp
; sp
++)
2267 if (*sp
== '\\' || *sp
== searchar
)
2271 putc (searchar
, tagf
);
2274 { /* anything else; text pattern inadequate */
2275 fprintf (tagf
, "%d", np
->lno
);
2280 } /* if this node contains a valid tag */
2282 /* Output subentries that follow this one */
2283 put_entries (np
->right
);
2285 put_entries (np
->left
);
2290 #define C_EXT 0x00fff /* C extensions */
2291 #define C_PLAIN 0x00000 /* C */
2292 #define C_PLPL 0x00001 /* C++ */
2293 #define C_STAR 0x00003 /* C* */
2294 #define C_JAVA 0x00005 /* JAVA */
2295 #define C_AUTO 0x01000 /* C, but switch to C++ if `class' is met */
2296 #define YACC 0x10000 /* yacc file */
2299 * The C symbol tables.
2304 st_C_objprot
, st_C_objimpl
, st_C_objend
,
2306 st_C_ignore
, st_C_attribute
,
2309 st_C_class
, st_C_template
,
2310 st_C_struct
, st_C_extern
, st_C_enum
, st_C_define
, st_C_typedef
2313 /* Feed stuff between (but not including) %[ and %] lines to:
2319 struct C_stab_entry { char *name; int c_ext; enum sym_type type; }
2323 while, 0, st_C_ignore
2324 switch, 0, st_C_ignore
2325 return, 0, st_C_ignore
2326 __attribute__, 0, st_C_attribute
2327 GTY, 0, st_C_attribute
2328 @interface, 0, st_C_objprot
2329 @protocol, 0, st_C_objprot
2330 @implementation,0, st_C_objimpl
2331 @end, 0, st_C_objend
2332 import, (C_JAVA & ~C_PLPL), st_C_ignore
2333 package, (C_JAVA & ~C_PLPL), st_C_ignore
2334 friend, C_PLPL, st_C_ignore
2335 extends, (C_JAVA & ~C_PLPL), st_C_javastruct
2336 implements, (C_JAVA & ~C_PLPL), st_C_javastruct
2337 interface, (C_JAVA & ~C_PLPL), st_C_struct
2338 class, 0, st_C_class
2339 namespace, C_PLPL, st_C_struct
2340 domain, C_STAR, st_C_struct
2341 union, 0, st_C_struct
2342 struct, 0, st_C_struct
2343 extern, 0, st_C_extern
2345 typedef, 0, st_C_typedef
2346 define, 0, st_C_define
2347 undef, 0, st_C_define
2348 operator, C_PLPL, st_C_operator
2349 template, 0, st_C_template
2350 # DEFUN used in emacs, the next three used in glibc (SYSCALL only for mach).
2351 DEFUN, 0, st_C_gnumacro
2352 SYSCALL, 0, st_C_gnumacro
2353 ENTRY, 0, st_C_gnumacro
2354 PSEUDO, 0, st_C_gnumacro
2355 # These are defined inside C functions, so currently they are not met.
2356 # EXFUN used in glibc, DEFVAR_* in emacs.
2357 #EXFUN, 0, st_C_gnumacro
2358 #DEFVAR_, 0, st_C_gnumacro
2360 and replace lines between %< and %> with its output, then:
2361 - remove the #if characterset check
2362 - make in_word_set static and not inline. */
2364 /* C code produced by gperf version 3.0.1 */
2365 /* Command-line: gperf -m 5 */
2366 /* Computed positions: -k'2-3' */
2368 struct C_stab_entry
{ const char *name
; int c_ext
; enum sym_type type
; };
2369 /* maximum key range = 33, duplicates = 0 */
2372 hash (const char *str
, int len
)
2374 static char const asso_values
[] =
2376 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2377 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2378 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2379 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2380 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2381 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2382 35, 35, 35, 35, 35, 35, 35, 35, 35, 3,
2383 26, 35, 35, 35, 35, 35, 35, 35, 27, 35,
2384 35, 35, 35, 24, 0, 35, 35, 35, 35, 0,
2385 35, 35, 35, 35, 35, 1, 35, 16, 35, 6,
2386 23, 0, 0, 35, 22, 0, 35, 35, 5, 0,
2387 0, 15, 1, 35, 6, 35, 8, 19, 35, 16,
2388 4, 5, 35, 35, 35, 35, 35, 35, 35, 35,
2389 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2390 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2391 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2392 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2393 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2394 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2395 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2396 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2397 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2398 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2399 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2400 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2401 35, 35, 35, 35, 35, 35
2408 hval
+= asso_values
[(unsigned char) str
[2]];
2411 hval
+= asso_values
[(unsigned char) str
[1]];
2417 static struct C_stab_entry
*
2418 in_word_set (register const char *str
, register unsigned int len
)
2422 TOTAL_KEYWORDS
= 33,
2423 MIN_WORD_LENGTH
= 2,
2424 MAX_WORD_LENGTH
= 15,
2429 static struct C_stab_entry wordlist
[] =
2432 {"if", 0, st_C_ignore
},
2433 {"GTY", 0, st_C_attribute
},
2434 {"@end", 0, st_C_objend
},
2435 {"union", 0, st_C_struct
},
2436 {"define", 0, st_C_define
},
2437 {"import", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2438 {"template", 0, st_C_template
},
2439 {"operator", C_PLPL
, st_C_operator
},
2440 {"@interface", 0, st_C_objprot
},
2441 {"implements", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2442 {"friend", C_PLPL
, st_C_ignore
},
2443 {"typedef", 0, st_C_typedef
},
2444 {"return", 0, st_C_ignore
},
2445 {"@implementation",0, st_C_objimpl
},
2446 {"@protocol", 0, st_C_objprot
},
2447 {"interface", (C_JAVA
& ~C_PLPL
), st_C_struct
},
2448 {"extern", 0, st_C_extern
},
2449 {"extends", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2450 {"struct", 0, st_C_struct
},
2451 {"domain", C_STAR
, st_C_struct
},
2452 {"switch", 0, st_C_ignore
},
2453 {"enum", 0, st_C_enum
},
2454 {"for", 0, st_C_ignore
},
2455 {"namespace", C_PLPL
, st_C_struct
},
2456 {"class", 0, st_C_class
},
2457 {"while", 0, st_C_ignore
},
2458 {"undef", 0, st_C_define
},
2459 {"package", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2460 {"__attribute__", 0, st_C_attribute
},
2461 {"SYSCALL", 0, st_C_gnumacro
},
2462 {"ENTRY", 0, st_C_gnumacro
},
2463 {"PSEUDO", 0, st_C_gnumacro
},
2464 {"DEFUN", 0, st_C_gnumacro
}
2467 if (len
<= MAX_WORD_LENGTH
&& len
>= MIN_WORD_LENGTH
)
2469 int key
= hash (str
, len
);
2471 if (key
<= MAX_HASH_VALUE
&& key
>= 0)
2473 const char *s
= wordlist
[key
].name
;
2475 if (*str
== *s
&& !strncmp (str
+ 1, s
+ 1, len
- 1) && s
[len
] == '\0')
2476 return &wordlist
[key
];
2483 static enum sym_type
2484 C_symtype (char *str
, int len
, int c_ext
)
2486 register struct C_stab_entry
*se
= in_word_set (str
, len
);
2488 if (se
== NULL
|| (se
->c_ext
&& !(c_ext
& se
->c_ext
)))
2495 * Ignoring __attribute__ ((list))
2497 static bool inattribute
; /* looking at an __attribute__ construct */
2500 * C functions and variables are recognized using a simple
2501 * finite automaton. fvdef is its state variable.
2505 fvnone
, /* nothing seen */
2506 fdefunkey
, /* Emacs DEFUN keyword seen */
2507 fdefunname
, /* Emacs DEFUN name seen */
2508 foperator
, /* func: operator keyword seen (cplpl) */
2509 fvnameseen
, /* function or variable name seen */
2510 fstartlist
, /* func: just after open parenthesis */
2511 finlist
, /* func: in parameter list */
2512 flistseen
, /* func: after parameter list */
2513 fignore
, /* func: before open brace */
2514 vignore
/* var-like: ignore until ';' */
2517 static bool fvextern
; /* func or var: extern keyword seen; */
2520 * typedefs are recognized using a simple finite automaton.
2521 * typdef is its state variable.
2525 tnone
, /* nothing seen */
2526 tkeyseen
, /* typedef keyword seen */
2527 ttypeseen
, /* defined type seen */
2528 tinbody
, /* inside typedef body */
2529 tend
, /* just before typedef tag */
2530 tignore
/* junk after typedef tag */
2534 * struct-like structures (enum, struct and union) are recognized
2535 * using another simple finite automaton. `structdef' is its state
2540 snone
, /* nothing seen yet,
2541 or in struct body if bracelev > 0 */
2542 skeyseen
, /* struct-like keyword seen */
2543 stagseen
, /* struct-like tag seen */
2544 scolonseen
/* colon seen after struct-like tag */
2548 * When objdef is different from onone, objtag is the name of the class.
2550 static const char *objtag
= "<uninited>";
2553 * Yet another little state machine to deal with preprocessor lines.
2557 dnone
, /* nothing seen */
2558 dsharpseen
, /* '#' seen as first char on line */
2559 ddefineseen
, /* '#' and 'define' seen */
2560 dignorerest
/* ignore rest of line */
2564 * State machine for Objective C protocols and implementations.
2565 * Idea by Tom R.Hageman <tom@basil.icce.rug.nl> (1995)
2569 onone
, /* nothing seen */
2570 oprotocol
, /* @interface or @protocol seen */
2571 oimplementation
, /* @implementations seen */
2572 otagseen
, /* class name seen */
2573 oparenseen
, /* parenthesis before category seen */
2574 ocatseen
, /* category name seen */
2575 oinbody
, /* in @implementation body */
2576 omethodsign
, /* in @implementation body, after +/- */
2577 omethodtag
, /* after method name */
2578 omethodcolon
, /* after method colon */
2579 omethodparm
, /* after method parameter */
2580 oignore
/* wait for @end */
2585 * Use this structure to keep info about the token read, and how it
2586 * should be tagged. Used by the make_C_tag function to build a tag.
2590 char *line
; /* string containing the token */
2591 int offset
; /* where the token starts in LINE */
2592 int length
; /* token length */
2594 The previous members can be used to pass strings around for generic
2595 purposes. The following ones specifically refer to creating tags. In this
2596 case the token contained here is the pattern that will be used to create a
2599 bool valid
; /* do not create a tag; the token should be
2600 invalidated whenever a state machine is
2601 reset prematurely */
2602 bool named
; /* create a named tag */
2603 int lineno
; /* source line number of tag */
2604 long linepos
; /* source char number of tag */
2605 } token
; /* latest token read */
2608 * Variables and functions for dealing with nested structures.
2609 * Idea by Mykola Dzyuba <mdzyuba@yahoo.com> (2001)
2611 static void pushclass_above (int, char *, int);
2612 static void popclass_above (int);
2613 static void write_classname (linebuffer
*, const char *qualifier
);
2616 char **cname
; /* nested class names */
2617 int *bracelev
; /* nested class brace level */
2618 int nl
; /* class nesting level (elements used) */
2619 int size
; /* length of the array */
2620 } cstack
; /* stack for nested declaration tags */
2621 /* Current struct nesting depth (namespace, class, struct, union, enum). */
2622 #define nestlev (cstack.nl)
2623 /* After struct keyword or in struct body, not inside a nested function. */
2624 #define instruct (structdef == snone && nestlev > 0 \
2625 && bracelev == cstack.bracelev[nestlev-1] + 1)
2628 pushclass_above (int bracelev
, char *str
, int len
)
2632 popclass_above (bracelev
);
2634 if (nl
>= cstack
.size
)
2636 int size
= cstack
.size
*= 2;
2637 xrnew (cstack
.cname
, size
, char *);
2638 xrnew (cstack
.bracelev
, size
, int);
2640 assert (nl
== 0 || cstack
.bracelev
[nl
-1] < bracelev
);
2641 cstack
.cname
[nl
] = (str
== NULL
) ? NULL
: savenstr (str
, len
);
2642 cstack
.bracelev
[nl
] = bracelev
;
2647 popclass_above (int bracelev
)
2651 for (nl
= cstack
.nl
- 1;
2652 nl
>= 0 && cstack
.bracelev
[nl
] >= bracelev
;
2655 free (cstack
.cname
[nl
]);
2661 write_classname (linebuffer
*cn
, const char *qualifier
)
2664 int qlen
= strlen (qualifier
);
2666 if (cstack
.nl
== 0 || cstack
.cname
[0] == NULL
)
2670 cn
->buffer
[0] = '\0';
2674 len
= strlen (cstack
.cname
[0]);
2675 linebuffer_setlen (cn
, len
);
2676 strcpy (cn
->buffer
, cstack
.cname
[0]);
2678 for (i
= 1; i
< cstack
.nl
; i
++)
2680 char *s
= cstack
.cname
[i
];
2683 linebuffer_setlen (cn
, len
+ qlen
+ strlen (s
));
2684 len
+= sprintf (cn
->buffer
+ len
, "%s%s", qualifier
, s
);
2689 static bool consider_token (char *, int, int, int *, int, int, bool *);
2690 static void make_C_tag (bool);
2694 * checks to see if the current token is at the start of a
2695 * function or variable, or corresponds to a typedef, or
2696 * is a struct/union/enum tag, or #define, or an enum constant.
2698 * *IS_FUNC_OR_VAR gets true if the token is a function or #define macro
2699 * with args. C_EXTP points to which language we are looking at.
2710 consider_token (char *str
, int len
, int c
, int *c_extp
,
2711 int bracelev
, int parlev
, bool *is_func_or_var
)
2712 /* IN: token pointer */
2713 /* IN: token length */
2714 /* IN: first char after the token */
2715 /* IN, OUT: C extensions mask */
2716 /* IN: brace level */
2717 /* IN: parenthesis level */
2718 /* OUT: function or variable found */
2720 /* When structdef is stagseen, scolonseen, or snone with bracelev > 0,
2721 structtype is the type of the preceding struct-like keyword, and
2722 structbracelev is the brace level where it has been seen. */
2723 static enum sym_type structtype
;
2724 static int structbracelev
;
2725 static enum sym_type toktype
;
2728 toktype
= C_symtype (str
, len
, *c_extp
);
2731 * Skip __attribute__
2733 if (toktype
== st_C_attribute
)
2740 * Advance the definedef state machine.
2745 /* We're not on a preprocessor line. */
2746 if (toktype
== st_C_gnumacro
)
2753 if (toktype
== st_C_define
)
2755 definedef
= ddefineseen
;
2759 definedef
= dignorerest
;
2764 * Make a tag for any macro, unless it is a constant
2765 * and constantypedefs is false.
2767 definedef
= dignorerest
;
2768 *is_func_or_var
= (c
== '(');
2769 if (!*is_func_or_var
&& !constantypedefs
)
2776 error ("internal error: definedef value.");
2785 if (toktype
== st_C_typedef
)
2808 if (structdef
== snone
&& fvdef
== fvnone
)
2830 case st_C_javastruct
:
2831 if (structdef
== stagseen
)
2832 structdef
= scolonseen
;
2836 if ((*c_extp
& C_AUTO
) /* automatic detection of C++ language */
2838 && definedef
== dnone
&& structdef
== snone
2839 && typdef
== tnone
&& fvdef
== fvnone
)
2840 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
2841 if (toktype
== st_C_template
)
2848 && (typdef
== tkeyseen
2849 || (typedefs_or_cplusplus
&& structdef
== snone
)))
2851 structdef
= skeyseen
;
2852 structtype
= toktype
;
2853 structbracelev
= bracelev
;
2854 if (fvdef
== fvnameseen
)
2862 if (structdef
== skeyseen
)
2864 structdef
= stagseen
;
2868 if (typdef
!= tnone
)
2871 /* Detect Objective C constructs. */
2881 objdef
= oimplementation
;
2887 case oimplementation
:
2888 /* Save the class tag for functions or variables defined inside. */
2889 objtag
= savenstr (str
, len
);
2893 /* Save the class tag for categories. */
2894 objtag
= savenstr (str
, len
);
2896 *is_func_or_var
= true;
2900 *is_func_or_var
= true;
2908 objdef
= omethodtag
;
2909 linebuffer_setlen (&token_name
, len
);
2910 memcpy (token_name
.buffer
, str
, len
);
2911 token_name
.buffer
[len
] = '\0';
2917 objdef
= omethodparm
;
2922 objdef
= omethodtag
;
2925 int oldlen
= token_name
.len
;
2927 linebuffer_setlen (&token_name
, oldlen
+ len
);
2928 memcpy (token_name
.buffer
+ oldlen
, str
, len
);
2929 token_name
.buffer
[oldlen
+ len
] = '\0';
2935 if (toktype
== st_C_objend
)
2937 /* Memory leakage here: the string pointed by objtag is
2938 never released, because many tests would be needed to
2939 avoid breaking on incorrect input code. The amount of
2940 memory leaked here is the sum of the lengths of the
2950 /* A function, variable or enum constant? */
2972 *is_func_or_var
= true;
2976 && structdef
== snone
2977 && structtype
== st_C_enum
&& bracelev
> structbracelev
2978 /* Don't tag tokens in expressions that assign values to enum
2980 && fvdef
!= vignore
)
2981 return true; /* enum constant */
2987 fvdef
= fdefunname
; /* GNU macro */
2988 *is_func_or_var
= true;
2996 if ((strneq (str
, "asm", 3) && endtoken (str
[3]))
2997 || (strneq (str
, "__asm__", 7) && endtoken (str
[7])))
3008 if (len
>= 10 && strneq (str
+len
-10, "::operator", 10))
3010 if (*c_extp
& C_AUTO
) /* automatic detection of C++ */
3011 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
3013 *is_func_or_var
= true;
3016 if (bracelev
> 0 && !instruct
)
3018 fvdef
= fvnameseen
; /* function or variable */
3019 *is_func_or_var
= true;
3034 * C_entries often keeps pointers to tokens or lines which are older than
3035 * the line currently read. By keeping two line buffers, and switching
3036 * them at end of line, it is possible to use those pointers.
3044 #define current_lb_is_new (newndx == curndx)
3045 #define switch_line_buffers() (curndx = 1 - curndx)
3047 #define curlb (lbs[curndx].lb)
3048 #define newlb (lbs[newndx].lb)
3049 #define curlinepos (lbs[curndx].linepos)
3050 #define newlinepos (lbs[newndx].linepos)
3052 #define plainc ((c_ext & C_EXT) == C_PLAIN)
3053 #define cplpl (c_ext & C_PLPL)
3054 #define cjava ((c_ext & C_JAVA) == C_JAVA)
3056 #define CNL_SAVE_DEFINEDEF() \
3058 curlinepos = charno; \
3059 readline (&curlb, inf); \
3060 lp = curlb.buffer; \
3067 CNL_SAVE_DEFINEDEF (); \
3068 if (savetoken.valid) \
3070 token = savetoken; \
3071 savetoken.valid = false; \
3073 definedef = dnone; \
3078 make_C_tag (bool isfun
)
3080 /* This function is never called when token.valid is false, but
3081 we must protect against invalid input or internal errors. */
3083 make_tag (token_name
.buffer
, token_name
.len
, isfun
, token
.line
,
3084 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3086 { /* this branch is optimized away if !DEBUG */
3087 make_tag (concat ("INVALID TOKEN:-->", token_name
.buffer
, ""),
3088 token_name
.len
+ 17, isfun
, token
.line
,
3089 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3090 error ("INVALID TOKEN");
3093 token
.valid
= false;
3097 perhaps_more_input (FILE *inf
)
3099 return !feof (inf
) && !ferror (inf
);
3105 * This routine finds functions, variables, typedefs,
3106 * #define's, enum constants and struct/union/enum definitions in
3107 * C syntax and adds them to the list.
3110 C_entries (int c_ext
, FILE *inf
)
3111 /* extension of C */
3114 register char c
; /* latest char read; '\0' for end of line */
3115 register char *lp
; /* pointer one beyond the character `c' */
3116 int curndx
, newndx
; /* indices for current and new lb */
3117 register int tokoff
; /* offset in line of start of current token */
3118 register int toklen
; /* length of current token */
3119 const char *qualifier
; /* string used to qualify names */
3120 int qlen
; /* length of qualifier */
3121 int bracelev
; /* current brace level */
3122 int bracketlev
; /* current bracket level */
3123 int parlev
; /* current parenthesis level */
3124 int attrparlev
; /* __attribute__ parenthesis level */
3125 int templatelev
; /* current template level */
3126 int typdefbracelev
; /* bracelev where a typedef struct body begun */
3127 bool incomm
, inquote
, inchar
, quotednl
, midtoken
;
3128 bool yacc_rules
; /* in the rules part of a yacc file */
3129 struct tok savetoken
= {0}; /* token saved during preprocessor handling */
3132 linebuffer_init (&lbs
[0].lb
);
3133 linebuffer_init (&lbs
[1].lb
);
3134 if (cstack
.size
== 0)
3136 cstack
.size
= (DEBUG
) ? 1 : 4;
3138 cstack
.cname
= xnew (cstack
.size
, char *);
3139 cstack
.bracelev
= xnew (cstack
.size
, int);
3142 tokoff
= toklen
= typdefbracelev
= 0; /* keep compiler quiet */
3143 curndx
= newndx
= 0;
3147 fvdef
= fvnone
; fvextern
= false; typdef
= tnone
;
3148 structdef
= snone
; definedef
= dnone
; objdef
= onone
;
3150 midtoken
= inquote
= inchar
= incomm
= quotednl
= false;
3151 token
.valid
= savetoken
.valid
= false;
3152 bracelev
= bracketlev
= parlev
= attrparlev
= templatelev
= 0;
3154 { qualifier
= "."; qlen
= 1; }
3156 { qualifier
= "::"; qlen
= 2; }
3159 while (perhaps_more_input (inf
))
3164 /* If we are at the end of the line, the next character is a
3165 '\0'; do not skip it, because it is what tells us
3166 to read the next line. */
3187 /* Newlines inside comments do not end macro definitions in
3189 CNL_SAVE_DEFINEDEF ();
3202 /* Newlines inside strings do not end macro definitions
3203 in traditional cpp, even though compilers don't
3204 usually accept them. */
3205 CNL_SAVE_DEFINEDEF ();
3215 /* Hmmm, something went wrong. */
3251 if (fvdef
!= finlist
&& fvdef
!= fignore
&& fvdef
!= vignore
)
3266 else if (/* cplpl && */ *lp
== '/')
3272 if ((c_ext
& YACC
) && *lp
== '%')
3274 /* Entering or exiting rules section in yacc file. */
3276 definedef
= dnone
; fvdef
= fvnone
; fvextern
= false;
3277 typdef
= tnone
; structdef
= snone
;
3278 midtoken
= inquote
= inchar
= incomm
= quotednl
= false;
3280 yacc_rules
= !yacc_rules
;
3286 if (definedef
== dnone
)
3289 bool cpptoken
= true;
3291 /* Look back on this line. If all blanks, or nonblanks
3292 followed by an end of comment, this is a preprocessor
3294 for (cp
= newlb
.buffer
; cp
< lp
-1; cp
++)
3295 if (!c_isspace (*cp
))
3297 if (*cp
== '*' && cp
[1] == '/')
3307 definedef
= dsharpseen
;
3308 /* This is needed for tagging enum values: when there are
3309 preprocessor conditionals inside the enum, we need to
3310 reset the value of fvdef so that the next enum value is
3311 tagged even though the one before it did not end in a
3313 if (fvdef
== vignore
&& instruct
&& parlev
== 0)
3315 if (strneq (cp
, "#if", 3) || strneq (cp
, "#el", 3))
3319 } /* if (definedef == dnone) */
3330 CNL_SAVE_DEFINEDEF ();
3337 /* Consider token only if some involved conditions are satisfied. */
3338 if (typdef
!= tignore
3339 && definedef
!= dignorerest
3342 && (definedef
!= dnone
3343 || structdef
!= scolonseen
)
3350 if (c
== ':' && *lp
== ':' && begtoken (lp
[1]))
3351 /* This handles :: in the middle,
3352 but not at the beginning of an identifier.
3353 Also, space-separated :: is not recognized. */
3355 if (c_ext
& C_AUTO
) /* automatic detection of C++ */
3356 c_ext
= (c_ext
| C_PLPL
) & ~C_AUTO
;
3360 goto still_in_token
;
3364 bool funorvar
= false;
3367 || consider_token (newlb
.buffer
+ tokoff
, toklen
, c
,
3368 &c_ext
, bracelev
, parlev
,
3371 if (fvdef
== foperator
)
3374 lp
= skip_spaces (lp
-1);
3378 && !c_isspace (*lp
) && *lp
!= '(')
3381 toklen
+= lp
- oldlp
;
3383 token
.named
= false;
3385 && nestlev
> 0 && definedef
== dnone
)
3386 /* in struct body */
3391 write_classname (&token_name
, qualifier
);
3392 len
= token_name
.len
;
3393 linebuffer_setlen (&token_name
,
3394 len
+ qlen
+ toklen
);
3395 sprintf (token_name
.buffer
+ len
, "%s%.*s",
3397 newlb
.buffer
+ tokoff
);
3401 linebuffer_setlen (&token_name
, toklen
);
3402 sprintf (token_name
.buffer
, "%.*s",
3403 toklen
, newlb
.buffer
+ tokoff
);
3407 else if (objdef
== ocatseen
)
3408 /* Objective C category */
3412 int len
= strlen (objtag
) + 2 + toklen
;
3413 linebuffer_setlen (&token_name
, len
);
3414 sprintf (token_name
.buffer
, "%s(%.*s)",
3416 newlb
.buffer
+ tokoff
);
3420 linebuffer_setlen (&token_name
, toklen
);
3421 sprintf (token_name
.buffer
, "%.*s",
3422 toklen
, newlb
.buffer
+ tokoff
);
3426 else if (objdef
== omethodtag
3427 || objdef
== omethodparm
)
3428 /* Objective C method */
3432 else if (fvdef
== fdefunname
)
3433 /* GNU DEFUN and similar macros */
3435 bool defun
= (newlb
.buffer
[tokoff
] == 'F');
3439 /* Rewrite the tag so that emacs lisp DEFUNs
3440 can be found by their elisp name */
3446 linebuffer_setlen (&token_name
, len
);
3447 memcpy (token_name
.buffer
,
3448 newlb
.buffer
+ off
, len
);
3449 token_name
.buffer
[len
] = '\0';
3452 if (token_name
.buffer
[len
] == '_')
3453 token_name
.buffer
[len
] = '-';
3454 token
.named
= defun
;
3458 linebuffer_setlen (&token_name
, toklen
);
3459 memcpy (token_name
.buffer
,
3460 newlb
.buffer
+ tokoff
, toklen
);
3461 token_name
.buffer
[toklen
] = '\0';
3462 /* Name macros and members. */
3463 token
.named
= (structdef
== stagseen
3464 || typdef
== ttypeseen
3467 && definedef
== dignorerest
)
3469 && definedef
== dnone
3470 && structdef
== snone
3473 token
.lineno
= lineno
;
3474 token
.offset
= tokoff
;
3475 token
.length
= toklen
;
3476 token
.line
= newlb
.buffer
;
3477 token
.linepos
= newlinepos
;
3480 if (definedef
== dnone
3481 && (fvdef
== fvnameseen
3482 || fvdef
== foperator
3483 || structdef
== stagseen
3485 || typdef
== ttypeseen
3486 || objdef
!= onone
))
3488 if (current_lb_is_new
)
3489 switch_line_buffers ();
3491 else if (definedef
!= dnone
3492 || fvdef
== fdefunname
3494 make_C_tag (funorvar
);
3496 else /* not yacc and consider_token failed */
3498 if (inattribute
&& fvdef
== fignore
)
3500 /* We have just met __attribute__ after a
3501 function parameter list: do not tag the
3508 } /* if (endtoken (c)) */
3509 else if (intoken (c
))
3515 } /* if (midtoken) */
3516 else if (begtoken (c
))
3524 /* This prevents tagging fb in
3525 void (__attribute__((noreturn)) *fb) (void);
3526 Fixing this is not easy and not very important. */
3530 if (plainc
|| declarations
)
3532 make_C_tag (true); /* a function */
3539 if (structdef
== stagseen
&& !cjava
)
3541 popclass_above (bracelev
);
3551 if (!yacc_rules
|| lp
== newlb
.buffer
+ 1)
3553 tokoff
= lp
- 1 - newlb
.buffer
;
3558 } /* if (begtoken) */
3559 } /* if must look at token */
3562 /* Detect end of line, colon, comma, semicolon and various braces
3563 after having handled a token.*/
3569 if (yacc_rules
&& token
.offset
== 0 && token
.valid
)
3571 make_C_tag (false); /* a yacc function */
3574 if (definedef
!= dnone
)
3580 make_C_tag (true); /* an Objective C class */
3584 objdef
= omethodcolon
;
3587 int toklen
= token_name
.len
;
3588 linebuffer_setlen (&token_name
, toklen
+ 1);
3589 strcpy (token_name
.buffer
+ toklen
, ":");
3595 if (structdef
== stagseen
)
3597 structdef
= scolonseen
;
3600 /* Should be useless, but may be work as a safety net. */
3601 if (cplpl
&& fvdef
== flistseen
)
3603 make_C_tag (true); /* a function */
3609 if (definedef
!= dnone
|| inattribute
)
3615 make_C_tag (false); /* a typedef */
3625 if (typdef
== tignore
|| cplpl
)
3629 if ((globals
&& bracelev
== 0 && (!fvextern
|| declarations
))
3630 || (members
&& instruct
))
3631 make_C_tag (false); /* a variable */
3634 token
.valid
= false;
3638 && (cplpl
|| !instruct
)
3639 && (typdef
== tnone
|| (typdef
!= tignore
&& instruct
)))
3641 && plainc
&& instruct
))
3642 make_C_tag (true); /* a function */
3648 && cplpl
&& structdef
== stagseen
)
3649 make_C_tag (false); /* forward declaration */
3651 token
.valid
= false;
3652 } /* switch (fvdef) */
3658 if (structdef
== stagseen
)
3662 if (definedef
!= dnone
|| inattribute
)
3668 make_C_tag (true); /* an Objective C method */
3683 if (instruct
&& parlev
== 0)
3694 && (!fvextern
|| declarations
))
3695 || (members
&& instruct
)))
3696 make_C_tag (false); /* a variable */
3699 if ((declarations
&& typdef
== tnone
&& !instruct
)
3700 || (members
&& typdef
!= tignore
&& instruct
))
3702 make_C_tag (true); /* a function */
3705 else if (!declarations
)
3707 token
.valid
= false;
3712 if (structdef
== stagseen
)
3716 if (definedef
!= dnone
|| inattribute
)
3718 if (structdef
== stagseen
)
3725 make_C_tag (false); /* a typedef */
3737 if ((members
&& bracelev
== 1)
3738 || (globals
&& bracelev
== 0
3739 && (!fvextern
|| declarations
)))
3740 make_C_tag (false); /* a variable */
3756 if (definedef
!= dnone
)
3758 if (objdef
== otagseen
&& parlev
== 0)
3759 objdef
= oparenseen
;
3763 if (typdef
== ttypeseen
3767 /* This handles constructs like:
3768 typedef void OperatorFun (int fun); */
3789 if (--attrparlev
== 0)
3790 inattribute
= false;
3793 if (definedef
!= dnone
)
3795 if (objdef
== ocatseen
&& parlev
== 1)
3797 make_C_tag (true); /* an Objective C category */
3813 || typdef
== ttypeseen
))
3816 make_C_tag (false); /* a typedef */
3819 else if (parlev
< 0) /* can happen due to ill-conceived #if's. */
3823 if (definedef
!= dnone
)
3825 if (typdef
== ttypeseen
)
3827 /* Whenever typdef is set to tinbody (currently only
3828 here), typdefbracelev should be set to bracelev. */
3830 typdefbracelev
= bracelev
;
3835 if (cplpl
&& !class_qualify
)
3837 /* Remove class and namespace qualifiers from the token,
3838 leaving only the method/member name. */
3839 char *cc
, *uqname
= token_name
.buffer
;
3840 char *tok_end
= token_name
.buffer
+ token_name
.len
;
3842 for (cc
= token_name
.buffer
; cc
< tok_end
; cc
++)
3844 if (*cc
== ':' && cc
[1] == ':')
3850 if (uqname
> token_name
.buffer
)
3852 int uqlen
= strlen (uqname
);
3853 linebuffer_setlen (&token_name
, uqlen
);
3854 memmove (token_name
.buffer
, uqname
, uqlen
+ 1);
3857 make_C_tag (true); /* a function */
3866 make_C_tag (true); /* an Objective C class */
3871 make_C_tag (true); /* an Objective C method */
3875 /* Neutralize `extern "C" {' grot. */
3876 if (bracelev
== 0 && structdef
== snone
&& nestlev
== 0
3886 case skeyseen
: /* unnamed struct */
3887 pushclass_above (bracelev
, NULL
, 0);
3890 case stagseen
: /* named struct or enum */
3891 case scolonseen
: /* a class */
3892 pushclass_above (bracelev
,token
.line
+token
.offset
, token
.length
);
3894 make_C_tag (false); /* a struct or enum */
3902 if (definedef
!= dnone
)
3904 if (fvdef
== fstartlist
)
3906 fvdef
= fvnone
; /* avoid tagging `foo' in `foo (*bar()) ()' */
3907 token
.valid
= false;
3911 if (definedef
!= dnone
)
3914 if (!ignoreindent
&& lp
== newlb
.buffer
+ 1)
3917 token
.valid
= false; /* unexpected value, token unreliable */
3918 bracelev
= 0; /* reset brace level if first column */
3919 parlev
= 0; /* also reset paren level, just in case... */
3921 else if (bracelev
< 0)
3923 token
.valid
= false; /* something gone amiss, token unreliable */
3926 if (bracelev
== 0 && fvdef
== vignore
)
3927 fvdef
= fvnone
; /* end of function */
3928 popclass_above (bracelev
);
3930 /* Only if typdef == tinbody is typdefbracelev significant. */
3931 if (typdef
== tinbody
&& bracelev
<= typdefbracelev
)
3933 assert (bracelev
== typdefbracelev
);
3938 if (definedef
!= dnone
)
3948 if ((members
&& bracelev
== 1)
3949 || (globals
&& bracelev
== 0 && (!fvextern
|| declarations
)))
3950 make_C_tag (false); /* a variable */
3958 && (structdef
== stagseen
|| fvdef
== fvnameseen
))
3965 if (templatelev
> 0)
3973 if (objdef
== oinbody
&& bracelev
== 0)
3975 objdef
= omethodsign
;
3980 case '#': case '~': case '&': case '%': case '/':
3981 case '|': case '^': case '!': case '.': case '?':
3982 if (definedef
!= dnone
)
3984 /* These surely cannot follow a function tag in C. */
3997 if (objdef
== otagseen
)
3999 make_C_tag (true); /* an Objective C class */
4002 /* If a macro spans multiple lines don't reset its state. */
4004 CNL_SAVE_DEFINEDEF ();
4010 } /* while not eof */
4012 free (lbs
[0].lb
.buffer
);
4013 free (lbs
[1].lb
.buffer
);
4017 * Process either a C++ file or a C file depending on the setting
4021 default_C_entries (FILE *inf
)
4023 C_entries (cplusplus
? C_PLPL
: C_AUTO
, inf
);
4026 /* Always do plain C. */
4028 plain_C_entries (FILE *inf
)
4033 /* Always do C++. */
4035 Cplusplus_entries (FILE *inf
)
4037 C_entries (C_PLPL
, inf
);
4040 /* Always do Java. */
4042 Cjava_entries (FILE *inf
)
4044 C_entries (C_JAVA
, inf
);
4049 Cstar_entries (FILE *inf
)
4051 C_entries (C_STAR
, inf
);
4054 /* Always do Yacc. */
4056 Yacc_entries (FILE *inf
)
4058 C_entries (YACC
, inf
);
4062 /* Useful macros. */
4063 #define LOOP_ON_INPUT_LINES(file_pointer, line_buffer, char_pointer) \
4064 while (perhaps_more_input (file_pointer) \
4065 && (readline (&(line_buffer), file_pointer), \
4066 (char_pointer) = (line_buffer).buffer, \
4069 #define LOOKING_AT(cp, kw) /* kw is the keyword, a literal string */ \
4070 ((assert ("" kw), true) /* syntax error if not a literal string */ \
4071 && strneq ((cp), kw, sizeof (kw)-1) /* cp points at kw */ \
4072 && notinname ((cp)[sizeof (kw)-1]) /* end of kw */ \
4073 && ((cp) = skip_spaces ((cp)+sizeof (kw)-1))) /* skip spaces */
4075 /* Similar to LOOKING_AT but does not use notinname, does not skip */
4076 #define LOOKING_AT_NOCASE(cp, kw) /* the keyword is a literal string */ \
4077 ((assert ("" kw), true) /* syntax error if not a literal string */ \
4078 && strncaseeq ((cp), kw, sizeof (kw)-1) /* cp points at kw */ \
4079 && ((cp) += sizeof (kw)-1)) /* skip spaces */
4082 * Read a file, but do no processing. This is used to do regexp
4083 * matching on files that have no language defined.
4086 just_read_file (FILE *inf
)
4088 while (perhaps_more_input (inf
))
4089 readline (&lb
, inf
);
4093 /* Fortran parsing */
4095 static void F_takeprec (void);
4096 static void F_getit (FILE *);
4101 dbp
= skip_spaces (dbp
);
4105 dbp
= skip_spaces (dbp
);
4106 if (strneq (dbp
, "(*)", 3))
4111 if (!c_isdigit (*dbp
))
4113 --dbp
; /* force failure */
4118 while (c_isdigit (*dbp
));
4126 dbp
= skip_spaces (dbp
);
4129 readline (&lb
, inf
);
4134 dbp
= skip_spaces (dbp
);
4136 if (!c_isalpha (*dbp
) && *dbp
!= '_' && *dbp
!= '$')
4138 for (cp
= dbp
+ 1; *cp
!= '\0' && intoken (*cp
); cp
++)
4140 make_tag (dbp
, cp
-dbp
, true,
4141 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4146 Fortran_functions (FILE *inf
)
4148 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4151 dbp
++; /* Ratfor escape to fortran */
4152 dbp
= skip_spaces (dbp
);
4156 if (LOOKING_AT_NOCASE (dbp
, "recursive"))
4157 dbp
= skip_spaces (dbp
);
4159 if (LOOKING_AT_NOCASE (dbp
, "pure"))
4160 dbp
= skip_spaces (dbp
);
4162 if (LOOKING_AT_NOCASE (dbp
, "elemental"))
4163 dbp
= skip_spaces (dbp
);
4165 switch (c_tolower (*dbp
))
4168 if (nocase_tail ("integer"))
4172 if (nocase_tail ("real"))
4176 if (nocase_tail ("logical"))
4180 if (nocase_tail ("complex") || nocase_tail ("character"))
4184 if (nocase_tail ("double"))
4186 dbp
= skip_spaces (dbp
);
4189 if (nocase_tail ("precision"))
4195 dbp
= skip_spaces (dbp
);
4198 switch (c_tolower (*dbp
))
4201 if (nocase_tail ("function"))
4205 if (nocase_tail ("subroutine"))
4209 if (nocase_tail ("entry"))
4213 if (nocase_tail ("blockdata") || nocase_tail ("block data"))
4215 dbp
= skip_spaces (dbp
);
4216 if (*dbp
== '\0') /* assume un-named */
4217 make_tag ("blockdata", 9, true,
4218 lb
.buffer
, dbp
- lb
.buffer
, lineno
, linecharno
);
4220 F_getit (inf
); /* look for name */
4229 * Go language support
4230 * Original code by Xi Lu <lx@shellcodes.org> (2016)
4233 Go_functions(FILE *inf
)
4237 LOOP_ON_INPUT_LINES(inf
, lb
, cp
)
4239 cp
= skip_spaces (cp
);
4241 if (LOOKING_AT (cp
, "package"))
4244 while (!notinname (*cp
) && *cp
!= '\0')
4246 make_tag (name
, cp
- name
, false, lb
.buffer
,
4247 cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4249 else if (LOOKING_AT (cp
, "func"))
4251 /* Go implementation of interface, such as:
4252 func (n *Integer) Add(m Integer) ...
4253 skip `(n *Integer)` part.
4259 cp
= skip_spaces (cp
+1);
4266 while (!notinname (*cp
))
4269 make_tag (name
, cp
- name
, true, lb
.buffer
,
4270 cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4273 else if (members
&& LOOKING_AT (cp
, "type"))
4277 /* Ignore the likes of the following:
4285 while (!notinname (*cp
) && *cp
!= '\0')
4288 make_tag (name
, cp
- name
, false, lb
.buffer
,
4289 cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4298 * Philippe Waroquiers (1998)
4301 /* Once we are positioned after an "interesting" keyword, let's get
4302 the real tag value necessary. */
4304 Ada_getit (FILE *inf
, const char *name_qualifier
)
4310 while (perhaps_more_input (inf
))
4312 dbp
= skip_spaces (dbp
);
4314 || (dbp
[0] == '-' && dbp
[1] == '-'))
4316 readline (&lb
, inf
);
4319 switch (c_tolower (*dbp
))
4322 if (nocase_tail ("body"))
4324 /* Skipping body of procedure body or package body or ....
4325 resetting qualifier to body instead of spec. */
4326 name_qualifier
= "/b";
4331 /* Skipping type of task type or protected type ... */
4332 if (nocase_tail ("type"))
4339 for (cp
= dbp
; *cp
!= '\0' && *cp
!= '"'; cp
++)
4344 dbp
= skip_spaces (dbp
);
4346 c_isalnum (*cp
) || *cp
== '_' || *cp
== '.';
4354 name
= concat (dbp
, name_qualifier
, "");
4356 make_tag (name
, strlen (name
), true,
4357 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4366 Ada_funcs (FILE *inf
)
4368 bool inquote
= false;
4369 bool skip_till_semicolumn
= false;
4371 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4373 while (*dbp
!= '\0')
4375 /* Skip a string i.e. "abcd". */
4376 if (inquote
|| (*dbp
== '"'))
4378 dbp
= strchr (dbp
+ !inquote
, '"');
4383 continue; /* advance char */
4388 break; /* advance line */
4392 /* Skip comments. */
4393 if (dbp
[0] == '-' && dbp
[1] == '-')
4394 break; /* advance line */
4396 /* Skip character enclosed in single quote i.e. 'a'
4397 and skip single quote starting an attribute i.e. 'Image. */
4406 if (skip_till_semicolumn
)
4409 skip_till_semicolumn
= false;
4411 continue; /* advance char */
4414 /* Search for beginning of a token. */
4415 if (!begtoken (*dbp
))
4418 continue; /* advance char */
4421 /* We are at the beginning of a token. */
4422 switch (c_tolower (*dbp
))
4425 if (!packages_only
&& nocase_tail ("function"))
4426 Ada_getit (inf
, "/f");
4428 break; /* from switch */
4429 continue; /* advance char */
4431 if (!packages_only
&& nocase_tail ("procedure"))
4432 Ada_getit (inf
, "/p");
4433 else if (nocase_tail ("package"))
4434 Ada_getit (inf
, "/s");
4435 else if (nocase_tail ("protected")) /* protected type */
4436 Ada_getit (inf
, "/t");
4438 break; /* from switch */
4439 continue; /* advance char */
4442 if (typedefs
&& !packages_only
&& nocase_tail ("use"))
4444 /* when tagging types, avoid tagging use type Pack.Typename;
4445 for this, we will skip everything till a ; */
4446 skip_till_semicolumn
= true;
4447 continue; /* advance char */
4451 if (!packages_only
&& nocase_tail ("task"))
4452 Ada_getit (inf
, "/k");
4453 else if (typedefs
&& !packages_only
&& nocase_tail ("type"))
4455 Ada_getit (inf
, "/t");
4456 while (*dbp
!= '\0')
4460 break; /* from switch */
4461 continue; /* advance char */
4464 /* Look for the end of the token. */
4465 while (!endtoken (*dbp
))
4468 } /* advance char */
4469 } /* advance line */
4474 * Unix and microcontroller assembly tag handling
4475 * Labels: /^[a-zA-Z_.$][a-zA_Z0-9_.$]*[: ^I^J]/
4476 * Idea by Bob Weiner, Motorola Inc. (1994)
4479 Asm_labels (FILE *inf
)
4483 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4485 /* If first char is alphabetic or one of [_.$], test for colon
4486 following identifier. */
4487 if (c_isalpha (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4489 /* Read past label. */
4491 while (c_isalnum (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4493 if (*cp
== ':' || c_isspace (*cp
))
4494 /* Found end of label, so copy it and add it to the table. */
4495 make_tag (lb
.buffer
, cp
- lb
.buffer
, true,
4496 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4504 * Perl sub names: /^sub[ \t\n]+[^ \t\n{]+/
4505 * /^use constant[ \t\n]+[^ \t\n{=,;]+/
4506 * Perl variable names: /^(my|local).../
4507 * Original code by Bart Robinson <lomew@cs.utah.edu> (1995)
4508 * Additions by Michael Ernst <mernst@alum.mit.edu> (1997)
4509 * Ideas by Kai Großjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE> (2001)
4512 Perl_functions (FILE *inf
)
4514 char *package
= savestr ("main"); /* current package name */
4517 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4519 cp
= skip_spaces (cp
);
4521 if (LOOKING_AT (cp
, "package"))
4524 get_tag (cp
, &package
);
4526 else if (LOOKING_AT (cp
, "sub"))
4532 while (!notinname (*cp
))
4535 continue; /* nothing found */
4536 pos
= strchr (sp
, ':');
4537 if (pos
&& pos
< cp
&& pos
[1] == ':')
4538 /* The name is already qualified. */
4539 make_tag (sp
, cp
- sp
, true,
4540 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4544 char savechar
, *name
;
4548 name
= concat (package
, "::", sp
);
4550 make_tag (name
, strlen (name
), true,
4551 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4555 else if (LOOKING_AT (cp
, "use constant")
4556 || LOOKING_AT (cp
, "use constant::defer"))
4558 /* For hash style multi-constant like
4559 use constant { FOO => 123,
4561 only the first FOO is picked up. Parsing across the value
4562 expressions would be difficult in general, due to possible nested
4563 hashes, here-documents, etc. */
4565 cp
= skip_spaces (cp
+1);
4568 else if (globals
) /* only if we are tagging global vars */
4570 /* Skip a qualifier, if any. */
4571 bool qual
= LOOKING_AT (cp
, "my") || LOOKING_AT (cp
, "local");
4572 /* After "my" or "local", but before any following paren or space. */
4573 char *varstart
= cp
;
4575 if (qual
/* should this be removed? If yes, how? */
4576 && (*cp
== '$' || *cp
== '@' || *cp
== '%'))
4581 while (c_isalnum (*cp
) || *cp
== '_');
4585 /* Should be examining a variable list at this point;
4586 could insist on seeing an open parenthesis. */
4587 while (*cp
!= '\0' && *cp
!= ';' && *cp
!= '=' && *cp
!= ')')
4593 make_tag (varstart
, cp
- varstart
, false,
4594 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4603 * Look for /^[\t]*def[ \t\n]+[^ \t\n(:]+/ or /^class[ \t\n]+[^ \t\n(:]+/
4604 * Idea by Eric S. Raymond <esr@thyrsus.com> (1997)
4605 * More ideas by seb bacon <seb@jamkit.com> (2002)
4608 Python_functions (FILE *inf
)
4612 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4614 cp
= skip_spaces (cp
);
4615 if (LOOKING_AT (cp
, "def") || LOOKING_AT (cp
, "class"))
4618 while (!notinname (*cp
) && *cp
!= ':')
4620 make_tag (name
, cp
- name
, true,
4621 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4628 * Original code by Xi Lu <lx@shellcodes.org> (2015)
4631 Ruby_functions (FILE *inf
)
4634 bool reader
= false, writer
= false, alias
= false, continuation
= false;
4636 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4638 bool is_class
= false;
4639 bool is_method
= false;
4642 cp
= skip_spaces (cp
);
4645 && c_isalpha (*cp
) && c_isupper (*cp
))
4647 char *bp
, *colon
= NULL
;
4651 for (cp
++; c_isalnum (*cp
) || *cp
== '_' || *cp
== ':'; cp
++)
4658 bp
= skip_spaces (cp
);
4659 if (*bp
== '=' && !(bp
[1] == '=' || bp
[1] == '>'))
4661 if (colon
&& !c_isspace (colon
[1]))
4663 make_tag (name
, cp
- name
, false,
4664 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4668 else if (!continuation
4669 /* Modules, classes, methods. */
4670 && ((is_method
= LOOKING_AT (cp
, "def"))
4671 || (is_class
= LOOKING_AT (cp
, "class"))
4672 || LOOKING_AT (cp
, "module")))
4674 const char self_name
[] = "self.";
4675 const size_t self_size1
= sizeof (self_name
) - 1;
4679 /* Ruby method names can end in a '='. Also, operator overloading can
4680 define operators whose names include '='. */
4681 while (!notinname (*cp
) || *cp
== '=')
4684 /* Remove "self." from the method name. */
4685 if (cp
- name
> self_size1
4686 && strneq (name
, self_name
, self_size1
))
4689 /* Remove the class/module qualifiers from method names. */
4694 for (q
= name
; q
< cp
&& *q
!= '.'; q
++)
4696 if (q
< cp
- 1) /* punt if we see just "FOO." */
4700 /* Don't tag singleton classes. */
4701 if (is_class
&& strneq (name
, "<<", 2) && cp
== name
+ 2)
4704 make_tag (name
, cp
- name
, true,
4705 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4709 /* Tag accessors and aliases. */
4712 reader
= writer
= alias
= false;
4714 while (*cp
&& *cp
!= '#')
4718 reader
= writer
= alias
= false;
4719 if (LOOKING_AT (cp
, "attr_reader"))
4721 else if (LOOKING_AT (cp
, "attr_writer"))
4723 else if (LOOKING_AT (cp
, "attr_accessor"))
4728 else if (LOOKING_AT (cp
, "alias_method"))
4731 if (reader
|| writer
|| alias
)
4736 cp
= skip_spaces (cp
);
4738 cp
= skip_spaces (cp
+ 1);
4740 cp
= skip_name (cp
);
4746 make_tag (np
, cp
- np
, true,
4747 lb
.buffer
, cp
- lb
.buffer
+ 1,
4748 lineno
, linecharno
);
4749 continuation
= false;
4753 size_t name_len
= cp
- np
+ 1;
4754 char *wr_name
= xnew (name_len
+ 1, char);
4756 memcpy (wr_name
, np
, name_len
- 1);
4757 memcpy (wr_name
+ name_len
- 1, "=", 2);
4758 pfnote (wr_name
, true, lb
.buffer
, cp
- lb
.buffer
+ 1,
4759 lineno
, linecharno
);
4760 continuation
= false;
4765 make_tag (np
, cp
- np
, true,
4766 lb
.buffer
, cp
- lb
.buffer
+ 1,
4767 lineno
, linecharno
);
4768 continuation
= false;
4769 while (*cp
&& *cp
!= '#' && *cp
!= ';')
4772 continuation
= true;
4773 else if (!c_isspace (*cp
))
4774 continuation
= false;
4778 continuation
= false;
4780 cp
= skip_spaces (cp
);
4783 : (continuation
= (*cp
== ',')))
4784 && (cp
= skip_spaces (cp
+ 1), *cp
&& *cp
!= '#'));
4787 cp
= skip_name (cp
);
4788 while (*cp
&& *cp
!= '#' && notinname (*cp
))
4799 * - /^[ \t]*function[ \t\n]+[^ \t\n(]+/
4800 * - /^[ \t]*class[ \t\n]+[^ \t\n]+/
4801 * - /^[ \t]*define\(\"[^\"]+/
4802 * Only with --members:
4803 * - /^[ \t]*var[ \t\n]+\$[^ \t\n=;]/
4804 * Idea by Diez B. Roggisch (2001)
4807 PHP_functions (FILE *inf
)
4810 bool search_identifier
= false;
4812 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4814 cp
= skip_spaces (cp
);
4816 if (search_identifier
4819 while (!notinname (*cp
))
4821 make_tag (name
, cp
- name
, true,
4822 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4823 search_identifier
= false;
4825 else if (LOOKING_AT (cp
, "function"))
4828 cp
= skip_spaces (cp
+1);
4832 while (!notinname (*cp
))
4834 make_tag (name
, cp
- name
, true,
4835 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4838 search_identifier
= true;
4840 else if (LOOKING_AT (cp
, "class"))
4845 while (*cp
!= '\0' && !c_isspace (*cp
))
4847 make_tag (name
, cp
- name
, false,
4848 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4851 search_identifier
= true;
4853 else if (strneq (cp
, "define", 6)
4854 && (cp
= skip_spaces (cp
+6))
4856 && (*cp
== '"' || *cp
== '\''))
4860 while (*cp
!= quote
&& *cp
!= '\0')
4862 make_tag (name
, cp
- name
, false,
4863 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4866 && LOOKING_AT (cp
, "var")
4870 while (!notinname (*cp
))
4872 make_tag (name
, cp
- name
, false,
4873 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4880 * Cobol tag functions
4881 * We could look for anything that could be a paragraph name.
4882 * i.e. anything that starts in column 8 is one word and ends in a full stop.
4883 * Idea by Corny de Souza (1993)
4886 Cobol_paragraphs (FILE *inf
)
4888 register char *bp
, *ep
;
4890 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4896 /* If eoln, compiler option or comment ignore whole line. */
4897 if (bp
[-1] != ' ' || !c_isalnum (bp
[0]))
4900 for (ep
= bp
; c_isalnum (*ep
) || *ep
== '-'; ep
++)
4903 make_tag (bp
, ep
- bp
, true,
4904 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4911 * Ideas by Assar Westerlund <assar@sics.se> (2001)
4914 Makefile_targets (FILE *inf
)
4918 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4920 if (*bp
== '\t' || *bp
== '#')
4922 while (*bp
!= '\0' && *bp
!= '=' && *bp
!= ':')
4924 if (*bp
== ':' || (globals
&& *bp
== '='))
4926 /* We should detect if there is more than one tag, but we do not.
4927 We just skip initial and final spaces. */
4928 char * namestart
= skip_spaces (lb
.buffer
);
4929 while (--bp
> namestart
)
4930 if (!notinname (*bp
))
4932 make_tag (namestart
, bp
- namestart
+ 1, true,
4933 lb
.buffer
, bp
- lb
.buffer
+ 2, lineno
, linecharno
);
4941 * Original code by Mosur K. Mohan (1989)
4943 * Locates tags for procedures & functions. Doesn't do any type- or
4944 * var-definitions. It does look for the keyword "extern" or
4945 * "forward" immediately following the procedure statement; if found,
4946 * the tag is skipped.
4949 Pascal_functions (FILE *inf
)
4951 linebuffer tline
; /* mostly copied from C_entries */
4953 int save_lineno
, namelen
, taglen
;
4956 bool /* each of these flags is true if: */
4957 incomment
, /* point is inside a comment */
4958 inquote
, /* point is inside '..' string */
4959 get_tagname
, /* point is after PROCEDURE/FUNCTION
4960 keyword, so next item = potential tag */
4961 found_tag
, /* point is after a potential tag */
4962 inparms
, /* point is within parameter-list */
4963 verify_tag
; /* point has passed the parm-list, so the
4964 next token will determine whether this
4965 is a FORWARD/EXTERN to be ignored, or
4966 whether it is a real tag */
4968 save_lcno
= save_lineno
= namelen
= taglen
= 0; /* keep compiler quiet */
4969 name
= NULL
; /* keep compiler quiet */
4972 linebuffer_init (&tline
);
4974 incomment
= inquote
= false;
4975 found_tag
= false; /* have a proc name; check if extern */
4976 get_tagname
= false; /* found "procedure" keyword */
4977 inparms
= false; /* found '(' after "proc" */
4978 verify_tag
= false; /* check if "extern" is ahead */
4981 while (perhaps_more_input (inf
)) /* long main loop to get next char */
4984 if (c
== '\0') /* if end of line */
4986 readline (&lb
, inf
);
4990 if (!((found_tag
&& verify_tag
)
4992 c
= *dbp
++; /* only if don't need *dbp pointing
4993 to the beginning of the name of
4994 the procedure or function */
4998 if (c
== '}') /* within { } comments */
5000 else if (c
== '*' && *dbp
== ')') /* within (* *) comments */
5017 inquote
= true; /* found first quote */
5019 case '{': /* found open { comment */
5023 if (*dbp
== '*') /* found open (* comment */
5028 else if (found_tag
) /* found '(' after tag, i.e., parm-list */
5031 case ')': /* end of parms list */
5036 if (found_tag
&& !inparms
) /* end of proc or fn stmt */
5043 if (found_tag
&& verify_tag
&& (*dbp
!= ' '))
5045 /* Check if this is an "extern" declaration. */
5048 if (c_tolower (*dbp
) == 'e')
5050 if (nocase_tail ("extern")) /* superfluous, really! */
5056 else if (c_tolower (*dbp
) == 'f')
5058 if (nocase_tail ("forward")) /* check for forward reference */
5064 if (found_tag
&& verify_tag
) /* not external proc, so make tag */
5068 make_tag (name
, namelen
, true,
5069 tline
.buffer
, taglen
, save_lineno
, save_lcno
);
5073 if (get_tagname
) /* grab name of proc or fn */
5080 /* Find block name. */
5081 for (cp
= dbp
+ 1; *cp
!= '\0' && !endtoken (*cp
); cp
++)
5084 /* Save all values for later tagging. */
5085 linebuffer_setlen (&tline
, lb
.len
);
5086 strcpy (tline
.buffer
, lb
.buffer
);
5087 save_lineno
= lineno
;
5088 save_lcno
= linecharno
;
5089 name
= tline
.buffer
+ (dbp
- lb
.buffer
);
5091 taglen
= cp
- lb
.buffer
+ 1;
5093 dbp
= cp
; /* set dbp to e-o-token */
5094 get_tagname
= false;
5098 /* And proceed to check for "extern". */
5100 else if (!incomment
&& !inquote
&& !found_tag
)
5102 /* Check for proc/fn keywords. */
5103 switch (c_tolower (c
))
5106 if (nocase_tail ("rocedure")) /* c = 'p', dbp has advanced */
5110 if (nocase_tail ("unction"))
5115 } /* while not eof */
5117 free (tline
.buffer
);
5122 * Lisp tag functions
5123 * look for (def or (DEF, quote or QUOTE
5126 static void L_getit (void);
5131 if (*dbp
== '\'') /* Skip prefix quote */
5133 else if (*dbp
== '(')
5136 /* Try to skip "(quote " */
5137 if (!LOOKING_AT (dbp
, "quote") && !LOOKING_AT (dbp
, "QUOTE"))
5138 /* Ok, then skip "(" before name in (defstruct (foo)) */
5139 dbp
= skip_spaces (dbp
);
5141 get_tag (dbp
, NULL
);
5145 Lisp_functions (FILE *inf
)
5147 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
5152 /* "(defvar foo)" is a declaration rather than a definition. */
5156 if (LOOKING_AT (p
, "defvar"))
5158 p
= skip_name (p
); /* past var name */
5159 p
= skip_spaces (p
);
5165 if (strneq (dbp
+ 1, "cl-", 3) || strneq (dbp
+ 1, "CL-", 3))
5168 if (strneq (dbp
+1, "def", 3) || strneq (dbp
+1, "DEF", 3))
5170 dbp
= skip_non_spaces (dbp
);
5171 dbp
= skip_spaces (dbp
);
5176 /* Check for (foo::defmumble name-defined ... */
5179 while (!notinname (*dbp
) && *dbp
!= ':');
5184 while (*dbp
== ':');
5186 if (strneq (dbp
, "def", 3) || strneq (dbp
, "DEF", 3))
5188 dbp
= skip_non_spaces (dbp
);
5189 dbp
= skip_spaces (dbp
);
5199 * Lua script language parsing
5200 * Original code by David A. Capello <dacap@users.sourceforge.net> (2004)
5202 * "function" and "local function" are tags if they start at column 1.
5205 Lua_functions (FILE *inf
)
5209 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5211 bp
= skip_spaces (bp
);
5212 if (bp
[0] != 'f' && bp
[0] != 'l')
5215 (void)LOOKING_AT (bp
, "local"); /* skip possible "local" */
5217 if (LOOKING_AT (bp
, "function"))
5219 char *tag_name
, *tp_dot
, *tp_colon
;
5221 get_tag (bp
, &tag_name
);
5222 /* If the tag ends with ".foo" or ":foo", make an additional tag for
5224 tp_dot
= strrchr (tag_name
, '.');
5225 tp_colon
= strrchr (tag_name
, ':');
5226 if (tp_dot
|| tp_colon
)
5228 char *p
= tp_dot
> tp_colon
? tp_dot
: tp_colon
;
5229 int len_add
= p
- tag_name
+ 1;
5231 get_tag (bp
+ len_add
, NULL
);
5240 * Just look for lines where the first character is '/'
5241 * Also look at "defineps" for PSWrap
5243 * Richard Mlynarik <mly@adoc.xerox.com> (1997)
5244 * Masatake Yamato <masata-y@is.aist-nara.ac.jp> (1999)
5247 PS_functions (FILE *inf
)
5249 register char *bp
, *ep
;
5251 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5256 *ep
!= '\0' && *ep
!= ' ' && *ep
!= '{';
5259 make_tag (bp
, ep
- bp
, true,
5260 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
5262 else if (LOOKING_AT (bp
, "defineps"))
5270 * Ignore anything after \ followed by space or in ( )
5271 * Look for words defined by :
5272 * Look for constant, code, create, defer, value, and variable
5273 * OBP extensions: Look for buffer:, field,
5274 * Ideas by Eduardo Horvath <eeh@netbsd.org> (2004)
5277 Forth_words (FILE *inf
)
5281 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5282 while ((bp
= skip_spaces (bp
))[0] != '\0')
5283 if (bp
[0] == '\\' && c_isspace (bp
[1]))
5284 break; /* read next line */
5285 else if (bp
[0] == '(' && c_isspace (bp
[1]))
5286 do /* skip to ) or eol */
5288 while (*bp
!= ')' && *bp
!= '\0');
5289 else if ((bp
[0] == ':' && c_isspace (bp
[1]) && bp
++)
5290 || LOOKING_AT_NOCASE (bp
, "constant")
5291 || LOOKING_AT_NOCASE (bp
, "code")
5292 || LOOKING_AT_NOCASE (bp
, "create")
5293 || LOOKING_AT_NOCASE (bp
, "defer")
5294 || LOOKING_AT_NOCASE (bp
, "value")
5295 || LOOKING_AT_NOCASE (bp
, "variable")
5296 || LOOKING_AT_NOCASE (bp
, "buffer:")
5297 || LOOKING_AT_NOCASE (bp
, "field"))
5298 get_tag (skip_spaces (bp
), NULL
); /* Yay! A definition! */
5300 bp
= skip_non_spaces (bp
);
5305 * Scheme tag functions
5306 * look for (def... xyzzy
5308 * (def ... ((...(xyzzy ....
5310 * Original code by Ken Haase (1985?)
5313 Scheme_functions (FILE *inf
)
5317 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5319 if (strneq (bp
, "(def", 4) || strneq (bp
, "(DEF", 4))
5321 bp
= skip_non_spaces (bp
+4);
5322 /* Skip over open parens and white space. Don't continue past
5324 while (*bp
&& notinname (*bp
))
5328 if (LOOKING_AT (bp
, "(SET!") || LOOKING_AT (bp
, "(set!"))
5334 /* Find tags in TeX and LaTeX input files. */
5336 /* TEX_toktab is a table of TeX control sequences that define tags.
5337 * Each entry records one such control sequence.
5339 * Original code from who knows whom.
5341 * Stefan Monnier (2002)
5344 static linebuffer
*TEX_toktab
= NULL
; /* Table with tag tokens */
5346 /* Default set of control sequences to put into TEX_toktab.
5347 The value of environment var TEXTAGS is prepended to this. */
5348 static const char *TEX_defenv
= "\
5349 :chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem\
5350 :part:appendix:entry:index:def\
5351 :newcommand:renewcommand:newenvironment:renewenvironment";
5353 static void TEX_decode_env (const char *, const char *);
5356 * TeX/LaTeX scanning loop.
5359 TeX_commands (FILE *inf
)
5364 char TEX_esc
= '\0';
5365 char TEX_opgrp
, TEX_clgrp
;
5367 /* Initialize token table once from environment. */
5368 if (TEX_toktab
== NULL
)
5369 TEX_decode_env ("TEXTAGS", TEX_defenv
);
5371 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5373 /* Look at each TEX keyword in line. */
5376 /* Look for a TEX escape. */
5380 if (c
== '\0' || c
== '%')
5383 /* Select either \ or ! as escape character, whichever comes
5384 first outside a comment. */
5405 for (key
= TEX_toktab
; key
->buffer
!= NULL
; key
++)
5406 if (strneq (cp
, key
->buffer
, key
->len
))
5409 int namelen
, linelen
;
5412 cp
= skip_spaces (cp
+ key
->len
);
5413 if (*cp
== TEX_opgrp
)
5419 (!c_isspace (*p
) && *p
!= '#' &&
5420 *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
);
5425 if (!opgrp
|| *p
== TEX_clgrp
)
5427 while (*p
!= '\0' && *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
)
5429 linelen
= p
- lb
.buffer
+ 1;
5431 make_tag (cp
, namelen
, true,
5432 lb
.buffer
, linelen
, lineno
, linecharno
);
5433 goto tex_next_line
; /* We only tag a line once */
5441 /* Read environment and prepend it to the default string.
5442 Build token table. */
5444 TEX_decode_env (const char *evarname
, const char *defenv
)
5446 register const char *env
, *p
;
5449 /* Append default string to environment. */
5450 env
= getenv (evarname
);
5454 env
= concat (env
, defenv
, "");
5456 /* Allocate a token table */
5457 for (len
= 1, p
= env
; (p
= strchr (p
, ':')); )
5460 TEX_toktab
= xnew (len
, linebuffer
);
5462 /* Unpack environment string into token table. Be careful about */
5463 /* zero-length strings (leading ':', "::" and trailing ':') */
5464 for (i
= 0; *env
!= '\0';)
5466 p
= strchr (env
, ':');
5467 if (!p
) /* End of environment string. */
5468 p
= env
+ strlen (env
);
5470 { /* Only non-zero strings. */
5471 TEX_toktab
[i
].buffer
= savenstr (env
, p
- env
);
5472 TEX_toktab
[i
].len
= p
- env
;
5479 TEX_toktab
[i
].buffer
= NULL
; /* Mark end of table. */
5480 TEX_toktab
[i
].len
= 0;
5487 /* Texinfo support. Dave Love, Mar. 2000. */
5489 Texinfo_nodes (FILE *inf
)
5492 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5493 if (LOOKING_AT (cp
, "@node"))
5496 while (*cp
!= '\0' && *cp
!= ',')
5498 make_tag (start
, cp
- start
, true,
5499 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
5506 * Contents of <title>, <h1>, <h2>, <h3> are tags.
5507 * Contents of <a name=xxx> are tags with name xxx.
5509 * Francesco Potortì, 2002.
5512 HTML_labels (FILE *inf
)
5514 bool getnext
= false; /* next text outside of HTML tags is a tag */
5515 bool skiptag
= false; /* skip to the end of the current HTML tag */
5516 bool intag
= false; /* inside an html tag, looking for ID= */
5517 bool inanchor
= false; /* when INTAG, is an anchor, look for NAME= */
5521 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5523 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
5524 for (;;) /* loop on the same line */
5526 if (skiptag
) /* skip HTML tag */
5528 while (*dbp
!= '\0' && *dbp
!= '>')
5534 continue; /* look on the same line */
5536 break; /* go to next line */
5539 else if (intag
) /* look for "name=" or "id=" */
5541 while (*dbp
!= '\0' && *dbp
!= '>'
5542 && c_tolower (*dbp
) != 'n' && c_tolower (*dbp
) != 'i')
5545 break; /* go to next line */
5550 continue; /* look on the same line */
5552 if ((inanchor
&& LOOKING_AT_NOCASE (dbp
, "name="))
5553 || LOOKING_AT_NOCASE (dbp
, "id="))
5555 bool quoted
= (dbp
[0] == '"');
5558 for (end
= ++dbp
; *end
!= '\0' && *end
!= '"'; end
++)
5561 for (end
= dbp
; *end
!= '\0' && intoken (*end
); end
++)
5563 linebuffer_setlen (&token_name
, end
- dbp
);
5564 memcpy (token_name
.buffer
, dbp
, end
- dbp
);
5565 token_name
.buffer
[end
- dbp
] = '\0';
5568 intag
= false; /* we found what we looked for */
5569 skiptag
= true; /* skip to the end of the tag */
5570 getnext
= true; /* then grab the text */
5571 continue; /* look on the same line */
5576 else if (getnext
) /* grab next tokens and tag them */
5578 dbp
= skip_spaces (dbp
);
5580 break; /* go to next line */
5584 inanchor
= (c_tolower (dbp
[1]) == 'a' && !intoken (dbp
[2]));
5585 continue; /* look on the same line */
5588 for (end
= dbp
+ 1; *end
!= '\0' && *end
!= '<'; end
++)
5590 make_tag (token_name
.buffer
, token_name
.len
, true,
5591 dbp
, end
- dbp
, lineno
, linecharno
);
5592 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5594 break; /* go to next line */
5597 else /* look for an interesting HTML tag */
5599 while (*dbp
!= '\0' && *dbp
!= '<')
5602 break; /* go to next line */
5604 if (c_tolower (dbp
[1]) == 'a' && !intoken (dbp
[2]))
5607 continue; /* look on the same line */
5609 else if (LOOKING_AT_NOCASE (dbp
, "<title>")
5610 || LOOKING_AT_NOCASE (dbp
, "<h1>")
5611 || LOOKING_AT_NOCASE (dbp
, "<h2>")
5612 || LOOKING_AT_NOCASE (dbp
, "<h3>"))
5616 continue; /* look on the same line */
5627 * Assumes that the predicate or rule starts at column 0.
5628 * Only the first clause of a predicate or rule is added.
5629 * Original code by Sunichirou Sugou (1989)
5630 * Rewritten by Anders Lindgren (1996)
5632 static size_t prolog_pr (char *, char *);
5633 static void prolog_skip_comment (linebuffer
*, FILE *);
5634 static size_t prolog_atom (char *, size_t);
5637 Prolog_functions (FILE *inf
)
5647 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5649 if (cp
[0] == '\0') /* Empty line */
5651 else if (c_isspace (cp
[0])) /* Not a predicate */
5653 else if (cp
[0] == '/' && cp
[1] == '*') /* comment. */
5654 prolog_skip_comment (&lb
, inf
);
5655 else if ((len
= prolog_pr (cp
, last
)) > 0)
5657 /* Predicate or rule. Store the function name so that we
5658 only generate a tag for the first clause. */
5660 last
= xnew (len
+ 1, char);
5661 else if (len
+ 1 > allocated
)
5662 xrnew (last
, len
+ 1, char);
5663 allocated
= len
+ 1;
5664 memcpy (last
, cp
, len
);
5673 prolog_skip_comment (linebuffer
*plb
, FILE *inf
)
5679 for (cp
= plb
->buffer
; *cp
!= '\0'; cp
++)
5680 if (cp
[0] == '*' && cp
[1] == '/')
5682 readline (plb
, inf
);
5684 while (perhaps_more_input (inf
));
5688 * A predicate or rule definition is added if it matches:
5689 * <beginning of line><Prolog Atom><whitespace>(
5690 * or <beginning of line><Prolog Atom><whitespace>:-
5692 * It is added to the tags database if it doesn't match the
5693 * name of the previous clause header.
5695 * Return the size of the name of the predicate or rule, or 0 if no
5699 prolog_pr (char *s
, char *last
)
5701 /* Name of last clause. */
5706 pos
= prolog_atom (s
, 0);
5711 pos
= skip_spaces (s
+ pos
) - s
;
5714 || (s
[pos
] == '(' && (pos
+= 1))
5715 || (s
[pos
] == ':' && s
[pos
+ 1] == '-' && (pos
+= 2)))
5716 && (last
== NULL
/* save only the first clause */
5717 || len
!= strlen (last
)
5718 || !strneq (s
, last
, len
)))
5720 make_tag (s
, len
, true, s
, pos
, lineno
, linecharno
);
5728 * Consume a Prolog atom.
5729 * Return the number of bytes consumed, or 0 if there was an error.
5731 * A prolog atom, in this context, could be one of:
5732 * - An alphanumeric sequence, starting with a lower case letter.
5733 * - A quoted arbitrary string. Single quotes can escape themselves.
5734 * Backslash quotes everything.
5737 prolog_atom (char *s
, size_t pos
)
5743 if (c_islower (s
[pos
]) || s
[pos
] == '_')
5745 /* The atom is unquoted. */
5747 while (c_isalnum (s
[pos
]) || s
[pos
] == '_')
5751 return pos
- origpos
;
5753 else if (s
[pos
] == '\'')
5764 pos
++; /* A double quote */
5766 else if (s
[pos
] == '\0')
5767 /* Multiline quoted atoms are ignored. */
5769 else if (s
[pos
] == '\\')
5771 if (s
[pos
+1] == '\0')
5778 return pos
- origpos
;
5786 * Support for Erlang
5788 * Generates tags for functions, defines, and records.
5789 * Assumes that Erlang functions start at column 0.
5790 * Original code by Anders Lindgren (1996)
5792 static int erlang_func (char *, char *);
5793 static void erlang_attribute (char *);
5794 static int erlang_atom (char *);
5797 Erlang_functions (FILE *inf
)
5807 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5809 if (cp
[0] == '\0') /* Empty line */
5811 else if (c_isspace (cp
[0])) /* Not function nor attribute */
5813 else if (cp
[0] == '%') /* comment */
5815 else if (cp
[0] == '"') /* Sometimes, strings start in column one */
5817 else if (cp
[0] == '-') /* attribute, e.g. "-define" */
5819 erlang_attribute (cp
);
5826 else if ((len
= erlang_func (cp
, last
)) > 0)
5829 * Function. Store the function name so that we only
5830 * generates a tag for the first clause.
5833 last
= xnew (len
+ 1, char);
5834 else if (len
+ 1 > allocated
)
5835 xrnew (last
, len
+ 1, char);
5836 allocated
= len
+ 1;
5837 memcpy (last
, cp
, len
);
5846 * A function definition is added if it matches:
5847 * <beginning of line><Erlang Atom><whitespace>(
5849 * It is added to the tags database if it doesn't match the
5850 * name of the previous clause header.
5852 * Return the size of the name of the function, or 0 if no function
5856 erlang_func (char *s
, char *last
)
5858 /* Name of last clause. */
5863 pos
= erlang_atom (s
);
5868 pos
= skip_spaces (s
+ pos
) - s
;
5870 /* Save only the first clause. */
5873 || len
!= (int)strlen (last
)
5874 || !strneq (s
, last
, len
)))
5876 make_tag (s
, len
, true, s
, pos
, lineno
, linecharno
);
5885 * Handle attributes. Currently, tags are generated for defines
5888 * They are on the form:
5889 * -define(foo, bar).
5890 * -define(Foo(M, N), M+N).
5891 * -record(graph, {vtab = notable, cyclic = true}).
5894 erlang_attribute (char *s
)
5898 if ((LOOKING_AT (cp
, "-define") || LOOKING_AT (cp
, "-record"))
5901 int len
= erlang_atom (skip_spaces (cp
));
5903 make_tag (cp
, len
, true, s
, cp
+ len
- s
, lineno
, linecharno
);
5910 * Consume an Erlang atom (or variable).
5911 * Return the number of bytes consumed, or -1 if there was an error.
5914 erlang_atom (char *s
)
5918 if (c_isalpha (s
[pos
]) || s
[pos
] == '_')
5920 /* The atom is unquoted. */
5923 while (c_isalnum (s
[pos
]) || s
[pos
] == '_');
5925 else if (s
[pos
] == '\'')
5927 for (pos
++; s
[pos
] != '\''; pos
++)
5928 if (s
[pos
] == '\0' /* multiline quoted atoms are ignored */
5929 || (s
[pos
] == '\\' && s
[++pos
] == '\0'))
5938 static char *scan_separators (char *);
5939 static void add_regex (char *, language
*);
5940 static char *substitute (char *, char *, struct re_registers
*);
5943 * Take a string like "/blah/" and turn it into "blah", verifying
5944 * that the first and last characters are the same, and handling
5945 * quoted separator characters. Actually, stops on the occurrence of
5946 * an unquoted separator. Also process \t, \n, etc. and turn into
5947 * appropriate characters. Works in place. Null terminates name string.
5948 * Returns pointer to terminating separator, or NULL for
5949 * unterminated regexps.
5952 scan_separators (char *name
)
5955 char *copyto
= name
;
5956 bool quoted
= false;
5958 for (++name
; *name
!= '\0'; ++name
)
5964 case 'a': *copyto
++ = '\007'; break; /* BEL (bell) */
5965 case 'b': *copyto
++ = '\b'; break; /* BS (back space) */
5966 case 'd': *copyto
++ = 0177; break; /* DEL (delete) */
5967 case 'e': *copyto
++ = 033; break; /* ESC (delete) */
5968 case 'f': *copyto
++ = '\f'; break; /* FF (form feed) */
5969 case 'n': *copyto
++ = '\n'; break; /* NL (new line) */
5970 case 'r': *copyto
++ = '\r'; break; /* CR (carriage return) */
5971 case 't': *copyto
++ = '\t'; break; /* TAB (horizontal tab) */
5972 case 'v': *copyto
++ = '\v'; break; /* VT (vertical tab) */
5978 /* Something else is quoted, so preserve the quote. */
5986 else if (*name
== '\\')
5988 else if (*name
== sep
)
5994 name
= NULL
; /* signal unterminated regexp */
5996 /* Terminate copied string. */
6001 /* Look at the argument of --regex or --no-regex and do the right
6002 thing. Same for each line of a regexp file. */
6004 analyze_regex (char *regex_arg
)
6006 if (regex_arg
== NULL
)
6008 free_regexps (); /* --no-regex: remove existing regexps */
6012 /* A real --regexp option or a line in a regexp file. */
6013 switch (regex_arg
[0])
6015 /* Comments in regexp file or null arg to --regex. */
6021 /* Read a regex file. This is recursive and may result in a
6022 loop, which will stop when the file descriptors are exhausted. */
6026 linebuffer regexbuf
;
6027 char *regexfile
= regex_arg
+ 1;
6029 /* regexfile is a file containing regexps, one per line. */
6030 regexfp
= fopen (regexfile
, "r" FOPEN_BINARY
);
6031 if (regexfp
== NULL
)
6033 linebuffer_init (®exbuf
);
6034 while (readline_internal (®exbuf
, regexfp
, regexfile
) > 0)
6035 analyze_regex (regexbuf
.buffer
);
6036 free (regexbuf
.buffer
);
6037 if (fclose (regexfp
) != 0)
6042 /* Regexp to be used for a specific language only. */
6046 char *lang_name
= regex_arg
+ 1;
6049 for (cp
= lang_name
; *cp
!= '}'; cp
++)
6052 error ("unterminated language name in regex: %s", regex_arg
);
6056 lang
= get_language_from_langname (lang_name
);
6059 add_regex (cp
, lang
);
6063 /* Regexp to be used for any language. */
6065 add_regex (regex_arg
, NULL
);
6070 /* Separate the regexp pattern, compile it,
6071 and care for optional name and modifiers. */
6073 add_regex (char *regexp_pattern
, language
*lang
)
6075 static struct re_pattern_buffer zeropattern
;
6076 char sep
, *pat
, *name
, *modifiers
;
6079 struct re_pattern_buffer
*patbuf
;
6082 force_explicit_name
= true, /* do not use implicit tag names */
6083 ignore_case
= false, /* case is significant */
6084 multi_line
= false, /* matches are done one line at a time */
6085 single_line
= false; /* dot does not match newline */
6088 if (strlen (regexp_pattern
) < 3)
6090 error ("null regexp");
6093 sep
= regexp_pattern
[0];
6094 name
= scan_separators (regexp_pattern
);
6097 error ("%s: unterminated regexp", regexp_pattern
);
6102 error ("null name for regexp \"%s\"", regexp_pattern
);
6105 modifiers
= scan_separators (name
);
6106 if (modifiers
== NULL
) /* no terminating separator --> no name */
6112 modifiers
+= 1; /* skip separator */
6114 /* Parse regex modifiers. */
6115 for (; modifiers
[0] != '\0'; modifiers
++)
6116 switch (modifiers
[0])
6119 if (modifiers
== name
)
6120 error ("forcing explicit tag name but no name, ignoring");
6121 force_explicit_name
= true;
6131 need_filebuf
= true;
6134 error ("invalid regexp modifier '%c', ignoring", modifiers
[0]);
6138 patbuf
= xnew (1, struct re_pattern_buffer
);
6139 *patbuf
= zeropattern
;
6142 static char lc_trans
[UCHAR_MAX
+ 1];
6144 for (i
= 0; i
< UCHAR_MAX
+ 1; i
++)
6145 lc_trans
[i
] = c_tolower (i
);
6146 patbuf
->translate
= lc_trans
; /* translation table to fold case */
6150 pat
= concat ("^", regexp_pattern
, ""); /* anchor to beginning of line */
6152 pat
= regexp_pattern
;
6155 re_set_syntax (RE_SYNTAX_EMACS
| RE_DOT_NEWLINE
);
6157 re_set_syntax (RE_SYNTAX_EMACS
);
6159 err
= re_compile_pattern (pat
, strlen (pat
), patbuf
);
6164 error ("%s while compiling pattern", err
);
6169 p_head
= xnew (1, regexp
);
6170 p_head
->pattern
= savestr (regexp_pattern
);
6171 p_head
->p_next
= rp
;
6172 p_head
->lang
= lang
;
6173 p_head
->pat
= patbuf
;
6174 p_head
->name
= savestr (name
);
6175 p_head
->error_signaled
= false;
6176 p_head
->force_explicit_name
= force_explicit_name
;
6177 p_head
->ignore_case
= ignore_case
;
6178 p_head
->multi_line
= multi_line
;
6182 * Do the substitutions indicated by the regular expression and
6186 substitute (char *in
, char *out
, struct re_registers
*regs
)
6189 int size
, dig
, diglen
;
6192 size
= strlen (out
);
6194 /* Pass 1: figure out how much to allocate by finding all \N strings. */
6195 if (out
[size
- 1] == '\\')
6196 fatal ("pattern error in \"%s\"", out
);
6197 for (t
= strchr (out
, '\\');
6199 t
= strchr (t
+ 2, '\\'))
6200 if (c_isdigit (t
[1]))
6203 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
6209 /* Allocate space and do the substitutions. */
6211 result
= xnew (size
+ 1, char);
6213 for (t
= result
; *out
!= '\0'; out
++)
6214 if (*out
== '\\' && c_isdigit (*++out
))
6217 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
6218 memcpy (t
, in
+ regs
->start
[dig
], diglen
);
6225 assert (t
<= result
+ size
);
6226 assert (t
- result
== (int)strlen (result
));
6231 /* Deallocate all regexps. */
6236 while (p_head
!= NULL
)
6238 rp
= p_head
->p_next
;
6239 free (p_head
->pattern
);
6240 free (p_head
->name
);
6248 * Reads the whole file as a single string from `filebuf' and looks for
6249 * multi-line regular expressions, creating tags on matches.
6250 * readline already dealt with normal regexps.
6252 * Idea by Ben Wing <ben@666.com> (2002).
6255 regex_tag_multiline (void)
6257 char *buffer
= filebuf
.buffer
;
6261 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6265 if (!rp
->multi_line
)
6266 continue; /* skip normal regexps */
6268 /* Generic initializations before parsing file from memory. */
6269 lineno
= 1; /* reset global line number */
6270 charno
= 0; /* reset global char number */
6271 linecharno
= 0; /* reset global char number of line start */
6273 /* Only use generic regexps or those for the current language. */
6274 if (rp
->lang
!= NULL
&& rp
->lang
!= curfdp
->lang
)
6277 while (match
>= 0 && match
< filebuf
.len
)
6279 match
= re_search (rp
->pat
, buffer
, filebuf
.len
, charno
,
6280 filebuf
.len
- match
, &rp
->regs
);
6285 if (!rp
->error_signaled
)
6287 error ("regexp stack overflow while matching \"%s\"",
6289 rp
->error_signaled
= true;
6296 if (match
== rp
->regs
.end
[0])
6298 if (!rp
->error_signaled
)
6300 error ("regexp matches the empty string: \"%s\"",
6302 rp
->error_signaled
= true;
6304 match
= -3; /* exit from while loop */
6308 /* Match occurred. Construct a tag. */
6309 while (charno
< rp
->regs
.end
[0])
6310 if (buffer
[charno
++] == '\n')
6311 lineno
++, linecharno
= charno
;
6313 if (name
[0] == '\0')
6315 else /* make a named tag */
6316 name
= substitute (buffer
, rp
->name
, &rp
->regs
);
6317 if (rp
->force_explicit_name
)
6318 /* Force explicit tag name, if a name is there. */
6319 pfnote (name
, true, buffer
+ linecharno
,
6320 charno
- linecharno
+ 1, lineno
, linecharno
);
6322 make_tag (name
, strlen (name
), true, buffer
+ linecharno
,
6323 charno
- linecharno
+ 1, lineno
, linecharno
);
6332 nocase_tail (const char *cp
)
6336 while (*cp
!= '\0' && c_tolower (*cp
) == c_tolower (dbp
[len
]))
6338 if (*cp
== '\0' && !intoken (dbp
[len
]))
6347 get_tag (register char *bp
, char **namepp
)
6349 register char *cp
= bp
;
6353 /* Go till you get to white space or a syntactic break */
6354 for (cp
= bp
+ 1; !notinname (*cp
); cp
++)
6356 make_tag (bp
, cp
- bp
, true,
6357 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
6361 *namepp
= savenstr (bp
, cp
- bp
);
6365 * Read a line of text from `stream' into `lbp', excluding the
6366 * newline or CR-NL, if any. Return the number of characters read from
6367 * `stream', which is the length of the line including the newline.
6369 * On DOS or Windows we do not count the CR character, if any before the
6370 * NL, in the returned length; this mirrors the behavior of Emacs on those
6371 * platforms (for text files, it translates CR-NL to NL as it reads in the
6374 * If multi-line regular expressions are requested, each line read is
6375 * appended to `filebuf'.
6378 readline_internal (linebuffer
*lbp
, FILE *stream
, char const *filename
)
6380 char *buffer
= lbp
->buffer
;
6381 char *p
= lbp
->buffer
;
6385 pend
= p
+ lbp
->size
; /* Separate to avoid 386/IX compiler bug. */
6389 register int c
= getc (stream
);
6392 /* We're at the end of linebuffer: expand it. */
6394 xrnew (buffer
, lbp
->size
, char);
6395 p
+= buffer
- lbp
->buffer
;
6396 pend
= buffer
+ lbp
->size
;
6397 lbp
->buffer
= buffer
;
6401 if (ferror (stream
))
6409 if (p
> buffer
&& p
[-1] == '\r')
6423 lbp
->len
= p
- buffer
;
6425 if (need_filebuf
/* we need filebuf for multi-line regexps */
6426 && chars_deleted
> 0) /* not at EOF */
6428 while (filebuf
.size
<= filebuf
.len
+ lbp
->len
+ 1) /* +1 for \n */
6430 /* Expand filebuf. */
6432 xrnew (filebuf
.buffer
, filebuf
.size
, char);
6434 memcpy (filebuf
.buffer
+ filebuf
.len
, lbp
->buffer
, lbp
->len
);
6435 filebuf
.len
+= lbp
->len
;
6436 filebuf
.buffer
[filebuf
.len
++] = '\n';
6437 filebuf
.buffer
[filebuf
.len
] = '\0';
6440 return lbp
->len
+ chars_deleted
;
6444 * Like readline_internal, above, but in addition try to match the
6445 * input line against relevant regular expressions and manage #line
6449 readline (linebuffer
*lbp
, FILE *stream
)
6453 linecharno
= charno
; /* update global char number of line start */
6454 result
= readline_internal (lbp
, stream
, infilename
); /* read line */
6455 lineno
+= 1; /* increment global line number */
6456 charno
+= result
; /* increment global char number */
6458 /* Honor #line directives. */
6459 if (!no_line_directive
)
6461 static bool discard_until_line_directive
;
6463 /* Check whether this is a #line directive. */
6464 if (result
> 12 && strneq (lbp
->buffer
, "#line ", 6))
6469 if (sscanf (lbp
->buffer
, "#line %u \"%n", &lno
, &start
) >= 1
6470 && start
> 0) /* double quote character found */
6472 char *endp
= lbp
->buffer
+ start
;
6474 while ((endp
= strchr (endp
, '"')) != NULL
6475 && endp
[-1] == '\\')
6478 /* Ok, this is a real #line directive. Let's deal with it. */
6480 char *taggedabsname
; /* absolute name of original file */
6481 char *taggedfname
; /* name of original file as given */
6482 char *name
; /* temp var */
6484 discard_until_line_directive
= false; /* found it */
6485 name
= lbp
->buffer
+ start
;
6487 canonicalize_filename (name
);
6488 taggedabsname
= absolute_filename (name
, tagfiledir
);
6489 if (filename_is_absolute (name
)
6490 || filename_is_absolute (curfdp
->infname
))
6491 taggedfname
= savestr (taggedabsname
);
6493 taggedfname
= relative_filename (taggedabsname
,tagfiledir
);
6495 if (streq (curfdp
->taggedfname
, taggedfname
))
6496 /* The #line directive is only a line number change. We
6497 deal with this afterwards. */
6500 /* The tags following this #line directive should be
6501 attributed to taggedfname. In order to do this, set
6502 curfdp accordingly. */
6504 fdesc
*fdp
; /* file description pointer */
6506 /* Go look for a file description already set up for the
6507 file indicated in the #line directive. If there is
6508 one, use it from now until the next #line
6510 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6511 if (streq (fdp
->infname
, curfdp
->infname
)
6512 && streq (fdp
->taggedfname
, taggedfname
))
6513 /* If we remove the second test above (after the &&)
6514 then all entries pertaining to the same file are
6515 coalesced in the tags file. If we use it, then
6516 entries pertaining to the same file but generated
6517 from different files (via #line directives) will
6518 go into separate sections in the tags file. These
6519 alternatives look equivalent. The first one
6520 destroys some apparently useless information. */
6526 /* Else, if we already tagged the real file, skip all
6527 input lines until the next #line directive. */
6528 if (fdp
== NULL
) /* not found */
6529 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6530 if (streq (fdp
->infabsname
, taggedabsname
))
6532 discard_until_line_directive
= true;
6536 /* Else create a new file description and use that from
6537 now on, until the next #line directive. */
6538 if (fdp
== NULL
) /* not found */
6541 fdhead
= xnew (1, fdesc
);
6542 *fdhead
= *curfdp
; /* copy curr. file description */
6544 fdhead
->infname
= savestr (curfdp
->infname
);
6545 fdhead
->infabsname
= savestr (curfdp
->infabsname
);
6546 fdhead
->infabsdir
= savestr (curfdp
->infabsdir
);
6547 fdhead
->taggedfname
= taggedfname
;
6548 fdhead
->usecharno
= false;
6549 fdhead
->prop
= NULL
;
6550 fdhead
->written
= false;
6554 free (taggedabsname
);
6556 readline (lbp
, stream
);
6558 } /* if a real #line directive */
6559 } /* if #line is followed by a number */
6560 } /* if line begins with "#line " */
6562 /* If we are here, no #line directive was found. */
6563 if (discard_until_line_directive
)
6567 /* Do a tail recursion on ourselves, thus discarding the contents
6568 of the line buffer. */
6569 readline (lbp
, stream
);
6573 discard_until_line_directive
= false;
6576 } /* if #line directives should be considered */
6583 /* Match against relevant regexps. */
6585 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6587 /* Only use generic regexps or those for the current language.
6588 Also do not use multiline regexps, which is the job of
6589 regex_tag_multiline. */
6590 if ((rp
->lang
!= NULL
&& rp
->lang
!= fdhead
->lang
)
6594 match
= re_match (rp
->pat
, lbp
->buffer
, lbp
->len
, 0, &rp
->regs
);
6599 if (!rp
->error_signaled
)
6601 error ("regexp stack overflow while matching \"%s\"",
6603 rp
->error_signaled
= true;
6610 /* Empty string matched. */
6611 if (!rp
->error_signaled
)
6613 error ("regexp matches the empty string: \"%s\"", rp
->pattern
);
6614 rp
->error_signaled
= true;
6618 /* Match occurred. Construct a tag. */
6620 if (name
[0] == '\0')
6622 else /* make a named tag */
6623 name
= substitute (lbp
->buffer
, rp
->name
, &rp
->regs
);
6624 if (rp
->force_explicit_name
)
6625 /* Force explicit tag name, if a name is there. */
6626 pfnote (name
, true, lbp
->buffer
, match
, lineno
, linecharno
);
6628 make_tag (name
, strlen (name
), true,
6629 lbp
->buffer
, match
, lineno
, linecharno
);
6638 * Return a pointer to a space of size strlen(cp)+1 allocated
6639 * with xnew where the string CP has been copied.
6642 savestr (const char *cp
)
6644 return savenstr (cp
, strlen (cp
));
6648 * Return a pointer to a space of size LEN+1 allocated with xnew where
6649 * the string CP has been copied for at most the first LEN characters.
6652 savenstr (const char *cp
, int len
)
6654 char *dp
= xnew (len
+ 1, char);
6656 return memcpy (dp
, cp
, len
);
6659 /* Skip spaces (end of string is not space), return new pointer. */
6661 skip_spaces (char *cp
)
6663 while (c_isspace (*cp
))
6668 /* Skip non spaces, except end of string, return new pointer. */
6670 skip_non_spaces (char *cp
)
6672 while (*cp
!= '\0' && !c_isspace (*cp
))
6677 /* Skip any chars in the "name" class.*/
6679 skip_name (char *cp
)
6681 /* '\0' is a notinname() so loop stops there too */
6682 while (! notinname (*cp
))
6687 /* Print error message and exit. */
6689 fatal (char const *format
, ...)
6692 va_start (ap
, format
);
6693 verror (format
, ap
);
6695 exit (EXIT_FAILURE
);
6699 pfatal (const char *s1
)
6702 exit (EXIT_FAILURE
);
6706 suggest_asking_for_help (void)
6708 fprintf (stderr
, "\tTry '%s --help' for a complete list of options.\n",
6710 exit (EXIT_FAILURE
);
6713 /* Output a diagnostic with printf-style FORMAT and args. */
6715 error (const char *format
, ...)
6718 va_start (ap
, format
);
6719 verror (format
, ap
);
6724 verror (char const *format
, va_list ap
)
6726 fprintf (stderr
, "%s: ", progname
);
6727 vfprintf (stderr
, format
, ap
);
6728 fprintf (stderr
, "\n");
6731 /* Return a newly-allocated string whose contents
6732 concatenate those of s1, s2, s3. */
6734 concat (const char *s1
, const char *s2
, const char *s3
)
6736 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
6737 char *result
= xnew (len1
+ len2
+ len3
+ 1, char);
6739 strcpy (result
, s1
);
6740 strcpy (result
+ len1
, s2
);
6741 strcpy (result
+ len1
+ len2
, s3
);
6747 /* Does the same work as the system V getcwd, but does not need to
6748 guess the buffer size in advance. */
6753 char *path
= xnew (bufsize
, char);
6755 while (getcwd (path
, bufsize
) == NULL
)
6757 if (errno
!= ERANGE
)
6761 path
= xnew (bufsize
, char);
6764 canonicalize_filename (path
);
6768 /* Return a newly allocated string containing a name of a temporary file. */
6772 const char *tmpdir
= getenv ("TMPDIR");
6773 const char *slash
= "/";
6775 #if MSDOS || defined (DOS_NT)
6777 tmpdir
= getenv ("TEMP");
6779 tmpdir
= getenv ("TMP");
6782 if (tmpdir
[strlen (tmpdir
) - 1] == '/'
6783 || tmpdir
[strlen (tmpdir
) - 1] == '\\')
6788 if (tmpdir
[strlen (tmpdir
) - 1] == '/')
6792 char *templt
= concat (tmpdir
, slash
, "etXXXXXX");
6793 int fd
= mkostemp (templt
, O_CLOEXEC
);
6794 if (fd
< 0 || close (fd
) != 0)
6796 int temp_errno
= errno
;
6802 #if defined (DOS_NT)
6803 /* The file name will be used in shell redirection, so it needs to have
6804 DOS-style backslashes, or else the Windows shell will barf. */
6806 for (p
= templt
; *p
; p
++)
6814 /* Return a newly allocated string containing the file name of FILE
6815 relative to the absolute directory DIR (which should end with a slash). */
6817 relative_filename (char *file
, char *dir
)
6819 char *fp
, *dp
, *afn
, *res
;
6822 /* Find the common root of file and dir (with a trailing slash). */
6823 afn
= absolute_filename (file
, cwd
);
6826 while (*fp
++ == *dp
++)
6828 fp
--, dp
--; /* back to the first differing char */
6830 if (fp
== afn
&& afn
[0] != '/') /* cannot build a relative name */
6833 do /* look at the equal chars until '/' */
6837 /* Build a sequence of "../" strings for the resulting relative file name. */
6839 while ((dp
= strchr (dp
+ 1, '/')) != NULL
)
6841 res
= xnew (3*i
+ strlen (fp
+ 1) + 1, char);
6844 z
= stpcpy (z
, "../");
6846 /* Add the file name relative to the common root of file and dir. */
6853 /* Return a newly allocated string containing the absolute file name
6854 of FILE given DIR (which should end with a slash). */
6856 absolute_filename (char *file
, char *dir
)
6858 char *slashp
, *cp
, *res
;
6860 if (filename_is_absolute (file
))
6861 res
= savestr (file
);
6863 /* We don't support non-absolute file names with a drive
6864 letter, like `d:NAME' (it's too much hassle). */
6865 else if (file
[1] == ':')
6866 fatal ("%s: relative file names with drive letters not supported", file
);
6869 res
= concat (dir
, file
, "");
6871 /* Delete the "/dirname/.." and "/." substrings. */
6872 slashp
= strchr (res
, '/');
6873 while (slashp
!= NULL
&& slashp
[0] != '\0')
6875 if (slashp
[1] == '.')
6877 if (slashp
[2] == '.'
6878 && (slashp
[3] == '/' || slashp
[3] == '\0'))
6883 while (cp
>= res
&& !filename_is_absolute (cp
));
6885 cp
= slashp
; /* the absolute name begins with "/.." */
6887 /* Under MSDOS and NT we get `d:/NAME' as absolute
6888 file name, so the luser could say `d:/../NAME'.
6889 We silently treat this as `d:/NAME'. */
6890 else if (cp
[0] != '/')
6893 memmove (cp
, slashp
+ 3, strlen (slashp
+ 2));
6897 else if (slashp
[2] == '/' || slashp
[2] == '\0')
6899 memmove (slashp
, slashp
+ 2, strlen (slashp
+ 1));
6904 slashp
= strchr (slashp
+ 1, '/');
6907 if (res
[0] == '\0') /* just a safety net: should never happen */
6910 return savestr ("/");
6916 /* Return a newly allocated string containing the absolute
6917 file name of dir where FILE resides given DIR (which should
6918 end with a slash). */
6920 absolute_dirname (char *file
, char *dir
)
6925 slashp
= strrchr (file
, '/');
6927 return savestr (dir
);
6930 res
= absolute_filename (file
, dir
);
6936 /* Whether the argument string is an absolute file name. The argument
6937 string must have been canonicalized with canonicalize_filename. */
6939 filename_is_absolute (char *fn
)
6941 return (fn
[0] == '/'
6943 || (c_isalpha (fn
[0]) && fn
[1] == ':' && fn
[2] == '/')
6948 /* Downcase DOS drive letter and collapse separators into single slashes.
6951 canonicalize_filename (register char *fn
)
6956 /* Canonicalize drive letter case. */
6957 if (c_isupper (fn
[0]) && fn
[1] == ':')
6958 fn
[0] = c_tolower (fn
[0]);
6960 /* Collapse multiple forward- and back-slashes into a single forward
6962 for (cp
= fn
; *cp
!= '\0'; cp
++, fn
++)
6963 if (*cp
== '/' || *cp
== '\\')
6966 while (cp
[1] == '/' || cp
[1] == '\\')
6974 /* Collapse multiple slashes into a single slash. */
6975 for (cp
= fn
; *cp
!= '\0'; cp
++, fn
++)
6979 while (cp
[1] == '/')
6985 #endif /* !DOS_NT */
6991 /* Initialize a linebuffer for use. */
6993 linebuffer_init (linebuffer
*lbp
)
6995 lbp
->size
= (DEBUG
) ? 3 : 200;
6996 lbp
->buffer
= xnew (lbp
->size
, char);
6997 lbp
->buffer
[0] = '\0';
7001 /* Set the minimum size of a string contained in a linebuffer. */
7003 linebuffer_setlen (linebuffer
*lbp
, int toksize
)
7005 while (lbp
->size
<= toksize
)
7008 xrnew (lbp
->buffer
, lbp
->size
, char);
7013 /* Like malloc but get fatal error if memory is exhausted. */
7015 xmalloc (size_t size
)
7017 void *result
= malloc (size
);
7019 fatal ("virtual memory exhausted");
7024 xrealloc (void *ptr
, size_t size
)
7026 void *result
= realloc (ptr
, size
);
7028 fatal ("virtual memory exhausted");
7034 * indent-tabs-mode: t
7037 * c-font-lock-extra-types: ("FILE" "bool" "language" "linebuffer" "fdesc" "node" "regexp")
7038 * c-file-style: "gnu"
7042 /* etags.c ends here */