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) FFS_EXPR].name = "ffs";
 209   operator_name_info [(int) BIT_ANDTC_EXPR].name = "&~";
 210   operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
 211   operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
 212   operator_name_info [(int) IN_EXPR].name = "in";
 213   operator_name_info [(int) RANGE_EXPR].name = "...";
 214   operator_name_info [(int) CONVERT_EXPR].name = "+";
 215
 216   assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
 217     = "(exact /=)";
 218   assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
 219     = "(ceiling /=)";
 220   assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
 221     = "(floor /=)";
 222   assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
 223     = "(round /=)";
 224   assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
 225     = "(ceiling %=)";
 226   assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
 227     = "(floor %=)";
 228   assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
 229     = "(round %=)";
 230 }
 231
 232 /* The reserved keyword table.  */
 233 struct resword
 234 {
 235   const char *const word;
 236   const ENUM_BITFIELD(rid) rid : 16;
 237   const unsigned int disable   : 16;
 238 };
 239
 240 /* Disable mask.  Keywords are disabled if (reswords[i].disable & mask) is
 241    _true_.  */
 242 #define D_EXT           0x01    /* GCC extension */
 243 #define D_ASM           0x02    /* in C99, but has a switch to turn it off */
 244
 245 CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
 246
 247 static const struct resword reswords[] =
 248 {
 249   { "_Complex",         RID_COMPLEX,    0 },
 250   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
 251   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
 252   { "__alignof",        RID_ALIGNOF,    0 },
 253   { "__alignof__",      RID_ALIGNOF,    0 },
 254   { "__asm",            RID_ASM,        0 },
 255   { "__asm__",          RID_ASM,        0 },
 256   { "__attribute",      RID_ATTRIBUTE,  0 },
 257   { "__attribute__",    RID_ATTRIBUTE,  0 },
 258   { "__builtin_va_arg", RID_VA_ARG,     0 },
 259   { "__complex",        RID_COMPLEX,    0 },
 260   { "__complex__",      RID_COMPLEX,    0 },
 261   { "__const",          RID_CONST,      0 },
 262   { "__const__",        RID_CONST,      0 },
 263   { "__extension__",    RID_EXTENSION,  0 },
 264   { "__func__",         RID_C99_FUNCTION_NAME,  0 },
 265   { "__imag",           RID_IMAGPART,   0 },
 266   { "__imag__",         RID_IMAGPART,   0 },
 267   { "__inline",         RID_INLINE,     0 },
 268   { "__inline__",       RID_INLINE,     0 },
 269   { "__label__",        RID_LABEL,      0 },
 270   { "__null",           RID_NULL,       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 = build_int_2 (class_type, 0);
 409   TREE_TYPE (class_type_node) = class_type_node;
 410   ridpointers[(int) RID_CLASS] = class_type_node;
 411
 412   record_type_node = build_int_2 (record_type, 0);
 413   TREE_TYPE (record_type_node) = record_type_node;
 414   ridpointers[(int) RID_STRUCT] = record_type_node;
 415
 416   union_type_node = build_int_2 (union_type, 0);
 417   TREE_TYPE (union_type_node) = union_type_node;
 418   ridpointers[(int) RID_UNION] = union_type_node;
 419
 420   enum_type_node = build_int_2 (enum_type, 0);
 421   TREE_TYPE (enum_type_node) = enum_type_node;
 422   ridpointers[(int) RID_ENUM] = enum_type_node;
 423
 424   cxx_init_decl_processing ();
 425
 426   /* Create the built-in __null node.  */
 427   null_node = build_int_2 (0, 0);
 428   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
 429   ridpointers[RID_NULL] = null_node;
 430
 431   interface_unknown = 1;
 432
 433   if (c_common_init () == false)
 434     {
 435       pop_srcloc();
 436       return false;
 437     }
 438
 439   init_cp_pragma ();
 440
 441   init_repo (main_input_filename);
 442
 443   pop_srcloc();
 444   return true;
 445 }
 446 \f
 447 /* Helper function to load global variables with interface
 448    information.  */
 449
 450 void
 451 extract_interface_info (void)
 452 {
 453   struct c_fileinfo *finfo = 0;
 454
 455   if (flag_alt_external_templates)
 456     {
 457       tree til = tinst_for_decl ();
 458
 459       if (til)
 460         finfo = get_fileinfo (TINST_FILE (til));
 461     }
 462   if (!finfo)
 463     finfo = get_fileinfo (input_filename);
 464
 465   interface_only = finfo->interface_only;
 466   interface_unknown = finfo->interface_unknown;
 467 }
 468
 469 /* Return nonzero if S is not considered part of an
 470    INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
 471
 472 static int
 473 interface_strcmp (const char* s)
 474 {
 475   /* Set the interface/implementation bits for this scope.  */
 476   struct impl_files *ifiles;
 477   const char *s1;
 478
 479   for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
 480     {
 481       const char *t1 = ifiles->filename;
 482       s1 = s;
 483
 484       if (*s1 != *t1 || *s1 == 0)
 485         continue;
 486
 487       while (*s1 == *t1 && *s1 != 0)
 488         s1++, t1++;
 489
 490       /* A match.  */
 491       if (*s1 == *t1)
 492         return 0;
 493
 494       /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
 495       if (strchr (s1, '.') || strchr (t1, '.'))
 496         continue;
 497
 498       if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
 499         continue;
 500
 501       /* A match.  */
 502       return 0;
 503     }
 504
 505   /* No matches.  */
 506   return 1;
 507 }
 508
 509 \f
 510
 511 /* Parse a #pragma whose sole argument is a string constant.
 512    If OPT is true, the argument is optional.  */
 513 static tree
 514 parse_strconst_pragma (const char* name, int opt)
 515 {
 516   tree result, x;
 517   enum cpp_ttype t;
 518
 519   t = c_lex (&x);
 520   if (t == CPP_STRING)
 521     {
 522       result = x;
 523       if (c_lex (&x) != CPP_EOF)
 524         warning ("junk at end of #pragma %s", name);
 525       return result;
 526     }
 527
 528   if (t == CPP_EOF && opt)
 529     return 0;
 530
 531   error ("invalid #pragma %s", name);
 532   return (tree)-1;
 533 }
 534
 535 static void
 536 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
 537 {
 538   parse_strconst_pragma ("vtable", 0);
 539   sorry ("#pragma vtable no longer supported");
 540 }
 541
 542 static void
 543 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
 544 {
 545   /* Validate syntax, but don't do anything.  */
 546   parse_strconst_pragma ("unit", 0);
 547 }
 548
 549 static void
 550 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
 551 {
 552   tree fname = parse_strconst_pragma ("interface", 1);
 553   struct c_fileinfo *finfo;
 554   const char *main_filename;
 555
 556   if (fname == (tree)-1)
 557     return;
 558   else if (fname == 0)
 559     main_filename = lbasename (input_filename);
 560   else
 561     main_filename = TREE_STRING_POINTER (fname);
 562
 563   finfo = get_fileinfo (input_filename);
 564
 565   if (impl_file_chain == 0)
 566     {
 567       /* If this is zero at this point, then we are
 568          auto-implementing.  */
 569       if (main_input_filename == 0)
 570         main_input_filename = input_filename;
 571     }
 572
 573   interface_only = interface_strcmp (main_filename);
 574 #ifdef MULTIPLE_SYMBOL_SPACES
 575   if (! interface_only)
 576 #endif
 577     interface_unknown = 0;
 578
 579   finfo->interface_only = interface_only;
 580   finfo->interface_unknown = interface_unknown;
 581 }
 582
 583 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
 584    We used to only allow this at toplevel, but that restriction was buggy
 585    in older compilers and it seems reasonable to allow it in the headers
 586    themselves, too.  It only needs to precede the matching #p interface.
 587
 588    We don't touch interface_only or interface_unknown; the user must specify
 589    a matching #p interface for this to have any effect.  */
 590
 591 static void
 592 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
 593 {
 594   tree fname = parse_strconst_pragma ("implementation", 1);
 595   const char *main_filename;
 596   struct impl_files *ifiles = impl_file_chain;
 597
 598   if (fname == (tree)-1)
 599     return;
 600
 601   if (fname == 0)
 602     {
 603       if (main_input_filename)
 604         main_filename = main_input_filename;
 605       else
 606         main_filename = input_filename;
 607       main_filename = lbasename (main_filename);
 608     }
 609   else
 610     {
 611       main_filename = TREE_STRING_POINTER (fname);
 612       if (cpp_included (parse_in, main_filename))
 613         warning ("#pragma implementation for %s appears after file is included",
 614                  main_filename);
 615     }
 616
 617   for (; ifiles; ifiles = ifiles->next)
 618     {
 619       if (! strcmp (ifiles->filename, main_filename))
 620         break;
 621     }
 622   if (ifiles == 0)
 623     {
 624       ifiles = xmalloc (sizeof (struct impl_files));
 625       ifiles->filename = main_filename;
 626       ifiles->next = impl_file_chain;
 627       impl_file_chain = ifiles;
 628     }
 629 }
 630
 631 /* Indicate that this file uses Java-personality exception handling.  */
 632 static void
 633 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED )
 634 {
 635   tree x;
 636   if (c_lex (&x) != CPP_EOF)
 637     warning ("junk at end of #pragma GCC java_exceptions");
 638
 639   choose_personality_routine (lang_java);
 640 }
 641
 642 /* Issue an error message indicating that the lookup of NAME (an
 643    IDENTIFIER_NODE) failed.  Returns the ERROR_MARK_NODE.  */
 644
 645 tree
 646 unqualified_name_lookup_error (tree name)
 647 {
 648   if (IDENTIFIER_OPNAME_P (name))
 649     {
 650       if (name != ansi_opname (ERROR_MARK))
 651         error ("`%D' not defined", name);
 652     }
 653   else if (current_function_decl == 0)
 654     error ("`%D' was not declared in this scope", name);
 655   else
 656     {
 657       if (IDENTIFIER_NAMESPACE_VALUE (name) != error_mark_node
 658           || IDENTIFIER_ERROR_LOCUS (name) != current_function_decl)
 659         {
 660           static int undeclared_variable_notice;
 661
 662           error ("`%D' undeclared (first use this function)", name);
 663
 664           if (! undeclared_variable_notice)
 665             {
 666               error ("(Each undeclared identifier is reported only once for each function it appears in.)");
 667               undeclared_variable_notice = 1;
 668             }
 669         }
 670       /* Prevent repeated error messages.  */
 671       SET_IDENTIFIER_NAMESPACE_VALUE (name, error_mark_node);
 672       SET_IDENTIFIER_ERROR_LOCUS (name, current_function_decl);
 673     }
 674
 675   return error_mark_node;
 676 }
 677
 678 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
 679    used as a function.  Returns an appropriate expression for
 680    NAME.  */
 681
 682 tree
 683 unqualified_fn_lookup_error (tree name)
 684 {
 685   if (processing_template_decl)
 686     {
 687       /* In a template, it is invalid to write "f()" or "f(3)" if no
 688          declaration of "f" is available.  Historically, G++ and most
 689          other compilers accepted that usage since they deferred all name
 690          lookup until instantiation time rather than doing unqualified
 691          name lookup at template definition time; explain to the user what
 692          is going wrong.
 693
 694          Note that we have the exact wording of the following message in
 695          the manual (trouble.texi, node "Name lookup"), so they need to
 696          be kept in synch.  */
 697       pedwarn ("there are no arguments to `%D' that depend on a template "
 698                "parameter, so a declaration of `%D' must be available",
 699                name, name);
 700
 701       if (!flag_permissive)
 702         {
 703           static bool hint;
 704           if (!hint)
 705             {
 706               error ("(if you use `-fpermissive', G++ will accept your code, "
 707                      "but allowing the use of an undeclared name is "
 708                      "deprecated)");
 709               hint = true;
 710             }
 711         }
 712       return name;
 713     }
 714
 715   return unqualified_name_lookup_error (name);
 716 }
 717
 718 tree
 719 build_lang_decl (enum tree_code code, tree name, tree type)
 720 {
 721   tree t;
 722
 723   t = build_decl (code, name, type);
 724   retrofit_lang_decl (t);
 725
 726   return t;
 727 }
 728
 729 /* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
 730    and pushdecl (for functions generated by the backend).  */
 731
 732 void
 733 retrofit_lang_decl (tree t)
 734 {
 735   struct lang_decl *ld;
 736   size_t size;
 737
 738   if (CAN_HAVE_FULL_LANG_DECL_P (t))
 739     size = sizeof (struct lang_decl);
 740   else
 741     size = sizeof (struct lang_decl_flags);
 742
 743   ld = ggc_alloc_cleared (size);
 744
 745   ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
 746   ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
 747   ld->decl_flags.u2sel = 0;
 748   if (ld->decl_flags.can_be_full)
 749     ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
 750
 751   DECL_LANG_SPECIFIC (t) = ld;
 752   if (current_lang_name == lang_name_cplusplus)
 753     SET_DECL_LANGUAGE (t, lang_cplusplus);
 754   else if (current_lang_name == lang_name_c)
 755     SET_DECL_LANGUAGE (t, lang_c);
 756   else if (current_lang_name == lang_name_java)
 757     SET_DECL_LANGUAGE (t, lang_java);
 758   else abort ();
 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 void
 767 cxx_dup_lang_specific_decl (tree node)
 768 {
 769   int size;
 770   struct lang_decl *ld;
 771
 772   if (! DECL_LANG_SPECIFIC (node))
 773     return;
 774
 775   if (!CAN_HAVE_FULL_LANG_DECL_P (node))
 776     size = sizeof (struct lang_decl_flags);
 777   else
 778     size = sizeof (struct lang_decl);
 779   ld = ggc_alloc (size);
 780   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
 781   DECL_LANG_SPECIFIC (node) = ld;
 782
 783 #ifdef GATHER_STATISTICS
 784   tree_node_counts[(int)lang_decl] += 1;
 785   tree_node_sizes[(int)lang_decl] += size;
 786 #endif
 787 }
 788
 789 /* Copy DECL, including any language-specific parts.  */
 790
 791 tree
 792 copy_decl (tree decl)
 793 {
 794   tree copy;
 795
 796   copy = copy_node (decl);
 797   cxx_dup_lang_specific_decl (copy);
 798   return copy;
 799 }
 800
 801 /* Replace the shared language-specific parts of NODE with a new copy.  */
 802
 803 static void
 804 copy_lang_type (tree node)
 805 {
 806   int size;
 807   struct lang_type *lt;
 808
 809   if (! TYPE_LANG_SPECIFIC (node))
 810     return;
 811
 812   if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
 813     size = sizeof (struct lang_type);
 814   else
 815     size = sizeof (struct lang_type_ptrmem);
 816   lt = ggc_alloc (size);
 817   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
 818   TYPE_LANG_SPECIFIC (node) = lt;
 819
 820 #ifdef GATHER_STATISTICS
 821   tree_node_counts[(int)lang_type] += 1;
 822   tree_node_sizes[(int)lang_type] += size;
 823 #endif
 824 }
 825
 826 /* Copy TYPE, including any language-specific parts.  */
 827
 828 tree
 829 copy_type (tree type)
 830 {
 831   tree copy;
 832
 833   copy = copy_node (type);
 834   copy_lang_type (copy);
 835   return copy;
 836 }
 837
 838 tree
 839 cxx_make_type (enum tree_code code)
 840 {
 841   register tree t = make_node (code);
 842
 843   /* Create lang_type structure.  */
 844   if (IS_AGGR_TYPE_CODE (code)
 845       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
 846     {
 847       struct lang_type *pi;
 848
 849       pi = ggc_alloc_cleared (sizeof (struct lang_type));
 850
 851       TYPE_LANG_SPECIFIC (t) = pi;
 852       pi->u.c.h.is_lang_type_class = 1;
 853
 854 #ifdef GATHER_STATISTICS
 855       tree_node_counts[(int)lang_type] += 1;
 856       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
 857 #endif
 858     }
 859
 860   /* Set up some flags that give proper default behavior.  */
 861   if (IS_AGGR_TYPE_CODE (code))
 862     {
 863       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
 864       CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
 865
 866       /* Make sure this is laid out, for ease of use later.  In the
 867          presence of parse errors, the normal was of assuring this
 868          might not ever get executed, so we lay it out *immediately*.  */
 869       build_pointer_type (t);
 870     }
 871   else
 872     /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits.  But,
 873        TYPE_ALIAS_SET is initialized to -1 by default, so we must
 874        clear it here.  */
 875     TYPE_ALIAS_SET (t) = 0;
 876
 877   /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
 878      since they can be virtual base types, and we then need a
 879      canonical binfo for them.  Ideally, this would be done lazily for
 880      all types.  */
 881   if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM
 882       || code == BOUND_TEMPLATE_TEMPLATE_PARM
 883       || code == TYPENAME_TYPE)
 884     TYPE_BINFO (t) = make_binfo (size_zero_node, t, NULL_TREE, NULL_TREE);
 885
 886   return t;
 887 }
 888
 889 tree
 890 make_aggr_type (enum tree_code code)
 891 {
 892   tree t = cxx_make_type (code);
 893
 894   if (IS_AGGR_TYPE_CODE (code))
 895     SET_IS_AGGR_TYPE (t, 1);
 896
 897   return t;
 898 }
 899
 900 /* Return the type-qualifier corresponding to the identifier given by
 901    RID.  */
 902
 903 int
 904 cp_type_qual_from_rid (tree rid)
 905 {
 906   if (rid == ridpointers[(int) RID_CONST])
 907     return TYPE_QUAL_CONST;
 908   else if (rid == ridpointers[(int) RID_VOLATILE])
 909     return TYPE_QUAL_VOLATILE;
 910   else if (rid == ridpointers[(int) RID_RESTRICT])
 911     return TYPE_QUAL_RESTRICT;
 912
 913   abort ();
 914   return TYPE_UNQUALIFIED;
 915 }