contrib/gcc-4.1/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, 2003, 2004, 2005 Free Software Foundation, Inc.
   4    Hacked by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC 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 GCC 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 GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  21 Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* This file is the lexical analyzer for GNU C++.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "input.h"
  31 #include "tree.h"
  32 #include "cp-tree.h"
  33 #include "cpplib.h"
  34 #include "flags.h"
  35 #include "c-pragma.h"
  36 #include "toplev.h"
  37 #include "output.h"
  38 #include "tm_p.h"
  39 #include "timevar.h"
  40
  41 static int interface_strcmp (const char *);
  42 static void init_cp_pragma (void);
  43
  44 static tree parse_strconst_pragma (const char *, int);
  45 static void handle_pragma_vtable (cpp_reader *);
  46 static void handle_pragma_unit (cpp_reader *);
  47 static void handle_pragma_interface (cpp_reader *);
  48 static void handle_pragma_implementation (cpp_reader *);
  49 static void handle_pragma_java_exceptions (cpp_reader *);
  50
  51 static void init_operators (void);
  52 static void copy_lang_type (tree);
  53
  54 /* A constraint that can be tested at compile time.  */
  55 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
  56
  57 /* Functions and data structures for #pragma interface.
  58
  59    `#pragma implementation' means that the main file being compiled
  60    is considered to implement (provide) the classes that appear in
  61    its main body.  I.e., if this is file "foo.cc", and class `bar'
  62    is defined in "foo.cc", then we say that "foo.cc implements bar".
  63
  64    All main input files "implement" themselves automagically.
  65
  66    `#pragma interface' means that unless this file (of the form "foo.h"
  67    is not presently being included by file "foo.cc", the
  68    CLASSTYPE_INTERFACE_ONLY bit gets set.  The effect is that none
  69    of the vtables nor any of the inline functions defined in foo.h
  70    will ever be output.
  71
  72    There are cases when we want to link files such as "defs.h" and
  73    "main.cc".  In this case, we give "defs.h" a `#pragma interface',
  74    and "main.cc" has `#pragma implementation "defs.h"'.  */
  75
  76 struct impl_files
  77 {
  78   const char *filename;
  79   struct impl_files *next;
  80 };
  81
  82 static struct impl_files *impl_file_chain;
  83
  84 \f
  85 void
  86 cxx_finish (void)
  87 {
  88   c_common_finish ();
  89 }
  90
  91 /* A mapping from tree codes to operator name information.  */
  92 operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE];
  93 /* Similar, but for assignment operators.  */
  94 operator_name_info_t assignment_operator_name_info[(int) LAST_CPLUS_TREE_CODE];
  95
  96 /* Initialize data structures that keep track of operator names.  */
  97
  98 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
  99  CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
 100 #include "operators.def"
 101 #undef DEF_OPERATOR
 102
 103 static void
 104 init_operators (void)
 105 {
 106   tree identifier;
 107   char buffer[256];
 108   struct operator_name_info_t *oni;
 109
 110 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)                   \
 111   sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
 112   identifier = get_identifier (buffer);                                     \
 113   IDENTIFIER_OPNAME_P (identifier) = 1;                                     \
 114                                                                             \
 115   oni = (ASSN_P                                                             \
 116          ? &assignment_operator_name_info[(int) CODE]                       \
 117          : &operator_name_info[(int) CODE]);                                \
 118   oni->identifier = identifier;                                             \
 119   oni->name = NAME;                                                         \
 120   oni->mangled_name = MANGLING;                                             \
 121   oni->arity = ARITY;
 122
 123 #include "operators.def"
 124 #undef DEF_OPERATOR
 125
 126   operator_name_info[(int) ERROR_MARK].identifier
 127     = get_identifier ("<invalid operator>");
 128
 129   /* Handle some special cases.  These operators are not defined in
 130      the language, but can be produced internally.  We may need them
 131      for error-reporting.  (Eventually, we should ensure that this
 132      does not happen.  Error messages involving these operators will
 133      be confusing to users.)  */
 134
 135   operator_name_info [(int) INIT_EXPR].name
 136     = operator_name_info [(int) MODIFY_EXPR].name;
 137   operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
 138   operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
 139   operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
 140   operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
 141   operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
 142   operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
 143   operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
 144   operator_name_info [(int) ABS_EXPR].name = "abs";
 145   operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
 146   operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
 147   operator_name_info [(int) RANGE_EXPR].name = "...";
 148   operator_name_info [(int) UNARY_PLUS_EXPR].name = "+";
 149
 150   assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
 151     = "(exact /=)";
 152   assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
 153     = "(ceiling /=)";
 154   assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
 155     = "(floor /=)";
 156   assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
 157     = "(round /=)";
 158   assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
 159     = "(ceiling %=)";
 160   assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
 161     = "(floor %=)";
 162   assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
 163     = "(round %=)";
 164 }
 165
 166 /* The reserved keyword table.  */
 167 struct resword
 168 {
 169   const char *const word;
 170   ENUM_BITFIELD(rid) const rid : 16;
 171   const unsigned int disable   : 16;
 172 };
 173
 174 /* Disable mask.  Keywords are disabled if (reswords[i].disable & mask) is
 175    _true_.  */
 176 #define D_EXT           0x01    /* GCC extension */
 177 #define D_ASM           0x02    /* in C99, but has a switch to turn it off */
 178 #define D_OBJC          0x04    /* Objective C++ only */
 179
 180 CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
 181
 182 static const struct resword reswords[] =
 183 {
 184   { "_Complex",         RID_COMPLEX,    0 },
 185   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
 186   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
 187   { "__alignof",        RID_ALIGNOF,    0 },
 188   { "__alignof__",      RID_ALIGNOF,    0 },
 189   { "__asm",            RID_ASM,        0 },
 190   { "__asm__",          RID_ASM,        0 },
 191   { "__attribute",      RID_ATTRIBUTE,  0 },
 192   { "__attribute__",    RID_ATTRIBUTE,  0 },
 193   { "__builtin_offsetof", RID_OFFSETOF, 0 },
 194   { "__builtin_va_arg", RID_VA_ARG,     0 },
 195   { "__complex",        RID_COMPLEX,    0 },
 196   { "__complex__",      RID_COMPLEX,    0 },
 197   { "__const",          RID_CONST,      0 },
 198   { "__const__",        RID_CONST,      0 },
 199   { "__extension__",    RID_EXTENSION,  0 },
 200   { "__func__",         RID_C99_FUNCTION_NAME,  0 },
 201   { "__imag",           RID_IMAGPART,   0 },
 202   { "__imag__",         RID_IMAGPART,   0 },
 203   { "__inline",         RID_INLINE,     0 },
 204   { "__inline__",       RID_INLINE,     0 },
 205   { "__label__",        RID_LABEL,      0 },
 206   { "__null",           RID_NULL,       0 },
 207   { "__real",           RID_REALPART,   0 },
 208   { "__real__",         RID_REALPART,   0 },
 209   { "__restrict",       RID_RESTRICT,   0 },
 210   { "__restrict__",     RID_RESTRICT,   0 },
 211   { "__signed",         RID_SIGNED,     0 },
 212   { "__signed__",       RID_SIGNED,     0 },
 213   { "__thread",         RID_THREAD,     0 },
 214   { "__typeof",         RID_TYPEOF,     0 },
 215   { "__typeof__",       RID_TYPEOF,     0 },
 216   { "__volatile",       RID_VOLATILE,   0 },
 217   { "__volatile__",     RID_VOLATILE,   0 },
 218   { "asm",              RID_ASM,        D_ASM },
 219   { "auto",             RID_AUTO,       0 },
 220   { "bool",             RID_BOOL,       0 },
 221   { "break",            RID_BREAK,      0 },
 222   { "case",             RID_CASE,       0 },
 223   { "catch",            RID_CATCH,      0 },
 224   { "char",             RID_CHAR,       0 },
 225   { "class",            RID_CLASS,      0 },
 226   { "const",            RID_CONST,      0 },
 227   { "const_cast",       RID_CONSTCAST,  0 },
 228   { "continue",         RID_CONTINUE,   0 },
 229   { "default",          RID_DEFAULT,    0 },
 230   { "delete",           RID_DELETE,     0 },
 231   { "do",               RID_DO,         0 },
 232   { "double",           RID_DOUBLE,     0 },
 233   { "dynamic_cast",     RID_DYNCAST,    0 },
 234   { "else",             RID_ELSE,       0 },
 235   { "enum",             RID_ENUM,       0 },
 236   { "explicit",         RID_EXPLICIT,   0 },
 237   { "export",           RID_EXPORT,     0 },
 238   { "extern",           RID_EXTERN,     0 },
 239   { "false",            RID_FALSE,      0 },
 240   { "float",            RID_FLOAT,      0 },
 241   { "for",              RID_FOR,        0 },
 242   { "friend",           RID_FRIEND,     0 },
 243   { "goto",             RID_GOTO,       0 },
 244   { "if",               RID_IF,         0 },
 245   { "inline",           RID_INLINE,     0 },
 246   { "int",              RID_INT,        0 },
 247   { "long",             RID_LONG,       0 },
 248   { "mutable",          RID_MUTABLE,    0 },
 249   { "namespace",        RID_NAMESPACE,  0 },
 250   { "new",              RID_NEW,        0 },
 251   { "operator",         RID_OPERATOR,   0 },
 252   { "private",          RID_PRIVATE,    0 },
 253   { "protected",        RID_PROTECTED,  0 },
 254   { "public",           RID_PUBLIC,     0 },
 255   { "register",         RID_REGISTER,   0 },
 256   { "reinterpret_cast", RID_REINTCAST,  0 },
 257   { "return",           RID_RETURN,     0 },
 258   { "short",            RID_SHORT,      0 },
 259   { "signed",           RID_SIGNED,     0 },
 260   { "sizeof",           RID_SIZEOF,     0 },
 261   { "static",           RID_STATIC,     0 },
 262   { "static_cast",      RID_STATCAST,   0 },
 263   { "struct",           RID_STRUCT,     0 },
 264   { "switch",           RID_SWITCH,     0 },
 265   { "template",         RID_TEMPLATE,   0 },
 266   { "this",             RID_THIS,       0 },
 267   { "throw",            RID_THROW,      0 },
 268   { "true",             RID_TRUE,       0 },
 269   { "try",              RID_TRY,        0 },
 270   { "typedef",          RID_TYPEDEF,    0 },
 271   { "typename",         RID_TYPENAME,   0 },
 272   { "typeid",           RID_TYPEID,     0 },
 273   { "typeof",           RID_TYPEOF,     D_ASM|D_EXT },
 274   { "union",            RID_UNION,      0 },
 275   { "unsigned",         RID_UNSIGNED,   0 },
 276   { "using",            RID_USING,      0 },
 277   { "virtual",          RID_VIRTUAL,    0 },
 278   { "void",             RID_VOID,       0 },
 279   { "volatile",         RID_VOLATILE,   0 },
 280   { "wchar_t",          RID_WCHAR,      0 },
 281   { "while",            RID_WHILE,      0 },
 282
 283   /* The remaining keywords are specific to Objective-C++.  NB:
 284      All of them will remain _disabled_, since they are context-
 285      sensitive.  */
 286
 287   /* These ObjC keywords are recognized only immediately after
 288      an '@'.  NB: The following C++ keywords double as
 289      ObjC keywords in this context: RID_CLASS, RID_PRIVATE,
 290      RID_PROTECTED, RID_PUBLIC, RID_THROW, RID_TRY and RID_CATCH.  */
 291   { "compatibility_alias", RID_AT_ALIAS,        D_OBJC },
 292   { "defs",             RID_AT_DEFS,            D_OBJC },
 293   { "encode",           RID_AT_ENCODE,          D_OBJC },
 294   { "end",              RID_AT_END,             D_OBJC },
 295   { "implementation",   RID_AT_IMPLEMENTATION,  D_OBJC },
 296   { "interface",        RID_AT_INTERFACE,       D_OBJC },
 297   { "protocol",         RID_AT_PROTOCOL,        D_OBJC },
 298   { "selector",         RID_AT_SELECTOR,        D_OBJC },
 299   { "finally",          RID_AT_FINALLY,         D_OBJC },
 300   { "synchronized",     RID_AT_SYNCHRONIZED,    D_OBJC },
 301   /* These are recognized only in protocol-qualifier context.  */
 302   { "bycopy",           RID_BYCOPY,             D_OBJC },
 303   { "byref",            RID_BYREF,              D_OBJC },
 304   { "in",               RID_IN,                 D_OBJC },
 305   { "inout",            RID_INOUT,              D_OBJC },
 306   { "oneway",           RID_ONEWAY,             D_OBJC },
 307   { "out",              RID_OUT,                D_OBJC },
 308 };
 309
 310 void
 311 init_reswords (void)
 312 {
 313   unsigned int i;
 314   tree id;
 315   int mask = ((flag_no_asm ? D_ASM : 0)
 316               | D_OBJC
 317               | (flag_no_gnu_keywords ? D_EXT : 0));
 318
 319   ridpointers = ggc_calloc ((int) RID_MAX, sizeof (tree));
 320   for (i = 0; i < ARRAY_SIZE (reswords); i++)
 321     {
 322       id = get_identifier (reswords[i].word);
 323       C_RID_CODE (id) = reswords[i].rid;
 324       ridpointers [(int) reswords[i].rid] = id;
 325       if (! (reswords[i].disable & mask))
 326         C_IS_RESERVED_WORD (id) = 1;
 327     }
 328 }
 329
 330 static void
 331 init_cp_pragma (void)
 332 {
 333   c_register_pragma (0, "vtable", handle_pragma_vtable);
 334   c_register_pragma (0, "unit", handle_pragma_unit);
 335   c_register_pragma (0, "interface", handle_pragma_interface);
 336   c_register_pragma (0, "implementation", handle_pragma_implementation);
 337   c_register_pragma ("GCC", "interface", handle_pragma_interface);
 338   c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
 339   c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
 340 }
 341 \f
 342 /* TRUE if a code represents a statement.  */
 343
 344 bool statement_code_p[MAX_TREE_CODES];
 345
 346 /* Initialize the C++ front end.  This function is very sensitive to
 347    the exact order that things are done here.  It would be nice if the
 348    initialization done by this routine were moved to its subroutines,
 349    and the ordering dependencies clarified and reduced.  */
 350 bool
 351 cxx_init (void)
 352 {
 353   unsigned int i;
 354   static const enum tree_code stmt_codes[] = {
 355    CTOR_INITIALIZER,    TRY_BLOCK,      HANDLER,
 356    EH_SPEC_BLOCK,       USING_STMT,     TAG_DEFN,
 357    IF_STMT,             CLEANUP_STMT,   FOR_STMT,
 358    WHILE_STMT,          DO_STMT,        BREAK_STMT,
 359    CONTINUE_STMT,       SWITCH_STMT,    EXPR_STMT
 360   };
 361
 362   memset (&statement_code_p, 0, sizeof (statement_code_p));
 363   for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
 364     statement_code_p[stmt_codes[i]] = true;
 365
 366   /* We cannot just assign to input_filename because it has already
 367      been initialized and will be used later as an N_BINCL for stabs+
 368      debugging.  */
 369 #ifdef USE_MAPPED_LOCATION
 370   push_srcloc (BUILTINS_LOCATION);
 371 #else
 372   push_srcloc ("<built-in>", 0);
 373 #endif
 374
 375   init_reswords ();
 376   init_tree ();
 377   init_cp_semantics ();
 378   init_operators ();
 379   init_method ();
 380   init_error ();
 381
 382   current_function_decl = NULL;
 383
 384   class_type_node = ridpointers[(int) RID_CLASS];
 385
 386   cxx_init_decl_processing ();
 387
 388   /* The fact that G++ uses COMDAT for many entities (inline
 389      functions, template instantiations, virtual tables, etc.) mean
 390      that it is fundamentally unreliable to try to make decisions
 391      about whether or not to output a particular entity until the end
 392      of the compilation.  However, the inliner requires that functions
 393      be provided to the back end if they are to be inlined.
 394      Therefore, we always use unit-at-a-time mode; in that mode, we
 395      can provide entities to the back end and it will decide what to
 396      emit based on what is actually needed.  */
 397   flag_unit_at_a_time = 1;
 398
 399   if (c_common_init () == false)
 400     {
 401       pop_srcloc();
 402       return false;
 403     }
 404
 405   init_cp_pragma ();
 406
 407   init_repo ();
 408
 409   pop_srcloc();
 410   return true;
 411 }
 412 \f
 413 /* Return nonzero if S is not considered part of an
 414    INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
 415
 416 static int
 417 interface_strcmp (const char* s)
 418 {
 419   /* Set the interface/implementation bits for this scope.  */
 420   struct impl_files *ifiles;
 421   const char *s1;
 422
 423   for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
 424     {
 425       const char *t1 = ifiles->filename;
 426       s1 = s;
 427
 428       if (*s1 != *t1 || *s1 == 0)
 429         continue;
 430
 431       while (*s1 == *t1 && *s1 != 0)
 432         s1++, t1++;
 433
 434       /* A match.  */
 435       if (*s1 == *t1)
 436         return 0;
 437
 438       /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
 439       if (strchr (s1, '.') || strchr (t1, '.'))
 440         continue;
 441
 442       if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
 443         continue;
 444
 445       /* A match.  */
 446       return 0;
 447     }
 448
 449   /* No matches.  */
 450   return 1;
 451 }
 452
 453 \f
 454
 455 /* Parse a #pragma whose sole argument is a string constant.
 456    If OPT is true, the argument is optional.  */
 457 static tree
 458 parse_strconst_pragma (const char* name, int opt)
 459 {
 460   tree result, x;
 461   enum cpp_ttype t;
 462
 463   t = c_lex (&x);
 464   if (t == CPP_STRING)
 465     {
 466       result = x;
 467       if (c_lex (&x) != CPP_EOF)
 468         warning (0, "junk at end of #pragma %s", name);
 469       return result;
 470     }
 471
 472   if (t == CPP_EOF && opt)
 473     return 0;
 474
 475   error ("invalid #pragma %s", name);
 476   return (tree)-1;
 477 }
 478
 479 static void
 480 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
 481 {
 482   parse_strconst_pragma ("vtable", 0);
 483   sorry ("#pragma vtable no longer supported");
 484 }
 485
 486 static void
 487 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
 488 {
 489   /* Validate syntax, but don't do anything.  */
 490   parse_strconst_pragma ("unit", 0);
 491 }
 492
 493 static void
 494 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
 495 {
 496   tree fname = parse_strconst_pragma ("interface", 1);
 497   struct c_fileinfo *finfo;
 498   const char *filename;
 499
 500   if (fname == (tree)-1)
 501     return;
 502   else if (fname == 0)
 503     filename = lbasename (input_filename);
 504   else
 505     filename = ggc_strdup (TREE_STRING_POINTER (fname));
 506
 507   finfo = get_fileinfo (filename);
 508
 509   if (impl_file_chain == 0)
 510     {
 511       /* If this is zero at this point, then we are
 512          auto-implementing.  */
 513       if (main_input_filename == 0)
 514         main_input_filename = input_filename;
 515     }
 516
 517   finfo->interface_only = interface_strcmp (filename);
 518   /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
 519      a definition in another file.  */
 520   if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
 521     finfo->interface_unknown = 0;
 522 }
 523
 524 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
 525    We used to only allow this at toplevel, but that restriction was buggy
 526    in older compilers and it seems reasonable to allow it in the headers
 527    themselves, too.  It only needs to precede the matching #p interface.
 528
 529    We don't touch finfo->interface_only or finfo->interface_unknown;
 530    the user must specify a matching #p interface for this to have
 531    any effect.  */
 532
 533 static void
 534 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
 535 {
 536   tree fname = parse_strconst_pragma ("implementation", 1);
 537   const char *filename;
 538   struct impl_files *ifiles = impl_file_chain;
 539
 540   if (fname == (tree)-1)
 541     return;
 542
 543   if (fname == 0)
 544     {
 545       if (main_input_filename)
 546         filename = main_input_filename;
 547       else
 548         filename = input_filename;
 549       filename = lbasename (filename);
 550     }
 551   else
 552     {
 553       filename = ggc_strdup (TREE_STRING_POINTER (fname));
 554 #if 0
 555       /* We currently cannot give this diagnostic, as we reach this point
 556          only after cpplib has scanned the entire translation unit, so
 557          cpp_included always returns true.  A plausible fix is to compare
 558          the current source-location cookie with the first source-location
 559          cookie (if any) of the filename, but this requires completing the
 560          --enable-mapped-location project first.  See PR 17577.  */
 561       if (cpp_included (parse_in, filename))
 562         warning (0, "#pragma implementation for %qs appears after "
 563                  "file is included", filename);
 564 #endif
 565     }
 566
 567   for (; ifiles; ifiles = ifiles->next)
 568     {
 569       if (! strcmp (ifiles->filename, filename))
 570         break;
 571     }
 572   if (ifiles == 0)
 573     {
 574       ifiles = xmalloc (sizeof (struct impl_files));
 575       ifiles->filename = filename;
 576       ifiles->next = impl_file_chain;
 577       impl_file_chain = ifiles;
 578     }
 579 }
 580
 581 /* Indicate that this file uses Java-personality exception handling.  */
 582 static void
 583 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED )
 584 {
 585   tree x;
 586   if (c_lex (&x) != CPP_EOF)
 587     warning (0, "junk at end of #pragma GCC java_exceptions");
 588
 589   choose_personality_routine (lang_java);
 590 }
 591
 592 /* Issue an error message indicating that the lookup of NAME (an
 593    IDENTIFIER_NODE) failed.  Returns the ERROR_MARK_NODE.  */
 594
 595 tree
 596 unqualified_name_lookup_error (tree name)
 597 {
 598   if (IDENTIFIER_OPNAME_P (name))
 599     {
 600       if (name != ansi_opname (ERROR_MARK))
 601         error ("%qD not defined", name);
 602     }
 603   else
 604     {
 605       error ("%qD was not declared in this scope", name);
 606       /* Prevent repeated error messages by creating a VAR_DECL with
 607          this NAME in the innermost block scope.  */
 608       if (current_function_decl)
 609         {
 610           tree decl;
 611           decl = build_decl (VAR_DECL, name, error_mark_node);
 612           DECL_CONTEXT (decl) = current_function_decl;
 613           push_local_binding (name, decl, 0);
 614           /* Mark the variable as used so that we do not get warnings
 615              about it being unused later.  */
 616           TREE_USED (decl) = 1;
 617         }
 618     }
 619
 620   return error_mark_node;
 621 }
 622
 623 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
 624    used as a function.  Returns an appropriate expression for
 625    NAME.  */
 626
 627 tree
 628 unqualified_fn_lookup_error (tree name)
 629 {
 630   if (processing_template_decl)
 631     {
 632       /* In a template, it is invalid to write "f()" or "f(3)" if no
 633          declaration of "f" is available.  Historically, G++ and most
 634          other compilers accepted that usage since they deferred all name
 635          lookup until instantiation time rather than doing unqualified
 636          name lookup at template definition time; explain to the user what
 637          is going wrong.
 638
 639          Note that we have the exact wording of the following message in
 640          the manual (trouble.texi, node "Name lookup"), so they need to
 641          be kept in synch.  */
 642       pedwarn ("there are no arguments to %qD that depend on a template "
 643                "parameter, so a declaration of %qD must be available",
 644                name, name);
 645
 646       if (!flag_permissive)
 647         {
 648           static bool hint;
 649           if (!hint)
 650             {
 651               error ("(if you use %<-fpermissive%>, G++ will accept your "
 652                      "code, but allowing the use of an undeclared name is "
 653                      "deprecated)");
 654               hint = true;
 655             }
 656         }
 657       return name;
 658     }
 659
 660   return unqualified_name_lookup_error (name);
 661 }
 662
 663 tree
 664 build_lang_decl (enum tree_code code, tree name, tree type)
 665 {
 666   tree t;
 667
 668   t = build_decl (code, name, type);
 669   retrofit_lang_decl (t);
 670
 671   /* All nesting of C++ functions is lexical; there is never a "static
 672      chain" in the sense of GNU C nested functions.  */
 673   if (code == FUNCTION_DECL)
 674     DECL_NO_STATIC_CHAIN (t) = 1;
 675
 676   return t;
 677 }
 678
 679 /* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
 680    and pushdecl (for functions generated by the backend).  */
 681
 682 void
 683 retrofit_lang_decl (tree t)
 684 {
 685   struct lang_decl *ld;
 686   size_t size;
 687
 688   if (CAN_HAVE_FULL_LANG_DECL_P (t))
 689     size = sizeof (struct lang_decl);
 690   else
 691     size = sizeof (struct lang_decl_flags);
 692
 693   ld = GGC_CNEWVAR (struct lang_decl, size);
 694
 695   ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
 696   ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
 697   ld->decl_flags.u2sel = 0;
 698   if (ld->decl_flags.can_be_full)
 699     ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
 700
 701   DECL_LANG_SPECIFIC (t) = ld;
 702   if (current_lang_name == lang_name_cplusplus
 703       || decl_linkage (t) == lk_none)
 704     SET_DECL_LANGUAGE (t, lang_cplusplus);
 705   else if (current_lang_name == lang_name_c)
 706     SET_DECL_LANGUAGE (t, lang_c);
 707   else if (current_lang_name == lang_name_java)
 708     SET_DECL_LANGUAGE (t, lang_java);
 709   else
 710     gcc_unreachable ();
 711
 712 #ifdef GATHER_STATISTICS
 713   tree_node_counts[(int)lang_decl] += 1;
 714   tree_node_sizes[(int)lang_decl] += size;
 715 #endif
 716 }
 717
 718 void
 719 cxx_dup_lang_specific_decl (tree node)
 720 {
 721   int size;
 722   struct lang_decl *ld;
 723
 724   if (! DECL_LANG_SPECIFIC (node))
 725     return;
 726
 727   if (!CAN_HAVE_FULL_LANG_DECL_P (node))
 728     size = sizeof (struct lang_decl_flags);
 729   else
 730     size = sizeof (struct lang_decl);
 731   ld = GGC_NEWVAR (struct lang_decl, size);
 732   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
 733   DECL_LANG_SPECIFIC (node) = ld;
 734
 735 #ifdef GATHER_STATISTICS
 736   tree_node_counts[(int)lang_decl] += 1;
 737   tree_node_sizes[(int)lang_decl] += size;
 738 #endif
 739 }
 740
 741 /* Copy DECL, including any language-specific parts.  */
 742
 743 tree
 744 copy_decl (tree decl)
 745 {
 746   tree copy;
 747
 748   copy = copy_node (decl);
 749   cxx_dup_lang_specific_decl (copy);
 750   return copy;
 751 }
 752
 753 /* Replace the shared language-specific parts of NODE with a new copy.  */
 754
 755 static void
 756 copy_lang_type (tree node)
 757 {
 758   int size;
 759   struct lang_type *lt;
 760
 761   if (! TYPE_LANG_SPECIFIC (node))
 762     return;
 763
 764   if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
 765     size = sizeof (struct lang_type);
 766   else
 767     size = sizeof (struct lang_type_ptrmem);
 768   lt = GGC_NEWVAR (struct lang_type, size);
 769   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
 770   TYPE_LANG_SPECIFIC (node) = lt;
 771
 772 #ifdef GATHER_STATISTICS
 773   tree_node_counts[(int)lang_type] += 1;
 774   tree_node_sizes[(int)lang_type] += size;
 775 #endif
 776 }
 777
 778 /* Copy TYPE, including any language-specific parts.  */
 779
 780 tree
 781 copy_type (tree type)
 782 {
 783   tree copy;
 784
 785   copy = copy_node (type);
 786   copy_lang_type (copy);
 787   return copy;
 788 }
 789
 790 tree
 791 cxx_make_type (enum tree_code code)
 792 {
 793   tree t = make_node (code);
 794
 795   /* Create lang_type structure.  */
 796   if (IS_AGGR_TYPE_CODE (code)
 797       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
 798     {
 799       struct lang_type *pi = GGC_CNEW (struct lang_type);
 800
 801       TYPE_LANG_SPECIFIC (t) = pi;
 802       pi->u.c.h.is_lang_type_class = 1;
 803
 804 #ifdef GATHER_STATISTICS
 805       tree_node_counts[(int)lang_type] += 1;
 806       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
 807 #endif
 808     }
 809
 810   /* Set up some flags that give proper default behavior.  */
 811   if (IS_AGGR_TYPE_CODE (code))
 812     {
 813       struct c_fileinfo *finfo = get_fileinfo (lbasename (input_filename));
 814       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
 815       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
 816     }
 817
 818   return t;
 819 }
 820
 821 tree
 822 make_aggr_type (enum tree_code code)
 823 {
 824   tree t = cxx_make_type (code);
 825
 826   if (IS_AGGR_TYPE_CODE (code))
 827     SET_IS_AGGR_TYPE (t, 1);
 828
 829   return t;
 830 }