1 /* Tags file maker to go with GNU Emacs
2 Copyright (C) 1984, 1987, 1988, 1989, 1993 Free Software Foundation, Inc. and Ken Arnold
4 This file is not considered part of GNU Emacs.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 * Ctags originally by Ken Arnold.
23 * FORTRAN added by Jim Kleckner.
24 * Ed Pelegri-Llopart added C typedefs.
25 * Gnu Emacs TAGS format and modifications by RMS?
26 * Sam Kendall added C++.
28 * Francesco Potorti` (pot@cnuce.cnr.it) is the current maintainer. 9.7
32 #include <../src/config.h>
37 #include <sys/types.h>
40 #if !defined (S_ISREG) && defined (S_IFREG)
41 # define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
46 extern char *malloc (), *realloc ();
47 extern char *getenv ();
48 extern char *strcpy (), *strncpy ();
51 char *etags_index (), *etags_rindex ();
54 /* Define the symbol ETAGS to make the program "etags",
55 which makes emacs-style tag tables by default.
56 Define CTAGS to make the program "ctags" compatible with the usual one.
57 Define neither one to get behavior that depends
58 on the name with which the program is invoked
59 (but we don't normally compile it that way). */
61 #if !defined(ETAGS) && !defined(CTAGS)
62 /* If neither is defined, program can be run as either. */
67 /* On VMS, CTAGS is not useful, so always do ETAGS. */
74 /* Exit codes for success and failure. */
84 * The FILEPOS abstract type, which represents a position in a file,
85 * plus the following accessor functions:
87 * long GET_CHARNO (pos)
88 * returns absolute char number.
89 * void SET_FILEPOS (pos, fp, charno)
90 * FILE *fp; long charno;
91 * sets `pos' from the current file
92 * position of `fp' and from `charno',
93 * which must be the absolute character
94 * number corresponding to the current
97 * The `pos' parameter is an lvalue expression of type FILEPOS.
98 * Parameters to the accessor functions are evaluated 0 or more times,
99 * and so must have no side effects.
101 * FILEPOS objects can also be assigned and passed to and from
102 * functions in the normal C manner.
104 * Implementation notes: the `+ 0' is to enforce rvalue-ness.
108 /* real implementation */
109 typedef long FILEPOS
;
110 #define GET_CHARNO(pos) ((pos) + 0)
111 #define SET_FILEPOS(pos, fp, cno) ((void) ((pos) = (cno)))
113 /* debugging implementation */
119 #define GET_CHARNO(pos) ((pos).charno + 0)
120 #define SET_FILEPOS(pos, fp, cno) \
121 ((void) ((pos).charno = (cno), \
122 (cno) != ftell (fp) ? (error ("SET_FILEPOS inconsistency"), 0) \
126 #define streq(s, t) (strcmp (s, t) == 0)
127 #define strneq(s, t, n) (strncmp (s, t, n) == 0)
133 #define iswhite(arg) (_wht[arg]) /* T if char is white */
134 #define begtoken(arg) (_btk[arg]) /* T if char can start token */
135 #define intoken(arg) (_itk[arg]) /* T if char can be in token */
136 #define endtoken(arg) (_etk[arg]) /* T if char ends tokens */
138 #define max(I1,I2) ((I1) > (I2) ? (I1) : (I2))
141 { /* sorting structure */
142 char *name
; /* function or type name */
143 char *file
; /* file name */
144 logical is_func
; /* use pattern or line no */
145 logical named
; /* list name separately */
146 logical been_warned
; /* set if noticed dup */
147 int lno
; /* line number tag is on */
148 long cno
; /* character number line starts on */
149 char *pat
; /* search pattern */
150 struct nd_st
*left
, *right
; /* left and right sons */
154 typedef struct nd_st NODE
;
156 logical header_file
; /* TRUE if .h file, FALSE o.w. */
157 /* boolean "functions" (see init) */
158 logical _wht
[0177], _etk
[0177], _itk
[0177], _btk
[0177];
166 int L_isdef (), L_isquote ();
168 int total_size_of_entries ();
169 logical
consider_token ();
177 void Scheme_funcs ();
182 void find_entries ();
190 void process_file ();
196 * xnew -- allocate storage
199 * Type *xnew (int n, Type);
201 #define xnew(n, Type) ((Type *) xmalloc ((n) * sizeof (Type)))
206 * Symbol table stuff.
208 * Should probably be implemented with hash table; linked list for now.
213 st_none
, st_C_struct
, st_C_enum
, st_C_define
, st_C_typedef
, st_C_typespec
221 struct stab_entry
*next
;
224 typedef struct stab_entry Stab_entry
;
225 typedef Stab_entry
*Stab
;
229 * Stab, Stab_entry, stab_create, stab_search, stab_find -- symbol table
232 * Types: Stab, Stab_entry, enum sym_type
234 * Stab * stab_create ()
236 * Stab_entry * stab_find (stab, sym)
240 * Stab_entry * stab_search (stab, sym)
245 * stab_create creates a Stab, a symbol table object, and returns a
246 * pointer to it. stab_find finds a symbol in a Stab; it returns a
247 * pointer to the Stab_entry if found, otherwise NULL. stab_search
248 * is like stab_find, except that it creates a new Stab_entry,
249 * initialized with type = st_none, if one did not exist already
250 * (it never returns NULL).
252 * A Stab_entry is a structure that contains at least the following
255 * char *name; // must not be modified
256 * enum sym_type type; // should be set
258 * The type field is initially set to st_none; it should be set to
259 * something else by the caller of stab_search. Other possible values
260 * of an enum sym_type can be added.
268 *sp
= NULL
; /* a Stab starts out as a null Stab_entry* */
273 stab_find (stab
, sym
, symlen
)
278 register Stab_entry
*se
;
279 for (se
= *stab
; se
!= NULL
; se
= se
->next
)
281 if (se
->symlen
== symlen
&& strneq (se
->sym
, sym
, symlen
))
289 stab_search (stab
, sym
, symlen
)
294 register Stab_entry
*se
;
295 se
= stab_find (stab
, sym
, symlen
);
300 se
= xnew (1, Stab_entry
);
301 se
->sym
= savenstr (sym
, symlen
);
313 * stab_type -- type of a symbol table entry
316 * enum sym_type stab_type (Stab_entry *se);
319 * May evaluate its argument more than once.
322 #define stab_type(se) ((se)==NULL ? st_none : (se)->type)
338 #define C_PLPL 0x00001 /* C++ */
339 #define C_STAR 0x00003 /* C* */
340 #define YACC 0x10000 /* yacc file */
342 char searchar
= '/'; /* use /.../ searches */
344 LINENO lineno
; /* line number of current line */
345 long charno
; /* current character number */
347 long linecharno
; /* charno of start of line; not used by C, but
348 * by every other language.
351 char *curfile
, /* current input file name */
352 *outfile
, /* output file */
353 *white
= " \f\t\n", /* white chars */
354 *endtk
= " \t\n\"'#()[]{}=-+%*/&|^~!<>;,.:?", /* token ending chars */
355 /* token starting chars */
356 *begtk
= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$",
357 /* valid in-token chars */
358 *intk
= "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$0123456789";
360 int append_to_tagfile
; /* -a: append to tags */
361 int emacs_tags_format
; /* emacs style output (no -e option any more) */
362 /* The following three default to 1 for etags, but to 0 for ctags. */
363 int typedefs
; /* -t: create tags for typedefs */
364 int typedefs_and_cplusplus
; /* -T: create tags for typedefs, level */
365 /* 0 struct/enum/union decls, and C++ */
366 /* member functions */
367 int constantypedefs
; /* -d: create tags for C #define and enum */
368 /* constants. Default under etags. Enum */
369 /* constants not implemented. */
370 /* -D: opposite of -d. Default under ctags. */
371 int update
; /* -u: update tags */
372 int vgrind_style
; /* -v: create vgrind style index output */
373 int no_warnings
; /* -w: suppress warnings */
374 int cxref_style
; /* -x: create cxref style output */
375 int cplusplus
; /* .[hc] means C++, not C */
376 int noindentypedefs
; /* -S: ignore indentation in C */
378 /* Name this program was invoked with. */
381 struct option longopts
[] = {
382 { "append", no_argument
, NULL
, 'a' },
383 { "backward-search", no_argument
, NULL
, 'B' },
384 { "c++", no_argument
, NULL
, 'C' },
385 { "cxref", no_argument
, NULL
, 'x' },
386 { "defines", no_argument
, NULL
, 'd' },
387 { "forward-search", no_argument
, NULL
, 'F' },
388 { "help", no_argument
, NULL
, 'H' },
389 { "ignore-indentation", no_argument
, NULL
, 'S' },
390 { "include", required_argument
, NULL
, 'i' },
391 { "no-defines", no_argument
, NULL
, 'D' },
392 { "no-warn", no_argument
, NULL
, 'w' },
393 { "output", required_argument
, NULL
, 'o' },
394 { "typedefs", no_argument
, NULL
, 't' },
395 { "typedefs-and-c++", no_argument
, NULL
, 'T' },
396 { "update", no_argument
, NULL
, 'u' },
397 { "version", no_argument
, NULL
, 'V' },
398 { "vgrind", no_argument
, NULL
, 'v' },
402 FILE *inf
, /* ioptr for current input file */
403 *outf
; /* ioptr for tags file */
405 NODE
*head
; /* the head of the binary tree of tags */
407 int permit_duplicates
= 1; /* Nonzero means allow duplicate tags. */
409 /* A `struct linebuffer' is a structure which holds a line of text.
410 `readline' reads a line from a stream into a linebuffer
411 and works regardless of the length of the line. */
419 struct linebuffer lb
; /* the current line */
420 struct linebuffer filename_lb
; /* used to read in filenames */
424 struct linebuffer lb
; /* used by C_entries instead of lb */
439 printf ("for Emacs version 19.\n");
447 printf ("These are the options accepted by %s. You may use unambiguous\n\
448 abbreviations for the long option names.\n\n", progname
);
450 puts ("-a, --append\n\
451 Append tag entries to existing tags file.");
453 Treat files with `.c' and `.h' extensions as C++ code, not C\n\
454 code. Files with `.C', `.H', `.cxx', `.hxx', or `.cc'\n\
455 extensions are always assumed to be C++ code.");
456 fputs ("-d, --defines\n\
457 Create tag entries for #defines, too.", stdout
);
460 fputs (" This is the default\n\
466 Don't create tag entries for #defines.", stdout
);
469 fputs (" This is the default\n\
474 -o FILE, --output=FILE\n\
475 Write the tags to FILE.\n\
476 -S, --ignore-indentation\n\
477 Don't rely on indentation quite as much as normal. Currently,\n\
478 this means not to assume that a closing brace in the first\n\
479 column is the final brace of a function or structure\n\
481 puts ("-t, --typedefs\n\
482 Generate tag entries for typedefs. This is the default\n\
484 puts ("-T, --typedefs-and-c++\n\
485 Generate tag entries for typedefs, struct/enum/union tags, and\n\
486 C++ member functions.");
489 puts ("-i FILE, --include=FILE\n\
490 Include a note in tag file indicating that, when searching for\n\
491 a tag, one should also consult the tags file FILE after\n\
492 checking the current file.");
496 puts ("-B, --backward-search\n\
497 Write the search commands for the tag entries using '?', the\n\
498 backward-search command.");
499 puts ("-F, --forward-search\n\
500 Write the search commands for the tag entries using '/', the\n\
501 forward-search command.");
502 puts ("-u, --update\n\
503 Update the tag entries for the given files, leaving tag\n\
504 entries for other files in place. Currently, this is\n\
505 implemented by deleting the existing entries for the given\n\
506 files and then rewriting the new entries at the end of the\n\
507 tags file. It is often faster to simply rebuild the entire\n\
508 tag file than to use this.");
509 puts ("-v, --vgrind\n\
510 Generates an index of items intended for human consumption,\n\
511 similar to the output of vgrind. The index is sorted, and\n\
512 gives the page number of each item.");
513 puts ("-x, --cxref\n\
514 Like --vgrind, but in the style of cxref, rather than vgrind.\n\
515 The output uses line numbers instead of page numbers, but\n\
516 beyond that the differences are cosmetic; try both to see\n\
518 puts ("-w, --no-warn\n\
519 Suppress warning messages about entries defined in multiple\n\
523 puts ("-V, --version\n\
524 Print the version of the program.\n\
526 Print this help message.");
539 unsigned int nincluded_files
= 0;
540 char **included_files
= xnew (argc
, char *);
545 extern char *gfnames ();
546 extern char *massage_name ();
552 emacs_tags_format
= 1;
554 emacs_tags_format
= 0;
558 * If etags, always find typedefs and structure tags. Why not?
559 * Also default is to find macro constants.
561 if (emacs_tags_format
)
562 typedefs
= typedefs_and_cplusplus
= constantypedefs
= 1;
567 opt
= getopt_long (argc
, argv
, "aCdDo:f:StTi:BFuvxwVH", longopts
, 0);
575 /* If getopt returns '\0', then it has already processed a
576 long-named option. We should do nothing. */
579 /* Common options. */
597 "%s: -%c flag may only be given once\n", progname
, opt
);
610 typedefs_and_cplusplus
++;
621 if (!emacs_tags_format
)
623 included_files
[nincluded_files
++] = optarg
;
629 if (emacs_tags_format
)
634 if (emacs_tags_format
)
639 if (emacs_tags_format
)
647 if (emacs_tags_format
)
652 if (emacs_tags_format
)
661 if (optind
== argc
&& nincluded_files
== 0)
663 fprintf (stderr
, "%s: No input files specified.\n", progname
);
666 fprintf (stderr
, "%s: Try `%s --help' for a complete list of options.\n",
673 outfile
= emacs_tags_format
? "TAGS" : "tags";
676 init (); /* set up boolean "functions" */
679 initbuffer (&lbs
[0].lb
);
680 initbuffer (&lbs
[1].lb
);
681 initbuffer (&filename_lb
);
683 * loop through files finding functions
685 if (emacs_tags_format
)
687 if (streq (outfile
, "-"))
690 outf
= fopen (outfile
, append_to_tagfile
? "a" : "w");
701 while (gfnames (&argc
, &argv
, &got_err
) != NULL
)
705 error ("Can't find file %s\n", this_file
);
710 this_file
= massage_name (this_file
);
713 } /* solely to balance out the ifdef'd parens above */
716 for (; optind
< argc
; optind
++)
718 this_file
= argv
[optind
];
722 /* Input file named "-" means read file names from stdin
724 if (streq (this_file
, "-"))
726 while (!feof (stdin
))
728 (void) readline (&filename_lb
, stdin
);
729 if (strlen (filename_lb
.buffer
) > 0)
730 process_file (filename_lb
.buffer
);
734 process_file (this_file
);
738 if (emacs_tags_format
)
740 while (nincluded_files
-- > 0)
741 fprintf (outf
, "\f\n%s,include\n", *included_files
++);
743 (void) fclose (outf
);
754 /* update cannot be set under VMS, so we may assume that argc
755 and argv have not been munged. */
756 for (i
= optind
; i
< argc
; i
++)
759 "mv %s OTAGS;fgrep -v '\t%s\t' OTAGS >%s;rm OTAGS",
760 outfile
, argv
[i
], outfile
);
765 outf
= fopen (outfile
, append_to_tagfile
? "a" : "w");
772 (void) fclose (outf
);
775 sprintf (cmd
, "sort %s -o %s", outfile
, outfile
);
783 * This routine is called on each file argument.
789 struct stat stat_buf
;
791 if (stat (file
, &stat_buf
) || !S_ISREG (stat_buf
.st_mode
))
793 fprintf (stderr
, "Skipping %s: it is not a regular file.\n", file
);
797 if (streq (file
, outfile
) && !streq (outfile
, "-"))
799 fprintf (stderr
, "Skipping inclusion of %s in self.\n", file
);
803 if (emacs_tags_format
)
805 fprintf (outf
, "\f\n%s,%d\n", file
, total_size_of_entries (head
));
813 * This routine sets up the boolean pseudo-functions which work
814 * by setting boolean flags dependent upon the corresponding character
815 * Every char which is NOT in that string is not a white char. Therefore,
816 * all of the array "_wht" is set to FALSE, and then the elements
817 * subscripted by the chars in "white" are set to TRUE. Thus "_wht"
818 * of a char is TRUE if it is the string "white", else FALSE.
826 for (i
= 0; i
< 0177; i
++)
827 _wht
[i
] = _etk
[i
] = _itk
[i
] = _btk
[i
] = FALSE
;
828 for (sp
= white
; *sp
; sp
++)
830 for (sp
= endtk
; *sp
; sp
++)
832 for (sp
= intk
; *sp
; sp
++)
834 for (sp
= begtk
; *sp
; sp
++)
836 _wht
[0] = _wht
['\n'];
837 _etk
[0] = _etk
['\n'];
838 _btk
[0] = _btk
['\n'];
839 _itk
[0] = _itk
['\n'];
843 * This routine opens the specified file and calls the function
844 * which finds the function and type definitions.
851 void prolog_funcs ();
853 inf
= fopen (file
, "r");
859 curfile
= savestr (file
);
860 cp
= etags_rindex (file
, '.');
862 header_file
= (cp
&& (streq (cp
+ 1, "h")));
864 /* .tex, .aux or .bbl implies LaTeX source code */
865 if (cp
&& (streq (cp
+ 1, "tex") || streq (cp
+ 1, "aux")
866 || streq (cp
+ 1, "bbl")))
869 goto close_and_return
;
871 /* .l or .el or .lisp (or .cl or .clisp or ...) implies lisp source code */
872 if (cp
&& (streq (cp
+ 1, "l")
873 || streq (cp
+ 1, "el")
874 || streq (cp
+ 1, "lsp")
875 || streq (cp
+ 1, "lisp")
876 || streq (cp
+ 1, "cl")
877 || streq (cp
+ 1, "clisp")))
880 goto close_and_return
;
882 /* .scm or .sm or .scheme or ... implies scheme source code */
883 if (cp
&& (streq (cp
+ 1, "sm")
884 || streq (cp
+ 1, "scm")
885 || streq (cp
+ 1, "scheme")
886 || streq (cp
+ 1, "t")
887 || streq (cp
+ 1, "sch")
888 || streq (cp
+ 1, "SM")
889 || streq (cp
+ 1, "SCM")
890 /* The `SCM' or `scm' prefix with a version number */
891 || (cp
[-1] == 'm' && cp
[-2] == 'c' && cp
[-3] == 's'
892 && string_numeric_p (cp
+ 1))
893 || (cp
[-1] == 'M' && cp
[-2] == 'C' && cp
[-3] == 'S'
894 && string_numeric_p (cp
+ 1))))
900 /* Assume that ".s" or ".a" is assembly code. -wolfgang.
902 if (cp
&& (streq (cp
+ 1, "s")
903 || streq (cp
+ 1, "a")
904 || streq (cp
+ 1, "sa")))
910 /* .C or .H or .cxx or .hxx or .cc: a C++ file */
911 if (cp
&& (streq (cp
+ 1, "C")
912 || streq (cp
+ 1, "H")
913 || streq (cp
+ 1, "cxx")
914 || streq (cp
+ 1, "hxx")
915 || streq (cp
+ 1, "cc")))
917 C_entries (C_PLPL
); /* C++ */
918 goto close_and_return
;
920 /* .cs or .hs: a C* file */
921 if (cp
&& (streq (cp
+ 1, "cs")
922 || streq (cp
+ 1, "hs")))
925 goto close_and_return
;
927 /* .y: a yacc file */
928 if (cp
&& (streq (cp
+ 1, "y")))
931 goto close_and_return
;
933 /* .pl implies prolog source code */
934 if (cp
&& streq (cp
+ 1, "pl"))
937 goto close_and_return
;
939 /* .p or .pas: a Pascal file */
940 if (cp
&& (streq (cp
+ 1, "p")
941 || streq (cp
+ 1, "pas")))
944 goto close_and_return
;
946 /* If .f or .for, assume it is fortran or nothing. */
947 if (cp
&& (streq (cp
+ 1, "f")
948 || streq (cp
+ 1, "for")))
951 goto close_and_return
;
953 /* if not a .c or .h or .y file, try fortran */
954 if (cp
&& ((cp
[1] != 'c'
957 || (cp
[1] != 0 && cp
[2] != 0)))
959 if (PF_funcs (inf
) != 0)
960 goto close_and_return
;
961 rewind (inf
); /* no fortran tags found, try C */
963 C_entries (cplusplus
? C_PLPL
: 0);
969 /* Nonzero if string STR is composed of digits. */
972 string_numeric_p (str
)
977 if (*str
< '0' || *str
> '9')
984 /* Should take a TOKEN* instead!! */
986 pfnote (name
, is_func
, named
, linestart
, linelen
, lno
, cno
)
987 char *name
; /* tag name */
988 logical is_func
; /* function or type name? */
989 logical named
; /* tag different from text of definition? */
1000 np
= (NODE
*) malloc (sizeof (NODE
));
1003 if (!emacs_tags_format
)
1005 /* It's okay to output early in etags -- it only disrupts the
1006 * character count of the tag entries, which is no longer used
1007 * by tags.el anyway.
1009 error ("too many entries to sort");
1014 np
= xnew (1, NODE
);
1016 /* If ctags mode, change name "main" to M<thisfilename>. */
1017 if (!emacs_tags_format
&& !cxref_style
&& streq (name
, "main"))
1019 fp
= etags_rindex (curfile
, '/');
1020 name
= concat ("M", fp
== 0 ? curfile
: fp
+ 1, "");
1021 fp
= etags_rindex (name
, '.');
1022 if (fp
&& fp
[1] != '\0' && fp
[2] == '\0')
1026 np
->name
= savestr (name
);
1028 np
->is_func
= is_func
;
1031 /* UNCOMMENT THE +1 HERE: */
1032 np
->cno
= cno
/* + 1 */ ; /* our char numbers are 0-base; emacs's are 1-base */
1033 np
->left
= np
->right
= 0;
1034 if (emacs_tags_format
)
1036 c
= linestart
[linelen
];
1037 linestart
[linelen
] = 0;
1039 else if (cxref_style
== 0)
1041 sprintf (tem
, strlen (linestart
) < 50 ? "%s$" : "%.50s", linestart
);
1044 np
->pat
= savestr (linestart
);
1045 if (emacs_tags_format
)
1047 linestart
[linelen
] = c
;
1050 add_node (np
, &head
);
1055 * recurse on left children, iterate on right children.
1059 register NODE
*node
;
1063 register NODE
*node_right
= node
->right
;
1064 free_tree (node
->left
);
1067 free ((char *) node
);
1074 * Adds a node to the tree of nodes. In etags mode, we don't keep
1075 * it sorted; we just keep a linear list. In ctags mode, maintain
1076 * an ordered tree, with no attempt at balancing.
1078 * add_node is the only function allowed to add nodes, so it can
1081 /* Must avoid static vars within functions since some systems
1082 #define static as nothing. */
1083 static NODE
*last_node
= NULL
;
1086 add_node (node
, cur_node_p
)
1087 NODE
*node
, **cur_node_p
;
1090 register NODE
*cur_node
= *cur_node_p
;
1092 if (cur_node
== NULL
)
1099 if (emacs_tags_format
)
1103 fatal ("internal error in add_node");
1104 last_node
->right
= node
;
1110 dif
= strcmp (node
->name
, cur_node
->name
);
1113 * If this tag name matches an existing one, then
1114 * do not add the node, but maybe print a warning.
1118 if (node
->file
== cur_node
->file
)
1122 fprintf (stderr
, "Duplicate entry in file %s, line %d: %s\n",
1123 node
->file
, lineno
, node
->name
);
1124 fprintf (stderr
, "Second entry ignored\n");
1128 if (!cur_node
->been_warned
&& !no_warnings
)
1131 "Duplicate entry in files %s and %s: %s (Warning only)\n",
1132 node
->file
, cur_node
->file
, node
->name
);
1134 cur_node
->been_warned
= TRUE
;
1138 /* Maybe refuse to add duplicate nodes. */
1139 if (!permit_duplicates
)
1141 if (!strcmp (node
->name
, cur_node
->name
)
1142 && !strcmp (node
->file
, cur_node
->file
))
1146 /* Actually add the node */
1147 add_node (node
, dif
< 0 ? &cur_node
->left
: &cur_node
->right
);
1153 register NODE
*node
;
1160 /* Output subentries that precede this one */
1161 put_entries (node
->left
);
1163 /* Output this entry */
1165 if (emacs_tags_format
)
1169 fprintf (outf
, "%s\177%s\001%d,%d\n",
1170 node
->pat
, node
->name
,
1171 node
->lno
, node
->cno
);
1175 fprintf (outf
, "%s\177%d,%d\n",
1177 node
->lno
, node
->cno
);
1180 else if (!cxref_style
)
1182 fprintf (outf
, "%s\t%s\t",
1183 node
->name
, node
->file
);
1187 putc (searchar
, outf
);
1190 for (sp
= node
->pat
; *sp
; sp
++)
1192 if (*sp
== '\\' || *sp
== searchar
)
1196 putc (searchar
, outf
);
1199 { /* a typedef; text pattern inadequate */
1200 fprintf (outf
, "%d", node
->lno
);
1204 else if (vgrind_style
)
1205 fprintf (stdout
, "%s %s %d\n",
1206 node
->name
, node
->file
, (node
->lno
+ 63) / 64);
1208 fprintf (stdout
, "%-16s %3d %-16s %s\n",
1209 node
->name
, node
->lno
, node
->file
, node
->pat
);
1211 /* Output subentries that follow this one */
1212 put_entries (node
->right
);
1215 /* Length of a number's decimal representation. */
1223 for (; num
; num
/= 10)
1229 * Return total number of characters that put_entries will output for
1230 * the nodes in the subtree of the specified node. Works only if emacs_tags_format
1231 * is set, but called only in that case. This count is irrelevant with
1232 * the new tags.el, but is still supplied for backward compatibility.
1235 total_size_of_entries (node
)
1236 register NODE
*node
;
1244 for (; node
; node
= node
->right
)
1246 /* Count left subentries. */
1247 total
+= total_size_of_entries (node
->left
);
1249 /* Count this entry */
1250 total
+= strlen (node
->pat
) + 1;
1251 total
+= number_len ((long) node
->lno
) + 1 + number_len (node
->cno
) + 1;
1253 total
+= 1 + strlen (node
->name
); /* \001name */
1260 * The C symbol tables.
1263 Stab
*C_stab
, *C_PLPL_stab
, *C_STAR_stab
;
1267 * Stab *get_C_stab (int c_ext);
1269 #define get_C_stab(c_ext) ((c_ext & C_STAR) ? C_STAR_stab : \
1270 (c_ext & C_PLPL) ? C_PLPL_stab : \
1274 add_keyword (stab
, sym
, type
)
1279 stab_search (stab
, sym
, strlen (sym
))->type
= type
;
1283 C_create_stab (c_ext
)
1288 stab
= stab_create ();
1292 add_keyword (stab
, "class", st_C_struct
);
1294 add_keyword (stab
, "domain", st_C_struct
);
1295 add_keyword (stab
, "union", st_C_struct
);
1296 add_keyword (stab
, "struct", st_C_struct
);
1297 add_keyword (stab
, "enum", st_C_enum
);
1298 add_keyword (stab
, "typedef", st_C_typedef
);
1299 add_keyword (stab
, "define", st_C_define
);
1300 add_keyword (stab
, "long", st_C_typespec
);
1301 add_keyword (stab
, "short", st_C_typespec
);
1302 add_keyword (stab
, "int", st_C_typespec
);
1303 add_keyword (stab
, "char", st_C_typespec
);
1304 add_keyword (stab
, "float", st_C_typespec
);
1305 add_keyword (stab
, "double", st_C_typespec
);
1306 add_keyword (stab
, "signed", st_C_typespec
);
1307 add_keyword (stab
, "unsigned", st_C_typespec
);
1308 add_keyword (stab
, "auto", st_C_typespec
);
1309 add_keyword (stab
, "void", st_C_typespec
);
1310 add_keyword (stab
, "extern", st_C_typespec
);
1311 add_keyword (stab
, "static", st_C_typespec
);
1312 add_keyword (stab
, "const", st_C_typespec
);
1313 add_keyword (stab
, "volatile", st_C_typespec
);
1321 C_stab
= C_create_stab (0);
1322 C_PLPL_stab
= C_create_stab (C_PLPL
);
1323 C_STAR_stab
= C_create_stab (C_STAR
| C_PLPL
);
1327 * C functions are recognized using a simple finite automaton.
1328 * funcdef is its state variable.
1332 fnone
, /* nothing seen */
1333 ftagseen
, /* function-like tag seen */
1334 finlist
, /* in parameter list */
1335 flistseen
, /* after parameter list */
1336 fignore
, /* before open brace */
1341 /* typedefs are recognized using a simple finite automaton.
1342 * typeddef is its state variable.
1346 tnone
, /* nothing seen */
1347 ttypedseen
, /* typedef keyword seen */
1348 tinbody
, /* inside typedef body */
1349 tend
, /* just before typedef tag */
1354 /* struct tags for C++ are recognized using another simple
1355 * finite automaton. `structdef' is its state variable.
1356 * This machinery is only invoked for C++; otherwise structdef
1357 * should remain snone. However, this machinery can easily be
1358 * adapted to find structure tags in normal C code.
1362 snone
, /* nothing seen yet */
1363 skeyseen
, /* struct-like keyword seen */
1364 stagseen
, /* struct-like tag seen */
1365 scolonseen
, /* colon seen after struct-like tag */
1366 sinbody
, /* in struct body: recognize member func defs*/
1370 * When structdef is stagseen, scolonseen, or sinbody, structtag is the
1371 * struct tag, and structkey is the preceding struct-like keyword.
1373 char structtag
[BUFSIZ
];
1374 Stab_entry
*structkey
;
1377 * Yet another little state machine to deal with preprocessor lines.
1381 dnone
, /* nothing seen */
1382 dsharpseen
, /* '#' seen as first char on line */
1383 ddefineseen
, /* '#' and 'define' seen */
1384 dignorerest
, /* ignore rest of line */
1389 * Set this to TRUE, and the next token considered is called a function.
1390 * Used only for GNUmacs's function-defining macros.
1392 logical next_token_is_func
;
1395 * TRUE in the rules part of a yacc file, FALSE outside (parse as C).
1401 * This routine finds functions, typedefs, #define's and
1402 * struct/union/enum definitions in C syntax and adds them
1406 #define curlb (lbs[curndx].lb)
1407 #define othlb (lbs[1-curndx].lb)
1408 #define newlb (lbs[newndx].lb)
1409 #define curlinepos (lbs[curndx].linepos)
1410 #define othlinepos (lbs[1-curndx].linepos)
1411 #define newlinepos (lbs[newndx].linepos)
1413 #define CNL_SAVE_DEFINEDEF \
1415 SET_FILEPOS (curlinepos, inf, charno); \
1417 charno += readline (&curlb, inf); \
1418 lp = curlb.buffer; \
1425 CNL_SAVE_DEFINEDEF; \
1426 definedef = dnone; \
1429 #define MAKE_TAG_FROM_NEW_LB(isfun) pfnote (nameb, isfun, tok.named, \
1430 newlb.buffer, tokoff + toklen + 1, tok.lineno, GET_CHARNO (newlinepos))
1431 #define MAKE_TAG_FROM_OTH_LB(isfun) pfnote (nameb, isfun, tok.named, \
1432 othlb.buffer, tokoff + toklen + 1, tok.lineno, GET_CHARNO (othlinepos))
1436 int c_ext
; /* extension of C? */
1438 register char c
; /* latest char read; '\0' for end of line */
1439 register char *lp
; /* pointer one beyond the character `c' */
1440 int curndx
, newndx
; /* indices for current and new lb */
1441 TOKEN tok
; /* latest token read for funcdef & structdef */
1442 char nameb
[BUFSIZ
]; /* latest token name for funcdef & structdef */
1443 register int tokoff
; /* offset in line of start of latest token */
1444 register int toklen
; /* length of latest token */
1445 int cblev
; /* current curly brace level */
1446 logical incomm
, inquote
, inchar
, quotednl
, midtoken
;
1449 curndx
= newndx
= 0;
1455 definedef
= dnone
; funcdef
= fnone
; typdef
= tnone
; structdef
= snone
;
1456 next_token_is_func
= yacc_rules
= FALSE
;
1457 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
1459 cplpl
= c_ext
& C_PLPL
;
1468 /* If we're at the end of the line, the next character is a
1469 '\0'; don't skip it, because it's the thing that tells us
1470 to read the next line. */
1491 /* Newlines inside comments do not end macro definitions in
1506 /* Newlines inside strings, do not end macro definitions
1507 in traditional cpp, even though compilers don't
1508 usually accept them. */
1536 else if (cplpl
&& *lp
== '/')
1543 if ((c_ext
& YACC
) && *lp
== '%')
1545 /* entering or exiting rules section in yacc file */
1547 definedef
= dnone
; funcdef
= fnone
;
1548 typdef
= tnone
; structdef
= snone
;
1549 next_token_is_func
= FALSE
;
1550 midtoken
= inquote
= inchar
= incomm
= quotednl
= FALSE
;
1552 yacc_rules
= !yacc_rules
;
1556 if (lp
== newlb
.buffer
+ 1 && definedef
== dnone
)
1557 definedef
= dsharpseen
;
1562 /* Consider token only if some complicated conditions are satisfied. */
1563 if (((cblev
== 0 && structdef
!= scolonseen
)
1564 || (cblev
== 1 && cplpl
&& structdef
== sinbody
))
1565 && definedef
!= dignorerest
1566 && funcdef
!= finlist
)
1572 if (cplpl
&& c
== ':' && *lp
== ':' && intoken (*(lp
+ 1)))
1575 * This handles :: in the middle, but not at beginning
1583 logical is_func
= FALSE
;
1585 tok
.lineno
= lineno
;
1586 tok
.p
= newlb
.buffer
+ tokoff
;
1590 || consider_token (c
, lp
, &tok
,
1591 c_ext
, cblev
, &is_func
))
1593 if (structdef
== sinbody
1594 && definedef
== dnone
1596 /* function defined in C++ class body */
1599 sprintf (nameb
, "%s::%.*s",
1600 ((structtag
[0] == '\0')
1601 ? "_anonymous_" : structtag
),
1606 sprintf (nameb
, "%.*s", tok
.len
, tok
.p
);
1609 if (structdef
== stagseen
1613 if (funcdef
== ftagseen
1614 || structdef
== stagseen
1617 if (newndx
== curndx
)
1618 curndx
= 1 - curndx
; /* switch line buffers */
1621 MAKE_TAG_FROM_NEW_LB (is_func
);
1625 } /* if (endtoken (c)) */
1626 else if (intoken (c
))
1631 } /* if (midtoken) */
1632 else if (begtoken (c
))
1637 MAKE_TAG_FROM_OTH_LB (TRUE
);
1644 if (structdef
== stagseen
)
1646 if (!yacc_rules
|| lp
== newlb
.buffer
+ 1)
1648 tokoff
= lp
- 1 - newlb
.buffer
;
1654 } /* if must look at token */
1657 /* Detect end of line, colon, comma, semicolon and various braces
1658 after having handled the last token on the line.*/
1662 if (structdef
== stagseen
)
1663 structdef
= scolonseen
;
1664 else if (yacc_rules
&& funcdef
== ftagseen
)
1666 MAKE_TAG_FROM_OTH_LB (FALSE
);
1671 if (cblev
== 0 && typdef
== tend
)
1674 MAKE_TAG_FROM_OTH_LB (FALSE
);
1676 if (funcdef
!= fignore
)
1682 if (funcdef
!= finlist
&& funcdef
!= fignore
)
1684 if (structdef
== stagseen
)
1700 if (funcdef
== finlist
)
1701 funcdef
= flistseen
;
1704 if (typdef
== ttypedseen
)
1708 case skeyseen
: /* unnamed struct */
1709 structtag
[0] = '\0';
1710 structdef
= sinbody
;
1713 case scolonseen
: /* named struct */
1714 structdef
= sinbody
;
1715 MAKE_TAG_FROM_OTH_LB (FALSE
);
1721 MAKE_TAG_FROM_OTH_LB (TRUE
);
1729 if (funcdef
== flistseen
)
1731 MAKE_TAG_FROM_OTH_LB (TRUE
);
1736 if (!noindentypedefs
&& lp
== newlb
.buffer
+ 1)
1737 cblev
= 0; /* reset curly brace level if first column */
1742 if (typdef
== tinbody
)
1745 (void) strcpy (structtag
, "<error 2>");
1749 /* If a macro spans multiple lines don't reset its state. */
1757 } /* while not eof */
1762 * checks to see if the current token is at the start of a
1763 * function, or corresponds to a typedef, or is a struct/union/enum
1766 * *IS_FUNC gets TRUE iff the token is a function or macro with args.
1767 * C_EXT is which language we are looking at.
1769 * In the future we will need some way to adjust where the end of
1770 * the token is; for instance, implementing the C++ keyword
1771 * `operator' properly will adjust the end of the token to be after
1772 * whatever follows `operator'.
1779 * next_token_is_func IN OUT
1783 consider_token (c
, lp
, tokp
, c_ext
, cblev
, is_func
)
1784 register char c
; /* IN: first char after the token */
1785 register char *lp
; /* IN: lp points to 2nd char after the token */
1786 register TOKEN
*tokp
; /* IN: token pointer */
1787 int c_ext
; /* IN: C extensions mask */
1788 int cblev
; /* IN: curly brace level */
1789 logical
*is_func
; /* OUT */
1791 Stab_entry
*tokse
= stab_find (get_C_stab (c_ext
), tokp
->p
, tokp
->len
);
1792 enum sym_type toktype
= stab_type (tokse
);
1795 * Advance the definedef state machine.
1800 /* We're not on a preprocessor line. */
1803 if (toktype
== st_C_define
)
1805 definedef
= ddefineseen
;
1809 definedef
= dignorerest
;
1814 * Make a tag for any macro.
1816 definedef
= dignorerest
;
1817 *is_func
= (c
== '(');
1818 if (!*is_func
&& !constantypedefs
)
1825 error ("internal error: definedef value");
1834 if (toktype
== st_C_typedef
)
1837 typdef
= ttypedseen
;
1852 /* Do not return here, so the structdef stuff has a chance. */
1866 * This structdef business is currently only invoked when cblev==0.
1867 * It should be recursively invoked whatever the curly brace level,
1868 * and a stack of states kept, to allow for definitions of structs
1871 * This structdef business is NOT invoked when we are ctags and the
1872 * file is plain C. This is because a struct tag may have the same
1873 * name as another tag, and this loses with ctags.
1875 * This if statement deals with the typdef state machine as
1876 * follows: if typdef==ttypedseen and token is struct/union/class/enum,
1877 * return (FALSE). All the other code here is for the structdef
1884 if (typdef
== ttypedseen
1885 || (typedefs_and_cplusplus
&& cblev
== 0 && structdef
== snone
))
1887 structdef
= skeyseen
;
1892 if (structdef
== skeyseen
)
1894 if (stab_type (structkey
) == st_C_struct
)
1896 (void) strncpy (structtag
, tokp
->p
, tokp
->len
);
1897 structtag
[tokp
->len
] = '\0'; /* for struct/union/class */
1901 structtag
[0] = '\0'; /* for enum (why is it treated differently?) */
1903 structdef
= stagseen
;
1907 /* Avoid entering funcdef stuff if typdef is going on. */
1908 if (typdef
!= tnone
)
1914 /* Detect GNUmacs's function-defining macros. */
1915 if (definedef
== dnone
)
1917 if (strneq (tokp
->p
, "DEF", 3)
1918 || strneq (tokp
->p
, "ENTRY", 5)
1919 || strneq (tokp
->p
, "SYSCALL", 7)
1920 || strneq (tokp
->p
, "PSEUDO", 6))
1922 next_token_is_func
= TRUE
;
1925 if (strneq (tokp
->p
, "EXFUN", 5))
1927 next_token_is_func
= FALSE
;
1931 if (next_token_is_func
)
1933 next_token_is_func
= FALSE
;
1935 *is_func
= TRUE
; /* to force search string in ctags */
1943 funcdef
= fnone
; /* should be useless */
1946 if (funcdef
== fnone
)
1957 /* Fortran parsing */
1973 linecharno
= charno
;
1974 charno
+= readline (&lb
, fi
);
1977 dbp
++; /* Ratfor escape to fortran */
1978 while (isspace (*dbp
))
1985 if (tail ("integer"))
1993 if (tail ("logical"))
1997 if (tail ("complex") || tail ("character"))
2001 if (tail ("double"))
2003 while (isspace (*dbp
))
2007 if (tail ("precision"))
2013 while (isspace (*dbp
))
2020 if (tail ("function"))
2024 if (tail ("subroutine"))
2032 if (tail ("program"))
2037 if (tail ("procedure"))
2049 register int len
= 0;
2051 while (*cp
&& (*cp
& ~' ') == ((*(dbp
+ len
)) & ~' '))
2064 while (isspace (*dbp
))
2069 while (isspace (*dbp
))
2071 if (!isdigit (*dbp
))
2073 --dbp
; /* force failure */
2078 while (isdigit (*dbp
));
2086 char nambuf
[BUFSIZ
];
2088 while (isspace (*dbp
))
2095 for (cp
= dbp
+ 1; *cp
&& (isalpha (*cp
) || isdigit (*cp
)
2096 || (*cp
== '_') || (*cp
== '$')); cp
++)
2100 (void) strcpy (nambuf
, dbp
);
2102 pfnote (nambuf
, TRUE
, FALSE
, lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
2106 /* Handle a file of assembler code. */
2122 linecharno
= charno
;
2123 charno
+= readline (&lb
, fi
);
2126 for (i
= 0; ((c
= dbp
[i
]) && !isspace (c
)) && (c
!= ':'); i
++)
2129 if ((i
> 0) && (c
== ':'))
2134 /* Added by Mosur Mohan, 4/22/88 */
2135 /* Pascal parsing */
2137 #define GET_NEW_LINE \
2139 linecharno = charno; lineno++; \
2140 charno += 1 + readline (&lb, inf); \
2144 /* Locates tags for procedures & functions.
2145 * Doesn't do any type- or var-definitions.
2146 * It does look for the keyword "extern" or "forward"
2147 * immediately following the procedure statement;
2148 * if found, the tag is skipped.
2155 struct linebuffer tline
; /* mostly copied from C_entries */
2159 char nambuf
[BUFSIZ
];
2161 logical
/* each of these flags is TRUE iff: */
2162 incomm1
, /* point is inside {..} comment */
2163 incomm2
, /* point is inside (*..*) comment */
2164 inquote
, /* point is inside '..' string */
2165 get_tagname
, /* point is after PROCEDURE/FUNCTION */
2166 /* keyword, so next item = potential tag */
2167 found_tag
, /* point is after a potential tag */
2168 inparms
, /* point is within parameter-list */
2169 verify_tag
; /* point has passed the parm-list, so the */
2170 /* next token will determine whether */
2171 /* this is a FORWARD/EXTERN to be */
2172 /* ignored, or whether it is a real tag */
2178 initbuffer (&tline
);
2180 incomm1
= incomm2
= inquote
= FALSE
;
2181 found_tag
= FALSE
; /* have a proc name; check if extern */
2182 get_tagname
= FALSE
; /* have found "procedure" keyword */
2183 inparms
= FALSE
; /* found '(' after "proc" */
2184 verify_tag
= FALSE
; /* check if "extern" is ahead */
2186 /* long main loop to get next char */
2190 if (c
== 0) /* if end of line */
2195 if (!((found_tag
&& verify_tag
) ||
2197 c
= *dbp
++; /* only if don't need *dbp pointing */
2198 /* to the beginning of the name of */
2199 /* the procedure or function */
2201 if (incomm1
) /* within { - } comments */
2207 else if (incomm2
) /* within (* - *) comments */
2211 while ((c
= *dbp
++) == '*')
2230 inquote
= TRUE
; /* found first quote */
2232 case '{': /* found open-{-comment */
2236 if (*dbp
== '*') /* found open-(*-comment */
2241 else if (found_tag
) /* found '(' after tag, i.e., parm-list */
2244 case ')': /* end of parms list */
2249 if ((found_tag
) && (!inparms
)) /* end of proc or fn stmt */
2256 if ((found_tag
) && (verify_tag
) && (*dbp
!= ' '))
2258 /* check if this is an "extern" declaration */
2261 if ((*dbp
== 'e') || (*dbp
== 'E'))
2263 if (tail ("extern")) /* superfluous, really! */
2269 else if ((*dbp
== 'f') || (*dbp
== 'F'))
2271 if (tail ("forward")) /* check for forward reference */
2277 if ((found_tag
) && (verify_tag
)) /* not external proc, so make tag */
2281 pfnote (nambuf
, TRUE
, FALSE
,
2282 tline
.buffer
, cp
- tline
.buffer
+ 1,
2283 save_lineno
, save_lcno
);
2287 if (get_tagname
) /* grab name of proc or fn */
2292 /* save all values for later tagging */
2293 tline
.size
= lb
.size
;
2294 strcpy (tline
.buffer
, lb
.buffer
);
2295 save_lineno
= lineno
;
2296 save_lcno
= linecharno
;
2298 /* grab block name */
2299 for (cp
= dbp
+ 1; *cp
&& (!endtoken (*cp
)); cp
++)
2303 strcpy (nambuf
, dbp
);
2305 dbp
= cp
; /* restore dbp to e-o-token */
2306 get_tagname
= FALSE
;
2310 /* and proceed to check for "extern" */
2312 if ((!incomm1
) && (!incomm2
) && (!inquote
) &&
2313 (!found_tag
) && (!get_tagname
))
2315 /* check for proc/fn keywords */
2319 if (tail ("rocedure")) /* c = 'p', dbp has advanced */
2323 if (tail ("unction"))
2328 } /* while not e-o-f */
2332 * lisp tag functions
2333 * just look for (def or (DEF
2347 linecharno
= charno
;
2348 charno
+= readline (&lb
, fi
);
2354 while (!isspace (*dbp
))
2356 while (isspace (*dbp
))
2362 /* Check for (foo::defmumble name-defined ... */
2365 while (*dbp
&& !isspace (*dbp
)
2366 && *dbp
!= ':' && *dbp
!= '(' && *dbp
!= ')');
2371 while (*dbp
== ':');
2373 if (L_isdef (dbp
- 1))
2375 while (!isspace (*dbp
))
2377 while (isspace (*dbp
))
2391 return ((dbp
[1] == 'd' || dbp
[1] == 'D')
2392 && (dbp
[2] == 'e' || dbp
[2] == 'E')
2393 && (dbp
[3] == 'f' || dbp
[3] == 'F'));
2400 return ((*(++dbp
) == 'q' || *dbp
== 'Q')
2401 && (*(++dbp
) == 'u' || *dbp
== 'U')
2402 && (*(++dbp
) == 'o' || *dbp
== 'O')
2403 && (*(++dbp
) == 't' || *dbp
== 'T')
2404 && (*(++dbp
) == 'e' || *dbp
== 'E')
2405 && isspace(*(++dbp
)));
2413 char nambuf
[BUFSIZ
];
2415 if (*dbp
== '\'') /* Skip prefix quote */
2417 else if (*dbp
== '(' && L_isquote (dbp
)) /* Skip "(quote " */
2420 while (isspace(*dbp
))
2423 for (cp
= dbp
/*+1*/; *cp
&& *cp
!= '(' && *cp
!= ' ' && *cp
!= ')'; cp
++)
2430 (void) strcpy (nambuf
, dbp
);
2432 pfnote (nambuf
, TRUE
, FALSE
, lb
.buffer
,
2433 cp
- lb
.buffer
+ 1, lineno
, linecharno
);
2438 * Scheme tag functions
2439 * look for (def... xyzzy
2440 * look for (def... (xyzzy
2441 * look for (def ... ((...(xyzzy ....
2442 * look for (set! xyzzy
2445 static void get_scheme ();
2458 linecharno
= charno
;
2459 charno
+= readline (&lb
, fi
);
2461 if (dbp
[0] == '(' &&
2462 (dbp
[1] == 'D' || dbp
[1] == 'd') &&
2463 (dbp
[2] == 'E' || dbp
[2] == 'e') &&
2464 (dbp
[3] == 'F' || dbp
[3] == 'f'))
2466 while (!isspace (*dbp
))
2468 /* Skip over open parens and white space */
2469 while (*dbp
&& (isspace (*dbp
) || *dbp
== '('))
2473 if (dbp
[0] == '(' &&
2474 (dbp
[1] == 'S' || dbp
[1] == 's') &&
2475 (dbp
[2] == 'E' || dbp
[2] == 'e') &&
2476 (dbp
[3] == 'T' || dbp
[3] == 't') &&
2477 (dbp
[4] == '!' || dbp
[4] == '!') &&
2480 while (!isspace (*dbp
))
2482 /* Skip over white space */
2483 while (isspace (*dbp
))
2495 char nambuf
[BUFSIZ
];
2499 /* Go till you get to white space or a syntactic break */
2500 for (cp
= dbp
+ 1; *cp
&& *cp
!= '(' && *cp
!= ')' && !isspace (*cp
); cp
++)
2502 /* Null terminate the string there. */
2505 /* Copy the string */
2506 strcpy (nambuf
, dbp
);
2507 /* Unterminate the string */
2509 /* Announce the change */
2510 pfnote (nambuf
, TRUE
, FALSE
, lb
.buffer
, cp
- lb
.buffer
+ 1, lineno
, linecharno
);
2514 /* Find tags in TeX and LaTeX input files. */
2516 /* TEX_toktab is a table of TeX control sequences that define tags.
2517 Each TEX_tabent records one such control sequence.
2518 CONVERT THIS TO USE THE Stab TYPE!! */
2526 struct TEX_tabent
*TEX_toktab
= NULL
; /* Table with tag tokens */
2528 /* Default set of control sequences to put into TEX_toktab.
2529 The value of environment var TEXTAGS is prepended to this. */
2531 static char *TEX_defenv
=
2532 ":chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem:typeout";
2535 struct TEX_tabent
*TEX_decode_env ();
2539 static char TEX_esc
= '\\';
2540 static char TEX_opgrp
= '{';
2541 static char TEX_clgrp
= '}';
2544 * TeX/LaTeX scanning loop.
2557 /* Select either \ or ! as escape character. */
2560 /* Initialize token table once from environment. */
2562 TEX_toktab
= TEX_decode_env ("TEXTAGS", TEX_defenv
);
2565 { /* Scan each line in file */
2567 linecharno
= charno
;
2568 charno
+= readline (&lb
, fi
);
2571 while (dbp
= etags_index (dbp
, TEX_esc
)) /* Look at each escape in line */
2577 linecharno
+= dbp
- lasthit
;
2579 i
= TEX_Token (lasthit
);
2582 TEX_getit (lasthit
, TEX_toktab
[i
].len
);
2583 break; /* We only save a line once */
2589 #define TEX_LESC '\\'
2590 #define TEX_SESC '!'
2593 /* Figure out whether TeX's escapechar is '\\' or '!' and set grouping */
2594 /* chars accordingly. */
2602 while ((c
= getc (f
)) != EOF
)
2604 /* Skip to next line if we hit the TeX comment char. */
2608 else if (c
== TEX_LESC
|| c
== TEX_SESC
)
2627 /* Read environment and prepend it to the default string. */
2628 /* Build token table. */
2631 TEX_decode_env (evarname
, defenv
)
2635 register char *env
, *p
;
2637 struct TEX_tabent
*tab
;
2640 /* Append default string to environment. */
2641 env
= getenv (evarname
);
2645 env
= concat (env
, defenv
, "");
2647 /* Allocate a token table */
2648 for (size
= 1, p
= env
; p
;)
2649 if ((p
= etags_index (p
, ':')) && *(++p
))
2651 /* Add 1 to leave room for null terminator. */
2652 tab
= xnew (size
+ 1, struct TEX_tabent
);
2654 /* Unpack environment string into token table. Be careful about */
2655 /* zero-length strings (leading ':', "::" and trailing ':') */
2658 p
= etags_index (env
, ':');
2659 if (!p
) /* End of environment string. */
2660 p
= env
+ strlen (env
);
2662 { /* Only non-zero strings. */
2663 tab
[i
].name
= savenstr (env
, p
- env
);
2664 tab
[i
].len
= strlen (tab
[i
].name
);
2671 tab
[i
].name
= NULL
; /* Mark end of table. */
2679 /* Record a tag defined by a TeX command of length LEN and starting at NAME.
2680 The name being defined actually starts at (NAME + LEN + 1).
2681 But we seem to include the TeX command in the tag name. */
2684 TEX_getit (name
, len
)
2688 char *p
= name
+ len
;
2689 char nambuf
[BUFSIZ
];
2694 /* Let tag name extend to next group close (or end of line) */
2695 while (*p
&& *p
!= TEX_clgrp
)
2697 (void) strncpy (nambuf
, name
, p
- name
);
2698 nambuf
[p
- name
] = 0;
2700 pfnote (nambuf
, TRUE
, FALSE
, lb
.buffer
, strlen (lb
.buffer
), lineno
, linecharno
);
2704 /* If the text at CP matches one of the tag-defining TeX command names,
2705 return the etags_index of that command in TEX_toktab.
2706 Otherwise return -1. */
2708 /* Keep the capital `T' in `Token' for dumb truncating compilers
2709 (this distinguishes it from `TEX_toktab' */
2716 for (i
= 0; TEX_toktab
[i
].len
> 0; i
++)
2717 if (strncmp (TEX_toktab
[i
].name
, cp
, TEX_toktab
[i
].len
) == 0)
2722 /* Support for Prolog. */
2724 /* whole head (not only functor, but also arguments)
2725 is gotten in compound term. */
2728 prolog_getit (s
, lineno
, linecharno
)
2733 char nambuf
[BUFSIZ
], *save_s
, tmpc
;
2741 if (*s
== '\0') /* syntax error. */
2743 else if (insquote
&& *s
== '\'' && *(s
+ 1) == '\'')
2745 else if (*s
== '\'')
2747 insquote
= !insquote
;
2750 else if (!insquote
&& *s
== '(')
2755 else if (!insquote
&& *s
== ')')
2761 else if (npar
< 0) /* syntax error. */
2764 else if (!insquote
&& *s
== '.' && (isspace (*(s
+ 1)) || *(s
+ 1) == '\0'))
2766 if (npar
!= 0) /* syntax error. */
2776 strcpy (nambuf
, save_s
);
2778 pfnote (nambuf
, TRUE
, FALSE
, save_s
, strlen (nambuf
), lineno
, linecharno
);
2781 /* It is assumed that prolog predicate starts from column 0. */
2787 void skip_comment (), prolog_getit ();
2789 lineno
= linecharno
= charno
= 0;
2793 linecharno
+= charno
;
2794 charno
= readline (&lb
, fi
) + 1; /* 1 for newline. */
2796 if (isspace (dbp
[0])) /* not predicate header. */
2798 else if (dbp
[0] == '%') /* comment. */
2800 else if (dbp
[0] == '/' && dbp
[1] == '*') /* comment. */
2801 skip_comment (&lb
, fi
, &lineno
, &linecharno
);
2803 prolog_getit (dbp
, lineno
, linecharno
);
2808 skip_comment (plb
, fi
, plineno
, plinecharno
)
2809 struct linebuffer
*plb
;
2811 int *plineno
; /* result */
2812 long *plinecharno
; /* result */
2814 while (!substr ("*/", plb
->buffer
))
2817 *plinecharno
+= readline (plb
, fi
) + 1;
2818 } /* 1 for newline. */
2821 /* Return TRUE if 'sub' exists somewhere in 's'. */
2828 while (*s
&& (s
= etags_index (s
, *sub
)))
2829 if (prestr (sub
, s
))
2836 /* Return TRUE if 'pre' is prefix of string 's'. */
2845 else if (*pre
== *s
)
2846 return (prestr (pre
+ 1, s
+ 1));
2851 /* Initialize a linebuffer for use */
2854 initbuffer (linebuffer
)
2855 struct linebuffer
*linebuffer
;
2857 linebuffer
->size
= 200;
2858 linebuffer
->buffer
= xnew (200, char);
2862 * Read a line of text from `stream' into `linebuffer'.
2863 * Return the number of characters read from `stream',
2864 * which is the length of the line including the newline, if any.
2867 readline (linebuffer
, stream
)
2868 struct linebuffer
*linebuffer
;
2869 register FILE *stream
;
2871 char *buffer
= linebuffer
->buffer
;
2872 register char *p
= linebuffer
->buffer
;
2873 register char *pend
;
2874 int newline
; /* 1 if ended with newline, 0 if ended with EOF */
2876 pend
= p
+ linebuffer
->size
; /* Separate to avoid 386/IX compiler bug. */
2880 register int c
= getc (stream
);
2883 linebuffer
->size
*= 2;
2884 buffer
= (char *) xrealloc (buffer
, linebuffer
->size
);
2885 p
+= buffer
- linebuffer
->buffer
;
2886 pend
= buffer
+ linebuffer
->size
;
2887 linebuffer
->buffer
= buffer
;
2889 if (c
< 0 || c
== '\n')
2892 newline
= (c
== '\n' ? 1 : 0);
2898 return p
- buffer
+ newline
;
2905 return savenstr (cp
, strlen (cp
));
2915 dp
= xnew (len
+ 1, char);
2916 (void) strncpy (dp
, cp
, len
);
2922 * Return the ptr in sp at which the character c last
2923 * appears; NULL if not found
2925 * Identical to v7 rindex, included for portability.
2929 etags_rindex (sp
, c
)
2930 register char *sp
, c
;
2945 * Return the ptr in sp at which the character c first
2946 * appears; NULL if not found
2948 * Identical to v7 index, included for portability.
2953 register char *sp
, c
;
2963 /* Print error message and exit. */
2974 /* Print error message. `s1' is printf control string, `s2' is arg for it. */
2981 fprintf (stderr
, "%s: ", progname
);
2982 fprintf (stderr
, s1
, s2
);
2983 fprintf (stderr
, "\n");
2986 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */
2992 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
2993 char *result
= xnew (len1
+ len2
+ len3
+ 1, char);
2995 (void) strcpy (result
, s1
);
2996 (void) strcpy (result
+ len1
, s2
);
2997 (void) strcpy (result
+ len1
+ len2
, s3
);
2998 *(result
+ len1
+ len2
+ len3
) = 0;
3003 /* Like malloc but get fatal error if memory is exhausted. */
3009 char *result
= malloc (size
);
3011 fatal ("virtual memory exhausted", 0);
3016 xrealloc (ptr
, size
)
3020 char *result
= realloc (ptr
, size
);
3022 fatal ("virtual memory exhausted");