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 (at
39 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'.\
684 \n(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, Java, and Perl.\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\".\n\
980 For Perl, this produces \"package::member\".");
981 puts ("-r REGEXP, --regex=REGEXP or --regex=@regexfile\n\
982 Make a tag for each line matching a regular expression pattern\n\
983 in the following files. {LANGUAGE}REGEXP uses REGEXP for LANGUAGE\n\
984 files only. REGEXFILE is a file containing one REGEXP per line.\n\
985 REGEXP takes the form /TAGREGEXP/TAGNAME/MODS, where TAGNAME/ is\n\
986 optional. The TAGREGEXP pattern is anchored (as if preceded by ^).");
987 puts (" If TAGNAME/ is present, the tags created are named.\n\
988 For example Tcl named tags can be created with:\n\
989 --regex=\"/proc[ \\t]+\\([^ \\t]+\\)/\\1/.\".\n\
990 MODS are optional one-letter modifiers: 'i' means to ignore case,\n\
991 'm' means to allow multi-line matches, 's' implies 'm' and\n\
992 causes dot to match any character, including newline.");
994 puts ("-R, --no-regex\n\
995 Don't create tags from regexps for the following files.");
997 puts ("-I, --ignore-indentation\n\
998 In C and C++ do not assume that a closing brace in the first\n\
999 column is the final brace of a function or structure definition.");
1001 puts ("-o FILE, --output=FILE\n\
1002 Write the tags to FILE.");
1004 puts ("--parse-stdin=NAME\n\
1005 Read from standard input and record tags as belonging to file NAME.");
1009 puts ("-t, --typedefs\n\
1010 Generate tag entries for C and Ada typedefs.");
1011 puts ("-T, --typedefs-and-c++\n\
1012 Generate tag entries for C typedefs, C struct/enum/union tags,\n\
1013 and C++ member functions.");
1017 puts ("-u, --update\n\
1018 Update the tag entries for the given files, leaving tag\n\
1019 entries for other files in place. Currently, this is\n\
1020 implemented by deleting the existing entries for the given\n\
1021 files and then rewriting the new entries at the end of the\n\
1022 tags file. It is often faster to simply rebuild the entire\n\
1023 tag file than to use this.");
1027 puts ("-v, --vgrind\n\
1028 Print on the standard output an index of items intended for\n\
1029 human consumption, similar to the output of vgrind. The index\n\
1030 is sorted, and gives the page number of each item.");
1032 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
1033 puts ("-w, --no-duplicates\n\
1034 Do not create duplicate tag entries, for compatibility with\n\
1035 traditional ctags.");
1037 if (PRINT_UNDOCUMENTED_OPTIONS_HELP
)
1038 puts ("-w, --no-warn\n\
1039 Suppress warning messages about duplicate tag entries.");
1041 puts ("-x, --cxref\n\
1042 Like --vgrind, but in the style of cxref, rather than vgrind.\n\
1043 The output uses line numbers instead of page numbers, but\n\
1044 beyond that the differences are cosmetic; try both to see\n\
1048 puts ("-V, --version\n\
1049 Print the version of the program.\n\
1051 Print this help message.\n\
1052 Followed by one or more '--language' options prints detailed\n\
1053 help about tag generation for the specified languages.");
1055 print_language_names ();
1058 puts ("Report bugs to bug-gnu-emacs@gnu.org");
1060 exit (EXIT_SUCCESS
);
1065 main (int argc
, char **argv
)
1068 unsigned int nincluded_files
;
1069 char **included_files
;
1070 argument
*argbuffer
;
1071 int current_arg
, file_count
;
1072 linebuffer filename_lb
;
1073 bool help_asked
= false;
1079 nincluded_files
= 0;
1080 included_files
= xnew (argc
, char *);
1084 /* Allocate enough no matter what happens. Overkill, but each one
1086 argbuffer
= xnew (argc
, argument
);
1089 * Always find typedefs and structure tags.
1090 * Also default to find macro constants, enum constants, struct
1091 * members and global variables. Do it for both etags and ctags.
1093 typedefs
= typedefs_or_cplusplus
= constantypedefs
= true;
1094 globals
= members
= true;
1096 /* When the optstring begins with a '-' getopt_long does not rearrange the
1097 non-options arguments to be at the end, but leaves them alone. */
1098 optstring
= concat ("-ac:Cf:Il:o:Qr:RSVhH",
1099 (CTAGS
) ? "BxdtTuvw" : "Di:",
1102 while ((opt
= getopt_long (argc
, argv
, optstring
, longopts
, NULL
)) != EOF
)
1106 /* If getopt returns 0, then it has already processed a
1107 long-named option. We should do nothing. */
1111 /* This means that a file name has been seen. Record it. */
1112 argbuffer
[current_arg
].arg_type
= at_filename
;
1113 argbuffer
[current_arg
].what
= optarg
;
1114 len
= strlen (optarg
);
1115 if (whatlen_max
< len
)
1122 /* Parse standard input. Idea by Vivek <vivek@etla.org>. */
1123 argbuffer
[current_arg
].arg_type
= at_stdin
;
1124 argbuffer
[current_arg
].what
= optarg
;
1125 len
= strlen (optarg
);
1126 if (whatlen_max
< len
)
1131 fatal ("cannot parse standard input more than once");
1132 parsing_stdin
= true;
1135 /* Common options. */
1136 case 'a': append_to_tagfile
= true; break;
1137 case 'C': cplusplus
= true; break;
1138 case 'f': /* for compatibility with old makefiles */
1142 error ("-o option may only be given once.");
1143 suggest_asking_for_help ();
1149 case 'S': /* for backward compatibility */
1150 ignoreindent
= true;
1154 language
*lang
= get_language_from_langname (optarg
);
1157 argbuffer
[current_arg
].lang
= lang
;
1158 argbuffer
[current_arg
].arg_type
= at_language
;
1164 /* Backward compatibility: support obsolete --ignore-case-regexp. */
1165 optarg
= concat (optarg
, "i", ""); /* memory leak here */
1168 argbuffer
[current_arg
].arg_type
= at_regexp
;
1169 argbuffer
[current_arg
].what
= optarg
;
1170 len
= strlen (optarg
);
1171 if (whatlen_max
< len
)
1176 argbuffer
[current_arg
].arg_type
= at_regexp
;
1177 argbuffer
[current_arg
].what
= NULL
;
1192 case 'D': constantypedefs
= false; break;
1193 case 'i': included_files
[nincluded_files
++] = optarg
; break;
1195 /* Ctags options. */
1196 case 'B': searchar
= '?'; break;
1197 case 'd': constantypedefs
= true; break;
1198 case 't': typedefs
= true; break;
1199 case 'T': typedefs
= typedefs_or_cplusplus
= true; break;
1200 case 'u': update
= true; break;
1201 case 'v': vgrind_style
= true; /*FALLTHRU*/
1202 case 'x': cxref_style
= true; break;
1203 case 'w': no_warnings
= true; break;
1205 suggest_asking_for_help ();
1209 /* No more options. Store the rest of arguments. */
1210 for (; optind
< argc
; optind
++)
1212 argbuffer
[current_arg
].arg_type
= at_filename
;
1213 argbuffer
[current_arg
].what
= argv
[optind
];
1214 len
= strlen (argv
[optind
]);
1215 if (whatlen_max
< len
)
1221 argbuffer
[current_arg
].arg_type
= at_end
;
1224 print_help (argbuffer
);
1227 if (nincluded_files
== 0 && file_count
== 0)
1229 error ("no input files specified.");
1230 suggest_asking_for_help ();
1234 if (tagfile
== NULL
)
1235 tagfile
= savestr (CTAGS
? "tags" : "TAGS");
1236 cwd
= etags_getcwd (); /* the current working directory */
1237 if (cwd
[strlen (cwd
) - 1] != '/')
1240 cwd
= concat (oldcwd
, "/", "");
1244 /* Compute base directory for relative file names. */
1245 if (streq (tagfile
, "-")
1246 || strneq (tagfile
, "/dev/", 5))
1247 tagfiledir
= cwd
; /* relative file names are relative to cwd */
1250 canonicalize_filename (tagfile
);
1251 tagfiledir
= absolute_dirname (tagfile
, cwd
);
1254 linebuffer_init (&lb
);
1255 linebuffer_init (&filename_lb
);
1256 linebuffer_init (&filebuf
);
1257 linebuffer_init (&token_name
);
1261 if (streq (tagfile
, "-"))
1264 SET_BINARY (fileno (stdout
));
1267 tagf
= fopen (tagfile
, append_to_tagfile
? "ab" : "wb");
1273 * Loop through files finding functions.
1275 for (i
= 0; i
< current_arg
; i
++)
1277 static language
*lang
; /* non-NULL if language is forced */
1280 switch (argbuffer
[i
].arg_type
)
1283 lang
= argbuffer
[i
].lang
;
1286 analyze_regex (argbuffer
[i
].what
);
1289 this_file
= argbuffer
[i
].what
;
1290 /* Input file named "-" means read file names from stdin
1291 (one per line) and use them. */
1292 if (streq (this_file
, "-"))
1295 fatal ("cannot parse standard input "
1296 "AND read file names from it");
1297 while (readline_internal (&filename_lb
, stdin
, "-") > 0)
1298 process_file_name (filename_lb
.buffer
, lang
);
1301 process_file_name (this_file
, lang
);
1304 this_file
= argbuffer
[i
].what
;
1305 process_file (stdin
, this_file
, lang
);
1308 error ("internal error: arg_type");
1314 free (filebuf
.buffer
);
1315 free (token_name
.buffer
);
1317 if (!CTAGS
|| cxref_style
)
1319 /* Write the remaining tags to tagf (ETAGS) or stdout (CXREF). */
1320 put_entries (nodehead
);
1321 free_tree (nodehead
);
1327 /* Output file entries that have no tags. */
1328 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1330 fprintf (tagf
, "\f\n%s,0\n", fdp
->taggedfname
);
1332 while (nincluded_files
-- > 0)
1333 fprintf (tagf
, "\f\n%s,include\n", *included_files
++);
1335 if (fclose (tagf
) == EOF
)
1339 exit (EXIT_SUCCESS
);
1342 /* From here on, we are in (CTAGS && !cxref_style) */
1346 xmalloc (strlen (tagfile
) + whatlen_max
+
1347 sizeof "mv..OTAGS;fgrep -v '\t\t' OTAGS >;rm OTAGS");
1348 for (i
= 0; i
< current_arg
; ++i
)
1350 switch (argbuffer
[i
].arg_type
)
1356 continue; /* the for loop */
1358 char *z
= stpcpy (cmd
, "mv ");
1359 z
= stpcpy (z
, tagfile
);
1360 z
= stpcpy (z
, " OTAGS;fgrep -v '\t");
1361 z
= stpcpy (z
, argbuffer
[i
].what
);
1362 z
= stpcpy (z
, "\t' OTAGS >");
1363 z
= stpcpy (z
, tagfile
);
1364 strcpy (z
, ";rm OTAGS");
1365 if (system (cmd
) != EXIT_SUCCESS
)
1366 fatal ("failed to execute shell command");
1369 append_to_tagfile
= true;
1372 tagf
= fopen (tagfile
, append_to_tagfile
? "ab" : "wb");
1375 put_entries (nodehead
); /* write all the tags (CTAGS) */
1376 free_tree (nodehead
);
1378 if (fclose (tagf
) == EOF
)
1382 if (append_to_tagfile
|| update
)
1384 char *cmd
= xmalloc (2 * strlen (tagfile
) + sizeof "sort -u -o..");
1385 /* Maybe these should be used:
1386 setenv ("LC_COLLATE", "C", 1);
1387 setenv ("LC_ALL", "C", 1); */
1388 char *z
= stpcpy (cmd
, "sort -u -o ");
1389 z
= stpcpy (z
, tagfile
);
1391 strcpy (z
, tagfile
);
1392 exit (system (cmd
));
1394 return EXIT_SUCCESS
;
1399 * Return a compressor given the file name. If EXTPTR is non-zero,
1400 * return a pointer into FILE where the compressor-specific
1401 * extension begins. If no compressor is found, NULL is returned
1402 * and EXTPTR is not significant.
1403 * Idea by Vladimir Alexiev <vladimir@cs.ualberta.ca> (1998)
1406 get_compressor_from_suffix (char *file
, char **extptr
)
1409 char *slash
, *suffix
;
1411 /* File has been processed by canonicalize_filename,
1412 so we don't need to consider backslashes on DOS_NT. */
1413 slash
= strrchr (file
, '/');
1414 suffix
= strrchr (file
, '.');
1415 if (suffix
== NULL
|| suffix
< slash
)
1420 /* Let those poor souls who live with DOS 8+3 file name limits get
1421 some solace by treating foo.cgz as if it were foo.c.gz, etc.
1422 Only the first do loop is run if not MSDOS */
1425 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1426 if (streq (compr
->suffix
, suffix
))
1429 break; /* do it only once: not really a loop */
1432 } while (*suffix
!= '\0');
1439 * Return a language given the name.
1442 get_language_from_langname (const char *name
)
1447 error ("empty language name");
1450 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1451 if (streq (name
, lang
->name
))
1453 error ("unknown language \"%s\"", name
);
1461 * Return a language given the interpreter name.
1464 get_language_from_interpreter (char *interpreter
)
1469 if (interpreter
== NULL
)
1471 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1472 if (lang
->interpreters
!= NULL
)
1473 for (iname
= lang
->interpreters
; *iname
!= NULL
; iname
++)
1474 if (streq (*iname
, interpreter
))
1483 * Return a language given the file name.
1486 get_language_from_filename (char *file
, int case_sensitive
)
1489 const char **name
, **ext
, *suffix
;
1492 /* Try whole file name first. */
1493 slash
= strrchr (file
, '/');
1497 else if (file
[0] && file
[1] == ':')
1500 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1501 if (lang
->filenames
!= NULL
)
1502 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
1503 if ((case_sensitive
)
1504 ? streq (*name
, file
)
1505 : strcaseeq (*name
, file
))
1508 /* If not found, try suffix after last dot. */
1509 suffix
= strrchr (file
, '.');
1513 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1514 if (lang
->suffixes
!= NULL
)
1515 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
1516 if ((case_sensitive
)
1517 ? streq (*ext
, suffix
)
1518 : strcaseeq (*ext
, suffix
))
1525 * This routine is called on each file argument.
1528 process_file_name (char *file
, language
*lang
)
1533 char *compressed_name
, *uncompressed_name
;
1534 char *ext
, *real_name
, *tmp_name
;
1537 canonicalize_filename (file
);
1538 if (streq (file
, tagfile
) && !streq (tagfile
, "-"))
1540 error ("skipping inclusion of %s in self.", file
);
1543 compr
= get_compressor_from_suffix (file
, &ext
);
1546 compressed_name
= file
;
1547 uncompressed_name
= savenstr (file
, ext
- file
);
1551 compressed_name
= NULL
;
1552 uncompressed_name
= file
;
1555 /* If the canonicalized uncompressed name
1556 has already been dealt with, skip it silently. */
1557 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1559 assert (fdp
->infname
!= NULL
);
1560 if (streq (uncompressed_name
, fdp
->infname
))
1564 inf
= fopen (file
, "r" FOPEN_BINARY
);
1569 int file_errno
= errno
;
1570 if (compressed_name
)
1572 /* Try with the given suffix. */
1573 inf
= fopen (uncompressed_name
, "r" FOPEN_BINARY
);
1575 real_name
= uncompressed_name
;
1579 /* Try all possible suffixes. */
1580 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1582 compressed_name
= concat (file
, ".", compr
->suffix
);
1583 inf
= fopen (compressed_name
, "r" FOPEN_BINARY
);
1586 real_name
= compressed_name
;
1591 char *suf
= compressed_name
+ strlen (file
);
1592 size_t suflen
= strlen (compr
->suffix
) + 1;
1593 for ( ; suf
[1]; suf
++, suflen
--)
1595 memmove (suf
, suf
+ 1, suflen
);
1596 inf
= fopen (compressed_name
, "r" FOPEN_BINARY
);
1599 real_name
= compressed_name
;
1606 free (compressed_name
);
1607 compressed_name
= NULL
;
1618 if (real_name
== compressed_name
)
1621 tmp_name
= etags_mktmp ();
1626 #if MSDOS || defined (DOS_NT)
1627 char *cmd1
= concat (compr
->command
, " \"", real_name
);
1628 char *cmd
= concat (cmd1
, "\" > ", tmp_name
);
1630 char *cmd1
= concat (compr
->command
, " '", real_name
);
1631 char *cmd
= concat (cmd1
, "' > ", tmp_name
);
1635 if (system (cmd
) == -1)
1642 inf
= fopen (tmp_name
, "r" FOPEN_BINARY
);
1656 process_file (inf
, uncompressed_name
, lang
);
1658 retval
= fclose (inf
);
1659 if (real_name
== compressed_name
)
1668 if (compressed_name
!= file
)
1669 free (compressed_name
);
1670 if (uncompressed_name
!= file
)
1671 free (uncompressed_name
);
1678 process_file (FILE *fh
, char *fn
, language
*lang
)
1680 static const fdesc emptyfdesc
;
1684 /* Create a new input file description entry. */
1685 fdp
= xnew (1, fdesc
);
1688 fdp
->infname
= savestr (fn
);
1690 fdp
->infabsname
= absolute_filename (fn
, cwd
);
1691 fdp
->infabsdir
= absolute_dirname (fn
, cwd
);
1692 if (filename_is_absolute (fn
))
1694 /* An absolute file name. Canonicalize it. */
1695 fdp
->taggedfname
= absolute_filename (fn
, NULL
);
1699 /* A file name relative to cwd. Make it relative
1700 to the directory of the tags file. */
1701 fdp
->taggedfname
= relative_filename (fn
, tagfiledir
);
1703 fdp
->usecharno
= true; /* use char position when making tags */
1705 fdp
->written
= false; /* not written on tags file yet */
1708 curfdp
= fdhead
; /* the current file description */
1712 /* If not Ctags, and if this is not metasource and if it contained no #line
1713 directives, we can write the tags and free all nodes pointing to
1716 && curfdp
->usecharno
/* no #line directives in this file */
1717 && !curfdp
->lang
->metasource
)
1721 /* Look for the head of the sublist relative to this file. See add_node
1722 for the structure of the node tree. */
1724 for (np
= nodehead
; np
!= NULL
; prev
= np
, np
= np
->left
)
1725 if (np
->fdp
== curfdp
)
1728 /* If we generated tags for this file, write and delete them. */
1731 /* This is the head of the last sublist, if any. The following
1732 instructions depend on this being true. */
1733 assert (np
->left
== NULL
);
1735 assert (fdhead
== curfdp
);
1736 assert (last_node
->fdp
== curfdp
);
1737 put_entries (np
); /* write tags for file curfdp->taggedfname */
1738 free_tree (np
); /* remove the written nodes */
1740 nodehead
= NULL
; /* no nodes left */
1742 prev
->left
= NULL
; /* delete the pointer to the sublist */
1748 reset_input (FILE *inf
)
1750 if (fseek (inf
, 0, SEEK_SET
) != 0)
1751 perror (infilename
);
1755 * This routine opens the specified file and calls the function
1756 * which finds the function and type definitions.
1759 find_entries (FILE *inf
)
1762 language
*lang
= curfdp
->lang
;
1763 Lang_function
*parser
= NULL
;
1765 /* If user specified a language, use it. */
1766 if (lang
!= NULL
&& lang
->function
!= NULL
)
1768 parser
= lang
->function
;
1771 /* Else try to guess the language given the file name. */
1774 lang
= get_language_from_filename (curfdp
->infname
, true);
1775 if (lang
!= NULL
&& lang
->function
!= NULL
)
1777 curfdp
->lang
= lang
;
1778 parser
= lang
->function
;
1782 /* Else look for sharp-bang as the first two characters. */
1784 && readline_internal (&lb
, inf
, infilename
) > 0
1786 && lb
.buffer
[0] == '#'
1787 && lb
.buffer
[1] == '!')
1791 /* Set lp to point at the first char after the last slash in the
1792 line or, if no slashes, at the first nonblank. Then set cp to
1793 the first successive blank and terminate the string. */
1794 lp
= strrchr (lb
.buffer
+2, '/');
1798 lp
= skip_spaces (lb
.buffer
+ 2);
1799 cp
= skip_non_spaces (lp
);
1802 if (strlen (lp
) > 0)
1804 lang
= get_language_from_interpreter (lp
);
1805 if (lang
!= NULL
&& lang
->function
!= NULL
)
1807 curfdp
->lang
= lang
;
1808 parser
= lang
->function
;
1815 /* Else try to guess the language given the case insensitive file name. */
1818 lang
= get_language_from_filename (curfdp
->infname
, false);
1819 if (lang
!= NULL
&& lang
->function
!= NULL
)
1821 curfdp
->lang
= lang
;
1822 parser
= lang
->function
;
1826 /* Else try Fortran or C. */
1829 node
*old_last_node
= last_node
;
1831 curfdp
->lang
= get_language_from_langname ("fortran");
1834 if (old_last_node
== last_node
)
1835 /* No Fortran entries found. Try C. */
1838 curfdp
->lang
= get_language_from_langname (cplusplus
? "c++" : "c");
1844 if (!no_line_directive
1845 && curfdp
->lang
!= NULL
&& curfdp
->lang
->metasource
)
1846 /* It may be that this is a bingo.y file, and we already parsed a bingo.c
1847 file, or anyway we parsed a file that is automatically generated from
1848 this one. If this is the case, the bingo.c file contained #line
1849 directives that generated tags pointing to this file. Let's delete
1850 them all before parsing this file, which is the real source. */
1852 fdesc
**fdpp
= &fdhead
;
1853 while (*fdpp
!= NULL
)
1855 && streq ((*fdpp
)->taggedfname
, curfdp
->taggedfname
))
1856 /* We found one of those! We must delete both the file description
1857 and all tags referring to it. */
1859 fdesc
*badfdp
= *fdpp
;
1861 /* Delete the tags referring to badfdp->taggedfname
1862 that were obtained from badfdp->infname. */
1863 invalidate_nodes (badfdp
, &nodehead
);
1865 *fdpp
= badfdp
->next
; /* remove the bad description from the list */
1866 free_fdesc (badfdp
);
1869 fdpp
= &(*fdpp
)->next
; /* advance the list pointer */
1872 assert (parser
!= NULL
);
1874 /* Generic initializations before reading from file. */
1875 linebuffer_setlen (&filebuf
, 0); /* reset the file buffer */
1877 /* Generic initializations before parsing file with readline. */
1878 lineno
= 0; /* reset global line number */
1879 charno
= 0; /* reset global char number */
1880 linecharno
= 0; /* reset global char number of line start */
1884 regex_tag_multiline ();
1889 * Check whether an implicitly named tag should be created,
1890 * then call `pfnote'.
1891 * NAME is a string that is internally copied by this function.
1893 * TAGS format specification
1894 * Idea by Sam Kendall <kendall@mv.mv.com> (1997)
1895 * The following is explained in some more detail in etc/ETAGS.EBNF.
1897 * make_tag creates tags with "implicit tag names" (unnamed tags)
1898 * if the following are all true, assuming NONAM=" \f\t\n\r()=,;":
1899 * 1. NAME does not contain any of the characters in NONAM;
1900 * 2. LINESTART contains name as either a rightmost, or rightmost but
1901 * one character, substring;
1902 * 3. the character, if any, immediately before NAME in LINESTART must
1903 * be a character in NONAM;
1904 * 4. the character, if any, immediately after NAME in LINESTART must
1905 * also be a character in NONAM.
1907 * The implementation uses the notinname() macro, which recognizes the
1908 * characters stored in the string `nonam'.
1909 * etags.el needs to use the same characters that are in NONAM.
1912 make_tag (const char *name
, /* tag name, or NULL if unnamed */
1913 int namelen
, /* tag length */
1914 bool is_func
, /* tag is a function */
1915 char *linestart
, /* start of the line where tag is */
1916 int linelen
, /* length of the line where tag is */
1917 int lno
, /* line number */
1918 long int cno
) /* character number */
1920 bool named
= (name
!= NULL
&& namelen
> 0);
1923 if (!CTAGS
&& named
) /* maybe set named to false */
1924 /* Let's try to make an implicit tag name, that is, create an unnamed tag
1925 such that etags.el can guess a name from it. */
1928 register const char *cp
= name
;
1930 for (i
= 0; i
< namelen
; i
++)
1931 if (notinname (*cp
++))
1933 if (i
== namelen
) /* rule #1 */
1935 cp
= linestart
+ linelen
- namelen
;
1936 if (notinname (linestart
[linelen
-1]))
1937 cp
-= 1; /* rule #4 */
1938 if (cp
>= linestart
/* rule #2 */
1940 || notinname (cp
[-1])) /* rule #3 */
1941 && strneq (name
, cp
, namelen
)) /* rule #2 */
1942 named
= false; /* use implicit tag name */
1947 nname
= savenstr (name
, namelen
);
1949 pfnote (nname
, is_func
, linestart
, linelen
, lno
, cno
);
1954 pfnote (char *name
, bool is_func
, char *linestart
, int linelen
, int lno
,
1956 /* tag name, or NULL if unnamed */
1957 /* tag is a function */
1958 /* start of the line where tag is */
1959 /* length of the line where tag is */
1961 /* character number */
1965 assert (name
== NULL
|| name
[0] != '\0');
1966 if (CTAGS
&& name
== NULL
)
1969 np
= xnew (1, node
);
1971 /* If ctags mode, change name "main" to M<thisfilename>. */
1972 if (CTAGS
&& !cxref_style
&& streq (name
, "main"))
1974 char *fp
= strrchr (curfdp
->taggedfname
, '/');
1975 np
->name
= concat ("M", fp
== NULL
? curfdp
->taggedfname
: fp
+ 1, "");
1976 fp
= strrchr (np
->name
, '.');
1977 if (fp
!= NULL
&& fp
[1] != '\0' && fp
[2] == '\0')
1983 np
->been_warned
= false;
1985 np
->is_func
= is_func
;
1987 if (np
->fdp
->usecharno
)
1988 /* Our char numbers are 0-base, because of C language tradition?
1989 ctags compatibility? old versions compatibility? I don't know.
1990 Anyway, since emacs's are 1-base we expect etags.el to take care
1991 of the difference. If we wanted to have 1-based numbers, we would
1992 uncomment the +1 below. */
1993 np
->cno
= cno
/* + 1 */ ;
1995 np
->cno
= invalidcharno
;
1996 np
->left
= np
->right
= NULL
;
1997 if (CTAGS
&& !cxref_style
)
1999 if (strlen (linestart
) < 50)
2000 np
->regex
= concat (linestart
, "$", "");
2002 np
->regex
= savenstr (linestart
, 50);
2005 np
->regex
= savenstr (linestart
, linelen
);
2007 add_node (np
, &nodehead
);
2012 * recurse on left children, iterate on right children.
2015 free_tree (register node
*np
)
2019 register node
*node_right
= np
->right
;
2020 free_tree (np
->left
);
2030 * delete a file description
2033 free_fdesc (register fdesc
*fdp
)
2035 free (fdp
->infname
);
2036 free (fdp
->infabsname
);
2037 free (fdp
->infabsdir
);
2038 free (fdp
->taggedfname
);
2045 * Adds a node to the tree of nodes. In etags mode, sort by file
2046 * name. In ctags mode, sort by tag name. Make no attempt at
2049 * add_node is the only function allowed to add nodes, so it can
2053 add_node (node
*np
, node
**cur_node_p
)
2056 register node
*cur_node
= *cur_node_p
;
2058 if (cur_node
== NULL
)
2068 /* For each file name, tags are in a linked sublist on the right
2069 pointer. The first tags of different files are a linked list
2070 on the left pointer. last_node points to the end of the last
2072 if (last_node
!= NULL
&& last_node
->fdp
== np
->fdp
)
2074 /* Let's use the same sublist as the last added node. */
2075 assert (last_node
->right
== NULL
);
2076 last_node
->right
= np
;
2079 else if (cur_node
->fdp
== np
->fdp
)
2081 /* Scanning the list we found the head of a sublist which is
2082 good for us. Let's scan this sublist. */
2083 add_node (np
, &cur_node
->right
);
2086 /* The head of this sublist is not good for us. Let's try the
2088 add_node (np
, &cur_node
->left
);
2089 } /* if ETAGS mode */
2094 dif
= strcmp (np
->name
, cur_node
->name
);
2097 * If this tag name matches an existing one, then
2098 * do not add the node, but maybe print a warning.
2100 if (no_duplicates
&& !dif
)
2102 if (np
->fdp
== cur_node
->fdp
)
2106 fprintf (stderr
, "Duplicate entry in file %s, line %d: %s\n",
2107 np
->fdp
->infname
, lineno
, np
->name
);
2108 fprintf (stderr
, "Second entry ignored\n");
2111 else if (!cur_node
->been_warned
&& !no_warnings
)
2115 "Duplicate entry in files %s and %s: %s (Warning only)\n",
2116 np
->fdp
->infname
, cur_node
->fdp
->infname
, np
->name
);
2117 cur_node
->been_warned
= true;
2122 /* Actually add the node */
2123 add_node (np
, dif
< 0 ? &cur_node
->left
: &cur_node
->right
);
2124 } /* if CTAGS mode */
2128 * invalidate_nodes ()
2129 * Scan the node tree and invalidate all nodes pointing to the
2130 * given file description (CTAGS case) or free them (ETAGS case).
2133 invalidate_nodes (fdesc
*badfdp
, node
**npp
)
2142 if (np
->left
!= NULL
)
2143 invalidate_nodes (badfdp
, &np
->left
);
2144 if (np
->fdp
== badfdp
)
2146 if (np
->right
!= NULL
)
2147 invalidate_nodes (badfdp
, &np
->right
);
2151 assert (np
->fdp
!= NULL
);
2152 if (np
->fdp
== badfdp
)
2154 *npp
= np
->left
; /* detach the sublist from the list */
2155 np
->left
= NULL
; /* isolate it */
2156 free_tree (np
); /* free it */
2157 invalidate_nodes (badfdp
, npp
);
2160 invalidate_nodes (badfdp
, &np
->left
);
2165 static int total_size_of_entries (node
*);
2166 static int number_len (long) ATTRIBUTE_CONST
;
2168 /* Length of a non-negative number's decimal representation. */
2170 number_len (long int num
)
2173 while ((num
/= 10) > 0)
2179 * Return total number of characters that put_entries will output for
2180 * the nodes in the linked list at the right of the specified node.
2181 * This count is irrelevant with etags.el since emacs 19.34 at least,
2182 * but is still supplied for backward compatibility.
2185 total_size_of_entries (register node
*np
)
2187 register int total
= 0;
2189 for (; np
!= NULL
; np
= np
->right
)
2192 total
+= strlen (np
->regex
) + 1; /* pat\177 */
2193 if (np
->name
!= NULL
)
2194 total
+= strlen (np
->name
) + 1; /* name\001 */
2195 total
+= number_len ((long) np
->lno
) + 1; /* lno, */
2196 if (np
->cno
!= invalidcharno
) /* cno */
2197 total
+= number_len (np
->cno
);
2198 total
+= 1; /* newline */
2205 put_entries (register node
*np
)
2208 static fdesc
*fdp
= NULL
;
2213 /* Output subentries that precede this one */
2215 put_entries (np
->left
);
2217 /* Output this entry */
2226 fprintf (tagf
, "\f\n%s,%d\n",
2227 fdp
->taggedfname
, total_size_of_entries (np
));
2228 fdp
->written
= true;
2230 fputs (np
->regex
, tagf
);
2231 fputc ('\177', tagf
);
2232 if (np
->name
!= NULL
)
2234 fputs (np
->name
, tagf
);
2235 fputc ('\001', tagf
);
2237 fprintf (tagf
, "%d,", np
->lno
);
2238 if (np
->cno
!= invalidcharno
)
2239 fprintf (tagf
, "%ld", np
->cno
);
2245 if (np
->name
== NULL
)
2246 error ("internal error: NULL name in ctags mode.");
2251 fprintf (stdout
, "%s %s %d\n",
2252 np
->name
, np
->fdp
->taggedfname
, (np
->lno
+ 63) / 64);
2254 fprintf (stdout
, "%-16s %3d %-16s %s\n",
2255 np
->name
, np
->lno
, np
->fdp
->taggedfname
, np
->regex
);
2259 fprintf (tagf
, "%s\t%s\t", np
->name
, np
->fdp
->taggedfname
);
2262 { /* function or #define macro with args */
2263 putc (searchar
, tagf
);
2266 for (sp
= np
->regex
; *sp
; sp
++)
2268 if (*sp
== '\\' || *sp
== searchar
)
2272 putc (searchar
, tagf
);
2275 { /* anything else; text pattern inadequate */
2276 fprintf (tagf
, "%d", np
->lno
);
2281 } /* if this node contains a valid tag */
2283 /* Output subentries that follow this one */
2284 put_entries (np
->right
);
2286 put_entries (np
->left
);
2291 #define C_EXT 0x00fff /* C extensions */
2292 #define C_PLAIN 0x00000 /* C */
2293 #define C_PLPL 0x00001 /* C++ */
2294 #define C_STAR 0x00003 /* C* */
2295 #define C_JAVA 0x00005 /* JAVA */
2296 #define C_AUTO 0x01000 /* C, but switch to C++ if `class' is met */
2297 #define YACC 0x10000 /* yacc file */
2300 * The C symbol tables.
2305 st_C_objprot
, st_C_objimpl
, st_C_objend
,
2307 st_C_ignore
, st_C_attribute
,
2310 st_C_class
, st_C_template
,
2311 st_C_struct
, st_C_extern
, st_C_enum
, st_C_define
, st_C_typedef
2314 /* Feed stuff between (but not including) %[ and %] lines to:
2320 struct C_stab_entry { char *name; int c_ext; enum sym_type type; }
2324 while, 0, st_C_ignore
2325 switch, 0, st_C_ignore
2326 return, 0, st_C_ignore
2327 __attribute__, 0, st_C_attribute
2328 GTY, 0, st_C_attribute
2329 @interface, 0, st_C_objprot
2330 @protocol, 0, st_C_objprot
2331 @implementation,0, st_C_objimpl
2332 @end, 0, st_C_objend
2333 import, (C_JAVA & ~C_PLPL), st_C_ignore
2334 package, (C_JAVA & ~C_PLPL), st_C_ignore
2335 friend, C_PLPL, st_C_ignore
2336 extends, (C_JAVA & ~C_PLPL), st_C_javastruct
2337 implements, (C_JAVA & ~C_PLPL), st_C_javastruct
2338 interface, (C_JAVA & ~C_PLPL), st_C_struct
2339 class, 0, st_C_class
2340 namespace, C_PLPL, st_C_struct
2341 domain, C_STAR, st_C_struct
2342 union, 0, st_C_struct
2343 struct, 0, st_C_struct
2344 extern, 0, st_C_extern
2346 typedef, 0, st_C_typedef
2347 define, 0, st_C_define
2348 undef, 0, st_C_define
2349 operator, C_PLPL, st_C_operator
2350 template, 0, st_C_template
2351 # DEFUN used in emacs, the next three used in glibc (SYSCALL only for mach).
2352 DEFUN, 0, st_C_gnumacro
2353 SYSCALL, 0, st_C_gnumacro
2354 ENTRY, 0, st_C_gnumacro
2355 PSEUDO, 0, st_C_gnumacro
2356 # These are defined inside C functions, so currently they are not met.
2357 # EXFUN used in glibc, DEFVAR_* in emacs.
2358 #EXFUN, 0, st_C_gnumacro
2359 #DEFVAR_, 0, st_C_gnumacro
2361 and replace lines between %< and %> with its output, then:
2362 - remove the #if characterset check
2363 - make in_word_set static and not inline. */
2365 /* C code produced by gperf version 3.0.1 */
2366 /* Command-line: gperf -m 5 */
2367 /* Computed positions: -k'2-3' */
2369 struct C_stab_entry
{ const char *name
; int c_ext
; enum sym_type type
; };
2370 /* maximum key range = 33, duplicates = 0 */
2373 hash (const char *str
, int len
)
2375 static char const asso_values
[] =
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, 35,
2383 35, 35, 35, 35, 35, 35, 35, 35, 35, 3,
2384 26, 35, 35, 35, 35, 35, 35, 35, 27, 35,
2385 35, 35, 35, 24, 0, 35, 35, 35, 35, 0,
2386 35, 35, 35, 35, 35, 1, 35, 16, 35, 6,
2387 23, 0, 0, 35, 22, 0, 35, 35, 5, 0,
2388 0, 15, 1, 35, 6, 35, 8, 19, 35, 16,
2389 4, 5, 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, 35, 35, 35, 35,
2402 35, 35, 35, 35, 35, 35
2409 hval
+= asso_values
[(unsigned char) str
[2]];
2412 hval
+= asso_values
[(unsigned char) str
[1]];
2418 static struct C_stab_entry
*
2419 in_word_set (register const char *str
, register unsigned int len
)
2423 TOTAL_KEYWORDS
= 33,
2424 MIN_WORD_LENGTH
= 2,
2425 MAX_WORD_LENGTH
= 15,
2430 static struct C_stab_entry wordlist
[] =
2433 {"if", 0, st_C_ignore
},
2434 {"GTY", 0, st_C_attribute
},
2435 {"@end", 0, st_C_objend
},
2436 {"union", 0, st_C_struct
},
2437 {"define", 0, st_C_define
},
2438 {"import", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2439 {"template", 0, st_C_template
},
2440 {"operator", C_PLPL
, st_C_operator
},
2441 {"@interface", 0, st_C_objprot
},
2442 {"implements", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2443 {"friend", C_PLPL
, st_C_ignore
},
2444 {"typedef", 0, st_C_typedef
},
2445 {"return", 0, st_C_ignore
},
2446 {"@implementation",0, st_C_objimpl
},
2447 {"@protocol", 0, st_C_objprot
},
2448 {"interface", (C_JAVA
& ~C_PLPL
), st_C_struct
},
2449 {"extern", 0, st_C_extern
},
2450 {"extends", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2451 {"struct", 0, st_C_struct
},
2452 {"domain", C_STAR
, st_C_struct
},
2453 {"switch", 0, st_C_ignore
},
2454 {"enum", 0, st_C_enum
},
2455 {"for", 0, st_C_ignore
},
2456 {"namespace", C_PLPL
, st_C_struct
},
2457 {"class", 0, st_C_class
},
2458 {"while", 0, st_C_ignore
},
2459 {"undef", 0, st_C_define
},
2460 {"package", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2461 {"__attribute__", 0, st_C_attribute
},
2462 {"SYSCALL", 0, st_C_gnumacro
},
2463 {"ENTRY", 0, st_C_gnumacro
},
2464 {"PSEUDO", 0, st_C_gnumacro
},
2465 {"DEFUN", 0, st_C_gnumacro
}
2468 if (len
<= MAX_WORD_LENGTH
&& len
>= MIN_WORD_LENGTH
)
2470 int key
= hash (str
, len
);
2472 if (key
<= MAX_HASH_VALUE
&& key
>= 0)
2474 const char *s
= wordlist
[key
].name
;
2476 if (*str
== *s
&& !strncmp (str
+ 1, s
+ 1, len
- 1) && s
[len
] == '\0')
2477 return &wordlist
[key
];
2484 static enum sym_type
2485 C_symtype (char *str
, int len
, int c_ext
)
2487 register struct C_stab_entry
*se
= in_word_set (str
, len
);
2489 if (se
== NULL
|| (se
->c_ext
&& !(c_ext
& se
->c_ext
)))
2496 * Ignoring __attribute__ ((list))
2498 static bool inattribute
; /* looking at an __attribute__ construct */
2501 * C functions and variables are recognized using a simple
2502 * finite automaton. fvdef is its state variable.
2506 fvnone
, /* nothing seen */
2507 fdefunkey
, /* Emacs DEFUN keyword seen */
2508 fdefunname
, /* Emacs DEFUN name seen */
2509 foperator
, /* func: operator keyword seen (cplpl) */
2510 fvnameseen
, /* function or variable name seen */
2511 fstartlist
, /* func: just after open parenthesis */
2512 finlist
, /* func: in parameter list */
2513 flistseen
, /* func: after parameter list */
2514 fignore
, /* func: before open brace */
2515 vignore
/* var-like: ignore until ';' */
2518 static bool fvextern
; /* func or var: extern keyword seen; */
2521 * typedefs are recognized using a simple finite automaton.
2522 * typdef is its state variable.
2526 tnone
, /* nothing seen */
2527 tkeyseen
, /* typedef keyword seen */
2528 ttypeseen
, /* defined type seen */
2529 tinbody
, /* inside typedef body */
2530 tend
, /* just before typedef tag */
2531 tignore
/* junk after typedef tag */
2535 * struct-like structures (enum, struct and union) are recognized
2536 * using another simple finite automaton. `structdef' is its state
2541 snone
, /* nothing seen yet,
2542 or in struct body if bracelev > 0 */
2543 skeyseen
, /* struct-like keyword seen */
2544 stagseen
, /* struct-like tag seen */
2545 scolonseen
/* colon seen after struct-like tag */
2549 * When objdef is different from onone, objtag is the name of the class.
2551 static const char *objtag
= "<uninited>";
2554 * Yet another little state machine to deal with preprocessor lines.
2558 dnone
, /* nothing seen */
2559 dsharpseen
, /* '#' seen as first char on line */
2560 ddefineseen
, /* '#' and 'define' seen */
2561 dignorerest
/* ignore rest of line */
2565 * State machine for Objective C protocols and implementations.
2566 * Idea by Tom R.Hageman <tom@basil.icce.rug.nl> (1995)
2570 onone
, /* nothing seen */
2571 oprotocol
, /* @interface or @protocol seen */
2572 oimplementation
, /* @implementations seen */
2573 otagseen
, /* class name seen */
2574 oparenseen
, /* parenthesis before category seen */
2575 ocatseen
, /* category name seen */
2576 oinbody
, /* in @implementation body */
2577 omethodsign
, /* in @implementation body, after +/- */
2578 omethodtag
, /* after method name */
2579 omethodcolon
, /* after method colon */
2580 omethodparm
, /* after method parameter */
2581 oignore
/* wait for @end */
2586 * Use this structure to keep info about the token read, and how it
2587 * should be tagged. Used by the make_C_tag function to build a tag.
2591 char *line
; /* string containing the token */
2592 int offset
; /* where the token starts in LINE */
2593 int length
; /* token length */
2595 The previous members can be used to pass strings around for generic
2596 purposes. The following ones specifically refer to creating tags. In this
2597 case the token contained here is the pattern that will be used to create a
2600 bool valid
; /* do not create a tag; the token should be
2601 invalidated whenever a state machine is
2602 reset prematurely */
2603 bool named
; /* create a named tag */
2604 int lineno
; /* source line number of tag */
2605 long linepos
; /* source char number of tag */
2606 } token
; /* latest token read */
2609 * Variables and functions for dealing with nested structures.
2610 * Idea by Mykola Dzyuba <mdzyuba@yahoo.com> (2001)
2612 static void pushclass_above (int, char *, int);
2613 static void popclass_above (int);
2614 static void write_classname (linebuffer
*, const char *qualifier
);
2617 char **cname
; /* nested class names */
2618 int *bracelev
; /* nested class brace level */
2619 int nl
; /* class nesting level (elements used) */
2620 int size
; /* length of the array */
2621 } cstack
; /* stack for nested declaration tags */
2622 /* Current struct nesting depth (namespace, class, struct, union, enum). */
2623 #define nestlev (cstack.nl)
2624 /* After struct keyword or in struct body, not inside a nested function. */
2625 #define instruct (structdef == snone && nestlev > 0 \
2626 && bracelev == cstack.bracelev[nestlev-1] + 1)
2629 pushclass_above (int bracelev
, char *str
, int len
)
2633 popclass_above (bracelev
);
2635 if (nl
>= cstack
.size
)
2637 int size
= cstack
.size
*= 2;
2638 xrnew (cstack
.cname
, size
, char *);
2639 xrnew (cstack
.bracelev
, size
, int);
2641 assert (nl
== 0 || cstack
.bracelev
[nl
-1] < bracelev
);
2642 cstack
.cname
[nl
] = (str
== NULL
) ? NULL
: savenstr (str
, len
);
2643 cstack
.bracelev
[nl
] = bracelev
;
2648 popclass_above (int bracelev
)
2652 for (nl
= cstack
.nl
- 1;
2653 nl
>= 0 && cstack
.bracelev
[nl
] >= bracelev
;
2656 free (cstack
.cname
[nl
]);
2662 write_classname (linebuffer
*cn
, const char *qualifier
)
2665 int qlen
= strlen (qualifier
);
2667 if (cstack
.nl
== 0 || cstack
.cname
[0] == NULL
)
2671 cn
->buffer
[0] = '\0';
2675 len
= strlen (cstack
.cname
[0]);
2676 linebuffer_setlen (cn
, len
);
2677 strcpy (cn
->buffer
, cstack
.cname
[0]);
2679 for (i
= 1; i
< cstack
.nl
; i
++)
2681 char *s
= cstack
.cname
[i
];
2684 linebuffer_setlen (cn
, len
+ qlen
+ strlen (s
));
2685 len
+= sprintf (cn
->buffer
+ len
, "%s%s", qualifier
, s
);
2690 static bool consider_token (char *, int, int, int *, int, int, bool *);
2691 static void make_C_tag (bool);
2695 * checks to see if the current token is at the start of a
2696 * function or variable, or corresponds to a typedef, or
2697 * is a struct/union/enum tag, or #define, or an enum constant.
2699 * *IS_FUNC_OR_VAR gets true if the token is a function or #define macro
2700 * with args. C_EXTP points to which language we are looking at.
2711 consider_token (char *str
, int len
, int c
, int *c_extp
,
2712 int bracelev
, int parlev
, bool *is_func_or_var
)
2713 /* IN: token pointer */
2714 /* IN: token length */
2715 /* IN: first char after the token */
2716 /* IN, OUT: C extensions mask */
2717 /* IN: brace level */
2718 /* IN: parenthesis level */
2719 /* OUT: function or variable found */
2721 /* When structdef is stagseen, scolonseen, or snone with bracelev > 0,
2722 structtype is the type of the preceding struct-like keyword, and
2723 structbracelev is the brace level where it has been seen. */
2724 static enum sym_type structtype
;
2725 static int structbracelev
;
2726 static enum sym_type toktype
;
2729 toktype
= C_symtype (str
, len
, *c_extp
);
2732 * Skip __attribute__
2734 if (toktype
== st_C_attribute
)
2741 * Advance the definedef state machine.
2746 /* We're not on a preprocessor line. */
2747 if (toktype
== st_C_gnumacro
)
2754 if (toktype
== st_C_define
)
2756 definedef
= ddefineseen
;
2760 definedef
= dignorerest
;
2765 * Make a tag for any macro, unless it is a constant
2766 * and constantypedefs is false.
2768 definedef
= dignorerest
;
2769 *is_func_or_var
= (c
== '(');
2770 if (!*is_func_or_var
&& !constantypedefs
)
2777 error ("internal error: definedef value.");
2786 if (toktype
== st_C_typedef
)
2809 if (structdef
== snone
&& fvdef
== fvnone
)
2831 case st_C_javastruct
:
2832 if (structdef
== stagseen
)
2833 structdef
= scolonseen
;
2837 if ((*c_extp
& C_AUTO
) /* automatic detection of C++ language */
2839 && definedef
== dnone
&& structdef
== snone
2840 && typdef
== tnone
&& fvdef
== fvnone
)
2841 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
2842 if (toktype
== st_C_template
)
2849 && (typdef
== tkeyseen
2850 || (typedefs_or_cplusplus
&& structdef
== snone
)))
2852 structdef
= skeyseen
;
2853 structtype
= toktype
;
2854 structbracelev
= bracelev
;
2855 if (fvdef
== fvnameseen
)
2863 if (structdef
== skeyseen
)
2865 structdef
= stagseen
;
2869 if (typdef
!= tnone
)
2872 /* Detect Objective C constructs. */
2882 objdef
= oimplementation
;
2888 case oimplementation
:
2889 /* Save the class tag for functions or variables defined inside. */
2890 objtag
= savenstr (str
, len
);
2894 /* Save the class tag for categories. */
2895 objtag
= savenstr (str
, len
);
2897 *is_func_or_var
= true;
2901 *is_func_or_var
= true;
2909 objdef
= omethodtag
;
2910 linebuffer_setlen (&token_name
, len
);
2911 memcpy (token_name
.buffer
, str
, len
);
2912 token_name
.buffer
[len
] = '\0';
2918 objdef
= omethodparm
;
2923 objdef
= omethodtag
;
2926 int oldlen
= token_name
.len
;
2928 linebuffer_setlen (&token_name
, oldlen
+ len
);
2929 memcpy (token_name
.buffer
+ oldlen
, str
, len
);
2930 token_name
.buffer
[oldlen
+ len
] = '\0';
2936 if (toktype
== st_C_objend
)
2938 /* Memory leakage here: the string pointed by objtag is
2939 never released, because many tests would be needed to
2940 avoid breaking on incorrect input code. The amount of
2941 memory leaked here is the sum of the lengths of the
2951 /* A function, variable or enum constant? */
2973 *is_func_or_var
= true;
2977 && structdef
== snone
2978 && structtype
== st_C_enum
&& bracelev
> structbracelev
2979 /* Don't tag tokens in expressions that assign values to enum
2981 && fvdef
!= vignore
)
2982 return true; /* enum constant */
2988 fvdef
= fdefunname
; /* GNU macro */
2989 *is_func_or_var
= true;
2997 if ((strneq (str
, "asm", 3) && endtoken (str
[3]))
2998 || (strneq (str
, "__asm__", 7) && endtoken (str
[7])))
3009 if (len
>= 10 && strneq (str
+len
-10, "::operator", 10))
3011 if (*c_extp
& C_AUTO
) /* automatic detection of C++ */
3012 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
3014 *is_func_or_var
= true;
3017 if (bracelev
> 0 && !instruct
)
3019 fvdef
= fvnameseen
; /* function or variable */
3020 *is_func_or_var
= true;
3035 * C_entries often keeps pointers to tokens or lines which are older than
3036 * the line currently read. By keeping two line buffers, and switching
3037 * them at end of line, it is possible to use those pointers.
3045 #define current_lb_is_new (newndx == curndx)
3046 #define switch_line_buffers() (curndx = 1 - curndx)
3048 #define curlb (lbs[curndx].lb)
3049 #define newlb (lbs[newndx].lb)
3050 #define curlinepos (lbs[curndx].linepos)
3051 #define newlinepos (lbs[newndx].linepos)
3053 #define plainc ((c_ext & C_EXT) == C_PLAIN)
3054 #define cplpl (c_ext & C_PLPL)
3055 #define cjava ((c_ext & C_JAVA) == C_JAVA)
3057 #define CNL_SAVE_DEFINEDEF() \
3059 curlinepos = charno; \
3060 readline (&curlb, inf); \
3061 lp = curlb.buffer; \
3068 CNL_SAVE_DEFINEDEF (); \
3069 if (savetoken.valid) \
3071 token = savetoken; \
3072 savetoken.valid = false; \
3074 definedef = dnone; \
3079 make_C_tag (bool isfun
)
3081 /* This function is never called when token.valid is false, but
3082 we must protect against invalid input or internal errors. */
3084 make_tag (token_name
.buffer
, token_name
.len
, isfun
, token
.line
,
3085 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3087 { /* this branch is optimized away if !DEBUG */
3088 make_tag (concat ("INVALID TOKEN:-->", token_name
.buffer
, ""),
3089 token_name
.len
+ 17, isfun
, token
.line
,
3090 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3091 error ("INVALID TOKEN");
3094 token
.valid
= false;
3098 perhaps_more_input (FILE *inf
)
3100 return !feof (inf
) && !ferror (inf
);
3106 * This routine finds functions, variables, typedefs,
3107 * #define's, enum constants and struct/union/enum definitions in
3108 * C syntax and adds them to the list.
3111 C_entries (int c_ext
, FILE *inf
)
3112 /* extension of C */
3115 register char c
; /* latest char read; '\0' for end of line */
3116 register char *lp
; /* pointer one beyond the character `c' */
3117 int curndx
, newndx
; /* indices for current and new lb */
3118 register int tokoff
; /* offset in line of start of current token */
3119 register int toklen
; /* length of current token */
3120 const char *qualifier
; /* string used to qualify names */
3121 int qlen
; /* length of qualifier */
3122 int bracelev
; /* current brace level */
3123 int bracketlev
; /* current bracket level */
3124 int parlev
; /* current parenthesis level */
3125 int attrparlev
; /* __attribute__ parenthesis level */
3126 int templatelev
; /* current template level */
3127 int typdefbracelev
; /* bracelev where a typedef struct body begun */
3128 bool incomm
, inquote
, inchar
, quotednl
, midtoken
;
3129 bool yacc_rules
; /* in the rules part of a yacc file */
3130 struct tok savetoken
= {0}; /* token saved during preprocessor handling */
3133 linebuffer_init (&lbs
[0].lb
);
3134 linebuffer_init (&lbs
[1].lb
);
3135 if (cstack
.size
== 0)
3137 cstack
.size
= (DEBUG
) ? 1 : 4;
3139 cstack
.cname
= xnew (cstack
.size
, char *);
3140 cstack
.bracelev
= xnew (cstack
.size
, int);
3143 tokoff
= toklen
= typdefbracelev
= 0; /* keep compiler quiet */
3144 curndx
= newndx
= 0;
3148 fvdef
= fvnone
; fvextern
= false; typdef
= tnone
;
3149 structdef
= snone
; definedef
= dnone
; objdef
= onone
;
3151 midtoken
= inquote
= inchar
= incomm
= quotednl
= false;
3152 token
.valid
= savetoken
.valid
= false;
3153 bracelev
= bracketlev
= parlev
= attrparlev
= templatelev
= 0;
3155 { qualifier
= "."; qlen
= 1; }
3157 { qualifier
= "::"; qlen
= 2; }
3160 while (perhaps_more_input (inf
))
3165 /* If we are at the end of the line, the next character is a
3166 '\0'; do not skip it, because it is what tells us
3167 to read the next line. */
3188 /* Newlines inside comments do not end macro definitions in
3190 CNL_SAVE_DEFINEDEF ();
3203 /* Newlines inside strings do not end macro definitions
3204 in traditional cpp, even though compilers don't
3205 usually accept them. */
3206 CNL_SAVE_DEFINEDEF ();
3216 /* Hmmm, something went wrong. */
3252 if (fvdef
!= finlist
&& fvdef
!= fignore
&& fvdef
!= vignore
)
3267 else if (/* cplpl && */ *lp
== '/')
3273 if ((c_ext
& YACC
) && *lp
== '%')
3275 /* Entering or exiting rules section in yacc file. */
3277 definedef
= dnone
; fvdef
= fvnone
; fvextern
= false;
3278 typdef
= tnone
; structdef
= snone
;
3279 midtoken
= inquote
= inchar
= incomm
= quotednl
= false;
3281 yacc_rules
= !yacc_rules
;
3287 if (definedef
== dnone
)
3290 bool cpptoken
= true;
3292 /* Look back on this line. If all blanks, or nonblanks
3293 followed by an end of comment, this is a preprocessor
3295 for (cp
= newlb
.buffer
; cp
< lp
-1; cp
++)
3296 if (!c_isspace (*cp
))
3298 if (*cp
== '*' && cp
[1] == '/')
3308 definedef
= dsharpseen
;
3309 /* This is needed for tagging enum values: when there are
3310 preprocessor conditionals inside the enum, we need to
3311 reset the value of fvdef so that the next enum value is
3312 tagged even though the one before it did not end in a
3314 if (fvdef
== vignore
&& instruct
&& parlev
== 0)
3316 if (strneq (cp
, "#if", 3) || strneq (cp
, "#el", 3))
3320 } /* if (definedef == dnone) */
3331 CNL_SAVE_DEFINEDEF ();
3338 /* Consider token only if some involved conditions are satisfied. */
3339 if (typdef
!= tignore
3340 && definedef
!= dignorerest
3343 && (definedef
!= dnone
3344 || structdef
!= scolonseen
)
3351 if (c
== ':' && *lp
== ':' && begtoken (lp
[1]))
3352 /* This handles :: in the middle,
3353 but not at the beginning of an identifier.
3354 Also, space-separated :: is not recognized. */
3356 if (c_ext
& C_AUTO
) /* automatic detection of C++ */
3357 c_ext
= (c_ext
| C_PLPL
) & ~C_AUTO
;
3361 goto still_in_token
;
3365 bool funorvar
= false;
3368 || consider_token (newlb
.buffer
+ tokoff
, toklen
, c
,
3369 &c_ext
, bracelev
, parlev
,
3372 if (fvdef
== foperator
)
3375 lp
= skip_spaces (lp
-1);
3379 && !c_isspace (*lp
) && *lp
!= '(')
3382 toklen
+= lp
- oldlp
;
3384 token
.named
= false;
3386 && nestlev
> 0 && definedef
== dnone
)
3387 /* in struct body */
3392 write_classname (&token_name
, qualifier
);
3393 len
= token_name
.len
;
3394 linebuffer_setlen (&token_name
,
3395 len
+ qlen
+ toklen
);
3396 sprintf (token_name
.buffer
+ len
, "%s%.*s",
3398 newlb
.buffer
+ tokoff
);
3402 linebuffer_setlen (&token_name
, toklen
);
3403 sprintf (token_name
.buffer
, "%.*s",
3404 toklen
, newlb
.buffer
+ tokoff
);
3408 else if (objdef
== ocatseen
)
3409 /* Objective C category */
3413 int len
= strlen (objtag
) + 2 + toklen
;
3414 linebuffer_setlen (&token_name
, len
);
3415 sprintf (token_name
.buffer
, "%s(%.*s)",
3417 newlb
.buffer
+ tokoff
);
3421 linebuffer_setlen (&token_name
, toklen
);
3422 sprintf (token_name
.buffer
, "%.*s",
3423 toklen
, newlb
.buffer
+ tokoff
);
3427 else if (objdef
== omethodtag
3428 || objdef
== omethodparm
)
3429 /* Objective C method */
3433 else if (fvdef
== fdefunname
)
3434 /* GNU DEFUN and similar macros */
3436 bool defun
= (newlb
.buffer
[tokoff
] == 'F');
3440 /* Rewrite the tag so that emacs lisp DEFUNs
3441 can be found by their elisp name */
3447 linebuffer_setlen (&token_name
, len
);
3448 memcpy (token_name
.buffer
,
3449 newlb
.buffer
+ off
, len
);
3450 token_name
.buffer
[len
] = '\0';
3453 if (token_name
.buffer
[len
] == '_')
3454 token_name
.buffer
[len
] = '-';
3455 token
.named
= defun
;
3459 linebuffer_setlen (&token_name
, toklen
);
3460 memcpy (token_name
.buffer
,
3461 newlb
.buffer
+ tokoff
, toklen
);
3462 token_name
.buffer
[toklen
] = '\0';
3463 /* Name macros and members. */
3464 token
.named
= (structdef
== stagseen
3465 || typdef
== ttypeseen
3468 && definedef
== dignorerest
)
3470 && definedef
== dnone
3471 && structdef
== snone
3474 token
.lineno
= lineno
;
3475 token
.offset
= tokoff
;
3476 token
.length
= toklen
;
3477 token
.line
= newlb
.buffer
;
3478 token
.linepos
= newlinepos
;
3481 if (definedef
== dnone
3482 && (fvdef
== fvnameseen
3483 || fvdef
== foperator
3484 || structdef
== stagseen
3486 || typdef
== ttypeseen
3487 || objdef
!= onone
))
3489 if (current_lb_is_new
)
3490 switch_line_buffers ();
3492 else if (definedef
!= dnone
3493 || fvdef
== fdefunname
3495 make_C_tag (funorvar
);
3497 else /* not yacc and consider_token failed */
3499 if (inattribute
&& fvdef
== fignore
)
3501 /* We have just met __attribute__ after a
3502 function parameter list: do not tag the
3509 } /* if (endtoken (c)) */
3510 else if (intoken (c
))
3516 } /* if (midtoken) */
3517 else if (begtoken (c
))
3525 /* This prevents tagging fb in
3526 void (__attribute__((noreturn)) *fb) (void);
3527 Fixing this is not easy and not very important. */
3531 if (plainc
|| declarations
)
3533 make_C_tag (true); /* a function */
3540 if (structdef
== stagseen
&& !cjava
)
3542 popclass_above (bracelev
);
3552 if (!yacc_rules
|| lp
== newlb
.buffer
+ 1)
3554 tokoff
= lp
- 1 - newlb
.buffer
;
3559 } /* if (begtoken) */
3560 } /* if must look at token */
3563 /* Detect end of line, colon, comma, semicolon and various braces
3564 after having handled a token.*/
3570 if (yacc_rules
&& token
.offset
== 0 && token
.valid
)
3572 make_C_tag (false); /* a yacc function */
3575 if (definedef
!= dnone
)
3581 make_C_tag (true); /* an Objective C class */
3585 objdef
= omethodcolon
;
3588 int toklen
= token_name
.len
;
3589 linebuffer_setlen (&token_name
, toklen
+ 1);
3590 strcpy (token_name
.buffer
+ toklen
, ":");
3596 if (structdef
== stagseen
)
3598 structdef
= scolonseen
;
3601 /* Should be useless, but may be work as a safety net. */
3602 if (cplpl
&& fvdef
== flistseen
)
3604 make_C_tag (true); /* a function */
3610 if (definedef
!= dnone
|| inattribute
)
3616 make_C_tag (false); /* a typedef */
3626 if (typdef
== tignore
|| cplpl
)
3630 if ((globals
&& bracelev
== 0 && (!fvextern
|| declarations
))
3631 || (members
&& instruct
))
3632 make_C_tag (false); /* a variable */
3635 token
.valid
= false;
3639 && (cplpl
|| !instruct
)
3640 && (typdef
== tnone
|| (typdef
!= tignore
&& instruct
)))
3642 && plainc
&& instruct
))
3643 make_C_tag (true); /* a function */
3649 && cplpl
&& structdef
== stagseen
)
3650 make_C_tag (false); /* forward declaration */
3652 token
.valid
= false;
3653 } /* switch (fvdef) */
3659 if (structdef
== stagseen
)
3663 if (definedef
!= dnone
|| inattribute
)
3669 make_C_tag (true); /* an Objective C method */
3684 if (instruct
&& parlev
== 0)
3695 && (!fvextern
|| declarations
))
3696 || (members
&& instruct
)))
3697 make_C_tag (false); /* a variable */
3700 if ((declarations
&& typdef
== tnone
&& !instruct
)
3701 || (members
&& typdef
!= tignore
&& instruct
))
3703 make_C_tag (true); /* a function */
3706 else if (!declarations
)
3708 token
.valid
= false;
3713 if (structdef
== stagseen
)
3717 if (definedef
!= dnone
|| inattribute
)
3719 if (structdef
== stagseen
)
3726 make_C_tag (false); /* a typedef */
3738 if ((members
&& bracelev
== 1)
3739 || (globals
&& bracelev
== 0
3740 && (!fvextern
|| declarations
)))
3741 make_C_tag (false); /* a variable */
3757 if (definedef
!= dnone
)
3759 if (objdef
== otagseen
&& parlev
== 0)
3760 objdef
= oparenseen
;
3764 if (typdef
== ttypeseen
3768 /* This handles constructs like:
3769 typedef void OperatorFun (int fun); */
3790 if (--attrparlev
== 0)
3791 inattribute
= false;
3794 if (definedef
!= dnone
)
3796 if (objdef
== ocatseen
&& parlev
== 1)
3798 make_C_tag (true); /* an Objective C category */
3814 || typdef
== ttypeseen
))
3817 make_C_tag (false); /* a typedef */
3820 else if (parlev
< 0) /* can happen due to ill-conceived #if's. */
3824 if (definedef
!= dnone
)
3826 if (typdef
== ttypeseen
)
3828 /* Whenever typdef is set to tinbody (currently only
3829 here), typdefbracelev should be set to bracelev. */
3831 typdefbracelev
= bracelev
;
3836 if (cplpl
&& !class_qualify
)
3838 /* Remove class and namespace qualifiers from the token,
3839 leaving only the method/member name. */
3840 char *cc
, *uqname
= token_name
.buffer
;
3841 char *tok_end
= token_name
.buffer
+ token_name
.len
;
3843 for (cc
= token_name
.buffer
; cc
< tok_end
; cc
++)
3845 if (*cc
== ':' && cc
[1] == ':')
3851 if (uqname
> token_name
.buffer
)
3853 int uqlen
= strlen (uqname
);
3854 linebuffer_setlen (&token_name
, uqlen
);
3855 memmove (token_name
.buffer
, uqname
, uqlen
+ 1);
3858 make_C_tag (true); /* a function */
3867 make_C_tag (true); /* an Objective C class */
3872 make_C_tag (true); /* an Objective C method */
3876 /* Neutralize `extern "C" {' grot. */
3877 if (bracelev
== 0 && structdef
== snone
&& nestlev
== 0
3887 case skeyseen
: /* unnamed struct */
3888 pushclass_above (bracelev
, NULL
, 0);
3891 case stagseen
: /* named struct or enum */
3892 case scolonseen
: /* a class */
3893 pushclass_above (bracelev
,token
.line
+token
.offset
, token
.length
);
3895 make_C_tag (false); /* a struct or enum */
3903 if (definedef
!= dnone
)
3905 if (fvdef
== fstartlist
)
3907 fvdef
= fvnone
; /* avoid tagging `foo' in `foo (*bar()) ()' */
3908 token
.valid
= false;
3912 if (definedef
!= dnone
)
3915 if (!ignoreindent
&& lp
== newlb
.buffer
+ 1)
3918 token
.valid
= false; /* unexpected value, token unreliable */
3919 bracelev
= 0; /* reset brace level if first column */
3920 parlev
= 0; /* also reset paren level, just in case... */
3922 else if (bracelev
< 0)
3924 token
.valid
= false; /* something gone amiss, token unreliable */
3927 if (bracelev
== 0 && fvdef
== vignore
)
3928 fvdef
= fvnone
; /* end of function */
3929 popclass_above (bracelev
);
3931 /* Only if typdef == tinbody is typdefbracelev significant. */
3932 if (typdef
== tinbody
&& bracelev
<= typdefbracelev
)
3934 assert (bracelev
== typdefbracelev
);
3939 if (definedef
!= dnone
)
3949 if ((members
&& bracelev
== 1)
3950 || (globals
&& bracelev
== 0 && (!fvextern
|| declarations
)))
3951 make_C_tag (false); /* a variable */
3959 && (structdef
== stagseen
|| fvdef
== fvnameseen
))
3966 if (templatelev
> 0)
3974 if (objdef
== oinbody
&& bracelev
== 0)
3976 objdef
= omethodsign
;
3981 case '#': case '~': case '&': case '%': case '/':
3982 case '|': case '^': case '!': case '.': case '?':
3983 if (definedef
!= dnone
)
3985 /* These surely cannot follow a function tag in C. */
3998 if (objdef
== otagseen
)
4000 make_C_tag (true); /* an Objective C class */
4003 /* If a macro spans multiple lines don't reset its state. */
4005 CNL_SAVE_DEFINEDEF ();
4011 } /* while not eof */
4013 free (lbs
[0].lb
.buffer
);
4014 free (lbs
[1].lb
.buffer
);
4018 * Process either a C++ file or a C file depending on the setting
4022 default_C_entries (FILE *inf
)
4024 C_entries (cplusplus
? C_PLPL
: C_AUTO
, inf
);
4027 /* Always do plain C. */
4029 plain_C_entries (FILE *inf
)
4034 /* Always do C++. */
4036 Cplusplus_entries (FILE *inf
)
4038 C_entries (C_PLPL
, inf
);
4041 /* Always do Java. */
4043 Cjava_entries (FILE *inf
)
4045 C_entries (C_JAVA
, inf
);
4050 Cstar_entries (FILE *inf
)
4052 C_entries (C_STAR
, inf
);
4055 /* Always do Yacc. */
4057 Yacc_entries (FILE *inf
)
4059 C_entries (YACC
, inf
);
4063 /* Useful macros. */
4064 #define LOOP_ON_INPUT_LINES(file_pointer, line_buffer, char_pointer) \
4065 while (perhaps_more_input (file_pointer) \
4066 && (readline (&(line_buffer), file_pointer), \
4067 (char_pointer) = (line_buffer).buffer, \
4070 #define LOOKING_AT(cp, kw) /* kw is the keyword, a literal string */ \
4071 ((assert ("" kw), true) /* syntax error if not a literal string */ \
4072 && strneq ((cp), kw, sizeof (kw)-1) /* cp points at kw */ \
4073 && notinname ((cp)[sizeof (kw)-1]) /* end of kw */ \
4074 && ((cp) = skip_spaces ((cp)+sizeof (kw)-1))) /* skip spaces */
4076 /* Similar to LOOKING_AT but does not use notinname, does not skip */
4077 #define LOOKING_AT_NOCASE(cp, kw) /* the keyword is a literal string */ \
4078 ((assert ("" kw), true) /* syntax error if not a literal string */ \
4079 && strncaseeq ((cp), kw, sizeof (kw)-1) /* cp points at kw */ \
4080 && ((cp) += sizeof (kw)-1)) /* skip spaces */
4083 * Read a file, but do no processing. This is used to do regexp
4084 * matching on files that have no language defined.
4087 just_read_file (FILE *inf
)
4089 while (perhaps_more_input (inf
))
4090 readline (&lb
, inf
);
4094 /* Fortran parsing */
4096 static void F_takeprec (void);
4097 static void F_getit (FILE *);
4102 dbp
= skip_spaces (dbp
);
4106 dbp
= skip_spaces (dbp
);
4107 if (strneq (dbp
, "(*)", 3))
4112 if (!c_isdigit (*dbp
))
4114 --dbp
; /* force failure */
4119 while (c_isdigit (*dbp
));
4127 dbp
= skip_spaces (dbp
);
4130 readline (&lb
, inf
);
4135 dbp
= skip_spaces (dbp
);
4137 if (!c_isalpha (*dbp
) && *dbp
!= '_' && *dbp
!= '$')
4139 for (cp
= dbp
+ 1; *cp
!= '\0' && intoken (*cp
); cp
++)
4141 make_tag (dbp
, cp
-dbp
, true,
4142 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4147 Fortran_functions (FILE *inf
)
4149 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4152 dbp
++; /* Ratfor escape to fortran */
4153 dbp
= skip_spaces (dbp
);
4157 if (LOOKING_AT_NOCASE (dbp
, "recursive"))
4158 dbp
= skip_spaces (dbp
);
4160 if (LOOKING_AT_NOCASE (dbp
, "pure"))
4161 dbp
= skip_spaces (dbp
);
4163 if (LOOKING_AT_NOCASE (dbp
, "elemental"))
4164 dbp
= skip_spaces (dbp
);
4166 switch (c_tolower (*dbp
))
4169 if (nocase_tail ("integer"))
4173 if (nocase_tail ("real"))
4177 if (nocase_tail ("logical"))
4181 if (nocase_tail ("complex") || nocase_tail ("character"))
4185 if (nocase_tail ("double"))
4187 dbp
= skip_spaces (dbp
);
4190 if (nocase_tail ("precision"))
4196 dbp
= skip_spaces (dbp
);
4199 switch (c_tolower (*dbp
))
4202 if (nocase_tail ("function"))
4206 if (nocase_tail ("subroutine"))
4210 if (nocase_tail ("entry"))
4214 if (nocase_tail ("blockdata") || nocase_tail ("block data"))
4216 dbp
= skip_spaces (dbp
);
4217 if (*dbp
== '\0') /* assume un-named */
4218 make_tag ("blockdata", 9, true,
4219 lb
.buffer
, dbp
- lb
.buffer
, lineno
, linecharno
);
4221 F_getit (inf
); /* look for name */
4230 * Go language support
4231 * Original code by Xi Lu <lx@shellcodes.org> (2016)
4234 Go_functions(FILE *inf
)
4238 LOOP_ON_INPUT_LINES(inf
, lb
, cp
)
4240 cp
= skip_spaces (cp
);
4242 if (LOOKING_AT (cp
, "package"))
4245 while (!notinname (*cp
) && *cp
!= '\0')
4247 make_tag (name
, cp
- name
, false, lb
.buffer
,
4248 cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4250 else if (LOOKING_AT (cp
, "func"))
4252 /* Go implementation of interface, such as:
4253 func (n *Integer) Add(m Integer) ...
4254 skip `(n *Integer)` part.
4260 cp
= skip_spaces (cp
+1);
4267 while (!notinname (*cp
))
4270 make_tag (name
, cp
- name
, true, lb
.buffer
,
4271 cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4274 else if (members
&& LOOKING_AT (cp
, "type"))
4278 /* Ignore the likes of the following:
4286 while (!notinname (*cp
) && *cp
!= '\0')
4289 make_tag (name
, cp
- name
, false, lb
.buffer
,
4290 cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4299 * Philippe Waroquiers (1998)
4302 /* Once we are positioned after an "interesting" keyword, let's get
4303 the real tag value necessary. */
4305 Ada_getit (FILE *inf
, const char *name_qualifier
)
4311 while (perhaps_more_input (inf
))
4313 dbp
= skip_spaces (dbp
);
4315 || (dbp
[0] == '-' && dbp
[1] == '-'))
4317 readline (&lb
, inf
);
4320 switch (c_tolower (*dbp
))
4323 if (nocase_tail ("body"))
4325 /* Skipping body of procedure body or package body or ....
4326 resetting qualifier to body instead of spec. */
4327 name_qualifier
= "/b";
4332 /* Skipping type of task type or protected type ... */
4333 if (nocase_tail ("type"))
4340 for (cp
= dbp
; *cp
!= '\0' && *cp
!= '"'; cp
++)
4345 dbp
= skip_spaces (dbp
);
4347 c_isalnum (*cp
) || *cp
== '_' || *cp
== '.';
4355 name
= concat (dbp
, name_qualifier
, "");
4357 make_tag (name
, strlen (name
), true,
4358 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4367 Ada_funcs (FILE *inf
)
4369 bool inquote
= false;
4370 bool skip_till_semicolumn
= false;
4372 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4374 while (*dbp
!= '\0')
4376 /* Skip a string i.e. "abcd". */
4377 if (inquote
|| (*dbp
== '"'))
4379 dbp
= strchr (dbp
+ !inquote
, '"');
4384 continue; /* advance char */
4389 break; /* advance line */
4393 /* Skip comments. */
4394 if (dbp
[0] == '-' && dbp
[1] == '-')
4395 break; /* advance line */
4397 /* Skip character enclosed in single quote i.e. 'a'
4398 and skip single quote starting an attribute i.e. 'Image. */
4407 if (skip_till_semicolumn
)
4410 skip_till_semicolumn
= false;
4412 continue; /* advance char */
4415 /* Search for beginning of a token. */
4416 if (!begtoken (*dbp
))
4419 continue; /* advance char */
4422 /* We are at the beginning of a token. */
4423 switch (c_tolower (*dbp
))
4426 if (!packages_only
&& nocase_tail ("function"))
4427 Ada_getit (inf
, "/f");
4429 break; /* from switch */
4430 continue; /* advance char */
4432 if (!packages_only
&& nocase_tail ("procedure"))
4433 Ada_getit (inf
, "/p");
4434 else if (nocase_tail ("package"))
4435 Ada_getit (inf
, "/s");
4436 else if (nocase_tail ("protected")) /* protected type */
4437 Ada_getit (inf
, "/t");
4439 break; /* from switch */
4440 continue; /* advance char */
4443 if (typedefs
&& !packages_only
&& nocase_tail ("use"))
4445 /* when tagging types, avoid tagging use type Pack.Typename;
4446 for this, we will skip everything till a ; */
4447 skip_till_semicolumn
= true;
4448 continue; /* advance char */
4452 if (!packages_only
&& nocase_tail ("task"))
4453 Ada_getit (inf
, "/k");
4454 else if (typedefs
&& !packages_only
&& nocase_tail ("type"))
4456 Ada_getit (inf
, "/t");
4457 while (*dbp
!= '\0')
4461 break; /* from switch */
4462 continue; /* advance char */
4465 /* Look for the end of the token. */
4466 while (!endtoken (*dbp
))
4469 } /* advance char */
4470 } /* advance line */
4475 * Unix and microcontroller assembly tag handling
4476 * Labels: /^[a-zA-Z_.$][a-zA_Z0-9_.$]*[: ^I^J]/
4477 * Idea by Bob Weiner, Motorola Inc. (1994)
4480 Asm_labels (FILE *inf
)
4484 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4486 /* If first char is alphabetic or one of [_.$], test for colon
4487 following identifier. */
4488 if (c_isalpha (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4490 /* Read past label. */
4492 while (c_isalnum (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4494 if (*cp
== ':' || c_isspace (*cp
))
4495 /* Found end of label, so copy it and add it to the table. */
4496 make_tag (lb
.buffer
, cp
- lb
.buffer
, true,
4497 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4505 * Perl sub names: /^sub[ \t\n]+[^ \t\n{]+/
4506 * /^use constant[ \t\n]+[^ \t\n{=,;]+/
4507 * Perl variable names: /^(my|local).../
4508 * Original code by Bart Robinson <lomew@cs.utah.edu> (1995)
4509 * Additions by Michael Ernst <mernst@alum.mit.edu> (1997)
4510 * Ideas by Kai Großjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE> (2001)
4513 Perl_functions (FILE *inf
)
4515 char *package
= savestr ("main"); /* current package name */
4518 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4520 cp
= skip_spaces (cp
);
4522 if (LOOKING_AT (cp
, "package"))
4525 get_tag (cp
, &package
);
4527 else if (LOOKING_AT (cp
, "sub"))
4533 while (!notinname (*cp
))
4536 continue; /* nothing found */
4537 pos
= strchr (sp
, ':');
4538 if (pos
&& pos
< cp
&& pos
[1] == ':')
4540 /* The name is already qualified. */
4543 char *q
= pos
+ 2, *qpos
;
4544 while ((qpos
= strchr (q
, ':')) != NULL
4550 make_tag (sp
, cp
- sp
, true,
4551 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4553 else if (class_qualify
)
4556 char savechar
, *name
;
4560 name
= concat (package
, "::", sp
);
4562 make_tag (name
, strlen (name
), true,
4563 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4567 make_tag (sp
, cp
- sp
, true,
4568 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4570 else if (LOOKING_AT (cp
, "use constant")
4571 || LOOKING_AT (cp
, "use constant::defer"))
4573 /* For hash style multi-constant like
4574 use constant { FOO => 123,
4576 only the first FOO is picked up. Parsing across the value
4577 expressions would be difficult in general, due to possible nested
4578 hashes, here-documents, etc. */
4580 cp
= skip_spaces (cp
+1);
4583 else if (globals
) /* only if we are tagging global vars */
4585 /* Skip a qualifier, if any. */
4586 bool qual
= LOOKING_AT (cp
, "my") || LOOKING_AT (cp
, "local");
4587 /* After "my" or "local", but before any following paren or space. */
4588 char *varstart
= cp
;
4590 if (qual
/* should this be removed? If yes, how? */
4591 && (*cp
== '$' || *cp
== '@' || *cp
== '%'))
4596 while (c_isalnum (*cp
) || *cp
== '_');
4600 /* Should be examining a variable list at this point;
4601 could insist on seeing an open parenthesis. */
4602 while (*cp
!= '\0' && *cp
!= ';' && *cp
!= '=' && *cp
!= ')')
4608 make_tag (varstart
, cp
- varstart
, false,
4609 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4618 * Look for /^[\t]*def[ \t\n]+[^ \t\n(:]+/ or /^class[ \t\n]+[^ \t\n(:]+/
4619 * Idea by Eric S. Raymond <esr@thyrsus.com> (1997)
4620 * More ideas by seb bacon <seb@jamkit.com> (2002)
4623 Python_functions (FILE *inf
)
4627 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4629 cp
= skip_spaces (cp
);
4630 if (LOOKING_AT (cp
, "def") || LOOKING_AT (cp
, "class"))
4633 while (!notinname (*cp
) && *cp
!= ':')
4635 make_tag (name
, cp
- name
, true,
4636 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4643 * Original code by Xi Lu <lx@shellcodes.org> (2015)
4646 Ruby_functions (FILE *inf
)
4649 bool reader
= false, writer
= false, alias
= false, continuation
= false;
4651 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4653 bool is_class
= false;
4654 bool is_method
= false;
4657 cp
= skip_spaces (cp
);
4660 && c_isalpha (*cp
) && c_isupper (*cp
))
4662 char *bp
, *colon
= NULL
;
4666 for (cp
++; c_isalnum (*cp
) || *cp
== '_' || *cp
== ':'; cp
++)
4673 bp
= skip_spaces (cp
);
4674 if (*bp
== '=' && !(bp
[1] == '=' || bp
[1] == '>'))
4676 if (colon
&& !c_isspace (colon
[1]))
4678 make_tag (name
, cp
- name
, false,
4679 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4683 else if (!continuation
4684 /* Modules, classes, methods. */
4685 && ((is_method
= LOOKING_AT (cp
, "def"))
4686 || (is_class
= LOOKING_AT (cp
, "class"))
4687 || LOOKING_AT (cp
, "module")))
4689 const char self_name
[] = "self.";
4690 const size_t self_size1
= sizeof (self_name
) - 1;
4694 /* Ruby method names can end in a '='. Also, operator overloading can
4695 define operators whose names include '='. */
4696 while (!notinname (*cp
) || *cp
== '=')
4699 /* Remove "self." from the method name. */
4700 if (cp
- name
> self_size1
4701 && strneq (name
, self_name
, self_size1
))
4704 /* Remove the class/module qualifiers from method names. */
4709 for (q
= name
; q
< cp
&& *q
!= '.'; q
++)
4711 if (q
< cp
- 1) /* punt if we see just "FOO." */
4715 /* Don't tag singleton classes. */
4716 if (is_class
&& strneq (name
, "<<", 2) && cp
== name
+ 2)
4719 make_tag (name
, cp
- name
, true,
4720 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4724 /* Tag accessors and aliases. */
4727 reader
= writer
= alias
= false;
4729 while (*cp
&& *cp
!= '#')
4733 reader
= writer
= alias
= false;
4734 if (LOOKING_AT (cp
, "attr_reader"))
4736 else if (LOOKING_AT (cp
, "attr_writer"))
4738 else if (LOOKING_AT (cp
, "attr_accessor"))
4743 else if (LOOKING_AT (cp
, "alias_method"))
4746 if (reader
|| writer
|| alias
)
4751 cp
= skip_spaces (cp
);
4753 cp
= skip_spaces (cp
+ 1);
4755 cp
= skip_name (cp
);
4761 make_tag (np
, cp
- np
, true,
4762 lb
.buffer
, cp
- lb
.buffer
+ 1,
4763 lineno
, linecharno
);
4764 continuation
= false;
4768 size_t name_len
= cp
- np
+ 1;
4769 char *wr_name
= xnew (name_len
+ 1, char);
4771 memcpy (wr_name
, np
, name_len
- 1);
4772 memcpy (wr_name
+ name_len
- 1, "=", 2);
4773 pfnote (wr_name
, true, lb
.buffer
, cp
- lb
.buffer
+ 1,
4774 lineno
, linecharno
);
4775 continuation
= false;
4780 make_tag (np
, cp
- np
, true,
4781 lb
.buffer
, cp
- lb
.buffer
+ 1,
4782 lineno
, linecharno
);
4783 continuation
= false;
4784 while (*cp
&& *cp
!= '#' && *cp
!= ';')
4787 continuation
= true;
4788 else if (!c_isspace (*cp
))
4789 continuation
= false;
4793 continuation
= false;
4795 cp
= skip_spaces (cp
);
4798 : (continuation
= (*cp
== ',')))
4799 && (cp
= skip_spaces (cp
+ 1), *cp
&& *cp
!= '#'));
4802 cp
= skip_name (cp
);
4803 while (*cp
&& *cp
!= '#' && notinname (*cp
))
4814 * - /^[ \t]*function[ \t\n]+[^ \t\n(]+/
4815 * - /^[ \t]*class[ \t\n]+[^ \t\n]+/
4816 * - /^[ \t]*define\(\"[^\"]+/
4817 * Only with --members:
4818 * - /^[ \t]*var[ \t\n]+\$[^ \t\n=;]/
4819 * Idea by Diez B. Roggisch (2001)
4822 PHP_functions (FILE *inf
)
4825 bool search_identifier
= false;
4827 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4829 cp
= skip_spaces (cp
);
4831 if (search_identifier
4834 while (!notinname (*cp
))
4836 make_tag (name
, cp
- name
, true,
4837 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4838 search_identifier
= false;
4840 else if (LOOKING_AT (cp
, "function"))
4843 cp
= skip_spaces (cp
+1);
4847 while (!notinname (*cp
))
4849 make_tag (name
, cp
- name
, true,
4850 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4853 search_identifier
= true;
4855 else if (LOOKING_AT (cp
, "class"))
4860 while (*cp
!= '\0' && !c_isspace (*cp
))
4862 make_tag (name
, cp
- name
, false,
4863 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4866 search_identifier
= true;
4868 else if (strneq (cp
, "define", 6)
4869 && (cp
= skip_spaces (cp
+6))
4871 && (*cp
== '"' || *cp
== '\''))
4875 while (*cp
!= quote
&& *cp
!= '\0')
4877 make_tag (name
, cp
- name
, false,
4878 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4881 && LOOKING_AT (cp
, "var")
4885 while (!notinname (*cp
))
4887 make_tag (name
, cp
- name
, false,
4888 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4895 * Cobol tag functions
4896 * We could look for anything that could be a paragraph name.
4897 * i.e. anything that starts in column 8 is one word and ends in a full stop.
4898 * Idea by Corny de Souza (1993)
4901 Cobol_paragraphs (FILE *inf
)
4903 register char *bp
, *ep
;
4905 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4911 /* If eoln, compiler option or comment ignore whole line. */
4912 if (bp
[-1] != ' ' || !c_isalnum (bp
[0]))
4915 for (ep
= bp
; c_isalnum (*ep
) || *ep
== '-'; ep
++)
4918 make_tag (bp
, ep
- bp
, true,
4919 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4926 * Ideas by Assar Westerlund <assar@sics.se> (2001)
4929 Makefile_targets (FILE *inf
)
4933 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4935 if (*bp
== '\t' || *bp
== '#')
4937 while (*bp
!= '\0' && *bp
!= '=' && *bp
!= ':')
4939 if (*bp
== ':' || (globals
&& *bp
== '='))
4941 /* We should detect if there is more than one tag, but we do not.
4942 We just skip initial and final spaces. */
4943 char * namestart
= skip_spaces (lb
.buffer
);
4944 while (--bp
> namestart
)
4945 if (!notinname (*bp
))
4947 make_tag (namestart
, bp
- namestart
+ 1, true,
4948 lb
.buffer
, bp
- lb
.buffer
+ 2, lineno
, linecharno
);
4956 * Original code by Mosur K. Mohan (1989)
4958 * Locates tags for procedures & functions. Doesn't do any type- or
4959 * var-definitions. It does look for the keyword "extern" or
4960 * "forward" immediately following the procedure statement; if found,
4961 * the tag is skipped.
4964 Pascal_functions (FILE *inf
)
4966 linebuffer tline
; /* mostly copied from C_entries */
4968 int save_lineno
, namelen
, taglen
;
4971 bool /* each of these flags is true if: */
4972 incomment
, /* point is inside a comment */
4973 inquote
, /* point is inside '..' string */
4974 get_tagname
, /* point is after PROCEDURE/FUNCTION
4975 keyword, so next item = potential tag */
4976 found_tag
, /* point is after a potential tag */
4977 inparms
, /* point is within parameter-list */
4978 verify_tag
; /* point has passed the parm-list, so the
4979 next token will determine whether this
4980 is a FORWARD/EXTERN to be ignored, or
4981 whether it is a real tag */
4983 save_lcno
= save_lineno
= namelen
= taglen
= 0; /* keep compiler quiet */
4984 name
= NULL
; /* keep compiler quiet */
4987 linebuffer_init (&tline
);
4989 incomment
= inquote
= false;
4990 found_tag
= false; /* have a proc name; check if extern */
4991 get_tagname
= false; /* found "procedure" keyword */
4992 inparms
= false; /* found '(' after "proc" */
4993 verify_tag
= false; /* check if "extern" is ahead */
4996 while (perhaps_more_input (inf
)) /* long main loop to get next char */
4999 if (c
== '\0') /* if end of line */
5001 readline (&lb
, inf
);
5005 if (!((found_tag
&& verify_tag
)
5007 c
= *dbp
++; /* only if don't need *dbp pointing
5008 to the beginning of the name of
5009 the procedure or function */
5013 if (c
== '}') /* within { } comments */
5015 else if (c
== '*' && *dbp
== ')') /* within (* *) comments */
5032 inquote
= true; /* found first quote */
5034 case '{': /* found open { comment */
5038 if (*dbp
== '*') /* found open (* comment */
5043 else if (found_tag
) /* found '(' after tag, i.e., parm-list */
5046 case ')': /* end of parms list */
5051 if (found_tag
&& !inparms
) /* end of proc or fn stmt */
5058 if (found_tag
&& verify_tag
&& (*dbp
!= ' '))
5060 /* Check if this is an "extern" declaration. */
5063 if (c_tolower (*dbp
) == 'e')
5065 if (nocase_tail ("extern")) /* superfluous, really! */
5071 else if (c_tolower (*dbp
) == 'f')
5073 if (nocase_tail ("forward")) /* check for forward reference */
5079 if (found_tag
&& verify_tag
) /* not external proc, so make tag */
5083 make_tag (name
, namelen
, true,
5084 tline
.buffer
, taglen
, save_lineno
, save_lcno
);
5088 if (get_tagname
) /* grab name of proc or fn */
5095 /* Find block name. */
5096 for (cp
= dbp
+ 1; *cp
!= '\0' && !endtoken (*cp
); cp
++)
5099 /* Save all values for later tagging. */
5100 linebuffer_setlen (&tline
, lb
.len
);
5101 strcpy (tline
.buffer
, lb
.buffer
);
5102 save_lineno
= lineno
;
5103 save_lcno
= linecharno
;
5104 name
= tline
.buffer
+ (dbp
- lb
.buffer
);
5106 taglen
= cp
- lb
.buffer
+ 1;
5108 dbp
= cp
; /* set dbp to e-o-token */
5109 get_tagname
= false;
5113 /* And proceed to check for "extern". */
5115 else if (!incomment
&& !inquote
&& !found_tag
)
5117 /* Check for proc/fn keywords. */
5118 switch (c_tolower (c
))
5121 if (nocase_tail ("rocedure")) /* c = 'p', dbp has advanced */
5125 if (nocase_tail ("unction"))
5130 } /* while not eof */
5132 free (tline
.buffer
);
5137 * Lisp tag functions
5138 * look for (def or (DEF, quote or QUOTE
5141 static void L_getit (void);
5146 if (*dbp
== '\'') /* Skip prefix quote */
5148 else if (*dbp
== '(')
5151 /* Try to skip "(quote " */
5152 if (!LOOKING_AT (dbp
, "quote") && !LOOKING_AT (dbp
, "QUOTE"))
5153 /* Ok, then skip "(" before name in (defstruct (foo)) */
5154 dbp
= skip_spaces (dbp
);
5156 get_tag (dbp
, NULL
);
5160 Lisp_functions (FILE *inf
)
5162 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
5167 /* "(defvar foo)" is a declaration rather than a definition. */
5171 if (LOOKING_AT (p
, "defvar"))
5173 p
= skip_name (p
); /* past var name */
5174 p
= skip_spaces (p
);
5180 if (strneq (dbp
+ 1, "cl-", 3) || strneq (dbp
+ 1, "CL-", 3))
5183 if (strneq (dbp
+1, "def", 3) || strneq (dbp
+1, "DEF", 3))
5185 dbp
= skip_non_spaces (dbp
);
5186 dbp
= skip_spaces (dbp
);
5191 /* Check for (foo::defmumble name-defined ... */
5194 while (!notinname (*dbp
) && *dbp
!= ':');
5199 while (*dbp
== ':');
5201 if (strneq (dbp
, "def", 3) || strneq (dbp
, "DEF", 3))
5203 dbp
= skip_non_spaces (dbp
);
5204 dbp
= skip_spaces (dbp
);
5214 * Lua script language parsing
5215 * Original code by David A. Capello <dacap@users.sourceforge.net> (2004)
5217 * "function" and "local function" are tags if they start at column 1.
5220 Lua_functions (FILE *inf
)
5224 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5226 bp
= skip_spaces (bp
);
5227 if (bp
[0] != 'f' && bp
[0] != 'l')
5230 (void)LOOKING_AT (bp
, "local"); /* skip possible "local" */
5232 if (LOOKING_AT (bp
, "function"))
5234 char *tag_name
, *tp_dot
, *tp_colon
;
5236 get_tag (bp
, &tag_name
);
5237 /* If the tag ends with ".foo" or ":foo", make an additional tag for
5239 tp_dot
= strrchr (tag_name
, '.');
5240 tp_colon
= strrchr (tag_name
, ':');
5241 if (tp_dot
|| tp_colon
)
5243 char *p
= tp_dot
> tp_colon
? tp_dot
: tp_colon
;
5244 int len_add
= p
- tag_name
+ 1;
5246 get_tag (bp
+ len_add
, NULL
);
5255 * Just look for lines where the first character is '/'
5256 * Also look at "defineps" for PSWrap
5258 * Richard Mlynarik <mly@adoc.xerox.com> (1997)
5259 * Masatake Yamato <masata-y@is.aist-nara.ac.jp> (1999)
5262 PS_functions (FILE *inf
)
5264 register char *bp
, *ep
;
5266 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5271 *ep
!= '\0' && *ep
!= ' ' && *ep
!= '{';
5274 make_tag (bp
, ep
- bp
, true,
5275 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
5277 else if (LOOKING_AT (bp
, "defineps"))
5285 * Ignore anything after \ followed by space or in ( )
5286 * Look for words defined by :
5287 * Look for constant, code, create, defer, value, and variable
5288 * OBP extensions: Look for buffer:, field,
5289 * Ideas by Eduardo Horvath <eeh@netbsd.org> (2004)
5292 Forth_words (FILE *inf
)
5296 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5297 while ((bp
= skip_spaces (bp
))[0] != '\0')
5298 if (bp
[0] == '\\' && c_isspace (bp
[1]))
5299 break; /* read next line */
5300 else if (bp
[0] == '(' && c_isspace (bp
[1]))
5301 do /* skip to ) or eol */
5303 while (*bp
!= ')' && *bp
!= '\0');
5304 else if ((bp
[0] == ':' && c_isspace (bp
[1]) && bp
++)
5305 || LOOKING_AT_NOCASE (bp
, "constant")
5306 || LOOKING_AT_NOCASE (bp
, "code")
5307 || LOOKING_AT_NOCASE (bp
, "create")
5308 || LOOKING_AT_NOCASE (bp
, "defer")
5309 || LOOKING_AT_NOCASE (bp
, "value")
5310 || LOOKING_AT_NOCASE (bp
, "variable")
5311 || LOOKING_AT_NOCASE (bp
, "buffer:")
5312 || LOOKING_AT_NOCASE (bp
, "field"))
5313 get_tag (skip_spaces (bp
), NULL
); /* Yay! A definition! */
5315 bp
= skip_non_spaces (bp
);
5320 * Scheme tag functions
5321 * look for (def... xyzzy
5323 * (def ... ((...(xyzzy ....
5325 * Original code by Ken Haase (1985?)
5328 Scheme_functions (FILE *inf
)
5332 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5334 if (strneq (bp
, "(def", 4) || strneq (bp
, "(DEF", 4))
5336 bp
= skip_non_spaces (bp
+4);
5337 /* Skip over open parens and white space. Don't continue past
5339 while (*bp
&& notinname (*bp
))
5343 if (LOOKING_AT (bp
, "(SET!") || LOOKING_AT (bp
, "(set!"))
5349 /* Find tags in TeX and LaTeX input files. */
5351 /* TEX_toktab is a table of TeX control sequences that define tags.
5352 * Each entry records one such control sequence.
5354 * Original code from who knows whom.
5356 * Stefan Monnier (2002)
5359 static linebuffer
*TEX_toktab
= NULL
; /* Table with tag tokens */
5361 /* Default set of control sequences to put into TEX_toktab.
5362 The value of environment var TEXTAGS is prepended to this. */
5363 static const char *TEX_defenv
= "\
5364 :chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem\
5365 :part:appendix:entry:index:def\
5366 :newcommand:renewcommand:newenvironment:renewenvironment";
5368 static void TEX_decode_env (const char *, const char *);
5371 * TeX/LaTeX scanning loop.
5374 TeX_commands (FILE *inf
)
5379 char TEX_esc
= '\0';
5380 char TEX_opgrp
, TEX_clgrp
;
5382 /* Initialize token table once from environment. */
5383 if (TEX_toktab
== NULL
)
5384 TEX_decode_env ("TEXTAGS", TEX_defenv
);
5386 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5388 /* Look at each TEX keyword in line. */
5391 /* Look for a TEX escape. */
5395 if (c
== '\0' || c
== '%')
5398 /* Select either \ or ! as escape character, whichever comes
5399 first outside a comment. */
5420 for (key
= TEX_toktab
; key
->buffer
!= NULL
; key
++)
5421 if (strneq (cp
, key
->buffer
, key
->len
))
5424 int namelen
, linelen
;
5427 cp
= skip_spaces (cp
+ key
->len
);
5428 if (*cp
== TEX_opgrp
)
5434 (!c_isspace (*p
) && *p
!= '#' &&
5435 *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
);
5440 if (!opgrp
|| *p
== TEX_clgrp
)
5442 while (*p
!= '\0' && *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
)
5444 linelen
= p
- lb
.buffer
+ 1;
5446 make_tag (cp
, namelen
, true,
5447 lb
.buffer
, linelen
, lineno
, linecharno
);
5448 goto tex_next_line
; /* We only tag a line once */
5456 /* Read environment and prepend it to the default string.
5457 Build token table. */
5459 TEX_decode_env (const char *evarname
, const char *defenv
)
5461 register const char *env
, *p
;
5464 /* Append default string to environment. */
5465 env
= getenv (evarname
);
5469 env
= concat (env
, defenv
, "");
5471 /* Allocate a token table */
5472 for (len
= 1, p
= env
; (p
= strchr (p
, ':')); )
5475 TEX_toktab
= xnew (len
, linebuffer
);
5477 /* Unpack environment string into token table. Be careful about */
5478 /* zero-length strings (leading ':', "::" and trailing ':') */
5479 for (i
= 0; *env
!= '\0';)
5481 p
= strchr (env
, ':');
5482 if (!p
) /* End of environment string. */
5483 p
= env
+ strlen (env
);
5485 { /* Only non-zero strings. */
5486 TEX_toktab
[i
].buffer
= savenstr (env
, p
- env
);
5487 TEX_toktab
[i
].len
= p
- env
;
5494 TEX_toktab
[i
].buffer
= NULL
; /* Mark end of table. */
5495 TEX_toktab
[i
].len
= 0;
5502 /* Texinfo support. Dave Love, Mar. 2000. */
5504 Texinfo_nodes (FILE *inf
)
5507 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5508 if (LOOKING_AT (cp
, "@node"))
5511 while (*cp
!= '\0' && *cp
!= ',')
5513 make_tag (start
, cp
- start
, true,
5514 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
5521 * Contents of <title>, <h1>, <h2>, <h3> are tags.
5522 * Contents of <a name=xxx> are tags with name xxx.
5524 * Francesco Potortì, 2002.
5527 HTML_labels (FILE *inf
)
5529 bool getnext
= false; /* next text outside of HTML tags is a tag */
5530 bool skiptag
= false; /* skip to the end of the current HTML tag */
5531 bool intag
= false; /* inside an html tag, looking for ID= */
5532 bool inanchor
= false; /* when INTAG, is an anchor, look for NAME= */
5536 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5538 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
5539 for (;;) /* loop on the same line */
5541 if (skiptag
) /* skip HTML tag */
5543 while (*dbp
!= '\0' && *dbp
!= '>')
5549 continue; /* look on the same line */
5551 break; /* go to next line */
5554 else if (intag
) /* look for "name=" or "id=" */
5556 while (*dbp
!= '\0' && *dbp
!= '>'
5557 && c_tolower (*dbp
) != 'n' && c_tolower (*dbp
) != 'i')
5560 break; /* go to next line */
5565 continue; /* look on the same line */
5567 if ((inanchor
&& LOOKING_AT_NOCASE (dbp
, "name="))
5568 || LOOKING_AT_NOCASE (dbp
, "id="))
5570 bool quoted
= (dbp
[0] == '"');
5573 for (end
= ++dbp
; *end
!= '\0' && *end
!= '"'; end
++)
5576 for (end
= dbp
; *end
!= '\0' && intoken (*end
); end
++)
5578 linebuffer_setlen (&token_name
, end
- dbp
);
5579 memcpy (token_name
.buffer
, dbp
, end
- dbp
);
5580 token_name
.buffer
[end
- dbp
] = '\0';
5583 intag
= false; /* we found what we looked for */
5584 skiptag
= true; /* skip to the end of the tag */
5585 getnext
= true; /* then grab the text */
5586 continue; /* look on the same line */
5591 else if (getnext
) /* grab next tokens and tag them */
5593 dbp
= skip_spaces (dbp
);
5595 break; /* go to next line */
5599 inanchor
= (c_tolower (dbp
[1]) == 'a' && !intoken (dbp
[2]));
5600 continue; /* look on the same line */
5603 for (end
= dbp
+ 1; *end
!= '\0' && *end
!= '<'; end
++)
5605 make_tag (token_name
.buffer
, token_name
.len
, true,
5606 dbp
, end
- dbp
, lineno
, linecharno
);
5607 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5609 break; /* go to next line */
5612 else /* look for an interesting HTML tag */
5614 while (*dbp
!= '\0' && *dbp
!= '<')
5617 break; /* go to next line */
5619 if (c_tolower (dbp
[1]) == 'a' && !intoken (dbp
[2]))
5622 continue; /* look on the same line */
5624 else if (LOOKING_AT_NOCASE (dbp
, "<title>")
5625 || LOOKING_AT_NOCASE (dbp
, "<h1>")
5626 || LOOKING_AT_NOCASE (dbp
, "<h2>")
5627 || LOOKING_AT_NOCASE (dbp
, "<h3>"))
5631 continue; /* look on the same line */
5642 * Assumes that the predicate or rule starts at column 0.
5643 * Only the first clause of a predicate or rule is added.
5644 * Original code by Sunichirou Sugou (1989)
5645 * Rewritten by Anders Lindgren (1996)
5647 static size_t prolog_pr (char *, char *);
5648 static void prolog_skip_comment (linebuffer
*, FILE *);
5649 static size_t prolog_atom (char *, size_t);
5652 Prolog_functions (FILE *inf
)
5662 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5664 if (cp
[0] == '\0') /* Empty line */
5666 else if (c_isspace (cp
[0])) /* Not a predicate */
5668 else if (cp
[0] == '/' && cp
[1] == '*') /* comment. */
5669 prolog_skip_comment (&lb
, inf
);
5670 else if ((len
= prolog_pr (cp
, last
)) > 0)
5672 /* Predicate or rule. Store the function name so that we
5673 only generate a tag for the first clause. */
5675 last
= xnew (len
+ 1, char);
5676 else if (len
+ 1 > allocated
)
5677 xrnew (last
, len
+ 1, char);
5678 allocated
= len
+ 1;
5679 memcpy (last
, cp
, len
);
5688 prolog_skip_comment (linebuffer
*plb
, FILE *inf
)
5694 for (cp
= plb
->buffer
; *cp
!= '\0'; cp
++)
5695 if (cp
[0] == '*' && cp
[1] == '/')
5697 readline (plb
, inf
);
5699 while (perhaps_more_input (inf
));
5703 * A predicate or rule definition is added if it matches:
5704 * <beginning of line><Prolog Atom><whitespace>(
5705 * or <beginning of line><Prolog Atom><whitespace>:-
5707 * It is added to the tags database if it doesn't match the
5708 * name of the previous clause header.
5710 * Return the size of the name of the predicate or rule, or 0 if no
5714 prolog_pr (char *s
, char *last
)
5716 /* Name of last clause. */
5721 pos
= prolog_atom (s
, 0);
5726 pos
= skip_spaces (s
+ pos
) - s
;
5729 || (s
[pos
] == '(' && (pos
+= 1))
5730 || (s
[pos
] == ':' && s
[pos
+ 1] == '-' && (pos
+= 2)))
5731 && (last
== NULL
/* save only the first clause */
5732 || len
!= strlen (last
)
5733 || !strneq (s
, last
, len
)))
5735 make_tag (s
, len
, true, s
, pos
, lineno
, linecharno
);
5743 * Consume a Prolog atom.
5744 * Return the number of bytes consumed, or 0 if there was an error.
5746 * A prolog atom, in this context, could be one of:
5747 * - An alphanumeric sequence, starting with a lower case letter.
5748 * - A quoted arbitrary string. Single quotes can escape themselves.
5749 * Backslash quotes everything.
5752 prolog_atom (char *s
, size_t pos
)
5758 if (c_islower (s
[pos
]) || s
[pos
] == '_')
5760 /* The atom is unquoted. */
5762 while (c_isalnum (s
[pos
]) || s
[pos
] == '_')
5766 return pos
- origpos
;
5768 else if (s
[pos
] == '\'')
5779 pos
++; /* A double quote */
5781 else if (s
[pos
] == '\0')
5782 /* Multiline quoted atoms are ignored. */
5784 else if (s
[pos
] == '\\')
5786 if (s
[pos
+1] == '\0')
5793 return pos
- origpos
;
5801 * Support for Erlang
5803 * Generates tags for functions, defines, and records.
5804 * Assumes that Erlang functions start at column 0.
5805 * Original code by Anders Lindgren (1996)
5807 static int erlang_func (char *, char *);
5808 static void erlang_attribute (char *);
5809 static int erlang_atom (char *);
5812 Erlang_functions (FILE *inf
)
5822 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5824 if (cp
[0] == '\0') /* Empty line */
5826 else if (c_isspace (cp
[0])) /* Not function nor attribute */
5828 else if (cp
[0] == '%') /* comment */
5830 else if (cp
[0] == '"') /* Sometimes, strings start in column one */
5832 else if (cp
[0] == '-') /* attribute, e.g. "-define" */
5834 erlang_attribute (cp
);
5841 else if ((len
= erlang_func (cp
, last
)) > 0)
5844 * Function. Store the function name so that we only
5845 * generates a tag for the first clause.
5848 last
= xnew (len
+ 1, char);
5849 else if (len
+ 1 > allocated
)
5850 xrnew (last
, len
+ 1, char);
5851 allocated
= len
+ 1;
5852 memcpy (last
, cp
, len
);
5861 * A function definition is added if it matches:
5862 * <beginning of line><Erlang Atom><whitespace>(
5864 * It is added to the tags database if it doesn't match the
5865 * name of the previous clause header.
5867 * Return the size of the name of the function, or 0 if no function
5871 erlang_func (char *s
, char *last
)
5873 /* Name of last clause. */
5878 pos
= erlang_atom (s
);
5883 pos
= skip_spaces (s
+ pos
) - s
;
5885 /* Save only the first clause. */
5888 || len
!= (int)strlen (last
)
5889 || !strneq (s
, last
, len
)))
5891 make_tag (s
, len
, true, s
, pos
, lineno
, linecharno
);
5900 * Handle attributes. Currently, tags are generated for defines
5903 * They are on the form:
5904 * -define(foo, bar).
5905 * -define(Foo(M, N), M+N).
5906 * -record(graph, {vtab = notable, cyclic = true}).
5909 erlang_attribute (char *s
)
5913 if ((LOOKING_AT (cp
, "-define") || LOOKING_AT (cp
, "-record"))
5916 int len
= erlang_atom (skip_spaces (cp
));
5918 make_tag (cp
, len
, true, s
, cp
+ len
- s
, lineno
, linecharno
);
5925 * Consume an Erlang atom (or variable).
5926 * Return the number of bytes consumed, or -1 if there was an error.
5929 erlang_atom (char *s
)
5933 if (c_isalpha (s
[pos
]) || s
[pos
] == '_')
5935 /* The atom is unquoted. */
5938 while (c_isalnum (s
[pos
]) || s
[pos
] == '_');
5940 else if (s
[pos
] == '\'')
5942 for (pos
++; s
[pos
] != '\''; pos
++)
5943 if (s
[pos
] == '\0' /* multiline quoted atoms are ignored */
5944 || (s
[pos
] == '\\' && s
[++pos
] == '\0'))
5953 static char *scan_separators (char *);
5954 static void add_regex (char *, language
*);
5955 static char *substitute (char *, char *, struct re_registers
*);
5958 * Take a string like "/blah/" and turn it into "blah", verifying
5959 * that the first and last characters are the same, and handling
5960 * quoted separator characters. Actually, stops on the occurrence of
5961 * an unquoted separator. Also process \t, \n, etc. and turn into
5962 * appropriate characters. Works in place. Null terminates name string.
5963 * Returns pointer to terminating separator, or NULL for
5964 * unterminated regexps.
5967 scan_separators (char *name
)
5970 char *copyto
= name
;
5971 bool quoted
= false;
5973 for (++name
; *name
!= '\0'; ++name
)
5979 case 'a': *copyto
++ = '\007'; break; /* BEL (bell) */
5980 case 'b': *copyto
++ = '\b'; break; /* BS (back space) */
5981 case 'd': *copyto
++ = 0177; break; /* DEL (delete) */
5982 case 'e': *copyto
++ = 033; break; /* ESC (delete) */
5983 case 'f': *copyto
++ = '\f'; break; /* FF (form feed) */
5984 case 'n': *copyto
++ = '\n'; break; /* NL (new line) */
5985 case 'r': *copyto
++ = '\r'; break; /* CR (carriage return) */
5986 case 't': *copyto
++ = '\t'; break; /* TAB (horizontal tab) */
5987 case 'v': *copyto
++ = '\v'; break; /* VT (vertical tab) */
5993 /* Something else is quoted, so preserve the quote. */
6001 else if (*name
== '\\')
6003 else if (*name
== sep
)
6009 name
= NULL
; /* signal unterminated regexp */
6011 /* Terminate copied string. */
6016 /* Look at the argument of --regex or --no-regex and do the right
6017 thing. Same for each line of a regexp file. */
6019 analyze_regex (char *regex_arg
)
6021 if (regex_arg
== NULL
)
6023 free_regexps (); /* --no-regex: remove existing regexps */
6027 /* A real --regexp option or a line in a regexp file. */
6028 switch (regex_arg
[0])
6030 /* Comments in regexp file or null arg to --regex. */
6036 /* Read a regex file. This is recursive and may result in a
6037 loop, which will stop when the file descriptors are exhausted. */
6041 linebuffer regexbuf
;
6042 char *regexfile
= regex_arg
+ 1;
6044 /* regexfile is a file containing regexps, one per line. */
6045 regexfp
= fopen (regexfile
, "r" FOPEN_BINARY
);
6046 if (regexfp
== NULL
)
6048 linebuffer_init (®exbuf
);
6049 while (readline_internal (®exbuf
, regexfp
, regexfile
) > 0)
6050 analyze_regex (regexbuf
.buffer
);
6051 free (regexbuf
.buffer
);
6052 if (fclose (regexfp
) != 0)
6057 /* Regexp to be used for a specific language only. */
6061 char *lang_name
= regex_arg
+ 1;
6064 for (cp
= lang_name
; *cp
!= '}'; cp
++)
6067 error ("unterminated language name in regex: %s", regex_arg
);
6071 lang
= get_language_from_langname (lang_name
);
6074 add_regex (cp
, lang
);
6078 /* Regexp to be used for any language. */
6080 add_regex (regex_arg
, NULL
);
6085 /* Separate the regexp pattern, compile it,
6086 and care for optional name and modifiers. */
6088 add_regex (char *regexp_pattern
, language
*lang
)
6090 static struct re_pattern_buffer zeropattern
;
6091 char sep
, *pat
, *name
, *modifiers
;
6094 struct re_pattern_buffer
*patbuf
;
6097 force_explicit_name
= true, /* do not use implicit tag names */
6098 ignore_case
= false, /* case is significant */
6099 multi_line
= false, /* matches are done one line at a time */
6100 single_line
= false; /* dot does not match newline */
6103 if (strlen (regexp_pattern
) < 3)
6105 error ("null regexp");
6108 sep
= regexp_pattern
[0];
6109 name
= scan_separators (regexp_pattern
);
6112 error ("%s: unterminated regexp", regexp_pattern
);
6117 error ("null name for regexp \"%s\"", regexp_pattern
);
6120 modifiers
= scan_separators (name
);
6121 if (modifiers
== NULL
) /* no terminating separator --> no name */
6127 modifiers
+= 1; /* skip separator */
6129 /* Parse regex modifiers. */
6130 for (; modifiers
[0] != '\0'; modifiers
++)
6131 switch (modifiers
[0])
6134 if (modifiers
== name
)
6135 error ("forcing explicit tag name but no name, ignoring");
6136 force_explicit_name
= true;
6146 need_filebuf
= true;
6149 error ("invalid regexp modifier '%c', ignoring", modifiers
[0]);
6153 patbuf
= xnew (1, struct re_pattern_buffer
);
6154 *patbuf
= zeropattern
;
6157 static char lc_trans
[UCHAR_MAX
+ 1];
6159 for (i
= 0; i
< UCHAR_MAX
+ 1; i
++)
6160 lc_trans
[i
] = c_tolower (i
);
6161 patbuf
->translate
= lc_trans
; /* translation table to fold case */
6165 pat
= concat ("^", regexp_pattern
, ""); /* anchor to beginning of line */
6167 pat
= regexp_pattern
;
6170 re_set_syntax (RE_SYNTAX_EMACS
| RE_DOT_NEWLINE
);
6172 re_set_syntax (RE_SYNTAX_EMACS
);
6174 err
= re_compile_pattern (pat
, strlen (pat
), patbuf
);
6179 error ("%s while compiling pattern", err
);
6184 p_head
= xnew (1, regexp
);
6185 p_head
->pattern
= savestr (regexp_pattern
);
6186 p_head
->p_next
= rp
;
6187 p_head
->lang
= lang
;
6188 p_head
->pat
= patbuf
;
6189 p_head
->name
= savestr (name
);
6190 p_head
->error_signaled
= false;
6191 p_head
->force_explicit_name
= force_explicit_name
;
6192 p_head
->ignore_case
= ignore_case
;
6193 p_head
->multi_line
= multi_line
;
6197 * Do the substitutions indicated by the regular expression and
6201 substitute (char *in
, char *out
, struct re_registers
*regs
)
6204 int size
, dig
, diglen
;
6207 size
= strlen (out
);
6209 /* Pass 1: figure out how much to allocate by finding all \N strings. */
6210 if (out
[size
- 1] == '\\')
6211 fatal ("pattern error in \"%s\"", out
);
6212 for (t
= strchr (out
, '\\');
6214 t
= strchr (t
+ 2, '\\'))
6215 if (c_isdigit (t
[1]))
6218 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
6224 /* Allocate space and do the substitutions. */
6226 result
= xnew (size
+ 1, char);
6228 for (t
= result
; *out
!= '\0'; out
++)
6229 if (*out
== '\\' && c_isdigit (*++out
))
6232 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
6233 memcpy (t
, in
+ regs
->start
[dig
], diglen
);
6240 assert (t
<= result
+ size
);
6241 assert (t
- result
== (int)strlen (result
));
6246 /* Deallocate all regexps. */
6251 while (p_head
!= NULL
)
6253 rp
= p_head
->p_next
;
6254 free (p_head
->pattern
);
6255 free (p_head
->name
);
6263 * Reads the whole file as a single string from `filebuf' and looks for
6264 * multi-line regular expressions, creating tags on matches.
6265 * readline already dealt with normal regexps.
6267 * Idea by Ben Wing <ben@666.com> (2002).
6270 regex_tag_multiline (void)
6272 char *buffer
= filebuf
.buffer
;
6276 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6280 if (!rp
->multi_line
)
6281 continue; /* skip normal regexps */
6283 /* Generic initializations before parsing file from memory. */
6284 lineno
= 1; /* reset global line number */
6285 charno
= 0; /* reset global char number */
6286 linecharno
= 0; /* reset global char number of line start */
6288 /* Only use generic regexps or those for the current language. */
6289 if (rp
->lang
!= NULL
&& rp
->lang
!= curfdp
->lang
)
6292 while (match
>= 0 && match
< filebuf
.len
)
6294 match
= re_search (rp
->pat
, buffer
, filebuf
.len
, charno
,
6295 filebuf
.len
- match
, &rp
->regs
);
6300 if (!rp
->error_signaled
)
6302 error ("regexp stack overflow while matching \"%s\"",
6304 rp
->error_signaled
= true;
6311 if (match
== rp
->regs
.end
[0])
6313 if (!rp
->error_signaled
)
6315 error ("regexp matches the empty string: \"%s\"",
6317 rp
->error_signaled
= true;
6319 match
= -3; /* exit from while loop */
6323 /* Match occurred. Construct a tag. */
6324 while (charno
< rp
->regs
.end
[0])
6325 if (buffer
[charno
++] == '\n')
6326 lineno
++, linecharno
= charno
;
6328 if (name
[0] == '\0')
6330 else /* make a named tag */
6331 name
= substitute (buffer
, rp
->name
, &rp
->regs
);
6332 if (rp
->force_explicit_name
)
6333 /* Force explicit tag name, if a name is there. */
6334 pfnote (name
, true, buffer
+ linecharno
,
6335 charno
- linecharno
+ 1, lineno
, linecharno
);
6337 make_tag (name
, strlen (name
), true, buffer
+ linecharno
,
6338 charno
- linecharno
+ 1, lineno
, linecharno
);
6347 nocase_tail (const char *cp
)
6351 while (*cp
!= '\0' && c_tolower (*cp
) == c_tolower (dbp
[len
]))
6353 if (*cp
== '\0' && !intoken (dbp
[len
]))
6362 get_tag (register char *bp
, char **namepp
)
6364 register char *cp
= bp
;
6368 /* Go till you get to white space or a syntactic break */
6369 for (cp
= bp
+ 1; !notinname (*cp
); cp
++)
6371 make_tag (bp
, cp
- bp
, true,
6372 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
6376 *namepp
= savenstr (bp
, cp
- bp
);
6380 * Read a line of text from `stream' into `lbp', excluding the
6381 * newline or CR-NL, if any. Return the number of characters read from
6382 * `stream', which is the length of the line including the newline.
6384 * On DOS or Windows we do not count the CR character, if any before the
6385 * NL, in the returned length; this mirrors the behavior of Emacs on those
6386 * platforms (for text files, it translates CR-NL to NL as it reads in the
6389 * If multi-line regular expressions are requested, each line read is
6390 * appended to `filebuf'.
6393 readline_internal (linebuffer
*lbp
, FILE *stream
, char const *filename
)
6395 char *buffer
= lbp
->buffer
;
6396 char *p
= lbp
->buffer
;
6400 pend
= p
+ lbp
->size
; /* Separate to avoid 386/IX compiler bug. */
6404 register int c
= getc (stream
);
6407 /* We're at the end of linebuffer: expand it. */
6409 xrnew (buffer
, lbp
->size
, char);
6410 p
+= buffer
- lbp
->buffer
;
6411 pend
= buffer
+ lbp
->size
;
6412 lbp
->buffer
= buffer
;
6416 if (ferror (stream
))
6424 if (p
> buffer
&& p
[-1] == '\r')
6438 lbp
->len
= p
- buffer
;
6440 if (need_filebuf
/* we need filebuf for multi-line regexps */
6441 && chars_deleted
> 0) /* not at EOF */
6443 while (filebuf
.size
<= filebuf
.len
+ lbp
->len
+ 1) /* +1 for \n */
6445 /* Expand filebuf. */
6447 xrnew (filebuf
.buffer
, filebuf
.size
, char);
6449 memcpy (filebuf
.buffer
+ filebuf
.len
, lbp
->buffer
, lbp
->len
);
6450 filebuf
.len
+= lbp
->len
;
6451 filebuf
.buffer
[filebuf
.len
++] = '\n';
6452 filebuf
.buffer
[filebuf
.len
] = '\0';
6455 return lbp
->len
+ chars_deleted
;
6459 * Like readline_internal, above, but in addition try to match the
6460 * input line against relevant regular expressions and manage #line
6464 readline (linebuffer
*lbp
, FILE *stream
)
6468 linecharno
= charno
; /* update global char number of line start */
6469 result
= readline_internal (lbp
, stream
, infilename
); /* read line */
6470 lineno
+= 1; /* increment global line number */
6471 charno
+= result
; /* increment global char number */
6473 /* Honor #line directives. */
6474 if (!no_line_directive
)
6476 static bool discard_until_line_directive
;
6478 /* Check whether this is a #line directive. */
6479 if (result
> 12 && strneq (lbp
->buffer
, "#line ", 6))
6484 if (sscanf (lbp
->buffer
, "#line %u \"%n", &lno
, &start
) >= 1
6485 && start
> 0) /* double quote character found */
6487 char *endp
= lbp
->buffer
+ start
;
6489 while ((endp
= strchr (endp
, '"')) != NULL
6490 && endp
[-1] == '\\')
6493 /* Ok, this is a real #line directive. Let's deal with it. */
6495 char *taggedabsname
; /* absolute name of original file */
6496 char *taggedfname
; /* name of original file as given */
6497 char *name
; /* temp var */
6499 discard_until_line_directive
= false; /* found it */
6500 name
= lbp
->buffer
+ start
;
6502 canonicalize_filename (name
);
6503 taggedabsname
= absolute_filename (name
, tagfiledir
);
6504 if (filename_is_absolute (name
)
6505 || filename_is_absolute (curfdp
->infname
))
6506 taggedfname
= savestr (taggedabsname
);
6508 taggedfname
= relative_filename (taggedabsname
,tagfiledir
);
6510 if (streq (curfdp
->taggedfname
, taggedfname
))
6511 /* The #line directive is only a line number change. We
6512 deal with this afterwards. */
6515 /* The tags following this #line directive should be
6516 attributed to taggedfname. In order to do this, set
6517 curfdp accordingly. */
6519 fdesc
*fdp
; /* file description pointer */
6521 /* Go look for a file description already set up for the
6522 file indicated in the #line directive. If there is
6523 one, use it from now until the next #line
6525 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6526 if (streq (fdp
->infname
, curfdp
->infname
)
6527 && streq (fdp
->taggedfname
, taggedfname
))
6528 /* If we remove the second test above (after the &&)
6529 then all entries pertaining to the same file are
6530 coalesced in the tags file. If we use it, then
6531 entries pertaining to the same file but generated
6532 from different files (via #line directives) will
6533 go into separate sections in the tags file. These
6534 alternatives look equivalent. The first one
6535 destroys some apparently useless information. */
6541 /* Else, if we already tagged the real file, skip all
6542 input lines until the next #line directive. */
6543 if (fdp
== NULL
) /* not found */
6544 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6545 if (streq (fdp
->infabsname
, taggedabsname
))
6547 discard_until_line_directive
= true;
6551 /* Else create a new file description and use that from
6552 now on, until the next #line directive. */
6553 if (fdp
== NULL
) /* not found */
6556 fdhead
= xnew (1, fdesc
);
6557 *fdhead
= *curfdp
; /* copy curr. file description */
6559 fdhead
->infname
= savestr (curfdp
->infname
);
6560 fdhead
->infabsname
= savestr (curfdp
->infabsname
);
6561 fdhead
->infabsdir
= savestr (curfdp
->infabsdir
);
6562 fdhead
->taggedfname
= taggedfname
;
6563 fdhead
->usecharno
= false;
6564 fdhead
->prop
= NULL
;
6565 fdhead
->written
= false;
6569 free (taggedabsname
);
6571 readline (lbp
, stream
);
6573 } /* if a real #line directive */
6574 } /* if #line is followed by a number */
6575 } /* if line begins with "#line " */
6577 /* If we are here, no #line directive was found. */
6578 if (discard_until_line_directive
)
6582 /* Do a tail recursion on ourselves, thus discarding the contents
6583 of the line buffer. */
6584 readline (lbp
, stream
);
6588 discard_until_line_directive
= false;
6591 } /* if #line directives should be considered */
6598 /* Match against relevant regexps. */
6600 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6602 /* Only use generic regexps or those for the current language.
6603 Also do not use multiline regexps, which is the job of
6604 regex_tag_multiline. */
6605 if ((rp
->lang
!= NULL
&& rp
->lang
!= fdhead
->lang
)
6609 match
= re_match (rp
->pat
, lbp
->buffer
, lbp
->len
, 0, &rp
->regs
);
6614 if (!rp
->error_signaled
)
6616 error ("regexp stack overflow while matching \"%s\"",
6618 rp
->error_signaled
= true;
6625 /* Empty string matched. */
6626 if (!rp
->error_signaled
)
6628 error ("regexp matches the empty string: \"%s\"", rp
->pattern
);
6629 rp
->error_signaled
= true;
6633 /* Match occurred. Construct a tag. */
6635 if (name
[0] == '\0')
6637 else /* make a named tag */
6638 name
= substitute (lbp
->buffer
, rp
->name
, &rp
->regs
);
6639 if (rp
->force_explicit_name
)
6640 /* Force explicit tag name, if a name is there. */
6641 pfnote (name
, true, lbp
->buffer
, match
, lineno
, linecharno
);
6643 make_tag (name
, strlen (name
), true,
6644 lbp
->buffer
, match
, lineno
, linecharno
);
6653 * Return a pointer to a space of size strlen(cp)+1 allocated
6654 * with xnew where the string CP has been copied.
6657 savestr (const char *cp
)
6659 return savenstr (cp
, strlen (cp
));
6663 * Return a pointer to a space of size LEN+1 allocated with xnew where
6664 * the string CP has been copied for at most the first LEN characters.
6667 savenstr (const char *cp
, int len
)
6669 char *dp
= xnew (len
+ 1, char);
6671 return memcpy (dp
, cp
, len
);
6674 /* Skip spaces (end of string is not space), return new pointer. */
6676 skip_spaces (char *cp
)
6678 while (c_isspace (*cp
))
6683 /* Skip non spaces, except end of string, return new pointer. */
6685 skip_non_spaces (char *cp
)
6687 while (*cp
!= '\0' && !c_isspace (*cp
))
6692 /* Skip any chars in the "name" class.*/
6694 skip_name (char *cp
)
6696 /* '\0' is a notinname() so loop stops there too */
6697 while (! notinname (*cp
))
6702 /* Print error message and exit. */
6704 fatal (char const *format
, ...)
6707 va_start (ap
, format
);
6708 verror (format
, ap
);
6710 exit (EXIT_FAILURE
);
6714 pfatal (const char *s1
)
6717 exit (EXIT_FAILURE
);
6721 suggest_asking_for_help (void)
6723 fprintf (stderr
, "\tTry '%s --help' for a complete list of options.\n",
6725 exit (EXIT_FAILURE
);
6728 /* Output a diagnostic with printf-style FORMAT and args. */
6730 error (const char *format
, ...)
6733 va_start (ap
, format
);
6734 verror (format
, ap
);
6739 verror (char const *format
, va_list ap
)
6741 fprintf (stderr
, "%s: ", progname
);
6742 vfprintf (stderr
, format
, ap
);
6743 fprintf (stderr
, "\n");
6746 /* Return a newly-allocated string whose contents
6747 concatenate those of s1, s2, s3. */
6749 concat (const char *s1
, const char *s2
, const char *s3
)
6751 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
6752 char *result
= xnew (len1
+ len2
+ len3
+ 1, char);
6754 strcpy (result
, s1
);
6755 strcpy (result
+ len1
, s2
);
6756 strcpy (result
+ len1
+ len2
, s3
);
6762 /* Does the same work as the system V getcwd, but does not need to
6763 guess the buffer size in advance. */
6768 char *path
= xnew (bufsize
, char);
6770 while (getcwd (path
, bufsize
) == NULL
)
6772 if (errno
!= ERANGE
)
6776 path
= xnew (bufsize
, char);
6779 canonicalize_filename (path
);
6783 /* Return a newly allocated string containing a name of a temporary file. */
6787 const char *tmpdir
= getenv ("TMPDIR");
6788 const char *slash
= "/";
6790 #if MSDOS || defined (DOS_NT)
6792 tmpdir
= getenv ("TEMP");
6794 tmpdir
= getenv ("TMP");
6797 if (tmpdir
[strlen (tmpdir
) - 1] == '/'
6798 || tmpdir
[strlen (tmpdir
) - 1] == '\\')
6803 if (tmpdir
[strlen (tmpdir
) - 1] == '/')
6807 char *templt
= concat (tmpdir
, slash
, "etXXXXXX");
6808 int fd
= mkostemp (templt
, O_CLOEXEC
);
6809 if (fd
< 0 || close (fd
) != 0)
6811 int temp_errno
= errno
;
6817 #if defined (DOS_NT)
6818 /* The file name will be used in shell redirection, so it needs to have
6819 DOS-style backslashes, or else the Windows shell will barf. */
6821 for (p
= templt
; *p
; p
++)
6829 /* Return a newly allocated string containing the file name of FILE
6830 relative to the absolute directory DIR (which should end with a slash). */
6832 relative_filename (char *file
, char *dir
)
6834 char *fp
, *dp
, *afn
, *res
;
6837 /* Find the common root of file and dir (with a trailing slash). */
6838 afn
= absolute_filename (file
, cwd
);
6841 while (*fp
++ == *dp
++)
6843 fp
--, dp
--; /* back to the first differing char */
6845 if (fp
== afn
&& afn
[0] != '/') /* cannot build a relative name */
6848 do /* look at the equal chars until '/' */
6852 /* Build a sequence of "../" strings for the resulting relative file name. */
6854 while ((dp
= strchr (dp
+ 1, '/')) != NULL
)
6856 res
= xnew (3*i
+ strlen (fp
+ 1) + 1, char);
6859 z
= stpcpy (z
, "../");
6861 /* Add the file name relative to the common root of file and dir. */
6868 /* Return a newly allocated string containing the absolute file name
6869 of FILE given DIR (which should end with a slash). */
6871 absolute_filename (char *file
, char *dir
)
6873 char *slashp
, *cp
, *res
;
6875 if (filename_is_absolute (file
))
6876 res
= savestr (file
);
6878 /* We don't support non-absolute file names with a drive
6879 letter, like `d:NAME' (it's too much hassle). */
6880 else if (file
[1] == ':')
6881 fatal ("%s: relative file names with drive letters not supported", file
);
6884 res
= concat (dir
, file
, "");
6886 /* Delete the "/dirname/.." and "/." substrings. */
6887 slashp
= strchr (res
, '/');
6888 while (slashp
!= NULL
&& slashp
[0] != '\0')
6890 if (slashp
[1] == '.')
6892 if (slashp
[2] == '.'
6893 && (slashp
[3] == '/' || slashp
[3] == '\0'))
6898 while (cp
>= res
&& !filename_is_absolute (cp
));
6900 cp
= slashp
; /* the absolute name begins with "/.." */
6902 /* Under MSDOS and NT we get `d:/NAME' as absolute
6903 file name, so the luser could say `d:/../NAME'.
6904 We silently treat this as `d:/NAME'. */
6905 else if (cp
[0] != '/')
6908 memmove (cp
, slashp
+ 3, strlen (slashp
+ 2));
6912 else if (slashp
[2] == '/' || slashp
[2] == '\0')
6914 memmove (slashp
, slashp
+ 2, strlen (slashp
+ 1));
6919 slashp
= strchr (slashp
+ 1, '/');
6922 if (res
[0] == '\0') /* just a safety net: should never happen */
6925 return savestr ("/");
6931 /* Return a newly allocated string containing the absolute
6932 file name of dir where FILE resides given DIR (which should
6933 end with a slash). */
6935 absolute_dirname (char *file
, char *dir
)
6940 slashp
= strrchr (file
, '/');
6942 return savestr (dir
);
6945 res
= absolute_filename (file
, dir
);
6951 /* Whether the argument string is an absolute file name. The argument
6952 string must have been canonicalized with canonicalize_filename. */
6954 filename_is_absolute (char *fn
)
6956 return (fn
[0] == '/'
6958 || (c_isalpha (fn
[0]) && fn
[1] == ':' && fn
[2] == '/')
6963 /* Downcase DOS drive letter and collapse separators into single slashes.
6966 canonicalize_filename (register char *fn
)
6971 /* Canonicalize drive letter case. */
6972 if (c_isupper (fn
[0]) && fn
[1] == ':')
6973 fn
[0] = c_tolower (fn
[0]);
6975 /* Collapse multiple forward- and back-slashes into a single forward
6977 for (cp
= fn
; *cp
!= '\0'; cp
++, fn
++)
6978 if (*cp
== '/' || *cp
== '\\')
6981 while (cp
[1] == '/' || cp
[1] == '\\')
6989 /* Collapse multiple slashes into a single slash. */
6990 for (cp
= fn
; *cp
!= '\0'; cp
++, fn
++)
6994 while (cp
[1] == '/')
7000 #endif /* !DOS_NT */
7006 /* Initialize a linebuffer for use. */
7008 linebuffer_init (linebuffer
*lbp
)
7010 lbp
->size
= (DEBUG
) ? 3 : 200;
7011 lbp
->buffer
= xnew (lbp
->size
, char);
7012 lbp
->buffer
[0] = '\0';
7016 /* Set the minimum size of a string contained in a linebuffer. */
7018 linebuffer_setlen (linebuffer
*lbp
, int toksize
)
7020 while (lbp
->size
<= toksize
)
7023 xrnew (lbp
->buffer
, lbp
->size
, char);
7028 /* Like malloc but get fatal error if memory is exhausted. */
7030 xmalloc (size_t size
)
7032 void *result
= malloc (size
);
7034 fatal ("virtual memory exhausted");
7039 xrealloc (void *ptr
, size_t size
)
7041 void *result
= realloc (ptr
, size
);
7043 fatal ("virtual memory exhausted");
7049 * indent-tabs-mode: t
7052 * c-font-lock-extra-types: ("FILE" "bool" "language" "linebuffer" "fdesc" "node" "regexp")
7053 * c-file-style: "gnu"
7057 /* etags.c ends here */