1 /* ebrowse.c --- parsing files for the ebrowse C++ browser
3 Copyright (C) 1992-1999, 2000 Free Software Foundation Inc.
5 Author: Gerd Moellmann <gerd@gnu.org>
8 This file is part of GNU Emacs.
10 GNU Emacs is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
15 GNU Emacs is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GNU Emacs; see the file COPYING. If not, write to
22 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
35 /* Conditionalize function prototypes. */
37 #ifdef PROTOTYPES /* From config.h. */
43 /* Value is non-zero if strings X and Y compare equal. */
45 #define streq(X, Y) (*(X) == *(Y) && strcmp ((X) + 1, (Y) + 1) == 0)
47 /* The ubiquitous `max' and `min' macros. */
50 #define max(X, Y) ((X) > (Y) ? (X) : (Y))
51 #define min(X, Y) ((X) < (Y) ? (X) : (Y))
54 /* Files are read in chunks of this number of bytes. */
56 #define READ_CHUNK_SIZE (100 * 1024)
58 /* The character used as a separator in path lists (like $PATH). */
60 #define PATH_LIST_SEPARATOR ':'
62 /* The default output file name. */
64 #define DEFAULT_OUTFILE "EBROWSE"
66 /* A version string written to the output file. Change this whenever
67 the structure of the output file changes. */
69 #define EBROWSE_FILE_VERSION "ebrowse 5.0"
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. */
75 #define TREE_HEADER_STRUCT "[ebrowse-hs "
76 #define TREE_STRUCT "[ebrowse-ts "
77 #define MEMBER_STRUCT "[ebrowse-ms "
78 #define BROWSE_STRUCT "[ebrowse-bs "
79 #define CLASS_STRUCT "[ebrowse-cs "
81 /* The name of the symbol table entry for global functions, variables,
82 defines etc. This name also appears in the browser display. */
84 #define GLOBALS_NAME "*Globals*"
86 /* Token definitions. */
90 YYEOF
= 0, /* end of file */
91 CSTRING
= 256, /* string constant */
92 CCHAR
, /* character constant */
93 CINT
, /* integral constant */
94 CFLOAT
, /* real constant */
100 IDENT
, /* identifier */
123 /* Keywords. The undef's are there because these
124 three symbols are very likely to be defined somewhere. */
137 CONTINUE
, /* continue */
138 DEFAULT
, /* default */
150 T_INLINE
, /* inline */
154 OPERATOR
, /* operator */
155 PRIVATE
, /* private */
156 PROTECTED
, /* protected */
158 REGISTER
, /* register */
166 TEMPLATE
, /* template */
170 TYPEDEF
, /* typedef */
172 UNSIGNED
, /* unsigned */
173 VIRTUAL
, /* virtual */
175 VOLATILE
, /* volatile */
177 MUTABLE
, /* mutable */
181 SIGNATURE
, /* signature (GNU extension) */
182 NAMESPACE
, /* namespace */
183 EXPLICIT
, /* explicit */
184 TYPENAME
, /* typename */
185 CONST_CAST
, /* const_cast */
186 DYNAMIC_CAST
, /* dynamic_cast */
187 REINTERPRET_CAST
, /* reinterpret_cast */
188 STATIC_CAST
, /* static_cast */
194 /* Storage classes, in a wider sense. */
199 SC_MEMBER
, /* Is an instance member. */
200 SC_STATIC
, /* Is static member. */
201 SC_FRIEND
, /* Is friend function. */
202 SC_TYPE
/* Is a type definition. */
205 /* Member visibility. */
216 #define F_VIRTUAL 1 /* Is virtual function. */
217 #define F_INLINE 2 /* Is inline function. */
218 #define F_CONST 4 /* Is const. */
219 #define F_PURE 8 /* Is pure virtual function. */
220 #define F_MUTABLE 16 /* Is mutable. */
221 #define F_TEMPLATE 32 /* Is a template. */
222 #define F_EXPLICIT 64 /* Is explicit constructor. */
223 #define F_THROW 128 /* Has a throw specification. */
224 #define F_EXTERNC 256 /* Is declared extern "C". */
225 #define F_DEFINE 512 /* Is a #define. */
227 /* Two macros to set and test a bit in an int. */
229 #define SET_FLAG(F, FLAG) ((F) |= (FLAG))
230 #define HAS_FLAG(F, FLAG) (((F) & (FLAG)) != 0)
232 /* Structure describing a class member. */
236 struct member
*next
; /* Next in list of members. */
237 struct member
*anext
; /* Collision chain in member_table. */
238 struct member
**list
; /* Pointer to list in class. */
239 unsigned param_hash
; /* Hash value for parameter types. */
240 int vis
; /* Visibility (public, ...). */
241 int flags
; /* See F_* above. */
242 char *regexp
; /* Matching regular expression. */
243 char *filename
; /* Don't free this shared string. */
244 int pos
; /* Buffer position of occurrence. */
245 char *def_regexp
; /* Regular expression matching definition. */
246 char *def_filename
; /* File name of definition. */
247 int def_pos
; /* Buffer position of definition. */
248 char name
[1]; /* Member name. */
251 /* Structures of this type are used to connect class structures with
252 their super and subclasses. */
256 struct sym
*sym
; /* The super or subclass. */
257 struct link
*next
; /* Next in list or NULL. */
260 /* Structure used to record namespace aliases. */
264 struct alias
*next
; /* Next in list. */
265 char name
[1]; /* Alias name. */
268 /* The structure used to describe a class in the symbol table,
269 or a namespace in all_namespaces. */
273 int flags
; /* Is class a template class?. */
274 unsigned char visited
; /* Used to find circles. */
275 struct sym
*next
; /* Hash collision list. */
276 struct link
*subs
; /* List of subclasses. */
277 struct link
*supers
; /* List of superclasses. */
278 struct member
*vars
; /* List of instance variables. */
279 struct member
*fns
; /* List of instance functions. */
280 struct member
*static_vars
; /* List of static variables. */
281 struct member
*static_fns
; /* List of static functions. */
282 struct member
*friends
; /* List of friend functions. */
283 struct member
*types
; /* List of local types. */
284 char *regexp
; /* Matching regular expression. */
285 int pos
; /* Buffer position. */
286 char *filename
; /* File in which it can be found. */
287 char *sfilename
; /* File in which members can be found. */
288 struct sym
*namesp
; /* Namespace in which defined. . */
289 struct alias
*namesp_aliases
; /* List of aliases for namespaces. */
290 char name
[1]; /* Name of the class. */
293 /* Experimental: Print info for `--position-info'. We print
294 '(CLASS-NAME SCOPE MEMBER-NAME). */
300 struct sym
*info_cls
= NULL
;
301 struct member
*info_member
= NULL
;
303 /* Experimental. For option `--position-info', the buffer position we
304 are interested in. When this position is reached, print out
305 information about what we know about that point. */
307 int info_position
= -1;
309 /* Command line options structure for getopt_long. */
311 struct option options
[] =
313 {"append", no_argument
, NULL
, 'a'},
314 {"files", required_argument
, NULL
, 'f'},
315 {"help", no_argument
, NULL
, -2},
316 {"min-regexp-length", required_argument
, NULL
, 'm'},
317 {"max-regexp-length", required_argument
, NULL
, 'M'},
318 {"no-nested-classes", no_argument
, NULL
, 'n'},
319 {"no-regexps", no_argument
, NULL
, 'x'},
320 {"no-structs-or-unions", no_argument
, NULL
, 's'},
321 {"output-file", required_argument
, NULL
, 'o'},
322 {"position-info", required_argument
, NULL
, 'p'},
323 {"search-path", required_argument
, NULL
, 'I'},
324 {"verbose", no_argument
, NULL
, 'v'},
325 {"version", no_argument
, NULL
, -3},
326 {"very-verbose", no_argument
, NULL
, 'V'},
330 /* Semantic values of tokens. Set by yylex.. */
332 unsigned yyival
; /* Set for token CINT. */
333 char *yytext
; /* Set for token IDENT. */
340 /* Current line number. */
344 /* The name of the current input file. */
348 /* Three character class vectors, and macros to test membership
355 #define IDENTP(C) is_ident[(unsigned char) (C)]
356 #define DIGITP(C) is_digit[(unsigned char) (C)]
357 #define WHITEP(C) is_white[(unsigned char) (C)]
359 /* Command line flags. */
366 int f_nested_classes
= 1;
368 /* Maximum and minimum lengths of regular expressions matching a
369 member, class etc., for writing them to the output file. These are
370 overridable from the command line. */
381 /* Return the current buffer position in the input file. */
383 #define BUFFER_POS() (in - inbuffer)
385 /* If current lookahead is CSTRING, the following points to the
386 first character in the string constant. Used for recognizing
391 /* The size of the hash tables for classes.and members. Should be
394 #define TABLE_SIZE 1001
396 /* The hash table for class symbols. */
398 struct sym
*class_table
[TABLE_SIZE
];
400 /* Hash table containing all member structures. This is generally
401 faster for member lookup than traversing the member lists of a
404 struct member
*member_table
[TABLE_SIZE
];
406 /* The special class symbol used to hold global functions,
409 struct sym
*global_symbols
;
411 /* The current namespace. */
413 struct sym
*current_namespace
;
415 /* The list of all known namespaces. */
417 struct sym
*all_namespaces
;
419 /* Stack of namespaces we're currently nested in, during the parse. */
421 struct sym
**namespace_stack
;
422 int namespace_stack_size
;
425 /* The current lookahead token. */
429 /* Structure describing a keyword. */
433 char *name
; /* Spelling. */
434 int tk
; /* Token value. */
435 struct kw
*next
; /* Next in collision chain. */
438 /* Keywords are lookup up in a hash table of their own. */
440 #define KEYWORD_TABLE_SIZE 1001
441 struct kw
*keyword_table
[KEYWORD_TABLE_SIZE
];
448 struct search_path
*next
;
451 struct search_path
*search_path
;
452 struct search_path
*search_path_tail
;
454 /* Function prototypes. */
456 int yylex
P_ ((void));
457 void yyparse
P_ ((void));
458 void re_init_parser
P_ ((void));
459 char *token_string
P_ ((int));
460 char *matching_regexp
P_ ((void));
461 void init_sym
P_ ((void));
462 struct sym
*add_sym
P_ ((char *, struct sym
*));
463 void add_link
P_ ((struct sym
*, struct sym
*));
464 void add_member_defn
P_ ((struct sym
*, char *, char *,
465 int, unsigned, int, int, int));
466 void add_member_decl
P_ ((struct sym
*, char *, char *, int,
467 unsigned, int, int, int, int));
468 void dump_roots
P_ ((FILE *));
469 void *xmalloc
P_ ((int));
470 void add_global_defn
P_ ((char *, char *, int, unsigned, int, int, int));
471 void add_global_decl
P_ ((char *, char *, int, unsigned, int, int, int));
472 void add_define
P_ ((char *, char *, int));
473 void mark_inherited_virtual
P_ ((void));
474 void leave_namespace
P_ ((void));
475 void enter_namespace
P_ ((char *));
476 void register_namespace_alias
P_ ((char *, char *));
477 void insert_keyword
P_ ((char *, int));
478 void re_init_scanner
P_ ((void));
479 void init_scanner
P_ ((void));
480 void usage
P_ ((int));
481 void version
P_ ((void));
482 void process_file
P_ ((char *));
483 void add_search_path
P_ ((char *));
484 FILE *open_file
P_ ((char *));
485 int process_pp_line
P_ ((void));
486 int dump_members
P_ ((FILE *, struct member
*));
487 void dump_sym
P_ ((FILE *, struct sym
*));
488 int dump_tree
P_ ((FILE *, struct sym
*));
489 struct member
*find_member
P_ ((struct sym
*, char *, int, int, unsigned));
490 struct member
*add_member
P_ ((struct sym
*, char *, int, int, unsigned));
491 void mark_virtual
P_ ((struct sym
*));
492 void mark_virtual
P_ ((struct sym
*));
493 struct sym
*make_namespace
P_ ((char *));
494 char *sym_scope
P_ ((struct sym
*));
495 char *sym_scope_1
P_ ((struct sym
*));
496 int skip_to
P_ ((int));
497 void skip_matching
P_ ((void));
498 void member
P_ ((struct sym
*, int));
499 void class_body
P_ ((struct sym
*, int));
500 void class_definition
P_ ((struct sym
*, int, int, int));
501 void declaration
P_ ((int, int));
502 unsigned parm_list
P_ ((int *));
503 char *operator_name
P_ ((int *));
504 struct sym
*parse_classname
P_ ((void));
505 struct sym
*parse_qualified_ident_or_type
P_ ((char **));
506 void parse_qualified_param_ident_or_type
P_ ((char **));
507 int globals
P_ ((int));
511 /***********************************************************************
513 ***********************************************************************/
515 /* Print an error in a printf-like style with the current input file
516 name and line number. */
519 yyerror (format
, a1
, a2
, a3
, a4
, a5
)
521 int a1
, a2
, a3
, a4
, a5
;
523 fprintf (stderr
, "%s:%d: ", filename
, yyline
);
524 fprintf (stderr
, format
, a1
, a2
, a3
, a4
, a5
);
529 /* Like malloc but print an error and exit if not enough memory is
536 void *p
= malloc (nbytes
);
539 yyerror ("out of memory");
544 /* Like realloc but print an error and exit if out of memory. */
554 yyerror ("out of memory");
559 /* Like strdup, but print an error and exit if not enough memory is
560 available.. If S is null, return null. */
567 s
= strcpy (xmalloc (strlen (s
) + 1), s
);
573 /***********************************************************************
575 ***********************************************************************/
577 /* Initialize the symbol table. This currently only sets up the
578 special symbol for globals (`*Globals*'). */
583 global_symbols
= add_sym (GLOBALS_NAME
, NULL
);
587 /* Add a symbol for class NAME to the symbol table. NESTED_IN_CLASS
588 is the class in which class NAME was found. If it is null,
589 this means the scope of NAME is the current namespace.
591 If a symbol for NAME already exists, return that. Otherwise
592 create a new symbol and set it to default values. */
595 add_sym (name
, nested_in_class
)
597 struct sym
*nested_in_class
;
602 struct sym
*scope
= nested_in_class
? nested_in_class
: current_namespace
;
604 for (s
= name
, h
= 0; *s
; ++s
)
608 for (sym
= class_table
[h
]; sym
; sym
= sym
->next
)
609 if (streq (name
, sym
->name
) && sym
->namesp
== scope
)
620 sym
= (struct sym
*) xmalloc (sizeof *sym
+ strlen (name
));
621 bzero (sym
, sizeof *sym
);
622 strcpy (sym
->name
, name
);
624 sym
->next
= class_table
[h
];
625 class_table
[h
] = sym
;
632 /* Add links between superclass SUPER and subclass SUB. */
635 add_link (super
, sub
)
636 struct sym
*super
, *sub
;
638 struct link
*lnk
, *lnk2
, *p
, *prev
;
640 /* See if a link already exists. */
641 for (p
= super
->subs
, prev
= NULL
;
642 p
&& strcmp (sub
->name
, p
->sym
->name
) > 0;
643 prev
= p
, p
= p
->next
)
646 /* Avoid duplicates. */
647 if (p
== NULL
|| p
->sym
!= sub
)
649 lnk
= (struct link
*) xmalloc (sizeof *lnk
);
650 lnk2
= (struct link
*) xmalloc (sizeof *lnk2
);
661 lnk2
->next
= sub
->supers
;
667 /* Find in class CLS member NAME.
669 VAR non-zero means look for a member variable; otherwise a function
670 is searched. SC specifies what kind of member is searched---a
671 static, or per-instance member etc. HASH is a hash code for the
672 parameter types of functions. Value is a pointer to the member
673 found or null if not found. */
676 find_member (cls
, name
, var
, sc
, hash
)
682 struct member
**list
;
684 unsigned name_hash
= 0;
691 list
= &cls
->friends
;
699 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
703 list
= var
? &cls
->vars
: &cls
->fns
;
707 for (s
= name
; *s
; ++s
)
708 name_hash
= (name_hash
<< 1) ^ *s
;
709 i
= name_hash
% TABLE_SIZE
;
711 for (p
= member_table
[i
]; p
; p
= p
->anext
)
712 if (p
->list
== list
&& p
->param_hash
== hash
&& streq (name
, p
->name
))
719 /* Add to class CLS information for the declaration of member NAME.
720 REGEXP is a regexp matching the declaration, if non-null. POS is
721 the position in the source where the declaration is found. HASH is
722 a hash code for the parameter list of the member, if it's a
723 function. VAR non-zero means member is a variable or type. SC
724 specifies the type of member (instance member, static, ...). VIS
725 is the member's visibility (public, protected, private). FLAGS is
726 a bit set giving additional information about the member (see the
730 add_member_decl (cls
, name
, regexp
, pos
, hash
, var
, sc
, vis
, flags
)
743 m
= find_member (cls
, name
, var
, sc
, hash
);
745 m
= add_member (cls
, name
, var
, sc
, hash
);
747 /* Have we seen a new filename? If so record that. */
748 if (!cls
->filename
|| !streq (cls
->filename
, filename
))
749 m
->filename
= filename
;
762 m
->vis
= V_PROTECTED
;
776 /* Add to class CLS information for the definition of member NAME.
777 REGEXP is a regexp matching the declaration, if non-null. POS is
778 the position in the source where the declaration is found. HASH is
779 a hash code for the parameter list of the member, if it's a
780 function. VAR non-zero means member is a variable or type. SC
781 specifies the type of member (instance member, static, ...). VIS
782 is the member's visibility (public, protected, private). FLAGS is
783 a bit set giving additional information about the member (see the
787 add_member_defn (cls
, name
, regexp
, pos
, hash
, var
, sc
, flags
)
799 if (sc
== SC_UNKNOWN
)
801 m
= find_member (cls
, name
, var
, SC_MEMBER
, hash
);
804 m
= find_member (cls
, name
, var
, SC_STATIC
, hash
);
806 m
= add_member (cls
, name
, var
, sc
, hash
);
811 m
= find_member (cls
, name
, var
, sc
, hash
);
813 m
= add_member (cls
, name
, var
, sc
, hash
);
817 cls
->sfilename
= filename
;
819 if (!streq (cls
->sfilename
, filename
))
820 m
->def_filename
= filename
;
822 m
->def_regexp
= regexp
;
832 /* Add a symbol for a define named NAME to the symbol table.
833 REGEXP is a regular expression matching the define in the source,
834 if it is non-null. POS is the position in the file. */
837 add_define (name
, regexp
, pos
)
841 add_global_defn (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
842 add_global_decl (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
846 /* Add information for the global definition of NAME.
847 REGEXP is a regexp matching the declaration, if non-null. POS is
848 the position in the source where the declaration is found. HASH is
849 a hash code for the parameter list of the member, if it's a
850 function. VAR non-zero means member is a variable or type. SC
851 specifies the type of member (instance member, static, ...). VIS
852 is the member's visibility (public, protected, private). FLAGS is
853 a bit set giving additional information about the member (see the
857 add_global_defn (name
, regexp
, pos
, hash
, var
, sc
, flags
)
868 /* Try to find out for which classes a function is a friend, and add
869 what we know about it to them. */
871 for (i
= 0; i
< TABLE_SIZE
; ++i
)
872 for (sym
= class_table
[i
]; sym
; sym
= sym
->next
)
873 if (sym
!= global_symbols
&& sym
->friends
)
874 if (find_member (sym
, name
, 0, SC_FRIEND
, hash
))
875 add_member_defn (sym
, name
, regexp
, pos
, hash
, 0,
878 /* Add to global symbols. */
879 add_member_defn (global_symbols
, name
, regexp
, pos
, hash
, var
, sc
, flags
);
883 /* Add information for the global declaration of NAME.
884 REGEXP is a regexp matching the declaration, if non-null. POS is
885 the position in the source where the declaration is found. HASH is
886 a hash code for the parameter list of the member, if it's a
887 function. VAR non-zero means member is a variable or type. SC
888 specifies the type of member (instance member, static, ...). VIS
889 is the member's visibility (public, protected, private). FLAGS is
890 a bit set giving additional information about the member (see the
894 add_global_decl (name
, regexp
, pos
, hash
, var
, sc
, flags
)
902 /* Add declaration only if not already declared. Header files must
903 be processed before source files for this to have the right effect.
904 I do not want to handle implicit declarations at the moment. */
906 struct member
*found
;
908 m
= found
= find_member (global_symbols
, name
, var
, sc
, hash
);
910 m
= add_member (global_symbols
, name
, var
, sc
, hash
);
912 /* Definition already seen => probably last declaration implicit.
913 Override. This means that declarations must always be added to
914 the symbol table before definitions. */
917 if (!global_symbols
->filename
918 || !streq (global_symbols
->filename
, filename
))
919 m
->filename
= filename
;
927 info_cls
= global_symbols
;
933 /* Add a symbol for member NAME to class CLS.
934 VAR non-zero means it's a variable. SC specifies the kind of
935 member. HASH is a hash code for the parameter types of a function.
936 Value is a pointer to the member's structure. */
939 add_member (cls
, name
, var
, sc
, hash
)
946 struct member
*m
= (struct member
*) xmalloc (sizeof *m
+ strlen (name
));
947 struct member
**list
;
950 unsigned name_hash
= 0;
954 strcpy (m
->name
, name
);
955 m
->param_hash
= hash
;
962 m
->def_regexp
= NULL
;
963 m
->def_filename
= NULL
;
966 assert (cls
!= NULL
);
971 list
= &cls
->friends
;
979 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
983 list
= var
? &cls
->vars
: &cls
->fns
;
987 for (s
= name
; *s
; ++s
)
988 name_hash
= (name_hash
<< 1) ^ *s
;
989 i
= name_hash
% TABLE_SIZE
;
990 m
->anext
= member_table
[i
];
994 /* Keep the member list sorted. It's cheaper to do it here than to
995 sort them in Lisp. */
996 for (prev
= NULL
, p
= *list
;
997 p
&& strcmp (name
, p
->name
) > 0;
998 prev
= p
, p
= p
->next
)
1010 /* Given the root R of a class tree, step through all subclasses
1011 recursively, marking functions as virtual that are declared virtual
1019 struct member
*m
, *m2
;
1021 for (p
= r
->subs
; p
; p
= p
->next
)
1023 for (m
= r
->fns
; m
; m
= m
->next
)
1024 if (HAS_FLAG (m
->flags
, F_VIRTUAL
))
1026 for (m2
= p
->sym
->fns
; m2
; m2
= m2
->next
)
1027 if (m
->param_hash
== m2
->param_hash
&& streq (m
->name
, m2
->name
))
1028 SET_FLAG (m2
->flags
, F_VIRTUAL
);
1031 mark_virtual (p
->sym
);
1036 /* For all roots of the class tree, mark functions as virtual that
1037 are virtual because of a virtual declaration in a base class. */
1040 mark_inherited_virtual ()
1045 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1046 for (r
= class_table
[i
]; r
; r
= r
->next
)
1047 if (r
->supers
== NULL
)
1052 /* Create and return a symbol for a namespace with name NAME. */
1055 make_namespace (name
)
1058 struct sym
*s
= (struct sym
*) xmalloc (sizeof *s
+ strlen (name
));
1059 bzero (s
, sizeof *s
);
1060 strcpy (s
->name
, name
);
1061 s
->next
= all_namespaces
;
1062 s
->namesp
= current_namespace
;
1068 /* Find the symbol for namespace NAME. If not found, add a new symbol
1069 for NAME to all_namespaces. */
1072 find_namespace (name
)
1077 for (p
= all_namespaces
; p
; p
= p
->next
)
1079 if (streq (p
->name
, name
))
1084 for (p2
= p
->namesp_aliases
; p2
; p2
= p2
->next
)
1085 if (streq (p2
->name
, name
))
1093 p
= make_namespace (name
);
1099 /* Register the name NEW_NAME as an alias for namespace OLD_NAME. */
1102 register_namespace_alias (new_name
, old_name
)
1103 char *new_name
, *old_name
;
1105 struct sym
*p
= find_namespace (old_name
);
1108 /* Is it already in the list of aliases? */
1109 for (al
= p
->namesp_aliases
; al
; al
= al
->next
)
1110 if (streq (new_name
, p
->name
))
1113 al
= (struct alias
*) xmalloc (sizeof *al
+ strlen (new_name
));
1114 strcpy (al
->name
, new_name
);
1115 al
->next
= p
->namesp_aliases
;
1116 p
->namesp_aliases
= al
;
1120 /* Enter namespace with name NAME. */
1123 enter_namespace (name
)
1126 struct sym
*p
= find_namespace (name
);
1128 if (namespace_sp
== namespace_stack_size
)
1130 int size
= max (10, 2 * namespace_stack_size
);
1131 namespace_stack
= (struct sym
**) xrealloc (namespace_stack
, size
);
1132 namespace_stack_size
= size
;
1135 namespace_stack
[namespace_sp
++] = current_namespace
;
1136 current_namespace
= p
;
1140 /* Leave the current namespace. */
1145 assert (namespace_sp
> 0);
1146 current_namespace
= namespace_stack
[--namespace_sp
];
1151 /***********************************************************************
1152 Writing the Output File
1153 ***********************************************************************/
1155 /* Write string S to the output file FP in a Lisp-readable form.
1156 If S is null, write out `()'. */
1158 #define PUTSTR(s, fp) \
1175 /* A dynamically allocated buffer for constructing a scope name. */
1178 int scope_buffer_size
;
1179 int scope_buffer_len
;
1182 /* Make sure scope_buffer has enough room to add LEN chars to it. */
1185 ensure_scope_buffer_room (len
)
1188 if (scope_buffer_len
+ len
>= scope_buffer_size
)
1190 int new_size
= max (2 * scope_buffer_size
, scope_buffer_len
+ len
);
1191 scope_buffer
= (char *) xrealloc (new_size
);
1192 scope_buffer_size
= new_size
;
1197 /* Recursively add the scope names of symbol P and the scopes of its
1198 namespaces to scope_buffer. Value is a pointer to the complete
1199 scope name constructed. */
1208 sym_scope_1 (p
->namesp
);
1212 ensure_scope_buffer_room (3);
1213 strcat (scope_buffer
, "::");
1214 scope_buffer_len
+= 2;
1217 len
= strlen (p
->name
);
1218 ensure_scope_buffer_room (len
+ 1);
1219 strcat (scope_buffer
, p
->name
);
1220 scope_buffer_len
+= len
;
1222 if (HAS_FLAG (p
->flags
, F_TEMPLATE
))
1224 ensure_scope_buffer_room (3);
1225 strcat (scope_buffer
, "<>");
1226 scope_buffer_len
+= 2;
1229 return scope_buffer
;
1233 /* Return the scope of symbol P in printed representation, i.e.
1234 as it would appear in a C*+ source file. */
1242 scope_buffer_size
= 1024;
1243 scope_buffer
= (char *) xmalloc (scope_buffer_size
);
1246 *scope_buffer
= '\0';
1247 scope_buffer_len
= 0;
1250 sym_scope_1 (p
->namesp
);
1252 return scope_buffer
;
1256 /* Dump the list of members M to file FP. Value is the length of the
1260 dump_members (fp
, m
)
1268 for (n
= 0; m
; m
= m
->next
, ++n
)
1270 fputs (MEMBER_STRUCT
, fp
);
1271 PUTSTR (m
->name
, fp
);
1272 PUTSTR (NULL
, fp
); /* FIXME? scope for globals */
1273 fprintf (fp
, "%u ", (unsigned) m
->flags
);
1274 PUTSTR (m
->filename
, fp
);
1275 PUTSTR (m
->regexp
, fp
);
1276 fprintf (fp
, "%u ", (unsigned) m
->pos
);
1277 fprintf (fp
, "%u ", (unsigned) m
->vis
);
1279 PUTSTR (m
->def_filename
, fp
);
1280 PUTSTR (m
->def_regexp
, fp
);
1281 fprintf (fp
, "%u", (unsigned) m
->def_pos
);
1292 /* Dump class ROOT to stream FP. */
1299 fputs (CLASS_STRUCT
, fp
);
1300 PUTSTR (root
->name
, fp
);
1302 /* Print scope, if any. */
1304 PUTSTR (sym_scope (root
), fp
);
1309 fprintf (fp
, "%u", root
->flags
);
1310 PUTSTR (root
->filename
, fp
);
1311 PUTSTR (root
->regexp
, fp
);
1312 fprintf (fp
, "%u", (unsigned) root
->pos
);
1313 PUTSTR (root
->sfilename
, fp
);
1319 /* Dump class ROOT and its subclasses to file FP. Value is the
1320 number of classes written. */
1323 dump_tree (fp
, root
)
1330 dump_sym (fp
, root
);
1340 for (lk
= root
->subs
; lk
; lk
= lk
->next
)
1342 fputs (TREE_STRUCT
, fp
);
1343 n
+= dump_tree (fp
, lk
->sym
);
1349 dump_members (fp
, root
->vars
);
1350 n
+= dump_members (fp
, root
->fns
);
1351 dump_members (fp
, root
->static_vars
);
1352 n
+= dump_members (fp
, root
->static_fns
);
1353 n
+= dump_members (fp
, root
->friends
);
1354 dump_members (fp
, root
->types
);
1369 /* Dump the entire class tree to file FP. */
1378 /* Output file header containing version string, command line
1382 fputs (TREE_HEADER_STRUCT
, fp
);
1383 PUTSTR (EBROWSE_FILE_VERSION
, fp
);
1396 /* Mark functions as virtual that are so because of functions
1397 declared virtual in base classes. */
1398 mark_inherited_virtual ();
1400 /* Dump the roots of the graph. */
1401 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1402 for (r
= class_table
[i
]; r
; r
= r
->next
)
1405 fputs (TREE_STRUCT
, fp
);
1406 n
+= dump_tree (fp
, r
);
1416 /***********************************************************************
1418 ***********************************************************************/
1421 #define INCREMENT_LINENO \
1423 if (f_very_verbose) \
1426 printf ("%d:\n", yyline); \
1432 #define INCREMENT_LINENO ++yyline
1435 /* Define two macros for accessing the input buffer (current input
1436 file). GET(C) sets C to the next input character and advances the
1437 input pointer. UNGET retracts the input pointer. */
1439 #define GET(C) ((C) = *in++)
1440 #define UNGET() (--in)
1443 /* Process a preprocessor line. Value is the next character from the
1444 input buffer not consumed. */
1453 /* Skip over white space. The `#' has been consumed already. */
1454 while (WHITEP (GET (c
)))
1457 /* Read the preprocessor command (if any). */
1464 /* Is it a `define'? */
1467 if (*yytext
&& streq (yytext
, "define"))
1482 char *regexp
= matching_regexp ();
1483 int pos
= BUFFER_POS ();
1484 add_define (yytext
, regexp
, pos
);
1488 while (c
&& (c
!= '\n' || in_comment
))
1492 else if (c
== '/' && !in_comment
)
1497 else if (c
== '*' && in_comment
)
1513 /* Value is the next token from the input buffer. */
1524 while (WHITEP (GET (c
)))
1546 /* String and character constants. */
1549 while (GET (c
) && c
!= end_char
)
1554 /* Escape sequences. */
1557 if (end_char
== '\'')
1558 yyerror ("EOF in character constant");
1560 yyerror ("EOF in string constant");
1577 /* Hexadecimal escape sequence. */
1579 for (i
= 0; i
< 2; ++i
)
1583 if (c
>= '0' && c
<= '7')
1585 else if (c
>= 'a' && c
<= 'f')
1587 else if (c
>= 'A' && c
<= 'F')
1600 /* Octal escape sequence. */
1602 for (i
= 0; i
< 3; ++i
)
1606 if (c
>= '0' && c
<= '7')
1623 if (end_char
== '\'')
1624 yyerror ("newline in character constant");
1626 yyerror ("newline in string constant");
1636 return end_char
== '\'' ? CCHAR
: CSTRING
;
1638 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1639 case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
1640 case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
1641 case 'v': case 'w': case 'x': case 'y': case 'z':
1642 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
1643 case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
1644 case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
1645 case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_':
1647 /* Identifier and keywords. */
1654 while (IDENTP (GET (*p
)))
1656 hash
= (hash
<< 1) ^ *p
++;
1657 if (p
== yytext_end
- 1)
1659 int size
= yytext_end
- yytext
;
1660 yytext
= (char *) xrealloc (yytext
, 2 * size
);
1661 yytext_end
= yytext
+ 2 * size
;
1662 p
= yytext
+ size
- 1;
1669 for (k
= keyword_table
[hash
% KEYWORD_TABLE_SIZE
]; k
; k
= k
->next
)
1670 if (streq (k
->name
, yytext
))
1677 /* C and C++ comments, '/' and '/='. */
1705 while (GET (c
) && c
!= '\n')
1780 yyerror ("invalid token '..' ('...' assumed)");
1784 else if (!DIGITP (c
))
1838 c
= process_pp_line ();
1843 case '(': case ')': case '[': case ']': case '{': case '}':
1844 case ';': case ',': case '?': case '~':
1850 if (GET (c
) == 'x' || c
== 'X')
1855 yyival
= yyival
* 16 + c
- '0';
1856 else if (c
>= 'a' && c
<= 'f')
1857 yyival
= yyival
* 16 + c
- 'a' + 10;
1858 else if (c
>= 'A' && c
<= 'F')
1859 yyival
= yyival
* 16 + c
- 'A' + 10;
1869 while (c
>= '0' && c
<= '7')
1871 yyival
= (yyival
<< 3) + c
- '0';
1876 /* Integer suffixes. */
1882 case '1': case '2': case '3': case '4': case '5': case '6':
1883 case '7': case '8': case '9':
1884 /* Integer or floating constant, part before '.'. */
1887 while (GET (c
) && DIGITP (c
))
1888 yyival
= 10 * yyival
+ c
- '0';
1894 /* Digits following '.'. */
1898 /* Optional exponent. */
1899 if (c
== 'E' || c
== 'e')
1901 if (GET (c
) == '-' || c
== '+')
1908 /* Optional type suffixes. */
1921 /* Value is the string from the start of the line to the current
1922 position in the input buffer, or maybe a bit more if that string is
1923 shorter than min_regexp. */
1931 static char *buffer
, *end_buf
;
1938 buffer
= (char *) xmalloc (max_regexp
);
1939 end_buf
= &buffer
[max_regexp
] - 1;
1942 /* Scan back to previous newline of buffer start. */
1943 for (p
= in
- 1; p
> inbuffer
&& *p
!= '\n'; --p
)
1948 while (in
- p
< min_regexp
&& p
> inbuffer
)
1950 /* Line probably not significant enough */
1951 for (--p
; p
>= inbuffer
&& *p
!= '\n'; --p
)
1958 /* Copy from end to make sure significant portions are included.
1959 This implies that in the browser a regular expressing of the form
1960 `^.*{regexp}' has to be used. */
1961 for (s
= end_buf
- 1, t
= in
; s
> buffer
&& t
> p
;)
1969 *(end_buf
- 1) = '\0';
1974 /* Return a printable representation of token T. */
1984 case CSTRING
: return "string constant";
1985 case CCHAR
: return "char constant";
1986 case CINT
: return "int constant";
1987 case CFLOAT
: return "floating constant";
1988 case ELLIPSIS
: return "...";
1989 case LSHIFTASGN
: return "<<=";
1990 case RSHIFTASGN
: return ">>=";
1991 case ARROWSTAR
: return "->*";
1992 case IDENT
: return "identifier";
1993 case DIVASGN
: return "/=";
1994 case INC
: return "++";
1995 case ADDASGN
: return "+=";
1996 case DEC
: return "--";
1997 case ARROW
: return "->";
1998 case SUBASGN
: return "-=";
1999 case MULASGN
: return "*=";
2000 case MODASGN
: return "%=";
2001 case LOR
: return "||";
2002 case ORASGN
: return "|=";
2003 case LAND
: return "&&";
2004 case ANDASGN
: return "&=";
2005 case XORASGN
: return "^=";
2006 case POINTSTAR
: return ".*";
2007 case DCOLON
: return "::";
2008 case EQ
: return "==";
2009 case NE
: return "!=";
2010 case LE
: return "<=";
2011 case LSHIFT
: return "<<";
2012 case GE
: return ">=";
2013 case RSHIFT
: return ">>";
2014 case ASM
: return "asm";
2015 case AUTO
: return "auto";
2016 case BREAK
: return "break";
2017 case CASE
: return "case";
2018 case CATCH
: return "catch";
2019 case CHAR
: return "char";
2020 case CLASS
: return "class";
2021 case CONST
: return "const";
2022 case CONTINUE
: return "continue";
2023 case DEFAULT
: return "default";
2024 case DELETE
: return "delete";
2025 case DO
: return "do";
2026 case DOUBLE
: return "double";
2027 case ELSE
: return "else";
2028 case ENUM
: return "enum";
2029 case EXTERN
: return "extern";
2030 case FLOAT
: return "float";
2031 case FOR
: return "for";
2032 case FRIEND
: return "friend";
2033 case GOTO
: return "goto";
2034 case IF
: return "if";
2035 case T_INLINE
: return "inline";
2036 case INT
: return "int";
2037 case LONG
: return "long";
2038 case NEW
: return "new";
2039 case OPERATOR
: return "operator";
2040 case PRIVATE
: return "private";
2041 case PROTECTED
: return "protected";
2042 case PUBLIC
: return "public";
2043 case REGISTER
: return "register";
2044 case RETURN
: return "return";
2045 case SHORT
: return "short";
2046 case SIGNED
: return "signed";
2047 case SIZEOF
: return "sizeof";
2048 case STATIC
: return "static";
2049 case STRUCT
: return "struct";
2050 case SWITCH
: return "switch";
2051 case TEMPLATE
: return "template";
2052 case THIS
: return "this";
2053 case THROW
: return "throw";
2054 case TRY
: return "try";
2055 case TYPEDEF
: return "typedef";
2056 case UNION
: return "union";
2057 case UNSIGNED
: return "unsigned";
2058 case VIRTUAL
: return "virtual";
2059 case VOID
: return "void";
2060 case VOLATILE
: return "volatile";
2061 case WHILE
: return "while";
2062 case YYEOF
: return "EOF";
2072 /* Reinitialize the scanner for a new input file. */
2083 yytext
= (char *) xmalloc (size
* sizeof *yytext
);
2084 yytext_end
= yytext
+ size
;
2089 /* Insert a keyword NAME with token value TK into the keyword hash
2093 insert_keyword (name
, tk
)
2099 struct kw
*k
= (struct kw
*) xmalloc (sizeof *k
);
2101 for (s
= name
; *s
; ++s
)
2104 h
%= KEYWORD_TABLE_SIZE
;
2107 k
->next
= keyword_table
[h
];
2108 keyword_table
[h
] = k
;
2112 /* Initialize the scanner for the first file. This sets up the
2113 character class vectors and fills the keyword hash table. */
2120 /* Allocate the input buffer */
2121 inbuffer_size
= READ_CHUNK_SIZE
+ 1;
2122 inbuffer
= in
= (char *) xmalloc (inbuffer_size
);
2125 /* Set up character class vectors. */
2126 for (i
= 0; i
< sizeof is_ident
; ++i
)
2128 if (i
== '_' || isalnum (i
))
2131 if (i
>= '0' && i
<= '9')
2134 if (i
== ' ' || i
== '\t' || i
== '\f' || i
== '\v')
2138 /* Fill keyword hash table. */
2139 insert_keyword ("and", LAND
);
2140 insert_keyword ("and_eq", ANDASGN
);
2141 insert_keyword ("asm", ASM
);
2142 insert_keyword ("auto", AUTO
);
2143 insert_keyword ("bitand", '&');
2144 insert_keyword ("bitor", '|');
2145 insert_keyword ("bool", BOOL
);
2146 insert_keyword ("break", BREAK
);
2147 insert_keyword ("case", CASE
);
2148 insert_keyword ("catch", CATCH
);
2149 insert_keyword ("char", CHAR
);
2150 insert_keyword ("class", CLASS
);
2151 insert_keyword ("compl", '~');
2152 insert_keyword ("const", CONST
);
2153 insert_keyword ("const_cast", CONST_CAST
);
2154 insert_keyword ("continue", CONTINUE
);
2155 insert_keyword ("default", DEFAULT
);
2156 insert_keyword ("delete", DELETE
);
2157 insert_keyword ("do", DO
);
2158 insert_keyword ("double", DOUBLE
);
2159 insert_keyword ("dynamic_cast", DYNAMIC_CAST
);
2160 insert_keyword ("else", ELSE
);
2161 insert_keyword ("enum", ENUM
);
2162 insert_keyword ("explicit", EXPLICIT
);
2163 insert_keyword ("extern", EXTERN
);
2164 insert_keyword ("false", FALSE
);
2165 insert_keyword ("float", FLOAT
);
2166 insert_keyword ("for", FOR
);
2167 insert_keyword ("friend", FRIEND
);
2168 insert_keyword ("goto", GOTO
);
2169 insert_keyword ("if", IF
);
2170 insert_keyword ("inline", T_INLINE
);
2171 insert_keyword ("int", INT
);
2172 insert_keyword ("long", LONG
);
2173 insert_keyword ("mutable", MUTABLE
);
2174 insert_keyword ("namespace", NAMESPACE
);
2175 insert_keyword ("new", NEW
);
2176 insert_keyword ("not", '!');
2177 insert_keyword ("not_eq", NE
);
2178 insert_keyword ("operator", OPERATOR
);
2179 insert_keyword ("or", LOR
);
2180 insert_keyword ("or_eq", ORASGN
);
2181 insert_keyword ("private", PRIVATE
);
2182 insert_keyword ("protected", PROTECTED
);
2183 insert_keyword ("public", PUBLIC
);
2184 insert_keyword ("register", REGISTER
);
2185 insert_keyword ("reinterpret_cast", REINTERPRET_CAST
);
2186 insert_keyword ("return", RETURN
);
2187 insert_keyword ("short", SHORT
);
2188 insert_keyword ("signed", SIGNED
);
2189 insert_keyword ("sizeof", SIZEOF
);
2190 insert_keyword ("static", STATIC
);
2191 insert_keyword ("static_cast", STATIC_CAST
);
2192 insert_keyword ("struct", STRUCT
);
2193 insert_keyword ("switch", SWITCH
);
2194 insert_keyword ("template", TEMPLATE
);
2195 insert_keyword ("this", THIS
);
2196 insert_keyword ("throw", THROW
);
2197 insert_keyword ("true", TRUE
);
2198 insert_keyword ("try", TRY
);
2199 insert_keyword ("typedef", TYPEDEF
);
2200 insert_keyword ("typeid", TYPEID
);
2201 insert_keyword ("typename", TYPENAME
);
2202 insert_keyword ("union", UNION
);
2203 insert_keyword ("unsigned", UNSIGNED
);
2204 insert_keyword ("using", USING
);
2205 insert_keyword ("virtual", VIRTUAL
);
2206 insert_keyword ("void", VOID
);
2207 insert_keyword ("volatile", VOLATILE
);
2208 insert_keyword ("wchar_t", WCHAR
);
2209 insert_keyword ("while", WHILE
);
2210 insert_keyword ("xor", '^');
2211 insert_keyword ("xor_eq", XORASGN
);
2216 /***********************************************************************
2218 ***********************************************************************/
2220 /* Match the current lookahead token and set it to the next token. */
2222 #define MATCH() (tk = yylex ())
2224 /* Return the lookahead token. If current lookahead token is cleared,
2225 read a new token. */
2227 #define LA1 (tk == -1 ? (tk = yylex ()) : tk)
2229 /* Is the current lookahead equal to the token T? */
2231 #define LOOKING_AT(T) (tk == (T))
2233 /* Is the current lookahead one of T1 or T2? */
2235 #define LOOKING_AT2(T1, T2) (tk == (T1) || tk == (T2))
2237 /* Is the current lookahead one of T1, T2 or T3? */
2239 #define LOOKING_AT3(T1, T2, T3) (tk == (T1) || tk == (T2) || tk == (T3))
2241 /* Is the current lookahead one of T1...T4? */
2243 #define LOOKING_AT4(T1, T2, T3, T4) \
2244 (tk == (T1) || tk == (T2) || tk == (T3) || tk == (T4))
2246 /* Match token T if current lookahead is T. */
2248 #define MATCH_IF(T) if (LOOKING_AT (T)) MATCH (); else ((void) 0)
2250 /* Skip to matching token if current token is T. */
2252 #define SKIP_MATCHING_IF(T) \
2253 if (LOOKING_AT (T)) skip_matching (); else ((void) 0)
2256 /* Skip forward until a given token TOKEN or YYEOF is seen and return
2257 the current lookahead token after skipping. */
2263 while (!LOOKING_AT2 (YYEOF
, token
))
2269 /* Skip over pairs of tokens (parentheses, square brackets,
2270 angle brackets, curly brackets) matching the current lookahead. */
2301 if (LOOKING_AT (open
))
2303 else if (LOOKING_AT (close
))
2305 else if (LOOKING_AT (YYEOF
))
2316 /* Re-initialize the parser by resetting the lookahead token. */
2325 /* Parse a parameter list, including the const-specifier,
2326 pure-specifier, and throw-list that may follow a parameter list.
2327 Return in FLAGS what was seen following the parameter list.
2328 Returns a hash code for the parameter types. This value is used to
2329 distinguish between overloaded functions. */
2338 while (!LOOKING_AT2 (YYEOF
, ')'))
2342 /* Skip over grouping parens or parameter lists in parameter
2348 /* Next parameter. */
2354 /* Ignore the scope part of types, if any. This is because
2355 some types need scopes when defined outside of a class body,
2356 and don't need them inside the class body. This means that
2357 we have to look for the last IDENT in a sequence of
2358 IDENT::IDENT::... */
2363 unsigned ident_type_hash
= 0;
2365 parse_qualified_param_ident_or_type (&s
);
2367 ident_type_hash
= (ident_type_hash
<< 1) ^ *s
;
2368 hash
= (hash
<< 1) ^ ident_type_hash
;
2376 /* This distinction is made to make `func (void)' equivalent
2380 if (!LOOKING_AT (')'))
2381 hash
= (hash
<< 1) ^ VOID
;
2384 case BOOL
: case CHAR
: case CLASS
: case CONST
:
2385 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2386 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2387 case UNION
: case UNSIGNED
: case VOLATILE
: case WCHAR
:
2390 hash
= (hash
<< 1) ^ LA1
;
2394 case '*': case '&': case '[': case ']':
2395 hash
= (hash
<< 1) ^ LA1
;
2405 if (LOOKING_AT (')'))
2409 if (LOOKING_AT (CONST
))
2411 /* We can overload the same function on `const' */
2412 hash
= (hash
<< 1) ^ CONST
;
2413 SET_FLAG (*flags
, F_CONST
);
2417 if (LOOKING_AT (THROW
))
2420 SKIP_MATCHING_IF ('(');
2421 SET_FLAG (*flags
, F_THROW
);
2424 if (LOOKING_AT ('='))
2427 if (LOOKING_AT (CINT
) && yyival
== 0)
2430 SET_FLAG (*flags
, F_PURE
);
2439 /* Print position info to stdout. */
2444 if (info_position
>= 0 && BUFFER_POS () <= info_position
)
2446 printf ("(\"%s\" \"%s\" \"%s\" %d)\n",
2447 info_cls
->name
, sym_scope (info_cls
),
2448 info_member
->name
, info_where
);
2452 /* Parse a member declaration within the class body of CLS. VIS is
2453 the access specifier for the member (private, protected,
2463 char *regexp
= NULL
;
2474 while (!LOOKING_AT4 (';', '{', '}', YYEOF
))
2482 /* A function or class may follow. */
2485 SET_FLAG (flags
, F_TEMPLATE
);
2486 /* Skip over template argument list */
2487 SKIP_MATCHING_IF ('<');
2491 SET_FLAG (flags
, F_EXPLICIT
);
2495 SET_FLAG (flags
, F_MUTABLE
);
2499 SET_FLAG (flags
, F_INLINE
);
2503 SET_FLAG (flags
, F_VIRTUAL
);
2532 /* Remember IDENTS seen so far. Among these will be the member
2534 id
= (char *) alloca (strlen (yytext
) + 2);
2538 strcpy (id
+ 1, yytext
);
2541 strcpy (id
, yytext
);
2546 id
= operator_name (&sc
);
2550 /* Most probably the beginning of a parameter list. */
2556 if (!(is_constructor
= streq (id
, cls
->name
)))
2557 regexp
= matching_regexp ();
2562 pos
= BUFFER_POS ();
2563 hash
= parm_list (&flags
);
2566 regexp
= matching_regexp ();
2568 if (id
&& cls
!= NULL
)
2569 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, flags
);
2571 while (!LOOKING_AT3 (';', '{', YYEOF
))
2574 if (LOOKING_AT ('{') && id
&& cls
)
2575 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0, sc
, flags
);
2581 case STRUCT
: case UNION
: case CLASS
:
2588 /* More than one ident here to allow for MS-DOS specialties
2589 like `_export class' etc. The last IDENT seen counts
2590 as the class name. */
2591 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
2593 if (LOOKING_AT (IDENT
))
2598 if (LOOKING_AT2 (':', '{'))
2599 class_definition (anonymous
? NULL
: cls
, class_tag
, flags
, 1);
2604 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
2605 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
2606 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
2615 if (LOOKING_AT (';'))
2617 /* The end of a member variable, a friend declaration or an access
2618 declaration. We don't want to add friend classes as members. */
2619 if (id
&& sc
!= SC_FRIEND
&& cls
)
2621 regexp
= matching_regexp ();
2622 pos
= BUFFER_POS ();
2626 if (type_seen
|| !paren_seen
)
2627 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2629 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, 0);
2636 else if (LOOKING_AT ('{'))
2639 if (sc
== SC_TYPE
&& id
&& cls
)
2641 regexp
= matching_regexp ();
2642 pos
= BUFFER_POS ();
2646 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2647 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, sc
, 0);
2657 /* Parse the body of class CLS. TAG is the tag of the class (struct,
2661 class_body (cls
, tag
)
2665 int vis
= tag
== CLASS
? PRIVATE
: PUBLIC
;
2668 while (!LOOKING_AT2 (YYEOF
, '}'))
2672 case PRIVATE
: case PROTECTED
: case PUBLIC
:
2676 if (LOOKING_AT (':'))
2683 /* Probably conditional compilation for inheritance list.
2684 We don't known whether there comes more of this.
2685 This is only a crude fix that works most of the time. */
2690 while (LOOKING_AT2 (IDENT
, ',')
2691 || LOOKING_AT3 (PUBLIC
, PROTECTED
, PRIVATE
));
2700 /* Try to synchronize */
2701 case CHAR
: case CLASS
: case CONST
:
2702 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2703 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2704 case UNION
: case UNSIGNED
: case VOID
: case VOLATILE
:
2705 case TYPEDEF
: case STATIC
: case T_INLINE
: case FRIEND
:
2706 case VIRTUAL
: case TEMPLATE
: case IDENT
: case '~':
2707 case BOOL
: case WCHAR
: case EXPLICIT
: case MUTABLE
:
2719 /* Parse a qualified identifier. Current lookahead is IDENT. A
2720 qualified ident has the form `X<..>::Y<...>::T<...>. Returns a
2721 symbol for that class. */
2726 struct sym
*last_class
= NULL
;
2728 while (LOOKING_AT (IDENT
))
2730 last_class
= add_sym (yytext
, last_class
);
2733 if (LOOKING_AT ('<'))
2736 SET_FLAG (last_class
->flags
, F_TEMPLATE
);
2739 if (!LOOKING_AT (DCOLON
))
2749 /* Parse an operator name. Add the `static' flag to *SC if an
2750 implicitly static operator has been parsed. Value is a pointer to
2751 a static buffer holding the constructed operator name string. */
2757 static int id_size
= 0;
2758 static char *id
= NULL
;
2764 if (LOOKING_AT2 (NEW
, DELETE
))
2766 /* `new' and `delete' are implicitly static. */
2767 if (*sc
!= SC_FRIEND
)
2770 s
= token_string (LA1
);
2773 len
= strlen (s
) + 10;
2776 int new_size
= max (len
, 2 * id_size
);
2777 id
= (char *) xrealloc (id
, new_size
);
2782 /* Vector new or delete? */
2783 if (LOOKING_AT ('['))
2788 if (LOOKING_AT (']'))
2797 int tokens_matched
= 0;
2802 int new_size
= max (len
, 2 * id_size
);
2803 id
= (char *) xrealloc (id
, new_size
);
2806 strcpy (id
, "operator");
2808 /* Beware access declarations of the form "X::f;" Beware of
2809 `operator () ()'. Yet another difficulty is found in
2810 GCC 2.95's STL: `operator == __STL_NULL_TMPL_ARGS (...'. */
2811 while (!(LOOKING_AT ('(') && tokens_matched
)
2812 && !LOOKING_AT2 (';', YYEOF
))
2814 s
= token_string (LA1
);
2815 len
+= strlen (s
) + 2;
2818 int new_size
= max (len
, 2 * id_size
);
2819 id
= (char *) xrealloc (id
, new_size
);
2823 if (*s
!= ')' && *s
!= ']')
2828 /* If this is a simple operator like `+', stop now. */
2829 if (!isalpha (*s
) && *s
!= '(' && *s
!= '[')
2840 /* This one consumes the last IDENT of a qualified member name like
2841 `X::Y::z'. This IDENT is returned in LAST_ID. Value if the
2842 symbol structure for the ident. */
2845 parse_qualified_ident_or_type (last_id
)
2848 struct sym
*cls
= NULL
;
2849 static char *id
= NULL
;
2850 static int id_size
= 0;
2852 while (LOOKING_AT (IDENT
))
2854 int len
= strlen (yytext
) + 1;
2857 id
= (char *) xrealloc (id
, len
);
2860 strcpy (id
, yytext
);
2864 SKIP_MATCHING_IF ('<');
2866 if (LOOKING_AT (DCOLON
))
2868 cls
= add_sym (id
, cls
);
2880 /* This one consumes the last IDENT of a qualified member name like
2881 `X::Y::z'. This IDENT is returned in LAST_ID. Value if the
2882 symbol structure for the ident. */
2885 parse_qualified_param_ident_or_type (last_id
)
2888 struct sym
*cls
= NULL
;
2889 static char *id
= NULL
;
2890 static int id_size
= 0;
2892 while (LOOKING_AT (IDENT
))
2894 int len
= strlen (yytext
) + 1;
2897 id
= (char *) xrealloc (id
, len
);
2900 strcpy (id
, yytext
);
2904 SKIP_MATCHING_IF ('<');
2906 if (LOOKING_AT (DCOLON
))
2908 cls
= add_sym (id
, cls
);
2918 /* Parse a class definition.
2920 CONTAINING is the class containing the class being parsed or null.
2921 This may also be null if NESTED != 0 if the containing class is
2922 anonymous. TAG is the tag of the class (struct, union, class).
2923 NESTED is non-zero if we are parsing a nested class.
2925 Current lookahead is the class name. */
2928 class_definition (containing
, tag
, flags
, nested
)
2929 struct sym
*containing
;
2935 struct sym
*current
;
2936 struct sym
*base_class
;
2938 /* Set CURRENT to null if no entry has to be made for the class
2939 parsed. This is the case for certain command line flag
2941 if ((tag
!= CLASS
&& !f_structs
) || (nested
&& !f_nested_classes
))
2945 current
= add_sym (yytext
, containing
);
2946 current
->pos
= BUFFER_POS ();
2947 current
->regexp
= matching_regexp ();
2948 current
->filename
= filename
;
2949 current
->flags
= flags
;
2952 /* If at ':', base class list follows. */
2953 if (LOOKING_AT (':'))
2960 switch (token
= LA1
)
2962 case VIRTUAL
: case PUBLIC
: case PROTECTED
: case PRIVATE
:
2967 base_class
= parse_classname ();
2968 if (base_class
&& current
&& base_class
!= current
)
2969 add_link (base_class
, current
);
2972 /* The `,' between base classes or the end of the base
2973 class list. Add the previously found base class.
2974 It's done this way to skip over sequences of
2975 `A::B::C' until we reach the end.
2977 FIXME: it is now possible to handle `class X : public B::X'
2978 because we have enough information. */
2984 /* A syntax error, possibly due to preprocessor constructs
2990 class A : private B.
2992 MATCH until we see something like `;' or `{'. */
2993 while (!LOOKING_AT3 (';', YYEOF
, '{'))
3004 /* Parse the class body if there is one. */
3005 if (LOOKING_AT ('{'))
3007 if (tag
!= CLASS
&& !f_structs
)
3012 class_body (current
, tag
);
3014 if (LOOKING_AT ('}'))
3017 if (LOOKING_AT (';') && !nested
)
3025 /* Parse a declaration. */
3028 declaration (is_extern
, flags
)
3033 struct sym
*cls
= NULL
;
3034 char *regexp
= NULL
;
3040 while (!LOOKING_AT3 (';', '{', YYEOF
))
3063 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
3064 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
3065 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
3069 case CLASS
: case STRUCT
: case UNION
:
3070 /* This is for the case `STARTWRAP class X : ...' or
3071 `declare (X, Y)\n class A : ...'. */
3076 /* Assumed to be the start of an initialization in this context.
3077 Skip over everything up to ';'. */
3082 id
= operator_name (&sc
);
3086 SET_FLAG (flags
, F_INLINE
);
3092 if (LOOKING_AT (IDENT
))
3094 id
= (char *) alloca (strlen (yytext
) + 2);
3096 strcpy (id
+ 1, yytext
);
3102 cls
= parse_qualified_ident_or_type (&id
);
3106 /* Most probably the beginning of a parameter list. */
3113 if (!(is_constructor
= streq (id
, cls
->name
)))
3114 regexp
= matching_regexp ();
3119 pos
= BUFFER_POS ();
3120 hash
= parm_list (&flags
);
3123 regexp
= matching_regexp ();
3126 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0,
3131 /* This may be a C functions, but also a macro
3132 call of the form `declare (A, B)' --- such macros
3133 can be found in some class libraries. */
3138 regexp
= matching_regexp ();
3139 pos
= BUFFER_POS ();
3140 hash
= parm_list (&flags
);
3141 add_global_decl (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3144 /* This is for the case that the function really is
3145 a macro with no `;' following it. If a CLASS directly
3146 follows, we would miss it otherwise. */
3147 if (LOOKING_AT3 (CLASS
, STRUCT
, UNION
))
3151 while (!LOOKING_AT3 (';', '{', YYEOF
))
3154 if (!cls
&& id
&& LOOKING_AT ('{'))
3155 add_global_defn (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3161 if (LOOKING_AT (';'))
3163 /* The end of a member variable or of an access declaration
3164 `X::f'. To distinguish between them we have to know whether
3165 type information has been seen. */
3168 char *regexp
= matching_regexp ();
3169 int pos
= BUFFER_POS ();
3172 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, SC_UNKNOWN
, flags
);
3174 add_global_defn (id
, regexp
, pos
, 0, 1, sc
, flags
);
3180 else if (LOOKING_AT ('{'))
3182 if (sc
== SC_TYPE
&& id
)
3184 /* A named enumeration. */
3185 regexp
= matching_regexp ();
3186 pos
= BUFFER_POS ();
3187 add_global_defn (id
, regexp
, pos
, 0, 1, sc
, flags
);
3196 /* Parse a list of top-level declarations/definitions. START_FLAGS
3197 says in which context we are parsing. If it is F_EXTERNC, we are
3198 parsing in an `extern "C"' block. Value is 1 if EOF is reached, 0
3202 globals (start_flags
)
3207 int flags
= start_flags
;
3219 if (LOOKING_AT (IDENT
))
3221 char *namespace_name
3222 = (char *) alloca (strlen (yytext
) + 1);
3223 strcpy (namespace_name
, yytext
);
3226 if (LOOKING_AT ('='))
3228 if (skip_to (';') == ';')
3230 register_namespace_alias (namespace_name
, yytext
);
3232 else if (LOOKING_AT ('{'))
3235 enter_namespace (namespace_name
);
3246 if (LOOKING_AT (CSTRING
) && *string_start
== 'C'
3247 && *(string_start
+ 1) == '"')
3249 /* This is `extern "C"'. */
3252 if (LOOKING_AT ('{'))
3255 globals (F_EXTERNC
);
3259 SET_FLAG (flags
, F_EXTERNC
);
3265 SKIP_MATCHING_IF ('<');
3266 SET_FLAG (flags
, F_TEMPLATE
);
3269 case CLASS
: case STRUCT
: case UNION
:
3274 /* More than one ident here to allow for MS-DOS and OS/2
3275 specialties like `far', `_Export' etc. Some C++ libs
3276 have constructs like `_OS_DLLIMPORT(_OS_CLIENT)' in front
3277 of the class name. */
3278 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
3280 if (LOOKING_AT (IDENT
))
3285 /* Don't add anonymous unions. */
3286 if (LOOKING_AT2 (':', '{') && !anonymous
)
3287 class_definition (NULL
, class_tk
, flags
, 0);
3290 if (skip_to (';') == ';')
3294 flags
= start_flags
;
3304 declaration (0, flags
);
3305 flags
= start_flags
;
3310 yyerror ("parse error");
3315 /* Parse the current input file. */
3320 while (globals (0) == 0)
3326 /***********************************************************************
3328 ***********************************************************************/
3330 /* Add the list of paths PATH_LIST to the current search path for
3334 add_search_path (path_list
)
3339 char *start
= path_list
;
3340 struct search_path
*p
;
3342 while (*path_list
&& *path_list
!= PATH_LIST_SEPARATOR
)
3345 p
= (struct search_path
*) xmalloc (sizeof *p
);
3346 p
->path
= (char *) xmalloc (path_list
- start
+ 1);
3347 memcpy (p
->path
, start
, path_list
- start
);
3348 p
->path
[path_list
- start
] = '\0';
3351 if (search_path_tail
)
3353 search_path_tail
->next
= p
;
3354 search_path_tail
= p
;
3357 search_path
= search_path_tail
= p
;
3359 while (*path_list
== PATH_LIST_SEPARATOR
)
3365 /* Open FILE and return a file handle for it, or -1 if FILE cannot be
3366 opened. Try to find FILE in search_path first, then try the
3367 unchanged file name. */
3374 static char *buffer
;
3375 static int buffer_size
;
3376 struct search_path
*path
;
3378 filename
= xstrdup (file
);
3380 for (path
= search_path
; path
&& fp
== NULL
; path
= path
->next
)
3382 int len
= strlen (path
->path
);
3384 if (len
+ 1 >= buffer_size
)
3386 buffer_size
= max (len
+ 1, 2 * buffer_size
);
3387 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3390 strcpy (buffer
, path
->path
);
3391 strcat (buffer
, "/");
3392 strcat (buffer
, file
);
3393 fp
= fopen (buffer
, "r");
3396 /* Try the original file name. */
3398 fp
= fopen (file
, "r");
3401 yyerror ("cannot open");
3407 /* Display usage information and exit program. */
3410 Usage: ebrowse [options] {files}\n\
3412 -a, --append append output\n\
3413 -f, --files=FILES read input file names from FILE\n\
3414 -I, --search-path=LIST set search path for input files\n\
3415 -m, --min-regexp-length=N set minimum regexp length to N\n\
3416 -M, --max-regexp-length=N set maximum regexp length to N\n\
3417 -n, --no-nested-classes exclude nested classes\n\
3418 -o, --output-file=FILE set output file name to FILE\n\
3419 -p, --position-info print info about position in file\n\
3420 -s, --no-structs-or-unions don't record structs or unions\n\
3421 -v, --verbose be verbose\n\
3422 -V, --very-verbose be very verbose\n\
3423 -x, --no-regexps don't record regular expressions\n\
3424 --help display this help\n\
3425 --version display version info\n\
3433 exit (error
? 1 : 0);
3437 /* Display version and copyright info. The VERSION macro is set
3438 from the Makefile and contains the Emacs version. */
3443 printf ("ebrowse %s\n", VERSION
);
3444 puts ("Copyright (C) 1992-1999, 2000 Free Software Foundation, Inc.");
3445 puts ("This program is distributed under the same terms as Emacs.");
3450 /* Parse one input file FILE, adding classes and members to the symbol
3459 fp
= open_file (file
);
3464 /* Give a progress indication if needed. */
3476 /* Read file to inbuffer. */
3479 if (nread
+ READ_CHUNK_SIZE
>= inbuffer_size
)
3481 inbuffer_size
= nread
+ READ_CHUNK_SIZE
+ 1;
3482 inbuffer
= (char *) xrealloc (inbuffer
, inbuffer_size
);
3485 nbytes
= fread (inbuffer
+ nread
, 1, READ_CHUNK_SIZE
, fp
);
3487 if (nbytes
< READ_CHUNK_SIZE
)
3490 inbuffer
[nread
] = '\0';
3492 /* Reinitialize scanner and parser for the new input file. */
3496 /* Parse it and close the file. */
3503 /* Read a line from stream FP and return a pointer to a static buffer
3504 containing its contents without the terminating newline. Value
3505 is null when EOF is reached. */
3511 static char *buffer
;
3512 static int buffer_size
;
3515 while ((c
= getc (fp
)) != EOF
&& c
!= '\n')
3517 if (i
>= buffer_size
)
3519 buffer_size
= max (100, buffer_size
* 2);
3520 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3526 if (c
== EOF
&& i
== 0)
3529 if (i
== buffer_size
)
3531 buffer_size
= max (100, buffer_size
* 2);
3532 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3540 /* Main entry point. */
3548 int any_inputfiles
= 0;
3549 static char *out_filename
= DEFAULT_OUTFILE
;
3550 static char **input_filenames
= NULL
;
3551 static int input_filenames_size
= 0;
3552 static int n_input_files
;
3554 filename
= "command line";
3557 while ((i
= getopt_long (argc
, argv
, "af:I:m:M:no:p:svVx",
3558 options
, NULL
)) != EOF
)
3564 info_position
= atoi (optarg
);
3568 f_nested_classes
= 0;
3575 /* Add the name of a file containing more input files. */
3577 if (n_input_files
== input_filenames_size
)
3579 input_filenames_size
= max (10, 2 * input_filenames_size
);
3580 input_filenames
= (char **) xrealloc (input_filenames
,
3581 input_filenames_size
);
3583 input_filenames
[n_input_files
++] = xstrdup (optarg
);
3586 /* Append new output to output file instead of truncating it. */
3591 /* Include structs in the output */
3596 /* Be verbose (give a progress indication). */
3601 /* Be very verbose (print file names as they are processed). */
3607 /* Change the name of the output file. */
3609 out_filename
= optarg
;
3612 /* Set minimum length for regular expression strings
3613 when recorded in the output file. */
3615 min_regexp
= atoi (optarg
);
3618 /* Set maximum length for regular expression strings
3619 when recorded in the output file. */
3621 max_regexp
= atoi (optarg
);
3624 /* Add to search path. */
3626 add_search_path (optarg
);
3640 /* Call init_scanner after command line flags have been processed to be
3641 able to add keywords depending on command line (not yet
3646 /* Open output file */
3649 yyout
= fopen (out_filename
, f_append
? "a" : "w");
3652 yyerror ("cannot open output file `%s'", out_filename
);
3657 /* Process input files specified on the command line. */
3658 while (optind
< argc
)
3660 process_file (argv
[optind
++]);
3664 /* Process files given on stdin if no files specified. */
3665 if (!any_inputfiles
&& n_input_files
== 0)
3668 while ((file
= read_line (stdin
)) != NULL
)
3669 process_file (file
);
3673 /* Process files from `--files=FILE'. Every line in FILE names
3674 one input file to process. */
3675 for (i
= 0; i
< n_input_files
; ++i
)
3677 FILE *fp
= fopen (input_filenames
[i
], "r");
3680 yyerror ("cannot open input file `%s'", input_filenames
[i
]);
3684 while ((file
= read_line (fp
)) != NULL
)
3685 process_file (file
);
3691 /* Write output file. */
3694 /* Close output file. */
3695 if (yyout
!= stdout
)
3702 /* ebrowse.c ends here. */