gcc/cp/lex.c

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