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 #ifdef MULTIBYTE_CHARS
  44 #include "mbchar.h"
  45 #include <locale.h>
  46 #endif
  47
  48 static int interface_strcmp PARAMS ((const char *));
  49 static void init_cp_pragma PARAMS ((void));
  50
  51 static tree parse_strconst_pragma PARAMS ((const char *, int));
  52 static void handle_pragma_vtable PARAMS ((cpp_reader *));
  53 static void handle_pragma_unit PARAMS ((cpp_reader *));
  54 static void handle_pragma_interface PARAMS ((cpp_reader *));
  55 static void handle_pragma_implementation PARAMS ((cpp_reader *));
  56 static void handle_pragma_java_exceptions PARAMS ((cpp_reader *));
  57
  58 static int is_global PARAMS ((tree));
  59 static void init_operators PARAMS ((void));
  60 static void copy_lang_type PARAMS ((tree));
  61
  62 /* A constraint that can be tested at compile time.  */
  63 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
  64
  65 /* Functions and data structures for #pragma interface.
  66
  67    `#pragma implementation' means that the main file being compiled
  68    is considered to implement (provide) the classes that appear in
  69    its main body.  I.e., if this is file "foo.cc", and class `bar'
  70    is defined in "foo.cc", then we say that "foo.cc implements bar".
  71
  72    All main input files "implement" themselves automagically.
  73
  74    `#pragma interface' means that unless this file (of the form "foo.h"
  75    is not presently being included by file "foo.cc", the
  76    CLASSTYPE_INTERFACE_ONLY bit gets set.  The effect is that none
  77    of the vtables nor any of the inline functions defined in foo.h
  78    will ever be output.
  79
  80    There are cases when we want to link files such as "defs.h" and
  81    "main.cc".  In this case, we give "defs.h" a `#pragma interface',
  82    and "main.cc" has `#pragma implementation "defs.h"'.  */
  83
  84 struct impl_files
  85 {
  86   const char *filename;
  87   struct impl_files *next;
  88 };
  89
  90 static struct impl_files *impl_file_chain;
  91
  92 \f
  93 /* Return something to represent absolute declarators containing a *.
  94    TARGET is the absolute declarator that the * contains.
  95    CV_QUALIFIERS is a list of modifiers such as const or volatile
  96    to apply to the pointer type, represented as identifiers.
  97
  98    We return an INDIRECT_REF whose "contents" are TARGET
  99    and whose type is the modifier list.  */
 100
 101 tree
 102 make_pointer_declarator (cv_qualifiers, target)
 103      tree cv_qualifiers, target;
 104 {
 105   if (target && TREE_CODE (target) == IDENTIFIER_NODE
 106       && ANON_AGGRNAME_P (target))
 107     error ("type name expected before `*'");
 108   target = build_nt (INDIRECT_REF, target);
 109   TREE_TYPE (target) = cv_qualifiers;
 110   return target;
 111 }
 112
 113 /* Return something to represent absolute declarators containing a &.
 114    TARGET is the absolute declarator that the & contains.
 115    CV_QUALIFIERS is a list of modifiers such as const or volatile
 116    to apply to the reference type, represented as identifiers.
 117
 118    We return an ADDR_EXPR whose "contents" are TARGET
 119    and whose type is the modifier list.  */
 120
 121 tree
 122 make_reference_declarator (cv_qualifiers, target)
 123      tree cv_qualifiers, target;
 124 {
 125   target = build_nt (ADDR_EXPR, target);
 126   TREE_TYPE (target) = cv_qualifiers;
 127   return target;
 128 }
 129
 130 tree
 131 make_call_declarator (target, parms, cv_qualifiers, exception_specification)
 132      tree target, parms, cv_qualifiers, exception_specification;
 133 {
 134   target = build_nt (CALL_EXPR, target,
 135                      tree_cons (parms, cv_qualifiers, NULL_TREE),
 136                      /* The third operand is really RTL.  We
 137                         shouldn't put anything there.  */
 138                      NULL_TREE);
 139   CALL_DECLARATOR_EXCEPTION_SPEC (target) = exception_specification;
 140   return target;
 141 }
 142
 143 void
 144 set_quals_and_spec (call_declarator, cv_qualifiers, exception_specification)
 145      tree call_declarator, cv_qualifiers, exception_specification;
 146 {
 147   CALL_DECLARATOR_QUALS (call_declarator) = cv_qualifiers;
 148   CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator) = exception_specification;
 149 }
 150 \f
 151 int interface_only;             /* whether or not current file is only for
 152                                    interface definitions.  */
 153 int interface_unknown;          /* whether or not we know this class
 154                                    to behave according to #pragma interface.  */
 155
 156 \f
 157 /* Initialization before switch parsing.  */
 158 void
 159 cxx_init_options ()
 160 {
 161   c_common_init_options (clk_cplusplus);
 162
 163   /* Default exceptions on.  */
 164   flag_exceptions = 1;
 165   /* By default wrap lines at 80 characters.  Is getenv ("COLUMNS")
 166      preferable?  */
 167   diagnostic_line_cutoff (global_dc) = 80;
 168   /* By default, emit location information once for every
 169      diagnostic message.  */
 170   diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 171 }
 172
 173 void
 174 cxx_finish ()
 175 {
 176   c_common_finish ();
 177 }
 178
 179 /* A mapping from tree codes to operator name information.  */
 180 operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE];
 181 /* Similar, but for assignment operators.  */
 182 operator_name_info_t assignment_operator_name_info[(int) LAST_CPLUS_TREE_CODE];
 183
 184 /* Initialize data structures that keep track of operator names.  */
 185
 186 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
 187  CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
 188 #include "operators.def"
 189 #undef DEF_OPERATOR
 190
 191 static void
 192 init_operators ()
 193 {
 194   tree identifier;
 195   char buffer[256];
 196   struct operator_name_info_t *oni;
 197
 198 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)                   \
 199   sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
 200   identifier = get_identifier (buffer);                                     \
 201   IDENTIFIER_OPNAME_P (identifier) = 1;                                     \
 202                                                                             \
 203   oni = (ASSN_P                                                             \
 204          ? &assignment_operator_name_info[(int) CODE]                       \
 205          : &operator_name_info[(int) CODE]);                                \
 206   oni->identifier = identifier;                                             \
 207   oni->name = NAME;                                                         \
 208   oni->mangled_name = MANGLING;                                             \
 209   oni->arity = ARITY;
 210
 211 #include "operators.def"
 212 #undef DEF_OPERATOR
 213
 214   operator_name_info[(int) ERROR_MARK].identifier
 215     = get_identifier ("<invalid operator>");
 216
 217   /* Handle some special cases.  These operators are not defined in
 218      the language, but can be produced internally.  We may need them
 219      for error-reporting.  (Eventually, we should ensure that this
 220      does not happen.  Error messages involving these operators will
 221      be confusing to users.)  */
 222
 223   operator_name_info [(int) INIT_EXPR].name
 224     = operator_name_info [(int) MODIFY_EXPR].name;
 225   operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
 226   operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
 227   operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
 228   operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
 229   operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
 230   operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
 231   operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
 232   operator_name_info [(int) ABS_EXPR].name = "abs";
 233   operator_name_info [(int) FFS_EXPR].name = "ffs";
 234   operator_name_info [(int) BIT_ANDTC_EXPR].name = "&~";
 235   operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
 236   operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
 237   operator_name_info [(int) IN_EXPR].name = "in";
 238   operator_name_info [(int) RANGE_EXPR].name = "...";
 239   operator_name_info [(int) CONVERT_EXPR].name = "+";
 240
 241   assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
 242     = "(exact /=)";
 243   assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
 244     = "(ceiling /=)";
 245   assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
 246     = "(floor /=)";
 247   assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
 248     = "(round /=)";
 249   assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
 250     = "(ceiling %=)";
 251   assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
 252     = "(floor %=)";
 253   assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
 254     = "(round %=)";
 255 }
 256
 257 /* The reserved keyword table.  */
 258 struct resword
 259 {
 260   const char *const word;
 261   const ENUM_BITFIELD(rid) rid : 16;
 262   const unsigned int disable   : 16;
 263 };
 264
 265 /* Disable mask.  Keywords are disabled if (reswords[i].disable & mask) is
 266    _true_.  */
 267 #define D_EXT           0x01    /* GCC extension */
 268 #define D_ASM           0x02    /* in C99, but has a switch to turn it off */
 269
 270 CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
 271
 272 static const struct resword reswords[] =
 273 {
 274   { "_Complex",         RID_COMPLEX,    0 },
 275   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
 276   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
 277   { "__alignof",        RID_ALIGNOF,    0 },
 278   { "__alignof__",      RID_ALIGNOF,    0 },
 279   { "__asm",            RID_ASM,        0 },
 280   { "__asm__",          RID_ASM,        0 },
 281   { "__attribute",      RID_ATTRIBUTE,  0 },
 282   { "__attribute__",    RID_ATTRIBUTE,  0 },
 283   { "__builtin_va_arg", RID_VA_ARG,     0 },
 284   { "__complex",        RID_COMPLEX,    0 },
 285   { "__complex__",      RID_COMPLEX,    0 },
 286   { "__const",          RID_CONST,      0 },
 287   { "__const__",        RID_CONST,      0 },
 288   { "__extension__",    RID_EXTENSION,  0 },
 289   { "__func__",         RID_C99_FUNCTION_NAME,  0 },
 290   { "__imag",           RID_IMAGPART,   0 },
 291   { "__imag__",         RID_IMAGPART,   0 },
 292   { "__inline",         RID_INLINE,     0 },
 293   { "__inline__",       RID_INLINE,     0 },
 294   { "__label__",        RID_LABEL,      0 },
 295   { "__null",           RID_NULL,       0 },
 296   { "__real",           RID_REALPART,   0 },
 297   { "__real__",         RID_REALPART,   0 },
 298   { "__restrict",       RID_RESTRICT,   0 },
 299   { "__restrict__",     RID_RESTRICT,   0 },
 300   { "__signed",         RID_SIGNED,     0 },
 301   { "__signed__",       RID_SIGNED,     0 },
 302   { "__thread",         RID_THREAD,     0 },
 303   { "__typeof",         RID_TYPEOF,     0 },
 304   { "__typeof__",       RID_TYPEOF,     0 },
 305   { "__volatile",       RID_VOLATILE,   0 },
 306   { "__volatile__",     RID_VOLATILE,   0 },
 307   { "asm",              RID_ASM,        D_ASM },
 308   { "auto",             RID_AUTO,       0 },
 309   { "bool",             RID_BOOL,       0 },
 310   { "break",            RID_BREAK,      0 },
 311   { "case",             RID_CASE,       0 },
 312   { "catch",            RID_CATCH,      0 },
 313   { "char",             RID_CHAR,       0 },
 314   { "class",            RID_CLASS,      0 },
 315   { "const",            RID_CONST,      0 },
 316   { "const_cast",       RID_CONSTCAST,  0 },
 317   { "continue",         RID_CONTINUE,   0 },
 318   { "default",          RID_DEFAULT,    0 },
 319   { "delete",           RID_DELETE,     0 },
 320   { "do",               RID_DO,         0 },
 321   { "double",           RID_DOUBLE,     0 },
 322   { "dynamic_cast",     RID_DYNCAST,    0 },
 323   { "else",             RID_ELSE,       0 },
 324   { "enum",             RID_ENUM,       0 },
 325   { "explicit",         RID_EXPLICIT,   0 },
 326   { "export",           RID_EXPORT,     0 },
 327   { "extern",           RID_EXTERN,     0 },
 328   { "false",            RID_FALSE,      0 },
 329   { "float",            RID_FLOAT,      0 },
 330   { "for",              RID_FOR,        0 },
 331   { "friend",           RID_FRIEND,     0 },
 332   { "goto",             RID_GOTO,       0 },
 333   { "if",               RID_IF,         0 },
 334   { "inline",           RID_INLINE,     0 },
 335   { "int",              RID_INT,        0 },
 336   { "long",             RID_LONG,       0 },
 337   { "mutable",          RID_MUTABLE,    0 },
 338   { "namespace",        RID_NAMESPACE,  0 },
 339   { "new",              RID_NEW,        0 },
 340   { "operator",         RID_OPERATOR,   0 },
 341   { "private",          RID_PRIVATE,    0 },
 342   { "protected",        RID_PROTECTED,  0 },
 343   { "public",           RID_PUBLIC,     0 },
 344   { "register",         RID_REGISTER,   0 },
 345   { "reinterpret_cast", RID_REINTCAST,  0 },
 346   { "return",           RID_RETURN,     0 },
 347   { "short",            RID_SHORT,      0 },
 348   { "signed",           RID_SIGNED,     0 },
 349   { "sizeof",           RID_SIZEOF,     0 },
 350   { "static",           RID_STATIC,     0 },
 351   { "static_cast",      RID_STATCAST,   0 },
 352   { "struct",           RID_STRUCT,     0 },
 353   { "switch",           RID_SWITCH,     0 },
 354   { "template",         RID_TEMPLATE,   0 },
 355   { "this",             RID_THIS,       0 },
 356   { "throw",            RID_THROW,      0 },
 357   { "true",             RID_TRUE,       0 },
 358   { "try",              RID_TRY,        0 },
 359   { "typedef",          RID_TYPEDEF,    0 },
 360   { "typename",         RID_TYPENAME,   0 },
 361   { "typeid",           RID_TYPEID,     0 },
 362   { "typeof",           RID_TYPEOF,     D_ASM|D_EXT },
 363   { "union",            RID_UNION,      0 },
 364   { "unsigned",         RID_UNSIGNED,   0 },
 365   { "using",            RID_USING,      0 },
 366   { "virtual",          RID_VIRTUAL,    0 },
 367   { "void",             RID_VOID,       0 },
 368   { "volatile",         RID_VOLATILE,   0 },
 369   { "wchar_t",          RID_WCHAR,      0 },
 370   { "while",            RID_WHILE,      0 },
 371
 372 };
 373
 374 void
 375 init_reswords ()
 376 {
 377   unsigned int i;
 378   tree id;
 379   int mask = ((flag_no_asm ? D_ASM : 0)
 380               | (flag_no_gnu_keywords ? D_EXT : 0));
 381
 382   ridpointers = (tree *) ggc_calloc ((int) RID_MAX, sizeof (tree));
 383   for (i = 0; i < ARRAY_SIZE (reswords); i++)
 384     {
 385       id = get_identifier (reswords[i].word);
 386       C_RID_CODE (id) = reswords[i].rid;
 387       ridpointers [(int) reswords[i].rid] = id;
 388       if (! (reswords[i].disable & mask))
 389         C_IS_RESERVED_WORD (id) = 1;
 390     }
 391 }
 392
 393 static void
 394 init_cp_pragma ()
 395 {
 396   c_register_pragma (0, "vtable", handle_pragma_vtable);
 397   c_register_pragma (0, "unit", handle_pragma_unit);
 398   c_register_pragma (0, "interface", handle_pragma_interface);
 399   c_register_pragma (0, "implementation", handle_pragma_implementation);
 400   c_register_pragma ("GCC", "interface", handle_pragma_interface);
 401   c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
 402   c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
 403 }
 404
 405 /* Initialize the C++ front end.  This function is very sensitive to
 406    the exact order that things are done here.  It would be nice if the
 407    initialization done by this routine were moved to its subroutines,
 408    and the ordering dependencies clarified and reduced.  */
 409 const char *
 410 cxx_init (filename)
 411      const char *filename;
 412 {
 413   input_filename = "<internal>";
 414
 415   init_reswords ();
 416   init_tree ();
 417   init_cp_semantics ();
 418   init_operators ();
 419   init_method ();
 420   init_error ();
 421
 422   current_function_decl = NULL;
 423
 424   class_type_node = build_int_2 (class_type, 0);
 425   TREE_TYPE (class_type_node) = class_type_node;
 426   ridpointers[(int) RID_CLASS] = class_type_node;
 427
 428   record_type_node = build_int_2 (record_type, 0);
 429   TREE_TYPE (record_type_node) = record_type_node;
 430   ridpointers[(int) RID_STRUCT] = record_type_node;
 431
 432   union_type_node = build_int_2 (union_type, 0);
 433   TREE_TYPE (union_type_node) = union_type_node;
 434   ridpointers[(int) RID_UNION] = union_type_node;
 435
 436   enum_type_node = build_int_2 (enum_type, 0);
 437   TREE_TYPE (enum_type_node) = enum_type_node;
 438   ridpointers[(int) RID_ENUM] = enum_type_node;
 439
 440   cxx_init_decl_processing ();
 441
 442   /* Create the built-in __null node.  */
 443   null_node = build_int_2 (0, 0);
 444   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
 445   ridpointers[RID_NULL] = null_node;
 446
 447   interface_unknown = 1;
 448
 449   filename = c_common_init (filename);
 450   if (filename == NULL)
 451     return NULL;
 452
 453   init_cp_pragma ();
 454
 455   init_repo (filename);
 456
 457   return filename;
 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         enforce_access (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 }