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