gcc/cp/lex.c

   1 /* Separate lexical analyzer for GNU C++.
   2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001 Free Software Foundation, Inc.
   4    Hacked by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* This file is the lexical analyzer for GNU C++.  */
  25
  26 /* Cause the `yydebug' variable to be defined.  */
  27 #define YYDEBUG 1
  28
  29 #include "config.h"
  30 #include "system.h"
  31 #include "input.h"
  32 #include "tree.h"
  33 #include "cp-tree.h"
  34 #include "cpplib.h"
  35 #include "c-lex.h"
  36 #include "lex.h"
  37 #include "parse.h"
  38 #include "flags.h"
  39 #include "c-pragma.h"
  40 #include "toplev.h"
  41 #include "output.h"
  42 #include "ggc.h"
  43 #include "tm_p.h"
  44 #include "timevar.h"
  45 #include "diagnostic.h"
  46
  47 #ifdef MULTIBYTE_CHARS
  48 #include "mbchar.h"
  49 #include <locale.h>
  50 #endif
  51
  52 extern void yyprint PARAMS ((FILE *, int, YYSTYPE));
  53
  54 static int interface_strcmp PARAMS ((const char *));
  55 static int *init_cpp_parse PARAMS ((void));
  56 static void init_cp_pragma PARAMS ((void));
  57
  58 static tree parse_strconst_pragma PARAMS ((const char *, int));
  59 static void handle_pragma_vtable PARAMS ((cpp_reader *));
  60 static void handle_pragma_unit PARAMS ((cpp_reader *));
  61 static void handle_pragma_interface PARAMS ((cpp_reader *));
  62 static void handle_pragma_implementation PARAMS ((cpp_reader *));
  63 static void handle_pragma_java_exceptions PARAMS ((cpp_reader *));
  64
  65 #ifdef GATHER_STATISTICS
  66 #ifdef REDUCE_LENGTH
  67 static int reduce_cmp PARAMS ((int *, int *));
  68 static int token_cmp PARAMS ((int *, int *));
  69 #endif
  70 #endif
  71 static int is_global PARAMS ((tree));
  72 static void init_operators PARAMS ((void));
  73 static void copy_lang_type PARAMS ((tree));
  74
  75 /* A constraint that can be tested at compile time.  */
  76 #ifdef __STDC__
  77 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
  78 #else
  79 #define CONSTRAINT(name, expr) extern int constraint_/**/name [(expr) ? 1 : -1]
  80 #endif
  81
  82 #include "cpplib.h"
  83
  84 extern int yychar;              /*  the lookahead symbol                */
  85 extern YYSTYPE yylval;          /*  the semantic value of the           */
  86                                 /*  lookahead symbol                    */
  87
  88 /* These flags are used by c-lex.c.  In C++, they're always off and on,
  89    respectively.  */
  90 int warn_traditional = 0;
  91 int flag_digraphs = 1;
  92
  93 /* the declaration found for the last IDENTIFIER token read in.
  94    yylex must look this up to detect typedefs, which get token type TYPENAME,
  95    so it is left around in case the identifier is not a typedef but is
  96    used in a context which makes it a reference to a variable.  */
  97 tree lastiddecl;
  98
  99 /* Array for holding counts of the numbers of tokens seen.  */
 100 extern int *token_count;
 101
 102 /* Functions and data structures for #pragma interface.
 103
 104    `#pragma implementation' means that the main file being compiled
 105    is considered to implement (provide) the classes that appear in
 106    its main body.  I.e., if this is file "foo.cc", and class `bar'
 107    is defined in "foo.cc", then we say that "foo.cc implements bar".
 108
 109    All main input files "implement" themselves automagically.
 110
 111    `#pragma interface' means that unless this file (of the form "foo.h"
 112    is not presently being included by file "foo.cc", the
 113    CLASSTYPE_INTERFACE_ONLY bit gets set.  The effect is that none
 114    of the vtables nor any of the inline functions defined in foo.h
 115    will ever be output.
 116
 117    There are cases when we want to link files such as "defs.h" and
 118    "main.cc".  In this case, we give "defs.h" a `#pragma interface',
 119    and "main.cc" has `#pragma implementation "defs.h"'.  */
 120
 121 struct impl_files
 122 {
 123   const char *filename;
 124   struct impl_files *next;
 125 };
 126
 127 static struct impl_files *impl_file_chain;
 128
 129 \f
 130 /* Return something to represent absolute declarators containing a *.
 131    TARGET is the absolute declarator that the * contains.
 132    CV_QUALIFIERS is a list of modifiers such as const or volatile
 133    to apply to the pointer type, represented as identifiers.
 134
 135    We return an INDIRECT_REF whose "contents" are TARGET
 136    and whose type is the modifier list.  */
 137
 138 tree
 139 make_pointer_declarator (cv_qualifiers, target)
 140      tree cv_qualifiers, target;
 141 {
 142   if (target && TREE_CODE (target) == IDENTIFIER_NODE
 143       && ANON_AGGRNAME_P (target))
 144     error ("type name expected before `*'");
 145   target = build_nt (INDIRECT_REF, target);
 146   TREE_TYPE (target) = cv_qualifiers;
 147   return target;
 148 }
 149
 150 /* Return something to represent absolute declarators containing a &.
 151    TARGET is the absolute declarator that the & contains.
 152    CV_QUALIFIERS is a list of modifiers such as const or volatile
 153    to apply to the reference type, represented as identifiers.
 154
 155    We return an ADDR_EXPR whose "contents" are TARGET
 156    and whose type is the modifier list.  */
 157
 158 tree
 159 make_reference_declarator (cv_qualifiers, target)
 160      tree cv_qualifiers, target;
 161 {
 162   if (target)
 163     {
 164       if (TREE_CODE (target) == ADDR_EXPR)
 165         {
 166           error ("cannot declare references to references");
 167           return target;
 168         }
 169       if (TREE_CODE (target) == INDIRECT_REF)
 170         {
 171           error ("cannot declare pointers to references");
 172           return target;
 173         }
 174       if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
 175           error ("type name expected before `&'");
 176     }
 177   target = build_nt (ADDR_EXPR, target);
 178   TREE_TYPE (target) = cv_qualifiers;
 179   return target;
 180 }
 181
 182 tree
 183 make_call_declarator (target, parms, cv_qualifiers, exception_specification)
 184      tree target, parms, cv_qualifiers, exception_specification;
 185 {
 186   target = build_nt (CALL_EXPR, target,
 187                      tree_cons (parms, cv_qualifiers, NULL_TREE),
 188                      /* The third operand is really RTL.  We
 189                         shouldn't put anything there.  */
 190                      NULL_TREE);
 191   CALL_DECLARATOR_EXCEPTION_SPEC (target) = exception_specification;
 192   return target;
 193 }
 194
 195 void
 196 set_quals_and_spec (call_declarator, cv_qualifiers, exception_specification)
 197      tree call_declarator, cv_qualifiers, exception_specification;
 198 {
 199   CALL_DECLARATOR_QUALS (call_declarator) = cv_qualifiers;
 200   CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator) = exception_specification;
 201 }
 202 \f
 203 int interface_only;             /* whether or not current file is only for
 204                                    interface definitions.  */
 205 int interface_unknown;          /* whether or not we know this class
 206                                    to behave according to #pragma interface.  */
 207
 208 \f
 209 /* Post-switch processing.  */
 210 void
 211 cxx_post_options ()
 212 {
 213   c_common_post_options ();
 214 }
 215
 216 /* Initialization before switch parsing.  */
 217 void
 218 cxx_init_options ()
 219 {
 220   c_common_init_options (clk_cplusplus);
 221
 222   /* Default exceptions on.  */
 223   flag_exceptions = 1;
 224   /* By default wrap lines at 80 characters.  Is getenv ("COLUMNS")
 225      preferable?  */
 226   diagnostic_line_cutoff (global_dc) = 80;
 227   /* By default, emit location information once for every
 228      diagnostic message.  */
 229   diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 230 }
 231
 232 void
 233 cxx_finish ()
 234 {
 235   c_common_finish ();
 236 }
 237
 238 static int *
 239 init_cpp_parse ()
 240 {
 241 #ifdef GATHER_STATISTICS
 242 #ifdef REDUCE_LENGTH
 243   reduce_count = (int *) xcalloc (sizeof (int), (REDUCE_LENGTH + 1));
 244   reduce_count += 1;
 245   token_count = (int *) xcalloc (sizeof (int), (TOKEN_LENGTH + 1));
 246   token_count += 1;
 247 #endif
 248 #endif
 249   return token_count;
 250 }
 251
 252 /* A mapping from tree codes to operator name information.  */
 253 operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE];
 254 /* Similar, but for assignment operators.  */
 255 operator_name_info_t assignment_operator_name_info[(int) LAST_CPLUS_TREE_CODE];
 256
 257 /* Initialize data structures that keep track of operator names.  */
 258
 259 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
 260  CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
 261 #include "operators.def"
 262 #undef DEF_OPERATOR
 263
 264 static void
 265 init_operators ()
 266 {
 267   tree identifier;
 268   char buffer[256];
 269   struct operator_name_info_t *oni;
 270
 271 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)                   \
 272   sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
 273   identifier = get_identifier (buffer);                                     \
 274   IDENTIFIER_OPNAME_P (identifier) = 1;                                     \
 275                                                                             \
 276   oni = (ASSN_P                                                             \
 277          ? &assignment_operator_name_info[(int) CODE]                       \
 278          : &operator_name_info[(int) CODE]);                                \
 279   oni->identifier = identifier;                                             \
 280   oni->name = NAME;                                                         \
 281   oni->mangled_name = MANGLING;
 282
 283 #include "operators.def"
 284 #undef DEF_OPERATOR
 285
 286   operator_name_info[(int) ERROR_MARK].identifier
 287     = get_identifier ("<invalid operator>");
 288
 289   /* Handle some special cases.  These operators are not defined in
 290      the language, but can be produced internally.  We may need them
 291      for error-reporting.  (Eventually, we should ensure that this
 292      does not happen.  Error messages involving these operators will
 293      be confusing to users.)  */
 294
 295   operator_name_info [(int) INIT_EXPR].name
 296     = operator_name_info [(int) MODIFY_EXPR].name;
 297   operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
 298   operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
 299   operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
 300   operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
 301   operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
 302   operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
 303   operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
 304   operator_name_info [(int) ABS_EXPR].name = "abs";
 305   operator_name_info [(int) FFS_EXPR].name = "ffs";
 306   operator_name_info [(int) BIT_ANDTC_EXPR].name = "&~";
 307   operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
 308   operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
 309   operator_name_info [(int) IN_EXPR].name = "in";
 310   operator_name_info [(int) RANGE_EXPR].name = "...";
 311   operator_name_info [(int) CONVERT_EXPR].name = "+";
 312
 313   assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
 314     = "(exact /=)";
 315   assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
 316     = "(ceiling /=)";
 317   assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
 318     = "(floor /=)";
 319   assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
 320     = "(round /=)";
 321   assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
 322     = "(ceiling %=)";
 323   assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
 324     = "(floor %=)";
 325   assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
 326     = "(round %=)";
 327 }
 328
 329 /* The reserved keyword table.  */
 330 struct resword
 331 {
 332   const char *const word;
 333   const ENUM_BITFIELD(rid) rid : 16;
 334   const unsigned int disable   : 16;
 335 };
 336
 337 /* Disable mask.  Keywords are disabled if (reswords[i].disable & mask) is
 338    _true_.  */
 339 #define D_EXT           0x01    /* GCC extension */
 340 #define D_ASM           0x02    /* in C99, but has a switch to turn it off */
 341 #define D_OPNAME        0x04    /* operator names */
 342
 343 CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
 344
 345 static const struct resword reswords[] =
 346 {
 347   { "_Complex",         RID_COMPLEX,    0 },
 348   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
 349   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
 350   { "__alignof",        RID_ALIGNOF,    0 },
 351   { "__alignof__",      RID_ALIGNOF,    0 },
 352   { "__asm",            RID_ASM,        0 },
 353   { "__asm__",          RID_ASM,        0 },
 354   { "__attribute",      RID_ATTRIBUTE,  0 },
 355   { "__attribute__",    RID_ATTRIBUTE,  0 },
 356   { "__builtin_va_arg", RID_VA_ARG,     0 },
 357   { "__complex",        RID_COMPLEX,    0 },
 358   { "__complex__",      RID_COMPLEX,    0 },
 359   { "__const",          RID_CONST,      0 },
 360   { "__const__",        RID_CONST,      0 },
 361   { "__extension__",    RID_EXTENSION,  0 },
 362   { "__func__",         RID_C99_FUNCTION_NAME,  0 },
 363   { "__imag",           RID_IMAGPART,   0 },
 364   { "__imag__",         RID_IMAGPART,   0 },
 365   { "__inline",         RID_INLINE,     0 },
 366   { "__inline__",       RID_INLINE,     0 },
 367   { "__label__",        RID_LABEL,      0 },
 368   { "__null",           RID_NULL,       0 },
 369   { "__real",           RID_REALPART,   0 },
 370   { "__real__",         RID_REALPART,   0 },
 371   { "__restrict",       RID_RESTRICT,   0 },
 372   { "__restrict__",     RID_RESTRICT,   0 },
 373   { "__signed",         RID_SIGNED,     0 },
 374   { "__signed__",       RID_SIGNED,     0 },
 375   { "__typeof",         RID_TYPEOF,     0 },
 376   { "__typeof__",       RID_TYPEOF,     0 },
 377   { "__volatile",       RID_VOLATILE,   0 },
 378   { "__volatile__",     RID_VOLATILE,   0 },
 379   { "asm",              RID_ASM,        D_ASM },
 380   { "and",              RID_AND,        D_OPNAME },
 381   { "and_eq",           RID_AND_EQ,     D_OPNAME },
 382   { "auto",             RID_AUTO,       0 },
 383   { "bitand",           RID_BITAND,     D_OPNAME },
 384   { "bitor",            RID_BITOR,      D_OPNAME },
 385   { "bool",             RID_BOOL,       0 },
 386   { "break",            RID_BREAK,      0 },
 387   { "case",             RID_CASE,       0 },
 388   { "catch",            RID_CATCH,      0 },
 389   { "char",             RID_CHAR,       0 },
 390   { "class",            RID_CLASS,      0 },
 391   { "compl",            RID_COMPL,      D_OPNAME },
 392   { "const",            RID_CONST,      0 },
 393   { "const_cast",       RID_CONSTCAST,  0 },
 394   { "continue",         RID_CONTINUE,   0 },
 395   { "default",          RID_DEFAULT,    0 },
 396   { "delete",           RID_DELETE,     0 },
 397   { "do",               RID_DO,         0 },
 398   { "double",           RID_DOUBLE,     0 },
 399   { "dynamic_cast",     RID_DYNCAST,    0 },
 400   { "else",             RID_ELSE,       0 },
 401   { "enum",             RID_ENUM,       0 },
 402   { "explicit",         RID_EXPLICIT,   0 },
 403   { "export",           RID_EXPORT,     0 },
 404   { "extern",           RID_EXTERN,     0 },
 405   { "false",            RID_FALSE,      0 },
 406   { "float",            RID_FLOAT,      0 },
 407   { "for",              RID_FOR,        0 },
 408   { "friend",           RID_FRIEND,     0 },
 409   { "goto",             RID_GOTO,       0 },
 410   { "if",               RID_IF,         0 },
 411   { "inline",           RID_INLINE,     0 },
 412   { "int",              RID_INT,        0 },
 413   { "long",             RID_LONG,       0 },
 414   { "mutable",          RID_MUTABLE,    0 },
 415   { "namespace",        RID_NAMESPACE,  0 },
 416   { "new",              RID_NEW,        0 },
 417   { "not",              RID_NOT,        D_OPNAME },
 418   { "not_eq",           RID_NOT_EQ,     D_OPNAME },
 419   { "operator",         RID_OPERATOR,   0 },
 420   { "or",               RID_OR,         D_OPNAME },
 421   { "or_eq",            RID_OR_EQ,      D_OPNAME },
 422   { "private",          RID_PRIVATE,    0 },
 423   { "protected",        RID_PROTECTED,  0 },
 424   { "public",           RID_PUBLIC,     0 },
 425   { "register",         RID_REGISTER,   0 },
 426   { "reinterpret_cast", RID_REINTCAST,  0 },
 427   { "return",           RID_RETURN,     0 },
 428   { "short",            RID_SHORT,      0 },
 429   { "signed",           RID_SIGNED,     0 },
 430   { "sizeof",           RID_SIZEOF,     0 },
 431   { "static",           RID_STATIC,     0 },
 432   { "static_cast",      RID_STATCAST,   0 },
 433   { "struct",           RID_STRUCT,     0 },
 434   { "switch",           RID_SWITCH,     0 },
 435   { "template",         RID_TEMPLATE,   0 },
 436   { "this",             RID_THIS,       0 },
 437   { "throw",            RID_THROW,      0 },
 438   { "true",             RID_TRUE,       0 },
 439   { "try",              RID_TRY,        0 },
 440   { "typedef",          RID_TYPEDEF,    0 },
 441   { "typename",         RID_TYPENAME,   0 },
 442   { "typeid",           RID_TYPEID,     0 },
 443   { "typeof",           RID_TYPEOF,     D_ASM|D_EXT },
 444   { "union",            RID_UNION,      0 },
 445   { "unsigned",         RID_UNSIGNED,   0 },
 446   { "using",            RID_USING,      0 },
 447   { "virtual",          RID_VIRTUAL,    0 },
 448   { "void",             RID_VOID,       0 },
 449   { "volatile",         RID_VOLATILE,   0 },
 450   { "wchar_t",          RID_WCHAR,      0 },
 451   { "while",            RID_WHILE,      0 },
 452   { "xor",              RID_XOR,        D_OPNAME },
 453   { "xor_eq",           RID_XOR_EQ,     D_OPNAME },
 454
 455 };
 456
 457 /* Table mapping from RID_* constants to yacc token numbers.
 458    Unfortunately we have to have entries for all the keywords in all
 459    three languages.  */
 460 const short rid_to_yy[RID_MAX] =
 461 {
 462   /* RID_STATIC */      SCSPEC,
 463   /* RID_UNSIGNED */    TYPESPEC,
 464   /* RID_LONG */        TYPESPEC,
 465   /* RID_CONST */       CV_QUALIFIER,
 466   /* RID_EXTERN */      SCSPEC,
 467   /* RID_REGISTER */    SCSPEC,
 468   /* RID_TYPEDEF */     SCSPEC,
 469   /* RID_SHORT */       TYPESPEC,
 470   /* RID_INLINE */      SCSPEC,
 471   /* RID_VOLATILE */    CV_QUALIFIER,
 472   /* RID_SIGNED */      TYPESPEC,
 473   /* RID_AUTO */        SCSPEC,
 474   /* RID_RESTRICT */    CV_QUALIFIER,
 475
 476   /* C extensions.  Bounded pointers are not yet in C++ */
 477   /* RID_BOUNDED */     0,
 478   /* RID_UNBOUNDED */   0,
 479   /* RID_COMPLEX */     TYPESPEC,
 480
 481   /* C++ */
 482   /* RID_FRIEND */      SCSPEC,
 483   /* RID_VIRTUAL */     SCSPEC,
 484   /* RID_EXPLICIT */    SCSPEC,
 485   /* RID_EXPORT */      EXPORT,
 486   /* RID_MUTABLE */     SCSPEC,
 487
 488   /* ObjC */
 489   /* RID_IN */          0,
 490   /* RID_OUT */         0,
 491   /* RID_INOUT */       0,
 492   /* RID_BYCOPY */      0,
 493   /* RID_BYREF */       0,
 494   /* RID_ONEWAY */      0,
 495
 496   /* C */
 497   /* RID_INT */         TYPESPEC,
 498   /* RID_CHAR */        TYPESPEC,
 499   /* RID_FLOAT */       TYPESPEC,
 500   /* RID_DOUBLE */      TYPESPEC,
 501   /* RID_VOID */        TYPESPEC,
 502   /* RID_ENUM */        ENUM,
 503   /* RID_STRUCT */      AGGR,
 504   /* RID_UNION */       AGGR,
 505   /* RID_IF */          IF,
 506   /* RID_ELSE */        ELSE,
 507   /* RID_WHILE */       WHILE,
 508   /* RID_DO */          DO,
 509   /* RID_FOR */         FOR,
 510   /* RID_SWITCH */      SWITCH,
 511   /* RID_CASE */        CASE,
 512   /* RID_DEFAULT */     DEFAULT,
 513   /* RID_BREAK */       BREAK,
 514   /* RID_CONTINUE */    CONTINUE,
 515   /* RID_RETURN */      RETURN_KEYWORD,
 516   /* RID_GOTO */        GOTO,
 517   /* RID_SIZEOF */      SIZEOF,
 518
 519   /* C extensions */
 520   /* RID_ASM */         ASM_KEYWORD,
 521   /* RID_TYPEOF */      TYPEOF,
 522   /* RID_ALIGNOF */     ALIGNOF,
 523   /* RID_ATTRIBUTE */   ATTRIBUTE,
 524   /* RID_VA_ARG */      VA_ARG,
 525   /* RID_EXTENSION */   EXTENSION,
 526   /* RID_IMAGPART */    IMAGPART,
 527   /* RID_REALPART */    REALPART,
 528   /* RID_LABEL */       LABEL,
 529   /* RID_PTRBASE */     0,
 530   /* RID_PTREXTENT */   0,
 531   /* RID_PTRVALUE */    0,
 532   /* RID_CHOOSE_EXPR */ 0,
 533   /* RID_TYPES_COMPATIBLE_P */ 0,
 534
 535   /* RID_FUNCTION_NAME */       VAR_FUNC_NAME,
 536   /* RID_PRETTY_FUNCTION_NAME */ VAR_FUNC_NAME,
 537   /* RID_c99_FUNCTION_NAME */   VAR_FUNC_NAME,
 538
 539   /* C++ */
 540   /* RID_BOOL */        TYPESPEC,
 541   /* RID_WCHAR */       TYPESPEC,
 542   /* RID_CLASS */       AGGR,
 543   /* RID_PUBLIC */      VISSPEC,
 544   /* RID_PRIVATE */     VISSPEC,
 545   /* RID_PROTECTED */   VISSPEC,
 546   /* RID_TEMPLATE */    TEMPLATE,
 547   /* RID_NULL */        CONSTANT,
 548   /* RID_CATCH */       CATCH,
 549   /* RID_DELETE */      DELETE,
 550   /* RID_FALSE */       CXX_FALSE,
 551   /* RID_NAMESPACE */   NAMESPACE,
 552   /* RID_NEW */         NEW,
 553   /* RID_OPERATOR */    OPERATOR,
 554   /* RID_THIS */        THIS,
 555   /* RID_THROW */       THROW,
 556   /* RID_TRUE */        CXX_TRUE,
 557   /* RID_TRY */         TRY,
 558   /* RID_TYPENAME */    TYPENAME_KEYWORD,
 559   /* RID_TYPEID */      TYPEID,
 560   /* RID_USING */       USING,
 561
 562   /* casts */
 563   /* RID_CONSTCAST */   CONST_CAST,
 564   /* RID_DYNCAST */     DYNAMIC_CAST,
 565   /* RID_REINTCAST */   REINTERPRET_CAST,
 566   /* RID_STATCAST */    STATIC_CAST,
 567
 568   /* alternate spellings */
 569   /* RID_AND */         ANDAND,
 570   /* RID_AND_EQ */      ASSIGN,
 571   /* RID_NOT */         '!',
 572   /* RID_NOT_EQ */      EQCOMPARE,
 573   /* RID_OR */          OROR,
 574   /* RID_OR_EQ */       ASSIGN,
 575   /* RID_XOR */         '^',
 576   /* RID_XOR_EQ */      ASSIGN,
 577   /* RID_BITAND */      '&',
 578   /* RID_BITOR */       '|',
 579   /* RID_COMPL */       '~',
 580
 581   /* Objective C */
 582   /* RID_ID */                  0,
 583   /* RID_AT_ENCODE */           0,
 584   /* RID_AT_END */              0,
 585   /* RID_AT_CLASS */            0,
 586   /* RID_AT_ALIAS */            0,
 587   /* RID_AT_DEFS */             0,
 588   /* RID_AT_PRIVATE */          0,
 589   /* RID_AT_PROTECTED */        0,
 590   /* RID_AT_PUBLIC */           0,
 591   /* RID_AT_PROTOCOL */         0,
 592   /* RID_AT_SELECTOR */         0,
 593   /* RID_AT_INTERFACE */        0,
 594   /* RID_AT_IMPLEMENTATION */   0
 595 };
 596
 597 void
 598 init_reswords ()
 599 {
 600   unsigned int i;
 601   tree id;
 602   int mask = ((flag_operator_names ? 0 : D_OPNAME)
 603               | (flag_no_asm ? D_ASM : 0)
 604               | (flag_no_gnu_keywords ? D_EXT : 0));
 605
 606   /* It is not necessary to register ridpointers as a GC root, because
 607      all the trees it points to are permanently interned in the
 608      get_identifier hash anyway.  */
 609   ridpointers = (tree *) xcalloc ((int) RID_MAX, sizeof (tree));
 610   for (i = 0; i < ARRAY_SIZE (reswords); i++)
 611     {
 612       id = get_identifier (reswords[i].word);
 613       C_RID_CODE (id) = reswords[i].rid;
 614       ridpointers [(int) reswords[i].rid] = id;
 615       if (! (reswords[i].disable & mask))
 616         C_IS_RESERVED_WORD (id) = 1;
 617     }
 618 }
 619
 620 static void
 621 init_cp_pragma ()
 622 {
 623   cpp_register_pragma (parse_in, 0, "vtable", handle_pragma_vtable);
 624   cpp_register_pragma (parse_in, 0, "unit", handle_pragma_unit);
 625
 626   cpp_register_pragma (parse_in, 0, "interface", handle_pragma_interface);
 627   cpp_register_pragma (parse_in, 0, "implementation",
 628                        handle_pragma_implementation);
 629
 630   cpp_register_pragma (parse_in, "GCC", "interface", handle_pragma_interface);
 631   cpp_register_pragma (parse_in, "GCC", "implementation",
 632                        handle_pragma_implementation);
 633   cpp_register_pragma (parse_in, "GCC", "java_exceptions",
 634                        handle_pragma_java_exceptions);
 635 }
 636
 637 /* Initialize the C++ front end.  This function is very sensitive to
 638    the exact order that things are done here.  It would be nice if the
 639    initialization done by this routine were moved to its subroutines,
 640    and the ordering dependencies clarified and reduced.  */
 641 const char *
 642 cxx_init (filename)
 643      const char *filename;
 644 {
 645   input_filename = "<internal>";
 646
 647   init_reswords ();
 648   init_spew ();
 649   init_tree ();
 650   init_cp_semantics ();
 651
 652   lang_unsafe_for_reeval = c_unsafe_for_reeval;
 653
 654   init_operators ();
 655   init_method ();
 656   init_error ();
 657
 658   current_function_decl = NULL;
 659
 660   class_type_node = build_int_2 (class_type, 0);
 661   TREE_TYPE (class_type_node) = class_type_node;
 662   ridpointers[(int) RID_CLASS] = class_type_node;
 663
 664   record_type_node = build_int_2 (record_type, 0);
 665   TREE_TYPE (record_type_node) = record_type_node;
 666   ridpointers[(int) RID_STRUCT] = record_type_node;
 667
 668   union_type_node = build_int_2 (union_type, 0);
 669   TREE_TYPE (union_type_node) = union_type_node;
 670   ridpointers[(int) RID_UNION] = union_type_node;
 671
 672   enum_type_node = build_int_2 (enum_type, 0);
 673   TREE_TYPE (enum_type_node) = enum_type_node;
 674   ridpointers[(int) RID_ENUM] = enum_type_node;
 675
 676   cxx_init_decl_processing ();
 677
 678   /* Create the built-in __null node.  */
 679   null_node = build_int_2 (0, 0);
 680   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
 681   ridpointers[RID_NULL] = null_node;
 682
 683   token_count = init_cpp_parse ();
 684   interface_unknown = 1;
 685
 686   filename = c_common_init (filename);
 687   if (filename == NULL)
 688     return NULL;
 689
 690   init_cp_pragma ();
 691
 692   init_repo (filename);
 693
 694   return filename;
 695 }
 696 \f
 697 inline void
 698 yyprint (file, yychar, yylval)
 699      FILE *file;
 700      int yychar;
 701      YYSTYPE yylval;
 702 {
 703   tree t;
 704   switch (yychar)
 705     {
 706     case IDENTIFIER:
 707     case TYPENAME:
 708     case TYPESPEC:
 709     case PTYPENAME:
 710     case PFUNCNAME:
 711     case IDENTIFIER_DEFN:
 712     case TYPENAME_DEFN:
 713     case PTYPENAME_DEFN:
 714     case SCSPEC:
 715     case PRE_PARSED_CLASS_DECL:
 716       t = yylval.ttype;
 717       if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL)
 718         {
 719           fprintf (file, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t)));
 720           break;
 721         }
 722       my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
 723       if (IDENTIFIER_POINTER (t))
 724           fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
 725       break;
 726
 727     case AGGR:
 728       if (yylval.ttype == class_type_node)
 729         fprintf (file, " `class'");
 730       else if (yylval.ttype == record_type_node)
 731         fprintf (file, " `struct'");
 732       else if (yylval.ttype == union_type_node)
 733         fprintf (file, " `union'");
 734       else if (yylval.ttype == enum_type_node)
 735         fprintf (file, " `enum'");
 736       else
 737         abort ();
 738       break;
 739
 740     case CONSTANT:
 741       t = yylval.ttype;
 742       if (TREE_CODE (t) == INTEGER_CST)
 743         fprintf (file,
 744 #if HOST_BITS_PER_WIDE_INT == 64
 745 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
 746                  " 0x%x%016x",
 747 #else
 748 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
 749                  " 0x%lx%016lx",
 750 #else
 751                  " 0x%llx%016llx",
 752 #endif
 753 #endif
 754 #else
 755 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
 756                  " 0x%lx%08lx",
 757 #else
 758                  " 0x%x%08x",
 759 #endif
 760 #endif
 761                  TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
 762       break;
 763     }
 764 }
 765
 766 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
 767 static int *reduce_count;
 768 #endif
 769
 770 int *token_count;
 771
 772 #if 0
 773 #define REDUCE_LENGTH ARRAY_SIZE (yyr2)
 774 #define TOKEN_LENGTH (256 + ARRAY_SIZE (yytname))
 775 #endif
 776
 777 #ifdef GATHER_STATISTICS
 778 #ifdef REDUCE_LENGTH
 779 void
 780 yyhook (yyn)
 781      int yyn;
 782 {
 783   reduce_count[yyn] += 1;
 784 }
 785
 786 static int
 787 reduce_cmp (p, q)
 788      int *p, *q;
 789 {
 790   return reduce_count[*q] - reduce_count[*p];
 791 }
 792
 793 static int
 794 token_cmp (p, q)
 795      int *p, *q;
 796 {
 797   return token_count[*q] - token_count[*p];
 798 }
 799 #endif
 800 #endif
 801
 802 void
 803 print_parse_statistics ()
 804 {
 805 #ifdef GATHER_STATISTICS
 806 #ifdef REDUCE_LENGTH
 807 #if YYDEBUG != 0
 808   int i;
 809   int maxlen = REDUCE_LENGTH;
 810   unsigned *sorted;
 811
 812   if (reduce_count[-1] == 0)
 813     return;
 814
 815   if (TOKEN_LENGTH > REDUCE_LENGTH)
 816     maxlen = TOKEN_LENGTH;
 817   sorted = (unsigned *) alloca (sizeof (int) * maxlen);
 818
 819   for (i = 0; i < TOKEN_LENGTH; i++)
 820     sorted[i] = i;
 821   qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
 822   for (i = 0; i < TOKEN_LENGTH; i++)
 823     {
 824       int idx = sorted[i];
 825       if (token_count[idx] == 0)
 826         break;
 827       if (token_count[idx] < token_count[-1])
 828         break;
 829       fprintf (stderr, "token %d, `%s', count = %d\n",
 830                idx, yytname[YYTRANSLATE (idx)], token_count[idx]);
 831     }
 832   fprintf (stderr, "\n");
 833   for (i = 0; i < REDUCE_LENGTH; i++)
 834     sorted[i] = i;
 835   qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
 836   for (i = 0; i < REDUCE_LENGTH; i++)
 837     {
 838       int idx = sorted[i];
 839       if (reduce_count[idx] == 0)
 840         break;
 841       if (reduce_count[idx] < reduce_count[-1])
 842         break;
 843       fprintf (stderr, "rule %d, line %d, count = %d\n",
 844                idx, yyrline[idx], reduce_count[idx]);
 845     }
 846   fprintf (stderr, "\n");
 847 #endif
 848 #endif
 849 #endif
 850 }
 851
 852 /* Sets the value of the 'yydebug' variable to VALUE.
 853    This is a function so we don't have to have YYDEBUG defined
 854    in order to build the compiler.  */
 855
 856 void
 857 cxx_set_yydebug (value)
 858      int value;
 859 {
 860 #if YYDEBUG != 0
 861   extern int yydebug;
 862   yydebug = value;
 863 #else
 864   warning ("YYDEBUG not defined");
 865 #endif
 866 }
 867
 868 /* Helper function to load global variables with interface
 869    information.  */
 870
 871 void
 872 extract_interface_info ()
 873 {
 874   struct c_fileinfo *finfo = 0;
 875
 876   if (flag_alt_external_templates)
 877     {
 878       tree til = tinst_for_decl ();
 879
 880       if (til)
 881         finfo = get_fileinfo (TINST_FILE (til));
 882     }
 883   if (!finfo)
 884     finfo = get_fileinfo (input_filename);
 885
 886   interface_only = finfo->interface_only;
 887   interface_unknown = finfo->interface_unknown;
 888 }
 889
 890 /* Return nonzero if S is not considered part of an
 891    INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
 892
 893 static int
 894 interface_strcmp (s)
 895      const char *s;
 896 {
 897   /* Set the interface/implementation bits for this scope.  */
 898   struct impl_files *ifiles;
 899   const char *s1;
 900
 901   for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
 902     {
 903       const char *t1 = ifiles->filename;
 904       s1 = s;
 905
 906       if (*s1 != *t1 || *s1 == 0)
 907         continue;
 908
 909       while (*s1 == *t1 && *s1 != 0)
 910         s1++, t1++;
 911
 912       /* A match.  */
 913       if (*s1 == *t1)
 914         return 0;
 915
 916       /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
 917       if (strchr (s1, '.') || strchr (t1, '.'))
 918         continue;
 919
 920       if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
 921         continue;
 922
 923       /* A match.  */
 924       return 0;
 925     }
 926
 927   /* No matches.  */
 928   return 1;
 929 }
 930
 931 /* Heuristic to tell whether the user is missing a semicolon
 932    after a struct or enum declaration.  Emit an error message
 933    if we know the user has blown it.  */
 934
 935 void
 936 check_for_missing_semicolon (type)
 937      tree type;
 938 {
 939   if (yychar < 0)
 940     yychar = yylex ();
 941
 942   if ((yychar > 255
 943        && yychar != SCSPEC
 944        && yychar != IDENTIFIER
 945        && yychar != TYPENAME
 946        && yychar != CV_QUALIFIER
 947        && yychar != SELFNAME)
 948       || yychar == 0  /* EOF */)
 949     {
 950       if (TYPE_ANONYMOUS_P (type))
 951         error ("semicolon missing after %s declaration",
 952                TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
 953       else
 954         error ("semicolon missing after declaration of `%T'", type);
 955       shadow_tag (build_tree_list (0, type));
 956     }
 957   /* Could probably also hack cases where class { ... } f (); appears.  */
 958   clear_anon_tags ();
 959 }
 960
 961 void
 962 note_got_semicolon (type)
 963      tree type;
 964 {
 965   if (!TYPE_P (type))
 966     abort ();
 967   if (CLASS_TYPE_P (type))
 968     CLASSTYPE_GOT_SEMICOLON (type) = 1;
 969 }
 970
 971 void
 972 note_list_got_semicolon (declspecs)
 973      tree declspecs;
 974 {
 975   tree link;
 976
 977   for (link = declspecs; link; link = TREE_CHAIN (link))
 978     {
 979       tree type = TREE_VALUE (link);
 980       if (type && TYPE_P (type))
 981         note_got_semicolon (type);
 982     }
 983   clear_anon_tags ();
 984 }
 985 \f
 986
 987 /* Parse a #pragma whose sole argument is a string constant.
 988    If OPT is true, the argument is optional.  */
 989 static tree
 990 parse_strconst_pragma (name, opt)
 991      const char *name;
 992      int opt;
 993 {
 994   tree result, x;
 995   enum cpp_ttype t;
 996
 997   t = c_lex (&x);
 998   if (t == CPP_STRING)
 999     {
1000       result = x;
1001       if (c_lex (&x) != CPP_EOF)
1002         warning ("junk at end of #pragma %s", name);
1003       return result;
1004     }
1005
1006   if (t == CPP_EOF && opt)
1007     return 0;
1008
1009   error ("invalid #pragma %s", name);
1010   return (tree)-1;
1011 }
1012
1013 static void
1014 handle_pragma_vtable (dfile)
1015      cpp_reader *dfile ATTRIBUTE_UNUSED;
1016 {
1017   parse_strconst_pragma ("vtable", 0);
1018   sorry ("#pragma vtable no longer supported");
1019 }
1020
1021 static void
1022 handle_pragma_unit (dfile)
1023      cpp_reader *dfile ATTRIBUTE_UNUSED;
1024 {
1025   /* Validate syntax, but don't do anything.  */
1026   parse_strconst_pragma ("unit", 0);
1027 }
1028
1029 static void
1030 handle_pragma_interface (dfile)
1031      cpp_reader *dfile ATTRIBUTE_UNUSED;
1032 {
1033   tree fname = parse_strconst_pragma ("interface", 1);
1034   struct c_fileinfo *finfo;
1035   const char *main_filename;
1036
1037   if (fname == (tree)-1)
1038     return;
1039   else if (fname == 0)
1040     main_filename = lbasename (input_filename);
1041   else
1042     main_filename = TREE_STRING_POINTER (fname);
1043
1044   finfo = get_fileinfo (input_filename);
1045
1046   if (impl_file_chain == 0)
1047     {
1048       /* If this is zero at this point, then we are
1049          auto-implementing.  */
1050       if (main_input_filename == 0)
1051         main_input_filename = input_filename;
1052     }
1053
1054   interface_only = interface_strcmp (main_filename);
1055 #ifdef MULTIPLE_SYMBOL_SPACES
1056   if (! interface_only)
1057 #endif
1058     interface_unknown = 0;
1059
1060   finfo->interface_only = interface_only;
1061   finfo->interface_unknown = interface_unknown;
1062 }
1063
1064 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
1065    We used to only allow this at toplevel, but that restriction was buggy
1066    in older compilers and it seems reasonable to allow it in the headers
1067    themselves, too.  It only needs to precede the matching #p interface.
1068
1069    We don't touch interface_only or interface_unknown; the user must specify
1070    a matching #p interface for this to have any effect.  */
1071
1072 static void
1073 handle_pragma_implementation (dfile)
1074      cpp_reader *dfile ATTRIBUTE_UNUSED;
1075 {
1076   tree fname = parse_strconst_pragma ("implementation", 1);
1077   const char *main_filename;
1078   struct impl_files *ifiles = impl_file_chain;
1079
1080   if (fname == (tree)-1)
1081     return;
1082
1083   if (fname == 0)
1084     {
1085       if (main_input_filename)
1086         main_filename = main_input_filename;
1087       else
1088         main_filename = input_filename;
1089       main_filename = lbasename (main_filename);
1090     }
1091   else
1092     {
1093       main_filename = TREE_STRING_POINTER (fname);
1094       if (cpp_included (parse_in, main_filename))
1095         warning ("#pragma implementation for %s appears after file is included",
1096                  main_filename);
1097     }
1098
1099   for (; ifiles; ifiles = ifiles->next)
1100     {
1101       if (! strcmp (ifiles->filename, main_filename))
1102         break;
1103     }
1104   if (ifiles == 0)
1105     {
1106       ifiles = (struct impl_files*) xmalloc (sizeof (struct impl_files));
1107       ifiles->filename = main_filename;
1108       ifiles->next = impl_file_chain;
1109       impl_file_chain = ifiles;
1110     }
1111 }
1112
1113 /* Indicate that this file uses Java-personality exception handling.  */
1114 static void
1115 handle_pragma_java_exceptions (dfile)
1116      cpp_reader *dfile ATTRIBUTE_UNUSED;
1117 {
1118   tree x;
1119   if (c_lex (&x) != CPP_EOF)
1120     warning ("junk at end of #pragma GCC java_exceptions");
1121
1122   choose_personality_routine (lang_java);
1123 }
1124
1125 void
1126 do_pending_lang_change ()
1127 {
1128   for (; pending_lang_change > 0; --pending_lang_change)
1129     push_lang_context (lang_name_c);
1130   for (; pending_lang_change < 0; ++pending_lang_change)
1131     pop_lang_context ();
1132 }
1133
1134 /* Return true if d is in a global scope. */
1135
1136 static int
1137 is_global (d)
1138   tree d;
1139 {
1140   while (1)
1141     switch (TREE_CODE (d))
1142       {
1143       case ERROR_MARK:
1144         return 1;
1145
1146       case OVERLOAD: d = OVL_FUNCTION (d); continue;
1147       case TREE_LIST: d = TREE_VALUE (d); continue;
1148       default:
1149         my_friendly_assert (DECL_P (d), 980629);
1150
1151         return DECL_NAMESPACE_SCOPE_P (d);
1152       }
1153 }
1154
1155 tree
1156 do_identifier (token, parsing, args)
1157      register tree token;
1158      int parsing;
1159      tree args;
1160 {
1161   register tree id;
1162   int lexing = (parsing == 1);
1163
1164   if (! lexing)
1165     id = lookup_name (token, 0);
1166   else
1167     id = lastiddecl;
1168
1169   if (lexing && id && TREE_DEPRECATED (id))
1170     warn_deprecated_use (id);
1171
1172   /* Do Koenig lookup if appropriate (inside templates we build lookup
1173      expressions instead).
1174
1175      [basic.lookup.koenig]: If the ordinary unqualified lookup of the name
1176      finds the declaration of a class member function, the associated
1177      namespaces and classes are not considered.  */
1178
1179   if (args && !current_template_parms && (!id || is_global (id)))
1180     id = lookup_arg_dependent (token, id, args);
1181
1182   /* Remember that this name has been used in the class definition, as per
1183      [class.scope0] */
1184   if (id && parsing)
1185     maybe_note_name_used_in_class (token, id);
1186
1187   if (id == error_mark_node)
1188     {
1189       /* lookup_name quietly returns error_mark_node if we're parsing,
1190          as we don't want to complain about an identifier that ends up
1191          being used as a declarator.  So we call it again to get the error
1192          message.  */
1193       id = lookup_name (token, 0);
1194       return error_mark_node;
1195     }
1196
1197   if (!id || (TREE_CODE (id) == FUNCTION_DECL
1198               && DECL_ANTICIPATED (id)))
1199     {
1200       if (current_template_parms)
1201         return build_min_nt (LOOKUP_EXPR, token);
1202       else if (IDENTIFIER_TYPENAME_P (token))
1203         /* A templated conversion operator might exist.  */
1204         return token;
1205       else if (IDENTIFIER_OPNAME_P (token))
1206         {
1207           if (token != ansi_opname (ERROR_MARK))
1208             error ("`%D' not defined", token);
1209           id = error_mark_node;
1210         }
1211       else if (current_function_decl == 0)
1212         {
1213           error ("`%D' was not declared in this scope", token);
1214           id = error_mark_node;
1215         }
1216       else
1217         {
1218           if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node
1219               || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
1220             {
1221               static int undeclared_variable_notice;
1222
1223               error ("`%D' undeclared (first use this function)", token);
1224
1225               if (! undeclared_variable_notice)
1226                 {
1227                   error ("(Each undeclared identifier is reported only once for each function it appears in.)");
1228                   undeclared_variable_notice = 1;
1229                 }
1230             }
1231           id = error_mark_node;
1232           /* Prevent repeated error messages.  */
1233           SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
1234           SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
1235         }
1236     }
1237
1238   if (TREE_CODE (id) == VAR_DECL && DECL_DEAD_FOR_LOCAL (id))
1239     {
1240       tree shadowed = DECL_SHADOWED_FOR_VAR (id);
1241       while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1242              && DECL_DEAD_FOR_LOCAL (shadowed))
1243         shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
1244       if (!shadowed)
1245         shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id));
1246       if (shadowed)
1247         {
1248           if (!DECL_ERROR_REPORTED (id))
1249             {
1250               warning ("name lookup of `%s' changed",
1251                        IDENTIFIER_POINTER (token));
1252               cp_warning_at ("  matches this `%D' under ISO standard rules",
1253                              shadowed);
1254               cp_warning_at ("  matches this `%D' under old rules", id);
1255               DECL_ERROR_REPORTED (id) = 1;
1256             }
1257           id = shadowed;
1258         }
1259       else if (!DECL_ERROR_REPORTED (id))
1260         {
1261           DECL_ERROR_REPORTED (id) = 1;
1262           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (id)))
1263             {
1264               error ("name lookup of `%s' changed for new ISO `for' scoping",
1265                      IDENTIFIER_POINTER (token));
1266               cp_error_at ("  cannot use obsolete binding at `%D' because it has a destructor", id);
1267               id = error_mark_node;
1268             }
1269           else
1270             {
1271               pedwarn ("name lookup of `%s' changed for new ISO `for' scoping",
1272                        IDENTIFIER_POINTER (token));
1273               cp_pedwarn_at ("  using obsolete binding at `%D'", id);
1274             }
1275         }
1276     }
1277   /* TREE_USED is set in `hack_identifier'.  */
1278   if (TREE_CODE (id) == CONST_DECL)
1279     {
1280       /* Check access.  */
1281       if (IDENTIFIER_CLASS_VALUE (token) == id)
1282         enforce_access (CP_DECL_CONTEXT(id), id);
1283       if (!processing_template_decl || DECL_TEMPLATE_PARM_P (id))
1284         id = DECL_INITIAL (id);
1285     }
1286   else
1287     id = hack_identifier (id, token);
1288
1289   /* We must look up dependent names when the template is
1290      instantiated, not while parsing it.  For now, we don't
1291      distinguish between dependent and independent names.  So, for
1292      example, we look up all overloaded functions at
1293      instantiation-time, even though in some cases we should just use
1294      the DECL we have here.  We also use LOOKUP_EXPRs to find things
1295      like local variables, rather than creating TEMPLATE_DECLs for the
1296      local variables and then finding matching instantiations.  */
1297   if (current_template_parms
1298       && (is_overloaded_fn (id)
1299           || (TREE_CODE (id) == VAR_DECL
1300               && CP_DECL_CONTEXT (id)
1301               && TREE_CODE (CP_DECL_CONTEXT (id)) == FUNCTION_DECL)
1302           || TREE_CODE (id) == PARM_DECL
1303           || TREE_CODE (id) == RESULT_DECL
1304           || TREE_CODE (id) == USING_DECL))
1305     id = build_min_nt (LOOKUP_EXPR, token);
1306
1307   return id;
1308 }
1309
1310 tree
1311 do_scoped_id (token, parsing)
1312      tree token;
1313      int parsing;
1314 {
1315   tree id;
1316   /* during parsing, this is ::name. Otherwise, it is black magic. */
1317   if (parsing)
1318     {
1319       id = make_node (CPLUS_BINDING);
1320       if (!qualified_lookup_using_namespace (token, global_namespace, id, 0))
1321         id = NULL_TREE;
1322       else
1323         id = BINDING_VALUE (id);
1324     }
1325   else
1326     id = IDENTIFIER_GLOBAL_VALUE (token);
1327   if (parsing && yychar == YYEMPTY)
1328     yychar = yylex ();
1329   if (! id)
1330     {
1331       if (processing_template_decl)
1332         {
1333           id = build_min_nt (LOOKUP_EXPR, token);
1334           LOOKUP_EXPR_GLOBAL (id) = 1;
1335           return id;
1336         }
1337       if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
1338         error ("`::%D' undeclared (first use here)", token);
1339       id = error_mark_node;
1340       /* Prevent repeated error messages.  */
1341       SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
1342     }
1343   else
1344     {
1345       if (TREE_CODE (id) == ADDR_EXPR)
1346         mark_used (TREE_OPERAND (id, 0));
1347       else if (TREE_CODE (id) != OVERLOAD)
1348         mark_used (id);
1349     }
1350   if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
1351     {
1352       /* XXX CHS - should we set TREE_USED of the constant? */
1353       id = DECL_INITIAL (id);
1354       /* This is to prevent an enum whose value is 0
1355          from being considered a null pointer constant.  */
1356       id = build1 (NOP_EXPR, TREE_TYPE (id), id);
1357       TREE_CONSTANT (id) = 1;
1358     }
1359
1360   if (processing_template_decl)
1361     {
1362       if (is_overloaded_fn (id))
1363         {
1364           id = build_min_nt (LOOKUP_EXPR, token);
1365           LOOKUP_EXPR_GLOBAL (id) = 1;
1366           return id;
1367         }
1368       /* else just use the decl */
1369     }
1370   return convert_from_reference (id);
1371 }
1372
1373 tree
1374 identifier_typedecl_value (node)
1375      tree node;
1376 {
1377   tree t, type;
1378   type = IDENTIFIER_TYPE_VALUE (node);
1379   if (type == NULL_TREE)
1380     return NULL_TREE;
1381
1382   if (IDENTIFIER_BINDING (node))
1383     {
1384       t = IDENTIFIER_VALUE (node);
1385       if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
1386         return t;
1387     }
1388   if (IDENTIFIER_NAMESPACE_VALUE (node))
1389     {
1390       t = IDENTIFIER_NAMESPACE_VALUE (node);
1391       if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
1392         return t;
1393     }
1394
1395   /* Will this one ever happen?  */
1396   if (TYPE_MAIN_DECL (type))
1397     return TYPE_MAIN_DECL (type);
1398
1399   /* We used to do an internal error of 62 here, but instead we will
1400      handle the return of a null appropriately in the callers.  */
1401   return NULL_TREE;
1402 }
1403
1404 #ifdef GATHER_STATISTICS
1405 /* The original for tree_node_kind is in the toplevel tree.c; changes there
1406    need to be brought into here, unless this were actually put into a header
1407    instead.  */
1408 /* Statistics-gathering stuff.  */
1409 typedef enum
1410 {
1411   d_kind,
1412   t_kind,
1413   b_kind,
1414   s_kind,
1415   r_kind,
1416   e_kind,
1417   c_kind,
1418   id_kind,
1419   op_id_kind,
1420   perm_list_kind,
1421   temp_list_kind,
1422   vec_kind,
1423   x_kind,
1424   lang_decl,
1425   lang_type,
1426   all_kinds
1427 } tree_node_kind;
1428
1429 extern int tree_node_counts[];
1430 extern int tree_node_sizes[];
1431 #endif
1432
1433 tree
1434 build_lang_decl (code, name, type)
1435      enum tree_code code;
1436      tree name;
1437      tree type;
1438 {
1439   tree t;
1440
1441   t = build_decl (code, name, type);
1442   retrofit_lang_decl (t);
1443
1444   return t;
1445 }
1446
1447 /* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
1448    and pushdecl (for functions generated by the backend).  */
1449
1450 void
1451 retrofit_lang_decl (t)
1452      tree t;
1453 {
1454   struct lang_decl *ld;
1455   size_t size;
1456
1457   if (CAN_HAVE_FULL_LANG_DECL_P (t))
1458     size = sizeof (struct lang_decl);
1459   else
1460     size = sizeof (struct lang_decl_flags);
1461
1462   ld = (struct lang_decl *) ggc_alloc_cleared (size);
1463
1464   DECL_LANG_SPECIFIC (t) = ld;
1465   if (current_lang_name == lang_name_cplusplus)
1466     SET_DECL_LANGUAGE (t, lang_cplusplus);
1467   else if (current_lang_name == lang_name_c)
1468     SET_DECL_LANGUAGE (t, lang_c);
1469   else if (current_lang_name == lang_name_java)
1470     SET_DECL_LANGUAGE (t, lang_java);
1471   else abort ();
1472
1473 #ifdef GATHER_STATISTICS
1474   tree_node_counts[(int)lang_decl] += 1;
1475   tree_node_sizes[(int)lang_decl] += size;
1476 #endif
1477 }
1478
1479 void
1480 cxx_dup_lang_specific_decl (node)
1481      tree node;
1482 {
1483   int size;
1484   struct lang_decl *ld;
1485
1486   if (! DECL_LANG_SPECIFIC (node))
1487     return;
1488
1489   if (!CAN_HAVE_FULL_LANG_DECL_P (node))
1490     size = sizeof (struct lang_decl_flags);
1491   else
1492     size = sizeof (struct lang_decl);
1493   ld = (struct lang_decl *) ggc_alloc (size);
1494   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
1495   DECL_LANG_SPECIFIC (node) = ld;
1496
1497 #ifdef GATHER_STATISTICS
1498   tree_node_counts[(int)lang_decl] += 1;
1499   tree_node_sizes[(int)lang_decl] += size;
1500 #endif
1501 }
1502
1503 /* Copy DECL, including any language-specific parts.  */
1504
1505 tree
1506 copy_decl (decl)
1507      tree decl;
1508 {
1509   tree copy;
1510
1511   copy = copy_node (decl);
1512   cxx_dup_lang_specific_decl (copy);
1513   return copy;
1514 }
1515
1516 /* Replace the shared language-specific parts of NODE with a new copy.  */
1517
1518 static void
1519 copy_lang_type (node)
1520      tree node;
1521 {
1522   int size;
1523   struct lang_type *lt;
1524
1525   if (! TYPE_LANG_SPECIFIC (node))
1526     return;
1527
1528   size = sizeof (struct lang_type);
1529   lt = (struct lang_type *) ggc_alloc (size);
1530   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
1531   TYPE_LANG_SPECIFIC (node) = lt;
1532
1533 #ifdef GATHER_STATISTICS
1534   tree_node_counts[(int)lang_type] += 1;
1535   tree_node_sizes[(int)lang_type] += size;
1536 #endif
1537 }
1538
1539 /* Copy TYPE, including any language-specific parts.  */
1540
1541 tree
1542 copy_type (type)
1543      tree type;
1544 {
1545   tree copy;
1546
1547   copy = copy_node (type);
1548   copy_lang_type (copy);
1549   return copy;
1550 }
1551
1552 tree
1553 cxx_make_type (code)
1554      enum tree_code code;
1555 {
1556   register tree t = make_node (code);
1557
1558   /* Create lang_type structure.  */
1559   if (IS_AGGR_TYPE_CODE (code)
1560       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
1561     {
1562       struct lang_type *pi;
1563
1564       pi = ((struct lang_type *)
1565             ggc_alloc_cleared (sizeof (struct lang_type)));
1566
1567       TYPE_LANG_SPECIFIC (t) = pi;
1568
1569 #ifdef GATHER_STATISTICS
1570       tree_node_counts[(int)lang_type] += 1;
1571       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
1572 #endif
1573     }
1574
1575   /* Set up some flags that give proper default behavior.  */
1576   if (IS_AGGR_TYPE_CODE (code))
1577     {
1578       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
1579       CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
1580
1581       /* Make sure this is laid out, for ease of use later.  In the
1582          presence of parse errors, the normal was of assuring this
1583          might not ever get executed, so we lay it out *immediately*.  */
1584       build_pointer_type (t);
1585     }
1586   else
1587     /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits.  But,
1588        TYPE_ALIAS_SET is initialized to -1 by default, so we must
1589        clear it here.  */
1590     TYPE_ALIAS_SET (t) = 0;
1591
1592   /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
1593      since they can be virtual base types, and we then need a
1594      canonical binfo for them.  Ideally, this would be done lazily for
1595      all types.  */
1596   if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM
1597       || code == BOUND_TEMPLATE_TEMPLATE_PARM
1598       || code == TYPENAME_TYPE)
1599     TYPE_BINFO (t) = make_binfo (size_zero_node, t, NULL_TREE, NULL_TREE);
1600
1601   return t;
1602 }
1603
1604 tree
1605 make_aggr_type (code)
1606      enum tree_code code;
1607 {
1608   tree t = cxx_make_type (code);
1609
1610   if (IS_AGGR_TYPE_CODE (code))
1611     SET_IS_AGGR_TYPE (t, 1);
1612
1613   return t;
1614 }
1615
1616 void
1617 compiler_error VPARAMS ((const char *msg, ...))
1618 {
1619   char buf[1024];
1620
1621   VA_OPEN (ap, msg);
1622   VA_FIXEDARG (ap, const char *, msg);
1623
1624   vsprintf (buf, msg, ap);
1625   VA_CLOSE (ap);
1626
1627   error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
1628 }
1629
1630 /* Return the type-qualifier corresponding to the identifier given by
1631    RID.  */
1632
1633 int
1634 cp_type_qual_from_rid (rid)
1635      tree rid;
1636 {
1637   if (rid == ridpointers[(int) RID_CONST])
1638     return TYPE_QUAL_CONST;
1639   else if (rid == ridpointers[(int) RID_VOLATILE])
1640     return TYPE_QUAL_VOLATILE;
1641   else if (rid == ridpointers[(int) RID_RESTRICT])
1642     return TYPE_QUAL_RESTRICT;
1643
1644   abort ();
1645   return TYPE_UNQUALIFIED;
1646 }