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. */
47 #define obstack_chunk_alloc xmalloc
48 #define obstack_chunk_free free
50 extern struct obstack permanent_obstack
;
51 extern struct obstack
* saveable_obstack
;
53 extern int current_class_depth
;
55 extern tree static_ctors
, static_dtors
;
57 extern tree current_namespace
;
58 extern tree global_namespace
;
60 extern int (*valid_lang_attribute
) PROTO ((tree
, tree
, tree
, tree
));
62 /* Obstack used for remembering local class declarations (like
63 enums and static (const) members. */
65 struct obstack decl_obstack
;
66 static struct stack_level
*decl_stack
;
68 #ifndef CHAR_TYPE_SIZE
69 #define CHAR_TYPE_SIZE BITS_PER_UNIT
72 #ifndef SHORT_TYPE_SIZE
73 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
77 #define INT_TYPE_SIZE BITS_PER_WORD
80 #ifndef LONG_TYPE_SIZE
81 #define LONG_TYPE_SIZE BITS_PER_WORD
84 #ifndef LONG_LONG_TYPE_SIZE
85 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
88 #ifndef WCHAR_UNSIGNED
89 #define WCHAR_UNSIGNED 0
92 #ifndef FLOAT_TYPE_SIZE
93 #define FLOAT_TYPE_SIZE BITS_PER_WORD
96 #ifndef DOUBLE_TYPE_SIZE
97 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
100 #ifndef LONG_DOUBLE_TYPE_SIZE
101 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
104 #ifndef BOOL_TYPE_SIZE
105 #ifdef SLOW_BYTE_ACCESS
106 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
108 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
112 /* We let tm.h override the types used here, to handle trivial differences
113 such as the choice of unsigned int or long unsigned int for size_t.
114 When machines start needing nontrivial differences in the size type,
115 it would be best to do something here to figure out automatically
116 from other information what type to use. */
119 #define SIZE_TYPE "long unsigned int"
123 #define PTRDIFF_TYPE "long int"
127 #define WCHAR_TYPE "int"
130 static tree grokparms
PROTO((tree
, int));
131 static const char *redeclaration_error_message
PROTO((tree
, tree
));
133 static struct stack_level
*push_decl_level
PROTO((struct stack_level
*,
135 static void push_binding_level
PROTO((struct binding_level
*, int,
137 static void pop_binding_level
PROTO((void));
138 static void suspend_binding_level
PROTO((void));
139 static void resume_binding_level
PROTO((struct binding_level
*));
140 static struct binding_level
*make_binding_level
PROTO((void));
141 static void declare_namespace_level
PROTO((void));
142 static void signal_catch
PROTO((int)) ATTRIBUTE_NORETURN
;
143 static void storedecls
PROTO((tree
));
144 static void require_complete_types_for_parms
PROTO((tree
));
145 static void push_overloaded_decl_1
PROTO((tree
));
146 static int ambi_op_p
PROTO((tree
));
147 static int unary_op_p
PROTO((tree
));
148 static tree store_bindings
PROTO((tree
, tree
));
149 static tree lookup_tag_reverse
PROTO((tree
, tree
));
150 static tree obscure_complex_init
PROTO((tree
, tree
));
151 static tree maybe_build_cleanup_1
PROTO((tree
, tree
));
152 static tree lookup_name_real
PROTO((tree
, int, int, int));
153 static void warn_extern_redeclared_static
PROTO((tree
, tree
));
154 static void grok_reference_init
PROTO((tree
, tree
, tree
));
155 static tree grokfndecl
PROTO((tree
, tree
, tree
, tree
, int,
156 enum overload_flags
, tree
,
157 tree
, int, int, int, int, int, int, tree
));
158 static tree grokvardecl
PROTO((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
159 static tree lookup_tag
PROTO((enum tree_code
, tree
,
160 struct binding_level
*, int));
161 static void set_identifier_type_value_with_scope
162 PROTO((tree
, tree
, struct binding_level
*));
163 static void record_builtin_type
PROTO((enum rid
, const char *, tree
));
164 static void record_unknown_type
PROTO((tree
, const char *));
165 static int member_function_or_else
PROTO((tree
, tree
, const char *));
166 static void bad_specifiers
PROTO((tree
, const char *, int, int, int, int,
168 static void lang_print_error_function
PROTO((const char *));
169 static tree maybe_process_template_type_declaration
PROTO((tree
, int, struct binding_level
*));
170 static void check_for_uninitialized_const_var
PROTO((tree
));
171 static unsigned long typename_hash
PROTO((hash_table_key
));
172 static boolean typename_compare
PROTO((hash_table_key
, hash_table_key
));
173 static void push_binding
PROTO((tree
, tree
, struct binding_level
*));
174 static int add_binding
PROTO((tree
, tree
));
175 static void pop_binding
PROTO((tree
, tree
));
176 static tree local_variable_p
PROTO((tree
));
177 static tree find_binding
PROTO((tree
, tree
));
178 static tree select_decl
PROTO((tree
, int));
179 static int lookup_flags
PROTO((int, int));
180 static tree qualify_lookup
PROTO((tree
, int));
181 static tree record_builtin_java_type
PROTO((const char *, int));
182 static const char *tag_name
PROTO((enum tag_types code
));
183 static void find_class_binding_level
PROTO((void));
184 static struct binding_level
*innermost_nonclass_level
PROTO((void));
185 static tree poplevel_class
PROTO((void));
186 static void warn_about_implicit_typename_lookup
PROTO((tree
, tree
));
187 static int walk_namespaces_r
PROTO((tree
, walk_namespaces_fn
, void *));
188 static int walk_globals_r
PROTO((tree
, void *));
189 static void add_decl_to_level
PROTO((tree
, struct binding_level
*));
190 static tree make_label_decl
PROTO((tree
, int));
191 static void pop_label
PROTO((tree
));
192 static void pop_labels
PROTO((tree
));
193 static void maybe_deduce_size_from_array_init
PROTO((tree
, tree
));
194 static void layout_var_decl
PROTO((tree
, tree
*));
195 static void maybe_commonize_var
PROTO((tree
));
196 static tree build_cleanup_on_safe_obstack
PROTO((tree
));
197 static void check_initializer
PROTO((tree
, tree
*));
198 static void make_rtl_for_nonlocal_decl
PROTO((tree
, tree
, const char *));
199 static void push_cp_function_context
PROTO((struct function
*));
200 static void pop_cp_function_context
PROTO((struct function
*));
202 #if defined (DEBUG_CP_BINDING_LEVELS)
203 static void indent
PROTO((void));
206 /* A node which has tree code ERROR_MARK, and whose type is itself.
207 All erroneous expressions are replaced with this node. All functions
208 that accept nodes as arguments should avoid generating error messages
209 if this node is one of the arguments, since it is undesirable to get
210 multiple error messages from one error in the input. */
212 tree error_mark_node
;
214 /* Erroneous argument lists can use this *IFF* they do not modify it. */
215 tree error_mark_list
;
217 /* The following symbols are subsumed in the cp_global_trees array, and
218 listed here individually for documentation purposes.
221 tree wchar_decl_node;
224 tree vtable_entry_type;
225 tree delta_type_node;
228 tree __baselist_desc_type_node;
229 tree __i_desc_type_node, __m_desc_type_node;
230 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
232 tree __t_desc_type_node;
234 tree __tp_desc_type_node;
236 tree __access_mode_type_node;
237 tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
238 tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
239 tree __ptmf_desc_type_node, __ptmd_desc_type_node;
241 Not needed yet? May be needed one day?
242 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
243 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
244 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
247 tree class_star_type_node;
248 tree class_type_node, record_type_node, union_type_node, enum_type_node;
249 tree unknown_type_node;
251 Array type `vtable_entry_type[]'
254 tree vtbl_ptr_type_node;
260 A FUNCTION_DECL which can call `abort'. Not necessarily the
261 one that the user will declare, but sufficient to be called
262 by routines that want to abort the program.
266 The FUNCTION_DECL for the default `::operator delete'.
268 tree global_delete_fndecl;
271 tree type_info_type_node, tinfo_fn_id, tinfo_fn_type;
275 tree cp_global_trees
[CPTI_MAX
];
277 /* These can't be part of the above array, since they are declared
278 individually in tree.h, and used by the debug output routines. */
282 tree integer_type_node
;
283 tree unsigned_type_node
;
285 /* These can't be part of the above array, since they are declared
286 individially in tree.h and used by the target routines. */
289 tree va_list_type_node
;
291 /* Indicates that there is a type value in some namespace, although
292 that is not necessarily in scope at the moment. */
294 static tree global_type_node
;
299 /* Expect only namespace names now. */
300 static int only_namespace_names
;
302 /* In a destructor, the last insn emitted after the start of the
303 function and the parms. */
305 #define last_dtor_insn cp_function_chain->last_dtor_insn
307 /* In a constructor, the last insn emitted after the start of the
308 function and the parms, the exception specification and any
309 function-try-block. The constructor initializers are emitted after
312 #define last_parm_cleanup_insn cp_function_chain->last_parm_cleanup_insn
314 /* If original DECL_RESULT of current function was a register,
315 but due to being an addressable named return value, would up
316 on the stack, this variable holds the named return value's
317 original location. */
319 #define original_result_rtx cp_function_chain->result_rtx
321 /* C++: Keep these around to reduce calls to `get_identifier'.
322 Identifiers for `this' in member functions and the auto-delete
323 parameter for destructors. */
324 tree this_identifier
, in_charge_identifier
;
325 tree ctor_identifier
, dtor_identifier
;
326 /* Used in pointer to member functions, in vtables, and in sigtables. */
327 tree pfn_identifier
, index_identifier
, delta_identifier
, delta2_identifier
;
328 tree pfn_or_delta2_identifier
, tag_identifier
;
329 tree vt_off_identifier
;
331 /* Exception specifier used for throw(). */
332 tree empty_except_spec
;
334 struct named_label_list
336 struct binding_level
*binding_level
;
339 const char *filename_o_goto
;
341 struct named_label_list
*next
;
344 /* A list (chain of TREE_LIST nodes) of named label uses.
345 The TREE_PURPOSE field is the list of variables defined
346 in the label's scope defined at the point of use.
347 The TREE_VALUE field is the LABEL_DECL used.
348 The TREE_TYPE field holds `current_binding_level' at the
349 point of the label's use.
351 BWAHAHAAHAHahhahahahaah. No, no, no, said the little chicken.
353 Look at the pretty struct named_label_list. See the pretty struct
354 with the pretty named fields that describe what they do. See the
355 pretty lack of gratuitous casts. Notice the code got a lot cleaner.
357 Used only for jumps to as-yet undefined labels, since
358 jumps to defined labels can have their validity checked
361 #define named_label_uses cp_function_chain->named_label_uses
363 /* A list of objects which have constructors or destructors
364 which reside in the global scope. The decl is stored in
365 the TREE_VALUE slot and the initializer is stored
366 in the TREE_PURPOSE slot. */
367 tree static_aggregates
;
371 /* Two expressions that are constants with value zero.
372 The first is of type `int', the second of type `void *'. */
374 tree integer_zero_node
;
375 tree null_pointer_node
;
377 /* The value for __null (NULL), namely, a zero of an integer type with
378 the same number of bits as a pointer. */
381 /* A node for the integer constants 1, 2, and 3. */
383 tree integer_one_node
, integer_two_node
, integer_three_node
;
385 /* While defining an enum type, this is 1 plus the last enumerator
388 static tree enum_next_value
;
390 /* Nonzero means that there was overflow computing enum_next_value. */
392 static int enum_overflow
;
394 /* Parsing a function declarator leaves a list of parameter names
395 or a chain or parameter decls here. */
397 tree last_function_parms
;
399 /* Parsing a function declarator leaves here a chain of structure
400 and enum types declared in the parmlist. */
402 static tree last_function_parm_tags
;
404 /* After parsing the declarator that starts a function definition,
405 `start_function' puts here the list of parameter names or chain of decls.
406 `store_parm_decls' finds it here. */
408 static tree current_function_parms
;
410 /* Similar, for last_function_parm_tags. */
411 static tree current_function_parm_tags
;
413 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
414 that have names. Here so we can clear out their names' definitions
415 at the end of the function. The TREE_VALUE is a LABEL_DECL; the
416 TREE_PURPOSE is the previous binding of the label. */
418 #define named_labels cp_function_chain->named_labels
420 /* The FUNCTION_DECL for the function currently being compiled,
421 or 0 if between functions. */
422 tree current_function_decl
;
424 /* Set to 0 at beginning of a function definition, and whenever
425 a label (case or named) is defined. Set to value of expression
426 returned from function when that value can be transformed into
427 a named return value. */
429 tree current_function_return_value
;
431 /* Nonzero means give `double' the same size as `float'. */
433 extern int flag_short_double
;
435 /* Nonzero means don't recognize any builtin functions. */
437 extern int flag_no_builtin
;
439 /* Nonzero means don't recognize the non-ANSI builtin functions.
442 extern int flag_no_nonansi_builtin
;
444 /* Nonzero means enable obscure ANSI features and disable GNU extensions
445 that might cause ANSI-compliant code to be miscompiled. */
447 extern int flag_ansi
;
449 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
451 extern int flag_huge_objects
;
453 /* Nonzero if we want to conserve space in the .o files. We do this
454 by putting uninitialized data and runtime initialized data into
455 .common instead of .data at the expense of not flagging multiple
457 extern int flag_conserve_space
;
459 /* Pointers to the base and current top of the language name stack. */
461 extern tree
*current_lang_base
, *current_lang_stack
;
463 /* C and C++ flags are in decl2.c. */
465 /* Set to 0 at beginning of a constructor, set to 1
466 if that function does an allocation before referencing its
467 instance variable. */
468 #define current_function_assigns_this cp_function_chain->assigns_this
469 #define current_function_just_assigned_this \
470 cp_function_chain->just_assigned_this
472 /* Flag used when debugging spew.c */
474 extern int spew_debug
;
476 /* This is a copy of the class_shadowed list of the previous class binding
477 contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
478 when entering another class scope (i.e. a cache miss). */
479 extern tree previous_class_values
;
481 /* A expression of value 0 with the same precision as a sizetype
483 tree signed_size_zero_node
;
485 /* The name of the anonymous namespace, throughout this translation
487 tree anonymous_namespace_name
;
490 /* Allocate a level of searching. */
494 push_decl_level (stack
, obstack
)
495 struct stack_level
*stack
;
496 struct obstack
*obstack
;
498 struct stack_level tem
;
501 return push_stack_level (obstack
, (char *)&tem
, sizeof (tem
));
504 /* For each binding contour we allocate a binding_level structure
505 which records the names defined in that contour.
508 1) one for each function definition,
509 where internal declarations of the parameters appear.
510 2) one for each compound statement,
511 to record its declarations.
513 The current meaning of a name can be found by searching the levels
514 from the current one out to the global one.
516 Off to the side, may be the class_binding_level. This exists only
517 to catch class-local declarations. It is otherwise nonexistent.
519 Also there may be binding levels that catch cleanups that must be
520 run when exceptions occur. Thus, to see whether a name is bound in
521 the current scope, it is not enough to look in the
522 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
525 /* Note that the information in the `names' component of the global contour
526 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
530 /* A chain of _DECL nodes for all variables, constants, functions,
531 and typedef types. These are in the reverse of the order
532 supplied. There may be OVERLOADs on this list, too, but they
533 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
536 /* A list of structure, union and enum definitions, for looking up
538 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
539 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
540 or ENUMERAL_TYPE node.
542 C++: the TREE_VALUE nodes can be simple types for
543 component_bindings. */
546 /* A list of USING_DECL nodes. */
549 /* A list of used namespaces. PURPOSE is the namespace,
550 VALUE the common ancestor with this binding_level's namespace. */
551 tree using_directives
;
553 /* If this binding level is the binding level for a class, then
554 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
555 is the name of an entity bound in the class; the TREE_VALUE is
556 the IDENTIFIER_CLASS_VALUE before we entered the class. Thus,
557 when leaving class scope, we can restore the
558 IDENTIFIER_CLASS_VALUE by walking this list. The TREE_TYPE is
559 the DECL bound by this name in the class. */
562 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
563 is used for all binding levels. */
566 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
567 label in this scope. The TREE_PURPOSE is the previous value of
568 the IDENTIFIER_LABEL VALUE. */
569 tree shadowed_labels
;
571 /* For each level (except not the global one),
572 a chain of BLOCK nodes for all the levels
573 that were entered and exited one level down. */
576 /* The BLOCK node for this level, if one has been preallocated.
577 If 0, the BLOCK is allocated (if needed) when the level is popped. */
580 /* The binding level which this one is contained in (inherits from). */
581 struct binding_level
*level_chain
;
583 /* List of decls in `names' that have incomplete
584 structure or union types. */
587 /* List of VAR_DECLS saved from a previous for statement.
588 These would be dead in ANSI-conforming code, but might
589 be referenced in ARM-era code. These are stored in a
590 TREE_LIST; the TREE_VALUE is the actual declaration. */
591 tree dead_vars_from_for
;
593 /* 1 for the level that holds the parameters of a function.
594 2 for the level that holds a class declaration.
595 3 for levels that hold parameter declarations. */
596 unsigned parm_flag
: 4;
598 /* 1 means make a BLOCK for this level regardless of all else.
599 2 for temporary binding contours created by the compiler. */
602 /* Nonzero if this level "doesn't exist" for tags. */
603 unsigned tag_transparent
: 1;
605 /* Nonzero if this level can safely have additional
606 cleanup-needing variables added to it. */
607 unsigned more_cleanups_ok
: 1;
608 unsigned have_cleanups
: 1;
610 /* Nonzero if this level is for storing the decls for template
611 parameters and generic decls; these decls will be discarded and
612 replaced with a TEMPLATE_DECL. */
613 unsigned pseudo_global
: 1;
615 /* This is set for a namespace binding level. */
616 unsigned namespace_p
: 1;
618 /* True if this level is that of a for-statement where we need to
619 worry about ambiguous (ARM or ANSI) scope rules. */
620 unsigned is_for_scope
: 1;
622 /* True if this level corresponds to an EH region, as for a try block. */
623 unsigned eh_region
: 1;
625 /* One bit left for this word. */
627 #if defined(DEBUG_CP_BINDING_LEVELS)
628 /* Binding depth at which this level began. */
629 unsigned binding_depth
;
630 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
633 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
635 /* The binding level currently in effect. */
637 #define current_binding_level cp_function_chain->binding_level
639 /* The binding level of the current class, if any. */
641 static struct binding_level
*class_binding_level
;
643 /* A chain of binding_level structures awaiting reuse. */
645 static struct binding_level
*free_binding_level
;
647 /* The outermost binding level, for names of file scope.
648 This is created when the compiler is started and exists
649 through the entire run. */
651 static struct binding_level
*global_binding_level
;
653 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
655 static int keep_next_level_flag
;
657 #if defined(DEBUG_CP_BINDING_LEVELS)
658 static int binding_depth
= 0;
659 static int is_class_level
= 0;
666 for (i
= 0; i
< binding_depth
*2; i
++)
669 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
671 static tree pushdecl_with_scope
PROTO((tree
, struct binding_level
*));
674 push_binding_level (newlevel
, tag_transparent
, keep
)
675 struct binding_level
*newlevel
;
676 int tag_transparent
, keep
;
678 /* Add this level to the front of the chain (stack) of levels that
680 bzero ((char*) newlevel
, sizeof (struct binding_level
));
681 newlevel
->level_chain
= current_binding_level
;
682 current_binding_level
= newlevel
;
683 newlevel
->tag_transparent
= tag_transparent
;
684 newlevel
->more_cleanups_ok
= 1;
686 /* We are called before expand_start_bindings, but after
687 expand_eh_region_start for a try block; so we check this now,
688 before the EH block is covered up. */
689 newlevel
->eh_region
= is_eh_region ();
691 newlevel
->keep
= keep
;
692 #if defined(DEBUG_CP_BINDING_LEVELS)
693 newlevel
->binding_depth
= binding_depth
;
695 fprintf (stderr
, "push %s level 0x%08x line %d\n",
696 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
699 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
702 /* Find the innermost enclosing class scope, and reset
703 CLASS_BINDING_LEVEL appropriately. */
706 find_class_binding_level ()
708 struct binding_level
*level
= current_binding_level
;
710 while (level
&& level
->parm_flag
!= 2)
711 level
= level
->level_chain
;
712 if (level
&& level
->parm_flag
== 2)
713 class_binding_level
= level
;
715 class_binding_level
= 0;
721 if (global_binding_level
)
723 /* Cannot pop a level, if there are none left to pop. */
724 if (current_binding_level
== global_binding_level
)
725 my_friendly_abort (123);
727 /* Pop the current level, and free the structure for reuse. */
728 #if defined(DEBUG_CP_BINDING_LEVELS)
731 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
732 (is_class_level
) ? "class" : "block",
733 current_binding_level
, lineno
);
734 if (is_class_level
!= (current_binding_level
== class_binding_level
))
737 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
740 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
742 register struct binding_level
*level
= current_binding_level
;
743 current_binding_level
= current_binding_level
->level_chain
;
744 level
->level_chain
= free_binding_level
;
745 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
746 if (level
->binding_depth
!= binding_depth
)
748 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
749 free_binding_level
= level
;
750 find_class_binding_level ();
755 suspend_binding_level ()
757 if (class_binding_level
)
758 current_binding_level
= class_binding_level
;
760 if (global_binding_level
)
762 /* Cannot suspend a level, if there are none left to suspend. */
763 if (current_binding_level
== global_binding_level
)
764 my_friendly_abort (123);
766 /* Suspend the current level. */
767 #if defined(DEBUG_CP_BINDING_LEVELS)
770 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
771 (is_class_level
) ? "class" : "block",
772 current_binding_level
, lineno
);
773 if (is_class_level
!= (current_binding_level
== class_binding_level
))
776 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
779 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
780 current_binding_level
= current_binding_level
->level_chain
;
781 find_class_binding_level ();
785 resume_binding_level (b
)
786 struct binding_level
*b
;
788 /* Resuming binding levels is meant only for namespaces,
789 and those cannot nest into classes. */
790 my_friendly_assert(!class_binding_level
, 386);
791 /* Also, resuming a non-directly nested namespace is a no-no. */
792 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
793 current_binding_level
= b
;
794 #if defined(DEBUG_CP_BINDING_LEVELS)
795 b
->binding_depth
= binding_depth
;
797 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
798 (is_class_level
) ? "class" : "block", b
, lineno
);
801 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
804 /* Create a new `struct binding_level'. */
807 struct binding_level
*
808 make_binding_level ()
811 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
814 /* Nonzero if we are currently in the global binding level. */
819 return current_binding_level
== global_binding_level
;
822 /* Return the innermost binding level that is not for a class scope. */
824 static struct binding_level
*
825 innermost_nonclass_level ()
827 struct binding_level
*b
;
829 b
= current_binding_level
;
830 while (b
->parm_flag
== 2)
836 /* Nonzero if we are currently in a toplevel binding level. This
837 means either the global binding level or a namespace in a toplevel
838 binding level. Since there are no non-toplevel namespace levels,
839 this really means any namespace or pseudo-global level. We also
840 include a class whose context is toplevel. */
843 toplevel_bindings_p ()
845 struct binding_level
*b
= innermost_nonclass_level ();
847 return b
->namespace_p
|| b
->pseudo_global
;
850 /* Nonzero if this is a namespace scope, or if we are defining a class
851 which is itself at namespace scope, or whose enclosing class is
852 such a class, etc. */
855 namespace_bindings_p ()
857 struct binding_level
*b
= innermost_nonclass_level ();
859 return b
->namespace_p
;
862 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
863 unconditionally. Otherwise, use the normal logic to decide whether
864 or not to create a BLOCK. */
867 keep_next_level (keep
)
870 keep_next_level_flag
= keep
;
873 /* Nonzero if the current level needs to have a BLOCK made. */
878 return (current_binding_level
->blocks
!= NULL_TREE
879 || current_binding_level
->keep
880 || current_binding_level
->names
!= NULL_TREE
881 || (current_binding_level
->tags
!= NULL_TREE
882 && !current_binding_level
->tag_transparent
));
885 /* Identify this binding level as a level of parameters. */
888 declare_parm_level ()
890 current_binding_level
->parm_flag
= 1;
894 declare_pseudo_global_level ()
896 current_binding_level
->pseudo_global
= 1;
900 declare_namespace_level ()
902 current_binding_level
->namespace_p
= 1;
906 pseudo_global_level_p ()
908 return current_binding_level
->pseudo_global
;
912 set_class_shadows (shadows
)
915 class_binding_level
->class_shadowed
= shadows
;
918 /* Enter a new binding level.
919 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
920 not for that of tags. */
923 pushlevel (tag_transparent
)
926 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
928 /* If this is the top level of a function,
929 just make sure that NAMED_LABELS is 0.
930 They should have been set to 0 at the end of the previous function. */
932 if (current_binding_level
== global_binding_level
)
933 my_friendly_assert (named_labels
== NULL_TREE
, 134);
935 /* Reuse or create a struct for this binding level. */
937 #if defined(DEBUG_CP_BINDING_LEVELS)
939 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
940 if (free_binding_level
)
941 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
943 newlevel
= free_binding_level
;
944 free_binding_level
= free_binding_level
->level_chain
;
947 newlevel
= make_binding_level ();
949 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
950 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
951 keep_next_level_flag
= 0;
955 note_level_for_for ()
957 current_binding_level
->is_for_scope
= 1;
961 pushlevel_temporary (tag_transparent
)
964 pushlevel (tag_transparent
);
965 current_binding_level
->keep
= 2;
968 /* Note we don't call push_momentary() here. Otherwise, it would cause
969 cleanups to be allocated on the momentary obstack, and they will be
970 overwritten by the next statement. */
972 expand_start_bindings (0);
975 /* For a binding between a name and an entity at a block scope,
976 this is the `struct binding_level' for the block. */
977 #define BINDING_LEVEL(NODE) \
978 (((struct tree_binding*)NODE)->scope.level)
980 /* These are currently unused, but permanent, CPLUS_BINDING nodes.
981 They are kept here because they are allocated from the permanent
982 obstack and cannot be easily freed. */
983 static tree free_binding_nodes
;
985 /* Make DECL the innermost binding for ID. The LEVEL is the binding
986 level at which this declaration is being bound. */
989 push_binding (id
, decl
, level
)
992 struct binding_level
* level
;
996 if (!free_binding_nodes
)
998 /* There are no free nodes, so we must build one here. */
999 push_permanent_obstack ();
1000 binding
= make_node (CPLUS_BINDING
);
1005 /* There are nodes on the free list. Grab the first one. */
1006 binding
= free_binding_nodes
;
1008 /* And update the free list. */
1009 free_binding_nodes
= TREE_CHAIN (free_binding_nodes
);
1012 /* Now, fill in the binding information. */
1013 BINDING_VALUE (binding
) = decl
;
1014 BINDING_TYPE (binding
) = NULL_TREE
;
1015 BINDING_LEVEL (binding
) = level
;
1016 INHERITED_VALUE_BINDING_P (binding
) = 0;
1017 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
1019 /* And put it on the front of the list of bindings for ID. */
1020 TREE_CHAIN (binding
) = IDENTIFIER_BINDING (id
);
1021 IDENTIFIER_BINDING (id
) = binding
;
1024 /* ID is already bound in the current scope. But, DECL is an
1025 additional binding for ID in the same scope. This is the `struct
1026 stat' hack whereby a non-typedef class-name or enum-name can be
1027 bound at the same level as some other kind of entity. It's the
1028 responsibility of the caller to check that inserting this name is
1029 legal here. Returns nonzero if the new binding was successful. */
1031 add_binding (id
, decl
)
1035 tree binding
= IDENTIFIER_BINDING (id
);
1038 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
1039 /* The new name is the type name. */
1040 BINDING_TYPE (binding
) = decl
;
1041 else if (!BINDING_VALUE (binding
))
1042 /* This situation arises when push_class_level_binding moves an
1043 inherited type-binding out of the way to make room for a new
1045 BINDING_VALUE (binding
) = decl
;
1046 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1047 && DECL_ARTIFICIAL (BINDING_VALUE (binding
)))
1049 /* The old binding was a type name. It was placed in
1050 BINDING_VALUE because it was thought, at the point it was
1051 declared, to be the only entity with such a name. Move the
1052 type name into the type slot; it is now hidden by the new
1054 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
1055 BINDING_VALUE (binding
) = decl
;
1056 INHERITED_VALUE_BINDING_P (binding
) = 0;
1058 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1059 && TREE_CODE (decl
) == TYPE_DECL
1060 && DECL_NAME (decl
) == DECL_NAME (BINDING_VALUE (binding
))
1061 && same_type_p (TREE_TYPE (decl
),
1062 TREE_TYPE (BINDING_VALUE (binding
))))
1063 /* We have two typedef-names, both naming the same type to have
1064 the same name. This is OK because of:
1068 In a given scope, a typedef specifier can be used to redefine
1069 the name of any type declared in that scope to refer to the
1070 type to which it already refers. */
1074 cp_error ("declaration of `%#D'", decl
);
1075 cp_error_at ("conflicts with previous declaration `%#D'",
1076 BINDING_VALUE (binding
));
1083 /* Add DECL to the list of things declared in B. */
1086 add_decl_to_level (decl
, b
)
1088 struct binding_level
*b
;
1090 /* Only things that will live forever should go in the global
1092 my_friendly_assert (!(b
== global_binding_level
1093 && !TREE_PERMANENT (decl
)),
1096 /* We build up the list in reverse order, and reverse it later if
1098 TREE_CHAIN (decl
) = b
->names
;
1102 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1103 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1104 doesn't really belong to this binding level, that it got here
1105 through a using-declaration. */
1108 push_local_binding (id
, decl
, flags
)
1113 struct binding_level
*b
;
1115 /* Skip over any local classes. This makes sense if we call
1116 push_local_binding with a friend decl of a local class. */
1117 b
= current_binding_level
;
1118 while (b
->parm_flag
== 2)
1121 if (lookup_name_current_level (id
))
1123 /* Supplement the existing binding. */
1124 if (!add_binding (id
, decl
))
1125 /* It didn't work. Something else must be bound at this
1126 level. Do not add DECL to the list of things to pop
1131 /* Create a new binding. */
1132 push_binding (id
, decl
, b
);
1134 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1135 /* We must put the OVERLOAD into a TREE_LIST since the
1136 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1137 decls that got here through a using-declaration. */
1138 decl
= build_tree_list (NULL_TREE
, decl
);
1140 /* And put DECL on the list of things declared by the current
1142 add_decl_to_level (decl
, b
);
1145 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1146 binding was successful. */
1149 push_class_binding (id
, decl
)
1154 tree binding
= IDENTIFIER_BINDING (id
);
1157 /* Note that we declared this value so that we can issue an error if
1158 this an illegal redeclaration of a name already used for some
1160 note_name_declared_in_class (id
, decl
);
1162 if (binding
&& BINDING_LEVEL (binding
) == class_binding_level
)
1163 /* Supplement the existing binding. */
1164 result
= add_binding (id
, decl
);
1166 /* Create a new binding. */
1167 push_binding (id
, decl
, class_binding_level
);
1169 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1170 class-level declaration. Note that we do not use DECL here
1171 because of the possibility of the `struct stat' hack; if DECL is
1172 a class-name or enum-name we might prefer a field-name, or some
1174 IDENTIFIER_CLASS_VALUE (id
) = BINDING_VALUE (IDENTIFIER_BINDING (id
));
1176 /* If this is a binding from a base class, mark it as such. */
1177 binding
= IDENTIFIER_BINDING (id
);
1178 if (BINDING_VALUE (binding
) == decl
&& TREE_CODE (decl
) != TREE_LIST
)
1180 /* Any implicit typename must be from a base-class. The
1181 context for an implicit typename declaration is always
1182 the derived class in which the lookup was done, so the checks
1183 based on the context of DECL below will not trigger. */
1184 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl
))
1185 INHERITED_VALUE_BINDING_P (binding
) = 1;
1188 if (TREE_CODE (decl
) == OVERLOAD
)
1189 context
= DECL_REAL_CONTEXT (OVL_CURRENT (decl
));
1192 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd',
1194 context
= DECL_REAL_CONTEXT (decl
);
1197 if (is_properly_derived_from (current_class_type
, context
))
1198 INHERITED_VALUE_BINDING_P (binding
) = 1;
1200 INHERITED_VALUE_BINDING_P (binding
) = 0;
1203 else if (BINDING_VALUE (binding
) == decl
)
1204 /* We only encounter a TREE_LIST when push_class_decls detects an
1205 ambiguity. Such an ambiguity can be overridden by a definition
1207 INHERITED_VALUE_BINDING_P (binding
) = 1;
1212 /* Remove the binding for DECL which should be the innermost binding
1216 pop_binding (id
, decl
)
1222 if (id
== NULL_TREE
)
1223 /* It's easiest to write the loops that call this function without
1224 checking whether or not the entities involved have names. We
1225 get here for such an entity. */
1228 /* Get the innermost binding for ID. */
1229 binding
= IDENTIFIER_BINDING (id
);
1231 /* The name should be bound. */
1232 my_friendly_assert (binding
!= NULL_TREE
, 0);
1234 /* The DECL will be either the ordinary binding or the type
1235 binding for this identifier. Remove that binding. */
1236 if (BINDING_VALUE (binding
) == decl
)
1237 BINDING_VALUE (binding
) = NULL_TREE
;
1238 else if (BINDING_TYPE (binding
) == decl
)
1239 BINDING_TYPE (binding
) = NULL_TREE
;
1241 my_friendly_abort (0);
1243 if (!BINDING_VALUE (binding
) && !BINDING_TYPE (binding
))
1245 /* We're completely done with the innermost binding for this
1246 identifier. Unhook it from the list of bindings. */
1247 IDENTIFIER_BINDING (id
) = TREE_CHAIN (binding
);
1249 /* And place it on the free list. */
1250 TREE_CHAIN (binding
) = free_binding_nodes
;
1251 free_binding_nodes
= binding
;
1255 /* When a label goes out of scope, check to see if that label was used
1256 in a valid manner, and issue any appropriate warnings or errors. */
1262 tree label
= TREE_VALUE (link
);
1264 if (DECL_INITIAL (label
) == NULL_TREE
)
1266 cp_error_at ("label `%D' used but not defined", label
);
1267 /* Avoid crashing later. */
1268 define_label (input_filename
, 1, DECL_NAME (label
));
1270 else if (warn_unused
&& !TREE_USED (label
))
1271 cp_warning_at ("label `%D' defined but not used", label
);
1273 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), TREE_PURPOSE (link
));
1276 /* At the end of a function, all labels declared within the fucntion
1277 go out of scope. BLOCK is the top-level block for the
1286 /* Clear out the definitions of all label names, since their scopes
1288 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1291 /* Put the labels into the "variables" of the top-level block,
1292 so debugger can see them. */
1293 TREE_CHAIN (TREE_VALUE (link
)) = BLOCK_VARS (block
);
1294 BLOCK_VARS (block
) = TREE_VALUE (link
);
1297 named_labels
= NULL_TREE
;
1300 /* Exit a binding level.
1301 Pop the level off, and restore the state of the identifier-decl mappings
1302 that were in effect when this level was entered.
1304 If KEEP == 1, this level had explicit declarations, so
1305 and create a "block" (a BLOCK node) for the level
1306 to record its declarations and subblocks for symbol table output.
1308 If FUNCTIONBODY is nonzero, this level is the body of a function,
1309 so create a block as if KEEP were set and also clear out all
1312 If REVERSE is nonzero, reverse the order of decls before putting
1313 them into the BLOCK. */
1316 poplevel (keep
, reverse
, functionbody
)
1322 /* The chain of decls was accumulated in reverse order.
1323 Put it into forward order, just for cleanliness. */
1325 int tmp
= functionbody
;
1326 int real_functionbody
= current_binding_level
->keep
== 2
1327 ? ((functionbody
= 0), tmp
) : functionbody
;
1328 tree tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1329 tree subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1330 tree block
= NULL_TREE
;
1332 int block_previously_created
;
1333 int leaving_for_scope
;
1335 if (current_binding_level
->parm_flag
== 2)
1336 return poplevel_class ();
1338 my_friendly_assert (!current_binding_level
->class_shadowed
,
1341 /* We used to use KEEP == 2 to indicate that the new block should go
1342 at the beginning of the list of blocks at this binding level,
1343 rather than the end. This hack is no longer used. */
1344 my_friendly_assert (keep
== 0 || keep
== 1, 0);
1346 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1347 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1348 current_binding_level
->parm_flag
,
1349 current_binding_level
->keep
);
1351 if (current_binding_level
->keep
== 1)
1354 /* Get the decls in the order they were written.
1355 Usually current_binding_level->names is in reverse order.
1356 But parameter decls were previously put in forward order. */
1359 current_binding_level
->names
1360 = decls
= nreverse (current_binding_level
->names
);
1362 decls
= current_binding_level
->names
;
1364 /* Output any nested inline functions within this block
1365 if they weren't already output. */
1367 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1368 if (TREE_CODE (decl
) == FUNCTION_DECL
1369 && ! TREE_ASM_WRITTEN (decl
)
1370 && DECL_INITIAL (decl
) != NULL_TREE
1371 && TREE_ADDRESSABLE (decl
)
1372 && decl_function_context (decl
) == current_function_decl
)
1374 /* If this decl was copied from a file-scope decl
1375 on account of a block-scope extern decl,
1376 propagate TREE_ADDRESSABLE to the file-scope decl. */
1377 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1378 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1381 push_function_context ();
1382 output_inline_function (decl
);
1383 pop_function_context ();
1387 /* If there were any declarations or structure tags in that level,
1388 or if this level is a function body,
1389 create a BLOCK to record them for the life of this function. */
1392 block_previously_created
= (current_binding_level
->this_block
!= NULL_TREE
);
1393 if (block_previously_created
)
1394 block
= current_binding_level
->this_block
;
1395 else if (keep
== 1 || functionbody
)
1396 block
= make_node (BLOCK
);
1397 if (block
!= NULL_TREE
)
1399 if (block_previously_created
)
1401 if (decls
|| tags
|| subblocks
)
1403 if (BLOCK_VARS (block
) || BLOCK_TYPE_TAGS (block
))
1404 warning ("internal compiler error: debugging info corrupted");
1406 BLOCK_VARS (block
) = decls
;
1407 BLOCK_TYPE_TAGS (block
) = tags
;
1409 /* We can have previous subblocks and new subblocks when
1410 doing fixup_gotos with complex cleanups. We chain the new
1411 subblocks onto the end of any pre-existing subblocks. */
1412 BLOCK_SUBBLOCKS (block
) = chainon (BLOCK_SUBBLOCKS (block
),
1415 /* If we created the block earlier on, and we are just
1416 diddling it now, then it already should have a proper
1417 BLOCK_END_NOTE value associated with it. */
1421 BLOCK_VARS (block
) = decls
;
1422 BLOCK_TYPE_TAGS (block
) = tags
;
1423 BLOCK_SUBBLOCKS (block
) = subblocks
;
1424 /* Otherwise, for a new block, install a new BLOCK_END_NOTE
1426 remember_end_note (block
);
1430 /* In each subblock, record that this is its superior. */
1433 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1434 BLOCK_SUPERCONTEXT (link
) = block
;
1436 /* We still support the old for-scope rules, whereby the variables
1437 in a for-init statement were in scope after the for-statement
1438 ended. We only use the new rules in flag_new_for_scope is
1441 = current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1;
1443 /* Remove declarations for all the DECLs in this level. */
1444 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1446 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
)
1449 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link
)));
1453 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link
));
1455 ns_binding
= NULL_TREE
;
1458 && (BINDING_LEVEL (outer_binding
)
1459 == current_binding_level
->level_chain
))
1460 /* We have something like:
1465 and we are leaving the `for' scope. There's no reason to
1466 keep the binding of the inner `i' in this case. */
1467 pop_binding (DECL_NAME (link
), link
);
1468 else if ((outer_binding
1469 && (TREE_CODE (BINDING_VALUE (outer_binding
))
1472 && TREE_CODE (ns_binding
) == TYPE_DECL
))
1473 /* Here, we have something like:
1481 We must pop the for-scope binding so we know what's a
1482 type and what isn't. */
1483 pop_binding (DECL_NAME (link
), link
);
1486 /* Mark this VAR_DECL as dead so that we can tell we left it
1487 there only for backward compatibility. */
1488 DECL_DEAD_FOR_LOCAL (link
) = 1;
1490 /* Keep track of what should of have happenned when we
1491 popped the binding. */
1492 if (outer_binding
&& BINDING_VALUE (outer_binding
))
1493 DECL_SHADOWED_FOR_VAR (link
)
1494 = BINDING_VALUE (outer_binding
);
1496 /* Add it to the list of dead variables in the next
1497 outermost binding to that we can remove these when we
1498 leave that binding. */
1499 current_binding_level
->level_chain
->dead_vars_from_for
1500 = tree_cons (NULL_TREE
, link
,
1501 current_binding_level
->level_chain
->
1502 dead_vars_from_for
);
1504 /* Although we don't pop the CPLUS_BINDING, we do clear
1505 its BINDING_LEVEL since the level is going away now. */
1506 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link
)))
1512 /* Remove the binding. */
1514 if (TREE_CODE (decl
) == TREE_LIST
)
1515 decl
= TREE_VALUE (decl
);
1516 if (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd')
1517 pop_binding (DECL_NAME (decl
), decl
);
1518 else if (TREE_CODE (decl
) == OVERLOAD
)
1519 pop_binding (DECL_NAME (OVL_FUNCTION (decl
)), decl
);
1521 my_friendly_abort (0);
1525 /* Remove declarations for any `for' variables from inner scopes
1526 that we kept around. */
1527 for (link
= current_binding_level
->dead_vars_from_for
;
1528 link
; link
= TREE_CHAIN (link
))
1529 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
1531 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1532 for (link
= current_binding_level
->type_shadowed
;
1533 link
; link
= TREE_CHAIN (link
))
1534 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1536 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1537 for (link
= current_binding_level
->shadowed_labels
;
1539 link
= TREE_CHAIN (link
))
1542 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1543 list if a `using' declaration put them there. The debugging
1544 back-ends won't understand OVERLOAD, so we remove them here.
1545 Because the BLOCK_VARS are (temporarily) shared with
1546 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1547 popped all the bindings. */
1552 for (d
= &BLOCK_VARS (block
); *d
; )
1554 if (TREE_CODE (*d
) == TREE_LIST
)
1555 *d
= TREE_CHAIN (*d
);
1557 d
= &TREE_CHAIN (*d
);
1561 /* If the level being exited is the top level of a function,
1562 check over all the labels. */
1565 /* Since this is the top level block of a function, the vars are
1566 the function's parameters. Don't leave them in the BLOCK
1567 because they are found in the FUNCTION_DECL instead. */
1568 BLOCK_VARS (block
) = 0;
1572 /* Any uses of undefined labels now operate under constraints
1573 of next binding contour. */
1575 struct binding_level
*level_chain
;
1576 level_chain
= current_binding_level
->level_chain
;
1579 struct named_label_list
*labels
;
1580 for (labels
= named_label_uses
; labels
; labels
= labels
->next
)
1581 if (labels
->binding_level
== current_binding_level
)
1583 labels
->binding_level
= level_chain
;
1584 labels
->names_in_scope
= level_chain
->names
;
1589 tmp
= current_binding_level
->keep
;
1591 pop_binding_level ();
1593 DECL_INITIAL (current_function_decl
) = block
;
1596 if (!block_previously_created
)
1597 current_binding_level
->blocks
1598 = chainon (current_binding_level
->blocks
, block
);
1600 /* If we did not make a block for the level just exited,
1601 any blocks made for inner levels
1602 (since they cannot be recorded as subblocks in that level)
1603 must be carried forward so they will later become subblocks
1604 of something else. */
1606 current_binding_level
->blocks
1607 = chainon (current_binding_level
->blocks
, subblocks
);
1609 /* Take care of compiler's internal binding structures. */
1612 expand_end_bindings (getdecls (), keep
, 1);
1613 /* Each and every BLOCK node created here in `poplevel' is important
1614 (e.g. for proper debugging information) so if we created one
1615 earlier, mark it as "used". */
1617 TREE_USED (block
) = 1;
1618 block
= poplevel (keep
, reverse
, real_functionbody
);
1621 /* Each and every BLOCK node created here in `poplevel' is important
1622 (e.g. for proper debugging information) so if we created one
1623 earlier, mark it as "used". */
1625 TREE_USED (block
) = 1;
1629 /* Delete the node BLOCK from the current binding level.
1630 This is used for the block inside a stmt expr ({...})
1631 so that the block can be reinserted where appropriate. */
1634 delete_block (block
)
1638 if (current_binding_level
->blocks
== block
)
1639 current_binding_level
->blocks
= TREE_CHAIN (block
);
1640 for (t
= current_binding_level
->blocks
; t
;)
1642 if (TREE_CHAIN (t
) == block
)
1643 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1647 TREE_CHAIN (block
) = NULL_TREE
;
1648 /* Clear TREE_USED which is always set by poplevel.
1649 The flag is set again if insert_block is called. */
1650 TREE_USED (block
) = 0;
1653 /* Insert BLOCK at the end of the list of subblocks of the
1654 current binding level. This is used when a BIND_EXPR is expanded,
1655 to handle the BLOCK node inside the BIND_EXPR. */
1658 insert_block (block
)
1661 TREE_USED (block
) = 1;
1662 current_binding_level
->blocks
1663 = chainon (current_binding_level
->blocks
, block
);
1666 /* Set the BLOCK node for the innermost scope
1667 (the one we are currently in). */
1671 register tree block
;
1673 current_binding_level
->this_block
= block
;
1676 /* Do a pushlevel for class declarations. */
1681 register struct binding_level
*newlevel
;
1683 /* Reuse or create a struct for this binding level. */
1684 #if defined(DEBUG_CP_BINDING_LEVELS)
1686 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1687 if (free_binding_level
)
1688 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1690 newlevel
= free_binding_level
;
1691 free_binding_level
= free_binding_level
->level_chain
;
1694 newlevel
= make_binding_level ();
1696 #if defined(DEBUG_CP_BINDING_LEVELS)
1698 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1700 push_binding_level (newlevel
, 0, 0);
1702 decl_stack
= push_decl_level (decl_stack
, &decl_obstack
);
1703 class_binding_level
= current_binding_level
;
1704 class_binding_level
->parm_flag
= 2;
1707 /* ...and a poplevel for class declarations. */
1712 register struct binding_level
*level
= class_binding_level
;
1715 my_friendly_assert (level
!= 0, 354);
1717 decl_stack
= pop_stack_level (decl_stack
);
1718 /* If we're leaving a toplevel class, don't bother to do the setting
1719 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1720 shouldn't even be used when current_class_type isn't set, and second,
1721 if we don't touch it here, we're able to use the cache effect if the
1722 next time we're entering a class scope, it is the same class. */
1723 if (current_class_depth
!= 1)
1725 struct binding_level
* b
;
1727 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1728 for (shadowed
= level
->class_shadowed
;
1730 shadowed
= TREE_CHAIN (shadowed
))
1731 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = NULL_TREE
;
1733 /* Find the next enclosing class, and recreate
1734 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1735 b
= level
->level_chain
;
1736 while (b
&& b
->parm_flag
!= 2)
1740 for (shadowed
= b
->class_shadowed
;
1742 shadowed
= TREE_CHAIN (shadowed
))
1746 t
= IDENTIFIER_BINDING (TREE_PURPOSE (shadowed
));
1747 while (t
&& BINDING_LEVEL (t
) != b
)
1751 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
))
1752 = BINDING_VALUE (t
);
1756 /* Remember to save what IDENTIFIER's were bound in this scope so we
1757 can recover from cache misses. */
1759 previous_class_type
= current_class_type
;
1760 previous_class_values
= class_binding_level
->class_shadowed
;
1762 for (shadowed
= level
->type_shadowed
;
1764 shadowed
= TREE_CHAIN (shadowed
))
1765 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1767 /* Remove the bindings for all of the class-level declarations. */
1768 for (shadowed
= level
->class_shadowed
;
1770 shadowed
= TREE_CHAIN (shadowed
))
1771 pop_binding (TREE_PURPOSE (shadowed
), TREE_TYPE (shadowed
));
1773 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1774 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1775 class_binding_level
->parm_flag
,
1776 class_binding_level
->keep
);
1778 /* Now, pop out of the binding level which we created up in the
1779 `pushlevel_class' routine. */
1780 #if defined(DEBUG_CP_BINDING_LEVELS)
1782 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1784 pop_binding_level ();
1789 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1790 for any names in enclosing classes. */
1793 clear_identifier_class_values ()
1797 if (!class_binding_level
)
1800 for (t
= class_binding_level
->class_shadowed
;
1803 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t
)) = NULL_TREE
;
1806 /* Returns non-zero if T is a virtual function table. */
1809 vtable_decl_p (t
, data
)
1811 void *data ATTRIBUTE_UNUSED
;
1813 return (TREE_CODE (t
) == VAR_DECL
&& DECL_VIRTUAL_P (t
));
1816 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1820 vtype_decl_p (t
, data
)
1822 void *data ATTRIBUTE_UNUSED
;
1824 return (TREE_CODE (t
) == TYPE_DECL
1825 && TREE_TYPE (t
) != error_mark_node
1826 && TYPE_LANG_SPECIFIC (TREE_TYPE (t
))
1827 && CLASSTYPE_VSIZE (TREE_TYPE (t
)));
1830 /* Return the declarations that are members of the namespace NS. */
1833 cp_namespace_decls (ns
)
1836 return NAMESPACE_LEVEL (ns
)->names
;
1839 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1840 itself, calling F for each. The DATA is passed to F as well. */
1843 walk_namespaces_r (namespace, f
, data
)
1845 walk_namespaces_fn f
;
1851 result
|= (*f
) (namespace, data
);
1853 for (current
= cp_namespace_decls (namespace);
1855 current
= TREE_CHAIN (current
))
1857 if (TREE_CODE (current
) != NAMESPACE_DECL
1858 || DECL_NAMESPACE_ALIAS (current
))
1860 if (!DECL_LANG_SPECIFIC (current
))
1863 my_friendly_assert (current
== std_node
, 393);
1867 /* We found a namespace. */
1868 result
|= walk_namespaces_r (current
, f
, data
);
1874 /* Walk all the namespaces, calling F for each. The DATA is passed to
1878 walk_namespaces (f
, data
)
1879 walk_namespaces_fn f
;
1882 return walk_namespaces_r (global_namespace
, f
, data
);
1885 struct walk_globals_data
{
1886 walk_globals_pred p
;
1891 /* Walk the global declarations in NAMESPACE. Whenever one is found
1892 for which P returns non-zero, call F with its address. If any call
1893 to F returns a non-zero value, return a non-zero value. */
1896 walk_globals_r (namespace, data
)
1900 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
1901 walk_globals_pred p
= wgd
->p
;
1902 walk_globals_fn f
= wgd
->f
;
1903 void *d
= wgd
->data
;
1907 t
= &NAMESPACE_LEVEL (namespace)->names
;
1914 result
|= (*f
) (t
, d
);
1916 /* If F changed *T, then *T still points at the next item to
1919 t
= &TREE_CHAIN (*t
);
1925 /* Walk the global declarations. Whenever one is found for which P
1926 returns non-zero, call F with its address. If any call to F
1927 returns a non-zero value, return a non-zero value. */
1930 walk_globals (p
, f
, data
)
1931 walk_globals_pred p
;
1935 struct walk_globals_data wgd
;
1940 return walk_namespaces (walk_globals_r
, &wgd
);
1943 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1944 DATA is non-NULL, this is the last time we will call
1945 wrapup_global_declarations for this NAMESPACE. */
1948 wrapup_globals_for_namespace (namespace, data
)
1952 tree globals
= cp_namespace_decls (namespace);
1953 int len
= list_length (globals
);
1954 tree
*vec
= (tree
*) alloca (sizeof (tree
) * len
);
1958 int last_time
= (data
!= 0);
1960 if (last_time
&& namespace == global_namespace
)
1961 /* Let compile_file handle the global namespace. */
1964 /* Process the decls in reverse order--earliest first.
1965 Put them into VEC from back to front, then take out from front. */
1967 for (i
= 0, decl
= globals
; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
1968 vec
[len
- i
- 1] = decl
;
1972 check_global_declarations (vec
, len
);
1976 /* Temporarily mark vtables as external. That prevents
1977 wrapup_global_declarations from writing them out; we must process
1978 them ourselves in finish_vtable_vardecl. */
1979 for (i
= 0; i
< len
; ++i
)
1980 if (vtable_decl_p (vec
[i
], /*data=*/0) && !DECL_EXTERNAL (vec
[i
]))
1982 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 1;
1983 DECL_EXTERNAL (vec
[i
]) = 1;
1986 /* Write out any globals that need to be output. */
1987 result
= wrapup_global_declarations (vec
, len
);
1989 /* Undo the hack to DECL_EXTERNAL above. */
1990 for (i
= 0; i
< len
; ++i
)
1991 if (vtable_decl_p (vec
[i
], /*data=*/0)
1992 && DECL_NOT_REALLY_EXTERN (vec
[i
]))
1994 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 0;
1995 DECL_EXTERNAL (vec
[i
]) = 0;
2002 /* For debugging. */
2003 static int no_print_functions
= 0;
2004 static int no_print_builtins
= 0;
2007 print_binding_level (lvl
)
2008 struct binding_level
*lvl
;
2012 fprintf (stderr
, " blocks=");
2013 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
2014 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
2015 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
2016 if (lvl
->tag_transparent
)
2017 fprintf (stderr
, " tag-transparent");
2018 if (lvl
->more_cleanups_ok
)
2019 fprintf (stderr
, " more-cleanups-ok");
2020 if (lvl
->have_cleanups
)
2021 fprintf (stderr
, " have-cleanups");
2022 fprintf (stderr
, "\n");
2025 fprintf (stderr
, " names:\t");
2026 /* We can probably fit 3 names to a line? */
2027 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
2029 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
2031 if (no_print_builtins
2032 && (TREE_CODE (t
) == TYPE_DECL
)
2033 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
2036 /* Function decls tend to have longer names. */
2037 if (TREE_CODE (t
) == FUNCTION_DECL
)
2044 fprintf (stderr
, "\n\t");
2047 print_node_brief (stderr
, "", t
, 0);
2048 if (t
== error_mark_node
)
2052 fprintf (stderr
, "\n");
2056 fprintf (stderr
, " tags:\t");
2058 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
2060 if (TREE_PURPOSE (t
) == NULL_TREE
)
2062 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2069 fprintf (stderr
, "\n\t");
2072 if (TREE_PURPOSE (t
) == NULL_TREE
)
2074 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
2075 fprintf (stderr
, ">");
2077 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2078 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2081 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
2082 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2083 fprintf (stderr
, ">");
2087 fprintf (stderr
, "\n");
2089 if (lvl
->class_shadowed
)
2091 fprintf (stderr
, " class-shadowed:");
2092 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
2094 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2096 fprintf (stderr
, "\n");
2098 if (lvl
->type_shadowed
)
2100 fprintf (stderr
, " type-shadowed:");
2101 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2103 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2105 fprintf (stderr
, "\n");
2110 print_other_binding_stack (stack
)
2111 struct binding_level
*stack
;
2113 struct binding_level
*level
;
2114 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
2116 fprintf (stderr
, "binding level ");
2117 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
2118 fprintf (stderr
, "\n");
2119 print_binding_level (level
);
2124 print_binding_stack ()
2126 struct binding_level
*b
;
2127 fprintf (stderr
, "current_binding_level=");
2128 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
2129 fprintf (stderr
, "\nclass_binding_level=");
2130 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
2131 fprintf (stderr
, "\nglobal_binding_level=");
2132 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
2133 fprintf (stderr
, "\n");
2134 if (class_binding_level
)
2136 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
2137 if (b
== current_binding_level
)
2140 b
= class_binding_level
;
2142 b
= current_binding_level
;
2145 b
= current_binding_level
;
2146 print_other_binding_stack (b
);
2147 fprintf (stderr
, "global:\n");
2148 print_binding_level (global_binding_level
);
2151 /* Namespace binding access routines: The namespace_bindings field of
2152 the identifier is polymorphic, with three possible values:
2153 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2154 indicating the BINDING_VALUE of global_namespace. */
2156 /* Check whether the a binding for the name to scope is known.
2157 Assumes that the bindings of the name are already a list
2158 of bindings. Returns the binding found, or NULL_TREE. */
2161 find_binding (name
, scope
)
2165 tree iter
, prev
= NULL_TREE
;
2167 scope
= ORIGINAL_NAMESPACE (scope
);
2169 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
2170 iter
= TREE_CHAIN (iter
))
2172 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
2173 if (BINDING_SCOPE (iter
) == scope
)
2175 /* Move binding found to the front of the list, so
2176 subsequent lookups will find it faster. */
2179 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
2180 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
2181 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
2190 /* Always returns a binding for name in scope. If the
2191 namespace_bindings is not a list, convert it to one first.
2192 If no binding is found, make a new one. */
2195 binding_for_name (name
, scope
)
2199 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2202 scope
= ORIGINAL_NAMESPACE (scope
);
2204 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
2206 /* Get rid of optimization for global scope. */
2207 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
2208 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
2209 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2211 if (b
&& (result
= find_binding (name
, scope
)))
2213 /* Not found, make a new permanent one. */
2214 push_obstacks (&permanent_obstack
, &permanent_obstack
);
2215 result
= make_node (CPLUS_BINDING
);
2216 TREE_CHAIN (result
) = b
;
2217 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2218 BINDING_SCOPE (result
) = scope
;
2219 BINDING_TYPE (result
) = NULL_TREE
;
2220 BINDING_VALUE (result
) = NULL_TREE
;
2225 /* Return the binding value for name in scope, considering that
2226 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2229 namespace_binding (name
, scope
)
2233 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2236 if (scope
== NULL_TREE
)
2237 scope
= global_namespace
;
2238 if (TREE_CODE (b
) != CPLUS_BINDING
)
2239 return (scope
== global_namespace
) ? b
: NULL_TREE
;
2240 name
= find_binding (name
,scope
);
2241 if (name
== NULL_TREE
)
2243 return BINDING_VALUE (name
);
2246 /* Set the binding value for name in scope. If modifying the binding
2247 of global_namespace is attempted, try to optimize it. */
2250 set_namespace_binding (name
, scope
, val
)
2257 if (scope
== NULL_TREE
)
2258 scope
= global_namespace
;
2260 if (scope
== global_namespace
)
2262 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2263 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
2265 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
2269 b
= binding_for_name (name
, scope
);
2270 BINDING_VALUE (b
) = val
;
2273 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2274 select a name that is unique to this compilation unit. */
2277 push_namespace (name
)
2282 int implicit_use
= 0;
2284 if (!global_namespace
)
2286 /* This must be ::. */
2287 my_friendly_assert (name
== get_identifier ("::"), 377);
2292 /* The name of anonymous namespace is unique for the translation
2294 if (!anonymous_namespace_name
)
2295 anonymous_namespace_name
= get_file_function_name ('N');
2296 name
= anonymous_namespace_name
;
2297 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2299 /* Reopening anonymous namespace. */
2303 else if (current_namespace
== global_namespace
2304 && name
== DECL_NAME (std_node
))
2311 /* Check whether this is an extended namespace definition. */
2312 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2313 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2316 if (DECL_NAMESPACE_ALIAS (d
))
2318 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2319 d
, DECL_NAMESPACE_ALIAS (d
));
2320 d
= DECL_NAMESPACE_ALIAS (d
);
2327 /* Make a new namespace, binding the name to it. */
2328 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2329 /* The global namespace is not pushed, and the global binding
2330 level is set elsewhere. */
2335 declare_namespace_level ();
2336 NAMESPACE_LEVEL (d
) = current_binding_level
;
2340 resume_binding_level (NAMESPACE_LEVEL (d
));
2343 do_using_directive (d
);
2344 /* Enter the name space. */
2345 current_namespace
= d
;
2348 /* Pop from the scope of the current namespace. */
2353 if (current_namespace
== global_namespace
)
2355 my_friendly_assert (in_std
>0, 980421);
2359 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2360 /* The binding level is not popped, as it might be re-opened later. */
2361 suspend_binding_level ();
2364 /* Push into the scope of the namespace NS, even if it is deeply
2365 nested within another namespace. */
2368 push_nested_namespace (ns
)
2371 if (ns
== global_namespace
)
2372 push_to_top_level ();
2375 push_nested_namespace (CP_DECL_CONTEXT (ns
));
2376 push_namespace (DECL_NAME (ns
));
2380 /* Pop back from the scope of the namespace NS, which was previously
2381 entered with push_nested_namespace. */
2384 pop_nested_namespace (ns
)
2387 while (ns
!= global_namespace
)
2390 ns
= CP_DECL_CONTEXT (ns
);
2393 pop_from_top_level ();
2397 /* Subroutines for reverting temporarily to top-level for instantiation
2398 of templates and such. We actually need to clear out the class- and
2399 local-value slots of all identifiers, so that only the global values
2400 are at all visible. Simply setting current_binding_level to the global
2401 scope isn't enough, because more binding levels may be pushed. */
2402 struct saved_scope
{
2403 struct binding_level
*old_binding_level
;
2406 struct saved_scope
*prev
;
2407 tree class_name
, class_type
;
2408 tree access_specifier
;
2410 struct binding_level
*class_bindings
;
2411 tree
*lang_base
, *lang_stack
, lang_name
;
2413 tree last_function_parms
;
2414 tree template_parms
;
2415 HOST_WIDE_INT processing_template_decl
;
2416 tree previous_class_type
, previous_class_values
;
2417 int processing_specialization
;
2418 int processing_explicit_instantiation
;
2419 char *class_cache_firstobj
;
2421 static struct saved_scope
*current_saved_scope
;
2423 /* A chain of the binding vecs created by store_bindings. We create a
2424 whole bunch of these during compilation, on permanent_obstack, so we
2425 can't just throw them away. */
2426 static tree free_binding_vecs
;
2429 store_bindings (names
, old_bindings
)
2430 tree names
, old_bindings
;
2433 for (t
= names
; t
; t
= TREE_CHAIN (t
))
2435 tree binding
, t1
, id
;
2437 if (TREE_CODE (t
) == TREE_LIST
)
2438 id
= TREE_PURPOSE (t
);
2443 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2444 we have no IDENTIFIER_BINDING if we have left the class
2445 scope, but cached the class-level declarations. */
2446 || !(IDENTIFIER_BINDING (id
) || IDENTIFIER_CLASS_VALUE (id
)))
2449 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
2450 if (TREE_VEC_ELT (t1
, 0) == id
)
2453 if (free_binding_vecs
)
2455 binding
= free_binding_vecs
;
2456 free_binding_vecs
= TREE_CHAIN (free_binding_vecs
);
2459 binding
= make_tree_vec (4);
2463 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
2464 TREE_VEC_ELT (binding
, 0) = id
;
2465 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
2466 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_BINDING (id
);
2467 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
2468 IDENTIFIER_BINDING (id
) = NULL_TREE
;
2469 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
2471 TREE_CHAIN (binding
) = old_bindings
;
2472 old_bindings
= binding
;
2476 return old_bindings
;
2480 maybe_push_to_top_level (pseudo
)
2483 extern int current_lang_stacksize
;
2484 struct saved_scope
*s
2485 = (struct saved_scope
*) xmalloc (sizeof (struct saved_scope
));
2486 struct binding_level
*b
= current_binding_level
;
2487 tree old_bindings
= NULL_TREE
;
2489 push_function_context_to (NULL_TREE
);
2491 if (previous_class_type
)
2492 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
2494 /* Have to include global_binding_level, because class-level decls
2495 aren't listed anywhere useful. */
2496 for (; b
; b
= b
->level_chain
)
2500 /* Template IDs are inserted into the global level. If they were
2501 inserted into namespace level, finish_file wouldn't find them
2502 when doing pending instantiations. Therefore, don't stop at
2503 namespace level, but continue until :: . */
2504 if (b
== global_binding_level
|| (pseudo
&& b
->pseudo_global
))
2507 old_bindings
= store_bindings (b
->names
, old_bindings
);
2508 /* We also need to check class_shadowed to save class-level type
2509 bindings, since pushclass doesn't fill in b->names. */
2510 if (b
->parm_flag
== 2)
2511 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2513 /* Unwind type-value slots back to top level. */
2514 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2515 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2518 s
->old_binding_level
= current_binding_level
;
2519 current_binding_level
= b
;
2521 s
->old_namespace
= current_namespace
;
2522 s
->class_name
= current_class_name
;
2523 s
->class_type
= current_class_type
;
2524 s
->access_specifier
= current_access_specifier
;
2525 s
->function_decl
= current_function_decl
;
2526 s
->class_bindings
= class_binding_level
;
2527 s
->lang_stack
= current_lang_stack
;
2528 s
->lang_base
= current_lang_base
;
2529 s
->lang_stacksize
= current_lang_stacksize
;
2530 s
->lang_name
= current_lang_name
;
2531 s
->last_function_parms
= last_function_parms
;
2532 s
->template_parms
= current_template_parms
;
2533 s
->processing_template_decl
= processing_template_decl
;
2534 s
->previous_class_type
= previous_class_type
;
2535 s
->previous_class_values
= previous_class_values
;
2536 s
->class_cache_firstobj
= class_cache_firstobj
;
2537 s
->processing_specialization
= processing_specialization
;
2538 s
->processing_explicit_instantiation
= processing_explicit_instantiation
;
2540 current_class_name
= current_class_type
= NULL_TREE
;
2541 current_function_decl
= NULL_TREE
;
2542 class_binding_level
= (struct binding_level
*)0;
2543 current_lang_stacksize
= 10;
2544 current_lang_stack
= current_lang_base
2545 = (tree
*) xmalloc (current_lang_stacksize
* sizeof (tree
));
2546 current_lang_name
= lang_name_cplusplus
;
2547 strict_prototype
= strict_prototypes_lang_cplusplus
;
2548 named_labels
= NULL_TREE
;
2549 previous_class_type
= previous_class_values
= NULL_TREE
;
2550 class_cache_firstobj
= 0;
2551 processing_specialization
= 0;
2552 processing_explicit_instantiation
= 0;
2553 current_template_parms
= NULL_TREE
;
2554 processing_template_decl
= 0;
2555 current_namespace
= global_namespace
;
2557 s
->prev
= current_saved_scope
;
2558 s
->old_bindings
= old_bindings
;
2559 current_saved_scope
= s
;
2561 push_obstacks (&permanent_obstack
, &permanent_obstack
);
2565 push_to_top_level ()
2567 maybe_push_to_top_level (0);
2571 pop_from_top_level ()
2573 extern int current_lang_stacksize
;
2574 struct saved_scope
*s
= current_saved_scope
;
2577 /* Clear out class-level bindings cache. */
2578 if (previous_class_type
)
2579 invalidate_class_lookup_cache ();
2583 current_binding_level
= s
->old_binding_level
;
2584 current_saved_scope
= s
->prev
;
2585 for (t
= s
->old_bindings
; t
; )
2588 tree id
= TREE_VEC_ELT (t
, 0);
2591 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2592 IDENTIFIER_BINDING (id
) = TREE_VEC_ELT (t
, 2);
2593 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2596 TREE_CHAIN (save
) = free_binding_vecs
;
2597 free_binding_vecs
= save
;
2599 current_namespace
= s
->old_namespace
;
2600 current_class_name
= s
->class_name
;
2601 current_class_type
= s
->class_type
;
2602 current_access_specifier
= s
->access_specifier
;
2603 current_function_decl
= s
->function_decl
;
2604 class_binding_level
= s
->class_bindings
;
2605 free (current_lang_base
);
2606 current_lang_base
= s
->lang_base
;
2607 current_lang_stack
= s
->lang_stack
;
2608 current_lang_name
= s
->lang_name
;
2609 current_lang_stacksize
= s
->lang_stacksize
;
2610 if (current_lang_name
== lang_name_cplusplus
)
2611 strict_prototype
= strict_prototypes_lang_cplusplus
;
2612 else if (current_lang_name
== lang_name_c
)
2613 strict_prototype
= strict_prototypes_lang_c
;
2614 last_function_parms
= s
->last_function_parms
;
2615 current_template_parms
= s
->template_parms
;
2616 processing_template_decl
= s
->processing_template_decl
;
2617 previous_class_type
= s
->previous_class_type
;
2618 previous_class_values
= s
->previous_class_values
;
2619 processing_specialization
= s
->processing_specialization
;
2620 processing_explicit_instantiation
= s
->processing_explicit_instantiation
;
2621 class_cache_firstobj
= s
->class_cache_firstobj
;
2625 pop_function_context_from (NULL_TREE
);
2628 /* Push a definition of struct, union or enum tag "name".
2629 into binding_level "b". "type" should be the type node,
2630 We assume that the tag "name" is not already defined.
2632 Note that the definition may really be just a forward reference.
2633 In that case, the TYPE_SIZE will be a NULL_TREE.
2635 C++ gratuitously puts all these tags in the name space. */
2637 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2638 record the shadowed value for this binding contour. TYPE is
2639 the type that ID maps to. */
2642 set_identifier_type_value_with_scope (id
, type
, b
)
2645 struct binding_level
*b
;
2647 if (!b
->namespace_p
)
2649 /* Shadow the marker, not the real thing, so that the marker
2650 gets restored later. */
2651 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2653 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2657 tree binding
= binding_for_name (id
, current_namespace
);
2658 BINDING_TYPE (binding
) = type
;
2659 /* Store marker instead of real type. */
2660 type
= global_type_node
;
2662 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2665 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2668 set_identifier_type_value (id
, type
)
2672 set_identifier_type_value_with_scope (id
, type
, current_binding_level
);
2675 /* Return the type associated with id. */
2678 identifier_type_value (id
)
2681 /* There is no type with that name, anywhere. */
2682 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2684 /* This is not the type marker, but the real thing. */
2685 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2686 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2687 /* Have to search for it. It must be on the global level, now.
2688 Ask lookup_name not to return non-types. */
2689 id
= lookup_name_real (id
, 2, 1, 0);
2691 return TREE_TYPE (id
);
2695 /* Pop off extraneous binding levels left over due to syntax errors.
2697 We don't pop past namespaces, as they might be valid. */
2702 #ifdef DEBUG_CP_BINDING_LEVELS
2703 fprintf (stderr
, "XXX entering pop_everything ()\n");
2705 while (!toplevel_bindings_p ())
2707 if (current_binding_level
->parm_flag
== 2)
2708 pop_nested_class ();
2712 #ifdef DEBUG_CP_BINDING_LEVELS
2713 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2717 /* The type TYPE is being declared. If it is a class template, or a
2718 specialization of a class template, do any processing required and
2719 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2720 being declared a friend. B is the binding level at which this TYPE
2723 Returns the TYPE_DECL for TYPE, which may have been altered by this
2727 maybe_process_template_type_declaration (type
, globalize
, b
)
2730 struct binding_level
* b
;
2732 tree decl
= TYPE_NAME (type
);
2734 if (processing_template_parmlist
)
2735 /* You can't declare a new template type in a template parameter
2736 list. But, you can declare a non-template type:
2738 template <class A*> struct S;
2740 is a forward-declaration of `A'. */
2744 maybe_check_template_type (type
);
2746 my_friendly_assert (IS_AGGR_TYPE (type
)
2747 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2750 if (processing_template_decl
)
2752 /* This may change after the call to
2753 push_template_decl_real, but we want the original value. */
2754 tree name
= DECL_NAME (decl
);
2756 decl
= push_template_decl_real (decl
, globalize
);
2757 /* If the current binding level is the binding level for the
2758 template parameters (see the comment in
2759 begin_template_parm_list) and the enclosing level is a class
2760 scope, and we're not looking at a friend, push the
2761 declaration of the member class into the class scope. In the
2762 friend case, push_template_decl will already have put the
2763 friend into global scope, if appropriate. */
2764 if (TREE_CODE (type
) != ENUMERAL_TYPE
2765 && !globalize
&& b
->pseudo_global
2766 && b
->level_chain
->parm_flag
== 2)
2768 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2769 /* Put this tag on the list of tags for the class, since
2770 that won't happen below because B is not the class
2771 binding level, but is instead the pseudo-global level. */
2772 b
->level_chain
->tags
=
2773 saveable_tree_cons (name
, type
, b
->level_chain
->tags
);
2774 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2775 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2783 /* In C++, you don't have to write `struct S' to refer to `S'; you
2784 can just use `S'. We accomplish this by creating a TYPE_DECL as
2785 if the user had written `typedef struct S S'. Create and return
2786 the TYPE_DECL for TYPE. */
2789 create_implicit_typedef (name
, type
)
2795 decl
= build_decl (TYPE_DECL
, name
, type
);
2796 SET_DECL_ARTIFICIAL (decl
);
2797 /* There are other implicit type declarations, like the one *within*
2798 a class that allows you to write `S::S'. We must distinguish
2800 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
2801 TYPE_NAME (type
) = decl
;
2806 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2807 Normally put it into the inner-most non-tag-transparent scope,
2808 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2809 The latter is needed for implicit declarations. */
2812 pushtag (name
, type
, globalize
)
2816 register struct binding_level
*b
;
2818 b
= current_binding_level
;
2819 while (b
->tag_transparent
2820 || (globalize
&& b
->parm_flag
== 2))
2823 if (toplevel_bindings_p ())
2824 b
->tags
= perm_tree_cons (name
, type
, b
->tags
);
2826 b
->tags
= saveable_tree_cons (name
, type
, b
->tags
);
2830 /* Do C++ gratuitous typedefing. */
2831 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2833 register tree d
= NULL_TREE
;
2835 tree context
= TYPE_CONTEXT (type
);
2839 tree cs
= current_scope ();
2843 else if (cs
!= NULL_TREE
2844 && TREE_CODE_CLASS (TREE_CODE (cs
)) == 't')
2845 /* When declaring a friend class of a local class, we want
2846 to inject the newly named class into the scope
2847 containing the local class, not the namespace scope. */
2848 context
= hack_decl_function_context (get_type_decl (cs
));
2851 context
= current_namespace
;
2853 if ((b
->pseudo_global
&& b
->level_chain
->parm_flag
== 2)
2854 || b
->parm_flag
== 2)
2857 if (current_lang_name
== lang_name_java
)
2858 TYPE_FOR_JAVA (type
) = 1;
2860 d
= create_implicit_typedef (name
, type
);
2861 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2863 set_identifier_type_value_with_scope (name
, type
, b
);
2865 d
= maybe_process_template_type_declaration (type
,
2868 if (b
->parm_flag
== 2)
2870 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2871 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2872 class. But if it's a member template class, we
2873 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2875 finish_member_declaration (d
);
2877 pushdecl_class_level (d
);
2880 d
= pushdecl_with_scope (d
, b
);
2882 if (ANON_AGGRNAME_P (name
))
2883 DECL_IGNORED_P (d
) = 1;
2885 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2886 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2887 if (!uses_template_parms (type
))
2888 DECL_ASSEMBLER_NAME (d
)
2889 = get_identifier (build_overload_name (type
, 1, 1));
2891 if (b
->parm_flag
== 2)
2893 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2894 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2898 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2899 /* Use the canonical TYPE_DECL for this node. */
2900 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2903 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2904 will be the tagged type we just added to the current
2905 binding level. This fake NULL-named TYPE_DECL node helps
2906 dwarfout.c to know when it needs to output a
2907 representation of a tagged type, and it also gives us a
2908 convenient place to record the "scope start" address for
2911 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2912 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2916 /* Counter used to create anonymous type names. */
2918 static int anon_cnt
= 0;
2920 /* Return an IDENTIFIER which can be used as a name for
2921 anonymous structs and unions. */
2928 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2929 return get_identifier (buf
);
2932 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2933 This keeps dbxout from getting confused. */
2938 register struct binding_level
*b
;
2940 static int last_cnt
= 0;
2942 /* Fast out if no new anon names were declared. */
2943 if (last_cnt
== anon_cnt
)
2946 b
= current_binding_level
;
2947 while (b
->tag_transparent
)
2952 /* A NULL purpose means we have already processed all tags
2953 from here to the end of the list. */
2954 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2956 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2957 TREE_PURPOSE (tags
) = NULL_TREE
;
2958 tags
= TREE_CHAIN (tags
);
2960 last_cnt
= anon_cnt
;
2963 /* Subroutine of duplicate_decls: return truthvalue of whether
2964 or not types of these decls match.
2966 For C++, we must compare the parameter list so that `int' can match
2967 `int&' in a parameter position, but `int&' is not confused with
2971 decls_match (newdecl
, olddecl
)
2972 tree newdecl
, olddecl
;
2976 if (newdecl
== olddecl
)
2979 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
2980 /* If the two DECLs are not even the same kind of thing, we're not
2981 interested in their types. */
2984 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2986 tree f1
= TREE_TYPE (newdecl
);
2987 tree f2
= TREE_TYPE (olddecl
);
2988 tree p1
= TYPE_ARG_TYPES (f1
);
2989 tree p2
= TYPE_ARG_TYPES (f2
);
2991 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
)
2992 && ! (DECL_LANGUAGE (newdecl
) == lang_c
2993 && DECL_LANGUAGE (olddecl
) == lang_c
))
2996 /* When we parse a static member function definition,
2997 we put together a FUNCTION_DECL which thinks its type
2998 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
3000 if (TREE_CODE (f1
) == METHOD_TYPE
&& DECL_STATIC_FUNCTION_P (olddecl
))
3001 revert_static_member_fn (&newdecl
, &f1
, &p1
);
3002 else if (TREE_CODE (f2
) == METHOD_TYPE
3003 && DECL_STATIC_FUNCTION_P (newdecl
))
3004 revert_static_member_fn (&olddecl
, &f2
, &p2
);
3006 /* Here we must take care of the case where new default
3007 parameters are specified. Also, warn if an old
3008 declaration becomes ambiguous because default
3009 parameters may cause the two to be ambiguous. */
3010 if (TREE_CODE (f1
) != TREE_CODE (f2
))
3012 if (TREE_CODE (f1
) == OFFSET_TYPE
)
3013 cp_compiler_error ("`%D' redeclared as member function", newdecl
);
3015 cp_compiler_error ("`%D' redeclared as non-member function", newdecl
);
3019 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
3021 if (! strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
) == lang_c
3024 types_match
= self_promoting_args_p (p1
);
3025 if (p1
== void_list_node
)
3026 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
3028 else if (!strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
)==lang_c
3029 && DECL_LANGUAGE (newdecl
) == lang_c
&& p1
== NULL_TREE
)
3031 types_match
= self_promoting_args_p (p2
);
3032 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
3035 types_match
= compparms (p1
, p2
);
3040 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3042 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3043 DECL_TEMPLATE_PARMS (olddecl
)))
3046 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3049 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
3050 DECL_TEMPLATE_RESULT (newdecl
));
3054 if (TREE_TYPE (newdecl
) == error_mark_node
)
3055 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
3056 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
3057 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
3058 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
3061 types_match
= comptypes (TREE_TYPE (newdecl
),
3062 TREE_TYPE (olddecl
),
3063 COMPARE_REDECLARATION
);
3069 /* If NEWDECL is `static' and an `extern' was seen previously,
3070 warn about it. (OLDDECL may be NULL_TREE; NAME contains
3071 information about previous usage as an `extern'.)
3073 Note that this does not apply to the C++ case of declaring
3074 a variable `extern const' and then later `const'.
3076 Don't complain about built-in functions, since they are beyond
3077 the user's control. */
3080 warn_extern_redeclared_static (newdecl
, olddecl
)
3081 tree newdecl
, olddecl
;
3085 static const char *explicit_extern_static_warning
3086 = "`%D' was declared `extern' and later `static'";
3087 static const char *implicit_extern_static_warning
3088 = "`%D' was declared implicitly `extern' and later `static'";
3090 if (TREE_CODE (newdecl
) == TYPE_DECL
)
3093 name
= DECL_ASSEMBLER_NAME (newdecl
);
3094 if (TREE_PUBLIC (name
) && DECL_THIS_STATIC (newdecl
))
3096 /* It's okay to redeclare an ANSI built-in function as static,
3097 or to declare a non-ANSI built-in function as anything. */
3098 if (! (TREE_CODE (newdecl
) == FUNCTION_DECL
3099 && olddecl
!= NULL_TREE
3100 && TREE_CODE (olddecl
) == FUNCTION_DECL
3101 && DECL_ARTIFICIAL (olddecl
)))
3103 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
3104 ? implicit_extern_static_warning
3105 : explicit_extern_static_warning
, newdecl
);
3106 if (olddecl
!= NULL_TREE
)
3107 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
3112 /* Handle when a new declaration NEWDECL has the same name as an old
3113 one OLDDECL in the same binding contour. Prints an error message
3116 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3117 Otherwise, return 0. */
3120 duplicate_decls (newdecl
, olddecl
)
3121 tree newdecl
, olddecl
;
3123 extern struct obstack permanent_obstack
;
3124 unsigned olddecl_uid
= DECL_UID (olddecl
);
3125 int olddecl_friend
= 0, types_match
= 0;
3126 int new_defines_function
= 0;
3128 if (newdecl
== olddecl
)
3131 types_match
= decls_match (newdecl
, olddecl
);
3133 /* If either the type of the new decl or the type of the old decl is an
3134 error_mark_node, then that implies that we have already issued an
3135 error (earlier) for some bogus type specification, and in that case,
3136 it is rather pointless to harass the user with yet more error message
3137 about the same declaration, so just pretend the types match here. */
3138 if (TREE_TYPE (newdecl
) == error_mark_node
3139 || TREE_TYPE (olddecl
) == error_mark_node
)
3142 /* Check for redeclaration and other discrepancies. */
3143 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3144 && DECL_ARTIFICIAL (olddecl
))
3146 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
3148 /* If you declare a built-in or predefined function name as static,
3149 the old definition is overridden, but optionally warn this was a
3150 bad choice of name. */
3151 if (! TREE_PUBLIC (newdecl
))
3154 cp_warning ("shadowing %s function `%#D'",
3155 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3157 /* Discard the old built-in function. */
3160 /* If the built-in is not ansi, then programs can override
3161 it even globally without an error. */
3162 else if (! DECL_BUILT_IN (olddecl
))
3163 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3167 cp_error ("declaration of `%#D'", newdecl
);
3168 cp_error ("conflicts with built-in declaration `%#D'",
3173 else if (!types_match
)
3175 if ((DECL_LANGUAGE (newdecl
) == lang_c
3176 && DECL_LANGUAGE (olddecl
) == lang_c
)
3177 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3178 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3180 /* A near match; override the builtin. */
3182 if (TREE_PUBLIC (newdecl
))
3184 cp_warning ("new declaration `%#D'", newdecl
);
3185 cp_warning ("ambiguates built-in declaration `%#D'",
3188 else if (warn_shadow
)
3189 cp_warning ("shadowing %s function `%#D'",
3190 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3194 /* Discard the old built-in function. */
3198 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
3200 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
3201 && TREE_CODE (newdecl
) != TYPE_DECL
3202 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
3203 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
3204 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
3205 && TREE_CODE (olddecl
) != TYPE_DECL
3206 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
3207 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
3210 /* We do nothing special here, because C++ does such nasty
3211 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3212 get shadowed, and know that if we need to find a TYPE_DECL
3213 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3214 slot of the identifier. */
3218 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
3219 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
3220 || (TREE_CODE (olddecl
) == FUNCTION_DECL
3221 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
3224 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
3225 if (TREE_CODE (olddecl
) == TREE_LIST
)
3226 olddecl
= TREE_VALUE (olddecl
);
3227 cp_error_at ("previous declaration of `%#D'", olddecl
);
3229 /* New decl is completely inconsistent with the old one =>
3230 tell caller to replace the old one. */
3234 else if (!types_match
)
3236 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
))
3237 /* These are certainly not duplicate declarations; they're
3238 from different scopes. */
3241 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3243 /* The name of a class template may not be declared to refer to
3244 any other template, class, function, object, namespace, value,
3245 or type in the same scope. */
3246 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
3247 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3249 cp_error ("declaration of template `%#D'", newdecl
);
3250 cp_error_at ("conflicts with previous declaration `%#D'",
3253 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
3254 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
3255 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
3256 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
3257 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3258 DECL_TEMPLATE_PARMS (olddecl
)))
3260 cp_error ("new declaration `%#D'", newdecl
);
3261 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3265 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3267 if (DECL_LANGUAGE (newdecl
) == lang_c
3268 && DECL_LANGUAGE (olddecl
) == lang_c
)
3270 cp_error ("declaration of C function `%#D' conflicts with",
3272 cp_error_at ("previous declaration `%#D' here", olddecl
);
3274 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3275 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3277 cp_error ("new declaration `%#D'", newdecl
);
3278 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3284 /* Already complained about this, so don't do so again. */
3285 else if (current_class_type
== NULL_TREE
3286 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
3288 cp_error ("conflicting types for `%#D'", newdecl
);
3289 cp_error_at ("previous declaration as `%#D'", olddecl
);
3292 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3293 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
3294 && (!DECL_TEMPLATE_INFO (newdecl
)
3295 || (DECL_TI_TEMPLATE (newdecl
)
3296 != DECL_TI_TEMPLATE (olddecl
))))
3297 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
3298 && (!DECL_TEMPLATE_INFO (olddecl
)
3299 || (DECL_TI_TEMPLATE (olddecl
)
3300 != DECL_TI_TEMPLATE (newdecl
))))))
3301 /* It's OK to have a template specialization and a non-template
3302 with the same type, or to have specializations of two
3303 different templates with the same type. Note that if one is a
3304 specialization, and the other is an instantiation of the same
3305 template, that we do not exit at this point. That situation
3306 can occur if we instantiate a template class, and then
3307 specialize one of its methods. This situation is legal, but
3308 the declarations must be merged in the usual way. */
3310 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3311 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
3312 && !DECL_USE_TEMPLATE (newdecl
))
3313 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
3314 && !DECL_USE_TEMPLATE (olddecl
))))
3315 /* One of the declarations is a template instantiation, and the
3316 other is not a template at all. That's OK. */
3318 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
3319 && DECL_NAMESPACE_ALIAS (newdecl
)
3320 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
3321 /* Redeclaration of namespace alias, ignore it. */
3325 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
3328 cp_error (errmsg
, newdecl
);
3329 if (DECL_NAME (olddecl
) != NULL_TREE
)
3330 cp_error_at ((DECL_INITIAL (olddecl
)
3331 && namespace_bindings_p ())
3332 ? "`%#D' previously defined here"
3333 : "`%#D' previously declared here", olddecl
);
3335 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3336 && DECL_INITIAL (olddecl
) != NULL_TREE
3337 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
3338 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
3340 /* Prototype decl follows defn w/o prototype. */
3341 cp_warning_at ("prototype for `%#D'", newdecl
);
3342 cp_warning_at ("follows non-prototype definition here", olddecl
);
3344 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3345 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
3347 /* extern "C" int foo ();
3348 int foo () { bar (); }
3350 if (current_lang_stack
== current_lang_base
)
3351 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3354 cp_error_at ("previous declaration of `%#D' with %L linkage",
3355 olddecl
, DECL_LANGUAGE (olddecl
));
3356 cp_error ("conflicts with new declaration with %L linkage",
3357 DECL_LANGUAGE (newdecl
));
3361 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
3363 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
3365 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
3366 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
3369 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
3370 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
3372 for (; t1
&& t1
!= void_list_node
;
3373 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
3374 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
3376 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
3381 cp_pedwarn ("default argument given for parameter %d of `%#D'",
3383 cp_pedwarn_at ("after previous specification in `%#D'",
3389 cp_error ("default argument given for parameter %d of `%#D'",
3391 cp_error_at ("after previous specification in `%#D'",
3396 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
3397 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
3399 cp_warning ("`%#D' was used before it was declared inline",
3401 cp_warning_at ("previous non-inline declaration here",
3407 /* If new decl is `static' and an `extern' was seen previously,
3409 warn_extern_redeclared_static (newdecl
, olddecl
);
3411 /* We have committed to returning 1 at this point. */
3412 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3414 /* Now that functions must hold information normally held
3415 by field decls, there is extra work to do so that
3416 declaration information does not get destroyed during
3418 if (DECL_VINDEX (olddecl
))
3419 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
3420 if (DECL_CONTEXT (olddecl
))
3421 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
3422 if (DECL_CLASS_CONTEXT (olddecl
))
3423 DECL_CLASS_CONTEXT (newdecl
) = DECL_CLASS_CONTEXT (olddecl
);
3424 if (DECL_PENDING_INLINE_INFO (newdecl
) == (struct pending_inline
*)0)
3425 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
3426 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
3427 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
3428 DECL_ABSTRACT_VIRTUAL_P (newdecl
) |= DECL_ABSTRACT_VIRTUAL_P (olddecl
);
3429 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
3430 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
3431 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
3433 /* Optionally warn about more than one declaration for the same
3434 name, but don't warn about a function declaration followed by a
3436 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
3437 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
3438 /* Don't warn about extern decl followed by definition. */
3439 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
3440 /* Don't warn about friends, let add_friend take care of it. */
3441 && ! DECL_FRIEND_P (newdecl
))
3443 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
3444 cp_warning_at ("previous declaration of `%D'", olddecl
);
3448 /* Deal with C++: must preserve virtual function table size. */
3449 if (TREE_CODE (olddecl
) == TYPE_DECL
)
3451 register tree newtype
= TREE_TYPE (newdecl
);
3452 register tree oldtype
= TREE_TYPE (olddecl
);
3454 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
3455 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
3457 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
3458 CLASSTYPE_FRIEND_CLASSES (newtype
)
3459 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
3463 /* Copy all the DECL_... slots specified in the new decl
3464 except for any that we copy here from the old type. */
3465 DECL_MACHINE_ATTRIBUTES (newdecl
)
3466 = merge_machine_decl_attributes (olddecl
, newdecl
);
3468 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3470 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl
),
3471 DECL_TEMPLATE_RESULT (olddecl
)))
3472 cp_error ("invalid redeclaration of %D", newdecl
);
3473 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
3474 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
3475 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
3476 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3483 /* Automatically handles default parameters. */
3484 tree oldtype
= TREE_TYPE (olddecl
);
3487 /* Make sure we put the new type in the same obstack as the old one. */
3489 push_obstacks (TYPE_OBSTACK (oldtype
), TYPE_OBSTACK (oldtype
));
3491 push_permanent_obstack ();
3493 /* Merge the data types specified in the two decls. */
3494 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3496 if (TREE_CODE (newdecl
) == VAR_DECL
)
3497 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3498 /* Do this after calling `common_type' so that default
3499 parameters don't confuse us. */
3500 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3501 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3502 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3504 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3505 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3506 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3507 TYPE_RAISES_EXCEPTIONS (oldtype
));
3509 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3510 && DECL_SOURCE_LINE (olddecl
) != 0
3512 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)),
3513 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
)), 1))
3515 cp_error ("declaration of `%F' throws different exceptions",
3517 cp_error_at ("to previous declaration `%F'", olddecl
);
3520 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3522 /* Lay the type out, unless already done. */
3523 if (! same_type_p (newtype
, oldtype
)
3524 && TREE_TYPE (newdecl
) != error_mark_node
3525 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3526 layout_type (TREE_TYPE (newdecl
));
3528 if ((TREE_CODE (newdecl
) == VAR_DECL
3529 || TREE_CODE (newdecl
) == PARM_DECL
3530 || TREE_CODE (newdecl
) == RESULT_DECL
3531 || TREE_CODE (newdecl
) == FIELD_DECL
3532 || TREE_CODE (newdecl
) == TYPE_DECL
)
3533 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3534 layout_decl (newdecl
, 0);
3536 /* Merge the type qualifiers. */
3537 if (TREE_READONLY (newdecl
))
3538 TREE_READONLY (olddecl
) = 1;
3539 if (TREE_THIS_VOLATILE (newdecl
))
3540 TREE_THIS_VOLATILE (olddecl
) = 1;
3542 /* Merge the initialization information. */
3543 if (DECL_INITIAL (newdecl
) == NULL_TREE
3544 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3546 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3547 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3548 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3549 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
3550 && DECL_LANG_SPECIFIC (newdecl
)
3551 && DECL_LANG_SPECIFIC (olddecl
))
3552 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3555 /* Merge the section attribute.
3556 We want to issue an error if the sections conflict but that must be
3557 done later in decl_attributes since we are called before attributes
3559 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3560 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3562 /* Keep the old rtl since we can safely use it, unless it's the
3563 call to abort() used for abstract virtuals. */
3564 if ((DECL_LANG_SPECIFIC (olddecl
)
3565 && !DECL_ABSTRACT_VIRTUAL_P (olddecl
))
3566 || DECL_RTL (olddecl
) != DECL_RTL (abort_fndecl
))
3567 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3571 /* If cannot merge, then use the new type and qualifiers,
3572 and don't preserve the old rtl. */
3575 /* Clean out any memory we had of the old declaration. */
3576 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3578 TREE_VALUE (oldstatic
) = error_mark_node
;
3580 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3581 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3582 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3583 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3586 /* Merge the storage class information. */
3587 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3588 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3589 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3590 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3591 if (! DECL_EXTERNAL (olddecl
))
3592 DECL_EXTERNAL (newdecl
) = 0;
3594 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3596 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3597 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3598 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3599 DECL_TEMPLATE_INSTANTIATED (newdecl
)
3600 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
3601 /* Don't really know how much of the language-specific
3602 values we should copy from old to new. */
3603 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3604 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3605 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3606 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3607 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3609 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3610 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3611 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
3612 DECL_BEFRIENDING_CLASSES (newdecl
)
3613 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
3614 DECL_BEFRIENDING_CLASSES (olddecl
));
3617 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3619 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3620 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3622 /* If newdecl is not a specialization, then it is not a
3623 template-related function at all. And that means that we
3624 shoud have exited above, returning 0. */
3625 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3628 if (TREE_USED (olddecl
))
3629 /* From [temp.expl.spec]:
3631 If a template, a member template or the member of a class
3632 template is explicitly specialized then that
3633 specialization shall be declared before the first use of
3634 that specialization that would cause an implicit
3635 instantiation to take place, in every translation unit in
3636 which such a use occurs. */
3637 cp_error ("explicit specialization of %D after first use",
3640 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3642 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3644 /* If either decl says `inline', this fn is inline, unless its
3645 definition was passed already. */
3646 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3647 DECL_INLINE (olddecl
) = 1;
3648 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3652 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3653 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3654 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3656 if (! types_match
|| new_defines_function
)
3658 /* These need to be copied so that the names are available.
3659 Note that if the types do match, we'll preserve inline
3660 info and other bits, but if not, we won't. */
3661 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3662 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3664 if (new_defines_function
)
3665 /* If defining a function declared with other language
3666 linkage, use the previously declared language linkage. */
3667 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3668 else if (types_match
)
3670 /* If redeclaring a builtin function, and not a definition,
3671 it stays built in. */
3672 if (DECL_BUILT_IN (olddecl
))
3674 DECL_BUILT_IN (newdecl
) = 1;
3675 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3676 /* If we're keeping the built-in definition, keep the rtl,
3677 regardless of declaration matches. */
3678 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3681 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3683 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3684 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3685 /* Previously saved insns go together with
3686 the function's previous definition. */
3687 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3688 /* Don't clear out the arguments if we're redefining a function. */
3689 if (DECL_ARGUMENTS (olddecl
))
3690 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3692 if (DECL_LANG_SPECIFIC (olddecl
))
3693 DECL_MAIN_VARIANT (newdecl
) = DECL_MAIN_VARIANT (olddecl
);
3696 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3698 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3701 /* Now preserve various other info from the definition. */
3702 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3703 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3704 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3705 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3707 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3710 struct lang_decl
*ol
= DECL_LANG_SPECIFIC (olddecl
);
3711 struct lang_decl
*nl
= DECL_LANG_SPECIFIC (newdecl
);
3713 function_size
= sizeof (struct tree_decl
);
3715 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3716 (char *) olddecl
+ sizeof (struct tree_common
),
3717 function_size
- sizeof (struct tree_common
));
3719 /* Can we safely free the storage used by newdecl? */
3721 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3722 & ~ obstack_alignment_mask (&permanent_obstack))
3724 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3726 /* If newdecl is a template instantiation, it is possible that
3727 the following sequence of events has occurred:
3729 o A friend function was declared in a class template. The
3730 class template was instantiated.
3732 o The instantiation of the friend declaration was
3733 recorded on the instantiation list, and is newdecl.
3735 o Later, however, instantiate_class_template called pushdecl
3736 on the newdecl to perform name injection. But, pushdecl in
3737 turn called duplicate_decls when it discovered that another
3738 declaration of a global function with the same name already
3741 o Here, in duplicate_decls, we decided to clobber newdecl.
3743 If we're going to do that, we'd better make sure that
3744 olddecl, and not newdecl, is on the list of
3745 instantiations so that if we try to do the instantiation
3746 again we won't get the clobbered declaration. */
3748 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3749 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3751 for (; decls
; decls
= TREE_CHAIN (decls
))
3752 if (TREE_VALUE (decls
) == newdecl
)
3753 TREE_VALUE (decls
) = olddecl
;
3756 if (((char *)newdecl
+ ROUND (function_size
) == (char *)nl
3757 && ((char *)newdecl
+ ROUND (function_size
)
3758 + ROUND (sizeof (struct lang_decl
))
3759 == obstack_next_free (&permanent_obstack
)))
3760 || ((char *)newdecl
+ ROUND (function_size
)
3761 == obstack_next_free (&permanent_obstack
)))
3763 DECL_MAIN_VARIANT (newdecl
) = olddecl
;
3764 DECL_LANG_SPECIFIC (olddecl
) = ol
;
3765 bcopy ((char *)nl
, (char *)ol
, sizeof (struct lang_decl
));
3767 obstack_free (&permanent_obstack
, newdecl
);
3769 else if (LANG_DECL_PERMANENT (ol
) && ol
!= nl
)
3771 if (DECL_MAIN_VARIANT (olddecl
) == olddecl
)
3773 struct lang_decl
*free_lang_decl
= ol
;
3775 /* Save these lang_decls that would otherwise be lost. */
3776 if (DECL_LANG_SPECIFIC (olddecl
) == ol
)
3779 free_lang_decl
->u
.next
= free_lang_decl_chain
;
3780 free_lang_decl_chain
= free_lang_decl
;
3784 /* Storage leak. */;
3790 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3791 (char *) olddecl
+ sizeof (struct tree_common
),
3792 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3793 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3796 DECL_UID (olddecl
) = olddecl_uid
;
3798 DECL_FRIEND_P (olddecl
) = 1;
3800 /* NEWDECL contains the merged attribute lists.
3801 Update OLDDECL to be the same. */
3802 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3807 /* Record a decl-node X as belonging to the current lexical scope.
3808 Check for errors (such as an incompatible declaration for the same
3809 name already seen in the same scope).
3811 Returns either X or an old decl for the same name.
3812 If an old decl is returned, it may have been smashed
3813 to agree with what X says. */
3820 register tree name
= DECL_ASSEMBLER_NAME (x
);
3821 int need_new_binding
= 1;
3823 if (DECL_TEMPLATE_PARM_P (x
))
3824 /* Template parameters have no context; they are not X::T even
3825 when declared within a class or namespace. */
3829 if (current_function_decl
&& x
!= current_function_decl
3830 /* A local declaration for a function doesn't constitute
3832 && (TREE_CODE (x
) != FUNCTION_DECL
|| DECL_INITIAL (x
))
3833 /* Don't change DECL_CONTEXT of virtual methods. */
3834 && (TREE_CODE (x
) != FUNCTION_DECL
|| !DECL_VIRTUAL_P (x
))
3835 && !DECL_CONTEXT (x
))
3836 DECL_CONTEXT (x
) = current_function_decl
;
3837 if (!DECL_CONTEXT (x
))
3838 DECL_CONTEXT (x
) = FROB_CONTEXT (current_namespace
);
3841 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3842 compiler wants to use. */
3843 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
3844 || TREE_CODE (x
) == NAMESPACE_DECL
)
3845 name
= DECL_NAME (x
);
3850 /* Not needed...see below. */
3854 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3855 name
= TREE_OPERAND (name
, 0);
3857 /* Namespace-scoped variables are not found in the current level. */
3858 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
))
3859 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3861 t
= lookup_name_current_level (name
);
3862 if (t
== error_mark_node
)
3864 /* error_mark_node is 0 for a while during initialization! */
3866 cp_error_at ("`%#D' used prior to declaration", x
);
3869 else if (t
!= NULL_TREE
)
3872 /* This is turned off until I have time to do it right (bpk). */
3873 /* With the code below that uses it... */
3874 file
= DECL_SOURCE_FILE (t
);
3875 line
= DECL_SOURCE_LINE (t
);
3877 if (TREE_CODE (t
) == PARM_DECL
)
3879 if (DECL_CONTEXT (t
) == NULL_TREE
)
3880 fatal ("parse errors have confused me too much");
3882 /* Check for duplicate params. */
3883 if (duplicate_decls (x
, t
))
3886 else if (((TREE_CODE (x
) == FUNCTION_DECL
&& DECL_LANGUAGE (x
) == lang_c
)
3887 || DECL_FUNCTION_TEMPLATE_P (x
))
3888 && is_overloaded_fn (t
))
3889 /* Don't do anything just yet. */;
3890 else if (t
== wchar_decl_node
)
3892 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3893 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3895 /* Throw away the redeclaration. */
3898 else if (TREE_CODE (t
) != TREE_CODE (x
))
3900 if (duplicate_decls (x
, t
))
3903 else if (duplicate_decls (x
, t
))
3906 /* This is turned off until I have time to do it right (bpk). */
3908 /* Also warn if they did a prototype with `static' on it, but
3909 then later left the `static' off. */
3910 if (! TREE_PUBLIC (name
) && TREE_PUBLIC (x
))
3912 if (DECL_LANG_SPECIFIC (t
) && DECL_FRIEND_P (t
))
3917 cp_warning ("`static' missing from declaration of `%D'",
3919 warning_with_file_and_line (file
, line
,
3920 "previous declaration of `%s'",
3921 decl_as_string (t
, 0));
3924 /* Now fix things so it'll do what they expect. */
3925 if (current_function_decl
)
3926 TREE_PUBLIC (current_function_decl
) = 0;
3928 /* Due to interference in memory reclamation (X may be
3929 obstack-deallocated at this point), we must guard against
3930 one really special case. [jason: This should be handled
3931 by start_function] */
3932 if (current_function_decl
== x
)
3933 current_function_decl
= t
;
3935 if (TREE_CODE (t
) == TYPE_DECL
)
3936 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3937 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3938 check_default_args (t
);
3942 else if (DECL_MAIN_P (x
))
3944 /* A redeclaration of main, but not a duplicate of the
3949 This function shall not be overloaded. */
3950 cp_error_at ("invalid redeclaration of `%D'", t
);
3951 cp_error ("as `%D'", x
);
3952 /* We don't try to push this declaration since that
3958 check_template_shadow (x
);
3960 /* If this is a function conjured up by the backend, massage it
3961 so it looks friendly. */
3962 if (TREE_CODE (x
) == FUNCTION_DECL
3963 && ! DECL_LANG_SPECIFIC (x
))
3965 retrofit_lang_decl (x
);
3966 DECL_LANGUAGE (x
) = lang_c
;
3969 if (TREE_CODE (x
) == FUNCTION_DECL
&& ! DECL_FUNCTION_MEMBER_P (x
))
3971 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
3972 if (t
!= x
|| DECL_LANGUAGE (x
) == lang_c
)
3974 if (!namespace_bindings_p ())
3975 /* We do not need to create a binding for this name;
3976 push_overloaded_decl will have already done so if
3978 need_new_binding
= 0;
3980 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3982 t
= push_overloaded_decl (x
, PUSH_GLOBAL
);
3984 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
3988 /* If declaring a type as a typedef, copy the type (unless we're
3989 at line 0), and install this TYPE_DECL as the new type's typedef
3990 name. See the extensive comment in ../c-decl.c (pushdecl). */
3991 if (TREE_CODE (x
) == TYPE_DECL
)
3993 tree type
= TREE_TYPE (x
);
3994 if (DECL_SOURCE_LINE (x
) == 0)
3996 if (TYPE_NAME (type
) == 0)
3997 TYPE_NAME (type
) = x
;
3999 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
4000 /* We don't want to copy the type when all we're
4001 doing is making a TYPE_DECL for the purposes of
4003 && (!TYPE_NAME (type
)
4004 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
4006 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
4008 DECL_ORIGINAL_TYPE (x
) = type
;
4009 type
= build_type_copy (type
);
4010 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
4011 TYPE_NAME (type
) = x
;
4012 TREE_TYPE (x
) = type
;
4017 if (type
!= error_mark_node
4019 && TYPE_IDENTIFIER (type
))
4020 set_identifier_type_value_with_scope (DECL_NAME (x
), type
,
4021 current_binding_level
);
4025 /* Multiple external decls of the same identifier ought to match.
4027 We get warnings about inline functions where they are defined.
4028 We get warnings about other functions from push_overloaded_decl.
4030 Avoid duplicate warnings where they are used. */
4031 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
4035 if (IDENTIFIER_NAMESPACE_VALUE (name
) != NULL_TREE
4036 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name
))
4037 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name
))))
4038 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
4043 /* If different sort of thing, we already gave an error. */
4044 && TREE_CODE (decl
) == TREE_CODE (x
)
4045 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
4047 cp_pedwarn ("type mismatch with previous external decl", x
);
4048 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
4052 /* This name is new in its binding level.
4053 Install the new declaration and return it. */
4054 if (namespace_bindings_p ())
4056 /* Install a global value. */
4058 /* If the first global decl has external linkage,
4059 warn if we later see static one. */
4060 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
4061 TREE_PUBLIC (name
) = 1;
4063 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
4066 if (TREE_CODE (x
) == FUNCTION_DECL
)
4068 ((IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
)
4069 || (IDENTIFIER_GLOBAL_VALUE (name
) == x
), 378);
4070 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
4073 /* Don't forget if the function was used via an implicit decl. */
4074 if (IDENTIFIER_IMPLICIT_DECL (name
)
4075 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
4078 /* Don't forget if its address was taken in that way. */
4079 if (IDENTIFIER_IMPLICIT_DECL (name
)
4080 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
4081 TREE_ADDRESSABLE (x
) = 1;
4083 /* Warn about mismatches against previous implicit decl. */
4084 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
4085 /* If this real decl matches the implicit, don't complain. */
4086 && ! (TREE_CODE (x
) == FUNCTION_DECL
4087 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
4089 ("`%D' was previously implicitly declared to return `int'", x
);
4091 /* If new decl is `static' and an `extern' was seen previously,
4093 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
4094 warn_extern_redeclared_static (x
, t
);
4098 /* Here to install a non-global value. */
4099 tree oldlocal
= IDENTIFIER_VALUE (name
);
4100 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
4102 if (need_new_binding
)
4104 push_local_binding (name
, x
, 0);
4105 /* Because push_local_binding will hook X on to the
4106 current_binding_level's name list, we don't want to
4107 do that again below. */
4108 need_new_binding
= 0;
4111 /* If this is a TYPE_DECL, push it into the type value slot. */
4112 if (TREE_CODE (x
) == TYPE_DECL
)
4113 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
),
4114 current_binding_level
);
4116 /* Clear out any TYPE_DECL shadowed by a namespace so that
4117 we won't think this is a type. The C struct hack doesn't
4118 go through namespaces. */
4119 if (TREE_CODE (x
) == NAMESPACE_DECL
)
4120 set_identifier_type_value_with_scope (name
, NULL_TREE
,
4121 current_binding_level
);
4123 /* If this is an extern function declaration, see if we
4124 have a global definition or declaration for the function. */
4125 if (oldlocal
== NULL_TREE
4126 && DECL_EXTERNAL (x
)
4127 && oldglobal
!= NULL_TREE
4128 && TREE_CODE (x
) == FUNCTION_DECL
4129 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
4131 /* We have one. Their types must agree. */
4132 if (decls_match (x
, oldglobal
))
4136 cp_warning ("extern declaration of `%#D' doesn't match", x
);
4137 cp_warning_at ("global declaration `%#D'", oldglobal
);
4140 /* If we have a local external declaration,
4141 and no file-scope declaration has yet been seen,
4142 then if we later have a file-scope decl it must not be static. */
4143 if (oldlocal
== NULL_TREE
4144 && oldglobal
== NULL_TREE
4145 && DECL_EXTERNAL (x
)
4147 TREE_PUBLIC (name
) = 1;
4149 if (DECL_FROM_INLINE (x
))
4150 /* Inline decls shadow nothing. */;
4152 /* Warn if shadowing an argument at the top level of the body. */
4153 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
4154 && TREE_CODE (oldlocal
) == PARM_DECL
4155 /* Don't complain if it's from an enclosing function. */
4156 && DECL_CONTEXT (oldlocal
) == current_function_decl
4157 && TREE_CODE (x
) != PARM_DECL
)
4159 /* Go to where the parms should be and see if we
4161 struct binding_level
*b
= current_binding_level
->level_chain
;
4167 if (b
->parm_flag
== 1)
4168 cp_error ("declaration of `%#D' shadows a parameter", name
);
4170 else if (warn_shadow
&& oldlocal
!= NULL_TREE
4171 && current_binding_level
->is_for_scope
4172 && !DECL_DEAD_FOR_LOCAL (oldlocal
))
4174 warning ("variable `%s' shadows local",
4175 IDENTIFIER_POINTER (name
));
4176 cp_warning_at (" this is the shadowed declaration", oldlocal
);
4178 /* Maybe warn if shadowing something else. */
4179 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
4180 /* No shadow warnings for internally generated vars. */
4181 && ! DECL_ARTIFICIAL (x
)
4182 /* No shadow warnings for vars made for inlining. */
4183 && ! DECL_FROM_INLINE (x
))
4185 const char *warnstring
= NULL
;
4187 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
4188 warnstring
= "declaration of `%s' shadows a parameter";
4189 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
4190 && current_class_ptr
4191 && !TREE_STATIC (name
))
4192 warnstring
= "declaration of `%s' shadows a member of `this'";
4193 else if (oldlocal
!= NULL_TREE
)
4194 warnstring
= "declaration of `%s' shadows previous local";
4195 else if (oldglobal
!= NULL_TREE
)
4196 /* XXX shadow warnings in outer-more namespaces */
4197 warnstring
= "declaration of `%s' shadows global declaration";
4200 warning (warnstring
, IDENTIFIER_POINTER (name
));
4204 if (TREE_CODE (x
) == FUNCTION_DECL
)
4205 check_default_args (x
);
4207 /* Keep count of variables in this level with incomplete type. */
4208 if (TREE_CODE (x
) == VAR_DECL
4209 && TREE_TYPE (x
) != error_mark_node
4210 && ((TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
4211 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
4212 /* RTTI TD entries are created while defining the type_info. */
4213 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
4214 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
4215 current_binding_level
->incomplete
4216 = tree_cons (NULL_TREE
, x
, current_binding_level
->incomplete
);
4219 if (need_new_binding
)
4220 add_decl_to_level (x
, current_binding_level
);
4225 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4226 caller to set DECL_CONTEXT properly. */
4229 pushdecl_with_scope (x
, level
)
4231 struct binding_level
*level
;
4233 register struct binding_level
*b
;
4234 tree function_decl
= current_function_decl
;
4236 current_function_decl
= NULL_TREE
;
4237 if (level
->parm_flag
== 2)
4239 b
= class_binding_level
;
4240 class_binding_level
= level
;
4241 pushdecl_class_level (x
);
4242 class_binding_level
= b
;
4246 b
= current_binding_level
;
4247 current_binding_level
= level
;
4249 current_binding_level
= b
;
4251 current_function_decl
= function_decl
;
4255 /* Like pushdecl, only it places X in the current namespace,
4259 pushdecl_namespace_level (x
)
4262 register struct binding_level
*b
= current_binding_level
;
4265 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
4267 /* Now, the type_shadowed stack may screw us. Munge it so it does
4269 if (TREE_CODE (x
) == TYPE_DECL
)
4271 tree name
= DECL_NAME (x
);
4273 tree
*ptr
= (tree
*)0;
4274 for (; b
!= global_binding_level
; b
= b
->level_chain
)
4276 tree shadowed
= b
->type_shadowed
;
4277 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
4278 if (TREE_PURPOSE (shadowed
) == name
)
4280 ptr
= &TREE_VALUE (shadowed
);
4281 /* Can't break out of the loop here because sometimes
4282 a binding level will have duplicate bindings for
4283 PT names. It's gross, but I haven't time to fix it. */
4286 newval
= TREE_TYPE (x
);
4287 if (ptr
== (tree
*)0)
4289 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4290 up here if this is changed to an assertion. --KR */
4291 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
4301 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4305 pushdecl_top_level (x
)
4308 tree cur_namespace
= current_namespace
;
4309 current_namespace
= global_namespace
;
4310 x
= pushdecl_namespace_level (x
);
4311 current_namespace
= cur_namespace
;
4315 /* Make the declaration of X appear in CLASS scope. */
4318 pushdecl_class_level (x
)
4321 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4322 scope looks for the pre-mangled name. */
4325 if (TREE_CODE (x
) == OVERLOAD
)
4326 x
= OVL_CURRENT (x
);
4327 name
= DECL_NAME (x
);
4331 push_class_level_binding (name
, x
);
4332 if (TREE_CODE (x
) == TYPE_DECL
)
4333 set_identifier_type_value (name
, TREE_TYPE (x
));
4335 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4339 for (f
= TYPE_FIELDS (TREE_TYPE (x
));
4342 pushdecl_class_level (f
);
4346 /* Enter DECL into the symbol table, if that's appropriate. Returns
4347 DECL, or a modified version thereof. */
4350 maybe_push_decl (decl
)
4353 tree type
= TREE_TYPE (decl
);
4355 /* Add this decl to the current binding level, but not if it comes
4356 from another scope, e.g. a static member variable. TEM may equal
4357 DECL or it may be a previous decl of the same name. */
4358 if ((TREE_CODE (decl
) != PARM_DECL
4359 && DECL_CONTEXT (decl
) != NULL_TREE
4360 /* Definitions of namespace members outside their namespace are
4362 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4363 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
4364 || TREE_CODE (type
) == UNKNOWN_TYPE
4365 /* The declaration of a template specialization does not affect
4366 the functions available for overload resolution, so we do not
4368 || (TREE_CODE (decl
) == FUNCTION_DECL
4369 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
4372 return pushdecl (decl
);
4376 /* This function is used to push the mangled decls for nested types into
4377 the appropriate scope. Previously pushdecl_top_level was used, but that
4378 is incorrect for members of local classes. */
4381 pushdecl_nonclass_level (x
)
4384 struct binding_level
*b
= current_binding_level
;
4386 my_friendly_assert (b
->parm_flag
!= 2, 180);
4389 /* Get out of template binding levels */
4390 while (b
->pseudo_global
)
4394 pushdecl_with_scope (x
, b
);
4398 /* Make the declaration(s) of X appear in CLASS scope
4399 under the name NAME. */
4402 push_class_level_binding (name
, x
)
4407 /* The class_binding_level will be NULL if x is a template
4408 parameter name in a member template. */
4409 if (!class_binding_level
)
4412 /* Make sure that this new member does not have the same name
4413 as a template parameter. */
4414 if (TYPE_BEING_DEFINED (current_class_type
))
4415 check_template_shadow (x
);
4417 /* If this declaration shadows a declaration from an enclosing
4418 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4419 we leave this class. Record the shadowed declaration here. */
4420 binding
= IDENTIFIER_BINDING (name
);
4422 && ((TREE_CODE (x
) == OVERLOAD
4423 && BINDING_VALUE (binding
)
4424 && is_overloaded_fn (BINDING_VALUE (binding
)))
4425 || INHERITED_VALUE_BINDING_P (binding
)))
4430 /* If the old binding was from a base class, and was for a tag
4431 name, slide it over to make room for the new binding. The
4432 old binding is still visible if explicitly qualified with a
4434 if (INHERITED_VALUE_BINDING_P (binding
)
4435 && BINDING_VALUE (binding
)
4436 && TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
4437 && DECL_ARTIFICIAL (BINDING_VALUE (binding
))
4438 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
4440 old_decl
= BINDING_TYPE (binding
);
4441 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
4442 BINDING_VALUE (binding
) = NULL_TREE
;
4443 INHERITED_VALUE_BINDING_P (binding
) = 0;
4446 old_decl
= BINDING_VALUE (binding
);
4448 /* There was already a binding for X containing fewer
4449 functions than are named in X. Find the previous
4450 declaration of X on the class-shadowed list, and update it. */
4451 for (shadow
= class_binding_level
->class_shadowed
;
4453 shadow
= TREE_CHAIN (shadow
))
4454 if (TREE_PURPOSE (shadow
) == name
4455 && TREE_TYPE (shadow
) == old_decl
)
4457 BINDING_VALUE (binding
) = x
;
4458 INHERITED_VALUE_BINDING_P (binding
) = 0;
4459 TREE_TYPE (shadow
) = x
;
4464 /* If we didn't replace an existing binding, put the binding on the
4465 stack of bindings for the identifier, and update
4466 IDENTIFIER_CLASS_VALUE. */
4467 if (push_class_binding (name
, x
))
4469 push_cache_obstack ();
4470 class_binding_level
->class_shadowed
4471 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
4472 class_binding_level
->class_shadowed
);
4474 /* Record the value we are binding NAME to so that we can know
4475 what to pop later. */
4476 TREE_TYPE (class_binding_level
->class_shadowed
) = x
;
4480 /* Insert another USING_DECL into the current binding level,
4481 returning this declaration. If this is a redeclaration,
4482 do nothing and return NULL_TREE. */
4485 push_using_decl (scope
, name
)
4491 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
4492 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
4493 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
4494 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
4498 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
4499 DECL_INITIAL (decl
) = scope
;
4500 TREE_CHAIN (decl
) = current_binding_level
->usings
;
4501 current_binding_level
->usings
= decl
;
4505 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4506 changed (i.e. there was already a directive), or the fresh
4507 TREE_LIST otherwise. */
4510 push_using_directive (used
)
4513 tree ud
= current_binding_level
->using_directives
;
4514 tree iter
, ancestor
;
4516 /* Check if we already have this. */
4517 if (purpose_member (used
, ud
) != NULL_TREE
)
4520 /* Recursively add all namespaces used. */
4521 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4522 push_using_directive (TREE_PURPOSE (iter
));
4524 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4525 ud
= current_binding_level
->using_directives
;
4526 ud
= perm_tree_cons (used
, ancestor
, ud
);
4527 current_binding_level
->using_directives
= ud
;
4531 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4532 other definitions already in place. We get around this by making
4533 the value of the identifier point to a list of all the things that
4534 want to be referenced by that name. It is then up to the users of
4535 that name to decide what to do with that list.
4537 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4538 slot. It is dealt with the same way.
4540 FLAGS is a bitwise-or of the following values:
4541 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4543 PUSH_USING: DECL is being pushed as the result of a using
4546 The value returned may be a previous declaration if we guessed wrong
4547 about what language DECL should belong to (C or C++). Otherwise,
4548 it's always DECL (and never something that's not a _DECL). */
4551 push_overloaded_decl (decl
, flags
)
4555 tree name
= DECL_NAME (decl
);
4558 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
4561 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
4563 old
= lookup_name_current_level (name
);
4567 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4569 tree t
= TREE_TYPE (old
);
4570 if (IS_AGGR_TYPE (t
) && warn_shadow
4571 && (! DECL_IN_SYSTEM_HEADER (decl
)
4572 || ! DECL_IN_SYSTEM_HEADER (old
)))
4573 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4576 else if (is_overloaded_fn (old
))
4580 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4582 tree fn
= OVL_CURRENT (tmp
);
4584 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
4585 && !(flags
& PUSH_USING
)
4586 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
4587 TYPE_ARG_TYPES (TREE_TYPE (decl
))))
4588 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4591 if (duplicate_decls (decl
, fn
))
4597 cp_error_at ("previous non-function declaration `%#D'", old
);
4598 cp_error ("conflicts with function declaration `%#D'", decl
);
4603 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4605 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4606 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
4608 new_binding
= ovl_cons (decl
, old
);
4609 if (flags
& PUSH_USING
)
4610 OVL_USED (new_binding
) = 1;
4613 /* NAME is not ambiguous. */
4617 set_namespace_binding (name
, current_namespace
, new_binding
);
4620 /* We only create an OVERLOAD if there was a previous binding at
4621 this level, or if decl is a template. In the former case, we
4622 need to remove the old binding and replace it with the new
4623 binding. We must also run through the NAMES on the binding
4624 level where the name was bound to update the chain. */
4626 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
4630 for (d
= &BINDING_LEVEL (IDENTIFIER_BINDING (name
))->names
;
4632 d
= &TREE_CHAIN (*d
))
4634 || (TREE_CODE (*d
) == TREE_LIST
4635 && TREE_VALUE (*d
) == old
))
4637 if (TREE_CODE (*d
) == TREE_LIST
)
4638 /* Just replace the old binding with the new. */
4639 TREE_VALUE (*d
) = new_binding
;
4641 /* Build a TREE_LIST to wrap the OVERLOAD. */
4642 *d
= build_tree_list (NULL_TREE
, new_binding
);
4644 /* And update the CPLUS_BINDING node. */
4645 BINDING_VALUE (IDENTIFIER_BINDING (name
))
4650 /* We should always find a previous binding in this case. */
4651 my_friendly_abort (0);
4654 /* Install the new binding. */
4655 push_local_binding (name
, new_binding
, flags
);
4661 /* Generate an implicit declaration for identifier FUNCTIONID
4662 as a function of type int (). Print a warning if appropriate. */
4665 implicitly_declare (functionid
)
4669 int temp
= allocation_temporary_p ();
4671 push_obstacks_nochange ();
4673 /* Save the decl permanently so we can warn if definition follows.
4674 In ANSI C, warn_implicit is usually false, so the saves little space.
4675 But in C++, it's usually true, hence the extra code. */
4676 if (temp
&& (! warn_implicit
|| toplevel_bindings_p ()))
4677 end_temporary_allocation ();
4679 /* We used to reuse an old implicit decl here,
4680 but this loses with inline functions because it can clobber
4681 the saved decl chains. */
4682 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4684 DECL_EXTERNAL (decl
) = 1;
4685 TREE_PUBLIC (decl
) = 1;
4687 /* ANSI standard says implicit declarations are in the innermost block.
4688 So we record the decl in the standard fashion. */
4690 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4693 /* Only one warning per identifier. */
4694 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4696 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4699 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4706 /* Return zero if the declaration NEWDECL is valid
4707 when the declaration OLDDECL (assumed to be for the same name)
4708 has already been seen.
4709 Otherwise return an error message format string with a %s
4710 where the identifier should go. */
4713 redeclaration_error_message (newdecl
, olddecl
)
4714 tree newdecl
, olddecl
;
4716 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4718 /* Because C++ can put things into name space for free,
4719 constructs like "typedef struct foo { ... } foo"
4720 would look like an erroneous redeclaration. */
4721 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
4724 return "redefinition of `%#D'";
4726 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4728 /* If this is a pure function, its olddecl will actually be
4729 the original initialization to `0' (which we force to call
4730 abort()). Don't complain about redefinition in this case. */
4731 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_ABSTRACT_VIRTUAL_P (olddecl
))
4734 /* If both functions come from different namespaces, this is not
4735 a redeclaration - this is a conflict with a used function. */
4736 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4737 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4738 return "`%D' conflicts with used function";
4740 /* We'll complain about linkage mismatches in
4741 warn_extern_redeclared_static. */
4743 /* Defining the same name twice is no good. */
4744 if (DECL_INITIAL (olddecl
) != NULL_TREE
4745 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4747 if (DECL_NAME (olddecl
) == NULL_TREE
)
4748 return "`%#D' not declared in class";
4750 return "redefinition of `%#D'";
4754 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4756 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4757 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4758 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4759 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4760 && TYPE_SIZE (TREE_TYPE (newdecl
))
4761 && TYPE_SIZE (TREE_TYPE (olddecl
))))
4762 return "redefinition of `%#D'";
4765 else if (toplevel_bindings_p ())
4767 /* Objects declared at top level: */
4768 /* If at least one is a reference, it's ok. */
4769 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4771 /* Reject two definitions. */
4772 return "redefinition of `%#D'";
4776 /* Objects declared with block scope: */
4777 /* Reject two definitions, and reject a definition
4778 together with an external reference. */
4779 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4780 return "redeclaration of `%#D'";
4785 /* Create a new label, named ID. */
4788 make_label_decl (id
, local_p
)
4794 if (building_stmt_tree ())
4795 push_permanent_obstack ();
4796 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4797 if (building_stmt_tree ())
4800 /* Make sure every label has an rtx. */
4803 DECL_CONTEXT (decl
) = current_function_decl
;
4804 DECL_MODE (decl
) = VOIDmode
;
4805 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
4807 /* Say where one reference is to the label, for the sake of the
4808 error if it is not defined. */
4809 DECL_SOURCE_LINE (decl
) = lineno
;
4810 DECL_SOURCE_FILE (decl
) = input_filename
;
4812 /* Record the fact that this identifier is bound to this label. */
4813 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4815 /* Record this label on the list of used labels so that we can check
4816 at the end of the function to see whether or not the label was
4817 actually defined. */
4818 if ((named_label_uses
== NULL
|| named_label_uses
->label_decl
!= decl
)
4819 && (named_label_uses
== NULL
4820 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4821 || named_label_uses
->label_decl
!= decl
))
4823 struct named_label_list
*new_ent
;
4825 = (struct named_label_list
*)oballoc (sizeof (struct named_label_list
));
4826 new_ent
->label_decl
= decl
;
4827 new_ent
->names_in_scope
= current_binding_level
->names
;
4828 new_ent
->binding_level
= current_binding_level
;
4829 new_ent
->lineno_o_goto
= lineno
;
4830 new_ent
->filename_o_goto
= input_filename
;
4831 new_ent
->next
= named_label_uses
;
4832 named_label_uses
= new_ent
;
4838 /* Look for a label named ID in the current function. If one cannot
4839 be found, create one. (We keep track of used, but undefined,
4840 labels, and complain about them at the end of a function.) */
4848 /* You can't use labels at global scope. */
4849 if (current_function_decl
== NULL_TREE
)
4851 error ("label `%s' referenced outside of any function",
4852 IDENTIFIER_POINTER (id
));
4856 /* See if we've already got this label. */
4857 decl
= IDENTIFIER_LABEL_VALUE (id
);
4858 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
4861 /* Record this label on the list of labels used in this function.
4862 We do this before calling make_label_decl so that we get the
4863 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4864 named_labels
= tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
4866 /* We need a new label. */
4867 decl
= make_label_decl (id
, /*local_p=*/0);
4868 /* Now fill in the information we didn't have before. */
4869 TREE_VALUE (named_labels
) = decl
;
4874 /* Declare a local label named ID. */
4877 declare_local_label (id
)
4882 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4883 this scope we can restore the old value of
4884 IDENTIFIER_TYPE_VALUE. */
4885 current_binding_level
->shadowed_labels
4886 = tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
4887 current_binding_level
->shadowed_labels
);
4888 /* Look for the label. */
4889 decl
= make_label_decl (id
, /*local_p=*/1);
4890 /* Now fill in the information we didn't have before. */
4891 TREE_VALUE (current_binding_level
->shadowed_labels
) = decl
;
4896 /* Define a label, specifying the location in the source file.
4897 Return the LABEL_DECL node for the label, if the definition is valid.
4898 Otherwise return 0. */
4901 define_label (filename
, line
, name
)
4906 tree decl
= lookup_label (name
);
4908 /* After labels, make any new cleanups go into their
4909 own new (temporary) binding contour. */
4910 current_binding_level
->more_cleanups_ok
= 0;
4912 if (name
== get_identifier ("wchar_t"))
4913 cp_pedwarn ("label named wchar_t");
4915 if (DECL_INITIAL (decl
) != NULL_TREE
)
4917 cp_error ("duplicate label `%D'", decl
);
4922 struct named_label_list
*uses
, *prev
;
4926 /* Mark label as having been defined. */
4927 DECL_INITIAL (decl
) = error_mark_node
;
4928 /* Say where in the source. */
4929 DECL_SOURCE_FILE (decl
) = filename
;
4930 DECL_SOURCE_LINE (decl
) = line
;
4933 uses
= named_label_uses
;
4934 while (uses
!= NULL
)
4935 if (uses
->label_decl
== decl
)
4937 struct binding_level
*b
= current_binding_level
;
4940 tree new_decls
= b
->names
;
4941 tree old_decls
= (b
== uses
->binding_level
)
4942 ? uses
->names_in_scope
: NULL_TREE
;
4943 while (new_decls
!= old_decls
)
4945 if (TREE_CODE (new_decls
) == VAR_DECL
4946 /* Don't complain about crossing initialization
4947 of internal entities. They can't be accessed,
4948 and they should be cleaned up
4949 by the time we get to the label. */
4950 && ! DECL_ARTIFICIAL (new_decls
)
4951 && !(DECL_INITIAL (new_decls
) == NULL_TREE
4952 && pod_type_p (TREE_TYPE (new_decls
))))
4954 /* This is really only important if we're crossing
4955 an initialization. The POD stuff is just
4956 pedantry; why should it matter if the class
4957 contains a field of pointer to member type? */
4958 int problem
= (DECL_INITIAL (new_decls
)
4959 || (TYPE_NEEDS_CONSTRUCTING
4960 (TREE_TYPE (new_decls
))));
4966 cp_error ("jump to label `%D'", decl
);
4967 error_with_file_and_line
4968 (uses
->filename_o_goto
,
4969 uses
->lineno_o_goto
, " from here");
4973 cp_pedwarn ("jump to label `%D'", decl
);
4974 pedwarn_with_file_and_line
4975 (uses
->filename_o_goto
,
4976 uses
->lineno_o_goto
, " from here");
4982 cp_error_at (" crosses initialization of `%#D'",
4985 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4988 new_decls
= TREE_CHAIN (new_decls
);
4990 if (b
== uses
->binding_level
)
4992 if (b
->eh_region
&& ! saw_eh
)
4996 cp_error ("jump to label `%D'", decl
);
4997 error_with_file_and_line
4998 (uses
->filename_o_goto
,
4999 uses
->lineno_o_goto
, " from here");
5002 error (" enters exception handling block");
5009 prev
->next
= uses
->next
;
5011 named_label_uses
= uses
->next
;
5020 current_function_return_value
= NULL_TREE
;
5027 struct binding_level
*level
;
5028 struct cp_switch
*next
;
5031 static struct cp_switch
*switch_stack
;
5037 = (struct cp_switch
*) oballoc (sizeof (struct cp_switch
));
5038 p
->level
= current_binding_level
;
5039 p
->next
= switch_stack
;
5046 switch_stack
= switch_stack
->next
;
5049 /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
5050 /* XXX Note decl is never actually used. (bpk) */
5053 define_case_label ()
5055 tree cleanup
= last_cleanup_this_contour ();
5056 struct binding_level
*b
= current_binding_level
;
5061 static int explained
= 0;
5062 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup
));
5063 warning ("where case label appears here");
5066 warning ("(enclose actions of previous case statements requiring");
5067 warning ("destructors in their own binding contours.)");
5072 for (; b
&& b
!= switch_stack
->level
; b
= b
->level_chain
)
5074 tree new_decls
= b
->names
;
5075 for (; new_decls
; new_decls
= TREE_CHAIN (new_decls
))
5077 if (TREE_CODE (new_decls
) == VAR_DECL
5078 /* Don't complain about crossing initialization
5079 of internal entities. They can't be accessed,
5080 and they should be cleaned up
5081 by the time we get to the label. */
5082 && ! DECL_ARTIFICIAL (new_decls
)
5083 && ((DECL_INITIAL (new_decls
) != NULL_TREE
5084 && DECL_INITIAL (new_decls
) != error_mark_node
)
5085 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
5088 error ("jump to case label");
5090 cp_error_at (" crosses initialization of `%#D'",
5096 /* After labels, make any new cleanups go into their
5097 own new (temporary) binding contour. */
5099 current_binding_level
->more_cleanups_ok
= 0;
5100 current_function_return_value
= NULL_TREE
;
5103 /* Return the list of declarations of the current level.
5104 Note that this list is in reverse order unless/until
5105 you nreverse it; and when you do nreverse it, you must
5106 store the result back using `storedecls' or you will lose. */
5111 return current_binding_level
->names
;
5114 /* Return the list of type-tags (for structs, etc) of the current level. */
5119 return current_binding_level
->tags
;
5122 /* Store the list of declarations of the current level.
5123 This is done for the parameter declarations of a function being defined,
5124 after they are modified in the light of any missing parameters. */
5130 current_binding_level
->names
= decls
;
5133 /* Similarly, store the list of tags of the current level. */
5139 current_binding_level
->tags
= tags
;
5142 /* Given NAME, an IDENTIFIER_NODE,
5143 return the structure (or union or enum) definition for that name.
5144 Searches binding levels from BINDING_LEVEL up to the global level.
5145 If THISLEVEL_ONLY is nonzero, searches only the specified context
5146 (but skips any tag-transparent contexts to find one that is
5147 meaningful for tags).
5148 FORM says which kind of type the caller wants;
5149 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5150 If the wrong kind of type is found, and it's not a template, an error is
5154 lookup_tag (form
, name
, binding_level
, thislevel_only
)
5155 enum tree_code form
;
5157 struct binding_level
*binding_level
;
5160 register struct binding_level
*level
;
5161 /* Non-zero if, we should look past a pseudo-global level, even if
5163 int allow_pseudo_global
= 1;
5165 for (level
= binding_level
; level
; level
= level
->level_chain
)
5168 if (ANON_AGGRNAME_P (name
))
5169 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5171 /* There's no need for error checking here, because
5172 anon names are unique throughout the compilation. */
5173 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
5174 return TREE_VALUE (tail
);
5176 else if (level
->namespace_p
)
5177 /* Do namespace lookup. */
5178 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
5180 tree old
= binding_for_name (name
, tail
);
5182 /* If we just skipped past a pseudo global level, even
5183 though THISLEVEL_ONLY, and we find a template class
5184 declaration, then we use the _TYPE node for the
5185 template. See the example below. */
5186 if (thislevel_only
&& !allow_pseudo_global
5187 && old
&& BINDING_VALUE (old
)
5188 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
5189 old
= TREE_TYPE (BINDING_VALUE (old
));
5191 old
= BINDING_TYPE (old
);
5193 /* If it has an original type, it is a typedef, and we
5194 should not return it. */
5195 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
5197 if (old
&& TREE_CODE (old
) != form
5198 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
5200 cp_error ("`%#D' redeclared as %C", old
, form
);
5205 if (thislevel_only
|| tail
== global_namespace
)
5209 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5211 if (TREE_PURPOSE (tail
) == name
)
5213 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
5214 /* Should tighten this up; it'll probably permit
5215 UNION_TYPE and a struct template, for example. */
5217 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
5219 /* Definition isn't the kind we were looking for. */
5220 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
5224 return TREE_VALUE (tail
);
5227 if (thislevel_only
&& ! level
->tag_transparent
)
5229 if (level
->pseudo_global
&& allow_pseudo_global
)
5231 /* We must deal with cases like this:
5233 template <class T> struct S;
5234 template <class T> struct S {};
5236 When looking up `S', for the second declaration, we
5237 would like to find the first declaration. But, we
5238 are in the pseudo-global level created for the
5239 template parameters, rather than the (surrounding)
5240 namespace level. Thus, we keep going one more level,
5241 even though THISLEVEL_ONLY is non-zero. */
5242 allow_pseudo_global
= 0;
5254 set_current_level_tags_transparency (tags_transparent
)
5255 int tags_transparent
;
5257 current_binding_level
->tag_transparent
= tags_transparent
;
5261 /* Given a type, find the tag that was defined for it and return the tag name.
5262 Otherwise return 0. However, the value can never be 0
5263 in the cases in which this is used.
5265 C++: If NAME is non-zero, this is the new name to install. This is
5266 done when replacing anonymous tags with real tag names. */
5269 lookup_tag_reverse (type
, name
)
5273 register struct binding_level
*level
;
5275 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
5278 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5280 if (TREE_VALUE (tail
) == type
)
5283 TREE_PURPOSE (tail
) = name
;
5284 return TREE_PURPOSE (tail
);
5291 /* Look up NAME in the NAMESPACE. */
5294 lookup_namespace_name (namespace, name
)
5295 tree
namespace, name
;
5297 struct tree_binding _b
;
5299 tree template_id
= NULL_TREE
;
5301 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
5303 if (TREE_CODE (name
) == NAMESPACE_DECL
)
5304 /* This happens for A::B<int> when B is a namespace. */
5306 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
5308 /* This happens for A::B where B is a template, and there are no
5309 template arguments. */
5310 cp_error ("invalid use of `%D'", name
);
5311 return error_mark_node
;
5314 namespace = ORIGINAL_NAMESPACE (namespace);
5316 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5319 name
= TREE_OPERAND (name
, 0);
5320 if (TREE_CODE (name
) == OVERLOAD
)
5321 name
= DECL_NAME (OVL_CURRENT (name
));
5322 else if (TREE_CODE_CLASS (TREE_CODE (name
)) == 'd')
5323 name
= DECL_NAME (name
);
5326 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
5328 val
= binding_init (&_b
);
5329 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
5330 return error_mark_node
;
5332 if (BINDING_VALUE (val
))
5334 val
= BINDING_VALUE (val
);
5338 if (DECL_CLASS_TEMPLATE_P (val
))
5339 val
= lookup_template_class (val
,
5340 TREE_OPERAND (template_id
, 1),
5341 /*in_decl=*/NULL_TREE
,
5342 /*context=*/NULL_TREE
,
5343 /*entering_scope=*/0);
5344 else if (DECL_FUNCTION_TEMPLATE_P (val
)
5345 || TREE_CODE (val
) == OVERLOAD
)
5346 val
= lookup_template_function (val
,
5347 TREE_OPERAND (template_id
, 1));
5350 cp_error ("`%D::%D' is not a template",
5352 return error_mark_node
;
5356 /* If we have a single function from a using decl, pull it out. */
5357 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5358 val
= OVL_FUNCTION (val
);
5362 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
5363 return error_mark_node
;
5366 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5368 static unsigned long
5376 hash
= (((unsigned long) TYPE_CONTEXT (t
))
5377 ^ ((unsigned long) DECL_NAME (TYPE_NAME (t
))));
5382 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5385 typename_compare (k1
, k2
)
5396 d1
= TYPE_NAME (t1
);
5397 d2
= TYPE_NAME (t2
);
5399 return (DECL_NAME (d1
) == DECL_NAME (d2
)
5400 && same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
))
5401 && ((TREE_TYPE (t1
) != NULL_TREE
)
5402 == (TREE_TYPE (t2
) != NULL_TREE
))
5403 && same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
5404 && TYPENAME_TYPE_FULLNAME (t1
) == TYPENAME_TYPE_FULLNAME (t2
));
5407 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5408 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5409 is non-NULL, this type is being created by the implicit typename
5410 extension, and BASE_TYPE is a type named `t' in some base class of
5411 `T' which depends on template parameters.
5413 Returns the new TYPENAME_TYPE. */
5416 build_typename_type (context
, name
, fullname
, base_type
)
5424 struct hash_entry
* e
;
5426 static struct hash_table ht
;
5428 push_obstacks (&permanent_obstack
, &permanent_obstack
);
5431 && !hash_table_init (&ht
, &hash_newfunc
, &typename_hash
,
5433 fatal ("virtual memory exhausted");
5435 /* The FULLNAME needs to exist for the life of the hash table, i.e.,
5436 for the entire compilation. */
5437 if (!TREE_PERMANENT (fullname
))
5438 fullname
= copy_to_permanent (fullname
);
5440 /* Build the TYPENAME_TYPE. */
5441 t
= make_lang_type (TYPENAME_TYPE
);
5442 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5443 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
5444 TREE_TYPE (t
) = base_type
;
5446 /* Build the corresponding TYPE_DECL. */
5447 d
= build_decl (TYPE_DECL
, name
, t
);
5448 TYPE_NAME (TREE_TYPE (d
)) = d
;
5449 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
5450 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
5451 DECL_ARTIFICIAL (d
) = 1;
5453 /* See if we already have this type. */
5454 e
= hash_lookup (&ht
, t
, /*create=*/false, /*copy=*/0);
5457 /* This will free not only TREE_TYPE, but the lang-specific data
5458 and the TYPE_DECL as well. */
5459 obstack_free (&permanent_obstack
, t
);
5463 /* Insert the type into the table. */
5464 hash_lookup (&ht
, t
, /*create=*/true, /*copy=*/0);
5472 make_typename_type (context
, name
)
5477 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
5479 if (!(TYPE_LANG_SPECIFIC (name
)
5480 && (CLASSTYPE_IS_TEMPLATE (name
)
5481 || CLASSTYPE_USE_TEMPLATE (name
))))
5482 name
= TYPE_IDENTIFIER (name
);
5484 /* Create a TEMPLATE_ID_EXPR for the type. */
5485 name
= build_nt (TEMPLATE_ID_EXPR
,
5486 CLASSTYPE_TI_TEMPLATE (name
),
5487 CLASSTYPE_TI_ARGS (name
));
5489 else if (TREE_CODE (name
) == TYPE_DECL
)
5490 name
= DECL_NAME (name
);
5494 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5496 name
= TREE_OPERAND (name
, 0);
5497 if (TREE_CODE (name
) == TEMPLATE_DECL
)
5498 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
5500 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
5501 my_friendly_abort (2000);
5503 if (TREE_CODE (context
) == NAMESPACE_DECL
)
5505 /* We can get here from typename_sub0 in the explicit_template_type
5506 expansion. Just fail. */
5507 cp_error ("no class template named `%#T' in `%#T'",
5509 return error_mark_node
;
5512 if (! uses_template_parms (context
)
5513 || currently_open_class (context
))
5515 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
5517 tree tmpl
= NULL_TREE
;
5518 if (IS_AGGR_TYPE (context
))
5519 tmpl
= lookup_field (context
, name
, 0, 0);
5520 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
5522 cp_error ("no class template named `%#T' in `%#T'",
5524 return error_mark_node
;
5527 return lookup_template_class (tmpl
,
5528 TREE_OPERAND (fullname
, 1),
5530 /*entering_scope=*/0);
5536 if (!IS_AGGR_TYPE (context
))
5538 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5539 return error_mark_node
;
5542 t
= lookup_field (context
, name
, 0, 1);
5544 return TREE_TYPE (t
);
5548 /* If the CONTEXT is not a template type, then either the field is
5549 there now or its never going to be. */
5550 if (!uses_template_parms (context
))
5552 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5553 return error_mark_node
;
5557 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
5560 /* Select the right _DECL from multiple choices. */
5563 select_decl (binding
, flags
)
5568 val
= BINDING_VALUE (binding
);
5569 if (LOOKUP_NAMESPACES_ONLY (flags
))
5571 /* We are not interested in types. */
5572 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
5577 /* If we could have a type and
5578 we have nothing or we need a type and have none. */
5579 if (BINDING_TYPE (binding
)
5580 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
5581 && TREE_CODE (val
) != TYPE_DECL
)))
5582 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
5583 /* Don't return non-types if we really prefer types. */
5584 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
5585 && (TREE_CODE (val
) != TEMPLATE_DECL
5586 || !DECL_CLASS_TEMPLATE_P (val
)))
5592 /* Unscoped lookup of a global: iterate over current namespaces,
5593 considering using-directives. If SPACESP is non-NULL, store a list
5594 of the namespaces we've considered in it. */
5597 unqualified_namespace_lookup (name
, flags
, spacesp
)
5602 struct tree_binding _binding
;
5603 tree b
= binding_init (&_binding
);
5604 tree initial
= current_decl_namespace();
5605 tree scope
= initial
;
5607 struct binding_level
*level
;
5608 tree val
= NULL_TREE
;
5611 *spacesp
= NULL_TREE
;
5613 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
5616 *spacesp
= scratch_tree_cons (scope
, NULL_TREE
, *spacesp
);
5617 val
= binding_for_name (name
, scope
);
5619 /* Initialize binding for this context. */
5620 BINDING_VALUE (b
) = BINDING_VALUE (val
);
5621 BINDING_TYPE (b
) = BINDING_TYPE (val
);
5623 /* Add all _DECLs seen through local using-directives. */
5624 for (level
= current_binding_level
;
5625 !level
->namespace_p
;
5626 level
= level
->level_chain
)
5627 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
5628 scope
, flags
, spacesp
))
5629 /* Give up because of error. */
5630 return error_mark_node
;
5632 /* Add all _DECLs seen through global using-directives. */
5633 /* XXX local and global using lists should work equally. */
5637 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
5638 scope
, flags
, spacesp
))
5639 /* Give up because of error. */
5640 return error_mark_node
;
5641 if (siter
== scope
) break;
5642 siter
= CP_DECL_CONTEXT (siter
);
5645 val
= select_decl (b
, flags
);
5646 if (scope
== global_namespace
)
5652 /* Combine prefer_type and namespaces_only into flags. */
5655 lookup_flags (prefer_type
, namespaces_only
)
5656 int prefer_type
, namespaces_only
;
5658 if (namespaces_only
)
5659 return LOOKUP_PREFER_NAMESPACES
;
5660 if (prefer_type
> 1)
5661 return LOOKUP_PREFER_TYPES
;
5662 if (prefer_type
> 0)
5663 return LOOKUP_PREFER_BOTH
;
5667 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5668 ignore it or not. Subroutine of lookup_name_real. */
5671 qualify_lookup (val
, flags
)
5675 if (val
== NULL_TREE
)
5677 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5679 if ((flags
& LOOKUP_PREFER_TYPES
)
5680 && (TREE_CODE (val
) == TYPE_DECL
5681 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5682 && DECL_CLASS_TEMPLATE_P (val
))))
5684 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5689 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5693 warn_about_implicit_typename_lookup (typename
, binding
)
5697 tree subtype
= TREE_TYPE (TREE_TYPE (typename
));
5698 tree name
= DECL_NAME (typename
);
5700 if (! (TREE_CODE (binding
) == TEMPLATE_DECL
5701 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5702 && CLASSTYPE_TI_TEMPLATE (subtype
) == binding
)
5703 && ! (TREE_CODE (binding
) == TYPE_DECL
5704 && same_type_p (TREE_TYPE (binding
), subtype
)))
5706 cp_warning ("lookup of `%D' finds `%#D'",
5708 cp_warning (" instead of `%D' from dependent base class",
5710 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5711 constructor_name (current_class_type
), name
);
5715 /* Look up NAME in the current binding level and its superiors in the
5716 namespace of variables, functions and typedefs. Return a ..._DECL
5717 node of some kind representing its definition if there is only one
5718 such declaration, or return a TREE_LIST with all the overloaded
5719 definitions if there are many, or return 0 if it is undefined.
5721 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5722 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5723 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5724 Otherwise we prefer non-TYPE_DECLs.
5726 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5727 using IDENTIFIER_CLASS_VALUE. */
5730 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5732 int prefer_type
, nonclass
, namespaces_only
;
5735 tree val
= NULL_TREE
;
5737 tree from_obj
= NULL_TREE
;
5739 int val_is_implicit_typename
= 0;
5741 /* Hack: copy flag set by parser, if set. */
5742 if (only_namespace_names
)
5743 namespaces_only
= 1;
5745 if (prefer_type
== -2)
5747 extern int looking_for_typename
;
5748 tree type
= NULL_TREE
;
5751 prefer_type
= looking_for_typename
;
5753 flags
= lookup_flags (prefer_type
, namespaces_only
);
5754 /* If the next thing is '<', class templates are types. */
5755 if (looking_for_template
)
5756 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5758 /* std:: becomes :: for now. */
5759 if (got_scope
== std_node
)
5760 got_scope
= void_type_node
;
5764 else if (got_object
!= error_mark_node
)
5769 if (type
== error_mark_node
)
5770 return error_mark_node
;
5771 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5772 type
= TREE_TYPE (type
);
5775 type
= complete_type (type
);
5777 if (TREE_CODE (type
) == VOID_TYPE
)
5778 type
= global_namespace
;
5779 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5781 struct tree_binding b
;
5782 val
= binding_init (&b
);
5783 flags
|= LOOKUP_COMPLAIN
;
5784 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5786 val
= select_decl (val
, flags
);
5788 else if (! IS_AGGR_TYPE (type
)
5789 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5790 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
5791 || TREE_CODE (type
) == TYPENAME_TYPE
)
5792 /* Someone else will give an error about this if needed. */
5794 else if (type
== current_class_type
)
5795 val
= IDENTIFIER_CLASS_VALUE (name
);
5797 val
= lookup_member (type
, name
, 0, prefer_type
);
5804 else if (got_object
&& val
)
5809 flags
= lookup_flags (prefer_type
, namespaces_only
);
5810 /* If we're not parsing, we need to complain. */
5811 flags
|= LOOKUP_COMPLAIN
;
5814 /* First, look in non-namespace scopes. */
5816 if (current_class_type
== NULL_TREE
)
5819 for (t
= IDENTIFIER_BINDING (name
); t
; t
= TREE_CHAIN (t
))
5823 if (!LOCAL_BINDING_P (t
) && nonclass
)
5824 /* We're not looking for class-scoped bindings, so keep going. */
5827 /* If this is the kind of thing we're looking for, we're done. */
5828 if (qualify_lookup (BINDING_VALUE (t
), flags
))
5829 binding
= BINDING_VALUE (t
);
5830 else if ((flags
& LOOKUP_PREFER_TYPES
)
5831 && qualify_lookup (BINDING_TYPE (t
), flags
))
5832 binding
= BINDING_TYPE (t
);
5834 binding
= NULL_TREE
;
5837 && (!val
|| !IMPLICIT_TYPENAME_TYPE_DECL_P (binding
)))
5839 if (val_is_implicit_typename
&& !yylex
)
5840 warn_about_implicit_typename_lookup (val
, binding
);
5842 val_is_implicit_typename
5843 = IMPLICIT_TYPENAME_TYPE_DECL_P (val
);
5844 if (!val_is_implicit_typename
)
5849 /* Now lookup in namespace scopes. */
5850 if (!val
|| val_is_implicit_typename
)
5852 t
= unqualified_namespace_lookup (name
, flags
, 0);
5855 if (val_is_implicit_typename
&& !yylex
)
5856 warn_about_implicit_typename_lookup (val
, t
);
5864 /* This should only warn about types used in qualified-ids. */
5865 if (from_obj
&& from_obj
!= val
)
5867 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
5868 && TREE_CODE (val
) == TYPE_DECL
5869 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
5871 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5872 name
, got_object
, TREE_TYPE (from_obj
));
5873 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5877 /* We don't change val to from_obj if got_object depends on
5878 template parms because that breaks implicit typename for
5879 destructor calls. */
5880 if (! uses_template_parms (got_object
))
5884 /* If we have a single function from a using decl, pull it out. */
5885 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5886 val
= OVL_FUNCTION (val
);
5895 lookup_name_nonclass (name
)
5898 return lookup_name_real (name
, 0, 1, 0);
5902 lookup_function_nonclass (name
, args
)
5906 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
5910 lookup_name_namespace_only (name
)
5913 /* type-or-namespace, nonclass, namespace_only */
5914 return lookup_name_real (name
, 1, 1, 1);
5918 lookup_name (name
, prefer_type
)
5922 return lookup_name_real (name
, prefer_type
, 0, 0);
5925 /* Similar to `lookup_name' but look only in the innermost non-class
5929 lookup_name_current_level (name
)
5932 struct binding_level
*b
;
5935 b
= current_binding_level
;
5936 while (b
->parm_flag
== 2)
5941 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5943 /* extern "C" function() */
5944 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5947 else if (IDENTIFIER_BINDING (name
)
5948 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
5952 if (BINDING_LEVEL (IDENTIFIER_BINDING (name
)) == b
)
5953 return IDENTIFIER_VALUE (name
);
5965 /* Like lookup_name_current_level, but for types. */
5968 lookup_type_current_level (name
)
5971 register tree t
= NULL_TREE
;
5973 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
5975 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5976 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5978 struct binding_level
*b
= current_binding_level
;
5981 if (purpose_member (name
, b
->type_shadowed
))
5982 return REAL_IDENTIFIER_TYPE_VALUE (name
);
5994 begin_only_namespace_names ()
5996 only_namespace_names
= 1;
6000 end_only_namespace_names ()
6002 only_namespace_names
= 0;
6005 /* Arrange for the user to get a source line number, even when the
6006 compiler is going down in flames, so that she at least has a
6007 chance of working around problems in the compiler. We used to
6008 call error(), but that let the segmentation fault continue
6009 through; now, it's much more passive by asking them to send the
6010 maintainers mail about the problem. */
6014 int sig ATTRIBUTE_UNUSED
;
6016 signal (SIGSEGV
, SIG_DFL
);
6018 signal (SIGIOT
, SIG_DFL
);
6021 signal (SIGILL
, SIG_DFL
);
6024 signal (SIGABRT
, SIG_DFL
);
6027 signal (SIGBUS
, SIG_DFL
);
6029 my_friendly_abort (0);
6033 /* Unused -- brendan 970107 */
6034 /* Array for holding types considered "built-in". These types
6035 are output in the module in which `main' is defined. */
6036 static tree
*builtin_type_tdescs_arr
;
6037 static int builtin_type_tdescs_len
, builtin_type_tdescs_max
;
6040 /* Push the declarations of builtin types into the namespace.
6041 RID_INDEX, if < RID_MAX is the index of the builtin type
6042 in the array RID_POINTERS. NAME is the name used when looking
6043 up the builtin type. TYPE is the _TYPE node for the builtin type. */
6046 record_builtin_type (rid_index
, name
, type
)
6051 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
6052 tree tdecl
= NULL_TREE
;
6054 if ((int) rid_index
< (int) RID_MAX
)
6055 rname
= ridpointers
[(int) rid_index
];
6057 tname
= get_identifier (name
);
6059 TYPE_BUILT_IN (type
) = 1;
6063 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
6064 set_identifier_type_value (tname
, NULL_TREE
);
6065 if ((int) rid_index
< (int) RID_MAX
)
6066 /* Built-in types live in the global namespace. */
6067 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
6069 if (rname
!= NULL_TREE
)
6071 if (tname
!= NULL_TREE
)
6073 set_identifier_type_value (rname
, NULL_TREE
);
6074 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
6078 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
6079 set_identifier_type_value (rname
, NULL_TREE
);
6084 /* Record one of the standard Java types.
6085 * Declare it as having the given NAME.
6086 * If SIZE > 0, it is the size of one of the integral types;
6087 * otherwise it is the negative of the size of one of the other types. */
6090 record_builtin_java_type (name
, size
)
6096 type
= make_signed_type (size
);
6097 else if (size
> -32)
6098 { /* "__java_char" or ""__java_boolean". */
6099 type
= make_unsigned_type (-size
);
6100 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6103 { /* "__java_float" or ""__java_double". */
6104 type
= make_node (REAL_TYPE
);
6105 TYPE_PRECISION (type
) = - size
;
6108 record_builtin_type (RID_MAX
, name
, type
);
6109 decl
= TYPE_NAME (type
);
6111 /* Suppress generate debug symbol entries for these types,
6112 since for normal C++ they are just clutter.
6113 However, push_lang_context undoes this if extern "Java" is seen. */
6114 DECL_IGNORED_P (decl
) = 1;
6116 TYPE_FOR_JAVA (type
) = 1;
6120 /* Push a type into the namespace so that the back-ends ignore it. */
6123 record_unknown_type (type
, name
)
6127 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
6128 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
6129 DECL_IGNORED_P (decl
) = 1;
6130 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6131 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
6132 TYPE_ALIGN (type
) = 1;
6133 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
6136 /* Push overloaded decl, in global scope, with one argument so it
6137 can be used as a callback from define_function. */
6140 push_overloaded_decl_1 (x
)
6143 push_overloaded_decl (x
, PUSH_GLOBAL
);
6150 auto_function (name
, type
, code
)
6152 enum built_in_function code
;
6154 return define_function
6155 (IDENTIFIER_POINTER (name
), type
, code
, push_overloaded_decl_1
,
6156 IDENTIFIER_POINTER (build_decl_overload (name
, TYPE_ARG_TYPES (type
),
6160 /* Create the predefined scalar types of C,
6161 and some nodes representing standard constants (0, 1, (void *)0).
6162 Initialize the global binding level.
6163 Make definitions for built-in primitive functions. */
6166 init_decl_processing ()
6169 int wchar_type_size
;
6170 tree array_domain_type
;
6172 /* Have to make these distinct before we try using them. */
6173 lang_name_cplusplus
= get_identifier ("C++");
6174 lang_name_c
= get_identifier ("C");
6175 lang_name_java
= get_identifier ("Java");
6177 /* Let the back-end now how to save and restore language-specific
6178 per-function globals. */
6179 save_lang_status
= &push_cp_function_context
;
6180 restore_lang_status
= &pop_cp_function_context
;
6182 /* Create the global per-function variables. */
6183 push_function_context_to (NULL_TREE
);
6185 /* Enter the global namespace. */
6186 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
6187 my_friendly_assert (current_lang_name
== NULL_TREE
, 375);
6188 current_lang_name
= lang_name_cplusplus
;
6189 push_namespace (get_identifier ("::"));
6190 global_namespace
= current_namespace
;
6191 current_lang_name
= NULL_TREE
;
6193 if (flag_strict_prototype
== 2)
6194 flag_strict_prototype
= pedantic
;
6195 if (! flag_permissive
&& ! pedantic
)
6196 flag_pedantic_errors
= 1;
6198 strict_prototypes_lang_c
= flag_strict_prototype
;
6201 current_lang_name
= lang_name_c
;
6203 current_function_decl
= NULL_TREE
;
6204 named_labels
= NULL_TREE
;
6205 named_label_uses
= NULL
;
6206 current_binding_level
= NULL_BINDING_LEVEL
;
6207 free_binding_level
= NULL_BINDING_LEVEL
;
6209 /* Because most segmentation signals can be traced back into user
6210 code, catch them and at least give the user a chance of working
6211 around compiler bugs. */
6212 signal (SIGSEGV
, signal_catch
);
6214 /* We will also catch aborts in the back-end through signal_catch and
6215 give the user a chance to see where the error might be, and to defeat
6216 aborts in the back-end when there have been errors previously in their
6219 signal (SIGIOT
, signal_catch
);
6222 signal (SIGILL
, signal_catch
);
6225 signal (SIGABRT
, signal_catch
);
6228 signal (SIGBUS
, signal_catch
);
6231 gcc_obstack_init (&decl_obstack
);
6233 /* Must lay these out before anything else gets laid out. */
6234 error_mark_node
= make_node (ERROR_MARK
);
6235 TREE_PERMANENT (error_mark_node
) = 1;
6236 TREE_TYPE (error_mark_node
) = error_mark_node
;
6237 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
6238 TREE_TYPE (error_mark_list
) = error_mark_node
;
6240 /* Make the binding_level structure for global names. */
6242 global_binding_level
= current_binding_level
;
6243 /* The global level is the namespace level of ::. */
6244 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
6245 declare_namespace_level ();
6247 this_identifier
= get_identifier (THIS_NAME
);
6248 in_charge_identifier
= get_identifier (IN_CHARGE_NAME
);
6249 ctor_identifier
= get_identifier (CTOR_NAME
);
6250 dtor_identifier
= get_identifier (DTOR_NAME
);
6251 pfn_identifier
= get_identifier (VTABLE_PFN_NAME
);
6252 index_identifier
= get_identifier (VTABLE_INDEX_NAME
);
6253 delta_identifier
= get_identifier (VTABLE_DELTA_NAME
);
6254 delta2_identifier
= get_identifier (VTABLE_DELTA2_NAME
);
6255 pfn_or_delta2_identifier
= get_identifier ("__pfn_or_delta2");
6257 /* Define `int' and `char' first so that dbx will output them first. */
6259 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
6260 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
6262 /* Define `char', which is like either `signed char' or `unsigned char'
6263 but not the same as either. */
6267 ? make_signed_type (CHAR_TYPE_SIZE
)
6268 : make_unsigned_type (CHAR_TYPE_SIZE
));
6269 record_builtin_type (RID_CHAR
, "char", char_type_node
);
6271 /* `signed' is the same as `int' */
6272 record_builtin_type (RID_SIGNED
, NULL_PTR
, integer_type_node
);
6274 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
6275 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
6277 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
6278 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
6280 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
6281 record_builtin_type (RID_MAX
, "long unsigned int", long_unsigned_type_node
);
6282 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
6284 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
6285 record_builtin_type (RID_MAX
, "long long int", long_long_integer_type_node
);
6287 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
6288 record_builtin_type (RID_MAX
, "long long unsigned int",
6289 long_long_unsigned_type_node
);
6290 record_builtin_type (RID_MAX
, "long long unsigned",
6291 long_long_unsigned_type_node
);
6293 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
6294 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
6295 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
6296 record_builtin_type (RID_MAX
, "short unsigned int", short_unsigned_type_node
);
6297 record_builtin_type (RID_MAX
, "unsigned short", short_unsigned_type_node
);
6299 /* `unsigned long' is the standard type for sizeof.
6300 Note that stddef.h uses `unsigned long',
6301 and this must agree, even if long and int are the same size. */
6303 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
6306 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
6308 /* Define both `signed char' and `unsigned char'. */
6309 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
6310 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
6311 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
6312 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
6314 /* Create the widest literal types. */
6315 widest_integer_literal_type_node
= make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
6316 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6317 widest_integer_literal_type_node
));
6319 widest_unsigned_literal_type_node
= make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
6320 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6321 widest_unsigned_literal_type_node
));
6323 /* These are types that type_for_size and type_for_mode use. */
6324 intQI_type_node
= make_signed_type (GET_MODE_BITSIZE (QImode
));
6325 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
6326 intHI_type_node
= make_signed_type (GET_MODE_BITSIZE (HImode
));
6327 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
6328 intSI_type_node
= make_signed_type (GET_MODE_BITSIZE (SImode
));
6329 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
6330 intDI_type_node
= make_signed_type (GET_MODE_BITSIZE (DImode
));
6331 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
6332 #if HOST_BITS_PER_WIDE_INT >= 64
6333 intTI_type_node
= make_signed_type (GET_MODE_BITSIZE (TImode
));
6334 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
6336 unsigned_intQI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (QImode
));
6337 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
6338 unsigned_intHI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (HImode
));
6339 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
6340 unsigned_intSI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (SImode
));
6341 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
6342 unsigned_intDI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (DImode
));
6343 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
6344 #if HOST_BITS_PER_WIDE_INT >= 64
6345 unsigned_intTI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (TImode
));
6346 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
6349 float_type_node
= make_node (REAL_TYPE
);
6350 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
6351 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
6352 layout_type (float_type_node
);
6354 double_type_node
= make_node (REAL_TYPE
);
6355 if (flag_short_double
)
6356 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
6358 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
6359 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
6360 layout_type (double_type_node
);
6362 long_double_type_node
= make_node (REAL_TYPE
);
6363 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
6364 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
6365 layout_type (long_double_type_node
);
6367 complex_integer_type_node
= make_node (COMPLEX_TYPE
);
6368 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
6369 complex_integer_type_node
));
6370 TREE_TYPE (complex_integer_type_node
) = integer_type_node
;
6371 layout_type (complex_integer_type_node
);
6373 complex_float_type_node
= make_node (COMPLEX_TYPE
);
6374 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
6375 complex_float_type_node
));
6376 TREE_TYPE (complex_float_type_node
) = float_type_node
;
6377 layout_type (complex_float_type_node
);
6379 complex_double_type_node
= make_node (COMPLEX_TYPE
);
6380 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
6381 complex_double_type_node
));
6382 TREE_TYPE (complex_double_type_node
) = double_type_node
;
6383 layout_type (complex_double_type_node
);
6385 complex_long_double_type_node
= make_node (COMPLEX_TYPE
);
6386 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
6387 complex_long_double_type_node
));
6388 TREE_TYPE (complex_long_double_type_node
) = long_double_type_node
;
6389 layout_type (complex_long_double_type_node
);
6391 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
6392 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
6393 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
6394 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
6395 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
6396 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
6397 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
6398 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
6400 integer_zero_node
= build_int_2 (0, 0);
6401 TREE_TYPE (integer_zero_node
) = integer_type_node
;
6402 integer_one_node
= build_int_2 (1, 0);
6403 TREE_TYPE (integer_one_node
) = integer_type_node
;
6404 integer_two_node
= build_int_2 (2, 0);
6405 TREE_TYPE (integer_two_node
) = integer_type_node
;
6406 integer_three_node
= build_int_2 (3, 0);
6407 TREE_TYPE (integer_three_node
) = integer_type_node
;
6409 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
6410 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
6411 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
6412 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
6413 TYPE_PRECISION (boolean_type_node
) = 1;
6414 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
6415 boolean_false_node
= build_int_2 (0, 0);
6416 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
6417 boolean_true_node
= build_int_2 (1, 0);
6418 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
6420 /* These are needed by stor-layout.c. */
6421 size_zero_node
= size_int (0);
6422 size_one_node
= size_int (1);
6424 signed_size_zero_node
= build_int_2 (0, 0);
6425 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
6427 void_type_node
= make_node (VOID_TYPE
);
6428 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
6429 layout_type (void_type_node
); /* Uses integer_zero_node. */
6430 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
6431 TREE_PARMLIST (void_list_node
) = 1;
6433 null_pointer_node
= build_int_2 (0, 0);
6434 TREE_TYPE (null_pointer_node
) = build_pointer_type (void_type_node
);
6435 layout_type (TREE_TYPE (null_pointer_node
));
6437 /* Used for expressions that do nothing, but are not errors. */
6438 void_zero_node
= build_int_2 (0, 0);
6439 TREE_TYPE (void_zero_node
) = void_type_node
;
6441 string_type_node
= build_pointer_type (char_type_node
);
6442 const_string_type_node
6443 = build_pointer_type (build_qualified_type (char_type_node
,
6445 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
6447 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
6450 /* Make a type to be the domain of a few array types
6451 whose domains don't really matter.
6452 200 is small enough that it always fits in size_t
6453 and large enough that it can hold most function names for the
6454 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
6455 array_domain_type
= build_index_type (build_int_2 (200, 0));
6457 /* Make a type for arrays of characters.
6458 With luck nothing will ever really depend on the length of this
6460 char_array_type_node
6461 = build_array_type (char_type_node
, array_domain_type
);
6462 /* Likewise for arrays of ints. */
6464 = build_array_type (integer_type_node
, array_domain_type
);
6466 /* This is just some anonymous class type. Nobody should ever
6467 need to look inside this envelope. */
6468 class_star_type_node
= build_pointer_type (make_lang_type (RECORD_TYPE
));
6470 if (flag_huge_objects
)
6471 delta_type_node
= long_integer_type_node
;
6473 delta_type_node
= short_integer_type_node
;
6475 default_function_type
6476 = build_function_type (integer_type_node
, NULL_TREE
);
6478 ptr_type_node
= build_pointer_type (void_type_node
);
6480 = build_pointer_type (build_qualified_type (void_type_node
,
6482 c_common_nodes_and_builtins (1, flag_no_builtin
, flag_no_nonansi_builtin
);
6485 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6487 /* C++ extensions */
6489 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6490 record_unknown_type (unknown_type_node
, "unknown type");
6492 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6493 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6495 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6497 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6499 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6500 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6502 /* This is special for C++ so functions can be overloaded. */
6504 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE
)));
6505 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6506 signed_wchar_type_node
= make_signed_type (wchar_type_size
);
6507 unsigned_wchar_type_node
= make_unsigned_type (wchar_type_size
);
6509 = TREE_UNSIGNED (wchar_type_node
)
6510 ? unsigned_wchar_type_node
6511 : signed_wchar_type_node
;
6512 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6514 /* Artificial declaration of wchar_t -- can be bashed */
6515 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6517 pushdecl (wchar_decl_node
);
6519 /* This is for wide string constants. */
6520 wchar_array_type_node
6521 = build_array_type (wchar_type_node
, array_domain_type
);
6523 if (flag_vtable_thunks
)
6525 /* Make sure we get a unique function type, so we can give
6526 its pointer type a name. (This wins for gdb.) */
6527 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6528 TREE_TYPE (vfunc_type
) = integer_type_node
;
6529 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6530 layout_type (vfunc_type
);
6532 vtable_entry_type
= build_pointer_type (vfunc_type
);
6536 vtable_entry_type
= make_lang_type (RECORD_TYPE
);
6537 fields
[0] = build_lang_decl (FIELD_DECL
, delta_identifier
,
6539 fields
[1] = build_lang_decl (FIELD_DECL
, index_identifier
,
6541 fields
[2] = build_lang_decl (FIELD_DECL
, pfn_identifier
,
6543 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6546 /* Make this part of an invisible union. */
6547 fields
[3] = copy_node (fields
[2]);
6548 TREE_TYPE (fields
[3]) = delta_type_node
;
6549 DECL_NAME (fields
[3]) = delta2_identifier
;
6550 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6551 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6552 TREE_UNSIGNED (fields
[3]) = 0;
6553 TREE_CHAIN (fields
[2]) = fields
[3];
6554 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6557 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6560 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
6561 layout_type (vtbl_type_node
);
6562 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6563 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6564 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6565 layout_type (vtbl_ptr_type_node
);
6566 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6568 std_node
= build_decl (NAMESPACE_DECL
,
6569 get_identifier (flag_honor_std
? "fake std":"std"),
6571 pushdecl (std_node
);
6573 global_type_node
= make_node (LANG_TYPE
);
6574 record_unknown_type (global_type_node
, "global type");
6577 current_lang_name
= lang_name_cplusplus
;
6580 tree bad_alloc_type_node
, newtype
, deltype
;
6582 push_namespace (get_identifier ("std"));
6583 bad_alloc_type_node
= xref_tag
6584 (class_type_node
, get_identifier ("bad_alloc"), 1);
6587 newtype
= build_exception_variant
6588 (ptr_ftype_sizetype
, add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1));
6589 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6590 auto_function (ansi_opname
[(int) NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6591 auto_function (ansi_opname
[(int) VEC_NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6592 global_delete_fndecl
6593 = auto_function (ansi_opname
[(int) DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6594 auto_function (ansi_opname
[(int) VEC_DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6598 = define_function ("__pure_virtual", void_ftype
,
6599 NOT_BUILT_IN
, 0, 0);
6601 /* Perform other language dependent initializations. */
6602 init_class_processing ();
6603 init_init_processing ();
6604 init_search_processing ();
6606 init_rtti_processing ();
6608 if (flag_exceptions
)
6609 init_exception_processing ();
6612 flag_inline_functions
= 0;
6615 if (! supports_one_only ())
6618 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6619 declare_function_name ();
6621 /* Prepare to check format strings against argument lists. */
6622 init_function_format_info ();
6624 /* Show we use EH for cleanups. */
6625 using_eh_for_cleanups ();
6627 print_error_function
= lang_print_error_function
;
6628 lang_get_alias_set
= &c_get_alias_set
;
6629 valid_lang_attribute
= cp_valid_lang_attribute
;
6631 /* Maintain consistency. Perhaps we should just complain if they
6632 say -fwritable-strings? */
6633 if (flag_writable_strings
)
6634 flag_const_strings
= 0;
6637 /* Function to print any language-specific context for an error message. */
6640 lang_print_error_function (file
)
6643 default_print_error_function (file
);
6644 maybe_print_template_context ();
6647 /* Make a definition for a builtin function named NAME and whose data type
6648 is TYPE. TYPE should be a function type with argument types.
6649 FUNCTION_CODE tells later passes how to compile calls to this function.
6650 See tree.h for its possible values.
6652 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6653 the name to be called if we can't opencode the function. */
6656 define_function (name
, type
, function_code
, pfn
, library_name
)
6659 enum built_in_function function_code
;
6660 void (*pfn
) PROTO((tree
));
6661 const char *library_name
;
6663 tree decl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), type
);
6664 DECL_EXTERNAL (decl
) = 1;
6665 TREE_PUBLIC (decl
) = 1;
6666 DECL_ARTIFICIAL (decl
) = 1;
6668 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6669 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
6671 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6672 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6673 function in the namespace. */
6674 if (pfn
) (*pfn
) (decl
);
6676 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
6677 make_function_rtl (decl
);
6678 if (function_code
!= NOT_BUILT_IN
)
6680 DECL_BUILT_IN (decl
) = 1;
6681 DECL_FUNCTION_CODE (decl
) = function_code
;
6687 builtin_function (name
, type
, code
, libname
)
6690 enum built_in_function code
;
6691 const char *libname
;
6693 return define_function (name
, type
, code
, (void (*) PROTO((tree
)))pushdecl
, libname
);
6696 /* When we call finish_struct for an anonymous union, we create
6697 default copy constructors and such. But, an anonymous union
6698 shouldn't have such things; this function undoes the damage to the
6699 anonymous union type T.
6701 (The reason that we create the synthesized methods is that we don't
6702 distinguish `union { int i; }' from `typedef union { int i; } U'.
6703 The first is an anonymous union; the second is just an ordinary
6707 fixup_anonymous_aggr (t
)
6712 /* Wipe out memory of synthesized methods */
6713 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6714 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6715 TYPE_HAS_INIT_REF (t
) = 0;
6716 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6717 TYPE_HAS_ASSIGN_REF (t
) = 0;
6718 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6720 /* Splice the implicitly generated functions out of the TYPE_METHODS
6722 q
= &TYPE_METHODS (t
);
6725 if (DECL_ARTIFICIAL (*q
))
6726 *q
= TREE_CHAIN (*q
);
6728 q
= &TREE_CHAIN (*q
);
6731 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
6732 function members. */
6733 if (TYPE_METHODS (t
))
6734 error ("an anonymous union cannot have function members");
6737 /* Make sure that a declaration with no declarator is well-formed, i.e.
6738 just defines a tagged type or anonymous union.
6740 Returns the type defined, if any. */
6743 check_tag_decl (declspecs
)
6747 tree ob_modifier
= NULL_TREE
;
6749 register tree t
= NULL_TREE
;
6751 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6753 register tree value
= TREE_VALUE (link
);
6759 if (IS_AGGR_TYPE (value
) || TREE_CODE (value
) == ENUMERAL_TYPE
)
6761 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
6765 else if (value
== ridpointers
[(int) RID_FRIEND
])
6767 if (current_class_type
== NULL_TREE
6768 || current_scope () != current_class_type
)
6769 ob_modifier
= value
;
6771 else if (value
== ridpointers
[(int) RID_STATIC
]
6772 || value
== ridpointers
[(int) RID_EXTERN
]
6773 || value
== ridpointers
[(int) RID_AUTO
]
6774 || value
== ridpointers
[(int) RID_REGISTER
]
6775 || value
== ridpointers
[(int) RID_INLINE
]
6776 || value
== ridpointers
[(int) RID_VIRTUAL
]
6777 || value
== ridpointers
[(int) RID_CONST
]
6778 || value
== ridpointers
[(int) RID_VOLATILE
]
6779 || value
== ridpointers
[(int) RID_EXPLICIT
])
6780 ob_modifier
= value
;
6784 error ("multiple types in one declaration");
6786 /* Inside a class, we might be in a friend or access declaration.
6787 Until we have a good way of detecting the latter, don't warn. */
6788 if (t
== NULL_TREE
&& ! current_class_type
)
6789 pedwarn ("declaration does not declare anything");
6791 /* Check for an anonymous union. We're careful
6792 accessing TYPE_IDENTIFIER because some built-in types, like
6793 pointer-to-member types, do not have TYPE_NAME. */
6794 else if (t
&& IS_AGGR_TYPE_CODE (TREE_CODE (t
))
6796 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
6798 /* Anonymous unions are objects, so they can have specifiers. */;
6799 SET_ANON_AGGR_TYPE_P (t
);
6801 if (TREE_CODE (t
) != UNION_TYPE
&& pedantic
&& ! in_system_header
)
6802 pedwarn ("ISO C++ prohibits anonymous structs");
6805 else if (ob_modifier
)
6807 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
6808 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
6809 cp_error ("`%D' can only be specified for functions", ob_modifier
);
6810 else if (ob_modifier
== ridpointers
[(int) RID_FRIEND
])
6811 cp_error ("`%D' can only be specified inside a class", ob_modifier
);
6812 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
6813 cp_error ("`%D' can only be specified for constructors",
6816 cp_error ("`%D' can only be specified for objects and functions",
6823 /* Called when a declaration is seen that contains no names to declare.
6824 If its type is a reference to a structure, union or enum inherited
6825 from a containing scope, shadow that tag name for the current scope
6826 with a forward reference.
6827 If its type defines a new named structure or union
6828 or defines an enum, it is valid but we need not do anything here.
6829 Otherwise, it is an error.
6831 C++: may have to grok the declspecs to learn about static,
6832 complain for anonymous unions. */
6835 shadow_tag (declspecs
)
6838 tree t
= check_tag_decl (declspecs
);
6841 maybe_process_partial_specialization (t
);
6843 /* This is where the variables in an anonymous union are
6844 declared. An anonymous union declaration looks like:
6846 because there is no declarator after the union, the parser
6847 sends that declaration here. */
6848 if (t
&& ANON_AGGR_TYPE_P (t
))
6850 fixup_anonymous_aggr (t
);
6852 if (TYPE_FIELDS (t
))
6854 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
6856 finish_anon_union (decl
);
6861 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6864 groktypename (typename
)
6867 if (TREE_CODE (typename
) != TREE_LIST
)
6869 return grokdeclarator (TREE_VALUE (typename
),
6870 TREE_PURPOSE (typename
),
6871 TYPENAME
, 0, NULL_TREE
);
6874 /* Decode a declarator in an ordinary declaration or data definition.
6875 This is called as soon as the type information and variable name
6876 have been parsed, before parsing the initializer if any.
6877 Here we create the ..._DECL node, fill in its type,
6878 and put it on the list of decls for the current context.
6879 The ..._DECL node is returned as the value.
6881 Exception: for arrays where the length is not specified,
6882 the type is left null, to be filled in by `cp_finish_decl'.
6884 Function definitions do not come here; they go to start_function
6885 instead. However, external and forward declarations of functions
6886 do go through here. Structure field declarations are done by
6887 grokfield and not through here. */
6889 /* Set this to zero to debug not using the temporary obstack
6890 to parse initializers. */
6891 int debug_temp_inits
= 1;
6894 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
6895 tree declarator
, declspecs
;
6897 tree attributes
, prefix_attributes
;
6900 register tree type
, tem
;
6902 extern int have_extern_spec
;
6903 extern int used_extern_spec
;
6907 /* See code below that used this. */
6908 int init_written
= initialized
;
6911 /* This should only be done once on the top most decl. */
6912 if (have_extern_spec
&& !used_extern_spec
)
6914 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
6916 used_extern_spec
= 1;
6919 if (attributes
|| prefix_attributes
)
6920 attrlist
= build_scratch_list (attributes
, prefix_attributes
);
6922 attrlist
= NULL_TREE
;
6924 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
6927 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
6930 type
= TREE_TYPE (decl
);
6932 if (type
== error_mark_node
)
6935 /* Don't lose if destructors must be executed at file-level. */
6936 if (! processing_template_decl
&& TREE_STATIC (decl
)
6937 && TYPE_NEEDS_DESTRUCTOR (complete_type (type
))
6938 && !TREE_PERMANENT (decl
))
6940 push_obstacks (&permanent_obstack
, &permanent_obstack
);
6941 decl
= copy_node (decl
);
6942 if (TREE_CODE (type
) == ARRAY_TYPE
)
6944 tree itype
= TYPE_DOMAIN (type
);
6945 if (itype
&& ! TREE_PERMANENT (itype
))
6947 itype
= build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype
)));
6948 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
6949 TREE_TYPE (decl
) = type
;
6956 = (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
6957 ? DECL_CLASS_CONTEXT (decl
)
6958 : DECL_CONTEXT (decl
);
6960 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
6961 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
6963 /* When parsing the initializer, lookup should use the object's
6965 push_decl_namespace (context
);
6968 /* We are only interested in class contexts, later. */
6969 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
6970 context
= NULL_TREE
;
6973 /* Is it valid for this decl to have an initializer at all?
6974 If not, set INITIALIZED to zero, which will indirectly
6975 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6976 switch (TREE_CODE (decl
))
6979 /* typedef foo = bar means give foo the same type as bar.
6980 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6981 Any other case of an initialization in a TYPE_DECL is an error. */
6982 if (pedantic
|| list_length (declspecs
) > 1)
6984 cp_error ("typedef `%D' is initialized", decl
);
6990 cp_error ("function `%#D' is initialized like a variable", decl
);
7000 if (! toplevel_bindings_p ()
7001 && DECL_EXTERNAL (decl
))
7002 cp_warning ("declaration of `%#D' has `extern' and is initialized",
7004 DECL_EXTERNAL (decl
) = 0;
7005 if (toplevel_bindings_p ())
7006 TREE_STATIC (decl
) = 1;
7008 /* Tell `pushdecl' this is an initialized decl
7009 even though we don't yet have the initializer expression.
7010 Also tell `cp_finish_decl' it may store the real initializer. */
7011 DECL_INITIAL (decl
) = error_mark_node
;
7014 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7015 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
7018 /* Set attributes here so if duplicate decl, will have proper attributes. */
7019 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
7021 if (context
&& TYPE_SIZE (complete_type (context
)) != NULL_TREE
)
7023 push_nested_class (context
, 2);
7025 if (TREE_CODE (decl
) == VAR_DECL
)
7027 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
7028 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
7029 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
7032 if (DECL_CONTEXT (field
) != context
)
7034 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
7035 DECL_CONTEXT (field
), DECL_NAME (decl
),
7036 context
, DECL_NAME (decl
));
7037 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
7039 /* Static data member are tricky; an in-class initialization
7040 still doesn't provide a definition, so the in-class
7041 declaration will have DECL_EXTERNAL set, but will have an
7042 initialization. Thus, duplicate_decls won't warn
7043 about this situation, and so we check here. */
7044 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
7045 cp_error ("duplicate initialization of %D", decl
);
7046 if (duplicate_decls (decl
, field
))
7052 tree field
= check_classfn (context
, decl
);
7053 if (field
&& duplicate_decls (decl
, field
))
7057 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7058 DECL_IN_AGGR_P (decl
) = 0;
7059 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
7060 || CLASSTYPE_USE_TEMPLATE (context
))
7062 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
7063 /* [temp.expl.spec] An explicit specialization of a static data
7064 member of a template is a definition if the declaration
7065 includes an initializer; otherwise, it is a declaration.
7067 We check for processing_specialization so this only applies
7068 to the new specialization syntax. */
7069 if (DECL_INITIAL (decl
) == NULL_TREE
&& processing_specialization
)
7070 DECL_EXTERNAL (decl
) = 1;
7073 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
7074 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7078 /* Enter this declaration into the symbol table. */
7079 tem
= maybe_push_decl (decl
);
7081 if (processing_template_decl
)
7083 if (at_function_scope_p ())
7084 push_permanent_obstack ();
7086 tem
= push_template_decl (tem
);
7087 /* In a a local scope, add a representation of this declaration
7088 to the statement tree. */
7089 if (at_function_scope_p ())
7091 add_decl_stmt (decl
);
7097 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7098 /* Tell the back-end to use or not use .common as appropriate. If we say
7099 -fconserve-space, we want this to save .data space, at the expense of
7100 wrong semantics. If we say -fno-conserve-space, we want this to
7101 produce errors about redefs; to do this we force variables into the
7103 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
7106 if (! processing_template_decl
)
7109 /* Corresponding pop_obstacks is done in `cp_finish_decl'. */
7110 push_obstacks_nochange ();
7119 tree type
= TREE_TYPE (decl
);
7120 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
7122 if (type
== error_mark_node
)
7125 /* If this type of object needs a cleanup, and control may
7126 jump past it, make a new binding level so that it is cleaned
7127 up only when it is initialized first. */
7128 if (TYPE_NEEDS_DESTRUCTOR (type
)
7129 && current_binding_level
->more_cleanups_ok
== 0)
7130 pushlevel_temporary (1);
7133 /* Is it valid for this decl to have an initializer at all?
7134 If not, set INITIALIZED to zero, which will indirectly
7135 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7137 /* Don't allow initializations for incomplete types except for
7138 arrays which might be completed by the initialization. */
7139 if (TYPE_SIZE (complete_type (type
)) != NULL_TREE
)
7140 ; /* A complete type is ok. */
7141 else if (TREE_CODE (type
) != ARRAY_TYPE
)
7143 cp_error ("variable `%#D' has initializer but incomplete type",
7146 type
= TREE_TYPE (decl
) = error_mark_node
;
7148 else if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
7150 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
7151 cp_error ("elements of array `%#D' have incomplete type", decl
);
7152 /* else we already gave an error in start_decl. */
7158 && TREE_CODE (decl
) != TYPE_DECL
7159 && TREE_CODE (decl
) != TEMPLATE_DECL
7160 && IS_AGGR_TYPE (type
) && ! DECL_EXTERNAL (decl
))
7162 if ((! processing_template_decl
|| ! uses_template_parms (type
))
7163 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
7165 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7167 /* Change the type so that assemble_variable will give
7168 DECL an rtl we can live with: (mem (const_int 0)). */
7169 type
= TREE_TYPE (decl
) = error_mark_node
;
7173 /* If any base type in the hierarchy of TYPE needs a constructor,
7174 then we set initialized to 1. This way any nodes which are
7175 created for the purposes of initializing this aggregate
7176 will live as long as it does. This is necessary for global
7177 aggregates which do not have their initializers processed until
7178 the end of the file. */
7179 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
7184 DECL_INITIAL (decl
) = NULL_TREE
;
7187 /* Handle initialization of references.
7188 These three arguments are from `cp_finish_decl', and have the
7189 same meaning here that they do there.
7191 Quotes on semantics can be found in ARM 8.4.3. */
7194 grok_reference_init (decl
, type
, init
)
7195 tree decl
, type
, init
;
7199 if (init
== NULL_TREE
)
7201 if ((DECL_LANG_SPECIFIC (decl
) == 0
7202 || DECL_IN_AGGR_P (decl
) == 0)
7203 && ! DECL_THIS_EXTERN (decl
))
7205 cp_error ("`%D' declared as reference but not initialized", decl
);
7206 if (TREE_CODE (decl
) == VAR_DECL
)
7207 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
7212 if (init
== error_mark_node
)
7215 if (TREE_CODE (type
) == REFERENCE_TYPE
7216 && TREE_CODE (init
) == CONSTRUCTOR
)
7218 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl
);
7222 if (TREE_CODE (init
) == TREE_LIST
)
7223 init
= build_compound_expr (init
);
7225 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
7226 init
= convert_from_reference (init
);
7228 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
7229 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
7231 /* Note: default conversion is only called in very special cases. */
7232 init
= default_conversion (init
);
7235 tmp
= convert_to_reference
7236 (type
, init
, CONV_IMPLICIT
,
7237 LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
, decl
);
7239 if (tmp
== error_mark_node
)
7241 else if (tmp
!= NULL_TREE
)
7244 DECL_INITIAL (decl
) = save_expr (init
);
7248 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
7252 /* ?? Can this be optimized in some cases to
7253 hand back the DECL_INITIAL slot?? */
7254 if (TYPE_SIZE (TREE_TYPE (type
)))
7256 init
= convert_from_reference (decl
);
7257 if (TREE_PERMANENT (decl
))
7258 init
= copy_to_permanent (init
);
7259 SET_DECL_REFERENCE_SLOT (decl
, init
);
7262 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
7264 expand_static_init (decl
, DECL_INITIAL (decl
));
7265 DECL_INITIAL (decl
) = NULL_TREE
;
7270 if (TREE_CODE (decl
) == VAR_DECL
)
7271 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
7275 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7276 mucking with forces it does not comprehend (i.e. initialization with a
7277 constructor). If we are at global scope and won't go into COMMON, fill
7278 it in with a dummy CONSTRUCTOR to force the variable into .data;
7279 otherwise we can use error_mark_node. */
7282 obscure_complex_init (decl
, init
)
7285 if (! flag_no_inline
&& TREE_STATIC (decl
))
7287 if (extract_init (decl
, init
))
7291 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7292 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
7293 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
7297 DECL_INITIAL (decl
) = error_mark_node
;
7302 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7303 array until we finish parsing the initializer. If that's the
7304 situation we're in, update DECL accordingly. */
7307 maybe_deduce_size_from_array_init (decl
, init
)
7311 tree type
= TREE_TYPE (decl
);
7313 if (TREE_CODE (type
) == ARRAY_TYPE
7314 && TYPE_DOMAIN (type
) == NULL_TREE
7315 && TREE_CODE (decl
) != TYPE_DECL
)
7318 = (TREE_STATIC (decl
)
7319 /* Even if pedantic, an external linkage array
7320 may have incomplete type at first. */
7321 ? pedantic
&& ! DECL_EXTERNAL (decl
)
7322 : !DECL_EXTERNAL (decl
));
7323 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7324 int failure
= complete_array_type (type
, initializer
, do_default
);
7327 cp_error ("initializer fails to determine size of `%D'", decl
);
7332 cp_error ("array size missing in `%D'", decl
);
7333 /* If a `static' var's size isn't known, make it extern as
7334 well as static, so it does not get allocated. If it's not
7335 `static', then don't mark it extern; finish_incomplete_decl
7336 will give it a default size and it will get allocated. */
7337 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7338 DECL_EXTERNAL (decl
) = 1;
7341 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7342 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7344 cp_error ("zero-size array `%D'", decl
);
7346 layout_decl (decl
, 0);
7350 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7351 any appropriate error messages regarding the layout. INITP is a
7352 pointer to the initializer for DECL; the initializer may be
7353 modified by this function. */
7356 layout_var_decl (decl
, initp
)
7360 tree ttype
= target_type (TREE_TYPE (decl
));
7362 if (DECL_SIZE (decl
) == NULL_TREE
7363 && TYPE_SIZE (complete_type (TREE_TYPE (decl
))) != NULL_TREE
)
7364 layout_decl (decl
, 0);
7366 if (TREE_STATIC (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7368 /* A static variable with an incomplete type:
7369 that is an error if it is initialized.
7370 Otherwise, let it through, but if it is not `extern'
7371 then it may cause an error message later. */
7372 if (DECL_INITIAL (decl
) != NULL_TREE
)
7373 cp_error ("storage size of `%D' isn't known", decl
);
7376 else if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7378 /* An automatic variable with an incomplete type: that is an error.
7379 Don't talk about array types here, since we took care of that
7380 message in grokdeclarator. */
7381 cp_error ("storage size of `%D' isn't known", decl
);
7382 TREE_TYPE (decl
) = error_mark_node
;
7384 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7385 /* Let debugger know it should output info for this type. */
7386 note_debug_info_needed (ttype
);
7388 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7389 note_debug_info_needed (DECL_CONTEXT (decl
));
7391 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7392 && DECL_SIZE (decl
) != NULL_TREE
7393 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7395 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7396 constant_expression_warning (DECL_SIZE (decl
));
7398 cp_error ("storage size of `%D' isn't constant", decl
);
7402 /* Return a cleanup for DECL, created on whatever obstack is
7406 build_cleanup_on_safe_obstack (decl
)
7413 type
= TREE_TYPE (decl
);
7415 /* Only variables get cleaned up. */
7416 if (TREE_CODE (decl
) != VAR_DECL
)
7419 /* And only things with destructors need cleaning up. */
7420 if (!TYPE_NEEDS_DESTRUCTOR (type
))
7423 if (TREE_CODE (decl
) == VAR_DECL
&&
7424 (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
)))
7425 /* We don't clean up things that aren't defined in this
7426 translation unit, or that need a static cleanup. The latter
7427 are handled by finish_file. */
7430 /* Switch to an obstack that will live until the point where the
7431 cleanup code is actually expanded. */
7432 need_pop
= suspend_momentary ();
7434 /* Compute the cleanup. */
7435 cleanup
= maybe_build_cleanup (decl
);
7437 /* Pop back to the obstack we were on before. */
7438 resume_momentary (need_pop
);
7443 /* If a local static variable is declared in an inline function, or if
7444 we have a weak definition, we must endeavor to create only one
7445 instance of the variable at link-time. */
7448 maybe_commonize_var (decl
)
7451 /* Static data in a function with comdat linkage also has comdat
7453 if (TREE_STATIC (decl
)
7454 /* Don't mess with __FUNCTION__. */
7455 && ! TREE_ASM_WRITTEN (decl
)
7456 && current_function_decl
7457 && DECL_CONTEXT (decl
) == current_function_decl
7458 && (DECL_THIS_INLINE (current_function_decl
)
7459 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7460 && TREE_PUBLIC (current_function_decl
))
7462 /* Rather than try to get this right with inlining, we suppress
7463 inlining of such functions. */
7464 current_function_cannot_inline
7465 = "function with static variable cannot be inline";
7467 /* If flag_weak, we don't need to mess with this, as we can just
7468 make the function weak, and let it refer to its unique local
7469 copy. This works because we don't allow the function to be
7473 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7475 TREE_PUBLIC (decl
) = 1;
7476 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7478 else if (DECL_INITIAL (decl
) == NULL_TREE
7479 || DECL_INITIAL (decl
) == error_mark_node
)
7481 TREE_PUBLIC (decl
) = 1;
7482 DECL_COMMON (decl
) = 1;
7484 /* else we lose. We can only do this if we can use common,
7485 which we can't if it has been initialized. */
7487 if (TREE_PUBLIC (decl
))
7488 DECL_ASSEMBLER_NAME (decl
)
7489 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7490 else if (! DECL_ARTIFICIAL (decl
))
7492 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7493 cp_warning_at (" you can work around this by removing the initializer", decl
);
7497 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
7498 /* Set it up again; we might have set DECL_INITIAL since the last
7500 comdat_linkage (decl
);
7503 /* Issue an error message if DECL is an uninitialized const variable. */
7506 check_for_uninitialized_const_var (decl
)
7509 tree type
= TREE_TYPE (decl
);
7511 /* ``Unless explicitly declared extern, a const object does not have
7512 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7514 if (TREE_CODE (decl
) == VAR_DECL
7515 && TREE_CODE (type
) != REFERENCE_TYPE
7516 && CP_TYPE_CONST_P (type
)
7517 && !TYPE_NEEDS_CONSTRUCTING (type
)
7518 && !DECL_INITIAL (decl
))
7519 cp_error ("uninitialized const `%D'", decl
);
7522 /* Verify INITP (the initializer for DECL), and record the
7523 initialization in DECL_INITIAL, if appropriate. The initializer
7524 may be modified by this function. */
7527 check_initializer (decl
, initp
)
7534 if (TREE_CODE (decl
) == FIELD_DECL
)
7537 type
= TREE_TYPE (decl
);
7540 /* If `start_decl' didn't like having an initialization, ignore it now. */
7541 if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7543 else if (DECL_EXTERNAL (decl
))
7545 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
7547 if (TREE_STATIC (decl
))
7548 make_decl_rtl (decl
, NULL_PTR
, toplevel_bindings_p ());
7549 grok_reference_init (decl
, type
, init
);
7553 /* Check for certain invalid initializations. */
7556 if (TYPE_SIZE (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
7558 cp_error ("variable-sized object `%D' may not be initialized", decl
);
7561 if (TREE_CODE (type
) == ARRAY_TYPE
7562 && !TYPE_SIZE (complete_type (TREE_TYPE (type
))))
7564 cp_error ("elements of array `%#D' have incomplete type", decl
);
7569 if (TREE_CODE (decl
) == CONST_DECL
)
7571 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7573 DECL_INITIAL (decl
) = init
;
7575 /* This will keep us from needing to worry about our obstacks. */
7576 my_friendly_assert (init
!= NULL_TREE
, 149);
7581 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7583 if (TREE_CODE (type
) == ARRAY_TYPE
)
7584 init
= digest_init (type
, init
, (tree
*) 0);
7585 else if (TREE_CODE (init
) == CONSTRUCTOR
7586 && TREE_HAS_CONSTRUCTOR (init
))
7588 if (TYPE_NON_AGGREGATE_CLASS (type
))
7590 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7592 init
= error_mark_node
;
7595 goto dont_use_constructor
;
7600 dont_use_constructor
:
7601 if (TREE_CODE (init
) != TREE_VEC
)
7602 init
= store_init_value (decl
, init
);
7606 /* We must hide the initializer so that expand_decl
7607 won't try to do something it does not understand. */
7608 init
= obscure_complex_init (decl
, init
);
7610 else if (DECL_EXTERNAL (decl
))
7612 else if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't'
7613 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7615 tree core_type
= strip_array_types (type
);
7617 if (! TYPE_NEEDS_CONSTRUCTING (core_type
))
7619 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
7620 cp_error ("structure `%D' with uninitialized const members", decl
);
7621 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
7622 cp_error ("structure `%D' with uninitialized reference members",
7626 check_for_uninitialized_const_var (decl
);
7628 if (TYPE_SIZE (type
) != NULL_TREE
7629 && TYPE_NEEDS_CONSTRUCTING (type
))
7630 init
= obscure_complex_init (decl
, NULL_TREE
);
7634 check_for_uninitialized_const_var (decl
);
7636 /* Store the modified initializer for our caller. */
7640 /* If DECL is not a local variable, give it RTL. */
7643 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
)
7646 const char *asmspec
;
7651 type
= TREE_TYPE (decl
);
7652 toplev
= toplevel_bindings_p ();
7653 push_obstacks_nochange ();
7654 if (TREE_STATIC (decl
)
7655 && TYPE_NEEDS_DESTRUCTOR (type
)
7656 && allocation_temporary_p ())
7657 end_temporary_allocation ();
7659 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
7660 make_decl_rtl (decl
, NULL_PTR
, toplev
);
7661 else if (TREE_CODE (decl
) == VAR_DECL
7662 && TREE_READONLY (decl
)
7663 && DECL_INITIAL (decl
) != NULL_TREE
7664 && DECL_INITIAL (decl
) != error_mark_node
7665 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7667 DECL_INITIAL (decl
) = save_expr (DECL_INITIAL (decl
));
7670 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7673 && TREE_STATIC (decl
)
7674 && ! TREE_SIDE_EFFECTS (decl
)
7675 && ! TREE_PUBLIC (decl
)
7676 && ! DECL_EXTERNAL (decl
)
7677 && ! TYPE_NEEDS_DESTRUCTOR (type
)
7678 && DECL_MODE (decl
) != BLKmode
)
7680 /* If this variable is really a constant, then fill its DECL_RTL
7681 slot with something which won't take up storage.
7682 If something later should take its address, we can always give
7683 it legitimate RTL at that time. */
7684 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
7685 store_expr (DECL_INITIAL (decl
), DECL_RTL (decl
), 0);
7686 TREE_ASM_WRITTEN (decl
) = 1;
7688 else if (toplev
&& ! TREE_PUBLIC (decl
))
7690 /* If this is a static const, change its apparent linkage
7691 if it belongs to a #pragma interface. */
7692 if (!interface_unknown
)
7694 TREE_PUBLIC (decl
) = 1;
7695 DECL_EXTERNAL (decl
) = interface_only
;
7697 make_decl_rtl (decl
, asmspec
, toplev
);
7700 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7702 else if (TREE_CODE (decl
) == VAR_DECL
7703 && DECL_LANG_SPECIFIC (decl
)
7704 && DECL_IN_AGGR_P (decl
))
7706 my_friendly_assert (TREE_STATIC (decl
), 19990828);
7708 if (init
== NULL_TREE
7709 #ifdef DEFAULT_STATIC_DEFS
7710 /* If this code is dead, then users must
7711 explicitly declare static member variables
7712 outside the class def'n as well. */
7713 && TYPE_NEEDS_CONSTRUCTING (type
)
7717 DECL_EXTERNAL (decl
) = 1;
7718 make_decl_rtl (decl
, asmspec
, 1);
7721 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7724 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7729 /* The old ARM scoping rules injected variables declared in the
7730 initialization statement of a for-statement into the surrounding
7731 scope. We support this usage, in order to be backward-compatible.
7732 DECL is a just-declared VAR_DECL; if necessary inject its
7733 declaration into the surrounding scope. */
7736 maybe_inject_for_scope_var (decl
)
7739 if (current_binding_level
->is_for_scope
)
7741 struct binding_level
*outer
7742 = current_binding_level
->level_chain
;
7744 /* Check to see if the same name is already bound at the outer
7745 level, either because it was directly declared, or because a
7746 dead for-decl got preserved. In either case, the code would
7747 not have been valid under the ARM scope rules, so clear
7748 is_for_scope for the current_binding_level.
7750 Otherwise, we need to preserve the temp slot for decl to last
7751 into the outer binding level. */
7754 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl
)));
7756 if (outer_binding
&& BINDING_LEVEL (outer_binding
) == outer
7757 && (TREE_CODE (BINDING_VALUE (outer_binding
))
7759 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding
)))
7761 BINDING_VALUE (outer_binding
)
7762 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding
));
7763 current_binding_level
->is_for_scope
= 0;
7765 else if (DECL_IN_MEMORY_P (decl
))
7766 preserve_temp_slots (DECL_RTL (decl
));
7770 /* Generate code to initialized DECL (a local variable). */
7773 initialize_local_var (decl
, init
, flags
)
7781 type
= TREE_TYPE (decl
);
7783 cleanup
= build_cleanup_on_safe_obstack (decl
);
7785 if (DECL_SIZE (decl
) == NULL_TREE
&& !TREE_STATIC (decl
))
7787 /* If we used it already as memory, it must stay in memory. */
7788 DECL_INITIAL (decl
) = NULL_TREE
;
7789 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7792 if (DECL_RTL (decl
))
7793 /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7794 All other local variables are assigned RTL in this function. */
7795 my_friendly_assert (TREE_CODE (decl
) == RESULT_DECL
, 19990828);
7797 /* Create RTL for this variable. */
7800 expand_start_target_temps ();
7802 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7806 /* Compute and store the initial value. */
7807 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7809 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7811 emit_line_note (DECL_SOURCE_FILE (decl
),
7812 DECL_SOURCE_LINE (decl
));
7813 /* We call push_momentary here so that when
7814 finish_expr_stmt clears the momentary obstack it
7815 doesn't destory any momentary expressions we may
7816 have lying around. Although cp_finish_decl is
7817 usually called at the end of a declaration
7818 statement, it may also be called for a temporary
7819 object in the middle of an expression. */
7821 finish_expr_stmt (build_aggr_init (decl
, init
, flags
));
7825 expand_decl_init (decl
);
7827 /* Set this to 0 so we can tell whether an aggregate which was
7828 initialized was ever used. Don't do this if it has a
7829 destructor, so we don't complain about the 'resource
7830 allocation is initialization' idiom. Now set
7831 attribute((unused)) on types so decls of that type will be
7832 marked used. (see TREE_USED, above.) */
7833 if (TYPE_NEEDS_CONSTRUCTING (type
)
7835 && cleanup
== NULL_TREE
7836 && DECL_NAME (decl
))
7837 TREE_USED (decl
) = 0;
7838 else if (already_used
)
7839 TREE_USED (decl
) = 1;
7842 /* Cleanup any temporaries needed for the initial value. */
7843 expand_end_target_temps ();
7845 /* Record the cleanup required for this declaration. */
7846 if (DECL_SIZE (decl
)
7847 && type
!= error_mark_node
7849 && !expand_decl_cleanup (decl
, cleanup
))
7850 cp_error ("parser lost in parsing declaration of `%D'", decl
);
7853 /* Finish processing of a declaration;
7854 install its line number and initial value.
7855 If the length of an array type is not known before,
7856 it must be determined now, from the initial value, or it is an error.
7858 Call `pop_obstacks' iff NEED_POP is nonzero.
7860 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
7861 for aggregates that have constructors alive on the permanent obstack,
7862 so that the global initializing functions can be written at the end.
7864 INIT0 holds the value of an initializer that should be allowed to escape
7867 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7868 if the (init) syntax was used.
7870 For functions that take default parameters, DECL points to its
7871 "maximal" instantiation. `cp_finish_decl' must then also declared its
7872 subsequently lower and lower forms of instantiation, checking for
7873 ambiguity as it goes. This can be sped up later. */
7876 cp_finish_decl (decl
, init
, asmspec_tree
, need_pop
, flags
)
7883 tree ttype
= NULL_TREE
;
7884 int temporary
= allocation_temporary_p ();
7885 const char *asmspec
= NULL
;
7886 int was_readonly
= 0;
7888 /* If this is 0, then we did not change obstacks. */
7892 error ("assignment (not initialization) in declaration");
7896 /* If a name was specified, get the string. */
7898 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
7900 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
7902 cp_error ("Cannot initialize `%D' to namespace `%D'",
7907 if (current_class_type
7908 && DECL_REAL_CONTEXT (decl
) == current_class_type
7909 && TYPE_BEING_DEFINED (current_class_type
)
7910 && (DECL_INITIAL (decl
) || init
))
7911 DECL_DEFINED_IN_CLASS_P (decl
) = 1;
7913 if (TREE_CODE (decl
) == VAR_DECL
7914 && DECL_CONTEXT (decl
)
7915 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
7916 && DECL_CONTEXT (decl
) != current_namespace
7919 /* Leave the namespace of the object. */
7920 pop_decl_namespace ();
7923 type
= complete_type (TREE_TYPE (decl
));
7925 if (type
== error_mark_node
)
7927 if (toplevel_bindings_p () && temporary
)
7928 end_temporary_allocation ();
7933 if (TYPE_HAS_MUTABLE_P (type
))
7934 TREE_READONLY (decl
) = 0;
7936 if (processing_template_decl
)
7938 if (init
&& DECL_INITIAL (decl
))
7939 DECL_INITIAL (decl
) = copy_to_permanent (init
);
7943 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
7944 my_friendly_assert (TREE_CODE (decl
) != PARM_DECL
, 19990828);
7946 /* Take care of TYPE_DECLs up front. */
7947 if (TREE_CODE (decl
) == TYPE_DECL
)
7949 if (init
&& DECL_INITIAL (decl
))
7951 /* typedef foo = bar; store the type of bar as the type of foo. */
7952 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
7953 DECL_INITIAL (decl
) = init
= NULL_TREE
;
7955 if (type
!= error_mark_node
7956 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
7958 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7959 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
7960 set_identifier_type_value (DECL_NAME (decl
), type
);
7961 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
7963 GNU_xref_decl (current_function_decl
, decl
);
7965 /* If we have installed this as the canonical typedef for this
7966 type, and that type has not been defined yet, delay emitting
7967 the debug information for it, as we will emit it later. */
7968 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7969 && TYPE_SIZE (TREE_TYPE (decl
)) == NULL_TREE
)
7970 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
7972 rest_of_decl_compilation (decl
, NULL_PTR
,
7973 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
7977 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7978 ttype
= target_type (type
);
7980 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
7981 && TYPE_NEEDS_CONSTRUCTING (type
))
7983 /* Currently, GNU C++ puts constants in text space, making them
7984 impossible to initialize. In the future, one would hope for
7985 an operating system which understood the difference between
7986 initialization and the running of a program. */
7988 TREE_READONLY (decl
) = 0;
7991 if (TREE_CODE (decl
) == FIELD_DECL
&& asmspec
)
7993 /* This must override the asm specifier which was placed by
7994 grokclassfn. Lay this out fresh. */
7995 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
7996 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7997 make_decl_rtl (decl
, asmspec
, 0);
8000 check_initializer (decl
, &init
);
8002 GNU_xref_decl (current_function_decl
, decl
);
8004 /* For top-level declaration, the initial value was read in
8005 the temporary obstack. MAXINDEX, rtl, etc. to be made below
8006 must go in the permanent obstack; but don't discard the
8007 temporary data yet. */
8009 if (toplevel_bindings_p () && temporary
)
8010 end_temporary_allocation ();
8012 /* Deduce size of array from initialization, if not already known. */
8013 maybe_deduce_size_from_array_init (decl
, init
);
8015 if (TREE_CODE (decl
) == VAR_DECL
)
8016 layout_var_decl (decl
, &init
);
8018 /* Output the assembler code and/or RTL code for variables and functions,
8019 unless the type is an undefined structure or union.
8020 If not, it will get done when the type is completed. */
8021 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
8022 || TREE_CODE (decl
) == RESULT_DECL
)
8024 /* ??? FIXME: What about nested classes? */
8025 int toplev
= toplevel_bindings_p ();
8027 if (TREE_CODE (decl
) == VAR_DECL
)
8028 maybe_commonize_var (decl
);
8030 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
8032 if (TREE_CODE (type
) == FUNCTION_TYPE
8033 || TREE_CODE (type
) == METHOD_TYPE
)
8034 abstract_virtuals_error (decl
,
8035 strip_array_types (TREE_TYPE (type
)));
8037 abstract_virtuals_error (decl
, strip_array_types (type
));
8039 if (TREE_CODE (decl
) == FUNCTION_DECL
)
8041 else if (DECL_EXTERNAL (decl
)
8042 && ! (DECL_LANG_SPECIFIC (decl
)
8043 && DECL_NOT_REALLY_EXTERN (decl
)))
8046 DECL_INITIAL (decl
) = init
;
8048 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
8050 /* Cleanups for static variables are handled by `finish_file'. */
8051 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
8052 || TYPE_NEEDS_DESTRUCTOR (type
))
8053 expand_static_init (decl
, init
);
8057 /* This is a local declaration. */
8058 maybe_inject_for_scope_var (decl
);
8059 /* Initialize the local variable. But, if we're building a
8060 statement-tree, we'll do the initialization when we
8062 if (!building_stmt_tree ())
8063 initialize_local_var (decl
, init
, flags
);
8064 else if (init
|| DECL_INITIAL (decl
) == error_mark_node
)
8065 DECL_INITIAL (decl
) = init
;
8069 /* Undo call to `pushclass' that was done in `start_decl'
8070 due to initialization of qualified member variable.
8071 I.e., Foo::x = 10; */
8073 tree context
= DECL_REAL_CONTEXT (decl
);
8075 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't'
8076 && (TREE_CODE (decl
) == VAR_DECL
8077 /* We also have a pushclass done that we need to undo here
8078 if we're at top level and declare a method. */
8079 || TREE_CODE (decl
) == FUNCTION_DECL
)
8080 /* If size hasn't been set, we're still defining it,
8081 and therefore inside the class body; don't pop
8082 the binding level.. */
8083 && TYPE_SIZE (context
) != NULL_TREE
8084 && context
== current_class_type
)
8085 pop_nested_class ();
8091 /* If requested, warn about definitions of large data objects. */
8093 if (warn_larger_than
8094 && ! processing_template_decl
8095 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
8096 && !DECL_EXTERNAL (decl
))
8098 register tree decl_size
= DECL_SIZE (decl
);
8100 if (decl_size
&& TREE_CODE (decl_size
) == INTEGER_CST
)
8102 unsigned units
= TREE_INT_CST_LOW (decl_size
) / BITS_PER_UNIT
;
8104 if (units
> larger_than_size
)
8105 warning_with_decl (decl
, "size of `%s' is %u bytes", units
);
8110 /* Resume permanent allocation, if not within a function. The
8111 corresponding push_obstacks_nochange is in start_decl,
8112 start_method, groktypename, and in grokfield. */
8116 TREE_READONLY (decl
) = 1;
8119 /* This is here for a midend callback from c-common.c */
8122 finish_decl (decl
, init
, asmspec_tree
)
8126 cp_finish_decl (decl
, init
, asmspec_tree
, 1, 0);
8130 expand_static_init (decl
, init
)
8134 tree oldstatic
= value_member (decl
, static_aggregates
);
8138 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
8139 cp_error ("multiple initializations given for `%D'", decl
);
8141 else if (! toplevel_bindings_p ())
8143 /* Emit code to perform this initialization but once. */
8149 /* Remember this information until end of file. */
8150 push_obstacks (&permanent_obstack
, &permanent_obstack
);
8152 /* Emit code to perform this initialization but once. This code
8155 static int temp = 0;
8157 // Do initialization.
8159 // Register variable for destruction at end of program.
8162 Note that the `temp' variable is only set to 1 *after* the
8163 initialization is complete. This ensures that an exception,
8164 thrown during the construction, will cause the variable to
8165 reinitialized when we pass through this code again, as per:
8169 If the initialization exits by throwing an exception, the
8170 initialization is not complete, so it will be tried again
8171 the next time control enters the declaration.
8173 In theory, this process should be thread-safe, too; multiple
8174 threads should not be able to initialize the variable more
8175 than once. We don't yet attempt to ensure thread-safety. */
8176 temp
= get_temp_name (integer_type_node
, 1);
8177 rest_of_decl_compilation (temp
, NULL_PTR
, 0, 0);
8179 /* Begin the conditional initialization. */
8180 if_stmt
= begin_if_stmt ();
8181 finish_if_stmt_cond (build_binary_op (EQ_EXPR
, temp
,
8185 /* Do the initialization itself. */
8186 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
8187 || (init
&& TREE_CODE (init
) == TREE_LIST
))
8188 assignment
= build_aggr_init (decl
, init
, 0);
8190 /* The initialization we're doing here is just a bitwise
8192 assignment
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, init
);
8194 assignment
= NULL_TREE
;
8196 /* Once the assignment is complete, set TEMP to 1. Since the
8197 construction of the static object is complete at this point,
8198 we want to make sure TEMP is set to 1 even if a temporary
8199 constructed during the initialization throws an exception
8200 when it is destroyed. So, we combine the initialization and
8201 the assignment to TEMP into a single expression, ensuring
8202 that when we call finish_expr_stmt the cleanups will not be
8203 run until after TEMP is set to 1. */
8204 temp_init
= build_modify_expr (temp
, NOP_EXPR
, integer_one_node
);
8207 assignment
= tree_cons (NULL_TREE
, assignment
,
8208 build_tree_list (NULL_TREE
,
8210 assignment
= build_compound_expr (assignment
);
8213 assignment
= temp_init
;
8214 finish_expr_stmt (assignment
);
8216 /* Use atexit to register a function for destroying this static
8218 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
8220 tree cleanup
, fcall
;
8221 static tree Atexit
= 0;
8222 int saved_flag_access_control
;
8226 tree atexit_fndecl
, PFV
, pfvlist
;
8227 /* Remember this information until end of file. */
8228 push_obstacks (&permanent_obstack
, &permanent_obstack
);
8229 PFV
= build_pointer_type (build_function_type
8230 (void_type_node
, void_list_node
));
8232 pfvlist
= tree_cons (NULL_TREE
, PFV
, void_list_node
);
8234 push_lang_context (lang_name_c
);
8235 /* Note that we do not call pushdecl for this function;
8236 there's no reason that this declaration should be
8237 accessible to anyone. */
8239 = define_function ("atexit",
8240 build_function_type (void_type_node
,
8245 mark_used (atexit_fndecl
);
8246 Atexit
= default_conversion (atexit_fndecl
);
8247 pop_lang_context ();
8251 /* Call build_cleanup before we enter the anonymous function
8252 so that any access checks will be done relative to the
8253 current scope, rather than the scope of the anonymous
8255 build_cleanup (decl
);
8257 /* Now start the function. */
8258 cleanup
= start_anon_func ();
8260 /* Now, recompute the cleanup. It may contain SAVE_EXPRs
8261 that refer to the original function, rather than the
8262 anonymous one. That will make the back-end think that
8263 nested functions are in use, which causes confusion. */
8264 saved_flag_access_control
= flag_access_control
;
8265 flag_access_control
= 0;
8266 fcall
= build_cleanup (decl
);
8267 flag_access_control
= saved_flag_access_control
;
8269 /* Finish off the function. */
8270 expand_expr_stmt (fcall
);
8273 /* Call atexit with the cleanup function. */
8274 mark_addressable (cleanup
);
8275 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
8276 fcall
= build_function_call (Atexit
,
8277 expr_tree_cons (NULL_TREE
,
8280 finish_expr_stmt (fcall
);
8283 finish_then_clause (if_stmt
);
8286 /* Resume old (possibly temporary) allocation. */
8291 /* This code takes into account memory allocation policy of
8292 `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING does not
8293 hold for this object, then we must make permanent the storage
8294 currently in the temporary obstack. */
8295 if (!TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
8296 preserve_initializer ();
8297 static_aggregates
= perm_tree_cons (init
, decl
, static_aggregates
);
8301 /* Finish the declaration of a catch-parameter. */
8304 start_handler_parms (declspecs
, declarator
)
8311 decl
= grokdeclarator (declarator
, declspecs
, CATCHPARM
,
8313 if (decl
== NULL_TREE
)
8314 error ("invalid catch parameter");
8318 expand_start_catch_block (decl
);
8322 /* Make TYPE a complete type based on INITIAL_VALUE.
8323 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8324 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8327 complete_array_type (type
, initial_value
, do_default
)
8328 tree type
, initial_value
;
8331 register tree maxindex
= NULL_TREE
;
8334 /* Allocate on the same obstack as TYPE. */
8335 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8339 /* Note MAXINDEX is really the maximum index,
8340 one less than the size. */
8341 if (TREE_CODE (initial_value
) == STRING_CST
)
8344 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8345 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
8348 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8350 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
8351 maxindex
= size_binop (MINUS_EXPR
, integer_zero_node
, size_one_node
);
8352 for (; elts
; elts
= TREE_CHAIN (elts
))
8354 if (TREE_PURPOSE (elts
))
8355 maxindex
= TREE_PURPOSE (elts
);
8357 maxindex
= size_binop (PLUS_EXPR
, maxindex
, size_one_node
);
8359 maxindex
= copy_node (maxindex
);
8363 /* Make an error message unless that happened already. */
8364 if (initial_value
!= error_mark_node
)
8367 initial_value
= NULL_TREE
;
8369 /* Prevent further error messages. */
8370 maxindex
= build_int_2 (0, 0);
8377 maxindex
= build_int_2 (0, 0);
8386 domain
= build_index_type (maxindex
);
8387 TYPE_DOMAIN (type
) = domain
;
8389 if (! TREE_TYPE (maxindex
))
8390 TREE_TYPE (maxindex
) = domain
;
8392 itype
= TREE_TYPE (initial_value
);
8395 if (itype
&& !TYPE_DOMAIN (itype
))
8396 TYPE_DOMAIN (itype
) = domain
;
8397 /* The type of the main variant should never be used for arrays
8398 of different sizes. It should only ever be completed with the
8399 size of the array. */
8400 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
8401 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = domain
;
8406 /* Lay out the type now that we can get the real answer. */
8413 /* Return zero if something is declared to be a member of type
8414 CTYPE when in the context of CUR_TYPE. STRING is the error
8415 message to print in that case. Otherwise, quietly return 1. */
8418 member_function_or_else (ctype
, cur_type
, string
)
8419 tree ctype
, cur_type
;
8422 if (ctype
&& ctype
!= cur_type
)
8424 error (string
, TYPE_NAME_STRING (ctype
));
8430 /* Subroutine of `grokdeclarator'. */
8432 /* Generate errors possibly applicable for a given set of specifiers.
8433 This is for ARM $7.1.2. */
8436 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
8439 int virtualp
, quals
, friendp
, raises
, inlinep
;
8442 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
8444 cp_error ("`%D' declared as an `inline' %s", object
, type
);
8446 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8449 cp_error_at ("`%D' declared as a friend", object
);
8451 cp_error_at ("`%D' declared with an exception specification", object
);
8454 /* CTYPE is class type, or null if non-class.
8455 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8457 DECLARATOR is the function's name.
8458 VIRTUALP is truthvalue of whether the function is virtual or not.
8459 FLAGS are to be passed through to `grokclassfn'.
8460 QUALS are qualifiers indicating whether the function is `const'
8462 RAISES is a list of exceptions that this function can raise.
8463 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8464 not look, and -1 if we should not call `grokclassfn' at all.
8466 Returns `NULL_TREE' if something goes wrong, after issuing
8467 applicable error messages. */
8470 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8471 raises
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8472 template_count
, in_namespace
)
8475 tree orig_declarator
;
8477 enum overload_flags flags
;
8479 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8483 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8484 int has_default_arg
= 0;
8488 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8489 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8495 type
= build_exception_variant (type
, raises
);
8498 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8499 /* Propagate volatile out from type to decl. */
8500 if (TYPE_VOLATILE (type
))
8501 TREE_THIS_VOLATILE (decl
) = 1;
8503 /* If this decl has namespace scope, set that up. */
8505 set_decl_namespace (decl
, in_namespace
, friendp
);
8506 else if (publicp
&& ! ctype
)
8507 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8509 /* `main' and builtins have implicit 'C' linkage. */
8510 if ((MAIN_NAME_P (declarator
)
8511 || (IDENTIFIER_LENGTH (declarator
) > 10
8512 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8513 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8514 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8515 && current_lang_name
== lang_name_cplusplus
8516 && ctype
== NULL_TREE
8517 /* NULL_TREE means global namespace. */
8518 && DECL_CONTEXT (decl
) == NULL_TREE
)
8519 DECL_LANGUAGE (decl
) = lang_c
;
8521 /* Should probably propagate const out from type to decl I bet (mrs). */
8524 DECL_STATIC_FUNCTION_P (decl
) = 1;
8525 DECL_CONTEXT (decl
) = ctype
;
8529 DECL_CLASS_CONTEXT (decl
) = ctype
;
8531 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8533 if (processing_template_decl
)
8534 error ("cannot declare `main' to be a template");
8536 error ("cannot declare `main' to be inline");
8538 error ("cannot declare `main' to be static");
8543 /* Members of anonymous types and local classes have no linkage; make
8545 if (ctype
&& (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
))
8546 || hack_decl_function_context (TYPE_MAIN_DECL (ctype
))))
8551 /* [basic.link]: A name with no linkage (notably, the name of a class
8552 or enumeration declared in a local scope) shall not be used to
8553 declare an entity with linkage.
8555 Only check this for public decls for now. */
8556 t
= no_linkage_check (TREE_TYPE (decl
));
8559 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8561 if (DECL_LANGUAGE (decl
) == lang_c
)
8562 /* Allow this; it's pretty common in C. */;
8564 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8568 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8573 TREE_PUBLIC (decl
) = publicp
;
8576 DECL_INTERFACE_KNOWN (decl
) = 1;
8577 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8581 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8583 DECL_EXTERNAL (decl
) = 1;
8584 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8586 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8587 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8591 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8592 grok_op_properties (decl
, virtualp
, check
< 0);
8594 if (ctype
&& hack_decl_function_context (decl
))
8595 DECL_NO_STATIC_CHAIN (decl
) = 1;
8597 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8598 if (TREE_PURPOSE (t
)
8599 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8601 has_default_arg
= 1;
8606 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8610 ("defining explicit specialization `%D' in friend declaration",
8614 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8616 /* Something like `template <class T> friend void f<T>()'. */
8617 cp_error ("template-id `%D' in declaration of primary template",
8623 /* A friend declaration of the form friend void f<>(). Record
8624 the information in the TEMPLATE_ID_EXPR. */
8625 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8626 DECL_TEMPLATE_INFO (decl
)
8627 = perm_tree_cons (TREE_OPERAND (orig_declarator
, 0),
8628 TREE_OPERAND (orig_declarator
, 1),
8631 if (has_default_arg
)
8633 cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8640 cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8647 if (has_default_arg
)
8648 add_defarg_fn (decl
);
8650 /* Plain overloading: will not be grok'd by grokclassfn. */
8651 if (! ctype
&& ! processing_template_decl
8652 && DECL_LANGUAGE (decl
) != lang_c
8653 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
8654 set_mangled_name_for_decl (decl
);
8657 /* Make the init_value nonzero so pushdecl knows this is not
8658 tentative. error_mark_node is replaced later with the BLOCK. */
8659 DECL_INITIAL (decl
) = error_mark_node
;
8661 /* Caller will do the rest of this. */
8665 if (check
&& funcdef_flag
)
8666 DECL_INITIAL (decl
) = error_mark_node
;
8668 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8671 /* Just handle constructors here. We could do this
8672 inside the following if stmt, but I think
8673 that the code is more legible by breaking this
8674 case out. See comments below for what each of
8675 the following calls is supposed to do. */
8676 DECL_CONSTRUCTOR_P (decl
) = 1;
8678 grokclassfn (ctype
, decl
, flags
, quals
);
8680 decl
= check_explicit_specialization (orig_declarator
, decl
,
8682 2 * (funcdef_flag
!= 0) +
8683 4 * (friendp
!= 0));
8684 if (decl
== error_mark_node
)
8687 if ((! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8690 tmp
= check_classfn (ctype
, decl
);
8692 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8693 tmp
= DECL_TEMPLATE_RESULT(tmp
);
8695 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8696 cp_error ("definition of implicitly-declared `%D'", tmp
);
8697 if (tmp
&& duplicate_decls (decl
, tmp
))
8700 if (! grok_ctor_properties (ctype
, decl
))
8707 /* Function gets the ugly name, field gets the nice one.
8708 This call may change the type of the function (because
8709 of default parameters)! */
8710 if (ctype
!= NULL_TREE
)
8711 grokclassfn (ctype
, decl
, flags
, quals
);
8713 decl
= check_explicit_specialization (orig_declarator
, decl
,
8715 2 * (funcdef_flag
!= 0) +
8716 4 * (friendp
!= 0));
8717 if (decl
== error_mark_node
)
8720 if (ctype
!= NULL_TREE
8721 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8724 tmp
= check_classfn (ctype
, decl
);
8726 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8727 tmp
= DECL_TEMPLATE_RESULT (tmp
);
8729 if (tmp
&& DECL_STATIC_FUNCTION_P (tmp
)
8730 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8732 /* Remove the `this' parm added by grokclassfn.
8733 XXX Isn't this done in start_function, too? */
8734 revert_static_member_fn (&decl
, NULL
, NULL
);
8735 last_function_parms
= TREE_CHAIN (last_function_parms
);
8737 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8738 cp_error ("definition of implicitly-declared `%D'", tmp
);
8741 /* Attempt to merge the declarations. This can fail, in
8742 the case of some illegal specialization declarations. */
8743 if (!duplicate_decls (decl
, tmp
))
8744 cp_error ("no `%#D' member function declared in class `%T'",
8750 if (ctype
== NULL_TREE
|| check
)
8755 DECL_VIRTUAL_P (decl
) = 1;
8756 if (DECL_VINDEX (decl
) == NULL_TREE
)
8757 DECL_VINDEX (decl
) = error_mark_node
;
8758 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
8765 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
8768 RID_BIT_TYPE
*specbits_in
;
8774 RID_BIT_TYPE specbits
;
8776 specbits
= *specbits_in
;
8778 if (TREE_CODE (type
) == OFFSET_TYPE
)
8780 /* If you declare a static member so that it
8781 can be initialized, the code will reach here. */
8782 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
8783 type
= TREE_TYPE (type
);
8784 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
8785 DECL_CONTEXT (decl
) = basetype
;
8786 DECL_CLASS_CONTEXT (decl
) = basetype
;
8787 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
, declarator
);
8794 context
= in_namespace
;
8795 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
8796 context
= current_namespace
;
8798 context
= NULL_TREE
;
8800 if (processing_template_decl
)
8802 /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8803 we can call push_template_decl. */
8804 push_permanent_obstack ();
8805 decl
= build_lang_decl (VAR_DECL
, declarator
,
8806 complete_type (type
));
8810 decl
= build_decl (VAR_DECL
, declarator
, complete_type (type
));
8813 set_decl_namespace (decl
, context
, 0);
8815 context
= DECL_CONTEXT (decl
);
8816 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
8817 DECL_ASSEMBLER_NAME (decl
) = build_static_name (context
, declarator
);
8821 set_decl_namespace (decl
, in_namespace
, 0);
8823 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
8825 DECL_THIS_EXTERN (decl
) = 1;
8826 DECL_EXTERNAL (decl
) = !initialized
;
8829 /* In class context, static means one per class,
8830 public access, and static storage. */
8831 if (DECL_CLASS_SCOPE_P (decl
))
8833 TREE_PUBLIC (decl
) = 1;
8834 TREE_STATIC (decl
) = 1;
8835 DECL_EXTERNAL (decl
) = 0;
8837 /* At top level, either `static' or no s.c. makes a definition
8838 (perhaps tentative), and absence of `static' makes it public. */
8839 else if (toplevel_bindings_p ())
8841 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
8842 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8843 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8845 /* Not at top level, only `static' makes a static definition. */
8848 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
8849 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8852 if (TREE_PUBLIC (decl
))
8854 /* [basic.link]: A name with no linkage (notably, the name of a class
8855 or enumeration declared in a local scope) shall not be used to
8856 declare an entity with linkage.
8858 Only check this for public decls for now. */
8859 tree t
= no_linkage_check (TREE_TYPE (decl
));
8862 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8863 /* Ignore for now; `enum { foo } e' is pretty common. */;
8865 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8873 /* Create and return a canonical pointer to member function type, for
8874 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8877 build_ptrmemfunc_type (type
)
8883 tree unqualified_variant
= NULL_TREE
;
8885 /* If a canonical type already exists for this type, use it. We use
8886 this method instead of type_hash_canon, because it only does a
8887 simple equality check on the list of field members. */
8889 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8892 /* Make sure that we always have the unqualified pointer-to-member
8894 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
8896 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8898 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8900 u
= make_lang_type (UNION_TYPE
);
8901 SET_IS_AGGR_TYPE (u
, 0);
8902 fields
[0] = build_lang_decl (FIELD_DECL
, pfn_identifier
, type
);
8903 fields
[1] = build_lang_decl (FIELD_DECL
, delta2_identifier
,
8905 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
8906 TYPE_NAME (u
) = NULL_TREE
;
8908 t
= make_lang_type (RECORD_TYPE
);
8910 /* Let the front-end know this is a pointer to member function... */
8911 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8912 /* ... and not really an aggregate. */
8913 SET_IS_AGGR_TYPE (t
, 0);
8915 fields
[0] = build_lang_decl (FIELD_DECL
, delta_identifier
,
8917 fields
[1] = build_lang_decl (FIELD_DECL
, index_identifier
,
8919 fields
[2] = build_lang_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
8920 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
8924 /* Zap out the name so that the back-end will give us the debugging
8925 information for this anonymous RECORD_TYPE. */
8926 TYPE_NAME (t
) = NULL_TREE
;
8928 /* If this is not the unqualified form of this pointer-to-member
8929 type, set the TYPE_MAIN_VARIANT for this type to be the
8930 unqualified type. Since they are actually RECORD_TYPEs that are
8931 not variants of each other, we must do this manually. */
8932 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
8934 t
= build_qualified_type (t
, CP_TYPE_QUALS (type
));
8935 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
8936 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
8937 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
8940 /* Cache this pointer-to-member type so that we can find it again
8942 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8944 /* Seems to be wanted. */
8945 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
8950 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8951 Check to see that the definition is valid. Issue appropriate error
8952 messages. Return 1 if the definition is particularly bad, or 0
8956 check_static_variable_definition (decl
, type
)
8960 /* Motion 10 at San Diego: If a static const integral data member is
8961 initialized with an integral constant expression, the initializer
8962 may appear either in the declaration (within the class), or in
8963 the definition, but not both. If it appears in the class, the
8964 member is a member constant. The file-scope definition is always
8966 if (CLASS_TYPE_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
8968 cp_error ("in-class initialization of static data member of non-integral type `%T'",
8970 /* If we just return the declaration, crashes will sometimes
8971 occur. We therefore return void_type_node, as if this was a
8972 friend declaration, to cause callers to completely ignore
8973 this declaration. */
8976 else if (!CP_TYPE_CONST_P (type
))
8977 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8979 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
8980 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
8985 /* Given declspecs and a declarator,
8986 determine the name and type of the object declared
8987 and construct a ..._DECL node for it.
8988 (In one case we can return a ..._TYPE node instead.
8989 For invalid input we sometimes return 0.)
8991 DECLSPECS is a chain of tree_list nodes whose value fields
8992 are the storage classes and type specifiers.
8994 DECL_CONTEXT says which syntactic context this declaration is in:
8995 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8996 FUNCDEF for a function definition. Like NORMAL but a few different
8997 error messages in each case. Return value may be zero meaning
8998 this definition is too screwy to try to parse.
8999 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9000 handle member functions (which have FIELD context).
9001 Return value may be zero meaning this definition is too screwy to
9003 PARM for a parameter declaration (either within a function prototype
9004 or before a function body). Make a PARM_DECL, or return void_type_node.
9005 CATCHPARM for a parameter declaration before a catch clause.
9006 TYPENAME if for a typename (in a cast or sizeof).
9007 Don't make a DECL node; just return the ..._TYPE node.
9008 FIELD for a struct or union field; make a FIELD_DECL.
9009 BITFIELD for a field with specified width.
9010 INITIALIZED is 1 if the decl has an initializer.
9012 ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9013 normal attributes in TREE_PURPOSE, or NULL_TREE.
9015 In the TYPENAME case, DECLARATOR is really an absolute declarator.
9016 It may also be so in the PARM case, for a prototype where the
9017 argument type is specified but not the name.
9019 This function is where the complicated C meanings of `static'
9020 and `extern' are interpreted.
9022 For C++, if there is any monkey business to do, the function which
9023 calls this one must do it, i.e., prepending instance variables,
9024 renaming overloaded function names, etc.
9026 Note that for this C++, it is an error to define a method within a class
9027 which does not belong to that class.
9029 Except in the case where SCOPE_REFs are implicitly known (such as
9030 methods within a class being redundantly qualified),
9031 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9032 (class_name::decl_name). The caller must also deal with this.
9034 If a constructor or destructor is seen, and the context is FIELD,
9035 then the type gains the attribute TREE_HAS_x. If such a declaration
9036 is erroneous, NULL_TREE is returned.
9038 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
9039 function, these are the qualifiers to give to the `this' pointer.
9041 May return void_type_node if the declarator turned out to be a friend.
9042 See grokfield for details. */
9044 enum return_types
{ return_normal
, return_ctor
, return_dtor
, return_conversion
};
9047 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
9050 enum decl_context decl_context
;
9054 RID_BIT_TYPE specbits
;
9057 tree type
= NULL_TREE
;
9063 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9064 int explicit_int
= 0;
9065 int explicit_char
= 0;
9066 int defaulted_int
= 0;
9067 tree typedef_decl
= NULL_TREE
;
9069 tree typedef_type
= NULL_TREE
;
9070 int funcdef_flag
= 0;
9071 enum tree_code innermost_code
= ERROR_MARK
;
9074 /* See the code below that used this. */
9075 tree decl_machine_attr
= NULL_TREE
;
9077 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9078 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
9079 tree init
= NULL_TREE
;
9081 /* Keep track of what sort of function is being processed
9082 so that we can warn about default return values, or explicit
9083 return values which do not match prescribed defaults. */
9084 enum return_types return_type
= return_normal
;
9086 tree dname
= NULL_TREE
;
9087 tree ctype
= current_class_type
;
9088 tree ctor_return_type
= NULL_TREE
;
9089 enum overload_flags flags
= NO_SPECIAL
;
9090 tree quals
= NULL_TREE
;
9091 tree raises
= NULL_TREE
;
9092 int template_count
= 0;
9093 tree in_namespace
= NULL_TREE
;
9097 RIDBIT_RESET_ALL (specbits
);
9098 if (decl_context
== FUNCDEF
)
9099 funcdef_flag
= 1, decl_context
= NORMAL
;
9100 else if (decl_context
== MEMFUNCDEF
)
9101 funcdef_flag
= -1, decl_context
= FIELD
;
9102 else if (decl_context
== BITFIELD
)
9103 bitfield
= 1, decl_context
= FIELD
;
9105 /* Look inside a declarator for the name being declared
9106 and get it as a string, for an error message. */
9108 tree
*next
= &declarator
;
9112 while (next
&& *next
)
9115 switch (TREE_CODE (decl
))
9118 /* For attributes. */
9119 next
= &TREE_VALUE (decl
);
9124 next
= &TREE_OPERAND (decl
, 0);
9127 case BIT_NOT_EXPR
: /* For C++ destructors! */
9129 tree name
= TREE_OPERAND (decl
, 0);
9130 tree rename
= NULL_TREE
;
9132 my_friendly_assert (flags
== NO_SPECIAL
, 152);
9134 return_type
= return_dtor
;
9135 if (TREE_CODE (name
) == TYPE_DECL
)
9136 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
9137 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
9138 if (ctype
== NULL_TREE
)
9140 if (current_class_type
== NULL_TREE
)
9142 error ("destructors must be member functions");
9147 tree t
= constructor_name (current_class_name
);
9154 tree t
= constructor_name (ctype
);
9161 cp_error ("destructor `%T' must match class name `%T'",
9163 TREE_OPERAND (decl
, 0) = rename
;
9169 case ADDR_EXPR
: /* C++ reference declaration */
9174 innermost_code
= TREE_CODE (decl
);
9175 next
= &TREE_OPERAND (decl
, 0);
9179 if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl
)))
9181 /* This is actually a variable declaration using
9182 constructor syntax. We need to call start_decl and
9183 cp_finish_decl so we can get the variable
9186 tree attributes
, prefix_attributes
;
9188 *next
= TREE_OPERAND (decl
, 0);
9189 init
= CALL_DECLARATOR_PARMS (decl
);
9193 attributes
= TREE_PURPOSE (attrlist
);
9194 prefix_attributes
= TREE_VALUE (attrlist
);
9198 attributes
= NULL_TREE
;
9199 prefix_attributes
= NULL_TREE
;
9202 decl
= start_decl (declarator
, declspecs
, 1,
9203 attributes
, prefix_attributes
);
9206 /* Look for __unused__ attribute */
9207 if (TREE_USED (TREE_TYPE (decl
)))
9208 TREE_USED (decl
) = 1;
9209 finish_decl (decl
, init
, NULL_TREE
);
9212 cp_error ("invalid declarator");
9215 innermost_code
= TREE_CODE (decl
);
9216 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
9217 ctype
= current_class_type
;
9219 && TREE_OPERAND (decl
, 0)
9220 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
9221 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
9222 == constructor_name_full (ctype
))
9223 || (DECL_NAME (TREE_OPERAND (decl
, 0))
9224 == constructor_name (ctype
)))))
9225 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9226 next
= &TREE_OPERAND (decl
, 0);
9228 if (ctype
!= NULL_TREE
9229 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
9230 && decl
== constructor_name (ctype
))
9232 return_type
= return_ctor
;
9233 ctor_return_type
= ctype
;
9238 case TEMPLATE_ID_EXPR
:
9240 tree fns
= TREE_OPERAND (decl
, 0);
9242 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
9243 fns
= TREE_OPERAND (fns
, 0);
9246 if (TREE_CODE (dname
) == COMPONENT_REF
)
9247 dname
= TREE_OPERAND (dname
, 1);
9248 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
9250 my_friendly_assert (is_overloaded_fn (dname
),
9252 dname
= DECL_NAME (get_first_fn (dname
));
9257 case IDENTIFIER_NODE
:
9258 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
9265 cp_error ("declarator-id missing; using reserved word `%D'",
9267 name
= IDENTIFIER_POINTER (dname
);
9269 if (! IDENTIFIER_OPNAME_P (dname
)
9270 /* GNU/Linux headers use '__op'. Arrgh. */
9271 || (IDENTIFIER_TYPENAME_P (dname
) && ! TREE_TYPE (dname
)))
9272 name
= IDENTIFIER_POINTER (dname
);
9275 if (IDENTIFIER_TYPENAME_P (dname
))
9277 my_friendly_assert (flags
== NO_SPECIAL
, 154);
9278 flags
= TYPENAME_FLAG
;
9279 ctor_return_type
= TREE_TYPE (dname
);
9280 return_type
= return_conversion
;
9282 name
= operator_name_string (dname
);
9289 /* Perform error checking, and decide on a ctype. */
9290 tree cname
= TREE_OPERAND (decl
, 0);
9291 if (cname
== NULL_TREE
)
9293 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
9296 in_namespace
= TREE_OPERAND (decl
, 0);
9297 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9299 else if (! is_aggr_type (cname
, 1))
9300 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9301 /* Must test TREE_OPERAND (decl, 1), in case user gives
9302 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9303 else if (TREE_OPERAND (decl
, 1)
9304 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
9306 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
9307 || TREE_CODE (cname
) == TEMPLATE_TEMPLATE_PARM
)
9309 cp_error ("`%T::%D' is not a valid declarator", cname
,
9310 TREE_OPERAND (decl
, 1));
9311 cp_error (" perhaps you want `typename %T::%D' to make it a type",
9312 cname
, TREE_OPERAND (decl
, 1));
9313 return void_type_node
;
9315 else if (ctype
== NULL_TREE
)
9317 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
9318 TREE_OPERAND (decl
, 0) = ctype
;
9321 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
9323 cp_error ("type `%T' is not derived from type `%T'",
9325 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9331 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
9332 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
9333 == constructor_name_full (ctype
))
9334 || (DECL_NAME (TREE_OPERAND (decl
, 1))
9335 == constructor_name (ctype
))))
9336 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
9337 next
= &TREE_OPERAND (decl
, 1);
9341 if (TREE_CODE (decl
) == IDENTIFIER_NODE
9342 && constructor_name (ctype
) == decl
)
9344 return_type
= return_ctor
;
9345 ctor_return_type
= ctype
;
9347 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
9348 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
9349 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
9350 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
9352 return_type
= return_dtor
;
9353 ctor_return_type
= ctype
;
9355 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9356 next
= &TREE_OPERAND (decl
, 0);
9367 /* Parse error puts this typespec where
9368 a declarator should go. */
9369 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
9370 if (TREE_TYPE (decl
) == current_class_type
)
9371 cp_error (" perhaps you want `%T' for a constructor",
9372 current_class_name
);
9373 dname
= DECL_NAME (decl
);
9374 name
= IDENTIFIER_POINTER (dname
);
9376 /* Avoid giving two errors for this. */
9377 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
9379 declspecs
= temp_tree_cons (NULL_TREE
, integer_type_node
,
9386 cp_compiler_error ("`%D' as declarator", decl
);
9387 return 0; /* We used to do a 155 abort here. */
9394 /* A function definition's declarator must have the form of
9395 a function declarator. */
9397 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
9400 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
9401 && innermost_code
!= CALL_EXPR
9402 && ! (ctype
&& declspecs
== NULL_TREE
))
9404 cp_error ("declaration of `%D' as non-function", dname
);
9405 return void_type_node
;
9408 /* Anything declared one level down from the top level
9409 must be one of the parameters of a function
9410 (because the body is at least two levels down). */
9412 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9413 by not allowing C++ class definitions to specify their parameters
9414 with xdecls (must be spec.d in the parmlist).
9416 Since we now wait to push a class scope until we are sure that
9417 we are in a legitimate method context, we must set oldcname
9418 explicitly (since current_class_name is not yet alive).
9420 We also want to avoid calling this a PARM if it is in a namespace. */
9422 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9424 struct binding_level
*b
= current_binding_level
;
9425 current_binding_level
= b
->level_chain
;
9426 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9427 decl_context
= PARM
;
9428 current_binding_level
= b
;
9431 /* Look through the decl specs and record which ones appear.
9432 Some typespecs are defined as built-in typenames.
9433 Others, the ones that are modifiers of other types,
9434 are represented by bits in SPECBITS: set the bits for
9435 the modifiers that appear. Storage class keywords are also in SPECBITS.
9437 If there is a typedef name or a type, store the type in TYPE.
9438 This includes builtin typedefs such as `int'.
9440 Set EXPLICIT_INT if the type is `int' or `char' and did not
9441 come from a user typedef.
9443 Set LONGLONG if `long' is mentioned twice.
9445 For C++, constructors and destructors have their own fast treatment. */
9447 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
9452 /* Certain parse errors slip through. For example,
9453 `int class;' is not caught by the parser. Try
9454 weakly to recover here. */
9455 if (TREE_CODE (spec
) != TREE_LIST
)
9458 id
= TREE_VALUE (spec
);
9460 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9462 if (id
== ridpointers
[(int) RID_INT
]
9463 || id
== ridpointers
[(int) RID_CHAR
]
9464 || id
== ridpointers
[(int) RID_BOOL
]
9465 || id
== ridpointers
[(int) RID_WCHAR
])
9469 if (id
== ridpointers
[(int) RID_BOOL
])
9470 error ("`bool' is now a keyword");
9472 cp_error ("extraneous `%T' ignored", id
);
9476 if (id
== ridpointers
[(int) RID_INT
])
9478 else if (id
== ridpointers
[(int) RID_CHAR
])
9480 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
9484 /* C++ aggregate types. */
9485 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
9488 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
9490 type
= IDENTIFIER_TYPE_VALUE (id
);
9494 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
9496 if (ridpointers
[i
] == id
)
9498 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
9500 if (pedantic
&& ! in_system_header
&& warn_long_long
)
9501 pedwarn ("ANSI C++ does not support `long long'");
9503 error ("`long long long' is too long for GCC");
9507 else if (RIDBIT_SETP (i
, specbits
))
9508 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
9509 RIDBIT_SET (i
, specbits
);
9514 /* C++ aggregate types. */
9515 else if (TREE_CODE (id
) == TYPE_DECL
|| TREE_CODE (id
) == TEMPLATE_DECL
)
9518 cp_error ("multiple declarations `%T' and `%T'", type
,
9522 type
= TREE_TYPE (id
);
9523 TREE_VALUE (spec
) = type
;
9528 error ("two or more data types in declaration of `%s'", name
);
9529 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9531 register tree t
= lookup_name (id
, 1);
9532 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9533 error ("`%s' fails to be a typedef or built in type",
9534 IDENTIFIER_POINTER (id
));
9537 type
= TREE_TYPE (t
);
9539 /* See the code below that used this. */
9540 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
9545 else if (id
!= error_mark_node
)
9546 /* Can't change CLASS nodes into RECORD nodes here! */
9552 typedef_type
= type
;
9554 /* No type at all: default to `int', and set DEFAULTED_INT
9555 because it was not a user-defined typedef. */
9557 if (type
== NULL_TREE
9558 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
9559 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9560 || RIDBIT_SETP (RID_LONG
, specbits
)
9561 || RIDBIT_SETP (RID_SHORT
, specbits
)))
9563 /* These imply 'int'. */
9564 type
= integer_type_node
;
9568 if (type
== NULL_TREE
)
9571 if (return_type
== return_dtor
)
9572 type
= void_type_node
;
9573 else if (return_type
== return_ctor
)
9574 type
= build_pointer_type (ctor_return_type
);
9575 else if (return_type
== return_conversion
)
9576 type
= ctor_return_type
;
9579 /* We handle `main' specially here, because 'main () { }' is so
9580 common. With no options, it is allowed. With -Wreturn-type,
9581 it is a warning. It is only an error with -pedantic-errors. */
9582 int is_main
= (funcdef_flag
9583 && MAIN_NAME_P (dname
)
9584 && ctype
== NULL_TREE
9585 && in_namespace
== NULL_TREE
9586 && current_namespace
== global_namespace
);
9588 if (in_system_header
|| flag_ms_extensions
)
9589 /* Allow it, sigh. */;
9590 else if (pedantic
|| ! is_main
)
9591 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
9593 else if (warn_return_type
)
9594 cp_warning ("ANSI C++ forbids declaration `%D' with no type",
9597 type
= integer_type_node
;
9600 else if (return_type
== return_dtor
)
9602 error ("return type specification for destructor invalid");
9603 type
= void_type_node
;
9605 else if (return_type
== return_ctor
)
9607 error ("return type specification for constructor invalid");
9608 type
= build_pointer_type (ctor_return_type
);
9610 else if (return_type
== return_conversion
)
9612 if (!same_type_p (type
, ctor_return_type
))
9613 cp_error ("operator `%T' declared to return `%T'",
9614 ctor_return_type
, type
);
9616 cp_pedwarn ("return type specified for `operator %T'",
9619 type
= ctor_return_type
;
9624 /* Now process the modifiers that were specified
9625 and check for invalid combinations. */
9627 /* Long double is a special combination. */
9629 if (RIDBIT_SETP (RID_LONG
, specbits
)
9630 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
9632 RIDBIT_RESET (RID_LONG
, specbits
);
9633 type
= build_qualified_type (long_double_type_node
,
9634 CP_TYPE_QUALS (type
));
9637 /* Check all other uses of type modifiers. */
9639 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9640 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9641 || RIDBIT_SETP (RID_LONG
, specbits
)
9642 || RIDBIT_SETP (RID_SHORT
, specbits
))
9646 if (TREE_CODE (type
) == REAL_TYPE
)
9647 error ("short, signed or unsigned invalid for `%s'", name
);
9648 else if (TREE_CODE (type
) != INTEGER_TYPE
)
9649 error ("long, short, signed or unsigned invalid for `%s'", name
);
9650 else if (RIDBIT_SETP (RID_LONG
, specbits
)
9651 && RIDBIT_SETP (RID_SHORT
, specbits
))
9652 error ("long and short specified together for `%s'", name
);
9653 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9654 || RIDBIT_SETP (RID_SHORT
, specbits
))
9656 error ("long or short specified with char for `%s'", name
);
9657 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9658 || RIDBIT_SETP (RID_SHORT
, specbits
))
9659 && TREE_CODE (type
) == REAL_TYPE
)
9660 error ("long or short specified with floating type for `%s'", name
);
9661 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9662 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
9663 error ("signed and unsigned given together for `%s'", name
);
9667 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
9669 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9671 if (flag_pedantic_errors
)
9676 /* Discard the type modifiers if they are invalid. */
9679 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
9680 RIDBIT_RESET (RID_SIGNED
, specbits
);
9681 RIDBIT_RESET (RID_LONG
, specbits
);
9682 RIDBIT_RESET (RID_SHORT
, specbits
);
9687 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
9688 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9690 error ("complex invalid for `%s'", name
);
9691 RIDBIT_RESET (RID_COMPLEX
, specbits
);
9694 /* Decide whether an integer type is signed or not.
9695 Optionally treat bitfields as signed by default. */
9696 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9699 It is implementation-defined whether a plain (neither
9700 explicitly signed or unsigned) char, short, int, or long
9701 bit-field is signed or unsigned.
9703 Naturally, we extend this to long long as well. Note that
9704 this does not include wchar_t. */
9705 || (bitfield
&& !flag_signed_bitfields
9706 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)
9707 /* A typedef for plain `int' without `signed' can be
9708 controlled just like plain `int', but a typedef for
9709 `signed int' cannot be so controlled. */
9711 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9712 && (TREE_CODE (type
) == INTEGER_TYPE
9713 || TREE_CODE (type
) == CHAR_TYPE
)
9714 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9717 type
= long_long_unsigned_type_node
;
9718 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9719 type
= long_unsigned_type_node
;
9720 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9721 type
= short_unsigned_type_node
;
9722 else if (type
== char_type_node
)
9723 type
= unsigned_char_type_node
;
9724 else if (typedef_decl
)
9725 type
= unsigned_type (type
);
9727 type
= unsigned_type_node
;
9729 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9730 && type
== char_type_node
)
9731 type
= signed_char_type_node
;
9733 type
= long_long_integer_type_node
;
9734 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9735 type
= long_integer_type_node
;
9736 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9737 type
= short_integer_type_node
;
9739 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
9741 /* If we just have "complex", it is equivalent to
9742 "complex double", but if any modifiers at all are specified it is
9743 the complex form of TYPE. E.g, "complex short" is
9744 "complex short int". */
9746 if (defaulted_int
&& ! longlong
9747 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
9748 || RIDBIT_SETP (RID_SHORT
, specbits
)
9749 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9750 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
9751 type
= complex_double_type_node
;
9752 else if (type
== integer_type_node
)
9753 type
= complex_integer_type_node
;
9754 else if (type
== float_type_node
)
9755 type
= complex_float_type_node
;
9756 else if (type
== double_type_node
)
9757 type
= complex_double_type_node
;
9758 else if (type
== long_double_type_node
)
9759 type
= complex_long_double_type_node
;
9761 type
= build_complex_type (type
);
9764 if (return_type
== return_conversion
9765 && (RIDBIT_SETP (RID_CONST
, specbits
)
9766 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
9767 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
9768 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9771 /* Set CONSTP if this declaration is `const', whether by
9772 explicit specification or via a typedef.
9773 Likewise for VOLATILEP. */
9775 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
9777 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
9779 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
9780 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9781 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9782 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9783 type
= cp_build_qualified_type (type
, type_quals
);
9785 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
9786 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
9787 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
9788 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
9789 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
9791 if (RIDBIT_SETP (RID_STATIC
, specbits
))
9792 staticp
= 1 + (decl_context
== FIELD
);
9794 if (virtualp
&& staticp
== 2)
9796 cp_error ("member `%D' cannot be declared both virtual and static",
9800 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
9801 RIDBIT_RESET (RID_FRIEND
, specbits
);
9803 /* $7.1.2, Function specifiers */
9804 if (friendp
&& explicitp
)
9805 error ("only declarations of constructors can be `explicit'");
9807 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9809 if (decl_context
== PARM
)
9811 error ("non-member `%s' cannot be declared `mutable'", name
);
9812 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9814 else if (friendp
|| decl_context
== TYPENAME
)
9816 error ("non-object member `%s' cannot be declared `mutable'", name
);
9817 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9821 /* Warn if two storage classes are given. Default to `auto'. */
9823 if (RIDBIT_ANY_SET (specbits
))
9825 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
9826 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
9827 if (decl_context
== PARM
&& nclasses
> 0)
9828 error ("storage class specifiers invalid in parameter declarations");
9829 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9831 if (decl_context
== PARM
)
9832 error ("typedef declaration invalid in parameter declaration");
9835 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
9836 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
9839 /* Give error if `virtual' is used outside of class declaration. */
9841 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9843 error ("virtual outside class declaration");
9846 if (current_class_name
== NULL_TREE
&& RIDBIT_SETP (RID_MUTABLE
, specbits
))
9848 error ("only members can be declared mutable");
9849 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9852 /* Static anonymous unions are dealt with here. */
9853 if (staticp
&& decl_context
== TYPENAME
9854 && TREE_CODE (declspecs
) == TREE_LIST
9855 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs
)))
9856 decl_context
= FIELD
;
9858 /* Warn about storage classes that are invalid for certain
9859 kinds of declarations (parameters, typenames, etc.). */
9862 error ("multiple storage classes in declaration of `%s'", name
);
9863 else if (decl_context
!= NORMAL
&& nclasses
> 0)
9865 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9866 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
9867 || RIDBIT_SETP (RID_AUTO
, specbits
)))
9869 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9871 else if (decl_context
== FIELD
9872 /* C++ allows static class elements */
9873 && RIDBIT_SETP (RID_STATIC
, specbits
))
9874 /* C++ also allows inlines and signed and unsigned elements,
9875 but in those cases we don't come in here. */
9879 if (decl_context
== FIELD
)
9881 tree tmp
= NULL_TREE
;
9882 register int op
= 0;
9886 /* Avoid trying to get an operand off an identifier node. */
9887 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
9890 tmp
= TREE_OPERAND (declarator
, 0);
9891 op
= IDENTIFIER_OPNAME_P (tmp
);
9893 error ("storage class specified for %s `%s'",
9894 op
? "member operator" : "field",
9895 op
? operator_name_string (tmp
) : name
);
9898 error (((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9899 ? "storage class specified for parameter `%s'"
9900 : "storage class specified for typename"), name
);
9901 RIDBIT_RESET (RID_REGISTER
, specbits
);
9902 RIDBIT_RESET (RID_AUTO
, specbits
);
9903 RIDBIT_RESET (RID_EXTERN
, specbits
);
9906 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
9908 if (toplevel_bindings_p ())
9910 /* It's common practice (and completely valid) to have a const
9911 be initialized and declared extern. */
9912 if (!(type_quals
& TYPE_QUAL_CONST
))
9913 warning ("`%s' initialized and declared `extern'", name
);
9916 error ("`%s' has both `extern' and initializer", name
);
9918 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
9919 && ! toplevel_bindings_p ())
9920 error ("nested function `%s' declared `extern'", name
);
9921 else if (toplevel_bindings_p ())
9923 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9924 error ("top-level declaration of `%s' specifies `auto'", name
);
9927 if (nclasses
> 0 && friendp
)
9928 error ("storage class specifiers invalid in friend function declarations");
9930 /* Now figure out the structure of the declarator proper.
9931 Descend through it, creating more complex types, until we reach
9932 the declared identifier (or NULL_TREE, in an absolute declarator). */
9934 inner_attrs
= NULL_TREE
;
9937 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
9938 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
9940 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9941 an INDIRECT_REF (for *...),
9942 a CALL_EXPR (for ...(...)),
9943 an identifier (for the name being declared)
9944 or a null pointer (for the place in an absolute declarator
9945 where the name was omitted).
9946 For the last two cases, we have just exited the loop.
9948 For C++ it could also be
9949 a SCOPE_REF (for class :: ...). In this case, we have converted
9950 sensible names to types, and those are the values we use to
9951 qualify the member name.
9952 an ADDR_EXPR (for &...),
9953 a BIT_NOT_EXPR (for destructors)
9955 At this point, TYPE is the type of elements of an array,
9956 or for a function to return, or for a pointer to point to.
9957 After this sequence of ifs, TYPE is the type of the
9958 array or function or pointer, and DECLARATOR has had its
9959 outermost layer removed. */
9961 if (type
== error_mark_node
)
9963 if (TREE_CODE (declarator
) == SCOPE_REF
)
9964 declarator
= TREE_OPERAND (declarator
, 1);
9966 declarator
= TREE_OPERAND (declarator
, 0);
9969 if (quals
!= NULL_TREE
9970 && (declarator
== NULL_TREE
9971 || TREE_CODE (declarator
) != SCOPE_REF
))
9973 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
9974 ctype
= TYPE_METHOD_BASETYPE (type
);
9975 if (ctype
!= NULL_TREE
)
9977 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
9978 ctype
= grok_method_quals (ctype
, dummy
, quals
);
9979 type
= TREE_TYPE (dummy
);
9984 /* See the comment for the TREE_LIST case, below. */
9987 else if (inner_attrs
)
9989 decl_attributes (type
, inner_attrs
, NULL_TREE
);
9990 inner_attrs
= NULL_TREE
;
9993 switch (TREE_CODE (declarator
))
9997 /* We encode a declarator with embedded attributes using
9998 a TREE_LIST. The attributes apply to the declarator
9999 directly inside them, so we have to skip an iteration
10000 before applying them to the type. If the declarator just
10001 inside is the declarator-id, we apply the attrs to the
10003 inner_attrs
= TREE_PURPOSE (declarator
);
10005 declarator
= TREE_VALUE (declarator
);
10011 register tree itype
= NULL_TREE
;
10012 register tree size
= TREE_OPERAND (declarator
, 1);
10013 /* The index is a signed object `sizetype' bits wide. */
10014 tree index_type
= signed_type (sizetype
);
10016 declarator
= TREE_OPERAND (declarator
, 0);
10018 /* Check for some types that there cannot be arrays of. */
10020 if (TREE_CODE (type
) == VOID_TYPE
)
10022 cp_error ("declaration of `%D' as array of voids", dname
);
10023 type
= error_mark_node
;
10026 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10028 cp_error ("declaration of `%D' as array of functions", dname
);
10029 type
= error_mark_node
;
10032 /* ARM $8.4.3: Since you can't have a pointer to a reference,
10033 you can't have arrays of references. If we allowed them,
10034 then we'd be saying x[i] is valid for an array x, but
10035 then you'd have to ask: what does `*(x + i)' mean? */
10036 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10038 if (decl_context
== TYPENAME
)
10039 cp_error ("cannot make arrays of references");
10041 cp_error ("declaration of `%D' as array of references",
10043 type
= error_mark_node
;
10046 if (TREE_CODE (type
) == OFFSET_TYPE
)
10048 cp_error ("declaration of `%D' as array of data members",
10050 type
= error_mark_node
;
10053 if (TREE_CODE (type
) == METHOD_TYPE
)
10055 cp_error ("declaration of `%D' as array of function members",
10057 type
= error_mark_node
;
10060 if (size
== error_mark_node
)
10061 type
= error_mark_node
;
10062 else if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
10066 the constant expressions that specify the bounds of
10067 the arrays can be omitted only for the first member
10068 of the sequence. */
10069 cp_error ("declaration of `%D' as multidimensional array",
10071 cp_error ("must have bounds for all dimensions except the first");
10072 type
= error_mark_node
;
10075 if (type
== error_mark_node
)
10078 /* VC++ spells a zero-sized array with []. */
10079 if (size
== NULL_TREE
&& decl_context
== FIELD
&& ! staticp
10080 && ! RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10081 size
= integer_zero_node
;
10085 /* Must suspend_momentary here because the index
10086 type may need to live until the end of the function.
10087 For example, it is used in the declaration of a
10088 variable which requires destructing at the end of
10089 the function; then build_vec_delete will need this
10091 int yes
= suspend_momentary ();
10092 /* Might be a cast. */
10093 if (TREE_CODE (size
) == NOP_EXPR
10094 && TREE_TYPE (size
) == TREE_TYPE (TREE_OPERAND (size
, 0)))
10095 size
= TREE_OPERAND (size
, 0);
10096 if (TREE_READONLY_DECL_P (size
))
10097 size
= decl_constant_value (size
);
10099 /* If this involves a template parameter, it will be a
10100 constant at instantiation time, but we don't know
10101 what the value is yet. Even if no template
10102 parameters are involved, we may an expression that
10103 is not a constant; we don't even simplify `1 + 2'
10104 when processing a template. */
10105 if (processing_template_decl
)
10107 /* Resolve a qualified reference to an enumerator or
10108 static const data member of ours. */
10109 if (TREE_CODE (size
) == SCOPE_REF
10110 && TREE_OPERAND (size
, 0) == current_class_type
)
10112 tree t
= lookup_field (current_class_type
,
10113 TREE_OPERAND (size
, 1), 0, 0);
10118 itype
= build_index_type (build_min
10119 (MINUS_EXPR
, sizetype
, size
, integer_one_node
));
10120 goto dont_grok_size
;
10123 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
10124 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
10125 && TREE_CODE (TREE_TYPE (size
)) != BOOLEAN_TYPE
)
10127 cp_error ("size of array `%D' has non-integer type",
10129 size
= integer_one_node
;
10131 if (pedantic
&& integer_zerop (size
))
10132 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname
);
10133 if (TREE_CONSTANT (size
))
10135 int old_flag_pedantic_errors
= flag_pedantic_errors
;
10136 int old_pedantic
= pedantic
;
10137 pedantic
= flag_pedantic_errors
= 1;
10138 /* Always give overflow errors on array subscripts. */
10139 constant_expression_warning (size
);
10140 pedantic
= old_pedantic
;
10141 flag_pedantic_errors
= old_flag_pedantic_errors
;
10142 if (INT_CST_LT (size
, integer_zero_node
))
10144 cp_error ("size of array `%D' is negative", dname
);
10145 size
= integer_one_node
;
10153 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
10156 cp_pedwarn ("ANSI C++ forbids variable-size array");
10161 = fold (build_binary_op (MINUS_EXPR
,
10162 cp_convert (index_type
, size
),
10163 cp_convert (index_type
,
10164 integer_one_node
)));
10165 if (! TREE_CONSTANT (itype
))
10166 itype
= variable_size (itype
);
10167 else if (TREE_OVERFLOW (itype
))
10169 error ("overflow in array dimension");
10170 TREE_OVERFLOW (itype
) = 0;
10173 /* If we're a parm, we need to have a permanent type so
10174 mangling checks for re-use will work right. If both the
10175 element and index types are permanent, the array type
10177 if (decl_context
== PARM
10178 && allocation_temporary_p () && TREE_PERMANENT (type
))
10180 push_obstacks (&permanent_obstack
, &permanent_obstack
);
10181 itype
= build_index_type (itype
);
10185 itype
= build_index_type (itype
);
10188 resume_momentary (yes
);
10191 type
= build_cplus_array_type (type
, itype
);
10200 tree inner_parms
= CALL_DECLARATOR_PARMS (declarator
);
10201 tree inner_decl
= TREE_OPERAND (declarator
, 0);
10203 /* Declaring a function type.
10204 Make sure we have a valid type for the function to return. */
10206 /* We now know that the TYPE_QUALS don't apply to the
10207 decl, but to its return type. */
10208 type_quals
= TYPE_UNQUALIFIED
;
10210 /* Warn about some types functions can't return. */
10212 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10214 error ("`%s' declared as function returning a function", name
);
10215 type
= integer_type_node
;
10217 if (TREE_CODE (type
) == ARRAY_TYPE
)
10219 error ("`%s' declared as function returning an array", name
);
10220 type
= integer_type_node
;
10223 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
10224 inner_decl
= TREE_OPERAND (inner_decl
, 1);
10226 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
10227 inner_decl
= dname
;
10229 /* Pick up type qualifiers which should be applied to `this'. */
10230 quals
= CALL_DECLARATOR_QUALS (declarator
);
10232 /* Pick up the exception specifications. */
10233 raises
= CALL_DECLARATOR_EXCEPTION_SPEC (declarator
);
10235 /* Say it's a definition only for the CALL_EXPR
10236 closest to the identifier. */
10239 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
10240 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
10241 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
10243 if (ctype
== NULL_TREE
10244 && decl_context
== FIELD
10246 && (friendp
== 0 || dname
== current_class_name
))
10247 ctype
= current_class_type
;
10249 if (ctype
&& return_type
== return_conversion
)
10250 TYPE_HAS_CONVERSION (ctype
) = 1;
10251 if (ctype
&& constructor_name (ctype
) == dname
)
10253 /* We are within a class's scope. If our declarator name
10254 is the same as the class name, and we are defining
10255 a function, then it is a constructor/destructor, and
10256 therefore returns a void type. */
10258 if (flags
== DTOR_FLAG
)
10260 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
10261 not be declared const or volatile. A destructor
10262 may not be static. */
10264 error ("destructor cannot be static member function");
10267 cp_error ("destructors may not be `%s'",
10268 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10271 if (decl_context
== FIELD
)
10273 if (! member_function_or_else (ctype
, current_class_type
,
10274 "destructor for alien class `%s' cannot be a member"))
10275 return void_type_node
;
10278 else /* It's a constructor. */
10280 if (explicitp
== 1)
10282 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
10283 not be declared const or volatile. A constructor may
10284 not be virtual. A constructor may not be static. */
10286 error ("constructor cannot be static member function");
10289 pedwarn ("constructors cannot be declared virtual");
10294 cp_error ("constructors may not be `%s'",
10295 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10299 RID_BIT_TYPE tmp_bits
;
10300 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
10301 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
10302 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
10303 if (RIDBIT_ANY_SET (tmp_bits
))
10304 error ("return value type specifier for constructor ignored");
10306 type
= build_pointer_type (ctype
);
10307 if (decl_context
== FIELD
)
10309 if (! member_function_or_else (ctype
, current_class_type
,
10310 "constructor for alien class `%s' cannot be member"))
10311 return void_type_node
;
10312 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
10313 if (return_type
!= return_ctor
)
10317 if (decl_context
== FIELD
)
10323 error ("can't initialize friend function `%s'", name
);
10326 /* Cannot be both friend and virtual. */
10327 error ("virtual functions cannot be friends");
10328 RIDBIT_RESET (RID_FRIEND
, specbits
);
10331 if (decl_context
== NORMAL
)
10332 error ("friend declaration not in class definition");
10333 if (current_function_decl
&& funcdef_flag
)
10334 cp_error ("can't define friend function `%s' in a local class definition",
10338 /* Construct the function type and go to the next
10339 inner layer of declarator. */
10341 declarator
= TREE_OPERAND (declarator
, 0);
10343 /* FIXME: This is where default args should be fully
10346 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
10348 if (declarator
&& flags
== DTOR_FLAG
)
10350 /* A destructor declared in the body of a class will
10351 be represented as a BIT_NOT_EXPR. But, we just
10352 want the underlying IDENTIFIER. */
10353 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
10354 declarator
= TREE_OPERAND (declarator
, 0);
10356 if (strict_prototype
== 0 && arg_types
== NULL_TREE
)
10357 arg_types
= void_list_node
;
10358 else if (arg_types
== NULL_TREE
10359 || arg_types
!= void_list_node
)
10361 cp_error ("destructors may not have parameters");
10362 arg_types
= void_list_node
;
10363 last_function_parms
= NULL_TREE
;
10367 /* ANSI says that `const int foo ();'
10368 does not make the function foo const. */
10369 type
= build_function_type (type
, arg_types
);
10373 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
10374 if (TREE_PURPOSE (t
)
10375 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
10377 add_defarg_fn (type
);
10386 /* Filter out pointers-to-references and references-to-references.
10387 We can get these if a TYPE_DECL is used. */
10389 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10391 error ("cannot declare %s to references",
10392 TREE_CODE (declarator
) == ADDR_EXPR
10393 ? "references" : "pointers");
10394 declarator
= TREE_OPERAND (declarator
, 0);
10398 if (TREE_CODE (type
) == OFFSET_TYPE
10399 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
10400 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
10402 cp_error ("cannot declare pointer to `%#T' member",
10404 type
= TREE_TYPE (type
);
10407 /* Merge any constancy or volatility into the target type
10408 for the pointer. */
10410 /* We now know that the TYPE_QUALS don't apply to the decl,
10411 but to the target of the pointer. */
10412 type_quals
= TYPE_UNQUALIFIED
;
10414 if (TREE_CODE (declarator
) == ADDR_EXPR
)
10416 if (TREE_CODE (type
) == VOID_TYPE
)
10417 error ("invalid type: `void &'");
10419 type
= build_reference_type (type
);
10421 else if (TREE_CODE (type
) == METHOD_TYPE
)
10422 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10424 type
= build_pointer_type (type
);
10426 /* Process a list of type modifier keywords (such as
10427 const or volatile) that were given inside the `*' or `&'. */
10429 if (TREE_TYPE (declarator
))
10431 register tree typemodlist
;
10437 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
10438 typemodlist
= TREE_CHAIN (typemodlist
))
10440 tree qualifier
= TREE_VALUE (typemodlist
);
10442 if (qualifier
== ridpointers
[(int) RID_CONST
])
10444 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
10446 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
10451 error ("invalid type modifier within pointer declarator");
10455 pedwarn ("duplicate `const'");
10457 pedwarn ("duplicate `volatile'");
10459 pedwarn ("duplicate `restrict'");
10461 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10462 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10463 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10464 if (TREE_CODE (declarator
) == ADDR_EXPR
10465 && (constp
|| volatilep
))
10468 pedwarn ("discarding `const' applied to a reference");
10470 pedwarn ("discarding `volatile' applied to a reference");
10471 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
10473 type
= cp_build_qualified_type (type
, type_quals
);
10475 declarator
= TREE_OPERAND (declarator
, 0);
10481 /* We have converted type names to NULL_TREE if the
10482 name was bogus, or to a _TYPE node, if not.
10484 The variable CTYPE holds the type we will ultimately
10485 resolve to. The code here just needs to build
10486 up appropriate member types. */
10487 tree sname
= TREE_OPERAND (declarator
, 1);
10490 /* Destructors can have their visibilities changed as well. */
10491 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
10492 sname
= TREE_OPERAND (sname
, 0);
10494 if (TREE_COMPLEXITY (declarator
) == 0)
10495 /* This needs to be here, in case we are called
10496 multiple times. */ ;
10497 else if (TREE_COMPLEXITY (declarator
) == -1)
10498 /* Namespace member. */
10499 pop_decl_namespace ();
10500 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
10501 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10502 else if (! IS_AGGR_TYPE_CODE
10503 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
10505 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
10507 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10508 that refer to ctype. They couldn't be resolved earlier
10509 because we hadn't pushed into the class yet.
10510 Example: resolve 'B<T>::type' in
10511 'B<typename B<T>::type> B<T>::f () { }'. */
10512 if (current_template_parms
10513 && uses_template_parms (type
)
10514 && uses_template_parms (current_class_type
))
10516 tree args
= current_template_args ();
10517 type
= tsubst (type
, args
, /*complain=*/1, NULL_TREE
);
10520 /* This pop_nested_class corresponds to the
10521 push_nested_class used to push into class scope for
10522 parsing the argument list of a function decl, in
10524 pop_nested_class ();
10525 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10528 my_friendly_abort (16);
10530 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10532 /* We had a reference to a global decl, or
10533 perhaps we were given a non-aggregate typedef,
10534 in which case we cleared this out, and should just
10535 keep going as though it wasn't there. */
10536 declarator
= sname
;
10539 ctype
= TREE_OPERAND (declarator
, 0);
10542 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
10544 if (CLASSTYPE_TEMPLATE_INFO (t
) &&
10545 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
10546 template_count
+= 1;
10547 t
= TYPE_MAIN_DECL (t
);
10548 if (DECL_LANG_SPECIFIC (t
))
10549 t
= DECL_CLASS_CONTEXT (t
);
10554 if (sname
== NULL_TREE
)
10557 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10559 /* This is the `standard' use of the scoping operator:
10560 basetype :: member . */
10562 if (ctype
== current_class_type
)
10568 Is this ill-formed? */
10571 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10574 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10576 if (current_class_type
== NULL_TREE
10578 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10579 TYPE_ARG_TYPES (type
));
10582 cp_error ("cannot declare member function `%T::%s' within `%T'",
10583 ctype
, name
, current_class_type
);
10584 return void_type_node
;
10587 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10588 || TYPE_SIZE (complete_type (ctype
)) != NULL_TREE
)
10590 /* Have to move this code elsewhere in this function.
10591 this code is used for i.e., typedef int A::M; M *pm;
10593 It is? How? jason 10/2/94 */
10595 if (current_class_type
)
10597 cp_error ("cannot declare member `%T::%s' within `%T'",
10598 ctype
, name
, current_class_type
);
10599 return void_type_node
;
10601 type
= build_offset_type (ctype
, type
);
10603 else if (uses_template_parms (ctype
))
10605 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10607 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
10608 TYPE_ARG_TYPES (type
));
10612 cp_error ("structure `%T' not yet defined", ctype
);
10613 return error_mark_node
;
10616 declarator
= sname
;
10618 else if (TREE_CODE (sname
) == SCOPE_REF
)
10619 my_friendly_abort (17);
10623 declarator
= TREE_OPERAND (declarator
, 1);
10624 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
10625 /* In this case, we will deal with it later. */
10629 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10630 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10631 TYPE_ARG_TYPES (type
));
10633 type
= build_offset_type (ctype
, type
);
10640 declarator
= TREE_OPERAND (declarator
, 0);
10645 case ENUMERAL_TYPE
:
10646 declarator
= NULL_TREE
;
10650 declarator
= NULL_TREE
;
10654 my_friendly_abort (158);
10658 /* See the comment for the TREE_LIST case, above. */
10661 if (! ignore_attrs
)
10662 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10664 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
10666 attrlist
= build_decl_list (NULL_TREE
, inner_attrs
);
10669 /* Now TYPE has the actual type. */
10671 if (explicitp
== 1)
10673 error ("only constructors can be declared `explicit'");
10677 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10679 if (type_quals
& TYPE_QUAL_CONST
)
10681 error ("const `%s' cannot be declared `mutable'", name
);
10682 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10686 error ("static `%s' cannot be declared `mutable'", name
);
10687 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10691 if (declarator
== NULL_TREE
10692 || TREE_CODE (declarator
) == IDENTIFIER_NODE
10693 || (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
10694 && (TREE_CODE (type
) == FUNCTION_TYPE
10695 || TREE_CODE (type
) == METHOD_TYPE
)))
10697 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10699 cp_error ("template-id `%D' used as a declarator", declarator
);
10700 declarator
= dname
;
10703 /* Unexpected declarator format. */
10704 my_friendly_abort (990210);
10706 /* If this is declaring a typedef name, return a TYPE_DECL. */
10708 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
10712 /* Note that the grammar rejects storage classes
10713 in typenames, fields or parameters. */
10714 if (current_lang_name
== lang_name_java
)
10715 TYPE_FOR_JAVA (type
) = 1;
10717 if (decl_context
== FIELD
)
10719 if (declarator
== constructor_name (current_class_type
))
10720 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10722 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10726 /* Make sure this typedef lives as long as its type,
10727 since it might be used as a template parameter. */
10728 if (type
!= error_mark_node
)
10729 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
10730 if (processing_template_decl
)
10731 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10733 decl
= build_decl (TYPE_DECL
, declarator
, type
);
10734 if (type
!= error_mark_node
)
10738 /* If the user declares "typedef struct {...} foo" then the
10739 struct will have an anonymous name. Fill that name in now.
10740 Nothing can refer to it, so nothing needs know about the name
10742 if (type
!= error_mark_node
10743 && TYPE_NAME (type
)
10744 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10745 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
))
10746 && CP_TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
10748 tree oldname
= TYPE_NAME (type
);
10751 /* Replace the anonymous name with the real name everywhere. */
10752 lookup_tag_reverse (type
, declarator
);
10753 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10754 if (TYPE_NAME (t
) == oldname
)
10755 TYPE_NAME (t
) = decl
;
10757 if (TYPE_LANG_SPECIFIC (type
))
10758 TYPE_WAS_ANONYMOUS (type
) = 1;
10760 /* If this is a typedef within a template class, the nested
10761 type is a (non-primary) template. The name for the
10762 template needs updating as well. */
10763 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10764 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10765 = TYPE_IDENTIFIER (type
);
10767 /* XXX Temporarily set the scope.
10768 When returning, start_decl expects it as NULL_TREE,
10769 and will then then set it using pushdecl. */
10770 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
10771 if (current_class_type
)
10772 DECL_CONTEXT (decl
) = current_class_type
;
10774 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10776 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
10777 DECL_ASSEMBLER_NAME (decl
)
10778 = get_identifier (build_overload_name (type
, 1, 1));
10779 DECL_CONTEXT (decl
) = NULL_TREE
;
10781 /* FIXME remangle member functions; member functions of a
10782 type with external linkage have external linkage. */
10785 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10787 cp_error_at ("typedef name may not be class-qualified", decl
);
10792 if (ctype
== NULL_TREE
)
10794 if (TREE_CODE (type
) != METHOD_TYPE
)
10795 cp_error_at ("invalid type qualifier for non-method type", decl
);
10797 ctype
= TYPE_METHOD_BASETYPE (type
);
10799 if (ctype
!= NULL_TREE
)
10800 grok_method_quals (ctype
, decl
, quals
);
10803 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10804 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10805 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10807 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10808 error ("non-object member `%s' cannot be declared mutable", name
);
10810 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
10811 inlinep
, friendp
, raises
!= NULL_TREE
);
10814 error ("typedef declaration includes an initializer");
10819 /* Detect the case of an array type of unspecified size
10820 which came, as such, direct from a typedef name.
10821 We must copy the type, so that each identifier gets
10822 a distinct type, so that each identifier's size can be
10823 controlled separately by its own initializer. */
10825 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
10826 && TYPE_DOMAIN (type
) == NULL_TREE
)
10828 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
10831 /* If this is a type name (such as, in a cast or sizeof),
10832 compute the type and return it now. */
10834 if (decl_context
== TYPENAME
)
10836 /* Note that the grammar rejects storage classes
10837 in typenames, fields or parameters. */
10838 if (type_quals
!= TYPE_UNQUALIFIED
)
10839 type_quals
= TYPE_UNQUALIFIED
;
10841 /* Special case: "friend class foo" looks like a TYPENAME context. */
10844 if (type_quals
!= TYPE_UNQUALIFIED
)
10846 cp_error ("type qualifiers specified for friend class declaration");
10847 type_quals
= TYPE_UNQUALIFIED
;
10851 cp_error ("`inline' specified for friend class declaration");
10855 /* Only try to do this stuff if we didn't already give up. */
10856 if (type
!= integer_type_node
)
10858 /* A friendly class? */
10859 if (current_class_type
)
10860 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
10862 error ("trying to make class `%s' a friend of global scope",
10863 TYPE_NAME_STRING (type
));
10864 type
= void_type_node
;
10869 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
10870 if (ctype
== NULL_TREE
)
10872 my_friendly_assert (TREE_CODE (type
) == METHOD_TYPE
, 159);
10873 ctype
= TYPE_METHOD_BASETYPE (type
);
10875 grok_method_quals (ctype
, dummy
, quals
);
10876 type
= TREE_TYPE (dummy
);
10881 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
10882 && decl_context
!= CATCHPARM
10883 && TREE_CODE (type
) != UNION_TYPE
10886 cp_error ("abstract declarator `%T' used as declaration", type
);
10887 declarator
= make_anon_name ();
10890 /* `void' at top level (not within pointer)
10891 is allowed only in typedefs or type names.
10892 We don't complain about parms either, but that is because
10893 a better error message can be made later. */
10895 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
10898 error ("unnamed variable or field declared void");
10899 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10901 if (IDENTIFIER_OPNAME_P (declarator
))
10902 my_friendly_abort (356);
10904 error ("variable or field `%s' declared void", name
);
10907 error ("variable or field declared void");
10908 type
= integer_type_node
;
10911 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10912 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10914 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10916 if (ctype
|| in_namespace
)
10917 error ("cannot use `::' in parameter declaration");
10919 /* A parameter declared as an array of T is really a pointer to T.
10920 One declared as a function is really a pointer to a function.
10921 One declared as a member is really a pointer to member. */
10923 if (TREE_CODE (type
) == ARRAY_TYPE
)
10925 /* Transfer const-ness of array into that of type pointed to. */
10926 type
= build_pointer_type (TREE_TYPE (type
));
10927 type_quals
= TYPE_UNQUALIFIED
;
10929 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10930 type
= build_pointer_type (type
);
10931 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10932 type
= build_pointer_type (type
);
10933 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
10935 error ("declaration of `%s' as void", name
);
10941 register tree decl
;
10943 if (decl_context
== PARM
)
10945 decl
= build_decl (PARM_DECL
, declarator
, type
);
10947 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
10948 inlinep
, friendp
, raises
!= NULL_TREE
);
10950 /* Compute the type actually passed in the parmlist,
10951 for the case where there is no prototype.
10952 (For example, shorts and chars are passed as ints.)
10953 When there is a prototype, this is overridden later. */
10955 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
10957 else if (decl_context
== FIELD
)
10959 if (type
== error_mark_node
)
10961 /* Happens when declaring arrays of sizes which
10962 are error_mark_node, for example. */
10965 else if (in_namespace
&& !friendp
)
10967 /* Something like struct S { int N::j; }; */
10968 cp_error ("invalid use of `::'");
10971 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10974 tree function_context
;
10976 /* We catch the others as conflicts with the builtin
10978 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
10980 cp_error ("function `%D' cannot be declared friend",
10987 if (ctype
== NULL_TREE
)
10988 ctype
= current_class_type
;
10990 if (ctype
== NULL_TREE
)
10992 cp_error ("can't make `%D' into a method -- not in a class",
10994 return void_type_node
;
10997 /* ``A union may [ ... ] not [ have ] virtual functions.''
10999 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11001 cp_error ("function `%D' declared virtual inside a union",
11003 return void_type_node
;
11006 if (declarator
== ansi_opname
[(int) NEW_EXPR
]
11007 || declarator
== ansi_opname
[(int) VEC_NEW_EXPR
]
11008 || declarator
== ansi_opname
[(int) DELETE_EXPR
]
11009 || declarator
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11013 cp_error ("`%D' cannot be declared virtual, since it is always static",
11018 else if (staticp
< 2)
11019 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11020 TYPE_ARG_TYPES (type
));
11023 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11024 function_context
= (ctype
!= NULL_TREE
) ?
11025 hack_decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11026 publicp
= (! friendp
|| ! staticp
)
11027 && function_context
== NULL_TREE
;
11028 decl
= grokfndecl (ctype
, type
,
11029 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
11030 ? declarator
: dname
,
11032 virtualp
, flags
, quals
, raises
,
11033 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
11034 funcdef_flag
, template_count
, in_namespace
);
11035 if (decl
== NULL_TREE
)
11038 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11039 /* The decl and setting of decl_machine_attr is also turned off. */
11040 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
11043 /* [class.conv.ctor]
11045 A constructor declared without the function-specifier
11046 explicit that can be called with a single parameter
11047 specifies a conversion from the type of its first
11048 parameter to the type of its class. Such a constructor
11049 is called a converting constructor. */
11050 if (explicitp
== 2)
11051 DECL_NONCONVERTING_P (decl
) = 1;
11052 else if (DECL_CONSTRUCTOR_P (decl
))
11054 /* The constructor can be called with exactly one
11055 parameter if there is at least one parameter, and
11056 any subsequent parameters have default arguments.
11057 We don't look at the first parameter, which is
11058 really just the `this' parameter for the new
11061 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
11063 /* Skip the `in_chrg' argument too, if present. */
11064 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl
)))
11065 arg_types
= TREE_CHAIN (arg_types
);
11067 if (arg_types
== void_list_node
11069 && TREE_CHAIN (arg_types
)
11070 && TREE_CHAIN (arg_types
) != void_list_node
11071 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
11072 DECL_NONCONVERTING_P (decl
) = 1;
11075 else if (TREE_CODE (type
) == METHOD_TYPE
)
11077 /* We only get here for friend declarations of
11078 members of other classes. */
11079 /* All method decls are public, so tell grokfndecl to set
11080 TREE_PUBLIC, also. */
11081 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
11082 virtualp
, flags
, quals
, raises
,
11083 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
11084 template_count
, in_namespace
);
11085 if (decl
== NULL_TREE
)
11088 else if (!staticp
&& ! processing_template_decl
11089 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
11090 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
11093 cp_error ("field `%D' has incomplete type", declarator
);
11095 cp_error ("name `%T' has incomplete type", type
);
11097 /* If we're instantiating a template, tell them which
11098 instantiation made the field's type be incomplete. */
11099 if (current_class_type
11100 && TYPE_NAME (current_class_type
)
11101 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
11102 && declspecs
&& TREE_VALUE (declspecs
)
11103 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
11104 cp_error (" in instantiation of template `%T'",
11105 current_class_type
);
11107 type
= error_mark_node
;
11114 error ("`%s' is neither function nor method; cannot be declared friend",
11115 IDENTIFIER_POINTER (declarator
));
11123 /* Friends are treated specially. */
11124 if (ctype
== current_class_type
)
11125 warning ("member functions are implicitly friends of their class");
11128 tree t
= NULL_TREE
;
11129 if (decl
&& DECL_NAME (decl
))
11131 if (template_class_depth (current_class_type
) == 0)
11134 = check_explicit_specialization
11136 template_count
, 2 * (funcdef_flag
!= 0) + 4);
11137 if (decl
== error_mark_node
)
11138 return error_mark_node
;
11141 t
= do_friend (ctype
, declarator
, decl
,
11142 last_function_parms
, attrlist
, flags
, quals
,
11145 if (t
&& funcdef_flag
)
11148 return void_type_node
;
11152 /* Structure field. It may not be a function, except for C++ */
11154 if (decl
== NULL_TREE
)
11160 /* An attempt is being made to initialize a non-static
11161 member. But, from [class.mem]:
11163 4 A member-declarator can contain a
11164 constant-initializer only if it declares a static
11165 member (_class.static_) of integral or enumeration
11166 type, see _class.static.data_.
11168 This used to be relatively common practice, but
11169 the rest of the compiler does not correctly
11170 handle the initialization unless the member is
11171 static so we make it static below. */
11172 cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
11174 cp_pedwarn ("making `%D' static", declarator
);
11178 if (uses_template_parms (type
))
11179 /* We'll check at instantiation time. */
11181 else if (check_static_variable_definition (declarator
,
11183 /* If we just return the declaration, crashes
11184 will sometimes occur. We therefore return
11185 void_type_node, as if this was a friend
11186 declaration, to cause callers to completely
11187 ignore this declaration. */
11188 return void_type_node
;
11191 /* 9.2p13 [class.mem] */
11192 if (declarator
== constructor_name (current_class_type
)
11193 /* Divergence from the standard: In extern "C", we
11194 allow non-static data members here, because C does
11195 and /usr/include/netinet/in.h uses that. */
11196 && (staticp
|| ! in_system_header
))
11197 cp_pedwarn ("ANSI C++ forbids data member `%D' with same name as enclosing class",
11202 /* C++ allows static class members. All other work
11203 for this is done by grokfield. */
11204 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
11205 TREE_STATIC (decl
) = 1;
11206 /* In class context, 'static' means public access. */
11207 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
11211 decl
= build_lang_decl (FIELD_DECL
, declarator
, type
);
11212 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11214 DECL_MUTABLE_P (decl
) = 1;
11215 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11219 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
11220 inlinep
, friendp
, raises
!= NULL_TREE
);
11223 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11225 tree original_name
;
11231 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
11232 original_name
= dname
;
11234 original_name
= declarator
;
11236 if (RIDBIT_SETP (RID_AUTO
, specbits
))
11237 error ("storage class `auto' invalid for function `%s'", name
);
11238 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11239 error ("storage class `register' invalid for function `%s'", name
);
11241 /* Function declaration not at top level.
11242 Storage classes other than `extern' are not allowed
11243 and `extern' makes no difference. */
11244 if (! toplevel_bindings_p ()
11245 && (RIDBIT_SETP (RID_STATIC
, specbits
)
11246 || RIDBIT_SETP (RID_INLINE
, specbits
))
11249 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11250 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
11252 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
11255 if (ctype
== NULL_TREE
)
11259 error ("virtual non-class function `%s'", name
);
11263 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
11264 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11265 TYPE_ARG_TYPES (type
));
11267 /* Record presence of `static'. */
11268 publicp
= (ctype
!= NULL_TREE
11269 || RIDBIT_SETP (RID_EXTERN
, specbits
)
11270 || !RIDBIT_SETP (RID_STATIC
, specbits
));
11272 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
11273 virtualp
, flags
, quals
, raises
,
11275 publicp
, inlinep
, funcdef_flag
,
11276 template_count
, in_namespace
);
11277 if (decl
== NULL_TREE
)
11282 int illegal_static
= 0;
11284 /* Don't allow a static member function in a class, and forbid
11285 declaring main to be static. */
11286 if (TREE_CODE (type
) == METHOD_TYPE
)
11288 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
11289 illegal_static
= 1;
11291 else if (current_function_decl
)
11293 /* FIXME need arm citation */
11294 error ("cannot declare static function inside another function");
11295 illegal_static
= 1;
11298 if (illegal_static
)
11301 RIDBIT_RESET (RID_STATIC
, specbits
);
11307 /* It's a variable. */
11309 /* An uninitialized decl with `extern' is a reference. */
11310 decl
= grokvardecl (type
, declarator
, &specbits
,
11312 (type_quals
& TYPE_QUAL_CONST
) != 0,
11314 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
11315 inlinep
, friendp
, raises
!= NULL_TREE
);
11319 DECL_CONTEXT (decl
) = ctype
;
11322 cp_pedwarn ("static member `%D' re-declared as static", decl
);
11324 RIDBIT_RESET (RID_STATIC
, specbits
);
11326 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
11328 cp_error ("static member `%D' declared `register'", decl
);
11329 RIDBIT_RESET (RID_REGISTER
, specbits
);
11331 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
11333 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11335 RIDBIT_RESET (RID_EXTERN
, specbits
);
11340 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11342 error ("`%s' cannot be declared mutable", name
);
11345 /* Record `register' declaration for warnings on &
11346 and in case doing stupid register allocation. */
11348 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11349 DECL_REGISTER (decl
) = 1;
11351 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
11352 DECL_THIS_EXTERN (decl
) = 1;
11354 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11355 DECL_THIS_STATIC (decl
) = 1;
11357 /* Record constancy and volatility. There's no need to do this
11358 when processing a template; we'll do this for the instantiated
11359 declaration based on the type of DECL. */
11360 if (!processing_template_decl
)
11361 c_apply_type_quals_to_decl (type_quals
, decl
);
11367 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11368 An empty exprlist is a parmlist. An exprlist which
11369 contains only identifiers at the global level
11370 is a parmlist. Otherwise, it is an exprlist. */
11373 parmlist_is_exprlist (exprs
)
11376 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
11379 if (toplevel_bindings_p ())
11381 /* At the global level, if these are all identifiers,
11382 then it is a parmlist. */
11385 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
11387 exprs
= TREE_CHAIN (exprs
);
11394 /* Subroutine of start_function. Ensure that each of the parameter
11395 types (as listed in PARMS) is complete, as is required for a
11396 function definition. */
11399 require_complete_types_for_parms (parms
)
11404 tree type
= TREE_TYPE (parms
);
11405 if (TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
11407 if (DECL_NAME (parms
))
11408 error ("parameter `%s' has incomplete type",
11409 IDENTIFIER_POINTER (DECL_NAME (parms
)));
11411 error ("parameter has incomplete type");
11412 TREE_TYPE (parms
) = error_mark_node
;
11415 layout_decl (parms
, 0);
11417 parms
= TREE_CHAIN (parms
);
11421 /* Returns DECL if DECL is a local variable (or parameter). Returns
11422 NULL_TREE otherwise. */
11425 local_variable_p (t
)
11428 if ((TREE_CODE (t
) == VAR_DECL
11429 /* A VAR_DECL with a context that is a _TYPE is a static data
11431 && !TYPE_P (CP_DECL_CONTEXT (t
))
11432 /* Any other non-local variable must be at namespace scope. */
11433 && TREE_CODE (CP_DECL_CONTEXT (t
)) != NAMESPACE_DECL
)
11434 || (TREE_CODE (t
) == PARM_DECL
))
11440 /* Check that ARG, which is a default-argument expression for a
11441 parameter DECL, is legal. Returns ARG, or ERROR_MARK_NODE, if
11442 something goes wrong. DECL may also be a _TYPE node, rather than a
11443 DECL, if there is no DECL available. */
11446 check_default_argument (decl
, arg
)
11453 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11454 /* We get a DEFAULT_ARG when looking at an in-class declaration
11455 with a default argument. Ignore the argument for now; we'll
11456 deal with it after the class is complete. */
11459 if (processing_template_decl
|| uses_template_parms (arg
))
11460 /* We don't do anything checking until instantiation-time. Note
11461 that there may be uninstantiated arguments even for an
11462 instantiated function, since default arguments are not
11463 instantiated until they are needed. */
11472 decl_type
= TREE_TYPE (decl
);
11474 if (arg
== error_mark_node
11475 || decl
== error_mark_node
11476 || TREE_TYPE (arg
) == error_mark_node
11477 || decl_type
== error_mark_node
)
11478 /* Something already went wrong. There's no need to check
11480 return error_mark_node
;
11482 /* [dcl.fct.default]
11484 A default argument expression is implicitly converted to the
11486 if (!TREE_TYPE (arg
)
11487 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
))
11490 cp_error ("default argument for `%#D' has type `%T'",
11491 decl
, TREE_TYPE (arg
));
11493 cp_error ("default argument for parameter of type `%T' has type `%T'",
11494 decl_type
, TREE_TYPE (arg
));
11496 return error_mark_node
;
11499 /* [dcl.fct.default]
11501 Local variables shall not be used in default argument
11504 The keyword `this' shall not be used in a default argument of a
11505 member function. */
11506 var
= search_tree (arg
, local_variable_p
);
11509 cp_error ("default argument `%E' uses local variable `%D'",
11511 return error_mark_node
;
11518 /* Decode the list of parameter types for a function type.
11519 Given the list of things declared inside the parens,
11520 return a list of types.
11522 The list we receive can have three kinds of elements:
11523 an IDENTIFIER_NODE for names given without types,
11524 a TREE_LIST node for arguments given as typespecs or names with typespecs,
11525 or void_type_node, to mark the end of an argument list
11526 when additional arguments are not permitted (... was not used).
11528 FUNCDEF_FLAG is nonzero for a function definition, 0 for
11529 a mere declaration. A nonempty identifier-list gets an error message
11530 when FUNCDEF_FLAG is zero.
11531 If FUNCDEF_FLAG is 1, then parameter types must be complete.
11532 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11534 If all elements of the input list contain types,
11535 we return a list of the types.
11536 If all elements contain no type (except perhaps a void_type_node
11537 at the end), we return a null list.
11538 If some have types and some do not, it is an error, and we
11539 return a null list.
11541 Also set last_function_parms to either
11542 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11543 A list of names is converted to a chain of PARM_DECLs
11544 by store_parm_decls so that ultimately it is always a chain of decls.
11546 Note that in C++, parameters can take default values. These default
11547 values are in the TREE_PURPOSE field of the TREE_LIST. It is
11548 an error to specify default values which are followed by parameters
11549 that have no default values, or an ELLIPSES. For simplicities sake,
11550 only parameters which are specified with their types can take on
11554 grokparms (first_parm
, funcdef_flag
)
11558 tree result
= NULL_TREE
;
11559 tree decls
= NULL_TREE
;
11561 if (first_parm
!= NULL_TREE
11562 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
11564 if (! funcdef_flag
)
11565 pedwarn ("parameter names (without types) in function declaration");
11566 last_function_parms
= first_parm
;
11569 else if (first_parm
!= NULL_TREE
11570 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
11571 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
11572 my_friendly_abort (145);
11575 /* Types were specified. This is a list of declarators
11576 each represented as a TREE_LIST node. */
11577 register tree parm
, chain
;
11578 int any_init
= 0, any_error
= 0;
11580 if (first_parm
!= NULL_TREE
)
11582 tree last_result
= NULL_TREE
;
11583 tree last_decl
= NULL_TREE
;
11585 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
11587 tree type
= NULL_TREE
, list_node
= parm
;
11588 register tree decl
= TREE_VALUE (parm
);
11589 tree init
= TREE_PURPOSE (parm
);
11591 chain
= TREE_CHAIN (parm
);
11592 /* @@ weak defense against parse errors. */
11593 if (TREE_CODE (decl
) != VOID_TYPE
11594 && TREE_CODE (decl
) != TREE_LIST
)
11596 /* Give various messages as the need arises. */
11597 if (TREE_CODE (decl
) == STRING_CST
)
11598 cp_error ("invalid string constant `%E'", decl
);
11599 else if (TREE_CODE (decl
) == INTEGER_CST
)
11600 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11604 if (TREE_CODE (decl
) != VOID_TYPE
)
11606 decl
= grokdeclarator (TREE_VALUE (decl
),
11607 TREE_PURPOSE (decl
),
11608 PARM
, init
!= NULL_TREE
,
11610 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11613 /* Top-level qualifiers on the parameters are
11614 ignored for function types. */
11615 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
11617 if (TREE_CODE (type
) == VOID_TYPE
)
11618 decl
= void_type_node
;
11619 else if (TREE_CODE (type
) == METHOD_TYPE
)
11621 if (DECL_NAME (decl
))
11622 /* Cannot use the decl here because
11623 we don't have DECL_CONTEXT set up yet. */
11624 cp_error ("parameter `%D' invalidly declared method type",
11627 error ("parameter invalidly declared method type");
11628 type
= build_pointer_type (type
);
11629 TREE_TYPE (decl
) = type
;
11631 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11633 if (DECL_NAME (decl
))
11634 cp_error ("parameter `%D' invalidly declared offset type",
11637 error ("parameter invalidly declared offset type");
11638 type
= build_pointer_type (type
);
11639 TREE_TYPE (decl
) = type
;
11641 else if (abstract_virtuals_error (decl
, type
))
11642 any_error
= 1; /* Seems like a good idea. */
11643 else if (POINTER_TYPE_P (type
))
11646 while (POINTER_TYPE_P (t
)
11647 || (TREE_CODE (t
) == ARRAY_TYPE
11648 && TYPE_DOMAIN (t
) != NULL_TREE
))
11650 if (TREE_CODE (t
) == ARRAY_TYPE
)
11651 cp_error ("parameter type `%T' includes %s to array of unknown bound",
11653 TYPE_PTR_P (type
) ? "pointer" : "reference");
11657 if (TREE_CODE (decl
) == VOID_TYPE
)
11659 if (result
== NULL_TREE
)
11661 result
= void_list_node
;
11662 last_result
= result
;
11666 TREE_CHAIN (last_result
) = void_list_node
;
11667 last_result
= void_list_node
;
11670 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
11671 error ("`void' in parameter list must be entire list");
11675 /* Since there is a prototype, args are passed in their own types. */
11676 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
11677 if (PROMOTE_PROTOTYPES
11678 && (TREE_CODE (type
) == INTEGER_TYPE
11679 || TREE_CODE (type
) == ENUMERAL_TYPE
)
11680 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
11681 DECL_ARG_TYPE (decl
) = integer_type_node
;
11682 if (!any_error
&& init
)
11685 init
= check_default_argument (decl
, init
);
11690 if (decls
== NULL_TREE
)
11697 TREE_CHAIN (last_decl
) = decl
;
11700 if (! current_function_decl
&& TREE_PERMANENT (list_node
))
11702 TREE_PURPOSE (list_node
) = init
;
11703 TREE_VALUE (list_node
) = type
;
11704 TREE_CHAIN (list_node
) = NULL_TREE
;
11707 list_node
= saveable_tree_cons (init
, type
, NULL_TREE
);
11708 if (result
== NULL_TREE
)
11710 result
= list_node
;
11711 last_result
= result
;
11715 TREE_CHAIN (last_result
) = list_node
;
11716 last_result
= list_node
;
11720 TREE_CHAIN (last_result
) = NULL_TREE
;
11721 /* If there are no parameters, and the function does not end
11722 with `...', then last_decl will be NULL_TREE. */
11723 if (last_decl
!= NULL_TREE
)
11724 TREE_CHAIN (last_decl
) = NULL_TREE
;
11728 last_function_parms
= decls
;
11733 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11734 FUNCTION_TYPE with the newly parsed version of its default argument, which
11735 was previously digested as text. See snarf_defarg et al in lex.c. */
11738 replace_defarg (arg
, init
)
11741 if (! processing_template_decl
11742 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
11743 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11744 TREE_TYPE (init
), TREE_VALUE (arg
));
11745 TREE_PURPOSE (arg
) = init
;
11752 tree t
= FUNCTION_ARG_CHAIN (d
);
11753 if (DECL_CONSTRUCTOR_P (d
)
11754 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d
)))
11755 t
= TREE_CHAIN (t
);
11756 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
11757 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
11758 == DECL_CLASS_CONTEXT (d
))
11759 && (TREE_CHAIN (t
) == NULL_TREE
11760 || TREE_CHAIN (t
) == void_list_node
11761 || TREE_PURPOSE (TREE_CHAIN (t
))))
11766 /* These memoizing functions keep track of special properties which
11767 a class may have. `grok_ctor_properties' notices whether a class
11768 has a constructor of the form X(X&), and also complains
11769 if the class has a constructor of the form X(X).
11770 `grok_op_properties' takes notice of the various forms of
11771 operator= which are defined, as well as what sorts of type conversion
11772 may apply. Both functions take a FUNCTION_DECL as an argument. */
11775 grok_ctor_properties (ctype
, decl
)
11778 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
11779 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
11781 /* When a type has virtual baseclasses, a magical first int argument is
11782 added to any ctor so we can tell if the class has been initialized
11783 yet. This could screw things up in this function, so we deliberately
11784 ignore the leading int if we're in that situation. */
11785 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
11787 my_friendly_assert (parmtypes
11788 && TREE_VALUE (parmtypes
) == integer_type_node
,
11790 parmtypes
= TREE_CHAIN (parmtypes
);
11791 parmtype
= TREE_VALUE (parmtypes
);
11796 A non-template constructor for class X is a copy constructor if
11797 its first parameter is of type X&, const X&, volatile X& or const
11798 volatile X&, and either there are no other parameters or else all
11799 other parameters have default arguments. */
11800 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
11801 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
11802 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11803 || TREE_CHAIN (parmtypes
) == void_list_node
11804 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
11805 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11806 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11808 TYPE_HAS_INIT_REF (ctype
) = 1;
11809 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11810 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
11814 A declaration of a constructor for a class X is ill-formed if its
11815 first parameter is of type (optionally cv-qualified) X and either
11816 there are no other parameters or else all other parameters have
11819 We *don't* complain about member template instantiations that
11820 have this form, though; they can occur as we try to decide what
11821 constructor to use during overload resolution. Since overload
11822 resolution will never prefer such a constructor to the
11823 non-template copy constructor (which is either explicitly or
11824 implicitly defined), there's no need to worry about their
11825 existence. Theoretically, they should never even be
11826 instantiated, but that's hard to forestall. */
11827 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
11828 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11829 || TREE_CHAIN (parmtypes
) == void_list_node
11830 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
11831 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11832 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11834 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11836 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
11839 else if (TREE_CODE (parmtype
) == VOID_TYPE
11840 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
11841 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
11846 /* An operator with this name can be either unary or binary. */
11852 return (name
== ansi_opname
[(int) INDIRECT_REF
]
11853 || name
== ansi_opname
[(int) ADDR_EXPR
]
11854 || name
== ansi_opname
[(int) NEGATE_EXPR
]
11855 || name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11856 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]
11857 || name
== ansi_opname
[(int) CONVERT_EXPR
]);
11860 /* An operator with this name can only be unary. */
11866 return (name
== ansi_opname
[(int) TRUTH_NOT_EXPR
]
11867 || name
== ansi_opname
[(int) BIT_NOT_EXPR
]
11868 || name
== ansi_opname
[(int) COMPONENT_REF
]
11869 || IDENTIFIER_TYPENAME_P (name
));
11872 /* Do a little sanity-checking on how they declared their operator. */
11875 grok_op_properties (decl
, virtualp
, friendp
)
11877 int virtualp
, friendp
;
11879 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11880 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11881 tree name
= DECL_NAME (decl
);
11883 if (current_class_type
== NULL_TREE
)
11890 A user-declared copy assignment operator X::operator= is a
11891 non-static non-template member function of class X with
11892 exactly one parameter of type X, X&, const X&, volatile X& or
11893 const volatile X&. */
11894 if (name
== ansi_opname
[(int) MODIFY_EXPR
]
11895 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11896 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11898 else if (name
== ansi_opname
[(int) CALL_EXPR
])
11899 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
11900 else if (name
== ansi_opname
[(int) ARRAY_REF
])
11901 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
11902 else if (name
== ansi_opname
[(int) COMPONENT_REF
]
11903 || name
== ansi_opname
[(int) MEMBER_REF
])
11904 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
11905 else if (name
== ansi_opname
[(int) NEW_EXPR
])
11906 TYPE_GETS_NEW (current_class_type
) |= 1;
11907 else if (name
== ansi_opname
[(int) DELETE_EXPR
])
11908 TYPE_GETS_DELETE (current_class_type
) |= 1;
11909 else if (name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11910 TYPE_GETS_NEW (current_class_type
) |= 2;
11911 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11912 TYPE_GETS_DELETE (current_class_type
) |= 2;
11915 if (name
== ansi_opname
[(int) NEW_EXPR
]
11916 || name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11918 /* When the compiler encounters the definition of A::operator new, it
11919 doesn't look at the class declaration to find out if it's static. */
11921 revert_static_member_fn (&decl
, NULL
, NULL
);
11923 /* Take care of function decl if we had syntax errors. */
11924 if (argtypes
== NULL_TREE
)
11926 = build_function_type (ptr_type_node
,
11927 hash_tree_chain (integer_type_node
,
11930 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11932 else if (name
== ansi_opname
[(int) DELETE_EXPR
]
11933 || name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11936 revert_static_member_fn (&decl
, NULL
, NULL
);
11938 if (argtypes
== NULL_TREE
)
11940 = build_function_type (void_type_node
,
11941 hash_tree_chain (ptr_type_node
,
11945 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11947 if (! friendp
&& name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
11948 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
11949 != void_list_node
))
11950 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type
) = 1;
11955 /* An operator function must either be a non-static member function
11956 or have at least one parameter of a class, a reference to a class,
11957 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11958 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11960 if (IDENTIFIER_TYPENAME_P (name
)
11961 || name
== ansi_opname
[(int) CALL_EXPR
]
11962 || name
== ansi_opname
[(int) MODIFY_EXPR
]
11963 || name
== ansi_opname
[(int) COMPONENT_REF
]
11964 || name
== ansi_opname
[(int) ARRAY_REF
])
11965 cp_error ("`%D' must be a nonstatic member function", decl
);
11970 if (DECL_STATIC_FUNCTION_P (decl
))
11971 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
11974 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
11976 tree arg
= TREE_VALUE (p
);
11977 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
11978 arg
= TREE_TYPE (arg
);
11980 /* This lets bad template code slip through. */
11981 if (IS_AGGR_TYPE (arg
)
11982 || TREE_CODE (arg
) == ENUMERAL_TYPE
11983 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
11984 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11988 ("`%D' must have an argument of class or enumerated type",
11995 if (name
== ansi_opname
[(int) CALL_EXPR
])
11996 return; /* No restrictions on args. */
11998 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
12000 tree t
= TREE_TYPE (name
);
12001 if (TREE_CODE (t
) == VOID_TYPE
)
12002 pedwarn ("void is not a valid type conversion operator");
12003 else if (! friendp
)
12005 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
12006 const char *what
= 0;
12008 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
12010 if (t
== current_class_type
)
12011 what
= "the same type";
12012 /* Don't force t to be complete here. */
12013 else if (IS_AGGR_TYPE (t
)
12015 && DERIVED_FROM_P (t
, current_class_type
))
12016 what
= "a base class";
12019 warning ("conversion to %s%s will never use a type conversion operator",
12020 ref
? "a reference to " : "", what
);
12024 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
12028 if (list_length (argtypes
) != 3 && methodp
)
12030 cp_error ("`%D' must take exactly one argument", decl
);
12033 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
12035 if (copy_assignment_arg_p (parmtype
, virtualp
)
12038 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
12039 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
12040 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
12041 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
12044 else if (name
== ansi_opname
[(int) COND_EXPR
])
12047 cp_error ("ANSI C++ prohibits overloading operator ?:");
12049 else if (ambi_op_p (name
))
12051 if (list_length (argtypes
) == 2)
12053 else if (list_length (argtypes
) == 3)
12055 if ((name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
12056 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
12057 && ! processing_template_decl
12058 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12061 cp_error ("postfix `%D' must take `int' as its argument",
12065 ("postfix `%D' must take `int' as its second argument",
12072 cp_error ("`%D' must take either zero or one argument", decl
);
12074 cp_error ("`%D' must take either one or two arguments", decl
);
12077 /* More Effective C++ rule 6. */
12079 && (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
12080 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]))
12082 tree arg
= TREE_VALUE (argtypes
);
12083 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12084 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12085 arg
= TREE_TYPE (arg
);
12086 arg
= TYPE_MAIN_VARIANT (arg
);
12087 if (list_length (argtypes
) == 2)
12089 if (TREE_CODE (ret
) != REFERENCE_TYPE
12090 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12092 cp_warning ("prefix `%D' should return `%T'", decl
,
12093 build_reference_type (arg
));
12097 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12098 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
12102 else if (unary_op_p (name
))
12104 if (list_length (argtypes
) != 2)
12107 cp_error ("`%D' must take `void'", decl
);
12109 cp_error ("`%D' must take exactly one argument", decl
);
12112 else /* if (binary_op_p (name)) */
12114 if (list_length (argtypes
) != 3)
12117 cp_error ("`%D' must take exactly one argument", decl
);
12119 cp_error ("`%D' must take exactly two arguments", decl
);
12122 /* More Effective C++ rule 7. */
12124 && (name
== ansi_opname
[TRUTH_ANDIF_EXPR
]
12125 || name
== ansi_opname
[TRUTH_ORIF_EXPR
]
12126 || name
== ansi_opname
[COMPOUND_EXPR
]))
12127 cp_warning ("user-defined `%D' always evaluates both arguments",
12131 /* Effective C++ rule 23. */
12133 && list_length (argtypes
) == 3
12134 && (name
== ansi_opname
[PLUS_EXPR
]
12135 || name
== ansi_opname
[MINUS_EXPR
]
12136 || name
== ansi_opname
[TRUNC_DIV_EXPR
]
12137 || name
== ansi_opname
[MULT_EXPR
])
12138 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12139 cp_warning ("`%D' should return by value", decl
);
12143 for (; argtypes
!= void_list_node
; argtypes
= TREE_CHAIN (argtypes
))
12144 if (TREE_PURPOSE (argtypes
))
12146 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12147 if (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
12148 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
12151 cp_pedwarn ("`%D' cannot have default arguments", decl
);
12154 cp_error ("`%D' cannot have default arguments", decl
);
12159 static const char *
12161 enum tag_types code
;
12174 my_friendly_abort (981122);
12178 /* Get the struct, enum or union (CODE says which) with tag NAME.
12179 Define the tag as a forward-reference if it is not defined.
12181 C++: If a class derivation is given, process it here, and report
12182 an error if multiple derivation declarations are not identical.
12184 If this is a definition, come in through xref_tag and only look in
12185 the current frame for the name (since C++ allows new names in any
12189 xref_tag (code_type_node
, name
, globalize
)
12190 tree code_type_node
;
12194 enum tag_types tag_code
;
12195 enum tree_code code
;
12197 register tree ref
, t
;
12198 struct binding_level
*b
= current_binding_level
;
12200 tree attributes
= NULL_TREE
;
12201 tree context
= NULL_TREE
;
12203 /* If we are called from the parser, code_type_node will sometimes be a
12204 TREE_LIST. This indicates that the user wrote
12205 "class __attribute__ ((foo)) bar". Extract the attributes so we can
12207 if (TREE_CODE (code_type_node
) == TREE_LIST
)
12209 attributes
= TREE_PURPOSE (code_type_node
);
12210 code_type_node
= TREE_VALUE (code_type_node
);
12213 tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
12218 code
= RECORD_TYPE
;
12224 code
= ENUMERAL_TYPE
;
12227 my_friendly_abort (18);
12230 /* If a cross reference is requested, look up the type
12231 already defined for this tag and return it. */
12232 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
12235 name
= TYPE_IDENTIFIER (t
);
12239 t
= IDENTIFIER_TYPE_VALUE (name
);
12241 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
12242 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
)
12247 /* If we know we are defining this tag, only look it up in
12248 this scope and don't try to find it as a type. */
12249 ref
= lookup_tag (code
, name
, b
, 1);
12255 /* [dcl.type.elab] If the identifier resolves to a
12256 typedef-name or a template type-parameter, the
12257 elaborated-type-specifier is ill-formed. */
12258 if (t
!= TYPE_MAIN_VARIANT (t
)
12259 || (CLASS_TYPE_P (t
) && TYPE_WAS_ANONYMOUS (t
)))
12260 cp_pedwarn ("using typedef-name `%D' after `%s'",
12261 TYPE_NAME (t
), tag_name (tag_code
));
12262 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
12263 cp_error ("using template type parameter `%T' after `%s'",
12264 t
, tag_name (tag_code
));
12269 ref
= lookup_tag (code
, name
, b
, 0);
12273 /* Try finding it as a type declaration. If that wins,
12275 ref
= lookup_name (name
, 1);
12277 if (ref
!= NULL_TREE
12278 && processing_template_decl
12279 && DECL_CLASS_TEMPLATE_P (ref
)
12280 && template_class_depth (current_class_type
) == 0)
12281 /* Since GLOBALIZE is true, we're declaring a global
12282 template, so we want this type. */
12283 ref
= DECL_RESULT (ref
);
12285 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
12286 && TREE_CODE (TREE_TYPE (ref
)) == code
)
12287 ref
= TREE_TYPE (ref
);
12292 if (ref
&& current_class_type
12293 && template_class_depth (current_class_type
)
12294 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12296 /* Since GLOBALIZE is non-zero, we are not looking at a
12297 definition of this tag. Since, in addition, we are currently
12298 processing a (member) template declaration of a template
12299 class, we must be very careful; consider:
12306 { template <class V>
12307 friend struct S1; };
12309 Here, the S2::S1 declaration should not be confused with the
12310 outer declaration. In particular, the inner version should
12311 have a template parameter of level 2, not level 1. This
12312 would be particularly important if the member declaration
12315 template <class V = U> friend struct S1;
12317 say, when we should tsubst into `U' when instantiating
12318 S2. On the other hand, when presented with:
12328 we must find the inner binding eventually. We
12329 accomplish this by making sure that the new type we
12330 create to represent this declaration has the right
12332 context
= TYPE_CONTEXT (ref
);
12337 push_obstacks_nochange ();
12341 /* If no such tag is yet defined, create a forward-reference node
12342 and record it as the "definition".
12343 When a real declaration of this type is found,
12344 the forward-reference will be altered into a real type. */
12346 /* In C++, since these migrate into the global scope, we must
12347 build them on the permanent obstack. */
12349 temp
= allocation_temporary_p ();
12351 end_temporary_allocation ();
12353 if (code
== ENUMERAL_TYPE
)
12355 cp_error ("use of enum `%#D' without previous declaration", name
);
12357 ref
= make_node (ENUMERAL_TYPE
);
12359 /* Give the type a default layout like unsigned int
12360 to avoid crashing if it does not get defined. */
12361 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
12362 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
12363 TREE_UNSIGNED (ref
) = 1;
12364 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
12365 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
12366 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
12368 /* Enable us to recognize when a type is created in class context.
12369 To do nested classes correctly, this should probably be cleared
12370 out when we leave this classes scope. Currently this in only
12371 done in `start_enum'. */
12373 pushtag (name
, ref
, globalize
);
12377 struct binding_level
*old_b
= class_binding_level
;
12379 ref
= make_lang_type (code
);
12380 TYPE_CONTEXT (ref
) = context
;
12382 #ifdef NONNESTED_CLASSES
12383 /* Class types don't nest the way enums do. */
12384 class_binding_level
= (struct binding_level
*)0;
12386 pushtag (name
, ref
, globalize
);
12387 class_binding_level
= old_b
;
12392 /* If it no longer looks like a nested type, make sure it's
12394 If it is not an IDENTIFIER, this is not a declaration */
12395 if (b
->namespace_p
&& !class_binding_level
12396 && TREE_CODE (name
) == IDENTIFIER_NODE
)
12398 if (IDENTIFIER_NAMESPACE_VALUE (name
) == NULL_TREE
)
12399 SET_IDENTIFIER_NAMESPACE_VALUE (name
, TYPE_NAME (ref
));
12402 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
12403 redeclare_class_template (ref
, current_template_parms
);
12406 /* Until the type is defined, tentatively accept whatever
12407 structure tag the user hands us. */
12408 if (TYPE_SIZE (ref
) == NULL_TREE
12409 && ref
!= current_class_type
12410 /* Have to check this, in case we have contradictory tag info. */
12411 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
12413 if (tag_code
== class_type
)
12414 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
12415 else if (tag_code
== record_type
)
12416 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
12421 TREE_TYPE (ref
) = attributes
;
12427 xref_tag_from_type (old
, id
, globalize
)
12431 tree code_type_node
;
12433 if (TREE_CODE (old
) == RECORD_TYPE
)
12434 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
12435 ? class_type_node
: record_type_node
);
12437 code_type_node
= union_type_node
;
12439 if (id
== NULL_TREE
)
12440 id
= TYPE_IDENTIFIER (old
);
12442 return xref_tag (code_type_node
, id
, globalize
);
12445 /* REF is a type (named NAME), for which we have just seen some
12446 baseclasses. BINFO is a list of those baseclasses; the
12447 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12448 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12449 struct, or union. */
12452 xref_basetypes (code_type_node
, name
, ref
, binfo
)
12453 tree code_type_node
;
12457 /* In the declaration `A : X, Y, ... Z' we mark all the types
12458 (A, X, Y, ..., Z) so we can check for duplicates. */
12463 enum tag_types tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
12465 if (tag_code
== union_type
)
12467 cp_error ("derived union `%T' invalid", ref
);
12471 len
= list_length (binfo
);
12472 push_obstacks (TYPE_OBSTACK (ref
), TYPE_OBSTACK (ref
));
12474 /* First, make sure that any templates in base-classes are
12475 instantiated. This ensures that if we call ourselves recursively
12476 we do not get confused about which classes are marked and which
12478 for (base
= binfo
; base
; base
= TREE_CHAIN (base
))
12479 complete_type (TREE_VALUE (base
));
12481 SET_CLASSTYPE_MARKED (ref
);
12482 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
12484 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
12486 /* The base of a derived struct is public by default. */
12488 = (TREE_PURPOSE (binfo
) == access_public_node
12489 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12490 || (tag_code
!= class_type
12491 && (TREE_PURPOSE (binfo
) == access_default_node
12492 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
12494 = (TREE_PURPOSE (binfo
) == access_protected_node
12495 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
12497 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
12498 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
12499 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12500 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
12501 tree basetype
= TREE_VALUE (binfo
);
12504 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
12505 basetype
= TREE_TYPE (basetype
);
12507 || (TREE_CODE (basetype
) != RECORD_TYPE
12508 && TREE_CODE (basetype
) != TYPENAME_TYPE
12509 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
12510 && TREE_CODE (basetype
) != TEMPLATE_TEMPLATE_PARM
))
12512 cp_error ("base type `%T' fails to be a struct or class type",
12513 TREE_VALUE (binfo
));
12517 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
12519 /* This code replaces similar code in layout_basetypes.
12520 We put the complete_type first for implicit `typename'. */
12521 if (TYPE_SIZE (basetype
) == NULL_TREE
12522 && ! (current_template_parms
&& uses_template_parms (basetype
)))
12524 cp_error ("base class `%T' has incomplete type", basetype
);
12529 if (CLASSTYPE_MARKED (basetype
))
12531 if (basetype
== ref
)
12532 cp_error ("recursive type `%T' undefined", basetype
);
12534 cp_error ("duplicate base type `%T' invalid", basetype
);
12538 if (TYPE_FOR_JAVA (basetype
)
12539 && current_lang_stack
== current_lang_base
)
12540 TYPE_FOR_JAVA (ref
) = 1;
12542 /* Note that the BINFO records which describe individual
12543 inheritances are *not* shared in the lattice! They
12544 cannot be shared because a given baseclass may be
12545 inherited with different `accessibility' by different
12546 derived classes. (Each BINFO record describing an
12547 individual inheritance contains flags which say what
12548 the `accessibility' of that particular inheritance is.) */
12551 = make_binfo (integer_zero_node
, basetype
,
12552 CLASS_TYPE_P (basetype
)
12553 ? TYPE_BINFO_VTABLE (basetype
) : NULL_TREE
,
12554 CLASS_TYPE_P (basetype
)
12555 ? TYPE_BINFO_VIRTUALS (basetype
) : NULL_TREE
);
12557 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
12558 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
12559 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
12560 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
12561 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
12563 /* We need to unshare the binfos now so that lookups during class
12564 definition work. */
12565 unshare_base_binfos (base_binfo
);
12567 SET_CLASSTYPE_MARKED (basetype
);
12569 /* We are free to modify these bits because they are meaningless
12570 at top level, and BASETYPE is a top-level type. */
12571 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
12573 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
12574 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12577 if (CLASS_TYPE_P (basetype
))
12579 TYPE_GETS_NEW (ref
) |= TYPE_GETS_NEW (basetype
);
12580 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12587 TREE_VEC_LENGTH (binfos
) = i
;
12589 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
12592 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
12595 tree basetype
= BINFO_TYPE (TREE_VEC_ELT (binfos
, 0));
12597 if (CLASS_TYPE_P (basetype
))
12598 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
12599 = TYPE_USES_MULTIPLE_INHERITANCE (basetype
);
12602 if (TYPE_USES_MULTIPLE_INHERITANCE (ref
))
12603 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12605 /* Unmark all the types. */
12607 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
12608 CLEAR_CLASSTYPE_MARKED (ref
);
12610 /* Now that we know all the base-classes, set up the list of virtual
12612 CLASSTYPE_VBASECLASSES (ref
) = get_vbase_types (ref
);
12618 /* Begin compiling the definition of an enumeration type.
12619 NAME is its name (or null if anonymous).
12620 Returns the type object, as yet incomplete.
12621 Also records info about it so that build_enumerator
12622 may be used to declare the individual values as they are read. */
12628 register tree enumtype
= NULL_TREE
;
12629 struct binding_level
*b
= current_binding_level
;
12631 /* We are wasting space here and putting these on the permanent_obstack so
12632 that typeid(local enum) will work correctly. */
12633 push_obstacks (&permanent_obstack
, &permanent_obstack
);
12635 /* If this is the real definition for a previous forward reference,
12636 fill in the contents in the same object that used to be the
12637 forward reference. */
12639 if (name
!= NULL_TREE
)
12640 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
12642 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12644 cp_error ("multiple definition of `%#T'", enumtype
);
12645 cp_error_at ("previous definition here", enumtype
);
12649 enumtype
= make_node (ENUMERAL_TYPE
);
12650 pushtag (name
, enumtype
, 0);
12653 if (current_class_type
)
12654 TREE_ADDRESSABLE (b
->tags
) = 1;
12656 /* We don't copy this value because build_enumerator needs to do it. */
12657 enum_next_value
= integer_zero_node
;
12660 GNU_xref_decl (current_function_decl
, enumtype
);
12664 /* After processing and defining all the values of an enumeration type,
12665 install their decls in the enumeration type and finish it off.
12666 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12667 Returns ENUMTYPE. */
12670 finish_enum (enumtype
)
12673 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
12674 /* Calculate the maximum value of any enumerator in this type. */
12676 tree values
= TYPE_VALUES (enumtype
);
12681 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
12686 /* The TREE_VALUE is a CONST_DECL for this enumeration
12688 decl
= TREE_VALUE (pair
);
12690 /* The DECL_INITIAL will be NULL if we are processing a
12691 template declaration and this enumeration constant had no
12692 explicit initializer. */
12693 value
= DECL_INITIAL (decl
);
12694 if (value
&& !processing_template_decl
)
12696 /* Set the TREE_TYPE for the VALUE as well. That's so
12697 that when we call decl_constant_value we get an
12698 entity of the right type (but with the constant
12699 value). Since we shouldn't ever call
12700 decl_constant_value on a template type, there's no
12701 reason to do that when processing_template_decl.
12702 And, if the expression is something like a
12703 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12704 wreak havoc on the intended type of the expression.
12706 Of course, there's also no point in trying to compute
12707 minimum or maximum values if we're in a template. */
12708 TREE_TYPE (value
) = enumtype
;
12711 minnode
= maxnode
= value
;
12712 else if (tree_int_cst_lt (maxnode
, value
))
12714 else if (tree_int_cst_lt (value
, minnode
))
12718 if (processing_template_decl
)
12719 /* If this is just a template, leave the CONST_DECL
12720 alone. That way tsubst_copy will find CONST_DECLs for
12721 CONST_DECLs, and not INTEGER_CSTs. */
12724 /* In the list we're building up, we want the enumeration
12725 values, not the CONST_DECLs. */
12726 TREE_VALUE (pair
) = value
;
12730 maxnode
= minnode
= integer_zero_node
;
12732 TYPE_VALUES (enumtype
) = nreverse (values
);
12734 if (processing_template_decl
)
12736 tree scope
= current_scope ();
12737 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
12738 add_tree (build_min (TAG_DEFN
, enumtype
));
12742 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12743 int lowprec
= min_precision (minnode
, unsignedp
);
12744 int highprec
= min_precision (maxnode
, unsignedp
);
12745 int precision
= MAX (lowprec
, highprec
);
12748 TYPE_SIZE (enumtype
) = NULL_TREE
;
12750 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12752 TYPE_PRECISION (enumtype
) = precision
;
12754 fixup_unsigned_type (enumtype
);
12756 fixup_signed_type (enumtype
);
12758 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
12759 /* Use the width of the narrowest normal C type which is wide
12761 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
12764 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
12766 TYPE_SIZE (enumtype
) = 0;
12767 layout_type (enumtype
);
12769 /* Fix up all variant types of this enum type. */
12770 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
12771 tem
= TYPE_NEXT_VARIANT (tem
))
12773 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
12774 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
12775 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
12776 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
12777 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
12778 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
12779 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
12780 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
12781 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
12784 /* Finish debugging output for this type. */
12785 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12788 /* In start_enum we pushed obstacks. Here, we must pop them. */
12794 /* Build and install a CONST_DECL for an enumeration constant of the
12795 enumeration type TYPE whose NAME and VALUE (if any) are provided.
12796 Assignment of sequential values by default is handled here. */
12799 build_enumerator (name
, value
, type
)
12807 /* Remove no-op casts from the value. */
12809 STRIP_TYPE_NOPS (value
);
12811 if (! processing_template_decl
)
12813 /* Validate and default VALUE. */
12814 if (value
!= NULL_TREE
)
12816 if (TREE_READONLY_DECL_P (value
))
12817 value
= decl_constant_value (value
);
12819 if (TREE_CODE (value
) == INTEGER_CST
)
12821 value
= default_conversion (value
);
12822 constant_expression_warning (value
);
12826 cp_error ("enumerator value for `%D' not integer constant", name
);
12831 /* Default based on previous value. */
12832 if (value
== NULL_TREE
&& ! processing_template_decl
)
12834 value
= enum_next_value
;
12836 cp_error ("overflow in enumeration values at `%D'", name
);
12839 /* Remove no-op casts from the value. */
12841 STRIP_TYPE_NOPS (value
);
12843 /* To fix MAX_VAL enum consts. (bkoz) */
12844 TREE_TYPE (value
) = integer_type_node
;
12848 /* We always have to copy here; not all INTEGER_CSTs are unshared.
12849 Even in other cases, we will later (in finish_enum) be setting the
12851 if (value
!= NULL_TREE
)
12852 value
= copy_node (value
);
12854 /* C++ associates enums with global, function, or class declarations. */
12856 context
= current_scope ();
12857 if (context
&& context
== current_class_type
)
12858 /* This enum declaration is local to the class. */
12859 decl
= build_lang_decl (CONST_DECL
, name
, type
);
12861 /* It's a global enum, or it's local to a function. (Note local to
12862 a function could mean local to a class method. */
12863 decl
= build_decl (CONST_DECL
, name
, type
);
12865 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
12866 DECL_INITIAL (decl
) = value
;
12867 TREE_READONLY (decl
) = 1;
12869 if (context
&& context
== current_class_type
)
12870 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12871 on the TYPE_FIELDS list for `S'. (That's so that you can say
12872 things like `S::i' later.) */
12873 finish_member_declaration (decl
);
12877 GNU_xref_decl (current_function_decl
, decl
);
12880 if (! processing_template_decl
)
12882 /* Set basis for default for next value. */
12883 enum_next_value
= build_binary_op_nodefault (PLUS_EXPR
, value
,
12884 integer_one_node
, PLUS_EXPR
);
12885 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
12888 result
= saveable_tree_cons (name
, decl
, NULL_TREE
);
12893 static int function_depth
;
12895 /* Create the FUNCTION_DECL for a function definition.
12896 DECLSPECS and DECLARATOR are the parts of the declaration;
12897 they describe the function's name and the type it returns,
12898 but twisted together in a fashion that parallels the syntax of C.
12900 If PRE_PARSED_P is non-zero then DECLARATOR is really the DECL for
12901 the function we are about to process; DECLSPECS are ignored. For
12902 example, we set PRE_PARSED_P when processing the definition of
12903 inline function that was defined in-class; the definition is
12904 actually processed when the class is complete. In this case,
12905 PRE_PARSED_P is 2. We also set PRE_PARSED_P when instanting the
12906 body of a template function, and when constructing thunk functions
12907 and such; in these cases PRE_PARSED_P is 1.
12909 This function creates a binding context for the function body
12910 as well as setting up the FUNCTION_DECL in current_function_decl.
12912 Returns 1 on success. If the DECLARATOR is not suitable for a function
12913 (it defines a datum instead), we return 0, which tells
12914 yyparse to report a parse error.
12916 For C++, we must first check whether that datum makes any sense.
12917 For example, "class A local_a(1,2);" means that variable local_a
12918 is an aggregate of type A, which should have a constructor
12919 applied to it with the argument list [1, 2].
12921 @@ There is currently no way to retrieve the storage
12922 @@ allocated to FUNCTION (or all of its parms) if we return
12923 @@ something we had previously. */
12926 start_function (declspecs
, declarator
, attrs
, pre_parsed_p
)
12927 tree declspecs
, declarator
, attrs
;
12931 tree ctype
= NULL_TREE
;
12934 extern int have_extern_spec
;
12935 extern int used_extern_spec
;
12936 int doing_friend
= 0;
12938 /* Sanity check. */
12939 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
12940 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
12942 /* Assume, until we see it does. */
12943 current_function_returns_value
= 0;
12944 current_function_returns_null
= 0;
12946 current_function_assigns_this
= 0;
12947 current_function_just_assigned_this
= 0;
12948 current_function_parms_stored
= 0;
12949 original_result_rtx
= NULL_RTX
;
12950 base_init_expr
= NULL_TREE
;
12951 current_base_init_list
= NULL_TREE
;
12952 current_member_init_list
= NULL_TREE
;
12953 ctor_label
= dtor_label
= NULL_TREE
;
12954 static_labelno
= 0;
12955 in_function_try_handler
= 0;
12957 clear_temp_name ();
12959 /* This should only be done once on the top most decl. */
12960 if (have_extern_spec
&& !used_extern_spec
)
12962 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
12963 used_extern_spec
= 1;
12968 decl1
= declarator
;
12970 fntype
= TREE_TYPE (decl1
);
12971 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12972 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12974 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
12975 class is in the (lexical) scope of the class in which it is
12977 if (!ctype
&& DECL_FRIEND_P (decl1
))
12979 ctype
= DECL_CLASS_CONTEXT (decl1
);
12981 /* CTYPE could be null here if we're dealing with a template;
12982 for example, `inline friend float foo()' inside a template
12983 will have no CTYPE set. */
12984 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
12990 last_function_parms
= DECL_ARGUMENTS (decl1
);
12991 last_function_parm_tags
= NULL_TREE
;
12995 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
12996 /* If the declarator is not suitable for a function definition,
12997 cause a syntax error. */
12998 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
13000 fntype
= TREE_TYPE (decl1
);
13002 restype
= TREE_TYPE (fntype
);
13003 if (CLASS_TYPE_P (restype
) && !CLASSTYPE_GOT_SEMICOLON (restype
))
13005 cp_error ("semicolon missing after declaration of `%#T'", restype
);
13006 shadow_tag (build_expr_list (NULL_TREE
, restype
));
13007 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
13008 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
13009 fntype
= build_function_type (integer_type_node
,
13010 TYPE_ARG_TYPES (fntype
));
13012 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
13014 TYPE_ARG_TYPES (fntype
));
13015 TREE_TYPE (decl1
) = fntype
;
13018 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13019 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13020 else if (DECL_MAIN_P (decl1
))
13022 /* If this doesn't return integer_type, complain. */
13023 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
13025 if (pedantic
|| warn_return_type
)
13026 pedwarn ("return type for `main' changed to `int'");
13027 TREE_TYPE (decl1
) = fntype
= default_function_type
;
13032 /* Warn if function was previously implicitly declared
13033 (but not if we warned then). */
13034 if (! warn_implicit
13035 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
13036 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
13038 if (!building_stmt_tree ())
13039 announce_function (decl1
);
13041 /* Set up current_class_type, and enter the scope of the class, if
13044 push_nested_class (ctype
, 1);
13045 else if (DECL_STATIC_FUNCTION_P (decl1
))
13046 push_nested_class (DECL_CONTEXT (decl1
), 2);
13048 /* Now that we have entered the scope of the class, we must restore
13049 the bindings for any template parameters surrounding DECL1, if it
13050 is an inline member template. (Order is important; consider the
13051 case where a template parameter has the same name as a field of
13052 the class.) It is not until after this point that
13053 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13054 if (pre_parsed_p
== 2)
13055 maybe_begin_member_template_processing (decl1
);
13057 /* Effective C++ rule 15. See also c_expand_return. */
13059 && DECL_NAME (decl1
) == ansi_opname
[(int) MODIFY_EXPR
]
13060 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
13061 cp_warning ("`operator=' should return a reference to `*this'");
13063 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13064 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13065 DECL_INITIAL (decl1
) = error_mark_node
;
13067 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13068 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
13071 /* This function exists in static storage.
13072 (This does not mean `static' in the C sense!) */
13073 TREE_STATIC (decl1
) = 1;
13075 /* We must call push_template_decl after current_class_type is set
13076 up. (If we are processing inline definitions after exiting a
13077 class scope, current_class_type will be NULL_TREE until set above
13078 by push_nested_class.) */
13079 if (processing_template_decl
)
13080 decl1
= push_template_decl (decl1
);
13082 /* We are now in the scope of the function being defined. */
13083 current_function_decl
= decl1
;
13085 /* Save the parm names or decls from this function's declarator
13086 where store_parm_decls will find them. */
13087 current_function_parms
= last_function_parms
;
13088 current_function_parm_tags
= last_function_parm_tags
;
13090 if (! processing_template_decl
)
13092 /* In a function definition, arg types must be complete. */
13093 require_complete_types_for_parms (current_function_parms
);
13095 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype
))) == NULL_TREE
)
13097 cp_error ("return-type `%#T' is an incomplete type",
13098 TREE_TYPE (fntype
));
13100 /* Make it return void instead, but don't change the
13101 type of the DECL_RESULT, in case we have a named return value. */
13104 = build_cplus_method_type (build_type_variant (ctype
,
13105 TREE_READONLY (decl1
),
13106 TREE_SIDE_EFFECTS (decl1
)),
13108 FUNCTION_ARG_CHAIN (decl1
));
13111 = build_function_type (void_type_node
,
13112 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
13113 DECL_RESULT (decl1
)
13114 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype
)));
13115 TREE_READONLY (DECL_RESULT (decl1
))
13116 = CP_TYPE_CONST_P (TREE_TYPE (fntype
));
13117 TREE_THIS_VOLATILE (DECL_RESULT (decl1
))
13118 = CP_TYPE_VOLATILE_P (TREE_TYPE (fntype
));
13121 abstract_virtuals_error (decl1
, TREE_TYPE (fntype
));
13124 /* Record the decl so that the function name is defined.
13125 If we already have a decl for this name, and it is a FUNCTION_DECL,
13126 use the old decl. */
13127 if (!processing_template_decl
&& pre_parsed_p
== 0)
13129 /* A specialization is not used to guide overload resolution. */
13130 if ((flag_guiding_decls
13131 || !DECL_TEMPLATE_SPECIALIZATION (decl1
))
13132 && ! DECL_FUNCTION_MEMBER_P (decl1
))
13133 decl1
= pushdecl (decl1
);
13136 /* We need to set the DECL_CONTEXT. */
13137 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13138 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13139 /* And make sure we have enough default args. */
13140 check_default_args (decl1
);
13142 DECL_MAIN_VARIANT (decl1
) = decl1
;
13143 fntype
= TREE_TYPE (decl1
);
13146 current_function_decl
= decl1
;
13148 if (DECL_INTERFACE_KNOWN (decl1
))
13150 tree ctx
= hack_decl_function_context (decl1
);
13152 if (DECL_NOT_REALLY_EXTERN (decl1
))
13153 DECL_EXTERNAL (decl1
) = 0;
13155 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
13156 && TREE_PUBLIC (ctx
))
13157 /* This is a function in a local class in an extern inline
13159 comdat_linkage (decl1
);
13161 /* If this function belongs to an interface, it is public.
13162 If it belongs to someone else's interface, it is also external.
13163 This only affects inlines and template instantiations. */
13164 else if (interface_unknown
== 0
13165 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13166 || flag_alt_external_templates
))
13168 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
13169 || processing_template_decl
)
13171 DECL_EXTERNAL (decl1
)
13173 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
13174 && !DECL_VINDEX (decl1
)));
13176 /* For WIN32 we also want to put these in linkonce sections. */
13177 maybe_make_one_only (decl1
);
13180 DECL_EXTERNAL (decl1
) = 0;
13181 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13182 DECL_INTERFACE_KNOWN (decl1
) = 1;
13184 else if (interface_unknown
&& interface_only
13185 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13186 || flag_alt_external_templates
))
13188 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13189 interface, we will have interface_only set but not
13190 interface_known. In that case, we don't want to use the normal
13191 heuristics because someone will supply a #pragma implementation
13192 elsewhere, and deducing it here would produce a conflict. */
13193 comdat_linkage (decl1
);
13194 DECL_EXTERNAL (decl1
) = 0;
13195 DECL_INTERFACE_KNOWN (decl1
) = 1;
13196 DECL_DEFER_OUTPUT (decl1
) = 1;
13200 /* This is a definition, not a reference.
13201 So clear DECL_EXTERNAL. */
13202 DECL_EXTERNAL (decl1
) = 0;
13204 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
13205 && ! DECL_INTERFACE_KNOWN (decl1
)
13206 /* Don't try to defer nested functions for now. */
13207 && ! hack_decl_function_context (decl1
))
13208 DECL_DEFER_OUTPUT (decl1
) = 1;
13210 DECL_INTERFACE_KNOWN (decl1
) = 1;
13213 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
))
13215 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13216 TREE_TYPE (decl1
) = fntype
13217 = build_function_type (TREE_TYPE (fntype
),
13218 TREE_CHAIN (TYPE_ARG_TYPES (fntype
)));
13219 current_function_parms
= TREE_CHAIN (current_function_parms
);
13220 DECL_ARGUMENTS (decl1
) = current_function_parms
;
13223 restype
= TREE_TYPE (fntype
);
13227 /* If we're compiling a friend function, neither of the variables
13228 current_class_ptr nor current_class_type will have values. */
13229 if (! doing_friend
)
13231 /* We know that this was set up by `grokclassfn'.
13232 We do not wait until `store_parm_decls', since evil
13233 parse errors may never get us to that point. Here
13234 we keep the consistency between `current_class_type'
13235 and `current_class_ptr'. */
13236 tree t
= current_function_parms
;
13239 my_friendly_assert (t
!= NULL_TREE
13240 && TREE_CODE (t
) == PARM_DECL
, 162);
13241 my_friendly_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
,
13244 if (! hack_decl_function_context (decl1
))
13245 temporary_allocation ();
13246 i
= suspend_momentary ();
13248 /* Normally, build_indirect_ref returns current_class_ref
13249 whenever current_class_ptr is dereferenced. This time,
13250 however, we want it to *create* current_class_ref, so we
13251 temporarily clear current_class_ptr to fool it. */
13252 current_class_ptr
= NULL_TREE
;
13253 current_class_ref
= build_indirect_ref (t
, NULL_PTR
);
13254 current_class_ptr
= t
;
13256 resume_momentary (i
);
13257 if (! hack_decl_function_context (decl1
))
13258 end_temporary_allocation ();
13262 current_class_ptr
= current_class_ref
= NULL_TREE
;
13265 current_binding_level
->parm_flag
= 1;
13268 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
13270 if (!building_stmt_tree ())
13272 GNU_xref_function (decl1
, current_function_parms
);
13273 make_function_rtl (decl1
);
13276 /* Promote the value to int before returning it. */
13277 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
13278 restype
= type_promotes_to (restype
);
13280 /* If this fcn was already referenced via a block-scope `extern' decl
13281 (or an implicit decl), propagate certain information about the usage. */
13282 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
13283 TREE_ADDRESSABLE (decl1
) = 1;
13285 if (DECL_RESULT (decl1
) == NULL_TREE
)
13287 DECL_RESULT (decl1
)
13288 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13289 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
13290 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
13293 /* Allocate further tree nodes temporarily during compilation
13294 of this function only. Tiemann moved up here from bottom of fn. */
13295 /* If this is a nested function, then we must continue to allocate RTL
13296 on the permanent obstack in case we need to inline it later. */
13297 if (! hack_decl_function_context (decl1
))
13298 temporary_allocation ();
13300 /* Make sure that we always have a momntary obstack while we're in a
13304 if (building_stmt_tree ())
13305 begin_stmt_tree (decl1
);
13309 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1
))
13310 && DECL_LANGUAGE (decl1
) == lang_cplusplus
)
13312 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13313 ctor_label
= NULL_TREE
;
13317 dtor_label
= NULL_TREE
;
13318 if (DECL_CONSTRUCTOR_P (decl1
))
13319 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13325 /* Called after store_parm_decls for a function-try-block. We need to update
13326 last_parm_cleanup_insn so that the base initializers for a constructor
13327 are run within this block, not before it. */
13330 expand_start_early_try_stmts ()
13332 expand_start_try_stmts ();
13333 last_parm_cleanup_insn
= get_last_insn ();
13336 /* Store the parameter declarations into the current function declaration.
13337 This is called after parsing the parameter declarations, before
13338 digesting the body of the function.
13340 Also install to binding contour return value identifier, if any. */
13343 store_parm_decls ()
13345 register tree fndecl
= current_function_decl
;
13346 register tree parm
;
13347 int parms_have_cleanups
= 0;
13348 tree cleanups
= NULL_TREE
;
13350 /* This is either a chain of PARM_DECLs (when a prototype is used). */
13351 tree specparms
= current_function_parms
;
13353 /* This is a list of types declared among parms in a prototype. */
13354 tree parmtags
= current_function_parm_tags
;
13356 /* This is a chain of any other decls that came in among the parm
13357 declarations. If a parm is declared with enum {foo, bar} x;
13358 then CONST_DECLs for foo and bar are put here. */
13359 tree nonparms
= NULL_TREE
;
13361 if (toplevel_bindings_p ())
13362 fatal ("parse errors have confused me too much");
13364 /* Initialize RTL machinery. */
13365 init_function_start (fndecl
, input_filename
, lineno
);
13366 /* Even though we're inside a function body, we still don't want to
13367 call expand_expr to calculate the size of a variable-sized array.
13368 We haven't necessarily assigned RTL to all variables yet, so it's
13369 not safe to try to expand expressions involving them. */
13370 immediate_size_expand
= 0;
13371 get_pending_sizes ();
13373 /* Create a binding level for the parms. */
13374 expand_start_bindings (0);
13376 if (specparms
!= NULL_TREE
)
13378 /* This case is when the function was defined with an ANSI prototype.
13379 The parms already have decls, so we need not do anything here
13380 except record them as in effect
13381 and complain if any redundant old-style parm decls were written. */
13383 register tree next
;
13385 /* Must clear this because it might contain TYPE_DECLs declared
13387 storedecls (NULL_TREE
);
13389 for (parm
= nreverse (specparms
); parm
; parm
= next
)
13391 next
= TREE_CHAIN (parm
);
13392 if (TREE_CODE (parm
) == PARM_DECL
)
13395 if (DECL_NAME (parm
) == NULL_TREE
)
13399 else if (TREE_CODE (TREE_TYPE (parm
)) == VOID_TYPE
)
13400 cp_error ("parameter `%D' declared void", parm
);
13403 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
13404 A parameter is assumed not to have any side effects.
13405 If this should change for any reason, then this
13406 will have to wrap the bashed reference type in a save_expr.
13408 Also, if the parameter type is declared to be an X
13409 and there is an X(X&) constructor, we cannot lay it
13410 into the stack (any more), so we make this parameter
13411 look like it is really of reference type. Functions
13412 which pass parameters to this function will know to
13413 create a temporary in their frame, and pass a reference
13416 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
13417 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))))
13418 SET_DECL_REFERENCE_SLOT (parm
, convert_from_reference (parm
));
13422 if (! building_stmt_tree ()
13423 && (cleanup
= maybe_build_cleanup (parm
), cleanup
))
13425 expand_decl (parm
);
13426 parms_have_cleanups
= 1;
13428 /* Keep track of the cleanups. */
13429 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
13434 /* If we find an enum constant or a type tag,
13435 put it aside for the moment. */
13436 TREE_CHAIN (parm
) = NULL_TREE
;
13437 nonparms
= chainon (nonparms
, parm
);
13441 /* Get the decls in their original chain order
13442 and record in the function. This is all and only the
13443 PARM_DECLs that were pushed into scope by the loop above. */
13444 DECL_ARGUMENTS (fndecl
) = getdecls ();
13446 storetags (chainon (parmtags
, gettags ()));
13449 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13451 /* Now store the final chain of decls for the arguments
13452 as the decl-chain of the current lexical scope.
13453 Put the enumerators in as well, at the front so that
13454 DECL_ARGUMENTS is not modified. */
13456 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
13458 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
13459 declare_function_name ();
13461 /* Initialize the RTL code for the function. */
13462 DECL_SAVED_INSNS (fndecl
) = 0;
13463 if (! building_stmt_tree ())
13464 expand_function_start (fndecl
, parms_have_cleanups
);
13466 current_function_parms_stored
= 1;
13468 /* If this function is `main', emit a call to `__main'
13469 to run global initializers, etc. */
13470 if (DECL_MAIN_P (fndecl
) && !building_stmt_tree ())
13471 expand_main_function ();
13473 /* Now that we have initialized the parms, we can start their
13474 cleanups. We cannot do this before, since expand_decl_cleanup
13475 should not be called before the parm can be used. */
13476 if (cleanups
&& !building_stmt_tree ())
13478 for (cleanups
= nreverse (cleanups
); cleanups
; cleanups
= TREE_CHAIN (cleanups
))
13480 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups
), TREE_VALUE (cleanups
)))
13481 cp_error ("parser lost in parsing declaration of `%D'",
13482 TREE_PURPOSE (cleanups
));
13486 /* Create a binding contour which can be used to catch
13487 cleanup-generated temporaries. Also, if the return value needs or
13488 has initialization, deal with that now. */
13489 if (parms_have_cleanups
)
13492 if (!building_stmt_tree ())
13493 expand_start_bindings (0);
13496 if (! building_stmt_tree () && flag_exceptions
)
13498 /* Do the starting of the exception specifications, if we have any. */
13499 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
13500 expand_start_eh_spec ();
13503 last_parm_cleanup_insn
= get_last_insn ();
13504 last_dtor_insn
= get_last_insn ();
13507 /* Bind a name and initialization to the return value of
13508 the current function. */
13511 store_return_init (decl
)
13514 /* If this named return value comes in a register, put it in a
13515 pseudo-register. */
13516 if (DECL_REGISTER (decl
))
13518 original_result_rtx
= DECL_RTL (decl
);
13519 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
13524 /* Finish up a function declaration and compile that function
13525 all the way to assembler language output. The free the storage
13526 for the function definition.
13528 This is called after parsing the body of the function definition.
13529 LINENO is the current line number.
13531 FLAGS is a bitwise or of the following values:
13533 An extra call to poplevel (and expand_end_bindings) must be
13534 made to take care of the binding contour for the base
13535 initializers. This is only relevant for constructors.
13537 We just finished processing the body of an in-class inline
13538 function definition. (This processing will have taken place
13539 after the class definition is complete.)
13541 NESTED is nonzero if we were in the middle of compiling another function
13542 when we started on this one. */
13545 finish_function (lineno
, flags
, nested
)
13550 register tree fndecl
= current_function_decl
;
13551 tree fntype
, ctype
= NULL_TREE
;
13552 rtx fn_last_parm_insn
, insns
;
13553 /* Label to use if this function is supposed to return a value. */
13554 tree no_return_label
= NULL_TREE
;
13555 tree decls
= NULL_TREE
;
13556 int call_poplevel
= (flags
& 1) != 0;
13557 int inclass_inline
= (flags
& 2) != 0;
13560 /* When we get some parse errors, we can end up without a
13561 current_function_decl, so cope. */
13562 if (fndecl
== NULL_TREE
)
13565 if (function_depth
> 1)
13568 fntype
= TREE_TYPE (fndecl
);
13570 /* TREE_READONLY (fndecl) = 1;
13571 This caused &foo to be of type ptr-to-const-function
13572 which then got a warning when stored in a ptr-to-function variable. */
13574 /* This happens on strange parse errors. */
13575 if (! current_function_parms_stored
)
13578 store_parm_decls ();
13581 if (building_stmt_tree ())
13583 if (DECL_CONSTRUCTOR_P (fndecl
) && call_poplevel
)
13585 decls
= getdecls ();
13586 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13587 poplevel (decls
!= NULL_TREE
, 0, 0);
13592 if (write_symbols
!= NO_DEBUG
/*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13594 tree ttype
= target_type (fntype
);
13597 if (IS_AGGR_TYPE (ttype
))
13598 /* Let debugger know it should output info for this type. */
13599 note_debug_info_needed (ttype
);
13601 for (parmdecl
= DECL_ARGUMENTS (fndecl
); parmdecl
; parmdecl
= TREE_CHAIN (parmdecl
))
13603 ttype
= target_type (TREE_TYPE (parmdecl
));
13604 if (IS_AGGR_TYPE (ttype
))
13605 /* Let debugger know it should output info for this type. */
13606 note_debug_info_needed (ttype
);
13610 /* Clean house because we will need to reorder insns here. */
13611 do_pending_stack_adjust ();
13615 tree binfo
= TYPE_BINFO (current_class_type
);
13616 tree cond
= integer_one_node
;
13618 tree in_charge_node
= lookup_name (in_charge_identifier
, 0);
13620 int ok_to_optimize_dtor
= 0;
13621 int empty_dtor
= get_last_insn () == last_dtor_insn
;
13623 if (current_function_assigns_this
)
13624 cond
= build (NE_EXPR
, boolean_type_node
,
13625 current_class_ptr
, integer_zero_node
);
13628 int n_baseclasses
= CLASSTYPE_N_BASECLASSES (current_class_type
);
13630 /* If this destructor is empty, then we don't need to check
13631 whether `this' is NULL in some cases. */
13632 if ((flag_this_is_variable
& 1) == 0)
13633 ok_to_optimize_dtor
= 1;
13634 else if (empty_dtor
)
13635 ok_to_optimize_dtor
13636 = (n_baseclasses
== 0
13637 || (n_baseclasses
== 1
13638 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type
, 0))));
13641 /* These initializations might go inline. Protect
13642 the binding level of the parms. */
13644 expand_start_bindings (0);
13646 if (current_function_assigns_this
)
13648 current_function_assigns_this
= 0;
13649 current_function_just_assigned_this
= 0;
13652 /* Generate the code to call destructor on base class.
13653 If this destructor belongs to a class with virtual
13654 functions, then set the virtual function table
13655 pointer to represent the type of our base class. */
13657 /* This side-effect makes call to `build_delete' generate the
13658 code we have to have at the end of this destructor.
13659 `build_delete' will set the flag again. */
13660 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
13662 /* These are two cases where we cannot delegate deletion. */
13663 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)
13664 || TYPE_GETS_REG_DELETE (current_class_type
))
13665 exprstmt
= build_delete (current_class_type
, current_class_ref
, integer_zero_node
,
13666 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13668 exprstmt
= build_delete (current_class_type
, current_class_ref
, in_charge_node
,
13669 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13671 /* If we did not assign to this, then `this' is non-zero at
13672 the end of a destructor. As a special optimization, don't
13673 emit test if this is an empty destructor. If it does nothing,
13674 it does nothing. If it calls a base destructor, the base
13675 destructor will perform the test. */
13677 if (exprstmt
!= error_mark_node
13678 && (TREE_CODE (exprstmt
) != NOP_EXPR
13679 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
13680 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
13682 expand_label (dtor_label
);
13683 if (cond
!= integer_one_node
)
13684 expand_start_cond (cond
, 0);
13685 if (exprstmt
!= void_zero_node
)
13686 /* Don't call `expand_expr_stmt' if we're not going to do
13687 anything, since -Wall will give a diagnostic. */
13688 expand_expr_stmt (exprstmt
);
13690 /* Run destructor on all virtual baseclasses. */
13691 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13693 tree vbases
= nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type
)));
13694 expand_start_cond (build (BIT_AND_EXPR
, integer_type_node
,
13695 in_charge_node
, integer_two_node
), 0);
13698 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases
)))
13700 tree vb
= get_vbase
13701 (BINFO_TYPE (vbases
),
13702 TYPE_BINFO (current_class_type
));
13704 (build_scoped_method_call
13705 (current_class_ref
, vb
, dtor_identifier
,
13706 build_expr_list (NULL_TREE
, integer_zero_node
)));
13708 vbases
= TREE_CHAIN (vbases
);
13710 expand_end_cond ();
13713 do_pending_stack_adjust ();
13714 if (cond
!= integer_one_node
)
13715 expand_end_cond ();
13718 virtual_size
= c_sizeof (current_class_type
);
13720 /* At the end, call delete if that's what's requested. */
13722 /* FDIS sez: At the point of definition of a virtual destructor
13723 (including an implicit definition), non-placement operator
13724 delete shall be looked up in the scope of the destructor's
13725 class and if found shall be accessible and unambiguous.
13727 This is somewhat unclear, but I take it to mean that if the
13728 class only defines placement deletes we don't do anything here.
13729 So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain
13730 for us if they ever try to delete one of these. */
13732 if (TYPE_GETS_REG_DELETE (current_class_type
)
13733 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13734 exprstmt
= build_op_delete_call
13735 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
13736 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
13738 exprstmt
= NULL_TREE
;
13742 cond
= build (BIT_AND_EXPR
, integer_type_node
,
13743 in_charge_node
, integer_one_node
);
13744 expand_start_cond (cond
, 0);
13745 expand_expr_stmt (exprstmt
);
13746 expand_end_cond ();
13749 /* End of destructor. */
13750 expand_end_bindings (NULL_TREE
, getdecls () != NULL_TREE
, 0);
13751 poplevel (getdecls () != NULL_TREE
, 0, 0);
13753 /* Back to the top of destructor. */
13754 /* Don't execute destructor code if `this' is NULL. */
13758 /* If the dtor is empty, and we know there is not possible way we
13759 could use any vtable entries, before they are possibly set by
13760 a base class dtor, we don't have to setup the vtables, as we
13761 know that any base class dtoring will set up any vtables it
13762 needs. We avoid MI, because one base class dtor can do a
13763 virtual dispatch to an overridden function that would need to
13764 have a non-related vtable set up, we cannot avoid setting up
13765 vtables in that case. We could change this to see if there is
13766 just one vtable. */
13767 if (! empty_dtor
|| TYPE_USES_COMPLEX_INHERITANCE (current_class_type
))
13769 /* Make all virtual function table pointers in non-virtual base
13770 classes point to CURRENT_CLASS_TYPE's virtual function
13772 expand_direct_vtbls_init (binfo
, binfo
, 1, 0, current_class_ptr
);
13774 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13775 expand_indirect_vtbls_init (binfo
, current_class_ref
, current_class_ptr
);
13778 if (! ok_to_optimize_dtor
)
13780 cond
= build_binary_op (NE_EXPR
,
13781 current_class_ptr
, integer_zero_node
);
13782 expand_start_cond (cond
, 0);
13785 insns
= get_insns ();
13788 fn_last_parm_insn
= get_first_nonparm_insn ();
13789 if (fn_last_parm_insn
== NULL_RTX
)
13790 fn_last_parm_insn
= get_last_insn ();
13792 fn_last_parm_insn
= previous_insn (fn_last_parm_insn
);
13794 emit_insns_after (insns
, fn_last_parm_insn
);
13796 if (! ok_to_optimize_dtor
)
13797 expand_end_cond ();
13799 else if (current_function_assigns_this
)
13801 /* Does not need to call emit_base_init, because
13802 that is done (if needed) just after assignment to this
13805 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13807 end_protect_partials ();
13808 expand_label (ctor_label
);
13809 ctor_label
= NULL_TREE
;
13813 decls
= getdecls ();
13814 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13815 poplevel (decls
!= NULL_TREE
, 0, 0);
13817 /* c_expand_return knows to return 'this' from a constructor. */
13818 c_expand_return (NULL_TREE
);
13820 else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl
))) != VOID_TYPE
13821 && return_label
!= NULL_RTX
)
13822 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13824 current_function_assigns_this
= 0;
13825 current_function_just_assigned_this
= 0;
13826 base_init_expr
= NULL_TREE
;
13828 else if (DECL_CONSTRUCTOR_P (fndecl
))
13830 tree cond
= NULL_TREE
, thenclause
= NULL_TREE
;
13831 /* Allow constructor for a type to get a new instance of the object
13832 using `build_new'. */
13833 tree abstract_virtuals
= CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
);
13834 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = NULL_TREE
;
13836 if (flag_this_is_variable
> 0)
13838 cond
= build_binary_op (EQ_EXPR
,
13839 current_class_ptr
, integer_zero_node
);
13840 thenclause
= build_modify_expr (current_class_ptr
, NOP_EXPR
,
13841 build_new (NULL_TREE
, current_class_type
, void_type_node
, 0));
13844 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = abstract_virtuals
;
13848 if (flag_this_is_variable
> 0)
13850 expand_start_cond (cond
, 0);
13851 expand_expr_stmt (thenclause
);
13852 expand_end_cond ();
13855 /* Emit insns from `emit_base_init' which sets up virtual
13856 function table pointer(s). */
13857 if (base_init_expr
)
13859 expand_expr_stmt (base_init_expr
);
13860 base_init_expr
= NULL_TREE
;
13863 insns
= get_insns ();
13866 /* This is where the body of the constructor begins. */
13868 emit_insns_after (insns
, last_parm_cleanup_insn
);
13870 end_protect_partials ();
13872 /* This is where the body of the constructor ends. */
13873 expand_label (ctor_label
);
13874 ctor_label
= NULL_TREE
;
13878 decls
= getdecls ();
13879 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13880 poplevel (decls
!= NULL_TREE
, 1, 0);
13883 /* c_expand_return knows to return 'this' from a constructor. */
13884 c_expand_return (NULL_TREE
);
13886 current_function_assigns_this
= 0;
13887 current_function_just_assigned_this
= 0;
13889 else if (DECL_MAIN_P (fndecl
))
13891 /* Make it so that `main' always returns 0 by default. */
13893 c_expand_return (integer_one_node
);
13895 c_expand_return (integer_zero_node
);
13898 else if (return_label
!= NULL_RTX
13899 && current_function_return_value
== NULL_TREE
13900 && ! DECL_NAME (DECL_RESULT (current_function_decl
)))
13901 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13903 if (flag_exceptions
)
13904 expand_exception_blocks ();
13906 /* If this function is supposed to return a value, ensure that
13907 we do not fall into the cleanups by mistake. The end of our
13908 function will look like this:
13910 user code (may have return stmt somewhere)
13911 goto no_return_label
13916 NOTE_INSN_FUNCTION_END
13920 If the user omits a return stmt in the USER CODE section, we
13921 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13922 Otherwise, we won't. */
13923 if (no_return_label
)
13925 DECL_CONTEXT (no_return_label
) = fndecl
;
13926 DECL_INITIAL (no_return_label
) = error_mark_node
;
13927 DECL_SOURCE_FILE (no_return_label
) = input_filename
;
13928 DECL_SOURCE_LINE (no_return_label
) = lineno
;
13929 expand_goto (no_return_label
);
13934 /* Remove the binding contour which is used
13935 to catch cleanup-generated temporaries. */
13936 expand_end_bindings (0, 0, 0);
13937 poplevel (0, 0, 0);
13939 /* Emit label at beginning of cleanup code for parameters. */
13940 emit_label (cleanup_label
);
13943 /* Get return value into register if that's where it's supposed to be. */
13944 if (original_result_rtx
)
13945 fixup_result_decl (DECL_RESULT (fndecl
), original_result_rtx
);
13947 /* Finish building code that will trigger warnings if users forget
13948 to make their functions return values. */
13949 if (no_return_label
|| cleanup_label
)
13950 emit_jump (return_label
);
13951 if (no_return_label
)
13953 /* We don't need to call `expand_*_return' here because we
13954 don't need any cleanups here--this path of code is only
13955 for error checking purposes. */
13956 expand_label (no_return_label
);
13959 /* We hard-wired immediate_size_expand to zero in
13960 start_function. Expand_function_end will decrement this
13961 variable. So, we set the variable to one here, so that after
13962 the decrement it will remain zero. */
13963 immediate_size_expand
= 1;
13965 /* Generate rtl for function exit. */
13966 expand_function_end (input_filename
, lineno
, 1);
13969 /* We have to save this value here in case
13970 maybe_end_member_template_processing decides to pop all the
13971 template parameters. */
13972 expand_p
= !building_stmt_tree ();
13974 /* If we're saving up tree structure, tie off the function now. */
13976 finish_stmt_tree (fndecl
);
13978 /* This must come after expand_function_end because cleanups might
13979 have declarations (from inline functions) that need to go into
13980 this function's blocks. */
13981 if (current_binding_level
->parm_flag
!= 1)
13982 my_friendly_abort (122);
13983 poplevel (1, 0, 1);
13985 /* If this is a in-class inline definition, we may have to pop the
13986 bindings for the template parameters that we added in
13987 maybe_begin_member_template_processing when start_function was
13989 if (inclass_inline
)
13990 maybe_end_member_template_processing ();
13992 /* Reset scope for C++: if we were in the scope of a class,
13993 then when we finish this function, we are not longer so.
13994 This cannot be done until we know for sure that no more
13995 class members will ever be referenced in this function
13996 (i.e., calls to destructors). */
13997 if (current_class_name
)
13999 ctype
= current_class_type
;
14000 pop_nested_class ();
14003 /* Must mark the RESULT_DECL as being in this function. */
14004 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14006 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14007 to the FUNCTION_DECL node itself. */
14008 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14010 /* Undo the call to push_momentary in start_function. */
14015 int saved_flag_keep_inline_functions
=
14016 flag_keep_inline_functions
;
14018 /* So we can tell if jump_optimize sets it to 1. */
14021 if (DECL_CONTEXT (fndecl
) != NULL_TREE
14022 && hack_decl_function_context (fndecl
))
14023 /* Trick rest_of_compilation into not deferring output of this
14024 function, even if it is inline, since the rtl_obstack for
14025 this function is the function_obstack of the enclosing
14026 function and will be deallocated when the enclosing
14027 function is gone. See save_tree_status. */
14028 flag_keep_inline_functions
= 1;
14030 /* Run the optimizers and output the assembler code for this
14033 if (DECL_ARTIFICIAL (fndecl
))
14035 /* Do we really *want* to inline this synthesized method? */
14037 int save_fif
= flag_inline_functions
;
14038 flag_inline_functions
= 1;
14040 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
14041 will check our size. */
14042 DECL_INLINE (fndecl
) = 0;
14044 rest_of_compilation (fndecl
);
14045 flag_inline_functions
= save_fif
;
14048 rest_of_compilation (fndecl
);
14050 flag_keep_inline_functions
= saved_flag_keep_inline_functions
;
14052 if (DECL_SAVED_INSNS (fndecl
) && ! TREE_ASM_WRITTEN (fndecl
))
14054 /* Set DECL_EXTERNAL so that assemble_external will be called as
14055 necessary. We'll clear it again in finish_file. */
14056 if (! DECL_EXTERNAL (fndecl
))
14057 DECL_NOT_REALLY_EXTERN (fndecl
) = 1;
14058 DECL_EXTERNAL (fndecl
) = 1;
14059 mark_inline_for_output (fndecl
);
14062 if (ctype
&& TREE_ASM_WRITTEN (fndecl
))
14063 note_debug_info_needed (ctype
);
14065 current_function_returns_null
|= can_reach_end
;
14067 /* Since we don't normally go through c_expand_return for constructors,
14068 this normally gets the wrong value.
14069 Also, named return values have their return codes emitted after
14070 NOTE_INSN_FUNCTION_END, confusing jump.c. */
14071 if (DECL_CONSTRUCTOR_P (fndecl
)
14072 || DECL_NAME (DECL_RESULT (fndecl
)) != NULL_TREE
)
14073 current_function_returns_null
= 0;
14075 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
14076 cp_warning ("`noreturn' function `%D' does return", fndecl
);
14077 else if ((warn_return_type
|| pedantic
)
14078 && current_function_returns_null
14079 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
)
14081 /* If this function returns non-void and control can drop through,
14083 cp_warning ("control reaches end of non-void function `%D'", fndecl
);
14085 /* With just -W, complain only if function returns both with
14086 and without a value. */
14087 else if (extra_warnings
14088 && current_function_returns_value
&& current_function_returns_null
)
14089 warning ("this function may return with or without a value");
14094 /* Free all the tree nodes making up this function. */
14095 /* Switch back to allocating nodes permanently
14096 until we start another function. */
14098 permanent_allocation (1);
14100 if (DECL_SAVED_INSNS (fndecl
) == 0)
14104 /* Stop pointing to the local nodes about to be freed. */
14105 /* But DECL_INITIAL must remain nonzero so we know this
14106 was an actual function definition. */
14107 DECL_INITIAL (fndecl
) = error_mark_node
;
14108 for (t
= DECL_ARGUMENTS (fndecl
); t
; t
= TREE_CHAIN (t
))
14109 DECL_RTL (t
) = DECL_INCOMING_RTL (t
) = NULL_RTX
;
14112 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
14113 static_ctors
= perm_tree_cons (NULL_TREE
, fndecl
, static_ctors
);
14114 if (DECL_STATIC_DESTRUCTOR (fndecl
))
14115 static_dtors
= perm_tree_cons (NULL_TREE
, fndecl
, static_dtors
);
14119 /* Let the error reporting routines know that we're outside a
14120 function. For a nested function, this value is used in
14121 pop_cp_function_context and then reset via pop_function_context. */
14122 current_function_decl
= NULL_TREE
;
14125 named_label_uses
= NULL
;
14126 current_class_ptr
= NULL_TREE
;
14127 current_class_ref
= NULL_TREE
;
14130 /* Create the FUNCTION_DECL for a function definition.
14131 DECLSPECS and DECLARATOR are the parts of the declaration;
14132 they describe the return type and the name of the function,
14133 but twisted together in a fashion that parallels the syntax of C.
14135 This function creates a binding context for the function body
14136 as well as setting up the FUNCTION_DECL in current_function_decl.
14138 Returns a FUNCTION_DECL on success.
14140 If the DECLARATOR is not suitable for a function (it defines a datum
14141 instead), we return 0, which tells yyparse to report a parse error.
14143 May return void_type_node indicating that this method is actually
14144 a friend. See grokfield for more details.
14146 Came here with a `.pushlevel' .
14148 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14149 CHANGES TO CODE IN `grokfield'. */
14152 start_method (declspecs
, declarator
, attrlist
)
14153 tree declarator
, declspecs
, attrlist
;
14155 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14158 /* Something too ugly to handle. */
14159 if (fndecl
== NULL_TREE
)
14162 /* Pass friends other than inline friend functions back. */
14163 if (fndecl
== void_type_node
)
14166 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
14167 /* Not a function, tell parser to report parse error. */
14170 if (DECL_IN_AGGR_P (fndecl
))
14172 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
14174 if (DECL_CONTEXT (fndecl
)
14175 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
14176 cp_error ("`%D' is already defined in class %s", fndecl
,
14177 TYPE_NAME_STRING (DECL_CONTEXT (fndecl
)));
14179 return void_type_node
;
14182 check_template_shadow (fndecl
);
14184 DECL_THIS_INLINE (fndecl
) = 1;
14186 if (flag_default_inline
)
14187 DECL_INLINE (fndecl
) = 1;
14189 /* We process method specializations in finish_struct_1. */
14190 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14191 fndecl
= push_template_decl (fndecl
);
14193 /* We read in the parameters on the maybepermanent_obstack,
14194 but we won't be getting back to them until after we
14195 may have clobbered them. So the call to preserve_data
14196 will keep them safe. */
14199 if (! DECL_FRIEND_P (fndecl
))
14201 if (TREE_CHAIN (fndecl
))
14203 fndecl
= copy_node (fndecl
);
14204 TREE_CHAIN (fndecl
) = NULL_TREE
;
14207 if (DECL_CONSTRUCTOR_P (fndecl
))
14209 if (! grok_ctor_properties (current_class_type
, fndecl
))
14210 return void_type_node
;
14212 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
14213 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
14216 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0, 0);
14218 /* Make a place for the parms */
14220 current_binding_level
->parm_flag
= 1;
14222 DECL_IN_AGGR_P (fndecl
) = 1;
14226 /* Go through the motions of finishing a function definition.
14227 We don't compile this method until after the whole class has
14230 FINISH_METHOD must return something that looks as though it
14231 came from GROKFIELD (since we are defining a method, after all).
14233 This is called after parsing the body of the function definition.
14234 STMTS is the chain of statements that makes up the function body.
14236 DECL is the ..._DECL that `start_method' provided. */
14239 finish_method (decl
)
14242 register tree fndecl
= decl
;
14245 register tree link
;
14247 if (decl
== void_type_node
)
14250 old_initial
= DECL_INITIAL (fndecl
);
14252 /* Undo the level for the parms (from start_method).
14253 This is like poplevel, but it causes nothing to be
14254 saved. Saving information here confuses symbol-table
14255 output routines. Besides, this information will
14256 be correctly output when this method is actually
14259 /* Clear out the meanings of the local variables of this level;
14260 also record in each decl which block it belongs to. */
14262 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
14264 if (DECL_NAME (link
) != NULL_TREE
)
14265 pop_binding (DECL_NAME (link
), link
);
14266 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
14267 DECL_CONTEXT (link
) = NULL_TREE
;
14270 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
14271 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
14272 current_binding_level
->parm_flag
,
14273 current_binding_level
->keep
);
14275 poplevel (0, 0, 0);
14277 DECL_INITIAL (fndecl
) = old_initial
;
14279 /* We used to check if the context of FNDECL was different from
14280 current_class_type as another way to get inside here. This didn't work
14281 for String.cc in libg++. */
14282 if (DECL_FRIEND_P (fndecl
))
14284 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
14285 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
14286 decl
= void_type_node
;
14292 /* Called when a new struct TYPE is defined.
14293 If this structure or union completes the type of any previous
14294 variable declaration, lay it out and output its rtl. */
14297 hack_incomplete_structures (type
)
14302 if (current_binding_level
->incomplete
== NULL_TREE
)
14305 if (!type
) /* Don't do this for class templates. */
14308 for (list
= ¤t_binding_level
->incomplete
; *list
; )
14310 tree decl
= TREE_VALUE (*list
);
14311 if ((decl
&& TREE_TYPE (decl
) == type
)
14312 || (TREE_TYPE (decl
)
14313 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14314 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
14316 int toplevel
= toplevel_bindings_p ();
14317 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14318 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
14319 layout_type (TREE_TYPE (decl
));
14320 layout_decl (decl
, 0);
14321 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
14325 expand_decl (decl
);
14326 cleanup
= maybe_build_cleanup (decl
);
14327 expand_decl_init (decl
);
14328 if (! expand_decl_cleanup (decl
, cleanup
))
14329 cp_error ("parser lost in parsing declaration of `%D'",
14332 *list
= TREE_CHAIN (*list
);
14335 list
= &TREE_CHAIN (*list
);
14339 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14340 See build_delete for information about AUTO_DELETE.
14342 Don't build these on the momentary obstack; they must live
14343 the life of the binding contour. */
14346 maybe_build_cleanup_1 (decl
, auto_delete
)
14347 tree decl
, auto_delete
;
14349 tree type
= TREE_TYPE (decl
);
14350 if (type
!= error_mark_node
&& TYPE_NEEDS_DESTRUCTOR (type
))
14352 int temp
= 0, flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14355 if (TREE_CODE (decl
) != PARM_DECL
)
14356 temp
= suspend_momentary ();
14358 if (TREE_CODE (type
) == ARRAY_TYPE
)
14362 mark_addressable (decl
);
14363 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
14366 /* Optimize for space over speed here. */
14367 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
14368 || flag_expensive_optimizations
)
14369 flags
|= LOOKUP_NONVIRTUAL
;
14371 rval
= build_delete (TREE_TYPE (rval
), rval
, auto_delete
, flags
, 0);
14373 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
14374 && ! TYPE_HAS_DESTRUCTOR (type
))
14375 rval
= build_compound_expr (expr_tree_cons (NULL_TREE
, rval
,
14376 build_expr_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
14378 if (TREE_CODE (decl
) != PARM_DECL
)
14379 resume_momentary (temp
);
14386 /* If DECL is of a type which needs a cleanup, build that cleanup
14387 here. The cleanup does free the storage with a call to delete. */
14390 maybe_build_cleanup_and_delete (decl
)
14393 return maybe_build_cleanup_1 (decl
, integer_three_node
);
14396 /* If DECL is of a type which needs a cleanup, build that cleanup
14397 here. The cleanup does not free the storage with a call a delete. */
14400 maybe_build_cleanup (decl
)
14403 return maybe_build_cleanup_1 (decl
, integer_two_node
);
14406 /* Expand a C++ expression at the statement level.
14407 This is needed to ferret out nodes which have UNKNOWN_TYPE.
14408 The C++ type checker should get all of these out when
14409 expressions are combined with other, type-providing, expressions,
14410 leaving only orphan expressions, such as:
14412 &class::bar; / / takes its address, but does nothing with it. */
14415 cplus_expand_expr_stmt (exp
)
14418 exp
= require_complete_type_in_void (exp
);
14420 if (TREE_CODE (exp
) == FUNCTION_DECL
)
14422 cp_warning ("reference, not call, to function `%D'", exp
);
14423 warning ("at this point in file");
14427 /* We should do this eventually, but right now this causes regex.o from
14428 libg++ to miscompile, and tString to core dump. */
14429 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
14432 /* Strip unused implicit INDIRECT_REFs of references. */
14433 if (TREE_CODE (exp
) == INDIRECT_REF
14434 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
14435 exp
= TREE_OPERAND (exp
, 0);
14437 /* If we don't do this, we end up down inside expand_expr
14438 trying to do TYPE_MODE on the ERROR_MARK, and really
14439 go outside the bounds of the type. */
14440 if (exp
!= error_mark_node
)
14441 expand_expr_stmt (break_out_cleanups (exp
));
14444 /* When a stmt has been parsed, this function is called. */
14449 if (!current_function_assigns_this
14450 && current_function_just_assigned_this
)
14452 if (DECL_CONSTRUCTOR_P (current_function_decl
))
14454 /* Constructors must wait until we are out of control
14455 zones before calling base constructors. */
14456 if (in_control_zone_p ())
14458 expand_expr_stmt (base_init_expr
);
14459 check_base_init (current_class_type
);
14461 current_function_assigns_this
= 1;
14464 /* Always assume this statement was not an expression statement. If
14465 it actually was an expression statement, its our callers
14466 responsibility to fix this up. */
14467 last_expr_type
= NULL_TREE
;
14470 /* Change a static member function definition into a FUNCTION_TYPE, instead
14471 of the METHOD_TYPE that we create when it's originally parsed.
14473 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14474 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14475 other decls. Either pass the addresses of local variables or NULL. */
14478 revert_static_member_fn (decl
, fn
, argtypes
)
14479 tree
*decl
, *fn
, *argtypes
;
14482 tree function
= fn
? *fn
: TREE_TYPE (*decl
);
14483 tree args
= argtypes
? *argtypes
: TYPE_ARG_TYPES (function
);
14485 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
14486 != TYPE_UNQUALIFIED
)
14487 cp_error ("static member function `%#D' declared with type qualifiers",
14490 args
= TREE_CHAIN (args
);
14491 tmp
= build_function_type (TREE_TYPE (function
), args
);
14492 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
14493 tmp
= build_exception_variant (tmp
,
14494 TYPE_RAISES_EXCEPTIONS (function
));
14495 TREE_TYPE (*decl
) = tmp
;
14496 if (DECL_ARGUMENTS (*decl
))
14497 DECL_ARGUMENTS (*decl
) = TREE_CHAIN (DECL_ARGUMENTS (*decl
));
14498 DECL_STATIC_FUNCTION_P (*decl
) = 1;
14505 /* Save and reinitialize the variables
14506 used during compilation of a C++ function. */
14509 push_cp_function_context (f
)
14510 struct function
*f
;
14512 struct language_function
*p
14513 = ((struct language_function
*)
14514 xmalloc (sizeof (struct language_function
)));
14517 *p
= *f
->next
->language
;
14519 bzero (p
, sizeof (struct language_function
));
14521 /* For now, we always assume we're expanding all the way to RTL
14522 unless we're explicitly doing otherwise. */
14525 /* Whenever we start a new function, we destroy temporaries in the
14527 stmts_are_full_exprs_p
= 1;
14530 /* Restore the variables used during compilation of a C++ function. */
14533 pop_cp_function_context (f
)
14534 struct function
*f
;
14536 free (f
->language
);
14543 return function_depth
!= 0;