lib-src/ebrowse.c

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