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 (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
545 name
= TREE_OPERAND (name
, 0);
547 if (processing_template_decl
)
549 /* In a template, it is invalid to write "f()" or "f(3)" if no
550 declaration of "f" is available. Historically, G++ and most
551 other compilers accepted that usage since they deferred all name
552 lookup until instantiation time rather than doing unqualified
553 name lookup at template definition time; explain to the user what
556 Note that we have the exact wording of the following message in
557 the manual (trouble.texi, node "Name lookup"), so they need to
559 permerror (loc
, "there are no arguments to %qD that depend on a template "
560 "parameter, so a declaration of %qD must be available",
563 if (!flag_permissive
)
568 inform (loc
, "(if you use %<-fpermissive%>, G++ will accept your "
569 "code, but allowing the use of an undeclared name is "
577 return unqualified_name_lookup_error (name
, loc
);
581 /* Hasher for the conversion operator name hash table. */
582 struct conv_type_hasher
: ggc_ptr_hash
<tree_node
>
584 /* Hash NODE, an identifier node in the table. TYPE_UID is
585 suitable, as we're not concerned about matching canonicalness
587 static hashval_t
hash (tree node
)
589 return (hashval_t
) TYPE_UID (TREE_TYPE (node
));
592 /* Compare NODE, an identifier node in the table, against TYPE, an
593 incoming TYPE being looked up. */
594 static bool equal (tree node
, tree type
)
596 return TREE_TYPE (node
) == type
;
600 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
601 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
604 static GTY (()) hash_table
<conv_type_hasher
> *conv_type_names
;
606 /* Return an identifier for a conversion operator to TYPE. We can get
607 from the returned identifier to the type. We store TYPE, which is
608 not necessarily the canonical type, which allows us to report the
609 form the user used in error messages. All these identifiers are
610 not in the identifier hash table, and have the same string name.
611 These IDENTIFIERS are not in the identifier hash table, and all
612 have the same IDENTIFIER_STRING. */
615 make_conv_op_name (tree type
)
617 if (type
== error_mark_node
)
618 return error_mark_node
;
620 if (conv_type_names
== NULL
)
621 conv_type_names
= hash_table
<conv_type_hasher
>::create_ggc (31);
623 tree
*slot
= conv_type_names
->find_slot_with_hash
624 (type
, (hashval_t
) TYPE_UID (type
), INSERT
);
625 tree identifier
= *slot
;
628 /* Create a raw IDENTIFIER outside of the identifier hash
630 identifier
= copy_node (conv_op_identifier
);
632 /* Just in case something managed to bind. */
633 IDENTIFIER_BINDING (identifier
) = NULL
;
635 /* Hang TYPE off the identifier so it can be found easily later
636 when performing conversions. */
637 TREE_TYPE (identifier
) = type
;
645 /* Wrapper around build_lang_decl_loc(). Should gradually move to
646 build_lang_decl_loc() and then rename build_lang_decl_loc() back to
647 build_lang_decl(). */
650 build_lang_decl (enum tree_code code
, tree name
, tree type
)
652 return build_lang_decl_loc (input_location
, code
, name
, type
);
655 /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
656 DECL_LANG_SPECIFIC info to the result. */
659 build_lang_decl_loc (location_t loc
, enum tree_code code
, tree name
, tree type
)
663 t
= build_decl (loc
, code
, name
, type
);
664 retrofit_lang_decl (t
);
669 /* Maybe add a raw lang_decl to T, a decl. Return true if it needed
673 maybe_add_lang_decl_raw (tree t
, bool decomp_p
)
676 lang_decl_selector sel
;
679 sel
= lds_decomp
, size
= sizeof (struct lang_decl_decomp
);
680 else if (TREE_CODE (t
) == FUNCTION_DECL
)
681 sel
= lds_fn
, size
= sizeof (struct lang_decl_fn
);
682 else if (TREE_CODE (t
) == NAMESPACE_DECL
)
683 sel
= lds_ns
, size
= sizeof (struct lang_decl_ns
);
684 else if (TREE_CODE (t
) == PARM_DECL
)
685 sel
= lds_parm
, size
= sizeof (struct lang_decl_parm
);
686 else if (LANG_DECL_HAS_MIN (t
))
687 sel
= lds_min
, size
= sizeof (struct lang_decl_min
);
692 = (struct lang_decl
*) ggc_internal_cleared_alloc (size
);
694 ld
->u
.base
.selector
= sel
;
695 DECL_LANG_SPECIFIC (t
) = ld
;
698 /* Who'd create a namespace, only to put nothing in it? */
699 ld
->u
.ns
.bindings
= hash_table
<named_decl_hash
>::create_ggc (499);
701 if (GATHER_STATISTICS
)
703 tree_node_counts
[(int)lang_decl
] += 1;
704 tree_node_sizes
[(int)lang_decl
] += size
;
709 /* T has just had a decl_lang_specific added. Initialize its
713 set_decl_linkage (tree t
)
715 if (current_lang_name
== lang_name_cplusplus
716 || decl_linkage (t
) == lk_none
)
717 SET_DECL_LANGUAGE (t
, lang_cplusplus
);
718 else if (current_lang_name
== lang_name_c
)
719 SET_DECL_LANGUAGE (t
, lang_c
);
724 /* T is a VAR_DECL node that needs to be a decomposition of BASE. */
727 fit_decomposition_lang_decl (tree t
, tree base
)
729 if (struct lang_decl
*orig_ld
= DECL_LANG_SPECIFIC (t
))
731 if (orig_ld
->u
.base
.selector
== lds_min
)
733 maybe_add_lang_decl_raw (t
, true);
734 memcpy (DECL_LANG_SPECIFIC (t
), orig_ld
,
735 sizeof (struct lang_decl_min
));
736 /* Reset selector, which will have been bashed by the
738 DECL_LANG_SPECIFIC (t
)->u
.base
.selector
= lds_decomp
;
741 gcc_checking_assert (orig_ld
->u
.base
.selector
== lds_decomp
);
745 maybe_add_lang_decl_raw (t
, true);
746 set_decl_linkage (t
);
749 DECL_DECOMP_BASE (t
) = base
;
752 /* Add DECL_LANG_SPECIFIC info to T, if it needs one. Generally
753 every C++ decl needs one, but C builtins etc do not. */
756 retrofit_lang_decl (tree t
)
758 if (DECL_LANG_SPECIFIC (t
))
761 if (maybe_add_lang_decl_raw (t
, false))
762 set_decl_linkage (t
);
766 cxx_dup_lang_specific_decl (tree node
)
770 if (! DECL_LANG_SPECIFIC (node
))
773 switch (DECL_LANG_SPECIFIC (node
)->u
.base
.selector
)
776 size
= sizeof (struct lang_decl_min
);
779 size
= sizeof (struct lang_decl_fn
);
782 size
= sizeof (struct lang_decl_ns
);
785 size
= sizeof (struct lang_decl_parm
);
788 size
= sizeof (struct lang_decl_decomp
);
794 struct lang_decl
*ld
= (struct lang_decl
*) ggc_internal_alloc (size
);
795 memcpy (ld
, DECL_LANG_SPECIFIC (node
), size
);
796 DECL_LANG_SPECIFIC (node
) = ld
;
798 if (GATHER_STATISTICS
)
800 tree_node_counts
[(int)lang_decl
] += 1;
801 tree_node_sizes
[(int)lang_decl
] += size
;
805 /* Copy DECL, including any language-specific parts. */
808 copy_decl (tree decl MEM_STAT_DECL
)
812 copy
= copy_node (decl PASS_MEM_STAT
);
813 cxx_dup_lang_specific_decl (copy
);
817 /* Replace the shared language-specific parts of NODE with a new copy. */
820 copy_lang_type (tree node
)
822 if (! TYPE_LANG_SPECIFIC (node
))
826 = (struct lang_type
*) ggc_internal_alloc (sizeof (struct lang_type
));
828 memcpy (lt
, TYPE_LANG_SPECIFIC (node
), (sizeof (struct lang_type
)));
829 TYPE_LANG_SPECIFIC (node
) = lt
;
831 if (GATHER_STATISTICS
)
833 tree_node_counts
[(int)lang_type
] += 1;
834 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
838 /* Copy TYPE, including any language-specific parts. */
841 copy_type (tree type MEM_STAT_DECL
)
845 copy
= copy_node (type PASS_MEM_STAT
);
846 copy_lang_type (copy
);
850 /* Add a raw lang_type to T, a type, should it need one. */
853 maybe_add_lang_type_raw (tree t
)
855 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (t
)))
858 TYPE_LANG_SPECIFIC (t
)
859 = (struct lang_type
*) (ggc_internal_cleared_alloc
860 (sizeof (struct lang_type
)));
862 if (GATHER_STATISTICS
)
864 tree_node_counts
[(int)lang_type
] += 1;
865 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
872 cxx_make_type (enum tree_code code MEM_STAT_DECL
)
874 tree t
= make_node (code PASS_MEM_STAT
);
876 if (maybe_add_lang_type_raw (t
))
878 /* Set up some flags that give proper default behavior. */
879 struct c_fileinfo
*finfo
=
880 get_fileinfo (LOCATION_FILE (input_location
));
881 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, finfo
->interface_unknown
);
882 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
888 /* A wrapper without the memory stats for LANG_HOOKS_MAKE_TYPE. */
891 cxx_make_type_hook (enum tree_code code
)
893 return cxx_make_type (code
);
897 make_class_type (enum tree_code code MEM_STAT_DECL
)
899 tree t
= cxx_make_type (code PASS_MEM_STAT
);
900 SET_CLASS_TYPE_P (t
, 1);
904 /* Returns true if we are currently in the main source file, or in a
905 template instantiation started from the main source file. */
908 in_main_input_context (void)
910 struct tinst_level
*tl
= outermost_tinst_level();
913 return filename_cmp (main_input_filename
,
914 LOCATION_FILE (tl
->locus
)) == 0;
916 return filename_cmp (main_input_filename
, LOCATION_FILE (input_location
)) == 0;
919 #include "gt-cp-lex.h"