1 /* ebrowse.c --- parsing files for the ebrowse C++ browser
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
5 Free Software Foundation Inc.
7 Author: Gerd Moellmann <gerd@gnu.org>
10 This file is part of GNU Emacs.
12 GNU Emacs is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2, or (at your option)
17 GNU Emacs is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with GNU Emacs; see the file COPYING. If not, write to
24 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
37 /* The SunOS compiler doesn't have SEEK_END. */
42 /* Conditionalize function prototypes. */
44 #ifdef PROTOTYPES /* From config.h. */
50 /* Value is non-zero if strings X and Y compare equal. */
52 #define streq(X, Y) (*(X) == *(Y) && strcmp ((X) + 1, (Y) + 1) == 0)
54 /* The ubiquitous `max' and `min' macros. */
57 #define max(X, Y) ((X) > (Y) ? (X) : (Y))
58 #define min(X, Y) ((X) < (Y) ? (X) : (Y))
61 /* Files are read in chunks of this number of bytes. */
63 #define READ_CHUNK_SIZE (100 * 1024)
65 /* The character used as a separator in path lists (like $PATH). */
67 #if defined(__MSDOS__)
68 #define PATH_LIST_SEPARATOR ';'
69 #define FILENAME_EQ(X,Y) (strcasecmp(X,Y) == 0)
71 #if defined(WINDOWSNT)
72 #define PATH_LIST_SEPARATOR ';'
73 #define FILENAME_EQ(X,Y) (stricmp(X,Y) == 0)
75 #define PATH_LIST_SEPARATOR ':'
76 #define FILENAME_EQ(X,Y) (streq(X,Y))
79 /* The default output file name. */
81 #define DEFAULT_OUTFILE "BROWSE"
83 /* A version string written to the output file. Change this whenever
84 the structure of the output file changes. */
86 #define EBROWSE_FILE_VERSION "ebrowse 5.0"
88 /* The output file consists of a tree of Lisp objects, with major
89 nodes built out of Lisp structures. These are the heads of the
90 Lisp structs with symbols identifying their type. */
92 #define TREE_HEADER_STRUCT "[ebrowse-hs "
93 #define TREE_STRUCT "[ebrowse-ts "
94 #define MEMBER_STRUCT "[ebrowse-ms "
95 #define BROWSE_STRUCT "[ebrowse-bs "
96 #define CLASS_STRUCT "[ebrowse-cs "
98 /* The name of the symbol table entry for global functions, variables,
99 defines etc. This name also appears in the browser display. */
101 #define GLOBALS_NAME "*Globals*"
103 /* Token definitions. */
107 YYEOF
= 0, /* end of file */
108 CSTRING
= 256, /* string constant */
109 CCHAR
, /* character constant */
110 CINT
, /* integral constant */
111 CFLOAT
, /* real constant */
114 LSHIFTASGN
, /* <<= */
115 RSHIFTASGN
, /* >>= */
117 IDENT
, /* identifier */
140 /* Keywords. The undef's are there because these
141 three symbols are very likely to be defined somewhere. */
154 CONTINUE
, /* continue */
155 DEFAULT
, /* default */
167 T_INLINE
, /* inline */
171 OPERATOR
, /* operator */
172 PRIVATE
, /* private */
173 PROTECTED
, /* protected */
175 REGISTER
, /* register */
183 TEMPLATE
, /* template */
187 TYPEDEF
, /* typedef */
189 UNSIGNED
, /* unsigned */
190 VIRTUAL
, /* virtual */
192 VOLATILE
, /* volatile */
194 MUTABLE
, /* mutable */
198 SIGNATURE
, /* signature (GNU extension) */
199 NAMESPACE
, /* namespace */
200 EXPLICIT
, /* explicit */
201 TYPENAME
, /* typename */
202 CONST_CAST
, /* const_cast */
203 DYNAMIC_CAST
, /* dynamic_cast */
204 REINTERPRET_CAST
, /* reinterpret_cast */
205 STATIC_CAST
, /* static_cast */
211 /* Storage classes, in a wider sense. */
216 SC_MEMBER
, /* Is an instance member. */
217 SC_STATIC
, /* Is static member. */
218 SC_FRIEND
, /* Is friend function. */
219 SC_TYPE
/* Is a type definition. */
222 /* Member visibility. */
233 #define F_VIRTUAL 1 /* Is virtual function. */
234 #define F_INLINE 2 /* Is inline function. */
235 #define F_CONST 4 /* Is const. */
236 #define F_PURE 8 /* Is pure virtual function. */
237 #define F_MUTABLE 16 /* Is mutable. */
238 #define F_TEMPLATE 32 /* Is a template. */
239 #define F_EXPLICIT 64 /* Is explicit constructor. */
240 #define F_THROW 128 /* Has a throw specification. */
241 #define F_EXTERNC 256 /* Is declared extern "C". */
242 #define F_DEFINE 512 /* Is a #define. */
244 /* Two macros to set and test a bit in an int. */
246 #define SET_FLAG(F, FLAG) ((F) |= (FLAG))
247 #define HAS_FLAG(F, FLAG) (((F) & (FLAG)) != 0)
249 /* Structure describing a class member. */
253 struct member
*next
; /* Next in list of members. */
254 struct member
*anext
; /* Collision chain in member_table. */
255 struct member
**list
; /* Pointer to list in class. */
256 unsigned param_hash
; /* Hash value for parameter types. */
257 int vis
; /* Visibility (public, ...). */
258 int flags
; /* See F_* above. */
259 char *regexp
; /* Matching regular expression. */
260 char *filename
; /* Don't free this shared string. */
261 int pos
; /* Buffer position of occurrence. */
262 char *def_regexp
; /* Regular expression matching definition. */
263 char *def_filename
; /* File name of definition. */
264 int def_pos
; /* Buffer position of definition. */
265 char name
[1]; /* Member name. */
268 /* Structures of this type are used to connect class structures with
269 their super and subclasses. */
273 struct sym
*sym
; /* The super or subclass. */
274 struct link
*next
; /* Next in list or NULL. */
277 /* Structure used to record namespace aliases. */
281 struct alias
*next
; /* Next in list. */
282 char name
[1]; /* Alias name. */
285 /* The structure used to describe a class in the symbol table,
286 or a namespace in all_namespaces. */
290 int flags
; /* Is class a template class?. */
291 unsigned char visited
; /* Used to find circles. */
292 struct sym
*next
; /* Hash collision list. */
293 struct link
*subs
; /* List of subclasses. */
294 struct link
*supers
; /* List of superclasses. */
295 struct member
*vars
; /* List of instance variables. */
296 struct member
*fns
; /* List of instance functions. */
297 struct member
*static_vars
; /* List of static variables. */
298 struct member
*static_fns
; /* List of static functions. */
299 struct member
*friends
; /* List of friend functions. */
300 struct member
*types
; /* List of local types. */
301 char *regexp
; /* Matching regular expression. */
302 int pos
; /* Buffer position. */
303 char *filename
; /* File in which it can be found. */
304 char *sfilename
; /* File in which members can be found. */
305 struct sym
*namesp
; /* Namespace in which defined. . */
306 struct alias
*namesp_aliases
; /* List of aliases for namespaces. */
307 char name
[1]; /* Name of the class. */
310 /* Experimental: Print info for `--position-info'. We print
311 '(CLASS-NAME SCOPE MEMBER-NAME). */
317 struct sym
*info_cls
= NULL
;
318 struct member
*info_member
= NULL
;
320 /* Experimental. For option `--position-info', the buffer position we
321 are interested in. When this position is reached, print out
322 information about what we know about that point. */
324 int info_position
= -1;
326 /* Command line options structure for getopt_long. */
328 struct option options
[] =
330 {"append", no_argument
, NULL
, 'a'},
331 {"files", required_argument
, NULL
, 'f'},
332 {"help", no_argument
, NULL
, -2},
333 {"min-regexp-length", required_argument
, NULL
, 'm'},
334 {"max-regexp-length", required_argument
, NULL
, 'M'},
335 {"no-nested-classes", no_argument
, NULL
, 'n'},
336 {"no-regexps", no_argument
, NULL
, 'x'},
337 {"no-structs-or-unions", no_argument
, NULL
, 's'},
338 {"output-file", required_argument
, NULL
, 'o'},
339 {"position-info", required_argument
, NULL
, 'p'},
340 {"search-path", required_argument
, NULL
, 'I'},
341 {"verbose", no_argument
, NULL
, 'v'},
342 {"version", no_argument
, NULL
, -3},
343 {"very-verbose", no_argument
, NULL
, 'V'},
347 /* Semantic values of tokens. Set by yylex.. */
349 unsigned yyival
; /* Set for token CINT. */
350 char *yytext
; /* Set for token IDENT. */
357 /* Current line number. */
361 /* The name of the current input file. */
365 /* Three character class vectors, and macros to test membership
372 #define IDENTP(C) is_ident[(unsigned char) (C)]
373 #define DIGITP(C) is_digit[(unsigned char) (C)]
374 #define WHITEP(C) is_white[(unsigned char) (C)]
376 /* Command line flags. */
383 int f_nested_classes
= 1;
385 /* Maximum and minimum lengths of regular expressions matching a
386 member, class etc., for writing them to the output file. These are
387 overridable from the command line. */
398 /* Return the current buffer position in the input file. */
400 #define BUFFER_POS() (in - inbuffer)
402 /* If current lookahead is CSTRING, the following points to the
403 first character in the string constant. Used for recognizing
408 /* The size of the hash tables for classes.and members. Should be
411 #define TABLE_SIZE 1001
413 /* The hash table for class symbols. */
415 struct sym
*class_table
[TABLE_SIZE
];
417 /* Hash table containing all member structures. This is generally
418 faster for member lookup than traversing the member lists of a
421 struct member
*member_table
[TABLE_SIZE
];
423 /* The special class symbol used to hold global functions,
426 struct sym
*global_symbols
;
428 /* The current namespace. */
430 struct sym
*current_namespace
;
432 /* The list of all known namespaces. */
434 struct sym
*all_namespaces
;
436 /* Stack of namespaces we're currently nested in, during the parse. */
438 struct sym
**namespace_stack
;
439 int namespace_stack_size
;
442 /* The current lookahead token. */
446 /* Structure describing a keyword. */
450 char *name
; /* Spelling. */
451 int tk
; /* Token value. */
452 struct kw
*next
; /* Next in collision chain. */
455 /* Keywords are lookup up in a hash table of their own. */
457 #define KEYWORD_TABLE_SIZE 1001
458 struct kw
*keyword_table
[KEYWORD_TABLE_SIZE
];
465 struct search_path
*next
;
468 struct search_path
*search_path
;
469 struct search_path
*search_path_tail
;
471 /* Function prototypes. */
473 int yylex
P_ ((void));
474 void yyparse
P_ ((void));
475 void re_init_parser
P_ ((void));
476 char *token_string
P_ ((int));
477 char *matching_regexp
P_ ((void));
478 void init_sym
P_ ((void));
479 struct sym
*add_sym
P_ ((char *, struct sym
*));
480 void add_link
P_ ((struct sym
*, struct sym
*));
481 void add_member_defn
P_ ((struct sym
*, char *, char *,
482 int, unsigned, int, int, int));
483 void add_member_decl
P_ ((struct sym
*, char *, char *, int,
484 unsigned, int, int, int, int));
485 void dump_roots
P_ ((FILE *));
486 void *xmalloc
P_ ((int));
487 void xfree
P_ ((void *));
488 void add_global_defn
P_ ((char *, char *, int, unsigned, int, int, int));
489 void add_global_decl
P_ ((char *, char *, int, unsigned, int, int, int));
490 void add_define
P_ ((char *, char *, int));
491 void mark_inherited_virtual
P_ ((void));
492 void leave_namespace
P_ ((void));
493 void enter_namespace
P_ ((char *));
494 void register_namespace_alias
P_ ((char *, char *));
495 void insert_keyword
P_ ((char *, int));
496 void re_init_scanner
P_ ((void));
497 void init_scanner
P_ ((void));
498 void usage
P_ ((int));
499 void version
P_ ((void));
500 void process_file
P_ ((char *));
501 void add_search_path
P_ ((char *));
502 FILE *open_file
P_ ((char *));
503 int process_pp_line
P_ ((void));
504 int dump_members
P_ ((FILE *, struct member
*));
505 void dump_sym
P_ ((FILE *, struct sym
*));
506 int dump_tree
P_ ((FILE *, struct sym
*));
507 struct member
*find_member
P_ ((struct sym
*, char *, int, int, unsigned));
508 struct member
*add_member
P_ ((struct sym
*, char *, int, int, unsigned));
509 void mark_virtual
P_ ((struct sym
*));
510 void mark_virtual
P_ ((struct sym
*));
511 struct sym
*make_namespace
P_ ((char *));
512 char *sym_scope
P_ ((struct sym
*));
513 char *sym_scope_1
P_ ((struct sym
*));
514 int skip_to
P_ ((int));
515 void skip_matching
P_ ((void));
516 void member
P_ ((struct sym
*, int));
517 void class_body
P_ ((struct sym
*, int));
518 void class_definition
P_ ((struct sym
*, int, int, int));
519 void declaration
P_ ((int));
520 unsigned parm_list
P_ ((int *));
521 char *operator_name
P_ ((int *));
522 struct sym
*parse_classname
P_ ((void));
523 struct sym
*parse_qualified_ident_or_type
P_ ((char **));
524 void parse_qualified_param_ident_or_type
P_ ((char **));
525 int globals
P_ ((int));
526 void yyerror
P_ ((char *, char *));
530 /***********************************************************************
532 ***********************************************************************/
534 /* Print an error in a printf-like style with the current input file
535 name and line number. */
541 fprintf (stderr
, "%s:%d: ", filename
, yyline
);
542 fprintf (stderr
, format
, s
);
547 /* Like malloc but print an error and exit if not enough memory is
554 void *p
= malloc (nbytes
);
557 yyerror ("out of memory", NULL
);
564 /* Like realloc but print an error and exit if out of memory. */
574 yyerror ("out of memory", NULL
);
581 /* Like free but always check for null pointers.. */
592 /* Like strdup, but print an error and exit if not enough memory is
593 available.. If S is null, return null. */
600 s
= strcpy (xmalloc (strlen (s
) + 1), s
);
606 /***********************************************************************
608 ***********************************************************************/
610 /* Initialize the symbol table. This currently only sets up the
611 special symbol for globals (`*Globals*'). */
616 global_symbols
= add_sym (GLOBALS_NAME
, NULL
);
620 /* Add a symbol for class NAME to the symbol table. NESTED_IN_CLASS
621 is the class in which class NAME was found. If it is null,
622 this means the scope of NAME is the current namespace.
624 If a symbol for NAME already exists, return that. Otherwise
625 create a new symbol and set it to default values. */
628 add_sym (name
, nested_in_class
)
630 struct sym
*nested_in_class
;
635 struct sym
*scope
= nested_in_class
? nested_in_class
: current_namespace
;
637 for (s
= name
, h
= 0; *s
; ++s
)
641 for (sym
= class_table
[h
]; sym
; sym
= sym
->next
)
642 if (streq (name
, sym
->name
) && sym
->namesp
== scope
)
653 sym
= (struct sym
*) xmalloc (sizeof *sym
+ strlen (name
));
654 bzero (sym
, sizeof *sym
);
655 strcpy (sym
->name
, name
);
657 sym
->next
= class_table
[h
];
658 class_table
[h
] = sym
;
665 /* Add links between superclass SUPER and subclass SUB. */
668 add_link (super
, sub
)
669 struct sym
*super
, *sub
;
671 struct link
*lnk
, *lnk2
, *p
, *prev
;
673 /* See if a link already exists. */
674 for (p
= super
->subs
, prev
= NULL
;
675 p
&& strcmp (sub
->name
, p
->sym
->name
) > 0;
676 prev
= p
, p
= p
->next
)
679 /* Avoid duplicates. */
680 if (p
== NULL
|| p
->sym
!= sub
)
682 lnk
= (struct link
*) xmalloc (sizeof *lnk
);
683 lnk2
= (struct link
*) xmalloc (sizeof *lnk2
);
694 lnk2
->next
= sub
->supers
;
700 /* Find in class CLS member NAME.
702 VAR non-zero means look for a member variable; otherwise a function
703 is searched. SC specifies what kind of member is searched---a
704 static, or per-instance member etc. HASH is a hash code for the
705 parameter types of functions. Value is a pointer to the member
706 found or null if not found. */
709 find_member (cls
, name
, var
, sc
, hash
)
715 struct member
**list
;
717 unsigned name_hash
= 0;
724 list
= &cls
->friends
;
732 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
736 list
= var
? &cls
->vars
: &cls
->fns
;
740 for (s
= name
; *s
; ++s
)
741 name_hash
= (name_hash
<< 1) ^ *s
;
742 i
= name_hash
% TABLE_SIZE
;
744 for (p
= member_table
[i
]; p
; p
= p
->anext
)
745 if (p
->list
== list
&& p
->param_hash
== hash
&& streq (name
, p
->name
))
752 /* Add to class CLS information for the declaration of member NAME.
753 REGEXP is a regexp matching the declaration, if non-null. POS is
754 the position in the source where the declaration is found. HASH is
755 a hash code for the parameter list of the member, if it's a
756 function. VAR non-zero means member is a variable or type. SC
757 specifies the type of member (instance member, static, ...). VIS
758 is the member's visibility (public, protected, private). FLAGS is
759 a bit set giving additional information about the member (see the
763 add_member_decl (cls
, name
, regexp
, pos
, hash
, var
, sc
, vis
, flags
)
776 m
= find_member (cls
, name
, var
, sc
, hash
);
778 m
= add_member (cls
, name
, var
, sc
, hash
);
780 /* Have we seen a new filename? If so record that. */
781 if (!cls
->filename
|| !FILENAME_EQ (cls
->filename
, filename
))
782 m
->filename
= filename
;
795 m
->vis
= V_PROTECTED
;
809 /* Add to class CLS information for the definition of member NAME.
810 REGEXP is a regexp matching the declaration, if non-null. POS is
811 the position in the source where the declaration is found. HASH is
812 a hash code for the parameter list of the member, if it's a
813 function. VAR non-zero means member is a variable or type. SC
814 specifies the type of member (instance member, static, ...). VIS
815 is the member's visibility (public, protected, private). FLAGS is
816 a bit set giving additional information about the member (see the
820 add_member_defn (cls
, name
, regexp
, pos
, hash
, var
, sc
, flags
)
832 if (sc
== SC_UNKNOWN
)
834 m
= find_member (cls
, name
, var
, SC_MEMBER
, hash
);
837 m
= find_member (cls
, name
, var
, SC_STATIC
, hash
);
839 m
= add_member (cls
, name
, var
, sc
, hash
);
844 m
= find_member (cls
, name
, var
, sc
, hash
);
846 m
= add_member (cls
, name
, var
, sc
, hash
);
850 cls
->sfilename
= filename
;
852 if (!FILENAME_EQ (cls
->sfilename
, filename
))
853 m
->def_filename
= filename
;
855 m
->def_regexp
= regexp
;
865 /* Add a symbol for a define named NAME to the symbol table.
866 REGEXP is a regular expression matching the define in the source,
867 if it is non-null. POS is the position in the file. */
870 add_define (name
, regexp
, pos
)
874 add_global_defn (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
875 add_global_decl (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
879 /* Add information for the global definition of NAME.
880 REGEXP is a regexp matching the declaration, if non-null. POS is
881 the position in the source where the declaration is found. HASH is
882 a hash code for the parameter list of the member, if it's a
883 function. VAR non-zero means member is a variable or type. SC
884 specifies the type of member (instance member, static, ...). VIS
885 is the member's visibility (public, protected, private). FLAGS is
886 a bit set giving additional information about the member (see the
890 add_global_defn (name
, regexp
, pos
, hash
, var
, sc
, flags
)
901 /* Try to find out for which classes a function is a friend, and add
902 what we know about it to them. */
904 for (i
= 0; i
< TABLE_SIZE
; ++i
)
905 for (sym
= class_table
[i
]; sym
; sym
= sym
->next
)
906 if (sym
!= global_symbols
&& sym
->friends
)
907 if (find_member (sym
, name
, 0, SC_FRIEND
, hash
))
908 add_member_defn (sym
, name
, regexp
, pos
, hash
, 0,
911 /* Add to global symbols. */
912 add_member_defn (global_symbols
, name
, regexp
, pos
, hash
, var
, sc
, flags
);
916 /* Add information for the global declaration of NAME.
917 REGEXP is a regexp matching the declaration, if non-null. POS is
918 the position in the source where the declaration is found. HASH is
919 a hash code for the parameter list of the member, if it's a
920 function. VAR non-zero means member is a variable or type. SC
921 specifies the type of member (instance member, static, ...). VIS
922 is the member's visibility (public, protected, private). FLAGS is
923 a bit set giving additional information about the member (see the
927 add_global_decl (name
, regexp
, pos
, hash
, var
, sc
, flags
)
935 /* Add declaration only if not already declared. Header files must
936 be processed before source files for this to have the right effect.
937 I do not want to handle implicit declarations at the moment. */
939 struct member
*found
;
941 m
= found
= find_member (global_symbols
, name
, var
, sc
, hash
);
943 m
= add_member (global_symbols
, name
, var
, sc
, hash
);
945 /* Definition already seen => probably last declaration implicit.
946 Override. This means that declarations must always be added to
947 the symbol table before definitions. */
950 if (!global_symbols
->filename
951 || !FILENAME_EQ (global_symbols
->filename
, filename
))
952 m
->filename
= filename
;
960 info_cls
= global_symbols
;
966 /* Add a symbol for member NAME to class CLS.
967 VAR non-zero means it's a variable. SC specifies the kind of
968 member. HASH is a hash code for the parameter types of a function.
969 Value is a pointer to the member's structure. */
972 add_member (cls
, name
, var
, sc
, hash
)
979 struct member
*m
= (struct member
*) xmalloc (sizeof *m
+ strlen (name
));
980 struct member
**list
;
983 unsigned name_hash
= 0;
987 strcpy (m
->name
, name
);
988 m
->param_hash
= hash
;
995 m
->def_regexp
= NULL
;
996 m
->def_filename
= NULL
;
999 assert (cls
!= NULL
);
1004 list
= &cls
->friends
;
1012 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
1016 list
= var
? &cls
->vars
: &cls
->fns
;
1020 for (s
= name
; *s
; ++s
)
1021 name_hash
= (name_hash
<< 1) ^ *s
;
1022 i
= name_hash
% TABLE_SIZE
;
1023 m
->anext
= member_table
[i
];
1024 member_table
[i
] = m
;
1027 /* Keep the member list sorted. It's cheaper to do it here than to
1028 sort them in Lisp. */
1029 for (prev
= NULL
, p
= *list
;
1030 p
&& strcmp (name
, p
->name
) > 0;
1031 prev
= p
, p
= p
->next
)
1043 /* Given the root R of a class tree, step through all subclasses
1044 recursively, marking functions as virtual that are declared virtual
1052 struct member
*m
, *m2
;
1054 for (p
= r
->subs
; p
; p
= p
->next
)
1056 for (m
= r
->fns
; m
; m
= m
->next
)
1057 if (HAS_FLAG (m
->flags
, F_VIRTUAL
))
1059 for (m2
= p
->sym
->fns
; m2
; m2
= m2
->next
)
1060 if (m
->param_hash
== m2
->param_hash
&& streq (m
->name
, m2
->name
))
1061 SET_FLAG (m2
->flags
, F_VIRTUAL
);
1064 mark_virtual (p
->sym
);
1069 /* For all roots of the class tree, mark functions as virtual that
1070 are virtual because of a virtual declaration in a base class. */
1073 mark_inherited_virtual ()
1078 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1079 for (r
= class_table
[i
]; r
; r
= r
->next
)
1080 if (r
->supers
== NULL
)
1085 /* Create and return a symbol for a namespace with name NAME. */
1088 make_namespace (name
)
1091 struct sym
*s
= (struct sym
*) xmalloc (sizeof *s
+ strlen (name
));
1092 bzero (s
, sizeof *s
);
1093 strcpy (s
->name
, name
);
1094 s
->next
= all_namespaces
;
1095 s
->namesp
= current_namespace
;
1101 /* Find the symbol for namespace NAME. If not found, add a new symbol
1102 for NAME to all_namespaces. */
1105 find_namespace (name
)
1110 for (p
= all_namespaces
; p
; p
= p
->next
)
1112 if (streq (p
->name
, name
))
1117 for (p2
= p
->namesp_aliases
; p2
; p2
= p2
->next
)
1118 if (streq (p2
->name
, name
))
1126 p
= make_namespace (name
);
1132 /* Register the name NEW_NAME as an alias for namespace OLD_NAME. */
1135 register_namespace_alias (new_name
, old_name
)
1136 char *new_name
, *old_name
;
1138 struct sym
*p
= find_namespace (old_name
);
1141 /* Is it already in the list of aliases? */
1142 for (al
= p
->namesp_aliases
; al
; al
= al
->next
)
1143 if (streq (new_name
, p
->name
))
1146 al
= (struct alias
*) xmalloc (sizeof *al
+ strlen (new_name
));
1147 strcpy (al
->name
, new_name
);
1148 al
->next
= p
->namesp_aliases
;
1149 p
->namesp_aliases
= al
;
1153 /* Enter namespace with name NAME. */
1156 enter_namespace (name
)
1159 struct sym
*p
= find_namespace (name
);
1161 if (namespace_sp
== namespace_stack_size
)
1163 int size
= max (10, 2 * namespace_stack_size
);
1165 = (struct sym
**) xrealloc ((void *)namespace_stack
,
1166 size
* sizeof *namespace_stack
);
1167 namespace_stack_size
= size
;
1170 namespace_stack
[namespace_sp
++] = current_namespace
;
1171 current_namespace
= p
;
1175 /* Leave the current namespace. */
1180 assert (namespace_sp
> 0);
1181 current_namespace
= namespace_stack
[--namespace_sp
];
1186 /***********************************************************************
1187 Writing the Output File
1188 ***********************************************************************/
1190 /* Write string S to the output file FP in a Lisp-readable form.
1191 If S is null, write out `()'. */
1193 #define PUTSTR(s, fp) \
1210 /* A dynamically allocated buffer for constructing a scope name. */
1213 int scope_buffer_size
;
1214 int scope_buffer_len
;
1217 /* Make sure scope_buffer has enough room to add LEN chars to it. */
1220 ensure_scope_buffer_room (len
)
1223 if (scope_buffer_len
+ len
>= scope_buffer_size
)
1225 int new_size
= max (2 * scope_buffer_size
, scope_buffer_len
+ len
);
1226 scope_buffer
= (char *) xrealloc (scope_buffer
, new_size
);
1227 scope_buffer_size
= new_size
;
1232 /* Recursively add the scope names of symbol P and the scopes of its
1233 namespaces to scope_buffer. Value is a pointer to the complete
1234 scope name constructed. */
1243 sym_scope_1 (p
->namesp
);
1247 ensure_scope_buffer_room (3);
1248 strcat (scope_buffer
, "::");
1249 scope_buffer_len
+= 2;
1252 len
= strlen (p
->name
);
1253 ensure_scope_buffer_room (len
+ 1);
1254 strcat (scope_buffer
, p
->name
);
1255 scope_buffer_len
+= len
;
1257 if (HAS_FLAG (p
->flags
, F_TEMPLATE
))
1259 ensure_scope_buffer_room (3);
1260 strcat (scope_buffer
, "<>");
1261 scope_buffer_len
+= 2;
1264 return scope_buffer
;
1268 /* Return the scope of symbol P in printed representation, i.e.
1269 as it would appear in a C*+ source file. */
1277 scope_buffer_size
= 1024;
1278 scope_buffer
= (char *) xmalloc (scope_buffer_size
);
1281 *scope_buffer
= '\0';
1282 scope_buffer_len
= 0;
1285 sym_scope_1 (p
->namesp
);
1287 return scope_buffer
;
1291 /* Dump the list of members M to file FP. Value is the length of the
1295 dump_members (fp
, m
)
1303 for (n
= 0; m
; m
= m
->next
, ++n
)
1305 fputs (MEMBER_STRUCT
, fp
);
1306 PUTSTR (m
->name
, fp
);
1307 PUTSTR (NULL
, fp
); /* FIXME? scope for globals */
1308 fprintf (fp
, "%u ", (unsigned) m
->flags
);
1309 PUTSTR (m
->filename
, fp
);
1310 PUTSTR (m
->regexp
, fp
);
1311 fprintf (fp
, "%u ", (unsigned) m
->pos
);
1312 fprintf (fp
, "%u ", (unsigned) m
->vis
);
1314 PUTSTR (m
->def_filename
, fp
);
1315 PUTSTR (m
->def_regexp
, fp
);
1316 fprintf (fp
, "%u", (unsigned) m
->def_pos
);
1327 /* Dump class ROOT to stream FP. */
1334 fputs (CLASS_STRUCT
, fp
);
1335 PUTSTR (root
->name
, fp
);
1337 /* Print scope, if any. */
1339 PUTSTR (sym_scope (root
), fp
);
1344 fprintf (fp
, "%u", root
->flags
);
1345 PUTSTR (root
->filename
, fp
);
1346 PUTSTR (root
->regexp
, fp
);
1347 fprintf (fp
, "%u", (unsigned) root
->pos
);
1348 PUTSTR (root
->sfilename
, fp
);
1354 /* Dump class ROOT and its subclasses to file FP. Value is the
1355 number of classes written. */
1358 dump_tree (fp
, root
)
1365 dump_sym (fp
, root
);
1375 for (lk
= root
->subs
; lk
; lk
= lk
->next
)
1377 fputs (TREE_STRUCT
, fp
);
1378 n
+= dump_tree (fp
, lk
->sym
);
1384 dump_members (fp
, root
->vars
);
1385 n
+= dump_members (fp
, root
->fns
);
1386 dump_members (fp
, root
->static_vars
);
1387 n
+= dump_members (fp
, root
->static_fns
);
1388 n
+= dump_members (fp
, root
->friends
);
1389 dump_members (fp
, root
->types
);
1404 /* Dump the entire class tree to file FP. */
1413 /* Output file header containing version string, command line
1417 fputs (TREE_HEADER_STRUCT
, fp
);
1418 PUTSTR (EBROWSE_FILE_VERSION
, fp
);
1431 /* Mark functions as virtual that are so because of functions
1432 declared virtual in base classes. */
1433 mark_inherited_virtual ();
1435 /* Dump the roots of the graph. */
1436 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1437 for (r
= class_table
[i
]; r
; r
= r
->next
)
1440 fputs (TREE_STRUCT
, fp
);
1441 n
+= dump_tree (fp
, r
);
1451 /***********************************************************************
1453 ***********************************************************************/
1456 #define INCREMENT_LINENO \
1458 if (f_very_verbose) \
1461 printf ("%d:\n", yyline); \
1467 #define INCREMENT_LINENO ++yyline
1470 /* Define two macros for accessing the input buffer (current input
1471 file). GET(C) sets C to the next input character and advances the
1472 input pointer. UNGET retracts the input pointer. */
1474 #define GET(C) ((C) = *in++)
1475 #define UNGET() (--in)
1478 /* Process a preprocessor line. Value is the next character from the
1479 input buffer not consumed. */
1484 int in_comment
= 0, in_string
= 0;
1488 /* Skip over white space. The `#' has been consumed already. */
1489 while (WHITEP (GET (c
)))
1492 /* Read the preprocessor command (if any). */
1499 /* Is it a `define'? */
1502 if (*yytext
&& streq (yytext
, "define"))
1517 char *regexp
= matching_regexp ();
1518 int pos
= BUFFER_POS ();
1519 add_define (yytext
, regexp
, pos
);
1523 while (c
&& (c
!= '\n' || in_comment
|| in_string
))
1527 else if (c
== '/' && !in_comment
)
1532 else if (c
== '*' && in_comment
)
1538 in_string
= !in_string
;
1550 /* Value is the next token from the input buffer. */
1561 while (WHITEP (GET (c
)))
1583 /* String and character constants. */
1586 while (GET (c
) && c
!= end_char
)
1591 /* Escape sequences. */
1594 if (end_char
== '\'')
1595 yyerror ("EOF in character constant", NULL
);
1597 yyerror ("EOF in string constant", NULL
);
1615 /* Hexadecimal escape sequence. */
1617 for (i
= 0; i
< 2; ++i
)
1621 if (c
>= '0' && c
<= '7')
1623 else if (c
>= 'a' && c
<= 'f')
1625 else if (c
>= 'A' && c
<= 'F')
1638 /* Octal escape sequence. */
1640 for (i
= 0; i
< 3; ++i
)
1644 if (c
>= '0' && c
<= '7')
1661 if (end_char
== '\'')
1662 yyerror ("newline in character constant", NULL
);
1664 yyerror ("newline in string constant", NULL
);
1674 return end_char
== '\'' ? CCHAR
: CSTRING
;
1676 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1677 case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
1678 case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
1679 case 'v': case 'w': case 'x': case 'y': case 'z':
1680 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
1681 case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
1682 case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
1683 case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_':
1685 /* Identifier and keywords. */
1692 while (IDENTP (GET (*p
)))
1694 hash
= (hash
<< 1) ^ *p
++;
1695 if (p
== yytext_end
- 1)
1697 int size
= yytext_end
- yytext
;
1698 yytext
= (char *) xrealloc (yytext
, 2 * size
);
1699 yytext_end
= yytext
+ 2 * size
;
1700 p
= yytext
+ size
- 1;
1707 for (k
= keyword_table
[hash
% KEYWORD_TABLE_SIZE
]; k
; k
= k
->next
)
1708 if (streq (k
->name
, yytext
))
1715 /* C and C++ comments, '/' and '/='. */
1743 while (GET (c
) && c
!= '\n')
1818 yyerror ("invalid token '..' ('...' assumed)", NULL
);
1822 else if (!DIGITP (c
))
1876 c
= process_pp_line ();
1881 case '(': case ')': case '[': case ']': case '{': case '}':
1882 case ';': case ',': case '?': case '~':
1888 if (GET (c
) == 'x' || c
== 'X')
1893 yyival
= yyival
* 16 + c
- '0';
1894 else if (c
>= 'a' && c
<= 'f')
1895 yyival
= yyival
* 16 + c
- 'a' + 10;
1896 else if (c
>= 'A' && c
<= 'F')
1897 yyival
= yyival
* 16 + c
- 'A' + 10;
1907 while (c
>= '0' && c
<= '7')
1909 yyival
= (yyival
<< 3) + c
- '0';
1914 /* Integer suffixes. */
1920 case '1': case '2': case '3': case '4': case '5': case '6':
1921 case '7': case '8': case '9':
1922 /* Integer or floating constant, part before '.'. */
1925 while (GET (c
) && DIGITP (c
))
1926 yyival
= 10 * yyival
+ c
- '0';
1932 /* Digits following '.'. */
1936 /* Optional exponent. */
1937 if (c
== 'E' || c
== 'e')
1939 if (GET (c
) == '-' || c
== '+')
1946 /* Optional type suffixes. */
1959 /* Actually local to matching_regexp. These variables must be in
1960 global scope for the case that `static' get's defined away. */
1962 static char *matching_regexp_buffer
, *matching_regexp_end_buf
;
1965 /* Value is the string from the start of the line to the current
1966 position in the input buffer, or maybe a bit more if that string is
1967 shorter than min_regexp. */
1979 if (matching_regexp_buffer
== NULL
)
1981 matching_regexp_buffer
= (char *) xmalloc (max_regexp
);
1982 matching_regexp_end_buf
= &matching_regexp_buffer
[max_regexp
] - 1;
1985 /* Scan back to previous newline of buffer start. */
1986 for (p
= in
- 1; p
> inbuffer
&& *p
!= '\n'; --p
)
1991 while (in
- p
< min_regexp
&& p
> inbuffer
)
1993 /* Line probably not significant enough */
1994 for (--p
; p
>= inbuffer
&& *p
!= '\n'; --p
)
2001 /* Copy from end to make sure significant portions are included.
2002 This implies that in the browser a regular expressing of the form
2003 `^.*{regexp}' has to be used. */
2004 for (s
= matching_regexp_end_buf
- 1, t
= in
;
2005 s
> matching_regexp_buffer
&& t
> p
;)
2013 *(matching_regexp_end_buf
- 1) = '\0';
2018 /* Return a printable representation of token T. */
2028 case CSTRING
: return "string constant";
2029 case CCHAR
: return "char constant";
2030 case CINT
: return "int constant";
2031 case CFLOAT
: return "floating constant";
2032 case ELLIPSIS
: return "...";
2033 case LSHIFTASGN
: return "<<=";
2034 case RSHIFTASGN
: return ">>=";
2035 case ARROWSTAR
: return "->*";
2036 case IDENT
: return "identifier";
2037 case DIVASGN
: return "/=";
2038 case INC
: return "++";
2039 case ADDASGN
: return "+=";
2040 case DEC
: return "--";
2041 case ARROW
: return "->";
2042 case SUBASGN
: return "-=";
2043 case MULASGN
: return "*=";
2044 case MODASGN
: return "%=";
2045 case LOR
: return "||";
2046 case ORASGN
: return "|=";
2047 case LAND
: return "&&";
2048 case ANDASGN
: return "&=";
2049 case XORASGN
: return "^=";
2050 case POINTSTAR
: return ".*";
2051 case DCOLON
: return "::";
2052 case EQ
: return "==";
2053 case NE
: return "!=";
2054 case LE
: return "<=";
2055 case LSHIFT
: return "<<";
2056 case GE
: return ">=";
2057 case RSHIFT
: return ">>";
2058 case ASM
: return "asm";
2059 case AUTO
: return "auto";
2060 case BREAK
: return "break";
2061 case CASE
: return "case";
2062 case CATCH
: return "catch";
2063 case CHAR
: return "char";
2064 case CLASS
: return "class";
2065 case CONST
: return "const";
2066 case CONTINUE
: return "continue";
2067 case DEFAULT
: return "default";
2068 case DELETE
: return "delete";
2069 case DO
: return "do";
2070 case DOUBLE
: return "double";
2071 case ELSE
: return "else";
2072 case ENUM
: return "enum";
2073 case EXTERN
: return "extern";
2074 case FLOAT
: return "float";
2075 case FOR
: return "for";
2076 case FRIEND
: return "friend";
2077 case GOTO
: return "goto";
2078 case IF
: return "if";
2079 case T_INLINE
: return "inline";
2080 case INT
: return "int";
2081 case LONG
: return "long";
2082 case NEW
: return "new";
2083 case OPERATOR
: return "operator";
2084 case PRIVATE
: return "private";
2085 case PROTECTED
: return "protected";
2086 case PUBLIC
: return "public";
2087 case REGISTER
: return "register";
2088 case RETURN
: return "return";
2089 case SHORT
: return "short";
2090 case SIGNED
: return "signed";
2091 case SIZEOF
: return "sizeof";
2092 case STATIC
: return "static";
2093 case STRUCT
: return "struct";
2094 case SWITCH
: return "switch";
2095 case TEMPLATE
: return "template";
2096 case THIS
: return "this";
2097 case THROW
: return "throw";
2098 case TRY
: return "try";
2099 case TYPEDEF
: return "typedef";
2100 case UNION
: return "union";
2101 case UNSIGNED
: return "unsigned";
2102 case VIRTUAL
: return "virtual";
2103 case VOID
: return "void";
2104 case VOLATILE
: return "volatile";
2105 case WHILE
: return "while";
2106 case MUTABLE
: return "mutable";
2107 case BOOL
: return "bool";
2108 case TRUE
: return "true";
2109 case FALSE
: return "false";
2110 case SIGNATURE
: return "signature";
2111 case NAMESPACE
: return "namespace";
2112 case EXPLICIT
: return "explicit";
2113 case TYPENAME
: return "typename";
2114 case CONST_CAST
: return "const_cast";
2115 case DYNAMIC_CAST
: return "dynamic_cast";
2116 case REINTERPRET_CAST
: return "reinterpret_cast";
2117 case STATIC_CAST
: return "static_cast";
2118 case TYPEID
: return "typeid";
2119 case USING
: return "using";
2120 case WCHAR
: return "wchar_t";
2121 case YYEOF
: return "EOF";
2136 /* Reinitialize the scanner for a new input file. */
2147 yytext
= (char *) xmalloc (size
* sizeof *yytext
);
2148 yytext_end
= yytext
+ size
;
2153 /* Insert a keyword NAME with token value TK into the keyword hash
2157 insert_keyword (name
, tk
)
2163 struct kw
*k
= (struct kw
*) xmalloc (sizeof *k
);
2165 for (s
= name
; *s
; ++s
)
2168 h
%= KEYWORD_TABLE_SIZE
;
2171 k
->next
= keyword_table
[h
];
2172 keyword_table
[h
] = k
;
2176 /* Initialize the scanner for the first file. This sets up the
2177 character class vectors and fills the keyword hash table. */
2184 /* Allocate the input buffer */
2185 inbuffer_size
= READ_CHUNK_SIZE
+ 1;
2186 inbuffer
= in
= (char *) xmalloc (inbuffer_size
);
2189 /* Set up character class vectors. */
2190 for (i
= 0; i
< sizeof is_ident
; ++i
)
2192 if (i
== '_' || isalnum (i
))
2195 if (i
>= '0' && i
<= '9')
2198 if (i
== ' ' || i
== '\t' || i
== '\f' || i
== '\v')
2202 /* Fill keyword hash table. */
2203 insert_keyword ("and", LAND
);
2204 insert_keyword ("and_eq", ANDASGN
);
2205 insert_keyword ("asm", ASM
);
2206 insert_keyword ("auto", AUTO
);
2207 insert_keyword ("bitand", '&');
2208 insert_keyword ("bitor", '|');
2209 insert_keyword ("bool", BOOL
);
2210 insert_keyword ("break", BREAK
);
2211 insert_keyword ("case", CASE
);
2212 insert_keyword ("catch", CATCH
);
2213 insert_keyword ("char", CHAR
);
2214 insert_keyword ("class", CLASS
);
2215 insert_keyword ("compl", '~');
2216 insert_keyword ("const", CONST
);
2217 insert_keyword ("const_cast", CONST_CAST
);
2218 insert_keyword ("continue", CONTINUE
);
2219 insert_keyword ("default", DEFAULT
);
2220 insert_keyword ("delete", DELETE
);
2221 insert_keyword ("do", DO
);
2222 insert_keyword ("double", DOUBLE
);
2223 insert_keyword ("dynamic_cast", DYNAMIC_CAST
);
2224 insert_keyword ("else", ELSE
);
2225 insert_keyword ("enum", ENUM
);
2226 insert_keyword ("explicit", EXPLICIT
);
2227 insert_keyword ("extern", EXTERN
);
2228 insert_keyword ("false", FALSE
);
2229 insert_keyword ("float", FLOAT
);
2230 insert_keyword ("for", FOR
);
2231 insert_keyword ("friend", FRIEND
);
2232 insert_keyword ("goto", GOTO
);
2233 insert_keyword ("if", IF
);
2234 insert_keyword ("inline", T_INLINE
);
2235 insert_keyword ("int", INT
);
2236 insert_keyword ("long", LONG
);
2237 insert_keyword ("mutable", MUTABLE
);
2238 insert_keyword ("namespace", NAMESPACE
);
2239 insert_keyword ("new", NEW
);
2240 insert_keyword ("not", '!');
2241 insert_keyword ("not_eq", NE
);
2242 insert_keyword ("operator", OPERATOR
);
2243 insert_keyword ("or", LOR
);
2244 insert_keyword ("or_eq", ORASGN
);
2245 insert_keyword ("private", PRIVATE
);
2246 insert_keyword ("protected", PROTECTED
);
2247 insert_keyword ("public", PUBLIC
);
2248 insert_keyword ("register", REGISTER
);
2249 insert_keyword ("reinterpret_cast", REINTERPRET_CAST
);
2250 insert_keyword ("return", RETURN
);
2251 insert_keyword ("short", SHORT
);
2252 insert_keyword ("signed", SIGNED
);
2253 insert_keyword ("sizeof", SIZEOF
);
2254 insert_keyword ("static", STATIC
);
2255 insert_keyword ("static_cast", STATIC_CAST
);
2256 insert_keyword ("struct", STRUCT
);
2257 insert_keyword ("switch", SWITCH
);
2258 insert_keyword ("template", TEMPLATE
);
2259 insert_keyword ("this", THIS
);
2260 insert_keyword ("throw", THROW
);
2261 insert_keyword ("true", TRUE
);
2262 insert_keyword ("try", TRY
);
2263 insert_keyword ("typedef", TYPEDEF
);
2264 insert_keyword ("typeid", TYPEID
);
2265 insert_keyword ("typename", TYPENAME
);
2266 insert_keyword ("union", UNION
);
2267 insert_keyword ("unsigned", UNSIGNED
);
2268 insert_keyword ("using", USING
);
2269 insert_keyword ("virtual", VIRTUAL
);
2270 insert_keyword ("void", VOID
);
2271 insert_keyword ("volatile", VOLATILE
);
2272 insert_keyword ("wchar_t", WCHAR
);
2273 insert_keyword ("while", WHILE
);
2274 insert_keyword ("xor", '^');
2275 insert_keyword ("xor_eq", XORASGN
);
2280 /***********************************************************************
2282 ***********************************************************************/
2284 /* Match the current lookahead token and set it to the next token. */
2286 #define MATCH() (tk = yylex ())
2288 /* Return the lookahead token. If current lookahead token is cleared,
2289 read a new token. */
2291 #define LA1 (tk == -1 ? (tk = yylex ()) : tk)
2293 /* Is the current lookahead equal to the token T? */
2295 #define LOOKING_AT(T) (tk == (T))
2297 /* Is the current lookahead one of T1 or T2? */
2299 #define LOOKING_AT2(T1, T2) (tk == (T1) || tk == (T2))
2301 /* Is the current lookahead one of T1, T2 or T3? */
2303 #define LOOKING_AT3(T1, T2, T3) (tk == (T1) || tk == (T2) || tk == (T3))
2305 /* Is the current lookahead one of T1...T4? */
2307 #define LOOKING_AT4(T1, T2, T3, T4) \
2308 (tk == (T1) || tk == (T2) || tk == (T3) || tk == (T4))
2310 /* Match token T if current lookahead is T. */
2312 #define MATCH_IF(T) if (LOOKING_AT (T)) MATCH (); else ((void) 0)
2314 /* Skip to matching token if current token is T. */
2316 #define SKIP_MATCHING_IF(T) \
2317 if (LOOKING_AT (T)) skip_matching (); else ((void) 0)
2320 /* Skip forward until a given token TOKEN or YYEOF is seen and return
2321 the current lookahead token after skipping. */
2327 while (!LOOKING_AT2 (YYEOF
, token
))
2333 /* Skip over pairs of tokens (parentheses, square brackets,
2334 angle brackets, curly brackets) matching the current lookahead. */
2365 if (LOOKING_AT (open
))
2367 else if (LOOKING_AT (close
))
2369 else if (LOOKING_AT (YYEOF
))
2380 /* Re-initialize the parser by resetting the lookahead token. */
2389 /* Parse a parameter list, including the const-specifier,
2390 pure-specifier, and throw-list that may follow a parameter list.
2391 Return in FLAGS what was seen following the parameter list.
2392 Returns a hash code for the parameter types. This value is used to
2393 distinguish between overloaded functions. */
2402 while (!LOOKING_AT2 (YYEOF
, ')'))
2406 /* Skip over grouping parens or parameter lists in parameter
2412 /* Next parameter. */
2418 /* Ignore the scope part of types, if any. This is because
2419 some types need scopes when defined outside of a class body,
2420 and don't need them inside the class body. This means that
2421 we have to look for the last IDENT in a sequence of
2422 IDENT::IDENT::... */
2427 unsigned ident_type_hash
= 0;
2429 parse_qualified_param_ident_or_type (&last_id
);
2432 /* LAST_ID null means something like `X::*'. */
2433 for (; *last_id
; ++last_id
)
2434 ident_type_hash
= (ident_type_hash
<< 1) ^ *last_id
;
2435 hash
= (hash
<< 1) ^ ident_type_hash
;
2444 /* This distinction is made to make `func (void)' equivalent
2448 if (!LOOKING_AT (')'))
2449 hash
= (hash
<< 1) ^ VOID
;
2452 case BOOL
: case CHAR
: case CLASS
: case CONST
:
2453 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2454 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2455 case UNION
: case UNSIGNED
: case VOLATILE
: case WCHAR
:
2458 hash
= (hash
<< 1) ^ LA1
;
2462 case '*': case '&': case '[': case ']':
2463 hash
= (hash
<< 1) ^ LA1
;
2473 if (LOOKING_AT (')'))
2477 if (LOOKING_AT (CONST
))
2479 /* We can overload the same function on `const' */
2480 hash
= (hash
<< 1) ^ CONST
;
2481 SET_FLAG (*flags
, F_CONST
);
2485 if (LOOKING_AT (THROW
))
2488 SKIP_MATCHING_IF ('(');
2489 SET_FLAG (*flags
, F_THROW
);
2492 if (LOOKING_AT ('='))
2495 if (LOOKING_AT (CINT
) && yyival
== 0)
2498 SET_FLAG (*flags
, F_PURE
);
2507 /* Print position info to stdout. */
2512 if (info_position
>= 0 && BUFFER_POS () <= info_position
)
2514 printf ("(\"%s\" \"%s\" \"%s\" %d)\n",
2515 info_cls
->name
, sym_scope (info_cls
),
2516 info_member
->name
, info_where
);
2520 /* Parse a member declaration within the class body of CLS. VIS is
2521 the access specifier for the member (private, protected,
2531 char *regexp
= NULL
;
2542 while (!LOOKING_AT4 (';', '{', '}', YYEOF
))
2550 /* A function or class may follow. */
2553 SET_FLAG (flags
, F_TEMPLATE
);
2554 /* Skip over template argument list */
2555 SKIP_MATCHING_IF ('<');
2559 SET_FLAG (flags
, F_EXPLICIT
);
2563 SET_FLAG (flags
, F_MUTABLE
);
2567 SET_FLAG (flags
, F_INLINE
);
2571 SET_FLAG (flags
, F_VIRTUAL
);
2600 /* Remember IDENTS seen so far. Among these will be the member
2602 id
= (char *) xrealloc (id
, strlen (yytext
) + 2);
2606 strcpy (id
+ 1, yytext
);
2609 strcpy (id
, yytext
);
2615 char *s
= operator_name (&sc
);
2616 id
= (char *) xrealloc (id
, strlen (s
) + 1);
2622 /* Most probably the beginning of a parameter list. */
2628 if (!(is_constructor
= streq (id
, cls
->name
)))
2629 regexp
= matching_regexp ();
2634 pos
= BUFFER_POS ();
2635 hash
= parm_list (&flags
);
2638 regexp
= matching_regexp ();
2640 if (id
&& cls
!= NULL
)
2641 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, flags
);
2643 while (!LOOKING_AT3 (';', '{', YYEOF
))
2646 if (LOOKING_AT ('{') && id
&& cls
)
2647 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0, sc
, flags
);
2654 case STRUCT
: case UNION
: case CLASS
:
2661 /* More than one ident here to allow for MS-DOS specialties
2662 like `_export class' etc. The last IDENT seen counts
2663 as the class name. */
2664 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
2666 if (LOOKING_AT (IDENT
))
2671 if (LOOKING_AT2 (':', '{'))
2672 class_definition (anonymous
? NULL
: cls
, class_tag
, flags
, 1);
2677 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
2678 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
2679 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
2688 if (LOOKING_AT (';'))
2690 /* The end of a member variable, a friend declaration or an access
2691 declaration. We don't want to add friend classes as members. */
2692 if (id
&& sc
!= SC_FRIEND
&& cls
)
2694 regexp
= matching_regexp ();
2695 pos
= BUFFER_POS ();
2699 if (type_seen
|| !paren_seen
)
2700 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2702 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, 0);
2709 else if (LOOKING_AT ('{'))
2712 if (sc
== SC_TYPE
&& id
&& cls
)
2714 regexp
= matching_regexp ();
2715 pos
= BUFFER_POS ();
2719 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2720 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, sc
, 0);
2732 /* Parse the body of class CLS. TAG is the tag of the class (struct,
2736 class_body (cls
, tag
)
2740 int vis
= tag
== CLASS
? PRIVATE
: PUBLIC
;
2743 while (!LOOKING_AT2 (YYEOF
, '}'))
2747 case PRIVATE
: case PROTECTED
: case PUBLIC
:
2751 if (LOOKING_AT (':'))
2758 /* Probably conditional compilation for inheritance list.
2759 We don't known whether there comes more of this.
2760 This is only a crude fix that works most of the time. */
2765 while (LOOKING_AT2 (IDENT
, ',')
2766 || LOOKING_AT3 (PUBLIC
, PROTECTED
, PRIVATE
));
2775 /* Try to synchronize */
2776 case CHAR
: case CLASS
: case CONST
:
2777 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2778 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2779 case UNION
: case UNSIGNED
: case VOID
: case VOLATILE
:
2780 case TYPEDEF
: case STATIC
: case T_INLINE
: case FRIEND
:
2781 case VIRTUAL
: case TEMPLATE
: case IDENT
: case '~':
2782 case BOOL
: case WCHAR
: case EXPLICIT
: case MUTABLE
:
2794 /* Parse a qualified identifier. Current lookahead is IDENT. A
2795 qualified ident has the form `X<..>::Y<...>::T<...>. Returns a
2796 symbol for that class. */
2801 struct sym
*last_class
= NULL
;
2803 while (LOOKING_AT (IDENT
))
2805 last_class
= add_sym (yytext
, last_class
);
2808 if (LOOKING_AT ('<'))
2811 SET_FLAG (last_class
->flags
, F_TEMPLATE
);
2814 if (!LOOKING_AT (DCOLON
))
2824 /* Parse an operator name. Add the `static' flag to *SC if an
2825 implicitly static operator has been parsed. Value is a pointer to
2826 a static buffer holding the constructed operator name string. */
2832 static int id_size
= 0;
2833 static char *id
= NULL
;
2839 if (LOOKING_AT2 (NEW
, DELETE
))
2841 /* `new' and `delete' are implicitly static. */
2842 if (*sc
!= SC_FRIEND
)
2845 s
= token_string (LA1
);
2848 len
= strlen (s
) + 10;
2851 int new_size
= max (len
, 2 * id_size
);
2852 id
= (char *) xrealloc (id
, new_size
);
2857 /* Vector new or delete? */
2858 if (LOOKING_AT ('['))
2863 if (LOOKING_AT (']'))
2872 int tokens_matched
= 0;
2877 int new_size
= max (len
, 2 * id_size
);
2878 id
= (char *) xrealloc (id
, new_size
);
2881 strcpy (id
, "operator");
2883 /* Beware access declarations of the form "X::f;" Beware of
2884 `operator () ()'. Yet another difficulty is found in
2885 GCC 2.95's STL: `operator == __STL_NULL_TMPL_ARGS (...'. */
2886 while (!(LOOKING_AT ('(') && tokens_matched
)
2887 && !LOOKING_AT2 (';', YYEOF
))
2889 s
= token_string (LA1
);
2890 len
+= strlen (s
) + 2;
2893 int new_size
= max (len
, 2 * id_size
);
2894 id
= (char *) xrealloc (id
, new_size
);
2898 if (*s
!= ')' && *s
!= ']')
2903 /* If this is a simple operator like `+', stop now. */
2904 if (!isalpha ((unsigned char) *s
) && *s
!= '(' && *s
!= '[')
2915 /* This one consumes the last IDENT of a qualified member name like
2916 `X::Y::z'. This IDENT is returned in LAST_ID. Value if the
2917 symbol structure for the ident. */
2920 parse_qualified_ident_or_type (last_id
)
2923 struct sym
*cls
= NULL
;
2927 while (LOOKING_AT (IDENT
))
2929 int len
= strlen (yytext
) + 1;
2932 id
= (char *) xrealloc (id
, len
);
2935 strcpy (id
, yytext
);
2939 SKIP_MATCHING_IF ('<');
2941 if (LOOKING_AT (DCOLON
))
2943 cls
= add_sym (id
, cls
);
2958 /* This one consumes the last IDENT of a qualified member name like
2959 `X::Y::z'. This IDENT is returned in LAST_ID. Value if the
2960 symbol structure for the ident. */
2963 parse_qualified_param_ident_or_type (last_id
)
2966 struct sym
*cls
= NULL
;
2967 static char *id
= NULL
;
2968 static int id_size
= 0;
2970 while (LOOKING_AT (IDENT
))
2972 int len
= strlen (yytext
) + 1;
2975 id
= (char *) xrealloc (id
, len
);
2978 strcpy (id
, yytext
);
2982 SKIP_MATCHING_IF ('<');
2984 if (LOOKING_AT (DCOLON
))
2986 cls
= add_sym (id
, cls
);
2996 /* Parse a class definition.
2998 CONTAINING is the class containing the class being parsed or null.
2999 This may also be null if NESTED != 0 if the containing class is
3000 anonymous. TAG is the tag of the class (struct, union, class).
3001 NESTED is non-zero if we are parsing a nested class.
3003 Current lookahead is the class name. */
3006 class_definition (containing
, tag
, flags
, nested
)
3007 struct sym
*containing
;
3012 struct sym
*current
;
3013 struct sym
*base_class
;
3015 /* Set CURRENT to null if no entry has to be made for the class
3016 parsed. This is the case for certain command line flag
3018 if ((tag
!= CLASS
&& !f_structs
) || (nested
&& !f_nested_classes
))
3022 current
= add_sym (yytext
, containing
);
3023 current
->pos
= BUFFER_POS ();
3024 current
->regexp
= matching_regexp ();
3025 current
->filename
= filename
;
3026 current
->flags
= flags
;
3029 /* If at ':', base class list follows. */
3030 if (LOOKING_AT (':'))
3039 case VIRTUAL
: case PUBLIC
: case PROTECTED
: case PRIVATE
:
3044 base_class
= parse_classname ();
3045 if (base_class
&& current
&& base_class
!= current
)
3046 add_link (base_class
, current
);
3049 /* The `,' between base classes or the end of the base
3050 class list. Add the previously found base class.
3051 It's done this way to skip over sequences of
3052 `A::B::C' until we reach the end.
3054 FIXME: it is now possible to handle `class X : public B::X'
3055 because we have enough information. */
3061 /* A syntax error, possibly due to preprocessor constructs
3067 class A : private B.
3069 MATCH until we see something like `;' or `{'. */
3070 while (!LOOKING_AT3 (';', YYEOF
, '{'))
3081 /* Parse the class body if there is one. */
3082 if (LOOKING_AT ('{'))
3084 if (tag
!= CLASS
&& !f_structs
)
3089 class_body (current
, tag
);
3091 if (LOOKING_AT ('}'))
3094 if (LOOKING_AT (';') && !nested
)
3102 /* Parse a declaration. */
3109 struct sym
*cls
= NULL
;
3110 char *regexp
= NULL
;
3116 while (!LOOKING_AT3 (';', '{', YYEOF
))
3139 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
3140 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
3141 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
3145 case CLASS
: case STRUCT
: case UNION
:
3146 /* This is for the case `STARTWRAP class X : ...' or
3147 `declare (X, Y)\n class A : ...'. */
3155 /* Assumed to be the start of an initialization in this context.
3156 Skip over everything up to ';'. */
3162 char *s
= operator_name (&sc
);
3163 id
= (char *) xrealloc (id
, strlen (s
) + 1);
3169 SET_FLAG (flags
, F_INLINE
);
3175 if (LOOKING_AT (IDENT
))
3177 id
= (char *) xrealloc (id
, strlen (yytext
) + 2);
3179 strcpy (id
+ 1, yytext
);
3185 cls
= parse_qualified_ident_or_type (&id
);
3189 /* Most probably the beginning of a parameter list. */
3196 if (!(is_constructor
= streq (id
, cls
->name
)))
3197 regexp
= matching_regexp ();
3202 pos
= BUFFER_POS ();
3203 hash
= parm_list (&flags
);
3206 regexp
= matching_regexp ();
3209 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0,
3214 /* This may be a C functions, but also a macro
3215 call of the form `declare (A, B)' --- such macros
3216 can be found in some class libraries. */
3221 regexp
= matching_regexp ();
3222 pos
= BUFFER_POS ();
3223 hash
= parm_list (&flags
);
3224 add_global_decl (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3227 /* This is for the case that the function really is
3228 a macro with no `;' following it. If a CLASS directly
3229 follows, we would miss it otherwise. */
3230 if (LOOKING_AT3 (CLASS
, STRUCT
, UNION
))
3234 while (!LOOKING_AT3 (';', '{', YYEOF
))
3237 if (!cls
&& id
&& LOOKING_AT ('{'))
3238 add_global_defn (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3246 if (LOOKING_AT (';'))
3248 /* The end of a member variable or of an access declaration
3249 `X::f'. To distinguish between them we have to know whether
3250 type information has been seen. */
3253 char *regexp
= matching_regexp ();
3254 int pos
= BUFFER_POS ();
3257 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, SC_UNKNOWN
, flags
);
3259 add_global_defn (id
, regexp
, pos
, 0, 1, sc
, flags
);
3265 else if (LOOKING_AT ('{'))
3267 if (sc
== SC_TYPE
&& id
)
3269 /* A named enumeration. */
3270 regexp
= matching_regexp ();
3271 pos
= BUFFER_POS ();
3272 add_global_defn (id
, regexp
, pos
, 0, 1, sc
, flags
);
3283 /* Parse a list of top-level declarations/definitions. START_FLAGS
3284 says in which context we are parsing. If it is F_EXTERNC, we are
3285 parsing in an `extern "C"' block. Value is 1 if EOF is reached, 0
3289 globals (start_flags
)
3294 int flags
= start_flags
;
3306 if (LOOKING_AT (IDENT
))
3308 char *namespace_name
= xstrdup (yytext
);
3311 if (LOOKING_AT ('='))
3314 if (LOOKING_AT (IDENT
))
3315 register_namespace_alias (namespace_name
, yytext
);
3317 if (skip_to (';') == ';')
3320 else if (LOOKING_AT ('{'))
3323 enter_namespace (namespace_name
);
3329 xfree (namespace_name
);
3336 if (LOOKING_AT (CSTRING
) && *string_start
== 'C'
3337 && *(string_start
+ 1) == '"')
3339 /* This is `extern "C"'. */
3342 if (LOOKING_AT ('{'))
3345 globals (F_EXTERNC
);
3349 SET_FLAG (flags
, F_EXTERNC
);
3355 SKIP_MATCHING_IF ('<');
3356 SET_FLAG (flags
, F_TEMPLATE
);
3359 case CLASS
: case STRUCT
: case UNION
:
3364 /* More than one ident here to allow for MS-DOS and OS/2
3365 specialties like `far', `_Export' etc. Some C++ libs
3366 have constructs like `_OS_DLLIMPORT(_OS_CLIENT)' in front
3367 of the class name. */
3368 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
3370 if (LOOKING_AT (IDENT
))
3375 /* Don't add anonymous unions. */
3376 if (LOOKING_AT2 (':', '{') && !anonymous
)
3377 class_definition (NULL
, class_tk
, flags
, 0);
3380 if (skip_to (';') == ';')
3384 flags
= start_flags
;
3394 declaration (flags
);
3395 flags
= start_flags
;
3400 yyerror ("parse error", NULL
);
3405 /* Parse the current input file. */
3410 while (globals (0) == 0)
3416 /***********************************************************************
3418 ***********************************************************************/
3420 /* Add the list of paths PATH_LIST to the current search path for
3424 add_search_path (path_list
)
3429 char *start
= path_list
;
3430 struct search_path
*p
;
3432 while (*path_list
&& *path_list
!= PATH_LIST_SEPARATOR
)
3435 p
= (struct search_path
*) xmalloc (sizeof *p
);
3436 p
->path
= (char *) xmalloc (path_list
- start
+ 1);
3437 memcpy (p
->path
, start
, path_list
- start
);
3438 p
->path
[path_list
- start
] = '\0';
3441 if (search_path_tail
)
3443 search_path_tail
->next
= p
;
3444 search_path_tail
= p
;
3447 search_path
= search_path_tail
= p
;
3449 while (*path_list
== PATH_LIST_SEPARATOR
)
3455 /* Open FILE and return a file handle for it, or -1 if FILE cannot be
3456 opened. Try to find FILE in search_path first, then try the
3457 unchanged file name. */
3464 static char *buffer
;
3465 static int buffer_size
;
3466 struct search_path
*path
;
3467 int flen
= strlen (file
) + 1; /* +1 for the slash */
3469 filename
= xstrdup (file
);
3471 for (path
= search_path
; path
&& fp
== NULL
; path
= path
->next
)
3473 int len
= strlen (path
->path
) + flen
;
3475 if (len
+ 1 >= buffer_size
)
3477 buffer_size
= max (len
+ 1, 2 * buffer_size
);
3478 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3481 strcpy (buffer
, path
->path
);
3482 strcat (buffer
, "/");
3483 strcat (buffer
, file
);
3484 fp
= fopen (buffer
, "r");
3487 /* Try the original file name. */
3489 fp
= fopen (file
, "r");
3492 yyerror ("cannot open", NULL
);
3498 /* Display usage information and exit program. */
3501 Usage: ebrowse [options] {files}\n\
3503 -a, --append append output to existing file\n\
3504 -f, --files=FILES read input file names from FILE\n\
3505 -I, --search-path=LIST set search path for input files\n\
3506 -m, --min-regexp-length=N set minimum regexp length to N\n\
3507 -M, --max-regexp-length=N set maximum regexp length to N\n\
3508 -n, --no-nested-classes exclude nested classes\n\
3509 -o, --output-file=FILE set output file name to FILE\n\
3510 -p, --position-info print info about position in file\n\
3511 -s, --no-structs-or-unions don't record structs or unions\n\
3512 -v, --verbose be verbose\n\
3513 -V, --very-verbose be very verbose\n\
3514 -x, --no-regexps don't record regular expressions\n\
3515 --help display this help\n\
3516 --version display version info\n\
3524 exit (error
? 1 : 0);
3528 /* Display version and copyright info. The VERSION macro is set
3529 from the Makefile and contains the Emacs version. */
3532 # define VERSION "21"
3538 printf ("ebrowse %s\n", VERSION
);
3539 puts ("Copyright (C) 1992-1999, 2000 Free Software Foundation, Inc.");
3540 puts ("This program is distributed under the same terms as Emacs.");
3545 /* Parse one input file FILE, adding classes and members to the symbol
3554 fp
= open_file (file
);
3559 /* Give a progress indication if needed. */
3571 /* Read file to inbuffer. */
3574 if (nread
+ READ_CHUNK_SIZE
>= inbuffer_size
)
3576 inbuffer_size
= nread
+ READ_CHUNK_SIZE
+ 1;
3577 inbuffer
= (char *) xrealloc (inbuffer
, inbuffer_size
);
3580 nbytes
= fread (inbuffer
+ nread
, 1, READ_CHUNK_SIZE
, fp
);
3587 inbuffer
[nread
] = '\0';
3589 /* Reinitialize scanner and parser for the new input file. */
3593 /* Parse it and close the file. */
3600 /* Read a line from stream FP and return a pointer to a static buffer
3601 containing its contents without the terminating newline. Value
3602 is null when EOF is reached. */
3608 static char *buffer
;
3609 static int buffer_size
;
3612 while ((c
= getc (fp
)) != EOF
&& c
!= '\n')
3614 if (i
>= buffer_size
)
3616 buffer_size
= max (100, buffer_size
* 2);
3617 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3623 if (c
== EOF
&& i
== 0)
3626 if (i
== buffer_size
)
3628 buffer_size
= max (100, buffer_size
* 2);
3629 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3633 if (i
> 0 && buffer
[i
- 1] == '\r')
3634 buffer
[i
- 1] = '\0';
3639 /* Main entry point. */
3647 int any_inputfiles
= 0;
3648 static char *out_filename
= DEFAULT_OUTFILE
;
3649 static char **input_filenames
= NULL
;
3650 static int input_filenames_size
= 0;
3651 static int n_input_files
;
3653 filename
= "command line";
3656 while ((i
= getopt_long (argc
, argv
, "af:I:m:M:no:p:svVx",
3657 options
, NULL
)) != EOF
)
3663 info_position
= atoi (optarg
);
3667 f_nested_classes
= 0;
3674 /* Add the name of a file containing more input files. */
3676 if (n_input_files
== input_filenames_size
)
3678 input_filenames_size
= max (10, 2 * input_filenames_size
);
3679 input_filenames
= (char **) xrealloc ((void *)input_filenames
,
3680 input_filenames_size
);
3682 input_filenames
[n_input_files
++] = xstrdup (optarg
);
3685 /* Append new output to output file instead of truncating it. */
3690 /* Include structs in the output */
3695 /* Be verbose (give a progress indication). */
3700 /* Be very verbose (print file names as they are processed). */
3706 /* Change the name of the output file. */
3708 out_filename
= optarg
;
3711 /* Set minimum length for regular expression strings
3712 when recorded in the output file. */
3714 min_regexp
= atoi (optarg
);
3717 /* Set maximum length for regular expression strings
3718 when recorded in the output file. */
3720 max_regexp
= atoi (optarg
);
3723 /* Add to search path. */
3725 add_search_path (optarg
);
3739 /* Call init_scanner after command line flags have been processed to be
3740 able to add keywords depending on command line (not yet
3745 /* Open output file */
3750 /* Check that the file to append to exists, and is not
3751 empty. More specifically, it should be a valid file
3752 produced by a previous run of ebrowse, but that's too
3753 difficult to check. */
3757 fp
= fopen (out_filename
, "r");
3759 yyerror ("file `%s' must exist for --append", out_filename
);
3761 rc
= fseek (fp
, 0, SEEK_END
);
3763 yyerror ("error seeking in file `%s'", out_filename
);
3767 yyerror ("error getting size of file `%s'", out_filename
);
3769 yyerror ("file `%s' is empty", out_filename
);
3774 yyout
= fopen (out_filename
, f_append
? "a" : "w");
3777 yyerror ("cannot open output file `%s'", out_filename
);
3782 /* Process input files specified on the command line. */
3783 while (optind
< argc
)
3785 process_file (argv
[optind
++]);
3789 /* Process files given on stdin if no files specified. */
3790 if (!any_inputfiles
&& n_input_files
== 0)
3793 while ((file
= read_line (stdin
)) != NULL
)
3794 process_file (file
);
3798 /* Process files from `--files=FILE'. Every line in FILE names
3799 one input file to process. */
3800 for (i
= 0; i
< n_input_files
; ++i
)
3802 FILE *fp
= fopen (input_filenames
[i
], "r");
3805 yyerror ("cannot open input file `%s'", input_filenames
[i
]);
3809 while ((file
= read_line (fp
)) != NULL
)
3810 process_file (file
);
3816 /* Write output file. */
3819 /* Close output file. */
3820 if (yyout
!= stdout
)
3827 /* ebrowse.c ends here. */