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   { "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   location_t saved_loc;
 376   unsigned int i;
 377   static const enum tree_code stmt_codes[] = {
 378    CTOR_INITIALIZER,    TRY_BLOCK,      HANDLER,
 379    EH_SPEC_BLOCK,       USING_STMT,     TAG_DEFN,
 380    IF_STMT,             CLEANUP_STMT,   FOR_STMT,
 381    WHILE_STMT,          DO_STMT,        BREAK_STMT,
 382    CONTINUE_STMT,       SWITCH_STMT,    EXPR_STMT
 383   };
 384
 385   memset (&statement_code_p, 0, sizeof (statement_code_p));
 386   for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
 387     statement_code_p[stmt_codes[i]] = true;
 388
 389   saved_loc = input_location;
 390   input_location = BUILTINS_LOCATION;
 391
 392   init_reswords ();
 393   init_tree ();
 394   init_cp_semantics ();
 395   init_operators ();
 396   init_method ();
 397   init_error ();
 398
 399   current_function_decl = NULL;
 400
 401   class_type_node = ridpointers[(int) RID_CLASS];
 402
 403   cxx_init_decl_processing ();
 404
 405   /* The fact that G++ uses COMDAT for many entities (inline
 406      functions, template instantiations, virtual tables, etc.) mean
 407      that it is fundamentally unreliable to try to make decisions
 408      about whether or not to output a particular entity until the end
 409      of the compilation.  However, the inliner requires that functions
 410      be provided to the back end if they are to be inlined.
 411      Therefore, we always use unit-at-a-time mode; in that mode, we
 412      can provide entities to the back end and it will decide what to
 413      emit based on what is actually needed.  */
 414   flag_unit_at_a_time = 1;
 415
 416   if (c_common_init () == false)
 417     {
 418       input_location = saved_loc;
 419       return false;
 420     }
 421
 422   init_cp_pragma ();
 423
 424   init_repo ();
 425
 426   input_location = saved_loc;
 427   return true;
 428 }
 429 \f
 430 /* Return nonzero if S is not considered part of an
 431    INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
 432
 433 static int
 434 interface_strcmp (const char* s)
 435 {
 436   /* Set the interface/implementation bits for this scope.  */
 437   struct impl_files *ifiles;
 438   const char *s1;
 439
 440   for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
 441     {
 442       const char *t1 = ifiles->filename;
 443       s1 = s;
 444
 445       if (*s1 != *t1 || *s1 == 0)
 446         continue;
 447
 448       while (*s1 == *t1 && *s1 != 0)
 449         s1++, t1++;
 450
 451       /* A match.  */
 452       if (*s1 == *t1)
 453         return 0;
 454
 455       /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
 456       if (strchr (s1, '.') || strchr (t1, '.'))
 457         continue;
 458
 459       if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
 460         continue;
 461
 462       /* A match.  */
 463       return 0;
 464     }
 465
 466   /* No matches.  */
 467   return 1;
 468 }
 469
 470 \f
 471
 472 /* Parse a #pragma whose sole argument is a string constant.
 473    If OPT is true, the argument is optional.  */
 474 static tree
 475 parse_strconst_pragma (const char* name, int opt)
 476 {
 477   tree result, x;
 478   enum cpp_ttype t;
 479
 480   t = pragma_lex (&result);
 481   if (t == CPP_STRING)
 482     {
 483       if (pragma_lex (&x) != CPP_EOF)
 484         warning (0, "junk at end of #pragma %s", name);
 485       return result;
 486     }
 487
 488   if (t == CPP_EOF && opt)
 489     return NULL_TREE;
 490
 491   error ("invalid #pragma %s", name);
 492   return error_mark_node;
 493 }
 494
 495 static void
 496 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
 497 {
 498   parse_strconst_pragma ("vtable", 0);
 499   sorry ("#pragma vtable no longer supported");
 500 }
 501
 502 static void
 503 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
 504 {
 505   /* Validate syntax, but don't do anything.  */
 506   parse_strconst_pragma ("unit", 0);
 507 }
 508
 509 static void
 510 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
 511 {
 512   tree fname = parse_strconst_pragma ("interface", 1);
 513   struct c_fileinfo *finfo;
 514   const char *filename;
 515
 516   if (fname == error_mark_node)
 517     return;
 518   else if (fname == 0)
 519     filename = lbasename (input_filename);
 520   else
 521     filename = TREE_STRING_POINTER (fname);
 522
 523   finfo = get_fileinfo (input_filename);
 524
 525   if (impl_file_chain == 0)
 526     {
 527       /* If this is zero at this point, then we are
 528          auto-implementing.  */
 529       if (main_input_filename == 0)
 530         main_input_filename = input_filename;
 531     }
 532
 533   finfo->interface_only = interface_strcmp (filename);
 534   /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
 535      a definition in another file.  */
 536   if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
 537     finfo->interface_unknown = 0;
 538 }
 539
 540 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
 541    We used to only allow this at toplevel, but that restriction was buggy
 542    in older compilers and it seems reasonable to allow it in the headers
 543    themselves, too.  It only needs to precede the matching #p interface.
 544
 545    We don't touch finfo->interface_only or finfo->interface_unknown;
 546    the user must specify a matching #p interface for this to have
 547    any effect.  */
 548
 549 static void
 550 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
 551 {
 552   tree fname = parse_strconst_pragma ("implementation", 1);
 553   const char *filename;
 554   struct impl_files *ifiles = impl_file_chain;
 555
 556   if (fname == error_mark_node)
 557     return;
 558
 559   if (fname == 0)
 560     {
 561       if (main_input_filename)
 562         filename = main_input_filename;
 563       else
 564         filename = input_filename;
 565       filename = lbasename (filename);
 566     }
 567   else
 568     {
 569       filename = TREE_STRING_POINTER (fname);
 570       if (cpp_included_before (parse_in, filename, input_location))
 571         warning (0, "#pragma implementation for %qs appears after "
 572                  "file is included", filename);
 573     }
 574
 575   for (; ifiles; ifiles = ifiles->next)
 576     {
 577       if (! strcmp (ifiles->filename, filename))
 578         break;
 579     }
 580   if (ifiles == 0)
 581     {
 582       ifiles = XNEW (struct impl_files);
 583       ifiles->filename = xstrdup (filename);
 584       ifiles->next = impl_file_chain;
 585       impl_file_chain = ifiles;
 586     }
 587 }
 588
 589 /* Indicate that this file uses Java-personality exception handling.  */
 590 static void
 591 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED)
 592 {
 593   tree x;
 594   if (pragma_lex (&x) != CPP_EOF)
 595     warning (0, "junk at end of #pragma GCC java_exceptions");
 596
 597   choose_personality_routine (lang_java);
 598 }
 599
 600 /* Issue an error message indicating that the lookup of NAME (an
 601    IDENTIFIER_NODE) failed.  Returns the ERROR_MARK_NODE.  */
 602
 603 tree
 604 unqualified_name_lookup_error (tree name)
 605 {
 606   if (IDENTIFIER_OPNAME_P (name))
 607     {
 608       if (name != ansi_opname (ERROR_MARK))
 609         error ("%qD not defined", name);
 610     }
 611   else
 612     {
 613       error ("%qD was not declared in this scope", name);
 614       /* Prevent repeated error messages by creating a VAR_DECL with
 615          this NAME in the innermost block scope.  */
 616       if (current_function_decl)
 617         {
 618           tree decl;
 619           decl = build_decl (VAR_DECL, name, error_mark_node);
 620           DECL_CONTEXT (decl) = current_function_decl;
 621           push_local_binding (name, decl, 0);
 622           /* Mark the variable as used so that we do not get warnings
 623              about it being unused later.  */
 624           TREE_USED (decl) = 1;
 625         }
 626     }
 627
 628   return error_mark_node;
 629 }
 630
 631 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
 632    used as a function.  Returns an appropriate expression for
 633    NAME.  */
 634
 635 tree
 636 unqualified_fn_lookup_error (tree name)
 637 {
 638   if (processing_template_decl)
 639     {
 640       /* In a template, it is invalid to write "f()" or "f(3)" if no
 641          declaration of "f" is available.  Historically, G++ and most
 642          other compilers accepted that usage since they deferred all name
 643          lookup until instantiation time rather than doing unqualified
 644          name lookup at template definition time; explain to the user what
 645          is going wrong.
 646
 647          Note that we have the exact wording of the following message in
 648          the manual (trouble.texi, node "Name lookup"), so they need to
 649          be kept in synch.  */
 650       permerror ("there are no arguments to %qD that depend on a template "
 651                  "parameter, so a declaration of %qD must be available",
 652                  name, name);
 653
 654       if (!flag_permissive)
 655         {
 656           static bool hint;
 657           if (!hint)
 658             {
 659               inform ("(if you use %<-fpermissive%>, G++ will accept your "
 660                      "code, but allowing the use of an undeclared name is "
 661                      "deprecated)");
 662               hint = true;
 663             }
 664         }
 665       return name;
 666     }
 667
 668   return unqualified_name_lookup_error (name);
 669 }
 670
 671 tree
 672 build_lang_decl (enum tree_code code, tree name, tree type)
 673 {
 674   tree t;
 675
 676   t = build_decl (code, name, type);
 677   retrofit_lang_decl (t);
 678
 679   /* All nesting of C++ functions is lexical; there is never a "static
 680      chain" in the sense of GNU C nested functions.  */
 681   if (code == FUNCTION_DECL)
 682     DECL_NO_STATIC_CHAIN (t) = 1;
 683
 684   return t;
 685 }
 686
 687 /* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
 688    and pushdecl (for functions generated by the back end).  */
 689
 690 void
 691 retrofit_lang_decl (tree t)
 692 {
 693   struct lang_decl *ld;
 694   size_t size;
 695
 696   if (CAN_HAVE_FULL_LANG_DECL_P (t))
 697     size = sizeof (struct lang_decl);
 698   else
 699     size = sizeof (struct lang_decl_flags);
 700
 701   ld = GGC_CNEWVAR (struct lang_decl, size);
 702
 703   ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
 704   ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
 705   ld->decl_flags.u2sel = 0;
 706   if (ld->decl_flags.can_be_full)
 707     ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
 708
 709   DECL_LANG_SPECIFIC (t) = ld;
 710   if (current_lang_name == lang_name_cplusplus
 711       || decl_linkage (t) == lk_none)
 712     SET_DECL_LANGUAGE (t, lang_cplusplus);
 713   else if (current_lang_name == lang_name_c)
 714     SET_DECL_LANGUAGE (t, lang_c);
 715   else if (current_lang_name == lang_name_java)
 716     SET_DECL_LANGUAGE (t, lang_java);
 717   else
 718     gcc_unreachable ();
 719
 720 #ifdef GATHER_STATISTICS
 721   tree_node_counts[(int)lang_decl] += 1;
 722   tree_node_sizes[(int)lang_decl] += size;
 723 #endif
 724 }
 725
 726 void
 727 cxx_dup_lang_specific_decl (tree node)
 728 {
 729   int size;
 730   struct lang_decl *ld;
 731
 732   if (! DECL_LANG_SPECIFIC (node))
 733     return;
 734
 735   if (!CAN_HAVE_FULL_LANG_DECL_P (node))
 736     size = sizeof (struct lang_decl_flags);
 737   else
 738     size = sizeof (struct lang_decl);
 739   ld = GGC_NEWVAR (struct lang_decl, size);
 740   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
 741   DECL_LANG_SPECIFIC (node) = ld;
 742
 743 #ifdef GATHER_STATISTICS
 744   tree_node_counts[(int)lang_decl] += 1;
 745   tree_node_sizes[(int)lang_decl] += size;
 746 #endif
 747 }
 748
 749 /* Copy DECL, including any language-specific parts.  */
 750
 751 tree
 752 copy_decl (tree decl)
 753 {
 754   tree copy;
 755
 756   copy = copy_node (decl);
 757   cxx_dup_lang_specific_decl (copy);
 758   return copy;
 759 }
 760
 761 /* Replace the shared language-specific parts of NODE with a new copy.  */
 762
 763 static void
 764 copy_lang_type (tree node)
 765 {
 766   int size;
 767   struct lang_type *lt;
 768
 769   if (! TYPE_LANG_SPECIFIC (node))
 770     return;
 771
 772   if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
 773     size = sizeof (struct lang_type);
 774   else
 775     size = sizeof (struct lang_type_ptrmem);
 776   lt = GGC_NEWVAR (struct lang_type, size);
 777   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
 778   TYPE_LANG_SPECIFIC (node) = lt;
 779
 780 #ifdef GATHER_STATISTICS
 781   tree_node_counts[(int)lang_type] += 1;
 782   tree_node_sizes[(int)lang_type] += size;
 783 #endif
 784 }
 785
 786 /* Copy TYPE, including any language-specific parts.  */
 787
 788 tree
 789 copy_type (tree type)
 790 {
 791   tree copy;
 792
 793   copy = copy_node (type);
 794   copy_lang_type (copy);
 795   return copy;
 796 }
 797
 798 tree
 799 cxx_make_type (enum tree_code code)
 800 {
 801   tree t = make_node (code);
 802
 803   /* Create lang_type structure.  */
 804   if (RECORD_OR_UNION_CODE_P (code)
 805       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
 806     {
 807       struct lang_type *pi = GGC_CNEW (struct lang_type);
 808
 809       TYPE_LANG_SPECIFIC (t) = pi;
 810       pi->u.c.h.is_lang_type_class = 1;
 811
 812 #ifdef GATHER_STATISTICS
 813       tree_node_counts[(int)lang_type] += 1;
 814       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
 815 #endif
 816     }
 817
 818   /* Set up some flags that give proper default behavior.  */
 819   if (RECORD_OR_UNION_CODE_P (code))
 820     {
 821       struct c_fileinfo *finfo = get_fileinfo (input_filename);
 822       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
 823       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
 824     }
 825
 826   return t;
 827 }
 828
 829 tree
 830 make_class_type (enum tree_code code)
 831 {
 832   tree t = cxx_make_type (code);
 833   SET_CLASS_TYPE_P (t, 1);
 834   return t;
 835 }
 836
 837 /* Returns true if we are currently in the main source file, or in a
 838    template instantiation started from the main source file.  */
 839
 840 bool
 841 in_main_input_context (void)
 842 {
 843   struct tinst_level *tl = outermost_tinst_level();
 844
 845   if (tl)
 846     return strcmp (main_input_filename,
 847                   LOCATION_FILE (tl->locus)) == 0;
 848   else
 849     return strcmp (main_input_filename, input_filename) == 0;
 850 }