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