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
4 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
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)
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.
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/>. */
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 */
179 #define D_CXX0X 0x08 /* C++0x only */
181 CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
183 static const struct resword reswords[] =
185 { "_Complex", RID_COMPLEX, 0 },
186 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
187 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
188 { "__alignof", RID_ALIGNOF, 0 },
189 { "__alignof__", RID_ALIGNOF, 0 },
190 { "__asm", RID_ASM, 0 },
191 { "__asm__", RID_ASM, 0 },
192 { "__attribute", RID_ATTRIBUTE, 0 },
193 { "__attribute__", RID_ATTRIBUTE, 0 },
194 { "__builtin_offsetof", RID_OFFSETOF, 0 },
195 { "__builtin_va_arg", RID_VA_ARG, 0 },
196 { "__complex", RID_COMPLEX, 0 },
197 { "__complex__", RID_COMPLEX, 0 },
198 { "__const", RID_CONST, 0 },
199 { "__const__", RID_CONST, 0 },
200 { "__decltype", RID_DECLTYPE, 0 },
201 { "__extension__", RID_EXTENSION, 0 },
202 { "__func__", RID_C99_FUNCTION_NAME, 0 },
203 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, 0 },
204 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, 0 },
205 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, 0 },
206 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, 0 },
207 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, 0 },
208 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, 0 },
209 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, 0 },
210 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, 0 },
211 { "__is_abstract", RID_IS_ABSTRACT, 0 },
212 { "__is_base_of", RID_IS_BASE_OF, 0 },
213 { "__is_class", RID_IS_CLASS, 0 },
214 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, 0 },
215 { "__is_empty", RID_IS_EMPTY, 0 },
216 { "__is_enum", RID_IS_ENUM, 0 },
217 { "__is_pod", RID_IS_POD, 0 },
218 { "__is_polymorphic", RID_IS_POLYMORPHIC, 0 },
219 { "__is_union", RID_IS_UNION, 0 },
220 { "__imag", RID_IMAGPART, 0 },
221 { "__imag__", RID_IMAGPART, 0 },
222 { "__inline", RID_INLINE, 0 },
223 { "__inline__", RID_INLINE, 0 },
224 { "__label__", RID_LABEL, 0 },
225 { "__null", RID_NULL, 0 },
226 { "__real", RID_REALPART, 0 },
227 { "__real__", RID_REALPART, 0 },
228 { "__restrict", RID_RESTRICT, 0 },
229 { "__restrict__", RID_RESTRICT, 0 },
230 { "__signed", RID_SIGNED, 0 },
231 { "__signed__", RID_SIGNED, 0 },
232 { "__thread", RID_THREAD, 0 },
233 { "__typeof", RID_TYPEOF, 0 },
234 { "__typeof__", RID_TYPEOF, 0 },
235 { "__volatile", RID_VOLATILE, 0 },
236 { "__volatile__", RID_VOLATILE, 0 },
237 { "asm", RID_ASM, D_ASM },
238 { "auto", RID_AUTO, 0 },
239 { "bool", RID_BOOL, 0 },
240 { "break", RID_BREAK, 0 },
241 { "case", RID_CASE, 0 },
242 { "catch", RID_CATCH, 0 },
243 { "char", RID_CHAR, 0 },
244 { "char16_t", RID_CHAR16, D_CXX0X },
245 { "char32_t", RID_CHAR32, D_CXX0X },
246 { "class", RID_CLASS, 0 },
247 { "const", RID_CONST, 0 },
248 { "const_cast", RID_CONSTCAST, 0 },
249 { "continue", RID_CONTINUE, 0 },
250 { "decltype", RID_DECLTYPE, D_CXX0X },
251 { "default", RID_DEFAULT, 0 },
252 { "delete", RID_DELETE, 0 },
254 { "double", RID_DOUBLE, 0 },
255 { "dynamic_cast", RID_DYNCAST, 0 },
256 { "else", RID_ELSE, 0 },
257 { "enum", RID_ENUM, 0 },
258 { "explicit", RID_EXPLICIT, 0 },
259 { "export", RID_EXPORT, 0 },
260 { "extern", RID_EXTERN, 0 },
261 { "false", RID_FALSE, 0 },
262 { "float", RID_FLOAT, 0 },
263 { "for", RID_FOR, 0 },
264 { "friend", RID_FRIEND, 0 },
265 { "goto", RID_GOTO, 0 },
267 { "inline", RID_INLINE, 0 },
268 { "int", RID_INT, 0 },
269 { "long", RID_LONG, 0 },
270 { "mutable", RID_MUTABLE, 0 },
271 { "namespace", RID_NAMESPACE, 0 },
272 { "new", RID_NEW, 0 },
273 { "operator", RID_OPERATOR, 0 },
274 { "private", RID_PRIVATE, 0 },
275 { "protected", RID_PROTECTED, 0 },
276 { "public", RID_PUBLIC, 0 },
277 { "register", RID_REGISTER, 0 },
278 { "reinterpret_cast", RID_REINTCAST, 0 },
279 { "return", RID_RETURN, 0 },
280 { "short", RID_SHORT, 0 },
281 { "signed", RID_SIGNED, 0 },
282 { "sizeof", RID_SIZEOF, 0 },
283 { "static", RID_STATIC, 0 },
284 { "static_assert", RID_STATIC_ASSERT, D_CXX0X },
285 { "static_cast", RID_STATCAST, 0 },
286 { "struct", RID_STRUCT, 0 },
287 { "switch", RID_SWITCH, 0 },
288 { "template", RID_TEMPLATE, 0 },
289 { "this", RID_THIS, 0 },
290 { "throw", RID_THROW, 0 },
291 { "true", RID_TRUE, 0 },
292 { "try", RID_TRY, 0 },
293 { "typedef", RID_TYPEDEF, 0 },
294 { "typename", RID_TYPENAME, 0 },
295 { "typeid", RID_TYPEID, 0 },
296 { "typeof", RID_TYPEOF, D_ASM|D_EXT },
297 { "union", RID_UNION, 0 },
298 { "unsigned", RID_UNSIGNED, 0 },
299 { "using", RID_USING, 0 },
300 { "virtual", RID_VIRTUAL, 0 },
301 { "void", RID_VOID, 0 },
302 { "volatile", RID_VOLATILE, 0 },
303 { "wchar_t", RID_WCHAR, 0 },
304 { "while", RID_WHILE, 0 },
306 /* The remaining keywords are specific to Objective-C++. NB:
307 All of them will remain _disabled_, since they are context-
310 /* These ObjC keywords are recognized only immediately after
311 an '@'. NB: The following C++ keywords double as
312 ObjC keywords in this context: RID_CLASS, RID_PRIVATE,
313 RID_PROTECTED, RID_PUBLIC, RID_THROW, RID_TRY and RID_CATCH. */
314 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
315 { "defs", RID_AT_DEFS, D_OBJC },
316 { "encode", RID_AT_ENCODE, D_OBJC },
317 { "end", RID_AT_END, D_OBJC },
318 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
319 { "interface", RID_AT_INTERFACE, D_OBJC },
320 { "protocol", RID_AT_PROTOCOL, D_OBJC },
321 { "selector", RID_AT_SELECTOR, D_OBJC },
322 { "finally", RID_AT_FINALLY, D_OBJC },
323 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
324 /* These are recognized only in protocol-qualifier context. */
325 { "bycopy", RID_BYCOPY, D_OBJC },
326 { "byref", RID_BYREF, D_OBJC },
327 { "in", RID_IN, D_OBJC },
328 { "inout", RID_INOUT, D_OBJC },
329 { "oneway", RID_ONEWAY, D_OBJC },
330 { "out", RID_OUT, D_OBJC },
338 int mask = ((flag_no_asm ? D_ASM : 0)
340 | (flag_no_gnu_keywords ? D_EXT : 0)
341 | ((cxx_dialect == cxx0x) ? 0 : D_CXX0X));
343 ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
344 for (i = 0; i < ARRAY_SIZE (reswords); i++)
346 id = get_identifier (reswords[i].word);
347 C_RID_CODE (id) = reswords[i].rid;
348 ridpointers [(int) reswords[i].rid] = id;
349 if (! (reswords[i].disable & mask))
350 C_IS_RESERVED_WORD (id) = 1;
355 init_cp_pragma (void)
357 c_register_pragma (0, "vtable", handle_pragma_vtable);
358 c_register_pragma (0, "unit", handle_pragma_unit);
359 c_register_pragma (0, "interface", handle_pragma_interface);
360 c_register_pragma (0, "implementation", handle_pragma_implementation);
361 c_register_pragma ("GCC", "interface", handle_pragma_interface);
362 c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
363 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
366 /* TRUE if a code represents a statement. */
368 bool statement_code_p[MAX_TREE_CODES];
370 /* Initialize the C++ front end. This function is very sensitive to
371 the exact order that things are done here. It would be nice if the
372 initialization done by this routine were moved to its subroutines,
373 and the ordering dependencies clarified and reduced. */
377 location_t saved_loc;
379 static const enum tree_code stmt_codes[] = {
380 CTOR_INITIALIZER, TRY_BLOCK, HANDLER,
381 EH_SPEC_BLOCK, USING_STMT, TAG_DEFN,
382 IF_STMT, CLEANUP_STMT, FOR_STMT,
383 WHILE_STMT, DO_STMT, BREAK_STMT,
384 CONTINUE_STMT, SWITCH_STMT, EXPR_STMT
387 memset (&statement_code_p, 0, sizeof (statement_code_p));
388 for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
389 statement_code_p[stmt_codes[i]] = true;
391 saved_loc = input_location;
392 input_location = BUILTINS_LOCATION;
396 init_cp_semantics ();
401 current_function_decl = NULL;
403 class_type_node = ridpointers[(int) RID_CLASS];
405 cxx_init_decl_processing ();
407 /* The fact that G++ uses COMDAT for many entities (inline
408 functions, template instantiations, virtual tables, etc.) mean
409 that it is fundamentally unreliable to try to make decisions
410 about whether or not to output a particular entity until the end
411 of the compilation. However, the inliner requires that functions
412 be provided to the back end if they are to be inlined.
413 Therefore, we always use unit-at-a-time mode; in that mode, we
414 can provide entities to the back end and it will decide what to
415 emit based on what is actually needed. */
416 flag_unit_at_a_time = 1;
418 if (c_common_init () == false)
420 input_location = saved_loc;
428 input_location = saved_loc;
432 /* Return nonzero if S is not considered part of an
433 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
436 interface_strcmp (const char* s)
438 /* Set the interface/implementation bits for this scope. */
439 struct impl_files *ifiles;
442 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
444 const char *t1 = ifiles->filename;
447 if (*s1 != *t1 || *s1 == 0)
450 while (*s1 == *t1 && *s1 != 0)
457 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
458 if (strchr (s1, '.') || strchr (t1, '.'))
461 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
474 /* Parse a #pragma whose sole argument is a string constant.
475 If OPT is true, the argument is optional. */
477 parse_strconst_pragma (const char* name, int opt)
482 t = pragma_lex (&result);
485 if (pragma_lex (&x) != CPP_EOF)
486 warning (0, "junk at end of #pragma %s", name);
490 if (t == CPP_EOF && opt)
493 error ("invalid #pragma %s", name);
494 return error_mark_node;
498 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
500 parse_strconst_pragma ("vtable", 0);
501 sorry ("#pragma vtable no longer supported");
505 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
507 /* Validate syntax, but don't do anything. */
508 parse_strconst_pragma ("unit", 0);
512 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
514 tree fname = parse_strconst_pragma ("interface", 1);
515 struct c_fileinfo *finfo;
516 const char *filename;
518 if (fname == error_mark_node)
521 filename = lbasename (input_filename);
523 filename = TREE_STRING_POINTER (fname);
525 finfo = get_fileinfo (input_filename);
527 if (impl_file_chain == 0)
529 /* If this is zero at this point, then we are
530 auto-implementing. */
531 if (main_input_filename == 0)
532 main_input_filename = input_filename;
535 finfo->interface_only = interface_strcmp (filename);
536 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
537 a definition in another file. */
538 if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
539 finfo->interface_unknown = 0;
542 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
543 We used to only allow this at toplevel, but that restriction was buggy
544 in older compilers and it seems reasonable to allow it in the headers
545 themselves, too. It only needs to precede the matching #p interface.
547 We don't touch finfo->interface_only or finfo->interface_unknown;
548 the user must specify a matching #p interface for this to have
552 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
554 tree fname = parse_strconst_pragma ("implementation", 1);
555 const char *filename;
556 struct impl_files *ifiles = impl_file_chain;
558 if (fname == error_mark_node)
563 if (main_input_filename)
564 filename = main_input_filename;
566 filename = input_filename;
567 filename = lbasename (filename);
571 filename = TREE_STRING_POINTER (fname);
572 if (cpp_included_before (parse_in, filename, input_location))
573 warning (0, "#pragma implementation for %qs appears after "
574 "file is included", filename);
577 for (; ifiles; ifiles = ifiles->next)
579 if (! strcmp (ifiles->filename, filename))
584 ifiles = XNEW (struct impl_files);
585 ifiles->filename = xstrdup (filename);
586 ifiles->next = impl_file_chain;
587 impl_file_chain = ifiles;
591 /* Indicate that this file uses Java-personality exception handling. */
593 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED)
596 if (pragma_lex (&x) != CPP_EOF)
597 warning (0, "junk at end of #pragma GCC java_exceptions");
599 choose_personality_routine (lang_java);
602 /* Issue an error message indicating that the lookup of NAME (an
603 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
606 unqualified_name_lookup_error (tree name)
608 if (IDENTIFIER_OPNAME_P (name))
610 if (name != ansi_opname (ERROR_MARK))
611 error ("%qD not defined", name);
615 error ("%qD was not declared in this scope", name);
616 /* Prevent repeated error messages by creating a VAR_DECL with
617 this NAME in the innermost block scope. */
618 if (current_function_decl)
621 decl = build_decl (VAR_DECL, name, error_mark_node);
622 DECL_CONTEXT (decl) = current_function_decl;
623 push_local_binding (name, decl, 0);
624 /* Mark the variable as used so that we do not get warnings
625 about it being unused later. */
626 TREE_USED (decl) = 1;
630 return error_mark_node;
633 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
634 used as a function. Returns an appropriate expression for
638 unqualified_fn_lookup_error (tree name)
640 if (processing_template_decl)
642 /* In a template, it is invalid to write "f()" or "f(3)" if no
643 declaration of "f" is available. Historically, G++ and most
644 other compilers accepted that usage since they deferred all name
645 lookup until instantiation time rather than doing unqualified
646 name lookup at template definition time; explain to the user what
649 Note that we have the exact wording of the following message in
650 the manual (trouble.texi, node "Name lookup"), so they need to
652 permerror ("there are no arguments to %qD that depend on a template "
653 "parameter, so a declaration of %qD must be available",
656 if (!flag_permissive)
661 inform ("(if you use %<-fpermissive%>, G++ will accept your "
662 "code, but allowing the use of an undeclared name is "
670 return unqualified_name_lookup_error (name);
674 build_lang_decl (enum tree_code code, tree name, tree type)
678 t = build_decl (code, name, type);
679 retrofit_lang_decl (t);
681 /* All nesting of C++ functions is lexical; there is never a "static
682 chain" in the sense of GNU C nested functions. */
683 if (code == FUNCTION_DECL)
684 DECL_NO_STATIC_CHAIN (t) = 1;
689 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
690 and pushdecl (for functions generated by the back end). */
693 retrofit_lang_decl (tree t)
695 struct lang_decl *ld;
698 if (CAN_HAVE_FULL_LANG_DECL_P (t))
699 size = sizeof (struct lang_decl);
701 size = sizeof (struct lang_decl_flags);
703 ld = GGC_CNEWVAR (struct lang_decl, size);
705 ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
706 ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
707 ld->decl_flags.u2sel = 0;
708 if (ld->decl_flags.can_be_full)
709 ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
711 DECL_LANG_SPECIFIC (t) = ld;
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);
717 else if (current_lang_name == lang_name_java)
718 SET_DECL_LANGUAGE (t, lang_java);
722 #ifdef GATHER_STATISTICS
723 tree_node_counts[(int)lang_decl] += 1;
724 tree_node_sizes[(int)lang_decl] += size;
729 cxx_dup_lang_specific_decl (tree node)
732 struct lang_decl *ld;
734 if (! DECL_LANG_SPECIFIC (node))
737 if (!CAN_HAVE_FULL_LANG_DECL_P (node))
738 size = sizeof (struct lang_decl_flags);
740 size = sizeof (struct lang_decl);
741 ld = GGC_NEWVAR (struct lang_decl, size);
742 memcpy (ld, DECL_LANG_SPECIFIC (node), size);
743 DECL_LANG_SPECIFIC (node) = ld;
745 #ifdef GATHER_STATISTICS
746 tree_node_counts[(int)lang_decl] += 1;
747 tree_node_sizes[(int)lang_decl] += size;
751 /* Copy DECL, including any language-specific parts. */
754 copy_decl (tree decl)
758 copy = copy_node (decl);
759 cxx_dup_lang_specific_decl (copy);
763 /* Replace the shared language-specific parts of NODE with a new copy. */
766 copy_lang_type (tree node)
769 struct lang_type *lt;
771 if (! TYPE_LANG_SPECIFIC (node))
774 if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
775 size = sizeof (struct lang_type);
777 size = sizeof (struct lang_type_ptrmem);
778 lt = GGC_NEWVAR (struct lang_type, size);
779 memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
780 TYPE_LANG_SPECIFIC (node) = lt;
782 #ifdef GATHER_STATISTICS
783 tree_node_counts[(int)lang_type] += 1;
784 tree_node_sizes[(int)lang_type] += size;
788 /* Copy TYPE, including any language-specific parts. */
791 copy_type (tree type)
795 copy = copy_node (type);
796 copy_lang_type (copy);
801 cxx_make_type (enum tree_code code)
803 tree t = make_node (code);
805 /* Create lang_type structure. */
806 if (RECORD_OR_UNION_CODE_P (code)
807 || code == BOUND_TEMPLATE_TEMPLATE_PARM)
809 struct lang_type *pi = GGC_CNEW (struct lang_type);
811 TYPE_LANG_SPECIFIC (t) = pi;
812 pi->u.c.h.is_lang_type_class = 1;
814 #ifdef GATHER_STATISTICS
815 tree_node_counts[(int)lang_type] += 1;
816 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
820 /* Set up some flags that give proper default behavior. */
821 if (RECORD_OR_UNION_CODE_P (code))
823 struct c_fileinfo *finfo = get_fileinfo (input_filename);
824 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
825 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
832 make_class_type (enum tree_code code)
834 tree t = cxx_make_type (code);
835 SET_CLASS_TYPE_P (t, 1);
839 /* Returns true if we are currently in the main source file, or in a
840 template instantiation started from the main source file. */
843 in_main_input_context (void)
845 struct tinst_level *tl = outermost_tinst_level();
848 return strcmp (main_input_filename,
849 LOCATION_FILE (tl->locus)) == 0;
851 return strcmp (main_input_filename, input_filename) == 0;