1 /* Tags file maker to go with GNU Emacs -*- coding: latin-1 -*-
3 Copyright (C) 1984 The Regents of the University of California
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are
8 1. Redistributions of source code must retain the above copyright
9 notice, this list of conditions and the following disclaimer.
10 2. Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the
14 3. Neither the name of the University nor the names of its
15 contributors may be used to endorse or promote products derived
16 from this software without specific prior written permission.
18 THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS''
19 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS
22 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
27 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
28 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 Copyright (C) 1984, 1987, 1988, 1989, 1993, 1994, 1995, 1998, 1999,
32 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
33 Free Software Foundation, Inc.
35 This file is not considered part of GNU Emacs.
37 This program is free software; you can redistribute it and/or modify
38 it under the terms of the GNU General Public License as published by
39 the Free Software Foundation; either version 2 of the License, or
40 (at your option) any later version.
42 This program is distributed in the hope that it will be useful,
43 but WITHOUT ANY WARRANTY; without even the implied warranty of
44 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
45 GNU General Public License for more details.
47 You should have received a copy of the GNU General Public License
48 along with this program; if not, write to the Free Software Foundation,
49 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
52 /* NB To comply with the above BSD license, copyright information is
53 reproduced in etc/ETAGS.README. That file should be updated when the
56 To the best of our knowledge, this code was originally based on the
57 ctags.c distributed with BSD4.2, which was copyrighted by the
58 University of California, as described above. */
63 * 1983 Ctags originally by Ken Arnold.
64 * 1984 Fortran added by Jim Kleckner.
65 * 1984 Ed Pelegri-Llopart added C typedefs.
66 * 1985 Emacs TAGS format by Richard Stallman.
67 * 1989 Sam Kendall added C++.
68 * 1992 Joseph B. Wells improved C and C++ parsing.
69 * 1993 Francesco Potortì reorganised C and C++.
70 * 1994 Line-by-line regexp tags by Tom Tromey.
71 * 2001 Nested classes by Francesco Potortì (concept by Mykola Dzyuba).
72 * 2002 #line directives by Francesco Potortì.
74 * Francesco Potortì <pot@gnu.org> has maintained and improved it since 1993.
78 * If you want to add support for a new language, start by looking at the LUA
79 * language, which is the simplest. Alternatively, consider shipping a
80 * configuration file containing regexp definitions for etags.
83 char pot_etags_version
[] = "@(#) pot revision number is 17.31";
93 # define NDEBUG /* disable assert */
98 /* On some systems, Emacs defines static as nothing for the sake
99 of unexec. We don't want that here since we don't use unexec. */
101 # ifndef PTR /* for XEmacs */
104 # ifndef __P /* for XEmacs */
105 # define __P(args) args
107 #else /* no config.h */
108 # if defined(__STDC__) && (__STDC__ || defined(__SUNPRO_C))
109 # define __P(args) args /* use prototypes */
110 # define PTR void * /* for generic pointers */
111 # else /* not standard C */
112 # define __P(args) () /* no prototypes */
113 # define const /* remove const for old compilers' sake */
114 # define PTR long * /* don't use void* */
116 #endif /* !HAVE_CONFIG_H */
119 # define _GNU_SOURCE 1 /* enables some compiler checks on GNU */
122 /* WIN32_NATIVE is for XEmacs.
123 MSDOS, WINDOWSNT, DOS_NT are for Emacs. */
128 #endif /* WIN32_NATIVE */
134 # include <sys/param.h>
136 # ifndef HAVE_CONFIG_H
138 # include <sys/config.h>
150 # define MAXPATHLEN _MAX_PATH
156 # endif /* undef HAVE_GETCWD */
157 #else /* not WINDOWSNT */
161 # else /* no standard C headers */
162 extern char *getenv ();
163 extern char *strcpy ();
164 extern char *strncpy ();
165 extern char *strcat ();
166 extern char *strncat ();
167 extern unsigned long strlen ();
168 extern PTR
malloc ();
169 extern PTR
realloc ();
171 # define EXIT_SUCCESS 1
172 # define EXIT_FAILURE 0
174 # define EXIT_SUCCESS 0
175 # define EXIT_FAILURE 1
178 #endif /* !WINDOWSNT */
183 # if defined (HAVE_GETCWD) && !defined (WINDOWSNT)
184 extern char *getcwd (char *buf
, size_t size
);
186 #endif /* HAVE_UNISTD_H */
194 #include <sys/types.h>
195 #include <sys/stat.h>
199 # undef assert /* some systems have a buggy assert.h */
200 # define assert(x) ((void) 0)
203 #if !defined (S_ISREG) && defined (S_IFREG)
204 # define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
207 #ifdef NO_LONG_OPTIONS /* define this if you don't have GNU getopt */
208 # define NO_LONG_OPTIONS TRUE
209 # define getopt_long(argc,argv,optstr,lopts,lind) getopt (argc, argv, optstr)
211 extern int optind
, opterr
;
213 # define NO_LONG_OPTIONS FALSE
215 #endif /* NO_LONG_OPTIONS */
217 #ifndef HAVE_CONFIG_H /* this is a standalone compilation */
218 # ifdef __CYGWIN__ /* compiling on Cygwin */
220 the regex
.h distributed with Cygwin is
not compatible with etags
, alas
!
221 If you want regular expression support
, you should
delete this notice
and
222 arrange to use the GNU regex
.h
and regex
.c
.
227 /* Define CTAGS to make the program "ctags" compatible with the usual one.
228 Leave it undefined to make the program "etags", which makes emacs-style
229 tag tables and tags typedefs, #defines and struct/union/enum by default. */
237 #define streq(s,t) (assert((s)!=NULL || (t)!=NULL), !strcmp (s, t))
238 #define strcaseeq(s,t) (assert((s)!=NULL && (t)!=NULL), !etags_strcasecmp (s, t))
239 #define strneq(s,t,n) (assert((s)!=NULL || (t)!=NULL), !strncmp (s, t, n))
240 #define strncaseeq(s,t,n) (assert((s)!=NULL && (t)!=NULL), !etags_strncasecmp (s, t, n))
242 #define CHARS 256 /* 2^sizeof(char) */
243 #define CHAR(x) ((unsigned int)(x) & (CHARS - 1))
244 #define iswhite(c) (_wht[CHAR(c)]) /* c is white (see white) */
245 #define notinname(c) (_nin[CHAR(c)]) /* c is not in a name (see nonam) */
246 #define begtoken(c) (_btk[CHAR(c)]) /* c can start token (see begtk) */
247 #define intoken(c) (_itk[CHAR(c)]) /* c can be in token (see midtk) */
248 #define endtoken(c) (_etk[CHAR(c)]) /* c ends tokens (see endtk) */
250 #define ISALNUM(c) isalnum (CHAR(c))
251 #define ISALPHA(c) isalpha (CHAR(c))
252 #define ISDIGIT(c) isdigit (CHAR(c))
253 #define ISLOWER(c) islower (CHAR(c))
255 #define lowcase(c) tolower (CHAR(c))
256 #define upcase(c) toupper (CHAR(c))
260 * xnew, xrnew -- allocate, reallocate storage
262 * SYNOPSIS: Type *xnew (int n, Type);
263 * void xrnew (OldPointer, int n, Type);
266 # include "chkmalloc.h"
267 # define xnew(n,Type) ((Type *) trace_malloc (__FILE__, __LINE__, \
268 (n) * sizeof (Type)))
269 # define xrnew(op,n,Type) ((op) = (Type *) trace_realloc (__FILE__, __LINE__, \
270 (char *) (op), (n) * sizeof (Type)))
272 # define xnew(n,Type) ((Type *) xmalloc ((n) * sizeof (Type)))
273 # define xrnew(op,n,Type) ((op) = (Type *) xrealloc ( \
274 (char *) (op), (n) * sizeof (Type)))
279 typedef void Lang_function
__P((FILE *));
283 char *suffix
; /* file name suffix for this compressor */
284 char *command
; /* takes one arg and decompresses to stdout */
289 char *name
; /* language name */
290 char *help
; /* detailed help for the language */
291 Lang_function
*function
; /* parse function */
292 char **suffixes
; /* name suffixes of this language's files */
293 char **filenames
; /* names of this language's files */
294 char **interpreters
; /* interpreters for this language */
295 bool metasource
; /* source used to generate other sources */
300 struct fdesc
*next
; /* for the linked list */
301 char *infname
; /* uncompressed input file name */
302 char *infabsname
; /* absolute uncompressed input file name */
303 char *infabsdir
; /* absolute dir of input file */
304 char *taggedfname
; /* file name to write in tagfile */
305 language
*lang
; /* language of file */
306 char *prop
; /* file properties to write in tagfile */
307 bool usecharno
; /* etags tags shall contain char number */
308 bool written
; /* entry written in the tags file */
311 typedef struct node_st
312 { /* sorting structure */
313 struct node_st
*left
, *right
; /* left and right sons */
314 fdesc
*fdp
; /* description of file to whom tag belongs */
315 char *name
; /* tag name */
316 char *regex
; /* search regexp */
317 bool valid
; /* write this tag on the tag file */
318 bool is_func
; /* function tag: use regexp in CTAGS mode */
319 bool been_warned
; /* warning already given for duplicated tag */
320 int lno
; /* line number tag is on */
321 long cno
; /* character number line starts on */
325 * A `linebuffer' is a structure which holds a line of text.
326 * `readline_internal' reads a line from a stream into a linebuffer
327 * and works regardless of the length of the line.
328 * SIZE is the size of BUFFER, LEN is the length of the string in
329 * BUFFER after readline reads it.
338 /* Used to support mixing of --lang and file names. */
342 at_language
, /* a language specification */
343 at_regexp
, /* a regular expression */
344 at_filename
, /* a file name */
345 at_stdin
, /* read from stdin here */
346 at_end
/* stop parsing the list */
347 } arg_type
; /* argument type */
348 language
*lang
; /* language associated with the argument */
349 char *what
; /* the argument itself */
352 /* Structure defining a regular expression. */
353 typedef struct regexp
355 struct regexp
*p_next
; /* pointer to next in list */
356 language
*lang
; /* if set, use only for this language */
357 char *pattern
; /* the regexp pattern */
358 char *name
; /* tag name */
359 struct re_pattern_buffer
*pat
; /* the compiled pattern */
360 struct re_registers regs
; /* re registers */
361 bool error_signaled
; /* already signaled for this regexp */
362 bool force_explicit_name
; /* do not allow implict tag name */
363 bool ignore_case
; /* ignore case when matching */
364 bool multi_line
; /* do a multi-line match on the whole file */
368 /* Many compilers barf on this:
369 Lang_function Ada_funcs;
370 so let's write it this way */
371 static void Ada_funcs
__P((FILE *));
372 static void Asm_labels
__P((FILE *));
373 static void C_entries
__P((int c_ext
, FILE *));
374 static void default_C_entries
__P((FILE *));
375 static void plain_C_entries
__P((FILE *));
376 static void Cjava_entries
__P((FILE *));
377 static void Cobol_paragraphs
__P((FILE *));
378 static void Cplusplus_entries
__P((FILE *));
379 static void Cstar_entries
__P((FILE *));
380 static void Erlang_functions
__P((FILE *));
381 static void Forth_words
__P((FILE *));
382 static void Fortran_functions
__P((FILE *));
383 static void HTML_labels
__P((FILE *));
384 static void Lisp_functions
__P((FILE *));
385 static void Lua_functions
__P((FILE *));
386 static void Makefile_targets
__P((FILE *));
387 static void Pascal_functions
__P((FILE *));
388 static void Perl_functions
__P((FILE *));
389 static void PHP_functions
__P((FILE *));
390 static void PS_functions
__P((FILE *));
391 static void Prolog_functions
__P((FILE *));
392 static void Python_functions
__P((FILE *));
393 static void Scheme_functions
__P((FILE *));
394 static void TeX_commands
__P((FILE *));
395 static void Texinfo_nodes
__P((FILE *));
396 static void Yacc_entries
__P((FILE *));
397 static void just_read_file
__P((FILE *));
399 static void print_language_names
__P((void));
400 static void print_version
__P((void));
401 static void print_help
__P((argument
*));
402 int main
__P((int, char **));
404 static compressor
*get_compressor_from_suffix
__P((char *, char **));
405 static language
*get_language_from_langname
__P((const char *));
406 static language
*get_language_from_interpreter
__P((char *));
407 static language
*get_language_from_filename
__P((char *, bool));
408 static void readline
__P((linebuffer
*, FILE *));
409 static long readline_internal
__P((linebuffer
*, FILE *));
410 static bool nocase_tail
__P((char *));
411 static void get_tag
__P((char *, char **));
413 static void analyse_regex
__P((char *));
414 static void free_regexps
__P((void));
415 static void regex_tag_multiline
__P((void));
416 static void error
__P((const char *, const char *));
417 static void suggest_asking_for_help
__P((void));
418 void fatal
__P((char *, char *));
419 static void pfatal
__P((char *));
420 static void add_node
__P((node
*, node
**));
422 static void init
__P((void));
423 static void process_file_name
__P((char *, language
*));
424 static void process_file
__P((FILE *, char *, language
*));
425 static void find_entries
__P((FILE *));
426 static void free_tree
__P((node
*));
427 static void free_fdesc
__P((fdesc
*));
428 static void pfnote
__P((char *, bool, char *, int, int, long));
429 static void make_tag
__P((char *, int, bool, char *, int, int, long));
430 static void invalidate_nodes
__P((fdesc
*, node
**));
431 static void put_entries
__P((node
*));
433 static char *concat
__P((char *, char *, char *));
434 static char *skip_spaces
__P((char *));
435 static char *skip_non_spaces
__P((char *));
436 static char *savenstr
__P((char *, int));
437 static char *savestr
__P((char *));
438 static char *etags_strchr
__P((const char *, int));
439 static char *etags_strrchr
__P((const char *, int));
440 static int etags_strcasecmp
__P((const char *, const char *));
441 static int etags_strncasecmp
__P((const char *, const char *, int));
442 static char *etags_getcwd
__P((void));
443 static char *relative_filename
__P((char *, char *));
444 static char *absolute_filename
__P((char *, char *));
445 static char *absolute_dirname
__P((char *, char *));
446 static bool filename_is_absolute
__P((char *f
));
447 static void canonicalize_filename
__P((char *));
448 static void linebuffer_init
__P((linebuffer
*));
449 static void linebuffer_setlen
__P((linebuffer
*, int));
450 static PTR xmalloc
__P((unsigned int));
451 static PTR xrealloc
__P((char *, unsigned int));
454 static char searchar
= '/'; /* use /.../ searches */
456 static char *tagfile
; /* output file */
457 static char *progname
; /* name this program was invoked with */
458 static char *cwd
; /* current working directory */
459 static char *tagfiledir
; /* directory of tagfile */
460 static FILE *tagf
; /* ioptr for tags file */
462 static fdesc
*fdhead
; /* head of file description list */
463 static fdesc
*curfdp
; /* current file description */
464 static int lineno
; /* line number of current line */
465 static long charno
; /* current character number */
466 static long linecharno
; /* charno of start of current line */
467 static char *dbp
; /* pointer to start of current tag */
469 static const int invalidcharno
= -1;
471 static node
*nodehead
; /* the head of the binary tree of tags */
472 static node
*last_node
; /* the last node created */
474 static linebuffer lb
; /* the current line */
475 static linebuffer filebuf
; /* a buffer containing the whole file */
476 static linebuffer token_name
; /* a buffer containing a tag name */
478 /* boolean "functions" (see init) */
479 static bool _wht
[CHARS
], _nin
[CHARS
], _itk
[CHARS
], _btk
[CHARS
], _etk
[CHARS
];
482 *white
= " \f\t\n\r\v",
484 *nonam
= " \f\t\n\r()=,;", /* look at make_tag before modifying! */
485 /* token ending chars */
486 *endtk
= " \t\n\r\"'#()[]{}=-+%*/&|^~!<>;,.:?",
487 /* token starting chars */
488 *begtk
= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$~@",
489 /* valid in-token chars */
490 *midtk
= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$0123456789";
492 static bool append_to_tagfile
; /* -a: append to tags */
493 /* The next five default to TRUE for etags, but to FALSE for ctags. */
494 static bool typedefs
; /* -t: create tags for C and Ada typedefs */
495 static bool typedefs_or_cplusplus
; /* -T: create tags for C typedefs, level */
496 /* 0 struct/enum/union decls, and C++ */
497 /* member functions. */
498 static bool constantypedefs
; /* -d: create tags for C #define, enum */
499 /* constants and variables. */
500 /* -D: opposite of -d. Default under ctags. */
501 static bool globals
; /* create tags for global variables */
502 static bool members
; /* create tags for C member variables */
503 static bool declarations
; /* --declarations: tag them and extern in C&Co*/
504 static bool no_line_directive
; /* ignore #line directives (undocumented) */
505 static bool no_duplicates
; /* no duplicate tags for ctags (undocumented) */
506 static bool update
; /* -u: update tags */
507 static bool vgrind_style
; /* -v: create vgrind style index output */
508 static bool no_warnings
; /* -w: suppress warnings (undocumented) */
509 static bool cxref_style
; /* -x: create cxref style output */
510 static bool cplusplus
; /* .[hc] means C++, not C */
511 static bool ignoreindent
; /* -I: ignore indentation in C */
512 static bool packages_only
; /* --packages-only: in Ada, only tag packages*/
514 /* STDIN is defined in LynxOS system headers */
519 #define STDIN 0x1001 /* returned by getopt_long on --parse-stdin */
520 static bool parsing_stdin
; /* --parse-stdin used */
522 static regexp
*p_head
; /* list of all regexps */
523 static bool need_filebuf
; /* some regexes are multi-line */
525 static struct option longopts
[] =
527 { "append", no_argument
, NULL
, 'a' },
528 { "packages-only", no_argument
, &packages_only
, TRUE
},
529 { "c++", no_argument
, NULL
, 'C' },
530 { "declarations", no_argument
, &declarations
, TRUE
},
531 { "no-line-directive", no_argument
, &no_line_directive
, TRUE
},
532 { "no-duplicates", no_argument
, &no_duplicates
, TRUE
},
533 { "help", no_argument
, NULL
, 'h' },
534 { "help", no_argument
, NULL
, 'H' },
535 { "ignore-indentation", no_argument
, NULL
, 'I' },
536 { "language", required_argument
, NULL
, 'l' },
537 { "members", no_argument
, &members
, TRUE
},
538 { "no-members", no_argument
, &members
, FALSE
},
539 { "output", required_argument
, NULL
, 'o' },
540 { "regex", required_argument
, NULL
, 'r' },
541 { "no-regex", no_argument
, NULL
, 'R' },
542 { "ignore-case-regex", required_argument
, NULL
, 'c' },
543 { "parse-stdin", required_argument
, NULL
, STDIN
},
544 { "version", no_argument
, NULL
, 'V' },
546 #if CTAGS /* Ctags options */
547 { "backward-search", no_argument
, NULL
, 'B' },
548 { "cxref", no_argument
, NULL
, 'x' },
549 { "defines", no_argument
, NULL
, 'd' },
550 { "globals", no_argument
, &globals
, TRUE
},
551 { "typedefs", no_argument
, NULL
, 't' },
552 { "typedefs-and-c++", no_argument
, NULL
, 'T' },
553 { "update", no_argument
, NULL
, 'u' },
554 { "vgrind", no_argument
, NULL
, 'v' },
555 { "no-warn", no_argument
, NULL
, 'w' },
557 #else /* Etags options */
558 { "no-defines", no_argument
, NULL
, 'D' },
559 { "no-globals", no_argument
, &globals
, FALSE
},
560 { "include", required_argument
, NULL
, 'i' },
565 static compressor compressors
[] =
567 { "z", "gzip -d -c"},
568 { "Z", "gzip -d -c"},
569 { "gz", "gzip -d -c"},
570 { "GZ", "gzip -d -c"},
571 { "bz2", "bzip2 -d -c" },
580 static char *Ada_suffixes
[] =
581 { "ads", "adb", "ada", NULL
};
582 static char Ada_help
[] =
583 "In Ada code, functions, procedures, packages, tasks and types are\n\
584 tags. Use the `--packages-only' option to create tags for\n\
586 Ada tag names have suffixes indicating the type of entity:\n\
587 Entity type: Qualifier:\n\
588 ------------ ----------\n\
595 Thus, `M-x find-tag <RET> bidule/b <RET>' will go directly to the\n\
596 body of the package `bidule', while `M-x find-tag <RET> bidule <RET>'\n\
597 will just search for any tag `bidule'.";
600 static char *Asm_suffixes
[] =
601 { "a", /* Unix assembler */
602 "asm", /* Microcontroller assembly */
603 "def", /* BSO/Tasking definition includes */
604 "inc", /* Microcontroller include files */
605 "ins", /* Microcontroller include files */
606 "s", "sa", /* Unix assembler */
607 "S", /* cpp-processed Unix assembler */
608 "src", /* BSO/Tasking C compiler output */
611 static char Asm_help
[] =
612 "In assembler code, labels appearing at the beginning of a line,\n\
613 followed by a colon, are tags.";
616 /* Note that .c and .h can be considered C++, if the --c++ flag was
617 given, or if the `class' or `template' keyowrds are met inside the file.
618 That is why default_C_entries is called for these. */
619 static char *default_C_suffixes
[] =
621 static char default_C_help
[] =
622 "In C code, any C function or typedef is a tag, and so are\n\
623 definitions of `struct', `union' and `enum'. `#define' macro\n\
624 definitions and `enum' constants are tags unless you specify\n\
625 `--no-defines'. Global variables are tags unless you specify\n\
626 `--no-globals' and so are struct members unless you specify\n\
627 `--no-members'. Use of `--no-globals', `--no-defines' and\n\
628 `--no-members' can make the tags table file much smaller.\n\
629 You can tag function declarations and external variables by\n\
630 using `--declarations'.";
632 static char *Cplusplus_suffixes
[] =
633 { "C", "c++", "cc", "cpp", "cxx", "H", "h++", "hh", "hpp", "hxx",
634 "M", /* Objective C++ */
635 "pdb", /* Postscript with C syntax */
637 static char Cplusplus_help
[] =
638 "In C++ code, all the tag constructs of C code are tagged. (Use\n\
639 --help --lang=c --lang=c++ for full help.)\n\
640 In addition to C tags, member functions are also recognized. Member\n\
641 variables are recognized unless you use the `--no-members' option.\n\
642 Tags for variables and functions in classes are named `CLASS::VARIABLE'\n\
643 and `CLASS::FUNCTION'. `operator' definitions have tag names like\n\
646 static char *Cjava_suffixes
[] =
648 static char Cjava_help
[] =
649 "In Java code, all the tags constructs of C and C++ code are\n\
650 tagged. (Use --help --lang=c --lang=c++ --lang=java for full help.)";
653 static char *Cobol_suffixes
[] =
654 { "COB", "cob", NULL
};
655 static char Cobol_help
[] =
656 "In Cobol code, tags are paragraph names; that is, any word\n\
657 starting in column 8 and followed by a period.";
659 static char *Cstar_suffixes
[] =
660 { "cs", "hs", NULL
};
662 static char *Erlang_suffixes
[] =
663 { "erl", "hrl", NULL
};
664 static char Erlang_help
[] =
665 "In Erlang code, the tags are the functions, records and macros\n\
666 defined in the file.";
668 char *Forth_suffixes
[] =
669 { "fth", "tok", NULL
};
670 static char Forth_help
[] =
671 "In Forth code, tags are words defined by `:',\n\
672 constant, code, create, defer, value, variable, buffer:, field.";
674 static char *Fortran_suffixes
[] =
675 { "F", "f", "f90", "for", NULL
};
676 static char Fortran_help
[] =
677 "In Fortran code, functions, subroutines and block data are tags.";
679 static char *HTML_suffixes
[] =
680 { "htm", "html", "shtml", NULL
};
681 static char HTML_help
[] =
682 "In HTML input files, the tags are the `title' and the `h1', `h2',\n\
683 `h3' headers. Also, tags are `name=' in anchors and all\n\
684 occurrences of `id='.";
686 static char *Lisp_suffixes
[] =
687 { "cl", "clisp", "el", "l", "lisp", "LSP", "lsp", "ml", NULL
};
688 static char Lisp_help
[] =
689 "In Lisp code, any function defined with `defun', any variable\n\
690 defined with `defvar' or `defconst', and in general the first\n\
691 argument of any expression that starts with `(def' in column zero\n\
694 static char *Lua_suffixes
[] =
695 { "lua", "LUA", NULL
};
696 static char Lua_help
[] =
697 "In Lua scripts, all functions are tags.";
699 static char *Makefile_filenames
[] =
700 { "Makefile", "makefile", "GNUMakefile", "Makefile.in", "Makefile.am", NULL
};
701 static char Makefile_help
[] =
702 "In makefiles, targets are tags; additionally, variables are tags\n\
703 unless you specify `--no-globals'.";
705 static char *Objc_suffixes
[] =
706 { "lm", /* Objective lex file */
707 "m", /* Objective C file */
709 static char Objc_help
[] =
710 "In Objective C code, tags include Objective C definitions for classes,\n\
711 class categories, methods and protocols. Tags for variables and\n\
712 functions in classes are named `CLASS::VARIABLE' and `CLASS::FUNCTION'.\n\
713 (Use --help --lang=c --lang=objc --lang=java for full help.)";
715 static char *Pascal_suffixes
[] =
716 { "p", "pas", NULL
};
717 static char Pascal_help
[] =
718 "In Pascal code, the tags are the functions and procedures defined\n\
720 /* " // this is for working around an Emacs highlighting bug... */
722 static char *Perl_suffixes
[] =
723 { "pl", "pm", NULL
};
724 static char *Perl_interpreters
[] =
725 { "perl", "@PERL@", NULL
};
726 static char Perl_help
[] =
727 "In Perl code, the tags are the packages, subroutines and variables\n\
728 defined by the `package', `sub', `my' and `local' keywords. Use\n\
729 `--globals' if you want to tag global variables. Tags for\n\
730 subroutines are named `PACKAGE::SUB'. The name for subroutines\n\
731 defined in the default package is `main::SUB'.";
733 static char *PHP_suffixes
[] =
734 { "php", "php3", "php4", NULL
};
735 static char PHP_help
[] =
736 "In PHP code, tags are functions, classes and defines. Unless you use\n\
737 the `--no-members' option, vars are tags too.";
739 static char *plain_C_suffixes
[] =
740 { "pc", /* Pro*C file */
743 static char *PS_suffixes
[] =
744 { "ps", "psw", NULL
}; /* .psw is for PSWrap */
745 static char PS_help
[] =
746 "In PostScript code, the tags are the functions.";
748 static char *Prolog_suffixes
[] =
750 static char Prolog_help
[] =
751 "In Prolog code, tags are predicates and rules at the beginning of\n\
754 static char *Python_suffixes
[] =
756 static char Python_help
[] =
757 "In Python code, `def' or `class' at the beginning of a line\n\
760 /* Can't do the `SCM' or `scm' prefix with a version number. */
761 static char *Scheme_suffixes
[] =
762 { "oak", "sch", "scheme", "SCM", "scm", "SM", "sm", "ss", "t", NULL
};
763 static char Scheme_help
[] =
764 "In Scheme code, tags include anything defined with `def' or with a\n\
765 construct whose name starts with `def'. They also include\n\
766 variables set with `set!' at top level in the file.";
768 static char *TeX_suffixes
[] =
769 { "bib", "clo", "cls", "ltx", "sty", "TeX", "tex", NULL
};
770 static char TeX_help
[] =
771 "In LaTeX text, the argument of any of the commands `\\chapter',\n\
772 `\\section', `\\subsection', `\\subsubsection', `\\eqno', `\\label',\n\
773 `\\ref', `\\cite', `\\bibitem', `\\part', `\\appendix', `\\entry',\n\
774 `\\index', `\\def', `\\newcommand', `\\renewcommand',\n\
775 `\\newenvironment' or `\\renewenvironment' is a tag.\n\
777 Other commands can be specified by setting the environment variable\n\
778 `TEXTAGS' to a colon-separated list like, for example,\n\
779 TEXTAGS=\"mycommand:myothercommand\".";
782 static char *Texinfo_suffixes
[] =
783 { "texi", "texinfo", "txi", NULL
};
784 static char Texinfo_help
[] =
785 "for texinfo files, lines starting with @node are tagged.";
787 static char *Yacc_suffixes
[] =
788 { "y", "y++", "ym", "yxx", "yy", NULL
}; /* .ym is Objective yacc file */
789 static char Yacc_help
[] =
790 "In Bison or Yacc input files, each rule defines as a tag the\n\
791 nonterminal it constructs. The portions of the file that contain\n\
792 C code are parsed as C code (use --help --lang=c --lang=yacc\n\
795 static char auto_help
[] =
796 "`auto' is not a real language, it indicates to use\n\
797 a default language for files base on file name suffix and file contents.";
799 static char none_help
[] =
800 "`none' is not a real language, it indicates to only do\n\
801 regexp processing on files.";
803 static char no_lang_help
[] =
804 "No detailed help available for this language.";
808 * Table of languages.
810 * It is ok for a given function to be listed under more than one
811 * name. I just didn't.
814 static language lang_names
[] =
816 { "ada", Ada_help
, Ada_funcs
, Ada_suffixes
},
817 { "asm", Asm_help
, Asm_labels
, Asm_suffixes
},
818 { "c", default_C_help
, default_C_entries
, default_C_suffixes
},
819 { "c++", Cplusplus_help
, Cplusplus_entries
, Cplusplus_suffixes
},
820 { "c*", no_lang_help
, Cstar_entries
, Cstar_suffixes
},
821 { "cobol", Cobol_help
, Cobol_paragraphs
, Cobol_suffixes
},
822 { "erlang", Erlang_help
, Erlang_functions
, Erlang_suffixes
},
823 { "forth", Forth_help
, Forth_words
, Forth_suffixes
},
824 { "fortran", Fortran_help
, Fortran_functions
, Fortran_suffixes
},
825 { "html", HTML_help
, HTML_labels
, HTML_suffixes
},
826 { "java", Cjava_help
, Cjava_entries
, Cjava_suffixes
},
827 { "lisp", Lisp_help
, Lisp_functions
, Lisp_suffixes
},
828 { "lua", Lua_help
, Lua_functions
, Lua_suffixes
},
829 { "makefile", Makefile_help
,Makefile_targets
,NULL
,Makefile_filenames
},
830 { "objc", Objc_help
, plain_C_entries
, Objc_suffixes
},
831 { "pascal", Pascal_help
, Pascal_functions
, Pascal_suffixes
},
832 { "perl",Perl_help
,Perl_functions
,Perl_suffixes
,NULL
,Perl_interpreters
},
833 { "php", PHP_help
, PHP_functions
, PHP_suffixes
},
834 { "postscript",PS_help
, PS_functions
, PS_suffixes
},
835 { "proc", no_lang_help
, plain_C_entries
, plain_C_suffixes
},
836 { "prolog", Prolog_help
, Prolog_functions
, Prolog_suffixes
},
837 { "python", Python_help
, Python_functions
, Python_suffixes
},
838 { "scheme", Scheme_help
, Scheme_functions
, Scheme_suffixes
},
839 { "tex", TeX_help
, TeX_commands
, TeX_suffixes
},
840 { "texinfo", Texinfo_help
, Texinfo_nodes
, Texinfo_suffixes
},
841 { "yacc", Yacc_help
,Yacc_entries
,Yacc_suffixes
,NULL
,NULL
,TRUE
},
842 { "auto", auto_help
}, /* default guessing scheme */
843 { "none", none_help
, just_read_file
}, /* regexp matching only */
844 { NULL
} /* end of list */
849 print_language_names ()
854 puts ("\nThese are the currently supported languages, along with the\n\
855 default file names and dot suffixes:");
856 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
858 printf (" %-*s", 10, lang
->name
);
859 if (lang
->filenames
!= NULL
)
860 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
861 printf (" %s", *name
);
862 if (lang
->suffixes
!= NULL
)
863 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
864 printf (" .%s", *ext
);
867 puts ("where `auto' means use default language for files based on file\n\
868 name suffix, and `none' means only do regexp processing on files.\n\
869 If no language is specified and no matching suffix is found,\n\
870 the first line of the file is read for a sharp-bang (#!) sequence\n\
871 followed by the name of an interpreter. If no such sequence is found,\n\
872 Fortran is tried first; if no tags are found, C is tried next.\n\
873 When parsing any C file, a \"class\" or \"template\" keyword\n\
875 puts ("Compressed files are supported using gzip and bzip2.\n\
877 For detailed help on a given language use, for example,\n\
878 etags --help --lang=ada.");
882 # define EMACS_NAME "standalone"
885 # define VERSION "17.31"
890 /* Makes it easier to update automatically. */
891 char emacs_copyright
[] = "Copyright (C) 2007 Free Software Foundation, Inc.";
893 printf ("%s (%s %s)\n", (CTAGS
) ? "ctags" : "etags", EMACS_NAME
, VERSION
);
894 puts (emacs_copyright
);
895 puts ("This program is distributed under the terms in ETAGS.README");
901 print_help (argbuffer
)
904 bool help_for_lang
= FALSE
;
906 for (; argbuffer
->arg_type
!= at_end
; argbuffer
++)
907 if (argbuffer
->arg_type
== at_language
)
911 puts (argbuffer
->lang
->help
);
912 help_for_lang
= TRUE
;
918 printf ("Usage: %s [options] [[regex-option ...] file-name] ...\n\
920 These are the options accepted by %s.\n", progname
, progname
);
922 puts ("WARNING: long option names do not work with this executable,\n\
923 as it is not linked with GNU getopt.");
925 puts ("You may use unambiguous abbreviations for the long option names.");
926 puts (" A - as file name means read names from stdin (one per line).\n\
927 Absolute names are stored in the output file as they are.\n\
928 Relative ones are stored relative to the output file's directory.\n");
930 puts ("-a, --append\n\
931 Append tag entries to existing tags file.");
933 puts ("--packages-only\n\
934 For Ada files, only generate tags for packages.");
937 puts ("-B, --backward-search\n\
938 Write the search commands for the tag entries using '?', the\n\
939 backward-search command instead of '/', the forward-search command.");
941 /* This option is mostly obsolete, because etags can now automatically
942 detect C++. Retained for backward compatibility and for debugging and
943 experimentation. In principle, we could want to tag as C++ even
944 before any "class" or "template" keyword.
946 Treat files whose name suffix defaults to C language as C++ files.");
949 puts ("--declarations\n\
950 In C and derived languages, create tags for function declarations,");
952 puts ("\tand create tags for extern variables if --globals is used.");
955 ("\tand create tags for extern variables unless --no-globals is used.");
958 puts ("-d, --defines\n\
959 Create tag entries for C #define constants and enum constants, too.");
961 puts ("-D, --no-defines\n\
962 Don't create tag entries for C #define constants and enum constants.\n\
963 This makes the tags file smaller.");
966 puts ("-i FILE, --include=FILE\n\
967 Include a note in tag file indicating that, when searching for\n\
968 a tag, one should also consult the tags file FILE after\n\
969 checking the current file.");
971 puts ("-l LANG, --language=LANG\n\
972 Force the following files to be considered as written in the\n\
973 named language up to the next --language=LANG option.");
977 Create tag entries for global variables in some languages.");
979 puts ("--no-globals\n\
980 Do not create tag entries for global variables in some\n\
981 languages. This makes the tags file smaller.");
984 Create tag entries for members of structures in some languages.");
986 puts ("--no-members\n\
987 Do not create tag entries for members of structures\n\
988 in some languages.");
990 puts ("-r REGEXP, --regex=REGEXP or --regex=@regexfile\n\
991 Make a tag for each line matching a regular expression pattern\n\
992 in the following files. {LANGUAGE}REGEXP uses REGEXP for LANGUAGE\n\
993 files only. REGEXFILE is a file containing one REGEXP per line.\n\
994 REGEXP takes the form /TAGREGEXP/TAGNAME/MODS, where TAGNAME/ is\n\
995 optional. The TAGREGEXP pattern is anchored (as if preceded by ^).");
996 puts (" If TAGNAME/ is present, the tags created are named.\n\
997 For example Tcl named tags can be created with:\n\
998 --regex=\"/proc[ \\t]+\\([^ \\t]+\\)/\\1/.\".\n\
999 MODS are optional one-letter modifiers: `i' means to ignore case,\n\
1000 `m' means to allow multi-line matches, `s' implies `m' and\n\
1001 causes dot to match any character, including newline.");
1002 puts ("-R, --no-regex\n\
1003 Don't create tags from regexps for the following files.");
1004 puts ("-I, --ignore-indentation\n\
1005 In C and C++ do not assume that a closing brace in the first\n\
1006 column is the final brace of a function or structure definition.");
1007 puts ("-o FILE, --output=FILE\n\
1008 Write the tags to FILE.");
1009 puts ("--parse-stdin=NAME\n\
1010 Read from standard input and record tags as belonging to file NAME.");
1014 puts ("-t, --typedefs\n\
1015 Generate tag entries for C and Ada typedefs.");
1016 puts ("-T, --typedefs-and-c++\n\
1017 Generate tag entries for C typedefs, C struct/enum/union tags,\n\
1018 and C++ member functions.");
1022 puts ("-u, --update\n\
1023 Update the tag entries for the given files, leaving tag\n\
1024 entries for other files in place. Currently, this is\n\
1025 implemented by deleting the existing entries for the given\n\
1026 files and then rewriting the new entries at the end of the\n\
1027 tags file. It is often faster to simply rebuild the entire\n\
1028 tag file than to use this.");
1032 puts ("-v, --vgrind\n\
1033 Print on the standard output an index of items intended for\n\
1034 human consumption, similar to the output of vgrind. The index\n\
1035 is sorted, and gives the page number of each item.");
1036 # if PRINT_UNDOCUMENTED_OPTIONS_HELP
1037 puts ("-w, --no-duplicates\n\
1038 Do not create duplicate tag entries, for compatibility with\n\
1039 traditional ctags.");
1040 puts ("-w, --no-warn\n\
1041 Suppress warning messages about duplicate tag entries.");
1042 # endif /* PRINT_UNDOCUMENTED_OPTIONS_HELP */
1043 puts ("-x, --cxref\n\
1044 Like --vgrind, but in the style of cxref, rather than vgrind.\n\
1045 The output uses line numbers instead of page numbers, but\n\
1046 beyond that the differences are cosmetic; try both to see\n\
1050 puts ("-V, --version\n\
1051 Print the version of the program.\n\
1053 Print this help message.\n\
1054 Followed by one or more `--language' options prints detailed\n\
1055 help about tag generation for the specified languages.");
1057 print_language_names ();
1060 puts ("Report bugs to bug-gnu-emacs@gnu.org");
1062 exit (EXIT_SUCCESS
);
1066 #ifdef VMS /* VMS specific functions */
1070 /* This is a BUG! ANY arbitrary limit is a BUG!
1071 Won't someone please fix this? */
1072 #define MAX_FILE_SPEC_LEN 255
1075 char body
[MAX_FILE_SPEC_LEN
+ 1];
1079 v1.05 nmm 26-Jun-86 fn_exp - expand specification of list of file names
1080 returning in each successive call the next file name matching the input
1081 spec. The function expects that each in_spec passed
1082 to it will be processed to completion; in particular, up to and
1083 including the call following that in which the last matching name
1084 is returned, the function ignores the value of in_spec, and will
1085 only start processing a new spec with the following call.
1086 If an error occurs, on return out_spec contains the value
1087 of in_spec when the error occurred.
1089 With each successive file name returned in out_spec, the
1090 function's return value is one. When there are no more matching
1091 names the function returns zero. If on the first call no file
1092 matches in_spec, or there is any other error, -1 is returned.
1096 #include <descrip.h>
1097 #define OUTSIZE MAX_FILE_SPEC_LEN
1103 static long context
= 0;
1104 static struct dsc$descriptor_s o
;
1105 static struct dsc$descriptor_s i
;
1106 static bool pass1
= TRUE
;
1113 o
.dsc$a_pointer
= (char *) out
;
1114 o
.dsc$w_length
= (short)OUTSIZE
;
1115 i
.dsc$a_pointer
= in
;
1116 i
.dsc$w_length
= (short)strlen(in
);
1117 i
.dsc$b_dtype
= DSC$K_DTYPE_T
;
1118 i
.dsc$b_class
= DSC$K_CLASS_S
;
1119 o
.dsc$b_dtype
= DSC$K_DTYPE_VT
;
1120 o
.dsc$b_class
= DSC$K_CLASS_VS
;
1122 if ((status
= lib$
find_file(&i
, &o
, &context
, 0, 0)) == RMS$_NORMAL
)
1124 out
->body
[out
->curlen
] = EOS
;
1127 else if (status
== RMS$_NMF
)
1131 strcpy(out
->body
, in
);
1134 lib$
find_file_end(&context
);
1140 v1.01 nmm 19-Aug-85 gfnames - return in successive calls the
1141 name of each file specified by the provided arg expanding wildcards.
1144 gfnames (arg
, p_error
)
1148 static vspec filename
= {MAX_FILE_SPEC_LEN
, "\0"};
1150 switch (fn_exp (&filename
, arg
))
1154 return filename
.body
;
1160 return filename
.body
;
1164 #ifndef OLD /* Newer versions of VMS do provide `system'. */
1168 error ("%s", "system() function not implemented under VMS");
1172 #define VERSION_DELIM ';'
1173 char *massage_name (s
)
1179 if (*s
== VERSION_DELIM
)
1197 unsigned int nincluded_files
;
1198 char **included_files
;
1199 argument
*argbuffer
;
1200 int current_arg
, file_count
;
1201 linebuffer filename_lb
;
1202 bool help_asked
= FALSE
;
1211 _fmode
= O_BINARY
; /* all of files are treated as binary files */
1215 nincluded_files
= 0;
1216 included_files
= xnew (argc
, char *);
1220 /* Allocate enough no matter what happens. Overkill, but each one
1222 argbuffer
= xnew (argc
, argument
);
1225 * If etags, always find typedefs and structure tags. Why not?
1226 * Also default to find macro constants, enum constants, struct
1227 * members and global variables.
1231 typedefs
= typedefs_or_cplusplus
= constantypedefs
= TRUE
;
1232 globals
= members
= TRUE
;
1235 /* When the optstring begins with a '-' getopt_long does not rearrange the
1236 non-options arguments to be at the end, but leaves them alone. */
1237 optstring
= concat (NO_LONG_OPTIONS
? "" : "-",
1238 "ac:Cf:Il:o:r:RSVhH",
1239 (CTAGS
) ? "BxdtTuvw" : "Di:");
1241 while ((opt
= getopt_long (argc
, argv
, optstring
, longopts
, NULL
)) != EOF
)
1245 /* If getopt returns 0, then it has already processed a
1246 long-named option. We should do nothing. */
1250 /* This means that a file name has been seen. Record it. */
1251 argbuffer
[current_arg
].arg_type
= at_filename
;
1252 argbuffer
[current_arg
].what
= optarg
;
1258 /* Parse standard input. Idea by Vivek <vivek@etla.org>. */
1259 argbuffer
[current_arg
].arg_type
= at_stdin
;
1260 argbuffer
[current_arg
].what
= optarg
;
1264 fatal ("cannot parse standard input more than once", (char *)NULL
);
1265 parsing_stdin
= TRUE
;
1268 /* Common options. */
1269 case 'a': append_to_tagfile
= TRUE
; break;
1270 case 'C': cplusplus
= TRUE
; break;
1271 case 'f': /* for compatibility with old makefiles */
1275 error ("-o option may only be given once.", (char *)NULL
);
1276 suggest_asking_for_help ();
1282 case 'S': /* for backward compatibility */
1283 ignoreindent
= TRUE
;
1287 language
*lang
= get_language_from_langname (optarg
);
1290 argbuffer
[current_arg
].lang
= lang
;
1291 argbuffer
[current_arg
].arg_type
= at_language
;
1297 /* Backward compatibility: support obsolete --ignore-case-regexp. */
1298 optarg
= concat (optarg
, "i", ""); /* memory leak here */
1301 argbuffer
[current_arg
].arg_type
= at_regexp
;
1302 argbuffer
[current_arg
].what
= optarg
;
1306 argbuffer
[current_arg
].arg_type
= at_regexp
;
1307 argbuffer
[current_arg
].what
= NULL
;
1319 case 'D': constantypedefs
= FALSE
; break;
1320 case 'i': included_files
[nincluded_files
++] = optarg
; break;
1322 /* Ctags options. */
1323 case 'B': searchar
= '?'; break;
1324 case 'd': constantypedefs
= TRUE
; break;
1325 case 't': typedefs
= TRUE
; break;
1326 case 'T': typedefs
= typedefs_or_cplusplus
= TRUE
; break;
1327 case 'u': update
= TRUE
; break;
1328 case 'v': vgrind_style
= TRUE
; /*FALLTHRU*/
1329 case 'x': cxref_style
= TRUE
; break;
1330 case 'w': no_warnings
= TRUE
; break;
1332 suggest_asking_for_help ();
1336 /* No more options. Store the rest of arguments. */
1337 for (; optind
< argc
; optind
++)
1339 argbuffer
[current_arg
].arg_type
= at_filename
;
1340 argbuffer
[current_arg
].what
= argv
[optind
];
1345 argbuffer
[current_arg
].arg_type
= at_end
;
1348 print_help (argbuffer
);
1351 if (nincluded_files
== 0 && file_count
== 0)
1353 error ("no input files specified.", (char *)NULL
);
1354 suggest_asking_for_help ();
1358 if (tagfile
== NULL
)
1359 tagfile
= CTAGS
? "tags" : "TAGS";
1360 cwd
= etags_getcwd (); /* the current working directory */
1361 if (cwd
[strlen (cwd
) - 1] != '/')
1364 cwd
= concat (oldcwd
, "/", "");
1367 /* Relative file names are made relative to the current directory. */
1368 if (streq (tagfile
, "-")
1369 || strneq (tagfile
, "/dev/", 5))
1372 tagfiledir
= absolute_dirname (tagfile
, cwd
);
1374 init (); /* set up boolean "functions" */
1376 linebuffer_init (&lb
);
1377 linebuffer_init (&filename_lb
);
1378 linebuffer_init (&filebuf
);
1379 linebuffer_init (&token_name
);
1383 if (streq (tagfile
, "-"))
1387 /* Switch redirected `stdout' to binary mode (setting `_fmode'
1388 doesn't take effect until after `stdout' is already open). */
1389 if (!isatty (fileno (stdout
)))
1390 setmode (fileno (stdout
), O_BINARY
);
1394 tagf
= fopen (tagfile
, append_to_tagfile
? "a" : "w");
1400 * Loop through files finding functions.
1402 for (i
= 0; i
< current_arg
; i
++)
1404 static language
*lang
; /* non-NULL if language is forced */
1407 switch (argbuffer
[i
].arg_type
)
1410 lang
= argbuffer
[i
].lang
;
1413 analyse_regex (argbuffer
[i
].what
);
1417 while ((this_file
= gfnames (argbuffer
[i
].what
, &got_err
)) != NULL
)
1421 error ("can't find file %s\n", this_file
);
1426 this_file
= massage_name (this_file
);
1429 this_file
= argbuffer
[i
].what
;
1431 /* Input file named "-" means read file names from stdin
1432 (one per line) and use them. */
1433 if (streq (this_file
, "-"))
1436 fatal ("cannot parse standard input AND read file names from it",
1438 while (readline_internal (&filename_lb
, stdin
) > 0)
1439 process_file_name (filename_lb
.buffer
, lang
);
1442 process_file_name (this_file
, lang
);
1448 this_file
= argbuffer
[i
].what
;
1449 process_file (stdin
, this_file
, lang
);
1456 free (filebuf
.buffer
);
1457 free (token_name
.buffer
);
1459 if (!CTAGS
|| cxref_style
)
1461 /* Write the remaining tags to tagf (ETAGS) or stdout (CXREF). */
1462 put_entries (nodehead
);
1463 free_tree (nodehead
);
1469 /* Output file entries that have no tags. */
1470 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1472 fprintf (tagf
, "\f\n%s,0\n", fdp
->taggedfname
);
1474 while (nincluded_files
-- > 0)
1475 fprintf (tagf
, "\f\n%s,include\n", *included_files
++);
1477 if (fclose (tagf
) == EOF
)
1481 exit (EXIT_SUCCESS
);
1487 for (i
= 0; i
< current_arg
; ++i
)
1489 switch (argbuffer
[i
].arg_type
)
1495 continue; /* the for loop */
1498 "mv %s OTAGS;fgrep -v '\t%s\t' OTAGS >%s;rm OTAGS",
1499 tagfile
, argbuffer
[i
].what
, tagfile
);
1500 if (system (cmd
) != EXIT_SUCCESS
)
1501 fatal ("failed to execute shell command", (char *)NULL
);
1503 append_to_tagfile
= TRUE
;
1506 tagf
= fopen (tagfile
, append_to_tagfile
? "a" : "w");
1509 put_entries (nodehead
); /* write all the tags (CTAGS) */
1510 free_tree (nodehead
);
1512 if (fclose (tagf
) == EOF
)
1516 if (append_to_tagfile
|| update
)
1518 char cmd
[2*BUFSIZ
+20];
1519 /* Maybe these should be used:
1520 setenv ("LC_COLLATE", "C", 1);
1521 setenv ("LC_ALL", "C", 1); */
1522 sprintf (cmd
, "sort -u -o %.*s %.*s", BUFSIZ
, tagfile
, BUFSIZ
, tagfile
);
1523 exit (system (cmd
));
1525 return EXIT_SUCCESS
;
1530 * Return a compressor given the file name. If EXTPTR is non-zero,
1531 * return a pointer into FILE where the compressor-specific
1532 * extension begins. If no compressor is found, NULL is returned
1533 * and EXTPTR is not significant.
1534 * Idea by Vladimir Alexiev <vladimir@cs.ualberta.ca> (1998)
1537 get_compressor_from_suffix (file
, extptr
)
1542 char *slash
, *suffix
;
1544 /* This relies on FN to be after canonicalize_filename,
1545 so we don't need to consider backslashes on DOS_NT. */
1546 slash
= etags_strrchr (file
, '/');
1547 suffix
= etags_strrchr (file
, '.');
1548 if (suffix
== NULL
|| suffix
< slash
)
1553 /* Let those poor souls who live with DOS 8+3 file name limits get
1554 some solace by treating foo.cgz as if it were foo.c.gz, etc.
1555 Only the first do loop is run if not MSDOS */
1558 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1559 if (streq (compr
->suffix
, suffix
))
1562 break; /* do it only once: not really a loop */
1565 } while (*suffix
!= '\0');
1572 * Return a language given the name.
1575 get_language_from_langname (name
)
1581 error ("empty language name", (char *)NULL
);
1584 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1585 if (streq (name
, lang
->name
))
1587 error ("unknown language \"%s\"", name
);
1595 * Return a language given the interpreter name.
1598 get_language_from_interpreter (interpreter
)
1604 if (interpreter
== NULL
)
1606 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1607 if (lang
->interpreters
!= NULL
)
1608 for (iname
= lang
->interpreters
; *iname
!= NULL
; iname
++)
1609 if (streq (*iname
, interpreter
))
1618 * Return a language given the file name.
1621 get_language_from_filename (file
, case_sensitive
)
1623 bool case_sensitive
;
1626 char **name
, **ext
, *suffix
;
1628 /* Try whole file name first. */
1629 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1630 if (lang
->filenames
!= NULL
)
1631 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
1632 if ((case_sensitive
)
1633 ? streq (*name
, file
)
1634 : strcaseeq (*name
, file
))
1637 /* If not found, try suffix after last dot. */
1638 suffix
= etags_strrchr (file
, '.');
1642 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1643 if (lang
->suffixes
!= NULL
)
1644 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
1645 if ((case_sensitive
)
1646 ? streq (*ext
, suffix
)
1647 : strcaseeq (*ext
, suffix
))
1654 * This routine is called on each file argument.
1657 process_file_name (file
, lang
)
1661 struct stat stat_buf
;
1665 char *compressed_name
, *uncompressed_name
;
1666 char *ext
, *real_name
;
1669 canonicalize_filename (file
);
1670 if (streq (file
, tagfile
) && !streq (tagfile
, "-"))
1672 error ("skipping inclusion of %s in self.", file
);
1675 if ((compr
= get_compressor_from_suffix (file
, &ext
)) == NULL
)
1677 compressed_name
= NULL
;
1678 real_name
= uncompressed_name
= savestr (file
);
1682 real_name
= compressed_name
= savestr (file
);
1683 uncompressed_name
= savenstr (file
, ext
- file
);
1686 /* If the canonicalized uncompressed name
1687 has already been dealt with, skip it silently. */
1688 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1690 assert (fdp
->infname
!= NULL
);
1691 if (streq (uncompressed_name
, fdp
->infname
))
1695 if (stat (real_name
, &stat_buf
) != 0)
1697 /* Reset real_name and try with a different name. */
1699 if (compressed_name
!= NULL
) /* try with the given suffix */
1701 if (stat (uncompressed_name
, &stat_buf
) == 0)
1702 real_name
= uncompressed_name
;
1704 else /* try all possible suffixes */
1706 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1708 compressed_name
= concat (file
, ".", compr
->suffix
);
1709 if (stat (compressed_name
, &stat_buf
) != 0)
1713 char *suf
= compressed_name
+ strlen (file
);
1714 size_t suflen
= strlen (compr
->suffix
) + 1;
1715 for ( ; suf
[1]; suf
++, suflen
--)
1717 memmove (suf
, suf
+ 1, suflen
);
1718 if (stat (compressed_name
, &stat_buf
) == 0)
1720 real_name
= compressed_name
;
1724 if (real_name
!= NULL
)
1727 free (compressed_name
);
1728 compressed_name
= NULL
;
1732 real_name
= compressed_name
;
1737 if (real_name
== NULL
)
1742 } /* try with a different name */
1744 if (!S_ISREG (stat_buf
.st_mode
))
1746 error ("skipping %s: it is not a regular file.", real_name
);
1749 if (real_name
== compressed_name
)
1751 char *cmd
= concat (compr
->command
, " ", real_name
);
1752 inf
= (FILE *) popen (cmd
, "r");
1756 inf
= fopen (real_name
, "r");
1763 process_file (inf
, uncompressed_name
, lang
);
1765 if (real_name
== compressed_name
)
1766 retval
= pclose (inf
);
1768 retval
= fclose (inf
);
1773 if (compressed_name
) free (compressed_name
);
1774 if (uncompressed_name
) free (uncompressed_name
);
1781 process_file (fh
, fn
, lang
)
1786 static const fdesc emptyfdesc
;
1789 /* Create a new input file description entry. */
1790 fdp
= xnew (1, fdesc
);
1793 fdp
->infname
= savestr (fn
);
1795 fdp
->infabsname
= absolute_filename (fn
, cwd
);
1796 fdp
->infabsdir
= absolute_dirname (fn
, cwd
);
1797 if (filename_is_absolute (fn
))
1799 /* An absolute file name. Canonicalize it. */
1800 fdp
->taggedfname
= absolute_filename (fn
, NULL
);
1804 /* A file name relative to cwd. Make it relative
1805 to the directory of the tags file. */
1806 fdp
->taggedfname
= relative_filename (fn
, tagfiledir
);
1808 fdp
->usecharno
= TRUE
; /* use char position when making tags */
1810 fdp
->written
= FALSE
; /* not written on tags file yet */
1813 curfdp
= fdhead
; /* the current file description */
1817 /* If not Ctags, and if this is not metasource and if it contained no #line
1818 directives, we can write the tags and free all nodes pointing to
1821 && curfdp
->usecharno
/* no #line directives in this file */
1822 && !curfdp
->lang
->metasource
)
1826 /* Look for the head of the sublist relative to this file. See add_node
1827 for the structure of the node tree. */
1829 for (np
= nodehead
; np
!= NULL
; prev
= np
, np
= np
->left
)
1830 if (np
->fdp
== curfdp
)
1833 /* If we generated tags for this file, write and delete them. */
1836 /* This is the head of the last sublist, if any. The following
1837 instructions depend on this being true. */
1838 assert (np
->left
== NULL
);
1840 assert (fdhead
== curfdp
);
1841 assert (last_node
->fdp
== curfdp
);
1842 put_entries (np
); /* write tags for file curfdp->taggedfname */
1843 free_tree (np
); /* remove the written nodes */
1845 nodehead
= NULL
; /* no nodes left */
1847 prev
->left
= NULL
; /* delete the pointer to the sublist */
1853 * This routine sets up the boolean pseudo-functions which work
1854 * by setting boolean flags dependent upon the corresponding character.
1855 * Every char which is NOT in that string is not a white char. Therefore,
1856 * all of the array "_wht" is set to FALSE, and then the elements
1857 * subscripted by the chars in "white" are set to TRUE. Thus "_wht"
1858 * of a char is TRUE if it is the string "white", else FALSE.
1866 for (i
= 0; i
< CHARS
; i
++)
1867 iswhite(i
) = notinname(i
) = begtoken(i
) = intoken(i
) = endtoken(i
) = FALSE
;
1868 for (sp
= white
; *sp
!= '\0'; sp
++) iswhite (*sp
) = TRUE
;
1869 for (sp
= nonam
; *sp
!= '\0'; sp
++) notinname (*sp
) = TRUE
;
1870 notinname('\0') = notinname('\n');
1871 for (sp
= begtk
; *sp
!= '\0'; sp
++) begtoken (*sp
) = TRUE
;
1872 begtoken('\0') = begtoken('\n');
1873 for (sp
= midtk
; *sp
!= '\0'; sp
++) intoken (*sp
) = TRUE
;
1874 intoken('\0') = intoken('\n');
1875 for (sp
= endtk
; *sp
!= '\0'; sp
++) endtoken (*sp
) = TRUE
;
1876 endtoken('\0') = endtoken('\n');
1880 * This routine opens the specified file and calls the function
1881 * which finds the function and type definitions.
1888 language
*lang
= curfdp
->lang
;
1889 Lang_function
*parser
= NULL
;
1891 /* If user specified a language, use it. */
1892 if (lang
!= NULL
&& lang
->function
!= NULL
)
1894 parser
= lang
->function
;
1897 /* Else try to guess the language given the file name. */
1900 lang
= get_language_from_filename (curfdp
->infname
, TRUE
);
1901 if (lang
!= NULL
&& lang
->function
!= NULL
)
1903 curfdp
->lang
= lang
;
1904 parser
= lang
->function
;
1908 /* Else look for sharp-bang as the first two characters. */
1910 && readline_internal (&lb
, inf
) > 0
1912 && lb
.buffer
[0] == '#'
1913 && lb
.buffer
[1] == '!')
1917 /* Set lp to point at the first char after the last slash in the
1918 line or, if no slashes, at the first nonblank. Then set cp to
1919 the first successive blank and terminate the string. */
1920 lp
= etags_strrchr (lb
.buffer
+2, '/');
1924 lp
= skip_spaces (lb
.buffer
+ 2);
1925 cp
= skip_non_spaces (lp
);
1928 if (strlen (lp
) > 0)
1930 lang
= get_language_from_interpreter (lp
);
1931 if (lang
!= NULL
&& lang
->function
!= NULL
)
1933 curfdp
->lang
= lang
;
1934 parser
= lang
->function
;
1939 /* We rewind here, even if inf may be a pipe. We fail if the
1940 length of the first line is longer than the pipe block size,
1941 which is unlikely. */
1944 /* Else try to guess the language given the case insensitive file name. */
1947 lang
= get_language_from_filename (curfdp
->infname
, FALSE
);
1948 if (lang
!= NULL
&& lang
->function
!= NULL
)
1950 curfdp
->lang
= lang
;
1951 parser
= lang
->function
;
1955 /* Else try Fortran or C. */
1958 node
*old_last_node
= last_node
;
1960 curfdp
->lang
= get_language_from_langname ("fortran");
1963 if (old_last_node
== last_node
)
1964 /* No Fortran entries found. Try C. */
1966 /* We do not tag if rewind fails.
1967 Only the file name will be recorded in the tags file. */
1969 curfdp
->lang
= get_language_from_langname (cplusplus
? "c++" : "c");
1975 if (!no_line_directive
1976 && curfdp
->lang
!= NULL
&& curfdp
->lang
->metasource
)
1977 /* It may be that this is a bingo.y file, and we already parsed a bingo.c
1978 file, or anyway we parsed a file that is automatically generated from
1979 this one. If this is the case, the bingo.c file contained #line
1980 directives that generated tags pointing to this file. Let's delete
1981 them all before parsing this file, which is the real source. */
1983 fdesc
**fdpp
= &fdhead
;
1984 while (*fdpp
!= NULL
)
1986 && streq ((*fdpp
)->taggedfname
, curfdp
->taggedfname
))
1987 /* We found one of those! We must delete both the file description
1988 and all tags referring to it. */
1990 fdesc
*badfdp
= *fdpp
;
1992 /* Delete the tags referring to badfdp->taggedfname
1993 that were obtained from badfdp->infname. */
1994 invalidate_nodes (badfdp
, &nodehead
);
1996 *fdpp
= badfdp
->next
; /* remove the bad description from the list */
1997 free_fdesc (badfdp
);
2000 fdpp
= &(*fdpp
)->next
; /* advance the list pointer */
2003 assert (parser
!= NULL
);
2005 /* Generic initialisations before reading from file. */
2006 linebuffer_setlen (&filebuf
, 0); /* reset the file buffer */
2008 /* Generic initialisations before parsing file with readline. */
2009 lineno
= 0; /* reset global line number */
2010 charno
= 0; /* reset global char number */
2011 linecharno
= 0; /* reset global char number of line start */
2015 regex_tag_multiline ();
2020 * Check whether an implicitly named tag should be created,
2021 * then call `pfnote'.
2022 * NAME is a string that is internally copied by this function.
2024 * TAGS format specification
2025 * Idea by Sam Kendall <kendall@mv.mv.com> (1997)
2026 * The following is explained in some more detail in etc/ETAGS.EBNF.
2028 * make_tag creates tags with "implicit tag names" (unnamed tags)
2029 * if the following are all true, assuming NONAM=" \f\t\n\r()=,;":
2030 * 1. NAME does not contain any of the characters in NONAM;
2031 * 2. LINESTART contains name as either a rightmost, or rightmost but
2032 * one character, substring;
2033 * 3. the character, if any, immediately before NAME in LINESTART must
2034 * be a character in NONAM;
2035 * 4. the character, if any, immediately after NAME in LINESTART must
2036 * also be a character in NONAM.
2038 * The implementation uses the notinname() macro, which recognises the
2039 * characters stored in the string `nonam'.
2040 * etags.el needs to use the same characters that are in NONAM.
2043 make_tag (name
, namelen
, is_func
, linestart
, linelen
, lno
, cno
)
2044 char *name
; /* tag name, or NULL if unnamed */
2045 int namelen
; /* tag length */
2046 bool is_func
; /* tag is a function */
2047 char *linestart
; /* start of the line where tag is */
2048 int linelen
; /* length of the line where tag is */
2049 int lno
; /* line number */
2050 long cno
; /* character number */
2052 bool named
= (name
!= NULL
&& namelen
> 0);
2054 if (!CTAGS
&& named
) /* maybe set named to false */
2055 /* Let's try to make an implicit tag name, that is, create an unnamed tag
2056 such that etags.el can guess a name from it. */
2059 register char *cp
= name
;
2061 for (i
= 0; i
< namelen
; i
++)
2062 if (notinname (*cp
++))
2064 if (i
== namelen
) /* rule #1 */
2066 cp
= linestart
+ linelen
- namelen
;
2067 if (notinname (linestart
[linelen
-1]))
2068 cp
-= 1; /* rule #4 */
2069 if (cp
>= linestart
/* rule #2 */
2071 || notinname (cp
[-1])) /* rule #3 */
2072 && strneq (name
, cp
, namelen
)) /* rule #2 */
2073 named
= FALSE
; /* use implicit tag name */
2078 name
= savenstr (name
, namelen
);
2081 pfnote (name
, is_func
, linestart
, linelen
, lno
, cno
);
2086 pfnote (name
, is_func
, linestart
, linelen
, lno
, cno
)
2087 char *name
; /* tag name, or NULL if unnamed */
2088 bool is_func
; /* tag is a function */
2089 char *linestart
; /* start of the line where tag is */
2090 int linelen
; /* length of the line where tag is */
2091 int lno
; /* line number */
2092 long cno
; /* character number */
2096 assert (name
== NULL
|| name
[0] != '\0');
2097 if (CTAGS
&& name
== NULL
)
2100 np
= xnew (1, node
);
2102 /* If ctags mode, change name "main" to M<thisfilename>. */
2103 if (CTAGS
&& !cxref_style
&& streq (name
, "main"))
2105 register char *fp
= etags_strrchr (curfdp
->taggedfname
, '/');
2106 np
->name
= concat ("M", fp
== NULL
? curfdp
->taggedfname
: fp
+ 1, "");
2107 fp
= etags_strrchr (np
->name
, '.');
2108 if (fp
!= NULL
&& fp
[1] != '\0' && fp
[2] == '\0')
2114 np
->been_warned
= FALSE
;
2116 np
->is_func
= is_func
;
2118 if (np
->fdp
->usecharno
)
2119 /* Our char numbers are 0-base, because of C language tradition?
2120 ctags compatibility? old versions compatibility? I don't know.
2121 Anyway, since emacs's are 1-base we expect etags.el to take care
2122 of the difference. If we wanted to have 1-based numbers, we would
2123 uncomment the +1 below. */
2124 np
->cno
= cno
/* + 1 */ ;
2126 np
->cno
= invalidcharno
;
2127 np
->left
= np
->right
= NULL
;
2128 if (CTAGS
&& !cxref_style
)
2130 if (strlen (linestart
) < 50)
2131 np
->regex
= concat (linestart
, "$", "");
2133 np
->regex
= savenstr (linestart
, 50);
2136 np
->regex
= savenstr (linestart
, linelen
);
2138 add_node (np
, &nodehead
);
2143 * recurse on left children, iterate on right children.
2151 register node
*node_right
= np
->right
;
2152 free_tree (np
->left
);
2153 if (np
->name
!= NULL
)
2163 * delete a file description
2167 register fdesc
*fdp
;
2169 if (fdp
->infname
!= NULL
) free (fdp
->infname
);
2170 if (fdp
->infabsname
!= NULL
) free (fdp
->infabsname
);
2171 if (fdp
->infabsdir
!= NULL
) free (fdp
->infabsdir
);
2172 if (fdp
->taggedfname
!= NULL
) free (fdp
->taggedfname
);
2173 if (fdp
->prop
!= NULL
) free (fdp
->prop
);
2179 * Adds a node to the tree of nodes. In etags mode, sort by file
2180 * name. In ctags mode, sort by tag name. Make no attempt at
2183 * add_node is the only function allowed to add nodes, so it can
2187 add_node (np
, cur_node_p
)
2188 node
*np
, **cur_node_p
;
2191 register node
*cur_node
= *cur_node_p
;
2193 if (cur_node
== NULL
)
2203 /* For each file name, tags are in a linked sublist on the right
2204 pointer. The first tags of different files are a linked list
2205 on the left pointer. last_node points to the end of the last
2207 if (last_node
!= NULL
&& last_node
->fdp
== np
->fdp
)
2209 /* Let's use the same sublist as the last added node. */
2210 assert (last_node
->right
== NULL
);
2211 last_node
->right
= np
;
2214 else if (cur_node
->fdp
== np
->fdp
)
2216 /* Scanning the list we found the head of a sublist which is
2217 good for us. Let's scan this sublist. */
2218 add_node (np
, &cur_node
->right
);
2221 /* The head of this sublist is not good for us. Let's try the
2223 add_node (np
, &cur_node
->left
);
2224 } /* if ETAGS mode */
2229 dif
= strcmp (np
->name
, cur_node
->name
);
2232 * If this tag name matches an existing one, then
2233 * do not add the node, but maybe print a warning.
2235 if (no_duplicates
&& !dif
)
2237 if (np
->fdp
== cur_node
->fdp
)
2241 fprintf (stderr
, "Duplicate entry in file %s, line %d: %s\n",
2242 np
->fdp
->infname
, lineno
, np
->name
);
2243 fprintf (stderr
, "Second entry ignored\n");
2246 else if (!cur_node
->been_warned
&& !no_warnings
)
2250 "Duplicate entry in files %s and %s: %s (Warning only)\n",
2251 np
->fdp
->infname
, cur_node
->fdp
->infname
, np
->name
);
2252 cur_node
->been_warned
= TRUE
;
2257 /* Actually add the node */
2258 add_node (np
, dif
< 0 ? &cur_node
->left
: &cur_node
->right
);
2259 } /* if CTAGS mode */
2263 * invalidate_nodes ()
2264 * Scan the node tree and invalidate all nodes pointing to the
2265 * given file description (CTAGS case) or free them (ETAGS case).
2268 invalidate_nodes (badfdp
, npp
)
2279 if (np
->left
!= NULL
)
2280 invalidate_nodes (badfdp
, &np
->left
);
2281 if (np
->fdp
== badfdp
)
2283 if (np
->right
!= NULL
)
2284 invalidate_nodes (badfdp
, &np
->right
);
2288 assert (np
->fdp
!= NULL
);
2289 if (np
->fdp
== badfdp
)
2291 *npp
= np
->left
; /* detach the sublist from the list */
2292 np
->left
= NULL
; /* isolate it */
2293 free_tree (np
); /* free it */
2294 invalidate_nodes (badfdp
, npp
);
2297 invalidate_nodes (badfdp
, &np
->left
);
2302 static int total_size_of_entries
__P((node
*));
2303 static int number_len
__P((long));
2305 /* Length of a non-negative number's decimal representation. */
2311 while ((num
/= 10) > 0)
2317 * Return total number of characters that put_entries will output for
2318 * the nodes in the linked list at the right of the specified node.
2319 * This count is irrelevant with etags.el since emacs 19.34 at least,
2320 * but is still supplied for backward compatibility.
2323 total_size_of_entries (np
)
2326 register int total
= 0;
2328 for (; np
!= NULL
; np
= np
->right
)
2331 total
+= strlen (np
->regex
) + 1; /* pat\177 */
2332 if (np
->name
!= NULL
)
2333 total
+= strlen (np
->name
) + 1; /* name\001 */
2334 total
+= number_len ((long) np
->lno
) + 1; /* lno, */
2335 if (np
->cno
!= invalidcharno
) /* cno */
2336 total
+= number_len (np
->cno
);
2337 total
+= 1; /* newline */
2348 static fdesc
*fdp
= NULL
;
2353 /* Output subentries that precede this one */
2355 put_entries (np
->left
);
2357 /* Output this entry */
2366 fprintf (tagf
, "\f\n%s,%d\n",
2367 fdp
->taggedfname
, total_size_of_entries (np
));
2368 fdp
->written
= TRUE
;
2370 fputs (np
->regex
, tagf
);
2371 fputc ('\177', tagf
);
2372 if (np
->name
!= NULL
)
2374 fputs (np
->name
, tagf
);
2375 fputc ('\001', tagf
);
2377 fprintf (tagf
, "%d,", np
->lno
);
2378 if (np
->cno
!= invalidcharno
)
2379 fprintf (tagf
, "%ld", np
->cno
);
2385 if (np
->name
== NULL
)
2386 error ("internal error: NULL name in ctags mode.", (char *)NULL
);
2391 fprintf (stdout
, "%s %s %d\n",
2392 np
->name
, np
->fdp
->taggedfname
, (np
->lno
+ 63) / 64);
2394 fprintf (stdout
, "%-16s %3d %-16s %s\n",
2395 np
->name
, np
->lno
, np
->fdp
->taggedfname
, np
->regex
);
2399 fprintf (tagf
, "%s\t%s\t", np
->name
, np
->fdp
->taggedfname
);
2402 { /* function or #define macro with args */
2403 putc (searchar
, tagf
);
2406 for (sp
= np
->regex
; *sp
; sp
++)
2408 if (*sp
== '\\' || *sp
== searchar
)
2412 putc (searchar
, tagf
);
2415 { /* anything else; text pattern inadequate */
2416 fprintf (tagf
, "%d", np
->lno
);
2421 } /* if this node contains a valid tag */
2423 /* Output subentries that follow this one */
2424 put_entries (np
->right
);
2426 put_entries (np
->left
);
2431 #define C_EXT 0x00fff /* C extensions */
2432 #define C_PLAIN 0x00000 /* C */
2433 #define C_PLPL 0x00001 /* C++ */
2434 #define C_STAR 0x00003 /* C* */
2435 #define C_JAVA 0x00005 /* JAVA */
2436 #define C_AUTO 0x01000 /* C, but switch to C++ if `class' is met */
2437 #define YACC 0x10000 /* yacc file */
2440 * The C symbol tables.
2445 st_C_objprot
, st_C_objimpl
, st_C_objend
,
2447 st_C_ignore
, st_C_attribute
,
2450 st_C_class
, st_C_template
,
2451 st_C_struct
, st_C_extern
, st_C_enum
, st_C_define
, st_C_typedef
2454 static unsigned int hash
__P((const char *, unsigned int));
2455 static struct C_stab_entry
* in_word_set
__P((const char *, unsigned int));
2456 static enum sym_type C_symtype
__P((char *, int, int));
2458 /* Feed stuff between (but not including) %[ and %] lines to:
2464 struct C_stab_entry { char *name; int c_ext; enum sym_type type; }
2468 while, 0, st_C_ignore
2469 switch, 0, st_C_ignore
2470 return, 0, st_C_ignore
2471 __attribute__, 0, st_C_attribute
2472 @interface, 0, st_C_objprot
2473 @protocol, 0, st_C_objprot
2474 @implementation,0, st_C_objimpl
2475 @end, 0, st_C_objend
2476 import, (C_JAVA & ~C_PLPL), st_C_ignore
2477 package, (C_JAVA & ~C_PLPL), st_C_ignore
2478 friend, C_PLPL, st_C_ignore
2479 extends, (C_JAVA & ~C_PLPL), st_C_javastruct
2480 implements, (C_JAVA & ~C_PLPL), st_C_javastruct
2481 interface, (C_JAVA & ~C_PLPL), st_C_struct
2482 class, 0, st_C_class
2483 namespace, C_PLPL, st_C_struct
2484 domain, C_STAR, st_C_struct
2485 union, 0, st_C_struct
2486 struct, 0, st_C_struct
2487 extern, 0, st_C_extern
2489 typedef, 0, st_C_typedef
2490 define, 0, st_C_define
2491 undef, 0, st_C_define
2492 operator, C_PLPL, st_C_operator
2493 template, 0, st_C_template
2494 # DEFUN used in emacs, the next three used in glibc (SYSCALL only for mach).
2495 DEFUN, 0, st_C_gnumacro
2496 SYSCALL, 0, st_C_gnumacro
2497 ENTRY, 0, st_C_gnumacro
2498 PSEUDO, 0, st_C_gnumacro
2499 # These are defined inside C functions, so currently they are not met.
2500 # EXFUN used in glibc, DEFVAR_* in emacs.
2501 #EXFUN, 0, st_C_gnumacro
2502 #DEFVAR_, 0, st_C_gnumacro
2504 and replace lines between %< and %> with its output, then:
2505 - remove the #if characterset check
2506 - make in_word_set static and not inline. */
2508 /* C code produced by gperf version 3.0.1 */
2509 /* Command-line: gperf -m 5 */
2510 /* Computed positions: -k'2-3' */
2512 struct C_stab_entry
{ char *name
; int c_ext
; enum sym_type type
; };
2513 /* maximum key range = 33, duplicates = 0 */
2524 register const char *str
;
2525 register unsigned int len
;
2527 static unsigned char asso_values
[] =
2529 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2530 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2531 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2532 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2533 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2534 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2535 35, 35, 35, 35, 35, 35, 35, 35, 35, 15,
2536 14, 35, 35, 35, 35, 35, 35, 35, 14, 35,
2537 35, 35, 35, 12, 13, 35, 35, 35, 35, 12,
2538 35, 35, 35, 35, 35, 1, 35, 16, 35, 6,
2539 23, 0, 0, 35, 22, 0, 35, 35, 5, 0,
2540 0, 15, 1, 35, 6, 35, 8, 19, 35, 16,
2541 4, 5, 35, 35, 35, 35, 35, 35, 35, 35,
2542 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2543 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2544 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2545 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2546 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2547 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2548 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2549 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2550 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2551 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2552 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2553 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2554 35, 35, 35, 35, 35, 35
2556 register int hval
= len
;
2561 hval
+= asso_values
[(unsigned char)str
[2]];
2564 hval
+= asso_values
[(unsigned char)str
[1]];
2570 static struct C_stab_entry
*
2571 in_word_set (str
, len
)
2572 register const char *str
;
2573 register unsigned int len
;
2577 TOTAL_KEYWORDS
= 32,
2578 MIN_WORD_LENGTH
= 2,
2579 MAX_WORD_LENGTH
= 15,
2584 static struct C_stab_entry wordlist
[] =
2587 {"if", 0, st_C_ignore
},
2589 {"@end", 0, st_C_objend
},
2590 {"union", 0, st_C_struct
},
2591 {"define", 0, st_C_define
},
2592 {"import", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2593 {"template", 0, st_C_template
},
2594 {"operator", C_PLPL
, st_C_operator
},
2595 {"@interface", 0, st_C_objprot
},
2596 {"implements", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2597 {"friend", C_PLPL
, st_C_ignore
},
2598 {"typedef", 0, st_C_typedef
},
2599 {"return", 0, st_C_ignore
},
2600 {"@implementation",0, st_C_objimpl
},
2601 {"@protocol", 0, st_C_objprot
},
2602 {"interface", (C_JAVA
& ~C_PLPL
), st_C_struct
},
2603 {"extern", 0, st_C_extern
},
2604 {"extends", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2605 {"struct", 0, st_C_struct
},
2606 {"domain", C_STAR
, st_C_struct
},
2607 {"switch", 0, st_C_ignore
},
2608 {"enum", 0, st_C_enum
},
2609 {"for", 0, st_C_ignore
},
2610 {"namespace", C_PLPL
, st_C_struct
},
2611 {"class", 0, st_C_class
},
2612 {"while", 0, st_C_ignore
},
2613 {"undef", 0, st_C_define
},
2614 {"package", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2615 {"__attribute__", 0, st_C_attribute
},
2616 {"SYSCALL", 0, st_C_gnumacro
},
2617 {"ENTRY", 0, st_C_gnumacro
},
2618 {"PSEUDO", 0, st_C_gnumacro
},
2619 {"DEFUN", 0, st_C_gnumacro
}
2622 if (len
<= MAX_WORD_LENGTH
&& len
>= MIN_WORD_LENGTH
)
2624 register int key
= hash (str
, len
);
2626 if (key
<= MAX_HASH_VALUE
&& key
>= 0)
2628 register const char *s
= wordlist
[key
].name
;
2630 if (*str
== *s
&& !strncmp (str
+ 1, s
+ 1, len
- 1) && s
[len
] == '\0')
2631 return &wordlist
[key
];
2638 static enum sym_type
2639 C_symtype (str
, len
, c_ext
)
2644 register struct C_stab_entry
*se
= in_word_set (str
, len
);
2646 if (se
== NULL
|| (se
->c_ext
&& !(c_ext
& se
->c_ext
)))
2653 * Ignoring __attribute__ ((list))
2655 static bool inattribute
; /* looking at an __attribute__ construct */
2658 * C functions and variables are recognized using a simple
2659 * finite automaton. fvdef is its state variable.
2663 fvnone
, /* nothing seen */
2664 fdefunkey
, /* Emacs DEFUN keyword seen */
2665 fdefunname
, /* Emacs DEFUN name seen */
2666 foperator
, /* func: operator keyword seen (cplpl) */
2667 fvnameseen
, /* function or variable name seen */
2668 fstartlist
, /* func: just after open parenthesis */
2669 finlist
, /* func: in parameter list */
2670 flistseen
, /* func: after parameter list */
2671 fignore
, /* func: before open brace */
2672 vignore
/* var-like: ignore until ';' */
2675 static bool fvextern
; /* func or var: extern keyword seen; */
2678 * typedefs are recognized using a simple finite automaton.
2679 * typdef is its state variable.
2683 tnone
, /* nothing seen */
2684 tkeyseen
, /* typedef keyword seen */
2685 ttypeseen
, /* defined type seen */
2686 tinbody
, /* inside typedef body */
2687 tend
, /* just before typedef tag */
2688 tignore
/* junk after typedef tag */
2692 * struct-like structures (enum, struct and union) are recognized
2693 * using another simple finite automaton. `structdef' is its state
2698 snone
, /* nothing seen yet,
2699 or in struct body if bracelev > 0 */
2700 skeyseen
, /* struct-like keyword seen */
2701 stagseen
, /* struct-like tag seen */
2702 scolonseen
/* colon seen after struct-like tag */
2706 * When objdef is different from onone, objtag is the name of the class.
2708 static char *objtag
= "<uninited>";
2711 * Yet another little state machine to deal with preprocessor lines.
2715 dnone
, /* nothing seen */
2716 dsharpseen
, /* '#' seen as first char on line */
2717 ddefineseen
, /* '#' and 'define' seen */
2718 dignorerest
/* ignore rest of line */
2722 * State machine for Objective C protocols and implementations.
2723 * Idea by Tom R.Hageman <tom@basil.icce.rug.nl> (1995)
2727 onone
, /* nothing seen */
2728 oprotocol
, /* @interface or @protocol seen */
2729 oimplementation
, /* @implementations seen */
2730 otagseen
, /* class name seen */
2731 oparenseen
, /* parenthesis before category seen */
2732 ocatseen
, /* category name seen */
2733 oinbody
, /* in @implementation body */
2734 omethodsign
, /* in @implementation body, after +/- */
2735 omethodtag
, /* after method name */
2736 omethodcolon
, /* after method colon */
2737 omethodparm
, /* after method parameter */
2738 oignore
/* wait for @end */
2743 * Use this structure to keep info about the token read, and how it
2744 * should be tagged. Used by the make_C_tag function to build a tag.
2748 char *line
; /* string containing the token */
2749 int offset
; /* where the token starts in LINE */
2750 int length
; /* token length */
2752 The previous members can be used to pass strings around for generic
2753 purposes. The following ones specifically refer to creating tags. In this
2754 case the token contained here is the pattern that will be used to create a
2757 bool valid
; /* do not create a tag; the token should be
2758 invalidated whenever a state machine is
2759 reset prematurely */
2760 bool named
; /* create a named tag */
2761 int lineno
; /* source line number of tag */
2762 long linepos
; /* source char number of tag */
2763 } token
; /* latest token read */
2766 * Variables and functions for dealing with nested structures.
2767 * Idea by Mykola Dzyuba <mdzyuba@yahoo.com> (2001)
2769 static void pushclass_above
__P((int, char *, int));
2770 static void popclass_above
__P((int));
2771 static void write_classname
__P((linebuffer
*, char *qualifier
));
2774 char **cname
; /* nested class names */
2775 int *bracelev
; /* nested class brace level */
2776 int nl
; /* class nesting level (elements used) */
2777 int size
; /* length of the array */
2778 } cstack
; /* stack for nested declaration tags */
2779 /* Current struct nesting depth (namespace, class, struct, union, enum). */
2780 #define nestlev (cstack.nl)
2781 /* After struct keyword or in struct body, not inside a nested function. */
2782 #define instruct (structdef == snone && nestlev > 0 \
2783 && bracelev == cstack.bracelev[nestlev-1] + 1)
2786 pushclass_above (bracelev
, str
, len
)
2793 popclass_above (bracelev
);
2795 if (nl
>= cstack
.size
)
2797 int size
= cstack
.size
*= 2;
2798 xrnew (cstack
.cname
, size
, char *);
2799 xrnew (cstack
.bracelev
, size
, int);
2801 assert (nl
== 0 || cstack
.bracelev
[nl
-1] < bracelev
);
2802 cstack
.cname
[nl
] = (str
== NULL
) ? NULL
: savenstr (str
, len
);
2803 cstack
.bracelev
[nl
] = bracelev
;
2808 popclass_above (bracelev
)
2813 for (nl
= cstack
.nl
- 1;
2814 nl
>= 0 && cstack
.bracelev
[nl
] >= bracelev
;
2817 if (cstack
.cname
[nl
] != NULL
)
2818 free (cstack
.cname
[nl
]);
2824 write_classname (cn
, qualifier
)
2829 int qlen
= strlen (qualifier
);
2831 if (cstack
.nl
== 0 || cstack
.cname
[0] == NULL
)
2835 cn
->buffer
[0] = '\0';
2839 len
= strlen (cstack
.cname
[0]);
2840 linebuffer_setlen (cn
, len
);
2841 strcpy (cn
->buffer
, cstack
.cname
[0]);
2843 for (i
= 1; i
< cstack
.nl
; i
++)
2848 s
= cstack
.cname
[i
];
2853 linebuffer_setlen (cn
, len
);
2854 strncat (cn
->buffer
, qualifier
, qlen
);
2855 strncat (cn
->buffer
, s
, slen
);
2860 static bool consider_token
__P((char *, int, int, int *, int, int, bool *));
2861 static void make_C_tag
__P((bool));
2865 * checks to see if the current token is at the start of a
2866 * function or variable, or corresponds to a typedef, or
2867 * is a struct/union/enum tag, or #define, or an enum constant.
2869 * *IS_FUNC gets TRUE iff the token is a function or #define macro
2870 * with args. C_EXTP points to which language we are looking at.
2881 consider_token (str
, len
, c
, c_extp
, bracelev
, parlev
, is_func_or_var
)
2882 register char *str
; /* IN: token pointer */
2883 register int len
; /* IN: token length */
2884 register int c
; /* IN: first char after the token */
2885 int *c_extp
; /* IN, OUT: C extensions mask */
2886 int bracelev
; /* IN: brace level */
2887 int parlev
; /* IN: parenthesis level */
2888 bool *is_func_or_var
; /* OUT: function or variable found */
2890 /* When structdef is stagseen, scolonseen, or snone with bracelev > 0,
2891 structtype is the type of the preceding struct-like keyword, and
2892 structbracelev is the brace level where it has been seen. */
2893 static enum sym_type structtype
;
2894 static int structbracelev
;
2895 static enum sym_type toktype
;
2898 toktype
= C_symtype (str
, len
, *c_extp
);
2901 * Skip __attribute__
2903 if (toktype
== st_C_attribute
)
2910 * Advance the definedef state machine.
2915 /* We're not on a preprocessor line. */
2916 if (toktype
== st_C_gnumacro
)
2923 if (toktype
== st_C_define
)
2925 definedef
= ddefineseen
;
2929 definedef
= dignorerest
;
2934 * Make a tag for any macro, unless it is a constant
2935 * and constantypedefs is FALSE.
2937 definedef
= dignorerest
;
2938 *is_func_or_var
= (c
== '(');
2939 if (!*is_func_or_var
&& !constantypedefs
)
2946 error ("internal error: definedef value.", (char *)NULL
);
2955 if (toktype
== st_C_typedef
)
2975 if (structdef
== snone
&& fvdef
== fvnone
)
2993 * This structdef business is NOT invoked when we are ctags and the
2994 * file is plain C. This is because a struct tag may have the same
2995 * name as another tag, and this loses with ctags.
2999 case st_C_javastruct
:
3000 if (structdef
== stagseen
)
3001 structdef
= scolonseen
;
3005 if ((*c_extp
& C_AUTO
) /* automatic detection of C++ language */
3007 && definedef
== dnone
&& structdef
== snone
3008 && typdef
== tnone
&& fvdef
== fvnone
)
3009 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
3010 if (toktype
== st_C_template
)
3017 && (typdef
== tkeyseen
3018 || (typedefs_or_cplusplus
&& structdef
== snone
)))
3020 structdef
= skeyseen
;
3021 structtype
= toktype
;
3022 structbracelev
= bracelev
;
3023 if (fvdef
== fvnameseen
)
3029 if (structdef
== skeyseen
)
3031 structdef
= stagseen
;
3035 if (typdef
!= tnone
)
3038 /* Detect Objective C constructs. */
3048 objdef
= oimplementation
;
3052 case oimplementation
:
3053 /* Save the class tag for functions or variables defined inside. */
3054 objtag
= savenstr (str
, len
);
3058 /* Save the class tag for categories. */
3059 objtag
= savenstr (str
, len
);
3061 *is_func_or_var
= TRUE
;
3065 *is_func_or_var
= TRUE
;
3073 objdef
= omethodtag
;
3074 linebuffer_setlen (&token_name
, len
);
3075 strncpy (token_name
.buffer
, str
, len
);
3076 token_name
.buffer
[len
] = '\0';
3082 objdef
= omethodparm
;
3088 objdef
= omethodtag
;
3089 linebuffer_setlen (&token_name
, token_name
.len
+ len
);
3090 strncat (token_name
.buffer
, str
, len
);
3095 if (toktype
== st_C_objend
)
3097 /* Memory leakage here: the string pointed by objtag is
3098 never released, because many tests would be needed to
3099 avoid breaking on incorrect input code. The amount of
3100 memory leaked here is the sum of the lengths of the
3108 /* A function, variable or enum constant? */
3130 *is_func_or_var
= TRUE
;
3134 && structdef
== snone
3135 && structtype
== st_C_enum
&& bracelev
> structbracelev
)
3136 return TRUE
; /* enum constant */
3142 fvdef
= fdefunname
; /* GNU macro */
3143 *is_func_or_var
= TRUE
;
3151 if ((strneq (str
, "asm", 3) && endtoken (str
[3]))
3152 || (strneq (str
, "__asm__", 7) && endtoken (str
[7])))
3161 if (len
>= 10 && strneq (str
+len
-10, "::operator", 10))
3163 if (*c_extp
& C_AUTO
) /* automatic detection of C++ */
3164 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
3166 *is_func_or_var
= TRUE
;
3169 if (bracelev
> 0 && !instruct
)
3171 fvdef
= fvnameseen
; /* function or variable */
3172 *is_func_or_var
= TRUE
;
3183 * C_entries often keeps pointers to tokens or lines which are older than
3184 * the line currently read. By keeping two line buffers, and switching
3185 * them at end of line, it is possible to use those pointers.
3193 #define current_lb_is_new (newndx == curndx)
3194 #define switch_line_buffers() (curndx = 1 - curndx)
3196 #define curlb (lbs[curndx].lb)
3197 #define newlb (lbs[newndx].lb)
3198 #define curlinepos (lbs[curndx].linepos)
3199 #define newlinepos (lbs[newndx].linepos)
3201 #define plainc ((c_ext & C_EXT) == C_PLAIN)
3202 #define cplpl (c_ext & C_PLPL)
3203 #define cjava ((c_ext & C_JAVA) == C_JAVA)
3205 #define CNL_SAVE_DEFINEDEF() \
3207 curlinepos = charno; \
3208 readline (&curlb, inf); \
3209 lp = curlb.buffer; \
3216 CNL_SAVE_DEFINEDEF(); \
3217 if (savetoken.valid) \
3219 token = savetoken; \
3220 savetoken.valid = FALSE; \
3222 definedef = dnone; \
3230 /* This function is never called when token.valid is FALSE, but
3231 we must protect against invalid input or internal errors. */
3232 if (!DEBUG
&& !token
.valid
)
3236 make_tag (token_name
.buffer
, token_name
.len
, isfun
, token
.line
,
3237 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3238 else /* this case is optimised away if !DEBUG */
3239 make_tag (concat ("INVALID TOKEN:-->", token_name
.buffer
, ""),
3240 token_name
.len
+ 17, isfun
, token
.line
,
3241 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3243 token
.valid
= FALSE
;
3249 * This routine finds functions, variables, typedefs,
3250 * #define's, enum constants and struct/union/enum definitions in
3251 * C syntax and adds them to the list.
3254 C_entries (c_ext
, inf
)
3255 int c_ext
; /* extension of C */
3256 FILE *inf
; /* input file */
3258 register char c
; /* latest char read; '\0' for end of line */
3259 register char *lp
; /* pointer one beyond the character `c' */
3260 int curndx
, newndx
; /* indices for current and new lb */
3261 register int tokoff
; /* offset in line of start of current token */
3262 register int toklen
; /* length of current token */
3263 char *qualifier
; /* string used to qualify names */
3264 int qlen
; /* length of qualifier */
3265 int bracelev
; /* current brace level */
3266 int bracketlev
; /* current bracket level */
3267 int parlev
; /* current parenthesis level */
3268 int attrparlev
; /* __attribute__ parenthesis level */
3269 int templatelev
; /* current template level */
3270 int typdefbracelev
; /* bracelev where a typedef struct body begun */
3271 bool incomm
, inquote
, inchar
, quotednl
, midtoken
;
3272 bool yacc_rules
; /* in the rules part of a yacc file */
3273 struct tok savetoken
= {0}; /* token saved during preprocessor handling */
3276 linebuffer_init (&lbs
[0].lb
);
3277 linebuffer_init (&lbs
[1].lb
);
3278 if (cstack
.size
== 0)
3280 cstack
.size
= (DEBUG
) ? 1 : 4;
3282 cstack
.cname
= xnew (cstack
.size
, char *);
3283 cstack
.bracelev
= xnew (cstack
.size
, int);
3286 tokoff
= toklen
= typdefbracelev
= 0; /* keep compiler quiet */
3287 curndx
= newndx
= 0;
3291 fvdef
= fvnone
; fvextern
= FALSE
; typdef
= tnone
;
3292 structdef
= snone
; definedef
= dnone
; objdef
= onone
;
3294 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
3295 token
.valid
= savetoken
.valid
= FALSE
;
3296 bracelev
= bracketlev
= parlev
= attrparlev
= templatelev
= 0;
3298 { qualifier
= "."; qlen
= 1; }
3300 { qualifier
= "::"; qlen
= 2; }
3308 /* If we are at the end of the line, the next character is a
3309 '\0'; do not skip it, because it is what tells us
3310 to read the next line. */
3331 /* Newlines inside comments do not end macro definitions in
3333 CNL_SAVE_DEFINEDEF ();
3346 /* Newlines inside strings do not end macro definitions
3347 in traditional cpp, even though compilers don't
3348 usually accept them. */
3349 CNL_SAVE_DEFINEDEF ();
3359 /* Hmmm, something went wrong. */
3368 else if (bracketlev
> 0)
3373 if (--bracketlev
> 0)
3377 CNL_SAVE_DEFINEDEF ();
3405 if (fvdef
!= finlist
&& fvdef
!= fignore
&& fvdef
!=vignore
)
3418 else if (/* cplpl && */ *lp
== '/')
3424 if ((c_ext
& YACC
) && *lp
== '%')
3426 /* Entering or exiting rules section in yacc file. */
3428 definedef
= dnone
; fvdef
= fvnone
; fvextern
= FALSE
;
3429 typdef
= tnone
; structdef
= snone
;
3430 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
3432 yacc_rules
= !yacc_rules
;
3438 if (definedef
== dnone
)
3441 bool cpptoken
= TRUE
;
3443 /* Look back on this line. If all blanks, or nonblanks
3444 followed by an end of comment, this is a preprocessor
3446 for (cp
= newlb
.buffer
; cp
< lp
-1; cp
++)
3449 if (*cp
== '*' && *(cp
+1) == '/')
3458 definedef
= dsharpseen
;
3459 } /* if (definedef == dnone) */
3467 /* Consider token only if some involved conditions are satisfied. */
3468 if (typdef
!= tignore
3469 && definedef
!= dignorerest
3472 && (definedef
!= dnone
3473 || structdef
!= scolonseen
)
3480 if (c
== ':' && *lp
== ':' && begtoken (lp
[1]))
3481 /* This handles :: in the middle,
3482 but not at the beginning of an identifier.
3483 Also, space-separated :: is not recognised. */
3485 if (c_ext
& C_AUTO
) /* automatic detection of C++ */
3486 c_ext
= (c_ext
| C_PLPL
) & ~C_AUTO
;
3490 goto still_in_token
;
3494 bool funorvar
= FALSE
;
3497 || consider_token (newlb
.buffer
+ tokoff
, toklen
, c
,
3498 &c_ext
, bracelev
, parlev
,
3501 if (fvdef
== foperator
)
3504 lp
= skip_spaces (lp
-1);
3508 && !iswhite (*lp
) && *lp
!= '(')
3511 toklen
+= lp
- oldlp
;
3513 token
.named
= FALSE
;
3515 && nestlev
> 0 && definedef
== dnone
)
3516 /* in struct body */
3518 write_classname (&token_name
, qualifier
);
3519 linebuffer_setlen (&token_name
,
3520 token_name
.len
+qlen
+toklen
);
3521 strcat (token_name
.buffer
, qualifier
);
3522 strncat (token_name
.buffer
,
3523 newlb
.buffer
+ tokoff
, toklen
);
3526 else if (objdef
== ocatseen
)
3527 /* Objective C category */
3529 int len
= strlen (objtag
) + 2 + toklen
;
3530 linebuffer_setlen (&token_name
, len
);
3531 strcpy (token_name
.buffer
, objtag
);
3532 strcat (token_name
.buffer
, "(");
3533 strncat (token_name
.buffer
,
3534 newlb
.buffer
+ tokoff
, toklen
);
3535 strcat (token_name
.buffer
, ")");
3538 else if (objdef
== omethodtag
3539 || objdef
== omethodparm
)
3540 /* Objective C method */
3544 else if (fvdef
== fdefunname
)
3545 /* GNU DEFUN and similar macros */
3547 bool defun
= (newlb
.buffer
[tokoff
] == 'F');
3551 /* Rewrite the tag so that emacs lisp DEFUNs
3552 can be found by their elisp name */
3558 linebuffer_setlen (&token_name
, len
);
3559 strncpy (token_name
.buffer
,
3560 newlb
.buffer
+ off
, len
);
3561 token_name
.buffer
[len
] = '\0';
3564 if (token_name
.buffer
[len
] == '_')
3565 token_name
.buffer
[len
] = '-';
3566 token
.named
= defun
;
3570 linebuffer_setlen (&token_name
, toklen
);
3571 strncpy (token_name
.buffer
,
3572 newlb
.buffer
+ tokoff
, toklen
);
3573 token_name
.buffer
[toklen
] = '\0';
3574 /* Name macros and members. */
3575 token
.named
= (structdef
== stagseen
3576 || typdef
== ttypeseen
3579 && definedef
== dignorerest
)
3581 && definedef
== dnone
3582 && structdef
== snone
3585 token
.lineno
= lineno
;
3586 token
.offset
= tokoff
;
3587 token
.length
= toklen
;
3588 token
.line
= newlb
.buffer
;
3589 token
.linepos
= newlinepos
;
3592 if (definedef
== dnone
3593 && (fvdef
== fvnameseen
3594 || fvdef
== foperator
3595 || structdef
== stagseen
3597 || typdef
== ttypeseen
3598 || objdef
!= onone
))
3600 if (current_lb_is_new
)
3601 switch_line_buffers ();
3603 else if (definedef
!= dnone
3604 || fvdef
== fdefunname
3606 make_C_tag (funorvar
);
3608 else /* not yacc and consider_token failed */
3610 if (inattribute
&& fvdef
== fignore
)
3612 /* We have just met __attribute__ after a
3613 function parameter list: do not tag the
3620 } /* if (endtoken (c)) */
3621 else if (intoken (c
))
3627 } /* if (midtoken) */
3628 else if (begtoken (c
))
3636 /* This prevents tagging fb in
3637 void (__attribute__((noreturn)) *fb) (void);
3638 Fixing this is not easy and not very important. */
3642 if (plainc
|| declarations
)
3644 make_C_tag (TRUE
); /* a function */
3649 if (structdef
== stagseen
&& !cjava
)
3651 popclass_above (bracelev
);
3659 if (!yacc_rules
|| lp
== newlb
.buffer
+ 1)
3661 tokoff
= lp
- 1 - newlb
.buffer
;
3666 } /* if (begtoken) */
3667 } /* if must look at token */
3670 /* Detect end of line, colon, comma, semicolon and various braces
3671 after having handled a token.*/
3677 if (yacc_rules
&& token
.offset
== 0 && token
.valid
)
3679 make_C_tag (FALSE
); /* a yacc function */
3682 if (definedef
!= dnone
)
3688 make_C_tag (TRUE
); /* an Objective C class */
3692 objdef
= omethodcolon
;
3693 linebuffer_setlen (&token_name
, token_name
.len
+ 1);
3694 strcat (token_name
.buffer
, ":");
3697 if (structdef
== stagseen
)
3699 structdef
= scolonseen
;
3702 /* Should be useless, but may be work as a safety net. */
3703 if (cplpl
&& fvdef
== flistseen
)
3705 make_C_tag (TRUE
); /* a function */
3711 if (definedef
!= dnone
|| inattribute
)
3717 make_C_tag (FALSE
); /* a typedef */
3727 if (typdef
== tignore
|| cplpl
)
3731 if ((globals
&& bracelev
== 0 && (!fvextern
|| declarations
))
3732 || (members
&& instruct
))
3733 make_C_tag (FALSE
); /* a variable */
3736 token
.valid
= FALSE
;
3740 && (cplpl
|| !instruct
)
3741 && (typdef
== tnone
|| (typdef
!= tignore
&& instruct
)))
3743 && plainc
&& instruct
))
3744 make_C_tag (TRUE
); /* a function */
3750 && cplpl
&& structdef
== stagseen
)
3751 make_C_tag (FALSE
); /* forward declaration */
3753 token
.valid
= FALSE
;
3754 } /* switch (fvdef) */
3760 if (structdef
== stagseen
)
3764 if (definedef
!= dnone
|| inattribute
)
3770 make_C_tag (TRUE
); /* an Objective C method */
3791 && (!fvextern
|| declarations
))
3792 || (members
&& instruct
)))
3793 make_C_tag (FALSE
); /* a variable */
3796 if ((declarations
&& typdef
== tnone
&& !instruct
)
3797 || (members
&& typdef
!= tignore
&& instruct
))
3799 make_C_tag (TRUE
); /* a function */
3802 else if (!declarations
)
3804 token
.valid
= FALSE
;
3809 if (structdef
== stagseen
)
3813 if (definedef
!= dnone
|| inattribute
)
3815 if (structdef
== stagseen
)
3822 make_C_tag (FALSE
); /* a typedef */
3834 if ((members
&& bracelev
== 1)
3835 || (globals
&& bracelev
== 0
3836 && (!fvextern
|| declarations
)))
3837 make_C_tag (FALSE
); /* a variable */
3851 if (definedef
!= dnone
)
3853 if (objdef
== otagseen
&& parlev
== 0)
3854 objdef
= oparenseen
;
3858 if (typdef
== ttypeseen
3862 /* This handles constructs like:
3863 typedef void OperatorFun (int fun); */
3882 if (--attrparlev
== 0)
3883 inattribute
= FALSE
;
3886 if (definedef
!= dnone
)
3888 if (objdef
== ocatseen
&& parlev
== 1)
3890 make_C_tag (TRUE
); /* an Objective C category */
3904 || typdef
== ttypeseen
))
3907 make_C_tag (FALSE
); /* a typedef */
3910 else if (parlev
< 0) /* can happen due to ill-conceived #if's. */
3914 if (definedef
!= dnone
)
3916 if (typdef
== ttypeseen
)
3918 /* Whenever typdef is set to tinbody (currently only
3919 here), typdefbracelev should be set to bracelev. */
3921 typdefbracelev
= bracelev
;
3926 make_C_tag (TRUE
); /* a function */
3935 make_C_tag (TRUE
); /* an Objective C class */
3940 make_C_tag (TRUE
); /* an Objective C method */
3944 /* Neutralize `extern "C" {' grot. */
3945 if (bracelev
== 0 && structdef
== snone
&& nestlev
== 0
3953 case skeyseen
: /* unnamed struct */
3954 pushclass_above (bracelev
, NULL
, 0);
3957 case stagseen
: /* named struct or enum */
3958 case scolonseen
: /* a class */
3959 pushclass_above (bracelev
,token
.line
+token
.offset
, token
.length
);
3961 make_C_tag (FALSE
); /* a struct or enum */
3967 if (definedef
!= dnone
)
3969 if (fvdef
== fstartlist
)
3971 fvdef
= fvnone
; /* avoid tagging `foo' in `foo (*bar()) ()' */
3972 token
.valid
= FALSE
;
3976 if (definedef
!= dnone
)
3978 if (!ignoreindent
&& lp
== newlb
.buffer
+ 1)
3981 token
.valid
= FALSE
;
3982 bracelev
= 0; /* reset brace level if first column */
3983 parlev
= 0; /* also reset paren level, just in case... */
3985 else if (bracelev
> 0)
3988 token
.valid
= FALSE
; /* something gone amiss, token unreliable */
3989 popclass_above (bracelev
);
3991 /* Only if typdef == tinbody is typdefbracelev significant. */
3992 if (typdef
== tinbody
&& bracelev
<= typdefbracelev
)
3994 assert (bracelev
== typdefbracelev
);
3999 if (definedef
!= dnone
)
4009 if ((members
&& bracelev
== 1)
4010 || (globals
&& bracelev
== 0 && (!fvextern
|| declarations
)))
4011 make_C_tag (FALSE
); /* a variable */
4019 && (structdef
== stagseen
|| fvdef
== fvnameseen
))
4026 if (templatelev
> 0)
4034 if (objdef
== oinbody
&& bracelev
== 0)
4036 objdef
= omethodsign
;
4041 case '#': case '~': case '&': case '%': case '/':
4042 case '|': case '^': case '!': case '.': case '?':
4043 if (definedef
!= dnone
)
4045 /* These surely cannot follow a function tag in C. */
4058 if (objdef
== otagseen
)
4060 make_C_tag (TRUE
); /* an Objective C class */
4063 /* If a macro spans multiple lines don't reset its state. */
4065 CNL_SAVE_DEFINEDEF ();
4071 } /* while not eof */
4073 free (lbs
[0].lb
.buffer
);
4074 free (lbs
[1].lb
.buffer
);
4078 * Process either a C++ file or a C file depending on the setting
4082 default_C_entries (inf
)
4085 C_entries (cplusplus
? C_PLPL
: C_AUTO
, inf
);
4088 /* Always do plain C. */
4090 plain_C_entries (inf
)
4096 /* Always do C++. */
4098 Cplusplus_entries (inf
)
4101 C_entries (C_PLPL
, inf
);
4104 /* Always do Java. */
4109 C_entries (C_JAVA
, inf
);
4117 C_entries (C_STAR
, inf
);
4120 /* Always do Yacc. */
4125 C_entries (YACC
, inf
);
4129 /* Useful macros. */
4130 #define LOOP_ON_INPUT_LINES(file_pointer, line_buffer, char_pointer) \
4131 for (; /* loop initialization */ \
4132 !feof (file_pointer) /* loop test */ \
4133 && /* instructions at start of loop */ \
4134 (readline (&line_buffer, file_pointer), \
4135 char_pointer = line_buffer.buffer, \
4139 #define LOOKING_AT(cp, kw) /* kw is the keyword, a literal string */ \
4140 ((assert("" kw), TRUE) /* syntax error if not a literal string */ \
4141 && strneq ((cp), kw, sizeof(kw)-1) /* cp points at kw */ \
4142 && notinname ((cp)[sizeof(kw)-1]) /* end of kw */ \
4143 && ((cp) = skip_spaces((cp)+sizeof(kw)-1))) /* skip spaces */
4145 /* Similar to LOOKING_AT but does not use notinname, does not skip */
4146 #define LOOKING_AT_NOCASE(cp, kw) /* the keyword is a literal string */ \
4147 ((assert("" kw), TRUE) /* syntax error if not a literal string */ \
4148 && strncaseeq ((cp), kw, sizeof(kw)-1) /* cp points at kw */ \
4149 && ((cp) += sizeof(kw)-1)) /* skip spaces */
4152 * Read a file, but do no processing. This is used to do regexp
4153 * matching on files that have no language defined.
4156 just_read_file (inf
)
4159 register char *dummy
;
4161 LOOP_ON_INPUT_LINES (inf
, lb
, dummy
)
4166 /* Fortran parsing */
4168 static void F_takeprec
__P((void));
4169 static void F_getit
__P((FILE *));
4174 dbp
= skip_spaces (dbp
);
4178 dbp
= skip_spaces (dbp
);
4179 if (strneq (dbp
, "(*)", 3))
4184 if (!ISDIGIT (*dbp
))
4186 --dbp
; /* force failure */
4191 while (ISDIGIT (*dbp
));
4200 dbp
= skip_spaces (dbp
);
4203 readline (&lb
, inf
);
4208 dbp
= skip_spaces (dbp
);
4210 if (!ISALPHA (*dbp
) && *dbp
!= '_' && *dbp
!= '$')
4212 for (cp
= dbp
+ 1; *cp
!= '\0' && intoken (*cp
); cp
++)
4214 make_tag (dbp
, cp
-dbp
, TRUE
,
4215 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4220 Fortran_functions (inf
)
4223 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4226 dbp
++; /* Ratfor escape to fortran */
4227 dbp
= skip_spaces (dbp
);
4230 switch (lowcase (*dbp
))
4233 if (nocase_tail ("integer"))
4237 if (nocase_tail ("real"))
4241 if (nocase_tail ("logical"))
4245 if (nocase_tail ("complex") || nocase_tail ("character"))
4249 if (nocase_tail ("double"))
4251 dbp
= skip_spaces (dbp
);
4254 if (nocase_tail ("precision"))
4260 dbp
= skip_spaces (dbp
);
4263 switch (lowcase (*dbp
))
4266 if (nocase_tail ("function"))
4270 if (nocase_tail ("subroutine"))
4274 if (nocase_tail ("entry"))
4278 if (nocase_tail ("blockdata") || nocase_tail ("block data"))
4280 dbp
= skip_spaces (dbp
);
4281 if (*dbp
== '\0') /* assume un-named */
4282 make_tag ("blockdata", 9, TRUE
,
4283 lb
.buffer
, dbp
- lb
.buffer
, lineno
, linecharno
);
4285 F_getit (inf
); /* look for name */
4296 * Philippe Waroquiers (1998)
4299 static void Ada_getit
__P((FILE *, char *));
4301 /* Once we are positioned after an "interesting" keyword, let's get
4302 the real tag value necessary. */
4304 Ada_getit (inf
, name_qualifier
)
4306 char *name_qualifier
;
4314 dbp
= skip_spaces (dbp
);
4316 || (dbp
[0] == '-' && dbp
[1] == '-'))
4318 readline (&lb
, inf
);
4321 switch (lowcase(*dbp
))
4324 if (nocase_tail ("body"))
4326 /* Skipping body of procedure body or package body or ....
4327 resetting qualifier to body instead of spec. */
4328 name_qualifier
= "/b";
4333 /* Skipping type of task type or protected type ... */
4334 if (nocase_tail ("type"))
4341 for (cp
= dbp
; *cp
!= '\0' && *cp
!= '"'; cp
++)
4346 dbp
= skip_spaces (dbp
);
4349 && (ISALPHA (*cp
) || ISDIGIT (*cp
) || *cp
== '_' || *cp
== '.'));
4357 name
= concat (dbp
, name_qualifier
, "");
4359 make_tag (name
, strlen (name
), TRUE
,
4360 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4372 bool inquote
= FALSE
;
4373 bool skip_till_semicolumn
= FALSE
;
4375 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4377 while (*dbp
!= '\0')
4379 /* Skip a string i.e. "abcd". */
4380 if (inquote
|| (*dbp
== '"'))
4382 dbp
= etags_strchr ((inquote
) ? dbp
: dbp
+1, '"');
4387 continue; /* advance char */
4392 break; /* advance line */
4396 /* Skip comments. */
4397 if (dbp
[0] == '-' && dbp
[1] == '-')
4398 break; /* advance line */
4400 /* Skip character enclosed in single quote i.e. 'a'
4401 and skip single quote starting an attribute i.e. 'Image. */
4410 if (skip_till_semicolumn
)
4413 skip_till_semicolumn
= FALSE
;
4415 continue; /* advance char */
4418 /* Search for beginning of a token. */
4419 if (!begtoken (*dbp
))
4422 continue; /* advance char */
4425 /* We are at the beginning of a token. */
4426 switch (lowcase(*dbp
))
4429 if (!packages_only
&& nocase_tail ("function"))
4430 Ada_getit (inf
, "/f");
4432 break; /* from switch */
4433 continue; /* advance char */
4435 if (!packages_only
&& nocase_tail ("procedure"))
4436 Ada_getit (inf
, "/p");
4437 else if (nocase_tail ("package"))
4438 Ada_getit (inf
, "/s");
4439 else if (nocase_tail ("protected")) /* protected type */
4440 Ada_getit (inf
, "/t");
4442 break; /* from switch */
4443 continue; /* advance char */
4446 if (typedefs
&& !packages_only
&& nocase_tail ("use"))
4448 /* when tagging types, avoid tagging use type Pack.Typename;
4449 for this, we will skip everything till a ; */
4450 skip_till_semicolumn
= TRUE
;
4451 continue; /* advance char */
4455 if (!packages_only
&& nocase_tail ("task"))
4456 Ada_getit (inf
, "/k");
4457 else if (typedefs
&& !packages_only
&& nocase_tail ("type"))
4459 Ada_getit (inf
, "/t");
4460 while (*dbp
!= '\0')
4464 break; /* from switch */
4465 continue; /* advance char */
4468 /* Look for the end of the token. */
4469 while (!endtoken (*dbp
))
4472 } /* advance char */
4473 } /* advance line */
4478 * Unix and microcontroller assembly tag handling
4479 * Labels: /^[a-zA-Z_.$][a-zA_Z0-9_.$]*[: ^I^J]/
4480 * Idea by Bob Weiner, Motorola Inc. (1994)
4488 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4490 /* If first char is alphabetic or one of [_.$], test for colon
4491 following identifier. */
4492 if (ISALPHA (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4494 /* Read past label. */
4496 while (ISALNUM (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4498 if (*cp
== ':' || iswhite (*cp
))
4499 /* Found end of label, so copy it and add it to the table. */
4500 make_tag (lb
.buffer
, cp
- lb
.buffer
, TRUE
,
4501 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4509 * Perl sub names: /^sub[ \t\n]+[^ \t\n{]+/
4510 * Perl variable names: /^(my|local).../
4511 * Original code by Bart Robinson <lomew@cs.utah.edu> (1995)
4512 * Additions by Michael Ernst <mernst@alum.mit.edu> (1997)
4513 * Ideas by Kai Großjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE> (2001)
4516 Perl_functions (inf
)
4519 char *package
= savestr ("main"); /* current package name */
4522 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4526 if (LOOKING_AT (cp
, "package"))
4529 get_tag (cp
, &package
);
4531 else if (LOOKING_AT (cp
, "sub"))
4536 while (!notinname (*cp
))
4539 continue; /* nothing found */
4540 if ((pos
= etags_strchr (sp
, ':')) != NULL
4541 && pos
< cp
&& pos
[1] == ':')
4542 /* The name is already qualified. */
4543 make_tag (sp
, cp
- sp
, TRUE
,
4544 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4548 char savechar
, *name
;
4552 name
= concat (package
, "::", sp
);
4554 make_tag (name
, strlen(name
), TRUE
,
4555 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4559 else if (globals
) /* only if we are tagging global vars */
4561 /* Skip a qualifier, if any. */
4562 bool qual
= LOOKING_AT (cp
, "my") || LOOKING_AT (cp
, "local");
4563 /* After "my" or "local", but before any following paren or space. */
4564 char *varstart
= cp
;
4566 if (qual
/* should this be removed? If yes, how? */
4567 && (*cp
== '$' || *cp
== '@' || *cp
== '%'))
4572 while (ISALNUM (*cp
) || *cp
== '_');
4576 /* Should be examining a variable list at this point;
4577 could insist on seeing an open parenthesis. */
4578 while (*cp
!= '\0' && *cp
!= ';' && *cp
!= '=' && *cp
!= ')')
4584 make_tag (varstart
, cp
- varstart
, FALSE
,
4585 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4594 * Look for /^[\t]*def[ \t\n]+[^ \t\n(:]+/ or /^class[ \t\n]+[^ \t\n(:]+/
4595 * Idea by Eric S. Raymond <esr@thyrsus.com> (1997)
4596 * More ideas by seb bacon <seb@jamkit.com> (2002)
4599 Python_functions (inf
)
4604 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4606 cp
= skip_spaces (cp
);
4607 if (LOOKING_AT (cp
, "def") || LOOKING_AT (cp
, "class"))
4610 while (!notinname (*cp
) && *cp
!= ':')
4612 make_tag (name
, cp
- name
, TRUE
,
4613 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4622 * - /^[ \t]*function[ \t\n]+[^ \t\n(]+/
4623 * - /^[ \t]*class[ \t\n]+[^ \t\n]+/
4624 * - /^[ \t]*define\(\"[^\"]+/
4625 * Only with --members:
4626 * - /^[ \t]*var[ \t\n]+\$[^ \t\n=;]/
4627 * Idea by Diez B. Roggisch (2001)
4633 register char *cp
, *name
;
4634 bool search_identifier
= FALSE
;
4636 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4638 cp
= skip_spaces (cp
);
4640 if (search_identifier
4643 while (!notinname (*cp
))
4645 make_tag (name
, cp
- name
, TRUE
,
4646 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4647 search_identifier
= FALSE
;
4649 else if (LOOKING_AT (cp
, "function"))
4652 cp
= skip_spaces (cp
+1);
4656 while (!notinname (*cp
))
4658 make_tag (name
, cp
- name
, TRUE
,
4659 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4662 search_identifier
= TRUE
;
4664 else if (LOOKING_AT (cp
, "class"))
4669 while (*cp
!= '\0' && !iswhite (*cp
))
4671 make_tag (name
, cp
- name
, FALSE
,
4672 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4675 search_identifier
= TRUE
;
4677 else if (strneq (cp
, "define", 6)
4678 && (cp
= skip_spaces (cp
+6))
4680 && (*cp
== '"' || *cp
== '\''))
4684 while (*cp
!= quote
&& *cp
!= '\0')
4686 make_tag (name
, cp
- name
, FALSE
,
4687 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4690 && LOOKING_AT (cp
, "var")
4694 while (!notinname(*cp
))
4696 make_tag (name
, cp
- name
, FALSE
,
4697 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4704 * Cobol tag functions
4705 * We could look for anything that could be a paragraph name.
4706 * i.e. anything that starts in column 8 is one word and ends in a full stop.
4707 * Idea by Corny de Souza (1993)
4710 Cobol_paragraphs (inf
)
4713 register char *bp
, *ep
;
4715 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4721 /* If eoln, compiler option or comment ignore whole line. */
4722 if (bp
[-1] != ' ' || !ISALNUM (bp
[0]))
4725 for (ep
= bp
; ISALNUM (*ep
) || *ep
== '-'; ep
++)
4728 make_tag (bp
, ep
- bp
, TRUE
,
4729 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4736 * Ideas by Assar Westerlund <assar@sics.se> (2001)
4739 Makefile_targets (inf
)
4744 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4746 if (*bp
== '\t' || *bp
== '#')
4748 while (*bp
!= '\0' && *bp
!= '=' && *bp
!= ':')
4750 if (*bp
== ':' || (globals
&& *bp
== '='))
4752 /* We should detect if there is more than one tag, but we do not.
4753 We just skip initial and final spaces. */
4754 char * namestart
= skip_spaces (lb
.buffer
);
4755 while (--bp
> namestart
)
4756 if (!notinname (*bp
))
4758 make_tag (namestart
, bp
- namestart
+ 1, TRUE
,
4759 lb
.buffer
, bp
- lb
.buffer
+ 2, lineno
, linecharno
);
4767 * Original code by Mosur K. Mohan (1989)
4769 * Locates tags for procedures & functions. Doesn't do any type- or
4770 * var-definitions. It does look for the keyword "extern" or
4771 * "forward" immediately following the procedure statement; if found,
4772 * the tag is skipped.
4775 Pascal_functions (inf
)
4778 linebuffer tline
; /* mostly copied from C_entries */
4780 int save_lineno
, namelen
, taglen
;
4783 bool /* each of these flags is TRUE iff: */
4784 incomment
, /* point is inside a comment */
4785 inquote
, /* point is inside '..' string */
4786 get_tagname
, /* point is after PROCEDURE/FUNCTION
4787 keyword, so next item = potential tag */
4788 found_tag
, /* point is after a potential tag */
4789 inparms
, /* point is within parameter-list */
4790 verify_tag
; /* point has passed the parm-list, so the
4791 next token will determine whether this
4792 is a FORWARD/EXTERN to be ignored, or
4793 whether it is a real tag */
4795 save_lcno
= save_lineno
= namelen
= taglen
= 0; /* keep compiler quiet */
4796 name
= NULL
; /* keep compiler quiet */
4799 linebuffer_init (&tline
);
4801 incomment
= inquote
= FALSE
;
4802 found_tag
= FALSE
; /* have a proc name; check if extern */
4803 get_tagname
= FALSE
; /* found "procedure" keyword */
4804 inparms
= FALSE
; /* found '(' after "proc" */
4805 verify_tag
= FALSE
; /* check if "extern" is ahead */
4808 while (!feof (inf
)) /* long main loop to get next char */
4811 if (c
== '\0') /* if end of line */
4813 readline (&lb
, inf
);
4817 if (!((found_tag
&& verify_tag
)
4819 c
= *dbp
++; /* only if don't need *dbp pointing
4820 to the beginning of the name of
4821 the procedure or function */
4825 if (c
== '}') /* within { } comments */
4827 else if (c
== '*' && *dbp
== ')') /* within (* *) comments */
4844 inquote
= TRUE
; /* found first quote */
4846 case '{': /* found open { comment */
4850 if (*dbp
== '*') /* found open (* comment */
4855 else if (found_tag
) /* found '(' after tag, i.e., parm-list */
4858 case ')': /* end of parms list */
4863 if (found_tag
&& !inparms
) /* end of proc or fn stmt */
4870 if (found_tag
&& verify_tag
&& (*dbp
!= ' '))
4872 /* Check if this is an "extern" declaration. */
4875 if (lowcase (*dbp
== 'e'))
4877 if (nocase_tail ("extern")) /* superfluous, really! */
4883 else if (lowcase (*dbp
) == 'f')
4885 if (nocase_tail ("forward")) /* check for forward reference */
4891 if (found_tag
&& verify_tag
) /* not external proc, so make tag */
4895 make_tag (name
, namelen
, TRUE
,
4896 tline
.buffer
, taglen
, save_lineno
, save_lcno
);
4900 if (get_tagname
) /* grab name of proc or fn */
4907 /* Find block name. */
4908 for (cp
= dbp
+ 1; *cp
!= '\0' && !endtoken (*cp
); cp
++)
4911 /* Save all values for later tagging. */
4912 linebuffer_setlen (&tline
, lb
.len
);
4913 strcpy (tline
.buffer
, lb
.buffer
);
4914 save_lineno
= lineno
;
4915 save_lcno
= linecharno
;
4916 name
= tline
.buffer
+ (dbp
- lb
.buffer
);
4918 taglen
= cp
- lb
.buffer
+ 1;
4920 dbp
= cp
; /* set dbp to e-o-token */
4921 get_tagname
= FALSE
;
4925 /* And proceed to check for "extern". */
4927 else if (!incomment
&& !inquote
&& !found_tag
)
4929 /* Check for proc/fn keywords. */
4930 switch (lowcase (c
))
4933 if (nocase_tail ("rocedure")) /* c = 'p', dbp has advanced */
4937 if (nocase_tail ("unction"))
4942 } /* while not eof */
4944 free (tline
.buffer
);
4949 * Lisp tag functions
4950 * look for (def or (DEF, quote or QUOTE
4953 static void L_getit
__P((void));
4958 if (*dbp
== '\'') /* Skip prefix quote */
4960 else if (*dbp
== '(')
4963 /* Try to skip "(quote " */
4964 if (!LOOKING_AT (dbp
, "quote") && !LOOKING_AT (dbp
, "QUOTE"))
4965 /* Ok, then skip "(" before name in (defstruct (foo)) */
4966 dbp
= skip_spaces (dbp
);
4968 get_tag (dbp
, NULL
);
4972 Lisp_functions (inf
)
4975 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4980 if (strneq (dbp
+1, "def", 3) || strneq (dbp
+1, "DEF", 3))
4982 dbp
= skip_non_spaces (dbp
);
4983 dbp
= skip_spaces (dbp
);
4988 /* Check for (foo::defmumble name-defined ... */
4991 while (!notinname (*dbp
) && *dbp
!= ':');
4996 while (*dbp
== ':');
4998 if (strneq (dbp
, "def", 3) || strneq (dbp
, "DEF", 3))
5000 dbp
= skip_non_spaces (dbp
);
5001 dbp
= skip_spaces (dbp
);
5011 * Lua script language parsing
5012 * Original code by David A. Capello <dacap@users.sourceforge.net> (2004)
5014 * "function" and "local function" are tags if they start at column 1.
5022 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5024 if (bp
[0] != 'f' && bp
[0] != 'l')
5027 (void)LOOKING_AT (bp
, "local"); /* skip possible "local" */
5029 if (LOOKING_AT (bp
, "function"))
5037 * Just look for lines where the first character is '/'
5038 * Also look at "defineps" for PSWrap
5040 * Richard Mlynarik <mly@adoc.xerox.com> (1997)
5041 * Masatake Yamato <masata-y@is.aist-nara.ac.jp> (1999)
5047 register char *bp
, *ep
;
5049 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5054 *ep
!= '\0' && *ep
!= ' ' && *ep
!= '{';
5057 make_tag (bp
, ep
- bp
, TRUE
,
5058 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
5060 else if (LOOKING_AT (bp
, "defineps"))
5068 * Ignore anything after \ followed by space or in ( )
5069 * Look for words defined by :
5070 * Look for constant, code, create, defer, value, and variable
5071 * OBP extensions: Look for buffer:, field,
5072 * Ideas by Eduardo Horvath <eeh@netbsd.org> (2004)
5080 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5081 while ((bp
= skip_spaces (bp
))[0] != '\0')
5082 if (bp
[0] == '\\' && iswhite(bp
[1]))
5083 break; /* read next line */
5084 else if (bp
[0] == '(' && iswhite(bp
[1]))
5085 do /* skip to ) or eol */
5087 while (*bp
!= ')' && *bp
!= '\0');
5088 else if ((bp
[0] == ':' && iswhite(bp
[1]) && bp
++)
5089 || LOOKING_AT_NOCASE (bp
, "constant")
5090 || LOOKING_AT_NOCASE (bp
, "code")
5091 || LOOKING_AT_NOCASE (bp
, "create")
5092 || LOOKING_AT_NOCASE (bp
, "defer")
5093 || LOOKING_AT_NOCASE (bp
, "value")
5094 || LOOKING_AT_NOCASE (bp
, "variable")
5095 || LOOKING_AT_NOCASE (bp
, "buffer:")
5096 || LOOKING_AT_NOCASE (bp
, "field"))
5097 get_tag (skip_spaces (bp
), NULL
); /* Yay! A definition! */
5099 bp
= skip_non_spaces (bp
);
5104 * Scheme tag functions
5105 * look for (def... xyzzy
5107 * (def ... ((...(xyzzy ....
5109 * Original code by Ken Haase (1985?)
5112 Scheme_functions (inf
)
5117 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5119 if (strneq (bp
, "(def", 4) || strneq (bp
, "(DEF", 4))
5121 bp
= skip_non_spaces (bp
+4);
5122 /* Skip over open parens and white space */
5123 while (notinname (*bp
))
5127 if (LOOKING_AT (bp
, "(SET!") || LOOKING_AT (bp
, "(set!"))
5133 /* Find tags in TeX and LaTeX input files. */
5135 /* TEX_toktab is a table of TeX control sequences that define tags.
5136 * Each entry records one such control sequence.
5138 * Original code from who knows whom.
5140 * Stefan Monnier (2002)
5143 static linebuffer
*TEX_toktab
= NULL
; /* Table with tag tokens */
5145 /* Default set of control sequences to put into TEX_toktab.
5146 The value of environment var TEXTAGS is prepended to this. */
5147 static char *TEX_defenv
= "\
5148 :chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem\
5149 :part:appendix:entry:index:def\
5150 :newcommand:renewcommand:newenvironment:renewenvironment";
5152 static void TEX_mode
__P((FILE *));
5153 static void TEX_decode_env
__P((char *, char *));
5155 static char TEX_esc
= '\\';
5156 static char TEX_opgrp
= '{';
5157 static char TEX_clgrp
= '}';
5160 * TeX/LaTeX scanning loop.
5169 /* Select either \ or ! as escape character. */
5172 /* Initialize token table once from environment. */
5173 if (TEX_toktab
== NULL
)
5174 TEX_decode_env ("TEXTAGS", TEX_defenv
);
5176 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5178 /* Look at each TEX keyword in line. */
5181 /* Look for a TEX escape. */
5182 while (*cp
++ != TEX_esc
)
5183 if (cp
[-1] == '\0' || cp
[-1] == '%')
5186 for (key
= TEX_toktab
; key
->buffer
!= NULL
; key
++)
5187 if (strneq (cp
, key
->buffer
, key
->len
))
5190 int namelen
, linelen
;
5193 cp
= skip_spaces (cp
+ key
->len
);
5194 if (*cp
== TEX_opgrp
)
5200 (!iswhite (*p
) && *p
!= '#' &&
5201 *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
);
5206 if (!opgrp
|| *p
== TEX_clgrp
)
5208 while (*p
!= '\0' && *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
)
5210 linelen
= p
- lb
.buffer
+ 1;
5212 make_tag (cp
, namelen
, TRUE
,
5213 lb
.buffer
, linelen
, lineno
, linecharno
);
5214 goto tex_next_line
; /* We only tag a line once */
5222 #define TEX_LESC '\\'
5223 #define TEX_SESC '!'
5225 /* Figure out whether TeX's escapechar is '\\' or '!' and set grouping
5226 chars accordingly. */
5233 while ((c
= getc (inf
)) != EOF
)
5235 /* Skip to next line if we hit the TeX comment char. */
5237 while (c
!= '\n' && c
!= EOF
)
5239 else if (c
== TEX_LESC
|| c
== TEX_SESC
)
5255 /* If the input file is compressed, inf is a pipe, and rewind may fail.
5256 No attempt is made to correct the situation. */
5260 /* Read environment and prepend it to the default string.
5261 Build token table. */
5263 TEX_decode_env (evarname
, defenv
)
5267 register char *env
, *p
;
5270 /* Append default string to environment. */
5271 env
= getenv (evarname
);
5277 env
= concat (oldenv
, defenv
, "");
5280 /* Allocate a token table */
5281 for (len
= 1, p
= env
; p
;)
5282 if ((p
= etags_strchr (p
, ':')) && *++p
!= '\0')
5284 TEX_toktab
= xnew (len
, linebuffer
);
5286 /* Unpack environment string into token table. Be careful about */
5287 /* zero-length strings (leading ':', "::" and trailing ':') */
5288 for (i
= 0; *env
!= '\0';)
5290 p
= etags_strchr (env
, ':');
5291 if (!p
) /* End of environment string. */
5292 p
= env
+ strlen (env
);
5294 { /* Only non-zero strings. */
5295 TEX_toktab
[i
].buffer
= savenstr (env
, p
- env
);
5296 TEX_toktab
[i
].len
= p
- env
;
5303 TEX_toktab
[i
].buffer
= NULL
; /* Mark end of table. */
5304 TEX_toktab
[i
].len
= 0;
5311 /* Texinfo support. Dave Love, Mar. 2000. */
5317 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5318 if (LOOKING_AT (cp
, "@node"))
5321 while (*cp
!= '\0' && *cp
!= ',')
5323 make_tag (start
, cp
- start
, TRUE
,
5324 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
5331 * Contents of <title>, <h1>, <h2>, <h3> are tags.
5332 * Contents of <a name=xxx> are tags with name xxx.
5334 * Francesco Potortì, 2002.
5340 bool getnext
= FALSE
; /* next text outside of HTML tags is a tag */
5341 bool skiptag
= FALSE
; /* skip to the end of the current HTML tag */
5342 bool intag
= FALSE
; /* inside an html tag, looking for ID= */
5343 bool inanchor
= FALSE
; /* when INTAG, is an anchor, look for NAME= */
5347 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5349 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
5350 for (;;) /* loop on the same line */
5352 if (skiptag
) /* skip HTML tag */
5354 while (*dbp
!= '\0' && *dbp
!= '>')
5360 continue; /* look on the same line */
5362 break; /* go to next line */
5365 else if (intag
) /* look for "name=" or "id=" */
5367 while (*dbp
!= '\0' && *dbp
!= '>'
5368 && lowcase (*dbp
) != 'n' && lowcase (*dbp
) != 'i')
5371 break; /* go to next line */
5376 continue; /* look on the same line */
5378 if ((inanchor
&& LOOKING_AT_NOCASE (dbp
, "name="))
5379 || LOOKING_AT_NOCASE (dbp
, "id="))
5381 bool quoted
= (dbp
[0] == '"');
5384 for (end
= ++dbp
; *end
!= '\0' && *end
!= '"'; end
++)
5387 for (end
= dbp
; *end
!= '\0' && intoken (*end
); end
++)
5389 linebuffer_setlen (&token_name
, end
- dbp
);
5390 strncpy (token_name
.buffer
, dbp
, end
- dbp
);
5391 token_name
.buffer
[end
- dbp
] = '\0';
5394 intag
= FALSE
; /* we found what we looked for */
5395 skiptag
= TRUE
; /* skip to the end of the tag */
5396 getnext
= TRUE
; /* then grab the text */
5397 continue; /* look on the same line */
5402 else if (getnext
) /* grab next tokens and tag them */
5404 dbp
= skip_spaces (dbp
);
5406 break; /* go to next line */
5410 inanchor
= (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]));
5411 continue; /* look on the same line */
5414 for (end
= dbp
+ 1; *end
!= '\0' && *end
!= '<'; end
++)
5416 make_tag (token_name
.buffer
, token_name
.len
, TRUE
,
5417 dbp
, end
- dbp
, lineno
, linecharno
);
5418 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5420 break; /* go to next line */
5423 else /* look for an interesting HTML tag */
5425 while (*dbp
!= '\0' && *dbp
!= '<')
5428 break; /* go to next line */
5430 if (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]))
5433 continue; /* look on the same line */
5435 else if (LOOKING_AT_NOCASE (dbp
, "<title>")
5436 || LOOKING_AT_NOCASE (dbp
, "<h1>")
5437 || LOOKING_AT_NOCASE (dbp
, "<h2>")
5438 || LOOKING_AT_NOCASE (dbp
, "<h3>"))
5442 continue; /* look on the same line */
5453 * Assumes that the predicate or rule starts at column 0.
5454 * Only the first clause of a predicate or rule is added.
5455 * Original code by Sunichirou Sugou (1989)
5456 * Rewritten by Anders Lindgren (1996)
5458 static int prolog_pr
__P((char *, char *));
5459 static void prolog_skip_comment
__P((linebuffer
*, FILE *));
5460 static int prolog_atom
__P((char *, int));
5463 Prolog_functions (inf
)
5474 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5476 if (cp
[0] == '\0') /* Empty line */
5478 else if (iswhite (cp
[0])) /* Not a predicate */
5480 else if (cp
[0] == '/' && cp
[1] == '*') /* comment. */
5481 prolog_skip_comment (&lb
, inf
);
5482 else if ((len
= prolog_pr (cp
, last
)) > 0)
5484 /* Predicate or rule. Store the function name so that we
5485 only generate a tag for the first clause. */
5487 last
= xnew(len
+ 1, char);
5488 else if (len
+ 1 > allocated
)
5489 xrnew (last
, len
+ 1, char);
5490 allocated
= len
+ 1;
5491 strncpy (last
, cp
, len
);
5501 prolog_skip_comment (plb
, inf
)
5509 for (cp
= plb
->buffer
; *cp
!= '\0'; cp
++)
5510 if (cp
[0] == '*' && cp
[1] == '/')
5512 readline (plb
, inf
);
5518 * A predicate or rule definition is added if it matches:
5519 * <beginning of line><Prolog Atom><whitespace>(
5520 * or <beginning of line><Prolog Atom><whitespace>:-
5522 * It is added to the tags database if it doesn't match the
5523 * name of the previous clause header.
5525 * Return the size of the name of the predicate or rule, or 0 if no
5531 char *last
; /* Name of last clause. */
5536 pos
= prolog_atom (s
, 0);
5541 pos
= skip_spaces (s
+ pos
) - s
;
5544 || (s
[pos
] == '(' && (pos
+= 1))
5545 || (s
[pos
] == ':' && s
[pos
+ 1] == '-' && (pos
+= 2)))
5546 && (last
== NULL
/* save only the first clause */
5547 || len
!= (int)strlen (last
)
5548 || !strneq (s
, last
, len
)))
5550 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5558 * Consume a Prolog atom.
5559 * Return the number of bytes consumed, or -1 if there was an error.
5561 * A prolog atom, in this context, could be one of:
5562 * - An alphanumeric sequence, starting with a lower case letter.
5563 * - A quoted arbitrary string. Single quotes can escape themselves.
5564 * Backslash quotes everything.
5567 prolog_atom (s
, pos
)
5575 if (ISLOWER(s
[pos
]) || (s
[pos
] == '_'))
5577 /* The atom is unquoted. */
5579 while (ISALNUM(s
[pos
]) || (s
[pos
] == '_'))
5583 return pos
- origpos
;
5585 else if (s
[pos
] == '\'')
5596 pos
++; /* A double quote */
5598 else if (s
[pos
] == '\0')
5599 /* Multiline quoted atoms are ignored. */
5601 else if (s
[pos
] == '\\')
5603 if (s
[pos
+1] == '\0')
5610 return pos
- origpos
;
5618 * Support for Erlang
5620 * Generates tags for functions, defines, and records.
5621 * Assumes that Erlang functions start at column 0.
5622 * Original code by Anders Lindgren (1996)
5624 static int erlang_func
__P((char *, char *));
5625 static void erlang_attribute
__P((char *));
5626 static int erlang_atom
__P((char *));
5629 Erlang_functions (inf
)
5640 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5642 if (cp
[0] == '\0') /* Empty line */
5644 else if (iswhite (cp
[0])) /* Not function nor attribute */
5646 else if (cp
[0] == '%') /* comment */
5648 else if (cp
[0] == '"') /* Sometimes, strings start in column one */
5650 else if (cp
[0] == '-') /* attribute, e.g. "-define" */
5652 erlang_attribute (cp
);
5659 else if ((len
= erlang_func (cp
, last
)) > 0)
5662 * Function. Store the function name so that we only
5663 * generates a tag for the first clause.
5666 last
= xnew (len
+ 1, char);
5667 else if (len
+ 1 > allocated
)
5668 xrnew (last
, len
+ 1, char);
5669 allocated
= len
+ 1;
5670 strncpy (last
, cp
, len
);
5680 * A function definition is added if it matches:
5681 * <beginning of line><Erlang Atom><whitespace>(
5683 * It is added to the tags database if it doesn't match the
5684 * name of the previous clause header.
5686 * Return the size of the name of the function, or 0 if no function
5690 erlang_func (s
, last
)
5692 char *last
; /* Name of last clause. */
5697 pos
= erlang_atom (s
);
5702 pos
= skip_spaces (s
+ pos
) - s
;
5704 /* Save only the first clause. */
5707 || len
!= (int)strlen (last
)
5708 || !strneq (s
, last
, len
)))
5710 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5719 * Handle attributes. Currently, tags are generated for defines
5722 * They are on the form:
5723 * -define(foo, bar).
5724 * -define(Foo(M, N), M+N).
5725 * -record(graph, {vtab = notable, cyclic = true}).
5728 erlang_attribute (s
)
5733 if ((LOOKING_AT (cp
, "-define") || LOOKING_AT (cp
, "-record"))
5736 int len
= erlang_atom (skip_spaces (cp
));
5738 make_tag (cp
, len
, TRUE
, s
, cp
+ len
- s
, lineno
, linecharno
);
5745 * Consume an Erlang atom (or variable).
5746 * Return the number of bytes consumed, or -1 if there was an error.
5754 if (ISALPHA (s
[pos
]) || s
[pos
] == '_')
5756 /* The atom is unquoted. */
5759 while (ISALNUM (s
[pos
]) || s
[pos
] == '_');
5761 else if (s
[pos
] == '\'')
5763 for (pos
++; s
[pos
] != '\''; pos
++)
5764 if (s
[pos
] == '\0' /* multiline quoted atoms are ignored */
5765 || (s
[pos
] == '\\' && s
[++pos
] == '\0'))
5774 static char *scan_separators
__P((char *));
5775 static void add_regex
__P((char *, language
*));
5776 static char *substitute
__P((char *, char *, struct re_registers
*));
5779 * Take a string like "/blah/" and turn it into "blah", verifying
5780 * that the first and last characters are the same, and handling
5781 * quoted separator characters. Actually, stops on the occurrence of
5782 * an unquoted separator. Also process \t, \n, etc. and turn into
5783 * appropriate characters. Works in place. Null terminates name string.
5784 * Returns pointer to terminating separator, or NULL for
5785 * unterminated regexps.
5788 scan_separators (name
)
5792 char *copyto
= name
;
5793 bool quoted
= FALSE
;
5795 for (++name
; *name
!= '\0'; ++name
)
5801 case 'a': *copyto
++ = '\007'; break; /* BEL (bell) */
5802 case 'b': *copyto
++ = '\b'; break; /* BS (back space) */
5803 case 'd': *copyto
++ = 0177; break; /* DEL (delete) */
5804 case 'e': *copyto
++ = 033; break; /* ESC (delete) */
5805 case 'f': *copyto
++ = '\f'; break; /* FF (form feed) */
5806 case 'n': *copyto
++ = '\n'; break; /* NL (new line) */
5807 case 'r': *copyto
++ = '\r'; break; /* CR (carriage return) */
5808 case 't': *copyto
++ = '\t'; break; /* TAB (horizontal tab) */
5809 case 'v': *copyto
++ = '\v'; break; /* VT (vertical tab) */
5815 /* Something else is quoted, so preserve the quote. */
5823 else if (*name
== '\\')
5825 else if (*name
== sep
)
5831 name
= NULL
; /* signal unterminated regexp */
5833 /* Terminate copied string. */
5838 /* Look at the argument of --regex or --no-regex and do the right
5839 thing. Same for each line of a regexp file. */
5841 analyse_regex (regex_arg
)
5844 if (regex_arg
== NULL
)
5846 free_regexps (); /* --no-regex: remove existing regexps */
5850 /* A real --regexp option or a line in a regexp file. */
5851 switch (regex_arg
[0])
5853 /* Comments in regexp file or null arg to --regex. */
5859 /* Read a regex file. This is recursive and may result in a
5860 loop, which will stop when the file descriptors are exhausted. */
5864 linebuffer regexbuf
;
5865 char *regexfile
= regex_arg
+ 1;
5867 /* regexfile is a file containing regexps, one per line. */
5868 regexfp
= fopen (regexfile
, "r");
5869 if (regexfp
== NULL
)
5874 linebuffer_init (®exbuf
);
5875 while (readline_internal (®exbuf
, regexfp
) > 0)
5876 analyse_regex (regexbuf
.buffer
);
5877 free (regexbuf
.buffer
);
5882 /* Regexp to be used for a specific language only. */
5886 char *lang_name
= regex_arg
+ 1;
5889 for (cp
= lang_name
; *cp
!= '}'; cp
++)
5892 error ("unterminated language name in regex: %s", regex_arg
);
5896 lang
= get_language_from_langname (lang_name
);
5899 add_regex (cp
, lang
);
5903 /* Regexp to be used for any language. */
5905 add_regex (regex_arg
, NULL
);
5910 /* Separate the regexp pattern, compile it,
5911 and care for optional name and modifiers. */
5913 add_regex (regexp_pattern
, lang
)
5914 char *regexp_pattern
;
5917 static struct re_pattern_buffer zeropattern
;
5918 char sep
, *pat
, *name
, *modifiers
;
5920 struct re_pattern_buffer
*patbuf
;
5923 force_explicit_name
= TRUE
, /* do not use implicit tag names */
5924 ignore_case
= FALSE
, /* case is significant */
5925 multi_line
= FALSE
, /* matches are done one line at a time */
5926 single_line
= FALSE
; /* dot does not match newline */
5929 if (strlen(regexp_pattern
) < 3)
5931 error ("null regexp", (char *)NULL
);
5934 sep
= regexp_pattern
[0];
5935 name
= scan_separators (regexp_pattern
);
5938 error ("%s: unterminated regexp", regexp_pattern
);
5943 error ("null name for regexp \"%s\"", regexp_pattern
);
5946 modifiers
= scan_separators (name
);
5947 if (modifiers
== NULL
) /* no terminating separator --> no name */
5953 modifiers
+= 1; /* skip separator */
5955 /* Parse regex modifiers. */
5956 for (; modifiers
[0] != '\0'; modifiers
++)
5957 switch (modifiers
[0])
5960 if (modifiers
== name
)
5961 error ("forcing explicit tag name but no name, ignoring", NULL
);
5962 force_explicit_name
= TRUE
;
5972 need_filebuf
= TRUE
;
5977 wrongmod
[0] = modifiers
[0];
5979 error ("invalid regexp modifier `%s', ignoring", wrongmod
);
5984 patbuf
= xnew (1, struct re_pattern_buffer
);
5985 *patbuf
= zeropattern
;
5988 static char lc_trans
[CHARS
];
5990 for (i
= 0; i
< CHARS
; i
++)
5991 lc_trans
[i
] = lowcase (i
);
5992 patbuf
->translate
= lc_trans
; /* translation table to fold case */
5996 pat
= concat ("^", regexp_pattern
, ""); /* anchor to beginning of line */
5998 pat
= regexp_pattern
;
6001 re_set_syntax (RE_SYNTAX_EMACS
| RE_DOT_NEWLINE
);
6003 re_set_syntax (RE_SYNTAX_EMACS
);
6005 err
= re_compile_pattern (pat
, strlen (regexp_pattern
), patbuf
);
6010 error ("%s while compiling pattern", err
);
6015 p_head
= xnew (1, regexp
);
6016 p_head
->pattern
= savestr (regexp_pattern
);
6017 p_head
->p_next
= rp
;
6018 p_head
->lang
= lang
;
6019 p_head
->pat
= patbuf
;
6020 p_head
->name
= savestr (name
);
6021 p_head
->error_signaled
= FALSE
;
6022 p_head
->force_explicit_name
= force_explicit_name
;
6023 p_head
->ignore_case
= ignore_case
;
6024 p_head
->multi_line
= multi_line
;
6028 * Do the substitutions indicated by the regular expression and
6032 substitute (in
, out
, regs
)
6034 struct re_registers
*regs
;
6037 int size
, dig
, diglen
;
6040 size
= strlen (out
);
6042 /* Pass 1: figure out how much to allocate by finding all \N strings. */
6043 if (out
[size
- 1] == '\\')
6044 fatal ("pattern error in \"%s\"", out
);
6045 for (t
= etags_strchr (out
, '\\');
6047 t
= etags_strchr (t
+ 2, '\\'))
6051 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
6057 /* Allocate space and do the substitutions. */
6059 result
= xnew (size
+ 1, char);
6061 for (t
= result
; *out
!= '\0'; out
++)
6062 if (*out
== '\\' && ISDIGIT (*++out
))
6065 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
6066 strncpy (t
, in
+ regs
->start
[dig
], diglen
);
6073 assert (t
<= result
+ size
);
6074 assert (t
- result
== (int)strlen (result
));
6079 /* Deallocate all regexps. */
6084 while (p_head
!= NULL
)
6086 rp
= p_head
->p_next
;
6087 free (p_head
->pattern
);
6088 free (p_head
->name
);
6096 * Reads the whole file as a single string from `filebuf' and looks for
6097 * multi-line regular expressions, creating tags on matches.
6098 * readline already dealt with normal regexps.
6100 * Idea by Ben Wing <ben@666.com> (2002).
6103 regex_tag_multiline ()
6105 char *buffer
= filebuf
.buffer
;
6109 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6113 if (!rp
->multi_line
)
6114 continue; /* skip normal regexps */
6116 /* Generic initialisations before parsing file from memory. */
6117 lineno
= 1; /* reset global line number */
6118 charno
= 0; /* reset global char number */
6119 linecharno
= 0; /* reset global char number of line start */
6121 /* Only use generic regexps or those for the current language. */
6122 if (rp
->lang
!= NULL
&& rp
->lang
!= curfdp
->lang
)
6125 while (match
>= 0 && match
< filebuf
.len
)
6127 match
= re_search (rp
->pat
, buffer
, filebuf
.len
, charno
,
6128 filebuf
.len
- match
, &rp
->regs
);
6133 if (!rp
->error_signaled
)
6135 error ("regexp stack overflow while matching \"%s\"",
6137 rp
->error_signaled
= TRUE
;
6144 if (match
== rp
->regs
.end
[0])
6146 if (!rp
->error_signaled
)
6148 error ("regexp matches the empty string: \"%s\"",
6150 rp
->error_signaled
= TRUE
;
6152 match
= -3; /* exit from while loop */
6156 /* Match occurred. Construct a tag. */
6157 while (charno
< rp
->regs
.end
[0])
6158 if (buffer
[charno
++] == '\n')
6159 lineno
++, linecharno
= charno
;
6161 if (name
[0] == '\0')
6163 else /* make a named tag */
6164 name
= substitute (buffer
, rp
->name
, &rp
->regs
);
6165 if (rp
->force_explicit_name
)
6166 /* Force explicit tag name, if a name is there. */
6167 pfnote (name
, TRUE
, buffer
+ linecharno
,
6168 charno
- linecharno
+ 1, lineno
, linecharno
);
6170 make_tag (name
, strlen (name
), TRUE
, buffer
+ linecharno
,
6171 charno
- linecharno
+ 1, lineno
, linecharno
);
6183 register int len
= 0;
6185 while (*cp
!= '\0' && lowcase (*cp
) == lowcase (dbp
[len
]))
6187 if (*cp
== '\0' && !intoken (dbp
[len
]))
6196 get_tag (bp
, namepp
)
6200 register char *cp
= bp
;
6204 /* Go till you get to white space or a syntactic break */
6205 for (cp
= bp
+ 1; !notinname (*cp
); cp
++)
6207 make_tag (bp
, cp
- bp
, TRUE
,
6208 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
6212 *namepp
= savenstr (bp
, cp
- bp
);
6216 * Read a line of text from `stream' into `lbp', excluding the
6217 * newline or CR-NL, if any. Return the number of characters read from
6218 * `stream', which is the length of the line including the newline.
6220 * On DOS or Windows we do not count the CR character, if any before the
6221 * NL, in the returned length; this mirrors the behavior of Emacs on those
6222 * platforms (for text files, it translates CR-NL to NL as it reads in the
6225 * If multi-line regular expressions are requested, each line read is
6226 * appended to `filebuf'.
6229 readline_internal (lbp
, stream
)
6231 register FILE *stream
;
6233 char *buffer
= lbp
->buffer
;
6234 register char *p
= lbp
->buffer
;
6235 register char *pend
;
6238 pend
= p
+ lbp
->size
; /* Separate to avoid 386/IX compiler bug. */
6242 register int c
= getc (stream
);
6245 /* We're at the end of linebuffer: expand it. */
6247 xrnew (buffer
, lbp
->size
, char);
6248 p
+= buffer
- lbp
->buffer
;
6249 pend
= buffer
+ lbp
->size
;
6250 lbp
->buffer
= buffer
;
6260 if (p
> buffer
&& p
[-1] == '\r')
6264 /* Assume CRLF->LF translation will be performed by Emacs
6265 when loading this file, so CRs won't appear in the buffer.
6266 It would be cleaner to compensate within Emacs;
6267 however, Emacs does not know how many CRs were deleted
6268 before any given point in the file. */
6283 lbp
->len
= p
- buffer
;
6285 if (need_filebuf
/* we need filebuf for multi-line regexps */
6286 && chars_deleted
> 0) /* not at EOF */
6288 while (filebuf
.size
<= filebuf
.len
+ lbp
->len
+ 1) /* +1 for \n */
6290 /* Expand filebuf. */
6292 xrnew (filebuf
.buffer
, filebuf
.size
, char);
6294 strncpy (filebuf
.buffer
+ filebuf
.len
, lbp
->buffer
, lbp
->len
);
6295 filebuf
.len
+= lbp
->len
;
6296 filebuf
.buffer
[filebuf
.len
++] = '\n';
6297 filebuf
.buffer
[filebuf
.len
] = '\0';
6300 return lbp
->len
+ chars_deleted
;
6304 * Like readline_internal, above, but in addition try to match the
6305 * input line against relevant regular expressions and manage #line
6309 readline (lbp
, stream
)
6315 linecharno
= charno
; /* update global char number of line start */
6316 result
= readline_internal (lbp
, stream
); /* read line */
6317 lineno
+= 1; /* increment global line number */
6318 charno
+= result
; /* increment global char number */
6320 /* Honour #line directives. */
6321 if (!no_line_directive
)
6323 static bool discard_until_line_directive
;
6325 /* Check whether this is a #line directive. */
6326 if (result
> 12 && strneq (lbp
->buffer
, "#line ", 6))
6331 if (sscanf (lbp
->buffer
, "#line %u \"%n", &lno
, &start
) >= 1
6332 && start
> 0) /* double quote character found */
6334 char *endp
= lbp
->buffer
+ start
;
6336 while ((endp
= etags_strchr (endp
, '"')) != NULL
6337 && endp
[-1] == '\\')
6340 /* Ok, this is a real #line directive. Let's deal with it. */
6342 char *taggedabsname
; /* absolute name of original file */
6343 char *taggedfname
; /* name of original file as given */
6344 char *name
; /* temp var */
6346 discard_until_line_directive
= FALSE
; /* found it */
6347 name
= lbp
->buffer
+ start
;
6349 canonicalize_filename (name
); /* for DOS */
6350 taggedabsname
= absolute_filename (name
, tagfiledir
);
6351 if (filename_is_absolute (name
)
6352 || filename_is_absolute (curfdp
->infname
))
6353 taggedfname
= savestr (taggedabsname
);
6355 taggedfname
= relative_filename (taggedabsname
,tagfiledir
);
6357 if (streq (curfdp
->taggedfname
, taggedfname
))
6358 /* The #line directive is only a line number change. We
6359 deal with this afterwards. */
6362 /* The tags following this #line directive should be
6363 attributed to taggedfname. In order to do this, set
6364 curfdp accordingly. */
6366 fdesc
*fdp
; /* file description pointer */
6368 /* Go look for a file description already set up for the
6369 file indicated in the #line directive. If there is
6370 one, use it from now until the next #line
6372 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6373 if (streq (fdp
->infname
, curfdp
->infname
)
6374 && streq (fdp
->taggedfname
, taggedfname
))
6375 /* If we remove the second test above (after the &&)
6376 then all entries pertaining to the same file are
6377 coalesced in the tags file. If we use it, then
6378 entries pertaining to the same file but generated
6379 from different files (via #line directives) will
6380 go into separate sections in the tags file. These
6381 alternatives look equivalent. The first one
6382 destroys some apparently useless information. */
6388 /* Else, if we already tagged the real file, skip all
6389 input lines until the next #line directive. */
6390 if (fdp
== NULL
) /* not found */
6391 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6392 if (streq (fdp
->infabsname
, taggedabsname
))
6394 discard_until_line_directive
= TRUE
;
6398 /* Else create a new file description and use that from
6399 now on, until the next #line directive. */
6400 if (fdp
== NULL
) /* not found */
6403 fdhead
= xnew (1, fdesc
);
6404 *fdhead
= *curfdp
; /* copy curr. file description */
6406 fdhead
->infname
= savestr (curfdp
->infname
);
6407 fdhead
->infabsname
= savestr (curfdp
->infabsname
);
6408 fdhead
->infabsdir
= savestr (curfdp
->infabsdir
);
6409 fdhead
->taggedfname
= taggedfname
;
6410 fdhead
->usecharno
= FALSE
;
6411 fdhead
->prop
= NULL
;
6412 fdhead
->written
= FALSE
;
6416 free (taggedabsname
);
6418 readline (lbp
, stream
);
6420 } /* if a real #line directive */
6421 } /* if #line is followed by a a number */
6422 } /* if line begins with "#line " */
6424 /* If we are here, no #line directive was found. */
6425 if (discard_until_line_directive
)
6429 /* Do a tail recursion on ourselves, thus discarding the contents
6430 of the line buffer. */
6431 readline (lbp
, stream
);
6435 discard_until_line_directive
= FALSE
;
6438 } /* if #line directives should be considered */
6445 /* Match against relevant regexps. */
6447 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6449 /* Only use generic regexps or those for the current language.
6450 Also do not use multiline regexps, which is the job of
6451 regex_tag_multiline. */
6452 if ((rp
->lang
!= NULL
&& rp
->lang
!= fdhead
->lang
)
6456 match
= re_match (rp
->pat
, lbp
->buffer
, lbp
->len
, 0, &rp
->regs
);
6461 if (!rp
->error_signaled
)
6463 error ("regexp stack overflow while matching \"%s\"",
6465 rp
->error_signaled
= TRUE
;
6472 /* Empty string matched. */
6473 if (!rp
->error_signaled
)
6475 error ("regexp matches the empty string: \"%s\"", rp
->pattern
);
6476 rp
->error_signaled
= TRUE
;
6480 /* Match occurred. Construct a tag. */
6482 if (name
[0] == '\0')
6484 else /* make a named tag */
6485 name
= substitute (lbp
->buffer
, rp
->name
, &rp
->regs
);
6486 if (rp
->force_explicit_name
)
6487 /* Force explicit tag name, if a name is there. */
6488 pfnote (name
, TRUE
, lbp
->buffer
, match
, lineno
, linecharno
);
6490 make_tag (name
, strlen (name
), TRUE
,
6491 lbp
->buffer
, match
, lineno
, linecharno
);
6500 * Return a pointer to a space of size strlen(cp)+1 allocated
6501 * with xnew where the string CP has been copied.
6507 return savenstr (cp
, strlen (cp
));
6511 * Return a pointer to a space of size LEN+1 allocated with xnew where
6512 * the string CP has been copied for at most the first LEN characters.
6521 dp
= xnew (len
+ 1, char);
6522 strncpy (dp
, cp
, len
);
6528 * Return the ptr in sp at which the character c last
6529 * appears; NULL if not found
6531 * Identical to POSIX strrchr, included for portability.
6534 etags_strrchr (sp
, c
)
6535 register const char *sp
;
6538 register const char *r
;
6550 * Return the ptr in sp at which the character c first
6551 * appears; NULL if not found
6553 * Identical to POSIX strchr, included for portability.
6556 etags_strchr (sp
, c
)
6557 register const char *sp
;
6569 * Compare two strings, ignoring case for alphabetic characters.
6571 * Same as BSD's strcasecmp, included for portability.
6574 etags_strcasecmp (s1
, s2
)
6575 register const char *s1
;
6576 register const char *s2
;
6579 && (ISALPHA (*s1
) && ISALPHA (*s2
)
6580 ? lowcase (*s1
) == lowcase (*s2
)
6584 return (ISALPHA (*s1
) && ISALPHA (*s2
)
6585 ? lowcase (*s1
) - lowcase (*s2
)
6590 * Compare two strings, ignoring case for alphabetic characters.
6591 * Stop after a given number of characters
6593 * Same as BSD's strncasecmp, included for portability.
6596 etags_strncasecmp (s1
, s2
, n
)
6597 register const char *s1
;
6598 register const char *s2
;
6601 while (*s1
!= '\0' && n
-- > 0
6602 && (ISALPHA (*s1
) && ISALPHA (*s2
)
6603 ? lowcase (*s1
) == lowcase (*s2
)
6610 return (ISALPHA (*s1
) && ISALPHA (*s2
)
6611 ? lowcase (*s1
) - lowcase (*s2
)
6615 /* Skip spaces (end of string is not space), return new pointer. */
6620 while (iswhite (*cp
))
6625 /* Skip non spaces, except end of string, return new pointer. */
6627 skip_non_spaces (cp
)
6630 while (*cp
!= '\0' && !iswhite (*cp
))
6635 /* Print error message and exit. */
6641 exit (EXIT_FAILURE
);
6649 exit (EXIT_FAILURE
);
6653 suggest_asking_for_help ()
6655 fprintf (stderr
, "\tTry `%s %s' for a complete list of options.\n",
6656 progname
, NO_LONG_OPTIONS
? "-h" : "--help");
6657 exit (EXIT_FAILURE
);
6660 /* Print error message. `s1' is printf control string, `s2' is arg for it. */
6663 const char *s1
, *s2
;
6665 fprintf (stderr
, "%s: ", progname
);
6666 fprintf (stderr
, s1
, s2
);
6667 fprintf (stderr
, "\n");
6670 /* Return a newly-allocated string whose contents
6671 concatenate those of s1, s2, s3. */
6676 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
6677 char *result
= xnew (len1
+ len2
+ len3
+ 1, char);
6679 strcpy (result
, s1
);
6680 strcpy (result
+ len1
, s2
);
6681 strcpy (result
+ len1
+ len2
, s3
);
6682 result
[len1
+ len2
+ len3
] = '\0';
6688 /* Does the same work as the system V getcwd, but does not need to
6689 guess the buffer size in advance. */
6695 char *path
= xnew (bufsize
, char);
6697 while (getcwd (path
, bufsize
) == NULL
)
6699 if (errno
!= ERANGE
)
6703 path
= xnew (bufsize
, char);
6706 canonicalize_filename (path
);
6709 #else /* not HAVE_GETCWD */
6712 char *p
, path
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
6716 for (p
= path
; *p
!= '\0'; p
++)
6722 return strdup (path
);
6723 #else /* not MSDOS */
6727 linebuffer_init (&path
);
6728 pipe
= (FILE *) popen ("pwd 2>/dev/null", "r");
6729 if (pipe
== NULL
|| readline_internal (&path
, pipe
) == 0)
6734 #endif /* not MSDOS */
6735 #endif /* not HAVE_GETCWD */
6738 /* Return a newly allocated string containing the file name of FILE
6739 relative to the absolute directory DIR (which should end with a slash). */
6741 relative_filename (file
, dir
)
6744 char *fp
, *dp
, *afn
, *res
;
6747 /* Find the common root of file and dir (with a trailing slash). */
6748 afn
= absolute_filename (file
, cwd
);
6751 while (*fp
++ == *dp
++)
6753 fp
--, dp
--; /* back to the first differing char */
6755 if (fp
== afn
&& afn
[0] != '/') /* cannot build a relative name */
6758 do /* look at the equal chars until '/' */
6762 /* Build a sequence of "../" strings for the resulting relative file name. */
6764 while ((dp
= etags_strchr (dp
+ 1, '/')) != NULL
)
6766 res
= xnew (3*i
+ strlen (fp
+ 1) + 1, char);
6769 strcat (res
, "../");
6771 /* Add the file name relative to the common root of file and dir. */
6772 strcat (res
, fp
+ 1);
6778 /* Return a newly allocated string containing the absolute file name
6779 of FILE given DIR (which should end with a slash). */
6781 absolute_filename (file
, dir
)
6784 char *slashp
, *cp
, *res
;
6786 if (filename_is_absolute (file
))
6787 res
= savestr (file
);
6789 /* We don't support non-absolute file names with a drive
6790 letter, like `d:NAME' (it's too much hassle). */
6791 else if (file
[1] == ':')
6792 fatal ("%s: relative file names with drive letters not supported", file
);
6795 res
= concat (dir
, file
, "");
6797 /* Delete the "/dirname/.." and "/." substrings. */
6798 slashp
= etags_strchr (res
, '/');
6799 while (slashp
!= NULL
&& slashp
[0] != '\0')
6801 if (slashp
[1] == '.')
6803 if (slashp
[2] == '.'
6804 && (slashp
[3] == '/' || slashp
[3] == '\0'))
6809 while (cp
>= res
&& !filename_is_absolute (cp
));
6811 cp
= slashp
; /* the absolute name begins with "/.." */
6813 /* Under MSDOS and NT we get `d:/NAME' as absolute
6814 file name, so the luser could say `d:/../NAME'.
6815 We silently treat this as `d:/NAME'. */
6816 else if (cp
[0] != '/')
6819 strcpy (cp
, slashp
+ 3);
6823 else if (slashp
[2] == '/' || slashp
[2] == '\0')
6825 strcpy (slashp
, slashp
+ 2);
6830 slashp
= etags_strchr (slashp
+ 1, '/');
6833 if (res
[0] == '\0') /* just a safety net: should never happen */
6836 return savestr ("/");
6842 /* Return a newly allocated string containing the absolute
6843 file name of dir where FILE resides given DIR (which should
6844 end with a slash). */
6846 absolute_dirname (file
, dir
)
6852 canonicalize_filename (file
);
6853 slashp
= etags_strrchr (file
, '/');
6855 return savestr (dir
);
6858 res
= absolute_filename (file
, dir
);
6864 /* Whether the argument string is an absolute file name. The argument
6865 string must have been canonicalized with canonicalize_filename. */
6867 filename_is_absolute (fn
)
6870 return (fn
[0] == '/'
6872 || (ISALPHA(fn
[0]) && fn
[1] == ':' && fn
[2] == '/')
6877 /* Translate backslashes into slashes. Works in place. */
6879 canonicalize_filename (fn
)
6883 /* Canonicalize drive letter case. */
6884 if (fn
[0] != '\0' && fn
[1] == ':' && ISLOWER (fn
[0]))
6885 fn
[0] = upcase (fn
[0]);
6886 /* Convert backslashes to slashes. */
6887 for (; *fn
!= '\0'; fn
++)
6892 fn
= NULL
; /* shut up the compiler */
6897 /* Initialize a linebuffer for use */
6899 linebuffer_init (lbp
)
6902 lbp
->size
= (DEBUG
) ? 3 : 200;
6903 lbp
->buffer
= xnew (lbp
->size
, char);
6904 lbp
->buffer
[0] = '\0';
6908 /* Set the minimum size of a string contained in a linebuffer. */
6910 linebuffer_setlen (lbp
, toksize
)
6914 while (lbp
->size
<= toksize
)
6917 xrnew (lbp
->buffer
, lbp
->size
, char);
6922 /* Like malloc but get fatal error if memory is exhausted. */
6927 PTR result
= (PTR
) malloc (size
);
6929 fatal ("virtual memory exhausted", (char *)NULL
);
6934 xrealloc (ptr
, size
)
6938 PTR result
= (PTR
) realloc (ptr
, size
);
6940 fatal ("virtual memory exhausted", (char *)NULL
);
6946 * indent-tabs-mode: t
6949 * c-font-lock-extra-types: ("FILE" "bool" "language" "linebuffer" "fdesc" "node" "regexp")
6950 * c-file-style: "gnu"
6954 /* arch-tag: 8a9b748d-390c-4922-99db-2eeefa921051
6955 (do not change this comment) */
6957 /* etags.c ends here */