1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* This file is the lexical analyzer for GNU C++. */
25 /* For use with name_hint. */
26 #define INCLUDE_UNIQUE_PTR
28 #include "coretypes.h"
30 #include "stringpool.h"
31 #include "c-family/c-pragma.h"
32 #include "c-family/c-objc.h"
33 #include "gcc-rich-location.h"
34 #include "cp-name-hint.h"
36 static int interface_strcmp (const char *);
37 static void init_cp_pragma (void);
39 static tree
parse_strconst_pragma (const char *, int);
40 static void handle_pragma_vtable (cpp_reader
*);
41 static void handle_pragma_unit (cpp_reader
*);
42 static void handle_pragma_interface (cpp_reader
*);
43 static void handle_pragma_implementation (cpp_reader
*);
45 static void init_operators (void);
46 static void copy_lang_type (tree
);
48 /* A constraint that can be tested at compile time. */
49 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
51 /* Functions and data structures for #pragma interface.
53 `#pragma implementation' means that the main file being compiled
54 is considered to implement (provide) the classes that appear in
55 its main body. I.e., if this is file "foo.cc", and class `bar'
56 is defined in "foo.cc", then we say that "foo.cc implements bar".
58 All main input files "implement" themselves automagically.
60 `#pragma interface' means that unless this file (of the form "foo.h"
61 is not presently being included by file "foo.cc", the
62 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
63 of the vtables nor any of the inline functions defined in foo.h
66 There are cases when we want to link files such as "defs.h" and
67 "main.cc". In this case, we give "defs.h" a `#pragma interface',
68 and "main.cc" has `#pragma implementation "defs.h"'. */
73 struct impl_files
*next
;
76 static struct impl_files
*impl_file_chain
;
84 ovl_op_info_t ovl_op_info
[2][OVL_OP_MAX
] =
87 {NULL_TREE
, NULL
, NULL
, ERROR_MARK
, OVL_OP_ERROR_MARK
, 0},
88 {NULL_TREE
, NULL
, NULL
, NOP_EXPR
, OVL_OP_NOP_EXPR
, 0},
89 #define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS) \
90 {NULL_TREE, NAME, MANGLING, CODE, OVL_OP_##CODE, FLAGS},
91 #define OPERATOR_TRANSITION }, { \
92 {NULL_TREE, NULL, NULL, ERROR_MARK, OVL_OP_ERROR_MARK, 0},
93 #include "operators.def"
96 unsigned char ovl_op_mapping
[MAX_TREE_CODES
];
97 unsigned char ovl_op_alternate
[OVL_OP_MAX
];
99 /* Get the name of the kind of identifier T. */
102 get_identifier_kind_name (tree id
)
104 /* Keep in sync with cp_id_kind enumeration. */
105 static const char *const names
[cik_max
] = {
106 "normal", "keyword", "constructor", "destructor",
107 "simple-op", "assign-op", "conv-op", "<reserved>udlit-op"
111 kind
|= IDENTIFIER_KIND_BIT_2 (id
) << 2;
112 kind
|= IDENTIFIER_KIND_BIT_1 (id
) << 1;
113 kind
|= IDENTIFIER_KIND_BIT_0 (id
) << 0;
118 /* Set the identifier kind, which we expect to currently be zero. */
121 set_identifier_kind (tree id
, cp_identifier_kind kind
)
123 gcc_checking_assert (!IDENTIFIER_KIND_BIT_2 (id
)
124 & !IDENTIFIER_KIND_BIT_1 (id
)
125 & !IDENTIFIER_KIND_BIT_0 (id
));
126 IDENTIFIER_KIND_BIT_2 (id
) |= (kind
>> 2) & 1;
127 IDENTIFIER_KIND_BIT_1 (id
) |= (kind
>> 1) & 1;
128 IDENTIFIER_KIND_BIT_0 (id
) |= (kind
>> 0) & 1;
131 /* Create and tag the internal operator name for the overloaded
132 operator PTR describes. */
135 set_operator_ident (ovl_op_info_t
*ptr
)
138 size_t len
= snprintf (buffer
, sizeof (buffer
), "operator%s%s",
139 &" "[ptr
->name
[0] && ptr
->name
[0] != '_'
140 && !ISALPHA (ptr
->name
[0])],
142 gcc_checking_assert (len
< sizeof (buffer
));
144 tree ident
= get_identifier_with_length (buffer
, len
);
145 ptr
->identifier
= ident
;
150 /* Initialize data structures that keep track of operator names. */
153 init_operators (void)
155 /* We rely on both these being zero. */
156 gcc_checking_assert (!OVL_OP_ERROR_MARK
&& !ERROR_MARK
);
158 /* This loop iterates backwards because we need to move the
159 assignment operators down to their correct slots. I.e. morally
160 equivalent to an overlapping memmove where dest > src. Slot
161 zero is for error_mark, so hae no operator. */
162 for (unsigned ix
= OVL_OP_MAX
; --ix
;)
164 ovl_op_info_t
*op_ptr
= &ovl_op_info
[false][ix
];
168 /* Make sure it fits in lang_decl_fn::operator_code. */
169 gcc_checking_assert (op_ptr
->ovl_op_code
< (1 << 6));
170 tree ident
= set_operator_ident (op_ptr
);
171 if (unsigned index
= IDENTIFIER_CP_INDEX (ident
))
173 ovl_op_info_t
*bin_ptr
= &ovl_op_info
[false][index
];
175 /* They should only differ in unary/binary ness. */
176 gcc_checking_assert ((op_ptr
->flags
^ bin_ptr
->flags
)
177 == OVL_OP_FLAG_AMBIARY
);
178 bin_ptr
->flags
|= op_ptr
->flags
;
179 ovl_op_alternate
[index
] = ix
;
183 IDENTIFIER_CP_INDEX (ident
) = ix
;
184 set_identifier_kind (ident
, cik_simple_op
);
187 if (op_ptr
->tree_code
)
189 gcc_checking_assert (op_ptr
->ovl_op_code
== ix
190 && !ovl_op_mapping
[op_ptr
->tree_code
]);
191 ovl_op_mapping
[op_ptr
->tree_code
] = op_ptr
->ovl_op_code
;
194 ovl_op_info_t
*as_ptr
= &ovl_op_info
[true][ix
];
197 /* These will be placed at the start of the array, move to
198 the correct slot and initialize. */
199 if (as_ptr
->ovl_op_code
!= ix
)
201 ovl_op_info_t
*dst_ptr
= &ovl_op_info
[true][as_ptr
->ovl_op_code
];
202 gcc_assert (as_ptr
->ovl_op_code
> ix
&& !dst_ptr
->tree_code
);
203 memcpy (dst_ptr
, as_ptr
, sizeof (*dst_ptr
));
204 memset (as_ptr
, 0, sizeof (*as_ptr
));
208 tree ident
= set_operator_ident (as_ptr
);
209 gcc_checking_assert (!IDENTIFIER_CP_INDEX (ident
));
210 IDENTIFIER_CP_INDEX (ident
) = as_ptr
->ovl_op_code
;
211 set_identifier_kind (ident
, cik_assign_op
);
213 gcc_checking_assert (!ovl_op_mapping
[as_ptr
->tree_code
]
214 || (ovl_op_mapping
[as_ptr
->tree_code
]
215 == as_ptr
->ovl_op_code
));
216 ovl_op_mapping
[as_ptr
->tree_code
] = as_ptr
->ovl_op_code
;
221 /* Initialize the reserved words. */
230 if (cxx_dialect
< cxx11
)
233 mask
|= D_CXX_CONCEPTS
;
237 mask
|= D_ASM
| D_EXT
;
238 if (flag_no_gnu_keywords
)
241 /* The Objective-C keywords are all context-dependent. */
244 ridpointers
= ggc_cleared_vec_alloc
<tree
> ((int) RID_MAX
);
245 for (i
= 0; i
< num_c_common_reswords
; i
++)
247 if (c_common_reswords
[i
].disable
& D_CONLY
)
249 id
= get_identifier (c_common_reswords
[i
].word
);
250 C_SET_RID_CODE (id
, c_common_reswords
[i
].rid
);
251 ridpointers
[(int) c_common_reswords
[i
].rid
] = id
;
252 if (! (c_common_reswords
[i
].disable
& mask
))
253 set_identifier_kind (id
, cik_keyword
);
256 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
259 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
260 id
= get_identifier (name
);
261 C_SET_RID_CODE (id
, RID_FIRST_INT_N
+ i
);
262 set_identifier_kind (id
, cik_keyword
);
267 init_cp_pragma (void)
269 c_register_pragma (0, "vtable", handle_pragma_vtable
);
270 c_register_pragma (0, "unit", handle_pragma_unit
);
271 c_register_pragma (0, "interface", handle_pragma_interface
);
272 c_register_pragma (0, "implementation", handle_pragma_implementation
);
273 c_register_pragma ("GCC", "interface", handle_pragma_interface
);
274 c_register_pragma ("GCC", "implementation", handle_pragma_implementation
);
277 /* TRUE if a code represents a statement. */
279 bool statement_code_p
[MAX_TREE_CODES
];
281 /* Initialize the C++ front end. This function is very sensitive to
282 the exact order that things are done here. It would be nice if the
283 initialization done by this routine were moved to its subroutines,
284 and the ordering dependencies clarified and reduced. */
288 location_t saved_loc
;
290 static const enum tree_code stmt_codes
[] = {
291 CTOR_INITIALIZER
, TRY_BLOCK
, HANDLER
,
292 EH_SPEC_BLOCK
, USING_STMT
, TAG_DEFN
,
293 IF_STMT
, CLEANUP_STMT
, FOR_STMT
,
294 RANGE_FOR_STMT
, WHILE_STMT
, DO_STMT
,
295 BREAK_STMT
, CONTINUE_STMT
, SWITCH_STMT
,
299 memset (&statement_code_p
, 0, sizeof (statement_code_p
));
300 for (i
= 0; i
< ARRAY_SIZE (stmt_codes
); i
++)
301 statement_code_p
[stmt_codes
[i
]] = true;
303 saved_loc
= input_location
;
304 input_location
= BUILTINS_LOCATION
;
308 init_cp_semantics ();
312 current_function_decl
= NULL
;
314 class_type_node
= ridpointers
[(int) RID_CLASS
];
316 cxx_init_decl_processing ();
318 if (c_common_init () == false)
320 input_location
= saved_loc
;
328 input_location
= saved_loc
;
332 /* Return nonzero if S is not considered part of an
333 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
336 interface_strcmp (const char* s
)
338 /* Set the interface/implementation bits for this scope. */
339 struct impl_files
*ifiles
;
342 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
344 const char *t1
= ifiles
->filename
;
347 if (*s1
== 0 || filename_ncmp (s1
, t1
, 1) != 0)
350 while (*s1
!= 0 && filename_ncmp (s1
, t1
, 1) == 0)
357 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
358 if (strchr (s1
, '.') || strchr (t1
, '.'))
361 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
374 /* Parse a #pragma whose sole argument is a string constant.
375 If OPT is true, the argument is optional. */
377 parse_strconst_pragma (const char* name
, int opt
)
382 t
= pragma_lex (&result
);
385 if (pragma_lex (&x
) != CPP_EOF
)
386 warning (0, "junk at end of #pragma %s", name
);
390 if (t
== CPP_EOF
&& opt
)
393 error ("invalid #pragma %s", name
);
394 return error_mark_node
;
398 handle_pragma_vtable (cpp_reader
* /*dfile*/)
400 parse_strconst_pragma ("vtable", 0);
401 sorry ("#pragma vtable no longer supported");
405 handle_pragma_unit (cpp_reader
* /*dfile*/)
407 /* Validate syntax, but don't do anything. */
408 parse_strconst_pragma ("unit", 0);
412 handle_pragma_interface (cpp_reader
* /*dfile*/)
414 tree fname
= parse_strconst_pragma ("interface", 1);
415 struct c_fileinfo
*finfo
;
416 const char *filename
;
418 if (fname
== error_mark_node
)
421 filename
= lbasename (LOCATION_FILE (input_location
));
423 filename
= TREE_STRING_POINTER (fname
);
425 finfo
= get_fileinfo (LOCATION_FILE (input_location
));
427 if (impl_file_chain
== 0)
429 /* If this is zero at this point, then we are
430 auto-implementing. */
431 if (main_input_filename
== 0)
432 main_input_filename
= LOCATION_FILE (input_location
);
435 finfo
->interface_only
= interface_strcmp (filename
);
436 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
437 a definition in another file. */
438 if (!MULTIPLE_SYMBOL_SPACES
|| !finfo
->interface_only
)
439 finfo
->interface_unknown
= 0;
442 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
443 We used to only allow this at toplevel, but that restriction was buggy
444 in older compilers and it seems reasonable to allow it in the headers
445 themselves, too. It only needs to precede the matching #p interface.
447 We don't touch finfo->interface_only or finfo->interface_unknown;
448 the user must specify a matching #p interface for this to have
452 handle_pragma_implementation (cpp_reader
* /*dfile*/)
454 tree fname
= parse_strconst_pragma ("implementation", 1);
455 const char *filename
;
456 struct impl_files
*ifiles
= impl_file_chain
;
458 if (fname
== error_mark_node
)
463 if (main_input_filename
)
464 filename
= main_input_filename
;
466 filename
= LOCATION_FILE (input_location
);
467 filename
= lbasename (filename
);
471 filename
= TREE_STRING_POINTER (fname
);
472 if (cpp_included_before (parse_in
, filename
, input_location
))
473 warning (0, "#pragma implementation for %qs appears after "
474 "file is included", filename
);
477 for (; ifiles
; ifiles
= ifiles
->next
)
479 if (! filename_cmp (ifiles
->filename
, filename
))
484 ifiles
= XNEW (struct impl_files
);
485 ifiles
->filename
= xstrdup (filename
);
486 ifiles
->next
= impl_file_chain
;
487 impl_file_chain
= ifiles
;
491 /* Issue an error message indicating that the lookup of NAME (an
492 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
495 unqualified_name_lookup_error (tree name
, location_t loc
)
497 if (loc
== UNKNOWN_LOCATION
)
498 loc
= cp_expr_loc_or_loc (name
, input_location
);
500 if (IDENTIFIER_ANY_OP_P (name
))
501 error_at (loc
, "%qD not defined", name
);
504 if (!objc_diagnose_private_ivar (name
))
506 auto_diagnostic_group d
;
507 name_hint hint
= suggest_alternatives_for (loc
, name
, true);
508 if (const char *suggestion
= hint
.suggestion ())
510 gcc_rich_location
richloc (loc
);
511 richloc
.add_fixit_replace (suggestion
);
513 "%qD was not declared in this scope; did you mean %qs?",
517 error_at (loc
, "%qD was not declared in this scope", name
);
519 /* Prevent repeated error messages by creating a VAR_DECL with
520 this NAME in the innermost block scope. */
521 if (local_bindings_p ())
523 tree decl
= build_decl (loc
, VAR_DECL
, name
, error_mark_node
);
524 TREE_USED (decl
) = true;
529 return error_mark_node
;
532 /* Like unqualified_name_lookup_error, but NAME_EXPR is an unqualified-id
533 NAME, encapsulated with its location in a CP_EXPR, used as a function.
534 Returns an appropriate expression for NAME. */
537 unqualified_fn_lookup_error (cp_expr name_expr
)
539 tree name
= name_expr
.get_value ();
540 location_t loc
= name_expr
.get_location ();
541 if (loc
== UNKNOWN_LOCATION
)
542 loc
= input_location
;
544 if (processing_template_decl
)
546 /* In a template, it is invalid to write "f()" or "f(3)" if no
547 declaration of "f" is available. Historically, G++ and most
548 other compilers accepted that usage since they deferred all name
549 lookup until instantiation time rather than doing unqualified
550 name lookup at template definition time; explain to the user what
553 Note that we have the exact wording of the following message in
554 the manual (trouble.texi, node "Name lookup"), so they need to
556 permerror (loc
, "there are no arguments to %qD that depend on a template "
557 "parameter, so a declaration of %qD must be available",
560 if (!flag_permissive
)
565 inform (loc
, "(if you use %<-fpermissive%>, G++ will accept your "
566 "code, but allowing the use of an undeclared name is "
574 return unqualified_name_lookup_error (name
, loc
);
578 /* Hasher for the conversion operator name hash table. */
579 struct conv_type_hasher
: ggc_ptr_hash
<tree_node
>
581 /* Hash NODE, an identifier node in the table. TYPE_UID is
582 suitable, as we're not concerned about matching canonicalness
584 static hashval_t
hash (tree node
)
586 return (hashval_t
) TYPE_UID (TREE_TYPE (node
));
589 /* Compare NODE, an identifier node in the table, against TYPE, an
590 incoming TYPE being looked up. */
591 static bool equal (tree node
, tree type
)
593 return TREE_TYPE (node
) == type
;
597 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
598 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
601 static GTY (()) hash_table
<conv_type_hasher
> *conv_type_names
;
603 /* Return an identifier for a conversion operator to TYPE. We can get
604 from the returned identifier to the type. We store TYPE, which is
605 not necessarily the canonical type, which allows us to report the
606 form the user used in error messages. All these identifiers are
607 not in the identifier hash table, and have the same string name.
608 These IDENTIFIERS are not in the identifier hash table, and all
609 have the same IDENTIFIER_STRING. */
612 make_conv_op_name (tree type
)
614 if (type
== error_mark_node
)
615 return error_mark_node
;
617 if (conv_type_names
== NULL
)
618 conv_type_names
= hash_table
<conv_type_hasher
>::create_ggc (31);
620 tree
*slot
= conv_type_names
->find_slot_with_hash
621 (type
, (hashval_t
) TYPE_UID (type
), INSERT
);
622 tree identifier
= *slot
;
625 /* Create a raw IDENTIFIER outside of the identifier hash
627 identifier
= copy_node (conv_op_identifier
);
629 /* Just in case something managed to bind. */
630 IDENTIFIER_BINDING (identifier
) = NULL
;
632 /* Hang TYPE off the identifier so it can be found easily later
633 when performing conversions. */
634 TREE_TYPE (identifier
) = type
;
642 /* Wrapper around build_lang_decl_loc(). Should gradually move to
643 build_lang_decl_loc() and then rename build_lang_decl_loc() back to
644 build_lang_decl(). */
647 build_lang_decl (enum tree_code code
, tree name
, tree type
)
649 return build_lang_decl_loc (input_location
, code
, name
, type
);
652 /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
653 DECL_LANG_SPECIFIC info to the result. */
656 build_lang_decl_loc (location_t loc
, enum tree_code code
, tree name
, tree type
)
660 t
= build_decl (loc
, code
, name
, type
);
661 retrofit_lang_decl (t
);
666 /* Maybe add a raw lang_decl to T, a decl. Return true if it needed
670 maybe_add_lang_decl_raw (tree t
, bool decomp_p
)
673 lang_decl_selector sel
;
676 sel
= lds_decomp
, size
= sizeof (struct lang_decl_decomp
);
677 else if (TREE_CODE (t
) == FUNCTION_DECL
)
678 sel
= lds_fn
, size
= sizeof (struct lang_decl_fn
);
679 else if (TREE_CODE (t
) == NAMESPACE_DECL
)
680 sel
= lds_ns
, size
= sizeof (struct lang_decl_ns
);
681 else if (TREE_CODE (t
) == PARM_DECL
)
682 sel
= lds_parm
, size
= sizeof (struct lang_decl_parm
);
683 else if (LANG_DECL_HAS_MIN (t
))
684 sel
= lds_min
, size
= sizeof (struct lang_decl_min
);
689 = (struct lang_decl
*) ggc_internal_cleared_alloc (size
);
691 ld
->u
.base
.selector
= sel
;
692 DECL_LANG_SPECIFIC (t
) = ld
;
695 /* Who'd create a namespace, only to put nothing in it? */
696 ld
->u
.ns
.bindings
= hash_table
<named_decl_hash
>::create_ggc (499);
698 if (GATHER_STATISTICS
)
700 tree_node_counts
[(int)lang_decl
] += 1;
701 tree_node_sizes
[(int)lang_decl
] += size
;
706 /* T has just had a decl_lang_specific added. Initialize its
710 set_decl_linkage (tree t
)
712 if (current_lang_name
== lang_name_cplusplus
713 || decl_linkage (t
) == lk_none
)
714 SET_DECL_LANGUAGE (t
, lang_cplusplus
);
715 else if (current_lang_name
== lang_name_c
)
716 SET_DECL_LANGUAGE (t
, lang_c
);
721 /* T is a VAR_DECL node that needs to be a decomposition of BASE. */
724 fit_decomposition_lang_decl (tree t
, tree base
)
726 if (struct lang_decl
*orig_ld
= DECL_LANG_SPECIFIC (t
))
728 if (orig_ld
->u
.base
.selector
== lds_min
)
730 maybe_add_lang_decl_raw (t
, true);
731 memcpy (DECL_LANG_SPECIFIC (t
), orig_ld
,
732 sizeof (struct lang_decl_min
));
733 /* Reset selector, which will have been bashed by the
735 DECL_LANG_SPECIFIC (t
)->u
.base
.selector
= lds_decomp
;
738 gcc_checking_assert (orig_ld
->u
.base
.selector
== lds_decomp
);
742 maybe_add_lang_decl_raw (t
, true);
743 set_decl_linkage (t
);
746 DECL_DECOMP_BASE (t
) = base
;
749 /* Add DECL_LANG_SPECIFIC info to T, if it needs one. Generally
750 every C++ decl needs one, but C builtins etc do not. */
753 retrofit_lang_decl (tree t
)
755 if (DECL_LANG_SPECIFIC (t
))
758 if (maybe_add_lang_decl_raw (t
, false))
759 set_decl_linkage (t
);
763 cxx_dup_lang_specific_decl (tree node
)
767 if (! DECL_LANG_SPECIFIC (node
))
770 switch (DECL_LANG_SPECIFIC (node
)->u
.base
.selector
)
773 size
= sizeof (struct lang_decl_min
);
776 size
= sizeof (struct lang_decl_fn
);
779 size
= sizeof (struct lang_decl_ns
);
782 size
= sizeof (struct lang_decl_parm
);
785 size
= sizeof (struct lang_decl_decomp
);
791 struct lang_decl
*ld
= (struct lang_decl
*) ggc_internal_alloc (size
);
792 memcpy (ld
, DECL_LANG_SPECIFIC (node
), size
);
793 DECL_LANG_SPECIFIC (node
) = ld
;
795 if (GATHER_STATISTICS
)
797 tree_node_counts
[(int)lang_decl
] += 1;
798 tree_node_sizes
[(int)lang_decl
] += size
;
802 /* Copy DECL, including any language-specific parts. */
805 copy_decl (tree decl MEM_STAT_DECL
)
809 copy
= copy_node (decl PASS_MEM_STAT
);
810 cxx_dup_lang_specific_decl (copy
);
814 /* Replace the shared language-specific parts of NODE with a new copy. */
817 copy_lang_type (tree node
)
819 if (! TYPE_LANG_SPECIFIC (node
))
823 = (struct lang_type
*) ggc_internal_alloc (sizeof (struct lang_type
));
825 memcpy (lt
, TYPE_LANG_SPECIFIC (node
), (sizeof (struct lang_type
)));
826 TYPE_LANG_SPECIFIC (node
) = lt
;
828 if (GATHER_STATISTICS
)
830 tree_node_counts
[(int)lang_type
] += 1;
831 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
835 /* Copy TYPE, including any language-specific parts. */
838 copy_type (tree type MEM_STAT_DECL
)
842 copy
= copy_node (type PASS_MEM_STAT
);
843 copy_lang_type (copy
);
847 /* Add a raw lang_type to T, a type, should it need one. */
850 maybe_add_lang_type_raw (tree t
)
852 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (t
)))
855 TYPE_LANG_SPECIFIC (t
)
856 = (struct lang_type
*) (ggc_internal_cleared_alloc
857 (sizeof (struct lang_type
)));
859 if (GATHER_STATISTICS
)
861 tree_node_counts
[(int)lang_type
] += 1;
862 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
869 cxx_make_type (enum tree_code code MEM_STAT_DECL
)
871 tree t
= make_node (code PASS_MEM_STAT
);
873 if (maybe_add_lang_type_raw (t
))
875 /* Set up some flags that give proper default behavior. */
876 struct c_fileinfo
*finfo
=
877 get_fileinfo (LOCATION_FILE (input_location
));
878 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, finfo
->interface_unknown
);
879 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
885 /* A wrapper without the memory stats for LANG_HOOKS_MAKE_TYPE. */
888 cxx_make_type_hook (enum tree_code code
)
890 return cxx_make_type (code
);
894 make_class_type (enum tree_code code MEM_STAT_DECL
)
896 tree t
= cxx_make_type (code PASS_MEM_STAT
);
897 SET_CLASS_TYPE_P (t
, 1);
901 /* Returns true if we are currently in the main source file, or in a
902 template instantiation started from the main source file. */
905 in_main_input_context (void)
907 struct tinst_level
*tl
= outermost_tinst_level();
910 return filename_cmp (main_input_filename
,
911 LOCATION_FILE (tl
->locus
)) == 0;
913 return filename_cmp (main_input_filename
, LOCATION_FILE (input_location
)) == 0;
916 #include "gt-cp-lex.h"