contrib/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_CNEWVEC (tree, (int) RID_MAX);
 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 = pragma_lex (&result);
 464   if (t == CPP_STRING)
 465     {
 466       if (pragma_lex (&x) != CPP_EOF)
 467         warning (0, "junk at end of #pragma %s", name);
 468       return result;
 469     }
 470
 471   if (t == CPP_EOF && opt)
 472     return NULL_TREE;
 473
 474   error ("invalid #pragma %s", name);
 475   return error_mark_node;
 476 }
 477
 478 static void
 479 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
 480 {
 481   parse_strconst_pragma ("vtable", 0);
 482   sorry ("#pragma vtable no longer supported");
 483 }
 484
 485 static void
 486 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
 487 {
 488   /* Validate syntax, but don't do anything.  */
 489   parse_strconst_pragma ("unit", 0);
 490 }
 491
 492 static void
 493 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
 494 {
 495   tree fname = parse_strconst_pragma ("interface", 1);
 496   struct c_fileinfo *finfo;
 497   const char *filename;
 498
 499   if (fname == error_mark_node)
 500     return;
 501   else if (fname == 0)
 502     filename = lbasename (input_filename);
 503   else
 504     filename = ggc_strdup (TREE_STRING_POINTER (fname));
 505
 506   finfo = get_fileinfo (input_filename);
 507
 508   if (impl_file_chain == 0)
 509     {
 510       /* If this is zero at this point, then we are
 511          auto-implementing.  */
 512       if (main_input_filename == 0)
 513         main_input_filename = input_filename;
 514     }
 515
 516   finfo->interface_only = interface_strcmp (filename);
 517   /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
 518      a definition in another file.  */
 519   if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
 520     finfo->interface_unknown = 0;
 521 }
 522
 523 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
 524    We used to only allow this at toplevel, but that restriction was buggy
 525    in older compilers and it seems reasonable to allow it in the headers
 526    themselves, too.  It only needs to precede the matching #p interface.
 527
 528    We don't touch finfo->interface_only or finfo->interface_unknown;
 529    the user must specify a matching #p interface for this to have
 530    any effect.  */
 531
 532 static void
 533 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
 534 {
 535   tree fname = parse_strconst_pragma ("implementation", 1);
 536   const char *filename;
 537   struct impl_files *ifiles = impl_file_chain;
 538
 539   if (fname == error_mark_node)
 540     return;
 541
 542   if (fname == 0)
 543     {
 544       if (main_input_filename)
 545         filename = main_input_filename;
 546       else
 547         filename = input_filename;
 548       filename = lbasename (filename);
 549     }
 550   else
 551     {
 552       filename = ggc_strdup (TREE_STRING_POINTER (fname));
 553 #if 0
 554       /* We currently cannot give this diagnostic, as we reach this point
 555          only after cpplib has scanned the entire translation unit, so
 556          cpp_included always returns true.  A plausible fix is to compare
 557          the current source-location cookie with the first source-location
 558          cookie (if any) of the filename, but this requires completing the
 559          --enable-mapped-location project first.  See PR 17577.  */
 560       if (cpp_included (parse_in, filename))
 561         warning (0, "#pragma implementation for %qs appears after "
 562                  "file is included", filename);
 563 #endif
 564     }
 565
 566   for (; ifiles; ifiles = ifiles->next)
 567     {
 568       if (! strcmp (ifiles->filename, filename))
 569         break;
 570     }
 571   if (ifiles == 0)
 572     {
 573       ifiles = XNEW (struct impl_files);
 574       ifiles->filename = filename;
 575       ifiles->next = impl_file_chain;
 576       impl_file_chain = ifiles;
 577     }
 578 }
 579
 580 /* Indicate that this file uses Java-personality exception handling.  */
 581 static void
 582 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED)
 583 {
 584   tree x;
 585   if (pragma_lex (&x) != CPP_EOF)
 586     warning (0, "junk at end of #pragma GCC java_exceptions");
 587
 588   choose_personality_routine (lang_java);
 589 }
 590
 591 /* Issue an error message indicating that the lookup of NAME (an
 592    IDENTIFIER_NODE) failed.  Returns the ERROR_MARK_NODE.  */
 593
 594 tree
 595 unqualified_name_lookup_error (tree name)
 596 {
 597   if (IDENTIFIER_OPNAME_P (name))
 598     {
 599       if (name != ansi_opname (ERROR_MARK))
 600         error ("%qD not defined", name);
 601     }
 602   else
 603     {
 604       error ("%qD was not declared in this scope", name);
 605       /* Prevent repeated error messages by creating a VAR_DECL with
 606          this NAME in the innermost block scope.  */
 607       if (current_function_decl)
 608         {
 609           tree decl;
 610           decl = build_decl (VAR_DECL, name, error_mark_node);
 611           DECL_CONTEXT (decl) = current_function_decl;
 612           push_local_binding (name, decl, 0);
 613           /* Mark the variable as used so that we do not get warnings
 614              about it being unused later.  */
 615           TREE_USED (decl) = 1;
 616         }
 617     }
 618
 619   return error_mark_node;
 620 }
 621
 622 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
 623    used as a function.  Returns an appropriate expression for
 624    NAME.  */
 625
 626 tree
 627 unqualified_fn_lookup_error (tree name)
 628 {
 629   if (processing_template_decl)
 630     {
 631       /* In a template, it is invalid to write "f()" or "f(3)" if no
 632          declaration of "f" is available.  Historically, G++ and most
 633          other compilers accepted that usage since they deferred all name
 634          lookup until instantiation time rather than doing unqualified
 635          name lookup at template definition time; explain to the user what
 636          is going wrong.
 637
 638          Note that we have the exact wording of the following message in
 639          the manual (trouble.texi, node "Name lookup"), so they need to
 640          be kept in synch.  */
 641       pedwarn ("there are no arguments to %qD that depend on a template "
 642                "parameter, so a declaration of %qD must be available",
 643                name, name);
 644
 645       if (!flag_permissive)
 646         {
 647           static bool hint;
 648           if (!hint)
 649             {
 650               error ("(if you use %<-fpermissive%>, G++ will accept your "
 651                      "code, but allowing the use of an undeclared name is "
 652                      "deprecated)");
 653               hint = true;
 654             }
 655         }
 656       return name;
 657     }
 658
 659   return unqualified_name_lookup_error (name);
 660 }
 661
 662 tree
 663 build_lang_decl (enum tree_code code, tree name, tree type)
 664 {
 665   tree t;
 666
 667   t = build_decl (code, name, type);
 668   retrofit_lang_decl (t);
 669
 670   /* All nesting of C++ functions is lexical; there is never a "static
 671      chain" in the sense of GNU C nested functions.  */
 672   if (code == FUNCTION_DECL)
 673     DECL_NO_STATIC_CHAIN (t) = 1;
 674
 675   return t;
 676 }
 677
 678 /* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
 679    and pushdecl (for functions generated by the backend).  */
 680
 681 void
 682 retrofit_lang_decl (tree t)
 683 {
 684   struct lang_decl *ld;
 685   size_t size;
 686
 687   if (CAN_HAVE_FULL_LANG_DECL_P (t))
 688     size = sizeof (struct lang_decl);
 689   else
 690     size = sizeof (struct lang_decl_flags);
 691
 692   ld = GGC_CNEWVAR (struct lang_decl, size);
 693
 694   ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
 695   ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
 696   ld->decl_flags.u2sel = 0;
 697   if (ld->decl_flags.can_be_full)
 698     ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
 699
 700   DECL_LANG_SPECIFIC (t) = ld;
 701   if (current_lang_name == lang_name_cplusplus
 702       || decl_linkage (t) == lk_none)
 703     SET_DECL_LANGUAGE (t, lang_cplusplus);
 704   else if (current_lang_name == lang_name_c)
 705     SET_DECL_LANGUAGE (t, lang_c);
 706   else if (current_lang_name == lang_name_java)
 707     SET_DECL_LANGUAGE (t, lang_java);
 708   else
 709     gcc_unreachable ();
 710
 711 #ifdef GATHER_STATISTICS
 712   tree_node_counts[(int)lang_decl] += 1;
 713   tree_node_sizes[(int)lang_decl] += size;
 714 #endif
 715 }
 716
 717 void
 718 cxx_dup_lang_specific_decl (tree node)
 719 {
 720   int size;
 721   struct lang_decl *ld;
 722
 723   if (! DECL_LANG_SPECIFIC (node))
 724     return;
 725
 726   if (!CAN_HAVE_FULL_LANG_DECL_P (node))
 727     size = sizeof (struct lang_decl_flags);
 728   else
 729     size = sizeof (struct lang_decl);
 730   ld = GGC_NEWVAR (struct lang_decl, size);
 731   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
 732   DECL_LANG_SPECIFIC (node) = ld;
 733
 734 #ifdef GATHER_STATISTICS
 735   tree_node_counts[(int)lang_decl] += 1;
 736   tree_node_sizes[(int)lang_decl] += size;
 737 #endif
 738 }
 739
 740 /* Copy DECL, including any language-specific parts.  */
 741
 742 tree
 743 copy_decl (tree decl)
 744 {
 745   tree copy;
 746
 747   copy = copy_node (decl);
 748   cxx_dup_lang_specific_decl (copy);
 749   return copy;
 750 }
 751
 752 /* Replace the shared language-specific parts of NODE with a new copy.  */
 753
 754 static void
 755 copy_lang_type (tree node)
 756 {
 757   int size;
 758   struct lang_type *lt;
 759
 760   if (! TYPE_LANG_SPECIFIC (node))
 761     return;
 762
 763   if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
 764     size = sizeof (struct lang_type);
 765   else
 766     size = sizeof (struct lang_type_ptrmem);
 767   lt = GGC_NEWVAR (struct lang_type, size);
 768   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
 769   TYPE_LANG_SPECIFIC (node) = lt;
 770
 771 #ifdef GATHER_STATISTICS
 772   tree_node_counts[(int)lang_type] += 1;
 773   tree_node_sizes[(int)lang_type] += size;
 774 #endif
 775 }
 776
 777 /* Copy TYPE, including any language-specific parts.  */
 778
 779 tree
 780 copy_type (tree type)
 781 {
 782   tree copy;
 783
 784   copy = copy_node (type);
 785   copy_lang_type (copy);
 786   return copy;
 787 }
 788
 789 tree
 790 cxx_make_type (enum tree_code code)
 791 {
 792   tree t = make_node (code);
 793
 794   /* Create lang_type structure.  */
 795   if (IS_AGGR_TYPE_CODE (code)
 796       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
 797     {
 798       struct lang_type *pi = GGC_CNEW (struct lang_type);
 799
 800       TYPE_LANG_SPECIFIC (t) = pi;
 801       pi->u.c.h.is_lang_type_class = 1;
 802
 803 #ifdef GATHER_STATISTICS
 804       tree_node_counts[(int)lang_type] += 1;
 805       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
 806 #endif
 807     }
 808
 809   /* Set up some flags that give proper default behavior.  */
 810   if (IS_AGGR_TYPE_CODE (code))
 811     {
 812       struct c_fileinfo *finfo = get_fileinfo (input_filename);
 813       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
 814       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
 815     }
 816
 817   return t;
 818 }
 819
 820 tree
 821 make_aggr_type (enum tree_code code)
 822 {
 823   tree t = cxx_make_type (code);
 824
 825   if (IS_AGGR_TYPE_CODE (code))
 826     SET_IS_AGGR_TYPE (t, 1);
 827
 828   return t;
 829 }
 830
 831 /* Returns true if we are currently in the main source file, or in a
 832    template instantiation started from the main source file.  */
 833
 834 bool
 835 in_main_input_context (void)
 836 {
 837   tree tl = outermost_tinst_level();
 838
 839   if (tl)
 840     return strcmp (main_input_filename,
 841                    LOCATION_FILE (TINST_LOCATION (tl))) == 0;
 842   else
 843     return strcmp (main_input_filename, input_filename) == 0;
 844 }