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 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
24 /* This file is the lexical analyzer for GNU C++. */
28 #include "coretypes.h"
41 static int interface_strcmp (const char *);
42 static void init_cp_pragma (void);
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
*);
51 static void init_operators (void);
52 static void copy_lang_type (tree
);
54 /* A constraint that can be tested at compile time. */
55 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
57 /* Functions and data structures for #pragma interface.
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".
64 All main input files "implement" themselves automagically.
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
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"'. */
79 struct impl_files
*next
;
82 static struct impl_files
*impl_file_chain
;
91 /* A mapping from tree codes to operator name information. */
92 operator_name_info_t operator_name_info
[(int) LAST_CPLUS_TREE_CODE
];
93 /* Similar, but for assignment operators. */
94 operator_name_info_t assignment_operator_name_info
[(int) LAST_CPLUS_TREE_CODE
];
96 /* Initialize data structures that keep track of operator names. */
98 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
99 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
100 #include "operators.def"
104 init_operators (void)
108 struct operator_name_info_t
*oni
;
110 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
111 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
112 identifier = get_identifier (buffer); \
113 IDENTIFIER_OPNAME_P (identifier) = 1; \
116 ? &assignment_operator_name_info[(int) CODE] \
117 : &operator_name_info[(int) CODE]); \
118 oni->identifier = identifier; \
120 oni->mangled_name = MANGLING; \
123 #include "operators.def"
126 operator_name_info
[(int) ERROR_MARK
].identifier
127 = get_identifier ("<invalid operator>");
129 /* Handle some special cases. These operators are not defined in
130 the language, but can be produced internally. We may need them
131 for error-reporting. (Eventually, we should ensure that this
132 does not happen. Error messages involving these operators will
133 be confusing to users.) */
135 operator_name_info
[(int) INIT_EXPR
].name
136 = operator_name_info
[(int) MODIFY_EXPR
].name
;
137 operator_name_info
[(int) EXACT_DIV_EXPR
].name
= "(ceiling /)";
138 operator_name_info
[(int) CEIL_DIV_EXPR
].name
= "(ceiling /)";
139 operator_name_info
[(int) FLOOR_DIV_EXPR
].name
= "(floor /)";
140 operator_name_info
[(int) ROUND_DIV_EXPR
].name
= "(round /)";
141 operator_name_info
[(int) CEIL_MOD_EXPR
].name
= "(ceiling %)";
142 operator_name_info
[(int) FLOOR_MOD_EXPR
].name
= "(floor %)";
143 operator_name_info
[(int) ROUND_MOD_EXPR
].name
= "(round %)";
144 operator_name_info
[(int) ABS_EXPR
].name
= "abs";
145 operator_name_info
[(int) TRUTH_AND_EXPR
].name
= "strict &&";
146 operator_name_info
[(int) TRUTH_OR_EXPR
].name
= "strict ||";
147 operator_name_info
[(int) RANGE_EXPR
].name
= "...";
148 operator_name_info
[(int) UNARY_PLUS_EXPR
].name
= "+";
150 assignment_operator_name_info
[(int) EXACT_DIV_EXPR
].name
152 assignment_operator_name_info
[(int) CEIL_DIV_EXPR
].name
154 assignment_operator_name_info
[(int) FLOOR_DIV_EXPR
].name
156 assignment_operator_name_info
[(int) ROUND_DIV_EXPR
].name
158 assignment_operator_name_info
[(int) CEIL_MOD_EXPR
].name
160 assignment_operator_name_info
[(int) FLOOR_MOD_EXPR
].name
162 assignment_operator_name_info
[(int) ROUND_MOD_EXPR
].name
166 /* The reserved keyword table. */
169 const char *const word
;
170 ENUM_BITFIELD(rid
) const rid
: 16;
171 const unsigned int disable
: 16;
174 /* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is
176 #define D_EXT 0x01 /* GCC extension */
177 #define D_ASM 0x02 /* in C99, but has a switch to turn it off */
178 #define D_OBJC 0x04 /* Objective C++ only */
180 CONSTRAINT(ridbits_fit
, RID_LAST_MODIFIER
< sizeof(unsigned long) * CHAR_BIT
);
182 static const struct resword reswords
[] =
184 { "_Complex", RID_COMPLEX
, 0 },
185 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
186 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
187 { "__alignof", RID_ALIGNOF
, 0 },
188 { "__alignof__", RID_ALIGNOF
, 0 },
189 { "__asm", RID_ASM
, 0 },
190 { "__asm__", RID_ASM
, 0 },
191 { "__attribute", RID_ATTRIBUTE
, 0 },
192 { "__attribute__", RID_ATTRIBUTE
, 0 },
193 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
194 { "__builtin_va_arg", RID_VA_ARG
, 0 },
195 { "__complex", RID_COMPLEX
, 0 },
196 { "__complex__", RID_COMPLEX
, 0 },
197 { "__const", RID_CONST
, 0 },
198 { "__const__", RID_CONST
, 0 },
199 { "__extension__", RID_EXTENSION
, 0 },
200 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
201 { "__imag", RID_IMAGPART
, 0 },
202 { "__imag__", RID_IMAGPART
, 0 },
203 { "__inline", RID_INLINE
, 0 },
204 { "__inline__", RID_INLINE
, 0 },
205 { "__label__", RID_LABEL
, 0 },
206 { "__null", RID_NULL
, 0 },
207 { "__real", RID_REALPART
, 0 },
208 { "__real__", RID_REALPART
, 0 },
209 { "__restrict", RID_RESTRICT
, 0 },
210 { "__restrict__", RID_RESTRICT
, 0 },
211 { "__signed", RID_SIGNED
, 0 },
212 { "__signed__", RID_SIGNED
, 0 },
213 { "__thread", RID_THREAD
, 0 },
214 { "__typeof", RID_TYPEOF
, 0 },
215 { "__typeof__", RID_TYPEOF
, 0 },
216 { "__volatile", RID_VOLATILE
, 0 },
217 { "__volatile__", RID_VOLATILE
, 0 },
218 { "asm", RID_ASM
, D_ASM
},
219 { "auto", RID_AUTO
, 0 },
220 { "bool", RID_BOOL
, 0 },
221 { "break", RID_BREAK
, 0 },
222 { "case", RID_CASE
, 0 },
223 { "catch", RID_CATCH
, 0 },
224 { "char", RID_CHAR
, 0 },
225 { "class", RID_CLASS
, 0 },
226 { "const", RID_CONST
, 0 },
227 { "const_cast", RID_CONSTCAST
, 0 },
228 { "continue", RID_CONTINUE
, 0 },
229 { "default", RID_DEFAULT
, 0 },
230 { "delete", RID_DELETE
, 0 },
232 { "double", RID_DOUBLE
, 0 },
233 { "dynamic_cast", RID_DYNCAST
, 0 },
234 { "else", RID_ELSE
, 0 },
235 { "enum", RID_ENUM
, 0 },
236 { "explicit", RID_EXPLICIT
, 0 },
237 { "export", RID_EXPORT
, 0 },
238 { "extern", RID_EXTERN
, 0 },
239 { "false", RID_FALSE
, 0 },
240 { "float", RID_FLOAT
, 0 },
241 { "for", RID_FOR
, 0 },
242 { "friend", RID_FRIEND
, 0 },
243 { "goto", RID_GOTO
, 0 },
245 { "inline", RID_INLINE
, 0 },
246 { "int", RID_INT
, 0 },
247 { "long", RID_LONG
, 0 },
248 { "mutable", RID_MUTABLE
, 0 },
249 { "namespace", RID_NAMESPACE
, 0 },
250 { "new", RID_NEW
, 0 },
251 { "operator", RID_OPERATOR
, 0 },
252 { "private", RID_PRIVATE
, 0 },
253 { "protected", RID_PROTECTED
, 0 },
254 { "public", RID_PUBLIC
, 0 },
255 { "register", RID_REGISTER
, 0 },
256 { "reinterpret_cast", RID_REINTCAST
, 0 },
257 { "return", RID_RETURN
, 0 },
258 { "short", RID_SHORT
, 0 },
259 { "signed", RID_SIGNED
, 0 },
260 { "sizeof", RID_SIZEOF
, 0 },
261 { "static", RID_STATIC
, 0 },
262 { "static_cast", RID_STATCAST
, 0 },
263 { "struct", RID_STRUCT
, 0 },
264 { "switch", RID_SWITCH
, 0 },
265 { "template", RID_TEMPLATE
, 0 },
266 { "this", RID_THIS
, 0 },
267 { "throw", RID_THROW
, 0 },
268 { "true", RID_TRUE
, 0 },
269 { "try", RID_TRY
, 0 },
270 { "typedef", RID_TYPEDEF
, 0 },
271 { "typename", RID_TYPENAME
, 0 },
272 { "typeid", RID_TYPEID
, 0 },
273 { "typeof", RID_TYPEOF
, D_ASM
|D_EXT
},
274 { "union", RID_UNION
, 0 },
275 { "unsigned", RID_UNSIGNED
, 0 },
276 { "using", RID_USING
, 0 },
277 { "virtual", RID_VIRTUAL
, 0 },
278 { "void", RID_VOID
, 0 },
279 { "volatile", RID_VOLATILE
, 0 },
280 { "wchar_t", RID_WCHAR
, 0 },
281 { "while", RID_WHILE
, 0 },
283 /* The remaining keywords are specific to Objective-C++. NB:
284 All of them will remain _disabled_, since they are context-
287 /* These ObjC keywords are recognized only immediately after
288 an '@'. NB: The following C++ keywords double as
289 ObjC keywords in this context: RID_CLASS, RID_PRIVATE,
290 RID_PROTECTED, RID_PUBLIC, RID_THROW, RID_TRY and RID_CATCH. */
291 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
292 { "defs", RID_AT_DEFS
, D_OBJC
},
293 { "encode", RID_AT_ENCODE
, D_OBJC
},
294 { "end", RID_AT_END
, D_OBJC
},
295 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
296 { "interface", RID_AT_INTERFACE
, D_OBJC
},
297 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
298 { "selector", RID_AT_SELECTOR
, D_OBJC
},
299 { "finally", RID_AT_FINALLY
, D_OBJC
},
300 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
301 /* These are recognized only in protocol-qualifier context. */
302 { "bycopy", RID_BYCOPY
, D_OBJC
},
303 { "byref", RID_BYREF
, D_OBJC
},
304 { "in", RID_IN
, D_OBJC
},
305 { "inout", RID_INOUT
, D_OBJC
},
306 { "oneway", RID_ONEWAY
, D_OBJC
},
307 { "out", RID_OUT
, D_OBJC
},
315 int mask
= ((flag_no_asm
? D_ASM
: 0)
317 | (flag_no_gnu_keywords
? D_EXT
: 0));
319 ridpointers
= ggc_calloc ((int) RID_MAX
, sizeof (tree
));
320 for (i
= 0; i
< ARRAY_SIZE (reswords
); i
++)
322 id
= get_identifier (reswords
[i
].word
);
323 C_RID_CODE (id
) = reswords
[i
].rid
;
324 ridpointers
[(int) reswords
[i
].rid
] = id
;
325 if (! (reswords
[i
].disable
& mask
))
326 C_IS_RESERVED_WORD (id
) = 1;
331 init_cp_pragma (void)
333 c_register_pragma (0, "vtable", handle_pragma_vtable
);
334 c_register_pragma (0, "unit", handle_pragma_unit
);
335 c_register_pragma (0, "interface", handle_pragma_interface
);
336 c_register_pragma (0, "implementation", handle_pragma_implementation
);
337 c_register_pragma ("GCC", "interface", handle_pragma_interface
);
338 c_register_pragma ("GCC", "implementation", handle_pragma_implementation
);
339 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions
);
342 /* TRUE if a code represents a statement. */
344 bool statement_code_p
[MAX_TREE_CODES
];
346 /* Initialize the C++ front end. This function is very sensitive to
347 the exact order that things are done here. It would be nice if the
348 initialization done by this routine were moved to its subroutines,
349 and the ordering dependencies clarified and reduced. */
354 static const enum tree_code stmt_codes
[] = {
355 CTOR_INITIALIZER
, TRY_BLOCK
, HANDLER
,
356 EH_SPEC_BLOCK
, USING_STMT
, TAG_DEFN
,
357 IF_STMT
, CLEANUP_STMT
, FOR_STMT
,
358 WHILE_STMT
, DO_STMT
, BREAK_STMT
,
359 CONTINUE_STMT
, SWITCH_STMT
, EXPR_STMT
362 memset (&statement_code_p
, 0, sizeof (statement_code_p
));
363 for (i
= 0; i
< ARRAY_SIZE (stmt_codes
); i
++)
364 statement_code_p
[stmt_codes
[i
]] = true;
366 /* We cannot just assign to input_filename because it has already
367 been initialized and will be used later as an N_BINCL for stabs+
369 #ifdef USE_MAPPED_LOCATION
370 push_srcloc (BUILTINS_LOCATION
);
372 push_srcloc ("<built-in>", 0);
377 init_cp_semantics ();
382 current_function_decl
= NULL
;
384 class_type_node
= ridpointers
[(int) RID_CLASS
];
386 cxx_init_decl_processing ();
388 /* The fact that G++ uses COMDAT for many entities (inline
389 functions, template instantiations, virtual tables, etc.) mean
390 that it is fundamentally unreliable to try to make decisions
391 about whether or not to output a particular entity until the end
392 of the compilation. However, the inliner requires that functions
393 be provided to the back end if they are to be inlined.
394 Therefore, we always use unit-at-a-time mode; in that mode, we
395 can provide entities to the back end and it will decide what to
396 emit based on what is actually needed. */
397 flag_unit_at_a_time
= 1;
399 if (c_common_init () == false)
413 /* Return nonzero if S is not considered part of an
414 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
417 interface_strcmp (const char* s
)
419 /* Set the interface/implementation bits for this scope. */
420 struct impl_files
*ifiles
;
423 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
425 const char *t1
= ifiles
->filename
;
428 if (*s1
!= *t1
|| *s1
== 0)
431 while (*s1
== *t1
&& *s1
!= 0)
438 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
439 if (strchr (s1
, '.') || strchr (t1
, '.'))
442 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
455 /* Parse a #pragma whose sole argument is a string constant.
456 If OPT is true, the argument is optional. */
458 parse_strconst_pragma (const char* name
, int opt
)
467 if (c_lex (&x
) != CPP_EOF
)
468 warning (0, "junk at end of #pragma %s", name
);
472 if (t
== CPP_EOF
&& opt
)
475 error ("invalid #pragma %s", name
);
480 handle_pragma_vtable (cpp_reader
* dfile ATTRIBUTE_UNUSED
)
482 parse_strconst_pragma ("vtable", 0);
483 sorry ("#pragma vtable no longer supported");
487 handle_pragma_unit (cpp_reader
* dfile ATTRIBUTE_UNUSED
)
489 /* Validate syntax, but don't do anything. */
490 parse_strconst_pragma ("unit", 0);
494 handle_pragma_interface (cpp_reader
* dfile ATTRIBUTE_UNUSED
)
496 tree fname
= parse_strconst_pragma ("interface", 1);
497 struct c_fileinfo
*finfo
;
498 const char *filename
;
500 if (fname
== (tree
)-1)
503 filename
= lbasename (input_filename
);
505 filename
= ggc_strdup (TREE_STRING_POINTER (fname
));
507 finfo
= get_fileinfo (filename
);
509 if (impl_file_chain
== 0)
511 /* If this is zero at this point, then we are
512 auto-implementing. */
513 if (main_input_filename
== 0)
514 main_input_filename
= input_filename
;
517 finfo
->interface_only
= interface_strcmp (filename
);
518 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
519 a definition in another file. */
520 if (!MULTIPLE_SYMBOL_SPACES
|| !finfo
->interface_only
)
521 finfo
->interface_unknown
= 0;
524 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
525 We used to only allow this at toplevel, but that restriction was buggy
526 in older compilers and it seems reasonable to allow it in the headers
527 themselves, too. It only needs to precede the matching #p interface.
529 We don't touch finfo->interface_only or finfo->interface_unknown;
530 the user must specify a matching #p interface for this to have
534 handle_pragma_implementation (cpp_reader
* dfile ATTRIBUTE_UNUSED
)
536 tree fname
= parse_strconst_pragma ("implementation", 1);
537 const char *filename
;
538 struct impl_files
*ifiles
= impl_file_chain
;
540 if (fname
== (tree
)-1)
545 if (main_input_filename
)
546 filename
= main_input_filename
;
548 filename
= input_filename
;
549 filename
= lbasename (filename
);
553 filename
= ggc_strdup (TREE_STRING_POINTER (fname
));
555 /* We currently cannot give this diagnostic, as we reach this point
556 only after cpplib has scanned the entire translation unit, so
557 cpp_included always returns true. A plausible fix is to compare
558 the current source-location cookie with the first source-location
559 cookie (if any) of the filename, but this requires completing the
560 --enable-mapped-location project first. See PR 17577. */
561 if (cpp_included (parse_in
, filename
))
562 warning (0, "#pragma implementation for %qs appears after "
563 "file is included", filename
);
567 for (; ifiles
; ifiles
= ifiles
->next
)
569 if (! strcmp (ifiles
->filename
, filename
))
574 ifiles
= xmalloc (sizeof (struct impl_files
));
575 ifiles
->filename
= filename
;
576 ifiles
->next
= impl_file_chain
;
577 impl_file_chain
= ifiles
;
581 /* Indicate that this file uses Java-personality exception handling. */
583 handle_pragma_java_exceptions (cpp_reader
* dfile ATTRIBUTE_UNUSED
)
586 if (c_lex (&x
) != CPP_EOF
)
587 warning (0, "junk at end of #pragma GCC java_exceptions");
589 choose_personality_routine (lang_java
);
592 /* Issue an error message indicating that the lookup of NAME (an
593 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
596 unqualified_name_lookup_error (tree name
)
598 if (IDENTIFIER_OPNAME_P (name
))
600 if (name
!= ansi_opname (ERROR_MARK
))
601 error ("%qD not defined", name
);
605 error ("%qD was not declared in this scope", name
);
606 /* Prevent repeated error messages by creating a VAR_DECL with
607 this NAME in the innermost block scope. */
608 if (current_function_decl
)
611 decl
= build_decl (VAR_DECL
, name
, error_mark_node
);
612 DECL_CONTEXT (decl
) = current_function_decl
;
613 push_local_binding (name
, decl
, 0);
614 /* Mark the variable as used so that we do not get warnings
615 about it being unused later. */
616 TREE_USED (decl
) = 1;
620 return error_mark_node
;
623 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
624 used as a function. Returns an appropriate expression for
628 unqualified_fn_lookup_error (tree name
)
630 if (processing_template_decl
)
632 /* In a template, it is invalid to write "f()" or "f(3)" if no
633 declaration of "f" is available. Historically, G++ and most
634 other compilers accepted that usage since they deferred all name
635 lookup until instantiation time rather than doing unqualified
636 name lookup at template definition time; explain to the user what
639 Note that we have the exact wording of the following message in
640 the manual (trouble.texi, node "Name lookup"), so they need to
642 pedwarn ("there are no arguments to %qD that depend on a template "
643 "parameter, so a declaration of %qD must be available",
646 if (!flag_permissive
)
651 error ("(if you use %<-fpermissive%>, G++ will accept your "
652 "code, but allowing the use of an undeclared name is "
660 return unqualified_name_lookup_error (name
);
664 build_lang_decl (enum tree_code code
, tree name
, tree type
)
668 t
= build_decl (code
, name
, type
);
669 retrofit_lang_decl (t
);
671 /* All nesting of C++ functions is lexical; there is never a "static
672 chain" in the sense of GNU C nested functions. */
673 if (code
== FUNCTION_DECL
)
674 DECL_NO_STATIC_CHAIN (t
) = 1;
679 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
680 and pushdecl (for functions generated by the backend). */
683 retrofit_lang_decl (tree t
)
685 struct lang_decl
*ld
;
688 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
689 size
= sizeof (struct lang_decl
);
691 size
= sizeof (struct lang_decl_flags
);
693 ld
= GGC_CNEWVAR (struct lang_decl
, size
);
695 ld
->decl_flags
.can_be_full
= CAN_HAVE_FULL_LANG_DECL_P (t
) ? 1 : 0;
696 ld
->decl_flags
.u1sel
= TREE_CODE (t
) == NAMESPACE_DECL
? 1 : 0;
697 ld
->decl_flags
.u2sel
= 0;
698 if (ld
->decl_flags
.can_be_full
)
699 ld
->u
.f
.u3sel
= TREE_CODE (t
) == FUNCTION_DECL
? 1 : 0;
701 DECL_LANG_SPECIFIC (t
) = ld
;
702 if (current_lang_name
== lang_name_cplusplus
703 || decl_linkage (t
) == lk_none
)
704 SET_DECL_LANGUAGE (t
, lang_cplusplus
);
705 else if (current_lang_name
== lang_name_c
)
706 SET_DECL_LANGUAGE (t
, lang_c
);
707 else if (current_lang_name
== lang_name_java
)
708 SET_DECL_LANGUAGE (t
, lang_java
);
712 #ifdef GATHER_STATISTICS
713 tree_node_counts
[(int)lang_decl
] += 1;
714 tree_node_sizes
[(int)lang_decl
] += size
;
719 cxx_dup_lang_specific_decl (tree node
)
722 struct lang_decl
*ld
;
724 if (! DECL_LANG_SPECIFIC (node
))
727 if (!CAN_HAVE_FULL_LANG_DECL_P (node
))
728 size
= sizeof (struct lang_decl_flags
);
730 size
= sizeof (struct lang_decl
);
731 ld
= GGC_NEWVAR (struct lang_decl
, size
);
732 memcpy (ld
, DECL_LANG_SPECIFIC (node
), size
);
733 DECL_LANG_SPECIFIC (node
) = ld
;
735 #ifdef GATHER_STATISTICS
736 tree_node_counts
[(int)lang_decl
] += 1;
737 tree_node_sizes
[(int)lang_decl
] += size
;
741 /* Copy DECL, including any language-specific parts. */
744 copy_decl (tree decl
)
748 copy
= copy_node (decl
);
749 cxx_dup_lang_specific_decl (copy
);
753 /* Replace the shared language-specific parts of NODE with a new copy. */
756 copy_lang_type (tree node
)
759 struct lang_type
*lt
;
761 if (! TYPE_LANG_SPECIFIC (node
))
764 if (TYPE_LANG_SPECIFIC (node
)->u
.h
.is_lang_type_class
)
765 size
= sizeof (struct lang_type
);
767 size
= sizeof (struct lang_type_ptrmem
);
768 lt
= GGC_NEWVAR (struct lang_type
, size
);
769 memcpy (lt
, TYPE_LANG_SPECIFIC (node
), size
);
770 TYPE_LANG_SPECIFIC (node
) = lt
;
772 #ifdef GATHER_STATISTICS
773 tree_node_counts
[(int)lang_type
] += 1;
774 tree_node_sizes
[(int)lang_type
] += size
;
778 /* Copy TYPE, including any language-specific parts. */
781 copy_type (tree type
)
785 copy
= copy_node (type
);
786 copy_lang_type (copy
);
791 cxx_make_type (enum tree_code code
)
793 tree t
= make_node (code
);
795 /* Create lang_type structure. */
796 if (IS_AGGR_TYPE_CODE (code
)
797 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
799 struct lang_type
*pi
= GGC_CNEW (struct lang_type
);
801 TYPE_LANG_SPECIFIC (t
) = pi
;
802 pi
->u
.c
.h
.is_lang_type_class
= 1;
804 #ifdef GATHER_STATISTICS
805 tree_node_counts
[(int)lang_type
] += 1;
806 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
810 /* Set up some flags that give proper default behavior. */
811 if (IS_AGGR_TYPE_CODE (code
))
813 struct c_fileinfo
*finfo
= get_fileinfo (lbasename (input_filename
));
814 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, finfo
->interface_unknown
);
815 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
822 make_aggr_type (enum tree_code code
)
824 tree t
= cxx_make_type (code
);
826 if (IS_AGGR_TYPE_CODE (code
))
827 SET_IS_AGGR_TYPE (t
, 1);