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 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 "lex.h"
  35 #include "flags.h"
  36 #include "c-pragma.h"
  37 #include "toplev.h"
  38 #include "output.h"
  39 #include "tm_p.h"
  40 #include "timevar.h"
  41
  42 static int interface_strcmp (const char *);
  43 static void init_cp_pragma (void);
  44
  45 static tree parse_strconst_pragma (const char *, int);
  46 static void handle_pragma_vtable (cpp_reader *);
  47 static void handle_pragma_unit (cpp_reader *);
  48 static void handle_pragma_interface (cpp_reader *);
  49 static void handle_pragma_implementation (cpp_reader *);
  50 static void handle_pragma_java_exceptions (cpp_reader *);
  51
  52 static int is_global (tree);
  53 static void init_operators (void);
  54 static void copy_lang_type (tree);
  55
  56 /* A constraint that can be tested at compile time.  */
  57 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
  58
  59 /* Functions and data structures for #pragma interface.
  60
  61    `#pragma implementation' means that the main file being compiled
  62    is considered to implement (provide) the classes that appear in
  63    its main body.  I.e., if this is file "foo.cc", and class `bar'
  64    is defined in "foo.cc", then we say that "foo.cc implements bar".
  65
  66    All main input files "implement" themselves automagically.
  67
  68    `#pragma interface' means that unless this file (of the form "foo.h"
  69    is not presently being included by file "foo.cc", the
  70    CLASSTYPE_INTERFACE_ONLY bit gets set.  The effect is that none
  71    of the vtables nor any of the inline functions defined in foo.h
  72    will ever be output.
  73
  74    There are cases when we want to link files such as "defs.h" and
  75    "main.cc".  In this case, we give "defs.h" a `#pragma interface',
  76    and "main.cc" has `#pragma implementation "defs.h"'.  */
  77
  78 struct impl_files
  79 {
  80   const char *filename;
  81   struct impl_files *next;
  82 };
  83
  84 static struct impl_files *impl_file_chain;
  85
  86 \f
  87 /* Return something to represent absolute declarators containing a *.
  88    TARGET is the absolute declarator that the * contains.
  89    CV_QUALIFIERS is a list of modifiers such as const or volatile
  90    to apply to the pointer type, represented as identifiers.
  91
  92    We return an INDIRECT_REF whose "contents" are TARGET
  93    and whose type is the modifier list.  */
  94
  95 tree
  96 make_pointer_declarator (tree cv_qualifiers, tree target)
  97 {
  98   if (target && TREE_CODE (target) == IDENTIFIER_NODE
  99       && ANON_AGGRNAME_P (target))
 100     error ("type name expected before `*'");
 101   target = build_nt (INDIRECT_REF, target);
 102   TREE_TYPE (target) = cv_qualifiers;
 103   return target;
 104 }
 105
 106 /* Return something to represent absolute declarators containing a &.
 107    TARGET is the absolute declarator that the & contains.
 108    CV_QUALIFIERS is a list of modifiers such as const or volatile
 109    to apply to the reference type, represented as identifiers.
 110
 111    We return an ADDR_EXPR whose "contents" are TARGET
 112    and whose type is the modifier list.  */
 113
 114 tree
 115 make_reference_declarator (tree cv_qualifiers, tree target)
 116 {
 117   target = build_nt (ADDR_EXPR, target);
 118   TREE_TYPE (target) = cv_qualifiers;
 119   return target;
 120 }
 121
 122 tree
 123 make_call_declarator (tree target, tree parms, tree cv_qualifiers,
 124                       tree exception_specification)
 125 {
 126   target = build_nt (CALL_EXPR, target,
 127                      tree_cons (parms, cv_qualifiers, NULL_TREE),
 128                      /* The third operand is really RTL.  We
 129                         shouldn't put anything there.  */
 130                      NULL_TREE);
 131   CALL_DECLARATOR_EXCEPTION_SPEC (target) = exception_specification;
 132   return target;
 133 }
 134
 135 void
 136 set_quals_and_spec (tree call_declarator, tree cv_qualifiers,
 137                     tree exception_specification)
 138 {
 139   CALL_DECLARATOR_QUALS (call_declarator) = cv_qualifiers;
 140   CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator) = exception_specification;
 141 }
 142 \f
 143 int interface_only;             /* whether or not current file is only for
 144                                    interface definitions.  */
 145 int interface_unknown;          /* whether or not we know this class
 146                                    to behave according to #pragma interface.  */
 147
 148 \f
 149 void
 150 cxx_finish (void)
 151 {
 152   c_common_finish ();
 153 }
 154
 155 /* A mapping from tree codes to operator name information.  */
 156 operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE];
 157 /* Similar, but for assignment operators.  */
 158 operator_name_info_t assignment_operator_name_info[(int) LAST_CPLUS_TREE_CODE];
 159
 160 /* Initialize data structures that keep track of operator names.  */
 161
 162 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
 163  CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
 164 #include "operators.def"
 165 #undef DEF_OPERATOR
 166
 167 static void
 168 init_operators (void)
 169 {
 170   tree identifier;
 171   char buffer[256];
 172   struct operator_name_info_t *oni;
 173
 174 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)                   \
 175   sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
 176   identifier = get_identifier (buffer);                                     \
 177   IDENTIFIER_OPNAME_P (identifier) = 1;                                     \
 178                                                                             \
 179   oni = (ASSN_P                                                             \
 180          ? &assignment_operator_name_info[(int) CODE]                       \
 181          : &operator_name_info[(int) CODE]);                                \
 182   oni->identifier = identifier;                                             \
 183   oni->name = NAME;                                                         \
 184   oni->mangled_name = MANGLING;                                             \
 185   oni->arity = ARITY;
 186
 187 #include "operators.def"
 188 #undef DEF_OPERATOR
 189
 190   operator_name_info[(int) ERROR_MARK].identifier
 191     = get_identifier ("<invalid operator>");
 192
 193   /* Handle some special cases.  These operators are not defined in
 194      the language, but can be produced internally.  We may need them
 195      for error-reporting.  (Eventually, we should ensure that this
 196      does not happen.  Error messages involving these operators will
 197      be confusing to users.)  */
 198
 199   operator_name_info [(int) INIT_EXPR].name
 200     = operator_name_info [(int) MODIFY_EXPR].name;
 201   operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
 202   operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
 203   operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
 204   operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
 205   operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
 206   operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
 207   operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
 208   operator_name_info [(int) ABS_EXPR].name = "abs";
 209   operator_name_info [(int) FFS_EXPR].name = "ffs";
 210   operator_name_info [(int) BIT_ANDTC_EXPR].name = "&~";
 211   operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
 212   operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
 213   operator_name_info [(int) IN_EXPR].name = "in";
 214   operator_name_info [(int) RANGE_EXPR].name = "...";
 215   operator_name_info [(int) CONVERT_EXPR].name = "+";
 216
 217   assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
 218     = "(exact /=)";
 219   assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
 220     = "(ceiling /=)";
 221   assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
 222     = "(floor /=)";
 223   assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
 224     = "(round /=)";
 225   assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
 226     = "(ceiling %=)";
 227   assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
 228     = "(floor %=)";
 229   assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
 230     = "(round %=)";
 231 }
 232
 233 /* The reserved keyword table.  */
 234 struct resword
 235 {
 236   const char *const word;
 237   const ENUM_BITFIELD(rid) rid : 16;
 238   const unsigned int disable   : 16;
 239 };
 240
 241 /* Disable mask.  Keywords are disabled if (reswords[i].disable & mask) is
 242    _true_.  */
 243 #define D_EXT           0x01    /* GCC extension */
 244 #define D_ASM           0x02    /* in C99, but has a switch to turn it off */
 245
 246 CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
 247
 248 static const struct resword reswords[] =
 249 {
 250   { "_Complex",         RID_COMPLEX,    0 },
 251   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
 252   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
 253   { "__alignof",        RID_ALIGNOF,    0 },
 254   { "__alignof__",      RID_ALIGNOF,    0 },
 255   { "__asm",            RID_ASM,        0 },
 256   { "__asm__",          RID_ASM,        0 },
 257   { "__attribute",      RID_ATTRIBUTE,  0 },
 258   { "__attribute__",    RID_ATTRIBUTE,  0 },
 259   { "__builtin_va_arg", RID_VA_ARG,     0 },
 260   { "__complex",        RID_COMPLEX,    0 },
 261   { "__complex__",      RID_COMPLEX,    0 },
 262   { "__const",          RID_CONST,      0 },
 263   { "__const__",        RID_CONST,      0 },
 264   { "__extension__",    RID_EXTENSION,  0 },
 265   { "__func__",         RID_C99_FUNCTION_NAME,  0 },
 266   { "__imag",           RID_IMAGPART,   0 },
 267   { "__imag__",         RID_IMAGPART,   0 },
 268   { "__inline",         RID_INLINE,     0 },
 269   { "__inline__",       RID_INLINE,     0 },
 270   { "__label__",        RID_LABEL,      0 },
 271   { "__null",           RID_NULL,       0 },
 272   { "__real",           RID_REALPART,   0 },
 273   { "__real__",         RID_REALPART,   0 },
 274   { "__restrict",       RID_RESTRICT,   0 },
 275   { "__restrict__",     RID_RESTRICT,   0 },
 276   { "__signed",         RID_SIGNED,     0 },
 277   { "__signed__",       RID_SIGNED,     0 },
 278   { "__thread",         RID_THREAD,     0 },
 279   { "__typeof",         RID_TYPEOF,     0 },
 280   { "__typeof__",       RID_TYPEOF,     0 },
 281   { "__volatile",       RID_VOLATILE,   0 },
 282   { "__volatile__",     RID_VOLATILE,   0 },
 283   { "asm",              RID_ASM,        D_ASM },
 284   { "auto",             RID_AUTO,       0 },
 285   { "bool",             RID_BOOL,       0 },
 286   { "break",            RID_BREAK,      0 },
 287   { "case",             RID_CASE,       0 },
 288   { "catch",            RID_CATCH,      0 },
 289   { "char",             RID_CHAR,       0 },
 290   { "class",            RID_CLASS,      0 },
 291   { "const",            RID_CONST,      0 },
 292   { "const_cast",       RID_CONSTCAST,  0 },
 293   { "continue",         RID_CONTINUE,   0 },
 294   { "default",          RID_DEFAULT,    0 },
 295   { "delete",           RID_DELETE,     0 },
 296   { "do",               RID_DO,         0 },
 297   { "double",           RID_DOUBLE,     0 },
 298   { "dynamic_cast",     RID_DYNCAST,    0 },
 299   { "else",             RID_ELSE,       0 },
 300   { "enum",             RID_ENUM,       0 },
 301   { "explicit",         RID_EXPLICIT,   0 },
 302   { "export",           RID_EXPORT,     0 },
 303   { "extern",           RID_EXTERN,     0 },
 304   { "false",            RID_FALSE,      0 },
 305   { "float",            RID_FLOAT,      0 },
 306   { "for",              RID_FOR,        0 },
 307   { "friend",           RID_FRIEND,     0 },
 308   { "goto",             RID_GOTO,       0 },
 309   { "if",               RID_IF,         0 },
 310   { "inline",           RID_INLINE,     0 },
 311   { "int",              RID_INT,        0 },
 312   { "long",             RID_LONG,       0 },
 313   { "mutable",          RID_MUTABLE,    0 },
 314   { "namespace",        RID_NAMESPACE,  0 },
 315   { "new",              RID_NEW,        0 },
 316   { "operator",         RID_OPERATOR,   0 },
 317   { "private",          RID_PRIVATE,    0 },
 318   { "protected",        RID_PROTECTED,  0 },
 319   { "public",           RID_PUBLIC,     0 },
 320   { "register",         RID_REGISTER,   0 },
 321   { "reinterpret_cast", RID_REINTCAST,  0 },
 322   { "return",           RID_RETURN,     0 },
 323   { "short",            RID_SHORT,      0 },
 324   { "signed",           RID_SIGNED,     0 },
 325   { "sizeof",           RID_SIZEOF,     0 },
 326   { "static",           RID_STATIC,     0 },
 327   { "static_cast",      RID_STATCAST,   0 },
 328   { "struct",           RID_STRUCT,     0 },
 329   { "switch",           RID_SWITCH,     0 },
 330   { "template",         RID_TEMPLATE,   0 },
 331   { "this",             RID_THIS,       0 },
 332   { "throw",            RID_THROW,      0 },
 333   { "true",             RID_TRUE,       0 },
 334   { "try",              RID_TRY,        0 },
 335   { "typedef",          RID_TYPEDEF,    0 },
 336   { "typename",         RID_TYPENAME,   0 },
 337   { "typeid",           RID_TYPEID,     0 },
 338   { "typeof",           RID_TYPEOF,     D_ASM|D_EXT },
 339   { "union",            RID_UNION,      0 },
 340   { "unsigned",         RID_UNSIGNED,   0 },
 341   { "using",            RID_USING,      0 },
 342   { "virtual",          RID_VIRTUAL,    0 },
 343   { "void",             RID_VOID,       0 },
 344   { "volatile",         RID_VOLATILE,   0 },
 345   { "wchar_t",          RID_WCHAR,      0 },
 346   { "while",            RID_WHILE,      0 },
 347
 348 };
 349
 350 void
 351 init_reswords (void)
 352 {
 353   unsigned int i;
 354   tree id;
 355   int mask = ((flag_no_asm ? D_ASM : 0)
 356               | (flag_no_gnu_keywords ? D_EXT : 0));
 357
 358   ridpointers = (tree *) ggc_calloc ((int) RID_MAX, sizeof (tree));
 359   for (i = 0; i < ARRAY_SIZE (reswords); i++)
 360     {
 361       id = get_identifier (reswords[i].word);
 362       C_RID_CODE (id) = reswords[i].rid;
 363       ridpointers [(int) reswords[i].rid] = id;
 364       if (! (reswords[i].disable & mask))
 365         C_IS_RESERVED_WORD (id) = 1;
 366     }
 367 }
 368
 369 static void
 370 init_cp_pragma (void)
 371 {
 372   c_register_pragma (0, "vtable", handle_pragma_vtable);
 373   c_register_pragma (0, "unit", handle_pragma_unit);
 374   c_register_pragma (0, "interface", handle_pragma_interface);
 375   c_register_pragma (0, "implementation", handle_pragma_implementation);
 376   c_register_pragma ("GCC", "interface", handle_pragma_interface);
 377   c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
 378   c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
 379 }
 380 \f
 381 /* Initialize the C++ front end.  This function is very sensitive to
 382    the exact order that things are done here.  It would be nice if the
 383    initialization done by this routine were moved to its subroutines,
 384    and the ordering dependencies clarified and reduced.  */
 385 bool
 386 cxx_init (void)
 387 {
 388   static const enum tree_code stmt_codes[] = {
 389     c_common_stmt_codes,
 390     cp_stmt_codes
 391   };
 392
 393   INIT_STATEMENT_CODES (stmt_codes);
 394
 395   input_filename = "<internal>";
 396
 397   init_reswords ();
 398   init_tree ();
 399   init_cp_semantics ();
 400   init_operators ();
 401   init_method ();
 402   init_error ();
 403
 404   current_function_decl = NULL;
 405
 406   class_type_node = build_int_2 (class_type, 0);
 407   TREE_TYPE (class_type_node) = class_type_node;
 408   ridpointers[(int) RID_CLASS] = class_type_node;
 409
 410   record_type_node = build_int_2 (record_type, 0);
 411   TREE_TYPE (record_type_node) = record_type_node;
 412   ridpointers[(int) RID_STRUCT] = record_type_node;
 413
 414   union_type_node = build_int_2 (union_type, 0);
 415   TREE_TYPE (union_type_node) = union_type_node;
 416   ridpointers[(int) RID_UNION] = union_type_node;
 417
 418   enum_type_node = build_int_2 (enum_type, 0);
 419   TREE_TYPE (enum_type_node) = enum_type_node;
 420   ridpointers[(int) RID_ENUM] = enum_type_node;
 421
 422   cxx_init_decl_processing ();
 423
 424   /* Create the built-in __null node.  */
 425   null_node = build_int_2 (0, 0);
 426   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
 427   ridpointers[RID_NULL] = null_node;
 428
 429   interface_unknown = 1;
 430
 431   if (c_common_init () == false)
 432     return false;
 433
 434   init_cp_pragma ();
 435
 436   init_repo (main_input_filename);
 437
 438   return true;
 439 }
 440 \f
 441 /* Helper function to load global variables with interface
 442    information.  */
 443
 444 void
 445 extract_interface_info (void)
 446 {
 447   struct c_fileinfo *finfo = 0;
 448
 449   if (flag_alt_external_templates)
 450     {
 451       tree til = tinst_for_decl ();
 452
 453       if (til)
 454         finfo = get_fileinfo (TINST_FILE (til));
 455     }
 456   if (!finfo)
 457     finfo = get_fileinfo (input_filename);
 458
 459   interface_only = finfo->interface_only;
 460   interface_unknown = finfo->interface_unknown;
 461 }
 462
 463 /* Return nonzero if S is not considered part of an
 464    INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
 465
 466 static int
 467 interface_strcmp (const char* s)
 468 {
 469   /* Set the interface/implementation bits for this scope.  */
 470   struct impl_files *ifiles;
 471   const char *s1;
 472
 473   for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
 474     {
 475       const char *t1 = ifiles->filename;
 476       s1 = s;
 477
 478       if (*s1 != *t1 || *s1 == 0)
 479         continue;
 480
 481       while (*s1 == *t1 && *s1 != 0)
 482         s1++, t1++;
 483
 484       /* A match.  */
 485       if (*s1 == *t1)
 486         return 0;
 487
 488       /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
 489       if (strchr (s1, '.') || strchr (t1, '.'))
 490         continue;
 491
 492       if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
 493         continue;
 494
 495       /* A match.  */
 496       return 0;
 497     }
 498
 499   /* No matches.  */
 500   return 1;
 501 }
 502
 503 void
 504 note_got_semicolon (tree type)
 505 {
 506   if (!TYPE_P (type))
 507     abort ();
 508   if (CLASS_TYPE_P (type))
 509     CLASSTYPE_GOT_SEMICOLON (type) = 1;
 510 }
 511
 512 void
 513 note_list_got_semicolon (tree declspecs)
 514 {
 515   tree link;
 516
 517   for (link = declspecs; link; link = TREE_CHAIN (link))
 518     {
 519       tree type = TREE_VALUE (link);
 520       if (type && TYPE_P (type))
 521         note_got_semicolon (type);
 522     }
 523   clear_anon_tags ();
 524 }
 525 \f
 526
 527 /* Parse a #pragma whose sole argument is a string constant.
 528    If OPT is true, the argument is optional.  */
 529 static tree
 530 parse_strconst_pragma (const char* name, int opt)
 531 {
 532   tree result, x;
 533   enum cpp_ttype t;
 534
 535   t = c_lex (&x);
 536   if (t == CPP_STRING)
 537     {
 538       result = x;
 539       if (c_lex (&x) != CPP_EOF)
 540         warning ("junk at end of #pragma %s", name);
 541       return result;
 542     }
 543
 544   if (t == CPP_EOF && opt)
 545     return 0;
 546
 547   error ("invalid #pragma %s", name);
 548   return (tree)-1;
 549 }
 550
 551 static void
 552 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
 553 {
 554   parse_strconst_pragma ("vtable", 0);
 555   sorry ("#pragma vtable no longer supported");
 556 }
 557
 558 static void
 559 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
 560 {
 561   /* Validate syntax, but don't do anything.  */
 562   parse_strconst_pragma ("unit", 0);
 563 }
 564
 565 static void
 566 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
 567 {
 568   tree fname = parse_strconst_pragma ("interface", 1);
 569   struct c_fileinfo *finfo;
 570   const char *main_filename;
 571
 572   if (fname == (tree)-1)
 573     return;
 574   else if (fname == 0)
 575     main_filename = lbasename (input_filename);
 576   else
 577     main_filename = TREE_STRING_POINTER (fname);
 578
 579   finfo = get_fileinfo (input_filename);
 580
 581   if (impl_file_chain == 0)
 582     {
 583       /* If this is zero at this point, then we are
 584          auto-implementing.  */
 585       if (main_input_filename == 0)
 586         main_input_filename = input_filename;
 587     }
 588
 589   interface_only = interface_strcmp (main_filename);
 590 #ifdef MULTIPLE_SYMBOL_SPACES
 591   if (! interface_only)
 592 #endif
 593     interface_unknown = 0;
 594
 595   finfo->interface_only = interface_only;
 596   finfo->interface_unknown = interface_unknown;
 597 }
 598
 599 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
 600    We used to only allow this at toplevel, but that restriction was buggy
 601    in older compilers and it seems reasonable to allow it in the headers
 602    themselves, too.  It only needs to precede the matching #p interface.
 603
 604    We don't touch interface_only or interface_unknown; the user must specify
 605    a matching #p interface for this to have any effect.  */
 606
 607 static void
 608 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
 609 {
 610   tree fname = parse_strconst_pragma ("implementation", 1);
 611   const char *main_filename;
 612   struct impl_files *ifiles = impl_file_chain;
 613
 614   if (fname == (tree)-1)
 615     return;
 616
 617   if (fname == 0)
 618     {
 619       if (main_input_filename)
 620         main_filename = main_input_filename;
 621       else
 622         main_filename = input_filename;
 623       main_filename = lbasename (main_filename);
 624     }
 625   else
 626     {
 627       main_filename = TREE_STRING_POINTER (fname);
 628       if (cpp_included (parse_in, main_filename))
 629         warning ("#pragma implementation for %s appears after file is included",
 630                  main_filename);
 631     }
 632
 633   for (; ifiles; ifiles = ifiles->next)
 634     {
 635       if (! strcmp (ifiles->filename, main_filename))
 636         break;
 637     }
 638   if (ifiles == 0)
 639     {
 640       ifiles = (struct impl_files*) xmalloc (sizeof (struct impl_files));
 641       ifiles->filename = main_filename;
 642       ifiles->next = impl_file_chain;
 643       impl_file_chain = ifiles;
 644     }
 645 }
 646
 647 /* Indicate that this file uses Java-personality exception handling.  */
 648 static void
 649 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED )
 650 {
 651   tree x;
 652   if (c_lex (&x) != CPP_EOF)
 653     warning ("junk at end of #pragma GCC java_exceptions");
 654
 655   choose_personality_routine (lang_java);
 656 }
 657
 658 /* Return true if d is in a global scope.  */
 659
 660 static int
 661 is_global (tree d)
 662 {
 663   while (1)
 664     switch (TREE_CODE (d))
 665       {
 666       case ERROR_MARK:
 667         return 1;
 668
 669       case OVERLOAD: d = OVL_FUNCTION (d); continue;
 670       case TREE_LIST: d = TREE_VALUE (d); continue;
 671       default:
 672         my_friendly_assert (DECL_P (d), 980629);
 673
 674         return DECL_NAMESPACE_SCOPE_P (d);
 675       }
 676 }
 677
 678 /* Issue an error message indicating that the lookup of NAME (an
 679    IDENTIFIER_NODE) failed.  */
 680
 681 void
 682 unqualified_name_lookup_error (tree name)
 683 {
 684   if (IDENTIFIER_OPNAME_P (name))
 685     {
 686       if (name != ansi_opname (ERROR_MARK))
 687         error ("`%D' not defined", name);
 688     }
 689   else if (current_function_decl == 0)
 690     error ("`%D' was not declared in this scope", name);
 691   else
 692     {
 693       if (IDENTIFIER_NAMESPACE_VALUE (name) != error_mark_node
 694           || IDENTIFIER_ERROR_LOCUS (name) != current_function_decl)
 695         {
 696           static int undeclared_variable_notice;
 697
 698           error ("`%D' undeclared (first use this function)", name);
 699
 700           if (! undeclared_variable_notice)
 701             {
 702               error ("(Each undeclared identifier is reported only once for each function it appears in.)");
 703               undeclared_variable_notice = 1;
 704             }
 705         }
 706       /* Prevent repeated error messages.  */
 707       SET_IDENTIFIER_NAMESPACE_VALUE (name, error_mark_node);
 708       SET_IDENTIFIER_ERROR_LOCUS (name, current_function_decl);
 709     }
 710 }
 711
 712 tree
 713 do_identifier (register tree token, tree args)
 714 {
 715   register tree id;
 716
 717   timevar_push (TV_NAME_LOOKUP);
 718   id = lookup_name (token, 0);
 719
 720   /* Do Koenig lookup if appropriate (inside templates we build lookup
 721      expressions instead).
 722
 723      [basic.lookup.koenig]: If the ordinary unqualified lookup of the name
 724      finds the declaration of a class member function, the associated
 725      namespaces and classes are not considered.  */
 726
 727   if (args && !current_template_parms && (!id || is_global (id)))
 728     id = lookup_arg_dependent (token, id, args);
 729
 730   if (id == error_mark_node)
 731     {
 732       /* lookup_name quietly returns error_mark_node if we're parsing,
 733          as we don't want to complain about an identifier that ends up
 734          being used as a declarator.  So we call it again to get the error
 735          message.  */
 736       id = lookup_name (token, 0);
 737       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
 738     }
 739
 740   if (!id || (TREE_CODE (id) == FUNCTION_DECL
 741               && DECL_ANTICIPATED (id)))
 742     {
 743       if (current_template_parms)
 744         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
 745                                 build_min_nt (LOOKUP_EXPR, token));
 746       else if (IDENTIFIER_TYPENAME_P (token))
 747         /* A templated conversion operator might exist.  */
 748         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, token);
 749       else
 750         {
 751           unqualified_name_lookup_error (token);
 752           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
 753         }
 754     }
 755
 756   id = check_for_out_of_scope_variable (id);
 757
 758   /* TREE_USED is set in `hack_identifier'.  */
 759   if (TREE_CODE (id) == CONST_DECL)
 760     {
 761       /* Check access.  */
 762       if (IDENTIFIER_CLASS_VALUE (token) == id)
 763         perform_or_defer_access_check (TYPE_BINFO (DECL_CONTEXT (id)), id);
 764       if (!processing_template_decl || DECL_TEMPLATE_PARM_P (id))
 765         id = DECL_INITIAL (id);
 766     }
 767   else
 768     id = hack_identifier (id, token);
 769
 770   /* We must look up dependent names when the template is
 771      instantiated, not while parsing it.  For now, we don't
 772      distinguish between dependent and independent names.  So, for
 773      example, we look up all overloaded functions at
 774      instantiation-time, even though in some cases we should just use
 775      the DECL we have here.  We also use LOOKUP_EXPRs to find things
 776      like local variables, rather than creating TEMPLATE_DECLs for the
 777      local variables and then finding matching instantiations.  */
 778   if (current_template_parms
 779       && (is_overloaded_fn (id)
 780           || (TREE_CODE (id) == VAR_DECL
 781               && CP_DECL_CONTEXT (id)
 782               && TREE_CODE (CP_DECL_CONTEXT (id)) == FUNCTION_DECL)
 783           || TREE_CODE (id) == PARM_DECL
 784           || TREE_CODE (id) == RESULT_DECL
 785           || TREE_CODE (id) == USING_DECL))
 786     id = build_min_nt (LOOKUP_EXPR, token);
 787
 788   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, id);
 789 }
 790
 791 tree
 792 do_scoped_id (tree token, tree id)
 793 {
 794   timevar_push (TV_NAME_LOOKUP);
 795   if (!id || (TREE_CODE (id) == FUNCTION_DECL
 796               && DECL_ANTICIPATED (id)))
 797     {
 798       if (processing_template_decl)
 799         {
 800           id = build_min_nt (LOOKUP_EXPR, token);
 801           LOOKUP_EXPR_GLOBAL (id) = 1;
 802           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, id);
 803         }
 804       if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
 805         error ("`::%D' undeclared (first use here)", token);
 806       id = error_mark_node;
 807       /* Prevent repeated error messages.  */
 808       SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
 809     }
 810   else
 811     {
 812       if (TREE_CODE (id) == ADDR_EXPR)
 813         mark_used (TREE_OPERAND (id, 0));
 814       else if (TREE_CODE (id) != OVERLOAD)
 815         mark_used (id);
 816     }
 817   if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
 818     {
 819       /* XXX CHS - should we set TREE_USED of the constant? */
 820       id = DECL_INITIAL (id);
 821       /* This is to prevent an enum whose value is 0
 822          from being considered a null pointer constant.  */
 823       id = build1 (NOP_EXPR, TREE_TYPE (id), id);
 824       TREE_CONSTANT (id) = 1;
 825     }
 826
 827   if (processing_template_decl)
 828     {
 829       if (is_overloaded_fn (id))
 830         {
 831           id = build_min_nt (LOOKUP_EXPR, token);
 832           LOOKUP_EXPR_GLOBAL (id) = 1;
 833           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, id);
 834         }
 835       /* else just use the decl */
 836     }
 837   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, convert_from_reference (id));
 838 }
 839
 840 tree
 841 identifier_typedecl_value (tree node)
 842 {
 843   tree t, type;
 844   type = IDENTIFIER_TYPE_VALUE (node);
 845   if (type == NULL_TREE)
 846     return NULL_TREE;
 847
 848   if (IDENTIFIER_BINDING (node))
 849     {
 850       t = IDENTIFIER_VALUE (node);
 851       if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
 852         return t;
 853     }
 854   if (IDENTIFIER_NAMESPACE_VALUE (node))
 855     {
 856       t = IDENTIFIER_NAMESPACE_VALUE (node);
 857       if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
 858         return t;
 859     }
 860
 861   /* Will this one ever happen?  */
 862   if (TYPE_MAIN_DECL (type))
 863     return TYPE_MAIN_DECL (type);
 864
 865   /* We used to do an internal error of 62 here, but instead we will
 866      handle the return of a null appropriately in the callers.  */
 867   return NULL_TREE;
 868 }
 869
 870 #ifdef GATHER_STATISTICS
 871 /* The original for tree_node_kind is in the toplevel tree.c; changes there
 872    need to be brought into here, unless this were actually put into a header
 873    instead.  */
 874 /* Statistics-gathering stuff.  */
 875 typedef enum
 876 {
 877   d_kind,
 878   t_kind,
 879   b_kind,
 880   s_kind,
 881   r_kind,
 882   e_kind,
 883   c_kind,
 884   id_kind,
 885   op_id_kind,
 886   perm_list_kind,
 887   temp_list_kind,
 888   vec_kind,
 889   x_kind,
 890   lang_decl,
 891   lang_type,
 892   all_kinds
 893 } tree_node_kind;
 894
 895 extern int tree_node_counts[];
 896 extern int tree_node_sizes[];
 897 #endif
 898
 899 tree
 900 build_lang_decl (enum tree_code code, tree name, tree type)
 901 {
 902   tree t;
 903
 904   t = build_decl (code, name, type);
 905   retrofit_lang_decl (t);
 906
 907   return t;
 908 }
 909
 910 /* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
 911    and pushdecl (for functions generated by the backend).  */
 912
 913 void
 914 retrofit_lang_decl (tree t)
 915 {
 916   struct lang_decl *ld;
 917   size_t size;
 918
 919   if (CAN_HAVE_FULL_LANG_DECL_P (t))
 920     size = sizeof (struct lang_decl);
 921   else
 922     size = sizeof (struct lang_decl_flags);
 923
 924   ld = (struct lang_decl *) ggc_alloc_cleared (size);
 925
 926   ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
 927   ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
 928   ld->decl_flags.u2sel = 0;
 929   if (ld->decl_flags.can_be_full)
 930     ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
 931
 932   DECL_LANG_SPECIFIC (t) = ld;
 933   if (current_lang_name == lang_name_cplusplus)
 934     SET_DECL_LANGUAGE (t, lang_cplusplus);
 935   else if (current_lang_name == lang_name_c)
 936     SET_DECL_LANGUAGE (t, lang_c);
 937   else if (current_lang_name == lang_name_java)
 938     SET_DECL_LANGUAGE (t, lang_java);
 939   else abort ();
 940
 941 #ifdef GATHER_STATISTICS
 942   tree_node_counts[(int)lang_decl] += 1;
 943   tree_node_sizes[(int)lang_decl] += size;
 944 #endif
 945 }
 946
 947 void
 948 cxx_dup_lang_specific_decl (tree node)
 949 {
 950   int size;
 951   struct lang_decl *ld;
 952
 953   if (! DECL_LANG_SPECIFIC (node))
 954     return;
 955
 956   if (!CAN_HAVE_FULL_LANG_DECL_P (node))
 957     size = sizeof (struct lang_decl_flags);
 958   else
 959     size = sizeof (struct lang_decl);
 960   ld = (struct lang_decl *) ggc_alloc (size);
 961   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
 962   DECL_LANG_SPECIFIC (node) = ld;
 963
 964 #ifdef GATHER_STATISTICS
 965   tree_node_counts[(int)lang_decl] += 1;
 966   tree_node_sizes[(int)lang_decl] += size;
 967 #endif
 968 }
 969
 970 /* Copy DECL, including any language-specific parts.  */
 971
 972 tree
 973 copy_decl (tree decl)
 974 {
 975   tree copy;
 976
 977   copy = copy_node (decl);
 978   cxx_dup_lang_specific_decl (copy);
 979   return copy;
 980 }
 981
 982 /* Replace the shared language-specific parts of NODE with a new copy.  */
 983
 984 static void
 985 copy_lang_type (tree node)
 986 {
 987   int size;
 988   struct lang_type *lt;
 989
 990   if (! TYPE_LANG_SPECIFIC (node))
 991     return;
 992
 993   if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
 994     size = sizeof (struct lang_type);
 995   else
 996     size = sizeof (struct lang_type_ptrmem);
 997   lt = (struct lang_type *) ggc_alloc (size);
 998   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
 999   TYPE_LANG_SPECIFIC (node) = lt;
1000
1001 #ifdef GATHER_STATISTICS
1002   tree_node_counts[(int)lang_type] += 1;
1003   tree_node_sizes[(int)lang_type] += size;
1004 #endif
1005 }
1006
1007 /* Copy TYPE, including any language-specific parts.  */
1008
1009 tree
1010 copy_type (tree type)
1011 {
1012   tree copy;
1013
1014   copy = copy_node (type);
1015   copy_lang_type (copy);
1016   return copy;
1017 }
1018
1019 tree
1020 cxx_make_type (enum tree_code code)
1021 {
1022   register tree t = make_node (code);
1023
1024   /* Create lang_type structure.  */
1025   if (IS_AGGR_TYPE_CODE (code)
1026       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
1027     {
1028       struct lang_type *pi;
1029
1030       pi = ((struct lang_type *)
1031             ggc_alloc_cleared (sizeof (struct lang_type)));
1032
1033       TYPE_LANG_SPECIFIC (t) = pi;
1034       pi->u.c.h.is_lang_type_class = 1;
1035
1036 #ifdef GATHER_STATISTICS
1037       tree_node_counts[(int)lang_type] += 1;
1038       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
1039 #endif
1040     }
1041
1042   /* Set up some flags that give proper default behavior.  */
1043   if (IS_AGGR_TYPE_CODE (code))
1044     {
1045       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
1046       CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
1047
1048       /* Make sure this is laid out, for ease of use later.  In the
1049          presence of parse errors, the normal was of assuring this
1050          might not ever get executed, so we lay it out *immediately*.  */
1051       build_pointer_type (t);
1052     }
1053   else
1054     /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits.  But,
1055        TYPE_ALIAS_SET is initialized to -1 by default, so we must
1056        clear it here.  */
1057     TYPE_ALIAS_SET (t) = 0;
1058
1059   /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
1060      since they can be virtual base types, and we then need a
1061      canonical binfo for them.  Ideally, this would be done lazily for
1062      all types.  */
1063   if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM
1064       || code == BOUND_TEMPLATE_TEMPLATE_PARM
1065       || code == TYPENAME_TYPE)
1066     TYPE_BINFO (t) = make_binfo (size_zero_node, t, NULL_TREE, NULL_TREE);
1067
1068   return t;
1069 }
1070
1071 tree
1072 make_aggr_type (enum tree_code code)
1073 {
1074   tree t = cxx_make_type (code);
1075
1076   if (IS_AGGR_TYPE_CODE (code))
1077     SET_IS_AGGR_TYPE (t, 1);
1078
1079   return t;
1080 }
1081
1082 /* Return the type-qualifier corresponding to the identifier given by
1083    RID.  */
1084
1085 int
1086 cp_type_qual_from_rid (tree rid)
1087 {
1088   if (rid == ridpointers[(int) RID_CONST])
1089     return TYPE_QUAL_CONST;
1090   else if (rid == ridpointers[(int) RID_VOLATILE])
1091     return TYPE_QUAL_VOLATILE;
1092   else if (rid == ridpointers[(int) RID_RESTRICT])
1093     return TYPE_QUAL_RESTRICT;
1094
1095   abort ();
1096   return TYPE_UNQUALIFIED;
1097 }