lib-src/ebrowse.c

   1 /* ebrowse.c --- parsing files for the ebrowse C++ browser
   2
   3    Copyright (C) 1992,92,94,95,96,97,98,99,2000,2001
   4       Free Software Foundation Inc.
   5
   6    Author: Gerd Moellmann <gerd@gnu.org>
   7    Maintainer: FSF
   8
   9    This file is part of GNU Emacs.
  10
  11    GNU Emacs is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2, or (at your option)
  14    any later version.
  15
  16    GNU Emacs is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with GNU Emacs; see the file COPYING.  If not, write to
  23    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <assert.h>
  34 #include "getopt.h"
  35
  36 /* Conditionalize function prototypes.  */
  37
  38 #ifdef PROTOTYPES               /* From config.h.  */
  39 #define P_(x) x
  40 #else
  41 #define P_(x) ()
  42 #endif
  43
  44 /* Value is non-zero if strings X and Y compare equal.  */
  45
  46 #define streq(X, Y) (*(X) == *(Y) && strcmp ((X) + 1, (Y) + 1) == 0)
  47
  48 /* The ubiquitous `max' and `min' macros.  */
  49
  50 #ifndef max
  51 #define max(X, Y)       ((X) > (Y) ? (X) : (Y))
  52 #define min(X, Y)       ((X) < (Y) ? (X) : (Y))
  53 #endif
  54
  55 /* Files are read in chunks of this number of bytes.  */
  56
  57 #define READ_CHUNK_SIZE (100 * 1024)
  58
  59 /* The character used as a separator in path lists (like $PATH).  */
  60
  61 #if defined(__MSDOS__)
  62 #define PATH_LIST_SEPARATOR ';'
  63 #define FILENAME_EQ(X,Y)    (strcasecmp(X,Y) == 0)
  64 #else
  65 #if defined(WINDOWSNT)
  66 #define PATH_LIST_SEPARATOR ';'
  67 #define FILENAME_EQ(X,Y)    (stricmp(X,Y) == 0)
  68 #else
  69 #define PATH_LIST_SEPARATOR ':'
  70 #define FILENAME_EQ(X,Y)    (streq(X,Y))
  71 #endif
  72 #endif
  73 /* The default output file name.  */
  74
  75 #define DEFAULT_OUTFILE "BROWSE"
  76
  77 /* A version string written to the output file.  Change this whenever
  78    the structure of the output file changes.  */
  79
  80 #define EBROWSE_FILE_VERSION "ebrowse 5.0"
  81
  82 /* The output file consists of a tree of Lisp objects, with major
  83    nodes built out of Lisp structures.  These are the heads of the
  84    Lisp structs with symbols identifying their type.  */
  85
  86 #define TREE_HEADER_STRUCT      "[ebrowse-hs "
  87 #define TREE_STRUCT             "[ebrowse-ts "
  88 #define MEMBER_STRUCT           "[ebrowse-ms "
  89 #define BROWSE_STRUCT           "[ebrowse-bs "
  90 #define CLASS_STRUCT            "[ebrowse-cs "
  91
  92 /* The name of the symbol table entry for global functions, variables,
  93    defines etc.  This name also appears in the browser display.  */
  94
  95 #define GLOBALS_NAME "*Globals*"
  96
  97 /* Token definitions.  */
  98
  99 enum token
 100 {
 101   YYEOF = 0,                    /* end of file */
 102   CSTRING = 256,                /* string constant */
 103   CCHAR,                        /* character constant */
 104   CINT,                         /* integral constant */
 105   CFLOAT,                       /* real constant */
 106
 107   ELLIPSIS,                     /* ... */
 108   LSHIFTASGN,                   /* <<= */
 109   RSHIFTASGN,                   /* >>= */
 110   ARROWSTAR,                    /* ->* */
 111   IDENT,                        /* identifier */
 112   DIVASGN,                      /* /= */
 113   INC,                          /* ++ */
 114   ADDASGN,                      /* += */
 115   DEC,                          /* -- */
 116   ARROW,                        /* -> */
 117   SUBASGN,                      /* -= */
 118   MULASGN,                      /* *= */
 119   MODASGN,                      /* %= */
 120   LOR,                          /* || */
 121   ORASGN,                       /* |= */
 122   LAND,                         /* && */
 123   ANDASGN,                      /* &= */
 124   XORASGN,                      /* ^= */
 125   POINTSTAR,                    /* .* */
 126   DCOLON,                       /* :: */
 127   EQ,                           /* == */
 128   NE,                           /* != */
 129   LE,                           /* <= */
 130   LSHIFT,                       /* << */
 131   GE,                           /* >= */
 132   RSHIFT,                       /* >> */
 133
 134 /* Keywords.  The undef's are there because these
 135    three symbols are very likely to be defined somewhere.  */
 136 #undef BOOL
 137 #undef TRUE
 138 #undef FALSE
 139
 140   ASM,                          /* asm */
 141   AUTO,                         /* auto */
 142   BREAK,                        /* break */
 143   CASE,                         /* case  */
 144   CATCH,                        /* catch */
 145   CHAR,                         /* char */
 146   CLASS,                        /* class */
 147   CONST,                        /* const */
 148   CONTINUE,                     /* continue */
 149   DEFAULT,                      /* default */
 150   DELETE,                       /* delete */
 151   DO,                           /* do */
 152   DOUBLE,                       /* double */
 153   ELSE,                         /* else */
 154   ENUM,                         /* enum */
 155   EXTERN,                       /* extern */
 156   FLOAT,                        /* float */
 157   FOR,                          /* for */
 158   FRIEND,                       /* friend */
 159   GOTO,                         /* goto */
 160   IF,                           /* if */
 161   T_INLINE,                     /* inline */
 162   INT,                          /* int */
 163   LONG,                         /* long */
 164   NEW,                          /* new */
 165   OPERATOR,                     /* operator */
 166   PRIVATE,                      /* private */
 167   PROTECTED,                    /* protected */
 168   PUBLIC,                       /* public */
 169   REGISTER,                     /* register */
 170   RETURN,                       /* return */
 171   SHORT,                        /* short */
 172   SIGNED,                       /* signed */
 173   SIZEOF,                       /* sizeof */
 174   STATIC,                       /* static */
 175   STRUCT,                       /* struct */
 176   SWITCH,                       /* switch */
 177   TEMPLATE,                     /* template */
 178   THIS,                         /* this */
 179   THROW,                        /* throw */
 180   TRY,                          /* try */
 181   TYPEDEF,                      /* typedef */
 182   UNION,                        /* union */
 183   UNSIGNED,                     /* unsigned */
 184   VIRTUAL,                      /* virtual */
 185   VOID,                         /* void */
 186   VOLATILE,                     /* volatile */
 187   WHILE,                        /* while */
 188   MUTABLE,                      /* mutable */
 189   BOOL,                         /* bool */
 190   TRUE,                         /* true */
 191   FALSE,                        /* false */
 192   SIGNATURE,                    /* signature (GNU extension) */
 193   NAMESPACE,                    /* namespace */
 194   EXPLICIT,                     /* explicit */
 195   TYPENAME,                     /* typename */
 196   CONST_CAST,                   /* const_cast */
 197   DYNAMIC_CAST,                 /* dynamic_cast */
 198   REINTERPRET_CAST,             /* reinterpret_cast */
 199   STATIC_CAST,                  /* static_cast */
 200   TYPEID,                       /* typeid */
 201   USING,                        /* using */
 202   WCHAR                         /* wchar_t */
 203 };
 204
 205 /* Storage classes, in a wider sense.  */
 206
 207 enum sc
 208 {
 209   SC_UNKNOWN,
 210   SC_MEMBER,                    /* Is an instance member.  */
 211   SC_STATIC,                    /* Is static member.  */
 212   SC_FRIEND,                    /* Is friend function.  */
 213   SC_TYPE                       /* Is a type definition.  */
 214 };
 215
 216 /* Member visibility.  */
 217
 218 enum visibility
 219 {
 220   V_PUBLIC,
 221   V_PROTECTED,
 222   V_PRIVATE
 223 };
 224
 225 /* Member flags.  */
 226
 227 #define F_VIRTUAL       1       /* Is virtual function.  */
 228 #define F_INLINE        2       /* Is inline function.  */
 229 #define F_CONST         4       /* Is const.  */
 230 #define F_PURE          8       /* Is pure virtual function.  */
 231 #define F_MUTABLE       16      /* Is mutable.  */
 232 #define F_TEMPLATE      32      /* Is a template.  */
 233 #define F_EXPLICIT      64      /* Is explicit constructor.  */
 234 #define F_THROW         128     /* Has a throw specification.  */
 235 #define F_EXTERNC       256     /* Is declared extern "C".  */
 236 #define F_DEFINE        512     /* Is a #define.  */
 237
 238 /* Two macros to set and test a bit in an int.  */
 239
 240 #define SET_FLAG(F, FLAG)       ((F) |= (FLAG))
 241 #define HAS_FLAG(F, FLAG)       (((F) & (FLAG)) != 0)
 242
 243 /* Structure describing a class member.  */
 244
 245 struct member
 246 {
 247   struct member *next;          /* Next in list of members.  */
 248   struct member *anext;         /* Collision chain in member_table.  */
 249   struct member **list;         /* Pointer to list in class.  */
 250   unsigned param_hash;          /* Hash value for parameter types.  */
 251   int vis;                      /* Visibility (public, ...).  */
 252   int flags;                    /* See F_* above.  */
 253   char *regexp;                 /* Matching regular expression.  */
 254   char *filename;               /* Don't free this shared string.  */
 255   int pos;                      /* Buffer position of occurrence.  */
 256   char *def_regexp;             /* Regular expression matching definition.  */
 257   char *def_filename;           /* File name of definition.  */
 258   int def_pos;                  /* Buffer position of definition.  */
 259   char name[1];                 /* Member name.  */
 260 };
 261
 262 /* Structures of this type are used to connect class structures with
 263    their super and subclasses.  */
 264
 265 struct link
 266 {
 267   struct sym *sym;              /* The super or subclass.  */
 268   struct link *next;            /* Next in list or NULL.  */
 269 };
 270
 271 /* Structure used to record namespace aliases.  */
 272
 273 struct alias
 274 {
 275   struct alias *next;           /* Next in list.  */
 276   char name[1];                 /* Alias name.  */
 277 };
 278
 279 /* The structure used to describe a class in the symbol table,
 280    or a namespace in all_namespaces.  */
 281
 282 struct sym
 283 {
 284   int flags;                    /* Is class a template class?.  */
 285   unsigned char visited;        /* Used to find circles.  */
 286   struct sym *next;             /* Hash collision list.  */
 287   struct link *subs;            /* List of subclasses.  */
 288   struct link *supers;          /* List of superclasses.  */
 289   struct member *vars;          /* List of instance variables.  */
 290   struct member *fns;           /* List of instance functions.  */
 291   struct member *static_vars;   /* List of static variables.  */
 292   struct member *static_fns;    /* List of static functions.  */
 293   struct member *friends;       /* List of friend functions.  */
 294   struct member *types;         /* List of local types.  */
 295   char *regexp;                 /* Matching regular expression.  */
 296   int pos;                      /* Buffer position.  */
 297   char *filename;               /* File in which it can be found.  */
 298   char *sfilename;              /* File in which members can be found.  */
 299   struct sym *namesp;           /* Namespace in which defined. .  */
 300   struct alias *namesp_aliases; /* List of aliases for namespaces.  */
 301   char name[1];                 /* Name of the class.  */
 302 };
 303
 304 /* Experimental: Print info for `--position-info'.  We print
 305    '(CLASS-NAME SCOPE MEMBER-NAME).  */
 306
 307 #define P_DEFN  1
 308 #define P_DECL  2
 309
 310 int info_where;
 311 struct sym *info_cls = NULL;
 312 struct member *info_member = NULL;
 313
 314 /* Experimental.  For option `--position-info', the buffer position we
 315    are interested in.  When this position is reached, print out
 316    information about what we know about that point.  */
 317
 318 int info_position = -1;
 319
 320 /* Command line options structure for getopt_long.  */
 321
 322 struct option options[] =
 323 {
 324   {"append",                    no_argument,       NULL, 'a'},
 325   {"files",                     required_argument, NULL, 'f'},
 326   {"help",                      no_argument,       NULL, -2},
 327   {"min-regexp-length",         required_argument, NULL, 'm'},
 328   {"max-regexp-length",         required_argument, NULL, 'M'},
 329   {"no-nested-classes",         no_argument,       NULL, 'n'},
 330   {"no-regexps",                no_argument,       NULL, 'x'},
 331   {"no-structs-or-unions",      no_argument,       NULL, 's'},
 332   {"output-file",               required_argument, NULL, 'o'},
 333   {"position-info",             required_argument, NULL, 'p'},
 334   {"search-path",               required_argument, NULL, 'I'},
 335   {"verbose",                   no_argument,       NULL, 'v'},
 336   {"version",                   no_argument,       NULL, -3},
 337   {"very-verbose",              no_argument,       NULL, 'V'},
 338   {NULL,                        0,                 NULL, 0}
 339 };
 340
 341 /* Semantic values of tokens.  Set by yylex..  */
 342
 343 unsigned yyival;                /* Set for token CINT.  */
 344 char *yytext;                   /* Set for token IDENT.  */
 345 char *yytext_end;
 346
 347 /* Output file.  */
 348
 349 FILE *yyout;
 350
 351 /* Current line number.  */
 352
 353 int yyline;
 354
 355 /* The name of the current input file.  */
 356
 357 char *filename;
 358
 359 /* Three character class vectors, and macros to test membership
 360    of characters.  */
 361
 362 char is_ident[255];
 363 char is_digit[255];
 364 char is_white[255];
 365
 366 #define IDENTP(C)       is_ident[(unsigned char) (C)]
 367 #define DIGITP(C)       is_digit[(unsigned char) (C)]
 368 #define WHITEP(C)       is_white[(unsigned char) (C)]
 369
 370 /* Command line flags.  */
 371
 372 int f_append;
 373 int f_verbose;
 374 int f_very_verbose;
 375 int f_structs = 1;
 376 int f_regexps = 1;
 377 int f_nested_classes = 1;
 378
 379 /* Maximum and minimum lengths of regular expressions matching a
 380    member, class etc., for writing them to the output file.  These are
 381    overridable from the command line.  */
 382
 383 int min_regexp = 5;
 384 int max_regexp = 50;
 385
 386 /* Input buffer.  */
 387
 388 char *inbuffer;
 389 char *in;
 390 int inbuffer_size;
 391
 392 /* Return the current buffer position in the input file.  */
 393
 394 #define BUFFER_POS() (in - inbuffer)
 395
 396 /* If current lookahead is CSTRING, the following points to the
 397    first character in the string constant.  Used for recognizing
 398    extern "C".  */
 399
 400 char *string_start;
 401
 402 /* The size of the hash tables for classes.and members.  Should be
 403    prime.  */
 404
 405 #define TABLE_SIZE 1001
 406
 407 /* The hash table for class symbols.  */
 408
 409 struct sym *class_table[TABLE_SIZE];
 410
 411 /* Hash table containing all member structures.  This is generally
 412    faster for member lookup than traversing the member lists of a
 413    `struct sym'.  */
 414
 415 struct member *member_table[TABLE_SIZE];
 416
 417 /* The special class symbol used to hold global functions,
 418    variables etc.  */
 419
 420 struct sym *global_symbols;
 421
 422 /* The current namespace.  */
 423
 424 struct sym *current_namespace;
 425
 426 /* The list of all known namespaces.  */
 427
 428 struct sym *all_namespaces;
 429
 430 /* Stack of namespaces we're currently nested in, during the parse.  */
 431
 432 struct sym **namespace_stack;
 433 int namespace_stack_size;
 434 int namespace_sp;
 435
 436 /* The current lookahead token.  */
 437
 438 int tk = -1;
 439
 440 /* Structure describing a keyword.  */
 441
 442 struct kw
 443 {
 444   char *name;                   /* Spelling.  */
 445   int tk;                       /* Token value.  */
 446   struct kw *next;              /* Next in collision chain.  */
 447 };
 448
 449 /* Keywords are lookup up in a hash table of their own.  */
 450
 451 #define KEYWORD_TABLE_SIZE 1001
 452 struct kw *keyword_table[KEYWORD_TABLE_SIZE];
 453
 454 /* Search path.  */
 455
 456 struct search_path
 457 {
 458   char *path;
 459   struct search_path *next;
 460 };
 461
 462 struct search_path *search_path;
 463 struct search_path *search_path_tail;
 464
 465 /* Function prototypes.  */
 466
 467 int yylex P_ ((void));
 468 void yyparse P_ ((void));
 469 void re_init_parser P_ ((void));
 470 char *token_string P_ ((int));
 471 char *matching_regexp P_ ((void));
 472 void init_sym P_ ((void));
 473 struct sym *add_sym P_ ((char *, struct sym *));
 474 void add_link P_ ((struct sym *, struct sym *));
 475 void add_member_defn P_ ((struct sym *, char *, char *,
 476                           int, unsigned, int, int, int));
 477 void add_member_decl P_ ((struct sym *, char *, char *, int,
 478                           unsigned, int, int, int, int));
 479 void dump_roots P_ ((FILE *));
 480 void *xmalloc P_ ((int));
 481 void xfree P_ ((void *));
 482 void add_global_defn P_ ((char *, char *, int, unsigned, int, int, int));
 483 void add_global_decl P_ ((char *, char *, int, unsigned, int, int, int));
 484 void add_define P_ ((char *, char *, int));
 485 void mark_inherited_virtual P_ ((void));
 486 void leave_namespace P_ ((void));
 487 void enter_namespace P_ ((char *));
 488 void register_namespace_alias P_ ((char *, char *));
 489 void insert_keyword P_ ((char *, int));
 490 void re_init_scanner P_ ((void));
 491 void init_scanner P_ ((void));
 492 void usage P_ ((int));
 493 void version P_ ((void));
 494 void process_file P_ ((char *));
 495 void add_search_path P_ ((char *));
 496 FILE *open_file P_ ((char *));
 497 int process_pp_line P_ ((void));
 498 int dump_members P_ ((FILE *, struct member *));
 499 void dump_sym P_ ((FILE *, struct sym *));
 500 int dump_tree P_ ((FILE *, struct sym *));
 501 struct member *find_member P_ ((struct sym *, char *, int, int, unsigned));
 502 struct member *add_member P_ ((struct sym *, char *, int, int, unsigned));
 503 void mark_virtual P_ ((struct sym *));
 504 void mark_virtual P_ ((struct sym *));
 505 struct sym *make_namespace P_ ((char *));
 506 char *sym_scope P_ ((struct sym *));
 507 char *sym_scope_1 P_ ((struct sym *));
 508 int skip_to P_ ((int));
 509 void skip_matching P_ ((void));
 510 void member P_ ((struct sym *, int));
 511 void class_body P_ ((struct sym *, int));
 512 void class_definition P_ ((struct sym *, int, int, int));
 513 void declaration P_ ((int));
 514 unsigned parm_list P_ ((int *));
 515 char *operator_name P_ ((int *));
 516 struct sym *parse_classname P_ ((void));
 517 struct sym *parse_qualified_ident_or_type P_ ((char **));
 518 void parse_qualified_param_ident_or_type P_ ((char **));
 519 int globals P_ ((int));
 520 void yyerror P_ ((char *, char *));
 521
 522
 523 \f
 524 /***********************************************************************
 525                               Utilities
 526  ***********************************************************************/
 527
 528 /* Print an error in a printf-like style with the current input file
 529    name and line number.  */
 530
 531 void
 532 yyerror (format, s)
 533      char *format, *s;
 534 {
 535   fprintf (stderr, "%s:%d: ", filename, yyline);
 536   fprintf (stderr, format, s);
 537   putc ('\n', stderr);
 538 }
 539
 540
 541 /* Like malloc but print an error and exit if not enough memory is
 542    available.  */
 543
 544 void *
 545 xmalloc (nbytes)
 546      int nbytes;
 547 {
 548   void *p = malloc (nbytes);
 549   if (p == NULL)
 550     {
 551       yyerror ("out of memory", NULL);
 552       exit (1);
 553     }
 554   return p;
 555 }
 556
 557
 558 /* Like realloc but print an error and exit if out of memory.  */
 559
 560 void *
 561 xrealloc (p, sz)
 562      void *p;
 563      int sz;
 564 {
 565   p = realloc (p, sz);
 566   if (p == NULL)
 567     {
 568       yyerror ("out of memory", NULL);
 569       exit (1);
 570     }
 571   return p;
 572 }
 573
 574
 575 /* Like free but always check for null pointers..  */
 576
 577 void
 578 xfree (p)
 579      void *p;
 580 {
 581   if (p)
 582     free (p);
 583 }
 584
 585
 586 /* Like strdup, but print an error and exit if not enough memory is
 587    available..  If S is null, return null.  */
 588
 589 char *
 590 xstrdup (s)
 591      char *s;
 592 {
 593   if (s)
 594     s = strcpy (xmalloc (strlen (s) + 1), s);
 595   return s;
 596 }
 597
 598
 599 \f
 600 /***********************************************************************
 601                                Symbols
 602  ***********************************************************************/
 603
 604 /* Initialize the symbol table.  This currently only sets up the
 605    special symbol for globals (`*Globals*').  */
 606
 607 void
 608 init_sym ()
 609 {
 610   global_symbols = add_sym (GLOBALS_NAME, NULL);
 611 }
 612
 613
 614 /* Add a symbol for class NAME to the symbol table.  NESTED_IN_CLASS
 615    is the class in which class NAME was found.  If it is null,
 616    this means the scope of NAME is the current namespace.
 617
 618    If a symbol for NAME already exists, return that.  Otherwise
 619    create a new symbol and set it to default values.  */
 620
 621 struct sym *
 622 add_sym (name, nested_in_class)
 623      char *name;
 624      struct sym *nested_in_class;
 625 {
 626   struct sym *sym;
 627   unsigned h;
 628   char *s;
 629   struct sym *scope = nested_in_class ? nested_in_class : current_namespace;
 630
 631   for (s = name, h = 0; *s; ++s)
 632     h = (h << 1) ^ *s;
 633   h %= TABLE_SIZE;
 634
 635   for (sym = class_table[h]; sym; sym = sym->next)
 636     if (streq (name, sym->name) && sym->namesp == scope)
 637       break;
 638
 639   if (sym == NULL)
 640     {
 641       if (f_very_verbose)
 642         {
 643           putchar ('\t');
 644           puts (name);
 645         }
 646
 647       sym = (struct sym *) xmalloc (sizeof *sym + strlen (name));
 648       bzero (sym, sizeof *sym);
 649       strcpy (sym->name, name);
 650       sym->namesp = scope;
 651       sym->next = class_table[h];
 652       class_table[h] = sym;
 653     }
 654
 655   return sym;
 656 }
 657
 658
 659 /* Add links between superclass SUPER and subclass SUB.  */
 660
 661 void
 662 add_link (super, sub)
 663      struct sym *super, *sub;
 664 {
 665   struct link *lnk, *lnk2, *p, *prev;
 666
 667   /* See if a link already exists.  */
 668   for (p = super->subs, prev = NULL;
 669        p && strcmp (sub->name, p->sym->name) > 0;
 670        prev = p, p = p->next)
 671     ;
 672
 673   /* Avoid duplicates.  */
 674   if (p == NULL || p->sym != sub)
 675     {
 676       lnk = (struct link *) xmalloc (sizeof *lnk);
 677       lnk2 = (struct link *) xmalloc (sizeof *lnk2);
 678
 679       lnk->sym = sub;
 680       lnk->next = p;
 681
 682       if (prev)
 683         prev->next = lnk;
 684       else
 685         super->subs = lnk;
 686
 687       lnk2->sym = super;
 688       lnk2->next = sub->supers;
 689       sub->supers = lnk2;
 690     }
 691 }
 692
 693
 694 /* Find in class CLS member NAME.
 695
 696    VAR non-zero means look for a member variable; otherwise a function
 697    is searched.  SC specifies what kind of member is searched---a
 698    static, or per-instance member etc.  HASH is a hash code for the
 699    parameter types of functions.  Value is a pointer to the member
 700    found or null if not found.  */
 701
 702 struct member *
 703 find_member (cls, name, var, sc, hash)
 704      struct sym *cls;
 705      char *name;
 706      int var, sc;
 707      unsigned hash;
 708 {
 709   struct member **list;
 710   struct member *p;
 711   unsigned name_hash = 0;
 712   char *s;
 713   int i;
 714
 715   switch (sc)
 716     {
 717     case SC_FRIEND:
 718       list = &cls->friends;
 719       break;
 720
 721     case SC_TYPE:
 722       list = &cls->types;
 723       break;
 724
 725     case SC_STATIC:
 726       list = var ? &cls->static_vars : &cls->static_fns;
 727       break;
 728
 729     default:
 730       list = var ? &cls->vars : &cls->fns;
 731       break;
 732     }
 733
 734   for (s = name; *s; ++s)
 735     name_hash = (name_hash << 1) ^ *s;
 736   i = name_hash % TABLE_SIZE;
 737
 738   for (p = member_table[i]; p; p = p->anext)
 739     if (p->list == list && p->param_hash == hash && streq (name, p->name))
 740       break;
 741
 742   return p;
 743 }
 744
 745
 746 /* Add to class CLS information for the declaration of member NAME.
 747    REGEXP is a regexp matching the declaration, if non-null.  POS is
 748    the position in the source where the declaration is found.  HASH is
 749    a hash code for the parameter list of the member, if it's a
 750    function.  VAR non-zero means member is a variable or type.  SC
 751    specifies the type of member (instance member, static, ...).  VIS
 752    is the member's visibility (public, protected, private).  FLAGS is
 753    a bit set giving additional information about the member (see the
 754    F_* defines).  */
 755
 756 void
 757 add_member_decl (cls, name, regexp, pos, hash, var, sc, vis, flags)
 758      struct sym *cls;
 759      char *name;
 760      char *regexp;
 761      int pos;
 762      unsigned hash;
 763      int var;
 764      int sc;
 765      int vis;
 766      int flags;
 767 {
 768   struct member *m;
 769
 770   m = find_member (cls, name, var, sc, hash);
 771   if (m == NULL)
 772     m = add_member (cls, name, var, sc, hash);
 773
 774   /* Have we seen a new filename?  If so record that.  */
 775   if (!cls->filename || !FILENAME_EQ (cls->filename, filename))
 776     m->filename = filename;
 777
 778   m->regexp = regexp;
 779   m->pos = pos;
 780   m->flags = flags;
 781
 782   switch (vis)
 783     {
 784     case PRIVATE:
 785       m->vis = V_PRIVATE;
 786       break;
 787
 788     case PROTECTED:
 789       m->vis = V_PROTECTED;
 790       break;
 791
 792     case PUBLIC:
 793       m->vis = V_PUBLIC;
 794       break;
 795     }
 796
 797   info_where = P_DECL;
 798   info_cls = cls;
 799   info_member = m;
 800 }
 801
 802
 803 /* Add to class CLS information for the definition of member NAME.
 804    REGEXP is a regexp matching the declaration, if non-null.  POS is
 805    the position in the source where the declaration is found.  HASH is
 806    a hash code for the parameter list of the member, if it's a
 807    function.  VAR non-zero means member is a variable or type.  SC
 808    specifies the type of member (instance member, static, ...).  VIS
 809    is the member's visibility (public, protected, private).  FLAGS is
 810    a bit set giving additional information about the member (see the
 811    F_* defines).  */
 812
 813 void
 814 add_member_defn (cls, name, regexp, pos, hash, var, sc, flags)
 815      struct sym *cls;
 816      char *name;
 817      char *regexp;
 818      int pos;
 819      unsigned hash;
 820      int var;
 821      int sc;
 822      int flags;
 823 {
 824   struct member *m;
 825
 826   if (sc == SC_UNKNOWN)
 827     {
 828       m = find_member (cls, name, var, SC_MEMBER, hash);
 829       if (m == NULL)
 830         {
 831           m = find_member (cls, name, var, SC_STATIC, hash);
 832           if (m == NULL)
 833             m = add_member (cls, name, var, sc, hash);
 834         }
 835     }
 836   else
 837     {
 838       m = find_member (cls, name, var, sc, hash);
 839       if (m == NULL)
 840         m = add_member (cls, name, var, sc, hash);
 841     }
 842
 843   if (!cls->sfilename)
 844     cls->sfilename = filename;
 845
 846   if (!FILENAME_EQ (cls->sfilename, filename))
 847     m->def_filename = filename;
 848
 849   m->def_regexp = regexp;
 850   m->def_pos = pos;
 851   m->flags |= flags;
 852
 853   info_where = P_DEFN;
 854   info_cls = cls;
 855   info_member = m;
 856 }
 857
 858
 859 /* Add a symbol for a define named NAME to the symbol table.
 860    REGEXP is a regular expression matching the define in the source,
 861    if it is non-null.  POS is the position in the file.  */
 862
 863 void
 864 add_define (name, regexp, pos)
 865      char *name, *regexp;
 866      int pos;
 867 {
 868   add_global_defn (name, regexp, pos, 0, 1, SC_FRIEND, F_DEFINE);
 869   add_global_decl (name, regexp, pos, 0, 1, SC_FRIEND, F_DEFINE);
 870 }
 871
 872
 873 /* Add information for the global definition of NAME.
 874    REGEXP is a regexp matching the declaration, if non-null.  POS is
 875    the position in the source where the declaration is found.  HASH is
 876    a hash code for the parameter list of the member, if it's a
 877    function.  VAR non-zero means member is a variable or type.  SC
 878    specifies the type of member (instance member, static, ...).  VIS
 879    is the member's visibility (public, protected, private).  FLAGS is
 880    a bit set giving additional information about the member (see the
 881    F_* defines).  */
 882
 883 void
 884 add_global_defn (name, regexp, pos, hash, var, sc, flags)
 885      char *name, *regexp;
 886      int pos;
 887      unsigned hash;
 888      int var;
 889      int sc;
 890      int flags;
 891 {
 892   int i;
 893   struct sym *sym;
 894
 895   /* Try to find out for which classes a function is a friend, and add
 896      what we know about it to them.  */
 897   if (!var)
 898     for (i = 0; i < TABLE_SIZE; ++i)
 899       for (sym = class_table[i]; sym; sym = sym->next)
 900         if (sym != global_symbols && sym->friends)
 901           if (find_member (sym, name, 0, SC_FRIEND, hash))
 902             add_member_defn (sym, name, regexp, pos, hash, 0,
 903                              SC_FRIEND, flags);
 904
 905   /* Add to global symbols.  */
 906   add_member_defn (global_symbols, name, regexp, pos, hash, var, sc, flags);
 907 }
 908
 909
 910 /* Add information for the global declaration of NAME.
 911    REGEXP is a regexp matching the declaration, if non-null.  POS is
 912    the position in the source where the declaration is found.  HASH is
 913    a hash code for the parameter list of the member, if it's a
 914    function.  VAR non-zero means member is a variable or type.  SC
 915    specifies the type of member (instance member, static, ...).  VIS
 916    is the member's visibility (public, protected, private).  FLAGS is
 917    a bit set giving additional information about the member (see the
 918    F_* defines).  */
 919
 920 void
 921 add_global_decl (name, regexp, pos, hash, var, sc, flags)
 922      char *name, *regexp;
 923      int pos;
 924      unsigned hash;
 925      int var;
 926      int sc;
 927      int flags;
 928 {
 929   /* Add declaration only if not already declared.  Header files must
 930      be processed before source files for this to have the right effect.
 931      I do not want to handle implicit declarations at the moment.  */
 932   struct member *m;
 933   struct member *found;
 934
 935   m = found = find_member (global_symbols, name, var, sc, hash);
 936   if (m == NULL)
 937     m = add_member (global_symbols, name, var, sc, hash);
 938
 939   /* Definition already seen => probably last declaration implicit.
 940      Override.  This means that declarations must always be added to
 941      the symbol table before definitions.  */
 942   if (!found)
 943     {
 944       if (!global_symbols->filename
 945           || !FILENAME_EQ (global_symbols->filename, filename))
 946         m->filename = filename;
 947
 948       m->regexp = regexp;
 949       m->pos = pos;
 950       m->vis = V_PUBLIC;
 951       m->flags = flags;
 952
 953       info_where = P_DECL;
 954       info_cls = global_symbols;
 955       info_member = m;
 956     }
 957 }
 958
 959
 960 /* Add a symbol for member NAME to class CLS.
 961    VAR non-zero means it's a variable.  SC specifies the kind of
 962    member.  HASH is a hash code for the parameter types of a function.
 963    Value is a pointer to the member's structure.  */
 964
 965 struct member *
 966 add_member (cls, name, var, sc, hash)
 967      struct sym *cls;
 968      char *name;
 969      int var;
 970      int sc;
 971      unsigned hash;
 972 {
 973   struct member *m = (struct member *) xmalloc (sizeof *m + strlen (name));
 974   struct member **list;
 975   struct member *p;
 976   struct member *prev;
 977   unsigned name_hash = 0;
 978   int i;
 979   char *s;
 980
 981   strcpy (m->name, name);
 982   m->param_hash = hash;
 983
 984   m->vis = 0;
 985   m->flags = 0;
 986   m->regexp = NULL;
 987   m->filename = NULL;
 988   m->pos = 0;
 989   m->def_regexp = NULL;
 990   m->def_filename = NULL;
 991   m->def_pos = 0;
 992
 993   assert (cls != NULL);
 994
 995   switch (sc)
 996     {
 997     case SC_FRIEND:
 998       list = &cls->friends;
 999       break;
1000
1001     case SC_TYPE:
1002       list = &cls->types;
1003       break;
1004
1005     case SC_STATIC:
1006       list = var ? &cls->static_vars : &cls->static_fns;
1007       break;
1008
1009     default:
1010       list = var ? &cls->vars : &cls->fns;
1011       break;
1012     }
1013
1014   for (s = name; *s; ++s)
1015     name_hash = (name_hash << 1) ^ *s;
1016   i = name_hash % TABLE_SIZE;
1017   m->anext = member_table[i];
1018   member_table[i] = m;
1019   m->list = list;
1020
1021   /* Keep the member list sorted.  It's cheaper to do it here than to
1022      sort them in Lisp.  */
1023   for (prev = NULL, p = *list;
1024        p && strcmp (name, p->name) > 0;
1025        prev = p, p = p->next)
1026     ;
1027
1028   m->next = p;
1029   if (prev)
1030     prev->next = m;
1031   else
1032     *list = m;
1033   return m;
1034 }
1035
1036
1037 /* Given the root R of a class tree, step through all subclasses
1038    recursively, marking functions as virtual that are declared virtual
1039    in base classes.  */
1040
1041 void
1042 mark_virtual (r)
1043      struct sym *r;
1044 {
1045   struct link *p;
1046   struct member *m, *m2;
1047
1048   for (p = r->subs; p; p = p->next)
1049     {
1050       for (m = r->fns; m; m = m->next)
1051         if (HAS_FLAG (m->flags, F_VIRTUAL))
1052           {
1053             for (m2 = p->sym->fns; m2; m2 = m2->next)
1054               if (m->param_hash == m2->param_hash && streq (m->name, m2->name))
1055                 SET_FLAG (m2->flags, F_VIRTUAL);
1056           }
1057
1058       mark_virtual (p->sym);
1059     }
1060 }
1061
1062
1063 /* For all roots of the class tree, mark functions as virtual that
1064    are virtual because of a virtual declaration in a base class.  */
1065
1066 void
1067 mark_inherited_virtual ()
1068 {
1069   struct sym *r;
1070   int i;
1071
1072   for (i = 0; i < TABLE_SIZE; ++i)
1073     for (r = class_table[i]; r; r = r->next)
1074       if (r->supers == NULL)
1075         mark_virtual (r);
1076 }
1077
1078
1079 /* Create and return a symbol for a namespace with name NAME.  */
1080
1081 struct sym *
1082 make_namespace (name)
1083      char *name;
1084 {
1085   struct sym *s = (struct sym *) xmalloc (sizeof *s + strlen (name));
1086   bzero (s, sizeof *s);
1087   strcpy (s->name, name);
1088   s->next = all_namespaces;
1089   s->namesp = current_namespace;
1090   all_namespaces = s;
1091   return s;
1092 }
1093
1094
1095 /* Find the symbol for namespace NAME.  If not found, add a new symbol
1096    for NAME to all_namespaces.  */
1097
1098 struct sym *
1099 find_namespace (name)
1100      char *name;
1101 {
1102   struct sym *p;
1103
1104   for (p = all_namespaces; p; p = p->next)
1105     {
1106       if (streq (p->name, name))
1107         break;
1108       else
1109         {
1110           struct alias *p2;
1111           for (p2 = p->namesp_aliases; p2; p2 = p2->next)
1112             if (streq (p2->name, name))
1113               break;
1114           if (p2)
1115             break;
1116         }
1117     }
1118
1119   if (p == NULL)
1120     p = make_namespace (name);
1121
1122   return p;
1123 }
1124
1125
1126 /* Register the name NEW_NAME as an alias for namespace OLD_NAME.  */
1127
1128 void
1129 register_namespace_alias (new_name, old_name)
1130      char *new_name, *old_name;
1131 {
1132   struct sym *p = find_namespace (old_name);
1133   struct alias *al;
1134
1135   /* Is it already in the list of aliases?  */
1136   for (al = p->namesp_aliases; al; al = al->next)
1137     if (streq (new_name, p->name))
1138       return;
1139
1140   al = (struct alias *) xmalloc (sizeof *al + strlen (new_name));
1141   strcpy (al->name, new_name);
1142   al->next = p->namesp_aliases;
1143   p->namesp_aliases = al;
1144 }
1145
1146
1147 /* Enter namespace with name NAME.  */
1148
1149 void
1150 enter_namespace (name)
1151      char *name;
1152 {
1153   struct sym *p = find_namespace (name);
1154
1155   if (namespace_sp == namespace_stack_size)
1156     {
1157       int size = max (10, 2 * namespace_stack_size);
1158       namespace_stack = (struct sym **) xrealloc ((void *)namespace_stack,
1159                                                   size);
1160       namespace_stack_size = size;
1161     }
1162
1163   namespace_stack[namespace_sp++] = current_namespace;
1164   current_namespace = p;
1165 }
1166
1167
1168 /* Leave the current namespace.  */
1169
1170 void
1171 leave_namespace ()
1172 {
1173   assert (namespace_sp > 0);
1174   current_namespace = namespace_stack[--namespace_sp];
1175 }
1176
1177
1178 \f
1179 /***********************************************************************
1180                        Writing the Output File
1181  ***********************************************************************/
1182
1183 /* Write string S to the output file FP in a Lisp-readable form.
1184    If S is null, write out `()'.  */
1185
1186 #define PUTSTR(s, fp)                           \
1187   do {                                          \
1188     if (!s)                                     \
1189       {                                         \
1190         putc ('(', fp);                         \
1191         putc (')', fp);                         \
1192         putc (' ', fp);                         \
1193       }                                         \
1194     else                                        \
1195       {                                         \
1196         putc ('"', fp);                         \
1197         fputs (s, fp);                          \
1198         putc ('"', fp);                         \
1199         putc (' ', fp);                         \
1200       }                                         \
1201    } while (0)
1202
1203 /* A dynamically allocated buffer for constructing a scope name.  */
1204
1205 char *scope_buffer;
1206 int scope_buffer_size;
1207 int scope_buffer_len;
1208
1209
1210 /* Make sure scope_buffer has enough room to add LEN chars to it.  */
1211
1212 void
1213 ensure_scope_buffer_room (len)
1214      int len;
1215 {
1216   if (scope_buffer_len + len >= scope_buffer_size)
1217     {
1218       int new_size = max (2 * scope_buffer_size, scope_buffer_len + len);
1219       scope_buffer = (char *) xrealloc (scope_buffer, new_size);
1220       scope_buffer_size = new_size;
1221     }
1222 }
1223
1224
1225 /* Recursively add the scope names of symbol P and the scopes of its
1226    namespaces to scope_buffer.  Value is a pointer to the complete
1227    scope name constructed.  */
1228
1229 char *
1230 sym_scope_1 (p)
1231      struct sym *p;
1232 {
1233   int len;
1234
1235   if (p->namesp)
1236     sym_scope_1 (p->namesp);
1237
1238   if (*scope_buffer)
1239     {
1240       ensure_scope_buffer_room (3);
1241       strcat (scope_buffer, "::");
1242       scope_buffer_len += 2;
1243     }
1244
1245   len = strlen (p->name);
1246   ensure_scope_buffer_room (len + 1);
1247   strcat (scope_buffer, p->name);
1248   scope_buffer_len += len;
1249
1250   if (HAS_FLAG (p->flags, F_TEMPLATE))
1251     {
1252       ensure_scope_buffer_room (3);
1253       strcat (scope_buffer, "<>");
1254       scope_buffer_len += 2;
1255     }
1256
1257   return scope_buffer;
1258 }
1259
1260
1261 /* Return the scope of symbol P in printed representation, i.e.
1262    as it would appear in a C*+ source file.  */
1263
1264 char *
1265 sym_scope (p)
1266      struct sym *p;
1267 {
1268   if (!scope_buffer)
1269     {
1270       scope_buffer_size = 1024;
1271       scope_buffer = (char *) xmalloc (scope_buffer_size);
1272     }
1273
1274   *scope_buffer = '\0';
1275   scope_buffer_len = 0;
1276
1277   if (p->namesp)
1278     sym_scope_1 (p->namesp);
1279
1280   return scope_buffer;
1281 }
1282
1283
1284 /* Dump the list of members M to file FP.  Value is the length of the
1285    list.  */
1286
1287 int
1288 dump_members (fp, m)
1289      FILE *fp;
1290      struct member *m;
1291 {
1292   int n;
1293
1294   putc ('(', fp);
1295
1296   for (n = 0; m; m = m->next, ++n)
1297     {
1298       fputs (MEMBER_STRUCT, fp);
1299       PUTSTR (m->name, fp);
1300       PUTSTR (NULL, fp);                /* FIXME? scope for globals */
1301       fprintf (fp, "%u ", (unsigned) m->flags);
1302       PUTSTR (m->filename, fp);
1303       PUTSTR (m->regexp, fp);
1304       fprintf (fp, "%u ", (unsigned) m->pos);
1305       fprintf (fp, "%u ", (unsigned) m->vis);
1306       putc (' ', fp);
1307       PUTSTR (m->def_filename, fp);
1308       PUTSTR (m->def_regexp, fp);
1309       fprintf (fp, "%u", (unsigned) m->def_pos);
1310       putc (']', fp);
1311       putc ('\n', fp);
1312     }
1313
1314   putc (')', fp);
1315   putc ('\n', fp);
1316   return n;
1317 }
1318
1319
1320 /* Dump class ROOT to stream FP.  */
1321
1322 void
1323 dump_sym (fp, root)
1324      FILE *fp;
1325      struct sym *root;
1326 {
1327   fputs (CLASS_STRUCT, fp);
1328   PUTSTR (root->name, fp);
1329
1330   /* Print scope, if any.  */
1331   if (root->namesp)
1332     PUTSTR (sym_scope (root), fp);
1333   else
1334     PUTSTR (NULL, fp);
1335
1336   /* Print flags.  */
1337   fprintf (fp, "%u", root->flags);
1338   PUTSTR (root->filename, fp);
1339   PUTSTR (root->regexp, fp);
1340   fprintf (fp, "%u", (unsigned) root->pos);
1341   PUTSTR (root->sfilename, fp);
1342   putc (']', fp);
1343   putc ('\n', fp);
1344 }
1345
1346
1347 /* Dump class ROOT and its subclasses to file FP.  Value is the
1348    number of classes written.  */
1349
1350 int
1351 dump_tree (fp, root)
1352      FILE *fp;
1353      struct sym *root;
1354 {
1355   struct link *lk;
1356   unsigned n = 0;
1357
1358   dump_sym (fp, root);
1359
1360   if (f_verbose)
1361     {
1362       putchar ('+');
1363       fflush (stdout);
1364     }
1365
1366   putc ('(', fp);
1367
1368   for (lk = root->subs; lk; lk = lk->next)
1369     {
1370       fputs (TREE_STRUCT, fp);
1371       n += dump_tree (fp, lk->sym);
1372       putc (']', fp);
1373     }
1374
1375   putc (')', fp);
1376
1377   dump_members (fp, root->vars);
1378   n += dump_members (fp, root->fns);
1379   dump_members (fp, root->static_vars);
1380   n += dump_members (fp, root->static_fns);
1381   n += dump_members (fp, root->friends);
1382   dump_members (fp, root->types);
1383
1384   /* Superclasses.  */
1385   putc ('(', fp);
1386   putc (')', fp);
1387
1388   /* Mark slot.  */
1389   putc ('(', fp);
1390   putc (')', fp);
1391
1392   putc ('\n', fp);
1393   return n;
1394 }
1395
1396
1397 /* Dump the entire class tree to file FP.  */
1398
1399 void
1400 dump_roots (fp)
1401      FILE *fp;
1402 {
1403   int i, n = 0;
1404   struct sym *r;
1405
1406   /* Output file header containing version string, command line
1407      options etc.  */
1408   if (!f_append)
1409     {
1410       fputs (TREE_HEADER_STRUCT, fp);
1411       PUTSTR (EBROWSE_FILE_VERSION, fp);
1412
1413       putc ('\"', fp);
1414       if (!f_structs)
1415         fputs (" -s", fp);
1416       if (f_regexps)
1417         fputs (" -x", fp);
1418       putc ('\"', fp);
1419       fputs (" ()", fp);
1420       fputs (" ()", fp);
1421       putc (']', fp);
1422     }
1423
1424   /* Mark functions as virtual that are so because of functions
1425      declared virtual in base classes.  */
1426   mark_inherited_virtual ();
1427
1428   /* Dump the roots of the graph.  */
1429   for (i = 0; i < TABLE_SIZE; ++i)
1430     for (r = class_table[i]; r; r = r->next)
1431       if (!r->supers)
1432         {
1433           fputs (TREE_STRUCT, fp);
1434           n += dump_tree (fp, r);
1435           putc (']', fp);
1436         }
1437
1438   if (f_verbose)
1439     putchar ('\n');
1440 }
1441
1442
1443 \f
1444 /***********************************************************************
1445                                 Scanner
1446  ***********************************************************************/
1447
1448 #ifdef DEBUG
1449 #define INCREMENT_LINENO                        \
1450 do {                                            \
1451   if (f_very_verbose)                           \
1452     {                                           \
1453       ++yyline;                                 \
1454       printf ("%d:\n", yyline);                 \
1455     }                                           \
1456   else                                          \
1457     ++yyline;                                   \
1458 } while (0)
1459 #else
1460 #define INCREMENT_LINENO        ++yyline
1461 #endif
1462
1463 /* Define two macros for accessing the input buffer (current input
1464    file).  GET(C) sets C to the next input character and advances the
1465    input pointer.  UNGET retracts the input pointer.  */
1466
1467 #define GET(C)  ((C) = *in++)
1468 #define UNGET() (--in)
1469
1470
1471 /* Process a preprocessor line.  Value is the next character from the
1472    input buffer not consumed.  */
1473
1474 int
1475 process_pp_line ()
1476 {
1477   int in_comment = 0, in_string = 0;
1478   int c;
1479   char *p = yytext;
1480
1481   /* Skip over white space.  The `#' has been consumed already.  */
1482   while (WHITEP (GET (c)))
1483     ;
1484
1485   /* Read the preprocessor command (if any).  */
1486   while (IDENTP (c))
1487     {
1488       *p++ = c;
1489       GET (c);
1490     }
1491
1492   /* Is it a `define'?  */
1493   *p = '\0';
1494
1495   if (*yytext && streq (yytext, "define"))
1496     {
1497       p = yytext;
1498       while (WHITEP (c))
1499         GET (c);
1500       while (IDENTP (c))
1501         {
1502           *p++ = c;
1503           GET (c);
1504         }
1505
1506       *p = '\0';
1507
1508       if (*yytext)
1509         {
1510           char *regexp = matching_regexp ();
1511           int pos = BUFFER_POS ();
1512           add_define (yytext, regexp, pos);
1513         }
1514     }
1515
1516   while (c && (c != '\n' || in_comment || in_string))
1517     {
1518       if (c == '\\')
1519         GET (c);
1520       else if (c == '/' && !in_comment)
1521         {
1522           if (GET (c) == '*')
1523             in_comment = 1;
1524         }
1525       else if (c == '*' && in_comment)
1526         {
1527           if (GET (c) == '/')
1528             in_comment = 0;
1529         }
1530       else if (c == '"')
1531         in_string = !in_string;
1532
1533       if (c == '\n')
1534         INCREMENT_LINENO;
1535
1536       GET (c);
1537     }
1538
1539   return c;
1540 }
1541
1542
1543 /* Value is the next token from the input buffer.  */
1544
1545 int
1546 yylex ()
1547 {
1548   int c;
1549   char end_char;
1550   char *p;
1551
1552   for (;;)
1553     {
1554       while (WHITEP (GET (c)))
1555         ;
1556
1557       switch (c)
1558         {
1559         case '\n':
1560           INCREMENT_LINENO;
1561           break;
1562
1563         case '\r':
1564           break;
1565
1566         case 0:
1567           /* End of file.  */
1568           return YYEOF;
1569
1570         case '\\':
1571           GET (c);
1572           break;
1573
1574         case '"':
1575         case '\'':
1576           /* String and character constants.  */
1577           end_char = c;
1578           string_start = in;
1579           while (GET (c) && c != end_char)
1580             {
1581               switch (c)
1582                 {
1583                 case '\\':
1584                   /* Escape sequences.  */
1585                   if (!GET (c))
1586                     {
1587                       if (end_char == '\'')
1588                         yyerror ("EOF in character constant", NULL);
1589                       else
1590                         yyerror ("EOF in string constant", NULL);
1591                       goto end_string;
1592                     }
1593                   else switch (c)
1594                     {
1595                     case '\n':
1596                       INCREMENT_LINENO;
1597                     case 'a':
1598                     case 'b':
1599                     case 'f':
1600                     case 'n':
1601                     case 'r':
1602                     case 't':
1603                     case 'v':
1604                       break;
1605
1606                     case 'x':
1607                       {
1608                         /* Hexadecimal escape sequence.  */
1609                         int i;
1610                         for (i = 0; i < 2; ++i)
1611                           {
1612                             GET (c);
1613
1614                             if (c >= '0' && c <= '7')
1615                               ;
1616                             else if (c >= 'a' && c <= 'f')
1617                               ;
1618                             else if (c >= 'A' && c <= 'F')
1619                               ;
1620                             else
1621                               {
1622                                 UNGET ();
1623                                 break;
1624                               }
1625                           }
1626                       }
1627                       break;
1628
1629                     case '0':
1630                       {
1631                         /* Octal escape sequence.  */
1632                         int i;
1633                         for (i = 0; i < 3; ++i)
1634                           {
1635                             GET (c);
1636
1637                             if (c >= '0' && c <= '7')
1638                               ;
1639                             else
1640                               {
1641                                 UNGET ();
1642                                 break;
1643                               }
1644                           }
1645                       }
1646                       break;
1647
1648                     default:
1649                       break;
1650                     }
1651                   break;
1652
1653                 case '\n':
1654                   if (end_char == '\'')
1655                     yyerror ("newline in character constant", NULL);
1656                   else
1657                     yyerror ("newline in string constant", NULL);
1658                   INCREMENT_LINENO;
1659                   break;
1660
1661                 default:
1662                   break;
1663                 }
1664             }
1665
1666         end_string:
1667           return end_char == '\'' ? CCHAR : CSTRING;
1668
1669         case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1670         case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
1671         case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
1672         case 'v': case 'w': case 'x': case 'y': case 'z':
1673         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
1674         case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
1675         case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
1676         case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_':
1677           {
1678             /* Identifier and keywords.  */
1679             unsigned hash;
1680             struct kw *k;
1681
1682             p = yytext;
1683             *p++ = hash = c;
1684
1685             while (IDENTP (GET (*p)))
1686               {
1687                 hash = (hash << 1) ^ *p++;
1688                 if (p == yytext_end - 1)
1689                   {
1690                     int size = yytext_end - yytext;
1691                     yytext = (char *) xrealloc (yytext, 2 * size);
1692                     yytext_end = yytext + 2 * size;
1693                     p = yytext + size - 1;
1694                   }
1695               }
1696
1697             UNGET ();
1698             *p = 0;
1699
1700             for (k = keyword_table[hash % KEYWORD_TABLE_SIZE]; k; k = k->next)
1701               if (streq (k->name, yytext))
1702                 return k->tk;
1703
1704             return IDENT;
1705           }
1706
1707         case '/':
1708           /* C and C++ comments, '/' and '/='.  */
1709           switch (GET (c))
1710             {
1711             case '*':
1712               while (GET (c))
1713                 {
1714                   switch (c)
1715                     {
1716                     case '*':
1717                       if (GET (c) == '/')
1718                         goto comment_end;
1719                       UNGET ();
1720                       break;
1721                     case '\\':
1722                       GET (c);
1723                       break;
1724                     case '\n':
1725                       INCREMENT_LINENO;
1726                       break;
1727                     }
1728                 }
1729             comment_end:;
1730               break;
1731
1732             case '=':
1733               return DIVASGN;
1734
1735             case '/':
1736               while (GET (c) && c != '\n')
1737                 ;
1738               INCREMENT_LINENO;
1739               break;
1740
1741             default:
1742               UNGET ();
1743               return '/';
1744             }
1745           break;
1746
1747         case '+':
1748           if (GET (c) == '+')
1749             return INC;
1750           else if (c == '=')
1751             return ADDASGN;
1752           UNGET ();
1753           return '+';
1754
1755         case '-':
1756           switch (GET (c))
1757             {
1758             case '-':
1759               return DEC;
1760             case '>':
1761               if (GET (c) == '*')
1762                 return ARROWSTAR;
1763               UNGET ();
1764               return ARROW;
1765             case '=':
1766               return SUBASGN;
1767             }
1768           UNGET ();
1769           return '-';
1770
1771         case '*':
1772           if (GET (c) == '=')
1773             return MULASGN;
1774           UNGET ();
1775           return '*';
1776
1777         case '%':
1778           if (GET (c) == '=')
1779             return MODASGN;
1780           UNGET ();
1781           return '%';
1782
1783         case '|':
1784           if (GET (c) == '|')
1785             return LOR;
1786           else if (c == '=')
1787             return ORASGN;
1788           UNGET ();
1789           return '|';
1790
1791         case '&':
1792           if (GET (c) == '&')
1793             return LAND;
1794           else if (c == '=')
1795             return ANDASGN;
1796           UNGET ();
1797           return '&';
1798
1799         case '^':
1800           if (GET (c) == '=')
1801             return XORASGN;
1802           UNGET ();
1803           return '^';
1804
1805         case '.':
1806           if (GET (c) == '*')
1807             return POINTSTAR;
1808           else if (c == '.')
1809             {
1810               if (GET (c) != '.')
1811                 yyerror ("invalid token '..' ('...' assumed)", NULL);
1812               UNGET ();
1813               return ELLIPSIS;
1814             }
1815           else if (!DIGITP (c))
1816             {
1817               UNGET ();
1818               return '.';
1819             }
1820           goto mantissa;
1821
1822         case ':':
1823           if (GET (c) == ':')
1824             return DCOLON;
1825           UNGET ();
1826           return ':';
1827
1828         case '=':
1829           if (GET (c) == '=')
1830             return EQ;
1831           UNGET ();
1832           return '=';
1833
1834         case '!':
1835           if (GET (c) == '=')
1836             return NE;
1837           UNGET ();
1838           return '!';
1839
1840         case '<':
1841           switch (GET (c))
1842             {
1843             case '=':
1844               return LE;
1845             case '<':
1846               if (GET (c) == '=')
1847                 return LSHIFTASGN;
1848               UNGET ();
1849               return LSHIFT;
1850             }
1851           UNGET ();
1852           return '<';
1853
1854         case '>':
1855           switch (GET (c))
1856             {
1857             case '=':
1858               return GE;
1859             case '>':
1860               if (GET (c) == '=')
1861                 return RSHIFTASGN;
1862               UNGET ();
1863               return RSHIFT;
1864             }
1865           UNGET ();
1866           return '>';
1867
1868         case '#':
1869           c = process_pp_line ();
1870           if (c == 0)
1871             return YYEOF;
1872           break;
1873
1874         case '(': case ')': case '[': case ']': case '{': case '}':
1875         case ';': case ',': case '?': case '~':
1876           return c;
1877
1878         case '0':
1879           yyival = 0;
1880
1881           if (GET (c) == 'x' || c == 'X')
1882             {
1883               while (GET (c))
1884                 {
1885                   if (DIGITP (c))
1886                     yyival = yyival * 16 + c - '0';
1887                   else if (c >= 'a' && c <= 'f')
1888                     yyival = yyival * 16 + c - 'a' + 10;
1889                   else if (c >= 'A' && c <= 'F')
1890                     yyival = yyival * 16 + c - 'A' + 10;
1891                   else
1892                     break;
1893                 }
1894
1895               goto int_suffixes;
1896             }
1897           else if (c == '.')
1898             goto mantissa;
1899
1900           while (c >= '0' && c <= '7')
1901             {
1902               yyival = (yyival << 3) + c - '0';
1903               GET (c);
1904             }
1905
1906         int_suffixes:
1907           /* Integer suffixes.  */
1908           while (isalpha (c))
1909             GET (c);
1910           UNGET ();
1911           return CINT;
1912
1913         case '1': case '2': case '3': case '4': case '5': case '6':
1914         case '7': case '8': case '9':
1915           /* Integer or floating constant, part before '.'.  */
1916           yyival = c - '0';
1917
1918           while (GET (c) && DIGITP (c))
1919             yyival = 10 * yyival + c - '0';
1920
1921           if (c != '.')
1922             goto int_suffixes;
1923
1924         mantissa:
1925           /* Digits following '.'.  */
1926           while (DIGITP (c))
1927             GET (c);
1928
1929           /* Optional exponent.  */
1930           if (c == 'E' || c == 'e')
1931             {
1932               if (GET (c) == '-' || c == '+')
1933                 GET (c);
1934
1935               while (DIGITP (c))
1936                 GET (c);
1937             }
1938
1939           /* Optional type suffixes.  */
1940           while (isalpha (c))
1941             GET (c);
1942           UNGET ();
1943           return CFLOAT;
1944
1945         default:
1946           break;
1947         }
1948     }
1949 }
1950
1951
1952 /* Actually local to matching_regexp.  These variables must be in
1953    global scope for the case that `static' get's defined away.  */
1954
1955 static char *matching_regexp_buffer, *matching_regexp_end_buf;
1956
1957
1958 /* Value is the string from the start of the line to the current
1959    position in the input buffer, or maybe a bit more if that string is
1960    shorter than min_regexp.  */
1961
1962 char *
1963 matching_regexp ()
1964 {
1965   char *p;
1966   char *s;
1967   char *t;
1968
1969   if (!f_regexps)
1970     return NULL;
1971
1972   if (matching_regexp_buffer == NULL)
1973     {
1974       matching_regexp_buffer = (char *) xmalloc (max_regexp);
1975       matching_regexp_end_buf = &matching_regexp_buffer[max_regexp] - 1;
1976     }
1977
1978   /* Scan back to previous newline of buffer start.  */
1979   for (p = in - 1; p > inbuffer && *p != '\n'; --p)
1980     ;
1981
1982   if (*p == '\n')
1983     {
1984       while (in - p < min_regexp && p > inbuffer)
1985         {
1986           /* Line probably not significant enough */
1987           for (--p; p >= inbuffer && *p != '\n'; --p)
1988             ;
1989         }
1990       if (*p == '\n')
1991         ++p;
1992     }
1993
1994   /* Copy from end to make sure significant portions are included.
1995      This implies that in the browser a regular expressing of the form
1996      `^.*{regexp}' has to be used.  */
1997   for (s = matching_regexp_end_buf - 1, t = in;
1998        s > matching_regexp_buffer && t > p;)
1999     {
2000       *--s = *--t;
2001
2002       if (*s == '"')
2003         *--s = '\\';
2004     }
2005
2006   *(matching_regexp_end_buf - 1) = '\0';
2007   return xstrdup (s);
2008 }
2009
2010
2011 /* Return a printable representation of token T.  */
2012
2013 char *
2014 token_string (t)
2015      int t;
2016 {
2017   static char b[3];
2018
2019   switch (t)
2020     {
2021     case CSTRING:               return "string constant";
2022     case CCHAR:                 return "char constant";
2023     case CINT:                  return "int constant";
2024     case CFLOAT:                return "floating constant";
2025     case ELLIPSIS:              return "...";
2026     case LSHIFTASGN:            return "<<=";
2027     case RSHIFTASGN:            return ">>=";
2028     case ARROWSTAR:             return "->*";
2029     case IDENT:                 return "identifier";
2030     case DIVASGN:               return "/=";
2031     case INC:                   return "++";
2032     case ADDASGN:               return "+=";
2033     case DEC:                   return "--";
2034     case ARROW:                 return "->";
2035     case SUBASGN:               return "-=";
2036     case MULASGN:               return "*=";
2037     case MODASGN:               return "%=";
2038     case LOR:                   return "||";
2039     case ORASGN:                return "|=";
2040     case LAND:                  return "&&";
2041     case ANDASGN:               return "&=";
2042     case XORASGN:               return "^=";
2043     case POINTSTAR:             return ".*";
2044     case DCOLON:                return "::";
2045     case EQ:                    return "==";
2046     case NE:                    return "!=";
2047     case LE:                    return "<=";
2048     case LSHIFT:                return "<<";
2049     case GE:                    return ">=";
2050     case RSHIFT:                return ">>";
2051     case ASM:                   return "asm";
2052     case AUTO:                  return "auto";
2053     case BREAK:                 return "break";
2054     case CASE:                  return "case";
2055     case CATCH:                 return "catch";
2056     case CHAR:                  return "char";
2057     case CLASS:                 return "class";
2058     case CONST:                 return "const";
2059     case CONTINUE:              return "continue";
2060     case DEFAULT:               return "default";
2061     case DELETE:                return "delete";
2062     case DO:                    return "do";
2063     case DOUBLE:                return "double";
2064     case ELSE:                  return "else";
2065     case ENUM:                  return "enum";
2066     case EXTERN:                return "extern";
2067     case FLOAT:                 return "float";
2068     case FOR:                   return "for";
2069     case FRIEND:                return "friend";
2070     case GOTO:                  return "goto";
2071     case IF:                    return "if";
2072     case T_INLINE:              return "inline";
2073     case INT:                   return "int";
2074     case LONG:                  return "long";
2075     case NEW:                   return "new";
2076     case OPERATOR:              return "operator";
2077     case PRIVATE:               return "private";
2078     case PROTECTED:             return "protected";
2079     case PUBLIC:                return "public";
2080     case REGISTER:              return "register";
2081     case RETURN:                return "return";
2082     case SHORT:                 return "short";
2083     case SIGNED:                return "signed";
2084     case SIZEOF:                return "sizeof";
2085     case STATIC:                return "static";
2086     case STRUCT:                return "struct";
2087     case SWITCH:                return "switch";
2088     case TEMPLATE:              return "template";
2089     case THIS:                  return "this";
2090     case THROW:                 return "throw";
2091     case TRY:                   return "try";
2092     case TYPEDEF:               return "typedef";
2093     case UNION:                 return "union";
2094     case UNSIGNED:              return "unsigned";
2095     case VIRTUAL:               return "virtual";
2096     case VOID:                  return "void";
2097     case VOLATILE:              return "volatile";
2098     case WHILE:                 return "while";
2099     case MUTABLE:               return "mutable";
2100     case BOOL:                  return "bool";
2101     case TRUE:                  return "true";
2102     case FALSE:                 return "false";
2103     case SIGNATURE:             return "signature";
2104     case NAMESPACE:             return "namespace";
2105     case EXPLICIT:              return "explicit";
2106     case TYPENAME:              return "typename";
2107     case CONST_CAST:            return "const_cast";
2108     case DYNAMIC_CAST:          return "dynamic_cast";
2109     case REINTERPRET_CAST:      return "reinterpret_cast";
2110     case STATIC_CAST:           return "static_cast";
2111     case TYPEID:                return "typeid";
2112     case USING:                 return "using";
2113     case WCHAR:                 return "wchar_t";
2114     case YYEOF:                 return "EOF";
2115
2116     default:
2117       if (t < 255)
2118         {
2119           b[0] = t;
2120           b[1] = '\0';
2121           return b;
2122         }
2123       else
2124         return "???";
2125     }
2126 }
2127
2128
2129 /* Reinitialize the scanner for a new input file.  */
2130
2131 void
2132 re_init_scanner ()
2133 {
2134   in = inbuffer;
2135   yyline = 1;
2136
2137   if (yytext == NULL)
2138     {
2139       int size = 256;
2140       yytext = (char *) xmalloc (size * sizeof *yytext);
2141       yytext_end = yytext + size;
2142     }
2143 }
2144
2145
2146 /* Insert a keyword NAME with token value TK into the keyword hash
2147    table.  */
2148
2149 void
2150 insert_keyword (name, tk)
2151      char *name;
2152      int tk;
2153 {
2154   char *s;
2155   unsigned h = 0;
2156   struct kw *k = (struct kw *) xmalloc (sizeof *k);
2157
2158   for (s = name; *s; ++s)
2159     h = (h << 1) ^ *s;
2160
2161   h %= KEYWORD_TABLE_SIZE;
2162   k->name = name;
2163   k->tk = tk;
2164   k->next = keyword_table[h];
2165   keyword_table[h] = k;
2166 }
2167
2168
2169 /* Initialize the scanner for the first file.  This sets up the
2170    character class vectors and fills the keyword hash table.  */
2171
2172 void
2173 init_scanner ()
2174 {
2175   int i;
2176
2177   /* Allocate the input buffer */
2178   inbuffer_size = READ_CHUNK_SIZE + 1;
2179   inbuffer = in = (char *) xmalloc (inbuffer_size);
2180   yyline = 1;
2181
2182   /* Set up character class vectors.  */
2183   for (i = 0; i < sizeof is_ident; ++i)
2184     {
2185       if (i == '_' || isalnum (i))
2186         is_ident[i] = 1;
2187
2188       if (i >= '0' && i <= '9')
2189         is_digit[i] = 1;
2190
2191       if (i == ' ' || i == '\t' || i == '\f' || i == '\v')
2192         is_white[i] = 1;
2193     }
2194
2195   /* Fill keyword hash table.  */
2196   insert_keyword ("and", LAND);
2197   insert_keyword ("and_eq", ANDASGN);
2198   insert_keyword ("asm", ASM);
2199   insert_keyword ("auto", AUTO);
2200   insert_keyword ("bitand", '&');
2201   insert_keyword ("bitor", '|');
2202   insert_keyword ("bool", BOOL);
2203   insert_keyword ("break", BREAK);
2204   insert_keyword ("case", CASE);
2205   insert_keyword ("catch", CATCH);
2206   insert_keyword ("char", CHAR);
2207   insert_keyword ("class", CLASS);
2208   insert_keyword ("compl", '~');
2209   insert_keyword ("const", CONST);
2210   insert_keyword ("const_cast", CONST_CAST);
2211   insert_keyword ("continue", CONTINUE);
2212   insert_keyword ("default", DEFAULT);
2213   insert_keyword ("delete", DELETE);
2214   insert_keyword ("do", DO);
2215   insert_keyword ("double", DOUBLE);
2216   insert_keyword ("dynamic_cast", DYNAMIC_CAST);
2217   insert_keyword ("else", ELSE);
2218   insert_keyword ("enum", ENUM);
2219   insert_keyword ("explicit", EXPLICIT);
2220   insert_keyword ("extern", EXTERN);
2221   insert_keyword ("false", FALSE);
2222   insert_keyword ("float", FLOAT);
2223   insert_keyword ("for", FOR);
2224   insert_keyword ("friend", FRIEND);
2225   insert_keyword ("goto", GOTO);
2226   insert_keyword ("if", IF);
2227   insert_keyword ("inline", T_INLINE);
2228   insert_keyword ("int", INT);
2229   insert_keyword ("long", LONG);
2230   insert_keyword ("mutable", MUTABLE);
2231   insert_keyword ("namespace", NAMESPACE);
2232   insert_keyword ("new", NEW);
2233   insert_keyword ("not", '!');
2234   insert_keyword ("not_eq", NE);
2235   insert_keyword ("operator", OPERATOR);
2236   insert_keyword ("or", LOR);
2237   insert_keyword ("or_eq", ORASGN);
2238   insert_keyword ("private", PRIVATE);
2239   insert_keyword ("protected", PROTECTED);
2240   insert_keyword ("public", PUBLIC);
2241   insert_keyword ("register", REGISTER);
2242   insert_keyword ("reinterpret_cast", REINTERPRET_CAST);
2243   insert_keyword ("return", RETURN);
2244   insert_keyword ("short", SHORT);
2245   insert_keyword ("signed", SIGNED);
2246   insert_keyword ("sizeof", SIZEOF);
2247   insert_keyword ("static", STATIC);
2248   insert_keyword ("static_cast", STATIC_CAST);
2249   insert_keyword ("struct", STRUCT);
2250   insert_keyword ("switch", SWITCH);
2251   insert_keyword ("template", TEMPLATE);
2252   insert_keyword ("this", THIS);
2253   insert_keyword ("throw", THROW);
2254   insert_keyword ("true", TRUE);
2255   insert_keyword ("try", TRY);
2256   insert_keyword ("typedef", TYPEDEF);
2257   insert_keyword ("typeid", TYPEID);
2258   insert_keyword ("typename", TYPENAME);
2259   insert_keyword ("union", UNION);
2260   insert_keyword ("unsigned", UNSIGNED);
2261   insert_keyword ("using", USING);
2262   insert_keyword ("virtual", VIRTUAL);
2263   insert_keyword ("void", VOID);
2264   insert_keyword ("volatile", VOLATILE);
2265   insert_keyword ("wchar_t", WCHAR);
2266   insert_keyword ("while", WHILE);
2267   insert_keyword ("xor", '^');
2268   insert_keyword ("xor_eq", XORASGN);
2269 }
2270
2271
2272 \f
2273 /***********************************************************************
2274                                 Parser
2275  ***********************************************************************/
2276
2277 /* Match the current lookahead token and set it to the next token.  */
2278
2279 #define MATCH() (tk = yylex ())
2280
2281 /* Return the lookahead token.  If current lookahead token is cleared,
2282    read a new token.  */
2283
2284 #define LA1 (tk == -1 ? (tk = yylex ()) : tk)
2285
2286 /* Is the current lookahead equal to the token T? */
2287
2288 #define LOOKING_AT(T) (tk == (T))
2289
2290 /* Is the current lookahead one of T1 or T2?  */
2291
2292 #define LOOKING_AT2(T1, T2)     (tk == (T1) || tk == (T2))
2293
2294 /* Is the current lookahead one of T1, T2 or T3?  */
2295
2296 #define LOOKING_AT3(T1, T2, T3) (tk == (T1) || tk == (T2) || tk == (T3))
2297
2298 /* Is the current lookahead one of T1...T4?  */
2299
2300 #define LOOKING_AT4(T1, T2, T3, T4) \
2301      (tk == (T1) || tk == (T2) || tk == (T3) || tk == (T4))
2302
2303 /* Match token T if current lookahead is T.  */
2304
2305 #define MATCH_IF(T) if (LOOKING_AT (T)) MATCH (); else ((void) 0)
2306
2307 /* Skip to matching token if current token is T.  */
2308
2309 #define SKIP_MATCHING_IF(T) \
2310   if (LOOKING_AT (T)) skip_matching (); else ((void) 0)
2311
2312
2313 /* Skip forward until a given token TOKEN or YYEOF is seen and return
2314    the current lookahead token after skipping.  */
2315
2316 int
2317 skip_to (token)
2318      int token;
2319 {
2320   while (!LOOKING_AT2 (YYEOF, token))
2321     MATCH ();
2322   return tk;
2323 }
2324
2325
2326 /* Skip over pairs of tokens (parentheses, square brackets,
2327    angle brackets, curly brackets) matching the current lookahead.  */
2328
2329 void
2330 skip_matching ()
2331 {
2332   int open, close, n;
2333
2334   switch (open = LA1)
2335     {
2336     case '{':
2337       close = '}';
2338       break;
2339
2340     case '(':
2341       close = ')';
2342       break;
2343
2344     case '<':
2345       close = '>';
2346       break;
2347
2348     case '[':
2349       close = ']';
2350       break;
2351
2352     default:
2353       abort ();
2354     }
2355
2356   for (n = 0;;)
2357     {
2358       if (LOOKING_AT (open))
2359         ++n;
2360       else if (LOOKING_AT (close))
2361         --n;
2362       else if (LOOKING_AT (YYEOF))
2363         break;
2364
2365       MATCH ();
2366
2367       if (n == 0)
2368         break;
2369     }
2370 }
2371
2372
2373 /* Re-initialize the parser by resetting the lookahead token.  */
2374
2375 void
2376 re_init_parser ()
2377 {
2378   tk = -1;
2379 }
2380
2381
2382 /* Parse a parameter list, including the const-specifier,
2383    pure-specifier, and throw-list that may follow a parameter list.
2384    Return in FLAGS what was seen following the parameter list.
2385    Returns a hash code for the parameter types.  This value is used to
2386    distinguish between overloaded functions.  */
2387
2388 unsigned
2389 parm_list (flags)
2390      int *flags;
2391 {
2392   unsigned hash = 0;
2393   int type_seen = 0;
2394
2395   while (!LOOKING_AT2 (YYEOF, ')'))
2396     {
2397       switch (LA1)
2398         {
2399           /* Skip over grouping parens or parameter lists in parameter
2400              declarations.  */
2401         case '(':
2402           skip_matching ();
2403           break;
2404
2405           /* Next parameter.  */
2406         case ',':
2407           MATCH ();
2408           type_seen = 0;
2409           break;
2410
2411           /* Ignore the scope part of types, if any.  This is because
2412              some types need scopes when defined outside of a class body,
2413              and don't need them inside the class body.  This means that
2414              we have to look for the last IDENT in a sequence of
2415              IDENT::IDENT::...  */
2416         case IDENT:
2417           if (!type_seen)
2418             {
2419               char *last_id;
2420               unsigned ident_type_hash = 0;
2421
2422               parse_qualified_param_ident_or_type (&last_id);
2423               if (last_id)
2424                 {
2425                   /* LAST_ID null means something like `X::*'.  */
2426                   for (; *last_id; ++last_id)
2427                     ident_type_hash = (ident_type_hash << 1) ^ *last_id;
2428                   hash = (hash << 1) ^ ident_type_hash;
2429                   type_seen = 1;
2430                 }
2431             }
2432           else
2433             MATCH ();
2434           break;
2435
2436         case VOID:
2437           /* This distinction is made to make `func (void)' equivalent
2438              to `func ()'.  */
2439           type_seen = 1;
2440           MATCH ();
2441           if (!LOOKING_AT (')'))
2442             hash = (hash << 1) ^ VOID;
2443           break;
2444
2445         case BOOL:      case CHAR:      case CLASS:     case CONST:
2446         case DOUBLE:    case ENUM:      case FLOAT:     case INT:
2447         case LONG:      case SHORT:     case SIGNED:    case STRUCT:
2448         case UNION:     case UNSIGNED:  case VOLATILE:  case WCHAR:
2449         case ELLIPSIS:
2450           type_seen = 1;
2451           hash = (hash << 1) ^ LA1;
2452           MATCH ();
2453           break;
2454
2455         case '*':       case '&':       case '[':       case ']':
2456           hash = (hash << 1) ^ LA1;
2457           MATCH ();
2458           break;
2459
2460         default:
2461           MATCH ();
2462           break;
2463         }
2464     }
2465
2466   if (LOOKING_AT (')'))
2467     {
2468       MATCH ();
2469
2470       if (LOOKING_AT (CONST))
2471         {
2472           /* We can overload the same function on `const' */
2473           hash = (hash << 1) ^ CONST;
2474           SET_FLAG (*flags, F_CONST);
2475           MATCH ();
2476         }
2477
2478       if (LOOKING_AT (THROW))
2479         {
2480           MATCH ();
2481           SKIP_MATCHING_IF ('(');
2482           SET_FLAG (*flags, F_THROW);
2483         }
2484
2485       if (LOOKING_AT ('='))
2486         {
2487           MATCH ();
2488           if (LOOKING_AT (CINT) && yyival == 0)
2489             {
2490               MATCH ();
2491               SET_FLAG (*flags, F_PURE);
2492             }
2493         }
2494     }
2495
2496   return hash;
2497 }
2498
2499
2500 /* Print position info to stdout.  */
2501
2502 void
2503 print_info ()
2504 {
2505   if (info_position >= 0 && BUFFER_POS () <= info_position)
2506     if (info_cls)
2507       printf ("(\"%s\" \"%s\" \"%s\" %d)\n",
2508               info_cls->name, sym_scope (info_cls),
2509               info_member->name, info_where);
2510 }
2511
2512
2513 /* Parse a member declaration within the class body of CLS.  VIS is
2514    the access specifier for the member (private, protected,
2515    public).  */
2516
2517 void
2518 member (cls, vis)
2519      struct sym *cls;
2520      int vis;
2521 {
2522   char *id = NULL;
2523   int sc = SC_MEMBER;
2524   char *regexp = NULL;
2525   int pos;
2526   int is_constructor;
2527   int anonymous = 0;
2528   int flags = 0;
2529   int class_tag;
2530   int type_seen = 0;
2531   int paren_seen = 0;
2532   unsigned hash = 0;
2533   int tilde = 0;
2534
2535   while (!LOOKING_AT4 (';', '{', '}', YYEOF))
2536     {
2537       switch (LA1)
2538         {
2539         default:
2540           MATCH ();
2541           break;
2542
2543           /* A function or class may follow.  */
2544         case TEMPLATE:
2545           MATCH();
2546           SET_FLAG (flags, F_TEMPLATE);
2547           /* Skip over template argument list */
2548           SKIP_MATCHING_IF ('<');
2549           break;
2550
2551         case EXPLICIT:
2552           SET_FLAG (flags, F_EXPLICIT);
2553           goto typeseen;
2554
2555         case MUTABLE:
2556           SET_FLAG (flags, F_MUTABLE);
2557           goto typeseen;
2558
2559         case T_INLINE:
2560           SET_FLAG (flags, F_INLINE);
2561           goto typeseen;
2562
2563         case VIRTUAL:
2564           SET_FLAG (flags, F_VIRTUAL);
2565           goto typeseen;
2566
2567         case '[':
2568           skip_matching ();
2569           break;
2570
2571         case ENUM:
2572           sc = SC_TYPE;
2573           goto typeseen;
2574
2575         case TYPEDEF:
2576           sc = SC_TYPE;
2577           goto typeseen;
2578
2579         case FRIEND:
2580           sc = SC_FRIEND;
2581           goto typeseen;
2582
2583         case STATIC:
2584           sc = SC_STATIC;
2585           goto typeseen;
2586
2587         case '~':
2588           tilde = 1;
2589           MATCH ();
2590           break;
2591
2592         case IDENT:
2593           /* Remember IDENTS seen so far.  Among these will be the member
2594              name.  */
2595           id = (char *) xrealloc (id, strlen (yytext) + 2);
2596           if (tilde)
2597             {
2598               *id = '~';
2599               strcpy (id + 1, yytext);
2600             }
2601           else
2602             strcpy (id, yytext);
2603           MATCH ();
2604           break;
2605
2606         case OPERATOR:
2607           {
2608             char *s = operator_name (&sc);
2609             id = (char *) xrealloc (id, strlen (s) + 1);
2610             strcpy (id, s);
2611           }
2612           break;
2613
2614         case '(':
2615           /* Most probably the beginning of a parameter list.  */
2616           MATCH ();
2617           paren_seen = 1;
2618
2619           if (id && cls)
2620             {
2621               if (!(is_constructor = streq (id, cls->name)))
2622                 regexp = matching_regexp ();
2623             }
2624           else
2625             is_constructor = 0;
2626
2627           pos = BUFFER_POS ();
2628           hash = parm_list (&flags);
2629
2630           if (is_constructor)
2631             regexp = matching_regexp ();
2632
2633           if (id && cls != NULL)
2634             add_member_decl (cls, id, regexp, pos, hash, 0, sc, vis, flags);
2635
2636           while (!LOOKING_AT3 (';', '{', YYEOF))
2637             MATCH ();
2638
2639           if (LOOKING_AT ('{') && id && cls)
2640             add_member_defn (cls, id, regexp, pos, hash, 0, sc, flags);
2641
2642           xfree (id);
2643           id = NULL;
2644           sc = SC_MEMBER;
2645           break;
2646
2647         case STRUCT: case UNION: case CLASS:
2648           /* Nested class */
2649           class_tag = LA1;
2650           type_seen = 1;
2651           MATCH ();
2652           anonymous = 1;
2653
2654           /* More than one ident here to allow for MS-DOS specialties
2655              like `_export class' etc.  The last IDENT seen counts
2656              as the class name.  */
2657           while (!LOOKING_AT4 (YYEOF, ';', ':', '{'))
2658             {
2659               if (LOOKING_AT (IDENT))
2660                 anonymous = 0;
2661               MATCH ();
2662             }
2663
2664           if (LOOKING_AT2 (':', '{'))
2665             class_definition (anonymous ? NULL : cls, class_tag, flags, 1);
2666           else
2667             skip_to (';');
2668           break;
2669
2670         case INT:       case CHAR:      case LONG:      case UNSIGNED:
2671         case SIGNED:    case CONST:     case DOUBLE:    case VOID:
2672         case SHORT:     case VOLATILE:  case BOOL:      case WCHAR:
2673         case TYPENAME:
2674         typeseen:
2675           type_seen = 1;
2676           MATCH ();
2677           break;
2678         }
2679     }
2680
2681   if (LOOKING_AT (';'))
2682     {
2683       /* The end of a member variable, a friend declaration or an access
2684          declaration.  We don't want to add friend classes as members.  */
2685       if (id && sc != SC_FRIEND && cls)
2686         {
2687           regexp = matching_regexp ();
2688           pos = BUFFER_POS ();
2689
2690           if (cls != NULL)
2691             {
2692               if (type_seen || !paren_seen)
2693                 add_member_decl (cls, id, regexp, pos, 0, 1, sc, vis, 0);
2694               else
2695                 add_member_decl (cls, id, regexp, pos, hash, 0, sc, vis, 0);
2696             }
2697         }
2698
2699       MATCH ();
2700       print_info ();
2701     }
2702   else if (LOOKING_AT ('{'))
2703     {
2704       /* A named enum.  */
2705       if (sc == SC_TYPE && id && cls)
2706         {
2707           regexp = matching_regexp ();
2708           pos = BUFFER_POS ();
2709
2710           if (cls != NULL)
2711             {
2712               add_member_decl (cls, id, regexp, pos, 0, 1, sc, vis, 0);
2713               add_member_defn (cls, id, regexp, pos, 0, 1, sc, 0);
2714             }
2715         }
2716
2717       skip_matching ();
2718       print_info ();
2719     }
2720
2721   xfree (id);
2722 }
2723
2724
2725 /* Parse the body of class CLS.  TAG is the tag of the class (struct,
2726    union, class).  */
2727
2728 void
2729 class_body (cls, tag)
2730      struct sym *cls;
2731      int tag;
2732 {
2733   int vis = tag == CLASS ? PRIVATE : PUBLIC;
2734   int temp;
2735
2736   while (!LOOKING_AT2 (YYEOF, '}'))
2737     {
2738       switch (LA1)
2739         {
2740         case PRIVATE: case PROTECTED: case PUBLIC:
2741           temp = LA1;
2742           MATCH ();
2743
2744           if (LOOKING_AT (':'))
2745             {
2746               vis = temp;
2747               MATCH ();
2748             }
2749           else
2750             {
2751               /* Probably conditional compilation for inheritance list.
2752                  We don't known whether there comes more of this.
2753                  This is only a crude fix that works most of the time.  */
2754               do
2755                 {
2756                   MATCH ();
2757                 }
2758               while (LOOKING_AT2 (IDENT, ',')
2759                      || LOOKING_AT3 (PUBLIC, PROTECTED, PRIVATE));
2760             }
2761           break;
2762
2763         case TYPENAME:
2764         case USING:
2765           skip_to (';');
2766           break;
2767
2768           /* Try to synchronize */
2769         case CHAR:      case CLASS:     case CONST:
2770         case DOUBLE:    case ENUM:      case FLOAT:     case INT:
2771         case LONG:      case SHORT:     case SIGNED:    case STRUCT:
2772         case UNION:     case UNSIGNED:  case VOID:      case VOLATILE:
2773         case TYPEDEF:   case STATIC:    case T_INLINE:  case FRIEND:
2774         case VIRTUAL:   case TEMPLATE:  case IDENT:     case '~':
2775         case BOOL:      case WCHAR:     case EXPLICIT:  case MUTABLE:
2776           member (cls, vis);
2777           break;
2778
2779         default:
2780           MATCH ();
2781           break;
2782         }
2783     }
2784 }
2785
2786
2787 /* Parse a qualified identifier.  Current lookahead is IDENT.  A
2788    qualified ident has the form `X<..>::Y<...>::T<...>.  Returns a
2789    symbol for that class.  */
2790
2791 struct sym *
2792 parse_classname ()
2793 {
2794   struct sym *last_class = NULL;
2795
2796   while (LOOKING_AT (IDENT))
2797     {
2798       last_class = add_sym (yytext, last_class);
2799       MATCH ();
2800
2801       if (LOOKING_AT ('<'))
2802         {
2803           skip_matching ();
2804           SET_FLAG (last_class->flags, F_TEMPLATE);
2805         }
2806
2807       if (!LOOKING_AT (DCOLON))
2808         break;
2809
2810       MATCH ();
2811     }
2812
2813   return last_class;
2814 }
2815
2816
2817 /* Parse an operator name.  Add the `static' flag to *SC if an
2818    implicitly static operator has been parsed.  Value is a pointer to
2819    a static buffer holding the constructed operator name string.  */
2820
2821 char *
2822 operator_name (sc)
2823      int *sc;
2824 {
2825   static int id_size = 0;
2826   static char *id = NULL;
2827   char *s;
2828   int len;
2829
2830   MATCH ();
2831
2832   if (LOOKING_AT2 (NEW, DELETE))
2833     {
2834       /* `new' and `delete' are implicitly static.  */
2835       if (*sc != SC_FRIEND)
2836         *sc = SC_STATIC;
2837
2838       s = token_string (LA1);
2839       MATCH ();
2840
2841       len = strlen (s) + 10;
2842       if (len > id_size)
2843         {
2844           int new_size = max (len, 2 * id_size);
2845           id = (char *) xrealloc (id, new_size);
2846           id_size = new_size;
2847         }
2848       strcpy (id, s);
2849
2850       /* Vector new or delete? */
2851       if (LOOKING_AT ('['))
2852         {
2853           strcat (id, "[");
2854           MATCH ();
2855
2856           if (LOOKING_AT (']'))
2857             {
2858               strcat (id, "]");
2859               MATCH ();
2860             }
2861         }
2862     }
2863   else
2864     {
2865       int tokens_matched = 0;
2866
2867       len = 20;
2868       if (len > id_size)
2869         {
2870           int new_size = max (len, 2 * id_size);
2871           id = (char *) xrealloc (id, new_size);
2872           id_size = new_size;
2873         }
2874       strcpy (id, "operator");
2875
2876       /* Beware access declarations of the form "X::f;" Beware of
2877          `operator () ()'.  Yet another difficulty is found in
2878          GCC 2.95's STL: `operator == __STL_NULL_TMPL_ARGS (...'.  */
2879       while (!(LOOKING_AT ('(') && tokens_matched)
2880              && !LOOKING_AT2 (';', YYEOF))
2881         {
2882           s = token_string (LA1);
2883           len += strlen (s) + 2;
2884           if (len > id_size)
2885             {
2886               int new_size = max (len, 2 * id_size);
2887               id = (char *) xrealloc (id, new_size);
2888               id_size = new_size;
2889             }
2890
2891           if (*s != ')' && *s != ']')
2892             strcat (id, " ");
2893           strcat (id, s);
2894           MATCH ();
2895
2896           /* If this is a simple operator like `+', stop now.  */
2897           if (!isalpha ((unsigned char) *s) && *s != '(' && *s != '[')
2898             break;
2899
2900           ++tokens_matched;
2901         }
2902     }
2903
2904   return id;
2905 }
2906
2907
2908 /* This one consumes the last IDENT of a qualified member name like
2909    `X::Y::z'.  This IDENT is returned in LAST_ID.  Value if the
2910    symbol structure for the ident.  */
2911
2912 struct sym *
2913 parse_qualified_ident_or_type (last_id)
2914      char **last_id;
2915 {
2916   struct sym *cls = NULL;
2917   char *id = NULL;
2918   size_t id_size = 0;
2919
2920   while (LOOKING_AT (IDENT))
2921     {
2922       int len = strlen (yytext) + 1;
2923       if (len > id_size)
2924         {
2925           id = (char *) xrealloc (id, len);
2926           id_size = len;
2927         }
2928       strcpy (id, yytext);
2929       *last_id = id;
2930       MATCH ();
2931
2932       SKIP_MATCHING_IF ('<');
2933
2934       if (LOOKING_AT (DCOLON))
2935         {
2936           cls = add_sym (id, cls);
2937           *last_id = NULL;
2938           xfree (id);
2939           id = NULL;
2940           id_size = 0;
2941           MATCH ();
2942         }
2943       else
2944         break;
2945     }
2946
2947   return cls;
2948 }
2949
2950
2951 /* This one consumes the last IDENT of a qualified member name like
2952    `X::Y::z'.  This IDENT is returned in LAST_ID.  Value if the
2953    symbol structure for the ident.  */
2954
2955 void
2956 parse_qualified_param_ident_or_type (last_id)
2957      char **last_id;
2958 {
2959   struct sym *cls = NULL;
2960   static char *id = NULL;
2961   static int id_size = 0;
2962
2963   while (LOOKING_AT (IDENT))
2964     {
2965       int len = strlen (yytext) + 1;
2966       if (len > id_size)
2967         {
2968           id = (char *) xrealloc (id, len);
2969           id_size = len;
2970         }
2971       strcpy (id, yytext);
2972       *last_id = id;
2973       MATCH ();
2974
2975       SKIP_MATCHING_IF ('<');
2976
2977       if (LOOKING_AT (DCOLON))
2978         {
2979           cls = add_sym (id, cls);
2980           *last_id = NULL;
2981           MATCH ();
2982         }
2983       else
2984         break;
2985     }
2986 }
2987
2988
2989 /* Parse a class definition.
2990
2991    CONTAINING is the class containing the class being parsed or null.
2992    This may also be null if NESTED != 0 if the containing class is
2993    anonymous.  TAG is the tag of the class (struct, union, class).
2994    NESTED is non-zero if we are parsing a nested class.
2995
2996    Current lookahead is the class name.  */
2997
2998 void
2999 class_definition (containing, tag, flags, nested)
3000      struct sym *containing;
3001      int tag;
3002      int flags;
3003      int nested;
3004 {
3005   struct sym *current;
3006   struct sym *base_class;
3007
3008   /* Set CURRENT to null if no entry has to be made for the class
3009      parsed.  This is the case for certain command line flag
3010      settings.  */
3011   if ((tag != CLASS && !f_structs) || (nested && !f_nested_classes))
3012     current = NULL;
3013   else
3014     {
3015       current = add_sym (yytext, containing);
3016       current->pos = BUFFER_POS ();
3017       current->regexp = matching_regexp ();
3018       current->filename = filename;
3019       current->flags = flags;
3020     }
3021
3022   /* If at ':', base class list follows.  */
3023   if (LOOKING_AT (':'))
3024     {
3025       int done = 0;
3026       MATCH ();
3027
3028       while (!done)
3029         {
3030           switch (LA1)
3031             {
3032             case VIRTUAL: case PUBLIC: case PROTECTED: case PRIVATE:
3033               MATCH ();
3034               break;
3035
3036             case IDENT:
3037               base_class = parse_classname ();
3038               if (base_class && current && base_class != current)
3039                 add_link (base_class, current);
3040               break;
3041
3042               /* The `,' between base classes or the end of the base
3043                  class list.  Add the previously found base class.
3044                  It's done this way to skip over sequences of
3045                  `A::B::C' until we reach the end.
3046
3047                  FIXME: it is now possible to handle `class X : public B::X'
3048                  because we have enough information.  */
3049             case ',':
3050               MATCH ();
3051               break;
3052
3053             default:
3054               /* A syntax error, possibly due to preprocessor constructs
3055                  like
3056
3057                  #ifdef SOMETHING
3058                  class A : public B
3059                  #else
3060                  class A : private B.
3061
3062                  MATCH until we see something like `;' or `{'.  */
3063               while (!LOOKING_AT3 (';', YYEOF, '{'))
3064                 MATCH ();
3065               done = 1;
3066
3067             case '{':
3068               done = 1;
3069               break;
3070             }
3071         }
3072     }
3073
3074   /* Parse the class body if there is one.  */
3075   if (LOOKING_AT ('{'))
3076     {
3077       if (tag != CLASS && !f_structs)
3078         skip_matching ();
3079       else
3080         {
3081           MATCH ();
3082           class_body (current, tag);
3083
3084           if (LOOKING_AT ('}'))
3085             {
3086               MATCH ();
3087               if (LOOKING_AT (';') && !nested)
3088                 MATCH ();
3089             }
3090         }
3091     }
3092 }
3093
3094
3095 /* Parse a declaration.  */
3096
3097 void
3098 declaration (flags)
3099      int flags;
3100 {
3101   char *id = NULL;
3102   struct sym *cls = NULL;
3103   char *regexp = NULL;
3104   int pos = 0;
3105   unsigned hash = 0;
3106   int is_constructor;
3107   int sc = 0;
3108
3109   while (!LOOKING_AT3 (';', '{', YYEOF))
3110     {
3111       switch (LA1)
3112         {
3113         default:
3114           MATCH ();
3115           break;
3116
3117         case '[':
3118           skip_matching ();
3119           break;
3120
3121         case ENUM:
3122         case TYPEDEF:
3123           sc = SC_TYPE;
3124           MATCH ();
3125           break;
3126
3127         case STATIC:
3128           sc = SC_STATIC;
3129           MATCH ();
3130           break;
3131
3132         case INT:       case CHAR:      case LONG:      case UNSIGNED:
3133         case SIGNED:    case CONST:     case DOUBLE:    case VOID:
3134         case SHORT:     case VOLATILE:  case BOOL:      case WCHAR:
3135           MATCH ();
3136           break;
3137
3138         case CLASS: case STRUCT: case UNION:
3139           /* This is for the case `STARTWRAP class X : ...' or
3140              `declare (X, Y)\n class A : ...'.  */
3141           if (id)
3142             {
3143               xfree (id);
3144               return;
3145             }
3146
3147         case '=':
3148           /* Assumed to be the start of an initialization in this context.
3149              Skip over everything up to ';'.  */
3150           skip_to (';');
3151           break;
3152
3153         case OPERATOR:
3154           {
3155             char *s = operator_name (&sc);
3156             id = (char *) xrealloc (id, strlen (s) + 1);
3157             strcpy (id, s);
3158           }
3159           break;
3160
3161         case T_INLINE:
3162           SET_FLAG (flags, F_INLINE);
3163           MATCH ();
3164           break;
3165
3166         case '~':
3167           MATCH ();
3168           if (LOOKING_AT (IDENT))
3169             {
3170               id = (char *) xrealloc (id, strlen (yytext) + 2);
3171               *id = '~';
3172               strcpy (id + 1, yytext);
3173               MATCH ();
3174             }
3175           break;
3176
3177         case IDENT:
3178           cls = parse_qualified_ident_or_type (&id);
3179           break;
3180
3181         case '(':
3182           /* Most probably the beginning of a parameter list.  */
3183           if (cls)
3184             {
3185               MATCH ();
3186
3187               if (id && cls)
3188                 {
3189                   if (!(is_constructor = streq (id, cls->name)))
3190                     regexp = matching_regexp ();
3191                 }
3192               else
3193                 is_constructor = 0;
3194
3195               pos = BUFFER_POS ();
3196               hash = parm_list (&flags);
3197
3198               if (is_constructor)
3199                 regexp = matching_regexp ();
3200
3201               if (id && cls)
3202                 add_member_defn (cls, id, regexp, pos, hash, 0,
3203                                  SC_UNKNOWN, flags);
3204             }
3205           else
3206             {
3207               /* This may be a C functions, but also a macro
3208                  call of the form `declare (A, B)' --- such macros
3209                  can be found in some class libraries.  */
3210               MATCH ();
3211
3212               if (id)
3213                 {
3214                   regexp = matching_regexp ();
3215                   pos = BUFFER_POS ();
3216                   hash = parm_list (&flags);
3217                   add_global_decl (id, regexp, pos, hash, 0, sc, flags);
3218                 }
3219
3220               /* This is for the case that the function really is
3221                  a macro with no `;' following it.  If a CLASS directly
3222                  follows, we would miss it otherwise.  */
3223               if (LOOKING_AT3 (CLASS, STRUCT, UNION))
3224                 return;
3225             }
3226
3227           while (!LOOKING_AT3 (';', '{', YYEOF))
3228             MATCH ();
3229
3230           if (!cls && id && LOOKING_AT ('{'))
3231             add_global_defn (id, regexp, pos, hash, 0, sc, flags);
3232
3233           xfree (id);
3234           id = NULL;
3235           break;
3236         }
3237     }
3238
3239   if (LOOKING_AT (';'))
3240     {
3241       /* The end of a member variable or of an access declaration
3242          `X::f'.  To distinguish between them we have to know whether
3243          type information has been seen.  */
3244       if (id)
3245         {
3246           char *regexp = matching_regexp ();
3247           int pos = BUFFER_POS ();
3248
3249           if (cls)
3250             add_member_defn (cls, id, regexp, pos, 0, 1, SC_UNKNOWN, flags);
3251           else
3252             add_global_defn (id, regexp, pos, 0, 1, sc, flags);
3253         }
3254
3255       MATCH ();
3256       print_info ();
3257     }
3258   else if (LOOKING_AT ('{'))
3259     {
3260       if (sc == SC_TYPE && id)
3261         {
3262           /* A named enumeration.  */
3263           regexp = matching_regexp ();
3264           pos = BUFFER_POS ();
3265           add_global_defn (id, regexp, pos, 0, 1, sc, flags);
3266         }
3267
3268       skip_matching ();
3269       print_info ();
3270     }
3271
3272   xfree (id);
3273 }
3274
3275
3276 /* Parse a list of top-level declarations/definitions.  START_FLAGS
3277    says in which context we are parsing.  If it is F_EXTERNC, we are
3278    parsing in an `extern "C"' block.  Value is 1 if EOF is reached, 0
3279    otherwise.  */
3280
3281 int
3282 globals (start_flags)
3283      int start_flags;
3284 {
3285   int anonymous;
3286   int class_tk;
3287   int flags = start_flags;
3288
3289   for (;;)
3290     {
3291       char *prev_in = in;
3292
3293       switch (LA1)
3294         {
3295         case NAMESPACE:
3296           {
3297             MATCH ();
3298
3299             if (LOOKING_AT (IDENT))
3300               {
3301                 char *namespace_name = xstrdup (yytext);
3302                 MATCH ();
3303
3304                 if (LOOKING_AT ('='))
3305                   {
3306                     if (skip_to (';') == ';')
3307                       MATCH ();
3308                     register_namespace_alias (namespace_name, yytext);
3309                   }
3310                 else if (LOOKING_AT ('{'))
3311                   {
3312                     MATCH ();
3313                     enter_namespace (namespace_name);
3314                     globals (0);
3315                     leave_namespace ();
3316                     MATCH_IF ('}');
3317                   }
3318
3319                 xfree (namespace_name);
3320               }
3321           }
3322           break;
3323
3324         case EXTERN:
3325           MATCH ();
3326           if (LOOKING_AT (CSTRING) && *string_start == 'C'
3327               && *(string_start + 1) == '"')
3328             {
3329               /* This is `extern "C"'.  */
3330               MATCH ();
3331
3332               if (LOOKING_AT ('{'))
3333                 {
3334                   MATCH ();
3335                   globals (F_EXTERNC);
3336                   MATCH_IF ('}');
3337                 }
3338               else
3339                 SET_FLAG (flags, F_EXTERNC);
3340             }
3341           break;
3342
3343         case TEMPLATE:
3344           MATCH ();
3345           SKIP_MATCHING_IF ('<');
3346           SET_FLAG (flags, F_TEMPLATE);
3347           break;
3348
3349         case CLASS: case STRUCT: case UNION:
3350           class_tk = LA1;
3351           MATCH ();
3352           anonymous = 1;
3353
3354           /* More than one ident here to allow for MS-DOS and OS/2
3355              specialties like `far', `_Export' etc.  Some C++ libs
3356              have constructs like `_OS_DLLIMPORT(_OS_CLIENT)' in front
3357              of the class name.  */
3358           while (!LOOKING_AT4 (YYEOF, ';', ':', '{'))
3359             {
3360               if (LOOKING_AT (IDENT))
3361                 anonymous = 0;
3362               MATCH ();
3363             }
3364
3365           /* Don't add anonymous unions.  */
3366           if (LOOKING_AT2 (':', '{') && !anonymous)
3367               class_definition (NULL, class_tk, flags, 0);
3368           else
3369             {
3370               if (skip_to (';') == ';')
3371                 MATCH ();
3372             }
3373
3374           flags = start_flags;
3375           break;
3376
3377         case YYEOF:
3378           return 1;
3379
3380         case '}':
3381           return 0;
3382
3383         default:
3384           declaration (flags);
3385           flags = start_flags;
3386           break;
3387         }
3388
3389       if (prev_in == in)
3390         yyerror ("parse error", NULL);
3391     }
3392 }
3393
3394
3395 /* Parse the current input file.  */
3396
3397 void
3398 yyparse ()
3399 {
3400   while (globals (0) == 0)
3401     MATCH_IF ('}');
3402 }
3403
3404
3405 \f
3406 /***********************************************************************
3407                              Main Program
3408  ***********************************************************************/
3409
3410 /* Add the list of paths PATH_LIST to the current search path for
3411    input files.  */
3412
3413 void
3414 add_search_path (path_list)
3415      char *path_list;
3416 {
3417   while (*path_list)
3418     {
3419       char *start = path_list;
3420       struct search_path *p;
3421
3422       while (*path_list && *path_list != PATH_LIST_SEPARATOR)
3423         ++path_list;
3424
3425       p = (struct search_path *) xmalloc (sizeof *p);
3426       p->path = (char *) xmalloc (path_list - start + 1);
3427       memcpy (p->path, start, path_list - start);
3428       p->path[path_list - start] = '\0';
3429       p->next = NULL;
3430
3431       if (search_path_tail)
3432         {
3433           search_path_tail->next = p;
3434           search_path_tail = p;
3435         }
3436       else
3437         search_path = search_path_tail = p;
3438
3439       while (*path_list == PATH_LIST_SEPARATOR)
3440         ++path_list;
3441     }
3442 }
3443
3444
3445 /* Open FILE and return a file handle for it, or -1 if FILE cannot be
3446    opened.  Try to find FILE in search_path first, then try the
3447    unchanged file name.  */
3448
3449 FILE *
3450 open_file (file)
3451      char *file;
3452 {
3453   FILE *fp = NULL;
3454   static char *buffer;
3455   static int buffer_size;
3456   struct search_path *path;
3457   int flen = strlen (file) + 1; /* +1 for the slash */
3458
3459   filename = xstrdup (file);
3460
3461   for (path = search_path; path && fp == NULL; path = path->next)
3462     {
3463       int len = strlen (path->path) + flen;
3464
3465       if (len + 1 >= buffer_size)
3466         {
3467           buffer_size = max (len + 1, 2 * buffer_size);
3468           buffer = (char *) xrealloc (buffer, buffer_size);
3469         }
3470
3471       strcpy (buffer, path->path);
3472       strcat (buffer, "/");
3473       strcat (buffer, file);
3474       fp = fopen (buffer, "r");
3475     }
3476
3477   /* Try the original file name.  */
3478   if (fp == NULL)
3479      fp = fopen (file, "r");
3480
3481   if (fp == NULL)
3482     yyerror ("cannot open", NULL);
3483
3484   return fp;
3485 }
3486
3487
3488 /* Display usage information and exit program.  */
3489
3490 #define USAGE "\
3491 Usage: ebrowse [options] {files}\n\
3492 \n\
3493   -a, --append                  append output\n\
3494   -f, --files=FILES             read input file names from FILE\n\
3495   -I, --search-path=LIST        set search path for input files\n\
3496   -m, --min-regexp-length=N     set minimum regexp length to N\n\
3497   -M, --max-regexp-length=N     set maximum regexp length to N\n\
3498   -n, --no-nested-classes       exclude nested classes\n\
3499   -o, --output-file=FILE        set output file name to FILE\n\
3500   -p, --position-info           print info about position in file\n\
3501   -s, --no-structs-or-unions    don't record structs or unions\n\
3502   -v, --verbose                 be verbose\n\
3503   -V, --very-verbose            be very verbose\n\
3504   -x, --no-regexps              don't record regular expressions\n\
3505       --help                    display this help\n\
3506       --version                 display version info\n\
3507 "
3508
3509 void
3510 usage (error)
3511      int error;
3512 {
3513   puts (USAGE);
3514   exit (error ? 1 : 0);
3515 }
3516
3517
3518 /* Display version and copyright info.  The VERSION macro is set
3519    from the Makefile and contains the Emacs version.  */
3520
3521 #ifndef VERSION
3522 # define VERSION "21"
3523 #endif
3524
3525 void
3526 version ()
3527 {
3528   printf ("ebrowse %s\n", VERSION);
3529   puts ("Copyright (C) 1992-1999, 2000 Free Software Foundation, Inc.");
3530   puts ("This program is distributed under the same terms as Emacs.");
3531   exit (0);
3532 }
3533
3534
3535 /* Parse one input file FILE, adding classes and members to the symbol
3536    table.  */
3537
3538 void
3539 process_file (file)
3540      char *file;
3541 {
3542   FILE *fp;
3543
3544   fp = open_file (file);
3545   if (fp)
3546     {
3547       int nread, nbytes;
3548
3549       /* Give a progress indication if needed.  */
3550       if (f_very_verbose)
3551         {
3552           puts (filename);
3553           fflush (stdout);
3554         }
3555       else if (f_verbose)
3556         {
3557           putchar ('.');
3558           fflush (stdout);
3559         }
3560
3561       /* Read file to inbuffer.  */
3562       for (nread = 0;;)
3563         {
3564           if (nread + READ_CHUNK_SIZE >= inbuffer_size)
3565             {
3566               inbuffer_size = nread + READ_CHUNK_SIZE + 1;
3567               inbuffer = (char *) xrealloc (inbuffer, inbuffer_size);
3568             }
3569
3570           nbytes = fread (inbuffer + nread, 1, READ_CHUNK_SIZE, fp);
3571           if (nbytes <= 0)
3572             break;
3573           nread += nbytes;
3574         }
3575       if (nread < 0)
3576         nread = 0;
3577       inbuffer[nread] = '\0';
3578
3579       /* Reinitialize scanner and parser for the new input file.  */
3580       re_init_scanner ();
3581       re_init_parser ();
3582
3583       /* Parse it and close the file.  */
3584       yyparse ();
3585       fclose (fp);
3586     }
3587 }
3588
3589
3590 /* Read a line from stream FP and return a pointer to a static buffer
3591    containing its contents without the terminating newline.  Value
3592    is null when EOF is reached.  */
3593
3594 char *
3595 read_line (fp)
3596      FILE *fp;
3597 {
3598   static char *buffer;
3599   static int buffer_size;
3600   int i = 0, c;
3601
3602   while ((c = getc (fp)) != EOF && c != '\n')
3603     {
3604       if (i >= buffer_size)
3605         {
3606           buffer_size = max (100, buffer_size * 2);
3607           buffer = (char *) xrealloc (buffer, buffer_size);
3608         }
3609
3610       buffer[i++] = c;
3611     }
3612
3613   if (c == EOF && i == 0)
3614     return NULL;
3615
3616   if (i == buffer_size)
3617     {
3618       buffer_size = max (100, buffer_size * 2);
3619       buffer = (char *) xrealloc (buffer, buffer_size);
3620     }
3621
3622   buffer[i] = '\0';
3623   if (i > 0 && buffer[i - 1] == '\r')
3624     buffer[i - 1] = '\0';
3625   return buffer;
3626 }
3627
3628
3629 /* Main entry point.  */
3630
3631 int
3632 main (argc, argv)
3633      int argc;
3634      char **argv;
3635 {
3636   int i;
3637   int any_inputfiles = 0;
3638   static char *out_filename = DEFAULT_OUTFILE;
3639   static char **input_filenames = NULL;
3640   static int input_filenames_size = 0;
3641   static int n_input_files;
3642
3643   filename = "command line";
3644   yyout = stdout;
3645
3646   while ((i = getopt_long (argc, argv, "af:I:m:M:no:p:svVx",
3647                            options, NULL)) != EOF)
3648     {
3649       switch (i)
3650         {
3651           /* Experimental.  */
3652         case 'p':
3653           info_position = atoi (optarg);
3654           break;
3655
3656         case 'n':
3657           f_nested_classes = 0;
3658           break;
3659
3660         case 'x':
3661           f_regexps = 0;
3662           break;
3663
3664           /* Add the name of a file containing more input files.  */
3665         case 'f':
3666           if (n_input_files == input_filenames_size)
3667             {
3668               input_filenames_size = max (10, 2 * input_filenames_size);
3669               input_filenames = (char **) xrealloc ((void *)input_filenames,
3670                                                     input_filenames_size);
3671             }
3672           input_filenames[n_input_files++] = xstrdup (optarg);
3673           break;
3674
3675           /* Append new output to output file instead of truncating it.  */
3676         case 'a':
3677           f_append = 1;
3678           break;
3679
3680           /* Include structs in the output */
3681         case 's':
3682           f_structs = 0;
3683           break;
3684
3685           /* Be verbose (give a progress indication).  */
3686         case 'v':
3687           f_verbose = 1;
3688           break;
3689
3690           /* Be very verbose (print file names as they are processed).  */
3691         case 'V':
3692           f_verbose = 1;
3693           f_very_verbose = 1;
3694           break;
3695
3696           /* Change the name of the output file.  */
3697         case 'o':
3698           out_filename = optarg;
3699           break;
3700
3701           /* Set minimum length for regular expression strings
3702              when recorded in the output file.  */
3703         case 'm':
3704           min_regexp = atoi (optarg);
3705           break;
3706
3707           /* Set maximum length for regular expression strings
3708              when recorded in the output file.  */
3709         case 'M':
3710           max_regexp = atoi (optarg);
3711           break;
3712
3713           /* Add to search path.  */
3714         case 'I':
3715           add_search_path (optarg);
3716           break;
3717
3718           /* Display help */
3719         case -2:
3720           usage (0);
3721           break;
3722
3723         case -3:
3724           version ();
3725           break;
3726         }
3727     }
3728
3729   /* Call init_scanner after command line flags have been processed to be
3730      able to add keywords depending on command line (not yet
3731      implemented).  */
3732   init_scanner ();
3733   init_sym ();
3734
3735   /* Open output file */
3736   if (*out_filename)
3737     {
3738       yyout = fopen (out_filename, f_append ? "a" : "w");
3739       if (yyout == NULL)
3740         {
3741           yyerror ("cannot open output file `%s'", out_filename);
3742           exit (1);
3743         }
3744     }
3745
3746   /* Process input files specified on the command line.  */
3747   while (optind < argc)
3748     {
3749       process_file (argv[optind++]);
3750       any_inputfiles = 1;
3751     }
3752
3753   /* Process files given on stdin if no files specified.  */
3754   if (!any_inputfiles && n_input_files == 0)
3755     {
3756       char *file;
3757       while ((file = read_line (stdin)) != NULL)
3758         process_file (file);
3759     }
3760   else
3761     {
3762       /* Process files from `--files=FILE'.  Every line in FILE names
3763          one input file to process.  */
3764       for (i = 0; i < n_input_files; ++i)
3765         {
3766           FILE *fp = fopen (input_filenames[i], "r");
3767
3768           if (fp == NULL)
3769             yyerror ("cannot open input file `%s'", input_filenames[i]);
3770           else
3771             {
3772               char *file;
3773               while ((file = read_line (fp)) != NULL)
3774                 process_file (file);
3775               fclose (fp);
3776             }
3777         }
3778     }
3779
3780   /* Write output file.  */
3781   dump_roots (yyout);
3782
3783   /* Close output file.  */
3784   if (yyout != stdout)
3785     fclose (yyout);
3786
3787   return 0;
3788 }
3789
3790
3791 /* ebrowse.c ends here.  */