lib-src/ebrowse.c

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