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