1 /* ebrowse.c --- parsing files for the ebrowse C++ browser
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
5 Free Software Foundation Inc.
7 Author: Gerd Moellmann <gerd@gnu.org>
10 This file is part of GNU Emacs.
12 GNU Emacs is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2, or (at your option)
17 GNU Emacs is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with GNU Emacs; see the file COPYING. If not, write to
24 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
37 /* The SunOS compiler doesn't have SEEK_END. */
42 /* Conditionalize function prototypes. */
44 #ifdef PROTOTYPES /* From config.h. */
50 /* Value is non-zero if strings X and Y compare equal. */
52 #define streq(X, Y) (*(X) == *(Y) && strcmp ((X) + 1, (Y) + 1) == 0)
54 /* The ubiquitous `max' and `min' macros. */
57 #define max(X, Y) ((X) > (Y) ? (X) : (Y))
58 #define min(X, Y) ((X) < (Y) ? (X) : (Y))
61 /* Files are read in chunks of this number of bytes. */
63 #define READ_CHUNK_SIZE (100 * 1024)
65 /* The character used as a separator in path lists (like $PATH). */
67 #if defined(__MSDOS__)
68 #define PATH_LIST_SEPARATOR ';'
69 #define FILENAME_EQ(X,Y) (strcasecmp(X,Y) == 0)
71 #if defined(WINDOWSNT)
72 #define PATH_LIST_SEPARATOR ';'
73 #define FILENAME_EQ(X,Y) (stricmp(X,Y) == 0)
75 #define PATH_LIST_SEPARATOR ':'
76 #define FILENAME_EQ(X,Y) (streq(X,Y))
79 /* The default output file name. */
81 #define DEFAULT_OUTFILE "BROWSE"
83 /* A version string written to the output file. Change this whenever
84 the structure of the output file changes. */
86 #define EBROWSE_FILE_VERSION "ebrowse 5.0"
88 /* The output file consists of a tree of Lisp objects, with major
89 nodes built out of Lisp structures. These are the heads of the
90 Lisp structs with symbols identifying their type. */
92 #define TREE_HEADER_STRUCT "[ebrowse-hs "
93 #define TREE_STRUCT "[ebrowse-ts "
94 #define MEMBER_STRUCT "[ebrowse-ms "
95 #define BROWSE_STRUCT "[ebrowse-bs "
96 #define CLASS_STRUCT "[ebrowse-cs "
98 /* The name of the symbol table entry for global functions, variables,
99 defines etc. This name also appears in the browser display. */
101 #define GLOBALS_NAME "*Globals*"
103 /* Token definitions. */
107 YYEOF
= 0, /* end of file */
108 CSTRING
= 256, /* string constant */
109 CCHAR
, /* character constant */
110 CINT
, /* integral constant */
111 CFLOAT
, /* real constant */
114 LSHIFTASGN
, /* <<= */
115 RSHIFTASGN
, /* >>= */
117 IDENT
, /* identifier */
140 /* Keywords. The undef's are there because these
141 three symbols are very likely to be defined somewhere. */
154 CONTINUE
, /* continue */
155 DEFAULT
, /* default */
167 T_INLINE
, /* inline */
171 OPERATOR
, /* operator */
172 PRIVATE
, /* private */
173 PROTECTED
, /* protected */
175 REGISTER
, /* register */
183 TEMPLATE
, /* template */
187 TYPEDEF
, /* typedef */
189 UNSIGNED
, /* unsigned */
190 VIRTUAL
, /* virtual */
192 VOLATILE
, /* volatile */
194 MUTABLE
, /* mutable */
198 SIGNATURE
, /* signature (GNU extension) */
199 NAMESPACE
, /* namespace */
200 EXPLICIT
, /* explicit */
201 TYPENAME
, /* typename */
202 CONST_CAST
, /* const_cast */
203 DYNAMIC_CAST
, /* dynamic_cast */
204 REINTERPRET_CAST
, /* reinterpret_cast */
205 STATIC_CAST
, /* static_cast */
211 /* Storage classes, in a wider sense. */
216 SC_MEMBER
, /* Is an instance member. */
217 SC_STATIC
, /* Is static member. */
218 SC_FRIEND
, /* Is friend function. */
219 SC_TYPE
/* Is a type definition. */
222 /* Member visibility. */
233 #define F_VIRTUAL 1 /* Is virtual function. */
234 #define F_INLINE 2 /* Is inline function. */
235 #define F_CONST 4 /* Is const. */
236 #define F_PURE 8 /* Is pure virtual function. */
237 #define F_MUTABLE 16 /* Is mutable. */
238 #define F_TEMPLATE 32 /* Is a template. */
239 #define F_EXPLICIT 64 /* Is explicit constructor. */
240 #define F_THROW 128 /* Has a throw specification. */
241 #define F_EXTERNC 256 /* Is declared extern "C". */
242 #define F_DEFINE 512 /* Is a #define. */
244 /* Two macros to set and test a bit in an int. */
246 #define SET_FLAG(F, FLAG) ((F) |= (FLAG))
247 #define HAS_FLAG(F, FLAG) (((F) & (FLAG)) != 0)
249 /* Structure describing a class member. */
253 struct member
*next
; /* Next in list of members. */
254 struct member
*anext
; /* Collision chain in member_table. */
255 struct member
**list
; /* Pointer to list in class. */
256 unsigned param_hash
; /* Hash value for parameter types. */
257 int vis
; /* Visibility (public, ...). */
258 int flags
; /* See F_* above. */
259 char *regexp
; /* Matching regular expression. */
260 char *filename
; /* Don't free this shared string. */
261 int pos
; /* Buffer position of occurrence. */
262 char *def_regexp
; /* Regular expression matching definition. */
263 char *def_filename
; /* File name of definition. */
264 int def_pos
; /* Buffer position of definition. */
265 char name
[1]; /* Member name. */
268 /* Structures of this type are used to connect class structures with
269 their super and subclasses. */
273 struct sym
*sym
; /* The super or subclass. */
274 struct link
*next
; /* Next in list or NULL. */
277 /* Structure used to record namespace aliases. */
281 struct alias
*next
; /* Next in list. */
282 struct sym
*namesp
; /* Namespace in which defined. */
283 struct link
*aliasee
; /* List of aliased namespaces (A::B::C...). */
284 char name
[1]; /* Alias name. */
287 /* The structure used to describe a class in the symbol table,
288 or a namespace in all_namespaces. */
292 int flags
; /* Is class a template class?. */
293 unsigned char visited
; /* Used to find circles. */
294 struct sym
*next
; /* Hash collision list. */
295 struct link
*subs
; /* List of subclasses. */
296 struct link
*supers
; /* List of superclasses. */
297 struct member
*vars
; /* List of instance variables. */
298 struct member
*fns
; /* List of instance functions. */
299 struct member
*static_vars
; /* List of static variables. */
300 struct member
*static_fns
; /* List of static functions. */
301 struct member
*friends
; /* List of friend functions. */
302 struct member
*types
; /* List of local types. */
303 char *regexp
; /* Matching regular expression. */
304 int pos
; /* Buffer position. */
305 char *filename
; /* File in which it can be found. */
306 char *sfilename
; /* File in which members can be found. */
307 struct sym
*namesp
; /* Namespace in which defined. . */
308 char name
[1]; /* Name of the class. */
311 /* Experimental: Print info for `--position-info'. We print
312 '(CLASS-NAME SCOPE MEMBER-NAME). */
318 struct sym
*info_cls
= NULL
;
319 struct member
*info_member
= NULL
;
321 /* Experimental. For option `--position-info', the buffer position we
322 are interested in. When this position is reached, print out
323 information about what we know about that point. */
325 int info_position
= -1;
327 /* Command line options structure for getopt_long. */
329 struct option options
[] =
331 {"append", no_argument
, NULL
, 'a'},
332 {"files", required_argument
, NULL
, 'f'},
333 {"help", no_argument
, NULL
, -2},
334 {"min-regexp-length", required_argument
, NULL
, 'm'},
335 {"max-regexp-length", required_argument
, NULL
, 'M'},
336 {"no-nested-classes", no_argument
, NULL
, 'n'},
337 {"no-regexps", no_argument
, NULL
, 'x'},
338 {"no-structs-or-unions", no_argument
, NULL
, 's'},
339 {"output-file", required_argument
, NULL
, 'o'},
340 {"position-info", required_argument
, NULL
, 'p'},
341 {"search-path", required_argument
, NULL
, 'I'},
342 {"verbose", no_argument
, NULL
, 'v'},
343 {"version", no_argument
, NULL
, -3},
344 {"very-verbose", no_argument
, NULL
, 'V'},
348 /* Semantic values of tokens. Set by yylex.. */
350 unsigned yyival
; /* Set for token CINT. */
351 char *yytext
; /* Set for token IDENT. */
358 /* Current line number. */
362 /* The name of the current input file. */
366 /* Three character class vectors, and macros to test membership
373 #define IDENTP(C) is_ident[(unsigned char) (C)]
374 #define DIGITP(C) is_digit[(unsigned char) (C)]
375 #define WHITEP(C) is_white[(unsigned char) (C)]
377 /* Command line flags. */
384 int f_nested_classes
= 1;
386 /* Maximum and minimum lengths of regular expressions matching a
387 member, class etc., for writing them to the output file. These are
388 overridable from the command line. */
399 /* Return the current buffer position in the input file. */
401 #define BUFFER_POS() (in - inbuffer)
403 /* If current lookahead is CSTRING, the following points to the
404 first character in the string constant. Used for recognizing
409 /* The size of the hash tables for classes.and members. Should be
412 #define TABLE_SIZE 1001
414 /* The hash table for class symbols. */
416 struct sym
*class_table
[TABLE_SIZE
];
418 /* Hash table containing all member structures. This is generally
419 faster for member lookup than traversing the member lists of a
422 struct member
*member_table
[TABLE_SIZE
];
424 /* Hash table for namespace aliases */
426 struct alias
*namespace_alias_table
[TABLE_SIZE
];
428 /* The special class symbol used to hold global functions,
431 struct sym
*global_symbols
;
433 /* The current namespace. */
435 struct sym
*current_namespace
;
437 /* The list of all known namespaces. */
439 struct sym
*all_namespaces
;
441 /* Stack of namespaces we're currently nested in, during the parse. */
443 struct sym
**namespace_stack
;
444 int namespace_stack_size
;
447 /* The current lookahead token. */
451 /* Structure describing a keyword. */
455 char *name
; /* Spelling. */
456 int tk
; /* Token value. */
457 struct kw
*next
; /* Next in collision chain. */
460 /* Keywords are lookup up in a hash table of their own. */
462 #define KEYWORD_TABLE_SIZE 1001
463 struct kw
*keyword_table
[KEYWORD_TABLE_SIZE
];
470 struct search_path
*next
;
473 struct search_path
*search_path
;
474 struct search_path
*search_path_tail
;
476 /* Function prototypes. */
478 int yylex
P_ ((void));
479 void yyparse
P_ ((void));
480 void re_init_parser
P_ ((void));
481 char *token_string
P_ ((int));
482 char *matching_regexp
P_ ((void));
483 void init_sym
P_ ((void));
484 struct sym
*add_sym
P_ ((char *, struct sym
*));
485 void add_link
P_ ((struct sym
*, struct sym
*));
486 void add_member_defn
P_ ((struct sym
*, char *, char *,
487 int, unsigned, int, int, int));
488 void add_member_decl
P_ ((struct sym
*, char *, char *, int,
489 unsigned, int, int, int, int));
490 void dump_roots
P_ ((FILE *));
491 void *xmalloc
P_ ((int));
492 void xfree
P_ ((void *));
493 void add_global_defn
P_ ((char *, char *, int, unsigned, int, int, int));
494 void add_global_decl
P_ ((char *, char *, int, unsigned, int, int, int));
495 void add_define
P_ ((char *, char *, int));
496 void mark_inherited_virtual
P_ ((void));
497 void leave_namespace
P_ ((void));
498 void enter_namespace
P_ ((char *));
499 void register_namespace_alias
P_ ((char *, struct link
*));
500 void insert_keyword
P_ ((char *, int));
501 void re_init_scanner
P_ ((void));
502 void init_scanner
P_ ((void));
503 void usage
P_ ((int));
504 void version
P_ ((void));
505 void process_file
P_ ((char *));
506 void add_search_path
P_ ((char *));
507 FILE *open_file
P_ ((char *));
508 int process_pp_line
P_ ((void));
509 int dump_members
P_ ((FILE *, struct member
*));
510 void dump_sym
P_ ((FILE *, struct sym
*));
511 int dump_tree
P_ ((FILE *, struct sym
*));
512 struct member
*find_member
P_ ((struct sym
*, char *, int, int, unsigned));
513 struct member
*add_member
P_ ((struct sym
*, char *, int, int, unsigned));
514 void mark_virtual
P_ ((struct sym
*));
515 void mark_virtual
P_ ((struct sym
*));
516 struct sym
*make_namespace
P_ ((char *, struct sym
*));
517 char *sym_scope
P_ ((struct sym
*));
518 char *sym_scope_1
P_ ((struct sym
*));
519 int skip_to
P_ ((int));
520 void skip_matching
P_ ((void));
521 void member
P_ ((struct sym
*, int));
522 void class_body
P_ ((struct sym
*, int));
523 void class_definition
P_ ((struct sym
*, int, int, int));
524 void declaration
P_ ((int));
525 unsigned parm_list
P_ ((int *));
526 char *operator_name
P_ ((int *));
527 struct sym
*parse_classname
P_ ((void));
528 struct sym
*parse_qualified_ident_or_type
P_ ((char **));
529 void parse_qualified_param_ident_or_type
P_ ((char **));
530 int globals
P_ ((int));
531 void yyerror
P_ ((char *, char *));
535 /***********************************************************************
537 ***********************************************************************/
539 /* Print an error in a printf-like style with the current input file
540 name and line number. */
546 fprintf (stderr
, "%s:%d: ", filename
, yyline
);
547 fprintf (stderr
, format
, s
);
552 /* Like malloc but print an error and exit if not enough memory is
559 void *p
= malloc (nbytes
);
562 yyerror ("out of memory", NULL
);
569 /* Like realloc but print an error and exit if out of memory. */
579 yyerror ("out of memory", NULL
);
586 /* Like free but always check for null pointers.. */
597 /* Like strdup, but print an error and exit if not enough memory is
598 available.. If S is null, return null. */
605 s
= strcpy (xmalloc (strlen (s
) + 1), s
);
611 /***********************************************************************
613 ***********************************************************************/
615 /* Initialize the symbol table. This currently only sets up the
616 special symbol for globals (`*Globals*'). */
621 global_symbols
= add_sym (GLOBALS_NAME
, NULL
);
625 /* Add a symbol for class NAME to the symbol table. NESTED_IN_CLASS
626 is the class in which class NAME was found. If it is null,
627 this means the scope of NAME is the current namespace.
629 If a symbol for NAME already exists, return that. Otherwise
630 create a new symbol and set it to default values. */
633 add_sym (name
, nested_in_class
)
635 struct sym
*nested_in_class
;
640 struct sym
*scope
= nested_in_class
? nested_in_class
: current_namespace
;
642 for (s
= name
, h
= 0; *s
; ++s
)
646 for (sym
= class_table
[h
]; sym
; sym
= sym
->next
)
647 if (streq (name
, sym
->name
) && sym
->namesp
== scope
)
658 sym
= (struct sym
*) xmalloc (sizeof *sym
+ strlen (name
));
659 bzero (sym
, sizeof *sym
);
660 strcpy (sym
->name
, name
);
662 sym
->next
= class_table
[h
];
663 class_table
[h
] = sym
;
670 /* Add links between superclass SUPER and subclass SUB. */
673 add_link (super
, sub
)
674 struct sym
*super
, *sub
;
676 struct link
*lnk
, *lnk2
, *p
, *prev
;
678 /* See if a link already exists. */
679 for (p
= super
->subs
, prev
= NULL
;
680 p
&& strcmp (sub
->name
, p
->sym
->name
) > 0;
681 prev
= p
, p
= p
->next
)
684 /* Avoid duplicates. */
685 if (p
== NULL
|| p
->sym
!= sub
)
687 lnk
= (struct link
*) xmalloc (sizeof *lnk
);
688 lnk2
= (struct link
*) xmalloc (sizeof *lnk2
);
699 lnk2
->next
= sub
->supers
;
705 /* Find in class CLS member NAME.
707 VAR non-zero means look for a member variable; otherwise a function
708 is searched. SC specifies what kind of member is searched---a
709 static, or per-instance member etc. HASH is a hash code for the
710 parameter types of functions. Value is a pointer to the member
711 found or null if not found. */
714 find_member (cls
, name
, var
, sc
, hash
)
720 struct member
**list
;
722 unsigned name_hash
= 0;
729 list
= &cls
->friends
;
737 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
741 list
= var
? &cls
->vars
: &cls
->fns
;
745 for (s
= name
; *s
; ++s
)
746 name_hash
= (name_hash
<< 1) ^ *s
;
747 i
= name_hash
% TABLE_SIZE
;
749 for (p
= member_table
[i
]; p
; p
= p
->anext
)
750 if (p
->list
== list
&& p
->param_hash
== hash
&& streq (name
, p
->name
))
757 /* Add to class CLS information for the declaration of member NAME.
758 REGEXP is a regexp matching the declaration, if non-null. POS is
759 the position in the source where the declaration is found. HASH is
760 a hash code for the parameter list of the member, if it's a
761 function. VAR non-zero means member is a variable or type. SC
762 specifies the type of member (instance member, static, ...). VIS
763 is the member's visibility (public, protected, private). FLAGS is
764 a bit set giving additional information about the member (see the
768 add_member_decl (cls
, name
, regexp
, pos
, hash
, var
, sc
, vis
, flags
)
781 m
= find_member (cls
, name
, var
, sc
, hash
);
783 m
= add_member (cls
, name
, var
, sc
, hash
);
785 /* Have we seen a new filename? If so record that. */
786 if (!cls
->filename
|| !FILENAME_EQ (cls
->filename
, filename
))
787 m
->filename
= filename
;
800 m
->vis
= V_PROTECTED
;
814 /* Add to class CLS information for the definition of member NAME.
815 REGEXP is a regexp matching the declaration, if non-null. POS is
816 the position in the source where the declaration is found. HASH is
817 a hash code for the parameter list of the member, if it's a
818 function. VAR non-zero means member is a variable or type. SC
819 specifies the type of member (instance member, static, ...). VIS
820 is the member's visibility (public, protected, private). FLAGS is
821 a bit set giving additional information about the member (see the
825 add_member_defn (cls
, name
, regexp
, pos
, hash
, var
, sc
, flags
)
837 if (sc
== SC_UNKNOWN
)
839 m
= find_member (cls
, name
, var
, SC_MEMBER
, hash
);
842 m
= find_member (cls
, name
, var
, SC_STATIC
, hash
);
844 m
= add_member (cls
, name
, var
, sc
, hash
);
849 m
= find_member (cls
, name
, var
, sc
, hash
);
851 m
= add_member (cls
, name
, var
, sc
, hash
);
855 cls
->sfilename
= filename
;
857 if (!FILENAME_EQ (cls
->sfilename
, filename
))
858 m
->def_filename
= filename
;
860 m
->def_regexp
= regexp
;
870 /* Add a symbol for a define named NAME to the symbol table.
871 REGEXP is a regular expression matching the define in the source,
872 if it is non-null. POS is the position in the file. */
875 add_define (name
, regexp
, pos
)
879 add_global_defn (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
880 add_global_decl (name
, regexp
, pos
, 0, 1, SC_FRIEND
, F_DEFINE
);
884 /* Add information for the global definition of NAME.
885 REGEXP is a regexp matching the declaration, if non-null. POS is
886 the position in the source where the declaration is found. HASH is
887 a hash code for the parameter list of the member, if it's a
888 function. VAR non-zero means member is a variable or type. SC
889 specifies the type of member (instance member, static, ...). VIS
890 is the member's visibility (public, protected, private). FLAGS is
891 a bit set giving additional information about the member (see the
895 add_global_defn (name
, regexp
, pos
, hash
, var
, sc
, flags
)
906 /* Try to find out for which classes a function is a friend, and add
907 what we know about it to them. */
909 for (i
= 0; i
< TABLE_SIZE
; ++i
)
910 for (sym
= class_table
[i
]; sym
; sym
= sym
->next
)
911 if (sym
!= global_symbols
&& sym
->friends
)
912 if (find_member (sym
, name
, 0, SC_FRIEND
, hash
))
913 add_member_defn (sym
, name
, regexp
, pos
, hash
, 0,
916 /* Add to global symbols. */
917 add_member_defn (global_symbols
, name
, regexp
, pos
, hash
, var
, sc
, flags
);
921 /* Add information for the global declaration of NAME.
922 REGEXP is a regexp matching the declaration, if non-null. POS is
923 the position in the source where the declaration is found. HASH is
924 a hash code for the parameter list of the member, if it's a
925 function. VAR non-zero means member is a variable or type. SC
926 specifies the type of member (instance member, static, ...). VIS
927 is the member's visibility (public, protected, private). FLAGS is
928 a bit set giving additional information about the member (see the
932 add_global_decl (name
, regexp
, pos
, hash
, var
, sc
, flags
)
940 /* Add declaration only if not already declared. Header files must
941 be processed before source files for this to have the right effect.
942 I do not want to handle implicit declarations at the moment. */
944 struct member
*found
;
946 m
= found
= find_member (global_symbols
, name
, var
, sc
, hash
);
948 m
= add_member (global_symbols
, name
, var
, sc
, hash
);
950 /* Definition already seen => probably last declaration implicit.
951 Override. This means that declarations must always be added to
952 the symbol table before definitions. */
955 if (!global_symbols
->filename
956 || !FILENAME_EQ (global_symbols
->filename
, filename
))
957 m
->filename
= filename
;
965 info_cls
= global_symbols
;
971 /* Add a symbol for member NAME to class CLS.
972 VAR non-zero means it's a variable. SC specifies the kind of
973 member. HASH is a hash code for the parameter types of a function.
974 Value is a pointer to the member's structure. */
977 add_member (cls
, name
, var
, sc
, hash
)
984 struct member
*m
= (struct member
*) xmalloc (sizeof *m
+ strlen (name
));
985 struct member
**list
;
988 unsigned name_hash
= 0;
992 strcpy (m
->name
, name
);
993 m
->param_hash
= hash
;
1000 m
->def_regexp
= NULL
;
1001 m
->def_filename
= NULL
;
1004 assert (cls
!= NULL
);
1009 list
= &cls
->friends
;
1017 list
= var
? &cls
->static_vars
: &cls
->static_fns
;
1021 list
= var
? &cls
->vars
: &cls
->fns
;
1025 for (s
= name
; *s
; ++s
)
1026 name_hash
= (name_hash
<< 1) ^ *s
;
1027 i
= name_hash
% TABLE_SIZE
;
1028 m
->anext
= member_table
[i
];
1029 member_table
[i
] = m
;
1032 /* Keep the member list sorted. It's cheaper to do it here than to
1033 sort them in Lisp. */
1034 for (prev
= NULL
, p
= *list
;
1035 p
&& strcmp (name
, p
->name
) > 0;
1036 prev
= p
, p
= p
->next
)
1048 /* Given the root R of a class tree, step through all subclasses
1049 recursively, marking functions as virtual that are declared virtual
1057 struct member
*m
, *m2
;
1059 for (p
= r
->subs
; p
; p
= p
->next
)
1061 for (m
= r
->fns
; m
; m
= m
->next
)
1062 if (HAS_FLAG (m
->flags
, F_VIRTUAL
))
1064 for (m2
= p
->sym
->fns
; m2
; m2
= m2
->next
)
1065 if (m
->param_hash
== m2
->param_hash
&& streq (m
->name
, m2
->name
))
1066 SET_FLAG (m2
->flags
, F_VIRTUAL
);
1069 mark_virtual (p
->sym
);
1074 /* For all roots of the class tree, mark functions as virtual that
1075 are virtual because of a virtual declaration in a base class. */
1078 mark_inherited_virtual ()
1083 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1084 for (r
= class_table
[i
]; r
; r
= r
->next
)
1085 if (r
->supers
== NULL
)
1090 /* Create and return a symbol for a namespace with name NAME. */
1093 make_namespace (name
, context
)
1095 struct sym
*context
;
1097 struct sym
*s
= (struct sym
*) xmalloc (sizeof *s
+ strlen (name
));
1098 bzero (s
, sizeof *s
);
1099 strcpy (s
->name
, name
);
1100 s
->next
= all_namespaces
;
1101 s
->namesp
= context
;
1107 /* Find the symbol for namespace NAME. If not found, retrun NULL */
1110 check_namespace (name
, context
)
1112 struct sym
*context
;
1114 struct sym
*p
= NULL
;
1116 for (p
= all_namespaces
; p
; p
= p
->next
)
1118 if (streq (p
->name
, name
) && (p
->namesp
== context
))
1125 /* Find the symbol for namespace NAME. If not found, add a new symbol
1126 for NAME to all_namespaces. */
1129 find_namespace (name
, context
)
1131 struct sym
*context
;
1133 struct sym
*p
= check_namespace (name
, context
);
1136 p
= make_namespace (name
, context
);
1142 /* Find namespace alias with name NAME. If not found return NULL. */
1145 check_namespace_alias (name
)
1148 struct link
*p
= NULL
;
1153 for (s
= name
, h
= 0; *s
; ++s
)
1157 for (al
= namespace_alias_table
[h
]; al
; al
= al
->next
)
1158 if (streq (name
, al
->name
) && (al
->namesp
== current_namespace
))
1167 /* Register the name NEW_NAME as an alias for namespace list OLD_NAME. */
1170 register_namespace_alias (new_name
, old_name
)
1172 struct link
*old_name
;
1178 for (s
= new_name
, h
= 0; *s
; ++s
)
1183 /* Is it already in the table of aliases? */
1184 for (al
= namespace_alias_table
[h
]; al
; al
= al
->next
)
1185 if (streq (new_name
, al
->name
) && (al
->namesp
== current_namespace
))
1188 al
= (struct alias
*) xmalloc (sizeof *al
+ strlen (new_name
));
1189 strcpy (al
->name
, new_name
);
1190 al
->next
= namespace_alias_table
[h
];
1191 al
->namesp
= current_namespace
;
1192 al
->aliasee
= old_name
;
1193 namespace_alias_table
[h
] = al
;
1197 /* Enter namespace with name NAME. */
1200 enter_namespace (name
)
1203 struct sym
*p
= find_namespace (name
, current_namespace
);
1205 if (namespace_sp
== namespace_stack_size
)
1207 int size
= max (10, 2 * namespace_stack_size
);
1209 = (struct sym
**) xrealloc ((void *)namespace_stack
,
1210 size
* sizeof *namespace_stack
);
1211 namespace_stack_size
= size
;
1214 namespace_stack
[namespace_sp
++] = current_namespace
;
1215 current_namespace
= p
;
1219 /* Leave the current namespace. */
1224 assert (namespace_sp
> 0);
1225 current_namespace
= namespace_stack
[--namespace_sp
];
1230 /***********************************************************************
1231 Writing the Output File
1232 ***********************************************************************/
1234 /* Write string S to the output file FP in a Lisp-readable form.
1235 If S is null, write out `()'. */
1237 #define PUTSTR(s, fp) \
1254 /* A dynamically allocated buffer for constructing a scope name. */
1257 int scope_buffer_size
;
1258 int scope_buffer_len
;
1261 /* Make sure scope_buffer has enough room to add LEN chars to it. */
1264 ensure_scope_buffer_room (len
)
1267 if (scope_buffer_len
+ len
>= scope_buffer_size
)
1269 int new_size
= max (2 * scope_buffer_size
, scope_buffer_len
+ len
);
1270 scope_buffer
= (char *) xrealloc (scope_buffer
, new_size
);
1271 scope_buffer_size
= new_size
;
1276 /* Recursively add the scope names of symbol P and the scopes of its
1277 namespaces to scope_buffer. Value is a pointer to the complete
1278 scope name constructed. */
1287 sym_scope_1 (p
->namesp
);
1291 ensure_scope_buffer_room (3);
1292 strcat (scope_buffer
, "::");
1293 scope_buffer_len
+= 2;
1296 len
= strlen (p
->name
);
1297 ensure_scope_buffer_room (len
+ 1);
1298 strcat (scope_buffer
, p
->name
);
1299 scope_buffer_len
+= len
;
1301 if (HAS_FLAG (p
->flags
, F_TEMPLATE
))
1303 ensure_scope_buffer_room (3);
1304 strcat (scope_buffer
, "<>");
1305 scope_buffer_len
+= 2;
1308 return scope_buffer
;
1312 /* Return the scope of symbol P in printed representation, i.e.
1313 as it would appear in a C*+ source file. */
1321 scope_buffer_size
= 1024;
1322 scope_buffer
= (char *) xmalloc (scope_buffer_size
);
1325 *scope_buffer
= '\0';
1326 scope_buffer_len
= 0;
1329 sym_scope_1 (p
->namesp
);
1331 return scope_buffer
;
1335 /* Dump the list of members M to file FP. Value is the length of the
1339 dump_members (fp
, m
)
1347 for (n
= 0; m
; m
= m
->next
, ++n
)
1349 fputs (MEMBER_STRUCT
, fp
);
1350 PUTSTR (m
->name
, fp
);
1351 PUTSTR (NULL
, fp
); /* FIXME? scope for globals */
1352 fprintf (fp
, "%u ", (unsigned) m
->flags
);
1353 PUTSTR (m
->filename
, fp
);
1354 PUTSTR (m
->regexp
, fp
);
1355 fprintf (fp
, "%u ", (unsigned) m
->pos
);
1356 fprintf (fp
, "%u ", (unsigned) m
->vis
);
1358 PUTSTR (m
->def_filename
, fp
);
1359 PUTSTR (m
->def_regexp
, fp
);
1360 fprintf (fp
, "%u", (unsigned) m
->def_pos
);
1371 /* Dump class ROOT to stream FP. */
1378 fputs (CLASS_STRUCT
, fp
);
1379 PUTSTR (root
->name
, fp
);
1381 /* Print scope, if any. */
1383 PUTSTR (sym_scope (root
), fp
);
1388 fprintf (fp
, "%u", root
->flags
);
1389 PUTSTR (root
->filename
, fp
);
1390 PUTSTR (root
->regexp
, fp
);
1391 fprintf (fp
, "%u", (unsigned) root
->pos
);
1392 PUTSTR (root
->sfilename
, fp
);
1398 /* Dump class ROOT and its subclasses to file FP. Value is the
1399 number of classes written. */
1402 dump_tree (fp
, root
)
1409 dump_sym (fp
, root
);
1419 for (lk
= root
->subs
; lk
; lk
= lk
->next
)
1421 fputs (TREE_STRUCT
, fp
);
1422 n
+= dump_tree (fp
, lk
->sym
);
1428 dump_members (fp
, root
->vars
);
1429 n
+= dump_members (fp
, root
->fns
);
1430 dump_members (fp
, root
->static_vars
);
1431 n
+= dump_members (fp
, root
->static_fns
);
1432 n
+= dump_members (fp
, root
->friends
);
1433 dump_members (fp
, root
->types
);
1448 /* Dump the entire class tree to file FP. */
1457 /* Output file header containing version string, command line
1461 fputs (TREE_HEADER_STRUCT
, fp
);
1462 PUTSTR (EBROWSE_FILE_VERSION
, fp
);
1475 /* Mark functions as virtual that are so because of functions
1476 declared virtual in base classes. */
1477 mark_inherited_virtual ();
1479 /* Dump the roots of the graph. */
1480 for (i
= 0; i
< TABLE_SIZE
; ++i
)
1481 for (r
= class_table
[i
]; r
; r
= r
->next
)
1484 fputs (TREE_STRUCT
, fp
);
1485 n
+= dump_tree (fp
, r
);
1495 /***********************************************************************
1497 ***********************************************************************/
1500 #define INCREMENT_LINENO \
1502 if (f_very_verbose) \
1505 printf ("%d:\n", yyline); \
1511 #define INCREMENT_LINENO ++yyline
1514 /* Define two macros for accessing the input buffer (current input
1515 file). GET(C) sets C to the next input character and advances the
1516 input pointer. UNGET retracts the input pointer. */
1518 #define GET(C) ((C) = *in++)
1519 #define UNGET() (--in)
1522 /* Process a preprocessor line. Value is the next character from the
1523 input buffer not consumed. */
1528 int in_comment
= 0, in_string
= 0;
1532 /* Skip over white space. The `#' has been consumed already. */
1533 while (WHITEP (GET (c
)))
1536 /* Read the preprocessor command (if any). */
1543 /* Is it a `define'? */
1546 if (*yytext
&& streq (yytext
, "define"))
1561 char *regexp
= matching_regexp ();
1562 int pos
= BUFFER_POS ();
1563 add_define (yytext
, regexp
, pos
);
1567 while (c
&& (c
!= '\n' || in_comment
|| in_string
))
1571 else if (c
== '/' && !in_comment
)
1576 else if (c
== '*' && in_comment
)
1582 in_string
= !in_string
;
1594 /* Value is the next token from the input buffer. */
1605 while (WHITEP (GET (c
)))
1627 /* String and character constants. */
1630 while (GET (c
) && c
!= end_char
)
1635 /* Escape sequences. */
1638 if (end_char
== '\'')
1639 yyerror ("EOF in character constant", NULL
);
1641 yyerror ("EOF in string constant", NULL
);
1659 /* Hexadecimal escape sequence. */
1661 for (i
= 0; i
< 2; ++i
)
1665 if (c
>= '0' && c
<= '7')
1667 else if (c
>= 'a' && c
<= 'f')
1669 else if (c
>= 'A' && c
<= 'F')
1682 /* Octal escape sequence. */
1684 for (i
= 0; i
< 3; ++i
)
1688 if (c
>= '0' && c
<= '7')
1705 if (end_char
== '\'')
1706 yyerror ("newline in character constant", NULL
);
1708 yyerror ("newline in string constant", NULL
);
1718 return end_char
== '\'' ? CCHAR
: CSTRING
;
1720 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1721 case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
1722 case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
1723 case 'v': case 'w': case 'x': case 'y': case 'z':
1724 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
1725 case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
1726 case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
1727 case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_':
1729 /* Identifier and keywords. */
1736 while (IDENTP (GET (*p
)))
1738 hash
= (hash
<< 1) ^ *p
++;
1739 if (p
== yytext_end
- 1)
1741 int size
= yytext_end
- yytext
;
1742 yytext
= (char *) xrealloc (yytext
, 2 * size
);
1743 yytext_end
= yytext
+ 2 * size
;
1744 p
= yytext
+ size
- 1;
1751 for (k
= keyword_table
[hash
% KEYWORD_TABLE_SIZE
]; k
; k
= k
->next
)
1752 if (streq (k
->name
, yytext
))
1759 /* C and C++ comments, '/' and '/='. */
1787 while (GET (c
) && c
!= '\n')
1862 yyerror ("invalid token '..' ('...' assumed)", NULL
);
1866 else if (!DIGITP (c
))
1920 c
= process_pp_line ();
1925 case '(': case ')': case '[': case ']': case '{': case '}':
1926 case ';': case ',': case '?': case '~':
1932 if (GET (c
) == 'x' || c
== 'X')
1937 yyival
= yyival
* 16 + c
- '0';
1938 else if (c
>= 'a' && c
<= 'f')
1939 yyival
= yyival
* 16 + c
- 'a' + 10;
1940 else if (c
>= 'A' && c
<= 'F')
1941 yyival
= yyival
* 16 + c
- 'A' + 10;
1951 while (c
>= '0' && c
<= '7')
1953 yyival
= (yyival
<< 3) + c
- '0';
1958 /* Integer suffixes. */
1964 case '1': case '2': case '3': case '4': case '5': case '6':
1965 case '7': case '8': case '9':
1966 /* Integer or floating constant, part before '.'. */
1969 while (GET (c
) && DIGITP (c
))
1970 yyival
= 10 * yyival
+ c
- '0';
1976 /* Digits following '.'. */
1980 /* Optional exponent. */
1981 if (c
== 'E' || c
== 'e')
1983 if (GET (c
) == '-' || c
== '+')
1990 /* Optional type suffixes. */
2003 /* Actually local to matching_regexp. These variables must be in
2004 global scope for the case that `static' get's defined away. */
2006 static char *matching_regexp_buffer
, *matching_regexp_end_buf
;
2009 /* Value is the string from the start of the line to the current
2010 position in the input buffer, or maybe a bit more if that string is
2011 shorter than min_regexp. */
2023 if (matching_regexp_buffer
== NULL
)
2025 matching_regexp_buffer
= (char *) xmalloc (max_regexp
);
2026 matching_regexp_end_buf
= &matching_regexp_buffer
[max_regexp
] - 1;
2029 /* Scan back to previous newline of buffer start. */
2030 for (p
= in
- 1; p
> inbuffer
&& *p
!= '\n'; --p
)
2035 while (in
- p
< min_regexp
&& p
> inbuffer
)
2037 /* Line probably not significant enough */
2038 for (--p
; p
>= inbuffer
&& *p
!= '\n'; --p
)
2045 /* Copy from end to make sure significant portions are included.
2046 This implies that in the browser a regular expressing of the form
2047 `^.*{regexp}' has to be used. */
2048 for (s
= matching_regexp_end_buf
- 1, t
= in
;
2049 s
> matching_regexp_buffer
&& t
> p
;)
2057 *(matching_regexp_end_buf
- 1) = '\0';
2062 /* Return a printable representation of token T. */
2072 case CSTRING
: return "string constant";
2073 case CCHAR
: return "char constant";
2074 case CINT
: return "int constant";
2075 case CFLOAT
: return "floating constant";
2076 case ELLIPSIS
: return "...";
2077 case LSHIFTASGN
: return "<<=";
2078 case RSHIFTASGN
: return ">>=";
2079 case ARROWSTAR
: return "->*";
2080 case IDENT
: return "identifier";
2081 case DIVASGN
: return "/=";
2082 case INC
: return "++";
2083 case ADDASGN
: return "+=";
2084 case DEC
: return "--";
2085 case ARROW
: return "->";
2086 case SUBASGN
: return "-=";
2087 case MULASGN
: return "*=";
2088 case MODASGN
: return "%=";
2089 case LOR
: return "||";
2090 case ORASGN
: return "|=";
2091 case LAND
: return "&&";
2092 case ANDASGN
: return "&=";
2093 case XORASGN
: return "^=";
2094 case POINTSTAR
: return ".*";
2095 case DCOLON
: return "::";
2096 case EQ
: return "==";
2097 case NE
: return "!=";
2098 case LE
: return "<=";
2099 case LSHIFT
: return "<<";
2100 case GE
: return ">=";
2101 case RSHIFT
: return ">>";
2102 case ASM
: return "asm";
2103 case AUTO
: return "auto";
2104 case BREAK
: return "break";
2105 case CASE
: return "case";
2106 case CATCH
: return "catch";
2107 case CHAR
: return "char";
2108 case CLASS
: return "class";
2109 case CONST
: return "const";
2110 case CONTINUE
: return "continue";
2111 case DEFAULT
: return "default";
2112 case DELETE
: return "delete";
2113 case DO
: return "do";
2114 case DOUBLE
: return "double";
2115 case ELSE
: return "else";
2116 case ENUM
: return "enum";
2117 case EXTERN
: return "extern";
2118 case FLOAT
: return "float";
2119 case FOR
: return "for";
2120 case FRIEND
: return "friend";
2121 case GOTO
: return "goto";
2122 case IF
: return "if";
2123 case T_INLINE
: return "inline";
2124 case INT
: return "int";
2125 case LONG
: return "long";
2126 case NEW
: return "new";
2127 case OPERATOR
: return "operator";
2128 case PRIVATE
: return "private";
2129 case PROTECTED
: return "protected";
2130 case PUBLIC
: return "public";
2131 case REGISTER
: return "register";
2132 case RETURN
: return "return";
2133 case SHORT
: return "short";
2134 case SIGNED
: return "signed";
2135 case SIZEOF
: return "sizeof";
2136 case STATIC
: return "static";
2137 case STRUCT
: return "struct";
2138 case SWITCH
: return "switch";
2139 case TEMPLATE
: return "template";
2140 case THIS
: return "this";
2141 case THROW
: return "throw";
2142 case TRY
: return "try";
2143 case TYPEDEF
: return "typedef";
2144 case UNION
: return "union";
2145 case UNSIGNED
: return "unsigned";
2146 case VIRTUAL
: return "virtual";
2147 case VOID
: return "void";
2148 case VOLATILE
: return "volatile";
2149 case WHILE
: return "while";
2150 case MUTABLE
: return "mutable";
2151 case BOOL
: return "bool";
2152 case TRUE
: return "true";
2153 case FALSE
: return "false";
2154 case SIGNATURE
: return "signature";
2155 case NAMESPACE
: return "namespace";
2156 case EXPLICIT
: return "explicit";
2157 case TYPENAME
: return "typename";
2158 case CONST_CAST
: return "const_cast";
2159 case DYNAMIC_CAST
: return "dynamic_cast";
2160 case REINTERPRET_CAST
: return "reinterpret_cast";
2161 case STATIC_CAST
: return "static_cast";
2162 case TYPEID
: return "typeid";
2163 case USING
: return "using";
2164 case WCHAR
: return "wchar_t";
2165 case YYEOF
: return "EOF";
2180 /* Reinitialize the scanner for a new input file. */
2191 yytext
= (char *) xmalloc (size
* sizeof *yytext
);
2192 yytext_end
= yytext
+ size
;
2197 /* Insert a keyword NAME with token value TK into the keyword hash
2201 insert_keyword (name
, tk
)
2207 struct kw
*k
= (struct kw
*) xmalloc (sizeof *k
);
2209 for (s
= name
; *s
; ++s
)
2212 h
%= KEYWORD_TABLE_SIZE
;
2215 k
->next
= keyword_table
[h
];
2216 keyword_table
[h
] = k
;
2220 /* Initialize the scanner for the first file. This sets up the
2221 character class vectors and fills the keyword hash table. */
2228 /* Allocate the input buffer */
2229 inbuffer_size
= READ_CHUNK_SIZE
+ 1;
2230 inbuffer
= in
= (char *) xmalloc (inbuffer_size
);
2233 /* Set up character class vectors. */
2234 for (i
= 0; i
< sizeof is_ident
; ++i
)
2236 if (i
== '_' || isalnum (i
))
2239 if (i
>= '0' && i
<= '9')
2242 if (i
== ' ' || i
== '\t' || i
== '\f' || i
== '\v')
2246 /* Fill keyword hash table. */
2247 insert_keyword ("and", LAND
);
2248 insert_keyword ("and_eq", ANDASGN
);
2249 insert_keyword ("asm", ASM
);
2250 insert_keyword ("auto", AUTO
);
2251 insert_keyword ("bitand", '&');
2252 insert_keyword ("bitor", '|');
2253 insert_keyword ("bool", BOOL
);
2254 insert_keyword ("break", BREAK
);
2255 insert_keyword ("case", CASE
);
2256 insert_keyword ("catch", CATCH
);
2257 insert_keyword ("char", CHAR
);
2258 insert_keyword ("class", CLASS
);
2259 insert_keyword ("compl", '~');
2260 insert_keyword ("const", CONST
);
2261 insert_keyword ("const_cast", CONST_CAST
);
2262 insert_keyword ("continue", CONTINUE
);
2263 insert_keyword ("default", DEFAULT
);
2264 insert_keyword ("delete", DELETE
);
2265 insert_keyword ("do", DO
);
2266 insert_keyword ("double", DOUBLE
);
2267 insert_keyword ("dynamic_cast", DYNAMIC_CAST
);
2268 insert_keyword ("else", ELSE
);
2269 insert_keyword ("enum", ENUM
);
2270 insert_keyword ("explicit", EXPLICIT
);
2271 insert_keyword ("extern", EXTERN
);
2272 insert_keyword ("false", FALSE
);
2273 insert_keyword ("float", FLOAT
);
2274 insert_keyword ("for", FOR
);
2275 insert_keyword ("friend", FRIEND
);
2276 insert_keyword ("goto", GOTO
);
2277 insert_keyword ("if", IF
);
2278 insert_keyword ("inline", T_INLINE
);
2279 insert_keyword ("int", INT
);
2280 insert_keyword ("long", LONG
);
2281 insert_keyword ("mutable", MUTABLE
);
2282 insert_keyword ("namespace", NAMESPACE
);
2283 insert_keyword ("new", NEW
);
2284 insert_keyword ("not", '!');
2285 insert_keyword ("not_eq", NE
);
2286 insert_keyword ("operator", OPERATOR
);
2287 insert_keyword ("or", LOR
);
2288 insert_keyword ("or_eq", ORASGN
);
2289 insert_keyword ("private", PRIVATE
);
2290 insert_keyword ("protected", PROTECTED
);
2291 insert_keyword ("public", PUBLIC
);
2292 insert_keyword ("register", REGISTER
);
2293 insert_keyword ("reinterpret_cast", REINTERPRET_CAST
);
2294 insert_keyword ("return", RETURN
);
2295 insert_keyword ("short", SHORT
);
2296 insert_keyword ("signed", SIGNED
);
2297 insert_keyword ("sizeof", SIZEOF
);
2298 insert_keyword ("static", STATIC
);
2299 insert_keyword ("static_cast", STATIC_CAST
);
2300 insert_keyword ("struct", STRUCT
);
2301 insert_keyword ("switch", SWITCH
);
2302 insert_keyword ("template", TEMPLATE
);
2303 insert_keyword ("this", THIS
);
2304 insert_keyword ("throw", THROW
);
2305 insert_keyword ("true", TRUE
);
2306 insert_keyword ("try", TRY
);
2307 insert_keyword ("typedef", TYPEDEF
);
2308 insert_keyword ("typeid", TYPEID
);
2309 insert_keyword ("typename", TYPENAME
);
2310 insert_keyword ("union", UNION
);
2311 insert_keyword ("unsigned", UNSIGNED
);
2312 insert_keyword ("using", USING
);
2313 insert_keyword ("virtual", VIRTUAL
);
2314 insert_keyword ("void", VOID
);
2315 insert_keyword ("volatile", VOLATILE
);
2316 insert_keyword ("wchar_t", WCHAR
);
2317 insert_keyword ("while", WHILE
);
2318 insert_keyword ("xor", '^');
2319 insert_keyword ("xor_eq", XORASGN
);
2324 /***********************************************************************
2326 ***********************************************************************/
2328 /* Match the current lookahead token and set it to the next token. */
2330 #define MATCH() (tk = yylex ())
2332 /* Return the lookahead token. If current lookahead token is cleared,
2333 read a new token. */
2335 #define LA1 (tk == -1 ? (tk = yylex ()) : tk)
2337 /* Is the current lookahead equal to the token T? */
2339 #define LOOKING_AT(T) (tk == (T))
2341 /* Is the current lookahead one of T1 or T2? */
2343 #define LOOKING_AT2(T1, T2) (tk == (T1) || tk == (T2))
2345 /* Is the current lookahead one of T1, T2 or T3? */
2347 #define LOOKING_AT3(T1, T2, T3) (tk == (T1) || tk == (T2) || tk == (T3))
2349 /* Is the current lookahead one of T1...T4? */
2351 #define LOOKING_AT4(T1, T2, T3, T4) \
2352 (tk == (T1) || tk == (T2) || tk == (T3) || tk == (T4))
2354 /* Match token T if current lookahead is T. */
2356 #define MATCH_IF(T) if (LOOKING_AT (T)) MATCH (); else ((void) 0)
2358 /* Skip to matching token if current token is T. */
2360 #define SKIP_MATCHING_IF(T) \
2361 if (LOOKING_AT (T)) skip_matching (); else ((void) 0)
2364 /* Skip forward until a given token TOKEN or YYEOF is seen and return
2365 the current lookahead token after skipping. */
2371 while (!LOOKING_AT2 (YYEOF
, token
))
2376 /* Skip over pairs of tokens (parentheses, square brackets,
2377 angle brackets, curly brackets) matching the current lookahead. */
2408 if (LOOKING_AT (open
))
2410 else if (LOOKING_AT (close
))
2412 else if (LOOKING_AT (YYEOF
))
2423 /* Build qualified namespace alias (A::B::c) and return it. */
2426 match_qualified_namespace_alias ()
2428 struct link
*head
= NULL
;
2429 struct link
*cur
= NULL
;
2430 struct link
*tmp
= NULL
;
2438 tmp
= (struct link
*) xmalloc (sizeof *cur
);
2439 tmp
->sym
= find_namespace (yytext
, cur
);
2443 cur
= cur
->next
= tmp
;
2460 /* Re-initialize the parser by resetting the lookahead token. */
2469 /* Parse a parameter list, including the const-specifier,
2470 pure-specifier, and throw-list that may follow a parameter list.
2471 Return in FLAGS what was seen following the parameter list.
2472 Returns a hash code for the parameter types. This value is used to
2473 distinguish between overloaded functions. */
2482 while (!LOOKING_AT2 (YYEOF
, ')'))
2486 /* Skip over grouping parens or parameter lists in parameter
2492 /* Next parameter. */
2498 /* Ignore the scope part of types, if any. This is because
2499 some types need scopes when defined outside of a class body,
2500 and don't need them inside the class body. This means that
2501 we have to look for the last IDENT in a sequence of
2502 IDENT::IDENT::... */
2507 unsigned ident_type_hash
= 0;
2509 parse_qualified_param_ident_or_type (&last_id
);
2512 /* LAST_ID null means something like `X::*'. */
2513 for (; *last_id
; ++last_id
)
2514 ident_type_hash
= (ident_type_hash
<< 1) ^ *last_id
;
2515 hash
= (hash
<< 1) ^ ident_type_hash
;
2524 /* This distinction is made to make `func (void)' equivalent
2528 if (!LOOKING_AT (')'))
2529 hash
= (hash
<< 1) ^ VOID
;
2532 case BOOL
: case CHAR
: case CLASS
: case CONST
:
2533 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2534 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2535 case UNION
: case UNSIGNED
: case VOLATILE
: case WCHAR
:
2538 hash
= (hash
<< 1) ^ LA1
;
2542 case '*': case '&': case '[': case ']':
2543 hash
= (hash
<< 1) ^ LA1
;
2553 if (LOOKING_AT (')'))
2557 if (LOOKING_AT (CONST
))
2559 /* We can overload the same function on `const' */
2560 hash
= (hash
<< 1) ^ CONST
;
2561 SET_FLAG (*flags
, F_CONST
);
2565 if (LOOKING_AT (THROW
))
2568 SKIP_MATCHING_IF ('(');
2569 SET_FLAG (*flags
, F_THROW
);
2572 if (LOOKING_AT ('='))
2575 if (LOOKING_AT (CINT
) && yyival
== 0)
2578 SET_FLAG (*flags
, F_PURE
);
2587 /* Print position info to stdout. */
2592 if (info_position
>= 0 && BUFFER_POS () <= info_position
)
2594 printf ("(\"%s\" \"%s\" \"%s\" %d)\n",
2595 info_cls
->name
, sym_scope (info_cls
),
2596 info_member
->name
, info_where
);
2600 /* Parse a member declaration within the class body of CLS. VIS is
2601 the access specifier for the member (private, protected,
2611 char *regexp
= NULL
;
2622 while (!LOOKING_AT4 (';', '{', '}', YYEOF
))
2630 /* A function or class may follow. */
2633 SET_FLAG (flags
, F_TEMPLATE
);
2634 /* Skip over template argument list */
2635 SKIP_MATCHING_IF ('<');
2639 SET_FLAG (flags
, F_EXPLICIT
);
2643 SET_FLAG (flags
, F_MUTABLE
);
2647 SET_FLAG (flags
, F_INLINE
);
2651 SET_FLAG (flags
, F_VIRTUAL
);
2680 /* Remember IDENTS seen so far. Among these will be the member
2682 id
= (char *) xrealloc (id
, strlen (yytext
) + 2);
2686 strcpy (id
+ 1, yytext
);
2689 strcpy (id
, yytext
);
2695 char *s
= operator_name (&sc
);
2696 id
= (char *) xrealloc (id
, strlen (s
) + 1);
2702 /* Most probably the beginning of a parameter list. */
2708 if (!(is_constructor
= streq (id
, cls
->name
)))
2709 regexp
= matching_regexp ();
2714 pos
= BUFFER_POS ();
2715 hash
= parm_list (&flags
);
2718 regexp
= matching_regexp ();
2720 if (id
&& cls
!= NULL
)
2721 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, flags
);
2723 while (!LOOKING_AT3 (';', '{', YYEOF
))
2726 if (LOOKING_AT ('{') && id
&& cls
)
2727 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0, sc
, flags
);
2734 case STRUCT
: case UNION
: case CLASS
:
2741 /* More than one ident here to allow for MS-DOS specialties
2742 like `_export class' etc. The last IDENT seen counts
2743 as the class name. */
2744 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
2746 if (LOOKING_AT (IDENT
))
2751 if (LOOKING_AT2 (':', '{'))
2752 class_definition (anonymous
? NULL
: cls
, class_tag
, flags
, 1);
2757 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
2758 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
2759 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
2768 if (LOOKING_AT (';'))
2770 /* The end of a member variable, a friend declaration or an access
2771 declaration. We don't want to add friend classes as members. */
2772 if (id
&& sc
!= SC_FRIEND
&& cls
)
2774 regexp
= matching_regexp ();
2775 pos
= BUFFER_POS ();
2779 if (type_seen
|| !paren_seen
)
2780 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2782 add_member_decl (cls
, id
, regexp
, pos
, hash
, 0, sc
, vis
, 0);
2789 else if (LOOKING_AT ('{'))
2792 if (sc
== SC_TYPE
&& id
&& cls
)
2794 regexp
= matching_regexp ();
2795 pos
= BUFFER_POS ();
2799 add_member_decl (cls
, id
, regexp
, pos
, 0, 1, sc
, vis
, 0);
2800 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, sc
, 0);
2812 /* Parse the body of class CLS. TAG is the tag of the class (struct,
2816 class_body (cls
, tag
)
2820 int vis
= tag
== CLASS
? PRIVATE
: PUBLIC
;
2823 while (!LOOKING_AT2 (YYEOF
, '}'))
2827 case PRIVATE
: case PROTECTED
: case PUBLIC
:
2831 if (LOOKING_AT (':'))
2838 /* Probably conditional compilation for inheritance list.
2839 We don't known whether there comes more of this.
2840 This is only a crude fix that works most of the time. */
2845 while (LOOKING_AT2 (IDENT
, ',')
2846 || LOOKING_AT3 (PUBLIC
, PROTECTED
, PRIVATE
));
2855 /* Try to synchronize */
2856 case CHAR
: case CLASS
: case CONST
:
2857 case DOUBLE
: case ENUM
: case FLOAT
: case INT
:
2858 case LONG
: case SHORT
: case SIGNED
: case STRUCT
:
2859 case UNION
: case UNSIGNED
: case VOID
: case VOLATILE
:
2860 case TYPEDEF
: case STATIC
: case T_INLINE
: case FRIEND
:
2861 case VIRTUAL
: case TEMPLATE
: case IDENT
: case '~':
2862 case BOOL
: case WCHAR
: case EXPLICIT
: case MUTABLE
:
2874 /* Parse a qualified identifier. Current lookahead is IDENT. A
2875 qualified ident has the form `X<..>::Y<...>::T<...>. Returns a
2876 symbol for that class. */
2881 struct sym
*last_class
= NULL
;
2883 while (LOOKING_AT (IDENT
))
2885 last_class
= add_sym (yytext
, last_class
);
2888 if (LOOKING_AT ('<'))
2891 SET_FLAG (last_class
->flags
, F_TEMPLATE
);
2894 if (!LOOKING_AT (DCOLON
))
2904 /* Parse an operator name. Add the `static' flag to *SC if an
2905 implicitly static operator has been parsed. Value is a pointer to
2906 a static buffer holding the constructed operator name string. */
2912 static int id_size
= 0;
2913 static char *id
= NULL
;
2919 if (LOOKING_AT2 (NEW
, DELETE
))
2921 /* `new' and `delete' are implicitly static. */
2922 if (*sc
!= SC_FRIEND
)
2925 s
= token_string (LA1
);
2928 len
= strlen (s
) + 10;
2931 int new_size
= max (len
, 2 * id_size
);
2932 id
= (char *) xrealloc (id
, new_size
);
2937 /* Vector new or delete? */
2938 if (LOOKING_AT ('['))
2943 if (LOOKING_AT (']'))
2952 int tokens_matched
= 0;
2957 int new_size
= max (len
, 2 * id_size
);
2958 id
= (char *) xrealloc (id
, new_size
);
2961 strcpy (id
, "operator");
2963 /* Beware access declarations of the form "X::f;" Beware of
2964 `operator () ()'. Yet another difficulty is found in
2965 GCC 2.95's STL: `operator == __STL_NULL_TMPL_ARGS (...'. */
2966 while (!(LOOKING_AT ('(') && tokens_matched
)
2967 && !LOOKING_AT2 (';', YYEOF
))
2969 s
= token_string (LA1
);
2970 len
+= strlen (s
) + 2;
2973 int new_size
= max (len
, 2 * id_size
);
2974 id
= (char *) xrealloc (id
, new_size
);
2978 if (*s
!= ')' && *s
!= ']')
2983 /* If this is a simple operator like `+', stop now. */
2984 if (!isalpha ((unsigned char) *s
) && *s
!= '(' && *s
!= '[')
2995 /* This one consumes the last IDENT of a qualified member name like
2996 `X::Y::z'. This IDENT is returned in LAST_ID. Value is the
2997 symbol structure for the ident. */
3000 parse_qualified_ident_or_type (last_id
)
3003 struct sym
*cls
= NULL
;
3008 while (LOOKING_AT (IDENT
))
3010 int len
= strlen (yytext
) + 1;
3013 id
= (char *) xrealloc (id
, len
);
3016 strcpy (id
, yytext
);
3020 SKIP_MATCHING_IF ('<');
3022 if (LOOKING_AT (DCOLON
))
3024 struct sym
*pcn
= NULL
;
3025 struct link
*pna
= check_namespace_alias (id
);
3030 enter_namespace (pna
->sym
->name
);
3036 else if ((pcn
= check_namespace (id
, current_namespace
)))
3038 enter_namespace (pcn
->name
);
3042 cls
= add_sym (id
, cls
);
3061 /* This one consumes the last IDENT of a qualified member name like
3062 `X::Y::z'. This IDENT is returned in LAST_ID. Value is the
3063 symbol structure for the ident. */
3066 parse_qualified_param_ident_or_type (last_id
)
3069 struct sym
*cls
= NULL
;
3070 static char *id
= NULL
;
3071 static int id_size
= 0;
3073 while (LOOKING_AT (IDENT
))
3075 int len
= strlen (yytext
) + 1;
3078 id
= (char *) xrealloc (id
, len
);
3081 strcpy (id
, yytext
);
3085 SKIP_MATCHING_IF ('<');
3087 if (LOOKING_AT (DCOLON
))
3089 cls
= add_sym (id
, cls
);
3099 /* Parse a class definition.
3101 CONTAINING is the class containing the class being parsed or null.
3102 This may also be null if NESTED != 0 if the containing class is
3103 anonymous. TAG is the tag of the class (struct, union, class).
3104 NESTED is non-zero if we are parsing a nested class.
3106 Current lookahead is the class name. */
3109 class_definition (containing
, tag
, flags
, nested
)
3110 struct sym
*containing
;
3115 struct sym
*current
;
3116 struct sym
*base_class
;
3118 /* Set CURRENT to null if no entry has to be made for the class
3119 parsed. This is the case for certain command line flag
3121 if ((tag
!= CLASS
&& !f_structs
) || (nested
&& !f_nested_classes
))
3125 current
= add_sym (yytext
, containing
);
3126 current
->pos
= BUFFER_POS ();
3127 current
->regexp
= matching_regexp ();
3128 current
->filename
= filename
;
3129 current
->flags
= flags
;
3132 /* If at ':', base class list follows. */
3133 if (LOOKING_AT (':'))
3142 case VIRTUAL
: case PUBLIC
: case PROTECTED
: case PRIVATE
:
3147 base_class
= parse_classname ();
3148 if (base_class
&& current
&& base_class
!= current
)
3149 add_link (base_class
, current
);
3152 /* The `,' between base classes or the end of the base
3153 class list. Add the previously found base class.
3154 It's done this way to skip over sequences of
3155 `A::B::C' until we reach the end.
3157 FIXME: it is now possible to handle `class X : public B::X'
3158 because we have enough information. */
3164 /* A syntax error, possibly due to preprocessor constructs
3170 class A : private B.
3172 MATCH until we see something like `;' or `{'. */
3173 while (!LOOKING_AT3 (';', YYEOF
, '{'))
3184 /* Parse the class body if there is one. */
3185 if (LOOKING_AT ('{'))
3187 if (tag
!= CLASS
&& !f_structs
)
3192 class_body (current
, tag
);
3194 if (LOOKING_AT ('}'))
3197 if (LOOKING_AT (';') && !nested
)
3205 /* Parse a declaration. */
3212 struct sym
*cls
= NULL
;
3213 char *regexp
= NULL
;
3219 while (!LOOKING_AT3 (';', '{', YYEOF
))
3242 case INT
: case CHAR
: case LONG
: case UNSIGNED
:
3243 case SIGNED
: case CONST
: case DOUBLE
: case VOID
:
3244 case SHORT
: case VOLATILE
: case BOOL
: case WCHAR
:
3248 case CLASS
: case STRUCT
: case UNION
:
3249 /* This is for the case `STARTWRAP class X : ...' or
3250 `declare (X, Y)\n class A : ...'. */
3258 /* Assumed to be the start of an initialization in this context.
3259 Skip over everything up to ';'. */
3265 char *s
= operator_name (&sc
);
3266 id
= (char *) xrealloc (id
, strlen (s
) + 1);
3272 SET_FLAG (flags
, F_INLINE
);
3278 if (LOOKING_AT (IDENT
))
3280 id
= (char *) xrealloc (id
, strlen (yytext
) + 2);
3282 strcpy (id
+ 1, yytext
);
3288 cls
= parse_qualified_ident_or_type (&id
);
3292 /* Most probably the beginning of a parameter list. */
3299 if (!(is_constructor
= streq (id
, cls
->name
)))
3300 regexp
= matching_regexp ();
3305 pos
= BUFFER_POS ();
3306 hash
= parm_list (&flags
);
3309 regexp
= matching_regexp ();
3312 add_member_defn (cls
, id
, regexp
, pos
, hash
, 0,
3317 /* This may be a C functions, but also a macro
3318 call of the form `declare (A, B)' --- such macros
3319 can be found in some class libraries. */
3324 regexp
= matching_regexp ();
3325 pos
= BUFFER_POS ();
3326 hash
= parm_list (&flags
);
3327 add_global_decl (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3330 /* This is for the case that the function really is
3331 a macro with no `;' following it. If a CLASS directly
3332 follows, we would miss it otherwise. */
3333 if (LOOKING_AT3 (CLASS
, STRUCT
, UNION
))
3337 while (!LOOKING_AT3 (';', '{', YYEOF
))
3340 if (!cls
&& id
&& LOOKING_AT ('{'))
3341 add_global_defn (id
, regexp
, pos
, hash
, 0, sc
, flags
);
3349 if (LOOKING_AT (';'))
3351 /* The end of a member variable or of an access declaration
3352 `X::f'. To distinguish between them we have to know whether
3353 type information has been seen. */
3356 char *regexp
= matching_regexp ();
3357 int pos
= BUFFER_POS ();
3360 add_member_defn (cls
, id
, regexp
, pos
, 0, 1, SC_UNKNOWN
, flags
);
3362 add_global_defn (id
, regexp
, pos
, 0, 1, sc
, flags
);
3368 else if (LOOKING_AT ('{'))
3370 if (sc
== SC_TYPE
&& id
)
3372 /* A named enumeration. */
3373 regexp
= matching_regexp ();
3374 pos
= BUFFER_POS ();
3375 add_global_defn (id
, regexp
, pos
, 0, 1, sc
, flags
);
3386 /* Parse a list of top-level declarations/definitions. START_FLAGS
3387 says in which context we are parsing. If it is F_EXTERNC, we are
3388 parsing in an `extern "C"' block. Value is 1 if EOF is reached, 0
3392 globals (start_flags
)
3397 int flags
= start_flags
;
3409 if (LOOKING_AT (IDENT
))
3411 char *namespace_name
= xstrdup (yytext
);
3414 if (LOOKING_AT ('='))
3416 struct link
*qna
= match_qualified_namespace_alias ();
3418 register_namespace_alias (namespace_name
, qna
);
3420 if (skip_to (';') == ';')
3423 else if (LOOKING_AT ('{'))
3426 enter_namespace (namespace_name
);
3432 xfree (namespace_name
);
3439 if (LOOKING_AT (CSTRING
) && *string_start
== 'C'
3440 && *(string_start
+ 1) == '"')
3442 /* This is `extern "C"'. */
3445 if (LOOKING_AT ('{'))
3448 globals (F_EXTERNC
);
3452 SET_FLAG (flags
, F_EXTERNC
);
3458 SKIP_MATCHING_IF ('<');
3459 SET_FLAG (flags
, F_TEMPLATE
);
3462 case CLASS
: case STRUCT
: case UNION
:
3467 /* More than one ident here to allow for MS-DOS and OS/2
3468 specialties like `far', `_Export' etc. Some C++ libs
3469 have constructs like `_OS_DLLIMPORT(_OS_CLIENT)' in front
3470 of the class name. */
3471 while (!LOOKING_AT4 (YYEOF
, ';', ':', '{'))
3473 if (LOOKING_AT (IDENT
))
3478 /* Don't add anonymous unions. */
3479 if (LOOKING_AT2 (':', '{') && !anonymous
)
3480 class_definition (NULL
, class_tk
, flags
, 0);
3483 if (skip_to (';') == ';')
3487 flags
= start_flags
;
3497 declaration (flags
);
3498 flags
= start_flags
;
3503 yyerror ("parse error", NULL
);
3508 /* Parse the current input file. */
3513 while (globals (0) == 0)
3519 /***********************************************************************
3521 ***********************************************************************/
3523 /* Add the list of paths PATH_LIST to the current search path for
3527 add_search_path (path_list
)
3532 char *start
= path_list
;
3533 struct search_path
*p
;
3535 while (*path_list
&& *path_list
!= PATH_LIST_SEPARATOR
)
3538 p
= (struct search_path
*) xmalloc (sizeof *p
);
3539 p
->path
= (char *) xmalloc (path_list
- start
+ 1);
3540 memcpy (p
->path
, start
, path_list
- start
);
3541 p
->path
[path_list
- start
] = '\0';
3544 if (search_path_tail
)
3546 search_path_tail
->next
= p
;
3547 search_path_tail
= p
;
3550 search_path
= search_path_tail
= p
;
3552 while (*path_list
== PATH_LIST_SEPARATOR
)
3558 /* Open FILE and return a file handle for it, or -1 if FILE cannot be
3559 opened. Try to find FILE in search_path first, then try the
3560 unchanged file name. */
3567 static char *buffer
;
3568 static int buffer_size
;
3569 struct search_path
*path
;
3570 int flen
= strlen (file
) + 1; /* +1 for the slash */
3572 filename
= xstrdup (file
);
3574 for (path
= search_path
; path
&& fp
== NULL
; path
= path
->next
)
3576 int len
= strlen (path
->path
) + flen
;
3578 if (len
+ 1 >= buffer_size
)
3580 buffer_size
= max (len
+ 1, 2 * buffer_size
);
3581 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3584 strcpy (buffer
, path
->path
);
3585 strcat (buffer
, "/");
3586 strcat (buffer
, file
);
3587 fp
= fopen (buffer
, "r");
3590 /* Try the original file name. */
3592 fp
= fopen (file
, "r");
3595 yyerror ("cannot open", NULL
);
3601 /* Display usage information and exit program. */
3604 Usage: ebrowse [options] {files}\n\
3606 -a, --append append output to existing file\n\
3607 -f, --files=FILES read input file names from FILE\n\
3608 -I, --search-path=LIST set search path for input files\n\
3609 -m, --min-regexp-length=N set minimum regexp length to N\n\
3610 -M, --max-regexp-length=N set maximum regexp length to N\n\
3611 -n, --no-nested-classes exclude nested classes\n\
3612 -o, --output-file=FILE set output file name to FILE\n\
3613 -p, --position-info print info about position in file\n\
3614 -s, --no-structs-or-unions don't record structs or unions\n\
3615 -v, --verbose be verbose\n\
3616 -V, --very-verbose be very verbose\n\
3617 -x, --no-regexps don't record regular expressions\n\
3618 --help display this help\n\
3619 --version display version info\n\
3627 exit (error
? 1 : 0);
3631 /* Display version and copyright info. The VERSION macro is set
3632 from the Makefile and contains the Emacs version. */
3635 # define VERSION "21"
3641 printf ("ebrowse %s\n", VERSION
);
3642 puts ("Copyright (C) 1992-1999, 2000, 2001 Free Software Foundation, Inc.");
3643 puts ("This program is distributed under the same terms as Emacs.");
3648 /* Parse one input file FILE, adding classes and members to the symbol
3657 fp
= open_file (file
);
3662 /* Give a progress indication if needed. */
3674 /* Read file to inbuffer. */
3677 if (nread
+ READ_CHUNK_SIZE
>= inbuffer_size
)
3679 inbuffer_size
= nread
+ READ_CHUNK_SIZE
+ 1;
3680 inbuffer
= (char *) xrealloc (inbuffer
, inbuffer_size
);
3683 nbytes
= fread (inbuffer
+ nread
, 1, READ_CHUNK_SIZE
, fp
);
3690 inbuffer
[nread
] = '\0';
3692 /* Reinitialize scanner and parser for the new input file. */
3696 /* Parse it and close the file. */
3703 /* Read a line from stream FP and return a pointer to a static buffer
3704 containing its contents without the terminating newline. Value
3705 is null when EOF is reached. */
3711 static char *buffer
;
3712 static int buffer_size
;
3715 while ((c
= getc (fp
)) != EOF
&& c
!= '\n')
3717 if (i
>= buffer_size
)
3719 buffer_size
= max (100, buffer_size
* 2);
3720 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3726 if (c
== EOF
&& i
== 0)
3729 if (i
== buffer_size
)
3731 buffer_size
= max (100, buffer_size
* 2);
3732 buffer
= (char *) xrealloc (buffer
, buffer_size
);
3736 if (i
> 0 && buffer
[i
- 1] == '\r')
3737 buffer
[i
- 1] = '\0';
3742 /* Main entry point. */
3750 int any_inputfiles
= 0;
3751 static char *out_filename
= DEFAULT_OUTFILE
;
3752 static char **input_filenames
= NULL
;
3753 static int input_filenames_size
= 0;
3754 static int n_input_files
;
3756 filename
= "command line";
3759 while ((i
= getopt_long (argc
, argv
, "af:I:m:M:no:p:svVx",
3760 options
, NULL
)) != EOF
)
3766 info_position
= atoi (optarg
);
3770 f_nested_classes
= 0;
3777 /* Add the name of a file containing more input files. */
3779 if (n_input_files
== input_filenames_size
)
3781 input_filenames_size
= max (10, 2 * input_filenames_size
);
3782 input_filenames
= (char **) xrealloc ((void *)input_filenames
,
3783 input_filenames_size
);
3785 input_filenames
[n_input_files
++] = xstrdup (optarg
);
3788 /* Append new output to output file instead of truncating it. */
3793 /* Include structs in the output */
3798 /* Be verbose (give a progress indication). */
3803 /* Be very verbose (print file names as they are processed). */
3809 /* Change the name of the output file. */
3811 out_filename
= optarg
;
3814 /* Set minimum length for regular expression strings
3815 when recorded in the output file. */
3817 min_regexp
= atoi (optarg
);
3820 /* Set maximum length for regular expression strings
3821 when recorded in the output file. */
3823 max_regexp
= atoi (optarg
);
3826 /* Add to search path. */
3828 add_search_path (optarg
);
3842 /* Call init_scanner after command line flags have been processed to be
3843 able to add keywords depending on command line (not yet
3848 /* Open output file */
3853 /* Check that the file to append to exists, and is not
3854 empty. More specifically, it should be a valid file
3855 produced by a previous run of ebrowse, but that's too
3856 difficult to check. */
3860 fp
= fopen (out_filename
, "r");
3862 yyerror ("file `%s' must exist for --append", out_filename
);
3864 rc
= fseek (fp
, 0, SEEK_END
);
3866 yyerror ("error seeking in file `%s'", out_filename
);
3870 yyerror ("error getting size of file `%s'", out_filename
);
3872 yyerror ("file `%s' is empty", out_filename
);
3877 yyout
= fopen (out_filename
, f_append
? "a" : "w");
3880 yyerror ("cannot open output file `%s'", out_filename
);
3885 /* Process input files specified on the command line. */
3886 while (optind
< argc
)
3888 process_file (argv
[optind
++]);
3892 /* Process files given on stdin if no files specified. */
3893 if (!any_inputfiles
&& n_input_files
== 0)
3896 while ((file
= read_line (stdin
)) != NULL
)
3897 process_file (file
);
3901 /* Process files from `--files=FILE'. Every line in FILE names
3902 one input file to process. */
3903 for (i
= 0; i
< n_input_files
; ++i
)
3905 FILE *fp
= fopen (input_filenames
[i
], "r");
3908 yyerror ("cannot open input file `%s'", input_filenames
[i
]);
3912 while ((file
= read_line (fp
)) != NULL
)
3913 process_file (file
);
3919 /* Write output file. */
3922 /* Close output file. */
3923 if (yyout
!= stdout
)
3930 /* ebrowse.c ends here. */