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, 2007
   4    Free Software Foundation, Inc.
   5    Hacked by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  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 #define D_CXX0X         0x08    /* C++0x only */
 180
 181 CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
 182
 183 static const struct resword reswords[] =
 184 {
 185   { "_Complex",         RID_COMPLEX,    0 },
 186   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
 187   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
 188   { "__alignof",        RID_ALIGNOF,    0 },
 189   { "__alignof__",      RID_ALIGNOF,    0 },
 190   { "__asm",            RID_ASM,        0 },
 191   { "__asm__",          RID_ASM,        0 },
 192   { "__attribute",      RID_ATTRIBUTE,  0 },
 193   { "__attribute__",    RID_ATTRIBUTE,  0 },
 194   { "__builtin_offsetof", RID_OFFSETOF, 0 },
 195   { "__builtin_va_arg", RID_VA_ARG,     0 },
 196   { "__complex",        RID_COMPLEX,    0 },
 197   { "__complex__",      RID_COMPLEX,    0 },
 198   { "__const",          RID_CONST,      0 },
 199   { "__const__",        RID_CONST,      0 },
 200   { "__decltype",       RID_DECLTYPE,   0 },
 201   { "__extension__",    RID_EXTENSION,  0 },
 202   { "__func__",         RID_C99_FUNCTION_NAME,  0 },
 203   { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, 0 },
 204   { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, 0 },
 205   { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, 0 },
 206   { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, 0 },
 207   { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, 0 },
 208   { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, 0 },
 209   { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, 0 },
 210   { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, 0 },
 211   { "__is_abstract",    RID_IS_ABSTRACT, 0 },
 212   { "__is_base_of",     RID_IS_BASE_OF, 0 },
 213   { "__is_class",       RID_IS_CLASS,   0 },
 214   { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, 0 },
 215   { "__is_empty",       RID_IS_EMPTY,   0 },
 216   { "__is_enum",        RID_IS_ENUM,    0 },
 217   { "__is_pod",         RID_IS_POD,     0 },
 218   { "__is_polymorphic", RID_IS_POLYMORPHIC, 0 },
 219   { "__is_union",       RID_IS_UNION,   0 },
 220   { "__imag",           RID_IMAGPART,   0 },
 221   { "__imag__",         RID_IMAGPART,   0 },
 222   { "__inline",         RID_INLINE,     0 },
 223   { "__inline__",       RID_INLINE,     0 },
 224   { "__label__",        RID_LABEL,      0 },
 225   { "__null",           RID_NULL,       0 },
 226   { "__real",           RID_REALPART,   0 },
 227   { "__real__",         RID_REALPART,   0 },
 228   { "__restrict",       RID_RESTRICT,   0 },
 229   { "__restrict__",     RID_RESTRICT,   0 },
 230   { "__signed",         RID_SIGNED,     0 },
 231   { "__signed__",       RID_SIGNED,     0 },
 232   { "__thread",         RID_THREAD,     0 },
 233   { "__typeof",         RID_TYPEOF,     0 },
 234   { "__typeof__",       RID_TYPEOF,     0 },
 235   { "__volatile",       RID_VOLATILE,   0 },
 236   { "__volatile__",     RID_VOLATILE,   0 },
 237   { "asm",              RID_ASM,        D_ASM },
 238   { "auto",             RID_AUTO,       0 },
 239   { "bool",             RID_BOOL,       0 },
 240   { "break",            RID_BREAK,      0 },
 241   { "case",             RID_CASE,       0 },
 242   { "catch",            RID_CATCH,      0 },
 243   { "char",             RID_CHAR,       0 },
 244   { "class",            RID_CLASS,      0 },
 245   { "const",            RID_CONST,      0 },
 246   { "const_cast",       RID_CONSTCAST,  0 },
 247   { "continue",         RID_CONTINUE,   0 },
 248   { "decltype",         RID_DECLTYPE,   D_CXX0X },
 249   { "default",          RID_DEFAULT,    0 },
 250   { "delete",           RID_DELETE,     0 },
 251   { "do",               RID_DO,         0 },
 252   { "double",           RID_DOUBLE,     0 },
 253   { "dynamic_cast",     RID_DYNCAST,    0 },
 254   { "else",             RID_ELSE,       0 },
 255   { "enum",             RID_ENUM,       0 },
 256   { "explicit",         RID_EXPLICIT,   0 },
 257   { "export",           RID_EXPORT,     0 },
 258   { "extern",           RID_EXTERN,     0 },
 259   { "false",            RID_FALSE,      0 },
 260   { "float",            RID_FLOAT,      0 },
 261   { "for",              RID_FOR,        0 },
 262   { "friend",           RID_FRIEND,     0 },
 263   { "goto",             RID_GOTO,       0 },
 264   { "if",               RID_IF,         0 },
 265   { "inline",           RID_INLINE,     0 },
 266   { "int",              RID_INT,        0 },
 267   { "long",             RID_LONG,       0 },
 268   { "mutable",          RID_MUTABLE,    0 },
 269   { "namespace",        RID_NAMESPACE,  0 },
 270   { "new",              RID_NEW,        0 },
 271   { "operator",         RID_OPERATOR,   0 },
 272   { "private",          RID_PRIVATE,    0 },
 273   { "protected",        RID_PROTECTED,  0 },
 274   { "public",           RID_PUBLIC,     0 },
 275   { "register",         RID_REGISTER,   0 },
 276   { "reinterpret_cast", RID_REINTCAST,  0 },
 277   { "return",           RID_RETURN,     0 },
 278   { "short",            RID_SHORT,      0 },
 279   { "signed",           RID_SIGNED,     0 },
 280   { "sizeof",           RID_SIZEOF,     0 },
 281   { "static",           RID_STATIC,     0 },
 282   { "static_assert",    RID_STATIC_ASSERT, D_CXX0X },
 283   { "static_cast",      RID_STATCAST,   0 },
 284   { "struct",           RID_STRUCT,     0 },
 285   { "switch",           RID_SWITCH,     0 },
 286   { "template",         RID_TEMPLATE,   0 },
 287   { "this",             RID_THIS,       0 },
 288   { "throw",            RID_THROW,      0 },
 289   { "true",             RID_TRUE,       0 },
 290   { "try",              RID_TRY,        0 },
 291   { "typedef",          RID_TYPEDEF,    0 },
 292   { "typename",         RID_TYPENAME,   0 },
 293   { "typeid",           RID_TYPEID,     0 },
 294   { "typeof",           RID_TYPEOF,     D_ASM|D_EXT },
 295   { "union",            RID_UNION,      0 },
 296   { "unsigned",         RID_UNSIGNED,   0 },
 297   { "using",            RID_USING,      0 },
 298   { "virtual",          RID_VIRTUAL,    0 },
 299   { "void",             RID_VOID,       0 },
 300   { "volatile",         RID_VOLATILE,   0 },
 301   { "wchar_t",          RID_WCHAR,      0 },
 302   { "while",            RID_WHILE,      0 },
 303
 304   /* The remaining keywords are specific to Objective-C++.  NB:
 305      All of them will remain _disabled_, since they are context-
 306      sensitive.  */
 307
 308   /* These ObjC keywords are recognized only immediately after
 309      an '@'.  NB: The following C++ keywords double as
 310      ObjC keywords in this context: RID_CLASS, RID_PRIVATE,
 311      RID_PROTECTED, RID_PUBLIC, RID_THROW, RID_TRY and RID_CATCH.  */
 312   { "compatibility_alias", RID_AT_ALIAS,        D_OBJC },
 313   { "defs",             RID_AT_DEFS,            D_OBJC },
 314   { "encode",           RID_AT_ENCODE,          D_OBJC },
 315   { "end",              RID_AT_END,             D_OBJC },
 316   { "implementation",   RID_AT_IMPLEMENTATION,  D_OBJC },
 317   { "interface",        RID_AT_INTERFACE,       D_OBJC },
 318   { "protocol",         RID_AT_PROTOCOL,        D_OBJC },
 319   { "selector",         RID_AT_SELECTOR,        D_OBJC },
 320   { "finally",          RID_AT_FINALLY,         D_OBJC },
 321   { "synchronized",     RID_AT_SYNCHRONIZED,    D_OBJC },
 322   /* These are recognized only in protocol-qualifier context.  */
 323   { "bycopy",           RID_BYCOPY,             D_OBJC },
 324   { "byref",            RID_BYREF,              D_OBJC },
 325   { "in",               RID_IN,                 D_OBJC },
 326   { "inout",            RID_INOUT,              D_OBJC },
 327   { "oneway",           RID_ONEWAY,             D_OBJC },
 328   { "out",              RID_OUT,                D_OBJC },
 329 };
 330
 331 void
 332 init_reswords (void)
 333 {
 334   unsigned int i;
 335   tree id;
 336   int mask = ((flag_no_asm ? D_ASM : 0)
 337               | D_OBJC
 338               | (flag_no_gnu_keywords ? D_EXT : 0)
 339               | ((cxx_dialect == cxx0x) ? 0 : D_CXX0X));
 340
 341   ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
 342   for (i = 0; i < ARRAY_SIZE (reswords); i++)
 343     {
 344       id = get_identifier (reswords[i].word);
 345       C_RID_CODE (id) = reswords[i].rid;
 346       ridpointers [(int) reswords[i].rid] = id;
 347       if (! (reswords[i].disable & mask))
 348         C_IS_RESERVED_WORD (id) = 1;
 349     }
 350 }
 351
 352 static void
 353 init_cp_pragma (void)
 354 {
 355   c_register_pragma (0, "vtable", handle_pragma_vtable);
 356   c_register_pragma (0, "unit", handle_pragma_unit);
 357   c_register_pragma (0, "interface", handle_pragma_interface);
 358   c_register_pragma (0, "implementation", handle_pragma_implementation);
 359   c_register_pragma ("GCC", "interface", handle_pragma_interface);
 360   c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
 361   c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
 362 }
 363 \f
 364 /* TRUE if a code represents a statement.  */
 365
 366 bool statement_code_p[MAX_TREE_CODES];
 367
 368 /* Initialize the C++ front end.  This function is very sensitive to
 369    the exact order that things are done here.  It would be nice if the
 370    initialization done by this routine were moved to its subroutines,
 371    and the ordering dependencies clarified and reduced.  */
 372 bool
 373 cxx_init (void)
 374 {
 375   unsigned int i;
 376   static const enum tree_code stmt_codes[] = {
 377    CTOR_INITIALIZER,    TRY_BLOCK,      HANDLER,
 378    EH_SPEC_BLOCK,       USING_STMT,     TAG_DEFN,
 379    IF_STMT,             CLEANUP_STMT,   FOR_STMT,
 380    WHILE_STMT,          DO_STMT,        BREAK_STMT,
 381    CONTINUE_STMT,       SWITCH_STMT,    EXPR_STMT
 382   };
 383
 384   memset (&statement_code_p, 0, sizeof (statement_code_p));
 385   for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
 386     statement_code_p[stmt_codes[i]] = true;
 387
 388   /* We cannot just assign to input_filename because it has already
 389      been initialized and will be used later as an N_BINCL for stabs+
 390      debugging.  */
 391 #ifdef USE_MAPPED_LOCATION
 392   push_srcloc (BUILTINS_LOCATION);
 393 #else
 394   push_srcloc ("<built-in>", 0);
 395 #endif
 396
 397   init_reswords ();
 398   init_tree ();
 399   init_cp_semantics ();
 400   init_operators ();
 401   init_method ();
 402   init_error ();
 403
 404   current_function_decl = NULL;
 405
 406   class_type_node = ridpointers[(int) RID_CLASS];
 407
 408   cxx_init_decl_processing ();
 409
 410   /* The fact that G++ uses COMDAT for many entities (inline
 411      functions, template instantiations, virtual tables, etc.) mean
 412      that it is fundamentally unreliable to try to make decisions
 413      about whether or not to output a particular entity until the end
 414      of the compilation.  However, the inliner requires that functions
 415      be provided to the back end if they are to be inlined.
 416      Therefore, we always use unit-at-a-time mode; in that mode, we
 417      can provide entities to the back end and it will decide what to
 418      emit based on what is actually needed.  */
 419   flag_unit_at_a_time = 1;
 420
 421   if (c_common_init () == false)
 422     {
 423       pop_srcloc();
 424       return false;
 425     }
 426
 427   init_cp_pragma ();
 428
 429   init_repo ();
 430
 431   pop_srcloc();
 432   return true;
 433 }
 434 \f
 435 /* Return nonzero if S is not considered part of an
 436    INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
 437
 438 static int
 439 interface_strcmp (const char* s)
 440 {
 441   /* Set the interface/implementation bits for this scope.  */
 442   struct impl_files *ifiles;
 443   const char *s1;
 444
 445   for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
 446     {
 447       const char *t1 = ifiles->filename;
 448       s1 = s;
 449
 450       if (*s1 != *t1 || *s1 == 0)
 451         continue;
 452
 453       while (*s1 == *t1 && *s1 != 0)
 454         s1++, t1++;
 455
 456       /* A match.  */
 457       if (*s1 == *t1)
 458         return 0;
 459
 460       /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
 461       if (strchr (s1, '.') || strchr (t1, '.'))
 462         continue;
 463
 464       if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
 465         continue;
 466
 467       /* A match.  */
 468       return 0;
 469     }
 470
 471   /* No matches.  */
 472   return 1;
 473 }
 474
 475 \f
 476
 477 /* Parse a #pragma whose sole argument is a string constant.
 478    If OPT is true, the argument is optional.  */
 479 static tree
 480 parse_strconst_pragma (const char* name, int opt)
 481 {
 482   tree result, x;
 483   enum cpp_ttype t;
 484
 485   t = pragma_lex (&result);
 486   if (t == CPP_STRING)
 487     {
 488       if (pragma_lex (&x) != CPP_EOF)
 489         warning (0, "junk at end of #pragma %s", name);
 490       return result;
 491     }
 492
 493   if (t == CPP_EOF && opt)
 494     return NULL_TREE;
 495
 496   error ("invalid #pragma %s", name);
 497   return error_mark_node;
 498 }
 499
 500 static void
 501 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
 502 {
 503   parse_strconst_pragma ("vtable", 0);
 504   sorry ("#pragma vtable no longer supported");
 505 }
 506
 507 static void
 508 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
 509 {
 510   /* Validate syntax, but don't do anything.  */
 511   parse_strconst_pragma ("unit", 0);
 512 }
 513
 514 static void
 515 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
 516 {
 517   tree fname = parse_strconst_pragma ("interface", 1);
 518   struct c_fileinfo *finfo;
 519   const char *filename;
 520
 521   if (fname == error_mark_node)
 522     return;
 523   else if (fname == 0)
 524     filename = lbasename (input_filename);
 525   else
 526     filename = ggc_strdup (TREE_STRING_POINTER (fname));
 527
 528   finfo = get_fileinfo (input_filename);
 529
 530   if (impl_file_chain == 0)
 531     {
 532       /* If this is zero at this point, then we are
 533          auto-implementing.  */
 534       if (main_input_filename == 0)
 535         main_input_filename = input_filename;
 536     }
 537
 538   finfo->interface_only = interface_strcmp (filename);
 539   /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
 540      a definition in another file.  */
 541   if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
 542     finfo->interface_unknown = 0;
 543 }
 544
 545 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
 546    We used to only allow this at toplevel, but that restriction was buggy
 547    in older compilers and it seems reasonable to allow it in the headers
 548    themselves, too.  It only needs to precede the matching #p interface.
 549
 550    We don't touch finfo->interface_only or finfo->interface_unknown;
 551    the user must specify a matching #p interface for this to have
 552    any effect.  */
 553
 554 static void
 555 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
 556 {
 557   tree fname = parse_strconst_pragma ("implementation", 1);
 558   const char *filename;
 559   struct impl_files *ifiles = impl_file_chain;
 560
 561   if (fname == error_mark_node)
 562     return;
 563
 564   if (fname == 0)
 565     {
 566       if (main_input_filename)
 567         filename = main_input_filename;
 568       else
 569         filename = input_filename;
 570       filename = lbasename (filename);
 571     }
 572   else
 573     {
 574       filename = ggc_strdup (TREE_STRING_POINTER (fname));
 575 #ifdef USE_MAPPED_LOCATION
 576       /* We currently cannot give this diagnostic, as we reach this point
 577          only after cpplib has scanned the entire translation unit, so
 578          cpp_included always returns true.  A plausible fix is to compare
 579          the current source-location cookie with the first source-location
 580          cookie (if any) of the filename, but this requires completing the
 581          --enable-mapped-location project first.  See PR 17577.  */
 582       if (cpp_included_before (parse_in, filename, input_location))
 583         warning (0, "#pragma implementation for %qs appears after "
 584                  "file is included", filename);
 585 #endif
 586     }
 587
 588   for (; ifiles; ifiles = ifiles->next)
 589     {
 590       if (! strcmp (ifiles->filename, filename))
 591         break;
 592     }
 593   if (ifiles == 0)
 594     {
 595       ifiles = XNEW (struct impl_files);
 596       ifiles->filename = filename;
 597       ifiles->next = impl_file_chain;
 598       impl_file_chain = ifiles;
 599     }
 600 }
 601
 602 /* Indicate that this file uses Java-personality exception handling.  */
 603 static void
 604 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED)
 605 {
 606   tree x;
 607   if (pragma_lex (&x) != CPP_EOF)
 608     warning (0, "junk at end of #pragma GCC java_exceptions");
 609
 610   choose_personality_routine (lang_java);
 611 }
 612
 613 /* Issue an error message indicating that the lookup of NAME (an
 614    IDENTIFIER_NODE) failed.  Returns the ERROR_MARK_NODE.  */
 615
 616 tree
 617 unqualified_name_lookup_error (tree name)
 618 {
 619   if (IDENTIFIER_OPNAME_P (name))
 620     {
 621       if (name != ansi_opname (ERROR_MARK))
 622         error ("%qD not defined", name);
 623     }
 624   else
 625     {
 626       error ("%qD was not declared in this scope", name);
 627       /* Prevent repeated error messages by creating a VAR_DECL with
 628          this NAME in the innermost block scope.  */
 629       if (current_function_decl)
 630         {
 631           tree decl;
 632           decl = build_decl (VAR_DECL, name, error_mark_node);
 633           DECL_CONTEXT (decl) = current_function_decl;
 634           push_local_binding (name, decl, 0);
 635           /* Mark the variable as used so that we do not get warnings
 636              about it being unused later.  */
 637           TREE_USED (decl) = 1;
 638         }
 639     }
 640
 641   return error_mark_node;
 642 }
 643
 644 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
 645    used as a function.  Returns an appropriate expression for
 646    NAME.  */
 647
 648 tree
 649 unqualified_fn_lookup_error (tree name)
 650 {
 651   if (processing_template_decl)
 652     {
 653       /* In a template, it is invalid to write "f()" or "f(3)" if no
 654          declaration of "f" is available.  Historically, G++ and most
 655          other compilers accepted that usage since they deferred all name
 656          lookup until instantiation time rather than doing unqualified
 657          name lookup at template definition time; explain to the user what
 658          is going wrong.
 659
 660          Note that we have the exact wording of the following message in
 661          the manual (trouble.texi, node "Name lookup"), so they need to
 662          be kept in synch.  */
 663       pedwarn ("there are no arguments to %qD that depend on a template "
 664                "parameter, so a declaration of %qD must be available",
 665                name, name);
 666
 667       if (!flag_permissive)
 668         {
 669           static bool hint;
 670           if (!hint)
 671             {
 672               error ("(if you use %<-fpermissive%>, G++ will accept your "
 673                      "code, but allowing the use of an undeclared name is "
 674                      "deprecated)");
 675               hint = true;
 676             }
 677         }
 678       return name;
 679     }
 680
 681   return unqualified_name_lookup_error (name);
 682 }
 683
 684 tree
 685 build_lang_decl (enum tree_code code, tree name, tree type)
 686 {
 687   tree t;
 688
 689   t = build_decl (code, name, type);
 690   retrofit_lang_decl (t);
 691
 692   /* All nesting of C++ functions is lexical; there is never a "static
 693      chain" in the sense of GNU C nested functions.  */
 694   if (code == FUNCTION_DECL)
 695     DECL_NO_STATIC_CHAIN (t) = 1;
 696
 697   return t;
 698 }
 699
 700 /* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
 701    and pushdecl (for functions generated by the back end).  */
 702
 703 void
 704 retrofit_lang_decl (tree t)
 705 {
 706   struct lang_decl *ld;
 707   size_t size;
 708
 709   if (CAN_HAVE_FULL_LANG_DECL_P (t))
 710     size = sizeof (struct lang_decl);
 711   else
 712     size = sizeof (struct lang_decl_flags);
 713
 714   ld = GGC_CNEWVAR (struct lang_decl, size);
 715
 716   ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
 717   ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
 718   ld->decl_flags.u2sel = 0;
 719   if (ld->decl_flags.can_be_full)
 720     ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
 721
 722   DECL_LANG_SPECIFIC (t) = ld;
 723   if (current_lang_name == lang_name_cplusplus
 724       || decl_linkage (t) == lk_none)
 725     SET_DECL_LANGUAGE (t, lang_cplusplus);
 726   else if (current_lang_name == lang_name_c)
 727     SET_DECL_LANGUAGE (t, lang_c);
 728   else if (current_lang_name == lang_name_java)
 729     SET_DECL_LANGUAGE (t, lang_java);
 730   else
 731     gcc_unreachable ();
 732
 733 #ifdef GATHER_STATISTICS
 734   tree_node_counts[(int)lang_decl] += 1;
 735   tree_node_sizes[(int)lang_decl] += size;
 736 #endif
 737 }
 738
 739 void
 740 cxx_dup_lang_specific_decl (tree node)
 741 {
 742   int size;
 743   struct lang_decl *ld;
 744
 745   if (! DECL_LANG_SPECIFIC (node))
 746     return;
 747
 748   if (!CAN_HAVE_FULL_LANG_DECL_P (node))
 749     size = sizeof (struct lang_decl_flags);
 750   else
 751     size = sizeof (struct lang_decl);
 752   ld = GGC_NEWVAR (struct lang_decl, size);
 753   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
 754   DECL_LANG_SPECIFIC (node) = ld;
 755
 756 #ifdef GATHER_STATISTICS
 757   tree_node_counts[(int)lang_decl] += 1;
 758   tree_node_sizes[(int)lang_decl] += size;
 759 #endif
 760 }
 761
 762 /* Copy DECL, including any language-specific parts.  */
 763
 764 tree
 765 copy_decl (tree decl)
 766 {
 767   tree copy;
 768
 769   copy = copy_node (decl);
 770   cxx_dup_lang_specific_decl (copy);
 771   return copy;
 772 }
 773
 774 /* Replace the shared language-specific parts of NODE with a new copy.  */
 775
 776 static void
 777 copy_lang_type (tree node)
 778 {
 779   int size;
 780   struct lang_type *lt;
 781
 782   if (! TYPE_LANG_SPECIFIC (node))
 783     return;
 784
 785   if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
 786     size = sizeof (struct lang_type);
 787   else
 788     size = sizeof (struct lang_type_ptrmem);
 789   lt = GGC_NEWVAR (struct lang_type, size);
 790   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
 791   TYPE_LANG_SPECIFIC (node) = lt;
 792
 793 #ifdef GATHER_STATISTICS
 794   tree_node_counts[(int)lang_type] += 1;
 795   tree_node_sizes[(int)lang_type] += size;
 796 #endif
 797 }
 798
 799 /* Copy TYPE, including any language-specific parts.  */
 800
 801 tree
 802 copy_type (tree type)
 803 {
 804   tree copy;
 805
 806   copy = copy_node (type);
 807   copy_lang_type (copy);
 808   return copy;
 809 }
 810
 811 tree
 812 cxx_make_type (enum tree_code code)
 813 {
 814   tree t = make_node (code);
 815
 816   /* Create lang_type structure.  */
 817   if (IS_AGGR_TYPE_CODE (code)
 818       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
 819     {
 820       struct lang_type *pi = GGC_CNEW (struct lang_type);
 821
 822       TYPE_LANG_SPECIFIC (t) = pi;
 823       pi->u.c.h.is_lang_type_class = 1;
 824
 825 #ifdef GATHER_STATISTICS
 826       tree_node_counts[(int)lang_type] += 1;
 827       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
 828 #endif
 829     }
 830
 831   /* Set up some flags that give proper default behavior.  */
 832   if (IS_AGGR_TYPE_CODE (code))
 833     {
 834       struct c_fileinfo *finfo = get_fileinfo (input_filename);
 835       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
 836       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
 837     }
 838
 839   return t;
 840 }
 841
 842 tree
 843 make_aggr_type (enum tree_code code)
 844 {
 845   tree t = cxx_make_type (code);
 846
 847   if (IS_AGGR_TYPE_CODE (code))
 848     SET_IS_AGGR_TYPE (t, 1);
 849
 850   return t;
 851 }
 852
 853 /* Returns true if we are currently in the main source file, or in a
 854    template instantiation started from the main source file.  */
 855
 856 bool
 857 in_main_input_context (void)
 858 {
 859   struct tinst_level *tl = outermost_tinst_level();
 860
 861   if (tl)
 862     return strcmp (main_input_filename,
 863                   LOCATION_FILE (tl->locus)) == 0;
 864   else
 865     return strcmp (main_input_filename, input_filename) == 0;
 866 }