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_cplus_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
);
8185 /* Make the init_value nonzero so pushdecl knows this is not
8186 tentative. error_mark_node is replaced later with the BLOCK. */
8187 DECL_INITIAL (decl
) = error_mark_node
;
8189 /* Caller will do the rest of this. */
8193 if (check
&& funcdef_flag
)
8194 DECL_INITIAL (decl
) = error_mark_node
;
8196 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8199 /* Just handle constructors here. We could do this
8200 inside the following if stmt, but I think
8201 that the code is more legible by breaking this
8202 case out. See comments below for what each of
8203 the following calls is supposed to do. */
8204 DECL_CONSTRUCTOR_P (decl
) = 1;
8206 grokclassfn (ctype
, decl
, flags
, quals
);
8208 decl
= check_explicit_specialization (orig_declarator
, decl
,
8210 2 * (funcdef_flag
!= 0) +
8211 4 * (friendp
!= 0));
8212 if (decl
== error_mark_node
)
8213 return error_mark_node
;
8215 if ((! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8218 tmp
= check_classfn (ctype
, decl
);
8220 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8221 tmp
= DECL_TEMPLATE_RESULT(tmp
);
8223 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8224 cp_error ("definition of implicitly-declared `%D'", tmp
);
8225 if (tmp
&& duplicate_decls (decl
, tmp
))
8228 if (! grok_ctor_properties (ctype
, decl
))
8229 return error_mark_node
;
8235 /* Function gets the ugly name, field gets the nice one.
8236 This call may change the type of the function (because
8237 of default parameters)! */
8238 if (ctype
!= NULL_TREE
)
8239 grokclassfn (ctype
, decl
, flags
, quals
);
8241 decl
= check_explicit_specialization (orig_declarator
, decl
,
8243 2 * (funcdef_flag
!= 0) +
8244 4 * (friendp
!= 0));
8245 if (decl
== error_mark_node
)
8246 return error_mark_node
;
8248 if (ctype
!= NULL_TREE
8249 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8252 tmp
= check_classfn (ctype
, decl
);
8254 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8255 tmp
= DECL_TEMPLATE_RESULT (tmp
);
8257 if (tmp
&& DECL_STATIC_FUNCTION_P (tmp
)
8258 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8260 /* Remove the `this' parm added by grokclassfn.
8261 XXX Isn't this done in start_function, too? */
8262 revert_static_member_fn (&decl
, NULL
, NULL
);
8263 last_function_parms
= TREE_CHAIN (last_function_parms
);
8265 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8266 cp_error ("definition of implicitly-declared `%D'", tmp
);
8269 if (!duplicate_decls (decl
, tmp
))
8270 my_friendly_abort (892);
8275 if (ctype
== NULL_TREE
|| check
)
8279 cplus_decl_attributes (decl
, TREE_PURPOSE (attrlist
),
8280 TREE_VALUE (attrlist
));
8281 make_decl_rtl (decl
, NULL_PTR
, 1);
8285 DECL_VIRTUAL_P (decl
) = 1;
8286 if (DECL_VINDEX (decl
) == NULL_TREE
)
8287 DECL_VINDEX (decl
) = error_mark_node
;
8288 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
8295 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
8298 RID_BIT_TYPE
*specbits_in
;
8304 RID_BIT_TYPE specbits
;
8306 specbits
= *specbits_in
;
8308 if (TREE_CODE (type
) == OFFSET_TYPE
)
8310 /* If you declare a static member so that it
8311 can be initialized, the code will reach here. */
8312 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
8313 type
= TREE_TYPE (type
);
8314 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
8315 DECL_CONTEXT (decl
) = basetype
;
8316 DECL_CLASS_CONTEXT (decl
) = basetype
;
8317 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
, declarator
);
8324 context
= in_namespace
;
8325 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
8326 context
= current_namespace
;
8328 context
= NULL_TREE
;
8330 decl
= build_decl (VAR_DECL
, declarator
, complete_type (type
));
8333 set_decl_namespace (decl
, context
);
8335 context
= DECL_CONTEXT (decl
);
8336 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
8337 DECL_ASSEMBLER_NAME (decl
) = build_static_name (context
, declarator
);
8341 set_decl_namespace (decl
, in_namespace
);
8343 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
8345 DECL_THIS_EXTERN (decl
) = 1;
8346 DECL_EXTERNAL (decl
) = !initialized
;
8349 /* In class context, static means one per class,
8350 public access, and static storage. */
8351 if (DECL_CLASS_SCOPE_P (decl
))
8353 TREE_PUBLIC (decl
) = 1;
8354 TREE_STATIC (decl
) = 1;
8355 DECL_EXTERNAL (decl
) = 0;
8357 /* At top level, either `static' or no s.c. makes a definition
8358 (perhaps tentative), and absence of `static' makes it public. */
8359 else if (toplevel_bindings_p ())
8361 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
8362 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8363 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8365 /* Not at top level, only `static' makes a static definition. */
8368 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
8369 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8372 if (TREE_PUBLIC (decl
))
8374 /* [basic.link]: A name with no linkage (notably, the name of a class
8375 or enumeration declared in a local scope) shall not be used to
8376 declare an entity with linkage.
8378 Only check this for public decls for now. */
8379 tree t
= no_linkage_check (TREE_TYPE (decl
));
8382 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8383 /* Ignore for now; `enum { foo } e' is pretty common. */;
8385 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8393 /* Create a canonical pointer to member function type. */
8396 build_ptrmemfunc_type (type
)
8403 /* If a canonical type already exists for this type, use it. We use
8404 this method instead of type_hash_canon, because it only does a
8405 simple equality check on the list of field members. */
8407 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8410 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8412 u
= make_lang_type (UNION_TYPE
);
8413 IS_AGGR_TYPE (u
) = 0;
8414 fields
[0] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
, type
);
8415 fields
[1] = build_lang_field_decl (FIELD_DECL
, delta2_identifier
,
8417 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
8418 TYPE_NAME (u
) = NULL_TREE
;
8420 t
= make_lang_type (RECORD_TYPE
);
8422 /* Let the front-end know this is a pointer to member function... */
8423 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8424 /* ... and not really an aggregate. */
8425 IS_AGGR_TYPE (t
) = 0;
8427 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
8429 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
8431 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
8432 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
8436 /* Zap out the name so that the back-end will give us the debugging
8437 information for this anonymous RECORD_TYPE. */
8438 TYPE_NAME (t
) = NULL_TREE
;
8440 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8442 /* Seems to be wanted. */
8443 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
8447 /* Given declspecs and a declarator,
8448 determine the name and type of the object declared
8449 and construct a ..._DECL node for it.
8450 (In one case we can return a ..._TYPE node instead.
8451 For invalid input we sometimes return 0.)
8453 DECLSPECS is a chain of tree_list nodes whose value fields
8454 are the storage classes and type specifiers.
8456 DECL_CONTEXT says which syntactic context this declaration is in:
8457 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8458 FUNCDEF for a function definition. Like NORMAL but a few different
8459 error messages in each case. Return value may be zero meaning
8460 this definition is too screwy to try to parse.
8461 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8462 handle member functions (which have FIELD context).
8463 Return value may be zero meaning this definition is too screwy to
8465 PARM for a parameter declaration (either within a function prototype
8466 or before a function body). Make a PARM_DECL, or return void_type_node.
8467 CATCHPARM for a parameter declaration before a catch clause.
8468 TYPENAME if for a typename (in a cast or sizeof).
8469 Don't make a DECL node; just return the ..._TYPE node.
8470 FIELD for a struct or union field; make a FIELD_DECL.
8471 BITFIELD for a field with specified width.
8472 INITIALIZED is 1 if the decl has an initializer.
8474 In the TYPENAME case, DECLARATOR is really an absolute declarator.
8475 It may also be so in the PARM case, for a prototype where the
8476 argument type is specified but not the name.
8478 This function is where the complicated C meanings of `static'
8479 and `extern' are interpreted.
8481 For C++, if there is any monkey business to do, the function which
8482 calls this one must do it, i.e., prepending instance variables,
8483 renaming overloaded function names, etc.
8485 Note that for this C++, it is an error to define a method within a class
8486 which does not belong to that class.
8488 Except in the case where SCOPE_REFs are implicitly known (such as
8489 methods within a class being redundantly qualified),
8490 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
8491 (class_name::decl_name). The caller must also deal with this.
8493 If a constructor or destructor is seen, and the context is FIELD,
8494 then the type gains the attribute TREE_HAS_x. If such a declaration
8495 is erroneous, NULL_TREE is returned.
8497 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
8498 function, these are the qualifiers to give to the `this' pointer.
8500 May return void_type_node if the declarator turned out to be a friend.
8501 See grokfield for details. */
8503 enum return_types
{ return_normal
, return_ctor
, return_dtor
, return_conversion
};
8506 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
8509 enum decl_context decl_context
;
8513 RID_BIT_TYPE specbits
;
8516 tree type
= NULL_TREE
;
8522 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8523 int explicit_int
= 0;
8524 int explicit_char
= 0;
8525 int defaulted_int
= 0;
8526 int opaque_typedef
= 0;
8527 tree typedef_decl
= NULL_TREE
;
8529 tree typedef_type
= NULL_TREE
;
8530 int funcdef_flag
= 0;
8531 enum tree_code innermost_code
= ERROR_MARK
;
8534 /* See the code below that used this. */
8535 tree decl_machine_attr
= NULL_TREE
;
8537 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
8538 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
8539 tree init
= NULL_TREE
;
8541 /* Keep track of what sort of function is being processed
8542 so that we can warn about default return values, or explicit
8543 return values which do not match prescribed defaults. */
8544 enum return_types return_type
= return_normal
;
8546 tree dname
= NULL_TREE
;
8547 tree ctype
= current_class_type
;
8548 tree ctor_return_type
= NULL_TREE
;
8549 enum overload_flags flags
= NO_SPECIAL
;
8550 tree quals
= NULL_TREE
;
8551 tree raises
= NULL_TREE
;
8552 int template_count
= 0;
8553 tree in_namespace
= NULL_TREE
;
8557 RIDBIT_RESET_ALL (specbits
);
8558 if (decl_context
== FUNCDEF
)
8559 funcdef_flag
= 1, decl_context
= NORMAL
;
8560 else if (decl_context
== MEMFUNCDEF
)
8561 funcdef_flag
= -1, decl_context
= FIELD
;
8562 else if (decl_context
== BITFIELD
)
8563 bitfield
= 1, decl_context
= FIELD
;
8565 /* Look inside a declarator for the name being declared
8566 and get it as a string, for an error message. */
8568 tree
*next
= &declarator
;
8572 while (next
&& *next
)
8575 switch (TREE_CODE (decl
))
8578 /* For attributes. */
8579 next
= &TREE_VALUE (decl
);
8584 next
= &TREE_OPERAND (decl
, 0);
8587 case BIT_NOT_EXPR
: /* For C++ destructors! */
8589 tree name
= TREE_OPERAND (decl
, 0);
8590 tree rename
= NULL_TREE
;
8592 my_friendly_assert (flags
== NO_SPECIAL
, 152);
8594 return_type
= return_dtor
;
8595 if (TREE_CODE (name
) == TYPE_DECL
)
8596 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
8597 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
8598 if (ctype
== NULL_TREE
)
8600 if (current_class_type
== NULL_TREE
)
8602 error ("destructors must be member functions");
8607 tree t
= constructor_name (current_class_name
);
8614 tree t
= constructor_name (ctype
);
8621 cp_error ("destructor `%T' must match class name `%T'",
8623 TREE_OPERAND (decl
, 0) = rename
;
8629 case ADDR_EXPR
: /* C++ reference declaration */
8634 innermost_code
= TREE_CODE (decl
);
8635 next
= &TREE_OPERAND (decl
, 0);
8639 if (parmlist_is_exprlist (TREE_OPERAND (decl
, 1)))
8641 /* This is actually a variable declaration using constructor
8642 syntax. We need to call start_decl and cp_finish_decl so we
8643 can get the variable initialized... */
8645 *next
= TREE_OPERAND (decl
, 0);
8646 init
= TREE_OPERAND (decl
, 1);
8648 decl
= start_decl (declarator
, declspecs
, 1, NULL_TREE
, NULL_TREE
);
8651 /* Look for __unused__ attribute */
8652 if (TREE_USED (TREE_TYPE (decl
)))
8653 TREE_USED (decl
) = 1;
8654 finish_decl (decl
, init
, NULL_TREE
);
8657 cp_error ("invalid declarator");
8660 innermost_code
= TREE_CODE (decl
);
8661 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
8662 ctype
= current_class_type
;
8664 && TREE_OPERAND (decl
, 0)
8665 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
8666 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
8667 == constructor_name_full (ctype
))
8668 || (DECL_NAME (TREE_OPERAND (decl
, 0))
8669 == constructor_name (ctype
)))))
8670 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8671 next
= &TREE_OPERAND (decl
, 0);
8673 if (ctype
!= NULL_TREE
8674 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
8675 && decl
== constructor_name (ctype
))
8677 return_type
= return_ctor
;
8678 ctor_return_type
= ctype
;
8683 case TEMPLATE_ID_EXPR
:
8685 tree fns
= TREE_OPERAND (decl
, 0);
8687 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
8688 fns
= TREE_OPERAND (fns
, 0);
8690 if (TREE_CODE (fns
) == IDENTIFIER_NODE
)
8692 else if (is_overloaded_fn (fns
))
8693 dname
= DECL_NAME (get_first_fn (fns
));
8695 my_friendly_abort (0);
8699 case IDENTIFIER_NODE
:
8700 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
8707 cp_error ("declarator-id missing; using reserved word `%D'",
8709 name
= IDENTIFIER_POINTER (dname
);
8711 if (! IDENTIFIER_OPNAME_P (dname
)
8712 /* GNU/Linux headers use '__op'. Arrgh. */
8713 || (IDENTIFIER_TYPENAME_P (dname
) && ! TREE_TYPE (dname
)))
8714 name
= IDENTIFIER_POINTER (dname
);
8717 if (IDENTIFIER_TYPENAME_P (dname
))
8719 my_friendly_assert (flags
== NO_SPECIAL
, 154);
8720 flags
= TYPENAME_FLAG
;
8721 ctor_return_type
= TREE_TYPE (dname
);
8722 return_type
= return_conversion
;
8724 name
= operator_name_string (dname
);
8731 /* Perform error checking, and decide on a ctype. */
8732 tree cname
= TREE_OPERAND (decl
, 0);
8733 if (cname
== NULL_TREE
)
8735 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
8738 in_namespace
= TREE_OPERAND (decl
, 0);
8739 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8741 else if (! is_aggr_type (cname
, 1))
8742 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8743 /* Must test TREE_OPERAND (decl, 1), in case user gives
8744 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
8745 else if (TREE_OPERAND (decl
, 1)
8746 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
8748 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
8749 || TREE_CODE (cname
) == TEMPLATE_TEMPLATE_PARM
)
8751 cp_error ("`%T::%D' is not a valid declarator", cname
,
8752 TREE_OPERAND (decl
, 1));
8753 cp_error (" perhaps you want `typename %T::%D' to make it a type",
8754 cname
, TREE_OPERAND (decl
, 1));
8755 return void_type_node
;
8757 else if (ctype
== NULL_TREE
)
8759 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
8760 TREE_OPERAND (decl
, 0) = ctype
;
8763 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
8765 cp_error ("type `%T' is not derived from type `%T'",
8767 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8773 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
8774 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
8775 == constructor_name_full (ctype
))
8776 || (DECL_NAME (TREE_OPERAND (decl
, 1))
8777 == constructor_name (ctype
))))
8778 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
8779 next
= &TREE_OPERAND (decl
, 1);
8783 if (TREE_CODE (decl
) == IDENTIFIER_NODE
8784 && constructor_name (ctype
) == decl
)
8786 return_type
= return_ctor
;
8787 ctor_return_type
= ctype
;
8789 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
8790 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
8791 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
8792 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
8794 return_type
= return_dtor
;
8795 ctor_return_type
= ctype
;
8797 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8798 next
= &TREE_OPERAND (decl
, 0);
8809 /* Parse error puts this typespec where
8810 a declarator should go. */
8811 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
8812 if (TREE_TYPE (decl
) == current_class_type
)
8813 cp_error (" perhaps you want `%T' for a constructor",
8814 current_class_name
);
8815 dname
= DECL_NAME (decl
);
8816 name
= IDENTIFIER_POINTER (dname
);
8818 /* Avoid giving two errors for this. */
8819 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
8821 declspecs
= temp_tree_cons (NULL_TREE
, integer_type_node
,
8828 cp_compiler_error ("`%D' as declarator", decl
);
8829 return 0; /* We used to do a 155 abort here. */
8836 /* A function definition's declarator must have the form of
8837 a function declarator. */
8839 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
8842 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8843 && innermost_code
!= CALL_EXPR
8844 && ! (ctype
&& declspecs
== NULL_TREE
))
8846 cp_error ("declaration of `%D' as non-function", dname
);
8847 return void_type_node
;
8850 /* Anything declared one level down from the top level
8851 must be one of the parameters of a function
8852 (because the body is at least two levels down). */
8854 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8855 by not allowing C++ class definitions to specify their parameters
8856 with xdecls (must be spec.d in the parmlist).
8858 Since we now wait to push a class scope until we are sure that
8859 we are in a legitimate method context, we must set oldcname
8860 explicitly (since current_class_name is not yet alive).
8862 We also want to avoid calling this a PARM if it is in a namespace. */
8864 if (decl_context
== NORMAL
&& ! namespace_bindings_p ()
8865 && ! pseudo_global_level_p ())
8867 struct binding_level
*b
= current_binding_level
;
8868 current_binding_level
= b
->level_chain
;
8869 if (current_binding_level
!= 0 && toplevel_bindings_p ())
8870 decl_context
= PARM
;
8871 current_binding_level
= b
;
8874 /* Look through the decl specs and record which ones appear.
8875 Some typespecs are defined as built-in typenames.
8876 Others, the ones that are modifiers of other types,
8877 are represented by bits in SPECBITS: set the bits for
8878 the modifiers that appear. Storage class keywords are also in SPECBITS.
8880 If there is a typedef name or a type, store the type in TYPE.
8881 This includes builtin typedefs such as `int'.
8883 Set EXPLICIT_INT if the type is `int' or `char' and did not
8884 come from a user typedef.
8886 Set LONGLONG if `long' is mentioned twice.
8888 For C++, constructors and destructors have their own fast treatment. */
8890 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
8895 /* Certain parse errors slip through. For example,
8896 `int class;' is not caught by the parser. Try
8897 weakly to recover here. */
8898 if (TREE_CODE (spec
) != TREE_LIST
)
8901 id
= TREE_VALUE (spec
);
8903 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8905 if (id
== ridpointers
[(int) RID_INT
]
8906 || id
== ridpointers
[(int) RID_CHAR
]
8907 || id
== ridpointers
[(int) RID_BOOL
]
8908 || id
== ridpointers
[(int) RID_WCHAR
])
8912 if (id
== ridpointers
[(int) RID_BOOL
])
8913 error ("`bool' is now a keyword");
8915 cp_error ("extraneous `%T' ignored", id
);
8919 if (id
== ridpointers
[(int) RID_INT
])
8921 else if (id
== ridpointers
[(int) RID_CHAR
])
8923 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
8927 /* C++ aggregate types. */
8928 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
8931 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
8933 type
= IDENTIFIER_TYPE_VALUE (id
);
8937 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
8939 if (ridpointers
[i
] == id
)
8941 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
8943 if (pedantic
&& ! in_system_header
&& warn_long_long
)
8944 pedwarn ("ANSI C++ does not support `long long'");
8946 error ("`long long long' is too long for GCC");
8950 else if (RIDBIT_SETP (i
, specbits
))
8951 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
8952 RIDBIT_SET (i
, specbits
);
8957 /* C++ aggregate types. */
8958 else if (TREE_CODE (id
) == TYPE_DECL
|| TREE_CODE (id
) == TEMPLATE_DECL
)
8961 cp_error ("multiple declarations `%T' and `%T'", type
,
8965 type
= TREE_TYPE (id
);
8966 TREE_VALUE (spec
) = type
;
8971 error ("two or more data types in declaration of `%s'", name
);
8972 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8974 register tree t
= lookup_name (id
, 1);
8975 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
8976 error ("`%s' fails to be a typedef or built in type",
8977 IDENTIFIER_POINTER (id
));
8980 type
= TREE_TYPE (t
);
8982 /* See the code below that used this. */
8983 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
8988 else if (id
!= error_mark_node
)
8989 /* Can't change CLASS nodes into RECORD nodes here! */
8995 typedef_type
= type
;
8997 /* No type at all: default to `int', and set DEFAULTED_INT
8998 because it was not a user-defined typedef.
8999 Except when we have a `typedef' inside a signature, in
9000 which case the type defaults to `unknown type' and is
9001 instantiated when assigning to a signature pointer or ref. */
9003 if (type
== NULL_TREE
9004 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
9005 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9006 || RIDBIT_SETP (RID_LONG
, specbits
)
9007 || RIDBIT_SETP (RID_SHORT
, specbits
)))
9009 /* These imply 'int'. */
9010 type
= integer_type_node
;
9014 if (type
== NULL_TREE
)
9017 if (return_type
== return_dtor
)
9018 type
= void_type_node
;
9019 else if (return_type
== return_ctor
)
9020 type
= build_pointer_type (ctor_return_type
);
9021 else if (return_type
== return_conversion
)
9022 type
= ctor_return_type
;
9023 else if (current_class_type
9024 && IS_SIGNATURE (current_class_type
)
9025 && RIDBIT_SETP (RID_TYPEDEF
, specbits
)
9026 && (decl_context
== FIELD
|| decl_context
== NORMAL
))
9030 type
= copy_node (opaque_type_node
);
9036 if (warn_return_type
9037 && return_type
== return_normal
)
9038 /* Save warning until we know what is really going on. */
9039 warn_about_return_type
= 1;
9041 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9042 pedwarn ("ANSI C++ forbids typedef which does not specify a type");
9043 else if (innermost_code
!= CALL_EXPR
|| pedantic
9044 || (warn_return_type
&& return_type
== return_normal
))
9046 if (innermost_code
== CALL_EXPR
)
9047 cp_pedwarn ("return-type of `%D' defaults to `int'", dname
);
9049 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
9052 type
= integer_type_node
;
9055 else if (return_type
== return_dtor
)
9057 error ("return type specification for destructor invalid");
9058 type
= void_type_node
;
9060 else if (return_type
== return_ctor
)
9062 error ("return type specification for constructor invalid");
9063 type
= build_pointer_type (ctor_return_type
);
9065 else if (return_type
== return_conversion
)
9067 if (comptypes (type
, ctor_return_type
, 1) == 0)
9068 cp_error ("operator `%T' declared to return `%T'",
9069 ctor_return_type
, type
);
9071 cp_pedwarn ("return type specified for `operator %T'",
9074 type
= ctor_return_type
;
9079 /* Now process the modifiers that were specified
9080 and check for invalid combinations. */
9082 /* Long double is a special combination. */
9084 if (RIDBIT_SETP (RID_LONG
, specbits
)
9085 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
9087 RIDBIT_RESET (RID_LONG
, specbits
);
9088 type
= build_qualified_type (long_double_type_node
,
9089 CP_TYPE_QUALS (type
));
9092 /* Check all other uses of type modifiers. */
9094 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9095 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9096 || RIDBIT_SETP (RID_LONG
, specbits
)
9097 || RIDBIT_SETP (RID_SHORT
, specbits
))
9101 if (TREE_CODE (type
) == REAL_TYPE
)
9102 error ("short, signed or unsigned invalid for `%s'", name
);
9103 else if (TREE_CODE (type
) != INTEGER_TYPE
)
9104 error ("long, short, signed or unsigned invalid for `%s'", name
);
9105 else if (RIDBIT_SETP (RID_LONG
, specbits
)
9106 && RIDBIT_SETP (RID_SHORT
, specbits
))
9107 error ("long and short specified together for `%s'", name
);
9108 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9109 || RIDBIT_SETP (RID_SHORT
, specbits
))
9111 error ("long or short specified with char for `%s'", name
);
9112 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9113 || RIDBIT_SETP (RID_SHORT
, specbits
))
9114 && TREE_CODE (type
) == REAL_TYPE
)
9115 error ("long or short specified with floating type for `%s'", name
);
9116 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9117 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
9118 error ("signed and unsigned given together for `%s'", name
);
9122 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
9124 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9126 if (flag_pedantic_errors
)
9131 /* Discard the type modifiers if they are invalid. */
9134 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
9135 RIDBIT_RESET (RID_SIGNED
, specbits
);
9136 RIDBIT_RESET (RID_LONG
, specbits
);
9137 RIDBIT_RESET (RID_SHORT
, specbits
);
9142 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
9143 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9145 error ("complex invalid for `%s'", name
);
9146 RIDBIT_RESET (RID_COMPLEX
, specbits
);
9149 /* Decide whether an integer type is signed or not.
9150 Optionally treat bitfields as signed by default. */
9151 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9152 || (bitfield
&& ! flag_signed_bitfields
9153 && (explicit_int
|| defaulted_int
|| explicit_char
9154 /* A typedef for plain `int' without `signed'
9155 can be controlled just like plain `int'. */
9156 || ! (typedef_decl
!= NULL_TREE
9157 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
9158 && TREE_CODE (type
) != ENUMERAL_TYPE
9159 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)))
9162 type
= long_long_unsigned_type_node
;
9163 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9164 type
= long_unsigned_type_node
;
9165 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9166 type
= short_unsigned_type_node
;
9167 else if (type
== char_type_node
)
9168 type
= unsigned_char_type_node
;
9169 else if (typedef_decl
)
9170 type
= unsigned_type (type
);
9172 type
= unsigned_type_node
;
9174 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9175 && type
== char_type_node
)
9176 type
= signed_char_type_node
;
9178 type
= long_long_integer_type_node
;
9179 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9180 type
= long_integer_type_node
;
9181 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9182 type
= short_integer_type_node
;
9184 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
9186 /* If we just have "complex", it is equivalent to
9187 "complex double", but if any modifiers at all are specified it is
9188 the complex form of TYPE. E.g, "complex short" is
9189 "complex short int". */
9191 if (defaulted_int
&& ! longlong
9192 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
9193 || RIDBIT_SETP (RID_SHORT
, specbits
)
9194 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9195 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
9196 type
= complex_double_type_node
;
9197 else if (type
== integer_type_node
)
9198 type
= complex_integer_type_node
;
9199 else if (type
== float_type_node
)
9200 type
= complex_float_type_node
;
9201 else if (type
== double_type_node
)
9202 type
= complex_double_type_node
;
9203 else if (type
== long_double_type_node
)
9204 type
= complex_long_double_type_node
;
9206 type
= build_complex_type (type
);
9209 if (return_type
== return_conversion
9210 && (RIDBIT_SETP (RID_CONST
, specbits
)
9211 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
9212 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
9213 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9216 /* Set CONSTP if this declaration is `const', whether by
9217 explicit specification or via a typedef.
9218 Likewise for VOLATILEP. */
9220 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
9222 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
9224 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
9225 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9226 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9227 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9228 type
= cp_build_qualified_type (type
, type_quals
);
9230 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
9231 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
9232 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
9233 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
9234 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
9236 if (RIDBIT_SETP (RID_STATIC
, specbits
))
9237 staticp
= 1 + (decl_context
== FIELD
);
9239 if (virtualp
&& staticp
== 2)
9241 cp_error ("member `%D' cannot be declared both virtual and static",
9245 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
9246 RIDBIT_RESET (RID_FRIEND
, specbits
);
9248 /* $7.1.2, Function specifiers */
9249 if (friendp
&& explicitp
)
9250 error ("only declarations of constructors can be `explicit'");
9252 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9254 if (decl_context
== PARM
)
9256 error ("non-member `%s' cannot be declared `mutable'", name
);
9257 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9259 else if (friendp
|| decl_context
== TYPENAME
)
9261 error ("non-object member `%s' cannot be declared `mutable'", name
);
9262 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9266 /* Warn if two storage classes are given. Default to `auto'. */
9268 if (RIDBIT_ANY_SET (specbits
))
9270 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
9271 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
9272 if (decl_context
== PARM
&& nclasses
> 0)
9273 error ("storage class specifiers invalid in parameter declarations");
9274 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9276 if (decl_context
== PARM
)
9277 error ("typedef declaration invalid in parameter declaration");
9280 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
9281 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
9284 /* Give error if `virtual' is used outside of class declaration. */
9286 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9288 error ("virtual outside class declaration");
9291 if (current_class_name
== NULL_TREE
&& RIDBIT_SETP (RID_MUTABLE
, specbits
))
9293 error ("only members can be declared mutable");
9294 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9297 /* Static anonymous unions are dealt with here. */
9298 if (staticp
&& decl_context
== TYPENAME
9299 && TREE_CODE (declspecs
) == TREE_LIST
9300 && ANON_UNION_TYPE_P (TREE_VALUE (declspecs
)))
9301 decl_context
= FIELD
;
9303 /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
9304 is used in a signature member function declaration. */
9305 if (decl_context
== FIELD
9306 && IS_SIGNATURE (current_class_type
)
9307 && RIDBIT_NOTSETP (RID_TYPEDEF
, specbits
))
9309 if (type_quals
!= TYPE_UNQUALIFIED
)
9311 error ("type qualifiers specified for signature member function `%s'", name
);
9312 type_quals
= TYPE_UNQUALIFIED
;
9316 error ("`inline' specified for signature member function `%s'", name
);
9317 /* Later, we'll make signature member functions inline. */
9322 error ("`friend' declaration in signature definition");
9327 error ("`virtual' specified for signature member function `%s'",
9329 /* Later, we'll make signature member functions virtual. */
9334 /* Warn about storage classes that are invalid for certain
9335 kinds of declarations (parameters, typenames, etc.). */
9338 error ("multiple storage classes in declaration of `%s'", name
);
9339 else if (decl_context
!= NORMAL
&& nclasses
> 0)
9341 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9342 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
9343 || RIDBIT_SETP (RID_AUTO
, specbits
)))
9345 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9347 else if (decl_context
== FIELD
9348 && ! IS_SIGNATURE (current_class_type
)
9349 /* C++ allows static class elements */
9350 && RIDBIT_SETP (RID_STATIC
, specbits
))
9351 /* C++ also allows inlines and signed and unsigned elements,
9352 but in those cases we don't come in here. */
9356 if (decl_context
== FIELD
)
9358 tree tmp
= NULL_TREE
;
9359 register int op
= 0;
9363 /* Avoid trying to get an operand off an identifier node. */
9364 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
9367 tmp
= TREE_OPERAND (declarator
, 0);
9368 op
= IDENTIFIER_OPNAME_P (tmp
);
9370 error ("storage class specified for %s `%s'",
9371 IS_SIGNATURE (current_class_type
)
9373 ? "signature member operator"
9374 : "signature member function")
9375 : (op
? "member operator" : "field"),
9376 op
? operator_name_string (tmp
) : name
);
9379 error (((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9380 ? "storage class specified for parameter `%s'"
9381 : "storage class specified for typename"), name
);
9382 RIDBIT_RESET (RID_REGISTER
, specbits
);
9383 RIDBIT_RESET (RID_AUTO
, specbits
);
9384 RIDBIT_RESET (RID_EXTERN
, specbits
);
9386 if (decl_context
== FIELD
&& IS_SIGNATURE (current_class_type
))
9388 RIDBIT_RESET (RID_STATIC
, specbits
);
9393 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
9395 if (toplevel_bindings_p ())
9397 /* It's common practice (and completely valid) to have a const
9398 be initialized and declared extern. */
9400 warning ("`%s' initialized and declared `extern'", name
);
9403 error ("`%s' has both `extern' and initializer", name
);
9405 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
9406 && ! toplevel_bindings_p ())
9407 error ("nested function `%s' declared `extern'", name
);
9408 else if (toplevel_bindings_p ())
9410 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9411 error ("top-level declaration of `%s' specifies `auto'", name
);
9414 if (nclasses
> 0 && friendp
)
9415 error ("storage class specifiers invalid in friend function declarations");
9417 /* Now figure out the structure of the declarator proper.
9418 Descend through it, creating more complex types, until we reach
9419 the declared identifier (or NULL_TREE, in an absolute declarator). */
9421 inner_attrs
= NULL_TREE
;
9424 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
9425 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
9427 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9428 an INDIRECT_REF (for *...),
9429 a CALL_EXPR (for ...(...)),
9430 an identifier (for the name being declared)
9431 or a null pointer (for the place in an absolute declarator
9432 where the name was omitted).
9433 For the last two cases, we have just exited the loop.
9435 For C++ it could also be
9436 a SCOPE_REF (for class :: ...). In this case, we have converted
9437 sensible names to types, and those are the values we use to
9438 qualify the member name.
9439 an ADDR_EXPR (for &...),
9440 a BIT_NOT_EXPR (for destructors)
9442 At this point, TYPE is the type of elements of an array,
9443 or for a function to return, or for a pointer to point to.
9444 After this sequence of ifs, TYPE is the type of the
9445 array or function or pointer, and DECLARATOR has had its
9446 outermost layer removed. */
9448 if (type
== error_mark_node
)
9450 if (TREE_CODE (declarator
) == SCOPE_REF
)
9451 declarator
= TREE_OPERAND (declarator
, 1);
9453 declarator
= TREE_OPERAND (declarator
, 0);
9456 if (quals
!= NULL_TREE
9457 && (declarator
== NULL_TREE
9458 || TREE_CODE (declarator
) != SCOPE_REF
))
9460 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
9461 ctype
= TYPE_METHOD_BASETYPE (type
);
9462 if (ctype
!= NULL_TREE
)
9464 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
9465 ctype
= grok_method_quals (ctype
, dummy
, quals
);
9466 type
= TREE_TYPE (dummy
);
9471 /* See the comment for the TREE_LIST case, below. */
9474 else if (inner_attrs
)
9476 decl_attributes (type
, inner_attrs
, NULL_TREE
);
9477 inner_attrs
= NULL_TREE
;
9480 switch (TREE_CODE (declarator
))
9484 /* We encode a declarator with embedded attributes using
9485 a TREE_LIST. The attributes apply to the declarator
9486 directly inside them, so we have to skip an iteration
9487 before applying them to the type. If the declarator just
9488 inside is the declarator-id, we apply the attrs to the
9490 inner_attrs
= TREE_PURPOSE (declarator
);
9492 declarator
= TREE_VALUE (declarator
);
9498 register tree itype
= NULL_TREE
;
9499 register tree size
= TREE_OPERAND (declarator
, 1);
9500 /* The index is a signed object `sizetype' bits wide. */
9501 tree index_type
= signed_type (sizetype
);
9503 declarator
= TREE_OPERAND (declarator
, 0);
9505 /* Check for some types that there cannot be arrays of. */
9507 if (TREE_CODE (type
) == VOID_TYPE
)
9509 cp_error ("declaration of `%D' as array of voids", dname
);
9510 type
= error_mark_node
;
9513 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9515 cp_error ("declaration of `%D' as array of functions", dname
);
9516 type
= error_mark_node
;
9519 /* ARM $8.4.3: Since you can't have a pointer to a reference,
9520 you can't have arrays of references. If we allowed them,
9521 then we'd be saying x[i] is valid for an array x, but
9522 then you'd have to ask: what does `*(x + i)' mean? */
9523 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9525 if (decl_context
== TYPENAME
)
9526 cp_error ("cannot make arrays of references");
9528 cp_error ("declaration of `%D' as array of references",
9530 type
= error_mark_node
;
9533 if (TREE_CODE (type
) == OFFSET_TYPE
)
9535 cp_error ("declaration of `%D' as array of data members",
9537 type
= error_mark_node
;
9540 if (TREE_CODE (type
) == METHOD_TYPE
)
9542 cp_error ("declaration of `%D' as array of function members",
9544 type
= error_mark_node
;
9547 if (size
== error_mark_node
)
9548 type
= error_mark_node
;
9550 if (type
== error_mark_node
)
9555 /* Must suspend_momentary here because the index
9556 type may need to live until the end of the function.
9557 For example, it is used in the declaration of a
9558 variable which requires destructing at the end of
9559 the function; then build_vec_delete will need this
9561 int yes
= suspend_momentary ();
9562 /* Might be a cast. */
9563 if (TREE_CODE (size
) == NOP_EXPR
9564 && TREE_TYPE (size
) == TREE_TYPE (TREE_OPERAND (size
, 0)))
9565 size
= TREE_OPERAND (size
, 0);
9567 /* If this involves a template parameter, it'll be
9568 constant, but we don't know what the value is yet. */
9569 if (processing_template_decl
)
9571 itype
= make_node (INTEGER_TYPE
);
9572 TYPE_MIN_VALUE (itype
) = size_zero_node
;
9573 TYPE_MAX_VALUE (itype
) = build_min
9574 (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
9575 goto dont_grok_size
;
9578 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
9579 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
)
9581 cp_error ("size of array `%D' has non-integer type",
9583 size
= integer_one_node
;
9585 if (TREE_READONLY_DECL_P (size
))
9586 size
= decl_constant_value (size
);
9587 if (pedantic
&& integer_zerop (size
))
9588 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname
);
9589 if (TREE_CONSTANT (size
))
9591 int old_flag_pedantic_errors
= flag_pedantic_errors
;
9592 int old_pedantic
= pedantic
;
9593 pedantic
= flag_pedantic_errors
= 1;
9594 /* Always give overflow errors on array subscripts. */
9595 constant_expression_warning (size
);
9596 pedantic
= old_pedantic
;
9597 flag_pedantic_errors
= old_flag_pedantic_errors
;
9598 if (INT_CST_LT (size
, integer_zero_node
))
9600 cp_error ("size of array `%D' is negative", dname
);
9601 size
= integer_one_node
;
9609 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
9612 cp_pedwarn ("ANSI C++ forbids variable-size array");
9617 = fold (build_binary_op (MINUS_EXPR
,
9618 cp_convert (index_type
, size
),
9619 cp_convert (index_type
,
9620 integer_one_node
), 1));
9621 if (! TREE_CONSTANT (itype
))
9622 itype
= variable_size (itype
);
9623 else if (TREE_OVERFLOW (itype
))
9625 error ("overflow in array dimension");
9626 TREE_OVERFLOW (itype
) = 0;
9629 /* If we're a parm, we need to have a permanent type so
9630 mangling checks for re-use will work right. If both the
9631 element and index types are permanent, the array type
9633 if (decl_context
== PARM
9634 && allocation_temporary_p () && TREE_PERMANENT (type
))
9636 push_obstacks (&permanent_obstack
, &permanent_obstack
);
9637 itype
= build_index_type (itype
);
9641 itype
= build_index_type (itype
);
9644 resume_momentary (yes
);
9647 type
= build_cplus_array_type (type
, itype
);
9656 tree inner_parms
= TREE_OPERAND (declarator
, 1);
9657 tree inner_decl
= TREE_OPERAND (declarator
, 0);
9659 /* Declaring a function type.
9660 Make sure we have a valid type for the function to return. */
9662 /* We now know that the TYPE_QUALS don't apply to the
9663 decl, but to its return type. */
9664 type_quals
= TYPE_UNQUALIFIED
;
9666 /* Warn about some types functions can't return. */
9668 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9670 error ("`%s' declared as function returning a function", name
);
9671 type
= integer_type_node
;
9673 if (TREE_CODE (type
) == ARRAY_TYPE
)
9675 error ("`%s' declared as function returning an array", name
);
9676 type
= integer_type_node
;
9679 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
9680 inner_decl
= TREE_OPERAND (inner_decl
, 1);
9682 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
9685 /* Pick up type qualifiers which should be applied to `this'. */
9686 quals
= TREE_OPERAND (declarator
, 2);
9688 /* Pick up the exception specifications. */
9689 raises
= TREE_TYPE (declarator
);
9691 /* Say it's a definition only for the CALL_EXPR
9692 closest to the identifier. */
9695 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
9696 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
9697 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
9699 if (ctype
== NULL_TREE
9700 && decl_context
== FIELD
9702 && (friendp
== 0 || dname
== current_class_name
))
9703 ctype
= current_class_type
;
9705 if (ctype
&& return_type
== return_conversion
)
9706 TYPE_HAS_CONVERSION (ctype
) = 1;
9707 if (ctype
&& constructor_name (ctype
) == dname
)
9709 /* We are within a class's scope. If our declarator name
9710 is the same as the class name, and we are defining
9711 a function, then it is a constructor/destructor, and
9712 therefore returns a void type. */
9714 if (flags
== DTOR_FLAG
)
9716 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
9717 not be declared const or volatile. A destructor
9718 may not be static. */
9720 error ("destructor cannot be static member function");
9723 cp_error ("destructors may not be `%s'",
9724 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9727 if (decl_context
== FIELD
)
9729 if (! member_function_or_else (ctype
, current_class_type
,
9730 "destructor for alien class `%s' cannot be a member"))
9731 return void_type_node
;
9734 else /* It's a constructor. */
9738 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
9739 not be declared const or volatile. A constructor may
9740 not be virtual. A constructor may not be static. */
9742 error ("constructor cannot be static member function");
9745 pedwarn ("constructors cannot be declared virtual");
9750 cp_error ("constructors may not be `%s'",
9751 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9755 RID_BIT_TYPE tmp_bits
;
9756 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
9757 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
9758 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
9759 if (RIDBIT_ANY_SET (tmp_bits
))
9760 error ("return value type specifier for constructor ignored");
9762 type
= build_pointer_type (ctype
);
9763 if (decl_context
== FIELD
9764 && IS_SIGNATURE (current_class_type
))
9766 error ("constructor not allowed in signature");
9767 return void_type_node
;
9769 else if (decl_context
== FIELD
)
9771 if (! member_function_or_else (ctype
, current_class_type
,
9772 "constructor for alien class `%s' cannot be member"))
9773 return void_type_node
;
9774 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
9775 if (return_type
!= return_ctor
)
9779 if (decl_context
== FIELD
)
9785 error ("can't initialize friend function `%s'", name
);
9788 /* Cannot be both friend and virtual. */
9789 error ("virtual functions cannot be friends");
9790 RIDBIT_RESET (RID_FRIEND
, specbits
);
9793 if (decl_context
== NORMAL
)
9794 error ("friend declaration not in class definition");
9795 if (current_function_decl
&& funcdef_flag
)
9796 cp_error ("can't define friend function `%s' in a local class definition",
9800 /* Construct the function type and go to the next
9801 inner layer of declarator. */
9803 declarator
= TREE_OPERAND (declarator
, 0);
9805 /* FIXME: This is where default args should be fully
9808 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
9810 if (declarator
&& flags
== DTOR_FLAG
)
9812 /* A destructor declared in the body of a class will
9813 be represented as a BIT_NOT_EXPR. But, we just
9814 want the underlying IDENTIFIER. */
9815 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
9816 declarator
= TREE_OPERAND (declarator
, 0);
9818 if (strict_prototype
== 0 && arg_types
== NULL_TREE
)
9819 arg_types
= void_list_node
;
9820 else if (arg_types
== NULL_TREE
9821 || arg_types
!= void_list_node
)
9823 cp_error ("destructors may not have parameters");
9824 arg_types
= void_list_node
;
9825 last_function_parms
= NULL_TREE
;
9829 /* ANSI says that `const int foo ();'
9830 does not make the function foo const. */
9831 type
= build_function_type (type
, arg_types
);
9835 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
9836 if (TREE_PURPOSE (t
)
9837 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
9839 add_defarg_fn (type
);
9848 /* Filter out pointers-to-references and references-to-references.
9849 We can get these if a TYPE_DECL is used. */
9851 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9853 error ("cannot declare %s to references",
9854 TREE_CODE (declarator
) == ADDR_EXPR
9855 ? "references" : "pointers");
9856 declarator
= TREE_OPERAND (declarator
, 0);
9860 if (TREE_CODE (type
) == OFFSET_TYPE
9861 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
9862 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
9864 cp_error ("cannot declare pointer to `%#T' member",
9866 type
= TREE_TYPE (type
);
9869 /* Merge any constancy or volatility into the target type
9872 /* We now know that the TYPE_QUALS don't apply to the decl,
9873 but to the target of the pointer. */
9874 type_quals
= TYPE_UNQUALIFIED
;
9876 if (IS_SIGNATURE (type
))
9878 if (TREE_CODE (declarator
) == ADDR_EXPR
)
9880 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9881 && TYPE_SIZE (type
))
9882 cp_warning ("empty signature `%T' used in signature reference declaration",
9885 type
= build_signature_reference_type (type
);
9887 sorry ("signature reference");
9893 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9894 && TYPE_SIZE (type
))
9895 cp_warning ("empty signature `%T' used in signature pointer declaration",
9897 type
= build_signature_pointer_type (type
);
9900 else if (TREE_CODE (declarator
) == ADDR_EXPR
)
9902 if (TREE_CODE (type
) == VOID_TYPE
)
9903 error ("invalid type: `void &'");
9905 type
= build_reference_type (type
);
9907 else if (TREE_CODE (type
) == METHOD_TYPE
)
9909 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9912 type
= build_pointer_type (type
);
9914 /* Process a list of type modifier keywords (such as
9915 const or volatile) that were given inside the `*' or `&'. */
9917 if (TREE_TYPE (declarator
))
9919 register tree typemodlist
;
9925 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
9926 typemodlist
= TREE_CHAIN (typemodlist
))
9928 tree qualifier
= TREE_VALUE (typemodlist
);
9930 if (qualifier
== ridpointers
[(int) RID_CONST
])
9932 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
9934 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
9939 error ("invalid type modifier within pointer declarator");
9943 pedwarn ("duplicate `const'");
9945 pedwarn ("duplicate `volatile'");
9947 pedwarn ("duplicate `restrict'");
9949 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9950 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9951 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9952 if (TREE_CODE (declarator
) == ADDR_EXPR
9953 && (constp
|| volatilep
))
9956 pedwarn ("discarding `const' applied to a reference");
9958 pedwarn ("discarding `volatile' applied to a reference");
9959 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
9961 type
= cp_build_qualified_type (type
, type_quals
);
9963 declarator
= TREE_OPERAND (declarator
, 0);
9969 /* We have converted type names to NULL_TREE if the
9970 name was bogus, or to a _TYPE node, if not.
9972 The variable CTYPE holds the type we will ultimately
9973 resolve to. The code here just needs to build
9974 up appropriate member types. */
9975 tree sname
= TREE_OPERAND (declarator
, 1);
9978 /* Destructors can have their visibilities changed as well. */
9979 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
9980 sname
= TREE_OPERAND (sname
, 0);
9982 if (TREE_COMPLEXITY (declarator
) == 0)
9983 /* This needs to be here, in case we are called
9984 multiple times. */ ;
9985 else if (TREE_COMPLEXITY (declarator
) == -1)
9986 /* Namespace member. */
9987 pop_decl_namespace ();
9988 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
9989 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
9990 else if (! IS_AGGR_TYPE_CODE
9991 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
9993 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
9995 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
9996 that refer to ctype. They couldn't be resolved earlier
9997 because we hadn't pushed into the class yet.
9998 Example: resolve 'B<T>::type' in
9999 'B<typename B<T>::type> B<T>::f () { }'. */
10000 if (current_template_parms
10001 && uses_template_parms (type
)
10002 && uses_template_parms (current_class_type
))
10004 tree args
= current_template_args ();
10005 type
= tsubst (type
, args
, NULL_TREE
);
10008 /* This pop_nested_class corresponds to the
10009 push_nested_class used to push into class scope for
10010 parsing the argument list of a function decl, in
10012 pop_nested_class (1);
10013 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10016 my_friendly_abort (16);
10018 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10020 /* We had a reference to a global decl, or
10021 perhaps we were given a non-aggregate typedef,
10022 in which case we cleared this out, and should just
10023 keep going as though it wasn't there. */
10024 declarator
= sname
;
10027 ctype
= TREE_OPERAND (declarator
, 0);
10030 while (t
!= NULL_TREE
)
10032 if (CLASSTYPE_TEMPLATE_INFO (t
) &&
10033 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
10034 template_count
+= 1;
10035 t
= TYPE_MAIN_DECL (t
);
10036 if (DECL_LANG_SPECIFIC (t
))
10037 t
= DECL_CLASS_CONTEXT (t
);
10042 if (sname
== NULL_TREE
)
10045 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10047 /* This is the `standard' use of the scoping operator:
10048 basetype :: member . */
10050 if (ctype
== current_class_type
)
10056 Is this ill-formed? */
10059 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10062 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10064 if (current_class_type
== NULL_TREE
10066 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10067 TYPE_ARG_TYPES (type
));
10070 cp_error ("cannot declare member function `%T::%s' within `%T'",
10071 ctype
, name
, current_class_type
);
10072 return void_type_node
;
10075 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10076 || TYPE_SIZE (complete_type (ctype
)) != NULL_TREE
)
10078 /* Have to move this code elsewhere in this function.
10079 this code is used for i.e., typedef int A::M; M *pm;
10081 It is? How? jason 10/2/94 */
10083 if (current_class_type
)
10085 cp_error ("cannot declare member `%T::%s' within `%T'",
10086 ctype
, name
, current_class_type
);
10087 return void_type_node
;
10089 type
= build_offset_type (ctype
, type
);
10091 else if (uses_template_parms (ctype
))
10093 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10095 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
10096 TYPE_ARG_TYPES (type
));
10100 cp_error ("structure `%T' not yet defined", ctype
);
10101 return error_mark_node
;
10104 declarator
= sname
;
10106 else if (TREE_CODE (sname
) == SCOPE_REF
)
10107 my_friendly_abort (17);
10111 declarator
= TREE_OPERAND (declarator
, 1);
10112 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
10113 /* In this case, we will deal with it later. */
10117 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10118 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10119 TYPE_ARG_TYPES (type
));
10121 type
= build_offset_type (ctype
, type
);
10128 declarator
= TREE_OPERAND (declarator
, 0);
10133 case ENUMERAL_TYPE
:
10134 declarator
= NULL_TREE
;
10138 declarator
= NULL_TREE
;
10142 my_friendly_abort (158);
10146 /* See the comment for the TREE_LIST case, above. */
10149 if (! ignore_attrs
)
10150 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10152 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
10154 attrlist
= build_decl_list (NULL_TREE
, inner_attrs
);
10157 if (explicitp
== 1)
10159 error ("only constructors can be declared `explicit'");
10163 /* Now TYPE has the actual type. */
10165 /* If this is declaring a typedef name, return a TYPE_DECL. */
10167 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10169 if (type_quals
& TYPE_QUAL_CONST
)
10171 error ("const `%s' cannot be declared `mutable'", name
);
10172 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10176 error ("static `%s' cannot be declared `mutable'", name
);
10177 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10181 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
10185 /* Note that the grammar rejects storage classes
10186 in typenames, fields or parameters. */
10187 if (current_lang_name
== lang_name_java
)
10188 TYPE_FOR_JAVA (type
) = 1;
10190 if (decl_context
== FIELD
)
10192 if (declarator
== current_class_name
)
10193 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10195 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10196 if (IS_SIGNATURE (current_class_type
) && opaque_typedef
)
10197 SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type
) = 1;
10201 /* Make sure this typedef lives as long as its type,
10202 since it might be used as a template parameter. */
10203 if (type
!= error_mark_node
)
10204 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
10205 decl
= build_decl (TYPE_DECL
, declarator
, type
);
10206 if (type
!= error_mark_node
)
10210 /* If the user declares "struct {...} foo" then `foo' will have
10211 an anonymous name. Fill that name in now. Nothing can
10212 refer to it, so nothing needs know about the name change.
10213 The TYPE_NAME field was filled in by build_struct_xref. */
10214 if (type
!= error_mark_node
10215 && TYPE_NAME (type
)
10216 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10217 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
10219 /* FIXME: This is bogus; we should not be doing this for
10220 cv-qualified types. */
10222 /* For anonymous structs that are cv-qualified, need to use
10223 TYPE_MAIN_VARIANT so that name will mangle correctly. As
10224 type not referenced after this block, don't bother
10225 resetting type to original type, ie. TREE_TYPE (decl). */
10226 type
= TYPE_MAIN_VARIANT (type
);
10228 /* Replace the anonymous name with the real name everywhere. */
10229 lookup_tag_reverse (type
, declarator
);
10230 TYPE_NAME (type
) = decl
;
10232 if (TYPE_LANG_SPECIFIC (type
))
10233 TYPE_WAS_ANONYMOUS (type
) = 1;
10235 /* XXX Temporarily set the scope.
10236 When returning, start_decl expects it as NULL_TREE,
10237 and will then then set it using pushdecl. */
10238 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
10239 if (current_class_type
)
10240 DECL_CONTEXT (decl
) = current_class_type
;
10242 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10244 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
10245 DECL_ASSEMBLER_NAME (decl
)
10246 = get_identifier (build_overload_name (type
, 1, 1));
10247 DECL_CONTEXT (decl
) = NULL_TREE
;
10249 /* FIXME remangle member functions; member functions of a
10250 type with external linkage have external linkage. */
10253 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10255 cp_error_at ("typedef name may not be class-qualified", decl
);
10260 if (ctype
== NULL_TREE
)
10262 if (TREE_CODE (type
) != METHOD_TYPE
)
10263 cp_error_at ("invalid type qualifier for non-method type", decl
);
10265 ctype
= TYPE_METHOD_BASETYPE (type
);
10267 if (ctype
!= NULL_TREE
)
10268 grok_method_quals (ctype
, decl
, quals
);
10271 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10272 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10273 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10275 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10276 error ("non-object member `%s' cannot be declared mutable", name
);
10278 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
10279 inlinep
, friendp
, raises
!= NULL_TREE
);
10282 error ("typedef declaration includes an initializer");
10287 /* Detect the case of an array type of unspecified size
10288 which came, as such, direct from a typedef name.
10289 We must copy the type, so that each identifier gets
10290 a distinct type, so that each identifier's size can be
10291 controlled separately by its own initializer. */
10293 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
10294 && TYPE_DOMAIN (type
) == NULL_TREE
)
10296 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
10299 /* If this is a type name (such as, in a cast or sizeof),
10300 compute the type and return it now. */
10302 if (decl_context
== TYPENAME
)
10304 /* Note that the grammar rejects storage classes
10305 in typenames, fields or parameters. */
10306 if (type_quals
!= TYPE_UNQUALIFIED
)
10308 if (IS_SIGNATURE (type
))
10309 error ("type qualifiers specified for signature type");
10310 type_quals
= TYPE_UNQUALIFIED
;
10313 /* Special case: "friend class foo" looks like a TYPENAME context. */
10316 if (type_quals
!= TYPE_UNQUALIFIED
)
10318 cp_error ("type qualifiers specified for friend class declaration");
10319 type_quals
= TYPE_UNQUALIFIED
;
10323 cp_error ("`inline' specified for friend class declaration");
10327 /* Only try to do this stuff if we didn't already give up. */
10328 if (type
!= integer_type_node
)
10330 /* A friendly class? */
10331 if (current_class_type
)
10332 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
10334 error ("trying to make class `%s' a friend of global scope",
10335 TYPE_NAME_STRING (type
));
10336 type
= void_type_node
;
10341 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
10342 if (ctype
== NULL_TREE
)
10344 my_friendly_assert (TREE_CODE (type
) == METHOD_TYPE
, 159);
10345 ctype
= TYPE_METHOD_BASETYPE (type
);
10347 grok_method_quals (ctype
, dummy
, quals
);
10348 type
= TREE_TYPE (dummy
);
10353 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
10354 && decl_context
!= CATCHPARM
10355 && TREE_CODE (type
) != UNION_TYPE
10358 cp_error ("abstract declarator `%T' used as declaration", type
);
10359 declarator
= make_anon_name ();
10362 /* `void' at top level (not within pointer)
10363 is allowed only in typedefs or type names.
10364 We don't complain about parms either, but that is because
10365 a better error message can be made later. */
10367 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
10370 error ("unnamed variable or field declared void");
10371 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10373 if (IDENTIFIER_OPNAME_P (declarator
))
10374 my_friendly_abort (356);
10376 error ("variable or field `%s' declared void", name
);
10379 error ("variable or field declared void");
10380 type
= integer_type_node
;
10383 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10384 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10386 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10388 if (ctype
|| in_namespace
)
10389 error ("cannot use `::' in parameter declaration");
10391 /* A parameter declared as an array of T is really a pointer to T.
10392 One declared as a function is really a pointer to a function.
10393 One declared as a member is really a pointer to member. */
10395 if (TREE_CODE (type
) == ARRAY_TYPE
)
10397 /* Transfer const-ness of array into that of type pointed to. */
10398 type
= build_pointer_type (TREE_TYPE (type
));
10399 type_quals
= TYPE_UNQUALIFIED
;
10401 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10402 type
= build_pointer_type (type
);
10403 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10404 type
= build_pointer_type (type
);
10405 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
10407 error ("declaration of `%s' as void", name
);
10413 register tree decl
;
10415 if (decl_context
== PARM
)
10417 decl
= build_decl (PARM_DECL
, declarator
, complete_type (type
));
10419 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
10420 inlinep
, friendp
, raises
!= NULL_TREE
);
10421 if (current_class_type
10422 && IS_SIGNATURE (current_class_type
))
10425 error ("parameter of signature member function declared `inline'");
10426 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10427 error ("parameter of signature member function declared `auto'");
10428 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10429 error ("parameter of signature member function declared `register'");
10432 /* Compute the type actually passed in the parmlist,
10433 for the case where there is no prototype.
10434 (For example, shorts and chars are passed as ints.)
10435 When there is a prototype, this is overridden later. */
10437 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
10439 else if (decl_context
== FIELD
)
10441 if (type
== error_mark_node
)
10443 /* Happens when declaring arrays of sizes which
10444 are error_mark_node, for example. */
10447 else if (in_namespace
)
10449 /* Something like struct S { int N::j; }; */
10450 cp_error ("invalid use of `::'");
10453 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10456 tree function_context
;
10458 /* We catch the others as conflicts with the builtin
10460 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
10462 cp_error ("function `%D' cannot be declared friend",
10469 if (ctype
== NULL_TREE
)
10470 ctype
= current_class_type
;
10472 if (ctype
== NULL_TREE
)
10474 cp_error ("can't make `%D' into a method -- not in a class",
10476 return void_type_node
;
10479 /* ``A union may [ ... ] not [ have ] virtual functions.''
10481 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10483 cp_error ("function `%D' declared virtual inside a union",
10485 return void_type_node
;
10488 if (declarator
== ansi_opname
[(int) NEW_EXPR
]
10489 || declarator
== ansi_opname
[(int) VEC_NEW_EXPR
]
10490 || declarator
== ansi_opname
[(int) DELETE_EXPR
]
10491 || declarator
== ansi_opname
[(int) VEC_DELETE_EXPR
])
10495 cp_error ("`%D' cannot be declared virtual, since it is always static",
10500 else if (staticp
< 2)
10501 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10502 TYPE_ARG_TYPES (type
));
10505 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10506 function_context
= (ctype
!= NULL_TREE
) ?
10507 hack_decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10508 publicp
= (! friendp
|| ! staticp
)
10509 && function_context
== NULL_TREE
;
10510 decl
= grokfndecl (ctype
, type
,
10511 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
10512 ? declarator
: dname
,
10514 virtualp
, flags
, quals
, raises
, attrlist
,
10515 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
10516 funcdef_flag
, template_count
, in_namespace
);
10517 if (decl
== NULL_TREE
|| decl
== error_mark_node
)
10520 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10521 /* The decl and setting of decl_machine_attr is also turned off. */
10522 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
10525 /* [class.conv.ctor]
10527 A constructor declared without the function-specifier
10528 explicit that can be called with a single parameter
10529 specifies a conversion from the type of its first
10530 parameter to the type of its class. Such a constructor
10531 is called a converting constructor. */
10532 if (explicitp
== 2)
10533 DECL_NONCONVERTING_P (decl
) = 1;
10534 else if (DECL_CONSTRUCTOR_P (decl
))
10536 /* The constructor can be called with exactly one
10537 parameter if there is at least one parameter, and
10538 any subsequent parameters have default arguments.
10539 We don't look at the first parameter, which is
10540 really just the `this' parameter for the new
10543 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
10545 /* Skip the `in_chrg' argument too, if present. */
10546 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl
)))
10547 arg_types
= TREE_CHAIN (arg_types
);
10549 if (arg_types
== void_list_node
10551 && TREE_CHAIN (arg_types
)
10552 && TREE_CHAIN (arg_types
) != void_list_node
10553 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
10554 DECL_NONCONVERTING_P (decl
) = 1;
10557 else if (TREE_CODE (type
) == METHOD_TYPE
)
10559 /* We only get here for friend declarations of
10560 members of other classes. */
10561 /* All method decls are public, so tell grokfndecl to set
10562 TREE_PUBLIC, also. */
10563 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
10564 virtualp
, flags
, quals
, raises
, attrlist
,
10565 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
10566 template_count
, in_namespace
);
10567 if (decl
== NULL_TREE
)
10570 else if (!staticp
&& ! processing_template_decl
10571 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
10572 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10575 cp_error ("field `%D' has incomplete type", declarator
);
10577 cp_error ("name `%T' has incomplete type", type
);
10579 /* If we're instantiating a template, tell them which
10580 instantiation made the field's type be incomplete. */
10581 if (current_class_type
10582 && TYPE_NAME (current_class_type
)
10583 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
10584 && declspecs
&& TREE_VALUE (declspecs
)
10585 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
10586 cp_error (" in instantiation of template `%T'",
10587 current_class_type
);
10589 type
= error_mark_node
;
10596 error ("`%s' is neither function nor method; cannot be declared friend",
10597 IDENTIFIER_POINTER (declarator
));
10605 /* Friends are treated specially. */
10606 if (ctype
== current_class_type
)
10607 warning ("member functions are implicitly friends of their class");
10610 tree t
= NULL_TREE
;
10611 if (decl
&& DECL_NAME (decl
))
10613 if (template_class_depth (current_class_type
) == 0)
10616 = check_explicit_specialization
10618 template_count
, 2 * (funcdef_flag
!= 0) + 4);
10619 if (decl
== error_mark_node
)
10620 return error_mark_node
;
10623 t
= do_friend (ctype
, declarator
, decl
,
10624 last_function_parms
, flags
, quals
,
10627 if (t
&& funcdef_flag
)
10630 return void_type_node
;
10634 /* Structure field. It may not be a function, except for C++ */
10636 if (decl
== NULL_TREE
)
10642 /* An attempt is being made to initialize a non-static
10643 member. But, from [class.mem]:
10645 4 A member-declarator can contain a
10646 constant-initializer only if it declares a static
10647 member (_class.static_) of integral or enumeration
10648 type, see _class.static.data_.
10650 This used to be relatively common practice, but
10651 the rest of the compiler does not correctly
10652 handle the initialization unless the member is
10653 static so we make it static below. */
10654 cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
10655 constp
? "const member" : "member",
10657 cp_pedwarn ("making `%D' static", declarator
);
10661 /* Motion 10 at San Diego: If a static const integral data
10662 member is initialized with an integral constant
10663 expression, the initializer may appear either in the
10664 declaration (within the class), or in the definition,
10665 but not both. If it appears in the class, the member is
10666 a member constant. The file-scope definition is always
10668 if (CLASS_TYPE_P (type
)
10669 || TREE_CODE (type
) == REFERENCE_TYPE
)
10671 cp_error ("in-class initialization of static data member of non-integral type `%T'",
10673 /* If we just return the declaration, crashes will
10674 sometimes occur. We therefore return
10675 void_type_node, as if this was a friend
10676 declaration, to cause callers to completely
10677 ignore this declaration. */
10678 return void_type_node
;
10681 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
10683 else if (pedantic
&& ! INTEGRAL_TYPE_P (type
)
10684 && !uses_template_parms (type
))
10685 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", declarator
, type
);
10690 /* ANSI C++ Apr '95 wp 9.2 */
10691 if (declarator
== current_class_name
)
10692 cp_pedwarn ("ANSI C++ forbids static member `%D' with same name as enclosing class",
10695 /* C++ allows static class members.
10696 All other work for this is done by grokfield.
10697 This VAR_DCL is built by build_lang_field_decl.
10698 All other VAR_DECLs are built by build_decl. */
10699 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
10700 TREE_STATIC (decl
) = 1;
10701 /* In class context, 'static' means public access. */
10702 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
10706 decl
= build_lang_field_decl (FIELD_DECL
, declarator
, type
);
10707 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10709 DECL_MUTABLE_P (decl
) = 1;
10710 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10714 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
10715 inlinep
, friendp
, raises
!= NULL_TREE
);
10718 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10720 tree original_name
;
10726 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10727 original_name
= dname
;
10729 original_name
= declarator
;
10731 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10732 error ("storage class `auto' invalid for function `%s'", name
);
10733 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10734 error ("storage class `register' invalid for function `%s'", name
);
10736 /* Function declaration not at top level.
10737 Storage classes other than `extern' are not allowed
10738 and `extern' makes no difference. */
10739 if (! toplevel_bindings_p ()
10740 && (RIDBIT_SETP (RID_STATIC
, specbits
)
10741 || RIDBIT_SETP (RID_INLINE
, specbits
))
10744 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10745 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
10747 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
10750 if (ctype
== NULL_TREE
)
10754 error ("virtual non-class function `%s'", name
);
10758 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
10759 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10760 TYPE_ARG_TYPES (type
));
10762 /* Record presence of `static'. */
10763 publicp
= (ctype
!= NULL_TREE
10764 || RIDBIT_SETP (RID_EXTERN
, specbits
)
10765 || !RIDBIT_SETP (RID_STATIC
, specbits
));
10767 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
10768 virtualp
, flags
, quals
, raises
, attrlist
,
10770 publicp
, inlinep
, funcdef_flag
,
10771 template_count
, in_namespace
);
10772 if (decl
== NULL_TREE
)
10775 /* Among other times, could occur from check_explicit_specialization
10776 returning an error_mark_node. */
10777 if (decl
== error_mark_node
)
10778 return error_mark_node
;
10782 int illegal_static
= 0;
10784 /* Don't allow a static member function in a class, and forbid
10785 declaring main to be static. */
10786 if (TREE_CODE (type
) == METHOD_TYPE
)
10788 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
10789 illegal_static
= 1;
10791 else if (current_function_decl
)
10793 /* FIXME need arm citation */
10794 error ("cannot declare static function inside another function");
10795 illegal_static
= 1;
10798 if (illegal_static
)
10801 RIDBIT_RESET (RID_STATIC
, specbits
);
10807 /* It's a variable. */
10809 /* An uninitialized decl with `extern' is a reference. */
10810 decl
= grokvardecl (type
, declarator
, &specbits
,
10811 initialized
, constp
, in_namespace
);
10812 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
10813 inlinep
, friendp
, raises
!= NULL_TREE
);
10817 DECL_CONTEXT (decl
) = ctype
;
10820 cp_pedwarn ("static member `%D' re-declared as static", decl
);
10822 RIDBIT_RESET (RID_STATIC
, specbits
);
10824 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
10826 cp_error ("static member `%D' declared `register'", decl
);
10827 RIDBIT_RESET (RID_REGISTER
, specbits
);
10829 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
10831 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
10833 RIDBIT_RESET (RID_EXTERN
, specbits
);
10838 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10840 error ("`%s' cannot be declared mutable", name
);
10843 /* Record `register' declaration for warnings on &
10844 and in case doing stupid register allocation. */
10846 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10847 DECL_REGISTER (decl
) = 1;
10849 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
10850 DECL_THIS_EXTERN (decl
) = 1;
10852 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10853 DECL_THIS_STATIC (decl
) = 1;
10855 /* Record constancy and volatility. */
10856 /* FIXME: Disallow `restrict' pointer-to-member declarations. */
10857 c_apply_type_quals_to_decl (type_quals
, decl
);
10863 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
10864 An empty exprlist is a parmlist. An exprlist which
10865 contains only identifiers at the global level
10866 is a parmlist. Otherwise, it is an exprlist. */
10869 parmlist_is_exprlist (exprs
)
10872 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
10875 if (toplevel_bindings_p ())
10877 /* At the global level, if these are all identifiers,
10878 then it is a parmlist. */
10881 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
10883 exprs
= TREE_CHAIN (exprs
);
10890 /* Subroutine of `grokparms'. In a fcn definition, arg types must
10893 C++: also subroutine of `start_function'. */
10896 require_complete_types_for_parms (parms
)
10899 if (processing_template_decl
)
10904 tree type
= TREE_TYPE (parms
);
10905 if (TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
10907 if (DECL_NAME (parms
))
10908 error ("parameter `%s' has incomplete type",
10909 IDENTIFIER_POINTER (DECL_NAME (parms
)));
10911 error ("parameter has incomplete type");
10912 TREE_TYPE (parms
) = error_mark_node
;
10915 /* If the arg types are incomplete in a declaration,
10916 they must include undefined tags.
10917 These tags can never be defined in the scope of the declaration,
10918 so the types can never be completed,
10919 and no call can be compiled successfully. */
10920 /* This is not the right behavior for C++, but not having
10921 it is also probably wrong. */
10924 /* Now warn if is a pointer to an incomplete type. */
10925 while (TREE_CODE (type
) == POINTER_TYPE
10926 || TREE_CODE (type
) == REFERENCE_TYPE
)
10927 type
= TREE_TYPE (type
);
10928 type
= TYPE_MAIN_VARIANT (type
);
10929 if (TYPE_SIZE (type
) == NULL_TREE
)
10931 if (DECL_NAME (parm
) != NULL_TREE
)
10932 warning ("parameter `%s' points to incomplete type",
10933 IDENTIFIER_POINTER (DECL_NAME (parm
)));
10935 warning ("parameter points to incomplete type");
10939 parms
= TREE_CHAIN (parms
);
10943 /* Decode the list of parameter types for a function type.
10944 Given the list of things declared inside the parens,
10945 return a list of types.
10947 The list we receive can have three kinds of elements:
10948 an IDENTIFIER_NODE for names given without types,
10949 a TREE_LIST node for arguments given as typespecs or names with typespecs,
10950 or void_type_node, to mark the end of an argument list
10951 when additional arguments are not permitted (... was not used).
10953 FUNCDEF_FLAG is nonzero for a function definition, 0 for
10954 a mere declaration. A nonempty identifier-list gets an error message
10955 when FUNCDEF_FLAG is zero.
10956 If FUNCDEF_FLAG is 1, then parameter types must be complete.
10957 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
10959 If all elements of the input list contain types,
10960 we return a list of the types.
10961 If all elements contain no type (except perhaps a void_type_node
10962 at the end), we return a null list.
10963 If some have types and some do not, it is an error, and we
10964 return a null list.
10966 Also set last_function_parms to either
10967 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
10968 A list of names is converted to a chain of PARM_DECLs
10969 by store_parm_decls so that ultimately it is always a chain of decls.
10971 Note that in C++, parameters can take default values. These default
10972 values are in the TREE_PURPOSE field of the TREE_LIST. It is
10973 an error to specify default values which are followed by parameters
10974 that have no default values, or an ELLIPSES. For simplicities sake,
10975 only parameters which are specified with their types can take on
10979 grokparms (first_parm
, funcdef_flag
)
10983 tree result
= NULL_TREE
;
10984 tree decls
= NULL_TREE
;
10986 if (first_parm
!= NULL_TREE
10987 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
10989 if (! funcdef_flag
)
10990 pedwarn ("parameter names (without types) in function declaration");
10991 last_function_parms
= first_parm
;
10994 else if (first_parm
!= NULL_TREE
10995 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
10996 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
10997 my_friendly_abort (145);
11000 /* Types were specified. This is a list of declarators
11001 each represented as a TREE_LIST node. */
11002 register tree parm
, chain
;
11003 int any_init
= 0, any_error
= 0;
11005 if (first_parm
!= NULL_TREE
)
11007 tree last_result
= NULL_TREE
;
11008 tree last_decl
= NULL_TREE
;
11010 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
11012 tree type
= NULL_TREE
, list_node
= parm
;
11013 register tree decl
= TREE_VALUE (parm
);
11014 tree init
= TREE_PURPOSE (parm
);
11016 chain
= TREE_CHAIN (parm
);
11017 /* @@ weak defense against parse errors. */
11018 if (TREE_CODE (decl
) != VOID_TYPE
11019 && TREE_CODE (decl
) != TREE_LIST
)
11021 /* Give various messages as the need arises. */
11022 if (TREE_CODE (decl
) == STRING_CST
)
11023 cp_error ("invalid string constant `%E'", decl
);
11024 else if (TREE_CODE (decl
) == INTEGER_CST
)
11025 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11029 if (TREE_CODE (decl
) != VOID_TYPE
)
11031 decl
= grokdeclarator (TREE_VALUE (decl
),
11032 TREE_PURPOSE (decl
),
11033 PARM
, init
!= NULL_TREE
,
11038 /* Top-level qualifiers on the parameters are
11039 ignored for function types. */
11040 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
11042 if (TREE_CODE (type
) == VOID_TYPE
)
11043 decl
= void_type_node
;
11044 else if (TREE_CODE (type
) == METHOD_TYPE
)
11046 if (DECL_NAME (decl
))
11047 /* Cannot use the decl here because
11048 we don't have DECL_CONTEXT set up yet. */
11049 cp_error ("parameter `%D' invalidly declared method type",
11052 error ("parameter invalidly declared method type");
11053 type
= build_pointer_type (type
);
11054 TREE_TYPE (decl
) = type
;
11056 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11058 if (DECL_NAME (decl
))
11059 cp_error ("parameter `%D' invalidly declared offset type",
11062 error ("parameter invalidly declared offset type");
11063 type
= build_pointer_type (type
);
11064 TREE_TYPE (decl
) = type
;
11066 else if (TREE_CODE (type
) == RECORD_TYPE
11067 && TYPE_LANG_SPECIFIC (type
)
11068 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
11070 abstract_virtuals_error (decl
, type
);
11071 any_error
= 1; /* Seems like a good idea. */
11073 else if (TREE_CODE (type
) == RECORD_TYPE
11074 && TYPE_LANG_SPECIFIC (type
)
11075 && IS_SIGNATURE (type
))
11077 signature_error (decl
, type
);
11078 any_error
= 1; /* Seems like a good idea. */
11080 else if (POINTER_TYPE_P (type
))
11083 while (POINTER_TYPE_P (t
)
11084 || (TREE_CODE (t
) == ARRAY_TYPE
11085 && TYPE_DOMAIN (t
) != NULL_TREE
))
11087 if (TREE_CODE (t
) == ARRAY_TYPE
)
11088 cp_error ("parameter type `%T' includes %s to array of unknown bound",
11090 TYPE_PTR_P (type
) ? "pointer" : "reference");
11094 if (TREE_CODE (decl
) == VOID_TYPE
)
11096 if (result
== NULL_TREE
)
11098 result
= void_list_node
;
11099 last_result
= result
;
11103 TREE_CHAIN (last_result
) = void_list_node
;
11104 last_result
= void_list_node
;
11107 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
11108 error ("`void' in parameter list must be entire list");
11112 /* Since there is a prototype, args are passed in their own types. */
11113 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
11114 #ifdef PROMOTE_PROTOTYPES
11115 if ((TREE_CODE (type
) == INTEGER_TYPE
11116 || TREE_CODE (type
) == ENUMERAL_TYPE
)
11117 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
11118 DECL_ARG_TYPE (decl
) = integer_type_node
;
11125 if (TREE_CODE (init
) == SAVE_EXPR
)
11126 PARM_DECL_EXPR (init
) = 1;
11127 else if (processing_template_decl
)
11129 /* Unparsed default arg from in-class decl. */
11130 else if (TREE_CODE (init
) == DEFAULT_ARG
)
11132 else if (TREE_CODE (init
) == VAR_DECL
11133 || TREE_CODE (init
) == PARM_DECL
)
11135 if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init
)))
11137 /* ``Local variables may not be used in default
11138 argument expressions.'' dpANSI C++ 8.2.6 */
11139 /* If extern int i; within a function is not
11140 considered a local variable, then this code is
11142 cp_error ("local variable `%D' may not be used as a default argument", init
);
11145 else if (TREE_READONLY_DECL_P (init
))
11146 init
= decl_constant_value (init
);
11149 init
= require_instantiated_type (type
, init
, integer_zero_node
);
11150 if (! processing_template_decl
11151 && init
!= error_mark_node
11152 && TREE_CODE (init
) != DEFAULT_ARG
11153 && ! can_convert_arg (type
, TREE_TYPE (init
), init
))
11154 cp_pedwarn ("invalid type `%T' for default argument to `%#D'",
11155 TREE_TYPE (init
), decl
);
11161 if (decls
== NULL_TREE
)
11168 TREE_CHAIN (last_decl
) = decl
;
11171 if (! current_function_decl
&& TREE_PERMANENT (list_node
))
11173 TREE_PURPOSE (list_node
) = init
;
11174 TREE_VALUE (list_node
) = type
;
11175 TREE_CHAIN (list_node
) = NULL_TREE
;
11178 list_node
= saveable_tree_cons (init
, type
, NULL_TREE
);
11179 if (result
== NULL_TREE
)
11181 result
= list_node
;
11182 last_result
= result
;
11186 TREE_CHAIN (last_result
) = list_node
;
11187 last_result
= list_node
;
11191 TREE_CHAIN (last_result
) = NULL_TREE
;
11192 /* If there are no parameters, and the function does not end
11193 with `...', then last_decl will be NULL_TREE. */
11194 if (last_decl
!= NULL_TREE
)
11195 TREE_CHAIN (last_decl
) = NULL_TREE
;
11199 last_function_parms
= decls
;
11201 /* In a fcn definition, arg types must be complete. */
11202 if (funcdef_flag
> 0)
11203 require_complete_types_for_parms (last_function_parms
);
11208 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11209 FUNCTION_TYPE with the newly parsed version of its default argument, which
11210 was previously digested as text. See snarf_defarg et al in lex.c. */
11213 replace_defarg (arg
, init
)
11216 if (! processing_template_decl
11217 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
11218 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11219 TREE_TYPE (init
), TREE_VALUE (arg
));
11220 TREE_PURPOSE (arg
) = init
;
11227 tree t
= FUNCTION_ARG_CHAIN (d
);
11228 if (DECL_CONSTRUCTOR_P (d
)
11229 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d
)))
11230 t
= TREE_CHAIN (t
);
11231 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
11232 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
11233 == DECL_CLASS_CONTEXT (d
))
11234 && (TREE_CHAIN (t
) == NULL_TREE
11235 || TREE_CHAIN (t
) == void_list_node
11236 || TREE_PURPOSE (TREE_CHAIN (t
))))
11241 /* These memoizing functions keep track of special properties which
11242 a class may have. `grok_ctor_properties' notices whether a class
11243 has a constructor of the form X(X&), and also complains
11244 if the class has a constructor of the form X(X).
11245 `grok_op_properties' takes notice of the various forms of
11246 operator= which are defined, as well as what sorts of type conversion
11247 may apply. Both functions take a FUNCTION_DECL as an argument. */
11250 grok_ctor_properties (ctype
, decl
)
11253 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
11254 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
11256 /* When a type has virtual baseclasses, a magical first int argument is
11257 added to any ctor so we can tell if the class has been initialized
11258 yet. This could screw things up in this function, so we deliberately
11259 ignore the leading int if we're in that situation. */
11260 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
11262 my_friendly_assert (parmtypes
11263 && TREE_VALUE (parmtypes
) == integer_type_node
,
11265 parmtypes
= TREE_CHAIN (parmtypes
);
11266 parmtype
= TREE_VALUE (parmtypes
);
11269 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
11270 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
11271 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11272 || TREE_CHAIN (parmtypes
) == void_list_node
11273 || TREE_PURPOSE (TREE_CHAIN (parmtypes
))))
11275 TYPE_HAS_INIT_REF (ctype
) = 1;
11276 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11277 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
11279 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
11280 && TREE_CHAIN (parmtypes
) != NULL_TREE
11281 && TREE_CHAIN (parmtypes
) == void_list_node
)
11283 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11285 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
11288 else if (TREE_CODE (parmtype
) == VOID_TYPE
11289 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
11290 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
11295 /* An operator with this name can be either unary or binary. */
11301 return (name
== ansi_opname
[(int) INDIRECT_REF
]
11302 || name
== ansi_opname
[(int) ADDR_EXPR
]
11303 || name
== ansi_opname
[(int) NEGATE_EXPR
]
11304 || name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11305 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]
11306 || name
== ansi_opname
[(int) CONVERT_EXPR
]);
11309 /* An operator with this name can only be unary. */
11315 return (name
== ansi_opname
[(int) TRUTH_NOT_EXPR
]
11316 || name
== ansi_opname
[(int) BIT_NOT_EXPR
]
11317 || name
== ansi_opname
[(int) COMPONENT_REF
]
11318 || OPERATOR_TYPENAME_P (name
));
11321 /* Do a little sanity-checking on how they declared their operator. */
11324 grok_op_properties (decl
, virtualp
, friendp
)
11326 int virtualp
, friendp
;
11328 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11329 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11330 tree name
= DECL_NAME (decl
);
11332 if (current_class_type
== NULL_TREE
)
11337 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11338 TYPE_HAS_ASSIGNMENT (current_class_type
) = 1;
11339 else if (name
== ansi_opname
[(int) CALL_EXPR
])
11340 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
11341 else if (name
== ansi_opname
[(int) ARRAY_REF
])
11342 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
11343 else if (name
== ansi_opname
[(int) COMPONENT_REF
]
11344 || name
== ansi_opname
[(int) MEMBER_REF
])
11345 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
11346 else if (name
== ansi_opname
[(int) NEW_EXPR
])
11347 TYPE_GETS_NEW (current_class_type
) |= 1;
11348 else if (name
== ansi_opname
[(int) DELETE_EXPR
])
11349 TYPE_GETS_DELETE (current_class_type
) |= 1;
11350 else if (name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11351 TYPE_GETS_NEW (current_class_type
) |= 2;
11352 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11353 TYPE_GETS_DELETE (current_class_type
) |= 2;
11356 if (name
== ansi_opname
[(int) NEW_EXPR
]
11357 || name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11359 /* When the compiler encounters the definition of A::operator new, it
11360 doesn't look at the class declaration to find out if it's static. */
11362 revert_static_member_fn (&decl
, NULL
, NULL
);
11364 /* Take care of function decl if we had syntax errors. */
11365 if (argtypes
== NULL_TREE
)
11367 = build_function_type (ptr_type_node
,
11368 hash_tree_chain (integer_type_node
,
11371 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11373 else if (name
== ansi_opname
[(int) DELETE_EXPR
]
11374 || name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11377 revert_static_member_fn (&decl
, NULL
, NULL
);
11379 if (argtypes
== NULL_TREE
)
11381 = build_function_type (void_type_node
,
11382 hash_tree_chain (ptr_type_node
,
11386 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11388 if (! friendp
&& name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
11389 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
11390 != void_list_node
))
11391 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type
) = 1;
11396 /* An operator function must either be a non-static member function
11397 or have at least one parameter of a class, a reference to a class,
11398 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11399 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11401 if (OPERATOR_TYPENAME_P (name
)
11402 || name
== ansi_opname
[(int) CALL_EXPR
]
11403 || name
== ansi_opname
[(int) MODIFY_EXPR
]
11404 || name
== ansi_opname
[(int) COMPONENT_REF
]
11405 || name
== ansi_opname
[(int) ARRAY_REF
])
11406 cp_error ("`%D' must be a nonstatic member function", decl
);
11411 if (DECL_STATIC_FUNCTION_P (decl
))
11412 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
11415 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
11417 tree arg
= TREE_VALUE (p
);
11418 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
11419 arg
= TREE_TYPE (arg
);
11421 /* This lets bad template code slip through. */
11422 if (IS_AGGR_TYPE (arg
)
11423 || TREE_CODE (arg
) == ENUMERAL_TYPE
11424 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
11425 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11429 ("`%D' must have an argument of class or enumerated type",
11436 if (name
== ansi_opname
[(int) CALL_EXPR
])
11437 return; /* No restrictions on args. */
11439 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
11441 tree t
= TREE_TYPE (name
);
11442 if (TREE_CODE (t
) == VOID_TYPE
)
11443 pedwarn ("void is not a valid type conversion operator");
11444 else if (! friendp
)
11446 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11449 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11451 if (t
== current_class_type
)
11452 what
= "the same type";
11453 /* Don't force t to be complete here. */
11454 else if (IS_AGGR_TYPE (t
)
11456 && DERIVED_FROM_P (t
, current_class_type
))
11457 what
= "a base class";
11460 warning ("conversion to %s%s will never use a type conversion operator",
11461 ref
? "a reference to " : "", what
);
11465 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11469 if (list_length (argtypes
) != 3 && methodp
)
11471 cp_error ("`%D' must take exactly one argument", decl
);
11474 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
11476 if (copy_assignment_arg_p (parmtype
, virtualp
)
11479 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
11480 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
11481 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11482 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
11485 else if (name
== ansi_opname
[(int) COND_EXPR
])
11488 pedwarn ("ANSI C++ prohibits overloading operator ?:");
11489 if (list_length (argtypes
) != 4)
11490 cp_error ("`%D' must take exactly three arguments", decl
);
11492 else if (ambi_op_p (name
))
11494 if (list_length (argtypes
) == 2)
11496 else if (list_length (argtypes
) == 3)
11498 if ((name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11499 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11500 && ! processing_template_decl
11501 && TREE_VALUE (TREE_CHAIN (argtypes
)) != integer_type_node
)
11504 cp_error ("postfix `%D' must take `int' as its argument",
11508 ("postfix `%D' must take `int' as its second argument",
11515 cp_error ("`%D' must take either zero or one argument", decl
);
11517 cp_error ("`%D' must take either one or two arguments", decl
);
11520 /* More Effective C++ rule 6. */
11522 && (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11523 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]))
11525 tree arg
= TREE_VALUE (argtypes
);
11526 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11527 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11528 arg
= TREE_TYPE (arg
);
11529 arg
= TYPE_MAIN_VARIANT (arg
);
11530 if (list_length (argtypes
) == 2)
11532 if (TREE_CODE (ret
) != REFERENCE_TYPE
11533 || !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11535 cp_warning ("prefix `%D' should return `%T'", decl
,
11536 build_reference_type (arg
));
11540 if (!comptypes (TYPE_MAIN_VARIANT (ret
), arg
, 1))
11541 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
11545 else if (unary_op_p (name
))
11547 if (list_length (argtypes
) != 2)
11550 cp_error ("`%D' must take `void'", decl
);
11552 cp_error ("`%D' must take exactly one argument", decl
);
11555 else /* if (binary_op_p (name)) */
11557 if (list_length (argtypes
) != 3)
11560 cp_error ("`%D' must take exactly one argument", decl
);
11562 cp_error ("`%D' must take exactly two arguments", decl
);
11565 /* More Effective C++ rule 7. */
11567 && (name
== ansi_opname
[TRUTH_ANDIF_EXPR
]
11568 || name
== ansi_opname
[TRUTH_ORIF_EXPR
]
11569 || name
== ansi_opname
[COMPOUND_EXPR
]))
11570 cp_warning ("user-defined `%D' always evaluates both arguments",
11574 /* Effective C++ rule 23. */
11576 && list_length (argtypes
) == 3
11577 && (name
== ansi_opname
[PLUS_EXPR
]
11578 || name
== ansi_opname
[MINUS_EXPR
]
11579 || name
== ansi_opname
[TRUNC_DIV_EXPR
]
11580 || name
== ansi_opname
[MULT_EXPR
])
11581 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11582 cp_warning ("`%D' should return by value", decl
);
11586 for (; argtypes
!= void_list_node
; argtypes
= TREE_CHAIN (argtypes
))
11587 if (TREE_PURPOSE (argtypes
))
11589 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11590 if (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11591 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11594 cp_pedwarn ("`%D' cannot have default arguments", decl
);
11597 cp_error ("`%D' cannot have default arguments", decl
);
11602 /* Get the struct, enum or union (CODE says which) with tag NAME.
11603 Define the tag as a forward-reference if it is not defined.
11605 C++: If a class derivation is given, process it here, and report
11606 an error if multiple derivation declarations are not identical.
11608 If this is a definition, come in through xref_tag and only look in
11609 the current frame for the name (since C++ allows new names in any
11613 xref_tag (code_type_node
, name
, globalize
)
11614 tree code_type_node
;
11618 enum tag_types tag_code
;
11619 enum tree_code code
;
11621 register tree ref
, t
;
11622 struct binding_level
*b
= inner_binding_level
;
11624 tree attributes
= NULL_TREE
;
11626 /* If we are called from the parser, code_type_node will sometimes be a
11627 TREE_LIST. This indicates that the user wrote
11628 "class __attribute__ ((foo)) bar". Extract the attributes so we can
11630 if (TREE_CODE (code_type_node
) == TREE_LIST
)
11632 attributes
= TREE_PURPOSE (code_type_node
);
11633 code_type_node
= TREE_VALUE (code_type_node
);
11636 tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11641 case signature_type
:
11642 code
= RECORD_TYPE
;
11648 code
= ENUMERAL_TYPE
;
11651 my_friendly_abort (18);
11654 /* If a cross reference is requested, look up the type
11655 already defined for this tag and return it. */
11656 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
11659 name
= TYPE_IDENTIFIER (t
);
11663 t
= IDENTIFIER_TYPE_VALUE (name
);
11665 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
11666 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
)
11671 if (t
&& (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
11672 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
))
11674 cp_error ("redeclaration of template type-parameter `%T'", name
);
11675 cp_error_at (" previously declared here `%#D'",
11676 TEMPLATE_TYPE_DECL (t
));
11678 if (t
&& TYPE_CONTEXT (t
) && got_type
)
11681 /* If we know we are defining this tag, only look it up in
11682 this scope and don't try to find it as a type. */
11683 ref
= lookup_tag (code
, name
, b
, 1);
11687 if (current_class_type
11688 && template_class_depth (current_class_type
)
11689 && PROCESSING_REAL_TEMPLATE_DECL_P ())
11690 /* Since GLOBALIZE is non-zero, we are not looking at a
11691 definition of this tag. Since, in addition, we are currently
11692 processing a (member) template declaration of a template
11693 class, we don't want to do any lookup at all; consider:
11700 { template <class V>
11701 friend struct S1; };
11703 Here, the S2::S1 declaration should not be confused with the
11704 outer declaration. In particular, the inner version should
11705 have a template parameter of level 2, not level 1. This
11706 would be particularly important if the member declaration
11709 template <class V = U> friend struct S1;
11711 say, when we should tsubst into `U' when instantiating S2. */
11718 ref
= lookup_tag (code
, name
, b
, 0);
11722 /* Try finding it as a type declaration. If that wins,
11724 ref
= lookup_name (name
, 1);
11726 if (ref
!= NULL_TREE
11727 && processing_template_decl
11728 && DECL_CLASS_TEMPLATE_P (ref
)
11729 && template_class_depth (current_class_type
) == 0)
11730 /* Since GLOBALIZE is true, we're declaring a global
11731 template, so we want this type. */
11732 ref
= DECL_RESULT (ref
);
11734 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
11735 && TREE_CODE (TREE_TYPE (ref
)) == code
)
11736 ref
= TREE_TYPE (ref
);
11743 push_obstacks_nochange ();
11747 /* If no such tag is yet defined, create a forward-reference node
11748 and record it as the "definition".
11749 When a real declaration of this type is found,
11750 the forward-reference will be altered into a real type. */
11752 /* In C++, since these migrate into the global scope, we must
11753 build them on the permanent obstack. */
11755 temp
= allocation_temporary_p ();
11757 end_temporary_allocation ();
11759 if (code
== ENUMERAL_TYPE
)
11761 cp_error ("use of enum `%#D' without previous declaration", name
);
11763 ref
= make_node (ENUMERAL_TYPE
);
11765 /* Give the type a default layout like unsigned int
11766 to avoid crashing if it does not get defined. */
11767 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
11768 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
11769 TREE_UNSIGNED (ref
) = 1;
11770 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
11771 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
11772 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
11774 /* Enable us to recognize when a type is created in class context.
11775 To do nested classes correctly, this should probably be cleared
11776 out when we leave this classes scope. Currently this in only
11777 done in `start_enum'. */
11779 pushtag (name
, ref
, globalize
);
11783 struct binding_level
*old_b
= class_binding_level
;
11785 ref
= make_lang_type (code
);
11787 if (tag_code
== signature_type
)
11789 SET_SIGNATURE (ref
);
11790 /* Since a signature type will be turned into the type
11791 of signature tables, it's not only an interface. */
11792 CLASSTYPE_INTERFACE_ONLY (ref
) = 0;
11793 SET_CLASSTYPE_INTERFACE_KNOWN (ref
);
11794 /* A signature doesn't have a vtable. */
11795 CLASSTYPE_VTABLE_NEEDS_WRITING (ref
) = 0;
11798 #ifdef NONNESTED_CLASSES
11799 /* Class types don't nest the way enums do. */
11800 class_binding_level
= (struct binding_level
*)0;
11802 pushtag (name
, ref
, globalize
);
11803 class_binding_level
= old_b
;
11808 /* If it no longer looks like a nested type, make sure it's
11810 If it is not an IDENTIFIER, this is not a declaration */
11811 if (b
->namespace_p
&& !class_binding_level
11812 && TREE_CODE (name
) == IDENTIFIER_NODE
)
11814 if (IDENTIFIER_NAMESPACE_VALUE (name
) == NULL_TREE
)
11815 SET_IDENTIFIER_NAMESPACE_VALUE (name
, TYPE_NAME (ref
));
11818 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
11819 redeclare_class_template (ref
, current_template_parms
);
11822 /* Until the type is defined, tentatively accept whatever
11823 structure tag the user hands us. */
11824 if (TYPE_SIZE (ref
) == NULL_TREE
11825 && ref
!= current_class_type
11826 /* Have to check this, in case we have contradictory tag info. */
11827 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
11829 if (tag_code
== class_type
)
11830 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
11831 else if (tag_code
== record_type
|| tag_code
== signature_type
)
11832 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
11837 TREE_TYPE (ref
) = attributes
;
11839 if (ref
&& TYPE_P (ref
))
11843 If the identifier resolves to a typedef-name or a template
11844 type-parameter, the elaborated-type-specifier is
11846 if (TYPE_LANG_SPECIFIC (ref
) && TYPE_WAS_ANONYMOUS (ref
))
11847 cp_error ("`%T' is a typedef name", ref
);
11848 else if (TREE_CODE (ref
) == TEMPLATE_TYPE_PARM
)
11849 cp_error ("`%T' is a template type paramter", ref
);
11856 xref_tag_from_type (old
, id
, globalize
)
11860 tree code_type_node
;
11862 if (TREE_CODE (old
) == RECORD_TYPE
)
11863 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
11864 ? class_type_node
: record_type_node
);
11866 code_type_node
= union_type_node
;
11868 if (id
== NULL_TREE
)
11869 id
= TYPE_IDENTIFIER (old
);
11871 return xref_tag (code_type_node
, id
, globalize
);
11875 xref_basetypes (code_type_node
, name
, ref
, binfo
)
11876 tree code_type_node
;
11880 /* In the declaration `A : X, Y, ... Z' we mark all the types
11881 (A, X, Y, ..., Z) so we can check for duplicates. */
11884 enum tag_types tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11886 if (tag_code
== union_type
)
11888 cp_error ("derived union `%T' invalid", ref
);
11892 len
= list_length (binfo
);
11893 push_obstacks (TYPE_OBSTACK (ref
), TYPE_OBSTACK (ref
));
11895 SET_CLASSTYPE_MARKED (ref
);
11896 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
11898 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
11900 /* The base of a derived struct is public by default. */
11902 = (TREE_PURPOSE (binfo
) == access_public_node
11903 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11904 || (tag_code
!= class_type
11905 && (TREE_PURPOSE (binfo
) == access_default_node
11906 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
11908 = (TREE_PURPOSE (binfo
) == access_protected_node
11909 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
11911 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
11912 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
11913 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11914 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
11915 tree basetype
= TREE_VALUE (binfo
);
11918 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
11919 basetype
= TREE_TYPE (basetype
);
11921 || (TREE_CODE (basetype
) != RECORD_TYPE
11922 && TREE_CODE (basetype
) != TYPENAME_TYPE
11923 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
11924 && TREE_CODE (basetype
) != TEMPLATE_TEMPLATE_PARM
))
11926 cp_error ("base type `%T' fails to be a struct or class type",
11927 TREE_VALUE (binfo
));
11931 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
11934 /* This code replaces similar code in layout_basetypes.
11935 We put the complete_type first for implicit `typename'. */
11936 if (TYPE_SIZE (complete_type (basetype
)) == NULL_TREE
11937 && ! (current_template_parms
&& uses_template_parms (basetype
)))
11939 cp_error ("base class `%T' has incomplete type", basetype
);
11945 if (CLASSTYPE_MARKED (basetype
))
11947 if (basetype
== ref
)
11948 cp_error ("recursive type `%T' undefined", basetype
);
11950 cp_error ("duplicate base type `%T' invalid", basetype
);
11954 if (TYPE_FOR_JAVA (basetype
)
11955 && current_lang_stack
== current_lang_base
)
11956 TYPE_FOR_JAVA (ref
) = 1;
11958 /* Note that the BINFO records which describe individual
11959 inheritances are *not* shared in the lattice! They
11960 cannot be shared because a given baseclass may be
11961 inherited with different `accessibility' by different
11962 derived classes. (Each BINFO record describing an
11963 individual inheritance contains flags which say what
11964 the `accessibility' of that particular inheritance is.) */
11966 base_binfo
= make_binfo (integer_zero_node
, basetype
,
11967 TYPE_BINFO_VTABLE (basetype
),
11968 TYPE_BINFO_VIRTUALS (basetype
));
11970 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
11971 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
11972 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
11973 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
11974 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
11976 /* We need to unshare the binfos now so that lookups during class
11977 definition work. */
11978 unshare_base_binfos (base_binfo
);
11980 SET_CLASSTYPE_MARKED (basetype
);
11982 /* We are free to modify these bits because they are meaningless
11983 at top level, and BASETYPE is a top-level type. */
11984 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
11986 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
11987 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
11990 TYPE_GETS_NEW (ref
) |= TYPE_GETS_NEW (basetype
);
11991 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
11996 TREE_VEC_LENGTH (binfos
) = i
;
11998 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
12001 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
12003 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
12004 = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos
, 0)));
12005 if (TYPE_USES_MULTIPLE_INHERITANCE (ref
))
12006 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12008 /* Unmark all the types. */
12010 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
12011 CLEAR_CLASSTYPE_MARKED (ref
);
12017 /* Begin compiling the definition of an enumeration type.
12018 NAME is its name (or null if anonymous).
12019 Returns the type object, as yet incomplete.
12020 Also records info about it so that build_enumerator
12021 may be used to declare the individual values as they are read. */
12027 register tree enumtype
= NULL_TREE
;
12028 struct binding_level
*b
= inner_binding_level
;
12030 /* We are wasting space here and putting these on the permanent_obstack so
12031 that typeid(local enum) will work correctly. */
12033 if (processing_template_decl
&& current_function_decl
)
12036 end_temporary_allocation ();
12038 /* If this is the real definition for a previous forward reference,
12039 fill in the contents in the same object that used to be the
12040 forward reference. */
12042 if (name
!= NULL_TREE
)
12043 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
12045 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12046 cp_error ("multiple definition of `%#T'", enumtype
);
12049 enumtype
= make_node (ENUMERAL_TYPE
);
12050 pushtag (name
, enumtype
, 0);
12053 if (current_class_type
)
12054 TREE_ADDRESSABLE (b
->tags
) = 1;
12056 /* We don't copy this value because build_enumerator needs to do it. */
12057 enum_next_value
= integer_zero_node
;
12060 GNU_xref_decl (current_function_decl
, enumtype
);
12064 /* After processing and defining all the values of an enumeration type,
12065 install their decls in the enumeration type and finish it off.
12066 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12067 Returns ENUMTYPE. */
12070 finish_enum (enumtype
)
12073 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
12074 /* Calculate the maximum value of any enumerator in this type. */
12076 tree values
= TYPE_VALUES (enumtype
);
12081 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
12086 /* The TREE_VALUE is a CONST_DECL for this enumeration
12088 decl
= TREE_VALUE (pair
);
12090 /* The DECL_INITIAL will be NULL if we are processing a
12091 template declaration and this enumeration constant had no
12092 explicit initializer. */
12093 value
= DECL_INITIAL (decl
);
12094 if (value
&& !processing_template_decl
)
12096 /* Set the TREE_TYPE for the VALUE as well. That's so
12097 that when we call decl_constant_value we get an
12098 entity of the right type (but with the constant
12099 value). Since we shouldn't ever call
12100 decl_constant_value on a template type, there's no
12101 reason to do that when processing_template_decl.
12102 And, if the expression is something like a
12103 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12104 wreak havoc on the intended type of the expression.
12106 Of course, there's also no point in trying to compute
12107 minimum or maximum values if we're in a template. */
12108 TREE_TYPE (value
) = enumtype
;
12111 minnode
= maxnode
= value
;
12112 else if (tree_int_cst_lt (maxnode
, value
))
12114 else if (tree_int_cst_lt (value
, minnode
))
12118 if (processing_template_decl
)
12119 /* If this is just a template, leave the CONST_DECL
12120 alone. That way tsubst_copy will find CONST_DECLs for
12121 CONST_DECLs, and not INTEGER_CSTs. */
12124 /* In the list we're building up, we want the enumeration
12125 values, not the CONST_DECLs. */
12126 TREE_VALUE (pair
) = value
;
12130 maxnode
= minnode
= integer_zero_node
;
12132 TYPE_VALUES (enumtype
) = nreverse (values
);
12134 if (processing_template_decl
)
12136 tree scope
= current_scope ();
12137 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
12139 add_tree (build_min (TAG_DEFN
, enumtype
));
12140 resume_temporary_allocation ();
12146 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12147 int lowprec
= min_precision (minnode
, unsignedp
);
12148 int highprec
= min_precision (maxnode
, unsignedp
);
12149 int precision
= MAX (lowprec
, highprec
);
12151 TYPE_SIZE (enumtype
) = NULL_TREE
;
12153 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12155 TYPE_PRECISION (enumtype
) = precision
;
12157 fixup_unsigned_type (enumtype
);
12159 fixup_signed_type (enumtype
);
12161 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
12162 /* Use the width of the narrowest normal C type which is wide enough. */
12163 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
12166 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
12168 TYPE_SIZE (enumtype
) = 0;
12169 layout_type (enumtype
);
12175 /* Fix up all variant types of this enum type. */
12176 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
12177 tem
= TYPE_NEXT_VARIANT (tem
))
12179 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
12180 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
12181 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
12182 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
12183 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
12184 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
12185 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
12186 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
12187 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
12191 /* Finish debugging output for this type. */
12192 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12197 /* Build and install a CONST_DECL for an enumeration constant of the
12198 enumeration type TYPE whose NAME and VALUE (if any) are provided.
12199 Assignment of sequential values by default is handled here. */
12202 build_enumerator (name
, value
, type
)
12210 /* Remove no-op casts from the value. */
12212 STRIP_TYPE_NOPS (value
);
12214 if (! processing_template_decl
)
12216 /* Validate and default VALUE. */
12217 if (value
!= NULL_TREE
)
12219 if (TREE_READONLY_DECL_P (value
))
12220 value
= decl_constant_value (value
);
12222 if (TREE_CODE (value
) == INTEGER_CST
)
12224 value
= default_conversion (value
);
12225 constant_expression_warning (value
);
12229 cp_error ("enumerator value for `%D' not integer constant", name
);
12234 /* Default based on previous value. */
12235 if (value
== NULL_TREE
&& ! processing_template_decl
)
12237 value
= enum_next_value
;
12239 cp_error ("overflow in enumeration values at `%D'", name
);
12242 /* Remove no-op casts from the value. */
12244 STRIP_TYPE_NOPS (value
);
12246 /* To fix MAX_VAL enum consts. (bkoz) */
12247 TREE_TYPE (value
) = integer_type_node
;
12251 /* We always have to copy here; not all INTEGER_CSTs are unshared.
12252 Even in other cases, we will later (in finish_enum) be setting the
12254 if (value
!= NULL_TREE
)
12255 value
= copy_node (value
);
12257 /* C++ associates enums with global, function, or class declarations. */
12259 context
= current_scope ();
12260 if (context
&& context
== current_class_type
)
12261 /* This enum declaration is local to the class. */
12262 decl
= build_lang_field_decl (CONST_DECL
, name
, type
);
12264 /* It's a global enum, or it's local to a function. (Note local to
12265 a function could mean local to a class method. */
12266 decl
= build_decl (CONST_DECL
, name
, type
);
12268 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
12269 DECL_INITIAL (decl
) = value
;
12270 TREE_READONLY (decl
) = 1;
12272 if (context
&& context
== current_class_type
)
12274 pushdecl_class_level (decl
);
12275 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12276 on the TYPE_FIELDS list for `S'. (That's so that you can say
12277 things like `S::i' later.) */
12278 finish_member_declaration (decl
);
12283 GNU_xref_decl (current_function_decl
, decl
);
12286 if (! processing_template_decl
)
12288 /* Set basis for default for next value. */
12289 enum_next_value
= build_binary_op_nodefault (PLUS_EXPR
, value
,
12290 integer_one_node
, PLUS_EXPR
);
12291 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
12294 result
= saveable_tree_cons (name
, decl
, NULL_TREE
);
12299 static int function_depth
;
12301 /* Create the FUNCTION_DECL for a function definition.
12302 DECLSPECS and DECLARATOR are the parts of the declaration;
12303 they describe the function's name and the type it returns,
12304 but twisted together in a fashion that parallels the syntax of C.
12306 This function creates a binding context for the function body
12307 as well as setting up the FUNCTION_DECL in current_function_decl.
12309 Returns 1 on success. If the DECLARATOR is not suitable for a function
12310 (it defines a datum instead), we return 0, which tells
12311 yyparse to report a parse error.
12313 For C++, we must first check whether that datum makes any sense.
12314 For example, "class A local_a(1,2);" means that variable local_a
12315 is an aggregate of type A, which should have a constructor
12316 applied to it with the argument list [1, 2].
12318 @@ There is currently no way to retrieve the storage
12319 @@ allocated to FUNCTION (or all of its parms) if we return
12320 @@ something we had previously. */
12323 start_function (declspecs
, declarator
, attrs
, pre_parsed_p
)
12324 tree declspecs
, declarator
, attrs
;
12328 tree ctype
= NULL_TREE
;
12331 extern int have_extern_spec
;
12332 extern int used_extern_spec
;
12333 int doing_friend
= 0;
12335 /* Sanity check. */
12336 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
12337 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
12339 /* Assume, until we see it does. */
12340 current_function_returns_value
= 0;
12341 current_function_returns_null
= 0;
12342 warn_about_return_type
= 0;
12344 shadowed_labels
= 0;
12345 current_function_assigns_this
= 0;
12346 current_function_just_assigned_this
= 0;
12347 current_function_parms_stored
= 0;
12348 original_result_rtx
= NULL_RTX
;
12349 base_init_expr
= NULL_TREE
;
12350 current_base_init_list
= NULL_TREE
;
12351 current_member_init_list
= NULL_TREE
;
12352 ctor_label
= dtor_label
= NULL_TREE
;
12353 static_labelno
= 0;
12355 clear_temp_name ();
12357 /* This should only be done once on the top most decl. */
12358 if (have_extern_spec
&& !used_extern_spec
)
12360 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
12361 used_extern_spec
= 1;
12366 decl1
= declarator
;
12369 /* What was this testing for, exactly? */
12370 if (! DECL_ARGUMENTS (decl1
)
12371 && !DECL_STATIC_FUNCTION_P (decl1
)
12372 && !DECL_ARTIFICIAL (decl1
)
12373 && DECL_CLASS_SCOPE_P (decl1
)
12374 && TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))
12375 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))))
12377 tree binding
= binding_for_name (DECL_NAME (decl1
),
12378 current_namespace
);
12379 cp_error ("redeclaration of `%#D'", decl1
);
12380 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)))
12381 cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)));
12382 else if (BINDING_VALUE (binding
))
12383 cp_error_at ("previous declaration here", BINDING_VALUE (binding
));
12387 fntype
= TREE_TYPE (decl1
);
12388 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12389 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12391 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
12392 class is in the (lexical) scope of the class in which it is
12394 if (!ctype
&& DECL_FRIEND_P (decl1
))
12396 ctype
= DECL_CLASS_CONTEXT (decl1
);
12398 /* CTYPE could be null here if we're dealing with a template;
12399 for example, `inline friend float foo()' inside a template
12400 will have no CTYPE set. */
12401 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
12407 /* In a fcn definition, arg types must be complete. */
12408 require_complete_types_for_parms (DECL_ARGUMENTS (decl1
));
12410 /* In case some arg types were completed since the declaration was
12411 parsed, fix up the decls. */
12413 tree t
= DECL_ARGUMENTS (decl1
);
12414 for (; t
; t
= TREE_CHAIN (t
))
12415 layout_decl (t
, 0);
12418 last_function_parms
= DECL_ARGUMENTS (decl1
);
12419 last_function_parm_tags
= NULL_TREE
;
12423 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
12424 /* If the declarator is not suitable for a function definition,
12425 cause a syntax error. */
12426 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
12428 fntype
= TREE_TYPE (decl1
);
12430 restype
= TREE_TYPE (fntype
);
12431 if (IS_AGGR_TYPE (restype
) && ! TYPE_PTRMEMFUNC_P (restype
)
12432 && ! CLASSTYPE_GOT_SEMICOLON (restype
))
12434 cp_error ("semicolon missing after declaration of `%#T'", restype
);
12435 shadow_tag (build_expr_list (NULL_TREE
, restype
));
12436 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
12437 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
12438 fntype
= build_function_type (integer_type_node
,
12439 TYPE_ARG_TYPES (fntype
));
12441 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
12443 TYPE_ARG_TYPES (fntype
));
12444 TREE_TYPE (decl1
) = fntype
;
12447 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12448 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12449 else if (DECL_MAIN_P (decl1
))
12451 /* If this doesn't return integer_type, complain. */
12452 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
12454 if (pedantic
|| warn_return_type
)
12455 pedwarn ("return type for `main' changed to `int'");
12456 TREE_TYPE (decl1
) = fntype
= default_function_type
;
12458 warn_about_return_type
= 0;
12462 /* Warn if function was previously implicitly declared
12463 (but not if we warned then). */
12464 if (! warn_implicit
12465 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
12466 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
12468 current_function_decl
= decl1
;
12469 /* Save the parm names or decls from this function's declarator
12470 where store_parm_decls will find them. */
12471 current_function_parms
= last_function_parms
;
12472 current_function_parm_tags
= last_function_parm_tags
;
12474 announce_function (decl1
);
12476 if (! processing_template_decl
)
12478 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype
))) == NULL_TREE
)
12480 cp_error ("return-type `%#T' is an incomplete type",
12481 TREE_TYPE (fntype
));
12483 /* Make it return void instead, but don't change the
12484 type of the DECL_RESULT, in case we have a named return value. */
12487 = build_cplus_method_type (build_type_variant (ctype
,
12488 TREE_READONLY (decl1
),
12489 TREE_SIDE_EFFECTS (decl1
)),
12491 FUNCTION_ARG_CHAIN (decl1
));
12494 = build_function_type (void_type_node
,
12495 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
12496 DECL_RESULT (decl1
)
12497 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype
)));
12498 TREE_READONLY (DECL_RESULT (decl1
))
12499 = CP_TYPE_CONST_P (TREE_TYPE (fntype
));
12500 TREE_THIS_VOLATILE (DECL_RESULT (decl1
))
12501 = CP_TYPE_VOLATILE_P (TREE_TYPE (fntype
));
12504 if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype
))
12505 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype
)))
12506 abstract_virtuals_error (decl1
, TREE_TYPE (fntype
));
12509 if (warn_about_return_type
)
12510 pedwarn ("return-type defaults to `int'");
12512 /* Effective C++ rule 15. See also c_expand_return. */
12514 && DECL_NAME (decl1
) == ansi_opname
[(int) MODIFY_EXPR
]
12515 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
12516 cp_warning ("`operator=' should return a reference to `*this'");
12518 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
12519 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
12522 /* This function exists in static storage.
12523 (This does not mean `static' in the C sense!) */
12524 TREE_STATIC (decl1
) = 1;
12526 /* Set up current_class_type, and enter the scope of the class, if
12529 push_nested_class (ctype
, 1);
12530 else if (DECL_STATIC_FUNCTION_P (decl1
))
12531 push_nested_class (DECL_CONTEXT (decl1
), 2);
12533 /* We must call push_template_decl after current_class_type is set
12534 up. (If we are processing inline definitions after exiting a
12535 class scope, current_class_type will be NULL_TREE until set above
12536 by push_nested_class.) */
12537 if (processing_template_decl
)
12538 decl1
= push_template_decl (decl1
);
12540 /* Record the decl so that the function name is defined.
12541 If we already have a decl for this name, and it is a FUNCTION_DECL,
12542 use the old decl. */
12543 if (!processing_template_decl
&& pre_parsed_p
== 0)
12545 /* A specialization is not used to guide overload resolution. */
12546 if ((flag_guiding_decls
12547 || !DECL_TEMPLATE_SPECIALIZATION (decl1
))
12548 && ! DECL_FUNCTION_MEMBER_P (decl1
))
12549 decl1
= pushdecl (decl1
);
12552 /* We need to set the DECL_CONTEXT. */
12553 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
12554 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
12555 /* And make sure we have enough default args. */
12556 check_default_args (decl1
);
12558 DECL_MAIN_VARIANT (decl1
) = decl1
;
12559 fntype
= TREE_TYPE (decl1
);
12562 current_function_decl
= decl1
;
12564 if (DECL_INTERFACE_KNOWN (decl1
))
12566 tree ctx
= hack_decl_function_context (decl1
);
12568 if (DECL_NOT_REALLY_EXTERN (decl1
))
12569 DECL_EXTERNAL (decl1
) = 0;
12571 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
12572 && TREE_PUBLIC (ctx
))
12573 /* This is a function in a local class in an extern inline
12575 comdat_linkage (decl1
);
12577 /* If this function belongs to an interface, it is public.
12578 If it belongs to someone else's interface, it is also external.
12579 It doesn't matter whether it's inline or not. */
12580 else if (interface_unknown
== 0
12581 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
12582 || flag_alt_external_templates
))
12584 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
12585 || processing_template_decl
)
12586 DECL_EXTERNAL (decl1
)
12588 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
));
12590 DECL_EXTERNAL (decl1
) = 0;
12591 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
12592 DECL_INTERFACE_KNOWN (decl1
) = 1;
12596 /* This is a definition, not a reference.
12597 So clear DECL_EXTERNAL. */
12598 DECL_EXTERNAL (decl1
) = 0;
12600 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
12601 && ! DECL_INTERFACE_KNOWN (decl1
)
12602 /* Don't try to defer nested functions for now. */
12603 && ! hack_decl_function_context (decl1
))
12604 DECL_DEFER_OUTPUT (decl1
) = 1;
12606 DECL_INTERFACE_KNOWN (decl1
) = 1;
12609 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
))
12611 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12612 TREE_TYPE (decl1
) = fntype
12613 = build_function_type (TREE_TYPE (fntype
),
12614 TREE_CHAIN (TYPE_ARG_TYPES (fntype
)));
12615 current_function_parms
= TREE_CHAIN (current_function_parms
);
12616 DECL_ARGUMENTS (decl1
) = current_function_parms
;
12619 restype
= TREE_TYPE (fntype
);
12623 /* If we're compiling a friend function, neither of the variables
12624 current_class_ptr nor current_class_type will have values. */
12625 if (! doing_friend
)
12627 /* We know that this was set up by `grokclassfn'.
12628 We do not wait until `store_parm_decls', since evil
12629 parse errors may never get us to that point. Here
12630 we keep the consistency between `current_class_type'
12631 and `current_class_ptr'. */
12632 tree t
= current_function_parms
;
12634 my_friendly_assert (t
!= NULL_TREE
12635 && TREE_CODE (t
) == PARM_DECL
, 162);
12637 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
12639 int i
= suspend_momentary ();
12641 /* Fool build_indirect_ref. */
12642 current_class_ptr
= NULL_TREE
;
12643 current_class_ref
= build_indirect_ref (t
, NULL_PTR
);
12644 current_class_ptr
= t
;
12645 resume_momentary (i
);
12648 /* We're having a signature pointer here. */
12649 current_class_ref
= current_class_ptr
= t
;
12655 current_class_ptr
= current_class_ref
= NULL_TREE
;
12659 current_binding_level
->parm_flag
= 1;
12661 GNU_xref_function (decl1
, current_function_parms
);
12664 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
12666 make_function_rtl (decl1
);
12668 /* Promote the value to int before returning it. */
12669 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
12670 restype
= type_promotes_to (restype
);
12672 /* If this fcn was already referenced via a block-scope `extern' decl
12673 (or an implicit decl), propagate certain information about the usage. */
12674 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
12675 TREE_ADDRESSABLE (decl1
) = 1;
12677 if (DECL_RESULT (decl1
) == NULL_TREE
)
12679 DECL_RESULT (decl1
)
12680 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
12681 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
12682 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
12685 /* Allocate further tree nodes temporarily during compilation
12686 of this function only. Tiemann moved up here from bottom of fn. */
12687 /* If this is a nested function, then we must continue to allocate RTL
12688 on the permanent obstack in case we need to inline it later. */
12689 if (! hack_decl_function_context (decl1
))
12690 temporary_allocation ();
12692 if (processing_template_decl
)
12694 ++minimal_parse_mode
;
12695 last_tree
= DECL_SAVED_TREE (decl1
)
12696 = build_nt (EXPR_STMT
, void_zero_node
);
12701 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1
))
12702 && DECL_LANGUAGE (decl1
) == lang_cplusplus
)
12704 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12705 ctor_label
= NULL_TREE
;
12709 dtor_label
= NULL_TREE
;
12710 if (DECL_CONSTRUCTOR_P (decl1
))
12711 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12717 /* Called after store_parm_decls for a function-try-block. We need to update
12718 last_parm_cleanup_insn so that the base initializers for a constructor
12719 are run within this block, not before it. */
12722 expand_start_early_try_stmts ()
12724 expand_start_try_stmts ();
12725 last_parm_cleanup_insn
= get_last_insn ();
12728 /* Store the parameter declarations into the current function declaration.
12729 This is called after parsing the parameter declarations, before
12730 digesting the body of the function.
12732 Also install to binding contour return value identifier, if any. */
12735 store_parm_decls ()
12737 register tree fndecl
= current_function_decl
;
12738 register tree parm
;
12739 int parms_have_cleanups
= 0;
12740 tree cleanups
= NULL_TREE
;
12742 /* This is either a chain of PARM_DECLs (when a prototype is used). */
12743 tree specparms
= current_function_parms
;
12745 /* This is a list of types declared among parms in a prototype. */
12746 tree parmtags
= current_function_parm_tags
;
12748 /* This is a chain of any other decls that came in among the parm
12749 declarations. If a parm is declared with enum {foo, bar} x;
12750 then CONST_DECLs for foo and bar are put here. */
12751 tree nonparms
= NULL_TREE
;
12753 if (toplevel_bindings_p ())
12754 fatal ("parse errors have confused me too much");
12756 /* Initialize RTL machinery. */
12757 init_function_start (fndecl
, input_filename
, lineno
);
12759 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
12760 declare_function_name ();
12762 /* Create a binding level for the parms. */
12763 expand_start_bindings (0);
12765 if (specparms
!= NULL_TREE
)
12767 /* This case is when the function was defined with an ANSI prototype.
12768 The parms already have decls, so we need not do anything here
12769 except record them as in effect
12770 and complain if any redundant old-style parm decls were written. */
12772 register tree next
;
12774 /* Must clear this because it might contain TYPE_DECLs declared
12776 storedecls (NULL_TREE
);
12778 for (parm
= nreverse (specparms
); parm
; parm
= next
)
12780 next
= TREE_CHAIN (parm
);
12781 if (TREE_CODE (parm
) == PARM_DECL
)
12784 if (DECL_NAME (parm
) == NULL_TREE
)
12788 else if (TREE_CODE (TREE_TYPE (parm
)) == VOID_TYPE
)
12789 cp_error ("parameter `%D' declared void", parm
);
12792 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
12793 A parameter is assumed not to have any side effects.
12794 If this should change for any reason, then this
12795 will have to wrap the bashed reference type in a save_expr.
12797 Also, if the parameter type is declared to be an X
12798 and there is an X(X&) constructor, we cannot lay it
12799 into the stack (any more), so we make this parameter
12800 look like it is really of reference type. Functions
12801 which pass parameters to this function will know to
12802 create a temporary in their frame, and pass a reference
12805 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
12806 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))))
12807 SET_DECL_REFERENCE_SLOT (parm
, convert_from_reference (parm
));
12811 if (! processing_template_decl
12812 && (cleanup
= maybe_build_cleanup (parm
), cleanup
))
12814 expand_decl (parm
);
12815 parms_have_cleanups
= 1;
12817 /* Keep track of the cleanups. */
12818 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
12823 /* If we find an enum constant or a type tag,
12824 put it aside for the moment. */
12825 TREE_CHAIN (parm
) = NULL_TREE
;
12826 nonparms
= chainon (nonparms
, parm
);
12830 /* Get the decls in their original chain order
12831 and record in the function. This is all and only the
12832 PARM_DECLs that were pushed into scope by the loop above. */
12833 DECL_ARGUMENTS (fndecl
) = getdecls ();
12835 storetags (chainon (parmtags
, gettags ()));
12838 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
12840 /* Now store the final chain of decls for the arguments
12841 as the decl-chain of the current lexical scope.
12842 Put the enumerators in as well, at the front so that
12843 DECL_ARGUMENTS is not modified. */
12845 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
12847 /* Initialize the RTL code for the function. */
12848 DECL_SAVED_INSNS (fndecl
) = NULL_RTX
;
12849 if (! processing_template_decl
)
12850 expand_function_start (fndecl
, parms_have_cleanups
);
12852 current_function_parms_stored
= 1;
12854 /* If this function is `main', emit a call to `__main'
12855 to run global initializers, etc. */
12856 if (DECL_MAIN_P (fndecl
))
12857 expand_main_function ();
12859 /* Now that we have initialized the parms, we can start their
12860 cleanups. We cannot do this before, since expand_decl_cleanup
12861 should not be called before the parm can be used. */
12863 && ! processing_template_decl
)
12865 for (cleanups
= nreverse (cleanups
); cleanups
; cleanups
= TREE_CHAIN (cleanups
))
12867 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups
), TREE_VALUE (cleanups
)))
12868 cp_error ("parser lost in parsing declaration of `%D'",
12869 TREE_PURPOSE (cleanups
));
12873 /* Create a binding contour which can be used to catch
12874 cleanup-generated temporaries. Also, if the return value needs or
12875 has initialization, deal with that now. */
12876 if (parms_have_cleanups
)
12879 expand_start_bindings (0);
12882 if (! processing_template_decl
&& flag_exceptions
)
12884 /* Do the starting of the exception specifications, if we have any. */
12885 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
12886 expand_start_eh_spec ();
12889 last_parm_cleanup_insn
= get_last_insn ();
12890 last_dtor_insn
= get_last_insn ();
12893 /* Bind a name and initialization to the return value of
12894 the current function. */
12897 store_return_init (return_id
, init
)
12898 tree return_id
, init
;
12900 tree decl
= DECL_RESULT (current_function_decl
);
12903 /* Give this error as many times as there are occurrences,
12904 so that users can use Emacs compilation buffers to find
12905 and fix all such places. */
12906 pedwarn ("ANSI C++ does not permit named return values");
12908 if (return_id
!= NULL_TREE
)
12910 if (DECL_NAME (decl
) == NULL_TREE
)
12912 DECL_NAME (decl
) = return_id
;
12913 DECL_ASSEMBLER_NAME (decl
) = return_id
;
12916 cp_error ("return identifier `%D' already in place", decl
);
12919 /* Can't let this happen for constructors. */
12920 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12922 error ("can't redefine default return value for constructors");
12926 /* If we have a named return value, put that in our scope as well. */
12927 if (DECL_NAME (decl
) != NULL_TREE
)
12929 /* If this named return value comes in a register,
12930 put it in a pseudo-register. */
12931 if (DECL_REGISTER (decl
))
12933 original_result_rtx
= DECL_RTL (decl
);
12934 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
12937 /* Let `cp_finish_decl' know that this initializer is ok. */
12938 DECL_INITIAL (decl
) = init
;
12941 if (minimal_parse_mode
)
12942 add_tree (build_min_nt (RETURN_INIT
, return_id
,
12943 copy_to_permanent (init
)));
12945 cp_finish_decl (decl
, init
, NULL_TREE
, 0, 0);
12950 /* Finish up a function declaration and compile that function
12951 all the way to assembler language output. The free the storage
12952 for the function definition.
12954 This is called after parsing the body of the function definition.
12955 LINENO is the current line number.
12957 C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
12958 (and expand_end_bindings) must be made to take care of the binding
12959 contour for the base initializers. This is only relevant for
12962 NESTED is nonzero if we were in the middle of compiling another function
12963 when we started on this one. */
12966 finish_function (lineno
, call_poplevel
, nested
)
12971 register tree fndecl
= current_function_decl
;
12972 tree fntype
, ctype
= NULL_TREE
;
12973 rtx last_parm_insn
, insns
;
12974 /* Label to use if this function is supposed to return a value. */
12975 tree no_return_label
= NULL_TREE
;
12976 tree decls
= NULL_TREE
;
12978 /* When we get some parse errors, we can end up without a
12979 current_function_decl, so cope. */
12980 if (fndecl
== NULL_TREE
)
12983 if (! nested
&& function_depth
> 1)
12986 fntype
= TREE_TYPE (fndecl
);
12988 /* TREE_READONLY (fndecl) = 1;
12989 This caused &foo to be of type ptr-to-const-function
12990 which then got a warning when stored in a ptr-to-function variable. */
12992 /* This happens on strange parse errors. */
12993 if (! current_function_parms_stored
)
12996 store_parm_decls ();
12999 if (processing_template_decl
)
13001 if (DECL_CONSTRUCTOR_P (fndecl
) && call_poplevel
)
13003 decls
= getdecls ();
13004 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13005 poplevel (decls
!= NULL_TREE
, 0, 0);
13010 if (write_symbols
!= NO_DEBUG
/*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13012 tree ttype
= target_type (fntype
);
13015 if (IS_AGGR_TYPE (ttype
))
13016 /* Let debugger know it should output info for this type. */
13017 note_debug_info_needed (ttype
);
13019 for (parmdecl
= DECL_ARGUMENTS (fndecl
); parmdecl
; parmdecl
= TREE_CHAIN (parmdecl
))
13021 ttype
= target_type (TREE_TYPE (parmdecl
));
13022 if (IS_AGGR_TYPE (ttype
))
13023 /* Let debugger know it should output info for this type. */
13024 note_debug_info_needed (ttype
);
13028 /* Clean house because we will need to reorder insns here. */
13029 do_pending_stack_adjust ();
13033 tree binfo
= TYPE_BINFO (current_class_type
);
13034 tree cond
= integer_one_node
;
13036 tree in_charge_node
= lookup_name (in_charge_identifier
, 0);
13038 int ok_to_optimize_dtor
= 0;
13039 int empty_dtor
= get_last_insn () == last_dtor_insn
;
13041 if (current_function_assigns_this
)
13042 cond
= build (NE_EXPR
, boolean_type_node
,
13043 current_class_ptr
, integer_zero_node
);
13046 int n_baseclasses
= CLASSTYPE_N_BASECLASSES (current_class_type
);
13048 /* If this destructor is empty, then we don't need to check
13049 whether `this' is NULL in some cases. */
13050 if ((flag_this_is_variable
& 1) == 0)
13051 ok_to_optimize_dtor
= 1;
13052 else if (empty_dtor
)
13053 ok_to_optimize_dtor
13054 = (n_baseclasses
== 0
13055 || (n_baseclasses
== 1
13056 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type
, 0))));
13059 /* These initializations might go inline. Protect
13060 the binding level of the parms. */
13062 expand_start_bindings (0);
13064 if (current_function_assigns_this
)
13066 current_function_assigns_this
= 0;
13067 current_function_just_assigned_this
= 0;
13070 /* Generate the code to call destructor on base class.
13071 If this destructor belongs to a class with virtual
13072 functions, then set the virtual function table
13073 pointer to represent the type of our base class. */
13075 /* This side-effect makes call to `build_delete' generate the
13076 code we have to have at the end of this destructor. */
13077 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
13079 /* These are two cases where we cannot delegate deletion. */
13080 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)
13081 || TYPE_GETS_REG_DELETE (current_class_type
))
13082 exprstmt
= build_delete (current_class_type
, current_class_ref
, integer_zero_node
,
13083 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13085 exprstmt
= build_delete (current_class_type
, current_class_ref
, in_charge_node
,
13086 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13088 /* If we did not assign to this, then `this' is non-zero at
13089 the end of a destructor. As a special optimization, don't
13090 emit test if this is an empty destructor. If it does nothing,
13091 it does nothing. If it calls a base destructor, the base
13092 destructor will perform the test. */
13094 if (exprstmt
!= error_mark_node
13095 && (TREE_CODE (exprstmt
) != NOP_EXPR
13096 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
13097 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
13099 expand_label (dtor_label
);
13100 if (cond
!= integer_one_node
)
13101 expand_start_cond (cond
, 0);
13102 if (exprstmt
!= void_zero_node
)
13103 /* Don't call `expand_expr_stmt' if we're not going to do
13104 anything, since -Wall will give a diagnostic. */
13105 expand_expr_stmt (exprstmt
);
13107 /* Run destructor on all virtual baseclasses. */
13108 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13110 tree vbases
= nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type
)));
13111 expand_start_cond (build (BIT_AND_EXPR
, integer_type_node
,
13112 in_charge_node
, integer_two_node
), 0);
13115 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases
)))
13117 tree vb
= get_vbase
13118 (BINFO_TYPE (vbases
),
13119 TYPE_BINFO (current_class_type
));
13121 (build_scoped_method_call
13122 (current_class_ref
, vb
, dtor_identifier
,
13123 build_expr_list (NULL_TREE
, integer_zero_node
)));
13125 vbases
= TREE_CHAIN (vbases
);
13127 expand_end_cond ();
13130 do_pending_stack_adjust ();
13131 if (cond
!= integer_one_node
)
13132 expand_end_cond ();
13135 TYPE_HAS_DESTRUCTOR (current_class_type
) = 1;
13137 virtual_size
= c_sizeof (current_class_type
);
13139 /* At the end, call delete if that's what's requested. */
13141 /* FDIS sez: At the point of definition of a virtual destructor
13142 (including an implicit definition), non-placement operator
13143 delete shall be looked up in the scope of the destructor's
13144 class and if found shall be accessible and unambiguous.
13146 This is somewhat unclear, but I take it to mean that if the
13147 class only defines placement deletes we don't do anything here.
13148 So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain
13149 for us if they ever try to delete one of these. */
13151 if (TYPE_GETS_REG_DELETE (current_class_type
)
13152 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13153 exprstmt
= build_op_delete_call
13154 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
13155 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
13157 exprstmt
= NULL_TREE
;
13161 cond
= build (BIT_AND_EXPR
, integer_type_node
,
13162 in_charge_node
, integer_one_node
);
13163 expand_start_cond (cond
, 0);
13164 expand_expr_stmt (exprstmt
);
13165 expand_end_cond ();
13168 /* End of destructor. */
13169 expand_end_bindings (NULL_TREE
, getdecls () != NULL_TREE
, 0);
13170 poplevel (2, 0, 0); /* XXX change to 1 */
13172 /* Back to the top of destructor. */
13173 /* Don't execute destructor code if `this' is NULL. */
13177 /* If the dtor is empty, and we know there is not possible way we
13178 could use any vtable entries, before they are possibly set by
13179 a base class dtor, we don't have to setup the vtables, as we
13180 know that any base class dtoring will set up any vtables it
13181 needs. We avoid MI, because one base class dtor can do a
13182 virtual dispatch to an overridden function that would need to
13183 have a non-related vtable set up, we cannot avoid setting up
13184 vtables in that case. We could change this to see if there is
13185 just one vtable. */
13186 if (! empty_dtor
|| TYPE_USES_COMPLEX_INHERITANCE (current_class_type
))
13188 /* Make all virtual function table pointers in non-virtual base
13189 classes point to CURRENT_CLASS_TYPE's virtual function
13191 expand_direct_vtbls_init (binfo
, binfo
, 1, 0, current_class_ptr
);
13193 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13194 expand_indirect_vtbls_init (binfo
, current_class_ref
, current_class_ptr
);
13197 if (! ok_to_optimize_dtor
)
13199 cond
= build_binary_op (NE_EXPR
,
13200 current_class_ptr
, integer_zero_node
, 1);
13201 expand_start_cond (cond
, 0);
13204 insns
= get_insns ();
13207 last_parm_insn
= get_first_nonparm_insn ();
13208 if (last_parm_insn
== NULL_RTX
)
13209 last_parm_insn
= get_last_insn ();
13211 last_parm_insn
= previous_insn (last_parm_insn
);
13213 emit_insns_after (insns
, last_parm_insn
);
13215 if (! ok_to_optimize_dtor
)
13216 expand_end_cond ();
13218 else if (current_function_assigns_this
)
13220 /* Does not need to call emit_base_init, because
13221 that is done (if needed) just after assignment to this
13224 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13226 end_protect_partials ();
13227 expand_label (ctor_label
);
13228 ctor_label
= NULL_TREE
;
13232 decls
= getdecls ();
13233 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13234 poplevel (decls
!= NULL_TREE
, 0, 0);
13236 /* c_expand_return knows to return 'this' from a constructor. */
13237 c_expand_return (NULL_TREE
);
13239 else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl
))) != VOID_TYPE
13240 && return_label
!= NULL_RTX
)
13241 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13243 current_function_assigns_this
= 0;
13244 current_function_just_assigned_this
= 0;
13245 base_init_expr
= NULL_TREE
;
13247 else if (DECL_CONSTRUCTOR_P (fndecl
))
13249 tree cond
= NULL_TREE
, thenclause
= NULL_TREE
;
13250 /* Allow constructor for a type to get a new instance of the object
13251 using `build_new'. */
13252 tree abstract_virtuals
= CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
);
13253 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = NULL_TREE
;
13255 DECL_RETURNS_FIRST_ARG (fndecl
) = 1;
13257 if (flag_this_is_variable
> 0)
13259 cond
= build_binary_op (EQ_EXPR
,
13260 current_class_ptr
, integer_zero_node
, 1);
13261 thenclause
= build_modify_expr (current_class_ptr
, NOP_EXPR
,
13262 build_new (NULL_TREE
, current_class_type
, void_type_node
, 0));
13265 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = abstract_virtuals
;
13269 if (flag_this_is_variable
> 0)
13271 expand_start_cond (cond
, 0);
13272 expand_expr_stmt (thenclause
);
13273 expand_end_cond ();
13276 /* Emit insns from `emit_base_init' which sets up virtual
13277 function table pointer(s). */
13278 if (base_init_expr
)
13280 expand_expr_stmt (base_init_expr
);
13281 base_init_expr
= NULL_TREE
;
13284 insns
= get_insns ();
13287 /* This is where the body of the constructor begins. */
13289 emit_insns_after (insns
, last_parm_cleanup_insn
);
13291 end_protect_partials ();
13293 /* This is where the body of the constructor ends. */
13294 expand_label (ctor_label
);
13295 ctor_label
= NULL_TREE
;
13299 decls
= getdecls ();
13300 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13301 poplevel (decls
!= NULL_TREE
, 1, 0);
13304 /* c_expand_return knows to return 'this' from a constructor. */
13305 c_expand_return (NULL_TREE
);
13307 current_function_assigns_this
= 0;
13308 current_function_just_assigned_this
= 0;
13310 else if (DECL_MAIN_P (fndecl
))
13312 /* Make it so that `main' always returns 0 by default. */
13314 c_expand_return (integer_one_node
);
13316 c_expand_return (integer_zero_node
);
13319 else if (return_label
!= NULL_RTX
13320 && current_function_return_value
== NULL_TREE
13321 && ! DECL_NAME (DECL_RESULT (current_function_decl
)))
13322 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13324 if (flag_exceptions
)
13325 expand_exception_blocks ();
13327 /* If this function is supposed to return a value, ensure that
13328 we do not fall into the cleanups by mistake. The end of our
13329 function will look like this:
13331 user code (may have return stmt somewhere)
13332 goto no_return_label
13337 NOTE_INSN_FUNCTION_END
13341 If the user omits a return stmt in the USER CODE section, we
13342 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13343 Otherwise, we won't. */
13344 if (no_return_label
)
13346 DECL_CONTEXT (no_return_label
) = fndecl
;
13347 DECL_INITIAL (no_return_label
) = error_mark_node
;
13348 DECL_SOURCE_FILE (no_return_label
) = input_filename
;
13349 DECL_SOURCE_LINE (no_return_label
) = lineno
;
13350 expand_goto (no_return_label
);
13355 /* Remove the binding contour which is used
13356 to catch cleanup-generated temporaries. */
13357 expand_end_bindings (0, 0, 0);
13358 poplevel (0, 0, 0);
13360 /* Emit label at beginning of cleanup code for parameters. */
13361 emit_label (cleanup_label
);
13364 /* Get return value into register if that's where it's supposed to be. */
13365 if (original_result_rtx
)
13366 fixup_result_decl (DECL_RESULT (fndecl
), original_result_rtx
);
13368 /* Finish building code that will trigger warnings if users forget
13369 to make their functions return values. */
13370 if (no_return_label
|| cleanup_label
)
13371 emit_jump (return_label
);
13372 if (no_return_label
)
13374 /* We don't need to call `expand_*_return' here because we
13375 don't need any cleanups here--this path of code is only
13376 for error checking purposes. */
13377 expand_label (no_return_label
);
13380 /* Generate rtl for function exit. */
13381 expand_function_end (input_filename
, lineno
, 1);
13384 /* This must come after expand_function_end because cleanups might
13385 have declarations (from inline functions) that need to go into
13386 this function's blocks. */
13387 if (current_binding_level
->parm_flag
!= 1)
13388 my_friendly_abort (122);
13389 poplevel (1, 0, 1);
13391 /* Reset scope for C++: if we were in the scope of a class,
13392 then when we finish this function, we are not longer so.
13393 This cannot be done until we know for sure that no more
13394 class members will ever be referenced in this function
13395 (i.e., calls to destructors). */
13396 if (current_class_name
)
13398 ctype
= current_class_type
;
13399 pop_nested_class (1);
13402 /* Must mark the RESULT_DECL as being in this function. */
13403 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13405 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13406 to the FUNCTION_DECL node itself. */
13407 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13409 if (! processing_template_decl
)
13411 int saved_flag_keep_inline_functions
=
13412 flag_keep_inline_functions
;
13414 /* So we can tell if jump_optimize sets it to 1. */
13417 if (DECL_CONTEXT (fndecl
) != NULL_TREE
13418 && hack_decl_function_context (fndecl
))
13419 /* Trick rest_of_compilation into not deferring output of this
13420 function, even if it is inline, since the rtl_obstack for
13421 this function is the function_obstack of the enclosing
13422 function and will be deallocated when the enclosing
13423 function is gone. See save_tree_status. */
13424 flag_keep_inline_functions
= 1;
13426 /* Run the optimizers and output the assembler code for this
13429 if (DECL_ARTIFICIAL (fndecl
))
13431 /* Do we really *want* to inline this synthesized method? */
13433 int save_fif
= flag_inline_functions
;
13434 flag_inline_functions
= 1;
13436 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13437 will check our size. */
13438 DECL_INLINE (fndecl
) = 0;
13440 rest_of_compilation (fndecl
);
13441 flag_inline_functions
= save_fif
;
13444 rest_of_compilation (fndecl
);
13446 flag_keep_inline_functions
= saved_flag_keep_inline_functions
;
13448 if (DECL_SAVED_INSNS (fndecl
) && ! TREE_ASM_WRITTEN (fndecl
))
13450 /* Set DECL_EXTERNAL so that assemble_external will be called as
13451 necessary. We'll clear it again in finish_file. */
13452 if (! DECL_EXTERNAL (fndecl
))
13453 DECL_NOT_REALLY_EXTERN (fndecl
) = 1;
13454 DECL_EXTERNAL (fndecl
) = 1;
13455 mark_inline_for_output (fndecl
);
13458 if (ctype
&& TREE_ASM_WRITTEN (fndecl
))
13459 note_debug_info_needed (ctype
);
13461 current_function_returns_null
|= can_reach_end
;
13463 /* Since we don't normally go through c_expand_return for constructors,
13464 this normally gets the wrong value.
13465 Also, named return values have their return codes emitted after
13466 NOTE_INSN_FUNCTION_END, confusing jump.c. */
13467 if (DECL_CONSTRUCTOR_P (fndecl
)
13468 || DECL_NAME (DECL_RESULT (fndecl
)) != NULL_TREE
)
13469 current_function_returns_null
= 0;
13471 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
13472 cp_warning ("`noreturn' function `%D' does return", fndecl
);
13473 else if ((warn_return_type
|| pedantic
)
13474 && current_function_returns_null
13475 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
)
13477 /* If this function returns non-void and control can drop through,
13479 cp_warning ("control reaches end of non-void function `%D'", fndecl
);
13481 /* With just -W, complain only if function returns both with
13482 and without a value. */
13483 else if (extra_warnings
13484 && current_function_returns_value
&& current_function_returns_null
)
13485 warning ("this function may return with or without a value");
13490 /* Free all the tree nodes making up this function. */
13491 /* Switch back to allocating nodes permanently
13492 until we start another function. */
13493 if (processing_template_decl
)
13495 --minimal_parse_mode
;
13496 DECL_SAVED_TREE (fndecl
) = TREE_CHAIN (DECL_SAVED_TREE (fndecl
));
13500 permanent_allocation (1);
13502 if (DECL_SAVED_INSNS (fndecl
) == NULL_RTX
)
13506 /* Stop pointing to the local nodes about to be freed. */
13507 /* But DECL_INITIAL must remain nonzero so we know this
13508 was an actual function definition. */
13509 DECL_INITIAL (fndecl
) = error_mark_node
;
13510 for (t
= DECL_ARGUMENTS (fndecl
); t
; t
= TREE_CHAIN (t
))
13511 DECL_RTL (t
) = DECL_INCOMING_RTL (t
) = NULL_RTX
;
13514 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
13515 static_ctors
= perm_tree_cons (NULL_TREE
, fndecl
, static_ctors
);
13516 if (DECL_STATIC_DESTRUCTOR (fndecl
))
13517 static_dtors
= perm_tree_cons (NULL_TREE
, fndecl
, static_dtors
);
13521 /* Let the error reporting routines know that we're outside a
13522 function. For a nested function, this value is used in
13523 pop_cp_function_context and then reset via pop_function_context. */
13524 current_function_decl
= NULL_TREE
;
13527 named_label_uses
= NULL
;
13528 current_class_ptr
= NULL_TREE
;
13529 current_class_ref
= NULL_TREE
;
13532 /* Create the FUNCTION_DECL for a function definition.
13533 LINE1 is the line number that the definition absolutely begins on.
13534 LINE2 is the line number that the name of the function appears on.
13535 DECLSPECS and DECLARATOR are the parts of the declaration;
13536 they describe the return type and the name of the function,
13537 but twisted together in a fashion that parallels the syntax of C.
13539 This function creates a binding context for the function body
13540 as well as setting up the FUNCTION_DECL in current_function_decl.
13542 Returns a FUNCTION_DECL on success.
13544 If the DECLARATOR is not suitable for a function (it defines a datum
13545 instead), we return 0, which tells yyparse to report a parse error.
13547 May return void_type_node indicating that this method is actually
13548 a friend. See grokfield for more details.
13550 Came here with a `.pushlevel' .
13552 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13553 CHANGES TO CODE IN `grokfield'. */
13556 start_method (declspecs
, declarator
, attrlist
)
13557 tree declarator
, declspecs
, attrlist
;
13559 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
13562 /* Something too ugly to handle. */
13563 if (fndecl
== NULL_TREE
)
13566 /* Pass friends other than inline friend functions back. */
13567 if (fndecl
== void_type_node
)
13570 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
13571 /* Not a function, tell parser to report parse error. */
13574 if (IS_SIGNATURE (current_class_type
))
13575 IS_DEFAULT_IMPLEMENTATION (fndecl
) = 1;
13577 if (DECL_IN_AGGR_P (fndecl
))
13579 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
13581 if (DECL_CONTEXT (fndecl
)
13582 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
13583 cp_error ("`%D' is already defined in class %s", fndecl
,
13584 TYPE_NAME_STRING (DECL_CONTEXT (fndecl
)));
13586 return void_type_node
;
13589 DECL_THIS_INLINE (fndecl
) = 1;
13591 if (flag_default_inline
)
13592 DECL_INLINE (fndecl
) = 1;
13594 /* We process method specializations in finish_struct_1. */
13595 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
13596 fndecl
= push_template_decl (fndecl
);
13598 /* We read in the parameters on the maybepermanent_obstack,
13599 but we won't be getting back to them until after we
13600 may have clobbered them. So the call to preserve_data
13601 will keep them safe. */
13604 if (! DECL_FRIEND_P (fndecl
))
13606 if (TREE_CHAIN (fndecl
))
13608 fndecl
= copy_node (fndecl
);
13609 TREE_CHAIN (fndecl
) = NULL_TREE
;
13612 if (DECL_CONSTRUCTOR_P (fndecl
))
13614 if (! grok_ctor_properties (current_class_type
, fndecl
))
13615 return void_type_node
;
13617 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
13618 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
13621 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0, 0);
13623 /* Make a place for the parms */
13625 current_binding_level
->parm_flag
= 1;
13627 DECL_IN_AGGR_P (fndecl
) = 1;
13631 /* Go through the motions of finishing a function definition.
13632 We don't compile this method until after the whole class has
13635 FINISH_METHOD must return something that looks as though it
13636 came from GROKFIELD (since we are defining a method, after all).
13638 This is called after parsing the body of the function definition.
13639 STMTS is the chain of statements that makes up the function body.
13641 DECL is the ..._DECL that `start_method' provided. */
13644 finish_method (decl
)
13647 register tree fndecl
= decl
;
13650 register tree link
;
13652 if (decl
== void_type_node
)
13655 old_initial
= DECL_INITIAL (fndecl
);
13657 /* Undo the level for the parms (from start_method).
13658 This is like poplevel, but it causes nothing to be
13659 saved. Saving information here confuses symbol-table
13660 output routines. Besides, this information will
13661 be correctly output when this method is actually
13664 /* Clear out the meanings of the local variables of this level;
13665 also record in each decl which block it belongs to. */
13667 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
13669 if (DECL_NAME (link
) != NULL_TREE
)
13670 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = 0;
13671 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
13672 DECL_CONTEXT (link
) = NULL_TREE
;
13675 /* Restore all name-meanings of the outer levels
13676 that were shadowed by this level. */
13678 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
13679 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
13680 for (link
= current_binding_level
->class_shadowed
;
13681 link
; link
= TREE_CHAIN (link
))
13682 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
13683 for (link
= current_binding_level
->type_shadowed
;
13684 link
; link
= TREE_CHAIN (link
))
13685 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
13687 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
13688 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
13689 current_binding_level
->parm_flag
,
13690 current_binding_level
->keep
);
13692 poplevel (0, 0, 0);
13694 DECL_INITIAL (fndecl
) = old_initial
;
13696 /* We used to check if the context of FNDECL was different from
13697 current_class_type as another way to get inside here. This didn't work
13698 for String.cc in libg++. */
13699 if (DECL_FRIEND_P (fndecl
))
13701 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
13702 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
13703 decl
= void_type_node
;
13709 /* Called when a new struct TYPE is defined.
13710 If this structure or union completes the type of any previous
13711 variable declaration, lay it out and output its rtl. */
13714 hack_incomplete_structures (type
)
13719 if (current_binding_level
->incomplete
== NULL_TREE
)
13722 if (!type
) /* Don't do this for class templates. */
13725 for (list
= ¤t_binding_level
->incomplete
; *list
; )
13727 tree decl
= TREE_VALUE (*list
);
13728 if ((decl
&& TREE_TYPE (decl
) == type
)
13729 || (TREE_TYPE (decl
)
13730 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13731 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
13733 int toplevel
= toplevel_bindings_p ();
13734 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13735 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
13736 layout_type (TREE_TYPE (decl
));
13737 layout_decl (decl
, 0);
13738 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
13742 expand_decl (decl
);
13743 cleanup
= maybe_build_cleanup (decl
);
13744 expand_decl_init (decl
);
13745 if (! expand_decl_cleanup (decl
, cleanup
))
13746 cp_error ("parser lost in parsing declaration of `%D'",
13749 *list
= TREE_CHAIN (*list
);
13752 list
= &TREE_CHAIN (*list
);
13756 /* If DECL is of a type which needs a cleanup, build that cleanup here.
13757 See build_delete for information about AUTO_DELETE.
13759 Don't build these on the momentary obstack; they must live
13760 the life of the binding contour. */
13763 maybe_build_cleanup_1 (decl
, auto_delete
)
13764 tree decl
, auto_delete
;
13766 tree type
= TREE_TYPE (decl
);
13767 if (TYPE_NEEDS_DESTRUCTOR (type
))
13769 int temp
= 0, flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
13772 if (TREE_CODE (decl
) != PARM_DECL
)
13773 temp
= suspend_momentary ();
13775 if (TREE_CODE (type
) == ARRAY_TYPE
)
13779 mark_addressable (decl
);
13780 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
13783 /* Optimize for space over speed here. */
13784 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
13785 || flag_expensive_optimizations
)
13786 flags
|= LOOKUP_NONVIRTUAL
;
13788 rval
= build_delete (TREE_TYPE (rval
), rval
, auto_delete
, flags
, 0);
13790 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
13791 && ! TYPE_HAS_DESTRUCTOR (type
))
13792 rval
= build_compound_expr (expr_tree_cons (NULL_TREE
, rval
,
13793 build_expr_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
13795 if (TREE_CODE (decl
) != PARM_DECL
)
13796 resume_momentary (temp
);
13803 /* If DECL is of a type which needs a cleanup, build that cleanup
13804 here. The cleanup does free the storage with a call to delete. */
13807 maybe_build_cleanup_and_delete (decl
)
13810 return maybe_build_cleanup_1 (decl
, integer_three_node
);
13813 /* If DECL is of a type which needs a cleanup, build that cleanup
13814 here. The cleanup does not free the storage with a call a delete. */
13817 maybe_build_cleanup (decl
)
13820 return maybe_build_cleanup_1 (decl
, integer_two_node
);
13823 /* Expand a C++ expression at the statement level.
13824 This is needed to ferret out nodes which have UNKNOWN_TYPE.
13825 The C++ type checker should get all of these out when
13826 expressions are combined with other, type-providing, expressions,
13827 leaving only orphan expressions, such as:
13829 &class::bar; / / takes its address, but does nothing with it. */
13832 cplus_expand_expr_stmt (exp
)
13835 if (processing_template_decl
)
13837 add_tree (build_min_nt (EXPR_STMT
, exp
));
13841 /* Arrange for all temps to disappear. */
13842 expand_start_target_temps ();
13844 if (TREE_TYPE (exp
) == unknown_type_node
)
13846 if (TREE_CODE (exp
) == ADDR_EXPR
|| TREE_CODE (exp
) == TREE_LIST
)
13847 error ("address of overloaded function with no contextual type information");
13848 else if (TREE_CODE (exp
) == COMPONENT_REF
)
13849 warning ("useless reference to a member function name, did you forget the ()?");
13853 if (TREE_CODE (exp
) == FUNCTION_DECL
)
13855 cp_warning ("reference, not call, to function `%D'", exp
);
13856 warning ("at this point in file");
13860 /* We should do this eventually, but right now this causes regex.o from
13861 libg++ to miscompile, and tString to core dump. */
13862 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
13865 /* Strip unused implicit INDIRECT_REFs of references. */
13866 if (TREE_CODE (exp
) == INDIRECT_REF
13867 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
13868 exp
= TREE_OPERAND (exp
, 0);
13870 /* If we don't do this, we end up down inside expand_expr
13871 trying to do TYPE_MODE on the ERROR_MARK, and really
13872 go outside the bounds of the type. */
13873 if (exp
!= error_mark_node
)
13874 expand_expr_stmt (break_out_cleanups (exp
));
13877 /* Clean up any pending cleanups. This happens when a function call
13878 returns a cleanup-needing value that nobody uses. */
13879 expand_end_target_temps ();
13882 /* When a stmt has been parsed, this function is called.
13884 Currently, this function only does something within a
13885 constructor's scope: if a stmt has just assigned to this,
13886 and we are in a derived class, we call `emit_base_init'. */
13891 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
13894 if (current_function_assigns_this
13895 || ! current_function_just_assigned_this
)
13897 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13899 /* Constructors must wait until we are out of control
13900 zones before calling base constructors. */
13901 if (cond_stack
|| loop_stack
|| case_stack
)
13903 expand_expr_stmt (base_init_expr
);
13904 check_base_init (current_class_type
);
13906 current_function_assigns_this
= 1;
13909 /* Change a static member function definition into a FUNCTION_TYPE, instead
13910 of the METHOD_TYPE that we create when it's originally parsed.
13912 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
13913 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
13914 other decls. Either pass the addresses of local variables or NULL. */
13917 revert_static_member_fn (decl
, fn
, argtypes
)
13918 tree
*decl
, *fn
, *argtypes
;
13921 tree function
= fn
? *fn
: TREE_TYPE (*decl
);
13922 tree args
= argtypes
? *argtypes
: TYPE_ARG_TYPES (function
);
13924 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
13925 != TYPE_UNQUALIFIED
)
13926 cp_error ("static member function `%#D' declared with type qualifiers",
13929 args
= TREE_CHAIN (args
);
13930 tmp
= build_function_type (TREE_TYPE (function
), args
);
13931 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
13932 tmp
= build_exception_variant (tmp
,
13933 TYPE_RAISES_EXCEPTIONS (function
));
13934 TREE_TYPE (*decl
) = tmp
;
13935 if (DECL_ARGUMENTS (*decl
))
13936 DECL_ARGUMENTS (*decl
) = TREE_CHAIN (DECL_ARGUMENTS (*decl
));
13937 DECL_STATIC_FUNCTION_P (*decl
) = 1;
13945 id_in_current_class (id
)
13948 return !!purpose_member (id
, class_binding_level
->class_shadowed
);
13955 int warn_about_return_type
;
13957 int just_assigned_this
;
13959 int temp_name_counter
;
13961 tree shadowed_labels
;
13964 rtx last_dtor_insn
;
13965 rtx last_parm_cleanup_insn
;
13966 tree base_init_list
;
13967 tree member_init_list
;
13968 tree base_init_expr
;
13969 tree current_class_ptr
;
13970 tree current_class_ref
;
13972 struct cp_function
*next
;
13973 struct binding_level
*binding_level
;
13974 int static_labelno
;
13977 static struct cp_function
*cp_function_chain
;
13979 extern int temp_name_counter
;
13981 /* Save and reinitialize the variables
13982 used during compilation of a C++ function. */
13985 push_cp_function_context (context
)
13988 struct cp_function
*p
13989 = (struct cp_function
*) xmalloc (sizeof (struct cp_function
));
13991 push_function_context_to (context
);
13993 p
->next
= cp_function_chain
;
13994 cp_function_chain
= p
;
13996 p
->named_labels
= named_labels
;
13997 p
->shadowed_labels
= shadowed_labels
;
13998 p
->returns_value
= current_function_returns_value
;
13999 p
->returns_null
= current_function_returns_null
;
14000 p
->warn_about_return_type
= warn_about_return_type
;
14001 p
->binding_level
= current_binding_level
;
14002 p
->ctor_label
= ctor_label
;
14003 p
->dtor_label
= dtor_label
;
14004 p
->last_dtor_insn
= last_dtor_insn
;
14005 p
->last_parm_cleanup_insn
= last_parm_cleanup_insn
;
14006 p
->assigns_this
= current_function_assigns_this
;
14007 p
->just_assigned_this
= current_function_just_assigned_this
;
14008 p
->parms_stored
= current_function_parms_stored
;
14009 p
->result_rtx
= original_result_rtx
;
14010 p
->base_init_expr
= base_init_expr
;
14011 p
->temp_name_counter
= temp_name_counter
;
14012 p
->base_init_list
= current_base_init_list
;
14013 p
->member_init_list
= current_member_init_list
;
14014 p
->current_class_ptr
= current_class_ptr
;
14015 p
->current_class_ref
= current_class_ref
;
14016 p
->static_labelno
= static_labelno
;
14019 /* Restore the variables used during compilation of a C++ function. */
14022 pop_cp_function_context (context
)
14025 struct cp_function
*p
= cp_function_chain
;
14028 /* Bring back all the labels that were shadowed. */
14029 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
14030 if (DECL_NAME (TREE_VALUE (link
)) != 0)
14031 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)),
14032 TREE_VALUE (link
));
14034 pop_function_context_from (context
);
14036 cp_function_chain
= p
->next
;
14038 named_labels
= p
->named_labels
;
14039 shadowed_labels
= p
->shadowed_labels
;
14040 current_function_returns_value
= p
->returns_value
;
14041 current_function_returns_null
= p
->returns_null
;
14042 warn_about_return_type
= p
->warn_about_return_type
;
14043 current_binding_level
= p
->binding_level
;
14044 ctor_label
= p
->ctor_label
;
14045 dtor_label
= p
->dtor_label
;
14046 last_dtor_insn
= p
->last_dtor_insn
;
14047 last_parm_cleanup_insn
= p
->last_parm_cleanup_insn
;
14048 current_function_assigns_this
= p
->assigns_this
;
14049 current_function_just_assigned_this
= p
->just_assigned_this
;
14050 current_function_parms_stored
= p
->parms_stored
;
14051 original_result_rtx
= p
->result_rtx
;
14052 base_init_expr
= p
->base_init_expr
;
14053 temp_name_counter
= p
->temp_name_counter
;
14054 current_base_init_list
= p
->base_init_list
;
14055 current_member_init_list
= p
->member_init_list
;
14056 current_class_ptr
= p
->current_class_ptr
;
14057 current_class_ref
= p
->current_class_ref
;
14058 static_labelno
= p
->static_labelno
;
14066 return function_depth
!= 0;