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