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));
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");
546 /* Like realloc but print an error and exit if out of memory. */
556 yyerror ("out of memory");
563 /* Like strdup, but print an error and exit if not enough memory is
564 available.. If S is null, return null. */
571 s
= strcpy (xmalloc (strlen (s
) + 1), s
);
577 /***********************************************************************
579 ***********************************************************************/
581 /* Initialize the symbol table. This currently only sets up the
582 special symbol for globals (`*Globals*'). */
587 global_symbols
= add_sym (GLOBALS_NAME
, NULL
);
591 /* Add a symbol for class NAME to the symbol table. NESTED_IN_CLASS
592 is the class in which class NAME was found. If it is null,
593 this means the scope of NAME is the current namespace.
595 If a symbol for NAME already exists, return that. Otherwise
596 create a new symbol and set it to default values. */
599 add_sym (name
, nested_in_class
)
601 struct sym
*nested_in_class
;
606 struct sym
*scope
= nested_in_class
? nested_in_class
: current_namespace
;
608 for (s
= name
, h
= 0; *s
; ++s
)
612 for (sym
= class_table
[h
]; sym
; sym
= sym
->next
)
613 if (streq (name
, sym
->name
) && sym
->namesp
== scope
)
624 sym
= (struct sym
*) xmalloc (sizeof *sym
+ strlen (name
));
625 bzero (sym
, sizeof *sym
);
626 strcpy (sym
->name
, name
);
628 sym
->next
= class_table
[h
];
629 class_table
[h
] = sym
;
636 /* Add links between superclass SUPER and subclass SUB. */
639 add_link (super
, sub
)
640 struct sym
*super
, *sub
;
642 struct link
*lnk
, *lnk2
, *p
, *prev
;
644 /* See if a link already exists. */
645 for (p
= super
->subs
, prev
= NULL
;
646 p
&& strcmp (sub
->name
, p
->sym
->name
) > 0;
647 prev
= p
, p
= p
->next
)
650 /* Avoid duplicates. */
651 if (p
== NULL
|| p
->sym
!= sub
)
653 lnk
= (struct link
*) xmalloc (sizeof *lnk
);
654 lnk2
= (struct link
*) xmalloc (sizeof *lnk2
);
665 lnk2
->next
= sub
->supers
;
671 /* Find in class CLS member NAME.
673 VAR non-zero means look for a member variable; otherwise a function
674 is searched. SC specifies what kind of member is searched---a
675 static, or per-instance member etc. HASH is a hash code for the
676 parameter types of functions. Value is a pointer to the member
677 found or null if not found. */
680 find_member (cls
, name
, var
, sc
, hash
)
686 struct member
**list
;
688 unsigned name_hash
= 0;
695 list
= &cls
->friends
;
703 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
707 list
= var
? &cls
->vars
: &cls
->fns
;
711 for (s
= name
; *s
; ++s
)
712 name_hash
= (name_hash
<< 1) ^ *s
;
713 i
= name_hash
% TABLE_SIZE
;
715 for (p
= member_table
[i
]; p
; p
= p
->anext
)
716 if (p
->list
== list
&& p
->param_hash
== hash
&& streq (name
, p
->name
))
723 /* Add to class CLS information for the declaration of member NAME.
724 REGEXP is a regexp matching the declaration, if non-null. POS is
725 the position in the source where the declaration is found. HASH is
726 a hash code for the parameter list of the member, if it's a
727 function. VAR non-zero means member is a variable or type. SC
728 specifies the type of member (instance member, static, ...). VIS
729 is the member's visibility (public, protected, private). FLAGS is
730 a bit set giving additional information about the member (see the
734 add_member_decl (cls
, name
, regexp
, pos
, hash
, var
, sc
, vis
, flags
)
747 m
= find_member (cls
, name
, var
, sc
, hash
);
749 m
= add_member (cls
, name
, var
, sc
, hash
);
751 /* Have we seen a new filename? If so record that. */
752 if (!cls
->filename
|| !streq (cls
->filename
, filename
))
753 m
->filename
= filename
;
766 m
->vis
= V_PROTECTED
;
780 /* Add to class CLS information for the definition of member NAME.
781 REGEXP is a regexp matching the declaration, if non-null. POS is
782 the position in the source where the declaration is found. HASH is
783 a hash code for the parameter list of the member, if it's a
784 function. VAR non-zero means member is a variable or type. SC
785 specifies the type of member (instance member, static, ...). VIS
786 is the member's visibility (public, protected, private). FLAGS is
787 a bit set giving additional information about the member (see the
791 add_member_defn (cls
, name
, regexp
, pos
, hash
, var
, sc
, flags
)
803 if (sc
== SC_UNKNOWN
)
805 m
= find_member (cls
, name
, var
, SC_MEMBER
, hash
);
808 m
= find_member (cls
, name
, var
, SC_STATIC
, hash
);
810 m
= add_member (cls
, name
, var
, sc
, hash
);
815 m
= find_member (cls
, name
, var
, sc
, hash
);
817 m
= add_member (cls
, name
, var
, sc
, hash
);
821 cls
->sfilename
= filename
;
823 if (!streq (cls
->sfilename
, filename
))
824 m
->def_filename
= filename
;
826 m
->def_regexp
= regexp
;
836 /* Add a symbol for a define named NAME to the symbol table.
837 REGEXP is a regular expression matching the define in the source,
838 if it is non-null. POS is the position in the file. */
841 add_define (name
, regexp
, pos
)
845 add_global_defn (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
846 add_global_decl (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
850 /* Add information for the global definition of NAME.
851 REGEXP is a regexp matching the declaration, if non-null. POS is
852 the position in the source where the declaration is found. HASH is
853 a hash code for the parameter list of the member, if it's a
854 function. VAR non-zero means member is a variable or type. SC
855 specifies the type of member (instance member, static, ...). VIS
856 is the member's visibility (public, protected, private). FLAGS is
857 a bit set giving additional information about the member (see the
861 add_global_defn (name
, regexp
, pos
, hash
, var
, sc
, flags
)
872 /* Try to find out for which classes a function is a friend, and add
873 what we know about it to them. */
875 for (i
= 0; i
< TABLE_SIZE
; ++i
)
876 for (sym
= class_table
[i
]; sym
; sym
= sym
->next
)
877 if (sym
!= global_symbols
&& sym
->friends
)
878 if (find_member (sym
, name
, 0, SC_FRIEND
, hash
))
879 add_member_defn (sym
, name
, regexp
, pos
, hash
, 0,
882 /* Add to global symbols. */
883 add_member_defn (global_symbols
, name
, regexp
, pos
, hash
, var
, sc
, flags
);
887 /* Add information for the global declaration of NAME.
888 REGEXP is a regexp matching the declaration, if non-null. POS is
889 the position in the source where the declaration is found. HASH is
890 a hash code for the parameter list of the member, if it's a
891 function. VAR non-zero means member is a variable or type. SC
892 specifies the type of member (instance member, static, ...). VIS
893 is the member's visibility (public, protected, private). FLAGS is
894 a bit set giving additional information about the member (see the
898 add_global_decl (name
, regexp
, pos
, hash
, var
, sc
, flags
)
906 /* Add declaration only if not already declared. Header files must
907 be processed before source files for this to have the right effect.
908 I do not want to handle implicit declarations at the moment. */
910 struct member
*found
;
912 m
= found
= find_member (global_symbols
, name
, var
, sc
, hash
);
914 m
= add_member (global_symbols
, name
, var
, sc
, hash
);
916 /* Definition already seen => probably last declaration implicit.
917 Override. This means that declarations must always be added to
918 the symbol table before definitions. */
921 if (!global_symbols
->filename
922 || !streq (global_symbols
->filename
, filename
))
923 m
->filename
= filename
;
931 info_cls
= global_symbols
;
937 /* Add a symbol for member NAME to class CLS.
938 VAR non-zero means it's a variable. SC specifies the kind of
939 member. HASH is a hash code for the parameter types of a function.
940 Value is a pointer to the member's structure. */
943 add_member (cls
, name
, var
, sc
, hash
)
950 struct member
*m
= (struct member
*) xmalloc (sizeof *m
+ strlen (name
));
951 struct member
**list
;
954 unsigned name_hash
= 0;
958 strcpy (m
->name
, name
);
959 m
->param_hash
= hash
;
966 m
->def_regexp
= NULL
;
967 m
->def_filename
= NULL
;
970 assert (cls
!= NULL
);
975 list
= &cls
->friends
;
983 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
987 list
= var
? &cls
->vars
: &cls
->fns
;
991 for (s
= name
; *s
; ++s
)
992 name_hash
= (name_hash
<< 1) ^ *s
;
993 i
= name_hash
% TABLE_SIZE
;
994 m
->anext
= member_table
[i
];
998 /* Keep the member list sorted. It's cheaper to do it here than to
999 sort them in Lisp. */
1000 for (prev
= NULL
, p
= *list
;
1001 p
&& strcmp (name
, p
->name
) > 0;
1002 prev
= p
, p
= p
->next
)
1014 /* Given the root R of a class tree, step through all subclasses
1015 recursively, marking functions as virtual that are declared virtual
1023 struct member
*m
, *m2
;
1025 for (p
= r
->subs
; p
; p
= p
->next
)
1027 for (m
= r
->fns
; m
; m
= m
->next
)
1028 if (HAS_FLAG (m
->flags
, F_VIRTUAL
))
1030 for (m2
= p
->sym
->fns
; m2
; m2
= m2
->next
)
1031 if (m
->param_hash
== m2
->param_hash
&& streq (m
->name
, m2
->name
))
1032 SET_FLAG (m2
->flags
, F_VIRTUAL
);
1035 mark_virtual (p
->sym
);
1040 /* For all roots of the class tree, mark functions as virtual that
1041 are virtual because of a virtual declaration in a base class. */
1044 mark_inherited_virtual ()
1049 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1050 for (r
= class_table
[i
]; r
; r
= r
->next
)
1051 if (r
->supers
== NULL
)
1056 /* Create and return a symbol for a namespace with name NAME. */
1059 make_namespace (name
)
1062 struct sym
*s
= (struct sym
*) xmalloc (sizeof *s
+ strlen (name
));
1063 bzero (s
, sizeof *s
);
1064 strcpy (s
->name
, name
);
1065 s
->next
= all_namespaces
;
1066 s
->namesp
= current_namespace
;
1072 /* Find the symbol for namespace NAME. If not found, add a new symbol
1073 for NAME to all_namespaces. */
1076 find_namespace (name
)
1081 for (p
= all_namespaces
; p
; p
= p
->next
)
1083 if (streq (p
->name
, name
))
1088 for (p2
= p
->namesp_aliases
; p2
; p2
= p2
->next
)
1089 if (streq (p2
->name
, name
))
1097 p
= make_namespace (name
);
1103 /* Register the name NEW_NAME as an alias for namespace OLD_NAME. */
1106 register_namespace_alias (new_name
, old_name
)
1107 char *new_name
, *old_name
;
1109 struct sym
*p
= find_namespace (old_name
);
1112 /* Is it already in the list of aliases? */
1113 for (al
= p
->namesp_aliases
; al
; al
= al
->next
)
1114 if (streq (new_name
, p
->name
))
1117 al
= (struct alias
*) xmalloc (sizeof *al
+ strlen (new_name
));
1118 strcpy (al
->name
, new_name
);
1119 al
->next
= p
->namesp_aliases
;
1120 p
->namesp_aliases
= al
;
1124 /* Enter namespace with name NAME. */
1127 enter_namespace (name
)
1130 struct sym
*p
= find_namespace (name
);
1132 if (namespace_sp
== namespace_stack_size
)
1134 int size
= max (10, 2 * namespace_stack_size
);
1135 namespace_stack
= (struct sym
**) xrealloc (namespace_stack
, size
);
1136 namespace_stack_size
= size
;
1139 namespace_stack
[namespace_sp
++] = current_namespace
;
1140 current_namespace
= p
;
1144 /* Leave the current namespace. */
1149 assert (namespace_sp
> 0);
1150 current_namespace
= namespace_stack
[--namespace_sp
];
1155 /***********************************************************************
1156 Writing the Output File
1157 ***********************************************************************/
1159 /* Write string S to the output file FP in a Lisp-readable form.
1160 If S is null, write out `()'. */
1162 #define PUTSTR(s, fp) \
1179 /* A dynamically allocated buffer for constructing a scope name. */
1182 int scope_buffer_size
;
1183 int scope_buffer_len
;
1186 /* Make sure scope_buffer has enough room to add LEN chars to it. */
1189 ensure_scope_buffer_room (len
)
1192 if (scope_buffer_len
+ len
>= scope_buffer_size
)
1194 int new_size
= max (2 * scope_buffer_size
, scope_buffer_len
+ len
);
1195 scope_buffer
= (char *) xrealloc (new_size
);
1196 scope_buffer_size
= new_size
;
1201 /* Recursively add the scope names of symbol P and the scopes of its
1202 namespaces to scope_buffer. Value is a pointer to the complete
1203 scope name constructed. */
1212 sym_scope_1 (p
->namesp
);
1216 ensure_scope_buffer_room (3);
1217 strcat (scope_buffer
, "::");
1218 scope_buffer_len
+= 2;
1221 len
= strlen (p
->name
);
1222 ensure_scope_buffer_room (len
+ 1);
1223 strcat (scope_buffer
, p
->name
);
1224 scope_buffer_len
+= len
;
1226 if (HAS_FLAG (p
->flags
, F_TEMPLATE
))
1228 ensure_scope_buffer_room (3);
1229 strcat (scope_buffer
, "<>");
1230 scope_buffer_len
+= 2;
1233 return scope_buffer
;
1237 /* Return the scope of symbol P in printed representation, i.e.
1238 as it would appear in a C*+ source file. */
1246 scope_buffer_size
= 1024;
1247 scope_buffer
= (char *) xmalloc (scope_buffer_size
);
1250 *scope_buffer
= '\0';
1251 scope_buffer_len
= 0;
1254 sym_scope_1 (p
->namesp
);
1256 return scope_buffer
;
1260 /* Dump the list of members M to file FP. Value is the length of the
1264 dump_members (fp
, m
)
1272 for (n
= 0; m
; m
= m
->next
, ++n
)
1274 fputs (MEMBER_STRUCT
, fp
);
1275 PUTSTR (m
->name
, fp
);
1276 PUTSTR (NULL
, fp
); /* FIXME? scope for globals */
1277 fprintf (fp
, "%u ", (unsigned) m
->flags
);
1278 PUTSTR (m
->filename
, fp
);
1279 PUTSTR (m
->regexp
, fp
);
1280 fprintf (fp
, "%u ", (unsigned) m
->pos
);
1281 fprintf (fp
, "%u ", (unsigned) m
->vis
);
1283 PUTSTR (m
->def_filename
, fp
);
1284 PUTSTR (m
->def_regexp
, fp
);
1285 fprintf (fp
, "%u", (unsigned) m
->def_pos
);
1296 /* Dump class ROOT to stream FP. */
1303 fputs (CLASS_STRUCT
, fp
);
1304 PUTSTR (root
->name
, fp
);
1306 /* Print scope, if any. */
1308 PUTSTR (sym_scope (root
), fp
);
1313 fprintf (fp
, "%u", root
->flags
);
1314 PUTSTR (root
->filename
, fp
);
1315 PUTSTR (root
->regexp
, fp
);
1316 fprintf (fp
, "%u", (unsigned) root
->pos
);
1317 PUTSTR (root
->sfilename
, fp
);
1323 /* Dump class ROOT and its subclasses to file FP. Value is the
1324 number of classes written. */
1327 dump_tree (fp
, root
)
1334 dump_sym (fp
, root
);
1344 for (lk
= root
->subs
; lk
; lk
= lk
->next
)
1346 fputs (TREE_STRUCT
, fp
);
1347 n
+= dump_tree (fp
, lk
->sym
);
1353 dump_members (fp
, root
->vars
);
1354 n
+= dump_members (fp
, root
->fns
);
1355 dump_members (fp
, root
->static_vars
);
1356 n
+= dump_members (fp
, root
->static_fns
);
1357 n
+= dump_members (fp
, root
->friends
);
1358 dump_members (fp
, root
->types
);
1373 /* Dump the entire class tree to file FP. */
1382 /* Output file header containing version string, command line
1386 fputs (TREE_HEADER_STRUCT
, fp
);
1387 PUTSTR (EBROWSE_FILE_VERSION
, fp
);
1400 /* Mark functions as virtual that are so because of functions
1401 declared virtual in base classes. */
1402 mark_inherited_virtual ();
1404 /* Dump the roots of the graph. */
1405 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1406 for (r
= class_table
[i
]; r
; r
= r
->next
)
1409 fputs (TREE_STRUCT
, fp
);
1410 n
+= dump_tree (fp
, r
);
1420 /***********************************************************************
1422 ***********************************************************************/
1425 #define INCREMENT_LINENO \
1427 if (f_very_verbose) \
1430 printf ("%d:\n", yyline); \
1436 #define INCREMENT_LINENO ++yyline
1439 /* Define two macros for accessing the input buffer (current input
1440 file). GET(C) sets C to the next input character and advances the
1441 input pointer. UNGET retracts the input pointer. */
1443 #define GET(C) ((C) = *in++)
1444 #define UNGET() (--in)
1447 /* Process a preprocessor line. Value is the next character from the
1448 input buffer not consumed. */
1457 /* Skip over white space. The `#' has been consumed already. */
1458 while (WHITEP (GET (c
)))
1461 /* Read the preprocessor command (if any). */
1468 /* Is it a `define'? */
1471 if (*yytext
&& streq (yytext
, "define"))
1486 char *regexp
= matching_regexp ();
1487 int pos
= BUFFER_POS ();
1488 add_define (yytext
, regexp
, pos
);
1492 while (c
&& (c
!= '\n' || in_comment
))
1496 else if (c
== '/' && !in_comment
)
1501 else if (c
== '*' && in_comment
)
1517 /* Value is the next token from the input buffer. */
1528 while (WHITEP (GET (c
)))
1550 /* String and character constants. */
1553 while (GET (c
) && c
!= end_char
)
1558 /* Escape sequences. */
1561 if (end_char
== '\'')
1562 yyerror ("EOF in character constant");
1564 yyerror ("EOF in string constant");
1581 /* Hexadecimal escape sequence. */
1583 for (i
= 0; i
< 2; ++i
)
1587 if (c
>= '0' && c
<= '7')
1589 else if (c
>= 'a' && c
<= 'f')
1591 else if (c
>= 'A' && c
<= 'F')
1604 /* Octal escape sequence. */
1606 for (i
= 0; i
< 3; ++i
)
1610 if (c
>= '0' && c
<= '7')
1627 if (end_char
== '\'')
1628 yyerror ("newline in character constant");
1630 yyerror ("newline in string constant");
1640 return end_char
== '\'' ? CCHAR
: CSTRING
;
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':
1646 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
1647 case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
1648 case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
1649 case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_':
1651 /* Identifier and keywords. */
1658 while (IDENTP (GET (*p
)))
1660 hash
= (hash
<< 1) ^ *p
++;
1661 if (p
== yytext_end
- 1)
1663 int size
= yytext_end
- yytext
;
1664 yytext
= (char *) xrealloc (yytext
, 2 * size
);
1665 yytext_end
= yytext
+ 2 * size
;
1666 p
= yytext
+ size
- 1;
1673 for (k
= keyword_table
[hash
% KEYWORD_TABLE_SIZE
]; k
; k
= k
->next
)
1674 if (streq (k
->name
, yytext
))
1681 /* C and C++ comments, '/' and '/='. */
1709 while (GET (c
) && c
!= '\n')
1784 yyerror ("invalid token '..' ('...' assumed)");
1788 else if (!DIGITP (c
))
1842 c
= process_pp_line ();
1847 case '(': case ')': case '[': case ']': case '{': case '}':
1848 case ';': case ',': case '?': case '~':
1854 if (GET (c
) == 'x' || c
== 'X')
1859 yyival
= yyival
* 16 + c
- '0';
1860 else if (c
>= 'a' && c
<= 'f')
1861 yyival
= yyival
* 16 + c
- 'a' + 10;
1862 else if (c
>= 'A' && c
<= 'F')
1863 yyival
= yyival
* 16 + c
- 'A' + 10;
1873 while (c
>= '0' && c
<= '7')
1875 yyival
= (yyival
<< 3) + c
- '0';
1880 /* Integer suffixes. */
1886 case '1': case '2': case '3': case '4': case '5': case '6':
1887 case '7': case '8': case '9':
1888 /* Integer or floating constant, part before '.'. */
1891 while (GET (c
) && DIGITP (c
))
1892 yyival
= 10 * yyival
+ c
- '0';
1898 /* Digits following '.'. */
1902 /* Optional exponent. */
1903 if (c
== 'E' || c
== 'e')
1905 if (GET (c
) == '-' || c
== '+')
1912 /* Optional type suffixes. */
1925 /* Value is the string from the start of the line to the current
1926 position in the input buffer, or maybe a bit more if that string is
1927 shorter than min_regexp. */
1935 static char *buffer
, *end_buf
;
1942 buffer
= (char *) xmalloc (max_regexp
);
1943 end_buf
= &buffer
[max_regexp
] - 1;
1946 /* Scan back to previous newline of buffer start. */
1947 for (p
= in
- 1; p
> inbuffer
&& *p
!= '\n'; --p
)
1952 while (in
- p
< min_regexp
&& p
> inbuffer
)
1954 /* Line probably not significant enough */
1955 for (--p
; p
>= inbuffer
&& *p
!= '\n'; --p
)
1962 /* Copy from end to make sure significant portions are included.
1963 This implies that in the browser a regular expressing of the form
1964 `^.*{regexp}' has to be used. */
1965 for (s
= end_buf
- 1, t
= in
; s
> buffer
&& t
> p
;)
1973 *(end_buf
- 1) = '\0';
1978 /* Return a printable representation of token T. */
1988 case CSTRING
: return "string constant";
1989 case CCHAR
: return "char constant";
1990 case CINT
: return "int constant";
1991 case CFLOAT
: return "floating constant";
1992 case ELLIPSIS
: return "...";
1993 case LSHIFTASGN
: return "<<=";
1994 case RSHIFTASGN
: return ">>=";
1995 case ARROWSTAR
: return "->*";
1996 case IDENT
: return "identifier";
1997 case DIVASGN
: return "/=";
1998 case INC
: return "++";
1999 case ADDASGN
: return "+=";
2000 case DEC
: return "--";
2001 case ARROW
: return "->";
2002 case SUBASGN
: return "-=";
2003 case MULASGN
: return "*=";
2004 case MODASGN
: return "%=";
2005 case LOR
: return "||";
2006 case ORASGN
: return "|=";
2007 case LAND
: return "&&";
2008 case ANDASGN
: return "&=";
2009 case XORASGN
: return "^=";
2010 case POINTSTAR
: return ".*";
2011 case DCOLON
: return "::";
2012 case EQ
: return "==";
2013 case NE
: return "!=";
2014 case LE
: return "<=";
2015 case LSHIFT
: return "<<";
2016 case GE
: return ">=";
2017 case RSHIFT
: return ">>";
2018 case ASM
: return "asm";
2019 case AUTO
: return "auto";
2020 case BREAK
: return "break";
2021 case CASE
: return "case";
2022 case CATCH
: return "catch";
2023 case CHAR
: return "char";
2024 case CLASS
: return "class";
2025 case CONST
: return "const";
2026 case CONTINUE
: return "continue";
2027 case DEFAULT
: return "default";
2028 case DELETE
: return "delete";
2029 case DO
: return "do";
2030 case DOUBLE
: return "double";
2031 case ELSE
: return "else";
2032 case ENUM
: return "enum";
2033 case EXTERN
: return "extern";
2034 case FLOAT
: return "float";
2035 case FOR
: return "for";
2036 case FRIEND
: return "friend";
2037 case GOTO
: return "goto";
2038 case IF
: return "if";
2039 case T_INLINE
: return "inline";
2040 case INT
: return "int";
2041 case LONG
: return "long";
2042 case NEW
: return "new";
2043 case OPERATOR
: return "operator";
2044 case PRIVATE
: return "private";
2045 case PROTECTED
: return "protected";
2046 case PUBLIC
: return "public";
2047 case REGISTER
: return "register";
2048 case RETURN
: return "return";
2049 case SHORT
: return "short";
2050 case SIGNED
: return "signed";
2051 case SIZEOF
: return "sizeof";
2052 case STATIC
: return "static";
2053 case STRUCT
: return "struct";
2054 case SWITCH
: return "switch";
2055 case TEMPLATE
: return "template";
2056 case THIS
: return "this";
2057 case THROW
: return "throw";
2058 case TRY
: return "try";
2059 case TYPEDEF
: return "typedef";
2060 case UNION
: return "union";
2061 case UNSIGNED
: return "unsigned";
2062 case VIRTUAL
: return "virtual";
2063 case VOID
: return "void";
2064 case VOLATILE
: return "volatile";
2065 case WHILE
: return "while";
2066 case YYEOF
: return "EOF";
2076 /* Reinitialize the scanner for a new input file. */
2087 yytext
= (char *) xmalloc (size
* sizeof *yytext
);
2088 yytext_end
= yytext
+ size
;
2093 /* Insert a keyword NAME with token value TK into the keyword hash
2097 insert_keyword (name
, tk
)
2103 struct kw
*k
= (struct kw
*) xmalloc (sizeof *k
);
2105 for (s
= name
; *s
; ++s
)
2108 h
%= KEYWORD_TABLE_SIZE
;
2111 k
->next
= keyword_table
[h
];
2112 keyword_table
[h
] = k
;
2116 /* Initialize the scanner for the first file. This sets up the
2117 character class vectors and fills the keyword hash table. */
2124 /* Allocate the input buffer */
2125 inbuffer_size
= READ_CHUNK_SIZE
+ 1;
2126 inbuffer
= in
= (char *) xmalloc (inbuffer_size
);
2129 /* Set up character class vectors. */
2130 for (i
= 0; i
< sizeof is_ident
; ++i
)
2132 if (i
== '_' || isalnum (i
))
2135 if (i
>= '0' && i
<= '9')
2138 if (i
== ' ' || i
== '\t' || i
== '\f' || i
== '\v')
2142 /* Fill keyword hash table. */
2143 insert_keyword ("and", LAND
);
2144 insert_keyword ("and_eq", ANDASGN
);
2145 insert_keyword ("asm", ASM
);
2146 insert_keyword ("auto", AUTO
);
2147 insert_keyword ("bitand", '&');
2148 insert_keyword ("bitor", '|');
2149 insert_keyword ("bool", BOOL
);
2150 insert_keyword ("break", BREAK
);
2151 insert_keyword ("case", CASE
);
2152 insert_keyword ("catch", CATCH
);
2153 insert_keyword ("char", CHAR
);
2154 insert_keyword ("class", CLASS
);
2155 insert_keyword ("compl", '~');
2156 insert_keyword ("const", CONST
);
2157 insert_keyword ("const_cast", CONST_CAST
);
2158 insert_keyword ("continue", CONTINUE
);
2159 insert_keyword ("default", DEFAULT
);
2160 insert_keyword ("delete", DELETE
);
2161 insert_keyword ("do", DO
);
2162 insert_keyword ("double", DOUBLE
);
2163 insert_keyword ("dynamic_cast", DYNAMIC_CAST
);
2164 insert_keyword ("else", ELSE
);
2165 insert_keyword ("enum", ENUM
);
2166 insert_keyword ("explicit", EXPLICIT
);
2167 insert_keyword ("extern", EXTERN
);
2168 insert_keyword ("false", FALSE
);
2169 insert_keyword ("float", FLOAT
);
2170 insert_keyword ("for", FOR
);
2171 insert_keyword ("friend", FRIEND
);
2172 insert_keyword ("goto", GOTO
);
2173 insert_keyword ("if", IF
);
2174 insert_keyword ("inline", T_INLINE
);
2175 insert_keyword ("int", INT
);
2176 insert_keyword ("long", LONG
);
2177 insert_keyword ("mutable", MUTABLE
);
2178 insert_keyword ("namespace", NAMESPACE
);
2179 insert_keyword ("new", NEW
);
2180 insert_keyword ("not", '!');
2181 insert_keyword ("not_eq", NE
);
2182 insert_keyword ("operator", OPERATOR
);
2183 insert_keyword ("or", LOR
);
2184 insert_keyword ("or_eq", ORASGN
);
2185 insert_keyword ("private", PRIVATE
);
2186 insert_keyword ("protected", PROTECTED
);
2187 insert_keyword ("public", PUBLIC
);
2188 insert_keyword ("register", REGISTER
);
2189 insert_keyword ("reinterpret_cast", REINTERPRET_CAST
);
2190 insert_keyword ("return", RETURN
);
2191 insert_keyword ("short", SHORT
);
2192 insert_keyword ("signed", SIGNED
);
2193 insert_keyword ("sizeof", SIZEOF
);
2194 insert_keyword ("static", STATIC
);
2195 insert_keyword ("static_cast", STATIC_CAST
);
2196 insert_keyword ("struct", STRUCT
);
2197 insert_keyword ("switch", SWITCH
);
2198 insert_keyword ("template", TEMPLATE
);
2199 insert_keyword ("this", THIS
);
2200 insert_keyword ("throw", THROW
);
2201 insert_keyword ("true", TRUE
);
2202 insert_keyword ("try", TRY
);
2203 insert_keyword ("typedef", TYPEDEF
);
2204 insert_keyword ("typeid", TYPEID
);
2205 insert_keyword ("typename", TYPENAME
);
2206 insert_keyword ("union", UNION
);
2207 insert_keyword ("unsigned", UNSIGNED
);
2208 insert_keyword ("using", USING
);
2209 insert_keyword ("virtual", VIRTUAL
);
2210 insert_keyword ("void", VOID
);
2211 insert_keyword ("volatile", VOLATILE
);
2212 insert_keyword ("wchar_t", WCHAR
);
2213 insert_keyword ("while", WHILE
);
2214 insert_keyword ("xor", '^');
2215 insert_keyword ("xor_eq", XORASGN
);
2220 /***********************************************************************
2222 ***********************************************************************/
2224 /* Match the current lookahead token and set it to the next token. */
2226 #define MATCH() (tk = yylex ())
2228 /* Return the lookahead token. If current lookahead token is cleared,
2229 read a new token. */
2231 #define LA1 (tk == -1 ? (tk = yylex ()) : tk)
2233 /* Is the current lookahead equal to the token T? */
2235 #define LOOKING_AT(T) (tk == (T))
2237 /* Is the current lookahead one of T1 or T2? */
2239 #define LOOKING_AT2(T1, T2) (tk == (T1) || tk == (T2))
2241 /* Is the current lookahead one of T1, T2 or T3? */
2243 #define LOOKING_AT3(T1, T2, T3) (tk == (T1) || tk == (T2) || tk == (T3))
2245 /* Is the current lookahead one of T1...T4? */
2247 #define LOOKING_AT4(T1, T2, T3, T4) \
2248 (tk == (T1) || tk == (T2) || tk == (T3) || tk == (T4))
2250 /* Match token T if current lookahead is T. */
2252 #define MATCH_IF(T) if (LOOKING_AT (T)) MATCH (); else ((void) 0)
2254 /* Skip to matching token if current token is T. */
2256 #define SKIP_MATCHING_IF(T) \
2257 if (LOOKING_AT (T)) skip_matching (); else ((void) 0)
2260 /* Skip forward until a given token TOKEN or YYEOF is seen and return
2261 the current lookahead token after skipping. */
2267 while (!LOOKING_AT2 (YYEOF
, token
))
2273 /* Skip over pairs of tokens (parentheses, square brackets,
2274 angle brackets, curly brackets) matching the current lookahead. */
2305 if (LOOKING_AT (open
))
2307 else if (LOOKING_AT (close
))
2309 else if (LOOKING_AT (YYEOF
))
2320 /* Re-initialize the parser by resetting the lookahead token. */
2329 /* Parse a parameter list, including the const-specifier,
2330 pure-specifier, and throw-list that may follow a parameter list.
2331 Return in FLAGS what was seen following the parameter list.
2332 Returns a hash code for the parameter types. This value is used to
2333 distinguish between overloaded functions. */
2342 while (!LOOKING_AT2 (YYEOF
, ')'))
2346 /* Skip over grouping parens or parameter lists in parameter
2352 /* Next parameter. */
2358 /* Ignore the scope part of types, if any. This is because
2359 some types need scopes when defined outside of a class body,
2360 and don't need them inside the class body. This means that
2361 we have to look for the last IDENT in a sequence of
2362 IDENT::IDENT::... */
2367 unsigned ident_type_hash
= 0;
2369 parse_qualified_param_ident_or_type (&s
);
2371 ident_type_hash
= (ident_type_hash
<< 1) ^ *s
;
2372 hash
= (hash
<< 1) ^ ident_type_hash
;
2380 /* This distinction is made to make `func (void)' equivalent
2384 if (!LOOKING_AT (')'))
2385 hash
= (hash
<< 1) ^ VOID
;
2388 case BOOL
: case CHAR
: case CLASS
: case CONST
:
2389 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2390 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2391 case UNION
: case UNSIGNED
: case VOLATILE
: case WCHAR
:
2394 hash
= (hash
<< 1) ^ LA1
;
2398 case '*': case '&': case '[': case ']':
2399 hash
= (hash
<< 1) ^ LA1
;
2409 if (LOOKING_AT (')'))
2413 if (LOOKING_AT (CONST
))
2415 /* We can overload the same function on `const' */
2416 hash
= (hash
<< 1) ^ CONST
;
2417 SET_FLAG (*flags
, F_CONST
);
2421 if (LOOKING_AT (THROW
))
2424 SKIP_MATCHING_IF ('(');
2425 SET_FLAG (*flags
, F_THROW
);
2428 if (LOOKING_AT ('='))
2431 if (LOOKING_AT (CINT
) && yyival
== 0)
2434 SET_FLAG (*flags
, F_PURE
);
2443 /* Print position info to stdout. */
2448 if (info_position
>= 0 && BUFFER_POS () <= info_position
)
2450 printf ("(\"%s\" \"%s\" \"%s\" %d)\n",
2451 info_cls
->name
, sym_scope (info_cls
),
2452 info_member
->name
, info_where
);
2456 /* Parse a member declaration within the class body of CLS. VIS is
2457 the access specifier for the member (private, protected,
2467 char *regexp
= NULL
;
2478 while (!LOOKING_AT4 (';', '{', '}', YYEOF
))
2486 /* A function or class may follow. */
2489 SET_FLAG (flags
, F_TEMPLATE
);
2490 /* Skip over template argument list */
2491 SKIP_MATCHING_IF ('<');
2495 SET_FLAG (flags
, F_EXPLICIT
);
2499 SET_FLAG (flags
, F_MUTABLE
);
2503 SET_FLAG (flags
, F_INLINE
);
2507 SET_FLAG (flags
, F_VIRTUAL
);
2536 /* Remember IDENTS seen so far. Among these will be the member
2538 id
= (char *) alloca (strlen (yytext
) + 2);
2542 strcpy (id
+ 1, yytext
);
2545 strcpy (id
, yytext
);
2550 id
= operator_name (&sc
);
2554 /* Most probably the beginning of a parameter list. */
2560 if (!(is_constructor
= streq (id
, cls
->name
)))
2561 regexp
= matching_regexp ();
2566 pos
= BUFFER_POS ();
2567 hash
= parm_list (&flags
);
2570 regexp
= matching_regexp ();
2572 if (id
&& cls
!= NULL
)
2573 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, flags
);
2575 while (!LOOKING_AT3 (';', '{', YYEOF
))
2578 if (LOOKING_AT ('{') && id
&& cls
)
2579 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0, sc
, flags
);
2585 case STRUCT
: case UNION
: case CLASS
:
2592 /* More than one ident here to allow for MS-DOS specialties
2593 like `_export class' etc. The last IDENT seen counts
2594 as the class name. */
2595 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
2597 if (LOOKING_AT (IDENT
))
2602 if (LOOKING_AT2 (':', '{'))
2603 class_definition (anonymous
? NULL
: cls
, class_tag
, flags
, 1);
2608 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
2609 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
2610 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
2619 if (LOOKING_AT (';'))
2621 /* The end of a member variable, a friend declaration or an access
2622 declaration. We don't want to add friend classes as members. */
2623 if (id
&& sc
!= SC_FRIEND
&& cls
)
2625 regexp
= matching_regexp ();
2626 pos
= BUFFER_POS ();
2630 if (type_seen
|| !paren_seen
)
2631 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2633 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, 0);
2640 else if (LOOKING_AT ('{'))
2643 if (sc
== SC_TYPE
&& id
&& cls
)
2645 regexp
= matching_regexp ();
2646 pos
= BUFFER_POS ();
2650 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2651 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, sc
, 0);
2661 /* Parse the body of class CLS. TAG is the tag of the class (struct,
2665 class_body (cls
, tag
)
2669 int vis
= tag
== CLASS
? PRIVATE
: PUBLIC
;
2672 while (!LOOKING_AT2 (YYEOF
, '}'))
2676 case PRIVATE
: case PROTECTED
: case PUBLIC
:
2680 if (LOOKING_AT (':'))
2687 /* Probably conditional compilation for inheritance list.
2688 We don't known whether there comes more of this.
2689 This is only a crude fix that works most of the time. */
2694 while (LOOKING_AT2 (IDENT
, ',')
2695 || LOOKING_AT3 (PUBLIC
, PROTECTED
, PRIVATE
));
2704 /* Try to synchronize */
2705 case CHAR
: case CLASS
: case CONST
:
2706 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2707 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2708 case UNION
: case UNSIGNED
: case VOID
: case VOLATILE
:
2709 case TYPEDEF
: case STATIC
: case T_INLINE
: case FRIEND
:
2710 case VIRTUAL
: case TEMPLATE
: case IDENT
: case '~':
2711 case BOOL
: case WCHAR
: case EXPLICIT
: case MUTABLE
:
2723 /* Parse a qualified identifier. Current lookahead is IDENT. A
2724 qualified ident has the form `X<..>::Y<...>::T<...>. Returns a
2725 symbol for that class. */
2730 struct sym
*last_class
= NULL
;
2732 while (LOOKING_AT (IDENT
))
2734 last_class
= add_sym (yytext
, last_class
);
2737 if (LOOKING_AT ('<'))
2740 SET_FLAG (last_class
->flags
, F_TEMPLATE
);
2743 if (!LOOKING_AT (DCOLON
))
2753 /* Parse an operator name. Add the `static' flag to *SC if an
2754 implicitly static operator has been parsed. Value is a pointer to
2755 a static buffer holding the constructed operator name string. */
2761 static int id_size
= 0;
2762 static char *id
= NULL
;
2768 if (LOOKING_AT2 (NEW
, DELETE
))
2770 /* `new' and `delete' are implicitly static. */
2771 if (*sc
!= SC_FRIEND
)
2774 s
= token_string (LA1
);
2777 len
= strlen (s
) + 10;
2780 int new_size
= max (len
, 2 * id_size
);
2781 id
= (char *) xrealloc (id
, new_size
);
2786 /* Vector new or delete? */
2787 if (LOOKING_AT ('['))
2792 if (LOOKING_AT (']'))
2801 int tokens_matched
= 0;
2806 int new_size
= max (len
, 2 * id_size
);
2807 id
= (char *) xrealloc (id
, new_size
);
2810 strcpy (id
, "operator");
2812 /* Beware access declarations of the form "X::f;" Beware of
2813 `operator () ()'. Yet another difficulty is found in
2814 GCC 2.95's STL: `operator == __STL_NULL_TMPL_ARGS (...'. */
2815 while (!(LOOKING_AT ('(') && tokens_matched
)
2816 && !LOOKING_AT2 (';', YYEOF
))
2818 s
= token_string (LA1
);
2819 len
+= strlen (s
) + 2;
2822 int new_size
= max (len
, 2 * id_size
);
2823 id
= (char *) xrealloc (id
, new_size
);
2827 if (*s
!= ')' && *s
!= ']')
2832 /* If this is a simple operator like `+', stop now. */
2833 if (!isalpha (*s
) && *s
!= '(' && *s
!= '[')
2844 /* This one consumes the last IDENT of a qualified member name like
2845 `X::Y::z'. This IDENT is returned in LAST_ID. Value if the
2846 symbol structure for the ident. */
2849 parse_qualified_ident_or_type (last_id
)
2852 struct sym
*cls
= NULL
;
2853 static char *id
= NULL
;
2854 static int id_size
= 0;
2856 while (LOOKING_AT (IDENT
))
2858 int len
= strlen (yytext
) + 1;
2861 id
= (char *) xrealloc (id
, len
);
2864 strcpy (id
, yytext
);
2868 SKIP_MATCHING_IF ('<');
2870 if (LOOKING_AT (DCOLON
))
2872 cls
= add_sym (id
, cls
);
2884 /* This one consumes the last IDENT of a qualified member name like
2885 `X::Y::z'. This IDENT is returned in LAST_ID. Value if the
2886 symbol structure for the ident. */
2889 parse_qualified_param_ident_or_type (last_id
)
2892 struct sym
*cls
= NULL
;
2893 static char *id
= NULL
;
2894 static int id_size
= 0;
2896 while (LOOKING_AT (IDENT
))
2898 int len
= strlen (yytext
) + 1;
2901 id
= (char *) xrealloc (id
, len
);
2904 strcpy (id
, yytext
);
2908 SKIP_MATCHING_IF ('<');
2910 if (LOOKING_AT (DCOLON
))
2912 cls
= add_sym (id
, cls
);
2922 /* Parse a class definition.
2924 CONTAINING is the class containing the class being parsed or null.
2925 This may also be null if NESTED != 0 if the containing class is
2926 anonymous. TAG is the tag of the class (struct, union, class).
2927 NESTED is non-zero if we are parsing a nested class.
2929 Current lookahead is the class name. */
2932 class_definition (containing
, tag
, flags
, nested
)
2933 struct sym
*containing
;
2938 struct sym
*current
;
2939 struct sym
*base_class
;
2941 /* Set CURRENT to null if no entry has to be made for the class
2942 parsed. This is the case for certain command line flag
2944 if ((tag
!= CLASS
&& !f_structs
) || (nested
&& !f_nested_classes
))
2948 current
= add_sym (yytext
, containing
);
2949 current
->pos
= BUFFER_POS ();
2950 current
->regexp
= matching_regexp ();
2951 current
->filename
= filename
;
2952 current
->flags
= flags
;
2955 /* If at ':', base class list follows. */
2956 if (LOOKING_AT (':'))
2965 case VIRTUAL
: case PUBLIC
: case PROTECTED
: case PRIVATE
:
2970 base_class
= parse_classname ();
2971 if (base_class
&& current
&& base_class
!= current
)
2972 add_link (base_class
, current
);
2975 /* The `,' between base classes or the end of the base
2976 class list. Add the previously found base class.
2977 It's done this way to skip over sequences of
2978 `A::B::C' until we reach the end.
2980 FIXME: it is now possible to handle `class X : public B::X'
2981 because we have enough information. */
2987 /* A syntax error, possibly due to preprocessor constructs
2993 class A : private B.
2995 MATCH until we see something like `;' or `{'. */
2996 while (!LOOKING_AT3 (';', YYEOF
, '{'))
3007 /* Parse the class body if there is one. */
3008 if (LOOKING_AT ('{'))
3010 if (tag
!= CLASS
&& !f_structs
)
3015 class_body (current
, tag
);
3017 if (LOOKING_AT ('}'))
3020 if (LOOKING_AT (';') && !nested
)
3028 /* Parse a declaration. */
3035 struct sym
*cls
= NULL
;
3036 char *regexp
= NULL
;
3042 while (!LOOKING_AT3 (';', '{', YYEOF
))
3065 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
3066 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
3067 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
3071 case CLASS
: case STRUCT
: case UNION
:
3072 /* This is for the case `STARTWRAP class X : ...' or
3073 `declare (X, Y)\n class A : ...'. */
3078 /* Assumed to be the start of an initialization in this context.
3079 Skip over everything up to ';'. */
3084 id
= operator_name (&sc
);
3088 SET_FLAG (flags
, F_INLINE
);
3094 if (LOOKING_AT (IDENT
))
3096 id
= (char *) alloca (strlen (yytext
) + 2);
3098 strcpy (id
+ 1, yytext
);
3104 cls
= parse_qualified_ident_or_type (&id
);
3108 /* Most probably the beginning of a parameter list. */
3115 if (!(is_constructor
= streq (id
, cls
->name
)))
3116 regexp
= matching_regexp ();
3121 pos
= BUFFER_POS ();
3122 hash
= parm_list (&flags
);
3125 regexp
= matching_regexp ();
3128 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0,
3133 /* This may be a C functions, but also a macro
3134 call of the form `declare (A, B)' --- such macros
3135 can be found in some class libraries. */
3140 regexp
= matching_regexp ();
3141 pos
= BUFFER_POS ();
3142 hash
= parm_list (&flags
);
3143 add_global_decl (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3146 /* This is for the case that the function really is
3147 a macro with no `;' following it. If a CLASS directly
3148 follows, we would miss it otherwise. */
3149 if (LOOKING_AT3 (CLASS
, STRUCT
, UNION
))
3153 while (!LOOKING_AT3 (';', '{', YYEOF
))
3156 if (!cls
&& id
&& LOOKING_AT ('{'))
3157 add_global_defn (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3163 if (LOOKING_AT (';'))
3165 /* The end of a member variable or of an access declaration
3166 `X::f'. To distinguish between them we have to know whether
3167 type information has been seen. */
3170 char *regexp
= matching_regexp ();
3171 int pos
= BUFFER_POS ();
3174 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, SC_UNKNOWN
, flags
);
3176 add_global_defn (id
, regexp
, pos
, 0, 1, sc
, flags
);
3182 else if (LOOKING_AT ('{'))
3184 if (sc
== SC_TYPE
&& id
)
3186 /* A named enumeration. */
3187 regexp
= matching_regexp ();
3188 pos
= BUFFER_POS ();
3189 add_global_defn (id
, regexp
, pos
, 0, 1, sc
, flags
);
3198 /* Parse a list of top-level declarations/definitions. START_FLAGS
3199 says in which context we are parsing. If it is F_EXTERNC, we are
3200 parsing in an `extern "C"' block. Value is 1 if EOF is reached, 0
3204 globals (start_flags
)
3209 int flags
= start_flags
;
3221 if (LOOKING_AT (IDENT
))
3223 char *namespace_name
3224 = (char *) alloca (strlen (yytext
) + 1);
3225 strcpy (namespace_name
, yytext
);
3228 if (LOOKING_AT ('='))
3230 if (skip_to (';') == ';')
3232 register_namespace_alias (namespace_name
, yytext
);
3234 else if (LOOKING_AT ('{'))
3237 enter_namespace (namespace_name
);
3248 if (LOOKING_AT (CSTRING
) && *string_start
== 'C'
3249 && *(string_start
+ 1) == '"')
3251 /* This is `extern "C"'. */
3254 if (LOOKING_AT ('{'))
3257 globals (F_EXTERNC
);
3261 SET_FLAG (flags
, F_EXTERNC
);
3267 SKIP_MATCHING_IF ('<');
3268 SET_FLAG (flags
, F_TEMPLATE
);
3271 case CLASS
: case STRUCT
: case UNION
:
3276 /* More than one ident here to allow for MS-DOS and OS/2
3277 specialties like `far', `_Export' etc. Some C++ libs
3278 have constructs like `_OS_DLLIMPORT(_OS_CLIENT)' in front
3279 of the class name. */
3280 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
3282 if (LOOKING_AT (IDENT
))
3287 /* Don't add anonymous unions. */
3288 if (LOOKING_AT2 (':', '{') && !anonymous
)
3289 class_definition (NULL
, class_tk
, flags
, 0);
3292 if (skip_to (';') == ';')
3296 flags
= start_flags
;
3306 declaration (flags
);
3307 flags
= start_flags
;
3312 yyerror ("parse error");
3317 /* Parse the current input file. */
3322 while (globals (0) == 0)
3328 /***********************************************************************
3330 ***********************************************************************/
3332 /* Add the list of paths PATH_LIST to the current search path for
3336 add_search_path (path_list
)
3341 char *start
= path_list
;
3342 struct search_path
*p
;
3344 while (*path_list
&& *path_list
!= PATH_LIST_SEPARATOR
)
3347 p
= (struct search_path
*) xmalloc (sizeof *p
);
3348 p
->path
= (char *) xmalloc (path_list
- start
+ 1);
3349 memcpy (p
->path
, start
, path_list
- start
);
3350 p
->path
[path_list
- start
] = '\0';
3353 if (search_path_tail
)
3355 search_path_tail
->next
= p
;
3356 search_path_tail
= p
;
3359 search_path
= search_path_tail
= p
;
3361 while (*path_list
== PATH_LIST_SEPARATOR
)
3367 /* Open FILE and return a file handle for it, or -1 if FILE cannot be
3368 opened. Try to find FILE in search_path first, then try the
3369 unchanged file name. */
3376 static char *buffer
;
3377 static int buffer_size
;
3378 struct search_path
*path
;
3380 filename
= xstrdup (file
);
3382 for (path
= search_path
; path
&& fp
== NULL
; path
= path
->next
)
3384 int len
= strlen (path
->path
);
3386 if (len
+ 1 >= buffer_size
)
3388 buffer_size
= max (len
+ 1, 2 * buffer_size
);
3389 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3392 strcpy (buffer
, path
->path
);
3393 strcat (buffer
, "/");
3394 strcat (buffer
, file
);
3395 fp
= fopen (buffer
, "r");
3398 /* Try the original file name. */
3400 fp
= fopen (file
, "r");
3403 yyerror ("cannot open");
3409 /* Display usage information and exit program. */
3412 Usage: ebrowse [options] {files}\n\
3414 -a, --append append output\n\
3415 -f, --files=FILES read input file names from FILE\n\
3416 -I, --search-path=LIST set search path for input files\n\
3417 -m, --min-regexp-length=N set minimum regexp length to N\n\
3418 -M, --max-regexp-length=N set maximum regexp length to N\n\
3419 -n, --no-nested-classes exclude nested classes\n\
3420 -o, --output-file=FILE set output file name to FILE\n\
3421 -p, --position-info print info about position in file\n\
3422 -s, --no-structs-or-unions don't record structs or unions\n\
3423 -v, --verbose be verbose\n\
3424 -V, --very-verbose be very verbose\n\
3425 -x, --no-regexps don't record regular expressions\n\
3426 --help display this help\n\
3427 --version display version info\n\
3435 exit (error
? 1 : 0);
3439 /* Display version and copyright info. The VERSION macro is set
3440 from the Makefile and contains the Emacs version. */
3445 printf ("ebrowse %s\n", VERSION
);
3446 puts ("Copyright (C) 1992-1999, 2000 Free Software Foundation, Inc.");
3447 puts ("This program is distributed under the same terms as Emacs.");
3452 /* Parse one input file FILE, adding classes and members to the symbol
3461 fp
= open_file (file
);
3466 /* Give a progress indication if needed. */
3478 /* Read file to inbuffer. */
3481 if (nread
+ READ_CHUNK_SIZE
>= inbuffer_size
)
3483 inbuffer_size
= nread
+ READ_CHUNK_SIZE
+ 1;
3484 inbuffer
= (char *) xrealloc (inbuffer
, inbuffer_size
);
3487 nbytes
= fread (inbuffer
+ nread
, 1, READ_CHUNK_SIZE
, fp
);
3489 if (nbytes
< READ_CHUNK_SIZE
)
3492 inbuffer
[nread
] = '\0';
3494 /* Reinitialize scanner and parser for the new input file. */
3498 /* Parse it and close the file. */
3505 /* Read a line from stream FP and return a pointer to a static buffer
3506 containing its contents without the terminating newline. Value
3507 is null when EOF is reached. */
3513 static char *buffer
;
3514 static int buffer_size
;
3517 while ((c
= getc (fp
)) != EOF
&& c
!= '\n')
3519 if (i
>= buffer_size
)
3521 buffer_size
= max (100, buffer_size
* 2);
3522 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3528 if (c
== EOF
&& i
== 0)
3531 if (i
== buffer_size
)
3533 buffer_size
= max (100, buffer_size
* 2);
3534 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3542 /* Main entry point. */
3550 int any_inputfiles
= 0;
3551 static char *out_filename
= DEFAULT_OUTFILE
;
3552 static char **input_filenames
= NULL
;
3553 static int input_filenames_size
= 0;
3554 static int n_input_files
;
3556 filename
= "command line";
3559 while ((i
= getopt_long (argc
, argv
, "af:I:m:M:no:p:svVx",
3560 options
, NULL
)) != EOF
)
3566 info_position
= atoi (optarg
);
3570 f_nested_classes
= 0;
3577 /* Add the name of a file containing more input files. */
3579 if (n_input_files
== input_filenames_size
)
3581 input_filenames_size
= max (10, 2 * input_filenames_size
);
3582 input_filenames
= (char **) xrealloc (input_filenames
,
3583 input_filenames_size
);
3585 input_filenames
[n_input_files
++] = xstrdup (optarg
);
3588 /* Append new output to output file instead of truncating it. */
3593 /* Include structs in the output */
3598 /* Be verbose (give a progress indication). */
3603 /* Be very verbose (print file names as they are processed). */
3609 /* Change the name of the output file. */
3611 out_filename
= optarg
;
3614 /* Set minimum length for regular expression strings
3615 when recorded in the output file. */
3617 min_regexp
= atoi (optarg
);
3620 /* Set maximum length for regular expression strings
3621 when recorded in the output file. */
3623 max_regexp
= atoi (optarg
);
3626 /* Add to search path. */
3628 add_search_path (optarg
);
3642 /* Call init_scanner after command line flags have been processed to be
3643 able to add keywords depending on command line (not yet
3648 /* Open output file */
3651 yyout
= fopen (out_filename
, f_append
? "a" : "w");
3654 yyerror ("cannot open output file `%s'", out_filename
);
3659 /* Process input files specified on the command line. */
3660 while (optind
< argc
)
3662 process_file (argv
[optind
++]);
3666 /* Process files given on stdin if no files specified. */
3667 if (!any_inputfiles
&& n_input_files
== 0)
3670 while ((file
= read_line (stdin
)) != NULL
)
3671 process_file (file
);
3675 /* Process files from `--files=FILE'. Every line in FILE names
3676 one input file to process. */
3677 for (i
= 0; i
< n_input_files
; ++i
)
3679 FILE *fp
= fopen (input_filenames
[i
], "r");
3682 yyerror ("cannot open input file `%s'", input_filenames
[i
]);
3686 while ((file
= read_line (fp
)) != NULL
)
3687 process_file (file
);
3693 /* Write output file. */
3696 /* Close output file. */
3697 if (yyout
!= stdout
)
3704 /* ebrowse.c ends here. */