HCoop / bpt / emacs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge from emacs--rel--22
[bpt/emacs.git] / lib-src / ebrowse.c
1 /* ebrowse.c --- parsing files for the ebrowse C++ browser
2
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
6
7 This file is part of GNU Emacs.
8
9 GNU Emacs is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GNU Emacs is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GNU Emacs; see the file COPYING. If not, write to the
21 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <stdio.h>
29
30 #ifdef HAVE_STDLIB_H
31 #include <stdlib.h>
32 #endif
33
34 #ifdef HAVE_STRING_H
35 #include <string.h>
36 #endif
37
38 #include <ctype.h>
39 #include <assert.h>
40 #include "getopt.h"
41
42 /* The SunOS compiler doesn't have SEEK_END. */
43 #ifndef SEEK_END
44 #define SEEK_END 2
45 #endif
46
47 /* Conditionalize function prototypes. */
48
49 #ifdef PROTOTYPES /* From config.h. */
50 #define P_(x) x
51 #else
52 #define P_(x) ()
53 #endif
54
55 /* Value is non-zero if strings X and Y compare equal. */
56
57 #define streq(X, Y) (*(X) == *(Y) && strcmp ((X) + 1, (Y) + 1) == 0)
58
59 /* The ubiquitous `max' and `min' macros. */
60
61 #ifndef max
62 #define max(X, Y) ((X) > (Y) ? (X) : (Y))
63 #define min(X, Y) ((X) < (Y) ? (X) : (Y))
64 #endif
65
66 /* Files are read in chunks of this number of bytes. */
67
68 #define READ_CHUNK_SIZE (100 * 1024)
69
70 /* The character used as a separator in path lists (like $PATH). */
71
72 #if defined(__MSDOS__)
73 #define PATH_LIST_SEPARATOR ';'
74 #define FILENAME_EQ(X,Y) (strcasecmp(X,Y) == 0)
75 #else
76 #if defined(WINDOWSNT)
77 #define PATH_LIST_SEPARATOR ';'
78 #define FILENAME_EQ(X,Y) (stricmp(X,Y) == 0)
79 #else
80 #define PATH_LIST_SEPARATOR ':'
81 #define FILENAME_EQ(X,Y) (streq(X,Y))
82 #endif
83 #endif
84 /* The default output file name. */
85
86 #define DEFAULT_OUTFILE "BROWSE"
87
88 /* A version string written to the output file. Change this whenever
89 the structure of the output file changes. */
90
91 #define EBROWSE_FILE_VERSION "ebrowse 5.0"
92
93 /* The output file consists of a tree of Lisp objects, with major
94 nodes built out of Lisp structures. These are the heads of the
95 Lisp structs with symbols identifying their type. */
96
97 #define TREE_HEADER_STRUCT "[ebrowse-hs "
98 #define TREE_STRUCT "[ebrowse-ts "
99 #define MEMBER_STRUCT "[ebrowse-ms "
100 #define BROWSE_STRUCT "[ebrowse-bs "
101 #define CLASS_STRUCT "[ebrowse-cs "
102
103 /* The name of the symbol table entry for global functions, variables,
104 defines etc. This name also appears in the browser display. */
105
106 #define GLOBALS_NAME "*Globals*"
107
108 /* Token definitions. */
109
110 enum token
111 {
112 YYEOF = 0, /* end of file */
113 CSTRING = 256, /* string constant */
114 CCHAR, /* character constant */
115 CINT, /* integral constant */
116 CFLOAT, /* real constant */
117
118 ELLIPSIS, /* ... */
119 LSHIFTASGN, /* <<= */
120 RSHIFTASGN, /* >>= */
121 ARROWSTAR, /* ->* */
122 IDENT, /* identifier */
123 DIVASGN, /* /= */
124 INC, /* ++ */
125 ADDASGN, /* += */
126 DEC, /* -- */
127 ARROW, /* -> */
128 SUBASGN, /* -= */
129 MULASGN, /* *= */
130 MODASGN, /* %= */
131 LOR, /* || */
132 ORASGN, /* |= */
133 LAND, /* && */
134 ANDASGN, /* &= */
135 XORASGN, /* ^= */
136 POINTSTAR, /* .* */
137 DCOLON, /* :: */
138 EQ, /* == */
139 NE, /* != */
140 LE, /* <= */
141 LSHIFT, /* << */
142 GE, /* >= */
143 RSHIFT, /* >> */
144
145 /* Keywords. The undef's are there because these
146 three symbols are very likely to be defined somewhere. */
147 #undef BOOL
148 #undef TRUE
149 #undef FALSE
150
151 ASM, /* asm */
152 AUTO, /* auto */
153 BREAK, /* break */
154 CASE, /* case */
155 CATCH, /* catch */
156 CHAR, /* char */
157 CLASS, /* class */
158 CONST, /* const */
159 CONTINUE, /* continue */
160 DEFAULT, /* default */
161 DELETE, /* delete */
162 DO, /* do */
163 DOUBLE, /* double */
164 ELSE, /* else */
165 ENUM, /* enum */
166 EXTERN, /* extern */
167 FLOAT, /* float */
168 FOR, /* for */
169 FRIEND, /* friend */
170 GOTO, /* goto */
171 IF, /* if */
172 T_INLINE, /* inline */
173 INT, /* int */
174 LONG, /* long */
175 NEW, /* new */
176 OPERATOR, /* operator */
177 PRIVATE, /* private */
178 PROTECTED, /* protected */
179 PUBLIC, /* public */
180 REGISTER, /* register */
181 RETURN, /* return */
182 SHORT, /* short */
183 SIGNED, /* signed */
184 SIZEOF, /* sizeof */
185 STATIC, /* static */
186 STRUCT, /* struct */
187 SWITCH, /* switch */
188 TEMPLATE, /* template */
189 THIS, /* this */
190 THROW, /* throw */
191 TRY, /* try */
192 TYPEDEF, /* typedef */
193 UNION, /* union */
194 UNSIGNED, /* unsigned */
195 VIRTUAL, /* virtual */
196 VOID, /* void */
197 VOLATILE, /* volatile */
198 WHILE, /* while */
199 MUTABLE, /* mutable */
200 BOOL, /* bool */
201 TRUE, /* true */
202 FALSE, /* false */
203 SIGNATURE, /* signature (GNU extension) */
204 NAMESPACE, /* namespace */
205 EXPLICIT, /* explicit */
206 TYPENAME, /* typename */
207 CONST_CAST, /* const_cast */
208 DYNAMIC_CAST, /* dynamic_cast */
209 REINTERPRET_CAST, /* reinterpret_cast */
210 STATIC_CAST, /* static_cast */
211 TYPEID, /* typeid */
212 USING, /* using */
213 WCHAR /* wchar_t */
214 };
215
216 /* Storage classes, in a wider sense. */
217
218 enum sc
219 {
220 SC_UNKNOWN,
221 SC_MEMBER, /* Is an instance member. */
222 SC_STATIC, /* Is static member. */
223 SC_FRIEND, /* Is friend function. */
224 SC_TYPE /* Is a type definition. */
225 };
226
227 /* Member visibility. */
228
229 enum visibility
230 {
231 V_PUBLIC,
232 V_PROTECTED,
233 V_PRIVATE
234 };
235
236 /* Member flags. */
237
238 #define F_VIRTUAL 1 /* Is virtual function. */
239 #define F_INLINE 2 /* Is inline function. */
240 #define F_CONST 4 /* Is const. */
241 #define F_PURE 8 /* Is pure virtual function. */
242 #define F_MUTABLE 16 /* Is mutable. */
243 #define F_TEMPLATE 32 /* Is a template. */
244 #define F_EXPLICIT 64 /* Is explicit constructor. */
245 #define F_THROW 128 /* Has a throw specification. */
246 #define F_EXTERNC 256 /* Is declared extern "C". */
247 #define F_DEFINE 512 /* Is a #define. */
248
249 /* Two macros to set and test a bit in an int. */
250
251 #define SET_FLAG(F, FLAG) ((F) |= (FLAG))
252 #define HAS_FLAG(F, FLAG) (((F) & (FLAG)) != 0)
253
254 /* Structure describing a class member. */
255
256 struct member
257 {
258 struct member *next; /* Next in list of members. */
259 struct member *anext; /* Collision chain in member_table. */
260 struct member **list; /* Pointer to list in class. */
261 unsigned param_hash; /* Hash value for parameter types. */
262 int vis; /* Visibility (public, ...). */
263 int flags; /* See F_* above. */
264 char *regexp; /* Matching regular expression. */
265 char *filename; /* Don't free this shared string. */
266 int pos; /* Buffer position of occurrence. */
267 char *def_regexp; /* Regular expression matching definition. */
268 char *def_filename; /* File name of definition. */
269 int def_pos; /* Buffer position of definition. */
270 char name[1]; /* Member name. */
271 };
272
273 /* Structures of this type are used to connect class structures with
274 their super and subclasses. */
275
276 struct link
277 {
278 struct sym *sym; /* The super or subclass. */
279 struct link *next; /* Next in list or NULL. */
280 };
281
282 /* Structure used to record namespace aliases. */
283
284 struct alias
285 {
286 struct alias *next; /* Next in list. */
287 struct sym *namesp; /* Namespace in which defined. */
288 struct link *aliasee; /* List of aliased namespaces (A::B::C...). */
289 char name[1]; /* Alias name. */
290 };
291
292 /* The structure used to describe a class in the symbol table,
293 or a namespace in all_namespaces. */
294
295 struct sym
296 {
297 int flags; /* Is class a template class?. */
298 unsigned char visited; /* Used to find circles. */
299 struct sym *next; /* Hash collision list. */
300 struct link *subs; /* List of subclasses. */
301 struct link *supers; /* List of superclasses. */
302 struct member *vars; /* List of instance variables. */
303 struct member *fns; /* List of instance functions. */
304 struct member *static_vars; /* List of static variables. */
305 struct member *static_fns; /* List of static functions. */
306 struct member *friends; /* List of friend functions. */
307 struct member *types; /* List of local types. */
308 char *regexp; /* Matching regular expression. */
309 int pos; /* Buffer position. */
310 char *filename; /* File in which it can be found. */
311 char *sfilename; /* File in which members can be found. */
312 struct sym *namesp; /* Namespace in which defined. . */
313 char name[1]; /* Name of the class. */
314 };
315
316 /* Experimental: Print info for `--position-info'. We print
317 '(CLASS-NAME SCOPE MEMBER-NAME). */
318
319 #define P_DEFN 1
320 #define P_DECL 2
321
322 int info_where;
323 struct sym *info_cls = NULL;
324 struct member *info_member = NULL;
325
326 /* Experimental. For option `--position-info', the buffer position we
327 are interested in. When this position is reached, print out
328 information about what we know about that point. */
329
330 int info_position = -1;
331
332 /* Command line options structure for getopt_long. */
333
334 struct option options[] =
335 {
336 {"append", no_argument, NULL, 'a'},
337 {"files", required_argument, NULL, 'f'},
338 {"help", no_argument, NULL, -2},
339 {"min-regexp-length", required_argument, NULL, 'm'},
340 {"max-regexp-length", required_argument, NULL, 'M'},
341 {"no-nested-classes", no_argument, NULL, 'n'},
342 {"no-regexps", no_argument, NULL, 'x'},
343 {"no-structs-or-unions", no_argument, NULL, 's'},
344 {"output-file", required_argument, NULL, 'o'},
345 {"position-info", required_argument, NULL, 'p'},
346 {"search-path", required_argument, NULL, 'I'},
347 {"verbose", no_argument, NULL, 'v'},
348 {"version", no_argument, NULL, -3},
349 {"very-verbose", no_argument, NULL, 'V'},
350 {NULL, 0, NULL, 0}
351 };
352
353 /* Semantic values of tokens. Set by yylex.. */
354
355 unsigned yyival; /* Set for token CINT. */
356 char *yytext; /* Set for token IDENT. */
357 char *yytext_end;
358
359 /* Output file. */
360
361 FILE *yyout;
362
363 /* Current line number. */
364
365 int yyline;
366
367 /* The name of the current input file. */
368
369 char *filename;
370
371 /* Three character class vectors, and macros to test membership
372 of characters. */
373
374 char is_ident[255];
375 char is_digit[255];
376 char is_white[255];
377
378 #define IDENTP(C) is_ident[(unsigned char) (C)]
379 #define DIGITP(C) is_digit[(unsigned char) (C)]
380 #define WHITEP(C) is_white[(unsigned char) (C)]
381
382 /* Command line flags. */
383
384 int f_append;
385 int f_verbose;
386 int f_very_verbose;
387 int f_structs = 1;
388 int f_regexps = 1;
389 int f_nested_classes = 1;
390
391 /* Maximum and minimum lengths of regular expressions matching a
392 member, class etc., for writing them to the output file. These are
393 overridable from the command line. */
394
395 int min_regexp = 5;
396 int max_regexp = 50;
397
398 /* Input buffer. */
399
400 char *inbuffer;
401 char *in;
402 int inbuffer_size;
403
404 /* Return the current buffer position in the input file. */
405
406 #define BUFFER_POS() (in - inbuffer)
407
408 /* If current lookahead is CSTRING, the following points to the
409 first character in the string constant. Used for recognizing
410 extern "C". */
411
412 char *string_start;
413
414 /* The size of the hash tables for classes.and members. Should be
415 prime. */
416
417 #define TABLE_SIZE 1001
418
419 /* The hash table for class symbols. */
420
421 struct sym *class_table[TABLE_SIZE];
422
423 /* Hash table containing all member structures. This is generally
424 faster for member lookup than traversing the member lists of a
425 `struct sym'. */
426
427 struct member *member_table[TABLE_SIZE];
428
429 /* Hash table for namespace aliases */
430
431 struct alias *namespace_alias_table[TABLE_SIZE];
432
433 /* The special class symbol used to hold global functions,
434 variables etc. */
435
436 struct sym *global_symbols;
437
438 /* The current namespace. */
439
440 struct sym *current_namespace;
441
442 /* The list of all known namespaces. */
443
444 struct sym *all_namespaces;
445
446 /* Stack of namespaces we're currently nested in, during the parse. */
447
448 struct sym **namespace_stack;
449 int namespace_stack_size;
450 int namespace_sp;
451
452 /* The current lookahead token. */
453
454 int tk = -1;
455
456 /* Structure describing a keyword. */
457
458 struct kw
459 {
460 char *name; /* Spelling. */
461 int tk; /* Token value. */
462 struct kw *next; /* Next in collision chain. */
463 };
464
465 /* Keywords are lookup up in a hash table of their own. */
466
467 #define KEYWORD_TABLE_SIZE 1001
468 struct kw *keyword_table[KEYWORD_TABLE_SIZE];
469
470 /* Search path. */
471
472 struct search_path
473 {
474 char *path;
475 struct search_path *next;
476 };
477
478 struct search_path *search_path;
479 struct search_path *search_path_tail;
480
481 /* Function prototypes. */
482
483 int yylex P_ ((void));
484 void yyparse P_ ((void));
485 void re_init_parser P_ ((void));
486 char *token_string P_ ((int));
487 char *matching_regexp P_ ((void));
488 void init_sym P_ ((void));
489 struct sym *add_sym P_ ((char *, struct sym *));
490 void add_link P_ ((struct sym *, struct sym *));
491 void add_member_defn P_ ((struct sym *, char *, char *,
492 int, unsigned, int, int, int));
493 void add_member_decl P_ ((struct sym *, char *, char *, int,
494 unsigned, int, int, int, int));
495 void dump_roots P_ ((FILE *));
496 void *xmalloc P_ ((int));
497 void xfree P_ ((void *));
498 void add_global_defn P_ ((char *, char *, int, unsigned, int, int, int));
499 void add_global_decl P_ ((char *, char *, int, unsigned, int, int, int));
500 void add_define P_ ((char *, char *, int));
501 void mark_inherited_virtual P_ ((void));
502 void leave_namespace P_ ((void));
503 void enter_namespace P_ ((char *));
504 void register_namespace_alias P_ ((char *, struct link *));
505 void insert_keyword P_ ((char *, int));
506 void re_init_scanner P_ ((void));
507 void init_scanner P_ ((void));
508 void usage P_ ((int));
509 void version P_ ((void));
510 void process_file P_ ((char *));
511 void add_search_path P_ ((char *));
512 FILE *open_file P_ ((char *));
513 int process_pp_line P_ ((void));
514 int dump_members P_ ((FILE *, struct member *));
515 void dump_sym P_ ((FILE *, struct sym *));
516 int dump_tree P_ ((FILE *, struct sym *));
517 struct member *find_member P_ ((struct sym *, char *, int, int, unsigned));
518 struct member *add_member P_ ((struct sym *, char *, int, int, unsigned));
519 void mark_virtual P_ ((struct sym *));
520 void mark_virtual P_ ((struct sym *));
521 struct sym *make_namespace P_ ((char *, struct sym *));
522 char *sym_scope P_ ((struct sym *));
523 char *sym_scope_1 P_ ((struct sym *));
524 int skip_to P_ ((int));
525 void skip_matching P_ ((void));
526 void member P_ ((struct sym *, int));
527 void class_body P_ ((struct sym *, int));
528 void class_definition P_ ((struct sym *, int, int, int));
529 void declaration P_ ((int));
530 unsigned parm_list P_ ((int *));
531 char *operator_name P_ ((int *));
532 struct sym *parse_classname P_ ((void));
533 struct sym *parse_qualified_ident_or_type P_ ((char **));
534 void parse_qualified_param_ident_or_type P_ ((char **));
535 int globals P_ ((int));
536 void yyerror P_ ((char *, char *));
537 void usage P_ ((int)) NO_RETURN;
538 void version P_ (()) NO_RETURN;
539
540
541 \f
542 /***********************************************************************
543 Utilities
544 ***********************************************************************/
545
546 /* Print an error in a printf-like style with the current input file
547 name and line number. */
548
549 void
550 yyerror (format, s)
551 char *format, *s;
552 {
553 fprintf (stderr, "%s:%d: ", filename, yyline);
554 fprintf (stderr, format, s);
555 putc ('\n', stderr);
556 }
557
558
559 /* Like malloc but print an error and exit if not enough memory is
560 available. */
561
562 void *
563 xmalloc (nbytes)
564 int nbytes;
565 {
566 void *p = malloc (nbytes);
567 if (p == NULL)
568 {
569 yyerror ("out of memory", NULL);
570 exit (EXIT_FAILURE);
571 }
572 return p;
573 }
574
575
576 /* Like realloc but print an error and exit if out of memory. */
577
578 void *
579 xrealloc (p, sz)
580 void *p;
581 int sz;
582 {
583 p = realloc (p, sz);
584 if (p == NULL)
585 {
586 yyerror ("out of memory", NULL);
587 exit (EXIT_FAILURE);
588 }
589 return p;
590 }
591
592
593 /* Like free but always check for null pointers.. */
594
595 void
596 xfree (p)
597 void *p;
598 {
599 if (p)
600 free (p);
601 }
602
603
604 /* Like strdup, but print an error and exit if not enough memory is
605 available.. If S is null, return null. */
606
607 char *
608 xstrdup (s)
609 char *s;
610 {
611 if (s)
612 s = strcpy (xmalloc (strlen (s) + 1), s);
613 return s;
614 }
615
616
617 \f
618 /***********************************************************************
619 Symbols
620 ***********************************************************************/
621
622 /* Initialize the symbol table. This currently only sets up the
623 special symbol for globals (`*Globals*'). */
624
625 void
626 init_sym ()
627 {
628 global_symbols = add_sym (GLOBALS_NAME, NULL);
629 }
630
631
632 /* Add a symbol for class NAME to the symbol table. NESTED_IN_CLASS
633 is the class in which class NAME was found. If it is null,
634 this means the scope of NAME is the current namespace.
635
636 If a symbol for NAME already exists, return that. Otherwise
637 create a new symbol and set it to default values. */
638
639 struct sym *
640 add_sym (name, nested_in_class)
641 char *name;
642 struct sym *nested_in_class;
643 {
644 struct sym *sym;
645 unsigned h;
646 char *s;
647 struct sym *scope = nested_in_class ? nested_in_class : current_namespace;
648
649 for (s = name, h = 0; *s; ++s)
650 h = (h << 1) ^ *s;
651 h %= TABLE_SIZE;
652
653 for (sym = class_table[h]; sym; sym = sym->next)
654 if (streq (name, sym->name)
655 && ((!sym->namesp && !scope)
656 || (sym->namesp && scope
657 && streq (sym->namesp->name, scope->name))))
658 break;
659
660 if (sym == NULL)
661 {
662 if (f_very_verbose)
663 {
664 putchar ('\t');
665 puts (name);
666 }
667
668 sym = (struct sym *) xmalloc (sizeof *sym + strlen (name));
669 bzero (sym, sizeof *sym);
670 strcpy (sym->name, name);
671 sym->namesp = scope;
672 sym->next = class_table[h];
673 class_table[h] = sym;
674 }
675
676 return sym;
677 }
678
679
680 /* Add links between superclass SUPER and subclass SUB. */
681
682 void
683 add_link (super, sub)
684 struct sym *super, *sub;
685 {
686 struct link *lnk, *lnk2, *p, *prev;
687
688 /* See if a link already exists. */
689 for (p = super->subs, prev = NULL;
690 p && strcmp (sub->name, p->sym->name) > 0;
691 prev = p, p = p->next)
692 ;
693
694 /* Avoid duplicates. */
695 if (p == NULL || p->sym != sub)
696 {
697 lnk = (struct link *) xmalloc (sizeof *lnk);
698 lnk2 = (struct link *) xmalloc (sizeof *lnk2);
699
700 lnk->sym = sub;
701 lnk->next = p;
702
703 if (prev)
704 prev->next = lnk;
705 else
706 super->subs = lnk;
707
708 lnk2->sym = super;
709 lnk2->next = sub->supers;
710 sub->supers = lnk2;
711 }
712 }
713
714
715 /* Find in class CLS member NAME.
716
717 VAR non-zero means look for a member variable; otherwise a function
718 is searched. SC specifies what kind of member is searched---a
719 static, or per-instance member etc. HASH is a hash code for the
720 parameter types of functions. Value is a pointer to the member
721 found or null if not found. */
722
723 struct member *
724 find_member (cls, name, var, sc, hash)
725 struct sym *cls;
726 char *name;
727 int var, sc;
728 unsigned hash;
729 {
730 struct member **list;
731 struct member *p;
732 unsigned name_hash = 0;
733 char *s;
734 int i;
735
736 switch (sc)
737 {
738 case SC_FRIEND:
739 list = &cls->friends;
740 break;
741
742 case SC_TYPE:
743 list = &cls->types;
744 break;
745
746 case SC_STATIC:
747 list = var ? &cls->static_vars : &cls->static_fns;
748 break;
749
750 default:
751 list = var ? &cls->vars : &cls->fns;
752 break;
753 }
754
755 for (s = name; *s; ++s)
756 name_hash = (name_hash << 1) ^ *s;
757 i = name_hash % TABLE_SIZE;
758
759 for (p = member_table[i]; p; p = p->anext)
760 if (p->list == list && p->param_hash == hash && streq (name, p->name))
761 break;
762
763 return p;
764 }
765
766
767 /* Add to class CLS information for the declaration of member NAME.
768 REGEXP is a regexp matching the declaration, if non-null. POS is
769 the position in the source where the declaration is found. HASH is
770 a hash code for the parameter list of the member, if it's a
771 function. VAR non-zero means member is a variable or type. SC
772 specifies the type of member (instance member, static, ...). VIS
773 is the member's visibility (public, protected, private). FLAGS is
774 a bit set giving additional information about the member (see the
775 F_* defines). */
776
777 void
778 add_member_decl (cls, name, regexp, pos, hash, var, sc, vis, flags)
779 struct sym *cls;
780 char *name;
781 char *regexp;
782 int pos;
783 unsigned hash;
784 int var;
785 int sc;
786 int vis;
787 int flags;
788 {
789 struct member *m;
790
791 m = find_member (cls, name, var, sc, hash);
792 if (m == NULL)
793 m = add_member (cls, name, var, sc, hash);
794
795 /* Have we seen a new filename? If so record that. */
796 if (!cls->filename || !FILENAME_EQ (cls->filename, filename))
797 m->filename = filename;
798
799 m->regexp = regexp;
800 m->pos = pos;
801 m->flags = flags;
802
803 switch (vis)
804 {
805 case PRIVATE:
806 m->vis = V_PRIVATE;
807 break;
808
809 case PROTECTED:
810 m->vis = V_PROTECTED;
811 break;
812
813 case PUBLIC:
814 m->vis = V_PUBLIC;
815 break;
816 }
817
818 info_where = P_DECL;
819 info_cls = cls;
820 info_member = m;
821 }
822
823
824 /* Add to class CLS information for the definition of member NAME.
825 REGEXP is a regexp matching the declaration, if non-null. POS is
826 the position in the source where the declaration is found. HASH is
827 a hash code for the parameter list of the member, if it's a
828 function. VAR non-zero means member is a variable or type. SC
829 specifies the type of member (instance member, static, ...). VIS
830 is the member's visibility (public, protected, private). FLAGS is
831 a bit set giving additional information about the member (see the
832 F_* defines). */
833
834 void
835 add_member_defn (cls, name, regexp, pos, hash, var, sc, flags)
836 struct sym *cls;
837 char *name;
838 char *regexp;
839 int pos;
840 unsigned hash;
841 int var;
842 int sc;
843 int flags;
844 {
845 struct member *m;
846
847 if (sc == SC_UNKNOWN)
848 {
849 m = find_member (cls, name, var, SC_MEMBER, hash);
850 if (m == NULL)
851 {
852 m = find_member (cls, name, var, SC_STATIC, hash);
853 if (m == NULL)
854 m = add_member (cls, name, var, sc, hash);
855 }
856 }
857 else
858 {
859 m = find_member (cls, name, var, sc, hash);
860 if (m == NULL)
861 m = add_member (cls, name, var, sc, hash);
862 }
863
864 if (!cls->sfilename)
865 cls->sfilename = filename;
866
867 if (!FILENAME_EQ (cls->sfilename, filename))
868 m->def_filename = filename;
869
870 m->def_regexp = regexp;
871 m->def_pos = pos;
872 m->flags |= flags;
873
874 info_where = P_DEFN;
875 info_cls = cls;
876 info_member = m;
877 }
878
879
880 /* Add a symbol for a define named NAME to the symbol table.
881 REGEXP is a regular expression matching the define in the source,
882 if it is non-null. POS is the position in the file. */
883
884 void
885 add_define (name, regexp, pos)
886 char *name, *regexp;
887 int pos;
888 {
889 add_global_defn (name, regexp, pos, 0, 1, SC_FRIEND, F_DEFINE);
890 add_global_decl (name, regexp, pos, 0, 1, SC_FRIEND, F_DEFINE);
891 }
892
893
894 /* Add information for the global definition of NAME.
895 REGEXP is a regexp matching the declaration, if non-null. POS is
896 the position in the source where the declaration is found. HASH is
897 a hash code for the parameter list of the member, if it's a
898 function. VAR non-zero means member is a variable or type. SC
899 specifies the type of member (instance member, static, ...). VIS
900 is the member's visibility (public, protected, private). FLAGS is
901 a bit set giving additional information about the member (see the
902 F_* defines). */
903
904 void
905 add_global_defn (name, regexp, pos, hash, var, sc, flags)
906 char *name, *regexp;
907 int pos;
908 unsigned hash;
909 int var;
910 int sc;
911 int flags;
912 {
913 int i;
914 struct sym *sym;
915
916 /* Try to find out for which classes a function is a friend, and add
917 what we know about it to them. */
918 if (!var)
919 for (i = 0; i < TABLE_SIZE; ++i)
920 for (sym = class_table[i]; sym; sym = sym->next)
921 if (sym != global_symbols && sym->friends)
922 if (find_member (sym, name, 0, SC_FRIEND, hash))
923 add_member_defn (sym, name, regexp, pos, hash, 0,
924 SC_FRIEND, flags);
925
926 /* Add to global symbols. */
927 add_member_defn (global_symbols, name, regexp, pos, hash, var, sc, flags);
928 }
929
930
931 /* Add information for the global declaration of NAME.
932 REGEXP is a regexp matching the declaration, if non-null. POS is
933 the position in the source where the declaration is found. HASH is
934 a hash code for the parameter list of the member, if it's a
935 function. VAR non-zero means member is a variable or type. SC
936 specifies the type of member (instance member, static, ...). VIS
937 is the member's visibility (public, protected, private). FLAGS is
938 a bit set giving additional information about the member (see the
939 F_* defines). */
940
941 void
942 add_global_decl (name, regexp, pos, hash, var, sc, flags)
943 char *name, *regexp;
944 int pos;
945 unsigned hash;
946 int var;
947 int sc;
948 int flags;
949 {
950 /* Add declaration only if not already declared. Header files must
951 be processed before source files for this to have the right effect.
952 I do not want to handle implicit declarations at the moment. */
953 struct member *m;
954 struct member *found;
955
956 m = found = find_member (global_symbols, name, var, sc, hash);
957 if (m == NULL)
958 m = add_member (global_symbols, name, var, sc, hash);
959
960 /* Definition already seen => probably last declaration implicit.
961 Override. This means that declarations must always be added to
962 the symbol table before definitions. */
963 if (!found)
964 {
965 if (!global_symbols->filename
966 || !FILENAME_EQ (global_symbols->filename, filename))
967 m->filename = filename;
968
969 m->regexp = regexp;
970 m->pos = pos;
971 m->vis = V_PUBLIC;
972 m->flags = flags;
973
974 info_where = P_DECL;
975 info_cls = global_symbols;
976 info_member = m;
977 }
978 }
979
980
981 /* Add a symbol for member NAME to class CLS.
982 VAR non-zero means it's a variable. SC specifies the kind of
983 member. HASH is a hash code for the parameter types of a function.
984 Value is a pointer to the member's structure. */
985
986 struct member *
987 add_member (cls, name, var, sc, hash)
988 struct sym *cls;
989 char *name;
990 int var;
991 int sc;
992 unsigned hash;
993 {
994 struct member *m = (struct member *) xmalloc (sizeof *m + strlen (name));
995 struct member **list;
996 struct member *p;
997 struct member *prev;
998 unsigned name_hash = 0;
999 int i;
1000 char *s;
1001
1002 strcpy (m->name, name);
1003 m->param_hash = hash;
1004
1005 m->vis = 0;
1006 m->flags = 0;
1007 m->regexp = NULL;
1008 m->filename = NULL;
1009 m->pos = 0;
1010 m->def_regexp = NULL;
1011 m->def_filename = NULL;
1012 m->def_pos = 0;
1013
1014 assert (cls != NULL);
1015
1016 switch (sc)
1017 {
1018 case SC_FRIEND:
1019 list = &cls->friends;
1020 break;
1021
1022 case SC_TYPE:
1023 list = &cls->types;
1024 break;
1025
1026 case SC_STATIC:
1027 list = var ? &cls->static_vars : &cls->static_fns;
1028 break;
1029
1030 default:
1031 list = var ? &cls->vars : &cls->fns;
1032 break;
1033 }
1034
1035 for (s = name; *s; ++s)
1036 name_hash = (name_hash << 1) ^ *s;
1037 i = name_hash % TABLE_SIZE;
1038 m->anext = member_table[i];
1039 member_table[i] = m;
1040 m->list = list;
1041
1042 /* Keep the member list sorted. It's cheaper to do it here than to
1043 sort them in Lisp. */
1044 for (prev = NULL, p = *list;
1045 p && strcmp (name, p->name) > 0;
1046 prev = p, p = p->next)
1047 ;
1048
1049 m->next = p;
1050 if (prev)
1051 prev->next = m;
1052 else
1053 *list = m;
1054 return m;
1055 }
1056
1057
1058 /* Given the root R of a class tree, step through all subclasses
1059 recursively, marking functions as virtual that are declared virtual
1060 in base classes. */
1061
1062 void
1063 mark_virtual (r)
1064 struct sym *r;
1065 {
1066 struct link *p;
1067 struct member *m, *m2;
1068
1069 for (p = r->subs; p; p = p->next)
1070 {
1071 for (m = r->fns; m; m = m->next)
1072 if (HAS_FLAG (m->flags, F_VIRTUAL))
1073 {
1074 for (m2 = p->sym->fns; m2; m2 = m2->next)
1075 if (m->param_hash == m2->param_hash && streq (m->name, m2->name))
1076 SET_FLAG (m2->flags, F_VIRTUAL);
1077 }
1078
1079 mark_virtual (p->sym);
1080 }
1081 }
1082
1083
1084 /* For all roots of the class tree, mark functions as virtual that
1085 are virtual because of a virtual declaration in a base class. */
1086
1087 void
1088 mark_inherited_virtual ()
1089 {
1090 struct sym *r;
1091 int i;
1092
1093 for (i = 0; i < TABLE_SIZE; ++i)
1094 for (r = class_table[i]; r; r = r->next)
1095 if (r->supers == NULL)
1096 mark_virtual (r);
1097 }
1098
1099
1100 /* Create and return a symbol for a namespace with name NAME. */
1101
1102 struct sym *
1103 make_namespace (name, context)
1104 char *name;
1105 struct sym *context;
1106 {
1107 struct sym *s = (struct sym *) xmalloc (sizeof *s + strlen (name));
1108 bzero (s, sizeof *s);
1109 strcpy (s->name, name);
1110 s->next = all_namespaces;
1111 s->namesp = context;
1112 all_namespaces = s;
1113 return s;
1114 }
1115
1116
1117 /* Find the symbol for namespace NAME. If not found, retrun NULL */
1118
1119 struct sym *
1120 check_namespace (name, context)
1121 char *name;
1122 struct sym *context;
1123 {
1124 struct sym *p = NULL;
1125
1126 for (p = all_namespaces; p; p = p->next)
1127 {
1128 if (streq (p->name, name) && (p->namesp == context))
1129 break;
1130 }
1131
1132 return p;
1133 }
1134
1135 /* Find the symbol for namespace NAME. If not found, add a new symbol
1136 for NAME to all_namespaces. */
1137
1138 struct sym *
1139 find_namespace (name, context)
1140 char *name;
1141 struct sym *context;
1142 {
1143 struct sym *p = check_namespace (name, context);
1144
1145 if (p == NULL)
1146 p = make_namespace (name, context);
1147
1148 return p;
1149 }
1150
1151
1152 /* Find namespace alias with name NAME. If not found return NULL. */
1153
1154 struct link *
1155 check_namespace_alias (name)
1156 char *name;
1157 {
1158 struct link *p = NULL;
1159 struct alias *al;
1160 unsigned h;
1161 char *s;
1162
1163 for (s = name, h = 0; *s; ++s)
1164 h = (h << 1) ^ *s;
1165 h %= TABLE_SIZE;
1166
1167 for (al = namespace_alias_table[h]; al; al = al->next)
1168 if (streq (name, al->name) && (al->namesp == current_namespace))
1169 {
1170 p = al->aliasee;
1171 break;
1172 }
1173
1174 return p;
1175 }
1176
1177 /* Register the name NEW_NAME as an alias for namespace list OLD_NAME. */
1178
1179 void
1180 register_namespace_alias (new_name, old_name)
1181 char *new_name;
1182 struct link *old_name;
1183 {
1184 unsigned h;
1185 char *s;
1186 struct alias *al;
1187
1188 for (s = new_name, h = 0; *s; ++s)
1189 h = (h << 1) ^ *s;
1190 h %= TABLE_SIZE;
1191
1192
1193 /* Is it already in the table of aliases? */
1194 for (al = namespace_alias_table[h]; al; al = al->next)
1195 if (streq (new_name, al->name) && (al->namesp == current_namespace))
1196 return;
1197
1198 al = (struct alias *) xmalloc (sizeof *al + strlen (new_name));
1199 strcpy (al->name, new_name);
1200 al->next = namespace_alias_table[h];
1201 al->namesp = current_namespace;
1202 al->aliasee = old_name;
1203 namespace_alias_table[h] = al;
1204 }
1205
1206
1207 /* Enter namespace with name NAME. */
1208
1209 void
1210 enter_namespace (name)
1211 char *name;
1212 {
1213 struct sym *p = find_namespace (name, current_namespace);
1214
1215 if (namespace_sp == namespace_stack_size)
1216 {
1217 int size = max (10, 2 * namespace_stack_size);
1218 namespace_stack
1219 = (struct sym **) xrealloc ((void *)namespace_stack,
1220 size * sizeof *namespace_stack);
1221 namespace_stack_size = size;
1222 }
1223
1224 namespace_stack[namespace_sp++] = current_namespace;
1225 current_namespace = p;
1226 }
1227
1228
1229 /* Leave the current namespace. */
1230
1231 void
1232 leave_namespace ()
1233 {
1234 assert (namespace_sp > 0);
1235 current_namespace = namespace_stack[--namespace_sp];
1236 }
1237
1238
1239 \f
1240 /***********************************************************************
1241 Writing the Output File
1242 ***********************************************************************/
1243
1244 /* Write string S to the output file FP in a Lisp-readable form.
1245 If S is null, write out `()'. */
1246
1247 #define PUTSTR(s, fp) \
1248 do { \
1249 if (!s) \
1250 { \
1251 putc ('(', fp); \
1252 putc (')', fp); \
1253 putc (' ', fp); \
1254 } \
1255 else \
1256 { \
1257 putc ('"', fp); \
1258 fputs (s, fp); \
1259 putc ('"', fp); \
1260 putc (' ', fp); \
1261 } \
1262 } while (0)
1263
1264 /* A dynamically allocated buffer for constructing a scope name. */
1265
1266 char *scope_buffer;
1267 int scope_buffer_size;
1268 int scope_buffer_len;
1269
1270
1271 /* Make sure scope_buffer has enough room to add LEN chars to it. */
1272
1273 void
1274 ensure_scope_buffer_room (len)
1275 int len;
1276 {
1277 if (scope_buffer_len + len >= scope_buffer_size)
1278 {
1279 int new_size = max (2 * scope_buffer_size, scope_buffer_len + len);
1280 scope_buffer = (char *) xrealloc (scope_buffer, new_size);
1281 scope_buffer_size = new_size;
1282 }
1283 }
1284
1285
1286 /* Recursively add the scope names of symbol P and the scopes of its
1287 namespaces to scope_buffer. Value is a pointer to the complete
1288 scope name constructed. */
1289
1290 char *
1291 sym_scope_1 (p)
1292 struct sym *p;
1293 {
1294 int len;
1295
1296 if (p->namesp)
1297 sym_scope_1 (p->namesp);
1298
1299 if (*scope_buffer)
1300 {
1301 ensure_scope_buffer_room (3);
1302 strcat (scope_buffer, "::");
1303 scope_buffer_len += 2;
1304 }
1305
1306 len = strlen (p->name);
1307 ensure_scope_buffer_room (len + 1);
1308 strcat (scope_buffer, p->name);
1309 scope_buffer_len += len;
1310
1311 if (HAS_FLAG (p->flags, F_TEMPLATE))
1312 {
1313 ensure_scope_buffer_room (3);
1314 strcat (scope_buffer, "<>");
1315 scope_buffer_len += 2;
1316 }
1317
1318 return scope_buffer;
1319 }
1320
1321
1322 /* Return the scope of symbol P in printed representation, i.e.
1323 as it would appear in a C*+ source file. */
1324
1325 char *
1326 sym_scope (p)
1327 struct sym *p;
1328 {
1329 if (!scope_buffer)
1330 {
1331 scope_buffer_size = 1024;
1332 scope_buffer = (char *) xmalloc (scope_buffer_size);
1333 }
1334
1335 *scope_buffer = '\0';
1336 scope_buffer_len = 0;
1337
1338 if (p->namesp)
1339 sym_scope_1 (p->namesp);
1340
1341 return scope_buffer;
1342 }
1343
1344
1345 /* Dump the list of members M to file FP. Value is the length of the
1346 list. */
1347
1348 int
1349 dump_members (fp, m)
1350 FILE *fp;
1351 struct member *m;
1352 {
1353 int n;
1354
1355 putc ('(', fp);
1356
1357 for (n = 0; m; m = m->next, ++n)
1358 {
1359 fputs (MEMBER_STRUCT, fp);
1360 PUTSTR (m->name, fp);
1361 PUTSTR (NULL, fp); /* FIXME? scope for globals */
1362 fprintf (fp, "%u ", (unsigned) m->flags);
1363 PUTSTR (m->filename, fp);
1364 PUTSTR (m->regexp, fp);
1365 fprintf (fp, "%u ", (unsigned) m->pos);
1366 fprintf (fp, "%u ", (unsigned) m->vis);
1367 putc (' ', fp);
1368 PUTSTR (m->def_filename, fp);
1369 PUTSTR (m->def_regexp, fp);
1370 fprintf (fp, "%u", (unsigned) m->def_pos);
1371 putc (']', fp);
1372 putc ('\n', fp);
1373 }
1374
1375 putc (')', fp);
1376 putc ('\n', fp);
1377 return n;
1378 }
1379
1380
1381 /* Dump class ROOT to stream FP. */
1382
1383 void
1384 dump_sym (fp, root)
1385 FILE *fp;
1386 struct sym *root;
1387 {
1388 fputs (CLASS_STRUCT, fp);
1389 PUTSTR (root->name, fp);
1390
1391 /* Print scope, if any. */
1392 if (root->namesp)
1393 PUTSTR (sym_scope (root), fp);
1394 else
1395 PUTSTR (NULL, fp);
1396
1397 /* Print flags. */
1398 fprintf (fp, "%u", root->flags);
1399 PUTSTR (root->filename, fp);
1400 PUTSTR (root->regexp, fp);
1401 fprintf (fp, "%u", (unsigned) root->pos);
1402 PUTSTR (root->sfilename, fp);
1403 putc (']', fp);
1404 putc ('\n', fp);
1405 }
1406
1407
1408 /* Dump class ROOT and its subclasses to file FP. Value is the
1409 number of classes written. */
1410
1411 int
1412 dump_tree (fp, root)
1413 FILE *fp;
1414 struct sym *root;
1415 {
1416 struct link *lk;
1417 unsigned n = 0;
1418
1419 dump_sym (fp, root);
1420
1421 if (f_verbose)
1422 {
1423 putchar ('+');
1424 fflush (stdout);
1425 }
1426
1427 putc ('(', fp);
1428
1429 for (lk = root->subs; lk; lk = lk->next)
1430 {
1431 fputs (TREE_STRUCT, fp);
1432 n += dump_tree (fp, lk->sym);
1433 putc (']', fp);
1434 }
1435
1436 putc (')', fp);
1437
1438 dump_members (fp, root->vars);
1439 n += dump_members (fp, root->fns);
1440 dump_members (fp, root->static_vars);
1441 n += dump_members (fp, root->static_fns);
1442 n += dump_members (fp, root->friends);
1443 dump_members (fp, root->types);
1444
1445 /* Superclasses. */
1446 putc ('(', fp);
1447 putc (')', fp);
1448
1449 /* Mark slot. */
1450 putc ('(', fp);
1451 putc (')', fp);
1452
1453 putc ('\n', fp);
1454 return n;
1455 }
1456
1457
1458 /* Dump the entire class tree to file FP. */
1459
1460 void
1461 dump_roots (fp)
1462 FILE *fp;
1463 {
1464 int i, n = 0;
1465 struct sym *r;
1466
1467 /* Output file header containing version string, command line
1468 options etc. */
1469 if (!f_append)
1470 {
1471 fputs (TREE_HEADER_STRUCT, fp);
1472 PUTSTR (EBROWSE_FILE_VERSION, fp);
1473
1474 putc ('\"', fp);
1475 if (!f_structs)
1476 fputs (" -s", fp);
1477 if (f_regexps)
1478 fputs (" -x", fp);
1479 putc ('\"', fp);
1480 fputs (" ()", fp);
1481 fputs (" ()", fp);
1482 putc (']', fp);
1483 }
1484
1485 /* Mark functions as virtual that are so because of functions
1486 declared virtual in base classes. */
1487 mark_inherited_virtual ();
1488
1489 /* Dump the roots of the graph. */
1490 for (i = 0; i < TABLE_SIZE; ++i)
1491 for (r = class_table[i]; r; r = r->next)
1492 if (!r->supers)
1493 {
1494 fputs (TREE_STRUCT, fp);
1495 n += dump_tree (fp, r);
1496 putc (']', fp);
1497 }
1498
1499 if (f_verbose)
1500 putchar ('\n');
1501 }
1502
1503
1504 \f
1505 /***********************************************************************
1506 Scanner
1507 ***********************************************************************/
1508
1509 #ifdef DEBUG
1510 #define INCREMENT_LINENO \
1511 do { \
1512 if (f_very_verbose) \
1513 { \
1514 ++yyline; \
1515 printf ("%d:\n", yyline); \
1516 } \
1517 else \
1518 ++yyline; \
1519 } while (0)
1520 #else
1521 #define INCREMENT_LINENO ++yyline
1522 #endif
1523
1524 /* Define two macros for accessing the input buffer (current input
1525 file). GET(C) sets C to the next input character and advances the
1526 input pointer. UNGET retracts the input pointer. */
1527
1528 #define GET(C) ((C) = *in++)
1529 #define UNGET() (--in)
1530
1531
1532 /* Process a preprocessor line. Value is the next character from the
1533 input buffer not consumed. */
1534
1535 int
1536 process_pp_line ()
1537 {
1538 int in_comment = 0, in_string = 0;
1539 int c;
1540 char *p = yytext;
1541
1542 /* Skip over white space. The `#' has been consumed already. */
1543 while (WHITEP (GET (c)))
1544 ;
1545
1546 /* Read the preprocessor command (if any). */
1547 while (IDENTP (c))
1548 {
1549 *p++ = c;
1550 GET (c);
1551 }
1552
1553 /* Is it a `define'? */
1554 *p = '\0';
1555
1556 if (*yytext && streq (yytext, "define"))
1557 {
1558 p = yytext;
1559 while (WHITEP (c))
1560 GET (c);
1561 while (IDENTP (c))
1562 {
1563 *p++ = c;
1564 GET (c);
1565 }
1566
1567 *p = '\0';
1568
1569 if (*yytext)
1570 {
1571 char *regexp = matching_regexp ();
1572 int pos = BUFFER_POS ();
1573 add_define (yytext, regexp, pos);
1574 }
1575 }
1576
1577 while (c && (c != '\n' || in_comment || in_string))
1578 {
1579 if (c == '\\')
1580 GET (c);
1581 else if (c == '/' && !in_comment)
1582 {
1583 if (GET (c) == '*')
1584 in_comment = 1;
1585 }
1586 else if (c == '*' && in_comment)
1587 {
1588 if (GET (c) == '/')
1589 in_comment = 0;
1590 }
1591 else if (c == '"')
1592 in_string = !in_string;
1593
1594 if (c == '\n')
1595 INCREMENT_LINENO;
1596
1597 GET (c);
1598 }
1599
1600 return c;
1601 }
1602
1603
1604 /* Value is the next token from the input buffer. */
1605
1606 int
1607 yylex ()
1608 {
1609 int c;
1610 char end_char;
1611 char *p;
1612
1613 for (;;)
1614 {
1615 while (WHITEP (GET (c)))
1616 ;
1617
1618 switch (c)
1619 {
1620 case '\n':
1621 INCREMENT_LINENO;
1622 break;
1623
1624 case '\r':
1625 break;
1626
1627 case 0:
1628 /* End of file. */
1629 return YYEOF;
1630
1631 case '\\':
1632 GET (c);
1633 break;
1634
1635 case '"':
1636 case '\'':
1637 /* String and character constants. */
1638 end_char = c;
1639 string_start = in;
1640 while (GET (c) && c != end_char)
1641 {
1642 switch (c)
1643 {
1644 case '\\':
1645 /* Escape sequences. */
1646 if (!GET (c))
1647 {
1648 if (end_char == '\'')
1649 yyerror ("EOF in character constant", NULL);
1650 else
1651 yyerror ("EOF in string constant", NULL);
1652 goto end_string;
1653 }
1654 else switch (c)
1655 {
1656 case '\n':
1657 INCREMENT_LINENO;
1658 case 'a':
1659 case 'b':
1660 case 'f':
1661 case 'n':
1662 case 'r':
1663 case 't':
1664 case 'v':
1665 break;
1666
1667 case 'x':
1668 {
1669 /* Hexadecimal escape sequence. */
1670 int i;
1671 for (i = 0; i < 2; ++i)
1672 {
1673 GET (c);
1674
1675 if (c >= '0' && c <= '7')
1676 ;
1677 else if (c >= 'a' && c <= 'f')
1678 ;
1679 else if (c >= 'A' && c <= 'F')
1680 ;
1681 else
1682 {
1683 UNGET ();
1684 break;
1685 }
1686 }
1687 }
1688 break;
1689
1690 case '0':
1691 {
1692 /* Octal escape sequence. */
1693 int i;
1694 for (i = 0; i < 3; ++i)
1695 {
1696 GET (c);
1697
1698 if (c >= '0' && c <= '7')
1699 ;
1700 else
1701 {
1702 UNGET ();
1703 break;
1704 }
1705 }
1706 }
1707 break;
1708
1709 default:
1710 break;
1711 }
1712 break;
1713
1714 case '\n':
1715 if (end_char == '\'')
1716 yyerror ("newline in character constant", NULL);
1717 else
1718 yyerror ("newline in string constant", NULL);
1719 INCREMENT_LINENO;
1720 break;
1721
1722 default:
1723 break;
1724 }
1725 }
1726
1727 end_string:
1728 return end_char == '\'' ? CCHAR : CSTRING;
1729
1730 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1731 case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
1732 case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
1733 case 'v': case 'w': case 'x': case 'y': case 'z':
1734 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
1735 case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
1736 case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
1737 case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_':
1738 {
1739 /* Identifier and keywords. */
1740 unsigned hash;
1741 struct kw *k;
1742
1743 p = yytext;
1744 *p++ = hash = c;
1745
1746 while (IDENTP (GET (*p)))
1747 {
1748 hash = (hash << 1) ^ *p++;
1749 if (p == yytext_end - 1)
1750 {
1751 int size = yytext_end - yytext;
1752 yytext = (char *) xrealloc (yytext, 2 * size);
1753 yytext_end = yytext + 2 * size;
1754 p = yytext + size - 1;
1755 }
1756 }
1757
1758 UNGET ();
1759 *p = 0;
1760
1761 for (k = keyword_table[hash % KEYWORD_TABLE_SIZE]; k; k = k->next)
1762 if (streq (k->name, yytext))
1763 return k->tk;
1764
1765 return IDENT;
1766 }
1767
1768 case '/':
1769 /* C and C++ comments, '/' and '/='. */
1770 switch (GET (c))
1771 {
1772 case '*':
1773 while (GET (c))
1774 {
1775 switch (c)
1776 {
1777 case '*':
1778 if (GET (c) == '/')
1779 goto comment_end;
1780 UNGET ();
1781 break;
1782 case '\\':
1783 GET (c);
1784 break;
1785 case '\n':
1786 INCREMENT_LINENO;
1787 break;
1788 }
1789 }
1790 comment_end:;
1791 break;
1792
1793 case '=':
1794 return DIVASGN;
1795
1796 case '/':
1797 while (GET (c) && c != '\n')
1798 ;
1799 INCREMENT_LINENO;
1800 break;
1801
1802 default:
1803 UNGET ();
1804 return '/';
1805 }
1806 break;
1807
1808 case '+':
1809 if (GET (c) == '+')
1810 return INC;
1811 else if (c == '=')
1812 return ADDASGN;
1813 UNGET ();
1814 return '+';
1815
1816 case '-':
1817 switch (GET (c))
1818 {
1819 case '-':
1820 return DEC;
1821 case '>':
1822 if (GET (c) == '*')
1823 return ARROWSTAR;
1824 UNGET ();
1825 return ARROW;
1826 case '=':
1827 return SUBASGN;
1828 }
1829 UNGET ();
1830 return '-';
1831
1832 case '*':
1833 if (GET (c) == '=')
1834 return MULASGN;
1835 UNGET ();
1836 return '*';
1837
1838 case '%':
1839 if (GET (c) == '=')
1840 return MODASGN;
1841 UNGET ();
1842 return '%';
1843
1844 case '|':
1845 if (GET (c) == '|')
1846 return LOR;
1847 else if (c == '=')
1848 return ORASGN;
1849 UNGET ();
1850 return '|';
1851
1852 case '&':
1853 if (GET (c) == '&')
1854 return LAND;
1855 else if (c == '=')
1856 return ANDASGN;
1857 UNGET ();
1858 return '&';
1859
1860 case '^':
1861 if (GET (c) == '=')
1862 return XORASGN;
1863 UNGET ();
1864 return '^';
1865
1866 case '.':
1867 if (GET (c) == '*')
1868 return POINTSTAR;
1869 else if (c == '.')
1870 {
1871 if (GET (c) != '.')
1872 yyerror ("invalid token '..' ('...' assumed)", NULL);
1873 UNGET ();
1874 return ELLIPSIS;
1875 }
1876 else if (!DIGITP (c))
1877 {
1878 UNGET ();
1879 return '.';
1880 }
1881 goto mantissa;
1882
1883 case ':':
1884 if (GET (c) == ':')
1885 return DCOLON;
1886 UNGET ();
1887 return ':';
1888
1889 case '=':
1890 if (GET (c) == '=')
1891 return EQ;
1892 UNGET ();
1893 return '=';
1894
1895 case '!':
1896 if (GET (c) == '=')
1897 return NE;
1898 UNGET ();
1899 return '!';
1900
1901 case '<':
1902 switch (GET (c))
1903 {
1904 case '=':
1905 return LE;
1906 case '<':
1907 if (GET (c) == '=')
1908 return LSHIFTASGN;
1909 UNGET ();
1910 return LSHIFT;
1911 }
1912 UNGET ();
1913 return '<';
1914
1915 case '>':
1916 switch (GET (c))
1917 {
1918 case '=':
1919 return GE;
1920 case '>':
1921 if (GET (c) == '=')
1922 return RSHIFTASGN;
1923 UNGET ();
1924 return RSHIFT;
1925 }
1926 UNGET ();
1927 return '>';
1928
1929 case '#':
1930 c = process_pp_line ();
1931 if (c == 0)
1932 return YYEOF;
1933 break;
1934
1935 case '(': case ')': case '[': case ']': case '{': case '}':
1936 case ';': case ',': case '?': case '~':
1937 return c;
1938
1939 case '0':
1940 yyival = 0;
1941
1942 if (GET (c) == 'x' || c == 'X')
1943 {
1944 while (GET (c))
1945 {
1946 if (DIGITP (c))
1947 yyival = yyival * 16 + c - '0';
1948 else if (c >= 'a' && c <= 'f')
1949 yyival = yyival * 16 + c - 'a' + 10;
1950 else if (c >= 'A' && c <= 'F')
1951 yyival = yyival * 16 + c - 'A' + 10;
1952 else
1953 break;
1954 }
1955
1956 goto int_suffixes;
1957 }
1958 else if (c == '.')
1959 goto mantissa;
1960
1961 while (c >= '0' && c <= '7')
1962 {
1963 yyival = (yyival << 3) + c - '0';
1964 GET (c);
1965 }
1966
1967 int_suffixes:
1968 /* Integer suffixes. */
1969 while (isalpha (c))
1970 GET (c);
1971 UNGET ();
1972 return CINT;
1973
1974 case '1': case '2': case '3': case '4': case '5': case '6':
1975 case '7': case '8': case '9':
1976 /* Integer or floating constant, part before '.'. */
1977 yyival = c - '0';
1978
1979 while (GET (c) && DIGITP (c))
1980 yyival = 10 * yyival + c - '0';
1981
1982 if (c != '.')
1983 goto int_suffixes;
1984
1985 mantissa:
1986 /* Digits following '.'. */
1987 while (DIGITP (c))
1988 GET (c);
1989
1990 /* Optional exponent. */
1991 if (c == 'E' || c == 'e')
1992 {
1993 if (GET (c) == '-' || c == '+')
1994 GET (c);
1995
1996 while (DIGITP (c))
1997 GET (c);
1998 }
1999
2000 /* Optional type suffixes. */
2001 while (isalpha (c))
2002 GET (c);
2003 UNGET ();
2004 return CFLOAT;
2005
2006 default:
2007 break;
2008 }
2009 }
2010 }
2011
2012
2013 /* Actually local to matching_regexp. These variables must be in
2014 global scope for the case that `static' get's defined away. */
2015
2016 static char *matching_regexp_buffer, *matching_regexp_end_buf;
2017
2018
2019 /* Value is the string from the start of the line to the current
2020 position in the input buffer, or maybe a bit more if that string is
2021 shorter than min_regexp. */
2022
2023 char *
2024 matching_regexp ()
2025 {
2026 char *p;
2027 char *s;
2028 char *t;
2029
2030 if (!f_regexps)
2031 return NULL;
2032
2033 if (matching_regexp_buffer == NULL)
2034 {
2035 matching_regexp_buffer = (char *) xmalloc (max_regexp);
2036 matching_regexp_end_buf = &matching_regexp_buffer[max_regexp] - 1;
2037 }
2038
2039 /* Scan back to previous newline of buffer start. */
2040 for (p = in - 1; p > inbuffer && *p != '\n'; --p)
2041 ;
2042
2043 if (*p == '\n')
2044 {
2045 while (in - p < min_regexp && p > inbuffer)
2046 {
2047 /* Line probably not significant enough */
2048 for (--p; p >= inbuffer && *p != '\n'; --p)
2049 ;
2050 }
2051 if (*p == '\n')
2052 ++p;
2053 }
2054
2055 /* Copy from end to make sure significant portions are included.
2056 This implies that in the browser a regular expressing of the form
2057 `^.*{regexp}' has to be used. */
2058 for (s = matching_regexp_end_buf - 1, t = in;
2059 s > matching_regexp_buffer && t > p;)
2060 {
2061 *--s = *--t;
2062
2063 if (*s == '"' || *s == '\\')
2064 *--s = '\\';
2065 }
2066
2067 *(matching_regexp_end_buf - 1) = '\0';
2068 return xstrdup (s);
2069 }
2070
2071
2072 /* Return a printable representation of token T. */
2073
2074 char *
2075 token_string (t)
2076 int t;
2077 {
2078 static char b[3];
2079
2080 switch (t)
2081 {
2082 case CSTRING: return "string constant";
2083 case CCHAR: return "char constant";
2084 case CINT: return "int constant";
2085 case CFLOAT: return "floating constant";
2086 case ELLIPSIS: return "...";
2087 case LSHIFTASGN: return "<<=";
2088 case RSHIFTASGN: return ">>=";
2089 case ARROWSTAR: return "->*";
2090 case IDENT: return "identifier";
2091 case DIVASGN: return "/=";
2092 case INC: return "++";
2093 case ADDASGN: return "+=";
2094 case DEC: return "--";
2095 case ARROW: return "->";
2096 case SUBASGN: return "-=";
2097 case MULASGN: return "*=";
2098 case MODASGN: return "%=";
2099 case LOR: return "||";
2100 case ORASGN: return "|=";
2101 case LAND: return "&&";
2102 case ANDASGN: return "&=";
2103 case XORASGN: return "^=";
2104 case POINTSTAR: return ".*";
2105 case DCOLON: return "::";
2106 case EQ: return "==";
2107 case NE: return "!=";
2108 case LE: return "<=";
2109 case LSHIFT: return "<<";
2110 case GE: return ">=";
2111 case RSHIFT: return ">>";
2112 case ASM: return "asm";
2113 case AUTO: return "auto";
2114 case BREAK: return "break";
2115 case CASE: return "case";
2116 case CATCH: return "catch";
2117 case CHAR: return "char";
2118 case CLASS: return "class";
2119 case CONST: return "const";
2120 case CONTINUE: return "continue";
2121 case DEFAULT: return "default";
2122 case DELETE: return "delete";
2123 case DO: return "do";
2124 case DOUBLE: return "double";
2125 case ELSE: return "else";
2126 case ENUM: return "enum";
2127 case EXTERN: return "extern";
2128 case FLOAT: return "float";
2129 case FOR: return "for";
2130 case FRIEND: return "friend";
2131 case GOTO: return "goto";
2132 case IF: return "if";
2133 case T_INLINE: return "inline";
2134 case INT: return "int";
2135 case LONG: return "long";
2136 case NEW: return "new";
2137 case OPERATOR: return "operator";
2138 case PRIVATE: return "private";
2139 case PROTECTED: return "protected";
2140 case PUBLIC: return "public";
2141 case REGISTER: return "register";
2142 case RETURN: return "return";
2143 case SHORT: return "short";
2144 case SIGNED: return "signed";
2145 case SIZEOF: return "sizeof";
2146 case STATIC: return "static";
2147 case STRUCT: return "struct";
2148 case SWITCH: return "switch";
2149 case TEMPLATE: return "template";
2150 case THIS: return "this";
2151 case THROW: return "throw";
2152 case TRY: return "try";
2153 case TYPEDEF: return "typedef";
2154 case UNION: return "union";
2155 case UNSIGNED: return "unsigned";
2156 case VIRTUAL: return "virtual";
2157 case VOID: return "void";
2158 case VOLATILE: return "volatile";
2159 case WHILE: return "while";
2160 case MUTABLE: return "mutable";
2161 case BOOL: return "bool";
2162 case TRUE: return "true";
2163 case FALSE: return "false";
2164 case SIGNATURE: return "signature";
2165 case NAMESPACE: return "namespace";
2166 case EXPLICIT: return "explicit";
2167 case TYPENAME: return "typename";
2168 case CONST_CAST: return "const_cast";
2169 case DYNAMIC_CAST: return "dynamic_cast";
2170 case REINTERPRET_CAST: return "reinterpret_cast";
2171 case STATIC_CAST: return "static_cast";
2172 case TYPEID: return "typeid";
2173 case USING: return "using";
2174 case WCHAR: return "wchar_t";
2175 case YYEOF: return "EOF";
2176
2177 default:
2178 if (t < 255)
2179 {
2180 b[0] = t;
2181 b[1] = '\0';
2182 return b;
2183 }
2184 else
2185 return "???";
2186 }
2187 }
2188
2189
2190 /* Reinitialize the scanner for a new input file. */
2191
2192 void
2193 re_init_scanner ()
2194 {
2195 in = inbuffer;
2196 yyline = 1;
2197
2198 if (yytext == NULL)
2199 {
2200 int size = 256;
2201 yytext = (char *) xmalloc (size * sizeof *yytext);
2202 yytext_end = yytext + size;
2203 }
2204 }
2205
2206
2207 /* Insert a keyword NAME with token value TK into the keyword hash
2208 table. */
2209
2210 void
2211 insert_keyword (name, tk)
2212 char *name;
2213 int tk;
2214 {
2215 char *s;
2216 unsigned h = 0;
2217 struct kw *k = (struct kw *) xmalloc (sizeof *k);
2218
2219 for (s = name; *s; ++s)
2220 h = (h << 1) ^ *s;
2221
2222 h %= KEYWORD_TABLE_SIZE;
2223 k->name = name;
2224 k->tk = tk;
2225 k->next = keyword_table[h];
2226 keyword_table[h] = k;
2227 }
2228
2229
2230 /* Initialize the scanner for the first file. This sets up the
2231 character class vectors and fills the keyword hash table. */
2232
2233 void
2234 init_scanner ()
2235 {
2236 int i;
2237
2238 /* Allocate the input buffer */
2239 inbuffer_size = READ_CHUNK_SIZE + 1;
2240 inbuffer = in = (char *) xmalloc (inbuffer_size);
2241 yyline = 1;
2242
2243 /* Set up character class vectors. */
2244 for (i = 0; i < sizeof is_ident; ++i)
2245 {
2246 if (i == '_' || isalnum (i))
2247 is_ident[i] = 1;
2248
2249 if (i >= '0' && i <= '9')
2250 is_digit[i] = 1;
2251
2252 if (i == ' ' || i == '\t' || i == '\f' || i == '\v')
2253 is_white[i] = 1;
2254 }
2255
2256 /* Fill keyword hash table. */
2257 insert_keyword ("and", LAND);
2258 insert_keyword ("and_eq", ANDASGN);
2259 insert_keyword ("asm", ASM);
2260 insert_keyword ("auto", AUTO);
2261 insert_keyword ("bitand", '&');
2262 insert_keyword ("bitor", '|');
2263 insert_keyword ("bool", BOOL);
2264 insert_keyword ("break", BREAK);
2265 insert_keyword ("case", CASE);
2266 insert_keyword ("catch", CATCH);
2267 insert_keyword ("char", CHAR);
2268 insert_keyword ("class", CLASS);
2269 insert_keyword ("compl", '~');
2270 insert_keyword ("const", CONST);
2271 insert_keyword ("const_cast", CONST_CAST);
2272 insert_keyword ("continue", CONTINUE);
2273 insert_keyword ("default", DEFAULT);
2274 insert_keyword ("delete", DELETE);
2275 insert_keyword ("do", DO);
2276 insert_keyword ("double", DOUBLE);
2277 insert_keyword ("dynamic_cast", DYNAMIC_CAST);
2278 insert_keyword ("else", ELSE);
2279 insert_keyword ("enum", ENUM);
2280 insert_keyword ("explicit", EXPLICIT);
2281 insert_keyword ("extern", EXTERN);
2282 insert_keyword ("false", FALSE);
2283 insert_keyword ("float", FLOAT);
2284 insert_keyword ("for", FOR);
2285 insert_keyword ("friend", FRIEND);
2286 insert_keyword ("goto", GOTO);
2287 insert_keyword ("if", IF);
2288 insert_keyword ("inline", T_INLINE);
2289 insert_keyword ("int", INT);
2290 insert_keyword ("long", LONG);
2291 insert_keyword ("mutable", MUTABLE);
2292 insert_keyword ("namespace", NAMESPACE);
2293 insert_keyword ("new", NEW);
2294 insert_keyword ("not", '!');
2295 insert_keyword ("not_eq", NE);
2296 insert_keyword ("operator", OPERATOR);
2297 insert_keyword ("or", LOR);
2298 insert_keyword ("or_eq", ORASGN);
2299 insert_keyword ("private", PRIVATE);
2300 insert_keyword ("protected", PROTECTED);
2301 insert_keyword ("public", PUBLIC);
2302 insert_keyword ("register", REGISTER);
2303 insert_keyword ("reinterpret_cast", REINTERPRET_CAST);
2304 insert_keyword ("return", RETURN);
2305 insert_keyword ("short", SHORT);
2306 insert_keyword ("signed", SIGNED);
2307 insert_keyword ("sizeof", SIZEOF);
2308 insert_keyword ("static", STATIC);
2309 insert_keyword ("static_cast", STATIC_CAST);
2310 insert_keyword ("struct", STRUCT);
2311 insert_keyword ("switch", SWITCH);
2312 insert_keyword ("template", TEMPLATE);
2313 insert_keyword ("this", THIS);
2314 insert_keyword ("throw", THROW);
2315 insert_keyword ("true", TRUE);
2316 insert_keyword ("try", TRY);
2317 insert_keyword ("typedef", TYPEDEF);
2318 insert_keyword ("typeid", TYPEID);
2319 insert_keyword ("typename", TYPENAME);
2320 insert_keyword ("union", UNION);
2321 insert_keyword ("unsigned", UNSIGNED);
2322 insert_keyword ("using", USING);
2323 insert_keyword ("virtual", VIRTUAL);
2324 insert_keyword ("void", VOID);
2325 insert_keyword ("volatile", VOLATILE);
2326 insert_keyword ("wchar_t", WCHAR);
2327 insert_keyword ("while", WHILE);
2328 insert_keyword ("xor", '^');
2329 insert_keyword ("xor_eq", XORASGN);
2330 }
2331
2332
2333 \f
2334 /***********************************************************************
2335 Parser
2336 ***********************************************************************/
2337
2338 /* Match the current lookahead token and set it to the next token. */
2339
2340 #define MATCH() (tk = yylex ())
2341
2342 /* Return the lookahead token. If current lookahead token is cleared,
2343 read a new token. */
2344
2345 #define LA1 (tk == -1 ? (tk = yylex ()) : tk)
2346
2347 /* Is the current lookahead equal to the token T? */
2348
2349 #define LOOKING_AT(T) (tk == (T))
2350
2351 /* Is the current lookahead one of T1 or T2? */
2352
2353 #define LOOKING_AT2(T1, T2) (tk == (T1) || tk == (T2))
2354
2355 /* Is the current lookahead one of T1, T2 or T3? */
2356
2357 #define LOOKING_AT3(T1, T2, T3) (tk == (T1) || tk == (T2) || tk == (T3))
2358
2359 /* Is the current lookahead one of T1...T4? */
2360
2361 #define LOOKING_AT4(T1, T2, T3, T4) \
2362 (tk == (T1) || tk == (T2) || tk == (T3) || tk == (T4))
2363
2364 /* Match token T if current lookahead is T. */
2365
2366 #define MATCH_IF(T) if (LOOKING_AT (T)) MATCH (); else ((void) 0)
2367
2368 /* Skip to matching token if current token is T. */
2369
2370 #define SKIP_MATCHING_IF(T) \
2371 if (LOOKING_AT (T)) skip_matching (); else ((void) 0)
2372
2373
2374 /* Skip forward until a given token TOKEN or YYEOF is seen and return
2375 the current lookahead token after skipping. */
2376
2377 int
2378 skip_to (token)
2379 int token;
2380 {
2381 while (!LOOKING_AT2 (YYEOF, token))
2382 MATCH ();
2383 return tk;
2384 }
2385
2386 /* Skip over pairs of tokens (parentheses, square brackets,
2387 angle brackets, curly brackets) matching the current lookahead. */
2388
2389 void
2390 skip_matching ()
2391 {
2392 int open, close, n;
2393
2394 switch (open = LA1)
2395 {
2396 case '{':
2397 close = '}';
2398 break;
2399
2400 case '(':
2401 close = ')';
2402 break;
2403
2404 case '<':
2405 close = '>';
2406 break;
2407
2408 case '[':
2409 close = ']';
2410 break;
2411
2412 default:
2413 abort ();
2414 }
2415
2416 for (n = 0;;)
2417 {
2418 if (LOOKING_AT (open))
2419 ++n;
2420 else if (LOOKING_AT (close))
2421 --n;
2422 else if (LOOKING_AT (YYEOF))
2423 break;
2424
2425 MATCH ();
2426
2427 if (n == 0)
2428 break;
2429 }
2430 }
2431
2432 void
2433 skip_initializer ()
2434 {
2435 for (;;)
2436 {
2437 switch (LA1)
2438 {
2439 case ';':
2440 case ',':
2441 case YYEOF:
2442 return;
2443
2444 case '{':
2445 case '[':
2446 case '(':
2447 skip_matching ();
2448 break;
2449
2450 default:
2451 MATCH ();
2452 break;
2453 }
2454 }
2455 }
2456
2457 /* Build qualified namespace alias (A::B::c) and return it. */
2458
2459 struct link *
2460 match_qualified_namespace_alias ()
2461 {
2462 struct link *head = NULL;
2463 struct link *cur = NULL;
2464 struct link *tmp = NULL;
2465
2466 for (;;)
2467 {
2468 MATCH ();
2469 switch (LA1)
2470 {
2471 case IDENT:
2472 tmp = (struct link *) xmalloc (sizeof *cur);
2473 tmp->sym = find_namespace (yytext, cur);
2474 tmp->next = NULL;
2475 if (head)
2476 {
2477 cur = cur->next = tmp;
2478 }
2479 else
2480 {
2481 head = cur = tmp;
2482 }
2483 break;
2484 case DCOLON:
2485 /* Just skip */
2486 break;
2487 default:
2488 return head;
2489 break;
2490 }
2491 }
2492 }
2493
2494 /* Re-initialize the parser by resetting the lookahead token. */
2495
2496 void
2497 re_init_parser ()
2498 {
2499 tk = -1;
2500 }
2501
2502
2503 /* Parse a parameter list, including the const-specifier,
2504 pure-specifier, and throw-list that may follow a parameter list.
2505 Return in FLAGS what was seen following the parameter list.
2506 Returns a hash code for the parameter types. This value is used to
2507 distinguish between overloaded functions. */
2508
2509 unsigned
2510 parm_list (flags)
2511 int *flags;
2512 {
2513 unsigned hash = 0;
2514 int type_seen = 0;
2515
2516 while (!LOOKING_AT2 (YYEOF, ')'))
2517 {
2518 switch (LA1)
2519 {
2520 /* Skip over grouping parens or parameter lists in parameter
2521 declarations. */
2522 case '(':
2523 skip_matching ();
2524 break;
2525
2526 /* Next parameter. */
2527 case ',':
2528 MATCH ();
2529 type_seen = 0;
2530 break;
2531
2532 /* Ignore the scope part of types, if any. This is because
2533 some types need scopes when defined outside of a class body,
2534 and don't need them inside the class body. This means that
2535 we have to look for the last IDENT in a sequence of
2536 IDENT::IDENT::... */
2537 case IDENT:
2538 if (!type_seen)
2539 {
2540 char *last_id;
2541 unsigned ident_type_hash = 0;
2542
2543 parse_qualified_param_ident_or_type (&last_id);
2544 if (last_id)
2545 {
2546 /* LAST_ID null means something like `X::*'. */
2547 for (; *last_id; ++last_id)
2548 ident_type_hash = (ident_type_hash << 1) ^ *last_id;
2549 hash = (hash << 1) ^ ident_type_hash;
2550 type_seen = 1;
2551 }
2552 }
2553 else
2554 MATCH ();
2555 break;
2556
2557 case VOID:
2558 /* This distinction is made to make `func (void)' equivalent
2559 to `func ()'. */
2560 type_seen = 1;
2561 MATCH ();
2562 if (!LOOKING_AT (')'))
2563 hash = (hash << 1) ^ VOID;
2564 break;
2565
2566 case BOOL: case CHAR: case CLASS: case CONST:
2567 case DOUBLE: case ENUM: case FLOAT: case INT:
2568 case LONG: case SHORT: case SIGNED: case STRUCT:
2569 case UNION: case UNSIGNED: case VOLATILE: case WCHAR:
2570 case ELLIPSIS:
2571 type_seen = 1;
2572 hash = (hash << 1) ^ LA1;
2573 MATCH ();
2574 break;
2575
2576 case '*': case '&': case '[': case ']':
2577 hash = (hash << 1) ^ LA1;
2578 MATCH ();
2579 break;
2580
2581 default:
2582 MATCH ();
2583 break;
2584 }
2585 }
2586
2587 if (LOOKING_AT (')'))
2588 {
2589 MATCH ();
2590
2591 if (LOOKING_AT (CONST))
2592 {
2593 /* We can overload the same function on `const' */
2594 hash = (hash << 1) ^ CONST;
2595 SET_FLAG (*flags, F_CONST);
2596 MATCH ();
2597 }
2598
2599 if (LOOKING_AT (THROW))
2600 {
2601 MATCH ();
2602 SKIP_MATCHING_IF ('(');
2603 SET_FLAG (*flags, F_THROW);
2604 }
2605
2606 if (LOOKING_AT ('='))
2607 {
2608 MATCH ();
2609 if (LOOKING_AT (CINT) && yyival == 0)
2610 {
2611 MATCH ();
2612 SET_FLAG (*flags, F_PURE);
2613 }
2614 }
2615 }
2616
2617 return hash;
2618 }
2619
2620
2621 /* Print position info to stdout. */
2622
2623 void
2624 print_info ()
2625 {
2626 if (info_position >= 0 && BUFFER_POS () <= info_position)
2627 if (info_cls)
2628 printf ("(\"%s\" \"%s\" \"%s\" %d)\n",
2629 info_cls->name, sym_scope (info_cls),
2630 info_member->name, info_where);
2631 }
2632
2633
2634 /* Parse a member declaration within the class body of CLS. VIS is
2635 the access specifier for the member (private, protected,
2636 public). */
2637
2638 void
2639 member (cls, vis)
2640 struct sym *cls;
2641 int vis;
2642 {
2643 char *id = NULL;
2644 int sc = SC_MEMBER;
2645 char *regexp = NULL;
2646 int pos;
2647 int is_constructor;
2648 int anonymous = 0;
2649 int flags = 0;
2650 int class_tag;
2651 int type_seen = 0;
2652 int paren_seen = 0;
2653 unsigned hash = 0;
2654 int tilde = 0;
2655
2656 while (!LOOKING_AT4 (';', '{', '}', YYEOF))
2657 {
2658 switch (LA1)
2659 {
2660 default:
2661 MATCH ();
2662 break;
2663
2664 /* A function or class may follow. */
2665 case TEMPLATE:
2666 MATCH();
2667 SET_FLAG (flags, F_TEMPLATE);
2668 /* Skip over template argument list */
2669 SKIP_MATCHING_IF ('<');
2670 break;
2671
2672 case EXPLICIT:
2673 SET_FLAG (flags, F_EXPLICIT);
2674 goto typeseen;
2675
2676 case MUTABLE:
2677 SET_FLAG (flags, F_MUTABLE);
2678 goto typeseen;
2679
2680 case T_INLINE:
2681 SET_FLAG (flags, F_INLINE);
2682 goto typeseen;
2683
2684 case VIRTUAL:
2685 SET_FLAG (flags, F_VIRTUAL);
2686 goto typeseen;
2687
2688 case '[':
2689 skip_matching ();
2690 break;
2691
2692 case ENUM:
2693 sc = SC_TYPE;
2694 goto typeseen;
2695
2696 case TYPEDEF:
2697 sc = SC_TYPE;
2698 goto typeseen;
2699
2700 case FRIEND:
2701 sc = SC_FRIEND;
2702 goto typeseen;
2703
2704 case STATIC:
2705 sc = SC_STATIC;
2706 goto typeseen;
2707
2708 case '~':
2709 tilde = 1;
2710 MATCH ();
2711 break;
2712
2713 case IDENT:
2714 /* Remember IDENTS seen so far. Among these will be the member
2715 name. */
2716 id = (char *) xrealloc (id, strlen (yytext) + 2);
2717 if (tilde)
2718 {
2719 *id = '~';
2720 strcpy (id + 1, yytext);
2721 }
2722 else
2723 strcpy (id, yytext);
2724 MATCH ();
2725 break;
2726
2727 case OPERATOR:
2728 {
2729 char *s = operator_name (&sc);
2730 id = (char *) xrealloc (id, strlen (s) + 1);
2731 strcpy (id, s);
2732 }
2733 break;
2734
2735 case '(':
2736 /* Most probably the beginning of a parameter list. */
2737 MATCH ();
2738 paren_seen = 1;
2739
2740 if (id && cls)
2741 {
2742 if (!(is_constructor = streq (id, cls->name)))
2743 regexp = matching_regexp ();
2744 }
2745 else
2746 is_constructor = 0;
2747
2748 pos = BUFFER_POS ();
2749 hash = parm_list (&flags);
2750
2751 if (is_constructor)
2752 regexp = matching_regexp ();
2753
2754 if (id && cls != NULL)
2755 add_member_decl (cls, id, regexp, pos, hash, 0, sc, vis, flags);
2756
2757 while (!LOOKING_AT3 (';', '{', YYEOF))
2758 MATCH ();
2759
2760 if (LOOKING_AT ('{') && id && cls)
2761 add_member_defn (cls, id, regexp, pos, hash, 0, sc, flags);
2762
2763 xfree (id);
2764 id = NULL;
2765 sc = SC_MEMBER;
2766 break;
2767
2768 case STRUCT: case UNION: case CLASS:
2769 /* Nested class */
2770 class_tag = LA1;
2771 type_seen = 1;
2772 MATCH ();
2773 anonymous = 1;
2774
2775 /* More than one ident here to allow for MS-DOS specialties
2776 like `_export class' etc. The last IDENT seen counts
2777 as the class name. */
2778 while (!LOOKING_AT4 (YYEOF, ';', ':', '{'))
2779 {
2780 if (LOOKING_AT (IDENT))
2781 anonymous = 0;
2782 MATCH ();
2783 }
2784
2785 if (LOOKING_AT2 (':', '{'))
2786 class_definition (anonymous ? NULL : cls, class_tag, flags, 1);
2787 else
2788 skip_to (';');
2789 break;
2790
2791 case INT: case CHAR: case LONG: case UNSIGNED:
2792 case SIGNED: case CONST: case DOUBLE: case VOID:
2793 case SHORT: case VOLATILE: case BOOL: case WCHAR:
2794 case TYPENAME:
2795 typeseen:
2796 type_seen = 1;
2797 MATCH ();
2798 break;
2799 }
2800 }
2801
2802 if (LOOKING_AT (';'))
2803 {
2804 /* The end of a member variable, a friend declaration or an access
2805 declaration. We don't want to add friend classes as members. */
2806 if (id && sc != SC_FRIEND && cls)
2807 {
2808 regexp = matching_regexp ();
2809 pos = BUFFER_POS ();
2810
2811 if (cls != NULL)
2812 {
2813 if (type_seen || !paren_seen)
2814 add_member_decl (cls, id, regexp, pos, 0, 1, sc, vis, 0);
2815 else
2816 add_member_decl (cls, id, regexp, pos, hash, 0, sc, vis, 0);
2817 }
2818 }
2819
2820 MATCH ();
2821 print_info ();
2822 }
2823 else if (LOOKING_AT ('{'))
2824 {
2825 /* A named enum. */
2826 if (sc == SC_TYPE && id && cls)
2827 {
2828 regexp = matching_regexp ();
2829 pos = BUFFER_POS ();
2830
2831 if (cls != NULL)
2832 {
2833 add_member_decl (cls, id, regexp, pos, 0, 1, sc, vis, 0);
2834 add_member_defn (cls, id, regexp, pos, 0, 1, sc, 0);
2835 }
2836 }
2837
2838 skip_matching ();
2839 print_info ();
2840 }
2841
2842 xfree (id);
2843 }
2844
2845
2846 /* Parse the body of class CLS. TAG is the tag of the class (struct,
2847 union, class). */
2848
2849 void
2850 class_body (cls, tag)
2851 struct sym *cls;
2852 int tag;
2853 {
2854 int vis = tag == CLASS ? PRIVATE : PUBLIC;
2855 int temp;
2856
2857 while (!LOOKING_AT2 (YYEOF, '}'))
2858 {
2859 switch (LA1)
2860 {
2861 case PRIVATE: case PROTECTED: case PUBLIC:
2862 temp = LA1;
2863 MATCH ();
2864
2865 if (LOOKING_AT (':'))
2866 {
2867 vis = temp;
2868 MATCH ();
2869 }
2870 else
2871 {
2872 /* Probably conditional compilation for inheritance list.
2873 We don't known whether there comes more of this.
2874 This is only a crude fix that works most of the time. */
2875 do
2876 {
2877 MATCH ();
2878 }
2879 while (LOOKING_AT2 (IDENT, ',')
2880 || LOOKING_AT3 (PUBLIC, PROTECTED, PRIVATE));
2881 }
2882 break;
2883
2884 case TYPENAME:
2885 case USING:
2886 skip_to (';');
2887 break;
2888
2889 /* Try to synchronize */
2890 case CHAR: case CLASS: case CONST:
2891 case DOUBLE: case ENUM: case FLOAT: case INT:
2892 case LONG: case SHORT: case SIGNED: case STRUCT:
2893 case UNION: case UNSIGNED: case VOID: case VOLATILE:
2894 case TYPEDEF: case STATIC: case T_INLINE: case FRIEND:
2895 case VIRTUAL: case TEMPLATE: case IDENT: case '~':
2896 case BOOL: case WCHAR: case EXPLICIT: case MUTABLE:
2897 member (cls, vis);
2898 break;
2899
2900 default:
2901 MATCH ();
2902 break;
2903 }
2904 }
2905 }
2906
2907
2908 /* Parse a qualified identifier. Current lookahead is IDENT. A
2909 qualified ident has the form `X<..>::Y<...>::T<...>. Returns a
2910 symbol for that class. */
2911
2912 struct sym *
2913 parse_classname ()
2914 {
2915 struct sym *last_class = NULL;
2916
2917 while (LOOKING_AT (IDENT))
2918 {
2919 last_class = add_sym (yytext, last_class);
2920 MATCH ();
2921
2922 if (LOOKING_AT ('<'))
2923 {
2924 skip_matching ();
2925 SET_FLAG (last_class->flags, F_TEMPLATE);
2926 }
2927
2928 if (!LOOKING_AT (DCOLON))
2929 break;
2930
2931 MATCH ();
2932 }
2933
2934 return last_class;
2935 }
2936
2937
2938 /* Parse an operator name. Add the `static' flag to *SC if an
2939 implicitly static operator has been parsed. Value is a pointer to
2940 a static buffer holding the constructed operator name string. */
2941
2942 char *
2943 operator_name (sc)
2944 int *sc;
2945 {
2946 static int id_size = 0;
2947 static char *id = NULL;
2948 char *s;
2949 int len;
2950
2951 MATCH ();
2952
2953 if (LOOKING_AT2 (NEW, DELETE))
2954 {
2955 /* `new' and `delete' are implicitly static. */
2956 if (*sc != SC_FRIEND)
2957 *sc = SC_STATIC;
2958
2959 s = token_string (LA1);
2960 MATCH ();
2961
2962 len = strlen (s) + 10;
2963 if (len > id_size)
2964 {
2965 int new_size = max (len, 2 * id_size);
2966 id = (char *) xrealloc (id, new_size);
2967 id_size = new_size;
2968 }
2969 strcpy (id, s);
2970
2971 /* Vector new or delete? */
2972 if (LOOKING_AT ('['))
2973 {
2974 strcat (id, "[");
2975 MATCH ();
2976
2977 if (LOOKING_AT (']'))
2978 {
2979 strcat (id, "]");
2980 MATCH ();
2981 }
2982 }
2983 }
2984 else
2985 {
2986 int tokens_matched = 0;
2987
2988 len = 20;
2989 if (len > id_size)
2990 {
2991 int new_size = max (len, 2 * id_size);
2992 id = (char *) xrealloc (id, new_size);
2993 id_size = new_size;
2994 }
2995 strcpy (id, "operator");
2996
2997 /* Beware access declarations of the form "X::f;" Beware of
2998 `operator () ()'. Yet another difficulty is found in
2999 GCC 2.95's STL: `operator == __STL_NULL_TMPL_ARGS (...'. */
3000 while (!(LOOKING_AT ('(') && tokens_matched)
3001 && !LOOKING_AT2 (';', YYEOF))
3002 {
3003 s = token_string (LA1);
3004 len += strlen (s) + 2;
3005 if (len > id_size)
3006 {
3007 int new_size = max (len, 2 * id_size);
3008 id = (char *) xrealloc (id, new_size);
3009 id_size = new_size;
3010 }
3011
3012 if (*s != ')' && *s != ']')
3013 strcat (id, " ");
3014 strcat (id, s);
3015 MATCH ();
3016
3017 /* If this is a simple operator like `+', stop now. */
3018 if (!isalpha ((unsigned char) *s) && *s != '(' && *s != '[')
3019 break;
3020
3021 ++tokens_matched;
3022 }
3023 }
3024
3025 return id;
3026 }
3027
3028
3029 /* This one consumes the last IDENT of a qualified member name like
3030 `X::Y::z'. This IDENT is returned in LAST_ID. Value is the
3031 symbol structure for the ident. */
3032
3033 struct sym *
3034 parse_qualified_ident_or_type (last_id)
3035 char **last_id;
3036 {
3037 struct sym *cls = NULL;
3038 char *id = NULL;
3039 size_t id_size = 0;
3040 int enter = 0;
3041
3042 while (LOOKING_AT (IDENT))
3043 {
3044 int len = strlen (yytext) + 1;
3045 if (len > id_size)
3046 {
3047 id = (char *) xrealloc (id, len);
3048 id_size = len;
3049 }
3050 strcpy (id, yytext);
3051 *last_id = id;
3052 MATCH ();
3053
3054 SKIP_MATCHING_IF ('<');
3055
3056 if (LOOKING_AT (DCOLON))
3057 {
3058 struct sym *pcn = NULL;
3059 struct link *pna = check_namespace_alias (id);
3060 if (pna)
3061 {
3062 do
3063 {
3064 enter_namespace (pna->sym->name);
3065 enter++;
3066 pna = pna->next;
3067 }
3068 while (pna);
3069 }
3070 else if ((pcn = check_namespace (id, current_namespace)))
3071 {
3072 enter_namespace (pcn->name);
3073 enter++;
3074 }
3075 else
3076 cls = add_sym (id, cls);
3077
3078 *last_id = NULL;
3079 xfree (id);
3080 id = NULL;
3081 id_size = 0;
3082 MATCH ();
3083 }
3084 else
3085 break;
3086 }
3087
3088 while (enter--)
3089 leave_namespace();
3090
3091 return cls;
3092 }
3093
3094
3095 /* This one consumes the last IDENT of a qualified member name like
3096 `X::Y::z'. This IDENT is returned in LAST_ID. Value is the
3097 symbol structure for the ident. */
3098
3099 void
3100 parse_qualified_param_ident_or_type (last_id)
3101 char **last_id;
3102 {
3103 struct sym *cls = NULL;
3104 static char *id = NULL;
3105 static int id_size = 0;
3106
3107 while (LOOKING_AT (IDENT))
3108 {
3109 int len = strlen (yytext) + 1;
3110 if (len > id_size)
3111 {
3112 id = (char *) xrealloc (id, len);
3113 id_size = len;
3114 }
3115 strcpy (id, yytext);
3116 *last_id = id;
3117 MATCH ();
3118
3119 SKIP_MATCHING_IF ('<');
3120
3121 if (LOOKING_AT (DCOLON))
3122 {
3123 cls = add_sym (id, cls);
3124 *last_id = NULL;
3125 MATCH ();
3126 }
3127 else
3128 break;
3129 }
3130 }
3131
3132
3133 /* Parse a class definition.
3134
3135 CONTAINING is the class containing the class being parsed or null.
3136 This may also be null if NESTED != 0 if the containing class is
3137 anonymous. TAG is the tag of the class (struct, union, class).
3138 NESTED is non-zero if we are parsing a nested class.
3139
3140 Current lookahead is the class name. */
3141
3142 void
3143 class_definition (containing, tag, flags, nested)
3144 struct sym *containing;
3145 int tag;
3146 int flags;
3147 int nested;
3148 {
3149 struct sym *current;
3150 struct sym *base_class;
3151
3152 /* Set CURRENT to null if no entry has to be made for the class
3153 parsed. This is the case for certain command line flag
3154 settings. */
3155 if ((tag != CLASS && !f_structs) || (nested && !f_nested_classes))
3156 current = NULL;
3157 else
3158 {
3159 current = add_sym (yytext, containing);
3160 current->pos = BUFFER_POS ();
3161 current->regexp = matching_regexp ();
3162 current->filename = filename;
3163 current->flags = flags;
3164 }
3165
3166 /* If at ':', base class list follows. */
3167 if (LOOKING_AT (':'))
3168 {
3169 int done = 0;
3170 MATCH ();
3171
3172 while (!done)
3173 {
3174 switch (LA1)
3175 {
3176 case VIRTUAL: case PUBLIC: case PROTECTED: case PRIVATE:
3177 MATCH ();
3178 break;
3179
3180 case IDENT:
3181 base_class = parse_classname ();
3182 if (base_class && current && base_class != current)
3183 add_link (base_class, current);
3184 break;
3185
3186 /* The `,' between base classes or the end of the base
3187 class list. Add the previously found base class.
3188 It's done this way to skip over sequences of
3189 `A::B::C' until we reach the end.
3190
3191 FIXME: it is now possible to handle `class X : public B::X'
3192 because we have enough information. */
3193 case ',':
3194 MATCH ();
3195 break;
3196
3197 default:
3198 /* A syntax error, possibly due to preprocessor constructs
3199 like
3200
3201 #ifdef SOMETHING
3202 class A : public B
3203 #else
3204 class A : private B.
3205
3206 MATCH until we see something like `;' or `{'. */
3207 while (!LOOKING_AT3 (';', YYEOF, '{'))
3208 MATCH ();
3209 done = 1;
3210
3211 case '{':
3212 done = 1;
3213 break;
3214 }
3215 }
3216 }
3217
3218 /* Parse the class body if there is one. */
3219 if (LOOKING_AT ('{'))
3220 {
3221 if (tag != CLASS && !f_structs)
3222 skip_matching ();
3223 else
3224 {
3225 MATCH ();
3226 class_body (current, tag);
3227
3228 if (LOOKING_AT ('}'))
3229 {
3230 MATCH ();
3231 if (LOOKING_AT (';') && !nested)
3232 MATCH ();
3233 }
3234 }
3235 }
3236 }
3237
3238 /* Add to class *CLS information for the declaration of variable or
3239 type *ID. If *CLS is null, this means a global declaration. SC is
3240 the storage class of *ID. FLAGS is a bit set giving additional
3241 information about the member (see the F_* defines). */
3242
3243 void
3244 add_declarator (cls, id, flags, sc)
3245 struct sym **cls;
3246 char **id;
3247 int flags, sc;
3248 {
3249 if (LOOKING_AT2 (';', ','))
3250 {
3251 /* The end of a member variable or of an access declaration
3252 `X::f'. To distinguish between them we have to know whether
3253 type information has been seen. */
3254 if (*id)
3255 {
3256 char *regexp = matching_regexp ();
3257 int pos = BUFFER_POS ();
3258
3259 if (*cls)
3260 add_member_defn (*cls, *id, regexp, pos, 0, 1, SC_UNKNOWN, flags);
3261 else
3262 add_global_defn (*id, regexp, pos, 0, 1, sc, flags);
3263 }
3264
3265 MATCH ();
3266 print_info ();
3267 }
3268 else if (LOOKING_AT ('{'))
3269 {
3270 if (sc == SC_TYPE && *id)
3271 {
3272 /* A named enumeration. */
3273 char *regexp = matching_regexp ();
3274 int pos = BUFFER_POS ();
3275 add_global_defn (*id, regexp, pos, 0, 1, sc, flags);
3276 }
3277
3278 skip_matching ();
3279 print_info ();
3280 }
3281
3282 xfree (*id);
3283 *id = NULL;
3284 *cls = NULL;
3285 }
3286
3287 /* Parse a declaration. */
3288
3289 void
3290 declaration (flags)
3291 int flags;
3292 {
3293 char *id = NULL;
3294 struct sym *cls = NULL;
3295 char *regexp = NULL;
3296 int pos = 0;
3297 unsigned hash = 0;
3298 int is_constructor;
3299 int sc = 0;
3300
3301 while (!LOOKING_AT3 (';', '{', YYEOF))
3302 {
3303 switch (LA1)
3304 {
3305 default:
3306 MATCH ();
3307 break;
3308
3309 case '[':
3310 skip_matching ();
3311 break;
3312
3313 case ENUM:
3314 case TYPEDEF:
3315 sc = SC_TYPE;
3316 MATCH ();
3317 break;
3318
3319 case STATIC:
3320 sc = SC_STATIC;
3321 MATCH ();
3322 break;
3323
3324 case INT: case CHAR: case LONG: case UNSIGNED:
3325 case SIGNED: case CONST: case DOUBLE: case VOID:
3326 case SHORT: case VOLATILE: case BOOL: case WCHAR:
3327 MATCH ();
3328 break;
3329
3330 case CLASS: case STRUCT: case UNION:
3331 /* This is for the case `STARTWRAP class X : ...' or
3332 `declare (X, Y)\n class A : ...'. */
3333 if (id)
3334 {
3335 xfree (id);
3336 return;
3337 }
3338
3339 case '=':
3340 /* Assumed to be the start of an initialization in this
3341 context. */
3342 skip_initializer ();
3343 break;
3344
3345 case ',':
3346 add_declarator (&cls, &id, flags, sc);
3347 break;
3348
3349 case OPERATOR:
3350 {
3351 char *s = operator_name (&sc);
3352 id = (char *) xrealloc (id, strlen (s) + 1);
3353 strcpy (id, s);
3354 }
3355 break;
3356
3357 case T_INLINE:
3358 SET_FLAG (flags, F_INLINE);
3359 MATCH ();
3360 break;
3361
3362 case '~':
3363 MATCH ();
3364 if (LOOKING_AT (IDENT))
3365 {
3366 id = (char *) xrealloc (id, strlen (yytext) + 2);
3367 *id = '~';
3368 strcpy (id + 1, yytext);
3369 MATCH ();
3370 }
3371 break;
3372
3373 case IDENT:
3374 cls = parse_qualified_ident_or_type (&id);
3375 break;
3376
3377 case '(':
3378 /* Most probably the beginning of a parameter list. */
3379 if (cls)
3380 {
3381 MATCH ();
3382
3383 if (id && cls)
3384 {
3385 if (!(is_constructor = streq (id, cls->name)))
3386 regexp = matching_regexp ();
3387 }
3388 else
3389 is_constructor = 0;
3390
3391 pos = BUFFER_POS ();
3392 hash = parm_list (&flags);
3393
3394 if (is_constructor)
3395 regexp = matching_regexp ();
3396
3397 if (id && cls)
3398 add_member_defn (cls, id, regexp, pos, hash, 0,
3399 SC_UNKNOWN, flags);
3400 }
3401 else
3402 {
3403 /* This may be a C functions, but also a macro
3404 call of the form `declare (A, B)' --- such macros
3405 can be found in some class libraries. */
3406 MATCH ();
3407
3408 if (id)
3409 {
3410 regexp = matching_regexp ();
3411 pos = BUFFER_POS ();
3412 hash = parm_list (&flags);
3413 add_global_decl (id, regexp, pos, hash, 0, sc, flags);
3414 }
3415
3416 /* This is for the case that the function really is
3417 a macro with no `;' following it. If a CLASS directly
3418 follows, we would miss it otherwise. */
3419 if (LOOKING_AT3 (CLASS, STRUCT, UNION))
3420 return;
3421 }
3422
3423 while (!LOOKING_AT3 (';', '{', YYEOF))
3424 MATCH ();
3425
3426 if (!cls && id && LOOKING_AT ('{'))
3427 add_global_defn (id, regexp, pos, hash, 0, sc, flags);
3428
3429 xfree (id);
3430 id = NULL;
3431 break;
3432 }
3433 }
3434
3435 add_declarator (&cls, &id, flags, sc);
3436 }
3437
3438
3439 /* Parse a list of top-level declarations/definitions. START_FLAGS
3440 says in which context we are parsing. If it is F_EXTERNC, we are
3441 parsing in an `extern "C"' block. Value is 1 if EOF is reached, 0
3442 otherwise. */
3443
3444 int
3445 globals (start_flags)
3446 int start_flags;
3447 {
3448 int anonymous;
3449 int class_tk;
3450 int flags = start_flags;
3451
3452 for (;;)
3453 {
3454 char *prev_in = in;
3455
3456 switch (LA1)
3457 {
3458 case NAMESPACE:
3459 {
3460 MATCH ();
3461
3462 if (LOOKING_AT (IDENT))
3463 {
3464 char *namespace_name = xstrdup (yytext);
3465 MATCH ();
3466
3467 if (LOOKING_AT ('='))
3468 {
3469 struct link *qna = match_qualified_namespace_alias ();
3470 if (qna)
3471 register_namespace_alias (namespace_name, qna);
3472
3473 if (skip_to (';') == ';')
3474 MATCH ();
3475 }
3476 else if (LOOKING_AT ('{'))
3477 {
3478 MATCH ();
3479 enter_namespace (namespace_name);
3480 globals (0);
3481 leave_namespace ();
3482 MATCH_IF ('}');
3483 }
3484
3485 xfree (namespace_name);
3486 }
3487 }
3488 break;
3489
3490 case EXTERN:
3491 MATCH ();
3492 if (LOOKING_AT (CSTRING) && *string_start == 'C'
3493 && *(string_start + 1) == '"')
3494 {
3495 /* This is `extern "C"'. */
3496 MATCH ();
3497
3498 if (LOOKING_AT ('{'))
3499 {
3500 MATCH ();
3501 globals (F_EXTERNC);
3502 MATCH_IF ('}');
3503 }
3504 else
3505 SET_FLAG (flags, F_EXTERNC);
3506 }
3507 break;
3508
3509 case TEMPLATE:
3510 MATCH ();
3511 SKIP_MATCHING_IF ('<');
3512 SET_FLAG (flags, F_TEMPLATE);
3513 break;
3514
3515 case CLASS: case STRUCT: case UNION:
3516 class_tk = LA1;
3517 MATCH ();
3518 anonymous = 1;
3519
3520 /* More than one ident here to allow for MS-DOS and OS/2
3521 specialties like `far', `_Export' etc. Some C++ libs
3522 have constructs like `_OS_DLLIMPORT(_OS_CLIENT)' in front
3523 of the class name. */
3524 while (!LOOKING_AT4 (YYEOF, ';', ':', '{'))
3525 {
3526 if (LOOKING_AT (IDENT))
3527 anonymous = 0;
3528 MATCH ();
3529 }
3530
3531 /* Don't add anonymous unions. */
3532 if (LOOKING_AT2 (':', '{') && !anonymous)
3533 class_definition (NULL, class_tk, flags, 0);
3534 else
3535 {
3536 if (skip_to (';') == ';')
3537 MATCH ();
3538 }
3539
3540 flags = start_flags;
3541 break;
3542
3543 case YYEOF:
3544 return 1;
3545
3546 case '}':
3547 return 0;
3548
3549 default:
3550 declaration (flags);
3551 flags = start_flags;
3552 break;
3553 }
3554
3555 if (prev_in == in)
3556 yyerror ("parse error", NULL);
3557 }
3558 }
3559
3560
3561 /* Parse the current input file. */
3562
3563 void
3564 yyparse ()
3565 {
3566 while (globals (0) == 0)
3567 MATCH_IF ('}');
3568 }
3569
3570
3571 \f
3572 /***********************************************************************
3573 Main Program
3574 ***********************************************************************/
3575
3576 /* Add the list of paths PATH_LIST to the current search path for
3577 input files. */
3578
3579 void
3580 add_search_path (path_list)
3581 char *path_list;
3582 {
3583 while (*path_list)
3584 {
3585 char *start = path_list;
3586 struct search_path *p;
3587
3588 while (*path_list && *path_list != PATH_LIST_SEPARATOR)
3589 ++path_list;
3590
3591 p = (struct search_path *) xmalloc (sizeof *p);
3592 p->path = (char *) xmalloc (path_list - start + 1);
3593 memcpy (p->path, start, path_list - start);
3594 p->path[path_list - start] = '\0';
3595 p->next = NULL;
3596
3597 if (search_path_tail)
3598 {
3599 search_path_tail->next = p;
3600 search_path_tail = p;
3601 }
3602 else
3603 search_path = search_path_tail = p;
3604
3605 while (*path_list == PATH_LIST_SEPARATOR)
3606 ++path_list;
3607 }
3608 }
3609
3610
3611 /* Open FILE and return a file handle for it, or -1 if FILE cannot be
3612 opened. Try to find FILE in search_path first, then try the
3613 unchanged file name. */
3614
3615 FILE *
3616 open_file (file)
3617 char *file;
3618 {
3619 FILE *fp = NULL;
3620 static char *buffer;
3621 static int buffer_size;
3622 struct search_path *path;
3623 int flen = strlen (file) + 1; /* +1 for the slash */
3624
3625 filename = xstrdup (file);
3626
3627 for (path = search_path; path && fp == NULL; path = path->next)
3628 {
3629 int len = strlen (path->path) + flen;
3630
3631 if (len + 1 >= buffer_size)
3632 {
3633 buffer_size = max (len + 1, 2 * buffer_size);
3634 buffer = (char *) xrealloc (buffer, buffer_size);
3635 }
3636
3637 strcpy (buffer, path->path);
3638 strcat (buffer, "/");
3639 strcat (buffer, file);
3640 fp = fopen (buffer, "r");
3641 }
3642
3643 /* Try the original file name. */
3644 if (fp == NULL)
3645 fp = fopen (file, "r");
3646
3647 if (fp == NULL)
3648 yyerror ("cannot open", NULL);
3649
3650 return fp;
3651 }
3652
3653
3654 /* Display usage information and exit program. */
3655
3656 #define USAGE "\
3657 Usage: ebrowse [options] {files}\n\
3658 \n\
3659 -a, --append append output to existing file\n\
3660 -f, --files=FILES read input file names from FILE\n\
3661 -I, --search-path=LIST set search path for input files\n\
3662 -m, --min-regexp-length=N set minimum regexp length to N\n\
3663 -M, --max-regexp-length=N set maximum regexp length to N\n\
3664 -n, --no-nested-classes exclude nested classes\n\
3665 -o, --output-file=FILE set output file name to FILE\n\
3666 -p, --position-info print info about position in file\n\
3667 -s, --no-structs-or-unions don't record structs or unions\n\
3668 -v, --verbose be verbose\n\
3669 -V, --very-verbose be very verbose\n\
3670 -x, --no-regexps don't record regular expressions\n\
3671 --help display this help\n\
3672 --version display version info\n\
3673 "
3674
3675 void
3676 usage (error)
3677 int error;
3678 {
3679 puts (USAGE);
3680 exit (error ? EXIT_FAILURE : EXIT_SUCCESS);
3681 }
3682
3683
3684 /* Display version and copyright info. The VERSION macro is set
3685 from the Makefile and contains the Emacs version. */
3686
3687 #ifndef VERSION
3688 # define VERSION "21"
3689 #endif
3690
3691 void
3692 version ()
3693 {
3694 /* Makes it easier to update automatically. */
3695 char emacs_copyright[] = "Copyright (C) 2008 Free Software Foundation, Inc.";
3696
3697 printf ("ebrowse %s\n", VERSION);
3698 puts (emacs_copyright);
3699 puts ("This program is distributed under the same terms as Emacs.");
3700 exit (EXIT_SUCCESS);
3701 }
3702
3703
3704 /* Parse one input file FILE, adding classes and members to the symbol
3705 table. */
3706
3707 void
3708 process_file (file)
3709 char *file;
3710 {
3711 FILE *fp;
3712
3713 fp = open_file (file);
3714 if (fp)
3715 {
3716 int nread, nbytes;
3717
3718 /* Give a progress indication if needed. */
3719 if (f_very_verbose)
3720 {
3721 puts (filename);
3722 fflush (stdout);
3723 }
3724 else if (f_verbose)
3725 {
3726 putchar ('.');
3727 fflush (stdout);
3728 }
3729
3730 /* Read file to inbuffer. */
3731 for (nread = 0;;)
3732 {
3733 if (nread + READ_CHUNK_SIZE >= inbuffer_size)
3734 {
3735 inbuffer_size = nread + READ_CHUNK_SIZE + 1;
3736 inbuffer = (char *) xrealloc (inbuffer, inbuffer_size);
3737 }
3738
3739 nbytes = fread (inbuffer + nread, 1, READ_CHUNK_SIZE, fp);
3740 if (nbytes <= 0)
3741 break;
3742 nread += nbytes;
3743 }
3744 if (nread < 0)
3745 nread = 0;
3746 inbuffer[nread] = '\0';
3747
3748 /* Reinitialize scanner and parser for the new input file. */
3749 re_init_scanner ();
3750 re_init_parser ();
3751
3752 /* Parse it and close the file. */
3753 yyparse ();
3754 fclose (fp);
3755 }
3756 }
3757
3758
3759 /* Read a line from stream FP and return a pointer to a static buffer
3760 containing its contents without the terminating newline. Value
3761 is null when EOF is reached. */
3762
3763 char *
3764 read_line (fp)
3765 FILE *fp;
3766 {
3767 static char *buffer;
3768 static int buffer_size;
3769 int i = 0, c;
3770
3771 while ((c = getc (fp)) != EOF && c != '\n')
3772 {
3773 if (i >= buffer_size)
3774 {
3775 buffer_size = max (100, buffer_size * 2);
3776 buffer = (char *) xrealloc (buffer, buffer_size);
3777 }
3778
3779 buffer[i++] = c;
3780 }
3781
3782 if (c == EOF && i == 0)
3783 return NULL;
3784
3785 if (i == buffer_size)
3786 {
3787 buffer_size = max (100, buffer_size * 2);
3788 buffer = (char *) xrealloc (buffer, buffer_size);
3789 }
3790
3791 buffer[i] = '\0';
3792 if (i > 0 && buffer[i - 1] == '\r')
3793 buffer[i - 1] = '\0';
3794 return buffer;
3795 }
3796
3797
3798 /* Main entry point. */
3799
3800 int
3801 main (argc, argv)
3802 int argc;
3803 char **argv;
3804 {
3805 int i;
3806 int any_inputfiles = 0;
3807 static char *out_filename = DEFAULT_OUTFILE;
3808 static char **input_filenames = NULL;
3809 static int input_filenames_size = 0;
3810 static int n_input_files;
3811
3812 filename = "command line";
3813 yyout = stdout;
3814
3815 while ((i = getopt_long (argc, argv, "af:I:m:M:no:p:svVx",
3816 options, NULL)) != EOF)
3817 {
3818 switch (i)
3819 {
3820 /* Experimental. */
3821 case 'p':
3822 info_position = atoi (optarg);
3823 break;
3824
3825 case 'n':
3826 f_nested_classes = 0;
3827 break;
3828
3829 case 'x':
3830 f_regexps = 0;
3831 break;
3832
3833 /* Add the name of a file containing more input files. */
3834 case 'f':
3835 if (n_input_files == input_filenames_size)
3836 {
3837 input_filenames_size = max (10, 2 * input_filenames_size);
3838 input_filenames = (char **) xrealloc ((void *)input_filenames,
3839 input_filenames_size);
3840 }
3841 input_filenames[n_input_files++] = xstrdup (optarg);
3842 break;
3843
3844 /* Append new output to output file instead of truncating it. */
3845 case 'a':
3846 f_append = 1;
3847 break;
3848
3849 /* Include structs in the output */
3850 case 's':
3851 f_structs = 0;
3852 break;
3853
3854 /* Be verbose (give a progress indication). */
3855 case 'v':
3856 f_verbose = 1;
3857 break;
3858
3859 /* Be very verbose (print file names as they are processed). */
3860 case 'V':
3861 f_verbose = 1;
3862 f_very_verbose = 1;
3863 break;
3864
3865 /* Change the name of the output file. */
3866 case 'o':
3867 out_filename = optarg;
3868 break;
3869
3870 /* Set minimum length for regular expression strings
3871 when recorded in the output file. */
3872 case 'm':
3873 min_regexp = atoi (optarg);
3874 break;
3875
3876 /* Set maximum length for regular expression strings
3877 when recorded in the output file. */
3878 case 'M':
3879 max_regexp = atoi (optarg);
3880 break;
3881
3882 /* Add to search path. */
3883 case 'I':
3884 add_search_path (optarg);
3885 break;
3886
3887 /* Display help */
3888 case -2:
3889 usage (0);
3890 break;
3891
3892 case -3:
3893 version ();
3894 break;
3895 }
3896 }
3897
3898 /* Call init_scanner after command line flags have been processed to be
3899 able to add keywords depending on command line (not yet
3900 implemented). */
3901 init_scanner ();
3902 init_sym ();
3903
3904 /* Open output file */
3905 if (*out_filename)
3906 {
3907 if (f_append)
3908 {
3909 /* Check that the file to append to exists, and is not
3910 empty. More specifically, it should be a valid file
3911 produced by a previous run of ebrowse, but that's too
3912 difficult to check. */
3913 FILE *fp;
3914 int rc;
3915
3916 fp = fopen (out_filename, "r");
3917 if (fp == NULL)
3918 {
3919 yyerror ("file `%s' must exist for --append", out_filename);
3920 exit (EXIT_FAILURE);
3921 }
3922
3923 rc = fseek (fp, 0, SEEK_END);
3924 if (rc == -1)
3925 {
3926 yyerror ("error seeking in file `%s'", out_filename);
3927 exit (EXIT_FAILURE);
3928 }
3929
3930 rc = ftell (fp);
3931 if (rc == -1)
3932 {
3933 yyerror ("error getting size of file `%s'", out_filename);
3934 exit (EXIT_FAILURE);
3935 }
3936
3937 else if (rc == 0)
3938 {
3939 yyerror ("file `%s' is empty", out_filename);
3940 /* It may be ok to use an empty file for appending.
3941 exit (EXIT_FAILURE); */
3942 }
3943
3944 fclose (fp);
3945 }
3946
3947 yyout = fopen (out_filename, f_append ? "a" : "w");
3948 if (yyout == NULL)
3949 {
3950 yyerror ("cannot open output file `%s'", out_filename);
3951 exit (EXIT_FAILURE);
3952 }
3953 }
3954
3955 /* Process input files specified on the command line. */
3956 while (optind < argc)
3957 {
3958 process_file (argv[optind++]);
3959 any_inputfiles = 1;
3960 }
3961
3962 /* Process files given on stdin if no files specified. */
3963 if (!any_inputfiles && n_input_files == 0)
3964 {
3965 char *file;
3966 while ((file = read_line (stdin)) != NULL)
3967 process_file (file);
3968 }
3969 else
3970 {
3971 /* Process files from `--files=FILE'. Every line in FILE names
3972 one input file to process. */
3973 for (i = 0; i < n_input_files; ++i)
3974 {
3975 FILE *fp = fopen (input_filenames[i], "r");
3976
3977 if (fp == NULL)
3978 yyerror ("cannot open input file `%s'", input_filenames[i]);
3979 else
3980 {
3981 char *file;
3982 while ((file = read_line (fp)) != NULL)
3983 process_file (file);
3984 fclose (fp);
3985 }
3986 }
3987 }
3988
3989 /* Write output file. */
3990 dump_roots (yyout);
3991
3992 /* Close output file. */
3993 if (yyout != stdout)
3994 fclose (yyout);
3995
3996 return EXIT_SUCCESS;
3997 }
3998
3999 /* arch-tag: fc03b4bc-91a9-4c3d-b3b9-12a77fa86dd8
4000 (do not change this comment) */
4001
4002 /* ebrowse.c ends here */
Unnamed repository; edit this file 'description' to name the repository.