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, 2011
   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               /* Don't try to read past the end of the input buffer if
1788                  the file ends in a C++ comment without a newline.  */
1789               if (c == 0)
1790                 return YYEOF;
1791
1792               INCREMENT_LINENO;
1793               break;
1794
1795             default:
1796               UNGET ();
1797               return '/';
1798             }
1799           break;
1800
1801         case '+':
1802           if (GET (c) == '+')
1803             return INC;
1804           else if (c == '=')
1805             return ADDASGN;
1806           UNGET ();
1807           return '+';
1808
1809         case '-':
1810           switch (GET (c))
1811             {
1812             case '-':
1813               return DEC;
1814             case '>':
1815               if (GET (c) == '*')
1816                 return ARROWSTAR;
1817               UNGET ();
1818               return ARROW;
1819             case '=':
1820               return SUBASGN;
1821             }
1822           UNGET ();
1823           return '-';
1824
1825         case '*':
1826           if (GET (c) == '=')
1827             return MULASGN;
1828           UNGET ();
1829           return '*';
1830
1831         case '%':
1832           if (GET (c) == '=')
1833             return MODASGN;
1834           UNGET ();
1835           return '%';
1836
1837         case '|':
1838           if (GET (c) == '|')
1839             return LOR;
1840           else if (c == '=')
1841             return ORASGN;
1842           UNGET ();
1843           return '|';
1844
1845         case '&':
1846           if (GET (c) == '&')
1847             return LAND;
1848           else if (c == '=')
1849             return ANDASGN;
1850           UNGET ();
1851           return '&';
1852
1853         case '^':
1854           if (GET (c) == '=')
1855             return XORASGN;
1856           UNGET ();
1857           return '^';
1858
1859         case '.':
1860           if (GET (c) == '*')
1861             return POINTSTAR;
1862           else if (c == '.')
1863             {
1864               if (GET (c) != '.')
1865                 yyerror ("invalid token '..' ('...' assumed)", NULL);
1866               UNGET ();
1867               return ELLIPSIS;
1868             }
1869           else if (!DIGITP (c))
1870             {
1871               UNGET ();
1872               return '.';
1873             }
1874           goto mantissa;
1875
1876         case ':':
1877           if (GET (c) == ':')
1878             return DCOLON;
1879           UNGET ();
1880           return ':';
1881
1882         case '=':
1883           if (GET (c) == '=')
1884             return EQ;
1885           UNGET ();
1886           return '=';
1887
1888         case '!':
1889           if (GET (c) == '=')
1890             return NE;
1891           UNGET ();
1892           return '!';
1893
1894         case '<':
1895           switch (GET (c))
1896             {
1897             case '=':
1898               return LE;
1899             case '<':
1900               if (GET (c) == '=')
1901                 return LSHIFTASGN;
1902               UNGET ();
1903               return LSHIFT;
1904             }
1905           UNGET ();
1906           return '<';
1907
1908         case '>':
1909           switch (GET (c))
1910             {
1911             case '=':
1912               return GE;
1913             case '>':
1914               if (GET (c) == '=')
1915                 return RSHIFTASGN;
1916               UNGET ();
1917               return RSHIFT;
1918             }
1919           UNGET ();
1920           return '>';
1921
1922         case '#':
1923           c = process_pp_line ();
1924           if (c == 0)
1925             return YYEOF;
1926           break;
1927
1928         case '(': case ')': case '[': case ']': case '{': case '}':
1929         case ';': case ',': case '?': case '~':
1930           return c;
1931
1932         case '0':
1933           yyival = 0;
1934
1935           if (GET (c) == 'x' || c == 'X')
1936             {
1937               while (GET (c))
1938                 {
1939                   if (DIGITP (c))
1940                     yyival = yyival * 16 + c - '0';
1941                   else if (c >= 'a' && c <= 'f')
1942                     yyival = yyival * 16 + c - 'a' + 10;
1943                   else if (c >= 'A' && c <= 'F')
1944                     yyival = yyival * 16 + c - 'A' + 10;
1945                   else
1946                     break;
1947                 }
1948
1949               goto int_suffixes;
1950             }
1951           else if (c == '.')
1952             goto mantissa;
1953
1954           while (c >= '0' && c <= '7')
1955             {
1956               yyival = (yyival << 3) + c - '0';
1957               GET (c);
1958             }
1959
1960         int_suffixes:
1961           /* Integer suffixes.  */
1962           while (isalpha (c))
1963             GET (c);
1964           UNGET ();
1965           return CINT;
1966
1967         case '1': case '2': case '3': case '4': case '5': case '6':
1968         case '7': case '8': case '9':
1969           /* Integer or floating constant, part before '.'.  */
1970           yyival = c - '0';
1971
1972           while (GET (c) && DIGITP (c))
1973             yyival = 10 * yyival + c - '0';
1974
1975           if (c != '.')
1976             goto int_suffixes;
1977
1978         mantissa:
1979           /* Digits following '.'.  */
1980           while (DIGITP (c))
1981             GET (c);
1982
1983           /* Optional exponent.  */
1984           if (c == 'E' || c == 'e')
1985             {
1986               if (GET (c) == '-' || c == '+')
1987                 GET (c);
1988
1989               while (DIGITP (c))
1990                 GET (c);
1991             }
1992
1993           /* Optional type suffixes.  */
1994           while (isalpha (c))
1995             GET (c);
1996           UNGET ();
1997           return CFLOAT;
1998
1999         default:
2000           break;
2001         }
2002     }
2003 }
2004
2005
2006 /* Actually local to matching_regexp.  These variables must be in
2007    global scope for the case that `static' get's defined away.  */
2008
2009 static char *matching_regexp_buffer, *matching_regexp_end_buf;
2010
2011
2012 /* Value is the string from the start of the line to the current
2013    position in the input buffer, or maybe a bit more if that string is
2014    shorter than min_regexp.  */
2015
2016 char *
2017 matching_regexp ()
2018 {
2019   char *p;
2020   char *s;
2021   char *t;
2022
2023   if (!f_regexps)
2024     return NULL;
2025
2026   if (matching_regexp_buffer == NULL)
2027     {
2028       matching_regexp_buffer = (char *) xmalloc (max_regexp);
2029       matching_regexp_end_buf = &matching_regexp_buffer[max_regexp] - 1;
2030     }
2031
2032   /* Scan back to previous newline of buffer start.  */
2033   for (p = in - 1; p > inbuffer && *p != '\n'; --p)
2034     ;
2035
2036   if (*p == '\n')
2037     {
2038       while (in - p < min_regexp && p > inbuffer)
2039         {
2040           /* Line probably not significant enough */
2041           for (--p; p > inbuffer && *p != '\n'; --p)
2042             ;
2043         }
2044       if (*p == '\n')
2045         ++p;
2046     }
2047
2048   /* Copy from end to make sure significant portions are included.
2049      This implies that in the browser a regular expressing of the form
2050      `^.*{regexp}' has to be used.  */
2051   for (s = matching_regexp_end_buf - 1, t = in;
2052        s > matching_regexp_buffer && t > p;)
2053     {
2054       *--s = *--t;
2055
2056       if (*s == '"' || *s == '\\')
2057         *--s = '\\';
2058     }
2059
2060   *(matching_regexp_end_buf - 1) = '\0';
2061   return xstrdup (s);
2062 }
2063
2064
2065 /* Return a printable representation of token T.  */
2066
2067 char *
2068 token_string (t)
2069      int t;
2070 {
2071   static char b[3];
2072
2073   switch (t)
2074     {
2075     case CSTRING:               return "string constant";
2076     case CCHAR:                 return "char constant";
2077     case CINT:                  return "int constant";
2078     case CFLOAT:                return "floating constant";
2079     case ELLIPSIS:              return "...";
2080     case LSHIFTASGN:            return "<<=";
2081     case RSHIFTASGN:            return ">>=";
2082     case ARROWSTAR:             return "->*";
2083     case IDENT:                 return "identifier";
2084     case DIVASGN:               return "/=";
2085     case INC:                   return "++";
2086     case ADDASGN:               return "+=";
2087     case DEC:                   return "--";
2088     case ARROW:                 return "->";
2089     case SUBASGN:               return "-=";
2090     case MULASGN:               return "*=";
2091     case MODASGN:               return "%=";
2092     case LOR:                   return "||";
2093     case ORASGN:                return "|=";
2094     case LAND:                  return "&&";
2095     case ANDASGN:               return "&=";
2096     case XORASGN:               return "^=";
2097     case POINTSTAR:             return ".*";
2098     case DCOLON:                return "::";
2099     case EQ:                    return "==";
2100     case NE:                    return "!=";
2101     case LE:                    return "<=";
2102     case LSHIFT:                return "<<";
2103     case GE:                    return ">=";
2104     case RSHIFT:                return ">>";
2105     case ASM:                   return "asm";
2106     case AUTO:                  return "auto";
2107     case BREAK:                 return "break";
2108     case CASE:                  return "case";
2109     case CATCH:                 return "catch";
2110     case CHAR:                  return "char";
2111     case CLASS:                 return "class";
2112     case CONST:                 return "const";
2113     case CONTINUE:              return "continue";
2114     case DEFAULT:               return "default";
2115     case DELETE:                return "delete";
2116     case DO:                    return "do";
2117     case DOUBLE:                return "double";
2118     case ELSE:                  return "else";
2119     case ENUM:                  return "enum";
2120     case EXTERN:                return "extern";
2121     case FLOAT:                 return "float";
2122     case FOR:                   return "for";
2123     case FRIEND:                return "friend";
2124     case GOTO:                  return "goto";
2125     case IF:                    return "if";
2126     case T_INLINE:              return "inline";
2127     case INT:                   return "int";
2128     case LONG:                  return "long";
2129     case NEW:                   return "new";
2130     case OPERATOR:              return "operator";
2131     case PRIVATE:               return "private";
2132     case PROTECTED:             return "protected";
2133     case PUBLIC:                return "public";
2134     case REGISTER:              return "register";
2135     case RETURN:                return "return";
2136     case SHORT:                 return "short";
2137     case SIGNED:                return "signed";
2138     case SIZEOF:                return "sizeof";
2139     case STATIC:                return "static";
2140     case STRUCT:                return "struct";
2141     case SWITCH:                return "switch";
2142     case TEMPLATE:              return "template";
2143     case THIS:                  return "this";
2144     case THROW:                 return "throw";
2145     case TRY:                   return "try";
2146     case TYPEDEF:               return "typedef";
2147     case UNION:                 return "union";
2148     case UNSIGNED:              return "unsigned";
2149     case VIRTUAL:               return "virtual";
2150     case VOID:                  return "void";
2151     case VOLATILE:              return "volatile";
2152     case WHILE:                 return "while";
2153     case MUTABLE:               return "mutable";
2154     case BOOL:                  return "bool";
2155     case TRUE:                  return "true";
2156     case FALSE:                 return "false";
2157     case SIGNATURE:             return "signature";
2158     case NAMESPACE:             return "namespace";
2159     case EXPLICIT:              return "explicit";
2160     case TYPENAME:              return "typename";
2161     case CONST_CAST:            return "const_cast";
2162     case DYNAMIC_CAST:          return "dynamic_cast";
2163     case REINTERPRET_CAST:      return "reinterpret_cast";
2164     case STATIC_CAST:           return "static_cast";
2165     case TYPEID:                return "typeid";
2166     case USING:                 return "using";
2167     case WCHAR:                 return "wchar_t";
2168     case YYEOF:                 return "EOF";
2169
2170     default:
2171       if (t < 255)
2172         {
2173           b[0] = t;
2174           b[1] = '\0';
2175           return b;
2176         }
2177       else
2178         return "???";
2179     }
2180 }
2181
2182
2183 /* Reinitialize the scanner for a new input file.  */
2184
2185 void
2186 re_init_scanner ()
2187 {
2188   in = inbuffer;
2189   yyline = 1;
2190
2191   if (yytext == NULL)
2192     {
2193       int size = 256;
2194       yytext = (char *) xmalloc (size * sizeof *yytext);
2195       yytext_end = yytext + size;
2196     }
2197 }
2198
2199
2200 /* Insert a keyword NAME with token value TK into the keyword hash
2201    table.  */
2202
2203 void
2204 insert_keyword (name, tk)
2205      char *name;
2206      int tk;
2207 {
2208   char *s;
2209   unsigned h = 0;
2210   struct kw *k = (struct kw *) xmalloc (sizeof *k);
2211
2212   for (s = name; *s; ++s)
2213     h = (h << 1) ^ *s;
2214
2215   h %= KEYWORD_TABLE_SIZE;
2216   k->name = name;
2217   k->tk = tk;
2218   k->next = keyword_table[h];
2219   keyword_table[h] = k;
2220 }
2221
2222
2223 /* Initialize the scanner for the first file.  This sets up the
2224    character class vectors and fills the keyword hash table.  */
2225
2226 void
2227 init_scanner ()
2228 {
2229   int i;
2230
2231   /* Allocate the input buffer */
2232   inbuffer_size = READ_CHUNK_SIZE + 1;
2233   inbuffer = in = (char *) xmalloc (inbuffer_size);
2234   yyline = 1;
2235
2236   /* Set up character class vectors.  */
2237   for (i = 0; i < sizeof is_ident; ++i)
2238     {
2239       if (i == '_' || isalnum (i))
2240         is_ident[i] = 1;
2241
2242       if (i >= '0' && i <= '9')
2243         is_digit[i] = 1;
2244
2245       if (i == ' ' || i == '\t' || i == '\f' || i == '\v')
2246         is_white[i] = 1;
2247     }
2248
2249   /* Fill keyword hash table.  */
2250   insert_keyword ("and", LAND);
2251   insert_keyword ("and_eq", ANDASGN);
2252   insert_keyword ("asm", ASM);
2253   insert_keyword ("auto", AUTO);
2254   insert_keyword ("bitand", '&');
2255   insert_keyword ("bitor", '|');
2256   insert_keyword ("bool", BOOL);
2257   insert_keyword ("break", BREAK);
2258   insert_keyword ("case", CASE);
2259   insert_keyword ("catch", CATCH);
2260   insert_keyword ("char", CHAR);
2261   insert_keyword ("class", CLASS);
2262   insert_keyword ("compl", '~');
2263   insert_keyword ("const", CONST);
2264   insert_keyword ("const_cast", CONST_CAST);
2265   insert_keyword ("continue", CONTINUE);
2266   insert_keyword ("default", DEFAULT);
2267   insert_keyword ("delete", DELETE);
2268   insert_keyword ("do", DO);
2269   insert_keyword ("double", DOUBLE);
2270   insert_keyword ("dynamic_cast", DYNAMIC_CAST);
2271   insert_keyword ("else", ELSE);
2272   insert_keyword ("enum", ENUM);
2273   insert_keyword ("explicit", EXPLICIT);
2274   insert_keyword ("extern", EXTERN);
2275   insert_keyword ("false", FALSE);
2276   insert_keyword ("float", FLOAT);
2277   insert_keyword ("for", FOR);
2278   insert_keyword ("friend", FRIEND);
2279   insert_keyword ("goto", GOTO);
2280   insert_keyword ("if", IF);
2281   insert_keyword ("inline", T_INLINE);
2282   insert_keyword ("int", INT);
2283   insert_keyword ("long", LONG);
2284   insert_keyword ("mutable", MUTABLE);
2285   insert_keyword ("namespace", NAMESPACE);
2286   insert_keyword ("new", NEW);
2287   insert_keyword ("not", '!');
2288   insert_keyword ("not_eq", NE);
2289   insert_keyword ("operator", OPERATOR);
2290   insert_keyword ("or", LOR);
2291   insert_keyword ("or_eq", ORASGN);
2292   insert_keyword ("private", PRIVATE);
2293   insert_keyword ("protected", PROTECTED);
2294   insert_keyword ("public", PUBLIC);
2295   insert_keyword ("register", REGISTER);
2296   insert_keyword ("reinterpret_cast", REINTERPRET_CAST);
2297   insert_keyword ("return", RETURN);
2298   insert_keyword ("short", SHORT);
2299   insert_keyword ("signed", SIGNED);
2300   insert_keyword ("sizeof", SIZEOF);
2301   insert_keyword ("static", STATIC);
2302   insert_keyword ("static_cast", STATIC_CAST);
2303   insert_keyword ("struct", STRUCT);
2304   insert_keyword ("switch", SWITCH);
2305   insert_keyword ("template", TEMPLATE);
2306   insert_keyword ("this", THIS);
2307   insert_keyword ("throw", THROW);
2308   insert_keyword ("true", TRUE);
2309   insert_keyword ("try", TRY);
2310   insert_keyword ("typedef", TYPEDEF);
2311   insert_keyword ("typeid", TYPEID);
2312   insert_keyword ("typename", TYPENAME);
2313   insert_keyword ("union", UNION);
2314   insert_keyword ("unsigned", UNSIGNED);
2315   insert_keyword ("using", USING);
2316   insert_keyword ("virtual", VIRTUAL);
2317   insert_keyword ("void", VOID);
2318   insert_keyword ("volatile", VOLATILE);
2319   insert_keyword ("wchar_t", WCHAR);
2320   insert_keyword ("while", WHILE);
2321   insert_keyword ("xor", '^');
2322   insert_keyword ("xor_eq", XORASGN);
2323 }
2324
2325
2326 \f
2327 /***********************************************************************
2328                                 Parser
2329  ***********************************************************************/
2330
2331 /* Match the current lookahead token and set it to the next token.  */
2332
2333 #define MATCH() (tk = yylex ())
2334
2335 /* Return the lookahead token.  If current lookahead token is cleared,
2336    read a new token.  */
2337
2338 #define LA1 (tk == -1 ? (tk = yylex ()) : tk)
2339
2340 /* Is the current lookahead equal to the token T? */
2341
2342 #define LOOKING_AT(T) (tk == (T))
2343
2344 /* Is the current lookahead one of T1 or T2?  */
2345
2346 #define LOOKING_AT2(T1, T2)     (tk == (T1) || tk == (T2))
2347
2348 /* Is the current lookahead one of T1, T2 or T3?  */
2349
2350 #define LOOKING_AT3(T1, T2, T3) (tk == (T1) || tk == (T2) || tk == (T3))
2351
2352 /* Is the current lookahead one of T1...T4?  */
2353
2354 #define LOOKING_AT4(T1, T2, T3, T4) \
2355      (tk == (T1) || tk == (T2) || tk == (T3) || tk == (T4))
2356
2357 /* Match token T if current lookahead is T.  */
2358
2359 #define MATCH_IF(T) if (LOOKING_AT (T)) MATCH (); else ((void) 0)
2360
2361 /* Skip to matching token if current token is T.  */
2362
2363 #define SKIP_MATCHING_IF(T) \
2364   if (LOOKING_AT (T)) skip_matching (); else ((void) 0)
2365
2366
2367 /* Skip forward until a given token TOKEN or YYEOF is seen and return
2368    the current lookahead token after skipping.  */
2369
2370 int
2371 skip_to (token)
2372      int token;
2373 {
2374   while (!LOOKING_AT2 (YYEOF, token))
2375     MATCH ();
2376   return tk;
2377 }
2378
2379 /* Skip over pairs of tokens (parentheses, square brackets,
2380    angle brackets, curly brackets) matching the current lookahead.  */
2381
2382 void
2383 skip_matching ()
2384 {
2385   int open, close, n;
2386
2387   switch (open = LA1)
2388     {
2389     case '{':
2390       close = '}';
2391       break;
2392
2393     case '(':
2394       close = ')';
2395       break;
2396
2397     case '<':
2398       close = '>';
2399       break;
2400
2401     case '[':
2402       close = ']';
2403       break;
2404
2405     default:
2406       abort ();
2407     }
2408
2409   for (n = 0;;)
2410     {
2411       if (LOOKING_AT (open))
2412         ++n;
2413       else if (LOOKING_AT (close))
2414         --n;
2415       else if (LOOKING_AT (YYEOF))
2416         break;
2417
2418       MATCH ();
2419
2420       if (n == 0)
2421         break;
2422     }
2423 }
2424
2425 void
2426 skip_initializer ()
2427 {
2428   for (;;)
2429     {
2430       switch (LA1)
2431         {
2432         case ';':
2433         case ',':
2434         case YYEOF:
2435           return;
2436
2437         case '{':
2438         case '[':
2439         case '(':
2440           skip_matching ();
2441           break;
2442
2443         default:
2444           MATCH ();
2445           break;
2446         }
2447     }
2448 }
2449
2450 /* Build qualified namespace alias (A::B::c) and return it. */
2451
2452 struct link *
2453 match_qualified_namespace_alias ()
2454 {
2455   struct link *head = NULL;
2456   struct link *cur = NULL;
2457   struct link *tmp = NULL;
2458
2459   for (;;)
2460     {
2461       MATCH ();
2462       switch (LA1)
2463         {
2464         case IDENT:
2465           tmp = (struct link *) xmalloc (sizeof *cur);
2466           tmp->sym = find_namespace (yytext, cur);
2467           tmp->next = NULL;
2468           if (head)
2469             {
2470               cur = cur->next = tmp;
2471             }
2472           else
2473             {
2474               head = cur = tmp;
2475             }
2476           break;
2477         case DCOLON:
2478           /* Just skip */
2479           break;
2480         default:
2481           return head;
2482           break;
2483         }
2484     }
2485 }
2486
2487 /* Re-initialize the parser by resetting the lookahead token.  */
2488
2489 void
2490 re_init_parser ()
2491 {
2492   tk = -1;
2493 }
2494
2495
2496 /* Parse a parameter list, including the const-specifier,
2497    pure-specifier, and throw-list that may follow a parameter list.
2498    Return in FLAGS what was seen following the parameter list.
2499    Returns a hash code for the parameter types.  This value is used to
2500    distinguish between overloaded functions.  */
2501
2502 unsigned
2503 parm_list (flags)
2504      int *flags;
2505 {
2506   unsigned hash = 0;
2507   int type_seen = 0;
2508
2509   while (!LOOKING_AT2 (YYEOF, ')'))
2510     {
2511       switch (LA1)
2512         {
2513           /* Skip over grouping parens or parameter lists in parameter
2514              declarations.  */
2515         case '(':
2516           skip_matching ();
2517           break;
2518
2519           /* Next parameter.  */
2520         case ',':
2521           MATCH ();
2522           type_seen = 0;
2523           break;
2524
2525           /* Ignore the scope part of types, if any.  This is because
2526              some types need scopes when defined outside of a class body,
2527              and don't need them inside the class body.  This means that
2528              we have to look for the last IDENT in a sequence of
2529              IDENT::IDENT::...  */
2530         case IDENT:
2531           if (!type_seen)
2532             {
2533               char *last_id;
2534               unsigned ident_type_hash = 0;
2535
2536               parse_qualified_param_ident_or_type (&last_id);
2537               if (last_id)
2538                 {
2539                   /* LAST_ID null means something like `X::*'.  */
2540                   for (; *last_id; ++last_id)
2541                     ident_type_hash = (ident_type_hash << 1) ^ *last_id;
2542                   hash = (hash << 1) ^ ident_type_hash;
2543                   type_seen = 1;
2544                 }
2545             }
2546           else
2547             MATCH ();
2548           break;
2549
2550         case VOID:
2551           /* This distinction is made to make `func (void)' equivalent
2552              to `func ()'.  */
2553           type_seen = 1;
2554           MATCH ();
2555           if (!LOOKING_AT (')'))
2556             hash = (hash << 1) ^ VOID;
2557           break;
2558
2559         case BOOL:      case CHAR:      case CLASS:     case CONST:
2560         case DOUBLE:    case ENUM:      case FLOAT:     case INT:
2561         case LONG:      case SHORT:     case SIGNED:    case STRUCT:
2562         case UNION:     case UNSIGNED:  case VOLATILE:  case WCHAR:
2563         case ELLIPSIS:
2564           type_seen = 1;
2565           hash = (hash << 1) ^ LA1;
2566           MATCH ();
2567           break;
2568
2569         case '*':       case '&':       case '[':       case ']':
2570           hash = (hash << 1) ^ LA1;
2571           MATCH ();
2572           break;
2573
2574         default:
2575           MATCH ();
2576           break;
2577         }
2578     }
2579
2580   if (LOOKING_AT (')'))
2581     {
2582       MATCH ();
2583
2584       if (LOOKING_AT (CONST))
2585         {
2586           /* We can overload the same function on `const' */
2587           hash = (hash << 1) ^ CONST;
2588           SET_FLAG (*flags, F_CONST);
2589           MATCH ();
2590         }
2591
2592       if (LOOKING_AT (THROW))
2593         {
2594           MATCH ();
2595           SKIP_MATCHING_IF ('(');
2596           SET_FLAG (*flags, F_THROW);
2597         }
2598
2599       if (LOOKING_AT ('='))
2600         {
2601           MATCH ();
2602           if (LOOKING_AT (CINT) && yyival == 0)
2603             {
2604               MATCH ();
2605               SET_FLAG (*flags, F_PURE);
2606             }
2607         }
2608     }
2609
2610   return hash;
2611 }
2612
2613
2614 /* Print position info to stdout.  */
2615
2616 void
2617 print_info ()
2618 {
2619   if (info_position >= 0 && BUFFER_POS () <= info_position)
2620     if (info_cls)
2621       printf ("(\"%s\" \"%s\" \"%s\" %d)\n",
2622               info_cls->name, sym_scope (info_cls),
2623               info_member->name, info_where);
2624 }
2625
2626
2627 /* Parse a member declaration within the class body of CLS.  VIS is
2628    the access specifier for the member (private, protected,
2629    public).  */
2630
2631 void
2632 member (cls, vis)
2633      struct sym *cls;
2634      int vis;
2635 {
2636   char *id = NULL;
2637   int sc = SC_MEMBER;
2638   char *regexp = NULL;
2639   int pos;
2640   int is_constructor;
2641   int anonymous = 0;
2642   int flags = 0;
2643   int class_tag;
2644   int type_seen = 0;
2645   int paren_seen = 0;
2646   unsigned hash = 0;
2647   int tilde = 0;
2648
2649   while (!LOOKING_AT4 (';', '{', '}', YYEOF))
2650     {
2651       switch (LA1)
2652         {
2653         default:
2654           MATCH ();
2655           break;
2656
2657           /* A function or class may follow.  */
2658         case TEMPLATE:
2659           MATCH();
2660           SET_FLAG (flags, F_TEMPLATE);
2661           /* Skip over template argument list */
2662           SKIP_MATCHING_IF ('<');
2663           break;
2664
2665         case EXPLICIT:
2666           SET_FLAG (flags, F_EXPLICIT);
2667           goto typeseen;
2668
2669         case MUTABLE:
2670           SET_FLAG (flags, F_MUTABLE);
2671           goto typeseen;
2672
2673         case T_INLINE:
2674           SET_FLAG (flags, F_INLINE);
2675           goto typeseen;
2676
2677         case VIRTUAL:
2678           SET_FLAG (flags, F_VIRTUAL);
2679           goto typeseen;
2680
2681         case '[':
2682           skip_matching ();
2683           break;
2684
2685         case ENUM:
2686           sc = SC_TYPE;
2687           goto typeseen;
2688
2689         case TYPEDEF:
2690           sc = SC_TYPE;
2691           goto typeseen;
2692
2693         case FRIEND:
2694           sc = SC_FRIEND;
2695           goto typeseen;
2696
2697         case STATIC:
2698           sc = SC_STATIC;
2699           goto typeseen;
2700
2701         case '~':
2702           tilde = 1;
2703           MATCH ();
2704           break;
2705
2706         case IDENT:
2707           /* Remember IDENTS seen so far.  Among these will be the member
2708              name.  */
2709           id = (char *) xrealloc (id, strlen (yytext) + 2);
2710           if (tilde)
2711             {
2712               *id = '~';
2713               strcpy (id + 1, yytext);
2714             }
2715           else
2716             strcpy (id, yytext);
2717           MATCH ();
2718           break;
2719
2720         case OPERATOR:
2721           {
2722             char *s = operator_name (&sc);
2723             id = (char *) xrealloc (id, strlen (s) + 1);
2724             strcpy (id, s);
2725           }
2726           break;
2727
2728         case '(':
2729           /* Most probably the beginning of a parameter list.  */
2730           MATCH ();
2731           paren_seen = 1;
2732
2733           if (id && cls)
2734             {
2735               if (!(is_constructor = streq (id, cls->name)))
2736                 regexp = matching_regexp ();
2737             }
2738           else
2739             is_constructor = 0;
2740
2741           pos = BUFFER_POS ();
2742           hash = parm_list (&flags);
2743
2744           if (is_constructor)
2745             regexp = matching_regexp ();
2746
2747           if (id && cls != NULL)
2748             add_member_decl (cls, id, regexp, pos, hash, 0, sc, vis, flags);
2749
2750           while (!LOOKING_AT3 (';', '{', YYEOF))
2751             MATCH ();
2752
2753           if (LOOKING_AT ('{') && id && cls)
2754             add_member_defn (cls, id, regexp, pos, hash, 0, sc, flags);
2755
2756           free (id);
2757           id = NULL;
2758           sc = SC_MEMBER;
2759           break;
2760
2761         case STRUCT: case UNION: case CLASS:
2762           /* Nested class */
2763           class_tag = LA1;
2764           type_seen = 1;
2765           MATCH ();
2766           anonymous = 1;
2767
2768           /* More than one ident here to allow for MS-DOS specialties
2769              like `_export class' etc.  The last IDENT seen counts
2770              as the class name.  */
2771           while (!LOOKING_AT4 (YYEOF, ';', ':', '{'))
2772             {
2773               if (LOOKING_AT (IDENT))
2774                 anonymous = 0;
2775               MATCH ();
2776             }
2777
2778           if (LOOKING_AT2 (':', '{'))
2779             class_definition (anonymous ? NULL : cls, class_tag, flags, 1);
2780           else
2781             skip_to (';');
2782           break;
2783
2784         case INT:       case CHAR:      case LONG:      case UNSIGNED:
2785         case SIGNED:    case CONST:     case DOUBLE:    case VOID:
2786         case SHORT:     case VOLATILE:  case BOOL:      case WCHAR:
2787         case TYPENAME:
2788         typeseen:
2789           type_seen = 1;
2790           MATCH ();
2791           break;
2792         }
2793     }
2794
2795   if (LOOKING_AT (';'))
2796     {
2797       /* The end of a member variable, a friend declaration or an access
2798          declaration.  We don't want to add friend classes as members.  */
2799       if (id && sc != SC_FRIEND && cls)
2800         {
2801           regexp = matching_regexp ();
2802           pos = BUFFER_POS ();
2803
2804           if (cls != NULL)
2805             {
2806               if (type_seen || !paren_seen)
2807                 add_member_decl (cls, id, regexp, pos, 0, 1, sc, vis, 0);
2808               else
2809                 add_member_decl (cls, id, regexp, pos, hash, 0, sc, vis, 0);
2810             }
2811         }
2812
2813       MATCH ();
2814       print_info ();
2815     }
2816   else if (LOOKING_AT ('{'))
2817     {
2818       /* A named enum.  */
2819       if (sc == SC_TYPE && id && cls)
2820         {
2821           regexp = matching_regexp ();
2822           pos = BUFFER_POS ();
2823
2824           if (cls != NULL)
2825             {
2826               add_member_decl (cls, id, regexp, pos, 0, 1, sc, vis, 0);
2827               add_member_defn (cls, id, regexp, pos, 0, 1, sc, 0);
2828             }
2829         }
2830
2831       skip_matching ();
2832       print_info ();
2833     }
2834
2835   free (id);
2836 }
2837
2838
2839 /* Parse the body of class CLS.  TAG is the tag of the class (struct,
2840    union, class).  */
2841
2842 void
2843 class_body (cls, tag)
2844      struct sym *cls;
2845      int tag;
2846 {
2847   int vis = tag == CLASS ? PRIVATE : PUBLIC;
2848   int temp;
2849
2850   while (!LOOKING_AT2 (YYEOF, '}'))
2851     {
2852       switch (LA1)
2853         {
2854         case PRIVATE: case PROTECTED: case PUBLIC:
2855           temp = LA1;
2856           MATCH ();
2857
2858           if (LOOKING_AT (':'))
2859             {
2860               vis = temp;
2861               MATCH ();
2862             }
2863           else
2864             {
2865               /* Probably conditional compilation for inheritance list.
2866                  We don't known whether there comes more of this.
2867                  This is only a crude fix that works most of the time.  */
2868               do
2869                 {
2870                   MATCH ();
2871                 }
2872               while (LOOKING_AT2 (IDENT, ',')
2873                      || LOOKING_AT3 (PUBLIC, PROTECTED, PRIVATE));
2874             }
2875           break;
2876
2877         case TYPENAME:
2878         case USING:
2879           skip_to (';');
2880           break;
2881
2882           /* Try to synchronize */
2883         case CHAR:      case CLASS:     case CONST:
2884         case DOUBLE:    case ENUM:      case FLOAT:     case INT:
2885         case LONG:      case SHORT:     case SIGNED:    case STRUCT:
2886         case UNION:     case UNSIGNED:  case VOID:      case VOLATILE:
2887         case TYPEDEF:   case STATIC:    case T_INLINE:  case FRIEND:
2888         case VIRTUAL:   case TEMPLATE:  case IDENT:     case '~':
2889         case BOOL:      case WCHAR:     case EXPLICIT:  case MUTABLE:
2890           member (cls, vis);
2891           break;
2892
2893         default:
2894           MATCH ();
2895           break;
2896         }
2897     }
2898 }
2899
2900
2901 /* Parse a qualified identifier.  Current lookahead is IDENT.  A
2902    qualified ident has the form `X<..>::Y<...>::T<...>.  Returns a
2903    symbol for that class.  */
2904
2905 struct sym *
2906 parse_classname ()
2907 {
2908   struct sym *last_class = NULL;
2909
2910   while (LOOKING_AT (IDENT))
2911     {
2912       last_class = add_sym (yytext, last_class);
2913       MATCH ();
2914
2915       if (LOOKING_AT ('<'))
2916         {
2917           skip_matching ();
2918           SET_FLAG (last_class->flags, F_TEMPLATE);
2919         }
2920
2921       if (!LOOKING_AT (DCOLON))
2922         break;
2923
2924       MATCH ();
2925     }
2926
2927   return last_class;
2928 }
2929
2930
2931 /* Parse an operator name.  Add the `static' flag to *SC if an
2932    implicitly static operator has been parsed.  Value is a pointer to
2933    a static buffer holding the constructed operator name string.  */
2934
2935 char *
2936 operator_name (sc)
2937      int *sc;
2938 {
2939   static int id_size = 0;
2940   static char *id = NULL;
2941   char *s;
2942   int len;
2943
2944   MATCH ();
2945
2946   if (LOOKING_AT2 (NEW, DELETE))
2947     {
2948       /* `new' and `delete' are implicitly static.  */
2949       if (*sc != SC_FRIEND)
2950         *sc = SC_STATIC;
2951
2952       s = token_string (LA1);
2953       MATCH ();
2954
2955       len = strlen (s) + 10;
2956       if (len > id_size)
2957         {
2958           int new_size = max (len, 2 * id_size);
2959           id = (char *) xrealloc (id, new_size);
2960           id_size = new_size;
2961         }
2962       strcpy (id, s);
2963
2964       /* Vector new or delete?  */
2965       if (LOOKING_AT ('['))
2966         {
2967           strcat (id, "[");
2968           MATCH ();
2969
2970           if (LOOKING_AT (']'))
2971             {
2972               strcat (id, "]");
2973               MATCH ();
2974             }
2975         }
2976     }
2977   else
2978     {
2979       int tokens_matched = 0;
2980
2981       len = 20;
2982       if (len > id_size)
2983         {
2984           int new_size = max (len, 2 * id_size);
2985           id = (char *) xrealloc (id, new_size);
2986           id_size = new_size;
2987         }
2988       strcpy (id, "operator");
2989
2990       /* Beware access declarations of the form "X::f;" Beware of
2991          `operator () ()'.  Yet another difficulty is found in
2992          GCC 2.95's STL: `operator == __STL_NULL_TMPL_ARGS (...'.  */
2993       while (!(LOOKING_AT ('(') && tokens_matched)
2994              && !LOOKING_AT2 (';', YYEOF))
2995         {
2996           s = token_string (LA1);
2997           len += strlen (s) + 2;
2998           if (len > id_size)
2999             {
3000               int new_size = max (len, 2 * id_size);
3001               id = (char *) xrealloc (id, new_size);
3002               id_size = new_size;
3003             }
3004
3005           if (*s != ')' && *s != ']')
3006             strcat (id, " ");
3007           strcat (id, s);
3008           MATCH ();
3009
3010           /* If this is a simple operator like `+', stop now.  */
3011           if (!isalpha ((unsigned char) *s) && *s != '(' && *s != '[')
3012             break;
3013
3014           ++tokens_matched;
3015         }
3016     }
3017
3018   return id;
3019 }
3020
3021
3022 /* This one consumes the last IDENT of a qualified member name like
3023    `X::Y::z'.  This IDENT is returned in LAST_ID.  Value is the
3024    symbol structure for the ident.  */
3025
3026 struct sym *
3027 parse_qualified_ident_or_type (last_id)
3028      char **last_id;
3029 {
3030   struct sym *cls = NULL;
3031   char *id = NULL;
3032   size_t id_size = 0;
3033   int enter = 0;
3034
3035   while (LOOKING_AT (IDENT))
3036     {
3037       int len = strlen (yytext) + 1;
3038       if (len > id_size)
3039         {
3040           id = (char *) xrealloc (id, len);
3041           id_size = len;
3042         }
3043       strcpy (id, yytext);
3044       *last_id = id;
3045       MATCH ();
3046
3047       SKIP_MATCHING_IF ('<');
3048
3049       if (LOOKING_AT (DCOLON))
3050         {
3051           struct sym *pcn = NULL;
3052           struct link *pna = check_namespace_alias (id);
3053           if (pna)
3054             {
3055               do
3056                 {
3057                   enter_namespace (pna->sym->name);
3058                   enter++;
3059                   pna = pna->next;
3060                 }
3061               while (pna);
3062             }
3063           else if ((pcn = check_namespace (id, current_namespace)))
3064             {
3065               enter_namespace (pcn->name);
3066               enter++;
3067             }
3068           else
3069             cls = add_sym (id, cls);
3070
3071           *last_id = NULL;
3072           free (id);
3073           id = NULL;
3074           id_size = 0;
3075           MATCH ();
3076         }
3077       else
3078         break;
3079     }
3080
3081   while (enter--)
3082     leave_namespace();
3083
3084   return cls;
3085 }
3086
3087
3088 /* This one consumes the last IDENT of a qualified member name like
3089    `X::Y::z'.  This IDENT is returned in LAST_ID.  Value is the
3090    symbol structure for the ident.  */
3091
3092 void
3093 parse_qualified_param_ident_or_type (last_id)
3094      char **last_id;
3095 {
3096   struct sym *cls = NULL;
3097   static char *id = NULL;
3098   static int id_size = 0;
3099
3100   while (LOOKING_AT (IDENT))
3101     {
3102       int len = strlen (yytext) + 1;
3103       if (len > id_size)
3104         {
3105           id = (char *) xrealloc (id, len);
3106           id_size = len;
3107         }
3108       strcpy (id, yytext);
3109       *last_id = id;
3110       MATCH ();
3111
3112       SKIP_MATCHING_IF ('<');
3113
3114       if (LOOKING_AT (DCOLON))
3115         {
3116           cls = add_sym (id, cls);
3117           *last_id = NULL;
3118           MATCH ();
3119         }
3120       else
3121         break;
3122     }
3123 }
3124
3125
3126 /* Parse a class definition.
3127
3128    CONTAINING is the class containing the class being parsed or null.
3129    This may also be null if NESTED != 0 if the containing class is
3130    anonymous.  TAG is the tag of the class (struct, union, class).
3131    NESTED is non-zero if we are parsing a nested class.
3132
3133    Current lookahead is the class name.  */
3134
3135 void
3136 class_definition (containing, tag, flags, nested)
3137      struct sym *containing;
3138      int tag;
3139      int flags;
3140      int nested;
3141 {
3142   struct sym *current;
3143   struct sym *base_class;
3144
3145   /* Set CURRENT to null if no entry has to be made for the class
3146      parsed.  This is the case for certain command line flag
3147      settings.  */
3148   if ((tag != CLASS && !f_structs) || (nested && !f_nested_classes))
3149     current = NULL;
3150   else
3151     {
3152       current = add_sym (yytext, containing);
3153       current->pos = BUFFER_POS ();
3154       current->regexp = matching_regexp ();
3155       current->filename = filename;
3156       current->flags = flags;
3157     }
3158
3159   /* If at ':', base class list follows.  */
3160   if (LOOKING_AT (':'))
3161     {
3162       int done = 0;
3163       MATCH ();
3164
3165       while (!done)
3166         {
3167           switch (LA1)
3168             {
3169             case VIRTUAL: case PUBLIC: case PROTECTED: case PRIVATE:
3170               MATCH ();
3171               break;
3172
3173             case IDENT:
3174               base_class = parse_classname ();
3175               if (base_class && current && base_class != current)
3176                 add_link (base_class, current);
3177               break;
3178
3179               /* The `,' between base classes or the end of the base
3180                  class list.  Add the previously found base class.
3181                  It's done this way to skip over sequences of
3182                  `A::B::C' until we reach the end.
3183
3184                  FIXME: it is now possible to handle `class X : public B::X'
3185                  because we have enough information.  */
3186             case ',':
3187               MATCH ();
3188               break;
3189
3190             default:
3191               /* A syntax error, possibly due to preprocessor constructs
3192                  like
3193
3194                  #ifdef SOMETHING
3195                  class A : public B
3196                  #else
3197                  class A : private B.
3198
3199                  MATCH until we see something like `;' or `{'.  */
3200               while (!LOOKING_AT3 (';', YYEOF, '{'))
3201                 MATCH ();
3202               done = 1;
3203
3204             case '{':
3205               done = 1;
3206               break;
3207             }
3208         }
3209     }
3210
3211   /* Parse the class body if there is one.  */
3212   if (LOOKING_AT ('{'))
3213     {
3214       if (tag != CLASS && !f_structs)
3215         skip_matching ();
3216       else
3217         {
3218           MATCH ();
3219           class_body (current, tag);
3220
3221           if (LOOKING_AT ('}'))
3222             {
3223               MATCH ();
3224               if (LOOKING_AT (';') && !nested)
3225                 MATCH ();
3226             }
3227         }
3228     }
3229 }
3230
3231 /* Add to class *CLS information for the declaration of variable or
3232    type *ID.  If *CLS is null, this means a global declaration.  SC is
3233    the storage class of *ID.  FLAGS is a bit set giving additional
3234    information about the member (see the F_* defines).  */
3235
3236 void
3237 add_declarator (cls, id, flags, sc)
3238      struct sym **cls;
3239      char **id;
3240      int flags, sc;
3241 {
3242   if (LOOKING_AT2 (';', ','))
3243     {
3244       /* The end of a member variable or of an access declaration
3245          `X::f'.  To distinguish between them we have to know whether
3246          type information has been seen.  */
3247       if (*id)
3248         {
3249           char *regexp = matching_regexp ();
3250           int pos = BUFFER_POS ();
3251
3252           if (*cls)
3253             add_member_defn (*cls, *id, regexp, pos, 0, 1, SC_UNKNOWN, flags);
3254           else
3255             add_global_defn (*id, regexp, pos, 0, 1, sc, flags);
3256         }
3257
3258       MATCH ();
3259       print_info ();
3260     }
3261   else if (LOOKING_AT ('{'))
3262     {
3263       if (sc == SC_TYPE && *id)
3264         {
3265           /* A named enumeration.  */
3266           char *regexp = matching_regexp ();
3267           int pos = BUFFER_POS ();
3268           add_global_defn (*id, regexp, pos, 0, 1, sc, flags);
3269         }
3270
3271       skip_matching ();
3272       print_info ();
3273     }
3274
3275   free (*id);
3276   *id = NULL;
3277   *cls = NULL;
3278 }
3279
3280 /* Parse a declaration.  */
3281
3282 void
3283 declaration (flags)
3284      int flags;
3285 {
3286   char *id = NULL;
3287   struct sym *cls = NULL;
3288   char *regexp = NULL;
3289   int pos = 0;
3290   unsigned hash = 0;
3291   int is_constructor;
3292   int sc = 0;
3293
3294   while (!LOOKING_AT3 (';', '{', YYEOF))
3295     {
3296       switch (LA1)
3297         {
3298         default:
3299           MATCH ();
3300           break;
3301
3302         case '[':
3303           skip_matching ();
3304           break;
3305
3306         case ENUM:
3307         case TYPEDEF:
3308           sc = SC_TYPE;
3309           MATCH ();
3310           break;
3311
3312         case STATIC:
3313           sc = SC_STATIC;
3314           MATCH ();
3315           break;
3316
3317         case INT:       case CHAR:      case LONG:      case UNSIGNED:
3318         case SIGNED:    case CONST:     case DOUBLE:    case VOID:
3319         case SHORT:     case VOLATILE:  case BOOL:      case WCHAR:
3320           MATCH ();
3321           break;
3322
3323         case CLASS: case STRUCT: case UNION:
3324           /* This is for the case `STARTWRAP class X : ...' or
3325              `declare (X, Y)\n class A : ...'.  */
3326           if (id)
3327             {
3328               free (id);
3329               return;
3330             }
3331
3332         case '=':
3333           /* Assumed to be the start of an initialization in this
3334              context.  */
3335           skip_initializer ();
3336           break;
3337
3338         case ',':
3339           add_declarator (&cls, &id, flags, sc);
3340           break;
3341
3342         case OPERATOR:
3343           {
3344             char *s = operator_name (&sc);
3345             id = (char *) xrealloc (id, strlen (s) + 1);
3346             strcpy (id, s);
3347           }
3348           break;
3349
3350         case T_INLINE:
3351           SET_FLAG (flags, F_INLINE);
3352           MATCH ();
3353           break;
3354
3355         case '~':
3356           MATCH ();
3357           if (LOOKING_AT (IDENT))
3358             {
3359               id = (char *) xrealloc (id, strlen (yytext) + 2);
3360               *id = '~';
3361               strcpy (id + 1, yytext);
3362               MATCH ();
3363             }
3364           break;
3365
3366         case IDENT:
3367           cls = parse_qualified_ident_or_type (&id);
3368           break;
3369
3370         case '(':
3371           /* Most probably the beginning of a parameter list.  */
3372           if (cls)
3373             {
3374               MATCH ();
3375
3376               if (id && cls)
3377                 {
3378                   if (!(is_constructor = streq (id, cls->name)))
3379                     regexp = matching_regexp ();
3380                 }
3381               else
3382                 is_constructor = 0;
3383
3384               pos = BUFFER_POS ();
3385               hash = parm_list (&flags);
3386
3387               if (is_constructor)
3388                 regexp = matching_regexp ();
3389
3390               if (id && cls)
3391                 add_member_defn (cls, id, regexp, pos, hash, 0,
3392                                  SC_UNKNOWN, flags);
3393             }
3394           else
3395             {
3396               /* This may be a C functions, but also a macro
3397                  call of the form `declare (A, B)' --- such macros
3398                  can be found in some class libraries.  */
3399               MATCH ();
3400
3401               if (id)
3402                 {
3403                   regexp = matching_regexp ();
3404                   pos = BUFFER_POS ();
3405                   hash = parm_list (&flags);
3406                   add_global_decl (id, regexp, pos, hash, 0, sc, flags);
3407                 }
3408
3409               /* This is for the case that the function really is
3410                  a macro with no `;' following it.  If a CLASS directly
3411                  follows, we would miss it otherwise.  */
3412               if (LOOKING_AT3 (CLASS, STRUCT, UNION))
3413                 return;
3414             }
3415
3416           while (!LOOKING_AT3 (';', '{', YYEOF))
3417             MATCH ();
3418
3419           if (!cls && id && LOOKING_AT ('{'))
3420             add_global_defn (id, regexp, pos, hash, 0, sc, flags);
3421
3422           free (id);
3423           id = NULL;
3424           break;
3425         }
3426     }
3427
3428   add_declarator (&cls, &id, flags, sc);
3429 }
3430
3431
3432 /* Parse a list of top-level declarations/definitions.  START_FLAGS
3433    says in which context we are parsing.  If it is F_EXTERNC, we are
3434    parsing in an `extern "C"' block.  Value is 1 if EOF is reached, 0
3435    otherwise.  */
3436
3437 int
3438 globals (start_flags)
3439      int start_flags;
3440 {
3441   int anonymous;
3442   int class_tk;
3443   int flags = start_flags;
3444
3445   for (;;)
3446     {
3447       char *prev_in = in;
3448
3449       switch (LA1)
3450         {
3451         case NAMESPACE:
3452           {
3453             MATCH ();
3454
3455             if (LOOKING_AT (IDENT))
3456               {
3457                 char *namespace_name = xstrdup (yytext);
3458                 MATCH ();
3459
3460                 if (LOOKING_AT ('='))
3461                   {
3462                     struct link *qna = match_qualified_namespace_alias ();
3463                     if (qna)
3464                       register_namespace_alias (namespace_name, qna);
3465
3466                     if (skip_to (';') == ';')
3467                       MATCH ();
3468                   }
3469                 else if (LOOKING_AT ('{'))
3470                   {
3471                     MATCH ();
3472                     enter_namespace (namespace_name);
3473                     globals (0);
3474                     leave_namespace ();
3475                     MATCH_IF ('}');
3476                   }
3477
3478                 free (namespace_name);
3479               }
3480           }
3481           break;
3482
3483         case EXTERN:
3484           MATCH ();
3485           if (LOOKING_AT (CSTRING) && *string_start == 'C'
3486               && *(string_start + 1) == '"')
3487             {
3488               /* This is `extern "C"'.  */
3489               MATCH ();
3490
3491               if (LOOKING_AT ('{'))
3492                 {
3493                   MATCH ();
3494                   globals (F_EXTERNC);
3495                   MATCH_IF ('}');
3496                 }
3497               else
3498                 SET_FLAG (flags, F_EXTERNC);
3499             }
3500           break;
3501
3502         case TEMPLATE:
3503           MATCH ();
3504           SKIP_MATCHING_IF ('<');
3505           SET_FLAG (flags, F_TEMPLATE);
3506           break;
3507
3508         case CLASS: case STRUCT: case UNION:
3509           class_tk = LA1;
3510           MATCH ();
3511           anonymous = 1;
3512
3513           /* More than one ident here to allow for MS-DOS and OS/2
3514              specialties like `far', `_Export' etc.  Some C++ libs
3515              have constructs like `_OS_DLLIMPORT(_OS_CLIENT)' in front
3516              of the class name.  */
3517           while (!LOOKING_AT4 (YYEOF, ';', ':', '{'))
3518             {
3519               if (LOOKING_AT (IDENT))
3520                 anonymous = 0;
3521               MATCH ();
3522             }
3523
3524           /* Don't add anonymous unions.  */
3525           if (LOOKING_AT2 (':', '{') && !anonymous)
3526               class_definition (NULL, class_tk, flags, 0);
3527           else
3528             {
3529               if (skip_to (';') == ';')
3530                 MATCH ();
3531             }
3532
3533           flags = start_flags;
3534           break;
3535
3536         case YYEOF:
3537           return 1;
3538
3539         case '}':
3540           return 0;
3541
3542         default:
3543           declaration (flags);
3544           flags = start_flags;
3545           break;
3546         }
3547
3548       if (prev_in == in)
3549         yyerror ("parse error", NULL);
3550     }
3551 }
3552
3553
3554 /* Parse the current input file.  */
3555
3556 void
3557 yyparse ()
3558 {
3559   while (globals (0) == 0)
3560     MATCH_IF ('}');
3561 }
3562
3563
3564 \f
3565 /***********************************************************************
3566                              Main Program
3567  ***********************************************************************/
3568
3569 /* Add the list of paths PATH_LIST to the current search path for
3570    input files.  */
3571
3572 void
3573 add_search_path (path_list)
3574      char *path_list;
3575 {
3576   while (*path_list)
3577     {
3578       char *start = path_list;
3579       struct search_path *p;
3580
3581       while (*path_list && *path_list != PATH_LIST_SEPARATOR)
3582         ++path_list;
3583
3584       p = (struct search_path *) xmalloc (sizeof *p);
3585       p->path = (char *) xmalloc (path_list - start + 1);
3586       memcpy (p->path, start, path_list - start);
3587       p->path[path_list - start] = '\0';
3588       p->next = NULL;
3589
3590       if (search_path_tail)
3591         {
3592           search_path_tail->next = p;
3593           search_path_tail = p;
3594         }
3595       else
3596         search_path = search_path_tail = p;
3597
3598       while (*path_list == PATH_LIST_SEPARATOR)
3599         ++path_list;
3600     }
3601 }
3602
3603
3604 /* Open FILE and return a file handle for it, or -1 if FILE cannot be
3605    opened.  Try to find FILE in search_path first, then try the
3606    unchanged file name.  */
3607
3608 FILE *
3609 open_file (file)
3610      char *file;
3611 {
3612   FILE *fp = NULL;
3613   static char *buffer;
3614   static int buffer_size;
3615   struct search_path *path;
3616   int flen = strlen (file) + 1; /* +1 for the slash */
3617
3618   filename = xstrdup (file);
3619
3620   for (path = search_path; path && fp == NULL; path = path->next)
3621     {
3622       int len = strlen (path->path) + flen;
3623
3624       if (len + 1 >= buffer_size)
3625         {
3626           buffer_size = max (len + 1, 2 * buffer_size);
3627           buffer = (char *) xrealloc (buffer, buffer_size);
3628         }
3629
3630       strcpy (buffer, path->path);
3631       strcat (buffer, "/");
3632       strcat (buffer, file);
3633       fp = fopen (buffer, "r");
3634     }
3635
3636   /* Try the original file name.  */
3637   if (fp == NULL)
3638      fp = fopen (file, "r");
3639
3640   if (fp == NULL)
3641     yyerror ("cannot open", NULL);
3642
3643   return fp;
3644 }
3645
3646
3647 /* Display usage information and exit program.  */
3648
3649 #define USAGE "\
3650 Usage: ebrowse [options] {files}\n\
3651 \n\
3652   -a, --append                  append output to existing file\n\
3653   -f, --files=FILES             read input file names from FILE\n\
3654   -I, --search-path=LIST        set search path for input files\n\
3655   -m, --min-regexp-length=N     set minimum regexp length to N\n\
3656   -M, --max-regexp-length=N     set maximum regexp length to N\n\
3657   -n, --no-nested-classes       exclude nested classes\n\
3658   -o, --output-file=FILE        set output file name to FILE\n\
3659   -p, --position-info           print info about position in file\n\
3660   -s, --no-structs-or-unions    don't record structs or unions\n\
3661   -v, --verbose                 be verbose\n\
3662   -V, --very-verbose            be very verbose\n\
3663   -x, --no-regexps              don't record regular expressions\n\
3664       --help                    display this help\n\
3665       --version                 display version info\n\
3666 "
3667
3668 void
3669 usage (error)
3670      int error;
3671 {
3672   puts (USAGE);
3673   exit (error ? EXIT_FAILURE : EXIT_SUCCESS);
3674 }
3675
3676
3677 /* Display version and copyright info.  The VERSION macro is set
3678    from the Makefile and contains the Emacs version.  */
3679
3680 #ifndef VERSION
3681 # define VERSION "21"
3682 #endif
3683
3684 void
3685 version ()
3686 {
3687   /* Makes it easier to update automatically. */
3688   char emacs_copyright[] = "Copyright (C) 2011 Free Software Foundation, Inc.";
3689
3690   printf ("ebrowse %s\n", VERSION);
3691   puts (emacs_copyright);
3692   puts ("This program is distributed under the same terms as Emacs.");
3693   exit (EXIT_SUCCESS);
3694 }
3695
3696
3697 /* Parse one input file FILE, adding classes and members to the symbol
3698    table.  */
3699
3700 void
3701 process_file (file)
3702      char *file;
3703 {
3704   FILE *fp;
3705
3706   fp = open_file (file);
3707   if (fp)
3708     {
3709       int nread, nbytes;
3710
3711       /* Give a progress indication if needed.  */
3712       if (f_very_verbose)
3713         {
3714           puts (filename);
3715           fflush (stdout);
3716         }
3717       else if (f_verbose)
3718         {
3719           putchar ('.');
3720           fflush (stdout);
3721         }
3722
3723       /* Read file to inbuffer.  */
3724       for (nread = 0;;)
3725         {
3726           if (nread + READ_CHUNK_SIZE >= inbuffer_size)
3727             {
3728               inbuffer_size = nread + READ_CHUNK_SIZE + 1;
3729               inbuffer = (char *) xrealloc (inbuffer, inbuffer_size);
3730             }
3731
3732           nbytes = fread (inbuffer + nread, 1, READ_CHUNK_SIZE, fp);
3733           if (nbytes <= 0)
3734             break;
3735           nread += nbytes;
3736         }
3737       if (nread < 0)
3738         nread = 0;
3739       inbuffer[nread] = '\0';
3740
3741       /* Reinitialize scanner and parser for the new input file.  */
3742       re_init_scanner ();
3743       re_init_parser ();
3744
3745       /* Parse it and close the file.  */
3746       yyparse ();
3747       fclose (fp);
3748     }
3749 }
3750
3751
3752 /* Read a line from stream FP and return a pointer to a static buffer
3753    containing its contents without the terminating newline.  Value
3754    is null when EOF is reached.  */
3755
3756 char *
3757 read_line (fp)
3758      FILE *fp;
3759 {
3760   static char *buffer;
3761   static int buffer_size;
3762   int i = 0, c;
3763
3764   while ((c = getc (fp)) != EOF && c != '\n')
3765     {
3766       if (i >= buffer_size)
3767         {
3768           buffer_size = max (100, buffer_size * 2);
3769           buffer = (char *) xrealloc (buffer, buffer_size);
3770         }
3771
3772       buffer[i++] = c;
3773     }
3774
3775   if (c == EOF && i == 0)
3776     return NULL;
3777
3778   if (i == buffer_size)
3779     {
3780       buffer_size = max (100, buffer_size * 2);
3781       buffer = (char *) xrealloc (buffer, buffer_size);
3782     }
3783
3784   buffer[i] = '\0';
3785   if (i > 0 && buffer[i - 1] == '\r')
3786     buffer[i - 1] = '\0';
3787   return buffer;
3788 }
3789
3790
3791 /* Main entry point.  */
3792
3793 int
3794 main (argc, argv)
3795      int argc;
3796      char **argv;
3797 {
3798   int i;
3799   int any_inputfiles = 0;
3800   static char *out_filename = DEFAULT_OUTFILE;
3801   static char **input_filenames = NULL;
3802   static int input_filenames_size = 0;
3803   static int n_input_files;
3804
3805   filename = "command line";
3806   yyout = stdout;
3807
3808   while ((i = getopt_long (argc, argv, "af:I:m:M:no:p:svVx",
3809                            options, NULL)) != EOF)
3810     {
3811       switch (i)
3812         {
3813           /* Experimental.  */
3814         case 'p':
3815           info_position = atoi (optarg);
3816           break;
3817
3818         case 'n':
3819           f_nested_classes = 0;
3820           break;
3821
3822         case 'x':
3823           f_regexps = 0;
3824           break;
3825
3826           /* Add the name of a file containing more input files.  */
3827         case 'f':
3828           if (n_input_files == input_filenames_size)
3829             {
3830               input_filenames_size = max (10, 2 * input_filenames_size);
3831               input_filenames = (char **) xrealloc ((void *)input_filenames,
3832                                                     input_filenames_size);
3833             }
3834           input_filenames[n_input_files++] = xstrdup (optarg);
3835           break;
3836
3837           /* Append new output to output file instead of truncating it.  */
3838         case 'a':
3839           f_append = 1;
3840           break;
3841
3842           /* Include structs in the output */
3843         case 's':
3844           f_structs = 0;
3845           break;
3846
3847           /* Be verbose (give a progress indication).  */
3848         case 'v':
3849           f_verbose = 1;
3850           break;
3851
3852           /* Be very verbose (print file names as they are processed).  */
3853         case 'V':
3854           f_verbose = 1;
3855           f_very_verbose = 1;
3856           break;
3857
3858           /* Change the name of the output file.  */
3859         case 'o':
3860           out_filename = optarg;
3861           break;
3862
3863           /* Set minimum length for regular expression strings
3864              when recorded in the output file.  */
3865         case 'm':
3866           min_regexp = atoi (optarg);
3867           break;
3868
3869           /* Set maximum length for regular expression strings
3870              when recorded in the output file.  */
3871         case 'M':
3872           max_regexp = atoi (optarg);
3873           break;
3874
3875           /* Add to search path.  */
3876         case 'I':
3877           add_search_path (optarg);
3878           break;
3879
3880           /* Display help */
3881         case -2:
3882           usage (0);
3883           break;
3884
3885         case -3:
3886           version ();
3887           break;
3888         }
3889     }
3890
3891   /* Call init_scanner after command line flags have been processed to be
3892      able to add keywords depending on command line (not yet
3893      implemented).  */
3894   init_scanner ();
3895   init_sym ();
3896
3897   /* Open output file */
3898   if (*out_filename)
3899     {
3900       if (f_append)
3901         {
3902           /* Check that the file to append to exists, and is not
3903              empty.  More specifically, it should be a valid file
3904              produced by a previous run of ebrowse, but that's too
3905              difficult to check.  */
3906           FILE *fp;
3907           int rc;
3908
3909           fp = fopen (out_filename, "r");
3910           if (fp == NULL)
3911             {
3912               yyerror ("file `%s' must exist for --append", out_filename);
3913               exit (EXIT_FAILURE);
3914             }
3915
3916           rc = fseek (fp, 0, SEEK_END);
3917           if (rc == -1)
3918             {
3919               yyerror ("error seeking in file `%s'", out_filename);
3920               exit (EXIT_FAILURE);
3921             }
3922
3923           rc = ftell (fp);
3924           if (rc == -1)
3925             {
3926               yyerror ("error getting size of file `%s'", out_filename);
3927               exit (EXIT_FAILURE);
3928             }
3929
3930           else if (rc == 0)
3931             {
3932               yyerror ("file `%s' is empty", out_filename);
3933               /* It may be ok to use an empty file for appending.
3934                  exit (EXIT_FAILURE); */
3935             }
3936
3937           fclose (fp);
3938         }
3939
3940       yyout = fopen (out_filename, f_append ? "a" : "w");
3941       if (yyout == NULL)
3942         {
3943           yyerror ("cannot open output file `%s'", out_filename);
3944           exit (EXIT_FAILURE);
3945         }
3946     }
3947
3948   /* Process input files specified on the command line.  */
3949   while (optind < argc)
3950     {
3951       process_file (argv[optind++]);
3952       any_inputfiles = 1;
3953     }
3954
3955   /* Process files given on stdin if no files specified.  */
3956   if (!any_inputfiles && n_input_files == 0)
3957     {
3958       char *file;
3959       while ((file = read_line (stdin)) != NULL)
3960         process_file (file);
3961     }
3962   else
3963     {
3964       /* Process files from `--files=FILE'.  Every line in FILE names
3965          one input file to process.  */
3966       for (i = 0; i < n_input_files; ++i)
3967         {
3968           FILE *fp = fopen (input_filenames[i], "r");
3969
3970           if (fp == NULL)
3971             yyerror ("cannot open input file `%s'", input_filenames[i]);
3972           else
3973             {
3974               char *file;
3975               while ((file = read_line (fp)) != NULL)
3976                 process_file (file);
3977               fclose (fp);
3978             }
3979         }
3980     }
3981
3982   /* Write output file.  */
3983   dump_roots (yyout);
3984
3985   /* Close output file.  */
3986   if (yyout != stdout)
3987     fclose (yyout);
3988
3989   return EXIT_SUCCESS;
3990 }
3991
3992 /* ebrowse.c ends here */