lib-src/ebrowse.c

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