1 /* ebrowse.c --- parsing files for the ebrowse C++ browser
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 This file is part of GNU Emacs.
9 GNU Emacs is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
14 GNU Emacs is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
41 /* The SunOS compiler doesn't have SEEK_END. */
46 /* Conditionalize function prototypes. */
48 #ifdef PROTOTYPES /* From config.h. */
54 /* Value is non-zero if strings X and Y compare equal. */
56 #define streq(X, Y) (*(X) == *(Y) && strcmp ((X) + 1, (Y) + 1) == 0)
58 /* The ubiquitous `max' and `min' macros. */
61 #define max(X, Y) ((X) > (Y) ? (X) : (Y))
62 #define min(X, Y) ((X) < (Y) ? (X) : (Y))
65 /* Files are read in chunks of this number of bytes. */
67 #define READ_CHUNK_SIZE (100 * 1024)
69 /* The character used as a separator in path lists (like $PATH). */
71 #if defined(__MSDOS__)
72 #define PATH_LIST_SEPARATOR ';'
73 #define FILENAME_EQ(X,Y) (strcasecmp(X,Y) == 0)
75 #if defined(WINDOWSNT)
76 #define PATH_LIST_SEPARATOR ';'
77 #define FILENAME_EQ(X,Y) (stricmp(X,Y) == 0)
79 #define PATH_LIST_SEPARATOR ':'
80 #define FILENAME_EQ(X,Y) (streq(X,Y))
83 /* The default output file name. */
85 #define DEFAULT_OUTFILE "BROWSE"
87 /* A version string written to the output file. Change this whenever
88 the structure of the output file changes. */
90 #define EBROWSE_FILE_VERSION "ebrowse 5.0"
92 /* The output file consists of a tree of Lisp objects, with major
93 nodes built out of Lisp structures. These are the heads of the
94 Lisp structs with symbols identifying their type. */
96 #define TREE_HEADER_STRUCT "[ebrowse-hs "
97 #define TREE_STRUCT "[ebrowse-ts "
98 #define MEMBER_STRUCT "[ebrowse-ms "
99 #define BROWSE_STRUCT "[ebrowse-bs "
100 #define CLASS_STRUCT "[ebrowse-cs "
102 /* The name of the symbol table entry for global functions, variables,
103 defines etc. This name also appears in the browser display. */
105 #define GLOBALS_NAME "*Globals*"
107 /* Token definitions. */
111 YYEOF
= 0, /* end of file */
112 CSTRING
= 256, /* string constant */
113 CCHAR
, /* character constant */
114 CINT
, /* integral constant */
115 CFLOAT
, /* real constant */
118 LSHIFTASGN
, /* <<= */
119 RSHIFTASGN
, /* >>= */
121 IDENT
, /* identifier */
144 /* Keywords. The undef's are there because these
145 three symbols are very likely to be defined somewhere. */
158 CONTINUE
, /* continue */
159 DEFAULT
, /* default */
171 T_INLINE
, /* inline */
175 OPERATOR
, /* operator */
176 PRIVATE
, /* private */
177 PROTECTED
, /* protected */
179 REGISTER
, /* register */
187 TEMPLATE
, /* template */
191 TYPEDEF
, /* typedef */
193 UNSIGNED
, /* unsigned */
194 VIRTUAL
, /* virtual */
196 VOLATILE
, /* volatile */
198 MUTABLE
, /* mutable */
202 SIGNATURE
, /* signature (GNU extension) */
203 NAMESPACE
, /* namespace */
204 EXPLICIT
, /* explicit */
205 TYPENAME
, /* typename */
206 CONST_CAST
, /* const_cast */
207 DYNAMIC_CAST
, /* dynamic_cast */
208 REINTERPRET_CAST
, /* reinterpret_cast */
209 STATIC_CAST
, /* static_cast */
215 /* Storage classes, in a wider sense. */
220 SC_MEMBER
, /* Is an instance member. */
221 SC_STATIC
, /* Is static member. */
222 SC_FRIEND
, /* Is friend function. */
223 SC_TYPE
/* Is a type definition. */
226 /* Member visibility. */
237 #define F_VIRTUAL 1 /* Is virtual function. */
238 #define F_INLINE 2 /* Is inline function. */
239 #define F_CONST 4 /* Is const. */
240 #define F_PURE 8 /* Is pure virtual function. */
241 #define F_MUTABLE 16 /* Is mutable. */
242 #define F_TEMPLATE 32 /* Is a template. */
243 #define F_EXPLICIT 64 /* Is explicit constructor. */
244 #define F_THROW 128 /* Has a throw specification. */
245 #define F_EXTERNC 256 /* Is declared extern "C". */
246 #define F_DEFINE 512 /* Is a #define. */
248 /* Two macros to set and test a bit in an int. */
250 #define SET_FLAG(F, FLAG) ((F) |= (FLAG))
251 #define HAS_FLAG(F, FLAG) (((F) & (FLAG)) != 0)
253 /* Structure describing a class member. */
257 struct member
*next
; /* Next in list of members. */
258 struct member
*anext
; /* Collision chain in member_table. */
259 struct member
**list
; /* Pointer to list in class. */
260 unsigned param_hash
; /* Hash value for parameter types. */
261 int vis
; /* Visibility (public, ...). */
262 int flags
; /* See F_* above. */
263 char *regexp
; /* Matching regular expression. */
264 char *filename
; /* Don't free this shared string. */
265 int pos
; /* Buffer position of occurrence. */
266 char *def_regexp
; /* Regular expression matching definition. */
267 char *def_filename
; /* File name of definition. */
268 int def_pos
; /* Buffer position of definition. */
269 char name
[1]; /* Member name. */
272 /* Structures of this type are used to connect class structures with
273 their super and subclasses. */
277 struct sym
*sym
; /* The super or subclass. */
278 struct link
*next
; /* Next in list or NULL. */
281 /* Structure used to record namespace aliases. */
285 struct alias
*next
; /* Next in list. */
286 struct sym
*namesp
; /* Namespace in which defined. */
287 struct link
*aliasee
; /* List of aliased namespaces (A::B::C...). */
288 char name
[1]; /* Alias name. */
291 /* The structure used to describe a class in the symbol table,
292 or a namespace in all_namespaces. */
296 int flags
; /* Is class a template class?. */
297 unsigned char visited
; /* Used to find circles. */
298 struct sym
*next
; /* Hash collision list. */
299 struct link
*subs
; /* List of subclasses. */
300 struct link
*supers
; /* List of superclasses. */
301 struct member
*vars
; /* List of instance variables. */
302 struct member
*fns
; /* List of instance functions. */
303 struct member
*static_vars
; /* List of static variables. */
304 struct member
*static_fns
; /* List of static functions. */
305 struct member
*friends
; /* List of friend functions. */
306 struct member
*types
; /* List of local types. */
307 char *regexp
; /* Matching regular expression. */
308 int pos
; /* Buffer position. */
309 char *filename
; /* File in which it can be found. */
310 char *sfilename
; /* File in which members can be found. */
311 struct sym
*namesp
; /* Namespace in which defined. . */
312 char name
[1]; /* Name of the class. */
315 /* Experimental: Print info for `--position-info'. We print
316 '(CLASS-NAME SCOPE MEMBER-NAME). */
322 struct sym
*info_cls
= NULL
;
323 struct member
*info_member
= NULL
;
325 /* Experimental. For option `--position-info', the buffer position we
326 are interested in. When this position is reached, print out
327 information about what we know about that point. */
329 int info_position
= -1;
331 /* Command line options structure for getopt_long. */
333 struct option options
[] =
335 {"append", no_argument
, NULL
, 'a'},
336 {"files", required_argument
, NULL
, 'f'},
337 {"help", no_argument
, NULL
, -2},
338 {"min-regexp-length", required_argument
, NULL
, 'm'},
339 {"max-regexp-length", required_argument
, NULL
, 'M'},
340 {"no-nested-classes", no_argument
, NULL
, 'n'},
341 {"no-regexps", no_argument
, NULL
, 'x'},
342 {"no-structs-or-unions", no_argument
, NULL
, 's'},
343 {"output-file", required_argument
, NULL
, 'o'},
344 {"position-info", required_argument
, NULL
, 'p'},
345 {"search-path", required_argument
, NULL
, 'I'},
346 {"verbose", no_argument
, NULL
, 'v'},
347 {"version", no_argument
, NULL
, -3},
348 {"very-verbose", no_argument
, NULL
, 'V'},
352 /* Semantic values of tokens. Set by yylex.. */
354 unsigned yyival
; /* Set for token CINT. */
355 char *yytext
; /* Set for token IDENT. */
362 /* Current line number. */
366 /* The name of the current input file. */
370 /* Three character class vectors, and macros to test membership
377 #define IDENTP(C) is_ident[(unsigned char) (C)]
378 #define DIGITP(C) is_digit[(unsigned char) (C)]
379 #define WHITEP(C) is_white[(unsigned char) (C)]
381 /* Command line flags. */
388 int f_nested_classes
= 1;
390 /* Maximum and minimum lengths of regular expressions matching a
391 member, class etc., for writing them to the output file. These are
392 overridable from the command line. */
403 /* Return the current buffer position in the input file. */
405 #define BUFFER_POS() (in - inbuffer)
407 /* If current lookahead is CSTRING, the following points to the
408 first character in the string constant. Used for recognizing
413 /* The size of the hash tables for classes.and members. Should be
416 #define TABLE_SIZE 1001
418 /* The hash table for class symbols. */
420 struct sym
*class_table
[TABLE_SIZE
];
422 /* Hash table containing all member structures. This is generally
423 faster for member lookup than traversing the member lists of a
426 struct member
*member_table
[TABLE_SIZE
];
428 /* Hash table for namespace aliases */
430 struct alias
*namespace_alias_table
[TABLE_SIZE
];
432 /* The special class symbol used to hold global functions,
435 struct sym
*global_symbols
;
437 /* The current namespace. */
439 struct sym
*current_namespace
;
441 /* The list of all known namespaces. */
443 struct sym
*all_namespaces
;
445 /* Stack of namespaces we're currently nested in, during the parse. */
447 struct sym
**namespace_stack
;
448 int namespace_stack_size
;
451 /* The current lookahead token. */
455 /* Structure describing a keyword. */
459 char *name
; /* Spelling. */
460 int tk
; /* Token value. */
461 struct kw
*next
; /* Next in collision chain. */
464 /* Keywords are lookup up in a hash table of their own. */
466 #define KEYWORD_TABLE_SIZE 1001
467 struct kw
*keyword_table
[KEYWORD_TABLE_SIZE
];
474 struct search_path
*next
;
477 struct search_path
*search_path
;
478 struct search_path
*search_path_tail
;
480 /* Function prototypes. */
484 void re_init_parser (void);
485 char *token_string (int);
486 char *matching_regexp (void);
487 void init_sym (void);
488 struct sym
*add_sym (char *, struct sym
*);
489 void add_link (struct sym
*, struct sym
*);
490 void add_member_defn (struct sym
*, char *, char *,
491 int, unsigned, int, int, int);
492 void add_member_decl (struct sym
*, char *, char *, int,
493 unsigned, int, int, int, int);
494 void dump_roots (FILE *);
497 void add_global_defn (char *, char *, int, unsigned, int, int, int);
498 void add_global_decl (char *, char *, int, unsigned, int, int, int);
499 void add_define (char *, char *, int);
500 void mark_inherited_virtual (void);
501 void leave_namespace (void);
502 void enter_namespace (char *);
503 void register_namespace_alias (char *, struct link
*);
504 void insert_keyword (char *, int);
505 void re_init_scanner (void);
506 void init_scanner (void);
509 void process_file (char *);
510 void add_search_path (char *);
511 FILE *open_file (char *);
512 int process_pp_line (void);
513 int dump_members (FILE *, struct member
*);
514 void dump_sym (FILE *, struct sym
*);
515 int dump_tree (FILE *, struct sym
*);
516 struct member
*find_member (struct sym
*, char *, int, int, unsigned);
517 struct member
*add_member (struct sym
*, char *, int, int, unsigned);
518 void mark_virtual (struct sym
*);
519 void mark_virtual (struct sym
*);
520 struct sym
*make_namespace (char *, struct sym
*);
521 char *sym_scope (struct sym
*);
522 char *sym_scope_1 (struct sym
*);
524 void skip_matching (void);
525 void member (struct sym
*, int);
526 void class_body (struct sym
*, int);
527 void class_definition (struct sym
*, int, int, int);
528 void declaration (int);
529 unsigned parm_list (int *);
530 char *operator_name (int *);
531 struct sym
*parse_classname (void);
532 struct sym
*parse_qualified_ident_or_type (char **);
533 void parse_qualified_param_ident_or_type (char **);
535 void yyerror (char *, char *);
536 void usage (int) NO_RETURN
;
537 void version (void) NO_RETURN
;
541 /***********************************************************************
543 ***********************************************************************/
545 /* Print an error in a printf-like style with the current input file
546 name and line number. */
549 yyerror (char *format
, char *s
)
551 fprintf (stderr
, "%s:%d: ", filename
, yyline
);
552 fprintf (stderr
, format
, s
);
557 /* Like malloc but print an error and exit if not enough memory is
563 void *p
= malloc (nbytes
);
566 yyerror ("out of memory", NULL
);
573 /* Like realloc but print an error and exit if out of memory. */
576 xrealloc (void *p
, int sz
)
581 yyerror ("out of memory", NULL
);
588 /* Like strdup, but print an error and exit if not enough memory is
589 available.. If S is null, return null. */
595 s
= strcpy (xmalloc (strlen (s
) + 1), s
);
601 /***********************************************************************
603 ***********************************************************************/
605 /* Initialize the symbol table. This currently only sets up the
606 special symbol for globals (`*Globals*'). */
611 global_symbols
= add_sym (GLOBALS_NAME
, NULL
);
615 /* Add a symbol for class NAME to the symbol table. NESTED_IN_CLASS
616 is the class in which class NAME was found. If it is null,
617 this means the scope of NAME is the current namespace.
619 If a symbol for NAME already exists, return that. Otherwise
620 create a new symbol and set it to default values. */
623 add_sym (char *name
, struct sym
*nested_in_class
)
628 struct sym
*scope
= nested_in_class
? nested_in_class
: current_namespace
;
630 for (s
= name
, h
= 0; *s
; ++s
)
634 for (sym
= class_table
[h
]; sym
; sym
= sym
->next
)
635 if (streq (name
, sym
->name
)
636 && ((!sym
->namesp
&& !scope
)
637 || (sym
->namesp
&& scope
638 && streq (sym
->namesp
->name
, scope
->name
))))
649 sym
= (struct sym
*) xmalloc (sizeof *sym
+ strlen (name
));
650 memset (sym
, 0, sizeof *sym
);
651 strcpy (sym
->name
, name
);
653 sym
->next
= class_table
[h
];
654 class_table
[h
] = sym
;
661 /* Add links between superclass SUPER and subclass SUB. */
664 add_link (struct sym
*super
, struct sym
*sub
)
666 struct link
*lnk
, *lnk2
, *p
, *prev
;
668 /* See if a link already exists. */
669 for (p
= super
->subs
, prev
= NULL
;
670 p
&& strcmp (sub
->name
, p
->sym
->name
) > 0;
671 prev
= p
, p
= p
->next
)
674 /* Avoid duplicates. */
675 if (p
== NULL
|| p
->sym
!= sub
)
677 lnk
= (struct link
*) xmalloc (sizeof *lnk
);
678 lnk2
= (struct link
*) xmalloc (sizeof *lnk2
);
689 lnk2
->next
= sub
->supers
;
695 /* Find in class CLS member NAME.
697 VAR non-zero means look for a member variable; otherwise a function
698 is searched. SC specifies what kind of member is searched---a
699 static, or per-instance member etc. HASH is a hash code for the
700 parameter types of functions. Value is a pointer to the member
701 found or null if not found. */
704 find_member (struct sym
*cls
, char *name
, int var
, int sc
, unsigned int hash
)
706 struct member
**list
;
708 unsigned name_hash
= 0;
715 list
= &cls
->friends
;
723 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
727 list
= var
? &cls
->vars
: &cls
->fns
;
731 for (s
= name
; *s
; ++s
)
732 name_hash
= (name_hash
<< 1) ^ *s
;
733 i
= name_hash
% TABLE_SIZE
;
735 for (p
= member_table
[i
]; p
; p
= p
->anext
)
736 if (p
->list
== list
&& p
->param_hash
== hash
&& streq (name
, p
->name
))
743 /* Add to class CLS information for the declaration of member NAME.
744 REGEXP is a regexp matching the declaration, if non-null. POS is
745 the position in the source where the declaration is found. HASH is
746 a hash code for the parameter list of the member, if it's a
747 function. VAR non-zero means member is a variable or type. SC
748 specifies the type of member (instance member, static, ...). VIS
749 is the member's visibility (public, protected, private). FLAGS is
750 a bit set giving additional information about the member (see the
754 add_member_decl (struct sym
*cls
, char *name
, char *regexp
, int pos
, unsigned int hash
, int var
, int sc
, int vis
, int flags
)
758 m
= find_member (cls
, name
, var
, sc
, hash
);
760 m
= add_member (cls
, name
, var
, sc
, hash
);
762 /* Have we seen a new filename? If so record that. */
763 if (!cls
->filename
|| !FILENAME_EQ (cls
->filename
, filename
))
764 m
->filename
= filename
;
777 m
->vis
= V_PROTECTED
;
791 /* Add to class CLS information for the definition of member NAME.
792 REGEXP is a regexp matching the declaration, if non-null. POS is
793 the position in the source where the declaration is found. HASH is
794 a hash code for the parameter list of the member, if it's a
795 function. VAR non-zero means member is a variable or type. SC
796 specifies the type of member (instance member, static, ...). VIS
797 is the member's visibility (public, protected, private). FLAGS is
798 a bit set giving additional information about the member (see the
802 add_member_defn (struct sym
*cls
, char *name
, char *regexp
, int pos
, unsigned int hash
, int var
, int sc
, int flags
)
806 if (sc
== SC_UNKNOWN
)
808 m
= find_member (cls
, name
, var
, SC_MEMBER
, hash
);
811 m
= find_member (cls
, name
, var
, SC_STATIC
, hash
);
813 m
= add_member (cls
, name
, var
, sc
, hash
);
818 m
= find_member (cls
, name
, var
, sc
, hash
);
820 m
= add_member (cls
, name
, var
, sc
, hash
);
824 cls
->sfilename
= filename
;
826 if (!FILENAME_EQ (cls
->sfilename
, filename
))
827 m
->def_filename
= filename
;
829 m
->def_regexp
= regexp
;
839 /* Add a symbol for a define named NAME to the symbol table.
840 REGEXP is a regular expression matching the define in the source,
841 if it is non-null. POS is the position in the file. */
844 add_define (char *name
, char *regexp
, int pos
)
846 add_global_defn (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
847 add_global_decl (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
851 /* Add information for the global definition of NAME.
852 REGEXP is a regexp matching the declaration, if non-null. POS is
853 the position in the source where the declaration is found. HASH is
854 a hash code for the parameter list of the member, if it's a
855 function. VAR non-zero means member is a variable or type. SC
856 specifies the type of member (instance member, static, ...). VIS
857 is the member's visibility (public, protected, private). FLAGS is
858 a bit set giving additional information about the member (see the
862 add_global_defn (char *name
, char *regexp
, int pos
, unsigned int hash
, int var
, int sc
, int flags
)
867 /* Try to find out for which classes a function is a friend, and add
868 what we know about it to them. */
870 for (i
= 0; i
< TABLE_SIZE
; ++i
)
871 for (sym
= class_table
[i
]; sym
; sym
= sym
->next
)
872 if (sym
!= global_symbols
&& sym
->friends
)
873 if (find_member (sym
, name
, 0, SC_FRIEND
, hash
))
874 add_member_defn (sym
, name
, regexp
, pos
, hash
, 0,
877 /* Add to global symbols. */
878 add_member_defn (global_symbols
, name
, regexp
, pos
, hash
, var
, sc
, flags
);
882 /* Add information for the global declaration of NAME.
883 REGEXP is a regexp matching the declaration, if non-null. POS is
884 the position in the source where the declaration is found. HASH is
885 a hash code for the parameter list of the member, if it's a
886 function. VAR non-zero means member is a variable or type. SC
887 specifies the type of member (instance member, static, ...). VIS
888 is the member's visibility (public, protected, private). FLAGS is
889 a bit set giving additional information about the member (see the
893 add_global_decl (char *name
, char *regexp
, int pos
, unsigned int hash
, int var
, int sc
, int flags
)
895 /* Add declaration only if not already declared. Header files must
896 be processed before source files for this to have the right effect.
897 I do not want to handle implicit declarations at the moment. */
899 struct member
*found
;
901 m
= found
= find_member (global_symbols
, name
, var
, sc
, hash
);
903 m
= add_member (global_symbols
, name
, var
, sc
, hash
);
905 /* Definition already seen => probably last declaration implicit.
906 Override. This means that declarations must always be added to
907 the symbol table before definitions. */
910 if (!global_symbols
->filename
911 || !FILENAME_EQ (global_symbols
->filename
, filename
))
912 m
->filename
= filename
;
920 info_cls
= global_symbols
;
926 /* Add a symbol for member NAME to class CLS.
927 VAR non-zero means it's a variable. SC specifies the kind of
928 member. HASH is a hash code for the parameter types of a function.
929 Value is a pointer to the member's structure. */
932 add_member (struct sym
*cls
, char *name
, int var
, int sc
, unsigned int hash
)
934 struct member
*m
= (struct member
*) xmalloc (sizeof *m
+ strlen (name
));
935 struct member
**list
;
938 unsigned name_hash
= 0;
942 strcpy (m
->name
, name
);
943 m
->param_hash
= hash
;
950 m
->def_regexp
= NULL
;
951 m
->def_filename
= NULL
;
954 assert (cls
!= NULL
);
959 list
= &cls
->friends
;
967 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
971 list
= var
? &cls
->vars
: &cls
->fns
;
975 for (s
= name
; *s
; ++s
)
976 name_hash
= (name_hash
<< 1) ^ *s
;
977 i
= name_hash
% TABLE_SIZE
;
978 m
->anext
= member_table
[i
];
982 /* Keep the member list sorted. It's cheaper to do it here than to
983 sort them in Lisp. */
984 for (prev
= NULL
, p
= *list
;
985 p
&& strcmp (name
, p
->name
) > 0;
986 prev
= p
, p
= p
->next
)
998 /* Given the root R of a class tree, step through all subclasses
999 recursively, marking functions as virtual that are declared virtual
1003 mark_virtual (struct sym
*r
)
1006 struct member
*m
, *m2
;
1008 for (p
= r
->subs
; p
; p
= p
->next
)
1010 for (m
= r
->fns
; m
; m
= m
->next
)
1011 if (HAS_FLAG (m
->flags
, F_VIRTUAL
))
1013 for (m2
= p
->sym
->fns
; m2
; m2
= m2
->next
)
1014 if (m
->param_hash
== m2
->param_hash
&& streq (m
->name
, m2
->name
))
1015 SET_FLAG (m2
->flags
, F_VIRTUAL
);
1018 mark_virtual (p
->sym
);
1023 /* For all roots of the class tree, mark functions as virtual that
1024 are virtual because of a virtual declaration in a base class. */
1027 mark_inherited_virtual (void)
1032 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1033 for (r
= class_table
[i
]; r
; r
= r
->next
)
1034 if (r
->supers
== NULL
)
1039 /* Create and return a symbol for a namespace with name NAME. */
1042 make_namespace (char *name
, struct sym
*context
)
1044 struct sym
*s
= (struct sym
*) xmalloc (sizeof *s
+ strlen (name
));
1045 memset (s
, 0, sizeof *s
);
1046 strcpy (s
->name
, name
);
1047 s
->next
= all_namespaces
;
1048 s
->namesp
= context
;
1054 /* Find the symbol for namespace NAME. If not found, retrun NULL */
1057 check_namespace (char *name
, struct sym
*context
)
1059 struct sym
*p
= NULL
;
1061 for (p
= all_namespaces
; p
; p
= p
->next
)
1063 if (streq (p
->name
, name
) && (p
->namesp
== context
))
1070 /* Find the symbol for namespace NAME. If not found, add a new symbol
1071 for NAME to all_namespaces. */
1074 find_namespace (char *name
, struct sym
*context
)
1076 struct sym
*p
= check_namespace (name
, context
);
1079 p
= make_namespace (name
, context
);
1085 /* Find namespace alias with name NAME. If not found return NULL. */
1088 check_namespace_alias (char *name
)
1090 struct link
*p
= NULL
;
1095 for (s
= name
, h
= 0; *s
; ++s
)
1099 for (al
= namespace_alias_table
[h
]; al
; al
= al
->next
)
1100 if (streq (name
, al
->name
) && (al
->namesp
== current_namespace
))
1109 /* Register the name NEW_NAME as an alias for namespace list OLD_NAME. */
1112 register_namespace_alias (char *new_name
, struct link
*old_name
)
1118 for (s
= new_name
, h
= 0; *s
; ++s
)
1123 /* Is it already in the table of aliases? */
1124 for (al
= namespace_alias_table
[h
]; al
; al
= al
->next
)
1125 if (streq (new_name
, al
->name
) && (al
->namesp
== current_namespace
))
1128 al
= (struct alias
*) xmalloc (sizeof *al
+ strlen (new_name
));
1129 strcpy (al
->name
, new_name
);
1130 al
->next
= namespace_alias_table
[h
];
1131 al
->namesp
= current_namespace
;
1132 al
->aliasee
= old_name
;
1133 namespace_alias_table
[h
] = al
;
1137 /* Enter namespace with name NAME. */
1140 enter_namespace (char *name
)
1142 struct sym
*p
= find_namespace (name
, current_namespace
);
1144 if (namespace_sp
== namespace_stack_size
)
1146 int size
= max (10, 2 * namespace_stack_size
);
1148 = (struct sym
**) xrealloc ((void *)namespace_stack
,
1149 size
* sizeof *namespace_stack
);
1150 namespace_stack_size
= size
;
1153 namespace_stack
[namespace_sp
++] = current_namespace
;
1154 current_namespace
= p
;
1158 /* Leave the current namespace. */
1161 leave_namespace (void)
1163 assert (namespace_sp
> 0);
1164 current_namespace
= namespace_stack
[--namespace_sp
];
1169 /***********************************************************************
1170 Writing the Output File
1171 ***********************************************************************/
1173 /* Write string S to the output file FP in a Lisp-readable form.
1174 If S is null, write out `()'. */
1176 #define PUTSTR(s, fp) \
1193 /* A dynamically allocated buffer for constructing a scope name. */
1196 int scope_buffer_size
;
1197 int scope_buffer_len
;
1200 /* Make sure scope_buffer has enough room to add LEN chars to it. */
1203 ensure_scope_buffer_room (int len
)
1205 if (scope_buffer_len
+ len
>= scope_buffer_size
)
1207 int new_size
= max (2 * scope_buffer_size
, scope_buffer_len
+ len
);
1208 scope_buffer
= (char *) xrealloc (scope_buffer
, new_size
);
1209 scope_buffer_size
= new_size
;
1214 /* Recursively add the scope names of symbol P and the scopes of its
1215 namespaces to scope_buffer. Value is a pointer to the complete
1216 scope name constructed. */
1219 sym_scope_1 (struct sym
*p
)
1224 sym_scope_1 (p
->namesp
);
1228 ensure_scope_buffer_room (3);
1229 strcat (scope_buffer
, "::");
1230 scope_buffer_len
+= 2;
1233 len
= strlen (p
->name
);
1234 ensure_scope_buffer_room (len
+ 1);
1235 strcat (scope_buffer
, p
->name
);
1236 scope_buffer_len
+= len
;
1238 if (HAS_FLAG (p
->flags
, F_TEMPLATE
))
1240 ensure_scope_buffer_room (3);
1241 strcat (scope_buffer
, "<>");
1242 scope_buffer_len
+= 2;
1245 return scope_buffer
;
1249 /* Return the scope of symbol P in printed representation, i.e.
1250 as it would appear in a C*+ source file. */
1253 sym_scope (struct sym
*p
)
1257 scope_buffer_size
= 1024;
1258 scope_buffer
= (char *) xmalloc (scope_buffer_size
);
1261 *scope_buffer
= '\0';
1262 scope_buffer_len
= 0;
1265 sym_scope_1 (p
->namesp
);
1267 return scope_buffer
;
1271 /* Dump the list of members M to file FP. Value is the length of the
1275 dump_members (FILE *fp
, struct member
*m
)
1281 for (n
= 0; m
; m
= m
->next
, ++n
)
1283 fputs (MEMBER_STRUCT
, fp
);
1284 PUTSTR (m
->name
, fp
);
1285 PUTSTR (NULL
, fp
); /* FIXME? scope for globals */
1286 fprintf (fp
, "%u ", (unsigned) m
->flags
);
1287 PUTSTR (m
->filename
, fp
);
1288 PUTSTR (m
->regexp
, fp
);
1289 fprintf (fp
, "%u ", (unsigned) m
->pos
);
1290 fprintf (fp
, "%u ", (unsigned) m
->vis
);
1292 PUTSTR (m
->def_filename
, fp
);
1293 PUTSTR (m
->def_regexp
, fp
);
1294 fprintf (fp
, "%u", (unsigned) m
->def_pos
);
1305 /* Dump class ROOT to stream FP. */
1308 dump_sym (FILE *fp
, struct sym
*root
)
1310 fputs (CLASS_STRUCT
, fp
);
1311 PUTSTR (root
->name
, fp
);
1313 /* Print scope, if any. */
1315 PUTSTR (sym_scope (root
), fp
);
1320 fprintf (fp
, "%u", root
->flags
);
1321 PUTSTR (root
->filename
, fp
);
1322 PUTSTR (root
->regexp
, fp
);
1323 fprintf (fp
, "%u", (unsigned) root
->pos
);
1324 PUTSTR (root
->sfilename
, fp
);
1330 /* Dump class ROOT and its subclasses to file FP. Value is the
1331 number of classes written. */
1334 dump_tree (FILE *fp
, struct sym
*root
)
1339 dump_sym (fp
, root
);
1349 for (lk
= root
->subs
; lk
; lk
= lk
->next
)
1351 fputs (TREE_STRUCT
, fp
);
1352 n
+= dump_tree (fp
, lk
->sym
);
1358 dump_members (fp
, root
->vars
);
1359 n
+= dump_members (fp
, root
->fns
);
1360 dump_members (fp
, root
->static_vars
);
1361 n
+= dump_members (fp
, root
->static_fns
);
1362 n
+= dump_members (fp
, root
->friends
);
1363 dump_members (fp
, root
->types
);
1378 /* Dump the entire class tree to file FP. */
1381 dump_roots (FILE *fp
)
1386 /* Output file header containing version string, command line
1390 fputs (TREE_HEADER_STRUCT
, fp
);
1391 PUTSTR (EBROWSE_FILE_VERSION
, fp
);
1404 /* Mark functions as virtual that are so because of functions
1405 declared virtual in base classes. */
1406 mark_inherited_virtual ();
1408 /* Dump the roots of the graph. */
1409 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1410 for (r
= class_table
[i
]; r
; r
= r
->next
)
1413 fputs (TREE_STRUCT
, fp
);
1414 n
+= dump_tree (fp
, r
);
1424 /***********************************************************************
1426 ***********************************************************************/
1429 #define INCREMENT_LINENO \
1431 if (f_very_verbose) \
1434 printf ("%d:\n", yyline); \
1440 #define INCREMENT_LINENO ++yyline
1443 /* Define two macros for accessing the input buffer (current input
1444 file). GET(C) sets C to the next input character and advances the
1445 input pointer. UNGET retracts the input pointer. */
1447 #define GET(C) ((C) = *in++)
1448 #define UNGET() (--in)
1451 /* Process a preprocessor line. Value is the next character from the
1452 input buffer not consumed. */
1455 process_pp_line (void)
1457 int in_comment
= 0, in_string
= 0;
1461 /* Skip over white space. The `#' has been consumed already. */
1462 while (WHITEP (GET (c
)))
1465 /* Read the preprocessor command (if any). */
1472 /* Is it a `define'? */
1475 if (*yytext
&& streq (yytext
, "define"))
1490 char *regexp
= matching_regexp ();
1491 int pos
= BUFFER_POS ();
1492 add_define (yytext
, regexp
, pos
);
1496 while (c
&& (c
!= '\n' || in_comment
|| in_string
))
1500 else if (c
== '/' && !in_comment
)
1505 else if (c
== '*' && in_comment
)
1511 in_string
= !in_string
;
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", NULL
);
1570 yyerror ("EOF in string constant", NULL
);
1588 /* Hexadecimal escape sequence. */
1590 for (i
= 0; i
< 2; ++i
)
1594 if (c
>= '0' && c
<= '7')
1596 else if (c
>= 'a' && c
<= 'f')
1598 else if (c
>= 'A' && c
<= 'F')
1611 /* Octal escape sequence. */
1613 for (i
= 0; i
< 3; ++i
)
1617 if (c
>= '0' && c
<= '7')
1634 if (end_char
== '\'')
1635 yyerror ("newline in character constant", NULL
);
1637 yyerror ("newline in string constant", NULL
);
1647 return end_char
== '\'' ? CCHAR
: CSTRING
;
1649 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1650 case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
1651 case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
1652 case 'v': case 'w': case 'x': case 'y': case 'z':
1653 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
1654 case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
1655 case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
1656 case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_':
1658 /* Identifier and keywords. */
1665 while (IDENTP (GET (*p
)))
1667 hash
= (hash
<< 1) ^ *p
++;
1668 if (p
== yytext_end
- 1)
1670 int size
= yytext_end
- yytext
;
1671 yytext
= (char *) xrealloc (yytext
, 2 * size
);
1672 yytext_end
= yytext
+ 2 * size
;
1673 p
= yytext
+ size
- 1;
1680 for (k
= keyword_table
[hash
% KEYWORD_TABLE_SIZE
]; k
; k
= k
->next
)
1681 if (streq (k
->name
, yytext
))
1688 /* C and C++ comments, '/' and '/='. */
1716 while (GET (c
) && c
!= '\n')
1791 yyerror ("invalid token '..' ('...' assumed)", NULL
);
1795 else if (!DIGITP (c
))
1849 c
= process_pp_line ();
1854 case '(': case ')': case '[': case ']': case '{': case '}':
1855 case ';': case ',': case '?': case '~':
1861 if (GET (c
) == 'x' || c
== 'X')
1866 yyival
= yyival
* 16 + c
- '0';
1867 else if (c
>= 'a' && c
<= 'f')
1868 yyival
= yyival
* 16 + c
- 'a' + 10;
1869 else if (c
>= 'A' && c
<= 'F')
1870 yyival
= yyival
* 16 + c
- 'A' + 10;
1880 while (c
>= '0' && c
<= '7')
1882 yyival
= (yyival
<< 3) + c
- '0';
1887 /* Integer suffixes. */
1893 case '1': case '2': case '3': case '4': case '5': case '6':
1894 case '7': case '8': case '9':
1895 /* Integer or floating constant, part before '.'. */
1898 while (GET (c
) && DIGITP (c
))
1899 yyival
= 10 * yyival
+ c
- '0';
1905 /* Digits following '.'. */
1909 /* Optional exponent. */
1910 if (c
== 'E' || c
== 'e')
1912 if (GET (c
) == '-' || c
== '+')
1919 /* Optional type suffixes. */
1932 /* Actually local to matching_regexp. These variables must be in
1933 global scope for the case that `static' get's defined away. */
1935 static char *matching_regexp_buffer
, *matching_regexp_end_buf
;
1938 /* Value is the string from the start of the line to the current
1939 position in the input buffer, or maybe a bit more if that string is
1940 shorter than min_regexp. */
1943 matching_regexp (void)
1952 if (matching_regexp_buffer
== NULL
)
1954 matching_regexp_buffer
= (char *) xmalloc (max_regexp
);
1955 matching_regexp_end_buf
= &matching_regexp_buffer
[max_regexp
] - 1;
1958 /* Scan back to previous newline of buffer start. */
1959 for (p
= in
- 1; p
> inbuffer
&& *p
!= '\n'; --p
)
1964 while (in
- p
< min_regexp
&& p
> inbuffer
)
1966 /* Line probably not significant enough */
1967 for (--p
; p
> inbuffer
&& *p
!= '\n'; --p
)
1974 /* Copy from end to make sure significant portions are included.
1975 This implies that in the browser a regular expressing of the form
1976 `^.*{regexp}' has to be used. */
1977 for (s
= matching_regexp_end_buf
- 1, t
= in
;
1978 s
> matching_regexp_buffer
&& t
> p
;)
1982 if (*s
== '"' || *s
== '\\')
1986 *(matching_regexp_end_buf
- 1) = '\0';
1991 /* Return a printable representation of token T. */
1994 token_string (int t
)
2000 case CSTRING
: return "string constant";
2001 case CCHAR
: return "char constant";
2002 case CINT
: return "int constant";
2003 case CFLOAT
: return "floating constant";
2004 case ELLIPSIS
: return "...";
2005 case LSHIFTASGN
: return "<<=";
2006 case RSHIFTASGN
: return ">>=";
2007 case ARROWSTAR
: return "->*";
2008 case IDENT
: return "identifier";
2009 case DIVASGN
: return "/=";
2010 case INC
: return "++";
2011 case ADDASGN
: return "+=";
2012 case DEC
: return "--";
2013 case ARROW
: return "->";
2014 case SUBASGN
: return "-=";
2015 case MULASGN
: return "*=";
2016 case MODASGN
: return "%=";
2017 case LOR
: return "||";
2018 case ORASGN
: return "|=";
2019 case LAND
: return "&&";
2020 case ANDASGN
: return "&=";
2021 case XORASGN
: return "^=";
2022 case POINTSTAR
: return ".*";
2023 case DCOLON
: return "::";
2024 case EQ
: return "==";
2025 case NE
: return "!=";
2026 case LE
: return "<=";
2027 case LSHIFT
: return "<<";
2028 case GE
: return ">=";
2029 case RSHIFT
: return ">>";
2030 case ASM
: return "asm";
2031 case AUTO
: return "auto";
2032 case BREAK
: return "break";
2033 case CASE
: return "case";
2034 case CATCH
: return "catch";
2035 case CHAR
: return "char";
2036 case CLASS
: return "class";
2037 case CONST
: return "const";
2038 case CONTINUE
: return "continue";
2039 case DEFAULT
: return "default";
2040 case DELETE
: return "delete";
2041 case DO
: return "do";
2042 case DOUBLE
: return "double";
2043 case ELSE
: return "else";
2044 case ENUM
: return "enum";
2045 case EXTERN
: return "extern";
2046 case FLOAT
: return "float";
2047 case FOR
: return "for";
2048 case FRIEND
: return "friend";
2049 case GOTO
: return "goto";
2050 case IF
: return "if";
2051 case T_INLINE
: return "inline";
2052 case INT
: return "int";
2053 case LONG
: return "long";
2054 case NEW
: return "new";
2055 case OPERATOR
: return "operator";
2056 case PRIVATE
: return "private";
2057 case PROTECTED
: return "protected";
2058 case PUBLIC
: return "public";
2059 case REGISTER
: return "register";
2060 case RETURN
: return "return";
2061 case SHORT
: return "short";
2062 case SIGNED
: return "signed";
2063 case SIZEOF
: return "sizeof";
2064 case STATIC
: return "static";
2065 case STRUCT
: return "struct";
2066 case SWITCH
: return "switch";
2067 case TEMPLATE
: return "template";
2068 case THIS
: return "this";
2069 case THROW
: return "throw";
2070 case TRY
: return "try";
2071 case TYPEDEF
: return "typedef";
2072 case UNION
: return "union";
2073 case UNSIGNED
: return "unsigned";
2074 case VIRTUAL
: return "virtual";
2075 case VOID
: return "void";
2076 case VOLATILE
: return "volatile";
2077 case WHILE
: return "while";
2078 case MUTABLE
: return "mutable";
2079 case BOOL
: return "bool";
2080 case TRUE
: return "true";
2081 case FALSE
: return "false";
2082 case SIGNATURE
: return "signature";
2083 case NAMESPACE
: return "namespace";
2084 case EXPLICIT
: return "explicit";
2085 case TYPENAME
: return "typename";
2086 case CONST_CAST
: return "const_cast";
2087 case DYNAMIC_CAST
: return "dynamic_cast";
2088 case REINTERPRET_CAST
: return "reinterpret_cast";
2089 case STATIC_CAST
: return "static_cast";
2090 case TYPEID
: return "typeid";
2091 case USING
: return "using";
2092 case WCHAR
: return "wchar_t";
2093 case YYEOF
: return "EOF";
2108 /* Reinitialize the scanner for a new input file. */
2111 re_init_scanner (void)
2119 yytext
= (char *) xmalloc (size
* sizeof *yytext
);
2120 yytext_end
= yytext
+ size
;
2125 /* Insert a keyword NAME with token value TK into the keyword hash
2129 insert_keyword (char *name
, int tk
)
2133 struct kw
*k
= (struct kw
*) xmalloc (sizeof *k
);
2135 for (s
= name
; *s
; ++s
)
2138 h
%= KEYWORD_TABLE_SIZE
;
2141 k
->next
= keyword_table
[h
];
2142 keyword_table
[h
] = k
;
2146 /* Initialize the scanner for the first file. This sets up the
2147 character class vectors and fills the keyword hash table. */
2154 /* Allocate the input buffer */
2155 inbuffer_size
= READ_CHUNK_SIZE
+ 1;
2156 inbuffer
= in
= (char *) xmalloc (inbuffer_size
);
2159 /* Set up character class vectors. */
2160 for (i
= 0; i
< sizeof is_ident
; ++i
)
2162 if (i
== '_' || isalnum (i
))
2165 if (i
>= '0' && i
<= '9')
2168 if (i
== ' ' || i
== '\t' || i
== '\f' || i
== '\v')
2172 /* Fill keyword hash table. */
2173 insert_keyword ("and", LAND
);
2174 insert_keyword ("and_eq", ANDASGN
);
2175 insert_keyword ("asm", ASM
);
2176 insert_keyword ("auto", AUTO
);
2177 insert_keyword ("bitand", '&');
2178 insert_keyword ("bitor", '|');
2179 insert_keyword ("bool", BOOL
);
2180 insert_keyword ("break", BREAK
);
2181 insert_keyword ("case", CASE
);
2182 insert_keyword ("catch", CATCH
);
2183 insert_keyword ("char", CHAR
);
2184 insert_keyword ("class", CLASS
);
2185 insert_keyword ("compl", '~');
2186 insert_keyword ("const", CONST
);
2187 insert_keyword ("const_cast", CONST_CAST
);
2188 insert_keyword ("continue", CONTINUE
);
2189 insert_keyword ("default", DEFAULT
);
2190 insert_keyword ("delete", DELETE
);
2191 insert_keyword ("do", DO
);
2192 insert_keyword ("double", DOUBLE
);
2193 insert_keyword ("dynamic_cast", DYNAMIC_CAST
);
2194 insert_keyword ("else", ELSE
);
2195 insert_keyword ("enum", ENUM
);
2196 insert_keyword ("explicit", EXPLICIT
);
2197 insert_keyword ("extern", EXTERN
);
2198 insert_keyword ("false", FALSE
);
2199 insert_keyword ("float", FLOAT
);
2200 insert_keyword ("for", FOR
);
2201 insert_keyword ("friend", FRIEND
);
2202 insert_keyword ("goto", GOTO
);
2203 insert_keyword ("if", IF
);
2204 insert_keyword ("inline", T_INLINE
);
2205 insert_keyword ("int", INT
);
2206 insert_keyword ("long", LONG
);
2207 insert_keyword ("mutable", MUTABLE
);
2208 insert_keyword ("namespace", NAMESPACE
);
2209 insert_keyword ("new", NEW
);
2210 insert_keyword ("not", '!');
2211 insert_keyword ("not_eq", NE
);
2212 insert_keyword ("operator", OPERATOR
);
2213 insert_keyword ("or", LOR
);
2214 insert_keyword ("or_eq", ORASGN
);
2215 insert_keyword ("private", PRIVATE
);
2216 insert_keyword ("protected", PROTECTED
);
2217 insert_keyword ("public", PUBLIC
);
2218 insert_keyword ("register", REGISTER
);
2219 insert_keyword ("reinterpret_cast", REINTERPRET_CAST
);
2220 insert_keyword ("return", RETURN
);
2221 insert_keyword ("short", SHORT
);
2222 insert_keyword ("signed", SIGNED
);
2223 insert_keyword ("sizeof", SIZEOF
);
2224 insert_keyword ("static", STATIC
);
2225 insert_keyword ("static_cast", STATIC_CAST
);
2226 insert_keyword ("struct", STRUCT
);
2227 insert_keyword ("switch", SWITCH
);
2228 insert_keyword ("template", TEMPLATE
);
2229 insert_keyword ("this", THIS
);
2230 insert_keyword ("throw", THROW
);
2231 insert_keyword ("true", TRUE
);
2232 insert_keyword ("try", TRY
);
2233 insert_keyword ("typedef", TYPEDEF
);
2234 insert_keyword ("typeid", TYPEID
);
2235 insert_keyword ("typename", TYPENAME
);
2236 insert_keyword ("union", UNION
);
2237 insert_keyword ("unsigned", UNSIGNED
);
2238 insert_keyword ("using", USING
);
2239 insert_keyword ("virtual", VIRTUAL
);
2240 insert_keyword ("void", VOID
);
2241 insert_keyword ("volatile", VOLATILE
);
2242 insert_keyword ("wchar_t", WCHAR
);
2243 insert_keyword ("while", WHILE
);
2244 insert_keyword ("xor", '^');
2245 insert_keyword ("xor_eq", XORASGN
);
2250 /***********************************************************************
2252 ***********************************************************************/
2254 /* Match the current lookahead token and set it to the next token. */
2256 #define MATCH() (tk = yylex ())
2258 /* Return the lookahead token. If current lookahead token is cleared,
2259 read a new token. */
2261 #define LA1 (tk == -1 ? (tk = yylex ()) : tk)
2263 /* Is the current lookahead equal to the token T? */
2265 #define LOOKING_AT(T) (tk == (T))
2267 /* Is the current lookahead one of T1 or T2? */
2269 #define LOOKING_AT2(T1, T2) (tk == (T1) || tk == (T2))
2271 /* Is the current lookahead one of T1, T2 or T3? */
2273 #define LOOKING_AT3(T1, T2, T3) (tk == (T1) || tk == (T2) || tk == (T3))
2275 /* Is the current lookahead one of T1...T4? */
2277 #define LOOKING_AT4(T1, T2, T3, T4) \
2278 (tk == (T1) || tk == (T2) || tk == (T3) || tk == (T4))
2280 /* Match token T if current lookahead is T. */
2282 #define MATCH_IF(T) if (LOOKING_AT (T)) MATCH (); else ((void) 0)
2284 /* Skip to matching token if current token is T. */
2286 #define SKIP_MATCHING_IF(T) \
2287 if (LOOKING_AT (T)) skip_matching (); else ((void) 0)
2290 /* Skip forward until a given token TOKEN or YYEOF is seen and return
2291 the current lookahead token after skipping. */
2296 while (!LOOKING_AT2 (YYEOF
, token
))
2301 /* Skip over pairs of tokens (parentheses, square brackets,
2302 angle brackets, curly brackets) matching the current lookahead. */
2305 skip_matching (void)
2333 if (LOOKING_AT (open
))
2335 else if (LOOKING_AT (close
))
2337 else if (LOOKING_AT (YYEOF
))
2348 skip_initializer (void)
2372 /* Build qualified namespace alias (A::B::c) and return it. */
2375 match_qualified_namespace_alias (void)
2377 struct link
*head
= NULL
;
2378 struct link
*cur
= NULL
;
2379 struct link
*tmp
= NULL
;
2387 tmp
= (struct link
*) xmalloc (sizeof *cur
);
2388 tmp
->sym
= find_namespace (yytext
, cur
? cur
->sym
: NULL
);
2392 cur
= cur
->next
= tmp
;
2409 /* Re-initialize the parser by resetting the lookahead token. */
2412 re_init_parser (void)
2418 /* Parse a parameter list, including the const-specifier,
2419 pure-specifier, and throw-list that may follow a parameter list.
2420 Return in FLAGS what was seen following the parameter list.
2421 Returns a hash code for the parameter types. This value is used to
2422 distinguish between overloaded functions. */
2425 parm_list (int *flags
)
2430 while (!LOOKING_AT2 (YYEOF
, ')'))
2434 /* Skip over grouping parens or parameter lists in parameter
2440 /* Next parameter. */
2446 /* Ignore the scope part of types, if any. This is because
2447 some types need scopes when defined outside of a class body,
2448 and don't need them inside the class body. This means that
2449 we have to look for the last IDENT in a sequence of
2450 IDENT::IDENT::... */
2455 unsigned ident_type_hash
= 0;
2457 parse_qualified_param_ident_or_type (&last_id
);
2460 /* LAST_ID null means something like `X::*'. */
2461 for (; *last_id
; ++last_id
)
2462 ident_type_hash
= (ident_type_hash
<< 1) ^ *last_id
;
2463 hash
= (hash
<< 1) ^ ident_type_hash
;
2472 /* This distinction is made to make `func (void)' equivalent
2476 if (!LOOKING_AT (')'))
2477 hash
= (hash
<< 1) ^ VOID
;
2480 case BOOL
: case CHAR
: case CLASS
: case CONST
:
2481 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2482 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2483 case UNION
: case UNSIGNED
: case VOLATILE
: case WCHAR
:
2486 hash
= (hash
<< 1) ^ LA1
;
2490 case '*': case '&': case '[': case ']':
2491 hash
= (hash
<< 1) ^ LA1
;
2501 if (LOOKING_AT (')'))
2505 if (LOOKING_AT (CONST
))
2507 /* We can overload the same function on `const' */
2508 hash
= (hash
<< 1) ^ CONST
;
2509 SET_FLAG (*flags
, F_CONST
);
2513 if (LOOKING_AT (THROW
))
2516 SKIP_MATCHING_IF ('(');
2517 SET_FLAG (*flags
, F_THROW
);
2520 if (LOOKING_AT ('='))
2523 if (LOOKING_AT (CINT
) && yyival
== 0)
2526 SET_FLAG (*flags
, F_PURE
);
2535 /* Print position info to stdout. */
2540 if (info_position
>= 0 && BUFFER_POS () <= info_position
)
2542 printf ("(\"%s\" \"%s\" \"%s\" %d)\n",
2543 info_cls
->name
, sym_scope (info_cls
),
2544 info_member
->name
, info_where
);
2548 /* Parse a member declaration within the class body of CLS. VIS is
2549 the access specifier for the member (private, protected,
2553 member (struct sym
*cls
, int vis
)
2557 char *regexp
= NULL
;
2568 while (!LOOKING_AT4 (';', '{', '}', YYEOF
))
2576 /* A function or class may follow. */
2579 SET_FLAG (flags
, F_TEMPLATE
);
2580 /* Skip over template argument list */
2581 SKIP_MATCHING_IF ('<');
2585 SET_FLAG (flags
, F_EXPLICIT
);
2589 SET_FLAG (flags
, F_MUTABLE
);
2593 SET_FLAG (flags
, F_INLINE
);
2597 SET_FLAG (flags
, F_VIRTUAL
);
2626 /* Remember IDENTS seen so far. Among these will be the member
2628 id
= (char *) xrealloc (id
, strlen (yytext
) + 2);
2632 strcpy (id
+ 1, yytext
);
2635 strcpy (id
, yytext
);
2641 char *s
= operator_name (&sc
);
2642 id
= (char *) xrealloc (id
, strlen (s
) + 1);
2648 /* Most probably the beginning of a parameter list. */
2654 if (!(is_constructor
= streq (id
, cls
->name
)))
2655 regexp
= matching_regexp ();
2660 pos
= BUFFER_POS ();
2661 hash
= parm_list (&flags
);
2664 regexp
= matching_regexp ();
2666 if (id
&& cls
!= NULL
)
2667 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, flags
);
2669 while (!LOOKING_AT3 (';', '{', YYEOF
))
2672 if (LOOKING_AT ('{') && id
&& cls
)
2673 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0, sc
, flags
);
2680 case STRUCT
: case UNION
: case CLASS
:
2687 /* More than one ident here to allow for MS-DOS specialties
2688 like `_export class' etc. The last IDENT seen counts
2689 as the class name. */
2690 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
2692 if (LOOKING_AT (IDENT
))
2697 if (LOOKING_AT2 (':', '{'))
2698 class_definition (anonymous
? NULL
: cls
, class_tag
, flags
, 1);
2703 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
2704 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
2705 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
2714 if (LOOKING_AT (';'))
2716 /* The end of a member variable, a friend declaration or an access
2717 declaration. We don't want to add friend classes as members. */
2718 if (id
&& sc
!= SC_FRIEND
&& cls
)
2720 regexp
= matching_regexp ();
2721 pos
= BUFFER_POS ();
2725 if (type_seen
|| !paren_seen
)
2726 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2728 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, 0);
2735 else if (LOOKING_AT ('{'))
2738 if (sc
== SC_TYPE
&& id
&& cls
)
2740 regexp
= matching_regexp ();
2741 pos
= BUFFER_POS ();
2745 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2746 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, sc
, 0);
2758 /* Parse the body of class CLS. TAG is the tag of the class (struct,
2762 class_body (struct sym
*cls
, int tag
)
2764 int vis
= tag
== CLASS
? PRIVATE
: PUBLIC
;
2767 while (!LOOKING_AT2 (YYEOF
, '}'))
2771 case PRIVATE
: case PROTECTED
: case PUBLIC
:
2775 if (LOOKING_AT (':'))
2782 /* Probably conditional compilation for inheritance list.
2783 We don't known whether there comes more of this.
2784 This is only a crude fix that works most of the time. */
2789 while (LOOKING_AT2 (IDENT
, ',')
2790 || LOOKING_AT3 (PUBLIC
, PROTECTED
, PRIVATE
));
2799 /* Try to synchronize */
2800 case CHAR
: case CLASS
: case CONST
:
2801 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2802 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2803 case UNION
: case UNSIGNED
: case VOID
: case VOLATILE
:
2804 case TYPEDEF
: case STATIC
: case T_INLINE
: case FRIEND
:
2805 case VIRTUAL
: case TEMPLATE
: case IDENT
: case '~':
2806 case BOOL
: case WCHAR
: case EXPLICIT
: case MUTABLE
:
2818 /* Parse a qualified identifier. Current lookahead is IDENT. A
2819 qualified ident has the form `X<..>::Y<...>::T<...>. Returns a
2820 symbol for that class. */
2823 parse_classname (void)
2825 struct sym
*last_class
= NULL
;
2827 while (LOOKING_AT (IDENT
))
2829 last_class
= add_sym (yytext
, last_class
);
2832 if (LOOKING_AT ('<'))
2835 SET_FLAG (last_class
->flags
, F_TEMPLATE
);
2838 if (!LOOKING_AT (DCOLON
))
2848 /* Parse an operator name. Add the `static' flag to *SC if an
2849 implicitly static operator has been parsed. Value is a pointer to
2850 a static buffer holding the constructed operator name string. */
2853 operator_name (int *sc
)
2855 static int id_size
= 0;
2856 static char *id
= NULL
;
2862 if (LOOKING_AT2 (NEW
, DELETE
))
2864 /* `new' and `delete' are implicitly static. */
2865 if (*sc
!= SC_FRIEND
)
2868 s
= token_string (LA1
);
2871 len
= strlen (s
) + 10;
2874 int new_size
= max (len
, 2 * id_size
);
2875 id
= (char *) xrealloc (id
, new_size
);
2880 /* Vector new or delete? */
2881 if (LOOKING_AT ('['))
2886 if (LOOKING_AT (']'))
2895 int tokens_matched
= 0;
2900 int new_size
= max (len
, 2 * id_size
);
2901 id
= (char *) xrealloc (id
, new_size
);
2904 strcpy (id
, "operator");
2906 /* Beware access declarations of the form "X::f;" Beware of
2907 `operator () ()'. Yet another difficulty is found in
2908 GCC 2.95's STL: `operator == __STL_NULL_TMPL_ARGS (...'. */
2909 while (!(LOOKING_AT ('(') && tokens_matched
)
2910 && !LOOKING_AT2 (';', YYEOF
))
2912 s
= token_string (LA1
);
2913 len
+= strlen (s
) + 2;
2916 int new_size
= max (len
, 2 * id_size
);
2917 id
= (char *) xrealloc (id
, new_size
);
2921 if (*s
!= ')' && *s
!= ']')
2926 /* If this is a simple operator like `+', stop now. */
2927 if (!isalpha ((unsigned char) *s
) && *s
!= '(' && *s
!= '[')
2938 /* This one consumes the last IDENT of a qualified member name like
2939 `X::Y::z'. This IDENT is returned in LAST_ID. Value is the
2940 symbol structure for the ident. */
2943 parse_qualified_ident_or_type (char **last_id
)
2945 struct sym
*cls
= NULL
;
2950 while (LOOKING_AT (IDENT
))
2952 int len
= strlen (yytext
) + 1;
2955 id
= (char *) xrealloc (id
, len
);
2958 strcpy (id
, yytext
);
2962 SKIP_MATCHING_IF ('<');
2964 if (LOOKING_AT (DCOLON
))
2966 struct sym
*pcn
= NULL
;
2967 struct link
*pna
= check_namespace_alias (id
);
2972 enter_namespace (pna
->sym
->name
);
2978 else if ((pcn
= check_namespace (id
, current_namespace
)))
2980 enter_namespace (pcn
->name
);
2984 cls
= add_sym (id
, cls
);
3003 /* This one consumes the last IDENT of a qualified member name like
3004 `X::Y::z'. This IDENT is returned in LAST_ID. Value is the
3005 symbol structure for the ident. */
3008 parse_qualified_param_ident_or_type (char **last_id
)
3010 struct sym
*cls
= NULL
;
3011 static char *id
= NULL
;
3012 static int id_size
= 0;
3014 while (LOOKING_AT (IDENT
))
3016 int len
= strlen (yytext
) + 1;
3019 id
= (char *) xrealloc (id
, len
);
3022 strcpy (id
, yytext
);
3026 SKIP_MATCHING_IF ('<');
3028 if (LOOKING_AT (DCOLON
))
3030 cls
= add_sym (id
, cls
);
3040 /* Parse a class definition.
3042 CONTAINING is the class containing the class being parsed or null.
3043 This may also be null if NESTED != 0 if the containing class is
3044 anonymous. TAG is the tag of the class (struct, union, class).
3045 NESTED is non-zero if we are parsing a nested class.
3047 Current lookahead is the class name. */
3050 class_definition (struct sym
*containing
, int tag
, int flags
, int nested
)
3052 struct sym
*current
;
3053 struct sym
*base_class
;
3055 /* Set CURRENT to null if no entry has to be made for the class
3056 parsed. This is the case for certain command line flag
3058 if ((tag
!= CLASS
&& !f_structs
) || (nested
&& !f_nested_classes
))
3062 current
= add_sym (yytext
, containing
);
3063 current
->pos
= BUFFER_POS ();
3064 current
->regexp
= matching_regexp ();
3065 current
->filename
= filename
;
3066 current
->flags
= flags
;
3069 /* If at ':', base class list follows. */
3070 if (LOOKING_AT (':'))
3079 case VIRTUAL
: case PUBLIC
: case PROTECTED
: case PRIVATE
:
3084 base_class
= parse_classname ();
3085 if (base_class
&& current
&& base_class
!= current
)
3086 add_link (base_class
, current
);
3089 /* The `,' between base classes or the end of the base
3090 class list. Add the previously found base class.
3091 It's done this way to skip over sequences of
3092 `A::B::C' until we reach the end.
3094 FIXME: it is now possible to handle `class X : public B::X'
3095 because we have enough information. */
3101 /* A syntax error, possibly due to preprocessor constructs
3107 class A : private B.
3109 MATCH until we see something like `;' or `{'. */
3110 while (!LOOKING_AT3 (';', YYEOF
, '{'))
3121 /* Parse the class body if there is one. */
3122 if (LOOKING_AT ('{'))
3124 if (tag
!= CLASS
&& !f_structs
)
3129 class_body (current
, tag
);
3131 if (LOOKING_AT ('}'))
3134 if (LOOKING_AT (';') && !nested
)
3141 /* Add to class *CLS information for the declaration of variable or
3142 type *ID. If *CLS is null, this means a global declaration. SC is
3143 the storage class of *ID. FLAGS is a bit set giving additional
3144 information about the member (see the F_* defines). */
3147 add_declarator (struct sym
**cls
, char **id
, int flags
, int sc
)
3149 if (LOOKING_AT2 (';', ','))
3151 /* The end of a member variable or of an access declaration
3152 `X::f'. To distinguish between them we have to know whether
3153 type information has been seen. */
3156 char *regexp
= matching_regexp ();
3157 int pos
= BUFFER_POS ();
3160 add_member_defn (*cls
, *id
, regexp
, pos
, 0, 1, SC_UNKNOWN
, flags
);
3162 add_global_defn (*id
, regexp
, pos
, 0, 1, sc
, flags
);
3168 else if (LOOKING_AT ('{'))
3170 if (sc
== SC_TYPE
&& *id
)
3172 /* A named enumeration. */
3173 char *regexp
= matching_regexp ();
3174 int pos
= BUFFER_POS ();
3175 add_global_defn (*id
, regexp
, pos
, 0, 1, sc
, flags
);
3187 /* Parse a declaration. */
3190 declaration (int flags
)
3193 struct sym
*cls
= NULL
;
3194 char *regexp
= NULL
;
3200 while (!LOOKING_AT3 (';', '{', YYEOF
))
3223 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
3224 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
3225 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
3229 case CLASS
: case STRUCT
: case UNION
:
3230 /* This is for the case `STARTWRAP class X : ...' or
3231 `declare (X, Y)\n class A : ...'. */
3239 /* Assumed to be the start of an initialization in this
3241 skip_initializer ();
3245 add_declarator (&cls
, &id
, flags
, sc
);
3250 char *s
= operator_name (&sc
);
3251 id
= (char *) xrealloc (id
, strlen (s
) + 1);
3257 SET_FLAG (flags
, F_INLINE
);
3263 if (LOOKING_AT (IDENT
))
3265 id
= (char *) xrealloc (id
, strlen (yytext
) + 2);
3267 strcpy (id
+ 1, yytext
);
3273 cls
= parse_qualified_ident_or_type (&id
);
3277 /* Most probably the beginning of a parameter list. */
3284 if (!(is_constructor
= streq (id
, cls
->name
)))
3285 regexp
= matching_regexp ();
3290 pos
= BUFFER_POS ();
3291 hash
= parm_list (&flags
);
3294 regexp
= matching_regexp ();
3297 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0,
3302 /* This may be a C functions, but also a macro
3303 call of the form `declare (A, B)' --- such macros
3304 can be found in some class libraries. */
3309 regexp
= matching_regexp ();
3310 pos
= BUFFER_POS ();
3311 hash
= parm_list (&flags
);
3312 add_global_decl (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3315 /* This is for the case that the function really is
3316 a macro with no `;' following it. If a CLASS directly
3317 follows, we would miss it otherwise. */
3318 if (LOOKING_AT3 (CLASS
, STRUCT
, UNION
))
3322 while (!LOOKING_AT3 (';', '{', YYEOF
))
3325 if (!cls
&& id
&& LOOKING_AT ('{'))
3326 add_global_defn (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3334 add_declarator (&cls
, &id
, flags
, sc
);
3338 /* Parse a list of top-level declarations/definitions. START_FLAGS
3339 says in which context we are parsing. If it is F_EXTERNC, we are
3340 parsing in an `extern "C"' block. Value is 1 if EOF is reached, 0
3344 globals (int start_flags
)
3348 int flags
= start_flags
;
3360 if (LOOKING_AT (IDENT
))
3362 char *namespace_name
= xstrdup (yytext
);
3365 if (LOOKING_AT ('='))
3367 struct link
*qna
= match_qualified_namespace_alias ();
3369 register_namespace_alias (namespace_name
, qna
);
3371 if (skip_to (';') == ';')
3374 else if (LOOKING_AT ('{'))
3377 enter_namespace (namespace_name
);
3383 free (namespace_name
);
3390 if (LOOKING_AT (CSTRING
) && *string_start
== 'C'
3391 && *(string_start
+ 1) == '"')
3393 /* This is `extern "C"'. */
3396 if (LOOKING_AT ('{'))
3399 globals (F_EXTERNC
);
3403 SET_FLAG (flags
, F_EXTERNC
);
3409 SKIP_MATCHING_IF ('<');
3410 SET_FLAG (flags
, F_TEMPLATE
);
3413 case CLASS
: case STRUCT
: case UNION
:
3418 /* More than one ident here to allow for MS-DOS and OS/2
3419 specialties like `far', `_Export' etc. Some C++ libs
3420 have constructs like `_OS_DLLIMPORT(_OS_CLIENT)' in front
3421 of the class name. */
3422 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
3424 if (LOOKING_AT (IDENT
))
3429 /* Don't add anonymous unions. */
3430 if (LOOKING_AT2 (':', '{') && !anonymous
)
3431 class_definition (NULL
, class_tk
, flags
, 0);
3434 if (skip_to (';') == ';')
3438 flags
= start_flags
;
3448 declaration (flags
);
3449 flags
= start_flags
;
3454 yyerror ("parse error", NULL
);
3459 /* Parse the current input file. */
3464 while (globals (0) == 0)
3470 /***********************************************************************
3472 ***********************************************************************/
3474 /* Add the list of paths PATH_LIST to the current search path for
3478 add_search_path (char *path_list
)
3482 char *start
= path_list
;
3483 struct search_path
*p
;
3485 while (*path_list
&& *path_list
!= PATH_LIST_SEPARATOR
)
3488 p
= (struct search_path
*) xmalloc (sizeof *p
);
3489 p
->path
= (char *) xmalloc (path_list
- start
+ 1);
3490 memcpy (p
->path
, start
, path_list
- start
);
3491 p
->path
[path_list
- start
] = '\0';
3494 if (search_path_tail
)
3496 search_path_tail
->next
= p
;
3497 search_path_tail
= p
;
3500 search_path
= search_path_tail
= p
;
3502 while (*path_list
== PATH_LIST_SEPARATOR
)
3508 /* Open FILE and return a file handle for it, or -1 if FILE cannot be
3509 opened. Try to find FILE in search_path first, then try the
3510 unchanged file name. */
3513 open_file (char *file
)
3516 static char *buffer
;
3517 static int buffer_size
;
3518 struct search_path
*path
;
3519 int flen
= strlen (file
) + 1; /* +1 for the slash */
3521 filename
= xstrdup (file
);
3523 for (path
= search_path
; path
&& fp
== NULL
; path
= path
->next
)
3525 int len
= strlen (path
->path
) + flen
;
3527 if (len
+ 1 >= buffer_size
)
3529 buffer_size
= max (len
+ 1, 2 * buffer_size
);
3530 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3533 strcpy (buffer
, path
->path
);
3534 strcat (buffer
, "/");
3535 strcat (buffer
, file
);
3536 fp
= fopen (buffer
, "r");
3539 /* Try the original file name. */
3541 fp
= fopen (file
, "r");
3544 yyerror ("cannot open", NULL
);
3550 /* Display usage information and exit program. */
3553 Usage: ebrowse [options] {files}\n\
3555 -a, --append append output to existing file\n\
3556 -f, --files=FILES read input file names from FILE\n\
3557 -I, --search-path=LIST set search path for input files\n\
3558 -m, --min-regexp-length=N set minimum regexp length to N\n\
3559 -M, --max-regexp-length=N set maximum regexp length to N\n\
3560 -n, --no-nested-classes exclude nested classes\n\
3561 -o, --output-file=FILE set output file name to FILE\n\
3562 -p, --position-info print info about position in file\n\
3563 -s, --no-structs-or-unions don't record structs or unions\n\
3564 -v, --verbose be verbose\n\
3565 -V, --very-verbose be very verbose\n\
3566 -x, --no-regexps don't record regular expressions\n\
3567 --help display this help\n\
3568 --version display version info\n\
3575 exit (error
? EXIT_FAILURE
: EXIT_SUCCESS
);
3579 /* Display version and copyright info. The VERSION macro is set
3580 from the Makefile and contains the Emacs version. */
3583 # define VERSION "21"
3589 /* Makes it easier to update automatically. */
3590 char emacs_copyright
[] = "Copyright (C) 2010 Free Software Foundation, Inc.";
3592 printf ("ebrowse %s\n", VERSION
);
3593 puts (emacs_copyright
);
3594 puts ("This program is distributed under the same terms as Emacs.");
3595 exit (EXIT_SUCCESS
);
3599 /* Parse one input file FILE, adding classes and members to the symbol
3603 process_file (char *file
)
3607 fp
= open_file (file
);
3612 /* Give a progress indication if needed. */
3624 /* Read file to inbuffer. */
3627 if (nread
+ READ_CHUNK_SIZE
>= inbuffer_size
)
3629 inbuffer_size
= nread
+ READ_CHUNK_SIZE
+ 1;
3630 inbuffer
= (char *) xrealloc (inbuffer
, inbuffer_size
);
3633 nbytes
= fread (inbuffer
+ nread
, 1, READ_CHUNK_SIZE
, fp
);
3640 inbuffer
[nread
] = '\0';
3642 /* Reinitialize scanner and parser for the new input file. */
3646 /* Parse it and close the file. */
3653 /* Read a line from stream FP and return a pointer to a static buffer
3654 containing its contents without the terminating newline. Value
3655 is null when EOF is reached. */
3658 read_line (FILE *fp
)
3660 static char *buffer
;
3661 static int buffer_size
;
3664 while ((c
= getc (fp
)) != EOF
&& c
!= '\n')
3666 if (i
>= buffer_size
)
3668 buffer_size
= max (100, buffer_size
* 2);
3669 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3675 if (c
== EOF
&& i
== 0)
3678 if (i
== buffer_size
)
3680 buffer_size
= max (100, buffer_size
* 2);
3681 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3685 if (i
> 0 && buffer
[i
- 1] == '\r')
3686 buffer
[i
- 1] = '\0';
3691 /* Main entry point. */
3694 main (int argc
, char **argv
)
3697 int any_inputfiles
= 0;
3698 static char *out_filename
= DEFAULT_OUTFILE
;
3699 static char **input_filenames
= NULL
;
3700 static int input_filenames_size
= 0;
3701 static int n_input_files
;
3703 filename
= "command line";
3706 while ((i
= getopt_long (argc
, argv
, "af:I:m:M:no:p:svVx",
3707 options
, NULL
)) != EOF
)
3713 info_position
= atoi (optarg
);
3717 f_nested_classes
= 0;
3724 /* Add the name of a file containing more input files. */
3726 if (n_input_files
== input_filenames_size
)
3728 input_filenames_size
= max (10, 2 * input_filenames_size
);
3729 input_filenames
= (char **) xrealloc ((void *)input_filenames
,
3730 input_filenames_size
);
3732 input_filenames
[n_input_files
++] = xstrdup (optarg
);
3735 /* Append new output to output file instead of truncating it. */
3740 /* Include structs in the output */
3745 /* Be verbose (give a progress indication). */
3750 /* Be very verbose (print file names as they are processed). */
3756 /* Change the name of the output file. */
3758 out_filename
= optarg
;
3761 /* Set minimum length for regular expression strings
3762 when recorded in the output file. */
3764 min_regexp
= atoi (optarg
);
3767 /* Set maximum length for regular expression strings
3768 when recorded in the output file. */
3770 max_regexp
= atoi (optarg
);
3773 /* Add to search path. */
3775 add_search_path (optarg
);
3789 /* Call init_scanner after command line flags have been processed to be
3790 able to add keywords depending on command line (not yet
3795 /* Open output file */
3800 /* Check that the file to append to exists, and is not
3801 empty. More specifically, it should be a valid file
3802 produced by a previous run of ebrowse, but that's too
3803 difficult to check. */
3807 fp
= fopen (out_filename
, "r");
3810 yyerror ("file `%s' must exist for --append", out_filename
);
3811 exit (EXIT_FAILURE
);
3814 rc
= fseek (fp
, 0, SEEK_END
);
3817 yyerror ("error seeking in file `%s'", out_filename
);
3818 exit (EXIT_FAILURE
);
3824 yyerror ("error getting size of file `%s'", out_filename
);
3825 exit (EXIT_FAILURE
);
3830 yyerror ("file `%s' is empty", out_filename
);
3831 /* It may be ok to use an empty file for appending.
3832 exit (EXIT_FAILURE); */
3838 yyout
= fopen (out_filename
, f_append
? "a" : "w");
3841 yyerror ("cannot open output file `%s'", out_filename
);
3842 exit (EXIT_FAILURE
);
3846 /* Process input files specified on the command line. */
3847 while (optind
< argc
)
3849 process_file (argv
[optind
++]);
3853 /* Process files given on stdin if no files specified. */
3854 if (!any_inputfiles
&& n_input_files
== 0)
3857 while ((file
= read_line (stdin
)) != NULL
)
3858 process_file (file
);
3862 /* Process files from `--files=FILE'. Every line in FILE names
3863 one input file to process. */
3864 for (i
= 0; i
< n_input_files
; ++i
)
3866 FILE *fp
= fopen (input_filenames
[i
], "r");
3869 yyerror ("cannot open input file `%s'", input_filenames
[i
]);
3873 while ((file
= read_line (fp
)) != NULL
)
3874 process_file (file
);
3880 /* Write output file. */
3883 /* Close output file. */
3884 if (yyout
!= stdout
)
3887 return EXIT_SUCCESS
;
3890 /* arch-tag: fc03b4bc-91a9-4c3d-b3b9-12a77fa86dd8
3891 (do not change this comment) */
3893 /* ebrowse.c ends here */