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