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