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