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