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 (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
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
),
2599 COMPARE_REDECLARATION
);
2605 /* If NEWDECL is `static' and an `extern' was seen previously,
2606 warn about it. (OLDDECL may be NULL_TREE; NAME contains
2607 information about previous usage as an `extern'.)
2609 Note that this does not apply to the C++ case of declaring
2610 a variable `extern const' and then later `const'.
2612 Don't complain about built-in functions, since they are beyond
2613 the user's control. */
2616 warn_extern_redeclared_static (newdecl
, olddecl
)
2617 tree newdecl
, olddecl
;
2621 static char *explicit_extern_static_warning
2622 = "`%D' was declared `extern' and later `static'";
2623 static char *implicit_extern_static_warning
2624 = "`%D' was declared implicitly `extern' and later `static'";
2626 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2629 name
= DECL_ASSEMBLER_NAME (newdecl
);
2630 if (TREE_PUBLIC (name
) && DECL_THIS_STATIC (newdecl
))
2632 /* It's okay to redeclare an ANSI built-in function as static,
2633 or to declare a non-ANSI built-in function as anything. */
2634 if (! (TREE_CODE (newdecl
) == FUNCTION_DECL
2635 && olddecl
!= NULL_TREE
2636 && TREE_CODE (olddecl
) == FUNCTION_DECL
2637 && (DECL_BUILT_IN (olddecl
)
2638 || DECL_BUILT_IN_NONANSI (olddecl
))))
2640 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
2641 ? implicit_extern_static_warning
2642 : explicit_extern_static_warning
, newdecl
);
2643 if (olddecl
!= NULL_TREE
)
2644 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
2649 /* Handle when a new declaration NEWDECL has the same name as an old
2650 one OLDDECL in the same binding contour. Prints an error message
2653 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2654 Otherwise, return 0. */
2657 duplicate_decls (newdecl
, olddecl
)
2658 tree newdecl
, olddecl
;
2660 extern struct obstack permanent_obstack
;
2661 unsigned olddecl_uid
= DECL_UID (olddecl
);
2662 int olddecl_friend
= 0, types_match
= 0;
2663 int new_defines_function
= 0;
2665 if (newdecl
== olddecl
)
2668 types_match
= decls_match (newdecl
, olddecl
);
2670 /* If either the type of the new decl or the type of the old decl is an
2671 error_mark_node, then that implies that we have already issued an
2672 error (earlier) for some bogus type specification, and in that case,
2673 it is rather pointless to harass the user with yet more error message
2674 about the same declaration, so just pretend the types match here. */
2675 if (TREE_TYPE (newdecl
) == error_mark_node
2676 || TREE_TYPE (olddecl
) == error_mark_node
)
2679 /* Check for redeclaration and other discrepancies. */
2680 if (TREE_CODE (olddecl
) == FUNCTION_DECL
2681 && DECL_ARTIFICIAL (olddecl
)
2682 && (DECL_BUILT_IN (olddecl
) || DECL_BUILT_IN_NONANSI (olddecl
)))
2684 /* If you declare a built-in or predefined function name as static,
2685 the old definition is overridden, but optionally warn this was a
2686 bad choice of name. Ditto for overloads. */
2687 if (! TREE_PUBLIC (newdecl
)
2688 || (TREE_CODE (newdecl
) == FUNCTION_DECL
2689 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
)))
2692 cp_warning ("shadowing %s function `%#D'",
2693 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
2695 /* Discard the old built-in function. */
2698 else if (! types_match
)
2700 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
2702 /* If the built-in is not ansi, then programs can override
2703 it even globally without an error. */
2704 if (! DECL_BUILT_IN (olddecl
))
2705 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2709 cp_error ("declaration of `%#D'", newdecl
);
2710 cp_error ("conflicts with built-in declaration `%#D'",
2716 cp_warning ("declaration of `%#D'", newdecl
);
2717 cp_warning ("conflicts with built-in declaration `%#D'",
2721 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
2723 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
2724 && TREE_CODE (newdecl
) != TYPE_DECL
2725 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
2726 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
2727 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
2728 && TREE_CODE (olddecl
) != TYPE_DECL
2729 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
2730 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2733 /* We do nothing special here, because C++ does such nasty
2734 things with TYPE_DECLs. Instead, just let the TYPE_DECL
2735 get shadowed, and know that if we need to find a TYPE_DECL
2736 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
2737 slot of the identifier. */
2741 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
2742 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
2743 || (TREE_CODE (olddecl
) == FUNCTION_DECL
2744 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
2747 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
2748 if (TREE_CODE (olddecl
) == TREE_LIST
)
2749 olddecl
= TREE_VALUE (olddecl
);
2750 cp_error_at ("previous declaration of `%#D'", olddecl
);
2752 /* New decl is completely inconsistent with the old one =>
2753 tell caller to replace the old one. */
2757 else if (!types_match
)
2759 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2761 /* The name of a class template may not be declared to refer to
2762 any other template, class, function, object, namespace, value,
2763 or type in the same scope. */
2764 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
2765 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2767 cp_error ("declaration of template `%#D'", newdecl
);
2768 cp_error_at ("conflicts with previous declaration `%#D'",
2771 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
2772 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
2773 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
2774 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
2775 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2776 DECL_TEMPLATE_PARMS (olddecl
)))
2778 cp_error ("new declaration `%#D'", newdecl
);
2779 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
2783 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2785 if (DECL_LANGUAGE (newdecl
) == lang_c
2786 && DECL_LANGUAGE (olddecl
) == lang_c
)
2788 cp_error ("declaration of C function `%#D' conflicts with",
2790 cp_error_at ("previous declaration `%#D' here", olddecl
);
2792 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
2793 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
2795 cp_error ("new declaration `%#D'", newdecl
);
2796 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
2802 /* Already complained about this, so don't do so again. */
2803 else if (current_class_type
== NULL_TREE
2804 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
2806 cp_error ("conflicting types for `%#D'", newdecl
);
2807 cp_error_at ("previous declaration as `%#D'", olddecl
);
2810 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2811 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
2812 && (!DECL_TEMPLATE_INFO (newdecl
)
2813 || (DECL_TI_TEMPLATE (newdecl
)
2814 != DECL_TI_TEMPLATE (olddecl
))))
2815 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2816 && (!DECL_TEMPLATE_INFO (olddecl
)
2817 || (DECL_TI_TEMPLATE (olddecl
)
2818 != DECL_TI_TEMPLATE (newdecl
))))))
2819 /* It's OK to have a template specialization and a non-template
2820 with the same type, or to have specializations of two
2821 different templates with the same type. Note that if one is a
2822 specialization, and the other is an instantiation of the same
2823 template, that we do not exit at this point. That situation
2824 can occur if we instantiate a template class, and then
2825 specialize one of its methods. This situation is legal, but
2826 the declarations must be merged in the usual way. */
2828 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2829 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
2830 && !DECL_USE_TEMPLATE (newdecl
))
2831 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
2832 && !DECL_USE_TEMPLATE (olddecl
))))
2833 /* One of the declarations is a template instantiation, and the
2834 other is not a template at all. That's OK. */
2836 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
2837 && DECL_NAMESPACE_ALIAS (newdecl
)
2838 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
2839 /* Redeclaration of namespace alias, ignore it. */
2843 char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
2846 cp_error (errmsg
, newdecl
);
2847 if (DECL_NAME (olddecl
) != NULL_TREE
)
2848 cp_error_at ((DECL_INITIAL (olddecl
)
2849 && namespace_bindings_p ())
2850 ? "`%#D' previously defined here"
2851 : "`%#D' previously declared here", olddecl
);
2853 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
2854 && DECL_INITIAL (olddecl
) != NULL_TREE
2855 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
2856 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
2858 /* Prototype decl follows defn w/o prototype. */
2859 cp_warning_at ("prototype for `%#D'", newdecl
);
2860 cp_warning_at ("follows non-prototype definition here", olddecl
);
2862 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
2863 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
2865 /* extern "C" int foo ();
2866 int foo () { bar (); }
2868 if (current_lang_stack
== current_lang_base
)
2869 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
2872 cp_error_at ("previous declaration of `%#D' with %L linkage",
2873 olddecl
, DECL_LANGUAGE (olddecl
));
2874 cp_error ("conflicts with new declaration with %L linkage",
2875 DECL_LANGUAGE (newdecl
));
2879 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
2881 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2883 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
2884 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
2887 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
2888 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
2890 for (; t1
&& t1
!= void_list_node
;
2891 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
2892 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
2894 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
2899 cp_pedwarn ("default argument given for parameter %d of `%#D'",
2901 cp_pedwarn_at ("after previous specification in `%#D'",
2907 cp_error ("default argument given for parameter %d of `%#D'",
2909 cp_error_at ("after previous specification in `%#D'",
2914 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
2915 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
2917 cp_warning ("`%#D' was used before it was declared inline",
2919 cp_warning_at ("previous non-inline declaration here",
2925 /* If new decl is `static' and an `extern' was seen previously,
2927 warn_extern_redeclared_static (newdecl
, olddecl
);
2929 /* We have committed to returning 1 at this point. */
2930 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2932 /* Now that functions must hold information normally held
2933 by field decls, there is extra work to do so that
2934 declaration information does not get destroyed during
2936 if (DECL_VINDEX (olddecl
))
2937 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
2938 if (DECL_CONTEXT (olddecl
))
2939 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2940 if (DECL_CLASS_CONTEXT (olddecl
))
2941 DECL_CLASS_CONTEXT (newdecl
) = DECL_CLASS_CONTEXT (olddecl
);
2942 if (DECL_PENDING_INLINE_INFO (newdecl
) == (struct pending_inline
*)0)
2943 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2944 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
2945 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2946 DECL_ABSTRACT_VIRTUAL_P (newdecl
) |= DECL_ABSTRACT_VIRTUAL_P (olddecl
);
2947 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
2948 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
2949 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
2951 /* Optionally warn about more than one declaration for the same
2952 name, but don't warn about a function declaration followed by a
2954 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
2955 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
2956 /* Don't warn about extern decl followed by definition. */
2957 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
2958 /* Don't warn about friends, let add_friend take care of it. */
2959 && ! DECL_FRIEND_P (newdecl
))
2961 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
2962 cp_warning_at ("previous declaration of `%D'", olddecl
);
2966 /* Deal with C++: must preserve virtual function table size. */
2967 if (TREE_CODE (olddecl
) == TYPE_DECL
)
2969 register tree newtype
= TREE_TYPE (newdecl
);
2970 register tree oldtype
= TREE_TYPE (olddecl
);
2972 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
2973 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
2975 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
2976 CLASSTYPE_FRIEND_CLASSES (newtype
)
2977 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
2981 /* Copy all the DECL_... slots specified in the new decl
2982 except for any that we copy here from the old type. */
2983 DECL_MACHINE_ATTRIBUTES (newdecl
)
2984 = merge_machine_decl_attributes (olddecl
, newdecl
);
2986 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2988 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl
),
2989 DECL_TEMPLATE_RESULT (olddecl
)))
2990 cp_error ("invalid redeclaration of %D", newdecl
);
2991 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
2992 DECL_TEMPLATE_PARMS (olddecl
) = DECL_TEMPLATE_PARMS (newdecl
);
2993 if (DECL_TEMPLATE_INFO (newdecl
))
2994 DECL_TEMPLATE_INFO (olddecl
) = DECL_TEMPLATE_INFO (newdecl
);
2995 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
2996 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
2997 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3004 /* Automatically handles default parameters. */
3005 tree oldtype
= TREE_TYPE (olddecl
);
3008 /* Make sure we put the new type in the same obstack as the old one. */
3010 push_obstacks (TYPE_OBSTACK (oldtype
), TYPE_OBSTACK (oldtype
));
3013 push_obstacks_nochange ();
3014 end_temporary_allocation ();
3017 /* Merge the data types specified in the two decls. */
3018 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3020 if (TREE_CODE (newdecl
) == VAR_DECL
)
3021 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3022 /* Do this after calling `common_type' so that default
3023 parameters don't confuse us. */
3024 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3025 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3026 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3028 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3029 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3030 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3031 TYPE_RAISES_EXCEPTIONS (oldtype
));
3033 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3034 && DECL_SOURCE_LINE (olddecl
) != 0
3036 && ! compexcepttypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
3038 cp_pedwarn ("declaration of `%D' throws different exceptions",
3040 cp_pedwarn_at ("previous declaration here", olddecl
);
3043 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3045 /* Lay the type out, unless already done. */
3046 if (newtype
!= canonical_type_variant (oldtype
)
3047 && TREE_TYPE (newdecl
) != error_mark_node
3048 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3049 layout_type (TREE_TYPE (newdecl
));
3051 if ((TREE_CODE (newdecl
) == VAR_DECL
3052 || TREE_CODE (newdecl
) == PARM_DECL
3053 || TREE_CODE (newdecl
) == RESULT_DECL
3054 || TREE_CODE (newdecl
) == FIELD_DECL
3055 || TREE_CODE (newdecl
) == TYPE_DECL
)
3056 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3057 layout_decl (newdecl
, 0);
3059 /* Merge the type qualifiers. */
3060 if (TREE_READONLY (newdecl
))
3061 TREE_READONLY (olddecl
) = 1;
3062 if (TREE_THIS_VOLATILE (newdecl
))
3063 TREE_THIS_VOLATILE (olddecl
) = 1;
3065 /* Merge the initialization information. */
3066 if (DECL_INITIAL (newdecl
) == NULL_TREE
3067 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3069 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3070 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3071 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3072 if (DECL_LANG_SPECIFIC (newdecl
)
3073 && DECL_LANG_SPECIFIC (olddecl
))
3074 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3077 /* Merge the section attribute.
3078 We want to issue an error if the sections conflict but that must be
3079 done later in decl_attributes since we are called before attributes
3081 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3082 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3084 /* Keep the old rtl since we can safely use it, unless it's the
3085 call to abort() used for abstract virtuals. */
3086 if ((DECL_LANG_SPECIFIC (olddecl
)
3087 && !DECL_ABSTRACT_VIRTUAL_P (olddecl
))
3088 || DECL_RTL (olddecl
) != DECL_RTL (abort_fndecl
))
3089 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3093 /* If cannot merge, then use the new type and qualifiers,
3094 and don't preserve the old rtl. */
3097 /* Clean out any memory we had of the old declaration. */
3098 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3100 TREE_VALUE (oldstatic
) = error_mark_node
;
3102 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3103 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3104 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3105 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3108 /* Merge the storage class information. */
3109 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3110 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3111 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3112 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3113 if (! DECL_EXTERNAL (olddecl
))
3114 DECL_EXTERNAL (newdecl
) = 0;
3116 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3118 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3119 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3120 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3121 /* Don't really know how much of the language-specific
3122 values we should copy from old to new. */
3123 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3124 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3125 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3126 if (DECL_TEMPLATE_INFO (newdecl
) == NULL_TREE
)
3128 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3129 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
3131 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3134 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3136 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3137 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3139 /* If newdecl is not a specialization, then it is not a
3140 template-related function at all. And that means that we
3141 shoud have exited above, returning 0. */
3142 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3145 if (TREE_USED (olddecl
))
3146 /* From [temp.expl.spec]:
3148 If a template, a member template or the member of a class
3149 template is explicitly specialized then that
3150 specialization shall be declared before the first use of
3151 that specialization that would cause an implicit
3152 instantiation to take place, in every translation unit in
3153 which such a use occurs. */
3154 cp_error ("explicit specialization of %D after first use",
3157 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3159 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3161 /* If either decl says `inline', this fn is inline, unless its
3162 definition was passed already. */
3163 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3164 DECL_INLINE (olddecl
) = 1;
3165 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3169 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3170 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3171 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3173 if (! types_match
|| new_defines_function
)
3175 /* These need to be copied so that the names are available. */
3176 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3177 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3179 if (new_defines_function
)
3180 /* If defining a function declared with other language
3181 linkage, use the previously declared language linkage. */
3182 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3185 /* If redeclaring a builtin function, and not a definition,
3186 it stays built in. */
3187 if (DECL_BUILT_IN (olddecl
))
3189 DECL_BUILT_IN (newdecl
) = 1;
3190 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3191 /* If we're keeping the built-in definition, keep the rtl,
3192 regardless of declaration matches. */
3193 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3196 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3198 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3199 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3200 /* Previously saved insns go together with
3201 the function's previous definition. */
3202 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3203 /* Don't clear out the arguments if we're redefining a function. */
3204 if (DECL_ARGUMENTS (olddecl
))
3205 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3207 if (DECL_LANG_SPECIFIC (olddecl
))
3208 DECL_MAIN_VARIANT (newdecl
) = DECL_MAIN_VARIANT (olddecl
);
3211 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3213 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3216 /* Now preserve various other info from the definition. */
3217 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3218 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3219 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3220 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3222 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3225 struct lang_decl
*ol
= DECL_LANG_SPECIFIC (olddecl
);
3226 struct lang_decl
*nl
= DECL_LANG_SPECIFIC (newdecl
);
3228 function_size
= sizeof (struct tree_decl
);
3230 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3231 (char *) olddecl
+ sizeof (struct tree_common
),
3232 function_size
- sizeof (struct tree_common
));
3234 /* Can we safely free the storage used by newdecl? */
3236 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3237 & ~ obstack_alignment_mask (&permanent_obstack))
3239 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3241 /* If newdecl is a template instantiation, it is possible that
3242 the following sequence of events has occurred:
3244 o A friend function was declared in a class template. The
3245 class template was instantiated.
3247 o The instantiation of the friend declaration was
3248 recorded on the instantiation list, and is newdecl.
3250 o Later, however, instantiate_class_template called pushdecl
3251 on the newdecl to perform name injection. But, pushdecl in
3252 turn called duplicate_decls when it discovered that another
3253 declaration of a global function with the same name already
3256 o Here, in duplicate_decls, we decided to clobber newdecl.
3258 If we're going to do that, we'd better make sure that
3259 olddecl, and not newdecl, is on the list of
3260 instantiations so that if we try to do the instantiation
3261 again we won't get the clobbered declaration. */
3263 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3264 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3266 for (; decls
; decls
= TREE_CHAIN (decls
))
3267 if (TREE_VALUE (decls
) == newdecl
)
3268 TREE_VALUE (decls
) = olddecl
;
3271 if (((char *)newdecl
+ ROUND (function_size
) == (char *)nl
3272 && ((char *)newdecl
+ ROUND (function_size
)
3273 + ROUND (sizeof (struct lang_decl
))
3274 == obstack_next_free (&permanent_obstack
)))
3275 || ((char *)newdecl
+ ROUND (function_size
)
3276 == obstack_next_free (&permanent_obstack
)))
3278 DECL_MAIN_VARIANT (newdecl
) = olddecl
;
3279 DECL_LANG_SPECIFIC (olddecl
) = ol
;
3280 bcopy ((char *)nl
, (char *)ol
, sizeof (struct lang_decl
));
3282 obstack_free (&permanent_obstack
, newdecl
);
3284 else if (LANG_DECL_PERMANENT (ol
) && ol
!= nl
)
3286 if (DECL_MAIN_VARIANT (olddecl
) == olddecl
)
3288 /* Save these lang_decls that would otherwise be lost. */
3289 extern tree free_lang_decl_chain
;
3290 tree free_lang_decl
= (tree
) ol
;
3292 if (DECL_LANG_SPECIFIC (olddecl
) == ol
)
3295 TREE_CHAIN (free_lang_decl
) = free_lang_decl_chain
;
3296 free_lang_decl_chain
= free_lang_decl
;
3300 /* Storage leak. */;
3306 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3307 (char *) olddecl
+ sizeof (struct tree_common
),
3308 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3309 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3312 DECL_UID (olddecl
) = olddecl_uid
;
3314 DECL_FRIEND_P (olddecl
) = 1;
3316 /* NEWDECL contains the merged attribute lists.
3317 Update OLDDECL to be the same. */
3318 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3323 /* Record a decl-node X as belonging to the current lexical scope.
3324 Check for errors (such as an incompatible declaration for the same
3325 name already seen in the same scope).
3327 Returns either X or an old decl for the same name.
3328 If an old decl is returned, it may have been smashed
3329 to agree with what X says. */
3336 register tree name
= DECL_ASSEMBLER_NAME (x
);
3337 register struct binding_level
*b
= current_binding_level
;
3339 if (current_function_decl
&& x
!= current_function_decl
3340 /* A local declaration for a function doesn't constitute nesting. */
3341 && (TREE_CODE (x
) != FUNCTION_DECL
|| DECL_INITIAL (x
))
3342 /* Don't change DECL_CONTEXT of virtual methods. */
3343 && (TREE_CODE (x
) != FUNCTION_DECL
|| !DECL_VIRTUAL_P (x
))
3344 && ! DECL_CONTEXT (x
))
3345 DECL_CONTEXT (x
) = current_function_decl
;
3346 if (!DECL_CONTEXT (x
))
3347 DECL_CONTEXT (x
) = FROB_CONTEXT (current_namespace
);
3349 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3350 compiler wants to use. */
3351 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
3352 || TREE_CODE (x
) == NAMESPACE_DECL
|| TREE_CODE (x
) == TEMPLATE_TYPE_PARM
3353 || TREE_CODE (x
) == TEMPLATE_TEMPLATE_PARM
)
3354 name
= DECL_NAME (x
);
3359 /* Not needed...see below. */
3363 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3364 name
= TREE_OPERAND (name
, 0);
3366 /* Namespace-scoped variables are not found in the current level. */
3367 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
))
3368 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3370 t
= lookup_name_current_level (name
);
3371 if (t
== error_mark_node
)
3373 /* error_mark_node is 0 for a while during initialization! */
3375 cp_error_at ("`%#D' used prior to declaration", x
);
3378 else if (t
!= NULL_TREE
)
3381 /* This is turned off until I have time to do it right (bpk). */
3382 /* With the code below that uses it... */
3383 file
= DECL_SOURCE_FILE (t
);
3384 line
= DECL_SOURCE_LINE (t
);
3386 if (TREE_CODE (t
) == PARM_DECL
)
3388 if (DECL_CONTEXT (t
) == NULL_TREE
)
3389 fatal ("parse errors have confused me too much");
3391 /* Check for duplicate params. */
3392 if (duplicate_decls (x
, t
))
3395 else if (((TREE_CODE (x
) == FUNCTION_DECL
&& DECL_LANGUAGE (x
) == lang_c
)
3396 || DECL_FUNCTION_TEMPLATE_P (x
))
3397 && is_overloaded_fn (t
))
3398 /* Don't do anything just yet. */;
3399 else if (t
== wchar_decl_node
)
3401 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3402 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3404 /* Throw away the redeclaration. */
3407 else if (TREE_CODE (t
) != TREE_CODE (x
))
3409 if (duplicate_decls (x
, t
))
3412 else if (duplicate_decls (x
, t
))
3415 /* This is turned off until I have time to do it right (bpk). */
3417 /* Also warn if they did a prototype with `static' on it, but
3418 then later left the `static' off. */
3419 if (! TREE_PUBLIC (name
) && TREE_PUBLIC (x
))
3421 if (DECL_LANG_SPECIFIC (t
) && DECL_FRIEND_P (t
))
3426 cp_warning ("`static' missing from declaration of `%D'",
3428 warning_with_file_and_line (file
, line
,
3429 "previous declaration of `%s'",
3430 decl_as_string (t
, 0));
3433 /* Now fix things so it'll do what they expect. */
3434 if (current_function_decl
)
3435 TREE_PUBLIC (current_function_decl
) = 0;
3437 /* Due to interference in memory reclamation (X may be
3438 obstack-deallocated at this point), we must guard against
3439 one really special case. [jason: This should be handled
3440 by start_function] */
3441 if (current_function_decl
== x
)
3442 current_function_decl
= t
;
3444 if (TREE_CODE (t
) == TYPE_DECL
)
3445 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3446 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3447 check_default_args (t
);
3451 else if (DECL_MAIN_P (x
))
3453 /* A redeclaration of main, but not a duplicate of the
3458 This function shall not be overloaded. */
3459 cp_error_at ("invalid redeclaration of `%D'", t
);
3460 cp_error ("as `%D'", x
);
3461 /* We don't try to push this declaration since that
3467 if (TREE_CODE (x
) == FUNCTION_DECL
&& ! DECL_FUNCTION_MEMBER_P (x
))
3469 t
= push_overloaded_decl (x
, 1);
3470 if (t
!= x
|| DECL_LANGUAGE (x
) == lang_c
)
3473 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3474 return push_overloaded_decl (x
, 0);
3476 /* If declaring a type as a typedef, copy the type (unless we're
3477 at line 0), and install this TYPE_DECL as the new type's typedef
3478 name. See the extensive comment in ../c-decl.c (pushdecl). */
3479 if (TREE_CODE (x
) == TYPE_DECL
)
3481 tree type
= TREE_TYPE (x
);
3482 if (DECL_SOURCE_LINE (x
) == 0)
3484 if (TYPE_NAME (type
) == 0)
3485 TYPE_NAME (type
) = x
;
3487 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
3488 /* We don't want to copy the type when all we're
3489 doing is making a TYPE_DECL for the purposes of
3491 && (!TYPE_NAME (type
)
3492 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
3494 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
3496 DECL_ORIGINAL_TYPE (x
) = type
;
3497 type
= build_type_copy (type
);
3498 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
3499 TYPE_NAME (type
) = x
;
3500 TREE_TYPE (x
) = type
;
3505 if (type
!= error_mark_node
3507 && TYPE_IDENTIFIER (type
))
3508 set_identifier_type_value_with_scope (DECL_NAME (x
), type
, b
);
3511 /* Multiple external decls of the same identifier ought to match.
3513 We get warnings about inline functions where they are defined.
3514 We get warnings about other functions from push_overloaded_decl.
3516 Avoid duplicate warnings where they are used. */
3517 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
3521 if (IDENTIFIER_NAMESPACE_VALUE (name
) != NULL_TREE
3522 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name
))
3523 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name
))))
3524 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
3529 /* If different sort of thing, we already gave an error. */
3530 && TREE_CODE (decl
) == TREE_CODE (x
)
3531 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
3533 cp_pedwarn ("type mismatch with previous external decl", x
);
3534 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
3538 /* This name is new in its binding level.
3539 Install the new declaration and return it. */
3540 if (namespace_bindings_p ())
3542 /* Install a global value. */
3544 /* If the first global decl has external linkage,
3545 warn if we later see static one. */
3546 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
3547 TREE_PUBLIC (name
) = 1;
3549 /* Don't install an artificial TYPE_DECL if we already have
3550 another _DECL with that name. */
3551 if (TREE_CODE (x
) != TYPE_DECL
3553 || ! DECL_ARTIFICIAL (x
))
3555 if (TREE_CODE (x
) == FUNCTION_DECL
)
3557 ((IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
)
3558 || (IDENTIFIER_GLOBAL_VALUE (name
) == x
), 378);
3559 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
3562 /* Don't forget if the function was used via an implicit decl. */
3563 if (IDENTIFIER_IMPLICIT_DECL (name
)
3564 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
3567 /* Don't forget if its address was taken in that way. */
3568 if (IDENTIFIER_IMPLICIT_DECL (name
)
3569 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
3570 TREE_ADDRESSABLE (x
) = 1;
3572 /* Warn about mismatches against previous implicit decl. */
3573 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
3574 /* If this real decl matches the implicit, don't complain. */
3575 && ! (TREE_CODE (x
) == FUNCTION_DECL
3576 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
3578 ("`%D' was previously implicitly declared to return `int'", x
);
3580 /* If new decl is `static' and an `extern' was seen previously,
3582 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
3583 warn_extern_redeclared_static (x
, t
);
3587 /* Here to install a non-global value. */
3588 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
3589 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
3591 /* Don't install an artificial TYPE_DECL if we already have
3592 another _DECL with that name. */
3593 if (TREE_CODE (x
) != TYPE_DECL
3595 || ! DECL_ARTIFICIAL (x
))
3596 set_identifier_local_value_with_scope (name
, x
, b
);
3598 /* If this is a TYPE_DECL, push it into the type value slot. */
3599 if (TREE_CODE (x
) == TYPE_DECL
)
3600 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
), b
);
3602 /* Clear out any TYPE_DECL shadowed by a namespace so that
3603 we won't think this is a type. The C struct hack doesn't
3604 go through namespaces. */
3605 if (TREE_CODE (x
) == NAMESPACE_DECL
)
3606 set_identifier_type_value_with_scope (name
, NULL_TREE
, b
);
3608 /* If this is an extern function declaration, see if we
3609 have a global definition or declaration for the function. */
3610 if (oldlocal
== NULL_TREE
3611 && DECL_EXTERNAL (x
)
3612 && oldglobal
!= NULL_TREE
3613 && TREE_CODE (x
) == FUNCTION_DECL
3614 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
3616 /* We have one. Their types must agree. */
3617 if (decls_match (x
, oldglobal
))
3621 cp_warning ("extern declaration of `%#D' doesn't match", x
);
3622 cp_warning_at ("global declaration `%#D'", oldglobal
);
3625 /* If we have a local external declaration,
3626 and no file-scope declaration has yet been seen,
3627 then if we later have a file-scope decl it must not be static. */
3628 if (oldlocal
== NULL_TREE
3629 && oldglobal
== NULL_TREE
3630 && DECL_EXTERNAL (x
)
3633 TREE_PUBLIC (name
) = 1;
3636 if (DECL_FROM_INLINE (x
))
3637 /* Inline decls shadow nothing. */;
3639 /* Warn if shadowing an argument at the top level of the body. */
3640 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
3641 && TREE_CODE (oldlocal
) == PARM_DECL
3642 && TREE_CODE (x
) != PARM_DECL
)
3644 /* Go to where the parms should be and see if we
3646 struct binding_level
*b
= current_binding_level
->level_chain
;
3652 if (b
->parm_flag
== 1)
3653 cp_error ("declaration of `%#D' shadows a parameter", name
);
3655 else if (warn_shadow
&& oldlocal
!= NULL_TREE
&& b
->is_for_scope
3656 && !DECL_DEAD_FOR_LOCAL (oldlocal
))
3658 warning ("variable `%s' shadows local",
3659 IDENTIFIER_POINTER (name
));
3660 cp_warning_at (" this is the shadowed declaration", oldlocal
);
3662 /* Maybe warn if shadowing something else. */
3663 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
3664 /* No shadow warnings for internally generated vars. */
3665 && ! DECL_ARTIFICIAL (x
)
3666 /* No shadow warnings for vars made for inlining. */
3667 && ! DECL_FROM_INLINE (x
))
3669 char *warnstring
= NULL
;
3671 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
3672 warnstring
= "declaration of `%s' shadows a parameter";
3673 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
3674 && current_class_ptr
3675 && !TREE_STATIC (name
))
3676 warnstring
= "declaration of `%s' shadows a member of `this'";
3677 else if (oldlocal
!= NULL_TREE
)
3678 warnstring
= "declaration of `%s' shadows previous local";
3679 else if (oldglobal
!= NULL_TREE
)
3680 /* XXX shadow warnings in outer-more namespaces */
3681 warnstring
= "declaration of `%s' shadows global declaration";
3684 warning (warnstring
, IDENTIFIER_POINTER (name
));
3686 /* Check to see if decl redeclares a template parameter. */
3687 if (oldlocal
&& (current_class_type
|| current_function_decl
)
3688 && current_template_parms
)
3690 if (decl_template_parm_p (oldlocal
))
3692 cp_error ("re-using name of template parameter `%T' in this scope", name
);
3693 cp_error_at (" previously declared here `%#D'", oldlocal
);
3698 if (TREE_CODE (x
) == FUNCTION_DECL
)
3699 check_default_args (x
);
3701 /* Keep count of variables in this level with incomplete type. */
3702 if (TREE_CODE (x
) == VAR_DECL
3703 && TREE_TYPE (x
) != error_mark_node
3704 && ((TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
3705 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
3706 /* RTTI TD entries are created while defining the type_info. */
3707 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
3708 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
3709 b
->incomplete
= tree_cons (NULL_TREE
, x
, b
->incomplete
);
3712 /* Put decls on list in reverse order.
3713 We will reverse them later if necessary. */
3714 TREE_CHAIN (x
) = b
->names
;
3716 if (! (b
!= global_binding_level
|| TREE_PERMANENT (x
)))
3717 my_friendly_abort (124);
3722 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3723 caller to set DECL_CONTEXT properly. */
3726 pushdecl_with_scope (x
, level
)
3728 struct binding_level
*level
;
3730 register struct binding_level
*b
;
3731 tree function_decl
= current_function_decl
;
3733 current_function_decl
= NULL_TREE
;
3734 if (level
->parm_flag
== 2)
3736 b
= class_binding_level
;
3737 class_binding_level
= level
;
3738 pushdecl_class_level (x
);
3739 class_binding_level
= b
;
3743 b
= current_binding_level
;
3744 current_binding_level
= level
;
3746 current_binding_level
= b
;
3748 current_function_decl
= function_decl
;
3752 /* Like pushdecl, only it places X in the current namespace,
3756 pushdecl_namespace_level (x
)
3759 register struct binding_level
*b
= inner_binding_level
;
3762 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
3764 /* Now, the type_shadowed stack may screw us. Munge it so it does
3766 if (TREE_CODE (x
) == TYPE_DECL
)
3768 tree name
= DECL_NAME (x
);
3770 tree
*ptr
= (tree
*)0;
3771 for (; b
!= global_binding_level
; b
= b
->level_chain
)
3773 tree shadowed
= b
->type_shadowed
;
3774 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3775 if (TREE_PURPOSE (shadowed
) == name
)
3777 ptr
= &TREE_VALUE (shadowed
);
3778 /* Can't break out of the loop here because sometimes
3779 a binding level will have duplicate bindings for
3780 PT names. It's gross, but I haven't time to fix it. */
3783 newval
= TREE_TYPE (x
);
3784 if (ptr
== (tree
*)0)
3786 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3787 up here if this is changed to an assertion. --KR */
3788 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
3798 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
3802 pushdecl_top_level (x
)
3805 tree cur_namespace
= current_namespace
;
3806 current_namespace
= global_namespace
;
3807 x
= pushdecl_namespace_level (x
);
3808 current_namespace
= cur_namespace
;
3812 /* Make the declaration of X appear in CLASS scope. */
3815 pushdecl_class_level (x
)
3818 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
3819 scope looks for the pre-mangled name. */
3820 register tree name
= DECL_NAME (x
);
3824 if (TYPE_BEING_DEFINED (current_class_type
))
3826 /* A name N used in a class S shall refer to the same declaration
3827 in its context and when re-evaluated in the completed scope of S.
3828 Types, enums, and static vars are checked here; other
3829 members are checked in finish_struct. */
3830 tree icv
= IDENTIFIER_CLASS_VALUE (name
);
3831 tree ilv
= IDENTIFIER_LOCAL_VALUE (name
);
3834 && flag_optional_diags
3835 /* Don't complain about inherited names. */
3836 && id_in_current_class (name
)
3837 /* Or shadowed tags. */
3838 && !(DECL_DECLARES_TYPE_P (icv
)
3839 && DECL_CONTEXT (icv
) == current_class_type
))
3841 cp_pedwarn ("declaration of identifier `%D' as `%#D'", name
, x
);
3842 cp_pedwarn_at ("conflicts with previous use in class as `%#D'",
3846 /* Check to see if decl redeclares a template parameter. */
3847 if (ilv
&& ! decls_match (ilv
, x
)
3848 && (current_class_type
|| current_function_decl
)
3849 && current_template_parms
)
3851 if (decl_template_parm_p (ilv
))
3853 cp_error ("re-using name of template parameter `%T' in this scope", name
);
3854 cp_error_at (" previously declared here `%#D'", ilv
);
3859 push_class_level_binding (name
, x
);
3860 if (TREE_CODE (x
) == TYPE_DECL
)
3862 set_identifier_type_value (name
, TREE_TYPE (x
));
3868 /* This function is used to push the mangled decls for nested types into
3869 the appropriate scope. Previously pushdecl_top_level was used, but that
3870 is incorrect for members of local classes. */
3873 pushdecl_nonclass_level (x
)
3876 struct binding_level
*b
= current_binding_level
;
3878 my_friendly_assert (b
->parm_flag
!= 2, 180);
3881 /* Get out of template binding levels */
3882 while (b
->pseudo_global
)
3886 pushdecl_with_scope (x
, b
);
3890 /* Make the declaration(s) of X appear in CLASS scope
3891 under the name NAME. */
3894 push_class_level_binding (name
, x
)
3898 /* The class_binding_level will be NULL if x is a template
3899 parameter name in a member template. */
3900 if (!class_binding_level
)
3903 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
3904 && purpose_member (name
, class_binding_level
->class_shadowed
))
3907 maybe_push_cache_obstack ();
3908 class_binding_level
->class_shadowed
3909 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
3910 class_binding_level
->class_shadowed
);
3912 IDENTIFIER_CLASS_VALUE (name
) = x
;
3913 obstack_ptr_grow (&decl_obstack
, x
);
3916 /* Insert another USING_DECL into the current binding level,
3917 returning this declaration. If this is a redeclaration,
3918 do nothing and return NULL_TREE. */
3921 push_using_decl (scope
, name
)
3927 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
3928 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
3929 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
3930 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
3934 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
3935 DECL_INITIAL (decl
) = scope
;
3936 TREE_CHAIN (decl
) = current_binding_level
->usings
;
3937 current_binding_level
->usings
= decl
;
3941 /* Add namespace to using_directives. Return NULL_TREE if nothing was
3942 changed (i.e. there was already a directive), or the fresh
3943 TREE_LIST otherwise. */
3946 push_using_directive (used
)
3949 tree ud
= current_binding_level
->using_directives
;
3950 tree iter
, ancestor
;
3952 /* Check if we already have this. */
3953 if (purpose_member (used
, ud
) != NULL_TREE
)
3956 /* Recursively add all namespaces used. */
3957 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
3958 push_using_directive (TREE_PURPOSE (iter
));
3960 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
3961 ud
= current_binding_level
->using_directives
;
3962 ud
= perm_tree_cons (used
, ancestor
, ud
);
3963 current_binding_level
->using_directives
= ud
;
3967 /* DECL is a FUNCTION_DECL which may have other definitions already in
3968 place. We get around this by making the value of the identifier point
3969 to a list of all the things that want to be referenced by that name. It
3970 is then up to the users of that name to decide what to do with that
3973 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
3974 slot. It is dealt with the same way.
3976 The value returned may be a previous declaration if we guessed wrong
3977 about what language DECL should belong to (C or C++). Otherwise,
3978 it's always DECL (and never something that's not a _DECL). */
3981 push_overloaded_decl (decl
, forgettable
)
3985 tree orig_name
= DECL_NAME (decl
);
3987 int doing_global
= (namespace_bindings_p () || ! forgettable
);
3991 old
= namespace_binding (orig_name
, DECL_CONTEXT (decl
));
3992 if (old
&& TREE_CODE (old
) == FUNCTION_DECL
3993 && DECL_ARTIFICIAL (old
)
3994 && (DECL_BUILT_IN (old
) || DECL_BUILT_IN_NONANSI (old
)))
3996 if (duplicate_decls (decl
, old
))
4003 old
= IDENTIFIER_LOCAL_VALUE (orig_name
);
4005 if (! purpose_member (orig_name
, current_binding_level
->shadowed
))
4007 current_binding_level
->shadowed
4008 = tree_cons (orig_name
, old
, current_binding_level
->shadowed
);
4015 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4017 tree t
= TREE_TYPE (old
);
4018 if (IS_AGGR_TYPE (t
) && warn_shadow
4019 && (! DECL_IN_SYSTEM_HEADER (decl
)
4020 || ! DECL_IN_SYSTEM_HEADER (old
)))
4021 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4024 else if (is_overloaded_fn (old
))
4028 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4029 if (decl
== OVL_CURRENT (tmp
)
4030 || duplicate_decls (decl
, OVL_CURRENT (tmp
)))
4031 return OVL_CURRENT (tmp
);
4035 cp_error_at ("previous non-function declaration `%#D'", old
);
4036 cp_error ("conflicts with function declaration `%#D'", decl
);
4041 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4043 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4044 old
= ovl_cons (old
, NULL_TREE
);
4045 old
= ovl_cons (decl
, old
);
4048 /* orig_name is not ambiguous. */
4052 set_namespace_binding (orig_name
, current_namespace
, old
);
4054 IDENTIFIER_LOCAL_VALUE (orig_name
) = old
;
4059 /* Generate an implicit declaration for identifier FUNCTIONID
4060 as a function of type int (). Print a warning if appropriate. */
4063 implicitly_declare (functionid
)
4067 int temp
= allocation_temporary_p ();
4069 push_obstacks_nochange ();
4071 /* Save the decl permanently so we can warn if definition follows.
4072 In ANSI C, warn_implicit is usually false, so the saves little space.
4073 But in C++, it's usually true, hence the extra code. */
4074 if (temp
&& (! warn_implicit
|| toplevel_bindings_p ()))
4075 end_temporary_allocation ();
4077 /* We used to reuse an old implicit decl here,
4078 but this loses with inline functions because it can clobber
4079 the saved decl chains. */
4080 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4082 DECL_EXTERNAL (decl
) = 1;
4083 TREE_PUBLIC (decl
) = 1;
4085 /* ANSI standard says implicit declarations are in the innermost block.
4086 So we record the decl in the standard fashion. */
4088 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4091 /* Only one warning per identifier. */
4092 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4094 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4097 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4104 /* Return zero if the declaration NEWDECL is valid
4105 when the declaration OLDDECL (assumed to be for the same name)
4106 has already been seen.
4107 Otherwise return an error message format string with a %s
4108 where the identifier should go. */
4111 redeclaration_error_message (newdecl
, olddecl
)
4112 tree newdecl
, olddecl
;
4114 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4116 /* Because C++ can put things into name space for free,
4117 constructs like "typedef struct foo { ... } foo"
4118 would look like an erroneous redeclaration. */
4119 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
4122 return "redefinition of `%#D'";
4124 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4126 /* If this is a pure function, its olddecl will actually be
4127 the original initialization to `0' (which we force to call
4128 abort()). Don't complain about redefinition in this case. */
4129 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_ABSTRACT_VIRTUAL_P (olddecl
))
4132 /* If both functions come from different namespaces, this is not
4133 a redeclaration - this is a conflict with a used function. */
4134 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4135 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4136 return "`%D' conflicts with used function";
4138 /* We'll complain about linkage mismatches in
4139 warn_extern_redeclared_static. */
4141 /* Defining the same name twice is no good. */
4142 if (DECL_INITIAL (olddecl
) != NULL_TREE
4143 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4145 if (DECL_NAME (olddecl
) == NULL_TREE
)
4146 return "`%#D' not declared in class";
4148 return "redefinition of `%#D'";
4152 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4154 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4155 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4156 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4157 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4158 && TYPE_SIZE (TREE_TYPE (newdecl
))
4159 && TYPE_SIZE (TREE_TYPE (olddecl
))))
4160 return "redefinition of `%#D'";
4163 else if (toplevel_bindings_p ())
4165 /* Objects declared at top level: */
4166 /* If at least one is a reference, it's ok. */
4167 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4169 /* Reject two definitions. */
4170 return "redefinition of `%#D'";
4174 /* Objects declared with block scope: */
4175 /* Reject two definitions, and reject a definition
4176 together with an external reference. */
4177 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4178 return "redeclaration of `%#D'";
4183 /* Get the LABEL_DECL corresponding to identifier ID as a label.
4184 Create one if none exists so far for the current function.
4185 This function is called for both label definitions and label references. */
4191 register tree decl
= IDENTIFIER_LABEL_VALUE (id
);
4193 if (current_function_decl
== NULL_TREE
)
4195 error ("label `%s' referenced outside of any function",
4196 IDENTIFIER_POINTER (id
));
4200 if ((decl
== NULL_TREE
4201 || DECL_SOURCE_LINE (decl
) == 0)
4202 && (named_label_uses
== NULL
4203 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4204 || named_label_uses
->label_decl
!= decl
))
4206 struct named_label_list
*new_ent
;
4208 = (struct named_label_list
*)oballoc (sizeof (struct named_label_list
));
4209 new_ent
->label_decl
= decl
;
4210 new_ent
->names_in_scope
= current_binding_level
->names
;
4211 new_ent
->binding_level
= current_binding_level
;
4212 new_ent
->lineno_o_goto
= lineno
;
4213 new_ent
->filename_o_goto
= input_filename
;
4214 new_ent
->next
= named_label_uses
;
4215 named_label_uses
= new_ent
;
4218 /* Use a label already defined or ref'd with this name. */
4219 if (decl
!= NULL_TREE
)
4221 /* But not if it is inherited and wasn't declared to be inheritable. */
4222 if (DECL_CONTEXT (decl
) != current_function_decl
4223 && ! C_DECLARED_LABEL_FLAG (decl
))
4224 return shadow_label (id
);
4228 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4230 /* Make sure every label has an rtx. */
4233 /* A label not explicitly declared must be local to where it's ref'd. */
4234 DECL_CONTEXT (decl
) = current_function_decl
;
4236 DECL_MODE (decl
) = VOIDmode
;
4238 /* Say where one reference is to the label,
4239 for the sake of the error if it is not defined. */
4240 DECL_SOURCE_LINE (decl
) = lineno
;
4241 DECL_SOURCE_FILE (decl
) = input_filename
;
4243 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4245 named_labels
= tree_cons (NULL_TREE
, decl
, named_labels
);
4246 named_label_uses
->label_decl
= decl
;
4251 /* Make a label named NAME in the current function,
4252 shadowing silently any that may be inherited from containing functions
4253 or containing scopes.
4255 Note that valid use, if the label being shadowed
4256 comes from another scope in the same function,
4257 requires calling declare_nonlocal_label right away. */
4263 register tree decl
= IDENTIFIER_LABEL_VALUE (name
);
4265 if (decl
!= NULL_TREE
)
4267 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
4268 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
4271 return lookup_label (name
);
4274 /* Define a label, specifying the location in the source file.
4275 Return the LABEL_DECL node for the label, if the definition is valid.
4276 Otherwise return 0. */
4279 define_label (filename
, line
, name
)
4286 if (minimal_parse_mode
)
4288 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4289 decl
= build_decl (LABEL_DECL
, name
, void_type_node
);
4291 DECL_SOURCE_LINE (decl
) = line
;
4292 DECL_SOURCE_FILE (decl
) = filename
;
4297 decl
= lookup_label (name
);
4299 /* After labels, make any new cleanups go into their
4300 own new (temporary) binding contour. */
4301 current_binding_level
->more_cleanups_ok
= 0;
4303 /* If label with this name is known from an outer context, shadow it. */
4304 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) != current_function_decl
)
4306 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
4307 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
4308 decl
= lookup_label (name
);
4311 if (name
== get_identifier ("wchar_t"))
4312 cp_pedwarn ("label named wchar_t");
4314 if (DECL_INITIAL (decl
) != NULL_TREE
)
4316 cp_error ("duplicate label `%D'", decl
);
4321 struct named_label_list
*uses
, *prev
;
4324 /* Mark label as having been defined. */
4325 DECL_INITIAL (decl
) = error_mark_node
;
4326 /* Say where in the source. */
4327 DECL_SOURCE_FILE (decl
) = filename
;
4328 DECL_SOURCE_LINE (decl
) = line
;
4331 uses
= named_label_uses
;
4332 while (uses
!= NULL
)
4333 if (uses
->label_decl
== decl
)
4335 struct binding_level
*b
= current_binding_level
;
4338 tree new_decls
= b
->names
;
4339 tree old_decls
= (b
== uses
->binding_level
)
4340 ? uses
->names_in_scope
: NULL_TREE
;
4341 while (new_decls
!= old_decls
)
4343 if (TREE_CODE (new_decls
) == VAR_DECL
4344 /* Don't complain about crossing initialization
4345 of internal entities. They can't be accessed,
4346 and they should be cleaned up
4347 by the time we get to the label. */
4348 && ! DECL_ARTIFICIAL (new_decls
)
4349 && !(DECL_INITIAL (new_decls
) == NULL_TREE
4350 && pod_type_p (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 if (DECL_INITIAL (new_decls
)
4361 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
)))
4362 cp_error_at (" crosses initialization of `%#D'",
4365 cp_error_at (" enters scope of non-POD `%#D'",
4368 new_decls
= TREE_CHAIN (new_decls
);
4370 if (b
== uses
->binding_level
)
4376 prev
->next
= uses
->next
;
4378 named_label_uses
= uses
->next
;
4387 current_function_return_value
= NULL_TREE
;
4394 struct binding_level
*level
;
4395 struct cp_switch
*next
;
4398 static struct cp_switch
*switch_stack
;
4404 = (struct cp_switch
*) oballoc (sizeof (struct cp_switch
));
4405 p
->level
= current_binding_level
;
4406 p
->next
= switch_stack
;
4413 switch_stack
= switch_stack
->next
;
4416 /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
4417 /* XXX Note decl is never actually used. (bpk) */
4420 define_case_label ()
4422 tree cleanup
= last_cleanup_this_contour ();
4423 struct binding_level
*b
= current_binding_level
;
4428 static int explained
= 0;
4429 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup
));
4430 warning ("where case label appears here");
4433 warning ("(enclose actions of previous case statements requiring");
4434 warning ("destructors in their own binding contours.)");
4439 for (; b
&& b
!= switch_stack
->level
; b
= b
->level_chain
)
4441 tree new_decls
= b
->names
;
4442 for (; new_decls
; new_decls
= TREE_CHAIN (new_decls
))
4444 if (TREE_CODE (new_decls
) == VAR_DECL
4445 /* Don't complain about crossing initialization
4446 of internal entities. They can't be accessed,
4447 and they should be cleaned up
4448 by the time we get to the label. */
4449 && ! DECL_ARTIFICIAL (new_decls
)
4450 && ((DECL_INITIAL (new_decls
) != NULL_TREE
4451 && DECL_INITIAL (new_decls
) != error_mark_node
)
4452 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
4455 error ("jump to case label");
4457 cp_error_at (" crosses initialization of `%#D'",
4463 /* After labels, make any new cleanups go into their
4464 own new (temporary) binding contour. */
4466 current_binding_level
->more_cleanups_ok
= 0;
4467 current_function_return_value
= NULL_TREE
;
4470 /* Return the list of declarations of the current level.
4471 Note that this list is in reverse order unless/until
4472 you nreverse it; and when you do nreverse it, you must
4473 store the result back using `storedecls' or you will lose. */
4478 return current_binding_level
->names
;
4481 /* Return the list of type-tags (for structs, etc) of the current level. */
4486 return current_binding_level
->tags
;
4489 /* Store the list of declarations of the current level.
4490 This is done for the parameter declarations of a function being defined,
4491 after they are modified in the light of any missing parameters. */
4497 current_binding_level
->names
= decls
;
4500 /* Similarly, store the list of tags of the current level. */
4506 current_binding_level
->tags
= tags
;
4509 /* Given NAME, an IDENTIFIER_NODE,
4510 return the structure (or union or enum) definition for that name.
4511 Searches binding levels from BINDING_LEVEL up to the global level.
4512 If THISLEVEL_ONLY is nonzero, searches only the specified context
4513 (but skips any tag-transparent contexts to find one that is
4514 meaningful for tags).
4515 FORM says which kind of type the caller wants;
4516 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4517 If the wrong kind of type is found, and it's not a template, an error is
4521 lookup_tag (form
, name
, binding_level
, thislevel_only
)
4522 enum tree_code form
;
4524 struct binding_level
*binding_level
;
4527 register struct binding_level
*level
;
4528 /* Non-zero if, we should look past a pseudo-global level, even if
4530 int allow_pseudo_global
= 1;
4532 for (level
= binding_level
; level
; level
= level
->level_chain
)
4535 if (ANON_AGGRNAME_P (name
))
4536 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4538 /* There's no need for error checking here, because
4539 anon names are unique throughout the compilation. */
4540 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
4541 return TREE_VALUE (tail
);
4543 else if (level
->namespace_p
)
4544 /* Do namespace lookup. */
4545 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
4547 tree old
= binding_for_name (name
, tail
);
4549 /* If we just skipped past a pseudo global level, even
4550 though THISLEVEL_ONLY, and we find a template class
4551 declaration, then we use the _TYPE node for the
4552 template. See the example below. */
4553 if (thislevel_only
&& !allow_pseudo_global
4554 && old
&& BINDING_VALUE (old
)
4555 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
4556 old
= TREE_TYPE (BINDING_VALUE (old
));
4558 old
= BINDING_TYPE (old
);
4560 /* If it has an original type, it is a typedef, and we
4561 should not return it. */
4562 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
4564 if (old
&& TREE_CODE (old
) != form
4565 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
4567 cp_error ("`%#D' redeclared as %C", old
, form
);
4572 if (thislevel_only
|| tail
== global_namespace
)
4576 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4578 if (TREE_PURPOSE (tail
) == name
)
4580 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
4581 /* Should tighten this up; it'll probably permit
4582 UNION_TYPE and a struct template, for example. */
4584 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
4586 /* Definition isn't the kind we were looking for. */
4587 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
4591 return TREE_VALUE (tail
);
4594 if (thislevel_only
&& ! level
->tag_transparent
)
4596 if (level
->pseudo_global
&& allow_pseudo_global
)
4598 /* We must deal with cases like this:
4600 template <class T> struct S;
4601 template <class T> struct S {};
4603 When looking up `S', for the second declaration, we
4604 would like to find the first declaration. But, we
4605 are in the pseudo-global level created for the
4606 template parameters, rather than the (surrounding)
4607 namespace level. Thus, we keep going one more level,
4608 even though THISLEVEL_ONLY is non-zero. */
4609 allow_pseudo_global
= 0;
4615 if (current_class_type
&& level
->level_chain
->namespace_p
)
4617 /* Try looking in this class's tags before heading into
4618 global binding level. */
4619 tree context
= current_class_type
;
4622 switch (TREE_CODE_CLASS (TREE_CODE (context
)))
4626 these_tags
= CLASSTYPE_TAGS (context
);
4627 if (ANON_AGGRNAME_P (name
))
4630 if (TYPE_IDENTIFIER (TREE_VALUE (these_tags
))
4632 return TREE_VALUE (tail
);
4633 these_tags
= TREE_CHAIN (these_tags
);
4638 if (TREE_PURPOSE (these_tags
) == name
)
4640 if (TREE_CODE (TREE_VALUE (these_tags
)) != form
)
4642 cp_error ("`%#D' redeclared as %C in class scope",
4643 TREE_VALUE (tail
), form
);
4646 return TREE_VALUE (tail
);
4648 these_tags
= TREE_CHAIN (these_tags
);
4650 /* If this type is not yet complete, then don't
4651 look at its context. */
4652 if (TYPE_SIZE (context
) == NULL_TREE
)
4654 /* Go to next enclosing type, if any. */
4655 context
= DECL_CONTEXT (TYPE_MAIN_DECL (context
));
4658 context
= DECL_CONTEXT (context
);
4661 my_friendly_abort (10);
4674 set_current_level_tags_transparency (tags_transparent
)
4675 int tags_transparent
;
4677 current_binding_level
->tag_transparent
= tags_transparent
;
4681 /* Given a type, find the tag that was defined for it and return the tag name.
4682 Otherwise return 0. However, the value can never be 0
4683 in the cases in which this is used.
4685 C++: If NAME is non-zero, this is the new name to install. This is
4686 done when replacing anonymous tags with real tag names. */
4689 lookup_tag_reverse (type
, name
)
4693 register struct binding_level
*level
;
4695 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
4698 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4700 if (TREE_VALUE (tail
) == type
)
4703 TREE_PURPOSE (tail
) = name
;
4704 return TREE_PURPOSE (tail
);
4711 /* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
4712 Return the type value, or NULL_TREE if not found. */
4715 lookup_nested_type (type
, context
)
4719 if (context
== NULL_TREE
)
4723 switch (TREE_CODE (context
))
4727 tree ctype
= TREE_TYPE (context
);
4728 tree match
= value_member (type
, CLASSTYPE_TAGS (ctype
));
4730 return TREE_VALUE (match
);
4731 context
= DECL_CONTEXT (context
);
4733 /* When we have a nested class whose member functions have
4734 local types (e.g., a set of enums), we'll arrive here
4735 with the DECL_CONTEXT as the actual RECORD_TYPE node for
4736 the enclosing class. Instead, we want to make sure we
4737 come back in here with the TYPE_DECL, not the RECORD_TYPE. */
4738 if (context
&& TREE_CODE (context
) == RECORD_TYPE
)
4739 context
= TREE_CHAIN (context
);
4743 if (TYPE_NAME (type
) && TYPE_IDENTIFIER (type
))
4744 return lookup_name (TYPE_IDENTIFIER (type
), 1);
4747 my_friendly_abort (12);
4753 /* Look up NAME in the NAMESPACE. */
4756 lookup_namespace_name (namespace, name
)
4757 tree
namespace, name
;
4759 struct tree_binding _b
;
4762 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
4764 /* This happens for A::B<int> when B is a namespace. */
4765 if (TREE_CODE (name
) == NAMESPACE_DECL
)
4768 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
4770 val
= binding_init (&_b
);
4771 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
4772 return error_mark_node
;
4774 if (BINDING_VALUE (val
))
4776 val
= BINDING_VALUE (val
);
4778 /* If we have a single function from a using decl, pull it out. */
4779 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
4780 val
= OVL_FUNCTION (val
);
4784 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
4785 return error_mark_node
;
4788 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4789 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
4790 is non-NULL, this type is being created by the implicit typename
4791 extension, and BASE_TYPE is a type named `t' in some base class of
4792 `T' which depends on template parameters.
4794 Returns the new TYPENAME_TYPE. */
4797 build_typename_type (context
, name
, fullname
, base_type
)
4806 if (processing_template_decl
)
4807 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4809 /* Build the TYPENAME_TYPE. */
4810 t
= make_lang_type (TYPENAME_TYPE
);
4811 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
4812 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
4813 TREE_TYPE (t
) = base_type
;
4814 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
4816 /* Build the corresponding TYPE_DECL. */
4817 d
= build_decl (TYPE_DECL
, name
, t
);
4818 TYPE_NAME (TREE_TYPE (d
)) = d
;
4819 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
4820 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
4822 if (processing_template_decl
)
4829 make_typename_type (context
, name
)
4835 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
4836 name
= TYPE_IDENTIFIER (name
);
4837 else if (TREE_CODE (name
) == TYPE_DECL
)
4838 name
= DECL_NAME (name
);
4842 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
4844 name
= TREE_OPERAND (name
, 0);
4845 if (TREE_CODE (name
) == TEMPLATE_DECL
)
4846 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
4848 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
4849 my_friendly_abort (2000);
4851 if (TREE_CODE (context
) == NAMESPACE_DECL
)
4853 /* We can get here from typename_sub0 in the explicit_template_type
4854 expansion. Just fail. */
4855 cp_error ("no class template named `%#T' in `%#T'",
4857 return error_mark_node
;
4860 if (! uses_template_parms (context
)
4861 || currently_open_class (context
))
4863 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
4865 if (IS_AGGR_TYPE (context
))
4866 t
= lookup_field (context
, name
, 0, 0);
4870 if (t
== NULL_TREE
|| TREE_CODE (t
) != TEMPLATE_DECL
4871 || TREE_CODE (DECL_RESULT (t
)) != TYPE_DECL
)
4873 cp_error ("no class template named `%#T' in `%#T'",
4875 return error_mark_node
;
4878 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
4880 /*entering_scope=*/0);
4884 if (IS_AGGR_TYPE (context
))
4885 t
= lookup_field (context
, name
, 0, 1);
4891 cp_error ("no type named `%#T' in `%#T'", name
, context
);
4892 return error_mark_node
;
4895 return TREE_TYPE (t
);
4899 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
4902 /* Select the right _DECL from multiple choices. */
4905 select_decl (binding
, flags
)
4910 val
= BINDING_VALUE (binding
);
4911 if (LOOKUP_NAMESPACES_ONLY (flags
))
4913 /* We are not interested in types. */
4914 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
4919 /* If we could have a type and
4920 we have nothing or we need a type and have none. */
4921 if (BINDING_TYPE (binding
)
4922 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
4923 && TREE_CODE (val
) != TYPE_DECL
)))
4924 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
4925 /* Don't return non-types if we really prefer types. */
4926 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
4927 && (!looking_for_template
|| TREE_CODE (val
) != TEMPLATE_DECL
))
4933 /* Unscoped lookup of a global, iterate over namespaces, considering
4934 using namespace statements. */
4937 unqualified_namespace_lookup (name
, flags
)
4941 struct tree_binding _binding
;
4942 tree b
= binding_init (&_binding
);
4943 tree initial
= current_decl_namespace();
4944 tree scope
= initial
;
4946 struct binding_level
*level
;
4947 tree val
= NULL_TREE
;
4951 val
= binding_for_name (name
, scope
);
4953 /* Initialize binding for this context. */
4954 BINDING_VALUE (b
) = BINDING_VALUE (val
);
4955 BINDING_TYPE (b
) = BINDING_TYPE (val
);
4957 /* Add all _DECLs seen through local using-directives. */
4958 for (level
= current_binding_level
;
4959 !level
->namespace_p
;
4960 level
= level
->level_chain
)
4961 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
4963 /* Give up because of error. */
4966 /* Add all _DECLs seen through global using-directives. */
4967 /* XXX local and global using lists should work equally. */
4971 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
4973 /* Give up because of error. */
4975 if (siter
== scope
) break;
4976 siter
= CP_DECL_CONTEXT (siter
);
4979 val
= select_decl (b
, flags
);
4980 if (scope
== global_namespace
)
4982 scope
= CP_DECL_CONTEXT (scope
);
4987 /* Combine prefer_type and namespaces_only into flags. */
4990 lookup_flags (prefer_type
, namespaces_only
)
4991 int prefer_type
, namespaces_only
;
4993 if (namespaces_only
)
4994 return LOOKUP_PREFER_NAMESPACES
;
4995 if (prefer_type
> 1)
4996 return LOOKUP_PREFER_TYPES
;
4997 if (prefer_type
> 0)
4998 return LOOKUP_PREFER_BOTH
;
5002 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5003 ignore it or not. Subroutine of lookup_name_real. */
5006 qualify_lookup (val
, flags
)
5010 if (val
== NULL_TREE
)
5012 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5014 if ((flags
& LOOKUP_PREFER_TYPES
)
5015 && (TREE_CODE (val
) == TYPE_DECL
5016 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5017 && DECL_CLASS_TEMPLATE_P (val
))))
5019 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5024 /* Look up NAME in the current binding level and its superiors in the
5025 namespace of variables, functions and typedefs. Return a ..._DECL
5026 node of some kind representing its definition if there is only one
5027 such declaration, or return a TREE_LIST with all the overloaded
5028 definitions if there are many, or return 0 if it is undefined.
5030 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5031 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5032 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5033 Otherwise we prefer non-TYPE_DECLs.
5035 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5036 using IDENTIFIER_CLASS_VALUE. */
5039 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5041 int prefer_type
, nonclass
, namespaces_only
;
5045 tree from_obj
= NULL_TREE
;
5046 tree locval
, classval
;
5049 /* Hack: copy flag set by parser, if set. */
5050 if (only_namespace_names
)
5051 namespaces_only
= 1;
5053 if (prefer_type
== -2)
5055 extern int looking_for_typename
;
5056 tree type
= NULL_TREE
;
5059 prefer_type
= looking_for_typename
;
5061 flags
= lookup_flags (prefer_type
, namespaces_only
);
5062 /* During parsing, we need to complain. */
5063 flags
|= LOOKUP_COMPLAIN
;
5064 /* If the next thing is '<', class templates are types. */
5065 if (looking_for_template
)
5066 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5068 /* std:: becomes :: for now. */
5069 if (got_scope
== std_node
)
5070 got_scope
= void_type_node
;
5074 else if (got_object
!= error_mark_node
)
5079 if (type
== error_mark_node
)
5080 return error_mark_node
;
5081 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5082 type
= TREE_TYPE (type
);
5085 type
= complete_type (type
);
5087 if (TREE_CODE (type
) == VOID_TYPE
)
5088 type
= global_namespace
;
5089 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5091 struct tree_binding b
;
5092 val
= binding_init (&b
);
5093 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5095 val
= select_decl (val
, flags
);
5097 else if (! IS_AGGR_TYPE (type
)
5098 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5099 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
5100 || TREE_CODE (type
) == TYPENAME_TYPE
)
5101 /* Someone else will give an error about this if needed. */
5103 else if (TYPE_BEING_DEFINED (type
))
5105 val
= IDENTIFIER_CLASS_VALUE (name
);
5106 if (val
&& DECL_CONTEXT (val
) != type
)
5108 struct binding_level
*b
= class_binding_level
;
5109 for (val
= NULL_TREE
; b
; b
= b
->level_chain
)
5111 tree t
= purpose_member (name
, b
->class_shadowed
);
5112 if (t
&& TREE_VALUE (t
)
5113 && DECL_CONTEXT (TREE_VALUE (t
)) == type
)
5115 val
= TREE_VALUE (t
);
5120 if (val
== NULL_TREE
)
5121 val
= lookup_field (type
, name
, 0, 1);
5123 else if (type
== current_class_type
)
5124 val
= IDENTIFIER_CLASS_VALUE (name
);
5126 val
= lookup_member (type
, name
, 0, prefer_type
);
5133 else if (got_object
&& val
)
5137 flags
= lookup_flags (prefer_type
, namespaces_only
);
5139 locval
= classval
= NULL_TREE
;
5141 if (! namespace_bindings_p ())
5142 locval
= qualify_lookup (IDENTIFIER_LOCAL_VALUE (name
), flags
);
5144 /* In C++ class fields are between local and global scope,
5145 just before the global scope. */
5146 if (current_class_type
&& ! nonclass
)
5148 classval
= IDENTIFIER_CLASS_VALUE (name
);
5149 if (classval
== NULL_TREE
&& TYPE_BEING_DEFINED (current_class_type
))
5150 /* Try to find values from base classes if we are presently
5151 defining a type. We are presently only interested in
5153 classval
= lookup_field (current_class_type
, name
, 0, 1);
5155 /* Add implicit 'typename' to types from template bases. lookup_field
5156 will do this for us. If classval is actually from an enclosing
5157 scope, lookup_nested_field will get it for us. */
5158 else if (processing_template_decl
5159 && classval
&& TREE_CODE (classval
) == TYPE_DECL
5160 && ! currently_open_class (DECL_CONTEXT (classval
))
5161 && uses_template_parms (current_class_type
))
5162 classval
= lookup_field (current_class_type
, name
, 0, 1);
5164 /* yylex() calls this with -2, since we should never start digging for
5165 the nested name at the point where we haven't even, for example,
5166 created the COMPONENT_REF or anything like that. */
5167 if (classval
== NULL_TREE
)
5168 classval
= lookup_nested_field (name
, ! yylex
);
5170 classval
= qualify_lookup (classval
, flags
);
5173 if (locval
&& classval
)
5175 /* We have both a local binding and a class-level binding. This
5176 can happen in two ways:
5178 o We are in a member function of a class.
5179 o We are in a local class within a function.
5181 We need to determine which one of these situations is
5182 occuring, and give the innermost binding. One tricky bit is
5183 that with member templates we can be in the first case
5184 without CURRENT_FUNCTION_DECL being set. Consider
5186 struct A { template <class A> void f(A); };
5188 Here, when we look at the `A' in the parameter declaration
5189 for `f' we have a local binding (the template parameter) and
5190 a class-level binding (the TYPE_DECL for the class).
5191 Fortunately, if LOCVAL is a template parameter it is safe to
5192 take it; nothing within the scope of the template parameter
5193 is allowed to have the same name. */
5195 if (decl_template_parm_p (locval
))
5197 else if (current_scope () == current_function_decl
5198 && ! hack_decl_function_context (current_function_decl
))
5199 /* Not in a nested function. */
5203 /* This is incredibly horrible. The whole concept of
5204 IDENTIFIER_LOCAL_VALUE / IDENTIFIER_CLASS_VALUE /
5205 IDENTIFIER_GLOBAL_VALUE needs to be scrapped for local
5207 tree lctx
= hack_decl_function_context (locval
);
5208 tree cctx
= hack_decl_function_context (classval
);
5210 if (lctx
== current_scope ())
5212 else if (lctx
== cctx
)
5215 /* I don't know which is right; let's just guess for now. */
5224 val
= unqualified_namespace_lookup (name
, flags
);
5226 /* Any other name takes precedence over an implicit typename. Warn the
5227 user about this potentially confusing lookup. */
5228 if (classval
&& TREE_CODE (val
) == TYPE_DECL
5229 && TREE_CODE (TREE_TYPE (val
)) == TYPENAME_TYPE
5230 && TREE_TYPE (TREE_TYPE (val
)))
5232 if (locval
== NULL_TREE
)
5233 locval
= unqualified_namespace_lookup (name
, flags
);
5235 if (locval
&& val
!= locval
)
5241 /* Only warn when not lexing; we don't want to warn if they
5242 use this name as a declarator. */
5243 subtype
= TREE_TYPE (TREE_TYPE (classval
));
5245 && ! (TREE_CODE (locval
) == TEMPLATE_DECL
5246 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5247 && CLASSTYPE_TI_TEMPLATE (subtype
) == locval
)
5248 && ! (TREE_CODE (locval
) == TYPE_DECL
5249 && same_type_p (TREE_TYPE (locval
), subtype
)))
5251 cp_warning ("lookup of `%D' finds `%#D'", name
, locval
);
5252 cp_warning (" instead of `%D' from dependent base class",
5254 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5255 constructor_name (current_class_type
), name
);
5263 /* This should only warn about types used in qualified-ids. */
5264 if (from_obj
&& from_obj
!= val
)
5266 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
5267 && TREE_CODE (val
) == TYPE_DECL
5268 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
5270 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5271 name
, got_object
, TREE_TYPE (from_obj
));
5272 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5276 /* We don't change val to from_obj if got_object depends on
5277 template parms because that breaks implicit typename for
5278 destructor calls. */
5279 if (! uses_template_parms (got_object
))
5283 if ((TREE_CODE (val
) == TEMPLATE_DECL
&& looking_for_template
)
5284 || TREE_CODE (val
) == TYPE_DECL
|| prefer_type
<= 0)
5286 /* Caller wants a class-or-namespace-name. */
5287 else if (prefer_type
== 1 && TREE_CODE (val
) == NAMESPACE_DECL
)
5289 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
5290 val
= TYPE_MAIN_DECL (IDENTIFIER_TYPE_VALUE (name
));
5291 else if (TREE_TYPE (val
) == error_mark_node
)
5292 val
= error_mark_node
;
5294 /* If we have a single function from a using decl, pull it out. */
5295 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5296 val
= OVL_FUNCTION (val
);
5305 lookup_name_nonclass (name
)
5308 return lookup_name_real (name
, 0, 1, 0);
5312 lookup_function_nonclass (name
, args
)
5316 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
5320 lookup_name_namespace_only (name
)
5323 /* type-or-namespace, nonclass, namespace_only */
5324 return lookup_name_real (name
, 1, 1, 1);
5328 lookup_name (name
, prefer_type
)
5332 return lookup_name_real (name
, prefer_type
, 0, 0);
5335 /* Similar to `lookup_name' but look only at current binding level. */
5338 lookup_name_current_level (name
)
5341 register tree t
= NULL_TREE
;
5343 if (current_binding_level
->namespace_p
)
5345 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5347 /* extern "C" function() */
5348 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5351 else if (IDENTIFIER_LOCAL_VALUE (name
) != NULL_TREE
)
5353 struct binding_level
*b
= current_binding_level
;
5356 if (purpose_member (name
, b
->shadowed
))
5357 return IDENTIFIER_LOCAL_VALUE (name
);
5368 /* Like lookup_name_current_level, but for types. */
5371 lookup_type_current_level (name
)
5374 register tree t
= NULL_TREE
;
5376 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
5378 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5379 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5381 struct binding_level
*b
= current_binding_level
;
5384 if (purpose_member (name
, b
->type_shadowed
))
5385 return REAL_IDENTIFIER_TYPE_VALUE (name
);
5397 begin_only_namespace_names ()
5399 only_namespace_names
= 1;
5403 end_only_namespace_names ()
5405 only_namespace_names
= 0;
5408 /* Arrange for the user to get a source line number, even when the
5409 compiler is going down in flames, so that she at least has a
5410 chance of working around problems in the compiler. We used to
5411 call error(), but that let the segmentation fault continue
5412 through; now, it's much more passive by asking them to send the
5413 maintainers mail about the problem. */
5417 int sig ATTRIBUTE_UNUSED
;
5419 signal (SIGSEGV
, SIG_DFL
);
5421 signal (SIGIOT
, SIG_DFL
);
5424 signal (SIGILL
, SIG_DFL
);
5427 signal (SIGABRT
, SIG_DFL
);
5430 signal (SIGBUS
, SIG_DFL
);
5432 my_friendly_abort (0);
5436 /* Unused -- brendan 970107 */
5437 /* Array for holding types considered "built-in". These types
5438 are output in the module in which `main' is defined. */
5439 static tree
*builtin_type_tdescs_arr
;
5440 static int builtin_type_tdescs_len
, builtin_type_tdescs_max
;
5443 /* Push the declarations of builtin types into the namespace.
5444 RID_INDEX, if < RID_MAX is the index of the builtin type
5445 in the array RID_POINTERS. NAME is the name used when looking
5446 up the builtin type. TYPE is the _TYPE node for the builtin type. */
5449 record_builtin_type (rid_index
, name
, type
)
5454 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
5455 tree tdecl
= NULL_TREE
;
5457 if ((int) rid_index
< (int) RID_MAX
)
5458 rname
= ridpointers
[(int) rid_index
];
5460 tname
= get_identifier (name
);
5462 TYPE_BUILT_IN (type
) = 1;
5466 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
5467 set_identifier_type_value (tname
, NULL_TREE
);
5468 if ((int) rid_index
< (int) RID_MAX
)
5469 /* Built-in types live in the global namespace. */
5470 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
5472 if (rname
!= NULL_TREE
)
5474 if (tname
!= NULL_TREE
)
5476 set_identifier_type_value (rname
, NULL_TREE
);
5477 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
5481 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
5482 set_identifier_type_value (rname
, NULL_TREE
);
5487 /* Record one of the standard Java types.
5488 * Declare it as having the given NAME.
5489 * If SIZE > 0, it is the size of one of the integral types;
5490 * otherwise it is the negative of the size of one of the other types. */
5493 record_builtin_java_type (name
, size
)
5499 type
= make_signed_type (size
);
5500 else if (size
> -32)
5501 { /* "__java_char" or ""__java_boolean". */
5502 type
= make_unsigned_type (-size
);
5503 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5506 { /* "__java_float" or ""__java_double". */
5507 type
= make_node (REAL_TYPE
);
5508 TYPE_PRECISION (type
) = - size
;
5511 record_builtin_type (RID_MAX
, name
, type
);
5512 decl
= TYPE_NAME (type
);
5513 DECL_IGNORED_P (decl
) = 1;
5514 TYPE_FOR_JAVA (type
) = 1;
5518 /* Push a type into the namespace so that the back-ends ignore it. */
5521 record_unknown_type (type
, name
)
5525 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
5526 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
5527 DECL_IGNORED_P (decl
) = 1;
5528 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
5529 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
5530 TYPE_ALIGN (type
) = 1;
5531 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
5534 /* Push overloaded decl, in global scope, with one argument so it
5535 can be used as a callback from define_function. */
5538 push_overloaded_decl_1 (x
)
5541 push_overloaded_decl (x
, 0);
5548 auto_function (name
, type
, code
)
5550 enum built_in_function code
;
5552 return define_function
5553 (IDENTIFIER_POINTER (name
), type
, code
, push_overloaded_decl_1
,
5554 IDENTIFIER_POINTER (build_decl_overload (name
, TYPE_ARG_TYPES (type
),
5558 /* Create the predefined scalar types of C,
5559 and some nodes representing standard constants (0, 1, (void *)0).
5560 Initialize the global binding level.
5561 Make definitions for built-in primitive functions. */
5564 init_decl_processing ()
5566 register tree endlink
, int_endlink
, double_endlink
, unsigned_endlink
;
5568 /* Data type of memcpy. */
5569 tree memcpy_ftype
, strlen_ftype
;
5570 int wchar_type_size
;
5572 tree array_domain_type
;
5573 tree vb_off_identifier
= NULL_TREE
;
5574 /* Function type `char *(char *, char *)' and similar ones */
5575 tree string_ftype_ptr_ptr
, int_ftype_string_string
;
5576 tree sizetype_endlink
;
5577 tree ptr_ftype
, ptr_ftype_unsigned
, ptr_ftype_sizetype
;
5578 tree void_ftype
, void_ftype_int
, void_ftype_ptr
;
5580 /* Have to make these distinct before we try using them. */
5581 lang_name_cplusplus
= get_identifier ("C++");
5582 lang_name_c
= get_identifier ("C");
5583 lang_name_java
= get_identifier ("Java");
5585 /* Enter the global namespace. */
5586 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
5587 my_friendly_assert (current_lang_name
== NULL_TREE
, 375);
5588 current_lang_name
= lang_name_cplusplus
;
5589 push_namespace (get_identifier ("::"));
5590 global_namespace
= current_namespace
;
5591 current_lang_name
= NULL_TREE
;
5593 if (flag_strict_prototype
== 2)
5594 flag_strict_prototype
= pedantic
;
5596 strict_prototypes_lang_c
= flag_strict_prototype
;
5599 current_lang_name
= lang_name_c
;
5601 current_function_decl
= NULL_TREE
;
5602 named_labels
= NULL_TREE
;
5603 named_label_uses
= NULL
;
5604 current_binding_level
= NULL_BINDING_LEVEL
;
5605 free_binding_level
= NULL_BINDING_LEVEL
;
5607 /* Because most segmentation signals can be traced back into user
5608 code, catch them and at least give the user a chance of working
5609 around compiler bugs. */
5610 signal (SIGSEGV
, signal_catch
);
5612 /* We will also catch aborts in the back-end through signal_catch and
5613 give the user a chance to see where the error might be, and to defeat
5614 aborts in the back-end when there have been errors previously in their
5617 signal (SIGIOT
, signal_catch
);
5620 signal (SIGILL
, signal_catch
);
5623 signal (SIGABRT
, signal_catch
);
5626 signal (SIGBUS
, signal_catch
);
5629 gcc_obstack_init (&decl_obstack
);
5631 /* Must lay these out before anything else gets laid out. */
5632 error_mark_node
= make_node (ERROR_MARK
);
5633 TREE_PERMANENT (error_mark_node
) = 1;
5634 TREE_TYPE (error_mark_node
) = error_mark_node
;
5635 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
5636 TREE_TYPE (error_mark_list
) = error_mark_node
;
5638 /* Make the binding_level structure for global names. */
5640 global_binding_level
= current_binding_level
;
5641 /* The global level is the namespace level of ::. */
5642 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
5643 declare_namespace_level ();
5645 this_identifier
= get_identifier (THIS_NAME
);
5646 in_charge_identifier
= get_identifier (IN_CHARGE_NAME
);
5647 ctor_identifier
= get_identifier (CTOR_NAME
);
5648 dtor_identifier
= get_identifier (DTOR_NAME
);
5649 pfn_identifier
= get_identifier (VTABLE_PFN_NAME
);
5650 index_identifier
= get_identifier (VTABLE_INDEX_NAME
);
5651 delta_identifier
= get_identifier (VTABLE_DELTA_NAME
);
5652 delta2_identifier
= get_identifier (VTABLE_DELTA2_NAME
);
5653 pfn_or_delta2_identifier
= get_identifier ("__pfn_or_delta2");
5654 if (flag_handle_signatures
)
5656 tag_identifier
= get_identifier (SIGTABLE_TAG_NAME
);
5657 vb_off_identifier
= get_identifier (SIGTABLE_VB_OFF_NAME
);
5658 vt_off_identifier
= get_identifier (SIGTABLE_VT_OFF_NAME
);
5661 /* Define `int' and `char' first so that dbx will output them first. */
5663 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
5664 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
5666 /* Define `char', which is like either `signed char' or `unsigned char'
5667 but not the same as either. */
5671 ? make_signed_type (CHAR_TYPE_SIZE
)
5672 : make_unsigned_type (CHAR_TYPE_SIZE
));
5673 record_builtin_type (RID_CHAR
, "char", char_type_node
);
5675 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
5676 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
5678 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
5679 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
5681 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
5682 record_builtin_type (RID_MAX
, "long unsigned int", long_unsigned_type_node
);
5683 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
5685 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
5686 record_builtin_type (RID_MAX
, "long long int", long_long_integer_type_node
);
5688 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
5689 record_builtin_type (RID_MAX
, "long long unsigned int",
5690 long_long_unsigned_type_node
);
5691 record_builtin_type (RID_MAX
, "long long unsigned",
5692 long_long_unsigned_type_node
);
5694 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
5695 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
5696 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
5697 record_builtin_type (RID_MAX
, "short unsigned int", short_unsigned_type_node
);
5698 record_builtin_type (RID_MAX
, "unsigned short", short_unsigned_type_node
);
5700 /* `unsigned long' is the standard type for sizeof.
5701 Note that stddef.h uses `unsigned long',
5702 and this must agree, even if long and int are the same size. */
5704 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
5707 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
5709 /* Define both `signed char' and `unsigned char'. */
5710 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
5711 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
5712 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
5713 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
5715 /* These are types that type_for_size and type_for_mode use. */
5716 intQI_type_node
= make_signed_type (GET_MODE_BITSIZE (QImode
));
5717 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
5718 intHI_type_node
= make_signed_type (GET_MODE_BITSIZE (HImode
));
5719 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
5720 intSI_type_node
= make_signed_type (GET_MODE_BITSIZE (SImode
));
5721 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
5722 intDI_type_node
= make_signed_type (GET_MODE_BITSIZE (DImode
));
5723 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
5724 #if HOST_BITS_PER_WIDE_INT >= 64
5725 intTI_type_node
= make_signed_type (GET_MODE_BITSIZE (TImode
));
5726 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intTI_type_node
));
5728 unsigned_intQI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (QImode
));
5729 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
5730 unsigned_intHI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (HImode
));
5731 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
5732 unsigned_intSI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (SImode
));
5733 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
5734 unsigned_intDI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (DImode
));
5735 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
5736 #if HOST_BITS_PER_WIDE_INT >= 64
5737 unsigned_intTI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (TImode
));
5738 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intTI_type_node
));
5741 float_type_node
= make_node (REAL_TYPE
);
5742 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
5743 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
5744 layout_type (float_type_node
);
5746 double_type_node
= make_node (REAL_TYPE
);
5747 if (flag_short_double
)
5748 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
5750 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
5751 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
5752 layout_type (double_type_node
);
5754 long_double_type_node
= make_node (REAL_TYPE
);
5755 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
5756 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
5757 layout_type (long_double_type_node
);
5759 complex_integer_type_node
= make_node (COMPLEX_TYPE
);
5760 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
5761 complex_integer_type_node
));
5762 TREE_TYPE (complex_integer_type_node
) = integer_type_node
;
5763 layout_type (complex_integer_type_node
);
5765 complex_float_type_node
= make_node (COMPLEX_TYPE
);
5766 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
5767 complex_float_type_node
));
5768 TREE_TYPE (complex_float_type_node
) = float_type_node
;
5769 layout_type (complex_float_type_node
);
5771 complex_double_type_node
= make_node (COMPLEX_TYPE
);
5772 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
5773 complex_double_type_node
));
5774 TREE_TYPE (complex_double_type_node
) = double_type_node
;
5775 layout_type (complex_double_type_node
);
5777 complex_long_double_type_node
= make_node (COMPLEX_TYPE
);
5778 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
5779 complex_long_double_type_node
));
5780 TREE_TYPE (complex_long_double_type_node
) = long_double_type_node
;
5781 layout_type (complex_long_double_type_node
);
5783 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
5784 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
5785 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
5786 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
5787 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
5788 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
5789 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
5790 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
5792 integer_zero_node
= build_int_2 (0, 0);
5793 TREE_TYPE (integer_zero_node
) = integer_type_node
;
5794 integer_one_node
= build_int_2 (1, 0);
5795 TREE_TYPE (integer_one_node
) = integer_type_node
;
5796 integer_two_node
= build_int_2 (2, 0);
5797 TREE_TYPE (integer_two_node
) = integer_type_node
;
5798 integer_three_node
= build_int_2 (3, 0);
5799 TREE_TYPE (integer_three_node
) = integer_type_node
;
5801 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
5802 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
5803 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
5804 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
5805 TYPE_PRECISION (boolean_type_node
) = 1;
5806 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
5807 boolean_false_node
= build_int_2 (0, 0);
5808 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
5809 boolean_true_node
= build_int_2 (1, 0);
5810 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
5812 /* These are needed by stor-layout.c. */
5813 size_zero_node
= size_int (0);
5814 size_one_node
= size_int (1);
5816 signed_size_zero_node
= build_int_2 (0, 0);
5817 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
5819 void_type_node
= make_node (VOID_TYPE
);
5820 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
5821 layout_type (void_type_node
); /* Uses integer_zero_node. */
5822 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
5823 TREE_PARMLIST (void_list_node
) = 1;
5825 null_pointer_node
= build_int_2 (0, 0);
5826 TREE_TYPE (null_pointer_node
) = build_pointer_type (void_type_node
);
5827 layout_type (TREE_TYPE (null_pointer_node
));
5829 /* Used for expressions that do nothing, but are not errors. */
5830 void_zero_node
= build_int_2 (0, 0);
5831 TREE_TYPE (void_zero_node
) = void_type_node
;
5833 string_type_node
= build_pointer_type (char_type_node
);
5834 const_string_type_node
5835 = build_pointer_type (build_qualified_type (char_type_node
,
5838 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
5841 /* Make a type to be the domain of a few array types
5842 whose domains don't really matter.
5843 200 is small enough that it always fits in size_t
5844 and large enough that it can hold most function names for the
5845 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5846 array_domain_type
= build_index_type (build_int_2 (200, 0));
5848 /* Make a type for arrays of characters.
5849 With luck nothing will ever really depend on the length of this
5851 char_array_type_node
5852 = build_array_type (char_type_node
, array_domain_type
);
5853 /* Likewise for arrays of ints. */
5855 = build_array_type (integer_type_node
, array_domain_type
);
5857 /* This is just some anonymous class type. Nobody should ever
5858 need to look inside this envelope. */
5859 class_star_type_node
= build_pointer_type (make_lang_type (RECORD_TYPE
));
5861 default_function_type
5862 = build_function_type (integer_type_node
, NULL_TREE
);
5864 ptr_type_node
= build_pointer_type (void_type_node
);
5866 = build_pointer_type (build_qualified_type (void_type_node
,
5869 record_builtin_type (RID_MAX
, NULL_PTR
, ptr_type_node
);
5871 endlink
= void_list_node
;
5872 int_endlink
= tree_cons (NULL_TREE
, integer_type_node
, endlink
);
5873 double_endlink
= tree_cons (NULL_TREE
, double_type_node
, endlink
);
5874 unsigned_endlink
= tree_cons (NULL_TREE
, unsigned_type_node
, endlink
);
5876 ptr_ftype
= build_function_type (ptr_type_node
, NULL_TREE
);
5877 ptr_ftype_unsigned
= build_function_type (ptr_type_node
, unsigned_endlink
);
5878 sizetype_endlink
= tree_cons (NULL_TREE
, sizetype
, endlink
);
5879 /* We realloc here because sizetype could be int or unsigned. S'ok. */
5880 ptr_ftype_sizetype
= build_function_type (ptr_type_node
, sizetype_endlink
);
5882 void_ftype
= build_function_type (void_type_node
, endlink
);
5883 void_ftype_int
= build_function_type (void_type_node
, int_endlink
);
5885 = build_function_type (void_type_node
,
5886 tree_cons (NULL_TREE
, ptr_type_node
, endlink
));
5888 = build_exception_variant (void_ftype_ptr
,
5889 tree_cons (NULL_TREE
, NULL_TREE
, NULL_TREE
));
5892 = build_function_type (float_type_node
,
5893 tree_cons (NULL_TREE
, float_type_node
, endlink
));
5896 = build_function_type (double_type_node
, double_endlink
);
5898 ldouble_ftype_ldouble
5899 = build_function_type (long_double_type_node
,
5900 tree_cons (NULL_TREE
, long_double_type_node
,
5903 double_ftype_double_double
5904 = build_function_type (double_type_node
,
5905 tree_cons (NULL_TREE
, double_type_node
,
5909 = build_function_type (integer_type_node
, int_endlink
);
5912 = build_function_type (long_integer_type_node
,
5913 tree_cons (NULL_TREE
, long_integer_type_node
,
5916 int_ftype_cptr_cptr_sizet
5917 = build_function_type (integer_type_node
,
5918 tree_cons (NULL_TREE
, const_ptr_type_node
,
5919 tree_cons (NULL_TREE
, const_ptr_type_node
,
5920 tree_cons (NULL_TREE
,
5924 string_ftype_ptr_ptr
/* strcpy prototype */
5925 = build_function_type (string_type_node
,
5926 tree_cons (NULL_TREE
, string_type_node
,
5927 tree_cons (NULL_TREE
,
5928 const_string_type_node
,
5931 int_ftype_string_string
/* strcmp prototype */
5932 = build_function_type (integer_type_node
,
5933 tree_cons (NULL_TREE
, const_string_type_node
,
5934 tree_cons (NULL_TREE
,
5935 const_string_type_node
,
5938 strlen_ftype
/* strlen prototype */
5939 = build_function_type (sizetype
,
5940 tree_cons (NULL_TREE
, const_string_type_node
,
5943 memcpy_ftype
/* memcpy prototype */
5944 = build_function_type (ptr_type_node
,
5945 tree_cons (NULL_TREE
, ptr_type_node
,
5946 tree_cons (NULL_TREE
, const_ptr_type_node
,
5947 sizetype_endlink
)));
5949 if (flag_huge_objects
)
5950 delta_type_node
= long_integer_type_node
;
5952 delta_type_node
= short_integer_type_node
;
5954 builtin_function ("__builtin_constant_p", default_function_type
,
5955 BUILT_IN_CONSTANT_P
, NULL_PTR
);
5957 builtin_return_address_fndecl
5958 = builtin_function ("__builtin_return_address", ptr_ftype_unsigned
,
5959 BUILT_IN_RETURN_ADDRESS
, NULL_PTR
);
5961 builtin_function ("__builtin_frame_address", ptr_ftype_unsigned
,
5962 BUILT_IN_FRAME_ADDRESS
, NULL_PTR
);
5964 builtin_function ("__builtin_alloca", ptr_ftype_sizetype
,
5965 BUILT_IN_ALLOCA
, "alloca");
5966 builtin_function ("__builtin_ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
5967 /* Define alloca, ffs as builtins.
5968 Declare _exit just to mark it as volatile. */
5969 if (! flag_no_builtin
&& !flag_no_nonansi_builtin
)
5971 temp
= builtin_function ("alloca", ptr_ftype_sizetype
,
5972 BUILT_IN_ALLOCA
, NULL_PTR
);
5973 /* Suppress error if redefined as a non-function. */
5974 DECL_BUILT_IN_NONANSI (temp
) = 1;
5975 temp
= builtin_function ("ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
5976 /* Suppress error if redefined as a non-function. */
5977 DECL_BUILT_IN_NONANSI (temp
) = 1;
5978 temp
= builtin_function ("_exit", void_ftype_int
,
5979 NOT_BUILT_IN
, NULL_PTR
);
5980 TREE_THIS_VOLATILE (temp
) = 1;
5981 TREE_SIDE_EFFECTS (temp
) = 1;
5982 /* Suppress error if redefined as a non-function. */
5983 DECL_BUILT_IN_NONANSI (temp
) = 1;
5986 builtin_function ("__builtin_abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
5987 builtin_function ("__builtin_fabsf", float_ftype_float
, BUILT_IN_FABS
,
5989 builtin_function ("__builtin_fabs", double_ftype_double
, BUILT_IN_FABS
,
5991 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
5993 builtin_function ("__builtin_labs", long_ftype_long
,
5994 BUILT_IN_LABS
, NULL_PTR
);
5995 builtin_function ("__builtin_saveregs", ptr_ftype
,
5996 BUILT_IN_SAVEREGS
, NULL_PTR
);
5997 builtin_function ("__builtin_classify_type", default_function_type
,
5998 BUILT_IN_CLASSIFY_TYPE
, NULL_PTR
);
5999 builtin_function ("__builtin_next_arg", ptr_ftype
,
6000 BUILT_IN_NEXT_ARG
, NULL_PTR
);
6001 builtin_function ("__builtin_args_info", int_ftype_int
,
6002 BUILT_IN_ARGS_INFO
, NULL_PTR
);
6003 builtin_function ("__builtin_setjmp",
6004 build_function_type (integer_type_node
,
6005 tree_cons (NULL_TREE
, ptr_type_node
,
6007 BUILT_IN_SETJMP
, NULL_PTR
);
6008 builtin_function ("__builtin_longjmp",
6009 build_function_type (integer_type_node
,
6010 tree_cons (NULL_TREE
, ptr_type_node
,
6011 tree_cons (NULL_TREE
,
6014 BUILT_IN_LONGJMP
, NULL_PTR
);
6016 /* Untyped call and return. */
6017 builtin_function ("__builtin_apply_args", ptr_ftype
,
6018 BUILT_IN_APPLY_ARGS
, NULL_PTR
);
6020 temp
= tree_cons (NULL_TREE
,
6021 build_pointer_type (build_function_type (void_type_node
,
6023 tree_cons (NULL_TREE
, ptr_ftype_sizetype
, NULL_TREE
));
6024 builtin_function ("__builtin_apply",
6025 build_function_type (ptr_type_node
, temp
),
6026 BUILT_IN_APPLY
, NULL_PTR
);
6027 builtin_function ("__builtin_return", void_ftype_ptr
,
6028 BUILT_IN_RETURN
, NULL_PTR
);
6030 /* Currently under experimentation. */
6031 builtin_function ("__builtin_memcpy", memcpy_ftype
,
6032 BUILT_IN_MEMCPY
, "memcpy");
6033 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet
,
6034 BUILT_IN_MEMCMP
, "memcmp");
6035 builtin_function ("__builtin_strcmp", int_ftype_string_string
,
6036 BUILT_IN_STRCMP
, "strcmp");
6037 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr
,
6038 BUILT_IN_STRCPY
, "strcpy");
6039 builtin_function ("__builtin_strlen", strlen_ftype
,
6040 BUILT_IN_STRLEN
, "strlen");
6041 builtin_function ("__builtin_sqrtf", float_ftype_float
,
6042 BUILT_IN_FSQRT
, "sqrtf");
6043 builtin_function ("__builtin_fsqrt", double_ftype_double
,
6044 BUILT_IN_FSQRT
, NULL_PTR
);
6045 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble
,
6046 BUILT_IN_FSQRT
, "sqrtl");
6047 builtin_function ("__builtin_sinf", float_ftype_float
,
6048 BUILT_IN_SIN
, "sinf");
6049 builtin_function ("__builtin_sin", double_ftype_double
,
6050 BUILT_IN_SIN
, "sin");
6051 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble
,
6052 BUILT_IN_SIN
, "sinl");
6053 builtin_function ("__builtin_cosf", float_ftype_float
,
6054 BUILT_IN_COS
, "cosf");
6055 builtin_function ("__builtin_cos", double_ftype_double
,
6056 BUILT_IN_COS
, "cos");
6057 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble
,
6058 BUILT_IN_COS
, "cosl");
6060 if (!flag_no_builtin
)
6062 builtin_function ("abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
6063 builtin_function ("fabs", double_ftype_double
, BUILT_IN_FABS
, NULL_PTR
);
6064 builtin_function ("labs", long_ftype_long
, BUILT_IN_LABS
, NULL_PTR
);
6065 builtin_function ("fabsf", float_ftype_float
, BUILT_IN_FABS
, NULL_PTR
);
6066 builtin_function ("fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
6068 builtin_function ("memcpy", memcpy_ftype
, BUILT_IN_MEMCPY
, NULL_PTR
);
6069 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet
, BUILT_IN_MEMCMP
,
6071 builtin_function ("strcmp", int_ftype_string_string
, BUILT_IN_STRCMP
,
6073 builtin_function ("strcpy", string_ftype_ptr_ptr
, BUILT_IN_STRCPY
,
6075 builtin_function ("strlen", strlen_ftype
, BUILT_IN_STRLEN
, NULL_PTR
);
6076 builtin_function ("sqrtf", float_ftype_float
, BUILT_IN_FSQRT
, NULL_PTR
);
6077 builtin_function ("sqrt", double_ftype_double
, BUILT_IN_FSQRT
, NULL_PTR
);
6078 builtin_function ("sqrtl", ldouble_ftype_ldouble
, BUILT_IN_FSQRT
,
6080 builtin_function ("sinf", float_ftype_float
, BUILT_IN_SIN
, NULL_PTR
);
6081 builtin_function ("sin", double_ftype_double
, BUILT_IN_SIN
, NULL_PTR
);
6082 builtin_function ("sinl", ldouble_ftype_ldouble
, BUILT_IN_SIN
, NULL_PTR
);
6083 builtin_function ("cosf", float_ftype_float
, BUILT_IN_COS
, NULL_PTR
);
6084 builtin_function ("cos", double_ftype_double
, BUILT_IN_COS
, NULL_PTR
);
6085 builtin_function ("cosl", ldouble_ftype_ldouble
, BUILT_IN_COS
, NULL_PTR
);
6087 /* Declare these functions volatile
6088 to avoid spurious "control drops through" warnings. */
6089 temp
= builtin_function ("abort", void_ftype
,
6090 NOT_BUILT_IN
, NULL_PTR
);
6091 TREE_THIS_VOLATILE (temp
) = 1;
6092 TREE_SIDE_EFFECTS (temp
) = 1;
6093 /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
6095 DECL_BUILT_IN_NONANSI (temp
) = 1;
6096 temp
= builtin_function ("exit", void_ftype_int
,
6097 NOT_BUILT_IN
, NULL_PTR
);
6098 TREE_THIS_VOLATILE (temp
) = 1;
6099 TREE_SIDE_EFFECTS (temp
) = 1;
6100 DECL_BUILT_IN_NONANSI (temp
) = 1;
6104 /* Support for these has not been written in either expand_builtin
6105 or build_function_call. */
6106 builtin_function ("__builtin_div", default_ftype
, BUILT_IN_DIV
, NULL_PTR
);
6107 builtin_function ("__builtin_ldiv", default_ftype
, BUILT_IN_LDIV
, NULL_PTR
);
6108 builtin_function ("__builtin_ffloor", double_ftype_double
, BUILT_IN_FFLOOR
,
6110 builtin_function ("__builtin_fceil", double_ftype_double
, BUILT_IN_FCEIL
,
6112 builtin_function ("__builtin_fmod", double_ftype_double_double
,
6113 BUILT_IN_FMOD
, NULL_PTR
);
6114 builtin_function ("__builtin_frem", double_ftype_double_double
,
6115 BUILT_IN_FREM
, NULL_PTR
);
6116 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int
,
6117 BUILT_IN_MEMSET
, NULL_PTR
);
6118 builtin_function ("__builtin_getexp", double_ftype_double
, BUILT_IN_GETEXP
,
6120 builtin_function ("__builtin_getman", double_ftype_double
, BUILT_IN_GETMAN
,
6124 /* C++ extensions */
6126 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6127 record_unknown_type (unknown_type_node
, "unknown type");
6129 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6130 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6132 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6134 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6136 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6137 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6139 /* This is for handling opaque types in signatures. */
6140 opaque_type_node
= copy_node (ptr_type_node
);
6141 TYPE_MAIN_VARIANT (opaque_type_node
) = opaque_type_node
;
6142 record_builtin_type (RID_MAX
, 0, opaque_type_node
);
6144 /* This is special for C++ so functions can be overloaded. */
6146 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE
)));
6147 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6148 signed_wchar_type_node
= make_signed_type (wchar_type_size
);
6149 unsigned_wchar_type_node
= make_unsigned_type (wchar_type_size
);
6151 = TREE_UNSIGNED (wchar_type_node
)
6152 ? unsigned_wchar_type_node
6153 : signed_wchar_type_node
;
6154 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6156 /* Artificial declaration of wchar_t -- can be bashed */
6157 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6159 pushdecl (wchar_decl_node
);
6161 /* This is for wide string constants. */
6162 wchar_array_type_node
6163 = build_array_type (wchar_type_node
, array_domain_type
);
6165 if (flag_vtable_thunks
)
6167 /* Make sure we get a unique function type, so we can give
6168 its pointer type a name. (This wins for gdb.) */
6169 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6170 TREE_TYPE (vfunc_type
) = integer_type_node
;
6171 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6172 layout_type (vfunc_type
);
6174 vtable_entry_type
= build_pointer_type (vfunc_type
);
6178 vtable_entry_type
= make_lang_type (RECORD_TYPE
);
6179 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
6181 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
6183 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
6185 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6188 /* Make this part of an invisible union. */
6189 fields
[3] = copy_node (fields
[2]);
6190 TREE_TYPE (fields
[3]) = delta_type_node
;
6191 DECL_NAME (fields
[3]) = delta2_identifier
;
6192 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6193 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6194 TREE_UNSIGNED (fields
[3]) = 0;
6195 TREE_CHAIN (fields
[2]) = fields
[3];
6196 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6199 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6202 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
6203 layout_type (vtbl_type_node
);
6204 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6205 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6206 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6207 layout_type (vtbl_ptr_type_node
);
6208 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6210 /* Simplify life by making a "sigtable_entry_type". Give its
6211 fields names so that the debugger can use them. */
6213 if (flag_handle_signatures
)
6215 sigtable_entry_type
= make_lang_type (RECORD_TYPE
);
6216 fields
[0] = build_lang_field_decl (FIELD_DECL
, tag_identifier
,
6218 fields
[1] = build_lang_field_decl (FIELD_DECL
, vb_off_identifier
,
6220 fields
[2] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
6222 fields
[3] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
6224 fields
[4] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
6227 /* Set the alignment to the max of the alignment of ptr_type_node and
6228 delta_type_node. Double alignment wastes a word on the Sparc. */
6229 finish_builtin_type (sigtable_entry_type
, SIGTABLE_PTR_TYPE
, fields
, 4,
6230 (TYPE_ALIGN (ptr_type_node
) > TYPE_ALIGN (delta_type_node
))
6234 /* Make this part of an invisible union. */
6235 fields
[5] = copy_node (fields
[4]);
6236 TREE_TYPE (fields
[5]) = delta_type_node
;
6237 DECL_NAME (fields
[5]) = vt_off_identifier
;
6238 DECL_MODE (fields
[5]) = TYPE_MODE (delta_type_node
);
6239 DECL_SIZE (fields
[5]) = TYPE_SIZE (delta_type_node
);
6240 TREE_UNSIGNED (fields
[5]) = 0;
6241 TREE_CHAIN (fields
[4]) = fields
[5];
6243 sigtable_entry_type
= build_qualified_type (sigtable_entry_type
,
6245 record_builtin_type (RID_MAX
, SIGTABLE_PTR_TYPE
, sigtable_entry_type
);
6248 std_node
= build_decl (NAMESPACE_DECL
,
6249 get_identifier (flag_honor_std
? "fake std":"std"),
6251 pushdecl (std_node
);
6253 global_type_node
= make_node (LANG_TYPE
);
6254 record_unknown_type (global_type_node
, "global type");
6257 current_lang_name
= lang_name_cplusplus
;
6260 tree bad_alloc_type_node
, newtype
, deltype
;
6262 push_namespace (get_identifier ("std"));
6263 bad_alloc_type_node
= xref_tag
6264 (class_type_node
, get_identifier ("bad_alloc"), 1);
6267 newtype
= build_exception_variant
6268 (ptr_ftype_sizetype
, build_tree_list (NULL_TREE
, bad_alloc_type_node
));
6269 deltype
= build_exception_variant
6270 (void_ftype_ptr
, build_tree_list (NULL_TREE
, NULL_TREE
));
6271 auto_function (ansi_opname
[(int) NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6272 auto_function (ansi_opname
[(int) VEC_NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6273 auto_function (ansi_opname
[(int) DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6274 auto_function (ansi_opname
[(int) VEC_DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6278 = define_function ("__pure_virtual", void_ftype
,
6279 NOT_BUILT_IN
, 0, 0);
6281 /* Perform other language dependent initializations. */
6282 init_class_processing ();
6283 init_init_processing ();
6284 init_search_processing ();
6286 init_rtti_processing ();
6288 if (flag_exceptions
)
6289 init_exception_processing ();
6292 flag_inline_functions
= 0;
6295 if (! supports_one_only ())
6298 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6299 declare_function_name ();
6301 /* Prepare to check format strings against argument lists. */
6302 init_function_format_info ();
6304 /* Show we use EH for cleanups. */
6305 using_eh_for_cleanups ();
6307 print_error_function
= lang_print_error_function
;
6308 lang_get_alias_set
= &c_get_alias_set
;
6310 /* Maintain consistency. Perhaps we should just complain if they
6311 say -fwritable-strings? */
6312 if (flag_writable_strings
)
6313 flag_const_strings
= 0;
6316 /* Function to print any language-specific context for an error message. */
6319 lang_print_error_function (file
)
6322 default_print_error_function (file
);
6323 maybe_print_template_context ();
6326 /* Make a definition for a builtin function named NAME and whose data type
6327 is TYPE. TYPE should be a function type with argument types.
6328 FUNCTION_CODE tells later passes how to compile calls to this function.
6329 See tree.h for its possible values.
6331 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6332 the name to be called if we can't opencode the function. */
6335 define_function (name
, type
, function_code
, pfn
, library_name
)
6338 enum built_in_function function_code
;
6339 void (*pfn
) PROTO((tree
));
6342 tree decl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), type
);
6343 DECL_EXTERNAL (decl
) = 1;
6344 TREE_PUBLIC (decl
) = 1;
6345 DECL_ARTIFICIAL (decl
) = 1;
6347 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6348 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
6350 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6351 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6352 function in the namespace. */
6353 if (pfn
) (*pfn
) (decl
);
6355 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
6356 make_function_rtl (decl
);
6357 if (function_code
!= NOT_BUILT_IN
)
6359 DECL_BUILT_IN (decl
) = 1;
6360 DECL_FUNCTION_CODE (decl
) = function_code
;
6365 /* When we call finish_struct for an anonymous union, we create
6366 default copy constructors and such. But, an anonymous union
6367 shouldn't have such things; this function undoes the damage to the
6368 anonymous union type T.
6370 (The reason that we create the synthesized methods is that we don't
6371 distinguish `union { int i; }' from `typedef union { int i; } U'.
6372 The first is an anonymous union; the second is just an ordinary
6376 fixup_anonymous_union (t
)
6381 /* Wipe out memory of synthesized methods */
6382 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6383 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6384 TYPE_HAS_INIT_REF (t
) = 0;
6385 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6386 TYPE_HAS_ASSIGN_REF (t
) = 0;
6387 TYPE_HAS_ASSIGNMENT (t
) = 0;
6388 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6390 /* Splice the implicitly generated functions out of the TYPE_METHODS
6392 q
= &TYPE_METHODS (t
);
6395 if (DECL_ARTIFICIAL (*q
))
6396 *q
= TREE_CHAIN (*q
);
6398 q
= &TREE_CHAIN (*q
);
6401 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
6402 function members. */
6403 if (TYPE_METHODS (t
))
6404 error ("an anonymous union cannot have function members");
6407 /* Called when a declaration is seen that contains no names to declare.
6408 If its type is a reference to a structure, union or enum inherited
6409 from a containing scope, shadow that tag name for the current scope
6410 with a forward reference.
6411 If its type defines a new named structure or union
6412 or defines an enum, it is valid but we need not do anything here.
6413 Otherwise, it is an error.
6415 C++: may have to grok the declspecs to learn about static,
6416 complain for anonymous unions. */
6419 shadow_tag (declspecs
)
6423 tree ob_modifier
= NULL_TREE
;
6425 register enum tree_code code
, ok_code
= ERROR_MARK
;
6426 register tree t
= NULL_TREE
;
6428 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6430 register tree value
= TREE_VALUE (link
);
6432 code
= TREE_CODE (value
);
6433 if (IS_AGGR_TYPE_CODE (code
) || code
== ENUMERAL_TYPE
)
6435 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
6437 maybe_process_partial_specialization (value
);
6443 else if (value
== ridpointers
[(int) RID_STATIC
]
6444 || value
== ridpointers
[(int) RID_EXTERN
]
6445 || value
== ridpointers
[(int) RID_AUTO
]
6446 || value
== ridpointers
[(int) RID_REGISTER
]
6447 || value
== ridpointers
[(int) RID_INLINE
]
6448 || value
== ridpointers
[(int) RID_VIRTUAL
]
6449 || value
== ridpointers
[(int) RID_EXPLICIT
])
6450 ob_modifier
= value
;
6453 /* This is where the variables in an anonymous union are
6454 declared. An anonymous union declaration looks like:
6456 because there is no declarator after the union, the parser
6457 sends that declaration here. */
6458 if (ok_code
== UNION_TYPE
6460 && ((TREE_CODE (TYPE_NAME (t
)) == IDENTIFIER_NODE
6461 && ANON_AGGRNAME_P (TYPE_NAME (t
)))
6462 || (TREE_CODE (TYPE_NAME (t
)) == TYPE_DECL
6463 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))))
6465 fixup_anonymous_union (t
);
6467 if (TYPE_FIELDS (t
))
6469 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
6471 finish_anon_union (decl
);
6476 /* Anonymous unions are objects, that's why we only check for
6477 inappropriate specifiers in this branch. */
6481 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
6482 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
6483 cp_error ("`%D' can only be specified for functions", ob_modifier
);
6484 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
6485 cp_error ("`%D' can only be specified for constructors",
6488 cp_error ("`%D' can only be specified for objects and functions",
6493 cp_error ("abstract declarator used as declaration");
6494 else if (found_tag
> 1)
6495 pedwarn ("multiple types in one declaration");
6499 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6502 groktypename (typename
)
6505 if (TREE_CODE (typename
) != TREE_LIST
)
6507 return grokdeclarator (TREE_VALUE (typename
),
6508 TREE_PURPOSE (typename
),
6509 TYPENAME
, 0, NULL_TREE
);
6512 /* Decode a declarator in an ordinary declaration or data definition.
6513 This is called as soon as the type information and variable name
6514 have been parsed, before parsing the initializer if any.
6515 Here we create the ..._DECL node, fill in its type,
6516 and put it on the list of decls for the current context.
6517 The ..._DECL node is returned as the value.
6519 Exception: for arrays where the length is not specified,
6520 the type is left null, to be filled in by `cp_finish_decl'.
6522 Function definitions do not come here; they go to start_function
6523 instead. However, external and forward declarations of functions
6524 do go through here. Structure field declarations are done by
6525 grokfield and not through here. */
6527 /* Set this to zero to debug not using the temporary obstack
6528 to parse initializers. */
6529 int debug_temp_inits
= 1;
6532 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
6533 tree declarator
, declspecs
;
6535 tree attributes
, prefix_attributes
;
6538 register tree type
, tem
;
6540 extern int have_extern_spec
;
6541 extern int used_extern_spec
;
6544 /* See code below that used this. */
6545 int init_written
= initialized
;
6548 /* This should only be done once on the top most decl. */
6549 if (have_extern_spec
&& !used_extern_spec
)
6551 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
6553 used_extern_spec
= 1;
6556 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
6558 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
6561 type
= TREE_TYPE (decl
);
6563 /* Don't lose if destructors must be executed at file-level. */
6564 if (! processing_template_decl
&& TREE_STATIC (decl
)
6565 && TYPE_NEEDS_DESTRUCTOR (complete_type (type
))
6566 && !TREE_PERMANENT (decl
))
6568 push_obstacks (&permanent_obstack
, &permanent_obstack
);
6569 decl
= copy_node (decl
);
6570 if (TREE_CODE (type
) == ARRAY_TYPE
)
6572 tree itype
= TYPE_DOMAIN (type
);
6573 if (itype
&& ! TREE_PERMANENT (itype
))
6575 itype
= build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype
)));
6576 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
6577 TREE_TYPE (decl
) = type
;
6584 = (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
6585 ? DECL_CLASS_CONTEXT (decl
)
6586 : DECL_CONTEXT (decl
);
6588 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
6589 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
6591 /* When parsing the initializer, lookup should use the object's
6593 push_decl_namespace (context
);
6596 /* We are only interested in class contexts, later. */
6597 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
6598 context
= NULL_TREE
;
6601 /* Is it valid for this decl to have an initializer at all?
6602 If not, set INITIALIZED to zero, which will indirectly
6603 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6604 switch (TREE_CODE (decl
))
6607 /* typedef foo = bar means give foo the same type as bar.
6608 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6609 Any other case of an initialization in a TYPE_DECL is an error. */
6610 if (pedantic
|| list_length (declspecs
) > 1)
6612 cp_error ("typedef `%D' is initialized", decl
);
6618 cp_error ("function `%#D' is initialized like a variable", decl
);
6623 if (! processing_template_decl
)
6625 if (type
!= error_mark_node
)
6627 if (TYPE_SIZE (type
) != NULL_TREE
6628 && ! TREE_CONSTANT (TYPE_SIZE (type
)))
6631 ("variable-sized object `%D' may not be initialized",
6636 if (TREE_CODE (type
) == ARRAY_TYPE
6637 && TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6640 ("elements of array `%#D' have incomplete type", decl
);
6649 if (! toplevel_bindings_p ()
6650 && DECL_EXTERNAL (decl
))
6651 cp_warning ("declaration of `%#D' has `extern' and is initialized",
6653 DECL_EXTERNAL (decl
) = 0;
6654 if (toplevel_bindings_p ())
6655 TREE_STATIC (decl
) = 1;
6657 /* Tell `pushdecl' this is an initialized decl
6658 even though we don't yet have the initializer expression.
6659 Also tell `cp_finish_decl' it may store the real initializer. */
6660 DECL_INITIAL (decl
) = error_mark_node
;
6663 if (context
&& TYPE_SIZE (complete_type (context
)) != NULL_TREE
)
6665 pushclass (context
, 2);
6667 if (TREE_CODE (decl
) == VAR_DECL
)
6669 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
6670 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
6671 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
6674 if (DECL_CONTEXT (field
) != context
)
6676 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6677 DECL_CONTEXT (field
), DECL_NAME (decl
),
6678 context
, DECL_NAME (decl
));
6679 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
6681 /* Static data member are tricky; an in-class initialization
6682 still doesn't provide a definition, so the in-class
6683 declaration will have DECL_EXTERNAL set, but will have an
6684 initialization. Thus, duplicate_decls won't warn
6685 about this situation, and so we check here. */
6686 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
6687 cp_error ("duplicate initialization of %D", decl
);
6688 if (duplicate_decls (decl
, field
))
6694 tree field
= check_classfn (context
, decl
);
6695 if (field
&& duplicate_decls (decl
, field
))
6699 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6700 DECL_IN_AGGR_P (decl
) = 0;
6701 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
6702 || CLASSTYPE_USE_TEMPLATE (context
))
6703 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
6705 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
6706 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6710 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6711 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
6714 /* Set attributes here so if duplicate decl, will have proper attributes. */
6715 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
6717 /* Add this decl to the current binding level, but not if it
6718 comes from another scope, e.g. a static member variable.
6719 TEM may equal DECL or it may be a previous decl of the same name. */
6721 if ((TREE_CODE (decl
) != PARM_DECL
&& DECL_CONTEXT (decl
) != NULL_TREE
6722 /* Definitions of namespace members outside their namespace are
6724 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
6725 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
6726 || TREE_CODE (type
) == LANG_TYPE
6727 /* The declaration of template specializations does not affect
6728 the functions available for overload resolution, so we do not
6730 || (TREE_CODE (decl
) == FUNCTION_DECL
6731 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
6734 tem
= pushdecl (decl
);
6736 if (processing_template_decl
)
6738 if (! current_function_decl
)
6739 tem
= push_template_decl (tem
);
6740 else if (minimal_parse_mode
)
6742 = build_min_nt (DECL_STMT
, copy_to_permanent (declarator
),
6743 copy_to_permanent (declspecs
),
6748 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6749 /* Tell the back-end to use or not use .common as appropriate. If we say
6750 -fconserve-space, we want this to save .data space, at the expense of
6751 wrong semantics. If we say -fno-conserve-space, we want this to
6752 produce errors about redefs; to do this we force variables into the
6754 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
6757 if (! processing_template_decl
)
6760 /* Corresponding pop_obstacks is done in `cp_finish_decl'. */
6761 push_obstacks_nochange ();
6764 /* We have no way of knowing whether the initializer will need to be
6765 evaluated at run-time or not until we've parsed it, so let's just put
6766 it in the permanent obstack. (jason) */
6768 && ! (TREE_CODE (tem
) == PARM_DECL
6769 || (TREE_READONLY (tem
)
6770 && (TREE_CODE (tem
) == VAR_DECL
6771 || TREE_CODE (tem
) == FIELD_DECL
))))
6773 /* When parsing and digesting the initializer,
6774 use temporary storage. Do this even if we will ignore the value. */
6775 if (toplevel_bindings_p () && debug_temp_inits
)
6777 if (processing_template_decl
6778 || TYPE_NEEDS_CONSTRUCTING (type
)
6779 || TREE_CODE (type
) == REFERENCE_TYPE
)
6780 /* In this case, the initializer must lay down in permanent
6781 storage, since it will be saved until `finish_file' is run. */
6784 temporary_allocation ();
6796 tree type
= TREE_TYPE (decl
);
6797 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
6799 /* If this type of object needs a cleanup, and control may
6800 jump past it, make a new binding level so that it is cleaned
6801 up only when it is initialized first. */
6802 if (TYPE_NEEDS_DESTRUCTOR (type
)
6803 && current_binding_level
->more_cleanups_ok
== 0)
6804 pushlevel_temporary (1);
6807 /* Is it valid for this decl to have an initializer at all?
6808 If not, set INITIALIZED to zero, which will indirectly
6809 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6811 /* Don't allow initializations for incomplete types except for
6812 arrays which might be completed by the initialization. */
6813 if (type
== error_mark_node
)
6814 ; /* Don't complain again. */
6815 else if (TYPE_SIZE (complete_type (type
)) != NULL_TREE
)
6816 ; /* A complete type is ok. */
6817 else if (TREE_CODE (type
) != ARRAY_TYPE
)
6819 cp_error ("variable `%#D' has initializer but incomplete type",
6822 type
= TREE_TYPE (decl
) = error_mark_node
;
6824 else if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6826 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
6827 cp_error ("elements of array `%#D' have incomplete type", decl
);
6828 /* else we already gave an error in start_decl. */
6834 && TREE_CODE (decl
) != TYPE_DECL
6835 && TREE_CODE (decl
) != TEMPLATE_DECL
6836 && IS_AGGR_TYPE (type
) && ! DECL_EXTERNAL (decl
))
6838 if ((! processing_template_decl
|| ! uses_template_parms (type
))
6839 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
6841 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6843 /* Change the type so that assemble_variable will give
6844 DECL an rtl we can live with: (mem (const_int 0)). */
6845 type
= TREE_TYPE (decl
) = error_mark_node
;
6849 /* If any base type in the hierarchy of TYPE needs a constructor,
6850 then we set initialized to 1. This way any nodes which are
6851 created for the purposes of initializing this aggregate
6852 will live as long as it does. This is necessary for global
6853 aggregates which do not have their initializers processed until
6854 the end of the file. */
6855 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
6860 /* We don't do this yet for GNU C++. */
6861 /* For a local variable, define the RTL now. */
6862 if (! toplevel_bindings_p ()
6863 /* But not if this is a duplicate decl
6864 and we preserved the rtl from the previous one
6865 (which may or may not happen). */
6866 && DECL_RTL (tem
) == NULL_RTX
)
6868 if (TYPE_SIZE (TREE_TYPE (tem
)) != NULL_TREE
)
6870 else if (TREE_CODE (TREE_TYPE (tem
)) == ARRAY_TYPE
6871 && DECL_INITIAL (tem
) != NULL_TREE
)
6877 DECL_INITIAL (decl
) = NULL_TREE
;
6880 /* Handle initialization of references.
6881 These three arguments are from `cp_finish_decl', and have the
6882 same meaning here that they do there.
6884 Quotes on semantics can be found in ARM 8.4.3. */
6887 grok_reference_init (decl
, type
, init
)
6888 tree decl
, type
, init
;
6892 if (init
== NULL_TREE
)
6894 if ((DECL_LANG_SPECIFIC (decl
) == 0
6895 || DECL_IN_AGGR_P (decl
) == 0)
6896 && ! DECL_THIS_EXTERN (decl
))
6898 cp_error ("`%D' declared as reference but not initialized", decl
);
6899 if (TREE_CODE (decl
) == VAR_DECL
)
6900 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
6905 if (init
== error_mark_node
)
6908 if (TREE_CODE (type
) == REFERENCE_TYPE
6909 && TREE_CODE (init
) == CONSTRUCTOR
)
6911 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl
);
6915 if (TREE_CODE (init
) == TREE_LIST
)
6916 init
= build_compound_expr (init
);
6918 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
6919 init
= convert_from_reference (init
);
6921 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
6922 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
6924 /* Note: default conversion is only called in very special cases. */
6925 init
= default_conversion (init
);
6928 tmp
= convert_to_reference
6929 (type
, init
, CONV_IMPLICIT
,
6930 LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
, decl
);
6932 if (tmp
== error_mark_node
)
6934 else if (tmp
!= NULL_TREE
)
6937 DECL_INITIAL (decl
) = save_expr (init
);
6941 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
6945 /* ?? Can this be optimized in some cases to
6946 hand back the DECL_INITIAL slot?? */
6947 if (TYPE_SIZE (TREE_TYPE (type
)))
6949 init
= convert_from_reference (decl
);
6950 if (TREE_PERMANENT (decl
))
6951 init
= copy_to_permanent (init
);
6952 SET_DECL_REFERENCE_SLOT (decl
, init
);
6955 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
6957 expand_static_init (decl
, DECL_INITIAL (decl
));
6958 DECL_INITIAL (decl
) = NULL_TREE
;
6963 if (TREE_CODE (decl
) == VAR_DECL
)
6964 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
6968 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6969 mucking with forces it does not comprehend (i.e. initialization with a
6970 constructor). If we are at global scope and won't go into COMMON, fill
6971 it in with a dummy CONSTRUCTOR to force the variable into .data;
6972 otherwise we can use error_mark_node. */
6975 obscure_complex_init (decl
, init
)
6978 if (! flag_no_inline
&& TREE_STATIC (decl
))
6980 if (extract_init (decl
, init
))
6984 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6985 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
6986 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
6990 DECL_INITIAL (decl
) = error_mark_node
;
6995 /* Issue an error message if DECL is an uninitialized const variable. */
6998 check_for_uninitialized_const_var (decl
)
7001 tree type
= TREE_TYPE (decl
);
7003 /* ``Unless explicitly declared extern, a const object does not have
7004 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7006 if (TREE_CODE (decl
) == VAR_DECL
7007 && TREE_CODE (type
) != REFERENCE_TYPE
7008 && CP_TYPE_CONST_P (type
)
7009 && !TYPE_NEEDS_CONSTRUCTING (type
)
7010 && !DECL_INITIAL (decl
))
7011 cp_error ("uninitialized const `%D'", decl
);
7014 /* Finish processing of a declaration;
7015 install its line number and initial value.
7016 If the length of an array type is not known before,
7017 it must be determined now, from the initial value, or it is an error.
7019 Call `pop_obstacks' iff NEED_POP is nonzero.
7021 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
7022 for aggregates that have constructors alive on the permanent obstack,
7023 so that the global initializing functions can be written at the end.
7025 INIT0 holds the value of an initializer that should be allowed to escape
7028 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7029 if the (init) syntax was used.
7031 For functions that take default parameters, DECL points to its
7032 "maximal" instantiation. `cp_finish_decl' must then also declared its
7033 subsequently lower and lower forms of instantiation, checking for
7034 ambiguity as it goes. This can be sped up later. */
7037 cp_finish_decl (decl
, init
, asmspec_tree
, need_pop
, flags
)
7044 tree cleanup
= NULL_TREE
, ttype
= NULL_TREE
;
7046 int temporary
= allocation_temporary_p ();
7047 char *asmspec
= NULL
;
7048 int was_readonly
= 0;
7049 int already_used
= 0;
7051 /* If this is 0, then we did not change obstacks. */
7055 error ("assignment (not initialization) in declaration");
7059 /* If a name was specified, get the string. */
7061 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
7063 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
7065 cp_error ("Cannot initialize `%D' to namespace `%D'",
7070 if (current_class_type
7071 && DECL_REAL_CONTEXT (decl
) == current_class_type
7072 && TYPE_BEING_DEFINED (current_class_type
)
7073 && (DECL_INITIAL (decl
) || init
))
7074 DECL_DEFINED_IN_CLASS_P (decl
) = 1;
7076 if (TREE_CODE (decl
) == VAR_DECL
7077 && DECL_CONTEXT (decl
)
7078 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
7079 && DECL_CONTEXT (decl
) != current_namespace
7082 /* Leave the namespace of the object. */
7083 pop_decl_namespace ();
7086 /* If the type of the thing we are declaring either has
7087 a constructor, or has a virtual function table pointer,
7088 AND its initialization was accepted by `start_decl',
7089 then we stayed on the permanent obstack through the
7090 declaration, otherwise, changed obstacks as GCC would. */
7092 type
= TREE_TYPE (decl
);
7094 if (type
== error_mark_node
)
7096 if (toplevel_bindings_p () && temporary
)
7097 end_temporary_allocation ();
7102 if (processing_template_decl
)
7104 if (init
&& DECL_INITIAL (decl
))
7105 DECL_INITIAL (decl
) = init
;
7106 if (minimal_parse_mode
&& ! DECL_ARTIFICIAL (decl
))
7108 tree stmt
= DECL_VINDEX (decl
);
7109 /* If the decl is declaring a member of a local class (in a
7110 template function), the DECL_VINDEX will either be NULL,
7111 or it will be an actual virtual function index, not a
7113 if (stmt
!= NULL_TREE
&& TREE_CODE (stmt
) == DECL_STMT
)
7115 DECL_VINDEX (decl
) = NULL_TREE
;
7116 TREE_OPERAND (stmt
, 2) = copy_to_permanent (init
);
7123 /* Take care of TYPE_DECLs up front. */
7124 if (TREE_CODE (decl
) == TYPE_DECL
)
7126 if (init
&& DECL_INITIAL (decl
))
7128 /* typedef foo = bar; store the type of bar as the type of foo. */
7129 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
7130 DECL_INITIAL (decl
) = init
= NULL_TREE
;
7132 if (type
!= error_mark_node
7133 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
7135 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7136 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
7137 set_identifier_type_value (DECL_NAME (decl
), type
);
7138 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
7140 GNU_xref_decl (current_function_decl
, decl
);
7142 /* If we have installed this as the canonical typedef for this
7143 type, and that type has not been defined yet, delay emitting
7144 the debug information for it, as we will emit it later. */
7145 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7146 && TYPE_SIZE (TREE_TYPE (decl
)) == NULL_TREE
)
7147 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
7149 rest_of_decl_compilation (decl
, NULL_PTR
,
7150 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
7153 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7155 ttype
= target_type (type
);
7158 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
7159 && TYPE_NEEDS_CONSTRUCTING (type
))
7162 /* Currently, GNU C++ puts constants in text space, making them
7163 impossible to initialize. In the future, one would hope for
7164 an operating system which understood the difference between
7165 initialization and the running of a program. */
7167 TREE_READONLY (decl
) = 0;
7170 if (TREE_CODE (decl
) == FIELD_DECL
)
7172 if (init
&& init
!= error_mark_node
)
7173 my_friendly_assert (TREE_PERMANENT (init
), 147);
7177 /* This must override the asm specifier which was placed
7178 by grokclassfn. Lay this out fresh. */
7179 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
7180 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7181 make_decl_rtl (decl
, asmspec
, 0);
7184 /* If `start_decl' didn't like having an initialization, ignore it now. */
7185 else if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7187 else if (DECL_EXTERNAL (decl
))
7189 else if (TREE_CODE (type
) == REFERENCE_TYPE
7190 || (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE_REFERENCE (type
)))
7192 if (TREE_STATIC (decl
))
7193 make_decl_rtl (decl
, NULL_PTR
,
7194 toplevel_bindings_p ()
7195 || pseudo_global_level_p ());
7196 grok_reference_init (decl
, type
, init
);
7200 GNU_xref_decl (current_function_decl
, decl
);
7202 if (TREE_CODE (decl
) == FIELD_DECL
)
7204 else if (TREE_CODE (decl
) == CONST_DECL
)
7206 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7208 DECL_INITIAL (decl
) = init
;
7210 /* This will keep us from needing to worry about our obstacks. */
7211 my_friendly_assert (init
!= NULL_TREE
, 149);
7216 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7218 if (TREE_CODE (type
) == ARRAY_TYPE
)
7219 init
= digest_init (type
, init
, (tree
*) 0);
7220 else if (TREE_CODE (init
) == CONSTRUCTOR
7221 && TREE_HAS_CONSTRUCTOR (init
))
7223 if (TYPE_NON_AGGREGATE_CLASS (type
))
7225 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7227 init
= error_mark_node
;
7230 goto dont_use_constructor
;
7235 dont_use_constructor
:
7236 if (TREE_CODE (init
) != TREE_VEC
)
7237 init
= store_init_value (decl
, init
);
7241 /* We must hide the initializer so that expand_decl
7242 won't try to do something it does not understand. */
7243 init
= obscure_complex_init (decl
, init
);
7245 else if (DECL_EXTERNAL (decl
))
7247 else if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't'
7248 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7251 while (TREE_CODE (ctype
) == ARRAY_TYPE
)
7252 ctype
= TREE_TYPE (ctype
);
7253 if (! TYPE_NEEDS_CONSTRUCTING (ctype
))
7255 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype
))
7256 cp_error ("structure `%D' with uninitialized const members", decl
);
7257 if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype
))
7258 cp_error ("structure `%D' with uninitialized reference members",
7262 check_for_uninitialized_const_var (decl
);
7264 if (TYPE_SIZE (type
) != NULL_TREE
7265 && TYPE_NEEDS_CONSTRUCTING (type
))
7266 init
= obscure_complex_init (decl
, NULL_TREE
);
7270 check_for_uninitialized_const_var (decl
);
7272 /* For top-level declaration, the initial value was read in
7273 the temporary obstack. MAXINDEX, rtl, etc. to be made below
7274 must go in the permanent obstack; but don't discard the
7275 temporary data yet. */
7277 if (toplevel_bindings_p () && temporary
)
7278 end_temporary_allocation ();
7280 /* Deduce size of array from initialization, if not already known. */
7282 if (TREE_CODE (type
) == ARRAY_TYPE
7283 && TYPE_DOMAIN (type
) == NULL_TREE
7284 && TREE_CODE (decl
) != TYPE_DECL
)
7287 = (TREE_STATIC (decl
)
7288 /* Even if pedantic, an external linkage array
7289 may have incomplete type at first. */
7290 ? pedantic
&& ! DECL_EXTERNAL (decl
)
7291 : !DECL_EXTERNAL (decl
));
7292 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7293 int failure
= complete_array_type (type
, initializer
, do_default
);
7296 cp_error ("initializer fails to determine size of `%D'", decl
);
7301 cp_error ("array size missing in `%D'", decl
);
7302 /* If a `static' var's size isn't known, make it extern as
7303 well as static, so it does not get allocated. If it's not
7304 `static', then don't mark it extern; finish_incomplete_decl
7305 will give it a default size and it will get allocated. */
7306 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7307 DECL_EXTERNAL (decl
) = 1;
7310 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7311 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7313 cp_error ("zero-size array `%D'", decl
);
7315 layout_decl (decl
, 0);
7318 if (TREE_CODE (decl
) == VAR_DECL
)
7320 if (DECL_SIZE (decl
) == NULL_TREE
7321 && TYPE_SIZE (complete_type (TREE_TYPE (decl
))) != NULL_TREE
)
7322 layout_decl (decl
, 0);
7324 if (TREE_STATIC (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7326 /* A static variable with an incomplete type:
7327 that is an error if it is initialized.
7328 Otherwise, let it through, but if it is not `extern'
7329 then it may cause an error message later. */
7330 if (DECL_INITIAL (decl
) != NULL_TREE
)
7331 cp_error ("storage size of `%D' isn't known", decl
);
7334 else if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7336 /* An automatic variable with an incomplete type: that is an error.
7337 Don't talk about array types here, since we took care of that
7338 message in grokdeclarator. */
7339 cp_error ("storage size of `%D' isn't known", decl
);
7340 TREE_TYPE (decl
) = error_mark_node
;
7342 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7343 /* Let debugger know it should output info for this type. */
7344 note_debug_info_needed (ttype
);
7346 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7347 note_debug_info_needed (DECL_CONTEXT (decl
));
7349 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7350 && DECL_SIZE (decl
) != NULL_TREE
7351 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7353 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7354 constant_expression_warning (DECL_SIZE (decl
));
7356 cp_error ("storage size of `%D' isn't constant", decl
);
7359 if (! DECL_EXTERNAL (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
7360 /* Cleanups for static variables are handled by `finish_file'. */
7361 && ! TREE_STATIC (decl
))
7363 int yes
= suspend_momentary ();
7364 cleanup
= maybe_build_cleanup (decl
);
7365 resume_momentary (yes
);
7368 /* PARM_DECLs get cleanups, too. */
7369 else if (TREE_CODE (decl
) == PARM_DECL
&& TYPE_NEEDS_DESTRUCTOR (type
))
7372 end_temporary_allocation ();
7373 cleanup
= maybe_build_cleanup (decl
);
7375 resume_temporary_allocation ();
7378 /* Output the assembler code and/or RTL code for variables and functions,
7379 unless the type is an undefined structure or union.
7380 If not, it will get done when the type is completed. */
7382 was_incomplete
= (DECL_SIZE (decl
) == NULL_TREE
);
7384 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
7385 || TREE_CODE (decl
) == RESULT_DECL
)
7387 /* ??? FIXME: What about nested classes? */
7388 int toplev
= toplevel_bindings_p () || pseudo_global_level_p ();
7390 = (TREE_STATIC (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
7391 && allocation_temporary_p ());
7394 end_temporary_allocation ();
7396 /* Static data in a function with comdat linkage also has comdat
7398 if (TREE_CODE (decl
) == VAR_DECL
7399 && TREE_STATIC (decl
)
7400 /* Don't mess with __FUNCTION__. */
7401 && ! TREE_ASM_WRITTEN (decl
)
7402 && current_function_decl
7403 && DECL_CONTEXT (decl
) == current_function_decl
7404 && (DECL_THIS_INLINE (current_function_decl
)
7405 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7406 && TREE_PUBLIC (current_function_decl
))
7408 /* Rather than try to get this right with inlining, we suppress
7409 inlining of such functions. */
7410 current_function_cannot_inline
7411 = "function with static variable cannot be inline";
7413 /* If flag_weak, we don't need to mess with this, as we can just
7414 make the function weak, and let it refer to its unique local
7415 copy. This works because we don't allow the function to be
7419 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7421 TREE_PUBLIC (decl
) = 1;
7422 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7424 else if (DECL_INITIAL (decl
) == NULL_TREE
7425 || DECL_INITIAL (decl
) == error_mark_node
)
7427 TREE_PUBLIC (decl
) = 1;
7428 DECL_COMMON (decl
) = 1;
7430 /* else we lose. We can only do this if we can use common,
7431 which we can't if it has been initialized. */
7433 if (TREE_PUBLIC (decl
))
7434 DECL_ASSEMBLER_NAME (decl
)
7435 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7436 else if (! DECL_ARTIFICIAL (decl
))
7438 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7439 cp_warning_at (" you can work around this by removing the initializer"), decl
;
7444 else if (TREE_CODE (decl
) == VAR_DECL
7445 && DECL_LANG_SPECIFIC (decl
)
7446 && DECL_COMDAT (decl
))
7448 /* Dynamically initialized vars go into common. */
7449 if (DECL_INITIAL (decl
) == NULL_TREE
7450 || DECL_INITIAL (decl
) == error_mark_node
)
7451 DECL_COMMON (decl
) = 1;
7452 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7454 DECL_COMMON (decl
) = 1;
7455 DECL_INITIAL (decl
) = error_mark_node
;
7459 /* Statically initialized vars are weak or comdat, if
7462 make_decl_one_only (decl
);
7465 /* We can't do anything useful; leave vars for explicit
7467 DECL_EXTERNAL (decl
) = 1;
7468 DECL_NOT_REALLY_EXTERN (decl
) = 0;
7473 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
7474 make_decl_rtl (decl
, NULL_PTR
, toplev
);
7475 else if (TREE_CODE (decl
) == VAR_DECL
7476 && TREE_READONLY (decl
)
7477 && DECL_INITIAL (decl
) != NULL_TREE
7478 && DECL_INITIAL (decl
) != error_mark_node
7479 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7481 DECL_INITIAL (decl
) = save_expr (DECL_INITIAL (decl
));
7484 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7487 && TREE_STATIC (decl
)
7488 && ! TREE_SIDE_EFFECTS (decl
)
7489 && ! TREE_PUBLIC (decl
)
7490 && ! DECL_EXTERNAL (decl
)
7491 && ! TYPE_NEEDS_DESTRUCTOR (type
)
7492 && DECL_MODE (decl
) != BLKmode
)
7494 /* If this variable is really a constant, then fill its DECL_RTL
7495 slot with something which won't take up storage.
7496 If something later should take its address, we can always give
7497 it legitimate RTL at that time. */
7498 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
7499 store_expr (DECL_INITIAL (decl
), DECL_RTL (decl
), 0);
7500 TREE_ASM_WRITTEN (decl
) = 1;
7502 else if (toplev
&& ! TREE_PUBLIC (decl
))
7504 /* If this is a static const, change its apparent linkage
7505 if it belongs to a #pragma interface. */
7506 if (!interface_unknown
)
7508 TREE_PUBLIC (decl
) = 1;
7509 DECL_EXTERNAL (decl
) = interface_only
;
7511 make_decl_rtl (decl
, asmspec
, toplev
);
7514 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7516 else if (TREE_CODE (decl
) == VAR_DECL
7517 && DECL_LANG_SPECIFIC (decl
)
7518 && DECL_IN_AGGR_P (decl
))
7520 if (TREE_STATIC (decl
))
7522 if (init
== NULL_TREE
7523 #ifdef DEFAULT_STATIC_DEFS
7524 /* If this code is dead, then users must
7525 explicitly declare static member variables
7526 outside the class def'n as well. */
7527 && TYPE_NEEDS_CONSTRUCTING (type
)
7531 DECL_EXTERNAL (decl
) = 1;
7532 make_decl_rtl (decl
, asmspec
, 1);
7535 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7538 /* Just a constant field. Should not need any rtl. */
7542 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7545 resume_temporary_allocation ();
7547 if (type
!= error_mark_node
7548 && TYPE_LANG_SPECIFIC (type
)
7549 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
7550 abstract_virtuals_error (decl
, type
);
7551 else if ((TREE_CODE (type
) == FUNCTION_TYPE
7552 || TREE_CODE (type
) == METHOD_TYPE
)
7553 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
7554 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type
)))
7555 abstract_virtuals_error (decl
, TREE_TYPE (type
));
7557 if (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE (type
))
7558 signature_error (decl
, type
);
7559 else if ((TREE_CODE (type
) == FUNCTION_TYPE
7560 || TREE_CODE (type
) == METHOD_TYPE
)
7561 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
7562 && IS_SIGNATURE (TREE_TYPE (type
)))
7563 signature_error (decl
, TREE_TYPE (type
));
7565 if (TREE_CODE (decl
) == FUNCTION_DECL
)
7567 else if (DECL_EXTERNAL (decl
)
7568 && ! (DECL_LANG_SPECIFIC (decl
)
7569 && DECL_NOT_REALLY_EXTERN (decl
)))
7572 DECL_INITIAL (decl
) = init
;
7574 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
7576 /* Cleanups for static variables are handled by `finish_file'. */
7577 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
7578 || TYPE_NEEDS_DESTRUCTOR (type
))
7579 expand_static_init (decl
, init
);
7583 /* This is a declared decl which must live until the
7584 end of the binding contour. It may need a cleanup. */
7586 /* Recompute the RTL of a local array now
7587 if it used to be an incomplete type. */
7588 if (was_incomplete
&& ! TREE_STATIC (decl
))
7590 /* If we used it already as memory, it must stay in memory. */
7591 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7592 /* If it's still incomplete now, no init will save it. */
7593 if (DECL_SIZE (decl
) == NULL_TREE
)
7594 DECL_INITIAL (decl
) = NULL_TREE
;
7597 else if (! TREE_ASM_WRITTEN (decl
)
7598 && (TYPE_SIZE (type
) != NULL_TREE
7599 || TREE_CODE (type
) == ARRAY_TYPE
))
7601 /* Do this here, because we did not expand this decl's
7602 rtl in start_decl. */
7603 if (DECL_RTL (decl
) == NULL_RTX
)
7607 /* XXX: Why don't we use decl here? */
7608 /* Ans: Because it was already expanded? */
7609 if (! expand_decl_cleanup (NULL_TREE
, cleanup
))
7610 cp_error ("parser lost in parsing declaration of `%D'",
7612 /* Cleanup used up here. */
7613 cleanup
= NULL_TREE
;
7617 if (current_binding_level
->is_for_scope
)
7619 struct binding_level
*outer
= current_binding_level
->level_chain
;
7621 /* Check to see if the same name is already bound at
7622 the outer level, either because it was directly declared,
7623 or because a dead for-decl got preserved. In either case,
7624 the code would not have been valid under the ARM
7625 scope rules, so clear is_for_scope for the
7626 current_binding_level.
7628 Otherwise, we need to preserve the temp slot for decl
7629 to last into the outer binding level. */
7631 int handling_dead_for_vars
= 0;
7632 tree link
= outer
->names
;
7633 for (; ; link
= TREE_CHAIN (link
))
7635 if (link
== NULL
&& handling_dead_for_vars
== 0)
7637 link
= outer
->dead_vars_from_for
;
7638 handling_dead_for_vars
= 1;
7642 if (DECL_IN_MEMORY_P (decl
))
7643 preserve_temp_slots (DECL_RTL (decl
));
7646 if (DECL_NAME (link
) == DECL_NAME (decl
))
7648 if (handling_dead_for_vars
)
7651 = purpose_member (DECL_NAME (decl
),
7652 current_binding_level
->shadowed
);
7653 if (shadowing
&& TREE_VALUE (shadowing
) == link
)
7654 TREE_VALUE (shadowing
)
7655 = DECL_SHADOWED_FOR_VAR (link
);
7657 current_binding_level
->is_for_scope
= 0;
7663 expand_start_target_temps ();
7665 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7667 /* Compute and store the initial value. */
7668 expand_decl_init (decl
);
7669 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7671 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7673 emit_line_note (DECL_SOURCE_FILE (decl
),
7674 DECL_SOURCE_LINE (decl
));
7675 expand_aggr_init (decl
, init
, flags
);
7678 /* Set this to 0 so we can tell whether an aggregate which
7679 was initialized was ever used. Don't do this if it has a
7680 destructor, so we don't complain about the 'resource
7681 allocation is initialization' idiom. */
7682 /* Now set attribute((unused)) on types so decls of
7683 that type will be marked used. (see TREE_USED, above.)
7684 This avoids the warning problems this particular code
7685 tried to work around. */
7687 if (TYPE_NEEDS_CONSTRUCTING (type
)
7689 && cleanup
== NULL_TREE
7690 && DECL_NAME (decl
))
7691 TREE_USED (decl
) = 0;
7694 TREE_USED (decl
) = 1;
7697 /* Cleanup any temporaries needed for the initial value. */
7698 expand_end_target_temps ();
7700 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7702 /* Store the cleanup, if there was one. */
7705 if (! expand_decl_cleanup (decl
, cleanup
))
7706 cp_error ("parser lost in parsing declaration of `%D'",
7713 /* Undo call to `pushclass' that was done in `start_decl'
7714 due to initialization of qualified member variable.
7715 I.e., Foo::x = 10; */
7717 tree context
= DECL_REAL_CONTEXT (decl
);
7719 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't'
7720 && (TREE_CODE (decl
) == VAR_DECL
7721 /* We also have a pushclass done that we need to undo here
7722 if we're at top level and declare a method. */
7723 || TREE_CODE (decl
) == FUNCTION_DECL
)
7724 /* If size hasn't been set, we're still defining it,
7725 and therefore inside the class body; don't pop
7726 the binding level.. */
7727 && TYPE_SIZE (context
) != NULL_TREE
7728 && context
== current_class_type
)
7735 /* If requested, warn about definitions of large data objects. */
7737 if (warn_larger_than
7738 && ! processing_template_decl
7739 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
7740 && !DECL_EXTERNAL (decl
))
7742 register tree decl_size
= DECL_SIZE (decl
);
7744 if (decl_size
&& TREE_CODE (decl_size
) == INTEGER_CST
)
7746 unsigned units
= TREE_INT_CST_LOW (decl_size
) / BITS_PER_UNIT
;
7748 if (units
> larger_than_size
)
7749 warning_with_decl (decl
, "size of `%s' is %u bytes", units
);
7755 /* Resume permanent allocation, if not within a function. */
7756 /* The corresponding push_obstacks_nochange is in start_decl,
7757 start_method, groktypename, and in grokfield. */
7762 TREE_READONLY (decl
) = 1;
7765 /* This is here for a midend callback from c-common.c */
7768 finish_decl (decl
, init
, asmspec_tree
)
7772 cp_finish_decl (decl
, init
, asmspec_tree
, 1, 0);
7776 expand_static_init (decl
, init
)
7780 tree oldstatic
= value_member (decl
, static_aggregates
);
7784 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
7785 cp_error ("multiple initializations given for `%D'", decl
);
7787 else if (! toplevel_bindings_p () && ! pseudo_global_level_p ())
7789 /* Emit code to perform this initialization but once. */
7792 /* Remember this information until end of file. */
7793 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7795 /* Emit code to perform this initialization but once. */
7796 temp
= get_temp_name (integer_type_node
, 1);
7797 rest_of_decl_compilation (temp
, NULL_PTR
, 0, 0);
7798 expand_start_cond (build_binary_op (EQ_EXPR
, temp
,
7799 integer_zero_node
, 1), 0);
7800 expand_start_target_temps ();
7802 expand_assignment (temp
, integer_one_node
, 0, 0);
7803 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
7804 || (init
&& TREE_CODE (init
) == TREE_LIST
))
7806 expand_aggr_init (decl
, init
, 0);
7807 do_pending_stack_adjust ();
7810 expand_assignment (decl
, init
, 0, 0);
7812 /* Cleanup any temporaries needed for the initial value. */
7813 expand_end_target_temps ();
7815 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
7817 tree cleanup
, fcall
;
7818 static tree Atexit
= 0;
7821 tree atexit_fndecl
, PFV
, pfvlist
;
7822 /* Remember this information until end of file. */
7823 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7824 PFV
= build_pointer_type (build_function_type
7825 (void_type_node
, void_list_node
));
7827 pfvlist
= tree_cons (NULL_TREE
, PFV
, void_list_node
);
7829 push_lang_context (lang_name_c
);
7831 = builtin_function ("atexit",
7832 build_function_type (void_type_node
,
7834 NOT_BUILT_IN
, NULL_PTR
);
7835 assemble_external (atexit_fndecl
);
7836 Atexit
= default_conversion (atexit_fndecl
);
7837 pop_lang_context ();
7841 /* Call build_cleanup before we enter the anonymous function
7842 so that any access checks will be done relative to the
7843 current scope, rather than the scope of the anonymous
7845 fcall
= build_cleanup (decl
);
7846 cleanup
= start_anon_func ();
7847 expand_expr_stmt (fcall
);
7849 mark_addressable (cleanup
);
7850 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
7851 fcall
= build_function_call (Atexit
, expr_tree_cons (NULL_TREE
, cleanup
, NULL_TREE
));
7852 expand_expr_stmt (fcall
);
7856 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
7858 static_aggregates
= perm_tree_cons (temp
, decl
, static_aggregates
);
7859 TREE_STATIC (static_aggregates
) = 1;
7862 /* Resume old (possibly temporary) allocation. */
7867 /* This code takes into account memory allocation
7868 policy of `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING
7869 does not hold for this object, then we must make permanent
7870 the storage currently in the temporary obstack. */
7871 if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
7872 preserve_initializer ();
7873 static_aggregates
= perm_tree_cons (init
, decl
, static_aggregates
);
7877 /* Make TYPE a complete type based on INITIAL_VALUE.
7878 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7879 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
7882 complete_array_type (type
, initial_value
, do_default
)
7883 tree type
, initial_value
;
7886 register tree maxindex
= NULL_TREE
;
7891 /* Note MAXINDEX is really the maximum index,
7892 one less than the size. */
7893 if (TREE_CODE (initial_value
) == STRING_CST
)
7896 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
7897 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
7900 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7902 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
7903 maxindex
= size_binop (MINUS_EXPR
, integer_zero_node
, size_one_node
);
7904 for (; elts
; elts
= TREE_CHAIN (elts
))
7906 if (TREE_PURPOSE (elts
))
7907 maxindex
= TREE_PURPOSE (elts
);
7909 maxindex
= size_binop (PLUS_EXPR
, maxindex
, size_one_node
);
7911 maxindex
= copy_node (maxindex
);
7915 /* Make an error message unless that happened already. */
7916 if (initial_value
!= error_mark_node
)
7919 /* Prevent further error messages. */
7920 maxindex
= build_int_2 (0, 0);
7927 maxindex
= build_int_2 (0, 0);
7935 TYPE_DOMAIN (type
) = build_index_type (maxindex
);
7936 if (! TREE_TYPE (maxindex
))
7937 TREE_TYPE (maxindex
) = TYPE_DOMAIN (type
);
7939 itype
= TREE_TYPE (initial_value
);
7942 if (itype
&& !TYPE_DOMAIN (itype
))
7943 TYPE_DOMAIN (itype
) = TYPE_DOMAIN (type
);
7944 /* The type of the main variant should never be used for arrays
7945 of different sizes. It should only ever be completed with the
7946 size of the array. */
7947 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
7948 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = TYPE_DOMAIN (type
);
7951 /* Lay out the type now that we can get the real answer. */
7958 /* Return zero if something is declared to be a member of type
7959 CTYPE when in the context of CUR_TYPE. STRING is the error
7960 message to print in that case. Otherwise, quietly return 1. */
7963 member_function_or_else (ctype
, cur_type
, string
)
7964 tree ctype
, cur_type
;
7967 if (ctype
&& ctype
!= cur_type
)
7969 error (string
, TYPE_NAME_STRING (ctype
));
7975 /* Subroutine of `grokdeclarator'. */
7977 /* Generate errors possibly applicable for a given set of specifiers.
7978 This is for ARM $7.1.2. */
7981 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
7984 int virtualp
, quals
, friendp
, raises
, inlinep
;
7987 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
7989 cp_error ("`%D' declared as an `inline' %s", object
, type
);
7991 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
7994 cp_error_at ("invalid friend declaration", object
);
7996 cp_error_at ("invalid exception specifications", object
);
7999 /* CTYPE is class type, or null if non-class.
8000 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8002 DECLARATOR is the function's name.
8003 VIRTUALP is truthvalue of whether the function is virtual or not.
8004 FLAGS are to be passed through to `grokclassfn'.
8005 QUALS are qualifiers indicating whether the function is `const'
8007 RAISES is a list of exceptions that this function can raise.
8008 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8009 not look, and -1 if we should not call `grokclassfn' at all.
8011 Returns `error_mark_node' if something goes wrong, after issuing
8012 applicable error messages. */
8015 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8016 raises
, attrlist
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8017 template_count
, in_namespace
)
8020 tree orig_declarator
;
8022 enum overload_flags flags
;
8023 tree quals
, raises
, attrlist
;
8024 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8028 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8032 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8033 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8039 type
= build_exception_variant (type
, raises
);
8042 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8043 /* Propagate volatile out from type to decl. */
8044 if (TYPE_VOLATILE (type
))
8045 TREE_THIS_VOLATILE (decl
) = 1;
8047 /* If this decl has namespace scope, set that up. */
8049 set_decl_namespace (decl
, in_namespace
);
8050 else if (publicp
&& ! ctype
)
8051 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8053 /* `main' and builtins have implicit 'C' linkage. */
8054 if ((MAIN_NAME_P (declarator
)
8055 || (IDENTIFIER_LENGTH (declarator
) > 10
8056 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8057 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8058 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8059 && current_lang_name
== lang_name_cplusplus
8060 && ctype
== NULL_TREE
8061 /* NULL_TREE means global namespace. */
8062 && DECL_CONTEXT (decl
) == NULL_TREE
)
8063 DECL_LANGUAGE (decl
) = lang_c
;
8065 /* Should probably propagate const out from type to decl I bet (mrs). */
8068 DECL_STATIC_FUNCTION_P (decl
) = 1;
8069 DECL_CONTEXT (decl
) = ctype
;
8073 DECL_CLASS_CONTEXT (decl
) = ctype
;
8075 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8077 if (processing_template_decl
)
8078 error ("cannot declare `main' to be a template");
8080 error ("cannot declare `main' to be inline");
8082 error ("cannot declare `main' to be static");
8087 /* Members of anonymous types have no linkage; make them internal. */
8088 if (ctype
&& ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
)))
8093 /* [basic.link]: A name with no linkage (notably, the name of a class
8094 or enumeration declared in a local scope) shall not be used to
8095 declare an entity with linkage.
8097 Only check this for public decls for now. */
8098 t
= no_linkage_check (TREE_TYPE (decl
));
8101 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8103 if (DECL_LANGUAGE (decl
) == lang_c
)
8104 /* Allow this; it's pretty common in C. */;
8106 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8110 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8115 TREE_PUBLIC (decl
) = publicp
;
8118 DECL_INTERFACE_KNOWN (decl
) = 1;
8119 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8123 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8125 DECL_EXTERNAL (decl
) = 1;
8126 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8128 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8129 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8133 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8134 grok_op_properties (decl
, virtualp
, check
< 0);
8136 if (ctype
&& hack_decl_function_context (decl
))
8137 DECL_NO_STATIC_CHAIN (decl
) = 1;
8139 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8140 if (TREE_PURPOSE (t
)
8141 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8143 add_defarg_fn (decl
);
8148 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8152 ("defining explicit specialization `%D' in friend declaration",
8156 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8158 /* Something like `template <class T> friend void f<T>()'. */
8159 cp_error ("template-id `%D' in declaration of primary template",
8161 return error_mark_node
;
8164 /* A friend declaration of the form friend void f<>(). Record
8165 the information in the TEMPLATE_ID_EXPR. */
8166 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8167 DECL_TEMPLATE_INFO (decl
)
8168 = perm_tree_cons (TREE_OPERAND (orig_declarator
, 0),
8169 TREE_OPERAND (orig_declarator
, 1),
8174 /* Plain overloading: will not be grok'd by grokclassfn. */
8175 if (! ctype
&& ! processing_template_decl
8176 && DECL_LANGUAGE (decl
) != lang_c
8177 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
8178 set_mangled_name_for_decl (decl
);
8181 /* Make the init_value nonzero so pushdecl knows this is not
8182 tentative. error_mark_node is replaced later with the BLOCK. */
8183 DECL_INITIAL (decl
) = error_mark_node
;
8185 /* Caller will do the rest of this. */
8189 if (check
&& funcdef_flag
)
8190 DECL_INITIAL (decl
) = error_mark_node
;
8192 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8195 /* Just handle constructors here. We could do this
8196 inside the following if stmt, but I think
8197 that the code is more legible by breaking this
8198 case out. See comments below for what each of
8199 the following calls is supposed to do. */
8200 DECL_CONSTRUCTOR_P (decl
) = 1;
8202 grokclassfn (ctype
, decl
, flags
, quals
);
8204 decl
= check_explicit_specialization (orig_declarator
, decl
,
8206 2 * (funcdef_flag
!= 0) +
8207 4 * (friendp
!= 0));
8208 if (decl
== error_mark_node
)
8209 return error_mark_node
;
8211 if ((! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8214 tmp
= check_classfn (ctype
, decl
);
8216 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8217 tmp
= DECL_TEMPLATE_RESULT(tmp
);
8219 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8220 cp_error ("definition of implicitly-declared `%D'", tmp
);
8221 if (tmp
&& duplicate_decls (decl
, tmp
))
8224 if (! grok_ctor_properties (ctype
, decl
))
8225 return error_mark_node
;
8231 /* Function gets the ugly name, field gets the nice one.
8232 This call may change the type of the function (because
8233 of default parameters)! */
8234 if (ctype
!= NULL_TREE
)
8235 grokclassfn (ctype
, decl
, flags
, quals
);
8237 decl
= check_explicit_specialization (orig_declarator
, decl
,
8239 2 * (funcdef_flag
!= 0) +
8240 4 * (friendp
!= 0));
8241 if (decl
== error_mark_node
)
8242 return error_mark_node
;
8244 if (ctype
!= NULL_TREE
8245 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8248 tmp
= check_classfn (ctype
, decl
);
8250 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8251 tmp
= DECL_TEMPLATE_RESULT (tmp
);
8253 if (tmp
&& DECL_STATIC_FUNCTION_P (tmp
)
8254 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8256 /* Remove the `this' parm added by grokclassfn.
8257 XXX Isn't this done in start_function, too? */
8258 revert_static_member_fn (&decl
, NULL
, NULL
);
8259 last_function_parms
= TREE_CHAIN (last_function_parms
);
8261 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8262 cp_error ("definition of implicitly-declared `%D'", tmp
);
8265 if (!duplicate_decls (decl
, tmp
))
8266 my_friendly_abort (892);
8271 if (ctype
== NULL_TREE
|| check
)
8275 cplus_decl_attributes (decl
, TREE_PURPOSE (attrlist
),
8276 TREE_VALUE (attrlist
));
8277 make_decl_rtl (decl
, NULL_PTR
, 1);
8281 DECL_VIRTUAL_P (decl
) = 1;
8282 if (DECL_VINDEX (decl
) == NULL_TREE
)
8283 DECL_VINDEX (decl
) = error_mark_node
;
8284 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
8291 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
8294 RID_BIT_TYPE
*specbits_in
;
8300 RID_BIT_TYPE specbits
;
8302 specbits
= *specbits_in
;
8304 if (TREE_CODE (type
) == OFFSET_TYPE
)
8306 /* If you declare a static member so that it
8307 can be initialized, the code will reach here. */
8308 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
8309 type
= TREE_TYPE (type
);
8310 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
8311 DECL_CONTEXT (decl
) = basetype
;
8312 DECL_CLASS_CONTEXT (decl
) = basetype
;
8313 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
, declarator
);
8320 context
= in_namespace
;
8321 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
8322 context
= current_namespace
;
8324 context
= NULL_TREE
;
8326 decl
= build_decl (VAR_DECL
, declarator
, complete_type (type
));
8329 set_decl_namespace (decl
, context
);
8331 context
= DECL_CONTEXT (decl
);
8332 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
8333 DECL_ASSEMBLER_NAME (decl
) = build_static_name (context
, declarator
);
8337 set_decl_namespace (decl
, in_namespace
);
8339 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
8341 DECL_THIS_EXTERN (decl
) = 1;
8342 DECL_EXTERNAL (decl
) = !initialized
;
8345 /* In class context, static means one per class,
8346 public access, and static storage. */
8347 if (DECL_CLASS_SCOPE_P (decl
))
8349 TREE_PUBLIC (decl
) = 1;
8350 TREE_STATIC (decl
) = 1;
8351 DECL_EXTERNAL (decl
) = 0;
8353 /* At top level, either `static' or no s.c. makes a definition
8354 (perhaps tentative), and absence of `static' makes it public. */
8355 else if (toplevel_bindings_p ())
8357 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
8358 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8359 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8361 /* Not at top level, only `static' makes a static definition. */
8364 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
8365 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8368 if (TREE_PUBLIC (decl
))
8370 /* [basic.link]: A name with no linkage (notably, the name of a class
8371 or enumeration declared in a local scope) shall not be used to
8372 declare an entity with linkage.
8374 Only check this for public decls for now. */
8375 tree t
= no_linkage_check (TREE_TYPE (decl
));
8378 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8379 /* Ignore for now; `enum { foo } e' is pretty common. */;
8381 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8389 /* Create a canonical pointer to member function type. */
8392 build_ptrmemfunc_type (type
)
8399 /* If a canonical type already exists for this type, use it. We use
8400 this method instead of type_hash_canon, because it only does a
8401 simple equality check on the list of field members. */
8403 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8406 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8408 u
= make_lang_type (UNION_TYPE
);
8409 IS_AGGR_TYPE (u
) = 0;
8410 fields
[0] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
, type
);
8411 fields
[1] = build_lang_field_decl (FIELD_DECL
, delta2_identifier
,
8413 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
8414 TYPE_NAME (u
) = NULL_TREE
;
8416 t
= make_lang_type (RECORD_TYPE
);
8418 /* Let the front-end know this is a pointer to member function... */
8419 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8420 /* ... and not really an aggregate. */
8421 IS_AGGR_TYPE (t
) = 0;
8423 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
8425 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
8427 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
8428 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
8432 /* Zap out the name so that the back-end will give us the debugging
8433 information for this anonymous RECORD_TYPE. */
8434 TYPE_NAME (t
) = NULL_TREE
;
8436 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8438 /* Seems to be wanted. */
8439 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
8443 /* Given declspecs and a declarator,
8444 determine the name and type of the object declared
8445 and construct a ..._DECL node for it.
8446 (In one case we can return a ..._TYPE node instead.
8447 For invalid input we sometimes return 0.)
8449 DECLSPECS is a chain of tree_list nodes whose value fields
8450 are the storage classes and type specifiers.
8452 DECL_CONTEXT says which syntactic context this declaration is in:
8453 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8454 FUNCDEF for a function definition. Like NORMAL but a few different
8455 error messages in each case. Return value may be zero meaning
8456 this definition is too screwy to try to parse.
8457 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8458 handle member functions (which have FIELD context).
8459 Return value may be zero meaning this definition is too screwy to
8461 PARM for a parameter declaration (either within a function prototype
8462 or before a function body). Make a PARM_DECL, or return void_type_node.
8463 CATCHPARM for a parameter declaration before a catch clause.
8464 TYPENAME if for a typename (in a cast or sizeof).
8465 Don't make a DECL node; just return the ..._TYPE node.
8466 FIELD for a struct or union field; make a FIELD_DECL.
8467 BITFIELD for a field with specified width.
8468 INITIALIZED is 1 if the decl has an initializer.
8470 In the TYPENAME case, DECLARATOR is really an absolute declarator.
8471 It may also be so in the PARM case, for a prototype where the
8472 argument type is specified but not the name.
8474 This function is where the complicated C meanings of `static'
8475 and `extern' are interpreted.
8477 For C++, if there is any monkey business to do, the function which
8478 calls this one must do it, i.e., prepending instance variables,
8479 renaming overloaded function names, etc.
8481 Note that for this C++, it is an error to define a method within a class
8482 which does not belong to that class.
8484 Except in the case where SCOPE_REFs are implicitly known (such as
8485 methods within a class being redundantly qualified),
8486 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
8487 (class_name::decl_name). The caller must also deal with this.
8489 If a constructor or destructor is seen, and the context is FIELD,
8490 then the type gains the attribute TREE_HAS_x. If such a declaration
8491 is erroneous, NULL_TREE is returned.
8493 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
8494 function, these are the qualifiers to give to the `this' pointer.
8496 May return void_type_node if the declarator turned out to be a friend.
8497 See grokfield for details. */
8499 enum return_types
{ return_normal
, return_ctor
, return_dtor
, return_conversion
};
8501 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8502 Check to see that the definition is valid. Issue appropriate error
8503 messages. Return 1 if the definition is particularly bad, or 0
8507 check_static_variable_definition (decl
, type
)
8511 /* Motion 10 at San Diego: If a static const integral data member is
8512 initialized with an integral constant expression, the initializer
8513 may appear either in the declaration (within the class), or in
8514 the definition, but not both. If it appears in the class, the
8515 member is a member constant. The file-scope definition is always
8517 if (CLASS_TYPE_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
8519 cp_error ("in-class initialization of static data member of non-integral type `%T'",
8521 /* If we just return the declaration, crashes will sometimes
8522 occur. We therefore return void_type_node, as if this was a
8523 friend declaration, to cause callers to completely ignore
8524 this declaration. */
8527 else if (!CP_TYPE_CONST_P (type
))
8528 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8530 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
8531 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
8537 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
8540 enum decl_context decl_context
;
8544 RID_BIT_TYPE specbits
;
8547 tree type
= NULL_TREE
;
8553 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8554 int explicit_int
= 0;
8555 int explicit_char
= 0;
8556 int defaulted_int
= 0;
8557 int opaque_typedef
= 0;
8558 tree typedef_decl
= NULL_TREE
;
8560 tree typedef_type
= NULL_TREE
;
8561 int funcdef_flag
= 0;
8562 enum tree_code innermost_code
= ERROR_MARK
;
8565 /* See the code below that used this. */
8566 tree decl_machine_attr
= NULL_TREE
;
8568 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
8569 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
8570 tree init
= NULL_TREE
;
8572 /* Keep track of what sort of function is being processed
8573 so that we can warn about default return values, or explicit
8574 return values which do not match prescribed defaults. */
8575 enum return_types return_type
= return_normal
;
8577 tree dname
= NULL_TREE
;
8578 tree ctype
= current_class_type
;
8579 tree ctor_return_type
= NULL_TREE
;
8580 enum overload_flags flags
= NO_SPECIAL
;
8581 tree quals
= NULL_TREE
;
8582 tree raises
= NULL_TREE
;
8583 int template_count
= 0;
8584 tree in_namespace
= NULL_TREE
;
8588 RIDBIT_RESET_ALL (specbits
);
8589 if (decl_context
== FUNCDEF
)
8590 funcdef_flag
= 1, decl_context
= NORMAL
;
8591 else if (decl_context
== MEMFUNCDEF
)
8592 funcdef_flag
= -1, decl_context
= FIELD
;
8593 else if (decl_context
== BITFIELD
)
8594 bitfield
= 1, decl_context
= FIELD
;
8596 /* Look inside a declarator for the name being declared
8597 and get it as a string, for an error message. */
8599 tree
*next
= &declarator
;
8603 while (next
&& *next
)
8606 switch (TREE_CODE (decl
))
8609 /* For attributes. */
8610 next
= &TREE_VALUE (decl
);
8615 next
= &TREE_OPERAND (decl
, 0);
8618 case BIT_NOT_EXPR
: /* For C++ destructors! */
8620 tree name
= TREE_OPERAND (decl
, 0);
8621 tree rename
= NULL_TREE
;
8623 my_friendly_assert (flags
== NO_SPECIAL
, 152);
8625 return_type
= return_dtor
;
8626 if (TREE_CODE (name
) == TYPE_DECL
)
8627 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
8628 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
8629 if (ctype
== NULL_TREE
)
8631 if (current_class_type
== NULL_TREE
)
8633 error ("destructors must be member functions");
8638 tree t
= constructor_name (current_class_name
);
8645 tree t
= constructor_name (ctype
);
8652 cp_error ("destructor `%T' must match class name `%T'",
8654 TREE_OPERAND (decl
, 0) = rename
;
8660 case ADDR_EXPR
: /* C++ reference declaration */
8665 innermost_code
= TREE_CODE (decl
);
8666 next
= &TREE_OPERAND (decl
, 0);
8670 if (parmlist_is_exprlist (TREE_OPERAND (decl
, 1)))
8672 /* This is actually a variable declaration using constructor
8673 syntax. We need to call start_decl and cp_finish_decl so we
8674 can get the variable initialized... */
8676 *next
= TREE_OPERAND (decl
, 0);
8677 init
= TREE_OPERAND (decl
, 1);
8679 decl
= start_decl (declarator
, declspecs
, 1, NULL_TREE
, NULL_TREE
);
8682 /* Look for __unused__ attribute */
8683 if (TREE_USED (TREE_TYPE (decl
)))
8684 TREE_USED (decl
) = 1;
8685 finish_decl (decl
, init
, NULL_TREE
);
8688 cp_error ("invalid declarator");
8691 innermost_code
= TREE_CODE (decl
);
8692 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
8693 ctype
= current_class_type
;
8695 && TREE_OPERAND (decl
, 0)
8696 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
8697 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
8698 == constructor_name_full (ctype
))
8699 || (DECL_NAME (TREE_OPERAND (decl
, 0))
8700 == constructor_name (ctype
)))))
8701 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8702 next
= &TREE_OPERAND (decl
, 0);
8704 if (ctype
!= NULL_TREE
8705 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
8706 && decl
== constructor_name (ctype
))
8708 return_type
= return_ctor
;
8709 ctor_return_type
= ctype
;
8714 case TEMPLATE_ID_EXPR
:
8716 tree fns
= TREE_OPERAND (decl
, 0);
8718 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
8719 fns
= TREE_OPERAND (fns
, 0);
8721 if (TREE_CODE (fns
) == IDENTIFIER_NODE
)
8723 else if (is_overloaded_fn (fns
))
8724 dname
= DECL_NAME (get_first_fn (fns
));
8726 my_friendly_abort (0);
8730 case IDENTIFIER_NODE
:
8731 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
8738 cp_error ("declarator-id missing; using reserved word `%D'",
8740 name
= IDENTIFIER_POINTER (dname
);
8742 if (! IDENTIFIER_OPNAME_P (dname
)
8743 /* GNU/Linux headers use '__op'. Arrgh. */
8744 || (IDENTIFIER_TYPENAME_P (dname
) && ! TREE_TYPE (dname
)))
8745 name
= IDENTIFIER_POINTER (dname
);
8748 if (IDENTIFIER_TYPENAME_P (dname
))
8750 my_friendly_assert (flags
== NO_SPECIAL
, 154);
8751 flags
= TYPENAME_FLAG
;
8752 ctor_return_type
= TREE_TYPE (dname
);
8753 return_type
= return_conversion
;
8755 name
= operator_name_string (dname
);
8762 /* Perform error checking, and decide on a ctype. */
8763 tree cname
= TREE_OPERAND (decl
, 0);
8764 if (cname
== NULL_TREE
)
8766 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
8769 in_namespace
= TREE_OPERAND (decl
, 0);
8770 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8772 else if (! is_aggr_type (cname
, 1))
8773 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8774 /* Must test TREE_OPERAND (decl, 1), in case user gives
8775 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
8776 else if (TREE_OPERAND (decl
, 1)
8777 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
8779 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
8780 || TREE_CODE (cname
) == TEMPLATE_TEMPLATE_PARM
)
8782 cp_error ("`%T::%D' is not a valid declarator", cname
,
8783 TREE_OPERAND (decl
, 1));
8784 cp_error (" perhaps you want `typename %T::%D' to make it a type",
8785 cname
, TREE_OPERAND (decl
, 1));
8786 return void_type_node
;
8788 else if (ctype
== NULL_TREE
)
8790 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
8791 TREE_OPERAND (decl
, 0) = ctype
;
8794 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
8796 cp_error ("type `%T' is not derived from type `%T'",
8798 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8804 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
8805 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
8806 == constructor_name_full (ctype
))
8807 || (DECL_NAME (TREE_OPERAND (decl
, 1))
8808 == constructor_name (ctype
))))
8809 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
8810 next
= &TREE_OPERAND (decl
, 1);
8814 if (TREE_CODE (decl
) == IDENTIFIER_NODE
8815 && constructor_name (ctype
) == decl
)
8817 return_type
= return_ctor
;
8818 ctor_return_type
= ctype
;
8820 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
8821 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
8822 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
8823 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
8825 return_type
= return_dtor
;
8826 ctor_return_type
= ctype
;
8828 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8829 next
= &TREE_OPERAND (decl
, 0);
8840 /* Parse error puts this typespec where
8841 a declarator should go. */
8842 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
8843 if (TREE_TYPE (decl
) == current_class_type
)
8844 cp_error (" perhaps you want `%T' for a constructor",
8845 current_class_name
);
8846 dname
= DECL_NAME (decl
);
8847 name
= IDENTIFIER_POINTER (dname
);
8849 /* Avoid giving two errors for this. */
8850 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
8852 declspecs
= temp_tree_cons (NULL_TREE
, integer_type_node
,
8859 cp_compiler_error ("`%D' as declarator", decl
);
8860 return 0; /* We used to do a 155 abort here. */
8867 /* A function definition's declarator must have the form of
8868 a function declarator. */
8870 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
8873 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8874 && innermost_code
!= CALL_EXPR
8875 && ! (ctype
&& declspecs
== NULL_TREE
))
8877 cp_error ("declaration of `%D' as non-function", dname
);
8878 return void_type_node
;
8881 /* Anything declared one level down from the top level
8882 must be one of the parameters of a function
8883 (because the body is at least two levels down). */
8885 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8886 by not allowing C++ class definitions to specify their parameters
8887 with xdecls (must be spec.d in the parmlist).
8889 Since we now wait to push a class scope until we are sure that
8890 we are in a legitimate method context, we must set oldcname
8891 explicitly (since current_class_name is not yet alive).
8893 We also want to avoid calling this a PARM if it is in a namespace. */
8895 if (decl_context
== NORMAL
&& ! namespace_bindings_p ()
8896 && ! pseudo_global_level_p ())
8898 struct binding_level
*b
= current_binding_level
;
8899 current_binding_level
= b
->level_chain
;
8900 if (current_binding_level
!= 0 && toplevel_bindings_p ())
8901 decl_context
= PARM
;
8902 current_binding_level
= b
;
8905 /* Look through the decl specs and record which ones appear.
8906 Some typespecs are defined as built-in typenames.
8907 Others, the ones that are modifiers of other types,
8908 are represented by bits in SPECBITS: set the bits for
8909 the modifiers that appear. Storage class keywords are also in SPECBITS.
8911 If there is a typedef name or a type, store the type in TYPE.
8912 This includes builtin typedefs such as `int'.
8914 Set EXPLICIT_INT if the type is `int' or `char' and did not
8915 come from a user typedef.
8917 Set LONGLONG if `long' is mentioned twice.
8919 For C++, constructors and destructors have their own fast treatment. */
8921 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
8926 /* Certain parse errors slip through. For example,
8927 `int class;' is not caught by the parser. Try
8928 weakly to recover here. */
8929 if (TREE_CODE (spec
) != TREE_LIST
)
8932 id
= TREE_VALUE (spec
);
8934 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8936 if (id
== ridpointers
[(int) RID_INT
]
8937 || id
== ridpointers
[(int) RID_CHAR
]
8938 || id
== ridpointers
[(int) RID_BOOL
]
8939 || id
== ridpointers
[(int) RID_WCHAR
])
8943 if (id
== ridpointers
[(int) RID_BOOL
])
8944 error ("`bool' is now a keyword");
8946 cp_error ("extraneous `%T' ignored", id
);
8950 if (id
== ridpointers
[(int) RID_INT
])
8952 else if (id
== ridpointers
[(int) RID_CHAR
])
8954 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
8958 /* C++ aggregate types. */
8959 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
8962 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
8964 type
= IDENTIFIER_TYPE_VALUE (id
);
8968 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
8970 if (ridpointers
[i
] == id
)
8972 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
8974 if (pedantic
&& ! in_system_header
&& warn_long_long
)
8975 pedwarn ("ANSI C++ does not support `long long'");
8977 error ("`long long long' is too long for GCC");
8981 else if (RIDBIT_SETP (i
, specbits
))
8982 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
8983 RIDBIT_SET (i
, specbits
);
8988 /* C++ aggregate types. */
8989 else if (TREE_CODE (id
) == TYPE_DECL
|| TREE_CODE (id
) == TEMPLATE_DECL
)
8992 cp_error ("multiple declarations `%T' and `%T'", type
,
8996 type
= TREE_TYPE (id
);
8997 TREE_VALUE (spec
) = type
;
9002 error ("two or more data types in declaration of `%s'", name
);
9003 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9005 register tree t
= lookup_name (id
, 1);
9006 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9007 error ("`%s' fails to be a typedef or built in type",
9008 IDENTIFIER_POINTER (id
));
9011 type
= TREE_TYPE (t
);
9013 /* See the code below that used this. */
9014 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
9019 else if (id
!= error_mark_node
)
9020 /* Can't change CLASS nodes into RECORD nodes here! */
9026 typedef_type
= type
;
9028 /* No type at all: default to `int', and set DEFAULTED_INT
9029 because it was not a user-defined typedef.
9030 Except when we have a `typedef' inside a signature, in
9031 which case the type defaults to `unknown type' and is
9032 instantiated when assigning to a signature pointer or ref. */
9034 if (type
== NULL_TREE
9035 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
9036 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9037 || RIDBIT_SETP (RID_LONG
, specbits
)
9038 || RIDBIT_SETP (RID_SHORT
, specbits
)))
9040 /* These imply 'int'. */
9041 type
= integer_type_node
;
9045 if (type
== NULL_TREE
)
9048 if (return_type
== return_dtor
)
9049 type
= void_type_node
;
9050 else if (return_type
== return_ctor
)
9051 type
= build_pointer_type (ctor_return_type
);
9052 else if (return_type
== return_conversion
)
9053 type
= ctor_return_type
;
9054 else if (current_class_type
9055 && IS_SIGNATURE (current_class_type
)
9056 && RIDBIT_SETP (RID_TYPEDEF
, specbits
)
9057 && (decl_context
== FIELD
|| decl_context
== NORMAL
))
9061 type
= copy_node (opaque_type_node
);
9067 if (warn_return_type
9068 && return_type
== return_normal
)
9069 /* Save warning until we know what is really going on. */
9070 warn_about_return_type
= 1;
9072 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9073 pedwarn ("ANSI C++ forbids typedef which does not specify a type");
9074 else if (innermost_code
!= CALL_EXPR
|| pedantic
9075 || (warn_return_type
&& return_type
== return_normal
))
9077 if (innermost_code
== CALL_EXPR
)
9078 cp_pedwarn ("return-type of `%D' defaults to `int'", dname
);
9080 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
9083 type
= integer_type_node
;
9086 else if (return_type
== return_dtor
)
9088 error ("return type specification for destructor invalid");
9089 type
= void_type_node
;
9091 else if (return_type
== return_ctor
)
9093 error ("return type specification for constructor invalid");
9094 type
= build_pointer_type (ctor_return_type
);
9096 else if (return_type
== return_conversion
)
9098 if (!same_type_p (type
, ctor_return_type
))
9099 cp_error ("operator `%T' declared to return `%T'",
9100 ctor_return_type
, type
);
9102 cp_pedwarn ("return type specified for `operator %T'",
9105 type
= ctor_return_type
;
9110 /* Now process the modifiers that were specified
9111 and check for invalid combinations. */
9113 /* Long double is a special combination. */
9115 if (RIDBIT_SETP (RID_LONG
, specbits
)
9116 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
9118 RIDBIT_RESET (RID_LONG
, specbits
);
9119 type
= build_qualified_type (long_double_type_node
,
9120 CP_TYPE_QUALS (type
));
9123 /* Check all other uses of type modifiers. */
9125 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9126 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9127 || RIDBIT_SETP (RID_LONG
, specbits
)
9128 || RIDBIT_SETP (RID_SHORT
, specbits
))
9132 if (TREE_CODE (type
) == REAL_TYPE
)
9133 error ("short, signed or unsigned invalid for `%s'", name
);
9134 else if (TREE_CODE (type
) != INTEGER_TYPE
)
9135 error ("long, short, signed or unsigned invalid for `%s'", name
);
9136 else if (RIDBIT_SETP (RID_LONG
, specbits
)
9137 && RIDBIT_SETP (RID_SHORT
, specbits
))
9138 error ("long and short specified together for `%s'", name
);
9139 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9140 || RIDBIT_SETP (RID_SHORT
, specbits
))
9142 error ("long or short specified with char for `%s'", name
);
9143 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9144 || RIDBIT_SETP (RID_SHORT
, specbits
))
9145 && TREE_CODE (type
) == REAL_TYPE
)
9146 error ("long or short specified with floating type for `%s'", name
);
9147 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9148 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
9149 error ("signed and unsigned given together for `%s'", name
);
9153 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
9155 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9157 if (flag_pedantic_errors
)
9162 /* Discard the type modifiers if they are invalid. */
9165 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
9166 RIDBIT_RESET (RID_SIGNED
, specbits
);
9167 RIDBIT_RESET (RID_LONG
, specbits
);
9168 RIDBIT_RESET (RID_SHORT
, specbits
);
9173 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
9174 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9176 error ("complex invalid for `%s'", name
);
9177 RIDBIT_RESET (RID_COMPLEX
, specbits
);
9180 /* Decide whether an integer type is signed or not.
9181 Optionally treat bitfields as signed by default. */
9182 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9183 || (bitfield
&& ! flag_signed_bitfields
9184 && (explicit_int
|| defaulted_int
|| explicit_char
9185 /* A typedef for plain `int' without `signed'
9186 can be controlled just like plain `int'. */
9187 || ! (typedef_decl
!= NULL_TREE
9188 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
9189 && TREE_CODE (type
) != ENUMERAL_TYPE
9190 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)))
9193 type
= long_long_unsigned_type_node
;
9194 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9195 type
= long_unsigned_type_node
;
9196 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9197 type
= short_unsigned_type_node
;
9198 else if (type
== char_type_node
)
9199 type
= unsigned_char_type_node
;
9200 else if (typedef_decl
)
9201 type
= unsigned_type (type
);
9203 type
= unsigned_type_node
;
9205 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9206 && type
== char_type_node
)
9207 type
= signed_char_type_node
;
9209 type
= long_long_integer_type_node
;
9210 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9211 type
= long_integer_type_node
;
9212 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9213 type
= short_integer_type_node
;
9215 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
9217 /* If we just have "complex", it is equivalent to
9218 "complex double", but if any modifiers at all are specified it is
9219 the complex form of TYPE. E.g, "complex short" is
9220 "complex short int". */
9222 if (defaulted_int
&& ! longlong
9223 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
9224 || RIDBIT_SETP (RID_SHORT
, specbits
)
9225 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9226 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
9227 type
= complex_double_type_node
;
9228 else if (type
== integer_type_node
)
9229 type
= complex_integer_type_node
;
9230 else if (type
== float_type_node
)
9231 type
= complex_float_type_node
;
9232 else if (type
== double_type_node
)
9233 type
= complex_double_type_node
;
9234 else if (type
== long_double_type_node
)
9235 type
= complex_long_double_type_node
;
9237 type
= build_complex_type (type
);
9240 if (return_type
== return_conversion
9241 && (RIDBIT_SETP (RID_CONST
, specbits
)
9242 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
9243 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
9244 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9247 /* Set CONSTP if this declaration is `const', whether by
9248 explicit specification or via a typedef.
9249 Likewise for VOLATILEP. */
9251 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
9253 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
9255 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
9256 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9257 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9258 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9259 type
= cp_build_qualified_type (type
, type_quals
);
9261 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
9262 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
9263 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
9264 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
9265 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
9267 if (RIDBIT_SETP (RID_STATIC
, specbits
))
9268 staticp
= 1 + (decl_context
== FIELD
);
9270 if (virtualp
&& staticp
== 2)
9272 cp_error ("member `%D' cannot be declared both virtual and static",
9276 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
9277 RIDBIT_RESET (RID_FRIEND
, specbits
);
9279 /* $7.1.2, Function specifiers */
9280 if (friendp
&& explicitp
)
9281 error ("only declarations of constructors can be `explicit'");
9283 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9285 if (decl_context
== PARM
)
9287 error ("non-member `%s' cannot be declared `mutable'", name
);
9288 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9290 else if (friendp
|| decl_context
== TYPENAME
)
9292 error ("non-object member `%s' cannot be declared `mutable'", name
);
9293 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9297 /* Warn if two storage classes are given. Default to `auto'. */
9299 if (RIDBIT_ANY_SET (specbits
))
9301 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
9302 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
9303 if (decl_context
== PARM
&& nclasses
> 0)
9304 error ("storage class specifiers invalid in parameter declarations");
9305 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9307 if (decl_context
== PARM
)
9308 error ("typedef declaration invalid in parameter declaration");
9311 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
9312 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
9315 /* Give error if `virtual' is used outside of class declaration. */
9317 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9319 error ("virtual outside class declaration");
9322 if (current_class_name
== NULL_TREE
&& RIDBIT_SETP (RID_MUTABLE
, specbits
))
9324 error ("only members can be declared mutable");
9325 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9328 /* Static anonymous unions are dealt with here. */
9329 if (staticp
&& decl_context
== TYPENAME
9330 && TREE_CODE (declspecs
) == TREE_LIST
9331 && ANON_UNION_TYPE_P (TREE_VALUE (declspecs
)))
9332 decl_context
= FIELD
;
9334 /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
9335 is used in a signature member function declaration. */
9336 if (decl_context
== FIELD
9337 && IS_SIGNATURE (current_class_type
)
9338 && RIDBIT_NOTSETP (RID_TYPEDEF
, specbits
))
9340 if (type_quals
!= TYPE_UNQUALIFIED
)
9342 error ("type qualifiers specified for signature member function `%s'", name
);
9343 type_quals
= TYPE_UNQUALIFIED
;
9347 error ("`inline' specified for signature member function `%s'", name
);
9348 /* Later, we'll make signature member functions inline. */
9353 error ("`friend' declaration in signature definition");
9358 error ("`virtual' specified for signature member function `%s'",
9360 /* Later, we'll make signature member functions virtual. */
9365 /* Warn about storage classes that are invalid for certain
9366 kinds of declarations (parameters, typenames, etc.). */
9369 error ("multiple storage classes in declaration of `%s'", name
);
9370 else if (decl_context
!= NORMAL
&& nclasses
> 0)
9372 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9373 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
9374 || RIDBIT_SETP (RID_AUTO
, specbits
)))
9376 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9378 else if (decl_context
== FIELD
9379 && ! IS_SIGNATURE (current_class_type
)
9380 /* C++ allows static class elements */
9381 && RIDBIT_SETP (RID_STATIC
, specbits
))
9382 /* C++ also allows inlines and signed and unsigned elements,
9383 but in those cases we don't come in here. */
9387 if (decl_context
== FIELD
)
9389 tree tmp
= NULL_TREE
;
9390 register int op
= 0;
9394 /* Avoid trying to get an operand off an identifier node. */
9395 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
9398 tmp
= TREE_OPERAND (declarator
, 0);
9399 op
= IDENTIFIER_OPNAME_P (tmp
);
9401 error ("storage class specified for %s `%s'",
9402 IS_SIGNATURE (current_class_type
)
9404 ? "signature member operator"
9405 : "signature member function")
9406 : (op
? "member operator" : "field"),
9407 op
? operator_name_string (tmp
) : name
);
9410 error (((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9411 ? "storage class specified for parameter `%s'"
9412 : "storage class specified for typename"), name
);
9413 RIDBIT_RESET (RID_REGISTER
, specbits
);
9414 RIDBIT_RESET (RID_AUTO
, specbits
);
9415 RIDBIT_RESET (RID_EXTERN
, specbits
);
9417 if (decl_context
== FIELD
&& IS_SIGNATURE (current_class_type
))
9419 RIDBIT_RESET (RID_STATIC
, specbits
);
9424 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
9426 if (toplevel_bindings_p ())
9428 /* It's common practice (and completely valid) to have a const
9429 be initialized and declared extern. */
9430 if (!(type_quals
& TYPE_QUAL_CONST
))
9431 warning ("`%s' initialized and declared `extern'", name
);
9434 error ("`%s' has both `extern' and initializer", name
);
9436 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
9437 && ! toplevel_bindings_p ())
9438 error ("nested function `%s' declared `extern'", name
);
9439 else if (toplevel_bindings_p ())
9441 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9442 error ("top-level declaration of `%s' specifies `auto'", name
);
9445 if (nclasses
> 0 && friendp
)
9446 error ("storage class specifiers invalid in friend function declarations");
9448 /* Now figure out the structure of the declarator proper.
9449 Descend through it, creating more complex types, until we reach
9450 the declared identifier (or NULL_TREE, in an absolute declarator). */
9452 inner_attrs
= NULL_TREE
;
9455 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
9456 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
9458 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9459 an INDIRECT_REF (for *...),
9460 a CALL_EXPR (for ...(...)),
9461 an identifier (for the name being declared)
9462 or a null pointer (for the place in an absolute declarator
9463 where the name was omitted).
9464 For the last two cases, we have just exited the loop.
9466 For C++ it could also be
9467 a SCOPE_REF (for class :: ...). In this case, we have converted
9468 sensible names to types, and those are the values we use to
9469 qualify the member name.
9470 an ADDR_EXPR (for &...),
9471 a BIT_NOT_EXPR (for destructors)
9473 At this point, TYPE is the type of elements of an array,
9474 or for a function to return, or for a pointer to point to.
9475 After this sequence of ifs, TYPE is the type of the
9476 array or function or pointer, and DECLARATOR has had its
9477 outermost layer removed. */
9479 if (type
== error_mark_node
)
9481 if (TREE_CODE (declarator
) == SCOPE_REF
)
9482 declarator
= TREE_OPERAND (declarator
, 1);
9484 declarator
= TREE_OPERAND (declarator
, 0);
9487 if (quals
!= NULL_TREE
9488 && (declarator
== NULL_TREE
9489 || TREE_CODE (declarator
) != SCOPE_REF
))
9491 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
9492 ctype
= TYPE_METHOD_BASETYPE (type
);
9493 if (ctype
!= NULL_TREE
)
9495 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
9496 ctype
= grok_method_quals (ctype
, dummy
, quals
);
9497 type
= TREE_TYPE (dummy
);
9502 /* See the comment for the TREE_LIST case, below. */
9505 else if (inner_attrs
)
9507 decl_attributes (type
, inner_attrs
, NULL_TREE
);
9508 inner_attrs
= NULL_TREE
;
9511 switch (TREE_CODE (declarator
))
9515 /* We encode a declarator with embedded attributes using
9516 a TREE_LIST. The attributes apply to the declarator
9517 directly inside them, so we have to skip an iteration
9518 before applying them to the type. If the declarator just
9519 inside is the declarator-id, we apply the attrs to the
9521 inner_attrs
= TREE_PURPOSE (declarator
);
9523 declarator
= TREE_VALUE (declarator
);
9529 register tree itype
= NULL_TREE
;
9530 register tree size
= TREE_OPERAND (declarator
, 1);
9531 /* The index is a signed object `sizetype' bits wide. */
9532 tree index_type
= signed_type (sizetype
);
9534 declarator
= TREE_OPERAND (declarator
, 0);
9536 /* Check for some types that there cannot be arrays of. */
9538 if (TREE_CODE (type
) == VOID_TYPE
)
9540 cp_error ("declaration of `%D' as array of voids", dname
);
9541 type
= error_mark_node
;
9544 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9546 cp_error ("declaration of `%D' as array of functions", dname
);
9547 type
= error_mark_node
;
9550 /* ARM $8.4.3: Since you can't have a pointer to a reference,
9551 you can't have arrays of references. If we allowed them,
9552 then we'd be saying x[i] is valid for an array x, but
9553 then you'd have to ask: what does `*(x + i)' mean? */
9554 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9556 if (decl_context
== TYPENAME
)
9557 cp_error ("cannot make arrays of references");
9559 cp_error ("declaration of `%D' as array of references",
9561 type
= error_mark_node
;
9564 if (TREE_CODE (type
) == OFFSET_TYPE
)
9566 cp_error ("declaration of `%D' as array of data members",
9568 type
= error_mark_node
;
9571 if (TREE_CODE (type
) == METHOD_TYPE
)
9573 cp_error ("declaration of `%D' as array of function members",
9575 type
= error_mark_node
;
9578 if (size
== error_mark_node
)
9579 type
= error_mark_node
;
9580 else if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9584 the constant expressions that specify the bounds of
9585 the arrays can be omitted only for the first member
9587 cp_error ("declaration of `%D' as multidimensional array",
9589 cp_error ("must have bounds for all dimensions except the first");
9590 type
= error_mark_node
;
9593 if (type
== error_mark_node
)
9598 /* Must suspend_momentary here because the index
9599 type may need to live until the end of the function.
9600 For example, it is used in the declaration of a
9601 variable which requires destructing at the end of
9602 the function; then build_vec_delete will need this
9604 int yes
= suspend_momentary ();
9605 /* Might be a cast. */
9606 if (TREE_CODE (size
) == NOP_EXPR
9607 && TREE_TYPE (size
) == TREE_TYPE (TREE_OPERAND (size
, 0)))
9608 size
= TREE_OPERAND (size
, 0);
9610 /* If this involves a template parameter, it'll be
9611 constant, but we don't know what the value is yet. */
9612 if (processing_template_decl
)
9614 /* Resolve a qualified reference to an enumerator or
9615 static const data member of ours. */
9616 if (TREE_CODE (size
) == SCOPE_REF
9617 && TREE_OPERAND (size
, 0) == current_class_type
)
9619 tree t
= lookup_field (current_class_type
,
9620 TREE_OPERAND (size
, 1), 0, 0);
9625 itype
= make_node (INTEGER_TYPE
);
9626 TYPE_MIN_VALUE (itype
) = size_zero_node
;
9627 TYPE_MAX_VALUE (itype
) = build_min
9628 (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
9629 goto dont_grok_size
;
9632 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
9633 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
)
9635 cp_error ("size of array `%D' has non-integer type",
9637 size
= integer_one_node
;
9639 if (TREE_READONLY_DECL_P (size
))
9640 size
= decl_constant_value (size
);
9641 if (pedantic
&& integer_zerop (size
))
9642 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname
);
9643 if (TREE_CONSTANT (size
))
9645 int old_flag_pedantic_errors
= flag_pedantic_errors
;
9646 int old_pedantic
= pedantic
;
9647 pedantic
= flag_pedantic_errors
= 1;
9648 /* Always give overflow errors on array subscripts. */
9649 constant_expression_warning (size
);
9650 pedantic
= old_pedantic
;
9651 flag_pedantic_errors
= old_flag_pedantic_errors
;
9652 if (INT_CST_LT (size
, integer_zero_node
))
9654 cp_error ("size of array `%D' is negative", dname
);
9655 size
= integer_one_node
;
9663 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
9666 cp_pedwarn ("ANSI C++ forbids variable-size array");
9671 = fold (build_binary_op (MINUS_EXPR
,
9672 cp_convert (index_type
, size
),
9673 cp_convert (index_type
,
9674 integer_one_node
), 1));
9675 if (! TREE_CONSTANT (itype
))
9676 itype
= variable_size (itype
);
9677 else if (TREE_OVERFLOW (itype
))
9679 error ("overflow in array dimension");
9680 TREE_OVERFLOW (itype
) = 0;
9683 /* If we're a parm, we need to have a permanent type so
9684 mangling checks for re-use will work right. If both the
9685 element and index types are permanent, the array type
9687 if (decl_context
== PARM
9688 && allocation_temporary_p () && TREE_PERMANENT (type
))
9690 push_obstacks (&permanent_obstack
, &permanent_obstack
);
9691 itype
= build_index_type (itype
);
9695 itype
= build_index_type (itype
);
9698 resume_momentary (yes
);
9701 type
= build_cplus_array_type (type
, itype
);
9710 tree inner_parms
= TREE_OPERAND (declarator
, 1);
9711 tree inner_decl
= TREE_OPERAND (declarator
, 0);
9713 /* Declaring a function type.
9714 Make sure we have a valid type for the function to return. */
9716 /* We now know that the TYPE_QUALS don't apply to the
9717 decl, but to its return type. */
9718 type_quals
= TYPE_UNQUALIFIED
;
9720 /* Warn about some types functions can't return. */
9722 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9724 error ("`%s' declared as function returning a function", name
);
9725 type
= integer_type_node
;
9727 if (TREE_CODE (type
) == ARRAY_TYPE
)
9729 error ("`%s' declared as function returning an array", name
);
9730 type
= integer_type_node
;
9733 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
9734 inner_decl
= TREE_OPERAND (inner_decl
, 1);
9736 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
9739 /* Pick up type qualifiers which should be applied to `this'. */
9740 quals
= TREE_OPERAND (declarator
, 2);
9742 /* Pick up the exception specifications. */
9743 raises
= TREE_TYPE (declarator
);
9745 /* Say it's a definition only for the CALL_EXPR
9746 closest to the identifier. */
9749 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
9750 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
9751 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
9753 if (ctype
== NULL_TREE
9754 && decl_context
== FIELD
9756 && (friendp
== 0 || dname
== current_class_name
))
9757 ctype
= current_class_type
;
9759 if (ctype
&& return_type
== return_conversion
)
9760 TYPE_HAS_CONVERSION (ctype
) = 1;
9761 if (ctype
&& constructor_name (ctype
) == dname
)
9763 /* We are within a class's scope. If our declarator name
9764 is the same as the class name, and we are defining
9765 a function, then it is a constructor/destructor, and
9766 therefore returns a void type. */
9768 if (flags
== DTOR_FLAG
)
9770 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
9771 not be declared const or volatile. A destructor
9772 may not be static. */
9774 error ("destructor cannot be static member function");
9777 cp_error ("destructors may not be `%s'",
9778 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9781 if (decl_context
== FIELD
)
9783 if (! member_function_or_else (ctype
, current_class_type
,
9784 "destructor for alien class `%s' cannot be a member"))
9785 return void_type_node
;
9788 else /* It's a constructor. */
9792 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
9793 not be declared const or volatile. A constructor may
9794 not be virtual. A constructor may not be static. */
9796 error ("constructor cannot be static member function");
9799 pedwarn ("constructors cannot be declared virtual");
9804 cp_error ("constructors may not be `%s'",
9805 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9809 RID_BIT_TYPE tmp_bits
;
9810 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
9811 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
9812 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
9813 if (RIDBIT_ANY_SET (tmp_bits
))
9814 error ("return value type specifier for constructor ignored");
9816 type
= build_pointer_type (ctype
);
9817 if (decl_context
== FIELD
9818 && IS_SIGNATURE (current_class_type
))
9820 error ("constructor not allowed in signature");
9821 return void_type_node
;
9823 else if (decl_context
== FIELD
)
9825 if (! member_function_or_else (ctype
, current_class_type
,
9826 "constructor for alien class `%s' cannot be member"))
9827 return void_type_node
;
9828 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
9829 if (return_type
!= return_ctor
)
9833 if (decl_context
== FIELD
)
9839 error ("can't initialize friend function `%s'", name
);
9842 /* Cannot be both friend and virtual. */
9843 error ("virtual functions cannot be friends");
9844 RIDBIT_RESET (RID_FRIEND
, specbits
);
9847 if (decl_context
== NORMAL
)
9848 error ("friend declaration not in class definition");
9849 if (current_function_decl
&& funcdef_flag
)
9850 cp_error ("can't define friend function `%s' in a local class definition",
9854 /* Construct the function type and go to the next
9855 inner layer of declarator. */
9857 declarator
= TREE_OPERAND (declarator
, 0);
9859 /* FIXME: This is where default args should be fully
9862 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
9864 if (declarator
&& flags
== DTOR_FLAG
)
9866 /* A destructor declared in the body of a class will
9867 be represented as a BIT_NOT_EXPR. But, we just
9868 want the underlying IDENTIFIER. */
9869 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
9870 declarator
= TREE_OPERAND (declarator
, 0);
9872 if (strict_prototype
== 0 && arg_types
== NULL_TREE
)
9873 arg_types
= void_list_node
;
9874 else if (arg_types
== NULL_TREE
9875 || arg_types
!= void_list_node
)
9877 cp_error ("destructors may not have parameters");
9878 arg_types
= void_list_node
;
9879 last_function_parms
= NULL_TREE
;
9883 /* ANSI says that `const int foo ();'
9884 does not make the function foo const. */
9885 type
= build_function_type (type
, arg_types
);
9889 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
9890 if (TREE_PURPOSE (t
)
9891 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
9893 add_defarg_fn (type
);
9902 /* Filter out pointers-to-references and references-to-references.
9903 We can get these if a TYPE_DECL is used. */
9905 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9907 error ("cannot declare %s to references",
9908 TREE_CODE (declarator
) == ADDR_EXPR
9909 ? "references" : "pointers");
9910 declarator
= TREE_OPERAND (declarator
, 0);
9914 if (TREE_CODE (type
) == OFFSET_TYPE
9915 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
9916 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
9918 cp_error ("cannot declare pointer to `%#T' member",
9920 type
= TREE_TYPE (type
);
9923 /* Merge any constancy or volatility into the target type
9926 /* We now know that the TYPE_QUALS don't apply to the decl,
9927 but to the target of the pointer. */
9928 type_quals
= TYPE_UNQUALIFIED
;
9930 if (IS_SIGNATURE (type
))
9932 if (TREE_CODE (declarator
) == ADDR_EXPR
)
9934 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9935 && TYPE_SIZE (type
))
9936 cp_warning ("empty signature `%T' used in signature reference declaration",
9939 type
= build_signature_reference_type (type
);
9941 sorry ("signature reference");
9947 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9948 && TYPE_SIZE (type
))
9949 cp_warning ("empty signature `%T' used in signature pointer declaration",
9951 type
= build_signature_pointer_type (type
);
9954 else if (TREE_CODE (declarator
) == ADDR_EXPR
)
9956 if (TREE_CODE (type
) == VOID_TYPE
)
9957 error ("invalid type: `void &'");
9959 type
= build_reference_type (type
);
9961 else if (TREE_CODE (type
) == METHOD_TYPE
)
9963 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9966 type
= build_pointer_type (type
);
9968 /* Process a list of type modifier keywords (such as
9969 const or volatile) that were given inside the `*' or `&'. */
9971 if (TREE_TYPE (declarator
))
9973 register tree typemodlist
;
9979 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
9980 typemodlist
= TREE_CHAIN (typemodlist
))
9982 tree qualifier
= TREE_VALUE (typemodlist
);
9984 if (qualifier
== ridpointers
[(int) RID_CONST
])
9986 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
9988 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
9993 error ("invalid type modifier within pointer declarator");
9997 pedwarn ("duplicate `const'");
9999 pedwarn ("duplicate `volatile'");
10001 pedwarn ("duplicate `restrict'");
10003 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10004 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10005 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10006 if (TREE_CODE (declarator
) == ADDR_EXPR
10007 && (constp
|| volatilep
))
10010 pedwarn ("discarding `const' applied to a reference");
10012 pedwarn ("discarding `volatile' applied to a reference");
10013 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
10015 type
= cp_build_qualified_type (type
, type_quals
);
10017 declarator
= TREE_OPERAND (declarator
, 0);
10023 /* We have converted type names to NULL_TREE if the
10024 name was bogus, or to a _TYPE node, if not.
10026 The variable CTYPE holds the type we will ultimately
10027 resolve to. The code here just needs to build
10028 up appropriate member types. */
10029 tree sname
= TREE_OPERAND (declarator
, 1);
10032 /* Destructors can have their visibilities changed as well. */
10033 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
10034 sname
= TREE_OPERAND (sname
, 0);
10036 if (TREE_COMPLEXITY (declarator
) == 0)
10037 /* This needs to be here, in case we are called
10038 multiple times. */ ;
10039 else if (TREE_COMPLEXITY (declarator
) == -1)
10040 /* Namespace member. */
10041 pop_decl_namespace ();
10042 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
10043 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10044 else if (! IS_AGGR_TYPE_CODE
10045 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
10047 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
10049 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10050 that refer to ctype. They couldn't be resolved earlier
10051 because we hadn't pushed into the class yet.
10052 Example: resolve 'B<T>::type' in
10053 'B<typename B<T>::type> B<T>::f () { }'. */
10054 if (current_template_parms
10055 && uses_template_parms (type
)
10056 && uses_template_parms (current_class_type
))
10058 tree args
= current_template_args ();
10059 type
= tsubst (type
, args
, NULL_TREE
);
10062 /* This pop_nested_class corresponds to the
10063 push_nested_class used to push into class scope for
10064 parsing the argument list of a function decl, in
10066 pop_nested_class (1);
10067 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10070 my_friendly_abort (16);
10072 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10074 /* We had a reference to a global decl, or
10075 perhaps we were given a non-aggregate typedef,
10076 in which case we cleared this out, and should just
10077 keep going as though it wasn't there. */
10078 declarator
= sname
;
10081 ctype
= TREE_OPERAND (declarator
, 0);
10084 while (t
!= NULL_TREE
)
10086 if (CLASSTYPE_TEMPLATE_INFO (t
) &&
10087 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
10088 template_count
+= 1;
10089 t
= TYPE_MAIN_DECL (t
);
10090 if (DECL_LANG_SPECIFIC (t
))
10091 t
= DECL_CLASS_CONTEXT (t
);
10096 if (sname
== NULL_TREE
)
10099 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10101 /* This is the `standard' use of the scoping operator:
10102 basetype :: member . */
10104 if (ctype
== current_class_type
)
10110 Is this ill-formed? */
10113 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10116 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10118 if (current_class_type
== NULL_TREE
10120 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10121 TYPE_ARG_TYPES (type
));
10124 cp_error ("cannot declare member function `%T::%s' within `%T'",
10125 ctype
, name
, current_class_type
);
10126 return void_type_node
;
10129 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10130 || TYPE_SIZE (complete_type (ctype
)) != NULL_TREE
)
10132 /* Have to move this code elsewhere in this function.
10133 this code is used for i.e., typedef int A::M; M *pm;
10135 It is? How? jason 10/2/94 */
10137 if (current_class_type
)
10139 cp_error ("cannot declare member `%T::%s' within `%T'",
10140 ctype
, name
, current_class_type
);
10141 return void_type_node
;
10143 type
= build_offset_type (ctype
, type
);
10145 else if (uses_template_parms (ctype
))
10147 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10149 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
10150 TYPE_ARG_TYPES (type
));
10154 cp_error ("structure `%T' not yet defined", ctype
);
10155 return error_mark_node
;
10158 declarator
= sname
;
10160 else if (TREE_CODE (sname
) == SCOPE_REF
)
10161 my_friendly_abort (17);
10165 declarator
= TREE_OPERAND (declarator
, 1);
10166 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
10167 /* In this case, we will deal with it later. */
10171 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10172 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10173 TYPE_ARG_TYPES (type
));
10175 type
= build_offset_type (ctype
, type
);
10182 declarator
= TREE_OPERAND (declarator
, 0);
10187 case ENUMERAL_TYPE
:
10188 declarator
= NULL_TREE
;
10192 declarator
= NULL_TREE
;
10196 my_friendly_abort (158);
10200 /* See the comment for the TREE_LIST case, above. */
10203 if (! ignore_attrs
)
10204 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10206 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
10208 attrlist
= build_decl_list (NULL_TREE
, inner_attrs
);
10211 if (explicitp
== 1)
10213 error ("only constructors can be declared `explicit'");
10217 /* Now TYPE has the actual type. */
10219 /* If this is declaring a typedef name, return a TYPE_DECL. */
10221 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10223 if (type_quals
& TYPE_QUAL_CONST
)
10225 error ("const `%s' cannot be declared `mutable'", name
);
10226 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10230 error ("static `%s' cannot be declared `mutable'", name
);
10231 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10235 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
10239 /* Note that the grammar rejects storage classes
10240 in typenames, fields or parameters. */
10241 if (current_lang_name
== lang_name_java
)
10242 TYPE_FOR_JAVA (type
) = 1;
10244 if (decl_context
== FIELD
)
10246 if (declarator
== current_class_name
)
10247 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10249 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10250 if (IS_SIGNATURE (current_class_type
) && opaque_typedef
)
10251 SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type
) = 1;
10255 /* Make sure this typedef lives as long as its type,
10256 since it might be used as a template parameter. */
10257 if (type
!= error_mark_node
)
10258 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
10259 decl
= build_decl (TYPE_DECL
, declarator
, type
);
10260 if (type
!= error_mark_node
)
10264 /* If the user declares "struct {...} foo" then `foo' will have
10265 an anonymous name. Fill that name in now. Nothing can
10266 refer to it, so nothing needs know about the name change.
10267 The TYPE_NAME field was filled in by build_struct_xref. */
10268 if (type
!= error_mark_node
10269 && TYPE_NAME (type
)
10270 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10271 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
10273 /* FIXME: This is bogus; we should not be doing this for
10274 cv-qualified types. */
10276 /* For anonymous structs that are cv-qualified, need to use
10277 TYPE_MAIN_VARIANT so that name will mangle correctly. As
10278 type not referenced after this block, don't bother
10279 resetting type to original type, ie. TREE_TYPE (decl). */
10280 type
= TYPE_MAIN_VARIANT (type
);
10282 /* Replace the anonymous name with the real name everywhere. */
10283 lookup_tag_reverse (type
, declarator
);
10284 TYPE_NAME (type
) = decl
;
10286 if (TYPE_LANG_SPECIFIC (type
))
10287 TYPE_WAS_ANONYMOUS (type
) = 1;
10289 /* XXX Temporarily set the scope.
10290 When returning, start_decl expects it as NULL_TREE,
10291 and will then then set it using pushdecl. */
10292 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
10293 if (current_class_type
)
10294 DECL_CONTEXT (decl
) = current_class_type
;
10296 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10298 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
10299 DECL_ASSEMBLER_NAME (decl
)
10300 = get_identifier (build_overload_name (type
, 1, 1));
10301 DECL_CONTEXT (decl
) = NULL_TREE
;
10303 /* FIXME remangle member functions; member functions of a
10304 type with external linkage have external linkage. */
10307 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10309 cp_error_at ("typedef name may not be class-qualified", decl
);
10314 if (ctype
== NULL_TREE
)
10316 if (TREE_CODE (type
) != METHOD_TYPE
)
10317 cp_error_at ("invalid type qualifier for non-method type", decl
);
10319 ctype
= TYPE_METHOD_BASETYPE (type
);
10321 if (ctype
!= NULL_TREE
)
10322 grok_method_quals (ctype
, decl
, quals
);
10325 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10326 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10327 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10329 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10330 error ("non-object member `%s' cannot be declared mutable", name
);
10332 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
10333 inlinep
, friendp
, raises
!= NULL_TREE
);
10336 error ("typedef declaration includes an initializer");
10341 /* Detect the case of an array type of unspecified size
10342 which came, as such, direct from a typedef name.
10343 We must copy the type, so that each identifier gets
10344 a distinct type, so that each identifier's size can be
10345 controlled separately by its own initializer. */
10347 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
10348 && TYPE_DOMAIN (type
) == NULL_TREE
)
10350 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
10353 /* If this is a type name (such as, in a cast or sizeof),
10354 compute the type and return it now. */
10356 if (decl_context
== TYPENAME
)
10358 /* Note that the grammar rejects storage classes
10359 in typenames, fields or parameters. */
10360 if (type_quals
!= TYPE_UNQUALIFIED
)
10362 if (IS_SIGNATURE (type
))
10363 error ("type qualifiers specified for signature type");
10364 type_quals
= TYPE_UNQUALIFIED
;
10367 /* Special case: "friend class foo" looks like a TYPENAME context. */
10370 if (type_quals
!= TYPE_UNQUALIFIED
)
10372 cp_error ("type qualifiers specified for friend class declaration");
10373 type_quals
= TYPE_UNQUALIFIED
;
10377 cp_error ("`inline' specified for friend class declaration");
10381 /* Only try to do this stuff if we didn't already give up. */
10382 if (type
!= integer_type_node
)
10384 /* A friendly class? */
10385 if (current_class_type
)
10386 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
10388 error ("trying to make class `%s' a friend of global scope",
10389 TYPE_NAME_STRING (type
));
10390 type
= void_type_node
;
10395 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
10396 if (ctype
== NULL_TREE
)
10398 my_friendly_assert (TREE_CODE (type
) == METHOD_TYPE
, 159);
10399 ctype
= TYPE_METHOD_BASETYPE (type
);
10401 grok_method_quals (ctype
, dummy
, quals
);
10402 type
= TREE_TYPE (dummy
);
10407 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
10408 && decl_context
!= CATCHPARM
10409 && TREE_CODE (type
) != UNION_TYPE
10412 cp_error ("abstract declarator `%T' used as declaration", type
);
10413 declarator
= make_anon_name ();
10416 /* `void' at top level (not within pointer)
10417 is allowed only in typedefs or type names.
10418 We don't complain about parms either, but that is because
10419 a better error message can be made later. */
10421 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
10424 error ("unnamed variable or field declared void");
10425 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10427 if (IDENTIFIER_OPNAME_P (declarator
))
10428 my_friendly_abort (356);
10430 error ("variable or field `%s' declared void", name
);
10433 error ("variable or field declared void");
10434 type
= integer_type_node
;
10437 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10438 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10440 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10442 if (ctype
|| in_namespace
)
10443 error ("cannot use `::' in parameter declaration");
10445 /* A parameter declared as an array of T is really a pointer to T.
10446 One declared as a function is really a pointer to a function.
10447 One declared as a member is really a pointer to member. */
10449 if (TREE_CODE (type
) == ARRAY_TYPE
)
10451 /* Transfer const-ness of array into that of type pointed to. */
10452 type
= build_pointer_type (TREE_TYPE (type
));
10453 type_quals
= TYPE_UNQUALIFIED
;
10455 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10456 type
= build_pointer_type (type
);
10457 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10458 type
= build_pointer_type (type
);
10459 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
10461 error ("declaration of `%s' as void", name
);
10467 register tree decl
;
10469 if (decl_context
== PARM
)
10471 decl
= build_decl (PARM_DECL
, declarator
, complete_type (type
));
10473 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
10474 inlinep
, friendp
, raises
!= NULL_TREE
);
10475 if (current_class_type
10476 && IS_SIGNATURE (current_class_type
))
10479 error ("parameter of signature member function declared `inline'");
10480 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10481 error ("parameter of signature member function declared `auto'");
10482 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10483 error ("parameter of signature member function declared `register'");
10486 /* Compute the type actually passed in the parmlist,
10487 for the case where there is no prototype.
10488 (For example, shorts and chars are passed as ints.)
10489 When there is a prototype, this is overridden later. */
10491 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
10493 else if (decl_context
== FIELD
)
10495 if (type
== error_mark_node
)
10497 /* Happens when declaring arrays of sizes which
10498 are error_mark_node, for example. */
10501 else if (in_namespace
&& !friendp
)
10503 /* Something like struct S { int N::j; }; */
10504 cp_error ("invalid use of `::'");
10507 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10510 tree function_context
;
10512 /* We catch the others as conflicts with the builtin
10514 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
10516 cp_error ("function `%D' cannot be declared friend",
10523 if (ctype
== NULL_TREE
)
10524 ctype
= current_class_type
;
10526 if (ctype
== NULL_TREE
)
10528 cp_error ("can't make `%D' into a method -- not in a class",
10530 return void_type_node
;
10533 /* ``A union may [ ... ] not [ have ] virtual functions.''
10535 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10537 cp_error ("function `%D' declared virtual inside a union",
10539 return void_type_node
;
10542 if (declarator
== ansi_opname
[(int) NEW_EXPR
]
10543 || declarator
== ansi_opname
[(int) VEC_NEW_EXPR
]
10544 || declarator
== ansi_opname
[(int) DELETE_EXPR
]
10545 || declarator
== ansi_opname
[(int) VEC_DELETE_EXPR
])
10549 cp_error ("`%D' cannot be declared virtual, since it is always static",
10554 else if (staticp
< 2)
10555 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10556 TYPE_ARG_TYPES (type
));
10559 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10560 function_context
= (ctype
!= NULL_TREE
) ?
10561 hack_decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10562 publicp
= (! friendp
|| ! staticp
)
10563 && function_context
== NULL_TREE
;
10564 decl
= grokfndecl (ctype
, type
,
10565 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
10566 ? declarator
: dname
,
10568 virtualp
, flags
, quals
, raises
, attrlist
,
10569 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
10570 funcdef_flag
, template_count
, in_namespace
);
10571 if (decl
== NULL_TREE
|| decl
== error_mark_node
)
10574 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10575 /* The decl and setting of decl_machine_attr is also turned off. */
10576 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
10579 /* [class.conv.ctor]
10581 A constructor declared without the function-specifier
10582 explicit that can be called with a single parameter
10583 specifies a conversion from the type of its first
10584 parameter to the type of its class. Such a constructor
10585 is called a converting constructor. */
10586 if (explicitp
== 2)
10587 DECL_NONCONVERTING_P (decl
) = 1;
10588 else if (DECL_CONSTRUCTOR_P (decl
))
10590 /* The constructor can be called with exactly one
10591 parameter if there is at least one parameter, and
10592 any subsequent parameters have default arguments.
10593 We don't look at the first parameter, which is
10594 really just the `this' parameter for the new
10597 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
10599 /* Skip the `in_chrg' argument too, if present. */
10600 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl
)))
10601 arg_types
= TREE_CHAIN (arg_types
);
10603 if (arg_types
== void_list_node
10605 && TREE_CHAIN (arg_types
)
10606 && TREE_CHAIN (arg_types
) != void_list_node
10607 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
10608 DECL_NONCONVERTING_P (decl
) = 1;
10611 else if (TREE_CODE (type
) == METHOD_TYPE
)
10613 /* We only get here for friend declarations of
10614 members of other classes. */
10615 /* All method decls are public, so tell grokfndecl to set
10616 TREE_PUBLIC, also. */
10617 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
10618 virtualp
, flags
, quals
, raises
, attrlist
,
10619 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
10620 template_count
, in_namespace
);
10621 if (decl
== NULL_TREE
)
10624 else if (!staticp
&& ! processing_template_decl
10625 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
10626 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10629 cp_error ("field `%D' has incomplete type", declarator
);
10631 cp_error ("name `%T' has incomplete type", type
);
10633 /* If we're instantiating a template, tell them which
10634 instantiation made the field's type be incomplete. */
10635 if (current_class_type
10636 && TYPE_NAME (current_class_type
)
10637 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
10638 && declspecs
&& TREE_VALUE (declspecs
)
10639 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
10640 cp_error (" in instantiation of template `%T'",
10641 current_class_type
);
10643 type
= error_mark_node
;
10650 error ("`%s' is neither function nor method; cannot be declared friend",
10651 IDENTIFIER_POINTER (declarator
));
10659 /* Friends are treated specially. */
10660 if (ctype
== current_class_type
)
10661 warning ("member functions are implicitly friends of their class");
10664 tree t
= NULL_TREE
;
10665 if (decl
&& DECL_NAME (decl
))
10667 if (template_class_depth (current_class_type
) == 0)
10670 = check_explicit_specialization
10672 template_count
, 2 * (funcdef_flag
!= 0) + 4);
10673 if (decl
== error_mark_node
)
10674 return error_mark_node
;
10677 t
= do_friend (ctype
, declarator
, decl
,
10678 last_function_parms
, flags
, quals
,
10681 if (t
&& funcdef_flag
)
10684 return void_type_node
;
10688 /* Structure field. It may not be a function, except for C++ */
10690 if (decl
== NULL_TREE
)
10696 /* An attempt is being made to initialize a non-static
10697 member. But, from [class.mem]:
10699 4 A member-declarator can contain a
10700 constant-initializer only if it declares a static
10701 member (_class.static_) of integral or enumeration
10702 type, see _class.static.data_.
10704 This used to be relatively common practice, but
10705 the rest of the compiler does not correctly
10706 handle the initialization unless the member is
10707 static so we make it static below. */
10708 cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
10710 cp_pedwarn ("making `%D' static", declarator
);
10714 if (uses_template_parms (type
))
10715 /* We'll check at instantiation time. */
10717 else if (check_static_variable_definition (declarator
,
10719 /* If we just return the declaration, crashes
10720 will sometimes occur. We therefore return
10721 void_type_node, as if this was a friend
10722 declaration, to cause callers to completely
10723 ignore this declaration. */
10724 return void_type_node
;
10729 /* ANSI C++ Apr '95 wp 9.2 */
10730 if (declarator
== current_class_name
)
10731 cp_pedwarn ("ANSI C++ forbids static member `%D' with same name as enclosing class",
10734 /* C++ allows static class members.
10735 All other work for this is done by grokfield.
10736 This VAR_DCL is built by build_lang_field_decl.
10737 All other VAR_DECLs are built by build_decl. */
10738 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
10739 TREE_STATIC (decl
) = 1;
10740 /* In class context, 'static' means public access. */
10741 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
10745 decl
= build_lang_field_decl (FIELD_DECL
, declarator
, type
);
10746 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10748 DECL_MUTABLE_P (decl
) = 1;
10749 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10753 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
10754 inlinep
, friendp
, raises
!= NULL_TREE
);
10757 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10759 tree original_name
;
10765 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10766 original_name
= dname
;
10768 original_name
= declarator
;
10770 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10771 error ("storage class `auto' invalid for function `%s'", name
);
10772 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10773 error ("storage class `register' invalid for function `%s'", name
);
10775 /* Function declaration not at top level.
10776 Storage classes other than `extern' are not allowed
10777 and `extern' makes no difference. */
10778 if (! toplevel_bindings_p ()
10779 && (RIDBIT_SETP (RID_STATIC
, specbits
)
10780 || RIDBIT_SETP (RID_INLINE
, specbits
))
10783 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10784 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
10786 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
10789 if (ctype
== NULL_TREE
)
10793 error ("virtual non-class function `%s'", name
);
10797 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
10798 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10799 TYPE_ARG_TYPES (type
));
10801 /* Record presence of `static'. */
10802 publicp
= (ctype
!= NULL_TREE
10803 || RIDBIT_SETP (RID_EXTERN
, specbits
)
10804 || !RIDBIT_SETP (RID_STATIC
, specbits
));
10806 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
10807 virtualp
, flags
, quals
, raises
, attrlist
,
10809 publicp
, inlinep
, funcdef_flag
,
10810 template_count
, in_namespace
);
10811 if (decl
== NULL_TREE
)
10814 /* Among other times, could occur from check_explicit_specialization
10815 returning an error_mark_node. */
10816 if (decl
== error_mark_node
)
10817 return error_mark_node
;
10821 int illegal_static
= 0;
10823 /* Don't allow a static member function in a class, and forbid
10824 declaring main to be static. */
10825 if (TREE_CODE (type
) == METHOD_TYPE
)
10827 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
10828 illegal_static
= 1;
10830 else if (current_function_decl
)
10832 /* FIXME need arm citation */
10833 error ("cannot declare static function inside another function");
10834 illegal_static
= 1;
10837 if (illegal_static
)
10840 RIDBIT_RESET (RID_STATIC
, specbits
);
10846 /* It's a variable. */
10848 /* An uninitialized decl with `extern' is a reference. */
10849 decl
= grokvardecl (type
, declarator
, &specbits
,
10851 (type_quals
& TYPE_QUAL_CONST
) != 0,
10853 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
10854 inlinep
, friendp
, raises
!= NULL_TREE
);
10858 DECL_CONTEXT (decl
) = ctype
;
10861 cp_pedwarn ("static member `%D' re-declared as static", decl
);
10863 RIDBIT_RESET (RID_STATIC
, specbits
);
10865 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
10867 cp_error ("static member `%D' declared `register'", decl
);
10868 RIDBIT_RESET (RID_REGISTER
, specbits
);
10870 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
10872 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
10874 RIDBIT_RESET (RID_EXTERN
, specbits
);
10879 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10881 error ("`%s' cannot be declared mutable", name
);
10884 /* Record `register' declaration for warnings on &
10885 and in case doing stupid register allocation. */
10887 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10888 DECL_REGISTER (decl
) = 1;
10890 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
10891 DECL_THIS_EXTERN (decl
) = 1;
10893 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10894 DECL_THIS_STATIC (decl
) = 1;
10896 /* Record constancy and volatility. */
10897 /* FIXME: Disallow `restrict' pointer-to-member declarations. */
10898 c_apply_type_quals_to_decl (type_quals
, decl
);
10904 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
10905 An empty exprlist is a parmlist. An exprlist which
10906 contains only identifiers at the global level
10907 is a parmlist. Otherwise, it is an exprlist. */
10910 parmlist_is_exprlist (exprs
)
10913 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
10916 if (toplevel_bindings_p ())
10918 /* At the global level, if these are all identifiers,
10919 then it is a parmlist. */
10922 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
10924 exprs
= TREE_CHAIN (exprs
);
10931 /* Subroutine of `grokparms'. In a fcn definition, arg types must
10934 C++: also subroutine of `start_function'. */
10937 require_complete_types_for_parms (parms
)
10940 if (processing_template_decl
)
10945 tree type
= TREE_TYPE (parms
);
10946 if (TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
10948 if (DECL_NAME (parms
))
10949 error ("parameter `%s' has incomplete type",
10950 IDENTIFIER_POINTER (DECL_NAME (parms
)));
10952 error ("parameter has incomplete type");
10953 TREE_TYPE (parms
) = error_mark_node
;
10956 /* If the arg types are incomplete in a declaration,
10957 they must include undefined tags.
10958 These tags can never be defined in the scope of the declaration,
10959 so the types can never be completed,
10960 and no call can be compiled successfully. */
10961 /* This is not the right behavior for C++, but not having
10962 it is also probably wrong. */
10965 /* Now warn if is a pointer to an incomplete type. */
10966 while (TREE_CODE (type
) == POINTER_TYPE
10967 || TREE_CODE (type
) == REFERENCE_TYPE
)
10968 type
= TREE_TYPE (type
);
10969 type
= TYPE_MAIN_VARIANT (type
);
10970 if (TYPE_SIZE (type
) == NULL_TREE
)
10972 if (DECL_NAME (parm
) != NULL_TREE
)
10973 warning ("parameter `%s' points to incomplete type",
10974 IDENTIFIER_POINTER (DECL_NAME (parm
)));
10976 warning ("parameter points to incomplete type");
10980 parms
= TREE_CHAIN (parms
);
10984 /* Decode the list of parameter types for a function type.
10985 Given the list of things declared inside the parens,
10986 return a list of types.
10988 The list we receive can have three kinds of elements:
10989 an IDENTIFIER_NODE for names given without types,
10990 a TREE_LIST node for arguments given as typespecs or names with typespecs,
10991 or void_type_node, to mark the end of an argument list
10992 when additional arguments are not permitted (... was not used).
10994 FUNCDEF_FLAG is nonzero for a function definition, 0 for
10995 a mere declaration. A nonempty identifier-list gets an error message
10996 when FUNCDEF_FLAG is zero.
10997 If FUNCDEF_FLAG is 1, then parameter types must be complete.
10998 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11000 If all elements of the input list contain types,
11001 we return a list of the types.
11002 If all elements contain no type (except perhaps a void_type_node
11003 at the end), we return a null list.
11004 If some have types and some do not, it is an error, and we
11005 return a null list.
11007 Also set last_function_parms to either
11008 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11009 A list of names is converted to a chain of PARM_DECLs
11010 by store_parm_decls so that ultimately it is always a chain of decls.
11012 Note that in C++, parameters can take default values. These default
11013 values are in the TREE_PURPOSE field of the TREE_LIST. It is
11014 an error to specify default values which are followed by parameters
11015 that have no default values, or an ELLIPSES. For simplicities sake,
11016 only parameters which are specified with their types can take on
11020 grokparms (first_parm
, funcdef_flag
)
11024 tree result
= NULL_TREE
;
11025 tree decls
= NULL_TREE
;
11027 if (first_parm
!= NULL_TREE
11028 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
11030 if (! funcdef_flag
)
11031 pedwarn ("parameter names (without types) in function declaration");
11032 last_function_parms
= first_parm
;
11035 else if (first_parm
!= NULL_TREE
11036 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
11037 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
11038 my_friendly_abort (145);
11041 /* Types were specified. This is a list of declarators
11042 each represented as a TREE_LIST node. */
11043 register tree parm
, chain
;
11044 int any_init
= 0, any_error
= 0;
11046 if (first_parm
!= NULL_TREE
)
11048 tree last_result
= NULL_TREE
;
11049 tree last_decl
= NULL_TREE
;
11051 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
11053 tree type
= NULL_TREE
, list_node
= parm
;
11054 register tree decl
= TREE_VALUE (parm
);
11055 tree init
= TREE_PURPOSE (parm
);
11057 chain
= TREE_CHAIN (parm
);
11058 /* @@ weak defense against parse errors. */
11059 if (TREE_CODE (decl
) != VOID_TYPE
11060 && TREE_CODE (decl
) != TREE_LIST
)
11062 /* Give various messages as the need arises. */
11063 if (TREE_CODE (decl
) == STRING_CST
)
11064 cp_error ("invalid string constant `%E'", decl
);
11065 else if (TREE_CODE (decl
) == INTEGER_CST
)
11066 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11070 if (TREE_CODE (decl
) != VOID_TYPE
)
11072 decl
= grokdeclarator (TREE_VALUE (decl
),
11073 TREE_PURPOSE (decl
),
11074 PARM
, init
!= NULL_TREE
,
11076 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11079 /* Top-level qualifiers on the parameters are
11080 ignored for function types. */
11081 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
11083 if (TREE_CODE (type
) == VOID_TYPE
)
11084 decl
= void_type_node
;
11085 else if (TREE_CODE (type
) == METHOD_TYPE
)
11087 if (DECL_NAME (decl
))
11088 /* Cannot use the decl here because
11089 we don't have DECL_CONTEXT set up yet. */
11090 cp_error ("parameter `%D' invalidly declared method type",
11093 error ("parameter invalidly declared method type");
11094 type
= build_pointer_type (type
);
11095 TREE_TYPE (decl
) = type
;
11097 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11099 if (DECL_NAME (decl
))
11100 cp_error ("parameter `%D' invalidly declared offset type",
11103 error ("parameter invalidly declared offset type");
11104 type
= build_pointer_type (type
);
11105 TREE_TYPE (decl
) = type
;
11107 else if (TREE_CODE (type
) == RECORD_TYPE
11108 && TYPE_LANG_SPECIFIC (type
)
11109 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
11111 abstract_virtuals_error (decl
, type
);
11112 any_error
= 1; /* Seems like a good idea. */
11114 else if (TREE_CODE (type
) == RECORD_TYPE
11115 && TYPE_LANG_SPECIFIC (type
)
11116 && IS_SIGNATURE (type
))
11118 signature_error (decl
, type
);
11119 any_error
= 1; /* Seems like a good idea. */
11121 else if (POINTER_TYPE_P (type
))
11124 while (POINTER_TYPE_P (t
)
11125 || (TREE_CODE (t
) == ARRAY_TYPE
11126 && TYPE_DOMAIN (t
) != NULL_TREE
))
11128 if (TREE_CODE (t
) == ARRAY_TYPE
)
11129 cp_error ("parameter type `%T' includes %s to array of unknown bound",
11131 TYPE_PTR_P (type
) ? "pointer" : "reference");
11135 if (TREE_CODE (decl
) == VOID_TYPE
)
11137 if (result
== NULL_TREE
)
11139 result
= void_list_node
;
11140 last_result
= result
;
11144 TREE_CHAIN (last_result
) = void_list_node
;
11145 last_result
= void_list_node
;
11148 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
11149 error ("`void' in parameter list must be entire list");
11153 /* Since there is a prototype, args are passed in their own types. */
11154 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
11155 #ifdef PROMOTE_PROTOTYPES
11156 if ((TREE_CODE (type
) == INTEGER_TYPE
11157 || TREE_CODE (type
) == ENUMERAL_TYPE
)
11158 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
11159 DECL_ARG_TYPE (decl
) = integer_type_node
;
11166 if (TREE_CODE (init
) == SAVE_EXPR
)
11167 PARM_DECL_EXPR (init
) = 1;
11168 else if (processing_template_decl
)
11170 /* Unparsed default arg from in-class decl. */
11171 else if (TREE_CODE (init
) == DEFAULT_ARG
)
11173 else if (TREE_CODE (init
) == VAR_DECL
11174 || TREE_CODE (init
) == PARM_DECL
)
11176 if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init
)))
11178 /* ``Local variables may not be used in default
11179 argument expressions.'' dpANSI C++ 8.2.6 */
11180 /* If extern int i; within a function is not
11181 considered a local variable, then this code is
11183 cp_error ("local variable `%D' may not be used as a default argument", init
);
11186 else if (TREE_READONLY_DECL_P (init
))
11187 init
= decl_constant_value (init
);
11189 else if (TREE_TYPE (init
) == NULL_TREE
)
11191 error ("argument list may not have an initializer list");
11192 init
= error_mark_node
;
11195 if (! processing_template_decl
11196 && init
!= error_mark_node
11197 && TREE_CODE (init
) != DEFAULT_ARG
11198 && ! can_convert_arg (type
, TREE_TYPE (init
), init
))
11199 cp_pedwarn ("invalid type `%T' for default argument to `%#D'",
11200 TREE_TYPE (init
), decl
);
11206 if (decls
== NULL_TREE
)
11213 TREE_CHAIN (last_decl
) = decl
;
11216 if (! current_function_decl
&& TREE_PERMANENT (list_node
))
11218 TREE_PURPOSE (list_node
) = init
;
11219 TREE_VALUE (list_node
) = type
;
11220 TREE_CHAIN (list_node
) = NULL_TREE
;
11223 list_node
= saveable_tree_cons (init
, type
, NULL_TREE
);
11224 if (result
== NULL_TREE
)
11226 result
= list_node
;
11227 last_result
= result
;
11231 TREE_CHAIN (last_result
) = list_node
;
11232 last_result
= list_node
;
11236 TREE_CHAIN (last_result
) = NULL_TREE
;
11237 /* If there are no parameters, and the function does not end
11238 with `...', then last_decl will be NULL_TREE. */
11239 if (last_decl
!= NULL_TREE
)
11240 TREE_CHAIN (last_decl
) = NULL_TREE
;
11244 last_function_parms
= decls
;
11246 /* In a fcn definition, arg types must be complete. */
11247 if (funcdef_flag
> 0)
11248 require_complete_types_for_parms (last_function_parms
);
11253 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11254 FUNCTION_TYPE with the newly parsed version of its default argument, which
11255 was previously digested as text. See snarf_defarg et al in lex.c. */
11258 replace_defarg (arg
, init
)
11261 if (! processing_template_decl
11262 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
11263 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11264 TREE_TYPE (init
), TREE_VALUE (arg
));
11265 TREE_PURPOSE (arg
) = init
;
11272 tree t
= FUNCTION_ARG_CHAIN (d
);
11273 if (DECL_CONSTRUCTOR_P (d
)
11274 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d
)))
11275 t
= TREE_CHAIN (t
);
11276 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
11277 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
11278 == DECL_CLASS_CONTEXT (d
))
11279 && (TREE_CHAIN (t
) == NULL_TREE
11280 || TREE_CHAIN (t
) == void_list_node
11281 || TREE_PURPOSE (TREE_CHAIN (t
))))
11286 /* These memoizing functions keep track of special properties which
11287 a class may have. `grok_ctor_properties' notices whether a class
11288 has a constructor of the form X(X&), and also complains
11289 if the class has a constructor of the form X(X).
11290 `grok_op_properties' takes notice of the various forms of
11291 operator= which are defined, as well as what sorts of type conversion
11292 may apply. Both functions take a FUNCTION_DECL as an argument. */
11295 grok_ctor_properties (ctype
, decl
)
11298 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
11299 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
11301 /* When a type has virtual baseclasses, a magical first int argument is
11302 added to any ctor so we can tell if the class has been initialized
11303 yet. This could screw things up in this function, so we deliberately
11304 ignore the leading int if we're in that situation. */
11305 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
11307 my_friendly_assert (parmtypes
11308 && TREE_VALUE (parmtypes
) == integer_type_node
,
11310 parmtypes
= TREE_CHAIN (parmtypes
);
11311 parmtype
= TREE_VALUE (parmtypes
);
11314 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
11315 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
11316 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11317 || TREE_CHAIN (parmtypes
) == void_list_node
11318 || TREE_PURPOSE (TREE_CHAIN (parmtypes
))))
11320 TYPE_HAS_INIT_REF (ctype
) = 1;
11321 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11322 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
11324 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
11325 && TREE_CHAIN (parmtypes
) != NULL_TREE
11326 && TREE_CHAIN (parmtypes
) == void_list_node
)
11328 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11330 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
11333 else if (TREE_CODE (parmtype
) == VOID_TYPE
11334 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
11335 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
11340 /* An operator with this name can be either unary or binary. */
11346 return (name
== ansi_opname
[(int) INDIRECT_REF
]
11347 || name
== ansi_opname
[(int) ADDR_EXPR
]
11348 || name
== ansi_opname
[(int) NEGATE_EXPR
]
11349 || name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11350 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]
11351 || name
== ansi_opname
[(int) CONVERT_EXPR
]);
11354 /* An operator with this name can only be unary. */
11360 return (name
== ansi_opname
[(int) TRUTH_NOT_EXPR
]
11361 || name
== ansi_opname
[(int) BIT_NOT_EXPR
]
11362 || name
== ansi_opname
[(int) COMPONENT_REF
]
11363 || OPERATOR_TYPENAME_P (name
));
11366 /* Do a little sanity-checking on how they declared their operator. */
11369 grok_op_properties (decl
, virtualp
, friendp
)
11371 int virtualp
, friendp
;
11373 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11374 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11375 tree name
= DECL_NAME (decl
);
11377 if (current_class_type
== NULL_TREE
)
11382 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11383 TYPE_HAS_ASSIGNMENT (current_class_type
) = 1;
11384 else if (name
== ansi_opname
[(int) CALL_EXPR
])
11385 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
11386 else if (name
== ansi_opname
[(int) ARRAY_REF
])
11387 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
11388 else if (name
== ansi_opname
[(int) COMPONENT_REF
]
11389 || name
== ansi_opname
[(int) MEMBER_REF
])
11390 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
11391 else if (name
== ansi_opname
[(int) NEW_EXPR
])
11392 TYPE_GETS_NEW (current_class_type
) |= 1;
11393 else if (name
== ansi_opname
[(int) DELETE_EXPR
])
11394 TYPE_GETS_DELETE (current_class_type
) |= 1;
11395 else if (name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11396 TYPE_GETS_NEW (current_class_type
) |= 2;
11397 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11398 TYPE_GETS_DELETE (current_class_type
) |= 2;
11401 if (name
== ansi_opname
[(int) NEW_EXPR
]
11402 || name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11404 /* When the compiler encounters the definition of A::operator new, it
11405 doesn't look at the class declaration to find out if it's static. */
11407 revert_static_member_fn (&decl
, NULL
, NULL
);
11409 /* Take care of function decl if we had syntax errors. */
11410 if (argtypes
== NULL_TREE
)
11412 = build_function_type (ptr_type_node
,
11413 hash_tree_chain (integer_type_node
,
11416 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11418 else if (name
== ansi_opname
[(int) DELETE_EXPR
]
11419 || name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11422 revert_static_member_fn (&decl
, NULL
, NULL
);
11424 if (argtypes
== NULL_TREE
)
11426 = build_function_type (void_type_node
,
11427 hash_tree_chain (ptr_type_node
,
11431 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11433 if (! friendp
&& name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
11434 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
11435 != void_list_node
))
11436 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type
) = 1;
11441 /* An operator function must either be a non-static member function
11442 or have at least one parameter of a class, a reference to a class,
11443 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11444 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11446 if (OPERATOR_TYPENAME_P (name
)
11447 || name
== ansi_opname
[(int) CALL_EXPR
]
11448 || name
== ansi_opname
[(int) MODIFY_EXPR
]
11449 || name
== ansi_opname
[(int) COMPONENT_REF
]
11450 || name
== ansi_opname
[(int) ARRAY_REF
])
11451 cp_error ("`%D' must be a nonstatic member function", decl
);
11456 if (DECL_STATIC_FUNCTION_P (decl
))
11457 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
11460 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
11462 tree arg
= TREE_VALUE (p
);
11463 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
11464 arg
= TREE_TYPE (arg
);
11466 /* This lets bad template code slip through. */
11467 if (IS_AGGR_TYPE (arg
)
11468 || TREE_CODE (arg
) == ENUMERAL_TYPE
11469 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
11470 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11474 ("`%D' must have an argument of class or enumerated type",
11481 if (name
== ansi_opname
[(int) CALL_EXPR
])
11482 return; /* No restrictions on args. */
11484 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
11486 tree t
= TREE_TYPE (name
);
11487 if (TREE_CODE (t
) == VOID_TYPE
)
11488 pedwarn ("void is not a valid type conversion operator");
11489 else if (! friendp
)
11491 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11494 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11496 if (t
== current_class_type
)
11497 what
= "the same type";
11498 /* Don't force t to be complete here. */
11499 else if (IS_AGGR_TYPE (t
)
11501 && DERIVED_FROM_P (t
, current_class_type
))
11502 what
= "a base class";
11505 warning ("conversion to %s%s will never use a type conversion operator",
11506 ref
? "a reference to " : "", what
);
11510 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11514 if (list_length (argtypes
) != 3 && methodp
)
11516 cp_error ("`%D' must take exactly one argument", decl
);
11519 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
11521 if (copy_assignment_arg_p (parmtype
, virtualp
)
11524 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
11525 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
11526 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11527 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
11530 else if (name
== ansi_opname
[(int) COND_EXPR
])
11533 pedwarn ("ANSI C++ prohibits overloading operator ?:");
11534 if (list_length (argtypes
) != 4)
11535 cp_error ("`%D' must take exactly three arguments", decl
);
11537 else if (ambi_op_p (name
))
11539 if (list_length (argtypes
) == 2)
11541 else if (list_length (argtypes
) == 3)
11543 if ((name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11544 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11545 && ! processing_template_decl
11546 && TREE_VALUE (TREE_CHAIN (argtypes
)) != integer_type_node
)
11549 cp_error ("postfix `%D' must take `int' as its argument",
11553 ("postfix `%D' must take `int' as its second argument",
11560 cp_error ("`%D' must take either zero or one argument", decl
);
11562 cp_error ("`%D' must take either one or two arguments", decl
);
11565 /* More Effective C++ rule 6. */
11567 && (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11568 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]))
11570 tree arg
= TREE_VALUE (argtypes
);
11571 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11572 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11573 arg
= TREE_TYPE (arg
);
11574 arg
= TYPE_MAIN_VARIANT (arg
);
11575 if (list_length (argtypes
) == 2)
11577 if (TREE_CODE (ret
) != REFERENCE_TYPE
11578 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11580 cp_warning ("prefix `%D' should return `%T'", decl
,
11581 build_reference_type (arg
));
11585 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11586 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
11590 else if (unary_op_p (name
))
11592 if (list_length (argtypes
) != 2)
11595 cp_error ("`%D' must take `void'", decl
);
11597 cp_error ("`%D' must take exactly one argument", decl
);
11600 else /* if (binary_op_p (name)) */
11602 if (list_length (argtypes
) != 3)
11605 cp_error ("`%D' must take exactly one argument", decl
);
11607 cp_error ("`%D' must take exactly two arguments", decl
);
11610 /* More Effective C++ rule 7. */
11612 && (name
== ansi_opname
[TRUTH_ANDIF_EXPR
]
11613 || name
== ansi_opname
[TRUTH_ORIF_EXPR
]
11614 || name
== ansi_opname
[COMPOUND_EXPR
]))
11615 cp_warning ("user-defined `%D' always evaluates both arguments",
11619 /* Effective C++ rule 23. */
11621 && list_length (argtypes
) == 3
11622 && (name
== ansi_opname
[PLUS_EXPR
]
11623 || name
== ansi_opname
[MINUS_EXPR
]
11624 || name
== ansi_opname
[TRUNC_DIV_EXPR
]
11625 || name
== ansi_opname
[MULT_EXPR
])
11626 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11627 cp_warning ("`%D' should return by value", decl
);
11631 for (; argtypes
!= void_list_node
; argtypes
= TREE_CHAIN (argtypes
))
11632 if (TREE_PURPOSE (argtypes
))
11634 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11635 if (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11636 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11639 cp_pedwarn ("`%D' cannot have default arguments", decl
);
11642 cp_error ("`%D' cannot have default arguments", decl
);
11647 /* Get the struct, enum or union (CODE says which) with tag NAME.
11648 Define the tag as a forward-reference if it is not defined.
11650 C++: If a class derivation is given, process it here, and report
11651 an error if multiple derivation declarations are not identical.
11653 If this is a definition, come in through xref_tag and only look in
11654 the current frame for the name (since C++ allows new names in any
11658 xref_tag (code_type_node
, name
, globalize
)
11659 tree code_type_node
;
11663 enum tag_types tag_code
;
11664 enum tree_code code
;
11666 register tree ref
, t
;
11667 struct binding_level
*b
= inner_binding_level
;
11669 tree attributes
= NULL_TREE
;
11671 /* If we are called from the parser, code_type_node will sometimes be a
11672 TREE_LIST. This indicates that the user wrote
11673 "class __attribute__ ((foo)) bar". Extract the attributes so we can
11675 if (TREE_CODE (code_type_node
) == TREE_LIST
)
11677 attributes
= TREE_PURPOSE (code_type_node
);
11678 code_type_node
= TREE_VALUE (code_type_node
);
11681 tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11686 case signature_type
:
11687 code
= RECORD_TYPE
;
11693 code
= ENUMERAL_TYPE
;
11696 my_friendly_abort (18);
11699 /* If a cross reference is requested, look up the type
11700 already defined for this tag and return it. */
11701 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
11704 name
= TYPE_IDENTIFIER (t
);
11708 t
= IDENTIFIER_TYPE_VALUE (name
);
11710 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
11711 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
)
11716 if (t
&& (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
11717 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
))
11719 cp_error ("redeclaration of template type-parameter `%T'", name
);
11720 cp_error_at (" previously declared here `%#D'",
11721 TEMPLATE_TYPE_DECL (t
));
11723 if (t
&& TYPE_CONTEXT (t
) && got_type
)
11726 /* If we know we are defining this tag, only look it up in
11727 this scope and don't try to find it as a type. */
11728 ref
= lookup_tag (code
, name
, b
, 1);
11732 if (current_class_type
11733 && template_class_depth (current_class_type
)
11734 && PROCESSING_REAL_TEMPLATE_DECL_P ())
11735 /* Since GLOBALIZE is non-zero, we are not looking at a
11736 definition of this tag. Since, in addition, we are currently
11737 processing a (member) template declaration of a template
11738 class, we don't want to do any lookup at all; consider:
11745 { template <class V>
11746 friend struct S1; };
11748 Here, the S2::S1 declaration should not be confused with the
11749 outer declaration. In particular, the inner version should
11750 have a template parameter of level 2, not level 1. This
11751 would be particularly important if the member declaration
11754 template <class V = U> friend struct S1;
11756 say, when we should tsubst into `U' when instantiating S2. */
11763 ref
= lookup_tag (code
, name
, b
, 0);
11767 /* Try finding it as a type declaration. If that wins,
11769 ref
= lookup_name (name
, 1);
11771 if (ref
!= NULL_TREE
11772 && processing_template_decl
11773 && DECL_CLASS_TEMPLATE_P (ref
)
11774 && template_class_depth (current_class_type
) == 0)
11775 /* Since GLOBALIZE is true, we're declaring a global
11776 template, so we want this type. */
11777 ref
= DECL_RESULT (ref
);
11779 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
11780 && TREE_CODE (TREE_TYPE (ref
)) == code
)
11781 ref
= TREE_TYPE (ref
);
11788 push_obstacks_nochange ();
11792 /* If no such tag is yet defined, create a forward-reference node
11793 and record it as the "definition".
11794 When a real declaration of this type is found,
11795 the forward-reference will be altered into a real type. */
11797 /* In C++, since these migrate into the global scope, we must
11798 build them on the permanent obstack. */
11800 temp
= allocation_temporary_p ();
11802 end_temporary_allocation ();
11804 if (code
== ENUMERAL_TYPE
)
11806 cp_error ("use of enum `%#D' without previous declaration", name
);
11808 ref
= make_node (ENUMERAL_TYPE
);
11810 /* Give the type a default layout like unsigned int
11811 to avoid crashing if it does not get defined. */
11812 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
11813 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
11814 TREE_UNSIGNED (ref
) = 1;
11815 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
11816 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
11817 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
11819 /* Enable us to recognize when a type is created in class context.
11820 To do nested classes correctly, this should probably be cleared
11821 out when we leave this classes scope. Currently this in only
11822 done in `start_enum'. */
11824 pushtag (name
, ref
, globalize
);
11828 struct binding_level
*old_b
= class_binding_level
;
11830 ref
= make_lang_type (code
);
11832 if (tag_code
== signature_type
)
11834 SET_SIGNATURE (ref
);
11835 /* Since a signature type will be turned into the type
11836 of signature tables, it's not only an interface. */
11837 CLASSTYPE_INTERFACE_ONLY (ref
) = 0;
11838 SET_CLASSTYPE_INTERFACE_KNOWN (ref
);
11839 /* A signature doesn't have a vtable. */
11840 CLASSTYPE_VTABLE_NEEDS_WRITING (ref
) = 0;
11843 #ifdef NONNESTED_CLASSES
11844 /* Class types don't nest the way enums do. */
11845 class_binding_level
= (struct binding_level
*)0;
11847 pushtag (name
, ref
, globalize
);
11848 class_binding_level
= old_b
;
11853 /* If it no longer looks like a nested type, make sure it's
11855 If it is not an IDENTIFIER, this is not a declaration */
11856 if (b
->namespace_p
&& !class_binding_level
11857 && TREE_CODE (name
) == IDENTIFIER_NODE
)
11859 if (IDENTIFIER_NAMESPACE_VALUE (name
) == NULL_TREE
)
11860 SET_IDENTIFIER_NAMESPACE_VALUE (name
, TYPE_NAME (ref
));
11863 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
11864 redeclare_class_template (ref
, current_template_parms
);
11867 /* Until the type is defined, tentatively accept whatever
11868 structure tag the user hands us. */
11869 if (TYPE_SIZE (ref
) == NULL_TREE
11870 && ref
!= current_class_type
11871 /* Have to check this, in case we have contradictory tag info. */
11872 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
11874 if (tag_code
== class_type
)
11875 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
11876 else if (tag_code
== record_type
|| tag_code
== signature_type
)
11877 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
11882 TREE_TYPE (ref
) = attributes
;
11884 if (ref
&& TYPE_P (ref
))
11888 If the identifier resolves to a typedef-name or a template
11889 type-parameter, the elaborated-type-specifier is
11891 if (TYPE_LANG_SPECIFIC (ref
) && TYPE_WAS_ANONYMOUS (ref
))
11892 cp_error ("`%T' is a typedef name", ref
);
11893 else if (TREE_CODE (ref
) == TEMPLATE_TYPE_PARM
)
11894 cp_error ("`%T' is a template type paramter", ref
);
11901 xref_tag_from_type (old
, id
, globalize
)
11905 tree code_type_node
;
11907 if (TREE_CODE (old
) == RECORD_TYPE
)
11908 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
11909 ? class_type_node
: record_type_node
);
11911 code_type_node
= union_type_node
;
11913 if (id
== NULL_TREE
)
11914 id
= TYPE_IDENTIFIER (old
);
11916 return xref_tag (code_type_node
, id
, globalize
);
11920 xref_basetypes (code_type_node
, name
, ref
, binfo
)
11921 tree code_type_node
;
11925 /* In the declaration `A : X, Y, ... Z' we mark all the types
11926 (A, X, Y, ..., Z) so we can check for duplicates. */
11929 enum tag_types tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11931 if (tag_code
== union_type
)
11933 cp_error ("derived union `%T' invalid", ref
);
11937 len
= list_length (binfo
);
11938 push_obstacks (TYPE_OBSTACK (ref
), TYPE_OBSTACK (ref
));
11940 SET_CLASSTYPE_MARKED (ref
);
11941 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
11943 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
11945 /* The base of a derived struct is public by default. */
11947 = (TREE_PURPOSE (binfo
) == access_public_node
11948 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11949 || (tag_code
!= class_type
11950 && (TREE_PURPOSE (binfo
) == access_default_node
11951 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
11953 = (TREE_PURPOSE (binfo
) == access_protected_node
11954 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
11956 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
11957 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
11958 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11959 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
11960 tree basetype
= TREE_VALUE (binfo
);
11963 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
11964 basetype
= TREE_TYPE (basetype
);
11966 || (TREE_CODE (basetype
) != RECORD_TYPE
11967 && TREE_CODE (basetype
) != TYPENAME_TYPE
11968 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
11969 && TREE_CODE (basetype
) != TEMPLATE_TEMPLATE_PARM
))
11971 cp_error ("base type `%T' fails to be a struct or class type",
11972 TREE_VALUE (binfo
));
11976 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
11979 /* This code replaces similar code in layout_basetypes.
11980 We put the complete_type first for implicit `typename'. */
11981 if (TYPE_SIZE (complete_type (basetype
)) == NULL_TREE
11982 && ! (current_template_parms
&& uses_template_parms (basetype
)))
11984 cp_error ("base class `%T' has incomplete type", basetype
);
11990 if (CLASSTYPE_MARKED (basetype
))
11992 if (basetype
== ref
)
11993 cp_error ("recursive type `%T' undefined", basetype
);
11995 cp_error ("duplicate base type `%T' invalid", basetype
);
11999 if (TYPE_FOR_JAVA (basetype
)
12000 && current_lang_stack
== current_lang_base
)
12001 TYPE_FOR_JAVA (ref
) = 1;
12003 /* Note that the BINFO records which describe individual
12004 inheritances are *not* shared in the lattice! They
12005 cannot be shared because a given baseclass may be
12006 inherited with different `accessibility' by different
12007 derived classes. (Each BINFO record describing an
12008 individual inheritance contains flags which say what
12009 the `accessibility' of that particular inheritance is.) */
12011 base_binfo
= make_binfo (integer_zero_node
, basetype
,
12012 TYPE_BINFO_VTABLE (basetype
),
12013 TYPE_BINFO_VIRTUALS (basetype
));
12015 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
12016 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
12017 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
12018 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
12019 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
12021 /* We need to unshare the binfos now so that lookups during class
12022 definition work. */
12023 unshare_base_binfos (base_binfo
);
12025 SET_CLASSTYPE_MARKED (basetype
);
12027 /* We are free to modify these bits because they are meaningless
12028 at top level, and BASETYPE is a top-level type. */
12029 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
12031 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
12032 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12035 TYPE_GETS_NEW (ref
) |= TYPE_GETS_NEW (basetype
);
12036 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12041 TREE_VEC_LENGTH (binfos
) = i
;
12043 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
12046 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
12048 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
12049 = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos
, 0)));
12050 if (TYPE_USES_MULTIPLE_INHERITANCE (ref
))
12051 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12053 /* Unmark all the types. */
12055 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
12056 CLEAR_CLASSTYPE_MARKED (ref
);
12062 /* Begin compiling the definition of an enumeration type.
12063 NAME is its name (or null if anonymous).
12064 Returns the type object, as yet incomplete.
12065 Also records info about it so that build_enumerator
12066 may be used to declare the individual values as they are read. */
12072 register tree enumtype
= NULL_TREE
;
12073 struct binding_level
*b
= inner_binding_level
;
12075 /* We are wasting space here and putting these on the permanent_obstack so
12076 that typeid(local enum) will work correctly. */
12078 if (processing_template_decl
&& current_function_decl
)
12081 end_temporary_allocation ();
12083 /* If this is the real definition for a previous forward reference,
12084 fill in the contents in the same object that used to be the
12085 forward reference. */
12087 if (name
!= NULL_TREE
)
12088 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
12090 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12091 cp_error ("multiple definition of `%#T'", enumtype
);
12094 enumtype
= make_node (ENUMERAL_TYPE
);
12095 pushtag (name
, enumtype
, 0);
12098 if (current_class_type
)
12099 TREE_ADDRESSABLE (b
->tags
) = 1;
12101 /* We don't copy this value because build_enumerator needs to do it. */
12102 enum_next_value
= integer_zero_node
;
12105 GNU_xref_decl (current_function_decl
, enumtype
);
12109 /* After processing and defining all the values of an enumeration type,
12110 install their decls in the enumeration type and finish it off.
12111 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12112 Returns ENUMTYPE. */
12115 finish_enum (enumtype
)
12118 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
12119 /* Calculate the maximum value of any enumerator in this type. */
12121 tree values
= TYPE_VALUES (enumtype
);
12126 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
12131 /* The TREE_VALUE is a CONST_DECL for this enumeration
12133 decl
= TREE_VALUE (pair
);
12135 /* The DECL_INITIAL will be NULL if we are processing a
12136 template declaration and this enumeration constant had no
12137 explicit initializer. */
12138 value
= DECL_INITIAL (decl
);
12139 if (value
&& !processing_template_decl
)
12141 /* Set the TREE_TYPE for the VALUE as well. That's so
12142 that when we call decl_constant_value we get an
12143 entity of the right type (but with the constant
12144 value). Since we shouldn't ever call
12145 decl_constant_value on a template type, there's no
12146 reason to do that when processing_template_decl.
12147 And, if the expression is something like a
12148 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12149 wreak havoc on the intended type of the expression.
12151 Of course, there's also no point in trying to compute
12152 minimum or maximum values if we're in a template. */
12153 TREE_TYPE (value
) = enumtype
;
12156 minnode
= maxnode
= value
;
12157 else if (tree_int_cst_lt (maxnode
, value
))
12159 else if (tree_int_cst_lt (value
, minnode
))
12163 if (processing_template_decl
)
12164 /* If this is just a template, leave the CONST_DECL
12165 alone. That way tsubst_copy will find CONST_DECLs for
12166 CONST_DECLs, and not INTEGER_CSTs. */
12169 /* In the list we're building up, we want the enumeration
12170 values, not the CONST_DECLs. */
12171 TREE_VALUE (pair
) = value
;
12175 maxnode
= minnode
= integer_zero_node
;
12177 TYPE_VALUES (enumtype
) = nreverse (values
);
12179 if (processing_template_decl
)
12181 tree scope
= current_scope ();
12182 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
12184 add_tree (build_min (TAG_DEFN
, enumtype
));
12185 resume_temporary_allocation ();
12191 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12192 int lowprec
= min_precision (minnode
, unsignedp
);
12193 int highprec
= min_precision (maxnode
, unsignedp
);
12194 int precision
= MAX (lowprec
, highprec
);
12196 TYPE_SIZE (enumtype
) = NULL_TREE
;
12198 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12200 TYPE_PRECISION (enumtype
) = precision
;
12202 fixup_unsigned_type (enumtype
);
12204 fixup_signed_type (enumtype
);
12206 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
12207 /* Use the width of the narrowest normal C type which is wide enough. */
12208 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
12211 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
12213 TYPE_SIZE (enumtype
) = 0;
12214 layout_type (enumtype
);
12220 /* Fix up all variant types of this enum type. */
12221 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
12222 tem
= TYPE_NEXT_VARIANT (tem
))
12224 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
12225 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
12226 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
12227 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
12228 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
12229 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
12230 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
12231 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
12232 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
12236 /* Finish debugging output for this type. */
12237 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12242 /* Build and install a CONST_DECL for an enumeration constant of the
12243 enumeration type TYPE whose NAME and VALUE (if any) are provided.
12244 Assignment of sequential values by default is handled here. */
12247 build_enumerator (name
, value
, type
)
12255 /* Remove no-op casts from the value. */
12257 STRIP_TYPE_NOPS (value
);
12259 if (! processing_template_decl
)
12261 /* Validate and default VALUE. */
12262 if (value
!= NULL_TREE
)
12264 if (TREE_READONLY_DECL_P (value
))
12265 value
= decl_constant_value (value
);
12267 if (TREE_CODE (value
) == INTEGER_CST
)
12269 value
= default_conversion (value
);
12270 constant_expression_warning (value
);
12274 cp_error ("enumerator value for `%D' not integer constant", name
);
12279 /* Default based on previous value. */
12280 if (value
== NULL_TREE
&& ! processing_template_decl
)
12282 value
= enum_next_value
;
12284 cp_error ("overflow in enumeration values at `%D'", name
);
12287 /* Remove no-op casts from the value. */
12289 STRIP_TYPE_NOPS (value
);
12291 /* To fix MAX_VAL enum consts. (bkoz) */
12292 TREE_TYPE (value
) = integer_type_node
;
12296 /* We always have to copy here; not all INTEGER_CSTs are unshared.
12297 Even in other cases, we will later (in finish_enum) be setting the
12299 if (value
!= NULL_TREE
)
12300 value
= copy_node (value
);
12302 /* C++ associates enums with global, function, or class declarations. */
12304 context
= current_scope ();
12305 if (context
&& context
== current_class_type
)
12306 /* This enum declaration is local to the class. */
12307 decl
= build_lang_field_decl (CONST_DECL
, name
, type
);
12309 /* It's a global enum, or it's local to a function. (Note local to
12310 a function could mean local to a class method. */
12311 decl
= build_decl (CONST_DECL
, name
, type
);
12313 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
12314 DECL_INITIAL (decl
) = value
;
12315 TREE_READONLY (decl
) = 1;
12317 if (context
&& context
== current_class_type
)
12319 pushdecl_class_level (decl
);
12320 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12321 on the TYPE_FIELDS list for `S'. (That's so that you can say
12322 things like `S::i' later.) */
12323 finish_member_declaration (decl
);
12328 GNU_xref_decl (current_function_decl
, decl
);
12331 if (! processing_template_decl
)
12333 /* Set basis for default for next value. */
12334 enum_next_value
= build_binary_op_nodefault (PLUS_EXPR
, value
,
12335 integer_one_node
, PLUS_EXPR
);
12336 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
12339 result
= saveable_tree_cons (name
, decl
, NULL_TREE
);
12344 static int function_depth
;
12346 /* Create the FUNCTION_DECL for a function definition.
12347 DECLSPECS and DECLARATOR are the parts of the declaration;
12348 they describe the function's name and the type it returns,
12349 but twisted together in a fashion that parallels the syntax of C.
12351 This function creates a binding context for the function body
12352 as well as setting up the FUNCTION_DECL in current_function_decl.
12354 Returns 1 on success. If the DECLARATOR is not suitable for a function
12355 (it defines a datum instead), we return 0, which tells
12356 yyparse to report a parse error.
12358 For C++, we must first check whether that datum makes any sense.
12359 For example, "class A local_a(1,2);" means that variable local_a
12360 is an aggregate of type A, which should have a constructor
12361 applied to it with the argument list [1, 2].
12363 @@ There is currently no way to retrieve the storage
12364 @@ allocated to FUNCTION (or all of its parms) if we return
12365 @@ something we had previously. */
12368 start_function (declspecs
, declarator
, attrs
, pre_parsed_p
)
12369 tree declspecs
, declarator
, attrs
;
12373 tree ctype
= NULL_TREE
;
12376 extern int have_extern_spec
;
12377 extern int used_extern_spec
;
12378 int doing_friend
= 0;
12380 /* Sanity check. */
12381 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
12382 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
12384 /* Assume, until we see it does. */
12385 current_function_returns_value
= 0;
12386 current_function_returns_null
= 0;
12387 warn_about_return_type
= 0;
12389 shadowed_labels
= 0;
12390 current_function_assigns_this
= 0;
12391 current_function_just_assigned_this
= 0;
12392 current_function_parms_stored
= 0;
12393 original_result_rtx
= NULL_RTX
;
12394 base_init_expr
= NULL_TREE
;
12395 current_base_init_list
= NULL_TREE
;
12396 current_member_init_list
= NULL_TREE
;
12397 ctor_label
= dtor_label
= NULL_TREE
;
12398 static_labelno
= 0;
12400 clear_temp_name ();
12402 /* This should only be done once on the top most decl. */
12403 if (have_extern_spec
&& !used_extern_spec
)
12405 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
12406 used_extern_spec
= 1;
12411 decl1
= declarator
;
12414 /* What was this testing for, exactly? */
12415 if (! DECL_ARGUMENTS (decl1
)
12416 && !DECL_STATIC_FUNCTION_P (decl1
)
12417 && !DECL_ARTIFICIAL (decl1
)
12418 && DECL_CLASS_SCOPE_P (decl1
)
12419 && TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))
12420 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))))
12422 tree binding
= binding_for_name (DECL_NAME (decl1
),
12423 current_namespace
);
12424 cp_error ("redeclaration of `%#D'", decl1
);
12425 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)))
12426 cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)));
12427 else if (BINDING_VALUE (binding
))
12428 cp_error_at ("previous declaration here", BINDING_VALUE (binding
));
12432 fntype
= TREE_TYPE (decl1
);
12433 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12434 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12436 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
12437 class is in the (lexical) scope of the class in which it is
12439 if (!ctype
&& DECL_FRIEND_P (decl1
))
12441 ctype
= DECL_CLASS_CONTEXT (decl1
);
12443 /* CTYPE could be null here if we're dealing with a template;
12444 for example, `inline friend float foo()' inside a template
12445 will have no CTYPE set. */
12446 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
12452 /* In a fcn definition, arg types must be complete. */
12453 require_complete_types_for_parms (DECL_ARGUMENTS (decl1
));
12455 /* In case some arg types were completed since the declaration was
12456 parsed, fix up the decls. */
12458 tree t
= DECL_ARGUMENTS (decl1
);
12459 for (; t
; t
= TREE_CHAIN (t
))
12460 layout_decl (t
, 0);
12463 last_function_parms
= DECL_ARGUMENTS (decl1
);
12464 last_function_parm_tags
= NULL_TREE
;
12468 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
12469 /* If the declarator is not suitable for a function definition,
12470 cause a syntax error. */
12471 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
12473 fntype
= TREE_TYPE (decl1
);
12475 restype
= TREE_TYPE (fntype
);
12476 if (IS_AGGR_TYPE (restype
) && ! TYPE_PTRMEMFUNC_P (restype
)
12477 && ! CLASSTYPE_GOT_SEMICOLON (restype
))
12479 cp_error ("semicolon missing after declaration of `%#T'", restype
);
12480 shadow_tag (build_expr_list (NULL_TREE
, restype
));
12481 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
12482 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
12483 fntype
= build_function_type (integer_type_node
,
12484 TYPE_ARG_TYPES (fntype
));
12486 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
12488 TYPE_ARG_TYPES (fntype
));
12489 TREE_TYPE (decl1
) = fntype
;
12492 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12493 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12494 else if (DECL_MAIN_P (decl1
))
12496 /* If this doesn't return integer_type, complain. */
12497 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
12499 if (pedantic
|| warn_return_type
)
12500 pedwarn ("return type for `main' changed to `int'");
12501 TREE_TYPE (decl1
) = fntype
= default_function_type
;
12503 warn_about_return_type
= 0;
12507 /* Warn if function was previously implicitly declared
12508 (but not if we warned then). */
12509 if (! warn_implicit
12510 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
12511 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
12513 current_function_decl
= decl1
;
12514 /* Save the parm names or decls from this function's declarator
12515 where store_parm_decls will find them. */
12516 current_function_parms
= last_function_parms
;
12517 current_function_parm_tags
= last_function_parm_tags
;
12519 announce_function (decl1
);
12521 if (! processing_template_decl
)
12523 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype
))) == NULL_TREE
)
12525 cp_error ("return-type `%#T' is an incomplete type",
12526 TREE_TYPE (fntype
));
12528 /* Make it return void instead, but don't change the
12529 type of the DECL_RESULT, in case we have a named return value. */
12532 = build_cplus_method_type (build_type_variant (ctype
,
12533 TREE_READONLY (decl1
),
12534 TREE_SIDE_EFFECTS (decl1
)),
12536 FUNCTION_ARG_CHAIN (decl1
));
12539 = build_function_type (void_type_node
,
12540 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
12541 DECL_RESULT (decl1
)
12542 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype
)));
12543 TREE_READONLY (DECL_RESULT (decl1
))
12544 = CP_TYPE_CONST_P (TREE_TYPE (fntype
));
12545 TREE_THIS_VOLATILE (DECL_RESULT (decl1
))
12546 = CP_TYPE_VOLATILE_P (TREE_TYPE (fntype
));
12549 if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype
))
12550 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype
)))
12551 abstract_virtuals_error (decl1
, TREE_TYPE (fntype
));
12554 if (warn_about_return_type
)
12555 pedwarn ("return-type defaults to `int'");
12557 /* Effective C++ rule 15. See also c_expand_return. */
12559 && DECL_NAME (decl1
) == ansi_opname
[(int) MODIFY_EXPR
]
12560 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
12561 cp_warning ("`operator=' should return a reference to `*this'");
12563 /* Make the init_value nonzero so pushdecl knows this is not tentative.
12564 error_mark_node is replaced below (in poplevel) with the BLOCK. */
12565 DECL_INITIAL (decl1
) = error_mark_node
;
12567 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
12568 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
12571 /* This function exists in static storage.
12572 (This does not mean `static' in the C sense!) */
12573 TREE_STATIC (decl1
) = 1;
12575 /* Set up current_class_type, and enter the scope of the class, if
12578 push_nested_class (ctype
, 1);
12579 else if (DECL_STATIC_FUNCTION_P (decl1
))
12580 push_nested_class (DECL_CONTEXT (decl1
), 2);
12582 /* We must call push_template_decl after current_class_type is set
12583 up. (If we are processing inline definitions after exiting a
12584 class scope, current_class_type will be NULL_TREE until set above
12585 by push_nested_class.) */
12586 if (processing_template_decl
)
12587 decl1
= push_template_decl (decl1
);
12589 /* Record the decl so that the function name is defined.
12590 If we already have a decl for this name, and it is a FUNCTION_DECL,
12591 use the old decl. */
12592 if (!processing_template_decl
&& pre_parsed_p
== 0)
12594 /* A specialization is not used to guide overload resolution. */
12595 if ((flag_guiding_decls
12596 || !DECL_TEMPLATE_SPECIALIZATION (decl1
))
12597 && ! DECL_FUNCTION_MEMBER_P (decl1
))
12598 decl1
= pushdecl (decl1
);
12601 /* We need to set the DECL_CONTEXT. */
12602 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
12603 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
12604 /* And make sure we have enough default args. */
12605 check_default_args (decl1
);
12607 DECL_MAIN_VARIANT (decl1
) = decl1
;
12608 fntype
= TREE_TYPE (decl1
);
12611 current_function_decl
= decl1
;
12613 if (DECL_INTERFACE_KNOWN (decl1
))
12615 tree ctx
= hack_decl_function_context (decl1
);
12617 if (DECL_NOT_REALLY_EXTERN (decl1
))
12618 DECL_EXTERNAL (decl1
) = 0;
12620 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
12621 && TREE_PUBLIC (ctx
))
12622 /* This is a function in a local class in an extern inline
12624 comdat_linkage (decl1
);
12626 /* If this function belongs to an interface, it is public.
12627 If it belongs to someone else's interface, it is also external.
12628 It doesn't matter whether it's inline or not. */
12629 else if (interface_unknown
== 0
12630 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
12631 || flag_alt_external_templates
))
12633 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
12634 || processing_template_decl
)
12635 DECL_EXTERNAL (decl1
)
12637 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
));
12639 DECL_EXTERNAL (decl1
) = 0;
12640 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
12641 DECL_INTERFACE_KNOWN (decl1
) = 1;
12645 /* This is a definition, not a reference.
12646 So clear DECL_EXTERNAL. */
12647 DECL_EXTERNAL (decl1
) = 0;
12649 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
12650 && ! DECL_INTERFACE_KNOWN (decl1
)
12651 /* Don't try to defer nested functions for now. */
12652 && ! hack_decl_function_context (decl1
))
12653 DECL_DEFER_OUTPUT (decl1
) = 1;
12655 DECL_INTERFACE_KNOWN (decl1
) = 1;
12658 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
))
12660 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12661 TREE_TYPE (decl1
) = fntype
12662 = build_function_type (TREE_TYPE (fntype
),
12663 TREE_CHAIN (TYPE_ARG_TYPES (fntype
)));
12664 current_function_parms
= TREE_CHAIN (current_function_parms
);
12665 DECL_ARGUMENTS (decl1
) = current_function_parms
;
12668 restype
= TREE_TYPE (fntype
);
12672 /* If we're compiling a friend function, neither of the variables
12673 current_class_ptr nor current_class_type will have values. */
12674 if (! doing_friend
)
12676 /* We know that this was set up by `grokclassfn'.
12677 We do not wait until `store_parm_decls', since evil
12678 parse errors may never get us to that point. Here
12679 we keep the consistency between `current_class_type'
12680 and `current_class_ptr'. */
12681 tree t
= current_function_parms
;
12683 my_friendly_assert (t
!= NULL_TREE
12684 && TREE_CODE (t
) == PARM_DECL
, 162);
12686 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
12688 int i
= suspend_momentary ();
12690 /* Fool build_indirect_ref. */
12691 current_class_ptr
= NULL_TREE
;
12692 current_class_ref
= build_indirect_ref (t
, NULL_PTR
);
12693 current_class_ptr
= t
;
12694 resume_momentary (i
);
12697 /* We're having a signature pointer here. */
12698 current_class_ref
= current_class_ptr
= t
;
12704 current_class_ptr
= current_class_ref
= NULL_TREE
;
12708 current_binding_level
->parm_flag
= 1;
12710 GNU_xref_function (decl1
, current_function_parms
);
12713 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
12715 make_function_rtl (decl1
);
12717 /* Promote the value to int before returning it. */
12718 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
12719 restype
= type_promotes_to (restype
);
12721 /* If this fcn was already referenced via a block-scope `extern' decl
12722 (or an implicit decl), propagate certain information about the usage. */
12723 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
12724 TREE_ADDRESSABLE (decl1
) = 1;
12726 if (DECL_RESULT (decl1
) == NULL_TREE
)
12728 DECL_RESULT (decl1
)
12729 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
12730 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
12731 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
12734 /* Allocate further tree nodes temporarily during compilation
12735 of this function only. Tiemann moved up here from bottom of fn. */
12736 /* If this is a nested function, then we must continue to allocate RTL
12737 on the permanent obstack in case we need to inline it later. */
12738 if (! hack_decl_function_context (decl1
))
12739 temporary_allocation ();
12741 if (processing_template_decl
)
12743 ++minimal_parse_mode
;
12744 last_tree
= DECL_SAVED_TREE (decl1
)
12745 = build_nt (EXPR_STMT
, void_zero_node
);
12750 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1
))
12751 && DECL_LANGUAGE (decl1
) == lang_cplusplus
)
12753 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12754 ctor_label
= NULL_TREE
;
12758 dtor_label
= NULL_TREE
;
12759 if (DECL_CONSTRUCTOR_P (decl1
))
12760 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12766 /* Called after store_parm_decls for a function-try-block. We need to update
12767 last_parm_cleanup_insn so that the base initializers for a constructor
12768 are run within this block, not before it. */
12771 expand_start_early_try_stmts ()
12773 expand_start_try_stmts ();
12774 last_parm_cleanup_insn
= get_last_insn ();
12777 /* Store the parameter declarations into the current function declaration.
12778 This is called after parsing the parameter declarations, before
12779 digesting the body of the function.
12781 Also install to binding contour return value identifier, if any. */
12784 store_parm_decls ()
12786 register tree fndecl
= current_function_decl
;
12787 register tree parm
;
12788 int parms_have_cleanups
= 0;
12789 tree cleanups
= NULL_TREE
;
12791 /* This is either a chain of PARM_DECLs (when a prototype is used). */
12792 tree specparms
= current_function_parms
;
12794 /* This is a list of types declared among parms in a prototype. */
12795 tree parmtags
= current_function_parm_tags
;
12797 /* This is a chain of any other decls that came in among the parm
12798 declarations. If a parm is declared with enum {foo, bar} x;
12799 then CONST_DECLs for foo and bar are put here. */
12800 tree nonparms
= NULL_TREE
;
12802 if (toplevel_bindings_p ())
12803 fatal ("parse errors have confused me too much");
12805 /* Initialize RTL machinery. */
12806 init_function_start (fndecl
, input_filename
, lineno
);
12808 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
12809 declare_function_name ();
12811 /* Create a binding level for the parms. */
12812 expand_start_bindings (0);
12814 if (specparms
!= NULL_TREE
)
12816 /* This case is when the function was defined with an ANSI prototype.
12817 The parms already have decls, so we need not do anything here
12818 except record them as in effect
12819 and complain if any redundant old-style parm decls were written. */
12821 register tree next
;
12823 /* Must clear this because it might contain TYPE_DECLs declared
12825 storedecls (NULL_TREE
);
12827 for (parm
= nreverse (specparms
); parm
; parm
= next
)
12829 next
= TREE_CHAIN (parm
);
12830 if (TREE_CODE (parm
) == PARM_DECL
)
12833 if (DECL_NAME (parm
) == NULL_TREE
)
12837 else if (TREE_CODE (TREE_TYPE (parm
)) == VOID_TYPE
)
12838 cp_error ("parameter `%D' declared void", parm
);
12841 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
12842 A parameter is assumed not to have any side effects.
12843 If this should change for any reason, then this
12844 will have to wrap the bashed reference type in a save_expr.
12846 Also, if the parameter type is declared to be an X
12847 and there is an X(X&) constructor, we cannot lay it
12848 into the stack (any more), so we make this parameter
12849 look like it is really of reference type. Functions
12850 which pass parameters to this function will know to
12851 create a temporary in their frame, and pass a reference
12854 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
12855 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))))
12856 SET_DECL_REFERENCE_SLOT (parm
, convert_from_reference (parm
));
12860 if (! processing_template_decl
12861 && (cleanup
= maybe_build_cleanup (parm
), cleanup
))
12863 expand_decl (parm
);
12864 parms_have_cleanups
= 1;
12866 /* Keep track of the cleanups. */
12867 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
12872 /* If we find an enum constant or a type tag,
12873 put it aside for the moment. */
12874 TREE_CHAIN (parm
) = NULL_TREE
;
12875 nonparms
= chainon (nonparms
, parm
);
12879 /* Get the decls in their original chain order
12880 and record in the function. This is all and only the
12881 PARM_DECLs that were pushed into scope by the loop above. */
12882 DECL_ARGUMENTS (fndecl
) = getdecls ();
12884 storetags (chainon (parmtags
, gettags ()));
12887 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
12889 /* Now store the final chain of decls for the arguments
12890 as the decl-chain of the current lexical scope.
12891 Put the enumerators in as well, at the front so that
12892 DECL_ARGUMENTS is not modified. */
12894 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
12896 /* Initialize the RTL code for the function. */
12897 DECL_SAVED_INSNS (fndecl
) = NULL_RTX
;
12898 if (! processing_template_decl
)
12899 expand_function_start (fndecl
, parms_have_cleanups
);
12901 current_function_parms_stored
= 1;
12903 /* If this function is `main', emit a call to `__main'
12904 to run global initializers, etc. */
12905 if (DECL_MAIN_P (fndecl
))
12906 expand_main_function ();
12908 /* Now that we have initialized the parms, we can start their
12909 cleanups. We cannot do this before, since expand_decl_cleanup
12910 should not be called before the parm can be used. */
12912 && ! processing_template_decl
)
12914 for (cleanups
= nreverse (cleanups
); cleanups
; cleanups
= TREE_CHAIN (cleanups
))
12916 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups
), TREE_VALUE (cleanups
)))
12917 cp_error ("parser lost in parsing declaration of `%D'",
12918 TREE_PURPOSE (cleanups
));
12922 /* Create a binding contour which can be used to catch
12923 cleanup-generated temporaries. Also, if the return value needs or
12924 has initialization, deal with that now. */
12925 if (parms_have_cleanups
)
12928 expand_start_bindings (0);
12931 if (! processing_template_decl
&& flag_exceptions
)
12933 /* Do the starting of the exception specifications, if we have any. */
12934 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
12935 expand_start_eh_spec ();
12938 last_parm_cleanup_insn
= get_last_insn ();
12939 last_dtor_insn
= get_last_insn ();
12942 /* Bind a name and initialization to the return value of
12943 the current function. */
12946 store_return_init (return_id
, init
)
12947 tree return_id
, init
;
12949 tree decl
= DECL_RESULT (current_function_decl
);
12952 /* Give this error as many times as there are occurrences,
12953 so that users can use Emacs compilation buffers to find
12954 and fix all such places. */
12955 pedwarn ("ANSI C++ does not permit named return values");
12957 if (return_id
!= NULL_TREE
)
12959 if (DECL_NAME (decl
) == NULL_TREE
)
12961 DECL_NAME (decl
) = return_id
;
12962 DECL_ASSEMBLER_NAME (decl
) = return_id
;
12965 cp_error ("return identifier `%D' already in place", decl
);
12968 /* Can't let this happen for constructors. */
12969 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12971 error ("can't redefine default return value for constructors");
12975 /* If we have a named return value, put that in our scope as well. */
12976 if (DECL_NAME (decl
) != NULL_TREE
)
12978 /* If this named return value comes in a register,
12979 put it in a pseudo-register. */
12980 if (DECL_REGISTER (decl
))
12982 original_result_rtx
= DECL_RTL (decl
);
12983 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
12986 /* Let `cp_finish_decl' know that this initializer is ok. */
12987 DECL_INITIAL (decl
) = init
;
12990 if (minimal_parse_mode
)
12991 add_tree (build_min_nt (RETURN_INIT
, return_id
,
12992 copy_to_permanent (init
)));
12994 cp_finish_decl (decl
, init
, NULL_TREE
, 0, 0);
12999 /* Finish up a function declaration and compile that function
13000 all the way to assembler language output. The free the storage
13001 for the function definition.
13003 This is called after parsing the body of the function definition.
13004 LINENO is the current line number.
13006 C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
13007 (and expand_end_bindings) must be made to take care of the binding
13008 contour for the base initializers. This is only relevant for
13011 NESTED is nonzero if we were in the middle of compiling another function
13012 when we started on this one. */
13015 finish_function (lineno
, call_poplevel
, nested
)
13020 register tree fndecl
= current_function_decl
;
13021 tree fntype
, ctype
= NULL_TREE
;
13022 rtx last_parm_insn
, insns
;
13023 /* Label to use if this function is supposed to return a value. */
13024 tree no_return_label
= NULL_TREE
;
13025 tree decls
= NULL_TREE
;
13027 /* When we get some parse errors, we can end up without a
13028 current_function_decl, so cope. */
13029 if (fndecl
== NULL_TREE
)
13032 if (! nested
&& function_depth
> 1)
13035 fntype
= TREE_TYPE (fndecl
);
13037 /* TREE_READONLY (fndecl) = 1;
13038 This caused &foo to be of type ptr-to-const-function
13039 which then got a warning when stored in a ptr-to-function variable. */
13041 /* This happens on strange parse errors. */
13042 if (! current_function_parms_stored
)
13045 store_parm_decls ();
13048 if (processing_template_decl
)
13050 if (DECL_CONSTRUCTOR_P (fndecl
) && call_poplevel
)
13052 decls
= getdecls ();
13053 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13054 poplevel (decls
!= NULL_TREE
, 0, 0);
13059 if (write_symbols
!= NO_DEBUG
/*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13061 tree ttype
= target_type (fntype
);
13064 if (IS_AGGR_TYPE (ttype
))
13065 /* Let debugger know it should output info for this type. */
13066 note_debug_info_needed (ttype
);
13068 for (parmdecl
= DECL_ARGUMENTS (fndecl
); parmdecl
; parmdecl
= TREE_CHAIN (parmdecl
))
13070 ttype
= target_type (TREE_TYPE (parmdecl
));
13071 if (IS_AGGR_TYPE (ttype
))
13072 /* Let debugger know it should output info for this type. */
13073 note_debug_info_needed (ttype
);
13077 /* Clean house because we will need to reorder insns here. */
13078 do_pending_stack_adjust ();
13082 tree binfo
= TYPE_BINFO (current_class_type
);
13083 tree cond
= integer_one_node
;
13085 tree in_charge_node
= lookup_name (in_charge_identifier
, 0);
13087 int ok_to_optimize_dtor
= 0;
13088 int empty_dtor
= get_last_insn () == last_dtor_insn
;
13090 if (current_function_assigns_this
)
13091 cond
= build (NE_EXPR
, boolean_type_node
,
13092 current_class_ptr
, integer_zero_node
);
13095 int n_baseclasses
= CLASSTYPE_N_BASECLASSES (current_class_type
);
13097 /* If this destructor is empty, then we don't need to check
13098 whether `this' is NULL in some cases. */
13099 if ((flag_this_is_variable
& 1) == 0)
13100 ok_to_optimize_dtor
= 1;
13101 else if (empty_dtor
)
13102 ok_to_optimize_dtor
13103 = (n_baseclasses
== 0
13104 || (n_baseclasses
== 1
13105 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type
, 0))));
13108 /* These initializations might go inline. Protect
13109 the binding level of the parms. */
13111 expand_start_bindings (0);
13113 if (current_function_assigns_this
)
13115 current_function_assigns_this
= 0;
13116 current_function_just_assigned_this
= 0;
13119 /* Generate the code to call destructor on base class.
13120 If this destructor belongs to a class with virtual
13121 functions, then set the virtual function table
13122 pointer to represent the type of our base class. */
13124 /* This side-effect makes call to `build_delete' generate the
13125 code we have to have at the end of this destructor.
13126 `build_delete' will set the flag again. */
13127 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
13129 /* These are two cases where we cannot delegate deletion. */
13130 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)
13131 || TYPE_GETS_REG_DELETE (current_class_type
))
13132 exprstmt
= build_delete (current_class_type
, current_class_ref
, integer_zero_node
,
13133 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13135 exprstmt
= build_delete (current_class_type
, current_class_ref
, in_charge_node
,
13136 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13138 /* If we did not assign to this, then `this' is non-zero at
13139 the end of a destructor. As a special optimization, don't
13140 emit test if this is an empty destructor. If it does nothing,
13141 it does nothing. If it calls a base destructor, the base
13142 destructor will perform the test. */
13144 if (exprstmt
!= error_mark_node
13145 && (TREE_CODE (exprstmt
) != NOP_EXPR
13146 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
13147 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
13149 expand_label (dtor_label
);
13150 if (cond
!= integer_one_node
)
13151 expand_start_cond (cond
, 0);
13152 if (exprstmt
!= void_zero_node
)
13153 /* Don't call `expand_expr_stmt' if we're not going to do
13154 anything, since -Wall will give a diagnostic. */
13155 expand_expr_stmt (exprstmt
);
13157 /* Run destructor on all virtual baseclasses. */
13158 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13160 tree vbases
= nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type
)));
13161 expand_start_cond (build (BIT_AND_EXPR
, integer_type_node
,
13162 in_charge_node
, integer_two_node
), 0);
13165 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases
)))
13167 tree vb
= get_vbase
13168 (BINFO_TYPE (vbases
),
13169 TYPE_BINFO (current_class_type
));
13171 (build_scoped_method_call
13172 (current_class_ref
, vb
, dtor_identifier
,
13173 build_expr_list (NULL_TREE
, integer_zero_node
)));
13175 vbases
= TREE_CHAIN (vbases
);
13177 expand_end_cond ();
13180 do_pending_stack_adjust ();
13181 if (cond
!= integer_one_node
)
13182 expand_end_cond ();
13185 virtual_size
= c_sizeof (current_class_type
);
13187 /* At the end, call delete if that's what's requested. */
13189 /* FDIS sez: At the point of definition of a virtual destructor
13190 (including an implicit definition), non-placement operator
13191 delete shall be looked up in the scope of the destructor's
13192 class and if found shall be accessible and unambiguous.
13194 This is somewhat unclear, but I take it to mean that if the
13195 class only defines placement deletes we don't do anything here.
13196 So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain
13197 for us if they ever try to delete one of these. */
13199 if (TYPE_GETS_REG_DELETE (current_class_type
)
13200 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13201 exprstmt
= build_op_delete_call
13202 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
13203 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
13205 exprstmt
= NULL_TREE
;
13209 cond
= build (BIT_AND_EXPR
, integer_type_node
,
13210 in_charge_node
, integer_one_node
);
13211 expand_start_cond (cond
, 0);
13212 expand_expr_stmt (exprstmt
);
13213 expand_end_cond ();
13216 /* End of destructor. */
13217 expand_end_bindings (NULL_TREE
, getdecls () != NULL_TREE
, 0);
13218 poplevel (2, 0, 0); /* XXX change to 1 */
13220 /* Back to the top of destructor. */
13221 /* Don't execute destructor code if `this' is NULL. */
13225 /* If the dtor is empty, and we know there is not possible way we
13226 could use any vtable entries, before they are possibly set by
13227 a base class dtor, we don't have to setup the vtables, as we
13228 know that any base class dtoring will set up any vtables it
13229 needs. We avoid MI, because one base class dtor can do a
13230 virtual dispatch to an overridden function that would need to
13231 have a non-related vtable set up, we cannot avoid setting up
13232 vtables in that case. We could change this to see if there is
13233 just one vtable. */
13234 if (! empty_dtor
|| TYPE_USES_COMPLEX_INHERITANCE (current_class_type
))
13236 /* Make all virtual function table pointers in non-virtual base
13237 classes point to CURRENT_CLASS_TYPE's virtual function
13239 expand_direct_vtbls_init (binfo
, binfo
, 1, 0, current_class_ptr
);
13241 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13242 expand_indirect_vtbls_init (binfo
, current_class_ref
, current_class_ptr
);
13245 if (! ok_to_optimize_dtor
)
13247 cond
= build_binary_op (NE_EXPR
,
13248 current_class_ptr
, integer_zero_node
, 1);
13249 expand_start_cond (cond
, 0);
13252 insns
= get_insns ();
13255 last_parm_insn
= get_first_nonparm_insn ();
13256 if (last_parm_insn
== NULL_RTX
)
13257 last_parm_insn
= get_last_insn ();
13259 last_parm_insn
= previous_insn (last_parm_insn
);
13261 emit_insns_after (insns
, last_parm_insn
);
13263 if (! ok_to_optimize_dtor
)
13264 expand_end_cond ();
13266 else if (current_function_assigns_this
)
13268 /* Does not need to call emit_base_init, because
13269 that is done (if needed) just after assignment to this
13272 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13274 end_protect_partials ();
13275 expand_label (ctor_label
);
13276 ctor_label
= NULL_TREE
;
13280 decls
= getdecls ();
13281 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13282 poplevel (decls
!= NULL_TREE
, 0, 0);
13284 /* c_expand_return knows to return 'this' from a constructor. */
13285 c_expand_return (NULL_TREE
);
13287 else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl
))) != VOID_TYPE
13288 && return_label
!= NULL_RTX
)
13289 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13291 current_function_assigns_this
= 0;
13292 current_function_just_assigned_this
= 0;
13293 base_init_expr
= NULL_TREE
;
13295 else if (DECL_CONSTRUCTOR_P (fndecl
))
13297 tree cond
= NULL_TREE
, thenclause
= NULL_TREE
;
13298 /* Allow constructor for a type to get a new instance of the object
13299 using `build_new'. */
13300 tree abstract_virtuals
= CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
);
13301 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = NULL_TREE
;
13303 DECL_RETURNS_FIRST_ARG (fndecl
) = 1;
13305 if (flag_this_is_variable
> 0)
13307 cond
= build_binary_op (EQ_EXPR
,
13308 current_class_ptr
, integer_zero_node
, 1);
13309 thenclause
= build_modify_expr (current_class_ptr
, NOP_EXPR
,
13310 build_new (NULL_TREE
, current_class_type
, void_type_node
, 0));
13313 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = abstract_virtuals
;
13317 if (flag_this_is_variable
> 0)
13319 expand_start_cond (cond
, 0);
13320 expand_expr_stmt (thenclause
);
13321 expand_end_cond ();
13324 /* Emit insns from `emit_base_init' which sets up virtual
13325 function table pointer(s). */
13326 if (base_init_expr
)
13328 expand_expr_stmt (base_init_expr
);
13329 base_init_expr
= NULL_TREE
;
13332 insns
= get_insns ();
13335 /* This is where the body of the constructor begins. */
13337 emit_insns_after (insns
, last_parm_cleanup_insn
);
13339 end_protect_partials ();
13341 /* This is where the body of the constructor ends. */
13342 expand_label (ctor_label
);
13343 ctor_label
= NULL_TREE
;
13347 decls
= getdecls ();
13348 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13349 poplevel (decls
!= NULL_TREE
, 1, 0);
13352 /* c_expand_return knows to return 'this' from a constructor. */
13353 c_expand_return (NULL_TREE
);
13355 current_function_assigns_this
= 0;
13356 current_function_just_assigned_this
= 0;
13358 else if (DECL_MAIN_P (fndecl
))
13360 /* Make it so that `main' always returns 0 by default. */
13362 c_expand_return (integer_one_node
);
13364 c_expand_return (integer_zero_node
);
13367 else if (return_label
!= NULL_RTX
13368 && current_function_return_value
== NULL_TREE
13369 && ! DECL_NAME (DECL_RESULT (current_function_decl
)))
13370 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13372 if (flag_exceptions
)
13373 expand_exception_blocks ();
13375 /* If this function is supposed to return a value, ensure that
13376 we do not fall into the cleanups by mistake. The end of our
13377 function will look like this:
13379 user code (may have return stmt somewhere)
13380 goto no_return_label
13385 NOTE_INSN_FUNCTION_END
13389 If the user omits a return stmt in the USER CODE section, we
13390 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13391 Otherwise, we won't. */
13392 if (no_return_label
)
13394 DECL_CONTEXT (no_return_label
) = fndecl
;
13395 DECL_INITIAL (no_return_label
) = error_mark_node
;
13396 DECL_SOURCE_FILE (no_return_label
) = input_filename
;
13397 DECL_SOURCE_LINE (no_return_label
) = lineno
;
13398 expand_goto (no_return_label
);
13403 /* Remove the binding contour which is used
13404 to catch cleanup-generated temporaries. */
13405 expand_end_bindings (0, 0, 0);
13406 poplevel (0, 0, 0);
13408 /* Emit label at beginning of cleanup code for parameters. */
13409 emit_label (cleanup_label
);
13412 /* Get return value into register if that's where it's supposed to be. */
13413 if (original_result_rtx
)
13414 fixup_result_decl (DECL_RESULT (fndecl
), original_result_rtx
);
13416 /* Finish building code that will trigger warnings if users forget
13417 to make their functions return values. */
13418 if (no_return_label
|| cleanup_label
)
13419 emit_jump (return_label
);
13420 if (no_return_label
)
13422 /* We don't need to call `expand_*_return' here because we
13423 don't need any cleanups here--this path of code is only
13424 for error checking purposes. */
13425 expand_label (no_return_label
);
13428 /* Generate rtl for function exit. */
13429 expand_function_end (input_filename
, lineno
, 1);
13432 /* This must come after expand_function_end because cleanups might
13433 have declarations (from inline functions) that need to go into
13434 this function's blocks. */
13435 if (current_binding_level
->parm_flag
!= 1)
13436 my_friendly_abort (122);
13437 poplevel (1, 0, 1);
13439 /* Reset scope for C++: if we were in the scope of a class,
13440 then when we finish this function, we are not longer so.
13441 This cannot be done until we know for sure that no more
13442 class members will ever be referenced in this function
13443 (i.e., calls to destructors). */
13444 if (current_class_name
)
13446 ctype
= current_class_type
;
13447 pop_nested_class (1);
13450 /* Must mark the RESULT_DECL as being in this function. */
13451 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13453 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13454 to the FUNCTION_DECL node itself. */
13455 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13457 if (! processing_template_decl
)
13459 int saved_flag_keep_inline_functions
=
13460 flag_keep_inline_functions
;
13462 /* So we can tell if jump_optimize sets it to 1. */
13465 if (DECL_CONTEXT (fndecl
) != NULL_TREE
13466 && hack_decl_function_context (fndecl
))
13467 /* Trick rest_of_compilation into not deferring output of this
13468 function, even if it is inline, since the rtl_obstack for
13469 this function is the function_obstack of the enclosing
13470 function and will be deallocated when the enclosing
13471 function is gone. See save_tree_status. */
13472 flag_keep_inline_functions
= 1;
13474 /* Run the optimizers and output the assembler code for this
13477 if (DECL_ARTIFICIAL (fndecl
))
13479 /* Do we really *want* to inline this synthesized method? */
13481 int save_fif
= flag_inline_functions
;
13482 flag_inline_functions
= 1;
13484 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13485 will check our size. */
13486 DECL_INLINE (fndecl
) = 0;
13488 rest_of_compilation (fndecl
);
13489 flag_inline_functions
= save_fif
;
13492 rest_of_compilation (fndecl
);
13494 flag_keep_inline_functions
= saved_flag_keep_inline_functions
;
13496 if (DECL_SAVED_INSNS (fndecl
) && ! TREE_ASM_WRITTEN (fndecl
))
13498 /* Set DECL_EXTERNAL so that assemble_external will be called as
13499 necessary. We'll clear it again in finish_file. */
13500 if (! DECL_EXTERNAL (fndecl
))
13501 DECL_NOT_REALLY_EXTERN (fndecl
) = 1;
13502 DECL_EXTERNAL (fndecl
) = 1;
13503 mark_inline_for_output (fndecl
);
13506 if (ctype
&& TREE_ASM_WRITTEN (fndecl
))
13507 note_debug_info_needed (ctype
);
13509 current_function_returns_null
|= can_reach_end
;
13511 /* Since we don't normally go through c_expand_return for constructors,
13512 this normally gets the wrong value.
13513 Also, named return values have their return codes emitted after
13514 NOTE_INSN_FUNCTION_END, confusing jump.c. */
13515 if (DECL_CONSTRUCTOR_P (fndecl
)
13516 || DECL_NAME (DECL_RESULT (fndecl
)) != NULL_TREE
)
13517 current_function_returns_null
= 0;
13519 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
13520 cp_warning ("`noreturn' function `%D' does return", fndecl
);
13521 else if ((warn_return_type
|| pedantic
)
13522 && current_function_returns_null
13523 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
)
13525 /* If this function returns non-void and control can drop through,
13527 cp_warning ("control reaches end of non-void function `%D'", fndecl
);
13529 /* With just -W, complain only if function returns both with
13530 and without a value. */
13531 else if (extra_warnings
13532 && current_function_returns_value
&& current_function_returns_null
)
13533 warning ("this function may return with or without a value");
13538 /* Free all the tree nodes making up this function. */
13539 /* Switch back to allocating nodes permanently
13540 until we start another function. */
13541 if (processing_template_decl
)
13543 --minimal_parse_mode
;
13544 DECL_SAVED_TREE (fndecl
) = TREE_CHAIN (DECL_SAVED_TREE (fndecl
));
13548 permanent_allocation (1);
13550 if (DECL_SAVED_INSNS (fndecl
) == NULL_RTX
)
13554 /* Stop pointing to the local nodes about to be freed. */
13555 /* But DECL_INITIAL must remain nonzero so we know this
13556 was an actual function definition. */
13557 DECL_INITIAL (fndecl
) = error_mark_node
;
13558 for (t
= DECL_ARGUMENTS (fndecl
); t
; t
= TREE_CHAIN (t
))
13559 DECL_RTL (t
) = DECL_INCOMING_RTL (t
) = NULL_RTX
;
13562 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
13563 static_ctors
= perm_tree_cons (NULL_TREE
, fndecl
, static_ctors
);
13564 if (DECL_STATIC_DESTRUCTOR (fndecl
))
13565 static_dtors
= perm_tree_cons (NULL_TREE
, fndecl
, static_dtors
);
13569 /* Let the error reporting routines know that we're outside a
13570 function. For a nested function, this value is used in
13571 pop_cp_function_context and then reset via pop_function_context. */
13572 current_function_decl
= NULL_TREE
;
13575 named_label_uses
= NULL
;
13576 current_class_ptr
= NULL_TREE
;
13577 current_class_ref
= NULL_TREE
;
13580 /* Create the FUNCTION_DECL for a function definition.
13581 LINE1 is the line number that the definition absolutely begins on.
13582 LINE2 is the line number that the name of the function appears on.
13583 DECLSPECS and DECLARATOR are the parts of the declaration;
13584 they describe the return type and the name of the function,
13585 but twisted together in a fashion that parallels the syntax of C.
13587 This function creates a binding context for the function body
13588 as well as setting up the FUNCTION_DECL in current_function_decl.
13590 Returns a FUNCTION_DECL on success.
13592 If the DECLARATOR is not suitable for a function (it defines a datum
13593 instead), we return 0, which tells yyparse to report a parse error.
13595 May return void_type_node indicating that this method is actually
13596 a friend. See grokfield for more details.
13598 Came here with a `.pushlevel' .
13600 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13601 CHANGES TO CODE IN `grokfield'. */
13604 start_method (declspecs
, declarator
, attrlist
)
13605 tree declarator
, declspecs
, attrlist
;
13607 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
13610 /* Something too ugly to handle. */
13611 if (fndecl
== NULL_TREE
)
13614 /* Pass friends other than inline friend functions back. */
13615 if (fndecl
== void_type_node
)
13618 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
13619 /* Not a function, tell parser to report parse error. */
13622 if (IS_SIGNATURE (current_class_type
))
13623 IS_DEFAULT_IMPLEMENTATION (fndecl
) = 1;
13625 if (DECL_IN_AGGR_P (fndecl
))
13627 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
13629 if (DECL_CONTEXT (fndecl
)
13630 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
13631 cp_error ("`%D' is already defined in class %s", fndecl
,
13632 TYPE_NAME_STRING (DECL_CONTEXT (fndecl
)));
13634 return void_type_node
;
13637 DECL_THIS_INLINE (fndecl
) = 1;
13639 if (flag_default_inline
)
13640 DECL_INLINE (fndecl
) = 1;
13642 /* We process method specializations in finish_struct_1. */
13643 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
13644 fndecl
= push_template_decl (fndecl
);
13646 /* We read in the parameters on the maybepermanent_obstack,
13647 but we won't be getting back to them until after we
13648 may have clobbered them. So the call to preserve_data
13649 will keep them safe. */
13652 if (! DECL_FRIEND_P (fndecl
))
13654 if (TREE_CHAIN (fndecl
))
13656 fndecl
= copy_node (fndecl
);
13657 TREE_CHAIN (fndecl
) = NULL_TREE
;
13660 if (DECL_CONSTRUCTOR_P (fndecl
))
13662 if (! grok_ctor_properties (current_class_type
, fndecl
))
13663 return void_type_node
;
13665 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
13666 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
13669 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0, 0);
13671 /* Make a place for the parms */
13673 current_binding_level
->parm_flag
= 1;
13675 DECL_IN_AGGR_P (fndecl
) = 1;
13679 /* Go through the motions of finishing a function definition.
13680 We don't compile this method until after the whole class has
13683 FINISH_METHOD must return something that looks as though it
13684 came from GROKFIELD (since we are defining a method, after all).
13686 This is called after parsing the body of the function definition.
13687 STMTS is the chain of statements that makes up the function body.
13689 DECL is the ..._DECL that `start_method' provided. */
13692 finish_method (decl
)
13695 register tree fndecl
= decl
;
13698 register tree link
;
13700 if (decl
== void_type_node
)
13703 old_initial
= DECL_INITIAL (fndecl
);
13705 /* Undo the level for the parms (from start_method).
13706 This is like poplevel, but it causes nothing to be
13707 saved. Saving information here confuses symbol-table
13708 output routines. Besides, this information will
13709 be correctly output when this method is actually
13712 /* Clear out the meanings of the local variables of this level;
13713 also record in each decl which block it belongs to. */
13715 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
13717 if (DECL_NAME (link
) != NULL_TREE
)
13718 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = 0;
13719 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
13720 DECL_CONTEXT (link
) = NULL_TREE
;
13723 /* Restore all name-meanings of the outer levels
13724 that were shadowed by this level. */
13726 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
13727 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
13728 for (link
= current_binding_level
->class_shadowed
;
13729 link
; link
= TREE_CHAIN (link
))
13730 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
13731 for (link
= current_binding_level
->type_shadowed
;
13732 link
; link
= TREE_CHAIN (link
))
13733 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
13735 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
13736 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
13737 current_binding_level
->parm_flag
,
13738 current_binding_level
->keep
);
13740 poplevel (0, 0, 0);
13742 DECL_INITIAL (fndecl
) = old_initial
;
13744 /* We used to check if the context of FNDECL was different from
13745 current_class_type as another way to get inside here. This didn't work
13746 for String.cc in libg++. */
13747 if (DECL_FRIEND_P (fndecl
))
13749 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
13750 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
13751 decl
= void_type_node
;
13757 /* Called when a new struct TYPE is defined.
13758 If this structure or union completes the type of any previous
13759 variable declaration, lay it out and output its rtl. */
13762 hack_incomplete_structures (type
)
13767 if (current_binding_level
->incomplete
== NULL_TREE
)
13770 if (!type
) /* Don't do this for class templates. */
13773 for (list
= ¤t_binding_level
->incomplete
; *list
; )
13775 tree decl
= TREE_VALUE (*list
);
13776 if ((decl
&& TREE_TYPE (decl
) == type
)
13777 || (TREE_TYPE (decl
)
13778 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13779 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
13781 int toplevel
= toplevel_bindings_p ();
13782 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13783 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
13784 layout_type (TREE_TYPE (decl
));
13785 layout_decl (decl
, 0);
13786 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
13790 expand_decl (decl
);
13791 cleanup
= maybe_build_cleanup (decl
);
13792 expand_decl_init (decl
);
13793 if (! expand_decl_cleanup (decl
, cleanup
))
13794 cp_error ("parser lost in parsing declaration of `%D'",
13797 *list
= TREE_CHAIN (*list
);
13800 list
= &TREE_CHAIN (*list
);
13804 /* If DECL is of a type which needs a cleanup, build that cleanup here.
13805 See build_delete for information about AUTO_DELETE.
13807 Don't build these on the momentary obstack; they must live
13808 the life of the binding contour. */
13811 maybe_build_cleanup_1 (decl
, auto_delete
)
13812 tree decl
, auto_delete
;
13814 tree type
= TREE_TYPE (decl
);
13815 if (TYPE_NEEDS_DESTRUCTOR (type
))
13817 int temp
= 0, flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
13820 if (TREE_CODE (decl
) != PARM_DECL
)
13821 temp
= suspend_momentary ();
13823 if (TREE_CODE (type
) == ARRAY_TYPE
)
13827 mark_addressable (decl
);
13828 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
13831 /* Optimize for space over speed here. */
13832 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
13833 || flag_expensive_optimizations
)
13834 flags
|= LOOKUP_NONVIRTUAL
;
13836 rval
= build_delete (TREE_TYPE (rval
), rval
, auto_delete
, flags
, 0);
13838 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
13839 && ! TYPE_HAS_DESTRUCTOR (type
))
13840 rval
= build_compound_expr (expr_tree_cons (NULL_TREE
, rval
,
13841 build_expr_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
13843 if (TREE_CODE (decl
) != PARM_DECL
)
13844 resume_momentary (temp
);
13851 /* If DECL is of a type which needs a cleanup, build that cleanup
13852 here. The cleanup does free the storage with a call to delete. */
13855 maybe_build_cleanup_and_delete (decl
)
13858 return maybe_build_cleanup_1 (decl
, integer_three_node
);
13861 /* If DECL is of a type which needs a cleanup, build that cleanup
13862 here. The cleanup does not free the storage with a call a delete. */
13865 maybe_build_cleanup (decl
)
13868 return maybe_build_cleanup_1 (decl
, integer_two_node
);
13871 /* Expand a C++ expression at the statement level.
13872 This is needed to ferret out nodes which have UNKNOWN_TYPE.
13873 The C++ type checker should get all of these out when
13874 expressions are combined with other, type-providing, expressions,
13875 leaving only orphan expressions, such as:
13877 &class::bar; / / takes its address, but does nothing with it. */
13880 cplus_expand_expr_stmt (exp
)
13883 if (processing_template_decl
)
13885 add_tree (build_min_nt (EXPR_STMT
, exp
));
13889 /* Arrange for all temps to disappear. */
13890 expand_start_target_temps ();
13892 if (TREE_TYPE (exp
) == unknown_type_node
)
13894 if (TREE_CODE (exp
) == ADDR_EXPR
|| TREE_CODE (exp
) == TREE_LIST
)
13895 error ("address of overloaded function with no contextual type information");
13896 else if (TREE_CODE (exp
) == COMPONENT_REF
)
13897 error ("invalid reference to a member function name, did you forget the ()?");
13901 if (TREE_CODE (exp
) == FUNCTION_DECL
)
13903 cp_warning ("reference, not call, to function `%D'", exp
);
13904 warning ("at this point in file");
13908 /* We should do this eventually, but right now this causes regex.o from
13909 libg++ to miscompile, and tString to core dump. */
13910 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
13913 /* Strip unused implicit INDIRECT_REFs of references. */
13914 if (TREE_CODE (exp
) == INDIRECT_REF
13915 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
13916 exp
= TREE_OPERAND (exp
, 0);
13918 /* If we don't do this, we end up down inside expand_expr
13919 trying to do TYPE_MODE on the ERROR_MARK, and really
13920 go outside the bounds of the type. */
13921 if (exp
!= error_mark_node
)
13922 expand_expr_stmt (break_out_cleanups (exp
));
13925 /* Clean up any pending cleanups. This happens when a function call
13926 returns a cleanup-needing value that nobody uses. */
13927 expand_end_target_temps ();
13930 /* When a stmt has been parsed, this function is called.
13932 Currently, this function only does something within a
13933 constructor's scope: if a stmt has just assigned to this,
13934 and we are in a derived class, we call `emit_base_init'. */
13939 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
13942 if (current_function_assigns_this
13943 || ! current_function_just_assigned_this
)
13945 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13947 /* Constructors must wait until we are out of control
13948 zones before calling base constructors. */
13949 if (cond_stack
|| loop_stack
|| case_stack
)
13951 expand_expr_stmt (base_init_expr
);
13952 check_base_init (current_class_type
);
13954 current_function_assigns_this
= 1;
13957 /* Change a static member function definition into a FUNCTION_TYPE, instead
13958 of the METHOD_TYPE that we create when it's originally parsed.
13960 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
13961 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
13962 other decls. Either pass the addresses of local variables or NULL. */
13965 revert_static_member_fn (decl
, fn
, argtypes
)
13966 tree
*decl
, *fn
, *argtypes
;
13969 tree function
= fn
? *fn
: TREE_TYPE (*decl
);
13970 tree args
= argtypes
? *argtypes
: TYPE_ARG_TYPES (function
);
13972 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
13973 != TYPE_UNQUALIFIED
)
13974 cp_error ("static member function `%#D' declared with type qualifiers",
13977 args
= TREE_CHAIN (args
);
13978 tmp
= build_function_type (TREE_TYPE (function
), args
);
13979 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
13980 tmp
= build_exception_variant (tmp
,
13981 TYPE_RAISES_EXCEPTIONS (function
));
13982 TREE_TYPE (*decl
) = tmp
;
13983 if (DECL_ARGUMENTS (*decl
))
13984 DECL_ARGUMENTS (*decl
) = TREE_CHAIN (DECL_ARGUMENTS (*decl
));
13985 DECL_STATIC_FUNCTION_P (*decl
) = 1;
13993 id_in_current_class (id
)
13996 return !!purpose_member (id
, class_binding_level
->class_shadowed
);
14003 int warn_about_return_type
;
14005 int just_assigned_this
;
14007 int temp_name_counter
;
14009 struct named_label_list
*named_label_uses
;
14010 tree shadowed_labels
;
14013 rtx last_dtor_insn
;
14014 rtx last_parm_cleanup_insn
;
14015 tree base_init_list
;
14016 tree member_init_list
;
14017 tree base_init_expr
;
14018 tree current_class_ptr
;
14019 tree current_class_ref
;
14021 struct cp_function
*next
;
14022 struct binding_level
*binding_level
;
14023 int static_labelno
;
14026 static struct cp_function
*cp_function_chain
;
14028 extern int temp_name_counter
;
14030 /* Save and reinitialize the variables
14031 used during compilation of a C++ function. */
14034 push_cp_function_context (context
)
14037 struct cp_function
*p
14038 = (struct cp_function
*) xmalloc (sizeof (struct cp_function
));
14040 push_function_context_to (context
);
14042 p
->next
= cp_function_chain
;
14043 cp_function_chain
= p
;
14045 p
->named_labels
= named_labels
;
14046 p
->named_label_uses
= named_label_uses
;
14047 p
->shadowed_labels
= shadowed_labels
;
14048 p
->returns_value
= current_function_returns_value
;
14049 p
->returns_null
= current_function_returns_null
;
14050 p
->warn_about_return_type
= warn_about_return_type
;
14051 p
->binding_level
= current_binding_level
;
14052 p
->ctor_label
= ctor_label
;
14053 p
->dtor_label
= dtor_label
;
14054 p
->last_dtor_insn
= last_dtor_insn
;
14055 p
->last_parm_cleanup_insn
= last_parm_cleanup_insn
;
14056 p
->assigns_this
= current_function_assigns_this
;
14057 p
->just_assigned_this
= current_function_just_assigned_this
;
14058 p
->parms_stored
= current_function_parms_stored
;
14059 p
->result_rtx
= original_result_rtx
;
14060 p
->base_init_expr
= base_init_expr
;
14061 p
->temp_name_counter
= temp_name_counter
;
14062 p
->base_init_list
= current_base_init_list
;
14063 p
->member_init_list
= current_member_init_list
;
14064 p
->current_class_ptr
= current_class_ptr
;
14065 p
->current_class_ref
= current_class_ref
;
14066 p
->static_labelno
= static_labelno
;
14069 /* Restore the variables used during compilation of a C++ function. */
14072 pop_cp_function_context (context
)
14075 struct cp_function
*p
= cp_function_chain
;
14078 /* Bring back all the labels that were shadowed. */
14079 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
14080 if (DECL_NAME (TREE_VALUE (link
)) != 0)
14081 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)),
14082 TREE_VALUE (link
));
14084 pop_function_context_from (context
);
14086 cp_function_chain
= p
->next
;
14088 named_labels
= p
->named_labels
;
14089 named_label_uses
= p
->named_label_uses
;
14090 shadowed_labels
= p
->shadowed_labels
;
14091 current_function_returns_value
= p
->returns_value
;
14092 current_function_returns_null
= p
->returns_null
;
14093 warn_about_return_type
= p
->warn_about_return_type
;
14094 current_binding_level
= p
->binding_level
;
14095 ctor_label
= p
->ctor_label
;
14096 dtor_label
= p
->dtor_label
;
14097 last_dtor_insn
= p
->last_dtor_insn
;
14098 last_parm_cleanup_insn
= p
->last_parm_cleanup_insn
;
14099 current_function_assigns_this
= p
->assigns_this
;
14100 current_function_just_assigned_this
= p
->just_assigned_this
;
14101 current_function_parms_stored
= p
->parms_stored
;
14102 original_result_rtx
= p
->result_rtx
;
14103 base_init_expr
= p
->base_init_expr
;
14104 temp_name_counter
= p
->temp_name_counter
;
14105 current_base_init_list
= p
->base_init_list
;
14106 current_member_init_list
= p
->member_init_list
;
14107 current_class_ptr
= p
->current_class_ptr
;
14108 current_class_ref
= p
->current_class_ref
;
14109 static_labelno
= p
->static_labelno
;
14117 return function_depth
!= 0;