gcc/cp/lex.c

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