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