1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92-98, 1999 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. */
48 #define obstack_chunk_alloc xmalloc
49 #define obstack_chunk_free free
51 extern struct obstack permanent_obstack
;
52 extern struct obstack
* saveable_obstack
;
54 extern int current_class_depth
;
56 extern tree static_ctors
, static_dtors
;
58 extern tree current_namespace
;
59 extern tree global_namespace
;
61 extern int (*valid_lang_attribute
) PROTO ((tree
, tree
, tree
, tree
));
63 /* Obstack used for remembering local class declarations (like
64 enums and static (const) members. */
66 struct obstack decl_obstack
;
67 static struct stack_level
*decl_stack
;
69 #ifndef CHAR_TYPE_SIZE
70 #define CHAR_TYPE_SIZE BITS_PER_UNIT
73 #ifndef SHORT_TYPE_SIZE
74 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
78 #define INT_TYPE_SIZE BITS_PER_WORD
81 #ifndef LONG_TYPE_SIZE
82 #define LONG_TYPE_SIZE BITS_PER_WORD
85 #ifndef LONG_LONG_TYPE_SIZE
86 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
89 #ifndef WCHAR_UNSIGNED
90 #define WCHAR_UNSIGNED 0
93 #ifndef FLOAT_TYPE_SIZE
94 #define FLOAT_TYPE_SIZE BITS_PER_WORD
97 #ifndef DOUBLE_TYPE_SIZE
98 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
101 #ifndef LONG_DOUBLE_TYPE_SIZE
102 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
105 #ifndef BOOL_TYPE_SIZE
106 #ifdef SLOW_BYTE_ACCESS
107 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
109 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
113 /* We let tm.h override the types used here, to handle trivial differences
114 such as the choice of unsigned int or long unsigned int for size_t.
115 When machines start needing nontrivial differences in the size type,
116 it would be best to do something here to figure out automatically
117 from other information what type to use. */
120 #define SIZE_TYPE "long unsigned int"
124 #define PTRDIFF_TYPE "long int"
128 #define WCHAR_TYPE "int"
131 static tree grokparms
PROTO((tree
, int));
132 static const char *redeclaration_error_message
PROTO((tree
, tree
));
134 static struct stack_level
*push_decl_level
PROTO((struct stack_level
*,
136 static void push_binding_level
PROTO((struct binding_level
*, int,
138 static void pop_binding_level
PROTO((void));
139 static void suspend_binding_level
PROTO((void));
140 static void resume_binding_level
PROTO((struct binding_level
*));
141 static struct binding_level
*make_binding_level
PROTO((void));
142 static void declare_namespace_level
PROTO((void));
143 static void signal_catch
PROTO((int)) ATTRIBUTE_NORETURN
;
144 static void storedecls
PROTO((tree
));
145 static void require_complete_types_for_parms
PROTO((tree
));
146 static void push_overloaded_decl_1
PROTO((tree
));
147 static int ambi_op_p
PROTO((tree
));
148 static int unary_op_p
PROTO((tree
));
149 static tree store_bindings
PROTO((tree
, tree
));
150 static tree lookup_tag_reverse
PROTO((tree
, tree
));
151 static tree obscure_complex_init
PROTO((tree
, tree
));
152 static tree maybe_build_cleanup_1
PROTO((tree
, tree
));
153 static tree lookup_name_real
PROTO((tree
, int, int, int));
154 static void warn_extern_redeclared_static
PROTO((tree
, tree
));
155 static void grok_reference_init
PROTO((tree
, tree
, tree
));
156 static tree grokfndecl
PROTO((tree
, tree
, tree
, tree
, int,
157 enum overload_flags
, tree
,
158 tree
, int, int, int, int, int, int, tree
));
159 static tree grokvardecl
PROTO((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
160 static tree lookup_tag
PROTO((enum tree_code
, tree
,
161 struct binding_level
*, int));
162 static void set_identifier_type_value_with_scope
163 PROTO((tree
, tree
, struct binding_level
*));
164 static void record_builtin_type
PROTO((enum rid
, const char *, tree
));
165 static void record_unknown_type
PROTO((tree
, const char *));
166 static int member_function_or_else
PROTO((tree
, tree
, const char *));
167 static void bad_specifiers
PROTO((tree
, const char *, int, int, int, int,
169 static void lang_print_error_function
PROTO((const char *));
170 static tree maybe_process_template_type_declaration
PROTO((tree
, int, struct binding_level
*));
171 static void check_for_uninitialized_const_var
PROTO((tree
));
172 static unsigned long typename_hash
PROTO((hash_table_key
));
173 static boolean typename_compare
PROTO((hash_table_key
, hash_table_key
));
174 static void push_binding
PROTO((tree
, tree
, struct binding_level
*));
175 static int add_binding
PROTO((tree
, tree
));
176 static void pop_binding
PROTO((tree
, tree
));
177 static tree local_variable_p
PROTO((tree
));
178 static tree find_binding
PROTO((tree
, tree
));
179 static tree select_decl
PROTO((tree
, int));
180 static int lookup_flags
PROTO((int, int));
181 static tree qualify_lookup
PROTO((tree
, int));
182 static tree record_builtin_java_type
PROTO((const char *, int));
183 static const char *tag_name
PROTO((enum tag_types code
));
184 static void find_class_binding_level
PROTO((void));
185 static struct binding_level
*innermost_nonclass_level
PROTO((void));
186 static tree poplevel_class
PROTO((void));
187 static void warn_about_implicit_typename_lookup
PROTO((tree
, tree
));
188 static int walk_namespaces_r
PROTO((tree
, walk_namespaces_fn
, void *));
189 static int walk_globals_r
PROTO((tree
, void *));
190 static void add_decl_to_level
PROTO((tree
, struct binding_level
*));
191 static tree make_label_decl
PROTO((tree
, int));
192 static void pop_label
PROTO((tree
));
193 static void pop_labels
PROTO((tree
));
194 static void maybe_deduce_size_from_array_init
PROTO((tree
, tree
));
195 static void layout_var_decl
PROTO((tree
, tree
*));
196 static void maybe_commonize_var
PROTO((tree
));
197 static tree build_cleanup_on_safe_obstack
PROTO((tree
));
198 static void check_initializer
PROTO((tree
, tree
*));
199 static void make_rtl_for_nonlocal_decl
PROTO((tree
, tree
, const char *));
200 static void push_cp_function_context
PROTO((struct function
*));
201 static void pop_cp_function_context
PROTO((struct function
*));
202 static void mark_binding_level
PROTO((void *));
203 static void mark_cp_function_context
PROTO((struct function
*));
205 #if defined (DEBUG_CP_BINDING_LEVELS)
206 static void indent
PROTO((void));
209 /* A node which has tree code ERROR_MARK, and whose type is itself.
210 All erroneous expressions are replaced with this node. All functions
211 that accept nodes as arguments should avoid generating error messages
212 if this node is one of the arguments, since it is undesirable to get
213 multiple error messages from one error in the input. */
215 tree error_mark_node
;
217 /* Erroneous argument lists can use this *IFF* they do not modify it. */
218 tree error_mark_list
;
220 /* The following symbols are subsumed in the cp_global_trees array, and
221 listed here individually for documentation purposes.
224 tree wchar_decl_node;
227 tree vtable_entry_type;
228 tree delta_type_node;
231 tree __baselist_desc_type_node;
232 tree __i_desc_type_node, __m_desc_type_node;
233 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
235 tree __t_desc_type_node;
237 tree __tp_desc_type_node;
239 tree __access_mode_type_node;
240 tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
241 tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
242 tree __ptmf_desc_type_node, __ptmd_desc_type_node;
244 Not needed yet? May be needed one day?
245 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
246 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
247 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
250 tree class_star_type_node;
251 tree class_type_node, record_type_node, union_type_node, enum_type_node;
252 tree unknown_type_node;
254 Array type `vtable_entry_type[]'
257 tree vtbl_ptr_type_node;
263 A FUNCTION_DECL which can call `abort'. Not necessarily the
264 one that the user will declare, but sufficient to be called
265 by routines that want to abort the program.
269 The FUNCTION_DECL for the default `::operator delete'.
271 tree global_delete_fndecl;
274 tree type_info_type_node, tinfo_fn_id, tinfo_fn_type;
278 tree cp_global_trees
[CPTI_MAX
];
280 /* These can't be part of the above array, since they are declared
281 individually in tree.h, and used by the debug output routines. */
285 tree integer_type_node
;
286 tree unsigned_type_node
;
288 /* These can't be part of the above array, since they are declared
289 individially in tree.h and used by the target routines. */
292 tree va_list_type_node
;
294 /* Indicates that there is a type value in some namespace, although
295 that is not necessarily in scope at the moment. */
297 static tree global_type_node
;
302 /* Expect only namespace names now. */
303 static int only_namespace_names
;
305 /* In a destructor, the last insn emitted after the start of the
306 function and the parms. */
308 #define last_dtor_insn cp_function_chain->x_last_dtor_insn
310 /* In a constructor, the last insn emitted after the start of the
311 function and the parms, the exception specification and any
312 function-try-block. The constructor initializers are emitted after
315 #define last_parm_cleanup_insn cp_function_chain->x_last_parm_cleanup_insn
317 /* If original DECL_RESULT of current function was a register,
318 but due to being an addressable named return value, would up
319 on the stack, this variable holds the named return value's
320 original location. */
322 #define original_result_rtx cp_function_chain->x_result_rtx
324 /* C++: Keep these around to reduce calls to `get_identifier'.
325 Identifiers for `this' in member functions and the auto-delete
326 parameter for destructors. */
327 tree this_identifier
, in_charge_identifier
;
328 tree ctor_identifier
, dtor_identifier
;
329 /* Used in pointer to member functions, in vtables, and in sigtables. */
330 tree pfn_identifier
, index_identifier
, delta_identifier
, delta2_identifier
;
331 tree pfn_or_delta2_identifier
, tag_identifier
;
332 tree vt_off_identifier
;
334 /* Exception specifier used for throw(). */
335 tree empty_except_spec
;
337 struct named_label_list
339 struct binding_level
*binding_level
;
342 const char *filename_o_goto
;
344 struct named_label_list
*next
;
347 /* A list (chain of TREE_LIST nodes) of named label uses.
348 The TREE_PURPOSE field is the list of variables defined
349 in the label's scope defined at the point of use.
350 The TREE_VALUE field is the LABEL_DECL used.
351 The TREE_TYPE field holds `current_binding_level' at the
352 point of the label's use.
354 BWAHAHAAHAHahhahahahaah. No, no, no, said the little chicken.
356 Look at the pretty struct named_label_list. See the pretty struct
357 with the pretty named fields that describe what they do. See the
358 pretty lack of gratuitous casts. Notice the code got a lot cleaner.
360 Used only for jumps to as-yet undefined labels, since
361 jumps to defined labels can have their validity checked
364 #define named_label_uses cp_function_chain->named_label_uses
366 /* A list of objects which have constructors or destructors
367 which reside in the global scope. The decl is stored in
368 the TREE_VALUE slot and the initializer is stored
369 in the TREE_PURPOSE slot. */
370 tree static_aggregates
;
374 /* Two expressions that are constants with value zero.
375 The first is of type `int', the second of type `void *'. */
377 tree integer_zero_node
;
378 tree null_pointer_node
;
380 /* The value for __null (NULL), namely, a zero of an integer type with
381 the same number of bits as a pointer. */
384 /* A node for the integer constants 1, 2, and 3. */
386 tree integer_one_node
, integer_two_node
, integer_three_node
;
388 /* While defining an enum type, this is 1 plus the last enumerator
391 static tree enum_next_value
;
393 /* Nonzero means that there was overflow computing enum_next_value. */
395 static int enum_overflow
;
397 /* Parsing a function declarator leaves a list of parameter names
398 or a chain or parameter decls here. */
400 tree last_function_parms
;
402 /* Parsing a function declarator leaves here a chain of structure
403 and enum types declared in the parmlist. */
405 static tree last_function_parm_tags
;
407 /* After parsing the declarator that starts a function definition,
408 `start_function' puts here the list of parameter names or chain of decls.
409 `store_parm_decls' finds it here. */
411 static tree current_function_parms
;
413 /* Similar, for last_function_parm_tags. */
414 static tree current_function_parm_tags
;
416 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
417 that have names. Here so we can clear out their names' definitions
418 at the end of the function. The TREE_VALUE is a LABEL_DECL; the
419 TREE_PURPOSE is the previous binding of the label. */
421 #define named_labels cp_function_chain->x_named_labels
423 /* The FUNCTION_DECL for the function currently being compiled,
424 or 0 if between functions. */
425 tree current_function_decl
;
427 /* Set to 0 at beginning of a function definition, and whenever
428 a label (case or named) is defined. Set to value of expression
429 returned from function when that value can be transformed into
430 a named return value. */
432 tree current_function_return_value
;
434 /* Nonzero means give `double' the same size as `float'. */
436 extern int flag_short_double
;
438 /* Nonzero means don't recognize any builtin functions. */
440 extern int flag_no_builtin
;
442 /* Nonzero means don't recognize the non-ANSI builtin functions.
445 extern int flag_no_nonansi_builtin
;
447 /* Nonzero means enable obscure ANSI features and disable GNU extensions
448 that might cause ANSI-compliant code to be miscompiled. */
450 extern int flag_ansi
;
452 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
454 extern int flag_huge_objects
;
456 /* Nonzero if we want to conserve space in the .o files. We do this
457 by putting uninitialized data and runtime initialized data into
458 .common instead of .data at the expense of not flagging multiple
460 extern int flag_conserve_space
;
462 /* Pointers to the base and current top of the language name stack. */
464 extern tree
*current_lang_base
, *current_lang_stack
;
466 /* C and C++ flags are in decl2.c. */
468 /* Set to 0 at beginning of a constructor, set to 1
469 if that function does an allocation before referencing its
470 instance variable. */
471 #define current_function_assigns_this cp_function_chain->assigns_this
472 #define current_function_just_assigned_this \
473 cp_function_chain->just_assigned_this
475 /* Flag used when debugging spew.c */
477 extern int spew_debug
;
479 /* This is a copy of the class_shadowed list of the previous class binding
480 contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
481 when entering another class scope (i.e. a cache miss). */
482 extern tree previous_class_values
;
484 /* A expression of value 0 with the same precision as a sizetype
486 tree signed_size_zero_node
;
488 /* The name of the anonymous namespace, throughout this translation
490 tree anonymous_namespace_name
;
493 /* Allocate a level of searching. */
497 push_decl_level (stack
, obstack
)
498 struct stack_level
*stack
;
499 struct obstack
*obstack
;
501 struct stack_level tem
;
504 return push_stack_level (obstack
, (char *)&tem
, sizeof (tem
));
507 /* For each binding contour we allocate a binding_level structure
508 which records the names defined in that contour.
511 1) one for each function definition,
512 where internal declarations of the parameters appear.
513 2) one for each compound statement,
514 to record its declarations.
516 The current meaning of a name can be found by searching the levels
517 from the current one out to the global one.
519 Off to the side, may be the class_binding_level. This exists only
520 to catch class-local declarations. It is otherwise nonexistent.
522 Also there may be binding levels that catch cleanups that must be
523 run when exceptions occur. Thus, to see whether a name is bound in
524 the current scope, it is not enough to look in the
525 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
528 /* Note that the information in the `names' component of the global contour
529 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
533 /* A chain of _DECL nodes for all variables, constants, functions,
534 and typedef types. These are in the reverse of the order
535 supplied. There may be OVERLOADs on this list, too, but they
536 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
539 /* A list of structure, union and enum definitions, for looking up
541 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
542 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
543 or ENUMERAL_TYPE node.
545 C++: the TREE_VALUE nodes can be simple types for
546 component_bindings. */
549 /* A list of USING_DECL nodes. */
552 /* A list of used namespaces. PURPOSE is the namespace,
553 VALUE the common ancestor with this binding_level's namespace. */
554 tree using_directives
;
556 /* If this binding level is the binding level for a class, then
557 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
558 is the name of an entity bound in the class; the TREE_VALUE is
559 the IDENTIFIER_CLASS_VALUE before we entered the class. Thus,
560 when leaving class scope, we can restore the
561 IDENTIFIER_CLASS_VALUE by walking this list. The TREE_TYPE is
562 the DECL bound by this name in the class. */
565 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
566 is used for all binding levels. */
569 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
570 label in this scope. The TREE_PURPOSE is the previous value of
571 the IDENTIFIER_LABEL VALUE. */
572 tree shadowed_labels
;
574 /* For each level (except not the global one),
575 a chain of BLOCK nodes for all the levels
576 that were entered and exited one level down. */
579 /* The BLOCK node for this level, if one has been preallocated.
580 If 0, the BLOCK is allocated (if needed) when the level is popped. */
583 /* The binding level which this one is contained in (inherits from). */
584 struct binding_level
*level_chain
;
586 /* List of decls in `names' that have incomplete
587 structure or union types. */
590 /* List of VAR_DECLS saved from a previous for statement.
591 These would be dead in ANSI-conforming code, but might
592 be referenced in ARM-era code. These are stored in a
593 TREE_LIST; the TREE_VALUE is the actual declaration. */
594 tree dead_vars_from_for
;
596 /* 1 for the level that holds the parameters of a function.
597 2 for the level that holds a class declaration.
598 3 for levels that hold parameter declarations. */
599 unsigned parm_flag
: 4;
601 /* 1 means make a BLOCK for this level regardless of all else.
602 2 for temporary binding contours created by the compiler. */
605 /* Nonzero if this level "doesn't exist" for tags. */
606 unsigned tag_transparent
: 1;
608 /* Nonzero if this level can safely have additional
609 cleanup-needing variables added to it. */
610 unsigned more_cleanups_ok
: 1;
611 unsigned have_cleanups
: 1;
613 /* Nonzero if this level is for storing the decls for template
614 parameters and generic decls; these decls will be discarded and
615 replaced with a TEMPLATE_DECL. */
616 unsigned pseudo_global
: 1;
618 /* This is set for a namespace binding level. */
619 unsigned namespace_p
: 1;
621 /* True if this level is that of a for-statement where we need to
622 worry about ambiguous (ARM or ANSI) scope rules. */
623 unsigned is_for_scope
: 1;
625 /* True if this level corresponds to an EH region, as for a try block. */
626 unsigned eh_region
: 1;
628 /* One bit left for this word. */
630 #if defined(DEBUG_CP_BINDING_LEVELS)
631 /* Binding depth at which this level began. */
632 unsigned binding_depth
;
633 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
636 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
638 /* The binding level currently in effect. */
640 #define current_binding_level cp_function_chain->binding_level
642 /* The binding level of the current class, if any. */
644 static struct binding_level
*class_binding_level
;
646 /* A chain of binding_level structures awaiting reuse. */
648 static struct binding_level
*free_binding_level
;
650 /* The outermost binding level, for names of file scope.
651 This is created when the compiler is started and exists
652 through the entire run. */
654 static struct binding_level
*global_binding_level
;
656 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
658 static int keep_next_level_flag
;
660 #if defined(DEBUG_CP_BINDING_LEVELS)
661 static int binding_depth
= 0;
662 static int is_class_level
= 0;
669 for (i
= 0; i
< binding_depth
*2; i
++)
672 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
674 static tree pushdecl_with_scope
PROTO((tree
, struct binding_level
*));
677 push_binding_level (newlevel
, tag_transparent
, keep
)
678 struct binding_level
*newlevel
;
679 int tag_transparent
, keep
;
681 /* Add this level to the front of the chain (stack) of levels that
683 bzero ((char*) newlevel
, sizeof (struct binding_level
));
684 newlevel
->level_chain
= current_binding_level
;
685 current_binding_level
= newlevel
;
686 newlevel
->tag_transparent
= tag_transparent
;
687 newlevel
->more_cleanups_ok
= 1;
689 /* We are called before expand_start_bindings, but after
690 expand_eh_region_start for a try block; so we check this now,
691 before the EH block is covered up. */
692 newlevel
->eh_region
= is_eh_region ();
694 newlevel
->keep
= keep
;
695 #if defined(DEBUG_CP_BINDING_LEVELS)
696 newlevel
->binding_depth
= binding_depth
;
698 fprintf (stderr
, "push %s level 0x%08x line %d\n",
699 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
702 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
705 /* Find the innermost enclosing class scope, and reset
706 CLASS_BINDING_LEVEL appropriately. */
709 find_class_binding_level ()
711 struct binding_level
*level
= current_binding_level
;
713 while (level
&& level
->parm_flag
!= 2)
714 level
= level
->level_chain
;
715 if (level
&& level
->parm_flag
== 2)
716 class_binding_level
= level
;
718 class_binding_level
= 0;
724 if (global_binding_level
)
726 /* Cannot pop a level, if there are none left to pop. */
727 if (current_binding_level
== global_binding_level
)
728 my_friendly_abort (123);
730 /* Pop the current level, and free the structure for reuse. */
731 #if defined(DEBUG_CP_BINDING_LEVELS)
734 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
735 (is_class_level
) ? "class" : "block",
736 current_binding_level
, lineno
);
737 if (is_class_level
!= (current_binding_level
== class_binding_level
))
740 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
743 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
745 register struct binding_level
*level
= current_binding_level
;
746 current_binding_level
= current_binding_level
->level_chain
;
747 level
->level_chain
= free_binding_level
;
748 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
749 if (level
->binding_depth
!= binding_depth
)
751 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
752 free_binding_level
= level
;
753 find_class_binding_level ();
758 suspend_binding_level ()
760 if (class_binding_level
)
761 current_binding_level
= class_binding_level
;
763 if (global_binding_level
)
765 /* Cannot suspend a level, if there are none left to suspend. */
766 if (current_binding_level
== global_binding_level
)
767 my_friendly_abort (123);
769 /* Suspend the current level. */
770 #if defined(DEBUG_CP_BINDING_LEVELS)
773 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
774 (is_class_level
) ? "class" : "block",
775 current_binding_level
, lineno
);
776 if (is_class_level
!= (current_binding_level
== class_binding_level
))
779 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
782 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
783 current_binding_level
= current_binding_level
->level_chain
;
784 find_class_binding_level ();
788 resume_binding_level (b
)
789 struct binding_level
*b
;
791 /* Resuming binding levels is meant only for namespaces,
792 and those cannot nest into classes. */
793 my_friendly_assert(!class_binding_level
, 386);
794 /* Also, resuming a non-directly nested namespace is a no-no. */
795 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
796 current_binding_level
= b
;
797 #if defined(DEBUG_CP_BINDING_LEVELS)
798 b
->binding_depth
= binding_depth
;
800 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
801 (is_class_level
) ? "class" : "block", b
, lineno
);
804 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
807 /* Create a new `struct binding_level'. */
810 struct binding_level
*
811 make_binding_level ()
814 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
817 /* Nonzero if we are currently in the global binding level. */
822 return current_binding_level
== global_binding_level
;
825 /* Return the innermost binding level that is not for a class scope. */
827 static struct binding_level
*
828 innermost_nonclass_level ()
830 struct binding_level
*b
;
832 b
= current_binding_level
;
833 while (b
->parm_flag
== 2)
839 /* Nonzero if we are currently in a toplevel binding level. This
840 means either the global binding level or a namespace in a toplevel
841 binding level. Since there are no non-toplevel namespace levels,
842 this really means any namespace or pseudo-global level. We also
843 include a class whose context is toplevel. */
846 toplevel_bindings_p ()
848 struct binding_level
*b
= innermost_nonclass_level ();
850 return b
->namespace_p
|| b
->pseudo_global
;
853 /* Nonzero if this is a namespace scope, or if we are defining a class
854 which is itself at namespace scope, or whose enclosing class is
855 such a class, etc. */
858 namespace_bindings_p ()
860 struct binding_level
*b
= innermost_nonclass_level ();
862 return b
->namespace_p
;
865 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
866 unconditionally. Otherwise, use the normal logic to decide whether
867 or not to create a BLOCK. */
870 keep_next_level (keep
)
873 keep_next_level_flag
= keep
;
876 /* Nonzero if the current level needs to have a BLOCK made. */
881 return (current_binding_level
->blocks
!= NULL_TREE
882 || current_binding_level
->keep
883 || current_binding_level
->names
!= NULL_TREE
884 || (current_binding_level
->tags
!= NULL_TREE
885 && !current_binding_level
->tag_transparent
));
888 /* Identify this binding level as a level of parameters. */
891 declare_parm_level ()
893 current_binding_level
->parm_flag
= 1;
897 declare_pseudo_global_level ()
899 current_binding_level
->pseudo_global
= 1;
903 declare_namespace_level ()
905 current_binding_level
->namespace_p
= 1;
909 pseudo_global_level_p ()
911 return current_binding_level
->pseudo_global
;
915 set_class_shadows (shadows
)
918 class_binding_level
->class_shadowed
= shadows
;
921 /* Enter a new binding level.
922 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
923 not for that of tags. */
926 pushlevel (tag_transparent
)
929 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
931 /* If this is the top level of a function,
932 just make sure that NAMED_LABELS is 0.
933 They should have been set to 0 at the end of the previous function. */
935 if (current_binding_level
== global_binding_level
)
936 my_friendly_assert (named_labels
== NULL_TREE
, 134);
938 /* Reuse or create a struct for this binding level. */
940 #if defined(DEBUG_CP_BINDING_LEVELS)
942 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
943 if (free_binding_level
)
944 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
946 newlevel
= free_binding_level
;
947 free_binding_level
= free_binding_level
->level_chain
;
950 newlevel
= make_binding_level ();
952 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
953 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
954 keep_next_level_flag
= 0;
958 note_level_for_for ()
960 current_binding_level
->is_for_scope
= 1;
964 pushlevel_temporary (tag_transparent
)
967 pushlevel (tag_transparent
);
968 current_binding_level
->keep
= 2;
971 /* Note we don't call push_momentary() here. Otherwise, it would cause
972 cleanups to be allocated on the momentary obstack, and they will be
973 overwritten by the next statement. */
975 expand_start_bindings (0);
978 /* For a binding between a name and an entity at a block scope,
979 this is the `struct binding_level' for the block. */
980 #define BINDING_LEVEL(NODE) \
981 (((struct tree_binding*)NODE)->scope.level)
983 /* These are currently unused, but permanent, CPLUS_BINDING nodes.
984 They are kept here because they are allocated from the permanent
985 obstack and cannot be easily freed. */
986 static tree free_binding_nodes
;
988 /* Make DECL the innermost binding for ID. The LEVEL is the binding
989 level at which this declaration is being bound. */
992 push_binding (id
, decl
, level
)
995 struct binding_level
* level
;
999 if (!free_binding_nodes
)
1001 /* There are no free nodes, so we must build one here. */
1002 push_permanent_obstack ();
1003 binding
= make_node (CPLUS_BINDING
);
1008 /* There are nodes on the free list. Grab the first one. */
1009 binding
= free_binding_nodes
;
1011 /* And update the free list. */
1012 free_binding_nodes
= TREE_CHAIN (free_binding_nodes
);
1015 /* Now, fill in the binding information. */
1016 BINDING_VALUE (binding
) = decl
;
1017 BINDING_TYPE (binding
) = NULL_TREE
;
1018 BINDING_LEVEL (binding
) = level
;
1019 INHERITED_VALUE_BINDING_P (binding
) = 0;
1020 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
1022 /* And put it on the front of the list of bindings for ID. */
1023 TREE_CHAIN (binding
) = IDENTIFIER_BINDING (id
);
1024 IDENTIFIER_BINDING (id
) = binding
;
1027 /* ID is already bound in the current scope. But, DECL is an
1028 additional binding for ID in the same scope. This is the `struct
1029 stat' hack whereby a non-typedef class-name or enum-name can be
1030 bound at the same level as some other kind of entity. It's the
1031 responsibility of the caller to check that inserting this name is
1032 legal here. Returns nonzero if the new binding was successful. */
1034 add_binding (id
, decl
)
1038 tree binding
= IDENTIFIER_BINDING (id
);
1041 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
1042 /* The new name is the type name. */
1043 BINDING_TYPE (binding
) = decl
;
1044 else if (!BINDING_VALUE (binding
))
1045 /* This situation arises when push_class_level_binding moves an
1046 inherited type-binding out of the way to make room for a new
1048 BINDING_VALUE (binding
) = decl
;
1049 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1050 && DECL_ARTIFICIAL (BINDING_VALUE (binding
)))
1052 /* The old binding was a type name. It was placed in
1053 BINDING_VALUE because it was thought, at the point it was
1054 declared, to be the only entity with such a name. Move the
1055 type name into the type slot; it is now hidden by the new
1057 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
1058 BINDING_VALUE (binding
) = decl
;
1059 INHERITED_VALUE_BINDING_P (binding
) = 0;
1061 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1062 && TREE_CODE (decl
) == TYPE_DECL
1063 && DECL_NAME (decl
) == DECL_NAME (BINDING_VALUE (binding
))
1064 && same_type_p (TREE_TYPE (decl
),
1065 TREE_TYPE (BINDING_VALUE (binding
))))
1066 /* We have two typedef-names, both naming the same type to have
1067 the same name. This is OK because of:
1071 In a given scope, a typedef specifier can be used to redefine
1072 the name of any type declared in that scope to refer to the
1073 type to which it already refers. */
1077 cp_error ("declaration of `%#D'", decl
);
1078 cp_error_at ("conflicts with previous declaration `%#D'",
1079 BINDING_VALUE (binding
));
1086 /* Add DECL to the list of things declared in B. */
1089 add_decl_to_level (decl
, b
)
1091 struct binding_level
*b
;
1093 /* Only things that will live forever should go in the global
1095 my_friendly_assert (!(b
== global_binding_level
1096 && !TREE_PERMANENT (decl
)),
1099 /* We build up the list in reverse order, and reverse it later if
1101 TREE_CHAIN (decl
) = b
->names
;
1105 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1106 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1107 doesn't really belong to this binding level, that it got here
1108 through a using-declaration. */
1111 push_local_binding (id
, decl
, flags
)
1116 struct binding_level
*b
;
1118 /* Skip over any local classes. This makes sense if we call
1119 push_local_binding with a friend decl of a local class. */
1120 b
= current_binding_level
;
1121 while (b
->parm_flag
== 2)
1124 if (lookup_name_current_level (id
))
1126 /* Supplement the existing binding. */
1127 if (!add_binding (id
, decl
))
1128 /* It didn't work. Something else must be bound at this
1129 level. Do not add DECL to the list of things to pop
1134 /* Create a new binding. */
1135 push_binding (id
, decl
, b
);
1137 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1138 /* We must put the OVERLOAD into a TREE_LIST since the
1139 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1140 decls that got here through a using-declaration. */
1141 decl
= build_tree_list (NULL_TREE
, decl
);
1143 /* And put DECL on the list of things declared by the current
1145 add_decl_to_level (decl
, b
);
1148 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1149 binding was successful. */
1152 push_class_binding (id
, decl
)
1157 tree binding
= IDENTIFIER_BINDING (id
);
1160 /* Note that we declared this value so that we can issue an error if
1161 this an illegal redeclaration of a name already used for some
1163 note_name_declared_in_class (id
, decl
);
1165 if (binding
&& BINDING_LEVEL (binding
) == class_binding_level
)
1166 /* Supplement the existing binding. */
1167 result
= add_binding (id
, decl
);
1169 /* Create a new binding. */
1170 push_binding (id
, decl
, class_binding_level
);
1172 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1173 class-level declaration. Note that we do not use DECL here
1174 because of the possibility of the `struct stat' hack; if DECL is
1175 a class-name or enum-name we might prefer a field-name, or some
1177 IDENTIFIER_CLASS_VALUE (id
) = BINDING_VALUE (IDENTIFIER_BINDING (id
));
1179 /* If this is a binding from a base class, mark it as such. */
1180 binding
= IDENTIFIER_BINDING (id
);
1181 if (BINDING_VALUE (binding
) == decl
&& TREE_CODE (decl
) != TREE_LIST
)
1183 /* Any implicit typename must be from a base-class. The
1184 context for an implicit typename declaration is always
1185 the derived class in which the lookup was done, so the checks
1186 based on the context of DECL below will not trigger. */
1187 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl
))
1188 INHERITED_VALUE_BINDING_P (binding
) = 1;
1191 if (TREE_CODE (decl
) == OVERLOAD
)
1192 context
= DECL_REAL_CONTEXT (OVL_CURRENT (decl
));
1195 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd',
1197 context
= DECL_REAL_CONTEXT (decl
);
1200 if (is_properly_derived_from (current_class_type
, context
))
1201 INHERITED_VALUE_BINDING_P (binding
) = 1;
1203 INHERITED_VALUE_BINDING_P (binding
) = 0;
1206 else if (BINDING_VALUE (binding
) == decl
)
1207 /* We only encounter a TREE_LIST when push_class_decls detects an
1208 ambiguity. Such an ambiguity can be overridden by a definition
1210 INHERITED_VALUE_BINDING_P (binding
) = 1;
1215 /* Remove the binding for DECL which should be the innermost binding
1219 pop_binding (id
, decl
)
1225 if (id
== NULL_TREE
)
1226 /* It's easiest to write the loops that call this function without
1227 checking whether or not the entities involved have names. We
1228 get here for such an entity. */
1231 /* Get the innermost binding for ID. */
1232 binding
= IDENTIFIER_BINDING (id
);
1234 /* The name should be bound. */
1235 my_friendly_assert (binding
!= NULL_TREE
, 0);
1237 /* The DECL will be either the ordinary binding or the type
1238 binding for this identifier. Remove that binding. */
1239 if (BINDING_VALUE (binding
) == decl
)
1240 BINDING_VALUE (binding
) = NULL_TREE
;
1241 else if (BINDING_TYPE (binding
) == decl
)
1242 BINDING_TYPE (binding
) = NULL_TREE
;
1244 my_friendly_abort (0);
1246 if (!BINDING_VALUE (binding
) && !BINDING_TYPE (binding
))
1248 /* We're completely done with the innermost binding for this
1249 identifier. Unhook it from the list of bindings. */
1250 IDENTIFIER_BINDING (id
) = TREE_CHAIN (binding
);
1252 /* And place it on the free list. */
1253 TREE_CHAIN (binding
) = free_binding_nodes
;
1254 free_binding_nodes
= binding
;
1258 /* When a label goes out of scope, check to see if that label was used
1259 in a valid manner, and issue any appropriate warnings or errors. */
1265 tree label
= TREE_VALUE (link
);
1267 if (DECL_INITIAL (label
) == NULL_TREE
)
1269 cp_error_at ("label `%D' used but not defined", label
);
1270 /* Avoid crashing later. */
1271 define_label (input_filename
, 1, DECL_NAME (label
));
1273 else if (warn_unused
&& !TREE_USED (label
))
1274 cp_warning_at ("label `%D' defined but not used", label
);
1276 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), TREE_PURPOSE (link
));
1279 /* At the end of a function, all labels declared within the fucntion
1280 go out of scope. BLOCK is the top-level block for the
1289 /* Clear out the definitions of all label names, since their scopes
1291 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1294 /* Put the labels into the "variables" of the top-level block,
1295 so debugger can see them. */
1296 TREE_CHAIN (TREE_VALUE (link
)) = BLOCK_VARS (block
);
1297 BLOCK_VARS (block
) = TREE_VALUE (link
);
1300 named_labels
= NULL_TREE
;
1303 /* Exit a binding level.
1304 Pop the level off, and restore the state of the identifier-decl mappings
1305 that were in effect when this level was entered.
1307 If KEEP == 1, this level had explicit declarations, so
1308 and create a "block" (a BLOCK node) for the level
1309 to record its declarations and subblocks for symbol table output.
1311 If FUNCTIONBODY is nonzero, this level is the body of a function,
1312 so create a block as if KEEP were set and also clear out all
1315 If REVERSE is nonzero, reverse the order of decls before putting
1316 them into the BLOCK. */
1319 poplevel (keep
, reverse
, functionbody
)
1325 /* The chain of decls was accumulated in reverse order.
1326 Put it into forward order, just for cleanliness. */
1328 int tmp
= functionbody
;
1329 int real_functionbody
= current_binding_level
->keep
== 2
1330 ? ((functionbody
= 0), tmp
) : functionbody
;
1331 tree tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1332 tree subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1333 tree block
= NULL_TREE
;
1335 int block_previously_created
;
1336 int leaving_for_scope
;
1338 if (current_binding_level
->parm_flag
== 2)
1339 return poplevel_class ();
1341 my_friendly_assert (!current_binding_level
->class_shadowed
,
1344 /* We used to use KEEP == 2 to indicate that the new block should go
1345 at the beginning of the list of blocks at this binding level,
1346 rather than the end. This hack is no longer used. */
1347 my_friendly_assert (keep
== 0 || keep
== 1, 0);
1349 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1350 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1351 current_binding_level
->parm_flag
,
1352 current_binding_level
->keep
);
1354 if (current_binding_level
->keep
== 1)
1357 /* Get the decls in the order they were written.
1358 Usually current_binding_level->names is in reverse order.
1359 But parameter decls were previously put in forward order. */
1362 current_binding_level
->names
1363 = decls
= nreverse (current_binding_level
->names
);
1365 decls
= current_binding_level
->names
;
1367 /* Output any nested inline functions within this block
1368 if they weren't already output. */
1370 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1371 if (TREE_CODE (decl
) == FUNCTION_DECL
1372 && ! TREE_ASM_WRITTEN (decl
)
1373 && DECL_INITIAL (decl
) != NULL_TREE
1374 && TREE_ADDRESSABLE (decl
)
1375 && decl_function_context (decl
) == current_function_decl
)
1377 /* If this decl was copied from a file-scope decl
1378 on account of a block-scope extern decl,
1379 propagate TREE_ADDRESSABLE to the file-scope decl. */
1380 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1381 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1384 push_function_context ();
1385 output_inline_function (decl
);
1386 pop_function_context ();
1390 /* If there were any declarations or structure tags in that level,
1391 or if this level is a function body,
1392 create a BLOCK to record them for the life of this function. */
1395 block_previously_created
= (current_binding_level
->this_block
!= NULL_TREE
);
1396 if (block_previously_created
)
1397 block
= current_binding_level
->this_block
;
1398 else if (keep
== 1 || functionbody
)
1399 block
= make_node (BLOCK
);
1400 if (block
!= NULL_TREE
)
1402 if (block_previously_created
)
1404 if (decls
|| tags
|| subblocks
)
1406 if (BLOCK_VARS (block
) || BLOCK_TYPE_TAGS (block
))
1407 warning ("internal compiler error: debugging info corrupted");
1409 BLOCK_VARS (block
) = decls
;
1410 BLOCK_TYPE_TAGS (block
) = tags
;
1412 /* We can have previous subblocks and new subblocks when
1413 doing fixup_gotos with complex cleanups. We chain the new
1414 subblocks onto the end of any pre-existing subblocks. */
1415 BLOCK_SUBBLOCKS (block
) = chainon (BLOCK_SUBBLOCKS (block
),
1418 /* If we created the block earlier on, and we are just
1419 diddling it now, then it already should have a proper
1420 BLOCK_END_NOTE value associated with it. */
1424 BLOCK_VARS (block
) = decls
;
1425 BLOCK_TYPE_TAGS (block
) = tags
;
1426 BLOCK_SUBBLOCKS (block
) = subblocks
;
1427 /* Otherwise, for a new block, install a new BLOCK_END_NOTE
1429 remember_end_note (block
);
1433 /* In each subblock, record that this is its superior. */
1436 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1437 BLOCK_SUPERCONTEXT (link
) = block
;
1439 /* We still support the old for-scope rules, whereby the variables
1440 in a for-init statement were in scope after the for-statement
1441 ended. We only use the new rules in flag_new_for_scope is
1444 = current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1;
1446 /* Remove declarations for all the DECLs in this level. */
1447 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1449 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
)
1452 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link
)));
1456 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link
));
1458 ns_binding
= NULL_TREE
;
1461 && (BINDING_LEVEL (outer_binding
)
1462 == current_binding_level
->level_chain
))
1463 /* We have something like:
1468 and we are leaving the `for' scope. There's no reason to
1469 keep the binding of the inner `i' in this case. */
1470 pop_binding (DECL_NAME (link
), link
);
1471 else if ((outer_binding
1472 && (TREE_CODE (BINDING_VALUE (outer_binding
))
1475 && TREE_CODE (ns_binding
) == TYPE_DECL
))
1476 /* Here, we have something like:
1484 We must pop the for-scope binding so we know what's a
1485 type and what isn't. */
1486 pop_binding (DECL_NAME (link
), link
);
1489 /* Mark this VAR_DECL as dead so that we can tell we left it
1490 there only for backward compatibility. */
1491 DECL_DEAD_FOR_LOCAL (link
) = 1;
1493 /* Keep track of what should of have happenned when we
1494 popped the binding. */
1495 if (outer_binding
&& BINDING_VALUE (outer_binding
))
1496 DECL_SHADOWED_FOR_VAR (link
)
1497 = BINDING_VALUE (outer_binding
);
1499 /* Add it to the list of dead variables in the next
1500 outermost binding to that we can remove these when we
1501 leave that binding. */
1502 current_binding_level
->level_chain
->dead_vars_from_for
1503 = tree_cons (NULL_TREE
, link
,
1504 current_binding_level
->level_chain
->
1505 dead_vars_from_for
);
1507 /* Although we don't pop the CPLUS_BINDING, we do clear
1508 its BINDING_LEVEL since the level is going away now. */
1509 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link
)))
1515 /* Remove the binding. */
1517 if (TREE_CODE (decl
) == TREE_LIST
)
1518 decl
= TREE_VALUE (decl
);
1519 if (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd')
1520 pop_binding (DECL_NAME (decl
), decl
);
1521 else if (TREE_CODE (decl
) == OVERLOAD
)
1522 pop_binding (DECL_NAME (OVL_FUNCTION (decl
)), decl
);
1524 my_friendly_abort (0);
1528 /* Remove declarations for any `for' variables from inner scopes
1529 that we kept around. */
1530 for (link
= current_binding_level
->dead_vars_from_for
;
1531 link
; link
= TREE_CHAIN (link
))
1532 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
1534 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1535 for (link
= current_binding_level
->type_shadowed
;
1536 link
; link
= TREE_CHAIN (link
))
1537 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1539 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1540 for (link
= current_binding_level
->shadowed_labels
;
1542 link
= TREE_CHAIN (link
))
1545 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1546 list if a `using' declaration put them there. The debugging
1547 back-ends won't understand OVERLOAD, so we remove them here.
1548 Because the BLOCK_VARS are (temporarily) shared with
1549 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1550 popped all the bindings. */
1555 for (d
= &BLOCK_VARS (block
); *d
; )
1557 if (TREE_CODE (*d
) == TREE_LIST
)
1558 *d
= TREE_CHAIN (*d
);
1560 d
= &TREE_CHAIN (*d
);
1564 /* If the level being exited is the top level of a function,
1565 check over all the labels. */
1568 /* Since this is the top level block of a function, the vars are
1569 the function's parameters. Don't leave them in the BLOCK
1570 because they are found in the FUNCTION_DECL instead. */
1571 BLOCK_VARS (block
) = 0;
1575 /* Any uses of undefined labels now operate under constraints
1576 of next binding contour. */
1578 struct binding_level
*level_chain
;
1579 level_chain
= current_binding_level
->level_chain
;
1582 struct named_label_list
*labels
;
1583 for (labels
= named_label_uses
; labels
; labels
= labels
->next
)
1584 if (labels
->binding_level
== current_binding_level
)
1586 labels
->binding_level
= level_chain
;
1587 labels
->names_in_scope
= level_chain
->names
;
1592 tmp
= current_binding_level
->keep
;
1594 pop_binding_level ();
1596 DECL_INITIAL (current_function_decl
) = block
;
1599 if (!block_previously_created
)
1600 current_binding_level
->blocks
1601 = chainon (current_binding_level
->blocks
, block
);
1603 /* If we did not make a block for the level just exited,
1604 any blocks made for inner levels
1605 (since they cannot be recorded as subblocks in that level)
1606 must be carried forward so they will later become subblocks
1607 of something else. */
1609 current_binding_level
->blocks
1610 = chainon (current_binding_level
->blocks
, subblocks
);
1612 /* Take care of compiler's internal binding structures. */
1615 expand_end_bindings (getdecls (), keep
, 1);
1616 /* Each and every BLOCK node created here in `poplevel' is important
1617 (e.g. for proper debugging information) so if we created one
1618 earlier, mark it as "used". */
1620 TREE_USED (block
) = 1;
1621 block
= poplevel (keep
, reverse
, real_functionbody
);
1624 /* Each and every BLOCK node created here in `poplevel' is important
1625 (e.g. for proper debugging information) so if we created one
1626 earlier, mark it as "used". */
1628 TREE_USED (block
) = 1;
1632 /* Delete the node BLOCK from the current binding level.
1633 This is used for the block inside a stmt expr ({...})
1634 so that the block can be reinserted where appropriate. */
1637 delete_block (block
)
1641 if (current_binding_level
->blocks
== block
)
1642 current_binding_level
->blocks
= TREE_CHAIN (block
);
1643 for (t
= current_binding_level
->blocks
; t
;)
1645 if (TREE_CHAIN (t
) == block
)
1646 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1650 TREE_CHAIN (block
) = NULL_TREE
;
1651 /* Clear TREE_USED which is always set by poplevel.
1652 The flag is set again if insert_block is called. */
1653 TREE_USED (block
) = 0;
1656 /* Insert BLOCK at the end of the list of subblocks of the
1657 current binding level. This is used when a BIND_EXPR is expanded,
1658 to handle the BLOCK node inside the BIND_EXPR. */
1661 insert_block (block
)
1664 TREE_USED (block
) = 1;
1665 current_binding_level
->blocks
1666 = chainon (current_binding_level
->blocks
, block
);
1669 /* Set the BLOCK node for the innermost scope
1670 (the one we are currently in). */
1674 register tree block
;
1676 current_binding_level
->this_block
= block
;
1679 /* Do a pushlevel for class declarations. */
1684 register struct binding_level
*newlevel
;
1686 /* Reuse or create a struct for this binding level. */
1687 #if defined(DEBUG_CP_BINDING_LEVELS)
1689 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1690 if (free_binding_level
)
1691 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1693 newlevel
= free_binding_level
;
1694 free_binding_level
= free_binding_level
->level_chain
;
1697 newlevel
= make_binding_level ();
1699 #if defined(DEBUG_CP_BINDING_LEVELS)
1701 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1703 push_binding_level (newlevel
, 0, 0);
1705 decl_stack
= push_decl_level (decl_stack
, &decl_obstack
);
1706 class_binding_level
= current_binding_level
;
1707 class_binding_level
->parm_flag
= 2;
1710 /* ...and a poplevel for class declarations. */
1715 register struct binding_level
*level
= class_binding_level
;
1718 my_friendly_assert (level
!= 0, 354);
1720 decl_stack
= pop_stack_level (decl_stack
);
1721 /* If we're leaving a toplevel class, don't bother to do the setting
1722 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1723 shouldn't even be used when current_class_type isn't set, and second,
1724 if we don't touch it here, we're able to use the cache effect if the
1725 next time we're entering a class scope, it is the same class. */
1726 if (current_class_depth
!= 1)
1728 struct binding_level
* b
;
1730 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1731 for (shadowed
= level
->class_shadowed
;
1733 shadowed
= TREE_CHAIN (shadowed
))
1734 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = NULL_TREE
;
1736 /* Find the next enclosing class, and recreate
1737 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1738 b
= level
->level_chain
;
1739 while (b
&& b
->parm_flag
!= 2)
1743 for (shadowed
= b
->class_shadowed
;
1745 shadowed
= TREE_CHAIN (shadowed
))
1749 t
= IDENTIFIER_BINDING (TREE_PURPOSE (shadowed
));
1750 while (t
&& BINDING_LEVEL (t
) != b
)
1754 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
))
1755 = BINDING_VALUE (t
);
1759 /* Remember to save what IDENTIFIER's were bound in this scope so we
1760 can recover from cache misses. */
1762 previous_class_type
= current_class_type
;
1763 previous_class_values
= class_binding_level
->class_shadowed
;
1765 for (shadowed
= level
->type_shadowed
;
1767 shadowed
= TREE_CHAIN (shadowed
))
1768 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1770 /* Remove the bindings for all of the class-level declarations. */
1771 for (shadowed
= level
->class_shadowed
;
1773 shadowed
= TREE_CHAIN (shadowed
))
1774 pop_binding (TREE_PURPOSE (shadowed
), TREE_TYPE (shadowed
));
1776 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1777 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1778 class_binding_level
->parm_flag
,
1779 class_binding_level
->keep
);
1781 /* Now, pop out of the binding level which we created up in the
1782 `pushlevel_class' routine. */
1783 #if defined(DEBUG_CP_BINDING_LEVELS)
1785 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1787 pop_binding_level ();
1792 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1793 for any names in enclosing classes. */
1796 clear_identifier_class_values ()
1800 if (!class_binding_level
)
1803 for (t
= class_binding_level
->class_shadowed
;
1806 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t
)) = NULL_TREE
;
1809 /* Returns non-zero if T is a virtual function table. */
1812 vtable_decl_p (t
, data
)
1814 void *data ATTRIBUTE_UNUSED
;
1816 return (TREE_CODE (t
) == VAR_DECL
&& DECL_VIRTUAL_P (t
));
1819 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1823 vtype_decl_p (t
, data
)
1825 void *data ATTRIBUTE_UNUSED
;
1827 return (TREE_CODE (t
) == TYPE_DECL
1828 && TREE_TYPE (t
) != error_mark_node
1829 && TYPE_LANG_SPECIFIC (TREE_TYPE (t
))
1830 && CLASSTYPE_VSIZE (TREE_TYPE (t
)));
1833 /* Return the declarations that are members of the namespace NS. */
1836 cp_namespace_decls (ns
)
1839 return NAMESPACE_LEVEL (ns
)->names
;
1842 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1843 itself, calling F for each. The DATA is passed to F as well. */
1846 walk_namespaces_r (namespace, f
, data
)
1848 walk_namespaces_fn f
;
1854 result
|= (*f
) (namespace, data
);
1856 for (current
= cp_namespace_decls (namespace);
1858 current
= TREE_CHAIN (current
))
1860 if (TREE_CODE (current
) != NAMESPACE_DECL
1861 || DECL_NAMESPACE_ALIAS (current
))
1863 if (!DECL_LANG_SPECIFIC (current
))
1866 my_friendly_assert (current
== std_node
, 393);
1870 /* We found a namespace. */
1871 result
|= walk_namespaces_r (current
, f
, data
);
1877 /* Walk all the namespaces, calling F for each. The DATA is passed to
1881 walk_namespaces (f
, data
)
1882 walk_namespaces_fn f
;
1885 return walk_namespaces_r (global_namespace
, f
, data
);
1888 struct walk_globals_data
{
1889 walk_globals_pred p
;
1894 /* Walk the global declarations in NAMESPACE. Whenever one is found
1895 for which P returns non-zero, call F with its address. If any call
1896 to F returns a non-zero value, return a non-zero value. */
1899 walk_globals_r (namespace, data
)
1903 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
1904 walk_globals_pred p
= wgd
->p
;
1905 walk_globals_fn f
= wgd
->f
;
1906 void *d
= wgd
->data
;
1910 t
= &NAMESPACE_LEVEL (namespace)->names
;
1917 result
|= (*f
) (t
, d
);
1919 /* If F changed *T, then *T still points at the next item to
1922 t
= &TREE_CHAIN (*t
);
1928 /* Walk the global declarations. Whenever one is found for which P
1929 returns non-zero, call F with its address. If any call to F
1930 returns a non-zero value, return a non-zero value. */
1933 walk_globals (p
, f
, data
)
1934 walk_globals_pred p
;
1938 struct walk_globals_data wgd
;
1943 return walk_namespaces (walk_globals_r
, &wgd
);
1946 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1947 DATA is non-NULL, this is the last time we will call
1948 wrapup_global_declarations for this NAMESPACE. */
1951 wrapup_globals_for_namespace (namespace, data
)
1955 tree globals
= cp_namespace_decls (namespace);
1956 int len
= list_length (globals
);
1957 tree
*vec
= (tree
*) alloca (sizeof (tree
) * len
);
1961 int last_time
= (data
!= 0);
1963 if (last_time
&& namespace == global_namespace
)
1964 /* Let compile_file handle the global namespace. */
1967 /* Process the decls in reverse order--earliest first.
1968 Put them into VEC from back to front, then take out from front. */
1970 for (i
= 0, decl
= globals
; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
1971 vec
[len
- i
- 1] = decl
;
1975 check_global_declarations (vec
, len
);
1979 /* Temporarily mark vtables as external. That prevents
1980 wrapup_global_declarations from writing them out; we must process
1981 them ourselves in finish_vtable_vardecl. */
1982 for (i
= 0; i
< len
; ++i
)
1983 if (vtable_decl_p (vec
[i
], /*data=*/0) && !DECL_EXTERNAL (vec
[i
]))
1985 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 1;
1986 DECL_EXTERNAL (vec
[i
]) = 1;
1989 /* Write out any globals that need to be output. */
1990 result
= wrapup_global_declarations (vec
, len
);
1992 /* Undo the hack to DECL_EXTERNAL above. */
1993 for (i
= 0; i
< len
; ++i
)
1994 if (vtable_decl_p (vec
[i
], /*data=*/0)
1995 && DECL_NOT_REALLY_EXTERN (vec
[i
]))
1997 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 0;
1998 DECL_EXTERNAL (vec
[i
]) = 0;
2006 mark_binding_level (arg
)
2009 struct binding_level
*lvl
= *(struct binding_level
**)arg
;
2013 ggc_mark_tree (lvl
->names
);
2014 ggc_mark_tree (lvl
->tags
);
2015 ggc_mark_tree (lvl
->usings
);
2016 ggc_mark_tree (lvl
->using_directives
);
2017 ggc_mark_tree (lvl
->class_shadowed
);
2018 ggc_mark_tree (lvl
->type_shadowed
);
2019 ggc_mark_tree (lvl
->shadowed_labels
);
2020 ggc_mark_tree (lvl
->blocks
);
2021 ggc_mark_tree (lvl
->this_block
);
2022 ggc_mark_tree (lvl
->incomplete
);
2023 ggc_mark_tree (lvl
->dead_vars_from_for
);
2025 lvl
= lvl
->level_chain
;
2029 /* For debugging. */
2030 static int no_print_functions
= 0;
2031 static int no_print_builtins
= 0;
2034 print_binding_level (lvl
)
2035 struct binding_level
*lvl
;
2039 fprintf (stderr
, " blocks=");
2040 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
2041 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
2042 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
2043 if (lvl
->tag_transparent
)
2044 fprintf (stderr
, " tag-transparent");
2045 if (lvl
->more_cleanups_ok
)
2046 fprintf (stderr
, " more-cleanups-ok");
2047 if (lvl
->have_cleanups
)
2048 fprintf (stderr
, " have-cleanups");
2049 fprintf (stderr
, "\n");
2052 fprintf (stderr
, " names:\t");
2053 /* We can probably fit 3 names to a line? */
2054 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
2056 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
2058 if (no_print_builtins
2059 && (TREE_CODE (t
) == TYPE_DECL
)
2060 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
2063 /* Function decls tend to have longer names. */
2064 if (TREE_CODE (t
) == FUNCTION_DECL
)
2071 fprintf (stderr
, "\n\t");
2074 print_node_brief (stderr
, "", t
, 0);
2075 if (t
== error_mark_node
)
2079 fprintf (stderr
, "\n");
2083 fprintf (stderr
, " tags:\t");
2085 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
2087 if (TREE_PURPOSE (t
) == NULL_TREE
)
2089 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2096 fprintf (stderr
, "\n\t");
2099 if (TREE_PURPOSE (t
) == NULL_TREE
)
2101 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
2102 fprintf (stderr
, ">");
2104 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2105 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2108 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
2109 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2110 fprintf (stderr
, ">");
2114 fprintf (stderr
, "\n");
2116 if (lvl
->class_shadowed
)
2118 fprintf (stderr
, " class-shadowed:");
2119 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
2121 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2123 fprintf (stderr
, "\n");
2125 if (lvl
->type_shadowed
)
2127 fprintf (stderr
, " type-shadowed:");
2128 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2130 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2132 fprintf (stderr
, "\n");
2137 print_other_binding_stack (stack
)
2138 struct binding_level
*stack
;
2140 struct binding_level
*level
;
2141 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
2143 fprintf (stderr
, "binding level ");
2144 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
2145 fprintf (stderr
, "\n");
2146 print_binding_level (level
);
2151 print_binding_stack ()
2153 struct binding_level
*b
;
2154 fprintf (stderr
, "current_binding_level=");
2155 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
2156 fprintf (stderr
, "\nclass_binding_level=");
2157 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
2158 fprintf (stderr
, "\nglobal_binding_level=");
2159 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
2160 fprintf (stderr
, "\n");
2161 if (class_binding_level
)
2163 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
2164 if (b
== current_binding_level
)
2167 b
= class_binding_level
;
2169 b
= current_binding_level
;
2172 b
= current_binding_level
;
2173 print_other_binding_stack (b
);
2174 fprintf (stderr
, "global:\n");
2175 print_binding_level (global_binding_level
);
2178 /* Namespace binding access routines: The namespace_bindings field of
2179 the identifier is polymorphic, with three possible values:
2180 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2181 indicating the BINDING_VALUE of global_namespace. */
2183 /* Check whether the a binding for the name to scope is known.
2184 Assumes that the bindings of the name are already a list
2185 of bindings. Returns the binding found, or NULL_TREE. */
2188 find_binding (name
, scope
)
2192 tree iter
, prev
= NULL_TREE
;
2194 scope
= ORIGINAL_NAMESPACE (scope
);
2196 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
2197 iter
= TREE_CHAIN (iter
))
2199 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
2200 if (BINDING_SCOPE (iter
) == scope
)
2202 /* Move binding found to the front of the list, so
2203 subsequent lookups will find it faster. */
2206 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
2207 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
2208 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
2217 /* Always returns a binding for name in scope. If the
2218 namespace_bindings is not a list, convert it to one first.
2219 If no binding is found, make a new one. */
2222 binding_for_name (name
, scope
)
2226 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2229 scope
= ORIGINAL_NAMESPACE (scope
);
2231 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
2233 /* Get rid of optimization for global scope. */
2234 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
2235 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
2236 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2238 if (b
&& (result
= find_binding (name
, scope
)))
2240 /* Not found, make a new permanent one. */
2241 push_obstacks (&permanent_obstack
, &permanent_obstack
);
2242 result
= make_node (CPLUS_BINDING
);
2243 TREE_CHAIN (result
) = b
;
2244 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2245 BINDING_SCOPE (result
) = scope
;
2246 BINDING_TYPE (result
) = NULL_TREE
;
2247 BINDING_VALUE (result
) = NULL_TREE
;
2252 /* Return the binding value for name in scope, considering that
2253 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2256 namespace_binding (name
, scope
)
2260 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2263 if (scope
== NULL_TREE
)
2264 scope
= global_namespace
;
2265 if (TREE_CODE (b
) != CPLUS_BINDING
)
2266 return (scope
== global_namespace
) ? b
: NULL_TREE
;
2267 name
= find_binding (name
,scope
);
2268 if (name
== NULL_TREE
)
2270 return BINDING_VALUE (name
);
2273 /* Set the binding value for name in scope. If modifying the binding
2274 of global_namespace is attempted, try to optimize it. */
2277 set_namespace_binding (name
, scope
, val
)
2284 if (scope
== NULL_TREE
)
2285 scope
= global_namespace
;
2287 if (scope
== global_namespace
)
2289 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2290 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
2292 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
2296 b
= binding_for_name (name
, scope
);
2297 BINDING_VALUE (b
) = val
;
2300 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2301 select a name that is unique to this compilation unit. */
2304 push_namespace (name
)
2309 int implicit_use
= 0;
2311 if (!global_namespace
)
2313 /* This must be ::. */
2314 my_friendly_assert (name
== get_identifier ("::"), 377);
2319 /* The name of anonymous namespace is unique for the translation
2321 if (!anonymous_namespace_name
)
2322 anonymous_namespace_name
= get_file_function_name ('N');
2323 name
= anonymous_namespace_name
;
2324 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2326 /* Reopening anonymous namespace. */
2330 else if (current_namespace
== global_namespace
2331 && name
== DECL_NAME (std_node
))
2338 /* Check whether this is an extended namespace definition. */
2339 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2340 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2343 if (DECL_NAMESPACE_ALIAS (d
))
2345 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2346 d
, DECL_NAMESPACE_ALIAS (d
));
2347 d
= DECL_NAMESPACE_ALIAS (d
);
2354 /* Make a new namespace, binding the name to it. */
2355 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2356 /* The global namespace is not pushed, and the global binding
2357 level is set elsewhere. */
2362 declare_namespace_level ();
2363 NAMESPACE_LEVEL (d
) = current_binding_level
;
2367 resume_binding_level (NAMESPACE_LEVEL (d
));
2370 do_using_directive (d
);
2371 /* Enter the name space. */
2372 current_namespace
= d
;
2375 /* Pop from the scope of the current namespace. */
2380 if (current_namespace
== global_namespace
)
2382 my_friendly_assert (in_std
>0, 980421);
2386 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2387 /* The binding level is not popped, as it might be re-opened later. */
2388 suspend_binding_level ();
2391 /* Push into the scope of the namespace NS, even if it is deeply
2392 nested within another namespace. */
2395 push_nested_namespace (ns
)
2398 if (ns
== global_namespace
)
2399 push_to_top_level ();
2402 push_nested_namespace (CP_DECL_CONTEXT (ns
));
2403 push_namespace (DECL_NAME (ns
));
2407 /* Pop back from the scope of the namespace NS, which was previously
2408 entered with push_nested_namespace. */
2411 pop_nested_namespace (ns
)
2414 while (ns
!= global_namespace
)
2417 ns
= CP_DECL_CONTEXT (ns
);
2420 pop_from_top_level ();
2424 /* Subroutines for reverting temporarily to top-level for instantiation
2425 of templates and such. We actually need to clear out the class- and
2426 local-value slots of all identifiers, so that only the global values
2427 are at all visible. Simply setting current_binding_level to the global
2428 scope isn't enough, because more binding levels may be pushed. */
2429 struct saved_scope
{
2430 struct binding_level
*old_binding_level
;
2433 struct saved_scope
*prev
;
2434 tree class_name
, class_type
;
2435 tree access_specifier
;
2437 struct binding_level
*class_bindings
;
2438 tree
*lang_base
, *lang_stack
, lang_name
;
2440 tree last_function_parms
;
2441 tree template_parms
;
2442 HOST_WIDE_INT processing_template_decl
;
2443 tree previous_class_type
, previous_class_values
;
2444 int processing_specialization
;
2445 int processing_explicit_instantiation
;
2446 char *class_cache_firstobj
;
2448 static struct saved_scope
*current_saved_scope
;
2450 /* A chain of the binding vecs created by store_bindings. We create a
2451 whole bunch of these during compilation, on permanent_obstack, so we
2452 can't just throw them away. */
2453 static tree free_binding_vecs
;
2456 store_bindings (names
, old_bindings
)
2457 tree names
, old_bindings
;
2460 for (t
= names
; t
; t
= TREE_CHAIN (t
))
2462 tree binding
, t1
, id
;
2464 if (TREE_CODE (t
) == TREE_LIST
)
2465 id
= TREE_PURPOSE (t
);
2470 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2471 we have no IDENTIFIER_BINDING if we have left the class
2472 scope, but cached the class-level declarations. */
2473 || !(IDENTIFIER_BINDING (id
) || IDENTIFIER_CLASS_VALUE (id
)))
2476 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
2477 if (TREE_VEC_ELT (t1
, 0) == id
)
2480 if (free_binding_vecs
)
2482 binding
= free_binding_vecs
;
2483 free_binding_vecs
= TREE_CHAIN (free_binding_vecs
);
2486 binding
= make_tree_vec (4);
2490 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
2491 TREE_VEC_ELT (binding
, 0) = id
;
2492 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
2493 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_BINDING (id
);
2494 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
2495 IDENTIFIER_BINDING (id
) = NULL_TREE
;
2496 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
2498 TREE_CHAIN (binding
) = old_bindings
;
2499 old_bindings
= binding
;
2503 return old_bindings
;
2507 maybe_push_to_top_level (pseudo
)
2510 extern int current_lang_stacksize
;
2511 struct saved_scope
*s
2512 = (struct saved_scope
*) xmalloc (sizeof (struct saved_scope
));
2513 struct binding_level
*b
= current_binding_level
;
2514 tree old_bindings
= NULL_TREE
;
2516 push_function_context_to (NULL_TREE
);
2518 if (previous_class_type
)
2519 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
2521 /* Have to include global_binding_level, because class-level decls
2522 aren't listed anywhere useful. */
2523 for (; b
; b
= b
->level_chain
)
2527 /* Template IDs are inserted into the global level. If they were
2528 inserted into namespace level, finish_file wouldn't find them
2529 when doing pending instantiations. Therefore, don't stop at
2530 namespace level, but continue until :: . */
2531 if (b
== global_binding_level
|| (pseudo
&& b
->pseudo_global
))
2534 old_bindings
= store_bindings (b
->names
, old_bindings
);
2535 /* We also need to check class_shadowed to save class-level type
2536 bindings, since pushclass doesn't fill in b->names. */
2537 if (b
->parm_flag
== 2)
2538 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2540 /* Unwind type-value slots back to top level. */
2541 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2542 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2545 s
->old_binding_level
= current_binding_level
;
2546 current_binding_level
= b
;
2548 s
->old_namespace
= current_namespace
;
2549 s
->class_name
= current_class_name
;
2550 s
->class_type
= current_class_type
;
2551 s
->access_specifier
= current_access_specifier
;
2552 s
->function_decl
= current_function_decl
;
2553 s
->class_bindings
= class_binding_level
;
2554 s
->lang_stack
= current_lang_stack
;
2555 s
->lang_base
= current_lang_base
;
2556 s
->lang_stacksize
= current_lang_stacksize
;
2557 s
->lang_name
= current_lang_name
;
2558 s
->last_function_parms
= last_function_parms
;
2559 s
->template_parms
= current_template_parms
;
2560 s
->processing_template_decl
= processing_template_decl
;
2561 s
->previous_class_type
= previous_class_type
;
2562 s
->previous_class_values
= previous_class_values
;
2563 s
->class_cache_firstobj
= class_cache_firstobj
;
2564 s
->processing_specialization
= processing_specialization
;
2565 s
->processing_explicit_instantiation
= processing_explicit_instantiation
;
2567 current_class_name
= current_class_type
= NULL_TREE
;
2568 current_function_decl
= NULL_TREE
;
2569 class_binding_level
= (struct binding_level
*)0;
2570 current_lang_stacksize
= 10;
2571 current_lang_stack
= current_lang_base
2572 = (tree
*) xmalloc (current_lang_stacksize
* sizeof (tree
));
2573 current_lang_name
= lang_name_cplusplus
;
2574 strict_prototype
= strict_prototypes_lang_cplusplus
;
2575 named_labels
= NULL_TREE
;
2576 previous_class_type
= previous_class_values
= NULL_TREE
;
2577 class_cache_firstobj
= 0;
2578 processing_specialization
= 0;
2579 processing_explicit_instantiation
= 0;
2580 current_template_parms
= NULL_TREE
;
2581 processing_template_decl
= 0;
2582 current_namespace
= global_namespace
;
2584 s
->prev
= current_saved_scope
;
2585 s
->old_bindings
= old_bindings
;
2586 current_saved_scope
= s
;
2588 push_obstacks (&permanent_obstack
, &permanent_obstack
);
2592 push_to_top_level ()
2594 maybe_push_to_top_level (0);
2598 pop_from_top_level ()
2600 extern int current_lang_stacksize
;
2601 struct saved_scope
*s
= current_saved_scope
;
2604 /* Clear out class-level bindings cache. */
2605 if (previous_class_type
)
2606 invalidate_class_lookup_cache ();
2610 current_binding_level
= s
->old_binding_level
;
2611 current_saved_scope
= s
->prev
;
2612 for (t
= s
->old_bindings
; t
; )
2615 tree id
= TREE_VEC_ELT (t
, 0);
2618 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2619 IDENTIFIER_BINDING (id
) = TREE_VEC_ELT (t
, 2);
2620 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2623 TREE_CHAIN (save
) = free_binding_vecs
;
2624 free_binding_vecs
= save
;
2626 current_namespace
= s
->old_namespace
;
2627 current_class_name
= s
->class_name
;
2628 current_class_type
= s
->class_type
;
2629 current_access_specifier
= s
->access_specifier
;
2630 current_function_decl
= s
->function_decl
;
2631 class_binding_level
= s
->class_bindings
;
2632 free (current_lang_base
);
2633 current_lang_base
= s
->lang_base
;
2634 current_lang_stack
= s
->lang_stack
;
2635 current_lang_name
= s
->lang_name
;
2636 current_lang_stacksize
= s
->lang_stacksize
;
2637 if (current_lang_name
== lang_name_cplusplus
)
2638 strict_prototype
= strict_prototypes_lang_cplusplus
;
2639 else if (current_lang_name
== lang_name_c
)
2640 strict_prototype
= strict_prototypes_lang_c
;
2641 last_function_parms
= s
->last_function_parms
;
2642 current_template_parms
= s
->template_parms
;
2643 processing_template_decl
= s
->processing_template_decl
;
2644 previous_class_type
= s
->previous_class_type
;
2645 previous_class_values
= s
->previous_class_values
;
2646 processing_specialization
= s
->processing_specialization
;
2647 processing_explicit_instantiation
= s
->processing_explicit_instantiation
;
2648 class_cache_firstobj
= s
->class_cache_firstobj
;
2652 pop_function_context_from (NULL_TREE
);
2655 /* Push a definition of struct, union or enum tag "name".
2656 into binding_level "b". "type" should be the type node,
2657 We assume that the tag "name" is not already defined.
2659 Note that the definition may really be just a forward reference.
2660 In that case, the TYPE_SIZE will be a NULL_TREE.
2662 C++ gratuitously puts all these tags in the name space. */
2664 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2665 record the shadowed value for this binding contour. TYPE is
2666 the type that ID maps to. */
2669 set_identifier_type_value_with_scope (id
, type
, b
)
2672 struct binding_level
*b
;
2674 if (!b
->namespace_p
)
2676 /* Shadow the marker, not the real thing, so that the marker
2677 gets restored later. */
2678 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2680 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2684 tree binding
= binding_for_name (id
, current_namespace
);
2685 BINDING_TYPE (binding
) = type
;
2686 /* Store marker instead of real type. */
2687 type
= global_type_node
;
2689 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2692 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2695 set_identifier_type_value (id
, type
)
2699 set_identifier_type_value_with_scope (id
, type
, current_binding_level
);
2702 /* Return the type associated with id. */
2705 identifier_type_value (id
)
2708 /* There is no type with that name, anywhere. */
2709 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2711 /* This is not the type marker, but the real thing. */
2712 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2713 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2714 /* Have to search for it. It must be on the global level, now.
2715 Ask lookup_name not to return non-types. */
2716 id
= lookup_name_real (id
, 2, 1, 0);
2718 return TREE_TYPE (id
);
2722 /* Pop off extraneous binding levels left over due to syntax errors.
2724 We don't pop past namespaces, as they might be valid. */
2729 #ifdef DEBUG_CP_BINDING_LEVELS
2730 fprintf (stderr
, "XXX entering pop_everything ()\n");
2732 while (!toplevel_bindings_p ())
2734 if (current_binding_level
->parm_flag
== 2)
2735 pop_nested_class ();
2739 #ifdef DEBUG_CP_BINDING_LEVELS
2740 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2744 /* The type TYPE is being declared. If it is a class template, or a
2745 specialization of a class template, do any processing required and
2746 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2747 being declared a friend. B is the binding level at which this TYPE
2750 Returns the TYPE_DECL for TYPE, which may have been altered by this
2754 maybe_process_template_type_declaration (type
, globalize
, b
)
2757 struct binding_level
* b
;
2759 tree decl
= TYPE_NAME (type
);
2761 if (processing_template_parmlist
)
2762 /* You can't declare a new template type in a template parameter
2763 list. But, you can declare a non-template type:
2765 template <class A*> struct S;
2767 is a forward-declaration of `A'. */
2771 maybe_check_template_type (type
);
2773 my_friendly_assert (IS_AGGR_TYPE (type
)
2774 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2777 if (processing_template_decl
)
2779 /* This may change after the call to
2780 push_template_decl_real, but we want the original value. */
2781 tree name
= DECL_NAME (decl
);
2783 decl
= push_template_decl_real (decl
, globalize
);
2784 /* If the current binding level is the binding level for the
2785 template parameters (see the comment in
2786 begin_template_parm_list) and the enclosing level is a class
2787 scope, and we're not looking at a friend, push the
2788 declaration of the member class into the class scope. In the
2789 friend case, push_template_decl will already have put the
2790 friend into global scope, if appropriate. */
2791 if (TREE_CODE (type
) != ENUMERAL_TYPE
2792 && !globalize
&& b
->pseudo_global
2793 && b
->level_chain
->parm_flag
== 2)
2795 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2796 /* Put this tag on the list of tags for the class, since
2797 that won't happen below because B is not the class
2798 binding level, but is instead the pseudo-global level. */
2799 b
->level_chain
->tags
=
2800 saveable_tree_cons (name
, type
, b
->level_chain
->tags
);
2801 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2802 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2810 /* In C++, you don't have to write `struct S' to refer to `S'; you
2811 can just use `S'. We accomplish this by creating a TYPE_DECL as
2812 if the user had written `typedef struct S S'. Create and return
2813 the TYPE_DECL for TYPE. */
2816 create_implicit_typedef (name
, type
)
2822 decl
= build_decl (TYPE_DECL
, name
, type
);
2823 SET_DECL_ARTIFICIAL (decl
);
2824 /* There are other implicit type declarations, like the one *within*
2825 a class that allows you to write `S::S'. We must distinguish
2827 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
2828 TYPE_NAME (type
) = decl
;
2833 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2834 Normally put it into the inner-most non-tag-transparent scope,
2835 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2836 The latter is needed for implicit declarations. */
2839 pushtag (name
, type
, globalize
)
2843 register struct binding_level
*b
;
2845 b
= current_binding_level
;
2846 while (b
->tag_transparent
2847 || (globalize
&& b
->parm_flag
== 2))
2850 if (toplevel_bindings_p ())
2851 b
->tags
= perm_tree_cons (name
, type
, b
->tags
);
2853 b
->tags
= saveable_tree_cons (name
, type
, b
->tags
);
2857 /* Do C++ gratuitous typedefing. */
2858 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2860 register tree d
= NULL_TREE
;
2862 tree context
= TYPE_CONTEXT (type
);
2866 tree cs
= current_scope ();
2870 else if (cs
!= NULL_TREE
2871 && TREE_CODE_CLASS (TREE_CODE (cs
)) == 't')
2872 /* When declaring a friend class of a local class, we want
2873 to inject the newly named class into the scope
2874 containing the local class, not the namespace scope. */
2875 context
= hack_decl_function_context (get_type_decl (cs
));
2878 context
= current_namespace
;
2880 if ((b
->pseudo_global
&& b
->level_chain
->parm_flag
== 2)
2881 || b
->parm_flag
== 2)
2884 if (current_lang_name
== lang_name_java
)
2885 TYPE_FOR_JAVA (type
) = 1;
2887 d
= create_implicit_typedef (name
, type
);
2888 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2890 set_identifier_type_value_with_scope (name
, type
, b
);
2892 d
= maybe_process_template_type_declaration (type
,
2895 if (b
->parm_flag
== 2)
2897 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2898 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2899 class. But if it's a member template class, we
2900 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2902 finish_member_declaration (d
);
2904 pushdecl_class_level (d
);
2907 d
= pushdecl_with_scope (d
, b
);
2909 if (ANON_AGGRNAME_P (name
))
2910 DECL_IGNORED_P (d
) = 1;
2912 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2913 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2914 if (!uses_template_parms (type
))
2915 DECL_ASSEMBLER_NAME (d
)
2916 = get_identifier (build_overload_name (type
, 1, 1));
2918 if (b
->parm_flag
== 2)
2920 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2921 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2925 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2926 /* Use the canonical TYPE_DECL for this node. */
2927 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2930 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2931 will be the tagged type we just added to the current
2932 binding level. This fake NULL-named TYPE_DECL node helps
2933 dwarfout.c to know when it needs to output a
2934 representation of a tagged type, and it also gives us a
2935 convenient place to record the "scope start" address for
2938 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2939 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2943 /* Counter used to create anonymous type names. */
2945 static int anon_cnt
= 0;
2947 /* Return an IDENTIFIER which can be used as a name for
2948 anonymous structs and unions. */
2955 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2956 return get_identifier (buf
);
2959 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2960 This keeps dbxout from getting confused. */
2965 register struct binding_level
*b
;
2967 static int last_cnt
= 0;
2969 /* Fast out if no new anon names were declared. */
2970 if (last_cnt
== anon_cnt
)
2973 b
= current_binding_level
;
2974 while (b
->tag_transparent
)
2979 /* A NULL purpose means we have already processed all tags
2980 from here to the end of the list. */
2981 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2983 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2984 TREE_PURPOSE (tags
) = NULL_TREE
;
2985 tags
= TREE_CHAIN (tags
);
2987 last_cnt
= anon_cnt
;
2990 /* Subroutine of duplicate_decls: return truthvalue of whether
2991 or not types of these decls match.
2993 For C++, we must compare the parameter list so that `int' can match
2994 `int&' in a parameter position, but `int&' is not confused with
2998 decls_match (newdecl
, olddecl
)
2999 tree newdecl
, olddecl
;
3003 if (newdecl
== olddecl
)
3006 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
3007 /* If the two DECLs are not even the same kind of thing, we're not
3008 interested in their types. */
3011 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3013 tree f1
= TREE_TYPE (newdecl
);
3014 tree f2
= TREE_TYPE (olddecl
);
3015 tree p1
= TYPE_ARG_TYPES (f1
);
3016 tree p2
= TYPE_ARG_TYPES (f2
);
3018 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
)
3019 && ! (DECL_LANGUAGE (newdecl
) == lang_c
3020 && DECL_LANGUAGE (olddecl
) == lang_c
))
3023 /* When we parse a static member function definition,
3024 we put together a FUNCTION_DECL which thinks its type
3025 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
3027 if (TREE_CODE (f1
) == METHOD_TYPE
&& DECL_STATIC_FUNCTION_P (olddecl
))
3028 revert_static_member_fn (&newdecl
, &f1
, &p1
);
3029 else if (TREE_CODE (f2
) == METHOD_TYPE
3030 && DECL_STATIC_FUNCTION_P (newdecl
))
3031 revert_static_member_fn (&olddecl
, &f2
, &p2
);
3033 /* Here we must take care of the case where new default
3034 parameters are specified. Also, warn if an old
3035 declaration becomes ambiguous because default
3036 parameters may cause the two to be ambiguous. */
3037 if (TREE_CODE (f1
) != TREE_CODE (f2
))
3039 if (TREE_CODE (f1
) == OFFSET_TYPE
)
3040 cp_compiler_error ("`%D' redeclared as member function", newdecl
);
3042 cp_compiler_error ("`%D' redeclared as non-member function", newdecl
);
3046 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
3048 if (! strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
) == lang_c
3051 types_match
= self_promoting_args_p (p1
);
3052 if (p1
== void_list_node
)
3053 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
3055 else if (!strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
)==lang_c
3056 && DECL_LANGUAGE (newdecl
) == lang_c
&& p1
== NULL_TREE
)
3058 types_match
= self_promoting_args_p (p2
);
3059 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
3062 types_match
= compparms (p1
, p2
);
3067 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3069 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3070 DECL_TEMPLATE_PARMS (olddecl
)))
3073 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3076 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
3077 DECL_TEMPLATE_RESULT (newdecl
));
3081 if (TREE_TYPE (newdecl
) == error_mark_node
)
3082 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
3083 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
3084 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
3085 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
3088 types_match
= comptypes (TREE_TYPE (newdecl
),
3089 TREE_TYPE (olddecl
),
3090 COMPARE_REDECLARATION
);
3096 /* If NEWDECL is `static' and an `extern' was seen previously,
3097 warn about it. (OLDDECL may be NULL_TREE; NAME contains
3098 information about previous usage as an `extern'.)
3100 Note that this does not apply to the C++ case of declaring
3101 a variable `extern const' and then later `const'.
3103 Don't complain about built-in functions, since they are beyond
3104 the user's control. */
3107 warn_extern_redeclared_static (newdecl
, olddecl
)
3108 tree newdecl
, olddecl
;
3112 static const char *explicit_extern_static_warning
3113 = "`%D' was declared `extern' and later `static'";
3114 static const char *implicit_extern_static_warning
3115 = "`%D' was declared implicitly `extern' and later `static'";
3117 if (TREE_CODE (newdecl
) == TYPE_DECL
)
3120 name
= DECL_ASSEMBLER_NAME (newdecl
);
3121 if (TREE_PUBLIC (name
) && DECL_THIS_STATIC (newdecl
))
3123 /* It's okay to redeclare an ANSI built-in function as static,
3124 or to declare a non-ANSI built-in function as anything. */
3125 if (! (TREE_CODE (newdecl
) == FUNCTION_DECL
3126 && olddecl
!= NULL_TREE
3127 && TREE_CODE (olddecl
) == FUNCTION_DECL
3128 && DECL_ARTIFICIAL (olddecl
)))
3130 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
3131 ? implicit_extern_static_warning
3132 : explicit_extern_static_warning
, newdecl
);
3133 if (olddecl
!= NULL_TREE
)
3134 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
3139 /* Handle when a new declaration NEWDECL has the same name as an old
3140 one OLDDECL in the same binding contour. Prints an error message
3143 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3144 Otherwise, return 0. */
3147 duplicate_decls (newdecl
, olddecl
)
3148 tree newdecl
, olddecl
;
3150 extern struct obstack permanent_obstack
;
3151 unsigned olddecl_uid
= DECL_UID (olddecl
);
3152 int olddecl_friend
= 0, types_match
= 0;
3153 int new_defines_function
= 0;
3155 if (newdecl
== olddecl
)
3158 types_match
= decls_match (newdecl
, olddecl
);
3160 /* If either the type of the new decl or the type of the old decl is an
3161 error_mark_node, then that implies that we have already issued an
3162 error (earlier) for some bogus type specification, and in that case,
3163 it is rather pointless to harass the user with yet more error message
3164 about the same declaration, so just pretend the types match here. */
3165 if (TREE_TYPE (newdecl
) == error_mark_node
3166 || TREE_TYPE (olddecl
) == error_mark_node
)
3169 /* Check for redeclaration and other discrepancies. */
3170 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3171 && DECL_ARTIFICIAL (olddecl
))
3173 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
3175 /* If you declare a built-in or predefined function name as static,
3176 the old definition is overridden, but optionally warn this was a
3177 bad choice of name. */
3178 if (! TREE_PUBLIC (newdecl
))
3181 cp_warning ("shadowing %s function `%#D'",
3182 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3184 /* Discard the old built-in function. */
3187 /* If the built-in is not ansi, then programs can override
3188 it even globally without an error. */
3189 else if (! DECL_BUILT_IN (olddecl
))
3190 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3194 cp_error ("declaration of `%#D'", newdecl
);
3195 cp_error ("conflicts with built-in declaration `%#D'",
3200 else if (!types_match
)
3202 if ((DECL_LANGUAGE (newdecl
) == lang_c
3203 && DECL_LANGUAGE (olddecl
) == lang_c
)
3204 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3205 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3207 /* A near match; override the builtin. */
3209 if (TREE_PUBLIC (newdecl
))
3211 cp_warning ("new declaration `%#D'", newdecl
);
3212 cp_warning ("ambiguates built-in declaration `%#D'",
3215 else if (warn_shadow
)
3216 cp_warning ("shadowing %s function `%#D'",
3217 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3221 /* Discard the old built-in function. */
3225 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
3227 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
3228 && TREE_CODE (newdecl
) != TYPE_DECL
3229 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
3230 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
3231 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
3232 && TREE_CODE (olddecl
) != TYPE_DECL
3233 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
3234 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
3237 /* We do nothing special here, because C++ does such nasty
3238 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3239 get shadowed, and know that if we need to find a TYPE_DECL
3240 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3241 slot of the identifier. */
3245 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
3246 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
3247 || (TREE_CODE (olddecl
) == FUNCTION_DECL
3248 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
3251 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
3252 if (TREE_CODE (olddecl
) == TREE_LIST
)
3253 olddecl
= TREE_VALUE (olddecl
);
3254 cp_error_at ("previous declaration of `%#D'", olddecl
);
3256 /* New decl is completely inconsistent with the old one =>
3257 tell caller to replace the old one. */
3261 else if (!types_match
)
3263 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
))
3264 /* These are certainly not duplicate declarations; they're
3265 from different scopes. */
3268 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3270 /* The name of a class template may not be declared to refer to
3271 any other template, class, function, object, namespace, value,
3272 or type in the same scope. */
3273 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
3274 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3276 cp_error ("declaration of template `%#D'", newdecl
);
3277 cp_error_at ("conflicts with previous declaration `%#D'",
3280 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
3281 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
3282 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
3283 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
3284 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3285 DECL_TEMPLATE_PARMS (olddecl
)))
3287 cp_error ("new declaration `%#D'", newdecl
);
3288 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3292 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3294 if (DECL_LANGUAGE (newdecl
) == lang_c
3295 && DECL_LANGUAGE (olddecl
) == lang_c
)
3297 cp_error ("declaration of C function `%#D' conflicts with",
3299 cp_error_at ("previous declaration `%#D' here", olddecl
);
3301 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3302 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3304 cp_error ("new declaration `%#D'", newdecl
);
3305 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3311 /* Already complained about this, so don't do so again. */
3312 else if (current_class_type
== NULL_TREE
3313 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
3315 cp_error ("conflicting types for `%#D'", newdecl
);
3316 cp_error_at ("previous declaration as `%#D'", olddecl
);
3319 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3320 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
3321 && (!DECL_TEMPLATE_INFO (newdecl
)
3322 || (DECL_TI_TEMPLATE (newdecl
)
3323 != DECL_TI_TEMPLATE (olddecl
))))
3324 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
3325 && (!DECL_TEMPLATE_INFO (olddecl
)
3326 || (DECL_TI_TEMPLATE (olddecl
)
3327 != DECL_TI_TEMPLATE (newdecl
))))))
3328 /* It's OK to have a template specialization and a non-template
3329 with the same type, or to have specializations of two
3330 different templates with the same type. Note that if one is a
3331 specialization, and the other is an instantiation of the same
3332 template, that we do not exit at this point. That situation
3333 can occur if we instantiate a template class, and then
3334 specialize one of its methods. This situation is legal, but
3335 the declarations must be merged in the usual way. */
3337 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3338 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
3339 && !DECL_USE_TEMPLATE (newdecl
))
3340 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
3341 && !DECL_USE_TEMPLATE (olddecl
))))
3342 /* One of the declarations is a template instantiation, and the
3343 other is not a template at all. That's OK. */
3345 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
3346 && DECL_NAMESPACE_ALIAS (newdecl
)
3347 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
3348 /* Redeclaration of namespace alias, ignore it. */
3352 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
3355 cp_error (errmsg
, newdecl
);
3356 if (DECL_NAME (olddecl
) != NULL_TREE
)
3357 cp_error_at ((DECL_INITIAL (olddecl
)
3358 && namespace_bindings_p ())
3359 ? "`%#D' previously defined here"
3360 : "`%#D' previously declared here", olddecl
);
3362 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3363 && DECL_INITIAL (olddecl
) != NULL_TREE
3364 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
3365 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
3367 /* Prototype decl follows defn w/o prototype. */
3368 cp_warning_at ("prototype for `%#D'", newdecl
);
3369 cp_warning_at ("follows non-prototype definition here", olddecl
);
3371 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3372 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
3374 /* extern "C" int foo ();
3375 int foo () { bar (); }
3377 if (current_lang_stack
== current_lang_base
)
3378 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3381 cp_error_at ("previous declaration of `%#D' with %L linkage",
3382 olddecl
, DECL_LANGUAGE (olddecl
));
3383 cp_error ("conflicts with new declaration with %L linkage",
3384 DECL_LANGUAGE (newdecl
));
3388 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
3390 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
3392 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
3393 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
3396 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
3397 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
3399 for (; t1
&& t1
!= void_list_node
;
3400 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
3401 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
3403 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
3408 cp_pedwarn ("default argument given for parameter %d of `%#D'",
3410 cp_pedwarn_at ("after previous specification in `%#D'",
3416 cp_error ("default argument given for parameter %d of `%#D'",
3418 cp_error_at ("after previous specification in `%#D'",
3423 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
3424 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
3426 cp_warning ("`%#D' was used before it was declared inline",
3428 cp_warning_at ("previous non-inline declaration here",
3434 /* If new decl is `static' and an `extern' was seen previously,
3436 warn_extern_redeclared_static (newdecl
, olddecl
);
3438 /* We have committed to returning 1 at this point. */
3439 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3441 /* Now that functions must hold information normally held
3442 by field decls, there is extra work to do so that
3443 declaration information does not get destroyed during
3445 if (DECL_VINDEX (olddecl
))
3446 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
3447 if (DECL_CONTEXT (olddecl
))
3448 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
3449 if (DECL_CLASS_CONTEXT (olddecl
))
3450 DECL_CLASS_CONTEXT (newdecl
) = DECL_CLASS_CONTEXT (olddecl
);
3451 if (DECL_PENDING_INLINE_INFO (newdecl
) == (struct pending_inline
*)0)
3452 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
3453 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
3454 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
3455 DECL_ABSTRACT_VIRTUAL_P (newdecl
) |= DECL_ABSTRACT_VIRTUAL_P (olddecl
);
3456 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
3457 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
3458 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
3460 /* Optionally warn about more than one declaration for the same
3461 name, but don't warn about a function declaration followed by a
3463 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
3464 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
3465 /* Don't warn about extern decl followed by definition. */
3466 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
3467 /* Don't warn about friends, let add_friend take care of it. */
3468 && ! DECL_FRIEND_P (newdecl
))
3470 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
3471 cp_warning_at ("previous declaration of `%D'", olddecl
);
3475 /* Deal with C++: must preserve virtual function table size. */
3476 if (TREE_CODE (olddecl
) == TYPE_DECL
)
3478 register tree newtype
= TREE_TYPE (newdecl
);
3479 register tree oldtype
= TREE_TYPE (olddecl
);
3481 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
3482 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
3484 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
3485 CLASSTYPE_FRIEND_CLASSES (newtype
)
3486 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
3490 /* Copy all the DECL_... slots specified in the new decl
3491 except for any that we copy here from the old type. */
3492 DECL_MACHINE_ATTRIBUTES (newdecl
)
3493 = merge_machine_decl_attributes (olddecl
, newdecl
);
3495 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3497 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl
),
3498 DECL_TEMPLATE_RESULT (olddecl
)))
3499 cp_error ("invalid redeclaration of %D", newdecl
);
3500 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
3501 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
3502 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
3503 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3510 /* Automatically handles default parameters. */
3511 tree oldtype
= TREE_TYPE (olddecl
);
3514 /* Make sure we put the new type in the same obstack as the old one. */
3516 push_obstacks (TYPE_OBSTACK (oldtype
), TYPE_OBSTACK (oldtype
));
3518 push_permanent_obstack ();
3520 /* Merge the data types specified in the two decls. */
3521 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3523 if (TREE_CODE (newdecl
) == VAR_DECL
)
3524 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3525 /* Do this after calling `common_type' so that default
3526 parameters don't confuse us. */
3527 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3528 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3529 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3531 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3532 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3533 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3534 TYPE_RAISES_EXCEPTIONS (oldtype
));
3536 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3537 && DECL_SOURCE_LINE (olddecl
) != 0
3539 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)),
3540 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
)), 1))
3542 cp_error ("declaration of `%F' throws different exceptions",
3544 cp_error_at ("to previous declaration `%F'", olddecl
);
3547 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3549 /* Lay the type out, unless already done. */
3550 if (! same_type_p (newtype
, oldtype
)
3551 && TREE_TYPE (newdecl
) != error_mark_node
3552 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3553 layout_type (TREE_TYPE (newdecl
));
3555 if ((TREE_CODE (newdecl
) == VAR_DECL
3556 || TREE_CODE (newdecl
) == PARM_DECL
3557 || TREE_CODE (newdecl
) == RESULT_DECL
3558 || TREE_CODE (newdecl
) == FIELD_DECL
3559 || TREE_CODE (newdecl
) == TYPE_DECL
)
3560 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3561 layout_decl (newdecl
, 0);
3563 /* Merge the type qualifiers. */
3564 if (TREE_READONLY (newdecl
))
3565 TREE_READONLY (olddecl
) = 1;
3566 if (TREE_THIS_VOLATILE (newdecl
))
3567 TREE_THIS_VOLATILE (olddecl
) = 1;
3569 /* Merge the initialization information. */
3570 if (DECL_INITIAL (newdecl
) == NULL_TREE
3571 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3573 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3574 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3575 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3576 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
3577 && DECL_LANG_SPECIFIC (newdecl
)
3578 && DECL_LANG_SPECIFIC (olddecl
))
3579 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3582 /* Merge the section attribute.
3583 We want to issue an error if the sections conflict but that must be
3584 done later in decl_attributes since we are called before attributes
3586 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3587 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3589 /* Keep the old rtl since we can safely use it, unless it's the
3590 call to abort() used for abstract virtuals. */
3591 if ((DECL_LANG_SPECIFIC (olddecl
)
3592 && !DECL_ABSTRACT_VIRTUAL_P (olddecl
))
3593 || DECL_RTL (olddecl
) != DECL_RTL (abort_fndecl
))
3594 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3598 /* If cannot merge, then use the new type and qualifiers,
3599 and don't preserve the old rtl. */
3602 /* Clean out any memory we had of the old declaration. */
3603 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3605 TREE_VALUE (oldstatic
) = error_mark_node
;
3607 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3608 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3609 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3610 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3613 /* Merge the storage class information. */
3614 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3615 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3616 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3617 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3618 if (! DECL_EXTERNAL (olddecl
))
3619 DECL_EXTERNAL (newdecl
) = 0;
3621 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3623 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3624 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3625 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3626 DECL_TEMPLATE_INSTANTIATED (newdecl
)
3627 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
3628 /* Don't really know how much of the language-specific
3629 values we should copy from old to new. */
3630 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3631 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3632 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3633 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3634 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3636 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3637 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3638 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
3639 DECL_BEFRIENDING_CLASSES (newdecl
)
3640 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
3641 DECL_BEFRIENDING_CLASSES (olddecl
));
3644 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3646 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3647 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3649 /* If newdecl is not a specialization, then it is not a
3650 template-related function at all. And that means that we
3651 shoud have exited above, returning 0. */
3652 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3655 if (TREE_USED (olddecl
))
3656 /* From [temp.expl.spec]:
3658 If a template, a member template or the member of a class
3659 template is explicitly specialized then that
3660 specialization shall be declared before the first use of
3661 that specialization that would cause an implicit
3662 instantiation to take place, in every translation unit in
3663 which such a use occurs. */
3664 cp_error ("explicit specialization of %D after first use",
3667 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3669 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3671 /* If either decl says `inline', this fn is inline, unless its
3672 definition was passed already. */
3673 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3674 DECL_INLINE (olddecl
) = 1;
3675 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3679 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3680 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3681 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3683 if (! types_match
|| new_defines_function
)
3685 /* These need to be copied so that the names are available.
3686 Note that if the types do match, we'll preserve inline
3687 info and other bits, but if not, we won't. */
3688 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3689 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3691 if (new_defines_function
)
3692 /* If defining a function declared with other language
3693 linkage, use the previously declared language linkage. */
3694 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3695 else if (types_match
)
3697 /* If redeclaring a builtin function, and not a definition,
3698 it stays built in. */
3699 if (DECL_BUILT_IN (olddecl
))
3701 DECL_BUILT_IN (newdecl
) = 1;
3702 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3703 /* If we're keeping the built-in definition, keep the rtl,
3704 regardless of declaration matches. */
3705 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3708 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3710 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3711 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3712 /* Previously saved insns go together with
3713 the function's previous definition. */
3714 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3715 /* Don't clear out the arguments if we're redefining a function. */
3716 if (DECL_ARGUMENTS (olddecl
))
3717 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3719 if (DECL_LANG_SPECIFIC (olddecl
))
3720 DECL_MAIN_VARIANT (newdecl
) = DECL_MAIN_VARIANT (olddecl
);
3723 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3725 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3728 /* Now preserve various other info from the definition. */
3729 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3730 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3731 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3732 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3734 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3737 struct lang_decl
*ol
= DECL_LANG_SPECIFIC (olddecl
);
3738 struct lang_decl
*nl
= DECL_LANG_SPECIFIC (newdecl
);
3740 function_size
= sizeof (struct tree_decl
);
3742 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3743 (char *) olddecl
+ sizeof (struct tree_common
),
3744 function_size
- sizeof (struct tree_common
));
3746 /* Can we safely free the storage used by newdecl? */
3748 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3749 & ~ obstack_alignment_mask (&permanent_obstack))
3751 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3753 /* If newdecl is a template instantiation, it is possible that
3754 the following sequence of events has occurred:
3756 o A friend function was declared in a class template. The
3757 class template was instantiated.
3759 o The instantiation of the friend declaration was
3760 recorded on the instantiation list, and is newdecl.
3762 o Later, however, instantiate_class_template called pushdecl
3763 on the newdecl to perform name injection. But, pushdecl in
3764 turn called duplicate_decls when it discovered that another
3765 declaration of a global function with the same name already
3768 o Here, in duplicate_decls, we decided to clobber newdecl.
3770 If we're going to do that, we'd better make sure that
3771 olddecl, and not newdecl, is on the list of
3772 instantiations so that if we try to do the instantiation
3773 again we won't get the clobbered declaration. */
3775 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3776 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3778 for (; decls
; decls
= TREE_CHAIN (decls
))
3779 if (TREE_VALUE (decls
) == newdecl
)
3780 TREE_VALUE (decls
) = olddecl
;
3783 if (((char *)newdecl
+ ROUND (function_size
) == (char *)nl
3784 && ((char *)newdecl
+ ROUND (function_size
)
3785 + ROUND (sizeof (struct lang_decl
))
3786 == obstack_next_free (&permanent_obstack
)))
3787 || ((char *)newdecl
+ ROUND (function_size
)
3788 == obstack_next_free (&permanent_obstack
)))
3790 DECL_MAIN_VARIANT (newdecl
) = olddecl
;
3791 DECL_LANG_SPECIFIC (olddecl
) = ol
;
3792 bcopy ((char *)nl
, (char *)ol
, sizeof (struct lang_decl
));
3794 obstack_free (&permanent_obstack
, newdecl
);
3796 else if (LANG_DECL_PERMANENT (ol
) && ol
!= nl
)
3798 if (DECL_MAIN_VARIANT (olddecl
) == olddecl
)
3800 struct lang_decl
*free_lang_decl
= ol
;
3802 /* Save these lang_decls that would otherwise be lost. */
3803 if (DECL_LANG_SPECIFIC (olddecl
) == ol
)
3806 free_lang_decl
->u
.next
= free_lang_decl_chain
;
3807 free_lang_decl_chain
= free_lang_decl
;
3811 /* Storage leak. */;
3817 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3818 (char *) olddecl
+ sizeof (struct tree_common
),
3819 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3820 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3823 DECL_UID (olddecl
) = olddecl_uid
;
3825 DECL_FRIEND_P (olddecl
) = 1;
3827 /* NEWDECL contains the merged attribute lists.
3828 Update OLDDECL to be the same. */
3829 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3834 /* Record a decl-node X as belonging to the current lexical scope.
3835 Check for errors (such as an incompatible declaration for the same
3836 name already seen in the same scope).
3838 Returns either X or an old decl for the same name.
3839 If an old decl is returned, it may have been smashed
3840 to agree with what X says. */
3847 register tree name
= DECL_ASSEMBLER_NAME (x
);
3848 int need_new_binding
= 1;
3850 if (DECL_TEMPLATE_PARM_P (x
))
3851 /* Template parameters have no context; they are not X::T even
3852 when declared within a class or namespace. */
3856 if (current_function_decl
&& x
!= current_function_decl
3857 /* A local declaration for a function doesn't constitute
3859 && (TREE_CODE (x
) != FUNCTION_DECL
|| DECL_INITIAL (x
))
3860 /* Don't change DECL_CONTEXT of virtual methods. */
3861 && (TREE_CODE (x
) != FUNCTION_DECL
|| !DECL_VIRTUAL_P (x
))
3862 && !DECL_CONTEXT (x
))
3863 DECL_CONTEXT (x
) = current_function_decl
;
3864 if (!DECL_CONTEXT (x
))
3865 DECL_CONTEXT (x
) = FROB_CONTEXT (current_namespace
);
3868 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3869 compiler wants to use. */
3870 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
3871 || TREE_CODE (x
) == NAMESPACE_DECL
)
3872 name
= DECL_NAME (x
);
3877 /* Not needed...see below. */
3881 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3882 name
= TREE_OPERAND (name
, 0);
3884 /* Namespace-scoped variables are not found in the current level. */
3885 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
))
3886 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3888 t
= lookup_name_current_level (name
);
3889 if (t
== error_mark_node
)
3891 /* error_mark_node is 0 for a while during initialization! */
3893 cp_error_at ("`%#D' used prior to declaration", x
);
3896 else if (t
!= NULL_TREE
)
3899 /* This is turned off until I have time to do it right (bpk). */
3900 /* With the code below that uses it... */
3901 file
= DECL_SOURCE_FILE (t
);
3902 line
= DECL_SOURCE_LINE (t
);
3904 if (TREE_CODE (t
) == PARM_DECL
)
3906 if (DECL_CONTEXT (t
) == NULL_TREE
)
3907 fatal ("parse errors have confused me too much");
3909 /* Check for duplicate params. */
3910 if (duplicate_decls (x
, t
))
3913 else if (((TREE_CODE (x
) == FUNCTION_DECL
&& DECL_LANGUAGE (x
) == lang_c
)
3914 || DECL_FUNCTION_TEMPLATE_P (x
))
3915 && is_overloaded_fn (t
))
3916 /* Don't do anything just yet. */;
3917 else if (t
== wchar_decl_node
)
3919 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3920 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3922 /* Throw away the redeclaration. */
3925 else if (TREE_CODE (t
) != TREE_CODE (x
))
3927 if (duplicate_decls (x
, t
))
3930 else if (duplicate_decls (x
, t
))
3933 /* This is turned off until I have time to do it right (bpk). */
3935 /* Also warn if they did a prototype with `static' on it, but
3936 then later left the `static' off. */
3937 if (! TREE_PUBLIC (name
) && TREE_PUBLIC (x
))
3939 if (DECL_LANG_SPECIFIC (t
) && DECL_FRIEND_P (t
))
3944 cp_warning ("`static' missing from declaration of `%D'",
3946 warning_with_file_and_line (file
, line
,
3947 "previous declaration of `%s'",
3948 decl_as_string (t
, 0));
3951 /* Now fix things so it'll do what they expect. */
3952 if (current_function_decl
)
3953 TREE_PUBLIC (current_function_decl
) = 0;
3955 /* Due to interference in memory reclamation (X may be
3956 obstack-deallocated at this point), we must guard against
3957 one really special case. [jason: This should be handled
3958 by start_function] */
3959 if (current_function_decl
== x
)
3960 current_function_decl
= t
;
3962 if (TREE_CODE (t
) == TYPE_DECL
)
3963 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3964 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3965 check_default_args (t
);
3969 else if (DECL_MAIN_P (x
))
3971 /* A redeclaration of main, but not a duplicate of the
3976 This function shall not be overloaded. */
3977 cp_error_at ("invalid redeclaration of `%D'", t
);
3978 cp_error ("as `%D'", x
);
3979 /* We don't try to push this declaration since that
3985 check_template_shadow (x
);
3987 /* If this is a function conjured up by the backend, massage it
3988 so it looks friendly. */
3989 if (TREE_CODE (x
) == FUNCTION_DECL
3990 && ! DECL_LANG_SPECIFIC (x
))
3992 retrofit_lang_decl (x
);
3993 DECL_LANGUAGE (x
) = lang_c
;
3996 if (TREE_CODE (x
) == FUNCTION_DECL
&& ! DECL_FUNCTION_MEMBER_P (x
))
3998 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
3999 if (t
!= x
|| DECL_LANGUAGE (x
) == lang_c
)
4001 if (!namespace_bindings_p ())
4002 /* We do not need to create a binding for this name;
4003 push_overloaded_decl will have already done so if
4005 need_new_binding
= 0;
4007 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
4009 t
= push_overloaded_decl (x
, PUSH_GLOBAL
);
4011 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
4015 /* If declaring a type as a typedef, copy the type (unless we're
4016 at line 0), and install this TYPE_DECL as the new type's typedef
4017 name. See the extensive comment in ../c-decl.c (pushdecl). */
4018 if (TREE_CODE (x
) == TYPE_DECL
)
4020 tree type
= TREE_TYPE (x
);
4021 if (DECL_SOURCE_LINE (x
) == 0)
4023 if (TYPE_NAME (type
) == 0)
4024 TYPE_NAME (type
) = x
;
4026 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
4027 /* We don't want to copy the type when all we're
4028 doing is making a TYPE_DECL for the purposes of
4030 && (!TYPE_NAME (type
)
4031 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
4033 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
4035 DECL_ORIGINAL_TYPE (x
) = type
;
4036 type
= build_type_copy (type
);
4037 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
4038 TYPE_NAME (type
) = x
;
4039 TREE_TYPE (x
) = type
;
4044 if (type
!= error_mark_node
4046 && TYPE_IDENTIFIER (type
))
4047 set_identifier_type_value_with_scope (DECL_NAME (x
), type
,
4048 current_binding_level
);
4052 /* Multiple external decls of the same identifier ought to match.
4054 We get warnings about inline functions where they are defined.
4055 We get warnings about other functions from push_overloaded_decl.
4057 Avoid duplicate warnings where they are used. */
4058 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
4062 if (IDENTIFIER_NAMESPACE_VALUE (name
) != NULL_TREE
4063 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name
))
4064 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name
))))
4065 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
4070 /* If different sort of thing, we already gave an error. */
4071 && TREE_CODE (decl
) == TREE_CODE (x
)
4072 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
4074 cp_pedwarn ("type mismatch with previous external decl", x
);
4075 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
4079 /* This name is new in its binding level.
4080 Install the new declaration and return it. */
4081 if (namespace_bindings_p ())
4083 /* Install a global value. */
4085 /* If the first global decl has external linkage,
4086 warn if we later see static one. */
4087 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
4088 TREE_PUBLIC (name
) = 1;
4090 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
4093 if (TREE_CODE (x
) == FUNCTION_DECL
)
4095 ((IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
)
4096 || (IDENTIFIER_GLOBAL_VALUE (name
) == x
), 378);
4097 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
4100 /* Don't forget if the function was used via an implicit decl. */
4101 if (IDENTIFIER_IMPLICIT_DECL (name
)
4102 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
4105 /* Don't forget if its address was taken in that way. */
4106 if (IDENTIFIER_IMPLICIT_DECL (name
)
4107 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
4108 TREE_ADDRESSABLE (x
) = 1;
4110 /* Warn about mismatches against previous implicit decl. */
4111 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
4112 /* If this real decl matches the implicit, don't complain. */
4113 && ! (TREE_CODE (x
) == FUNCTION_DECL
4114 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
4116 ("`%D' was previously implicitly declared to return `int'", x
);
4118 /* If new decl is `static' and an `extern' was seen previously,
4120 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
4121 warn_extern_redeclared_static (x
, t
);
4125 /* Here to install a non-global value. */
4126 tree oldlocal
= IDENTIFIER_VALUE (name
);
4127 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
4129 if (need_new_binding
)
4131 push_local_binding (name
, x
, 0);
4132 /* Because push_local_binding will hook X on to the
4133 current_binding_level's name list, we don't want to
4134 do that again below. */
4135 need_new_binding
= 0;
4138 /* If this is a TYPE_DECL, push it into the type value slot. */
4139 if (TREE_CODE (x
) == TYPE_DECL
)
4140 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
),
4141 current_binding_level
);
4143 /* Clear out any TYPE_DECL shadowed by a namespace so that
4144 we won't think this is a type. The C struct hack doesn't
4145 go through namespaces. */
4146 if (TREE_CODE (x
) == NAMESPACE_DECL
)
4147 set_identifier_type_value_with_scope (name
, NULL_TREE
,
4148 current_binding_level
);
4150 /* If this is an extern function declaration, see if we
4151 have a global definition or declaration for the function. */
4152 if (oldlocal
== NULL_TREE
4153 && DECL_EXTERNAL (x
)
4154 && oldglobal
!= NULL_TREE
4155 && TREE_CODE (x
) == FUNCTION_DECL
4156 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
4158 /* We have one. Their types must agree. */
4159 if (decls_match (x
, oldglobal
))
4163 cp_warning ("extern declaration of `%#D' doesn't match", x
);
4164 cp_warning_at ("global declaration `%#D'", oldglobal
);
4167 /* If we have a local external declaration,
4168 and no file-scope declaration has yet been seen,
4169 then if we later have a file-scope decl it must not be static. */
4170 if (oldlocal
== NULL_TREE
4171 && oldglobal
== NULL_TREE
4172 && DECL_EXTERNAL (x
)
4174 TREE_PUBLIC (name
) = 1;
4176 if (DECL_FROM_INLINE (x
))
4177 /* Inline decls shadow nothing. */;
4179 /* Warn if shadowing an argument at the top level of the body. */
4180 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
4181 && TREE_CODE (oldlocal
) == PARM_DECL
4182 /* Don't complain if it's from an enclosing function. */
4183 && DECL_CONTEXT (oldlocal
) == current_function_decl
4184 && TREE_CODE (x
) != PARM_DECL
)
4186 /* Go to where the parms should be and see if we
4188 struct binding_level
*b
= current_binding_level
->level_chain
;
4194 if (b
->parm_flag
== 1)
4195 cp_error ("declaration of `%#D' shadows a parameter", name
);
4197 else if (warn_shadow
&& oldlocal
!= NULL_TREE
4198 && current_binding_level
->is_for_scope
4199 && !DECL_DEAD_FOR_LOCAL (oldlocal
))
4201 warning ("variable `%s' shadows local",
4202 IDENTIFIER_POINTER (name
));
4203 cp_warning_at (" this is the shadowed declaration", oldlocal
);
4205 /* Maybe warn if shadowing something else. */
4206 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
4207 /* No shadow warnings for internally generated vars. */
4208 && ! DECL_ARTIFICIAL (x
)
4209 /* No shadow warnings for vars made for inlining. */
4210 && ! DECL_FROM_INLINE (x
))
4212 const char *warnstring
= NULL
;
4214 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
4215 warnstring
= "declaration of `%s' shadows a parameter";
4216 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
4217 && current_class_ptr
4218 && !TREE_STATIC (name
))
4219 warnstring
= "declaration of `%s' shadows a member of `this'";
4220 else if (oldlocal
!= NULL_TREE
)
4221 warnstring
= "declaration of `%s' shadows previous local";
4222 else if (oldglobal
!= NULL_TREE
)
4223 /* XXX shadow warnings in outer-more namespaces */
4224 warnstring
= "declaration of `%s' shadows global declaration";
4227 warning (warnstring
, IDENTIFIER_POINTER (name
));
4231 if (TREE_CODE (x
) == FUNCTION_DECL
)
4232 check_default_args (x
);
4234 /* Keep count of variables in this level with incomplete type. */
4235 if (TREE_CODE (x
) == VAR_DECL
4236 && TREE_TYPE (x
) != error_mark_node
4237 && ((TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
4238 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
4239 /* RTTI TD entries are created while defining the type_info. */
4240 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
4241 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
4242 current_binding_level
->incomplete
4243 = tree_cons (NULL_TREE
, x
, current_binding_level
->incomplete
);
4246 if (need_new_binding
)
4247 add_decl_to_level (x
, current_binding_level
);
4252 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4253 caller to set DECL_CONTEXT properly. */
4256 pushdecl_with_scope (x
, level
)
4258 struct binding_level
*level
;
4260 register struct binding_level
*b
;
4261 tree function_decl
= current_function_decl
;
4263 current_function_decl
= NULL_TREE
;
4264 if (level
->parm_flag
== 2)
4266 b
= class_binding_level
;
4267 class_binding_level
= level
;
4268 pushdecl_class_level (x
);
4269 class_binding_level
= b
;
4273 b
= current_binding_level
;
4274 current_binding_level
= level
;
4276 current_binding_level
= b
;
4278 current_function_decl
= function_decl
;
4282 /* Like pushdecl, only it places X in the current namespace,
4286 pushdecl_namespace_level (x
)
4289 register struct binding_level
*b
= current_binding_level
;
4292 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
4294 /* Now, the type_shadowed stack may screw us. Munge it so it does
4296 if (TREE_CODE (x
) == TYPE_DECL
)
4298 tree name
= DECL_NAME (x
);
4300 tree
*ptr
= (tree
*)0;
4301 for (; b
!= global_binding_level
; b
= b
->level_chain
)
4303 tree shadowed
= b
->type_shadowed
;
4304 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
4305 if (TREE_PURPOSE (shadowed
) == name
)
4307 ptr
= &TREE_VALUE (shadowed
);
4308 /* Can't break out of the loop here because sometimes
4309 a binding level will have duplicate bindings for
4310 PT names. It's gross, but I haven't time to fix it. */
4313 newval
= TREE_TYPE (x
);
4314 if (ptr
== (tree
*)0)
4316 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4317 up here if this is changed to an assertion. --KR */
4318 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
4328 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4332 pushdecl_top_level (x
)
4335 tree cur_namespace
= current_namespace
;
4336 current_namespace
= global_namespace
;
4337 x
= pushdecl_namespace_level (x
);
4338 current_namespace
= cur_namespace
;
4342 /* Make the declaration of X appear in CLASS scope. */
4345 pushdecl_class_level (x
)
4348 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4349 scope looks for the pre-mangled name. */
4352 if (TREE_CODE (x
) == OVERLOAD
)
4353 x
= OVL_CURRENT (x
);
4354 name
= DECL_NAME (x
);
4358 push_class_level_binding (name
, x
);
4359 if (TREE_CODE (x
) == TYPE_DECL
)
4360 set_identifier_type_value (name
, TREE_TYPE (x
));
4362 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4366 for (f
= TYPE_FIELDS (TREE_TYPE (x
));
4369 pushdecl_class_level (f
);
4373 /* Enter DECL into the symbol table, if that's appropriate. Returns
4374 DECL, or a modified version thereof. */
4377 maybe_push_decl (decl
)
4380 tree type
= TREE_TYPE (decl
);
4382 /* Add this decl to the current binding level, but not if it comes
4383 from another scope, e.g. a static member variable. TEM may equal
4384 DECL or it may be a previous decl of the same name. */
4385 if ((TREE_CODE (decl
) != PARM_DECL
4386 && DECL_CONTEXT (decl
) != NULL_TREE
4387 /* Definitions of namespace members outside their namespace are
4389 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4390 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
4391 || TREE_CODE (type
) == UNKNOWN_TYPE
4392 /* The declaration of a template specialization does not affect
4393 the functions available for overload resolution, so we do not
4395 || (TREE_CODE (decl
) == FUNCTION_DECL
4396 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
4399 return pushdecl (decl
);
4403 /* This function is used to push the mangled decls for nested types into
4404 the appropriate scope. Previously pushdecl_top_level was used, but that
4405 is incorrect for members of local classes. */
4408 pushdecl_nonclass_level (x
)
4411 struct binding_level
*b
= current_binding_level
;
4413 my_friendly_assert (b
->parm_flag
!= 2, 180);
4416 /* Get out of template binding levels */
4417 while (b
->pseudo_global
)
4421 pushdecl_with_scope (x
, b
);
4425 /* Make the declaration(s) of X appear in CLASS scope
4426 under the name NAME. */
4429 push_class_level_binding (name
, x
)
4434 /* The class_binding_level will be NULL if x is a template
4435 parameter name in a member template. */
4436 if (!class_binding_level
)
4439 /* Make sure that this new member does not have the same name
4440 as a template parameter. */
4441 if (TYPE_BEING_DEFINED (current_class_type
))
4442 check_template_shadow (x
);
4444 /* If this declaration shadows a declaration from an enclosing
4445 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4446 we leave this class. Record the shadowed declaration here. */
4447 binding
= IDENTIFIER_BINDING (name
);
4449 && ((TREE_CODE (x
) == OVERLOAD
4450 && BINDING_VALUE (binding
)
4451 && is_overloaded_fn (BINDING_VALUE (binding
)))
4452 || INHERITED_VALUE_BINDING_P (binding
)))
4457 /* If the old binding was from a base class, and was for a tag
4458 name, slide it over to make room for the new binding. The
4459 old binding is still visible if explicitly qualified with a
4461 if (INHERITED_VALUE_BINDING_P (binding
)
4462 && BINDING_VALUE (binding
)
4463 && TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
4464 && DECL_ARTIFICIAL (BINDING_VALUE (binding
))
4465 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
4467 old_decl
= BINDING_TYPE (binding
);
4468 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
4469 BINDING_VALUE (binding
) = NULL_TREE
;
4470 INHERITED_VALUE_BINDING_P (binding
) = 0;
4473 old_decl
= BINDING_VALUE (binding
);
4475 /* There was already a binding for X containing fewer
4476 functions than are named in X. Find the previous
4477 declaration of X on the class-shadowed list, and update it. */
4478 for (shadow
= class_binding_level
->class_shadowed
;
4480 shadow
= TREE_CHAIN (shadow
))
4481 if (TREE_PURPOSE (shadow
) == name
4482 && TREE_TYPE (shadow
) == old_decl
)
4484 BINDING_VALUE (binding
) = x
;
4485 INHERITED_VALUE_BINDING_P (binding
) = 0;
4486 TREE_TYPE (shadow
) = x
;
4491 /* If we didn't replace an existing binding, put the binding on the
4492 stack of bindings for the identifier, and update
4493 IDENTIFIER_CLASS_VALUE. */
4494 if (push_class_binding (name
, x
))
4496 push_cache_obstack ();
4497 class_binding_level
->class_shadowed
4498 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
4499 class_binding_level
->class_shadowed
);
4501 /* Record the value we are binding NAME to so that we can know
4502 what to pop later. */
4503 TREE_TYPE (class_binding_level
->class_shadowed
) = x
;
4507 /* Insert another USING_DECL into the current binding level,
4508 returning this declaration. If this is a redeclaration,
4509 do nothing and return NULL_TREE. */
4512 push_using_decl (scope
, name
)
4518 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
4519 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
4520 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
4521 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
4525 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
4526 DECL_INITIAL (decl
) = scope
;
4527 TREE_CHAIN (decl
) = current_binding_level
->usings
;
4528 current_binding_level
->usings
= decl
;
4532 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4533 changed (i.e. there was already a directive), or the fresh
4534 TREE_LIST otherwise. */
4537 push_using_directive (used
)
4540 tree ud
= current_binding_level
->using_directives
;
4541 tree iter
, ancestor
;
4543 /* Check if we already have this. */
4544 if (purpose_member (used
, ud
) != NULL_TREE
)
4547 /* Recursively add all namespaces used. */
4548 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4549 push_using_directive (TREE_PURPOSE (iter
));
4551 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4552 ud
= current_binding_level
->using_directives
;
4553 ud
= perm_tree_cons (used
, ancestor
, ud
);
4554 current_binding_level
->using_directives
= ud
;
4558 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4559 other definitions already in place. We get around this by making
4560 the value of the identifier point to a list of all the things that
4561 want to be referenced by that name. It is then up to the users of
4562 that name to decide what to do with that list.
4564 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4565 slot. It is dealt with the same way.
4567 FLAGS is a bitwise-or of the following values:
4568 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4570 PUSH_USING: DECL is being pushed as the result of a using
4573 The value returned may be a previous declaration if we guessed wrong
4574 about what language DECL should belong to (C or C++). Otherwise,
4575 it's always DECL (and never something that's not a _DECL). */
4578 push_overloaded_decl (decl
, flags
)
4582 tree name
= DECL_NAME (decl
);
4585 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
4588 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
4590 old
= lookup_name_current_level (name
);
4594 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4596 tree t
= TREE_TYPE (old
);
4597 if (IS_AGGR_TYPE (t
) && warn_shadow
4598 && (! DECL_IN_SYSTEM_HEADER (decl
)
4599 || ! DECL_IN_SYSTEM_HEADER (old
)))
4600 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4603 else if (is_overloaded_fn (old
))
4607 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4609 tree fn
= OVL_CURRENT (tmp
);
4611 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
4612 && !(flags
& PUSH_USING
)
4613 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
4614 TYPE_ARG_TYPES (TREE_TYPE (decl
))))
4615 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4618 if (duplicate_decls (decl
, fn
))
4624 cp_error_at ("previous non-function declaration `%#D'", old
);
4625 cp_error ("conflicts with function declaration `%#D'", decl
);
4630 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4632 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4633 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
4635 new_binding
= ovl_cons (decl
, old
);
4636 if (flags
& PUSH_USING
)
4637 OVL_USED (new_binding
) = 1;
4640 /* NAME is not ambiguous. */
4644 set_namespace_binding (name
, current_namespace
, new_binding
);
4647 /* We only create an OVERLOAD if there was a previous binding at
4648 this level, or if decl is a template. In the former case, we
4649 need to remove the old binding and replace it with the new
4650 binding. We must also run through the NAMES on the binding
4651 level where the name was bound to update the chain. */
4653 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
4657 for (d
= &BINDING_LEVEL (IDENTIFIER_BINDING (name
))->names
;
4659 d
= &TREE_CHAIN (*d
))
4661 || (TREE_CODE (*d
) == TREE_LIST
4662 && TREE_VALUE (*d
) == old
))
4664 if (TREE_CODE (*d
) == TREE_LIST
)
4665 /* Just replace the old binding with the new. */
4666 TREE_VALUE (*d
) = new_binding
;
4668 /* Build a TREE_LIST to wrap the OVERLOAD. */
4669 *d
= build_tree_list (NULL_TREE
, new_binding
);
4671 /* And update the CPLUS_BINDING node. */
4672 BINDING_VALUE (IDENTIFIER_BINDING (name
))
4677 /* We should always find a previous binding in this case. */
4678 my_friendly_abort (0);
4681 /* Install the new binding. */
4682 push_local_binding (name
, new_binding
, flags
);
4688 /* Generate an implicit declaration for identifier FUNCTIONID
4689 as a function of type int (). Print a warning if appropriate. */
4692 implicitly_declare (functionid
)
4696 int temp
= allocation_temporary_p ();
4698 push_obstacks_nochange ();
4700 /* Save the decl permanently so we can warn if definition follows.
4701 In ANSI C, warn_implicit is usually false, so the saves little space.
4702 But in C++, it's usually true, hence the extra code. */
4703 if (temp
&& (! warn_implicit
|| toplevel_bindings_p ()))
4704 end_temporary_allocation ();
4706 /* We used to reuse an old implicit decl here,
4707 but this loses with inline functions because it can clobber
4708 the saved decl chains. */
4709 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4711 DECL_EXTERNAL (decl
) = 1;
4712 TREE_PUBLIC (decl
) = 1;
4714 /* ANSI standard says implicit declarations are in the innermost block.
4715 So we record the decl in the standard fashion. */
4717 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4720 /* Only one warning per identifier. */
4721 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4723 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4726 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4733 /* Return zero if the declaration NEWDECL is valid
4734 when the declaration OLDDECL (assumed to be for the same name)
4735 has already been seen.
4736 Otherwise return an error message format string with a %s
4737 where the identifier should go. */
4740 redeclaration_error_message (newdecl
, olddecl
)
4741 tree newdecl
, olddecl
;
4743 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4745 /* Because C++ can put things into name space for free,
4746 constructs like "typedef struct foo { ... } foo"
4747 would look like an erroneous redeclaration. */
4748 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
4751 return "redefinition of `%#D'";
4753 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4755 /* If this is a pure function, its olddecl will actually be
4756 the original initialization to `0' (which we force to call
4757 abort()). Don't complain about redefinition in this case. */
4758 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_ABSTRACT_VIRTUAL_P (olddecl
))
4761 /* If both functions come from different namespaces, this is not
4762 a redeclaration - this is a conflict with a used function. */
4763 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4764 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4765 return "`%D' conflicts with used function";
4767 /* We'll complain about linkage mismatches in
4768 warn_extern_redeclared_static. */
4770 /* Defining the same name twice is no good. */
4771 if (DECL_INITIAL (olddecl
) != NULL_TREE
4772 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4774 if (DECL_NAME (olddecl
) == NULL_TREE
)
4775 return "`%#D' not declared in class";
4777 return "redefinition of `%#D'";
4781 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4783 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4784 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4785 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4786 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4787 && TYPE_SIZE (TREE_TYPE (newdecl
))
4788 && TYPE_SIZE (TREE_TYPE (olddecl
))))
4789 return "redefinition of `%#D'";
4792 else if (toplevel_bindings_p ())
4794 /* Objects declared at top level: */
4795 /* If at least one is a reference, it's ok. */
4796 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4798 /* Reject two definitions. */
4799 return "redefinition of `%#D'";
4803 /* Objects declared with block scope: */
4804 /* Reject two definitions, and reject a definition
4805 together with an external reference. */
4806 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4807 return "redeclaration of `%#D'";
4812 /* Create a new label, named ID. */
4815 make_label_decl (id
, local_p
)
4821 if (building_stmt_tree ())
4822 push_permanent_obstack ();
4823 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4824 if (building_stmt_tree ())
4827 /* Make sure every label has an rtx. */
4830 DECL_CONTEXT (decl
) = current_function_decl
;
4831 DECL_MODE (decl
) = VOIDmode
;
4832 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
4834 /* Say where one reference is to the label, for the sake of the
4835 error if it is not defined. */
4836 DECL_SOURCE_LINE (decl
) = lineno
;
4837 DECL_SOURCE_FILE (decl
) = input_filename
;
4839 /* Record the fact that this identifier is bound to this label. */
4840 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4842 /* Record this label on the list of used labels so that we can check
4843 at the end of the function to see whether or not the label was
4844 actually defined. */
4845 if ((named_label_uses
== NULL
|| named_label_uses
->label_decl
!= decl
)
4846 && (named_label_uses
== NULL
4847 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4848 || named_label_uses
->label_decl
!= decl
))
4850 struct named_label_list
*new_ent
;
4852 = (struct named_label_list
*)oballoc (sizeof (struct named_label_list
));
4853 new_ent
->label_decl
= decl
;
4854 new_ent
->names_in_scope
= current_binding_level
->names
;
4855 new_ent
->binding_level
= current_binding_level
;
4856 new_ent
->lineno_o_goto
= lineno
;
4857 new_ent
->filename_o_goto
= input_filename
;
4858 new_ent
->next
= named_label_uses
;
4859 named_label_uses
= new_ent
;
4865 /* Look for a label named ID in the current function. If one cannot
4866 be found, create one. (We keep track of used, but undefined,
4867 labels, and complain about them at the end of a function.) */
4875 /* You can't use labels at global scope. */
4876 if (current_function_decl
== NULL_TREE
)
4878 error ("label `%s' referenced outside of any function",
4879 IDENTIFIER_POINTER (id
));
4883 /* See if we've already got this label. */
4884 decl
= IDENTIFIER_LABEL_VALUE (id
);
4885 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
4888 /* Record this label on the list of labels used in this function.
4889 We do this before calling make_label_decl so that we get the
4890 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4891 named_labels
= tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
4893 /* We need a new label. */
4894 decl
= make_label_decl (id
, /*local_p=*/0);
4895 /* Now fill in the information we didn't have before. */
4896 TREE_VALUE (named_labels
) = decl
;
4901 /* Declare a local label named ID. */
4904 declare_local_label (id
)
4909 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4910 this scope we can restore the old value of
4911 IDENTIFIER_TYPE_VALUE. */
4912 current_binding_level
->shadowed_labels
4913 = tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
4914 current_binding_level
->shadowed_labels
);
4915 /* Look for the label. */
4916 decl
= make_label_decl (id
, /*local_p=*/1);
4917 /* Now fill in the information we didn't have before. */
4918 TREE_VALUE (current_binding_level
->shadowed_labels
) = decl
;
4923 /* Define a label, specifying the location in the source file.
4924 Return the LABEL_DECL node for the label, if the definition is valid.
4925 Otherwise return 0. */
4928 define_label (filename
, line
, name
)
4933 tree decl
= lookup_label (name
);
4935 /* After labels, make any new cleanups go into their
4936 own new (temporary) binding contour. */
4937 current_binding_level
->more_cleanups_ok
= 0;
4939 if (name
== get_identifier ("wchar_t"))
4940 cp_pedwarn ("label named wchar_t");
4942 if (DECL_INITIAL (decl
) != NULL_TREE
)
4944 cp_error ("duplicate label `%D'", decl
);
4949 struct named_label_list
*uses
, *prev
;
4953 /* Mark label as having been defined. */
4954 DECL_INITIAL (decl
) = error_mark_node
;
4955 /* Say where in the source. */
4956 DECL_SOURCE_FILE (decl
) = filename
;
4957 DECL_SOURCE_LINE (decl
) = line
;
4960 uses
= named_label_uses
;
4961 while (uses
!= NULL
)
4962 if (uses
->label_decl
== decl
)
4964 struct binding_level
*b
= current_binding_level
;
4967 tree new_decls
= b
->names
;
4968 tree old_decls
= (b
== uses
->binding_level
)
4969 ? uses
->names_in_scope
: NULL_TREE
;
4970 while (new_decls
!= old_decls
)
4972 if (TREE_CODE (new_decls
) == VAR_DECL
4973 /* Don't complain about crossing initialization
4974 of internal entities. They can't be accessed,
4975 and they should be cleaned up
4976 by the time we get to the label. */
4977 && ! DECL_ARTIFICIAL (new_decls
)
4978 && !(DECL_INITIAL (new_decls
) == NULL_TREE
4979 && pod_type_p (TREE_TYPE (new_decls
))))
4981 /* This is really only important if we're crossing
4982 an initialization. The POD stuff is just
4983 pedantry; why should it matter if the class
4984 contains a field of pointer to member type? */
4985 int problem
= (DECL_INITIAL (new_decls
)
4986 || (TYPE_NEEDS_CONSTRUCTING
4987 (TREE_TYPE (new_decls
))));
4993 cp_error ("jump to label `%D'", decl
);
4994 error_with_file_and_line
4995 (uses
->filename_o_goto
,
4996 uses
->lineno_o_goto
, " from here");
5000 cp_pedwarn ("jump to label `%D'", decl
);
5001 pedwarn_with_file_and_line
5002 (uses
->filename_o_goto
,
5003 uses
->lineno_o_goto
, " from here");
5009 cp_error_at (" crosses initialization of `%#D'",
5012 cp_pedwarn_at (" enters scope of non-POD `%#D'",
5015 new_decls
= TREE_CHAIN (new_decls
);
5017 if (b
== uses
->binding_level
)
5019 if (b
->eh_region
&& ! saw_eh
)
5023 cp_error ("jump to label `%D'", decl
);
5024 error_with_file_and_line
5025 (uses
->filename_o_goto
,
5026 uses
->lineno_o_goto
, " from here");
5029 error (" enters exception handling block");
5036 prev
->next
= uses
->next
;
5038 named_label_uses
= uses
->next
;
5047 current_function_return_value
= NULL_TREE
;
5054 struct binding_level
*level
;
5055 struct cp_switch
*next
;
5058 static struct cp_switch
*switch_stack
;
5064 = (struct cp_switch
*) oballoc (sizeof (struct cp_switch
));
5065 p
->level
= current_binding_level
;
5066 p
->next
= switch_stack
;
5073 switch_stack
= switch_stack
->next
;
5076 /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
5077 /* XXX Note decl is never actually used. (bpk) */
5080 define_case_label ()
5082 tree cleanup
= last_cleanup_this_contour ();
5083 struct binding_level
*b
= current_binding_level
;
5088 static int explained
= 0;
5089 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup
));
5090 warning ("where case label appears here");
5093 warning ("(enclose actions of previous case statements requiring");
5094 warning ("destructors in their own binding contours.)");
5099 for (; b
&& b
!= switch_stack
->level
; b
= b
->level_chain
)
5101 tree new_decls
= b
->names
;
5102 for (; new_decls
; new_decls
= TREE_CHAIN (new_decls
))
5104 if (TREE_CODE (new_decls
) == VAR_DECL
5105 /* Don't complain about crossing initialization
5106 of internal entities. They can't be accessed,
5107 and they should be cleaned up
5108 by the time we get to the label. */
5109 && ! DECL_ARTIFICIAL (new_decls
)
5110 && ((DECL_INITIAL (new_decls
) != NULL_TREE
5111 && DECL_INITIAL (new_decls
) != error_mark_node
)
5112 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
5115 error ("jump to case label");
5117 cp_error_at (" crosses initialization of `%#D'",
5123 /* After labels, make any new cleanups go into their
5124 own new (temporary) binding contour. */
5126 current_binding_level
->more_cleanups_ok
= 0;
5127 current_function_return_value
= NULL_TREE
;
5130 /* Return the list of declarations of the current level.
5131 Note that this list is in reverse order unless/until
5132 you nreverse it; and when you do nreverse it, you must
5133 store the result back using `storedecls' or you will lose. */
5138 return current_binding_level
->names
;
5141 /* Return the list of type-tags (for structs, etc) of the current level. */
5146 return current_binding_level
->tags
;
5149 /* Store the list of declarations of the current level.
5150 This is done for the parameter declarations of a function being defined,
5151 after they are modified in the light of any missing parameters. */
5157 current_binding_level
->names
= decls
;
5160 /* Similarly, store the list of tags of the current level. */
5166 current_binding_level
->tags
= tags
;
5169 /* Given NAME, an IDENTIFIER_NODE,
5170 return the structure (or union or enum) definition for that name.
5171 Searches binding levels from BINDING_LEVEL up to the global level.
5172 If THISLEVEL_ONLY is nonzero, searches only the specified context
5173 (but skips any tag-transparent contexts to find one that is
5174 meaningful for tags).
5175 FORM says which kind of type the caller wants;
5176 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5177 If the wrong kind of type is found, and it's not a template, an error is
5181 lookup_tag (form
, name
, binding_level
, thislevel_only
)
5182 enum tree_code form
;
5184 struct binding_level
*binding_level
;
5187 register struct binding_level
*level
;
5188 /* Non-zero if, we should look past a pseudo-global level, even if
5190 int allow_pseudo_global
= 1;
5192 for (level
= binding_level
; level
; level
= level
->level_chain
)
5195 if (ANON_AGGRNAME_P (name
))
5196 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5198 /* There's no need for error checking here, because
5199 anon names are unique throughout the compilation. */
5200 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
5201 return TREE_VALUE (tail
);
5203 else if (level
->namespace_p
)
5204 /* Do namespace lookup. */
5205 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
5207 tree old
= binding_for_name (name
, tail
);
5209 /* If we just skipped past a pseudo global level, even
5210 though THISLEVEL_ONLY, and we find a template class
5211 declaration, then we use the _TYPE node for the
5212 template. See the example below. */
5213 if (thislevel_only
&& !allow_pseudo_global
5214 && old
&& BINDING_VALUE (old
)
5215 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
5216 old
= TREE_TYPE (BINDING_VALUE (old
));
5218 old
= BINDING_TYPE (old
);
5220 /* If it has an original type, it is a typedef, and we
5221 should not return it. */
5222 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
5224 if (old
&& TREE_CODE (old
) != form
5225 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
5227 cp_error ("`%#D' redeclared as %C", old
, form
);
5232 if (thislevel_only
|| tail
== global_namespace
)
5236 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5238 if (TREE_PURPOSE (tail
) == name
)
5240 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
5241 /* Should tighten this up; it'll probably permit
5242 UNION_TYPE and a struct template, for example. */
5244 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
5246 /* Definition isn't the kind we were looking for. */
5247 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
5251 return TREE_VALUE (tail
);
5254 if (thislevel_only
&& ! level
->tag_transparent
)
5256 if (level
->pseudo_global
&& allow_pseudo_global
)
5258 /* We must deal with cases like this:
5260 template <class T> struct S;
5261 template <class T> struct S {};
5263 When looking up `S', for the second declaration, we
5264 would like to find the first declaration. But, we
5265 are in the pseudo-global level created for the
5266 template parameters, rather than the (surrounding)
5267 namespace level. Thus, we keep going one more level,
5268 even though THISLEVEL_ONLY is non-zero. */
5269 allow_pseudo_global
= 0;
5281 set_current_level_tags_transparency (tags_transparent
)
5282 int tags_transparent
;
5284 current_binding_level
->tag_transparent
= tags_transparent
;
5288 /* Given a type, find the tag that was defined for it and return the tag name.
5289 Otherwise return 0. However, the value can never be 0
5290 in the cases in which this is used.
5292 C++: If NAME is non-zero, this is the new name to install. This is
5293 done when replacing anonymous tags with real tag names. */
5296 lookup_tag_reverse (type
, name
)
5300 register struct binding_level
*level
;
5302 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
5305 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5307 if (TREE_VALUE (tail
) == type
)
5310 TREE_PURPOSE (tail
) = name
;
5311 return TREE_PURPOSE (tail
);
5318 /* Look up NAME in the NAMESPACE. */
5321 lookup_namespace_name (namespace, name
)
5322 tree
namespace, name
;
5324 struct tree_binding _b
;
5326 tree template_id
= NULL_TREE
;
5328 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
5330 if (TREE_CODE (name
) == NAMESPACE_DECL
)
5331 /* This happens for A::B<int> when B is a namespace. */
5333 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
5335 /* This happens for A::B where B is a template, and there are no
5336 template arguments. */
5337 cp_error ("invalid use of `%D'", name
);
5338 return error_mark_node
;
5341 namespace = ORIGINAL_NAMESPACE (namespace);
5343 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5346 name
= TREE_OPERAND (name
, 0);
5347 if (TREE_CODE (name
) == OVERLOAD
)
5348 name
= DECL_NAME (OVL_CURRENT (name
));
5349 else if (TREE_CODE_CLASS (TREE_CODE (name
)) == 'd')
5350 name
= DECL_NAME (name
);
5353 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
5355 val
= binding_init (&_b
);
5356 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
5357 return error_mark_node
;
5359 if (BINDING_VALUE (val
))
5361 val
= BINDING_VALUE (val
);
5365 if (DECL_CLASS_TEMPLATE_P (val
))
5366 val
= lookup_template_class (val
,
5367 TREE_OPERAND (template_id
, 1),
5368 /*in_decl=*/NULL_TREE
,
5369 /*context=*/NULL_TREE
,
5370 /*entering_scope=*/0);
5371 else if (DECL_FUNCTION_TEMPLATE_P (val
)
5372 || TREE_CODE (val
) == OVERLOAD
)
5373 val
= lookup_template_function (val
,
5374 TREE_OPERAND (template_id
, 1));
5377 cp_error ("`%D::%D' is not a template",
5379 return error_mark_node
;
5383 /* If we have a single function from a using decl, pull it out. */
5384 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5385 val
= OVL_FUNCTION (val
);
5389 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
5390 return error_mark_node
;
5393 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5395 static unsigned long
5403 hash
= (((unsigned long) TYPE_CONTEXT (t
))
5404 ^ ((unsigned long) DECL_NAME (TYPE_NAME (t
))));
5409 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5412 typename_compare (k1
, k2
)
5423 d1
= TYPE_NAME (t1
);
5424 d2
= TYPE_NAME (t2
);
5426 return (DECL_NAME (d1
) == DECL_NAME (d2
)
5427 && same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
))
5428 && ((TREE_TYPE (t1
) != NULL_TREE
)
5429 == (TREE_TYPE (t2
) != NULL_TREE
))
5430 && same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
5431 && TYPENAME_TYPE_FULLNAME (t1
) == TYPENAME_TYPE_FULLNAME (t2
));
5434 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5435 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5436 is non-NULL, this type is being created by the implicit typename
5437 extension, and BASE_TYPE is a type named `t' in some base class of
5438 `T' which depends on template parameters.
5440 Returns the new TYPENAME_TYPE. */
5443 build_typename_type (context
, name
, fullname
, base_type
)
5451 struct hash_entry
* e
;
5453 static struct hash_table ht
;
5455 push_obstacks (&permanent_obstack
, &permanent_obstack
);
5458 && !hash_table_init (&ht
, &hash_newfunc
, &typename_hash
,
5460 fatal ("virtual memory exhausted");
5462 /* The FULLNAME needs to exist for the life of the hash table, i.e.,
5463 for the entire compilation. */
5464 if (!TREE_PERMANENT (fullname
))
5465 fullname
= copy_to_permanent (fullname
);
5467 /* Build the TYPENAME_TYPE. */
5468 t
= make_lang_type (TYPENAME_TYPE
);
5469 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5470 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
5471 TREE_TYPE (t
) = base_type
;
5473 /* Build the corresponding TYPE_DECL. */
5474 d
= build_decl (TYPE_DECL
, name
, t
);
5475 TYPE_NAME (TREE_TYPE (d
)) = d
;
5476 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
5477 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
5478 DECL_ARTIFICIAL (d
) = 1;
5480 /* See if we already have this type. */
5481 e
= hash_lookup (&ht
, t
, /*create=*/false, /*copy=*/0);
5484 /* This will free not only TREE_TYPE, but the lang-specific data
5485 and the TYPE_DECL as well. */
5486 obstack_free (&permanent_obstack
, t
);
5490 /* Insert the type into the table. */
5491 hash_lookup (&ht
, t
, /*create=*/true, /*copy=*/0);
5499 make_typename_type (context
, name
)
5504 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
5506 if (!(TYPE_LANG_SPECIFIC (name
)
5507 && (CLASSTYPE_IS_TEMPLATE (name
)
5508 || CLASSTYPE_USE_TEMPLATE (name
))))
5509 name
= TYPE_IDENTIFIER (name
);
5511 /* Create a TEMPLATE_ID_EXPR for the type. */
5512 name
= build_nt (TEMPLATE_ID_EXPR
,
5513 CLASSTYPE_TI_TEMPLATE (name
),
5514 CLASSTYPE_TI_ARGS (name
));
5516 else if (TREE_CODE (name
) == TYPE_DECL
)
5517 name
= DECL_NAME (name
);
5521 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5523 name
= TREE_OPERAND (name
, 0);
5524 if (TREE_CODE (name
) == TEMPLATE_DECL
)
5525 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
5527 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
5528 my_friendly_abort (2000);
5530 if (TREE_CODE (context
) == NAMESPACE_DECL
)
5532 /* We can get here from typename_sub0 in the explicit_template_type
5533 expansion. Just fail. */
5534 cp_error ("no class template named `%#T' in `%#T'",
5536 return error_mark_node
;
5539 if (! uses_template_parms (context
)
5540 || currently_open_class (context
))
5542 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
5544 tree tmpl
= NULL_TREE
;
5545 if (IS_AGGR_TYPE (context
))
5546 tmpl
= lookup_field (context
, name
, 0, 0);
5547 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
5549 cp_error ("no class template named `%#T' in `%#T'",
5551 return error_mark_node
;
5554 return lookup_template_class (tmpl
,
5555 TREE_OPERAND (fullname
, 1),
5557 /*entering_scope=*/0);
5563 if (!IS_AGGR_TYPE (context
))
5565 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5566 return error_mark_node
;
5569 t
= lookup_field (context
, name
, 0, 1);
5571 return TREE_TYPE (t
);
5575 /* If the CONTEXT is not a template type, then either the field is
5576 there now or its never going to be. */
5577 if (!uses_template_parms (context
))
5579 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5580 return error_mark_node
;
5584 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
5587 /* Select the right _DECL from multiple choices. */
5590 select_decl (binding
, flags
)
5595 val
= BINDING_VALUE (binding
);
5596 if (LOOKUP_NAMESPACES_ONLY (flags
))
5598 /* We are not interested in types. */
5599 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
5604 /* If we could have a type and
5605 we have nothing or we need a type and have none. */
5606 if (BINDING_TYPE (binding
)
5607 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
5608 && TREE_CODE (val
) != TYPE_DECL
)))
5609 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
5610 /* Don't return non-types if we really prefer types. */
5611 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
5612 && (TREE_CODE (val
) != TEMPLATE_DECL
5613 || !DECL_CLASS_TEMPLATE_P (val
)))
5619 /* Unscoped lookup of a global: iterate over current namespaces,
5620 considering using-directives. If SPACESP is non-NULL, store a list
5621 of the namespaces we've considered in it. */
5624 unqualified_namespace_lookup (name
, flags
, spacesp
)
5629 struct tree_binding _binding
;
5630 tree b
= binding_init (&_binding
);
5631 tree initial
= current_decl_namespace();
5632 tree scope
= initial
;
5634 struct binding_level
*level
;
5635 tree val
= NULL_TREE
;
5638 *spacesp
= NULL_TREE
;
5640 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
5643 *spacesp
= scratch_tree_cons (scope
, NULL_TREE
, *spacesp
);
5644 val
= binding_for_name (name
, scope
);
5646 /* Initialize binding for this context. */
5647 BINDING_VALUE (b
) = BINDING_VALUE (val
);
5648 BINDING_TYPE (b
) = BINDING_TYPE (val
);
5650 /* Add all _DECLs seen through local using-directives. */
5651 for (level
= current_binding_level
;
5652 !level
->namespace_p
;
5653 level
= level
->level_chain
)
5654 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
5655 scope
, flags
, spacesp
))
5656 /* Give up because of error. */
5657 return error_mark_node
;
5659 /* Add all _DECLs seen through global using-directives. */
5660 /* XXX local and global using lists should work equally. */
5664 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
5665 scope
, flags
, spacesp
))
5666 /* Give up because of error. */
5667 return error_mark_node
;
5668 if (siter
== scope
) break;
5669 siter
= CP_DECL_CONTEXT (siter
);
5672 val
= select_decl (b
, flags
);
5673 if (scope
== global_namespace
)
5679 /* Combine prefer_type and namespaces_only into flags. */
5682 lookup_flags (prefer_type
, namespaces_only
)
5683 int prefer_type
, namespaces_only
;
5685 if (namespaces_only
)
5686 return LOOKUP_PREFER_NAMESPACES
;
5687 if (prefer_type
> 1)
5688 return LOOKUP_PREFER_TYPES
;
5689 if (prefer_type
> 0)
5690 return LOOKUP_PREFER_BOTH
;
5694 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5695 ignore it or not. Subroutine of lookup_name_real. */
5698 qualify_lookup (val
, flags
)
5702 if (val
== NULL_TREE
)
5704 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5706 if ((flags
& LOOKUP_PREFER_TYPES
)
5707 && (TREE_CODE (val
) == TYPE_DECL
5708 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5709 && DECL_CLASS_TEMPLATE_P (val
))))
5711 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5716 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5720 warn_about_implicit_typename_lookup (typename
, binding
)
5724 tree subtype
= TREE_TYPE (TREE_TYPE (typename
));
5725 tree name
= DECL_NAME (typename
);
5727 if (! (TREE_CODE (binding
) == TEMPLATE_DECL
5728 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5729 && CLASSTYPE_TI_TEMPLATE (subtype
) == binding
)
5730 && ! (TREE_CODE (binding
) == TYPE_DECL
5731 && same_type_p (TREE_TYPE (binding
), subtype
)))
5733 cp_warning ("lookup of `%D' finds `%#D'",
5735 cp_warning (" instead of `%D' from dependent base class",
5737 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5738 constructor_name (current_class_type
), name
);
5742 /* Look up NAME in the current binding level and its superiors in the
5743 namespace of variables, functions and typedefs. Return a ..._DECL
5744 node of some kind representing its definition if there is only one
5745 such declaration, or return a TREE_LIST with all the overloaded
5746 definitions if there are many, or return 0 if it is undefined.
5748 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5749 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5750 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5751 Otherwise we prefer non-TYPE_DECLs.
5753 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5754 using IDENTIFIER_CLASS_VALUE. */
5757 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5759 int prefer_type
, nonclass
, namespaces_only
;
5762 tree val
= NULL_TREE
;
5764 tree from_obj
= NULL_TREE
;
5766 int val_is_implicit_typename
= 0;
5768 /* Hack: copy flag set by parser, if set. */
5769 if (only_namespace_names
)
5770 namespaces_only
= 1;
5772 if (prefer_type
== -2)
5774 extern int looking_for_typename
;
5775 tree type
= NULL_TREE
;
5778 prefer_type
= looking_for_typename
;
5780 flags
= lookup_flags (prefer_type
, namespaces_only
);
5781 /* If the next thing is '<', class templates are types. */
5782 if (looking_for_template
)
5783 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5785 /* std:: becomes :: for now. */
5786 if (got_scope
== std_node
)
5787 got_scope
= void_type_node
;
5791 else if (got_object
!= error_mark_node
)
5796 if (type
== error_mark_node
)
5797 return error_mark_node
;
5798 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5799 type
= TREE_TYPE (type
);
5802 type
= complete_type (type
);
5804 if (TREE_CODE (type
) == VOID_TYPE
)
5805 type
= global_namespace
;
5806 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5808 struct tree_binding b
;
5809 val
= binding_init (&b
);
5810 flags
|= LOOKUP_COMPLAIN
;
5811 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5813 val
= select_decl (val
, flags
);
5815 else if (! IS_AGGR_TYPE (type
)
5816 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5817 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
5818 || TREE_CODE (type
) == TYPENAME_TYPE
)
5819 /* Someone else will give an error about this if needed. */
5821 else if (type
== current_class_type
)
5822 val
= IDENTIFIER_CLASS_VALUE (name
);
5824 val
= lookup_member (type
, name
, 0, prefer_type
);
5831 else if (got_object
&& val
)
5836 flags
= lookup_flags (prefer_type
, namespaces_only
);
5837 /* If we're not parsing, we need to complain. */
5838 flags
|= LOOKUP_COMPLAIN
;
5841 /* First, look in non-namespace scopes. */
5843 if (current_class_type
== NULL_TREE
)
5846 for (t
= IDENTIFIER_BINDING (name
); t
; t
= TREE_CHAIN (t
))
5850 if (!LOCAL_BINDING_P (t
) && nonclass
)
5851 /* We're not looking for class-scoped bindings, so keep going. */
5854 /* If this is the kind of thing we're looking for, we're done. */
5855 if (qualify_lookup (BINDING_VALUE (t
), flags
))
5856 binding
= BINDING_VALUE (t
);
5857 else if ((flags
& LOOKUP_PREFER_TYPES
)
5858 && qualify_lookup (BINDING_TYPE (t
), flags
))
5859 binding
= BINDING_TYPE (t
);
5861 binding
= NULL_TREE
;
5864 && (!val
|| !IMPLICIT_TYPENAME_TYPE_DECL_P (binding
)))
5866 if (val_is_implicit_typename
&& !yylex
)
5867 warn_about_implicit_typename_lookup (val
, binding
);
5869 val_is_implicit_typename
5870 = IMPLICIT_TYPENAME_TYPE_DECL_P (val
);
5871 if (!val_is_implicit_typename
)
5876 /* Now lookup in namespace scopes. */
5877 if (!val
|| val_is_implicit_typename
)
5879 t
= unqualified_namespace_lookup (name
, flags
, 0);
5882 if (val_is_implicit_typename
&& !yylex
)
5883 warn_about_implicit_typename_lookup (val
, t
);
5891 /* This should only warn about types used in qualified-ids. */
5892 if (from_obj
&& from_obj
!= val
)
5894 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
5895 && TREE_CODE (val
) == TYPE_DECL
5896 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
5898 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5899 name
, got_object
, TREE_TYPE (from_obj
));
5900 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5904 /* We don't change val to from_obj if got_object depends on
5905 template parms because that breaks implicit typename for
5906 destructor calls. */
5907 if (! uses_template_parms (got_object
))
5911 /* If we have a single function from a using decl, pull it out. */
5912 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5913 val
= OVL_FUNCTION (val
);
5922 lookup_name_nonclass (name
)
5925 return lookup_name_real (name
, 0, 1, 0);
5929 lookup_function_nonclass (name
, args
)
5933 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
5937 lookup_name_namespace_only (name
)
5940 /* type-or-namespace, nonclass, namespace_only */
5941 return lookup_name_real (name
, 1, 1, 1);
5945 lookup_name (name
, prefer_type
)
5949 return lookup_name_real (name
, prefer_type
, 0, 0);
5952 /* Similar to `lookup_name' but look only in the innermost non-class
5956 lookup_name_current_level (name
)
5959 struct binding_level
*b
;
5962 b
= current_binding_level
;
5963 while (b
->parm_flag
== 2)
5968 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5970 /* extern "C" function() */
5971 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5974 else if (IDENTIFIER_BINDING (name
)
5975 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
5979 if (BINDING_LEVEL (IDENTIFIER_BINDING (name
)) == b
)
5980 return IDENTIFIER_VALUE (name
);
5992 /* Like lookup_name_current_level, but for types. */
5995 lookup_type_current_level (name
)
5998 register tree t
= NULL_TREE
;
6000 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
6002 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
6003 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
6005 struct binding_level
*b
= current_binding_level
;
6008 if (purpose_member (name
, b
->type_shadowed
))
6009 return REAL_IDENTIFIER_TYPE_VALUE (name
);
6021 begin_only_namespace_names ()
6023 only_namespace_names
= 1;
6027 end_only_namespace_names ()
6029 only_namespace_names
= 0;
6032 /* Arrange for the user to get a source line number, even when the
6033 compiler is going down in flames, so that she at least has a
6034 chance of working around problems in the compiler. We used to
6035 call error(), but that let the segmentation fault continue
6036 through; now, it's much more passive by asking them to send the
6037 maintainers mail about the problem. */
6041 int sig ATTRIBUTE_UNUSED
;
6043 signal (SIGSEGV
, SIG_DFL
);
6045 signal (SIGIOT
, SIG_DFL
);
6048 signal (SIGILL
, SIG_DFL
);
6051 signal (SIGABRT
, SIG_DFL
);
6054 signal (SIGBUS
, SIG_DFL
);
6056 my_friendly_abort (0);
6060 /* Unused -- brendan 970107 */
6061 /* Array for holding types considered "built-in". These types
6062 are output in the module in which `main' is defined. */
6063 static tree
*builtin_type_tdescs_arr
;
6064 static int builtin_type_tdescs_len
, builtin_type_tdescs_max
;
6067 /* Push the declarations of builtin types into the namespace.
6068 RID_INDEX, if < RID_MAX is the index of the builtin type
6069 in the array RID_POINTERS. NAME is the name used when looking
6070 up the builtin type. TYPE is the _TYPE node for the builtin type. */
6073 record_builtin_type (rid_index
, name
, type
)
6078 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
6079 tree tdecl
= NULL_TREE
;
6081 if ((int) rid_index
< (int) RID_MAX
)
6082 rname
= ridpointers
[(int) rid_index
];
6084 tname
= get_identifier (name
);
6086 TYPE_BUILT_IN (type
) = 1;
6090 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
6091 set_identifier_type_value (tname
, NULL_TREE
);
6092 if ((int) rid_index
< (int) RID_MAX
)
6093 /* Built-in types live in the global namespace. */
6094 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
6096 if (rname
!= NULL_TREE
)
6098 if (tname
!= NULL_TREE
)
6100 set_identifier_type_value (rname
, NULL_TREE
);
6101 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
6105 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
6106 set_identifier_type_value (rname
, NULL_TREE
);
6111 /* Record one of the standard Java types.
6112 * Declare it as having the given NAME.
6113 * If SIZE > 0, it is the size of one of the integral types;
6114 * otherwise it is the negative of the size of one of the other types. */
6117 record_builtin_java_type (name
, size
)
6123 type
= make_signed_type (size
);
6124 else if (size
> -32)
6125 { /* "__java_char" or ""__java_boolean". */
6126 type
= make_unsigned_type (-size
);
6127 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6130 { /* "__java_float" or ""__java_double". */
6131 type
= make_node (REAL_TYPE
);
6132 TYPE_PRECISION (type
) = - size
;
6135 record_builtin_type (RID_MAX
, name
, type
);
6136 decl
= TYPE_NAME (type
);
6138 /* Suppress generate debug symbol entries for these types,
6139 since for normal C++ they are just clutter.
6140 However, push_lang_context undoes this if extern "Java" is seen. */
6141 DECL_IGNORED_P (decl
) = 1;
6143 TYPE_FOR_JAVA (type
) = 1;
6147 /* Push a type into the namespace so that the back-ends ignore it. */
6150 record_unknown_type (type
, name
)
6154 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
6155 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
6156 DECL_IGNORED_P (decl
) = 1;
6157 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6158 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
6159 TYPE_ALIGN (type
) = 1;
6160 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
6163 /* Push overloaded decl, in global scope, with one argument so it
6164 can be used as a callback from define_function. */
6167 push_overloaded_decl_1 (x
)
6170 push_overloaded_decl (x
, PUSH_GLOBAL
);
6177 auto_function (name
, type
, code
)
6179 enum built_in_function code
;
6181 return define_function
6182 (IDENTIFIER_POINTER (name
), type
, code
, push_overloaded_decl_1
,
6183 IDENTIFIER_POINTER (build_decl_overload (name
, TYPE_ARG_TYPES (type
),
6187 /* Create the predefined scalar types of C,
6188 and some nodes representing standard constants (0, 1, (void *)0).
6189 Initialize the global binding level.
6190 Make definitions for built-in primitive functions. */
6193 init_decl_processing ()
6196 int wchar_type_size
;
6197 tree array_domain_type
;
6199 /* Have to make these distinct before we try using them. */
6200 lang_name_cplusplus
= get_identifier ("C++");
6201 lang_name_c
= get_identifier ("C");
6202 lang_name_java
= get_identifier ("Java");
6204 /* Let the back-end now how to save and restore language-specific
6205 per-function globals. */
6206 save_lang_status
= &push_cp_function_context
;
6207 restore_lang_status
= &pop_cp_function_context
;
6208 mark_lang_status
= &mark_cp_function_context
;
6210 /* Create the global per-function variables. */
6211 push_function_context_to (NULL_TREE
);
6213 /* Enter the global namespace. */
6214 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
6215 my_friendly_assert (current_lang_name
== NULL_TREE
, 375);
6216 current_lang_name
= lang_name_cplusplus
;
6217 push_namespace (get_identifier ("::"));
6218 global_namespace
= current_namespace
;
6219 current_lang_name
= NULL_TREE
;
6221 if (flag_strict_prototype
== 2)
6222 flag_strict_prototype
= pedantic
;
6223 if (! flag_permissive
&& ! pedantic
)
6224 flag_pedantic_errors
= 1;
6226 strict_prototypes_lang_c
= flag_strict_prototype
;
6229 current_lang_name
= lang_name_c
;
6231 current_function_decl
= NULL_TREE
;
6232 named_labels
= NULL_TREE
;
6233 named_label_uses
= NULL
;
6234 current_binding_level
= NULL_BINDING_LEVEL
;
6235 free_binding_level
= NULL_BINDING_LEVEL
;
6237 /* Because most segmentation signals can be traced back into user
6238 code, catch them and at least give the user a chance of working
6239 around compiler bugs. */
6240 signal (SIGSEGV
, signal_catch
);
6242 /* We will also catch aborts in the back-end through signal_catch and
6243 give the user a chance to see where the error might be, and to defeat
6244 aborts in the back-end when there have been errors previously in their
6247 signal (SIGIOT
, signal_catch
);
6250 signal (SIGILL
, signal_catch
);
6253 signal (SIGABRT
, signal_catch
);
6256 signal (SIGBUS
, signal_catch
);
6259 gcc_obstack_init (&decl_obstack
);
6261 /* Must lay these out before anything else gets laid out. */
6262 error_mark_node
= make_node (ERROR_MARK
);
6263 TREE_PERMANENT (error_mark_node
) = 1;
6264 TREE_TYPE (error_mark_node
) = error_mark_node
;
6265 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
6266 TREE_TYPE (error_mark_list
) = error_mark_node
;
6268 /* Make the binding_level structure for global names. */
6270 global_binding_level
= current_binding_level
;
6271 /* The global level is the namespace level of ::. */
6272 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
6273 declare_namespace_level ();
6275 this_identifier
= get_identifier (THIS_NAME
);
6276 in_charge_identifier
= get_identifier (IN_CHARGE_NAME
);
6277 ctor_identifier
= get_identifier (CTOR_NAME
);
6278 dtor_identifier
= get_identifier (DTOR_NAME
);
6279 pfn_identifier
= get_identifier (VTABLE_PFN_NAME
);
6280 index_identifier
= get_identifier (VTABLE_INDEX_NAME
);
6281 delta_identifier
= get_identifier (VTABLE_DELTA_NAME
);
6282 delta2_identifier
= get_identifier (VTABLE_DELTA2_NAME
);
6283 pfn_or_delta2_identifier
= get_identifier ("__pfn_or_delta2");
6285 /* Define `int' and `char' first so that dbx will output them first. */
6287 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
6288 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
6290 /* Define `char', which is like either `signed char' or `unsigned char'
6291 but not the same as either. */
6295 ? make_signed_type (CHAR_TYPE_SIZE
)
6296 : make_unsigned_type (CHAR_TYPE_SIZE
));
6297 record_builtin_type (RID_CHAR
, "char", char_type_node
);
6299 /* `signed' is the same as `int' */
6300 record_builtin_type (RID_SIGNED
, NULL_PTR
, integer_type_node
);
6302 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
6303 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
6305 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
6306 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
6308 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
6309 record_builtin_type (RID_MAX
, "long unsigned int", long_unsigned_type_node
);
6310 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
6312 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
6313 record_builtin_type (RID_MAX
, "long long int", long_long_integer_type_node
);
6315 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
6316 record_builtin_type (RID_MAX
, "long long unsigned int",
6317 long_long_unsigned_type_node
);
6318 record_builtin_type (RID_MAX
, "long long unsigned",
6319 long_long_unsigned_type_node
);
6321 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
6322 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
6323 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
6324 record_builtin_type (RID_MAX
, "short unsigned int", short_unsigned_type_node
);
6325 record_builtin_type (RID_MAX
, "unsigned short", short_unsigned_type_node
);
6327 /* `unsigned long' is the standard type for sizeof.
6328 Note that stddef.h uses `unsigned long',
6329 and this must agree, even if long and int are the same size. */
6331 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
6334 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
6336 /* Define both `signed char' and `unsigned char'. */
6337 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
6338 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
6339 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
6340 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
6342 /* Create the widest literal types. */
6343 widest_integer_literal_type_node
= make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
6344 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6345 widest_integer_literal_type_node
));
6347 widest_unsigned_literal_type_node
= make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
6348 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6349 widest_unsigned_literal_type_node
));
6351 /* These are types that type_for_size and type_for_mode use. */
6352 intQI_type_node
= make_signed_type (GET_MODE_BITSIZE (QImode
));
6353 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
6354 intHI_type_node
= make_signed_type (GET_MODE_BITSIZE (HImode
));
6355 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
6356 intSI_type_node
= make_signed_type (GET_MODE_BITSIZE (SImode
));
6357 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
6358 intDI_type_node
= make_signed_type (GET_MODE_BITSIZE (DImode
));
6359 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
6360 #if HOST_BITS_PER_WIDE_INT >= 64
6361 intTI_type_node
= make_signed_type (GET_MODE_BITSIZE (TImode
));
6362 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
6364 unsigned_intQI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (QImode
));
6365 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
6366 unsigned_intHI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (HImode
));
6367 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
6368 unsigned_intSI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (SImode
));
6369 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
6370 unsigned_intDI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (DImode
));
6371 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
6372 #if HOST_BITS_PER_WIDE_INT >= 64
6373 unsigned_intTI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (TImode
));
6374 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
6377 float_type_node
= make_node (REAL_TYPE
);
6378 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
6379 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
6380 layout_type (float_type_node
);
6382 double_type_node
= make_node (REAL_TYPE
);
6383 if (flag_short_double
)
6384 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
6386 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
6387 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
6388 layout_type (double_type_node
);
6390 long_double_type_node
= make_node (REAL_TYPE
);
6391 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
6392 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
6393 layout_type (long_double_type_node
);
6395 complex_integer_type_node
= make_node (COMPLEX_TYPE
);
6396 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
6397 complex_integer_type_node
));
6398 TREE_TYPE (complex_integer_type_node
) = integer_type_node
;
6399 layout_type (complex_integer_type_node
);
6401 complex_float_type_node
= make_node (COMPLEX_TYPE
);
6402 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
6403 complex_float_type_node
));
6404 TREE_TYPE (complex_float_type_node
) = float_type_node
;
6405 layout_type (complex_float_type_node
);
6407 complex_double_type_node
= make_node (COMPLEX_TYPE
);
6408 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
6409 complex_double_type_node
));
6410 TREE_TYPE (complex_double_type_node
) = double_type_node
;
6411 layout_type (complex_double_type_node
);
6413 complex_long_double_type_node
= make_node (COMPLEX_TYPE
);
6414 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
6415 complex_long_double_type_node
));
6416 TREE_TYPE (complex_long_double_type_node
) = long_double_type_node
;
6417 layout_type (complex_long_double_type_node
);
6419 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
6420 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
6421 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
6422 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
6423 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
6424 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
6425 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
6426 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
6428 integer_zero_node
= build_int_2 (0, 0);
6429 TREE_TYPE (integer_zero_node
) = integer_type_node
;
6430 integer_one_node
= build_int_2 (1, 0);
6431 TREE_TYPE (integer_one_node
) = integer_type_node
;
6432 integer_two_node
= build_int_2 (2, 0);
6433 TREE_TYPE (integer_two_node
) = integer_type_node
;
6434 integer_three_node
= build_int_2 (3, 0);
6435 TREE_TYPE (integer_three_node
) = integer_type_node
;
6437 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
6438 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
6439 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
6440 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
6441 TYPE_PRECISION (boolean_type_node
) = 1;
6442 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
6443 boolean_false_node
= build_int_2 (0, 0);
6444 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
6445 boolean_true_node
= build_int_2 (1, 0);
6446 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
6448 /* These are needed by stor-layout.c. */
6449 size_zero_node
= size_int (0);
6450 size_one_node
= size_int (1);
6452 signed_size_zero_node
= build_int_2 (0, 0);
6453 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
6455 void_type_node
= make_node (VOID_TYPE
);
6456 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
6457 layout_type (void_type_node
); /* Uses integer_zero_node. */
6458 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
6459 TREE_PARMLIST (void_list_node
) = 1;
6461 null_pointer_node
= build_int_2 (0, 0);
6462 TREE_TYPE (null_pointer_node
) = build_pointer_type (void_type_node
);
6463 layout_type (TREE_TYPE (null_pointer_node
));
6465 /* Used for expressions that do nothing, but are not errors. */
6466 void_zero_node
= build_int_2 (0, 0);
6467 TREE_TYPE (void_zero_node
) = void_type_node
;
6469 string_type_node
= build_pointer_type (char_type_node
);
6470 const_string_type_node
6471 = build_pointer_type (build_qualified_type (char_type_node
,
6473 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
6475 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
6478 /* Make a type to be the domain of a few array types
6479 whose domains don't really matter.
6480 200 is small enough that it always fits in size_t
6481 and large enough that it can hold most function names for the
6482 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
6483 array_domain_type
= build_index_type (build_int_2 (200, 0));
6485 /* Make a type for arrays of characters.
6486 With luck nothing will ever really depend on the length of this
6488 char_array_type_node
6489 = build_array_type (char_type_node
, array_domain_type
);
6490 /* Likewise for arrays of ints. */
6492 = build_array_type (integer_type_node
, array_domain_type
);
6494 /* This is just some anonymous class type. Nobody should ever
6495 need to look inside this envelope. */
6496 class_star_type_node
= build_pointer_type (make_lang_type (RECORD_TYPE
));
6498 if (flag_huge_objects
)
6499 delta_type_node
= long_integer_type_node
;
6501 delta_type_node
= short_integer_type_node
;
6503 default_function_type
6504 = build_function_type (integer_type_node
, NULL_TREE
);
6506 ptr_type_node
= build_pointer_type (void_type_node
);
6508 = build_pointer_type (build_qualified_type (void_type_node
,
6510 c_common_nodes_and_builtins (1, flag_no_builtin
, flag_no_nonansi_builtin
);
6513 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6515 /* C++ extensions */
6517 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6518 record_unknown_type (unknown_type_node
, "unknown type");
6520 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6521 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6523 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6525 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6527 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6528 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6530 /* This is special for C++ so functions can be overloaded. */
6532 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE
)));
6533 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6534 signed_wchar_type_node
= make_signed_type (wchar_type_size
);
6535 unsigned_wchar_type_node
= make_unsigned_type (wchar_type_size
);
6537 = TREE_UNSIGNED (wchar_type_node
)
6538 ? unsigned_wchar_type_node
6539 : signed_wchar_type_node
;
6540 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6542 /* Artificial declaration of wchar_t -- can be bashed */
6543 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6545 pushdecl (wchar_decl_node
);
6547 /* This is for wide string constants. */
6548 wchar_array_type_node
6549 = build_array_type (wchar_type_node
, array_domain_type
);
6551 if (flag_vtable_thunks
)
6553 /* Make sure we get a unique function type, so we can give
6554 its pointer type a name. (This wins for gdb.) */
6555 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6556 TREE_TYPE (vfunc_type
) = integer_type_node
;
6557 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6558 layout_type (vfunc_type
);
6560 vtable_entry_type
= build_pointer_type (vfunc_type
);
6564 vtable_entry_type
= make_lang_type (RECORD_TYPE
);
6565 fields
[0] = build_lang_decl (FIELD_DECL
, delta_identifier
,
6567 fields
[1] = build_lang_decl (FIELD_DECL
, index_identifier
,
6569 fields
[2] = build_lang_decl (FIELD_DECL
, pfn_identifier
,
6571 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6574 /* Make this part of an invisible union. */
6575 fields
[3] = copy_node (fields
[2]);
6576 TREE_TYPE (fields
[3]) = delta_type_node
;
6577 DECL_NAME (fields
[3]) = delta2_identifier
;
6578 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6579 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6580 TREE_UNSIGNED (fields
[3]) = 0;
6581 TREE_CHAIN (fields
[2]) = fields
[3];
6582 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6585 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6588 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
6589 layout_type (vtbl_type_node
);
6590 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6591 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6592 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6593 layout_type (vtbl_ptr_type_node
);
6594 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6596 std_node
= build_decl (NAMESPACE_DECL
,
6597 get_identifier (flag_honor_std
? "fake std":"std"),
6599 pushdecl (std_node
);
6601 global_type_node
= make_node (LANG_TYPE
);
6602 record_unknown_type (global_type_node
, "global type");
6605 current_lang_name
= lang_name_cplusplus
;
6608 tree bad_alloc_type_node
, newtype
, deltype
;
6610 push_namespace (get_identifier ("std"));
6611 bad_alloc_type_node
= xref_tag
6612 (class_type_node
, get_identifier ("bad_alloc"), 1);
6615 newtype
= build_exception_variant
6616 (ptr_ftype_sizetype
, add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1));
6617 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6618 auto_function (ansi_opname
[(int) NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6619 auto_function (ansi_opname
[(int) VEC_NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6620 global_delete_fndecl
6621 = auto_function (ansi_opname
[(int) DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6622 auto_function (ansi_opname
[(int) VEC_DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6626 = define_function ("__pure_virtual", void_ftype
,
6627 NOT_BUILT_IN
, 0, 0);
6629 /* Perform other language dependent initializations. */
6630 init_class_processing ();
6631 init_init_processing ();
6632 init_search_processing ();
6634 init_rtti_processing ();
6636 if (flag_exceptions
)
6637 init_exception_processing ();
6640 flag_inline_functions
= 0;
6643 if (! supports_one_only ())
6646 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6647 declare_function_name ();
6649 /* Prepare to check format strings against argument lists. */
6650 init_function_format_info ();
6652 /* Show we use EH for cleanups. */
6653 using_eh_for_cleanups ();
6655 print_error_function
= lang_print_error_function
;
6656 lang_get_alias_set
= &c_get_alias_set
;
6657 valid_lang_attribute
= cp_valid_lang_attribute
;
6659 /* Maintain consistency. Perhaps we should just complain if they
6660 say -fwritable-strings? */
6661 if (flag_writable_strings
)
6662 flag_const_strings
= 0;
6665 /* Function to print any language-specific context for an error message. */
6668 lang_print_error_function (file
)
6671 default_print_error_function (file
);
6672 maybe_print_template_context ();
6675 /* Make a definition for a builtin function named NAME and whose data type
6676 is TYPE. TYPE should be a function type with argument types.
6677 FUNCTION_CODE tells later passes how to compile calls to this function.
6678 See tree.h for its possible values.
6680 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6681 the name to be called if we can't opencode the function. */
6684 define_function (name
, type
, function_code
, pfn
, library_name
)
6687 enum built_in_function function_code
;
6688 void (*pfn
) PROTO((tree
));
6689 const char *library_name
;
6691 tree decl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), type
);
6692 DECL_EXTERNAL (decl
) = 1;
6693 TREE_PUBLIC (decl
) = 1;
6694 DECL_ARTIFICIAL (decl
) = 1;
6696 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6697 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
6699 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6700 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6701 function in the namespace. */
6702 if (pfn
) (*pfn
) (decl
);
6704 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
6705 make_function_rtl (decl
);
6706 if (function_code
!= NOT_BUILT_IN
)
6708 DECL_BUILT_IN (decl
) = 1;
6709 DECL_FUNCTION_CODE (decl
) = function_code
;
6715 builtin_function (name
, type
, code
, libname
)
6718 enum built_in_function code
;
6719 const char *libname
;
6721 return define_function (name
, type
, code
, (void (*) PROTO((tree
)))pushdecl
, libname
);
6724 /* When we call finish_struct for an anonymous union, we create
6725 default copy constructors and such. But, an anonymous union
6726 shouldn't have such things; this function undoes the damage to the
6727 anonymous union type T.
6729 (The reason that we create the synthesized methods is that we don't
6730 distinguish `union { int i; }' from `typedef union { int i; } U'.
6731 The first is an anonymous union; the second is just an ordinary
6735 fixup_anonymous_aggr (t
)
6740 /* Wipe out memory of synthesized methods */
6741 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6742 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6743 TYPE_HAS_INIT_REF (t
) = 0;
6744 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6745 TYPE_HAS_ASSIGN_REF (t
) = 0;
6746 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6748 /* Splice the implicitly generated functions out of the TYPE_METHODS
6750 q
= &TYPE_METHODS (t
);
6753 if (DECL_ARTIFICIAL (*q
))
6754 *q
= TREE_CHAIN (*q
);
6756 q
= &TREE_CHAIN (*q
);
6759 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
6760 function members. */
6761 if (TYPE_METHODS (t
))
6762 error ("an anonymous union cannot have function members");
6765 /* Make sure that a declaration with no declarator is well-formed, i.e.
6766 just defines a tagged type or anonymous union.
6768 Returns the type defined, if any. */
6771 check_tag_decl (declspecs
)
6775 tree ob_modifier
= NULL_TREE
;
6777 register tree t
= NULL_TREE
;
6779 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6781 register tree value
= TREE_VALUE (link
);
6787 if (IS_AGGR_TYPE (value
) || TREE_CODE (value
) == ENUMERAL_TYPE
)
6789 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
6793 else if (value
== ridpointers
[(int) RID_FRIEND
])
6795 if (current_class_type
== NULL_TREE
6796 || current_scope () != current_class_type
)
6797 ob_modifier
= value
;
6799 else if (value
== ridpointers
[(int) RID_STATIC
]
6800 || value
== ridpointers
[(int) RID_EXTERN
]
6801 || value
== ridpointers
[(int) RID_AUTO
]
6802 || value
== ridpointers
[(int) RID_REGISTER
]
6803 || value
== ridpointers
[(int) RID_INLINE
]
6804 || value
== ridpointers
[(int) RID_VIRTUAL
]
6805 || value
== ridpointers
[(int) RID_CONST
]
6806 || value
== ridpointers
[(int) RID_VOLATILE
]
6807 || value
== ridpointers
[(int) RID_EXPLICIT
])
6808 ob_modifier
= value
;
6812 error ("multiple types in one declaration");
6814 /* Inside a class, we might be in a friend or access declaration.
6815 Until we have a good way of detecting the latter, don't warn. */
6816 if (t
== NULL_TREE
&& ! current_class_type
)
6817 pedwarn ("declaration does not declare anything");
6819 /* Check for an anonymous union. We're careful
6820 accessing TYPE_IDENTIFIER because some built-in types, like
6821 pointer-to-member types, do not have TYPE_NAME. */
6822 else if (t
&& IS_AGGR_TYPE_CODE (TREE_CODE (t
))
6824 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
6826 /* Anonymous unions are objects, so they can have specifiers. */;
6827 SET_ANON_AGGR_TYPE_P (t
);
6829 if (TREE_CODE (t
) != UNION_TYPE
&& pedantic
&& ! in_system_header
)
6830 pedwarn ("ISO C++ prohibits anonymous structs");
6833 else if (ob_modifier
)
6835 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
6836 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
6837 cp_error ("`%D' can only be specified for functions", ob_modifier
);
6838 else if (ob_modifier
== ridpointers
[(int) RID_FRIEND
])
6839 cp_error ("`%D' can only be specified inside a class", ob_modifier
);
6840 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
6841 cp_error ("`%D' can only be specified for constructors",
6844 cp_error ("`%D' can only be specified for objects and functions",
6851 /* Called when a declaration is seen that contains no names to declare.
6852 If its type is a reference to a structure, union or enum inherited
6853 from a containing scope, shadow that tag name for the current scope
6854 with a forward reference.
6855 If its type defines a new named structure or union
6856 or defines an enum, it is valid but we need not do anything here.
6857 Otherwise, it is an error.
6859 C++: may have to grok the declspecs to learn about static,
6860 complain for anonymous unions. */
6863 shadow_tag (declspecs
)
6866 tree t
= check_tag_decl (declspecs
);
6869 maybe_process_partial_specialization (t
);
6871 /* This is where the variables in an anonymous union are
6872 declared. An anonymous union declaration looks like:
6874 because there is no declarator after the union, the parser
6875 sends that declaration here. */
6876 if (t
&& ANON_AGGR_TYPE_P (t
))
6878 fixup_anonymous_aggr (t
);
6880 if (TYPE_FIELDS (t
))
6882 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
6884 finish_anon_union (decl
);
6889 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6892 groktypename (typename
)
6895 if (TREE_CODE (typename
) != TREE_LIST
)
6897 return grokdeclarator (TREE_VALUE (typename
),
6898 TREE_PURPOSE (typename
),
6899 TYPENAME
, 0, NULL_TREE
);
6902 /* Decode a declarator in an ordinary declaration or data definition.
6903 This is called as soon as the type information and variable name
6904 have been parsed, before parsing the initializer if any.
6905 Here we create the ..._DECL node, fill in its type,
6906 and put it on the list of decls for the current context.
6907 The ..._DECL node is returned as the value.
6909 Exception: for arrays where the length is not specified,
6910 the type is left null, to be filled in by `cp_finish_decl'.
6912 Function definitions do not come here; they go to start_function
6913 instead. However, external and forward declarations of functions
6914 do go through here. Structure field declarations are done by
6915 grokfield and not through here. */
6917 /* Set this to zero to debug not using the temporary obstack
6918 to parse initializers. */
6919 int debug_temp_inits
= 1;
6922 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
6923 tree declarator
, declspecs
;
6925 tree attributes
, prefix_attributes
;
6928 register tree type
, tem
;
6930 extern int have_extern_spec
;
6931 extern int used_extern_spec
;
6935 /* See code below that used this. */
6936 int init_written
= initialized
;
6939 /* This should only be done once on the top most decl. */
6940 if (have_extern_spec
&& !used_extern_spec
)
6942 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
6944 used_extern_spec
= 1;
6947 if (attributes
|| prefix_attributes
)
6948 attrlist
= build_scratch_list (attributes
, prefix_attributes
);
6950 attrlist
= NULL_TREE
;
6952 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
6955 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
6958 type
= TREE_TYPE (decl
);
6960 if (type
== error_mark_node
)
6963 /* Don't lose if destructors must be executed at file-level. */
6964 if (! processing_template_decl
&& TREE_STATIC (decl
)
6965 && TYPE_NEEDS_DESTRUCTOR (complete_type (type
))
6966 && !TREE_PERMANENT (decl
))
6968 push_obstacks (&permanent_obstack
, &permanent_obstack
);
6969 decl
= copy_node (decl
);
6970 if (TREE_CODE (type
) == ARRAY_TYPE
)
6972 tree itype
= TYPE_DOMAIN (type
);
6973 if (itype
&& ! TREE_PERMANENT (itype
))
6975 itype
= build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype
)));
6976 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
6977 TREE_TYPE (decl
) = type
;
6984 = (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
6985 ? DECL_CLASS_CONTEXT (decl
)
6986 : DECL_CONTEXT (decl
);
6988 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
6989 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
6991 /* When parsing the initializer, lookup should use the object's
6993 push_decl_namespace (context
);
6996 /* We are only interested in class contexts, later. */
6997 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
6998 context
= NULL_TREE
;
7001 /* Is it valid for this decl to have an initializer at all?
7002 If not, set INITIALIZED to zero, which will indirectly
7003 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7004 switch (TREE_CODE (decl
))
7007 /* typedef foo = bar means give foo the same type as bar.
7008 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7009 Any other case of an initialization in a TYPE_DECL is an error. */
7010 if (pedantic
|| list_length (declspecs
) > 1)
7012 cp_error ("typedef `%D' is initialized", decl
);
7018 cp_error ("function `%#D' is initialized like a variable", decl
);
7028 if (! toplevel_bindings_p ()
7029 && DECL_EXTERNAL (decl
))
7030 cp_warning ("declaration of `%#D' has `extern' and is initialized",
7032 DECL_EXTERNAL (decl
) = 0;
7033 if (toplevel_bindings_p ())
7034 TREE_STATIC (decl
) = 1;
7036 /* Tell `pushdecl' this is an initialized decl
7037 even though we don't yet have the initializer expression.
7038 Also tell `cp_finish_decl' it may store the real initializer. */
7039 DECL_INITIAL (decl
) = error_mark_node
;
7042 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7043 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
7046 /* Set attributes here so if duplicate decl, will have proper attributes. */
7047 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
7049 if (context
&& TYPE_SIZE (complete_type (context
)) != NULL_TREE
)
7051 push_nested_class (context
, 2);
7053 if (TREE_CODE (decl
) == VAR_DECL
)
7055 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
7056 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
7057 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
7060 if (DECL_CONTEXT (field
) != context
)
7062 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
7063 DECL_CONTEXT (field
), DECL_NAME (decl
),
7064 context
, DECL_NAME (decl
));
7065 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
7067 /* Static data member are tricky; an in-class initialization
7068 still doesn't provide a definition, so the in-class
7069 declaration will have DECL_EXTERNAL set, but will have an
7070 initialization. Thus, duplicate_decls won't warn
7071 about this situation, and so we check here. */
7072 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
7073 cp_error ("duplicate initialization of %D", decl
);
7074 if (duplicate_decls (decl
, field
))
7080 tree field
= check_classfn (context
, decl
);
7081 if (field
&& duplicate_decls (decl
, field
))
7085 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7086 DECL_IN_AGGR_P (decl
) = 0;
7087 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
7088 || CLASSTYPE_USE_TEMPLATE (context
))
7090 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
7091 /* [temp.expl.spec] An explicit specialization of a static data
7092 member of a template is a definition if the declaration
7093 includes an initializer; otherwise, it is a declaration.
7095 We check for processing_specialization so this only applies
7096 to the new specialization syntax. */
7097 if (DECL_INITIAL (decl
) == NULL_TREE
&& processing_specialization
)
7098 DECL_EXTERNAL (decl
) = 1;
7101 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
7102 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7106 /* Enter this declaration into the symbol table. */
7107 tem
= maybe_push_decl (decl
);
7109 if (processing_template_decl
)
7111 if (at_function_scope_p ())
7112 push_permanent_obstack ();
7114 tem
= push_template_decl (tem
);
7115 /* In a a local scope, add a representation of this declaration
7116 to the statement tree. */
7117 if (at_function_scope_p ())
7119 add_decl_stmt (decl
);
7125 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7126 /* Tell the back-end to use or not use .common as appropriate. If we say
7127 -fconserve-space, we want this to save .data space, at the expense of
7128 wrong semantics. If we say -fno-conserve-space, we want this to
7129 produce errors about redefs; to do this we force variables into the
7131 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
7134 if (! processing_template_decl
)
7137 /* Corresponding pop_obstacks is done in `cp_finish_decl'. */
7138 push_obstacks_nochange ();
7147 tree type
= TREE_TYPE (decl
);
7148 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
7150 if (type
== error_mark_node
)
7153 /* If this type of object needs a cleanup, and control may
7154 jump past it, make a new binding level so that it is cleaned
7155 up only when it is initialized first. */
7156 if (TYPE_NEEDS_DESTRUCTOR (type
)
7157 && current_binding_level
->more_cleanups_ok
== 0)
7158 pushlevel_temporary (1);
7161 /* Is it valid for this decl to have an initializer at all?
7162 If not, set INITIALIZED to zero, which will indirectly
7163 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7165 /* Don't allow initializations for incomplete types except for
7166 arrays which might be completed by the initialization. */
7167 if (TYPE_SIZE (complete_type (type
)) != NULL_TREE
)
7168 ; /* A complete type is ok. */
7169 else if (TREE_CODE (type
) != ARRAY_TYPE
)
7171 cp_error ("variable `%#D' has initializer but incomplete type",
7174 type
= TREE_TYPE (decl
) = error_mark_node
;
7176 else if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
7178 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
7179 cp_error ("elements of array `%#D' have incomplete type", decl
);
7180 /* else we already gave an error in start_decl. */
7186 && TREE_CODE (decl
) != TYPE_DECL
7187 && TREE_CODE (decl
) != TEMPLATE_DECL
7188 && IS_AGGR_TYPE (type
) && ! DECL_EXTERNAL (decl
))
7190 if ((! processing_template_decl
|| ! uses_template_parms (type
))
7191 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
7193 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7195 /* Change the type so that assemble_variable will give
7196 DECL an rtl we can live with: (mem (const_int 0)). */
7197 type
= TREE_TYPE (decl
) = error_mark_node
;
7201 /* If any base type in the hierarchy of TYPE needs a constructor,
7202 then we set initialized to 1. This way any nodes which are
7203 created for the purposes of initializing this aggregate
7204 will live as long as it does. This is necessary for global
7205 aggregates which do not have their initializers processed until
7206 the end of the file. */
7207 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
7212 DECL_INITIAL (decl
) = NULL_TREE
;
7215 /* Handle initialization of references.
7216 These three arguments are from `cp_finish_decl', and have the
7217 same meaning here that they do there.
7219 Quotes on semantics can be found in ARM 8.4.3. */
7222 grok_reference_init (decl
, type
, init
)
7223 tree decl
, type
, init
;
7227 if (init
== NULL_TREE
)
7229 if ((DECL_LANG_SPECIFIC (decl
) == 0
7230 || DECL_IN_AGGR_P (decl
) == 0)
7231 && ! DECL_THIS_EXTERN (decl
))
7233 cp_error ("`%D' declared as reference but not initialized", decl
);
7234 if (TREE_CODE (decl
) == VAR_DECL
)
7235 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
7240 if (init
== error_mark_node
)
7243 if (TREE_CODE (type
) == REFERENCE_TYPE
7244 && TREE_CODE (init
) == CONSTRUCTOR
)
7246 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl
);
7250 if (TREE_CODE (init
) == TREE_LIST
)
7251 init
= build_compound_expr (init
);
7253 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
7254 init
= convert_from_reference (init
);
7256 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
7257 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
7259 /* Note: default conversion is only called in very special cases. */
7260 init
= default_conversion (init
);
7263 tmp
= convert_to_reference
7264 (type
, init
, CONV_IMPLICIT
,
7265 LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
, decl
);
7267 if (tmp
== error_mark_node
)
7269 else if (tmp
!= NULL_TREE
)
7272 DECL_INITIAL (decl
) = save_expr (init
);
7276 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
7280 /* ?? Can this be optimized in some cases to
7281 hand back the DECL_INITIAL slot?? */
7282 if (TYPE_SIZE (TREE_TYPE (type
)))
7284 init
= convert_from_reference (decl
);
7285 if (TREE_PERMANENT (decl
))
7286 init
= copy_to_permanent (init
);
7287 SET_DECL_REFERENCE_SLOT (decl
, init
);
7290 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
7292 expand_static_init (decl
, DECL_INITIAL (decl
));
7293 DECL_INITIAL (decl
) = NULL_TREE
;
7298 if (TREE_CODE (decl
) == VAR_DECL
)
7299 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
7303 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7304 mucking with forces it does not comprehend (i.e. initialization with a
7305 constructor). If we are at global scope and won't go into COMMON, fill
7306 it in with a dummy CONSTRUCTOR to force the variable into .data;
7307 otherwise we can use error_mark_node. */
7310 obscure_complex_init (decl
, init
)
7313 if (! flag_no_inline
&& TREE_STATIC (decl
))
7315 if (extract_init (decl
, init
))
7319 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7320 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
7321 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
7325 DECL_INITIAL (decl
) = error_mark_node
;
7330 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7331 array until we finish parsing the initializer. If that's the
7332 situation we're in, update DECL accordingly. */
7335 maybe_deduce_size_from_array_init (decl
, init
)
7339 tree type
= TREE_TYPE (decl
);
7341 if (TREE_CODE (type
) == ARRAY_TYPE
7342 && TYPE_DOMAIN (type
) == NULL_TREE
7343 && TREE_CODE (decl
) != TYPE_DECL
)
7346 = (TREE_STATIC (decl
)
7347 /* Even if pedantic, an external linkage array
7348 may have incomplete type at first. */
7349 ? pedantic
&& ! DECL_EXTERNAL (decl
)
7350 : !DECL_EXTERNAL (decl
));
7351 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7352 int failure
= complete_array_type (type
, initializer
, do_default
);
7355 cp_error ("initializer fails to determine size of `%D'", decl
);
7360 cp_error ("array size missing in `%D'", decl
);
7361 /* If a `static' var's size isn't known, make it extern as
7362 well as static, so it does not get allocated. If it's not
7363 `static', then don't mark it extern; finish_incomplete_decl
7364 will give it a default size and it will get allocated. */
7365 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7366 DECL_EXTERNAL (decl
) = 1;
7369 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7370 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7372 cp_error ("zero-size array `%D'", decl
);
7374 layout_decl (decl
, 0);
7378 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7379 any appropriate error messages regarding the layout. INITP is a
7380 pointer to the initializer for DECL; the initializer may be
7381 modified by this function. */
7384 layout_var_decl (decl
, initp
)
7388 tree ttype
= target_type (TREE_TYPE (decl
));
7390 if (DECL_SIZE (decl
) == NULL_TREE
7391 && TYPE_SIZE (complete_type (TREE_TYPE (decl
))) != NULL_TREE
)
7392 layout_decl (decl
, 0);
7394 if (TREE_STATIC (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7396 /* A static variable with an incomplete type:
7397 that is an error if it is initialized.
7398 Otherwise, let it through, but if it is not `extern'
7399 then it may cause an error message later. */
7400 if (DECL_INITIAL (decl
) != NULL_TREE
)
7401 cp_error ("storage size of `%D' isn't known", decl
);
7404 else if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7406 /* An automatic variable with an incomplete type: that is an error.
7407 Don't talk about array types here, since we took care of that
7408 message in grokdeclarator. */
7409 cp_error ("storage size of `%D' isn't known", decl
);
7410 TREE_TYPE (decl
) = error_mark_node
;
7412 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7413 /* Let debugger know it should output info for this type. */
7414 note_debug_info_needed (ttype
);
7416 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7417 note_debug_info_needed (DECL_CONTEXT (decl
));
7419 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7420 && DECL_SIZE (decl
) != NULL_TREE
7421 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7423 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7424 constant_expression_warning (DECL_SIZE (decl
));
7426 cp_error ("storage size of `%D' isn't constant", decl
);
7430 /* Return a cleanup for DECL, created on whatever obstack is
7434 build_cleanup_on_safe_obstack (decl
)
7441 type
= TREE_TYPE (decl
);
7443 /* Only variables get cleaned up. */
7444 if (TREE_CODE (decl
) != VAR_DECL
)
7447 /* And only things with destructors need cleaning up. */
7448 if (!TYPE_NEEDS_DESTRUCTOR (type
))
7451 if (TREE_CODE (decl
) == VAR_DECL
&&
7452 (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
)))
7453 /* We don't clean up things that aren't defined in this
7454 translation unit, or that need a static cleanup. The latter
7455 are handled by finish_file. */
7458 /* Switch to an obstack that will live until the point where the
7459 cleanup code is actually expanded. */
7460 need_pop
= suspend_momentary ();
7462 /* Compute the cleanup. */
7463 cleanup
= maybe_build_cleanup (decl
);
7465 /* Pop back to the obstack we were on before. */
7466 resume_momentary (need_pop
);
7471 /* If a local static variable is declared in an inline function, or if
7472 we have a weak definition, we must endeavor to create only one
7473 instance of the variable at link-time. */
7476 maybe_commonize_var (decl
)
7479 /* Static data in a function with comdat linkage also has comdat
7481 if (TREE_STATIC (decl
)
7482 /* Don't mess with __FUNCTION__. */
7483 && ! TREE_ASM_WRITTEN (decl
)
7484 && current_function_decl
7485 && DECL_CONTEXT (decl
) == current_function_decl
7486 && (DECL_THIS_INLINE (current_function_decl
)
7487 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7488 && TREE_PUBLIC (current_function_decl
))
7490 /* Rather than try to get this right with inlining, we suppress
7491 inlining of such functions. */
7492 current_function_cannot_inline
7493 = "function with static variable cannot be inline";
7495 /* If flag_weak, we don't need to mess with this, as we can just
7496 make the function weak, and let it refer to its unique local
7497 copy. This works because we don't allow the function to be
7501 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7503 TREE_PUBLIC (decl
) = 1;
7504 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7506 else if (DECL_INITIAL (decl
) == NULL_TREE
7507 || DECL_INITIAL (decl
) == error_mark_node
)
7509 TREE_PUBLIC (decl
) = 1;
7510 DECL_COMMON (decl
) = 1;
7512 /* else we lose. We can only do this if we can use common,
7513 which we can't if it has been initialized. */
7515 if (TREE_PUBLIC (decl
))
7516 DECL_ASSEMBLER_NAME (decl
)
7517 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7518 else if (! DECL_ARTIFICIAL (decl
))
7520 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7521 cp_warning_at (" you can work around this by removing the initializer", decl
);
7525 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
7526 /* Set it up again; we might have set DECL_INITIAL since the last
7528 comdat_linkage (decl
);
7531 /* Issue an error message if DECL is an uninitialized const variable. */
7534 check_for_uninitialized_const_var (decl
)
7537 tree type
= TREE_TYPE (decl
);
7539 /* ``Unless explicitly declared extern, a const object does not have
7540 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7542 if (TREE_CODE (decl
) == VAR_DECL
7543 && TREE_CODE (type
) != REFERENCE_TYPE
7544 && CP_TYPE_CONST_P (type
)
7545 && !TYPE_NEEDS_CONSTRUCTING (type
)
7546 && !DECL_INITIAL (decl
))
7547 cp_error ("uninitialized const `%D'", decl
);
7550 /* Verify INITP (the initializer for DECL), and record the
7551 initialization in DECL_INITIAL, if appropriate. The initializer
7552 may be modified by this function. */
7555 check_initializer (decl
, initp
)
7562 if (TREE_CODE (decl
) == FIELD_DECL
)
7565 type
= TREE_TYPE (decl
);
7568 /* If `start_decl' didn't like having an initialization, ignore it now. */
7569 if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7571 else if (DECL_EXTERNAL (decl
))
7573 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
7575 if (TREE_STATIC (decl
))
7576 make_decl_rtl (decl
, NULL_PTR
, toplevel_bindings_p ());
7577 grok_reference_init (decl
, type
, init
);
7581 /* Check for certain invalid initializations. */
7584 if (TYPE_SIZE (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
7586 cp_error ("variable-sized object `%D' may not be initialized", decl
);
7589 if (TREE_CODE (type
) == ARRAY_TYPE
7590 && !TYPE_SIZE (complete_type (TREE_TYPE (type
))))
7592 cp_error ("elements of array `%#D' have incomplete type", decl
);
7597 if (TREE_CODE (decl
) == CONST_DECL
)
7599 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7601 DECL_INITIAL (decl
) = init
;
7603 /* This will keep us from needing to worry about our obstacks. */
7604 my_friendly_assert (init
!= NULL_TREE
, 149);
7609 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7611 if (TREE_CODE (type
) == ARRAY_TYPE
)
7612 init
= digest_init (type
, init
, (tree
*) 0);
7613 else if (TREE_CODE (init
) == CONSTRUCTOR
7614 && TREE_HAS_CONSTRUCTOR (init
))
7616 if (TYPE_NON_AGGREGATE_CLASS (type
))
7618 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7620 init
= error_mark_node
;
7623 goto dont_use_constructor
;
7628 dont_use_constructor
:
7629 if (TREE_CODE (init
) != TREE_VEC
)
7630 init
= store_init_value (decl
, init
);
7634 /* We must hide the initializer so that expand_decl
7635 won't try to do something it does not understand. */
7636 init
= obscure_complex_init (decl
, init
);
7638 else if (DECL_EXTERNAL (decl
))
7640 else if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't'
7641 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7643 tree core_type
= strip_array_types (type
);
7645 if (! TYPE_NEEDS_CONSTRUCTING (core_type
))
7647 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
7648 cp_error ("structure `%D' with uninitialized const members", decl
);
7649 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
7650 cp_error ("structure `%D' with uninitialized reference members",
7654 check_for_uninitialized_const_var (decl
);
7656 if (TYPE_SIZE (type
) != NULL_TREE
7657 && TYPE_NEEDS_CONSTRUCTING (type
))
7658 init
= obscure_complex_init (decl
, NULL_TREE
);
7662 check_for_uninitialized_const_var (decl
);
7664 /* Store the modified initializer for our caller. */
7668 /* If DECL is not a local variable, give it RTL. */
7671 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
)
7674 const char *asmspec
;
7679 type
= TREE_TYPE (decl
);
7680 toplev
= toplevel_bindings_p ();
7681 push_obstacks_nochange ();
7682 if (TREE_STATIC (decl
)
7683 && TYPE_NEEDS_DESTRUCTOR (type
)
7684 && allocation_temporary_p ())
7685 end_temporary_allocation ();
7687 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
7688 make_decl_rtl (decl
, NULL_PTR
, toplev
);
7689 else if (TREE_CODE (decl
) == VAR_DECL
7690 && TREE_READONLY (decl
)
7691 && DECL_INITIAL (decl
) != NULL_TREE
7692 && DECL_INITIAL (decl
) != error_mark_node
7693 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7695 DECL_INITIAL (decl
) = save_expr (DECL_INITIAL (decl
));
7698 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7701 && TREE_STATIC (decl
)
7702 && ! TREE_SIDE_EFFECTS (decl
)
7703 && ! TREE_PUBLIC (decl
)
7704 && ! DECL_EXTERNAL (decl
)
7705 && ! TYPE_NEEDS_DESTRUCTOR (type
)
7706 && DECL_MODE (decl
) != BLKmode
)
7708 /* If this variable is really a constant, then fill its DECL_RTL
7709 slot with something which won't take up storage.
7710 If something later should take its address, we can always give
7711 it legitimate RTL at that time. */
7712 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
7713 store_expr (DECL_INITIAL (decl
), DECL_RTL (decl
), 0);
7714 TREE_ASM_WRITTEN (decl
) = 1;
7716 else if (toplev
&& ! TREE_PUBLIC (decl
))
7718 /* If this is a static const, change its apparent linkage
7719 if it belongs to a #pragma interface. */
7720 if (!interface_unknown
)
7722 TREE_PUBLIC (decl
) = 1;
7723 DECL_EXTERNAL (decl
) = interface_only
;
7725 make_decl_rtl (decl
, asmspec
, toplev
);
7728 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7730 else if (TREE_CODE (decl
) == VAR_DECL
7731 && DECL_LANG_SPECIFIC (decl
)
7732 && DECL_IN_AGGR_P (decl
))
7734 my_friendly_assert (TREE_STATIC (decl
), 19990828);
7736 if (init
== NULL_TREE
7737 #ifdef DEFAULT_STATIC_DEFS
7738 /* If this code is dead, then users must
7739 explicitly declare static member variables
7740 outside the class def'n as well. */
7741 && TYPE_NEEDS_CONSTRUCTING (type
)
7745 DECL_EXTERNAL (decl
) = 1;
7746 make_decl_rtl (decl
, asmspec
, 1);
7749 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7752 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7757 /* The old ARM scoping rules injected variables declared in the
7758 initialization statement of a for-statement into the surrounding
7759 scope. We support this usage, in order to be backward-compatible.
7760 DECL is a just-declared VAR_DECL; if necessary inject its
7761 declaration into the surrounding scope. */
7764 maybe_inject_for_scope_var (decl
)
7767 if (current_binding_level
->is_for_scope
)
7769 struct binding_level
*outer
7770 = current_binding_level
->level_chain
;
7772 /* Check to see if the same name is already bound at the outer
7773 level, either because it was directly declared, or because a
7774 dead for-decl got preserved. In either case, the code would
7775 not have been valid under the ARM scope rules, so clear
7776 is_for_scope for the current_binding_level.
7778 Otherwise, we need to preserve the temp slot for decl to last
7779 into the outer binding level. */
7782 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl
)));
7784 if (outer_binding
&& BINDING_LEVEL (outer_binding
) == outer
7785 && (TREE_CODE (BINDING_VALUE (outer_binding
))
7787 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding
)))
7789 BINDING_VALUE (outer_binding
)
7790 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding
));
7791 current_binding_level
->is_for_scope
= 0;
7793 else if (DECL_IN_MEMORY_P (decl
))
7794 preserve_temp_slots (DECL_RTL (decl
));
7798 /* Generate code to initialized DECL (a local variable). */
7801 initialize_local_var (decl
, init
, flags
)
7809 type
= TREE_TYPE (decl
);
7811 cleanup
= build_cleanup_on_safe_obstack (decl
);
7813 if (DECL_SIZE (decl
) == NULL_TREE
&& !TREE_STATIC (decl
))
7815 /* If we used it already as memory, it must stay in memory. */
7816 DECL_INITIAL (decl
) = NULL_TREE
;
7817 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7820 if (DECL_RTL (decl
))
7821 /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7822 All other local variables are assigned RTL in this function. */
7823 my_friendly_assert (TREE_CODE (decl
) == RESULT_DECL
, 19990828);
7825 /* Create RTL for this variable. */
7828 expand_start_target_temps ();
7830 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7834 /* Compute and store the initial value. */
7835 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7837 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7839 emit_line_note (DECL_SOURCE_FILE (decl
),
7840 DECL_SOURCE_LINE (decl
));
7841 /* We call push_momentary here so that when
7842 finish_expr_stmt clears the momentary obstack it
7843 doesn't destory any momentary expressions we may
7844 have lying around. Although cp_finish_decl is
7845 usually called at the end of a declaration
7846 statement, it may also be called for a temporary
7847 object in the middle of an expression. */
7849 finish_expr_stmt (build_aggr_init (decl
, init
, flags
));
7853 expand_decl_init (decl
);
7855 /* Set this to 0 so we can tell whether an aggregate which was
7856 initialized was ever used. Don't do this if it has a
7857 destructor, so we don't complain about the 'resource
7858 allocation is initialization' idiom. Now set
7859 attribute((unused)) on types so decls of that type will be
7860 marked used. (see TREE_USED, above.) */
7861 if (TYPE_NEEDS_CONSTRUCTING (type
)
7863 && cleanup
== NULL_TREE
7864 && DECL_NAME (decl
))
7865 TREE_USED (decl
) = 0;
7866 else if (already_used
)
7867 TREE_USED (decl
) = 1;
7870 /* Cleanup any temporaries needed for the initial value. */
7871 expand_end_target_temps ();
7873 /* Record the cleanup required for this declaration. */
7874 if (DECL_SIZE (decl
)
7875 && type
!= error_mark_node
7877 && !expand_decl_cleanup (decl
, cleanup
))
7878 cp_error ("parser lost in parsing declaration of `%D'", decl
);
7881 /* Finish processing of a declaration;
7882 install its line number and initial value.
7883 If the length of an array type is not known before,
7884 it must be determined now, from the initial value, or it is an error.
7886 Call `pop_obstacks' iff NEED_POP is nonzero.
7888 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
7889 for aggregates that have constructors alive on the permanent obstack,
7890 so that the global initializing functions can be written at the end.
7892 INIT0 holds the value of an initializer that should be allowed to escape
7895 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7896 if the (init) syntax was used.
7898 For functions that take default parameters, DECL points to its
7899 "maximal" instantiation. `cp_finish_decl' must then also declared its
7900 subsequently lower and lower forms of instantiation, checking for
7901 ambiguity as it goes. This can be sped up later. */
7904 cp_finish_decl (decl
, init
, asmspec_tree
, need_pop
, flags
)
7911 tree ttype
= NULL_TREE
;
7912 int temporary
= allocation_temporary_p ();
7913 const char *asmspec
= NULL
;
7914 int was_readonly
= 0;
7916 /* If this is 0, then we did not change obstacks. */
7920 error ("assignment (not initialization) in declaration");
7924 /* If a name was specified, get the string. */
7926 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
7928 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
7930 cp_error ("Cannot initialize `%D' to namespace `%D'",
7935 if (current_class_type
7936 && DECL_REAL_CONTEXT (decl
) == current_class_type
7937 && TYPE_BEING_DEFINED (current_class_type
)
7938 && (DECL_INITIAL (decl
) || init
))
7939 DECL_DEFINED_IN_CLASS_P (decl
) = 1;
7941 if (TREE_CODE (decl
) == VAR_DECL
7942 && DECL_CONTEXT (decl
)
7943 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
7944 && DECL_CONTEXT (decl
) != current_namespace
7947 /* Leave the namespace of the object. */
7948 pop_decl_namespace ();
7951 type
= complete_type (TREE_TYPE (decl
));
7953 if (type
== error_mark_node
)
7955 if (toplevel_bindings_p () && temporary
)
7956 end_temporary_allocation ();
7961 if (TYPE_HAS_MUTABLE_P (type
))
7962 TREE_READONLY (decl
) = 0;
7964 if (processing_template_decl
)
7966 if (init
&& DECL_INITIAL (decl
))
7967 DECL_INITIAL (decl
) = copy_to_permanent (init
);
7971 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
7972 my_friendly_assert (TREE_CODE (decl
) != PARM_DECL
, 19990828);
7974 /* Take care of TYPE_DECLs up front. */
7975 if (TREE_CODE (decl
) == TYPE_DECL
)
7977 if (init
&& DECL_INITIAL (decl
))
7979 /* typedef foo = bar; store the type of bar as the type of foo. */
7980 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
7981 DECL_INITIAL (decl
) = init
= NULL_TREE
;
7983 if (type
!= error_mark_node
7984 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
7986 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7987 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
7988 set_identifier_type_value (DECL_NAME (decl
), type
);
7989 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
7991 GNU_xref_decl (current_function_decl
, decl
);
7993 /* If we have installed this as the canonical typedef for this
7994 type, and that type has not been defined yet, delay emitting
7995 the debug information for it, as we will emit it later. */
7996 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7997 && TYPE_SIZE (TREE_TYPE (decl
)) == NULL_TREE
)
7998 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
8000 rest_of_decl_compilation (decl
, NULL_PTR
,
8001 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
8005 if (TREE_CODE (decl
) != FUNCTION_DECL
)
8006 ttype
= target_type (type
);
8008 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
8009 && TYPE_NEEDS_CONSTRUCTING (type
))
8011 /* Currently, GNU C++ puts constants in text space, making them
8012 impossible to initialize. In the future, one would hope for
8013 an operating system which understood the difference between
8014 initialization and the running of a program. */
8016 TREE_READONLY (decl
) = 0;
8019 if (TREE_CODE (decl
) == FIELD_DECL
&& asmspec
)
8021 /* This must override the asm specifier which was placed by
8022 grokclassfn. Lay this out fresh. */
8023 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
8024 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
8025 make_decl_rtl (decl
, asmspec
, 0);
8028 check_initializer (decl
, &init
);
8030 GNU_xref_decl (current_function_decl
, decl
);
8032 /* For top-level declaration, the initial value was read in
8033 the temporary obstack. MAXINDEX, rtl, etc. to be made below
8034 must go in the permanent obstack; but don't discard the
8035 temporary data yet. */
8037 if (toplevel_bindings_p () && temporary
)
8038 end_temporary_allocation ();
8040 /* Deduce size of array from initialization, if not already known. */
8041 maybe_deduce_size_from_array_init (decl
, init
);
8043 if (TREE_CODE (decl
) == VAR_DECL
)
8044 layout_var_decl (decl
, &init
);
8046 /* Output the assembler code and/or RTL code for variables and functions,
8047 unless the type is an undefined structure or union.
8048 If not, it will get done when the type is completed. */
8049 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
8050 || TREE_CODE (decl
) == RESULT_DECL
)
8052 /* ??? FIXME: What about nested classes? */
8053 int toplev
= toplevel_bindings_p ();
8055 if (TREE_CODE (decl
) == VAR_DECL
)
8056 maybe_commonize_var (decl
);
8058 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
8060 if (TREE_CODE (type
) == FUNCTION_TYPE
8061 || TREE_CODE (type
) == METHOD_TYPE
)
8062 abstract_virtuals_error (decl
,
8063 strip_array_types (TREE_TYPE (type
)));
8065 abstract_virtuals_error (decl
, strip_array_types (type
));
8067 if (TREE_CODE (decl
) == FUNCTION_DECL
)
8069 else if (DECL_EXTERNAL (decl
)
8070 && ! (DECL_LANG_SPECIFIC (decl
)
8071 && DECL_NOT_REALLY_EXTERN (decl
)))
8074 DECL_INITIAL (decl
) = init
;
8076 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
8078 /* Cleanups for static variables are handled by `finish_file'. */
8079 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
8080 || TYPE_NEEDS_DESTRUCTOR (type
))
8081 expand_static_init (decl
, init
);
8085 /* This is a local declaration. */
8086 maybe_inject_for_scope_var (decl
);
8087 /* Initialize the local variable. But, if we're building a
8088 statement-tree, we'll do the initialization when we
8090 if (!building_stmt_tree ())
8091 initialize_local_var (decl
, init
, flags
);
8092 else if (init
|| DECL_INITIAL (decl
) == error_mark_node
)
8093 DECL_INITIAL (decl
) = init
;
8097 /* Undo call to `pushclass' that was done in `start_decl'
8098 due to initialization of qualified member variable.
8099 I.e., Foo::x = 10; */
8101 tree context
= DECL_REAL_CONTEXT (decl
);
8103 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't'
8104 && (TREE_CODE (decl
) == VAR_DECL
8105 /* We also have a pushclass done that we need to undo here
8106 if we're at top level and declare a method. */
8107 || TREE_CODE (decl
) == FUNCTION_DECL
)
8108 /* If size hasn't been set, we're still defining it,
8109 and therefore inside the class body; don't pop
8110 the binding level.. */
8111 && TYPE_SIZE (context
) != NULL_TREE
8112 && context
== current_class_type
)
8113 pop_nested_class ();
8119 /* If requested, warn about definitions of large data objects. */
8121 if (warn_larger_than
8122 && ! processing_template_decl
8123 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
8124 && !DECL_EXTERNAL (decl
))
8126 register tree decl_size
= DECL_SIZE (decl
);
8128 if (decl_size
&& TREE_CODE (decl_size
) == INTEGER_CST
)
8130 unsigned units
= TREE_INT_CST_LOW (decl_size
) / BITS_PER_UNIT
;
8132 if (units
> larger_than_size
)
8133 warning_with_decl (decl
, "size of `%s' is %u bytes", units
);
8138 /* Resume permanent allocation, if not within a function. The
8139 corresponding push_obstacks_nochange is in start_decl,
8140 start_method, groktypename, and in grokfield. */
8144 TREE_READONLY (decl
) = 1;
8147 /* This is here for a midend callback from c-common.c */
8150 finish_decl (decl
, init
, asmspec_tree
)
8154 cp_finish_decl (decl
, init
, asmspec_tree
, 1, 0);
8158 expand_static_init (decl
, init
)
8162 tree oldstatic
= value_member (decl
, static_aggregates
);
8166 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
8167 cp_error ("multiple initializations given for `%D'", decl
);
8169 else if (! toplevel_bindings_p ())
8171 /* Emit code to perform this initialization but once. */
8177 /* Remember this information until end of file. */
8178 push_obstacks (&permanent_obstack
, &permanent_obstack
);
8180 /* Emit code to perform this initialization but once. This code
8183 static int temp = 0;
8185 // Do initialization.
8187 // Register variable for destruction at end of program.
8190 Note that the `temp' variable is only set to 1 *after* the
8191 initialization is complete. This ensures that an exception,
8192 thrown during the construction, will cause the variable to
8193 reinitialized when we pass through this code again, as per:
8197 If the initialization exits by throwing an exception, the
8198 initialization is not complete, so it will be tried again
8199 the next time control enters the declaration.
8201 In theory, this process should be thread-safe, too; multiple
8202 threads should not be able to initialize the variable more
8203 than once. We don't yet attempt to ensure thread-safety. */
8204 temp
= get_temp_name (integer_type_node
, 1);
8205 rest_of_decl_compilation (temp
, NULL_PTR
, 0, 0);
8207 /* Begin the conditional initialization. */
8208 if_stmt
= begin_if_stmt ();
8209 finish_if_stmt_cond (build_binary_op (EQ_EXPR
, temp
,
8213 /* Do the initialization itself. */
8214 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
8215 || (init
&& TREE_CODE (init
) == TREE_LIST
))
8216 assignment
= build_aggr_init (decl
, init
, 0);
8218 /* The initialization we're doing here is just a bitwise
8220 assignment
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, init
);
8222 assignment
= NULL_TREE
;
8224 /* Once the assignment is complete, set TEMP to 1. Since the
8225 construction of the static object is complete at this point,
8226 we want to make sure TEMP is set to 1 even if a temporary
8227 constructed during the initialization throws an exception
8228 when it is destroyed. So, we combine the initialization and
8229 the assignment to TEMP into a single expression, ensuring
8230 that when we call finish_expr_stmt the cleanups will not be
8231 run until after TEMP is set to 1. */
8232 temp_init
= build_modify_expr (temp
, NOP_EXPR
, integer_one_node
);
8235 assignment
= tree_cons (NULL_TREE
, assignment
,
8236 build_tree_list (NULL_TREE
,
8238 assignment
= build_compound_expr (assignment
);
8241 assignment
= temp_init
;
8242 finish_expr_stmt (assignment
);
8244 /* Use atexit to register a function for destroying this static
8246 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
8248 tree cleanup
, fcall
;
8249 static tree Atexit
= 0;
8250 int saved_flag_access_control
;
8254 tree atexit_fndecl
, PFV
, pfvlist
;
8255 /* Remember this information until end of file. */
8256 push_obstacks (&permanent_obstack
, &permanent_obstack
);
8257 PFV
= build_pointer_type (build_function_type
8258 (void_type_node
, void_list_node
));
8260 pfvlist
= tree_cons (NULL_TREE
, PFV
, void_list_node
);
8262 push_lang_context (lang_name_c
);
8263 /* Note that we do not call pushdecl for this function;
8264 there's no reason that this declaration should be
8265 accessible to anyone. */
8267 = define_function ("atexit",
8268 build_function_type (void_type_node
,
8273 mark_used (atexit_fndecl
);
8274 Atexit
= default_conversion (atexit_fndecl
);
8275 pop_lang_context ();
8279 /* Call build_cleanup before we enter the anonymous function
8280 so that any access checks will be done relative to the
8281 current scope, rather than the scope of the anonymous
8283 build_cleanup (decl
);
8285 /* Now start the function. */
8286 cleanup
= start_anon_func ();
8288 /* Now, recompute the cleanup. It may contain SAVE_EXPRs
8289 that refer to the original function, rather than the
8290 anonymous one. That will make the back-end think that
8291 nested functions are in use, which causes confusion. */
8292 saved_flag_access_control
= flag_access_control
;
8293 flag_access_control
= 0;
8294 fcall
= build_cleanup (decl
);
8295 flag_access_control
= saved_flag_access_control
;
8297 /* Finish off the function. */
8298 expand_expr_stmt (fcall
);
8301 /* Call atexit with the cleanup function. */
8302 mark_addressable (cleanup
);
8303 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
8304 fcall
= build_function_call (Atexit
,
8305 expr_tree_cons (NULL_TREE
,
8308 finish_expr_stmt (fcall
);
8311 finish_then_clause (if_stmt
);
8314 /* Resume old (possibly temporary) allocation. */
8319 /* This code takes into account memory allocation policy of
8320 `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING does not
8321 hold for this object, then we must make permanent the storage
8322 currently in the temporary obstack. */
8323 if (!TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
8324 preserve_initializer ();
8325 static_aggregates
= perm_tree_cons (init
, decl
, static_aggregates
);
8329 /* Finish the declaration of a catch-parameter. */
8332 start_handler_parms (declspecs
, declarator
)
8339 decl
= grokdeclarator (declarator
, declspecs
, CATCHPARM
,
8341 if (decl
== NULL_TREE
)
8342 error ("invalid catch parameter");
8346 expand_start_catch_block (decl
);
8350 /* Make TYPE a complete type based on INITIAL_VALUE.
8351 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8352 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8355 complete_array_type (type
, initial_value
, do_default
)
8356 tree type
, initial_value
;
8359 register tree maxindex
= NULL_TREE
;
8362 /* Allocate on the same obstack as TYPE. */
8363 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8367 /* Note MAXINDEX is really the maximum index,
8368 one less than the size. */
8369 if (TREE_CODE (initial_value
) == STRING_CST
)
8372 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8373 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
8376 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8378 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
8379 maxindex
= size_binop (MINUS_EXPR
, integer_zero_node
, size_one_node
);
8380 for (; elts
; elts
= TREE_CHAIN (elts
))
8382 if (TREE_PURPOSE (elts
))
8383 maxindex
= TREE_PURPOSE (elts
);
8385 maxindex
= size_binop (PLUS_EXPR
, maxindex
, size_one_node
);
8387 maxindex
= copy_node (maxindex
);
8391 /* Make an error message unless that happened already. */
8392 if (initial_value
!= error_mark_node
)
8395 initial_value
= NULL_TREE
;
8397 /* Prevent further error messages. */
8398 maxindex
= build_int_2 (0, 0);
8405 maxindex
= build_int_2 (0, 0);
8414 domain
= build_index_type (maxindex
);
8415 TYPE_DOMAIN (type
) = domain
;
8417 if (! TREE_TYPE (maxindex
))
8418 TREE_TYPE (maxindex
) = domain
;
8420 itype
= TREE_TYPE (initial_value
);
8423 if (itype
&& !TYPE_DOMAIN (itype
))
8424 TYPE_DOMAIN (itype
) = domain
;
8425 /* The type of the main variant should never be used for arrays
8426 of different sizes. It should only ever be completed with the
8427 size of the array. */
8428 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
8429 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = domain
;
8434 /* Lay out the type now that we can get the real answer. */
8441 /* Return zero if something is declared to be a member of type
8442 CTYPE when in the context of CUR_TYPE. STRING is the error
8443 message to print in that case. Otherwise, quietly return 1. */
8446 member_function_or_else (ctype
, cur_type
, string
)
8447 tree ctype
, cur_type
;
8450 if (ctype
&& ctype
!= cur_type
)
8452 error (string
, TYPE_NAME_STRING (ctype
));
8458 /* Subroutine of `grokdeclarator'. */
8460 /* Generate errors possibly applicable for a given set of specifiers.
8461 This is for ARM $7.1.2. */
8464 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
8467 int virtualp
, quals
, friendp
, raises
, inlinep
;
8470 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
8472 cp_error ("`%D' declared as an `inline' %s", object
, type
);
8474 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8477 cp_error_at ("`%D' declared as a friend", object
);
8479 cp_error_at ("`%D' declared with an exception specification", object
);
8482 /* CTYPE is class type, or null if non-class.
8483 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8485 DECLARATOR is the function's name.
8486 VIRTUALP is truthvalue of whether the function is virtual or not.
8487 FLAGS are to be passed through to `grokclassfn'.
8488 QUALS are qualifiers indicating whether the function is `const'
8490 RAISES is a list of exceptions that this function can raise.
8491 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8492 not look, and -1 if we should not call `grokclassfn' at all.
8494 Returns `NULL_TREE' if something goes wrong, after issuing
8495 applicable error messages. */
8498 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8499 raises
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8500 template_count
, in_namespace
)
8503 tree orig_declarator
;
8505 enum overload_flags flags
;
8507 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8511 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8512 int has_default_arg
= 0;
8516 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8517 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8523 type
= build_exception_variant (type
, raises
);
8526 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8527 /* Propagate volatile out from type to decl. */
8528 if (TYPE_VOLATILE (type
))
8529 TREE_THIS_VOLATILE (decl
) = 1;
8531 /* If this decl has namespace scope, set that up. */
8533 set_decl_namespace (decl
, in_namespace
, friendp
);
8534 else if (publicp
&& ! ctype
)
8535 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8537 /* `main' and builtins have implicit 'C' linkage. */
8538 if ((MAIN_NAME_P (declarator
)
8539 || (IDENTIFIER_LENGTH (declarator
) > 10
8540 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8541 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8542 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8543 && current_lang_name
== lang_name_cplusplus
8544 && ctype
== NULL_TREE
8545 /* NULL_TREE means global namespace. */
8546 && DECL_CONTEXT (decl
) == NULL_TREE
)
8547 DECL_LANGUAGE (decl
) = lang_c
;
8549 /* Should probably propagate const out from type to decl I bet (mrs). */
8552 DECL_STATIC_FUNCTION_P (decl
) = 1;
8553 DECL_CONTEXT (decl
) = ctype
;
8557 DECL_CLASS_CONTEXT (decl
) = ctype
;
8559 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8561 if (processing_template_decl
)
8562 error ("cannot declare `main' to be a template");
8564 error ("cannot declare `main' to be inline");
8566 error ("cannot declare `main' to be static");
8571 /* Members of anonymous types and local classes have no linkage; make
8573 if (ctype
&& (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
))
8574 || hack_decl_function_context (TYPE_MAIN_DECL (ctype
))))
8579 /* [basic.link]: A name with no linkage (notably, the name of a class
8580 or enumeration declared in a local scope) shall not be used to
8581 declare an entity with linkage.
8583 Only check this for public decls for now. */
8584 t
= no_linkage_check (TREE_TYPE (decl
));
8587 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8589 if (DECL_LANGUAGE (decl
) == lang_c
)
8590 /* Allow this; it's pretty common in C. */;
8592 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8596 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8601 TREE_PUBLIC (decl
) = publicp
;
8604 DECL_INTERFACE_KNOWN (decl
) = 1;
8605 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8609 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8611 DECL_EXTERNAL (decl
) = 1;
8612 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8614 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8615 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8619 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8620 grok_op_properties (decl
, virtualp
, check
< 0);
8622 if (ctype
&& hack_decl_function_context (decl
))
8623 DECL_NO_STATIC_CHAIN (decl
) = 1;
8625 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8626 if (TREE_PURPOSE (t
)
8627 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8629 has_default_arg
= 1;
8634 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8638 ("defining explicit specialization `%D' in friend declaration",
8642 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8644 /* Something like `template <class T> friend void f<T>()'. */
8645 cp_error ("template-id `%D' in declaration of primary template",
8651 /* A friend declaration of the form friend void f<>(). Record
8652 the information in the TEMPLATE_ID_EXPR. */
8653 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8654 DECL_TEMPLATE_INFO (decl
)
8655 = perm_tree_cons (TREE_OPERAND (orig_declarator
, 0),
8656 TREE_OPERAND (orig_declarator
, 1),
8659 if (has_default_arg
)
8661 cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8668 cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8675 if (has_default_arg
)
8676 add_defarg_fn (decl
);
8678 /* Plain overloading: will not be grok'd by grokclassfn. */
8679 if (! ctype
&& ! processing_template_decl
8680 && DECL_LANGUAGE (decl
) != lang_c
8681 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
8682 set_mangled_name_for_decl (decl
);
8685 /* Make the init_value nonzero so pushdecl knows this is not
8686 tentative. error_mark_node is replaced later with the BLOCK. */
8687 DECL_INITIAL (decl
) = error_mark_node
;
8689 /* Caller will do the rest of this. */
8693 if (check
&& funcdef_flag
)
8694 DECL_INITIAL (decl
) = error_mark_node
;
8696 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8699 /* Just handle constructors here. We could do this
8700 inside the following if stmt, but I think
8701 that the code is more legible by breaking this
8702 case out. See comments below for what each of
8703 the following calls is supposed to do. */
8704 DECL_CONSTRUCTOR_P (decl
) = 1;
8706 grokclassfn (ctype
, decl
, flags
, quals
);
8708 decl
= check_explicit_specialization (orig_declarator
, decl
,
8710 2 * (funcdef_flag
!= 0) +
8711 4 * (friendp
!= 0));
8712 if (decl
== error_mark_node
)
8715 if ((! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8718 tmp
= check_classfn (ctype
, decl
);
8720 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8721 tmp
= DECL_TEMPLATE_RESULT(tmp
);
8723 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8724 cp_error ("definition of implicitly-declared `%D'", tmp
);
8725 if (tmp
&& duplicate_decls (decl
, tmp
))
8728 if (! grok_ctor_properties (ctype
, decl
))
8735 /* Function gets the ugly name, field gets the nice one.
8736 This call may change the type of the function (because
8737 of default parameters)! */
8738 if (ctype
!= NULL_TREE
)
8739 grokclassfn (ctype
, decl
, flags
, quals
);
8741 decl
= check_explicit_specialization (orig_declarator
, decl
,
8743 2 * (funcdef_flag
!= 0) +
8744 4 * (friendp
!= 0));
8745 if (decl
== error_mark_node
)
8748 if (ctype
!= NULL_TREE
8749 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8752 tmp
= check_classfn (ctype
, decl
);
8754 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8755 tmp
= DECL_TEMPLATE_RESULT (tmp
);
8757 if (tmp
&& DECL_STATIC_FUNCTION_P (tmp
)
8758 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8760 /* Remove the `this' parm added by grokclassfn.
8761 XXX Isn't this done in start_function, too? */
8762 revert_static_member_fn (&decl
, NULL
, NULL
);
8763 last_function_parms
= TREE_CHAIN (last_function_parms
);
8765 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8766 cp_error ("definition of implicitly-declared `%D'", tmp
);
8769 /* Attempt to merge the declarations. This can fail, in
8770 the case of some illegal specialization declarations. */
8771 if (!duplicate_decls (decl
, tmp
))
8772 cp_error ("no `%#D' member function declared in class `%T'",
8778 if (ctype
== NULL_TREE
|| check
)
8783 DECL_VIRTUAL_P (decl
) = 1;
8784 if (DECL_VINDEX (decl
) == NULL_TREE
)
8785 DECL_VINDEX (decl
) = error_mark_node
;
8786 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
8793 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
8796 RID_BIT_TYPE
*specbits_in
;
8802 RID_BIT_TYPE specbits
;
8804 specbits
= *specbits_in
;
8806 if (TREE_CODE (type
) == OFFSET_TYPE
)
8808 /* If you declare a static member so that it
8809 can be initialized, the code will reach here. */
8810 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
8811 type
= TREE_TYPE (type
);
8812 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
8813 DECL_CONTEXT (decl
) = basetype
;
8814 DECL_CLASS_CONTEXT (decl
) = basetype
;
8815 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
, declarator
);
8822 context
= in_namespace
;
8823 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
8824 context
= current_namespace
;
8826 context
= NULL_TREE
;
8828 if (processing_template_decl
)
8830 /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8831 we can call push_template_decl. */
8832 push_permanent_obstack ();
8833 decl
= build_lang_decl (VAR_DECL
, declarator
,
8834 complete_type (type
));
8838 decl
= build_decl (VAR_DECL
, declarator
, complete_type (type
));
8841 set_decl_namespace (decl
, context
, 0);
8843 context
= DECL_CONTEXT (decl
);
8844 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
8845 DECL_ASSEMBLER_NAME (decl
) = build_static_name (context
, declarator
);
8849 set_decl_namespace (decl
, in_namespace
, 0);
8851 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
8853 DECL_THIS_EXTERN (decl
) = 1;
8854 DECL_EXTERNAL (decl
) = !initialized
;
8857 /* In class context, static means one per class,
8858 public access, and static storage. */
8859 if (DECL_CLASS_SCOPE_P (decl
))
8861 TREE_PUBLIC (decl
) = 1;
8862 TREE_STATIC (decl
) = 1;
8863 DECL_EXTERNAL (decl
) = 0;
8865 /* At top level, either `static' or no s.c. makes a definition
8866 (perhaps tentative), and absence of `static' makes it public. */
8867 else if (toplevel_bindings_p ())
8869 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
8870 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8871 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8873 /* Not at top level, only `static' makes a static definition. */
8876 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
8877 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8880 if (TREE_PUBLIC (decl
))
8882 /* [basic.link]: A name with no linkage (notably, the name of a class
8883 or enumeration declared in a local scope) shall not be used to
8884 declare an entity with linkage.
8886 Only check this for public decls for now. */
8887 tree t
= no_linkage_check (TREE_TYPE (decl
));
8890 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8891 /* Ignore for now; `enum { foo } e' is pretty common. */;
8893 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8901 /* Create and return a canonical pointer to member function type, for
8902 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8905 build_ptrmemfunc_type (type
)
8911 tree unqualified_variant
= NULL_TREE
;
8913 /* If a canonical type already exists for this type, use it. We use
8914 this method instead of type_hash_canon, because it only does a
8915 simple equality check on the list of field members. */
8917 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8920 /* Make sure that we always have the unqualified pointer-to-member
8922 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
8924 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8926 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8928 u
= make_lang_type (UNION_TYPE
);
8929 SET_IS_AGGR_TYPE (u
, 0);
8930 fields
[0] = build_lang_decl (FIELD_DECL
, pfn_identifier
, type
);
8931 fields
[1] = build_lang_decl (FIELD_DECL
, delta2_identifier
,
8933 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
8934 TYPE_NAME (u
) = NULL_TREE
;
8936 t
= make_lang_type (RECORD_TYPE
);
8938 /* Let the front-end know this is a pointer to member function... */
8939 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8940 /* ... and not really an aggregate. */
8941 SET_IS_AGGR_TYPE (t
, 0);
8943 fields
[0] = build_lang_decl (FIELD_DECL
, delta_identifier
,
8945 fields
[1] = build_lang_decl (FIELD_DECL
, index_identifier
,
8947 fields
[2] = build_lang_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
8948 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
8952 /* Zap out the name so that the back-end will give us the debugging
8953 information for this anonymous RECORD_TYPE. */
8954 TYPE_NAME (t
) = NULL_TREE
;
8956 /* If this is not the unqualified form of this pointer-to-member
8957 type, set the TYPE_MAIN_VARIANT for this type to be the
8958 unqualified type. Since they are actually RECORD_TYPEs that are
8959 not variants of each other, we must do this manually. */
8960 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
8962 t
= build_qualified_type (t
, CP_TYPE_QUALS (type
));
8963 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
8964 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
8965 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
8968 /* Cache this pointer-to-member type so that we can find it again
8970 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8972 /* Seems to be wanted. */
8973 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
8978 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8979 Check to see that the definition is valid. Issue appropriate error
8980 messages. Return 1 if the definition is particularly bad, or 0
8984 check_static_variable_definition (decl
, type
)
8988 /* Motion 10 at San Diego: If a static const integral data member is
8989 initialized with an integral constant expression, the initializer
8990 may appear either in the declaration (within the class), or in
8991 the definition, but not both. If it appears in the class, the
8992 member is a member constant. The file-scope definition is always
8994 if (CLASS_TYPE_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
8996 cp_error ("in-class initialization of static data member of non-integral type `%T'",
8998 /* If we just return the declaration, crashes will sometimes
8999 occur. We therefore return void_type_node, as if this was a
9000 friend declaration, to cause callers to completely ignore
9001 this declaration. */
9004 else if (!CP_TYPE_CONST_P (type
))
9005 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
9007 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
9008 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
9013 /* Given declspecs and a declarator,
9014 determine the name and type of the object declared
9015 and construct a ..._DECL node for it.
9016 (In one case we can return a ..._TYPE node instead.
9017 For invalid input we sometimes return 0.)
9019 DECLSPECS is a chain of tree_list nodes whose value fields
9020 are the storage classes and type specifiers.
9022 DECL_CONTEXT says which syntactic context this declaration is in:
9023 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9024 FUNCDEF for a function definition. Like NORMAL but a few different
9025 error messages in each case. Return value may be zero meaning
9026 this definition is too screwy to try to parse.
9027 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9028 handle member functions (which have FIELD context).
9029 Return value may be zero meaning this definition is too screwy to
9031 PARM for a parameter declaration (either within a function prototype
9032 or before a function body). Make a PARM_DECL, or return void_type_node.
9033 CATCHPARM for a parameter declaration before a catch clause.
9034 TYPENAME if for a typename (in a cast or sizeof).
9035 Don't make a DECL node; just return the ..._TYPE node.
9036 FIELD for a struct or union field; make a FIELD_DECL.
9037 BITFIELD for a field with specified width.
9038 INITIALIZED is 1 if the decl has an initializer.
9040 ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9041 normal attributes in TREE_PURPOSE, or NULL_TREE.
9043 In the TYPENAME case, DECLARATOR is really an absolute declarator.
9044 It may also be so in the PARM case, for a prototype where the
9045 argument type is specified but not the name.
9047 This function is where the complicated C meanings of `static'
9048 and `extern' are interpreted.
9050 For C++, if there is any monkey business to do, the function which
9051 calls this one must do it, i.e., prepending instance variables,
9052 renaming overloaded function names, etc.
9054 Note that for this C++, it is an error to define a method within a class
9055 which does not belong to that class.
9057 Except in the case where SCOPE_REFs are implicitly known (such as
9058 methods within a class being redundantly qualified),
9059 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9060 (class_name::decl_name). The caller must also deal with this.
9062 If a constructor or destructor is seen, and the context is FIELD,
9063 then the type gains the attribute TREE_HAS_x. If such a declaration
9064 is erroneous, NULL_TREE is returned.
9066 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
9067 function, these are the qualifiers to give to the `this' pointer.
9069 May return void_type_node if the declarator turned out to be a friend.
9070 See grokfield for details. */
9072 enum return_types
{ return_normal
, return_ctor
, return_dtor
, return_conversion
};
9075 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
9078 enum decl_context decl_context
;
9082 RID_BIT_TYPE specbits
;
9085 tree type
= NULL_TREE
;
9091 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9092 int explicit_int
= 0;
9093 int explicit_char
= 0;
9094 int defaulted_int
= 0;
9095 tree typedef_decl
= NULL_TREE
;
9097 tree typedef_type
= NULL_TREE
;
9098 int funcdef_flag
= 0;
9099 enum tree_code innermost_code
= ERROR_MARK
;
9102 /* See the code below that used this. */
9103 tree decl_machine_attr
= NULL_TREE
;
9105 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9106 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
9107 tree init
= NULL_TREE
;
9109 /* Keep track of what sort of function is being processed
9110 so that we can warn about default return values, or explicit
9111 return values which do not match prescribed defaults. */
9112 enum return_types return_type
= return_normal
;
9114 tree dname
= NULL_TREE
;
9115 tree ctype
= current_class_type
;
9116 tree ctor_return_type
= NULL_TREE
;
9117 enum overload_flags flags
= NO_SPECIAL
;
9118 tree quals
= NULL_TREE
;
9119 tree raises
= NULL_TREE
;
9120 int template_count
= 0;
9121 tree in_namespace
= NULL_TREE
;
9125 RIDBIT_RESET_ALL (specbits
);
9126 if (decl_context
== FUNCDEF
)
9127 funcdef_flag
= 1, decl_context
= NORMAL
;
9128 else if (decl_context
== MEMFUNCDEF
)
9129 funcdef_flag
= -1, decl_context
= FIELD
;
9130 else if (decl_context
== BITFIELD
)
9131 bitfield
= 1, decl_context
= FIELD
;
9133 /* Look inside a declarator for the name being declared
9134 and get it as a string, for an error message. */
9136 tree
*next
= &declarator
;
9140 while (next
&& *next
)
9143 switch (TREE_CODE (decl
))
9146 /* For attributes. */
9147 next
= &TREE_VALUE (decl
);
9152 next
= &TREE_OPERAND (decl
, 0);
9155 case BIT_NOT_EXPR
: /* For C++ destructors! */
9157 tree name
= TREE_OPERAND (decl
, 0);
9158 tree rename
= NULL_TREE
;
9160 my_friendly_assert (flags
== NO_SPECIAL
, 152);
9162 return_type
= return_dtor
;
9163 if (TREE_CODE (name
) == TYPE_DECL
)
9164 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
9165 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
9166 if (ctype
== NULL_TREE
)
9168 if (current_class_type
== NULL_TREE
)
9170 error ("destructors must be member functions");
9175 tree t
= constructor_name (current_class_name
);
9182 tree t
= constructor_name (ctype
);
9189 cp_error ("destructor `%T' must match class name `%T'",
9191 TREE_OPERAND (decl
, 0) = rename
;
9197 case ADDR_EXPR
: /* C++ reference declaration */
9202 innermost_code
= TREE_CODE (decl
);
9203 next
= &TREE_OPERAND (decl
, 0);
9207 if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl
)))
9209 /* This is actually a variable declaration using
9210 constructor syntax. We need to call start_decl and
9211 cp_finish_decl so we can get the variable
9214 tree attributes
, prefix_attributes
;
9216 *next
= TREE_OPERAND (decl
, 0);
9217 init
= CALL_DECLARATOR_PARMS (decl
);
9221 attributes
= TREE_PURPOSE (attrlist
);
9222 prefix_attributes
= TREE_VALUE (attrlist
);
9226 attributes
= NULL_TREE
;
9227 prefix_attributes
= NULL_TREE
;
9230 decl
= start_decl (declarator
, declspecs
, 1,
9231 attributes
, prefix_attributes
);
9234 /* Look for __unused__ attribute */
9235 if (TREE_USED (TREE_TYPE (decl
)))
9236 TREE_USED (decl
) = 1;
9237 finish_decl (decl
, init
, NULL_TREE
);
9240 cp_error ("invalid declarator");
9243 innermost_code
= TREE_CODE (decl
);
9244 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
9245 ctype
= current_class_type
;
9247 && TREE_OPERAND (decl
, 0)
9248 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
9249 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
9250 == constructor_name_full (ctype
))
9251 || (DECL_NAME (TREE_OPERAND (decl
, 0))
9252 == constructor_name (ctype
)))))
9253 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9254 next
= &TREE_OPERAND (decl
, 0);
9256 if (ctype
!= NULL_TREE
9257 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
9258 && decl
== constructor_name (ctype
))
9260 return_type
= return_ctor
;
9261 ctor_return_type
= ctype
;
9266 case TEMPLATE_ID_EXPR
:
9268 tree fns
= TREE_OPERAND (decl
, 0);
9270 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
9271 fns
= TREE_OPERAND (fns
, 0);
9274 if (TREE_CODE (dname
) == COMPONENT_REF
)
9275 dname
= TREE_OPERAND (dname
, 1);
9276 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
9278 my_friendly_assert (is_overloaded_fn (dname
),
9280 dname
= DECL_NAME (get_first_fn (dname
));
9285 case IDENTIFIER_NODE
:
9286 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
9293 cp_error ("declarator-id missing; using reserved word `%D'",
9295 name
= IDENTIFIER_POINTER (dname
);
9297 if (! IDENTIFIER_OPNAME_P (dname
)
9298 /* GNU/Linux headers use '__op'. Arrgh. */
9299 || (IDENTIFIER_TYPENAME_P (dname
) && ! TREE_TYPE (dname
)))
9300 name
= IDENTIFIER_POINTER (dname
);
9303 if (IDENTIFIER_TYPENAME_P (dname
))
9305 my_friendly_assert (flags
== NO_SPECIAL
, 154);
9306 flags
= TYPENAME_FLAG
;
9307 ctor_return_type
= TREE_TYPE (dname
);
9308 return_type
= return_conversion
;
9310 name
= operator_name_string (dname
);
9317 /* Perform error checking, and decide on a ctype. */
9318 tree cname
= TREE_OPERAND (decl
, 0);
9319 if (cname
== NULL_TREE
)
9321 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
9324 in_namespace
= TREE_OPERAND (decl
, 0);
9325 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9327 else if (! is_aggr_type (cname
, 1))
9328 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9329 /* Must test TREE_OPERAND (decl, 1), in case user gives
9330 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9331 else if (TREE_OPERAND (decl
, 1)
9332 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
9334 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
9335 || TREE_CODE (cname
) == TEMPLATE_TEMPLATE_PARM
)
9337 cp_error ("`%T::%D' is not a valid declarator", cname
,
9338 TREE_OPERAND (decl
, 1));
9339 cp_error (" perhaps you want `typename %T::%D' to make it a type",
9340 cname
, TREE_OPERAND (decl
, 1));
9341 return void_type_node
;
9343 else if (ctype
== NULL_TREE
)
9345 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
9346 TREE_OPERAND (decl
, 0) = ctype
;
9349 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
9351 cp_error ("type `%T' is not derived from type `%T'",
9353 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9359 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
9360 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
9361 == constructor_name_full (ctype
))
9362 || (DECL_NAME (TREE_OPERAND (decl
, 1))
9363 == constructor_name (ctype
))))
9364 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
9365 next
= &TREE_OPERAND (decl
, 1);
9369 if (TREE_CODE (decl
) == IDENTIFIER_NODE
9370 && constructor_name (ctype
) == decl
)
9372 return_type
= return_ctor
;
9373 ctor_return_type
= ctype
;
9375 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
9376 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
9377 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
9378 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
9380 return_type
= return_dtor
;
9381 ctor_return_type
= ctype
;
9383 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9384 next
= &TREE_OPERAND (decl
, 0);
9395 /* Parse error puts this typespec where
9396 a declarator should go. */
9397 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
9398 if (TREE_TYPE (decl
) == current_class_type
)
9399 cp_error (" perhaps you want `%T' for a constructor",
9400 current_class_name
);
9401 dname
= DECL_NAME (decl
);
9402 name
= IDENTIFIER_POINTER (dname
);
9404 /* Avoid giving two errors for this. */
9405 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
9407 declspecs
= temp_tree_cons (NULL_TREE
, integer_type_node
,
9414 cp_compiler_error ("`%D' as declarator", decl
);
9415 return 0; /* We used to do a 155 abort here. */
9422 /* A function definition's declarator must have the form of
9423 a function declarator. */
9425 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
9428 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
9429 && innermost_code
!= CALL_EXPR
9430 && ! (ctype
&& declspecs
== NULL_TREE
))
9432 cp_error ("declaration of `%D' as non-function", dname
);
9433 return void_type_node
;
9436 /* Anything declared one level down from the top level
9437 must be one of the parameters of a function
9438 (because the body is at least two levels down). */
9440 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9441 by not allowing C++ class definitions to specify their parameters
9442 with xdecls (must be spec.d in the parmlist).
9444 Since we now wait to push a class scope until we are sure that
9445 we are in a legitimate method context, we must set oldcname
9446 explicitly (since current_class_name is not yet alive).
9448 We also want to avoid calling this a PARM if it is in a namespace. */
9450 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9452 struct binding_level
*b
= current_binding_level
;
9453 current_binding_level
= b
->level_chain
;
9454 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9455 decl_context
= PARM
;
9456 current_binding_level
= b
;
9459 /* Look through the decl specs and record which ones appear.
9460 Some typespecs are defined as built-in typenames.
9461 Others, the ones that are modifiers of other types,
9462 are represented by bits in SPECBITS: set the bits for
9463 the modifiers that appear. Storage class keywords are also in SPECBITS.
9465 If there is a typedef name or a type, store the type in TYPE.
9466 This includes builtin typedefs such as `int'.
9468 Set EXPLICIT_INT if the type is `int' or `char' and did not
9469 come from a user typedef.
9471 Set LONGLONG if `long' is mentioned twice.
9473 For C++, constructors and destructors have their own fast treatment. */
9475 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
9480 /* Certain parse errors slip through. For example,
9481 `int class;' is not caught by the parser. Try
9482 weakly to recover here. */
9483 if (TREE_CODE (spec
) != TREE_LIST
)
9486 id
= TREE_VALUE (spec
);
9488 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9490 if (id
== ridpointers
[(int) RID_INT
]
9491 || id
== ridpointers
[(int) RID_CHAR
]
9492 || id
== ridpointers
[(int) RID_BOOL
]
9493 || id
== ridpointers
[(int) RID_WCHAR
])
9497 if (id
== ridpointers
[(int) RID_BOOL
])
9498 error ("`bool' is now a keyword");
9500 cp_error ("extraneous `%T' ignored", id
);
9504 if (id
== ridpointers
[(int) RID_INT
])
9506 else if (id
== ridpointers
[(int) RID_CHAR
])
9508 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
9512 /* C++ aggregate types. */
9513 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
9516 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
9518 type
= IDENTIFIER_TYPE_VALUE (id
);
9522 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
9524 if (ridpointers
[i
] == id
)
9526 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
9528 if (pedantic
&& ! in_system_header
&& warn_long_long
)
9529 pedwarn ("ANSI C++ does not support `long long'");
9531 error ("`long long long' is too long for GCC");
9535 else if (RIDBIT_SETP (i
, specbits
))
9536 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
9537 RIDBIT_SET (i
, specbits
);
9542 /* C++ aggregate types. */
9543 else if (TREE_CODE (id
) == TYPE_DECL
|| TREE_CODE (id
) == TEMPLATE_DECL
)
9546 cp_error ("multiple declarations `%T' and `%T'", type
,
9550 type
= TREE_TYPE (id
);
9551 TREE_VALUE (spec
) = type
;
9556 error ("two or more data types in declaration of `%s'", name
);
9557 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9559 register tree t
= lookup_name (id
, 1);
9560 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9561 error ("`%s' fails to be a typedef or built in type",
9562 IDENTIFIER_POINTER (id
));
9565 type
= TREE_TYPE (t
);
9567 /* See the code below that used this. */
9568 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
9573 else if (id
!= error_mark_node
)
9574 /* Can't change CLASS nodes into RECORD nodes here! */
9580 typedef_type
= type
;
9582 /* No type at all: default to `int', and set DEFAULTED_INT
9583 because it was not a user-defined typedef. */
9585 if (type
== NULL_TREE
9586 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
9587 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9588 || RIDBIT_SETP (RID_LONG
, specbits
)
9589 || RIDBIT_SETP (RID_SHORT
, specbits
)))
9591 /* These imply 'int'. */
9592 type
= integer_type_node
;
9596 if (type
== NULL_TREE
)
9599 if (return_type
== return_dtor
)
9600 type
= void_type_node
;
9601 else if (return_type
== return_ctor
)
9602 type
= build_pointer_type (ctor_return_type
);
9603 else if (return_type
== return_conversion
)
9604 type
= ctor_return_type
;
9607 /* We handle `main' specially here, because 'main () { }' is so
9608 common. With no options, it is allowed. With -Wreturn-type,
9609 it is a warning. It is only an error with -pedantic-errors. */
9610 int is_main
= (funcdef_flag
9611 && MAIN_NAME_P (dname
)
9612 && ctype
== NULL_TREE
9613 && in_namespace
== NULL_TREE
9614 && current_namespace
== global_namespace
);
9616 if (in_system_header
|| flag_ms_extensions
)
9617 /* Allow it, sigh. */;
9618 else if (pedantic
|| ! is_main
)
9619 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
9621 else if (warn_return_type
)
9622 cp_warning ("ANSI C++ forbids declaration `%D' with no type",
9625 type
= integer_type_node
;
9628 else if (return_type
== return_dtor
)
9630 error ("return type specification for destructor invalid");
9631 type
= void_type_node
;
9633 else if (return_type
== return_ctor
)
9635 error ("return type specification for constructor invalid");
9636 type
= build_pointer_type (ctor_return_type
);
9638 else if (return_type
== return_conversion
)
9640 if (!same_type_p (type
, ctor_return_type
))
9641 cp_error ("operator `%T' declared to return `%T'",
9642 ctor_return_type
, type
);
9644 cp_pedwarn ("return type specified for `operator %T'",
9647 type
= ctor_return_type
;
9652 /* Now process the modifiers that were specified
9653 and check for invalid combinations. */
9655 /* Long double is a special combination. */
9657 if (RIDBIT_SETP (RID_LONG
, specbits
)
9658 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
9660 RIDBIT_RESET (RID_LONG
, specbits
);
9661 type
= build_qualified_type (long_double_type_node
,
9662 CP_TYPE_QUALS (type
));
9665 /* Check all other uses of type modifiers. */
9667 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9668 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9669 || RIDBIT_SETP (RID_LONG
, specbits
)
9670 || RIDBIT_SETP (RID_SHORT
, specbits
))
9674 if (TREE_CODE (type
) == REAL_TYPE
)
9675 error ("short, signed or unsigned invalid for `%s'", name
);
9676 else if (TREE_CODE (type
) != INTEGER_TYPE
)
9677 error ("long, short, signed or unsigned invalid for `%s'", name
);
9678 else if (RIDBIT_SETP (RID_LONG
, specbits
)
9679 && RIDBIT_SETP (RID_SHORT
, specbits
))
9680 error ("long and short specified together for `%s'", name
);
9681 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9682 || RIDBIT_SETP (RID_SHORT
, specbits
))
9684 error ("long or short specified with char for `%s'", name
);
9685 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9686 || RIDBIT_SETP (RID_SHORT
, specbits
))
9687 && TREE_CODE (type
) == REAL_TYPE
)
9688 error ("long or short specified with floating type for `%s'", name
);
9689 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9690 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
9691 error ("signed and unsigned given together for `%s'", name
);
9695 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
9697 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9699 if (flag_pedantic_errors
)
9704 /* Discard the type modifiers if they are invalid. */
9707 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
9708 RIDBIT_RESET (RID_SIGNED
, specbits
);
9709 RIDBIT_RESET (RID_LONG
, specbits
);
9710 RIDBIT_RESET (RID_SHORT
, specbits
);
9715 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
9716 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9718 error ("complex invalid for `%s'", name
);
9719 RIDBIT_RESET (RID_COMPLEX
, specbits
);
9722 /* Decide whether an integer type is signed or not.
9723 Optionally treat bitfields as signed by default. */
9724 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9727 It is implementation-defined whether a plain (neither
9728 explicitly signed or unsigned) char, short, int, or long
9729 bit-field is signed or unsigned.
9731 Naturally, we extend this to long long as well. Note that
9732 this does not include wchar_t. */
9733 || (bitfield
&& !flag_signed_bitfields
9734 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)
9735 /* A typedef for plain `int' without `signed' can be
9736 controlled just like plain `int', but a typedef for
9737 `signed int' cannot be so controlled. */
9739 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9740 && (TREE_CODE (type
) == INTEGER_TYPE
9741 || TREE_CODE (type
) == CHAR_TYPE
)
9742 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9745 type
= long_long_unsigned_type_node
;
9746 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9747 type
= long_unsigned_type_node
;
9748 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9749 type
= short_unsigned_type_node
;
9750 else if (type
== char_type_node
)
9751 type
= unsigned_char_type_node
;
9752 else if (typedef_decl
)
9753 type
= unsigned_type (type
);
9755 type
= unsigned_type_node
;
9757 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9758 && type
== char_type_node
)
9759 type
= signed_char_type_node
;
9761 type
= long_long_integer_type_node
;
9762 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9763 type
= long_integer_type_node
;
9764 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9765 type
= short_integer_type_node
;
9767 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
9769 /* If we just have "complex", it is equivalent to
9770 "complex double", but if any modifiers at all are specified it is
9771 the complex form of TYPE. E.g, "complex short" is
9772 "complex short int". */
9774 if (defaulted_int
&& ! longlong
9775 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
9776 || RIDBIT_SETP (RID_SHORT
, specbits
)
9777 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9778 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
9779 type
= complex_double_type_node
;
9780 else if (type
== integer_type_node
)
9781 type
= complex_integer_type_node
;
9782 else if (type
== float_type_node
)
9783 type
= complex_float_type_node
;
9784 else if (type
== double_type_node
)
9785 type
= complex_double_type_node
;
9786 else if (type
== long_double_type_node
)
9787 type
= complex_long_double_type_node
;
9789 type
= build_complex_type (type
);
9792 if (return_type
== return_conversion
9793 && (RIDBIT_SETP (RID_CONST
, specbits
)
9794 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
9795 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
9796 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9799 /* Set CONSTP if this declaration is `const', whether by
9800 explicit specification or via a typedef.
9801 Likewise for VOLATILEP. */
9803 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
9805 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
9807 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
9808 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9809 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9810 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9811 type
= cp_build_qualified_type (type
, type_quals
);
9813 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
9814 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
9815 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
9816 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
9817 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
9819 if (RIDBIT_SETP (RID_STATIC
, specbits
))
9820 staticp
= 1 + (decl_context
== FIELD
);
9822 if (virtualp
&& staticp
== 2)
9824 cp_error ("member `%D' cannot be declared both virtual and static",
9828 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
9829 RIDBIT_RESET (RID_FRIEND
, specbits
);
9831 /* $7.1.2, Function specifiers */
9832 if (friendp
&& explicitp
)
9833 error ("only declarations of constructors can be `explicit'");
9835 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9837 if (decl_context
== PARM
)
9839 error ("non-member `%s' cannot be declared `mutable'", name
);
9840 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9842 else if (friendp
|| decl_context
== TYPENAME
)
9844 error ("non-object member `%s' cannot be declared `mutable'", name
);
9845 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9849 /* Warn if two storage classes are given. Default to `auto'. */
9851 if (RIDBIT_ANY_SET (specbits
))
9853 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
9854 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
9855 if (decl_context
== PARM
&& nclasses
> 0)
9856 error ("storage class specifiers invalid in parameter declarations");
9857 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9859 if (decl_context
== PARM
)
9860 error ("typedef declaration invalid in parameter declaration");
9863 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
9864 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
9867 /* Give error if `virtual' is used outside of class declaration. */
9869 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9871 error ("virtual outside class declaration");
9874 if (current_class_name
== NULL_TREE
&& RIDBIT_SETP (RID_MUTABLE
, specbits
))
9876 error ("only members can be declared mutable");
9877 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9880 /* Static anonymous unions are dealt with here. */
9881 if (staticp
&& decl_context
== TYPENAME
9882 && TREE_CODE (declspecs
) == TREE_LIST
9883 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs
)))
9884 decl_context
= FIELD
;
9886 /* Warn about storage classes that are invalid for certain
9887 kinds of declarations (parameters, typenames, etc.). */
9890 error ("multiple storage classes in declaration of `%s'", name
);
9891 else if (decl_context
!= NORMAL
&& nclasses
> 0)
9893 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9894 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
9895 || RIDBIT_SETP (RID_AUTO
, specbits
)))
9897 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9899 else if (decl_context
== FIELD
9900 /* C++ allows static class elements */
9901 && RIDBIT_SETP (RID_STATIC
, specbits
))
9902 /* C++ also allows inlines and signed and unsigned elements,
9903 but in those cases we don't come in here. */
9907 if (decl_context
== FIELD
)
9909 tree tmp
= NULL_TREE
;
9910 register int op
= 0;
9914 /* Avoid trying to get an operand off an identifier node. */
9915 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
9918 tmp
= TREE_OPERAND (declarator
, 0);
9919 op
= IDENTIFIER_OPNAME_P (tmp
);
9921 error ("storage class specified for %s `%s'",
9922 op
? "member operator" : "field",
9923 op
? operator_name_string (tmp
) : name
);
9926 error (((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9927 ? "storage class specified for parameter `%s'"
9928 : "storage class specified for typename"), name
);
9929 RIDBIT_RESET (RID_REGISTER
, specbits
);
9930 RIDBIT_RESET (RID_AUTO
, specbits
);
9931 RIDBIT_RESET (RID_EXTERN
, specbits
);
9934 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
9936 if (toplevel_bindings_p ())
9938 /* It's common practice (and completely valid) to have a const
9939 be initialized and declared extern. */
9940 if (!(type_quals
& TYPE_QUAL_CONST
))
9941 warning ("`%s' initialized and declared `extern'", name
);
9944 error ("`%s' has both `extern' and initializer", name
);
9946 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
9947 && ! toplevel_bindings_p ())
9948 error ("nested function `%s' declared `extern'", name
);
9949 else if (toplevel_bindings_p ())
9951 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9952 error ("top-level declaration of `%s' specifies `auto'", name
);
9955 if (nclasses
> 0 && friendp
)
9956 error ("storage class specifiers invalid in friend function declarations");
9958 /* Now figure out the structure of the declarator proper.
9959 Descend through it, creating more complex types, until we reach
9960 the declared identifier (or NULL_TREE, in an absolute declarator). */
9962 inner_attrs
= NULL_TREE
;
9965 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
9966 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
9968 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9969 an INDIRECT_REF (for *...),
9970 a CALL_EXPR (for ...(...)),
9971 an identifier (for the name being declared)
9972 or a null pointer (for the place in an absolute declarator
9973 where the name was omitted).
9974 For the last two cases, we have just exited the loop.
9976 For C++ it could also be
9977 a SCOPE_REF (for class :: ...). In this case, we have converted
9978 sensible names to types, and those are the values we use to
9979 qualify the member name.
9980 an ADDR_EXPR (for &...),
9981 a BIT_NOT_EXPR (for destructors)
9983 At this point, TYPE is the type of elements of an array,
9984 or for a function to return, or for a pointer to point to.
9985 After this sequence of ifs, TYPE is the type of the
9986 array or function or pointer, and DECLARATOR has had its
9987 outermost layer removed. */
9989 if (type
== error_mark_node
)
9991 if (TREE_CODE (declarator
) == SCOPE_REF
)
9992 declarator
= TREE_OPERAND (declarator
, 1);
9994 declarator
= TREE_OPERAND (declarator
, 0);
9997 if (quals
!= NULL_TREE
9998 && (declarator
== NULL_TREE
9999 || TREE_CODE (declarator
) != SCOPE_REF
))
10001 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
10002 ctype
= TYPE_METHOD_BASETYPE (type
);
10003 if (ctype
!= NULL_TREE
)
10005 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
10006 ctype
= grok_method_quals (ctype
, dummy
, quals
);
10007 type
= TREE_TYPE (dummy
);
10012 /* See the comment for the TREE_LIST case, below. */
10015 else if (inner_attrs
)
10017 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10018 inner_attrs
= NULL_TREE
;
10021 switch (TREE_CODE (declarator
))
10025 /* We encode a declarator with embedded attributes using
10026 a TREE_LIST. The attributes apply to the declarator
10027 directly inside them, so we have to skip an iteration
10028 before applying them to the type. If the declarator just
10029 inside is the declarator-id, we apply the attrs to the
10031 inner_attrs
= TREE_PURPOSE (declarator
);
10033 declarator
= TREE_VALUE (declarator
);
10039 register tree itype
= NULL_TREE
;
10040 register tree size
= TREE_OPERAND (declarator
, 1);
10041 /* The index is a signed object `sizetype' bits wide. */
10042 tree index_type
= signed_type (sizetype
);
10044 declarator
= TREE_OPERAND (declarator
, 0);
10046 /* Check for some types that there cannot be arrays of. */
10048 if (TREE_CODE (type
) == VOID_TYPE
)
10050 cp_error ("declaration of `%D' as array of voids", dname
);
10051 type
= error_mark_node
;
10054 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10056 cp_error ("declaration of `%D' as array of functions", dname
);
10057 type
= error_mark_node
;
10060 /* ARM $8.4.3: Since you can't have a pointer to a reference,
10061 you can't have arrays of references. If we allowed them,
10062 then we'd be saying x[i] is valid for an array x, but
10063 then you'd have to ask: what does `*(x + i)' mean? */
10064 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10066 if (decl_context
== TYPENAME
)
10067 cp_error ("cannot make arrays of references");
10069 cp_error ("declaration of `%D' as array of references",
10071 type
= error_mark_node
;
10074 if (TREE_CODE (type
) == OFFSET_TYPE
)
10076 cp_error ("declaration of `%D' as array of data members",
10078 type
= error_mark_node
;
10081 if (TREE_CODE (type
) == METHOD_TYPE
)
10083 cp_error ("declaration of `%D' as array of function members",
10085 type
= error_mark_node
;
10088 if (size
== error_mark_node
)
10089 type
= error_mark_node
;
10090 else if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
10094 the constant expressions that specify the bounds of
10095 the arrays can be omitted only for the first member
10096 of the sequence. */
10097 cp_error ("declaration of `%D' as multidimensional array",
10099 cp_error ("must have bounds for all dimensions except the first");
10100 type
= error_mark_node
;
10103 if (type
== error_mark_node
)
10106 /* VC++ spells a zero-sized array with []. */
10107 if (size
== NULL_TREE
&& decl_context
== FIELD
&& ! staticp
10108 && ! RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10109 size
= integer_zero_node
;
10113 /* Must suspend_momentary here because the index
10114 type may need to live until the end of the function.
10115 For example, it is used in the declaration of a
10116 variable which requires destructing at the end of
10117 the function; then build_vec_delete will need this
10119 int yes
= suspend_momentary ();
10120 /* Might be a cast. */
10121 if (TREE_CODE (size
) == NOP_EXPR
10122 && TREE_TYPE (size
) == TREE_TYPE (TREE_OPERAND (size
, 0)))
10123 size
= TREE_OPERAND (size
, 0);
10124 if (TREE_READONLY_DECL_P (size
))
10125 size
= decl_constant_value (size
);
10127 /* If this involves a template parameter, it will be a
10128 constant at instantiation time, but we don't know
10129 what the value is yet. Even if no template
10130 parameters are involved, we may an expression that
10131 is not a constant; we don't even simplify `1 + 2'
10132 when processing a template. */
10133 if (processing_template_decl
)
10135 /* Resolve a qualified reference to an enumerator or
10136 static const data member of ours. */
10137 if (TREE_CODE (size
) == SCOPE_REF
10138 && TREE_OPERAND (size
, 0) == current_class_type
)
10140 tree t
= lookup_field (current_class_type
,
10141 TREE_OPERAND (size
, 1), 0, 0);
10146 itype
= build_index_type (build_min
10147 (MINUS_EXPR
, sizetype
, size
, integer_one_node
));
10148 goto dont_grok_size
;
10151 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
10152 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
10153 && TREE_CODE (TREE_TYPE (size
)) != BOOLEAN_TYPE
)
10155 cp_error ("size of array `%D' has non-integer type",
10157 size
= integer_one_node
;
10159 if (pedantic
&& integer_zerop (size
))
10160 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname
);
10161 if (TREE_CONSTANT (size
))
10163 int old_flag_pedantic_errors
= flag_pedantic_errors
;
10164 int old_pedantic
= pedantic
;
10165 pedantic
= flag_pedantic_errors
= 1;
10166 /* Always give overflow errors on array subscripts. */
10167 constant_expression_warning (size
);
10168 pedantic
= old_pedantic
;
10169 flag_pedantic_errors
= old_flag_pedantic_errors
;
10170 if (INT_CST_LT (size
, integer_zero_node
))
10172 cp_error ("size of array `%D' is negative", dname
);
10173 size
= integer_one_node
;
10181 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
10184 cp_pedwarn ("ANSI C++ forbids variable-size array");
10189 = fold (build_binary_op (MINUS_EXPR
,
10190 cp_convert (index_type
, size
),
10191 cp_convert (index_type
,
10192 integer_one_node
)));
10193 if (! TREE_CONSTANT (itype
))
10194 itype
= variable_size (itype
);
10195 else if (TREE_OVERFLOW (itype
))
10197 error ("overflow in array dimension");
10198 TREE_OVERFLOW (itype
) = 0;
10201 /* If we're a parm, we need to have a permanent type so
10202 mangling checks for re-use will work right. If both the
10203 element and index types are permanent, the array type
10205 if (decl_context
== PARM
10206 && allocation_temporary_p () && TREE_PERMANENT (type
))
10208 push_obstacks (&permanent_obstack
, &permanent_obstack
);
10209 itype
= build_index_type (itype
);
10213 itype
= build_index_type (itype
);
10216 resume_momentary (yes
);
10219 type
= build_cplus_array_type (type
, itype
);
10228 tree inner_parms
= CALL_DECLARATOR_PARMS (declarator
);
10229 tree inner_decl
= TREE_OPERAND (declarator
, 0);
10231 /* Declaring a function type.
10232 Make sure we have a valid type for the function to return. */
10234 /* We now know that the TYPE_QUALS don't apply to the
10235 decl, but to its return type. */
10236 type_quals
= TYPE_UNQUALIFIED
;
10238 /* Warn about some types functions can't return. */
10240 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10242 error ("`%s' declared as function returning a function", name
);
10243 type
= integer_type_node
;
10245 if (TREE_CODE (type
) == ARRAY_TYPE
)
10247 error ("`%s' declared as function returning an array", name
);
10248 type
= integer_type_node
;
10251 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
10252 inner_decl
= TREE_OPERAND (inner_decl
, 1);
10254 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
10255 inner_decl
= dname
;
10257 /* Pick up type qualifiers which should be applied to `this'. */
10258 quals
= CALL_DECLARATOR_QUALS (declarator
);
10260 /* Pick up the exception specifications. */
10261 raises
= CALL_DECLARATOR_EXCEPTION_SPEC (declarator
);
10263 /* Say it's a definition only for the CALL_EXPR
10264 closest to the identifier. */
10267 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
10268 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
10269 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
10271 if (ctype
== NULL_TREE
10272 && decl_context
== FIELD
10274 && (friendp
== 0 || dname
== current_class_name
))
10275 ctype
= current_class_type
;
10277 if (ctype
&& return_type
== return_conversion
)
10278 TYPE_HAS_CONVERSION (ctype
) = 1;
10279 if (ctype
&& constructor_name (ctype
) == dname
)
10281 /* We are within a class's scope. If our declarator name
10282 is the same as the class name, and we are defining
10283 a function, then it is a constructor/destructor, and
10284 therefore returns a void type. */
10286 if (flags
== DTOR_FLAG
)
10288 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
10289 not be declared const or volatile. A destructor
10290 may not be static. */
10292 error ("destructor cannot be static member function");
10295 cp_error ("destructors may not be `%s'",
10296 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10299 if (decl_context
== FIELD
)
10301 if (! member_function_or_else (ctype
, current_class_type
,
10302 "destructor for alien class `%s' cannot be a member"))
10303 return void_type_node
;
10306 else /* It's a constructor. */
10308 if (explicitp
== 1)
10310 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
10311 not be declared const or volatile. A constructor may
10312 not be virtual. A constructor may not be static. */
10314 error ("constructor cannot be static member function");
10317 pedwarn ("constructors cannot be declared virtual");
10322 cp_error ("constructors may not be `%s'",
10323 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10327 RID_BIT_TYPE tmp_bits
;
10328 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
10329 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
10330 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
10331 if (RIDBIT_ANY_SET (tmp_bits
))
10332 error ("return value type specifier for constructor ignored");
10334 type
= build_pointer_type (ctype
);
10335 if (decl_context
== FIELD
)
10337 if (! member_function_or_else (ctype
, current_class_type
,
10338 "constructor for alien class `%s' cannot be member"))
10339 return void_type_node
;
10340 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
10341 if (return_type
!= return_ctor
)
10345 if (decl_context
== FIELD
)
10351 error ("can't initialize friend function `%s'", name
);
10354 /* Cannot be both friend and virtual. */
10355 error ("virtual functions cannot be friends");
10356 RIDBIT_RESET (RID_FRIEND
, specbits
);
10359 if (decl_context
== NORMAL
)
10360 error ("friend declaration not in class definition");
10361 if (current_function_decl
&& funcdef_flag
)
10362 cp_error ("can't define friend function `%s' in a local class definition",
10366 /* Construct the function type and go to the next
10367 inner layer of declarator. */
10369 declarator
= TREE_OPERAND (declarator
, 0);
10371 /* FIXME: This is where default args should be fully
10374 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
10376 if (declarator
&& flags
== DTOR_FLAG
)
10378 /* A destructor declared in the body of a class will
10379 be represented as a BIT_NOT_EXPR. But, we just
10380 want the underlying IDENTIFIER. */
10381 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
10382 declarator
= TREE_OPERAND (declarator
, 0);
10384 if (strict_prototype
== 0 && arg_types
== NULL_TREE
)
10385 arg_types
= void_list_node
;
10386 else if (arg_types
== NULL_TREE
10387 || arg_types
!= void_list_node
)
10389 cp_error ("destructors may not have parameters");
10390 arg_types
= void_list_node
;
10391 last_function_parms
= NULL_TREE
;
10395 /* ANSI says that `const int foo ();'
10396 does not make the function foo const. */
10397 type
= build_function_type (type
, arg_types
);
10401 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
10402 if (TREE_PURPOSE (t
)
10403 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
10405 add_defarg_fn (type
);
10414 /* Filter out pointers-to-references and references-to-references.
10415 We can get these if a TYPE_DECL is used. */
10417 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10419 error ("cannot declare %s to references",
10420 TREE_CODE (declarator
) == ADDR_EXPR
10421 ? "references" : "pointers");
10422 declarator
= TREE_OPERAND (declarator
, 0);
10426 if (TREE_CODE (type
) == OFFSET_TYPE
10427 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
10428 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
10430 cp_error ("cannot declare pointer to `%#T' member",
10432 type
= TREE_TYPE (type
);
10435 /* Merge any constancy or volatility into the target type
10436 for the pointer. */
10438 /* We now know that the TYPE_QUALS don't apply to the decl,
10439 but to the target of the pointer. */
10440 type_quals
= TYPE_UNQUALIFIED
;
10442 if (TREE_CODE (declarator
) == ADDR_EXPR
)
10444 if (TREE_CODE (type
) == VOID_TYPE
)
10445 error ("invalid type: `void &'");
10447 type
= build_reference_type (type
);
10449 else if (TREE_CODE (type
) == METHOD_TYPE
)
10450 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10452 type
= build_pointer_type (type
);
10454 /* Process a list of type modifier keywords (such as
10455 const or volatile) that were given inside the `*' or `&'. */
10457 if (TREE_TYPE (declarator
))
10459 register tree typemodlist
;
10465 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
10466 typemodlist
= TREE_CHAIN (typemodlist
))
10468 tree qualifier
= TREE_VALUE (typemodlist
);
10470 if (qualifier
== ridpointers
[(int) RID_CONST
])
10472 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
10474 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
10479 error ("invalid type modifier within pointer declarator");
10483 pedwarn ("duplicate `const'");
10485 pedwarn ("duplicate `volatile'");
10487 pedwarn ("duplicate `restrict'");
10489 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10490 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10491 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10492 if (TREE_CODE (declarator
) == ADDR_EXPR
10493 && (constp
|| volatilep
))
10496 pedwarn ("discarding `const' applied to a reference");
10498 pedwarn ("discarding `volatile' applied to a reference");
10499 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
10501 type
= cp_build_qualified_type (type
, type_quals
);
10503 declarator
= TREE_OPERAND (declarator
, 0);
10509 /* We have converted type names to NULL_TREE if the
10510 name was bogus, or to a _TYPE node, if not.
10512 The variable CTYPE holds the type we will ultimately
10513 resolve to. The code here just needs to build
10514 up appropriate member types. */
10515 tree sname
= TREE_OPERAND (declarator
, 1);
10518 /* Destructors can have their visibilities changed as well. */
10519 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
10520 sname
= TREE_OPERAND (sname
, 0);
10522 if (TREE_COMPLEXITY (declarator
) == 0)
10523 /* This needs to be here, in case we are called
10524 multiple times. */ ;
10525 else if (TREE_COMPLEXITY (declarator
) == -1)
10526 /* Namespace member. */
10527 pop_decl_namespace ();
10528 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
10529 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10530 else if (! IS_AGGR_TYPE_CODE
10531 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
10533 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
10535 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10536 that refer to ctype. They couldn't be resolved earlier
10537 because we hadn't pushed into the class yet.
10538 Example: resolve 'B<T>::type' in
10539 'B<typename B<T>::type> B<T>::f () { }'. */
10540 if (current_template_parms
10541 && uses_template_parms (type
)
10542 && uses_template_parms (current_class_type
))
10544 tree args
= current_template_args ();
10545 type
= tsubst (type
, args
, /*complain=*/1, NULL_TREE
);
10548 /* This pop_nested_class corresponds to the
10549 push_nested_class used to push into class scope for
10550 parsing the argument list of a function decl, in
10552 pop_nested_class ();
10553 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10556 my_friendly_abort (16);
10558 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10560 /* We had a reference to a global decl, or
10561 perhaps we were given a non-aggregate typedef,
10562 in which case we cleared this out, and should just
10563 keep going as though it wasn't there. */
10564 declarator
= sname
;
10567 ctype
= TREE_OPERAND (declarator
, 0);
10570 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
10572 if (CLASSTYPE_TEMPLATE_INFO (t
) &&
10573 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
10574 template_count
+= 1;
10575 t
= TYPE_MAIN_DECL (t
);
10576 if (DECL_LANG_SPECIFIC (t
))
10577 t
= DECL_CLASS_CONTEXT (t
);
10582 if (sname
== NULL_TREE
)
10585 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10587 /* This is the `standard' use of the scoping operator:
10588 basetype :: member . */
10590 if (ctype
== current_class_type
)
10596 Is this ill-formed? */
10599 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10602 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10604 if (current_class_type
== NULL_TREE
10606 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10607 TYPE_ARG_TYPES (type
));
10610 cp_error ("cannot declare member function `%T::%s' within `%T'",
10611 ctype
, name
, current_class_type
);
10612 return void_type_node
;
10615 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10616 || TYPE_SIZE (complete_type (ctype
)) != NULL_TREE
)
10618 /* Have to move this code elsewhere in this function.
10619 this code is used for i.e., typedef int A::M; M *pm;
10621 It is? How? jason 10/2/94 */
10623 if (current_class_type
)
10625 cp_error ("cannot declare member `%T::%s' within `%T'",
10626 ctype
, name
, current_class_type
);
10627 return void_type_node
;
10629 type
= build_offset_type (ctype
, type
);
10631 else if (uses_template_parms (ctype
))
10633 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10635 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
10636 TYPE_ARG_TYPES (type
));
10640 cp_error ("structure `%T' not yet defined", ctype
);
10641 return error_mark_node
;
10644 declarator
= sname
;
10646 else if (TREE_CODE (sname
) == SCOPE_REF
)
10647 my_friendly_abort (17);
10651 declarator
= TREE_OPERAND (declarator
, 1);
10652 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
10653 /* In this case, we will deal with it later. */
10657 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10658 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10659 TYPE_ARG_TYPES (type
));
10661 type
= build_offset_type (ctype
, type
);
10668 declarator
= TREE_OPERAND (declarator
, 0);
10673 case ENUMERAL_TYPE
:
10674 declarator
= NULL_TREE
;
10678 declarator
= NULL_TREE
;
10682 my_friendly_abort (158);
10686 /* See the comment for the TREE_LIST case, above. */
10689 if (! ignore_attrs
)
10690 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10692 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
10694 attrlist
= build_decl_list (NULL_TREE
, inner_attrs
);
10697 /* Now TYPE has the actual type. */
10699 if (explicitp
== 1)
10701 error ("only constructors can be declared `explicit'");
10705 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10707 if (type_quals
& TYPE_QUAL_CONST
)
10709 error ("const `%s' cannot be declared `mutable'", name
);
10710 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10714 error ("static `%s' cannot be declared `mutable'", name
);
10715 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10719 if (declarator
== NULL_TREE
10720 || TREE_CODE (declarator
) == IDENTIFIER_NODE
10721 || (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
10722 && (TREE_CODE (type
) == FUNCTION_TYPE
10723 || TREE_CODE (type
) == METHOD_TYPE
)))
10725 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10727 cp_error ("template-id `%D' used as a declarator", declarator
);
10728 declarator
= dname
;
10731 /* Unexpected declarator format. */
10732 my_friendly_abort (990210);
10734 /* If this is declaring a typedef name, return a TYPE_DECL. */
10736 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
10740 /* Note that the grammar rejects storage classes
10741 in typenames, fields or parameters. */
10742 if (current_lang_name
== lang_name_java
)
10743 TYPE_FOR_JAVA (type
) = 1;
10745 if (decl_context
== FIELD
)
10747 if (declarator
== constructor_name (current_class_type
))
10748 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10750 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10754 /* Make sure this typedef lives as long as its type,
10755 since it might be used as a template parameter. */
10756 if (type
!= error_mark_node
)
10757 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
10758 if (processing_template_decl
)
10759 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10761 decl
= build_decl (TYPE_DECL
, declarator
, type
);
10762 if (type
!= error_mark_node
)
10766 /* If the user declares "typedef struct {...} foo" then the
10767 struct will have an anonymous name. Fill that name in now.
10768 Nothing can refer to it, so nothing needs know about the name
10770 if (type
!= error_mark_node
10771 && TYPE_NAME (type
)
10772 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10773 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
))
10774 && CP_TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
10776 tree oldname
= TYPE_NAME (type
);
10779 /* Replace the anonymous name with the real name everywhere. */
10780 lookup_tag_reverse (type
, declarator
);
10781 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10782 if (TYPE_NAME (t
) == oldname
)
10783 TYPE_NAME (t
) = decl
;
10785 if (TYPE_LANG_SPECIFIC (type
))
10786 TYPE_WAS_ANONYMOUS (type
) = 1;
10788 /* If this is a typedef within a template class, the nested
10789 type is a (non-primary) template. The name for the
10790 template needs updating as well. */
10791 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10792 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10793 = TYPE_IDENTIFIER (type
);
10795 /* XXX Temporarily set the scope.
10796 When returning, start_decl expects it as NULL_TREE,
10797 and will then then set it using pushdecl. */
10798 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
10799 if (current_class_type
)
10800 DECL_CONTEXT (decl
) = current_class_type
;
10802 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10804 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
10805 DECL_ASSEMBLER_NAME (decl
)
10806 = get_identifier (build_overload_name (type
, 1, 1));
10807 DECL_CONTEXT (decl
) = NULL_TREE
;
10809 /* FIXME remangle member functions; member functions of a
10810 type with external linkage have external linkage. */
10813 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10815 cp_error_at ("typedef name may not be class-qualified", decl
);
10820 if (ctype
== NULL_TREE
)
10822 if (TREE_CODE (type
) != METHOD_TYPE
)
10823 cp_error_at ("invalid type qualifier for non-method type", decl
);
10825 ctype
= TYPE_METHOD_BASETYPE (type
);
10827 if (ctype
!= NULL_TREE
)
10828 grok_method_quals (ctype
, decl
, quals
);
10831 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10832 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10833 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10835 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10836 error ("non-object member `%s' cannot be declared mutable", name
);
10838 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
10839 inlinep
, friendp
, raises
!= NULL_TREE
);
10842 error ("typedef declaration includes an initializer");
10847 /* Detect the case of an array type of unspecified size
10848 which came, as such, direct from a typedef name.
10849 We must copy the type, so that each identifier gets
10850 a distinct type, so that each identifier's size can be
10851 controlled separately by its own initializer. */
10853 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
10854 && TYPE_DOMAIN (type
) == NULL_TREE
)
10856 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
10859 /* If this is a type name (such as, in a cast or sizeof),
10860 compute the type and return it now. */
10862 if (decl_context
== TYPENAME
)
10864 /* Note that the grammar rejects storage classes
10865 in typenames, fields or parameters. */
10866 if (type_quals
!= TYPE_UNQUALIFIED
)
10867 type_quals
= TYPE_UNQUALIFIED
;
10869 /* Special case: "friend class foo" looks like a TYPENAME context. */
10872 if (type_quals
!= TYPE_UNQUALIFIED
)
10874 cp_error ("type qualifiers specified for friend class declaration");
10875 type_quals
= TYPE_UNQUALIFIED
;
10879 cp_error ("`inline' specified for friend class declaration");
10883 /* Only try to do this stuff if we didn't already give up. */
10884 if (type
!= integer_type_node
)
10886 /* A friendly class? */
10887 if (current_class_type
)
10888 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
10890 error ("trying to make class `%s' a friend of global scope",
10891 TYPE_NAME_STRING (type
));
10892 type
= void_type_node
;
10897 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
10898 if (ctype
== NULL_TREE
)
10900 my_friendly_assert (TREE_CODE (type
) == METHOD_TYPE
, 159);
10901 ctype
= TYPE_METHOD_BASETYPE (type
);
10903 grok_method_quals (ctype
, dummy
, quals
);
10904 type
= TREE_TYPE (dummy
);
10909 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
10910 && decl_context
!= CATCHPARM
10911 && TREE_CODE (type
) != UNION_TYPE
10914 cp_error ("abstract declarator `%T' used as declaration", type
);
10915 declarator
= make_anon_name ();
10918 /* `void' at top level (not within pointer)
10919 is allowed only in typedefs or type names.
10920 We don't complain about parms either, but that is because
10921 a better error message can be made later. */
10923 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
10926 error ("unnamed variable or field declared void");
10927 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10929 if (IDENTIFIER_OPNAME_P (declarator
))
10930 my_friendly_abort (356);
10932 error ("variable or field `%s' declared void", name
);
10935 error ("variable or field declared void");
10936 type
= integer_type_node
;
10939 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10940 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10942 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10944 if (ctype
|| in_namespace
)
10945 error ("cannot use `::' in parameter declaration");
10947 /* A parameter declared as an array of T is really a pointer to T.
10948 One declared as a function is really a pointer to a function.
10949 One declared as a member is really a pointer to member. */
10951 if (TREE_CODE (type
) == ARRAY_TYPE
)
10953 /* Transfer const-ness of array into that of type pointed to. */
10954 type
= build_pointer_type (TREE_TYPE (type
));
10955 type_quals
= TYPE_UNQUALIFIED
;
10957 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10958 type
= build_pointer_type (type
);
10959 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10960 type
= build_pointer_type (type
);
10961 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
10963 error ("declaration of `%s' as void", name
);
10969 register tree decl
;
10971 if (decl_context
== PARM
)
10973 decl
= build_decl (PARM_DECL
, declarator
, type
);
10975 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
10976 inlinep
, friendp
, raises
!= NULL_TREE
);
10978 /* Compute the type actually passed in the parmlist,
10979 for the case where there is no prototype.
10980 (For example, shorts and chars are passed as ints.)
10981 When there is a prototype, this is overridden later. */
10983 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
10985 else if (decl_context
== FIELD
)
10987 if (type
== error_mark_node
)
10989 /* Happens when declaring arrays of sizes which
10990 are error_mark_node, for example. */
10993 else if (in_namespace
&& !friendp
)
10995 /* Something like struct S { int N::j; }; */
10996 cp_error ("invalid use of `::'");
10999 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11002 tree function_context
;
11004 /* We catch the others as conflicts with the builtin
11006 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
11008 cp_error ("function `%D' cannot be declared friend",
11015 if (ctype
== NULL_TREE
)
11016 ctype
= current_class_type
;
11018 if (ctype
== NULL_TREE
)
11020 cp_error ("can't make `%D' into a method -- not in a class",
11022 return void_type_node
;
11025 /* ``A union may [ ... ] not [ have ] virtual functions.''
11027 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11029 cp_error ("function `%D' declared virtual inside a union",
11031 return void_type_node
;
11034 if (declarator
== ansi_opname
[(int) NEW_EXPR
]
11035 || declarator
== ansi_opname
[(int) VEC_NEW_EXPR
]
11036 || declarator
== ansi_opname
[(int) DELETE_EXPR
]
11037 || declarator
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11041 cp_error ("`%D' cannot be declared virtual, since it is always static",
11046 else if (staticp
< 2)
11047 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11048 TYPE_ARG_TYPES (type
));
11051 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11052 function_context
= (ctype
!= NULL_TREE
) ?
11053 hack_decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11054 publicp
= (! friendp
|| ! staticp
)
11055 && function_context
== NULL_TREE
;
11056 decl
= grokfndecl (ctype
, type
,
11057 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
11058 ? declarator
: dname
,
11060 virtualp
, flags
, quals
, raises
,
11061 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
11062 funcdef_flag
, template_count
, in_namespace
);
11063 if (decl
== NULL_TREE
)
11066 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11067 /* The decl and setting of decl_machine_attr is also turned off. */
11068 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
11071 /* [class.conv.ctor]
11073 A constructor declared without the function-specifier
11074 explicit that can be called with a single parameter
11075 specifies a conversion from the type of its first
11076 parameter to the type of its class. Such a constructor
11077 is called a converting constructor. */
11078 if (explicitp
== 2)
11079 DECL_NONCONVERTING_P (decl
) = 1;
11080 else if (DECL_CONSTRUCTOR_P (decl
))
11082 /* The constructor can be called with exactly one
11083 parameter if there is at least one parameter, and
11084 any subsequent parameters have default arguments.
11085 We don't look at the first parameter, which is
11086 really just the `this' parameter for the new
11089 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
11091 /* Skip the `in_chrg' argument too, if present. */
11092 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl
)))
11093 arg_types
= TREE_CHAIN (arg_types
);
11095 if (arg_types
== void_list_node
11097 && TREE_CHAIN (arg_types
)
11098 && TREE_CHAIN (arg_types
) != void_list_node
11099 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
11100 DECL_NONCONVERTING_P (decl
) = 1;
11103 else if (TREE_CODE (type
) == METHOD_TYPE
)
11105 /* We only get here for friend declarations of
11106 members of other classes. */
11107 /* All method decls are public, so tell grokfndecl to set
11108 TREE_PUBLIC, also. */
11109 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
11110 virtualp
, flags
, quals
, raises
,
11111 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
11112 template_count
, in_namespace
);
11113 if (decl
== NULL_TREE
)
11116 else if (!staticp
&& ! processing_template_decl
11117 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
11118 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
11121 cp_error ("field `%D' has incomplete type", declarator
);
11123 cp_error ("name `%T' has incomplete type", type
);
11125 /* If we're instantiating a template, tell them which
11126 instantiation made the field's type be incomplete. */
11127 if (current_class_type
11128 && TYPE_NAME (current_class_type
)
11129 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
11130 && declspecs
&& TREE_VALUE (declspecs
)
11131 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
11132 cp_error (" in instantiation of template `%T'",
11133 current_class_type
);
11135 type
= error_mark_node
;
11142 error ("`%s' is neither function nor method; cannot be declared friend",
11143 IDENTIFIER_POINTER (declarator
));
11151 /* Friends are treated specially. */
11152 if (ctype
== current_class_type
)
11153 warning ("member functions are implicitly friends of their class");
11156 tree t
= NULL_TREE
;
11157 if (decl
&& DECL_NAME (decl
))
11159 if (template_class_depth (current_class_type
) == 0)
11162 = check_explicit_specialization
11164 template_count
, 2 * (funcdef_flag
!= 0) + 4);
11165 if (decl
== error_mark_node
)
11166 return error_mark_node
;
11169 t
= do_friend (ctype
, declarator
, decl
,
11170 last_function_parms
, attrlist
, flags
, quals
,
11173 if (t
&& funcdef_flag
)
11176 return void_type_node
;
11180 /* Structure field. It may not be a function, except for C++ */
11182 if (decl
== NULL_TREE
)
11188 /* An attempt is being made to initialize a non-static
11189 member. But, from [class.mem]:
11191 4 A member-declarator can contain a
11192 constant-initializer only if it declares a static
11193 member (_class.static_) of integral or enumeration
11194 type, see _class.static.data_.
11196 This used to be relatively common practice, but
11197 the rest of the compiler does not correctly
11198 handle the initialization unless the member is
11199 static so we make it static below. */
11200 cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
11202 cp_pedwarn ("making `%D' static", declarator
);
11206 if (uses_template_parms (type
))
11207 /* We'll check at instantiation time. */
11209 else if (check_static_variable_definition (declarator
,
11211 /* If we just return the declaration, crashes
11212 will sometimes occur. We therefore return
11213 void_type_node, as if this was a friend
11214 declaration, to cause callers to completely
11215 ignore this declaration. */
11216 return void_type_node
;
11219 /* 9.2p13 [class.mem] */
11220 if (declarator
== constructor_name (current_class_type
)
11221 /* Divergence from the standard: In extern "C", we
11222 allow non-static data members here, because C does
11223 and /usr/include/netinet/in.h uses that. */
11224 && (staticp
|| ! in_system_header
))
11225 cp_pedwarn ("ANSI C++ forbids data member `%D' with same name as enclosing class",
11230 /* C++ allows static class members. All other work
11231 for this is done by grokfield. */
11232 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
11233 TREE_STATIC (decl
) = 1;
11234 /* In class context, 'static' means public access. */
11235 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
11239 decl
= build_lang_decl (FIELD_DECL
, declarator
, type
);
11240 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11242 DECL_MUTABLE_P (decl
) = 1;
11243 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11247 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
11248 inlinep
, friendp
, raises
!= NULL_TREE
);
11251 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11253 tree original_name
;
11259 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
11260 original_name
= dname
;
11262 original_name
= declarator
;
11264 if (RIDBIT_SETP (RID_AUTO
, specbits
))
11265 error ("storage class `auto' invalid for function `%s'", name
);
11266 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11267 error ("storage class `register' invalid for function `%s'", name
);
11269 /* Function declaration not at top level.
11270 Storage classes other than `extern' are not allowed
11271 and `extern' makes no difference. */
11272 if (! toplevel_bindings_p ()
11273 && (RIDBIT_SETP (RID_STATIC
, specbits
)
11274 || RIDBIT_SETP (RID_INLINE
, specbits
))
11277 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11278 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
11280 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
11283 if (ctype
== NULL_TREE
)
11287 error ("virtual non-class function `%s'", name
);
11291 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
11292 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11293 TYPE_ARG_TYPES (type
));
11295 /* Record presence of `static'. */
11296 publicp
= (ctype
!= NULL_TREE
11297 || RIDBIT_SETP (RID_EXTERN
, specbits
)
11298 || !RIDBIT_SETP (RID_STATIC
, specbits
));
11300 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
11301 virtualp
, flags
, quals
, raises
,
11303 publicp
, inlinep
, funcdef_flag
,
11304 template_count
, in_namespace
);
11305 if (decl
== NULL_TREE
)
11310 int illegal_static
= 0;
11312 /* Don't allow a static member function in a class, and forbid
11313 declaring main to be static. */
11314 if (TREE_CODE (type
) == METHOD_TYPE
)
11316 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
11317 illegal_static
= 1;
11319 else if (current_function_decl
)
11321 /* FIXME need arm citation */
11322 error ("cannot declare static function inside another function");
11323 illegal_static
= 1;
11326 if (illegal_static
)
11329 RIDBIT_RESET (RID_STATIC
, specbits
);
11335 /* It's a variable. */
11337 /* An uninitialized decl with `extern' is a reference. */
11338 decl
= grokvardecl (type
, declarator
, &specbits
,
11340 (type_quals
& TYPE_QUAL_CONST
) != 0,
11342 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
11343 inlinep
, friendp
, raises
!= NULL_TREE
);
11347 DECL_CONTEXT (decl
) = ctype
;
11350 cp_pedwarn ("static member `%D' re-declared as static", decl
);
11352 RIDBIT_RESET (RID_STATIC
, specbits
);
11354 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
11356 cp_error ("static member `%D' declared `register'", decl
);
11357 RIDBIT_RESET (RID_REGISTER
, specbits
);
11359 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
11361 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11363 RIDBIT_RESET (RID_EXTERN
, specbits
);
11368 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11370 error ("`%s' cannot be declared mutable", name
);
11373 /* Record `register' declaration for warnings on &
11374 and in case doing stupid register allocation. */
11376 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11377 DECL_REGISTER (decl
) = 1;
11379 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
11380 DECL_THIS_EXTERN (decl
) = 1;
11382 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11383 DECL_THIS_STATIC (decl
) = 1;
11385 /* Record constancy and volatility. There's no need to do this
11386 when processing a template; we'll do this for the instantiated
11387 declaration based on the type of DECL. */
11388 if (!processing_template_decl
)
11389 c_apply_type_quals_to_decl (type_quals
, decl
);
11395 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11396 An empty exprlist is a parmlist. An exprlist which
11397 contains only identifiers at the global level
11398 is a parmlist. Otherwise, it is an exprlist. */
11401 parmlist_is_exprlist (exprs
)
11404 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
11407 if (toplevel_bindings_p ())
11409 /* At the global level, if these are all identifiers,
11410 then it is a parmlist. */
11413 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
11415 exprs
= TREE_CHAIN (exprs
);
11422 /* Subroutine of start_function. Ensure that each of the parameter
11423 types (as listed in PARMS) is complete, as is required for a
11424 function definition. */
11427 require_complete_types_for_parms (parms
)
11432 tree type
= TREE_TYPE (parms
);
11433 if (TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
11435 if (DECL_NAME (parms
))
11436 error ("parameter `%s' has incomplete type",
11437 IDENTIFIER_POINTER (DECL_NAME (parms
)));
11439 error ("parameter has incomplete type");
11440 TREE_TYPE (parms
) = error_mark_node
;
11443 layout_decl (parms
, 0);
11445 parms
= TREE_CHAIN (parms
);
11449 /* Returns DECL if DECL is a local variable (or parameter). Returns
11450 NULL_TREE otherwise. */
11453 local_variable_p (t
)
11456 if ((TREE_CODE (t
) == VAR_DECL
11457 /* A VAR_DECL with a context that is a _TYPE is a static data
11459 && !TYPE_P (CP_DECL_CONTEXT (t
))
11460 /* Any other non-local variable must be at namespace scope. */
11461 && TREE_CODE (CP_DECL_CONTEXT (t
)) != NAMESPACE_DECL
)
11462 || (TREE_CODE (t
) == PARM_DECL
))
11468 /* Check that ARG, which is a default-argument expression for a
11469 parameter DECL, is legal. Returns ARG, or ERROR_MARK_NODE, if
11470 something goes wrong. DECL may also be a _TYPE node, rather than a
11471 DECL, if there is no DECL available. */
11474 check_default_argument (decl
, arg
)
11481 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11482 /* We get a DEFAULT_ARG when looking at an in-class declaration
11483 with a default argument. Ignore the argument for now; we'll
11484 deal with it after the class is complete. */
11487 if (processing_template_decl
|| uses_template_parms (arg
))
11488 /* We don't do anything checking until instantiation-time. Note
11489 that there may be uninstantiated arguments even for an
11490 instantiated function, since default arguments are not
11491 instantiated until they are needed. */
11500 decl_type
= TREE_TYPE (decl
);
11502 if (arg
== error_mark_node
11503 || decl
== error_mark_node
11504 || TREE_TYPE (arg
) == error_mark_node
11505 || decl_type
== error_mark_node
)
11506 /* Something already went wrong. There's no need to check
11508 return error_mark_node
;
11510 /* [dcl.fct.default]
11512 A default argument expression is implicitly converted to the
11514 if (!TREE_TYPE (arg
)
11515 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
))
11518 cp_error ("default argument for `%#D' has type `%T'",
11519 decl
, TREE_TYPE (arg
));
11521 cp_error ("default argument for parameter of type `%T' has type `%T'",
11522 decl_type
, TREE_TYPE (arg
));
11524 return error_mark_node
;
11527 /* [dcl.fct.default]
11529 Local variables shall not be used in default argument
11532 The keyword `this' shall not be used in a default argument of a
11533 member function. */
11534 var
= search_tree (arg
, local_variable_p
);
11537 cp_error ("default argument `%E' uses local variable `%D'",
11539 return error_mark_node
;
11546 /* Decode the list of parameter types for a function type.
11547 Given the list of things declared inside the parens,
11548 return a list of types.
11550 The list we receive can have three kinds of elements:
11551 an IDENTIFIER_NODE for names given without types,
11552 a TREE_LIST node for arguments given as typespecs or names with typespecs,
11553 or void_type_node, to mark the end of an argument list
11554 when additional arguments are not permitted (... was not used).
11556 FUNCDEF_FLAG is nonzero for a function definition, 0 for
11557 a mere declaration. A nonempty identifier-list gets an error message
11558 when FUNCDEF_FLAG is zero.
11559 If FUNCDEF_FLAG is 1, then parameter types must be complete.
11560 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11562 If all elements of the input list contain types,
11563 we return a list of the types.
11564 If all elements contain no type (except perhaps a void_type_node
11565 at the end), we return a null list.
11566 If some have types and some do not, it is an error, and we
11567 return a null list.
11569 Also set last_function_parms to either
11570 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11571 A list of names is converted to a chain of PARM_DECLs
11572 by store_parm_decls so that ultimately it is always a chain of decls.
11574 Note that in C++, parameters can take default values. These default
11575 values are in the TREE_PURPOSE field of the TREE_LIST. It is
11576 an error to specify default values which are followed by parameters
11577 that have no default values, or an ELLIPSES. For simplicities sake,
11578 only parameters which are specified with their types can take on
11582 grokparms (first_parm
, funcdef_flag
)
11586 tree result
= NULL_TREE
;
11587 tree decls
= NULL_TREE
;
11589 if (first_parm
!= NULL_TREE
11590 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
11592 if (! funcdef_flag
)
11593 pedwarn ("parameter names (without types) in function declaration");
11594 last_function_parms
= first_parm
;
11597 else if (first_parm
!= NULL_TREE
11598 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
11599 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
11600 my_friendly_abort (145);
11603 /* Types were specified. This is a list of declarators
11604 each represented as a TREE_LIST node. */
11605 register tree parm
, chain
;
11606 int any_init
= 0, any_error
= 0;
11608 if (first_parm
!= NULL_TREE
)
11610 tree last_result
= NULL_TREE
;
11611 tree last_decl
= NULL_TREE
;
11613 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
11615 tree type
= NULL_TREE
, list_node
= parm
;
11616 register tree decl
= TREE_VALUE (parm
);
11617 tree init
= TREE_PURPOSE (parm
);
11619 chain
= TREE_CHAIN (parm
);
11620 /* @@ weak defense against parse errors. */
11621 if (TREE_CODE (decl
) != VOID_TYPE
11622 && TREE_CODE (decl
) != TREE_LIST
)
11624 /* Give various messages as the need arises. */
11625 if (TREE_CODE (decl
) == STRING_CST
)
11626 cp_error ("invalid string constant `%E'", decl
);
11627 else if (TREE_CODE (decl
) == INTEGER_CST
)
11628 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11632 if (TREE_CODE (decl
) != VOID_TYPE
)
11634 decl
= grokdeclarator (TREE_VALUE (decl
),
11635 TREE_PURPOSE (decl
),
11636 PARM
, init
!= NULL_TREE
,
11638 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11641 /* Top-level qualifiers on the parameters are
11642 ignored for function types. */
11643 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
11645 if (TREE_CODE (type
) == VOID_TYPE
)
11646 decl
= void_type_node
;
11647 else if (TREE_CODE (type
) == METHOD_TYPE
)
11649 if (DECL_NAME (decl
))
11650 /* Cannot use the decl here because
11651 we don't have DECL_CONTEXT set up yet. */
11652 cp_error ("parameter `%D' invalidly declared method type",
11655 error ("parameter invalidly declared method type");
11656 type
= build_pointer_type (type
);
11657 TREE_TYPE (decl
) = type
;
11659 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11661 if (DECL_NAME (decl
))
11662 cp_error ("parameter `%D' invalidly declared offset type",
11665 error ("parameter invalidly declared offset type");
11666 type
= build_pointer_type (type
);
11667 TREE_TYPE (decl
) = type
;
11669 else if (abstract_virtuals_error (decl
, type
))
11670 any_error
= 1; /* Seems like a good idea. */
11671 else if (POINTER_TYPE_P (type
))
11674 while (POINTER_TYPE_P (t
)
11675 || (TREE_CODE (t
) == ARRAY_TYPE
11676 && TYPE_DOMAIN (t
) != NULL_TREE
))
11678 if (TREE_CODE (t
) == ARRAY_TYPE
)
11679 cp_error ("parameter type `%T' includes %s to array of unknown bound",
11681 TYPE_PTR_P (type
) ? "pointer" : "reference");
11685 if (TREE_CODE (decl
) == VOID_TYPE
)
11687 if (result
== NULL_TREE
)
11689 result
= void_list_node
;
11690 last_result
= result
;
11694 TREE_CHAIN (last_result
) = void_list_node
;
11695 last_result
= void_list_node
;
11698 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
11699 error ("`void' in parameter list must be entire list");
11703 /* Since there is a prototype, args are passed in their own types. */
11704 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
11705 if (PROMOTE_PROTOTYPES
11706 && (TREE_CODE (type
) == INTEGER_TYPE
11707 || TREE_CODE (type
) == ENUMERAL_TYPE
)
11708 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
11709 DECL_ARG_TYPE (decl
) = integer_type_node
;
11710 if (!any_error
&& init
)
11713 init
= check_default_argument (decl
, init
);
11718 if (decls
== NULL_TREE
)
11725 TREE_CHAIN (last_decl
) = decl
;
11728 if (! current_function_decl
&& TREE_PERMANENT (list_node
))
11730 TREE_PURPOSE (list_node
) = init
;
11731 TREE_VALUE (list_node
) = type
;
11732 TREE_CHAIN (list_node
) = NULL_TREE
;
11735 list_node
= saveable_tree_cons (init
, type
, NULL_TREE
);
11736 if (result
== NULL_TREE
)
11738 result
= list_node
;
11739 last_result
= result
;
11743 TREE_CHAIN (last_result
) = list_node
;
11744 last_result
= list_node
;
11748 TREE_CHAIN (last_result
) = NULL_TREE
;
11749 /* If there are no parameters, and the function does not end
11750 with `...', then last_decl will be NULL_TREE. */
11751 if (last_decl
!= NULL_TREE
)
11752 TREE_CHAIN (last_decl
) = NULL_TREE
;
11756 last_function_parms
= decls
;
11761 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11762 FUNCTION_TYPE with the newly parsed version of its default argument, which
11763 was previously digested as text. See snarf_defarg et al in lex.c. */
11766 replace_defarg (arg
, init
)
11769 if (! processing_template_decl
11770 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
11771 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11772 TREE_TYPE (init
), TREE_VALUE (arg
));
11773 TREE_PURPOSE (arg
) = init
;
11780 tree t
= FUNCTION_ARG_CHAIN (d
);
11781 if (DECL_CONSTRUCTOR_P (d
)
11782 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d
)))
11783 t
= TREE_CHAIN (t
);
11784 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
11785 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
11786 == DECL_CLASS_CONTEXT (d
))
11787 && (TREE_CHAIN (t
) == NULL_TREE
11788 || TREE_CHAIN (t
) == void_list_node
11789 || TREE_PURPOSE (TREE_CHAIN (t
))))
11794 /* These memoizing functions keep track of special properties which
11795 a class may have. `grok_ctor_properties' notices whether a class
11796 has a constructor of the form X(X&), and also complains
11797 if the class has a constructor of the form X(X).
11798 `grok_op_properties' takes notice of the various forms of
11799 operator= which are defined, as well as what sorts of type conversion
11800 may apply. Both functions take a FUNCTION_DECL as an argument. */
11803 grok_ctor_properties (ctype
, decl
)
11806 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
11807 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
11809 /* When a type has virtual baseclasses, a magical first int argument is
11810 added to any ctor so we can tell if the class has been initialized
11811 yet. This could screw things up in this function, so we deliberately
11812 ignore the leading int if we're in that situation. */
11813 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
11815 my_friendly_assert (parmtypes
11816 && TREE_VALUE (parmtypes
) == integer_type_node
,
11818 parmtypes
= TREE_CHAIN (parmtypes
);
11819 parmtype
= TREE_VALUE (parmtypes
);
11824 A non-template constructor for class X is a copy constructor if
11825 its first parameter is of type X&, const X&, volatile X& or const
11826 volatile X&, and either there are no other parameters or else all
11827 other parameters have default arguments. */
11828 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
11829 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
11830 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11831 || TREE_CHAIN (parmtypes
) == void_list_node
11832 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
11833 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11834 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11836 TYPE_HAS_INIT_REF (ctype
) = 1;
11837 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11838 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
11842 A declaration of a constructor for a class X is ill-formed if its
11843 first parameter is of type (optionally cv-qualified) X and either
11844 there are no other parameters or else all other parameters have
11847 We *don't* complain about member template instantiations that
11848 have this form, though; they can occur as we try to decide what
11849 constructor to use during overload resolution. Since overload
11850 resolution will never prefer such a constructor to the
11851 non-template copy constructor (which is either explicitly or
11852 implicitly defined), there's no need to worry about their
11853 existence. Theoretically, they should never even be
11854 instantiated, but that's hard to forestall. */
11855 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
11856 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11857 || TREE_CHAIN (parmtypes
) == void_list_node
11858 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
11859 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11860 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11862 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11864 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
11867 else if (TREE_CODE (parmtype
) == VOID_TYPE
11868 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
11869 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
11874 /* An operator with this name can be either unary or binary. */
11880 return (name
== ansi_opname
[(int) INDIRECT_REF
]
11881 || name
== ansi_opname
[(int) ADDR_EXPR
]
11882 || name
== ansi_opname
[(int) NEGATE_EXPR
]
11883 || name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11884 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]
11885 || name
== ansi_opname
[(int) CONVERT_EXPR
]);
11888 /* An operator with this name can only be unary. */
11894 return (name
== ansi_opname
[(int) TRUTH_NOT_EXPR
]
11895 || name
== ansi_opname
[(int) BIT_NOT_EXPR
]
11896 || name
== ansi_opname
[(int) COMPONENT_REF
]
11897 || IDENTIFIER_TYPENAME_P (name
));
11900 /* Do a little sanity-checking on how they declared their operator. */
11903 grok_op_properties (decl
, virtualp
, friendp
)
11905 int virtualp
, friendp
;
11907 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11908 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11909 tree name
= DECL_NAME (decl
);
11911 if (current_class_type
== NULL_TREE
)
11918 A user-declared copy assignment operator X::operator= is a
11919 non-static non-template member function of class X with
11920 exactly one parameter of type X, X&, const X&, volatile X& or
11921 const volatile X&. */
11922 if (name
== ansi_opname
[(int) MODIFY_EXPR
]
11923 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11924 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11926 else if (name
== ansi_opname
[(int) CALL_EXPR
])
11927 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
11928 else if (name
== ansi_opname
[(int) ARRAY_REF
])
11929 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
11930 else if (name
== ansi_opname
[(int) COMPONENT_REF
]
11931 || name
== ansi_opname
[(int) MEMBER_REF
])
11932 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
11933 else if (name
== ansi_opname
[(int) NEW_EXPR
])
11934 TYPE_GETS_NEW (current_class_type
) |= 1;
11935 else if (name
== ansi_opname
[(int) DELETE_EXPR
])
11936 TYPE_GETS_DELETE (current_class_type
) |= 1;
11937 else if (name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11938 TYPE_GETS_NEW (current_class_type
) |= 2;
11939 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11940 TYPE_GETS_DELETE (current_class_type
) |= 2;
11943 if (name
== ansi_opname
[(int) NEW_EXPR
]
11944 || name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11946 /* When the compiler encounters the definition of A::operator new, it
11947 doesn't look at the class declaration to find out if it's static. */
11949 revert_static_member_fn (&decl
, NULL
, NULL
);
11951 /* Take care of function decl if we had syntax errors. */
11952 if (argtypes
== NULL_TREE
)
11954 = build_function_type (ptr_type_node
,
11955 hash_tree_chain (integer_type_node
,
11958 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11960 else if (name
== ansi_opname
[(int) DELETE_EXPR
]
11961 || name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11964 revert_static_member_fn (&decl
, NULL
, NULL
);
11966 if (argtypes
== NULL_TREE
)
11968 = build_function_type (void_type_node
,
11969 hash_tree_chain (ptr_type_node
,
11973 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11975 if (! friendp
&& name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
11976 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
11977 != void_list_node
))
11978 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type
) = 1;
11983 /* An operator function must either be a non-static member function
11984 or have at least one parameter of a class, a reference to a class,
11985 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11986 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11988 if (IDENTIFIER_TYPENAME_P (name
)
11989 || name
== ansi_opname
[(int) CALL_EXPR
]
11990 || name
== ansi_opname
[(int) MODIFY_EXPR
]
11991 || name
== ansi_opname
[(int) COMPONENT_REF
]
11992 || name
== ansi_opname
[(int) ARRAY_REF
])
11993 cp_error ("`%D' must be a nonstatic member function", decl
);
11998 if (DECL_STATIC_FUNCTION_P (decl
))
11999 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
12002 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
12004 tree arg
= TREE_VALUE (p
);
12005 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
12006 arg
= TREE_TYPE (arg
);
12008 /* This lets bad template code slip through. */
12009 if (IS_AGGR_TYPE (arg
)
12010 || TREE_CODE (arg
) == ENUMERAL_TYPE
12011 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
12012 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
12016 ("`%D' must have an argument of class or enumerated type",
12023 if (name
== ansi_opname
[(int) CALL_EXPR
])
12024 return; /* No restrictions on args. */
12026 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
12028 tree t
= TREE_TYPE (name
);
12029 if (TREE_CODE (t
) == VOID_TYPE
)
12030 pedwarn ("void is not a valid type conversion operator");
12031 else if (! friendp
)
12033 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
12034 const char *what
= 0;
12036 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
12038 if (t
== current_class_type
)
12039 what
= "the same type";
12040 /* Don't force t to be complete here. */
12041 else if (IS_AGGR_TYPE (t
)
12043 && DERIVED_FROM_P (t
, current_class_type
))
12044 what
= "a base class";
12047 warning ("conversion to %s%s will never use a type conversion operator",
12048 ref
? "a reference to " : "", what
);
12052 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
12056 if (list_length (argtypes
) != 3 && methodp
)
12058 cp_error ("`%D' must take exactly one argument", decl
);
12061 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
12063 if (copy_assignment_arg_p (parmtype
, virtualp
)
12066 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
12067 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
12068 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
12069 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
12072 else if (name
== ansi_opname
[(int) COND_EXPR
])
12075 cp_error ("ANSI C++ prohibits overloading operator ?:");
12077 else if (ambi_op_p (name
))
12079 if (list_length (argtypes
) == 2)
12081 else if (list_length (argtypes
) == 3)
12083 if ((name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
12084 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
12085 && ! processing_template_decl
12086 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12089 cp_error ("postfix `%D' must take `int' as its argument",
12093 ("postfix `%D' must take `int' as its second argument",
12100 cp_error ("`%D' must take either zero or one argument", decl
);
12102 cp_error ("`%D' must take either one or two arguments", decl
);
12105 /* More Effective C++ rule 6. */
12107 && (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
12108 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]))
12110 tree arg
= TREE_VALUE (argtypes
);
12111 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12112 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12113 arg
= TREE_TYPE (arg
);
12114 arg
= TYPE_MAIN_VARIANT (arg
);
12115 if (list_length (argtypes
) == 2)
12117 if (TREE_CODE (ret
) != REFERENCE_TYPE
12118 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12120 cp_warning ("prefix `%D' should return `%T'", decl
,
12121 build_reference_type (arg
));
12125 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12126 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
12130 else if (unary_op_p (name
))
12132 if (list_length (argtypes
) != 2)
12135 cp_error ("`%D' must take `void'", decl
);
12137 cp_error ("`%D' must take exactly one argument", decl
);
12140 else /* if (binary_op_p (name)) */
12142 if (list_length (argtypes
) != 3)
12145 cp_error ("`%D' must take exactly one argument", decl
);
12147 cp_error ("`%D' must take exactly two arguments", decl
);
12150 /* More Effective C++ rule 7. */
12152 && (name
== ansi_opname
[TRUTH_ANDIF_EXPR
]
12153 || name
== ansi_opname
[TRUTH_ORIF_EXPR
]
12154 || name
== ansi_opname
[COMPOUND_EXPR
]))
12155 cp_warning ("user-defined `%D' always evaluates both arguments",
12159 /* Effective C++ rule 23. */
12161 && list_length (argtypes
) == 3
12162 && (name
== ansi_opname
[PLUS_EXPR
]
12163 || name
== ansi_opname
[MINUS_EXPR
]
12164 || name
== ansi_opname
[TRUNC_DIV_EXPR
]
12165 || name
== ansi_opname
[MULT_EXPR
])
12166 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12167 cp_warning ("`%D' should return by value", decl
);
12171 for (; argtypes
!= void_list_node
; argtypes
= TREE_CHAIN (argtypes
))
12172 if (TREE_PURPOSE (argtypes
))
12174 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12175 if (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
12176 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
12179 cp_pedwarn ("`%D' cannot have default arguments", decl
);
12182 cp_error ("`%D' cannot have default arguments", decl
);
12187 static const char *
12189 enum tag_types code
;
12202 my_friendly_abort (981122);
12206 /* Get the struct, enum or union (CODE says which) with tag NAME.
12207 Define the tag as a forward-reference if it is not defined.
12209 C++: If a class derivation is given, process it here, and report
12210 an error if multiple derivation declarations are not identical.
12212 If this is a definition, come in through xref_tag and only look in
12213 the current frame for the name (since C++ allows new names in any
12217 xref_tag (code_type_node
, name
, globalize
)
12218 tree code_type_node
;
12222 enum tag_types tag_code
;
12223 enum tree_code code
;
12225 register tree ref
, t
;
12226 struct binding_level
*b
= current_binding_level
;
12228 tree attributes
= NULL_TREE
;
12229 tree context
= NULL_TREE
;
12231 /* If we are called from the parser, code_type_node will sometimes be a
12232 TREE_LIST. This indicates that the user wrote
12233 "class __attribute__ ((foo)) bar". Extract the attributes so we can
12235 if (TREE_CODE (code_type_node
) == TREE_LIST
)
12237 attributes
= TREE_PURPOSE (code_type_node
);
12238 code_type_node
= TREE_VALUE (code_type_node
);
12241 tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
12246 code
= RECORD_TYPE
;
12252 code
= ENUMERAL_TYPE
;
12255 my_friendly_abort (18);
12258 /* If a cross reference is requested, look up the type
12259 already defined for this tag and return it. */
12260 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
12263 name
= TYPE_IDENTIFIER (t
);
12267 t
= IDENTIFIER_TYPE_VALUE (name
);
12269 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
12270 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
)
12275 /* If we know we are defining this tag, only look it up in
12276 this scope and don't try to find it as a type. */
12277 ref
= lookup_tag (code
, name
, b
, 1);
12283 /* [dcl.type.elab] If the identifier resolves to a
12284 typedef-name or a template type-parameter, the
12285 elaborated-type-specifier is ill-formed. */
12286 if (t
!= TYPE_MAIN_VARIANT (t
)
12287 || (CLASS_TYPE_P (t
) && TYPE_WAS_ANONYMOUS (t
)))
12288 cp_pedwarn ("using typedef-name `%D' after `%s'",
12289 TYPE_NAME (t
), tag_name (tag_code
));
12290 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
12291 cp_error ("using template type parameter `%T' after `%s'",
12292 t
, tag_name (tag_code
));
12297 ref
= lookup_tag (code
, name
, b
, 0);
12301 /* Try finding it as a type declaration. If that wins,
12303 ref
= lookup_name (name
, 1);
12305 if (ref
!= NULL_TREE
12306 && processing_template_decl
12307 && DECL_CLASS_TEMPLATE_P (ref
)
12308 && template_class_depth (current_class_type
) == 0)
12309 /* Since GLOBALIZE is true, we're declaring a global
12310 template, so we want this type. */
12311 ref
= DECL_RESULT (ref
);
12313 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
12314 && TREE_CODE (TREE_TYPE (ref
)) == code
)
12315 ref
= TREE_TYPE (ref
);
12320 if (ref
&& current_class_type
12321 && template_class_depth (current_class_type
)
12322 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12324 /* Since GLOBALIZE is non-zero, we are not looking at a
12325 definition of this tag. Since, in addition, we are currently
12326 processing a (member) template declaration of a template
12327 class, we must be very careful; consider:
12334 { template <class V>
12335 friend struct S1; };
12337 Here, the S2::S1 declaration should not be confused with the
12338 outer declaration. In particular, the inner version should
12339 have a template parameter of level 2, not level 1. This
12340 would be particularly important if the member declaration
12343 template <class V = U> friend struct S1;
12345 say, when we should tsubst into `U' when instantiating
12346 S2. On the other hand, when presented with:
12356 we must find the inner binding eventually. We
12357 accomplish this by making sure that the new type we
12358 create to represent this declaration has the right
12360 context
= TYPE_CONTEXT (ref
);
12365 push_obstacks_nochange ();
12369 /* If no such tag is yet defined, create a forward-reference node
12370 and record it as the "definition".
12371 When a real declaration of this type is found,
12372 the forward-reference will be altered into a real type. */
12374 /* In C++, since these migrate into the global scope, we must
12375 build them on the permanent obstack. */
12377 temp
= allocation_temporary_p ();
12379 end_temporary_allocation ();
12381 if (code
== ENUMERAL_TYPE
)
12383 cp_error ("use of enum `%#D' without previous declaration", name
);
12385 ref
= make_node (ENUMERAL_TYPE
);
12387 /* Give the type a default layout like unsigned int
12388 to avoid crashing if it does not get defined. */
12389 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
12390 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
12391 TREE_UNSIGNED (ref
) = 1;
12392 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
12393 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
12394 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
12396 /* Enable us to recognize when a type is created in class context.
12397 To do nested classes correctly, this should probably be cleared
12398 out when we leave this classes scope. Currently this in only
12399 done in `start_enum'. */
12401 pushtag (name
, ref
, globalize
);
12405 struct binding_level
*old_b
= class_binding_level
;
12407 ref
= make_lang_type (code
);
12408 TYPE_CONTEXT (ref
) = context
;
12410 #ifdef NONNESTED_CLASSES
12411 /* Class types don't nest the way enums do. */
12412 class_binding_level
= (struct binding_level
*)0;
12414 pushtag (name
, ref
, globalize
);
12415 class_binding_level
= old_b
;
12420 /* If it no longer looks like a nested type, make sure it's
12422 If it is not an IDENTIFIER, this is not a declaration */
12423 if (b
->namespace_p
&& !class_binding_level
12424 && TREE_CODE (name
) == IDENTIFIER_NODE
)
12426 if (IDENTIFIER_NAMESPACE_VALUE (name
) == NULL_TREE
)
12427 SET_IDENTIFIER_NAMESPACE_VALUE (name
, TYPE_NAME (ref
));
12430 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
12431 redeclare_class_template (ref
, current_template_parms
);
12434 /* Until the type is defined, tentatively accept whatever
12435 structure tag the user hands us. */
12436 if (TYPE_SIZE (ref
) == NULL_TREE
12437 && ref
!= current_class_type
12438 /* Have to check this, in case we have contradictory tag info. */
12439 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
12441 if (tag_code
== class_type
)
12442 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
12443 else if (tag_code
== record_type
)
12444 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
12449 TREE_TYPE (ref
) = attributes
;
12455 xref_tag_from_type (old
, id
, globalize
)
12459 tree code_type_node
;
12461 if (TREE_CODE (old
) == RECORD_TYPE
)
12462 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
12463 ? class_type_node
: record_type_node
);
12465 code_type_node
= union_type_node
;
12467 if (id
== NULL_TREE
)
12468 id
= TYPE_IDENTIFIER (old
);
12470 return xref_tag (code_type_node
, id
, globalize
);
12473 /* REF is a type (named NAME), for which we have just seen some
12474 baseclasses. BINFO is a list of those baseclasses; the
12475 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12476 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12477 struct, or union. */
12480 xref_basetypes (code_type_node
, name
, ref
, binfo
)
12481 tree code_type_node
;
12485 /* In the declaration `A : X, Y, ... Z' we mark all the types
12486 (A, X, Y, ..., Z) so we can check for duplicates. */
12491 enum tag_types tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
12493 if (tag_code
== union_type
)
12495 cp_error ("derived union `%T' invalid", ref
);
12499 len
= list_length (binfo
);
12500 push_obstacks (TYPE_OBSTACK (ref
), TYPE_OBSTACK (ref
));
12502 /* First, make sure that any templates in base-classes are
12503 instantiated. This ensures that if we call ourselves recursively
12504 we do not get confused about which classes are marked and which
12506 for (base
= binfo
; base
; base
= TREE_CHAIN (base
))
12507 complete_type (TREE_VALUE (base
));
12509 SET_CLASSTYPE_MARKED (ref
);
12510 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
12512 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
12514 /* The base of a derived struct is public by default. */
12516 = (TREE_PURPOSE (binfo
) == access_public_node
12517 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12518 || (tag_code
!= class_type
12519 && (TREE_PURPOSE (binfo
) == access_default_node
12520 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
12522 = (TREE_PURPOSE (binfo
) == access_protected_node
12523 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
12525 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
12526 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
12527 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12528 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
12529 tree basetype
= TREE_VALUE (binfo
);
12532 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
12533 basetype
= TREE_TYPE (basetype
);
12535 || (TREE_CODE (basetype
) != RECORD_TYPE
12536 && TREE_CODE (basetype
) != TYPENAME_TYPE
12537 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
12538 && TREE_CODE (basetype
) != TEMPLATE_TEMPLATE_PARM
))
12540 cp_error ("base type `%T' fails to be a struct or class type",
12541 TREE_VALUE (binfo
));
12545 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
12547 /* This code replaces similar code in layout_basetypes.
12548 We put the complete_type first for implicit `typename'. */
12549 if (TYPE_SIZE (basetype
) == NULL_TREE
12550 && ! (current_template_parms
&& uses_template_parms (basetype
)))
12552 cp_error ("base class `%T' has incomplete type", basetype
);
12557 if (CLASSTYPE_MARKED (basetype
))
12559 if (basetype
== ref
)
12560 cp_error ("recursive type `%T' undefined", basetype
);
12562 cp_error ("duplicate base type `%T' invalid", basetype
);
12566 if (TYPE_FOR_JAVA (basetype
)
12567 && current_lang_stack
== current_lang_base
)
12568 TYPE_FOR_JAVA (ref
) = 1;
12570 /* Note that the BINFO records which describe individual
12571 inheritances are *not* shared in the lattice! They
12572 cannot be shared because a given baseclass may be
12573 inherited with different `accessibility' by different
12574 derived classes. (Each BINFO record describing an
12575 individual inheritance contains flags which say what
12576 the `accessibility' of that particular inheritance is.) */
12579 = make_binfo (integer_zero_node
, basetype
,
12580 CLASS_TYPE_P (basetype
)
12581 ? TYPE_BINFO_VTABLE (basetype
) : NULL_TREE
,
12582 CLASS_TYPE_P (basetype
)
12583 ? TYPE_BINFO_VIRTUALS (basetype
) : NULL_TREE
);
12585 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
12586 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
12587 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
12588 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
12589 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
12591 /* We need to unshare the binfos now so that lookups during class
12592 definition work. */
12593 unshare_base_binfos (base_binfo
);
12595 SET_CLASSTYPE_MARKED (basetype
);
12597 /* We are free to modify these bits because they are meaningless
12598 at top level, and BASETYPE is a top-level type. */
12599 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
12601 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
12602 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12605 if (CLASS_TYPE_P (basetype
))
12607 TYPE_GETS_NEW (ref
) |= TYPE_GETS_NEW (basetype
);
12608 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12615 TREE_VEC_LENGTH (binfos
) = i
;
12617 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
12620 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
12623 tree basetype
= BINFO_TYPE (TREE_VEC_ELT (binfos
, 0));
12625 if (CLASS_TYPE_P (basetype
))
12626 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
12627 = TYPE_USES_MULTIPLE_INHERITANCE (basetype
);
12630 if (TYPE_USES_MULTIPLE_INHERITANCE (ref
))
12631 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12633 /* Unmark all the types. */
12635 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
12636 CLEAR_CLASSTYPE_MARKED (ref
);
12638 /* Now that we know all the base-classes, set up the list of virtual
12640 CLASSTYPE_VBASECLASSES (ref
) = get_vbase_types (ref
);
12646 /* Begin compiling the definition of an enumeration type.
12647 NAME is its name (or null if anonymous).
12648 Returns the type object, as yet incomplete.
12649 Also records info about it so that build_enumerator
12650 may be used to declare the individual values as they are read. */
12656 register tree enumtype
= NULL_TREE
;
12657 struct binding_level
*b
= current_binding_level
;
12659 /* We are wasting space here and putting these on the permanent_obstack so
12660 that typeid(local enum) will work correctly. */
12661 push_obstacks (&permanent_obstack
, &permanent_obstack
);
12663 /* If this is the real definition for a previous forward reference,
12664 fill in the contents in the same object that used to be the
12665 forward reference. */
12667 if (name
!= NULL_TREE
)
12668 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
12670 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12672 cp_error ("multiple definition of `%#T'", enumtype
);
12673 cp_error_at ("previous definition here", enumtype
);
12677 enumtype
= make_node (ENUMERAL_TYPE
);
12678 pushtag (name
, enumtype
, 0);
12681 if (current_class_type
)
12682 TREE_ADDRESSABLE (b
->tags
) = 1;
12684 /* We don't copy this value because build_enumerator needs to do it. */
12685 enum_next_value
= integer_zero_node
;
12688 GNU_xref_decl (current_function_decl
, enumtype
);
12692 /* After processing and defining all the values of an enumeration type,
12693 install their decls in the enumeration type and finish it off.
12694 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12695 Returns ENUMTYPE. */
12698 finish_enum (enumtype
)
12701 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
12702 /* Calculate the maximum value of any enumerator in this type. */
12704 tree values
= TYPE_VALUES (enumtype
);
12709 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
12714 /* The TREE_VALUE is a CONST_DECL for this enumeration
12716 decl
= TREE_VALUE (pair
);
12718 /* The DECL_INITIAL will be NULL if we are processing a
12719 template declaration and this enumeration constant had no
12720 explicit initializer. */
12721 value
= DECL_INITIAL (decl
);
12722 if (value
&& !processing_template_decl
)
12724 /* Set the TREE_TYPE for the VALUE as well. That's so
12725 that when we call decl_constant_value we get an
12726 entity of the right type (but with the constant
12727 value). Since we shouldn't ever call
12728 decl_constant_value on a template type, there's no
12729 reason to do that when processing_template_decl.
12730 And, if the expression is something like a
12731 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12732 wreak havoc on the intended type of the expression.
12734 Of course, there's also no point in trying to compute
12735 minimum or maximum values if we're in a template. */
12736 TREE_TYPE (value
) = enumtype
;
12739 minnode
= maxnode
= value
;
12740 else if (tree_int_cst_lt (maxnode
, value
))
12742 else if (tree_int_cst_lt (value
, minnode
))
12746 if (processing_template_decl
)
12747 /* If this is just a template, leave the CONST_DECL
12748 alone. That way tsubst_copy will find CONST_DECLs for
12749 CONST_DECLs, and not INTEGER_CSTs. */
12752 /* In the list we're building up, we want the enumeration
12753 values, not the CONST_DECLs. */
12754 TREE_VALUE (pair
) = value
;
12758 maxnode
= minnode
= integer_zero_node
;
12760 TYPE_VALUES (enumtype
) = nreverse (values
);
12762 if (processing_template_decl
)
12764 tree scope
= current_scope ();
12765 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
12766 add_tree (build_min (TAG_DEFN
, enumtype
));
12770 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12771 int lowprec
= min_precision (minnode
, unsignedp
);
12772 int highprec
= min_precision (maxnode
, unsignedp
);
12773 int precision
= MAX (lowprec
, highprec
);
12776 TYPE_SIZE (enumtype
) = NULL_TREE
;
12778 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12780 TYPE_PRECISION (enumtype
) = precision
;
12782 fixup_unsigned_type (enumtype
);
12784 fixup_signed_type (enumtype
);
12786 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
12787 /* Use the width of the narrowest normal C type which is wide
12789 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
12792 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
12794 TYPE_SIZE (enumtype
) = 0;
12795 layout_type (enumtype
);
12797 /* Fix up all variant types of this enum type. */
12798 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
12799 tem
= TYPE_NEXT_VARIANT (tem
))
12801 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
12802 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
12803 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
12804 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
12805 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
12806 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
12807 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
12808 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
12809 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
12812 /* Finish debugging output for this type. */
12813 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12816 /* In start_enum we pushed obstacks. Here, we must pop them. */
12822 /* Build and install a CONST_DECL for an enumeration constant of the
12823 enumeration type TYPE whose NAME and VALUE (if any) are provided.
12824 Assignment of sequential values by default is handled here. */
12827 build_enumerator (name
, value
, type
)
12835 /* Remove no-op casts from the value. */
12837 STRIP_TYPE_NOPS (value
);
12839 if (! processing_template_decl
)
12841 /* Validate and default VALUE. */
12842 if (value
!= NULL_TREE
)
12844 if (TREE_READONLY_DECL_P (value
))
12845 value
= decl_constant_value (value
);
12847 if (TREE_CODE (value
) == INTEGER_CST
)
12849 value
= default_conversion (value
);
12850 constant_expression_warning (value
);
12854 cp_error ("enumerator value for `%D' not integer constant", name
);
12859 /* Default based on previous value. */
12860 if (value
== NULL_TREE
&& ! processing_template_decl
)
12862 value
= enum_next_value
;
12864 cp_error ("overflow in enumeration values at `%D'", name
);
12867 /* Remove no-op casts from the value. */
12869 STRIP_TYPE_NOPS (value
);
12871 /* To fix MAX_VAL enum consts. (bkoz) */
12872 TREE_TYPE (value
) = integer_type_node
;
12876 /* We always have to copy here; not all INTEGER_CSTs are unshared.
12877 Even in other cases, we will later (in finish_enum) be setting the
12879 if (value
!= NULL_TREE
)
12880 value
= copy_node (value
);
12882 /* C++ associates enums with global, function, or class declarations. */
12884 context
= current_scope ();
12885 if (context
&& context
== current_class_type
)
12886 /* This enum declaration is local to the class. */
12887 decl
= build_lang_decl (CONST_DECL
, name
, type
);
12889 /* It's a global enum, or it's local to a function. (Note local to
12890 a function could mean local to a class method. */
12891 decl
= build_decl (CONST_DECL
, name
, type
);
12893 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
12894 DECL_INITIAL (decl
) = value
;
12895 TREE_READONLY (decl
) = 1;
12897 if (context
&& context
== current_class_type
)
12898 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12899 on the TYPE_FIELDS list for `S'. (That's so that you can say
12900 things like `S::i' later.) */
12901 finish_member_declaration (decl
);
12905 GNU_xref_decl (current_function_decl
, decl
);
12908 if (! processing_template_decl
)
12910 /* Set basis for default for next value. */
12911 enum_next_value
= build_binary_op_nodefault (PLUS_EXPR
, value
,
12912 integer_one_node
, PLUS_EXPR
);
12913 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
12916 result
= saveable_tree_cons (name
, decl
, NULL_TREE
);
12921 static int function_depth
;
12923 /* Create the FUNCTION_DECL for a function definition.
12924 DECLSPECS and DECLARATOR are the parts of the declaration;
12925 they describe the function's name and the type it returns,
12926 but twisted together in a fashion that parallels the syntax of C.
12928 If PRE_PARSED_P is non-zero then DECLARATOR is really the DECL for
12929 the function we are about to process; DECLSPECS are ignored. For
12930 example, we set PRE_PARSED_P when processing the definition of
12931 inline function that was defined in-class; the definition is
12932 actually processed when the class is complete. In this case,
12933 PRE_PARSED_P is 2. We also set PRE_PARSED_P when instanting the
12934 body of a template function, and when constructing thunk functions
12935 and such; in these cases PRE_PARSED_P is 1.
12937 This function creates a binding context for the function body
12938 as well as setting up the FUNCTION_DECL in current_function_decl.
12940 Returns 1 on success. If the DECLARATOR is not suitable for a function
12941 (it defines a datum instead), we return 0, which tells
12942 yyparse to report a parse error.
12944 For C++, we must first check whether that datum makes any sense.
12945 For example, "class A local_a(1,2);" means that variable local_a
12946 is an aggregate of type A, which should have a constructor
12947 applied to it with the argument list [1, 2].
12949 @@ There is currently no way to retrieve the storage
12950 @@ allocated to FUNCTION (or all of its parms) if we return
12951 @@ something we had previously. */
12954 start_function (declspecs
, declarator
, attrs
, pre_parsed_p
)
12955 tree declspecs
, declarator
, attrs
;
12959 tree ctype
= NULL_TREE
;
12962 extern int have_extern_spec
;
12963 extern int used_extern_spec
;
12964 int doing_friend
= 0;
12966 /* Sanity check. */
12967 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
12968 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
12970 /* Assume, until we see it does. */
12971 current_function_returns_value
= 0;
12972 current_function_returns_null
= 0;
12974 current_function_assigns_this
= 0;
12975 current_function_just_assigned_this
= 0;
12976 current_function_parms_stored
= 0;
12977 original_result_rtx
= NULL_RTX
;
12978 base_init_expr
= NULL_TREE
;
12979 current_base_init_list
= NULL_TREE
;
12980 current_member_init_list
= NULL_TREE
;
12981 ctor_label
= dtor_label
= NULL_TREE
;
12982 static_labelno
= 0;
12983 in_function_try_handler
= 0;
12985 clear_temp_name ();
12987 /* This should only be done once on the top most decl. */
12988 if (have_extern_spec
&& !used_extern_spec
)
12990 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
12991 used_extern_spec
= 1;
12996 decl1
= declarator
;
12998 fntype
= TREE_TYPE (decl1
);
12999 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13000 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13002 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
13003 class is in the (lexical) scope of the class in which it is
13005 if (!ctype
&& DECL_FRIEND_P (decl1
))
13007 ctype
= DECL_CLASS_CONTEXT (decl1
);
13009 /* CTYPE could be null here if we're dealing with a template;
13010 for example, `inline friend float foo()' inside a template
13011 will have no CTYPE set. */
13012 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13018 last_function_parms
= DECL_ARGUMENTS (decl1
);
13019 last_function_parm_tags
= NULL_TREE
;
13023 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
13024 /* If the declarator is not suitable for a function definition,
13025 cause a syntax error. */
13026 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
13028 fntype
= TREE_TYPE (decl1
);
13030 restype
= TREE_TYPE (fntype
);
13031 if (CLASS_TYPE_P (restype
) && !CLASSTYPE_GOT_SEMICOLON (restype
))
13033 cp_error ("semicolon missing after declaration of `%#T'", restype
);
13034 shadow_tag (build_expr_list (NULL_TREE
, restype
));
13035 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
13036 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
13037 fntype
= build_function_type (integer_type_node
,
13038 TYPE_ARG_TYPES (fntype
));
13040 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
13042 TYPE_ARG_TYPES (fntype
));
13043 TREE_TYPE (decl1
) = fntype
;
13046 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13047 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13048 else if (DECL_MAIN_P (decl1
))
13050 /* If this doesn't return integer_type, complain. */
13051 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
13053 if (pedantic
|| warn_return_type
)
13054 pedwarn ("return type for `main' changed to `int'");
13055 TREE_TYPE (decl1
) = fntype
= default_function_type
;
13060 /* Warn if function was previously implicitly declared
13061 (but not if we warned then). */
13062 if (! warn_implicit
13063 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
13064 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
13066 if (!building_stmt_tree ())
13067 announce_function (decl1
);
13069 /* Set up current_class_type, and enter the scope of the class, if
13072 push_nested_class (ctype
, 1);
13073 else if (DECL_STATIC_FUNCTION_P (decl1
))
13074 push_nested_class (DECL_CONTEXT (decl1
), 2);
13076 /* Now that we have entered the scope of the class, we must restore
13077 the bindings for any template parameters surrounding DECL1, if it
13078 is an inline member template. (Order is important; consider the
13079 case where a template parameter has the same name as a field of
13080 the class.) It is not until after this point that
13081 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13082 if (pre_parsed_p
== 2)
13083 maybe_begin_member_template_processing (decl1
);
13085 /* Effective C++ rule 15. See also c_expand_return. */
13087 && DECL_NAME (decl1
) == ansi_opname
[(int) MODIFY_EXPR
]
13088 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
13089 cp_warning ("`operator=' should return a reference to `*this'");
13091 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13092 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13093 DECL_INITIAL (decl1
) = error_mark_node
;
13095 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13096 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
13099 /* This function exists in static storage.
13100 (This does not mean `static' in the C sense!) */
13101 TREE_STATIC (decl1
) = 1;
13103 /* We must call push_template_decl after current_class_type is set
13104 up. (If we are processing inline definitions after exiting a
13105 class scope, current_class_type will be NULL_TREE until set above
13106 by push_nested_class.) */
13107 if (processing_template_decl
)
13108 decl1
= push_template_decl (decl1
);
13110 /* We are now in the scope of the function being defined. */
13111 current_function_decl
= decl1
;
13113 /* Save the parm names or decls from this function's declarator
13114 where store_parm_decls will find them. */
13115 current_function_parms
= last_function_parms
;
13116 current_function_parm_tags
= last_function_parm_tags
;
13118 if (! processing_template_decl
)
13120 /* In a function definition, arg types must be complete. */
13121 require_complete_types_for_parms (current_function_parms
);
13123 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype
))) == NULL_TREE
)
13125 cp_error ("return-type `%#T' is an incomplete type",
13126 TREE_TYPE (fntype
));
13128 /* Make it return void instead, but don't change the
13129 type of the DECL_RESULT, in case we have a named return value. */
13132 = build_cplus_method_type (build_type_variant (ctype
,
13133 TREE_READONLY (decl1
),
13134 TREE_SIDE_EFFECTS (decl1
)),
13136 FUNCTION_ARG_CHAIN (decl1
));
13139 = build_function_type (void_type_node
,
13140 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
13141 DECL_RESULT (decl1
)
13142 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype
)));
13143 TREE_READONLY (DECL_RESULT (decl1
))
13144 = CP_TYPE_CONST_P (TREE_TYPE (fntype
));
13145 TREE_THIS_VOLATILE (DECL_RESULT (decl1
))
13146 = CP_TYPE_VOLATILE_P (TREE_TYPE (fntype
));
13149 abstract_virtuals_error (decl1
, TREE_TYPE (fntype
));
13152 /* Record the decl so that the function name is defined.
13153 If we already have a decl for this name, and it is a FUNCTION_DECL,
13154 use the old decl. */
13155 if (!processing_template_decl
&& pre_parsed_p
== 0)
13157 /* A specialization is not used to guide overload resolution. */
13158 if ((flag_guiding_decls
13159 || !DECL_TEMPLATE_SPECIALIZATION (decl1
))
13160 && ! DECL_FUNCTION_MEMBER_P (decl1
))
13161 decl1
= pushdecl (decl1
);
13164 /* We need to set the DECL_CONTEXT. */
13165 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13166 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13167 /* And make sure we have enough default args. */
13168 check_default_args (decl1
);
13170 DECL_MAIN_VARIANT (decl1
) = decl1
;
13171 fntype
= TREE_TYPE (decl1
);
13174 current_function_decl
= decl1
;
13176 if (DECL_INTERFACE_KNOWN (decl1
))
13178 tree ctx
= hack_decl_function_context (decl1
);
13180 if (DECL_NOT_REALLY_EXTERN (decl1
))
13181 DECL_EXTERNAL (decl1
) = 0;
13183 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
13184 && TREE_PUBLIC (ctx
))
13185 /* This is a function in a local class in an extern inline
13187 comdat_linkage (decl1
);
13189 /* If this function belongs to an interface, it is public.
13190 If it belongs to someone else's interface, it is also external.
13191 This only affects inlines and template instantiations. */
13192 else if (interface_unknown
== 0
13193 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13194 || flag_alt_external_templates
))
13196 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
13197 || processing_template_decl
)
13199 DECL_EXTERNAL (decl1
)
13201 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
13202 && !DECL_VINDEX (decl1
)));
13204 /* For WIN32 we also want to put these in linkonce sections. */
13205 maybe_make_one_only (decl1
);
13208 DECL_EXTERNAL (decl1
) = 0;
13209 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13210 DECL_INTERFACE_KNOWN (decl1
) = 1;
13212 else if (interface_unknown
&& interface_only
13213 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13214 || flag_alt_external_templates
))
13216 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13217 interface, we will have interface_only set but not
13218 interface_known. In that case, we don't want to use the normal
13219 heuristics because someone will supply a #pragma implementation
13220 elsewhere, and deducing it here would produce a conflict. */
13221 comdat_linkage (decl1
);
13222 DECL_EXTERNAL (decl1
) = 0;
13223 DECL_INTERFACE_KNOWN (decl1
) = 1;
13224 DECL_DEFER_OUTPUT (decl1
) = 1;
13228 /* This is a definition, not a reference.
13229 So clear DECL_EXTERNAL. */
13230 DECL_EXTERNAL (decl1
) = 0;
13232 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
13233 && ! DECL_INTERFACE_KNOWN (decl1
)
13234 /* Don't try to defer nested functions for now. */
13235 && ! hack_decl_function_context (decl1
))
13236 DECL_DEFER_OUTPUT (decl1
) = 1;
13238 DECL_INTERFACE_KNOWN (decl1
) = 1;
13241 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
))
13243 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13244 TREE_TYPE (decl1
) = fntype
13245 = build_function_type (TREE_TYPE (fntype
),
13246 TREE_CHAIN (TYPE_ARG_TYPES (fntype
)));
13247 current_function_parms
= TREE_CHAIN (current_function_parms
);
13248 DECL_ARGUMENTS (decl1
) = current_function_parms
;
13251 restype
= TREE_TYPE (fntype
);
13255 /* If we're compiling a friend function, neither of the variables
13256 current_class_ptr nor current_class_type will have values. */
13257 if (! doing_friend
)
13259 /* We know that this was set up by `grokclassfn'.
13260 We do not wait until `store_parm_decls', since evil
13261 parse errors may never get us to that point. Here
13262 we keep the consistency between `current_class_type'
13263 and `current_class_ptr'. */
13264 tree t
= current_function_parms
;
13267 my_friendly_assert (t
!= NULL_TREE
13268 && TREE_CODE (t
) == PARM_DECL
, 162);
13269 my_friendly_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
,
13272 if (! hack_decl_function_context (decl1
))
13273 temporary_allocation ();
13274 i
= suspend_momentary ();
13276 /* Normally, build_indirect_ref returns current_class_ref
13277 whenever current_class_ptr is dereferenced. This time,
13278 however, we want it to *create* current_class_ref, so we
13279 temporarily clear current_class_ptr to fool it. */
13280 current_class_ptr
= NULL_TREE
;
13281 current_class_ref
= build_indirect_ref (t
, NULL_PTR
);
13282 current_class_ptr
= t
;
13284 resume_momentary (i
);
13285 if (! hack_decl_function_context (decl1
))
13286 end_temporary_allocation ();
13290 current_class_ptr
= current_class_ref
= NULL_TREE
;
13293 current_binding_level
->parm_flag
= 1;
13296 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
13298 if (!building_stmt_tree ())
13300 GNU_xref_function (decl1
, current_function_parms
);
13301 make_function_rtl (decl1
);
13304 /* Promote the value to int before returning it. */
13305 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
13306 restype
= type_promotes_to (restype
);
13308 /* If this fcn was already referenced via a block-scope `extern' decl
13309 (or an implicit decl), propagate certain information about the usage. */
13310 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
13311 TREE_ADDRESSABLE (decl1
) = 1;
13313 if (DECL_RESULT (decl1
) == NULL_TREE
)
13315 DECL_RESULT (decl1
)
13316 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13317 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
13318 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
13321 /* Allocate further tree nodes temporarily during compilation
13322 of this function only. Tiemann moved up here from bottom of fn. */
13323 /* If this is a nested function, then we must continue to allocate RTL
13324 on the permanent obstack in case we need to inline it later. */
13325 if (! hack_decl_function_context (decl1
))
13326 temporary_allocation ();
13328 /* Make sure that we always have a momntary obstack while we're in a
13332 if (building_stmt_tree ())
13333 begin_stmt_tree (decl1
);
13337 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1
))
13338 && DECL_LANGUAGE (decl1
) == lang_cplusplus
)
13340 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13341 ctor_label
= NULL_TREE
;
13345 dtor_label
= NULL_TREE
;
13346 if (DECL_CONSTRUCTOR_P (decl1
))
13347 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13353 /* Called after store_parm_decls for a function-try-block. We need to update
13354 last_parm_cleanup_insn so that the base initializers for a constructor
13355 are run within this block, not before it. */
13358 expand_start_early_try_stmts ()
13360 expand_start_try_stmts ();
13361 last_parm_cleanup_insn
= get_last_insn ();
13364 /* Store the parameter declarations into the current function declaration.
13365 This is called after parsing the parameter declarations, before
13366 digesting the body of the function.
13368 Also install to binding contour return value identifier, if any. */
13371 store_parm_decls ()
13373 register tree fndecl
= current_function_decl
;
13374 register tree parm
;
13375 int parms_have_cleanups
= 0;
13376 tree cleanups
= NULL_TREE
;
13378 /* This is either a chain of PARM_DECLs (when a prototype is used). */
13379 tree specparms
= current_function_parms
;
13381 /* This is a list of types declared among parms in a prototype. */
13382 tree parmtags
= current_function_parm_tags
;
13384 /* This is a chain of any other decls that came in among the parm
13385 declarations. If a parm is declared with enum {foo, bar} x;
13386 then CONST_DECLs for foo and bar are put here. */
13387 tree nonparms
= NULL_TREE
;
13389 if (toplevel_bindings_p ())
13390 fatal ("parse errors have confused me too much");
13392 /* Initialize RTL machinery. */
13393 init_function_start (fndecl
, input_filename
, lineno
);
13394 /* Even though we're inside a function body, we still don't want to
13395 call expand_expr to calculate the size of a variable-sized array.
13396 We haven't necessarily assigned RTL to all variables yet, so it's
13397 not safe to try to expand expressions involving them. */
13398 immediate_size_expand
= 0;
13399 get_pending_sizes ();
13401 /* Create a binding level for the parms. */
13402 expand_start_bindings (0);
13404 if (specparms
!= NULL_TREE
)
13406 /* This case is when the function was defined with an ANSI prototype.
13407 The parms already have decls, so we need not do anything here
13408 except record them as in effect
13409 and complain if any redundant old-style parm decls were written. */
13411 register tree next
;
13413 /* Must clear this because it might contain TYPE_DECLs declared
13415 storedecls (NULL_TREE
);
13417 for (parm
= nreverse (specparms
); parm
; parm
= next
)
13419 next
= TREE_CHAIN (parm
);
13420 if (TREE_CODE (parm
) == PARM_DECL
)
13423 if (DECL_NAME (parm
) == NULL_TREE
)
13427 else if (TREE_CODE (TREE_TYPE (parm
)) == VOID_TYPE
)
13428 cp_error ("parameter `%D' declared void", parm
);
13431 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
13432 A parameter is assumed not to have any side effects.
13433 If this should change for any reason, then this
13434 will have to wrap the bashed reference type in a save_expr.
13436 Also, if the parameter type is declared to be an X
13437 and there is an X(X&) constructor, we cannot lay it
13438 into the stack (any more), so we make this parameter
13439 look like it is really of reference type. Functions
13440 which pass parameters to this function will know to
13441 create a temporary in their frame, and pass a reference
13444 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
13445 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))))
13446 SET_DECL_REFERENCE_SLOT (parm
, convert_from_reference (parm
));
13450 if (! building_stmt_tree ()
13451 && (cleanup
= maybe_build_cleanup (parm
), cleanup
))
13453 expand_decl (parm
);
13454 parms_have_cleanups
= 1;
13456 /* Keep track of the cleanups. */
13457 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
13462 /* If we find an enum constant or a type tag,
13463 put it aside for the moment. */
13464 TREE_CHAIN (parm
) = NULL_TREE
;
13465 nonparms
= chainon (nonparms
, parm
);
13469 /* Get the decls in their original chain order
13470 and record in the function. This is all and only the
13471 PARM_DECLs that were pushed into scope by the loop above. */
13472 DECL_ARGUMENTS (fndecl
) = getdecls ();
13474 storetags (chainon (parmtags
, gettags ()));
13477 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13479 /* Now store the final chain of decls for the arguments
13480 as the decl-chain of the current lexical scope.
13481 Put the enumerators in as well, at the front so that
13482 DECL_ARGUMENTS is not modified. */
13484 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
13486 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
13487 declare_function_name ();
13489 /* Initialize the RTL code for the function. */
13490 DECL_SAVED_INSNS (fndecl
) = 0;
13491 if (! building_stmt_tree ())
13492 expand_function_start (fndecl
, parms_have_cleanups
);
13494 current_function_parms_stored
= 1;
13496 /* If this function is `main', emit a call to `__main'
13497 to run global initializers, etc. */
13498 if (DECL_MAIN_P (fndecl
) && !building_stmt_tree ())
13499 expand_main_function ();
13501 /* Now that we have initialized the parms, we can start their
13502 cleanups. We cannot do this before, since expand_decl_cleanup
13503 should not be called before the parm can be used. */
13504 if (cleanups
&& !building_stmt_tree ())
13506 for (cleanups
= nreverse (cleanups
); cleanups
; cleanups
= TREE_CHAIN (cleanups
))
13508 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups
), TREE_VALUE (cleanups
)))
13509 cp_error ("parser lost in parsing declaration of `%D'",
13510 TREE_PURPOSE (cleanups
));
13514 /* Create a binding contour which can be used to catch
13515 cleanup-generated temporaries. Also, if the return value needs or
13516 has initialization, deal with that now. */
13517 if (parms_have_cleanups
)
13520 if (!building_stmt_tree ())
13521 expand_start_bindings (0);
13524 if (! building_stmt_tree () && flag_exceptions
)
13526 /* Do the starting of the exception specifications, if we have any. */
13527 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
13528 expand_start_eh_spec ();
13531 last_parm_cleanup_insn
= get_last_insn ();
13532 last_dtor_insn
= get_last_insn ();
13535 /* Bind a name and initialization to the return value of
13536 the current function. */
13539 store_return_init (decl
)
13542 /* If this named return value comes in a register, put it in a
13543 pseudo-register. */
13544 if (DECL_REGISTER (decl
))
13546 original_result_rtx
= DECL_RTL (decl
);
13547 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
13552 /* Finish up a function declaration and compile that function
13553 all the way to assembler language output. The free the storage
13554 for the function definition.
13556 This is called after parsing the body of the function definition.
13557 LINENO is the current line number.
13559 FLAGS is a bitwise or of the following values:
13561 An extra call to poplevel (and expand_end_bindings) must be
13562 made to take care of the binding contour for the base
13563 initializers. This is only relevant for constructors.
13565 We just finished processing the body of an in-class inline
13566 function definition. (This processing will have taken place
13567 after the class definition is complete.)
13569 NESTED is nonzero if we were in the middle of compiling another function
13570 when we started on this one. */
13573 finish_function (lineno
, flags
, nested
)
13578 register tree fndecl
= current_function_decl
;
13579 tree fntype
, ctype
= NULL_TREE
;
13580 rtx fn_last_parm_insn
, insns
;
13581 /* Label to use if this function is supposed to return a value. */
13582 tree no_return_label
= NULL_TREE
;
13583 tree decls
= NULL_TREE
;
13584 int call_poplevel
= (flags
& 1) != 0;
13585 int inclass_inline
= (flags
& 2) != 0;
13588 /* When we get some parse errors, we can end up without a
13589 current_function_decl, so cope. */
13590 if (fndecl
== NULL_TREE
)
13593 if (function_depth
> 1)
13596 fntype
= TREE_TYPE (fndecl
);
13598 /* TREE_READONLY (fndecl) = 1;
13599 This caused &foo to be of type ptr-to-const-function
13600 which then got a warning when stored in a ptr-to-function variable. */
13602 /* This happens on strange parse errors. */
13603 if (! current_function_parms_stored
)
13606 store_parm_decls ();
13609 if (building_stmt_tree ())
13611 if (DECL_CONSTRUCTOR_P (fndecl
) && call_poplevel
)
13613 decls
= getdecls ();
13614 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13615 poplevel (decls
!= NULL_TREE
, 0, 0);
13620 if (write_symbols
!= NO_DEBUG
/*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13622 tree ttype
= target_type (fntype
);
13625 if (IS_AGGR_TYPE (ttype
))
13626 /* Let debugger know it should output info for this type. */
13627 note_debug_info_needed (ttype
);
13629 for (parmdecl
= DECL_ARGUMENTS (fndecl
); parmdecl
; parmdecl
= TREE_CHAIN (parmdecl
))
13631 ttype
= target_type (TREE_TYPE (parmdecl
));
13632 if (IS_AGGR_TYPE (ttype
))
13633 /* Let debugger know it should output info for this type. */
13634 note_debug_info_needed (ttype
);
13638 /* Clean house because we will need to reorder insns here. */
13639 do_pending_stack_adjust ();
13643 tree binfo
= TYPE_BINFO (current_class_type
);
13644 tree cond
= integer_one_node
;
13646 tree in_charge_node
= lookup_name (in_charge_identifier
, 0);
13648 int ok_to_optimize_dtor
= 0;
13649 int empty_dtor
= get_last_insn () == last_dtor_insn
;
13651 if (current_function_assigns_this
)
13652 cond
= build (NE_EXPR
, boolean_type_node
,
13653 current_class_ptr
, integer_zero_node
);
13656 int n_baseclasses
= CLASSTYPE_N_BASECLASSES (current_class_type
);
13658 /* If this destructor is empty, then we don't need to check
13659 whether `this' is NULL in some cases. */
13660 if ((flag_this_is_variable
& 1) == 0)
13661 ok_to_optimize_dtor
= 1;
13662 else if (empty_dtor
)
13663 ok_to_optimize_dtor
13664 = (n_baseclasses
== 0
13665 || (n_baseclasses
== 1
13666 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type
, 0))));
13669 /* These initializations might go inline. Protect
13670 the binding level of the parms. */
13672 expand_start_bindings (0);
13674 if (current_function_assigns_this
)
13676 current_function_assigns_this
= 0;
13677 current_function_just_assigned_this
= 0;
13680 /* Generate the code to call destructor on base class.
13681 If this destructor belongs to a class with virtual
13682 functions, then set the virtual function table
13683 pointer to represent the type of our base class. */
13685 /* This side-effect makes call to `build_delete' generate the
13686 code we have to have at the end of this destructor.
13687 `build_delete' will set the flag again. */
13688 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
13690 /* These are two cases where we cannot delegate deletion. */
13691 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)
13692 || TYPE_GETS_REG_DELETE (current_class_type
))
13693 exprstmt
= build_delete (current_class_type
, current_class_ref
, integer_zero_node
,
13694 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13696 exprstmt
= build_delete (current_class_type
, current_class_ref
, in_charge_node
,
13697 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13699 /* If we did not assign to this, then `this' is non-zero at
13700 the end of a destructor. As a special optimization, don't
13701 emit test if this is an empty destructor. If it does nothing,
13702 it does nothing. If it calls a base destructor, the base
13703 destructor will perform the test. */
13705 if (exprstmt
!= error_mark_node
13706 && (TREE_CODE (exprstmt
) != NOP_EXPR
13707 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
13708 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
13710 expand_label (dtor_label
);
13711 if (cond
!= integer_one_node
)
13712 expand_start_cond (cond
, 0);
13713 if (exprstmt
!= void_zero_node
)
13714 /* Don't call `expand_expr_stmt' if we're not going to do
13715 anything, since -Wall will give a diagnostic. */
13716 expand_expr_stmt (exprstmt
);
13718 /* Run destructor on all virtual baseclasses. */
13719 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13721 tree vbases
= nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type
)));
13722 expand_start_cond (build (BIT_AND_EXPR
, integer_type_node
,
13723 in_charge_node
, integer_two_node
), 0);
13726 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases
)))
13728 tree vb
= get_vbase
13729 (BINFO_TYPE (vbases
),
13730 TYPE_BINFO (current_class_type
));
13732 (build_scoped_method_call
13733 (current_class_ref
, vb
, dtor_identifier
,
13734 build_expr_list (NULL_TREE
, integer_zero_node
)));
13736 vbases
= TREE_CHAIN (vbases
);
13738 expand_end_cond ();
13741 do_pending_stack_adjust ();
13742 if (cond
!= integer_one_node
)
13743 expand_end_cond ();
13746 virtual_size
= c_sizeof (current_class_type
);
13748 /* At the end, call delete if that's what's requested. */
13750 /* FDIS sez: At the point of definition of a virtual destructor
13751 (including an implicit definition), non-placement operator
13752 delete shall be looked up in the scope of the destructor's
13753 class and if found shall be accessible and unambiguous.
13755 This is somewhat unclear, but I take it to mean that if the
13756 class only defines placement deletes we don't do anything here.
13757 So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain
13758 for us if they ever try to delete one of these. */
13760 if (TYPE_GETS_REG_DELETE (current_class_type
)
13761 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13762 exprstmt
= build_op_delete_call
13763 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
13764 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
13766 exprstmt
= NULL_TREE
;
13770 cond
= build (BIT_AND_EXPR
, integer_type_node
,
13771 in_charge_node
, integer_one_node
);
13772 expand_start_cond (cond
, 0);
13773 expand_expr_stmt (exprstmt
);
13774 expand_end_cond ();
13777 /* End of destructor. */
13778 expand_end_bindings (NULL_TREE
, getdecls () != NULL_TREE
, 0);
13779 poplevel (getdecls () != NULL_TREE
, 0, 0);
13781 /* Back to the top of destructor. */
13782 /* Don't execute destructor code if `this' is NULL. */
13786 /* If the dtor is empty, and we know there is not possible way we
13787 could use any vtable entries, before they are possibly set by
13788 a base class dtor, we don't have to setup the vtables, as we
13789 know that any base class dtoring will set up any vtables it
13790 needs. We avoid MI, because one base class dtor can do a
13791 virtual dispatch to an overridden function that would need to
13792 have a non-related vtable set up, we cannot avoid setting up
13793 vtables in that case. We could change this to see if there is
13794 just one vtable. */
13795 if (! empty_dtor
|| TYPE_USES_COMPLEX_INHERITANCE (current_class_type
))
13797 /* Make all virtual function table pointers in non-virtual base
13798 classes point to CURRENT_CLASS_TYPE's virtual function
13800 expand_direct_vtbls_init (binfo
, binfo
, 1, 0, current_class_ptr
);
13802 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13803 expand_indirect_vtbls_init (binfo
, current_class_ref
, current_class_ptr
);
13806 if (! ok_to_optimize_dtor
)
13808 cond
= build_binary_op (NE_EXPR
,
13809 current_class_ptr
, integer_zero_node
);
13810 expand_start_cond (cond
, 0);
13813 insns
= get_insns ();
13816 fn_last_parm_insn
= get_first_nonparm_insn ();
13817 if (fn_last_parm_insn
== NULL_RTX
)
13818 fn_last_parm_insn
= get_last_insn ();
13820 fn_last_parm_insn
= previous_insn (fn_last_parm_insn
);
13822 emit_insns_after (insns
, fn_last_parm_insn
);
13824 if (! ok_to_optimize_dtor
)
13825 expand_end_cond ();
13827 else if (current_function_assigns_this
)
13829 /* Does not need to call emit_base_init, because
13830 that is done (if needed) just after assignment to this
13833 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13835 end_protect_partials ();
13836 expand_label (ctor_label
);
13837 ctor_label
= NULL_TREE
;
13841 decls
= getdecls ();
13842 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13843 poplevel (decls
!= NULL_TREE
, 0, 0);
13845 /* c_expand_return knows to return 'this' from a constructor. */
13846 c_expand_return (NULL_TREE
);
13848 else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl
))) != VOID_TYPE
13849 && return_label
!= NULL_RTX
)
13850 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13852 current_function_assigns_this
= 0;
13853 current_function_just_assigned_this
= 0;
13854 base_init_expr
= NULL_TREE
;
13856 else if (DECL_CONSTRUCTOR_P (fndecl
))
13858 tree cond
= NULL_TREE
, thenclause
= NULL_TREE
;
13859 /* Allow constructor for a type to get a new instance of the object
13860 using `build_new'. */
13861 tree abstract_virtuals
= CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
);
13862 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = NULL_TREE
;
13864 if (flag_this_is_variable
> 0)
13866 cond
= build_binary_op (EQ_EXPR
,
13867 current_class_ptr
, integer_zero_node
);
13868 thenclause
= build_modify_expr (current_class_ptr
, NOP_EXPR
,
13869 build_new (NULL_TREE
, current_class_type
, void_type_node
, 0));
13872 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = abstract_virtuals
;
13876 if (flag_this_is_variable
> 0)
13878 expand_start_cond (cond
, 0);
13879 expand_expr_stmt (thenclause
);
13880 expand_end_cond ();
13883 /* Emit insns from `emit_base_init' which sets up virtual
13884 function table pointer(s). */
13885 if (base_init_expr
)
13887 expand_expr_stmt (base_init_expr
);
13888 base_init_expr
= NULL_TREE
;
13891 insns
= get_insns ();
13894 /* This is where the body of the constructor begins. */
13896 emit_insns_after (insns
, last_parm_cleanup_insn
);
13898 end_protect_partials ();
13900 /* This is where the body of the constructor ends. */
13901 expand_label (ctor_label
);
13902 ctor_label
= NULL_TREE
;
13906 decls
= getdecls ();
13907 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13908 poplevel (decls
!= NULL_TREE
, 1, 0);
13911 /* c_expand_return knows to return 'this' from a constructor. */
13912 c_expand_return (NULL_TREE
);
13914 current_function_assigns_this
= 0;
13915 current_function_just_assigned_this
= 0;
13917 else if (DECL_MAIN_P (fndecl
))
13919 /* Make it so that `main' always returns 0 by default. */
13921 c_expand_return (integer_one_node
);
13923 c_expand_return (integer_zero_node
);
13926 else if (return_label
!= NULL_RTX
13927 && current_function_return_value
== NULL_TREE
13928 && ! DECL_NAME (DECL_RESULT (current_function_decl
)))
13929 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13931 if (flag_exceptions
)
13932 expand_exception_blocks ();
13934 /* If this function is supposed to return a value, ensure that
13935 we do not fall into the cleanups by mistake. The end of our
13936 function will look like this:
13938 user code (may have return stmt somewhere)
13939 goto no_return_label
13944 NOTE_INSN_FUNCTION_END
13948 If the user omits a return stmt in the USER CODE section, we
13949 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13950 Otherwise, we won't. */
13951 if (no_return_label
)
13953 DECL_CONTEXT (no_return_label
) = fndecl
;
13954 DECL_INITIAL (no_return_label
) = error_mark_node
;
13955 DECL_SOURCE_FILE (no_return_label
) = input_filename
;
13956 DECL_SOURCE_LINE (no_return_label
) = lineno
;
13957 expand_goto (no_return_label
);
13962 /* Remove the binding contour which is used
13963 to catch cleanup-generated temporaries. */
13964 expand_end_bindings (0, 0, 0);
13965 poplevel (0, 0, 0);
13967 /* Emit label at beginning of cleanup code for parameters. */
13968 emit_label (cleanup_label
);
13971 /* Get return value into register if that's where it's supposed to be. */
13972 if (original_result_rtx
)
13973 fixup_result_decl (DECL_RESULT (fndecl
), original_result_rtx
);
13975 /* Finish building code that will trigger warnings if users forget
13976 to make their functions return values. */
13977 if (no_return_label
|| cleanup_label
)
13978 emit_jump (return_label
);
13979 if (no_return_label
)
13981 /* We don't need to call `expand_*_return' here because we
13982 don't need any cleanups here--this path of code is only
13983 for error checking purposes. */
13984 expand_label (no_return_label
);
13987 /* We hard-wired immediate_size_expand to zero in
13988 start_function. Expand_function_end will decrement this
13989 variable. So, we set the variable to one here, so that after
13990 the decrement it will remain zero. */
13991 immediate_size_expand
= 1;
13993 /* Generate rtl for function exit. */
13994 expand_function_end (input_filename
, lineno
, 1);
13997 /* We have to save this value here in case
13998 maybe_end_member_template_processing decides to pop all the
13999 template parameters. */
14000 expand_p
= !building_stmt_tree ();
14002 /* If we're saving up tree structure, tie off the function now. */
14004 finish_stmt_tree (fndecl
);
14006 /* This must come after expand_function_end because cleanups might
14007 have declarations (from inline functions) that need to go into
14008 this function's blocks. */
14009 if (current_binding_level
->parm_flag
!= 1)
14010 my_friendly_abort (122);
14011 poplevel (1, 0, 1);
14013 /* If this is a in-class inline definition, we may have to pop the
14014 bindings for the template parameters that we added in
14015 maybe_begin_member_template_processing when start_function was
14017 if (inclass_inline
)
14018 maybe_end_member_template_processing ();
14020 /* Reset scope for C++: if we were in the scope of a class,
14021 then when we finish this function, we are not longer so.
14022 This cannot be done until we know for sure that no more
14023 class members will ever be referenced in this function
14024 (i.e., calls to destructors). */
14025 if (current_class_name
)
14027 ctype
= current_class_type
;
14028 pop_nested_class ();
14031 /* Must mark the RESULT_DECL as being in this function. */
14032 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14034 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14035 to the FUNCTION_DECL node itself. */
14036 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14038 /* Undo the call to push_momentary in start_function. */
14043 int saved_flag_keep_inline_functions
=
14044 flag_keep_inline_functions
;
14046 /* So we can tell if jump_optimize sets it to 1. */
14049 if (DECL_CONTEXT (fndecl
) != NULL_TREE
14050 && hack_decl_function_context (fndecl
))
14051 /* Trick rest_of_compilation into not deferring output of this
14052 function, even if it is inline, since the rtl_obstack for
14053 this function is the function_obstack of the enclosing
14054 function and will be deallocated when the enclosing
14055 function is gone. See save_tree_status. */
14056 flag_keep_inline_functions
= 1;
14058 /* Run the optimizers and output the assembler code for this
14061 if (DECL_ARTIFICIAL (fndecl
))
14063 /* Do we really *want* to inline this synthesized method? */
14065 int save_fif
= flag_inline_functions
;
14066 flag_inline_functions
= 1;
14068 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
14069 will check our size. */
14070 DECL_INLINE (fndecl
) = 0;
14072 rest_of_compilation (fndecl
);
14073 flag_inline_functions
= save_fif
;
14076 rest_of_compilation (fndecl
);
14078 flag_keep_inline_functions
= saved_flag_keep_inline_functions
;
14080 if (DECL_SAVED_INSNS (fndecl
) && ! TREE_ASM_WRITTEN (fndecl
))
14082 /* Set DECL_EXTERNAL so that assemble_external will be called as
14083 necessary. We'll clear it again in finish_file. */
14084 if (! DECL_EXTERNAL (fndecl
))
14085 DECL_NOT_REALLY_EXTERN (fndecl
) = 1;
14086 DECL_EXTERNAL (fndecl
) = 1;
14087 mark_inline_for_output (fndecl
);
14090 if (ctype
&& TREE_ASM_WRITTEN (fndecl
))
14091 note_debug_info_needed (ctype
);
14093 current_function_returns_null
|= can_reach_end
;
14095 /* Since we don't normally go through c_expand_return for constructors,
14096 this normally gets the wrong value.
14097 Also, named return values have their return codes emitted after
14098 NOTE_INSN_FUNCTION_END, confusing jump.c. */
14099 if (DECL_CONSTRUCTOR_P (fndecl
)
14100 || DECL_NAME (DECL_RESULT (fndecl
)) != NULL_TREE
)
14101 current_function_returns_null
= 0;
14103 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
14104 cp_warning ("`noreturn' function `%D' does return", fndecl
);
14105 else if ((warn_return_type
|| pedantic
)
14106 && current_function_returns_null
14107 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
)
14109 /* If this function returns non-void and control can drop through,
14111 cp_warning ("control reaches end of non-void function `%D'", fndecl
);
14113 /* With just -W, complain only if function returns both with
14114 and without a value. */
14115 else if (extra_warnings
14116 && current_function_returns_value
&& current_function_returns_null
)
14117 warning ("this function may return with or without a value");
14122 /* Free all the tree nodes making up this function. */
14123 /* Switch back to allocating nodes permanently
14124 until we start another function. */
14126 permanent_allocation (1);
14128 if (DECL_SAVED_INSNS (fndecl
) == 0)
14132 /* Stop pointing to the local nodes about to be freed. */
14133 /* But DECL_INITIAL must remain nonzero so we know this
14134 was an actual function definition. */
14135 DECL_INITIAL (fndecl
) = error_mark_node
;
14136 for (t
= DECL_ARGUMENTS (fndecl
); t
; t
= TREE_CHAIN (t
))
14137 DECL_RTL (t
) = DECL_INCOMING_RTL (t
) = NULL_RTX
;
14140 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
14141 static_ctors
= perm_tree_cons (NULL_TREE
, fndecl
, static_ctors
);
14142 if (DECL_STATIC_DESTRUCTOR (fndecl
))
14143 static_dtors
= perm_tree_cons (NULL_TREE
, fndecl
, static_dtors
);
14147 /* Let the error reporting routines know that we're outside a
14148 function. For a nested function, this value is used in
14149 pop_cp_function_context and then reset via pop_function_context. */
14150 current_function_decl
= NULL_TREE
;
14153 named_label_uses
= NULL
;
14154 current_class_ptr
= NULL_TREE
;
14155 current_class_ref
= NULL_TREE
;
14158 /* Create the FUNCTION_DECL for a function definition.
14159 DECLSPECS and DECLARATOR are the parts of the declaration;
14160 they describe the return type and the name of the function,
14161 but twisted together in a fashion that parallels the syntax of C.
14163 This function creates a binding context for the function body
14164 as well as setting up the FUNCTION_DECL in current_function_decl.
14166 Returns a FUNCTION_DECL on success.
14168 If the DECLARATOR is not suitable for a function (it defines a datum
14169 instead), we return 0, which tells yyparse to report a parse error.
14171 May return void_type_node indicating that this method is actually
14172 a friend. See grokfield for more details.
14174 Came here with a `.pushlevel' .
14176 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14177 CHANGES TO CODE IN `grokfield'. */
14180 start_method (declspecs
, declarator
, attrlist
)
14181 tree declarator
, declspecs
, attrlist
;
14183 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14186 /* Something too ugly to handle. */
14187 if (fndecl
== NULL_TREE
)
14190 /* Pass friends other than inline friend functions back. */
14191 if (fndecl
== void_type_node
)
14194 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
14195 /* Not a function, tell parser to report parse error. */
14198 if (DECL_IN_AGGR_P (fndecl
))
14200 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
14202 if (DECL_CONTEXT (fndecl
)
14203 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
14204 cp_error ("`%D' is already defined in class %s", fndecl
,
14205 TYPE_NAME_STRING (DECL_CONTEXT (fndecl
)));
14207 return void_type_node
;
14210 check_template_shadow (fndecl
);
14212 DECL_THIS_INLINE (fndecl
) = 1;
14214 if (flag_default_inline
)
14215 DECL_INLINE (fndecl
) = 1;
14217 /* We process method specializations in finish_struct_1. */
14218 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14219 fndecl
= push_template_decl (fndecl
);
14221 /* We read in the parameters on the maybepermanent_obstack,
14222 but we won't be getting back to them until after we
14223 may have clobbered them. So the call to preserve_data
14224 will keep them safe. */
14227 if (! DECL_FRIEND_P (fndecl
))
14229 if (TREE_CHAIN (fndecl
))
14231 fndecl
= copy_node (fndecl
);
14232 TREE_CHAIN (fndecl
) = NULL_TREE
;
14235 if (DECL_CONSTRUCTOR_P (fndecl
))
14237 if (! grok_ctor_properties (current_class_type
, fndecl
))
14238 return void_type_node
;
14240 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
14241 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
14244 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0, 0);
14246 /* Make a place for the parms */
14248 current_binding_level
->parm_flag
= 1;
14250 DECL_IN_AGGR_P (fndecl
) = 1;
14254 /* Go through the motions of finishing a function definition.
14255 We don't compile this method until after the whole class has
14258 FINISH_METHOD must return something that looks as though it
14259 came from GROKFIELD (since we are defining a method, after all).
14261 This is called after parsing the body of the function definition.
14262 STMTS is the chain of statements that makes up the function body.
14264 DECL is the ..._DECL that `start_method' provided. */
14267 finish_method (decl
)
14270 register tree fndecl
= decl
;
14273 register tree link
;
14275 if (decl
== void_type_node
)
14278 old_initial
= DECL_INITIAL (fndecl
);
14280 /* Undo the level for the parms (from start_method).
14281 This is like poplevel, but it causes nothing to be
14282 saved. Saving information here confuses symbol-table
14283 output routines. Besides, this information will
14284 be correctly output when this method is actually
14287 /* Clear out the meanings of the local variables of this level;
14288 also record in each decl which block it belongs to. */
14290 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
14292 if (DECL_NAME (link
) != NULL_TREE
)
14293 pop_binding (DECL_NAME (link
), link
);
14294 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
14295 DECL_CONTEXT (link
) = NULL_TREE
;
14298 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
14299 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
14300 current_binding_level
->parm_flag
,
14301 current_binding_level
->keep
);
14303 poplevel (0, 0, 0);
14305 DECL_INITIAL (fndecl
) = old_initial
;
14307 /* We used to check if the context of FNDECL was different from
14308 current_class_type as another way to get inside here. This didn't work
14309 for String.cc in libg++. */
14310 if (DECL_FRIEND_P (fndecl
))
14312 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
14313 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
14314 decl
= void_type_node
;
14320 /* Called when a new struct TYPE is defined.
14321 If this structure or union completes the type of any previous
14322 variable declaration, lay it out and output its rtl. */
14325 hack_incomplete_structures (type
)
14330 if (current_binding_level
->incomplete
== NULL_TREE
)
14333 if (!type
) /* Don't do this for class templates. */
14336 for (list
= ¤t_binding_level
->incomplete
; *list
; )
14338 tree decl
= TREE_VALUE (*list
);
14339 if ((decl
&& TREE_TYPE (decl
) == type
)
14340 || (TREE_TYPE (decl
)
14341 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14342 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
14344 int toplevel
= toplevel_bindings_p ();
14345 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14346 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
14347 layout_type (TREE_TYPE (decl
));
14348 layout_decl (decl
, 0);
14349 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
14353 expand_decl (decl
);
14354 cleanup
= maybe_build_cleanup (decl
);
14355 expand_decl_init (decl
);
14356 if (! expand_decl_cleanup (decl
, cleanup
))
14357 cp_error ("parser lost in parsing declaration of `%D'",
14360 *list
= TREE_CHAIN (*list
);
14363 list
= &TREE_CHAIN (*list
);
14367 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14368 See build_delete for information about AUTO_DELETE.
14370 Don't build these on the momentary obstack; they must live
14371 the life of the binding contour. */
14374 maybe_build_cleanup_1 (decl
, auto_delete
)
14375 tree decl
, auto_delete
;
14377 tree type
= TREE_TYPE (decl
);
14378 if (type
!= error_mark_node
&& TYPE_NEEDS_DESTRUCTOR (type
))
14380 int temp
= 0, flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14383 if (TREE_CODE (decl
) != PARM_DECL
)
14384 temp
= suspend_momentary ();
14386 if (TREE_CODE (type
) == ARRAY_TYPE
)
14390 mark_addressable (decl
);
14391 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
14394 /* Optimize for space over speed here. */
14395 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
14396 || flag_expensive_optimizations
)
14397 flags
|= LOOKUP_NONVIRTUAL
;
14399 rval
= build_delete (TREE_TYPE (rval
), rval
, auto_delete
, flags
, 0);
14401 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
14402 && ! TYPE_HAS_DESTRUCTOR (type
))
14403 rval
= build_compound_expr (expr_tree_cons (NULL_TREE
, rval
,
14404 build_expr_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
14406 if (TREE_CODE (decl
) != PARM_DECL
)
14407 resume_momentary (temp
);
14414 /* If DECL is of a type which needs a cleanup, build that cleanup
14415 here. The cleanup does free the storage with a call to delete. */
14418 maybe_build_cleanup_and_delete (decl
)
14421 return maybe_build_cleanup_1 (decl
, integer_three_node
);
14424 /* If DECL is of a type which needs a cleanup, build that cleanup
14425 here. The cleanup does not free the storage with a call a delete. */
14428 maybe_build_cleanup (decl
)
14431 return maybe_build_cleanup_1 (decl
, integer_two_node
);
14434 /* Expand a C++ expression at the statement level.
14435 This is needed to ferret out nodes which have UNKNOWN_TYPE.
14436 The C++ type checker should get all of these out when
14437 expressions are combined with other, type-providing, expressions,
14438 leaving only orphan expressions, such as:
14440 &class::bar; / / takes its address, but does nothing with it. */
14443 cplus_expand_expr_stmt (exp
)
14446 exp
= require_complete_type_in_void (exp
);
14448 if (TREE_CODE (exp
) == FUNCTION_DECL
)
14450 cp_warning ("reference, not call, to function `%D'", exp
);
14451 warning ("at this point in file");
14455 /* We should do this eventually, but right now this causes regex.o from
14456 libg++ to miscompile, and tString to core dump. */
14457 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
14460 /* Strip unused implicit INDIRECT_REFs of references. */
14461 if (TREE_CODE (exp
) == INDIRECT_REF
14462 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
14463 exp
= TREE_OPERAND (exp
, 0);
14465 /* If we don't do this, we end up down inside expand_expr
14466 trying to do TYPE_MODE on the ERROR_MARK, and really
14467 go outside the bounds of the type. */
14468 if (exp
!= error_mark_node
)
14469 expand_expr_stmt (break_out_cleanups (exp
));
14472 /* When a stmt has been parsed, this function is called. */
14477 if (!current_function_assigns_this
14478 && current_function_just_assigned_this
)
14480 if (DECL_CONSTRUCTOR_P (current_function_decl
))
14482 /* Constructors must wait until we are out of control
14483 zones before calling base constructors. */
14484 if (in_control_zone_p ())
14486 expand_expr_stmt (base_init_expr
);
14487 check_base_init (current_class_type
);
14489 current_function_assigns_this
= 1;
14492 /* Always assume this statement was not an expression statement. If
14493 it actually was an expression statement, its our callers
14494 responsibility to fix this up. */
14495 last_expr_type
= NULL_TREE
;
14498 /* Change a static member function definition into a FUNCTION_TYPE, instead
14499 of the METHOD_TYPE that we create when it's originally parsed.
14501 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14502 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14503 other decls. Either pass the addresses of local variables or NULL. */
14506 revert_static_member_fn (decl
, fn
, argtypes
)
14507 tree
*decl
, *fn
, *argtypes
;
14510 tree function
= fn
? *fn
: TREE_TYPE (*decl
);
14511 tree args
= argtypes
? *argtypes
: TYPE_ARG_TYPES (function
);
14513 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
14514 != TYPE_UNQUALIFIED
)
14515 cp_error ("static member function `%#D' declared with type qualifiers",
14518 args
= TREE_CHAIN (args
);
14519 tmp
= build_function_type (TREE_TYPE (function
), args
);
14520 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
14521 tmp
= build_exception_variant (tmp
,
14522 TYPE_RAISES_EXCEPTIONS (function
));
14523 TREE_TYPE (*decl
) = tmp
;
14524 if (DECL_ARGUMENTS (*decl
))
14525 DECL_ARGUMENTS (*decl
) = TREE_CHAIN (DECL_ARGUMENTS (*decl
));
14526 DECL_STATIC_FUNCTION_P (*decl
) = 1;
14533 /* Save and reinitialize the variables
14534 used during compilation of a C++ function. */
14537 push_cp_function_context (f
)
14538 struct function
*f
;
14540 struct language_function
*p
14541 = ((struct language_function
*)
14542 xmalloc (sizeof (struct language_function
)));
14545 *p
= *f
->next
->language
;
14547 bzero (p
, sizeof (struct language_function
));
14549 /* For now, we always assume we're expanding all the way to RTL
14550 unless we're explicitly doing otherwise. */
14553 /* Whenever we start a new function, we destroy temporaries in the
14555 stmts_are_full_exprs_p
= 1;
14558 /* Restore the variables used during compilation of a C++ function. */
14561 pop_cp_function_context (f
)
14562 struct function
*f
;
14564 free (f
->language
);
14569 mark_cp_function_context (f
)
14570 struct function
*f
;
14572 struct language_function
*p
= f
->language
;
14574 ggc_mark_tree (p
->x_named_labels
);
14575 ggc_mark_tree (p
->x_ctor_label
);
14576 ggc_mark_tree (p
->x_dtor_label
);
14577 ggc_mark_tree (p
->x_base_init_list
);
14578 ggc_mark_tree (p
->x_member_init_list
);
14579 ggc_mark_tree (p
->x_base_init_expr
);
14580 ggc_mark_tree (p
->x_current_class_ptr
);
14581 ggc_mark_tree (p
->x_current_class_ref
);
14582 ggc_mark_tree (p
->x_last_tree
);
14583 ggc_mark_tree (p
->x_last_expr_type
);
14585 ggc_mark_rtx (p
->x_last_dtor_insn
);
14586 ggc_mark_rtx (p
->x_last_parm_cleanup_insn
);
14587 ggc_mark_rtx (p
->x_result_rtx
);
14589 mark_binding_level (&p
->binding_level
);
14596 return function_depth
!= 0;
14601 lang_mark_false_label_stack (l
)
14602 struct label_node
*l
;
14604 /* C++ doesn't use false_label_stack. It better be NULL. */
14605 my_friendly_assert (l
!= NULL
, 19990904);
14612 enum tree_code code
= TREE_CODE (t
);
14613 if (code
== IDENTIFIER_NODE
)
14615 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
14616 struct lang_id2
*li2
= li
->x
;
14617 ggc_mark_tree (li
->namespace_bindings
);
14618 ggc_mark_tree (li
->class_value
);
14619 ggc_mark_tree (li
->class_template_info
);
14623 ggc_mark_tree (li2
->label_value
);
14624 ggc_mark_tree (li2
->implicit_decl
);
14625 ggc_mark_tree (li2
->error_locus
);
14628 else if (TREE_CODE_CLASS (code
) == 'd')
14630 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
14634 ggc_mark_tree (ld
->decl_flags
.access
);
14635 ggc_mark_tree (ld
->decl_flags
.context
);
14636 if (TREE_CODE (t
) != NAMESPACE_DECL
)
14637 ggc_mark_tree (ld
->decl_flags
.u
.template_info
);
14638 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
14640 ggc_mark_tree (ld
->main_decl_variant
);
14641 ggc_mark_tree (ld
->befriending_classes
);
14642 ggc_mark_tree (ld
->saved_tree
);
14643 if (TREE_CODE (t
) == TYPE_DECL
)
14644 ggc_mark_tree (ld
->u
.sorted_fields
);
14648 else if (TREE_CODE_CLASS (code
) == 't')
14650 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
14654 ggc_mark_tree (lt
->vfields
);
14655 ggc_mark_tree (lt
->vbases
);
14656 ggc_mark_tree (lt
->tags
);
14657 ggc_mark_tree (lt
->search_slot
);
14658 ggc_mark_tree (lt
->size
);
14659 ggc_mark_tree (lt
->abstract_virtuals
);
14660 ggc_mark_tree (lt
->friend_classes
);
14661 ggc_mark_tree (lt
->rtti
);
14662 ggc_mark_tree (lt
->methods
);
14663 ggc_mark_tree (lt
->template_info
);
14669 lang_cleanup_tree (t
)
14672 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't'
14673 && TYPE_LANG_SPECIFIC (t
) != NULL
)
14676 /* This is currently allocated with an obstack. This will change. */
14677 free (TYPE_LANG_SPECIFIC (t
));