1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92-97, 1998 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC 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 2, or (at your option)
12 GNU CC 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 GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Process declarations and symbol lookup for C front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
27 /* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
45 #define obstack_chunk_alloc xmalloc
46 #define obstack_chunk_free free
48 extern tree builtin_return_address_fndecl
;
50 extern struct obstack permanent_obstack
;
51 extern struct obstack
* saveable_obstack
;
53 extern int current_class_depth
;
55 extern tree static_ctors
, static_dtors
;
57 extern int static_labelno
;
59 extern tree current_namespace
;
60 extern tree global_namespace
;
62 extern void (*print_error_function
) PROTO((char *));
64 /* Stack of places to restore the search obstack back to. */
66 /* Obstack used for remembering local class declarations (like
67 enums and static (const) members. */
69 struct obstack decl_obstack
;
70 static struct stack_level
*decl_stack
;
72 #ifndef CHAR_TYPE_SIZE
73 #define CHAR_TYPE_SIZE BITS_PER_UNIT
76 #ifndef SHORT_TYPE_SIZE
77 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
81 #define INT_TYPE_SIZE BITS_PER_WORD
84 #ifndef LONG_TYPE_SIZE
85 #define LONG_TYPE_SIZE BITS_PER_WORD
88 #ifndef LONG_LONG_TYPE_SIZE
89 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
92 #ifndef WCHAR_UNSIGNED
93 #define WCHAR_UNSIGNED 0
96 #ifndef FLOAT_TYPE_SIZE
97 #define FLOAT_TYPE_SIZE BITS_PER_WORD
100 #ifndef DOUBLE_TYPE_SIZE
101 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
104 #ifndef LONG_DOUBLE_TYPE_SIZE
105 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
108 #ifndef BOOL_TYPE_SIZE
109 #ifdef SLOW_BYTE_ACCESS
110 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
112 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
116 /* We let tm.h override the types used here, to handle trivial differences
117 such as the choice of unsigned int or long unsigned int for size_t.
118 When machines start needing nontrivial differences in the size type,
119 it would be best to do something here to figure out automatically
120 from other information what type to use. */
123 #define SIZE_TYPE "long unsigned int"
127 #define PTRDIFF_TYPE "long int"
131 #define WCHAR_TYPE "int"
134 static tree grokparms
PROTO((tree
, int));
135 static tree lookup_nested_type
PROTO((tree
, tree
));
136 static char *redeclaration_error_message
PROTO((tree
, tree
));
137 static tree push_overloaded_decl
PROTO((tree
, int));
139 static struct stack_level
*push_decl_level
PROTO((struct stack_level
*,
141 static void push_binding_level
PROTO((struct binding_level
*, int,
143 static void pop_binding_level
PROTO((void));
144 static void suspend_binding_level
PROTO((void));
145 static void resume_binding_level
PROTO((struct binding_level
*));
146 static struct binding_level
*make_binding_level
PROTO((void));
147 static int namespace_bindings_p
PROTO((void));
148 static void declare_namespace_level
PROTO((void));
149 static void signal_catch
PROTO((int)) ATTRIBUTE_NORETURN
;
150 static void storedecls
PROTO((tree
));
151 static void storetags
PROTO((tree
));
152 static void require_complete_types_for_parms
PROTO((tree
));
153 static void push_overloaded_decl_1
PROTO((tree
));
154 static int ambi_op_p
PROTO((tree
));
155 static int unary_op_p
PROTO((tree
));
156 static tree store_bindings
PROTO((tree
, tree
));
157 static tree lookup_tag_reverse
PROTO((tree
, tree
));
158 static tree obscure_complex_init
PROTO((tree
, tree
));
159 static tree maybe_build_cleanup_1
PROTO((tree
, tree
));
160 static tree lookup_name_real
PROTO((tree
, int, int, int));
161 static void warn_extern_redeclared_static
PROTO((tree
, tree
));
162 static void grok_reference_init
PROTO((tree
, tree
, tree
));
163 static tree grokfndecl
PROTO((tree
, tree
, tree
, tree
, int,
164 enum overload_flags
, tree
,
165 tree
, tree
, int, int, int, int, int, int, tree
));
166 static tree grokvardecl
PROTO((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
167 static tree lookup_tag
PROTO((enum tree_code
, tree
,
168 struct binding_level
*, int));
169 static void set_identifier_type_value_with_scope
170 PROTO((tree
, tree
, struct binding_level
*));
171 static void set_identifier_local_value_with_scope
172 PROTO((tree
, tree
, struct binding_level
*));
173 static void record_builtin_type
PROTO((enum rid
, char *, tree
));
174 static void record_unknown_type
PROTO((tree
, char *));
175 static int member_function_or_else
PROTO((tree
, tree
, char *));
176 static void bad_specifiers
PROTO((tree
, char *, int, int, int, int,
178 static void lang_print_error_function
PROTO((char *));
179 static tree maybe_process_template_type_declaration
PROTO((tree
, int, struct binding_level
*));
180 static void check_for_uninitialized_const_var
PROTO((tree
));
182 #if defined (DEBUG_CP_BINDING_LEVELS)
183 static void indent
PROTO((void));
186 /* A node which has tree code ERROR_MARK, and whose type is itself.
187 All erroneous expressions are replaced with this node. All functions
188 that accept nodes as arguments should avoid generating error messages
189 if this node is one of the arguments, since it is undesirable to get
190 multiple error messages from one error in the input. */
192 tree error_mark_node
;
194 /* Erroneous argument lists can use this *IFF* they do not modify it. */
195 tree error_mark_list
;
197 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
199 tree short_integer_type_node
;
200 tree integer_type_node
;
201 tree long_integer_type_node
;
202 tree long_long_integer_type_node
;
204 tree short_unsigned_type_node
;
205 tree unsigned_type_node
;
206 tree long_unsigned_type_node
;
207 tree long_long_unsigned_type_node
;
209 tree ptrdiff_type_node
;
211 tree unsigned_char_type_node
;
212 tree signed_char_type_node
;
214 tree wchar_type_node
;
215 tree signed_wchar_type_node
;
216 tree unsigned_wchar_type_node
;
218 tree wchar_decl_node
;
220 tree float_type_node
;
221 tree double_type_node
;
222 tree long_double_type_node
;
224 tree complex_integer_type_node
;
225 tree complex_float_type_node
;
226 tree complex_double_type_node
;
227 tree complex_long_double_type_node
;
229 tree intQI_type_node
;
230 tree intHI_type_node
;
231 tree intSI_type_node
;
232 tree intDI_type_node
;
233 #if HOST_BITS_PER_WIDE_INT >= 64
234 tree intTI_type_node
;
237 tree unsigned_intQI_type_node
;
238 tree unsigned_intHI_type_node
;
239 tree unsigned_intSI_type_node
;
240 tree unsigned_intDI_type_node
;
241 #if HOST_BITS_PER_WIDE_INT >= 64
242 tree unsigned_intTI_type_node
;
245 tree java_byte_type_node
;
246 tree java_short_type_node
;
247 tree java_int_type_node
;
248 tree java_long_type_node
;
249 tree java_float_type_node
;
250 tree java_double_type_node
;
251 tree java_char_type_node
;
252 tree java_boolean_type_node
;
254 /* A VOID_TYPE node, and the same, packaged in a TREE_LIST. */
256 tree void_type_node
, void_list_node
;
259 /* Nodes for types `void *' and `const void *'. */
262 tree const_ptr_type_node
;
264 /* Nodes for types `char *' and `const char *'. */
266 tree string_type_node
, const_string_type_node
;
268 /* Type `char[256]' or something like it.
269 Used when an array of char is needed and the size is irrelevant. */
271 tree char_array_type_node
;
273 /* Type `int[256]' or something like it.
274 Used when an array of int needed and the size is irrelevant. */
276 tree int_array_type_node
;
278 /* Type `wchar_t[256]' or something like it.
279 Used when a wide string literal is created. */
281 tree wchar_array_type_node
;
283 /* The bool data type, and constants */
284 tree boolean_type_node
, boolean_true_node
, boolean_false_node
;
286 /* Type `int ()' -- used for implicit declaration of functions. */
288 tree default_function_type
;
290 /* Function types `double (double)' and `double (double, double)', etc. */
292 static tree double_ftype_double
, double_ftype_double_double
;
293 static tree int_ftype_int
, long_ftype_long
;
294 static tree float_ftype_float
;
295 static tree ldouble_ftype_ldouble
;
297 /* Function type `int (const void *, const void *, size_t)' */
298 static tree int_ftype_cptr_cptr_sizet
;
301 tree vtable_entry_type
;
302 tree delta_type_node
;
304 /* Old rtti stuff. */
305 tree __baselist_desc_type_node
;
306 tree __i_desc_type_node
, __m_desc_type_node
;
307 tree __t_desc_array_type
, __i_desc_array_type
, __m_desc_array_type
;
309 tree __t_desc_type_node
;
311 tree __tp_desc_type_node
;
313 tree __access_mode_type_node
;
314 tree __bltn_desc_type_node
, __user_desc_type_node
, __class_desc_type_node
;
315 tree __ptr_desc_type_node
, __attr_desc_type_node
, __func_desc_type_node
;
316 tree __ptmf_desc_type_node
, __ptmd_desc_type_node
;
318 /* Not needed yet? May be needed one day? */
319 tree __bltn_desc_array_type
, __user_desc_array_type
, __class_desc_array_type
;
320 tree __ptr_desc_array_type
, __attr_dec_array_type
, __func_desc_array_type
;
321 tree __ptmf_desc_array_type
, __ptmd_desc_array_type
;
324 /* Indicates that there is a type value in some namespace, although
325 that is not necessarily in scope at the moment. */
327 static tree global_type_node
;
329 tree class_star_type_node
;
330 tree class_type_node
, record_type_node
, union_type_node
, enum_type_node
;
331 tree unknown_type_node
;
332 tree opaque_type_node
, signature_type_node
;
333 tree sigtable_entry_type
;
335 /* Array type `vtable_entry_type[]' */
337 tree vtbl_ptr_type_node
;
343 /* Expect only namespace names now. */
344 static int only_namespace_names
;
346 /* In a destructor, the point at which all derived class destroying
347 has been done, just before any base class destroying will be done. */
351 /* In a destructor, the last insn emitted after the start of the
352 function and the parms. */
354 static rtx last_dtor_insn
;
356 /* In a constructor, the last insn emitted after the start of the
357 function and the parms, the exception specification and any
358 function-try-block. The constructor initializers are emitted after
361 static rtx last_parm_cleanup_insn
;
363 /* In a constructor, the point at which we are ready to return
364 the pointer to the initialized object. */
368 /* A FUNCTION_DECL which can call `abort'. Not necessarily the
369 one that the user will declare, but sufficient to be called
370 by routines that want to abort the program. */
374 extern rtx cleanup_label
, return_label
;
376 /* If original DECL_RESULT of current function was a register,
377 but due to being an addressable named return value, would up
378 on the stack, this variable holds the named return value's
379 original location. */
380 static rtx original_result_rtx
;
382 /* Sequence of insns which represents base initialization. */
385 /* C++: Keep these around to reduce calls to `get_identifier'.
386 Identifiers for `this' in member functions and the auto-delete
387 parameter for destructors. */
388 tree this_identifier
, in_charge_identifier
;
389 tree ctor_identifier
, dtor_identifier
;
390 /* Used in pointer to member functions, in vtables, and in sigtables. */
391 tree pfn_identifier
, index_identifier
, delta_identifier
, delta2_identifier
;
392 tree pfn_or_delta2_identifier
, tag_identifier
;
393 tree vt_off_identifier
;
395 struct named_label_list
397 struct binding_level
*binding_level
;
400 char *filename_o_goto
;
402 struct named_label_list
*next
;
405 /* A list (chain of TREE_LIST nodes) of named label uses.
406 The TREE_PURPOSE field is the list of variables defined
407 in the label's scope defined at the point of use.
408 The TREE_VALUE field is the LABEL_DECL used.
409 The TREE_TYPE field holds `current_binding_level' at the
410 point of the label's use.
412 BWAHAHAAHAHahhahahahaah. No, no, no, said the little chicken.
414 Look at the pretty struct named_label_list. See the pretty struct
415 with the pretty named fields that describe what they do. See the
416 pretty lack of gratuitous casts. Notice the code got a lot cleaner.
418 Used only for jumps to as-yet undefined labels, since
419 jumps to defined labels can have their validity checked
422 static struct named_label_list
*named_label_uses
= NULL
;
424 /* A list of objects which have constructors or destructors
425 which reside in the global scope. The decl is stored in
426 the TREE_VALUE slot and the initializer is stored
427 in the TREE_PURPOSE slot. */
428 tree static_aggregates
;
432 /* Two expressions that are constants with value zero.
433 The first is of type `int', the second of type `void *'. */
435 tree integer_zero_node
;
436 tree null_pointer_node
;
438 /* The value for __null (NULL), namely, a zero of an integer type with
439 the same number of bits as a pointer. */
442 /* A node for the integer constants 1, 2, and 3. */
444 tree integer_one_node
, integer_two_node
, integer_three_node
;
446 /* While defining an enum type, this is 1 plus the last enumerator
449 static tree enum_next_value
;
451 /* Nonzero means that there was overflow computing enum_next_value. */
453 static int enum_overflow
;
455 /* Parsing a function declarator leaves a list of parameter names
456 or a chain or parameter decls here. */
458 tree last_function_parms
;
460 /* Parsing a function declarator leaves here a chain of structure
461 and enum types declared in the parmlist. */
463 static tree last_function_parm_tags
;
465 /* After parsing the declarator that starts a function definition,
466 `start_function' puts here the list of parameter names or chain of decls.
467 `store_parm_decls' finds it here. */
469 static tree current_function_parms
;
471 /* Similar, for last_function_parm_tags. */
472 static tree current_function_parm_tags
;
474 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
475 that have names. Here so we can clear out their names' definitions
476 at the end of the function. */
478 static tree named_labels
;
480 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
482 static tree shadowed_labels
;
484 /* The FUNCTION_DECL for the function currently being compiled,
485 or 0 if between functions. */
486 tree current_function_decl
;
488 /* Set to 0 at beginning of a function definition, set to 1 if
489 a return statement that specifies a return value is seen. */
491 int current_function_returns_value
;
493 /* Set to 0 at beginning of a function definition, set to 1 if
494 a return statement with no argument is seen. */
496 int current_function_returns_null
;
498 /* Set to 0 at beginning of a function definition, and whenever
499 a label (case or named) is defined. Set to value of expression
500 returned from function when that value can be transformed into
501 a named return value. */
503 tree current_function_return_value
;
505 /* Set to nonzero by `grokdeclarator' for a function
506 whose return type is defaulted, if warnings for this are desired. */
508 static int warn_about_return_type
;
510 /* Nonzero means give `double' the same size as `float'. */
512 extern int flag_short_double
;
514 /* Nonzero means don't recognize any builtin functions. */
516 extern int flag_no_builtin
;
518 /* Nonzero means don't recognize the non-ANSI builtin functions.
521 extern int flag_no_nonansi_builtin
;
523 /* Nonzero means enable obscure ANSI features and disable GNU extensions
524 that might cause ANSI-compliant code to be miscompiled. */
526 extern int flag_ansi
;
528 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
530 extern int flag_huge_objects
;
532 /* Nonzero if we want to conserve space in the .o files. We do this
533 by putting uninitialized data and runtime initialized data into
534 .common instead of .data at the expense of not flagging multiple
536 extern int flag_conserve_space
;
538 /* Pointers to the base and current top of the language name stack. */
540 extern tree
*current_lang_base
, *current_lang_stack
;
542 /* C and C++ flags are in decl2.c. */
544 /* Set to 0 at beginning of a constructor, set to 1
545 if that function does an allocation before referencing its
546 instance variable. */
547 static int current_function_assigns_this
;
548 int current_function_just_assigned_this
;
550 /* Set to 0 at beginning of a function. Set non-zero when
551 store_parm_decls is called. Don't call store_parm_decls
552 if this flag is non-zero! */
553 int current_function_parms_stored
;
555 /* Flag used when debugging spew.c */
557 extern int spew_debug
;
559 /* This is a copy of the class_shadowed list of the previous class binding
560 contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
561 when entering another class scope (i.e. a cache miss). */
562 extern tree previous_class_values
;
564 /* A expression of value 0 with the same precision as a sizetype
566 tree signed_size_zero_node
;
568 /* The name of the anonymous namespace, throughout this translation
570 tree anonymous_namespace_name
;
573 /* Allocate a level of searching. */
577 push_decl_level (stack
, obstack
)
578 struct stack_level
*stack
;
579 struct obstack
*obstack
;
581 struct stack_level tem
;
584 return push_stack_level (obstack
, (char *)&tem
, sizeof (tem
));
587 /* For each binding contour we allocate a binding_level structure
588 which records the names defined in that contour.
591 1) one for each function definition,
592 where internal declarations of the parameters appear.
593 2) one for each compound statement,
594 to record its declarations.
596 The current meaning of a name can be found by searching the levels
597 from the current one out to the global one.
599 Off to the side, may be the class_binding_level. This exists only
600 to catch class-local declarations. It is otherwise nonexistent.
602 Also there may be binding levels that catch cleanups that must be
603 run when exceptions occur. */
605 /* Note that the information in the `names' component of the global contour
606 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
610 /* A chain of _DECL nodes for all variables, constants, functions,
611 and typedef types. These are in the reverse of the order
615 /* A list of structure, union and enum definitions, for looking up
617 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
618 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
619 or ENUMERAL_TYPE node.
621 C++: the TREE_VALUE nodes can be simple types for
622 component_bindings. */
625 /* A list of USING_DECL nodes. */
628 /* A list of used namespaces. PURPOSE is the namespace,
629 VALUE the common ancestor with this binding_level's namespace. */
630 tree using_directives
;
632 /* For each level, a list of shadowed outer-level local definitions
633 to be restored when this level is popped.
634 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
635 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
638 /* Same, for IDENTIFIER_CLASS_VALUE. */
641 /* Same, for IDENTIFIER_TYPE_VALUE. */
644 /* For each level (except not the global one),
645 a chain of BLOCK nodes for all the levels
646 that were entered and exited one level down. */
649 /* The BLOCK node for this level, if one has been preallocated.
650 If 0, the BLOCK is allocated (if needed) when the level is popped. */
653 /* The binding level which this one is contained in (inherits from). */
654 struct binding_level
*level_chain
;
656 /* List of decls in `names' that have incomplete
657 structure or union types. */
660 /* List of VAR_DECLS saved from a previous for statement.
661 These would be dead in ANSI-conforming code, but might
662 be referenced in ARM-era code. */
663 tree dead_vars_from_for
;
665 /* 1 for the level that holds the parameters of a function.
666 2 for the level that holds a class declaration.
667 3 for levels that hold parameter declarations. */
668 unsigned parm_flag
: 4;
670 /* 1 means make a BLOCK for this level regardless of all else.
671 2 for temporary binding contours created by the compiler. */
674 /* Nonzero if this level "doesn't exist" for tags. */
675 unsigned tag_transparent
: 1;
677 /* Nonzero if this level can safely have additional
678 cleanup-needing variables added to it. */
679 unsigned more_cleanups_ok
: 1;
680 unsigned have_cleanups
: 1;
682 /* Nonzero if this level is for storing the decls for template
683 parameters and generic decls; these decls will be discarded and
684 replaced with a TEMPLATE_DECL. */
685 unsigned pseudo_global
: 1;
687 /* This is set for a namespace binding level. */
688 unsigned namespace_p
: 1;
690 /* True if this level is that of a for-statement where we need to
691 worry about ambiguous (ARM or ANSI) scope rules. */
692 unsigned is_for_scope
: 1;
694 /* Two bits left for this word. */
696 #if defined(DEBUG_CP_BINDING_LEVELS)
697 /* Binding depth at which this level began. */
698 unsigned binding_depth
;
699 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
702 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
704 /* The (non-class) binding level currently in effect. */
706 static struct binding_level
*current_binding_level
;
708 /* The binding level of the current class, if any. */
710 static struct binding_level
*class_binding_level
;
712 /* The current (class or non-class) binding level currently in effect. */
714 #define inner_binding_level \
715 (class_binding_level ? class_binding_level : current_binding_level)
717 /* A chain of binding_level structures awaiting reuse. */
719 static struct binding_level
*free_binding_level
;
721 /* The outermost binding level, for names of file scope.
722 This is created when the compiler is started and exists
723 through the entire run. */
725 static struct binding_level
*global_binding_level
;
727 /* Binding level structures are initialized by copying this one. */
729 static struct binding_level clear_binding_level
;
731 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
733 static int keep_next_level_flag
;
735 #if defined(DEBUG_CP_BINDING_LEVELS)
736 static int binding_depth
= 0;
737 static int is_class_level
= 0;
744 for (i
= 0; i
< binding_depth
*2; i
++)
747 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
749 static tree pushdecl_with_scope
PROTO((tree
, struct binding_level
*));
752 push_binding_level (newlevel
, tag_transparent
, keep
)
753 struct binding_level
*newlevel
;
754 int tag_transparent
, keep
;
756 /* Add this level to the front of the chain (stack) of levels that
758 *newlevel
= clear_binding_level
;
759 if (class_binding_level
)
761 newlevel
->level_chain
= class_binding_level
;
762 class_binding_level
= (struct binding_level
*)0;
766 newlevel
->level_chain
= current_binding_level
;
768 current_binding_level
= newlevel
;
769 newlevel
->tag_transparent
= tag_transparent
;
770 newlevel
->more_cleanups_ok
= 1;
771 newlevel
->keep
= keep
;
772 #if defined(DEBUG_CP_BINDING_LEVELS)
773 newlevel
->binding_depth
= binding_depth
;
775 fprintf (stderr
, "push %s level 0x%08x line %d\n",
776 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
779 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
785 if (class_binding_level
)
786 current_binding_level
= class_binding_level
;
788 if (global_binding_level
)
790 /* Cannot pop a level, if there are none left to pop. */
791 if (current_binding_level
== global_binding_level
)
792 my_friendly_abort (123);
794 /* Pop the current level, and free the structure for reuse. */
795 #if defined(DEBUG_CP_BINDING_LEVELS)
798 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
799 (is_class_level
) ? "class" : "block",
800 current_binding_level
, lineno
);
801 if (is_class_level
!= (current_binding_level
== class_binding_level
))
804 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
807 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
809 register struct binding_level
*level
= current_binding_level
;
810 current_binding_level
= current_binding_level
->level_chain
;
811 level
->level_chain
= free_binding_level
;
812 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
813 if (level
->binding_depth
!= binding_depth
)
815 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
816 free_binding_level
= level
;
818 class_binding_level
= current_binding_level
;
819 if (class_binding_level
->parm_flag
!= 2)
820 class_binding_level
= 0;
821 while (current_binding_level
->parm_flag
== 2)
822 current_binding_level
= current_binding_level
->level_chain
;
827 suspend_binding_level ()
829 if (class_binding_level
)
830 current_binding_level
= class_binding_level
;
832 if (global_binding_level
)
834 /* Cannot suspend a level, if there are none left to suspend. */
835 if (current_binding_level
== global_binding_level
)
836 my_friendly_abort (123);
838 /* Suspend the current level. */
839 #if defined(DEBUG_CP_BINDING_LEVELS)
842 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
843 (is_class_level
) ? "class" : "block",
844 current_binding_level
, lineno
);
845 if (is_class_level
!= (current_binding_level
== class_binding_level
))
848 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
851 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
853 current_binding_level
= current_binding_level
->level_chain
;
854 class_binding_level
= current_binding_level
;
855 if (class_binding_level
->parm_flag
!= 2)
856 class_binding_level
= 0;
857 while (current_binding_level
->parm_flag
== 2)
858 current_binding_level
= current_binding_level
->level_chain
;
863 resume_binding_level (b
)
864 struct binding_level
*b
;
866 /* Resuming binding levels is meant only for namespaces,
867 and those cannot nest into classes. */
868 my_friendly_assert(!class_binding_level
, 386);
869 /* Also, resuming a non-directly nested namespace is a no-no. */
870 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
871 current_binding_level
= b
;
872 #if defined(DEBUG_CP_BINDING_LEVELS)
873 b
->binding_depth
= binding_depth
;
875 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
876 (is_class_level
) ? "class" : "block", b
, lineno
);
879 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
882 /* Create a new `struct binding_level'. */
885 struct binding_level
*
886 make_binding_level ()
889 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
892 /* Nonzero if we are currently in the global binding level. */
897 return current_binding_level
== global_binding_level
;
900 /* Nonzero if we are currently in a toplevel binding level. This
901 means either the global binding level or a namespace in a toplevel
903 Since there are no non-toplevel namespace levels, this really
904 means any namespace or pseudo-global level. */
907 toplevel_bindings_p ()
909 return current_binding_level
->namespace_p
910 || current_binding_level
->pseudo_global
;
913 /* Nonzero if this is a namespace scope. */
916 namespace_bindings_p ()
918 return current_binding_level
->namespace_p
;
924 keep_next_level_flag
= 1;
927 /* Nonzero if the current level needs to have a BLOCK made. */
932 return (current_binding_level
->blocks
!= NULL_TREE
933 || current_binding_level
->keep
934 || current_binding_level
->names
!= NULL_TREE
935 || (current_binding_level
->tags
!= NULL_TREE
936 && !current_binding_level
->tag_transparent
));
939 /* Identify this binding level as a level of parameters. */
942 declare_parm_level ()
944 current_binding_level
->parm_flag
= 1;
948 declare_pseudo_global_level ()
950 current_binding_level
->pseudo_global
= 1;
954 declare_namespace_level ()
956 current_binding_level
->namespace_p
= 1;
960 pseudo_global_level_p ()
962 return current_binding_level
->pseudo_global
;
966 set_class_shadows (shadows
)
969 class_binding_level
->class_shadowed
= shadows
;
972 /* Enter a new binding level.
973 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
974 not for that of tags. */
977 pushlevel (tag_transparent
)
980 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
982 /* If this is the top level of a function,
983 just make sure that NAMED_LABELS is 0.
984 They should have been set to 0 at the end of the previous function. */
986 if (current_binding_level
== global_binding_level
)
987 my_friendly_assert (named_labels
== NULL_TREE
, 134);
989 /* Reuse or create a struct for this binding level. */
991 #if defined(DEBUG_CP_BINDING_LEVELS)
993 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
994 if (free_binding_level
)
995 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
997 newlevel
= free_binding_level
;
998 free_binding_level
= free_binding_level
->level_chain
;
1002 newlevel
= make_binding_level ();
1005 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
1006 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
1007 keep_next_level_flag
= 0;
1011 note_level_for_for ()
1013 current_binding_level
->is_for_scope
= 1;
1017 pushlevel_temporary (tag_transparent
)
1018 int tag_transparent
;
1020 pushlevel (tag_transparent
);
1021 current_binding_level
->keep
= 2;
1024 /* Note we don't call push_momentary() here. Otherwise, it would cause
1025 cleanups to be allocated on the momentary obstack, and they will be
1026 overwritten by the next statement. */
1028 expand_start_bindings (0);
1031 /* Exit a binding level.
1032 Pop the level off, and restore the state of the identifier-decl mappings
1033 that were in effect when this level was entered.
1035 If KEEP == 1, this level had explicit declarations, so
1036 and create a "block" (a BLOCK node) for the level
1037 to record its declarations and subblocks for symbol table output.
1039 If KEEP == 2, this level's subblocks go to the front,
1040 not the back of the current binding level. This happens,
1041 for instance, when code for constructors and destructors
1042 need to generate code at the end of a function which must
1043 be moved up to the front of the function.
1045 If FUNCTIONBODY is nonzero, this level is the body of a function,
1046 so create a block as if KEEP were set and also clear out all
1049 If REVERSE is nonzero, reverse the order of decls before putting
1050 them into the BLOCK. */
1053 poplevel (keep
, reverse
, functionbody
)
1059 /* The chain of decls was accumulated in reverse order.
1060 Put it into forward order, just for cleanliness. */
1062 int tmp
= functionbody
;
1063 int real_functionbody
= current_binding_level
->keep
== 2
1064 ? ((functionbody
= 0), tmp
) : functionbody
;
1065 tree tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1066 tree subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1067 tree block
= NULL_TREE
;
1069 int block_previously_created
;
1071 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1072 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1073 current_binding_level
->parm_flag
,
1074 current_binding_level
->keep
);
1076 if (current_binding_level
->keep
== 1)
1079 /* Get the decls in the order they were written.
1080 Usually current_binding_level->names is in reverse order.
1081 But parameter decls were previously put in forward order. */
1084 current_binding_level
->names
1085 = decls
= nreverse (current_binding_level
->names
);
1087 decls
= current_binding_level
->names
;
1089 /* Output any nested inline functions within this block
1090 if they weren't already output. */
1092 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1093 if (TREE_CODE (decl
) == FUNCTION_DECL
1094 && ! TREE_ASM_WRITTEN (decl
)
1095 && DECL_INITIAL (decl
) != NULL_TREE
1096 && TREE_ADDRESSABLE (decl
)
1097 && decl_function_context (decl
) == current_function_decl
)
1099 /* If this decl was copied from a file-scope decl
1100 on account of a block-scope extern decl,
1101 propagate TREE_ADDRESSABLE to the file-scope decl. */
1102 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1103 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1106 push_function_context ();
1107 output_inline_function (decl
);
1108 pop_function_context ();
1112 /* If there were any declarations or structure tags in that level,
1113 or if this level is a function body,
1114 create a BLOCK to record them for the life of this function. */
1117 block_previously_created
= (current_binding_level
->this_block
!= NULL_TREE
);
1118 if (block_previously_created
)
1119 block
= current_binding_level
->this_block
;
1120 else if (keep
== 1 || functionbody
)
1121 block
= make_node (BLOCK
);
1122 if (block
!= NULL_TREE
)
1124 if (block_previously_created
)
1126 if (decls
|| tags
|| subblocks
)
1128 if (BLOCK_VARS (block
) || BLOCK_TYPE_TAGS (block
))
1130 warning ("internal compiler error: debugging info corrupted");
1132 BLOCK_VARS (block
) = decls
;
1133 BLOCK_TYPE_TAGS (block
) = tags
;
1135 /* We can have previous subblocks and new subblocks when
1136 doing fixup_gotos with complex cleanups. We chain the new
1137 subblocks onto the end of any pre-existing subblocks. */
1138 BLOCK_SUBBLOCKS (block
) = chainon (BLOCK_SUBBLOCKS (block
),
1141 /* If we created the block earlier on, and we are just
1142 diddling it now, then it already should have a proper
1143 BLOCK_END_NOTE value associated with it. */
1147 BLOCK_VARS (block
) = decls
;
1148 BLOCK_TYPE_TAGS (block
) = tags
;
1149 BLOCK_SUBBLOCKS (block
) = subblocks
;
1150 /* Otherwise, for a new block, install a new BLOCK_END_NOTE value. */
1151 remember_end_note (block
);
1155 /* In each subblock, record that this is its superior. */
1158 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1159 BLOCK_SUPERCONTEXT (link
) = block
;
1161 /* Clear out the meanings of the local variables of this level. */
1163 if (current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1)
1165 struct binding_level
*outer
= current_binding_level
->level_chain
;
1166 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1168 if (TREE_CODE (link
) == VAR_DECL
)
1169 DECL_DEAD_FOR_LOCAL (link
) = 1;
1171 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = NULL_TREE
;
1174 /* Save declarations made in a 'for' statement so we can support pre-ANSI
1175 'for' scoping semantics. */
1177 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1179 tree id
= TREE_PURPOSE (link
);
1180 tree decl
= IDENTIFIER_LOCAL_VALUE (id
);
1182 if (decl
&& DECL_DEAD_FOR_LOCAL (decl
))
1184 /* In this case keep the dead for-decl visible,
1185 but remember what (if anything) it shadowed. */
1186 DECL_SHADOWED_FOR_VAR (decl
) = TREE_VALUE (link
);
1187 TREE_CHAIN (decl
) = outer
->dead_vars_from_for
;
1188 outer
->dead_vars_from_for
= decl
;
1191 IDENTIFIER_LOCAL_VALUE (id
) = TREE_VALUE (link
);
1194 else /* Not special for scope. */
1196 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1198 if (DECL_NAME (link
) != NULL_TREE
)
1200 /* If the ident. was used or addressed via a local extern decl,
1201 don't forget that fact. */
1202 if (DECL_EXTERNAL (link
))
1204 if (TREE_USED (link
))
1205 TREE_USED (DECL_ASSEMBLER_NAME (link
)) = 1;
1206 if (TREE_ADDRESSABLE (link
))
1207 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1209 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = NULL_TREE
;
1213 /* Restore all name-meanings of the outer levels
1214 that were shadowed by this level. */
1216 for (link
= current_binding_level
->shadowed
;
1217 link
; link
= TREE_CHAIN (link
))
1218 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1220 /* We first restore the regular decls and *then* the dead_vars_from_for
1221 to handle this case:
1225 for (int i; ; ) { ...} // i#2
1229 In this case, we want remove the binding for i#3, restoring
1230 that of i#2. Then we want to remove the binding for i#2,
1231 and restore that of i#1. */
1233 link
= current_binding_level
->dead_vars_from_for
;
1234 for (; link
!= NULL_TREE
; link
= TREE_CHAIN (link
))
1236 tree id
= DECL_NAME (link
);
1237 if (IDENTIFIER_LOCAL_VALUE (id
) == link
)
1238 IDENTIFIER_LOCAL_VALUE (id
) = DECL_SHADOWED_FOR_VAR (link
);
1241 for (link
= current_binding_level
->class_shadowed
;
1242 link
; link
= TREE_CHAIN (link
))
1243 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1244 for (link
= current_binding_level
->type_shadowed
;
1245 link
; link
= TREE_CHAIN (link
))
1246 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1249 /* If the level being exited is the top level of a function,
1250 check over all the labels. */
1254 /* If this is the top level block of a function,
1255 the vars are the function's parameters.
1256 Don't leave them in the BLOCK because they are
1257 found in the FUNCTION_DECL instead. */
1259 BLOCK_VARS (block
) = 0;
1261 /* Clear out the definitions of all label names,
1262 since their scopes end here. */
1264 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1266 register tree label
= TREE_VALUE (link
);
1268 if (DECL_INITIAL (label
) == NULL_TREE
)
1270 cp_error_at ("label `%D' used but not defined", label
);
1271 /* Avoid crashing later. */
1272 define_label (input_filename
, 1, DECL_NAME (label
));
1274 else if (warn_unused
&& !TREE_USED (label
))
1275 cp_warning_at ("label `%D' defined but not used", label
);
1276 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), NULL_TREE
);
1278 /* Put the labels into the "variables" of the
1279 top-level block, so debugger can see them. */
1280 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1281 BLOCK_VARS (block
) = label
;
1284 named_labels
= NULL_TREE
;
1287 /* Any uses of undefined labels now operate under constraints
1288 of next binding contour. */
1290 struct binding_level
*level_chain
;
1291 level_chain
= current_binding_level
->level_chain
;
1294 struct named_label_list
*labels
;
1295 for (labels
= named_label_uses
; labels
; labels
= labels
->next
)
1296 if (labels
->binding_level
== current_binding_level
)
1298 labels
->binding_level
= level_chain
;
1299 labels
->names_in_scope
= level_chain
->names
;
1304 tmp
= current_binding_level
->keep
;
1306 pop_binding_level ();
1308 DECL_INITIAL (current_function_decl
) = block
;
1311 if (!block_previously_created
)
1312 current_binding_level
->blocks
1313 = chainon (current_binding_level
->blocks
, block
);
1315 /* If we did not make a block for the level just exited,
1316 any blocks made for inner levels
1317 (since they cannot be recorded as subblocks in that level)
1318 must be carried forward so they will later become subblocks
1319 of something else. */
1323 current_binding_level
->blocks
1324 = chainon (subblocks
, current_binding_level
->blocks
);
1326 current_binding_level
->blocks
1327 = chainon (current_binding_level
->blocks
, subblocks
);
1330 /* Take care of compiler's internal binding structures. */
1333 expand_end_bindings (getdecls (), keep
, 1);
1334 /* Each and every BLOCK node created here in `poplevel' is important
1335 (e.g. for proper debugging information) so if we created one
1336 earlier, mark it as "used". */
1338 TREE_USED (block
) = 1;
1339 block
= poplevel (keep
, reverse
, real_functionbody
);
1342 /* Each and every BLOCK node created here in `poplevel' is important
1343 (e.g. for proper debugging information) so if we created one
1344 earlier, mark it as "used". */
1346 TREE_USED (block
) = 1;
1350 /* Delete the node BLOCK from the current binding level.
1351 This is used for the block inside a stmt expr ({...})
1352 so that the block can be reinserted where appropriate. */
1355 delete_block (block
)
1359 if (current_binding_level
->blocks
== block
)
1360 current_binding_level
->blocks
= TREE_CHAIN (block
);
1361 for (t
= current_binding_level
->blocks
; t
;)
1363 if (TREE_CHAIN (t
) == block
)
1364 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1368 TREE_CHAIN (block
) = NULL_TREE
;
1369 /* Clear TREE_USED which is always set by poplevel.
1370 The flag is set again if insert_block is called. */
1371 TREE_USED (block
) = 0;
1374 /* Insert BLOCK at the end of the list of subblocks of the
1375 current binding level. This is used when a BIND_EXPR is expanded,
1376 to handle the BLOCK node inside the BIND_EXPR. */
1379 insert_block (block
)
1382 TREE_USED (block
) = 1;
1383 current_binding_level
->blocks
1384 = chainon (current_binding_level
->blocks
, block
);
1387 /* Set the BLOCK node for the innermost scope
1388 (the one we are currently in). */
1392 register tree block
;
1394 current_binding_level
->this_block
= block
;
1397 /* Do a pushlevel for class declarations. */
1402 register struct binding_level
*newlevel
;
1404 /* Reuse or create a struct for this binding level. */
1405 #if defined(DEBUG_CP_BINDING_LEVELS)
1407 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1408 if (free_binding_level
)
1409 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1411 newlevel
= free_binding_level
;
1412 free_binding_level
= free_binding_level
->level_chain
;
1416 newlevel
= make_binding_level ();
1419 #if defined(DEBUG_CP_BINDING_LEVELS)
1421 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1423 push_binding_level (newlevel
, 0, 0);
1425 decl_stack
= push_decl_level (decl_stack
, &decl_obstack
);
1426 class_binding_level
= current_binding_level
;
1427 class_binding_level
->parm_flag
= 2;
1428 /* We have just pushed into a new binding level. Now, fake out the rest
1429 of the compiler. Set the `current_binding_level' back to point to
1430 the most closely containing non-class binding level. */
1433 current_binding_level
= current_binding_level
->level_chain
;
1435 while (current_binding_level
->parm_flag
== 2);
1438 /* ...and a poplevel for class declarations. FORCE is used to force
1439 clearing out of CLASS_VALUEs after a class definition. */
1442 poplevel_class (force
)
1445 register struct binding_level
*level
= class_binding_level
;
1446 tree block
= NULL_TREE
;
1449 my_friendly_assert (level
!= 0, 354);
1451 decl_stack
= pop_stack_level (decl_stack
);
1452 for (shadowed
= level
->shadowed
; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
1453 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed
)) = TREE_VALUE (shadowed
);
1454 /* If we're leaving a toplevel class, don't bother to do the setting
1455 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1456 shouldn't even be used when current_class_type isn't set, and second,
1457 if we don't touch it here, we're able to use the cache effect if the
1458 next time we're entering a class scope, it is the same class. */
1459 if (current_class_depth
!= 1 || force
)
1460 for (shadowed
= level
->class_shadowed
;
1462 shadowed
= TREE_CHAIN (shadowed
))
1463 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = TREE_VALUE (shadowed
);
1465 /* Remember to save what IDENTIFIER's were bound in this scope so we
1466 can recover from cache misses. */
1468 previous_class_type
= current_class_type
;
1469 previous_class_values
= class_binding_level
->class_shadowed
;
1471 for (shadowed
= level
->type_shadowed
;
1473 shadowed
= TREE_CHAIN (shadowed
))
1474 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1476 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1477 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1478 class_binding_level
->parm_flag
,
1479 class_binding_level
->keep
);
1481 if (class_binding_level
->parm_flag
!= 2)
1482 class_binding_level
= (struct binding_level
*)0;
1484 /* Now, pop out of the binding level which we created up in the
1485 `pushlevel_class' routine. */
1486 #if defined(DEBUG_CP_BINDING_LEVELS)
1488 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1490 pop_binding_level ();
1495 /* For debugging. */
1496 static int no_print_functions
= 0;
1497 static int no_print_builtins
= 0;
1500 print_binding_level (lvl
)
1501 struct binding_level
*lvl
;
1505 fprintf (stderr
, " blocks=");
1506 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
1507 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
1508 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
1509 if (lvl
->tag_transparent
)
1510 fprintf (stderr
, " tag-transparent");
1511 if (lvl
->more_cleanups_ok
)
1512 fprintf (stderr
, " more-cleanups-ok");
1513 if (lvl
->have_cleanups
)
1514 fprintf (stderr
, " have-cleanups");
1515 fprintf (stderr
, "\n");
1518 fprintf (stderr
, " names:\t");
1519 /* We can probably fit 3 names to a line? */
1520 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1522 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1524 if (no_print_builtins
1525 && (TREE_CODE (t
) == TYPE_DECL
)
1526 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
1529 /* Function decls tend to have longer names. */
1530 if (TREE_CODE (t
) == FUNCTION_DECL
)
1537 fprintf (stderr
, "\n\t");
1540 print_node_brief (stderr
, "", t
, 0);
1541 if (t
== error_mark_node
)
1545 fprintf (stderr
, "\n");
1549 fprintf (stderr
, " tags:\t");
1551 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
1553 if (TREE_PURPOSE (t
) == NULL_TREE
)
1555 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
1562 fprintf (stderr
, "\n\t");
1565 if (TREE_PURPOSE (t
) == NULL_TREE
)
1567 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
1568 fprintf (stderr
, ">");
1570 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
1571 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
1574 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
1575 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
1576 fprintf (stderr
, ">");
1580 fprintf (stderr
, "\n");
1584 fprintf (stderr
, " shadowed:");
1585 for (t
= lvl
->shadowed
; t
; t
= TREE_CHAIN (t
))
1587 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1589 fprintf (stderr
, "\n");
1591 if (lvl
->class_shadowed
)
1593 fprintf (stderr
, " class-shadowed:");
1594 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
1596 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1598 fprintf (stderr
, "\n");
1600 if (lvl
->type_shadowed
)
1602 fprintf (stderr
, " type-shadowed:");
1603 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1605 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1607 fprintf (stderr
, "\n");
1612 print_other_binding_stack (stack
)
1613 struct binding_level
*stack
;
1615 struct binding_level
*level
;
1616 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
1618 fprintf (stderr
, "binding level ");
1619 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
1620 fprintf (stderr
, "\n");
1621 print_binding_level (level
);
1626 print_binding_stack ()
1628 struct binding_level
*b
;
1629 fprintf (stderr
, "current_binding_level=");
1630 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
1631 fprintf (stderr
, "\nclass_binding_level=");
1632 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
1633 fprintf (stderr
, "\nglobal_binding_level=");
1634 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
1635 fprintf (stderr
, "\n");
1636 if (class_binding_level
)
1638 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1639 if (b
== current_binding_level
)
1642 b
= class_binding_level
;
1644 b
= current_binding_level
;
1647 b
= current_binding_level
;
1648 print_other_binding_stack (b
);
1649 fprintf (stderr
, "global:\n");
1650 print_binding_level (global_binding_level
);
1653 /* Namespace binding access routines: The namespace_bindings field of
1654 the identifier is polymorphic, with three possible values:
1655 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1656 indicating the BINDING_VALUE of global_namespace. */
1658 /* Check whether the a binding for the name to scope is known.
1659 Assumes that the bindings of the name are already a list
1660 of bindings. Returns the binding found, or NULL_TREE. */
1663 find_binding (name
, scope
)
1667 tree iter
, prev
= NULL_TREE
;
1669 scope
= ORIGINAL_NAMESPACE (scope
);
1671 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
1672 iter
= TREE_CHAIN (iter
))
1674 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
1675 if (BINDING_SCOPE (iter
) == scope
)
1677 /* Move binding found to the fron of the list, so
1678 subsequent lookups will find it faster. */
1681 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
1682 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
1683 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
1692 /* Always returns a binding for name in scope. If the
1693 namespace_bindings is not a list, convert it to one first.
1694 If no binding is found, make a new one. */
1697 binding_for_name (name
, scope
)
1701 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1704 scope
= ORIGINAL_NAMESPACE (scope
);
1706 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
1708 /* Get rid of optimization for global scope. */
1709 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
1710 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
1711 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1713 if (b
&& (result
= find_binding (name
, scope
)))
1715 /* Not found, make a new permanent one. */
1716 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1717 result
= make_node (CPLUS_BINDING
);
1718 TREE_CHAIN (result
) = b
;
1719 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1720 BINDING_SCOPE (result
) = scope
;
1721 BINDING_TYPE (result
) = NULL_TREE
;
1722 BINDING_VALUE (result
) = NULL_TREE
;
1727 /* Return the binding value for name in scope, considering that
1728 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
1731 namespace_binding (name
, scope
)
1735 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1738 if (scope
== NULL_TREE
)
1739 scope
= global_namespace
;
1740 if (TREE_CODE (b
) != CPLUS_BINDING
)
1741 return (scope
== global_namespace
) ? b
: NULL_TREE
;
1742 name
= find_binding (name
,scope
);
1743 if (name
== NULL_TREE
)
1745 return BINDING_VALUE (name
);
1748 /* Set the binding value for name in scope. If modifying the binding
1749 of global_namespace is attempted, try to optimize it. */
1752 set_namespace_binding (name
, scope
, val
)
1759 if (scope
== NULL_TREE
)
1760 scope
= global_namespace
;
1762 if (scope
== global_namespace
)
1764 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1765 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
1767 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
1771 b
= binding_for_name (name
, scope
);
1772 BINDING_VALUE (b
) = val
;
1775 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
1776 select a name that is unique to this compilation unit. */
1779 push_namespace (name
)
1784 int implicit_use
= 0;
1786 if (!global_namespace
)
1788 /* This must be ::. */
1789 my_friendly_assert (name
== get_identifier ("::"), 377);
1794 /* The name of anonymous namespace is unique for the translation
1796 if (!anonymous_namespace_name
)
1797 anonymous_namespace_name
= get_file_function_name ('N');
1798 name
= anonymous_namespace_name
;
1799 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
1801 /* Reopening anonymous namespace. */
1805 else if (current_namespace
== global_namespace
1806 && name
== DECL_NAME (std_node
))
1813 /* Check whether this is an extended namespace definition. */
1814 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
1815 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
1818 if (DECL_NAMESPACE_ALIAS (d
))
1820 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
1821 d
, DECL_NAMESPACE_ALIAS (d
));
1822 d
= DECL_NAMESPACE_ALIAS (d
);
1829 /* Make a new namespace, binding the name to it. */
1830 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
1831 /* The global namespace is not pushed, and the global binding
1832 level is set elsewhere. */
1837 declare_namespace_level ();
1838 NAMESPACE_LEVEL (d
) = current_binding_level
;
1842 resume_binding_level (NAMESPACE_LEVEL (d
));
1845 do_using_directive (d
);
1846 /* Enter the name space. */
1847 current_namespace
= d
;
1850 /* Pop from the scope of the current namespace. */
1855 if (current_namespace
== global_namespace
)
1857 my_friendly_assert (in_std
>0, 980421);
1861 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
1862 /* The binding level is not popped, as it might be re-opened later. */
1863 suspend_binding_level ();
1866 /* Concatenate the binding levels of all namespaces. */
1869 cat_namespace_levels()
1873 struct binding_level
*b
;
1875 last
= NAMESPACE_LEVEL (global_namespace
) -> names
;
1876 /* The nested namespaces appear in the names list of their ancestors. */
1877 for (current
= last
; current
; current
= TREE_CHAIN (current
))
1879 if (TREE_CODE (current
) != NAMESPACE_DECL
1880 || DECL_NAMESPACE_ALIAS (current
))
1882 if (!DECL_LANG_SPECIFIC (current
))
1885 my_friendly_assert (current
== std_node
, 393);
1888 b
= NAMESPACE_LEVEL (current
);
1889 while (TREE_CHAIN (last
))
1890 last
= TREE_CHAIN (last
);
1891 TREE_CHAIN (last
) = NAMESPACE_LEVEL (current
) -> names
;
1895 /* Subroutines for reverting temporarily to top-level for instantiation
1896 of templates and such. We actually need to clear out the class- and
1897 local-value slots of all identifiers, so that only the global values
1898 are at all visible. Simply setting current_binding_level to the global
1899 scope isn't enough, because more binding levels may be pushed. */
1900 struct saved_scope
{
1901 struct binding_level
*old_binding_level
;
1904 struct saved_scope
*prev
;
1905 tree class_name
, class_type
;
1906 tree access_specifier
;
1908 struct binding_level
*class_bindings
;
1909 tree
*lang_base
, *lang_stack
, lang_name
;
1911 int minimal_parse_mode
;
1912 tree last_function_parms
;
1913 tree template_parms
;
1914 HOST_WIDE_INT processing_template_decl
;
1915 tree previous_class_type
, previous_class_values
;
1916 int processing_specialization
;
1917 int processing_explicit_instantiation
;
1919 static struct saved_scope
*current_saved_scope
;
1921 /* A chain of the binding vecs created by store_bindings. We create a
1922 whole bunch of these during compilation, on permanent_obstack, so we
1923 can't just throw them away. */
1924 static tree free_binding_vecs
;
1927 store_bindings (names
, old_bindings
)
1928 tree names
, old_bindings
;
1931 for (t
= names
; t
; t
= TREE_CHAIN (t
))
1933 tree binding
, t1
, id
;
1935 if (TREE_CODE (t
) == TREE_LIST
)
1936 id
= TREE_PURPOSE (t
);
1941 || (!IDENTIFIER_LOCAL_VALUE (id
)
1942 && !IDENTIFIER_CLASS_VALUE (id
)))
1945 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
1946 if (TREE_VEC_ELT (t1
, 0) == id
)
1949 if (free_binding_vecs
)
1951 binding
= free_binding_vecs
;
1952 free_binding_vecs
= TREE_CHAIN (free_binding_vecs
);
1955 binding
= make_tree_vec (4);
1959 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
1960 TREE_VEC_ELT (binding
, 0) = id
;
1961 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
1962 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_LOCAL_VALUE (id
);
1963 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
1964 IDENTIFIER_LOCAL_VALUE (id
) = NULL_TREE
;
1965 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
1967 TREE_CHAIN (binding
) = old_bindings
;
1968 old_bindings
= binding
;
1972 return old_bindings
;
1976 maybe_push_to_top_level (pseudo
)
1979 extern int current_lang_stacksize
;
1980 struct saved_scope
*s
1981 = (struct saved_scope
*) xmalloc (sizeof (struct saved_scope
));
1982 struct binding_level
*b
= inner_binding_level
;
1983 tree old_bindings
= NULL_TREE
;
1985 if (current_function_decl
)
1986 push_cp_function_context (NULL_TREE
);
1988 if (previous_class_type
)
1989 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
1991 /* Have to include global_binding_level, because class-level decls
1992 aren't listed anywhere useful. */
1993 for (; b
; b
= b
->level_chain
)
1997 /* Template IDs are inserted into the global level. If they were
1998 inserted into namespace level, finish_file wouldn't find them
1999 when doing pending instantiations. Therefore, don't stop at
2000 namespace level, but continue until :: . */
2001 if (b
== global_binding_level
|| (pseudo
&& b
->pseudo_global
))
2004 old_bindings
= store_bindings (b
->names
, old_bindings
);
2005 /* We also need to check class_shadowed to save class-level type
2006 bindings, since pushclass doesn't fill in b->names. */
2007 if (b
->parm_flag
== 2)
2008 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2010 /* Unwind type-value slots back to top level. */
2011 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2012 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2015 s
->old_binding_level
= current_binding_level
;
2016 current_binding_level
= b
;
2018 s
->old_namespace
= current_namespace
;
2019 s
->class_name
= current_class_name
;
2020 s
->class_type
= current_class_type
;
2021 s
->access_specifier
= current_access_specifier
;
2022 s
->function_decl
= current_function_decl
;
2023 s
->class_bindings
= class_binding_level
;
2024 s
->lang_stack
= current_lang_stack
;
2025 s
->lang_base
= current_lang_base
;
2026 s
->lang_stacksize
= current_lang_stacksize
;
2027 s
->lang_name
= current_lang_name
;
2028 s
->minimal_parse_mode
= minimal_parse_mode
;
2029 s
->last_function_parms
= last_function_parms
;
2030 s
->template_parms
= current_template_parms
;
2031 s
->processing_template_decl
= processing_template_decl
;
2032 s
->previous_class_type
= previous_class_type
;
2033 s
->previous_class_values
= previous_class_values
;
2034 s
->processing_specialization
= processing_specialization
;
2035 s
->processing_explicit_instantiation
= processing_explicit_instantiation
;
2037 current_class_name
= current_class_type
= NULL_TREE
;
2038 current_function_decl
= NULL_TREE
;
2039 class_binding_level
= (struct binding_level
*)0;
2040 current_lang_stacksize
= 10;
2041 current_lang_stack
= current_lang_base
2042 = (tree
*) xmalloc (current_lang_stacksize
* sizeof (tree
));
2043 current_lang_name
= lang_name_cplusplus
;
2044 strict_prototype
= strict_prototypes_lang_cplusplus
;
2045 named_labels
= NULL_TREE
;
2046 shadowed_labels
= NULL_TREE
;
2047 minimal_parse_mode
= 0;
2048 previous_class_type
= previous_class_values
= NULL_TREE
;
2049 processing_specialization
= 0;
2050 processing_explicit_instantiation
= 0;
2051 current_template_parms
= NULL_TREE
;
2052 processing_template_decl
= 0;
2053 current_namespace
= global_namespace
;
2055 s
->prev
= current_saved_scope
;
2056 s
->old_bindings
= old_bindings
;
2057 current_saved_scope
= s
;
2059 push_obstacks (&permanent_obstack
, &permanent_obstack
);
2063 push_to_top_level ()
2065 maybe_push_to_top_level (0);
2069 pop_from_top_level ()
2071 extern int current_lang_stacksize
;
2072 struct saved_scope
*s
= current_saved_scope
;
2075 /* Clear out class-level bindings cache. */
2076 if (previous_class_type
)
2079 previous_class_type
= NULL_TREE
;
2084 current_binding_level
= s
->old_binding_level
;
2085 current_saved_scope
= s
->prev
;
2086 for (t
= s
->old_bindings
; t
; )
2089 tree id
= TREE_VEC_ELT (t
, 0);
2092 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2093 IDENTIFIER_LOCAL_VALUE (id
) = TREE_VEC_ELT (t
, 2);
2094 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2097 TREE_CHAIN (save
) = free_binding_vecs
;
2098 free_binding_vecs
= save
;
2100 current_namespace
= s
->old_namespace
;
2101 current_class_name
= s
->class_name
;
2102 current_class_type
= s
->class_type
;
2103 current_access_specifier
= s
->access_specifier
;
2104 current_function_decl
= s
->function_decl
;
2105 class_binding_level
= s
->class_bindings
;
2106 free (current_lang_base
);
2107 current_lang_base
= s
->lang_base
;
2108 current_lang_stack
= s
->lang_stack
;
2109 current_lang_name
= s
->lang_name
;
2110 current_lang_stacksize
= s
->lang_stacksize
;
2111 if (current_lang_name
== lang_name_cplusplus
)
2112 strict_prototype
= strict_prototypes_lang_cplusplus
;
2113 else if (current_lang_name
== lang_name_c
)
2114 strict_prototype
= strict_prototypes_lang_c
;
2115 minimal_parse_mode
= s
->minimal_parse_mode
;
2116 last_function_parms
= s
->last_function_parms
;
2117 current_template_parms
= s
->template_parms
;
2118 processing_template_decl
= s
->processing_template_decl
;
2119 previous_class_type
= s
->previous_class_type
;
2120 previous_class_values
= s
->previous_class_values
;
2121 processing_specialization
= s
->processing_specialization
;
2122 processing_explicit_instantiation
= s
->processing_explicit_instantiation
;
2126 if (current_function_decl
)
2127 pop_cp_function_context (NULL_TREE
);
2130 /* Push a definition of struct, union or enum tag "name".
2131 into binding_level "b". "type" should be the type node,
2132 We assume that the tag "name" is not already defined.
2134 Note that the definition may really be just a forward reference.
2135 In that case, the TYPE_SIZE will be a NULL_TREE.
2137 C++ gratuitously puts all these tags in the name space. */
2139 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2140 record the shadowed value for this binding contour. TYPE is
2141 the type that ID maps to. */
2144 set_identifier_type_value_with_scope (id
, type
, b
)
2147 struct binding_level
*b
;
2149 if (!b
->namespace_p
)
2151 /* Shadow the marker, not the real thing, so that the marker
2152 gets restored later. */
2153 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2155 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2159 tree binding
= binding_for_name (id
, current_namespace
);
2160 BINDING_TYPE (binding
) = type
;
2161 /* Store marker instead of real type. */
2162 type
= global_type_node
;
2164 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2167 /* As set_identifier_type_value_with_scope, but using inner_binding_level. */
2170 set_identifier_type_value (id
, type
)
2174 set_identifier_type_value_with_scope (id
, type
, inner_binding_level
);
2178 set_identifier_local_value_with_scope (id
, val
, b
)
2180 struct binding_level
*b
;
2183 my_friendly_assert (! b
->namespace_p
, 980716);
2185 oldlocal
= IDENTIFIER_LOCAL_VALUE (id
);
2186 b
->shadowed
= tree_cons (id
, oldlocal
, b
->shadowed
);
2187 IDENTIFIER_LOCAL_VALUE (id
) = val
;
2191 set_identifier_local_value (id
, val
)
2194 set_identifier_local_value_with_scope (id
, val
, current_binding_level
);
2197 /* Return the type associated with id. */
2200 identifier_type_value (id
)
2203 /* There is no type with that name, anywhere. */
2204 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2206 /* This is not the type marker, but the real thing. */
2207 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2208 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2209 /* Have to search for it. It must be on the global level, now.
2210 Ask lookup_name not to return non-types. */
2211 id
= lookup_name_real (id
, 2, 1, 0);
2213 return TREE_TYPE (id
);
2217 /* Pop off extraneous binding levels left over due to syntax errors.
2219 We don't pop past namespaces, as they might be valid. */
2224 #ifdef DEBUG_CP_BINDING_LEVELS
2225 fprintf (stderr
, "XXX entering pop_everything ()\n");
2227 while (! toplevel_bindings_p () && ! pseudo_global_level_p ())
2229 if (class_binding_level
)
2230 pop_nested_class (1);
2234 #ifdef DEBUG_CP_BINDING_LEVELS
2235 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2239 /* The type TYPE is being declared. If it is a class template, or a
2240 specialization of a class template, do any processing required and
2241 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2242 being declared a friend. B is the binding level at which this TYPE
2245 Returns the TYPE_DECL for TYPE, which may have been altered by this
2249 maybe_process_template_type_declaration (type
, globalize
, b
)
2252 struct binding_level
* b
;
2254 tree decl
= TYPE_NAME (type
);
2256 if (processing_template_parmlist
)
2257 /* You can't declare a new template type in a template parameter
2258 list. But, you can declare a non-template type:
2260 template <class A*> struct S;
2262 is a forward-declaration of `A'. */
2266 maybe_check_template_type (type
);
2268 my_friendly_assert (IS_AGGR_TYPE (type
)
2269 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2272 if (/* If !GLOBALIZE then we are looking at a definition.
2273 It may not be a primary template. (For example, in:
2276 struct S1 { class S2 {}; }
2278 we have to push_template_decl for S2.) */
2279 (processing_template_decl
&& !globalize
)
2280 /* If we are declaring a friend template class, we will
2281 have GLOBALIZE set, since something like:
2289 declares S2 to be at global scope. */
2290 || PROCESSING_REAL_TEMPLATE_DECL_P ())
2292 /* This may change after the call to
2293 push_template_decl_real, but we want the original value. */
2294 tree name
= DECL_NAME (decl
);
2296 decl
= push_template_decl_real (decl
, globalize
);
2297 /* If the current binding level is the binding level for the
2298 template parameters (see the comment in
2299 begin_template_parm_list) and the enclosing level is a class
2300 scope, and we're not looking at a friend, push the
2301 declaration of the member class into the class scope. In the
2302 friend case, push_template_decl will already have put the
2303 friend into global scope, if appropriate. */
2304 if (TREE_CODE (type
) != ENUMERAL_TYPE
2305 && !globalize
&& b
->pseudo_global
2306 && b
->level_chain
->parm_flag
== 2)
2308 pushdecl_with_scope (CLASSTYPE_TI_TEMPLATE (type
),
2310 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2311 /* Put this tag on the list of tags for the class, since
2312 that won't happen below because B is not the class
2313 binding level, but is instead the pseudo-global level. */
2314 b
->level_chain
->tags
=
2315 saveable_tree_cons (name
, type
, b
->level_chain
->tags
);
2316 TREE_NONLOCAL_FLAG (type
) = 1;
2317 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2318 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2326 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2327 Normally put it into the inner-most non-tag-transparent scope,
2328 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2329 The latter is needed for implicit declarations. */
2332 pushtag (name
, type
, globalize
)
2336 register struct binding_level
*b
;
2340 b
= inner_binding_level
;
2341 while (b
->tag_transparent
2342 || (globalize
&& b
->parm_flag
== 2))
2345 if (toplevel_bindings_p ())
2346 b
->tags
= perm_tree_cons (name
, type
, b
->tags
);
2348 b
->tags
= saveable_tree_cons (name
, type
, b
->tags
);
2352 context
= type
? TYPE_CONTEXT (type
) : NULL_TREE
;
2355 tree cs
= current_scope ();
2359 else if (cs
!= NULL_TREE
2360 && TREE_CODE_CLASS (TREE_CODE (cs
)) == 't')
2361 /* When declaring a friend class of a local class, we want
2362 to inject the newly named class into the scope
2363 containing the local class, not the namespace scope. */
2364 context
= hack_decl_function_context (get_type_decl (cs
));
2367 c_decl
= TREE_CODE (context
) == FUNCTION_DECL
2368 ? context
: TYPE_MAIN_DECL (context
);
2371 context
= current_namespace
;
2373 /* Do C++ gratuitous typedefing. */
2374 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2376 register tree d
= NULL_TREE
;
2377 int newdecl
= 0, in_class
= 0;
2379 if ((b
->pseudo_global
&& b
->level_chain
->parm_flag
== 2)
2380 || b
->parm_flag
== 2)
2383 d
= lookup_nested_type (type
, c_decl
);
2388 d
= build_decl (TYPE_DECL
, name
, type
);
2389 if (current_lang_name
== lang_name_java
)
2390 TYPE_FOR_JAVA (type
) = 1;
2391 SET_DECL_ARTIFICIAL (d
);
2393 set_identifier_type_value_with_scope (name
, type
, b
);
2396 d
= TYPE_MAIN_DECL (d
);
2398 TYPE_NAME (type
) = d
;
2399 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2401 d
= maybe_process_template_type_declaration (type
,
2404 if (b
->parm_flag
== 2)
2406 pushdecl_class_level (d
);
2407 if (newdecl
&& !PROCESSING_REAL_TEMPLATE_DECL_P ())
2408 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2409 class. But if it's a member template class, we
2410 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2412 finish_member_declaration (d
);
2415 d
= pushdecl_with_scope (d
, b
);
2419 if (ANON_AGGRNAME_P (name
))
2420 DECL_IGNORED_P (d
) = 1;
2422 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2423 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2424 if (!uses_template_parms (type
))
2425 DECL_ASSEMBLER_NAME (d
)
2426 = get_identifier (build_overload_name (type
, 1, 1));
2429 if (b
->parm_flag
== 2)
2431 TREE_NONLOCAL_FLAG (type
) = 1;
2432 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2433 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2437 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2438 /* Use the canonical TYPE_DECL for this node. */
2439 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2442 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2443 will be the tagged type we just added to the current
2444 binding level. This fake NULL-named TYPE_DECL node helps
2445 dwarfout.c to know when it needs to output a
2446 representation of a tagged type, and it also gives us a
2447 convenient place to record the "scope start" address for
2450 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2451 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2455 /* Counter used to create anonymous type names. */
2457 static int anon_cnt
= 0;
2459 /* Return an IDENTIFIER which can be used as a name for
2460 anonymous structs and unions. */
2467 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2468 return get_identifier (buf
);
2471 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2472 This keeps dbxout from getting confused. */
2477 register struct binding_level
*b
;
2479 static int last_cnt
= 0;
2481 /* Fast out if no new anon names were declared. */
2482 if (last_cnt
== anon_cnt
)
2485 b
= current_binding_level
;
2486 while (b
->tag_transparent
)
2491 /* A NULL purpose means we have already processed all tags
2492 from here to the end of the list. */
2493 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2495 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2496 TREE_PURPOSE (tags
) = NULL_TREE
;
2497 tags
= TREE_CHAIN (tags
);
2499 last_cnt
= anon_cnt
;
2502 /* Subroutine of duplicate_decls: return truthvalue of whether
2503 or not types of these decls match.
2505 For C++, we must compare the parameter list so that `int' can match
2506 `int&' in a parameter position, but `int&' is not confused with
2510 decls_match (newdecl
, olddecl
)
2511 tree newdecl
, olddecl
;
2515 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
2516 /* If the two DECLs are not even the same kind of thing, we're not
2517 interested in their types. */
2520 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2522 tree f1
= TREE_TYPE (newdecl
);
2523 tree f2
= TREE_TYPE (olddecl
);
2524 tree p1
= TYPE_ARG_TYPES (f1
);
2525 tree p2
= TYPE_ARG_TYPES (f2
);
2527 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
)
2528 && ! (DECL_LANGUAGE (newdecl
) == lang_c
2529 && DECL_LANGUAGE (olddecl
) == lang_c
))
2532 /* When we parse a static member function definition,
2533 we put together a FUNCTION_DECL which thinks its type
2534 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
2536 if (TREE_CODE (f1
) == METHOD_TYPE
&& DECL_STATIC_FUNCTION_P (olddecl
))
2537 revert_static_member_fn (&newdecl
, &f1
, &p1
);
2538 else if (TREE_CODE (f2
) == METHOD_TYPE
2539 && DECL_STATIC_FUNCTION_P (newdecl
))
2540 revert_static_member_fn (&olddecl
, &f2
, &p2
);
2542 /* Here we must take care of the case where new default
2543 parameters are specified. Also, warn if an old
2544 declaration becomes ambiguous because default
2545 parameters may cause the two to be ambiguous. */
2546 if (TREE_CODE (f1
) != TREE_CODE (f2
))
2548 if (TREE_CODE (f1
) == OFFSET_TYPE
)
2549 cp_compiler_error ("`%D' redeclared as member function", newdecl
);
2551 cp_compiler_error ("`%D' redeclared as non-member function", newdecl
);
2555 if (comptypes (TREE_TYPE (f1
), TREE_TYPE (f2
), 1))
2557 if (! strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
) == lang_c
2560 types_match
= self_promoting_args_p (p1
);
2561 if (p1
== void_list_node
)
2562 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2564 else if (!strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
)==lang_c
2565 && DECL_LANGUAGE (newdecl
) == lang_c
&& p1
== NULL_TREE
)
2567 types_match
= self_promoting_args_p (p2
);
2568 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2571 types_match
= compparms (p1
, p2
);
2576 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2578 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2579 DECL_TEMPLATE_PARMS (olddecl
)))
2582 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2585 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
2586 DECL_TEMPLATE_RESULT (newdecl
));
2590 if (TREE_TYPE (newdecl
) == error_mark_node
)
2591 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
2592 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
2593 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
2594 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
2597 types_match
= comptypes (TREE_TYPE (newdecl
),
2598 TREE_TYPE (olddecl
), 1);
2604 /* If NEWDECL is `static' and an `extern' was seen previously,
2605 warn about it. (OLDDECL may be NULL_TREE; NAME contains
2606 information about previous usage as an `extern'.)
2608 Note that this does not apply to the C++ case of declaring
2609 a variable `extern const' and then later `const'.
2611 Don't complain about built-in functions, since they are beyond
2612 the user's control. */
2615 warn_extern_redeclared_static (newdecl
, olddecl
)
2616 tree newdecl
, olddecl
;
2620 static char *explicit_extern_static_warning
2621 = "`%D' was declared `extern' and later `static'";
2622 static char *implicit_extern_static_warning
2623 = "`%D' was declared implicitly `extern' and later `static'";
2625 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2628 name
= DECL_ASSEMBLER_NAME (newdecl
);
2629 if (TREE_PUBLIC (name
) && DECL_THIS_STATIC (newdecl
))
2631 /* It's okay to redeclare an ANSI built-in function as static,
2632 or to declare a non-ANSI built-in function as anything. */
2633 if (! (TREE_CODE (newdecl
) == FUNCTION_DECL
2634 && olddecl
!= NULL_TREE
2635 && TREE_CODE (olddecl
) == FUNCTION_DECL
2636 && (DECL_BUILT_IN (olddecl
)
2637 || DECL_BUILT_IN_NONANSI (olddecl
))))
2639 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
2640 ? implicit_extern_static_warning
2641 : explicit_extern_static_warning
, newdecl
);
2642 if (olddecl
!= NULL_TREE
)
2643 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
2648 /* Handle when a new declaration NEWDECL has the same name as an old
2649 one OLDDECL in the same binding contour. Prints an error message
2652 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2653 Otherwise, return 0. */
2656 duplicate_decls (newdecl
, olddecl
)
2657 tree newdecl
, olddecl
;
2659 extern struct obstack permanent_obstack
;
2660 unsigned olddecl_uid
= DECL_UID (olddecl
);
2661 int olddecl_friend
= 0, types_match
= 0;
2662 int new_defines_function
= 0;
2664 if (newdecl
== olddecl
)
2667 types_match
= decls_match (newdecl
, olddecl
);
2669 /* If either the type of the new decl or the type of the old decl is an
2670 error_mark_node, then that implies that we have already issued an
2671 error (earlier) for some bogus type specification, and in that case,
2672 it is rather pointless to harass the user with yet more error message
2673 about the same declaration, so just pretend the types match here. */
2674 if (TREE_TYPE (newdecl
) == error_mark_node
2675 || TREE_TYPE (olddecl
) == error_mark_node
)
2678 /* Check for redeclaration and other discrepancies. */
2679 if (TREE_CODE (olddecl
) == FUNCTION_DECL
2680 && DECL_ARTIFICIAL (olddecl
)
2681 && (DECL_BUILT_IN (olddecl
) || DECL_BUILT_IN_NONANSI (olddecl
)))
2683 /* If you declare a built-in or predefined function name as static,
2684 the old definition is overridden, but optionally warn this was a
2685 bad choice of name. Ditto for overloads. */
2686 if (! TREE_PUBLIC (newdecl
)
2687 || (TREE_CODE (newdecl
) == FUNCTION_DECL
2688 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
)))
2691 cp_warning ("shadowing %s function `%#D'",
2692 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
2694 /* Discard the old built-in function. */
2697 else if (! types_match
)
2699 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
2701 /* If the built-in is not ansi, then programs can override
2702 it even globally without an error. */
2703 if (! DECL_BUILT_IN (olddecl
))
2704 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2708 cp_error ("declaration of `%#D'", newdecl
);
2709 cp_error ("conflicts with built-in declaration `%#D'",
2715 cp_warning ("declaration of `%#D'", newdecl
);
2716 cp_warning ("conflicts with built-in declaration `%#D'",
2720 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
2722 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
2723 && TREE_CODE (newdecl
) != TYPE_DECL
2724 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
2725 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
2726 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
2727 && TREE_CODE (olddecl
) != TYPE_DECL
2728 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
2729 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2732 /* We do nothing special here, because C++ does such nasty
2733 things with TYPE_DECLs. Instead, just let the TYPE_DECL
2734 get shadowed, and know that if we need to find a TYPE_DECL
2735 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
2736 slot of the identifier. */
2740 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
2741 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
2742 || (TREE_CODE (olddecl
) == FUNCTION_DECL
2743 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
2746 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
2747 if (TREE_CODE (olddecl
) == TREE_LIST
)
2748 olddecl
= TREE_VALUE (olddecl
);
2749 cp_error_at ("previous declaration of `%#D'", olddecl
);
2751 /* New decl is completely inconsistent with the old one =>
2752 tell caller to replace the old one. */
2756 else if (!types_match
)
2758 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2760 /* The name of a class template may not be declared to refer to
2761 any other template, class, function, object, namespace, value,
2762 or type in the same scope. */
2763 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
2764 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2766 cp_error ("declaration of template `%#D'", newdecl
);
2767 cp_error_at ("conflicts with previous declaration `%#D'",
2770 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
2771 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
2772 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
2773 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
2774 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2775 DECL_TEMPLATE_PARMS (olddecl
)))
2777 cp_error ("new declaration `%#D'", newdecl
);
2778 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
2782 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2784 if (DECL_LANGUAGE (newdecl
) == lang_c
2785 && DECL_LANGUAGE (olddecl
) == lang_c
)
2787 cp_error ("declaration of C function `%#D' conflicts with",
2789 cp_error_at ("previous declaration `%#D' here", olddecl
);
2791 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
2792 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
2794 cp_error ("new declaration `%#D'", newdecl
);
2795 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
2801 /* Already complained about this, so don't do so again. */
2802 else if (current_class_type
== NULL_TREE
2803 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
2805 cp_error ("conflicting types for `%#D'", newdecl
);
2806 cp_error_at ("previous declaration as `%#D'", olddecl
);
2809 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2810 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
2811 && (!DECL_TEMPLATE_INFO (newdecl
)
2812 || (DECL_TI_TEMPLATE (newdecl
)
2813 != DECL_TI_TEMPLATE (olddecl
))))
2814 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2815 && (!DECL_TEMPLATE_INFO (olddecl
)
2816 || (DECL_TI_TEMPLATE (olddecl
)
2817 != DECL_TI_TEMPLATE (newdecl
))))))
2818 /* It's OK to have a template specialization and a non-template
2819 with the same type, or to have specializations of two
2820 different templates with the same type. Note that if one is a
2821 specialization, and the other is an instantiation of the same
2822 template, that we do not exit at this point. That situation
2823 can occur if we instantiate a template class, and then
2824 specialize one of its methods. This situation is legal, but
2825 the declarations must be merged in the usual way. */
2827 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2828 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
2829 && !DECL_USE_TEMPLATE (newdecl
))
2830 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
2831 && !DECL_USE_TEMPLATE (olddecl
))))
2832 /* One of the declarations is a template instantiation, and the
2833 other is not a template at all. That's OK. */
2835 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
2836 && DECL_NAMESPACE_ALIAS (newdecl
)
2837 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
2838 /* Redeclaration of namespace alias, ignore it. */
2842 char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
2845 cp_error (errmsg
, newdecl
);
2846 if (DECL_NAME (olddecl
) != NULL_TREE
)
2847 cp_error_at ((DECL_INITIAL (olddecl
)
2848 && namespace_bindings_p ())
2849 ? "`%#D' previously defined here"
2850 : "`%#D' previously declared here", olddecl
);
2852 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
2853 && DECL_INITIAL (olddecl
) != NULL_TREE
2854 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
2855 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
2857 /* Prototype decl follows defn w/o prototype. */
2858 cp_warning_at ("prototype for `%#D'", newdecl
);
2859 cp_warning_at ("follows non-prototype definition here", olddecl
);
2861 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
2862 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
2864 /* extern "C" int foo ();
2865 int foo () { bar (); }
2867 if (current_lang_stack
== current_lang_base
)
2868 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
2871 cp_error_at ("previous declaration of `%#D' with %L linkage",
2872 olddecl
, DECL_LANGUAGE (olddecl
));
2873 cp_error ("conflicts with new declaration with %L linkage",
2874 DECL_LANGUAGE (newdecl
));
2878 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
2880 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2882 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
2883 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
2886 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
2887 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
2889 for (; t1
&& t1
!= void_list_node
;
2890 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
2891 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
2893 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
2898 cp_pedwarn ("default argument given for parameter %d of `%#D'",
2900 cp_pedwarn_at ("after previous specification in `%#D'",
2906 cp_error ("default argument given for parameter %d of `%#D'",
2908 cp_error_at ("after previous specification in `%#D'",
2913 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
2914 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
2916 cp_warning ("`%#D' was used before it was declared inline",
2918 cp_warning_at ("previous non-inline declaration here",
2924 /* If new decl is `static' and an `extern' was seen previously,
2926 warn_extern_redeclared_static (newdecl
, olddecl
);
2928 /* We have committed to returning 1 at this point. */
2929 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2931 /* Now that functions must hold information normally held
2932 by field decls, there is extra work to do so that
2933 declaration information does not get destroyed during
2935 if (DECL_VINDEX (olddecl
))
2936 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
2937 if (DECL_CONTEXT (olddecl
))
2938 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2939 if (DECL_CLASS_CONTEXT (olddecl
))
2940 DECL_CLASS_CONTEXT (newdecl
) = DECL_CLASS_CONTEXT (olddecl
);
2941 if (DECL_PENDING_INLINE_INFO (newdecl
) == (struct pending_inline
*)0)
2942 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2943 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
2944 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2945 DECL_ABSTRACT_VIRTUAL_P (newdecl
) |= DECL_ABSTRACT_VIRTUAL_P (olddecl
);
2946 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
2947 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
2948 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
2950 /* Optionally warn about more than one declaration for the same
2951 name, but don't warn about a function declaration followed by a
2953 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
2954 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
2955 /* Don't warn about extern decl followed by definition. */
2956 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
2957 /* Don't warn about friends, let add_friend take care of it. */
2958 && ! DECL_FRIEND_P (newdecl
))
2960 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
2961 cp_warning_at ("previous declaration of `%D'", olddecl
);
2965 /* Deal with C++: must preserve virtual function table size. */
2966 if (TREE_CODE (olddecl
) == TYPE_DECL
)
2968 register tree newtype
= TREE_TYPE (newdecl
);
2969 register tree oldtype
= TREE_TYPE (olddecl
);
2971 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
2972 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
2974 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
2975 CLASSTYPE_FRIEND_CLASSES (newtype
)
2976 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
2980 /* Copy all the DECL_... slots specified in the new decl
2981 except for any that we copy here from the old type. */
2982 DECL_MACHINE_ATTRIBUTES (newdecl
)
2983 = merge_machine_decl_attributes (olddecl
, newdecl
);
2985 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2987 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl
),
2988 DECL_TEMPLATE_RESULT (olddecl
)))
2989 cp_error ("invalid redeclaration of %D", newdecl
);
2990 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
2991 DECL_TEMPLATE_PARMS (olddecl
) = DECL_TEMPLATE_PARMS (newdecl
);
2992 if (DECL_TEMPLATE_INFO (newdecl
))
2993 DECL_TEMPLATE_INFO (olddecl
) = DECL_TEMPLATE_INFO (newdecl
);
2994 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
2995 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
2996 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3003 /* Automatically handles default parameters. */
3004 tree oldtype
= TREE_TYPE (olddecl
);
3007 /* Make sure we put the new type in the same obstack as the old one. */
3009 push_obstacks (TYPE_OBSTACK (oldtype
), TYPE_OBSTACK (oldtype
));
3012 push_obstacks_nochange ();
3013 end_temporary_allocation ();
3016 /* Merge the data types specified in the two decls. */
3017 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3019 if (TREE_CODE (newdecl
) == VAR_DECL
)
3020 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3021 /* Do this after calling `common_type' so that default
3022 parameters don't confuse us. */
3023 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3024 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3025 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3027 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3028 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3029 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3030 TYPE_RAISES_EXCEPTIONS (oldtype
));
3032 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3033 && DECL_SOURCE_LINE (olddecl
) != 0
3035 && ! compexcepttypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
3037 cp_pedwarn ("declaration of `%D' throws different exceptions",
3039 cp_pedwarn_at ("previous declaration here", olddecl
);
3042 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3044 /* Lay the type out, unless already done. */
3045 if (newtype
!= canonical_type_variant (oldtype
)
3046 && TREE_TYPE (newdecl
) != error_mark_node
3047 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3048 layout_type (TREE_TYPE (newdecl
));
3050 if ((TREE_CODE (newdecl
) == VAR_DECL
3051 || TREE_CODE (newdecl
) == PARM_DECL
3052 || TREE_CODE (newdecl
) == RESULT_DECL
3053 || TREE_CODE (newdecl
) == FIELD_DECL
3054 || TREE_CODE (newdecl
) == TYPE_DECL
)
3055 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3056 layout_decl (newdecl
, 0);
3058 /* Merge the type qualifiers. */
3059 if (TREE_READONLY (newdecl
))
3060 TREE_READONLY (olddecl
) = 1;
3061 if (TREE_THIS_VOLATILE (newdecl
))
3062 TREE_THIS_VOLATILE (olddecl
) = 1;
3064 /* Merge the initialization information. */
3065 if (DECL_INITIAL (newdecl
) == NULL_TREE
3066 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3068 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3069 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3070 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3071 if (DECL_LANG_SPECIFIC (newdecl
)
3072 && DECL_LANG_SPECIFIC (olddecl
))
3073 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3076 /* Merge the section attribute.
3077 We want to issue an error if the sections conflict but that must be
3078 done later in decl_attributes since we are called before attributes
3080 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3081 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3083 /* Keep the old rtl since we can safely use it, unless it's the
3084 call to abort() used for abstract virtuals. */
3085 if ((DECL_LANG_SPECIFIC (olddecl
)
3086 && !DECL_ABSTRACT_VIRTUAL_P (olddecl
))
3087 || DECL_RTL (olddecl
) != DECL_RTL (abort_fndecl
))
3088 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3092 /* If cannot merge, then use the new type and qualifiers,
3093 and don't preserve the old rtl. */
3096 /* Clean out any memory we had of the old declaration. */
3097 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3099 TREE_VALUE (oldstatic
) = error_mark_node
;
3101 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3102 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3103 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3104 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3107 /* Merge the storage class information. */
3108 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3109 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3110 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3111 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3112 if (! DECL_EXTERNAL (olddecl
))
3113 DECL_EXTERNAL (newdecl
) = 0;
3115 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3117 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3118 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3119 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3120 /* Don't really know how much of the language-specific
3121 values we should copy from old to new. */
3122 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3123 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3124 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3125 if (DECL_TEMPLATE_INFO (newdecl
) == NULL_TREE
)
3127 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3128 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
3130 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3133 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3135 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3136 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3138 /* If newdecl is not a specialization, then it is not a
3139 template-related function at all. And that means that we
3140 shoud have exited above, returning 0. */
3141 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3144 if (TREE_USED (olddecl
))
3145 /* From [temp.expl.spec]:
3147 If a template, a member template or the member of a class
3148 template is explicitly specialized then that
3149 specialization shall be declared before the first use of
3150 that specialization that would cause an implicit
3151 instantiation to take place, in every translation unit in
3152 which such a use occurs. */
3153 cp_error ("explicit specialization of %D after first use",
3156 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3158 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3160 /* If either decl says `inline', this fn is inline, unless its
3161 definition was passed already. */
3162 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3163 DECL_INLINE (olddecl
) = 1;
3164 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3168 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3169 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3170 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3172 if (! types_match
|| new_defines_function
)
3174 /* These need to be copied so that the names are available. */
3175 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3176 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3178 if (new_defines_function
)
3179 /* If defining a function declared with other language
3180 linkage, use the previously declared language linkage. */
3181 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3184 /* If redeclaring a builtin function, and not a definition,
3185 it stays built in. */
3186 if (DECL_BUILT_IN (olddecl
))
3188 DECL_BUILT_IN (newdecl
) = 1;
3189 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3190 /* If we're keeping the built-in definition, keep the rtl,
3191 regardless of declaration matches. */
3192 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3195 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3197 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3198 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3199 /* Previously saved insns go together with
3200 the function's previous definition. */
3201 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3202 /* Don't clear out the arguments if we're redefining a function. */
3203 if (DECL_ARGUMENTS (olddecl
))
3204 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3206 if (DECL_LANG_SPECIFIC (olddecl
))
3207 DECL_MAIN_VARIANT (newdecl
) = DECL_MAIN_VARIANT (olddecl
);
3210 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3212 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3215 /* Now preserve various other info from the definition. */
3216 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3217 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3218 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3219 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3221 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3224 struct lang_decl
*ol
= DECL_LANG_SPECIFIC (olddecl
);
3225 struct lang_decl
*nl
= DECL_LANG_SPECIFIC (newdecl
);
3227 function_size
= sizeof (struct tree_decl
);
3229 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3230 (char *) olddecl
+ sizeof (struct tree_common
),
3231 function_size
- sizeof (struct tree_common
));
3233 /* Can we safely free the storage used by newdecl? */
3235 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3236 & ~ obstack_alignment_mask (&permanent_obstack))
3238 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3240 /* If newdecl is a template instantiation, it is possible that
3241 the following sequence of events has occurred:
3243 o A friend function was declared in a class template. The
3244 class template was instantiated.
3246 o The instantiation of the friend declaration was
3247 recorded on the instantiation list, and is newdecl.
3249 o Later, however, instantiate_class_template called pushdecl
3250 on the newdecl to perform name injection. But, pushdecl in
3251 turn called duplicate_decls when it discovered that another
3252 declaration of a global function with the same name already
3255 o Here, in duplicate_decls, we decided to clobber newdecl.
3257 If we're going to do that, we'd better make sure that
3258 olddecl, and not newdecl, is on the list of
3259 instantiations so that if we try to do the instantiation
3260 again we won't get the clobbered declaration. */
3262 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3263 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3265 for (; decls
; decls
= TREE_CHAIN (decls
))
3266 if (TREE_VALUE (decls
) == newdecl
)
3267 TREE_VALUE (decls
) = olddecl
;
3270 if (((char *)newdecl
+ ROUND (function_size
) == (char *)nl
3271 && ((char *)newdecl
+ ROUND (function_size
)
3272 + ROUND (sizeof (struct lang_decl
))
3273 == obstack_next_free (&permanent_obstack
)))
3274 || ((char *)newdecl
+ ROUND (function_size
)
3275 == obstack_next_free (&permanent_obstack
)))
3277 DECL_MAIN_VARIANT (newdecl
) = olddecl
;
3278 DECL_LANG_SPECIFIC (olddecl
) = ol
;
3279 bcopy ((char *)nl
, (char *)ol
, sizeof (struct lang_decl
));
3281 obstack_free (&permanent_obstack
, newdecl
);
3283 else if (LANG_DECL_PERMANENT (ol
) && ol
!= nl
)
3285 if (DECL_MAIN_VARIANT (olddecl
) == olddecl
)
3287 /* Save these lang_decls that would otherwise be lost. */
3288 extern tree free_lang_decl_chain
;
3289 tree free_lang_decl
= (tree
) ol
;
3291 if (DECL_LANG_SPECIFIC (olddecl
) == ol
)
3294 TREE_CHAIN (free_lang_decl
) = free_lang_decl_chain
;
3295 free_lang_decl_chain
= free_lang_decl
;
3299 /* Storage leak. */;
3305 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3306 (char *) olddecl
+ sizeof (struct tree_common
),
3307 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3308 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3311 DECL_UID (olddecl
) = olddecl_uid
;
3313 DECL_FRIEND_P (olddecl
) = 1;
3315 /* NEWDECL contains the merged attribute lists.
3316 Update OLDDECL to be the same. */
3317 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3322 /* Record a decl-node X as belonging to the current lexical scope.
3323 Check for errors (such as an incompatible declaration for the same
3324 name already seen in the same scope).
3326 Returns either X or an old decl for the same name.
3327 If an old decl is returned, it may have been smashed
3328 to agree with what X says. */
3335 register tree name
= DECL_ASSEMBLER_NAME (x
);
3336 register struct binding_level
*b
= current_binding_level
;
3338 if (current_function_decl
&& x
!= current_function_decl
3339 /* A local declaration for a function doesn't constitute nesting. */
3340 && (TREE_CODE (x
) != FUNCTION_DECL
|| DECL_INITIAL (x
))
3341 /* Don't change DECL_CONTEXT of virtual methods. */
3342 && (TREE_CODE (x
) != FUNCTION_DECL
|| !DECL_VIRTUAL_P (x
))
3343 && ! DECL_CONTEXT (x
))
3344 DECL_CONTEXT (x
) = current_function_decl
;
3345 if (!DECL_CONTEXT (x
))
3346 DECL_CONTEXT (x
) = FROB_CONTEXT (current_namespace
);
3348 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3349 compiler wants to use. */
3350 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
3351 || TREE_CODE (x
) == NAMESPACE_DECL
|| TREE_CODE (x
) == TEMPLATE_TYPE_PARM
3352 || TREE_CODE (x
) == TEMPLATE_TEMPLATE_PARM
)
3353 name
= DECL_NAME (x
);
3358 /* Not needed...see below. */
3362 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3363 name
= TREE_OPERAND (name
, 0);
3365 /* Namespace-scoped variables are not found in the current level. */
3366 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
))
3367 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3369 t
= lookup_name_current_level (name
);
3370 if (t
== error_mark_node
)
3372 /* error_mark_node is 0 for a while during initialization! */
3374 cp_error_at ("`%#D' used prior to declaration", x
);
3377 else if (t
!= NULL_TREE
)
3380 /* This is turned off until I have time to do it right (bpk). */
3381 /* With the code below that uses it... */
3382 file
= DECL_SOURCE_FILE (t
);
3383 line
= DECL_SOURCE_LINE (t
);
3385 if (TREE_CODE (t
) == PARM_DECL
)
3387 if (DECL_CONTEXT (t
) == NULL_TREE
)
3388 fatal ("parse errors have confused me too much");
3390 /* Check for duplicate params. */
3391 if (duplicate_decls (x
, t
))
3394 else if (((TREE_CODE (x
) == FUNCTION_DECL
&& DECL_LANGUAGE (x
) == lang_c
)
3395 || DECL_FUNCTION_TEMPLATE_P (x
))
3396 && is_overloaded_fn (t
))
3397 /* Don't do anything just yet. */;
3398 else if (t
== wchar_decl_node
)
3400 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3401 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3403 /* Throw away the redeclaration. */
3406 else if (TREE_CODE (t
) != TREE_CODE (x
))
3408 if (duplicate_decls (x
, t
))
3411 else if (duplicate_decls (x
, t
))
3414 /* This is turned off until I have time to do it right (bpk). */
3416 /* Also warn if they did a prototype with `static' on it, but
3417 then later left the `static' off. */
3418 if (! TREE_PUBLIC (name
) && TREE_PUBLIC (x
))
3420 if (DECL_LANG_SPECIFIC (t
) && DECL_FRIEND_P (t
))
3425 cp_warning ("`static' missing from declaration of `%D'",
3427 warning_with_file_and_line (file
, line
,
3428 "previous declaration of `%s'",
3429 decl_as_string (t
, 0));
3432 /* Now fix things so it'll do what they expect. */
3433 if (current_function_decl
)
3434 TREE_PUBLIC (current_function_decl
) = 0;
3436 /* Due to interference in memory reclamation (X may be
3437 obstack-deallocated at this point), we must guard against
3438 one really special case. [jason: This should be handled
3439 by start_function] */
3440 if (current_function_decl
== x
)
3441 current_function_decl
= t
;
3443 if (TREE_CODE (t
) == TYPE_DECL
)
3444 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3445 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3446 check_default_args (t
);
3450 else if (DECL_MAIN_P (x
))
3452 /* A redeclaration of main, but not a duplicate of the
3457 This function shall not be overloaded. */
3458 cp_error_at ("invalid redeclaration of `%D'", t
);
3459 cp_error ("as `%D'", x
);
3460 /* We don't try to push this declaration since that
3466 if (TREE_CODE (x
) == FUNCTION_DECL
&& ! DECL_FUNCTION_MEMBER_P (x
))
3468 t
= push_overloaded_decl (x
, 1);
3469 if (t
!= x
|| DECL_LANGUAGE (x
) == lang_c
)
3472 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3473 return push_overloaded_decl (x
, 0);
3475 /* If declaring a type as a typedef, copy the type (unless we're
3476 at line 0), and install this TYPE_DECL as the new type's typedef
3477 name. See the extensive comment in ../c-decl.c (pushdecl). */
3478 if (TREE_CODE (x
) == TYPE_DECL
)
3480 tree type
= TREE_TYPE (x
);
3481 if (DECL_SOURCE_LINE (x
) == 0)
3483 if (TYPE_NAME (type
) == 0)
3484 TYPE_NAME (type
) = x
;
3486 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
3487 /* We don't want to copy the type when all we're
3488 doing is making a TYPE_DECL for the purposes of
3490 && (!TYPE_NAME (type
)
3491 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
3493 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
3495 DECL_ORIGINAL_TYPE (x
) = type
;
3496 type
= build_type_copy (type
);
3497 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
3498 TYPE_NAME (type
) = x
;
3499 TREE_TYPE (x
) = type
;
3504 if (type
!= error_mark_node
3506 && TYPE_IDENTIFIER (type
))
3507 set_identifier_type_value_with_scope (DECL_NAME (x
), type
, b
);
3510 /* Multiple external decls of the same identifier ought to match.
3512 We get warnings about inline functions where they are defined.
3513 We get warnings about other functions from push_overloaded_decl.
3515 Avoid duplicate warnings where they are used. */
3516 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
3520 if (IDENTIFIER_NAMESPACE_VALUE (name
) != NULL_TREE
3521 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name
))
3522 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name
))))
3523 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
3528 /* If different sort of thing, we already gave an error. */
3529 && TREE_CODE (decl
) == TREE_CODE (x
)
3530 && ! comptypes (TREE_TYPE (x
), TREE_TYPE (decl
), 1))
3532 cp_pedwarn ("type mismatch with previous external decl", x
);
3533 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
3537 /* This name is new in its binding level.
3538 Install the new declaration and return it. */
3539 if (namespace_bindings_p ())
3541 /* Install a global value. */
3543 /* If the first global decl has external linkage,
3544 warn if we later see static one. */
3545 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
3546 TREE_PUBLIC (name
) = 1;
3548 /* Don't install an artificial TYPE_DECL if we already have
3549 another _DECL with that name. */
3550 if (TREE_CODE (x
) != TYPE_DECL
3552 || ! DECL_ARTIFICIAL (x
))
3554 if (TREE_CODE (x
) == FUNCTION_DECL
)
3556 ((IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
)
3557 || (IDENTIFIER_GLOBAL_VALUE (name
) == x
), 378);
3558 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
3561 /* Don't forget if the function was used via an implicit decl. */
3562 if (IDENTIFIER_IMPLICIT_DECL (name
)
3563 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
3566 /* Don't forget if its address was taken in that way. */
3567 if (IDENTIFIER_IMPLICIT_DECL (name
)
3568 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
3569 TREE_ADDRESSABLE (x
) = 1;
3571 /* Warn about mismatches against previous implicit decl. */
3572 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
3573 /* If this real decl matches the implicit, don't complain. */
3574 && ! (TREE_CODE (x
) == FUNCTION_DECL
3575 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
3577 ("`%D' was previously implicitly declared to return `int'", x
);
3579 /* If new decl is `static' and an `extern' was seen previously,
3581 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
3582 warn_extern_redeclared_static (x
, t
);
3586 /* Here to install a non-global value. */
3587 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
3588 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
3590 /* Don't install an artificial TYPE_DECL if we already have
3591 another _DECL with that name. */
3592 if (TREE_CODE (x
) != TYPE_DECL
3594 || ! DECL_ARTIFICIAL (x
))
3595 set_identifier_local_value_with_scope (name
, x
, b
);
3597 /* If this is a TYPE_DECL, push it into the type value slot. */
3598 if (TREE_CODE (x
) == TYPE_DECL
)
3599 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
), b
);
3601 /* Clear out any TYPE_DECL shadowed by a namespace so that
3602 we won't think this is a type. The C struct hack doesn't
3603 go through namespaces. */
3604 if (TREE_CODE (x
) == NAMESPACE_DECL
)
3605 set_identifier_type_value_with_scope (name
, NULL_TREE
, b
);
3607 /* If this is an extern function declaration, see if we
3608 have a global definition or declaration for the function. */
3609 if (oldlocal
== NULL_TREE
3610 && DECL_EXTERNAL (x
)
3611 && oldglobal
!= NULL_TREE
3612 && TREE_CODE (x
) == FUNCTION_DECL
3613 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
3615 /* We have one. Their types must agree. */
3616 if (decls_match (x
, oldglobal
))
3620 cp_warning ("extern declaration of `%#D' doesn't match", x
);
3621 cp_warning_at ("global declaration `%#D'", oldglobal
);
3624 /* If we have a local external declaration,
3625 and no file-scope declaration has yet been seen,
3626 then if we later have a file-scope decl it must not be static. */
3627 if (oldlocal
== NULL_TREE
3628 && oldglobal
== NULL_TREE
3629 && DECL_EXTERNAL (x
)
3632 TREE_PUBLIC (name
) = 1;
3635 if (DECL_FROM_INLINE (x
))
3636 /* Inline decls shadow nothing. */;
3638 /* Warn if shadowing an argument at the top level of the body. */
3639 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
3640 && TREE_CODE (oldlocal
) == PARM_DECL
3641 && TREE_CODE (x
) != PARM_DECL
)
3643 /* Go to where the parms should be and see if we
3645 struct binding_level
*b
= current_binding_level
->level_chain
;
3651 if (b
->parm_flag
== 1)
3652 cp_error ("declaration of `%#D' shadows a parameter", name
);
3654 else if (warn_shadow
&& oldlocal
!= NULL_TREE
&& b
->is_for_scope
3655 && !DECL_DEAD_FOR_LOCAL (oldlocal
))
3657 warning ("variable `%s' shadows local",
3658 IDENTIFIER_POINTER (name
));
3659 cp_warning_at (" this is the shadowed declaration", oldlocal
);
3661 /* Maybe warn if shadowing something else. */
3662 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
3663 /* No shadow warnings for internally generated vars. */
3664 && ! DECL_ARTIFICIAL (x
)
3665 /* No shadow warnings for vars made for inlining. */
3666 && ! DECL_FROM_INLINE (x
))
3668 char *warnstring
= NULL
;
3670 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
3671 warnstring
= "declaration of `%s' shadows a parameter";
3672 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
3673 && current_class_ptr
3674 && !TREE_STATIC (name
))
3675 warnstring
= "declaration of `%s' shadows a member of `this'";
3676 else if (oldlocal
!= NULL_TREE
)
3677 warnstring
= "declaration of `%s' shadows previous local";
3678 else if (oldglobal
!= NULL_TREE
)
3679 /* XXX shadow warnings in outer-more namespaces */
3680 warnstring
= "declaration of `%s' shadows global declaration";
3683 warning (warnstring
, IDENTIFIER_POINTER (name
));
3685 /* Check to see if decl redeclares a template parameter. */
3686 if (oldlocal
&& (current_class_type
|| current_function_decl
)
3687 && current_template_parms
)
3689 if (decl_template_parm_p (oldlocal
))
3691 cp_error ("re-using name of template parameter `%T' in this scope", name
);
3692 cp_error_at (" previously declared here `%#D'", oldlocal
);
3697 if (TREE_CODE (x
) == FUNCTION_DECL
)
3698 check_default_args (x
);
3700 /* Keep count of variables in this level with incomplete type. */
3701 if (TREE_CODE (x
) == VAR_DECL
3702 && TREE_TYPE (x
) != error_mark_node
3703 && ((TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
3704 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
3705 /* RTTI TD entries are created while defining the type_info. */
3706 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
3707 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
3708 b
->incomplete
= tree_cons (NULL_TREE
, x
, b
->incomplete
);
3711 /* Put decls on list in reverse order.
3712 We will reverse them later if necessary. */
3713 TREE_CHAIN (x
) = b
->names
;
3715 if (! (b
!= global_binding_level
|| TREE_PERMANENT (x
)))
3716 my_friendly_abort (124);
3721 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3722 caller to set DECL_CONTEXT properly. */
3725 pushdecl_with_scope (x
, level
)
3727 struct binding_level
*level
;
3729 register struct binding_level
*b
;
3730 tree function_decl
= current_function_decl
;
3732 current_function_decl
= NULL_TREE
;
3733 if (level
->parm_flag
== 2)
3735 b
= class_binding_level
;
3736 class_binding_level
= level
;
3737 pushdecl_class_level (x
);
3738 class_binding_level
= b
;
3742 b
= current_binding_level
;
3743 current_binding_level
= level
;
3745 current_binding_level
= b
;
3747 current_function_decl
= function_decl
;
3751 /* Like pushdecl, only it places X in the current namespace,
3755 pushdecl_namespace_level (x
)
3758 register struct binding_level
*b
= inner_binding_level
;
3761 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
3763 /* Now, the type_shadowed stack may screw us. Munge it so it does
3765 if (TREE_CODE (x
) == TYPE_DECL
)
3767 tree name
= DECL_NAME (x
);
3769 tree
*ptr
= (tree
*)0;
3770 for (; b
!= global_binding_level
; b
= b
->level_chain
)
3772 tree shadowed
= b
->type_shadowed
;
3773 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3774 if (TREE_PURPOSE (shadowed
) == name
)
3776 ptr
= &TREE_VALUE (shadowed
);
3777 /* Can't break out of the loop here because sometimes
3778 a binding level will have duplicate bindings for
3779 PT names. It's gross, but I haven't time to fix it. */
3782 newval
= TREE_TYPE (x
);
3783 if (ptr
== (tree
*)0)
3785 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3786 up here if this is changed to an assertion. --KR */
3787 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
3797 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
3801 pushdecl_top_level (x
)
3804 tree cur_namespace
= current_namespace
;
3805 current_namespace
= global_namespace
;
3806 x
= pushdecl_namespace_level (x
);
3807 current_namespace
= cur_namespace
;
3811 /* Make the declaration of X appear in CLASS scope. */
3814 pushdecl_class_level (x
)
3817 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
3818 scope looks for the pre-mangled name. */
3819 register tree name
= DECL_NAME (x
);
3823 if (TYPE_BEING_DEFINED (current_class_type
))
3825 /* A name N used in a class S shall refer to the same declaration
3826 in its context and when re-evaluated in the completed scope of S.
3827 Types, enums, and static vars are checked here; other
3828 members are checked in finish_struct. */
3829 tree icv
= IDENTIFIER_CLASS_VALUE (name
);
3830 tree ilv
= IDENTIFIER_LOCAL_VALUE (name
);
3833 && flag_optional_diags
3834 /* Don't complain about inherited names. */
3835 && id_in_current_class (name
)
3836 /* Or shadowed tags. */
3837 && !(DECL_DECLARES_TYPE_P (icv
)
3838 && DECL_CONTEXT (icv
) == current_class_type
))
3840 cp_pedwarn ("declaration of identifier `%D' as `%#D'", name
, x
);
3841 cp_pedwarn_at ("conflicts with previous use in class as `%#D'",
3845 /* Check to see if decl redeclares a template parameter. */
3846 if (ilv
&& ! decls_match (ilv
, x
)
3847 && (current_class_type
|| current_function_decl
)
3848 && current_template_parms
)
3850 if (decl_template_parm_p (ilv
))
3852 cp_error ("re-using name of template parameter `%T' in this scope", name
);
3853 cp_error_at (" previously declared here `%#D'", ilv
);
3858 push_class_level_binding (name
, x
);
3859 if (TREE_CODE (x
) == TYPE_DECL
)
3861 set_identifier_type_value (name
, TREE_TYPE (x
));
3867 /* This function is used to push the mangled decls for nested types into
3868 the appropriate scope. Previously pushdecl_top_level was used, but that
3869 is incorrect for members of local classes. */
3872 pushdecl_nonclass_level (x
)
3875 struct binding_level
*b
= current_binding_level
;
3877 my_friendly_assert (b
->parm_flag
!= 2, 180);
3880 /* Get out of template binding levels */
3881 while (b
->pseudo_global
)
3885 pushdecl_with_scope (x
, b
);
3889 /* Make the declaration(s) of X appear in CLASS scope
3890 under the name NAME. */
3893 push_class_level_binding (name
, x
)
3897 /* The class_binding_level will be NULL if x is a template
3898 parameter name in a member template. */
3899 if (!class_binding_level
)
3902 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
3903 && purpose_member (name
, class_binding_level
->class_shadowed
))
3906 maybe_push_cache_obstack ();
3907 class_binding_level
->class_shadowed
3908 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
3909 class_binding_level
->class_shadowed
);
3911 IDENTIFIER_CLASS_VALUE (name
) = x
;
3912 obstack_ptr_grow (&decl_obstack
, x
);
3915 /* Insert another USING_DECL into the current binding level,
3916 returning this declaration. If this is a redeclaration,
3917 do nothing and return NULL_TREE. */
3920 push_using_decl (scope
, name
)
3926 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
3927 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
3928 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
3929 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
3933 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
3934 DECL_INITIAL (decl
) = scope
;
3935 TREE_CHAIN (decl
) = current_binding_level
->usings
;
3936 current_binding_level
->usings
= decl
;
3940 /* Add namespace to using_directives. Return NULL_TREE if nothing was
3941 changed (i.e. there was already a directive), or the fresh
3942 TREE_LIST otherwise. */
3945 push_using_directive (used
)
3948 tree ud
= current_binding_level
->using_directives
;
3949 tree iter
, ancestor
;
3951 /* Check if we already have this. */
3952 if (purpose_member (used
, ud
) != NULL_TREE
)
3955 /* Recursively add all namespaces used. */
3956 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
3957 push_using_directive (TREE_PURPOSE (iter
));
3959 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
3960 ud
= current_binding_level
->using_directives
;
3961 ud
= perm_tree_cons (used
, ancestor
, ud
);
3962 current_binding_level
->using_directives
= ud
;
3966 /* DECL is a FUNCTION_DECL which may have other definitions already in
3967 place. We get around this by making the value of the identifier point
3968 to a list of all the things that want to be referenced by that name. It
3969 is then up to the users of that name to decide what to do with that
3972 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
3973 slot. It is dealt with the same way.
3975 The value returned may be a previous declaration if we guessed wrong
3976 about what language DECL should belong to (C or C++). Otherwise,
3977 it's always DECL (and never something that's not a _DECL). */
3980 push_overloaded_decl (decl
, forgettable
)
3984 tree orig_name
= DECL_NAME (decl
);
3986 int doing_global
= (namespace_bindings_p () || ! forgettable
);
3990 old
= namespace_binding (orig_name
, DECL_CONTEXT (decl
));
3991 if (old
&& TREE_CODE (old
) == FUNCTION_DECL
3992 && DECL_ARTIFICIAL (old
)
3993 && (DECL_BUILT_IN (old
) || DECL_BUILT_IN_NONANSI (old
)))
3995 if (duplicate_decls (decl
, old
))
4002 old
= IDENTIFIER_LOCAL_VALUE (orig_name
);
4004 if (! purpose_member (orig_name
, current_binding_level
->shadowed
))
4006 current_binding_level
->shadowed
4007 = tree_cons (orig_name
, old
, current_binding_level
->shadowed
);
4014 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4016 tree t
= TREE_TYPE (old
);
4017 if (IS_AGGR_TYPE (t
) && warn_shadow
4018 && (! DECL_IN_SYSTEM_HEADER (decl
)
4019 || ! DECL_IN_SYSTEM_HEADER (old
)))
4020 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4023 else if (is_overloaded_fn (old
))
4027 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4028 if (decl
== OVL_CURRENT (tmp
)
4029 || duplicate_decls (decl
, OVL_CURRENT (tmp
)))
4030 return OVL_CURRENT (tmp
);
4034 cp_error_at ("previous non-function declaration `%#D'", old
);
4035 cp_error ("conflicts with function declaration `%#D'", decl
);
4040 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4042 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4043 old
= ovl_cons (old
, NULL_TREE
);
4044 old
= ovl_cons (decl
, old
);
4047 /* orig_name is not ambiguous. */
4051 set_namespace_binding (orig_name
, current_namespace
, old
);
4053 IDENTIFIER_LOCAL_VALUE (orig_name
) = old
;
4058 /* Generate an implicit declaration for identifier FUNCTIONID
4059 as a function of type int (). Print a warning if appropriate. */
4062 implicitly_declare (functionid
)
4066 int temp
= allocation_temporary_p ();
4068 push_obstacks_nochange ();
4070 /* Save the decl permanently so we can warn if definition follows.
4071 In ANSI C, warn_implicit is usually false, so the saves little space.
4072 But in C++, it's usually true, hence the extra code. */
4073 if (temp
&& (! warn_implicit
|| toplevel_bindings_p ()))
4074 end_temporary_allocation ();
4076 /* We used to reuse an old implicit decl here,
4077 but this loses with inline functions because it can clobber
4078 the saved decl chains. */
4079 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4081 DECL_EXTERNAL (decl
) = 1;
4082 TREE_PUBLIC (decl
) = 1;
4084 /* ANSI standard says implicit declarations are in the innermost block.
4085 So we record the decl in the standard fashion. */
4087 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4090 /* Only one warning per identifier. */
4091 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4093 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4096 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4103 /* Return zero if the declaration NEWDECL is valid
4104 when the declaration OLDDECL (assumed to be for the same name)
4105 has already been seen.
4106 Otherwise return an error message format string with a %s
4107 where the identifier should go. */
4110 redeclaration_error_message (newdecl
, olddecl
)
4111 tree newdecl
, olddecl
;
4113 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4115 /* Because C++ can put things into name space for free,
4116 constructs like "typedef struct foo { ... } foo"
4117 would look like an erroneous redeclaration. */
4118 if (comptypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
), 0))
4121 return "redefinition of `%#D'";
4123 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4125 /* If this is a pure function, its olddecl will actually be
4126 the original initialization to `0' (which we force to call
4127 abort()). Don't complain about redefinition in this case. */
4128 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_ABSTRACT_VIRTUAL_P (olddecl
))
4131 /* If both functions come from different namespaces, this is not
4132 a redeclaration - this is a conflict with a used function. */
4133 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4134 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4135 return "`%D' conflicts with used function";
4137 /* We'll complain about linkage mismatches in
4138 warn_extern_redeclared_static. */
4140 /* Defining the same name twice is no good. */
4141 if (DECL_INITIAL (olddecl
) != NULL_TREE
4142 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4144 if (DECL_NAME (olddecl
) == NULL_TREE
)
4145 return "`%#D' not declared in class";
4147 return "redefinition of `%#D'";
4151 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4153 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4154 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4155 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4156 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4157 && TYPE_SIZE (TREE_TYPE (newdecl
))
4158 && TYPE_SIZE (TREE_TYPE (olddecl
))))
4159 return "redefinition of `%#D'";
4162 else if (toplevel_bindings_p ())
4164 /* Objects declared at top level: */
4165 /* If at least one is a reference, it's ok. */
4166 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4168 /* Reject two definitions. */
4169 return "redefinition of `%#D'";
4173 /* Objects declared with block scope: */
4174 /* Reject two definitions, and reject a definition
4175 together with an external reference. */
4176 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4177 return "redeclaration of `%#D'";
4182 /* Get the LABEL_DECL corresponding to identifier ID as a label.
4183 Create one if none exists so far for the current function.
4184 This function is called for both label definitions and label references. */
4190 register tree decl
= IDENTIFIER_LABEL_VALUE (id
);
4192 if (current_function_decl
== NULL_TREE
)
4194 error ("label `%s' referenced outside of any function",
4195 IDENTIFIER_POINTER (id
));
4199 if ((decl
== NULL_TREE
4200 || DECL_SOURCE_LINE (decl
) == 0)
4201 && (named_label_uses
== NULL
4202 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4203 || named_label_uses
->label_decl
!= decl
))
4205 struct named_label_list
*new_ent
;
4207 = (struct named_label_list
*)oballoc (sizeof (struct named_label_list
));
4208 new_ent
->label_decl
= decl
;
4209 new_ent
->names_in_scope
= current_binding_level
->names
;
4210 new_ent
->binding_level
= current_binding_level
;
4211 new_ent
->lineno_o_goto
= lineno
;
4212 new_ent
->filename_o_goto
= input_filename
;
4213 new_ent
->next
= named_label_uses
;
4214 named_label_uses
= new_ent
;
4217 /* Use a label already defined or ref'd with this name. */
4218 if (decl
!= NULL_TREE
)
4220 /* But not if it is inherited and wasn't declared to be inheritable. */
4221 if (DECL_CONTEXT (decl
) != current_function_decl
4222 && ! C_DECLARED_LABEL_FLAG (decl
))
4223 return shadow_label (id
);
4227 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4229 /* Make sure every label has an rtx. */
4232 /* A label not explicitly declared must be local to where it's ref'd. */
4233 DECL_CONTEXT (decl
) = current_function_decl
;
4235 DECL_MODE (decl
) = VOIDmode
;
4237 /* Say where one reference is to the label,
4238 for the sake of the error if it is not defined. */
4239 DECL_SOURCE_LINE (decl
) = lineno
;
4240 DECL_SOURCE_FILE (decl
) = input_filename
;
4242 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4244 named_labels
= tree_cons (NULL_TREE
, decl
, named_labels
);
4245 named_label_uses
->label_decl
= decl
;
4250 /* Make a label named NAME in the current function,
4251 shadowing silently any that may be inherited from containing functions
4252 or containing scopes.
4254 Note that valid use, if the label being shadowed
4255 comes from another scope in the same function,
4256 requires calling declare_nonlocal_label right away. */
4262 register tree decl
= IDENTIFIER_LABEL_VALUE (name
);
4264 if (decl
!= NULL_TREE
)
4266 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
4267 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
4270 return lookup_label (name
);
4273 /* Define a label, specifying the location in the source file.
4274 Return the LABEL_DECL node for the label, if the definition is valid.
4275 Otherwise return 0. */
4278 define_label (filename
, line
, name
)
4285 if (minimal_parse_mode
)
4287 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4288 decl
= build_decl (LABEL_DECL
, name
, void_type_node
);
4290 DECL_SOURCE_LINE (decl
) = line
;
4291 DECL_SOURCE_FILE (decl
) = filename
;
4296 decl
= lookup_label (name
);
4298 /* After labels, make any new cleanups go into their
4299 own new (temporary) binding contour. */
4300 current_binding_level
->more_cleanups_ok
= 0;
4302 /* If label with this name is known from an outer context, shadow it. */
4303 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) != current_function_decl
)
4305 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
4306 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
4307 decl
= lookup_label (name
);
4310 if (name
== get_identifier ("wchar_t"))
4311 cp_pedwarn ("label named wchar_t");
4313 if (DECL_INITIAL (decl
) != NULL_TREE
)
4315 cp_error ("duplicate label `%D'", decl
);
4320 struct named_label_list
*uses
, *prev
;
4323 /* Mark label as having been defined. */
4324 DECL_INITIAL (decl
) = error_mark_node
;
4325 /* Say where in the source. */
4326 DECL_SOURCE_FILE (decl
) = filename
;
4327 DECL_SOURCE_LINE (decl
) = line
;
4330 uses
= named_label_uses
;
4331 while (uses
!= NULL
)
4332 if (uses
->label_decl
== decl
)
4334 struct binding_level
*b
= current_binding_level
;
4337 tree new_decls
= b
->names
;
4338 tree old_decls
= (b
== uses
->binding_level
)
4339 ? uses
->names_in_scope
: NULL_TREE
;
4340 while (new_decls
!= old_decls
)
4342 if (TREE_CODE (new_decls
) == VAR_DECL
4343 /* Don't complain about crossing initialization
4344 of internal entities. They can't be accessed,
4345 and they should be cleaned up
4346 by the time we get to the label. */
4347 && ! DECL_ARTIFICIAL (new_decls
)
4348 && ((DECL_INITIAL (new_decls
) != NULL_TREE
4349 && DECL_INITIAL (new_decls
) != error_mark_node
)
4350 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
4354 cp_error ("jump to label `%D'", decl
);
4355 error_with_file_and_line (uses
->filename_o_goto
,
4356 uses
->lineno_o_goto
,
4360 cp_error_at (" crosses initialization of `%#D'",
4363 new_decls
= TREE_CHAIN (new_decls
);
4365 if (b
== uses
->binding_level
)
4371 prev
->next
= uses
->next
;
4373 named_label_uses
= uses
->next
;
4382 current_function_return_value
= NULL_TREE
;
4389 struct binding_level
*level
;
4390 struct cp_switch
*next
;
4393 static struct cp_switch
*switch_stack
;
4399 = (struct cp_switch
*) oballoc (sizeof (struct cp_switch
));
4400 p
->level
= current_binding_level
;
4401 p
->next
= switch_stack
;
4408 switch_stack
= switch_stack
->next
;
4411 /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
4412 /* XXX Note decl is never actually used. (bpk) */
4415 define_case_label ()
4417 tree cleanup
= last_cleanup_this_contour ();
4418 struct binding_level
*b
= current_binding_level
;
4423 static int explained
= 0;
4424 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup
));
4425 warning ("where case label appears here");
4428 warning ("(enclose actions of previous case statements requiring");
4429 warning ("destructors in their own binding contours.)");
4434 for (; b
&& b
!= switch_stack
->level
; b
= b
->level_chain
)
4436 tree new_decls
= b
->names
;
4437 for (; new_decls
; new_decls
= TREE_CHAIN (new_decls
))
4439 if (TREE_CODE (new_decls
) == VAR_DECL
4440 /* Don't complain about crossing initialization
4441 of internal entities. They can't be accessed,
4442 and they should be cleaned up
4443 by the time we get to the label. */
4444 && ! DECL_ARTIFICIAL (new_decls
)
4445 && ((DECL_INITIAL (new_decls
) != NULL_TREE
4446 && DECL_INITIAL (new_decls
) != error_mark_node
)
4447 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
4450 error ("jump to case label");
4452 cp_error_at (" crosses initialization of `%#D'",
4458 /* After labels, make any new cleanups go into their
4459 own new (temporary) binding contour. */
4461 current_binding_level
->more_cleanups_ok
= 0;
4462 current_function_return_value
= NULL_TREE
;
4465 /* Return the list of declarations of the current level.
4466 Note that this list is in reverse order unless/until
4467 you nreverse it; and when you do nreverse it, you must
4468 store the result back using `storedecls' or you will lose. */
4473 return current_binding_level
->names
;
4476 /* Return the list of type-tags (for structs, etc) of the current level. */
4481 return current_binding_level
->tags
;
4484 /* Store the list of declarations of the current level.
4485 This is done for the parameter declarations of a function being defined,
4486 after they are modified in the light of any missing parameters. */
4492 current_binding_level
->names
= decls
;
4495 /* Similarly, store the list of tags of the current level. */
4501 current_binding_level
->tags
= tags
;
4504 /* Given NAME, an IDENTIFIER_NODE,
4505 return the structure (or union or enum) definition for that name.
4506 Searches binding levels from BINDING_LEVEL up to the global level.
4507 If THISLEVEL_ONLY is nonzero, searches only the specified context
4508 (but skips any tag-transparent contexts to find one that is
4509 meaningful for tags).
4510 FORM says which kind of type the caller wants;
4511 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4512 If the wrong kind of type is found, and it's not a template, an error is
4516 lookup_tag (form
, name
, binding_level
, thislevel_only
)
4517 enum tree_code form
;
4519 struct binding_level
*binding_level
;
4522 register struct binding_level
*level
;
4523 /* Non-zero if, we should look past a pseudo-global level, even if
4525 int allow_pseudo_global
= 1;
4527 for (level
= binding_level
; level
; level
= level
->level_chain
)
4530 if (ANON_AGGRNAME_P (name
))
4531 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4533 /* There's no need for error checking here, because
4534 anon names are unique throughout the compilation. */
4535 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
4536 return TREE_VALUE (tail
);
4538 else if (level
->namespace_p
)
4539 /* Do namespace lookup. */
4540 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
4542 tree old
= binding_for_name (name
, tail
);
4544 /* If we just skipped past a pseudo global level, even
4545 though THISLEVEL_ONLY, and we find a template class
4546 declaration, then we use the _TYPE node for the
4547 template. See the example below. */
4548 if (thislevel_only
&& !allow_pseudo_global
4549 && old
&& BINDING_VALUE (old
)
4550 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
4551 old
= TREE_TYPE (BINDING_VALUE (old
));
4553 old
= BINDING_TYPE (old
);
4555 /* If it has an original type, it is a typedef, and we
4556 should not return it. */
4557 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
4559 if (old
&& TREE_CODE (old
) != form
4560 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
4562 cp_error ("`%#D' redeclared as %C", old
, form
);
4567 if (thislevel_only
|| tail
== global_namespace
)
4571 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4573 if (TREE_PURPOSE (tail
) == name
)
4575 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
4576 /* Should tighten this up; it'll probably permit
4577 UNION_TYPE and a struct template, for example. */
4579 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
4581 /* Definition isn't the kind we were looking for. */
4582 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
4586 return TREE_VALUE (tail
);
4589 if (thislevel_only
&& ! level
->tag_transparent
)
4591 if (level
->pseudo_global
&& allow_pseudo_global
)
4593 /* We must deal with cases like this:
4595 template <class T> struct S;
4596 template <class T> struct S {};
4598 When looking up `S', for the second declaration, we
4599 would like to find the first declaration. But, we
4600 are in the pseudo-global level created for the
4601 template parameters, rather than the (surrounding)
4602 namespace level. Thus, we keep going one more level,
4603 even though THISLEVEL_ONLY is non-zero. */
4604 allow_pseudo_global
= 0;
4610 if (current_class_type
&& level
->level_chain
->namespace_p
)
4612 /* Try looking in this class's tags before heading into
4613 global binding level. */
4614 tree context
= current_class_type
;
4617 switch (TREE_CODE_CLASS (TREE_CODE (context
)))
4621 these_tags
= CLASSTYPE_TAGS (context
);
4622 if (ANON_AGGRNAME_P (name
))
4625 if (TYPE_IDENTIFIER (TREE_VALUE (these_tags
))
4627 return TREE_VALUE (tail
);
4628 these_tags
= TREE_CHAIN (these_tags
);
4633 if (TREE_PURPOSE (these_tags
) == name
)
4635 if (TREE_CODE (TREE_VALUE (these_tags
)) != form
)
4637 cp_error ("`%#D' redeclared as %C in class scope",
4638 TREE_VALUE (tail
), form
);
4641 return TREE_VALUE (tail
);
4643 these_tags
= TREE_CHAIN (these_tags
);
4645 /* If this type is not yet complete, then don't
4646 look at its context. */
4647 if (TYPE_SIZE (context
) == NULL_TREE
)
4649 /* Go to next enclosing type, if any. */
4650 context
= DECL_CONTEXT (TYPE_MAIN_DECL (context
));
4653 context
= DECL_CONTEXT (context
);
4656 my_friendly_abort (10);
4669 set_current_level_tags_transparency (tags_transparent
)
4670 int tags_transparent
;
4672 current_binding_level
->tag_transparent
= tags_transparent
;
4676 /* Given a type, find the tag that was defined for it and return the tag name.
4677 Otherwise return 0. However, the value can never be 0
4678 in the cases in which this is used.
4680 C++: If NAME is non-zero, this is the new name to install. This is
4681 done when replacing anonymous tags with real tag names. */
4684 lookup_tag_reverse (type
, name
)
4688 register struct binding_level
*level
;
4690 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
4693 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4695 if (TREE_VALUE (tail
) == type
)
4698 TREE_PURPOSE (tail
) = name
;
4699 return TREE_PURPOSE (tail
);
4706 /* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
4707 Return the type value, or NULL_TREE if not found. */
4710 lookup_nested_type (type
, context
)
4714 if (context
== NULL_TREE
)
4718 switch (TREE_CODE (context
))
4722 tree ctype
= TREE_TYPE (context
);
4723 tree match
= value_member (type
, CLASSTYPE_TAGS (ctype
));
4725 return TREE_VALUE (match
);
4726 context
= DECL_CONTEXT (context
);
4728 /* When we have a nested class whose member functions have
4729 local types (e.g., a set of enums), we'll arrive here
4730 with the DECL_CONTEXT as the actual RECORD_TYPE node for
4731 the enclosing class. Instead, we want to make sure we
4732 come back in here with the TYPE_DECL, not the RECORD_TYPE. */
4733 if (context
&& TREE_CODE (context
) == RECORD_TYPE
)
4734 context
= TREE_CHAIN (context
);
4738 if (TYPE_NAME (type
) && TYPE_IDENTIFIER (type
))
4739 return lookup_name (TYPE_IDENTIFIER (type
), 1);
4742 my_friendly_abort (12);
4748 /* Look up NAME in the NAMESPACE. */
4751 lookup_namespace_name (namespace, name
)
4752 tree
namespace, name
;
4754 struct tree_binding _b
;
4757 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
4759 /* This happens for A::B<int> when B is a namespace. */
4760 if (TREE_CODE (name
) == NAMESPACE_DECL
)
4763 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
4765 val
= binding_init (&_b
);
4766 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
4767 return error_mark_node
;
4769 if (BINDING_VALUE (val
))
4771 val
= BINDING_VALUE (val
);
4773 /* If we have a single function from a using decl, pull it out. */
4774 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
4775 val
= OVL_FUNCTION (val
);
4779 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
4780 return error_mark_node
;
4783 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4784 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
4785 is non-NULL, this type is being created by the implicit typename
4786 extension, and BASE_TYPE is a type named `t' in some base class of
4787 `T' which depends on template parameters.
4789 Returns the new TYPENAME_TYPE. */
4792 build_typename_type (context
, name
, fullname
, base_type
)
4801 if (processing_template_decl
)
4802 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4804 /* Build the TYPENAME_TYPE. */
4805 t
= make_lang_type (TYPENAME_TYPE
);
4806 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
4807 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
4808 TREE_TYPE (t
) = base_type
;
4809 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
4811 /* Build the corresponding TYPE_DECL. */
4812 d
= build_decl (TYPE_DECL
, name
, t
);
4813 TYPE_NAME (TREE_TYPE (d
)) = d
;
4814 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
4815 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
4817 if (processing_template_decl
)
4824 make_typename_type (context
, name
)
4830 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
4831 name
= TYPE_IDENTIFIER (name
);
4832 else if (TREE_CODE (name
) == TYPE_DECL
)
4833 name
= DECL_NAME (name
);
4837 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
4839 name
= TREE_OPERAND (name
, 0);
4840 if (TREE_CODE (name
) == TEMPLATE_DECL
)
4841 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
4843 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
4844 my_friendly_abort (2000);
4846 if (TREE_CODE (context
) == NAMESPACE_DECL
)
4848 /* We can get here from typename_sub0 in the explicit_template_type
4849 expansion. Just fail. */
4850 cp_error ("no class template named `%#T' in `%#T'",
4852 return error_mark_node
;
4855 if (! uses_template_parms (context
)
4856 || currently_open_class (context
))
4858 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
4860 if (IS_AGGR_TYPE (context
))
4861 t
= lookup_field (context
, name
, 0, 0);
4865 if (t
== NULL_TREE
|| TREE_CODE (t
) != TEMPLATE_DECL
4866 || TREE_CODE (DECL_RESULT (t
)) != TYPE_DECL
)
4868 cp_error ("no class template named `%#T' in `%#T'",
4870 return error_mark_node
;
4873 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
4875 /*entering_scope=*/0);
4879 if (IS_AGGR_TYPE (context
))
4880 t
= lookup_field (context
, name
, 0, 1);
4886 cp_error ("no type named `%#T' in `%#T'", name
, context
);
4887 return error_mark_node
;
4890 return TREE_TYPE (t
);
4894 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
4897 /* Select the right _DECL from multiple choices. */
4900 select_decl (binding
, flags
)
4905 val
= BINDING_VALUE (binding
);
4906 if (LOOKUP_NAMESPACES_ONLY (flags
))
4908 /* We are not interested in types. */
4909 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
4914 /* If we could have a type and
4915 we have nothing or we need a type and have none. */
4916 if (BINDING_TYPE (binding
)
4917 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
4918 && TREE_CODE (val
) != TYPE_DECL
)))
4919 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
4920 /* Don't return non-types if we really prefer types. */
4921 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
4922 && (!looking_for_template
|| TREE_CODE (val
) != TEMPLATE_DECL
))
4928 /* Unscoped lookup of a global, iterate over namespaces, considering
4929 using namespace statements. */
4932 unqualified_namespace_lookup (name
, flags
)
4936 struct tree_binding _binding
;
4937 tree b
= binding_init (&_binding
);
4938 tree initial
= current_decl_namespace();
4939 tree scope
= initial
;
4941 struct binding_level
*level
;
4942 tree val
= NULL_TREE
;
4946 val
= binding_for_name (name
, scope
);
4948 /* Initialize binding for this context. */
4949 BINDING_VALUE (b
) = BINDING_VALUE (val
);
4950 BINDING_TYPE (b
) = BINDING_TYPE (val
);
4952 /* Add all _DECLs seen through local using-directives. */
4953 for (level
= current_binding_level
;
4954 !level
->namespace_p
;
4955 level
= level
->level_chain
)
4956 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
4958 /* Give up because of error. */
4961 /* Add all _DECLs seen through global using-directives. */
4962 /* XXX local and global using lists should work equally. */
4966 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
4968 /* Give up because of error. */
4970 if (siter
== scope
) break;
4971 siter
= CP_DECL_CONTEXT (siter
);
4974 val
= select_decl (b
, flags
);
4975 if (scope
== global_namespace
)
4977 scope
= CP_DECL_CONTEXT (scope
);
4982 /* Combine prefer_type and namespaces_only into flags. */
4985 lookup_flags (prefer_type
, namespaces_only
)
4986 int prefer_type
, namespaces_only
;
4988 if (namespaces_only
)
4989 return LOOKUP_PREFER_NAMESPACES
;
4990 if (prefer_type
> 1)
4991 return LOOKUP_PREFER_TYPES
;
4992 if (prefer_type
> 0)
4993 return LOOKUP_PREFER_BOTH
;
4997 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4998 ignore it or not. Subroutine of lookup_name_real. */
5001 qualify_lookup (val
, flags
)
5005 if (val
== NULL_TREE
)
5007 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5009 if ((flags
& LOOKUP_PREFER_TYPES
)
5010 && (TREE_CODE (val
) == TYPE_DECL
5011 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5012 && DECL_CLASS_TEMPLATE_P (val
))))
5014 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5019 /* Look up NAME in the current binding level and its superiors in the
5020 namespace of variables, functions and typedefs. Return a ..._DECL
5021 node of some kind representing its definition if there is only one
5022 such declaration, or return a TREE_LIST with all the overloaded
5023 definitions if there are many, or return 0 if it is undefined.
5025 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5026 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5027 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5028 Otherwise we prefer non-TYPE_DECLs.
5030 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5031 using IDENTIFIER_CLASS_VALUE. */
5034 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5036 int prefer_type
, nonclass
, namespaces_only
;
5040 tree from_obj
= NULL_TREE
;
5041 tree locval
, classval
;
5044 /* Hack: copy flag set by parser, if set. */
5045 if (only_namespace_names
)
5046 namespaces_only
= 1;
5048 if (prefer_type
== -2)
5050 extern int looking_for_typename
;
5051 tree type
= NULL_TREE
;
5054 prefer_type
= looking_for_typename
;
5056 flags
= lookup_flags (prefer_type
, namespaces_only
);
5057 /* During parsing, we need to complain. */
5058 flags
|= LOOKUP_COMPLAIN
;
5059 /* If the next thing is '<', class templates are types. */
5060 if (looking_for_template
)
5061 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5063 /* std:: becomes :: for now. */
5064 if (got_scope
== std_node
)
5065 got_scope
= void_type_node
;
5069 else if (got_object
!= error_mark_node
)
5074 if (type
== error_mark_node
)
5075 return error_mark_node
;
5076 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5077 type
= TREE_TYPE (type
);
5080 type
= complete_type (type
);
5082 if (TREE_CODE (type
) == VOID_TYPE
)
5083 type
= global_namespace
;
5084 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5086 struct tree_binding b
;
5087 val
= binding_init (&b
);
5088 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5090 val
= select_decl (val
, flags
);
5092 else if (! IS_AGGR_TYPE (type
)
5093 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5094 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
5095 || TREE_CODE (type
) == TYPENAME_TYPE
)
5096 /* Someone else will give an error about this if needed. */
5098 else if (TYPE_BEING_DEFINED (type
))
5100 val
= IDENTIFIER_CLASS_VALUE (name
);
5101 if (val
&& DECL_CONTEXT (val
) != type
)
5103 struct binding_level
*b
= class_binding_level
;
5104 for (val
= NULL_TREE
; b
; b
= b
->level_chain
)
5106 tree t
= purpose_member (name
, b
->class_shadowed
);
5107 if (t
&& TREE_VALUE (t
)
5108 && DECL_CONTEXT (TREE_VALUE (t
)) == type
)
5110 val
= TREE_VALUE (t
);
5115 if (val
== NULL_TREE
)
5116 val
= lookup_field (type
, name
, 0, 1);
5118 else if (type
== current_class_type
)
5119 val
= IDENTIFIER_CLASS_VALUE (name
);
5121 val
= lookup_member (type
, name
, 0, prefer_type
);
5128 else if (got_object
&& val
)
5132 flags
= lookup_flags (prefer_type
, namespaces_only
);
5134 locval
= classval
= NULL_TREE
;
5136 if (! namespace_bindings_p ())
5137 locval
= qualify_lookup (IDENTIFIER_LOCAL_VALUE (name
), flags
);
5139 /* In C++ class fields are between local and global scope,
5140 just before the global scope. */
5141 if (current_class_type
&& ! nonclass
)
5143 classval
= IDENTIFIER_CLASS_VALUE (name
);
5144 if (classval
== NULL_TREE
&& TYPE_BEING_DEFINED (current_class_type
))
5145 /* Try to find values from base classes if we are presently
5146 defining a type. We are presently only interested in
5148 classval
= lookup_field (current_class_type
, name
, 0, 1);
5150 /* Add implicit 'typename' to types from template bases. lookup_field
5151 will do this for us. If classval is actually from an enclosing
5152 scope, lookup_nested_field will get it for us. */
5153 else if (processing_template_decl
5154 && classval
&& TREE_CODE (classval
) == TYPE_DECL
5155 && ! currently_open_class (DECL_CONTEXT (classval
))
5156 && uses_template_parms (current_class_type
))
5157 classval
= lookup_field (current_class_type
, name
, 0, 1);
5159 /* yylex() calls this with -2, since we should never start digging for
5160 the nested name at the point where we haven't even, for example,
5161 created the COMPONENT_REF or anything like that. */
5162 if (classval
== NULL_TREE
)
5163 classval
= lookup_nested_field (name
, ! yylex
);
5165 classval
= qualify_lookup (classval
, flags
);
5168 if (locval
&& classval
)
5170 /* We have both a local binding and a class-level binding. This
5171 can happen in two ways:
5173 o We are in a member function of a class.
5174 o We are in a local class within a function.
5176 We need to determine which one of these situations is
5177 occuring, and give the innermost binding. One tricky bit is
5178 that with member templates we can be in the first case
5179 without CURRENT_FUNCTION_DECL being set. Consider
5181 struct A { template <class A> void f(A); };
5183 Here, when we look at the `A' in the parameter declaration
5184 for `f' we have a local binding (the template parameter) and
5185 a class-level binding (the TYPE_DECL for the class).
5186 Fortunately, if LOCVAL is a template parameter it is safe to
5187 take it; nothing within the scope of the template parameter
5188 is allowed to have the same name. */
5190 if (decl_template_parm_p (locval
))
5192 else if (current_scope () == current_function_decl
5193 && ! hack_decl_function_context (current_function_decl
))
5194 /* Not in a nested function. */
5198 /* This is incredibly horrible. The whole concept of
5199 IDENTIFIER_LOCAL_VALUE / IDENTIFIER_CLASS_VALUE /
5200 IDENTIFIER_GLOBAL_VALUE needs to be scrapped for local
5202 tree lctx
= hack_decl_function_context (locval
);
5203 tree cctx
= hack_decl_function_context (classval
);
5205 if (lctx
== current_scope ())
5207 else if (lctx
== cctx
)
5210 /* I don't know which is right; let's just guess for now. */
5219 val
= unqualified_namespace_lookup (name
, flags
);
5221 /* Any other name takes precedence over an implicit typename. Warn the
5222 user about this potentially confusing lookup. */
5223 if (classval
&& TREE_CODE (val
) == TYPE_DECL
5224 && TREE_CODE (TREE_TYPE (val
)) == TYPENAME_TYPE
5225 && TREE_TYPE (TREE_TYPE (val
)))
5227 if (locval
== NULL_TREE
)
5228 locval
= unqualified_namespace_lookup (name
, flags
);
5230 if (locval
&& val
!= locval
)
5236 /* To avoid redundant warnings, only warn when lexing, and the
5237 decls are significantly different. */
5238 subtype
= TREE_TYPE (TREE_TYPE (classval
));
5240 && ! (TREE_CODE (locval
) == TEMPLATE_DECL
5241 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5242 && CLASSTYPE_TI_TEMPLATE (subtype
) == locval
)
5243 && ! (TREE_CODE (locval
) == TYPE_DECL
5244 && comptypes (TREE_TYPE (locval
), subtype
, 1)))
5246 static int explained
;
5248 cp_warning ("lookup of `%D' finds `%#D'", name
, locval
);
5250 (" instead of `%D' from dependent base class", classval
);
5254 cp_warning (" (use `typename %D' if that's what you meant)",
5264 /* This should only warn about types used in qualified-ids. */
5265 if (from_obj
&& from_obj
!= val
)
5267 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
5268 && TREE_CODE (val
) == TYPE_DECL
5269 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
5271 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5272 name
, got_object
, TREE_TYPE (from_obj
));
5273 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5277 /* We don't change val to from_obj if got_object depends on
5278 template parms because that breaks implicit typename for
5279 destructor calls. */
5280 if (! uses_template_parms (got_object
))
5284 if ((TREE_CODE (val
) == TEMPLATE_DECL
&& looking_for_template
)
5285 || TREE_CODE (val
) == TYPE_DECL
|| prefer_type
<= 0)
5287 /* Caller wants a class-or-namespace-name. */
5288 else if (prefer_type
== 1 && TREE_CODE (val
) == NAMESPACE_DECL
)
5290 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
5291 val
= TYPE_MAIN_DECL (IDENTIFIER_TYPE_VALUE (name
));
5292 else if (TREE_TYPE (val
) == error_mark_node
)
5293 val
= error_mark_node
;
5295 /* If we have a single function from a using decl, pull it out. */
5296 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5297 val
= OVL_FUNCTION (val
);
5306 lookup_name_nonclass (name
)
5309 return lookup_name_real (name
, 0, 1, 0);
5313 lookup_function_nonclass (name
, args
)
5317 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
5321 lookup_name_namespace_only (name
)
5324 /* type-or-namespace, nonclass, namespace_only */
5325 return lookup_name_real (name
, 1, 1, 1);
5329 lookup_name (name
, prefer_type
)
5333 return lookup_name_real (name
, prefer_type
, 0, 0);
5336 /* Similar to `lookup_name' but look only at current binding level. */
5339 lookup_name_current_level (name
)
5342 register tree t
= NULL_TREE
;
5344 if (current_binding_level
->namespace_p
)
5346 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5348 /* extern "C" function() */
5349 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5352 else if (IDENTIFIER_LOCAL_VALUE (name
) != NULL_TREE
)
5354 struct binding_level
*b
= current_binding_level
;
5357 if (purpose_member (name
, b
->shadowed
))
5358 return IDENTIFIER_LOCAL_VALUE (name
);
5369 /* Like lookup_name_current_level, but for types. */
5372 lookup_type_current_level (name
)
5375 register tree t
= NULL_TREE
;
5377 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
5379 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5380 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5382 struct binding_level
*b
= current_binding_level
;
5385 if (purpose_member (name
, b
->type_shadowed
))
5386 return REAL_IDENTIFIER_TYPE_VALUE (name
);
5398 begin_only_namespace_names ()
5400 only_namespace_names
= 1;
5404 end_only_namespace_names ()
5406 only_namespace_names
= 0;
5409 /* Arrange for the user to get a source line number, even when the
5410 compiler is going down in flames, so that she at least has a
5411 chance of working around problems in the compiler. We used to
5412 call error(), but that let the segmentation fault continue
5413 through; now, it's much more passive by asking them to send the
5414 maintainers mail about the problem. */
5418 int sig ATTRIBUTE_UNUSED
;
5420 signal (SIGSEGV
, SIG_DFL
);
5422 signal (SIGIOT
, SIG_DFL
);
5425 signal (SIGILL
, SIG_DFL
);
5428 signal (SIGABRT
, SIG_DFL
);
5431 signal (SIGBUS
, SIG_DFL
);
5433 my_friendly_abort (0);
5437 /* Unused -- brendan 970107 */
5438 /* Array for holding types considered "built-in". These types
5439 are output in the module in which `main' is defined. */
5440 static tree
*builtin_type_tdescs_arr
;
5441 static int builtin_type_tdescs_len
, builtin_type_tdescs_max
;
5444 /* Push the declarations of builtin types into the namespace.
5445 RID_INDEX, if < RID_MAX is the index of the builtin type
5446 in the array RID_POINTERS. NAME is the name used when looking
5447 up the builtin type. TYPE is the _TYPE node for the builtin type. */
5450 record_builtin_type (rid_index
, name
, type
)
5455 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
5456 tree tdecl
= NULL_TREE
;
5458 if ((int) rid_index
< (int) RID_MAX
)
5459 rname
= ridpointers
[(int) rid_index
];
5461 tname
= get_identifier (name
);
5463 TYPE_BUILT_IN (type
) = 1;
5467 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
5468 set_identifier_type_value (tname
, NULL_TREE
);
5469 if ((int) rid_index
< (int) RID_MAX
)
5470 /* Built-in types live in the global namespace. */
5471 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
5473 if (rname
!= NULL_TREE
)
5475 if (tname
!= NULL_TREE
)
5477 set_identifier_type_value (rname
, NULL_TREE
);
5478 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
5482 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
5483 set_identifier_type_value (rname
, NULL_TREE
);
5488 /* Record one of the standard Java types.
5489 * Declare it as having the given NAME.
5490 * If SIZE > 0, it is the size of one of the integral types;
5491 * otherwise it is the negative of the size of one of the other types. */
5494 record_builtin_java_type (name
, size
)
5500 type
= make_signed_type (size
);
5501 else if (size
> -32)
5502 { /* "__java_char" or ""__java_boolean". */
5503 type
= make_unsigned_type (-size
);
5504 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5507 { /* "__java_float" or ""__java_double". */
5508 type
= make_node (REAL_TYPE
);
5509 TYPE_PRECISION (type
) = - size
;
5512 record_builtin_type (RID_MAX
, name
, type
);
5513 decl
= TYPE_NAME (type
);
5514 DECL_IGNORED_P (decl
) = 1;
5515 TYPE_FOR_JAVA (type
) = 1;
5519 /* Push a type into the namespace so that the back-ends ignore it. */
5522 record_unknown_type (type
, name
)
5526 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
5527 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
5528 DECL_IGNORED_P (decl
) = 1;
5529 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
5530 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
5531 TYPE_ALIGN (type
) = 1;
5532 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
5535 /* Push overloaded decl, in global scope, with one argument so it
5536 can be used as a callback from define_function. */
5539 push_overloaded_decl_1 (x
)
5542 push_overloaded_decl (x
, 0);
5549 auto_function (name
, type
, code
)
5551 enum built_in_function code
;
5553 return define_function
5554 (IDENTIFIER_POINTER (name
), type
, code
, push_overloaded_decl_1
,
5555 IDENTIFIER_POINTER (build_decl_overload (name
, TYPE_ARG_TYPES (type
),
5559 /* Create the predefined scalar types of C,
5560 and some nodes representing standard constants (0, 1, (void *)0).
5561 Initialize the global binding level.
5562 Make definitions for built-in primitive functions. */
5565 init_decl_processing ()
5567 register tree endlink
, int_endlink
, double_endlink
, unsigned_endlink
;
5569 /* Data type of memcpy. */
5570 tree memcpy_ftype
, strlen_ftype
;
5571 int wchar_type_size
;
5573 tree array_domain_type
;
5574 tree vb_off_identifier
= NULL_TREE
;
5575 /* Function type `char *(char *, char *)' and similar ones */
5576 tree string_ftype_ptr_ptr
, int_ftype_string_string
;
5577 tree sizetype_endlink
;
5578 tree ptr_ftype
, ptr_ftype_unsigned
, ptr_ftype_sizetype
;
5579 tree void_ftype
, void_ftype_int
, void_ftype_ptr
;
5581 /* Have to make these distinct before we try using them. */
5582 lang_name_cplusplus
= get_identifier ("C++");
5583 lang_name_c
= get_identifier ("C");
5584 lang_name_java
= get_identifier ("Java");
5586 /* Enter the global namespace. */
5587 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
5588 my_friendly_assert (current_lang_name
== NULL_TREE
, 375);
5589 current_lang_name
= lang_name_cplusplus
;
5590 push_namespace (get_identifier ("::"));
5591 global_namespace
= current_namespace
;
5592 current_lang_name
= NULL_TREE
;
5594 if (flag_strict_prototype
== 2)
5595 flag_strict_prototype
= pedantic
;
5597 strict_prototypes_lang_c
= flag_strict_prototype
;
5600 current_lang_name
= lang_name_c
;
5602 current_function_decl
= NULL_TREE
;
5603 named_labels
= NULL_TREE
;
5604 named_label_uses
= NULL
;
5605 current_binding_level
= NULL_BINDING_LEVEL
;
5606 free_binding_level
= NULL_BINDING_LEVEL
;
5608 #ifndef __CYGWIN32__
5609 /* Because most segmentation signals can be traced back into user
5610 code, catch them and at least give the user a chance of working
5611 around compiler bugs. */
5612 signal (SIGSEGV
, signal_catch
);
5614 /* We will also catch aborts in the back-end through signal_catch and
5615 give the user a chance to see where the error might be, and to defeat
5616 aborts in the back-end when there have been errors previously in their
5619 signal (SIGIOT
, signal_catch
);
5622 signal (SIGILL
, signal_catch
);
5625 signal (SIGABRT
, signal_catch
);
5628 signal (SIGBUS
, signal_catch
);
5630 #else /* ndef __CYGWIN32__ */
5631 /* Cygwin32 cannot handle catching signals other than
5632 SIGABRT yet. We hope this will cease to be the case soon. */
5634 signal (SIGABRT
, signal_catch
);
5636 #endif /* ndef __CYGWIN32__ */
5638 gcc_obstack_init (&decl_obstack
);
5640 /* Must lay these out before anything else gets laid out. */
5641 error_mark_node
= make_node (ERROR_MARK
);
5642 TREE_PERMANENT (error_mark_node
) = 1;
5643 TREE_TYPE (error_mark_node
) = error_mark_node
;
5644 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
5645 TREE_TYPE (error_mark_list
) = error_mark_node
;
5647 /* Make the binding_level structure for global names. */
5649 global_binding_level
= current_binding_level
;
5650 /* The global level is the namespace level of ::. */
5651 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
5652 declare_namespace_level ();
5654 this_identifier
= get_identifier (THIS_NAME
);
5655 in_charge_identifier
= get_identifier (IN_CHARGE_NAME
);
5656 ctor_identifier
= get_identifier (CTOR_NAME
);
5657 dtor_identifier
= get_identifier (DTOR_NAME
);
5658 pfn_identifier
= get_identifier (VTABLE_PFN_NAME
);
5659 index_identifier
= get_identifier (VTABLE_INDEX_NAME
);
5660 delta_identifier
= get_identifier (VTABLE_DELTA_NAME
);
5661 delta2_identifier
= get_identifier (VTABLE_DELTA2_NAME
);
5662 pfn_or_delta2_identifier
= get_identifier ("__pfn_or_delta2");
5663 if (flag_handle_signatures
)
5665 tag_identifier
= get_identifier (SIGTABLE_TAG_NAME
);
5666 vb_off_identifier
= get_identifier (SIGTABLE_VB_OFF_NAME
);
5667 vt_off_identifier
= get_identifier (SIGTABLE_VT_OFF_NAME
);
5670 /* Define `int' and `char' first so that dbx will output them first. */
5672 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
5673 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
5675 /* Define `char', which is like either `signed char' or `unsigned char'
5676 but not the same as either. */
5680 ? make_signed_type (CHAR_TYPE_SIZE
)
5681 : make_unsigned_type (CHAR_TYPE_SIZE
));
5682 record_builtin_type (RID_CHAR
, "char", char_type_node
);
5684 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
5685 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
5687 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
5688 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
5690 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
5691 record_builtin_type (RID_MAX
, "long unsigned int", long_unsigned_type_node
);
5692 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
5694 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
5695 record_builtin_type (RID_MAX
, "long long int", long_long_integer_type_node
);
5697 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
5698 record_builtin_type (RID_MAX
, "long long unsigned int",
5699 long_long_unsigned_type_node
);
5700 record_builtin_type (RID_MAX
, "long long unsigned",
5701 long_long_unsigned_type_node
);
5703 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
5704 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
5705 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
5706 record_builtin_type (RID_MAX
, "short unsigned int", short_unsigned_type_node
);
5707 record_builtin_type (RID_MAX
, "unsigned short", short_unsigned_type_node
);
5709 /* `unsigned long' is the standard type for sizeof.
5710 Note that stddef.h uses `unsigned long',
5711 and this must agree, even if long and int are the same size. */
5713 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
5716 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
5718 /* Define both `signed char' and `unsigned char'. */
5719 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
5720 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
5721 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
5722 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
5724 /* These are types that type_for_size and type_for_mode use. */
5725 intQI_type_node
= make_signed_type (GET_MODE_BITSIZE (QImode
));
5726 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
5727 intHI_type_node
= make_signed_type (GET_MODE_BITSIZE (HImode
));
5728 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
5729 intSI_type_node
= make_signed_type (GET_MODE_BITSIZE (SImode
));
5730 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
5731 intDI_type_node
= make_signed_type (GET_MODE_BITSIZE (DImode
));
5732 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
5733 #if HOST_BITS_PER_WIDE_INT >= 64
5734 intTI_type_node
= make_signed_type (GET_MODE_BITSIZE (TImode
));
5735 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intTI_type_node
));
5737 unsigned_intQI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (QImode
));
5738 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
5739 unsigned_intHI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (HImode
));
5740 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
5741 unsigned_intSI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (SImode
));
5742 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
5743 unsigned_intDI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (DImode
));
5744 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
5745 #if HOST_BITS_PER_WIDE_INT >= 64
5746 unsigned_intTI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (TImode
));
5747 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intTI_type_node
));
5750 float_type_node
= make_node (REAL_TYPE
);
5751 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
5752 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
5753 layout_type (float_type_node
);
5755 double_type_node
= make_node (REAL_TYPE
);
5756 if (flag_short_double
)
5757 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
5759 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
5760 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
5761 layout_type (double_type_node
);
5763 long_double_type_node
= make_node (REAL_TYPE
);
5764 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
5765 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
5766 layout_type (long_double_type_node
);
5768 complex_integer_type_node
= make_node (COMPLEX_TYPE
);
5769 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
5770 complex_integer_type_node
));
5771 TREE_TYPE (complex_integer_type_node
) = integer_type_node
;
5772 layout_type (complex_integer_type_node
);
5774 complex_float_type_node
= make_node (COMPLEX_TYPE
);
5775 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
5776 complex_float_type_node
));
5777 TREE_TYPE (complex_float_type_node
) = float_type_node
;
5778 layout_type (complex_float_type_node
);
5780 complex_double_type_node
= make_node (COMPLEX_TYPE
);
5781 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
5782 complex_double_type_node
));
5783 TREE_TYPE (complex_double_type_node
) = double_type_node
;
5784 layout_type (complex_double_type_node
);
5786 complex_long_double_type_node
= make_node (COMPLEX_TYPE
);
5787 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
5788 complex_long_double_type_node
));
5789 TREE_TYPE (complex_long_double_type_node
) = long_double_type_node
;
5790 layout_type (complex_long_double_type_node
);
5792 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
5793 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
5794 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
5795 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
5796 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
5797 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
5798 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
5799 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
5801 integer_zero_node
= build_int_2 (0, 0);
5802 TREE_TYPE (integer_zero_node
) = integer_type_node
;
5803 integer_one_node
= build_int_2 (1, 0);
5804 TREE_TYPE (integer_one_node
) = integer_type_node
;
5805 integer_two_node
= build_int_2 (2, 0);
5806 TREE_TYPE (integer_two_node
) = integer_type_node
;
5807 integer_three_node
= build_int_2 (3, 0);
5808 TREE_TYPE (integer_three_node
) = integer_type_node
;
5810 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
5811 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
5812 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
5813 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
5814 TYPE_PRECISION (boolean_type_node
) = 1;
5815 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
5816 boolean_false_node
= build_int_2 (0, 0);
5817 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
5818 boolean_true_node
= build_int_2 (1, 0);
5819 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
5821 /* These are needed by stor-layout.c. */
5822 size_zero_node
= size_int (0);
5823 size_one_node
= size_int (1);
5825 signed_size_zero_node
= build_int_2 (0, 0);
5826 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
5828 void_type_node
= make_node (VOID_TYPE
);
5829 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
5830 layout_type (void_type_node
); /* Uses integer_zero_node. */
5831 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
5832 TREE_PARMLIST (void_list_node
) = 1;
5834 null_pointer_node
= build_int_2 (0, 0);
5835 TREE_TYPE (null_pointer_node
) = build_pointer_type (void_type_node
);
5836 layout_type (TREE_TYPE (null_pointer_node
));
5838 /* Used for expressions that do nothing, but are not errors. */
5839 void_zero_node
= build_int_2 (0, 0);
5840 TREE_TYPE (void_zero_node
) = void_type_node
;
5842 string_type_node
= build_pointer_type (char_type_node
);
5843 const_string_type_node
5844 = build_pointer_type (build_qualified_type (char_type_node
,
5847 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
5850 /* Make a type to be the domain of a few array types
5851 whose domains don't really matter.
5852 200 is small enough that it always fits in size_t
5853 and large enough that it can hold most function names for the
5854 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5855 array_domain_type
= build_index_type (build_int_2 (200, 0));
5857 /* Make a type for arrays of characters.
5858 With luck nothing will ever really depend on the length of this
5860 char_array_type_node
5861 = build_array_type (char_type_node
, array_domain_type
);
5862 /* Likewise for arrays of ints. */
5864 = build_array_type (integer_type_node
, array_domain_type
);
5866 /* This is just some anonymous class type. Nobody should ever
5867 need to look inside this envelope. */
5868 class_star_type_node
= build_pointer_type (make_lang_type (RECORD_TYPE
));
5870 default_function_type
5871 = build_function_type (integer_type_node
, NULL_TREE
);
5873 ptr_type_node
= build_pointer_type (void_type_node
);
5875 = build_pointer_type (build_qualified_type (void_type_node
,
5878 record_builtin_type (RID_MAX
, NULL_PTR
, ptr_type_node
);
5880 endlink
= void_list_node
;
5881 int_endlink
= tree_cons (NULL_TREE
, integer_type_node
, endlink
);
5882 double_endlink
= tree_cons (NULL_TREE
, double_type_node
, endlink
);
5883 unsigned_endlink
= tree_cons (NULL_TREE
, unsigned_type_node
, endlink
);
5885 ptr_ftype
= build_function_type (ptr_type_node
, NULL_TREE
);
5886 ptr_ftype_unsigned
= build_function_type (ptr_type_node
, unsigned_endlink
);
5887 sizetype_endlink
= tree_cons (NULL_TREE
, sizetype
, endlink
);
5888 /* We realloc here because sizetype could be int or unsigned. S'ok. */
5889 ptr_ftype_sizetype
= build_function_type (ptr_type_node
, sizetype_endlink
);
5891 void_ftype
= build_function_type (void_type_node
, endlink
);
5892 void_ftype_int
= build_function_type (void_type_node
, int_endlink
);
5894 = build_function_type (void_type_node
,
5895 tree_cons (NULL_TREE
, ptr_type_node
, endlink
));
5897 = build_exception_variant (void_ftype_ptr
,
5898 tree_cons (NULL_TREE
, NULL_TREE
, NULL_TREE
));
5901 = build_function_type (float_type_node
,
5902 tree_cons (NULL_TREE
, float_type_node
, endlink
));
5905 = build_function_type (double_type_node
, double_endlink
);
5907 ldouble_ftype_ldouble
5908 = build_function_type (long_double_type_node
,
5909 tree_cons (NULL_TREE
, long_double_type_node
,
5912 double_ftype_double_double
5913 = build_function_type (double_type_node
,
5914 tree_cons (NULL_TREE
, double_type_node
,
5918 = build_function_type (integer_type_node
, int_endlink
);
5921 = build_function_type (long_integer_type_node
,
5922 tree_cons (NULL_TREE
, long_integer_type_node
,
5925 int_ftype_cptr_cptr_sizet
5926 = build_function_type (integer_type_node
,
5927 tree_cons (NULL_TREE
, const_ptr_type_node
,
5928 tree_cons (NULL_TREE
, const_ptr_type_node
,
5929 tree_cons (NULL_TREE
,
5933 string_ftype_ptr_ptr
/* strcpy prototype */
5934 = build_function_type (string_type_node
,
5935 tree_cons (NULL_TREE
, string_type_node
,
5936 tree_cons (NULL_TREE
,
5937 const_string_type_node
,
5940 int_ftype_string_string
/* strcmp prototype */
5941 = build_function_type (integer_type_node
,
5942 tree_cons (NULL_TREE
, const_string_type_node
,
5943 tree_cons (NULL_TREE
,
5944 const_string_type_node
,
5947 strlen_ftype
/* strlen prototype */
5948 = build_function_type (sizetype
,
5949 tree_cons (NULL_TREE
, const_string_type_node
,
5952 memcpy_ftype
/* memcpy prototype */
5953 = build_function_type (ptr_type_node
,
5954 tree_cons (NULL_TREE
, ptr_type_node
,
5955 tree_cons (NULL_TREE
, const_ptr_type_node
,
5956 sizetype_endlink
)));
5958 if (flag_huge_objects
)
5959 delta_type_node
= long_integer_type_node
;
5961 delta_type_node
= short_integer_type_node
;
5963 builtin_function ("__builtin_constant_p", default_function_type
,
5964 BUILT_IN_CONSTANT_P
, NULL_PTR
);
5966 builtin_return_address_fndecl
5967 = builtin_function ("__builtin_return_address", ptr_ftype_unsigned
,
5968 BUILT_IN_RETURN_ADDRESS
, NULL_PTR
);
5970 builtin_function ("__builtin_frame_address", ptr_ftype_unsigned
,
5971 BUILT_IN_FRAME_ADDRESS
, NULL_PTR
);
5973 builtin_function ("__builtin_alloca", ptr_ftype_sizetype
,
5974 BUILT_IN_ALLOCA
, "alloca");
5975 builtin_function ("__builtin_ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
5976 /* Define alloca, ffs as builtins.
5977 Declare _exit just to mark it as volatile. */
5978 if (! flag_no_builtin
&& !flag_no_nonansi_builtin
)
5980 temp
= builtin_function ("alloca", ptr_ftype_sizetype
,
5981 BUILT_IN_ALLOCA
, NULL_PTR
);
5982 /* Suppress error if redefined as a non-function. */
5983 DECL_BUILT_IN_NONANSI (temp
) = 1;
5984 temp
= builtin_function ("ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
5985 /* Suppress error if redefined as a non-function. */
5986 DECL_BUILT_IN_NONANSI (temp
) = 1;
5987 temp
= builtin_function ("_exit", void_ftype_int
,
5988 NOT_BUILT_IN
, NULL_PTR
);
5989 TREE_THIS_VOLATILE (temp
) = 1;
5990 TREE_SIDE_EFFECTS (temp
) = 1;
5991 /* Suppress error if redefined as a non-function. */
5992 DECL_BUILT_IN_NONANSI (temp
) = 1;
5995 builtin_function ("__builtin_abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
5996 builtin_function ("__builtin_fabsf", float_ftype_float
, BUILT_IN_FABS
,
5998 builtin_function ("__builtin_fabs", double_ftype_double
, BUILT_IN_FABS
,
6000 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
6002 builtin_function ("__builtin_labs", long_ftype_long
,
6003 BUILT_IN_LABS
, NULL_PTR
);
6004 builtin_function ("__builtin_saveregs", ptr_ftype
,
6005 BUILT_IN_SAVEREGS
, NULL_PTR
);
6006 builtin_function ("__builtin_classify_type", default_function_type
,
6007 BUILT_IN_CLASSIFY_TYPE
, NULL_PTR
);
6008 builtin_function ("__builtin_next_arg", ptr_ftype
,
6009 BUILT_IN_NEXT_ARG
, NULL_PTR
);
6010 builtin_function ("__builtin_args_info", int_ftype_int
,
6011 BUILT_IN_ARGS_INFO
, NULL_PTR
);
6012 builtin_function ("__builtin_setjmp",
6013 build_function_type (integer_type_node
,
6014 tree_cons (NULL_TREE
, ptr_type_node
,
6016 BUILT_IN_SETJMP
, NULL_PTR
);
6017 builtin_function ("__builtin_longjmp",
6018 build_function_type (integer_type_node
,
6019 tree_cons (NULL_TREE
, ptr_type_node
,
6020 tree_cons (NULL_TREE
,
6023 BUILT_IN_LONGJMP
, NULL_PTR
);
6025 /* Untyped call and return. */
6026 builtin_function ("__builtin_apply_args", ptr_ftype
,
6027 BUILT_IN_APPLY_ARGS
, NULL_PTR
);
6029 temp
= tree_cons (NULL_TREE
,
6030 build_pointer_type (build_function_type (void_type_node
,
6032 tree_cons (NULL_TREE
, ptr_ftype_sizetype
, NULL_TREE
));
6033 builtin_function ("__builtin_apply",
6034 build_function_type (ptr_type_node
, temp
),
6035 BUILT_IN_APPLY
, NULL_PTR
);
6036 builtin_function ("__builtin_return", void_ftype_ptr
,
6037 BUILT_IN_RETURN
, NULL_PTR
);
6039 /* Currently under experimentation. */
6040 builtin_function ("__builtin_memcpy", memcpy_ftype
,
6041 BUILT_IN_MEMCPY
, "memcpy");
6042 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet
,
6043 BUILT_IN_MEMCMP
, "memcmp");
6044 builtin_function ("__builtin_strcmp", int_ftype_string_string
,
6045 BUILT_IN_STRCMP
, "strcmp");
6046 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr
,
6047 BUILT_IN_STRCPY
, "strcpy");
6048 builtin_function ("__builtin_strlen", strlen_ftype
,
6049 BUILT_IN_STRLEN
, "strlen");
6050 builtin_function ("__builtin_sqrtf", float_ftype_float
,
6051 BUILT_IN_FSQRT
, "sqrtf");
6052 builtin_function ("__builtin_fsqrt", double_ftype_double
,
6053 BUILT_IN_FSQRT
, NULL_PTR
);
6054 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble
,
6055 BUILT_IN_FSQRT
, "sqrtl");
6056 builtin_function ("__builtin_sinf", float_ftype_float
,
6057 BUILT_IN_SIN
, "sinf");
6058 builtin_function ("__builtin_sin", double_ftype_double
,
6059 BUILT_IN_SIN
, "sin");
6060 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble
,
6061 BUILT_IN_SIN
, "sinl");
6062 builtin_function ("__builtin_cosf", float_ftype_float
,
6063 BUILT_IN_COS
, "cosf");
6064 builtin_function ("__builtin_cos", double_ftype_double
,
6065 BUILT_IN_COS
, "cos");
6066 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble
,
6067 BUILT_IN_COS
, "cosl");
6069 if (!flag_no_builtin
)
6071 builtin_function ("abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
6072 builtin_function ("fabs", double_ftype_double
, BUILT_IN_FABS
, NULL_PTR
);
6073 builtin_function ("labs", long_ftype_long
, BUILT_IN_LABS
, NULL_PTR
);
6074 builtin_function ("fabsf", float_ftype_float
, BUILT_IN_FABS
, NULL_PTR
);
6075 builtin_function ("fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
6077 builtin_function ("memcpy", memcpy_ftype
, BUILT_IN_MEMCPY
, NULL_PTR
);
6078 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet
, BUILT_IN_MEMCMP
,
6080 builtin_function ("strcmp", int_ftype_string_string
, BUILT_IN_STRCMP
,
6082 builtin_function ("strcpy", string_ftype_ptr_ptr
, BUILT_IN_STRCPY
,
6084 builtin_function ("strlen", strlen_ftype
, BUILT_IN_STRLEN
, NULL_PTR
);
6085 builtin_function ("sqrtf", float_ftype_float
, BUILT_IN_FSQRT
, NULL_PTR
);
6086 builtin_function ("sqrt", double_ftype_double
, BUILT_IN_FSQRT
, NULL_PTR
);
6087 builtin_function ("sqrtl", ldouble_ftype_ldouble
, BUILT_IN_FSQRT
,
6089 builtin_function ("sinf", float_ftype_float
, BUILT_IN_SIN
, NULL_PTR
);
6090 builtin_function ("sin", double_ftype_double
, BUILT_IN_SIN
, NULL_PTR
);
6091 builtin_function ("sinl", ldouble_ftype_ldouble
, BUILT_IN_SIN
, NULL_PTR
);
6092 builtin_function ("cosf", float_ftype_float
, BUILT_IN_COS
, NULL_PTR
);
6093 builtin_function ("cos", double_ftype_double
, BUILT_IN_COS
, NULL_PTR
);
6094 builtin_function ("cosl", ldouble_ftype_ldouble
, BUILT_IN_COS
, NULL_PTR
);
6096 /* Declare these functions volatile
6097 to avoid spurious "control drops through" warnings. */
6098 temp
= builtin_function ("abort", void_ftype
,
6099 NOT_BUILT_IN
, NULL_PTR
);
6100 TREE_THIS_VOLATILE (temp
) = 1;
6101 TREE_SIDE_EFFECTS (temp
) = 1;
6102 /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
6104 DECL_BUILT_IN_NONANSI (temp
) = 1;
6105 temp
= builtin_function ("exit", void_ftype_int
,
6106 NOT_BUILT_IN
, NULL_PTR
);
6107 TREE_THIS_VOLATILE (temp
) = 1;
6108 TREE_SIDE_EFFECTS (temp
) = 1;
6109 DECL_BUILT_IN_NONANSI (temp
) = 1;
6113 /* Support for these has not been written in either expand_builtin
6114 or build_function_call. */
6115 builtin_function ("__builtin_div", default_ftype
, BUILT_IN_DIV
, NULL_PTR
);
6116 builtin_function ("__builtin_ldiv", default_ftype
, BUILT_IN_LDIV
, NULL_PTR
);
6117 builtin_function ("__builtin_ffloor", double_ftype_double
, BUILT_IN_FFLOOR
,
6119 builtin_function ("__builtin_fceil", double_ftype_double
, BUILT_IN_FCEIL
,
6121 builtin_function ("__builtin_fmod", double_ftype_double_double
,
6122 BUILT_IN_FMOD
, NULL_PTR
);
6123 builtin_function ("__builtin_frem", double_ftype_double_double
,
6124 BUILT_IN_FREM
, NULL_PTR
);
6125 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int
,
6126 BUILT_IN_MEMSET
, NULL_PTR
);
6127 builtin_function ("__builtin_getexp", double_ftype_double
, BUILT_IN_GETEXP
,
6129 builtin_function ("__builtin_getman", double_ftype_double
, BUILT_IN_GETMAN
,
6133 /* C++ extensions */
6135 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6136 record_unknown_type (unknown_type_node
, "unknown type");
6138 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6139 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6141 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6143 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6145 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6146 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6148 /* This is for handling opaque types in signatures. */
6149 opaque_type_node
= copy_node (ptr_type_node
);
6150 TYPE_MAIN_VARIANT (opaque_type_node
) = opaque_type_node
;
6151 record_builtin_type (RID_MAX
, 0, opaque_type_node
);
6153 /* This is special for C++ so functions can be overloaded. */
6155 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE
)));
6156 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6157 signed_wchar_type_node
= make_signed_type (wchar_type_size
);
6158 unsigned_wchar_type_node
= make_unsigned_type (wchar_type_size
);
6160 = TREE_UNSIGNED (wchar_type_node
)
6161 ? unsigned_wchar_type_node
6162 : signed_wchar_type_node
;
6163 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6165 /* Artificial declaration of wchar_t -- can be bashed */
6166 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6168 pushdecl (wchar_decl_node
);
6170 /* This is for wide string constants. */
6171 wchar_array_type_node
6172 = build_array_type (wchar_type_node
, array_domain_type
);
6174 if (flag_vtable_thunks
)
6176 /* Make sure we get a unique function type, so we can give
6177 its pointer type a name. (This wins for gdb.) */
6178 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6179 TREE_TYPE (vfunc_type
) = integer_type_node
;
6180 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6181 layout_type (vfunc_type
);
6183 vtable_entry_type
= build_pointer_type (vfunc_type
);
6187 vtable_entry_type
= make_lang_type (RECORD_TYPE
);
6188 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
6190 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
6192 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
6194 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6197 /* Make this part of an invisible union. */
6198 fields
[3] = copy_node (fields
[2]);
6199 TREE_TYPE (fields
[3]) = delta_type_node
;
6200 DECL_NAME (fields
[3]) = delta2_identifier
;
6201 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6202 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6203 TREE_UNSIGNED (fields
[3]) = 0;
6204 TREE_CHAIN (fields
[2]) = fields
[3];
6205 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6208 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6211 = build_array_type (vtable_entry_type
, NULL_TREE
);
6212 layout_type (vtbl_type_node
);
6213 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6214 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6215 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6216 layout_type (vtbl_ptr_type_node
);
6217 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6219 /* Simplify life by making a "sigtable_entry_type". Give its
6220 fields names so that the debugger can use them. */
6222 if (flag_handle_signatures
)
6224 sigtable_entry_type
= make_lang_type (RECORD_TYPE
);
6225 fields
[0] = build_lang_field_decl (FIELD_DECL
, tag_identifier
,
6227 fields
[1] = build_lang_field_decl (FIELD_DECL
, vb_off_identifier
,
6229 fields
[2] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
6231 fields
[3] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
6233 fields
[4] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
6236 /* Set the alignment to the max of the alignment of ptr_type_node and
6237 delta_type_node. Double alignment wastes a word on the Sparc. */
6238 finish_builtin_type (sigtable_entry_type
, SIGTABLE_PTR_TYPE
, fields
, 4,
6239 (TYPE_ALIGN (ptr_type_node
) > TYPE_ALIGN (delta_type_node
))
6243 /* Make this part of an invisible union. */
6244 fields
[5] = copy_node (fields
[4]);
6245 TREE_TYPE (fields
[5]) = delta_type_node
;
6246 DECL_NAME (fields
[5]) = vt_off_identifier
;
6247 DECL_MODE (fields
[5]) = TYPE_MODE (delta_type_node
);
6248 DECL_SIZE (fields
[5]) = TYPE_SIZE (delta_type_node
);
6249 TREE_UNSIGNED (fields
[5]) = 0;
6250 TREE_CHAIN (fields
[4]) = fields
[5];
6252 sigtable_entry_type
= build_qualified_type (sigtable_entry_type
,
6254 record_builtin_type (RID_MAX
, SIGTABLE_PTR_TYPE
, sigtable_entry_type
);
6257 std_node
= build_decl (NAMESPACE_DECL
,
6258 get_identifier (flag_honor_std
? "fake std":"std"),
6260 pushdecl (std_node
);
6262 global_type_node
= make_node (LANG_TYPE
);
6263 record_unknown_type (global_type_node
, "global type");
6266 current_lang_name
= lang_name_cplusplus
;
6269 tree bad_alloc_type_node
, newtype
, deltype
;
6271 push_namespace (get_identifier ("std"));
6272 bad_alloc_type_node
= xref_tag
6273 (class_type_node
, get_identifier ("bad_alloc"), 1);
6276 newtype
= build_exception_variant
6277 (ptr_ftype_sizetype
, build_tree_list (NULL_TREE
, bad_alloc_type_node
));
6278 deltype
= build_exception_variant
6279 (void_ftype_ptr
, build_tree_list (NULL_TREE
, NULL_TREE
));
6280 auto_function (ansi_opname
[(int) NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6281 auto_function (ansi_opname
[(int) VEC_NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6282 auto_function (ansi_opname
[(int) DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6283 auto_function (ansi_opname
[(int) VEC_DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6287 = define_function ("__pure_virtual", void_ftype
,
6288 NOT_BUILT_IN
, 0, 0);
6290 /* Perform other language dependent initializations. */
6291 init_class_processing ();
6292 init_init_processing ();
6293 init_search_processing ();
6295 init_rtti_processing ();
6297 if (flag_exceptions
)
6298 init_exception_processing ();
6301 flag_inline_functions
= 0;
6304 if (! supports_one_only ())
6307 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6308 declare_function_name ();
6310 /* Prepare to check format strings against argument lists. */
6311 init_function_format_info ();
6313 /* Show we use EH for cleanups. */
6314 using_eh_for_cleanups ();
6316 print_error_function
= lang_print_error_function
;
6317 lang_get_alias_set
= &c_get_alias_set
;
6319 /* Maintain consistency. Perhaps we should just complain if they
6320 say -fwritable-strings? */
6321 if (flag_writable_strings
)
6322 flag_const_strings
= 0;
6325 /* Function to print any language-specific context for an error message. */
6328 lang_print_error_function (file
)
6331 default_print_error_function (file
);
6332 maybe_print_template_context ();
6335 /* Make a definition for a builtin function named NAME and whose data type
6336 is TYPE. TYPE should be a function type with argument types.
6337 FUNCTION_CODE tells later passes how to compile calls to this function.
6338 See tree.h for its possible values.
6340 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6341 the name to be called if we can't opencode the function. */
6344 define_function (name
, type
, function_code
, pfn
, library_name
)
6347 enum built_in_function function_code
;
6348 void (*pfn
) PROTO((tree
));
6351 tree decl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), type
);
6352 DECL_EXTERNAL (decl
) = 1;
6353 TREE_PUBLIC (decl
) = 1;
6354 DECL_ARTIFICIAL (decl
) = 1;
6356 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6357 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
6359 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6360 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6361 function in the namespace. */
6362 if (pfn
) (*pfn
) (decl
);
6364 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
6365 make_function_rtl (decl
);
6366 if (function_code
!= NOT_BUILT_IN
)
6368 DECL_BUILT_IN (decl
) = 1;
6369 DECL_FUNCTION_CODE (decl
) = function_code
;
6374 /* When we call finish_struct for an anonymous union, we create
6375 default copy constructors and such. But, an anonymous union
6376 shouldn't have such things; this function undoes the damage to the
6377 anonymous union type T.
6379 (The reason that we create the synthesized methods is that we don't
6380 distinguish `union { int i; }' from `typedef union { int i; } U'.
6381 The first is an anonymous union; the second is just an ordinary
6385 fixup_anonymous_union (t
)
6390 /* Wipe out memory of synthesized methods */
6391 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6392 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6393 TYPE_HAS_INIT_REF (t
) = 0;
6394 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6395 TYPE_HAS_ASSIGN_REF (t
) = 0;
6396 TYPE_HAS_ASSIGNMENT (t
) = 0;
6397 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6399 /* Splice the implicitly generated functions out of the TYPE_METHODS
6401 q
= &TYPE_METHODS (t
);
6404 if (DECL_ARTIFICIAL (*q
))
6405 *q
= TREE_CHAIN (*q
);
6407 q
= &TREE_CHAIN (*q
);
6410 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
6411 function members. */
6412 if (TYPE_METHODS (t
))
6413 error ("an anonymous union cannot have function members");
6416 /* Called when a declaration is seen that contains no names to declare.
6417 If its type is a reference to a structure, union or enum inherited
6418 from a containing scope, shadow that tag name for the current scope
6419 with a forward reference.
6420 If its type defines a new named structure or union
6421 or defines an enum, it is valid but we need not do anything here.
6422 Otherwise, it is an error.
6424 C++: may have to grok the declspecs to learn about static,
6425 complain for anonymous unions. */
6428 shadow_tag (declspecs
)
6432 tree ob_modifier
= NULL_TREE
;
6434 register enum tree_code code
, ok_code
= ERROR_MARK
;
6435 register tree t
= NULL_TREE
;
6437 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6439 register tree value
= TREE_VALUE (link
);
6441 code
= TREE_CODE (value
);
6442 if (IS_AGGR_TYPE_CODE (code
) || code
== ENUMERAL_TYPE
)
6444 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
6446 maybe_process_partial_specialization (value
);
6452 else if (value
== ridpointers
[(int) RID_STATIC
]
6453 || value
== ridpointers
[(int) RID_EXTERN
]
6454 || value
== ridpointers
[(int) RID_AUTO
]
6455 || value
== ridpointers
[(int) RID_REGISTER
]
6456 || value
== ridpointers
[(int) RID_INLINE
]
6457 || value
== ridpointers
[(int) RID_VIRTUAL
]
6458 || value
== ridpointers
[(int) RID_EXPLICIT
])
6459 ob_modifier
= value
;
6462 /* This is where the variables in an anonymous union are
6463 declared. An anonymous union declaration looks like:
6465 because there is no declarator after the union, the parser
6466 sends that declaration here. */
6467 if (ok_code
== UNION_TYPE
6469 && ((TREE_CODE (TYPE_NAME (t
)) == IDENTIFIER_NODE
6470 && ANON_AGGRNAME_P (TYPE_NAME (t
)))
6471 || (TREE_CODE (TYPE_NAME (t
)) == TYPE_DECL
6472 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))))
6474 fixup_anonymous_union (t
);
6476 if (TYPE_FIELDS (t
))
6478 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
6480 finish_anon_union (decl
);
6485 /* Anonymous unions are objects, that's why we only check for
6486 inappropriate specifiers in this branch. */
6490 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
6491 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
6492 cp_error ("`%D' can only be specified for functions", ob_modifier
);
6493 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
6494 cp_error ("`%D' can only be specified for constructors",
6497 cp_error ("`%D' can only be specified for objects and functions",
6502 cp_error ("abstract declarator used as declaration");
6503 else if (found_tag
> 1)
6504 pedwarn ("multiple types in one declaration");
6508 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6511 groktypename (typename
)
6514 if (TREE_CODE (typename
) != TREE_LIST
)
6516 return grokdeclarator (TREE_VALUE (typename
),
6517 TREE_PURPOSE (typename
),
6518 TYPENAME
, 0, NULL_TREE
);
6521 /* Decode a declarator in an ordinary declaration or data definition.
6522 This is called as soon as the type information and variable name
6523 have been parsed, before parsing the initializer if any.
6524 Here we create the ..._DECL node, fill in its type,
6525 and put it on the list of decls for the current context.
6526 The ..._DECL node is returned as the value.
6528 Exception: for arrays where the length is not specified,
6529 the type is left null, to be filled in by `cp_finish_decl'.
6531 Function definitions do not come here; they go to start_function
6532 instead. However, external and forward declarations of functions
6533 do go through here. Structure field declarations are done by
6534 grokfield and not through here. */
6536 /* Set this to zero to debug not using the temporary obstack
6537 to parse initializers. */
6538 int debug_temp_inits
= 1;
6541 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
6542 tree declarator
, declspecs
;
6544 tree attributes
, prefix_attributes
;
6547 register tree type
, tem
;
6549 extern int have_extern_spec
;
6550 extern int used_extern_spec
;
6553 /* See code below that used this. */
6554 int init_written
= initialized
;
6557 /* This should only be done once on the top most decl. */
6558 if (have_extern_spec
&& !used_extern_spec
)
6560 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
6562 used_extern_spec
= 1;
6565 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
6567 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
6570 type
= TREE_TYPE (decl
);
6572 /* Don't lose if destructors must be executed at file-level. */
6573 if (! processing_template_decl
&& TREE_STATIC (decl
)
6574 && TYPE_NEEDS_DESTRUCTOR (complete_type (type
))
6575 && !TREE_PERMANENT (decl
))
6577 push_obstacks (&permanent_obstack
, &permanent_obstack
);
6578 decl
= copy_node (decl
);
6579 if (TREE_CODE (type
) == ARRAY_TYPE
)
6581 tree itype
= TYPE_DOMAIN (type
);
6582 if (itype
&& ! TREE_PERMANENT (itype
))
6584 itype
= build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype
)));
6585 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
6586 TREE_TYPE (decl
) = type
;
6593 = (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
6594 ? DECL_CLASS_CONTEXT (decl
)
6595 : DECL_CONTEXT (decl
);
6597 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
6598 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
6600 /* When parsing the initializer, lookup should use the object's
6602 push_decl_namespace (context
);
6605 /* We are only interested in class contexts, later. */
6606 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
6607 context
= NULL_TREE
;
6610 /* Is it valid for this decl to have an initializer at all?
6611 If not, set INITIALIZED to zero, which will indirectly
6612 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6613 switch (TREE_CODE (decl
))
6616 /* typedef foo = bar means give foo the same type as bar.
6617 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6618 Any other case of an initialization in a TYPE_DECL is an error. */
6619 if (pedantic
|| list_length (declspecs
) > 1)
6621 cp_error ("typedef `%D' is initialized", decl
);
6627 cp_error ("function `%#D' is initialized like a variable", decl
);
6632 if (! processing_template_decl
)
6634 if (type
!= error_mark_node
)
6636 if (TYPE_SIZE (type
) != NULL_TREE
6637 && ! TREE_CONSTANT (TYPE_SIZE (type
)))
6640 ("variable-sized object `%D' may not be initialized",
6645 if (TREE_CODE (type
) == ARRAY_TYPE
6646 && TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6649 ("elements of array `%#D' have incomplete type", decl
);
6658 if (! toplevel_bindings_p ()
6659 && DECL_EXTERNAL (decl
))
6660 cp_warning ("declaration of `%#D' has `extern' and is initialized",
6662 DECL_EXTERNAL (decl
) = 0;
6663 if (toplevel_bindings_p ())
6664 TREE_STATIC (decl
) = 1;
6666 /* Tell `pushdecl' this is an initialized decl
6667 even though we don't yet have the initializer expression.
6668 Also tell `cp_finish_decl' it may store the real initializer. */
6669 DECL_INITIAL (decl
) = error_mark_node
;
6672 if (context
&& TYPE_SIZE (complete_type (context
)) != NULL_TREE
)
6674 if (TREE_CODE (decl
) == VAR_DECL
)
6676 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
6677 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
6678 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
6681 if (DECL_CONTEXT (field
) != context
)
6683 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6684 DECL_CONTEXT (field
), DECL_NAME (decl
),
6685 context
, DECL_NAME (decl
));
6686 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
6688 /* Static data member are tricky; an in-class initialization
6689 still doesn't provide a definition, so the in-class
6690 declaration will have DECL_EXTERNAL set, but will have an
6691 initialization. Thus, duplicate_decls won't warn
6692 about this situation, and so we check here. */
6693 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
6694 cp_error ("duplicate initialization of %D", decl
);
6695 if (duplicate_decls (decl
, field
))
6701 tree field
= check_classfn (context
, decl
);
6702 if (field
&& duplicate_decls (decl
, field
))
6706 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6707 DECL_IN_AGGR_P (decl
) = 0;
6708 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
6709 || CLASSTYPE_USE_TEMPLATE (context
))
6710 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
6712 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
6713 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6716 pushclass (context
, 2);
6719 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6720 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
6723 /* Set attributes here so if duplicate decl, will have proper attributes. */
6724 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
6726 /* Add this decl to the current binding level, but not if it
6727 comes from another scope, e.g. a static member variable.
6728 TEM may equal DECL or it may be a previous decl of the same name. */
6730 if ((TREE_CODE (decl
) != PARM_DECL
&& DECL_CONTEXT (decl
) != NULL_TREE
6731 /* Definitions of namespace members outside their namespace are
6733 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
6734 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
6735 || TREE_CODE (type
) == LANG_TYPE
6736 /* The declaration of template specializations does not affect
6737 the functions available for overload resolution, so we do not
6739 || (TREE_CODE (decl
) == FUNCTION_DECL
6740 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
6743 tem
= pushdecl (decl
);
6745 if (processing_template_decl
)
6747 if (! current_function_decl
)
6748 tem
= push_template_decl (tem
);
6749 else if (minimal_parse_mode
)
6751 = build_min_nt (DECL_STMT
, copy_to_permanent (declarator
),
6752 copy_to_permanent (declspecs
),
6757 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6758 /* Tell the back-end to use or not use .common as appropriate. If we say
6759 -fconserve-space, we want this to save .data space, at the expense of
6760 wrong semantics. If we say -fno-conserve-space, we want this to
6761 produce errors about redefs; to do this we force variables into the
6763 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
6766 if (! processing_template_decl
)
6769 /* Corresponding pop_obstacks is done in `cp_finish_decl'. */
6770 push_obstacks_nochange ();
6773 /* We have no way of knowing whether the initializer will need to be
6774 evaluated at run-time or not until we've parsed it, so let's just put
6775 it in the permanent obstack. (jason) */
6777 && ! (TREE_CODE (tem
) == PARM_DECL
6778 || (TREE_READONLY (tem
)
6779 && (TREE_CODE (tem
) == VAR_DECL
6780 || TREE_CODE (tem
) == FIELD_DECL
))))
6782 /* When parsing and digesting the initializer,
6783 use temporary storage. Do this even if we will ignore the value. */
6784 if (toplevel_bindings_p () && debug_temp_inits
)
6786 if (processing_template_decl
6787 || TYPE_NEEDS_CONSTRUCTING (type
)
6788 || TREE_CODE (type
) == REFERENCE_TYPE
)
6789 /* In this case, the initializer must lay down in permanent
6790 storage, since it will be saved until `finish_file' is run. */
6793 temporary_allocation ();
6805 tree type
= TREE_TYPE (decl
);
6806 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
6808 /* If this type of object needs a cleanup, and control may
6809 jump past it, make a new binding level so that it is cleaned
6810 up only when it is initialized first. */
6811 if (TYPE_NEEDS_DESTRUCTOR (type
)
6812 && current_binding_level
->more_cleanups_ok
== 0)
6813 pushlevel_temporary (1);
6816 /* Is it valid for this decl to have an initializer at all?
6817 If not, set INITIALIZED to zero, which will indirectly
6818 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6820 /* Don't allow initializations for incomplete types except for
6821 arrays which might be completed by the initialization. */
6822 if (type
== error_mark_node
)
6823 ; /* Don't complain again. */
6824 else if (TYPE_SIZE (complete_type (type
)) != NULL_TREE
)
6825 ; /* A complete type is ok. */
6826 else if (TREE_CODE (type
) != ARRAY_TYPE
)
6828 cp_error ("variable `%#D' has initializer but incomplete type",
6831 type
= TREE_TYPE (decl
) = error_mark_node
;
6833 else if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6835 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
6836 cp_error ("elements of array `%#D' have incomplete type", decl
);
6837 /* else we already gave an error in start_decl. */
6843 && TREE_CODE (decl
) != TYPE_DECL
6844 && TREE_CODE (decl
) != TEMPLATE_DECL
6845 && IS_AGGR_TYPE (type
) && ! DECL_EXTERNAL (decl
))
6847 if ((! processing_template_decl
|| ! uses_template_parms (type
))
6848 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
6850 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6852 /* Change the type so that assemble_variable will give
6853 DECL an rtl we can live with: (mem (const_int 0)). */
6854 type
= TREE_TYPE (decl
) = error_mark_node
;
6858 /* If any base type in the hierarchy of TYPE needs a constructor,
6859 then we set initialized to 1. This way any nodes which are
6860 created for the purposes of initializing this aggregate
6861 will live as long as it does. This is necessary for global
6862 aggregates which do not have their initializers processed until
6863 the end of the file. */
6864 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
6869 /* We don't do this yet for GNU C++. */
6870 /* For a local variable, define the RTL now. */
6871 if (! toplevel_bindings_p ()
6872 /* But not if this is a duplicate decl
6873 and we preserved the rtl from the previous one
6874 (which may or may not happen). */
6875 && DECL_RTL (tem
) == NULL_RTX
)
6877 if (TYPE_SIZE (TREE_TYPE (tem
)) != NULL_TREE
)
6879 else if (TREE_CODE (TREE_TYPE (tem
)) == ARRAY_TYPE
6880 && DECL_INITIAL (tem
) != NULL_TREE
)
6886 DECL_INITIAL (decl
) = NULL_TREE
;
6889 /* Handle initialization of references.
6890 These three arguments are from `cp_finish_decl', and have the
6891 same meaning here that they do there.
6893 Quotes on semantics can be found in ARM 8.4.3. */
6896 grok_reference_init (decl
, type
, init
)
6897 tree decl
, type
, init
;
6901 if (init
== NULL_TREE
)
6903 if ((DECL_LANG_SPECIFIC (decl
) == 0
6904 || DECL_IN_AGGR_P (decl
) == 0)
6905 && ! DECL_THIS_EXTERN (decl
))
6907 cp_error ("`%D' declared as reference but not initialized", decl
);
6908 if (TREE_CODE (decl
) == VAR_DECL
)
6909 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
6914 if (init
== error_mark_node
)
6917 if (TREE_CODE (type
) == REFERENCE_TYPE
6918 && TREE_CODE (init
) == CONSTRUCTOR
)
6920 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl
);
6924 if (TREE_TYPE (init
) && TREE_CODE (TREE_TYPE (init
)) == UNKNOWN_TYPE
)
6925 /* decay_conversion is probably wrong for references to functions. */
6926 init
= decay_conversion (instantiate_type (TREE_TYPE (type
), init
, 1));
6928 if (TREE_CODE (init
) == TREE_LIST
)
6929 init
= build_compound_expr (init
);
6931 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
6932 init
= convert_from_reference (init
);
6934 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
6935 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
6937 /* Note: default conversion is only called in very special cases. */
6938 init
= default_conversion (init
);
6941 tmp
= convert_to_reference
6942 (type
, init
, CONV_IMPLICIT
,
6943 LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
, decl
);
6945 if (tmp
== error_mark_node
)
6947 else if (tmp
!= NULL_TREE
)
6950 DECL_INITIAL (decl
) = save_expr (init
);
6954 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
6958 /* ?? Can this be optimized in some cases to
6959 hand back the DECL_INITIAL slot?? */
6960 if (TYPE_SIZE (TREE_TYPE (type
)))
6962 init
= convert_from_reference (decl
);
6963 if (TREE_PERMANENT (decl
))
6964 init
= copy_to_permanent (init
);
6965 SET_DECL_REFERENCE_SLOT (decl
, init
);
6968 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
6970 expand_static_init (decl
, DECL_INITIAL (decl
));
6971 DECL_INITIAL (decl
) = NULL_TREE
;
6976 if (TREE_CODE (decl
) == VAR_DECL
)
6977 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
6981 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6982 mucking with forces it does not comprehend (i.e. initialization with a
6983 constructor). If we are at global scope and won't go into COMMON, fill
6984 it in with a dummy CONSTRUCTOR to force the variable into .data;
6985 otherwise we can use error_mark_node. */
6988 obscure_complex_init (decl
, init
)
6991 if (! flag_no_inline
&& TREE_STATIC (decl
))
6993 if (extract_init (decl
, init
))
6997 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6998 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
6999 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
7003 DECL_INITIAL (decl
) = error_mark_node
;
7008 /* Issue an error message if DECL is an uninitialized const variable. */
7011 check_for_uninitialized_const_var (decl
)
7014 tree type
= TREE_TYPE (decl
);
7016 /* ``Unless explicitly declared extern, a const object does not have
7017 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7019 if (TREE_CODE (decl
) == VAR_DECL
7020 && TREE_CODE (type
) != REFERENCE_TYPE
7021 && CP_TYPE_CONST_P (type
)
7022 && !TYPE_NEEDS_CONSTRUCTING (type
)
7023 && !DECL_INITIAL (decl
))
7024 cp_error ("uninitialized const `%D'", decl
);
7027 /* Finish processing of a declaration;
7028 install its line number and initial value.
7029 If the length of an array type is not known before,
7030 it must be determined now, from the initial value, or it is an error.
7032 Call `pop_obstacks' iff NEED_POP is nonzero.
7034 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
7035 for aggregates that have constructors alive on the permanent obstack,
7036 so that the global initializing functions can be written at the end.
7038 INIT0 holds the value of an initializer that should be allowed to escape
7041 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7042 if the (init) syntax was used.
7044 For functions that take default parameters, DECL points to its
7045 "maximal" instantiation. `cp_finish_decl' must then also declared its
7046 subsequently lower and lower forms of instantiation, checking for
7047 ambiguity as it goes. This can be sped up later. */
7050 cp_finish_decl (decl
, init
, asmspec_tree
, need_pop
, flags
)
7057 tree cleanup
= NULL_TREE
, ttype
= NULL_TREE
;
7059 int temporary
= allocation_temporary_p ();
7060 char *asmspec
= NULL
;
7061 int was_readonly
= 0;
7062 int already_used
= 0;
7064 /* If this is 0, then we did not change obstacks. */
7068 error ("assignment (not initialization) in declaration");
7072 /* If a name was specified, get the string. */
7074 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
7076 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
7078 cp_error ("Cannot initialize `%D' to namespace `%D'",
7083 if (TREE_CODE (decl
) == VAR_DECL
7084 && DECL_CONTEXT (decl
)
7085 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
7086 && DECL_CONTEXT (decl
) != current_namespace
7089 /* Leave the namespace of the object. */
7090 pop_decl_namespace ();
7093 /* If the type of the thing we are declaring either has
7094 a constructor, or has a virtual function table pointer,
7095 AND its initialization was accepted by `start_decl',
7096 then we stayed on the permanent obstack through the
7097 declaration, otherwise, changed obstacks as GCC would. */
7099 type
= TREE_TYPE (decl
);
7101 if (type
== error_mark_node
)
7103 if (toplevel_bindings_p () && temporary
)
7104 end_temporary_allocation ();
7109 if (processing_template_decl
)
7111 if (init
&& DECL_INITIAL (decl
))
7112 DECL_INITIAL (decl
) = init
;
7113 if (minimal_parse_mode
&& ! DECL_ARTIFICIAL (decl
))
7115 tree stmt
= DECL_VINDEX (decl
);
7116 /* If the decl is declaring a member of a local class (in a
7117 template function), the DECL_VINDEX will either be NULL,
7118 or it will be an actual virtual function index, not a
7120 if (stmt
!= NULL_TREE
&& TREE_CODE (stmt
) == DECL_STMT
)
7122 DECL_VINDEX (decl
) = NULL_TREE
;
7123 TREE_OPERAND (stmt
, 2) = copy_to_permanent (init
);
7130 /* Take care of TYPE_DECLs up front. */
7131 if (TREE_CODE (decl
) == TYPE_DECL
)
7133 if (init
&& DECL_INITIAL (decl
))
7135 /* typedef foo = bar; store the type of bar as the type of foo. */
7136 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
7137 DECL_INITIAL (decl
) = init
= NULL_TREE
;
7139 if (type
!= error_mark_node
7140 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
7142 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7143 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
7144 set_identifier_type_value (DECL_NAME (decl
), type
);
7145 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
7147 GNU_xref_decl (current_function_decl
, decl
);
7149 /* If we have installed this as the canonical typedef for this
7150 type, and that type has not been defined yet, delay emitting
7151 the debug information for it, as we will emit it later. */
7152 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7153 && TYPE_SIZE (TREE_TYPE (decl
)) == NULL_TREE
)
7154 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
7156 rest_of_decl_compilation (decl
, NULL_PTR
,
7157 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
7160 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7162 ttype
= target_type (type
);
7165 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
7166 && TYPE_NEEDS_CONSTRUCTING (type
))
7169 /* Currently, GNU C++ puts constants in text space, making them
7170 impossible to initialize. In the future, one would hope for
7171 an operating system which understood the difference between
7172 initialization and the running of a program. */
7174 TREE_READONLY (decl
) = 0;
7177 if (TREE_CODE (decl
) == FIELD_DECL
)
7179 if (init
&& init
!= error_mark_node
)
7180 my_friendly_assert (TREE_PERMANENT (init
), 147);
7184 /* This must override the asm specifier which was placed
7185 by grokclassfn. Lay this out fresh. */
7186 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
7187 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7188 make_decl_rtl (decl
, asmspec
, 0);
7191 /* If `start_decl' didn't like having an initialization, ignore it now. */
7192 else if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7194 else if (DECL_EXTERNAL (decl
))
7196 else if (TREE_CODE (type
) == REFERENCE_TYPE
7197 || (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE_REFERENCE (type
)))
7199 if (TREE_STATIC (decl
))
7200 make_decl_rtl (decl
, NULL_PTR
,
7201 toplevel_bindings_p ()
7202 || pseudo_global_level_p ());
7203 grok_reference_init (decl
, type
, init
);
7207 GNU_xref_decl (current_function_decl
, decl
);
7209 if (TREE_CODE (decl
) == FIELD_DECL
)
7211 else if (TREE_CODE (decl
) == CONST_DECL
)
7213 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7215 DECL_INITIAL (decl
) = init
;
7217 /* This will keep us from needing to worry about our obstacks. */
7218 my_friendly_assert (init
!= NULL_TREE
, 149);
7223 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7225 if (TREE_CODE (type
) == ARRAY_TYPE
)
7226 init
= digest_init (type
, init
, (tree
*) 0);
7227 else if (TREE_CODE (init
) == CONSTRUCTOR
)
7229 if (TYPE_NON_AGGREGATE_CLASS (type
))
7231 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7233 init
= error_mark_node
;
7236 goto dont_use_constructor
;
7241 dont_use_constructor
:
7242 if (TREE_CODE (init
) != TREE_VEC
)
7243 init
= store_init_value (decl
, init
);
7247 /* We must hide the initializer so that expand_decl
7248 won't try to do something it does not understand. */
7249 init
= obscure_complex_init (decl
, init
);
7251 else if (DECL_EXTERNAL (decl
))
7253 else if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't'
7254 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7257 while (TREE_CODE (ctype
) == ARRAY_TYPE
)
7258 ctype
= TREE_TYPE (ctype
);
7259 if (! TYPE_NEEDS_CONSTRUCTING (ctype
))
7261 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype
))
7262 cp_error ("structure `%D' with uninitialized const members", decl
);
7263 if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype
))
7264 cp_error ("structure `%D' with uninitialized reference members",
7268 check_for_uninitialized_const_var (decl
);
7270 if (TYPE_SIZE (type
) != NULL_TREE
7271 && TYPE_NEEDS_CONSTRUCTING (type
))
7272 init
= obscure_complex_init (decl
, NULL_TREE
);
7276 check_for_uninitialized_const_var (decl
);
7278 /* For top-level declaration, the initial value was read in
7279 the temporary obstack. MAXINDEX, rtl, etc. to be made below
7280 must go in the permanent obstack; but don't discard the
7281 temporary data yet. */
7283 if (toplevel_bindings_p () && temporary
)
7284 end_temporary_allocation ();
7286 /* Deduce size of array from initialization, if not already known. */
7288 if (TREE_CODE (type
) == ARRAY_TYPE
7289 && TYPE_DOMAIN (type
) == NULL_TREE
7290 && TREE_CODE (decl
) != TYPE_DECL
)
7293 = (TREE_STATIC (decl
)
7294 /* Even if pedantic, an external linkage array
7295 may have incomplete type at first. */
7296 ? pedantic
&& ! DECL_EXTERNAL (decl
)
7297 : !DECL_EXTERNAL (decl
));
7298 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7299 int failure
= complete_array_type (type
, initializer
, do_default
);
7302 cp_error ("initializer fails to determine size of `%D'", decl
);
7307 cp_error ("array size missing in `%D'", decl
);
7308 /* If a `static' var's size isn't known, make it extern as
7309 well as static, so it does not get allocated. If it's not
7310 `static', then don't mark it extern; finish_incomplete_decl
7311 will give it a default size and it will get allocated. */
7312 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7313 DECL_EXTERNAL (decl
) = 1;
7316 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7317 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7319 cp_error ("zero-size array `%D'", decl
);
7321 layout_decl (decl
, 0);
7324 if (TREE_CODE (decl
) == VAR_DECL
)
7326 if (DECL_SIZE (decl
) == NULL_TREE
7327 && TYPE_SIZE (complete_type (TREE_TYPE (decl
))) != NULL_TREE
)
7328 layout_decl (decl
, 0);
7330 if (TREE_STATIC (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7332 /* A static variable with an incomplete type:
7333 that is an error if it is initialized.
7334 Otherwise, let it through, but if it is not `extern'
7335 then it may cause an error message later. */
7336 if (DECL_INITIAL (decl
) != NULL_TREE
)
7337 cp_error ("storage size of `%D' isn't known", decl
);
7340 else if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7342 /* An automatic variable with an incomplete type: that is an error.
7343 Don't talk about array types here, since we took care of that
7344 message in grokdeclarator. */
7345 cp_error ("storage size of `%D' isn't known", decl
);
7346 TREE_TYPE (decl
) = error_mark_node
;
7348 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7349 /* Let debugger know it should output info for this type. */
7350 note_debug_info_needed (ttype
);
7352 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7353 note_debug_info_needed (DECL_CONTEXT (decl
));
7355 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7356 && DECL_SIZE (decl
) != NULL_TREE
7357 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7359 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7360 constant_expression_warning (DECL_SIZE (decl
));
7362 cp_error ("storage size of `%D' isn't constant", decl
);
7365 if (! DECL_EXTERNAL (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
7366 /* Cleanups for static variables are handled by `finish_file'. */
7367 && ! TREE_STATIC (decl
))
7369 int yes
= suspend_momentary ();
7370 cleanup
= maybe_build_cleanup (decl
);
7371 resume_momentary (yes
);
7374 /* PARM_DECLs get cleanups, too. */
7375 else if (TREE_CODE (decl
) == PARM_DECL
&& TYPE_NEEDS_DESTRUCTOR (type
))
7378 end_temporary_allocation ();
7379 cleanup
= maybe_build_cleanup (decl
);
7381 resume_temporary_allocation ();
7384 /* Output the assembler code and/or RTL code for variables and functions,
7385 unless the type is an undefined structure or union.
7386 If not, it will get done when the type is completed. */
7388 was_incomplete
= (DECL_SIZE (decl
) == NULL_TREE
);
7390 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
7391 || TREE_CODE (decl
) == RESULT_DECL
)
7393 /* ??? FIXME: What about nested classes? */
7394 int toplev
= toplevel_bindings_p () || pseudo_global_level_p ();
7396 = (TREE_STATIC (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
7397 && allocation_temporary_p ());
7400 end_temporary_allocation ();
7402 /* Static data in a function with comdat linkage also has comdat
7404 if (TREE_CODE (decl
) == VAR_DECL
7405 && TREE_STATIC (decl
)
7406 /* Don't mess with __FUNCTION__. */
7407 && ! TREE_ASM_WRITTEN (decl
)
7408 && current_function_decl
7409 && DECL_CONTEXT (decl
) == current_function_decl
7410 && (DECL_THIS_INLINE (current_function_decl
)
7411 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7412 && TREE_PUBLIC (current_function_decl
))
7414 /* Rather than try to get this right with inlining, we suppress
7415 inlining of such functions. */
7416 current_function_cannot_inline
7417 = "function with static variable cannot be inline";
7419 /* If flag_weak, we don't need to mess with this, as we can just
7420 make the function weak, and let it refer to its unique local
7421 copy. This works because we don't allow the function to be
7425 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7427 TREE_PUBLIC (decl
) = 1;
7428 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7430 else if (DECL_INITIAL (decl
) == NULL_TREE
7431 || DECL_INITIAL (decl
) == error_mark_node
)
7433 TREE_PUBLIC (decl
) = 1;
7434 DECL_COMMON (decl
) = 1;
7436 /* else we lose. We can only do this if we can use common,
7437 which we can't if it has been initialized. */
7439 if (TREE_PUBLIC (decl
))
7440 DECL_ASSEMBLER_NAME (decl
)
7441 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7442 else if (! DECL_ARTIFICIAL (decl
))
7444 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7445 cp_warning_at (" you can work around this by removing the initializer"), decl
;
7450 else if (TREE_CODE (decl
) == VAR_DECL
7451 && DECL_LANG_SPECIFIC (decl
)
7452 && DECL_COMDAT (decl
))
7454 /* Dynamically initialized vars go into common. */
7455 if (DECL_INITIAL (decl
) == NULL_TREE
7456 || DECL_INITIAL (decl
) == error_mark_node
)
7457 DECL_COMMON (decl
) = 1;
7458 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7460 DECL_COMMON (decl
) = 1;
7461 DECL_INITIAL (decl
) = error_mark_node
;
7465 /* Statically initialized vars are weak or comdat, if
7468 make_decl_one_only (decl
);
7471 /* We can't do anything useful; leave vars for explicit
7473 DECL_EXTERNAL (decl
) = 1;
7474 DECL_NOT_REALLY_EXTERN (decl
) = 0;
7479 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
7480 make_decl_rtl (decl
, NULL_PTR
, toplev
);
7481 else if (TREE_CODE (decl
) == VAR_DECL
7482 && TREE_READONLY (decl
)
7483 && DECL_INITIAL (decl
) != NULL_TREE
7484 && DECL_INITIAL (decl
) != error_mark_node
7485 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7487 DECL_INITIAL (decl
) = save_expr (DECL_INITIAL (decl
));
7490 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7493 && TREE_STATIC (decl
)
7494 && ! TREE_SIDE_EFFECTS (decl
)
7495 && ! TREE_PUBLIC (decl
)
7496 && ! DECL_EXTERNAL (decl
)
7497 && ! TYPE_NEEDS_DESTRUCTOR (type
)
7498 && DECL_MODE (decl
) != BLKmode
)
7500 /* If this variable is really a constant, then fill its DECL_RTL
7501 slot with something which won't take up storage.
7502 If something later should take its address, we can always give
7503 it legitimate RTL at that time. */
7504 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
7505 store_expr (DECL_INITIAL (decl
), DECL_RTL (decl
), 0);
7506 TREE_ASM_WRITTEN (decl
) = 1;
7508 else if (toplev
&& ! TREE_PUBLIC (decl
))
7510 /* If this is a static const, change its apparent linkage
7511 if it belongs to a #pragma interface. */
7512 if (!interface_unknown
)
7514 TREE_PUBLIC (decl
) = 1;
7515 DECL_EXTERNAL (decl
) = interface_only
;
7517 make_decl_rtl (decl
, asmspec
, toplev
);
7520 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7522 else if (TREE_CODE (decl
) == VAR_DECL
7523 && DECL_LANG_SPECIFIC (decl
)
7524 && DECL_IN_AGGR_P (decl
))
7526 if (TREE_STATIC (decl
))
7528 if (init
== NULL_TREE
7529 #ifdef DEFAULT_STATIC_DEFS
7530 /* If this code is dead, then users must
7531 explicitly declare static member variables
7532 outside the class def'n as well. */
7533 && TYPE_NEEDS_CONSTRUCTING (type
)
7537 DECL_EXTERNAL (decl
) = 1;
7538 make_decl_rtl (decl
, asmspec
, 1);
7541 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7544 /* Just a constant field. Should not need any rtl. */
7548 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7551 resume_temporary_allocation ();
7553 if (type
!= error_mark_node
7554 && TYPE_LANG_SPECIFIC (type
)
7555 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
7556 abstract_virtuals_error (decl
, type
);
7557 else if ((TREE_CODE (type
) == FUNCTION_TYPE
7558 || TREE_CODE (type
) == METHOD_TYPE
)
7559 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
7560 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type
)))
7561 abstract_virtuals_error (decl
, TREE_TYPE (type
));
7563 if (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE (type
))
7564 signature_error (decl
, type
);
7565 else if ((TREE_CODE (type
) == FUNCTION_TYPE
7566 || TREE_CODE (type
) == METHOD_TYPE
)
7567 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
7568 && IS_SIGNATURE (TREE_TYPE (type
)))
7569 signature_error (decl
, TREE_TYPE (type
));
7571 if (TREE_CODE (decl
) == FUNCTION_DECL
)
7573 else if (DECL_EXTERNAL (decl
)
7574 && ! (DECL_LANG_SPECIFIC (decl
)
7575 && DECL_NOT_REALLY_EXTERN (decl
)))
7578 DECL_INITIAL (decl
) = init
;
7580 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
7582 /* Cleanups for static variables are handled by `finish_file'. */
7583 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
7584 || TYPE_NEEDS_DESTRUCTOR (type
))
7585 expand_static_init (decl
, init
);
7589 /* This is a declared decl which must live until the
7590 end of the binding contour. It may need a cleanup. */
7592 /* Recompute the RTL of a local array now
7593 if it used to be an incomplete type. */
7594 if (was_incomplete
&& ! TREE_STATIC (decl
))
7596 /* If we used it already as memory, it must stay in memory. */
7597 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7598 /* If it's still incomplete now, no init will save it. */
7599 if (DECL_SIZE (decl
) == NULL_TREE
)
7600 DECL_INITIAL (decl
) = NULL_TREE
;
7603 else if (! TREE_ASM_WRITTEN (decl
)
7604 && (TYPE_SIZE (type
) != NULL_TREE
7605 || TREE_CODE (type
) == ARRAY_TYPE
))
7607 /* Do this here, because we did not expand this decl's
7608 rtl in start_decl. */
7609 if (DECL_RTL (decl
) == NULL_RTX
)
7613 /* XXX: Why don't we use decl here? */
7614 /* Ans: Because it was already expanded? */
7615 if (! expand_decl_cleanup (NULL_TREE
, cleanup
))
7616 cp_error ("parser lost in parsing declaration of `%D'",
7618 /* Cleanup used up here. */
7619 cleanup
= NULL_TREE
;
7623 if (current_binding_level
->is_for_scope
)
7625 struct binding_level
*outer
= current_binding_level
->level_chain
;
7627 /* Check to see if the same name is already bound at
7628 the outer level, either because it was directly declared,
7629 or because a dead for-decl got preserved. In either case,
7630 the code would not have been valid under the ARM
7631 scope rules, so clear is_for_scope for the
7632 current_binding_level.
7634 Otherwise, we need to preserve the temp slot for decl
7635 to last into the outer binding level. */
7637 int handling_dead_for_vars
= 0;
7638 tree link
= outer
->names
;
7639 for (; ; link
= TREE_CHAIN (link
))
7641 if (link
== NULL
&& handling_dead_for_vars
== 0)
7643 link
= outer
->dead_vars_from_for
;
7644 handling_dead_for_vars
= 1;
7648 if (DECL_IN_MEMORY_P (decl
))
7649 preserve_temp_slots (DECL_RTL (decl
));
7652 if (DECL_NAME (link
) == DECL_NAME (decl
))
7654 if (handling_dead_for_vars
)
7657 = purpose_member (DECL_NAME (decl
),
7658 current_binding_level
->shadowed
);
7659 if (shadowing
&& TREE_VALUE (shadowing
) == link
)
7660 TREE_VALUE (shadowing
)
7661 = DECL_SHADOWED_FOR_VAR (link
);
7663 current_binding_level
->is_for_scope
= 0;
7669 expand_start_target_temps ();
7671 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7673 /* Compute and store the initial value. */
7674 expand_decl_init (decl
);
7675 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7677 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7679 emit_line_note (DECL_SOURCE_FILE (decl
),
7680 DECL_SOURCE_LINE (decl
));
7681 expand_aggr_init (decl
, init
, flags
);
7684 /* Set this to 0 so we can tell whether an aggregate which
7685 was initialized was ever used. Don't do this if it has a
7686 destructor, so we don't complain about the 'resource
7687 allocation is initialization' idiom. */
7688 /* Now set attribute((unused)) on types so decls of
7689 that type will be marked used. (see TREE_USED, above.)
7690 This avoids the warning problems this particular code
7691 tried to work around. */
7693 if (TYPE_NEEDS_CONSTRUCTING (type
)
7695 && cleanup
== NULL_TREE
7696 && DECL_NAME (decl
))
7697 TREE_USED (decl
) = 0;
7700 TREE_USED (decl
) = 1;
7703 /* Cleanup any temporaries needed for the initial value. */
7704 expand_end_target_temps ();
7706 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7708 /* Store the cleanup, if there was one. */
7711 if (! expand_decl_cleanup (decl
, cleanup
))
7712 cp_error ("parser lost in parsing declaration of `%D'",
7719 /* Undo call to `pushclass' that was done in `start_decl'
7720 due to initialization of qualified member variable.
7721 I.e., Foo::x = 10; */
7723 tree context
= DECL_REAL_CONTEXT (decl
);
7725 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't'
7726 && (TREE_CODE (decl
) == VAR_DECL
7727 /* We also have a pushclass done that we need to undo here
7728 if we're at top level and declare a method. */
7729 || TREE_CODE (decl
) == FUNCTION_DECL
)
7730 /* If size hasn't been set, we're still defining it,
7731 and therefore inside the class body; don't pop
7732 the binding level.. */
7733 && TYPE_SIZE (context
) != NULL_TREE
7734 && context
== current_class_type
)
7741 /* If requested, warn about definitions of large data objects. */
7743 if (warn_larger_than
7744 && ! processing_template_decl
7745 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
7746 && !DECL_EXTERNAL (decl
))
7748 register tree decl_size
= DECL_SIZE (decl
);
7750 if (decl_size
&& TREE_CODE (decl_size
) == INTEGER_CST
)
7752 unsigned units
= TREE_INT_CST_LOW (decl_size
) / BITS_PER_UNIT
;
7754 if (units
> larger_than_size
)
7755 warning_with_decl (decl
, "size of `%s' is %u bytes", units
);
7761 /* Resume permanent allocation, if not within a function. */
7762 /* The corresponding push_obstacks_nochange is in start_decl,
7763 start_method, groktypename, and in grokfield. */
7768 TREE_READONLY (decl
) = 1;
7771 /* This is here for a midend callback from c-common.c */
7774 finish_decl (decl
, init
, asmspec_tree
)
7778 cp_finish_decl (decl
, init
, asmspec_tree
, 1, 0);
7782 expand_static_init (decl
, init
)
7786 tree oldstatic
= value_member (decl
, static_aggregates
);
7790 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
7791 cp_error ("multiple initializations given for `%D'", decl
);
7793 else if (! toplevel_bindings_p () && ! pseudo_global_level_p ())
7795 /* Emit code to perform this initialization but once. */
7798 /* Remember this information until end of file. */
7799 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7801 /* Emit code to perform this initialization but once. */
7802 temp
= get_temp_name (integer_type_node
, 1);
7803 rest_of_decl_compilation (temp
, NULL_PTR
, 0, 0);
7804 expand_start_cond (build_binary_op (EQ_EXPR
, temp
,
7805 integer_zero_node
, 1), 0);
7806 expand_start_target_temps ();
7808 expand_assignment (temp
, integer_one_node
, 0, 0);
7809 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
7810 || (init
&& TREE_CODE (init
) == TREE_LIST
))
7812 expand_aggr_init (decl
, init
, 0);
7813 do_pending_stack_adjust ();
7816 expand_assignment (decl
, init
, 0, 0);
7818 /* Cleanup any temporaries needed for the initial value. */
7819 expand_end_target_temps ();
7821 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
7823 tree cleanup
, fcall
;
7824 static tree Atexit
= 0;
7827 tree atexit_fndecl
, PFV
, pfvlist
;
7828 /* Remember this information until end of file. */
7829 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7830 PFV
= build_pointer_type (build_function_type
7831 (void_type_node
, void_list_node
));
7833 pfvlist
= tree_cons (NULL_TREE
, PFV
, void_list_node
);
7835 push_lang_context (lang_name_c
);
7837 = builtin_function ("atexit",
7838 build_function_type (void_type_node
,
7840 NOT_BUILT_IN
, NULL_PTR
);
7841 assemble_external (atexit_fndecl
);
7842 Atexit
= default_conversion (atexit_fndecl
);
7843 pop_lang_context ();
7847 /* Call build_cleanup before we enter the anonymous function
7848 so that any access checks will be done relative to the
7849 current scope, rather than the scope of the anonymous
7851 fcall
= build_cleanup (decl
);
7852 cleanup
= start_anon_func ();
7853 expand_expr_stmt (fcall
);
7855 mark_addressable (cleanup
);
7856 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
7857 fcall
= build_function_call (Atexit
, expr_tree_cons (NULL_TREE
, cleanup
, NULL_TREE
));
7858 expand_expr_stmt (fcall
);
7862 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
7864 static_aggregates
= perm_tree_cons (temp
, decl
, static_aggregates
);
7865 TREE_STATIC (static_aggregates
) = 1;
7868 /* Resume old (possibly temporary) allocation. */
7873 /* This code takes into account memory allocation
7874 policy of `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING
7875 does not hold for this object, then we must make permanent
7876 the storage currently in the temporary obstack. */
7877 if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
7878 preserve_initializer ();
7879 static_aggregates
= perm_tree_cons (init
, decl
, static_aggregates
);
7883 /* Make TYPE a complete type based on INITIAL_VALUE.
7884 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7885 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
7888 complete_array_type (type
, initial_value
, do_default
)
7889 tree type
, initial_value
;
7892 register tree maxindex
= NULL_TREE
;
7897 /* Note MAXINDEX is really the maximum index,
7898 one less than the size. */
7899 if (TREE_CODE (initial_value
) == STRING_CST
)
7902 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
7903 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
7906 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7908 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
7909 maxindex
= size_binop (MINUS_EXPR
, integer_zero_node
, size_one_node
);
7910 for (; elts
; elts
= TREE_CHAIN (elts
))
7912 if (TREE_PURPOSE (elts
))
7913 maxindex
= TREE_PURPOSE (elts
);
7915 maxindex
= size_binop (PLUS_EXPR
, maxindex
, size_one_node
);
7917 maxindex
= copy_node (maxindex
);
7921 /* Make an error message unless that happened already. */
7922 if (initial_value
!= error_mark_node
)
7925 /* Prevent further error messages. */
7926 maxindex
= build_int_2 (0, 0);
7933 maxindex
= build_int_2 (0, 0);
7941 TYPE_DOMAIN (type
) = build_index_type (maxindex
);
7942 if (! TREE_TYPE (maxindex
))
7943 TREE_TYPE (maxindex
) = TYPE_DOMAIN (type
);
7945 itype
= TREE_TYPE (initial_value
);
7948 if (itype
&& !TYPE_DOMAIN (itype
))
7949 TYPE_DOMAIN (itype
) = TYPE_DOMAIN (type
);
7950 /* The type of the main variant should never be used for arrays
7951 of different sizes. It should only ever be completed with the
7952 size of the array. */
7953 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
7954 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = TYPE_DOMAIN (type
);
7957 /* Lay out the type now that we can get the real answer. */
7964 /* Return zero if something is declared to be a member of type
7965 CTYPE when in the context of CUR_TYPE. STRING is the error
7966 message to print in that case. Otherwise, quietly return 1. */
7969 member_function_or_else (ctype
, cur_type
, string
)
7970 tree ctype
, cur_type
;
7973 if (ctype
&& ctype
!= cur_type
)
7975 error (string
, TYPE_NAME_STRING (ctype
));
7981 /* Subroutine of `grokdeclarator'. */
7983 /* Generate errors possibly applicable for a given set of specifiers.
7984 This is for ARM $7.1.2. */
7987 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
7990 int virtualp
, quals
, friendp
, raises
, inlinep
;
7993 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
7995 cp_error ("`%D' declared as an `inline' %s", object
, type
);
7997 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8000 cp_error_at ("invalid friend declaration", object
);
8002 cp_error_at ("invalid exception specifications", object
);
8005 /* CTYPE is class type, or null if non-class.
8006 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8008 DECLARATOR is the function's name.
8009 VIRTUALP is truthvalue of whether the function is virtual or not.
8010 FLAGS are to be passed through to `grokclassfn'.
8011 QUALS are qualifiers indicating whether the function is `const'
8013 RAISES is a list of exceptions that this function can raise.
8014 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8015 not look, and -1 if we should not call `grokclassfn' at all.
8017 Returns `error_mark_node' if something goes wrong, after issuing
8018 applicable error messages. */
8021 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8022 raises
, attrlist
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8023 template_count
, in_namespace
)
8026 tree orig_declarator
;
8028 enum overload_flags flags
;
8029 tree quals
, raises
, attrlist
;
8030 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8034 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8038 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8039 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8045 type
= build_exception_variant (type
, raises
);
8048 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8049 /* Propagate volatile out from type to decl. */
8050 if (TYPE_VOLATILE (type
))
8051 TREE_THIS_VOLATILE (decl
) = 1;
8053 /* If this decl has namespace scope, set that up. */
8055 set_decl_namespace (decl
, in_namespace
);
8056 else if (publicp
&& ! ctype
)
8057 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8059 /* `main' and builtins have implicit 'C' linkage. */
8060 if ((MAIN_NAME_P (declarator
)
8061 || (IDENTIFIER_LENGTH (declarator
) > 10
8062 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8063 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8064 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8065 && current_lang_name
== lang_name_cplusplus
8066 && ctype
== NULL_TREE
8067 /* NULL_TREE means global namespace. */
8068 && DECL_CONTEXT (decl
) == NULL_TREE
)
8069 DECL_LANGUAGE (decl
) = lang_c
;
8071 /* Should probably propagate const out from type to decl I bet (mrs). */
8074 DECL_STATIC_FUNCTION_P (decl
) = 1;
8075 DECL_CONTEXT (decl
) = ctype
;
8079 DECL_CLASS_CONTEXT (decl
) = ctype
;
8081 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8084 error ("cannot declare `main' to be inline");
8086 error ("cannot declare `main' to be static");
8091 /* Members of anonymous types have no linkage; make them internal. */
8092 if (ctype
&& ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
)))
8097 /* [basic.link]: A name with no linkage (notably, the name of a class
8098 or enumeration declared in a local scope) shall not be used to
8099 declare an entity with linkage.
8101 Only check this for public decls for now. */
8102 t
= no_linkage_check (TREE_TYPE (decl
));
8105 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8107 if (DECL_LANGUAGE (decl
) == lang_c
)
8108 /* Allow this; it's pretty common in C. */;
8110 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8114 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8119 TREE_PUBLIC (decl
) = publicp
;
8122 DECL_INTERFACE_KNOWN (decl
) = 1;
8123 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8127 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8129 DECL_EXTERNAL (decl
) = 1;
8130 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8132 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8133 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8137 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8138 grok_op_properties (decl
, virtualp
, check
< 0);
8140 if (ctype
&& hack_decl_function_context (decl
))
8141 DECL_NO_STATIC_CHAIN (decl
) = 1;
8143 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8144 if (TREE_PURPOSE (t
)
8145 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8147 add_defarg_fn (decl
);
8152 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8156 ("defining explicit specialization `%D' in friend declaration",
8160 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8162 /* Something like `template <class T> friend void f<T>()'. */
8163 cp_error ("template-id `%D' in declaration of primary template",
8165 return error_mark_node
;
8168 /* A friend declaration of the form friend void f<>(). Record
8169 the information in the TEMPLATE_ID_EXPR. */
8170 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8171 DECL_TEMPLATE_INFO (decl
)
8172 = perm_tree_cons (TREE_OPERAND (orig_declarator
, 0),
8173 TREE_OPERAND (orig_declarator
, 1),
8178 /* Plain overloading: will not be grok'd by grokclassfn. */
8179 if (! ctype
&& ! processing_template_decl
8180 && DECL_LANGUAGE (decl
) != lang_c
8181 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
8182 set_mangled_name_for_decl (decl
);
8184 /* Caller will do the rest of this. */
8188 if (check
&& funcdef_flag
)
8189 DECL_INITIAL (decl
) = error_mark_node
;
8191 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8194 /* Just handle constructors here. We could do this
8195 inside the following if stmt, but I think
8196 that the code is more legible by breaking this
8197 case out. See comments below for what each of
8198 the following calls is supposed to do. */
8199 DECL_CONSTRUCTOR_P (decl
) = 1;
8201 grokclassfn (ctype
, decl
, flags
, quals
);
8203 decl
= check_explicit_specialization (orig_declarator
, decl
,
8205 2 * (funcdef_flag
!= 0) +
8206 4 * (friendp
!= 0));
8207 if (decl
== error_mark_node
)
8208 return error_mark_node
;
8210 if ((! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8213 tmp
= check_classfn (ctype
, decl
);
8215 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8216 tmp
= DECL_TEMPLATE_RESULT(tmp
);
8218 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8219 cp_error ("definition of implicitly-declared `%D'", tmp
);
8220 if (tmp
&& duplicate_decls (decl
, tmp
))
8223 if (! grok_ctor_properties (ctype
, decl
))
8224 return error_mark_node
;
8230 /* Function gets the ugly name, field gets the nice one.
8231 This call may change the type of the function (because
8232 of default parameters)! */
8233 if (ctype
!= NULL_TREE
)
8234 grokclassfn (ctype
, decl
, flags
, quals
);
8236 decl
= check_explicit_specialization (orig_declarator
, decl
,
8238 2 * (funcdef_flag
!= 0) +
8239 4 * (friendp
!= 0));
8240 if (decl
== error_mark_node
)
8241 return error_mark_node
;
8243 if (ctype
!= NULL_TREE
8244 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8247 tmp
= check_classfn (ctype
, decl
);
8249 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8250 tmp
= DECL_TEMPLATE_RESULT (tmp
);
8252 if (tmp
&& DECL_STATIC_FUNCTION_P (tmp
)
8253 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8255 /* Remove the `this' parm added by grokclassfn.
8256 XXX Isn't this done in start_function, too? */
8257 revert_static_member_fn (&decl
, NULL
, NULL
);
8258 last_function_parms
= TREE_CHAIN (last_function_parms
);
8260 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8261 cp_error ("definition of implicitly-declared `%D'", tmp
);
8264 if (!duplicate_decls (decl
, tmp
))
8265 my_friendly_abort (892);
8270 if (ctype
== NULL_TREE
|| check
)
8274 cplus_decl_attributes (decl
, TREE_PURPOSE (attrlist
),
8275 TREE_VALUE (attrlist
));
8276 make_decl_rtl (decl
, NULL_PTR
, 1);
8280 DECL_VIRTUAL_P (decl
) = 1;
8281 if (DECL_VINDEX (decl
) == NULL_TREE
)
8282 DECL_VINDEX (decl
) = error_mark_node
;
8283 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
8290 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
8293 RID_BIT_TYPE
*specbits_in
;
8299 RID_BIT_TYPE specbits
;
8301 specbits
= *specbits_in
;
8303 if (TREE_CODE (type
) == OFFSET_TYPE
)
8305 /* If you declare a static member so that it
8306 can be initialized, the code will reach here. */
8307 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
8308 type
= TREE_TYPE (type
);
8309 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
8310 DECL_CONTEXT (decl
) = basetype
;
8311 DECL_CLASS_CONTEXT (decl
) = basetype
;
8312 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
, declarator
);
8319 context
= in_namespace
;
8320 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
8321 context
= current_namespace
;
8323 context
= NULL_TREE
;
8325 decl
= build_decl (VAR_DECL
, declarator
, complete_type (type
));
8328 set_decl_namespace (decl
, context
);
8330 context
= DECL_CONTEXT (decl
);
8331 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
8332 DECL_ASSEMBLER_NAME (decl
) = build_static_name (context
, declarator
);
8336 set_decl_namespace (decl
, in_namespace
);
8338 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
8340 DECL_THIS_EXTERN (decl
) = 1;
8341 DECL_EXTERNAL (decl
) = !initialized
;
8344 /* In class context, static means one per class,
8345 public access, and static storage. */
8346 if (DECL_CLASS_SCOPE_P (decl
))
8348 TREE_PUBLIC (decl
) = 1;
8349 TREE_STATIC (decl
) = 1;
8350 DECL_EXTERNAL (decl
) = 0;
8352 /* At top level, either `static' or no s.c. makes a definition
8353 (perhaps tentative), and absence of `static' makes it public. */
8354 else if (toplevel_bindings_p ())
8356 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
8357 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8358 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8360 /* Not at top level, only `static' makes a static definition. */
8363 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
8364 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8367 if (TREE_PUBLIC (decl
))
8369 /* [basic.link]: A name with no linkage (notably, the name of a class
8370 or enumeration declared in a local scope) shall not be used to
8371 declare an entity with linkage.
8373 Only check this for public decls for now. */
8374 tree t
= no_linkage_check (TREE_TYPE (decl
));
8377 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8378 /* Ignore for now; `enum { foo } e' is pretty common. */;
8380 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8388 /* Create a canonical pointer to member function type. */
8391 build_ptrmemfunc_type (type
)
8398 /* If a canonical type already exists for this type, use it. We use
8399 this method instead of type_hash_canon, because it only does a
8400 simple equality check on the list of field members. */
8402 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8405 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8407 u
= make_lang_type (UNION_TYPE
);
8408 IS_AGGR_TYPE (u
) = 0;
8409 fields
[0] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
, type
);
8410 fields
[1] = build_lang_field_decl (FIELD_DECL
, delta2_identifier
,
8412 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
8413 TYPE_NAME (u
) = NULL_TREE
;
8415 t
= make_lang_type (RECORD_TYPE
);
8417 /* Let the front-end know this is a pointer to member function... */
8418 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8419 /* ... and not really an aggregate. */
8420 IS_AGGR_TYPE (t
) = 0;
8422 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
8424 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
8426 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
8427 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
8431 /* Zap out the name so that the back-end will give us the debugging
8432 information for this anonymous RECORD_TYPE. */
8433 TYPE_NAME (t
) = NULL_TREE
;
8435 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8437 /* Seems to be wanted. */
8438 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
8442 /* Given declspecs and a declarator,
8443 determine the name and type of the object declared
8444 and construct a ..._DECL node for it.
8445 (In one case we can return a ..._TYPE node instead.
8446 For invalid input we sometimes return 0.)
8448 DECLSPECS is a chain of tree_list nodes whose value fields
8449 are the storage classes and type specifiers.
8451 DECL_CONTEXT says which syntactic context this declaration is in:
8452 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8453 FUNCDEF for a function definition. Like NORMAL but a few different
8454 error messages in each case. Return value may be zero meaning
8455 this definition is too screwy to try to parse.
8456 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8457 handle member functions (which have FIELD context).
8458 Return value may be zero meaning this definition is too screwy to
8460 PARM for a parameter declaration (either within a function prototype
8461 or before a function body). Make a PARM_DECL, or return void_type_node.
8462 CATCHPARM for a parameter declaration before a catch clause.
8463 TYPENAME if for a typename (in a cast or sizeof).
8464 Don't make a DECL node; just return the ..._TYPE node.
8465 FIELD for a struct or union field; make a FIELD_DECL.
8466 BITFIELD for a field with specified width.
8467 INITIALIZED is 1 if the decl has an initializer.
8469 In the TYPENAME case, DECLARATOR is really an absolute declarator.
8470 It may also be so in the PARM case, for a prototype where the
8471 argument type is specified but not the name.
8473 This function is where the complicated C meanings of `static'
8474 and `extern' are interpreted.
8476 For C++, if there is any monkey business to do, the function which
8477 calls this one must do it, i.e., prepending instance variables,
8478 renaming overloaded function names, etc.
8480 Note that for this C++, it is an error to define a method within a class
8481 which does not belong to that class.
8483 Except in the case where SCOPE_REFs are implicitly known (such as
8484 methods within a class being redundantly qualified),
8485 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
8486 (class_name::decl_name). The caller must also deal with this.
8488 If a constructor or destructor is seen, and the context is FIELD,
8489 then the type gains the attribute TREE_HAS_x. If such a declaration
8490 is erroneous, NULL_TREE is returned.
8492 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
8493 function, these are the qualifiers to give to the `this' pointer.
8495 May return void_type_node if the declarator turned out to be a friend.
8496 See grokfield for details. */
8498 enum return_types
{ return_normal
, return_ctor
, return_dtor
, return_conversion
};
8501 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
8504 enum decl_context decl_context
;
8508 RID_BIT_TYPE specbits
;
8511 tree type
= NULL_TREE
;
8517 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8518 int explicit_int
= 0;
8519 int explicit_char
= 0;
8520 int defaulted_int
= 0;
8521 int opaque_typedef
= 0;
8522 tree typedef_decl
= NULL_TREE
;
8524 tree typedef_type
= NULL_TREE
;
8525 int funcdef_flag
= 0;
8526 enum tree_code innermost_code
= ERROR_MARK
;
8529 /* See the code below that used this. */
8530 tree decl_machine_attr
= NULL_TREE
;
8532 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
8533 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
8534 tree init
= NULL_TREE
;
8536 /* Keep track of what sort of function is being processed
8537 so that we can warn about default return values, or explicit
8538 return values which do not match prescribed defaults. */
8539 enum return_types return_type
= return_normal
;
8541 tree dname
= NULL_TREE
;
8542 tree ctype
= current_class_type
;
8543 tree ctor_return_type
= NULL_TREE
;
8544 enum overload_flags flags
= NO_SPECIAL
;
8545 tree quals
= NULL_TREE
;
8546 tree raises
= NULL_TREE
;
8547 int template_count
= 0;
8548 tree in_namespace
= NULL_TREE
;
8552 RIDBIT_RESET_ALL (specbits
);
8553 if (decl_context
== FUNCDEF
)
8554 funcdef_flag
= 1, decl_context
= NORMAL
;
8555 else if (decl_context
== MEMFUNCDEF
)
8556 funcdef_flag
= -1, decl_context
= FIELD
;
8557 else if (decl_context
== BITFIELD
)
8558 bitfield
= 1, decl_context
= FIELD
;
8560 /* Look inside a declarator for the name being declared
8561 and get it as a string, for an error message. */
8563 tree
*next
= &declarator
;
8567 while (next
&& *next
)
8570 switch (TREE_CODE (decl
))
8573 /* For attributes. */
8574 next
= &TREE_VALUE (decl
);
8579 next
= &TREE_OPERAND (decl
, 0);
8582 case BIT_NOT_EXPR
: /* For C++ destructors! */
8584 tree name
= TREE_OPERAND (decl
, 0);
8585 tree rename
= NULL_TREE
;
8587 my_friendly_assert (flags
== NO_SPECIAL
, 152);
8589 return_type
= return_dtor
;
8590 if (TREE_CODE (name
) == TYPE_DECL
)
8591 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
8592 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
8593 if (ctype
== NULL_TREE
)
8595 if (current_class_type
== NULL_TREE
)
8597 error ("destructors must be member functions");
8602 tree t
= constructor_name (current_class_name
);
8609 tree t
= constructor_name (ctype
);
8616 cp_error ("destructor `%T' must match class name `%T'",
8618 TREE_OPERAND (decl
, 0) = rename
;
8624 case ADDR_EXPR
: /* C++ reference declaration */
8629 innermost_code
= TREE_CODE (decl
);
8630 next
= &TREE_OPERAND (decl
, 0);
8634 if (parmlist_is_exprlist (TREE_OPERAND (decl
, 1)))
8636 /* This is actually a variable declaration using constructor
8637 syntax. We need to call start_decl and cp_finish_decl so we
8638 can get the variable initialized... */
8640 *next
= TREE_OPERAND (decl
, 0);
8641 init
= TREE_OPERAND (decl
, 1);
8643 decl
= start_decl (declarator
, declspecs
, 1, NULL_TREE
, NULL_TREE
);
8644 /* Look for __unused__ attribute */
8645 if (TREE_USED (TREE_TYPE (decl
)))
8646 TREE_USED (decl
) = 1;
8647 finish_decl (decl
, init
, NULL_TREE
);
8650 innermost_code
= TREE_CODE (decl
);
8651 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
8652 ctype
= current_class_type
;
8654 && TREE_OPERAND (decl
, 0)
8655 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
8656 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
8657 == constructor_name_full (ctype
))
8658 || (DECL_NAME (TREE_OPERAND (decl
, 0))
8659 == constructor_name (ctype
)))))
8660 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8661 next
= &TREE_OPERAND (decl
, 0);
8663 if (ctype
!= NULL_TREE
8664 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
8665 && decl
== constructor_name (ctype
))
8667 return_type
= return_ctor
;
8668 ctor_return_type
= ctype
;
8673 case TEMPLATE_ID_EXPR
:
8675 tree fns
= TREE_OPERAND (decl
, 0);
8677 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
8678 fns
= TREE_OPERAND (fns
, 0);
8680 if (TREE_CODE (fns
) == IDENTIFIER_NODE
)
8682 else if (is_overloaded_fn (fns
))
8683 dname
= DECL_NAME (get_first_fn (fns
));
8685 my_friendly_abort (0);
8689 case IDENTIFIER_NODE
:
8690 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
8697 cp_error ("declarator-id missing; using reserved word `%D'",
8699 name
= IDENTIFIER_POINTER (dname
);
8701 if (! IDENTIFIER_OPNAME_P (dname
)
8702 /* GNU/Linux headers use '__op'. Arrgh. */
8703 || (IDENTIFIER_TYPENAME_P (dname
) && ! TREE_TYPE (dname
)))
8704 name
= IDENTIFIER_POINTER (dname
);
8707 if (IDENTIFIER_TYPENAME_P (dname
))
8709 my_friendly_assert (flags
== NO_SPECIAL
, 154);
8710 flags
= TYPENAME_FLAG
;
8711 ctor_return_type
= TREE_TYPE (dname
);
8712 return_type
= return_conversion
;
8714 name
= operator_name_string (dname
);
8721 /* Perform error checking, and decide on a ctype. */
8722 tree cname
= TREE_OPERAND (decl
, 0);
8723 if (cname
== NULL_TREE
)
8725 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
8728 in_namespace
= TREE_OPERAND (decl
, 0);
8729 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8731 else if (! is_aggr_type (cname
, 1))
8732 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8733 /* Must test TREE_OPERAND (decl, 1), in case user gives
8734 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
8735 else if (TREE_OPERAND (decl
, 1)
8736 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
8738 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
8739 || TREE_CODE (cname
) == TEMPLATE_TEMPLATE_PARM
)
8741 cp_error ("`%T::%D' is not a valid declarator", cname
,
8742 TREE_OPERAND (decl
, 1));
8743 cp_error (" perhaps you want `typename %T::%D' to make it a type",
8744 cname
, TREE_OPERAND (decl
, 1));
8745 return void_type_node
;
8747 else if (ctype
== NULL_TREE
)
8749 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
8750 TREE_OPERAND (decl
, 0) = ctype
;
8753 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
8755 cp_error ("type `%T' is not derived from type `%T'",
8757 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8763 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
8764 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
8765 == constructor_name_full (ctype
))
8766 || (DECL_NAME (TREE_OPERAND (decl
, 1))
8767 == constructor_name (ctype
))))
8768 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
8769 next
= &TREE_OPERAND (decl
, 1);
8773 if (TREE_CODE (decl
) == IDENTIFIER_NODE
8774 && constructor_name (ctype
) == decl
)
8776 return_type
= return_ctor
;
8777 ctor_return_type
= ctype
;
8779 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
8780 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
8781 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
8782 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
8784 return_type
= return_dtor
;
8785 ctor_return_type
= ctype
;
8787 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8788 next
= &TREE_OPERAND (decl
, 0);
8799 /* Parse error puts this typespec where
8800 a declarator should go. */
8801 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
8802 if (TREE_TYPE (decl
) == current_class_type
)
8803 cp_error (" perhaps you want `%T' for a constructor",
8804 current_class_name
);
8805 dname
= DECL_NAME (decl
);
8806 name
= IDENTIFIER_POINTER (dname
);
8808 /* Avoid giving two errors for this. */
8809 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
8811 declspecs
= temp_tree_cons (NULL_TREE
, integer_type_node
,
8818 cp_compiler_error ("`%D' as declarator", decl
);
8819 return 0; /* We used to do a 155 abort here. */
8826 /* A function definition's declarator must have the form of
8827 a function declarator. */
8829 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
8832 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8833 && innermost_code
!= CALL_EXPR
8834 && ! (ctype
&& declspecs
== NULL_TREE
))
8836 cp_error ("declaration of `%D' as non-function", dname
);
8837 return void_type_node
;
8840 /* Anything declared one level down from the top level
8841 must be one of the parameters of a function
8842 (because the body is at least two levels down). */
8844 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8845 by not allowing C++ class definitions to specify their parameters
8846 with xdecls (must be spec.d in the parmlist).
8848 Since we now wait to push a class scope until we are sure that
8849 we are in a legitimate method context, we must set oldcname
8850 explicitly (since current_class_name is not yet alive).
8852 We also want to avoid calling this a PARM if it is in a namespace. */
8854 if (decl_context
== NORMAL
&& ! namespace_bindings_p ()
8855 && ! pseudo_global_level_p ())
8857 struct binding_level
*b
= current_binding_level
;
8858 current_binding_level
= b
->level_chain
;
8859 if (current_binding_level
!= 0 && toplevel_bindings_p ())
8860 decl_context
= PARM
;
8861 current_binding_level
= b
;
8864 /* Look through the decl specs and record which ones appear.
8865 Some typespecs are defined as built-in typenames.
8866 Others, the ones that are modifiers of other types,
8867 are represented by bits in SPECBITS: set the bits for
8868 the modifiers that appear. Storage class keywords are also in SPECBITS.
8870 If there is a typedef name or a type, store the type in TYPE.
8871 This includes builtin typedefs such as `int'.
8873 Set EXPLICIT_INT if the type is `int' or `char' and did not
8874 come from a user typedef.
8876 Set LONGLONG if `long' is mentioned twice.
8878 For C++, constructors and destructors have their own fast treatment. */
8880 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
8885 /* Certain parse errors slip through. For example,
8886 `int class;' is not caught by the parser. Try
8887 weakly to recover here. */
8888 if (TREE_CODE (spec
) != TREE_LIST
)
8891 id
= TREE_VALUE (spec
);
8893 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8895 if (id
== ridpointers
[(int) RID_INT
]
8896 || id
== ridpointers
[(int) RID_CHAR
]
8897 || id
== ridpointers
[(int) RID_BOOL
]
8898 || id
== ridpointers
[(int) RID_WCHAR
])
8902 if (id
== ridpointers
[(int) RID_BOOL
])
8903 error ("`bool' is now a keyword");
8905 cp_error ("extraneous `%T' ignored", id
);
8909 if (id
== ridpointers
[(int) RID_INT
])
8911 else if (id
== ridpointers
[(int) RID_CHAR
])
8913 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
8917 /* C++ aggregate types. */
8918 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
8921 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
8923 type
= IDENTIFIER_TYPE_VALUE (id
);
8927 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
8929 if (ridpointers
[i
] == id
)
8931 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
8933 if (pedantic
&& ! in_system_header
&& warn_long_long
)
8934 pedwarn ("ANSI C++ does not support `long long'");
8936 error ("`long long long' is too long for GCC");
8940 else if (RIDBIT_SETP (i
, specbits
))
8941 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
8942 RIDBIT_SET (i
, specbits
);
8947 /* C++ aggregate types. */
8948 else if (TREE_CODE (id
) == TYPE_DECL
|| TREE_CODE (id
) == TEMPLATE_DECL
)
8951 cp_error ("multiple declarations `%T' and `%T'", type
,
8955 type
= TREE_TYPE (id
);
8956 TREE_VALUE (spec
) = type
;
8961 error ("two or more data types in declaration of `%s'", name
);
8962 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8964 register tree t
= lookup_name (id
, 1);
8965 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
8966 error ("`%s' fails to be a typedef or built in type",
8967 IDENTIFIER_POINTER (id
));
8970 type
= TREE_TYPE (t
);
8972 /* See the code below that used this. */
8973 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
8978 else if (id
!= error_mark_node
)
8979 /* Can't change CLASS nodes into RECORD nodes here! */
8985 typedef_type
= type
;
8987 /* No type at all: default to `int', and set DEFAULTED_INT
8988 because it was not a user-defined typedef.
8989 Except when we have a `typedef' inside a signature, in
8990 which case the type defaults to `unknown type' and is
8991 instantiated when assigning to a signature pointer or ref. */
8993 if (type
== NULL_TREE
8994 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
8995 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
8996 || RIDBIT_SETP (RID_LONG
, specbits
)
8997 || RIDBIT_SETP (RID_SHORT
, specbits
)))
8999 /* These imply 'int'. */
9000 type
= integer_type_node
;
9004 if (type
== NULL_TREE
)
9007 if (return_type
== return_dtor
)
9008 type
= void_type_node
;
9009 else if (return_type
== return_ctor
)
9010 type
= build_pointer_type (ctor_return_type
);
9011 else if (return_type
== return_conversion
)
9012 type
= ctor_return_type
;
9013 else if (current_class_type
9014 && IS_SIGNATURE (current_class_type
)
9015 && RIDBIT_SETP (RID_TYPEDEF
, specbits
)
9016 && (decl_context
== FIELD
|| decl_context
== NORMAL
))
9020 type
= copy_node (opaque_type_node
);
9026 if (warn_return_type
9027 && return_type
== return_normal
)
9028 /* Save warning until we know what is really going on. */
9029 warn_about_return_type
= 1;
9031 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9032 pedwarn ("ANSI C++ forbids typedef which does not specify a type");
9033 else if (innermost_code
!= CALL_EXPR
|| pedantic
9034 || (warn_return_type
&& return_type
== return_normal
))
9036 if (innermost_code
== CALL_EXPR
)
9037 cp_pedwarn ("return-type of `%D' defaults to `int'", dname
);
9039 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
9042 type
= integer_type_node
;
9045 else if (return_type
== return_dtor
)
9047 error ("return type specification for destructor invalid");
9048 type
= void_type_node
;
9050 else if (return_type
== return_ctor
)
9052 error ("return type specification for constructor invalid");
9053 type
= build_pointer_type (ctor_return_type
);
9055 else if (return_type
== return_conversion
)
9057 if (comptypes (type
, ctor_return_type
, 1) == 0)
9058 cp_error ("operator `%T' declared to return `%T'",
9059 ctor_return_type
, type
);
9061 cp_pedwarn ("return type specified for `operator %T'",
9064 type
= ctor_return_type
;
9069 /* Now process the modifiers that were specified
9070 and check for invalid combinations. */
9072 /* Long double is a special combination. */
9074 if (RIDBIT_SETP (RID_LONG
, specbits
)
9075 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
9077 RIDBIT_RESET (RID_LONG
, specbits
);
9078 type
= build_qualified_type (long_double_type_node
,
9079 CP_TYPE_QUALS (type
));
9082 /* Check all other uses of type modifiers. */
9084 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9085 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9086 || RIDBIT_SETP (RID_LONG
, specbits
)
9087 || RIDBIT_SETP (RID_SHORT
, specbits
))
9091 if (TREE_CODE (type
) == REAL_TYPE
)
9092 error ("short, signed or unsigned invalid for `%s'", name
);
9093 else if (TREE_CODE (type
) != INTEGER_TYPE
)
9094 error ("long, short, signed or unsigned invalid for `%s'", name
);
9095 else if (RIDBIT_SETP (RID_LONG
, specbits
)
9096 && RIDBIT_SETP (RID_SHORT
, specbits
))
9097 error ("long and short specified together for `%s'", name
);
9098 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9099 || RIDBIT_SETP (RID_SHORT
, specbits
))
9101 error ("long or short specified with char for `%s'", name
);
9102 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9103 || RIDBIT_SETP (RID_SHORT
, specbits
))
9104 && TREE_CODE (type
) == REAL_TYPE
)
9105 error ("long or short specified with floating type for `%s'", name
);
9106 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9107 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
9108 error ("signed and unsigned given together for `%s'", name
);
9112 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
9114 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9116 if (flag_pedantic_errors
)
9121 /* Discard the type modifiers if they are invalid. */
9124 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
9125 RIDBIT_RESET (RID_SIGNED
, specbits
);
9126 RIDBIT_RESET (RID_LONG
, specbits
);
9127 RIDBIT_RESET (RID_SHORT
, specbits
);
9132 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
9133 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9135 error ("complex invalid for `%s'", name
);
9136 RIDBIT_RESET (RID_COMPLEX
, specbits
);
9139 /* Decide whether an integer type is signed or not.
9140 Optionally treat bitfields as signed by default. */
9141 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9142 || (bitfield
&& ! flag_signed_bitfields
9143 && (explicit_int
|| defaulted_int
|| explicit_char
9144 /* A typedef for plain `int' without `signed'
9145 can be controlled just like plain `int'. */
9146 || ! (typedef_decl
!= NULL_TREE
9147 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
9148 && TREE_CODE (type
) != ENUMERAL_TYPE
9149 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)))
9152 type
= long_long_unsigned_type_node
;
9153 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9154 type
= long_unsigned_type_node
;
9155 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9156 type
= short_unsigned_type_node
;
9157 else if (type
== char_type_node
)
9158 type
= unsigned_char_type_node
;
9159 else if (typedef_decl
)
9160 type
= unsigned_type (type
);
9162 type
= unsigned_type_node
;
9164 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9165 && type
== char_type_node
)
9166 type
= signed_char_type_node
;
9168 type
= long_long_integer_type_node
;
9169 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9170 type
= long_integer_type_node
;
9171 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9172 type
= short_integer_type_node
;
9174 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
9176 /* If we just have "complex", it is equivalent to
9177 "complex double", but if any modifiers at all are specified it is
9178 the complex form of TYPE. E.g, "complex short" is
9179 "complex short int". */
9181 if (defaulted_int
&& ! longlong
9182 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
9183 || RIDBIT_SETP (RID_SHORT
, specbits
)
9184 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9185 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
9186 type
= complex_double_type_node
;
9187 else if (type
== integer_type_node
)
9188 type
= complex_integer_type_node
;
9189 else if (type
== float_type_node
)
9190 type
= complex_float_type_node
;
9191 else if (type
== double_type_node
)
9192 type
= complex_double_type_node
;
9193 else if (type
== long_double_type_node
)
9194 type
= complex_long_double_type_node
;
9196 type
= build_complex_type (type
);
9199 if (return_type
== return_conversion
9200 && (RIDBIT_SETP (RID_CONST
, specbits
)
9201 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
9202 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
9203 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9206 /* Set CONSTP if this declaration is `const', whether by
9207 explicit specification or via a typedef.
9208 Likewise for VOLATILEP. */
9210 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
9212 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
9214 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
9215 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9216 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9217 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9218 type
= cp_build_qualified_type (type
, type_quals
);
9220 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
9221 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
9222 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
9223 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
9224 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
9226 if (RIDBIT_SETP (RID_STATIC
, specbits
))
9227 staticp
= 1 + (decl_context
== FIELD
);
9229 if (virtualp
&& staticp
== 2)
9231 cp_error ("member `%D' cannot be declared both virtual and static",
9235 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
9236 RIDBIT_RESET (RID_FRIEND
, specbits
);
9238 /* $7.1.2, Function specifiers */
9239 if (friendp
&& explicitp
)
9240 error ("only declarations of constructors can be `explicit'");
9242 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9244 if (decl_context
== PARM
)
9246 error ("non-member `%s' cannot be declared `mutable'", name
);
9247 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9249 else if (friendp
|| decl_context
== TYPENAME
)
9251 error ("non-object member `%s' cannot be declared `mutable'", name
);
9252 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9256 /* Warn if two storage classes are given. Default to `auto'. */
9258 if (RIDBIT_ANY_SET (specbits
))
9260 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
9261 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
9262 if (decl_context
== PARM
&& nclasses
> 0)
9263 error ("storage class specifiers invalid in parameter declarations");
9264 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9266 if (decl_context
== PARM
)
9267 error ("typedef declaration invalid in parameter declaration");
9270 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
9271 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
9274 /* Give error if `virtual' is used outside of class declaration. */
9276 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9278 error ("virtual outside class declaration");
9281 if (current_class_name
== NULL_TREE
&& RIDBIT_SETP (RID_MUTABLE
, specbits
))
9283 error ("only members can be declared mutable");
9284 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9287 /* Static anonymous unions are dealt with here. */
9288 if (staticp
&& decl_context
== TYPENAME
9289 && TREE_CODE (declspecs
) == TREE_LIST
9290 && ANON_UNION_TYPE_P (TREE_VALUE (declspecs
)))
9291 decl_context
= FIELD
;
9293 /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
9294 is used in a signature member function declaration. */
9295 if (decl_context
== FIELD
9296 && IS_SIGNATURE (current_class_type
)
9297 && RIDBIT_NOTSETP (RID_TYPEDEF
, specbits
))
9299 if (type_quals
!= TYPE_UNQUALIFIED
)
9301 error ("type qualifiers specified for signature member function `%s'", name
);
9302 type_quals
= TYPE_UNQUALIFIED
;
9306 error ("`inline' specified for signature member function `%s'", name
);
9307 /* Later, we'll make signature member functions inline. */
9312 error ("`friend' declaration in signature definition");
9317 error ("`virtual' specified for signature member function `%s'",
9319 /* Later, we'll make signature member functions virtual. */
9324 /* Warn about storage classes that are invalid for certain
9325 kinds of declarations (parameters, typenames, etc.). */
9328 error ("multiple storage classes in declaration of `%s'", name
);
9329 else if (decl_context
!= NORMAL
&& nclasses
> 0)
9331 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9332 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
9333 || RIDBIT_SETP (RID_AUTO
, specbits
)))
9335 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9337 else if (decl_context
== FIELD
9338 && ! IS_SIGNATURE (current_class_type
)
9339 /* C++ allows static class elements */
9340 && RIDBIT_SETP (RID_STATIC
, specbits
))
9341 /* C++ also allows inlines and signed and unsigned elements,
9342 but in those cases we don't come in here. */
9346 if (decl_context
== FIELD
)
9348 tree tmp
= NULL_TREE
;
9349 register int op
= 0;
9353 /* Avoid trying to get an operand off an identifier node. */
9354 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
9357 tmp
= TREE_OPERAND (declarator
, 0);
9358 op
= IDENTIFIER_OPNAME_P (tmp
);
9360 error ("storage class specified for %s `%s'",
9361 IS_SIGNATURE (current_class_type
)
9363 ? "signature member operator"
9364 : "signature member function")
9365 : (op
? "member operator" : "field"),
9366 op
? operator_name_string (tmp
) : name
);
9369 error (((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9370 ? "storage class specified for parameter `%s'"
9371 : "storage class specified for typename"), name
);
9372 RIDBIT_RESET (RID_REGISTER
, specbits
);
9373 RIDBIT_RESET (RID_AUTO
, specbits
);
9374 RIDBIT_RESET (RID_EXTERN
, specbits
);
9376 if (decl_context
== FIELD
&& IS_SIGNATURE (current_class_type
))
9378 RIDBIT_RESET (RID_STATIC
, specbits
);
9383 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
9385 if (toplevel_bindings_p ())
9387 /* It's common practice (and completely valid) to have a const
9388 be initialized and declared extern. */
9390 warning ("`%s' initialized and declared `extern'", name
);
9393 error ("`%s' has both `extern' and initializer", name
);
9395 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
9396 && ! toplevel_bindings_p ())
9397 error ("nested function `%s' declared `extern'", name
);
9398 else if (toplevel_bindings_p ())
9400 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9401 error ("top-level declaration of `%s' specifies `auto'", name
);
9404 if (nclasses
> 0 && friendp
)
9405 error ("storage class specifiers invalid in friend function declarations");
9407 /* Now figure out the structure of the declarator proper.
9408 Descend through it, creating more complex types, until we reach
9409 the declared identifier (or NULL_TREE, in an absolute declarator). */
9411 inner_attrs
= NULL_TREE
;
9414 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
9415 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
9417 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9418 an INDIRECT_REF (for *...),
9419 a CALL_EXPR (for ...(...)),
9420 an identifier (for the name being declared)
9421 or a null pointer (for the place in an absolute declarator
9422 where the name was omitted).
9423 For the last two cases, we have just exited the loop.
9425 For C++ it could also be
9426 a SCOPE_REF (for class :: ...). In this case, we have converted
9427 sensible names to types, and those are the values we use to
9428 qualify the member name.
9429 an ADDR_EXPR (for &...),
9430 a BIT_NOT_EXPR (for destructors)
9432 At this point, TYPE is the type of elements of an array,
9433 or for a function to return, or for a pointer to point to.
9434 After this sequence of ifs, TYPE is the type of the
9435 array or function or pointer, and DECLARATOR has had its
9436 outermost layer removed. */
9438 if (type
== error_mark_node
)
9440 if (TREE_CODE (declarator
) == SCOPE_REF
)
9441 declarator
= TREE_OPERAND (declarator
, 1);
9443 declarator
= TREE_OPERAND (declarator
, 0);
9446 if (quals
!= NULL_TREE
9447 && (declarator
== NULL_TREE
9448 || TREE_CODE (declarator
) != SCOPE_REF
))
9450 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
9451 ctype
= TYPE_METHOD_BASETYPE (type
);
9452 if (ctype
!= NULL_TREE
)
9454 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
9455 ctype
= grok_method_quals (ctype
, dummy
, quals
);
9456 type
= TREE_TYPE (dummy
);
9461 /* See the comment for the TREE_LIST case, below. */
9464 else if (inner_attrs
)
9466 decl_attributes (type
, inner_attrs
, NULL_TREE
);
9467 inner_attrs
= NULL_TREE
;
9470 switch (TREE_CODE (declarator
))
9474 /* We encode a declarator with embedded attributes using
9475 a TREE_LIST. The attributes apply to the declarator
9476 directly inside them, so we have to skip an iteration
9477 before applying them to the type. If the declarator just
9478 inside is the declarator-id, we apply the attrs to the
9480 inner_attrs
= TREE_PURPOSE (declarator
);
9482 declarator
= TREE_VALUE (declarator
);
9488 register tree itype
= NULL_TREE
;
9489 register tree size
= TREE_OPERAND (declarator
, 1);
9490 /* The index is a signed object `sizetype' bits wide. */
9491 tree index_type
= signed_type (sizetype
);
9493 declarator
= TREE_OPERAND (declarator
, 0);
9495 /* Check for some types that there cannot be arrays of. */
9497 if (TREE_CODE (type
) == VOID_TYPE
)
9499 cp_error ("declaration of `%D' as array of voids", dname
);
9500 type
= error_mark_node
;
9503 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9505 cp_error ("declaration of `%D' as array of functions", dname
);
9506 type
= error_mark_node
;
9509 /* ARM $8.4.3: Since you can't have a pointer to a reference,
9510 you can't have arrays of references. If we allowed them,
9511 then we'd be saying x[i] is valid for an array x, but
9512 then you'd have to ask: what does `*(x + i)' mean? */
9513 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9515 if (decl_context
== TYPENAME
)
9516 cp_error ("cannot make arrays of references");
9518 cp_error ("declaration of `%D' as array of references",
9520 type
= error_mark_node
;
9523 if (TREE_CODE (type
) == OFFSET_TYPE
)
9525 cp_error ("declaration of `%D' as array of data members",
9527 type
= error_mark_node
;
9530 if (TREE_CODE (type
) == METHOD_TYPE
)
9532 cp_error ("declaration of `%D' as array of function members",
9534 type
= error_mark_node
;
9537 if (size
== error_mark_node
)
9538 type
= error_mark_node
;
9540 if (type
== error_mark_node
)
9545 /* Must suspend_momentary here because the index
9546 type may need to live until the end of the function.
9547 For example, it is used in the declaration of a
9548 variable which requires destructing at the end of
9549 the function; then build_vec_delete will need this
9551 int yes
= suspend_momentary ();
9552 /* Might be a cast. */
9553 if (TREE_CODE (size
) == NOP_EXPR
9554 && TREE_TYPE (size
) == TREE_TYPE (TREE_OPERAND (size
, 0)))
9555 size
= TREE_OPERAND (size
, 0);
9557 /* If this involves a template parameter, it'll be
9558 constant, but we don't know what the value is yet. */
9559 if (processing_template_decl
)
9561 itype
= make_node (INTEGER_TYPE
);
9562 TYPE_MIN_VALUE (itype
) = size_zero_node
;
9563 TYPE_MAX_VALUE (itype
) = build_min
9564 (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
9565 goto dont_grok_size
;
9568 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
9569 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
)
9571 cp_error ("size of array `%D' has non-integer type",
9573 size
= integer_one_node
;
9575 if (TREE_READONLY_DECL_P (size
))
9576 size
= decl_constant_value (size
);
9577 if (pedantic
&& integer_zerop (size
))
9578 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname
);
9579 if (TREE_CONSTANT (size
))
9581 int old_flag_pedantic_errors
= flag_pedantic_errors
;
9582 int old_pedantic
= pedantic
;
9583 pedantic
= flag_pedantic_errors
= 1;
9584 /* Always give overflow errors on array subscripts. */
9585 constant_expression_warning (size
);
9586 pedantic
= old_pedantic
;
9587 flag_pedantic_errors
= old_flag_pedantic_errors
;
9588 if (INT_CST_LT (size
, integer_zero_node
))
9590 cp_error ("size of array `%D' is negative", dname
);
9591 size
= integer_one_node
;
9599 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
9602 cp_pedwarn ("ANSI C++ forbids variable-size array");
9607 = fold (build_binary_op (MINUS_EXPR
,
9608 cp_convert (index_type
, size
),
9609 cp_convert (index_type
,
9610 integer_one_node
), 1));
9611 if (! TREE_CONSTANT (itype
))
9612 itype
= variable_size (itype
);
9613 else if (TREE_OVERFLOW (itype
))
9615 error ("overflow in array dimension");
9616 TREE_OVERFLOW (itype
) = 0;
9619 /* If we're a parm, we need to have a permanent type so
9620 mangling checks for re-use will work right. If both the
9621 element and index types are permanent, the array type
9623 if (decl_context
== PARM
9624 && allocation_temporary_p () && TREE_PERMANENT (type
))
9626 push_obstacks (&permanent_obstack
, &permanent_obstack
);
9627 itype
= build_index_type (itype
);
9631 itype
= build_index_type (itype
);
9634 resume_momentary (yes
);
9637 type
= build_cplus_array_type (type
, itype
);
9646 tree inner_parms
= TREE_OPERAND (declarator
, 1);
9647 tree inner_decl
= TREE_OPERAND (declarator
, 0);
9649 /* Declaring a function type.
9650 Make sure we have a valid type for the function to return. */
9652 /* We now know that the TYPE_QUALS don't apply to the
9653 decl, but to its return type. */
9654 type_quals
= TYPE_UNQUALIFIED
;
9656 /* Warn about some types functions can't return. */
9658 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9660 error ("`%s' declared as function returning a function", name
);
9661 type
= integer_type_node
;
9663 if (TREE_CODE (type
) == ARRAY_TYPE
)
9665 error ("`%s' declared as function returning an array", name
);
9666 type
= integer_type_node
;
9669 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
9670 inner_decl
= TREE_OPERAND (inner_decl
, 1);
9672 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
9675 /* Pick up type qualifiers which should be applied to `this'. */
9676 quals
= TREE_OPERAND (declarator
, 2);
9678 /* Pick up the exception specifications. */
9679 raises
= TREE_TYPE (declarator
);
9681 /* Say it's a definition only for the CALL_EXPR
9682 closest to the identifier. */
9685 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
9686 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
9687 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
9689 if (ctype
== NULL_TREE
9690 && decl_context
== FIELD
9692 && (friendp
== 0 || dname
== current_class_name
))
9693 ctype
= current_class_type
;
9695 if (ctype
&& return_type
== return_conversion
)
9696 TYPE_HAS_CONVERSION (ctype
) = 1;
9697 if (ctype
&& constructor_name (ctype
) == dname
)
9699 /* We are within a class's scope. If our declarator name
9700 is the same as the class name, and we are defining
9701 a function, then it is a constructor/destructor, and
9702 therefore returns a void type. */
9704 if (flags
== DTOR_FLAG
)
9706 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
9707 not be declared const or volatile. A destructor
9708 may not be static. */
9710 error ("destructor cannot be static member function");
9713 cp_error ("destructors may not be `%s'",
9714 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9717 if (decl_context
== FIELD
)
9719 if (! member_function_or_else (ctype
, current_class_type
,
9720 "destructor for alien class `%s' cannot be a member"))
9721 return void_type_node
;
9724 else /* It's a constructor. */
9728 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
9729 not be declared const or volatile. A constructor may
9730 not be virtual. A constructor may not be static. */
9732 error ("constructor cannot be static member function");
9735 pedwarn ("constructors cannot be declared virtual");
9740 cp_error ("constructors may not be `%s'",
9741 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9745 RID_BIT_TYPE tmp_bits
;
9746 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
9747 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
9748 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
9749 if (RIDBIT_ANY_SET (tmp_bits
))
9750 error ("return value type specifier for constructor ignored");
9752 type
= build_pointer_type (ctype
);
9753 if (decl_context
== FIELD
9754 && IS_SIGNATURE (current_class_type
))
9756 error ("constructor not allowed in signature");
9757 return void_type_node
;
9759 else if (decl_context
== FIELD
)
9761 if (! member_function_or_else (ctype
, current_class_type
,
9762 "constructor for alien class `%s' cannot be member"))
9763 return void_type_node
;
9764 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
9765 if (return_type
!= return_ctor
)
9769 if (decl_context
== FIELD
)
9775 error ("can't initialize friend function `%s'", name
);
9778 /* Cannot be both friend and virtual. */
9779 error ("virtual functions cannot be friends");
9780 RIDBIT_RESET (RID_FRIEND
, specbits
);
9783 if (decl_context
== NORMAL
)
9784 error ("friend declaration not in class definition");
9785 if (current_function_decl
&& funcdef_flag
)
9786 cp_error ("can't define friend function `%s' in a local class definition",
9790 /* Construct the function type and go to the next
9791 inner layer of declarator. */
9793 declarator
= TREE_OPERAND (declarator
, 0);
9795 /* FIXME: This is where default args should be fully
9798 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
9800 if (declarator
&& flags
== DTOR_FLAG
)
9802 /* A destructor declared in the body of a class will
9803 be represented as a BIT_NOT_EXPR. But, we just
9804 want the underlying IDENTIFIER. */
9805 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
9806 declarator
= TREE_OPERAND (declarator
, 0);
9808 if (strict_prototype
== 0 && arg_types
== NULL_TREE
)
9809 arg_types
= void_list_node
;
9810 else if (arg_types
== NULL_TREE
9811 || arg_types
!= void_list_node
)
9813 cp_error ("destructors may not have parameters");
9814 arg_types
= void_list_node
;
9815 last_function_parms
= NULL_TREE
;
9819 /* ANSI says that `const int foo ();'
9820 does not make the function foo const. */
9821 type
= build_function_type (type
, arg_types
);
9825 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
9826 if (TREE_PURPOSE (t
)
9827 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
9829 add_defarg_fn (type
);
9838 /* Filter out pointers-to-references and references-to-references.
9839 We can get these if a TYPE_DECL is used. */
9841 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9843 error ("cannot declare %s to references",
9844 TREE_CODE (declarator
) == ADDR_EXPR
9845 ? "references" : "pointers");
9846 declarator
= TREE_OPERAND (declarator
, 0);
9850 if (TREE_CODE (type
) == OFFSET_TYPE
9851 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
9852 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
9854 cp_error ("cannot declare pointer to `%#T' member",
9856 type
= TREE_TYPE (type
);
9859 /* Merge any constancy or volatility into the target type
9862 /* We now know that the TYPE_QUALS don't apply to the decl,
9863 but to the target of the pointer. */
9864 type_quals
= TYPE_UNQUALIFIED
;
9866 if (IS_SIGNATURE (type
))
9868 if (TREE_CODE (declarator
) == ADDR_EXPR
)
9870 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9871 && TYPE_SIZE (type
))
9872 cp_warning ("empty signature `%T' used in signature reference declaration",
9875 type
= build_signature_reference_type (type
);
9877 sorry ("signature reference");
9883 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9884 && TYPE_SIZE (type
))
9885 cp_warning ("empty signature `%T' used in signature pointer declaration",
9887 type
= build_signature_pointer_type (type
);
9890 else if (TREE_CODE (declarator
) == ADDR_EXPR
)
9892 if (TREE_CODE (type
) == VOID_TYPE
)
9893 error ("invalid type: `void &'");
9895 type
= build_reference_type (type
);
9897 else if (TREE_CODE (type
) == METHOD_TYPE
)
9899 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9902 type
= build_pointer_type (type
);
9904 /* Process a list of type modifier keywords (such as
9905 const or volatile) that were given inside the `*' or `&'. */
9907 if (TREE_TYPE (declarator
))
9909 register tree typemodlist
;
9915 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
9916 typemodlist
= TREE_CHAIN (typemodlist
))
9918 tree qualifier
= TREE_VALUE (typemodlist
);
9920 if (qualifier
== ridpointers
[(int) RID_CONST
])
9922 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
9924 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
9929 error ("invalid type modifier within pointer declarator");
9933 pedwarn ("duplicate `const'");
9935 pedwarn ("duplicate `volatile'");
9937 pedwarn ("duplicate `restrict'");
9939 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9940 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9941 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9942 if (TREE_CODE (declarator
) == ADDR_EXPR
9943 && (constp
|| volatilep
))
9946 pedwarn ("discarding `const' applied to a reference");
9948 pedwarn ("discarding `volatile' applied to a reference");
9949 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
9951 type
= cp_build_qualified_type (type
, type_quals
);
9953 declarator
= TREE_OPERAND (declarator
, 0);
9959 /* We have converted type names to NULL_TREE if the
9960 name was bogus, or to a _TYPE node, if not.
9962 The variable CTYPE holds the type we will ultimately
9963 resolve to. The code here just needs to build
9964 up appropriate member types. */
9965 tree sname
= TREE_OPERAND (declarator
, 1);
9968 /* Destructors can have their visibilities changed as well. */
9969 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
9970 sname
= TREE_OPERAND (sname
, 0);
9972 if (TREE_COMPLEXITY (declarator
) == 0)
9973 /* This needs to be here, in case we are called
9974 multiple times. */ ;
9975 else if (TREE_COMPLEXITY (declarator
) == -1)
9976 /* Namespace member. */
9977 pop_decl_namespace ();
9978 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
9979 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
9980 else if (! IS_AGGR_TYPE_CODE
9981 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
9983 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
9985 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
9986 that refer to ctype. They couldn't be resolved earlier
9987 because we hadn't pushed into the class yet.
9988 Example: resolve 'B<T>::type' in
9989 'B<typename B<T>::type> B<T>::f () { }'. */
9990 if (current_template_parms
9991 && uses_template_parms (type
)
9992 && uses_template_parms (current_class_type
))
9994 tree args
= current_template_args ();
9995 type
= tsubst (type
, args
, NULL_TREE
);
9998 /* This pop_nested_class corresponds to the
9999 push_nested_class used to push into class scope for
10000 parsing the argument list of a function decl, in
10002 pop_nested_class (1);
10003 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10006 my_friendly_abort (16);
10008 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10010 /* We had a reference to a global decl, or
10011 perhaps we were given a non-aggregate typedef,
10012 in which case we cleared this out, and should just
10013 keep going as though it wasn't there. */
10014 declarator
= sname
;
10017 ctype
= TREE_OPERAND (declarator
, 0);
10020 while (t
!= NULL_TREE
)
10022 if (CLASSTYPE_TEMPLATE_INFO (t
) &&
10023 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
10024 template_count
+= 1;
10025 t
= TYPE_MAIN_DECL (t
);
10026 if (DECL_LANG_SPECIFIC (t
))
10027 t
= DECL_CLASS_CONTEXT (t
);
10032 if (sname
== NULL_TREE
)
10035 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10037 /* This is the `standard' use of the scoping operator:
10038 basetype :: member . */
10040 if (ctype
== current_class_type
)
10046 Is this ill-formed? */
10049 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10052 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10054 if (current_class_type
== NULL_TREE
10056 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10057 TYPE_ARG_TYPES (type
));
10060 cp_error ("cannot declare member function `%T::%s' within `%T'",
10061 ctype
, name
, current_class_type
);
10062 return void_type_node
;
10065 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10066 || TYPE_SIZE (complete_type (ctype
)) != NULL_TREE
)
10068 /* Have to move this code elsewhere in this function.
10069 this code is used for i.e., typedef int A::M; M *pm;
10071 It is? How? jason 10/2/94 */
10073 if (current_class_type
)
10075 cp_error ("cannot declare member `%T::%s' within `%T'",
10076 ctype
, name
, current_class_type
);
10077 return void_type_node
;
10079 type
= build_offset_type (ctype
, type
);
10081 else if (uses_template_parms (ctype
))
10083 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10085 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
10086 TYPE_ARG_TYPES (type
));
10090 cp_error ("structure `%T' not yet defined", ctype
);
10091 return error_mark_node
;
10094 declarator
= sname
;
10096 else if (TREE_CODE (sname
) == SCOPE_REF
)
10097 my_friendly_abort (17);
10101 declarator
= TREE_OPERAND (declarator
, 1);
10102 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
10103 /* In this case, we will deal with it later. */
10107 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10108 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10109 TYPE_ARG_TYPES (type
));
10111 type
= build_offset_type (ctype
, type
);
10118 declarator
= TREE_OPERAND (declarator
, 0);
10123 case ENUMERAL_TYPE
:
10124 declarator
= NULL_TREE
;
10128 declarator
= NULL_TREE
;
10132 my_friendly_abort (158);
10136 /* See the comment for the TREE_LIST case, above. */
10139 if (! ignore_attrs
)
10140 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10142 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
10144 attrlist
= build_decl_list (NULL_TREE
, inner_attrs
);
10147 if (explicitp
== 1)
10149 error ("only constructors can be declared `explicit'");
10153 /* Now TYPE has the actual type. */
10155 /* If this is declaring a typedef name, return a TYPE_DECL. */
10157 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10159 if (type_quals
& TYPE_QUAL_CONST
)
10161 error ("const `%s' cannot be declared `mutable'", name
);
10162 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10166 error ("static `%s' cannot be declared `mutable'", name
);
10167 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10171 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
10175 /* Note that the grammar rejects storage classes
10176 in typenames, fields or parameters. */
10177 if (current_lang_name
== lang_name_java
)
10178 TYPE_FOR_JAVA (type
) = 1;
10180 if (decl_context
== FIELD
)
10182 if (declarator
== current_class_name
)
10183 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10185 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10186 if (IS_SIGNATURE (current_class_type
) && opaque_typedef
)
10187 SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type
) = 1;
10191 /* Make sure this typedef lives as long as its type,
10192 since it might be used as a template parameter. */
10193 if (type
!= error_mark_node
)
10194 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
10195 decl
= build_decl (TYPE_DECL
, declarator
, type
);
10196 if (type
!= error_mark_node
)
10200 /* If the user declares "struct {...} foo" then `foo' will have
10201 an anonymous name. Fill that name in now. Nothing can
10202 refer to it, so nothing needs know about the name change.
10203 The TYPE_NAME field was filled in by build_struct_xref. */
10204 if (type
!= error_mark_node
10205 && TYPE_NAME (type
)
10206 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10207 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
10209 /* FIXME: This is bogus; we should not be doing this for
10210 cv-qualified types. */
10212 /* For anonymous structs that are cv-qualified, need to use
10213 TYPE_MAIN_VARIANT so that name will mangle correctly. As
10214 type not referenced after this block, don't bother
10215 resetting type to original type, ie. TREE_TYPE (decl). */
10216 type
= TYPE_MAIN_VARIANT (type
);
10218 /* Replace the anonymous name with the real name everywhere. */
10219 lookup_tag_reverse (type
, declarator
);
10220 TYPE_NAME (type
) = decl
;
10222 if (TYPE_LANG_SPECIFIC (type
))
10223 TYPE_WAS_ANONYMOUS (type
) = 1;
10225 /* XXX Temporarily set the scope.
10226 When returning, start_decl expects it as NULL_TREE,
10227 and will then then set it using pushdecl. */
10228 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
10229 if (current_class_type
)
10230 DECL_CONTEXT (decl
) = current_class_type
;
10232 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10234 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
10235 DECL_ASSEMBLER_NAME (decl
)
10236 = get_identifier (build_overload_name (type
, 1, 1));
10237 DECL_CONTEXT (decl
) = NULL_TREE
;
10239 /* FIXME remangle member functions; member functions of a
10240 type with external linkage have external linkage. */
10243 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10245 cp_error_at ("typedef name may not be class-qualified", decl
);
10250 if (ctype
== NULL_TREE
)
10252 if (TREE_CODE (type
) != METHOD_TYPE
)
10253 cp_error_at ("invalid type qualifier for non-method type", decl
);
10255 ctype
= TYPE_METHOD_BASETYPE (type
);
10257 if (ctype
!= NULL_TREE
)
10258 grok_method_quals (ctype
, decl
, quals
);
10261 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10262 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10263 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10265 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10266 error ("non-object member `%s' cannot be declared mutable", name
);
10268 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
10269 inlinep
, friendp
, raises
!= NULL_TREE
);
10272 error ("typedef declaration includes an initializer");
10277 /* Detect the case of an array type of unspecified size
10278 which came, as such, direct from a typedef name.
10279 We must copy the type, so that each identifier gets
10280 a distinct type, so that each identifier's size can be
10281 controlled separately by its own initializer. */
10283 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
10284 && TYPE_DOMAIN (type
) == NULL_TREE
)
10286 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
10289 /* If this is a type name (such as, in a cast or sizeof),
10290 compute the type and return it now. */
10292 if (decl_context
== TYPENAME
)
10294 /* Note that the grammar rejects storage classes
10295 in typenames, fields or parameters. */
10296 if (type_quals
!= TYPE_UNQUALIFIED
)
10298 if (IS_SIGNATURE (type
))
10299 error ("type qualifiers specified for signature type");
10300 type_quals
= TYPE_UNQUALIFIED
;
10303 /* Special case: "friend class foo" looks like a TYPENAME context. */
10306 if (type_quals
!= TYPE_UNQUALIFIED
)
10308 cp_error ("type qualifiers specified for friend class declaration");
10309 type_quals
= TYPE_UNQUALIFIED
;
10313 cp_error ("`inline' specified for friend class declaration");
10317 /* Only try to do this stuff if we didn't already give up. */
10318 if (type
!= integer_type_node
)
10320 /* A friendly class? */
10321 if (current_class_type
)
10322 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
10324 error ("trying to make class `%s' a friend of global scope",
10325 TYPE_NAME_STRING (type
));
10326 type
= void_type_node
;
10331 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
10332 if (ctype
== NULL_TREE
)
10334 my_friendly_assert (TREE_CODE (type
) == METHOD_TYPE
, 159);
10335 ctype
= TYPE_METHOD_BASETYPE (type
);
10337 grok_method_quals (ctype
, dummy
, quals
);
10338 type
= TREE_TYPE (dummy
);
10343 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
10344 && decl_context
!= CATCHPARM
10345 && TREE_CODE (type
) != UNION_TYPE
10348 cp_error ("abstract declarator `%T' used as declaration", type
);
10349 declarator
= make_anon_name ();
10352 /* `void' at top level (not within pointer)
10353 is allowed only in typedefs or type names.
10354 We don't complain about parms either, but that is because
10355 a better error message can be made later. */
10357 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
10360 error ("unnamed variable or field declared void");
10361 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10363 if (IDENTIFIER_OPNAME_P (declarator
))
10364 my_friendly_abort (356);
10366 error ("variable or field `%s' declared void", name
);
10369 error ("variable or field declared void");
10370 type
= integer_type_node
;
10373 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10374 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10376 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10378 if (ctype
|| in_namespace
)
10379 error ("cannot use `::' in parameter declaration");
10381 /* A parameter declared as an array of T is really a pointer to T.
10382 One declared as a function is really a pointer to a function.
10383 One declared as a member is really a pointer to member. */
10385 if (TREE_CODE (type
) == ARRAY_TYPE
)
10387 /* Transfer const-ness of array into that of type pointed to. */
10388 type
= build_pointer_type (TREE_TYPE (type
));
10389 type_quals
= TYPE_UNQUALIFIED
;
10391 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10392 type
= build_pointer_type (type
);
10393 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10394 type
= build_pointer_type (type
);
10395 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
10397 error ("declaration of `%s' as void", name
);
10403 register tree decl
;
10405 if (decl_context
== PARM
)
10407 decl
= build_decl (PARM_DECL
, declarator
, complete_type (type
));
10409 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
10410 inlinep
, friendp
, raises
!= NULL_TREE
);
10411 if (current_class_type
10412 && IS_SIGNATURE (current_class_type
))
10415 error ("parameter of signature member function declared `inline'");
10416 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10417 error ("parameter of signature member function declared `auto'");
10418 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10419 error ("parameter of signature member function declared `register'");
10422 /* Compute the type actually passed in the parmlist,
10423 for the case where there is no prototype.
10424 (For example, shorts and chars are passed as ints.)
10425 When there is a prototype, this is overridden later. */
10427 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
10429 else if (decl_context
== FIELD
)
10431 if (type
== error_mark_node
)
10433 /* Happens when declaring arrays of sizes which
10434 are error_mark_node, for example. */
10437 else if (in_namespace
)
10439 /* Something like struct S { int N::j; }; */
10440 cp_error ("invalid use of `::'");
10443 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10446 tree function_context
;
10448 /* We catch the others as conflicts with the builtin
10450 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
10452 cp_error ("function `%D' cannot be declared friend",
10459 if (ctype
== NULL_TREE
)
10460 ctype
= current_class_type
;
10462 if (ctype
== NULL_TREE
)
10464 cp_error ("can't make `%D' into a method -- not in a class",
10466 return void_type_node
;
10469 /* ``A union may [ ... ] not [ have ] virtual functions.''
10471 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10473 cp_error ("function `%D' declared virtual inside a union",
10475 return void_type_node
;
10478 if (declarator
== ansi_opname
[(int) NEW_EXPR
]
10479 || declarator
== ansi_opname
[(int) VEC_NEW_EXPR
]
10480 || declarator
== ansi_opname
[(int) DELETE_EXPR
]
10481 || declarator
== ansi_opname
[(int) VEC_DELETE_EXPR
])
10485 cp_error ("`%D' cannot be declared virtual, since it is always static",
10490 else if (staticp
< 2)
10491 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10492 TYPE_ARG_TYPES (type
));
10495 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10496 function_context
= (ctype
!= NULL_TREE
) ?
10497 hack_decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10498 publicp
= (! friendp
|| ! staticp
)
10499 && function_context
== NULL_TREE
;
10500 decl
= grokfndecl (ctype
, type
,
10501 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
10502 ? declarator
: dname
,
10504 virtualp
, flags
, quals
, raises
, attrlist
,
10505 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
10506 funcdef_flag
, template_count
, in_namespace
);
10507 if (decl
== NULL_TREE
|| decl
== error_mark_node
)
10510 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10511 /* The decl and setting of decl_machine_attr is also turned off. */
10512 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
10515 /* [class.conv.ctor]
10517 A constructor declared without the function-specifier
10518 explicit that can be called with a single parameter
10519 specifies a conversion from the type of its first
10520 parameter to the type of its class. Such a constructor
10521 is called a converting constructor. */
10522 if (explicitp
== 2)
10523 DECL_NONCONVERTING_P (decl
) = 1;
10524 else if (DECL_CONSTRUCTOR_P (decl
))
10526 /* The constructor can be called with exactly one
10527 parameter if there is at least one parameter, and
10528 any subsequent parameters have default arguments.
10529 We don't look at the first parameter, which is
10530 really just the `this' parameter for the new
10533 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
10535 /* Skip the `in_chrg' argument too, if present. */
10536 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl
)))
10537 arg_types
= TREE_CHAIN (arg_types
);
10539 if (arg_types
== void_list_node
10541 && TREE_CHAIN (arg_types
)
10542 && TREE_CHAIN (arg_types
) != void_list_node
10543 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
10544 DECL_NONCONVERTING_P (decl
) = 1;
10547 else if (TREE_CODE (type
) == METHOD_TYPE
)
10549 /* We only get here for friend declarations of
10550 members of other classes. */
10551 /* All method decls are public, so tell grokfndecl to set
10552 TREE_PUBLIC, also. */
10553 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
10554 virtualp
, flags
, quals
, raises
, attrlist
,
10555 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
10556 template_count
, in_namespace
);
10557 if (decl
== NULL_TREE
)
10560 else if (!staticp
&& ! processing_template_decl
10561 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
10562 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10565 cp_error ("field `%D' has incomplete type", declarator
);
10567 cp_error ("name `%T' has incomplete type", type
);
10569 /* If we're instantiating a template, tell them which
10570 instantiation made the field's type be incomplete. */
10571 if (current_class_type
10572 && TYPE_NAME (current_class_type
)
10573 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
10574 && declspecs
&& TREE_VALUE (declspecs
)
10575 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
10576 cp_error (" in instantiation of template `%T'",
10577 current_class_type
);
10579 type
= error_mark_node
;
10586 error ("`%s' is neither function nor method; cannot be declared friend",
10587 IDENTIFIER_POINTER (declarator
));
10595 /* Friends are treated specially. */
10596 if (ctype
== current_class_type
)
10597 warning ("member functions are implicitly friends of their class");
10600 tree t
= NULL_TREE
;
10601 if (decl
&& DECL_NAME (decl
))
10603 if (template_class_depth (current_class_type
) == 0)
10606 = check_explicit_specialization
10608 template_count
, 2 * (funcdef_flag
!= 0) + 4);
10609 if (decl
== error_mark_node
)
10610 return error_mark_node
;
10613 t
= do_friend (ctype
, declarator
, decl
,
10614 last_function_parms
, flags
, quals
,
10617 if (t
&& funcdef_flag
)
10620 return void_type_node
;
10624 /* Structure field. It may not be a function, except for C++ */
10626 if (decl
== NULL_TREE
)
10632 /* An attempt is being made to initialize a non-static
10633 member. But, from [class.mem]:
10635 4 A member-declarator can contain a
10636 constant-initializer only if it declares a static
10637 member (_class.static_) of integral or enumeration
10638 type, see _class.static.data_.
10640 This used to be relatively common practice, but
10641 the rest of the compiler does not correctly
10642 handle the initialization unless the member is
10643 static so we make it static below. */
10644 cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
10645 constp
? "const member" : "member",
10647 cp_pedwarn ("making `%D' static", declarator
);
10651 /* Motion 10 at San Diego: If a static const integral data
10652 member is initialized with an integral constant
10653 expression, the initializer may appear either in the
10654 declaration (within the class), or in the definition,
10655 but not both. If it appears in the class, the member is
10656 a member constant. The file-scope definition is always
10658 if (CLASS_TYPE_P (type
)
10659 || TREE_CODE (type
) == REFERENCE_TYPE
)
10661 cp_error ("in-class initialization of static data member of non-integral type `%T'",
10663 /* If we just return the declaration, crashes will
10664 sometimes occur. We therefore return
10665 void_type_node, as if this was a friend
10666 declaration, to cause callers to completely
10667 ignore this declaration. */
10668 return void_type_node
;
10671 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
10673 else if (pedantic
&& ! INTEGRAL_TYPE_P (type
)
10674 && !uses_template_parms (type
))
10675 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", declarator
, type
);
10680 /* ANSI C++ Apr '95 wp 9.2 */
10681 if (declarator
== current_class_name
)
10682 cp_pedwarn ("ANSI C++ forbids static member `%D' with same name as enclosing class",
10685 /* C++ allows static class members.
10686 All other work for this is done by grokfield.
10687 This VAR_DCL is built by build_lang_field_decl.
10688 All other VAR_DECLs are built by build_decl. */
10689 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
10690 TREE_STATIC (decl
) = 1;
10691 /* In class context, 'static' means public access. */
10692 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
10696 decl
= build_lang_field_decl (FIELD_DECL
, declarator
, type
);
10697 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10699 DECL_MUTABLE_P (decl
) = 1;
10700 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10704 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
10705 inlinep
, friendp
, raises
!= NULL_TREE
);
10708 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10710 tree original_name
;
10716 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10717 original_name
= dname
;
10719 original_name
= declarator
;
10721 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10722 error ("storage class `auto' invalid for function `%s'", name
);
10723 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10724 error ("storage class `register' invalid for function `%s'", name
);
10726 /* Function declaration not at top level.
10727 Storage classes other than `extern' are not allowed
10728 and `extern' makes no difference. */
10729 if (! toplevel_bindings_p ()
10730 && (RIDBIT_SETP (RID_STATIC
, specbits
)
10731 || RIDBIT_SETP (RID_INLINE
, specbits
))
10734 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10735 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
10737 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
10740 if (ctype
== NULL_TREE
)
10744 error ("virtual non-class function `%s'", name
);
10748 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
10749 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10750 TYPE_ARG_TYPES (type
));
10752 /* Record presence of `static'. */
10753 publicp
= (ctype
!= NULL_TREE
10754 || RIDBIT_SETP (RID_EXTERN
, specbits
)
10755 || !RIDBIT_SETP (RID_STATIC
, specbits
));
10757 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
10758 virtualp
, flags
, quals
, raises
, attrlist
,
10760 publicp
, inlinep
, funcdef_flag
,
10761 template_count
, in_namespace
);
10762 if (decl
== NULL_TREE
)
10765 /* Among other times, could occur from check_explicit_specialization
10766 returning an error_mark_node. */
10767 if (decl
== error_mark_node
)
10768 return error_mark_node
;
10772 int illegal_static
= 0;
10774 /* Don't allow a static member function in a class, and forbid
10775 declaring main to be static. */
10776 if (TREE_CODE (type
) == METHOD_TYPE
)
10778 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
10779 illegal_static
= 1;
10781 else if (current_function_decl
)
10783 /* FIXME need arm citation */
10784 error ("cannot declare static function inside another function");
10785 illegal_static
= 1;
10788 if (illegal_static
)
10791 RIDBIT_RESET (RID_STATIC
, specbits
);
10797 /* It's a variable. */
10799 /* An uninitialized decl with `extern' is a reference. */
10800 decl
= grokvardecl (type
, declarator
, &specbits
,
10801 initialized
, constp
, in_namespace
);
10802 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
10803 inlinep
, friendp
, raises
!= NULL_TREE
);
10807 DECL_CONTEXT (decl
) = ctype
;
10810 cp_pedwarn ("static member `%D' re-declared as static", decl
);
10812 RIDBIT_RESET (RID_STATIC
, specbits
);
10814 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
10816 cp_error ("static member `%D' declared `register'", decl
);
10817 RIDBIT_RESET (RID_REGISTER
, specbits
);
10819 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
10821 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
10823 RIDBIT_RESET (RID_EXTERN
, specbits
);
10828 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10830 error ("`%s' cannot be declared mutable", name
);
10833 /* Record `register' declaration for warnings on &
10834 and in case doing stupid register allocation. */
10836 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10837 DECL_REGISTER (decl
) = 1;
10839 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
10840 DECL_THIS_EXTERN (decl
) = 1;
10842 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10843 DECL_THIS_STATIC (decl
) = 1;
10845 /* Record constancy and volatility. */
10846 /* FIXME: Disallow `restrict' pointer-to-member declarations. */
10847 c_apply_type_quals_to_decl (type_quals
, decl
);
10853 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
10854 An empty exprlist is a parmlist. An exprlist which
10855 contains only identifiers at the global level
10856 is a parmlist. Otherwise, it is an exprlist. */
10859 parmlist_is_exprlist (exprs
)
10862 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
10865 if (toplevel_bindings_p ())
10867 /* At the global level, if these are all identifiers,
10868 then it is a parmlist. */
10871 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
10873 exprs
= TREE_CHAIN (exprs
);
10880 /* Subroutine of `grokparms'. In a fcn definition, arg types must
10883 C++: also subroutine of `start_function'. */
10886 require_complete_types_for_parms (parms
)
10889 if (processing_template_decl
)
10894 tree type
= TREE_TYPE (parms
);
10895 if (TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
10897 if (DECL_NAME (parms
))
10898 error ("parameter `%s' has incomplete type",
10899 IDENTIFIER_POINTER (DECL_NAME (parms
)));
10901 error ("parameter has incomplete type");
10902 TREE_TYPE (parms
) = error_mark_node
;
10905 /* If the arg types are incomplete in a declaration,
10906 they must include undefined tags.
10907 These tags can never be defined in the scope of the declaration,
10908 so the types can never be completed,
10909 and no call can be compiled successfully. */
10910 /* This is not the right behavior for C++, but not having
10911 it is also probably wrong. */
10914 /* Now warn if is a pointer to an incomplete type. */
10915 while (TREE_CODE (type
) == POINTER_TYPE
10916 || TREE_CODE (type
) == REFERENCE_TYPE
)
10917 type
= TREE_TYPE (type
);
10918 type
= TYPE_MAIN_VARIANT (type
);
10919 if (TYPE_SIZE (type
) == NULL_TREE
)
10921 if (DECL_NAME (parm
) != NULL_TREE
)
10922 warning ("parameter `%s' points to incomplete type",
10923 IDENTIFIER_POINTER (DECL_NAME (parm
)));
10925 warning ("parameter points to incomplete type");
10929 parms
= TREE_CHAIN (parms
);
10933 /* Decode the list of parameter types for a function type.
10934 Given the list of things declared inside the parens,
10935 return a list of types.
10937 The list we receive can have three kinds of elements:
10938 an IDENTIFIER_NODE for names given without types,
10939 a TREE_LIST node for arguments given as typespecs or names with typespecs,
10940 or void_type_node, to mark the end of an argument list
10941 when additional arguments are not permitted (... was not used).
10943 FUNCDEF_FLAG is nonzero for a function definition, 0 for
10944 a mere declaration. A nonempty identifier-list gets an error message
10945 when FUNCDEF_FLAG is zero.
10946 If FUNCDEF_FLAG is 1, then parameter types must be complete.
10947 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
10949 If all elements of the input list contain types,
10950 we return a list of the types.
10951 If all elements contain no type (except perhaps a void_type_node
10952 at the end), we return a null list.
10953 If some have types and some do not, it is an error, and we
10954 return a null list.
10956 Also set last_function_parms to either
10957 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
10958 A list of names is converted to a chain of PARM_DECLs
10959 by store_parm_decls so that ultimately it is always a chain of decls.
10961 Note that in C++, parameters can take default values. These default
10962 values are in the TREE_PURPOSE field of the TREE_LIST. It is
10963 an error to specify default values which are followed by parameters
10964 that have no default values, or an ELLIPSES. For simplicities sake,
10965 only parameters which are specified with their types can take on
10969 grokparms (first_parm
, funcdef_flag
)
10973 tree result
= NULL_TREE
;
10974 tree decls
= NULL_TREE
;
10976 if (first_parm
!= NULL_TREE
10977 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
10979 if (! funcdef_flag
)
10980 pedwarn ("parameter names (without types) in function declaration");
10981 last_function_parms
= first_parm
;
10984 else if (first_parm
!= NULL_TREE
10985 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
10986 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
10987 my_friendly_abort (145);
10990 /* Types were specified. This is a list of declarators
10991 each represented as a TREE_LIST node. */
10992 register tree parm
, chain
;
10993 int any_init
= 0, any_error
= 0;
10995 if (first_parm
!= NULL_TREE
)
10997 tree last_result
= NULL_TREE
;
10998 tree last_decl
= NULL_TREE
;
11000 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
11002 tree type
= NULL_TREE
, list_node
= parm
;
11003 register tree decl
= TREE_VALUE (parm
);
11004 tree init
= TREE_PURPOSE (parm
);
11006 chain
= TREE_CHAIN (parm
);
11007 /* @@ weak defense against parse errors. */
11008 if (TREE_CODE (decl
) != VOID_TYPE
11009 && TREE_CODE (decl
) != TREE_LIST
)
11011 /* Give various messages as the need arises. */
11012 if (TREE_CODE (decl
) == STRING_CST
)
11013 cp_error ("invalid string constant `%E'", decl
);
11014 else if (TREE_CODE (decl
) == INTEGER_CST
)
11015 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11019 if (TREE_CODE (decl
) != VOID_TYPE
)
11021 decl
= grokdeclarator (TREE_VALUE (decl
),
11022 TREE_PURPOSE (decl
),
11023 PARM
, init
!= NULL_TREE
,
11028 /* Top-level qualifiers on the parameters are
11029 ignored for function types. */
11030 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
11032 if (TREE_CODE (type
) == VOID_TYPE
)
11033 decl
= void_type_node
;
11034 else if (TREE_CODE (type
) == METHOD_TYPE
)
11036 if (DECL_NAME (decl
))
11037 /* Cannot use the decl here because
11038 we don't have DECL_CONTEXT set up yet. */
11039 cp_error ("parameter `%D' invalidly declared method type",
11042 error ("parameter invalidly declared method type");
11043 type
= build_pointer_type (type
);
11044 TREE_TYPE (decl
) = type
;
11046 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11048 if (DECL_NAME (decl
))
11049 cp_error ("parameter `%D' invalidly declared offset type",
11052 error ("parameter invalidly declared offset type");
11053 type
= build_pointer_type (type
);
11054 TREE_TYPE (decl
) = type
;
11056 else if (TREE_CODE (type
) == RECORD_TYPE
11057 && TYPE_LANG_SPECIFIC (type
)
11058 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
11060 abstract_virtuals_error (decl
, type
);
11061 any_error
= 1; /* Seems like a good idea. */
11063 else if (TREE_CODE (type
) == RECORD_TYPE
11064 && TYPE_LANG_SPECIFIC (type
)
11065 && IS_SIGNATURE (type
))
11067 signature_error (decl
, type
);
11068 any_error
= 1; /* Seems like a good idea. */
11070 else if (POINTER_TYPE_P (type
))
11073 while (POINTER_TYPE_P (t
)
11074 || (TREE_CODE (t
) == ARRAY_TYPE
11075 && TYPE_DOMAIN (t
) != NULL_TREE
))
11077 if (TREE_CODE (t
) == ARRAY_TYPE
)
11078 cp_error ("parameter type `%T' includes %s to array of unknown bound",
11080 TYPE_PTR_P (type
) ? "pointer" : "reference");
11084 if (TREE_CODE (decl
) == VOID_TYPE
)
11086 if (result
== NULL_TREE
)
11088 result
= void_list_node
;
11089 last_result
= result
;
11093 TREE_CHAIN (last_result
) = void_list_node
;
11094 last_result
= void_list_node
;
11097 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
11098 error ("`void' in parameter list must be entire list");
11102 /* Since there is a prototype, args are passed in their own types. */
11103 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
11104 #ifdef PROMOTE_PROTOTYPES
11105 if ((TREE_CODE (type
) == INTEGER_TYPE
11106 || TREE_CODE (type
) == ENUMERAL_TYPE
)
11107 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
11108 DECL_ARG_TYPE (decl
) = integer_type_node
;
11115 if (TREE_CODE (init
) == SAVE_EXPR
)
11116 PARM_DECL_EXPR (init
) = 1;
11117 else if (processing_template_decl
)
11119 /* Unparsed default arg from in-class decl. */
11120 else if (TREE_CODE (init
) == DEFAULT_ARG
)
11122 else if (TREE_CODE (init
) == VAR_DECL
11123 || TREE_CODE (init
) == PARM_DECL
)
11125 if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init
)))
11127 /* ``Local variables may not be used in default
11128 argument expressions.'' dpANSI C++ 8.2.6 */
11129 /* If extern int i; within a function is not
11130 considered a local variable, then this code is
11132 cp_error ("local variable `%D' may not be used as a default argument", init
);
11135 else if (TREE_READONLY_DECL_P (init
))
11136 init
= decl_constant_value (init
);
11139 init
= require_instantiated_type (type
, init
, integer_zero_node
);
11140 if (! processing_template_decl
11141 && init
!= error_mark_node
11142 && TREE_CODE (init
) != DEFAULT_ARG
11143 && ! can_convert_arg (type
, TREE_TYPE (init
), init
))
11144 cp_pedwarn ("invalid type `%T' for default argument to `%#D'",
11145 TREE_TYPE (init
), decl
);
11151 if (decls
== NULL_TREE
)
11158 TREE_CHAIN (last_decl
) = decl
;
11161 if (! current_function_decl
&& TREE_PERMANENT (list_node
))
11163 TREE_PURPOSE (list_node
) = init
;
11164 TREE_VALUE (list_node
) = type
;
11165 TREE_CHAIN (list_node
) = NULL_TREE
;
11168 list_node
= saveable_tree_cons (init
, type
, NULL_TREE
);
11169 if (result
== NULL_TREE
)
11171 result
= list_node
;
11172 last_result
= result
;
11176 TREE_CHAIN (last_result
) = list_node
;
11177 last_result
= list_node
;
11181 TREE_CHAIN (last_result
) = NULL_TREE
;
11182 /* If there are no parameters, and the function does not end
11183 with `...', then last_decl will be NULL_TREE. */
11184 if (last_decl
!= NULL_TREE
)
11185 TREE_CHAIN (last_decl
) = NULL_TREE
;
11189 last_function_parms
= decls
;
11191 /* In a fcn definition, arg types must be complete. */
11192 if (funcdef_flag
> 0)
11193 require_complete_types_for_parms (last_function_parms
);
11198 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11199 FUNCTION_TYPE with the newly parsed version of its default argument, which
11200 was previously digested as text. See snarf_defarg et al in lex.c. */
11203 replace_defarg (arg
, init
)
11206 if (! processing_template_decl
11207 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
11208 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11209 TREE_TYPE (init
), TREE_VALUE (arg
));
11210 TREE_PURPOSE (arg
) = init
;
11217 tree t
= FUNCTION_ARG_CHAIN (d
);
11218 if (DECL_CONSTRUCTOR_P (d
)
11219 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d
)))
11220 t
= TREE_CHAIN (t
);
11221 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
11222 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
11223 == DECL_CLASS_CONTEXT (d
))
11224 && (TREE_CHAIN (t
) == NULL_TREE
11225 || TREE_CHAIN (t
) == void_list_node
11226 || TREE_PURPOSE (TREE_CHAIN (t
))))
11231 /* These memoizing functions keep track of special properties which
11232 a class may have. `grok_ctor_properties' notices whether a class
11233 has a constructor of the form X(X&), and also complains
11234 if the class has a constructor of the form X(X).
11235 `grok_op_properties' takes notice of the various forms of
11236 operator= which are defined, as well as what sorts of type conversion
11237 may apply. Both functions take a FUNCTION_DECL as an argument. */
11240 grok_ctor_properties (ctype
, decl
)
11243 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
11244 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
11246 /* When a type has virtual baseclasses, a magical first int argument is
11247 added to any ctor so we can tell if the class has been initialized
11248 yet. This could screw things up in this function, so we deliberately
11249 ignore the leading int if we're in that situation. */
11250 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
11252 my_friendly_assert (parmtypes
11253 && TREE_VALUE (parmtypes
) == integer_type_node
,
11255 parmtypes
= TREE_CHAIN (parmtypes
);
11256 parmtype
= TREE_VALUE (parmtypes
);
11259 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
11260 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
11261 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11262 || TREE_CHAIN (parmtypes
) == void_list_node
11263 || TREE_PURPOSE (TREE_CHAIN (parmtypes
))))
11265 TYPE_HAS_INIT_REF (ctype
) = 1;
11266 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11267 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
11269 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
11270 && TREE_CHAIN (parmtypes
) != NULL_TREE
11271 && TREE_CHAIN (parmtypes
) == void_list_node
)
11273 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11275 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
11278 else if (TREE_CODE (parmtype
) == VOID_TYPE
11279 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
11280 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
11285 /* An operator with this name can be either unary or binary. */
11291 return (name
== ansi_opname
[(int) INDIRECT_REF
]
11292 || name
== ansi_opname
[(int) ADDR_EXPR
]
11293 || name
== ansi_opname
[(int) NEGATE_EXPR
]
11294 || name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11295 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]
11296 || name
== ansi_opname
[(int) CONVERT_EXPR
]);
11299 /* An operator with this name can only be unary. */
11305 return (name
== ansi_opname
[(int) TRUTH_NOT_EXPR
]
11306 || name
== ansi_opname
[(int) BIT_NOT_EXPR
]
11307 || name
== ansi_opname
[(int) COMPONENT_REF
]
11308 || OPERATOR_TYPENAME_P (name
));
11311 /* Do a little sanity-checking on how they declared their operator. */
11314 grok_op_properties (decl
, virtualp
, friendp
)
11316 int virtualp
, friendp
;
11318 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11319 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11320 tree name
= DECL_NAME (decl
);
11322 if (current_class_type
== NULL_TREE
)
11327 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11328 TYPE_HAS_ASSIGNMENT (current_class_type
) = 1;
11329 else if (name
== ansi_opname
[(int) CALL_EXPR
])
11330 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
11331 else if (name
== ansi_opname
[(int) ARRAY_REF
])
11332 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
11333 else if (name
== ansi_opname
[(int) COMPONENT_REF
]
11334 || name
== ansi_opname
[(int) MEMBER_REF
])
11335 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
11336 else if (name
== ansi_opname
[(int) NEW_EXPR
])
11337 TYPE_GETS_NEW (current_class_type
) |= 1;
11338 else if (name
== ansi_opname
[(int) DELETE_EXPR
])
11339 TYPE_GETS_DELETE (current_class_type
) |= 1;
11340 else if (name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11341 TYPE_GETS_NEW (current_class_type
) |= 2;
11342 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11343 TYPE_GETS_DELETE (current_class_type
) |= 2;
11346 if (name
== ansi_opname
[(int) NEW_EXPR
]
11347 || name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11349 /* When the compiler encounters the definition of A::operator new, it
11350 doesn't look at the class declaration to find out if it's static. */
11352 revert_static_member_fn (&decl
, NULL
, NULL
);
11354 /* Take care of function decl if we had syntax errors. */
11355 if (argtypes
== NULL_TREE
)
11357 = build_function_type (ptr_type_node
,
11358 hash_tree_chain (integer_type_node
,
11361 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11363 else if (name
== ansi_opname
[(int) DELETE_EXPR
]
11364 || name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11367 revert_static_member_fn (&decl
, NULL
, NULL
);
11369 if (argtypes
== NULL_TREE
)
11371 = build_function_type (void_type_node
,
11372 hash_tree_chain (ptr_type_node
,
11376 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11378 if (! friendp
&& name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
11379 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
11380 != void_list_node
))
11381 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type
) = 1;
11386 /* An operator function must either be a non-static member function
11387 or have at least one parameter of a class, a reference to a class,
11388 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11389 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11391 if (OPERATOR_TYPENAME_P (name
)
11392 || name
== ansi_opname
[(int) CALL_EXPR
]
11393 || name
== ansi_opname
[(int) MODIFY_EXPR
]
11394 || name
== ansi_opname
[(int) COMPONENT_REF
]
11395 || name
== ansi_opname
[(int) ARRAY_REF
])
11396 cp_error ("`%D' must be a nonstatic member function", decl
);
11401 if (DECL_STATIC_FUNCTION_P (decl
))
11402 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
11405 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
11407 tree arg
= TREE_VALUE (p
);
11408 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
11409 arg
= TREE_TYPE (arg
);
11411 /* This lets bad template code slip through. */
11412 if (IS_AGGR_TYPE (arg
)
11413 || TREE_CODE (arg
) == ENUMERAL_TYPE
11414 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
11415 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11419 ("`%D' must have an argument of class or enumerated type",
11426 if (name
== ansi_opname
[(int) CALL_EXPR
])
11427 return; /* No restrictions on args. */
11429 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
11431 tree t
= TREE_TYPE (name
);
11432 if (TREE_CODE (t
) == VOID_TYPE
)
11433 pedwarn ("void is not a valid type conversion operator");
11434 else if (! friendp
)
11436 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11439 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11441 if (t
== current_class_type
)
11442 what
= "the same type";
11443 /* Don't force t to be complete here. */
11444 else if (IS_AGGR_TYPE (t
)
11446 && DERIVED_FROM_P (t
, current_class_type
))
11447 what
= "a base class";
11450 warning ("conversion to %s%s will never use a type conversion operator",
11451 ref
? "a reference to " : "", what
);
11455 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11459 if (list_length (argtypes
) != 3 && methodp
)
11461 cp_error ("`%D' must take exactly one argument", decl
);
11464 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
11466 if (copy_assignment_arg_p (parmtype
, virtualp
)
11469 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
11470 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
11471 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11472 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
11475 else if (name
== ansi_opname
[(int) COND_EXPR
])
11478 pedwarn ("ANSI C++ prohibits overloading operator ?:");
11479 if (list_length (argtypes
) != 4)
11480 cp_error ("`%D' must take exactly three arguments", decl
);
11482 else if (ambi_op_p (name
))
11484 if (list_length (argtypes
) == 2)
11486 else if (list_length (argtypes
) == 3)
11488 if ((name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11489 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11490 && ! processing_template_decl
11491 && TREE_VALUE (TREE_CHAIN (argtypes
)) != integer_type_node
)
11494 cp_error ("postfix `%D' must take `int' as its argument",
11498 ("postfix `%D' must take `int' as its second argument",
11505 cp_error ("`%D' must take either zero or one argument", decl
);
11507 cp_error ("`%D' must take either one or two arguments", decl
);
11510 /* More Effective C++ rule 6. */
11512 && (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11513 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]))
11515 tree arg
= TREE_VALUE (argtypes
);
11516 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11517 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11518 arg
= TREE_TYPE (arg
);
11519 arg
= TYPE_MAIN_VARIANT (arg
);
11520 if (list_length (argtypes
) == 2)
11522 if (TREE_CODE (ret
) != REFERENCE_TYPE
11523 || !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11525 cp_warning ("prefix `%D' should return `%T'", decl
,
11526 build_reference_type (arg
));
11530 if (!comptypes (TYPE_MAIN_VARIANT (ret
), arg
, 1))
11531 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
11535 else if (unary_op_p (name
))
11537 if (list_length (argtypes
) != 2)
11540 cp_error ("`%D' must take `void'", decl
);
11542 cp_error ("`%D' must take exactly one argument", decl
);
11545 else /* if (binary_op_p (name)) */
11547 if (list_length (argtypes
) != 3)
11550 cp_error ("`%D' must take exactly one argument", decl
);
11552 cp_error ("`%D' must take exactly two arguments", decl
);
11555 /* More Effective C++ rule 7. */
11557 && (name
== ansi_opname
[TRUTH_ANDIF_EXPR
]
11558 || name
== ansi_opname
[TRUTH_ORIF_EXPR
]
11559 || name
== ansi_opname
[COMPOUND_EXPR
]))
11560 cp_warning ("user-defined `%D' always evaluates both arguments",
11564 /* Effective C++ rule 23. */
11566 && list_length (argtypes
) == 3
11567 && (name
== ansi_opname
[PLUS_EXPR
]
11568 || name
== ansi_opname
[MINUS_EXPR
]
11569 || name
== ansi_opname
[TRUNC_DIV_EXPR
]
11570 || name
== ansi_opname
[MULT_EXPR
])
11571 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11572 cp_warning ("`%D' should return by value", decl
);
11576 for (; argtypes
!= void_list_node
; argtypes
= TREE_CHAIN (argtypes
))
11577 if (TREE_PURPOSE (argtypes
))
11579 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11580 if (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11581 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11584 cp_pedwarn ("`%D' cannot have default arguments", decl
);
11587 cp_error ("`%D' cannot have default arguments", decl
);
11592 /* Get the struct, enum or union (CODE says which) with tag NAME.
11593 Define the tag as a forward-reference if it is not defined.
11595 C++: If a class derivation is given, process it here, and report
11596 an error if multiple derivation declarations are not identical.
11598 If this is a definition, come in through xref_tag and only look in
11599 the current frame for the name (since C++ allows new names in any
11603 xref_tag (code_type_node
, name
, globalize
)
11604 tree code_type_node
;
11608 enum tag_types tag_code
;
11609 enum tree_code code
;
11611 register tree ref
, t
;
11612 struct binding_level
*b
= inner_binding_level
;
11614 tree attributes
= NULL_TREE
;
11616 /* If we are called from the parser, code_type_node will sometimes be a
11617 TREE_LIST. This indicates that the user wrote
11618 "class __attribute__ ((foo)) bar". Extract the attributes so we can
11620 if (TREE_CODE (code_type_node
) == TREE_LIST
)
11622 attributes
= TREE_PURPOSE (code_type_node
);
11623 code_type_node
= TREE_VALUE (code_type_node
);
11626 tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11631 case signature_type
:
11632 code
= RECORD_TYPE
;
11638 code
= ENUMERAL_TYPE
;
11641 my_friendly_abort (18);
11644 /* If a cross reference is requested, look up the type
11645 already defined for this tag and return it. */
11646 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
11649 name
= TYPE_IDENTIFIER (t
);
11653 t
= IDENTIFIER_TYPE_VALUE (name
);
11655 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
11656 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
)
11661 if (t
&& (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
11662 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
))
11664 cp_error ("redeclaration of template type-parameter `%T'", name
);
11665 cp_error_at (" previously declared here `%#D'",
11666 TEMPLATE_TYPE_DECL (t
));
11668 if (t
&& TYPE_CONTEXT (t
) && got_type
)
11671 /* If we know we are defining this tag, only look it up in
11672 this scope and don't try to find it as a type. */
11673 ref
= lookup_tag (code
, name
, b
, 1);
11677 if (current_class_type
11678 && template_class_depth (current_class_type
)
11679 && PROCESSING_REAL_TEMPLATE_DECL_P ())
11680 /* Since GLOBALIZE is non-zero, we are not looking at a
11681 definition of this tag. Since, in addition, we are currently
11682 processing a (member) template declaration of a template
11683 class, we don't want to do any lookup at all; consider:
11690 { template <class V>
11691 friend struct S1; };
11693 Here, the S2::S1 declaration should not be confused with the
11694 outer declaration. In particular, the inner version should
11695 have a template parameter of level 2, not level 1. This
11696 would be particularly important if the member declaration
11699 template <class V = U> friend struct S1;
11701 say, when we should tsubst into `U' when instantiating S2. */
11708 ref
= lookup_tag (code
, name
, b
, 0);
11712 /* Try finding it as a type declaration. If that wins,
11714 ref
= lookup_name (name
, 1);
11716 if (ref
!= NULL_TREE
11717 && processing_template_decl
11718 && DECL_CLASS_TEMPLATE_P (ref
)
11719 && template_class_depth (current_class_type
) == 0)
11720 /* Since GLOBALIZE is true, we're declaring a global
11721 template, so we want this type. */
11722 ref
= DECL_RESULT (ref
);
11724 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
11725 && TREE_CODE (TREE_TYPE (ref
)) == code
)
11726 ref
= TREE_TYPE (ref
);
11733 push_obstacks_nochange ();
11737 /* If no such tag is yet defined, create a forward-reference node
11738 and record it as the "definition".
11739 When a real declaration of this type is found,
11740 the forward-reference will be altered into a real type. */
11742 /* In C++, since these migrate into the global scope, we must
11743 build them on the permanent obstack. */
11745 temp
= allocation_temporary_p ();
11747 end_temporary_allocation ();
11749 if (code
== ENUMERAL_TYPE
)
11751 cp_error ("use of enum `%#D' without previous declaration", name
);
11753 ref
= make_node (ENUMERAL_TYPE
);
11755 /* Give the type a default layout like unsigned int
11756 to avoid crashing if it does not get defined. */
11757 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
11758 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
11759 TREE_UNSIGNED (ref
) = 1;
11760 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
11761 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
11762 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
11764 /* Enable us to recognize when a type is created in class context.
11765 To do nested classes correctly, this should probably be cleared
11766 out when we leave this classes scope. Currently this in only
11767 done in `start_enum'. */
11769 pushtag (name
, ref
, globalize
);
11773 struct binding_level
*old_b
= class_binding_level
;
11775 ref
= make_lang_type (code
);
11777 if (tag_code
== signature_type
)
11779 SET_SIGNATURE (ref
);
11780 /* Since a signature type will be turned into the type
11781 of signature tables, it's not only an interface. */
11782 CLASSTYPE_INTERFACE_ONLY (ref
) = 0;
11783 SET_CLASSTYPE_INTERFACE_KNOWN (ref
);
11784 /* A signature doesn't have a vtable. */
11785 CLASSTYPE_VTABLE_NEEDS_WRITING (ref
) = 0;
11788 #ifdef NONNESTED_CLASSES
11789 /* Class types don't nest the way enums do. */
11790 class_binding_level
= (struct binding_level
*)0;
11792 pushtag (name
, ref
, globalize
);
11793 class_binding_level
= old_b
;
11798 /* If it no longer looks like a nested type, make sure it's
11800 If it is not an IDENTIFIER, this is not a declaration */
11801 if (b
->namespace_p
&& !class_binding_level
11802 && TREE_CODE (name
) == IDENTIFIER_NODE
)
11804 if (IDENTIFIER_NAMESPACE_VALUE (name
) == NULL_TREE
)
11805 SET_IDENTIFIER_NAMESPACE_VALUE (name
, TYPE_NAME (ref
));
11808 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
11809 redeclare_class_template (ref
, current_template_parms
);
11812 /* Until the type is defined, tentatively accept whatever
11813 structure tag the user hands us. */
11814 if (TYPE_SIZE (ref
) == NULL_TREE
11815 && ref
!= current_class_type
11816 /* Have to check this, in case we have contradictory tag info. */
11817 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
11819 if (tag_code
== class_type
)
11820 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
11821 else if (tag_code
== record_type
|| tag_code
== signature_type
)
11822 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
11827 TREE_TYPE (ref
) = attributes
;
11829 if (ref
&& TYPE_P (ref
))
11833 If the identifier resolves to a typedef-name or a template
11834 type-parameter, the elaborated-type-specifier is
11836 if (TYPE_LANG_SPECIFIC (ref
) && TYPE_WAS_ANONYMOUS (ref
))
11837 cp_error ("`%T' is a typedef name", ref
);
11838 else if (TREE_CODE (ref
) == TEMPLATE_TYPE_PARM
)
11839 cp_error ("`%T' is a template type paramter", ref
);
11846 xref_tag_from_type (old
, id
, globalize
)
11850 tree code_type_node
;
11852 if (TREE_CODE (old
) == RECORD_TYPE
)
11853 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
11854 ? class_type_node
: record_type_node
);
11856 code_type_node
= union_type_node
;
11858 if (id
== NULL_TREE
)
11859 id
= TYPE_IDENTIFIER (old
);
11861 return xref_tag (code_type_node
, id
, globalize
);
11865 xref_basetypes (code_type_node
, name
, ref
, binfo
)
11866 tree code_type_node
;
11870 /* In the declaration `A : X, Y, ... Z' we mark all the types
11871 (A, X, Y, ..., Z) so we can check for duplicates. */
11874 enum tag_types tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11876 if (tag_code
== union_type
)
11878 cp_error ("derived union `%T' invalid", ref
);
11882 len
= list_length (binfo
);
11883 push_obstacks (TYPE_OBSTACK (ref
), TYPE_OBSTACK (ref
));
11885 SET_CLASSTYPE_MARKED (ref
);
11886 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
11888 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
11890 /* The base of a derived struct is public by default. */
11892 = (TREE_PURPOSE (binfo
) == access_public_node
11893 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11894 || (tag_code
!= class_type
11895 && (TREE_PURPOSE (binfo
) == access_default_node
11896 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
11898 = (TREE_PURPOSE (binfo
) == access_protected_node
11899 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
11901 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
11902 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
11903 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11904 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
11905 tree basetype
= TREE_VALUE (binfo
);
11908 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
11909 basetype
= TREE_TYPE (basetype
);
11911 || (TREE_CODE (basetype
) != RECORD_TYPE
11912 && TREE_CODE (basetype
) != TYPENAME_TYPE
11913 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
11914 && TREE_CODE (basetype
) != TEMPLATE_TEMPLATE_PARM
))
11916 cp_error ("base type `%T' fails to be a struct or class type",
11917 TREE_VALUE (binfo
));
11921 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
11924 /* This code replaces similar code in layout_basetypes.
11925 We put the complete_type first for implicit `typename'. */
11926 if (TYPE_SIZE (complete_type (basetype
)) == NULL_TREE
11927 && ! (current_template_parms
&& uses_template_parms (basetype
)))
11929 cp_error ("base class `%T' has incomplete type", basetype
);
11935 if (CLASSTYPE_MARKED (basetype
))
11937 if (basetype
== ref
)
11938 cp_error ("recursive type `%T' undefined", basetype
);
11940 cp_error ("duplicate base type `%T' invalid", basetype
);
11944 if (TYPE_FOR_JAVA (basetype
)
11945 && current_lang_stack
== current_lang_base
)
11946 TYPE_FOR_JAVA (ref
) = 1;
11948 /* Note that the BINFO records which describe individual
11949 inheritances are *not* shared in the lattice! They
11950 cannot be shared because a given baseclass may be
11951 inherited with different `accessibility' by different
11952 derived classes. (Each BINFO record describing an
11953 individual inheritance contains flags which say what
11954 the `accessibility' of that particular inheritance is.) */
11956 base_binfo
= make_binfo (integer_zero_node
, basetype
,
11957 TYPE_BINFO_VTABLE (basetype
),
11958 TYPE_BINFO_VIRTUALS (basetype
));
11960 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
11961 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
11962 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
11963 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
11964 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
11966 /* We need to unshare the binfos now so that lookups during class
11967 definition work. */
11968 unshare_base_binfos (base_binfo
);
11970 SET_CLASSTYPE_MARKED (basetype
);
11972 /* We are free to modify these bits because they are meaningless
11973 at top level, and BASETYPE is a top-level type. */
11974 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
11976 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
11977 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
11980 TYPE_GETS_NEW (ref
) |= TYPE_GETS_NEW (basetype
);
11981 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
11986 TREE_VEC_LENGTH (binfos
) = i
;
11988 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
11991 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
11993 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
11994 = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos
, 0)));
11995 if (TYPE_USES_MULTIPLE_INHERITANCE (ref
))
11996 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
11998 /* Unmark all the types. */
12000 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
12001 CLEAR_CLASSTYPE_MARKED (ref
);
12007 /* Begin compiling the definition of an enumeration type.
12008 NAME is its name (or null if anonymous).
12009 Returns the type object, as yet incomplete.
12010 Also records info about it so that build_enumerator
12011 may be used to declare the individual values as they are read. */
12017 register tree enumtype
= NULL_TREE
;
12018 struct binding_level
*b
= inner_binding_level
;
12020 /* We are wasting space here and putting these on the permanent_obstack so
12021 that typeid(local enum) will work correctly. */
12023 if (processing_template_decl
&& current_function_decl
)
12026 end_temporary_allocation ();
12028 /* If this is the real definition for a previous forward reference,
12029 fill in the contents in the same object that used to be the
12030 forward reference. */
12032 if (name
!= NULL_TREE
)
12033 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
12035 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12036 cp_error ("multiple definition of `%#T'", enumtype
);
12039 enumtype
= make_node (ENUMERAL_TYPE
);
12040 pushtag (name
, enumtype
, 0);
12043 if (current_class_type
)
12044 TREE_ADDRESSABLE (b
->tags
) = 1;
12046 /* We don't copy this value because build_enumerator needs to do it. */
12047 enum_next_value
= integer_zero_node
;
12050 GNU_xref_decl (current_function_decl
, enumtype
);
12054 /* After processing and defining all the values of an enumeration type,
12055 install their decls in the enumeration type and finish it off.
12056 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12057 Returns ENUMTYPE. */
12060 finish_enum (enumtype
)
12063 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
12064 /* Calculate the maximum value of any enumerator in this type. */
12066 tree values
= TYPE_VALUES (enumtype
);
12071 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
12076 /* The TREE_VALUE is a CONST_DECL for this enumeration
12078 decl
= TREE_VALUE (pair
);
12080 /* The DECL_INITIAL will be NULL if we are processing a
12081 template declaration and this enumeration constant had no
12082 explicit initializer. */
12083 value
= DECL_INITIAL (decl
);
12084 if (value
&& !processing_template_decl
)
12086 /* Set the TREE_TYPE for the VALUE as well. That's so
12087 that when we call decl_constant_value we get an
12088 entity of the right type (but with the constant
12089 value). Since we shouldn't ever call
12090 decl_constant_value on a template type, there's no
12091 reason to do that when processing_template_decl.
12092 And, if the expression is something like a
12093 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12094 wreak havoc on the intended type of the expression.
12096 Of course, there's also no point in trying to compute
12097 minimum or maximum values if we're in a template. */
12098 TREE_TYPE (value
) = enumtype
;
12101 minnode
= maxnode
= value
;
12102 else if (tree_int_cst_lt (maxnode
, value
))
12104 else if (tree_int_cst_lt (value
, minnode
))
12108 if (processing_template_decl
)
12109 /* If this is just a template, leave the CONST_DECL
12110 alone. That way tsubst_copy will find CONST_DECLs for
12111 CONST_DECLs, and not INTEGER_CSTs. */
12114 /* In the list we're building up, we want the enumeration
12115 values, not the CONST_DECLs. */
12116 TREE_VALUE (pair
) = value
;
12120 maxnode
= minnode
= integer_zero_node
;
12122 TYPE_VALUES (enumtype
) = nreverse (values
);
12124 if (processing_template_decl
)
12126 tree scope
= current_scope ();
12127 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
12129 add_tree (build_min (TAG_DEFN
, enumtype
));
12130 resume_temporary_allocation ();
12136 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12137 int lowprec
= min_precision (minnode
, unsignedp
);
12138 int highprec
= min_precision (maxnode
, unsignedp
);
12139 int precision
= MAX (lowprec
, highprec
);
12141 TYPE_SIZE (enumtype
) = NULL_TREE
;
12143 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12145 TYPE_PRECISION (enumtype
) = precision
;
12147 fixup_unsigned_type (enumtype
);
12149 fixup_signed_type (enumtype
);
12151 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
12152 /* Use the width of the narrowest normal C type which is wide enough. */
12153 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
12156 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
12158 TYPE_SIZE (enumtype
) = 0;
12159 layout_type (enumtype
);
12165 /* Fix up all variant types of this enum type. */
12166 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
12167 tem
= TYPE_NEXT_VARIANT (tem
))
12169 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
12170 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
12171 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
12172 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
12173 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
12174 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
12175 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
12176 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
12177 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
12181 /* Finish debugging output for this type. */
12182 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12187 /* Build and install a CONST_DECL for an enumeration constant of the
12188 enumeration type TYPE whose NAME and VALUE (if any) are provided.
12189 Assignment of sequential values by default is handled here. */
12192 build_enumerator (name
, value
, type
)
12200 /* Remove no-op casts from the value. */
12202 STRIP_TYPE_NOPS (value
);
12204 if (! processing_template_decl
)
12206 /* Validate and default VALUE. */
12207 if (value
!= NULL_TREE
)
12209 if (TREE_READONLY_DECL_P (value
))
12210 value
= decl_constant_value (value
);
12212 if (TREE_CODE (value
) == INTEGER_CST
)
12214 value
= default_conversion (value
);
12215 constant_expression_warning (value
);
12219 cp_error ("enumerator value for `%D' not integer constant", name
);
12224 /* Default based on previous value. */
12225 if (value
== NULL_TREE
&& ! processing_template_decl
)
12227 value
= enum_next_value
;
12229 cp_error ("overflow in enumeration values at `%D'", name
);
12232 /* Remove no-op casts from the value. */
12234 STRIP_TYPE_NOPS (value
);
12236 /* To fix MAX_VAL enum consts. (bkoz) */
12237 TREE_TYPE (value
) = integer_type_node
;
12241 /* We always have to copy here; not all INTEGER_CSTs are unshared.
12242 Even in other cases, we will later (in finish_enum) be setting the
12244 if (value
!= NULL_TREE
)
12245 value
= copy_node (value
);
12247 /* C++ associates enums with global, function, or class declarations. */
12249 context
= current_scope ();
12250 if (context
&& context
== current_class_type
)
12251 /* This enum declaration is local to the class. */
12252 decl
= build_lang_field_decl (CONST_DECL
, name
, type
);
12254 /* It's a global enum, or it's local to a function. (Note local to
12255 a function could mean local to a class method. */
12256 decl
= build_decl (CONST_DECL
, name
, type
);
12258 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
12259 DECL_INITIAL (decl
) = value
;
12260 TREE_READONLY (decl
) = 1;
12262 if (context
&& context
== current_class_type
)
12264 pushdecl_class_level (decl
);
12265 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12266 on the TYPE_FIELDS list for `S'. (That's so that you can say
12267 things like `S::i' later.) */
12268 finish_member_declaration (decl
);
12273 GNU_xref_decl (current_function_decl
, decl
);
12276 if (! processing_template_decl
)
12278 /* Set basis for default for next value. */
12279 enum_next_value
= build_binary_op_nodefault (PLUS_EXPR
, value
,
12280 integer_one_node
, PLUS_EXPR
);
12281 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
12284 result
= saveable_tree_cons (name
, decl
, NULL_TREE
);
12289 static int function_depth
;
12291 /* Create the FUNCTION_DECL for a function definition.
12292 DECLSPECS and DECLARATOR are the parts of the declaration;
12293 they describe the function's name and the type it returns,
12294 but twisted together in a fashion that parallels the syntax of C.
12296 This function creates a binding context for the function body
12297 as well as setting up the FUNCTION_DECL in current_function_decl.
12299 Returns 1 on success. If the DECLARATOR is not suitable for a function
12300 (it defines a datum instead), we return 0, which tells
12301 yyparse to report a parse error.
12303 For C++, we must first check whether that datum makes any sense.
12304 For example, "class A local_a(1,2);" means that variable local_a
12305 is an aggregate of type A, which should have a constructor
12306 applied to it with the argument list [1, 2].
12308 @@ There is currently no way to retrieve the storage
12309 @@ allocated to FUNCTION (or all of its parms) if we return
12310 @@ something we had previously. */
12313 start_function (declspecs
, declarator
, attrs
, pre_parsed_p
)
12314 tree declspecs
, declarator
, attrs
;
12318 tree ctype
= NULL_TREE
;
12321 extern int have_extern_spec
;
12322 extern int used_extern_spec
;
12323 int doing_friend
= 0;
12325 /* Sanity check. */
12326 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
12327 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
12329 /* Assume, until we see it does. */
12330 current_function_returns_value
= 0;
12331 current_function_returns_null
= 0;
12332 warn_about_return_type
= 0;
12334 shadowed_labels
= 0;
12335 current_function_assigns_this
= 0;
12336 current_function_just_assigned_this
= 0;
12337 current_function_parms_stored
= 0;
12338 original_result_rtx
= NULL_RTX
;
12339 base_init_expr
= NULL_TREE
;
12340 current_base_init_list
= NULL_TREE
;
12341 current_member_init_list
= NULL_TREE
;
12342 ctor_label
= dtor_label
= NULL_TREE
;
12343 static_labelno
= 0;
12345 clear_temp_name ();
12347 /* This should only be done once on the top most decl. */
12348 if (have_extern_spec
&& !used_extern_spec
)
12350 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
12351 used_extern_spec
= 1;
12356 decl1
= declarator
;
12359 /* What was this testing for, exactly? */
12360 if (! DECL_ARGUMENTS (decl1
)
12361 && !DECL_STATIC_FUNCTION_P (decl1
)
12362 && !DECL_ARTIFICIAL (decl1
)
12363 && DECL_CLASS_SCOPE_P (decl1
)
12364 && TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))
12365 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))))
12367 tree binding
= binding_for_name (DECL_NAME (decl1
),
12368 current_namespace
);
12369 cp_error ("redeclaration of `%#D'", decl1
);
12370 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)))
12371 cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)));
12372 else if (BINDING_VALUE (binding
))
12373 cp_error_at ("previous declaration here", BINDING_VALUE (binding
));
12377 fntype
= TREE_TYPE (decl1
);
12378 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12379 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12381 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
12382 class is in the (lexical) scope of the class in which it is
12384 if (!ctype
&& DECL_FRIEND_P (decl1
))
12386 ctype
= DECL_CLASS_CONTEXT (decl1
);
12388 /* CTYPE could be null here if we're dealing with a template;
12389 for example, `inline friend float foo()' inside a template
12390 will have no CTYPE set. */
12391 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
12397 /* In a fcn definition, arg types must be complete. */
12398 require_complete_types_for_parms (DECL_ARGUMENTS (decl1
));
12400 /* In case some arg types were completed since the declaration was
12401 parsed, fix up the decls. */
12403 tree t
= DECL_ARGUMENTS (decl1
);
12404 for (; t
; t
= TREE_CHAIN (t
))
12405 layout_decl (t
, 0);
12408 last_function_parms
= DECL_ARGUMENTS (decl1
);
12409 last_function_parm_tags
= NULL_TREE
;
12413 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
12414 /* If the declarator is not suitable for a function definition,
12415 cause a syntax error. */
12416 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
12418 fntype
= TREE_TYPE (decl1
);
12420 restype
= TREE_TYPE (fntype
);
12421 if (IS_AGGR_TYPE (restype
) && ! TYPE_PTRMEMFUNC_P (restype
)
12422 && ! CLASSTYPE_GOT_SEMICOLON (restype
))
12424 cp_error ("semicolon missing after declaration of `%#T'", restype
);
12425 shadow_tag (build_expr_list (NULL_TREE
, restype
));
12426 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
12427 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
12428 fntype
= build_function_type (integer_type_node
,
12429 TYPE_ARG_TYPES (fntype
));
12431 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
12433 TYPE_ARG_TYPES (fntype
));
12434 TREE_TYPE (decl1
) = fntype
;
12437 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12438 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12439 else if (DECL_MAIN_P (decl1
))
12441 /* If this doesn't return integer_type, complain. */
12442 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
12444 if (pedantic
|| warn_return_type
)
12445 pedwarn ("return type for `main' changed to `int'");
12446 TREE_TYPE (decl1
) = fntype
= default_function_type
;
12448 warn_about_return_type
= 0;
12452 /* Warn if function was previously implicitly declared
12453 (but not if we warned then). */
12454 if (! warn_implicit
12455 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
12456 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
12458 current_function_decl
= decl1
;
12459 /* Save the parm names or decls from this function's declarator
12460 where store_parm_decls will find them. */
12461 current_function_parms
= last_function_parms
;
12462 current_function_parm_tags
= last_function_parm_tags
;
12464 announce_function (decl1
);
12466 if (! processing_template_decl
)
12468 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype
))) == NULL_TREE
)
12470 cp_error ("return-type `%#T' is an incomplete type",
12471 TREE_TYPE (fntype
));
12473 /* Make it return void instead, but don't change the
12474 type of the DECL_RESULT, in case we have a named return value. */
12477 = build_cplus_method_type (build_type_variant (ctype
,
12478 TREE_READONLY (decl1
),
12479 TREE_SIDE_EFFECTS (decl1
)),
12481 FUNCTION_ARG_CHAIN (decl1
));
12484 = build_function_type (void_type_node
,
12485 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
12486 DECL_RESULT (decl1
)
12487 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype
)));
12488 TREE_READONLY (DECL_RESULT (decl1
))
12489 = CP_TYPE_CONST_P (TREE_TYPE (fntype
));
12490 TREE_THIS_VOLATILE (DECL_RESULT (decl1
))
12491 = CP_TYPE_VOLATILE_P (TREE_TYPE (fntype
));
12494 if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype
))
12495 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype
)))
12496 abstract_virtuals_error (decl1
, TREE_TYPE (fntype
));
12499 if (warn_about_return_type
)
12500 pedwarn ("return-type defaults to `int'");
12502 /* Effective C++ rule 15. See also c_expand_return. */
12504 && DECL_NAME (decl1
) == ansi_opname
[(int) MODIFY_EXPR
]
12505 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
12506 cp_warning ("`operator=' should return a reference to `*this'");
12508 /* Make the init_value nonzero so pushdecl knows this is not tentative.
12509 error_mark_node is replaced below (in poplevel) with the BLOCK. */
12510 DECL_INITIAL (decl1
) = error_mark_node
;
12512 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
12513 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
12516 /* This function exists in static storage.
12517 (This does not mean `static' in the C sense!) */
12518 TREE_STATIC (decl1
) = 1;
12520 /* Set up current_class_type, and enter the scope of the class, if
12523 push_nested_class (ctype
, 1);
12524 else if (DECL_STATIC_FUNCTION_P (decl1
))
12525 push_nested_class (DECL_CONTEXT (decl1
), 2);
12527 /* We must call push_template_decl after current_class_type is set
12528 up. (If we are processing inline definitions after exiting a
12529 class scope, current_class_type will be NULL_TREE until set above
12530 by push_nested_class.) */
12531 if (processing_template_decl
)
12532 decl1
= push_template_decl (decl1
);
12534 /* Record the decl so that the function name is defined.
12535 If we already have a decl for this name, and it is a FUNCTION_DECL,
12536 use the old decl. */
12537 if (!processing_template_decl
&& pre_parsed_p
== 0)
12539 /* A specialization is not used to guide overload resolution. */
12540 if ((flag_guiding_decls
12541 || !DECL_TEMPLATE_SPECIALIZATION (decl1
))
12542 && ! DECL_FUNCTION_MEMBER_P (decl1
))
12543 decl1
= pushdecl (decl1
);
12546 /* We need to set the DECL_CONTEXT. */
12547 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
12548 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
12549 /* And make sure we have enough default args. */
12550 check_default_args (decl1
);
12552 DECL_MAIN_VARIANT (decl1
) = decl1
;
12553 fntype
= TREE_TYPE (decl1
);
12556 current_function_decl
= decl1
;
12558 if (DECL_INTERFACE_KNOWN (decl1
))
12560 tree ctx
= hack_decl_function_context (decl1
);
12562 if (DECL_NOT_REALLY_EXTERN (decl1
))
12563 DECL_EXTERNAL (decl1
) = 0;
12565 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
12566 && TREE_PUBLIC (ctx
))
12567 /* This is a function in a local class in an extern inline
12569 comdat_linkage (decl1
);
12571 /* If this function belongs to an interface, it is public.
12572 If it belongs to someone else's interface, it is also external.
12573 It doesn't matter whether it's inline or not. */
12574 else if (interface_unknown
== 0
12575 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
12576 || flag_alt_external_templates
))
12578 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
12579 || processing_template_decl
)
12580 DECL_EXTERNAL (decl1
)
12582 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
));
12584 DECL_EXTERNAL (decl1
) = 0;
12585 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
12586 DECL_INTERFACE_KNOWN (decl1
) = 1;
12590 /* This is a definition, not a reference.
12591 So clear DECL_EXTERNAL. */
12592 DECL_EXTERNAL (decl1
) = 0;
12594 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
12595 && ! DECL_INTERFACE_KNOWN (decl1
)
12596 /* Don't try to defer nested functions for now. */
12597 && ! hack_decl_function_context (decl1
))
12598 DECL_DEFER_OUTPUT (decl1
) = 1;
12600 DECL_INTERFACE_KNOWN (decl1
) = 1;
12603 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
))
12605 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12606 TREE_TYPE (decl1
) = fntype
12607 = build_function_type (TREE_TYPE (fntype
),
12608 TREE_CHAIN (TYPE_ARG_TYPES (fntype
)));
12609 current_function_parms
= TREE_CHAIN (current_function_parms
);
12610 DECL_ARGUMENTS (decl1
) = current_function_parms
;
12613 restype
= TREE_TYPE (fntype
);
12617 /* If we're compiling a friend function, neither of the variables
12618 current_class_ptr nor current_class_type will have values. */
12619 if (! doing_friend
)
12621 /* We know that this was set up by `grokclassfn'.
12622 We do not wait until `store_parm_decls', since evil
12623 parse errors may never get us to that point. Here
12624 we keep the consistency between `current_class_type'
12625 and `current_class_ptr'. */
12626 tree t
= current_function_parms
;
12628 my_friendly_assert (t
!= NULL_TREE
12629 && TREE_CODE (t
) == PARM_DECL
, 162);
12631 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
12633 int i
= suspend_momentary ();
12635 /* Fool build_indirect_ref. */
12636 current_class_ptr
= NULL_TREE
;
12637 current_class_ref
= build_indirect_ref (t
, NULL_PTR
);
12638 current_class_ptr
= t
;
12639 resume_momentary (i
);
12642 /* We're having a signature pointer here. */
12643 current_class_ref
= current_class_ptr
= t
;
12649 current_class_ptr
= current_class_ref
= NULL_TREE
;
12653 current_binding_level
->parm_flag
= 1;
12655 GNU_xref_function (decl1
, current_function_parms
);
12658 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
12660 make_function_rtl (decl1
);
12662 /* Promote the value to int before returning it. */
12663 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
12664 restype
= type_promotes_to (restype
);
12666 /* If this fcn was already referenced via a block-scope `extern' decl
12667 (or an implicit decl), propagate certain information about the usage. */
12668 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
12669 TREE_ADDRESSABLE (decl1
) = 1;
12671 if (DECL_RESULT (decl1
) == NULL_TREE
)
12673 DECL_RESULT (decl1
)
12674 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
12675 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
12676 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
12679 /* Allocate further tree nodes temporarily during compilation
12680 of this function only. Tiemann moved up here from bottom of fn. */
12681 /* If this is a nested function, then we must continue to allocate RTL
12682 on the permanent obstack in case we need to inline it later. */
12683 if (! hack_decl_function_context (decl1
))
12684 temporary_allocation ();
12686 if (processing_template_decl
)
12688 ++minimal_parse_mode
;
12689 last_tree
= DECL_SAVED_TREE (decl1
)
12690 = build_nt (EXPR_STMT
, void_zero_node
);
12695 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1
))
12696 && DECL_LANGUAGE (decl1
) == lang_cplusplus
)
12698 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12699 ctor_label
= NULL_TREE
;
12703 dtor_label
= NULL_TREE
;
12704 if (DECL_CONSTRUCTOR_P (decl1
))
12705 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12711 /* Called after store_parm_decls for a function-try-block. We need to update
12712 last_parm_cleanup_insn so that the base initializers for a constructor
12713 are run within this block, not before it. */
12716 expand_start_early_try_stmts ()
12718 expand_start_try_stmts ();
12719 last_parm_cleanup_insn
= get_last_insn ();
12722 /* Store the parameter declarations into the current function declaration.
12723 This is called after parsing the parameter declarations, before
12724 digesting the body of the function.
12726 Also install to binding contour return value identifier, if any. */
12729 store_parm_decls ()
12731 register tree fndecl
= current_function_decl
;
12732 register tree parm
;
12733 int parms_have_cleanups
= 0;
12734 tree cleanups
= NULL_TREE
;
12736 /* This is either a chain of PARM_DECLs (when a prototype is used). */
12737 tree specparms
= current_function_parms
;
12739 /* This is a list of types declared among parms in a prototype. */
12740 tree parmtags
= current_function_parm_tags
;
12742 /* This is a chain of any other decls that came in among the parm
12743 declarations. If a parm is declared with enum {foo, bar} x;
12744 then CONST_DECLs for foo and bar are put here. */
12745 tree nonparms
= NULL_TREE
;
12747 if (toplevel_bindings_p ())
12748 fatal ("parse errors have confused me too much");
12750 /* Initialize RTL machinery. */
12751 init_function_start (fndecl
, input_filename
, lineno
);
12753 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
12754 declare_function_name ();
12756 /* Create a binding level for the parms. */
12757 expand_start_bindings (0);
12759 if (specparms
!= NULL_TREE
)
12761 /* This case is when the function was defined with an ANSI prototype.
12762 The parms already have decls, so we need not do anything here
12763 except record them as in effect
12764 and complain if any redundant old-style parm decls were written. */
12766 register tree next
;
12768 /* Must clear this because it might contain TYPE_DECLs declared
12770 storedecls (NULL_TREE
);
12772 for (parm
= nreverse (specparms
); parm
; parm
= next
)
12774 next
= TREE_CHAIN (parm
);
12775 if (TREE_CODE (parm
) == PARM_DECL
)
12778 if (DECL_NAME (parm
) == NULL_TREE
)
12782 else if (TREE_CODE (TREE_TYPE (parm
)) == VOID_TYPE
)
12783 cp_error ("parameter `%D' declared void", parm
);
12786 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
12787 A parameter is assumed not to have any side effects.
12788 If this should change for any reason, then this
12789 will have to wrap the bashed reference type in a save_expr.
12791 Also, if the parameter type is declared to be an X
12792 and there is an X(X&) constructor, we cannot lay it
12793 into the stack (any more), so we make this parameter
12794 look like it is really of reference type. Functions
12795 which pass parameters to this function will know to
12796 create a temporary in their frame, and pass a reference
12799 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
12800 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))))
12801 SET_DECL_REFERENCE_SLOT (parm
, convert_from_reference (parm
));
12805 if (! processing_template_decl
12806 && (cleanup
= maybe_build_cleanup (parm
), cleanup
))
12808 expand_decl (parm
);
12809 parms_have_cleanups
= 1;
12811 /* Keep track of the cleanups. */
12812 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
12817 /* If we find an enum constant or a type tag,
12818 put it aside for the moment. */
12819 TREE_CHAIN (parm
) = NULL_TREE
;
12820 nonparms
= chainon (nonparms
, parm
);
12824 /* Get the decls in their original chain order
12825 and record in the function. This is all and only the
12826 PARM_DECLs that were pushed into scope by the loop above. */
12827 DECL_ARGUMENTS (fndecl
) = getdecls ();
12829 storetags (chainon (parmtags
, gettags ()));
12832 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
12834 /* Now store the final chain of decls for the arguments
12835 as the decl-chain of the current lexical scope.
12836 Put the enumerators in as well, at the front so that
12837 DECL_ARGUMENTS is not modified. */
12839 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
12841 /* Initialize the RTL code for the function. */
12842 DECL_SAVED_INSNS (fndecl
) = NULL_RTX
;
12843 if (! processing_template_decl
)
12844 expand_function_start (fndecl
, parms_have_cleanups
);
12846 current_function_parms_stored
= 1;
12848 /* If this function is `main', emit a call to `__main'
12849 to run global initializers, etc. */
12850 if (DECL_MAIN_P (fndecl
))
12851 expand_main_function ();
12853 /* Now that we have initialized the parms, we can start their
12854 cleanups. We cannot do this before, since expand_decl_cleanup
12855 should not be called before the parm can be used. */
12857 && ! processing_template_decl
)
12859 for (cleanups
= nreverse (cleanups
); cleanups
; cleanups
= TREE_CHAIN (cleanups
))
12861 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups
), TREE_VALUE (cleanups
)))
12862 cp_error ("parser lost in parsing declaration of `%D'",
12863 TREE_PURPOSE (cleanups
));
12867 /* Create a binding contour which can be used to catch
12868 cleanup-generated temporaries. Also, if the return value needs or
12869 has initialization, deal with that now. */
12870 if (parms_have_cleanups
)
12873 expand_start_bindings (0);
12876 if (! processing_template_decl
&& flag_exceptions
)
12878 /* Do the starting of the exception specifications, if we have any. */
12879 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
12880 expand_start_eh_spec ();
12883 last_parm_cleanup_insn
= get_last_insn ();
12884 last_dtor_insn
= get_last_insn ();
12887 /* Bind a name and initialization to the return value of
12888 the current function. */
12891 store_return_init (return_id
, init
)
12892 tree return_id
, init
;
12894 tree decl
= DECL_RESULT (current_function_decl
);
12897 /* Give this error as many times as there are occurrences,
12898 so that users can use Emacs compilation buffers to find
12899 and fix all such places. */
12900 pedwarn ("ANSI C++ does not permit named return values");
12902 if (return_id
!= NULL_TREE
)
12904 if (DECL_NAME (decl
) == NULL_TREE
)
12906 DECL_NAME (decl
) = return_id
;
12907 DECL_ASSEMBLER_NAME (decl
) = return_id
;
12910 cp_error ("return identifier `%D' already in place", decl
);
12913 /* Can't let this happen for constructors. */
12914 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12916 error ("can't redefine default return value for constructors");
12920 /* If we have a named return value, put that in our scope as well. */
12921 if (DECL_NAME (decl
) != NULL_TREE
)
12923 /* If this named return value comes in a register,
12924 put it in a pseudo-register. */
12925 if (DECL_REGISTER (decl
))
12927 original_result_rtx
= DECL_RTL (decl
);
12928 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
12931 /* Let `cp_finish_decl' know that this initializer is ok. */
12932 DECL_INITIAL (decl
) = init
;
12935 if (minimal_parse_mode
)
12936 add_tree (build_min_nt (RETURN_INIT
, return_id
,
12937 copy_to_permanent (init
)));
12939 cp_finish_decl (decl
, init
, NULL_TREE
, 0, 0);
12944 /* Finish up a function declaration and compile that function
12945 all the way to assembler language output. The free the storage
12946 for the function definition.
12948 This is called after parsing the body of the function definition.
12949 LINENO is the current line number.
12951 C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
12952 (and expand_end_bindings) must be made to take care of the binding
12953 contour for the base initializers. This is only relevant for
12956 NESTED is nonzero if we were in the middle of compiling another function
12957 when we started on this one. */
12960 finish_function (lineno
, call_poplevel
, nested
)
12965 register tree fndecl
= current_function_decl
;
12966 tree fntype
, ctype
= NULL_TREE
;
12967 rtx last_parm_insn
, insns
;
12968 /* Label to use if this function is supposed to return a value. */
12969 tree no_return_label
= NULL_TREE
;
12970 tree decls
= NULL_TREE
;
12972 /* When we get some parse errors, we can end up without a
12973 current_function_decl, so cope. */
12974 if (fndecl
== NULL_TREE
)
12977 if (! nested
&& function_depth
> 1)
12980 fntype
= TREE_TYPE (fndecl
);
12982 /* TREE_READONLY (fndecl) = 1;
12983 This caused &foo to be of type ptr-to-const-function
12984 which then got a warning when stored in a ptr-to-function variable. */
12986 /* This happens on strange parse errors. */
12987 if (! current_function_parms_stored
)
12990 store_parm_decls ();
12993 if (processing_template_decl
)
12995 if (DECL_CONSTRUCTOR_P (fndecl
) && call_poplevel
)
12997 decls
= getdecls ();
12998 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
12999 poplevel (decls
!= NULL_TREE
, 0, 0);
13004 if (write_symbols
!= NO_DEBUG
/*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13006 tree ttype
= target_type (fntype
);
13009 if (IS_AGGR_TYPE (ttype
))
13010 /* Let debugger know it should output info for this type. */
13011 note_debug_info_needed (ttype
);
13013 for (parmdecl
= DECL_ARGUMENTS (fndecl
); parmdecl
; parmdecl
= TREE_CHAIN (parmdecl
))
13015 ttype
= target_type (TREE_TYPE (parmdecl
));
13016 if (IS_AGGR_TYPE (ttype
))
13017 /* Let debugger know it should output info for this type. */
13018 note_debug_info_needed (ttype
);
13022 /* Clean house because we will need to reorder insns here. */
13023 do_pending_stack_adjust ();
13027 tree binfo
= TYPE_BINFO (current_class_type
);
13028 tree cond
= integer_one_node
;
13030 tree in_charge_node
= lookup_name (in_charge_identifier
, 0);
13032 int ok_to_optimize_dtor
= 0;
13033 int empty_dtor
= get_last_insn () == last_dtor_insn
;
13035 if (current_function_assigns_this
)
13036 cond
= build (NE_EXPR
, boolean_type_node
,
13037 current_class_ptr
, integer_zero_node
);
13040 int n_baseclasses
= CLASSTYPE_N_BASECLASSES (current_class_type
);
13042 /* If this destructor is empty, then we don't need to check
13043 whether `this' is NULL in some cases. */
13044 if ((flag_this_is_variable
& 1) == 0)
13045 ok_to_optimize_dtor
= 1;
13046 else if (empty_dtor
)
13047 ok_to_optimize_dtor
13048 = (n_baseclasses
== 0
13049 || (n_baseclasses
== 1
13050 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type
, 0))));
13053 /* These initializations might go inline. Protect
13054 the binding level of the parms. */
13056 expand_start_bindings (0);
13058 if (current_function_assigns_this
)
13060 current_function_assigns_this
= 0;
13061 current_function_just_assigned_this
= 0;
13064 /* Generate the code to call destructor on base class.
13065 If this destructor belongs to a class with virtual
13066 functions, then set the virtual function table
13067 pointer to represent the type of our base class. */
13069 /* This side-effect makes call to `build_delete' generate the
13070 code we have to have at the end of this destructor. */
13071 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
13073 /* These are two cases where we cannot delegate deletion. */
13074 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)
13075 || TYPE_GETS_REG_DELETE (current_class_type
))
13076 exprstmt
= build_delete (current_class_type
, current_class_ref
, integer_zero_node
,
13077 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13079 exprstmt
= build_delete (current_class_type
, current_class_ref
, in_charge_node
,
13080 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13082 /* If we did not assign to this, then `this' is non-zero at
13083 the end of a destructor. As a special optimization, don't
13084 emit test if this is an empty destructor. If it does nothing,
13085 it does nothing. If it calls a base destructor, the base
13086 destructor will perform the test. */
13088 if (exprstmt
!= error_mark_node
13089 && (TREE_CODE (exprstmt
) != NOP_EXPR
13090 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
13091 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
13093 expand_label (dtor_label
);
13094 if (cond
!= integer_one_node
)
13095 expand_start_cond (cond
, 0);
13096 if (exprstmt
!= void_zero_node
)
13097 /* Don't call `expand_expr_stmt' if we're not going to do
13098 anything, since -Wall will give a diagnostic. */
13099 expand_expr_stmt (exprstmt
);
13101 /* Run destructor on all virtual baseclasses. */
13102 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13104 tree vbases
= nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type
)));
13105 expand_start_cond (build (BIT_AND_EXPR
, integer_type_node
,
13106 in_charge_node
, integer_two_node
), 0);
13109 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases
)))
13111 tree vb
= get_vbase
13112 (BINFO_TYPE (vbases
),
13113 TYPE_BINFO (current_class_type
));
13115 (build_scoped_method_call
13116 (current_class_ref
, vb
, dtor_identifier
,
13117 build_expr_list (NULL_TREE
, integer_zero_node
)));
13119 vbases
= TREE_CHAIN (vbases
);
13121 expand_end_cond ();
13124 do_pending_stack_adjust ();
13125 if (cond
!= integer_one_node
)
13126 expand_end_cond ();
13129 TYPE_HAS_DESTRUCTOR (current_class_type
) = 1;
13131 virtual_size
= c_sizeof (current_class_type
);
13133 /* At the end, call delete if that's what's requested. */
13135 /* FDIS sez: At the point of definition of a virtual destructor
13136 (including an implicit definition), non-placement operator
13137 delete shall be looked up in the scope of the destructor's
13138 class and if found shall be accessible and unambiguous.
13140 This is somewhat unclear, but I take it to mean that if the
13141 class only defines placement deletes we don't do anything here.
13142 So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain
13143 for us if they ever try to delete one of these. */
13145 if (TYPE_GETS_REG_DELETE (current_class_type
)
13146 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13147 exprstmt
= build_op_delete_call
13148 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
13149 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
13151 exprstmt
= NULL_TREE
;
13155 cond
= build (BIT_AND_EXPR
, integer_type_node
,
13156 in_charge_node
, integer_one_node
);
13157 expand_start_cond (cond
, 0);
13158 expand_expr_stmt (exprstmt
);
13159 expand_end_cond ();
13162 /* End of destructor. */
13163 expand_end_bindings (NULL_TREE
, getdecls () != NULL_TREE
, 0);
13164 poplevel (2, 0, 0); /* XXX change to 1 */
13166 /* Back to the top of destructor. */
13167 /* Don't execute destructor code if `this' is NULL. */
13171 /* If the dtor is empty, and we know there is not possible way we
13172 could use any vtable entries, before they are possibly set by
13173 a base class dtor, we don't have to setup the vtables, as we
13174 know that any base class dtoring will set up any vtables it
13175 needs. We avoid MI, because one base class dtor can do a
13176 virtual dispatch to an overridden function that would need to
13177 have a non-related vtable set up, we cannot avoid setting up
13178 vtables in that case. We could change this to see if there is
13179 just one vtable. */
13180 if (! empty_dtor
|| TYPE_USES_COMPLEX_INHERITANCE (current_class_type
))
13182 /* Make all virtual function table pointers in non-virtual base
13183 classes point to CURRENT_CLASS_TYPE's virtual function
13185 expand_direct_vtbls_init (binfo
, binfo
, 1, 0, current_class_ptr
);
13187 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13188 expand_indirect_vtbls_init (binfo
, current_class_ref
, current_class_ptr
);
13191 if (! ok_to_optimize_dtor
)
13193 cond
= build_binary_op (NE_EXPR
,
13194 current_class_ptr
, integer_zero_node
, 1);
13195 expand_start_cond (cond
, 0);
13198 insns
= get_insns ();
13201 last_parm_insn
= get_first_nonparm_insn ();
13202 if (last_parm_insn
== NULL_RTX
)
13203 last_parm_insn
= get_last_insn ();
13205 last_parm_insn
= previous_insn (last_parm_insn
);
13207 emit_insns_after (insns
, last_parm_insn
);
13209 if (! ok_to_optimize_dtor
)
13210 expand_end_cond ();
13212 else if (current_function_assigns_this
)
13214 /* Does not need to call emit_base_init, because
13215 that is done (if needed) just after assignment to this
13218 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13220 end_protect_partials ();
13221 expand_label (ctor_label
);
13222 ctor_label
= NULL_TREE
;
13226 decls
= getdecls ();
13227 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13228 poplevel (decls
!= NULL_TREE
, 0, 0);
13230 /* c_expand_return knows to return 'this' from a constructor. */
13231 c_expand_return (NULL_TREE
);
13233 else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl
))) != VOID_TYPE
13234 && return_label
!= NULL_RTX
)
13235 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13237 current_function_assigns_this
= 0;
13238 current_function_just_assigned_this
= 0;
13239 base_init_expr
= NULL_TREE
;
13241 else if (DECL_CONSTRUCTOR_P (fndecl
))
13243 tree cond
= NULL_TREE
, thenclause
= NULL_TREE
;
13244 /* Allow constructor for a type to get a new instance of the object
13245 using `build_new'. */
13246 tree abstract_virtuals
= CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
);
13247 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = NULL_TREE
;
13249 DECL_RETURNS_FIRST_ARG (fndecl
) = 1;
13251 if (flag_this_is_variable
> 0)
13253 cond
= build_binary_op (EQ_EXPR
,
13254 current_class_ptr
, integer_zero_node
, 1);
13255 thenclause
= build_modify_expr (current_class_ptr
, NOP_EXPR
,
13256 build_new (NULL_TREE
, current_class_type
, void_type_node
, 0));
13259 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = abstract_virtuals
;
13263 if (flag_this_is_variable
> 0)
13265 expand_start_cond (cond
, 0);
13266 expand_expr_stmt (thenclause
);
13267 expand_end_cond ();
13270 /* Emit insns from `emit_base_init' which sets up virtual
13271 function table pointer(s). */
13272 if (base_init_expr
)
13274 expand_expr_stmt (base_init_expr
);
13275 base_init_expr
= NULL_TREE
;
13278 insns
= get_insns ();
13281 /* This is where the body of the constructor begins. */
13283 emit_insns_after (insns
, last_parm_cleanup_insn
);
13285 end_protect_partials ();
13287 /* This is where the body of the constructor ends. */
13288 expand_label (ctor_label
);
13289 ctor_label
= NULL_TREE
;
13293 decls
= getdecls ();
13294 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13295 poplevel (decls
!= NULL_TREE
, 1, 0);
13298 /* c_expand_return knows to return 'this' from a constructor. */
13299 c_expand_return (NULL_TREE
);
13301 current_function_assigns_this
= 0;
13302 current_function_just_assigned_this
= 0;
13304 else if (DECL_MAIN_P (fndecl
))
13306 /* Make it so that `main' always returns 0 by default. */
13308 c_expand_return (integer_one_node
);
13310 c_expand_return (integer_zero_node
);
13313 else if (return_label
!= NULL_RTX
13314 && current_function_return_value
== NULL_TREE
13315 && ! DECL_NAME (DECL_RESULT (current_function_decl
)))
13316 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13318 if (flag_exceptions
)
13319 expand_exception_blocks ();
13321 /* If this function is supposed to return a value, ensure that
13322 we do not fall into the cleanups by mistake. The end of our
13323 function will look like this:
13325 user code (may have return stmt somewhere)
13326 goto no_return_label
13331 NOTE_INSN_FUNCTION_END
13335 If the user omits a return stmt in the USER CODE section, we
13336 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13337 Otherwise, we won't. */
13338 if (no_return_label
)
13340 DECL_CONTEXT (no_return_label
) = fndecl
;
13341 DECL_INITIAL (no_return_label
) = error_mark_node
;
13342 DECL_SOURCE_FILE (no_return_label
) = input_filename
;
13343 DECL_SOURCE_LINE (no_return_label
) = lineno
;
13344 expand_goto (no_return_label
);
13349 /* Remove the binding contour which is used
13350 to catch cleanup-generated temporaries. */
13351 expand_end_bindings (0, 0, 0);
13352 poplevel (0, 0, 0);
13354 /* Emit label at beginning of cleanup code for parameters. */
13355 emit_label (cleanup_label
);
13358 /* Get return value into register if that's where it's supposed to be. */
13359 if (original_result_rtx
)
13360 fixup_result_decl (DECL_RESULT (fndecl
), original_result_rtx
);
13362 /* Finish building code that will trigger warnings if users forget
13363 to make their functions return values. */
13364 if (no_return_label
|| cleanup_label
)
13365 emit_jump (return_label
);
13366 if (no_return_label
)
13368 /* We don't need to call `expand_*_return' here because we
13369 don't need any cleanups here--this path of code is only
13370 for error checking purposes. */
13371 expand_label (no_return_label
);
13374 /* Generate rtl for function exit. */
13375 expand_function_end (input_filename
, lineno
, 1);
13378 /* This must come after expand_function_end because cleanups might
13379 have declarations (from inline functions) that need to go into
13380 this function's blocks. */
13381 if (current_binding_level
->parm_flag
!= 1)
13382 my_friendly_abort (122);
13383 poplevel (1, 0, 1);
13385 /* Reset scope for C++: if we were in the scope of a class,
13386 then when we finish this function, we are not longer so.
13387 This cannot be done until we know for sure that no more
13388 class members will ever be referenced in this function
13389 (i.e., calls to destructors). */
13390 if (current_class_name
)
13392 ctype
= current_class_type
;
13393 pop_nested_class (1);
13396 /* Must mark the RESULT_DECL as being in this function. */
13397 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13399 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13400 to the FUNCTION_DECL node itself. */
13401 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13403 if (! processing_template_decl
)
13405 int saved_flag_keep_inline_functions
=
13406 flag_keep_inline_functions
;
13408 /* So we can tell if jump_optimize sets it to 1. */
13411 if (DECL_CONTEXT (fndecl
) != NULL_TREE
13412 && hack_decl_function_context (fndecl
))
13413 /* Trick rest_of_compilation into not deferring output of this
13414 function, even if it is inline, since the rtl_obstack for
13415 this function is the function_obstack of the enclosing
13416 function and will be deallocated when the enclosing
13417 function is gone. See save_tree_status. */
13418 flag_keep_inline_functions
= 1;
13420 /* Run the optimizers and output the assembler code for this
13423 if (DECL_ARTIFICIAL (fndecl
))
13425 /* Do we really *want* to inline this synthesized method? */
13427 int save_fif
= flag_inline_functions
;
13428 flag_inline_functions
= 1;
13430 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13431 will check our size. */
13432 DECL_INLINE (fndecl
) = 0;
13434 rest_of_compilation (fndecl
);
13435 flag_inline_functions
= save_fif
;
13438 rest_of_compilation (fndecl
);
13440 flag_keep_inline_functions
= saved_flag_keep_inline_functions
;
13442 if (DECL_SAVED_INSNS (fndecl
) && ! TREE_ASM_WRITTEN (fndecl
))
13444 /* Set DECL_EXTERNAL so that assemble_external will be called as
13445 necessary. We'll clear it again in finish_file. */
13446 if (! DECL_EXTERNAL (fndecl
))
13447 DECL_NOT_REALLY_EXTERN (fndecl
) = 1;
13448 DECL_EXTERNAL (fndecl
) = 1;
13449 mark_inline_for_output (fndecl
);
13452 if (ctype
&& TREE_ASM_WRITTEN (fndecl
))
13453 note_debug_info_needed (ctype
);
13455 current_function_returns_null
|= can_reach_end
;
13457 /* Since we don't normally go through c_expand_return for constructors,
13458 this normally gets the wrong value.
13459 Also, named return values have their return codes emitted after
13460 NOTE_INSN_FUNCTION_END, confusing jump.c. */
13461 if (DECL_CONSTRUCTOR_P (fndecl
)
13462 || DECL_NAME (DECL_RESULT (fndecl
)) != NULL_TREE
)
13463 current_function_returns_null
= 0;
13465 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
13466 cp_warning ("`noreturn' function `%D' does return", fndecl
);
13467 else if ((warn_return_type
|| pedantic
)
13468 && current_function_returns_null
13469 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
)
13471 /* If this function returns non-void and control can drop through,
13473 cp_warning ("control reaches end of non-void function `%D'", fndecl
);
13475 /* With just -W, complain only if function returns both with
13476 and without a value. */
13477 else if (extra_warnings
13478 && current_function_returns_value
&& current_function_returns_null
)
13479 warning ("this function may return with or without a value");
13484 /* Free all the tree nodes making up this function. */
13485 /* Switch back to allocating nodes permanently
13486 until we start another function. */
13487 if (processing_template_decl
)
13489 --minimal_parse_mode
;
13490 DECL_SAVED_TREE (fndecl
) = TREE_CHAIN (DECL_SAVED_TREE (fndecl
));
13494 permanent_allocation (1);
13496 if (DECL_SAVED_INSNS (fndecl
) == NULL_RTX
)
13500 /* Stop pointing to the local nodes about to be freed. */
13501 /* But DECL_INITIAL must remain nonzero so we know this
13502 was an actual function definition. */
13503 DECL_INITIAL (fndecl
) = error_mark_node
;
13504 for (t
= DECL_ARGUMENTS (fndecl
); t
; t
= TREE_CHAIN (t
))
13505 DECL_RTL (t
) = DECL_INCOMING_RTL (t
) = NULL_RTX
;
13508 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
13509 static_ctors
= perm_tree_cons (NULL_TREE
, fndecl
, static_ctors
);
13510 if (DECL_STATIC_DESTRUCTOR (fndecl
))
13511 static_dtors
= perm_tree_cons (NULL_TREE
, fndecl
, static_dtors
);
13515 /* Let the error reporting routines know that we're outside a
13516 function. For a nested function, this value is used in
13517 pop_cp_function_context and then reset via pop_function_context. */
13518 current_function_decl
= NULL_TREE
;
13521 named_label_uses
= NULL
;
13522 current_class_ptr
= NULL_TREE
;
13523 current_class_ref
= NULL_TREE
;
13526 /* Create the FUNCTION_DECL for a function definition.
13527 LINE1 is the line number that the definition absolutely begins on.
13528 LINE2 is the line number that the name of the function appears on.
13529 DECLSPECS and DECLARATOR are the parts of the declaration;
13530 they describe the return type and the name of the function,
13531 but twisted together in a fashion that parallels the syntax of C.
13533 This function creates a binding context for the function body
13534 as well as setting up the FUNCTION_DECL in current_function_decl.
13536 Returns a FUNCTION_DECL on success.
13538 If the DECLARATOR is not suitable for a function (it defines a datum
13539 instead), we return 0, which tells yyparse to report a parse error.
13541 May return void_type_node indicating that this method is actually
13542 a friend. See grokfield for more details.
13544 Came here with a `.pushlevel' .
13546 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13547 CHANGES TO CODE IN `grokfield'. */
13550 start_method (declspecs
, declarator
, attrlist
)
13551 tree declarator
, declspecs
, attrlist
;
13553 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
13556 /* Something too ugly to handle. */
13557 if (fndecl
== NULL_TREE
)
13560 /* Pass friends other than inline friend functions back. */
13561 if (fndecl
== void_type_node
)
13564 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
13565 /* Not a function, tell parser to report parse error. */
13568 if (IS_SIGNATURE (current_class_type
))
13569 IS_DEFAULT_IMPLEMENTATION (fndecl
) = 1;
13571 if (DECL_IN_AGGR_P (fndecl
))
13573 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
13575 if (DECL_CONTEXT (fndecl
)
13576 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
13577 cp_error ("`%D' is already defined in class %s", fndecl
,
13578 TYPE_NAME_STRING (DECL_CONTEXT (fndecl
)));
13580 return void_type_node
;
13583 DECL_THIS_INLINE (fndecl
) = 1;
13585 if (flag_default_inline
)
13586 DECL_INLINE (fndecl
) = 1;
13588 /* We process method specializations in finish_struct_1. */
13589 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
13590 fndecl
= push_template_decl (fndecl
);
13592 /* We read in the parameters on the maybepermanent_obstack,
13593 but we won't be getting back to them until after we
13594 may have clobbered them. So the call to preserve_data
13595 will keep them safe. */
13598 if (! DECL_FRIEND_P (fndecl
))
13600 if (TREE_CHAIN (fndecl
))
13602 fndecl
= copy_node (fndecl
);
13603 TREE_CHAIN (fndecl
) = NULL_TREE
;
13606 if (DECL_CONSTRUCTOR_P (fndecl
))
13608 if (! grok_ctor_properties (current_class_type
, fndecl
))
13609 return void_type_node
;
13611 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
13612 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
13615 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0, 0);
13617 /* Make a place for the parms */
13619 current_binding_level
->parm_flag
= 1;
13621 DECL_IN_AGGR_P (fndecl
) = 1;
13625 /* Go through the motions of finishing a function definition.
13626 We don't compile this method until after the whole class has
13629 FINISH_METHOD must return something that looks as though it
13630 came from GROKFIELD (since we are defining a method, after all).
13632 This is called after parsing the body of the function definition.
13633 STMTS is the chain of statements that makes up the function body.
13635 DECL is the ..._DECL that `start_method' provided. */
13638 finish_method (decl
)
13641 register tree fndecl
= decl
;
13644 register tree link
;
13646 if (decl
== void_type_node
)
13649 old_initial
= DECL_INITIAL (fndecl
);
13651 /* Undo the level for the parms (from start_method).
13652 This is like poplevel, but it causes nothing to be
13653 saved. Saving information here confuses symbol-table
13654 output routines. Besides, this information will
13655 be correctly output when this method is actually
13658 /* Clear out the meanings of the local variables of this level;
13659 also record in each decl which block it belongs to. */
13661 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
13663 if (DECL_NAME (link
) != NULL_TREE
)
13664 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = 0;
13665 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
13666 DECL_CONTEXT (link
) = NULL_TREE
;
13669 /* Restore all name-meanings of the outer levels
13670 that were shadowed by this level. */
13672 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
13673 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
13674 for (link
= current_binding_level
->class_shadowed
;
13675 link
; link
= TREE_CHAIN (link
))
13676 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
13677 for (link
= current_binding_level
->type_shadowed
;
13678 link
; link
= TREE_CHAIN (link
))
13679 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
13681 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
13682 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
13683 current_binding_level
->parm_flag
,
13684 current_binding_level
->keep
);
13686 poplevel (0, 0, 0);
13688 DECL_INITIAL (fndecl
) = old_initial
;
13690 /* We used to check if the context of FNDECL was different from
13691 current_class_type as another way to get inside here. This didn't work
13692 for String.cc in libg++. */
13693 if (DECL_FRIEND_P (fndecl
))
13695 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
13696 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
13697 decl
= void_type_node
;
13703 /* Called when a new struct TYPE is defined.
13704 If this structure or union completes the type of any previous
13705 variable declaration, lay it out and output its rtl. */
13708 hack_incomplete_structures (type
)
13713 if (current_binding_level
->incomplete
== NULL_TREE
)
13716 if (!type
) /* Don't do this for class templates. */
13719 for (list
= ¤t_binding_level
->incomplete
; *list
; )
13721 tree decl
= TREE_VALUE (*list
);
13722 if ((decl
&& TREE_TYPE (decl
) == type
)
13723 || (TREE_TYPE (decl
)
13724 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13725 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
13727 int toplevel
= toplevel_bindings_p ();
13728 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13729 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
13730 layout_type (TREE_TYPE (decl
));
13731 layout_decl (decl
, 0);
13732 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
13736 expand_decl (decl
);
13737 cleanup
= maybe_build_cleanup (decl
);
13738 expand_decl_init (decl
);
13739 if (! expand_decl_cleanup (decl
, cleanup
))
13740 cp_error ("parser lost in parsing declaration of `%D'",
13743 *list
= TREE_CHAIN (*list
);
13746 list
= &TREE_CHAIN (*list
);
13750 /* If DECL is of a type which needs a cleanup, build that cleanup here.
13751 See build_delete for information about AUTO_DELETE.
13753 Don't build these on the momentary obstack; they must live
13754 the life of the binding contour. */
13757 maybe_build_cleanup_1 (decl
, auto_delete
)
13758 tree decl
, auto_delete
;
13760 tree type
= TREE_TYPE (decl
);
13761 if (TYPE_NEEDS_DESTRUCTOR (type
))
13763 int temp
= 0, flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
13766 if (TREE_CODE (decl
) != PARM_DECL
)
13767 temp
= suspend_momentary ();
13769 if (TREE_CODE (type
) == ARRAY_TYPE
)
13773 mark_addressable (decl
);
13774 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
13777 /* Optimize for space over speed here. */
13778 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
13779 || flag_expensive_optimizations
)
13780 flags
|= LOOKUP_NONVIRTUAL
;
13782 rval
= build_delete (TREE_TYPE (rval
), rval
, auto_delete
, flags
, 0);
13784 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
13785 && ! TYPE_HAS_DESTRUCTOR (type
))
13786 rval
= build_compound_expr (expr_tree_cons (NULL_TREE
, rval
,
13787 build_expr_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
13789 if (TREE_CODE (decl
) != PARM_DECL
)
13790 resume_momentary (temp
);
13797 /* If DECL is of a type which needs a cleanup, build that cleanup
13798 here. The cleanup does free the storage with a call to delete. */
13801 maybe_build_cleanup_and_delete (decl
)
13804 return maybe_build_cleanup_1 (decl
, integer_three_node
);
13807 /* If DECL is of a type which needs a cleanup, build that cleanup
13808 here. The cleanup does not free the storage with a call a delete. */
13811 maybe_build_cleanup (decl
)
13814 return maybe_build_cleanup_1 (decl
, integer_two_node
);
13817 /* Expand a C++ expression at the statement level.
13818 This is needed to ferret out nodes which have UNKNOWN_TYPE.
13819 The C++ type checker should get all of these out when
13820 expressions are combined with other, type-providing, expressions,
13821 leaving only orphan expressions, such as:
13823 &class::bar; / / takes its address, but does nothing with it. */
13826 cplus_expand_expr_stmt (exp
)
13829 if (processing_template_decl
)
13831 add_tree (build_min_nt (EXPR_STMT
, exp
));
13835 /* Arrange for all temps to disappear. */
13836 expand_start_target_temps ();
13838 if (TREE_TYPE (exp
) == unknown_type_node
)
13840 if (TREE_CODE (exp
) == ADDR_EXPR
|| TREE_CODE (exp
) == TREE_LIST
)
13841 error ("address of overloaded function with no contextual type information");
13842 else if (TREE_CODE (exp
) == COMPONENT_REF
)
13843 warning ("useless reference to a member function name, did you forget the ()?");
13847 if (TREE_CODE (exp
) == FUNCTION_DECL
)
13849 cp_warning ("reference, not call, to function `%D'", exp
);
13850 warning ("at this point in file");
13854 /* We should do this eventually, but right now this causes regex.o from
13855 libg++ to miscompile, and tString to core dump. */
13856 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
13859 /* Strip unused implicit INDIRECT_REFs of references. */
13860 if (TREE_CODE (exp
) == INDIRECT_REF
13861 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
13862 exp
= TREE_OPERAND (exp
, 0);
13864 /* If we don't do this, we end up down inside expand_expr
13865 trying to do TYPE_MODE on the ERROR_MARK, and really
13866 go outside the bounds of the type. */
13867 if (exp
!= error_mark_node
)
13868 expand_expr_stmt (break_out_cleanups (exp
));
13871 /* Clean up any pending cleanups. This happens when a function call
13872 returns a cleanup-needing value that nobody uses. */
13873 expand_end_target_temps ();
13876 /* When a stmt has been parsed, this function is called.
13878 Currently, this function only does something within a
13879 constructor's scope: if a stmt has just assigned to this,
13880 and we are in a derived class, we call `emit_base_init'. */
13885 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
13888 if (current_function_assigns_this
13889 || ! current_function_just_assigned_this
)
13891 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13893 /* Constructors must wait until we are out of control
13894 zones before calling base constructors. */
13895 if (cond_stack
|| loop_stack
|| case_stack
)
13897 expand_expr_stmt (base_init_expr
);
13898 check_base_init (current_class_type
);
13900 current_function_assigns_this
= 1;
13903 /* Change a static member function definition into a FUNCTION_TYPE, instead
13904 of the METHOD_TYPE that we create when it's originally parsed.
13906 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
13907 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
13908 other decls. Either pass the addresses of local variables or NULL. */
13911 revert_static_member_fn (decl
, fn
, argtypes
)
13912 tree
*decl
, *fn
, *argtypes
;
13915 tree function
= fn
? *fn
: TREE_TYPE (*decl
);
13916 tree args
= argtypes
? *argtypes
: TYPE_ARG_TYPES (function
);
13918 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
13919 != TYPE_UNQUALIFIED
)
13920 cp_error ("static member function `%#D' declared with type qualifiers",
13923 args
= TREE_CHAIN (args
);
13924 tmp
= build_function_type (TREE_TYPE (function
), args
);
13925 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
13926 tmp
= build_exception_variant (tmp
,
13927 TYPE_RAISES_EXCEPTIONS (function
));
13928 TREE_TYPE (*decl
) = tmp
;
13929 if (DECL_ARGUMENTS (*decl
))
13930 DECL_ARGUMENTS (*decl
) = TREE_CHAIN (DECL_ARGUMENTS (*decl
));
13931 DECL_STATIC_FUNCTION_P (*decl
) = 1;
13939 id_in_current_class (id
)
13942 return !!purpose_member (id
, class_binding_level
->class_shadowed
);
13949 int warn_about_return_type
;
13951 int just_assigned_this
;
13953 int temp_name_counter
;
13955 tree shadowed_labels
;
13958 rtx last_dtor_insn
;
13959 rtx last_parm_cleanup_insn
;
13960 tree base_init_list
;
13961 tree member_init_list
;
13962 tree base_init_expr
;
13963 tree current_class_ptr
;
13964 tree current_class_ref
;
13966 struct cp_function
*next
;
13967 struct binding_level
*binding_level
;
13968 int static_labelno
;
13971 static struct cp_function
*cp_function_chain
;
13973 extern int temp_name_counter
;
13975 /* Save and reinitialize the variables
13976 used during compilation of a C++ function. */
13979 push_cp_function_context (context
)
13982 struct cp_function
*p
13983 = (struct cp_function
*) xmalloc (sizeof (struct cp_function
));
13985 push_function_context_to (context
);
13987 p
->next
= cp_function_chain
;
13988 cp_function_chain
= p
;
13990 p
->named_labels
= named_labels
;
13991 p
->shadowed_labels
= shadowed_labels
;
13992 p
->returns_value
= current_function_returns_value
;
13993 p
->returns_null
= current_function_returns_null
;
13994 p
->warn_about_return_type
= warn_about_return_type
;
13995 p
->binding_level
= current_binding_level
;
13996 p
->ctor_label
= ctor_label
;
13997 p
->dtor_label
= dtor_label
;
13998 p
->last_dtor_insn
= last_dtor_insn
;
13999 p
->last_parm_cleanup_insn
= last_parm_cleanup_insn
;
14000 p
->assigns_this
= current_function_assigns_this
;
14001 p
->just_assigned_this
= current_function_just_assigned_this
;
14002 p
->parms_stored
= current_function_parms_stored
;
14003 p
->result_rtx
= original_result_rtx
;
14004 p
->base_init_expr
= base_init_expr
;
14005 p
->temp_name_counter
= temp_name_counter
;
14006 p
->base_init_list
= current_base_init_list
;
14007 p
->member_init_list
= current_member_init_list
;
14008 p
->current_class_ptr
= current_class_ptr
;
14009 p
->current_class_ref
= current_class_ref
;
14010 p
->static_labelno
= static_labelno
;
14013 /* Restore the variables used during compilation of a C++ function. */
14016 pop_cp_function_context (context
)
14019 struct cp_function
*p
= cp_function_chain
;
14022 /* Bring back all the labels that were shadowed. */
14023 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
14024 if (DECL_NAME (TREE_VALUE (link
)) != 0)
14025 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)),
14026 TREE_VALUE (link
));
14028 pop_function_context_from (context
);
14030 cp_function_chain
= p
->next
;
14032 named_labels
= p
->named_labels
;
14033 shadowed_labels
= p
->shadowed_labels
;
14034 current_function_returns_value
= p
->returns_value
;
14035 current_function_returns_null
= p
->returns_null
;
14036 warn_about_return_type
= p
->warn_about_return_type
;
14037 current_binding_level
= p
->binding_level
;
14038 ctor_label
= p
->ctor_label
;
14039 dtor_label
= p
->dtor_label
;
14040 last_dtor_insn
= p
->last_dtor_insn
;
14041 last_parm_cleanup_insn
= p
->last_parm_cleanup_insn
;
14042 current_function_assigns_this
= p
->assigns_this
;
14043 current_function_just_assigned_this
= p
->just_assigned_this
;
14044 current_function_parms_stored
= p
->parms_stored
;
14045 original_result_rtx
= p
->result_rtx
;
14046 base_init_expr
= p
->base_init_expr
;
14047 temp_name_counter
= p
->temp_name_counter
;
14048 current_base_init_list
= p
->base_init_list
;
14049 current_member_init_list
= p
->member_init_list
;
14050 current_class_ptr
= p
->current_class_ptr
;
14051 current_class_ref
= p
->current_class_ref
;
14052 static_labelno
= p
->static_labelno
;
14060 return function_depth
!= 0;