1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* Process declarations and symbol lookup for C front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
47 extern int current_class_depth
;
49 extern tree global_namespace
;
51 extern int (*valid_lang_attribute
) PARAMS ((tree
, tree
, tree
, tree
));
53 /* Use garbage collection. */
57 #ifndef BOOL_TYPE_SIZE
58 #ifdef SLOW_BYTE_ACCESS
59 /* In the new ABI, `bool' has size and alignment `1', on all
61 #define BOOL_TYPE_SIZE \
62 ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
64 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
68 /* We let tm.h override the types used here, to handle trivial differences
69 such as the choice of unsigned int or long unsigned int for size_t.
70 When machines start needing nontrivial differences in the size type,
71 it would be best to do something here to figure out automatically
72 from other information what type to use. */
75 #define SIZE_TYPE "long unsigned int"
79 #define PTRDIFF_TYPE "long int"
83 #define WCHAR_TYPE "int"
86 static tree grokparms
PARAMS ((tree
, int));
87 static const char *redeclaration_error_message
PARAMS ((tree
, tree
));
89 static void push_binding_level
PARAMS ((struct binding_level
*, int,
91 static void pop_binding_level
PARAMS ((void));
92 static void suspend_binding_level
PARAMS ((void));
93 static void resume_binding_level
PARAMS ((struct binding_level
*));
94 static struct binding_level
*make_binding_level
PARAMS ((void));
95 static void declare_namespace_level
PARAMS ((void));
96 static int decl_jump_unsafe
PARAMS ((tree
));
97 static void storedecls
PARAMS ((tree
));
98 static void require_complete_types_for_parms
PARAMS ((tree
));
99 static int ambi_op_p
PARAMS ((enum tree_code
));
100 static int unary_op_p
PARAMS ((enum tree_code
));
101 static tree store_bindings
PARAMS ((tree
, tree
));
102 static tree lookup_tag_reverse
PARAMS ((tree
, tree
));
103 static tree obscure_complex_init
PARAMS ((tree
, tree
));
104 static tree lookup_name_real
PARAMS ((tree
, int, int, int));
105 static void warn_extern_redeclared_static
PARAMS ((tree
, tree
));
106 static void grok_reference_init
PARAMS ((tree
, tree
, tree
));
107 static tree grokfndecl
PARAMS ((tree
, tree
, tree
, tree
, int,
108 enum overload_flags
, tree
,
109 tree
, int, int, int, int, int, int, tree
));
110 static tree grokvardecl
PARAMS ((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
111 static tree lookup_tag
PARAMS ((enum tree_code
, tree
,
112 struct binding_level
*, int));
113 static void set_identifier_type_value_with_scope
114 PARAMS ((tree
, tree
, struct binding_level
*));
115 static void record_builtin_type
PARAMS ((enum rid
, const char *, tree
));
116 static void record_unknown_type
PARAMS ((tree
, const char *));
117 static tree build_library_fn_1
PARAMS ((tree
, enum tree_code
, tree
));
118 static int member_function_or_else
PARAMS ((tree
, tree
, enum overload_flags
));
119 static void bad_specifiers
PARAMS ((tree
, const char *, int, int, int, int,
121 static tree maybe_process_template_type_declaration
PARAMS ((tree
, int, struct binding_level
*));
122 static void check_for_uninitialized_const_var
PARAMS ((tree
));
123 static unsigned long typename_hash
PARAMS ((hash_table_key
));
124 static boolean typename_compare
PARAMS ((hash_table_key
, hash_table_key
));
125 static void push_binding
PARAMS ((tree
, tree
, struct binding_level
*));
126 static int add_binding
PARAMS ((tree
, tree
));
127 static void pop_binding
PARAMS ((tree
, tree
));
128 static tree local_variable_p_walkfn
PARAMS ((tree
*, int *, void *));
129 static tree find_binding
PARAMS ((tree
, tree
));
130 static tree select_decl
PARAMS ((tree
, int));
131 static int lookup_flags
PARAMS ((int, int));
132 static tree qualify_lookup
PARAMS ((tree
, int));
133 static tree record_builtin_java_type
PARAMS ((const char *, int));
134 static const char *tag_name
PARAMS ((enum tag_types code
));
135 static void find_class_binding_level
PARAMS ((void));
136 static struct binding_level
*innermost_nonclass_level
PARAMS ((void));
137 static void warn_about_implicit_typename_lookup
PARAMS ((tree
, tree
));
138 static int walk_namespaces_r
PARAMS ((tree
, walk_namespaces_fn
, void *));
139 static int walk_globals_r
PARAMS ((tree
, void *));
140 static void add_decl_to_level
PARAMS ((tree
, struct binding_level
*));
141 static tree make_label_decl
PARAMS ((tree
, int));
142 static void use_label
PARAMS ((tree
));
143 static void check_previous_goto_1
PARAMS ((tree
, struct binding_level
*, tree
,
145 static void check_previous_goto
PARAMS ((struct named_label_use_list
*));
146 static void check_switch_goto
PARAMS ((struct binding_level
*));
147 static void check_previous_gotos
PARAMS ((tree
));
148 static void pop_label
PARAMS ((tree
, tree
));
149 static void pop_labels
PARAMS ((tree
));
150 static void maybe_deduce_size_from_array_init
PARAMS ((tree
, tree
));
151 static void layout_var_decl
PARAMS ((tree
));
152 static void maybe_commonize_var
PARAMS ((tree
));
153 static tree check_initializer
PARAMS ((tree
, tree
));
154 static void make_rtl_for_nonlocal_decl
PARAMS ((tree
, tree
, const char *));
155 static void push_cp_function_context
PARAMS ((struct function
*));
156 static void pop_cp_function_context
PARAMS ((struct function
*));
157 static void mark_binding_level
PARAMS ((void *));
158 static void mark_named_label_lists
PARAMS ((void *, void *));
159 static void mark_cp_function_context
PARAMS ((struct function
*));
160 static void mark_saved_scope
PARAMS ((void *));
161 static void mark_lang_function
PARAMS ((struct cp_language_function
*));
162 static void mark_stmt_tree
PARAMS ((stmt_tree
));
163 static void save_function_data
PARAMS ((tree
));
164 static void check_function_type
PARAMS ((tree
, tree
));
165 static void destroy_local_var
PARAMS ((tree
));
166 static void finish_constructor_body
PARAMS ((void));
167 static void finish_destructor_body
PARAMS ((void));
168 static tree create_array_type_for_decl
PARAMS ((tree
, tree
, tree
));
169 static tree get_atexit_node
PARAMS ((void));
170 static tree get_dso_handle_node
PARAMS ((void));
171 static tree start_cleanup_fn
PARAMS ((void));
172 static void end_cleanup_fn
PARAMS ((void));
173 static tree cp_make_fname_decl
PARAMS ((tree
, const char *, int));
174 static void initialize_predefined_identifiers
PARAMS ((void));
175 static tree check_special_function_return_type
176 PARAMS ((special_function_kind
, tree
, tree
, tree
));
177 static tree push_cp_library_fn
PARAMS ((enum tree_code
, tree
));
178 static tree build_cp_library_fn
PARAMS ((tree
, enum tree_code
, tree
));
179 static int case_compare
PARAMS ((splay_tree_key
, splay_tree_key
));
180 static void store_parm_decls
PARAMS ((tree
));
182 #if defined (DEBUG_CP_BINDING_LEVELS)
183 static void indent
PARAMS ((void));
186 /* Erroneous argument lists can use this *IFF* they do not modify it. */
187 tree error_mark_list
;
189 /* The following symbols are subsumed in the cp_global_trees array, and
190 listed here individually for documentation purposes.
193 tree wchar_decl_node;
195 tree vtable_entry_type;
196 tree delta_type_node;
199 tree __baselist_desc_type_node;
200 tree __i_desc_type_node, __m_desc_type_node;
201 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
203 tree __t_desc_type_node;
205 tree __tp_desc_type_node;
207 tree ti_desc_type_node;
208 tree bltn_desc_type_node, ptr_desc_type_node;
209 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
210 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
211 tree ptm_desc_type_node;
212 tree base_desc_type_node;
214 Not needed yet? May be needed one day?
215 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
216 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
217 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
220 tree class_type_node, record_type_node, union_type_node, enum_type_node;
221 tree unknown_type_node;
223 Array type `vtable_entry_type[]'
226 tree vtbl_ptr_type_node;
233 A FUNCTION_DECL which can call `abort'. Not necessarily the
234 one that the user will declare, but sufficient to be called
235 by routines that want to abort the program.
239 The FUNCTION_DECL for the default `::operator delete'.
241 tree global_delete_fndecl;
244 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
249 tree cp_global_trees
[CPTI_MAX
];
251 /* Indicates that there is a type value in some namespace, although
252 that is not necessarily in scope at the moment. */
254 static tree global_type_node
;
259 /* Expect only namespace names now. */
260 static int only_namespace_names
;
262 /* Used only for jumps to as-yet undefined labels, since jumps to
263 defined labels can have their validity checked immediately. */
265 struct named_label_use_list
267 struct binding_level
*binding_level
;
270 const char *filename_o_goto
;
272 struct named_label_use_list
*next
;
275 #define named_label_uses cp_function_chain->x_named_label_uses
277 /* A list of objects which have constructors or destructors
278 which reside in the global scope. The decl is stored in
279 the TREE_VALUE slot and the initializer is stored
280 in the TREE_PURPOSE slot. */
281 tree static_aggregates
;
285 /* A node for the integer constants 2, and 3. */
287 tree integer_two_node
, integer_three_node
;
289 /* Parsing a function declarator leaves here a chain of structure
290 and enum types declared in the parmlist. */
292 static tree last_function_parm_tags
;
294 /* Similar, for last_function_parm_tags. */
295 tree last_function_parms
;
296 static tree current_function_parm_tags
;
298 /* A list of all LABEL_DECLs in the function that have names. Here so
299 we can clear out their names' definitions at the end of the
300 function, and so we can check the validity of jumps to these labels. */
302 struct named_label_list
304 struct binding_level
*binding_level
;
310 struct named_label_list
*next
;
313 #define named_labels cp_function_chain->x_named_labels
315 /* Set to 0 at beginning of a function definition, and whenever
316 a label (case or named) is defined. Set to value of expression
317 returned from function when that value can be transformed into
318 a named return value. */
320 tree current_function_return_value
;
322 /* Nonzero means use the ISO C94 dialect of C. */
326 /* Nonzero means use the ISO C99 dialect of C. */
330 /* Nonzero means we are a hosted implementation for code shared with C. */
334 /* Nonzero means add default format_arg attributes for functions not
337 int flag_noniso_default_format_attributes
= 1;
339 /* Nonzero means give `double' the same size as `float'. */
341 extern int flag_short_double
;
343 /* Nonzero means don't recognize any builtin functions. */
345 extern int flag_no_builtin
;
347 /* Nonzero means don't recognize the non-ANSI builtin functions.
350 extern int flag_no_nonansi_builtin
;
352 /* Nonzero if we want to conserve space in the .o files. We do this
353 by putting uninitialized data and runtime initialized data into
354 .common instead of .data at the expense of not flagging multiple
356 extern int flag_conserve_space
;
358 /* C and C++ flags are in decl2.c. */
360 /* Flag used when debugging spew.c */
362 extern int spew_debug
;
364 /* A expression of value 0 with the same precision as a sizetype
366 tree signed_size_zero_node
;
368 /* The name of the anonymous namespace, throughout this translation
370 tree anonymous_namespace_name
;
372 /* The number of function bodies which we are currently processing.
373 (Zero if we are at namespace scope, one inside the body of a
374 function, two inside the body of a function in a local class, etc.) */
377 /* For each binding contour we allocate a binding_level structure
378 which records the names defined in that contour.
381 1) one for each function definition,
382 where internal declarations of the parameters appear.
383 2) one for each compound statement,
384 to record its declarations.
386 The current meaning of a name can be found by searching the levels
387 from the current one out to the global one.
389 Off to the side, may be the class_binding_level. This exists only
390 to catch class-local declarations. It is otherwise nonexistent.
392 Also there may be binding levels that catch cleanups that must be
393 run when exceptions occur. Thus, to see whether a name is bound in
394 the current scope, it is not enough to look in the
395 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
398 /* Note that the information in the `names' component of the global contour
399 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
403 /* A chain of _DECL nodes for all variables, constants, functions,
404 and typedef types. These are in the reverse of the order
405 supplied. There may be OVERLOADs on this list, too, but they
406 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
409 /* A list of structure, union and enum definitions, for looking up
411 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
412 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
413 or ENUMERAL_TYPE node.
415 C++: the TREE_VALUE nodes can be simple types for
416 component_bindings. */
419 /* A list of USING_DECL nodes. */
422 /* A list of used namespaces. PURPOSE is the namespace,
423 VALUE the common ancestor with this binding_level's namespace. */
424 tree using_directives
;
426 /* If this binding level is the binding level for a class, then
427 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
428 is the name of an entity bound in the class; the TREE_VALUE is
429 the IDENTIFIER_CLASS_VALUE before we entered the class. Thus,
430 when leaving class scope, we can restore the
431 IDENTIFIER_CLASS_VALUE by walking this list. The TREE_TYPE is
432 the DECL bound by this name in the class. */
435 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
436 is used for all binding levels. */
439 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
440 label in this scope. The TREE_PURPOSE is the previous value of
441 the IDENTIFIER_LABEL VALUE. */
442 tree shadowed_labels
;
444 /* For each level (except not the global one),
445 a chain of BLOCK nodes for all the levels
446 that were entered and exited one level down. */
449 /* The _TYPE node for this level, if parm_flag == 2. */
452 /* The binding level which this one is contained in (inherits from). */
453 struct binding_level
*level_chain
;
455 /* List of decls in `names' that have incomplete
456 structure or union types. */
459 /* List of VAR_DECLS saved from a previous for statement.
460 These would be dead in ISO-conforming code, but might
461 be referenced in ARM-era code. These are stored in a
462 TREE_LIST; the TREE_VALUE is the actual declaration. */
463 tree dead_vars_from_for
;
465 /* 1 for the level that holds the parameters of a function.
466 2 for the level that holds a class declaration. */
467 unsigned parm_flag
: 2;
469 /* 1 means make a BLOCK for this level regardless of all else.
470 2 for temporary binding contours created by the compiler. */
473 /* Nonzero if this level "doesn't exist" for tags. */
474 unsigned tag_transparent
: 1;
476 /* Nonzero if this level can safely have additional
477 cleanup-needing variables added to it. */
478 unsigned more_cleanups_ok
: 1;
479 unsigned have_cleanups
: 1;
481 /* Nonzero if this scope is for storing the decls for template
482 parameters and generic decls; these decls will be discarded and
483 replaced with a TEMPLATE_DECL. */
484 unsigned template_parms_p
: 1;
486 /* Nonzero if this scope corresponds to the `<>' in a
487 `template <>' clause. Whenever this flag is set,
488 TEMPLATE_PARMS_P will be set as well. */
489 unsigned template_spec_p
: 1;
491 /* This is set for a namespace binding level. */
492 unsigned namespace_p
: 1;
494 /* True if this level is that of a for-statement where we need to
495 worry about ambiguous (ARM or ISO) scope rules. */
496 unsigned is_for_scope
: 1;
498 /* True if this level corresponds to an EH region, as for a try block.
499 Currently this information is only available while building the
501 unsigned eh_region
: 1;
503 /* Four bits left for this word. */
505 #if defined(DEBUG_CP_BINDING_LEVELS)
506 /* Binding depth at which this level began. */
507 unsigned binding_depth
;
508 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
511 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
513 /* The binding level currently in effect. */
515 #define current_binding_level \
517 ? cp_function_chain->bindings \
518 : scope_chain->bindings)
520 /* The binding level of the current class, if any. */
522 #define class_binding_level scope_chain->class_bindings
524 /* A chain of binding_level structures awaiting reuse. */
526 static struct binding_level
*free_binding_level
;
528 /* The outermost binding level, for names of file scope.
529 This is created when the compiler is started and exists
530 through the entire run. */
532 static struct binding_level
*global_binding_level
;
534 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
536 static int keep_next_level_flag
;
538 #if defined(DEBUG_CP_BINDING_LEVELS)
539 static int binding_depth
= 0;
540 static int is_class_level
= 0;
547 for (i
= 0; i
< binding_depth
*2; i
++)
550 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
552 static tree pushdecl_with_scope
PARAMS ((tree
, struct binding_level
*));
555 push_binding_level (newlevel
, tag_transparent
, keep
)
556 struct binding_level
*newlevel
;
557 int tag_transparent
, keep
;
559 /* Add this level to the front of the chain (stack) of levels that
561 bzero ((char*) newlevel
, sizeof (struct binding_level
));
562 newlevel
->level_chain
= current_binding_level
;
563 current_binding_level
= newlevel
;
564 newlevel
->tag_transparent
= tag_transparent
;
565 newlevel
->more_cleanups_ok
= 1;
567 newlevel
->keep
= keep
;
568 #if defined(DEBUG_CP_BINDING_LEVELS)
569 newlevel
->binding_depth
= binding_depth
;
571 fprintf (stderr
, "push %s level 0x%08x line %d\n",
572 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
575 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
578 /* Find the innermost enclosing class scope, and reset
579 CLASS_BINDING_LEVEL appropriately. */
582 find_class_binding_level ()
584 struct binding_level
*level
= current_binding_level
;
586 while (level
&& level
->parm_flag
!= 2)
587 level
= level
->level_chain
;
588 if (level
&& level
->parm_flag
== 2)
589 class_binding_level
= level
;
591 class_binding_level
= 0;
597 if (global_binding_level
)
599 /* Cannot pop a level, if there are none left to pop. */
600 if (current_binding_level
== global_binding_level
)
601 my_friendly_abort (123);
603 /* Pop the current level, and free the structure for reuse. */
604 #if defined(DEBUG_CP_BINDING_LEVELS)
607 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
608 (is_class_level
) ? "class" : "block",
609 current_binding_level
, lineno
);
610 if (is_class_level
!= (current_binding_level
== class_binding_level
))
613 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
616 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
618 register struct binding_level
*level
= current_binding_level
;
619 current_binding_level
= current_binding_level
->level_chain
;
620 level
->level_chain
= free_binding_level
;
621 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
622 if (level
->binding_depth
!= binding_depth
)
624 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
625 free_binding_level
= level
;
626 find_class_binding_level ();
631 suspend_binding_level ()
633 if (class_binding_level
)
634 current_binding_level
= class_binding_level
;
636 if (global_binding_level
)
638 /* Cannot suspend a level, if there are none left to suspend. */
639 if (current_binding_level
== global_binding_level
)
640 my_friendly_abort (123);
642 /* Suspend the current level. */
643 #if defined(DEBUG_CP_BINDING_LEVELS)
646 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
647 (is_class_level
) ? "class" : "block",
648 current_binding_level
, lineno
);
649 if (is_class_level
!= (current_binding_level
== class_binding_level
))
652 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
655 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
656 current_binding_level
= current_binding_level
->level_chain
;
657 find_class_binding_level ();
661 resume_binding_level (b
)
662 struct binding_level
*b
;
664 /* Resuming binding levels is meant only for namespaces,
665 and those cannot nest into classes. */
666 my_friendly_assert(!class_binding_level
, 386);
667 /* Also, resuming a non-directly nested namespace is a no-no. */
668 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
669 current_binding_level
= b
;
670 #if defined(DEBUG_CP_BINDING_LEVELS)
671 b
->binding_depth
= binding_depth
;
673 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
674 (is_class_level
) ? "class" : "block", b
, lineno
);
677 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
680 /* Create a new `struct binding_level'. */
683 struct binding_level
*
684 make_binding_level ()
687 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
690 /* Nonzero if we are currently in the global binding level. */
695 return current_binding_level
== global_binding_level
;
698 /* Return the innermost binding level that is not for a class scope. */
700 static struct binding_level
*
701 innermost_nonclass_level ()
703 struct binding_level
*b
;
705 b
= current_binding_level
;
706 while (b
->parm_flag
== 2)
712 /* Nonzero if we are currently in a toplevel binding level. This
713 means either the global binding level or a namespace in a toplevel
714 binding level. Since there are no non-toplevel namespace levels,
715 this really means any namespace or template parameter level. We
716 also include a class whose context is toplevel. */
719 toplevel_bindings_p ()
721 struct binding_level
*b
= innermost_nonclass_level ();
723 return b
->namespace_p
|| b
->template_parms_p
;
726 /* Nonzero if this is a namespace scope, or if we are defining a class
727 which is itself at namespace scope, or whose enclosing class is
728 such a class, etc. */
731 namespace_bindings_p ()
733 struct binding_level
*b
= innermost_nonclass_level ();
735 return b
->namespace_p
;
738 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
739 unconditionally. Otherwise, use the normal logic to decide whether
740 or not to create a BLOCK. */
743 keep_next_level (keep
)
746 keep_next_level_flag
= keep
;
749 /* Nonzero if the current level needs to have a BLOCK made. */
754 return (current_binding_level
->blocks
!= NULL_TREE
755 || current_binding_level
->keep
756 || current_binding_level
->names
!= NULL_TREE
757 || (current_binding_level
->tags
!= NULL_TREE
758 && !current_binding_level
->tag_transparent
));
762 declare_namespace_level ()
764 current_binding_level
->namespace_p
= 1;
767 /* Returns non-zero if this scope was created to store template
771 template_parm_scope_p ()
773 return current_binding_level
->template_parms_p
;
776 /* Returns the kind of template specialization we are currently
777 processing, given that it's declaration contained N_CLASS_SCOPES
778 explicit scope qualifications. */
781 current_tmpl_spec_kind (n_class_scopes
)
784 int n_template_parm_scopes
= 0;
785 int seen_specialization_p
= 0;
786 int innermost_specialization_p
= 0;
787 struct binding_level
*b
;
789 /* Scan through the template parameter scopes. */
790 for (b
= current_binding_level
; b
->template_parms_p
; b
= b
->level_chain
)
792 /* If we see a specialization scope inside a parameter scope,
793 then something is wrong. That corresponds to a declaration
796 template <class T> template <> ...
798 which is always illegal since [temp.expl.spec] forbids the
799 specialization of a class member template if the enclosing
800 class templates are not explicitly specialized as well. */
801 if (b
->template_spec_p
)
803 if (n_template_parm_scopes
== 0)
804 innermost_specialization_p
= 1;
806 seen_specialization_p
= 1;
808 else if (seen_specialization_p
== 1)
809 return tsk_invalid_member_spec
;
811 ++n_template_parm_scopes
;
814 /* Handle explicit instantiations. */
815 if (processing_explicit_instantiation
)
817 if (n_template_parm_scopes
!= 0)
818 /* We've seen a template parameter list during an explicit
819 instantiation. For example:
821 template <class T> template void f(int);
823 This is erroneous. */
824 return tsk_invalid_expl_inst
;
826 return tsk_expl_inst
;
829 if (n_template_parm_scopes
< n_class_scopes
)
830 /* We've not seen enough template headers to match all the
831 specialized classes present. For example:
833 template <class T> void R<T>::S<T>::f(int);
835 This is illegal; there needs to be one set of template
836 parameters for each class. */
837 return tsk_insufficient_parms
;
838 else if (n_template_parm_scopes
== n_class_scopes
)
839 /* We're processing a non-template declaration (even though it may
840 be a member of a template class.) For example:
842 template <class T> void S<T>::f(int);
844 The `class T' maches the `S<T>', leaving no template headers
845 corresponding to the `f'. */
847 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
848 /* We've got too many template headers. For example:
850 template <> template <class T> void f (T);
852 There need to be more enclosing classes. */
853 return tsk_excessive_parms
;
855 /* This must be a template. It's of the form:
857 template <class T> template <class U> void S<T>::f(U);
859 This is a specialization if the innermost level was a
860 specialization; otherwise it's just a definition of the
862 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
866 set_class_shadows (shadows
)
869 class_binding_level
->class_shadowed
= shadows
;
872 /* Enter a new binding level.
873 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
874 not for that of tags. */
877 pushlevel (tag_transparent
)
880 struct binding_level
*newlevel
;
882 if (cfun
&& !doing_semantic_analysis_p ())
885 /* Reuse or create a struct for this binding level. */
886 #if defined(DEBUG_CP_BINDING_LEVELS)
888 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
889 if (free_binding_level
)
890 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
892 newlevel
= free_binding_level
;
893 free_binding_level
= free_binding_level
->level_chain
;
896 newlevel
= make_binding_level ();
898 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
899 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
900 keep_next_level_flag
= 0;
903 /* Enter a new scope. The KIND indicates what kind of scope is being
914 case sk_template_spec
:
915 current_binding_level
->template_spec_p
= 1;
918 case sk_template_parms
:
919 current_binding_level
->template_parms_p
= 1;
923 my_friendly_abort (20000309);
927 /* Exit the current scope. */
936 note_level_for_for ()
938 current_binding_level
->is_for_scope
= 1;
941 /* Record that the current binding level represents a try block. */
946 current_binding_level
->eh_region
= 1;
949 /* For a binding between a name and an entity at a block scope,
950 this is the `struct binding_level' for the block. */
951 #define BINDING_LEVEL(NODE) \
952 (((struct tree_binding*)NODE)->scope.level)
954 /* Make DECL the innermost binding for ID. The LEVEL is the binding
955 level at which this declaration is being bound. */
958 push_binding (id
, decl
, level
)
961 struct binding_level
* level
;
965 binding
= make_node (CPLUS_BINDING
);
967 /* Now, fill in the binding information. */
968 BINDING_VALUE (binding
) = decl
;
969 BINDING_TYPE (binding
) = NULL_TREE
;
970 BINDING_LEVEL (binding
) = level
;
971 INHERITED_VALUE_BINDING_P (binding
) = 0;
972 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
973 BINDING_HAS_LEVEL_P (binding
) = 1;
975 /* And put it on the front of the list of bindings for ID. */
976 TREE_CHAIN (binding
) = IDENTIFIER_BINDING (id
);
977 IDENTIFIER_BINDING (id
) = binding
;
980 /* ID is already bound in the current scope. But, DECL is an
981 additional binding for ID in the same scope. This is the `struct
982 stat' hack whereby a non-typedef class-name or enum-name can be
983 bound at the same level as some other kind of entity. It's the
984 responsibility of the caller to check that inserting this name is
985 legal here. Returns nonzero if the new binding was successful. */
987 add_binding (id
, decl
)
991 tree binding
= IDENTIFIER_BINDING (id
);
994 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
995 /* The new name is the type name. */
996 BINDING_TYPE (binding
) = decl
;
997 else if (!BINDING_VALUE (binding
))
998 /* This situation arises when push_class_level_binding moves an
999 inherited type-binding out of the way to make room for a new
1001 BINDING_VALUE (binding
) = decl
;
1002 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1003 && DECL_ARTIFICIAL (BINDING_VALUE (binding
)))
1005 /* The old binding was a type name. It was placed in
1006 BINDING_VALUE because it was thought, at the point it was
1007 declared, to be the only entity with such a name. Move the
1008 type name into the type slot; it is now hidden by the new
1010 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
1011 BINDING_VALUE (binding
) = decl
;
1012 INHERITED_VALUE_BINDING_P (binding
) = 0;
1014 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1015 && TREE_CODE (decl
) == TYPE_DECL
1016 && DECL_NAME (decl
) == DECL_NAME (BINDING_VALUE (binding
))
1017 && same_type_p (TREE_TYPE (decl
),
1018 TREE_TYPE (BINDING_VALUE (binding
))))
1019 /* We have two typedef-names, both naming the same type to have
1020 the same name. This is OK because of:
1024 In a given scope, a typedef specifier can be used to redefine
1025 the name of any type declared in that scope to refer to the
1026 type to which it already refers. */
1028 /* There can be two block-scope declarations of the same variable,
1029 so long as they are `extern' declarations. */
1030 else if (TREE_CODE (decl
) == VAR_DECL
1031 && TREE_CODE (BINDING_VALUE (binding
)) == VAR_DECL
1032 && DECL_EXTERNAL (decl
)
1033 && DECL_EXTERNAL (BINDING_VALUE (binding
)))
1035 duplicate_decls (decl
, BINDING_VALUE (binding
));
1040 cp_error ("declaration of `%#D'", decl
);
1041 cp_error_at ("conflicts with previous declaration `%#D'",
1042 BINDING_VALUE (binding
));
1049 /* Add DECL to the list of things declared in B. */
1052 add_decl_to_level (decl
, b
)
1054 struct binding_level
*b
;
1056 /* We build up the list in reverse order, and reverse it later if
1058 TREE_CHAIN (decl
) = b
->names
;
1062 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1063 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1064 doesn't really belong to this binding level, that it got here
1065 through a using-declaration. */
1068 push_local_binding (id
, decl
, flags
)
1073 struct binding_level
*b
;
1075 /* Skip over any local classes. This makes sense if we call
1076 push_local_binding with a friend decl of a local class. */
1077 b
= current_binding_level
;
1078 while (b
->parm_flag
== 2)
1081 if (lookup_name_current_level (id
))
1083 /* Supplement the existing binding. */
1084 if (!add_binding (id
, decl
))
1085 /* It didn't work. Something else must be bound at this
1086 level. Do not add DECL to the list of things to pop
1091 /* Create a new binding. */
1092 push_binding (id
, decl
, b
);
1094 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1095 /* We must put the OVERLOAD into a TREE_LIST since the
1096 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1097 decls that got here through a using-declaration. */
1098 decl
= build_tree_list (NULL_TREE
, decl
);
1100 /* And put DECL on the list of things declared by the current
1102 add_decl_to_level (decl
, b
);
1105 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1106 binding was successful. */
1109 push_class_binding (id
, decl
)
1114 tree binding
= IDENTIFIER_BINDING (id
);
1117 /* Note that we declared this value so that we can issue an error if
1118 this an illegal redeclaration of a name already used for some
1120 note_name_declared_in_class (id
, decl
);
1122 if (binding
&& BINDING_LEVEL (binding
) == class_binding_level
)
1123 /* Supplement the existing binding. */
1124 result
= add_binding (id
, decl
);
1126 /* Create a new binding. */
1127 push_binding (id
, decl
, class_binding_level
);
1129 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1130 class-level declaration. Note that we do not use DECL here
1131 because of the possibility of the `struct stat' hack; if DECL is
1132 a class-name or enum-name we might prefer a field-name, or some
1134 IDENTIFIER_CLASS_VALUE (id
) = BINDING_VALUE (IDENTIFIER_BINDING (id
));
1136 /* If this is a binding from a base class, mark it as such. */
1137 binding
= IDENTIFIER_BINDING (id
);
1138 if (BINDING_VALUE (binding
) == decl
&& TREE_CODE (decl
) != TREE_LIST
)
1140 /* Any implicit typename must be from a base-class. The
1141 context for an implicit typename declaration is always
1142 the derived class in which the lookup was done, so the checks
1143 based on the context of DECL below will not trigger. */
1144 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl
))
1145 INHERITED_VALUE_BINDING_P (binding
) = 1;
1148 if (TREE_CODE (decl
) == OVERLOAD
)
1149 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
1152 my_friendly_assert (DECL_P (decl
), 0);
1153 context
= CP_DECL_CONTEXT (decl
);
1156 if (is_properly_derived_from (current_class_type
, context
))
1157 INHERITED_VALUE_BINDING_P (binding
) = 1;
1159 INHERITED_VALUE_BINDING_P (binding
) = 0;
1162 else if (BINDING_VALUE (binding
) == decl
)
1163 /* We only encounter a TREE_LIST when push_class_decls detects an
1164 ambiguity. Such an ambiguity can be overridden by a definition
1166 INHERITED_VALUE_BINDING_P (binding
) = 1;
1171 /* Remove the binding for DECL which should be the innermost binding
1175 pop_binding (id
, decl
)
1181 if (id
== NULL_TREE
)
1182 /* It's easiest to write the loops that call this function without
1183 checking whether or not the entities involved have names. We
1184 get here for such an entity. */
1187 /* Get the innermost binding for ID. */
1188 binding
= IDENTIFIER_BINDING (id
);
1190 /* The name should be bound. */
1191 my_friendly_assert (binding
!= NULL_TREE
, 0);
1193 /* The DECL will be either the ordinary binding or the type
1194 binding for this identifier. Remove that binding. */
1195 if (BINDING_VALUE (binding
) == decl
)
1196 BINDING_VALUE (binding
) = NULL_TREE
;
1197 else if (BINDING_TYPE (binding
) == decl
)
1198 BINDING_TYPE (binding
) = NULL_TREE
;
1200 my_friendly_abort (0);
1202 if (!BINDING_VALUE (binding
) && !BINDING_TYPE (binding
))
1203 /* We're completely done with the innermost binding for this
1204 identifier. Unhook it from the list of bindings. */
1205 IDENTIFIER_BINDING (id
) = TREE_CHAIN (binding
);
1208 /* When a label goes out of scope, check to see if that label was used
1209 in a valid manner, and issue any appropriate warnings or errors. */
1212 pop_label (label
, old_value
)
1216 if (!processing_template_decl
&& doing_semantic_analysis_p ())
1218 if (DECL_INITIAL (label
) == NULL_TREE
)
1220 cp_error_at ("label `%D' used but not defined", label
);
1221 /* Avoid crashing later. */
1222 define_label (input_filename
, 1, DECL_NAME (label
));
1224 else if (warn_unused_label
&& !TREE_USED (label
))
1225 cp_warning_at ("label `%D' defined but not used", label
);
1228 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
1231 /* At the end of a function, all labels declared within the function
1232 go out of scope. BLOCK is the top-level block for the
1239 struct named_label_list
*link
;
1241 /* Clear out the definitions of all label names, since their scopes
1243 for (link
= named_labels
; link
; link
= link
->next
)
1245 pop_label (link
->label_decl
, link
->old_value
);
1246 /* Put the labels into the "variables" of the top-level block,
1247 so debugger can see them. */
1248 TREE_CHAIN (link
->label_decl
) = BLOCK_VARS (block
);
1249 BLOCK_VARS (block
) = link
->label_decl
;
1252 named_labels
= NULL
;
1255 /* Exit a binding level.
1256 Pop the level off, and restore the state of the identifier-decl mappings
1257 that were in effect when this level was entered.
1259 If KEEP == 1, this level had explicit declarations, so
1260 and create a "block" (a BLOCK node) for the level
1261 to record its declarations and subblocks for symbol table output.
1263 If FUNCTIONBODY is nonzero, this level is the body of a function,
1264 so create a block as if KEEP were set and also clear out all
1267 If REVERSE is nonzero, reverse the order of decls before putting
1268 them into the BLOCK. */
1271 poplevel (keep
, reverse
, functionbody
)
1277 /* The chain of decls was accumulated in reverse order.
1278 Put it into forward order, just for cleanliness. */
1280 int tmp
= functionbody
;
1281 int real_functionbody
;
1284 tree block
= NULL_TREE
;
1286 int leaving_for_scope
;
1288 if (cfun
&& !doing_semantic_analysis_p ())
1291 my_friendly_assert (current_binding_level
->parm_flag
!= 2,
1294 real_functionbody
= (current_binding_level
->keep
== 2
1295 ? ((functionbody
= 0), tmp
) : functionbody
);
1296 tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1297 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1299 my_friendly_assert (!current_binding_level
->class_shadowed
,
1302 /* We used to use KEEP == 2 to indicate that the new block should go
1303 at the beginning of the list of blocks at this binding level,
1304 rather than the end. This hack is no longer used. */
1305 my_friendly_assert (keep
== 0 || keep
== 1, 0);
1307 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1308 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1309 current_binding_level
->parm_flag
,
1310 current_binding_level
->keep
);
1312 if (current_binding_level
->keep
== 1)
1315 /* Any uses of undefined labels, and any defined labels, now operate
1316 under constraints of next binding contour. */
1317 if (cfun
&& !functionbody
)
1319 struct binding_level
*level_chain
;
1320 level_chain
= current_binding_level
->level_chain
;
1323 struct named_label_use_list
*uses
;
1324 struct named_label_list
*labels
;
1325 for (labels
= named_labels
; labels
; labels
= labels
->next
)
1326 if (labels
->binding_level
== current_binding_level
)
1329 if (current_binding_level
->eh_region
)
1330 labels
->eh_region
= 1;
1331 for (decl
= labels
->names_in_scope
; decl
;
1332 decl
= TREE_CHAIN (decl
))
1333 if (decl_jump_unsafe (decl
))
1334 labels
->bad_decls
= tree_cons (NULL_TREE
, decl
,
1336 labels
->binding_level
= level_chain
;
1337 labels
->names_in_scope
= level_chain
->names
;
1340 for (uses
= named_label_uses
; uses
; uses
= uses
->next
)
1341 if (uses
->binding_level
== current_binding_level
)
1343 uses
->binding_level
= level_chain
;
1344 uses
->names_in_scope
= level_chain
->names
;
1349 /* Get the decls in the order they were written.
1350 Usually current_binding_level->names is in reverse order.
1351 But parameter decls were previously put in forward order. */
1354 current_binding_level
->names
1355 = decls
= nreverse (current_binding_level
->names
);
1357 decls
= current_binding_level
->names
;
1359 /* Output any nested inline functions within this block
1360 if they weren't already output. */
1361 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1362 if (TREE_CODE (decl
) == FUNCTION_DECL
1363 && ! TREE_ASM_WRITTEN (decl
)
1364 && DECL_INITIAL (decl
) != NULL_TREE
1365 && TREE_ADDRESSABLE (decl
)
1366 && decl_function_context (decl
) == current_function_decl
)
1368 /* If this decl was copied from a file-scope decl
1369 on account of a block-scope extern decl,
1370 propagate TREE_ADDRESSABLE to the file-scope decl. */
1371 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1372 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1375 push_function_context ();
1376 output_inline_function (decl
);
1377 pop_function_context ();
1381 /* When not in function-at-a-time mode, expand_end_bindings will
1382 warn about unused variables. But, in function-at-a-time mode
1383 expand_end_bindings is not passed the list of variables in the
1384 current scope, and therefore no warning is emitted. So, we
1385 explicitly warn here. */
1386 if (!processing_template_decl
)
1387 warn_about_unused_variables (getdecls ());
1389 /* If there were any declarations or structure tags in that level,
1390 or if this level is a function body,
1391 create a BLOCK to record them for the life of this function. */
1393 if (keep
== 1 || functionbody
)
1394 block
= make_node (BLOCK
);
1395 if (block
!= NULL_TREE
)
1397 BLOCK_VARS (block
) = decls
;
1398 BLOCK_SUBBLOCKS (block
) = subblocks
;
1401 /* In each subblock, record that this is its superior. */
1403 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1404 BLOCK_SUPERCONTEXT (link
) = block
;
1406 /* We still support the old for-scope rules, whereby the variables
1407 in a for-init statement were in scope after the for-statement
1408 ended. We only use the new rules in flag_new_for_scope is
1411 = current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1;
1413 /* Remove declarations for all the DECLs in this level. */
1414 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1416 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
1417 && DECL_NAME (link
))
1420 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link
)));
1424 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link
));
1426 ns_binding
= NULL_TREE
;
1429 && (BINDING_LEVEL (outer_binding
)
1430 == current_binding_level
->level_chain
))
1431 /* We have something like:
1436 and we are leaving the `for' scope. There's no reason to
1437 keep the binding of the inner `i' in this case. */
1438 pop_binding (DECL_NAME (link
), link
);
1439 else if ((outer_binding
1440 && (TREE_CODE (BINDING_VALUE (outer_binding
))
1443 && TREE_CODE (ns_binding
) == TYPE_DECL
))
1444 /* Here, we have something like:
1452 We must pop the for-scope binding so we know what's a
1453 type and what isn't. */
1454 pop_binding (DECL_NAME (link
), link
);
1457 /* Mark this VAR_DECL as dead so that we can tell we left it
1458 there only for backward compatibility. */
1459 DECL_DEAD_FOR_LOCAL (link
) = 1;
1461 /* Keep track of what should of have happenned when we
1462 popped the binding. */
1463 if (outer_binding
&& BINDING_VALUE (outer_binding
))
1464 DECL_SHADOWED_FOR_VAR (link
)
1465 = BINDING_VALUE (outer_binding
);
1467 /* Add it to the list of dead variables in the next
1468 outermost binding to that we can remove these when we
1469 leave that binding. */
1470 current_binding_level
->level_chain
->dead_vars_from_for
1471 = tree_cons (NULL_TREE
, link
,
1472 current_binding_level
->level_chain
->
1473 dead_vars_from_for
);
1475 /* Although we don't pop the CPLUS_BINDING, we do clear
1476 its BINDING_LEVEL since the level is going away now. */
1477 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link
)))
1483 /* Remove the binding. */
1485 if (TREE_CODE (decl
) == TREE_LIST
)
1486 decl
= TREE_VALUE (decl
);
1488 pop_binding (DECL_NAME (decl
), decl
);
1489 else if (TREE_CODE (decl
) == OVERLOAD
)
1490 pop_binding (DECL_NAME (OVL_FUNCTION (decl
)), decl
);
1492 my_friendly_abort (0);
1496 /* Remove declarations for any `for' variables from inner scopes
1497 that we kept around. */
1498 for (link
= current_binding_level
->dead_vars_from_for
;
1499 link
; link
= TREE_CHAIN (link
))
1500 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
1502 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1503 for (link
= current_binding_level
->type_shadowed
;
1504 link
; link
= TREE_CHAIN (link
))
1505 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1507 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1508 for (link
= current_binding_level
->shadowed_labels
;
1510 link
= TREE_CHAIN (link
))
1511 pop_label (TREE_VALUE (link
), TREE_PURPOSE (link
));
1513 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1514 list if a `using' declaration put them there. The debugging
1515 back-ends won't understand OVERLOAD, so we remove them here.
1516 Because the BLOCK_VARS are (temporarily) shared with
1517 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1518 popped all the bindings. */
1523 for (d
= &BLOCK_VARS (block
); *d
; )
1525 if (TREE_CODE (*d
) == TREE_LIST
)
1526 *d
= TREE_CHAIN (*d
);
1528 d
= &TREE_CHAIN (*d
);
1532 /* If the level being exited is the top level of a function,
1533 check over all the labels. */
1536 /* Since this is the top level block of a function, the vars are
1537 the function's parameters. Don't leave them in the BLOCK
1538 because they are found in the FUNCTION_DECL instead. */
1539 BLOCK_VARS (block
) = 0;
1543 tmp
= current_binding_level
->keep
;
1545 pop_binding_level ();
1547 DECL_INITIAL (current_function_decl
) = block
;
1549 current_binding_level
->blocks
1550 = chainon (current_binding_level
->blocks
, block
);
1552 /* If we did not make a block for the level just exited,
1553 any blocks made for inner levels
1554 (since they cannot be recorded as subblocks in that level)
1555 must be carried forward so they will later become subblocks
1556 of something else. */
1558 current_binding_level
->blocks
1559 = chainon (current_binding_level
->blocks
, subblocks
);
1561 /* Each and every BLOCK node created here in `poplevel' is important
1562 (e.g. for proper debugging information) so if we created one
1563 earlier, mark it as "used". */
1565 TREE_USED (block
) = 1;
1567 /* Take care of compiler's internal binding structures. */
1573 = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1576 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts
)) = block
;
1577 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts
)) = block
;
1580 block
= poplevel (keep
, reverse
, functionbody
);
1586 /* Delete the node BLOCK from the current binding level.
1587 This is used for the block inside a stmt expr ({...})
1588 so that the block can be reinserted where appropriate. */
1591 delete_block (block
)
1595 if (current_binding_level
->blocks
== block
)
1596 current_binding_level
->blocks
= TREE_CHAIN (block
);
1597 for (t
= current_binding_level
->blocks
; t
;)
1599 if (TREE_CHAIN (t
) == block
)
1600 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1604 TREE_CHAIN (block
) = NULL_TREE
;
1605 /* Clear TREE_USED which is always set by poplevel.
1606 The flag is set again if insert_block is called. */
1607 TREE_USED (block
) = 0;
1610 /* Insert BLOCK at the end of the list of subblocks of the
1611 current binding level. This is used when a BIND_EXPR is expanded,
1612 to handle the BLOCK node inside the BIND_EXPR. */
1615 insert_block (block
)
1618 TREE_USED (block
) = 1;
1619 current_binding_level
->blocks
1620 = chainon (current_binding_level
->blocks
, block
);
1623 /* Set the BLOCK node for the innermost scope
1624 (the one we are currently in). */
1628 tree block ATTRIBUTE_UNUSED
;
1630 /* The RTL expansion machinery requires us to provide this callback,
1631 but it is not applicable in function-at-a-time mode. */
1632 my_friendly_assert (cfun
&& !doing_semantic_analysis_p (), 20000911);
1635 /* Do a pushlevel for class declarations. */
1640 register struct binding_level
*newlevel
;
1642 /* Reuse or create a struct for this binding level. */
1643 #if defined(DEBUG_CP_BINDING_LEVELS)
1645 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1646 if (free_binding_level
)
1647 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1649 newlevel
= free_binding_level
;
1650 free_binding_level
= free_binding_level
->level_chain
;
1653 newlevel
= make_binding_level ();
1655 #if defined(DEBUG_CP_BINDING_LEVELS)
1657 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1659 push_binding_level (newlevel
, 0, 0);
1661 class_binding_level
= current_binding_level
;
1662 class_binding_level
->parm_flag
= 2;
1663 class_binding_level
->this_class
= current_class_type
;
1666 /* ...and a poplevel for class declarations. */
1671 register struct binding_level
*level
= class_binding_level
;
1674 my_friendly_assert (level
!= 0, 354);
1676 /* If we're leaving a toplevel class, don't bother to do the setting
1677 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1678 shouldn't even be used when current_class_type isn't set, and second,
1679 if we don't touch it here, we're able to use the cache effect if the
1680 next time we're entering a class scope, it is the same class. */
1681 if (current_class_depth
!= 1)
1683 struct binding_level
* b
;
1685 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1686 for (shadowed
= level
->class_shadowed
;
1688 shadowed
= TREE_CHAIN (shadowed
))
1689 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = NULL_TREE
;
1691 /* Find the next enclosing class, and recreate
1692 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1693 b
= level
->level_chain
;
1694 while (b
&& b
->parm_flag
!= 2)
1698 for (shadowed
= b
->class_shadowed
;
1700 shadowed
= TREE_CHAIN (shadowed
))
1704 t
= IDENTIFIER_BINDING (TREE_PURPOSE (shadowed
));
1705 while (t
&& BINDING_LEVEL (t
) != b
)
1709 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
))
1710 = BINDING_VALUE (t
);
1714 /* Remember to save what IDENTIFIER's were bound in this scope so we
1715 can recover from cache misses. */
1717 previous_class_type
= current_class_type
;
1718 previous_class_values
= class_binding_level
->class_shadowed
;
1720 for (shadowed
= level
->type_shadowed
;
1722 shadowed
= TREE_CHAIN (shadowed
))
1723 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1725 /* Remove the bindings for all of the class-level declarations. */
1726 for (shadowed
= level
->class_shadowed
;
1728 shadowed
= TREE_CHAIN (shadowed
))
1729 pop_binding (TREE_PURPOSE (shadowed
), TREE_TYPE (shadowed
));
1731 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1732 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1733 class_binding_level
->parm_flag
,
1734 class_binding_level
->keep
);
1736 /* Now, pop out of the binding level which we created up in the
1737 `pushlevel_class' routine. */
1738 #if defined(DEBUG_CP_BINDING_LEVELS)
1740 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1742 pop_binding_level ();
1745 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1746 for any names in enclosing classes. */
1749 clear_identifier_class_values ()
1753 if (!class_binding_level
)
1756 for (t
= class_binding_level
->class_shadowed
;
1759 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t
)) = NULL_TREE
;
1762 /* Returns non-zero if T is a virtual function table. */
1765 vtable_decl_p (t
, data
)
1767 void *data ATTRIBUTE_UNUSED
;
1769 return (TREE_CODE (t
) == VAR_DECL
&& DECL_VIRTUAL_P (t
));
1772 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1776 vtype_decl_p (t
, data
)
1778 void *data ATTRIBUTE_UNUSED
;
1780 return (TREE_CODE (t
) == TYPE_DECL
1781 && TREE_CODE (TREE_TYPE (t
)) == RECORD_TYPE
1782 && TYPE_POLYMORPHIC_P (TREE_TYPE (t
)));
1785 /* Return the declarations that are members of the namespace NS. */
1788 cp_namespace_decls (ns
)
1791 return NAMESPACE_LEVEL (ns
)->names
;
1794 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1795 itself, calling F for each. The DATA is passed to F as well. */
1798 walk_namespaces_r (namespace, f
, data
)
1800 walk_namespaces_fn f
;
1806 result
|= (*f
) (namespace, data
);
1808 for (current
= cp_namespace_decls (namespace);
1810 current
= TREE_CHAIN (current
))
1812 if (TREE_CODE (current
) != NAMESPACE_DECL
1813 || DECL_NAMESPACE_ALIAS (current
))
1815 if (!DECL_LANG_SPECIFIC (current
))
1818 my_friendly_assert (current
== std_node
, 393);
1822 /* We found a namespace. */
1823 result
|= walk_namespaces_r (current
, f
, data
);
1829 /* Walk all the namespaces, calling F for each. The DATA is passed to
1833 walk_namespaces (f
, data
)
1834 walk_namespaces_fn f
;
1837 return walk_namespaces_r (global_namespace
, f
, data
);
1840 struct walk_globals_data
{
1841 walk_globals_pred p
;
1846 /* Walk the global declarations in NAMESPACE. Whenever one is found
1847 for which P returns non-zero, call F with its address. If any call
1848 to F returns a non-zero value, return a non-zero value. */
1851 walk_globals_r (namespace, data
)
1855 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
1856 walk_globals_pred p
= wgd
->p
;
1857 walk_globals_fn f
= wgd
->f
;
1858 void *d
= wgd
->data
;
1862 t
= &NAMESPACE_LEVEL (namespace)->names
;
1869 result
|= (*f
) (t
, d
);
1871 /* If F changed *T, then *T still points at the next item to
1874 t
= &TREE_CHAIN (*t
);
1880 /* Walk the global declarations. Whenever one is found for which P
1881 returns non-zero, call F with its address. If any call to F
1882 returns a non-zero value, return a non-zero value. */
1885 walk_globals (p
, f
, data
)
1886 walk_globals_pred p
;
1890 struct walk_globals_data wgd
;
1895 return walk_namespaces (walk_globals_r
, &wgd
);
1898 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1899 DATA is non-NULL, this is the last time we will call
1900 wrapup_global_declarations for this NAMESPACE. */
1903 wrapup_globals_for_namespace (namespace, data
)
1907 tree globals
= cp_namespace_decls (namespace);
1908 int len
= list_length (globals
);
1909 tree
*vec
= (tree
*) alloca (sizeof (tree
) * len
);
1913 int last_time
= (data
!= 0);
1915 if (last_time
&& namespace == global_namespace
)
1916 /* Let compile_file handle the global namespace. */
1919 /* Process the decls in reverse order--earliest first.
1920 Put them into VEC from back to front, then take out from front. */
1922 for (i
= 0, decl
= globals
; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
1924 /* Pretend we've output an unused static variable. This ensures
1925 that the toplevel __FUNCTION__ etc won't be emitted, unless
1927 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_ARTIFICIAL (decl
)
1928 && !TREE_PUBLIC (decl
) && !TREE_USED (decl
))
1930 TREE_ASM_WRITTEN (decl
) = 1;
1931 DECL_IGNORED_P (decl
) = 1;
1933 vec
[len
- i
- 1] = decl
;
1938 check_global_declarations (vec
, len
);
1942 /* Temporarily mark vtables as external. That prevents
1943 wrapup_global_declarations from writing them out; we must process
1944 them ourselves in finish_vtable_vardecl. */
1945 for (i
= 0; i
< len
; ++i
)
1946 if (vtable_decl_p (vec
[i
], /*data=*/0) && !DECL_EXTERNAL (vec
[i
]))
1948 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 1;
1949 DECL_EXTERNAL (vec
[i
]) = 1;
1952 /* Write out any globals that need to be output. */
1953 result
= wrapup_global_declarations (vec
, len
);
1955 /* Undo the hack to DECL_EXTERNAL above. */
1956 for (i
= 0; i
< len
; ++i
)
1957 if (vtable_decl_p (vec
[i
], /*data=*/0)
1958 && DECL_NOT_REALLY_EXTERN (vec
[i
]))
1960 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 0;
1961 DECL_EXTERNAL (vec
[i
]) = 0;
1968 /* Mark ARG (which is really a struct binding_level **) for GC. */
1971 mark_binding_level (arg
)
1974 struct binding_level
*lvl
= *(struct binding_level
**)arg
;
1976 for (; lvl
; lvl
= lvl
->level_chain
)
1978 ggc_mark_tree (lvl
->names
);
1979 ggc_mark_tree (lvl
->tags
);
1980 ggc_mark_tree (lvl
->usings
);
1981 ggc_mark_tree (lvl
->using_directives
);
1982 ggc_mark_tree (lvl
->class_shadowed
);
1983 ggc_mark_tree (lvl
->type_shadowed
);
1984 ggc_mark_tree (lvl
->shadowed_labels
);
1985 ggc_mark_tree (lvl
->blocks
);
1986 ggc_mark_tree (lvl
->this_class
);
1987 ggc_mark_tree (lvl
->incomplete
);
1988 ggc_mark_tree (lvl
->dead_vars_from_for
);
1993 mark_named_label_lists (labs
, uses
)
1997 struct named_label_list
*l
= *(struct named_label_list
**)labs
;
1998 struct named_label_use_list
*u
= *(struct named_label_use_list
**)uses
;
2000 for (; l
; l
= l
->next
)
2003 mark_binding_level (l
->binding_level
);
2004 ggc_mark_tree (l
->old_value
);
2005 ggc_mark_tree (l
->label_decl
);
2006 ggc_mark_tree (l
->bad_decls
);
2009 for (; u
; u
= u
->next
)
2013 /* For debugging. */
2014 static int no_print_functions
= 0;
2015 static int no_print_builtins
= 0;
2018 print_binding_level (lvl
)
2019 struct binding_level
*lvl
;
2023 fprintf (stderr
, " blocks=");
2024 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
2025 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
2026 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
2027 if (lvl
->tag_transparent
)
2028 fprintf (stderr
, " tag-transparent");
2029 if (lvl
->more_cleanups_ok
)
2030 fprintf (stderr
, " more-cleanups-ok");
2031 if (lvl
->have_cleanups
)
2032 fprintf (stderr
, " have-cleanups");
2033 fprintf (stderr
, "\n");
2036 fprintf (stderr
, " names:\t");
2037 /* We can probably fit 3 names to a line? */
2038 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
2040 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
2042 if (no_print_builtins
2043 && (TREE_CODE (t
) == TYPE_DECL
)
2044 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
2047 /* Function decls tend to have longer names. */
2048 if (TREE_CODE (t
) == FUNCTION_DECL
)
2055 fprintf (stderr
, "\n\t");
2058 print_node_brief (stderr
, "", t
, 0);
2059 if (t
== error_mark_node
)
2063 fprintf (stderr
, "\n");
2067 fprintf (stderr
, " tags:\t");
2069 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
2071 if (TREE_PURPOSE (t
) == NULL_TREE
)
2073 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2080 fprintf (stderr
, "\n\t");
2083 if (TREE_PURPOSE (t
) == NULL_TREE
)
2085 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
2086 fprintf (stderr
, ">");
2088 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2089 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2092 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
2093 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2094 fprintf (stderr
, ">");
2098 fprintf (stderr
, "\n");
2100 if (lvl
->class_shadowed
)
2102 fprintf (stderr
, " class-shadowed:");
2103 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
2105 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2107 fprintf (stderr
, "\n");
2109 if (lvl
->type_shadowed
)
2111 fprintf (stderr
, " type-shadowed:");
2112 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2114 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2116 fprintf (stderr
, "\n");
2121 print_other_binding_stack (stack
)
2122 struct binding_level
*stack
;
2124 struct binding_level
*level
;
2125 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
2127 fprintf (stderr
, "binding level ");
2128 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
2129 fprintf (stderr
, "\n");
2130 print_binding_level (level
);
2135 print_binding_stack ()
2137 struct binding_level
*b
;
2138 fprintf (stderr
, "current_binding_level=");
2139 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
2140 fprintf (stderr
, "\nclass_binding_level=");
2141 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
2142 fprintf (stderr
, "\nglobal_binding_level=");
2143 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
2144 fprintf (stderr
, "\n");
2145 if (class_binding_level
)
2147 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
2148 if (b
== current_binding_level
)
2151 b
= class_binding_level
;
2153 b
= current_binding_level
;
2156 b
= current_binding_level
;
2157 print_other_binding_stack (b
);
2158 fprintf (stderr
, "global:\n");
2159 print_binding_level (global_binding_level
);
2162 /* Namespace binding access routines: The namespace_bindings field of
2163 the identifier is polymorphic, with three possible values:
2164 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2165 indicating the BINDING_VALUE of global_namespace. */
2167 /* Check whether the a binding for the name to scope is known.
2168 Assumes that the bindings of the name are already a list
2169 of bindings. Returns the binding found, or NULL_TREE. */
2172 find_binding (name
, scope
)
2176 tree iter
, prev
= NULL_TREE
;
2178 scope
= ORIGINAL_NAMESPACE (scope
);
2180 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
2181 iter
= TREE_CHAIN (iter
))
2183 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
2184 if (BINDING_SCOPE (iter
) == scope
)
2186 /* Move binding found to the front of the list, so
2187 subsequent lookups will find it faster. */
2190 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
2191 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
2192 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
2201 /* Always returns a binding for name in scope. If the
2202 namespace_bindings is not a list, convert it to one first.
2203 If no binding is found, make a new one. */
2206 binding_for_name (name
, scope
)
2210 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2213 scope
= ORIGINAL_NAMESPACE (scope
);
2215 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
2217 /* Get rid of optimization for global scope. */
2218 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
2219 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
2220 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2222 if (b
&& (result
= find_binding (name
, scope
)))
2224 /* Not found, make a new one. */
2225 result
= make_node (CPLUS_BINDING
);
2226 TREE_CHAIN (result
) = b
;
2227 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2228 BINDING_SCOPE (result
) = scope
;
2229 BINDING_TYPE (result
) = NULL_TREE
;
2230 BINDING_VALUE (result
) = NULL_TREE
;
2234 /* Return the binding value for name in scope, considering that
2235 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2238 namespace_binding (name
, scope
)
2242 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2245 if (scope
== NULL_TREE
)
2246 scope
= global_namespace
;
2247 if (TREE_CODE (b
) != CPLUS_BINDING
)
2248 return (scope
== global_namespace
) ? b
: NULL_TREE
;
2249 name
= find_binding (name
,scope
);
2250 if (name
== NULL_TREE
)
2252 return BINDING_VALUE (name
);
2255 /* Set the binding value for name in scope. If modifying the binding
2256 of global_namespace is attempted, try to optimize it. */
2259 set_namespace_binding (name
, scope
, val
)
2266 if (scope
== NULL_TREE
)
2267 scope
= global_namespace
;
2269 if (scope
== global_namespace
)
2271 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2272 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
2274 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
2278 b
= binding_for_name (name
, scope
);
2279 BINDING_VALUE (b
) = val
;
2282 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2283 select a name that is unique to this compilation unit. */
2286 push_namespace (name
)
2291 int implicit_use
= 0;
2293 if (!global_namespace
)
2295 /* This must be ::. */
2296 my_friendly_assert (name
== get_identifier ("::"), 377);
2301 /* The name of anonymous namespace is unique for the translation
2303 if (!anonymous_namespace_name
)
2304 anonymous_namespace_name
= get_file_function_name ('N');
2305 name
= anonymous_namespace_name
;
2306 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2308 /* Reopening anonymous namespace. */
2312 else if (current_namespace
== global_namespace
2313 && name
== DECL_NAME (std_node
))
2320 /* Check whether this is an extended namespace definition. */
2321 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2322 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2325 if (DECL_NAMESPACE_ALIAS (d
))
2327 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2328 d
, DECL_NAMESPACE_ALIAS (d
));
2329 d
= DECL_NAMESPACE_ALIAS (d
);
2336 /* Make a new namespace, binding the name to it. */
2337 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2338 /* The global namespace is not pushed, and the global binding
2339 level is set elsewhere. */
2342 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
2345 declare_namespace_level ();
2346 NAMESPACE_LEVEL (d
) = current_binding_level
;
2350 resume_binding_level (NAMESPACE_LEVEL (d
));
2353 do_using_directive (d
);
2354 /* Enter the name space. */
2355 current_namespace
= d
;
2358 /* Pop from the scope of the current namespace. */
2363 if (current_namespace
== global_namespace
)
2365 my_friendly_assert (in_std
>0, 980421);
2369 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2370 /* The binding level is not popped, as it might be re-opened later. */
2371 suspend_binding_level ();
2374 /* Push into the scope of the namespace NS, even if it is deeply
2375 nested within another namespace. */
2378 push_nested_namespace (ns
)
2381 if (ns
== global_namespace
)
2382 push_to_top_level ();
2385 push_nested_namespace (CP_DECL_CONTEXT (ns
));
2386 push_namespace (DECL_NAME (ns
));
2390 /* Pop back from the scope of the namespace NS, which was previously
2391 entered with push_nested_namespace. */
2394 pop_nested_namespace (ns
)
2397 while (ns
!= global_namespace
)
2400 ns
= CP_DECL_CONTEXT (ns
);
2403 pop_from_top_level ();
2407 /* Subroutines for reverting temporarily to top-level for instantiation
2408 of templates and such. We actually need to clear out the class- and
2409 local-value slots of all identifiers, so that only the global values
2410 are at all visible. Simply setting current_binding_level to the global
2411 scope isn't enough, because more binding levels may be pushed. */
2412 struct saved_scope
*scope_chain
;
2414 /* Mark ST for GC. */
2420 ggc_mark_tree (st
->x_last_stmt
);
2421 ggc_mark_tree (st
->x_last_expr_type
);
2424 /* Mark ARG (which is really a struct saved_scope **) for GC. */
2427 mark_saved_scope (arg
)
2430 struct saved_scope
*t
= *(struct saved_scope
**)arg
;
2433 mark_binding_level (&t
->class_bindings
);
2434 ggc_mark_tree (t
->old_bindings
);
2435 ggc_mark_tree (t
->old_namespace
);
2436 ggc_mark_tree (t
->class_name
);
2437 ggc_mark_tree (t
->class_type
);
2438 ggc_mark_tree (t
->access_specifier
);
2439 ggc_mark_tree (t
->function_decl
);
2441 ggc_mark_tree_varray (t
->lang_base
);
2442 ggc_mark_tree (t
->lang_name
);
2443 ggc_mark_tree (t
->template_parms
);
2444 ggc_mark_tree (t
->x_previous_class_type
);
2445 ggc_mark_tree (t
->x_previous_class_values
);
2446 ggc_mark_tree (t
->x_saved_tree
);
2447 ggc_mark_tree (t
->incomplete
);
2448 ggc_mark_tree (t
->lookups
);
2450 mark_stmt_tree (&t
->x_stmt_tree
);
2451 mark_binding_level (&t
->bindings
);
2457 store_bindings (names
, old_bindings
)
2458 tree names
, old_bindings
;
2461 for (t
= names
; t
; t
= TREE_CHAIN (t
))
2463 tree binding
, t1
, id
;
2465 if (TREE_CODE (t
) == TREE_LIST
)
2466 id
= TREE_PURPOSE (t
);
2471 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2472 we have no IDENTIFIER_BINDING if we have left the class
2473 scope, but cached the class-level declarations. */
2474 || !(IDENTIFIER_BINDING (id
) || IDENTIFIER_CLASS_VALUE (id
)))
2477 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
2478 if (TREE_VEC_ELT (t1
, 0) == id
)
2481 binding
= make_tree_vec (4);
2485 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
2486 TREE_VEC_ELT (binding
, 0) = id
;
2487 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
2488 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_BINDING (id
);
2489 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
2490 IDENTIFIER_BINDING (id
) = NULL_TREE
;
2491 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
2493 TREE_CHAIN (binding
) = old_bindings
;
2494 old_bindings
= binding
;
2498 return old_bindings
;
2502 maybe_push_to_top_level (pseudo
)
2505 struct saved_scope
*s
;
2506 struct binding_level
*b
;
2510 s
= (struct saved_scope
*) xcalloc (1, sizeof (struct saved_scope
));
2512 b
= scope_chain
? current_binding_level
: 0;
2514 /* If we're in the middle of some function, save our state. */
2518 push_function_context_to (NULL_TREE
);
2523 old_bindings
= NULL_TREE
;
2524 if (scope_chain
&& previous_class_type
)
2525 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
2527 /* Have to include global_binding_level, because class-level decls
2528 aren't listed anywhere useful. */
2529 for (; b
; b
= b
->level_chain
)
2533 /* Template IDs are inserted into the global level. If they were
2534 inserted into namespace level, finish_file wouldn't find them
2535 when doing pending instantiations. Therefore, don't stop at
2536 namespace level, but continue until :: . */
2537 if (b
== global_binding_level
|| (pseudo
&& b
->template_parms_p
))
2540 old_bindings
= store_bindings (b
->names
, old_bindings
);
2541 /* We also need to check class_shadowed to save class-level type
2542 bindings, since pushclass doesn't fill in b->names. */
2543 if (b
->parm_flag
== 2)
2544 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2546 /* Unwind type-value slots back to top level. */
2547 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2548 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2550 s
->prev
= scope_chain
;
2551 s
->old_bindings
= old_bindings
;
2553 s
->need_pop_function_context
= need_pop
;
2554 s
->function_decl
= current_function_decl
;
2557 current_function_decl
= NULL_TREE
;
2558 VARRAY_TREE_INIT (current_lang_base
, 10, "current_lang_base");
2559 current_lang_stack
= &VARRAY_TREE (current_lang_base
, 0);
2560 current_lang_name
= lang_name_cplusplus
;
2561 current_namespace
= global_namespace
;
2565 push_to_top_level ()
2567 maybe_push_to_top_level (0);
2571 pop_from_top_level ()
2573 struct saved_scope
*s
= scope_chain
;
2576 /* Clear out class-level bindings cache. */
2577 if (previous_class_type
)
2578 invalidate_class_lookup_cache ();
2580 VARRAY_FREE (current_lang_base
);
2582 scope_chain
= s
->prev
;
2583 for (t
= s
->old_bindings
; t
; t
= TREE_CHAIN (t
))
2585 tree id
= TREE_VEC_ELT (t
, 0);
2588 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2589 IDENTIFIER_BINDING (id
) = TREE_VEC_ELT (t
, 2);
2590 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2594 /* If we were in the middle of compiling a function, restore our
2596 if (s
->need_pop_function_context
)
2597 pop_function_context_from (NULL_TREE
);
2598 current_function_decl
= s
->function_decl
;
2603 /* Push a definition of struct, union or enum tag "name".
2604 into binding_level "b". "type" should be the type node,
2605 We assume that the tag "name" is not already defined.
2607 Note that the definition may really be just a forward reference.
2608 In that case, the TYPE_SIZE will be a NULL_TREE.
2610 C++ gratuitously puts all these tags in the name space. */
2612 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2613 record the shadowed value for this binding contour. TYPE is
2614 the type that ID maps to. */
2617 set_identifier_type_value_with_scope (id
, type
, b
)
2620 struct binding_level
*b
;
2622 if (!b
->namespace_p
)
2624 /* Shadow the marker, not the real thing, so that the marker
2625 gets restored later. */
2626 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2628 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2632 tree binding
= binding_for_name (id
, current_namespace
);
2633 BINDING_TYPE (binding
) = type
;
2634 /* Store marker instead of real type. */
2635 type
= global_type_node
;
2637 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2640 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2643 set_identifier_type_value (id
, type
)
2647 set_identifier_type_value_with_scope (id
, type
, current_binding_level
);
2650 /* Return the type associated with id. */
2653 identifier_type_value (id
)
2656 /* There is no type with that name, anywhere. */
2657 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2659 /* This is not the type marker, but the real thing. */
2660 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2661 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2662 /* Have to search for it. It must be on the global level, now.
2663 Ask lookup_name not to return non-types. */
2664 id
= lookup_name_real (id
, 2, 1, 0);
2666 return TREE_TYPE (id
);
2670 /* Pop off extraneous binding levels left over due to syntax errors.
2672 We don't pop past namespaces, as they might be valid. */
2677 #ifdef DEBUG_CP_BINDING_LEVELS
2678 fprintf (stderr
, "XXX entering pop_everything ()\n");
2680 while (!toplevel_bindings_p ())
2682 if (current_binding_level
->parm_flag
== 2)
2683 pop_nested_class ();
2687 #ifdef DEBUG_CP_BINDING_LEVELS
2688 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2692 /* The type TYPE is being declared. If it is a class template, or a
2693 specialization of a class template, do any processing required and
2694 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2695 being declared a friend. B is the binding level at which this TYPE
2698 Returns the TYPE_DECL for TYPE, which may have been altered by this
2702 maybe_process_template_type_declaration (type
, globalize
, b
)
2705 struct binding_level
* b
;
2707 tree decl
= TYPE_NAME (type
);
2709 if (processing_template_parmlist
)
2710 /* You can't declare a new template type in a template parameter
2711 list. But, you can declare a non-template type:
2713 template <class A*> struct S;
2715 is a forward-declaration of `A'. */
2719 maybe_check_template_type (type
);
2721 my_friendly_assert (IS_AGGR_TYPE (type
)
2722 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2725 if (processing_template_decl
)
2727 /* This may change after the call to
2728 push_template_decl_real, but we want the original value. */
2729 tree name
= DECL_NAME (decl
);
2731 decl
= push_template_decl_real (decl
, globalize
);
2732 /* If the current binding level is the binding level for the
2733 template parameters (see the comment in
2734 begin_template_parm_list) and the enclosing level is a class
2735 scope, and we're not looking at a friend, push the
2736 declaration of the member class into the class scope. In the
2737 friend case, push_template_decl will already have put the
2738 friend into global scope, if appropriate. */
2739 if (TREE_CODE (type
) != ENUMERAL_TYPE
2740 && !globalize
&& b
->template_parms_p
2741 && b
->level_chain
->parm_flag
== 2)
2743 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2744 /* Put this tag on the list of tags for the class, since
2745 that won't happen below because B is not the class
2746 binding level, but is instead the pseudo-global level. */
2747 b
->level_chain
->tags
=
2748 tree_cons (name
, type
, b
->level_chain
->tags
);
2749 if (!COMPLETE_TYPE_P (current_class_type
))
2750 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2758 /* In C++, you don't have to write `struct S' to refer to `S'; you
2759 can just use `S'. We accomplish this by creating a TYPE_DECL as
2760 if the user had written `typedef struct S S'. Create and return
2761 the TYPE_DECL for TYPE. */
2764 create_implicit_typedef (name
, type
)
2770 decl
= build_decl (TYPE_DECL
, name
, type
);
2771 DECL_ARTIFICIAL (decl
) = 1;
2772 /* There are other implicit type declarations, like the one *within*
2773 a class that allows you to write `S::S'. We must distinguish
2775 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
2776 TYPE_NAME (type
) = decl
;
2781 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2782 Normally put it into the inner-most non-tag-transparent scope,
2783 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2784 The latter is needed for implicit declarations. */
2787 pushtag (name
, type
, globalize
)
2791 register struct binding_level
*b
;
2793 b
= current_binding_level
;
2794 while (b
->tag_transparent
2795 || (globalize
&& b
->parm_flag
== 2))
2798 b
->tags
= tree_cons (name
, type
, b
->tags
);
2802 /* Do C++ gratuitous typedefing. */
2803 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2805 register tree d
= NULL_TREE
;
2807 tree context
= TYPE_CONTEXT (type
);
2811 tree cs
= current_scope ();
2815 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
2816 /* When declaring a friend class of a local class, we want
2817 to inject the newly named class into the scope
2818 containing the local class, not the namespace scope. */
2819 context
= decl_function_context (get_type_decl (cs
));
2822 context
= current_namespace
;
2824 if ((b
->template_parms_p
&& b
->level_chain
->parm_flag
== 2)
2825 || b
->parm_flag
== 2)
2828 if (current_lang_name
== lang_name_java
)
2829 TYPE_FOR_JAVA (type
) = 1;
2831 d
= create_implicit_typedef (name
, type
);
2832 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2834 set_identifier_type_value_with_scope (name
, type
, b
);
2836 d
= maybe_process_template_type_declaration (type
,
2839 if (b
->parm_flag
== 2)
2841 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2842 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2843 class. But if it's a member template class, we
2844 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2846 finish_member_declaration (d
);
2848 pushdecl_class_level (d
);
2851 d
= pushdecl_with_scope (d
, b
);
2853 if (ANON_AGGRNAME_P (name
))
2854 DECL_IGNORED_P (d
) = 1;
2856 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2857 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2859 /* If this is a local class, keep track of it. We need this
2860 information for name-mangling, and so that it is possible to find
2861 all function definitions in a translation unit in a convenient
2862 way. (It's otherwise tricky to find a member function definition
2863 it's only pointed to from within a local class.) */
2864 if (TYPE_CONTEXT (type
)
2865 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
2866 && !processing_template_decl
)
2867 VARRAY_PUSH_TREE (local_classes
, type
);
2869 if (!uses_template_parms (type
))
2872 DECL_ASSEMBLER_NAME (d
) = mangle_type (type
);
2874 DECL_ASSEMBLER_NAME (d
)
2875 = get_identifier (build_overload_name (type
, 1, 1));
2878 if (b
->parm_flag
== 2)
2880 if (!COMPLETE_TYPE_P (current_class_type
))
2881 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2885 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2886 /* Use the canonical TYPE_DECL for this node. */
2887 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2890 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2891 will be the tagged type we just added to the current
2892 binding level. This fake NULL-named TYPE_DECL node helps
2893 dwarfout.c to know when it needs to output a
2894 representation of a tagged type, and it also gives us a
2895 convenient place to record the "scope start" address for
2898 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2899 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2903 /* Counter used to create anonymous type names. */
2905 static int anon_cnt
= 0;
2907 /* Return an IDENTIFIER which can be used as a name for
2908 anonymous structs and unions. */
2915 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2916 return get_identifier (buf
);
2919 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2920 This keeps dbxout from getting confused. */
2925 register struct binding_level
*b
;
2927 static int last_cnt
= 0;
2929 /* Fast out if no new anon names were declared. */
2930 if (last_cnt
== anon_cnt
)
2933 b
= current_binding_level
;
2934 while (b
->tag_transparent
)
2939 /* A NULL purpose means we have already processed all tags
2940 from here to the end of the list. */
2941 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2943 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2944 TREE_PURPOSE (tags
) = NULL_TREE
;
2945 tags
= TREE_CHAIN (tags
);
2947 last_cnt
= anon_cnt
;
2950 /* Subroutine of duplicate_decls: return truthvalue of whether
2951 or not types of these decls match.
2953 For C++, we must compare the parameter list so that `int' can match
2954 `int&' in a parameter position, but `int&' is not confused with
2958 decls_match (newdecl
, olddecl
)
2959 tree newdecl
, olddecl
;
2963 if (newdecl
== olddecl
)
2966 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
2967 /* If the two DECLs are not even the same kind of thing, we're not
2968 interested in their types. */
2971 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2973 tree f1
= TREE_TYPE (newdecl
);
2974 tree f2
= TREE_TYPE (olddecl
);
2975 tree p1
= TYPE_ARG_TYPES (f1
);
2976 tree p2
= TYPE_ARG_TYPES (f2
);
2978 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
2979 && ! (DECL_EXTERN_C_P (newdecl
)
2980 && DECL_EXTERN_C_P (olddecl
)))
2983 if (TREE_CODE (f1
) != TREE_CODE (f2
))
2986 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
2988 if (p2
== NULL_TREE
&& DECL_EXTERN_C_P (olddecl
)
2989 && (DECL_BUILT_IN (olddecl
)
2990 #ifndef NO_IMPLICIT_EXTERN_C
2991 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
2992 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
2996 types_match
= self_promoting_args_p (p1
);
2997 if (p1
== void_list_node
)
2998 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
3000 #ifndef NO_IMPLICIT_EXTERN_C
3001 else if (p1
== NULL_TREE
3002 && (DECL_EXTERN_C_P (olddecl
)
3003 && DECL_IN_SYSTEM_HEADER (olddecl
)
3004 && !DECL_CLASS_SCOPE_P (olddecl
))
3005 && (DECL_EXTERN_C_P (newdecl
)
3006 && DECL_IN_SYSTEM_HEADER (newdecl
)
3007 && !DECL_CLASS_SCOPE_P (newdecl
)))
3009 types_match
= self_promoting_args_p (p2
);
3010 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
3014 types_match
= compparms (p1
, p2
);
3019 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3021 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3022 DECL_TEMPLATE_PARMS (olddecl
)))
3025 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
3026 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
3029 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3032 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
3033 DECL_TEMPLATE_RESULT (newdecl
));
3037 if (TREE_TYPE (newdecl
) == error_mark_node
)
3038 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
3039 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
3040 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
3041 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
3044 types_match
= comptypes (TREE_TYPE (newdecl
),
3045 TREE_TYPE (olddecl
),
3046 COMPARE_REDECLARATION
);
3052 /* If NEWDECL is `static' and an `extern' was seen previously,
3053 warn about it. OLDDECL is the previous declaration.
3055 Note that this does not apply to the C++ case of declaring
3056 a variable `extern const' and then later `const'.
3058 Don't complain about built-in functions, since they are beyond
3059 the user's control. */
3062 warn_extern_redeclared_static (newdecl
, olddecl
)
3063 tree newdecl
, olddecl
;
3065 static const char *explicit_extern_static_warning
3066 = "`%D' was declared `extern' and later `static'";
3067 static const char *implicit_extern_static_warning
3068 = "`%D' was declared implicitly `extern' and later `static'";
3072 if (TREE_CODE (newdecl
) == TYPE_DECL
3073 || TREE_CODE (newdecl
) == TEMPLATE_DECL
3074 || TREE_CODE (newdecl
) == CONST_DECL
)
3077 /* Don't get confused by static member functions; that's a different
3079 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3080 && DECL_STATIC_FUNCTION_P (newdecl
))
3083 /* If the old declaration was `static', or the new one isn't, then
3084 then everything is OK. */
3085 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
3088 /* It's OK to declare a builtin function as `static'. */
3089 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3090 && DECL_ARTIFICIAL (olddecl
))
3093 name
= DECL_ASSEMBLER_NAME (newdecl
);
3094 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
3095 ? implicit_extern_static_warning
3096 : explicit_extern_static_warning
, newdecl
);
3097 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
3100 /* Handle when a new declaration NEWDECL has the same name as an old
3101 one OLDDECL in the same binding contour. Prints an error message
3104 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3105 Otherwise, return 0. */
3108 duplicate_decls (newdecl
, olddecl
)
3109 tree newdecl
, olddecl
;
3111 unsigned olddecl_uid
= DECL_UID (olddecl
);
3112 int olddecl_friend
= 0, types_match
= 0;
3113 int new_defines_function
= 0;
3115 if (newdecl
== olddecl
)
3118 types_match
= decls_match (newdecl
, olddecl
);
3120 /* If either the type of the new decl or the type of the old decl is an
3121 error_mark_node, then that implies that we have already issued an
3122 error (earlier) for some bogus type specification, and in that case,
3123 it is rather pointless to harass the user with yet more error message
3124 about the same declaration, so just pretend the types match here. */
3125 if (TREE_TYPE (newdecl
) == error_mark_node
3126 || TREE_TYPE (olddecl
) == error_mark_node
)
3129 /* Check for redeclaration and other discrepancies. */
3130 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3131 && DECL_ARTIFICIAL (olddecl
))
3133 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
3135 /* If you declare a built-in or predefined function name as static,
3136 the old definition is overridden, but optionally warn this was a
3137 bad choice of name. */
3138 if (! TREE_PUBLIC (newdecl
))
3141 cp_warning ("shadowing %s function `%#D'",
3142 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3144 /* Discard the old built-in function. */
3147 /* If the built-in is not ansi, then programs can override
3148 it even globally without an error. */
3149 else if (! DECL_BUILT_IN (olddecl
))
3150 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3154 cp_error ("declaration of `%#D'", newdecl
);
3155 cp_error ("conflicts with built-in declaration `%#D'",
3160 else if (!types_match
)
3162 if ((DECL_EXTERN_C_P (newdecl
)
3163 && DECL_EXTERN_C_P (olddecl
))
3164 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3165 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3167 /* A near match; override the builtin. */
3169 if (TREE_PUBLIC (newdecl
))
3171 cp_warning ("new declaration `%#D'", newdecl
);
3172 cp_warning ("ambiguates built-in declaration `%#D'",
3175 else if (warn_shadow
)
3176 cp_warning ("shadowing %s function `%#D'",
3177 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3181 /* Discard the old built-in function. */
3185 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
3187 /* If a builtin function is redeclared as `static', merge
3188 the declarations, but make the original one static. */
3189 DECL_THIS_STATIC (olddecl
) = 1;
3190 TREE_PUBLIC (olddecl
) = 0;
3192 /* Make the old declaration consistent with the new one so
3193 that all remnants of the builtin-ness of this function
3194 will be banished. */
3195 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3196 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3197 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3198 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl
),
3202 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
3204 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
3205 && TREE_CODE (newdecl
) != TYPE_DECL
3206 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
3207 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
3208 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
3209 && TREE_CODE (olddecl
) != TYPE_DECL
3210 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
3211 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
3214 /* We do nothing special here, because C++ does such nasty
3215 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3216 get shadowed, and know that if we need to find a TYPE_DECL
3217 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3218 slot of the identifier. */
3222 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
3223 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
3224 || (TREE_CODE (olddecl
) == FUNCTION_DECL
3225 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
3228 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
3229 if (TREE_CODE (olddecl
) == TREE_LIST
)
3230 olddecl
= TREE_VALUE (olddecl
);
3231 cp_error_at ("previous declaration of `%#D'", olddecl
);
3233 /* New decl is completely inconsistent with the old one =>
3234 tell caller to replace the old one. */
3238 else if (!types_match
)
3240 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
3241 /* These are certainly not duplicate declarations; they're
3242 from different scopes. */
3245 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3247 /* The name of a class template may not be declared to refer to
3248 any other template, class, function, object, namespace, value,
3249 or type in the same scope. */
3250 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
3251 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3253 cp_error ("declaration of template `%#D'", newdecl
);
3254 cp_error_at ("conflicts with previous declaration `%#D'",
3257 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
3258 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
3259 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
3260 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
3261 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3262 DECL_TEMPLATE_PARMS (olddecl
)))
3264 cp_error ("new declaration `%#D'", newdecl
);
3265 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3269 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3271 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
3273 cp_error ("declaration of C function `%#D' conflicts with",
3275 cp_error_at ("previous declaration `%#D' here", olddecl
);
3277 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3278 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3280 cp_error ("new declaration `%#D'", newdecl
);
3281 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3287 /* Already complained about this, so don't do so again. */
3288 else if (current_class_type
== NULL_TREE
3289 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
3291 cp_error ("conflicting types for `%#D'", newdecl
);
3292 cp_error_at ("previous declaration as `%#D'", olddecl
);
3295 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3296 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
3297 && (!DECL_TEMPLATE_INFO (newdecl
)
3298 || (DECL_TI_TEMPLATE (newdecl
)
3299 != DECL_TI_TEMPLATE (olddecl
))))
3300 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
3301 && (!DECL_TEMPLATE_INFO (olddecl
)
3302 || (DECL_TI_TEMPLATE (olddecl
)
3303 != DECL_TI_TEMPLATE (newdecl
))))))
3304 /* It's OK to have a template specialization and a non-template
3305 with the same type, or to have specializations of two
3306 different templates with the same type. Note that if one is a
3307 specialization, and the other is an instantiation of the same
3308 template, that we do not exit at this point. That situation
3309 can occur if we instantiate a template class, and then
3310 specialize one of its methods. This situation is legal, but
3311 the declarations must be merged in the usual way. */
3313 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3314 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
3315 && !DECL_USE_TEMPLATE (newdecl
))
3316 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
3317 && !DECL_USE_TEMPLATE (olddecl
))))
3318 /* One of the declarations is a template instantiation, and the
3319 other is not a template at all. That's OK. */
3321 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
3322 && DECL_NAMESPACE_ALIAS (newdecl
)
3323 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
3324 /* Redeclaration of namespace alias, ignore it. */
3328 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
3331 cp_error (errmsg
, newdecl
);
3332 if (DECL_NAME (olddecl
) != NULL_TREE
)
3333 cp_error_at ((DECL_INITIAL (olddecl
)
3334 && namespace_bindings_p ())
3335 ? "`%#D' previously defined here"
3336 : "`%#D' previously declared here", olddecl
);
3338 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3339 && DECL_INITIAL (olddecl
) != NULL_TREE
3340 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
3341 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
3343 /* Prototype decl follows defn w/o prototype. */
3344 cp_warning_at ("prototype for `%#D'", newdecl
);
3345 cp_warning_at ("follows non-prototype definition here", olddecl
);
3347 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3348 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
3350 /* extern "C" int foo ();
3351 int foo () { bar (); }
3353 if (current_lang_stack
3354 == &VARRAY_TREE (current_lang_base
, 0))
3355 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3358 cp_error_at ("previous declaration of `%#D' with %L linkage",
3359 olddecl
, DECL_LANGUAGE (olddecl
));
3360 cp_error ("conflicts with new declaration with %L linkage",
3361 DECL_LANGUAGE (newdecl
));
3365 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
3367 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
3369 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
3370 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
3373 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
3374 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
3376 for (; t1
&& t1
!= void_list_node
;
3377 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
3378 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
3380 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
3385 cp_pedwarn ("default argument given for parameter %d of `%#D'",
3387 cp_pedwarn_at ("after previous specification in `%#D'",
3393 cp_error ("default argument given for parameter %d of `%#D'",
3395 cp_error_at ("after previous specification in `%#D'",
3400 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
3401 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
3403 cp_warning ("`%#D' was used before it was declared inline",
3405 cp_warning_at ("previous non-inline declaration here",
3411 /* If new decl is `static' and an `extern' was seen previously,
3413 warn_extern_redeclared_static (newdecl
, olddecl
);
3415 /* We have committed to returning 1 at this point. */
3416 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3418 /* Now that functions must hold information normally held
3419 by field decls, there is extra work to do so that
3420 declaration information does not get destroyed during
3422 if (DECL_VINDEX (olddecl
))
3423 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
3424 if (DECL_VIRTUAL_CONTEXT (olddecl
))
3425 DECL_VIRTUAL_CONTEXT (newdecl
) = DECL_VIRTUAL_CONTEXT (olddecl
);
3426 if (DECL_CONTEXT (olddecl
))
3427 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
3428 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
3429 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
3430 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
3431 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
3432 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
3433 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
3434 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
3435 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
3436 DECL_LANG_SPECIFIC (newdecl
)->u2
= DECL_LANG_SPECIFIC (olddecl
)->u2
;
3437 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
3439 /* Optionally warn about more than one declaration for the same
3440 name, but don't warn about a function declaration followed by a
3442 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
3443 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
3444 /* Don't warn about extern decl followed by definition. */
3445 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
3446 /* Don't warn about friends, let add_friend take care of it. */
3447 && ! DECL_FRIEND_P (newdecl
))
3449 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
3450 cp_warning_at ("previous declaration of `%D'", olddecl
);
3454 /* Deal with C++: must preserve virtual function table size. */
3455 if (TREE_CODE (olddecl
) == TYPE_DECL
)
3457 register tree newtype
= TREE_TYPE (newdecl
);
3458 register tree oldtype
= TREE_TYPE (olddecl
);
3460 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
3461 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
3463 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
3464 CLASSTYPE_FRIEND_CLASSES (newtype
)
3465 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
3468 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
3471 /* Copy all the DECL_... slots specified in the new decl
3472 except for any that we copy here from the old type. */
3473 DECL_MACHINE_ATTRIBUTES (newdecl
)
3474 = merge_machine_decl_attributes (olddecl
, newdecl
);
3476 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3478 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
3479 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
3480 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
3481 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3488 /* Automatically handles default parameters. */
3489 tree oldtype
= TREE_TYPE (olddecl
);
3492 /* Merge the data types specified in the two decls. */
3493 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3495 /* If common_type produces a non-typedef type, just use the old type. */
3496 if (TREE_CODE (newdecl
) == TYPE_DECL
3497 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
3500 if (TREE_CODE (newdecl
) == VAR_DECL
)
3501 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3502 /* Do this after calling `common_type' so that default
3503 parameters don't confuse us. */
3504 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3505 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3506 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3508 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3509 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3510 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3511 TYPE_RAISES_EXCEPTIONS (oldtype
));
3513 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3514 && DECL_SOURCE_LINE (olddecl
) != 0
3516 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)),
3517 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
)), 1))
3519 cp_error ("declaration of `%F' throws different exceptions",
3521 cp_error_at ("than previous declaration `%F'", olddecl
);
3524 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3526 /* Lay the type out, unless already done. */
3527 if (! same_type_p (newtype
, oldtype
)
3528 && TREE_TYPE (newdecl
) != error_mark_node
3529 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3530 layout_type (TREE_TYPE (newdecl
));
3532 if ((TREE_CODE (newdecl
) == VAR_DECL
3533 || TREE_CODE (newdecl
) == PARM_DECL
3534 || TREE_CODE (newdecl
) == RESULT_DECL
3535 || TREE_CODE (newdecl
) == FIELD_DECL
3536 || TREE_CODE (newdecl
) == TYPE_DECL
)
3537 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3538 layout_decl (newdecl
, 0);
3540 /* Merge the type qualifiers. */
3541 if (TREE_READONLY (newdecl
))
3542 TREE_READONLY (olddecl
) = 1;
3543 if (TREE_THIS_VOLATILE (newdecl
))
3544 TREE_THIS_VOLATILE (olddecl
) = 1;
3546 /* Merge the initialization information. */
3547 if (DECL_INITIAL (newdecl
) == NULL_TREE
3548 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3550 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3551 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3552 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3553 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
3554 && DECL_LANG_SPECIFIC (newdecl
)
3555 && DECL_LANG_SPECIFIC (olddecl
))
3556 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3559 /* Merge the section attribute.
3560 We want to issue an error if the sections conflict but that must be
3561 done later in decl_attributes since we are called before attributes
3563 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3564 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3566 /* Keep the old rtl since we can safely use it. */
3567 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3569 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3571 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
3572 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
3573 DECL_NO_CHECK_MEMORY_USAGE (newdecl
)
3574 |= DECL_NO_CHECK_MEMORY_USAGE (olddecl
);
3575 DECL_NO_LIMIT_STACK (newdecl
)
3576 |= DECL_NO_LIMIT_STACK (olddecl
);
3579 /* If cannot merge, then use the new type and qualifiers,
3580 and don't preserve the old rtl. */
3583 /* Clean out any memory we had of the old declaration. */
3584 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3586 TREE_VALUE (oldstatic
) = error_mark_node
;
3588 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3589 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3590 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3591 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3594 /* Merge the storage class information. */
3595 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3596 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3597 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
3598 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3599 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3600 if (! DECL_EXTERNAL (olddecl
))
3601 DECL_EXTERNAL (newdecl
) = 0;
3603 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3605 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3606 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3607 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3608 DECL_TEMPLATE_INSTANTIATED (newdecl
)
3609 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
3610 /* Don't really know how much of the language-specific
3611 values we should copy from old to new. */
3612 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3613 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3614 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3615 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3616 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3618 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3619 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3620 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
3621 DECL_BEFRIENDING_CLASSES (newdecl
)
3622 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
3623 DECL_BEFRIENDING_CLASSES (olddecl
));
3626 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3628 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3629 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3631 /* If newdecl is not a specialization, then it is not a
3632 template-related function at all. And that means that we
3633 shoud have exited above, returning 0. */
3634 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3637 if (TREE_USED (olddecl
))
3638 /* From [temp.expl.spec]:
3640 If a template, a member template or the member of a class
3641 template is explicitly specialized then that
3642 specialization shall be declared before the first use of
3643 that specialization that would cause an implicit
3644 instantiation to take place, in every translation unit in
3645 which such a use occurs. */
3646 cp_error ("explicit specialization of %D after first use",
3649 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3651 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3653 /* If either decl says `inline', this fn is inline, unless its
3654 definition was passed already. */
3655 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3656 DECL_INLINE (olddecl
) = 1;
3657 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3661 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3662 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3663 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3665 if (! types_match
|| new_defines_function
)
3667 /* These need to be copied so that the names are available.
3668 Note that if the types do match, we'll preserve inline
3669 info and other bits, but if not, we won't. */
3670 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3671 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3673 if (new_defines_function
)
3674 /* If defining a function declared with other language
3675 linkage, use the previously declared language linkage. */
3676 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3677 else if (types_match
)
3679 /* If redeclaring a builtin function, and not a definition,
3680 it stays built in. */
3681 if (DECL_BUILT_IN (olddecl
))
3683 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
3684 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3685 /* If we're keeping the built-in definition, keep the rtl,
3686 regardless of declaration matches. */
3687 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3690 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3692 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3693 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3694 /* Previously saved insns go together with
3695 the function's previous definition. */
3696 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3697 /* Don't clear out the arguments if we're redefining a function. */
3698 if (DECL_ARGUMENTS (olddecl
))
3699 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3703 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3705 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3708 /* Now preserve various other info from the definition. */
3709 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3710 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3711 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3712 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3714 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3718 function_size
= sizeof (struct tree_decl
);
3720 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3721 (char *) olddecl
+ sizeof (struct tree_common
),
3722 function_size
- sizeof (struct tree_common
));
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
;
3758 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3759 (char *) olddecl
+ sizeof (struct tree_common
),
3760 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3761 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3764 DECL_UID (olddecl
) = olddecl_uid
;
3766 DECL_FRIEND_P (olddecl
) = 1;
3768 /* NEWDECL contains the merged attribute lists.
3769 Update OLDDECL to be the same. */
3770 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3775 /* Record a decl-node X as belonging to the current lexical scope.
3776 Check for errors (such as an incompatible declaration for the same
3777 name already seen in the same scope).
3779 Returns either X or an old decl for the same name.
3780 If an old decl is returned, it may have been smashed
3781 to agree with what X says. */
3789 int need_new_binding
;
3791 /* We shouldn't be calling pushdecl when we're generating RTL for a
3792 function that we already did semantic analysis on previously. */
3793 my_friendly_assert (!cfun
|| doing_semantic_analysis_p (),
3796 need_new_binding
= 1;
3798 if (DECL_TEMPLATE_PARM_P (x
))
3799 /* Template parameters have no context; they are not X::T even
3800 when declared within a class or namespace. */
3804 if (current_function_decl
&& x
!= current_function_decl
3805 /* A local declaration for a function doesn't constitute
3807 && !(TREE_CODE (x
) == FUNCTION_DECL
&& !DECL_INITIAL (x
))
3808 /* A local declaration for an `extern' variable is in the
3809 scope of the current namespace, not the current
3811 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
3812 && !DECL_CONTEXT (x
))
3813 DECL_CONTEXT (x
) = current_function_decl
;
3815 /* If this is the declaration for a namespace-scope function,
3816 but the declaration itself is in a local scope, mark the
3818 if (TREE_CODE (x
) == FUNCTION_DECL
3819 && DECL_NAMESPACE_SCOPE_P (x
)
3820 && current_function_decl
3821 && x
!= current_function_decl
)
3822 DECL_LOCAL_FUNCTION_P (x
) = 1;
3825 name
= DECL_NAME (x
);
3828 int different_binding_level
= 0;
3830 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3831 name
= TREE_OPERAND (name
, 0);
3833 /* In case this decl was explicitly namespace-qualified, look it
3834 up in its namespace context. */
3835 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
)
3836 && namespace_bindings_p ())
3837 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3839 t
= lookup_name_current_level (name
);
3841 /* [basic.link] If there is a visible declaration of an entity
3842 with linkage having the same name and type, ignoring entities
3843 declared outside the innermost enclosing namespace scope, the
3844 block scope declaration declares that same entity and
3845 receives the linkage of the previous declaration. */
3846 if (! t
&& current_function_decl
&& x
!= current_function_decl
3847 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
3848 && DECL_EXTERNAL (x
))
3850 /* Look in block scope. */
3851 t
= IDENTIFIER_VALUE (name
);
3852 /* Or in the innermost namespace. */
3854 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3855 /* Does it have linkage? */
3856 if (t
&& ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
3859 different_binding_level
= 1;
3862 /* If we are declaring a function, and the result of name-lookup
3863 was an OVERLOAD, look for an overloaded instance that is
3864 actually the same as the function we are declaring. (If
3865 there is one, we have to merge our declaration with the
3866 previous declaration.) */
3867 if (t
&& TREE_CODE (t
) == OVERLOAD
)
3871 if (TREE_CODE (x
) == FUNCTION_DECL
)
3872 for (match
= t
; match
; match
= OVL_NEXT (match
))
3874 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t
))
3875 == DECL_ASSEMBLER_NAME (x
))
3879 /* Just choose one. */
3883 t
= OVL_CURRENT (match
);
3888 if (t
== error_mark_node
)
3890 /* error_mark_node is 0 for a while during initialization! */
3892 cp_error_at ("`%#D' used prior to declaration", x
);
3894 else if (t
!= NULL_TREE
)
3896 if (different_binding_level
)
3898 if (decls_match (x
, t
))
3899 /* The standard only says that the local extern
3900 inherits linkage from the previous decl; in
3901 particular, default args are not shared. It would
3902 be nice to propagate inlining info, though. FIXME. */
3903 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
3905 else if (TREE_CODE (t
) == PARM_DECL
)
3907 if (DECL_CONTEXT (t
) == NULL_TREE
)
3908 fatal ("parse errors have confused me too much");
3910 /* Check for duplicate params. */
3911 if (duplicate_decls (x
, t
))
3914 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
3915 || DECL_FUNCTION_TEMPLATE_P (x
))
3916 && is_overloaded_fn (t
))
3917 /* Don't do anything just yet. */;
3918 else if (t
== wchar_decl_node
)
3920 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3921 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3923 /* Throw away the redeclaration. */
3926 else if (TREE_CODE (t
) != TREE_CODE (x
))
3928 if (duplicate_decls (x
, t
))
3931 else if (duplicate_decls (x
, t
))
3933 if (TREE_CODE (t
) == TYPE_DECL
)
3934 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3935 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3936 check_default_args (t
);
3940 else if (DECL_MAIN_P (x
))
3942 /* A redeclaration of main, but not a duplicate of the
3947 This function shall not be overloaded. */
3948 cp_error_at ("invalid redeclaration of `%D'", t
);
3949 cp_error ("as `%D'", x
);
3950 /* We don't try to push this declaration since that
3956 check_template_shadow (x
);
3958 /* If this is a function conjured up by the backend, massage it
3959 so it looks friendly. */
3960 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
3962 retrofit_lang_decl (x
);
3963 DECL_LANGUAGE (x
) = lang_c
;
3966 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
3968 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
3971 if (!namespace_bindings_p ())
3972 /* We do not need to create a binding for this name;
3973 push_overloaded_decl will have already done so if
3975 need_new_binding
= 0;
3977 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3979 t
= push_overloaded_decl (x
, PUSH_GLOBAL
);
3981 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
3985 /* If declaring a type as a typedef, copy the type (unless we're
3986 at line 0), and install this TYPE_DECL as the new type's typedef
3987 name. See the extensive comment in ../c-decl.c (pushdecl). */
3988 if (TREE_CODE (x
) == TYPE_DECL
)
3990 tree type
= TREE_TYPE (x
);
3991 if (DECL_SOURCE_LINE (x
) == 0)
3993 if (TYPE_NAME (type
) == 0)
3994 TYPE_NAME (type
) = x
;
3996 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
3997 /* We don't want to copy the type when all we're
3998 doing is making a TYPE_DECL for the purposes of
4000 && (!TYPE_NAME (type
)
4001 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
4003 DECL_ORIGINAL_TYPE (x
) = type
;
4004 type
= build_type_copy (type
);
4005 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
4006 TYPE_NAME (type
) = x
;
4007 TREE_TYPE (x
) = type
;
4010 if (type
!= error_mark_node
4012 && TYPE_IDENTIFIER (type
))
4013 set_identifier_type_value_with_scope (DECL_NAME (x
), type
,
4014 current_binding_level
);
4018 /* Multiple external decls of the same identifier ought to match.
4020 We get warnings about inline functions where they are defined.
4021 We get warnings about other functions from push_overloaded_decl.
4023 Avoid duplicate warnings where they are used. */
4024 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
4028 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
4029 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
4030 decl
= OVL_FUNCTION (decl
);
4032 if (decl
&& decl
!= error_mark_node
4033 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
4034 /* If different sort of thing, we already gave an error. */
4035 && TREE_CODE (decl
) == TREE_CODE (x
)
4036 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
4038 cp_pedwarn ("type mismatch with previous external decl", x
);
4039 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
4043 /* This name is new in its binding level.
4044 Install the new declaration and return it. */
4045 if (namespace_bindings_p ())
4047 /* Install a global value. */
4049 /* If the first global decl has external linkage,
4050 warn if we later see static one. */
4051 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
4052 TREE_PUBLIC (name
) = 1;
4054 /* Bind the mangled name for the entity. In the future, we
4055 should not need to do this; mangled names are an
4056 implementation detail of which the front-end should not
4057 need to be aware. */
4058 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
4060 /* For an ordinary function, we create a binding from
4061 the mangled name (i.e., NAME) to the DECL. But, for
4062 an `extern "C"' function, the mangled name and the
4063 ordinary name are the same so we need not do this. */
4064 && !DECL_EXTERN_C_FUNCTION_P (x
))
4068 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
4069 || TREE_CODE (x
) == NAMESPACE_DECL
)
4070 mangled_name
= name
;
4072 mangled_name
= DECL_ASSEMBLER_NAME (x
);
4074 if (TREE_CODE (x
) == FUNCTION_DECL
)
4076 ((IDENTIFIER_GLOBAL_VALUE (mangled_name
) == NULL_TREE
)
4077 || (IDENTIFIER_GLOBAL_VALUE (mangled_name
) == x
), 378);
4078 SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name
, x
);
4081 /* Don't forget if the function was used via an implicit decl. */
4082 if (IDENTIFIER_IMPLICIT_DECL (name
)
4083 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
4086 /* Don't forget if its address was taken in that way. */
4087 if (IDENTIFIER_IMPLICIT_DECL (name
)
4088 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
4089 TREE_ADDRESSABLE (x
) = 1;
4091 /* Warn about mismatches against previous implicit decl. */
4092 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
4093 /* If this real decl matches the implicit, don't complain. */
4094 && ! (TREE_CODE (x
) == FUNCTION_DECL
4095 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
4097 ("`%D' was previously implicitly declared to return `int'", x
);
4099 /* If new decl is `static' and an `extern' was seen previously,
4101 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
4102 warn_extern_redeclared_static (x
, t
);
4106 /* Here to install a non-global value. */
4107 tree oldlocal
= IDENTIFIER_VALUE (name
);
4108 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
4110 if (need_new_binding
)
4112 push_local_binding (name
, x
, 0);
4113 /* Because push_local_binding will hook X on to the
4114 current_binding_level's name list, we don't want to
4115 do that again below. */
4116 need_new_binding
= 0;
4119 /* If this is a TYPE_DECL, push it into the type value slot. */
4120 if (TREE_CODE (x
) == TYPE_DECL
)
4121 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
),
4122 current_binding_level
);
4124 /* Clear out any TYPE_DECL shadowed by a namespace so that
4125 we won't think this is a type. The C struct hack doesn't
4126 go through namespaces. */
4127 if (TREE_CODE (x
) == NAMESPACE_DECL
)
4128 set_identifier_type_value_with_scope (name
, NULL_TREE
,
4129 current_binding_level
);
4136 && TREE_CODE (oldlocal
) == VAR_DECL
4137 && DECL_DEAD_FOR_LOCAL (oldlocal
))
4138 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
4140 if (oldlocal
== NULL_TREE
)
4141 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
4144 /* If this is an extern function declaration, see if we
4145 have a global definition or declaration for the function. */
4146 if (oldlocal
== NULL_TREE
4147 && DECL_EXTERNAL (x
)
4148 && oldglobal
!= NULL_TREE
4149 && TREE_CODE (x
) == FUNCTION_DECL
4150 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
4152 /* We have one. Their types must agree. */
4153 if (decls_match (x
, oldglobal
))
4157 cp_warning ("extern declaration of `%#D' doesn't match", x
);
4158 cp_warning_at ("global declaration `%#D'", oldglobal
);
4161 /* If we have a local external declaration,
4162 and no file-scope declaration has yet been seen,
4163 then if we later have a file-scope decl it must not be static. */
4164 if (oldlocal
== NULL_TREE
4165 && oldglobal
== NULL_TREE
4166 && DECL_EXTERNAL (x
)
4168 TREE_PUBLIC (name
) = 1;
4170 /* Warn if shadowing an argument at the top level of the body. */
4171 if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
4172 /* Inline decls shadow nothing. */
4173 && !DECL_FROM_INLINE (x
)
4174 && TREE_CODE (oldlocal
) == PARM_DECL
4175 /* Don't complain if it's from an enclosing function. */
4176 && DECL_CONTEXT (oldlocal
) == current_function_decl
4177 && TREE_CODE (x
) != PARM_DECL
)
4179 /* Go to where the parms should be and see if we
4181 struct binding_level
*b
= current_binding_level
->level_chain
;
4187 if (b
->parm_flag
== 1)
4188 cp_error ("declaration of `%#D' shadows a parameter", name
);
4191 /* Maybe warn if shadowing something else. */
4192 if (warn_shadow
&& !DECL_EXTERNAL (x
)
4193 /* Inline decls shadow nothing. */
4194 && !DECL_FROM_INLINE (x
)
4195 /* No shadow warnings for internally generated vars. */
4196 && ! DECL_ARTIFICIAL (x
)
4197 /* No shadow warnings for vars made for inlining. */
4198 && ! DECL_FROM_INLINE (x
))
4200 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
4201 warning ("declaration of `%s' shadows a parameter",
4202 IDENTIFIER_POINTER (name
));
4203 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
4204 && current_class_ptr
4205 && !TREE_STATIC (name
))
4206 warning ("declaration of `%s' shadows a member of `this'",
4207 IDENTIFIER_POINTER (name
));
4208 else if (oldlocal
!= NULL_TREE
)
4209 warning ("declaration of `%s' shadows previous local",
4210 IDENTIFIER_POINTER (name
));
4211 else if (oldglobal
!= NULL_TREE
)
4212 /* XXX shadow warnings in outer-more namespaces */
4213 warning ("declaration of `%s' shadows global declaration",
4214 IDENTIFIER_POINTER (name
));
4218 if (TREE_CODE (x
) == FUNCTION_DECL
)
4219 check_default_args (x
);
4221 /* Keep count of variables in this level with incomplete type. */
4222 if (TREE_CODE (x
) == VAR_DECL
4223 && TREE_TYPE (x
) != error_mark_node
4224 && ((!COMPLETE_TYPE_P (TREE_TYPE (x
))
4225 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
4226 /* RTTI TD entries are created while defining the type_info. */
4227 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
4228 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
4230 if (namespace_bindings_p ())
4231 namespace_scope_incomplete
4232 = tree_cons (NULL_TREE
, x
, namespace_scope_incomplete
);
4234 current_binding_level
->incomplete
4235 = tree_cons (NULL_TREE
, x
, current_binding_level
->incomplete
);
4239 if (need_new_binding
)
4240 add_decl_to_level (x
,
4241 DECL_NAMESPACE_SCOPE_P (x
)
4242 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
4243 : current_binding_level
);
4248 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4249 caller to set DECL_CONTEXT properly. */
4252 pushdecl_with_scope (x
, level
)
4254 struct binding_level
*level
;
4256 register struct binding_level
*b
;
4257 tree function_decl
= current_function_decl
;
4259 current_function_decl
= NULL_TREE
;
4260 if (level
->parm_flag
== 2)
4262 b
= class_binding_level
;
4263 class_binding_level
= level
;
4264 pushdecl_class_level (x
);
4265 class_binding_level
= b
;
4269 b
= current_binding_level
;
4270 current_binding_level
= level
;
4272 current_binding_level
= b
;
4274 current_function_decl
= function_decl
;
4278 /* Like pushdecl, only it places X in the current namespace,
4282 pushdecl_namespace_level (x
)
4285 register struct binding_level
*b
= current_binding_level
;
4288 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
4290 /* Now, the type_shadowed stack may screw us. Munge it so it does
4292 if (TREE_CODE (x
) == TYPE_DECL
)
4294 tree name
= DECL_NAME (x
);
4296 tree
*ptr
= (tree
*)0;
4297 for (; b
!= global_binding_level
; b
= b
->level_chain
)
4299 tree shadowed
= b
->type_shadowed
;
4300 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
4301 if (TREE_PURPOSE (shadowed
) == name
)
4303 ptr
= &TREE_VALUE (shadowed
);
4304 /* Can't break out of the loop here because sometimes
4305 a binding level will have duplicate bindings for
4306 PT names. It's gross, but I haven't time to fix it. */
4309 newval
= TREE_TYPE (x
);
4310 if (ptr
== (tree
*)0)
4312 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4313 up here if this is changed to an assertion. --KR */
4314 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
4324 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4328 pushdecl_top_level (x
)
4331 push_to_top_level ();
4332 x
= pushdecl_namespace_level (x
);
4333 pop_from_top_level ();
4337 /* Make the declaration of X appear in CLASS scope. */
4340 pushdecl_class_level (x
)
4343 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4344 scope looks for the pre-mangled name. */
4347 if (TREE_CODE (x
) == OVERLOAD
)
4348 x
= OVL_CURRENT (x
);
4349 name
= DECL_NAME (x
);
4353 push_class_level_binding (name
, x
);
4354 if (TREE_CODE (x
) == TYPE_DECL
)
4355 set_identifier_type_value (name
, TREE_TYPE (x
));
4357 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4361 for (f
= TYPE_FIELDS (TREE_TYPE (x
));
4364 pushdecl_class_level (f
);
4368 /* Enter DECL into the symbol table, if that's appropriate. Returns
4369 DECL, or a modified version thereof. */
4372 maybe_push_decl (decl
)
4375 tree type
= TREE_TYPE (decl
);
4377 /* Add this decl to the current binding level, but not if it comes
4378 from another scope, e.g. a static member variable. TEM may equal
4379 DECL or it may be a previous decl of the same name. */
4380 if (decl
== error_mark_node
4381 || (TREE_CODE (decl
) != PARM_DECL
4382 && DECL_CONTEXT (decl
) != NULL_TREE
4383 /* Definitions of namespace members outside their namespace are
4385 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4386 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
4387 || TREE_CODE (type
) == UNKNOWN_TYPE
4388 /* The declaration of a template specialization does not affect
4389 the functions available for overload resolution, so we do not
4391 || (TREE_CODE (decl
) == FUNCTION_DECL
4392 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
4395 return pushdecl (decl
);
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 class_binding_level
->class_shadowed
4470 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
4471 class_binding_level
->class_shadowed
);
4472 /* Record the value we are binding NAME to so that we can know
4473 what to pop later. */
4474 TREE_TYPE (class_binding_level
->class_shadowed
) = x
;
4478 /* Insert another USING_DECL into the current binding level, returning
4479 this declaration. If this is a redeclaration, do nothing, and
4480 return NULL_TREE if this not in namespace scope (in namespace
4481 scope, a using decl might extend any previous bindings). */
4484 push_using_decl (scope
, name
)
4490 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
4491 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
4492 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
4493 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
4496 return namespace_bindings_p () ? decl
: NULL_TREE
;
4497 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
4498 DECL_INITIAL (decl
) = scope
;
4499 TREE_CHAIN (decl
) = current_binding_level
->usings
;
4500 current_binding_level
->usings
= decl
;
4504 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4505 changed (i.e. there was already a directive), or the fresh
4506 TREE_LIST otherwise. */
4509 push_using_directive (used
)
4512 tree ud
= current_binding_level
->using_directives
;
4513 tree iter
, ancestor
;
4515 /* Check if we already have this. */
4516 if (purpose_member (used
, ud
) != NULL_TREE
)
4519 /* Recursively add all namespaces used. */
4520 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4521 push_using_directive (TREE_PURPOSE (iter
));
4523 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4524 ud
= current_binding_level
->using_directives
;
4525 ud
= tree_cons (used
, ancestor
, ud
);
4526 current_binding_level
->using_directives
= ud
;
4530 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4531 other definitions already in place. We get around this by making
4532 the value of the identifier point to a list of all the things that
4533 want to be referenced by that name. It is then up to the users of
4534 that name to decide what to do with that list.
4536 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4537 DECL_TEMPLATE_RESULT. It is dealt with the same way.
4539 FLAGS is a bitwise-or of the following values:
4540 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4542 PUSH_USING: DECL is being pushed as the result of a using
4545 The value returned may be a previous declaration if we guessed wrong
4546 about what language DECL should belong to (C or C++). Otherwise,
4547 it's always DECL (and never something that's not a _DECL). */
4550 push_overloaded_decl (decl
, flags
)
4554 tree name
= DECL_NAME (decl
);
4557 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
4560 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
4562 old
= lookup_name_current_level (name
);
4566 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4568 tree t
= TREE_TYPE (old
);
4569 if (IS_AGGR_TYPE (t
) && warn_shadow
4570 && (! DECL_IN_SYSTEM_HEADER (decl
)
4571 || ! DECL_IN_SYSTEM_HEADER (old
)))
4572 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4575 else if (is_overloaded_fn (old
))
4579 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4581 tree fn
= OVL_CURRENT (tmp
);
4583 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
4584 && !(flags
& PUSH_USING
)
4585 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
4586 TYPE_ARG_TYPES (TREE_TYPE (decl
))))
4587 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4590 if (duplicate_decls (decl
, fn
))
4594 else if (old
== error_mark_node
)
4595 /* Ignore the undefined symbol marker. */
4599 cp_error_at ("previous non-function declaration `%#D'", old
);
4600 cp_error ("conflicts with function declaration `%#D'", decl
);
4605 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4607 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4608 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
4610 new_binding
= ovl_cons (decl
, old
);
4611 if (flags
& PUSH_USING
)
4612 OVL_USED (new_binding
) = 1;
4615 /* NAME is not ambiguous. */
4619 set_namespace_binding (name
, current_namespace
, new_binding
);
4622 /* We only create an OVERLOAD if there was a previous binding at
4623 this level, or if decl is a template. In the former case, we
4624 need to remove the old binding and replace it with the new
4625 binding. We must also run through the NAMES on the binding
4626 level where the name was bound to update the chain. */
4628 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
4632 for (d
= &BINDING_LEVEL (IDENTIFIER_BINDING (name
))->names
;
4634 d
= &TREE_CHAIN (*d
))
4636 || (TREE_CODE (*d
) == TREE_LIST
4637 && TREE_VALUE (*d
) == old
))
4639 if (TREE_CODE (*d
) == TREE_LIST
)
4640 /* Just replace the old binding with the new. */
4641 TREE_VALUE (*d
) = new_binding
;
4643 /* Build a TREE_LIST to wrap the OVERLOAD. */
4644 *d
= tree_cons (NULL_TREE
, new_binding
,
4647 /* And update the CPLUS_BINDING node. */
4648 BINDING_VALUE (IDENTIFIER_BINDING (name
))
4653 /* We should always find a previous binding in this case. */
4654 my_friendly_abort (0);
4657 /* Install the new binding. */
4658 push_local_binding (name
, new_binding
, flags
);
4664 /* Generate an implicit declaration for identifier FUNCTIONID
4665 as a function of type int (). Print a warning if appropriate. */
4668 implicitly_declare (functionid
)
4673 /* We used to reuse an old implicit decl here,
4674 but this loses with inline functions because it can clobber
4675 the saved decl chains. */
4676 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4678 DECL_EXTERNAL (decl
) = 1;
4679 TREE_PUBLIC (decl
) = 1;
4681 /* ISO standard says implicit declarations are in the innermost block.
4682 So we record the decl in the standard fashion. */
4684 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4687 /* Only one warning per identifier. */
4688 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4690 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4693 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4698 /* Return zero if the declaration NEWDECL is valid
4699 when the declaration OLDDECL (assumed to be for the same name)
4700 has already been seen.
4701 Otherwise return an error message format string with a %s
4702 where the identifier should go. */
4705 redeclaration_error_message (newdecl
, olddecl
)
4706 tree newdecl
, olddecl
;
4708 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4710 /* Because C++ can put things into name space for free,
4711 constructs like "typedef struct foo { ... } foo"
4712 would look like an erroneous redeclaration. */
4713 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
4716 return "redefinition of `%#D'";
4718 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4720 /* If this is a pure function, its olddecl will actually be
4721 the original initialization to `0' (which we force to call
4722 abort()). Don't complain about redefinition in this case. */
4723 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
))
4726 /* If both functions come from different namespaces, this is not
4727 a redeclaration - this is a conflict with a used function. */
4728 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4729 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4730 return "`%D' conflicts with used function";
4732 /* We'll complain about linkage mismatches in
4733 warn_extern_redeclared_static. */
4735 /* Defining the same name twice is no good. */
4736 if (DECL_INITIAL (olddecl
) != NULL_TREE
4737 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4739 if (DECL_NAME (olddecl
) == NULL_TREE
)
4740 return "`%#D' not declared in class";
4742 return "redefinition of `%#D'";
4746 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4748 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4749 && (DECL_TEMPLATE_RESULT (newdecl
)
4750 != DECL_TEMPLATE_RESULT (olddecl
))
4751 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4752 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4753 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4754 && COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
4755 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
))))
4756 return "redefinition of `%#D'";
4759 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
4761 /* Objects declared at top level: */
4762 /* If at least one is a reference, it's ok. */
4763 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4765 /* Reject two definitions. */
4766 return "redefinition of `%#D'";
4770 /* Objects declared with block scope: */
4771 /* Reject two definitions, and reject a definition
4772 together with an external reference. */
4773 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4774 return "redeclaration of `%#D'";
4779 /* Create a new label, named ID. */
4782 make_label_decl (id
, local_p
)
4788 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4790 /* Make sure every label has an rtx. */
4793 DECL_CONTEXT (decl
) = current_function_decl
;
4794 DECL_MODE (decl
) = VOIDmode
;
4795 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
4797 /* Say where one reference is to the label, for the sake of the
4798 error if it is not defined. */
4799 DECL_SOURCE_LINE (decl
) = lineno
;
4800 DECL_SOURCE_FILE (decl
) = input_filename
;
4802 /* Record the fact that this identifier is bound to this label. */
4803 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4808 /* Record this label on the list of used labels so that we can check
4809 at the end of the function to see whether or not the label was
4810 actually defined, and so we can check when the label is defined whether
4811 this use is valid. */
4817 if (named_label_uses
== NULL
4818 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4819 || named_label_uses
->label_decl
!= decl
)
4821 struct named_label_use_list
*new_ent
;
4822 new_ent
= ((struct named_label_use_list
*)
4823 ggc_alloc (sizeof (struct named_label_use_list
)));
4824 new_ent
->label_decl
= decl
;
4825 new_ent
->names_in_scope
= current_binding_level
->names
;
4826 new_ent
->binding_level
= current_binding_level
;
4827 new_ent
->lineno_o_goto
= lineno
;
4828 new_ent
->filename_o_goto
= input_filename
;
4829 new_ent
->next
= named_label_uses
;
4830 named_label_uses
= new_ent
;
4834 /* Look for a label named ID in the current function. If one cannot
4835 be found, create one. (We keep track of used, but undefined,
4836 labels, and complain about them at the end of a function.) */
4843 struct named_label_list
*ent
;
4845 /* You can't use labels at global scope. */
4846 if (current_function_decl
== NULL_TREE
)
4848 error ("label `%s' referenced outside of any function",
4849 IDENTIFIER_POINTER (id
));
4853 /* See if we've already got this label. */
4854 decl
= IDENTIFIER_LABEL_VALUE (id
);
4855 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
4858 /* Record this label on the list of labels used in this function.
4859 We do this before calling make_label_decl so that we get the
4860 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4861 ent
= ((struct named_label_list
*)
4862 ggc_alloc_cleared (sizeof (struct named_label_list
)));
4863 ent
->old_value
= IDENTIFIER_LABEL_VALUE (id
);
4864 ent
->next
= named_labels
;
4867 /* We need a new label. */
4868 decl
= make_label_decl (id
, /*local_p=*/0);
4870 /* Now fill in the information we didn't have before. */
4871 ent
->label_decl
= decl
;
4876 /* Declare a local label named ID. */
4879 declare_local_label (id
)
4884 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4885 this scope we can restore the old value of
4886 IDENTIFIER_TYPE_VALUE. */
4887 current_binding_level
->shadowed_labels
4888 = tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
4889 current_binding_level
->shadowed_labels
);
4890 /* Look for the label. */
4891 decl
= make_label_decl (id
, /*local_p=*/1);
4892 /* Now fill in the information we didn't have before. */
4893 TREE_VALUE (current_binding_level
->shadowed_labels
) = decl
;
4898 /* Returns nonzero if it is ill-formed to jump past the declaration of
4899 DECL. Returns 2 if it's also a real problem. */
4902 decl_jump_unsafe (decl
)
4905 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
4908 if (DECL_INITIAL (decl
) == NULL_TREE
4909 && pod_type_p (TREE_TYPE (decl
)))
4912 /* This is really only important if we're crossing an initialization.
4913 The POD stuff is just pedantry; why should it matter if the class
4914 contains a field of pointer to member type? */
4915 if (DECL_INITIAL (decl
)
4916 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))))
4921 /* Check that a single previously seen jump to a newly defined label
4922 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4923 the jump context; NAMES are the names in scope in LEVEL at the jump
4924 context; FILE and LINE are the source position of the jump or 0. */
4927 check_previous_goto_1 (decl
, level
, names
, file
, line
)
4929 struct binding_level
*level
;
4936 struct binding_level
*b
= current_binding_level
;
4937 for (; b
; b
= b
->level_chain
)
4939 tree new_decls
= b
->names
;
4940 tree old_decls
= (b
== level
? names
: NULL_TREE
);
4941 for (; new_decls
!= old_decls
;
4942 new_decls
= TREE_CHAIN (new_decls
))
4944 int problem
= decl_jump_unsafe (new_decls
);
4951 cp_pedwarn ("jump to label `%D'", decl
);
4953 pedwarn ("jump to case label");
4956 pedwarn_with_file_and_line (file
, line
, " from here");
4960 if (problem
> 1 && DECL_ARTIFICIAL (new_decls
))
4961 /* Can't skip init of __exception_info. */
4962 cp_error_at (" enters catch block", new_decls
);
4963 else if (problem
> 1)
4964 cp_error_at (" crosses initialization of `%#D'",
4967 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4973 if (b
->eh_region
&& ! saw_eh
)
4978 cp_pedwarn ("jump to label `%D'", decl
);
4980 pedwarn ("jump to case label");
4983 pedwarn_with_file_and_line (file
, line
, " from here");
4986 error (" enters try block");
4993 check_previous_goto (use
)
4994 struct named_label_use_list
*use
;
4996 check_previous_goto_1 (use
->label_decl
, use
->binding_level
,
4997 use
->names_in_scope
, use
->filename_o_goto
,
4998 use
->lineno_o_goto
);
5002 check_switch_goto (level
)
5003 struct binding_level
*level
;
5005 check_previous_goto_1 (NULL_TREE
, level
, level
->names
, NULL
, 0);
5008 /* Check that any previously seen jumps to a newly defined label DECL
5009 are OK. Called by define_label. */
5012 check_previous_gotos (decl
)
5015 struct named_label_use_list
**usep
;
5017 if (! TREE_USED (decl
))
5020 for (usep
= &named_label_uses
; *usep
; )
5022 struct named_label_use_list
*use
= *usep
;
5023 if (use
->label_decl
== decl
)
5025 check_previous_goto (use
);
5029 usep
= &(use
->next
);
5033 /* Check that a new jump to a label DECL is OK. Called by
5034 finish_goto_stmt. */
5042 struct named_label_list
*lab
;
5044 /* We can't know where a computed goto is jumping. So we assume
5046 if (! DECL_P (decl
))
5049 /* If the label hasn't been defined yet, defer checking. */
5050 if (! DECL_INITIAL (decl
))
5056 for (lab
= named_labels
; lab
; lab
= lab
->next
)
5057 if (decl
== lab
->label_decl
)
5060 /* If the label is not on named_labels it's a gcc local label, so
5061 it must be in an outer scope, so jumping to it is always OK. */
5065 if ((lab
->eh_region
|| lab
->bad_decls
) && !identified
)
5067 cp_pedwarn_at ("jump to label `%D'", decl
);
5068 pedwarn (" from here");
5072 for (bad
= lab
->bad_decls
; bad
; bad
= TREE_CHAIN (bad
))
5074 tree b
= TREE_VALUE (bad
);
5075 int u
= decl_jump_unsafe (b
);
5077 if (u
> 1 && DECL_ARTIFICIAL (b
))
5078 /* Can't skip init of __exception_info. */
5079 cp_error_at (" enters catch block", b
);
5081 cp_error_at (" skips initialization of `%#D'", b
);
5083 cp_pedwarn_at (" enters scope of non-POD `%#D'", b
);
5087 error (" enters try block");
5090 /* Define a label, specifying the location in the source file.
5091 Return the LABEL_DECL node for the label, if the definition is valid.
5092 Otherwise return 0. */
5095 define_label (filename
, line
, name
)
5096 const char *filename
;
5100 tree decl
= lookup_label (name
);
5101 struct named_label_list
*ent
;
5103 for (ent
= named_labels
; ent
; ent
= ent
->next
)
5104 if (ent
->label_decl
== decl
)
5107 /* After labels, make any new cleanups go into their
5108 own new (temporary) binding contour. */
5109 current_binding_level
->more_cleanups_ok
= 0;
5111 if (name
== get_identifier ("wchar_t"))
5112 cp_pedwarn ("label named wchar_t");
5114 if (DECL_INITIAL (decl
) != NULL_TREE
)
5116 cp_error ("duplicate label `%D'", decl
);
5121 /* Mark label as having been defined. */
5122 DECL_INITIAL (decl
) = error_mark_node
;
5123 /* Say where in the source. */
5124 DECL_SOURCE_FILE (decl
) = filename
;
5125 DECL_SOURCE_LINE (decl
) = line
;
5128 ent
->names_in_scope
= current_binding_level
->names
;
5129 ent
->binding_level
= current_binding_level
;
5131 check_previous_gotos (decl
);
5132 current_function_return_value
= NULL_TREE
;
5139 struct binding_level
*level
;
5140 struct cp_switch
*next
;
5141 /* The SWITCH_STMT being built. */
5143 /* A splay-tree mapping the low element of a case range to the high
5144 element, or NULL_TREE if there is no high element. Used to
5145 determine whether or not a new case label duplicates an old case
5146 label. We need a tree, rather than simply a hash table, because
5147 of the GNU case range extension. */
5151 /* A stack of the currently active switch statements. The innermost
5152 switch statement is on the top of the stack. There is no need to
5153 mark the stack for garbage collection because it is only active
5154 during the processing of the body of a function, and we never
5155 collect at that point. */
5157 static struct cp_switch
*switch_stack
;
5160 case_compare (k1
, k2
)
5164 /* Consider a NULL key (such as arises with a `default' label) to be
5165 smaller than anything else. */
5171 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5174 /* Called right after a switch-statement condition is parsed.
5175 SWITCH_STMT is the switch statement being parsed. */
5178 push_switch (switch_stmt
)
5182 = (struct cp_switch
*) xmalloc (sizeof (struct cp_switch
));
5183 p
->level
= current_binding_level
;
5184 p
->next
= switch_stack
;
5185 p
->switch_stmt
= switch_stmt
;
5186 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
5193 struct cp_switch
*cs
;
5196 splay_tree_delete (cs
->cases
);
5197 switch_stack
= switch_stack
->next
;
5201 /* Note that we've seen a definition of a case label, and complain if this
5202 is a bad place for one. */
5205 finish_case_label (low_value
, high_value
)
5214 splay_tree_node node
;
5219 error ("case label not within a switch statement");
5221 cp_error ("case label `%E' not within a switch statement",
5224 error ("`default' label not within a switch statement");
5228 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
5230 if (processing_template_decl
)
5232 /* For templates, just add the case label; we'll do semantic
5233 analysis at instantiation-time. */
5234 add_stmt (build_case_label (low_value
, high_value
, label
));
5238 /* Find the condition on which this switch statement depends. */
5239 cond
= SWITCH_COND (switch_stack
->switch_stmt
);
5240 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
5241 cond
= TREE_VALUE (cond
);
5242 /* If there was an error processing the switch condition, bail now
5243 before we get more confused. */
5244 if (!cond
|| cond
== error_mark_node
)
5246 type
= TREE_TYPE (cond
);
5248 if ((low_value
&& TREE_TYPE (low_value
)
5249 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
5250 || (high_value
&& TREE_TYPE (high_value
)
5251 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
5252 error ("pointers are not permitted as case values");
5254 /* Case ranges are a GNU extension. */
5255 if (high_value
&& pedantic
)
5256 pedwarn ("ISO C++ forbids range expressions in switch statement");
5260 low_value
= check_case_value (low_value
);
5261 low_value
= convert_and_check (type
, low_value
);
5265 high_value
= check_case_value (high_value
);
5266 high_value
= convert_and_check (type
, high_value
);
5269 /* If an error has occurred, bail out now. */
5270 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
5273 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5274 really a case range, even though it was written that way. Remove
5275 the HIGH_VALUE to simplify later processing. */
5276 if (tree_int_cst_equal (low_value
, high_value
))
5277 high_value
= NULL_TREE
;
5278 if (low_value
&& high_value
5279 && !tree_int_cst_lt (low_value
, high_value
))
5280 warning ("empty range specified");
5282 /* Look up the LOW_VALUE in the table of case labels we already
5284 node
= splay_tree_lookup (switch_stack
->cases
, (splay_tree_key
) low_value
);
5285 /* If there was not an exact match, check for overlapping ranges.
5286 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5287 that's a `default' label and the only overlap is an exact match. */
5288 if (!node
&& (low_value
|| high_value
))
5290 splay_tree_node low_bound
;
5291 splay_tree_node high_bound
;
5293 /* Even though there wasn't an exact match, there might be an
5294 overlap between this case range and another case range.
5295 Since we've (inductively) not allowed any overlapping case
5296 ranges, we simply need to find the greatest low case label
5297 that is smaller that LOW_VALUE, and the smallest low case
5298 label that is greater than LOW_VALUE. If there is an overlap
5299 it will occur in one of these two ranges. */
5300 low_bound
= splay_tree_predecessor (switch_stack
->cases
,
5301 (splay_tree_key
) low_value
);
5302 high_bound
= splay_tree_successor (switch_stack
->cases
,
5303 (splay_tree_key
) low_value
);
5305 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5306 the LOW_VALUE, so there is no need to check unless the
5307 LOW_BOUND is in fact itself a case range. */
5309 && CASE_HIGH ((tree
) low_bound
->value
)
5310 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
5313 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5314 range is bigger than the low end of the current range, so we
5315 are only interested if the current range is a real range, and
5316 not an ordinary case label. */
5319 && (tree_int_cst_compare ((tree
) high_bound
->key
,
5324 /* If there was an overlap, issue an error. */
5327 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
5331 error ("duplicate (or overlapping) case value");
5332 cp_error_at ("this is the first entry overlapping that value",
5337 cp_error ("duplicate case value `%E'", low_value
) ;
5338 cp_error_at ("previously used here", duplicate
);
5342 error ("multiple default labels in one switch");
5343 cp_error_at ("this is the first default label", duplicate
);
5348 cleanup
= last_cleanup_this_contour ();
5351 static int explained
= 0;
5352 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup
));
5353 warning ("where case label appears here");
5356 warning ("(enclose actions of previous case statements requiring destructors in their own scope.)");
5361 check_switch_goto (switch_stack
->level
);
5363 /* After labels, make any new cleanups go into their
5364 own new (temporary) binding contour. */
5365 current_binding_level
->more_cleanups_ok
= 0;
5366 current_function_return_value
= NULL_TREE
;
5368 /* Add a representation for the case label to the statement
5370 case_label
= build_case_label (low_value
, high_value
, label
);
5371 add_stmt (case_label
);
5373 /* Register this case label in the splay tree. */
5374 splay_tree_insert (switch_stack
->cases
,
5375 (splay_tree_key
) low_value
,
5376 (splay_tree_value
) case_label
);
5379 /* Return the list of declarations of the current level.
5380 Note that this list is in reverse order unless/until
5381 you nreverse it; and when you do nreverse it, you must
5382 store the result back using `storedecls' or you will lose. */
5387 return current_binding_level
->names
;
5390 /* Return the list of type-tags (for structs, etc) of the current level. */
5395 return current_binding_level
->tags
;
5398 /* Store the list of declarations of the current level.
5399 This is done for the parameter declarations of a function being defined,
5400 after they are modified in the light of any missing parameters. */
5406 current_binding_level
->names
= decls
;
5409 /* Similarly, store the list of tags of the current level. */
5415 current_binding_level
->tags
= tags
;
5418 /* Given NAME, an IDENTIFIER_NODE,
5419 return the structure (or union or enum) definition for that name.
5420 Searches binding levels from BINDING_LEVEL up to the global level.
5421 If THISLEVEL_ONLY is nonzero, searches only the specified context
5422 (but skips any tag-transparent contexts to find one that is
5423 meaningful for tags).
5424 FORM says which kind of type the caller wants;
5425 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5426 If the wrong kind of type is found, and it's not a template, an error is
5430 lookup_tag (form
, name
, binding_level
, thislevel_only
)
5431 enum tree_code form
;
5433 struct binding_level
*binding_level
;
5436 register struct binding_level
*level
;
5437 /* Non-zero if, we should look past a template parameter level, even
5438 if THISLEVEL_ONLY. */
5439 int allow_template_parms_p
= 1;
5441 for (level
= binding_level
; level
; level
= level
->level_chain
)
5444 if (ANON_AGGRNAME_P (name
))
5445 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5447 /* There's no need for error checking here, because
5448 anon names are unique throughout the compilation. */
5449 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
5450 return TREE_VALUE (tail
);
5452 else if (level
->namespace_p
)
5453 /* Do namespace lookup. */
5454 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
5456 tree old
= binding_for_name (name
, tail
);
5458 /* If we just skipped past a template parameter level,
5459 even though THISLEVEL_ONLY, and we find a template
5460 class declaration, then we use the _TYPE node for the
5461 template. See the example below. */
5462 if (thislevel_only
&& !allow_template_parms_p
5463 && old
&& BINDING_VALUE (old
)
5464 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
5465 old
= TREE_TYPE (BINDING_VALUE (old
));
5467 old
= BINDING_TYPE (old
);
5469 /* If it has an original type, it is a typedef, and we
5470 should not return it. */
5471 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
5473 if (old
&& TREE_CODE (old
) != form
5474 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
5476 cp_error ("`%#D' redeclared as %C", old
, form
);
5481 if (thislevel_only
|| tail
== global_namespace
)
5485 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5487 if (TREE_PURPOSE (tail
) == name
)
5489 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
5490 /* Should tighten this up; it'll probably permit
5491 UNION_TYPE and a struct template, for example. */
5493 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
5495 /* Definition isn't the kind we were looking for. */
5496 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
5500 return TREE_VALUE (tail
);
5503 if (thislevel_only
&& ! level
->tag_transparent
)
5505 if (level
->template_parms_p
&& allow_template_parms_p
)
5507 /* We must deal with cases like this:
5509 template <class T> struct S;
5510 template <class T> struct S {};
5512 When looking up `S', for the second declaration, we
5513 would like to find the first declaration. But, we
5514 are in the pseudo-global level created for the
5515 template parameters, rather than the (surrounding)
5516 namespace level. Thus, we keep going one more level,
5517 even though THISLEVEL_ONLY is non-zero. */
5518 allow_template_parms_p
= 0;
5530 set_current_level_tags_transparency (tags_transparent
)
5531 int tags_transparent
;
5533 current_binding_level
->tag_transparent
= tags_transparent
;
5537 /* Given a type, find the tag that was defined for it and return the tag name.
5538 Otherwise return 0. However, the value can never be 0
5539 in the cases in which this is used.
5541 C++: If NAME is non-zero, this is the new name to install. This is
5542 done when replacing anonymous tags with real tag names. */
5545 lookup_tag_reverse (type
, name
)
5549 register struct binding_level
*level
;
5551 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
5554 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5556 if (TREE_VALUE (tail
) == type
)
5559 TREE_PURPOSE (tail
) = name
;
5560 return TREE_PURPOSE (tail
);
5567 /* Look up NAME in the NAMESPACE. */
5570 lookup_namespace_name (namespace, name
)
5571 tree
namespace, name
;
5574 tree template_id
= NULL_TREE
;
5576 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
5578 if (TREE_CODE (name
) == NAMESPACE_DECL
)
5579 /* This happens for A::B<int> when B is a namespace. */
5581 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
5583 /* This happens for A::B where B is a template, and there are no
5584 template arguments. */
5585 cp_error ("invalid use of `%D'", name
);
5586 return error_mark_node
;
5589 namespace = ORIGINAL_NAMESPACE (namespace);
5591 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5594 name
= TREE_OPERAND (name
, 0);
5595 if (TREE_CODE (name
) == OVERLOAD
)
5596 name
= DECL_NAME (OVL_CURRENT (name
));
5597 else if (DECL_P (name
))
5598 name
= DECL_NAME (name
);
5601 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
5603 val
= make_node (CPLUS_BINDING
);
5604 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
5605 return error_mark_node
;
5607 if (BINDING_VALUE (val
))
5609 val
= BINDING_VALUE (val
);
5613 if (DECL_CLASS_TEMPLATE_P (val
))
5614 val
= lookup_template_class (val
,
5615 TREE_OPERAND (template_id
, 1),
5616 /*in_decl=*/NULL_TREE
,
5617 /*context=*/NULL_TREE
,
5618 /*entering_scope=*/0);
5619 else if (DECL_FUNCTION_TEMPLATE_P (val
)
5620 || TREE_CODE (val
) == OVERLOAD
)
5621 val
= lookup_template_function (val
,
5622 TREE_OPERAND (template_id
, 1));
5625 cp_error ("`%D::%D' is not a template",
5627 return error_mark_node
;
5631 /* If we have a single function from a using decl, pull it out. */
5632 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5633 val
= OVL_FUNCTION (val
);
5637 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
5638 return error_mark_node
;
5641 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5643 static unsigned long
5651 hash
= (((unsigned long) TYPE_CONTEXT (t
))
5652 ^ ((unsigned long) DECL_NAME (TYPE_NAME (t
))));
5657 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5660 typename_compare (k1
, k2
)
5671 d1
= TYPE_NAME (t1
);
5672 d2
= TYPE_NAME (t2
);
5674 return (DECL_NAME (d1
) == DECL_NAME (d2
)
5675 && same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
))
5676 && ((TREE_TYPE (t1
) != NULL_TREE
)
5677 == (TREE_TYPE (t2
) != NULL_TREE
))
5678 && same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
5679 && TYPENAME_TYPE_FULLNAME (t1
) == TYPENAME_TYPE_FULLNAME (t2
));
5682 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5683 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5684 is non-NULL, this type is being created by the implicit typename
5685 extension, and BASE_TYPE is a type named `t' in some base class of
5686 `T' which depends on template parameters.
5688 Returns the new TYPENAME_TYPE. */
5691 build_typename_type (context
, name
, fullname
, base_type
)
5699 struct hash_entry
* e
;
5701 static struct hash_table ht
;
5705 static struct hash_table
*h
= &ht
;
5706 if (!hash_table_init (&ht
, &hash_newfunc
, &typename_hash
,
5708 fatal ("virtual memory exhausted");
5709 ggc_add_tree_hash_table_root (&h
, 1);
5712 /* Build the TYPENAME_TYPE. */
5713 t
= make_aggr_type (TYPENAME_TYPE
);
5714 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5715 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
5716 TREE_TYPE (t
) = base_type
;
5718 /* Build the corresponding TYPE_DECL. */
5719 d
= build_decl (TYPE_DECL
, name
, t
);
5720 TYPE_NAME (TREE_TYPE (d
)) = d
;
5721 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
5722 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
5723 DECL_ARTIFICIAL (d
) = 1;
5725 /* See if we already have this type. */
5726 e
= hash_lookup (&ht
, t
, /*create=*/false, /*copy=*/0);
5730 /* Insert the type into the table. */
5731 hash_lookup (&ht
, t
, /*create=*/true, /*copy=*/0);
5736 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
5737 unless an error occurs, in which case error_mark_node is returned.
5738 If COMPLAIN zero, don't complain about any errors that occur. */
5741 make_typename_type (context
, name
, complain
)
5749 if (!(TYPE_LANG_SPECIFIC (name
)
5750 && (CLASSTYPE_IS_TEMPLATE (name
)
5751 || CLASSTYPE_USE_TEMPLATE (name
))))
5752 name
= TYPE_IDENTIFIER (name
);
5754 /* Create a TEMPLATE_ID_EXPR for the type. */
5755 name
= build_nt (TEMPLATE_ID_EXPR
,
5756 CLASSTYPE_TI_TEMPLATE (name
),
5757 CLASSTYPE_TI_ARGS (name
));
5759 else if (TREE_CODE (name
) == TYPE_DECL
)
5760 name
= DECL_NAME (name
);
5764 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5766 name
= TREE_OPERAND (name
, 0);
5767 if (TREE_CODE (name
) == TEMPLATE_DECL
)
5768 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
5770 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
5771 my_friendly_abort (2000);
5773 if (TREE_CODE (context
) == NAMESPACE_DECL
)
5775 /* We can get here from typename_sub0 in the explicit_template_type
5776 expansion. Just fail. */
5778 cp_error ("no class template named `%#T' in `%#T'",
5780 return error_mark_node
;
5783 if (! uses_template_parms (context
)
5784 || currently_open_class (context
))
5786 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
5788 tree tmpl
= NULL_TREE
;
5789 if (IS_AGGR_TYPE (context
))
5790 tmpl
= lookup_field (context
, name
, 0, 0);
5791 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
5794 cp_error ("no class template named `%#T' in `%#T'",
5796 return error_mark_node
;
5799 return lookup_template_class (tmpl
,
5800 TREE_OPERAND (fullname
, 1),
5802 /*entering_scope=*/0);
5808 if (!IS_AGGR_TYPE (context
))
5811 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5812 return error_mark_node
;
5815 t
= lookup_field (context
, name
, 0, 1);
5817 return TREE_TYPE (t
);
5821 /* If the CONTEXT is not a template type, then either the field is
5822 there now or its never going to be. */
5823 if (!uses_template_parms (context
))
5826 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5827 return error_mark_node
;
5831 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
5834 /* Select the right _DECL from multiple choices. */
5837 select_decl (binding
, flags
)
5842 val
= BINDING_VALUE (binding
);
5843 if (LOOKUP_NAMESPACES_ONLY (flags
))
5845 /* We are not interested in types. */
5846 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
5851 /* If we could have a type and
5852 we have nothing or we need a type and have none. */
5853 if (BINDING_TYPE (binding
)
5854 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
5855 && TREE_CODE (val
) != TYPE_DECL
)))
5856 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
5857 /* Don't return non-types if we really prefer types. */
5858 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
5859 && (TREE_CODE (val
) != TEMPLATE_DECL
5860 || !DECL_CLASS_TEMPLATE_P (val
)))
5866 /* Unscoped lookup of a global: iterate over current namespaces,
5867 considering using-directives. If SPACESP is non-NULL, store a list
5868 of the namespaces we've considered in it. */
5871 unqualified_namespace_lookup (name
, flags
, spacesp
)
5876 tree b
= make_node (CPLUS_BINDING
);
5877 tree initial
= current_decl_namespace();
5878 tree scope
= initial
;
5880 struct binding_level
*level
;
5881 tree val
= NULL_TREE
;
5884 *spacesp
= NULL_TREE
;
5886 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
5889 *spacesp
= tree_cons (scope
, NULL_TREE
, *spacesp
);
5890 val
= binding_for_name (name
, scope
);
5892 /* Initialize binding for this context. */
5893 BINDING_VALUE (b
) = BINDING_VALUE (val
);
5894 BINDING_TYPE (b
) = BINDING_TYPE (val
);
5896 /* Add all _DECLs seen through local using-directives. */
5897 for (level
= current_binding_level
;
5898 !level
->namespace_p
;
5899 level
= level
->level_chain
)
5900 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
5901 scope
, flags
, spacesp
))
5902 /* Give up because of error. */
5903 return error_mark_node
;
5905 /* Add all _DECLs seen through global using-directives. */
5906 /* XXX local and global using lists should work equally. */
5910 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
5911 scope
, flags
, spacesp
))
5912 /* Give up because of error. */
5913 return error_mark_node
;
5914 if (siter
== scope
) break;
5915 siter
= CP_DECL_CONTEXT (siter
);
5918 val
= select_decl (b
, flags
);
5919 if (scope
== global_namespace
)
5925 /* Combine prefer_type and namespaces_only into flags. */
5928 lookup_flags (prefer_type
, namespaces_only
)
5929 int prefer_type
, namespaces_only
;
5931 if (namespaces_only
)
5932 return LOOKUP_PREFER_NAMESPACES
;
5933 if (prefer_type
> 1)
5934 return LOOKUP_PREFER_TYPES
;
5935 if (prefer_type
> 0)
5936 return LOOKUP_PREFER_BOTH
;
5940 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5941 ignore it or not. Subroutine of lookup_name_real. */
5944 qualify_lookup (val
, flags
)
5948 if (val
== NULL_TREE
)
5950 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5952 if ((flags
& LOOKUP_PREFER_TYPES
)
5953 && (TREE_CODE (val
) == TYPE_DECL
5954 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5955 && DECL_CLASS_TEMPLATE_P (val
))))
5957 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5962 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5966 warn_about_implicit_typename_lookup (typename
, binding
)
5970 tree subtype
= TREE_TYPE (TREE_TYPE (typename
));
5971 tree name
= DECL_NAME (typename
);
5973 if (! (TREE_CODE (binding
) == TEMPLATE_DECL
5974 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5975 && CLASSTYPE_TI_TEMPLATE (subtype
) == binding
)
5976 && ! (TREE_CODE (binding
) == TYPE_DECL
5977 && same_type_p (TREE_TYPE (binding
), subtype
)))
5979 cp_warning ("lookup of `%D' finds `%#D'",
5981 cp_warning (" instead of `%D' from dependent base class",
5983 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5984 constructor_name (current_class_type
), name
);
5988 /* Look up NAME in the current binding level and its superiors in the
5989 namespace of variables, functions and typedefs. Return a ..._DECL
5990 node of some kind representing its definition if there is only one
5991 such declaration, or return a TREE_LIST with all the overloaded
5992 definitions if there are many, or return 0 if it is undefined.
5994 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5995 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5996 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5997 Otherwise we prefer non-TYPE_DECLs.
5999 If NONCLASS is non-zero, we don't look for the NAME in class scope,
6000 using IDENTIFIER_CLASS_VALUE. */
6003 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
6005 int prefer_type
, nonclass
, namespaces_only
;
6008 tree val
= NULL_TREE
;
6010 tree from_obj
= NULL_TREE
;
6012 int val_is_implicit_typename
= 0;
6014 /* Hack: copy flag set by parser, if set. */
6015 if (only_namespace_names
)
6016 namespaces_only
= 1;
6018 if (prefer_type
== -2)
6020 extern int looking_for_typename
;
6021 tree type
= NULL_TREE
;
6024 prefer_type
= looking_for_typename
;
6026 flags
= lookup_flags (prefer_type
, namespaces_only
);
6027 /* If the next thing is '<', class templates are types. */
6028 if (looking_for_template
)
6029 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
6031 /* std:: becomes :: for now. */
6032 if (got_scope
== std_node
)
6033 got_scope
= void_type_node
;
6037 else if (got_object
!= error_mark_node
)
6042 if (type
== error_mark_node
)
6043 return error_mark_node
;
6044 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
6045 type
= TREE_TYPE (type
);
6048 type
= complete_type (type
);
6050 if (TREE_CODE (type
) == VOID_TYPE
)
6051 type
= global_namespace
;
6052 if (TREE_CODE (type
) == NAMESPACE_DECL
)
6054 val
= make_node (CPLUS_BINDING
);
6055 flags
|= LOOKUP_COMPLAIN
;
6056 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
6058 val
= select_decl (val
, flags
);
6060 else if (! IS_AGGR_TYPE (type
)
6061 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
6062 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
6063 || TREE_CODE (type
) == TYPENAME_TYPE
)
6064 /* Someone else will give an error about this if needed. */
6066 else if (type
== current_class_type
)
6067 val
= IDENTIFIER_CLASS_VALUE (name
);
6070 val
= lookup_member (type
, name
, 0, prefer_type
);
6071 type_access_control (type
, val
);
6073 /* Restore the containing TYPENAME_TYPE if we looked
6074 through it before. */
6075 if (got_scope
&& got_scope
!= type
6076 && val
&& TREE_CODE (val
) == TYPE_DECL
6077 && TREE_CODE (TREE_TYPE (val
)) == TYPENAME_TYPE
)
6078 TYPE_CONTEXT (TREE_TYPE (val
)) = got_scope
;
6086 else if (got_object
&& val
)
6091 flags
= lookup_flags (prefer_type
, namespaces_only
);
6092 /* If we're not parsing, we need to complain. */
6093 flags
|= LOOKUP_COMPLAIN
;
6096 /* First, look in non-namespace scopes. */
6098 if (current_class_type
== NULL_TREE
)
6101 for (t
= IDENTIFIER_BINDING (name
); t
; t
= TREE_CHAIN (t
))
6105 if (!LOCAL_BINDING_P (t
) && nonclass
)
6106 /* We're not looking for class-scoped bindings, so keep going. */
6109 /* If this is the kind of thing we're looking for, we're done. */
6110 if (qualify_lookup (BINDING_VALUE (t
), flags
))
6111 binding
= BINDING_VALUE (t
);
6112 else if ((flags
& LOOKUP_PREFER_TYPES
)
6113 && qualify_lookup (BINDING_TYPE (t
), flags
))
6114 binding
= BINDING_TYPE (t
);
6116 binding
= NULL_TREE
;
6118 /* Handle access control on types from enclosing or base classes. */
6119 if (binding
&& ! yylex
6120 && BINDING_LEVEL (t
) && BINDING_LEVEL (t
)->parm_flag
== 2)
6121 type_access_control (BINDING_LEVEL (t
)->this_class
, binding
);
6124 && (!val
|| !IMPLICIT_TYPENAME_TYPE_DECL_P (binding
)))
6126 if (val_is_implicit_typename
&& !yylex
)
6127 warn_about_implicit_typename_lookup (val
, binding
);
6129 val_is_implicit_typename
6130 = IMPLICIT_TYPENAME_TYPE_DECL_P (val
);
6131 if (!val_is_implicit_typename
)
6136 /* Now lookup in namespace scopes. */
6137 if (!val
|| val_is_implicit_typename
)
6139 t
= unqualified_namespace_lookup (name
, flags
, 0);
6142 if (val_is_implicit_typename
&& !yylex
)
6143 warn_about_implicit_typename_lookup (val
, t
);
6151 /* This should only warn about types used in qualified-ids. */
6152 if (from_obj
&& from_obj
!= val
)
6154 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
6155 && TREE_CODE (val
) == TYPE_DECL
6156 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
6158 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
6159 name
, got_object
, TREE_TYPE (from_obj
));
6160 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
6164 /* We don't change val to from_obj if got_object depends on
6165 template parms because that breaks implicit typename for
6166 destructor calls. */
6167 if (! uses_template_parms (got_object
))
6171 /* If we have a single function from a using decl, pull it out. */
6172 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
6173 val
= OVL_FUNCTION (val
);
6182 lookup_name_nonclass (name
)
6185 return lookup_name_real (name
, 0, 1, 0);
6189 lookup_function_nonclass (name
, args
)
6193 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
6197 lookup_name_namespace_only (name
)
6200 /* type-or-namespace, nonclass, namespace_only */
6201 return lookup_name_real (name
, 1, 1, 1);
6205 lookup_name (name
, prefer_type
)
6209 return lookup_name_real (name
, prefer_type
, 0, 0);
6212 /* Similar to `lookup_name' but look only in the innermost non-class
6216 lookup_name_current_level (name
)
6219 struct binding_level
*b
;
6222 b
= current_binding_level
;
6223 while (b
->parm_flag
== 2)
6228 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
6230 /* extern "C" function() */
6231 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
6234 else if (IDENTIFIER_BINDING (name
)
6235 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
6239 if (BINDING_LEVEL (IDENTIFIER_BINDING (name
)) == b
)
6240 return IDENTIFIER_VALUE (name
);
6252 /* Like lookup_name_current_level, but for types. */
6255 lookup_type_current_level (name
)
6258 register tree t
= NULL_TREE
;
6260 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
6262 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
6263 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
6265 struct binding_level
*b
= current_binding_level
;
6268 if (purpose_member (name
, b
->type_shadowed
))
6269 return REAL_IDENTIFIER_TYPE_VALUE (name
);
6281 begin_only_namespace_names ()
6283 only_namespace_names
= 1;
6287 end_only_namespace_names ()
6289 only_namespace_names
= 0;
6292 /* Push the declarations of builtin types into the namespace.
6293 RID_INDEX is the index of the builtin type
6294 in the array RID_POINTERS. NAME is the name used when looking
6295 up the builtin type. TYPE is the _TYPE node for the builtin type. */
6298 record_builtin_type (rid_index
, name
, type
)
6303 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
6304 tree tdecl
= NULL_TREE
;
6306 if ((int) rid_index
< (int) RID_MAX
)
6307 rname
= ridpointers
[(int) rid_index
];
6309 tname
= get_identifier (name
);
6311 TYPE_BUILT_IN (type
) = 1;
6315 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
6316 set_identifier_type_value (tname
, NULL_TREE
);
6317 if ((int) rid_index
< (int) RID_MAX
)
6318 /* Built-in types live in the global namespace. */
6319 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
6321 if (rname
!= NULL_TREE
)
6323 if (tname
!= NULL_TREE
)
6325 set_identifier_type_value (rname
, NULL_TREE
);
6326 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
6330 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
6331 set_identifier_type_value (rname
, NULL_TREE
);
6336 /* Record one of the standard Java types.
6337 * Declare it as having the given NAME.
6338 * If SIZE > 0, it is the size of one of the integral types;
6339 * otherwise it is the negative of the size of one of the other types. */
6342 record_builtin_java_type (name
, size
)
6348 type
= make_signed_type (size
);
6349 else if (size
> -32)
6350 { /* "__java_char" or ""__java_boolean". */
6351 type
= make_unsigned_type (-size
);
6352 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6355 { /* "__java_float" or ""__java_double". */
6356 type
= make_node (REAL_TYPE
);
6357 TYPE_PRECISION (type
) = - size
;
6360 record_builtin_type (RID_MAX
, name
, type
);
6361 decl
= TYPE_NAME (type
);
6363 /* Suppress generate debug symbol entries for these types,
6364 since for normal C++ they are just clutter.
6365 However, push_lang_context undoes this if extern "Java" is seen. */
6366 DECL_IGNORED_P (decl
) = 1;
6368 TYPE_FOR_JAVA (type
) = 1;
6372 /* Push a type into the namespace so that the back-ends ignore it. */
6375 record_unknown_type (type
, name
)
6379 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
6380 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
6381 DECL_IGNORED_P (decl
) = 1;
6382 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6383 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
6384 TYPE_ALIGN (type
) = 1;
6385 TYPE_USER_ALIGN (type
) = 0;
6386 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
6389 /* An string for which we should create an IDENTIFIER_NODE at
6392 typedef struct predefined_identifier
6394 /* The name of the identifier. */
6396 /* The place where the IDENTIFIER_NODE should be stored. */
6398 /* Non-zero if this is the name of a constructor or destructor. */
6400 } predefined_identifier
;
6402 /* Create all the predefined identifiers. */
6405 initialize_predefined_identifiers ()
6407 struct predefined_identifier
*pid
;
6409 /* A table of identifiers to create at startup. */
6410 static predefined_identifier predefined_identifiers
[] = {
6411 { "C++", &lang_name_cplusplus
, 0 },
6412 { "C", &lang_name_c
, 0 },
6413 { "Java", &lang_name_java
, 0 },
6414 { CTOR_NAME
, &ctor_identifier
, 1 },
6415 { "__base_ctor", &base_ctor_identifier
, 1 },
6416 { "__comp_ctor", &complete_ctor_identifier
, 1 },
6417 { DTOR_NAME
, &dtor_identifier
, 1 },
6418 { "__comp_dtor", &complete_dtor_identifier
, 1 },
6419 { "__base_dtor", &base_dtor_identifier
, 1 },
6420 { "__deleting_dtor", &deleting_dtor_identifier
, 1 },
6421 { VTABLE_DELTA2_NAME
, &delta2_identifier
, 0 },
6422 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
6423 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
6424 { VTABLE_INDEX_NAME
, &index_identifier
, 0 },
6425 { "nelts", &nelts_identifier
, 0 },
6426 { THIS_NAME
, &this_identifier
, 0 },
6427 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
6428 { "__pfn_or_delta2", &pfn_or_delta2_identifier
, 0 },
6429 { "_vptr", &vptr_identifier
, 0 },
6430 { "__cp_push_exception", &cp_push_exception_identifier
, 0 },
6431 { "__vtt_parm", &vtt_parm_identifier
, 0 },
6432 { "std", &std_identifier
, 0 },
6436 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
6438 *pid
->node
= get_identifier (pid
->name
);
6439 if (pid
->ctor_or_dtor_p
)
6440 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
6444 /* Create the predefined scalar types of C,
6445 and some nodes representing standard constants (0, 1, (void *)0).
6446 Initialize the global binding level.
6447 Make definitions for built-in primitive functions. */
6450 init_decl_processing ()
6453 int wchar_type_size
;
6454 tree array_domain_type
;
6456 /* Check to see that the user did not specify an invalid combination
6457 of command-line options. */
6458 if (flag_new_abi
&& !flag_vtable_thunks
)
6459 fatal ("the new ABI requires vtable thunks");
6461 /* Create all the identifiers we need. */
6462 initialize_predefined_identifiers ();
6464 /* Let the back-end now how to save and restore language-specific
6465 per-function globals. */
6466 init_lang_status
= &push_cp_function_context
;
6467 free_lang_status
= &pop_cp_function_context
;
6468 mark_lang_status
= &mark_cp_function_context
;
6474 /* Create the global variables. */
6475 push_to_top_level ();
6477 /* Enter the global namespace. */
6478 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
6479 push_namespace (get_identifier ("::"));
6480 global_namespace
= current_namespace
;
6481 current_lang_name
= NULL_TREE
;
6483 /* Adjust various flags based on command-line settings. */
6484 if (! flag_permissive
&& ! pedantic
)
6485 flag_pedantic_errors
= 1;
6486 if (!flag_no_inline
)
6487 flag_inline_trees
= 1;
6490 current_lang_name
= lang_name_c
;
6492 current_function_decl
= NULL_TREE
;
6493 current_binding_level
= NULL_BINDING_LEVEL
;
6494 free_binding_level
= NULL_BINDING_LEVEL
;
6496 build_common_tree_nodes (flag_signed_char
);
6498 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
6499 TREE_TYPE (error_mark_list
) = error_mark_node
;
6501 /* Make the binding_level structure for global names. */
6503 global_binding_level
= current_binding_level
;
6504 /* The global level is the namespace level of ::. */
6505 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
6506 declare_namespace_level ();
6508 /* Define `int' and `char' first so that dbx will output them first. */
6509 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
6510 record_builtin_type (RID_CHAR
, "char", char_type_node
);
6512 /* `signed' is the same as `int' */
6513 record_builtin_type (RID_SIGNED
, NULL_PTR
, integer_type_node
);
6514 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
6515 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
6516 record_builtin_type (RID_MAX
, "long unsigned int",
6517 long_unsigned_type_node
);
6518 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
6519 record_builtin_type (RID_MAX
, "long long int",
6520 long_long_integer_type_node
);
6521 record_builtin_type (RID_MAX
, "long long unsigned int",
6522 long_long_unsigned_type_node
);
6523 record_builtin_type (RID_MAX
, "long long unsigned",
6524 long_long_unsigned_type_node
);
6525 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
6526 record_builtin_type (RID_MAX
, "short unsigned int",
6527 short_unsigned_type_node
);
6528 record_builtin_type (RID_MAX
, "unsigned short",
6529 short_unsigned_type_node
);
6532 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
6534 /* Define both `signed char' and `unsigned char'. */
6535 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
6536 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
6538 /* `unsigned long' is the standard type for sizeof.
6539 Note that stddef.h uses `unsigned long',
6540 and this must agree, even if long and int are the same size. */
6542 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
6544 /* Create the widest literal types. */
6545 widest_integer_literal_type_node
= make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
6546 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6547 widest_integer_literal_type_node
));
6549 widest_unsigned_literal_type_node
= make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
6550 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6551 widest_unsigned_literal_type_node
));
6553 /* These are types that type_for_size and type_for_mode use. */
6554 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
6555 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
6556 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
6557 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
6558 #if HOST_BITS_PER_WIDE_INT >= 64
6559 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
6561 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
6562 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
6563 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
6564 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
6565 #if HOST_BITS_PER_WIDE_INT >= 64
6566 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
6569 build_common_tree_nodes_2 (flag_short_double
);
6571 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
6572 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
6573 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
6574 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
6575 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
6576 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
6577 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
6578 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
6580 integer_two_node
= build_int_2 (2, 0);
6581 TREE_TYPE (integer_two_node
) = integer_type_node
;
6582 integer_three_node
= build_int_2 (3, 0);
6583 TREE_TYPE (integer_three_node
) = integer_type_node
;
6585 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
6586 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
6587 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
6588 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
6589 TYPE_PRECISION (boolean_type_node
) = 1;
6590 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
6591 boolean_false_node
= build_int_2 (0, 0);
6592 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
6593 boolean_true_node
= build_int_2 (1, 0);
6594 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
6596 signed_size_zero_node
= build_int_2 (0, 0);
6597 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
6598 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
6599 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
6601 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
6602 complex_integer_type_node
));
6603 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
6604 complex_float_type_node
));
6605 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
6606 complex_double_type_node
));
6607 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
6608 complex_long_double_type_node
));
6610 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
6612 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
6613 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
6614 TREE_PARMLIST (void_list_node
) = 1;
6616 string_type_node
= build_pointer_type (char_type_node
);
6617 const_string_type_node
6618 = build_pointer_type (build_qualified_type (char_type_node
,
6620 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
6622 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
6625 /* Make a type to be the domain of a few array types
6626 whose domains don't really matter.
6627 200 is small enough that it always fits in size_t. */
6628 array_domain_type
= build_index_type (build_int_2 (200, 0));
6630 /* Make a type for arrays of characters.
6631 With luck nothing will ever really depend on the length of this
6633 char_array_type_node
6634 = build_array_type (char_type_node
, array_domain_type
);
6636 /* Likewise for arrays of ints. */
6638 = build_array_type (integer_type_node
, array_domain_type
);
6641 delta_type_node
= ptrdiff_type_node
;
6642 else if (flag_huge_objects
)
6643 delta_type_node
= long_integer_type_node
;
6645 delta_type_node
= short_integer_type_node
;
6648 vtable_index_type
= ptrdiff_type_node
;
6650 vtable_index_type
= delta_type_node
;
6652 default_function_type
6653 = build_function_type (integer_type_node
, NULL_TREE
);
6655 ptr_type_node
= build_pointer_type (void_type_node
);
6657 = build_pointer_type (build_qualified_type (void_type_node
,
6659 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
6660 c_common_nodes_and_builtins (1, flag_no_builtin
, flag_no_nonansi_builtin
);
6661 lang_type_promotes_to
= convert_type_from_ellipsis
;
6664 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6666 /* C++ extensions */
6668 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6669 record_unknown_type (unknown_type_node
, "unknown type");
6671 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6672 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6674 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6676 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6678 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6679 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6681 /* This is special for C++ so functions can be overloaded. */
6682 wchar_type_node
= get_identifier (flag_short_wchar
6683 ? "short unsigned int"
6685 wchar_type_node
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node
));
6686 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6687 if (TREE_UNSIGNED (wchar_type_node
))
6688 wchar_type_node
= make_signed_type (wchar_type_size
);
6690 wchar_type_node
= make_unsigned_type (wchar_type_size
);
6691 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6693 /* Artificial declaration of wchar_t -- can be bashed */
6694 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6696 pushdecl (wchar_decl_node
);
6698 /* This is for wide string constants. */
6699 wchar_array_type_node
6700 = build_array_type (wchar_type_node
, array_domain_type
);
6702 if (flag_vtable_thunks
)
6704 /* Make sure we get a unique function type, so we can give
6705 its pointer type a name. (This wins for gdb.) */
6706 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6707 TREE_TYPE (vfunc_type
) = integer_type_node
;
6708 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6709 layout_type (vfunc_type
);
6711 vtable_entry_type
= build_pointer_type (vfunc_type
);
6715 vtable_entry_type
= make_aggr_type (RECORD_TYPE
);
6716 fields
[0] = build_decl (FIELD_DECL
, delta_identifier
,
6718 fields
[1] = build_decl (FIELD_DECL
, index_identifier
,
6720 fields
[2] = build_decl (FIELD_DECL
, pfn_identifier
,
6722 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6725 /* Make this part of an invisible union. */
6726 fields
[3] = copy_node (fields
[2]);
6727 TREE_TYPE (fields
[3]) = delta_type_node
;
6728 DECL_NAME (fields
[3]) = delta2_identifier
;
6729 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6730 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6731 DECL_SIZE_UNIT (fields
[3]) = TYPE_SIZE_UNIT (delta_type_node
);
6732 TREE_UNSIGNED (fields
[3]) = 0;
6733 TREE_CHAIN (fields
[2]) = fields
[3];
6734 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6737 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6740 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
6741 layout_type (vtbl_type_node
);
6742 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6743 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6744 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6745 layout_type (vtbl_ptr_type_node
);
6746 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6748 std_node
= build_decl (NAMESPACE_DECL
,
6750 ? get_identifier ("fake std") : std_identifier
,
6752 pushdecl (std_node
);
6756 push_namespace (get_identifier ("__cxxabiv1"));
6757 abi_node
= current_namespace
;
6761 global_type_node
= make_node (LANG_TYPE
);
6762 record_unknown_type (global_type_node
, "global type");
6765 current_lang_name
= lang_name_cplusplus
;
6768 tree bad_alloc_type_node
, newtype
, deltype
;
6770 push_namespace (get_identifier ("std"));
6771 bad_alloc_type_node
= xref_tag
6772 (class_type_node
, get_identifier ("bad_alloc"), 1);
6775 newtype
= build_exception_variant
6776 (ptr_ftype_sizetype
, add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1));
6777 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6778 push_cp_library_fn (NEW_EXPR
, newtype
);
6779 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
6780 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
6781 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
6785 = build_library_fn_ptr ("__pure_virtual", void_ftype
);
6787 /* Perform other language dependent initializations. */
6788 init_class_processing ();
6789 init_init_processing ();
6790 init_search_processing ();
6791 init_rtti_processing ();
6793 if (flag_exceptions
)
6794 init_exception_processing ();
6797 flag_inline_functions
= 0;
6800 if (! supports_one_only ())
6803 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6804 function_id_node
= get_identifier ("__FUNCTION__");
6805 pretty_function_id_node
= get_identifier ("__PRETTY_FUNCTION__");
6806 func_id_node
= get_identifier ("__func__");
6808 make_fname_decl
= cp_make_fname_decl
;
6809 declare_function_name ();
6811 /* Prepare to check format strings against argument lists. */
6812 init_function_format_info ();
6814 /* Show we use EH for cleanups. */
6815 using_eh_for_cleanups ();
6817 valid_lang_attribute
= cp_valid_lang_attribute
;
6819 /* Maintain consistency. Perhaps we should just complain if they
6820 say -fwritable-strings? */
6821 if (flag_writable_strings
)
6822 flag_const_strings
= 0;
6824 /* Add GC roots for all of our global variables. */
6825 ggc_add_tree_root (c_global_trees
, sizeof c_global_trees
/ sizeof(tree
));
6826 ggc_add_tree_root (cp_global_trees
, sizeof cp_global_trees
/ sizeof(tree
));
6827 ggc_add_tree_root (&integer_three_node
, 1);
6828 ggc_add_tree_root (&integer_two_node
, 1);
6829 ggc_add_tree_root (&signed_size_zero_node
, 1);
6830 ggc_add_tree_root (&size_one_node
, 1);
6831 ggc_add_tree_root (&size_zero_node
, 1);
6832 ggc_add_root (&global_binding_level
, 1, sizeof global_binding_level
,
6833 mark_binding_level
);
6834 ggc_add_root (&scope_chain
, 1, sizeof scope_chain
, &mark_saved_scope
);
6835 ggc_add_tree_root (&static_ctors
, 1);
6836 ggc_add_tree_root (&static_dtors
, 1);
6837 ggc_add_tree_root (&lastiddecl
, 1);
6839 ggc_add_tree_root (&last_function_parm_tags
, 1);
6840 ggc_add_tree_root (¤t_function_return_value
, 1);
6841 ggc_add_tree_root (¤t_function_parm_tags
, 1);
6842 ggc_add_tree_root (&last_function_parms
, 1);
6843 ggc_add_tree_root (&error_mark_list
, 1);
6845 ggc_add_tree_root (&global_namespace
, 1);
6846 ggc_add_tree_root (&global_type_node
, 1);
6847 ggc_add_tree_root (&anonymous_namespace_name
, 1);
6849 ggc_add_tree_root (&got_object
, 1);
6850 ggc_add_tree_root (&got_scope
, 1);
6852 ggc_add_tree_root (¤t_lang_name
, 1);
6853 ggc_add_tree_root (&static_aggregates
, 1);
6856 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6857 decl, NAME is the initialization string and TYPE_DEP indicates whether
6858 NAME depended on the type of the function. We make use of that to detect
6859 __PRETTY_FUNCTION__ inside a template fn. Because we build a tree for
6860 the function before emitting any of it, we don't need to treat the
6861 VAR_DECL specially. We can decide whether to emit it later, if it was
6865 cp_make_fname_decl (id
, name
, type_dep
)
6870 tree decl
, type
, init
;
6871 size_t length
= strlen (name
);
6872 tree domain
= NULL_TREE
;
6874 if (!processing_template_decl
)
6877 domain
= build_index_type (build_int_2 (length
, 0));
6879 type
= build_cplus_array_type
6880 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
6883 decl
= build_decl (VAR_DECL
, id
, type
);
6884 TREE_STATIC (decl
) = 1;
6885 TREE_READONLY (decl
) = 1;
6886 DECL_SOURCE_LINE (decl
) = 0;
6887 DECL_ARTIFICIAL (decl
) = 1;
6888 DECL_IN_SYSTEM_HEADER (decl
) = 1;
6890 if (processing_template_decl
)
6891 decl
= push_template_decl (decl
);
6894 init
= build (FUNCTION_NAME
, type
);
6895 DECL_PRETTY_FUNCTION_P (decl
) = 1;
6899 init
= build_string (length
+ 1, name
);
6900 TREE_TYPE (init
) = type
;
6902 DECL_INITIAL (decl
) = init
;
6903 cp_finish_decl (decl
, init
, NULL_TREE
, LOOKUP_ONLYCONVERTING
);
6905 /* We will have to make sure we only emit this, if it is actually used. */
6909 /* Entry point for the benefit of c_common_nodes_and_builtins.
6911 Make a definition for a builtin function named NAME and whose data type
6912 is TYPE. TYPE should be a function type with argument types.
6914 CLASS and CODE tell later passes how to compile calls to this function.
6915 See tree.h for possible values.
6917 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6918 the name to be called if we can't opencode the function. */
6921 builtin_function (name
, type
, code
, class, libname
)
6925 enum built_in_class
class;
6926 const char *libname
;
6928 tree decl
= build_library_fn_1 (get_identifier (name
), ERROR_MARK
, type
);
6929 DECL_BUILT_IN_CLASS (decl
) = class;
6930 DECL_FUNCTION_CODE (decl
) = code
;
6932 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6934 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6935 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6936 function in the namespace. */
6939 DECL_ASSEMBLER_NAME (decl
) = get_identifier (libname
);
6940 make_function_rtl (decl
);
6942 /* Warn if a function in the namespace for users
6943 is used without an occasion to consider it declared. */
6944 if (name
[0] != '_' || name
[1] != '_')
6945 DECL_ANTICIPATED (decl
) = 1;
6950 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6951 function. Not called directly. */
6954 build_library_fn_1 (name
, operator_code
, type
)
6956 enum tree_code operator_code
;
6959 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
6960 DECL_EXTERNAL (fn
) = 1;
6961 TREE_PUBLIC (fn
) = 1;
6962 DECL_ARTIFICIAL (fn
) = 1;
6963 TREE_NOTHROW (fn
) = 1;
6964 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
6968 /* Returns the _DECL for a library function with C linkage.
6969 We assume that such functions never throw; if this is incorrect,
6970 callers should unset TREE_NOTHROW. */
6973 build_library_fn (name
, type
)
6977 tree fn
= build_library_fn_1 (name
, ERROR_MARK
, type
);
6978 make_function_rtl (fn
);
6982 /* Returns the _DECL for a library function with C++ linkage. */
6985 build_cp_library_fn (name
, operator_code
, type
)
6987 enum tree_code operator_code
;
6990 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
6991 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
6992 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
6993 set_mangled_name_for_decl (fn
);
6994 make_function_rtl (fn
);
6998 /* Like build_library_fn, but takes a C string instead of an
7002 build_library_fn_ptr (name
, type
)
7006 return build_library_fn (get_identifier (name
), type
);
7009 /* Like build_cp_library_fn, but takes a C string instead of an
7013 build_cp_library_fn_ptr (name
, type
)
7017 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
7020 /* Like build_library_fn, but also pushes the function so that we will
7021 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
7024 push_library_fn (name
, type
)
7027 tree fn
= build_library_fn (name
, type
);
7028 pushdecl_top_level (fn
);
7032 /* Like build_cp_library_fn, but also pushes the function so that it
7033 will be found by normal lookup. */
7036 push_cp_library_fn (operator_code
, type
)
7037 enum tree_code operator_code
;
7040 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
7047 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
7051 push_void_library_fn (name
, parmtypes
)
7052 tree name
, parmtypes
;
7054 tree type
= build_function_type (void_type_node
, parmtypes
);
7055 return push_library_fn (name
, type
);
7058 /* Like push_library_fn, but also note that this function throws
7059 and does not return. Used for __throw_foo and the like. */
7062 push_throw_library_fn (name
, type
)
7065 tree fn
= push_library_fn (name
, type
);
7066 TREE_THIS_VOLATILE (fn
) = 1;
7067 TREE_NOTHROW (fn
) = 0;
7071 /* When we call finish_struct for an anonymous union, we create
7072 default copy constructors and such. But, an anonymous union
7073 shouldn't have such things; this function undoes the damage to the
7074 anonymous union type T.
7076 (The reason that we create the synthesized methods is that we don't
7077 distinguish `union { int i; }' from `typedef union { int i; } U'.
7078 The first is an anonymous union; the second is just an ordinary
7082 fixup_anonymous_aggr (t
)
7087 /* Wipe out memory of synthesized methods */
7088 TYPE_HAS_CONSTRUCTOR (t
) = 0;
7089 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
7090 TYPE_HAS_INIT_REF (t
) = 0;
7091 TYPE_HAS_CONST_INIT_REF (t
) = 0;
7092 TYPE_HAS_ASSIGN_REF (t
) = 0;
7093 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
7095 /* Splice the implicitly generated functions out of the TYPE_METHODS
7097 q
= &TYPE_METHODS (t
);
7100 if (DECL_ARTIFICIAL (*q
))
7101 *q
= TREE_CHAIN (*q
);
7103 q
= &TREE_CHAIN (*q
);
7106 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
7107 if (TYPE_METHODS (t
))
7108 error ("an anonymous union cannot have function members");
7111 /* Make sure that a declaration with no declarator is well-formed, i.e.
7112 just defines a tagged type or anonymous union.
7114 Returns the type defined, if any. */
7117 check_tag_decl (declspecs
)
7122 tree ob_modifier
= NULL_TREE
;
7124 register tree t
= NULL_TREE
;
7126 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
7128 register tree value
= TREE_VALUE (link
);
7131 || (TREE_CODE (value
) == IDENTIFIER_NODE
7132 && IDENTIFIER_GLOBAL_VALUE (value
)
7133 && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value
))))
7137 if ((TREE_CODE (value
) != TYPENAME_TYPE
&& IS_AGGR_TYPE (value
))
7138 || TREE_CODE (value
) == ENUMERAL_TYPE
)
7140 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
7144 else if (value
== ridpointers
[(int) RID_FRIEND
])
7146 if (current_class_type
== NULL_TREE
7147 || current_scope () != current_class_type
)
7148 ob_modifier
= value
;
7152 else if (value
== ridpointers
[(int) RID_STATIC
]
7153 || value
== ridpointers
[(int) RID_EXTERN
]
7154 || value
== ridpointers
[(int) RID_AUTO
]
7155 || value
== ridpointers
[(int) RID_REGISTER
]
7156 || value
== ridpointers
[(int) RID_INLINE
]
7157 || value
== ridpointers
[(int) RID_VIRTUAL
]
7158 || value
== ridpointers
[(int) RID_CONST
]
7159 || value
== ridpointers
[(int) RID_VOLATILE
]
7160 || value
== ridpointers
[(int) RID_EXPLICIT
])
7161 ob_modifier
= value
;
7165 error ("multiple types in one declaration");
7167 if (t
== NULL_TREE
&& ! saw_friend
)
7168 pedwarn ("declaration does not declare anything");
7170 /* Check for an anonymous union. We're careful
7171 accessing TYPE_IDENTIFIER because some built-in types, like
7172 pointer-to-member types, do not have TYPE_NAME. */
7173 else if (t
&& IS_AGGR_TYPE_CODE (TREE_CODE (t
))
7175 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
7177 /* Anonymous unions are objects, so they can have specifiers. */;
7178 SET_ANON_AGGR_TYPE_P (t
);
7180 if (TREE_CODE (t
) != UNION_TYPE
&& pedantic
&& ! in_system_header
)
7181 pedwarn ("ISO C++ prohibits anonymous structs");
7184 else if (ob_modifier
)
7186 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
7187 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
7188 cp_error ("`%D' can only be specified for functions", ob_modifier
);
7189 else if (ob_modifier
== ridpointers
[(int) RID_FRIEND
])
7190 cp_error ("`%D' can only be specified inside a class", ob_modifier
);
7191 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
7192 cp_error ("`%D' can only be specified for constructors",
7195 cp_error ("`%D' can only be specified for objects and functions",
7202 /* Called when a declaration is seen that contains no names to declare.
7203 If its type is a reference to a structure, union or enum inherited
7204 from a containing scope, shadow that tag name for the current scope
7205 with a forward reference.
7206 If its type defines a new named structure or union
7207 or defines an enum, it is valid but we need not do anything here.
7208 Otherwise, it is an error.
7210 C++: may have to grok the declspecs to learn about static,
7211 complain for anonymous unions. */
7214 shadow_tag (declspecs
)
7217 tree t
= check_tag_decl (declspecs
);
7220 maybe_process_partial_specialization (t
);
7222 /* This is where the variables in an anonymous union are
7223 declared. An anonymous union declaration looks like:
7225 because there is no declarator after the union, the parser
7226 sends that declaration here. */
7227 if (t
&& ANON_AGGR_TYPE_P (t
))
7229 fixup_anonymous_aggr (t
);
7231 if (TYPE_FIELDS (t
))
7233 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
7235 finish_anon_union (decl
);
7240 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
7243 groktypename (typename
)
7246 if (TREE_CODE (typename
) != TREE_LIST
)
7248 return grokdeclarator (TREE_VALUE (typename
),
7249 TREE_PURPOSE (typename
),
7250 TYPENAME
, 0, NULL_TREE
);
7253 /* Decode a declarator in an ordinary declaration or data definition.
7254 This is called as soon as the type information and variable name
7255 have been parsed, before parsing the initializer if any.
7256 Here we create the ..._DECL node, fill in its type,
7257 and put it on the list of decls for the current context.
7258 The ..._DECL node is returned as the value.
7260 Exception: for arrays where the length is not specified,
7261 the type is left null, to be filled in by `cp_finish_decl'.
7263 Function definitions do not come here; they go to start_function
7264 instead. However, external and forward declarations of functions
7265 do go through here. Structure field declarations are done by
7266 grokfield and not through here. */
7269 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
7270 tree declarator
, declspecs
;
7272 tree attributes
, prefix_attributes
;
7275 register tree type
, tem
;
7277 extern int have_extern_spec
;
7278 extern int used_extern_spec
;
7282 /* See code below that used this. */
7283 int init_written
= initialized
;
7286 /* This should only be done once on the top most decl. */
7287 if (have_extern_spec
&& !used_extern_spec
)
7289 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
7291 used_extern_spec
= 1;
7294 if (attributes
|| prefix_attributes
)
7295 attrlist
= build_tree_list (attributes
, prefix_attributes
);
7297 attrlist
= NULL_TREE
;
7299 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
7302 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
7305 type
= TREE_TYPE (decl
);
7307 if (type
== error_mark_node
)
7310 context
= DECL_CONTEXT (decl
);
7312 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
7313 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
7315 /* When parsing the initializer, lookup should use the object's
7317 push_decl_namespace (context
);
7320 /* We are only interested in class contexts, later. */
7321 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
7322 context
= NULL_TREE
;
7325 /* Is it valid for this decl to have an initializer at all?
7326 If not, set INITIALIZED to zero, which will indirectly
7327 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7328 switch (TREE_CODE (decl
))
7331 /* typedef foo = bar means give foo the same type as bar.
7332 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7333 Any other case of an initialization in a TYPE_DECL is an error. */
7334 if (pedantic
|| list_length (declspecs
) > 1)
7336 cp_error ("typedef `%D' is initialized", decl
);
7342 cp_error ("function `%#D' is initialized like a variable", decl
);
7352 if (! toplevel_bindings_p ()
7353 && DECL_EXTERNAL (decl
))
7354 cp_warning ("declaration of `%#D' has `extern' and is initialized",
7356 DECL_EXTERNAL (decl
) = 0;
7357 if (toplevel_bindings_p ())
7358 TREE_STATIC (decl
) = 1;
7360 /* Tell `pushdecl' this is an initialized decl
7361 even though we don't yet have the initializer expression.
7362 Also tell `cp_finish_decl' it may store the real initializer. */
7363 DECL_INITIAL (decl
) = error_mark_node
;
7366 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7367 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
7370 /* Set attributes here so if duplicate decl, will have proper attributes. */
7371 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
7373 if (context
&& COMPLETE_TYPE_P (complete_type (context
)))
7375 push_nested_class (context
, 2);
7377 if (TREE_CODE (decl
) == VAR_DECL
)
7379 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
7380 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
7381 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
7384 if (DECL_CONTEXT (field
) != context
)
7386 cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7387 DECL_CONTEXT (field
), DECL_NAME (decl
),
7388 context
, DECL_NAME (decl
));
7389 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
7391 /* Static data member are tricky; an in-class initialization
7392 still doesn't provide a definition, so the in-class
7393 declaration will have DECL_EXTERNAL set, but will have an
7394 initialization. Thus, duplicate_decls won't warn
7395 about this situation, and so we check here. */
7396 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
7397 cp_error ("duplicate initialization of %D", decl
);
7398 if (duplicate_decls (decl
, field
))
7404 tree field
= check_classfn (context
, decl
);
7405 if (field
&& duplicate_decls (decl
, field
))
7409 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7410 DECL_IN_AGGR_P (decl
) = 0;
7411 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
7412 || CLASSTYPE_TEMPLATE_INSTANTIATION (context
))
7414 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
7415 /* [temp.expl.spec] An explicit specialization of a static data
7416 member of a template is a definition if the declaration
7417 includes an initializer; otherwise, it is a declaration.
7419 We check for processing_specialization so this only applies
7420 to the new specialization syntax. */
7421 if (DECL_INITIAL (decl
) == NULL_TREE
&& processing_specialization
)
7422 DECL_EXTERNAL (decl
) = 1;
7425 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
7426 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7430 /* Enter this declaration into the symbol table. */
7431 tem
= maybe_push_decl (decl
);
7433 if (processing_template_decl
)
7434 tem
= push_template_decl (tem
);
7436 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7437 /* Tell the back-end to use or not use .common as appropriate. If we say
7438 -fconserve-space, we want this to save .data space, at the expense of
7439 wrong semantics. If we say -fno-conserve-space, we want this to
7440 produce errors about redefs; to do this we force variables into the
7442 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
7445 if (! processing_template_decl
)
7455 tree type
= TREE_TYPE (decl
);
7456 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
7458 if (type
== error_mark_node
)
7461 /* If this type of object needs a cleanup, but we're not allowed to
7462 add any more objects with cleanups to the current scope, create a
7463 new binding level. */
7464 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7465 && current_binding_level
->more_cleanups_ok
== 0)
7467 keep_next_level (2);
7470 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7474 /* Is it valid for this decl to have an initializer at all?
7475 If not, set INITIALIZED to zero, which will indirectly
7476 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7478 /* Don't allow initializations for incomplete types except for
7479 arrays which might be completed by the initialization. */
7480 if (COMPLETE_TYPE_P (complete_type (type
)))
7481 ; /* A complete type is ok. */
7482 else if (TREE_CODE (type
) != ARRAY_TYPE
)
7484 cp_error ("variable `%#D' has initializer but incomplete type",
7487 type
= TREE_TYPE (decl
) = error_mark_node
;
7489 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
7491 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
7492 cp_error ("elements of array `%#D' have incomplete type", decl
);
7493 /* else we already gave an error in start_decl. */
7499 && TREE_CODE (decl
) != TYPE_DECL
7500 && TREE_CODE (decl
) != TEMPLATE_DECL
7501 && type
!= error_mark_node
7502 && IS_AGGR_TYPE (type
)
7503 && ! DECL_EXTERNAL (decl
))
7505 if ((! processing_template_decl
|| ! uses_template_parms (type
))
7506 && !COMPLETE_TYPE_P (complete_type (type
)))
7508 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7510 /* Change the type so that assemble_variable will give
7511 DECL an rtl we can live with: (mem (const_int 0)). */
7512 type
= TREE_TYPE (decl
) = error_mark_node
;
7516 /* If any base type in the hierarchy of TYPE needs a constructor,
7517 then we set initialized to 1. This way any nodes which are
7518 created for the purposes of initializing this aggregate
7519 will live as long as it does. This is necessary for global
7520 aggregates which do not have their initializers processed until
7521 the end of the file. */
7522 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
7527 DECL_INITIAL (decl
) = NULL_TREE
;
7530 /* Handle initialization of references.
7531 These three arguments are from `cp_finish_decl', and have the
7532 same meaning here that they do there.
7534 Quotes on semantics can be found in ARM 8.4.3. */
7537 grok_reference_init (decl
, type
, init
)
7538 tree decl
, type
, init
;
7542 if (init
== NULL_TREE
)
7544 if ((DECL_LANG_SPECIFIC (decl
) == 0
7545 || DECL_IN_AGGR_P (decl
) == 0)
7546 && ! DECL_THIS_EXTERN (decl
))
7547 cp_error ("`%D' declared as reference but not initialized", decl
);
7551 if (init
== error_mark_node
)
7554 if (TREE_CODE (init
) == CONSTRUCTOR
)
7556 cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl
);
7560 if (TREE_CODE (init
) == TREE_LIST
)
7561 init
= build_compound_expr (init
);
7563 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
7564 init
= convert_from_reference (init
);
7566 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
7567 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
7569 /* Note: default conversion is only called in very special cases. */
7570 init
= default_conversion (init
);
7573 /* Convert INIT to the reference type TYPE. This may involve the
7574 creation of a temporary, whose lifetime must be the same as that
7575 of the reference. If so, a DECL_STMT for the temporary will be
7576 added just after the DECL_STMT for DECL. That's why we don't set
7577 DECL_INITIAL for local references (instead assigning to them
7578 explicitly); we need to allow the temporary to be initialized
7580 tmp
= convert_to_reference
7581 (type
, init
, CONV_IMPLICIT
,
7582 LOOKUP_ONLYCONVERTING
|LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
,
7585 if (tmp
== error_mark_node
)
7587 else if (tmp
!= NULL_TREE
)
7590 tmp
= save_expr (tmp
);
7591 if (building_stmt_tree ())
7593 /* Initialize the declaration. */
7594 tmp
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, tmp
);
7595 finish_expr_stmt (tmp
);
7598 DECL_INITIAL (decl
) = tmp
;
7602 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
7606 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
7608 expand_static_init (decl
, DECL_INITIAL (decl
));
7609 DECL_INITIAL (decl
) = NULL_TREE
;
7614 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7615 mucking with forces it does not comprehend (i.e. initialization with a
7616 constructor). If we are at global scope and won't go into COMMON, fill
7617 it in with a dummy CONSTRUCTOR to force the variable into .data;
7618 otherwise we can use error_mark_node. */
7621 obscure_complex_init (decl
, init
)
7624 if (! flag_no_inline
&& TREE_STATIC (decl
))
7626 if (extract_init (decl
, init
))
7630 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7631 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
7632 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
7636 DECL_INITIAL (decl
) = error_mark_node
;
7641 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7642 array until we finish parsing the initializer. If that's the
7643 situation we're in, update DECL accordingly. */
7646 maybe_deduce_size_from_array_init (decl
, init
)
7650 tree type
= TREE_TYPE (decl
);
7652 if (TREE_CODE (type
) == ARRAY_TYPE
7653 && TYPE_DOMAIN (type
) == NULL_TREE
7654 && TREE_CODE (decl
) != TYPE_DECL
)
7657 = (TREE_STATIC (decl
)
7658 /* Even if pedantic, an external linkage array
7659 may have incomplete type at first. */
7660 ? pedantic
&& ! DECL_EXTERNAL (decl
)
7661 : !DECL_EXTERNAL (decl
));
7662 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7663 int failure
= complete_array_type (type
, initializer
, do_default
);
7666 cp_error ("initializer fails to determine size of `%D'", decl
);
7671 cp_error ("array size missing in `%D'", decl
);
7672 /* If a `static' var's size isn't known, make it extern as
7673 well as static, so it does not get allocated. If it's not
7674 `static', then don't mark it extern; finish_incomplete_decl
7675 will give it a default size and it will get allocated. */
7676 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7677 DECL_EXTERNAL (decl
) = 1;
7680 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7681 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7683 cp_error ("zero-size array `%D'", decl
);
7685 layout_decl (decl
, 0);
7689 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7690 any appropriate error messages regarding the layout. */
7693 layout_var_decl (decl
)
7696 tree type
= TREE_TYPE (decl
);
7698 tree ttype
= target_type (type
);
7701 /* If we haven't already layed out this declaration, do so now.
7702 Note that we must not call complete type for an external object
7703 because it's type might involve templates that we are not
7704 supposed to isntantiate yet. (And it's perfectly legal to say
7705 `extern X x' for some incomplete type `X'.) */
7706 if (!DECL_EXTERNAL (decl
))
7707 complete_type (type
);
7708 if (!DECL_SIZE (decl
) && COMPLETE_TYPE_P (type
))
7709 layout_decl (decl
, 0);
7711 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7713 /* An automatic variable with an incomplete type: that is an error.
7714 Don't talk about array types here, since we took care of that
7715 message in grokdeclarator. */
7716 cp_error ("storage size of `%D' isn't known", decl
);
7717 TREE_TYPE (decl
) = error_mark_node
;
7720 /* Keep this code around in case we later want to control debug info
7721 based on whether a type is "used". (jason 1999-11-11) */
7723 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7724 /* Let debugger know it should output info for this type. */
7725 note_debug_info_needed (ttype
);
7727 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7728 note_debug_info_needed (DECL_CONTEXT (decl
));
7731 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7732 && DECL_SIZE (decl
) != NULL_TREE
7733 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7735 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7736 constant_expression_warning (DECL_SIZE (decl
));
7738 cp_error ("storage size of `%D' isn't constant", decl
);
7742 /* If a local static variable is declared in an inline function, or if
7743 we have a weak definition, we must endeavor to create only one
7744 instance of the variable at link-time. */
7747 maybe_commonize_var (decl
)
7750 /* Static data in a function with comdat linkage also has comdat
7752 if (TREE_STATIC (decl
)
7753 /* Don't mess with __FUNCTION__. */
7754 && ! DECL_ARTIFICIAL (decl
)
7755 && current_function_decl
7756 && DECL_CONTEXT (decl
) == current_function_decl
7757 && (DECL_THIS_INLINE (current_function_decl
)
7758 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7759 && TREE_PUBLIC (current_function_decl
))
7761 /* Rather than try to get this right with inlining, we suppress
7762 inlining of such functions. */
7763 current_function_cannot_inline
7764 = "function with static variable cannot be inline";
7766 /* If flag_weak, we don't need to mess with this, as we can just
7767 make the function weak, and let it refer to its unique local
7768 copy. This works because we don't allow the function to be
7772 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7774 TREE_PUBLIC (decl
) = 1;
7775 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7777 else if (DECL_INITIAL (decl
) == NULL_TREE
7778 || DECL_INITIAL (decl
) == error_mark_node
)
7780 TREE_PUBLIC (decl
) = 1;
7781 DECL_COMMON (decl
) = 1;
7783 /* else we lose. We can only do this if we can use common,
7784 which we can't if it has been initialized. */
7786 if (TREE_PUBLIC (decl
))
7787 DECL_ASSEMBLER_NAME (decl
)
7788 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7791 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7792 cp_warning_at (" you can work around this by removing the initializer", decl
);
7796 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
7797 /* Set it up again; we might have set DECL_INITIAL since the last
7799 comdat_linkage (decl
);
7802 /* Issue an error message if DECL is an uninitialized const variable. */
7805 check_for_uninitialized_const_var (decl
)
7808 tree type
= TREE_TYPE (decl
);
7810 /* ``Unless explicitly declared extern, a const object does not have
7811 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7813 if (TREE_CODE (decl
) == VAR_DECL
7814 && TREE_CODE (type
) != REFERENCE_TYPE
7815 && CP_TYPE_CONST_P (type
)
7816 && !TYPE_NEEDS_CONSTRUCTING (type
)
7817 && !DECL_INITIAL (decl
))
7818 cp_error ("uninitialized const `%D'", decl
);
7821 /* Verify INIT (the initializer for DECL), and record the
7822 initialization in DECL_INITIAL, if appropriate. Returns a new
7826 check_initializer (decl
, init
)
7832 if (TREE_CODE (decl
) == FIELD_DECL
)
7835 type
= TREE_TYPE (decl
);
7837 /* If `start_decl' didn't like having an initialization, ignore it now. */
7838 if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7841 /* Check the initializer. */
7844 /* Things that are going to be initialized need to have complete
7846 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
7848 if (type
== error_mark_node
)
7849 /* We will have already complained. */
7851 else if (COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
7853 cp_error ("variable-sized object `%D' may not be initialized", decl
);
7856 else if (TREE_CODE (type
) == ARRAY_TYPE
7857 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
7859 cp_error ("elements of array `%#D' have incomplete type", decl
);
7862 else if (!COMPLETE_TYPE_P (type
))
7864 cp_error ("`%D' has incomplete type", decl
);
7865 TREE_TYPE (decl
) = error_mark_node
;
7870 if (TREE_CODE (decl
) == CONST_DECL
)
7872 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7874 DECL_INITIAL (decl
) = init
;
7876 /* This will keep us from needing to worry about our obstacks. */
7877 my_friendly_assert (init
!= NULL_TREE
, 149);
7880 else if (!DECL_EXTERNAL (decl
) && TREE_CODE (type
) == REFERENCE_TYPE
)
7882 if (TREE_STATIC (decl
))
7883 make_decl_rtl (decl
, NULL_PTR
, toplevel_bindings_p ());
7884 grok_reference_init (decl
, type
, init
);
7889 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7891 if (TREE_CODE (type
) == ARRAY_TYPE
)
7892 init
= digest_init (type
, init
, (tree
*) 0);
7893 else if (TREE_CODE (init
) == CONSTRUCTOR
7894 && TREE_HAS_CONSTRUCTOR (init
))
7896 if (TYPE_NON_AGGREGATE_CLASS (type
))
7898 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7900 init
= error_mark_node
;
7903 goto dont_use_constructor
;
7908 dont_use_constructor
:
7909 if (TREE_CODE (init
) != TREE_VEC
)
7910 init
= store_init_value (decl
, init
);
7914 /* We must hide the initializer so that expand_decl
7915 won't try to do something it does not understand. */
7916 init
= obscure_complex_init (decl
, init
);
7918 else if (DECL_EXTERNAL (decl
))
7920 else if (TYPE_P (type
)
7921 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7923 tree core_type
= strip_array_types (type
);
7925 if (! TYPE_NEEDS_CONSTRUCTING (core_type
))
7927 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
7928 cp_error ("structure `%D' with uninitialized const members", decl
);
7929 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
7930 cp_error ("structure `%D' with uninitialized reference members",
7934 check_for_uninitialized_const_var (decl
);
7936 if (COMPLETE_TYPE_P (type
) && TYPE_NEEDS_CONSTRUCTING (type
))
7937 init
= obscure_complex_init (decl
, NULL_TREE
);
7941 check_for_uninitialized_const_var (decl
);
7946 /* If DECL is not a local variable, give it RTL. */
7949 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
)
7952 const char *asmspec
;
7954 int toplev
= toplevel_bindings_p ();
7957 /* Handle non-variables up front. */
7958 if (TREE_CODE (decl
) != VAR_DECL
)
7960 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7964 /* If we see a class member here, it should be a static data
7966 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
7968 my_friendly_assert (TREE_STATIC (decl
), 19990828);
7969 /* An in-class declaration of a static data member should be
7970 external; it is only a declaration, and not a definition. */
7971 if (init
== NULL_TREE
)
7972 my_friendly_assert (DECL_EXTERNAL (decl
), 20000723);
7975 /* Set the DECL_ASSEMBLER_NAME for the variable. */
7977 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7979 /* We don't create any RTL for local variables. */
7980 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
7983 /* We defer emission of local statics until the corresponding
7984 DECL_STMT is expanded. */
7985 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
7987 /* We try to defer namespace-scope static constants so that they are
7988 not emitted into the object file unncessarily. */
7989 if (!DECL_VIRTUAL_P (decl
)
7990 && TREE_READONLY (decl
)
7991 && DECL_INITIAL (decl
) != NULL_TREE
7992 && DECL_INITIAL (decl
) != error_mark_node
7993 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
7995 && !TREE_PUBLIC (decl
))
7997 /* Fool with the linkage according to #pragma interface. */
7998 if (!interface_unknown
)
8000 TREE_PUBLIC (decl
) = 1;
8001 DECL_EXTERNAL (decl
) = interface_only
;
8007 /* If we're deferring the variable, just make RTL. Do not actually
8008 emit the variable. */
8010 make_decl_rtl (decl
, asmspec
, toplev
);
8011 /* If we're not deferring, go ahead and assemble the variable. */
8013 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
8016 /* The old ARM scoping rules injected variables declared in the
8017 initialization statement of a for-statement into the surrounding
8018 scope. We support this usage, in order to be backward-compatible.
8019 DECL is a just-declared VAR_DECL; if necessary inject its
8020 declaration into the surrounding scope. */
8023 maybe_inject_for_scope_var (decl
)
8026 if (!DECL_NAME (decl
))
8029 if (current_binding_level
->is_for_scope
)
8031 struct binding_level
*outer
8032 = current_binding_level
->level_chain
;
8034 /* Check to see if the same name is already bound at the outer
8035 level, either because it was directly declared, or because a
8036 dead for-decl got preserved. In either case, the code would
8037 not have been valid under the ARM scope rules, so clear
8038 is_for_scope for the current_binding_level.
8040 Otherwise, we need to preserve the temp slot for decl to last
8041 into the outer binding level. */
8044 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl
)));
8046 if (outer_binding
&& BINDING_LEVEL (outer_binding
) == outer
8047 && (TREE_CODE (BINDING_VALUE (outer_binding
))
8049 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding
)))
8051 BINDING_VALUE (outer_binding
)
8052 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding
));
8053 current_binding_level
->is_for_scope
= 0;
8055 else if (DECL_IN_MEMORY_P (decl
))
8056 preserve_temp_slots (DECL_RTL (decl
));
8060 /* Generate code to initialize DECL (a local variable). */
8063 initialize_local_var (decl
, init
, flags
)
8068 tree type
= TREE_TYPE (decl
);
8070 /* If the type is bogus, don't bother initializing the variable. */
8071 if (type
== error_mark_node
)
8074 if (DECL_SIZE (decl
) == NULL_TREE
&& !TREE_STATIC (decl
))
8076 /* If we used it already as memory, it must stay in memory. */
8077 DECL_INITIAL (decl
) = NULL_TREE
;
8078 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
8081 /* Local statics are handled differently from ordinary automatic
8083 if (TREE_STATIC (decl
))
8085 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
8086 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
8087 expand_static_init (decl
, init
);
8091 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
8095 /* Compute and store the initial value. */
8096 already_used
= TREE_USED (decl
) || TREE_USED (type
);
8098 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
8100 int saved_stmts_are_full_exprs_p
;
8102 my_friendly_assert (building_stmt_tree (), 20000906);
8103 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
8104 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
8105 finish_expr_stmt (build_aggr_init (decl
, init
, flags
));
8106 current_stmt_tree ()->stmts_are_full_exprs_p
=
8107 saved_stmts_are_full_exprs_p
;
8110 /* Set this to 0 so we can tell whether an aggregate which was
8111 initialized was ever used. Don't do this if it has a
8112 destructor, so we don't complain about the 'resource
8113 allocation is initialization' idiom. Now set
8114 attribute((unused)) on types so decls of that type will be
8115 marked used. (see TREE_USED, above.) */
8116 if (TYPE_NEEDS_CONSTRUCTING (type
)
8118 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
8119 && DECL_NAME (decl
))
8120 TREE_USED (decl
) = 0;
8121 else if (already_used
)
8122 TREE_USED (decl
) = 1;
8126 /* Generate code to destroy DECL (a local variable). */
8129 destroy_local_var (decl
)
8132 tree type
= TREE_TYPE (decl
);
8135 /* Only variables get cleaned up. */
8136 if (TREE_CODE (decl
) != VAR_DECL
)
8139 /* And only things with destructors need cleaning up. */
8140 if (type
== error_mark_node
8141 || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
8144 if (TREE_CODE (decl
) == VAR_DECL
&&
8145 (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
)))
8146 /* We don't clean up things that aren't defined in this
8147 translation unit, or that need a static cleanup. The latter
8148 are handled by finish_file. */
8151 /* Compute the cleanup. */
8152 cleanup
= maybe_build_cleanup (decl
);
8154 /* Record the cleanup required for this declaration. */
8155 if (DECL_SIZE (decl
) && TREE_TYPE (decl
) != error_mark_node
8157 finish_decl_cleanup (decl
, cleanup
);
8160 /* Finish processing of a declaration;
8161 install its line number and initial value.
8162 If the length of an array type is not known before,
8163 it must be determined now, from the initial value, or it is an error.
8165 INIT holds the value of an initializer that should be allowed to escape
8168 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8169 if the (init) syntax was used. */
8172 cp_finish_decl (decl
, init
, asmspec_tree
, flags
)
8178 tree ttype
= NULL_TREE
;
8179 const char *asmspec
= NULL
;
8180 int was_readonly
= 0;
8185 error ("assignment (not initialization) in declaration");
8189 /* If a name was specified, get the string. */
8191 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
8193 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
8195 cp_error ("cannot initialize `%D' to namespace `%D'",
8200 if (current_class_type
8201 && CP_DECL_CONTEXT (decl
) == current_class_type
8202 && TYPE_BEING_DEFINED (current_class_type
)
8203 && (DECL_INITIAL (decl
) || init
))
8204 DECL_DEFINED_IN_CLASS_P (decl
) = 1;
8206 if (TREE_CODE (decl
) == VAR_DECL
8207 && DECL_CONTEXT (decl
)
8208 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
8209 && DECL_CONTEXT (decl
) != current_namespace
8212 /* Leave the namespace of the object. */
8213 pop_decl_namespace ();
8216 type
= TREE_TYPE (decl
);
8218 if (type
== error_mark_node
)
8221 /* Add this declaration to the statement-tree. */
8222 if (building_stmt_tree ()
8223 && at_function_scope_p ()
8224 && TREE_CODE (decl
) != RESULT_DECL
)
8225 add_decl_stmt (decl
);
8227 if (TYPE_HAS_MUTABLE_P (type
))
8228 TREE_READONLY (decl
) = 0;
8230 if (processing_template_decl
)
8232 if (init
&& DECL_INITIAL (decl
))
8233 DECL_INITIAL (decl
) = init
;
8237 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8238 my_friendly_assert (TREE_CODE (decl
) != PARM_DECL
, 19990828);
8240 /* Take care of TYPE_DECLs up front. */
8241 if (TREE_CODE (decl
) == TYPE_DECL
)
8243 if (init
&& DECL_INITIAL (decl
))
8245 /* typedef foo = bar; store the type of bar as the type of foo. */
8246 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
8247 DECL_INITIAL (decl
) = init
= NULL_TREE
;
8249 if (type
!= error_mark_node
8250 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
8252 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
8253 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
8254 set_identifier_type_value (DECL_NAME (decl
), type
);
8255 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
8257 GNU_xref_decl (current_function_decl
, decl
);
8259 /* If we have installed this as the canonical typedef for this
8260 type, and that type has not been defined yet, delay emitting
8261 the debug information for it, as we will emit it later. */
8262 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
8263 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
8264 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
8266 rest_of_decl_compilation (decl
, NULL_PTR
,
8267 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
8271 if (TREE_CODE (decl
) != FUNCTION_DECL
)
8272 ttype
= target_type (type
);
8274 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
8275 && TYPE_NEEDS_CONSTRUCTING (type
))
8277 /* Currently, GNU C++ puts constants in text space, making them
8278 impossible to initialize. In the future, one would hope for
8279 an operating system which understood the difference between
8280 initialization and the running of a program. */
8282 TREE_READONLY (decl
) = 0;
8285 if (TREE_CODE (decl
) == FIELD_DECL
&& asmspec
)
8287 /* This must override the asm specifier which was placed by
8288 grokclassfn. Lay this out fresh. */
8289 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
8290 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
8291 make_decl_rtl (decl
, asmspec
, 0);
8294 /* Deduce size of array from initialization, if not already known. */
8295 maybe_deduce_size_from_array_init (decl
, init
);
8296 init
= check_initializer (decl
, init
);
8298 GNU_xref_decl (current_function_decl
, decl
);
8300 if (TREE_CODE (decl
) == VAR_DECL
)
8301 layout_var_decl (decl
);
8303 /* Output the assembler code and/or RTL code for variables and functions,
8304 unless the type is an undefined structure or union.
8305 If not, it will get done when the type is completed. */
8306 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
8307 || TREE_CODE (decl
) == RESULT_DECL
)
8309 if (TREE_CODE (decl
) == VAR_DECL
)
8310 maybe_commonize_var (decl
);
8312 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
8314 if (TREE_CODE (type
) == FUNCTION_TYPE
8315 || TREE_CODE (type
) == METHOD_TYPE
)
8316 abstract_virtuals_error (decl
,
8317 strip_array_types (TREE_TYPE (type
)));
8319 abstract_virtuals_error (decl
, strip_array_types (type
));
8321 if (TREE_CODE (decl
) == FUNCTION_DECL
)
8323 else if (DECL_EXTERNAL (decl
)
8324 && ! (DECL_LANG_SPECIFIC (decl
)
8325 && DECL_NOT_REALLY_EXTERN (decl
)))
8328 DECL_INITIAL (decl
) = init
;
8330 else if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
8332 /* This is a local declaration. */
8333 if (doing_semantic_analysis_p ())
8334 maybe_inject_for_scope_var (decl
);
8335 /* Initialize the local variable. But, if we're building a
8336 statement-tree, we'll do the initialization when we
8338 if (processing_template_decl
)
8340 if (init
|| DECL_INITIAL (decl
) == error_mark_node
)
8341 DECL_INITIAL (decl
) = init
;
8345 /* If we're not building RTL, then we need to do so
8347 my_friendly_assert (building_stmt_tree (), 20000906);
8348 /* Initialize the variable. */
8349 initialize_local_var (decl
, init
, flags
);
8350 /* Clean up the variable. */
8351 destroy_local_var (decl
);
8354 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
8356 /* Cleanups for static variables are handled by `finish_file'. */
8357 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
8358 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
8359 expand_static_init (decl
, init
);
8363 /* Undo call to `pushclass' that was done in `start_decl'
8364 due to initialization of qualified member variable.
8365 I.e., Foo::x = 10; */
8367 tree context
= CP_DECL_CONTEXT (decl
);
8370 && (TREE_CODE (decl
) == VAR_DECL
8371 /* We also have a pushclass done that we need to undo here
8372 if we're at top level and declare a method. */
8373 || TREE_CODE (decl
) == FUNCTION_DECL
)
8374 /* If size hasn't been set, we're still defining it,
8375 and therefore inside the class body; don't pop
8376 the binding level.. */
8377 && COMPLETE_TYPE_P (context
)
8378 && context
== current_class_type
)
8379 pop_nested_class ();
8386 TREE_READONLY (decl
) = 1;
8389 /* This is here for a midend callback from c-common.c */
8392 finish_decl (decl
, init
, asmspec_tree
)
8396 cp_finish_decl (decl
, init
, asmspec_tree
, 0);
8399 /* Returns a declaration for a VAR_DECL as if:
8401 extern "C" TYPE NAME;
8403 had been seen. Used to create compiler-generated global
8407 declare_global_var (name
, type
)
8413 push_to_top_level ();
8414 decl
= build_decl (VAR_DECL
, name
, type
);
8415 TREE_PUBLIC (decl
) = 1;
8416 DECL_EXTERNAL (decl
) = 1;
8417 DECL_ARTIFICIAL (decl
) = 1;
8419 cp_finish_decl (decl
, NULL_TREE
, NULL_TREE
, 0);
8420 pop_from_top_level ();
8425 /* Returns a pointer to the `atexit' function. Note that if
8426 FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8427 `__cxa_atexit' function specified in the IA64 C++ ABI. */
8441 if (flag_use_cxa_atexit
)
8443 /* The declaration for `__cxa_atexit' is:
8445 int __cxa_atexit (void (*)(void *), void *, void *)
8447 We build up the argument types and then then function type
8450 /* First, build the pointer-to-function type for the first
8452 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
8453 fn_type
= build_function_type (void_type_node
, arg_types
);
8454 fn_ptr_type
= build_pointer_type (fn_type
);
8455 /* Then, build the rest of the argument types. */
8456 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
8457 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
8458 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
8459 /* And the final __cxa_atexit type. */
8460 fn_type
= build_function_type (integer_type_node
, arg_types
);
8461 fn_ptr_type
= build_pointer_type (fn_type
);
8462 name
= "__cxa_atexit";
8466 /* The declaration for `atexit' is:
8468 int atexit (void (*)());
8470 We build up the argument types and then then function type
8472 fn_type
= build_function_type (void_type_node
, void_list_node
);
8473 fn_ptr_type
= build_pointer_type (fn_type
);
8474 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, void_list_node
);
8475 /* Build the final atexit type. */
8476 fn_type
= build_function_type (integer_type_node
, arg_types
);
8480 /* Now, build the function declaration. */
8481 push_lang_context (lang_name_c
);
8482 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
8483 mark_used (atexit_fndecl
);
8484 pop_lang_context ();
8485 atexit_node
= default_conversion (atexit_fndecl
);
8490 /* Returns the __dso_handle VAR_DECL. */
8493 get_dso_handle_node ()
8495 if (dso_handle_node
)
8496 return dso_handle_node
;
8498 /* Declare the variable. */
8499 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
8502 return dso_handle_node
;
8505 /* Begin a new function with internal linkage whose job will be simply
8506 to destroy some particular variable. */
8511 static int counter
= 0;
8512 int old_interface_unknown
= interface_unknown
;
8518 push_to_top_level ();
8520 /* No need to mangle this. */
8521 push_lang_context (lang_name_c
);
8523 interface_unknown
= 1;
8525 /* Build the parameter-types. */
8526 parmtypes
= void_list_node
;
8527 /* Functions passed to __cxa_atexit take an additional parameter.
8528 We'll just ignore it. After we implement the new calling
8529 convention for destructors, we can eliminate the use of
8530 additional cleanup functions entirely in the -fnew-abi case. */
8531 if (flag_use_cxa_atexit
)
8532 parmtypes
= tree_cons (NULL_TREE
, ptr_type_node
, parmtypes
);
8533 /* Build the function type itself. */
8534 fntype
= build_function_type (void_type_node
, parmtypes
);
8535 /* Build the name of the function. */
8536 sprintf (name
, "__tcf_%d", counter
++);
8537 /* Build the function declaration. */
8538 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
8539 /* It's a function with internal linkage, generated by the
8541 TREE_PUBLIC (fndecl
) = 0;
8542 DECL_ARTIFICIAL (fndecl
) = 1;
8543 /* Make the function `inline' so that it is only emitted if it is
8544 actually needed. It is unlikely that it will be inlined, since
8545 it is only called via a function pointer, but we avoid unncessary
8546 emissions this way. */
8547 DECL_INLINE (fndecl
) = 1;
8548 /* Build the parameter. */
8549 if (flag_use_cxa_atexit
)
8553 parmdecl
= build_decl (PARM_DECL
, NULL_TREE
, ptr_type_node
);
8554 DECL_CONTEXT (parmdecl
) = fndecl
;
8555 DECL_ARG_TYPE (parmdecl
) = ptr_type_node
;
8556 TREE_USED (parmdecl
) = 1;
8557 DECL_ARGUMENTS (fndecl
) = parmdecl
;
8561 start_function (/*specs=*/NULL_TREE
, fndecl
, NULL_TREE
, SF_PRE_PARSED
);
8564 interface_unknown
= old_interface_unknown
;
8566 pop_lang_context ();
8568 return current_function_decl
;
8571 /* Finish the cleanup function begun by start_cleanup_fn. */
8578 expand_body (finish_function (0));
8580 pop_from_top_level ();
8583 /* Generate code to handle the destruction of DECL, an object with
8584 static storage duration. */
8587 register_dtor_fn (decl
)
8595 int saved_flag_access_control
;
8597 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
8600 /* Call build_cleanup before we enter the anonymous function so that
8601 any access checks will be done relative to the current scope,
8602 rather than the scope of the anonymous function. */
8603 build_cleanup (decl
);
8605 /* Now start the function. */
8606 cleanup
= start_cleanup_fn ();
8608 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8609 to the original function, rather than the anonymous one. That
8610 will make the back-end think that nested functions are in use,
8611 which causes confusion. */
8612 saved_flag_access_control
= flag_access_control
;
8613 flag_access_control
= 0;
8614 fcall
= build_cleanup (decl
);
8615 flag_access_control
= saved_flag_access_control
;
8617 /* Create the body of the anonymous function. */
8618 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
8619 finish_expr_stmt (fcall
);
8620 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
8623 /* Call atexit with the cleanup function. */
8624 mark_addressable (cleanup
);
8625 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
8626 if (flag_use_cxa_atexit
)
8628 args
= tree_cons (NULL_TREE
, get_dso_handle_node (), NULL_TREE
);
8629 args
= tree_cons (NULL_TREE
, null_pointer_node
, args
);
8630 args
= tree_cons (NULL_TREE
, cleanup
, args
);
8633 args
= tree_cons (NULL_TREE
, cleanup
, NULL_TREE
);
8634 finish_expr_stmt (build_function_call (get_atexit_node (), args
));
8638 expand_static_init (decl
, init
)
8642 tree oldstatic
= value_member (decl
, static_aggregates
);
8646 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
8647 cp_error ("multiple initializations given for `%D'", decl
);
8649 else if (! toplevel_bindings_p ())
8651 /* Emit code to perform this initialization but once. */
8658 /* Emit code to perform this initialization but once. This code
8661 static int guard = 0;
8663 // Do initialization.
8665 // Register variable for destruction at end of program.
8668 Note that the `temp' variable is only set to 1 *after* the
8669 initialization is complete. This ensures that an exception,
8670 thrown during the construction, will cause the variable to
8671 reinitialized when we pass through this code again, as per:
8675 If the initialization exits by throwing an exception, the
8676 initialization is not complete, so it will be tried again
8677 the next time control enters the declaration.
8679 In theory, this process should be thread-safe, too; multiple
8680 threads should not be able to initialize the variable more
8681 than once. We don't yet attempt to ensure thread-safety. */
8683 /* Create the guard variable. */
8684 guard
= get_guard (decl
);
8686 /* Begin the conditional initialization. */
8687 if_stmt
= begin_if_stmt ();
8688 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
8689 then_clause
= begin_compound_stmt (/*has_no_scope=*/0);
8691 /* Do the initialization itself. */
8692 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
8693 || (init
&& TREE_CODE (init
) == TREE_LIST
))
8694 assignment
= build_aggr_init (decl
, init
, 0);
8696 /* The initialization we're doing here is just a bitwise
8698 assignment
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, init
);
8700 assignment
= NULL_TREE
;
8702 /* Once the assignment is complete, set TEMP to 1. Since the
8703 construction of the static object is complete at this point,
8704 we want to make sure TEMP is set to 1 even if a temporary
8705 constructed during the initialization throws an exception
8706 when it is destroyed. So, we combine the initialization and
8707 the assignment to TEMP into a single expression, ensuring
8708 that when we call finish_expr_stmt the cleanups will not be
8709 run until after TEMP is set to 1. */
8710 guard_init
= set_guard (guard
);
8713 assignment
= tree_cons (NULL_TREE
, assignment
,
8714 build_tree_list (NULL_TREE
,
8716 assignment
= build_compound_expr (assignment
);
8719 assignment
= guard_init
;
8720 finish_expr_stmt (assignment
);
8722 /* Use atexit to register a function for destroying this static
8724 register_dtor_fn (decl
);
8726 finish_compound_stmt (/*has_no_scope=*/0, then_clause
);
8727 finish_then_clause (if_stmt
);
8731 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
8734 /* Finish the declaration of a catch-parameter. */
8737 start_handler_parms (declspecs
, declarator
)
8744 decl
= grokdeclarator (declarator
, declspecs
, CATCHPARM
,
8746 if (decl
== NULL_TREE
)
8747 error ("invalid catch parameter");
8756 /* Make TYPE a complete type based on INITIAL_VALUE.
8757 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8758 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8761 complete_array_type (type
, initial_value
, do_default
)
8762 tree type
, initial_value
;
8765 register tree maxindex
= NULL_TREE
;
8770 /* An array of character type can be initialized from a
8771 brace-enclosed string constant. */
8772 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
)))
8773 && TREE_CODE (initial_value
) == CONSTRUCTOR
8774 && CONSTRUCTOR_ELTS (initial_value
)
8775 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
)))
8777 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value
)) == NULL_TREE
)
8778 initial_value
= TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
));
8780 /* Note MAXINDEX is really the maximum index, one less than the
8782 if (TREE_CODE (initial_value
) == STRING_CST
)
8785 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8786 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
8789 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8791 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
8793 maxindex
= ssize_int (-1);
8794 for (; elts
; elts
= TREE_CHAIN (elts
))
8796 if (TREE_PURPOSE (elts
))
8797 maxindex
= TREE_PURPOSE (elts
);
8799 maxindex
= size_binop (PLUS_EXPR
, maxindex
, ssize_int (1));
8801 maxindex
= copy_node (maxindex
);
8805 /* Make an error message unless that happened already. */
8806 if (initial_value
!= error_mark_node
)
8809 initial_value
= NULL_TREE
;
8811 /* Prevent further error messages. */
8812 maxindex
= build_int_2 (0, 0);
8819 maxindex
= build_int_2 (0, 0);
8828 domain
= build_index_type (maxindex
);
8829 TYPE_DOMAIN (type
) = domain
;
8831 if (! TREE_TYPE (maxindex
))
8832 TREE_TYPE (maxindex
) = domain
;
8834 itype
= TREE_TYPE (initial_value
);
8837 if (itype
&& !TYPE_DOMAIN (itype
))
8838 TYPE_DOMAIN (itype
) = domain
;
8839 /* The type of the main variant should never be used for arrays
8840 of different sizes. It should only ever be completed with the
8841 size of the array. */
8842 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
8843 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = domain
;
8846 /* Lay out the type now that we can get the real answer. */
8853 /* Return zero if something is declared to be a member of type
8854 CTYPE when in the context of CUR_TYPE. STRING is the error
8855 message to print in that case. Otherwise, quietly return 1. */
8858 member_function_or_else (ctype
, cur_type
, flags
)
8859 tree ctype
, cur_type
;
8860 enum overload_flags flags
;
8862 if (ctype
&& ctype
!= cur_type
)
8864 if (flags
== DTOR_FLAG
)
8865 cp_error ("destructor for alien class `%T' cannot be a member",
8868 cp_error ("constructor for alien class `%T' cannot be a member",
8875 /* Subroutine of `grokdeclarator'. */
8877 /* Generate errors possibly applicable for a given set of specifiers.
8878 This is for ARM $7.1.2. */
8881 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
8884 int virtualp
, quals
, friendp
, raises
, inlinep
;
8887 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
8889 cp_error ("`%D' declared as an `inline' %s", object
, type
);
8891 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8894 cp_error_at ("`%D' declared as a friend", object
);
8896 cp_error_at ("`%D' declared with an exception specification", object
);
8899 /* CTYPE is class type, or null if non-class.
8900 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8902 DECLARATOR is the function's name.
8903 VIRTUALP is truthvalue of whether the function is virtual or not.
8904 FLAGS are to be passed through to `grokclassfn'.
8905 QUALS are qualifiers indicating whether the function is `const'
8907 RAISES is a list of exceptions that this function can raise.
8908 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8909 not look, and -1 if we should not call `grokclassfn' at all.
8911 Returns `NULL_TREE' if something goes wrong, after issuing
8912 applicable error messages. */
8915 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8916 raises
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8917 template_count
, in_namespace
)
8920 tree orig_declarator
;
8922 enum overload_flags flags
;
8924 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8928 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8929 int has_default_arg
= 0;
8933 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8934 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8940 type
= build_exception_variant (type
, raises
);
8943 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8944 /* Propagate volatile out from type to decl. */
8945 if (TYPE_VOLATILE (type
))
8946 TREE_THIS_VOLATILE (decl
) = 1;
8948 /* If this decl has namespace scope, set that up. */
8950 set_decl_namespace (decl
, in_namespace
, friendp
);
8952 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8954 /* `main' and builtins have implicit 'C' linkage. */
8955 if ((MAIN_NAME_P (declarator
)
8956 || (IDENTIFIER_LENGTH (declarator
) > 10
8957 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8958 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8959 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8960 && current_lang_name
== lang_name_cplusplus
8961 && ctype
== NULL_TREE
8962 /* NULL_TREE means global namespace. */
8963 && DECL_CONTEXT (decl
) == NULL_TREE
)
8964 DECL_LANGUAGE (decl
) = lang_c
;
8966 /* Should probably propagate const out from type to decl I bet (mrs). */
8969 DECL_STATIC_FUNCTION_P (decl
) = 1;
8970 DECL_CONTEXT (decl
) = ctype
;
8974 DECL_CONTEXT (decl
) = ctype
;
8976 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8978 if (processing_template_decl
)
8979 error ("cannot declare `::main' to be a template");
8981 error ("cannot declare `::main' to be inline");
8983 error ("cannot declare `::main' to be static");
8984 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
8986 error ("`main' must return `int'");
8991 /* Members of anonymous types and local classes have no linkage; make
8993 if (ctype
&& (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
))
8994 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
8999 /* [basic.link]: A name with no linkage (notably, the name of a class
9000 or enumeration declared in a local scope) shall not be used to
9001 declare an entity with linkage.
9003 Only check this for public decls for now. */
9004 t
= no_linkage_check (TREE_TYPE (decl
));
9007 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
9009 if (DECL_EXTERN_C_P (decl
))
9010 /* Allow this; it's pretty common in C. */;
9012 cp_pedwarn ("non-local function `%#D' uses anonymous type",
9016 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
9021 TREE_PUBLIC (decl
) = publicp
;
9024 DECL_INTERFACE_KNOWN (decl
) = 1;
9025 DECL_NOT_REALLY_EXTERN (decl
) = 1;
9029 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
9031 DECL_EXTERNAL (decl
) = 1;
9032 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
9034 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
9035 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
9039 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
9040 grok_op_properties (decl
, virtualp
, check
< 0);
9042 if (ctype
&& decl_function_context (decl
))
9043 DECL_NO_STATIC_CHAIN (decl
) = 1;
9045 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
9046 if (TREE_PURPOSE (t
)
9047 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
9049 has_default_arg
= 1;
9054 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
9058 ("defining explicit specialization `%D' in friend declaration",
9062 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9064 /* Something like `template <class T> friend void f<T>()'. */
9065 cp_error ("invalid use of template-id `%D' in declaration of primary template",
9071 /* A friend declaration of the form friend void f<>(). Record
9072 the information in the TEMPLATE_ID_EXPR. */
9073 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
9074 DECL_TEMPLATE_INFO (decl
)
9075 = tree_cons (TREE_OPERAND (orig_declarator
, 0),
9076 TREE_OPERAND (orig_declarator
, 1),
9079 if (has_default_arg
)
9081 cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9088 cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9095 if (has_default_arg
)
9096 add_defarg_fn (decl
);
9098 /* Plain overloading: will not be grok'd by grokclassfn. */
9099 if (! ctype
&& ! processing_template_decl
9100 && !DECL_EXTERN_C_P (decl
)
9101 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
9102 set_mangled_name_for_decl (decl
);
9105 /* Make the init_value nonzero so pushdecl knows this is not
9106 tentative. error_mark_node is replaced later with the BLOCK. */
9107 DECL_INITIAL (decl
) = error_mark_node
;
9109 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
9110 TREE_NOTHROW (decl
) = 1;
9112 /* Caller will do the rest of this. */
9116 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
9117 DECL_CONSTRUCTOR_P (decl
) = 1;
9119 /* Function gets the ugly name, field gets the nice one. This call
9120 may change the type of the function (because of default
9122 if (ctype
!= NULL_TREE
)
9123 grokclassfn (ctype
, decl
, flags
, quals
);
9125 decl
= check_explicit_specialization (orig_declarator
, decl
,
9127 2 * (funcdef_flag
!= 0) +
9128 4 * (friendp
!= 0));
9129 if (decl
== error_mark_node
)
9132 if (ctype
!= NULL_TREE
9133 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
9138 old_decl
= check_classfn (ctype
, decl
);
9140 if (old_decl
&& TREE_CODE (old_decl
) == TEMPLATE_DECL
)
9141 /* Because grokfndecl is always supposed to return a
9142 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9143 here. We depend on our callers to figure out that its
9144 really a template that's being returned. */
9145 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
9147 if (old_decl
&& DECL_STATIC_FUNCTION_P (old_decl
)
9148 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
9150 /* Remove the `this' parm added by grokclassfn.
9151 XXX Isn't this done in start_function, too? */
9152 revert_static_member_fn (decl
);
9153 last_function_parms
= TREE_CHAIN (last_function_parms
);
9155 if (old_decl
&& DECL_ARTIFICIAL (old_decl
))
9156 cp_error ("definition of implicitly-declared `%D'", old_decl
);
9160 /* Since we've smashed OLD_DECL to its
9161 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
9162 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9163 decl
= DECL_TEMPLATE_RESULT (decl
);
9165 /* Attempt to merge the declarations. This can fail, in
9166 the case of some illegal specialization declarations. */
9167 if (!duplicate_decls (decl
, old_decl
))
9168 cp_error ("no `%#D' member function declared in class `%T'",
9174 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
9177 if (ctype
== NULL_TREE
|| check
)
9182 DECL_VIRTUAL_P (decl
) = 1;
9183 if (DECL_VINDEX (decl
) == NULL_TREE
)
9184 DECL_VINDEX (decl
) = error_mark_node
;
9185 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
9192 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
9195 RID_BIT_TYPE
*specbits_in
;
9201 RID_BIT_TYPE specbits
;
9203 specbits
= *specbits_in
;
9205 if (TREE_CODE (type
) == OFFSET_TYPE
)
9207 /* If you declare a static member so that it
9208 can be initialized, the code will reach here. */
9209 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
9210 type
= TREE_TYPE (type
);
9211 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
9212 DECL_CONTEXT (decl
) = basetype
;
9213 /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9215 if (!uses_template_parms (decl
))
9218 DECL_ASSEMBLER_NAME (decl
) = mangle_decl (decl
);
9220 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
,
9229 context
= in_namespace
;
9230 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
9231 context
= current_namespace
;
9233 context
= NULL_TREE
;
9235 if (processing_template_decl
&& context
)
9236 /* For global variables, declared in a template, we need the
9238 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
9240 decl
= build_decl (VAR_DECL
, declarator
, type
);
9243 set_decl_namespace (decl
, context
, 0);
9245 context
= DECL_CONTEXT (decl
);
9246 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
9249 DECL_ASSEMBLER_NAME (decl
) = mangle_decl (decl
);
9251 DECL_ASSEMBLER_NAME (decl
)
9252 = build_static_name (context
, declarator
);
9257 set_decl_namespace (decl
, in_namespace
, 0);
9259 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
9261 DECL_THIS_EXTERN (decl
) = 1;
9262 DECL_EXTERNAL (decl
) = !initialized
;
9265 /* In class context, static means one per class,
9266 public access, and static storage. */
9267 if (DECL_CLASS_SCOPE_P (decl
))
9269 TREE_PUBLIC (decl
) = 1;
9270 TREE_STATIC (decl
) = 1;
9271 DECL_EXTERNAL (decl
) = 0;
9273 /* At top level, either `static' or no s.c. makes a definition
9274 (perhaps tentative), and absence of `static' makes it public. */
9275 else if (toplevel_bindings_p ())
9277 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
9278 && (DECL_THIS_EXTERN (decl
) || ! constp
));
9279 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
9281 /* Not at top level, only `static' makes a static definition. */
9284 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
9285 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
9288 if (TREE_PUBLIC (decl
))
9290 /* [basic.link]: A name with no linkage (notably, the name of a class
9291 or enumeration declared in a local scope) shall not be used to
9292 declare an entity with linkage.
9294 Only check this for public decls for now. */
9295 tree t
= no_linkage_check (TREE_TYPE (decl
));
9298 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
9299 /* Ignore for now; `enum { foo } e' is pretty common. */;
9301 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9309 /* Create and return a canonical pointer to member function type, for
9310 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9313 build_ptrmemfunc_type (type
)
9319 tree unqualified_variant
= NULL_TREE
;
9321 /* If a canonical type already exists for this type, use it. We use
9322 this method instead of type_hash_canon, because it only does a
9323 simple equality check on the list of field members. */
9325 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
9328 /* Make sure that we always have the unqualified pointer-to-member
9330 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
9332 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
9334 t
= make_aggr_type (RECORD_TYPE
);
9335 /* Let the front-end know this is a pointer to member function... */
9336 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
9337 /* ... and not really an aggregate. */
9338 SET_IS_AGGR_TYPE (t
, 0);
9342 u
= make_aggr_type (UNION_TYPE
);
9343 SET_IS_AGGR_TYPE (u
, 0);
9344 fields
[0] = build_decl (FIELD_DECL
, pfn_identifier
, type
);
9345 fields
[1] = build_decl (FIELD_DECL
, delta2_identifier
,
9347 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
9348 TYPE_NAME (u
) = NULL_TREE
;
9350 fields
[0] = build_decl (FIELD_DECL
, delta_identifier
,
9352 fields
[1] = build_decl (FIELD_DECL
, index_identifier
,
9354 fields
[2] = build_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
9355 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
9359 fields
[0] = build_decl (FIELD_DECL
, pfn_identifier
, type
);
9360 fields
[1] = build_decl (FIELD_DECL
, delta_identifier
,
9362 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
9365 /* Zap out the name so that the back-end will give us the debugging
9366 information for this anonymous RECORD_TYPE. */
9367 TYPE_NAME (t
) = NULL_TREE
;
9369 /* If this is not the unqualified form of this pointer-to-member
9370 type, set the TYPE_MAIN_VARIANT for this type to be the
9371 unqualified type. Since they are actually RECORD_TYPEs that are
9372 not variants of each other, we must do this manually. */
9373 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
9375 t
= build_qualified_type (t
, CP_TYPE_QUALS (type
));
9376 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
9377 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
9378 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
9381 /* Cache this pointer-to-member type so that we can find it again
9383 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
9385 /* Seems to be wanted. */
9386 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
9391 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9392 Check to see that the definition is valid. Issue appropriate error
9393 messages. Return 1 if the definition is particularly bad, or 0
9397 check_static_variable_definition (decl
, type
)
9401 /* Motion 10 at San Diego: If a static const integral data member is
9402 initialized with an integral constant expression, the initializer
9403 may appear either in the declaration (within the class), or in
9404 the definition, but not both. If it appears in the class, the
9405 member is a member constant. The file-scope definition is always
9407 if (CLASS_TYPE_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
9409 cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9411 /* If we just return the declaration, crashes will sometimes
9412 occur. We therefore return void_type_node, as if this was a
9413 friend declaration, to cause callers to completely ignore
9414 this declaration. */
9417 else if (!CP_TYPE_CONST_P (type
))
9418 cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9420 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
9421 cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
9426 /* Given the SIZE (i.e., number of elements) in an array, compute an
9427 appropriate index type for the array. If non-NULL, NAME is the
9428 name of the thing being declared. */
9431 compute_array_index_type (name
, size
)
9437 /* The size might be the result of a cast. */
9438 STRIP_TYPE_NOPS (size
);
9440 /* It might be a const variable or enumeration constant. */
9441 size
= decl_constant_value (size
);
9443 /* If this involves a template parameter, it will be a constant at
9444 instantiation time, but we don't know what the value is yet.
9445 Even if no template parameters are involved, we may an expression
9446 that is not a constant; we don't even simplify `1 + 2' when
9447 processing a template. */
9448 if (processing_template_decl
)
9450 /* Resolve a qualified reference to an enumerator or static
9451 const data member of ours. */
9452 if (TREE_CODE (size
) == SCOPE_REF
9453 && TREE_OPERAND (size
, 0) == current_class_type
)
9455 tree t
= lookup_field (current_class_type
,
9456 TREE_OPERAND (size
, 1), 0, 0);
9461 return build_index_type (build_min (MINUS_EXPR
, sizetype
,
9462 size
, integer_one_node
));
9465 /* The array bound must be an integer type. */
9466 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
9467 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
9468 && TREE_CODE (TREE_TYPE (size
)) != BOOLEAN_TYPE
)
9471 cp_error ("size of array `%D' has non-integer type", name
);
9473 cp_error ("size of array has non-integer type");
9474 size
= integer_one_node
;
9477 /* Normally, the array-bound will be a constant. */
9478 if (TREE_CODE (size
) == INTEGER_CST
)
9480 /* Check to see if the array bound overflowed. Make that an
9481 error, no matter how generous we're being. */
9482 int old_flag_pedantic_errors
= flag_pedantic_errors
;
9483 int old_pedantic
= pedantic
;
9484 pedantic
= flag_pedantic_errors
= 1;
9485 constant_expression_warning (size
);
9486 pedantic
= old_pedantic
;
9487 flag_pedantic_errors
= old_flag_pedantic_errors
;
9489 /* An array must have a positive number of elements. */
9490 if (INT_CST_LT (size
, integer_zero_node
))
9493 cp_error ("size of array `%D' is negative", name
);
9495 cp_error ("size of array is negative");
9496 size
= integer_one_node
;
9498 /* Except that an extension we allow zero-sized arrays. We
9499 always allow them in system headers because glibc uses
9501 else if (integer_zerop (size
) && pedantic
&& !in_system_header
)
9504 cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name
);
9506 cp_pedwarn ("ISO C++ forbids zero-size array");
9509 else if (TREE_CONSTANT (size
))
9511 /* `(int) &fn' is not a valid array bound. */
9513 cp_error ("size of array `%D' is not an integral constant-expression",
9516 cp_error ("size of array is not an integral constant-expression");
9519 /* Compute the index of the largest element in the array. It is
9520 one less than the number of elements in the array. */
9522 = fold (cp_build_binary_op (MINUS_EXPR
,
9523 cp_convert (ssizetype
, size
),
9524 cp_convert (ssizetype
,
9525 integer_one_node
)));
9527 /* Check for variable-sized arrays. We allow such things as an
9528 extension, even though they are not allowed in ANSI/ISO C++. */
9529 if (!TREE_CONSTANT (itype
))
9534 cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9537 cp_pedwarn ("ISO C++ forbids variable-size array");
9540 /* Create a variable-sized array index type. */
9541 itype
= variable_size (itype
);
9543 /* Make sure that there was no overflow when creating to a signed
9544 index type. (For example, on a 32-bit machine, an array with
9545 size 2^32 - 1 is too big.) */
9546 else if (TREE_OVERFLOW (itype
))
9548 error ("overflow in array dimension");
9549 TREE_OVERFLOW (itype
) = 0;
9552 /* Create and return the appropriate index type. */
9553 return build_index_type (itype
);
9556 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9557 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9561 create_array_type_for_decl (name
, type
, size
)
9566 tree itype
= NULL_TREE
;
9567 const char* error_msg
;
9569 /* If things have already gone awry, bail now. */
9570 if (type
== error_mark_node
|| size
== error_mark_node
)
9571 return error_mark_node
;
9573 /* Assume that everything will go OK. */
9576 /* There are some types which cannot be array elements. */
9577 switch (TREE_CODE (type
))
9580 error_msg
= "array of void";
9584 error_msg
= "array of functions";
9587 case REFERENCE_TYPE
:
9588 error_msg
= "array of references";
9592 error_msg
= "array of data members";
9596 error_msg
= "array of function members";
9603 /* If something went wrong, issue an error-message and return. */
9607 cp_error ("declaration of `%D' as %s", name
, error_msg
);
9609 cp_error ("creating %s", error_msg
);
9611 return error_mark_node
;
9616 The constant expressions that specify the bounds of the arrays
9617 can be omitted only for the first member of the sequence. */
9618 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9620 cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9623 return error_mark_node
;
9626 /* Figure out the index type for the array. */
9628 itype
= compute_array_index_type (name
, size
);
9630 return build_cplus_array_type (type
, itype
);
9633 /* Check that it's OK to declare a function with the indicated TYPE.
9634 SFK indicates the kind of special function (if any) that this
9635 function is. CTYPE is the class of which this function is a
9636 member. OPTYPE is the type given in a conversion operator
9637 declaration. Returns the actual return type of the function; that
9638 may be different than TYPE if an error occurs, or for certain
9639 special functions. */
9642 check_special_function_return_type (sfk
, type
, ctype
, optype
)
9643 special_function_kind sfk
;
9650 case sfk_constructor
:
9652 cp_error ("return type specification for constructor invalid");
9654 /* In the old ABI, we return `this'; in the new ABI we don't
9656 type
= flag_new_abi
? void_type_node
: build_pointer_type (ctype
);
9659 case sfk_destructor
:
9661 cp_error ("return type specification for destructor invalid");
9662 type
= void_type_node
;
9665 case sfk_conversion
:
9666 if (type
&& !same_type_p (type
, optype
))
9667 cp_error ("operator `%T' declared to return `%T'", optype
, type
);
9669 cp_pedwarn ("return type specified for `operator %T'", optype
);
9674 my_friendly_abort (20000408);
9681 /* Given declspecs and a declarator,
9682 determine the name and type of the object declared
9683 and construct a ..._DECL node for it.
9684 (In one case we can return a ..._TYPE node instead.
9685 For invalid input we sometimes return 0.)
9687 DECLSPECS is a chain of tree_list nodes whose value fields
9688 are the storage classes and type specifiers.
9690 DECL_CONTEXT says which syntactic context this declaration is in:
9691 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9692 FUNCDEF for a function definition. Like NORMAL but a few different
9693 error messages in each case. Return value may be zero meaning
9694 this definition is too screwy to try to parse.
9695 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9696 handle member functions (which have FIELD context).
9697 Return value may be zero meaning this definition is too screwy to
9699 PARM for a parameter declaration (either within a function prototype
9700 or before a function body). Make a PARM_DECL, or return void_type_node.
9701 CATCHPARM for a parameter declaration before a catch clause.
9702 TYPENAME if for a typename (in a cast or sizeof).
9703 Don't make a DECL node; just return the ..._TYPE node.
9704 FIELD for a struct or union field; make a FIELD_DECL.
9705 BITFIELD for a field with specified width.
9706 INITIALIZED is 1 if the decl has an initializer.
9708 ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9709 normal attributes in TREE_PURPOSE, or NULL_TREE.
9711 In the TYPENAME case, DECLARATOR is really an abstract declarator.
9712 It may also be so in the PARM case, for a prototype where the
9713 argument type is specified but not the name.
9715 This function is where the complicated C meanings of `static'
9716 and `extern' are interpreted.
9718 For C++, if there is any monkey business to do, the function which
9719 calls this one must do it, i.e., prepending instance variables,
9720 renaming overloaded function names, etc.
9722 Note that for this C++, it is an error to define a method within a class
9723 which does not belong to that class.
9725 Except in the case where SCOPE_REFs are implicitly known (such as
9726 methods within a class being redundantly qualified),
9727 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9728 (class_name::decl_name). The caller must also deal with this.
9730 If a constructor or destructor is seen, and the context is FIELD,
9731 then the type gains the attribute TREE_HAS_x. If such a declaration
9732 is erroneous, NULL_TREE is returned.
9734 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
9735 function, these are the qualifiers to give to the `this' pointer. We
9736 apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9738 May return void_type_node if the declarator turned out to be a friend.
9739 See grokfield for details. */
9742 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
9745 enum decl_context decl_context
;
9749 RID_BIT_TYPE specbits
;
9752 tree type
= NULL_TREE
;
9758 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9759 int explicit_int
= 0;
9760 int explicit_char
= 0;
9761 int defaulted_int
= 0;
9762 tree typedef_decl
= NULL_TREE
;
9764 tree typedef_type
= NULL_TREE
;
9765 int funcdef_flag
= 0;
9766 enum tree_code innermost_code
= ERROR_MARK
;
9769 /* See the code below that used this. */
9770 tree decl_machine_attr
= NULL_TREE
;
9772 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9773 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
9774 tree init
= NULL_TREE
;
9776 /* Keep track of what sort of function is being processed
9777 so that we can warn about default return values, or explicit
9778 return values which do not match prescribed defaults. */
9779 special_function_kind sfk
= sfk_none
;
9781 tree dname
= NULL_TREE
;
9782 tree ctype
= current_class_type
;
9783 tree ctor_return_type
= NULL_TREE
;
9784 enum overload_flags flags
= NO_SPECIAL
;
9785 tree quals
= NULL_TREE
;
9786 tree raises
= NULL_TREE
;
9787 int template_count
= 0;
9788 tree in_namespace
= NULL_TREE
;
9792 RIDBIT_RESET_ALL (specbits
);
9793 if (decl_context
== FUNCDEF
)
9794 funcdef_flag
= 1, decl_context
= NORMAL
;
9795 else if (decl_context
== MEMFUNCDEF
)
9796 funcdef_flag
= -1, decl_context
= FIELD
;
9797 else if (decl_context
== BITFIELD
)
9798 bitfield
= 1, decl_context
= FIELD
;
9800 /* Look inside a declarator for the name being declared
9801 and get it as a string, for an error message. */
9803 tree
*next
= &declarator
;
9807 while (next
&& *next
)
9810 switch (TREE_CODE (decl
))
9813 /* For attributes. */
9814 next
= &TREE_VALUE (decl
);
9819 next
= &TREE_OPERAND (decl
, 0);
9822 case BIT_NOT_EXPR
: /* For C++ destructors! */
9824 tree name
= TREE_OPERAND (decl
, 0);
9825 tree rename
= NULL_TREE
;
9827 my_friendly_assert (flags
== NO_SPECIAL
, 152);
9829 sfk
= sfk_destructor
;
9830 if (TREE_CODE (name
) == TYPE_DECL
)
9831 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
9832 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
9833 if (ctype
== NULL_TREE
)
9835 if (current_class_type
== NULL_TREE
)
9837 error ("destructors must be member functions");
9842 tree t
= constructor_name (current_class_name
);
9849 tree t
= constructor_name (ctype
);
9856 cp_error ("destructor `%T' must match class name `%T'",
9858 TREE_OPERAND (decl
, 0) = rename
;
9864 case ADDR_EXPR
: /* C++ reference declaration */
9869 innermost_code
= TREE_CODE (decl
);
9870 next
= &TREE_OPERAND (decl
, 0);
9874 if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl
)))
9876 /* This is actually a variable declaration using
9877 constructor syntax. We need to call start_decl and
9878 cp_finish_decl so we can get the variable
9881 tree attributes
, prefix_attributes
;
9883 *next
= TREE_OPERAND (decl
, 0);
9884 init
= CALL_DECLARATOR_PARMS (decl
);
9888 attributes
= TREE_PURPOSE (attrlist
);
9889 prefix_attributes
= TREE_VALUE (attrlist
);
9893 attributes
= NULL_TREE
;
9894 prefix_attributes
= NULL_TREE
;
9897 decl
= start_decl (declarator
, declspecs
, 1,
9898 attributes
, prefix_attributes
);
9899 decl_type_access_control (decl
);
9902 /* Look for __unused__ attribute */
9903 if (TREE_USED (TREE_TYPE (decl
)))
9904 TREE_USED (decl
) = 1;
9905 finish_decl (decl
, init
, NULL_TREE
);
9908 cp_error ("invalid declarator");
9911 innermost_code
= TREE_CODE (decl
);
9912 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
9913 ctype
= current_class_type
;
9915 && TREE_OPERAND (decl
, 0)
9916 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
9917 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
9918 == constructor_name_full (ctype
))
9919 || (DECL_NAME (TREE_OPERAND (decl
, 0))
9920 == constructor_name (ctype
)))))
9921 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9922 next
= &TREE_OPERAND (decl
, 0);
9924 if (ctype
!= NULL_TREE
9925 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
9926 && decl
== constructor_name (ctype
))
9928 sfk
= sfk_constructor
;
9929 ctor_return_type
= ctype
;
9934 case TEMPLATE_ID_EXPR
:
9936 tree fns
= TREE_OPERAND (decl
, 0);
9938 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
9939 fns
= TREE_OPERAND (fns
, 0);
9942 if (TREE_CODE (dname
) == COMPONENT_REF
)
9943 dname
= TREE_OPERAND (dname
, 1);
9944 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
9946 my_friendly_assert (is_overloaded_fn (dname
),
9948 dname
= DECL_NAME (get_first_fn (dname
));
9953 case IDENTIFIER_NODE
:
9954 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
9959 if (C_IS_RESERVED_WORD (dname
))
9961 cp_error ("declarator-id missing; using reserved word `%D'",
9963 name
= IDENTIFIER_POINTER (dname
);
9965 else if (!IDENTIFIER_TYPENAME_P (dname
))
9966 name
= IDENTIFIER_POINTER (dname
);
9969 my_friendly_assert (flags
== NO_SPECIAL
, 154);
9970 flags
= TYPENAME_FLAG
;
9971 ctor_return_type
= TREE_TYPE (dname
);
9972 sfk
= sfk_conversion
;
9973 if (IDENTIFIER_GLOBAL_VALUE (dname
)
9974 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname
))
9976 name
= IDENTIFIER_POINTER (dname
);
9978 name
= "<invalid operator>";
9985 /* Perform error checking, and decide on a ctype. */
9986 tree cname
= TREE_OPERAND (decl
, 0);
9987 if (cname
== NULL_TREE
)
9989 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
9992 in_namespace
= TREE_OPERAND (decl
, 0);
9993 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9995 else if (! is_aggr_type (cname
, 1))
9996 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9997 /* Must test TREE_OPERAND (decl, 1), in case user gives
9998 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9999 else if (TREE_OPERAND (decl
, 1)
10000 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
10002 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
10003 || TREE_CODE (cname
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
10005 cp_error ("`%T::%D' is not a valid declarator", cname
,
10006 TREE_OPERAND (decl
, 1));
10007 cp_error (" perhaps you want `typename %T::%D' to make it a type",
10008 cname
, TREE_OPERAND (decl
, 1));
10009 return void_type_node
;
10011 else if (ctype
== NULL_TREE
)
10013 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
10014 TREE_OPERAND (decl
, 0) = ctype
;
10017 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
10019 cp_error ("type `%T' is not derived from type `%T'",
10021 TREE_OPERAND (decl
, 0) = NULL_TREE
;
10027 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
10028 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
10029 == constructor_name_full (ctype
))
10030 || (DECL_NAME (TREE_OPERAND (decl
, 1))
10031 == constructor_name (ctype
))))
10032 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
10033 next
= &TREE_OPERAND (decl
, 1);
10037 if (TREE_CODE (decl
) == IDENTIFIER_NODE
10038 && constructor_name (ctype
) == decl
)
10040 sfk
= sfk_constructor
;
10041 ctor_return_type
= ctype
;
10043 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
10044 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
10045 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
10046 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
10048 sfk
= sfk_destructor
;
10049 ctor_return_type
= ctype
;
10051 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
10052 next
= &TREE_OPERAND (decl
, 0);
10063 /* Parse error puts this typespec where
10064 a declarator should go. */
10065 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
10066 if (TREE_TYPE (decl
) == current_class_type
)
10067 cp_error (" perhaps you want `%T' for a constructor",
10068 current_class_name
);
10069 dname
= DECL_NAME (decl
);
10070 name
= IDENTIFIER_POINTER (dname
);
10072 /* Avoid giving two errors for this. */
10073 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
10075 declspecs
= tree_cons (NULL_TREE
, integer_type_node
, declspecs
);
10081 cp_compiler_error ("`%D' as declarator", decl
);
10082 return 0; /* We used to do a 155 abort here. */
10087 /* A function definition's declarator must have the form of
10088 a function declarator. */
10090 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
10093 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
10094 && innermost_code
!= CALL_EXPR
10095 && ! (ctype
&& declspecs
== NULL_TREE
))
10097 cp_error ("declaration of `%D' as non-function", dname
);
10098 return void_type_node
;
10101 /* Anything declared one level down from the top level
10102 must be one of the parameters of a function
10103 (because the body is at least two levels down). */
10105 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10106 by not allowing C++ class definitions to specify their parameters
10107 with xdecls (must be spec.d in the parmlist).
10109 Since we now wait to push a class scope until we are sure that
10110 we are in a legitimate method context, we must set oldcname
10111 explicitly (since current_class_name is not yet alive).
10113 We also want to avoid calling this a PARM if it is in a namespace. */
10115 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
10117 struct binding_level
*b
= current_binding_level
;
10118 current_binding_level
= b
->level_chain
;
10119 if (current_binding_level
!= 0 && toplevel_bindings_p ())
10120 decl_context
= PARM
;
10121 current_binding_level
= b
;
10125 name
= decl_context
== PARM
? "parameter" : "type name";
10127 /* Look through the decl specs and record which ones appear.
10128 Some typespecs are defined as built-in typenames.
10129 Others, the ones that are modifiers of other types,
10130 are represented by bits in SPECBITS: set the bits for
10131 the modifiers that appear. Storage class keywords are also in SPECBITS.
10133 If there is a typedef name or a type, store the type in TYPE.
10134 This includes builtin typedefs such as `int'.
10136 Set EXPLICIT_INT if the type is `int' or `char' and did not
10137 come from a user typedef.
10139 Set LONGLONG if `long' is mentioned twice.
10141 For C++, constructors and destructors have their own fast treatment. */
10143 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
10148 /* Certain parse errors slip through. For example,
10149 `int class;' is not caught by the parser. Try
10150 weakly to recover here. */
10151 if (TREE_CODE (spec
) != TREE_LIST
)
10154 id
= TREE_VALUE (spec
);
10156 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
10158 if (id
== ridpointers
[(int) RID_INT
]
10159 || id
== ridpointers
[(int) RID_CHAR
]
10160 || id
== ridpointers
[(int) RID_BOOL
]
10161 || id
== ridpointers
[(int) RID_WCHAR
])
10165 if (id
== ridpointers
[(int) RID_BOOL
])
10166 error ("`bool' is now a keyword");
10168 cp_error ("extraneous `%T' ignored", id
);
10172 if (id
== ridpointers
[(int) RID_INT
])
10174 else if (id
== ridpointers
[(int) RID_CHAR
])
10176 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
10180 /* C++ aggregate types. */
10181 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
10184 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
10186 type
= IDENTIFIER_TYPE_VALUE (id
);
10190 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
10192 if (ridpointers
[i
] == id
)
10194 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
10196 if (pedantic
&& ! in_system_header
&& warn_long_long
)
10197 pedwarn ("ISO C++ does not support `long long'");
10199 error ("`long long long' is too long for GCC");
10203 else if (RIDBIT_SETP (i
, specbits
))
10204 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
10205 RIDBIT_SET (i
, specbits
);
10210 /* C++ aggregate types. */
10211 else if (TREE_CODE (id
) == TYPE_DECL
)
10214 cp_error ("multiple declarations `%T' and `%T'", type
,
10218 type
= TREE_TYPE (id
);
10219 TREE_VALUE (spec
) = type
;
10224 error ("two or more data types in declaration of `%s'", name
);
10225 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
10227 register tree t
= lookup_name (id
, 1);
10228 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
10229 error ("`%s' fails to be a typedef or built in type",
10230 IDENTIFIER_POINTER (id
));
10233 type
= TREE_TYPE (t
);
10235 /* See the code below that used this. */
10236 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
10241 else if (id
!= error_mark_node
)
10242 /* Can't change CLASS nodes into RECORD nodes here! */
10248 typedef_type
= type
;
10250 /* No type at all: default to `int', and set DEFAULTED_INT
10251 because it was not a user-defined typedef. */
10253 if (type
== NULL_TREE
10254 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
10255 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10256 || RIDBIT_SETP (RID_LONG
, specbits
)
10257 || RIDBIT_SETP (RID_SHORT
, specbits
)))
10259 /* These imply 'int'. */
10260 type
= integer_type_node
;
10264 if (sfk
!= sfk_none
)
10265 type
= check_special_function_return_type (sfk
, type
,
10268 else if (type
== NULL_TREE
)
10274 /* We handle `main' specially here, because 'main () { }' is so
10275 common. With no options, it is allowed. With -Wreturn-type,
10276 it is a warning. It is only an error with -pedantic-errors. */
10277 is_main
= (funcdef_flag
10278 && MAIN_NAME_P (dname
)
10279 && ctype
== NULL_TREE
10280 && in_namespace
== NULL_TREE
10281 && current_namespace
== global_namespace
);
10283 if (in_system_header
|| flag_ms_extensions
)
10284 /* Allow it, sigh. */;
10285 else if (pedantic
|| ! is_main
)
10286 cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10288 else if (warn_return_type
)
10289 cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10292 type
= integer_type_node
;
10297 /* Now process the modifiers that were specified
10298 and check for invalid combinations. */
10300 /* Long double is a special combination. */
10302 if (RIDBIT_SETP (RID_LONG
, specbits
)
10303 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
10305 RIDBIT_RESET (RID_LONG
, specbits
);
10306 type
= build_qualified_type (long_double_type_node
,
10307 CP_TYPE_QUALS (type
));
10310 /* Check all other uses of type modifiers. */
10312 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10313 || RIDBIT_SETP (RID_SIGNED
, specbits
)
10314 || RIDBIT_SETP (RID_LONG
, specbits
)
10315 || RIDBIT_SETP (RID_SHORT
, specbits
))
10319 if (TREE_CODE (type
) == REAL_TYPE
)
10320 error ("short, signed or unsigned invalid for `%s'", name
);
10321 else if (TREE_CODE (type
) != INTEGER_TYPE
)
10322 error ("long, short, signed or unsigned invalid for `%s'", name
);
10323 else if (RIDBIT_SETP (RID_LONG
, specbits
)
10324 && RIDBIT_SETP (RID_SHORT
, specbits
))
10325 error ("long and short specified together for `%s'", name
);
10326 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
10327 || RIDBIT_SETP (RID_SHORT
, specbits
))
10329 error ("long or short specified with char for `%s'", name
);
10330 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
10331 || RIDBIT_SETP (RID_SHORT
, specbits
))
10332 && TREE_CODE (type
) == REAL_TYPE
)
10333 error ("long or short specified with floating type for `%s'", name
);
10334 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10335 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
10336 error ("signed and unsigned given together for `%s'", name
);
10340 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
10342 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10344 if (flag_pedantic_errors
)
10349 /* Discard the type modifiers if they are invalid. */
10352 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
10353 RIDBIT_RESET (RID_SIGNED
, specbits
);
10354 RIDBIT_RESET (RID_LONG
, specbits
);
10355 RIDBIT_RESET (RID_SHORT
, specbits
);
10360 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
10361 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
10363 error ("complex invalid for `%s'", name
);
10364 RIDBIT_RESET (RID_COMPLEX
, specbits
);
10367 /* Decide whether an integer type is signed or not.
10368 Optionally treat bitfields as signed by default. */
10369 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10372 It is implementation-defined whether a plain (neither
10373 explicitly signed or unsigned) char, short, int, or long
10374 bit-field is signed or unsigned.
10376 Naturally, we extend this to long long as well. Note that
10377 this does not include wchar_t. */
10378 || (bitfield
&& !flag_signed_bitfields
10379 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)
10380 /* A typedef for plain `int' without `signed' can be
10381 controlled just like plain `int', but a typedef for
10382 `signed int' cannot be so controlled. */
10384 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
10385 && (TREE_CODE (type
) == INTEGER_TYPE
10386 || TREE_CODE (type
) == CHAR_TYPE
)
10387 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
10390 type
= long_long_unsigned_type_node
;
10391 else if (RIDBIT_SETP (RID_LONG
, specbits
))
10392 type
= long_unsigned_type_node
;
10393 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
10394 type
= short_unsigned_type_node
;
10395 else if (type
== char_type_node
)
10396 type
= unsigned_char_type_node
;
10397 else if (typedef_decl
)
10398 type
= unsigned_type (type
);
10400 type
= unsigned_type_node
;
10402 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10403 && type
== char_type_node
)
10404 type
= signed_char_type_node
;
10406 type
= long_long_integer_type_node
;
10407 else if (RIDBIT_SETP (RID_LONG
, specbits
))
10408 type
= long_integer_type_node
;
10409 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
10410 type
= short_integer_type_node
;
10412 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
10414 /* If we just have "complex", it is equivalent to
10415 "complex double", but if any modifiers at all are specified it is
10416 the complex form of TYPE. E.g, "complex short" is
10417 "complex short int". */
10419 if (defaulted_int
&& ! longlong
10420 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
10421 || RIDBIT_SETP (RID_SHORT
, specbits
)
10422 || RIDBIT_SETP (RID_SIGNED
, specbits
)
10423 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
10424 type
= complex_double_type_node
;
10425 else if (type
== integer_type_node
)
10426 type
= complex_integer_type_node
;
10427 else if (type
== float_type_node
)
10428 type
= complex_float_type_node
;
10429 else if (type
== double_type_node
)
10430 type
= complex_double_type_node
;
10431 else if (type
== long_double_type_node
)
10432 type
= complex_long_double_type_node
;
10434 type
= build_complex_type (type
);
10437 if (sfk
== sfk_conversion
10438 && (RIDBIT_SETP (RID_CONST
, specbits
)
10439 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
10440 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
10441 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10444 /* Set CONSTP if this declaration is `const', whether by
10445 explicit specification or via a typedef.
10446 Likewise for VOLATILEP. */
10448 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
10450 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
10452 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
10453 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10454 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10455 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10456 type
= cp_build_qualified_type (type
, type_quals
);
10458 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
10459 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
10460 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
10461 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
10462 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
10464 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10465 staticp
= 1 + (decl_context
== FIELD
);
10467 if (virtualp
&& staticp
== 2)
10469 cp_error ("member `%D' cannot be declared both virtual and static",
10473 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
10474 RIDBIT_RESET (RID_FRIEND
, specbits
);
10476 /* Warn if two storage classes are given. Default to `auto'. */
10478 if (RIDBIT_ANY_SET (specbits
))
10480 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
10481 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
10482 if (decl_context
== PARM
&& nclasses
> 0)
10483 error ("storage class specifiers invalid in parameter declarations");
10484 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10486 if (decl_context
== PARM
)
10487 error ("typedef declaration invalid in parameter declaration");
10490 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
10491 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
10494 /* Give error if `virtual' is used outside of class declaration. */
10496 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
10498 error ("virtual outside class declaration");
10502 /* Static anonymous unions are dealt with here. */
10503 if (staticp
&& decl_context
== TYPENAME
10504 && TREE_CODE (declspecs
) == TREE_LIST
10505 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs
)))
10506 decl_context
= FIELD
;
10508 /* Warn about storage classes that are invalid for certain
10509 kinds of declarations (parameters, typenames, etc.). */
10512 error ("multiple storage classes in declaration of `%s'", name
);
10513 else if (decl_context
!= NORMAL
&& nclasses
> 0)
10515 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
10516 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
10517 || RIDBIT_SETP (RID_AUTO
, specbits
)))
10519 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10521 else if (decl_context
== FIELD
10522 /* C++ allows static class elements */
10523 && RIDBIT_SETP (RID_STATIC
, specbits
))
10524 /* C++ also allows inlines and signed and unsigned elements,
10525 but in those cases we don't come in here. */
10529 if (decl_context
== FIELD
)
10531 tree tmp
= NULL_TREE
;
10532 register int op
= 0;
10536 /* Avoid trying to get an operand off an identifier node. */
10537 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10540 tmp
= TREE_OPERAND (declarator
, 0);
10541 op
= IDENTIFIER_OPNAME_P (tmp
);
10542 if (IDENTIFIER_TYPENAME_P (tmp
))
10544 if (IDENTIFIER_GLOBAL_VALUE (tmp
)
10545 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp
))
10547 name
= IDENTIFIER_POINTER (tmp
);
10549 name
= "<invalid operator>";
10552 error ("storage class specified for %s `%s'",
10553 op
? "member operator" : "field",
10558 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10559 error ("storage class specified for parameter `%s'", name
);
10561 error ("storage class specified for typename");
10563 RIDBIT_RESET (RID_REGISTER
, specbits
);
10564 RIDBIT_RESET (RID_AUTO
, specbits
);
10565 RIDBIT_RESET (RID_EXTERN
, specbits
);
10568 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
10570 if (toplevel_bindings_p ())
10572 /* It's common practice (and completely valid) to have a const
10573 be initialized and declared extern. */
10574 if (!(type_quals
& TYPE_QUAL_CONST
))
10575 warning ("`%s' initialized and declared `extern'", name
);
10578 error ("`%s' has both `extern' and initializer", name
);
10580 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
10581 && ! toplevel_bindings_p ())
10582 error ("nested function `%s' declared `extern'", name
);
10583 else if (toplevel_bindings_p ())
10585 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10586 error ("top-level declaration of `%s' specifies `auto'", name
);
10589 if (nclasses
> 0 && friendp
)
10590 error ("storage class specifiers invalid in friend function declarations");
10592 /* Now figure out the structure of the declarator proper.
10593 Descend through it, creating more complex types, until we reach
10594 the declared identifier (or NULL_TREE, in an absolute declarator). */
10596 inner_attrs
= NULL_TREE
;
10599 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
10600 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
10602 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10603 an INDIRECT_REF (for *...),
10604 a CALL_EXPR (for ...(...)),
10605 an identifier (for the name being declared)
10606 or a null pointer (for the place in an absolute declarator
10607 where the name was omitted).
10608 For the last two cases, we have just exited the loop.
10610 For C++ it could also be
10611 a SCOPE_REF (for class :: ...). In this case, we have converted
10612 sensible names to types, and those are the values we use to
10613 qualify the member name.
10614 an ADDR_EXPR (for &...),
10615 a BIT_NOT_EXPR (for destructors)
10617 At this point, TYPE is the type of elements of an array,
10618 or for a function to return, or for a pointer to point to.
10619 After this sequence of ifs, TYPE is the type of the
10620 array or function or pointer, and DECLARATOR has had its
10621 outermost layer removed. */
10623 if (type
== error_mark_node
)
10625 if (TREE_CODE (declarator
) == SCOPE_REF
)
10626 declarator
= TREE_OPERAND (declarator
, 1);
10628 declarator
= TREE_OPERAND (declarator
, 0);
10631 if (quals
!= NULL_TREE
10632 && (declarator
== NULL_TREE
10633 || TREE_CODE (declarator
) != SCOPE_REF
))
10635 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
10636 ctype
= TYPE_METHOD_BASETYPE (type
);
10637 if (ctype
!= NULL_TREE
)
10639 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
10640 grok_method_quals (ctype
, dummy
, quals
);
10641 type
= TREE_TYPE (dummy
);
10642 ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
)));
10647 /* See the comment for the TREE_LIST case, below. */
10650 else if (inner_attrs
)
10652 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10653 inner_attrs
= NULL_TREE
;
10656 switch (TREE_CODE (declarator
))
10660 /* We encode a declarator with embedded attributes using
10661 a TREE_LIST. The attributes apply to the declarator
10662 directly inside them, so we have to skip an iteration
10663 before applying them to the type. If the declarator just
10664 inside is the declarator-id, we apply the attrs to the
10666 inner_attrs
= TREE_PURPOSE (declarator
);
10668 declarator
= TREE_VALUE (declarator
);
10674 register tree size
;
10676 size
= TREE_OPERAND (declarator
, 1);
10678 /* VC++ spells a zero-sized array with []. */
10679 if (size
== NULL_TREE
&& decl_context
== FIELD
&& ! staticp
10680 && ! RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10681 size
= integer_zero_node
;
10683 declarator
= TREE_OPERAND (declarator
, 0);
10685 type
= create_array_type_for_decl (dname
, type
, size
);
10687 /* VLAs never work as fields. */
10688 if (decl_context
== FIELD
&& !processing_template_decl
10689 && TREE_CODE (type
) == ARRAY_TYPE
10690 && TYPE_DOMAIN (type
) != NULL_TREE
10691 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
10693 cp_error ("size of member `%D' is not constant", dname
);
10694 /* Proceed with arbitrary constant size, so that offset
10695 computations don't get confused. */
10696 type
= create_array_type_for_decl (dname
, TREE_TYPE (type
),
10708 tree inner_parms
= CALL_DECLARATOR_PARMS (declarator
);
10709 tree inner_decl
= TREE_OPERAND (declarator
, 0);
10711 /* Declaring a function type.
10712 Make sure we have a valid type for the function to return. */
10714 /* We now know that the TYPE_QUALS don't apply to the
10715 decl, but to its return type. */
10716 type_quals
= TYPE_UNQUALIFIED
;
10718 /* Warn about some types functions can't return. */
10720 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10722 error ("`%s' declared as function returning a function", name
);
10723 type
= integer_type_node
;
10725 if (TREE_CODE (type
) == ARRAY_TYPE
)
10727 error ("`%s' declared as function returning an array", name
);
10728 type
= integer_type_node
;
10731 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
10732 inner_decl
= TREE_OPERAND (inner_decl
, 1);
10734 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
10735 inner_decl
= dname
;
10737 /* Pick up type qualifiers which should be applied to `this'. */
10738 quals
= CALL_DECLARATOR_QUALS (declarator
);
10740 /* Pick up the exception specifications. */
10741 raises
= CALL_DECLARATOR_EXCEPTION_SPEC (declarator
);
10743 /* Say it's a definition only for the CALL_EXPR
10744 closest to the identifier. */
10747 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
10748 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
10749 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
10751 if (ctype
== NULL_TREE
10752 && decl_context
== FIELD
10754 && (friendp
== 0 || dname
== current_class_name
))
10755 ctype
= current_class_type
;
10757 if (ctype
&& sfk
== sfk_conversion
)
10758 TYPE_HAS_CONVERSION (ctype
) = 1;
10759 if (ctype
&& constructor_name (ctype
) == dname
)
10761 /* We are within a class's scope. If our declarator name
10762 is the same as the class name, and we are defining
10763 a function, then it is a constructor/destructor, and
10764 therefore returns a void type. */
10766 if (flags
== DTOR_FLAG
)
10768 /* ISO C++ 12.4/2. A destructor may not be
10769 declared const or volatile. A destructor may
10772 error ("destructor cannot be static member function");
10775 cp_error ("destructors may not be `%s'",
10776 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10779 if (decl_context
== FIELD
)
10781 if (! member_function_or_else (ctype
,
10782 current_class_type
,
10784 return void_type_node
;
10787 else /* It's a constructor. */
10789 if (explicitp
== 1)
10791 /* ISO C++ 12.1. A constructor may not be
10792 declared const or volatile. A constructor may
10793 not be virtual. A constructor may not be
10796 error ("constructor cannot be static member function");
10799 pedwarn ("constructors cannot be declared virtual");
10804 cp_error ("constructors may not be `%s'",
10805 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10809 RID_BIT_TYPE tmp_bits
;
10810 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
10811 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
10812 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
10813 if (RIDBIT_ANY_SET (tmp_bits
))
10814 error ("return value type specifier for constructor ignored");
10816 if (decl_context
== FIELD
)
10818 if (! member_function_or_else (ctype
,
10819 current_class_type
,
10821 return void_type_node
;
10822 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
10823 if (sfk
!= sfk_constructor
)
10827 if (decl_context
== FIELD
)
10833 error ("can't initialize friend function `%s'", name
);
10836 /* Cannot be both friend and virtual. */
10837 error ("virtual functions cannot be friends");
10838 RIDBIT_RESET (RID_FRIEND
, specbits
);
10841 if (decl_context
== NORMAL
)
10842 error ("friend declaration not in class definition");
10843 if (current_function_decl
&& funcdef_flag
)
10844 cp_error ("can't define friend function `%s' in a local class definition",
10848 /* Construct the function type and go to the next
10849 inner layer of declarator. */
10851 declarator
= TREE_OPERAND (declarator
, 0);
10853 /* FIXME: This is where default args should be fully
10856 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
10858 if (declarator
&& flags
== DTOR_FLAG
)
10860 /* A destructor declared in the body of a class will
10861 be represented as a BIT_NOT_EXPR. But, we just
10862 want the underlying IDENTIFIER. */
10863 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
10864 declarator
= TREE_OPERAND (declarator
, 0);
10866 if (arg_types
!= void_list_node
)
10868 cp_error ("destructors may not have parameters");
10869 arg_types
= void_list_node
;
10870 last_function_parms
= NULL_TREE
;
10874 /* ANSI says that `const int foo ();'
10875 does not make the function foo const. */
10876 type
= build_function_type (type
, arg_types
);
10880 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
10881 if (TREE_PURPOSE (t
)
10882 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
10884 add_defarg_fn (type
);
10893 /* Filter out pointers-to-references and references-to-references.
10894 We can get these if a TYPE_DECL is used. */
10896 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10898 error ("cannot declare %s to references",
10899 TREE_CODE (declarator
) == ADDR_EXPR
10900 ? "references" : "pointers");
10901 declarator
= TREE_OPERAND (declarator
, 0);
10905 if (TREE_CODE (type
) == OFFSET_TYPE
10906 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
10907 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
10909 cp_error ("cannot declare pointer to `%#T' member",
10911 type
= TREE_TYPE (type
);
10914 /* Merge any constancy or volatility into the target type
10915 for the pointer. */
10917 /* We now know that the TYPE_QUALS don't apply to the decl,
10918 but to the target of the pointer. */
10919 type_quals
= TYPE_UNQUALIFIED
;
10921 if (TREE_CODE (declarator
) == ADDR_EXPR
)
10923 if (TREE_CODE (type
) == VOID_TYPE
)
10924 error ("invalid type: `void &'");
10926 type
= build_reference_type (type
);
10928 else if (TREE_CODE (type
) == METHOD_TYPE
)
10929 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10931 type
= build_pointer_type (type
);
10933 /* Process a list of type modifier keywords (such as
10934 const or volatile) that were given inside the `*' or `&'. */
10936 if (TREE_TYPE (declarator
))
10938 register tree typemodlist
;
10944 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
10945 typemodlist
= TREE_CHAIN (typemodlist
))
10947 tree qualifier
= TREE_VALUE (typemodlist
);
10949 if (qualifier
== ridpointers
[(int) RID_CONST
])
10951 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
10953 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
10958 error ("invalid type modifier within pointer declarator");
10962 pedwarn ("duplicate `const'");
10964 pedwarn ("duplicate `volatile'");
10966 pedwarn ("duplicate `restrict'");
10968 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10969 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10970 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10971 if (TREE_CODE (declarator
) == ADDR_EXPR
10972 && (constp
|| volatilep
))
10975 pedwarn ("discarding `const' applied to a reference");
10977 pedwarn ("discarding `volatile' applied to a reference");
10978 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
10980 type
= cp_build_qualified_type (type
, type_quals
);
10982 declarator
= TREE_OPERAND (declarator
, 0);
10988 /* We have converted type names to NULL_TREE if the
10989 name was bogus, or to a _TYPE node, if not.
10991 The variable CTYPE holds the type we will ultimately
10992 resolve to. The code here just needs to build
10993 up appropriate member types. */
10994 tree sname
= TREE_OPERAND (declarator
, 1);
10997 /* Destructors can have their visibilities changed as well. */
10998 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
10999 sname
= TREE_OPERAND (sname
, 0);
11001 if (TREE_COMPLEXITY (declarator
) == 0)
11002 /* This needs to be here, in case we are called
11003 multiple times. */ ;
11004 else if (TREE_COMPLEXITY (declarator
) == -1)
11005 /* Namespace member. */
11006 pop_decl_namespace ();
11007 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
11008 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
11009 else if (! IS_AGGR_TYPE_CODE
11010 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
11012 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
11014 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
11015 that refer to ctype. They couldn't be resolved earlier
11016 because we hadn't pushed into the class yet.
11017 Example: resolve 'B<T>::type' in
11018 'B<typename B<T>::type> B<T>::f () { }'. */
11019 if (current_template_parms
11020 && uses_template_parms (type
)
11021 && uses_template_parms (current_class_type
))
11023 tree args
= current_template_args ();
11024 type
= tsubst (type
, args
, /*complain=*/1, NULL_TREE
);
11027 /* This pop_nested_class corresponds to the
11028 push_nested_class used to push into class scope for
11029 parsing the argument list of a function decl, in
11031 pop_nested_class ();
11032 TREE_COMPLEXITY (declarator
) = current_class_depth
;
11035 my_friendly_abort (16);
11037 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
11039 /* We had a reference to a global decl, or
11040 perhaps we were given a non-aggregate typedef,
11041 in which case we cleared this out, and should just
11042 keep going as though it wasn't there. */
11043 declarator
= sname
;
11046 ctype
= TREE_OPERAND (declarator
, 0);
11049 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
11051 /* You're supposed to have one `template <...>'
11052 for every template class, but you don't need one
11053 for a full specialization. For example:
11055 template <class T> struct S{};
11056 template <> struct S<int> { void f(); };
11057 void S<int>::f () {}
11059 is correct; there shouldn't be a `template <>' for
11060 the definition of `S<int>::f'. */
11061 if (CLASSTYPE_TEMPLATE_INFO (t
)
11062 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
11063 || uses_template_parms (CLASSTYPE_TI_ARGS (t
))))
11064 template_count
+= 1;
11066 t
= TYPE_MAIN_DECL (t
);
11067 if (DECL_LANG_SPECIFIC (t
))
11068 t
= DECL_CONTEXT (t
);
11073 if (sname
== NULL_TREE
)
11076 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
11078 /* This is the `standard' use of the scoping operator:
11079 basetype :: member . */
11081 if (ctype
== current_class_type
)
11087 Is this ill-formed? */
11090 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
11093 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11095 if (current_class_type
== NULL_TREE
11097 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11098 TYPE_ARG_TYPES (type
));
11101 cp_error ("cannot declare member function `%T::%s' within `%T'",
11102 ctype
, name
, current_class_type
);
11103 return void_type_node
;
11106 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
11107 || COMPLETE_TYPE_P (complete_type (ctype
)))
11109 /* Have to move this code elsewhere in this function.
11110 this code is used for i.e., typedef int A::M; M *pm;
11112 It is? How? jason 10/2/94 */
11114 if (current_class_type
)
11116 cp_error ("cannot declare member `%T::%s' within `%T'",
11117 ctype
, name
, current_class_type
);
11118 return void_type_node
;
11120 type
= build_offset_type (ctype
, type
);
11122 else if (uses_template_parms (ctype
))
11124 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11126 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
11127 TYPE_ARG_TYPES (type
));
11131 cp_error ("structure `%T' not yet defined", ctype
);
11132 return error_mark_node
;
11135 declarator
= sname
;
11137 else if (TREE_CODE (sname
) == SCOPE_REF
)
11138 my_friendly_abort (17);
11142 declarator
= TREE_OPERAND (declarator
, 1);
11143 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
11144 /* In this case, we will deal with it later. */
11148 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11149 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11150 TYPE_ARG_TYPES (type
));
11152 type
= build_offset_type (ctype
, type
);
11159 declarator
= TREE_OPERAND (declarator
, 0);
11164 case ENUMERAL_TYPE
:
11165 declarator
= NULL_TREE
;
11169 declarator
= NULL_TREE
;
11173 my_friendly_abort (158);
11177 /* See the comment for the TREE_LIST case, above. */
11180 if (! ignore_attrs
)
11181 decl_attributes (type
, inner_attrs
, NULL_TREE
);
11183 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
11185 attrlist
= build_decl_list (NULL_TREE
, inner_attrs
);
11188 /* Now TYPE has the actual type. */
11190 if (explicitp
== 1 || (explicitp
&& friendp
))
11192 /* [dcl.fct.spec] The explicit specifier shall only be used in
11193 declarations of constructors within a class definition. */
11194 error ("only declarations of constructors can be `explicit'");
11198 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11200 if (current_class_name
== NULL_TREE
|| decl_context
== PARM
|| friendp
)
11202 error ("non-member `%s' cannot be declared `mutable'", name
);
11203 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11205 else if (decl_context
== TYPENAME
|| RIDBIT_SETP (RID_TYPEDEF
, specbits
))
11207 error ("non-object member `%s' cannot be declared `mutable'", name
);
11208 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11210 else if (TREE_CODE (type
) == FUNCTION_TYPE
11211 || TREE_CODE (type
) == METHOD_TYPE
)
11213 error ("function `%s' cannot be declared `mutable'", name
);
11214 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11218 error ("static `%s' cannot be declared `mutable'", name
);
11219 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11221 else if (type_quals
& TYPE_QUAL_CONST
)
11223 error ("const `%s' cannot be declared `mutable'", name
);
11224 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11228 if (declarator
== NULL_TREE
11229 || TREE_CODE (declarator
) == IDENTIFIER_NODE
11230 || (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
11231 && (TREE_CODE (type
) == FUNCTION_TYPE
11232 || TREE_CODE (type
) == METHOD_TYPE
)))
11234 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
11236 cp_error ("template-id `%D' used as a declarator", declarator
);
11237 declarator
= dname
;
11240 /* Unexpected declarator format. */
11241 my_friendly_abort (990210);
11243 /* If this is declaring a typedef name, return a TYPE_DECL. */
11245 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
11249 /* Note that the grammar rejects storage classes
11250 in typenames, fields or parameters. */
11251 if (current_lang_name
== lang_name_java
)
11252 TYPE_FOR_JAVA (type
) = 1;
11254 if (decl_context
== FIELD
)
11256 if (declarator
== constructor_name (current_class_type
))
11257 cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11259 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
11262 decl
= build_decl (TYPE_DECL
, declarator
, type
);
11264 /* If the user declares "typedef struct {...} foo" then the
11265 struct will have an anonymous name. Fill that name in now.
11266 Nothing can refer to it, so nothing needs know about the name
11268 if (type
!= error_mark_node
11270 && TYPE_NAME (type
)
11271 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
11272 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
))
11273 && CP_TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
11275 tree oldname
= TYPE_NAME (type
);
11278 /* Replace the anonymous name with the real name everywhere. */
11279 lookup_tag_reverse (type
, declarator
);
11280 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
11281 if (TYPE_NAME (t
) == oldname
)
11282 TYPE_NAME (t
) = decl
;
11284 if (TYPE_LANG_SPECIFIC (type
))
11285 TYPE_WAS_ANONYMOUS (type
) = 1;
11287 /* If this is a typedef within a template class, the nested
11288 type is a (non-primary) template. The name for the
11289 template needs updating as well. */
11290 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
11291 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
11292 = TYPE_IDENTIFIER (type
);
11295 DECL_ASSEMBLER_NAME (decl
) = mangle_type (type
);
11298 /* XXX Temporarily set the scope.
11299 When returning, start_decl expects it as NULL_TREE,
11300 and will then then set it using pushdecl. */
11301 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
11302 if (current_class_type
)
11303 DECL_CONTEXT (decl
) = current_class_type
;
11305 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
11307 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
11308 DECL_ASSEMBLER_NAME (decl
)
11309 = get_identifier (build_overload_name (type
, 1, 1));
11310 DECL_CONTEXT (decl
) = NULL_TREE
;
11313 /* FIXME remangle member functions; member functions of a
11314 type with external linkage have external linkage. */
11317 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11319 cp_error_at ("typedef name may not be class-qualified", decl
);
11324 if (ctype
== NULL_TREE
)
11326 if (TREE_CODE (type
) != METHOD_TYPE
)
11327 cp_error_at ("invalid type qualifier for non-member function type", decl
);
11329 ctype
= TYPE_METHOD_BASETYPE (type
);
11331 if (ctype
!= NULL_TREE
)
11332 grok_method_quals (ctype
, decl
, quals
);
11335 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
11336 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
11337 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
11339 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
11340 inlinep
, friendp
, raises
!= NULL_TREE
);
11343 error ("typedef declaration includes an initializer");
11348 /* Detect the case of an array type of unspecified size
11349 which came, as such, direct from a typedef name.
11350 We must copy the type, so that each identifier gets
11351 a distinct type, so that each identifier's size can be
11352 controlled separately by its own initializer. */
11354 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
11355 && TYPE_DOMAIN (type
) == NULL_TREE
)
11357 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
11360 /* If this is a type name (such as, in a cast or sizeof),
11361 compute the type and return it now. */
11363 if (decl_context
== TYPENAME
)
11365 /* Note that the grammar rejects storage classes
11366 in typenames, fields or parameters. */
11367 if (type_quals
!= TYPE_UNQUALIFIED
)
11368 type_quals
= TYPE_UNQUALIFIED
;
11370 /* Special case: "friend class foo" looks like a TYPENAME context. */
11373 if (type_quals
!= TYPE_UNQUALIFIED
)
11375 cp_error ("type qualifiers specified for friend class declaration");
11376 type_quals
= TYPE_UNQUALIFIED
;
11380 cp_error ("`inline' specified for friend class declaration");
11383 if (!current_aggr
&& TREE_CODE (type
) != TYPENAME_TYPE
)
11385 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11386 cp_error ("template parameters cannot be friends");
11388 cp_error ("friend declaration requires `%#T'", type
);
11391 /* Only try to do this stuff if we didn't already give up. */
11392 if (type
!= integer_type_node
)
11394 /* A friendly class? */
11395 if (current_class_type
)
11396 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
11398 cp_error ("trying to make class `%T' a friend of global scope",
11400 type
= void_type_node
;
11405 if (ctype
== NULL_TREE
)
11407 if (TREE_CODE (type
) != METHOD_TYPE
)
11408 cp_error ("invalid qualifiers on non-member function type");
11410 ctype
= TYPE_METHOD_BASETYPE (type
);
11414 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
11415 grok_method_quals (ctype
, dummy
, quals
);
11416 type
= TREE_TYPE (dummy
);
11422 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
11423 && decl_context
!= CATCHPARM
11424 && TREE_CODE (type
) != UNION_TYPE
11427 cp_error ("abstract declarator `%T' used as declaration", type
);
11428 declarator
= make_anon_name ();
11431 /* `void' at top level (not within pointer)
11432 is allowed only in typedefs or type names.
11433 We don't complain about parms either, but that is because
11434 a better error message can be made later. */
11436 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
11439 error ("unnamed variable or field declared void");
11440 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
11442 if (IDENTIFIER_OPNAME_P (declarator
))
11443 my_friendly_abort (356);
11445 error ("variable or field `%s' declared void", name
);
11448 error ("variable or field declared void");
11449 type
= integer_type_node
;
11452 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11453 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11455 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
11457 if (ctype
|| in_namespace
)
11458 error ("cannot use `::' in parameter declaration");
11460 /* A parameter declared as an array of T is really a pointer to T.
11461 One declared as a function is really a pointer to a function.
11462 One declared as a member is really a pointer to member. */
11464 if (TREE_CODE (type
) == ARRAY_TYPE
)
11466 /* Transfer const-ness of array into that of type pointed to. */
11467 type
= build_pointer_type (TREE_TYPE (type
));
11468 type_quals
= TYPE_UNQUALIFIED
;
11470 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11471 type
= build_pointer_type (type
);
11472 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11473 type
= build_pointer_type (type
);
11474 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
11476 error ("declaration of `%s' as void", name
);
11482 register tree decl
;
11484 if (decl_context
== PARM
)
11486 decl
= build_decl (PARM_DECL
, declarator
, type
);
11488 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
11489 inlinep
, friendp
, raises
!= NULL_TREE
);
11491 /* Compute the type actually passed in the parmlist,
11492 for the case where there is no prototype.
11493 (For example, shorts and chars are passed as ints.)
11494 When there is a prototype, this is overridden later. */
11496 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
11498 else if (decl_context
== FIELD
)
11500 if (type
== error_mark_node
)
11502 /* Happens when declaring arrays of sizes which
11503 are error_mark_node, for example. */
11506 else if (in_namespace
&& !friendp
)
11508 /* Something like struct S { int N::j; }; */
11509 cp_error ("invalid use of `::'");
11512 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11515 tree function_context
;
11517 /* We catch the others as conflicts with the builtin
11519 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
11521 cp_error ("function `%D' cannot be declared friend",
11528 if (ctype
== NULL_TREE
)
11529 ctype
= current_class_type
;
11531 if (ctype
== NULL_TREE
)
11533 cp_error ("can't make `%D' into a method -- not in a class",
11535 return void_type_node
;
11538 /* ``A union may [ ... ] not [ have ] virtual functions.''
11540 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11542 cp_error ("function `%D' declared virtual inside a union",
11544 return void_type_node
;
11547 if (declarator
== ansi_opname (NEW_EXPR
)
11548 || declarator
== ansi_opname (VEC_NEW_EXPR
)
11549 || declarator
== ansi_opname (DELETE_EXPR
)
11550 || declarator
== ansi_opname (VEC_DELETE_EXPR
))
11554 cp_error ("`%D' cannot be declared virtual, since it is always static",
11559 else if (staticp
< 2)
11560 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11561 TYPE_ARG_TYPES (type
));
11564 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11565 function_context
= (ctype
!= NULL_TREE
) ?
11566 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11567 publicp
= (! friendp
|| ! staticp
)
11568 && function_context
== NULL_TREE
;
11569 decl
= grokfndecl (ctype
, type
,
11570 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
11571 ? declarator
: dname
,
11573 virtualp
, flags
, quals
, raises
,
11574 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
11575 funcdef_flag
, template_count
, in_namespace
);
11576 if (decl
== NULL_TREE
)
11579 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11580 /* The decl and setting of decl_machine_attr is also turned off. */
11581 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
11584 /* [class.conv.ctor]
11586 A constructor declared without the function-specifier
11587 explicit that can be called with a single parameter
11588 specifies a conversion from the type of its first
11589 parameter to the type of its class. Such a constructor
11590 is called a converting constructor. */
11591 if (explicitp
== 2)
11592 DECL_NONCONVERTING_P (decl
) = 1;
11593 else if (DECL_CONSTRUCTOR_P (decl
))
11595 /* The constructor can be called with exactly one
11596 parameter if there is at least one parameter, and
11597 any subsequent parameters have default arguments.
11598 We don't look at the first parameter, which is
11599 really just the `this' parameter for the new
11602 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
11604 /* Skip the `in_chrg' argument too, if present. */
11605 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
11606 arg_types
= TREE_CHAIN (arg_types
);
11608 if (arg_types
== void_list_node
11610 && TREE_CHAIN (arg_types
)
11611 && TREE_CHAIN (arg_types
) != void_list_node
11612 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
11613 DECL_NONCONVERTING_P (decl
) = 1;
11616 else if (TREE_CODE (type
) == METHOD_TYPE
)
11618 /* We only get here for friend declarations of
11619 members of other classes. */
11620 /* All method decls are public, so tell grokfndecl to set
11621 TREE_PUBLIC, also. */
11622 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
11623 virtualp
, flags
, quals
, raises
,
11624 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
11625 template_count
, in_namespace
);
11626 if (decl
== NULL_TREE
)
11629 else if (!staticp
&& ! processing_template_decl
11630 && !COMPLETE_TYPE_P (complete_type (type
))
11631 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
11634 cp_error ("field `%D' has incomplete type", declarator
);
11636 cp_error ("name `%T' has incomplete type", type
);
11638 /* If we're instantiating a template, tell them which
11639 instantiation made the field's type be incomplete. */
11640 if (current_class_type
11641 && TYPE_NAME (current_class_type
)
11642 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
11643 && declspecs
&& TREE_VALUE (declspecs
)
11644 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
11645 cp_error (" in instantiation of template `%T'",
11646 current_class_type
);
11648 type
= error_mark_node
;
11655 error ("`%s' is neither function nor member function; cannot be declared friend",
11656 IDENTIFIER_POINTER (declarator
));
11664 /* Friends are treated specially. */
11665 if (ctype
== current_class_type
)
11666 warning ("member functions are implicitly friends of their class");
11669 tree t
= NULL_TREE
;
11670 if (decl
&& DECL_NAME (decl
))
11672 if (template_class_depth (current_class_type
) == 0)
11675 = check_explicit_specialization
11677 template_count
, 2 * (funcdef_flag
!= 0) + 4);
11678 if (decl
== error_mark_node
)
11679 return error_mark_node
;
11682 t
= do_friend (ctype
, declarator
, decl
,
11683 last_function_parms
, attrlist
, flags
, quals
,
11686 if (t
&& funcdef_flag
)
11689 return void_type_node
;
11693 /* Structure field. It may not be a function, except for C++ */
11695 if (decl
== NULL_TREE
)
11701 /* An attempt is being made to initialize a non-static
11702 member. But, from [class.mem]:
11704 4 A member-declarator can contain a
11705 constant-initializer only if it declares a static
11706 member (_class.static_) of integral or enumeration
11707 type, see _class.static.data_.
11709 This used to be relatively common practice, but
11710 the rest of the compiler does not correctly
11711 handle the initialization unless the member is
11712 static so we make it static below. */
11713 cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11715 cp_pedwarn ("making `%D' static", declarator
);
11719 if (uses_template_parms (type
))
11720 /* We'll check at instantiation time. */
11722 else if (check_static_variable_definition (declarator
,
11724 /* If we just return the declaration, crashes
11725 will sometimes occur. We therefore return
11726 void_type_node, as if this was a friend
11727 declaration, to cause callers to completely
11728 ignore this declaration. */
11729 return void_type_node
;
11732 /* 9.2p13 [class.mem] */
11733 if (declarator
== constructor_name (current_class_type
)
11734 /* The standard does not allow non-static data members
11735 here either, but we agreed at the 10/99 meeting
11736 to change that in TC 1 so that they are allowed in
11737 classes with no user-defined constructors. */
11739 cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11744 /* C++ allows static class members. All other work
11745 for this is done by grokfield. */
11746 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
11747 TREE_STATIC (decl
) = 1;
11748 /* In class context, 'static' means public access. */
11749 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
11753 decl
= build_decl (FIELD_DECL
, declarator
, type
);
11754 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
11755 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11757 DECL_MUTABLE_P (decl
) = 1;
11758 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11762 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
11763 inlinep
, friendp
, raises
!= NULL_TREE
);
11766 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11768 tree original_name
;
11774 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
11775 original_name
= dname
;
11777 original_name
= declarator
;
11779 if (RIDBIT_SETP (RID_AUTO
, specbits
))
11780 error ("storage class `auto' invalid for function `%s'", name
);
11781 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11782 error ("storage class `register' invalid for function `%s'", name
);
11784 /* Function declaration not at top level.
11785 Storage classes other than `extern' are not allowed
11786 and `extern' makes no difference. */
11787 if (! toplevel_bindings_p ()
11788 && (RIDBIT_SETP (RID_STATIC
, specbits
)
11789 || RIDBIT_SETP (RID_INLINE
, specbits
))
11792 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11793 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
11795 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
11798 if (ctype
== NULL_TREE
)
11802 error ("virtual non-class function `%s'", name
);
11806 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
11807 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11808 TYPE_ARG_TYPES (type
));
11810 /* Record presence of `static'. */
11811 publicp
= (ctype
!= NULL_TREE
11812 || RIDBIT_SETP (RID_EXTERN
, specbits
)
11813 || !RIDBIT_SETP (RID_STATIC
, specbits
));
11815 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
11816 virtualp
, flags
, quals
, raises
,
11818 publicp
, inlinep
, funcdef_flag
,
11819 template_count
, in_namespace
);
11820 if (decl
== NULL_TREE
)
11825 int illegal_static
= 0;
11827 /* Don't allow a static member function in a class, and forbid
11828 declaring main to be static. */
11829 if (TREE_CODE (type
) == METHOD_TYPE
)
11831 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
11832 illegal_static
= 1;
11834 else if (current_function_decl
)
11836 /* FIXME need arm citation */
11837 error ("cannot declare static function inside another function");
11838 illegal_static
= 1;
11841 if (illegal_static
)
11844 RIDBIT_RESET (RID_STATIC
, specbits
);
11850 /* It's a variable. */
11852 /* An uninitialized decl with `extern' is a reference. */
11853 decl
= grokvardecl (type
, declarator
, &specbits
,
11855 (type_quals
& TYPE_QUAL_CONST
) != 0,
11857 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
11858 inlinep
, friendp
, raises
!= NULL_TREE
);
11862 DECL_CONTEXT (decl
) = ctype
;
11865 cp_pedwarn ("static member `%D' re-declared as static", decl
);
11867 RIDBIT_RESET (RID_STATIC
, specbits
);
11869 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
11871 cp_error ("static member `%D' declared `register'", decl
);
11872 RIDBIT_RESET (RID_REGISTER
, specbits
);
11874 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
11876 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11878 RIDBIT_RESET (RID_EXTERN
, specbits
);
11883 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE
, specbits
), 19990927);
11885 /* Record `register' declaration for warnings on &
11886 and in case doing stupid register allocation. */
11888 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11889 DECL_REGISTER (decl
) = 1;
11891 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
11892 DECL_THIS_EXTERN (decl
) = 1;
11894 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11895 DECL_THIS_STATIC (decl
) = 1;
11897 /* Record constancy and volatility. There's no need to do this
11898 when processing a template; we'll do this for the instantiated
11899 declaration based on the type of DECL. */
11900 if (!processing_template_decl
)
11901 c_apply_type_quals_to_decl (type_quals
, decl
);
11907 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11908 An empty exprlist is a parmlist. An exprlist which
11909 contains only identifiers at the global level
11910 is a parmlist. Otherwise, it is an exprlist. */
11913 parmlist_is_exprlist (exprs
)
11916 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
11919 if (toplevel_bindings_p ())
11921 /* At the global level, if these are all identifiers,
11922 then it is a parmlist. */
11925 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
11927 exprs
= TREE_CHAIN (exprs
);
11934 /* Subroutine of start_function. Ensure that each of the parameter
11935 types (as listed in PARMS) is complete, as is required for a
11936 function definition. */
11939 require_complete_types_for_parms (parms
)
11942 for (; parms
; parms
= TREE_CHAIN (parms
))
11944 tree type
= TREE_TYPE (parms
);
11946 /* Try to complete the TYPE. */
11947 type
= complete_type (type
);
11949 if (type
== error_mark_node
)
11952 if (!COMPLETE_TYPE_P (type
))
11954 if (DECL_NAME (parms
))
11955 error ("parameter `%s' has incomplete type",
11956 IDENTIFIER_POINTER (DECL_NAME (parms
)));
11958 error ("parameter has incomplete type");
11959 TREE_TYPE (parms
) = error_mark_node
;
11962 layout_decl (parms
, 0);
11966 /* Returns non-zero if T is a local variable. */
11969 local_variable_p (t
)
11972 if ((TREE_CODE (t
) == VAR_DECL
11973 /* A VAR_DECL with a context that is a _TYPE is a static data
11975 && !TYPE_P (CP_DECL_CONTEXT (t
))
11976 /* Any other non-local variable must be at namespace scope. */
11977 && !DECL_NAMESPACE_SCOPE_P (t
))
11978 || (TREE_CODE (t
) == PARM_DECL
))
11984 /* Returns non-zero if T is an automatic local variable or a label.
11985 (These are the declarations that need to be remapped when the code
11986 containing them is duplicated.) */
11989 nonstatic_local_decl_p (t
)
11992 return ((local_variable_p (t
) && !TREE_STATIC (t
))
11993 || TREE_CODE (t
) == LABEL_DECL
11994 || TREE_CODE (t
) == RESULT_DECL
);
11997 /* Like local_variable_p, but suitable for use as a tree-walking
12001 local_variable_p_walkfn (tp
, walk_subtrees
, data
)
12003 int *walk_subtrees ATTRIBUTE_UNUSED
;
12004 void *data ATTRIBUTE_UNUSED
;
12006 return ((local_variable_p (*tp
) && !DECL_ARTIFICIAL (*tp
))
12007 ? *tp
: NULL_TREE
);
12010 /* Check that ARG, which is a default-argument expression for a
12011 parameter DECL, is legal. Returns ARG, or ERROR_MARK_NODE, if
12012 something goes wrong. DECL may also be a _TYPE node, rather than a
12013 DECL, if there is no DECL available. */
12016 check_default_argument (decl
, arg
)
12023 if (TREE_CODE (arg
) == DEFAULT_ARG
)
12024 /* We get a DEFAULT_ARG when looking at an in-class declaration
12025 with a default argument. Ignore the argument for now; we'll
12026 deal with it after the class is complete. */
12029 if (processing_template_decl
|| uses_template_parms (arg
))
12030 /* We don't do anything checking until instantiation-time. Note
12031 that there may be uninstantiated arguments even for an
12032 instantiated function, since default arguments are not
12033 instantiated until they are needed. */
12042 decl_type
= TREE_TYPE (decl
);
12044 if (arg
== error_mark_node
12045 || decl
== error_mark_node
12046 || TREE_TYPE (arg
) == error_mark_node
12047 || decl_type
== error_mark_node
)
12048 /* Something already went wrong. There's no need to check
12050 return error_mark_node
;
12052 /* [dcl.fct.default]
12054 A default argument expression is implicitly converted to the
12056 if (!TREE_TYPE (arg
)
12057 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
))
12060 cp_error ("default argument for `%#D' has type `%T'",
12061 decl
, TREE_TYPE (arg
));
12063 cp_error ("default argument for parameter of type `%T' has type `%T'",
12064 decl_type
, TREE_TYPE (arg
));
12066 return error_mark_node
;
12069 /* [dcl.fct.default]
12071 Local variables shall not be used in default argument
12074 The keyword `this' shall not be used in a default argument of a
12075 member function. */
12076 var
= walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
,
12080 cp_error ("default argument `%E' uses local variable `%D'",
12082 return error_mark_node
;
12089 /* Decode the list of parameter types for a function type.
12090 Given the list of things declared inside the parens,
12091 return a list of types.
12093 The list we receive can have three kinds of elements:
12094 an IDENTIFIER_NODE for names given without types,
12095 a TREE_LIST node for arguments given as typespecs or names with typespecs,
12096 or void_type_node, to mark the end of an argument list
12097 when additional arguments are not permitted (... was not used).
12099 FUNCDEF_FLAG is nonzero for a function definition, 0 for
12100 a mere declaration. A nonempty identifier-list gets an error message
12101 when FUNCDEF_FLAG is zero.
12102 If FUNCDEF_FLAG is 1, then parameter types must be complete.
12103 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
12105 If all elements of the input list contain types,
12106 we return a list of the types.
12107 If all elements contain no type (except perhaps a void_type_node
12108 at the end), we return a null list.
12109 If some have types and some do not, it is an error, and we
12110 return a null list.
12112 Also set last_function_parms to either
12113 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
12114 A list of names is converted to a chain of PARM_DECLs
12115 by store_parm_decls so that ultimately it is always a chain of decls.
12117 Note that in C++, parameters can take default values. These default
12118 values are in the TREE_PURPOSE field of the TREE_LIST. It is
12119 an error to specify default values which are followed by parameters
12120 that have no default values, or an ELLIPSES. For simplicities sake,
12121 only parameters which are specified with their types can take on
12125 grokparms (first_parm
, funcdef_flag
)
12129 tree result
= NULL_TREE
;
12130 tree decls
= NULL_TREE
;
12132 if (first_parm
!= NULL_TREE
12133 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
12135 if (! funcdef_flag
)
12136 pedwarn ("parameter names (without types) in function declaration");
12137 last_function_parms
= first_parm
;
12140 else if (first_parm
!= NULL_TREE
12141 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
12142 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
12143 my_friendly_abort (145);
12146 /* Types were specified. This is a list of declarators
12147 each represented as a TREE_LIST node. */
12148 register tree parm
, chain
;
12149 int any_init
= 0, any_error
= 0;
12151 if (first_parm
!= NULL_TREE
)
12153 tree last_result
= NULL_TREE
;
12154 tree last_decl
= NULL_TREE
;
12156 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
12158 tree type
= NULL_TREE
, list_node
= parm
;
12159 register tree decl
= TREE_VALUE (parm
);
12160 tree init
= TREE_PURPOSE (parm
);
12162 chain
= TREE_CHAIN (parm
);
12163 /* @@ weak defense against parse errors. */
12164 if (TREE_CODE (decl
) != VOID_TYPE
12165 && TREE_CODE (decl
) != TREE_LIST
)
12167 /* Give various messages as the need arises. */
12168 if (TREE_CODE (decl
) == STRING_CST
)
12169 cp_error ("invalid string constant `%E'", decl
);
12170 else if (TREE_CODE (decl
) == INTEGER_CST
)
12171 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12175 if (TREE_CODE (decl
) != VOID_TYPE
)
12177 decl
= grokdeclarator (TREE_VALUE (decl
),
12178 TREE_PURPOSE (decl
),
12179 PARM
, init
!= NULL_TREE
,
12181 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
12184 /* Top-level qualifiers on the parameters are
12185 ignored for function types. */
12186 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
12188 if (TREE_CODE (type
) == VOID_TYPE
)
12189 decl
= void_type_node
;
12190 else if (TREE_CODE (type
) == METHOD_TYPE
)
12192 if (DECL_NAME (decl
))
12193 /* Cannot use the decl here because
12194 we don't have DECL_CONTEXT set up yet. */
12195 cp_error ("parameter `%D' invalidly declared method type",
12198 error ("parameter invalidly declared method type");
12199 type
= build_pointer_type (type
);
12200 TREE_TYPE (decl
) = type
;
12202 else if (TREE_CODE (type
) == OFFSET_TYPE
)
12204 if (DECL_NAME (decl
))
12205 cp_error ("parameter `%D' invalidly declared offset type",
12208 error ("parameter invalidly declared offset type");
12209 type
= build_pointer_type (type
);
12210 TREE_TYPE (decl
) = type
;
12212 else if (abstract_virtuals_error (decl
, type
))
12213 any_error
= 1; /* Seems like a good idea. */
12214 else if (POINTER_TYPE_P (type
))
12217 while (POINTER_TYPE_P (t
)
12218 || (TREE_CODE (t
) == ARRAY_TYPE
12219 && TYPE_DOMAIN (t
) != NULL_TREE
))
12221 if (TREE_CODE (t
) == ARRAY_TYPE
)
12222 cp_error ("parameter type `%T' includes %s to array of unknown bound",
12224 TYPE_PTR_P (type
) ? "pointer" : "reference");
12228 if (TREE_CODE (decl
) == VOID_TYPE
)
12230 if (result
== NULL_TREE
)
12232 result
= void_list_node
;
12233 last_result
= result
;
12237 TREE_CHAIN (last_result
) = void_list_node
;
12238 last_result
= void_list_node
;
12241 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
12242 error ("`void' in parameter list must be entire list");
12246 /* Since there is a prototype, args are passed in their own types. */
12247 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
12248 if (PROMOTE_PROTOTYPES
12249 && (TREE_CODE (type
) == INTEGER_TYPE
12250 || TREE_CODE (type
) == ENUMERAL_TYPE
)
12251 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
12252 DECL_ARG_TYPE (decl
) = integer_type_node
;
12253 if (!any_error
&& init
)
12256 init
= check_default_argument (decl
, init
);
12261 if (decls
== NULL_TREE
)
12268 TREE_CHAIN (last_decl
) = decl
;
12271 list_node
= tree_cons (init
, type
, NULL_TREE
);
12272 if (result
== NULL_TREE
)
12274 result
= list_node
;
12275 last_result
= result
;
12279 TREE_CHAIN (last_result
) = list_node
;
12280 last_result
= list_node
;
12284 TREE_CHAIN (last_result
) = NULL_TREE
;
12285 /* If there are no parameters, and the function does not end
12286 with `...', then last_decl will be NULL_TREE. */
12287 if (last_decl
!= NULL_TREE
)
12288 TREE_CHAIN (last_decl
) = NULL_TREE
;
12292 last_function_parms
= decls
;
12297 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12298 FUNCTION_TYPE with the newly parsed version of its default argument, which
12299 was previously digested as text. See snarf_defarg et al in lex.c. */
12302 replace_defarg (arg
, init
)
12305 if (! processing_template_decl
12306 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
12307 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12308 TREE_TYPE (init
), TREE_VALUE (arg
));
12309 TREE_PURPOSE (arg
) = init
;
12312 /* D is a constructor or overloaded `operator='. Returns non-zero if
12313 D's arguments allow it to be a copy constructor, or copy assignment
12322 if (!DECL_FUNCTION_MEMBER_P (d
))
12325 t
= FUNCTION_ARG_CHAIN (d
);
12326 if (DECL_CONSTRUCTOR_P (d
) && DECL_HAS_IN_CHARGE_PARM_P (d
))
12327 t
= TREE_CHAIN (t
);
12328 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
12329 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
12330 == DECL_CONTEXT (d
))
12331 && (TREE_CHAIN (t
) == NULL_TREE
12332 || TREE_CHAIN (t
) == void_list_node
12333 || TREE_PURPOSE (TREE_CHAIN (t
))))
12338 /* These memoizing functions keep track of special properties which
12339 a class may have. `grok_ctor_properties' notices whether a class
12340 has a constructor of the form X(X&), and also complains
12341 if the class has a constructor of the form X(X).
12342 `grok_op_properties' takes notice of the various forms of
12343 operator= which are defined, as well as what sorts of type conversion
12344 may apply. Both functions take a FUNCTION_DECL as an argument. */
12347 grok_ctor_properties (ctype
, decl
)
12350 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
12351 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
12353 /* When a type has virtual baseclasses, a magical first int argument is
12354 added to any ctor so we can tell if the class has been initialized
12355 yet. This could screw things up in this function, so we deliberately
12356 ignore the leading int if we're in that situation. */
12357 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
12359 my_friendly_assert (parmtypes
12360 && TREE_VALUE (parmtypes
) == integer_type_node
,
12362 parmtypes
= TREE_CHAIN (parmtypes
);
12363 parmtype
= TREE_VALUE (parmtypes
);
12368 A non-template constructor for class X is a copy constructor if
12369 its first parameter is of type X&, const X&, volatile X& or const
12370 volatile X&, and either there are no other parameters or else all
12371 other parameters have default arguments. */
12372 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
12373 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
12374 && (TREE_CHAIN (parmtypes
) == NULL_TREE
12375 || TREE_CHAIN (parmtypes
) == void_list_node
12376 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
12377 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12378 && is_member_template (DECL_TI_TEMPLATE (decl
))))
12380 TYPE_HAS_INIT_REF (ctype
) = 1;
12381 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
12382 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
12386 A declaration of a constructor for a class X is ill-formed if its
12387 first parameter is of type (optionally cv-qualified) X and either
12388 there are no other parameters or else all other parameters have
12391 We *don't* complain about member template instantiations that
12392 have this form, though; they can occur as we try to decide what
12393 constructor to use during overload resolution. Since overload
12394 resolution will never prefer such a constructor to the
12395 non-template copy constructor (which is either explicitly or
12396 implicitly defined), there's no need to worry about their
12397 existence. Theoretically, they should never even be
12398 instantiated, but that's hard to forestall. */
12399 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
12400 && (TREE_CHAIN (parmtypes
) == NULL_TREE
12401 || TREE_CHAIN (parmtypes
) == void_list_node
12402 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
12403 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12404 && is_member_template (DECL_TI_TEMPLATE (decl
))))
12406 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12408 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
12411 else if (TREE_CODE (parmtype
) == VOID_TYPE
12412 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
12413 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
12418 /* An operator with this code is unary, but can also be binary. */
12422 enum tree_code code
;
12424 return (code
== INDIRECT_REF
12425 || code
== ADDR_EXPR
12426 || code
== CONVERT_EXPR
12427 || code
== NEGATE_EXPR
12428 || code
== PREINCREMENT_EXPR
12429 || code
== PREDECREMENT_EXPR
);
12432 /* An operator with this name can only be unary. */
12436 enum tree_code code
;
12438 return (code
== TRUTH_NOT_EXPR
12439 || code
== BIT_NOT_EXPR
12440 || code
== COMPONENT_REF
12441 || code
== TYPE_EXPR
);
12444 /* Do a little sanity-checking on how they declared their operator. */
12447 grok_op_properties (decl
, virtualp
, friendp
)
12449 int virtualp
, friendp
;
12451 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
12453 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
12454 tree name
= DECL_NAME (decl
);
12455 enum tree_code operator_code
;
12458 /* Count the number of arguments. */
12459 for (argtype
= argtypes
, arity
= 0;
12460 argtype
&& argtype
!= void_list_node
;
12461 argtype
= TREE_CHAIN (argtype
))
12464 if (current_class_type
== NULL_TREE
)
12467 if (DECL_CONV_FN_P (decl
))
12468 operator_code
= TYPE_EXPR
;
12472 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P) \
12473 if (ansi_opname (CODE) == name) \
12475 operator_code = CODE; \
12478 else if (ansi_assopname (CODE) == name) \
12480 operator_code = CODE; \
12481 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12485 #include "operators.def"
12486 #undef DEF_OPERATOR
12488 my_friendly_abort (20000527);
12491 my_friendly_assert (operator_code
!= LAST_CPLUS_TREE_CODE
, 20000526);
12492 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12496 switch (operator_code
)
12499 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
12503 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
12506 case COMPONENT_REF
:
12508 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
12512 TYPE_HAS_NEW_OPERATOR (current_class_type
) = 1;
12516 TYPE_GETS_DELETE (current_class_type
) |= 1;
12520 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type
) = 1;
12523 case VEC_DELETE_EXPR
:
12524 TYPE_GETS_DELETE (current_class_type
) |= 2;
12532 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
12534 /* When the compiler encounters the definition of A::operator new, it
12535 doesn't look at the class declaration to find out if it's static. */
12537 revert_static_member_fn (decl
);
12539 /* Take care of function decl if we had syntax errors. */
12540 if (argtypes
== NULL_TREE
)
12542 = build_function_type (ptr_type_node
,
12543 hash_tree_chain (integer_type_node
,
12546 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
12548 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12551 revert_static_member_fn (decl
);
12553 if (argtypes
== NULL_TREE
)
12555 = build_function_type (void_type_node
,
12556 hash_tree_chain (ptr_type_node
,
12559 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
12563 /* An operator function must either be a non-static member function
12564 or have at least one parameter of a class, a reference to a class,
12565 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12566 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
12568 if (operator_code
== TYPE_EXPR
12569 || operator_code
== CALL_EXPR
12570 || operator_code
== COMPONENT_REF
12571 || operator_code
== ARRAY_REF
12572 || operator_code
== NOP_EXPR
)
12573 cp_error ("`%D' must be a nonstatic member function", decl
);
12578 if (DECL_STATIC_FUNCTION_P (decl
))
12579 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
12582 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
12584 tree arg
= TREE_VALUE (p
);
12585 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
12586 arg
= TREE_TYPE (arg
);
12588 /* This lets bad template code slip through. */
12589 if (IS_AGGR_TYPE (arg
)
12590 || TREE_CODE (arg
) == ENUMERAL_TYPE
12591 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
12592 || TREE_CODE (arg
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12596 ("`%D' must have an argument of class or enumerated type",
12603 if (operator_code
== CALL_EXPR
)
12604 return; /* No restrictions on args. */
12606 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
12608 tree t
= TREE_TYPE (name
);
12611 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
12612 const char *what
= 0;
12615 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
12617 if (TREE_CODE (t
) == VOID_TYPE
)
12619 else if (t
== current_class_type
)
12620 what
= "the same type";
12621 /* Don't force t to be complete here. */
12622 else if (IS_AGGR_TYPE (t
)
12623 && COMPLETE_TYPE_P (t
)
12624 && DERIVED_FROM_P (t
, current_class_type
))
12625 what
= "a base class";
12628 warning ("conversion to %s%s will never use a type conversion operator",
12629 ref
? "a reference to " : "", what
);
12633 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
12634 && operator_code
== NOP_EXPR
)
12638 if (arity
!= 2 && methodp
)
12640 cp_error ("`%D' must take exactly one argument", decl
);
12643 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
12647 A user-declared copy assignment operator X::operator= is
12648 a non-static non-template member function of class X with
12649 exactly one parameter of type X, X&, const X&, volatile
12650 X& or const volatile X&. */
12651 if (copy_assignment_arg_p (parmtype
, virtualp
)
12652 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12653 && is_member_template (DECL_TI_TEMPLATE (decl
)))
12656 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
12657 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
12658 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
12659 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
12662 else if (operator_code
== COND_EXPR
)
12665 cp_error ("ISO C++ prohibits overloading operator ?:");
12667 else if (ambi_op_p (operator_code
))
12670 /* We pick the one-argument operator codes by default, so
12671 we don't have to change anything. */
12673 else if (arity
== 2)
12675 /* If we thought this was a unary operator, we now know
12676 it to be a binary operator. */
12677 switch (operator_code
)
12680 operator_code
= MULT_EXPR
;
12684 operator_code
= BIT_AND_EXPR
;
12688 operator_code
= PLUS_EXPR
;
12692 operator_code
= MINUS_EXPR
;
12695 case PREINCREMENT_EXPR
:
12696 operator_code
= POSTINCREMENT_EXPR
;
12699 case PREDECREMENT_EXPR
:
12700 operator_code
= POSTDECREMENT_EXPR
;
12704 my_friendly_abort (20000527);
12707 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12709 if ((operator_code
== POSTINCREMENT_EXPR
12710 || operator_code
== POSTDECREMENT_EXPR
)
12711 && ! processing_template_decl
12712 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12715 cp_error ("postfix `%D' must take `int' as its argument",
12719 ("postfix `%D' must take `int' as its second argument",
12726 cp_error ("`%D' must take either zero or one argument", decl
);
12728 cp_error ("`%D' must take either one or two arguments", decl
);
12731 /* More Effective C++ rule 6. */
12733 && (operator_code
== POSTINCREMENT_EXPR
12734 || operator_code
== POSTDECREMENT_EXPR
12735 || operator_code
== PREINCREMENT_EXPR
12736 || operator_code
== PREDECREMENT_EXPR
))
12738 tree arg
= TREE_VALUE (argtypes
);
12739 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12740 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12741 arg
= TREE_TYPE (arg
);
12742 arg
= TYPE_MAIN_VARIANT (arg
);
12743 if (operator_code
== PREINCREMENT_EXPR
12744 || operator_code
== PREDECREMENT_EXPR
)
12746 if (TREE_CODE (ret
) != REFERENCE_TYPE
12747 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12749 cp_warning ("prefix `%D' should return `%T'", decl
,
12750 build_reference_type (arg
));
12754 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12755 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
12759 else if (unary_op_p (operator_code
))
12764 cp_error ("`%D' must take `void'", decl
);
12766 cp_error ("`%D' must take exactly one argument", decl
);
12769 else /* if (binary_op_p (operator_code)) */
12774 cp_error ("`%D' must take exactly one argument", decl
);
12776 cp_error ("`%D' must take exactly two arguments", decl
);
12779 /* More Effective C++ rule 7. */
12781 && (operator_code
== TRUTH_ANDIF_EXPR
12782 || operator_code
== TRUTH_ORIF_EXPR
12783 || operator_code
== COMPOUND_EXPR
))
12784 cp_warning ("user-defined `%D' always evaluates both arguments",
12788 /* Effective C++ rule 23. */
12791 && (operator_code
== PLUS_EXPR
12792 || operator_code
== MINUS_EXPR
12793 || operator_code
== TRUNC_DIV_EXPR
12794 || operator_code
== MULT_EXPR
)
12795 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12796 cp_warning ("`%D' should return by value", decl
);
12799 for (; argtypes
&& argtypes
!= void_list_node
;
12800 argtypes
= TREE_CHAIN (argtypes
))
12801 if (TREE_PURPOSE (argtypes
))
12803 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12804 if (operator_code
== POSTINCREMENT_EXPR
12805 || operator_code
== POSTDECREMENT_EXPR
)
12808 cp_pedwarn ("`%D' cannot have default arguments", decl
);
12811 cp_error ("`%D' cannot have default arguments", decl
);
12817 static const char *
12819 enum tag_types code
;
12832 my_friendly_abort (981122);
12836 /* Get the struct, enum or union (CODE says which) with tag NAME.
12837 Define the tag as a forward-reference if it is not defined.
12839 C++: If a class derivation is given, process it here, and report
12840 an error if multiple derivation declarations are not identical.
12842 If this is a definition, come in through xref_tag and only look in
12843 the current frame for the name (since C++ allows new names in any
12847 xref_tag (code_type_node
, name
, globalize
)
12848 tree code_type_node
;
12852 enum tag_types tag_code
;
12853 enum tree_code code
;
12854 register tree ref
, t
;
12855 struct binding_level
*b
= current_binding_level
;
12857 tree attributes
= NULL_TREE
;
12858 tree context
= NULL_TREE
;
12860 /* If we are called from the parser, code_type_node will sometimes be a
12861 TREE_LIST. This indicates that the user wrote
12862 "class __attribute__ ((foo)) bar". Extract the attributes so we can
12864 if (TREE_CODE (code_type_node
) == TREE_LIST
)
12866 attributes
= TREE_PURPOSE (code_type_node
);
12867 code_type_node
= TREE_VALUE (code_type_node
);
12870 tag_code
= (enum tag_types
) tree_low_cst (code_type_node
, 1);
12875 code
= RECORD_TYPE
;
12881 code
= ENUMERAL_TYPE
;
12884 my_friendly_abort (18);
12887 /* If a cross reference is requested, look up the type
12888 already defined for this tag and return it. */
12892 name
= TYPE_IDENTIFIER (t
);
12896 t
= IDENTIFIER_TYPE_VALUE (name
);
12898 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
12899 && TREE_CODE (t
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
12904 /* If we know we are defining this tag, only look it up in
12905 this scope and don't try to find it as a type. */
12906 ref
= lookup_tag (code
, name
, b
, 1);
12912 /* [dcl.type.elab] If the identifier resolves to a
12913 typedef-name or a template type-parameter, the
12914 elaborated-type-specifier is ill-formed. */
12915 if (t
!= TYPE_MAIN_VARIANT (t
)
12916 || (CLASS_TYPE_P (t
) && TYPE_WAS_ANONYMOUS (t
)))
12917 cp_pedwarn ("using typedef-name `%D' after `%s'",
12918 TYPE_NAME (t
), tag_name (tag_code
));
12919 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
12920 cp_error ("using template type parameter `%T' after `%s'",
12921 t
, tag_name (tag_code
));
12926 ref
= lookup_tag (code
, name
, b
, 0);
12930 /* Try finding it as a type declaration. If that wins,
12932 ref
= lookup_name (name
, 1);
12934 if (ref
!= NULL_TREE
12935 && processing_template_decl
12936 && DECL_CLASS_TEMPLATE_P (ref
)
12937 && template_class_depth (current_class_type
) == 0)
12938 /* Since GLOBALIZE is true, we're declaring a global
12939 template, so we want this type. */
12940 ref
= DECL_TEMPLATE_RESULT (ref
);
12942 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
12943 && TREE_CODE (TREE_TYPE (ref
)) == code
)
12944 ref
= TREE_TYPE (ref
);
12949 if (ref
&& current_class_type
12950 && template_class_depth (current_class_type
)
12951 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12953 /* Since GLOBALIZE is non-zero, we are not looking at a
12954 definition of this tag. Since, in addition, we are currently
12955 processing a (member) template declaration of a template
12956 class, we must be very careful; consider:
12963 { template <class V>
12964 friend struct S1; };
12966 Here, the S2::S1 declaration should not be confused with the
12967 outer declaration. In particular, the inner version should
12968 have a template parameter of level 2, not level 1. This
12969 would be particularly important if the member declaration
12972 template <class V = U> friend struct S1;
12974 say, when we should tsubst into `U' when instantiating
12975 S2. On the other hand, when presented with:
12985 we must find the inner binding eventually. We
12986 accomplish this by making sure that the new type we
12987 create to represent this declaration has the right
12989 context
= TYPE_CONTEXT (ref
);
12996 /* If no such tag is yet defined, create a forward-reference node
12997 and record it as the "definition".
12998 When a real declaration of this type is found,
12999 the forward-reference will be altered into a real type. */
13000 if (code
== ENUMERAL_TYPE
)
13002 cp_error ("use of enum `%#D' without previous declaration", name
);
13004 ref
= make_node (ENUMERAL_TYPE
);
13006 /* Give the type a default layout like unsigned int
13007 to avoid crashing if it does not get defined. */
13008 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
13009 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
13010 TYPE_USER_ALIGN (ref
) = 0;
13011 TREE_UNSIGNED (ref
) = 1;
13012 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
13013 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
13014 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
13016 /* Enable us to recognize when a type is created in class context.
13017 To do nested classes correctly, this should probably be cleared
13018 out when we leave this classes scope. Currently this in only
13019 done in `start_enum'. */
13021 pushtag (name
, ref
, globalize
);
13025 struct binding_level
*old_b
= class_binding_level
;
13027 ref
= make_aggr_type (code
);
13028 TYPE_CONTEXT (ref
) = context
;
13030 #ifdef NONNESTED_CLASSES
13031 /* Class types don't nest the way enums do. */
13032 class_binding_level
= (struct binding_level
*)0;
13034 pushtag (name
, ref
, globalize
);
13035 class_binding_level
= old_b
;
13040 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
13041 redeclare_class_template (ref
, current_template_parms
);
13044 /* Until the type is defined, tentatively accept whatever
13045 structure tag the user hands us. */
13046 if (!COMPLETE_TYPE_P (ref
)
13047 && ref
!= current_class_type
13048 /* Have to check this, in case we have contradictory tag info. */
13049 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
13051 if (tag_code
== class_type
)
13052 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
13053 else if (tag_code
== record_type
)
13054 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
13057 TREE_TYPE (ref
) = attributes
;
13063 xref_tag_from_type (old
, id
, globalize
)
13067 tree code_type_node
;
13069 if (TREE_CODE (old
) == RECORD_TYPE
)
13070 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
13071 ? class_type_node
: record_type_node
);
13073 code_type_node
= union_type_node
;
13075 if (id
== NULL_TREE
)
13076 id
= TYPE_IDENTIFIER (old
);
13078 return xref_tag (code_type_node
, id
, globalize
);
13081 /* REF is a type (named NAME), for which we have just seen some
13082 baseclasses. BINFO is a list of those baseclasses; the
13083 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
13084 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
13085 struct, or union. */
13088 xref_basetypes (code_type_node
, name
, ref
, binfo
)
13089 tree code_type_node
;
13093 /* In the declaration `A : X, Y, ... Z' we mark all the types
13094 (A, X, Y, ..., Z) so we can check for duplicates. */
13099 enum tag_types tag_code
= (enum tag_types
) tree_low_cst (code_type_node
, 1);
13101 if (tag_code
== union_type
)
13103 cp_error ("derived union `%T' invalid", ref
);
13107 len
= list_length (binfo
);
13109 /* First, make sure that any templates in base-classes are
13110 instantiated. This ensures that if we call ourselves recursively
13111 we do not get confused about which classes are marked and which
13113 for (base
= binfo
; base
; base
= TREE_CHAIN (base
))
13114 complete_type (TREE_VALUE (base
));
13116 SET_CLASSTYPE_MARKED (ref
);
13117 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
13119 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
13121 /* The base of a derived struct is public by default. */
13123 = (TREE_PURPOSE (binfo
) == access_public_node
13124 || TREE_PURPOSE (binfo
) == access_public_virtual_node
13125 || (tag_code
!= class_type
13126 && (TREE_PURPOSE (binfo
) == access_default_node
13127 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
13129 = (TREE_PURPOSE (binfo
) == access_protected_node
13130 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
13132 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
13133 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
13134 || TREE_PURPOSE (binfo
) == access_public_virtual_node
13135 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
13136 tree basetype
= TREE_VALUE (binfo
);
13139 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
13140 basetype
= TREE_TYPE (basetype
);
13142 || (TREE_CODE (basetype
) != RECORD_TYPE
13143 && TREE_CODE (basetype
) != TYPENAME_TYPE
13144 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
13145 && TREE_CODE (basetype
) != BOUND_TEMPLATE_TEMPLATE_PARM
))
13147 cp_error ("base type `%T' fails to be a struct or class type",
13148 TREE_VALUE (binfo
));
13152 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
13154 /* This code replaces similar code in layout_basetypes.
13155 We put the complete_type first for implicit `typename'. */
13156 if (!COMPLETE_TYPE_P (basetype
)
13157 && ! (current_template_parms
&& uses_template_parms (basetype
)))
13159 cp_error ("base class `%T' has incomplete type", basetype
);
13164 if (CLASSTYPE_MARKED (basetype
))
13166 if (basetype
== ref
)
13167 cp_error ("recursive type `%T' undefined", basetype
);
13169 cp_error ("duplicate base type `%T' invalid", basetype
);
13173 if (TYPE_FOR_JAVA (basetype
)
13174 && (current_lang_stack
13175 == &VARRAY_TREE (current_lang_base
, 0)))
13176 TYPE_FOR_JAVA (ref
) = 1;
13178 /* Note that the BINFO records which describe individual
13179 inheritances are *not* shared in the lattice! They
13180 cannot be shared because a given baseclass may be
13181 inherited with different `accessibility' by different
13182 derived classes. (Each BINFO record describing an
13183 individual inheritance contains flags which say what
13184 the `accessibility' of that particular inheritance is.) */
13187 = make_binfo (size_zero_node
, basetype
,
13188 CLASS_TYPE_P (basetype
)
13189 ? TYPE_BINFO_VTABLE (basetype
) : NULL_TREE
,
13190 CLASS_TYPE_P (basetype
)
13191 ? TYPE_BINFO_VIRTUALS (basetype
) : NULL_TREE
);
13193 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
13194 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
13195 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
13196 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
13197 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
13199 /* We need to unshare the binfos now so that lookups during class
13200 definition work. */
13201 unshare_base_binfos (base_binfo
);
13203 SET_CLASSTYPE_MARKED (basetype
);
13205 /* We are free to modify these bits because they are meaningless
13206 at top level, and BASETYPE is a top-level type. */
13207 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
13209 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
13210 /* Converting to a virtual base class requires looking
13211 up the offset of the virtual base. */
13212 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
13215 if (CLASS_TYPE_P (basetype
))
13217 TYPE_HAS_NEW_OPERATOR (ref
)
13218 |= TYPE_HAS_NEW_OPERATOR (basetype
);
13219 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
13220 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
13221 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
13222 /* If the base-class uses multiple inheritance, so do we. */
13223 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
13224 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype
);
13225 /* Likewise, if converting to a base of the base may require
13226 code, then we may need to generate code to convert to a
13228 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
)
13229 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype
);
13236 TREE_VEC_LENGTH (binfos
) = i
;
13238 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
13242 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
13243 /* If there is more than one non-empty they cannot be at the same
13245 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
13248 /* Unmark all the types. */
13250 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
13251 CLEAR_CLASSTYPE_MARKED (ref
);
13253 /* Now that we know all the base-classes, set up the list of virtual
13255 get_vbase_types (ref
);
13259 /* Begin compiling the definition of an enumeration type.
13260 NAME is its name (or null if anonymous).
13261 Returns the type object, as yet incomplete.
13262 Also records info about it so that build_enumerator
13263 may be used to declare the individual values as they are read. */
13269 register tree enumtype
= NULL_TREE
;
13270 struct binding_level
*b
= current_binding_level
;
13272 /* If this is the real definition for a previous forward reference,
13273 fill in the contents in the same object that used to be the
13274 forward reference. */
13276 if (name
!= NULL_TREE
)
13277 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
13279 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
13281 cp_error ("multiple definition of `%#T'", enumtype
);
13282 cp_error_at ("previous definition here", enumtype
);
13283 /* Clear out TYPE_VALUES, and start again. */
13284 TYPE_VALUES (enumtype
) = NULL_TREE
;
13288 enumtype
= make_node (ENUMERAL_TYPE
);
13289 pushtag (name
, enumtype
, 0);
13292 if (current_class_type
)
13293 TREE_ADDRESSABLE (b
->tags
) = 1;
13295 GNU_xref_decl (current_function_decl
, enumtype
);
13299 /* After processing and defining all the values of an enumeration type,
13300 install their decls in the enumeration type and finish it off.
13301 ENUMTYPE is the type object and VALUES a list of name-value pairs.
13302 Returns ENUMTYPE. */
13305 finish_enum (enumtype
)
13308 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
13309 /* Calculate the maximum value of any enumerator in this type. */
13311 tree values
= TYPE_VALUES (enumtype
);
13316 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
13321 /* The TREE_VALUE is a CONST_DECL for this enumeration
13323 decl
= TREE_VALUE (pair
);
13327 Following the closing brace of an enum-specifier, each
13328 enumerator has the type of its enumeration. Prior to the
13329 closing brace, the type of each enumerator is the type of
13330 its initializing value. */
13331 TREE_TYPE (decl
) = enumtype
;
13333 /* The DECL_INITIAL will be NULL if we are processing a
13334 template declaration and this enumeration constant had no
13335 explicit initializer. */
13336 value
= DECL_INITIAL (decl
);
13337 if (value
&& !processing_template_decl
)
13339 /* Set the TREE_TYPE for the VALUE as well. That's so
13340 that when we call decl_constant_value we get an
13341 entity of the right type (but with the constant
13342 value). Since we shouldn't ever call
13343 decl_constant_value on a template type, there's no
13344 reason to do that when processing_template_decl.
13345 And, if the expression is something like a
13346 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13347 wreak havoc on the intended type of the expression.
13349 Of course, there's also no point in trying to compute
13350 minimum or maximum values if we're in a template. */
13351 TREE_TYPE (value
) = enumtype
;
13354 minnode
= maxnode
= value
;
13355 else if (tree_int_cst_lt (maxnode
, value
))
13357 else if (tree_int_cst_lt (value
, minnode
))
13361 if (processing_template_decl
)
13362 /* If this is just a template, leave the CONST_DECL
13363 alone. That way tsubst_copy will find CONST_DECLs for
13364 CONST_DECLs, and not INTEGER_CSTs. */
13367 /* In the list we're building up, we want the enumeration
13368 values, not the CONST_DECLs. */
13369 TREE_VALUE (pair
) = value
;
13373 maxnode
= minnode
= integer_zero_node
;
13375 TYPE_VALUES (enumtype
) = nreverse (values
);
13377 if (processing_template_decl
)
13379 tree scope
= current_scope ();
13380 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
13381 add_stmt (build_min (TAG_DEFN
, enumtype
));
13385 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
13386 int lowprec
= min_precision (minnode
, unsignedp
);
13387 int highprec
= min_precision (maxnode
, unsignedp
);
13388 int precision
= MAX (lowprec
, highprec
);
13391 TYPE_SIZE (enumtype
) = NULL_TREE
;
13393 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
13395 TYPE_PRECISION (enumtype
) = precision
;
13397 fixup_unsigned_type (enumtype
);
13399 fixup_signed_type (enumtype
);
13401 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
13402 /* Use the width of the narrowest normal C type which is wide
13404 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
13407 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
13409 TYPE_SIZE (enumtype
) = 0;
13410 layout_type (enumtype
);
13412 /* Fix up all variant types of this enum type. */
13413 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
13414 tem
= TYPE_NEXT_VARIANT (tem
))
13416 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
13417 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
13418 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
13419 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
13420 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
13421 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
13422 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
13423 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
13424 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
13425 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
13428 /* Finish debugging output for this type. */
13429 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13435 /* Build and install a CONST_DECL for an enumeration constant of the
13436 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13437 Assignment of sequential values by default is handled here. */
13440 build_enumerator (name
, value
, enumtype
)
13450 /* Remove no-op casts from the value. */
13452 STRIP_TYPE_NOPS (value
);
13454 if (! processing_template_decl
)
13456 /* Validate and default VALUE. */
13457 if (value
!= NULL_TREE
)
13459 value
= decl_constant_value (value
);
13461 if (TREE_CODE (value
) == INTEGER_CST
)
13463 value
= default_conversion (value
);
13464 constant_expression_warning (value
);
13468 cp_error ("enumerator value for `%D' not integer constant", name
);
13473 /* Default based on previous value. */
13474 if (value
== NULL_TREE
&& ! processing_template_decl
)
13478 if (TYPE_VALUES (enumtype
))
13480 /* The next value is the previous value ... */
13481 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13482 /* ... plus one. */
13483 value
= cp_build_binary_op (PLUS_EXPR
,
13487 if (tree_int_cst_lt (value
, prev_value
))
13488 cp_error ("overflow in enumeration values at `%D'", name
);
13491 value
= integer_zero_node
;
13494 /* Remove no-op casts from the value. */
13496 STRIP_TYPE_NOPS (value
);
13498 /* To fix MAX_VAL enum consts. (bkoz) */
13499 TREE_TYPE (value
) = integer_type_node
;
13503 /* We always have to copy here; not all INTEGER_CSTs are unshared.
13504 Even in other cases, we will later (in finish_enum) be setting
13505 the type of VALUE. But, we don't need to make a copy if this
13506 VALUE is one of the enumeration constants for this same
13507 enumeration type. */
13508 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
13509 if (TREE_VALUE (values
) == value
)
13511 /* If we didn't break out of the loop, then we do need a copy. */
13512 if (!values
&& value
)
13513 value
= copy_node (value
);
13515 /* C++ associates enums with global, function, or class declarations. */
13516 context
= current_scope ();
13518 /* Build the actual enumeration constant. Note that the enumeration
13519 constants have the type of their initializers until the
13520 enumeration is complete:
13524 Following the closing brace of an enum-specifier, each enumer-
13525 ator has the type of its enumeration. Prior to the closing
13526 brace, the type of each enumerator is the type of its
13527 initializing value.
13529 In finish_enum we will reset the type. Of course, if we're
13530 processing a template, there may be no value. */
13531 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13533 if (context
&& context
== current_class_type
)
13534 /* This enum declaration is local to the class. We need the full
13535 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
13536 decl
= build_lang_decl (CONST_DECL
, name
, type
);
13538 /* It's a global enum, or it's local to a function. (Note local to
13539 a function could mean local to a class method. */
13540 decl
= build_decl (CONST_DECL
, name
, type
);
13542 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
13543 DECL_INITIAL (decl
) = value
;
13544 TREE_READONLY (decl
) = 1;
13546 if (context
&& context
== current_class_type
)
13547 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13548 on the TYPE_FIELDS list for `S'. (That's so that you can say
13549 things like `S::i' later.) */
13550 finish_member_declaration (decl
);
13554 GNU_xref_decl (current_function_decl
, decl
);
13557 /* Add this enumeration constant to the list for this type. */
13558 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13562 /* We're defining DECL. Make sure that it's type is OK. */
13565 check_function_type (decl
, current_function_parms
)
13567 tree current_function_parms
;
13569 tree fntype
= TREE_TYPE (decl
);
13570 tree return_type
= complete_type (TREE_TYPE (fntype
));
13572 /* In a function definition, arg types must be complete. */
13573 require_complete_types_for_parms (current_function_parms
);
13575 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13577 cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype
));
13579 /* Make it return void instead, but don't change the
13580 type of the DECL_RESULT, in case we have a named return value. */
13581 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13583 tree ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
)));
13585 = build_cplus_method_type (ctype
,
13587 FUNCTION_ARG_CHAIN (decl
));
13591 = build_function_type (void_type_node
,
13592 TYPE_ARG_TYPES (TREE_TYPE (decl
)));
13594 = build_exception_variant (fntype
,
13595 TYPE_RAISES_EXCEPTIONS (fntype
));
13598 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13601 /* Create the FUNCTION_DECL for a function definition.
13602 DECLSPECS and DECLARATOR are the parts of the declaration;
13603 they describe the function's name and the type it returns,
13604 but twisted together in a fashion that parallels the syntax of C.
13606 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13607 DECLARATOR is really the DECL for the function we are about to
13608 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13609 indicating that the function is an inline defined in-class.
13611 This function creates a binding context for the function body
13612 as well as setting up the FUNCTION_DECL in current_function_decl.
13614 Returns 1 on success. If the DECLARATOR is not suitable for a function
13615 (it defines a datum instead), we return 0, which tells
13616 yyparse to report a parse error.
13618 For C++, we must first check whether that datum makes any sense.
13619 For example, "class A local_a(1,2);" means that variable local_a
13620 is an aggregate of type A, which should have a constructor
13621 applied to it with the argument list [1, 2]. */
13624 start_function (declspecs
, declarator
, attrs
, flags
)
13625 tree declspecs
, declarator
, attrs
;
13629 tree ctype
= NULL_TREE
;
13632 extern int have_extern_spec
;
13633 extern int used_extern_spec
;
13634 int doing_friend
= 0;
13635 struct binding_level
*bl
;
13636 tree current_function_parms
;
13638 /* Sanity check. */
13639 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
13640 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
13642 /* This should only be done once on the top most decl. */
13643 if (have_extern_spec
&& !used_extern_spec
)
13645 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
13646 used_extern_spec
= 1;
13649 if (flags
& SF_PRE_PARSED
)
13651 decl1
= declarator
;
13653 fntype
= TREE_TYPE (decl1
);
13654 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13655 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13657 /* ISO C++ 11.4/5. A friend function defined in a class is in
13658 the (lexical) scope of the class in which it is defined. */
13659 if (!ctype
&& DECL_FRIEND_P (decl1
))
13661 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13663 /* CTYPE could be null here if we're dealing with a template;
13664 for example, `inline friend float foo()' inside a template
13665 will have no CTYPE set. */
13666 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13672 last_function_parms
= DECL_ARGUMENTS (decl1
);
13673 last_function_parm_tags
= NULL_TREE
;
13677 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
13678 /* If the declarator is not suitable for a function definition,
13679 cause a syntax error. */
13680 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
13682 fntype
= TREE_TYPE (decl1
);
13684 restype
= TREE_TYPE (fntype
);
13685 if (CLASS_TYPE_P (restype
) && !CLASSTYPE_GOT_SEMICOLON (restype
))
13687 cp_error ("semicolon missing after declaration of `%#T'", restype
);
13688 shadow_tag (build_tree_list (NULL_TREE
, restype
));
13689 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
13690 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
13691 fntype
= build_function_type (integer_type_node
,
13692 TYPE_ARG_TYPES (fntype
));
13694 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
13696 TYPE_ARG_TYPES (fntype
));
13697 TREE_TYPE (decl1
) = fntype
;
13700 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13701 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13702 else if (DECL_MAIN_P (decl1
))
13704 /* If this doesn't return integer_type, complain. */
13705 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
13707 if (pedantic
|| warn_return_type
)
13708 pedwarn ("return type for `main' changed to `int'");
13709 TREE_TYPE (decl1
) = fntype
= default_function_type
;
13714 /* Sometimes we don't notice that a function is a static member, and
13715 build a METHOD_TYPE for it. Fix that up now. */
13716 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13717 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
)
13719 revert_static_member_fn (decl1
);
13720 last_function_parms
= TREE_CHAIN (last_function_parms
);
13724 /* Warn if function was previously implicitly declared
13725 (but not if we warned then). */
13726 if (! warn_implicit
13727 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
13728 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
13730 /* Set up current_class_type, and enter the scope of the class, if
13733 push_nested_class (ctype
, 1);
13734 else if (DECL_STATIC_FUNCTION_P (decl1
))
13735 push_nested_class (DECL_CONTEXT (decl1
), 2);
13737 /* Now that we have entered the scope of the class, we must restore
13738 the bindings for any template parameters surrounding DECL1, if it
13739 is an inline member template. (Order is important; consider the
13740 case where a template parameter has the same name as a field of
13741 the class.) It is not until after this point that
13742 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13743 if (flags
& SF_INCLASS_INLINE
)
13744 maybe_begin_member_template_processing (decl1
);
13746 /* Effective C++ rule 15. */
13748 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13749 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
13750 cp_warning ("`operator=' should return a reference to `*this'");
13752 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13753 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13754 if (!DECL_INITIAL (decl1
))
13755 DECL_INITIAL (decl1
) = error_mark_node
;
13757 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13758 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
13761 /* This function exists in static storage.
13762 (This does not mean `static' in the C sense!) */
13763 TREE_STATIC (decl1
) = 1;
13765 /* We must call push_template_decl after current_class_type is set
13766 up. (If we are processing inline definitions after exiting a
13767 class scope, current_class_type will be NULL_TREE until set above
13768 by push_nested_class.) */
13769 if (processing_template_decl
)
13770 decl1
= push_template_decl (decl1
);
13772 /* We are now in the scope of the function being defined. */
13773 current_function_decl
= decl1
;
13775 /* Save the parm names or decls from this function's declarator
13776 where store_parm_decls will find them. */
13777 current_function_parms
= last_function_parms
;
13778 current_function_parm_tags
= last_function_parm_tags
;
13780 /* Make sure the parameter and return types are reasonable. When
13781 you declare a function, these types can be incomplete, but they
13782 must be complete when you define the function. */
13783 if (! processing_template_decl
)
13784 check_function_type (decl1
, current_function_parms
);
13786 /* Build the return declaration for the function. */
13787 restype
= TREE_TYPE (fntype
);
13788 if (!processing_template_decl
)
13790 if (!DECL_RESULT (decl1
))
13792 DECL_RESULT (decl1
)
13793 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13794 c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype
),
13795 DECL_RESULT (decl1
));
13799 /* Just use `void'. Nobody will ever look at this anyhow. */
13800 DECL_RESULT (decl1
) = build_decl (RESULT_DECL
, 0, void_type_node
);
13802 /* Initialize RTL machinery. We cannot do this until
13803 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13804 even when processing a template; this is how we get
13805 CFUN set up, and our per-function variables initialized. */
13806 bl
= current_binding_level
;
13807 init_function_start (decl1
, input_filename
, lineno
);
13808 current_binding_level
= bl
;
13810 /* Even though we're inside a function body, we still don't want to
13811 call expand_expr to calculate the size of a variable-sized array.
13812 We haven't necessarily assigned RTL to all variables yet, so it's
13813 not safe to try to expand expressions involving them. */
13814 immediate_size_expand
= 0;
13815 cfun
->x_dont_save_pending_sizes_p
= 1;
13817 /* Start the statement-tree, start the tree now. */
13818 begin_stmt_tree (&DECL_SAVED_TREE (decl1
));
13820 /* Let the user know we're compiling this function. */
13821 announce_function (decl1
);
13823 /* Record the decl so that the function name is defined.
13824 If we already have a decl for this name, and it is a FUNCTION_DECL,
13825 use the old decl. */
13826 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13828 /* A specialization is not used to guide overload resolution. */
13829 if (!DECL_TEMPLATE_SPECIALIZATION (decl1
)
13830 && ! DECL_FUNCTION_MEMBER_P (decl1
))
13831 decl1
= pushdecl (decl1
);
13834 /* We need to set the DECL_CONTEXT. */
13835 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13836 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13837 /* And make sure we have enough default args. */
13838 check_default_args (decl1
);
13840 fntype
= TREE_TYPE (decl1
);
13843 /* Reset these in case the call to pushdecl changed them. */
13844 current_function_decl
= decl1
;
13845 cfun
->decl
= decl1
;
13847 my_friendly_assert ((DECL_PENDING_INLINE_P (decl1
)
13848 || !DECL_SAVED_FUNCTION_DATA (decl1
)),
13851 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13853 /* We know that this was set up by `grokclassfn'. We do not
13854 wait until `store_parm_decls', since evil parse errors may
13855 never get us to that point. Here we keep the consistency
13856 between `current_class_type' and `current_class_ptr'. */
13857 tree t
= DECL_ARGUMENTS (decl1
);
13859 my_friendly_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
,
13861 my_friendly_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
,
13864 cp_function_chain
->x_current_class_ref
13865 = build_indirect_ref (t
, NULL_PTR
);
13866 cp_function_chain
->x_current_class_ptr
= t
;
13868 /* Constructors and destructors need to know whether they're "in
13869 charge" of initializing virtual base classes. */
13870 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13871 current_in_charge_parm
= TREE_CHAIN (t
);
13874 if (DECL_INTERFACE_KNOWN (decl1
))
13876 tree ctx
= decl_function_context (decl1
);
13878 if (DECL_NOT_REALLY_EXTERN (decl1
))
13879 DECL_EXTERNAL (decl1
) = 0;
13881 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
13882 && TREE_PUBLIC (ctx
))
13883 /* This is a function in a local class in an extern inline
13885 comdat_linkage (decl1
);
13887 /* If this function belongs to an interface, it is public.
13888 If it belongs to someone else's interface, it is also external.
13889 This only affects inlines and template instantiations. */
13890 else if (interface_unknown
== 0
13891 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13892 || flag_alt_external_templates
))
13894 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
13895 || processing_template_decl
)
13897 DECL_EXTERNAL (decl1
)
13899 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
13900 && !DECL_VINDEX (decl1
)));
13902 /* For WIN32 we also want to put these in linkonce sections. */
13903 maybe_make_one_only (decl1
);
13906 DECL_EXTERNAL (decl1
) = 0;
13907 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13908 DECL_INTERFACE_KNOWN (decl1
) = 1;
13910 else if (interface_unknown
&& interface_only
13911 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13912 || flag_alt_external_templates
))
13914 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13915 interface, we will have interface_only set but not
13916 interface_known. In that case, we don't want to use the normal
13917 heuristics because someone will supply a #pragma implementation
13918 elsewhere, and deducing it here would produce a conflict. */
13919 comdat_linkage (decl1
);
13920 DECL_EXTERNAL (decl1
) = 0;
13921 DECL_INTERFACE_KNOWN (decl1
) = 1;
13922 DECL_DEFER_OUTPUT (decl1
) = 1;
13926 /* This is a definition, not a reference.
13927 So clear DECL_EXTERNAL. */
13928 DECL_EXTERNAL (decl1
) = 0;
13930 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
13931 && ! DECL_INTERFACE_KNOWN (decl1
)
13932 /* Don't try to defer nested functions for now. */
13933 && ! decl_function_context (decl1
))
13934 DECL_DEFER_OUTPUT (decl1
) = 1;
13936 DECL_INTERFACE_KNOWN (decl1
) = 1;
13940 current_binding_level
->parm_flag
= 1;
13943 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
13945 /* We need to do this even if we aren't expanding yet so that
13946 assemble_external works. */
13947 make_function_rtl (decl1
);
13949 /* Promote the value to int before returning it. */
13950 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
13951 restype
= type_promotes_to (restype
);
13953 /* If this fcn was already referenced via a block-scope `extern' decl
13954 (or an implicit decl), propagate certain information about the usage. */
13955 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
13956 TREE_ADDRESSABLE (decl1
) = 1;
13958 if (DECL_RESULT (decl1
) == NULL_TREE
)
13960 DECL_RESULT (decl1
)
13961 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13962 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
13963 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
13968 if (DECL_DESTRUCTOR_P (decl1
))
13970 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13971 DECL_CONTEXT (dtor_label
) = current_function_decl
;
13973 /* Under the old ABI we return `this' from constructors, so we make
13974 ordinary `return' statements in constructors jump to CTOR_LABEL;
13975 from there we return `this'. Under the new ABI, we don't bother
13976 with any of this. By not setting CTOR_LABEL the remainder of the
13977 machinery is automatically disabled. */
13978 else if (!flag_new_abi
&& DECL_CONSTRUCTOR_P (decl1
))
13980 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13981 DECL_CONTEXT (ctor_label
) = current_function_decl
;
13984 store_parm_decls (current_function_parms
);
13989 /* Store the parameter declarations into the current function declaration.
13990 This is called after parsing the parameter declarations, before
13991 digesting the body of the function.
13993 Also install to binding contour return value identifier, if any. */
13996 store_parm_decls (current_function_parms
)
13997 tree current_function_parms
;
13999 register tree fndecl
= current_function_decl
;
14000 register tree parm
;
14001 int parms_have_cleanups
= 0;
14002 tree cleanups
= NULL_TREE
;
14004 /* This is a list of types declared among parms in a prototype. */
14005 tree parmtags
= current_function_parm_tags
;
14007 /* This is a chain of any other decls that came in among the parm
14008 declarations. If a parm is declared with enum {foo, bar} x;
14009 then CONST_DECLs for foo and bar are put here. */
14010 tree nonparms
= NULL_TREE
;
14012 if (current_function_parms
)
14014 /* This case is when the function was defined with an ANSI prototype.
14015 The parms already have decls, so we need not do anything here
14016 except record them as in effect
14017 and complain if any redundant old-style parm decls were written. */
14019 tree specparms
= current_function_parms
;
14022 /* Must clear this because it might contain TYPE_DECLs declared
14024 storedecls (NULL_TREE
);
14026 /* If we're doing semantic analysis, then we'll call pushdecl
14027 for each of these. We must do them in reverse order so that
14028 they end in the correct forward order. */
14029 specparms
= nreverse (specparms
);
14031 for (parm
= specparms
; parm
; parm
= next
)
14033 next
= TREE_CHAIN (parm
);
14034 if (TREE_CODE (parm
) == PARM_DECL
)
14038 if (DECL_NAME (parm
) == NULL_TREE
14039 || TREE_CODE (parm
) != VOID_TYPE
)
14042 cp_error ("parameter `%D' declared void", parm
);
14044 cleanup
= (processing_template_decl
14046 : maybe_build_cleanup (parm
));
14049 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
14053 /* If we find an enum constant or a type tag,
14054 put it aside for the moment. */
14055 TREE_CHAIN (parm
) = NULL_TREE
;
14056 nonparms
= chainon (nonparms
, parm
);
14060 /* Get the decls in their original chain order and record in the
14061 function. This is all and only the PARM_DECLs that were
14062 pushed into scope by the loop above. */
14063 DECL_ARGUMENTS (fndecl
) = getdecls ();
14064 storetags (chainon (parmtags
, gettags ()));
14067 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
14069 /* Now store the final chain of decls for the arguments
14070 as the decl-chain of the current lexical scope.
14071 Put the enumerators in as well, at the front so that
14072 DECL_ARGUMENTS is not modified. */
14073 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
14075 /* Now that we have initialized the parms, we can start their
14076 cleanups. We cannot do this before, since expand_decl_cleanup
14077 should not be called before the parm can be used. */
14080 finish_decl_cleanup (TREE_PURPOSE (cleanups
),
14081 TREE_VALUE (cleanups
));
14082 cleanups
= TREE_CHAIN (cleanups
);
14085 /* Create a binding contour which can be used to catch
14086 cleanup-generated temporaries. */
14087 if (parms_have_cleanups
)
14090 /* Do the starting of the exception specifications, if we have any. */
14091 if (flag_exceptions
&& !processing_template_decl
14092 && flag_enforce_eh_specs
14093 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
14094 current_eh_spec_try_block
= expand_start_eh_spec ();
14098 /* We have finished doing semantic analysis on DECL, but have not yet
14099 generated RTL for its body. Save away our current state, so that
14100 when we want to generate RTL later we know what to do. */
14103 save_function_data (decl
)
14106 struct cp_language_function
*f
;
14108 /* Save the language-specific per-function data so that we can
14109 get it back when we really expand this function. */
14110 my_friendly_assert (!DECL_PENDING_INLINE_P (decl
),
14114 f
= ((struct cp_language_function
*)
14115 xmalloc (sizeof (struct cp_language_function
)));
14116 bcopy ((char *) cp_function_chain
, (char *) f
,
14117 sizeof (struct cp_language_function
));
14118 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
14120 /* Clear out the bits we don't need. */
14121 f
->base
.x_stmt_tree
.x_last_stmt
= NULL_TREE
;
14122 f
->base
.x_stmt_tree
.x_last_expr_type
= NULL_TREE
;
14123 f
->x_result_rtx
= NULL_RTX
;
14124 f
->x_named_label_uses
= NULL
;
14125 f
->bindings
= NULL
;
14127 /* When we get back here again, we will be expanding. */
14128 f
->x_expanding_p
= 1;
14130 /* If we've already decided that we cannot inline this function, we
14131 must remember that fact when we actually go to expand the
14133 f
->cannot_inline
= current_function_cannot_inline
;
14136 /* At the end of every constructor we generate to code to return
14137 `this'. Do that now. */
14140 finish_constructor_body ()
14142 /* Any return from a constructor will end up here. */
14144 add_stmt (build_stmt (LABEL_STMT
, ctor_label
));
14146 /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14147 generate the return, rather than a goto to CTOR_LABEL. */
14148 ctor_label
= NULL_TREE
;
14149 /* In check_return_expr we translate an empty return from a
14150 constructor to a return of `this'. */
14151 finish_return_stmt (NULL_TREE
);
14152 /* Mark the end of the constructor. */
14153 add_stmt (build_stmt (CTOR_STMT
));
14156 /* At the end of every destructor we generate code to restore virtual
14157 function tables to the values desired by base classes and to call
14158 to base class destructors. Do that now. */
14161 finish_destructor_body ()
14163 tree compound_stmt
;
14168 /* Create a block to contain all the extra code. */
14169 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
14171 /* Any return from a destructor will end up here. */
14172 add_stmt (build_stmt (LABEL_STMT
, dtor_label
));
14174 /* Generate the code to call destructor on base class. If this
14175 destructor belongs to a class with virtual functions, then set
14176 the virtual function table pointer to represent the type of our
14179 /* This side-effect makes call to `build_delete' generate the code
14180 we have to have at the end of this destructor. `build_delete'
14181 will set the flag again. */
14182 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
14184 exprstmt
= build_delete (current_class_type
,
14186 sfk_base_destructor
,
14187 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
14190 if (exprstmt
!= error_mark_node
14191 && (TREE_CODE (exprstmt
) != NOP_EXPR
14192 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
14193 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
14195 if (exprstmt
!= void_zero_node
)
14196 /* Don't call `expand_expr_stmt' if we're not going to do
14197 anything, since -Wall will give a diagnostic. */
14198 finish_expr_stmt (exprstmt
);
14200 /* Run destructors for all virtual baseclasses. */
14201 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
14206 if_stmt
= begin_if_stmt ();
14207 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
14208 current_in_charge_parm
,
14212 vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
14213 /* The CLASSTYPE_VBASECLASSES list is in initialization
14214 order, so we have to march through it in reverse order. */
14215 for (vbases
= nreverse (copy_list (vbases
));
14217 vbases
= TREE_CHAIN (vbases
))
14219 tree vbase
= TREE_VALUE (vbases
);
14221 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase
)))
14223 tree vb
= get_vbase
14224 (BINFO_TYPE (vbase
),
14225 TYPE_BINFO (current_class_type
));
14227 (build_scoped_method_call
14228 (current_class_ref
, vb
, base_dtor_identifier
,
14233 finish_then_clause (if_stmt
);
14238 virtual_size
= c_sizeof (current_class_type
);
14240 /* At the end, call delete if that's what's requested. */
14242 /* FDIS sez: At the point of definition of a virtual destructor
14243 (including an implicit definition), non-placement operator delete
14244 shall be looked up in the scope of the destructor's class and if
14245 found shall be accessible and unambiguous.
14247 This is somewhat unclear, but I take it to mean that if the class
14248 only defines placement deletes we don't do anything here. So we
14249 pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14250 they ever try to delete one of these. */
14251 exprstmt
= build_op_delete_call
14252 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
14253 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
14255 if_stmt
= begin_if_stmt ();
14256 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
14257 current_in_charge_parm
,
14260 finish_expr_stmt (exprstmt
);
14261 finish_then_clause (if_stmt
);
14264 /* Close the block we started above. */
14265 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
14268 /* Finish up a function declaration and compile that function
14269 all the way to assembler language output. The free the storage
14270 for the function definition.
14272 FLAGS is a bitwise or of the following values:
14274 An extra call to poplevel (and expand_end_bindings) must be
14275 made to take care of the binding contour for the base
14276 initializers. This is only relevant for constructors.
14278 We just finished processing the body of an in-class inline
14279 function definition. (This processing will have taken place
14280 after the class definition is complete.) */
14283 finish_function (flags
)
14286 register tree fndecl
= current_function_decl
;
14287 tree fntype
, ctype
= NULL_TREE
;
14288 int call_poplevel
= (flags
& 1) != 0;
14289 int inclass_inline
= (flags
& 2) != 0;
14292 /* When we get some parse errors, we can end up without a
14293 current_function_decl, so cope. */
14294 if (fndecl
== NULL_TREE
)
14295 return error_mark_node
;
14297 nested
= function_depth
> 1;
14298 fntype
= TREE_TYPE (fndecl
);
14300 /* TREE_READONLY (fndecl) = 1;
14301 This caused &foo to be of type ptr-to-const-function
14302 which then got a warning when stored in a ptr-to-function variable. */
14304 my_friendly_assert (building_stmt_tree (), 20000911);
14306 /* For a cloned function, we've already got all the code we need;
14307 there's no need to add any extra bits. */
14308 if (!DECL_CLONED_FUNCTION_P (fndecl
))
14310 if (DECL_CONSTRUCTOR_P (fndecl
))
14312 finish_constructor_body ();
14316 else if (DECL_DESTRUCTOR_P (fndecl
) && !processing_template_decl
)
14317 finish_destructor_body ();
14318 else if (DECL_MAIN_P (fndecl
))
14320 /* Make it so that `main' always returns 0 by default. */
14322 finish_return_stmt (integer_one_node
);
14324 finish_return_stmt (integer_zero_node
);
14328 /* Finish dealing with exception specifiers. */
14329 if (flag_exceptions
&& !processing_template_decl
14330 && flag_enforce_eh_specs
14331 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
14332 expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14333 (TREE_TYPE (current_function_decl
)),
14334 current_eh_spec_try_block
);
14337 /* If we're saving up tree structure, tie off the function now. */
14338 finish_stmt_tree (&DECL_SAVED_TREE (fndecl
));
14340 /* This must come after expand_function_end because cleanups might
14341 have declarations (from inline functions) that need to go into
14342 this function's blocks. */
14343 if (current_binding_level
->parm_flag
!= 1)
14344 my_friendly_abort (122);
14345 poplevel (1, 0, 1);
14347 /* Remember that we were in class scope. */
14348 if (current_class_name
)
14349 ctype
= current_class_type
;
14351 /* Must mark the RESULT_DECL as being in this function. */
14352 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14354 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14355 to the FUNCTION_DECL node itself. */
14356 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14358 /* Save away current state, if appropriate. */
14359 if (!processing_template_decl
)
14360 save_function_data (fndecl
);
14362 /* If this function calls `setjmp' it cannot be inlined. When
14363 `longjmp' is called it is not guaranteed to restore the value of
14364 local variables that have been modified since the call to
14365 `setjmp'. So, if were to inline this function into some caller
14366 `c', then when we `longjmp', we might not restore all variables
14367 in `c'. (It might seem, at first blush, that there's no way for
14368 this function to modify local variables in `c', but their
14369 addresses may have been stored somewhere accessible to this
14371 if (!processing_template_decl
&& calls_setjmp_p (fndecl
))
14372 DECL_UNINLINABLE (fndecl
) = 1;
14374 /* Clear out memory we no longer need. */
14375 free_after_parsing (cfun
);
14376 /* Since we never call rest_of_compilation, we never clear
14377 CFUN. Do so explicitly. */
14378 free_after_compilation (cfun
);
14381 /* If this is a in-class inline definition, we may have to pop the
14382 bindings for the template parameters that we added in
14383 maybe_begin_member_template_processing when start_function was
14385 if (inclass_inline
)
14386 maybe_end_member_template_processing ();
14388 /* Leave the scope of the class. */
14390 pop_nested_class ();
14397 /* Let the error reporting routines know that we're outside a
14398 function. For a nested function, this value is used in
14399 pop_cp_function_context and then reset via pop_function_context. */
14400 current_function_decl
= NULL_TREE
;
14401 /* We don't really care about obstacks, but the middle-end
14402 sometimes cares on what obstck things are located. */
14403 permanent_allocation (1);
14409 /* Create the FUNCTION_DECL for a function definition.
14410 DECLSPECS and DECLARATOR are the parts of the declaration;
14411 they describe the return type and the name of the function,
14412 but twisted together in a fashion that parallels the syntax of C.
14414 This function creates a binding context for the function body
14415 as well as setting up the FUNCTION_DECL in current_function_decl.
14417 Returns a FUNCTION_DECL on success.
14419 If the DECLARATOR is not suitable for a function (it defines a datum
14420 instead), we return 0, which tells yyparse to report a parse error.
14422 May return void_type_node indicating that this method is actually
14423 a friend. See grokfield for more details.
14425 Came here with a `.pushlevel' .
14427 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14428 CHANGES TO CODE IN `grokfield'. */
14431 start_method (declspecs
, declarator
, attrlist
)
14432 tree declarator
, declspecs
, attrlist
;
14434 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14437 /* Something too ugly to handle. */
14438 if (fndecl
== NULL_TREE
)
14441 /* Pass friends other than inline friend functions back. */
14442 if (fndecl
== void_type_node
)
14445 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
14446 /* Not a function, tell parser to report parse error. */
14449 if (DECL_IN_AGGR_P (fndecl
))
14451 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
14453 if (DECL_CONTEXT (fndecl
)
14454 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
14455 cp_error ("`%D' is already defined in class `%T'", fndecl
,
14456 DECL_CONTEXT (fndecl
));
14458 return void_type_node
;
14461 check_template_shadow (fndecl
);
14463 DECL_THIS_INLINE (fndecl
) = 1;
14465 if (flag_default_inline
)
14466 DECL_INLINE (fndecl
) = 1;
14468 /* We process method specializations in finish_struct_1. */
14469 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14470 fndecl
= push_template_decl (fndecl
);
14472 if (! DECL_FRIEND_P (fndecl
))
14474 if (TREE_CHAIN (fndecl
))
14476 fndecl
= copy_node (fndecl
);
14477 TREE_CHAIN (fndecl
) = NULL_TREE
;
14480 if (DECL_CONSTRUCTOR_P (fndecl
))
14482 if (! grok_ctor_properties (current_class_type
, fndecl
))
14483 return void_type_node
;
14485 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
14486 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
14489 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0);
14491 /* Make a place for the parms */
14493 current_binding_level
->parm_flag
= 1;
14495 DECL_IN_AGGR_P (fndecl
) = 1;
14499 /* Go through the motions of finishing a function definition.
14500 We don't compile this method until after the whole class has
14503 FINISH_METHOD must return something that looks as though it
14504 came from GROKFIELD (since we are defining a method, after all).
14506 This is called after parsing the body of the function definition.
14507 STMTS is the chain of statements that makes up the function body.
14509 DECL is the ..._DECL that `start_method' provided. */
14512 finish_method (decl
)
14515 register tree fndecl
= decl
;
14518 register tree link
;
14520 if (decl
== void_type_node
)
14523 old_initial
= DECL_INITIAL (fndecl
);
14525 /* Undo the level for the parms (from start_method).
14526 This is like poplevel, but it causes nothing to be
14527 saved. Saving information here confuses symbol-table
14528 output routines. Besides, this information will
14529 be correctly output when this method is actually
14532 /* Clear out the meanings of the local variables of this level;
14533 also record in each decl which block it belongs to. */
14535 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
14537 if (DECL_NAME (link
) != NULL_TREE
)
14538 pop_binding (DECL_NAME (link
), link
);
14539 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
14540 DECL_CONTEXT (link
) = NULL_TREE
;
14543 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
14544 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
14545 current_binding_level
->parm_flag
,
14546 current_binding_level
->keep
);
14548 poplevel (0, 0, 0);
14550 DECL_INITIAL (fndecl
) = old_initial
;
14552 /* We used to check if the context of FNDECL was different from
14553 current_class_type as another way to get inside here. This didn't work
14554 for String.cc in libg++. */
14555 if (DECL_FRIEND_P (fndecl
))
14557 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
14558 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
14559 decl
= void_type_node
;
14565 /* Called when a new struct TYPE is defined.
14566 If this structure or union completes the type of any previous
14567 variable declaration, lay it out and output its rtl. */
14570 hack_incomplete_structures (type
)
14574 struct binding_level
*level
;
14576 if (!type
) /* Don't do this for class templates. */
14579 if (namespace_bindings_p ())
14582 list
= &namespace_scope_incomplete
;
14586 level
= innermost_nonclass_level ();
14587 list
= &level
->incomplete
;
14594 tree decl
= TREE_VALUE (*list
);
14595 if ((decl
&& TREE_TYPE (decl
) == type
)
14596 || (TREE_TYPE (decl
)
14597 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14598 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
14600 int toplevel
= toplevel_bindings_p ();
14601 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14602 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
14603 layout_type (TREE_TYPE (decl
));
14604 layout_decl (decl
, 0);
14605 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
14609 expand_decl (decl
);
14610 cleanup
= maybe_build_cleanup (decl
);
14611 expand_decl_init (decl
);
14612 if (! expand_decl_cleanup (decl
, cleanup
))
14613 cp_error ("parser lost in parsing declaration of `%D'",
14616 *list
= TREE_CHAIN (*list
);
14619 list
= &TREE_CHAIN (*list
);
14622 /* Keep looking through artificial binding levels generated
14623 for local variables. */
14624 if (level
&& level
->keep
== 2)
14626 level
= level
->level_chain
;
14627 list
= &level
->incomplete
;
14634 /* If DECL is of a type which needs a cleanup, build that cleanup
14638 maybe_build_cleanup (decl
)
14641 tree type
= TREE_TYPE (decl
);
14643 if (type
!= error_mark_node
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
14645 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14648 if (TREE_CODE (type
) == ARRAY_TYPE
)
14652 mark_addressable (decl
);
14653 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
14656 /* Optimize for space over speed here. */
14657 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
14658 || flag_expensive_optimizations
)
14659 flags
|= LOOKUP_NONVIRTUAL
;
14661 rval
= build_delete (TREE_TYPE (rval
), rval
,
14662 sfk_complete_destructor
, flags
, 0);
14664 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
14665 && ! TYPE_HAS_DESTRUCTOR (type
))
14666 rval
= build_compound_expr (tree_cons (NULL_TREE
, rval
,
14667 build_tree_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
14674 /* Expand a C++ expression at the statement level.
14675 This is needed to ferret out nodes which have UNKNOWN_TYPE.
14676 The C++ type checker should get all of these out when
14677 expressions are combined with other, type-providing, expressions,
14678 leaving only orphan expressions, such as:
14680 &class::bar; / / takes its address, but does nothing with it. */
14683 cplus_expand_expr_stmt (exp
)
14687 /* We should do this eventually, but right now this causes regex.o from
14688 libg++ to miscompile, and tString to core dump. */
14689 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
14692 /* If we don't do this, we end up down inside expand_expr
14693 trying to do TYPE_MODE on the ERROR_MARK, and really
14694 go outside the bounds of the type. */
14695 if (exp
!= error_mark_node
)
14696 expand_expr_stmt (exp
);
14699 /* When a stmt has been parsed, this function is called. */
14704 /* Always assume this statement was not an expression statement. If
14705 it actually was an expression statement, its our callers
14706 responsibility to fix this up. */
14707 last_expr_type
= NULL_TREE
;
14710 /* DECL was originally constructed as a non-static member function,
14711 but turned out to be static. Update it accordingly. */
14714 revert_static_member_fn (decl
)
14718 tree function
= TREE_TYPE (decl
);
14719 tree args
= TYPE_ARG_TYPES (function
);
14721 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
14722 != TYPE_UNQUALIFIED
)
14723 cp_error ("static member function `%#D' declared with type qualifiers",
14726 args
= TREE_CHAIN (args
);
14727 tmp
= build_function_type (TREE_TYPE (function
), args
);
14728 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
14729 tmp
= build_exception_variant (tmp
,
14730 TYPE_RAISES_EXCEPTIONS (function
));
14731 TREE_TYPE (decl
) = tmp
;
14732 if (DECL_ARGUMENTS (decl
))
14733 DECL_ARGUMENTS (decl
) = TREE_CHAIN (DECL_ARGUMENTS (decl
));
14734 DECL_STATIC_FUNCTION_P (decl
) = 1;
14737 /* Initialize the variables used during compilation of a C++
14741 push_cp_function_context (f
)
14742 struct function
*f
;
14744 struct cp_language_function
*p
14745 = ((struct cp_language_function
*)
14746 xcalloc (1, sizeof (struct cp_language_function
)));
14747 f
->language
= (struct language_function
*) p
;
14749 /* It takes an explicit call to expand_body to generate RTL for a
14753 /* Whenever we start a new function, we destroy temporaries in the
14755 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
14758 /* Free the language-specific parts of F, now that we've finished
14759 compiling the function. */
14762 pop_cp_function_context (f
)
14763 struct function
*f
;
14766 free (f
->language
);
14770 /* Mark P for GC. */
14773 mark_lang_function (p
)
14774 struct cp_language_function
*p
;
14779 ggc_mark_tree (p
->x_ctor_label
);
14780 ggc_mark_tree (p
->x_dtor_label
);
14781 ggc_mark_tree (p
->x_current_class_ptr
);
14782 ggc_mark_tree (p
->x_current_class_ref
);
14783 ggc_mark_tree (p
->x_eh_spec_try_block
);
14784 ggc_mark_tree (p
->x_scope_stmt_stack
);
14786 ggc_mark_rtx (p
->x_result_rtx
);
14788 mark_named_label_lists (&p
->x_named_labels
, &p
->x_named_label_uses
);
14789 mark_stmt_tree (&p
->base
.x_stmt_tree
);
14790 mark_binding_level (&p
->bindings
);
14793 /* Mark the language-specific data in F for GC. */
14796 mark_cp_function_context (f
)
14797 struct function
*f
;
14799 mark_lang_function ((struct cp_language_function
*) f
->language
);
14803 lang_mark_false_label_stack (l
)
14804 struct label_node
*l
;
14806 /* C++ doesn't use false_label_stack. It better be NULL. */
14807 my_friendly_assert (l
== NULL
, 19990904);
14814 enum tree_code code
= TREE_CODE (t
);
14815 if (code
== IDENTIFIER_NODE
)
14817 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
14818 struct lang_id2
*li2
= li
->x
;
14819 ggc_mark_tree (li
->namespace_bindings
);
14820 ggc_mark_tree (li
->bindings
);
14821 ggc_mark_tree (li
->class_value
);
14822 ggc_mark_tree (li
->class_template_info
);
14826 ggc_mark_tree (li2
->label_value
);
14827 ggc_mark_tree (li2
->implicit_decl
);
14828 ggc_mark_tree (li2
->error_locus
);
14831 else if (code
== CPLUS_BINDING
)
14833 if (BINDING_HAS_LEVEL_P (t
))
14834 mark_binding_level (&BINDING_LEVEL (t
));
14836 ggc_mark_tree (BINDING_SCOPE (t
));
14837 ggc_mark_tree (BINDING_VALUE (t
));
14839 else if (code
== OVERLOAD
)
14840 ggc_mark_tree (OVL_FUNCTION (t
));
14841 else if (code
== TEMPLATE_PARM_INDEX
)
14842 ggc_mark_tree (TEMPLATE_PARM_DECL (t
));
14843 else if (TREE_CODE_CLASS (code
) == 'd')
14845 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
14850 if (!DECL_GLOBAL_CTOR_P (t
)
14851 && !DECL_GLOBAL_DTOR_P (t
)
14852 && !DECL_THUNK_P (t
))
14853 ggc_mark_tree (ld
->decl_flags
.u2
.access
);
14854 else if (DECL_THUNK_P (t
))
14855 ggc_mark_tree (ld
->decl_flags
.u2
.vcall_offset
);
14856 ggc_mark_tree (ld
->decl_flags
.context
);
14857 if (TREE_CODE (t
) != NAMESPACE_DECL
)
14858 ggc_mark_tree (ld
->decl_flags
.u
.template_info
);
14860 mark_binding_level (&NAMESPACE_LEVEL (t
));
14861 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
14863 ggc_mark_tree (ld
->befriending_classes
);
14864 ggc_mark_tree (ld
->saved_tree
);
14865 ggc_mark_tree (ld
->cloned_function
);
14866 if (!DECL_OVERLOADED_OPERATOR_P (t
))
14867 ggc_mark_tree (ld
->u2
.vtt_parm
);
14868 if (TREE_CODE (t
) == TYPE_DECL
)
14869 ggc_mark_tree (ld
->u
.sorted_fields
);
14870 else if (TREE_CODE (t
) == FUNCTION_DECL
14871 && !DECL_PENDING_INLINE_P (t
))
14872 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t
));
14876 else if (TREE_CODE_CLASS (code
) == 't')
14878 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
14880 if (lt
&& !(TREE_CODE (t
) == POINTER_TYPE
14881 && TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
))
14884 ggc_mark_tree (lt
->primary_base
);
14885 ggc_mark_tree (lt
->vfields
);
14886 ggc_mark_tree (lt
->vbases
);
14887 ggc_mark_tree (lt
->tags
);
14888 ggc_mark_tree (lt
->size
);
14889 ggc_mark_tree (lt
->pure_virtuals
);
14890 ggc_mark_tree (lt
->friend_classes
);
14891 ggc_mark_tree (lt
->rtti
);
14892 ggc_mark_tree (lt
->methods
);
14893 ggc_mark_tree (lt
->template_info
);
14894 ggc_mark_tree (lt
->befriending_classes
);
14897 /* In the case of pointer-to-member function types, the
14898 TYPE_LANG_SPECIFIC is really just a tree. */
14899 ggc_mark_tree ((tree
) lt
);