1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987-2019 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_CXX_CHAR8_T
;
239 mask
|= D_ASM
| D_EXT
;
240 if (flag_no_gnu_keywords
)
243 /* The Objective-C keywords are all context-dependent. */
246 ridpointers
= ggc_cleared_vec_alloc
<tree
> ((int) RID_MAX
);
247 for (i
= 0; i
< num_c_common_reswords
; i
++)
249 if (c_common_reswords
[i
].disable
& D_CONLY
)
251 id
= get_identifier (c_common_reswords
[i
].word
);
252 C_SET_RID_CODE (id
, c_common_reswords
[i
].rid
);
253 ridpointers
[(int) c_common_reswords
[i
].rid
] = id
;
254 if (! (c_common_reswords
[i
].disable
& mask
))
255 set_identifier_kind (id
, cik_keyword
);
258 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
261 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
262 id
= get_identifier (name
);
263 C_SET_RID_CODE (id
, RID_FIRST_INT_N
+ i
);
264 set_identifier_kind (id
, cik_keyword
);
269 init_cp_pragma (void)
271 c_register_pragma (0, "vtable", handle_pragma_vtable
);
272 c_register_pragma (0, "unit", handle_pragma_unit
);
273 c_register_pragma (0, "interface", handle_pragma_interface
);
274 c_register_pragma (0, "implementation", handle_pragma_implementation
);
275 c_register_pragma ("GCC", "interface", handle_pragma_interface
);
276 c_register_pragma ("GCC", "implementation", handle_pragma_implementation
);
279 /* TRUE if a code represents a statement. */
281 bool statement_code_p
[MAX_TREE_CODES
];
283 /* Initialize the C++ front end. This function is very sensitive to
284 the exact order that things are done here. It would be nice if the
285 initialization done by this routine were moved to its subroutines,
286 and the ordering dependencies clarified and reduced. */
290 location_t saved_loc
;
292 static const enum tree_code stmt_codes
[] = {
293 CTOR_INITIALIZER
, TRY_BLOCK
, HANDLER
,
294 EH_SPEC_BLOCK
, USING_STMT
, TAG_DEFN
,
295 IF_STMT
, CLEANUP_STMT
, FOR_STMT
,
296 RANGE_FOR_STMT
, WHILE_STMT
, DO_STMT
,
297 BREAK_STMT
, CONTINUE_STMT
, SWITCH_STMT
,
298 EXPR_STMT
, OMP_DEPOBJ
301 memset (&statement_code_p
, 0, sizeof (statement_code_p
));
302 for (i
= 0; i
< ARRAY_SIZE (stmt_codes
); i
++)
303 statement_code_p
[stmt_codes
[i
]] = true;
305 saved_loc
= input_location
;
306 input_location
= BUILTINS_LOCATION
;
310 init_cp_semantics ();
314 current_function_decl
= NULL
;
316 class_type_node
= ridpointers
[(int) RID_CLASS
];
318 cxx_init_decl_processing ();
320 if (c_common_init () == false)
322 input_location
= saved_loc
;
330 input_location
= saved_loc
;
334 /* Return nonzero if S is not considered part of an
335 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
338 interface_strcmp (const char* s
)
340 /* Set the interface/implementation bits for this scope. */
341 struct impl_files
*ifiles
;
344 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
346 const char *t1
= ifiles
->filename
;
349 if (*s1
== 0 || filename_ncmp (s1
, t1
, 1) != 0)
352 while (*s1
!= 0 && filename_ncmp (s1
, t1
, 1) == 0)
359 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
360 if (strchr (s1
, '.') || strchr (t1
, '.'))
363 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
376 /* Parse a #pragma whose sole argument is a string constant.
377 If OPT is true, the argument is optional. */
379 parse_strconst_pragma (const char* name
, int opt
)
384 t
= pragma_lex (&result
);
387 if (pragma_lex (&x
) != CPP_EOF
)
388 warning (0, "junk at end of %<#pragma %s%>", name
);
392 if (t
== CPP_EOF
&& opt
)
395 error ("invalid %<#pragma %s%>", name
);
396 return error_mark_node
;
400 handle_pragma_vtable (cpp_reader
* /*dfile*/)
402 parse_strconst_pragma ("vtable", 0);
403 sorry ("%<#pragma vtable%> no longer supported");
407 handle_pragma_unit (cpp_reader
* /*dfile*/)
409 /* Validate syntax, but don't do anything. */
410 parse_strconst_pragma ("unit", 0);
414 handle_pragma_interface (cpp_reader
* /*dfile*/)
416 tree fname
= parse_strconst_pragma ("interface", 1);
417 struct c_fileinfo
*finfo
;
418 const char *filename
;
420 if (fname
== error_mark_node
)
423 filename
= lbasename (LOCATION_FILE (input_location
));
425 filename
= TREE_STRING_POINTER (fname
);
427 finfo
= get_fileinfo (LOCATION_FILE (input_location
));
429 if (impl_file_chain
== 0)
431 /* If this is zero at this point, then we are
432 auto-implementing. */
433 if (main_input_filename
== 0)
434 main_input_filename
= LOCATION_FILE (input_location
);
437 finfo
->interface_only
= interface_strcmp (filename
);
438 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
439 a definition in another file. */
440 if (!MULTIPLE_SYMBOL_SPACES
|| !finfo
->interface_only
)
441 finfo
->interface_unknown
= 0;
444 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
445 We used to only allow this at toplevel, but that restriction was buggy
446 in older compilers and it seems reasonable to allow it in the headers
447 themselves, too. It only needs to precede the matching #p interface.
449 We don't touch finfo->interface_only or finfo->interface_unknown;
450 the user must specify a matching #p interface for this to have
454 handle_pragma_implementation (cpp_reader
* /*dfile*/)
456 tree fname
= parse_strconst_pragma ("implementation", 1);
457 const char *filename
;
458 struct impl_files
*ifiles
= impl_file_chain
;
460 if (fname
== error_mark_node
)
465 if (main_input_filename
)
466 filename
= main_input_filename
;
468 filename
= LOCATION_FILE (input_location
);
469 filename
= lbasename (filename
);
473 filename
= TREE_STRING_POINTER (fname
);
474 if (cpp_included_before (parse_in
, filename
, input_location
))
475 warning (0, "%<#pragma implementation%> for %qs appears after "
476 "file is included", filename
);
479 for (; ifiles
; ifiles
= ifiles
->next
)
481 if (! filename_cmp (ifiles
->filename
, filename
))
486 ifiles
= XNEW (struct impl_files
);
487 ifiles
->filename
= xstrdup (filename
);
488 ifiles
->next
= impl_file_chain
;
489 impl_file_chain
= ifiles
;
493 /* Issue an error message indicating that the lookup of NAME (an
494 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
497 unqualified_name_lookup_error (tree name
, location_t loc
)
499 if (loc
== UNKNOWN_LOCATION
)
500 loc
= cp_expr_loc_or_loc (name
, input_location
);
502 if (IDENTIFIER_ANY_OP_P (name
))
503 error_at (loc
, "%qD not defined", name
);
506 if (!objc_diagnose_private_ivar (name
))
508 auto_diagnostic_group d
;
509 name_hint hint
= suggest_alternatives_for (loc
, name
, true);
510 if (const char *suggestion
= hint
.suggestion ())
512 gcc_rich_location
richloc (loc
);
513 richloc
.add_fixit_replace (suggestion
);
515 "%qD was not declared in this scope; did you mean %qs?",
519 error_at (loc
, "%qD was not declared in this scope", name
);
521 /* Prevent repeated error messages by creating a VAR_DECL with
522 this NAME in the innermost block scope. */
523 if (local_bindings_p ())
525 tree decl
= build_decl (loc
, VAR_DECL
, name
, error_mark_node
);
526 TREE_USED (decl
) = true;
531 return error_mark_node
;
534 /* Like unqualified_name_lookup_error, but NAME_EXPR is an unqualified-id
535 NAME, encapsulated with its location in a CP_EXPR, used as a function.
536 Returns an appropriate expression for NAME. */
539 unqualified_fn_lookup_error (cp_expr name_expr
)
541 tree name
= name_expr
.get_value ();
542 location_t loc
= name_expr
.get_location ();
543 if (loc
== UNKNOWN_LOCATION
)
544 loc
= input_location
;
546 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
547 name
= TREE_OPERAND (name
, 0);
549 if (processing_template_decl
)
551 /* In a template, it is invalid to write "f()" or "f(3)" if no
552 declaration of "f" is available. Historically, G++ and most
553 other compilers accepted that usage since they deferred all name
554 lookup until instantiation time rather than doing unqualified
555 name lookup at template definition time; explain to the user what
558 Note that we have the exact wording of the following message in
559 the manual (trouble.texi, node "Name lookup"), so they need to
561 permerror (loc
, "there are no arguments to %qD that depend on a template "
562 "parameter, so a declaration of %qD must be available",
565 if (!flag_permissive
)
570 inform (loc
, "(if you use %<-fpermissive%>, G++ will accept your "
571 "code, but allowing the use of an undeclared name is "
579 return unqualified_name_lookup_error (name
, loc
);
583 /* Hasher for the conversion operator name hash table. */
584 struct conv_type_hasher
: ggc_ptr_hash
<tree_node
>
586 /* Hash NODE, an identifier node in the table. TYPE_UID is
587 suitable, as we're not concerned about matching canonicalness
589 static hashval_t
hash (tree node
)
591 return (hashval_t
) TYPE_UID (TREE_TYPE (node
));
594 /* Compare NODE, an identifier node in the table, against TYPE, an
595 incoming TYPE being looked up. */
596 static bool equal (tree node
, tree type
)
598 return TREE_TYPE (node
) == type
;
602 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
603 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
606 static GTY (()) hash_table
<conv_type_hasher
> *conv_type_names
;
608 /* Return an identifier for a conversion operator to TYPE. We can get
609 from the returned identifier to the type. We store TYPE, which is
610 not necessarily the canonical type, which allows us to report the
611 form the user used in error messages. All these identifiers are
612 not in the identifier hash table, and have the same string name.
613 These IDENTIFIERS are not in the identifier hash table, and all
614 have the same IDENTIFIER_STRING. */
617 make_conv_op_name (tree type
)
619 if (type
== error_mark_node
)
620 return error_mark_node
;
622 if (conv_type_names
== NULL
)
623 conv_type_names
= hash_table
<conv_type_hasher
>::create_ggc (31);
625 tree
*slot
= conv_type_names
->find_slot_with_hash
626 (type
, (hashval_t
) TYPE_UID (type
), INSERT
);
627 tree identifier
= *slot
;
630 /* Create a raw IDENTIFIER outside of the identifier hash
632 identifier
= copy_node (conv_op_identifier
);
634 /* Just in case something managed to bind. */
635 IDENTIFIER_BINDING (identifier
) = NULL
;
637 /* Hang TYPE off the identifier so it can be found easily later
638 when performing conversions. */
639 TREE_TYPE (identifier
) = type
;
647 /* Wrapper around build_lang_decl_loc(). Should gradually move to
648 build_lang_decl_loc() and then rename build_lang_decl_loc() back to
649 build_lang_decl(). */
652 build_lang_decl (enum tree_code code
, tree name
, tree type
)
654 return build_lang_decl_loc (input_location
, code
, name
, type
);
657 /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
658 DECL_LANG_SPECIFIC info to the result. */
661 build_lang_decl_loc (location_t loc
, enum tree_code code
, tree name
, tree type
)
665 t
= build_decl (loc
, code
, name
, type
);
666 retrofit_lang_decl (t
);
671 /* Maybe add a raw lang_decl to T, a decl. Return true if it needed
675 maybe_add_lang_decl_raw (tree t
, bool decomp_p
)
678 lang_decl_selector sel
;
681 sel
= lds_decomp
, size
= sizeof (struct lang_decl_decomp
);
682 else if (TREE_CODE (t
) == FUNCTION_DECL
)
683 sel
= lds_fn
, size
= sizeof (struct lang_decl_fn
);
684 else if (TREE_CODE (t
) == NAMESPACE_DECL
)
685 sel
= lds_ns
, size
= sizeof (struct lang_decl_ns
);
686 else if (TREE_CODE (t
) == PARM_DECL
)
687 sel
= lds_parm
, size
= sizeof (struct lang_decl_parm
);
688 else if (LANG_DECL_HAS_MIN (t
))
689 sel
= lds_min
, size
= sizeof (struct lang_decl_min
);
694 = (struct lang_decl
*) ggc_internal_cleared_alloc (size
);
696 ld
->u
.base
.selector
= sel
;
697 DECL_LANG_SPECIFIC (t
) = ld
;
700 /* Who'd create a namespace, only to put nothing in it? */
701 ld
->u
.ns
.bindings
= hash_table
<named_decl_hash
>::create_ggc (499);
703 if (GATHER_STATISTICS
)
705 tree_node_counts
[(int)lang_decl
] += 1;
706 tree_node_sizes
[(int)lang_decl
] += size
;
711 /* T has just had a decl_lang_specific added. Initialize its
715 set_decl_linkage (tree t
)
717 if (current_lang_name
== lang_name_cplusplus
718 || decl_linkage (t
) == lk_none
)
719 SET_DECL_LANGUAGE (t
, lang_cplusplus
);
720 else if (current_lang_name
== lang_name_c
)
721 SET_DECL_LANGUAGE (t
, lang_c
);
726 /* T is a VAR_DECL node that needs to be a decomposition of BASE. */
729 fit_decomposition_lang_decl (tree t
, tree base
)
731 if (struct lang_decl
*orig_ld
= DECL_LANG_SPECIFIC (t
))
733 if (orig_ld
->u
.base
.selector
== lds_min
)
735 maybe_add_lang_decl_raw (t
, true);
736 memcpy (DECL_LANG_SPECIFIC (t
), orig_ld
,
737 sizeof (struct lang_decl_min
));
738 /* Reset selector, which will have been bashed by the
740 DECL_LANG_SPECIFIC (t
)->u
.base
.selector
= lds_decomp
;
743 gcc_checking_assert (orig_ld
->u
.base
.selector
== lds_decomp
);
747 maybe_add_lang_decl_raw (t
, true);
748 set_decl_linkage (t
);
751 DECL_DECOMP_BASE (t
) = base
;
754 /* Add DECL_LANG_SPECIFIC info to T, if it needs one. Generally
755 every C++ decl needs one, but C builtins etc do not. */
758 retrofit_lang_decl (tree t
)
760 if (DECL_LANG_SPECIFIC (t
))
763 if (maybe_add_lang_decl_raw (t
, false))
764 set_decl_linkage (t
);
768 cxx_dup_lang_specific_decl (tree node
)
772 if (! DECL_LANG_SPECIFIC (node
))
775 switch (DECL_LANG_SPECIFIC (node
)->u
.base
.selector
)
778 size
= sizeof (struct lang_decl_min
);
781 size
= sizeof (struct lang_decl_fn
);
784 size
= sizeof (struct lang_decl_ns
);
787 size
= sizeof (struct lang_decl_parm
);
790 size
= sizeof (struct lang_decl_decomp
);
796 struct lang_decl
*ld
= (struct lang_decl
*) ggc_internal_alloc (size
);
797 memcpy (ld
, DECL_LANG_SPECIFIC (node
), size
);
798 DECL_LANG_SPECIFIC (node
) = ld
;
800 if (GATHER_STATISTICS
)
802 tree_node_counts
[(int)lang_decl
] += 1;
803 tree_node_sizes
[(int)lang_decl
] += size
;
807 /* Copy DECL, including any language-specific parts. */
810 copy_decl (tree decl MEM_STAT_DECL
)
814 copy
= copy_node (decl PASS_MEM_STAT
);
815 cxx_dup_lang_specific_decl (copy
);
819 /* Replace the shared language-specific parts of NODE with a new copy. */
822 copy_lang_type (tree node
)
824 if (! TYPE_LANG_SPECIFIC (node
))
828 = (struct lang_type
*) ggc_internal_alloc (sizeof (struct lang_type
));
830 memcpy (lt
, TYPE_LANG_SPECIFIC (node
), (sizeof (struct lang_type
)));
831 TYPE_LANG_SPECIFIC (node
) = lt
;
833 if (GATHER_STATISTICS
)
835 tree_node_counts
[(int)lang_type
] += 1;
836 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
840 /* Copy TYPE, including any language-specific parts. */
843 copy_type (tree type MEM_STAT_DECL
)
847 copy
= copy_node (type PASS_MEM_STAT
);
848 copy_lang_type (copy
);
852 /* Add a raw lang_type to T, a type, should it need one. */
855 maybe_add_lang_type_raw (tree t
)
857 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (t
)))
860 TYPE_LANG_SPECIFIC (t
)
861 = (struct lang_type
*) (ggc_internal_cleared_alloc
862 (sizeof (struct lang_type
)));
864 if (GATHER_STATISTICS
)
866 tree_node_counts
[(int)lang_type
] += 1;
867 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
874 cxx_make_type (enum tree_code code MEM_STAT_DECL
)
876 tree t
= make_node (code PASS_MEM_STAT
);
878 if (maybe_add_lang_type_raw (t
))
880 /* Set up some flags that give proper default behavior. */
881 struct c_fileinfo
*finfo
=
882 get_fileinfo (LOCATION_FILE (input_location
));
883 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, finfo
->interface_unknown
);
884 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
890 /* A wrapper without the memory stats for LANG_HOOKS_MAKE_TYPE. */
893 cxx_make_type_hook (enum tree_code code
)
895 return cxx_make_type (code
);
899 make_class_type (enum tree_code code MEM_STAT_DECL
)
901 tree t
= cxx_make_type (code PASS_MEM_STAT
);
902 SET_CLASS_TYPE_P (t
, 1);
906 /* Returns true if we are currently in the main source file, or in a
907 template instantiation started from the main source file. */
910 in_main_input_context (void)
912 struct tinst_level
*tl
= outermost_tinst_level();
915 return filename_cmp (main_input_filename
,
916 LOCATION_FILE (tl
->locus
)) == 0;
918 return filename_cmp (main_input_filename
, LOCATION_FILE (input_location
)) == 0;
921 #include "gt-cp-lex.h"