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, 2010
   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 "c-family/c-objc.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    RANGE_FOR_STMT,      WHILE_STMT,     DO_STMT,
 230    BREAK_STMT,          CONTINUE_STMT,  SWITCH_STMT,
 231    EXPR_STMT
 232   };
 233
 234   memset (&statement_code_p, 0, sizeof (statement_code_p));
 235   for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
 236     statement_code_p[stmt_codes[i]] = true;
 237
 238   saved_loc = input_location;
 239   input_location = BUILTINS_LOCATION;
 240
 241   init_reswords ();
 242   init_tree ();
 243   init_cp_semantics ();
 244   init_operators ();
 245   init_method ();
 246   init_error ();
 247
 248   current_function_decl = NULL;
 249
 250   class_type_node = ridpointers[(int) RID_CLASS];
 251
 252   cxx_init_decl_processing ();
 253
 254   if (c_common_init () == false)
 255     {
 256       input_location = saved_loc;
 257       return false;
 258     }
 259
 260   init_cp_pragma ();
 261
 262   init_repo ();
 263
 264   input_location = saved_loc;
 265   return true;
 266 }
 267 \f
 268 /* Return nonzero if S is not considered part of an
 269    INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
 270
 271 static int
 272 interface_strcmp (const char* s)
 273 {
 274   /* Set the interface/implementation bits for this scope.  */
 275   struct impl_files *ifiles;
 276   const char *s1;
 277
 278   for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
 279     {
 280       const char *t1 = ifiles->filename;
 281       s1 = s;
 282
 283       if (*s1 == 0 || filename_ncmp (s1, t1, 1) != 0)
 284         continue;
 285
 286       while (*s1 != 0 && filename_ncmp (s1, t1, 1) == 0)
 287         s1++, t1++;
 288
 289       /* A match.  */
 290       if (*s1 == *t1)
 291         return 0;
 292
 293       /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
 294       if (strchr (s1, '.') || strchr (t1, '.'))
 295         continue;
 296
 297       if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
 298         continue;
 299
 300       /* A match.  */
 301       return 0;
 302     }
 303
 304   /* No matches.  */
 305   return 1;
 306 }
 307
 308 \f
 309
 310 /* Parse a #pragma whose sole argument is a string constant.
 311    If OPT is true, the argument is optional.  */
 312 static tree
 313 parse_strconst_pragma (const char* name, int opt)
 314 {
 315   tree result, x;
 316   enum cpp_ttype t;
 317
 318   t = pragma_lex (&result);
 319   if (t == CPP_STRING)
 320     {
 321       if (pragma_lex (&x) != CPP_EOF)
 322         warning (0, "junk at end of #pragma %s", name);
 323       return result;
 324     }
 325
 326   if (t == CPP_EOF && opt)
 327     return NULL_TREE;
 328
 329   error ("invalid #pragma %s", name);
 330   return error_mark_node;
 331 }
 332
 333 static void
 334 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
 335 {
 336   parse_strconst_pragma ("vtable", 0);
 337   sorry ("#pragma vtable no longer supported");
 338 }
 339
 340 static void
 341 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
 342 {
 343   /* Validate syntax, but don't do anything.  */
 344   parse_strconst_pragma ("unit", 0);
 345 }
 346
 347 static void
 348 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
 349 {
 350   tree fname = parse_strconst_pragma ("interface", 1);
 351   struct c_fileinfo *finfo;
 352   const char *filename;
 353
 354   if (fname == error_mark_node)
 355     return;
 356   else if (fname == 0)
 357     filename = lbasename (input_filename);
 358   else
 359     filename = TREE_STRING_POINTER (fname);
 360
 361   finfo = get_fileinfo (input_filename);
 362
 363   if (impl_file_chain == 0)
 364     {
 365       /* If this is zero at this point, then we are
 366          auto-implementing.  */
 367       if (main_input_filename == 0)
 368         main_input_filename = input_filename;
 369     }
 370
 371   finfo->interface_only = interface_strcmp (filename);
 372   /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
 373      a definition in another file.  */
 374   if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
 375     finfo->interface_unknown = 0;
 376 }
 377
 378 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
 379    We used to only allow this at toplevel, but that restriction was buggy
 380    in older compilers and it seems reasonable to allow it in the headers
 381    themselves, too.  It only needs to precede the matching #p interface.
 382
 383    We don't touch finfo->interface_only or finfo->interface_unknown;
 384    the user must specify a matching #p interface for this to have
 385    any effect.  */
 386
 387 static void
 388 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
 389 {
 390   tree fname = parse_strconst_pragma ("implementation", 1);
 391   const char *filename;
 392   struct impl_files *ifiles = impl_file_chain;
 393
 394   if (fname == error_mark_node)
 395     return;
 396
 397   if (fname == 0)
 398     {
 399       if (main_input_filename)
 400         filename = main_input_filename;
 401       else
 402         filename = input_filename;
 403       filename = lbasename (filename);
 404     }
 405   else
 406     {
 407       filename = TREE_STRING_POINTER (fname);
 408       if (cpp_included_before (parse_in, filename, input_location))
 409         warning (0, "#pragma implementation for %qs appears after "
 410                  "file is included", filename);
 411     }
 412
 413   for (; ifiles; ifiles = ifiles->next)
 414     {
 415       if (! filename_cmp (ifiles->filename, filename))
 416         break;
 417     }
 418   if (ifiles == 0)
 419     {
 420       ifiles = XNEW (struct impl_files);
 421       ifiles->filename = xstrdup (filename);
 422       ifiles->next = impl_file_chain;
 423       impl_file_chain = ifiles;
 424     }
 425 }
 426
 427 /* Indicate that this file uses Java-personality exception handling.  */
 428 static void
 429 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED)
 430 {
 431   tree x;
 432   if (pragma_lex (&x) != CPP_EOF)
 433     warning (0, "junk at end of #pragma GCC java_exceptions");
 434
 435   choose_personality_routine (lang_java);
 436   pragma_java_exceptions = true;
 437 }
 438
 439 /* Issue an error message indicating that the lookup of NAME (an
 440    IDENTIFIER_NODE) failed.  Returns the ERROR_MARK_NODE.  */
 441
 442 tree
 443 unqualified_name_lookup_error (tree name)
 444 {
 445   if (IDENTIFIER_OPNAME_P (name))
 446     {
 447       if (name != ansi_opname (ERROR_MARK))
 448         error ("%qD not defined", name);
 449     }
 450   else
 451     {
 452       if (!objc_diagnose_private_ivar (name))
 453         {
 454           error ("%qD was not declared in this scope", name);
 455           suggest_alternatives_for (location_of (name), name);
 456         }
 457       /* Prevent repeated error messages by creating a VAR_DECL with
 458          this NAME in the innermost block scope.  */
 459       if (local_bindings_p ())
 460         {
 461           tree decl;
 462           decl = build_decl (input_location,
 463                              VAR_DECL, name, error_mark_node);
 464           DECL_CONTEXT (decl) = current_function_decl;
 465           push_local_binding (name, decl, 0);
 466           /* Mark the variable as used so that we do not get warnings
 467              about it being unused later.  */
 468           TREE_USED (decl) = 1;
 469         }
 470     }
 471
 472   return error_mark_node;
 473 }
 474
 475 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
 476    used as a function.  Returns an appropriate expression for
 477    NAME.  */
 478
 479 tree
 480 unqualified_fn_lookup_error (tree name)
 481 {
 482   if (processing_template_decl)
 483     {
 484       /* In a template, it is invalid to write "f()" or "f(3)" if no
 485          declaration of "f" is available.  Historically, G++ and most
 486          other compilers accepted that usage since they deferred all name
 487          lookup until instantiation time rather than doing unqualified
 488          name lookup at template definition time; explain to the user what
 489          is going wrong.
 490
 491          Note that we have the exact wording of the following message in
 492          the manual (trouble.texi, node "Name lookup"), so they need to
 493          be kept in synch.  */
 494       permerror (input_location, "there are no arguments to %qD that depend on a template "
 495                  "parameter, so a declaration of %qD must be available",
 496                  name, name);
 497
 498       if (!flag_permissive)
 499         {
 500           static bool hint;
 501           if (!hint)
 502             {
 503               inform (input_location, "(if you use %<-fpermissive%>, G++ will accept your "
 504                      "code, but allowing the use of an undeclared name is "
 505                      "deprecated)");
 506               hint = true;
 507             }
 508         }
 509       return name;
 510     }
 511
 512   return unqualified_name_lookup_error (name);
 513 }
 514
 515 /* Wrapper around build_lang_decl_loc(). Should gradually move to
 516    build_lang_decl_loc() and then rename build_lang_decl_loc() back to
 517    build_lang_decl().  */
 518
 519 tree
 520 build_lang_decl (enum tree_code code, tree name, tree type)
 521 {
 522   return build_lang_decl_loc (input_location, code, name, type);
 523 }
 524
 525 /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
 526    DECL_LANG_SPECIFIC info to the result.  */
 527
 528 tree
 529 build_lang_decl_loc (location_t loc, enum tree_code code, tree name, tree type)
 530 {
 531   tree t;
 532
 533   t = build_decl (loc, code, name, type);
 534   retrofit_lang_decl (t);
 535
 536   return t;
 537 }
 538
 539 /* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
 540    and pushdecl (for functions generated by the back end).  */
 541
 542 void
 543 retrofit_lang_decl (tree t)
 544 {
 545   struct lang_decl *ld;
 546   size_t size;
 547   int sel;
 548
 549   if (TREE_CODE (t) == FUNCTION_DECL)
 550     sel = 1, size = sizeof (struct lang_decl_fn);
 551   else if (TREE_CODE (t) == NAMESPACE_DECL)
 552     sel = 2, size = sizeof (struct lang_decl_ns);
 553   else if (TREE_CODE (t) == PARM_DECL)
 554     sel = 3, size = sizeof (struct lang_decl_parm);
 555   else if (LANG_DECL_HAS_MIN (t))
 556     sel = 0, size = sizeof (struct lang_decl_min);
 557   else
 558     gcc_unreachable ();
 559
 560   ld = ggc_alloc_cleared_lang_decl (size);
 561
 562   ld->u.base.selector = sel;
 563
 564   DECL_LANG_SPECIFIC (t) = ld;
 565   if (current_lang_name == lang_name_cplusplus
 566       || decl_linkage (t) == lk_none)
 567     SET_DECL_LANGUAGE (t, lang_cplusplus);
 568   else if (current_lang_name == lang_name_c)
 569     SET_DECL_LANGUAGE (t, lang_c);
 570   else if (current_lang_name == lang_name_java)
 571     SET_DECL_LANGUAGE (t, lang_java);
 572   else
 573     gcc_unreachable ();
 574
 575 #ifdef GATHER_STATISTICS
 576   tree_node_counts[(int)lang_decl] += 1;
 577   tree_node_sizes[(int)lang_decl] += size;
 578 #endif
 579 }
 580
 581 void
 582 cxx_dup_lang_specific_decl (tree node)
 583 {
 584   int size;
 585   struct lang_decl *ld;
 586
 587   if (! DECL_LANG_SPECIFIC (node))
 588     return;
 589
 590   if (TREE_CODE (node) == FUNCTION_DECL)
 591     size = sizeof (struct lang_decl_fn);
 592   else if (TREE_CODE (node) == NAMESPACE_DECL)
 593     size = sizeof (struct lang_decl_ns);
 594   else if (TREE_CODE (node) == PARM_DECL)
 595     size = sizeof (struct lang_decl_parm);
 596   else if (LANG_DECL_HAS_MIN (node))
 597     size = sizeof (struct lang_decl_min);
 598   else
 599     gcc_unreachable ();
 600
 601   ld = ggc_alloc_lang_decl (size);
 602   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
 603   DECL_LANG_SPECIFIC (node) = ld;
 604
 605 #ifdef GATHER_STATISTICS
 606   tree_node_counts[(int)lang_decl] += 1;
 607   tree_node_sizes[(int)lang_decl] += size;
 608 #endif
 609 }
 610
 611 /* Copy DECL, including any language-specific parts.  */
 612
 613 tree
 614 copy_decl (tree decl)
 615 {
 616   tree copy;
 617
 618   copy = copy_node (decl);
 619   cxx_dup_lang_specific_decl (copy);
 620   return copy;
 621 }
 622
 623 /* Replace the shared language-specific parts of NODE with a new copy.  */
 624
 625 static void
 626 copy_lang_type (tree node)
 627 {
 628   int size;
 629   struct lang_type *lt;
 630
 631   if (! TYPE_LANG_SPECIFIC (node))
 632     return;
 633
 634   if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
 635     size = sizeof (struct lang_type);
 636   else
 637     size = sizeof (struct lang_type_ptrmem);
 638   lt = ggc_alloc_lang_type (size);
 639   memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
 640   TYPE_LANG_SPECIFIC (node) = lt;
 641
 642 #ifdef GATHER_STATISTICS
 643   tree_node_counts[(int)lang_type] += 1;
 644   tree_node_sizes[(int)lang_type] += size;
 645 #endif
 646 }
 647
 648 /* Copy TYPE, including any language-specific parts.  */
 649
 650 tree
 651 copy_type (tree type)
 652 {
 653   tree copy;
 654
 655   copy = copy_node (type);
 656   copy_lang_type (copy);
 657   return copy;
 658 }
 659
 660 tree
 661 cxx_make_type (enum tree_code code)
 662 {
 663   tree t = make_node (code);
 664
 665   /* Create lang_type structure.  */
 666   if (RECORD_OR_UNION_CODE_P (code)
 667       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
 668     {
 669       struct lang_type *pi
 670           = ggc_alloc_cleared_lang_type (sizeof (struct lang_type));
 671
 672       TYPE_LANG_SPECIFIC (t) = pi;
 673       pi->u.c.h.is_lang_type_class = 1;
 674
 675 #ifdef GATHER_STATISTICS
 676       tree_node_counts[(int)lang_type] += 1;
 677       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
 678 #endif
 679     }
 680
 681   /* Set up some flags that give proper default behavior.  */
 682   if (RECORD_OR_UNION_CODE_P (code))
 683     {
 684       struct c_fileinfo *finfo = get_fileinfo (input_filename);
 685       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
 686       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
 687     }
 688
 689   return t;
 690 }
 691
 692 tree
 693 make_class_type (enum tree_code code)
 694 {
 695   tree t = cxx_make_type (code);
 696   SET_CLASS_TYPE_P (t, 1);
 697   return t;
 698 }
 699
 700 /* Returns true if we are currently in the main source file, or in a
 701    template instantiation started from the main source file.  */
 702
 703 bool
 704 in_main_input_context (void)
 705 {
 706   struct tinst_level *tl = outermost_tinst_level();
 707
 708   if (tl)
 709     return filename_cmp (main_input_filename,
 710                          LOCATION_FILE (tl->locus)) == 0;
 711   else
 712     return filename_cmp (main_input_filename, input_filename) == 0;
 713 }