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   id = lookup_name (token, 0);
 750
 751   /* Do Koenig lookup if appropriate (inside templates we build lookup
 752      expressions instead).
 753
 754      [basic.lookup.koenig]: If the ordinary unqualified lookup of the name
 755      finds the declaration of a class member function, the associated
 756      namespaces and classes are not considered.  */
 757
 758   if (args && !current_template_parms && (!id || is_global (id)))
 759     id = lookup_arg_dependent (token, id, args);
 760
 761   if (id == error_mark_node)
 762     {
 763       /* lookup_name quietly returns error_mark_node if we're parsing,
 764          as we don't want to complain about an identifier that ends up
 765          being used as a declarator.  So we call it again to get the error
 766          message.  */
 767       id = lookup_name (token, 0);
 768       return error_mark_node;
 769     }
 770
 771   if (!id || (TREE_CODE (id) == FUNCTION_DECL
 772               && DECL_ANTICIPATED (id)))
 773     {
 774       if (current_template_parms)
 775         return build_min_nt (LOOKUP_EXPR, token);
 776       else if (IDENTIFIER_TYPENAME_P (token))
 777         /* A templated conversion operator might exist.  */
 778         return token;
 779       else
 780         {
 781           unqualified_name_lookup_error (token);
 782           return error_mark_node;
 783         }
 784     }
 785
 786   id = check_for_out_of_scope_variable (id);
 787
 788   /* TREE_USED is set in `hack_identifier'.  */
 789   if (TREE_CODE (id) == CONST_DECL)
 790     {
 791       /* Check access.  */
 792       if (IDENTIFIER_CLASS_VALUE (token) == id)
 793         enforce_access (CP_DECL_CONTEXT(id), id);
 794       if (!processing_template_decl || DECL_TEMPLATE_PARM_P (id))
 795         id = DECL_INITIAL (id);
 796     }
 797   else
 798     id = hack_identifier (id, token);
 799
 800   /* We must look up dependent names when the template is
 801      instantiated, not while parsing it.  For now, we don't
 802      distinguish between dependent and independent names.  So, for
 803      example, we look up all overloaded functions at
 804      instantiation-time, even though in some cases we should just use
 805      the DECL we have here.  We also use LOOKUP_EXPRs to find things
 806      like local variables, rather than creating TEMPLATE_DECLs for the
 807      local variables and then finding matching instantiations.  */
 808   if (current_template_parms
 809       && (is_overloaded_fn (id)
 810           || (TREE_CODE (id) == VAR_DECL
 811               && CP_DECL_CONTEXT (id)
 812               && TREE_CODE (CP_DECL_CONTEXT (id)) == FUNCTION_DECL)
 813           || TREE_CODE (id) == PARM_DECL
 814           || TREE_CODE (id) == RESULT_DECL
 815           || TREE_CODE (id) == USING_DECL))
 816     id = build_min_nt (LOOKUP_EXPR, token);
 817
 818   return id;
 819 }
 820
 821 tree
 822 do_scoped_id (token, id)
 823      tree token;
 824      tree id;
 825 {
 826   if (!id || (TREE_CODE (id) == FUNCTION_DECL
 827               && DECL_ANTICIPATED (id)))
 828     {
 829       if (processing_template_decl)
 830         {
 831           id = build_min_nt (LOOKUP_EXPR, token);
 832           LOOKUP_EXPR_GLOBAL (id) = 1;
 833           return id;
 834         }
 835       if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
 836         error ("`::%D' undeclared (first use here)", token);
 837       id = error_mark_node;
 838       /* Prevent repeated error messages.  */
 839       SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
 840     }
 841   else
 842     {
 843       if (TREE_CODE (id) == ADDR_EXPR)
 844         mark_used (TREE_OPERAND (id, 0));
 845       else if (TREE_CODE (id) != OVERLOAD)
 846         mark_used (id);
 847     }
 848   if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
 849     {
 850       /* XXX CHS - should we set TREE_USED of the constant? */
 851       id = DECL_INITIAL (id);
 852       /* This is to prevent an enum whose value is 0
 853          from being considered a null pointer constant.  */
 854       id = build1 (NOP_EXPR, TREE_TYPE (id), id);
 855       TREE_CONSTANT (id) = 1;
 856     }
 857
 858   if (processing_template_decl)
 859     {
 860       if (is_overloaded_fn (id))
 861         {
 862           id = build_min_nt (LOOKUP_EXPR, token);
 863           LOOKUP_EXPR_GLOBAL (id) = 1;
 864           return id;
 865         }
 866       /* else just use the decl */
 867     }
 868   return convert_from_reference (id);
 869 }
 870
 871 tree
 872 identifier_typedecl_value (node)
 873      tree node;
 874 {
 875   tree t, type;
 876   type = IDENTIFIER_TYPE_VALUE (node);
 877   if (type == NULL_TREE)
 878     return NULL_TREE;
 879
 880   if (IDENTIFIER_BINDING (node))
 881     {
 882       t = IDENTIFIER_VALUE (node);
 883       if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
 884         return t;
 885     }
 886   if (IDENTIFIER_NAMESPACE_VALUE (node))
 887     {
 888       t = IDENTIFIER_NAMESPACE_VALUE (node);
 889       if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
 890         return t;
 891     }
 892
 893   /* Will this one ever happen?  */
 894   if (TYPE_MAIN_DECL (type))
 895     return TYPE_MAIN_DECL (type);
 896
 897   /* We used to do an internal error of 62 here, but instead we will
 898      handle the return of a null appropriately in the callers.  */
 899   return NULL_TREE;
 900 }
 901
 902 #ifdef GATHER_STATISTICS
 903 /* The original for tree_node_kind is in the toplevel tree.c; changes there
 904    need to be brought into here, unless this were actually put into a header
 905    instead.  */
 906 /* Statistics-gathering stuff.  */
 907 typedef enum
 908 {
 909   d_kind,
 910   t_kind,
 911   b_kind,
 912   s_kind,
 913   r_kind,
 914   e_kind,
 915   c_kind,
 916   id_kind,
 917   op_id_kind,
 918   perm_list_kind,
 919   temp_list_kind,
 920   vec_kind,
 921   x_kind,
 922   lang_decl,
 923   lang_type,
 924   all_kinds
 925 } tree_node_kind;
 926
 927 extern int tree_node_counts[];
 928 extern int tree_node_sizes[];
 929 #endif
 930
 931 tree
 932 build_lang_decl (code, name, type)
 933      enum tree_code code;
 934      tree name;
 935      tree type;
 936 {
 937   tree t;
 938
 939   t = build_decl (code, name, type);
 940   retrofit_lang_decl (t);
 941
 942   return t;
 943 }
 944
 945 /* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
 946    and pushdecl (for functions generated by the backend).  */
 947
 948 void
 949 retrofit_lang_decl (t)
 950      tree t;
 951 {
 952   struct lang_decl *ld;
 953   size_t size;
 954
 955   if (CAN_HAVE_FULL_LANG_DECL_P (t))
 956     size = sizeof (struct lang_decl);
 957   else
 958     size = sizeof (struct lang_decl_flags);
 959
 960   ld = (struct lang_decl *) ggc_alloc_cleared (size);
 961
 962   ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
 963   ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
 964   ld->decl_flags.u2sel = 0;
 965   if (ld->decl_flags.can_be_full)
 966     ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
 967
 968   DECL_LANG_SPECIFIC (t) = ld;
 969   if (current_lang_name == lang_name_cplusplus)
 970     SET_DECL_LANGUAGE (t, lang_cplusplus);
 971   else if (current_lang_name == lang_name_c)
 972     SET_DECL_LANGUAGE (t, lang_c);
 973   else if (current_lang_name == lang_name_java)
 974     SET_DECL_LANGUAGE (t, lang_java);
 975   else abort ();
 976
 977 #ifdef GATHER_STATISTICS
 978   tree_node_counts[(int)lang_decl] += 1;
 979   tree_node_sizes[(int)lang_decl] += size;
 980 #endif
 981 }
 982
 983 void
 984 cxx_dup_lang_specific_decl (node)
 985      tree node;
 986 {
 987   int size;
 988   struct lang_decl *ld;
 989
 990   if (! DECL_LANG_SPECIFIC (node))
 991     return;
 992
 993   if (!CAN_HAVE_FULL_LANG_DECL_P (node))
 994     size = sizeof (struct lang_decl_flags);
 995   else
 996     size = sizeof (struct lang_decl);
 997   ld = (struct lang_decl *) ggc_alloc (size);
 998   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
 999   DECL_LANG_SPECIFIC (node) = ld;
1000
1001 #ifdef GATHER_STATISTICS
1002   tree_node_counts[(int)lang_decl] += 1;
1003   tree_node_sizes[(int)lang_decl] += size;
1004 #endif
1005 }
1006
1007 /* Copy DECL, including any language-specific parts.  */
1008
1009 tree
1010 copy_decl (decl)
1011      tree decl;
1012 {
1013   tree copy;
1014
1015   copy = copy_node (decl);
1016   cxx_dup_lang_specific_decl (copy);
1017   return copy;
1018 }
1019
1020 /* Replace the shared language-specific parts of NODE with a new copy.  */
1021
1022 static void
1023 copy_lang_type (node)
1024      tree node;
1025 {
1026   int size;
1027   struct lang_type *lt;
1028
1029   if (! TYPE_LANG_SPECIFIC (node))
1030     return;
1031
1032   if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
1033     size = sizeof (struct lang_type);
1034   else
1035     size = sizeof (struct lang_type_ptrmem);
1036   lt = (struct lang_type *) ggc_alloc (size);
1037   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
1038   TYPE_LANG_SPECIFIC (node) = lt;
1039
1040 #ifdef GATHER_STATISTICS
1041   tree_node_counts[(int)lang_type] += 1;
1042   tree_node_sizes[(int)lang_type] += size;
1043 #endif
1044 }
1045
1046 /* Copy TYPE, including any language-specific parts.  */
1047
1048 tree
1049 copy_type (type)
1050      tree type;
1051 {
1052   tree copy;
1053
1054   copy = copy_node (type);
1055   copy_lang_type (copy);
1056   return copy;
1057 }
1058
1059 tree
1060 cxx_make_type (code)
1061      enum tree_code code;
1062 {
1063   register tree t = make_node (code);
1064
1065   /* Create lang_type structure.  */
1066   if (IS_AGGR_TYPE_CODE (code)
1067       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
1068     {
1069       struct lang_type *pi;
1070
1071       pi = ((struct lang_type *)
1072             ggc_alloc_cleared (sizeof (struct lang_type)));
1073
1074       TYPE_LANG_SPECIFIC (t) = pi;
1075       pi->u.c.h.is_lang_type_class = 1;
1076
1077 #ifdef GATHER_STATISTICS
1078       tree_node_counts[(int)lang_type] += 1;
1079       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
1080 #endif
1081     }
1082
1083   /* Set up some flags that give proper default behavior.  */
1084   if (IS_AGGR_TYPE_CODE (code))
1085     {
1086       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
1087       CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
1088
1089       /* Make sure this is laid out, for ease of use later.  In the
1090          presence of parse errors, the normal was of assuring this
1091          might not ever get executed, so we lay it out *immediately*.  */
1092       build_pointer_type (t);
1093     }
1094   else
1095     /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits.  But,
1096        TYPE_ALIAS_SET is initialized to -1 by default, so we must
1097        clear it here.  */
1098     TYPE_ALIAS_SET (t) = 0;
1099
1100   /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
1101      since they can be virtual base types, and we then need a
1102      canonical binfo for them.  Ideally, this would be done lazily for
1103      all types.  */
1104   if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM
1105       || code == BOUND_TEMPLATE_TEMPLATE_PARM
1106       || code == TYPENAME_TYPE)
1107     TYPE_BINFO (t) = make_binfo (size_zero_node, t, NULL_TREE, NULL_TREE);
1108
1109   return t;
1110 }
1111
1112 tree
1113 make_aggr_type (code)
1114      enum tree_code code;
1115 {
1116   tree t = cxx_make_type (code);
1117
1118   if (IS_AGGR_TYPE_CODE (code))
1119     SET_IS_AGGR_TYPE (t, 1);
1120
1121   return t;
1122 }
1123
1124 /* Return the type-qualifier corresponding to the identifier given by
1125    RID.  */
1126
1127 int
1128 cp_type_qual_from_rid (rid)
1129      tree rid;
1130 {
1131   if (rid == ridpointers[(int) RID_CONST])
1132     return TYPE_QUAL_CONST;
1133   else if (rid == ridpointers[(int) RID_VOLATILE])
1134     return TYPE_QUAL_VOLATILE;
1135   else if (rid == ridpointers[(int) RID_RESTRICT])
1136     return TYPE_QUAL_RESTRICT;
1137
1138   abort ();
1139   return TYPE_UNQUALIFIED;
1140 }