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 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, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, 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) CONVERT_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 */
179 CONSTRAINT(ridbits_fit
, RID_LAST_MODIFIER
< sizeof(unsigned long) * CHAR_BIT
);
181 static const struct resword reswords
[] =
183 { "_Complex", RID_COMPLEX
, 0 },
184 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
185 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
186 { "__alignof", RID_ALIGNOF
, 0 },
187 { "__alignof__", RID_ALIGNOF
, 0 },
188 { "__asm", RID_ASM
, 0 },
189 { "__asm__", RID_ASM
, 0 },
190 { "__attribute", RID_ATTRIBUTE
, 0 },
191 { "__attribute__", RID_ATTRIBUTE
, 0 },
192 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
193 { "__builtin_va_arg", RID_VA_ARG
, 0 },
194 { "__complex", RID_COMPLEX
, 0 },
195 { "__complex__", RID_COMPLEX
, 0 },
196 { "__const", RID_CONST
, 0 },
197 { "__const__", RID_CONST
, 0 },
198 { "__extension__", RID_EXTENSION
, 0 },
199 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
200 { "__imag", RID_IMAGPART
, 0 },
201 { "__imag__", RID_IMAGPART
, 0 },
202 { "__inline", RID_INLINE
, 0 },
203 { "__inline__", RID_INLINE
, 0 },
204 { "__label__", RID_LABEL
, 0 },
205 { "__null", RID_NULL
, 0 },
206 { "__real", RID_REALPART
, 0 },
207 { "__real__", RID_REALPART
, 0 },
208 { "__restrict", RID_RESTRICT
, 0 },
209 { "__restrict__", RID_RESTRICT
, 0 },
210 { "__signed", RID_SIGNED
, 0 },
211 { "__signed__", RID_SIGNED
, 0 },
212 { "__thread", RID_THREAD
, 0 },
213 { "__typeof", RID_TYPEOF
, 0 },
214 { "__typeof__", RID_TYPEOF
, 0 },
215 { "__volatile", RID_VOLATILE
, 0 },
216 { "__volatile__", RID_VOLATILE
, 0 },
217 { "asm", RID_ASM
, D_ASM
},
218 { "auto", RID_AUTO
, 0 },
219 { "bool", RID_BOOL
, 0 },
220 { "break", RID_BREAK
, 0 },
221 { "case", RID_CASE
, 0 },
222 { "catch", RID_CATCH
, 0 },
223 { "char", RID_CHAR
, 0 },
224 { "class", RID_CLASS
, 0 },
225 { "const", RID_CONST
, 0 },
226 { "const_cast", RID_CONSTCAST
, 0 },
227 { "continue", RID_CONTINUE
, 0 },
228 { "default", RID_DEFAULT
, 0 },
229 { "delete", RID_DELETE
, 0 },
231 { "double", RID_DOUBLE
, 0 },
232 { "dynamic_cast", RID_DYNCAST
, 0 },
233 { "else", RID_ELSE
, 0 },
234 { "enum", RID_ENUM
, 0 },
235 { "explicit", RID_EXPLICIT
, 0 },
236 { "export", RID_EXPORT
, 0 },
237 { "extern", RID_EXTERN
, 0 },
238 { "false", RID_FALSE
, 0 },
239 { "float", RID_FLOAT
, 0 },
240 { "for", RID_FOR
, 0 },
241 { "friend", RID_FRIEND
, 0 },
242 { "goto", RID_GOTO
, 0 },
244 { "inline", RID_INLINE
, 0 },
245 { "int", RID_INT
, 0 },
246 { "long", RID_LONG
, 0 },
247 { "mutable", RID_MUTABLE
, 0 },
248 { "namespace", RID_NAMESPACE
, 0 },
249 { "new", RID_NEW
, 0 },
250 { "operator", RID_OPERATOR
, 0 },
251 { "private", RID_PRIVATE
, 0 },
252 { "protected", RID_PROTECTED
, 0 },
253 { "public", RID_PUBLIC
, 0 },
254 { "register", RID_REGISTER
, 0 },
255 { "reinterpret_cast", RID_REINTCAST
, 0 },
256 { "return", RID_RETURN
, 0 },
257 { "short", RID_SHORT
, 0 },
258 { "signed", RID_SIGNED
, 0 },
259 { "sizeof", RID_SIZEOF
, 0 },
260 { "static", RID_STATIC
, 0 },
261 { "static_cast", RID_STATCAST
, 0 },
262 { "struct", RID_STRUCT
, 0 },
263 { "switch", RID_SWITCH
, 0 },
264 { "template", RID_TEMPLATE
, 0 },
265 { "this", RID_THIS
, 0 },
266 { "throw", RID_THROW
, 0 },
267 { "true", RID_TRUE
, 0 },
268 { "try", RID_TRY
, 0 },
269 { "typedef", RID_TYPEDEF
, 0 },
270 { "typename", RID_TYPENAME
, 0 },
271 { "typeid", RID_TYPEID
, 0 },
272 { "typeof", RID_TYPEOF
, D_ASM
|D_EXT
},
273 { "union", RID_UNION
, 0 },
274 { "unsigned", RID_UNSIGNED
, 0 },
275 { "using", RID_USING
, 0 },
276 { "virtual", RID_VIRTUAL
, 0 },
277 { "void", RID_VOID
, 0 },
278 { "volatile", RID_VOLATILE
, 0 },
279 { "wchar_t", RID_WCHAR
, 0 },
280 { "while", RID_WHILE
, 0 },
289 int mask
= ((flag_no_asm
? D_ASM
: 0)
290 | (flag_no_gnu_keywords
? D_EXT
: 0));
292 ridpointers
= ggc_calloc ((int) RID_MAX
, sizeof (tree
));
293 for (i
= 0; i
< ARRAY_SIZE (reswords
); i
++)
295 id
= get_identifier (reswords
[i
].word
);
296 C_RID_CODE (id
) = reswords
[i
].rid
;
297 ridpointers
[(int) reswords
[i
].rid
] = id
;
298 if (! (reswords
[i
].disable
& mask
))
299 C_IS_RESERVED_WORD (id
) = 1;
304 init_cp_pragma (void)
306 c_register_pragma (0, "vtable", handle_pragma_vtable
);
307 c_register_pragma (0, "unit", handle_pragma_unit
);
308 c_register_pragma (0, "interface", handle_pragma_interface
);
309 c_register_pragma (0, "implementation", handle_pragma_implementation
);
310 c_register_pragma ("GCC", "interface", handle_pragma_interface
);
311 c_register_pragma ("GCC", "implementation", handle_pragma_implementation
);
312 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions
);
315 /* Initialize the C++ front end. This function is very sensitive to
316 the exact order that things are done here. It would be nice if the
317 initialization done by this routine were moved to its subroutines,
318 and the ordering dependencies clarified and reduced. */
322 static const enum tree_code stmt_codes
[] = {
327 INIT_STATEMENT_CODES (stmt_codes
);
329 /* We cannot just assign to input_filename because it has already
330 been initialized and will be used later as an N_BINCL for stabs+
332 #ifdef USE_MAPPED_LOCATION
333 push_srcloc (BUILTINS_LOCATION
);
335 push_srcloc ("<built-in>", 0);
340 init_cp_semantics ();
345 current_function_decl
= NULL
;
347 class_type_node
= ridpointers
[(int) RID_CLASS
];
349 cxx_init_decl_processing ();
351 /* Create the built-in __null node. It is important that this is
353 null_node
= make_node (INTEGER_CST
);
354 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
355 ridpointers
[RID_NULL
] = null_node
;
357 /* The fact that G++ uses COMDAT for many entities (inline
358 functions, template instantiations, virtual tables, etc.) mean
359 that it is fundamentally unreliable to try to make decisions
360 about whether or not to output a particular entity until the end
361 of the compilation. However, the inliner requires that functions
362 be provided to the back end if they are to be inlined.
363 Therefore, we always use unit-at-a-time mode; in that mode, we
364 can provide entities to the back end and it will decide what to
365 emit based on what is actually needed. */
366 flag_unit_at_a_time
= 1;
368 if (c_common_init () == false)
382 /* Return nonzero if S is not considered part of an
383 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
386 interface_strcmp (const char* s
)
388 /* Set the interface/implementation bits for this scope. */
389 struct impl_files
*ifiles
;
392 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
394 const char *t1
= ifiles
->filename
;
397 if (*s1
!= *t1
|| *s1
== 0)
400 while (*s1
== *t1
&& *s1
!= 0)
407 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
408 if (strchr (s1
, '.') || strchr (t1
, '.'))
411 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
424 /* Parse a #pragma whose sole argument is a string constant.
425 If OPT is true, the argument is optional. */
427 parse_strconst_pragma (const char* name
, int opt
)
436 if (c_lex (&x
) != CPP_EOF
)
437 warning ("junk at end of #pragma %s", name
);
441 if (t
== CPP_EOF
&& opt
)
444 error ("invalid #pragma %s", name
);
449 handle_pragma_vtable (cpp_reader
* dfile ATTRIBUTE_UNUSED
)
451 parse_strconst_pragma ("vtable", 0);
452 sorry ("#pragma vtable no longer supported");
456 handle_pragma_unit (cpp_reader
* dfile ATTRIBUTE_UNUSED
)
458 /* Validate syntax, but don't do anything. */
459 parse_strconst_pragma ("unit", 0);
463 handle_pragma_interface (cpp_reader
* dfile ATTRIBUTE_UNUSED
)
465 tree fname
= parse_strconst_pragma ("interface", 1);
466 struct c_fileinfo
*finfo
;
467 const char *main_filename
;
469 if (fname
== (tree
)-1)
472 main_filename
= lbasename (input_filename
);
474 main_filename
= TREE_STRING_POINTER (fname
);
476 finfo
= get_fileinfo (input_filename
);
478 if (impl_file_chain
== 0)
480 /* If this is zero at this point, then we are
481 auto-implementing. */
482 if (main_input_filename
== 0)
483 main_input_filename
= input_filename
;
486 finfo
->interface_only
= interface_strcmp (main_filename
);
487 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
488 a definition in another file. */
489 if (!MULTIPLE_SYMBOL_SPACES
|| !finfo
->interface_only
)
490 finfo
->interface_unknown
= 0;
493 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
494 We used to only allow this at toplevel, but that restriction was buggy
495 in older compilers and it seems reasonable to allow it in the headers
496 themselves, too. It only needs to precede the matching #p interface.
498 We don't touch finfo->interface_only or finfo->interface_unknown;
499 the user must specify a matching #p interface for this to have
503 handle_pragma_implementation (cpp_reader
* dfile ATTRIBUTE_UNUSED
)
505 tree fname
= parse_strconst_pragma ("implementation", 1);
506 const char *main_filename
;
507 struct impl_files
*ifiles
= impl_file_chain
;
509 if (fname
== (tree
)-1)
514 if (main_input_filename
)
515 main_filename
= main_input_filename
;
517 main_filename
= input_filename
;
518 main_filename
= lbasename (main_filename
);
522 main_filename
= TREE_STRING_POINTER (fname
);
523 if (cpp_included (parse_in
, main_filename
))
524 warning ("#pragma implementation for %s appears after file is included",
528 for (; ifiles
; ifiles
= ifiles
->next
)
530 if (! strcmp (ifiles
->filename
, main_filename
))
535 ifiles
= xmalloc (sizeof (struct impl_files
));
536 ifiles
->filename
= main_filename
;
537 ifiles
->next
= impl_file_chain
;
538 impl_file_chain
= ifiles
;
542 /* Indicate that this file uses Java-personality exception handling. */
544 handle_pragma_java_exceptions (cpp_reader
* dfile ATTRIBUTE_UNUSED
)
547 if (c_lex (&x
) != CPP_EOF
)
548 warning ("junk at end of #pragma GCC java_exceptions");
550 choose_personality_routine (lang_java
);
553 /* Issue an error message indicating that the lookup of NAME (an
554 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
557 unqualified_name_lookup_error (tree name
)
559 if (IDENTIFIER_OPNAME_P (name
))
561 if (name
!= ansi_opname (ERROR_MARK
))
562 error ("`%D' not defined", name
);
566 error ("`%D' was not declared in this scope", name
);
567 /* Prevent repeated error messages by creating a VAR_DECL with
568 this NAME in the innermost block scope. */
569 if (current_function_decl
)
572 decl
= build_decl (VAR_DECL
, name
, error_mark_node
);
573 DECL_CONTEXT (decl
) = current_function_decl
;
574 push_local_binding (name
, decl
, 0);
575 /* Mark the variable as used so that we do not get warnings
576 about it being unused later. */
577 TREE_USED (decl
) = 1;
581 return error_mark_node
;
584 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
585 used as a function. Returns an appropriate expression for
589 unqualified_fn_lookup_error (tree name
)
591 if (processing_template_decl
)
593 /* In a template, it is invalid to write "f()" or "f(3)" if no
594 declaration of "f" is available. Historically, G++ and most
595 other compilers accepted that usage since they deferred all name
596 lookup until instantiation time rather than doing unqualified
597 name lookup at template definition time; explain to the user what
600 Note that we have the exact wording of the following message in
601 the manual (trouble.texi, node "Name lookup"), so they need to
603 pedwarn ("there are no arguments to `%D' that depend on a template "
604 "parameter, so a declaration of `%D' must be available",
607 if (!flag_permissive
)
612 error ("(if you use `-fpermissive', G++ will accept your code, "
613 "but allowing the use of an undeclared name is "
621 return unqualified_name_lookup_error (name
);
625 build_lang_decl (enum tree_code code
, tree name
, tree type
)
629 t
= build_decl (code
, name
, type
);
630 retrofit_lang_decl (t
);
632 /* All nesting of C++ functions is lexical; there is never a "static
633 chain" in the sense of GNU C nested functions. */
634 if (code
== FUNCTION_DECL
)
635 DECL_NO_STATIC_CHAIN (t
) = 1;
640 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
641 and pushdecl (for functions generated by the backend). */
644 retrofit_lang_decl (tree t
)
646 struct lang_decl
*ld
;
649 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
650 size
= sizeof (struct lang_decl
);
652 size
= sizeof (struct lang_decl_flags
);
654 ld
= GGC_CNEWVAR (struct lang_decl
, size
);
656 ld
->decl_flags
.can_be_full
= CAN_HAVE_FULL_LANG_DECL_P (t
) ? 1 : 0;
657 ld
->decl_flags
.u1sel
= TREE_CODE (t
) == NAMESPACE_DECL
? 1 : 0;
658 ld
->decl_flags
.u2sel
= 0;
659 if (ld
->decl_flags
.can_be_full
)
660 ld
->u
.f
.u3sel
= TREE_CODE (t
) == FUNCTION_DECL
? 1 : 0;
662 DECL_LANG_SPECIFIC (t
) = ld
;
663 if (current_lang_name
== lang_name_cplusplus
664 || decl_linkage (t
) == lk_none
)
665 SET_DECL_LANGUAGE (t
, lang_cplusplus
);
666 else if (current_lang_name
== lang_name_c
)
667 SET_DECL_LANGUAGE (t
, lang_c
);
668 else if (current_lang_name
== lang_name_java
)
669 SET_DECL_LANGUAGE (t
, lang_java
);
673 #ifdef GATHER_STATISTICS
674 tree_node_counts
[(int)lang_decl
] += 1;
675 tree_node_sizes
[(int)lang_decl
] += size
;
680 cxx_dup_lang_specific_decl (tree node
)
683 struct lang_decl
*ld
;
685 if (! DECL_LANG_SPECIFIC (node
))
688 if (!CAN_HAVE_FULL_LANG_DECL_P (node
))
689 size
= sizeof (struct lang_decl_flags
);
691 size
= sizeof (struct lang_decl
);
692 ld
= GGC_NEWVAR (struct lang_decl
, size
);
693 memcpy (ld
, DECL_LANG_SPECIFIC (node
), size
);
694 DECL_LANG_SPECIFIC (node
) = ld
;
696 #ifdef GATHER_STATISTICS
697 tree_node_counts
[(int)lang_decl
] += 1;
698 tree_node_sizes
[(int)lang_decl
] += size
;
702 /* Copy DECL, including any language-specific parts. */
705 copy_decl (tree decl
)
709 copy
= copy_node (decl
);
710 cxx_dup_lang_specific_decl (copy
);
714 /* Replace the shared language-specific parts of NODE with a new copy. */
717 copy_lang_type (tree node
)
720 struct lang_type
*lt
;
722 if (! TYPE_LANG_SPECIFIC (node
))
725 if (TYPE_LANG_SPECIFIC (node
)->u
.h
.is_lang_type_class
)
726 size
= sizeof (struct lang_type
);
728 size
= sizeof (struct lang_type_ptrmem
);
729 lt
= GGC_NEWVAR (struct lang_type
, size
);
730 memcpy (lt
, TYPE_LANG_SPECIFIC (node
), size
);
731 TYPE_LANG_SPECIFIC (node
) = lt
;
733 #ifdef GATHER_STATISTICS
734 tree_node_counts
[(int)lang_type
] += 1;
735 tree_node_sizes
[(int)lang_type
] += size
;
739 /* Copy TYPE, including any language-specific parts. */
742 copy_type (tree type
)
746 copy
= copy_node (type
);
747 copy_lang_type (copy
);
752 cxx_make_type (enum tree_code code
)
754 tree t
= make_node (code
);
756 /* Create lang_type structure. */
757 if (IS_AGGR_TYPE_CODE (code
)
758 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
760 struct lang_type
*pi
= GGC_CNEW (struct lang_type
);
762 TYPE_LANG_SPECIFIC (t
) = pi
;
763 pi
->u
.c
.h
.is_lang_type_class
= 1;
765 #ifdef GATHER_STATISTICS
766 tree_node_counts
[(int)lang_type
] += 1;
767 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
771 /* Set up some flags that give proper default behavior. */
772 if (IS_AGGR_TYPE_CODE (code
))
774 struct c_fileinfo
*finfo
= get_fileinfo (input_filename
);
775 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, finfo
->interface_unknown
);
776 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
779 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But,
780 TYPE_ALIAS_SET is initialized to -1 by default, so we must
782 TYPE_ALIAS_SET (t
) = 0;
788 make_aggr_type (enum tree_code code
)
790 tree t
= cxx_make_type (code
);
792 if (IS_AGGR_TYPE_CODE (code
))
793 SET_IS_AGGR_TYPE (t
, 1);
798 /* Return the type-qualifier corresponding to the identifier given by
802 cp_type_qual_from_rid (tree rid
)
804 if (rid
== ridpointers
[(int) RID_CONST
])
805 return TYPE_QUAL_CONST
;
806 else if (rid
== ridpointers
[(int) RID_VOLATILE
])
807 return TYPE_QUAL_VOLATILE
;
808 else if (rid
== ridpointers
[(int) RID_RESTRICT
])
809 return TYPE_QUAL_RESTRICT
;
812 return TYPE_UNQUALIFIED
;