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