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 #if defined(__MSDOS__) || defined(WINDOWSNT)
61 #define PATH_LIST_SEPARATOR ';'
62 #define FILENAME_EQ(X,Y) (strcasecmp(X,Y) == 0)
64 #define PATH_LIST_SEPARATOR ':'
65 #define FILENAME_EQ(X,Y) (streq(X,Y))
68 /* The default output file name. */
70 #define DEFAULT_OUTFILE "BROWSE"
72 /* A version string written to the output file. Change this whenever
73 the structure of the output file changes. */
75 #define EBROWSE_FILE_VERSION "ebrowse 5.0"
77 /* The output file consists of a tree of Lisp objects, with major
78 nodes built out of Lisp structures. These are the heads of the
79 Lisp structs with symbols identifying their type. */
81 #define TREE_HEADER_STRUCT "[ebrowse-hs "
82 #define TREE_STRUCT "[ebrowse-ts "
83 #define MEMBER_STRUCT "[ebrowse-ms "
84 #define BROWSE_STRUCT "[ebrowse-bs "
85 #define CLASS_STRUCT "[ebrowse-cs "
87 /* The name of the symbol table entry for global functions, variables,
88 defines etc. This name also appears in the browser display. */
90 #define GLOBALS_NAME "*Globals*"
92 /* Token definitions. */
96 YYEOF
= 0, /* end of file */
97 CSTRING
= 256, /* string constant */
98 CCHAR
, /* character constant */
99 CINT
, /* integral constant */
100 CFLOAT
, /* real constant */
103 LSHIFTASGN
, /* <<= */
104 RSHIFTASGN
, /* >>= */
106 IDENT
, /* identifier */
129 /* Keywords. The undef's are there because these
130 three symbols are very likely to be defined somewhere. */
143 CONTINUE
, /* continue */
144 DEFAULT
, /* default */
156 T_INLINE
, /* inline */
160 OPERATOR
, /* operator */
161 PRIVATE
, /* private */
162 PROTECTED
, /* protected */
164 REGISTER
, /* register */
172 TEMPLATE
, /* template */
176 TYPEDEF
, /* typedef */
178 UNSIGNED
, /* unsigned */
179 VIRTUAL
, /* virtual */
181 VOLATILE
, /* volatile */
183 MUTABLE
, /* mutable */
187 SIGNATURE
, /* signature (GNU extension) */
188 NAMESPACE
, /* namespace */
189 EXPLICIT
, /* explicit */
190 TYPENAME
, /* typename */
191 CONST_CAST
, /* const_cast */
192 DYNAMIC_CAST
, /* dynamic_cast */
193 REINTERPRET_CAST
, /* reinterpret_cast */
194 STATIC_CAST
, /* static_cast */
200 /* Storage classes, in a wider sense. */
205 SC_MEMBER
, /* Is an instance member. */
206 SC_STATIC
, /* Is static member. */
207 SC_FRIEND
, /* Is friend function. */
208 SC_TYPE
/* Is a type definition. */
211 /* Member visibility. */
222 #define F_VIRTUAL 1 /* Is virtual function. */
223 #define F_INLINE 2 /* Is inline function. */
224 #define F_CONST 4 /* Is const. */
225 #define F_PURE 8 /* Is pure virtual function. */
226 #define F_MUTABLE 16 /* Is mutable. */
227 #define F_TEMPLATE 32 /* Is a template. */
228 #define F_EXPLICIT 64 /* Is explicit constructor. */
229 #define F_THROW 128 /* Has a throw specification. */
230 #define F_EXTERNC 256 /* Is declared extern "C". */
231 #define F_DEFINE 512 /* Is a #define. */
233 /* Two macros to set and test a bit in an int. */
235 #define SET_FLAG(F, FLAG) ((F) |= (FLAG))
236 #define HAS_FLAG(F, FLAG) (((F) & (FLAG)) != 0)
238 /* Structure describing a class member. */
242 struct member
*next
; /* Next in list of members. */
243 struct member
*anext
; /* Collision chain in member_table. */
244 struct member
**list
; /* Pointer to list in class. */
245 unsigned param_hash
; /* Hash value for parameter types. */
246 int vis
; /* Visibility (public, ...). */
247 int flags
; /* See F_* above. */
248 char *regexp
; /* Matching regular expression. */
249 char *filename
; /* Don't free this shared string. */
250 int pos
; /* Buffer position of occurrence. */
251 char *def_regexp
; /* Regular expression matching definition. */
252 char *def_filename
; /* File name of definition. */
253 int def_pos
; /* Buffer position of definition. */
254 char name
[1]; /* Member name. */
257 /* Structures of this type are used to connect class structures with
258 their super and subclasses. */
262 struct sym
*sym
; /* The super or subclass. */
263 struct link
*next
; /* Next in list or NULL. */
266 /* Structure used to record namespace aliases. */
270 struct alias
*next
; /* Next in list. */
271 char name
[1]; /* Alias name. */
274 /* The structure used to describe a class in the symbol table,
275 or a namespace in all_namespaces. */
279 int flags
; /* Is class a template class?. */
280 unsigned char visited
; /* Used to find circles. */
281 struct sym
*next
; /* Hash collision list. */
282 struct link
*subs
; /* List of subclasses. */
283 struct link
*supers
; /* List of superclasses. */
284 struct member
*vars
; /* List of instance variables. */
285 struct member
*fns
; /* List of instance functions. */
286 struct member
*static_vars
; /* List of static variables. */
287 struct member
*static_fns
; /* List of static functions. */
288 struct member
*friends
; /* List of friend functions. */
289 struct member
*types
; /* List of local types. */
290 char *regexp
; /* Matching regular expression. */
291 int pos
; /* Buffer position. */
292 char *filename
; /* File in which it can be found. */
293 char *sfilename
; /* File in which members can be found. */
294 struct sym
*namesp
; /* Namespace in which defined. . */
295 struct alias
*namesp_aliases
; /* List of aliases for namespaces. */
296 char name
[1]; /* Name of the class. */
299 /* Experimental: Print info for `--position-info'. We print
300 '(CLASS-NAME SCOPE MEMBER-NAME). */
306 struct sym
*info_cls
= NULL
;
307 struct member
*info_member
= NULL
;
309 /* Experimental. For option `--position-info', the buffer position we
310 are interested in. When this position is reached, print out
311 information about what we know about that point. */
313 int info_position
= -1;
315 /* Command line options structure for getopt_long. */
317 struct option options
[] =
319 {"append", no_argument
, NULL
, 'a'},
320 {"files", required_argument
, NULL
, 'f'},
321 {"help", no_argument
, NULL
, -2},
322 {"min-regexp-length", required_argument
, NULL
, 'm'},
323 {"max-regexp-length", required_argument
, NULL
, 'M'},
324 {"no-nested-classes", no_argument
, NULL
, 'n'},
325 {"no-regexps", no_argument
, NULL
, 'x'},
326 {"no-structs-or-unions", no_argument
, NULL
, 's'},
327 {"output-file", required_argument
, NULL
, 'o'},
328 {"position-info", required_argument
, NULL
, 'p'},
329 {"search-path", required_argument
, NULL
, 'I'},
330 {"verbose", no_argument
, NULL
, 'v'},
331 {"version", no_argument
, NULL
, -3},
332 {"very-verbose", no_argument
, NULL
, 'V'},
336 /* Semantic values of tokens. Set by yylex.. */
338 unsigned yyival
; /* Set for token CINT. */
339 char *yytext
; /* Set for token IDENT. */
346 /* Current line number. */
350 /* The name of the current input file. */
354 /* Three character class vectors, and macros to test membership
361 #define IDENTP(C) is_ident[(unsigned char) (C)]
362 #define DIGITP(C) is_digit[(unsigned char) (C)]
363 #define WHITEP(C) is_white[(unsigned char) (C)]
365 /* Command line flags. */
372 int f_nested_classes
= 1;
374 /* Maximum and minimum lengths of regular expressions matching a
375 member, class etc., for writing them to the output file. These are
376 overridable from the command line. */
387 /* Return the current buffer position in the input file. */
389 #define BUFFER_POS() (in - inbuffer)
391 /* If current lookahead is CSTRING, the following points to the
392 first character in the string constant. Used for recognizing
397 /* The size of the hash tables for classes.and members. Should be
400 #define TABLE_SIZE 1001
402 /* The hash table for class symbols. */
404 struct sym
*class_table
[TABLE_SIZE
];
406 /* Hash table containing all member structures. This is generally
407 faster for member lookup than traversing the member lists of a
410 struct member
*member_table
[TABLE_SIZE
];
412 /* The special class symbol used to hold global functions,
415 struct sym
*global_symbols
;
417 /* The current namespace. */
419 struct sym
*current_namespace
;
421 /* The list of all known namespaces. */
423 struct sym
*all_namespaces
;
425 /* Stack of namespaces we're currently nested in, during the parse. */
427 struct sym
**namespace_stack
;
428 int namespace_stack_size
;
431 /* The current lookahead token. */
435 /* Structure describing a keyword. */
439 char *name
; /* Spelling. */
440 int tk
; /* Token value. */
441 struct kw
*next
; /* Next in collision chain. */
444 /* Keywords are lookup up in a hash table of their own. */
446 #define KEYWORD_TABLE_SIZE 1001
447 struct kw
*keyword_table
[KEYWORD_TABLE_SIZE
];
454 struct search_path
*next
;
457 struct search_path
*search_path
;
458 struct search_path
*search_path_tail
;
460 /* Function prototypes. */
462 int yylex
P_ ((void));
463 void yyparse
P_ ((void));
464 void re_init_parser
P_ ((void));
465 char *token_string
P_ ((int));
466 char *matching_regexp
P_ ((void));
467 void init_sym
P_ ((void));
468 struct sym
*add_sym
P_ ((char *, struct sym
*));
469 void add_link
P_ ((struct sym
*, struct sym
*));
470 void add_member_defn
P_ ((struct sym
*, char *, char *,
471 int, unsigned, int, int, int));
472 void add_member_decl
P_ ((struct sym
*, char *, char *, int,
473 unsigned, int, int, int, int));
474 void dump_roots
P_ ((FILE *));
475 void *xmalloc
P_ ((int));
476 void add_global_defn
P_ ((char *, char *, int, unsigned, int, int, int));
477 void add_global_decl
P_ ((char *, char *, int, unsigned, int, int, int));
478 void add_define
P_ ((char *, char *, int));
479 void mark_inherited_virtual
P_ ((void));
480 void leave_namespace
P_ ((void));
481 void enter_namespace
P_ ((char *));
482 void register_namespace_alias
P_ ((char *, char *));
483 void insert_keyword
P_ ((char *, int));
484 void re_init_scanner
P_ ((void));
485 void init_scanner
P_ ((void));
486 void usage
P_ ((int));
487 void version
P_ ((void));
488 void process_file
P_ ((char *));
489 void add_search_path
P_ ((char *));
490 FILE *open_file
P_ ((char *));
491 int process_pp_line
P_ ((void));
492 int dump_members
P_ ((FILE *, struct member
*));
493 void dump_sym
P_ ((FILE *, struct sym
*));
494 int dump_tree
P_ ((FILE *, struct sym
*));
495 struct member
*find_member
P_ ((struct sym
*, char *, int, int, unsigned));
496 struct member
*add_member
P_ ((struct sym
*, char *, int, int, unsigned));
497 void mark_virtual
P_ ((struct sym
*));
498 void mark_virtual
P_ ((struct sym
*));
499 struct sym
*make_namespace
P_ ((char *));
500 char *sym_scope
P_ ((struct sym
*));
501 char *sym_scope_1
P_ ((struct sym
*));
502 int skip_to
P_ ((int));
503 void skip_matching
P_ ((void));
504 void member
P_ ((struct sym
*, int));
505 void class_body
P_ ((struct sym
*, int));
506 void class_definition
P_ ((struct sym
*, int, int, int));
507 void declaration
P_ ((int));
508 unsigned parm_list
P_ ((int *));
509 char *operator_name
P_ ((int *));
510 struct sym
*parse_classname
P_ ((void));
511 struct sym
*parse_qualified_ident_or_type
P_ ((char **));
512 void parse_qualified_param_ident_or_type
P_ ((char **));
513 int globals
P_ ((int));
517 /***********************************************************************
519 ***********************************************************************/
521 /* Print an error in a printf-like style with the current input file
522 name and line number. */
525 yyerror (format
, a1
, a2
, a3
, a4
, a5
)
527 int a1
, a2
, a3
, a4
, a5
;
529 fprintf (stderr
, "%s:%d: ", filename
, yyline
);
530 fprintf (stderr
, format
, a1
, a2
, a3
, a4
, a5
);
535 /* Like malloc but print an error and exit if not enough memory is
542 void *p
= malloc (nbytes
);
545 yyerror ("out of memory");
552 /* Like realloc but print an error and exit if out of memory. */
562 yyerror ("out of memory");
569 /* Like strdup, but print an error and exit if not enough memory is
570 available.. If S is null, return null. */
577 s
= strcpy (xmalloc (strlen (s
) + 1), s
);
583 /***********************************************************************
585 ***********************************************************************/
587 /* Initialize the symbol table. This currently only sets up the
588 special symbol for globals (`*Globals*'). */
593 global_symbols
= add_sym (GLOBALS_NAME
, NULL
);
597 /* Add a symbol for class NAME to the symbol table. NESTED_IN_CLASS
598 is the class in which class NAME was found. If it is null,
599 this means the scope of NAME is the current namespace.
601 If a symbol for NAME already exists, return that. Otherwise
602 create a new symbol and set it to default values. */
605 add_sym (name
, nested_in_class
)
607 struct sym
*nested_in_class
;
612 struct sym
*scope
= nested_in_class
? nested_in_class
: current_namespace
;
614 for (s
= name
, h
= 0; *s
; ++s
)
618 for (sym
= class_table
[h
]; sym
; sym
= sym
->next
)
619 if (streq (name
, sym
->name
) && sym
->namesp
== scope
)
630 sym
= (struct sym
*) xmalloc (sizeof *sym
+ strlen (name
));
631 bzero (sym
, sizeof *sym
);
632 strcpy (sym
->name
, name
);
634 sym
->next
= class_table
[h
];
635 class_table
[h
] = sym
;
642 /* Add links between superclass SUPER and subclass SUB. */
645 add_link (super
, sub
)
646 struct sym
*super
, *sub
;
648 struct link
*lnk
, *lnk2
, *p
, *prev
;
650 /* See if a link already exists. */
651 for (p
= super
->subs
, prev
= NULL
;
652 p
&& strcmp (sub
->name
, p
->sym
->name
) > 0;
653 prev
= p
, p
= p
->next
)
656 /* Avoid duplicates. */
657 if (p
== NULL
|| p
->sym
!= sub
)
659 lnk
= (struct link
*) xmalloc (sizeof *lnk
);
660 lnk2
= (struct link
*) xmalloc (sizeof *lnk2
);
671 lnk2
->next
= sub
->supers
;
677 /* Find in class CLS member NAME.
679 VAR non-zero means look for a member variable; otherwise a function
680 is searched. SC specifies what kind of member is searched---a
681 static, or per-instance member etc. HASH is a hash code for the
682 parameter types of functions. Value is a pointer to the member
683 found or null if not found. */
686 find_member (cls
, name
, var
, sc
, hash
)
692 struct member
**list
;
694 unsigned name_hash
= 0;
701 list
= &cls
->friends
;
709 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
713 list
= var
? &cls
->vars
: &cls
->fns
;
717 for (s
= name
; *s
; ++s
)
718 name_hash
= (name_hash
<< 1) ^ *s
;
719 i
= name_hash
% TABLE_SIZE
;
721 for (p
= member_table
[i
]; p
; p
= p
->anext
)
722 if (p
->list
== list
&& p
->param_hash
== hash
&& streq (name
, p
->name
))
729 /* Add to class CLS information for the declaration of member NAME.
730 REGEXP is a regexp matching the declaration, if non-null. POS is
731 the position in the source where the declaration is found. HASH is
732 a hash code for the parameter list of the member, if it's a
733 function. VAR non-zero means member is a variable or type. SC
734 specifies the type of member (instance member, static, ...). VIS
735 is the member's visibility (public, protected, private). FLAGS is
736 a bit set giving additional information about the member (see the
740 add_member_decl (cls
, name
, regexp
, pos
, hash
, var
, sc
, vis
, flags
)
753 m
= find_member (cls
, name
, var
, sc
, hash
);
755 m
= add_member (cls
, name
, var
, sc
, hash
);
757 /* Have we seen a new filename? If so record that. */
758 if (!cls
->filename
|| !FILENAME_EQ (cls
->filename
, filename
))
759 m
->filename
= filename
;
772 m
->vis
= V_PROTECTED
;
786 /* Add to class CLS information for the definition of member NAME.
787 REGEXP is a regexp matching the declaration, if non-null. POS is
788 the position in the source where the declaration is found. HASH is
789 a hash code for the parameter list of the member, if it's a
790 function. VAR non-zero means member is a variable or type. SC
791 specifies the type of member (instance member, static, ...). VIS
792 is the member's visibility (public, protected, private). FLAGS is
793 a bit set giving additional information about the member (see the
797 add_member_defn (cls
, name
, regexp
, pos
, hash
, var
, sc
, flags
)
809 if (sc
== SC_UNKNOWN
)
811 m
= find_member (cls
, name
, var
, SC_MEMBER
, hash
);
814 m
= find_member (cls
, name
, var
, SC_STATIC
, hash
);
816 m
= add_member (cls
, name
, var
, sc
, hash
);
821 m
= find_member (cls
, name
, var
, sc
, hash
);
823 m
= add_member (cls
, name
, var
, sc
, hash
);
827 cls
->sfilename
= filename
;
829 if (!FILENAME_EQ (cls
->sfilename
, filename
))
830 m
->def_filename
= filename
;
832 m
->def_regexp
= regexp
;
842 /* Add a symbol for a define named NAME to the symbol table.
843 REGEXP is a regular expression matching the define in the source,
844 if it is non-null. POS is the position in the file. */
847 add_define (name
, regexp
, pos
)
851 add_global_defn (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
852 add_global_decl (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
856 /* Add information for the global definition of NAME.
857 REGEXP is a regexp matching the declaration, if non-null. POS is
858 the position in the source where the declaration is found. HASH is
859 a hash code for the parameter list of the member, if it's a
860 function. VAR non-zero means member is a variable or type. SC
861 specifies the type of member (instance member, static, ...). VIS
862 is the member's visibility (public, protected, private). FLAGS is
863 a bit set giving additional information about the member (see the
867 add_global_defn (name
, regexp
, pos
, hash
, var
, sc
, flags
)
878 /* Try to find out for which classes a function is a friend, and add
879 what we know about it to them. */
881 for (i
= 0; i
< TABLE_SIZE
; ++i
)
882 for (sym
= class_table
[i
]; sym
; sym
= sym
->next
)
883 if (sym
!= global_symbols
&& sym
->friends
)
884 if (find_member (sym
, name
, 0, SC_FRIEND
, hash
))
885 add_member_defn (sym
, name
, regexp
, pos
, hash
, 0,
888 /* Add to global symbols. */
889 add_member_defn (global_symbols
, name
, regexp
, pos
, hash
, var
, sc
, flags
);
893 /* Add information for the global declaration of NAME.
894 REGEXP is a regexp matching the declaration, if non-null. POS is
895 the position in the source where the declaration is found. HASH is
896 a hash code for the parameter list of the member, if it's a
897 function. VAR non-zero means member is a variable or type. SC
898 specifies the type of member (instance member, static, ...). VIS
899 is the member's visibility (public, protected, private). FLAGS is
900 a bit set giving additional information about the member (see the
904 add_global_decl (name
, regexp
, pos
, hash
, var
, sc
, flags
)
912 /* Add declaration only if not already declared. Header files must
913 be processed before source files for this to have the right effect.
914 I do not want to handle implicit declarations at the moment. */
916 struct member
*found
;
918 m
= found
= find_member (global_symbols
, name
, var
, sc
, hash
);
920 m
= add_member (global_symbols
, name
, var
, sc
, hash
);
922 /* Definition already seen => probably last declaration implicit.
923 Override. This means that declarations must always be added to
924 the symbol table before definitions. */
927 if (!global_symbols
->filename
928 || !FILENAME_EQ (global_symbols
->filename
, filename
))
929 m
->filename
= filename
;
937 info_cls
= global_symbols
;
943 /* Add a symbol for member NAME to class CLS.
944 VAR non-zero means it's a variable. SC specifies the kind of
945 member. HASH is a hash code for the parameter types of a function.
946 Value is a pointer to the member's structure. */
949 add_member (cls
, name
, var
, sc
, hash
)
956 struct member
*m
= (struct member
*) xmalloc (sizeof *m
+ strlen (name
));
957 struct member
**list
;
960 unsigned name_hash
= 0;
964 strcpy (m
->name
, name
);
965 m
->param_hash
= hash
;
972 m
->def_regexp
= NULL
;
973 m
->def_filename
= NULL
;
976 assert (cls
!= NULL
);
981 list
= &cls
->friends
;
989 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
993 list
= var
? &cls
->vars
: &cls
->fns
;
997 for (s
= name
; *s
; ++s
)
998 name_hash
= (name_hash
<< 1) ^ *s
;
999 i
= name_hash
% TABLE_SIZE
;
1000 m
->anext
= member_table
[i
];
1001 member_table
[i
] = m
;
1004 /* Keep the member list sorted. It's cheaper to do it here than to
1005 sort them in Lisp. */
1006 for (prev
= NULL
, p
= *list
;
1007 p
&& strcmp (name
, p
->name
) > 0;
1008 prev
= p
, p
= p
->next
)
1020 /* Given the root R of a class tree, step through all subclasses
1021 recursively, marking functions as virtual that are declared virtual
1029 struct member
*m
, *m2
;
1031 for (p
= r
->subs
; p
; p
= p
->next
)
1033 for (m
= r
->fns
; m
; m
= m
->next
)
1034 if (HAS_FLAG (m
->flags
, F_VIRTUAL
))
1036 for (m2
= p
->sym
->fns
; m2
; m2
= m2
->next
)
1037 if (m
->param_hash
== m2
->param_hash
&& streq (m
->name
, m2
->name
))
1038 SET_FLAG (m2
->flags
, F_VIRTUAL
);
1041 mark_virtual (p
->sym
);
1046 /* For all roots of the class tree, mark functions as virtual that
1047 are virtual because of a virtual declaration in a base class. */
1050 mark_inherited_virtual ()
1055 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1056 for (r
= class_table
[i
]; r
; r
= r
->next
)
1057 if (r
->supers
== NULL
)
1062 /* Create and return a symbol for a namespace with name NAME. */
1065 make_namespace (name
)
1068 struct sym
*s
= (struct sym
*) xmalloc (sizeof *s
+ strlen (name
));
1069 bzero (s
, sizeof *s
);
1070 strcpy (s
->name
, name
);
1071 s
->next
= all_namespaces
;
1072 s
->namesp
= current_namespace
;
1078 /* Find the symbol for namespace NAME. If not found, add a new symbol
1079 for NAME to all_namespaces. */
1082 find_namespace (name
)
1087 for (p
= all_namespaces
; p
; p
= p
->next
)
1089 if (streq (p
->name
, name
))
1094 for (p2
= p
->namesp_aliases
; p2
; p2
= p2
->next
)
1095 if (streq (p2
->name
, name
))
1103 p
= make_namespace (name
);
1109 /* Register the name NEW_NAME as an alias for namespace OLD_NAME. */
1112 register_namespace_alias (new_name
, old_name
)
1113 char *new_name
, *old_name
;
1115 struct sym
*p
= find_namespace (old_name
);
1118 /* Is it already in the list of aliases? */
1119 for (al
= p
->namesp_aliases
; al
; al
= al
->next
)
1120 if (streq (new_name
, p
->name
))
1123 al
= (struct alias
*) xmalloc (sizeof *al
+ strlen (new_name
));
1124 strcpy (al
->name
, new_name
);
1125 al
->next
= p
->namesp_aliases
;
1126 p
->namesp_aliases
= al
;
1130 /* Enter namespace with name NAME. */
1133 enter_namespace (name
)
1136 struct sym
*p
= find_namespace (name
);
1138 if (namespace_sp
== namespace_stack_size
)
1140 int size
= max (10, 2 * namespace_stack_size
);
1141 namespace_stack
= (struct sym
**) xrealloc (namespace_stack
, size
);
1142 namespace_stack_size
= size
;
1145 namespace_stack
[namespace_sp
++] = current_namespace
;
1146 current_namespace
= p
;
1150 /* Leave the current namespace. */
1155 assert (namespace_sp
> 0);
1156 current_namespace
= namespace_stack
[--namespace_sp
];
1161 /***********************************************************************
1162 Writing the Output File
1163 ***********************************************************************/
1165 /* Write string S to the output file FP in a Lisp-readable form.
1166 If S is null, write out `()'. */
1168 #define PUTSTR(s, fp) \
1185 /* A dynamically allocated buffer for constructing a scope name. */
1188 int scope_buffer_size
;
1189 int scope_buffer_len
;
1192 /* Make sure scope_buffer has enough room to add LEN chars to it. */
1195 ensure_scope_buffer_room (len
)
1198 if (scope_buffer_len
+ len
>= scope_buffer_size
)
1200 int new_size
= max (2 * scope_buffer_size
, scope_buffer_len
+ len
);
1201 scope_buffer
= (char *) xrealloc (new_size
);
1202 scope_buffer_size
= new_size
;
1207 /* Recursively add the scope names of symbol P and the scopes of its
1208 namespaces to scope_buffer. Value is a pointer to the complete
1209 scope name constructed. */
1218 sym_scope_1 (p
->namesp
);
1222 ensure_scope_buffer_room (3);
1223 strcat (scope_buffer
, "::");
1224 scope_buffer_len
+= 2;
1227 len
= strlen (p
->name
);
1228 ensure_scope_buffer_room (len
+ 1);
1229 strcat (scope_buffer
, p
->name
);
1230 scope_buffer_len
+= len
;
1232 if (HAS_FLAG (p
->flags
, F_TEMPLATE
))
1234 ensure_scope_buffer_room (3);
1235 strcat (scope_buffer
, "<>");
1236 scope_buffer_len
+= 2;
1239 return scope_buffer
;
1243 /* Return the scope of symbol P in printed representation, i.e.
1244 as it would appear in a C*+ source file. */
1252 scope_buffer_size
= 1024;
1253 scope_buffer
= (char *) xmalloc (scope_buffer_size
);
1256 *scope_buffer
= '\0';
1257 scope_buffer_len
= 0;
1260 sym_scope_1 (p
->namesp
);
1262 return scope_buffer
;
1266 /* Dump the list of members M to file FP. Value is the length of the
1270 dump_members (fp
, m
)
1278 for (n
= 0; m
; m
= m
->next
, ++n
)
1280 fputs (MEMBER_STRUCT
, fp
);
1281 PUTSTR (m
->name
, fp
);
1282 PUTSTR (NULL
, fp
); /* FIXME? scope for globals */
1283 fprintf (fp
, "%u ", (unsigned) m
->flags
);
1284 PUTSTR (m
->filename
, fp
);
1285 PUTSTR (m
->regexp
, fp
);
1286 fprintf (fp
, "%u ", (unsigned) m
->pos
);
1287 fprintf (fp
, "%u ", (unsigned) m
->vis
);
1289 PUTSTR (m
->def_filename
, fp
);
1290 PUTSTR (m
->def_regexp
, fp
);
1291 fprintf (fp
, "%u", (unsigned) m
->def_pos
);
1302 /* Dump class ROOT to stream FP. */
1309 fputs (CLASS_STRUCT
, fp
);
1310 PUTSTR (root
->name
, fp
);
1312 /* Print scope, if any. */
1314 PUTSTR (sym_scope (root
), fp
);
1319 fprintf (fp
, "%u", root
->flags
);
1320 PUTSTR (root
->filename
, fp
);
1321 PUTSTR (root
->regexp
, fp
);
1322 fprintf (fp
, "%u", (unsigned) root
->pos
);
1323 PUTSTR (root
->sfilename
, fp
);
1329 /* Dump class ROOT and its subclasses to file FP. Value is the
1330 number of classes written. */
1333 dump_tree (fp
, root
)
1340 dump_sym (fp
, root
);
1350 for (lk
= root
->subs
; lk
; lk
= lk
->next
)
1352 fputs (TREE_STRUCT
, fp
);
1353 n
+= dump_tree (fp
, lk
->sym
);
1359 dump_members (fp
, root
->vars
);
1360 n
+= dump_members (fp
, root
->fns
);
1361 dump_members (fp
, root
->static_vars
);
1362 n
+= dump_members (fp
, root
->static_fns
);
1363 n
+= dump_members (fp
, root
->friends
);
1364 dump_members (fp
, root
->types
);
1379 /* Dump the entire class tree to file FP. */
1388 /* Output file header containing version string, command line
1392 fputs (TREE_HEADER_STRUCT
, fp
);
1393 PUTSTR (EBROWSE_FILE_VERSION
, fp
);
1406 /* Mark functions as virtual that are so because of functions
1407 declared virtual in base classes. */
1408 mark_inherited_virtual ();
1410 /* Dump the roots of the graph. */
1411 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1412 for (r
= class_table
[i
]; r
; r
= r
->next
)
1415 fputs (TREE_STRUCT
, fp
);
1416 n
+= dump_tree (fp
, r
);
1426 /***********************************************************************
1428 ***********************************************************************/
1431 #define INCREMENT_LINENO \
1433 if (f_very_verbose) \
1436 printf ("%d:\n", yyline); \
1442 #define INCREMENT_LINENO ++yyline
1445 /* Define two macros for accessing the input buffer (current input
1446 file). GET(C) sets C to the next input character and advances the
1447 input pointer. UNGET retracts the input pointer. */
1449 #define GET(C) ((C) = *in++)
1450 #define UNGET() (--in)
1453 /* Process a preprocessor line. Value is the next character from the
1454 input buffer not consumed. */
1463 /* Skip over white space. The `#' has been consumed already. */
1464 while (WHITEP (GET (c
)))
1467 /* Read the preprocessor command (if any). */
1474 /* Is it a `define'? */
1477 if (*yytext
&& streq (yytext
, "define"))
1492 char *regexp
= matching_regexp ();
1493 int pos
= BUFFER_POS ();
1494 add_define (yytext
, regexp
, pos
);
1498 while (c
&& (c
!= '\n' || in_comment
))
1502 else if (c
== '/' && !in_comment
)
1507 else if (c
== '*' && in_comment
)
1523 /* Value is the next token from the input buffer. */
1534 while (WHITEP (GET (c
)))
1556 /* String and character constants. */
1559 while (GET (c
) && c
!= end_char
)
1564 /* Escape sequences. */
1567 if (end_char
== '\'')
1568 yyerror ("EOF in character constant");
1570 yyerror ("EOF in string constant");
1587 /* Hexadecimal escape sequence. */
1589 for (i
= 0; i
< 2; ++i
)
1593 if (c
>= '0' && c
<= '7')
1595 else if (c
>= 'a' && c
<= 'f')
1597 else if (c
>= 'A' && c
<= 'F')
1610 /* Octal escape sequence. */
1612 for (i
= 0; i
< 3; ++i
)
1616 if (c
>= '0' && c
<= '7')
1633 if (end_char
== '\'')
1634 yyerror ("newline in character constant");
1636 yyerror ("newline in string constant");
1646 return end_char
== '\'' ? CCHAR
: CSTRING
;
1648 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1649 case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
1650 case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
1651 case 'v': case 'w': case 'x': case 'y': case 'z':
1652 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
1653 case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
1654 case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
1655 case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_':
1657 /* Identifier and keywords. */
1664 while (IDENTP (GET (*p
)))
1666 hash
= (hash
<< 1) ^ *p
++;
1667 if (p
== yytext_end
- 1)
1669 int size
= yytext_end
- yytext
;
1670 yytext
= (char *) xrealloc (yytext
, 2 * size
);
1671 yytext_end
= yytext
+ 2 * size
;
1672 p
= yytext
+ size
- 1;
1679 for (k
= keyword_table
[hash
% KEYWORD_TABLE_SIZE
]; k
; k
= k
->next
)
1680 if (streq (k
->name
, yytext
))
1687 /* C and C++ comments, '/' and '/='. */
1715 while (GET (c
) && c
!= '\n')
1790 yyerror ("invalid token '..' ('...' assumed)");
1794 else if (!DIGITP (c
))
1848 c
= process_pp_line ();
1853 case '(': case ')': case '[': case ']': case '{': case '}':
1854 case ';': case ',': case '?': case '~':
1860 if (GET (c
) == 'x' || c
== 'X')
1865 yyival
= yyival
* 16 + c
- '0';
1866 else if (c
>= 'a' && c
<= 'f')
1867 yyival
= yyival
* 16 + c
- 'a' + 10;
1868 else if (c
>= 'A' && c
<= 'F')
1869 yyival
= yyival
* 16 + c
- 'A' + 10;
1879 while (c
>= '0' && c
<= '7')
1881 yyival
= (yyival
<< 3) + c
- '0';
1886 /* Integer suffixes. */
1892 case '1': case '2': case '3': case '4': case '5': case '6':
1893 case '7': case '8': case '9':
1894 /* Integer or floating constant, part before '.'. */
1897 while (GET (c
) && DIGITP (c
))
1898 yyival
= 10 * yyival
+ c
- '0';
1904 /* Digits following '.'. */
1908 /* Optional exponent. */
1909 if (c
== 'E' || c
== 'e')
1911 if (GET (c
) == '-' || c
== '+')
1918 /* Optional type suffixes. */
1931 /* Value is the string from the start of the line to the current
1932 position in the input buffer, or maybe a bit more if that string is
1933 shorter than min_regexp. */
1941 static char *buffer
, *end_buf
;
1948 buffer
= (char *) xmalloc (max_regexp
);
1949 end_buf
= &buffer
[max_regexp
] - 1;
1952 /* Scan back to previous newline of buffer start. */
1953 for (p
= in
- 1; p
> inbuffer
&& *p
!= '\n'; --p
)
1958 while (in
- p
< min_regexp
&& p
> inbuffer
)
1960 /* Line probably not significant enough */
1961 for (--p
; p
>= inbuffer
&& *p
!= '\n'; --p
)
1968 /* Copy from end to make sure significant portions are included.
1969 This implies that in the browser a regular expressing of the form
1970 `^.*{regexp}' has to be used. */
1971 for (s
= end_buf
- 1, t
= in
; s
> buffer
&& t
> p
;)
1979 *(end_buf
- 1) = '\0';
1984 /* Return a printable representation of token T. */
1994 case CSTRING
: return "string constant";
1995 case CCHAR
: return "char constant";
1996 case CINT
: return "int constant";
1997 case CFLOAT
: return "floating constant";
1998 case ELLIPSIS
: return "...";
1999 case LSHIFTASGN
: return "<<=";
2000 case RSHIFTASGN
: return ">>=";
2001 case ARROWSTAR
: return "->*";
2002 case IDENT
: return "identifier";
2003 case DIVASGN
: return "/=";
2004 case INC
: return "++";
2005 case ADDASGN
: return "+=";
2006 case DEC
: return "--";
2007 case ARROW
: return "->";
2008 case SUBASGN
: return "-=";
2009 case MULASGN
: return "*=";
2010 case MODASGN
: return "%=";
2011 case LOR
: return "||";
2012 case ORASGN
: return "|=";
2013 case LAND
: return "&&";
2014 case ANDASGN
: return "&=";
2015 case XORASGN
: return "^=";
2016 case POINTSTAR
: return ".*";
2017 case DCOLON
: return "::";
2018 case EQ
: return "==";
2019 case NE
: return "!=";
2020 case LE
: return "<=";
2021 case LSHIFT
: return "<<";
2022 case GE
: return ">=";
2023 case RSHIFT
: return ">>";
2024 case ASM
: return "asm";
2025 case AUTO
: return "auto";
2026 case BREAK
: return "break";
2027 case CASE
: return "case";
2028 case CATCH
: return "catch";
2029 case CHAR
: return "char";
2030 case CLASS
: return "class";
2031 case CONST
: return "const";
2032 case CONTINUE
: return "continue";
2033 case DEFAULT
: return "default";
2034 case DELETE
: return "delete";
2035 case DO
: return "do";
2036 case DOUBLE
: return "double";
2037 case ELSE
: return "else";
2038 case ENUM
: return "enum";
2039 case EXTERN
: return "extern";
2040 case FLOAT
: return "float";
2041 case FOR
: return "for";
2042 case FRIEND
: return "friend";
2043 case GOTO
: return "goto";
2044 case IF
: return "if";
2045 case T_INLINE
: return "inline";
2046 case INT
: return "int";
2047 case LONG
: return "long";
2048 case NEW
: return "new";
2049 case OPERATOR
: return "operator";
2050 case PRIVATE
: return "private";
2051 case PROTECTED
: return "protected";
2052 case PUBLIC
: return "public";
2053 case REGISTER
: return "register";
2054 case RETURN
: return "return";
2055 case SHORT
: return "short";
2056 case SIGNED
: return "signed";
2057 case SIZEOF
: return "sizeof";
2058 case STATIC
: return "static";
2059 case STRUCT
: return "struct";
2060 case SWITCH
: return "switch";
2061 case TEMPLATE
: return "template";
2062 case THIS
: return "this";
2063 case THROW
: return "throw";
2064 case TRY
: return "try";
2065 case TYPEDEF
: return "typedef";
2066 case UNION
: return "union";
2067 case UNSIGNED
: return "unsigned";
2068 case VIRTUAL
: return "virtual";
2069 case VOID
: return "void";
2070 case VOLATILE
: return "volatile";
2071 case WHILE
: return "while";
2072 case YYEOF
: return "EOF";
2082 /* Reinitialize the scanner for a new input file. */
2093 yytext
= (char *) xmalloc (size
* sizeof *yytext
);
2094 yytext_end
= yytext
+ size
;
2099 /* Insert a keyword NAME with token value TK into the keyword hash
2103 insert_keyword (name
, tk
)
2109 struct kw
*k
= (struct kw
*) xmalloc (sizeof *k
);
2111 for (s
= name
; *s
; ++s
)
2114 h
%= KEYWORD_TABLE_SIZE
;
2117 k
->next
= keyword_table
[h
];
2118 keyword_table
[h
] = k
;
2122 /* Initialize the scanner for the first file. This sets up the
2123 character class vectors and fills the keyword hash table. */
2130 /* Allocate the input buffer */
2131 inbuffer_size
= READ_CHUNK_SIZE
+ 1;
2132 inbuffer
= in
= (char *) xmalloc (inbuffer_size
);
2135 /* Set up character class vectors. */
2136 for (i
= 0; i
< sizeof is_ident
; ++i
)
2138 if (i
== '_' || isalnum (i
))
2141 if (i
>= '0' && i
<= '9')
2144 if (i
== ' ' || i
== '\t' || i
== '\f' || i
== '\v')
2148 /* Fill keyword hash table. */
2149 insert_keyword ("and", LAND
);
2150 insert_keyword ("and_eq", ANDASGN
);
2151 insert_keyword ("asm", ASM
);
2152 insert_keyword ("auto", AUTO
);
2153 insert_keyword ("bitand", '&');
2154 insert_keyword ("bitor", '|');
2155 insert_keyword ("bool", BOOL
);
2156 insert_keyword ("break", BREAK
);
2157 insert_keyword ("case", CASE
);
2158 insert_keyword ("catch", CATCH
);
2159 insert_keyword ("char", CHAR
);
2160 insert_keyword ("class", CLASS
);
2161 insert_keyword ("compl", '~');
2162 insert_keyword ("const", CONST
);
2163 insert_keyword ("const_cast", CONST_CAST
);
2164 insert_keyword ("continue", CONTINUE
);
2165 insert_keyword ("default", DEFAULT
);
2166 insert_keyword ("delete", DELETE
);
2167 insert_keyword ("do", DO
);
2168 insert_keyword ("double", DOUBLE
);
2169 insert_keyword ("dynamic_cast", DYNAMIC_CAST
);
2170 insert_keyword ("else", ELSE
);
2171 insert_keyword ("enum", ENUM
);
2172 insert_keyword ("explicit", EXPLICIT
);
2173 insert_keyword ("extern", EXTERN
);
2174 insert_keyword ("false", FALSE
);
2175 insert_keyword ("float", FLOAT
);
2176 insert_keyword ("for", FOR
);
2177 insert_keyword ("friend", FRIEND
);
2178 insert_keyword ("goto", GOTO
);
2179 insert_keyword ("if", IF
);
2180 insert_keyword ("inline", T_INLINE
);
2181 insert_keyword ("int", INT
);
2182 insert_keyword ("long", LONG
);
2183 insert_keyword ("mutable", MUTABLE
);
2184 insert_keyword ("namespace", NAMESPACE
);
2185 insert_keyword ("new", NEW
);
2186 insert_keyword ("not", '!');
2187 insert_keyword ("not_eq", NE
);
2188 insert_keyword ("operator", OPERATOR
);
2189 insert_keyword ("or", LOR
);
2190 insert_keyword ("or_eq", ORASGN
);
2191 insert_keyword ("private", PRIVATE
);
2192 insert_keyword ("protected", PROTECTED
);
2193 insert_keyword ("public", PUBLIC
);
2194 insert_keyword ("register", REGISTER
);
2195 insert_keyword ("reinterpret_cast", REINTERPRET_CAST
);
2196 insert_keyword ("return", RETURN
);
2197 insert_keyword ("short", SHORT
);
2198 insert_keyword ("signed", SIGNED
);
2199 insert_keyword ("sizeof", SIZEOF
);
2200 insert_keyword ("static", STATIC
);
2201 insert_keyword ("static_cast", STATIC_CAST
);
2202 insert_keyword ("struct", STRUCT
);
2203 insert_keyword ("switch", SWITCH
);
2204 insert_keyword ("template", TEMPLATE
);
2205 insert_keyword ("this", THIS
);
2206 insert_keyword ("throw", THROW
);
2207 insert_keyword ("true", TRUE
);
2208 insert_keyword ("try", TRY
);
2209 insert_keyword ("typedef", TYPEDEF
);
2210 insert_keyword ("typeid", TYPEID
);
2211 insert_keyword ("typename", TYPENAME
);
2212 insert_keyword ("union", UNION
);
2213 insert_keyword ("unsigned", UNSIGNED
);
2214 insert_keyword ("using", USING
);
2215 insert_keyword ("virtual", VIRTUAL
);
2216 insert_keyword ("void", VOID
);
2217 insert_keyword ("volatile", VOLATILE
);
2218 insert_keyword ("wchar_t", WCHAR
);
2219 insert_keyword ("while", WHILE
);
2220 insert_keyword ("xor", '^');
2221 insert_keyword ("xor_eq", XORASGN
);
2226 /***********************************************************************
2228 ***********************************************************************/
2230 /* Match the current lookahead token and set it to the next token. */
2232 #define MATCH() (tk = yylex ())
2234 /* Return the lookahead token. If current lookahead token is cleared,
2235 read a new token. */
2237 #define LA1 (tk == -1 ? (tk = yylex ()) : tk)
2239 /* Is the current lookahead equal to the token T? */
2241 #define LOOKING_AT(T) (tk == (T))
2243 /* Is the current lookahead one of T1 or T2? */
2245 #define LOOKING_AT2(T1, T2) (tk == (T1) || tk == (T2))
2247 /* Is the current lookahead one of T1, T2 or T3? */
2249 #define LOOKING_AT3(T1, T2, T3) (tk == (T1) || tk == (T2) || tk == (T3))
2251 /* Is the current lookahead one of T1...T4? */
2253 #define LOOKING_AT4(T1, T2, T3, T4) \
2254 (tk == (T1) || tk == (T2) || tk == (T3) || tk == (T4))
2256 /* Match token T if current lookahead is T. */
2258 #define MATCH_IF(T) if (LOOKING_AT (T)) MATCH (); else ((void) 0)
2260 /* Skip to matching token if current token is T. */
2262 #define SKIP_MATCHING_IF(T) \
2263 if (LOOKING_AT (T)) skip_matching (); else ((void) 0)
2266 /* Skip forward until a given token TOKEN or YYEOF is seen and return
2267 the current lookahead token after skipping. */
2273 while (!LOOKING_AT2 (YYEOF
, token
))
2279 /* Skip over pairs of tokens (parentheses, square brackets,
2280 angle brackets, curly brackets) matching the current lookahead. */
2311 if (LOOKING_AT (open
))
2313 else if (LOOKING_AT (close
))
2315 else if (LOOKING_AT (YYEOF
))
2326 /* Re-initialize the parser by resetting the lookahead token. */
2335 /* Parse a parameter list, including the const-specifier,
2336 pure-specifier, and throw-list that may follow a parameter list.
2337 Return in FLAGS what was seen following the parameter list.
2338 Returns a hash code for the parameter types. This value is used to
2339 distinguish between overloaded functions. */
2348 while (!LOOKING_AT2 (YYEOF
, ')'))
2352 /* Skip over grouping parens or parameter lists in parameter
2358 /* Next parameter. */
2364 /* Ignore the scope part of types, if any. This is because
2365 some types need scopes when defined outside of a class body,
2366 and don't need them inside the class body. This means that
2367 we have to look for the last IDENT in a sequence of
2368 IDENT::IDENT::... */
2373 unsigned ident_type_hash
= 0;
2375 parse_qualified_param_ident_or_type (&s
);
2377 ident_type_hash
= (ident_type_hash
<< 1) ^ *s
;
2378 hash
= (hash
<< 1) ^ ident_type_hash
;
2386 /* This distinction is made to make `func (void)' equivalent
2390 if (!LOOKING_AT (')'))
2391 hash
= (hash
<< 1) ^ VOID
;
2394 case BOOL
: case CHAR
: case CLASS
: case CONST
:
2395 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2396 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2397 case UNION
: case UNSIGNED
: case VOLATILE
: case WCHAR
:
2400 hash
= (hash
<< 1) ^ LA1
;
2404 case '*': case '&': case '[': case ']':
2405 hash
= (hash
<< 1) ^ LA1
;
2415 if (LOOKING_AT (')'))
2419 if (LOOKING_AT (CONST
))
2421 /* We can overload the same function on `const' */
2422 hash
= (hash
<< 1) ^ CONST
;
2423 SET_FLAG (*flags
, F_CONST
);
2427 if (LOOKING_AT (THROW
))
2430 SKIP_MATCHING_IF ('(');
2431 SET_FLAG (*flags
, F_THROW
);
2434 if (LOOKING_AT ('='))
2437 if (LOOKING_AT (CINT
) && yyival
== 0)
2440 SET_FLAG (*flags
, F_PURE
);
2449 /* Print position info to stdout. */
2454 if (info_position
>= 0 && BUFFER_POS () <= info_position
)
2456 printf ("(\"%s\" \"%s\" \"%s\" %d)\n",
2457 info_cls
->name
, sym_scope (info_cls
),
2458 info_member
->name
, info_where
);
2462 /* Parse a member declaration within the class body of CLS. VIS is
2463 the access specifier for the member (private, protected,
2473 char *regexp
= NULL
;
2484 while (!LOOKING_AT4 (';', '{', '}', YYEOF
))
2492 /* A function or class may follow. */
2495 SET_FLAG (flags
, F_TEMPLATE
);
2496 /* Skip over template argument list */
2497 SKIP_MATCHING_IF ('<');
2501 SET_FLAG (flags
, F_EXPLICIT
);
2505 SET_FLAG (flags
, F_MUTABLE
);
2509 SET_FLAG (flags
, F_INLINE
);
2513 SET_FLAG (flags
, F_VIRTUAL
);
2542 /* Remember IDENTS seen so far. Among these will be the member
2544 id
= (char *) alloca (strlen (yytext
) + 2);
2548 strcpy (id
+ 1, yytext
);
2551 strcpy (id
, yytext
);
2556 id
= operator_name (&sc
);
2560 /* Most probably the beginning of a parameter list. */
2566 if (!(is_constructor
= streq (id
, cls
->name
)))
2567 regexp
= matching_regexp ();
2572 pos
= BUFFER_POS ();
2573 hash
= parm_list (&flags
);
2576 regexp
= matching_regexp ();
2578 if (id
&& cls
!= NULL
)
2579 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, flags
);
2581 while (!LOOKING_AT3 (';', '{', YYEOF
))
2584 if (LOOKING_AT ('{') && id
&& cls
)
2585 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0, sc
, flags
);
2591 case STRUCT
: case UNION
: case CLASS
:
2598 /* More than one ident here to allow for MS-DOS specialties
2599 like `_export class' etc. The last IDENT seen counts
2600 as the class name. */
2601 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
2603 if (LOOKING_AT (IDENT
))
2608 if (LOOKING_AT2 (':', '{'))
2609 class_definition (anonymous
? NULL
: cls
, class_tag
, flags
, 1);
2614 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
2615 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
2616 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
2625 if (LOOKING_AT (';'))
2627 /* The end of a member variable, a friend declaration or an access
2628 declaration. We don't want to add friend classes as members. */
2629 if (id
&& sc
!= SC_FRIEND
&& cls
)
2631 regexp
= matching_regexp ();
2632 pos
= BUFFER_POS ();
2636 if (type_seen
|| !paren_seen
)
2637 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2639 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, 0);
2646 else if (LOOKING_AT ('{'))
2649 if (sc
== SC_TYPE
&& id
&& cls
)
2651 regexp
= matching_regexp ();
2652 pos
= BUFFER_POS ();
2656 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2657 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, sc
, 0);
2667 /* Parse the body of class CLS. TAG is the tag of the class (struct,
2671 class_body (cls
, tag
)
2675 int vis
= tag
== CLASS
? PRIVATE
: PUBLIC
;
2678 while (!LOOKING_AT2 (YYEOF
, '}'))
2682 case PRIVATE
: case PROTECTED
: case PUBLIC
:
2686 if (LOOKING_AT (':'))
2693 /* Probably conditional compilation for inheritance list.
2694 We don't known whether there comes more of this.
2695 This is only a crude fix that works most of the time. */
2700 while (LOOKING_AT2 (IDENT
, ',')
2701 || LOOKING_AT3 (PUBLIC
, PROTECTED
, PRIVATE
));
2710 /* Try to synchronize */
2711 case CHAR
: case CLASS
: case CONST
:
2712 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2713 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2714 case UNION
: case UNSIGNED
: case VOID
: case VOLATILE
:
2715 case TYPEDEF
: case STATIC
: case T_INLINE
: case FRIEND
:
2716 case VIRTUAL
: case TEMPLATE
: case IDENT
: case '~':
2717 case BOOL
: case WCHAR
: case EXPLICIT
: case MUTABLE
:
2729 /* Parse a qualified identifier. Current lookahead is IDENT. A
2730 qualified ident has the form `X<..>::Y<...>::T<...>. Returns a
2731 symbol for that class. */
2736 struct sym
*last_class
= NULL
;
2738 while (LOOKING_AT (IDENT
))
2740 last_class
= add_sym (yytext
, last_class
);
2743 if (LOOKING_AT ('<'))
2746 SET_FLAG (last_class
->flags
, F_TEMPLATE
);
2749 if (!LOOKING_AT (DCOLON
))
2759 /* Parse an operator name. Add the `static' flag to *SC if an
2760 implicitly static operator has been parsed. Value is a pointer to
2761 a static buffer holding the constructed operator name string. */
2767 static int id_size
= 0;
2768 static char *id
= NULL
;
2774 if (LOOKING_AT2 (NEW
, DELETE
))
2776 /* `new' and `delete' are implicitly static. */
2777 if (*sc
!= SC_FRIEND
)
2780 s
= token_string (LA1
);
2783 len
= strlen (s
) + 10;
2786 int new_size
= max (len
, 2 * id_size
);
2787 id
= (char *) xrealloc (id
, new_size
);
2792 /* Vector new or delete? */
2793 if (LOOKING_AT ('['))
2798 if (LOOKING_AT (']'))
2807 int tokens_matched
= 0;
2812 int new_size
= max (len
, 2 * id_size
);
2813 id
= (char *) xrealloc (id
, new_size
);
2816 strcpy (id
, "operator");
2818 /* Beware access declarations of the form "X::f;" Beware of
2819 `operator () ()'. Yet another difficulty is found in
2820 GCC 2.95's STL: `operator == __STL_NULL_TMPL_ARGS (...'. */
2821 while (!(LOOKING_AT ('(') && tokens_matched
)
2822 && !LOOKING_AT2 (';', YYEOF
))
2824 s
= token_string (LA1
);
2825 len
+= strlen (s
) + 2;
2828 int new_size
= max (len
, 2 * id_size
);
2829 id
= (char *) xrealloc (id
, new_size
);
2833 if (*s
!= ')' && *s
!= ']')
2838 /* If this is a simple operator like `+', stop now. */
2839 if (!isalpha (*s
) && *s
!= '(' && *s
!= '[')
2850 /* This one consumes the last IDENT of a qualified member name like
2851 `X::Y::z'. This IDENT is returned in LAST_ID. Value if the
2852 symbol structure for the ident. */
2855 parse_qualified_ident_or_type (last_id
)
2858 struct sym
*cls
= NULL
;
2859 static char *id
= NULL
;
2860 static int id_size
= 0;
2862 while (LOOKING_AT (IDENT
))
2864 int len
= strlen (yytext
) + 1;
2867 id
= (char *) xrealloc (id
, len
);
2870 strcpy (id
, yytext
);
2874 SKIP_MATCHING_IF ('<');
2876 if (LOOKING_AT (DCOLON
))
2878 cls
= add_sym (id
, cls
);
2890 /* This one consumes the last IDENT of a qualified member name like
2891 `X::Y::z'. This IDENT is returned in LAST_ID. Value if the
2892 symbol structure for the ident. */
2895 parse_qualified_param_ident_or_type (last_id
)
2898 struct sym
*cls
= NULL
;
2899 static char *id
= NULL
;
2900 static int id_size
= 0;
2902 while (LOOKING_AT (IDENT
))
2904 int len
= strlen (yytext
) + 1;
2907 id
= (char *) xrealloc (id
, len
);
2910 strcpy (id
, yytext
);
2914 SKIP_MATCHING_IF ('<');
2916 if (LOOKING_AT (DCOLON
))
2918 cls
= add_sym (id
, cls
);
2928 /* Parse a class definition.
2930 CONTAINING is the class containing the class being parsed or null.
2931 This may also be null if NESTED != 0 if the containing class is
2932 anonymous. TAG is the tag of the class (struct, union, class).
2933 NESTED is non-zero if we are parsing a nested class.
2935 Current lookahead is the class name. */
2938 class_definition (containing
, tag
, flags
, nested
)
2939 struct sym
*containing
;
2944 struct sym
*current
;
2945 struct sym
*base_class
;
2947 /* Set CURRENT to null if no entry has to be made for the class
2948 parsed. This is the case for certain command line flag
2950 if ((tag
!= CLASS
&& !f_structs
) || (nested
&& !f_nested_classes
))
2954 current
= add_sym (yytext
, containing
);
2955 current
->pos
= BUFFER_POS ();
2956 current
->regexp
= matching_regexp ();
2957 current
->filename
= filename
;
2958 current
->flags
= flags
;
2961 /* If at ':', base class list follows. */
2962 if (LOOKING_AT (':'))
2971 case VIRTUAL
: case PUBLIC
: case PROTECTED
: case PRIVATE
:
2976 base_class
= parse_classname ();
2977 if (base_class
&& current
&& base_class
!= current
)
2978 add_link (base_class
, current
);
2981 /* The `,' between base classes or the end of the base
2982 class list. Add the previously found base class.
2983 It's done this way to skip over sequences of
2984 `A::B::C' until we reach the end.
2986 FIXME: it is now possible to handle `class X : public B::X'
2987 because we have enough information. */
2993 /* A syntax error, possibly due to preprocessor constructs
2999 class A : private B.
3001 MATCH until we see something like `;' or `{'. */
3002 while (!LOOKING_AT3 (';', YYEOF
, '{'))
3013 /* Parse the class body if there is one. */
3014 if (LOOKING_AT ('{'))
3016 if (tag
!= CLASS
&& !f_structs
)
3021 class_body (current
, tag
);
3023 if (LOOKING_AT ('}'))
3026 if (LOOKING_AT (';') && !nested
)
3034 /* Parse a declaration. */
3041 struct sym
*cls
= NULL
;
3042 char *regexp
= NULL
;
3048 while (!LOOKING_AT3 (';', '{', YYEOF
))
3071 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
3072 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
3073 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
3077 case CLASS
: case STRUCT
: case UNION
:
3078 /* This is for the case `STARTWRAP class X : ...' or
3079 `declare (X, Y)\n class A : ...'. */
3084 /* Assumed to be the start of an initialization in this context.
3085 Skip over everything up to ';'. */
3090 id
= operator_name (&sc
);
3094 SET_FLAG (flags
, F_INLINE
);
3100 if (LOOKING_AT (IDENT
))
3102 id
= (char *) alloca (strlen (yytext
) + 2);
3104 strcpy (id
+ 1, yytext
);
3110 cls
= parse_qualified_ident_or_type (&id
);
3114 /* Most probably the beginning of a parameter list. */
3121 if (!(is_constructor
= streq (id
, cls
->name
)))
3122 regexp
= matching_regexp ();
3127 pos
= BUFFER_POS ();
3128 hash
= parm_list (&flags
);
3131 regexp
= matching_regexp ();
3134 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0,
3139 /* This may be a C functions, but also a macro
3140 call of the form `declare (A, B)' --- such macros
3141 can be found in some class libraries. */
3146 regexp
= matching_regexp ();
3147 pos
= BUFFER_POS ();
3148 hash
= parm_list (&flags
);
3149 add_global_decl (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3152 /* This is for the case that the function really is
3153 a macro with no `;' following it. If a CLASS directly
3154 follows, we would miss it otherwise. */
3155 if (LOOKING_AT3 (CLASS
, STRUCT
, UNION
))
3159 while (!LOOKING_AT3 (';', '{', YYEOF
))
3162 if (!cls
&& id
&& LOOKING_AT ('{'))
3163 add_global_defn (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3169 if (LOOKING_AT (';'))
3171 /* The end of a member variable or of an access declaration
3172 `X::f'. To distinguish between them we have to know whether
3173 type information has been seen. */
3176 char *regexp
= matching_regexp ();
3177 int pos
= BUFFER_POS ();
3180 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, SC_UNKNOWN
, flags
);
3182 add_global_defn (id
, regexp
, pos
, 0, 1, sc
, flags
);
3188 else if (LOOKING_AT ('{'))
3190 if (sc
== SC_TYPE
&& id
)
3192 /* A named enumeration. */
3193 regexp
= matching_regexp ();
3194 pos
= BUFFER_POS ();
3195 add_global_defn (id
, regexp
, pos
, 0, 1, sc
, flags
);
3204 /* Parse a list of top-level declarations/definitions. START_FLAGS
3205 says in which context we are parsing. If it is F_EXTERNC, we are
3206 parsing in an `extern "C"' block. Value is 1 if EOF is reached, 0
3210 globals (start_flags
)
3215 int flags
= start_flags
;
3227 if (LOOKING_AT (IDENT
))
3229 char *namespace_name
3230 = (char *) alloca (strlen (yytext
) + 1);
3231 strcpy (namespace_name
, yytext
);
3234 if (LOOKING_AT ('='))
3236 if (skip_to (';') == ';')
3238 register_namespace_alias (namespace_name
, yytext
);
3240 else if (LOOKING_AT ('{'))
3243 enter_namespace (namespace_name
);
3254 if (LOOKING_AT (CSTRING
) && *string_start
== 'C'
3255 && *(string_start
+ 1) == '"')
3257 /* This is `extern "C"'. */
3260 if (LOOKING_AT ('{'))
3263 globals (F_EXTERNC
);
3267 SET_FLAG (flags
, F_EXTERNC
);
3273 SKIP_MATCHING_IF ('<');
3274 SET_FLAG (flags
, F_TEMPLATE
);
3277 case CLASS
: case STRUCT
: case UNION
:
3282 /* More than one ident here to allow for MS-DOS and OS/2
3283 specialties like `far', `_Export' etc. Some C++ libs
3284 have constructs like `_OS_DLLIMPORT(_OS_CLIENT)' in front
3285 of the class name. */
3286 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
3288 if (LOOKING_AT (IDENT
))
3293 /* Don't add anonymous unions. */
3294 if (LOOKING_AT2 (':', '{') && !anonymous
)
3295 class_definition (NULL
, class_tk
, flags
, 0);
3298 if (skip_to (';') == ';')
3302 flags
= start_flags
;
3312 declaration (flags
);
3313 flags
= start_flags
;
3318 yyerror ("parse error");
3323 /* Parse the current input file. */
3328 while (globals (0) == 0)
3334 /***********************************************************************
3336 ***********************************************************************/
3338 /* Add the list of paths PATH_LIST to the current search path for
3342 add_search_path (path_list
)
3347 char *start
= path_list
;
3348 struct search_path
*p
;
3350 while (*path_list
&& *path_list
!= PATH_LIST_SEPARATOR
)
3353 p
= (struct search_path
*) xmalloc (sizeof *p
);
3354 p
->path
= (char *) xmalloc (path_list
- start
+ 1);
3355 memcpy (p
->path
, start
, path_list
- start
);
3356 p
->path
[path_list
- start
] = '\0';
3359 if (search_path_tail
)
3361 search_path_tail
->next
= p
;
3362 search_path_tail
= p
;
3365 search_path
= search_path_tail
= p
;
3367 while (*path_list
== PATH_LIST_SEPARATOR
)
3373 /* Open FILE and return a file handle for it, or -1 if FILE cannot be
3374 opened. Try to find FILE in search_path first, then try the
3375 unchanged file name. */
3382 static char *buffer
;
3383 static int buffer_size
;
3384 struct search_path
*path
;
3385 int flen
= strlen (file
) + 1; /* +1 for the slash */
3387 filename
= xstrdup (file
);
3389 for (path
= search_path
; path
&& fp
== NULL
; path
= path
->next
)
3391 int len
= strlen (path
->path
) + flen
;
3393 if (len
+ 1 >= buffer_size
)
3395 buffer_size
= max (len
+ 1, 2 * buffer_size
);
3396 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3399 strcpy (buffer
, path
->path
);
3400 strcat (buffer
, "/");
3401 strcat (buffer
, file
);
3402 fp
= fopen (buffer
, "r");
3405 /* Try the original file name. */
3407 fp
= fopen (file
, "r");
3410 yyerror ("cannot open");
3416 /* Display usage information and exit program. */
3419 Usage: ebrowse [options] {files}\n\
3421 -a, --append append output\n\
3422 -f, --files=FILES read input file names from FILE\n\
3423 -I, --search-path=LIST set search path for input files\n\
3424 -m, --min-regexp-length=N set minimum regexp length to N\n\
3425 -M, --max-regexp-length=N set maximum regexp length to N\n\
3426 -n, --no-nested-classes exclude nested classes\n\
3427 -o, --output-file=FILE set output file name to FILE\n\
3428 -p, --position-info print info about position in file\n\
3429 -s, --no-structs-or-unions don't record structs or unions\n\
3430 -v, --verbose be verbose\n\
3431 -V, --very-verbose be very verbose\n\
3432 -x, --no-regexps don't record regular expressions\n\
3433 --help display this help\n\
3434 --version display version info\n\
3442 exit (error
? 1 : 0);
3446 /* Display version and copyright info. The VERSION macro is set
3447 from the Makefile and contains the Emacs version. */
3452 printf ("ebrowse %s\n", VERSION
);
3453 puts ("Copyright (C) 1992-1999, 2000 Free Software Foundation, Inc.");
3454 puts ("This program is distributed under the same terms as Emacs.");
3459 /* Parse one input file FILE, adding classes and members to the symbol
3468 fp
= open_file (file
);
3473 /* Give a progress indication if needed. */
3485 /* Read file to inbuffer. */
3488 if (nread
+ READ_CHUNK_SIZE
>= inbuffer_size
)
3490 inbuffer_size
= nread
+ READ_CHUNK_SIZE
+ 1;
3491 inbuffer
= (char *) xrealloc (inbuffer
, inbuffer_size
);
3494 nbytes
= fread (inbuffer
+ nread
, 1, READ_CHUNK_SIZE
, fp
);
3501 inbuffer
[nread
] = '\0';
3503 /* Reinitialize scanner and parser for the new input file. */
3507 /* Parse it and close the file. */
3514 /* Read a line from stream FP and return a pointer to a static buffer
3515 containing its contents without the terminating newline. Value
3516 is null when EOF is reached. */
3522 static char *buffer
;
3523 static int buffer_size
;
3526 while ((c
= getc (fp
)) != EOF
&& c
!= '\n')
3528 if (i
>= buffer_size
)
3530 buffer_size
= max (100, buffer_size
* 2);
3531 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3537 if (c
== EOF
&& i
== 0)
3540 if (i
== buffer_size
)
3542 buffer_size
= max (100, buffer_size
* 2);
3543 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3551 /* Main entry point. */
3559 int any_inputfiles
= 0;
3560 static char *out_filename
= DEFAULT_OUTFILE
;
3561 static char **input_filenames
= NULL
;
3562 static int input_filenames_size
= 0;
3563 static int n_input_files
;
3565 filename
= "command line";
3568 while ((i
= getopt_long (argc
, argv
, "af:I:m:M:no:p:svVx",
3569 options
, NULL
)) != EOF
)
3575 info_position
= atoi (optarg
);
3579 f_nested_classes
= 0;
3586 /* Add the name of a file containing more input files. */
3588 if (n_input_files
== input_filenames_size
)
3590 input_filenames_size
= max (10, 2 * input_filenames_size
);
3591 input_filenames
= (char **) xrealloc (input_filenames
,
3592 input_filenames_size
);
3594 input_filenames
[n_input_files
++] = xstrdup (optarg
);
3597 /* Append new output to output file instead of truncating it. */
3602 /* Include structs in the output */
3607 /* Be verbose (give a progress indication). */
3612 /* Be very verbose (print file names as they are processed). */
3618 /* Change the name of the output file. */
3620 out_filename
= optarg
;
3623 /* Set minimum length for regular expression strings
3624 when recorded in the output file. */
3626 min_regexp
= atoi (optarg
);
3629 /* Set maximum length for regular expression strings
3630 when recorded in the output file. */
3632 max_regexp
= atoi (optarg
);
3635 /* Add to search path. */
3637 add_search_path (optarg
);
3651 /* Call init_scanner after command line flags have been processed to be
3652 able to add keywords depending on command line (not yet
3657 /* Open output file */
3660 yyout
= fopen (out_filename
, f_append
? "a" : "w");
3663 yyerror ("cannot open output file `%s'", out_filename
);
3668 /* Process input files specified on the command line. */
3669 while (optind
< argc
)
3671 process_file (argv
[optind
++]);
3675 /* Process files given on stdin if no files specified. */
3676 if (!any_inputfiles
&& n_input_files
== 0)
3679 while ((file
= read_line (stdin
)) != NULL
)
3680 process_file (file
);
3684 /* Process files from `--files=FILE'. Every line in FILE names
3685 one input file to process. */
3686 for (i
= 0; i
< n_input_files
; ++i
)
3688 FILE *fp
= fopen (input_filenames
[i
], "r");
3691 yyerror ("cannot open input file `%s'", input_filenames
[i
]);
3695 while ((file
= read_line (fp
)) != NULL
)
3696 process_file (file
);
3702 /* Write output file. */
3705 /* Close output file. */
3706 if (yyout
!= stdout
)
3713 /* ebrowse.c ends here. */