gcc/cp/lex.c

   1 /* Separate lexical analyzer for GNU C++.
   2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
   4    Free Software Foundation, Inc.
   5    Hacked by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23
  24 /* This file is the lexical analyzer for GNU C++.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "input.h"
  31 #include "tree.h"
  32 #include "cp-tree.h"
  33 #include "cpplib.h"
  34 #include "flags.h"
  35 #include "c-family/c-pragma.h"
  36 #include "toplev.h"
  37 #include "output.h"
  38 #include "tm_p.h"
  39 #include "timevar.h"
  40
  41 static int interface_strcmp (const char *);
  42 static void init_cp_pragma (void);
  43
  44 static tree parse_strconst_pragma (const char *, int);
  45 static void handle_pragma_vtable (cpp_reader *);
  46 static void handle_pragma_unit (cpp_reader *);
  47 static void handle_pragma_interface (cpp_reader *);
  48 static void handle_pragma_implementation (cpp_reader *);
  49 static void handle_pragma_java_exceptions (cpp_reader *);
  50
  51 static void init_operators (void);
  52 static void copy_lang_type (tree);
  53
  54 /* A constraint that can be tested at compile time.  */
  55 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
  56
  57 /* Functions and data structures for #pragma interface.
  58
  59    `#pragma implementation' means that the main file being compiled
  60    is considered to implement (provide) the classes that appear in
  61    its main body.  I.e., if this is file "foo.cc", and class `bar'
  62    is defined in "foo.cc", then we say that "foo.cc implements bar".
  63
  64    All main input files "implement" themselves automagically.
  65
  66    `#pragma interface' means that unless this file (of the form "foo.h"
  67    is not presently being included by file "foo.cc", the
  68    CLASSTYPE_INTERFACE_ONLY bit gets set.  The effect is that none
  69    of the vtables nor any of the inline functions defined in foo.h
  70    will ever be output.
  71
  72    There are cases when we want to link files such as "defs.h" and
  73    "main.cc".  In this case, we give "defs.h" a `#pragma interface',
  74    and "main.cc" has `#pragma implementation "defs.h"'.  */
  75
  76 struct impl_files
  77 {
  78   const char *filename;
  79   struct impl_files *next;
  80 };
  81
  82 static struct impl_files *impl_file_chain;
  83
  84 /* True if we saw "#pragma GCC java_exceptions".  */
  85 bool pragma_java_exceptions;
  86 \f
  87 void
  88 cxx_finish (void)
  89 {
  90   c_common_finish ();
  91 }
  92
  93 /* A mapping from tree codes to operator name information.  */
  94 operator_name_info_t operator_name_info[(int) MAX_TREE_CODES];
  95 /* Similar, but for assignment operators.  */
  96 operator_name_info_t assignment_operator_name_info[(int) MAX_TREE_CODES];
  97
  98 /* Initialize data structures that keep track of operator names.  */
  99
 100 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
 101  CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
 102 #include "operators.def"
 103 #undef DEF_OPERATOR
 104
 105 static void
 106 init_operators (void)
 107 {
 108   tree identifier;
 109   char buffer[256];
 110   struct operator_name_info_t *oni;
 111
 112 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)                   \
 113   sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
 114   identifier = get_identifier (buffer);                                     \
 115   IDENTIFIER_OPNAME_P (identifier) = 1;                                     \
 116                                                                             \
 117   oni = (ASSN_P                                                             \
 118          ? &assignment_operator_name_info[(int) CODE]                       \
 119          : &operator_name_info[(int) CODE]);                                \
 120   oni->identifier = identifier;                                             \
 121   oni->name = NAME;                                                         \
 122   oni->mangled_name = MANGLING;                                             \
 123   oni->arity = ARITY;
 124
 125 #include "operators.def"
 126 #undef DEF_OPERATOR
 127
 128   operator_name_info[(int) ERROR_MARK].identifier
 129     = get_identifier ("<invalid operator>");
 130
 131   /* Handle some special cases.  These operators are not defined in
 132      the language, but can be produced internally.  We may need them
 133      for error-reporting.  (Eventually, we should ensure that this
 134      does not happen.  Error messages involving these operators will
 135      be confusing to users.)  */
 136
 137   operator_name_info [(int) INIT_EXPR].name
 138     = operator_name_info [(int) MODIFY_EXPR].name;
 139   operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
 140   operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
 141   operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
 142   operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
 143   operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
 144   operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
 145   operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
 146   operator_name_info [(int) ABS_EXPR].name = "abs";
 147   operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
 148   operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
 149   operator_name_info [(int) RANGE_EXPR].name = "...";
 150   operator_name_info [(int) UNARY_PLUS_EXPR].name = "+";
 151
 152   assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
 153     = "(exact /=)";
 154   assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
 155     = "(ceiling /=)";
 156   assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
 157     = "(floor /=)";
 158   assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
 159     = "(round /=)";
 160   assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
 161     = "(ceiling %=)";
 162   assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
 163     = "(floor %=)";
 164   assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
 165     = "(round %=)";
 166 }
 167
 168 /* Initialize the reserved words.  */
 169
 170 void
 171 init_reswords (void)
 172 {
 173   unsigned int i;
 174   tree id;
 175   int mask = 0;
 176
 177   if (cxx_dialect != cxx0x)
 178     mask |= D_CXX0X;
 179   if (flag_no_asm)
 180     mask |= D_ASM | D_EXT;
 181   if (flag_no_gnu_keywords)
 182     mask |= D_EXT;
 183
 184   /* The Objective-C keywords are all context-dependent.  */
 185   mask |= D_OBJC;
 186
 187   ridpointers = ggc_alloc_cleared_vec_tree ((int) RID_MAX);
 188   for (i = 0; i < num_c_common_reswords; i++)
 189     {
 190       if (c_common_reswords[i].disable & D_CONLY)
 191         continue;
 192       id = get_identifier (c_common_reswords[i].word);
 193       C_SET_RID_CODE (id, c_common_reswords[i].rid);
 194       ridpointers [(int) c_common_reswords[i].rid] = id;
 195       if (! (c_common_reswords[i].disable & mask))
 196         C_IS_RESERVED_WORD (id) = 1;
 197     }
 198 }
 199
 200 static void
 201 init_cp_pragma (void)
 202 {
 203   c_register_pragma (0, "vtable", handle_pragma_vtable);
 204   c_register_pragma (0, "unit", handle_pragma_unit);
 205   c_register_pragma (0, "interface", handle_pragma_interface);
 206   c_register_pragma (0, "implementation", handle_pragma_implementation);
 207   c_register_pragma ("GCC", "interface", handle_pragma_interface);
 208   c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
 209   c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
 210 }
 211 \f
 212 /* TRUE if a code represents a statement.  */
 213
 214 bool statement_code_p[MAX_TREE_CODES];
 215
 216 /* Initialize the C++ front end.  This function is very sensitive to
 217    the exact order that things are done here.  It would be nice if the
 218    initialization done by this routine were moved to its subroutines,
 219    and the ordering dependencies clarified and reduced.  */
 220 bool
 221 cxx_init (void)
 222 {
 223   location_t saved_loc;
 224   unsigned int i;
 225   static const enum tree_code stmt_codes[] = {
 226    CTOR_INITIALIZER,    TRY_BLOCK,      HANDLER,
 227    EH_SPEC_BLOCK,       USING_STMT,     TAG_DEFN,
 228    IF_STMT,             CLEANUP_STMT,   FOR_STMT,
 229    WHILE_STMT,          DO_STMT,        BREAK_STMT,
 230    CONTINUE_STMT,       SWITCH_STMT,    EXPR_STMT
 231   };
 232
 233   memset (&statement_code_p, 0, sizeof (statement_code_p));
 234   for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
 235     statement_code_p[stmt_codes[i]] = true;
 236
 237   saved_loc = input_location;
 238   input_location = BUILTINS_LOCATION;
 239
 240   init_reswords ();
 241   init_tree ();
 242   init_cp_semantics ();
 243   init_operators ();
 244   init_method ();
 245   init_error ();
 246
 247   current_function_decl = NULL;
 248
 249   class_type_node = ridpointers[(int) RID_CLASS];
 250
 251   cxx_init_decl_processing ();
 252
 253   if (c_common_init () == false)
 254     {
 255       input_location = saved_loc;
 256       return false;
 257     }
 258
 259   init_cp_pragma ();
 260
 261   init_repo ();
 262
 263   input_location = saved_loc;
 264   return true;
 265 }
 266 \f
 267 /* Return nonzero if S is not considered part of an
 268    INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
 269
 270 static int
 271 interface_strcmp (const char* s)
 272 {
 273   /* Set the interface/implementation bits for this scope.  */
 274   struct impl_files *ifiles;
 275   const char *s1;
 276
 277   for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
 278     {
 279       const char *t1 = ifiles->filename;
 280       s1 = s;
 281
 282       if (*s1 != *t1 || *s1 == 0)
 283         continue;
 284
 285       while (*s1 == *t1 && *s1 != 0)
 286         s1++, t1++;
 287
 288       /* A match.  */
 289       if (*s1 == *t1)
 290         return 0;
 291
 292       /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
 293       if (strchr (s1, '.') || strchr (t1, '.'))
 294         continue;
 295
 296       if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
 297         continue;
 298
 299       /* A match.  */
 300       return 0;
 301     }
 302
 303   /* No matches.  */
 304   return 1;
 305 }
 306
 307 \f
 308
 309 /* Parse a #pragma whose sole argument is a string constant.
 310    If OPT is true, the argument is optional.  */
 311 static tree
 312 parse_strconst_pragma (const char* name, int opt)
 313 {
 314   tree result, x;
 315   enum cpp_ttype t;
 316
 317   t = pragma_lex (&result);
 318   if (t == CPP_STRING)
 319     {
 320       if (pragma_lex (&x) != CPP_EOF)
 321         warning (0, "junk at end of #pragma %s", name);
 322       return result;
 323     }
 324
 325   if (t == CPP_EOF && opt)
 326     return NULL_TREE;
 327
 328   error ("invalid #pragma %s", name);
 329   return error_mark_node;
 330 }
 331
 332 static void
 333 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
 334 {
 335   parse_strconst_pragma ("vtable", 0);
 336   sorry ("#pragma vtable no longer supported");
 337 }
 338
 339 static void
 340 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
 341 {
 342   /* Validate syntax, but don't do anything.  */
 343   parse_strconst_pragma ("unit", 0);
 344 }
 345
 346 static void
 347 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
 348 {
 349   tree fname = parse_strconst_pragma ("interface", 1);
 350   struct c_fileinfo *finfo;
 351   const char *filename;
 352
 353   if (fname == error_mark_node)
 354     return;
 355   else if (fname == 0)
 356     filename = lbasename (input_filename);
 357   else
 358     filename = TREE_STRING_POINTER (fname);
 359
 360   finfo = get_fileinfo (input_filename);
 361
 362   if (impl_file_chain == 0)
 363     {
 364       /* If this is zero at this point, then we are
 365          auto-implementing.  */
 366       if (main_input_filename == 0)
 367         main_input_filename = input_filename;
 368     }
 369
 370   finfo->interface_only = interface_strcmp (filename);
 371   /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
 372      a definition in another file.  */
 373   if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
 374     finfo->interface_unknown = 0;
 375 }
 376
 377 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
 378    We used to only allow this at toplevel, but that restriction was buggy
 379    in older compilers and it seems reasonable to allow it in the headers
 380    themselves, too.  It only needs to precede the matching #p interface.
 381
 382    We don't touch finfo->interface_only or finfo->interface_unknown;
 383    the user must specify a matching #p interface for this to have
 384    any effect.  */
 385
 386 static void
 387 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
 388 {
 389   tree fname = parse_strconst_pragma ("implementation", 1);
 390   const char *filename;
 391   struct impl_files *ifiles = impl_file_chain;
 392
 393   if (fname == error_mark_node)
 394     return;
 395
 396   if (fname == 0)
 397     {
 398       if (main_input_filename)
 399         filename = main_input_filename;
 400       else
 401         filename = input_filename;
 402       filename = lbasename (filename);
 403     }
 404   else
 405     {
 406       filename = TREE_STRING_POINTER (fname);
 407       if (cpp_included_before (parse_in, filename, input_location))
 408         warning (0, "#pragma implementation for %qs appears after "
 409                  "file is included", filename);
 410     }
 411
 412   for (; ifiles; ifiles = ifiles->next)
 413     {
 414       if (! strcmp (ifiles->filename, filename))
 415         break;
 416     }
 417   if (ifiles == 0)
 418     {
 419       ifiles = XNEW (struct impl_files);
 420       ifiles->filename = xstrdup (filename);
 421       ifiles->next = impl_file_chain;
 422       impl_file_chain = ifiles;
 423     }
 424 }
 425
 426 /* Indicate that this file uses Java-personality exception handling.  */
 427 static void
 428 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED)
 429 {
 430   tree x;
 431   if (pragma_lex (&x) != CPP_EOF)
 432     warning (0, "junk at end of #pragma GCC java_exceptions");
 433
 434   choose_personality_routine (lang_java);
 435   pragma_java_exceptions = true;
 436 }
 437
 438 /* Issue an error message indicating that the lookup of NAME (an
 439    IDENTIFIER_NODE) failed.  Returns the ERROR_MARK_NODE.  */
 440
 441 tree
 442 unqualified_name_lookup_error (tree name)
 443 {
 444   if (IDENTIFIER_OPNAME_P (name))
 445     {
 446       if (name != ansi_opname (ERROR_MARK))
 447         error ("%qD not defined", name);
 448     }
 449   else
 450     {
 451       error ("%qD was not declared in this scope", name);
 452       /* Prevent repeated error messages by creating a VAR_DECL with
 453          this NAME in the innermost block scope.  */
 454       if (current_function_decl)
 455         {
 456           tree decl;
 457           decl = build_decl (input_location,
 458                              VAR_DECL, name, error_mark_node);
 459           DECL_CONTEXT (decl) = current_function_decl;
 460           push_local_binding (name, decl, 0);
 461           /* Mark the variable as used so that we do not get warnings
 462              about it being unused later.  */
 463           TREE_USED (decl) = 1;
 464         }
 465     }
 466
 467   return error_mark_node;
 468 }
 469
 470 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
 471    used as a function.  Returns an appropriate expression for
 472    NAME.  */
 473
 474 tree
 475 unqualified_fn_lookup_error (tree name)
 476 {
 477   if (processing_template_decl)
 478     {
 479       /* In a template, it is invalid to write "f()" or "f(3)" if no
 480          declaration of "f" is available.  Historically, G++ and most
 481          other compilers accepted that usage since they deferred all name
 482          lookup until instantiation time rather than doing unqualified
 483          name lookup at template definition time; explain to the user what
 484          is going wrong.
 485
 486          Note that we have the exact wording of the following message in
 487          the manual (trouble.texi, node "Name lookup"), so they need to
 488          be kept in synch.  */
 489       permerror (input_location, "there are no arguments to %qD that depend on a template "
 490                  "parameter, so a declaration of %qD must be available",
 491                  name, name);
 492
 493       if (!flag_permissive)
 494         {
 495           static bool hint;
 496           if (!hint)
 497             {
 498               inform (input_location, "(if you use %<-fpermissive%>, G++ will accept your "
 499                      "code, but allowing the use of an undeclared name is "
 500                      "deprecated)");
 501               hint = true;
 502             }
 503         }
 504       return name;
 505     }
 506
 507   return unqualified_name_lookup_error (name);
 508 }
 509
 510 tree
 511 build_lang_decl (enum tree_code code, tree name, tree type)
 512 {
 513   tree t;
 514
 515   t = build_decl (input_location,
 516                   code, name, type);
 517   retrofit_lang_decl (t);
 518
 519   return t;
 520 }
 521
 522 /* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
 523    and pushdecl (for functions generated by the back end).  */
 524
 525 void
 526 retrofit_lang_decl (tree t)
 527 {
 528   struct lang_decl *ld;
 529   size_t size;
 530   int sel;
 531
 532   if (TREE_CODE (t) == FUNCTION_DECL)
 533     sel = 1, size = sizeof (struct lang_decl_fn);
 534   else if (TREE_CODE (t) == NAMESPACE_DECL)
 535     sel = 2, size = sizeof (struct lang_decl_ns);
 536   else if (TREE_CODE (t) == PARM_DECL)
 537     sel = 3, size = sizeof (struct lang_decl_parm);
 538   else if (LANG_DECL_HAS_MIN (t))
 539     sel = 0, size = sizeof (struct lang_decl_min);
 540   else
 541     gcc_unreachable ();
 542
 543   ld = ggc_alloc_cleared_lang_decl (size);
 544
 545   ld->u.base.selector = sel;
 546
 547   DECL_LANG_SPECIFIC (t) = ld;
 548   if (current_lang_name == lang_name_cplusplus
 549       || decl_linkage (t) == lk_none)
 550     SET_DECL_LANGUAGE (t, lang_cplusplus);
 551   else if (current_lang_name == lang_name_c)
 552     SET_DECL_LANGUAGE (t, lang_c);
 553   else if (current_lang_name == lang_name_java)
 554     SET_DECL_LANGUAGE (t, lang_java);
 555   else
 556     gcc_unreachable ();
 557
 558 #ifdef GATHER_STATISTICS
 559   tree_node_counts[(int)lang_decl] += 1;
 560   tree_node_sizes[(int)lang_decl] += size;
 561 #endif
 562 }
 563
 564 void
 565 cxx_dup_lang_specific_decl (tree node)
 566 {
 567   int size;
 568   struct lang_decl *ld;
 569
 570   if (! DECL_LANG_SPECIFIC (node))
 571     return;
 572
 573   if (TREE_CODE (node) == FUNCTION_DECL)
 574     size = sizeof (struct lang_decl_fn);
 575   else if (TREE_CODE (node) == NAMESPACE_DECL)
 576     size = sizeof (struct lang_decl_ns);
 577   else if (TREE_CODE (node) == PARM_DECL)
 578     size = sizeof (struct lang_decl_parm);
 579   else if (LANG_DECL_HAS_MIN (node))
 580     size = sizeof (struct lang_decl_min);
 581   else
 582     gcc_unreachable ();
 583
 584   ld = ggc_alloc_lang_decl (size);
 585   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
 586   DECL_LANG_SPECIFIC (node) = ld;
 587
 588 #ifdef GATHER_STATISTICS
 589   tree_node_counts[(int)lang_decl] += 1;
 590   tree_node_sizes[(int)lang_decl] += size;
 591 #endif
 592 }
 593
 594 /* Copy DECL, including any language-specific parts.  */
 595
 596 tree
 597 copy_decl (tree decl)
 598 {
 599   tree copy;
 600
 601   copy = copy_node (decl);
 602   cxx_dup_lang_specific_decl (copy);
 603   return copy;
 604 }
 605
 606 /* Replace the shared language-specific parts of NODE with a new copy.  */
 607
 608 static void
 609 copy_lang_type (tree node)
 610 {
 611   int size;
 612   struct lang_type *lt;
 613
 614   if (! TYPE_LANG_SPECIFIC (node))
 615     return;
 616
 617   if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
 618     size = sizeof (struct lang_type);
 619   else
 620     size = sizeof (struct lang_type_ptrmem);
 621   lt = ggc_alloc_lang_type (size);
 622   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
 623   TYPE_LANG_SPECIFIC (node) = lt;
 624
 625 #ifdef GATHER_STATISTICS
 626   tree_node_counts[(int)lang_type] += 1;
 627   tree_node_sizes[(int)lang_type] += size;
 628 #endif
 629 }
 630
 631 /* Copy TYPE, including any language-specific parts.  */
 632
 633 tree
 634 copy_type (tree type)
 635 {
 636   tree copy;
 637
 638   copy = copy_node (type);
 639   copy_lang_type (copy);
 640   return copy;
 641 }
 642
 643 tree
 644 cxx_make_type (enum tree_code code)
 645 {
 646   tree t = make_node (code);
 647
 648   /* Create lang_type structure.  */
 649   if (RECORD_OR_UNION_CODE_P (code)
 650       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
 651     {
 652       struct lang_type *pi
 653           = ggc_alloc_cleared_lang_type (sizeof (struct lang_type));
 654
 655       TYPE_LANG_SPECIFIC (t) = pi;
 656       pi->u.c.h.is_lang_type_class = 1;
 657
 658 #ifdef GATHER_STATISTICS
 659       tree_node_counts[(int)lang_type] += 1;
 660       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
 661 #endif
 662     }
 663
 664   /* Set up some flags that give proper default behavior.  */
 665   if (RECORD_OR_UNION_CODE_P (code))
 666     {
 667       struct c_fileinfo *finfo = get_fileinfo (input_filename);
 668       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
 669       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
 670     }
 671
 672   return t;
 673 }
 674
 675 tree
 676 make_class_type (enum tree_code code)
 677 {
 678   tree t = cxx_make_type (code);
 679   SET_CLASS_TYPE_P (t, 1);
 680   return t;
 681 }
 682
 683 /* Returns true if we are currently in the main source file, or in a
 684    template instantiation started from the main source file.  */
 685
 686 bool
 687 in_main_input_context (void)
 688 {
 689   struct tinst_level *tl = outermost_tinst_level();
 690
 691   if (tl)
 692     return strcmp (main_input_filename,
 693                   LOCATION_FILE (tl->locus)) == 0;
 694   else
 695     return strcmp (main_input_filename, input_filename) == 0;
 696 }