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 printf ("%s (%s %s)\n", (CTAGS
) ? "ctags" : "etags", EMACS_NAME
, VERSION
);
891 puts ("Copyright (C) 2007 Free Software Foundation, Inc.");
892 puts ("This program is distributed under the terms in ETAGS.README");
898 print_help (argbuffer
)
901 bool help_for_lang
= FALSE
;
903 for (; argbuffer
->arg_type
!= at_end
; argbuffer
++)
904 if (argbuffer
->arg_type
== at_language
)
908 puts (argbuffer
->lang
->help
);
909 help_for_lang
= TRUE
;
915 printf ("Usage: %s [options] [[regex-option ...] file-name] ...\n\
917 These are the options accepted by %s.\n", progname
, progname
);
919 puts ("WARNING: long option names do not work with this executable,\n\
920 as it is not linked with GNU getopt.");
922 puts ("You may use unambiguous abbreviations for the long option names.");
923 puts (" A - as file name means read names from stdin (one per line).\n\
924 Absolute names are stored in the output file as they are.\n\
925 Relative ones are stored relative to the output file's directory.\n");
927 puts ("-a, --append\n\
928 Append tag entries to existing tags file.");
930 puts ("--packages-only\n\
931 For Ada files, only generate tags for packages.");
934 puts ("-B, --backward-search\n\
935 Write the search commands for the tag entries using '?', the\n\
936 backward-search command instead of '/', the forward-search command.");
938 /* This option is mostly obsolete, because etags can now automatically
939 detect C++. Retained for backward compatibility and for debugging and
940 experimentation. In principle, we could want to tag as C++ even
941 before any "class" or "template" keyword.
943 Treat files whose name suffix defaults to C language as C++ files.");
946 puts ("--declarations\n\
947 In C and derived languages, create tags for function declarations,");
949 puts ("\tand create tags for extern variables if --globals is used.");
952 ("\tand create tags for extern variables unless --no-globals is used.");
955 puts ("-d, --defines\n\
956 Create tag entries for C #define constants and enum constants, too.");
958 puts ("-D, --no-defines\n\
959 Don't create tag entries for C #define constants and enum constants.\n\
960 This makes the tags file smaller.");
963 puts ("-i FILE, --include=FILE\n\
964 Include a note in tag file indicating that, when searching for\n\
965 a tag, one should also consult the tags file FILE after\n\
966 checking the current file.");
968 puts ("-l LANG, --language=LANG\n\
969 Force the following files to be considered as written in the\n\
970 named language up to the next --language=LANG option.");
974 Create tag entries for global variables in some languages.");
976 puts ("--no-globals\n\
977 Do not create tag entries for global variables in some\n\
978 languages. This makes the tags file smaller.");
981 Create tag entries for members of structures in some languages.");
983 puts ("--no-members\n\
984 Do not create tag entries for members of structures\n\
985 in some languages.");
987 puts ("-r REGEXP, --regex=REGEXP or --regex=@regexfile\n\
988 Make a tag for each line matching a regular expression pattern\n\
989 in the following files. {LANGUAGE}REGEXP uses REGEXP for LANGUAGE\n\
990 files only. REGEXFILE is a file containing one REGEXP per line.\n\
991 REGEXP takes the form /TAGREGEXP/TAGNAME/MODS, where TAGNAME/ is\n\
992 optional. The TAGREGEXP pattern is anchored (as if preceded by ^).");
993 puts (" If TAGNAME/ is present, the tags created are named.\n\
994 For example Tcl named tags can be created with:\n\
995 --regex=\"/proc[ \\t]+\\([^ \\t]+\\)/\\1/.\".\n\
996 MODS are optional one-letter modifiers: `i' means to ignore case,\n\
997 `m' means to allow multi-line matches, `s' implies `m' and\n\
998 causes dot to match any character, including newline.");
999 puts ("-R, --no-regex\n\
1000 Don't create tags from regexps for the following files.");
1001 puts ("-I, --ignore-indentation\n\
1002 In C and C++ do not assume that a closing brace in the first\n\
1003 column is the final brace of a function or structure definition.");
1004 puts ("-o FILE, --output=FILE\n\
1005 Write the tags to FILE.");
1006 puts ("--parse-stdin=NAME\n\
1007 Read from standard input and record tags as belonging to file NAME.");
1011 puts ("-t, --typedefs\n\
1012 Generate tag entries for C and Ada typedefs.");
1013 puts ("-T, --typedefs-and-c++\n\
1014 Generate tag entries for C typedefs, C struct/enum/union tags,\n\
1015 and C++ member functions.");
1019 puts ("-u, --update\n\
1020 Update the tag entries for the given files, leaving tag\n\
1021 entries for other files in place. Currently, this is\n\
1022 implemented by deleting the existing entries for the given\n\
1023 files and then rewriting the new entries at the end of the\n\
1024 tags file. It is often faster to simply rebuild the entire\n\
1025 tag file than to use this.");
1029 puts ("-v, --vgrind\n\
1030 Print on the standard output an index of items intended for\n\
1031 human consumption, similar to the output of vgrind. The index\n\
1032 is sorted, and gives the page number of each item.");
1033 # if PRINT_UNDOCUMENTED_OPTIONS_HELP
1034 puts ("-w, --no-duplicates\n\
1035 Do not create duplicate tag entries, for compatibility with\n\
1036 traditional ctags.");
1037 puts ("-w, --no-warn\n\
1038 Suppress warning messages about duplicate tag entries.");
1039 # endif /* PRINT_UNDOCUMENTED_OPTIONS_HELP */
1040 puts ("-x, --cxref\n\
1041 Like --vgrind, but in the style of cxref, rather than vgrind.\n\
1042 The output uses line numbers instead of page numbers, but\n\
1043 beyond that the differences are cosmetic; try both to see\n\
1047 puts ("-V, --version\n\
1048 Print the version of the program.\n\
1050 Print this help message.\n\
1051 Followed by one or more `--language' options prints detailed\n\
1052 help about tag generation for the specified languages.");
1054 print_language_names ();
1057 puts ("Report bugs to bug-gnu-emacs@gnu.org");
1059 exit (EXIT_SUCCESS
);
1063 #ifdef VMS /* VMS specific functions */
1067 /* This is a BUG! ANY arbitrary limit is a BUG!
1068 Won't someone please fix this? */
1069 #define MAX_FILE_SPEC_LEN 255
1072 char body
[MAX_FILE_SPEC_LEN
+ 1];
1076 v1.05 nmm 26-Jun-86 fn_exp - expand specification of list of file names
1077 returning in each successive call the next file name matching the input
1078 spec. The function expects that each in_spec passed
1079 to it will be processed to completion; in particular, up to and
1080 including the call following that in which the last matching name
1081 is returned, the function ignores the value of in_spec, and will
1082 only start processing a new spec with the following call.
1083 If an error occurs, on return out_spec contains the value
1084 of in_spec when the error occurred.
1086 With each successive file name returned in out_spec, the
1087 function's return value is one. When there are no more matching
1088 names the function returns zero. If on the first call no file
1089 matches in_spec, or there is any other error, -1 is returned.
1093 #include <descrip.h>
1094 #define OUTSIZE MAX_FILE_SPEC_LEN
1100 static long context
= 0;
1101 static struct dsc$descriptor_s o
;
1102 static struct dsc$descriptor_s i
;
1103 static bool pass1
= TRUE
;
1110 o
.dsc$a_pointer
= (char *) out
;
1111 o
.dsc$w_length
= (short)OUTSIZE
;
1112 i
.dsc$a_pointer
= in
;
1113 i
.dsc$w_length
= (short)strlen(in
);
1114 i
.dsc$b_dtype
= DSC$K_DTYPE_T
;
1115 i
.dsc$b_class
= DSC$K_CLASS_S
;
1116 o
.dsc$b_dtype
= DSC$K_DTYPE_VT
;
1117 o
.dsc$b_class
= DSC$K_CLASS_VS
;
1119 if ((status
= lib$
find_file(&i
, &o
, &context
, 0, 0)) == RMS$_NORMAL
)
1121 out
->body
[out
->curlen
] = EOS
;
1124 else if (status
== RMS$_NMF
)
1128 strcpy(out
->body
, in
);
1131 lib$
find_file_end(&context
);
1137 v1.01 nmm 19-Aug-85 gfnames - return in successive calls the
1138 name of each file specified by the provided arg expanding wildcards.
1141 gfnames (arg
, p_error
)
1145 static vspec filename
= {MAX_FILE_SPEC_LEN
, "\0"};
1147 switch (fn_exp (&filename
, arg
))
1151 return filename
.body
;
1157 return filename
.body
;
1161 #ifndef OLD /* Newer versions of VMS do provide `system'. */
1165 error ("%s", "system() function not implemented under VMS");
1169 #define VERSION_DELIM ';'
1170 char *massage_name (s
)
1176 if (*s
== VERSION_DELIM
)
1194 unsigned int nincluded_files
;
1195 char **included_files
;
1196 argument
*argbuffer
;
1197 int current_arg
, file_count
;
1198 linebuffer filename_lb
;
1199 bool help_asked
= FALSE
;
1208 _fmode
= O_BINARY
; /* all of files are treated as binary files */
1212 nincluded_files
= 0;
1213 included_files
= xnew (argc
, char *);
1217 /* Allocate enough no matter what happens. Overkill, but each one
1219 argbuffer
= xnew (argc
, argument
);
1222 * If etags, always find typedefs and structure tags. Why not?
1223 * Also default to find macro constants, enum constants, struct
1224 * members and global variables.
1228 typedefs
= typedefs_or_cplusplus
= constantypedefs
= TRUE
;
1229 globals
= members
= TRUE
;
1232 /* When the optstring begins with a '-' getopt_long does not rearrange the
1233 non-options arguments to be at the end, but leaves them alone. */
1234 optstring
= concat (NO_LONG_OPTIONS
? "" : "-",
1235 "ac:Cf:Il:o:r:RSVhH",
1236 (CTAGS
) ? "BxdtTuvw" : "Di:");
1238 while ((opt
= getopt_long (argc
, argv
, optstring
, longopts
, NULL
)) != EOF
)
1242 /* If getopt returns 0, then it has already processed a
1243 long-named option. We should do nothing. */
1247 /* This means that a file name has been seen. Record it. */
1248 argbuffer
[current_arg
].arg_type
= at_filename
;
1249 argbuffer
[current_arg
].what
= optarg
;
1255 /* Parse standard input. Idea by Vivek <vivek@etla.org>. */
1256 argbuffer
[current_arg
].arg_type
= at_stdin
;
1257 argbuffer
[current_arg
].what
= optarg
;
1261 fatal ("cannot parse standard input more than once", (char *)NULL
);
1262 parsing_stdin
= TRUE
;
1265 /* Common options. */
1266 case 'a': append_to_tagfile
= TRUE
; break;
1267 case 'C': cplusplus
= TRUE
; break;
1268 case 'f': /* for compatibility with old makefiles */
1272 error ("-o option may only be given once.", (char *)NULL
);
1273 suggest_asking_for_help ();
1279 case 'S': /* for backward compatibility */
1280 ignoreindent
= TRUE
;
1284 language
*lang
= get_language_from_langname (optarg
);
1287 argbuffer
[current_arg
].lang
= lang
;
1288 argbuffer
[current_arg
].arg_type
= at_language
;
1294 /* Backward compatibility: support obsolete --ignore-case-regexp. */
1295 optarg
= concat (optarg
, "i", ""); /* memory leak here */
1298 argbuffer
[current_arg
].arg_type
= at_regexp
;
1299 argbuffer
[current_arg
].what
= optarg
;
1303 argbuffer
[current_arg
].arg_type
= at_regexp
;
1304 argbuffer
[current_arg
].what
= NULL
;
1316 case 'D': constantypedefs
= FALSE
; break;
1317 case 'i': included_files
[nincluded_files
++] = optarg
; break;
1319 /* Ctags options. */
1320 case 'B': searchar
= '?'; break;
1321 case 'd': constantypedefs
= TRUE
; break;
1322 case 't': typedefs
= TRUE
; break;
1323 case 'T': typedefs
= typedefs_or_cplusplus
= TRUE
; break;
1324 case 'u': update
= TRUE
; break;
1325 case 'v': vgrind_style
= TRUE
; /*FALLTHRU*/
1326 case 'x': cxref_style
= TRUE
; break;
1327 case 'w': no_warnings
= TRUE
; break;
1329 suggest_asking_for_help ();
1333 /* No more options. Store the rest of arguments. */
1334 for (; optind
< argc
; optind
++)
1336 argbuffer
[current_arg
].arg_type
= at_filename
;
1337 argbuffer
[current_arg
].what
= argv
[optind
];
1342 argbuffer
[current_arg
].arg_type
= at_end
;
1345 print_help (argbuffer
);
1348 if (nincluded_files
== 0 && file_count
== 0)
1350 error ("no input files specified.", (char *)NULL
);
1351 suggest_asking_for_help ();
1355 if (tagfile
== NULL
)
1356 tagfile
= CTAGS
? "tags" : "TAGS";
1357 cwd
= etags_getcwd (); /* the current working directory */
1358 if (cwd
[strlen (cwd
) - 1] != '/')
1361 cwd
= concat (oldcwd
, "/", "");
1364 /* Relative file names are made relative to the current directory. */
1365 if (streq (tagfile
, "-")
1366 || strneq (tagfile
, "/dev/", 5))
1369 tagfiledir
= absolute_dirname (tagfile
, cwd
);
1371 init (); /* set up boolean "functions" */
1373 linebuffer_init (&lb
);
1374 linebuffer_init (&filename_lb
);
1375 linebuffer_init (&filebuf
);
1376 linebuffer_init (&token_name
);
1380 if (streq (tagfile
, "-"))
1384 /* Switch redirected `stdout' to binary mode (setting `_fmode'
1385 doesn't take effect until after `stdout' is already open). */
1386 if (!isatty (fileno (stdout
)))
1387 setmode (fileno (stdout
), O_BINARY
);
1391 tagf
= fopen (tagfile
, append_to_tagfile
? "a" : "w");
1397 * Loop through files finding functions.
1399 for (i
= 0; i
< current_arg
; i
++)
1401 static language
*lang
; /* non-NULL if language is forced */
1404 switch (argbuffer
[i
].arg_type
)
1407 lang
= argbuffer
[i
].lang
;
1410 analyse_regex (argbuffer
[i
].what
);
1414 while ((this_file
= gfnames (argbuffer
[i
].what
, &got_err
)) != NULL
)
1418 error ("can't find file %s\n", this_file
);
1423 this_file
= massage_name (this_file
);
1426 this_file
= argbuffer
[i
].what
;
1428 /* Input file named "-" means read file names from stdin
1429 (one per line) and use them. */
1430 if (streq (this_file
, "-"))
1433 fatal ("cannot parse standard input AND read file names from it",
1435 while (readline_internal (&filename_lb
, stdin
) > 0)
1436 process_file_name (filename_lb
.buffer
, lang
);
1439 process_file_name (this_file
, lang
);
1445 this_file
= argbuffer
[i
].what
;
1446 process_file (stdin
, this_file
, lang
);
1453 free (filebuf
.buffer
);
1454 free (token_name
.buffer
);
1456 if (!CTAGS
|| cxref_style
)
1458 /* Write the remaining tags to tagf (ETAGS) or stdout (CXREF). */
1459 put_entries (nodehead
);
1460 free_tree (nodehead
);
1466 /* Output file entries that have no tags. */
1467 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1469 fprintf (tagf
, "\f\n%s,0\n", fdp
->taggedfname
);
1471 while (nincluded_files
-- > 0)
1472 fprintf (tagf
, "\f\n%s,include\n", *included_files
++);
1474 if (fclose (tagf
) == EOF
)
1478 exit (EXIT_SUCCESS
);
1484 for (i
= 0; i
< current_arg
; ++i
)
1486 switch (argbuffer
[i
].arg_type
)
1492 continue; /* the for loop */
1495 "mv %s OTAGS;fgrep -v '\t%s\t' OTAGS >%s;rm OTAGS",
1496 tagfile
, argbuffer
[i
].what
, tagfile
);
1497 if (system (cmd
) != EXIT_SUCCESS
)
1498 fatal ("failed to execute shell command", (char *)NULL
);
1500 append_to_tagfile
= TRUE
;
1503 tagf
= fopen (tagfile
, append_to_tagfile
? "a" : "w");
1506 put_entries (nodehead
); /* write all the tags (CTAGS) */
1507 free_tree (nodehead
);
1509 if (fclose (tagf
) == EOF
)
1513 if (append_to_tagfile
|| update
)
1515 char cmd
[2*BUFSIZ
+20];
1516 /* Maybe these should be used:
1517 setenv ("LC_COLLATE", "C", 1);
1518 setenv ("LC_ALL", "C", 1); */
1519 sprintf (cmd
, "sort -u -o %.*s %.*s", BUFSIZ
, tagfile
, BUFSIZ
, tagfile
);
1520 exit (system (cmd
));
1522 return EXIT_SUCCESS
;
1527 * Return a compressor given the file name. If EXTPTR is non-zero,
1528 * return a pointer into FILE where the compressor-specific
1529 * extension begins. If no compressor is found, NULL is returned
1530 * and EXTPTR is not significant.
1531 * Idea by Vladimir Alexiev <vladimir@cs.ualberta.ca> (1998)
1534 get_compressor_from_suffix (file
, extptr
)
1539 char *slash
, *suffix
;
1541 /* This relies on FN to be after canonicalize_filename,
1542 so we don't need to consider backslashes on DOS_NT. */
1543 slash
= etags_strrchr (file
, '/');
1544 suffix
= etags_strrchr (file
, '.');
1545 if (suffix
== NULL
|| suffix
< slash
)
1550 /* Let those poor souls who live with DOS 8+3 file name limits get
1551 some solace by treating foo.cgz as if it were foo.c.gz, etc.
1552 Only the first do loop is run if not MSDOS */
1555 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1556 if (streq (compr
->suffix
, suffix
))
1559 break; /* do it only once: not really a loop */
1562 } while (*suffix
!= '\0');
1569 * Return a language given the name.
1572 get_language_from_langname (name
)
1578 error ("empty language name", (char *)NULL
);
1581 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1582 if (streq (name
, lang
->name
))
1584 error ("unknown language \"%s\"", name
);
1592 * Return a language given the interpreter name.
1595 get_language_from_interpreter (interpreter
)
1601 if (interpreter
== NULL
)
1603 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1604 if (lang
->interpreters
!= NULL
)
1605 for (iname
= lang
->interpreters
; *iname
!= NULL
; iname
++)
1606 if (streq (*iname
, interpreter
))
1615 * Return a language given the file name.
1618 get_language_from_filename (file
, case_sensitive
)
1620 bool case_sensitive
;
1623 char **name
, **ext
, *suffix
;
1625 /* Try whole file name first. */
1626 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1627 if (lang
->filenames
!= NULL
)
1628 for (name
= lang
->filenames
; *name
!= NULL
; name
++)
1629 if ((case_sensitive
)
1630 ? streq (*name
, file
)
1631 : strcaseeq (*name
, file
))
1634 /* If not found, try suffix after last dot. */
1635 suffix
= etags_strrchr (file
, '.');
1639 for (lang
= lang_names
; lang
->name
!= NULL
; lang
++)
1640 if (lang
->suffixes
!= NULL
)
1641 for (ext
= lang
->suffixes
; *ext
!= NULL
; ext
++)
1642 if ((case_sensitive
)
1643 ? streq (*ext
, suffix
)
1644 : strcaseeq (*ext
, suffix
))
1651 * This routine is called on each file argument.
1654 process_file_name (file
, lang
)
1658 struct stat stat_buf
;
1662 char *compressed_name
, *uncompressed_name
;
1663 char *ext
, *real_name
;
1666 canonicalize_filename (file
);
1667 if (streq (file
, tagfile
) && !streq (tagfile
, "-"))
1669 error ("skipping inclusion of %s in self.", file
);
1672 if ((compr
= get_compressor_from_suffix (file
, &ext
)) == NULL
)
1674 compressed_name
= NULL
;
1675 real_name
= uncompressed_name
= savestr (file
);
1679 real_name
= compressed_name
= savestr (file
);
1680 uncompressed_name
= savenstr (file
, ext
- file
);
1683 /* If the canonicalized uncompressed name
1684 has already been dealt with, skip it silently. */
1685 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
1687 assert (fdp
->infname
!= NULL
);
1688 if (streq (uncompressed_name
, fdp
->infname
))
1692 if (stat (real_name
, &stat_buf
) != 0)
1694 /* Reset real_name and try with a different name. */
1696 if (compressed_name
!= NULL
) /* try with the given suffix */
1698 if (stat (uncompressed_name
, &stat_buf
) == 0)
1699 real_name
= uncompressed_name
;
1701 else /* try all possible suffixes */
1703 for (compr
= compressors
; compr
->suffix
!= NULL
; compr
++)
1705 compressed_name
= concat (file
, ".", compr
->suffix
);
1706 if (stat (compressed_name
, &stat_buf
) != 0)
1710 char *suf
= compressed_name
+ strlen (file
);
1711 size_t suflen
= strlen (compr
->suffix
) + 1;
1712 for ( ; suf
[1]; suf
++, suflen
--)
1714 memmove (suf
, suf
+ 1, suflen
);
1715 if (stat (compressed_name
, &stat_buf
) == 0)
1717 real_name
= compressed_name
;
1721 if (real_name
!= NULL
)
1724 free (compressed_name
);
1725 compressed_name
= NULL
;
1729 real_name
= compressed_name
;
1734 if (real_name
== NULL
)
1739 } /* try with a different name */
1741 if (!S_ISREG (stat_buf
.st_mode
))
1743 error ("skipping %s: it is not a regular file.", real_name
);
1746 if (real_name
== compressed_name
)
1748 char *cmd
= concat (compr
->command
, " ", real_name
);
1749 inf
= (FILE *) popen (cmd
, "r");
1753 inf
= fopen (real_name
, "r");
1760 process_file (inf
, uncompressed_name
, lang
);
1762 if (real_name
== compressed_name
)
1763 retval
= pclose (inf
);
1765 retval
= fclose (inf
);
1770 if (compressed_name
) free (compressed_name
);
1771 if (uncompressed_name
) free (uncompressed_name
);
1778 process_file (fh
, fn
, lang
)
1783 static const fdesc emptyfdesc
;
1786 /* Create a new input file description entry. */
1787 fdp
= xnew (1, fdesc
);
1790 fdp
->infname
= savestr (fn
);
1792 fdp
->infabsname
= absolute_filename (fn
, cwd
);
1793 fdp
->infabsdir
= absolute_dirname (fn
, cwd
);
1794 if (filename_is_absolute (fn
))
1796 /* An absolute file name. Canonicalize it. */
1797 fdp
->taggedfname
= absolute_filename (fn
, NULL
);
1801 /* A file name relative to cwd. Make it relative
1802 to the directory of the tags file. */
1803 fdp
->taggedfname
= relative_filename (fn
, tagfiledir
);
1805 fdp
->usecharno
= TRUE
; /* use char position when making tags */
1807 fdp
->written
= FALSE
; /* not written on tags file yet */
1810 curfdp
= fdhead
; /* the current file description */
1814 /* If not Ctags, and if this is not metasource and if it contained no #line
1815 directives, we can write the tags and free all nodes pointing to
1818 && curfdp
->usecharno
/* no #line directives in this file */
1819 && !curfdp
->lang
->metasource
)
1823 /* Look for the head of the sublist relative to this file. See add_node
1824 for the structure of the node tree. */
1826 for (np
= nodehead
; np
!= NULL
; prev
= np
, np
= np
->left
)
1827 if (np
->fdp
== curfdp
)
1830 /* If we generated tags for this file, write and delete them. */
1833 /* This is the head of the last sublist, if any. The following
1834 instructions depend on this being true. */
1835 assert (np
->left
== NULL
);
1837 assert (fdhead
== curfdp
);
1838 assert (last_node
->fdp
== curfdp
);
1839 put_entries (np
); /* write tags for file curfdp->taggedfname */
1840 free_tree (np
); /* remove the written nodes */
1842 nodehead
= NULL
; /* no nodes left */
1844 prev
->left
= NULL
; /* delete the pointer to the sublist */
1850 * This routine sets up the boolean pseudo-functions which work
1851 * by setting boolean flags dependent upon the corresponding character.
1852 * Every char which is NOT in that string is not a white char. Therefore,
1853 * all of the array "_wht" is set to FALSE, and then the elements
1854 * subscripted by the chars in "white" are set to TRUE. Thus "_wht"
1855 * of a char is TRUE if it is the string "white", else FALSE.
1863 for (i
= 0; i
< CHARS
; i
++)
1864 iswhite(i
) = notinname(i
) = begtoken(i
) = intoken(i
) = endtoken(i
) = FALSE
;
1865 for (sp
= white
; *sp
!= '\0'; sp
++) iswhite (*sp
) = TRUE
;
1866 for (sp
= nonam
; *sp
!= '\0'; sp
++) notinname (*sp
) = TRUE
;
1867 notinname('\0') = notinname('\n');
1868 for (sp
= begtk
; *sp
!= '\0'; sp
++) begtoken (*sp
) = TRUE
;
1869 begtoken('\0') = begtoken('\n');
1870 for (sp
= midtk
; *sp
!= '\0'; sp
++) intoken (*sp
) = TRUE
;
1871 intoken('\0') = intoken('\n');
1872 for (sp
= endtk
; *sp
!= '\0'; sp
++) endtoken (*sp
) = TRUE
;
1873 endtoken('\0') = endtoken('\n');
1877 * This routine opens the specified file and calls the function
1878 * which finds the function and type definitions.
1885 language
*lang
= curfdp
->lang
;
1886 Lang_function
*parser
= NULL
;
1888 /* If user specified a language, use it. */
1889 if (lang
!= NULL
&& lang
->function
!= NULL
)
1891 parser
= lang
->function
;
1894 /* Else try to guess the language given the file name. */
1897 lang
= get_language_from_filename (curfdp
->infname
, TRUE
);
1898 if (lang
!= NULL
&& lang
->function
!= NULL
)
1900 curfdp
->lang
= lang
;
1901 parser
= lang
->function
;
1905 /* Else look for sharp-bang as the first two characters. */
1907 && readline_internal (&lb
, inf
) > 0
1909 && lb
.buffer
[0] == '#'
1910 && lb
.buffer
[1] == '!')
1914 /* Set lp to point at the first char after the last slash in the
1915 line or, if no slashes, at the first nonblank. Then set cp to
1916 the first successive blank and terminate the string. */
1917 lp
= etags_strrchr (lb
.buffer
+2, '/');
1921 lp
= skip_spaces (lb
.buffer
+ 2);
1922 cp
= skip_non_spaces (lp
);
1925 if (strlen (lp
) > 0)
1927 lang
= get_language_from_interpreter (lp
);
1928 if (lang
!= NULL
&& lang
->function
!= NULL
)
1930 curfdp
->lang
= lang
;
1931 parser
= lang
->function
;
1936 /* We rewind here, even if inf may be a pipe. We fail if the
1937 length of the first line is longer than the pipe block size,
1938 which is unlikely. */
1941 /* Else try to guess the language given the case insensitive file name. */
1944 lang
= get_language_from_filename (curfdp
->infname
, FALSE
);
1945 if (lang
!= NULL
&& lang
->function
!= NULL
)
1947 curfdp
->lang
= lang
;
1948 parser
= lang
->function
;
1952 /* Else try Fortran or C. */
1955 node
*old_last_node
= last_node
;
1957 curfdp
->lang
= get_language_from_langname ("fortran");
1960 if (old_last_node
== last_node
)
1961 /* No Fortran entries found. Try C. */
1963 /* We do not tag if rewind fails.
1964 Only the file name will be recorded in the tags file. */
1966 curfdp
->lang
= get_language_from_langname (cplusplus
? "c++" : "c");
1972 if (!no_line_directive
1973 && curfdp
->lang
!= NULL
&& curfdp
->lang
->metasource
)
1974 /* It may be that this is a bingo.y file, and we already parsed a bingo.c
1975 file, or anyway we parsed a file that is automatically generated from
1976 this one. If this is the case, the bingo.c file contained #line
1977 directives that generated tags pointing to this file. Let's delete
1978 them all before parsing this file, which is the real source. */
1980 fdesc
**fdpp
= &fdhead
;
1981 while (*fdpp
!= NULL
)
1983 && streq ((*fdpp
)->taggedfname
, curfdp
->taggedfname
))
1984 /* We found one of those! We must delete both the file description
1985 and all tags referring to it. */
1987 fdesc
*badfdp
= *fdpp
;
1989 /* Delete the tags referring to badfdp->taggedfname
1990 that were obtained from badfdp->infname. */
1991 invalidate_nodes (badfdp
, &nodehead
);
1993 *fdpp
= badfdp
->next
; /* remove the bad description from the list */
1994 free_fdesc (badfdp
);
1997 fdpp
= &(*fdpp
)->next
; /* advance the list pointer */
2000 assert (parser
!= NULL
);
2002 /* Generic initialisations before reading from file. */
2003 linebuffer_setlen (&filebuf
, 0); /* reset the file buffer */
2005 /* Generic initialisations before parsing file with readline. */
2006 lineno
= 0; /* reset global line number */
2007 charno
= 0; /* reset global char number */
2008 linecharno
= 0; /* reset global char number of line start */
2012 regex_tag_multiline ();
2017 * Check whether an implicitly named tag should be created,
2018 * then call `pfnote'.
2019 * NAME is a string that is internally copied by this function.
2021 * TAGS format specification
2022 * Idea by Sam Kendall <kendall@mv.mv.com> (1997)
2023 * The following is explained in some more detail in etc/ETAGS.EBNF.
2025 * make_tag creates tags with "implicit tag names" (unnamed tags)
2026 * if the following are all true, assuming NONAM=" \f\t\n\r()=,;":
2027 * 1. NAME does not contain any of the characters in NONAM;
2028 * 2. LINESTART contains name as either a rightmost, or rightmost but
2029 * one character, substring;
2030 * 3. the character, if any, immediately before NAME in LINESTART must
2031 * be a character in NONAM;
2032 * 4. the character, if any, immediately after NAME in LINESTART must
2033 * also be a character in NONAM.
2035 * The implementation uses the notinname() macro, which recognises the
2036 * characters stored in the string `nonam'.
2037 * etags.el needs to use the same characters that are in NONAM.
2040 make_tag (name
, namelen
, is_func
, linestart
, linelen
, lno
, cno
)
2041 char *name
; /* tag name, or NULL if unnamed */
2042 int namelen
; /* tag length */
2043 bool is_func
; /* tag is a function */
2044 char *linestart
; /* start of the line where tag is */
2045 int linelen
; /* length of the line where tag is */
2046 int lno
; /* line number */
2047 long cno
; /* character number */
2049 bool named
= (name
!= NULL
&& namelen
> 0);
2051 if (!CTAGS
&& named
) /* maybe set named to false */
2052 /* Let's try to make an implicit tag name, that is, create an unnamed tag
2053 such that etags.el can guess a name from it. */
2056 register char *cp
= name
;
2058 for (i
= 0; i
< namelen
; i
++)
2059 if (notinname (*cp
++))
2061 if (i
== namelen
) /* rule #1 */
2063 cp
= linestart
+ linelen
- namelen
;
2064 if (notinname (linestart
[linelen
-1]))
2065 cp
-= 1; /* rule #4 */
2066 if (cp
>= linestart
/* rule #2 */
2068 || notinname (cp
[-1])) /* rule #3 */
2069 && strneq (name
, cp
, namelen
)) /* rule #2 */
2070 named
= FALSE
; /* use implicit tag name */
2075 name
= savenstr (name
, namelen
);
2078 pfnote (name
, is_func
, linestart
, linelen
, lno
, cno
);
2083 pfnote (name
, is_func
, linestart
, linelen
, lno
, cno
)
2084 char *name
; /* tag name, or NULL if unnamed */
2085 bool is_func
; /* tag is a function */
2086 char *linestart
; /* start of the line where tag is */
2087 int linelen
; /* length of the line where tag is */
2088 int lno
; /* line number */
2089 long cno
; /* character number */
2093 assert (name
== NULL
|| name
[0] != '\0');
2094 if (CTAGS
&& name
== NULL
)
2097 np
= xnew (1, node
);
2099 /* If ctags mode, change name "main" to M<thisfilename>. */
2100 if (CTAGS
&& !cxref_style
&& streq (name
, "main"))
2102 register char *fp
= etags_strrchr (curfdp
->taggedfname
, '/');
2103 np
->name
= concat ("M", fp
== NULL
? curfdp
->taggedfname
: fp
+ 1, "");
2104 fp
= etags_strrchr (np
->name
, '.');
2105 if (fp
!= NULL
&& fp
[1] != '\0' && fp
[2] == '\0')
2111 np
->been_warned
= FALSE
;
2113 np
->is_func
= is_func
;
2115 if (np
->fdp
->usecharno
)
2116 /* Our char numbers are 0-base, because of C language tradition?
2117 ctags compatibility? old versions compatibility? I don't know.
2118 Anyway, since emacs's are 1-base we expect etags.el to take care
2119 of the difference. If we wanted to have 1-based numbers, we would
2120 uncomment the +1 below. */
2121 np
->cno
= cno
/* + 1 */ ;
2123 np
->cno
= invalidcharno
;
2124 np
->left
= np
->right
= NULL
;
2125 if (CTAGS
&& !cxref_style
)
2127 if (strlen (linestart
) < 50)
2128 np
->regex
= concat (linestart
, "$", "");
2130 np
->regex
= savenstr (linestart
, 50);
2133 np
->regex
= savenstr (linestart
, linelen
);
2135 add_node (np
, &nodehead
);
2140 * recurse on left children, iterate on right children.
2148 register node
*node_right
= np
->right
;
2149 free_tree (np
->left
);
2150 if (np
->name
!= NULL
)
2160 * delete a file description
2164 register fdesc
*fdp
;
2166 if (fdp
->infname
!= NULL
) free (fdp
->infname
);
2167 if (fdp
->infabsname
!= NULL
) free (fdp
->infabsname
);
2168 if (fdp
->infabsdir
!= NULL
) free (fdp
->infabsdir
);
2169 if (fdp
->taggedfname
!= NULL
) free (fdp
->taggedfname
);
2170 if (fdp
->prop
!= NULL
) free (fdp
->prop
);
2176 * Adds a node to the tree of nodes. In etags mode, sort by file
2177 * name. In ctags mode, sort by tag name. Make no attempt at
2180 * add_node is the only function allowed to add nodes, so it can
2184 add_node (np
, cur_node_p
)
2185 node
*np
, **cur_node_p
;
2188 register node
*cur_node
= *cur_node_p
;
2190 if (cur_node
== NULL
)
2200 /* For each file name, tags are in a linked sublist on the right
2201 pointer. The first tags of different files are a linked list
2202 on the left pointer. last_node points to the end of the last
2204 if (last_node
!= NULL
&& last_node
->fdp
== np
->fdp
)
2206 /* Let's use the same sublist as the last added node. */
2207 assert (last_node
->right
== NULL
);
2208 last_node
->right
= np
;
2211 else if (cur_node
->fdp
== np
->fdp
)
2213 /* Scanning the list we found the head of a sublist which is
2214 good for us. Let's scan this sublist. */
2215 add_node (np
, &cur_node
->right
);
2218 /* The head of this sublist is not good for us. Let's try the
2220 add_node (np
, &cur_node
->left
);
2221 } /* if ETAGS mode */
2226 dif
= strcmp (np
->name
, cur_node
->name
);
2229 * If this tag name matches an existing one, then
2230 * do not add the node, but maybe print a warning.
2232 if (no_duplicates
&& !dif
)
2234 if (np
->fdp
== cur_node
->fdp
)
2238 fprintf (stderr
, "Duplicate entry in file %s, line %d: %s\n",
2239 np
->fdp
->infname
, lineno
, np
->name
);
2240 fprintf (stderr
, "Second entry ignored\n");
2243 else if (!cur_node
->been_warned
&& !no_warnings
)
2247 "Duplicate entry in files %s and %s: %s (Warning only)\n",
2248 np
->fdp
->infname
, cur_node
->fdp
->infname
, np
->name
);
2249 cur_node
->been_warned
= TRUE
;
2254 /* Actually add the node */
2255 add_node (np
, dif
< 0 ? &cur_node
->left
: &cur_node
->right
);
2256 } /* if CTAGS mode */
2260 * invalidate_nodes ()
2261 * Scan the node tree and invalidate all nodes pointing to the
2262 * given file description (CTAGS case) or free them (ETAGS case).
2265 invalidate_nodes (badfdp
, npp
)
2276 if (np
->left
!= NULL
)
2277 invalidate_nodes (badfdp
, &np
->left
);
2278 if (np
->fdp
== badfdp
)
2280 if (np
->right
!= NULL
)
2281 invalidate_nodes (badfdp
, &np
->right
);
2285 assert (np
->fdp
!= NULL
);
2286 if (np
->fdp
== badfdp
)
2288 *npp
= np
->left
; /* detach the sublist from the list */
2289 np
->left
= NULL
; /* isolate it */
2290 free_tree (np
); /* free it */
2291 invalidate_nodes (badfdp
, npp
);
2294 invalidate_nodes (badfdp
, &np
->left
);
2299 static int total_size_of_entries
__P((node
*));
2300 static int number_len
__P((long));
2302 /* Length of a non-negative number's decimal representation. */
2308 while ((num
/= 10) > 0)
2314 * Return total number of characters that put_entries will output for
2315 * the nodes in the linked list at the right of the specified node.
2316 * This count is irrelevant with etags.el since emacs 19.34 at least,
2317 * but is still supplied for backward compatibility.
2320 total_size_of_entries (np
)
2323 register int total
= 0;
2325 for (; np
!= NULL
; np
= np
->right
)
2328 total
+= strlen (np
->regex
) + 1; /* pat\177 */
2329 if (np
->name
!= NULL
)
2330 total
+= strlen (np
->name
) + 1; /* name\001 */
2331 total
+= number_len ((long) np
->lno
) + 1; /* lno, */
2332 if (np
->cno
!= invalidcharno
) /* cno */
2333 total
+= number_len (np
->cno
);
2334 total
+= 1; /* newline */
2345 static fdesc
*fdp
= NULL
;
2350 /* Output subentries that precede this one */
2352 put_entries (np
->left
);
2354 /* Output this entry */
2363 fprintf (tagf
, "\f\n%s,%d\n",
2364 fdp
->taggedfname
, total_size_of_entries (np
));
2365 fdp
->written
= TRUE
;
2367 fputs (np
->regex
, tagf
);
2368 fputc ('\177', tagf
);
2369 if (np
->name
!= NULL
)
2371 fputs (np
->name
, tagf
);
2372 fputc ('\001', tagf
);
2374 fprintf (tagf
, "%d,", np
->lno
);
2375 if (np
->cno
!= invalidcharno
)
2376 fprintf (tagf
, "%ld", np
->cno
);
2382 if (np
->name
== NULL
)
2383 error ("internal error: NULL name in ctags mode.", (char *)NULL
);
2388 fprintf (stdout
, "%s %s %d\n",
2389 np
->name
, np
->fdp
->taggedfname
, (np
->lno
+ 63) / 64);
2391 fprintf (stdout
, "%-16s %3d %-16s %s\n",
2392 np
->name
, np
->lno
, np
->fdp
->taggedfname
, np
->regex
);
2396 fprintf (tagf
, "%s\t%s\t", np
->name
, np
->fdp
->taggedfname
);
2399 { /* function or #define macro with args */
2400 putc (searchar
, tagf
);
2403 for (sp
= np
->regex
; *sp
; sp
++)
2405 if (*sp
== '\\' || *sp
== searchar
)
2409 putc (searchar
, tagf
);
2412 { /* anything else; text pattern inadequate */
2413 fprintf (tagf
, "%d", np
->lno
);
2418 } /* if this node contains a valid tag */
2420 /* Output subentries that follow this one */
2421 put_entries (np
->right
);
2423 put_entries (np
->left
);
2428 #define C_EXT 0x00fff /* C extensions */
2429 #define C_PLAIN 0x00000 /* C */
2430 #define C_PLPL 0x00001 /* C++ */
2431 #define C_STAR 0x00003 /* C* */
2432 #define C_JAVA 0x00005 /* JAVA */
2433 #define C_AUTO 0x01000 /* C, but switch to C++ if `class' is met */
2434 #define YACC 0x10000 /* yacc file */
2437 * The C symbol tables.
2442 st_C_objprot
, st_C_objimpl
, st_C_objend
,
2444 st_C_ignore
, st_C_attribute
,
2447 st_C_class
, st_C_template
,
2448 st_C_struct
, st_C_extern
, st_C_enum
, st_C_define
, st_C_typedef
2451 static unsigned int hash
__P((const char *, unsigned int));
2452 static struct C_stab_entry
* in_word_set
__P((const char *, unsigned int));
2453 static enum sym_type C_symtype
__P((char *, int, int));
2455 /* Feed stuff between (but not including) %[ and %] lines to:
2461 struct C_stab_entry { char *name; int c_ext; enum sym_type type; }
2465 while, 0, st_C_ignore
2466 switch, 0, st_C_ignore
2467 return, 0, st_C_ignore
2468 __attribute__, 0, st_C_attribute
2469 @interface, 0, st_C_objprot
2470 @protocol, 0, st_C_objprot
2471 @implementation,0, st_C_objimpl
2472 @end, 0, st_C_objend
2473 import, (C_JAVA & ~C_PLPL), st_C_ignore
2474 package, (C_JAVA & ~C_PLPL), st_C_ignore
2475 friend, C_PLPL, st_C_ignore
2476 extends, (C_JAVA & ~C_PLPL), st_C_javastruct
2477 implements, (C_JAVA & ~C_PLPL), st_C_javastruct
2478 interface, (C_JAVA & ~C_PLPL), st_C_struct
2479 class, 0, st_C_class
2480 namespace, C_PLPL, st_C_struct
2481 domain, C_STAR, st_C_struct
2482 union, 0, st_C_struct
2483 struct, 0, st_C_struct
2484 extern, 0, st_C_extern
2486 typedef, 0, st_C_typedef
2487 define, 0, st_C_define
2488 undef, 0, st_C_define
2489 operator, C_PLPL, st_C_operator
2490 template, 0, st_C_template
2491 # DEFUN used in emacs, the next three used in glibc (SYSCALL only for mach).
2492 DEFUN, 0, st_C_gnumacro
2493 SYSCALL, 0, st_C_gnumacro
2494 ENTRY, 0, st_C_gnumacro
2495 PSEUDO, 0, st_C_gnumacro
2496 # These are defined inside C functions, so currently they are not met.
2497 # EXFUN used in glibc, DEFVAR_* in emacs.
2498 #EXFUN, 0, st_C_gnumacro
2499 #DEFVAR_, 0, st_C_gnumacro
2501 and replace lines between %< and %> with its output, then:
2502 - remove the #if characterset check
2503 - make in_word_set static and not inline. */
2505 /* C code produced by gperf version 3.0.1 */
2506 /* Command-line: gperf -m 5 */
2507 /* Computed positions: -k'2-3' */
2509 struct C_stab_entry
{ char *name
; int c_ext
; enum sym_type type
; };
2510 /* maximum key range = 33, duplicates = 0 */
2521 register const char *str
;
2522 register unsigned int len
;
2524 static unsigned char asso_values
[] =
2526 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2527 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2528 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
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, 15,
2533 14, 35, 35, 35, 35, 35, 35, 35, 14, 35,
2534 35, 35, 35, 12, 13, 35, 35, 35, 35, 12,
2535 35, 35, 35, 35, 35, 1, 35, 16, 35, 6,
2536 23, 0, 0, 35, 22, 0, 35, 35, 5, 0,
2537 0, 15, 1, 35, 6, 35, 8, 19, 35, 16,
2538 4, 5, 35, 35, 35, 35, 35, 35, 35, 35,
2539 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2540 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
2541 35, 35, 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
2553 register int hval
= len
;
2558 hval
+= asso_values
[(unsigned char)str
[2]];
2561 hval
+= asso_values
[(unsigned char)str
[1]];
2567 static struct C_stab_entry
*
2568 in_word_set (str
, len
)
2569 register const char *str
;
2570 register unsigned int len
;
2574 TOTAL_KEYWORDS
= 32,
2575 MIN_WORD_LENGTH
= 2,
2576 MAX_WORD_LENGTH
= 15,
2581 static struct C_stab_entry wordlist
[] =
2584 {"if", 0, st_C_ignore
},
2586 {"@end", 0, st_C_objend
},
2587 {"union", 0, st_C_struct
},
2588 {"define", 0, st_C_define
},
2589 {"import", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2590 {"template", 0, st_C_template
},
2591 {"operator", C_PLPL
, st_C_operator
},
2592 {"@interface", 0, st_C_objprot
},
2593 {"implements", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2594 {"friend", C_PLPL
, st_C_ignore
},
2595 {"typedef", 0, st_C_typedef
},
2596 {"return", 0, st_C_ignore
},
2597 {"@implementation",0, st_C_objimpl
},
2598 {"@protocol", 0, st_C_objprot
},
2599 {"interface", (C_JAVA
& ~C_PLPL
), st_C_struct
},
2600 {"extern", 0, st_C_extern
},
2601 {"extends", (C_JAVA
& ~C_PLPL
), st_C_javastruct
},
2602 {"struct", 0, st_C_struct
},
2603 {"domain", C_STAR
, st_C_struct
},
2604 {"switch", 0, st_C_ignore
},
2605 {"enum", 0, st_C_enum
},
2606 {"for", 0, st_C_ignore
},
2607 {"namespace", C_PLPL
, st_C_struct
},
2608 {"class", 0, st_C_class
},
2609 {"while", 0, st_C_ignore
},
2610 {"undef", 0, st_C_define
},
2611 {"package", (C_JAVA
& ~C_PLPL
), st_C_ignore
},
2612 {"__attribute__", 0, st_C_attribute
},
2613 {"SYSCALL", 0, st_C_gnumacro
},
2614 {"ENTRY", 0, st_C_gnumacro
},
2615 {"PSEUDO", 0, st_C_gnumacro
},
2616 {"DEFUN", 0, st_C_gnumacro
}
2619 if (len
<= MAX_WORD_LENGTH
&& len
>= MIN_WORD_LENGTH
)
2621 register int key
= hash (str
, len
);
2623 if (key
<= MAX_HASH_VALUE
&& key
>= 0)
2625 register const char *s
= wordlist
[key
].name
;
2627 if (*str
== *s
&& !strncmp (str
+ 1, s
+ 1, len
- 1) && s
[len
] == '\0')
2628 return &wordlist
[key
];
2635 static enum sym_type
2636 C_symtype (str
, len
, c_ext
)
2641 register struct C_stab_entry
*se
= in_word_set (str
, len
);
2643 if (se
== NULL
|| (se
->c_ext
&& !(c_ext
& se
->c_ext
)))
2650 * Ignoring __attribute__ ((list))
2652 static bool inattribute
; /* looking at an __attribute__ construct */
2655 * C functions and variables are recognized using a simple
2656 * finite automaton. fvdef is its state variable.
2660 fvnone
, /* nothing seen */
2661 fdefunkey
, /* Emacs DEFUN keyword seen */
2662 fdefunname
, /* Emacs DEFUN name seen */
2663 foperator
, /* func: operator keyword seen (cplpl) */
2664 fvnameseen
, /* function or variable name seen */
2665 fstartlist
, /* func: just after open parenthesis */
2666 finlist
, /* func: in parameter list */
2667 flistseen
, /* func: after parameter list */
2668 fignore
, /* func: before open brace */
2669 vignore
/* var-like: ignore until ';' */
2672 static bool fvextern
; /* func or var: extern keyword seen; */
2675 * typedefs are recognized using a simple finite automaton.
2676 * typdef is its state variable.
2680 tnone
, /* nothing seen */
2681 tkeyseen
, /* typedef keyword seen */
2682 ttypeseen
, /* defined type seen */
2683 tinbody
, /* inside typedef body */
2684 tend
, /* just before typedef tag */
2685 tignore
/* junk after typedef tag */
2689 * struct-like structures (enum, struct and union) are recognized
2690 * using another simple finite automaton. `structdef' is its state
2695 snone
, /* nothing seen yet,
2696 or in struct body if bracelev > 0 */
2697 skeyseen
, /* struct-like keyword seen */
2698 stagseen
, /* struct-like tag seen */
2699 scolonseen
/* colon seen after struct-like tag */
2703 * When objdef is different from onone, objtag is the name of the class.
2705 static char *objtag
= "<uninited>";
2708 * Yet another little state machine to deal with preprocessor lines.
2712 dnone
, /* nothing seen */
2713 dsharpseen
, /* '#' seen as first char on line */
2714 ddefineseen
, /* '#' and 'define' seen */
2715 dignorerest
/* ignore rest of line */
2719 * State machine for Objective C protocols and implementations.
2720 * Idea by Tom R.Hageman <tom@basil.icce.rug.nl> (1995)
2724 onone
, /* nothing seen */
2725 oprotocol
, /* @interface or @protocol seen */
2726 oimplementation
, /* @implementations seen */
2727 otagseen
, /* class name seen */
2728 oparenseen
, /* parenthesis before category seen */
2729 ocatseen
, /* category name seen */
2730 oinbody
, /* in @implementation body */
2731 omethodsign
, /* in @implementation body, after +/- */
2732 omethodtag
, /* after method name */
2733 omethodcolon
, /* after method colon */
2734 omethodparm
, /* after method parameter */
2735 oignore
/* wait for @end */
2740 * Use this structure to keep info about the token read, and how it
2741 * should be tagged. Used by the make_C_tag function to build a tag.
2745 char *line
; /* string containing the token */
2746 int offset
; /* where the token starts in LINE */
2747 int length
; /* token length */
2749 The previous members can be used to pass strings around for generic
2750 purposes. The following ones specifically refer to creating tags. In this
2751 case the token contained here is the pattern that will be used to create a
2754 bool valid
; /* do not create a tag; the token should be
2755 invalidated whenever a state machine is
2756 reset prematurely */
2757 bool named
; /* create a named tag */
2758 int lineno
; /* source line number of tag */
2759 long linepos
; /* source char number of tag */
2760 } token
; /* latest token read */
2763 * Variables and functions for dealing with nested structures.
2764 * Idea by Mykola Dzyuba <mdzyuba@yahoo.com> (2001)
2766 static void pushclass_above
__P((int, char *, int));
2767 static void popclass_above
__P((int));
2768 static void write_classname
__P((linebuffer
*, char *qualifier
));
2771 char **cname
; /* nested class names */
2772 int *bracelev
; /* nested class brace level */
2773 int nl
; /* class nesting level (elements used) */
2774 int size
; /* length of the array */
2775 } cstack
; /* stack for nested declaration tags */
2776 /* Current struct nesting depth (namespace, class, struct, union, enum). */
2777 #define nestlev (cstack.nl)
2778 /* After struct keyword or in struct body, not inside a nested function. */
2779 #define instruct (structdef == snone && nestlev > 0 \
2780 && bracelev == cstack.bracelev[nestlev-1] + 1)
2783 pushclass_above (bracelev
, str
, len
)
2790 popclass_above (bracelev
);
2792 if (nl
>= cstack
.size
)
2794 int size
= cstack
.size
*= 2;
2795 xrnew (cstack
.cname
, size
, char *);
2796 xrnew (cstack
.bracelev
, size
, int);
2798 assert (nl
== 0 || cstack
.bracelev
[nl
-1] < bracelev
);
2799 cstack
.cname
[nl
] = (str
== NULL
) ? NULL
: savenstr (str
, len
);
2800 cstack
.bracelev
[nl
] = bracelev
;
2805 popclass_above (bracelev
)
2810 for (nl
= cstack
.nl
- 1;
2811 nl
>= 0 && cstack
.bracelev
[nl
] >= bracelev
;
2814 if (cstack
.cname
[nl
] != NULL
)
2815 free (cstack
.cname
[nl
]);
2821 write_classname (cn
, qualifier
)
2826 int qlen
= strlen (qualifier
);
2828 if (cstack
.nl
== 0 || cstack
.cname
[0] == NULL
)
2832 cn
->buffer
[0] = '\0';
2836 len
= strlen (cstack
.cname
[0]);
2837 linebuffer_setlen (cn
, len
);
2838 strcpy (cn
->buffer
, cstack
.cname
[0]);
2840 for (i
= 1; i
< cstack
.nl
; i
++)
2845 s
= cstack
.cname
[i
];
2850 linebuffer_setlen (cn
, len
);
2851 strncat (cn
->buffer
, qualifier
, qlen
);
2852 strncat (cn
->buffer
, s
, slen
);
2857 static bool consider_token
__P((char *, int, int, int *, int, int, bool *));
2858 static void make_C_tag
__P((bool));
2862 * checks to see if the current token is at the start of a
2863 * function or variable, or corresponds to a typedef, or
2864 * is a struct/union/enum tag, or #define, or an enum constant.
2866 * *IS_FUNC gets TRUE iff the token is a function or #define macro
2867 * with args. C_EXTP points to which language we are looking at.
2878 consider_token (str
, len
, c
, c_extp
, bracelev
, parlev
, is_func_or_var
)
2879 register char *str
; /* IN: token pointer */
2880 register int len
; /* IN: token length */
2881 register int c
; /* IN: first char after the token */
2882 int *c_extp
; /* IN, OUT: C extensions mask */
2883 int bracelev
; /* IN: brace level */
2884 int parlev
; /* IN: parenthesis level */
2885 bool *is_func_or_var
; /* OUT: function or variable found */
2887 /* When structdef is stagseen, scolonseen, or snone with bracelev > 0,
2888 structtype is the type of the preceding struct-like keyword, and
2889 structbracelev is the brace level where it has been seen. */
2890 static enum sym_type structtype
;
2891 static int structbracelev
;
2892 static enum sym_type toktype
;
2895 toktype
= C_symtype (str
, len
, *c_extp
);
2898 * Skip __attribute__
2900 if (toktype
== st_C_attribute
)
2907 * Advance the definedef state machine.
2912 /* We're not on a preprocessor line. */
2913 if (toktype
== st_C_gnumacro
)
2920 if (toktype
== st_C_define
)
2922 definedef
= ddefineseen
;
2926 definedef
= dignorerest
;
2931 * Make a tag for any macro, unless it is a constant
2932 * and constantypedefs is FALSE.
2934 definedef
= dignorerest
;
2935 *is_func_or_var
= (c
== '(');
2936 if (!*is_func_or_var
&& !constantypedefs
)
2943 error ("internal error: definedef value.", (char *)NULL
);
2952 if (toktype
== st_C_typedef
)
2972 if (structdef
== snone
&& fvdef
== fvnone
)
2990 * This structdef business is NOT invoked when we are ctags and the
2991 * file is plain C. This is because a struct tag may have the same
2992 * name as another tag, and this loses with ctags.
2996 case st_C_javastruct
:
2997 if (structdef
== stagseen
)
2998 structdef
= scolonseen
;
3002 if ((*c_extp
& C_AUTO
) /* automatic detection of C++ language */
3004 && definedef
== dnone
&& structdef
== snone
3005 && typdef
== tnone
&& fvdef
== fvnone
)
3006 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
3007 if (toktype
== st_C_template
)
3014 && (typdef
== tkeyseen
3015 || (typedefs_or_cplusplus
&& structdef
== snone
)))
3017 structdef
= skeyseen
;
3018 structtype
= toktype
;
3019 structbracelev
= bracelev
;
3020 if (fvdef
== fvnameseen
)
3026 if (structdef
== skeyseen
)
3028 structdef
= stagseen
;
3032 if (typdef
!= tnone
)
3035 /* Detect Objective C constructs. */
3045 objdef
= oimplementation
;
3049 case oimplementation
:
3050 /* Save the class tag for functions or variables defined inside. */
3051 objtag
= savenstr (str
, len
);
3055 /* Save the class tag for categories. */
3056 objtag
= savenstr (str
, len
);
3058 *is_func_or_var
= TRUE
;
3062 *is_func_or_var
= TRUE
;
3070 objdef
= omethodtag
;
3071 linebuffer_setlen (&token_name
, len
);
3072 strncpy (token_name
.buffer
, str
, len
);
3073 token_name
.buffer
[len
] = '\0';
3079 objdef
= omethodparm
;
3085 objdef
= omethodtag
;
3086 linebuffer_setlen (&token_name
, token_name
.len
+ len
);
3087 strncat (token_name
.buffer
, str
, len
);
3092 if (toktype
== st_C_objend
)
3094 /* Memory leakage here: the string pointed by objtag is
3095 never released, because many tests would be needed to
3096 avoid breaking on incorrect input code. The amount of
3097 memory leaked here is the sum of the lengths of the
3105 /* A function, variable or enum constant? */
3127 *is_func_or_var
= TRUE
;
3131 && structdef
== snone
3132 && structtype
== st_C_enum
&& bracelev
> structbracelev
)
3133 return TRUE
; /* enum constant */
3139 fvdef
= fdefunname
; /* GNU macro */
3140 *is_func_or_var
= TRUE
;
3148 if ((strneq (str
, "asm", 3) && endtoken (str
[3]))
3149 || (strneq (str
, "__asm__", 7) && endtoken (str
[7])))
3158 if (len
>= 10 && strneq (str
+len
-10, "::operator", 10))
3160 if (*c_extp
& C_AUTO
) /* automatic detection of C++ */
3161 *c_extp
= (*c_extp
| C_PLPL
) & ~C_AUTO
;
3163 *is_func_or_var
= TRUE
;
3166 if (bracelev
> 0 && !instruct
)
3168 fvdef
= fvnameseen
; /* function or variable */
3169 *is_func_or_var
= TRUE
;
3180 * C_entries often keeps pointers to tokens or lines which are older than
3181 * the line currently read. By keeping two line buffers, and switching
3182 * them at end of line, it is possible to use those pointers.
3190 #define current_lb_is_new (newndx == curndx)
3191 #define switch_line_buffers() (curndx = 1 - curndx)
3193 #define curlb (lbs[curndx].lb)
3194 #define newlb (lbs[newndx].lb)
3195 #define curlinepos (lbs[curndx].linepos)
3196 #define newlinepos (lbs[newndx].linepos)
3198 #define plainc ((c_ext & C_EXT) == C_PLAIN)
3199 #define cplpl (c_ext & C_PLPL)
3200 #define cjava ((c_ext & C_JAVA) == C_JAVA)
3202 #define CNL_SAVE_DEFINEDEF() \
3204 curlinepos = charno; \
3205 readline (&curlb, inf); \
3206 lp = curlb.buffer; \
3213 CNL_SAVE_DEFINEDEF(); \
3214 if (savetoken.valid) \
3216 token = savetoken; \
3217 savetoken.valid = FALSE; \
3219 definedef = dnone; \
3227 /* This function is never called when token.valid is FALSE, but
3228 we must protect against invalid input or internal errors. */
3229 if (!DEBUG
&& !token
.valid
)
3233 make_tag (token_name
.buffer
, token_name
.len
, isfun
, token
.line
,
3234 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3235 else /* this case is optimised away if !DEBUG */
3236 make_tag (concat ("INVALID TOKEN:-->", token_name
.buffer
, ""),
3237 token_name
.len
+ 17, isfun
, token
.line
,
3238 token
.offset
+token
.length
+1, token
.lineno
, token
.linepos
);
3240 token
.valid
= FALSE
;
3246 * This routine finds functions, variables, typedefs,
3247 * #define's, enum constants and struct/union/enum definitions in
3248 * C syntax and adds them to the list.
3251 C_entries (c_ext
, inf
)
3252 int c_ext
; /* extension of C */
3253 FILE *inf
; /* input file */
3255 register char c
; /* latest char read; '\0' for end of line */
3256 register char *lp
; /* pointer one beyond the character `c' */
3257 int curndx
, newndx
; /* indices for current and new lb */
3258 register int tokoff
; /* offset in line of start of current token */
3259 register int toklen
; /* length of current token */
3260 char *qualifier
; /* string used to qualify names */
3261 int qlen
; /* length of qualifier */
3262 int bracelev
; /* current brace level */
3263 int bracketlev
; /* current bracket level */
3264 int parlev
; /* current parenthesis level */
3265 int attrparlev
; /* __attribute__ parenthesis level */
3266 int templatelev
; /* current template level */
3267 int typdefbracelev
; /* bracelev where a typedef struct body begun */
3268 bool incomm
, inquote
, inchar
, quotednl
, midtoken
;
3269 bool yacc_rules
; /* in the rules part of a yacc file */
3270 struct tok savetoken
= {0}; /* token saved during preprocessor handling */
3273 linebuffer_init (&lbs
[0].lb
);
3274 linebuffer_init (&lbs
[1].lb
);
3275 if (cstack
.size
== 0)
3277 cstack
.size
= (DEBUG
) ? 1 : 4;
3279 cstack
.cname
= xnew (cstack
.size
, char *);
3280 cstack
.bracelev
= xnew (cstack
.size
, int);
3283 tokoff
= toklen
= typdefbracelev
= 0; /* keep compiler quiet */
3284 curndx
= newndx
= 0;
3288 fvdef
= fvnone
; fvextern
= FALSE
; typdef
= tnone
;
3289 structdef
= snone
; definedef
= dnone
; objdef
= onone
;
3291 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
3292 token
.valid
= savetoken
.valid
= FALSE
;
3293 bracelev
= bracketlev
= parlev
= attrparlev
= templatelev
= 0;
3295 { qualifier
= "."; qlen
= 1; }
3297 { qualifier
= "::"; qlen
= 2; }
3305 /* If we are at the end of the line, the next character is a
3306 '\0'; do not skip it, because it is what tells us
3307 to read the next line. */
3328 /* Newlines inside comments do not end macro definitions in
3330 CNL_SAVE_DEFINEDEF ();
3343 /* Newlines inside strings do not end macro definitions
3344 in traditional cpp, even though compilers don't
3345 usually accept them. */
3346 CNL_SAVE_DEFINEDEF ();
3356 /* Hmmm, something went wrong. */
3365 else if (bracketlev
> 0)
3370 if (--bracketlev
> 0)
3374 CNL_SAVE_DEFINEDEF ();
3402 if (fvdef
!= finlist
&& fvdef
!= fignore
&& fvdef
!=vignore
)
3415 else if (/* cplpl && */ *lp
== '/')
3421 if ((c_ext
& YACC
) && *lp
== '%')
3423 /* Entering or exiting rules section in yacc file. */
3425 definedef
= dnone
; fvdef
= fvnone
; fvextern
= FALSE
;
3426 typdef
= tnone
; structdef
= snone
;
3427 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
3429 yacc_rules
= !yacc_rules
;
3435 if (definedef
== dnone
)
3438 bool cpptoken
= TRUE
;
3440 /* Look back on this line. If all blanks, or nonblanks
3441 followed by an end of comment, this is a preprocessor
3443 for (cp
= newlb
.buffer
; cp
< lp
-1; cp
++)
3446 if (*cp
== '*' && *(cp
+1) == '/')
3455 definedef
= dsharpseen
;
3456 } /* if (definedef == dnone) */
3464 /* Consider token only if some involved conditions are satisfied. */
3465 if (typdef
!= tignore
3466 && definedef
!= dignorerest
3469 && (definedef
!= dnone
3470 || structdef
!= scolonseen
)
3477 if (c
== ':' && *lp
== ':' && begtoken (lp
[1]))
3478 /* This handles :: in the middle,
3479 but not at the beginning of an identifier.
3480 Also, space-separated :: is not recognised. */
3482 if (c_ext
& C_AUTO
) /* automatic detection of C++ */
3483 c_ext
= (c_ext
| C_PLPL
) & ~C_AUTO
;
3487 goto still_in_token
;
3491 bool funorvar
= FALSE
;
3494 || consider_token (newlb
.buffer
+ tokoff
, toklen
, c
,
3495 &c_ext
, bracelev
, parlev
,
3498 if (fvdef
== foperator
)
3501 lp
= skip_spaces (lp
-1);
3505 && !iswhite (*lp
) && *lp
!= '(')
3508 toklen
+= lp
- oldlp
;
3510 token
.named
= FALSE
;
3512 && nestlev
> 0 && definedef
== dnone
)
3513 /* in struct body */
3515 write_classname (&token_name
, qualifier
);
3516 linebuffer_setlen (&token_name
,
3517 token_name
.len
+qlen
+toklen
);
3518 strcat (token_name
.buffer
, qualifier
);
3519 strncat (token_name
.buffer
,
3520 newlb
.buffer
+ tokoff
, toklen
);
3523 else if (objdef
== ocatseen
)
3524 /* Objective C category */
3526 int len
= strlen (objtag
) + 2 + toklen
;
3527 linebuffer_setlen (&token_name
, len
);
3528 strcpy (token_name
.buffer
, objtag
);
3529 strcat (token_name
.buffer
, "(");
3530 strncat (token_name
.buffer
,
3531 newlb
.buffer
+ tokoff
, toklen
);
3532 strcat (token_name
.buffer
, ")");
3535 else if (objdef
== omethodtag
3536 || objdef
== omethodparm
)
3537 /* Objective C method */
3541 else if (fvdef
== fdefunname
)
3542 /* GNU DEFUN and similar macros */
3544 bool defun
= (newlb
.buffer
[tokoff
] == 'F');
3548 /* Rewrite the tag so that emacs lisp DEFUNs
3549 can be found by their elisp name */
3555 linebuffer_setlen (&token_name
, len
);
3556 strncpy (token_name
.buffer
,
3557 newlb
.buffer
+ off
, len
);
3558 token_name
.buffer
[len
] = '\0';
3561 if (token_name
.buffer
[len
] == '_')
3562 token_name
.buffer
[len
] = '-';
3563 token
.named
= defun
;
3567 linebuffer_setlen (&token_name
, toklen
);
3568 strncpy (token_name
.buffer
,
3569 newlb
.buffer
+ tokoff
, toklen
);
3570 token_name
.buffer
[toklen
] = '\0';
3571 /* Name macros and members. */
3572 token
.named
= (structdef
== stagseen
3573 || typdef
== ttypeseen
3576 && definedef
== dignorerest
)
3578 && definedef
== dnone
3579 && structdef
== snone
3582 token
.lineno
= lineno
;
3583 token
.offset
= tokoff
;
3584 token
.length
= toklen
;
3585 token
.line
= newlb
.buffer
;
3586 token
.linepos
= newlinepos
;
3589 if (definedef
== dnone
3590 && (fvdef
== fvnameseen
3591 || fvdef
== foperator
3592 || structdef
== stagseen
3594 || typdef
== ttypeseen
3595 || objdef
!= onone
))
3597 if (current_lb_is_new
)
3598 switch_line_buffers ();
3600 else if (definedef
!= dnone
3601 || fvdef
== fdefunname
3603 make_C_tag (funorvar
);
3605 else /* not yacc and consider_token failed */
3607 if (inattribute
&& fvdef
== fignore
)
3609 /* We have just met __attribute__ after a
3610 function parameter list: do not tag the
3617 } /* if (endtoken (c)) */
3618 else if (intoken (c
))
3624 } /* if (midtoken) */
3625 else if (begtoken (c
))
3633 /* This prevents tagging fb in
3634 void (__attribute__((noreturn)) *fb) (void);
3635 Fixing this is not easy and not very important. */
3639 if (plainc
|| declarations
)
3641 make_C_tag (TRUE
); /* a function */
3646 if (structdef
== stagseen
&& !cjava
)
3648 popclass_above (bracelev
);
3656 if (!yacc_rules
|| lp
== newlb
.buffer
+ 1)
3658 tokoff
= lp
- 1 - newlb
.buffer
;
3663 } /* if (begtoken) */
3664 } /* if must look at token */
3667 /* Detect end of line, colon, comma, semicolon and various braces
3668 after having handled a token.*/
3674 if (yacc_rules
&& token
.offset
== 0 && token
.valid
)
3676 make_C_tag (FALSE
); /* a yacc function */
3679 if (definedef
!= dnone
)
3685 make_C_tag (TRUE
); /* an Objective C class */
3689 objdef
= omethodcolon
;
3690 linebuffer_setlen (&token_name
, token_name
.len
+ 1);
3691 strcat (token_name
.buffer
, ":");
3694 if (structdef
== stagseen
)
3696 structdef
= scolonseen
;
3699 /* Should be useless, but may be work as a safety net. */
3700 if (cplpl
&& fvdef
== flistseen
)
3702 make_C_tag (TRUE
); /* a function */
3708 if (definedef
!= dnone
|| inattribute
)
3714 make_C_tag (FALSE
); /* a typedef */
3724 if (typdef
== tignore
|| cplpl
)
3728 if ((globals
&& bracelev
== 0 && (!fvextern
|| declarations
))
3729 || (members
&& instruct
))
3730 make_C_tag (FALSE
); /* a variable */
3733 token
.valid
= FALSE
;
3737 && (cplpl
|| !instruct
)
3738 && (typdef
== tnone
|| (typdef
!= tignore
&& instruct
)))
3740 && plainc
&& instruct
))
3741 make_C_tag (TRUE
); /* a function */
3747 && cplpl
&& structdef
== stagseen
)
3748 make_C_tag (FALSE
); /* forward declaration */
3750 token
.valid
= FALSE
;
3751 } /* switch (fvdef) */
3757 if (structdef
== stagseen
)
3761 if (definedef
!= dnone
|| inattribute
)
3767 make_C_tag (TRUE
); /* an Objective C method */
3788 && (!fvextern
|| declarations
))
3789 || (members
&& instruct
)))
3790 make_C_tag (FALSE
); /* a variable */
3793 if ((declarations
&& typdef
== tnone
&& !instruct
)
3794 || (members
&& typdef
!= tignore
&& instruct
))
3796 make_C_tag (TRUE
); /* a function */
3799 else if (!declarations
)
3801 token
.valid
= FALSE
;
3806 if (structdef
== stagseen
)
3810 if (definedef
!= dnone
|| inattribute
)
3812 if (structdef
== stagseen
)
3819 make_C_tag (FALSE
); /* a typedef */
3831 if ((members
&& bracelev
== 1)
3832 || (globals
&& bracelev
== 0
3833 && (!fvextern
|| declarations
)))
3834 make_C_tag (FALSE
); /* a variable */
3848 if (definedef
!= dnone
)
3850 if (objdef
== otagseen
&& parlev
== 0)
3851 objdef
= oparenseen
;
3855 if (typdef
== ttypeseen
3859 /* This handles constructs like:
3860 typedef void OperatorFun (int fun); */
3879 if (--attrparlev
== 0)
3880 inattribute
= FALSE
;
3883 if (definedef
!= dnone
)
3885 if (objdef
== ocatseen
&& parlev
== 1)
3887 make_C_tag (TRUE
); /* an Objective C category */
3901 || typdef
== ttypeseen
))
3904 make_C_tag (FALSE
); /* a typedef */
3907 else if (parlev
< 0) /* can happen due to ill-conceived #if's. */
3911 if (definedef
!= dnone
)
3913 if (typdef
== ttypeseen
)
3915 /* Whenever typdef is set to tinbody (currently only
3916 here), typdefbracelev should be set to bracelev. */
3918 typdefbracelev
= bracelev
;
3923 make_C_tag (TRUE
); /* a function */
3932 make_C_tag (TRUE
); /* an Objective C class */
3937 make_C_tag (TRUE
); /* an Objective C method */
3941 /* Neutralize `extern "C" {' grot. */
3942 if (bracelev
== 0 && structdef
== snone
&& nestlev
== 0
3950 case skeyseen
: /* unnamed struct */
3951 pushclass_above (bracelev
, NULL
, 0);
3954 case stagseen
: /* named struct or enum */
3955 case scolonseen
: /* a class */
3956 pushclass_above (bracelev
,token
.line
+token
.offset
, token
.length
);
3958 make_C_tag (FALSE
); /* a struct or enum */
3964 if (definedef
!= dnone
)
3966 if (fvdef
== fstartlist
)
3968 fvdef
= fvnone
; /* avoid tagging `foo' in `foo (*bar()) ()' */
3969 token
.valid
= FALSE
;
3973 if (definedef
!= dnone
)
3975 if (!ignoreindent
&& lp
== newlb
.buffer
+ 1)
3978 token
.valid
= FALSE
;
3979 bracelev
= 0; /* reset brace level if first column */
3980 parlev
= 0; /* also reset paren level, just in case... */
3982 else if (bracelev
> 0)
3985 token
.valid
= FALSE
; /* something gone amiss, token unreliable */
3986 popclass_above (bracelev
);
3988 /* Only if typdef == tinbody is typdefbracelev significant. */
3989 if (typdef
== tinbody
&& bracelev
<= typdefbracelev
)
3991 assert (bracelev
== typdefbracelev
);
3996 if (definedef
!= dnone
)
4006 if ((members
&& bracelev
== 1)
4007 || (globals
&& bracelev
== 0 && (!fvextern
|| declarations
)))
4008 make_C_tag (FALSE
); /* a variable */
4016 && (structdef
== stagseen
|| fvdef
== fvnameseen
))
4023 if (templatelev
> 0)
4031 if (objdef
== oinbody
&& bracelev
== 0)
4033 objdef
= omethodsign
;
4038 case '#': case '~': case '&': case '%': case '/':
4039 case '|': case '^': case '!': case '.': case '?':
4040 if (definedef
!= dnone
)
4042 /* These surely cannot follow a function tag in C. */
4055 if (objdef
== otagseen
)
4057 make_C_tag (TRUE
); /* an Objective C class */
4060 /* If a macro spans multiple lines don't reset its state. */
4062 CNL_SAVE_DEFINEDEF ();
4068 } /* while not eof */
4070 free (lbs
[0].lb
.buffer
);
4071 free (lbs
[1].lb
.buffer
);
4075 * Process either a C++ file or a C file depending on the setting
4079 default_C_entries (inf
)
4082 C_entries (cplusplus
? C_PLPL
: C_AUTO
, inf
);
4085 /* Always do plain C. */
4087 plain_C_entries (inf
)
4093 /* Always do C++. */
4095 Cplusplus_entries (inf
)
4098 C_entries (C_PLPL
, inf
);
4101 /* Always do Java. */
4106 C_entries (C_JAVA
, inf
);
4114 C_entries (C_STAR
, inf
);
4117 /* Always do Yacc. */
4122 C_entries (YACC
, inf
);
4126 /* Useful macros. */
4127 #define LOOP_ON_INPUT_LINES(file_pointer, line_buffer, char_pointer) \
4128 for (; /* loop initialization */ \
4129 !feof (file_pointer) /* loop test */ \
4130 && /* instructions at start of loop */ \
4131 (readline (&line_buffer, file_pointer), \
4132 char_pointer = line_buffer.buffer, \
4136 #define LOOKING_AT(cp, kw) /* kw is the keyword, a literal string */ \
4137 ((assert("" kw), TRUE) /* syntax error if not a literal string */ \
4138 && strneq ((cp), kw, sizeof(kw)-1) /* cp points at kw */ \
4139 && notinname ((cp)[sizeof(kw)-1]) /* end of kw */ \
4140 && ((cp) = skip_spaces((cp)+sizeof(kw)-1))) /* skip spaces */
4142 /* Similar to LOOKING_AT but does not use notinname, does not skip */
4143 #define LOOKING_AT_NOCASE(cp, kw) /* the keyword is a literal string */ \
4144 ((assert("" kw), TRUE) /* syntax error if not a literal string */ \
4145 && strncaseeq ((cp), kw, sizeof(kw)-1) /* cp points at kw */ \
4146 && ((cp) += sizeof(kw)-1)) /* skip spaces */
4149 * Read a file, but do no processing. This is used to do regexp
4150 * matching on files that have no language defined.
4153 just_read_file (inf
)
4156 register char *dummy
;
4158 LOOP_ON_INPUT_LINES (inf
, lb
, dummy
)
4163 /* Fortran parsing */
4165 static void F_takeprec
__P((void));
4166 static void F_getit
__P((FILE *));
4171 dbp
= skip_spaces (dbp
);
4175 dbp
= skip_spaces (dbp
);
4176 if (strneq (dbp
, "(*)", 3))
4181 if (!ISDIGIT (*dbp
))
4183 --dbp
; /* force failure */
4188 while (ISDIGIT (*dbp
));
4197 dbp
= skip_spaces (dbp
);
4200 readline (&lb
, inf
);
4205 dbp
= skip_spaces (dbp
);
4207 if (!ISALPHA (*dbp
) && *dbp
!= '_' && *dbp
!= '$')
4209 for (cp
= dbp
+ 1; *cp
!= '\0' && intoken (*cp
); cp
++)
4211 make_tag (dbp
, cp
-dbp
, TRUE
,
4212 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4217 Fortran_functions (inf
)
4220 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4223 dbp
++; /* Ratfor escape to fortran */
4224 dbp
= skip_spaces (dbp
);
4227 switch (lowcase (*dbp
))
4230 if (nocase_tail ("integer"))
4234 if (nocase_tail ("real"))
4238 if (nocase_tail ("logical"))
4242 if (nocase_tail ("complex") || nocase_tail ("character"))
4246 if (nocase_tail ("double"))
4248 dbp
= skip_spaces (dbp
);
4251 if (nocase_tail ("precision"))
4257 dbp
= skip_spaces (dbp
);
4260 switch (lowcase (*dbp
))
4263 if (nocase_tail ("function"))
4267 if (nocase_tail ("subroutine"))
4271 if (nocase_tail ("entry"))
4275 if (nocase_tail ("blockdata") || nocase_tail ("block data"))
4277 dbp
= skip_spaces (dbp
);
4278 if (*dbp
== '\0') /* assume un-named */
4279 make_tag ("blockdata", 9, TRUE
,
4280 lb
.buffer
, dbp
- lb
.buffer
, lineno
, linecharno
);
4282 F_getit (inf
); /* look for name */
4293 * Philippe Waroquiers (1998)
4296 static void Ada_getit
__P((FILE *, char *));
4298 /* Once we are positioned after an "interesting" keyword, let's get
4299 the real tag value necessary. */
4301 Ada_getit (inf
, name_qualifier
)
4303 char *name_qualifier
;
4311 dbp
= skip_spaces (dbp
);
4313 || (dbp
[0] == '-' && dbp
[1] == '-'))
4315 readline (&lb
, inf
);
4318 switch (lowcase(*dbp
))
4321 if (nocase_tail ("body"))
4323 /* Skipping body of procedure body or package body or ....
4324 resetting qualifier to body instead of spec. */
4325 name_qualifier
= "/b";
4330 /* Skipping type of task type or protected type ... */
4331 if (nocase_tail ("type"))
4338 for (cp
= dbp
; *cp
!= '\0' && *cp
!= '"'; cp
++)
4343 dbp
= skip_spaces (dbp
);
4346 && (ISALPHA (*cp
) || ISDIGIT (*cp
) || *cp
== '_' || *cp
== '.'));
4354 name
= concat (dbp
, name_qualifier
, "");
4356 make_tag (name
, strlen (name
), TRUE
,
4357 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4369 bool inquote
= FALSE
;
4370 bool skip_till_semicolumn
= FALSE
;
4372 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4374 while (*dbp
!= '\0')
4376 /* Skip a string i.e. "abcd". */
4377 if (inquote
|| (*dbp
== '"'))
4379 dbp
= etags_strchr ((inquote
) ? dbp
: dbp
+1, '"');
4384 continue; /* advance char */
4389 break; /* advance line */
4393 /* Skip comments. */
4394 if (dbp
[0] == '-' && dbp
[1] == '-')
4395 break; /* advance line */
4397 /* Skip character enclosed in single quote i.e. 'a'
4398 and skip single quote starting an attribute i.e. 'Image. */
4407 if (skip_till_semicolumn
)
4410 skip_till_semicolumn
= FALSE
;
4412 continue; /* advance char */
4415 /* Search for beginning of a token. */
4416 if (!begtoken (*dbp
))
4419 continue; /* advance char */
4422 /* We are at the beginning of a token. */
4423 switch (lowcase(*dbp
))
4426 if (!packages_only
&& nocase_tail ("function"))
4427 Ada_getit (inf
, "/f");
4429 break; /* from switch */
4430 continue; /* advance char */
4432 if (!packages_only
&& nocase_tail ("procedure"))
4433 Ada_getit (inf
, "/p");
4434 else if (nocase_tail ("package"))
4435 Ada_getit (inf
, "/s");
4436 else if (nocase_tail ("protected")) /* protected type */
4437 Ada_getit (inf
, "/t");
4439 break; /* from switch */
4440 continue; /* advance char */
4443 if (typedefs
&& !packages_only
&& nocase_tail ("use"))
4445 /* when tagging types, avoid tagging use type Pack.Typename;
4446 for this, we will skip everything till a ; */
4447 skip_till_semicolumn
= TRUE
;
4448 continue; /* advance char */
4452 if (!packages_only
&& nocase_tail ("task"))
4453 Ada_getit (inf
, "/k");
4454 else if (typedefs
&& !packages_only
&& nocase_tail ("type"))
4456 Ada_getit (inf
, "/t");
4457 while (*dbp
!= '\0')
4461 break; /* from switch */
4462 continue; /* advance char */
4465 /* Look for the end of the token. */
4466 while (!endtoken (*dbp
))
4469 } /* advance char */
4470 } /* advance line */
4475 * Unix and microcontroller assembly tag handling
4476 * Labels: /^[a-zA-Z_.$][a-zA_Z0-9_.$]*[: ^I^J]/
4477 * Idea by Bob Weiner, Motorola Inc. (1994)
4485 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4487 /* If first char is alphabetic or one of [_.$], test for colon
4488 following identifier. */
4489 if (ISALPHA (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4491 /* Read past label. */
4493 while (ISALNUM (*cp
) || *cp
== '_' || *cp
== '.' || *cp
== '$')
4495 if (*cp
== ':' || iswhite (*cp
))
4496 /* Found end of label, so copy it and add it to the table. */
4497 make_tag (lb
.buffer
, cp
- lb
.buffer
, TRUE
,
4498 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4506 * Perl sub names: /^sub[ \t\n]+[^ \t\n{]+/
4507 * Perl variable names: /^(my|local).../
4508 * Original code by Bart Robinson <lomew@cs.utah.edu> (1995)
4509 * Additions by Michael Ernst <mernst@alum.mit.edu> (1997)
4510 * Ideas by Kai Großjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE> (2001)
4513 Perl_functions (inf
)
4516 char *package
= savestr ("main"); /* current package name */
4519 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4523 if (LOOKING_AT (cp
, "package"))
4526 get_tag (cp
, &package
);
4528 else if (LOOKING_AT (cp
, "sub"))
4533 while (!notinname (*cp
))
4536 continue; /* nothing found */
4537 if ((pos
= etags_strchr (sp
, ':')) != NULL
4538 && pos
< cp
&& pos
[1] == ':')
4539 /* The name is already qualified. */
4540 make_tag (sp
, cp
- sp
, TRUE
,
4541 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4545 char savechar
, *name
;
4549 name
= concat (package
, "::", sp
);
4551 make_tag (name
, strlen(name
), TRUE
,
4552 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4556 else if (globals
) /* only if we are tagging global vars */
4558 /* Skip a qualifier, if any. */
4559 bool qual
= LOOKING_AT (cp
, "my") || LOOKING_AT (cp
, "local");
4560 /* After "my" or "local", but before any following paren or space. */
4561 char *varstart
= cp
;
4563 if (qual
/* should this be removed? If yes, how? */
4564 && (*cp
== '$' || *cp
== '@' || *cp
== '%'))
4569 while (ISALNUM (*cp
) || *cp
== '_');
4573 /* Should be examining a variable list at this point;
4574 could insist on seeing an open parenthesis. */
4575 while (*cp
!= '\0' && *cp
!= ';' && *cp
!= '=' && *cp
!= ')')
4581 make_tag (varstart
, cp
- varstart
, FALSE
,
4582 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4591 * Look for /^[\t]*def[ \t\n]+[^ \t\n(:]+/ or /^class[ \t\n]+[^ \t\n(:]+/
4592 * Idea by Eric S. Raymond <esr@thyrsus.com> (1997)
4593 * More ideas by seb bacon <seb@jamkit.com> (2002)
4596 Python_functions (inf
)
4601 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4603 cp
= skip_spaces (cp
);
4604 if (LOOKING_AT (cp
, "def") || LOOKING_AT (cp
, "class"))
4607 while (!notinname (*cp
) && *cp
!= ':')
4609 make_tag (name
, cp
- name
, TRUE
,
4610 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4619 * - /^[ \t]*function[ \t\n]+[^ \t\n(]+/
4620 * - /^[ \t]*class[ \t\n]+[^ \t\n]+/
4621 * - /^[ \t]*define\(\"[^\"]+/
4622 * Only with --members:
4623 * - /^[ \t]*var[ \t\n]+\$[^ \t\n=;]/
4624 * Idea by Diez B. Roggisch (2001)
4630 register char *cp
, *name
;
4631 bool search_identifier
= FALSE
;
4633 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
4635 cp
= skip_spaces (cp
);
4637 if (search_identifier
4640 while (!notinname (*cp
))
4642 make_tag (name
, cp
- name
, TRUE
,
4643 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4644 search_identifier
= FALSE
;
4646 else if (LOOKING_AT (cp
, "function"))
4649 cp
= skip_spaces (cp
+1);
4653 while (!notinname (*cp
))
4655 make_tag (name
, cp
- name
, TRUE
,
4656 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4659 search_identifier
= TRUE
;
4661 else if (LOOKING_AT (cp
, "class"))
4666 while (*cp
!= '\0' && !iswhite (*cp
))
4668 make_tag (name
, cp
- name
, FALSE
,
4669 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4672 search_identifier
= TRUE
;
4674 else if (strneq (cp
, "define", 6)
4675 && (cp
= skip_spaces (cp
+6))
4677 && (*cp
== '"' || *cp
== '\''))
4681 while (*cp
!= quote
&& *cp
!= '\0')
4683 make_tag (name
, cp
- name
, FALSE
,
4684 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4687 && LOOKING_AT (cp
, "var")
4691 while (!notinname(*cp
))
4693 make_tag (name
, cp
- name
, FALSE
,
4694 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
4701 * Cobol tag functions
4702 * We could look for anything that could be a paragraph name.
4703 * i.e. anything that starts in column 8 is one word and ends in a full stop.
4704 * Idea by Corny de Souza (1993)
4707 Cobol_paragraphs (inf
)
4710 register char *bp
, *ep
;
4712 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4718 /* If eoln, compiler option or comment ignore whole line. */
4719 if (bp
[-1] != ' ' || !ISALNUM (bp
[0]))
4722 for (ep
= bp
; ISALNUM (*ep
) || *ep
== '-'; ep
++)
4725 make_tag (bp
, ep
- bp
, TRUE
,
4726 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
4733 * Ideas by Assar Westerlund <assar@sics.se> (2001)
4736 Makefile_targets (inf
)
4741 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
4743 if (*bp
== '\t' || *bp
== '#')
4745 while (*bp
!= '\0' && *bp
!= '=' && *bp
!= ':')
4747 if (*bp
== ':' || (globals
&& *bp
== '='))
4749 /* We should detect if there is more than one tag, but we do not.
4750 We just skip initial and final spaces. */
4751 char * namestart
= skip_spaces (lb
.buffer
);
4752 while (--bp
> namestart
)
4753 if (!notinname (*bp
))
4755 make_tag (namestart
, bp
- namestart
+ 1, TRUE
,
4756 lb
.buffer
, bp
- lb
.buffer
+ 2, lineno
, linecharno
);
4764 * Original code by Mosur K. Mohan (1989)
4766 * Locates tags for procedures & functions. Doesn't do any type- or
4767 * var-definitions. It does look for the keyword "extern" or
4768 * "forward" immediately following the procedure statement; if found,
4769 * the tag is skipped.
4772 Pascal_functions (inf
)
4775 linebuffer tline
; /* mostly copied from C_entries */
4777 int save_lineno
, namelen
, taglen
;
4780 bool /* each of these flags is TRUE iff: */
4781 incomment
, /* point is inside a comment */
4782 inquote
, /* point is inside '..' string */
4783 get_tagname
, /* point is after PROCEDURE/FUNCTION
4784 keyword, so next item = potential tag */
4785 found_tag
, /* point is after a potential tag */
4786 inparms
, /* point is within parameter-list */
4787 verify_tag
; /* point has passed the parm-list, so the
4788 next token will determine whether this
4789 is a FORWARD/EXTERN to be ignored, or
4790 whether it is a real tag */
4792 save_lcno
= save_lineno
= namelen
= taglen
= 0; /* keep compiler quiet */
4793 name
= NULL
; /* keep compiler quiet */
4796 linebuffer_init (&tline
);
4798 incomment
= inquote
= FALSE
;
4799 found_tag
= FALSE
; /* have a proc name; check if extern */
4800 get_tagname
= FALSE
; /* found "procedure" keyword */
4801 inparms
= FALSE
; /* found '(' after "proc" */
4802 verify_tag
= FALSE
; /* check if "extern" is ahead */
4805 while (!feof (inf
)) /* long main loop to get next char */
4808 if (c
== '\0') /* if end of line */
4810 readline (&lb
, inf
);
4814 if (!((found_tag
&& verify_tag
)
4816 c
= *dbp
++; /* only if don't need *dbp pointing
4817 to the beginning of the name of
4818 the procedure or function */
4822 if (c
== '}') /* within { } comments */
4824 else if (c
== '*' && *dbp
== ')') /* within (* *) comments */
4841 inquote
= TRUE
; /* found first quote */
4843 case '{': /* found open { comment */
4847 if (*dbp
== '*') /* found open (* comment */
4852 else if (found_tag
) /* found '(' after tag, i.e., parm-list */
4855 case ')': /* end of parms list */
4860 if (found_tag
&& !inparms
) /* end of proc or fn stmt */
4867 if (found_tag
&& verify_tag
&& (*dbp
!= ' '))
4869 /* Check if this is an "extern" declaration. */
4872 if (lowcase (*dbp
== 'e'))
4874 if (nocase_tail ("extern")) /* superfluous, really! */
4880 else if (lowcase (*dbp
) == 'f')
4882 if (nocase_tail ("forward")) /* check for forward reference */
4888 if (found_tag
&& verify_tag
) /* not external proc, so make tag */
4892 make_tag (name
, namelen
, TRUE
,
4893 tline
.buffer
, taglen
, save_lineno
, save_lcno
);
4897 if (get_tagname
) /* grab name of proc or fn */
4904 /* Find block name. */
4905 for (cp
= dbp
+ 1; *cp
!= '\0' && !endtoken (*cp
); cp
++)
4908 /* Save all values for later tagging. */
4909 linebuffer_setlen (&tline
, lb
.len
);
4910 strcpy (tline
.buffer
, lb
.buffer
);
4911 save_lineno
= lineno
;
4912 save_lcno
= linecharno
;
4913 name
= tline
.buffer
+ (dbp
- lb
.buffer
);
4915 taglen
= cp
- lb
.buffer
+ 1;
4917 dbp
= cp
; /* set dbp to e-o-token */
4918 get_tagname
= FALSE
;
4922 /* And proceed to check for "extern". */
4924 else if (!incomment
&& !inquote
&& !found_tag
)
4926 /* Check for proc/fn keywords. */
4927 switch (lowcase (c
))
4930 if (nocase_tail ("rocedure")) /* c = 'p', dbp has advanced */
4934 if (nocase_tail ("unction"))
4939 } /* while not eof */
4941 free (tline
.buffer
);
4946 * Lisp tag functions
4947 * look for (def or (DEF, quote or QUOTE
4950 static void L_getit
__P((void));
4955 if (*dbp
== '\'') /* Skip prefix quote */
4957 else if (*dbp
== '(')
4960 /* Try to skip "(quote " */
4961 if (!LOOKING_AT (dbp
, "quote") && !LOOKING_AT (dbp
, "QUOTE"))
4962 /* Ok, then skip "(" before name in (defstruct (foo)) */
4963 dbp
= skip_spaces (dbp
);
4965 get_tag (dbp
, NULL
);
4969 Lisp_functions (inf
)
4972 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
4977 if (strneq (dbp
+1, "def", 3) || strneq (dbp
+1, "DEF", 3))
4979 dbp
= skip_non_spaces (dbp
);
4980 dbp
= skip_spaces (dbp
);
4985 /* Check for (foo::defmumble name-defined ... */
4988 while (!notinname (*dbp
) && *dbp
!= ':');
4993 while (*dbp
== ':');
4995 if (strneq (dbp
, "def", 3) || strneq (dbp
, "DEF", 3))
4997 dbp
= skip_non_spaces (dbp
);
4998 dbp
= skip_spaces (dbp
);
5008 * Lua script language parsing
5009 * Original code by David A. Capello <dacap@users.sourceforge.net> (2004)
5011 * "function" and "local function" are tags if they start at column 1.
5019 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5021 if (bp
[0] != 'f' && bp
[0] != 'l')
5024 (void)LOOKING_AT (bp
, "local"); /* skip possible "local" */
5026 if (LOOKING_AT (bp
, "function"))
5034 * Just look for lines where the first character is '/'
5035 * Also look at "defineps" for PSWrap
5037 * Richard Mlynarik <mly@adoc.xerox.com> (1997)
5038 * Masatake Yamato <masata-y@is.aist-nara.ac.jp> (1999)
5044 register char *bp
, *ep
;
5046 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5051 *ep
!= '\0' && *ep
!= ' ' && *ep
!= '{';
5054 make_tag (bp
, ep
- bp
, TRUE
,
5055 lb
.buffer
, ep
- lb
.buffer
+ 1, lineno
, linecharno
);
5057 else if (LOOKING_AT (bp
, "defineps"))
5065 * Ignore anything after \ followed by space or in ( )
5066 * Look for words defined by :
5067 * Look for constant, code, create, defer, value, and variable
5068 * OBP extensions: Look for buffer:, field,
5069 * Ideas by Eduardo Horvath <eeh@netbsd.org> (2004)
5077 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5078 while ((bp
= skip_spaces (bp
))[0] != '\0')
5079 if (bp
[0] == '\\' && iswhite(bp
[1]))
5080 break; /* read next line */
5081 else if (bp
[0] == '(' && iswhite(bp
[1]))
5082 do /* skip to ) or eol */
5084 while (*bp
!= ')' && *bp
!= '\0');
5085 else if ((bp
[0] == ':' && iswhite(bp
[1]) && bp
++)
5086 || LOOKING_AT_NOCASE (bp
, "constant")
5087 || LOOKING_AT_NOCASE (bp
, "code")
5088 || LOOKING_AT_NOCASE (bp
, "create")
5089 || LOOKING_AT_NOCASE (bp
, "defer")
5090 || LOOKING_AT_NOCASE (bp
, "value")
5091 || LOOKING_AT_NOCASE (bp
, "variable")
5092 || LOOKING_AT_NOCASE (bp
, "buffer:")
5093 || LOOKING_AT_NOCASE (bp
, "field"))
5094 get_tag (skip_spaces (bp
), NULL
); /* Yay! A definition! */
5096 bp
= skip_non_spaces (bp
);
5101 * Scheme tag functions
5102 * look for (def... xyzzy
5104 * (def ... ((...(xyzzy ....
5106 * Original code by Ken Haase (1985?)
5109 Scheme_functions (inf
)
5114 LOOP_ON_INPUT_LINES (inf
, lb
, bp
)
5116 if (strneq (bp
, "(def", 4) || strneq (bp
, "(DEF", 4))
5118 bp
= skip_non_spaces (bp
+4);
5119 /* Skip over open parens and white space */
5120 while (notinname (*bp
))
5124 if (LOOKING_AT (bp
, "(SET!") || LOOKING_AT (bp
, "(set!"))
5130 /* Find tags in TeX and LaTeX input files. */
5132 /* TEX_toktab is a table of TeX control sequences that define tags.
5133 * Each entry records one such control sequence.
5135 * Original code from who knows whom.
5137 * Stefan Monnier (2002)
5140 static linebuffer
*TEX_toktab
= NULL
; /* Table with tag tokens */
5142 /* Default set of control sequences to put into TEX_toktab.
5143 The value of environment var TEXTAGS is prepended to this. */
5144 static char *TEX_defenv
= "\
5145 :chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem\
5146 :part:appendix:entry:index:def\
5147 :newcommand:renewcommand:newenvironment:renewenvironment";
5149 static void TEX_mode
__P((FILE *));
5150 static void TEX_decode_env
__P((char *, char *));
5152 static char TEX_esc
= '\\';
5153 static char TEX_opgrp
= '{';
5154 static char TEX_clgrp
= '}';
5157 * TeX/LaTeX scanning loop.
5166 /* Select either \ or ! as escape character. */
5169 /* Initialize token table once from environment. */
5170 if (TEX_toktab
== NULL
)
5171 TEX_decode_env ("TEXTAGS", TEX_defenv
);
5173 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5175 /* Look at each TEX keyword in line. */
5178 /* Look for a TEX escape. */
5179 while (*cp
++ != TEX_esc
)
5180 if (cp
[-1] == '\0' || cp
[-1] == '%')
5183 for (key
= TEX_toktab
; key
->buffer
!= NULL
; key
++)
5184 if (strneq (cp
, key
->buffer
, key
->len
))
5187 int namelen
, linelen
;
5190 cp
= skip_spaces (cp
+ key
->len
);
5191 if (*cp
== TEX_opgrp
)
5197 (!iswhite (*p
) && *p
!= '#' &&
5198 *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
);
5203 if (!opgrp
|| *p
== TEX_clgrp
)
5205 while (*p
!= '\0' && *p
!= TEX_opgrp
&& *p
!= TEX_clgrp
)
5207 linelen
= p
- lb
.buffer
+ 1;
5209 make_tag (cp
, namelen
, TRUE
,
5210 lb
.buffer
, linelen
, lineno
, linecharno
);
5211 goto tex_next_line
; /* We only tag a line once */
5219 #define TEX_LESC '\\'
5220 #define TEX_SESC '!'
5222 /* Figure out whether TeX's escapechar is '\\' or '!' and set grouping
5223 chars accordingly. */
5230 while ((c
= getc (inf
)) != EOF
)
5232 /* Skip to next line if we hit the TeX comment char. */
5234 while (c
!= '\n' && c
!= EOF
)
5236 else if (c
== TEX_LESC
|| c
== TEX_SESC
)
5252 /* If the input file is compressed, inf is a pipe, and rewind may fail.
5253 No attempt is made to correct the situation. */
5257 /* Read environment and prepend it to the default string.
5258 Build token table. */
5260 TEX_decode_env (evarname
, defenv
)
5264 register char *env
, *p
;
5267 /* Append default string to environment. */
5268 env
= getenv (evarname
);
5274 env
= concat (oldenv
, defenv
, "");
5277 /* Allocate a token table */
5278 for (len
= 1, p
= env
; p
;)
5279 if ((p
= etags_strchr (p
, ':')) && *++p
!= '\0')
5281 TEX_toktab
= xnew (len
, linebuffer
);
5283 /* Unpack environment string into token table. Be careful about */
5284 /* zero-length strings (leading ':', "::" and trailing ':') */
5285 for (i
= 0; *env
!= '\0';)
5287 p
= etags_strchr (env
, ':');
5288 if (!p
) /* End of environment string. */
5289 p
= env
+ strlen (env
);
5291 { /* Only non-zero strings. */
5292 TEX_toktab
[i
].buffer
= savenstr (env
, p
- env
);
5293 TEX_toktab
[i
].len
= p
- env
;
5300 TEX_toktab
[i
].buffer
= NULL
; /* Mark end of table. */
5301 TEX_toktab
[i
].len
= 0;
5308 /* Texinfo support. Dave Love, Mar. 2000. */
5314 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5315 if (LOOKING_AT (cp
, "@node"))
5318 while (*cp
!= '\0' && *cp
!= ',')
5320 make_tag (start
, cp
- start
, TRUE
,
5321 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
5328 * Contents of <title>, <h1>, <h2>, <h3> are tags.
5329 * Contents of <a name=xxx> are tags with name xxx.
5331 * Francesco Potortì, 2002.
5337 bool getnext
= FALSE
; /* next text outside of HTML tags is a tag */
5338 bool skiptag
= FALSE
; /* skip to the end of the current HTML tag */
5339 bool intag
= FALSE
; /* inside an html tag, looking for ID= */
5340 bool inanchor
= FALSE
; /* when INTAG, is an anchor, look for NAME= */
5344 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5346 LOOP_ON_INPUT_LINES (inf
, lb
, dbp
)
5347 for (;;) /* loop on the same line */
5349 if (skiptag
) /* skip HTML tag */
5351 while (*dbp
!= '\0' && *dbp
!= '>')
5357 continue; /* look on the same line */
5359 break; /* go to next line */
5362 else if (intag
) /* look for "name=" or "id=" */
5364 while (*dbp
!= '\0' && *dbp
!= '>'
5365 && lowcase (*dbp
) != 'n' && lowcase (*dbp
) != 'i')
5368 break; /* go to next line */
5373 continue; /* look on the same line */
5375 if ((inanchor
&& LOOKING_AT_NOCASE (dbp
, "name="))
5376 || LOOKING_AT_NOCASE (dbp
, "id="))
5378 bool quoted
= (dbp
[0] == '"');
5381 for (end
= ++dbp
; *end
!= '\0' && *end
!= '"'; end
++)
5384 for (end
= dbp
; *end
!= '\0' && intoken (*end
); end
++)
5386 linebuffer_setlen (&token_name
, end
- dbp
);
5387 strncpy (token_name
.buffer
, dbp
, end
- dbp
);
5388 token_name
.buffer
[end
- dbp
] = '\0';
5391 intag
= FALSE
; /* we found what we looked for */
5392 skiptag
= TRUE
; /* skip to the end of the tag */
5393 getnext
= TRUE
; /* then grab the text */
5394 continue; /* look on the same line */
5399 else if (getnext
) /* grab next tokens and tag them */
5401 dbp
= skip_spaces (dbp
);
5403 break; /* go to next line */
5407 inanchor
= (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]));
5408 continue; /* look on the same line */
5411 for (end
= dbp
+ 1; *end
!= '\0' && *end
!= '<'; end
++)
5413 make_tag (token_name
.buffer
, token_name
.len
, TRUE
,
5414 dbp
, end
- dbp
, lineno
, linecharno
);
5415 linebuffer_setlen (&token_name
, 0); /* no name in buffer */
5417 break; /* go to next line */
5420 else /* look for an interesting HTML tag */
5422 while (*dbp
!= '\0' && *dbp
!= '<')
5425 break; /* go to next line */
5427 if (lowcase (dbp
[1]) == 'a' && !intoken (dbp
[2]))
5430 continue; /* look on the same line */
5432 else if (LOOKING_AT_NOCASE (dbp
, "<title>")
5433 || LOOKING_AT_NOCASE (dbp
, "<h1>")
5434 || LOOKING_AT_NOCASE (dbp
, "<h2>")
5435 || LOOKING_AT_NOCASE (dbp
, "<h3>"))
5439 continue; /* look on the same line */
5450 * Assumes that the predicate or rule starts at column 0.
5451 * Only the first clause of a predicate or rule is added.
5452 * Original code by Sunichirou Sugou (1989)
5453 * Rewritten by Anders Lindgren (1996)
5455 static int prolog_pr
__P((char *, char *));
5456 static void prolog_skip_comment
__P((linebuffer
*, FILE *));
5457 static int prolog_atom
__P((char *, int));
5460 Prolog_functions (inf
)
5471 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5473 if (cp
[0] == '\0') /* Empty line */
5475 else if (iswhite (cp
[0])) /* Not a predicate */
5477 else if (cp
[0] == '/' && cp
[1] == '*') /* comment. */
5478 prolog_skip_comment (&lb
, inf
);
5479 else if ((len
= prolog_pr (cp
, last
)) > 0)
5481 /* Predicate or rule. Store the function name so that we
5482 only generate a tag for the first clause. */
5484 last
= xnew(len
+ 1, char);
5485 else if (len
+ 1 > allocated
)
5486 xrnew (last
, len
+ 1, char);
5487 allocated
= len
+ 1;
5488 strncpy (last
, cp
, len
);
5498 prolog_skip_comment (plb
, inf
)
5506 for (cp
= plb
->buffer
; *cp
!= '\0'; cp
++)
5507 if (cp
[0] == '*' && cp
[1] == '/')
5509 readline (plb
, inf
);
5515 * A predicate or rule definition is added if it matches:
5516 * <beginning of line><Prolog Atom><whitespace>(
5517 * or <beginning of line><Prolog Atom><whitespace>:-
5519 * It is added to the tags database if it doesn't match the
5520 * name of the previous clause header.
5522 * Return the size of the name of the predicate or rule, or 0 if no
5528 char *last
; /* Name of last clause. */
5533 pos
= prolog_atom (s
, 0);
5538 pos
= skip_spaces (s
+ pos
) - s
;
5541 || (s
[pos
] == '(' && (pos
+= 1))
5542 || (s
[pos
] == ':' && s
[pos
+ 1] == '-' && (pos
+= 2)))
5543 && (last
== NULL
/* save only the first clause */
5544 || len
!= (int)strlen (last
)
5545 || !strneq (s
, last
, len
)))
5547 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5555 * Consume a Prolog atom.
5556 * Return the number of bytes consumed, or -1 if there was an error.
5558 * A prolog atom, in this context, could be one of:
5559 * - An alphanumeric sequence, starting with a lower case letter.
5560 * - A quoted arbitrary string. Single quotes can escape themselves.
5561 * Backslash quotes everything.
5564 prolog_atom (s
, pos
)
5572 if (ISLOWER(s
[pos
]) || (s
[pos
] == '_'))
5574 /* The atom is unquoted. */
5576 while (ISALNUM(s
[pos
]) || (s
[pos
] == '_'))
5580 return pos
- origpos
;
5582 else if (s
[pos
] == '\'')
5593 pos
++; /* A double quote */
5595 else if (s
[pos
] == '\0')
5596 /* Multiline quoted atoms are ignored. */
5598 else if (s
[pos
] == '\\')
5600 if (s
[pos
+1] == '\0')
5607 return pos
- origpos
;
5615 * Support for Erlang
5617 * Generates tags for functions, defines, and records.
5618 * Assumes that Erlang functions start at column 0.
5619 * Original code by Anders Lindgren (1996)
5621 static int erlang_func
__P((char *, char *));
5622 static void erlang_attribute
__P((char *));
5623 static int erlang_atom
__P((char *));
5626 Erlang_functions (inf
)
5637 LOOP_ON_INPUT_LINES (inf
, lb
, cp
)
5639 if (cp
[0] == '\0') /* Empty line */
5641 else if (iswhite (cp
[0])) /* Not function nor attribute */
5643 else if (cp
[0] == '%') /* comment */
5645 else if (cp
[0] == '"') /* Sometimes, strings start in column one */
5647 else if (cp
[0] == '-') /* attribute, e.g. "-define" */
5649 erlang_attribute (cp
);
5656 else if ((len
= erlang_func (cp
, last
)) > 0)
5659 * Function. Store the function name so that we only
5660 * generates a tag for the first clause.
5663 last
= xnew (len
+ 1, char);
5664 else if (len
+ 1 > allocated
)
5665 xrnew (last
, len
+ 1, char);
5666 allocated
= len
+ 1;
5667 strncpy (last
, cp
, len
);
5677 * A function definition is added if it matches:
5678 * <beginning of line><Erlang Atom><whitespace>(
5680 * It is added to the tags database if it doesn't match the
5681 * name of the previous clause header.
5683 * Return the size of the name of the function, or 0 if no function
5687 erlang_func (s
, last
)
5689 char *last
; /* Name of last clause. */
5694 pos
= erlang_atom (s
);
5699 pos
= skip_spaces (s
+ pos
) - s
;
5701 /* Save only the first clause. */
5704 || len
!= (int)strlen (last
)
5705 || !strneq (s
, last
, len
)))
5707 make_tag (s
, len
, TRUE
, s
, pos
, lineno
, linecharno
);
5716 * Handle attributes. Currently, tags are generated for defines
5719 * They are on the form:
5720 * -define(foo, bar).
5721 * -define(Foo(M, N), M+N).
5722 * -record(graph, {vtab = notable, cyclic = true}).
5725 erlang_attribute (s
)
5730 if ((LOOKING_AT (cp
, "-define") || LOOKING_AT (cp
, "-record"))
5733 int len
= erlang_atom (skip_spaces (cp
));
5735 make_tag (cp
, len
, TRUE
, s
, cp
+ len
- s
, lineno
, linecharno
);
5742 * Consume an Erlang atom (or variable).
5743 * Return the number of bytes consumed, or -1 if there was an error.
5751 if (ISALPHA (s
[pos
]) || s
[pos
] == '_')
5753 /* The atom is unquoted. */
5756 while (ISALNUM (s
[pos
]) || s
[pos
] == '_');
5758 else if (s
[pos
] == '\'')
5760 for (pos
++; s
[pos
] != '\''; pos
++)
5761 if (s
[pos
] == '\0' /* multiline quoted atoms are ignored */
5762 || (s
[pos
] == '\\' && s
[++pos
] == '\0'))
5771 static char *scan_separators
__P((char *));
5772 static void add_regex
__P((char *, language
*));
5773 static char *substitute
__P((char *, char *, struct re_registers
*));
5776 * Take a string like "/blah/" and turn it into "blah", verifying
5777 * that the first and last characters are the same, and handling
5778 * quoted separator characters. Actually, stops on the occurrence of
5779 * an unquoted separator. Also process \t, \n, etc. and turn into
5780 * appropriate characters. Works in place. Null terminates name string.
5781 * Returns pointer to terminating separator, or NULL for
5782 * unterminated regexps.
5785 scan_separators (name
)
5789 char *copyto
= name
;
5790 bool quoted
= FALSE
;
5792 for (++name
; *name
!= '\0'; ++name
)
5798 case 'a': *copyto
++ = '\007'; break; /* BEL (bell) */
5799 case 'b': *copyto
++ = '\b'; break; /* BS (back space) */
5800 case 'd': *copyto
++ = 0177; break; /* DEL (delete) */
5801 case 'e': *copyto
++ = 033; break; /* ESC (delete) */
5802 case 'f': *copyto
++ = '\f'; break; /* FF (form feed) */
5803 case 'n': *copyto
++ = '\n'; break; /* NL (new line) */
5804 case 'r': *copyto
++ = '\r'; break; /* CR (carriage return) */
5805 case 't': *copyto
++ = '\t'; break; /* TAB (horizontal tab) */
5806 case 'v': *copyto
++ = '\v'; break; /* VT (vertical tab) */
5812 /* Something else is quoted, so preserve the quote. */
5820 else if (*name
== '\\')
5822 else if (*name
== sep
)
5828 name
= NULL
; /* signal unterminated regexp */
5830 /* Terminate copied string. */
5835 /* Look at the argument of --regex or --no-regex and do the right
5836 thing. Same for each line of a regexp file. */
5838 analyse_regex (regex_arg
)
5841 if (regex_arg
== NULL
)
5843 free_regexps (); /* --no-regex: remove existing regexps */
5847 /* A real --regexp option or a line in a regexp file. */
5848 switch (regex_arg
[0])
5850 /* Comments in regexp file or null arg to --regex. */
5856 /* Read a regex file. This is recursive and may result in a
5857 loop, which will stop when the file descriptors are exhausted. */
5861 linebuffer regexbuf
;
5862 char *regexfile
= regex_arg
+ 1;
5864 /* regexfile is a file containing regexps, one per line. */
5865 regexfp
= fopen (regexfile
, "r");
5866 if (regexfp
== NULL
)
5871 linebuffer_init (®exbuf
);
5872 while (readline_internal (®exbuf
, regexfp
) > 0)
5873 analyse_regex (regexbuf
.buffer
);
5874 free (regexbuf
.buffer
);
5879 /* Regexp to be used for a specific language only. */
5883 char *lang_name
= regex_arg
+ 1;
5886 for (cp
= lang_name
; *cp
!= '}'; cp
++)
5889 error ("unterminated language name in regex: %s", regex_arg
);
5893 lang
= get_language_from_langname (lang_name
);
5896 add_regex (cp
, lang
);
5900 /* Regexp to be used for any language. */
5902 add_regex (regex_arg
, NULL
);
5907 /* Separate the regexp pattern, compile it,
5908 and care for optional name and modifiers. */
5910 add_regex (regexp_pattern
, lang
)
5911 char *regexp_pattern
;
5914 static struct re_pattern_buffer zeropattern
;
5915 char sep
, *pat
, *name
, *modifiers
;
5917 struct re_pattern_buffer
*patbuf
;
5920 force_explicit_name
= TRUE
, /* do not use implicit tag names */
5921 ignore_case
= FALSE
, /* case is significant */
5922 multi_line
= FALSE
, /* matches are done one line at a time */
5923 single_line
= FALSE
; /* dot does not match newline */
5926 if (strlen(regexp_pattern
) < 3)
5928 error ("null regexp", (char *)NULL
);
5931 sep
= regexp_pattern
[0];
5932 name
= scan_separators (regexp_pattern
);
5935 error ("%s: unterminated regexp", regexp_pattern
);
5940 error ("null name for regexp \"%s\"", regexp_pattern
);
5943 modifiers
= scan_separators (name
);
5944 if (modifiers
== NULL
) /* no terminating separator --> no name */
5950 modifiers
+= 1; /* skip separator */
5952 /* Parse regex modifiers. */
5953 for (; modifiers
[0] != '\0'; modifiers
++)
5954 switch (modifiers
[0])
5957 if (modifiers
== name
)
5958 error ("forcing explicit tag name but no name, ignoring", NULL
);
5959 force_explicit_name
= TRUE
;
5969 need_filebuf
= TRUE
;
5974 wrongmod
[0] = modifiers
[0];
5976 error ("invalid regexp modifier `%s', ignoring", wrongmod
);
5981 patbuf
= xnew (1, struct re_pattern_buffer
);
5982 *patbuf
= zeropattern
;
5985 static char lc_trans
[CHARS
];
5987 for (i
= 0; i
< CHARS
; i
++)
5988 lc_trans
[i
] = lowcase (i
);
5989 patbuf
->translate
= lc_trans
; /* translation table to fold case */
5993 pat
= concat ("^", regexp_pattern
, ""); /* anchor to beginning of line */
5995 pat
= regexp_pattern
;
5998 re_set_syntax (RE_SYNTAX_EMACS
| RE_DOT_NEWLINE
);
6000 re_set_syntax (RE_SYNTAX_EMACS
);
6002 err
= re_compile_pattern (pat
, strlen (regexp_pattern
), patbuf
);
6007 error ("%s while compiling pattern", err
);
6012 p_head
= xnew (1, regexp
);
6013 p_head
->pattern
= savestr (regexp_pattern
);
6014 p_head
->p_next
= rp
;
6015 p_head
->lang
= lang
;
6016 p_head
->pat
= patbuf
;
6017 p_head
->name
= savestr (name
);
6018 p_head
->error_signaled
= FALSE
;
6019 p_head
->force_explicit_name
= force_explicit_name
;
6020 p_head
->ignore_case
= ignore_case
;
6021 p_head
->multi_line
= multi_line
;
6025 * Do the substitutions indicated by the regular expression and
6029 substitute (in
, out
, regs
)
6031 struct re_registers
*regs
;
6034 int size
, dig
, diglen
;
6037 size
= strlen (out
);
6039 /* Pass 1: figure out how much to allocate by finding all \N strings. */
6040 if (out
[size
- 1] == '\\')
6041 fatal ("pattern error in \"%s\"", out
);
6042 for (t
= etags_strchr (out
, '\\');
6044 t
= etags_strchr (t
+ 2, '\\'))
6048 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
6054 /* Allocate space and do the substitutions. */
6056 result
= xnew (size
+ 1, char);
6058 for (t
= result
; *out
!= '\0'; out
++)
6059 if (*out
== '\\' && ISDIGIT (*++out
))
6062 diglen
= regs
->end
[dig
] - regs
->start
[dig
];
6063 strncpy (t
, in
+ regs
->start
[dig
], diglen
);
6070 assert (t
<= result
+ size
);
6071 assert (t
- result
== (int)strlen (result
));
6076 /* Deallocate all regexps. */
6081 while (p_head
!= NULL
)
6083 rp
= p_head
->p_next
;
6084 free (p_head
->pattern
);
6085 free (p_head
->name
);
6093 * Reads the whole file as a single string from `filebuf' and looks for
6094 * multi-line regular expressions, creating tags on matches.
6095 * readline already dealt with normal regexps.
6097 * Idea by Ben Wing <ben@666.com> (2002).
6100 regex_tag_multiline ()
6102 char *buffer
= filebuf
.buffer
;
6106 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6110 if (!rp
->multi_line
)
6111 continue; /* skip normal regexps */
6113 /* Generic initialisations before parsing file from memory. */
6114 lineno
= 1; /* reset global line number */
6115 charno
= 0; /* reset global char number */
6116 linecharno
= 0; /* reset global char number of line start */
6118 /* Only use generic regexps or those for the current language. */
6119 if (rp
->lang
!= NULL
&& rp
->lang
!= curfdp
->lang
)
6122 while (match
>= 0 && match
< filebuf
.len
)
6124 match
= re_search (rp
->pat
, buffer
, filebuf
.len
, charno
,
6125 filebuf
.len
- match
, &rp
->regs
);
6130 if (!rp
->error_signaled
)
6132 error ("regexp stack overflow while matching \"%s\"",
6134 rp
->error_signaled
= TRUE
;
6141 if (match
== rp
->regs
.end
[0])
6143 if (!rp
->error_signaled
)
6145 error ("regexp matches the empty string: \"%s\"",
6147 rp
->error_signaled
= TRUE
;
6149 match
= -3; /* exit from while loop */
6153 /* Match occurred. Construct a tag. */
6154 while (charno
< rp
->regs
.end
[0])
6155 if (buffer
[charno
++] == '\n')
6156 lineno
++, linecharno
= charno
;
6158 if (name
[0] == '\0')
6160 else /* make a named tag */
6161 name
= substitute (buffer
, rp
->name
, &rp
->regs
);
6162 if (rp
->force_explicit_name
)
6163 /* Force explicit tag name, if a name is there. */
6164 pfnote (name
, TRUE
, buffer
+ linecharno
,
6165 charno
- linecharno
+ 1, lineno
, linecharno
);
6167 make_tag (name
, strlen (name
), TRUE
, buffer
+ linecharno
,
6168 charno
- linecharno
+ 1, lineno
, linecharno
);
6180 register int len
= 0;
6182 while (*cp
!= '\0' && lowcase (*cp
) == lowcase (dbp
[len
]))
6184 if (*cp
== '\0' && !intoken (dbp
[len
]))
6193 get_tag (bp
, namepp
)
6197 register char *cp
= bp
;
6201 /* Go till you get to white space or a syntactic break */
6202 for (cp
= bp
+ 1; !notinname (*cp
); cp
++)
6204 make_tag (bp
, cp
- bp
, TRUE
,
6205 lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
6209 *namepp
= savenstr (bp
, cp
- bp
);
6213 * Read a line of text from `stream' into `lbp', excluding the
6214 * newline or CR-NL, if any. Return the number of characters read from
6215 * `stream', which is the length of the line including the newline.
6217 * On DOS or Windows we do not count the CR character, if any before the
6218 * NL, in the returned length; this mirrors the behavior of Emacs on those
6219 * platforms (for text files, it translates CR-NL to NL as it reads in the
6222 * If multi-line regular expressions are requested, each line read is
6223 * appended to `filebuf'.
6226 readline_internal (lbp
, stream
)
6228 register FILE *stream
;
6230 char *buffer
= lbp
->buffer
;
6231 register char *p
= lbp
->buffer
;
6232 register char *pend
;
6235 pend
= p
+ lbp
->size
; /* Separate to avoid 386/IX compiler bug. */
6239 register int c
= getc (stream
);
6242 /* We're at the end of linebuffer: expand it. */
6244 xrnew (buffer
, lbp
->size
, char);
6245 p
+= buffer
- lbp
->buffer
;
6246 pend
= buffer
+ lbp
->size
;
6247 lbp
->buffer
= buffer
;
6257 if (p
> buffer
&& p
[-1] == '\r')
6261 /* Assume CRLF->LF translation will be performed by Emacs
6262 when loading this file, so CRs won't appear in the buffer.
6263 It would be cleaner to compensate within Emacs;
6264 however, Emacs does not know how many CRs were deleted
6265 before any given point in the file. */
6280 lbp
->len
= p
- buffer
;
6282 if (need_filebuf
/* we need filebuf for multi-line regexps */
6283 && chars_deleted
> 0) /* not at EOF */
6285 while (filebuf
.size
<= filebuf
.len
+ lbp
->len
+ 1) /* +1 for \n */
6287 /* Expand filebuf. */
6289 xrnew (filebuf
.buffer
, filebuf
.size
, char);
6291 strncpy (filebuf
.buffer
+ filebuf
.len
, lbp
->buffer
, lbp
->len
);
6292 filebuf
.len
+= lbp
->len
;
6293 filebuf
.buffer
[filebuf
.len
++] = '\n';
6294 filebuf
.buffer
[filebuf
.len
] = '\0';
6297 return lbp
->len
+ chars_deleted
;
6301 * Like readline_internal, above, but in addition try to match the
6302 * input line against relevant regular expressions and manage #line
6306 readline (lbp
, stream
)
6312 linecharno
= charno
; /* update global char number of line start */
6313 result
= readline_internal (lbp
, stream
); /* read line */
6314 lineno
+= 1; /* increment global line number */
6315 charno
+= result
; /* increment global char number */
6317 /* Honour #line directives. */
6318 if (!no_line_directive
)
6320 static bool discard_until_line_directive
;
6322 /* Check whether this is a #line directive. */
6323 if (result
> 12 && strneq (lbp
->buffer
, "#line ", 6))
6328 if (sscanf (lbp
->buffer
, "#line %u \"%n", &lno
, &start
) >= 1
6329 && start
> 0) /* double quote character found */
6331 char *endp
= lbp
->buffer
+ start
;
6333 while ((endp
= etags_strchr (endp
, '"')) != NULL
6334 && endp
[-1] == '\\')
6337 /* Ok, this is a real #line directive. Let's deal with it. */
6339 char *taggedabsname
; /* absolute name of original file */
6340 char *taggedfname
; /* name of original file as given */
6341 char *name
; /* temp var */
6343 discard_until_line_directive
= FALSE
; /* found it */
6344 name
= lbp
->buffer
+ start
;
6346 canonicalize_filename (name
); /* for DOS */
6347 taggedabsname
= absolute_filename (name
, tagfiledir
);
6348 if (filename_is_absolute (name
)
6349 || filename_is_absolute (curfdp
->infname
))
6350 taggedfname
= savestr (taggedabsname
);
6352 taggedfname
= relative_filename (taggedabsname
,tagfiledir
);
6354 if (streq (curfdp
->taggedfname
, taggedfname
))
6355 /* The #line directive is only a line number change. We
6356 deal with this afterwards. */
6359 /* The tags following this #line directive should be
6360 attributed to taggedfname. In order to do this, set
6361 curfdp accordingly. */
6363 fdesc
*fdp
; /* file description pointer */
6365 /* Go look for a file description already set up for the
6366 file indicated in the #line directive. If there is
6367 one, use it from now until the next #line
6369 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6370 if (streq (fdp
->infname
, curfdp
->infname
)
6371 && streq (fdp
->taggedfname
, taggedfname
))
6372 /* If we remove the second test above (after the &&)
6373 then all entries pertaining to the same file are
6374 coalesced in the tags file. If we use it, then
6375 entries pertaining to the same file but generated
6376 from different files (via #line directives) will
6377 go into separate sections in the tags file. These
6378 alternatives look equivalent. The first one
6379 destroys some apparently useless information. */
6385 /* Else, if we already tagged the real file, skip all
6386 input lines until the next #line directive. */
6387 if (fdp
== NULL
) /* not found */
6388 for (fdp
= fdhead
; fdp
!= NULL
; fdp
= fdp
->next
)
6389 if (streq (fdp
->infabsname
, taggedabsname
))
6391 discard_until_line_directive
= TRUE
;
6395 /* Else create a new file description and use that from
6396 now on, until the next #line directive. */
6397 if (fdp
== NULL
) /* not found */
6400 fdhead
= xnew (1, fdesc
);
6401 *fdhead
= *curfdp
; /* copy curr. file description */
6403 fdhead
->infname
= savestr (curfdp
->infname
);
6404 fdhead
->infabsname
= savestr (curfdp
->infabsname
);
6405 fdhead
->infabsdir
= savestr (curfdp
->infabsdir
);
6406 fdhead
->taggedfname
= taggedfname
;
6407 fdhead
->usecharno
= FALSE
;
6408 fdhead
->prop
= NULL
;
6409 fdhead
->written
= FALSE
;
6413 free (taggedabsname
);
6415 readline (lbp
, stream
);
6417 } /* if a real #line directive */
6418 } /* if #line is followed by a a number */
6419 } /* if line begins with "#line " */
6421 /* If we are here, no #line directive was found. */
6422 if (discard_until_line_directive
)
6426 /* Do a tail recursion on ourselves, thus discarding the contents
6427 of the line buffer. */
6428 readline (lbp
, stream
);
6432 discard_until_line_directive
= FALSE
;
6435 } /* if #line directives should be considered */
6442 /* Match against relevant regexps. */
6444 for (rp
= p_head
; rp
!= NULL
; rp
= rp
->p_next
)
6446 /* Only use generic regexps or those for the current language.
6447 Also do not use multiline regexps, which is the job of
6448 regex_tag_multiline. */
6449 if ((rp
->lang
!= NULL
&& rp
->lang
!= fdhead
->lang
)
6453 match
= re_match (rp
->pat
, lbp
->buffer
, lbp
->len
, 0, &rp
->regs
);
6458 if (!rp
->error_signaled
)
6460 error ("regexp stack overflow while matching \"%s\"",
6462 rp
->error_signaled
= TRUE
;
6469 /* Empty string matched. */
6470 if (!rp
->error_signaled
)
6472 error ("regexp matches the empty string: \"%s\"", rp
->pattern
);
6473 rp
->error_signaled
= TRUE
;
6477 /* Match occurred. Construct a tag. */
6479 if (name
[0] == '\0')
6481 else /* make a named tag */
6482 name
= substitute (lbp
->buffer
, rp
->name
, &rp
->regs
);
6483 if (rp
->force_explicit_name
)
6484 /* Force explicit tag name, if a name is there. */
6485 pfnote (name
, TRUE
, lbp
->buffer
, match
, lineno
, linecharno
);
6487 make_tag (name
, strlen (name
), TRUE
,
6488 lbp
->buffer
, match
, lineno
, linecharno
);
6497 * Return a pointer to a space of size strlen(cp)+1 allocated
6498 * with xnew where the string CP has been copied.
6504 return savenstr (cp
, strlen (cp
));
6508 * Return a pointer to a space of size LEN+1 allocated with xnew where
6509 * the string CP has been copied for at most the first LEN characters.
6518 dp
= xnew (len
+ 1, char);
6519 strncpy (dp
, cp
, len
);
6525 * Return the ptr in sp at which the character c last
6526 * appears; NULL if not found
6528 * Identical to POSIX strrchr, included for portability.
6531 etags_strrchr (sp
, c
)
6532 register const char *sp
;
6535 register const char *r
;
6547 * Return the ptr in sp at which the character c first
6548 * appears; NULL if not found
6550 * Identical to POSIX strchr, included for portability.
6553 etags_strchr (sp
, c
)
6554 register const char *sp
;
6566 * Compare two strings, ignoring case for alphabetic characters.
6568 * Same as BSD's strcasecmp, included for portability.
6571 etags_strcasecmp (s1
, s2
)
6572 register const char *s1
;
6573 register const char *s2
;
6576 && (ISALPHA (*s1
) && ISALPHA (*s2
)
6577 ? lowcase (*s1
) == lowcase (*s2
)
6581 return (ISALPHA (*s1
) && ISALPHA (*s2
)
6582 ? lowcase (*s1
) - lowcase (*s2
)
6587 * Compare two strings, ignoring case for alphabetic characters.
6588 * Stop after a given number of characters
6590 * Same as BSD's strncasecmp, included for portability.
6593 etags_strncasecmp (s1
, s2
, n
)
6594 register const char *s1
;
6595 register const char *s2
;
6598 while (*s1
!= '\0' && n
-- > 0
6599 && (ISALPHA (*s1
) && ISALPHA (*s2
)
6600 ? lowcase (*s1
) == lowcase (*s2
)
6607 return (ISALPHA (*s1
) && ISALPHA (*s2
)
6608 ? lowcase (*s1
) - lowcase (*s2
)
6612 /* Skip spaces (end of string is not space), return new pointer. */
6617 while (iswhite (*cp
))
6622 /* Skip non spaces, except end of string, return new pointer. */
6624 skip_non_spaces (cp
)
6627 while (*cp
!= '\0' && !iswhite (*cp
))
6632 /* Print error message and exit. */
6638 exit (EXIT_FAILURE
);
6646 exit (EXIT_FAILURE
);
6650 suggest_asking_for_help ()
6652 fprintf (stderr
, "\tTry `%s %s' for a complete list of options.\n",
6653 progname
, NO_LONG_OPTIONS
? "-h" : "--help");
6654 exit (EXIT_FAILURE
);
6657 /* Print error message. `s1' is printf control string, `s2' is arg for it. */
6660 const char *s1
, *s2
;
6662 fprintf (stderr
, "%s: ", progname
);
6663 fprintf (stderr
, s1
, s2
);
6664 fprintf (stderr
, "\n");
6667 /* Return a newly-allocated string whose contents
6668 concatenate those of s1, s2, s3. */
6673 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
6674 char *result
= xnew (len1
+ len2
+ len3
+ 1, char);
6676 strcpy (result
, s1
);
6677 strcpy (result
+ len1
, s2
);
6678 strcpy (result
+ len1
+ len2
, s3
);
6679 result
[len1
+ len2
+ len3
] = '\0';
6685 /* Does the same work as the system V getcwd, but does not need to
6686 guess the buffer size in advance. */
6692 char *path
= xnew (bufsize
, char);
6694 while (getcwd (path
, bufsize
) == NULL
)
6696 if (errno
!= ERANGE
)
6700 path
= xnew (bufsize
, char);
6703 canonicalize_filename (path
);
6706 #else /* not HAVE_GETCWD */
6709 char *p
, path
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
6713 for (p
= path
; *p
!= '\0'; p
++)
6719 return strdup (path
);
6720 #else /* not MSDOS */
6724 linebuffer_init (&path
);
6725 pipe
= (FILE *) popen ("pwd 2>/dev/null", "r");
6726 if (pipe
== NULL
|| readline_internal (&path
, pipe
) == 0)
6731 #endif /* not MSDOS */
6732 #endif /* not HAVE_GETCWD */
6735 /* Return a newly allocated string containing the file name of FILE
6736 relative to the absolute directory DIR (which should end with a slash). */
6738 relative_filename (file
, dir
)
6741 char *fp
, *dp
, *afn
, *res
;
6744 /* Find the common root of file and dir (with a trailing slash). */
6745 afn
= absolute_filename (file
, cwd
);
6748 while (*fp
++ == *dp
++)
6750 fp
--, dp
--; /* back to the first differing char */
6752 if (fp
== afn
&& afn
[0] != '/') /* cannot build a relative name */
6755 do /* look at the equal chars until '/' */
6759 /* Build a sequence of "../" strings for the resulting relative file name. */
6761 while ((dp
= etags_strchr (dp
+ 1, '/')) != NULL
)
6763 res
= xnew (3*i
+ strlen (fp
+ 1) + 1, char);
6766 strcat (res
, "../");
6768 /* Add the file name relative to the common root of file and dir. */
6769 strcat (res
, fp
+ 1);
6775 /* Return a newly allocated string containing the absolute file name
6776 of FILE given DIR (which should end with a slash). */
6778 absolute_filename (file
, dir
)
6781 char *slashp
, *cp
, *res
;
6783 if (filename_is_absolute (file
))
6784 res
= savestr (file
);
6786 /* We don't support non-absolute file names with a drive
6787 letter, like `d:NAME' (it's too much hassle). */
6788 else if (file
[1] == ':')
6789 fatal ("%s: relative file names with drive letters not supported", file
);
6792 res
= concat (dir
, file
, "");
6794 /* Delete the "/dirname/.." and "/." substrings. */
6795 slashp
= etags_strchr (res
, '/');
6796 while (slashp
!= NULL
&& slashp
[0] != '\0')
6798 if (slashp
[1] == '.')
6800 if (slashp
[2] == '.'
6801 && (slashp
[3] == '/' || slashp
[3] == '\0'))
6806 while (cp
>= res
&& !filename_is_absolute (cp
));
6808 cp
= slashp
; /* the absolute name begins with "/.." */
6810 /* Under MSDOS and NT we get `d:/NAME' as absolute
6811 file name, so the luser could say `d:/../NAME'.
6812 We silently treat this as `d:/NAME'. */
6813 else if (cp
[0] != '/')
6816 strcpy (cp
, slashp
+ 3);
6820 else if (slashp
[2] == '/' || slashp
[2] == '\0')
6822 strcpy (slashp
, slashp
+ 2);
6827 slashp
= etags_strchr (slashp
+ 1, '/');
6830 if (res
[0] == '\0') /* just a safety net: should never happen */
6833 return savestr ("/");
6839 /* Return a newly allocated string containing the absolute
6840 file name of dir where FILE resides given DIR (which should
6841 end with a slash). */
6843 absolute_dirname (file
, dir
)
6849 canonicalize_filename (file
);
6850 slashp
= etags_strrchr (file
, '/');
6852 return savestr (dir
);
6855 res
= absolute_filename (file
, dir
);
6861 /* Whether the argument string is an absolute file name. The argument
6862 string must have been canonicalized with canonicalize_filename. */
6864 filename_is_absolute (fn
)
6867 return (fn
[0] == '/'
6869 || (ISALPHA(fn
[0]) && fn
[1] == ':' && fn
[2] == '/')
6874 /* Translate backslashes into slashes. Works in place. */
6876 canonicalize_filename (fn
)
6880 /* Canonicalize drive letter case. */
6881 if (fn
[0] != '\0' && fn
[1] == ':' && ISLOWER (fn
[0]))
6882 fn
[0] = upcase (fn
[0]);
6883 /* Convert backslashes to slashes. */
6884 for (; *fn
!= '\0'; fn
++)
6889 fn
= NULL
; /* shut up the compiler */
6894 /* Initialize a linebuffer for use */
6896 linebuffer_init (lbp
)
6899 lbp
->size
= (DEBUG
) ? 3 : 200;
6900 lbp
->buffer
= xnew (lbp
->size
, char);
6901 lbp
->buffer
[0] = '\0';
6905 /* Set the minimum size of a string contained in a linebuffer. */
6907 linebuffer_setlen (lbp
, toksize
)
6911 while (lbp
->size
<= toksize
)
6914 xrnew (lbp
->buffer
, lbp
->size
, char);
6919 /* Like malloc but get fatal error if memory is exhausted. */
6924 PTR result
= (PTR
) malloc (size
);
6926 fatal ("virtual memory exhausted", (char *)NULL
);
6931 xrealloc (ptr
, size
)
6935 PTR result
= (PTR
) realloc (ptr
, size
);
6937 fatal ("virtual memory exhausted", (char *)NULL
);
6943 * indent-tabs-mode: t
6946 * c-font-lock-extra-types: ("FILE" "bool" "language" "linebuffer" "fdesc" "node" "regexp")
6947 * c-file-style: "gnu"
6951 /* arch-tag: 8a9b748d-390c-4922-99db-2eeefa921051
6952 (do not change this comment) */
6954 /* etags.c ends here */