1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92-98, 1999 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Process declarations and symbol lookup for C front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
27 /* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
46 #define obstack_chunk_alloc xmalloc
47 #define obstack_chunk_free free
49 extern struct obstack permanent_obstack
;
50 extern struct obstack
* saveable_obstack
;
52 extern int current_class_depth
;
54 extern tree static_ctors
, static_dtors
;
56 extern int static_labelno
;
58 extern tree current_namespace
;
59 extern tree global_namespace
;
61 extern void (*print_error_function
) PROTO((char *));
62 extern int (*valid_lang_attribute
) PROTO ((tree
, tree
, tree
, tree
));
64 /* Obstack used for remembering local class declarations (like
65 enums and static (const) members. */
67 struct obstack decl_obstack
;
68 static struct stack_level
*decl_stack
;
70 #ifndef CHAR_TYPE_SIZE
71 #define CHAR_TYPE_SIZE BITS_PER_UNIT
74 #ifndef SHORT_TYPE_SIZE
75 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
79 #define INT_TYPE_SIZE BITS_PER_WORD
82 #ifndef LONG_TYPE_SIZE
83 #define LONG_TYPE_SIZE BITS_PER_WORD
86 #ifndef LONG_LONG_TYPE_SIZE
87 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
90 #ifndef WCHAR_UNSIGNED
91 #define WCHAR_UNSIGNED 0
94 #ifndef FLOAT_TYPE_SIZE
95 #define FLOAT_TYPE_SIZE BITS_PER_WORD
98 #ifndef DOUBLE_TYPE_SIZE
99 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
102 #ifndef LONG_DOUBLE_TYPE_SIZE
103 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
106 #ifndef BOOL_TYPE_SIZE
107 #ifdef SLOW_BYTE_ACCESS
108 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
110 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
114 /* We let tm.h override the types used here, to handle trivial differences
115 such as the choice of unsigned int or long unsigned int for size_t.
116 When machines start needing nontrivial differences in the size type,
117 it would be best to do something here to figure out automatically
118 from other information what type to use. */
121 #define SIZE_TYPE "long unsigned int"
125 #define PTRDIFF_TYPE "long int"
129 #define WCHAR_TYPE "int"
132 static tree grokparms
PROTO((tree
, int));
133 static const char *redeclaration_error_message
PROTO((tree
, tree
));
135 static struct stack_level
*push_decl_level
PROTO((struct stack_level
*,
137 static void push_binding_level
PROTO((struct binding_level
*, int,
139 static void pop_binding_level
PROTO((void));
140 static void suspend_binding_level
PROTO((void));
141 static void resume_binding_level
PROTO((struct binding_level
*));
142 static struct binding_level
*make_binding_level
PROTO((void));
143 static void declare_namespace_level
PROTO((void));
144 static void signal_catch
PROTO((int)) ATTRIBUTE_NORETURN
;
145 static void storedecls
PROTO((tree
));
146 static void require_complete_types_for_parms
PROTO((tree
));
147 static void push_overloaded_decl_1
PROTO((tree
));
148 static int ambi_op_p
PROTO((tree
));
149 static int unary_op_p
PROTO((tree
));
150 static tree store_bindings
PROTO((tree
, tree
));
151 static tree lookup_tag_reverse
PROTO((tree
, tree
));
152 static tree obscure_complex_init
PROTO((tree
, tree
));
153 static tree maybe_build_cleanup_1
PROTO((tree
, tree
));
154 static tree lookup_name_real
PROTO((tree
, int, int, int));
155 static void warn_extern_redeclared_static
PROTO((tree
, tree
));
156 static void grok_reference_init
PROTO((tree
, tree
, tree
));
157 static tree grokfndecl
PROTO((tree
, tree
, tree
, tree
, int,
158 enum overload_flags
, tree
,
159 tree
, int, int, int, int, int, int, tree
));
160 static tree grokvardecl
PROTO((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
161 static tree lookup_tag
PROTO((enum tree_code
, tree
,
162 struct binding_level
*, int));
163 static void set_identifier_type_value_with_scope
164 PROTO((tree
, tree
, struct binding_level
*));
165 static void record_builtin_type
PROTO((enum rid
, const char *, tree
));
166 static void record_unknown_type
PROTO((tree
, const char *));
167 static int member_function_or_else
PROTO((tree
, tree
, const char *));
168 static void bad_specifiers
PROTO((tree
, const char *, int, int, int, int,
170 static void lang_print_error_function
PROTO((char *));
171 static tree maybe_process_template_type_declaration
PROTO((tree
, int, struct binding_level
*));
172 static void check_for_uninitialized_const_var
PROTO((tree
));
173 static unsigned long typename_hash
PROTO((hash_table_key
));
174 static boolean typename_compare
PROTO((hash_table_key
, hash_table_key
));
175 static void push_binding
PROTO((tree
, tree
, struct binding_level
*));
176 static int add_binding
PROTO((tree
, tree
));
177 static void pop_binding
PROTO((tree
, tree
));
178 static tree local_variable_p
PROTO((tree
));
179 static tree find_binding
PROTO((tree
, tree
));
180 static tree select_decl
PROTO((tree
, int));
181 static tree unqualified_namespace_lookup
PROTO((tree
, int));
182 static int lookup_flags
PROTO((int, int));
183 static tree qualify_lookup
PROTO((tree
, int));
184 static tree record_builtin_java_type
PROTO((const char *, int));
185 static const char *tag_name
PROTO((enum tag_types code
));
186 static void find_class_binding_level
PROTO((void));
187 static struct binding_level
*innermost_nonclass_level
PROTO((void));
188 static tree poplevel_class
PROTO((void));
189 static void warn_about_implicit_typename_lookup
PROTO((tree
, tree
));
190 static int walk_namespaces_r
PROTO((tree
, walk_namespaces_fn
, void *));
191 static int walk_globals_r
PROTO((tree
, void *));
193 #if defined (DEBUG_CP_BINDING_LEVELS)
194 static void indent
PROTO((void));
197 /* A node which has tree code ERROR_MARK, and whose type is itself.
198 All erroneous expressions are replaced with this node. All functions
199 that accept nodes as arguments should avoid generating error messages
200 if this node is one of the arguments, since it is undesirable to get
201 multiple error messages from one error in the input. */
203 tree error_mark_node
;
205 /* Erroneous argument lists can use this *IFF* they do not modify it. */
206 tree error_mark_list
;
208 /* The following symbols are subsumed in the cp_global_trees array, and
209 listed here individually for documentation purposes.
212 tree wchar_decl_node;
215 tree vtable_entry_type;
216 tree delta_type_node;
219 tree __baselist_desc_type_node;
220 tree __i_desc_type_node, __m_desc_type_node;
221 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
223 tree __t_desc_type_node;
225 tree __tp_desc_type_node;
227 tree __access_mode_type_node;
228 tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
229 tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
230 tree __ptmf_desc_type_node, __ptmd_desc_type_node;
232 Not needed yet? May be needed one day?
233 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
234 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
235 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
238 tree class_star_type_node;
239 tree class_type_node, record_type_node, union_type_node, enum_type_node;
240 tree unknown_type_node;
241 tree opaque_type_node, signature_type_node;
242 tree sigtable_entry_type;
244 Array type `vtable_entry_type[]'
247 tree vtbl_ptr_type_node;
253 A FUNCTION_DECL which can call `abort'. Not necessarily the
254 one that the user will declare, but sufficient to be called
255 by routines that want to abort the program.
259 The FUNCTION_DECL for the default `::operator delete'.
261 tree global_delete_fndecl;
264 tree type_info_type_node, tinfo_fn_id, tinfo_fn_type;
268 tree cp_global_trees
[CPTI_MAX
];
270 /* These can't be part of the above array, since they are declared
271 individually in tree.h, and used by the debug output routines. */
275 tree integer_type_node
;
276 tree unsigned_type_node
;
278 /* These can't be part of the above array, since they are declared
279 individially in tree.h and used by the target routines. */
282 tree va_list_type_node
;
284 /* Indicates that there is a type value in some namespace, although
285 that is not necessarily in scope at the moment. */
287 static tree global_type_node
;
292 /* Expect only namespace names now. */
293 static int only_namespace_names
;
295 /* In a destructor, the point at which all derived class destroying
296 has been done, just before any base class destroying will be done. */
300 /* In a destructor, the last insn emitted after the start of the
301 function and the parms. */
303 static rtx last_dtor_insn
;
305 /* In a constructor, the last insn emitted after the start of the
306 function and the parms, the exception specification and any
307 function-try-block. The constructor initializers are emitted after
310 static rtx last_parm_cleanup_insn
;
312 /* In a constructor, the point at which we are ready to return
313 the pointer to the initialized object. */
317 extern rtx cleanup_label
, return_label
;
319 /* If original DECL_RESULT of current function was a register,
320 but due to being an addressable named return value, would up
321 on the stack, this variable holds the named return value's
322 original location. */
323 static rtx original_result_rtx
;
325 /* Sequence of insns which represents base initialization. */
328 /* C++: Keep these around to reduce calls to `get_identifier'.
329 Identifiers for `this' in member functions and the auto-delete
330 parameter for destructors. */
331 tree this_identifier
, in_charge_identifier
;
332 tree ctor_identifier
, dtor_identifier
;
333 /* Used in pointer to member functions, in vtables, and in sigtables. */
334 tree pfn_identifier
, index_identifier
, delta_identifier
, delta2_identifier
;
335 tree pfn_or_delta2_identifier
, tag_identifier
;
336 tree vt_off_identifier
;
338 struct named_label_list
340 struct binding_level
*binding_level
;
343 char *filename_o_goto
;
345 struct named_label_list
*next
;
348 /* A list (chain of TREE_LIST nodes) of named label uses.
349 The TREE_PURPOSE field is the list of variables defined
350 in the label's scope defined at the point of use.
351 The TREE_VALUE field is the LABEL_DECL used.
352 The TREE_TYPE field holds `current_binding_level' at the
353 point of the label's use.
355 BWAHAHAAHAHahhahahahaah. No, no, no, said the little chicken.
357 Look at the pretty struct named_label_list. See the pretty struct
358 with the pretty named fields that describe what they do. See the
359 pretty lack of gratuitous casts. Notice the code got a lot cleaner.
361 Used only for jumps to as-yet undefined labels, since
362 jumps to defined labels can have their validity checked
365 static struct named_label_list
*named_label_uses
= NULL
;
367 /* A list of objects which have constructors or destructors
368 which reside in the global scope. The decl is stored in
369 the TREE_VALUE slot and the initializer is stored
370 in the TREE_PURPOSE slot. */
371 tree static_aggregates
;
375 /* Two expressions that are constants with value zero.
376 The first is of type `int', the second of type `void *'. */
378 tree integer_zero_node
;
379 tree null_pointer_node
;
381 /* The value for __null (NULL), namely, a zero of an integer type with
382 the same number of bits as a pointer. */
385 /* A node for the integer constants 1, 2, and 3. */
387 tree integer_one_node
, integer_two_node
, integer_three_node
;
389 /* While defining an enum type, this is 1 plus the last enumerator
392 static tree enum_next_value
;
394 /* Nonzero means that there was overflow computing enum_next_value. */
396 static int enum_overflow
;
398 /* Parsing a function declarator leaves a list of parameter names
399 or a chain or parameter decls here. */
401 tree last_function_parms
;
403 /* Parsing a function declarator leaves here a chain of structure
404 and enum types declared in the parmlist. */
406 static tree last_function_parm_tags
;
408 /* After parsing the declarator that starts a function definition,
409 `start_function' puts here the list of parameter names or chain of decls.
410 `store_parm_decls' finds it here. */
412 static tree current_function_parms
;
414 /* Similar, for last_function_parm_tags. */
415 static tree current_function_parm_tags
;
417 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
418 that have names. Here so we can clear out their names' definitions
419 at the end of the function. */
421 static tree named_labels
;
423 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
425 static tree shadowed_labels
;
427 /* The FUNCTION_DECL for the function currently being compiled,
428 or 0 if between functions. */
429 tree current_function_decl
;
431 /* Set to 0 at beginning of a function definition, set to 1 if
432 a return statement that specifies a return value is seen. */
434 int current_function_returns_value
;
436 /* Set to 0 at beginning of a function definition, set to 1 if
437 a return statement with no argument is seen. */
439 int current_function_returns_null
;
441 /* Set to 0 at beginning of a function definition, and whenever
442 a label (case or named) is defined. Set to value of expression
443 returned from function when that value can be transformed into
444 a named return value. */
446 tree current_function_return_value
;
448 /* Nonzero means give `double' the same size as `float'. */
450 extern int flag_short_double
;
452 /* Nonzero means don't recognize any builtin functions. */
454 extern int flag_no_builtin
;
456 /* Nonzero means don't recognize the non-ANSI builtin functions.
459 extern int flag_no_nonansi_builtin
;
461 /* Nonzero means enable obscure ANSI features and disable GNU extensions
462 that might cause ANSI-compliant code to be miscompiled. */
464 extern int flag_ansi
;
466 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
468 extern int flag_huge_objects
;
470 /* Nonzero if we want to conserve space in the .o files. We do this
471 by putting uninitialized data and runtime initialized data into
472 .common instead of .data at the expense of not flagging multiple
474 extern int flag_conserve_space
;
476 /* Pointers to the base and current top of the language name stack. */
478 extern tree
*current_lang_base
, *current_lang_stack
;
480 /* C and C++ flags are in decl2.c. */
482 /* Set to 0 at beginning of a constructor, set to 1
483 if that function does an allocation before referencing its
484 instance variable. */
485 static int current_function_assigns_this
;
486 int current_function_just_assigned_this
;
488 /* Set to 0 at beginning of a function. Set non-zero when
489 store_parm_decls is called. Don't call store_parm_decls
490 if this flag is non-zero! */
491 int current_function_parms_stored
;
493 /* Flag used when debugging spew.c */
495 extern int spew_debug
;
497 /* This is a copy of the class_shadowed list of the previous class binding
498 contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
499 when entering another class scope (i.e. a cache miss). */
500 extern tree previous_class_values
;
502 /* A expression of value 0 with the same precision as a sizetype
504 tree signed_size_zero_node
;
506 /* The name of the anonymous namespace, throughout this translation
508 tree anonymous_namespace_name
;
511 /* Allocate a level of searching. */
515 push_decl_level (stack
, obstack
)
516 struct stack_level
*stack
;
517 struct obstack
*obstack
;
519 struct stack_level tem
;
522 return push_stack_level (obstack
, (char *)&tem
, sizeof (tem
));
525 /* For each binding contour we allocate a binding_level structure
526 which records the names defined in that contour.
529 1) one for each function definition,
530 where internal declarations of the parameters appear.
531 2) one for each compound statement,
532 to record its declarations.
534 The current meaning of a name can be found by searching the levels
535 from the current one out to the global one.
537 Off to the side, may be the class_binding_level. This exists only
538 to catch class-local declarations. It is otherwise nonexistent.
540 Also there may be binding levels that catch cleanups that must be
541 run when exceptions occur. Thus, to see whether a name is bound in
542 the current scope, it is not enough to look in the
543 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
546 /* Note that the information in the `names' component of the global contour
547 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
551 /* A chain of _DECL nodes for all variables, constants, functions,
552 and typedef types. These are in the reverse of the order
553 supplied. There may be OVERLOADs on this list, too, but they
554 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
557 /* A list of structure, union and enum definitions, for looking up
559 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
560 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
561 or ENUMERAL_TYPE node.
563 C++: the TREE_VALUE nodes can be simple types for
564 component_bindings. */
567 /* A list of USING_DECL nodes. */
570 /* A list of used namespaces. PURPOSE is the namespace,
571 VALUE the common ancestor with this binding_level's namespace. */
572 tree using_directives
;
574 /* If this binding level is the binding level for a class, then
575 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
576 is the name of an entity bound in the class; the TREE_VALUE is
577 the IDENTIFIER_CLASS_VALUE before we entered the class. Thus,
578 when leaving class scope, we can restore the
579 IDENTIFIER_CLASS_VALUE by walking this list. The TREE_TYPE is
580 the DECL bound by this name in the class. */
583 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
584 is used for all binding levels. */
587 /* For each level (except not the global one),
588 a chain of BLOCK nodes for all the levels
589 that were entered and exited one level down. */
592 /* The BLOCK node for this level, if one has been preallocated.
593 If 0, the BLOCK is allocated (if needed) when the level is popped. */
596 /* The binding level which this one is contained in (inherits from). */
597 struct binding_level
*level_chain
;
599 /* List of decls in `names' that have incomplete
600 structure or union types. */
603 /* List of VAR_DECLS saved from a previous for statement.
604 These would be dead in ANSI-conforming code, but might
605 be referenced in ARM-era code. These are stored in a
606 TREE_LIST; the TREE_VALUE is the actual declaration. */
607 tree dead_vars_from_for
;
609 /* 1 for the level that holds the parameters of a function.
610 2 for the level that holds a class declaration.
611 3 for levels that hold parameter declarations. */
612 unsigned parm_flag
: 4;
614 /* 1 means make a BLOCK for this level regardless of all else.
615 2 for temporary binding contours created by the compiler. */
618 /* Nonzero if this level "doesn't exist" for tags. */
619 unsigned tag_transparent
: 1;
621 /* Nonzero if this level can safely have additional
622 cleanup-needing variables added to it. */
623 unsigned more_cleanups_ok
: 1;
624 unsigned have_cleanups
: 1;
626 /* Nonzero if this level is for storing the decls for template
627 parameters and generic decls; these decls will be discarded and
628 replaced with a TEMPLATE_DECL. */
629 unsigned pseudo_global
: 1;
631 /* This is set for a namespace binding level. */
632 unsigned namespace_p
: 1;
634 /* True if this level is that of a for-statement where we need to
635 worry about ambiguous (ARM or ANSI) scope rules. */
636 unsigned is_for_scope
: 1;
638 /* Two bits left for this word. */
640 #if defined(DEBUG_CP_BINDING_LEVELS)
641 /* Binding depth at which this level began. */
642 unsigned binding_depth
;
643 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
646 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
648 /* The binding level currently in effect. */
650 static struct binding_level
*current_binding_level
;
652 /* The binding level of the current class, if any. */
654 static struct binding_level
*class_binding_level
;
656 /* A chain of binding_level structures awaiting reuse. */
658 static struct binding_level
*free_binding_level
;
660 /* The outermost binding level, for names of file scope.
661 This is created when the compiler is started and exists
662 through the entire run. */
664 static struct binding_level
*global_binding_level
;
666 /* Binding level structures are initialized by copying this one. */
668 static struct binding_level clear_binding_level
;
670 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
672 static int keep_next_level_flag
;
674 #if defined(DEBUG_CP_BINDING_LEVELS)
675 static int binding_depth
= 0;
676 static int is_class_level
= 0;
683 for (i
= 0; i
< binding_depth
*2; i
++)
686 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
688 static tree pushdecl_with_scope
PROTO((tree
, struct binding_level
*));
691 push_binding_level (newlevel
, tag_transparent
, keep
)
692 struct binding_level
*newlevel
;
693 int tag_transparent
, keep
;
695 /* Add this level to the front of the chain (stack) of levels that
697 *newlevel
= clear_binding_level
;
698 newlevel
->level_chain
= current_binding_level
;
699 current_binding_level
= newlevel
;
700 newlevel
->tag_transparent
= tag_transparent
;
701 newlevel
->more_cleanups_ok
= 1;
702 newlevel
->keep
= keep
;
703 #if defined(DEBUG_CP_BINDING_LEVELS)
704 newlevel
->binding_depth
= binding_depth
;
706 fprintf (stderr
, "push %s level 0x%08x line %d\n",
707 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
710 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
713 /* Find the innermost enclosing class scope, and reset
714 CLASS_BINDING_LEVEL appropriately. */
717 find_class_binding_level ()
719 struct binding_level
*level
= current_binding_level
;
721 while (level
&& level
->parm_flag
!= 2)
722 level
= level
->level_chain
;
723 if (level
&& level
->parm_flag
== 2)
724 class_binding_level
= level
;
726 class_binding_level
= 0;
732 if (global_binding_level
)
734 /* Cannot pop a level, if there are none left to pop. */
735 if (current_binding_level
== global_binding_level
)
736 my_friendly_abort (123);
738 /* Pop the current level, and free the structure for reuse. */
739 #if defined(DEBUG_CP_BINDING_LEVELS)
742 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
743 (is_class_level
) ? "class" : "block",
744 current_binding_level
, lineno
);
745 if (is_class_level
!= (current_binding_level
== class_binding_level
))
748 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
751 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
753 register struct binding_level
*level
= current_binding_level
;
754 current_binding_level
= current_binding_level
->level_chain
;
755 level
->level_chain
= free_binding_level
;
756 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
757 if (level
->binding_depth
!= binding_depth
)
759 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
760 free_binding_level
= level
;
761 find_class_binding_level ();
766 suspend_binding_level ()
768 if (class_binding_level
)
769 current_binding_level
= class_binding_level
;
771 if (global_binding_level
)
773 /* Cannot suspend a level, if there are none left to suspend. */
774 if (current_binding_level
== global_binding_level
)
775 my_friendly_abort (123);
777 /* Suspend the current level. */
778 #if defined(DEBUG_CP_BINDING_LEVELS)
781 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
782 (is_class_level
) ? "class" : "block",
783 current_binding_level
, lineno
);
784 if (is_class_level
!= (current_binding_level
== class_binding_level
))
787 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
790 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
791 current_binding_level
= current_binding_level
->level_chain
;
792 find_class_binding_level ();
796 resume_binding_level (b
)
797 struct binding_level
*b
;
799 /* Resuming binding levels is meant only for namespaces,
800 and those cannot nest into classes. */
801 my_friendly_assert(!class_binding_level
, 386);
802 /* Also, resuming a non-directly nested namespace is a no-no. */
803 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
804 current_binding_level
= b
;
805 #if defined(DEBUG_CP_BINDING_LEVELS)
806 b
->binding_depth
= binding_depth
;
808 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
809 (is_class_level
) ? "class" : "block", b
, lineno
);
812 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
815 /* Create a new `struct binding_level'. */
818 struct binding_level
*
819 make_binding_level ()
822 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
825 /* Nonzero if we are currently in the global binding level. */
830 return current_binding_level
== global_binding_level
;
833 /* Return the innermost binding level that is not for a class scope. */
835 static struct binding_level
*
836 innermost_nonclass_level ()
838 struct binding_level
*b
;
840 b
= current_binding_level
;
841 while (b
->parm_flag
== 2)
847 /* Nonzero if we are currently in a toplevel binding level. This
848 means either the global binding level or a namespace in a toplevel
849 binding level. Since there are no non-toplevel namespace levels,
850 this really means any namespace or pseudo-global level. We also
851 include a class whose context is toplevel. */
854 toplevel_bindings_p ()
856 struct binding_level
*b
= innermost_nonclass_level ();
858 return b
->namespace_p
|| b
->pseudo_global
;
861 /* Nonzero if this is a namespace scope, or if we are defining a class
862 which is itself at namespace scope, or whose enclosing class is
863 such a class, etc. */
866 namespace_bindings_p ()
868 struct binding_level
*b
= innermost_nonclass_level ();
870 return b
->namespace_p
;
876 keep_next_level_flag
= 1;
879 /* Nonzero if the current level needs to have a BLOCK made. */
884 return (current_binding_level
->blocks
!= NULL_TREE
885 || current_binding_level
->keep
886 || current_binding_level
->names
!= NULL_TREE
887 || (current_binding_level
->tags
!= NULL_TREE
888 && !current_binding_level
->tag_transparent
));
891 /* Identify this binding level as a level of parameters. */
894 declare_parm_level ()
896 current_binding_level
->parm_flag
= 1;
900 declare_pseudo_global_level ()
902 current_binding_level
->pseudo_global
= 1;
906 declare_namespace_level ()
908 current_binding_level
->namespace_p
= 1;
912 pseudo_global_level_p ()
914 struct binding_level
*b
= innermost_nonclass_level ();
916 return b
->pseudo_global
;
920 set_class_shadows (shadows
)
923 class_binding_level
->class_shadowed
= shadows
;
926 /* Enter a new binding level.
927 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
928 not for that of tags. */
931 pushlevel (tag_transparent
)
934 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
936 /* If this is the top level of a function,
937 just make sure that NAMED_LABELS is 0.
938 They should have been set to 0 at the end of the previous function. */
940 if (current_binding_level
== global_binding_level
)
941 my_friendly_assert (named_labels
== NULL_TREE
, 134);
943 /* Reuse or create a struct for this binding level. */
945 #if defined(DEBUG_CP_BINDING_LEVELS)
947 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
948 if (free_binding_level
)
949 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
951 newlevel
= free_binding_level
;
952 free_binding_level
= free_binding_level
->level_chain
;
956 newlevel
= make_binding_level ();
959 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
960 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
961 keep_next_level_flag
= 0;
965 note_level_for_for ()
967 current_binding_level
->is_for_scope
= 1;
971 pushlevel_temporary (tag_transparent
)
974 pushlevel (tag_transparent
);
975 current_binding_level
->keep
= 2;
978 /* Note we don't call push_momentary() here. Otherwise, it would cause
979 cleanups to be allocated on the momentary obstack, and they will be
980 overwritten by the next statement. */
982 expand_start_bindings (0);
985 /* For a binding between a name and an entity at a block scope,
986 this is the `struct binding_level' for the block. */
987 #define BINDING_LEVEL(NODE) \
988 (((struct tree_binding*)NODE)->scope.level)
990 /* These are currently unused, but permanent, CPLUS_BINDING nodes.
991 They are kept here because they are allocated from the permanent
992 obstack and cannot be easily freed. */
993 static tree free_binding_nodes
;
995 /* Make DECL the innermost binding for ID. The LEVEL is the binding
996 level at which this declaration is being bound. */
999 push_binding (id
, decl
, level
)
1002 struct binding_level
* level
;
1006 if (!free_binding_nodes
)
1008 /* There are no free nodes, so we must build one here. */
1009 push_obstacks_nochange ();
1010 end_temporary_allocation ();
1011 binding
= make_node (CPLUS_BINDING
);
1016 /* There are nodes on the free list. Grab the first one. */
1017 binding
= free_binding_nodes
;
1019 /* And update the free list. */
1020 free_binding_nodes
= TREE_CHAIN (free_binding_nodes
);
1023 /* Now, fill in the binding information. */
1024 BINDING_VALUE (binding
) = decl
;
1025 BINDING_TYPE (binding
) = NULL_TREE
;
1026 BINDING_LEVEL (binding
) = level
;
1027 INHERITED_VALUE_BINDING_P (binding
) = 0;
1028 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
1030 /* And put it on the front of the list of bindings for ID. */
1031 TREE_CHAIN (binding
) = IDENTIFIER_BINDING (id
);
1032 IDENTIFIER_BINDING (id
) = binding
;
1035 /* ID is already bound in the current scope. But, DECL is an
1036 additional binding for ID in the same scope. This is the `struct
1037 stat' hack whereby a non-typedef class-name or enum-name can be
1038 bound at the same level as some other kind of entity. It's the
1039 responsibility of the caller to check that inserting this name is
1040 legal here. Returns nonzero if the new binding was successful. */
1042 add_binding (id
, decl
)
1046 tree binding
= IDENTIFIER_BINDING (id
);
1049 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
1050 /* The new name is the type name. */
1051 BINDING_TYPE (binding
) = decl
;
1052 else if (!BINDING_VALUE (binding
))
1053 /* This situation arises when push_class_level_binding moves an
1054 inherited type-binding out of the way to make room for a new
1056 BINDING_VALUE (binding
) = decl
;
1057 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1058 && DECL_ARTIFICIAL (BINDING_VALUE (binding
)))
1060 /* The old binding was a type name. It was placed in
1061 BINDING_VALUE because it was thought, at the point it was
1062 declared, to be the only entity with such a name. Move the
1063 type name into the type slot; it is now hidden by the new
1065 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
1066 BINDING_VALUE (binding
) = decl
;
1067 INHERITED_VALUE_BINDING_P (binding
) = 0;
1069 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1070 && TREE_CODE (decl
) == TYPE_DECL
1071 && DECL_NAME (decl
) == DECL_NAME (BINDING_VALUE (binding
))
1072 && same_type_p (TREE_TYPE (decl
),
1073 TREE_TYPE (BINDING_VALUE (binding
))))
1074 /* We have two typedef-names, both naming the same type to have
1075 the same name. This is OK because of:
1079 In a given scope, a typedef specifier can be used to redefine
1080 the name of any type declared in that scope to refer to the
1081 type to which it already refers. */
1085 cp_error ("declaration of `%#D'", decl
);
1086 cp_error_at ("conflicts with previous declaration `%#D'",
1087 BINDING_VALUE (binding
));
1094 /* Bind DECL to ID in the current_binding_level.
1095 If PUSH_USING is set in FLAGS, we know that DECL doesn't really belong
1096 to this binding level, that it got here through a using-declaration. */
1099 push_local_binding (id
, decl
, flags
)
1104 struct binding_level
*b
;
1106 /* Skip over any local classes. This makes sense if we call
1107 push_local_binding with a friend decl of a local class. */
1108 b
= current_binding_level
;
1109 while (b
->parm_flag
== 2)
1112 if (lookup_name_current_level (id
))
1114 /* Supplement the existing binding. */
1115 if (!add_binding (id
, decl
))
1116 /* It didn't work. Something else must be bound at this
1117 level. Do not add DECL to the list of things to pop
1122 /* Create a new binding. */
1123 push_binding (id
, decl
, b
);
1125 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1126 /* We must put the OVERLOAD into a TREE_LIST since the
1127 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1128 decls that got here through a using-declaration. */
1129 decl
= build_tree_list (NULL_TREE
, decl
);
1131 /* And put DECL on the list of things declared by the current
1133 TREE_CHAIN (decl
) = b
->names
;
1137 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1138 binding was successful. */
1141 push_class_binding (id
, decl
)
1146 tree binding
= IDENTIFIER_BINDING (id
);
1149 /* Note that we declared this value so that we can issue an error if
1150 this an illegal redeclaration of a name already used for some
1152 note_name_declared_in_class (id
, decl
);
1154 if (binding
&& BINDING_LEVEL (binding
) == class_binding_level
)
1155 /* Supplement the existing binding. */
1156 result
= add_binding (id
, decl
);
1158 /* Create a new binding. */
1159 push_binding (id
, decl
, class_binding_level
);
1161 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1162 class-level declaration. Note that we do not use DECL here
1163 because of the possibility of the `struct stat' hack; if DECL is
1164 a class-name or enum-name we might prefer a field-name, or some
1166 IDENTIFIER_CLASS_VALUE (id
) = BINDING_VALUE (IDENTIFIER_BINDING (id
));
1168 /* If this is a binding from a base class, mark it as such. */
1169 binding
= IDENTIFIER_BINDING (id
);
1170 if (BINDING_VALUE (binding
) == decl
&& TREE_CODE (decl
) != TREE_LIST
)
1172 /* Any implicit typename must be from a base-class. The
1173 context for an implicit typename declaration is always
1174 the derived class in which the lookup was done, so the checks
1175 based on the context of DECL below will not trigger. */
1176 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl
))
1177 INHERITED_VALUE_BINDING_P (binding
) = 1;
1180 if (TREE_CODE (decl
) == OVERLOAD
)
1181 context
= DECL_REAL_CONTEXT (OVL_CURRENT (decl
));
1184 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd',
1186 context
= DECL_REAL_CONTEXT (decl
);
1189 if (is_properly_derived_from (current_class_type
, context
))
1190 INHERITED_VALUE_BINDING_P (binding
) = 1;
1192 INHERITED_VALUE_BINDING_P (binding
) = 0;
1195 else if (BINDING_VALUE (binding
) == decl
)
1196 /* We only encounter a TREE_LIST when push_class_decls detects an
1197 ambiguity. Such an ambiguity can be overridden by a definition
1199 INHERITED_VALUE_BINDING_P (binding
) = 1;
1204 /* Remove the binding for DECL which should be the innermost binding
1208 pop_binding (id
, decl
)
1214 if (id
== NULL_TREE
)
1215 /* It's easiest to write the loops that call this function without
1216 checking whether or not the entities involved have names. We
1217 get here for such an entity. */
1220 /* Get the innermost binding for ID. */
1221 binding
= IDENTIFIER_BINDING (id
);
1223 /* The name should be bound. */
1224 my_friendly_assert (binding
!= NULL_TREE
, 0);
1226 /* The DECL will be either the ordinary binding or the type
1227 binding for this identifier. Remove that binding. */
1228 if (BINDING_VALUE (binding
) == decl
)
1229 BINDING_VALUE (binding
) = NULL_TREE
;
1230 else if (BINDING_TYPE (binding
) == decl
)
1231 BINDING_TYPE (binding
) = NULL_TREE
;
1233 my_friendly_abort (0);
1235 if (!BINDING_VALUE (binding
) && !BINDING_TYPE (binding
))
1237 /* We're completely done with the innermost binding for this
1238 identifier. Unhook it from the list of bindings. */
1239 IDENTIFIER_BINDING (id
) = TREE_CHAIN (binding
);
1241 /* And place it on the free list. */
1242 TREE_CHAIN (binding
) = free_binding_nodes
;
1243 free_binding_nodes
= binding
;
1247 /* Exit a binding level.
1248 Pop the level off, and restore the state of the identifier-decl mappings
1249 that were in effect when this level was entered.
1251 If KEEP == 1, this level had explicit declarations, so
1252 and create a "block" (a BLOCK node) for the level
1253 to record its declarations and subblocks for symbol table output.
1255 If FUNCTIONBODY is nonzero, this level is the body of a function,
1256 so create a block as if KEEP were set and also clear out all
1259 If REVERSE is nonzero, reverse the order of decls before putting
1260 them into the BLOCK. */
1263 poplevel (keep
, reverse
, functionbody
)
1269 /* The chain of decls was accumulated in reverse order.
1270 Put it into forward order, just for cleanliness. */
1272 int tmp
= functionbody
;
1273 int real_functionbody
= current_binding_level
->keep
== 2
1274 ? ((functionbody
= 0), tmp
) : functionbody
;
1275 tree tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1276 tree subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1277 tree block
= NULL_TREE
;
1279 int block_previously_created
;
1280 int leaving_for_scope
;
1282 if (current_binding_level
->parm_flag
== 2)
1283 return poplevel_class ();
1285 my_friendly_assert (!current_binding_level
->class_shadowed
,
1288 /* We used to use KEEP == 2 to indicate that the new block should go
1289 at the beginning of the list of blocks at this binding level,
1290 rather than the end. This hack is no longer used. */
1291 my_friendly_assert (keep
== 0 || keep
== 1, 0);
1293 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1294 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1295 current_binding_level
->parm_flag
,
1296 current_binding_level
->keep
);
1298 if (current_binding_level
->keep
== 1)
1301 /* Get the decls in the order they were written.
1302 Usually current_binding_level->names is in reverse order.
1303 But parameter decls were previously put in forward order. */
1306 current_binding_level
->names
1307 = decls
= nreverse (current_binding_level
->names
);
1309 decls
= current_binding_level
->names
;
1311 /* Output any nested inline functions within this block
1312 if they weren't already output. */
1314 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1315 if (TREE_CODE (decl
) == FUNCTION_DECL
1316 && ! TREE_ASM_WRITTEN (decl
)
1317 && DECL_INITIAL (decl
) != NULL_TREE
1318 && TREE_ADDRESSABLE (decl
)
1319 && decl_function_context (decl
) == current_function_decl
)
1321 /* If this decl was copied from a file-scope decl
1322 on account of a block-scope extern decl,
1323 propagate TREE_ADDRESSABLE to the file-scope decl. */
1324 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1325 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1328 push_function_context ();
1329 output_inline_function (decl
);
1330 pop_function_context ();
1334 /* If there were any declarations or structure tags in that level,
1335 or if this level is a function body,
1336 create a BLOCK to record them for the life of this function. */
1339 block_previously_created
= (current_binding_level
->this_block
!= NULL_TREE
);
1340 if (block_previously_created
)
1341 block
= current_binding_level
->this_block
;
1342 else if (keep
== 1 || functionbody
)
1343 block
= make_node (BLOCK
);
1344 if (block
!= NULL_TREE
)
1346 if (block_previously_created
)
1348 if (decls
|| tags
|| subblocks
)
1350 if (BLOCK_VARS (block
) || BLOCK_TYPE_TAGS (block
))
1351 warning ("internal compiler error: debugging info corrupted");
1353 BLOCK_VARS (block
) = decls
;
1354 BLOCK_TYPE_TAGS (block
) = tags
;
1356 /* We can have previous subblocks and new subblocks when
1357 doing fixup_gotos with complex cleanups. We chain the new
1358 subblocks onto the end of any pre-existing subblocks. */
1359 BLOCK_SUBBLOCKS (block
) = chainon (BLOCK_SUBBLOCKS (block
),
1362 /* If we created the block earlier on, and we are just
1363 diddling it now, then it already should have a proper
1364 BLOCK_END_NOTE value associated with it. */
1368 BLOCK_VARS (block
) = decls
;
1369 BLOCK_TYPE_TAGS (block
) = tags
;
1370 BLOCK_SUBBLOCKS (block
) = subblocks
;
1371 /* Otherwise, for a new block, install a new BLOCK_END_NOTE
1373 remember_end_note (block
);
1377 /* In each subblock, record that this is its superior. */
1380 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1381 BLOCK_SUPERCONTEXT (link
) = block
;
1383 /* We still support the old for-scope rules, whereby the variables
1384 in a for-init statement were in scope after the for-statement
1385 ended. We only use the new rules in flag_new_for_scope is
1388 = current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1;
1390 /* Remove declarations for all the DECLs in this level. */
1391 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1393 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
)
1396 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link
)));
1400 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link
));
1402 ns_binding
= NULL_TREE
;
1405 && (BINDING_LEVEL (outer_binding
)
1406 == current_binding_level
->level_chain
))
1407 /* We have something like:
1412 and we are leaving the `for' scope. There's no reason to
1413 keep the binding of the inner `i' in this case. */
1414 pop_binding (DECL_NAME (link
), link
);
1415 else if ((outer_binding
1416 && (TREE_CODE (BINDING_VALUE (outer_binding
))
1419 && TREE_CODE (ns_binding
) == TYPE_DECL
))
1420 /* Here, we have something like:
1428 We must pop the for-scope binding so we know what's a
1429 type and what isn't. */
1430 pop_binding (DECL_NAME (link
), link
);
1433 /* Mark this VAR_DECL as dead so that we can tell we left it
1434 there only for backward compatibility. */
1435 DECL_DEAD_FOR_LOCAL (link
) = 1;
1437 /* Keep track of what should of have happenned when we
1438 popped the binding. */
1439 if (outer_binding
&& BINDING_VALUE (outer_binding
))
1440 DECL_SHADOWED_FOR_VAR (link
)
1441 = BINDING_VALUE (outer_binding
);
1443 /* Add it to the list of dead variables in the next
1444 outermost binding to that we can remove these when we
1445 leave that binding. */
1446 current_binding_level
->level_chain
->dead_vars_from_for
1447 = tree_cons (NULL_TREE
, link
,
1448 current_binding_level
->level_chain
->
1449 dead_vars_from_for
);
1451 /* Although we don't pop the CPLUS_BINDING, we do clear
1452 its BINDING_LEVEL since the level is going away now. */
1453 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link
)))
1459 /* Remove the binding. */
1461 if (TREE_CODE (decl
) == TREE_LIST
)
1462 decl
= TREE_VALUE (decl
);
1463 if (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd')
1464 pop_binding (DECL_NAME (decl
), decl
);
1465 else if (TREE_CODE (decl
) == OVERLOAD
)
1466 pop_binding (DECL_NAME (OVL_FUNCTION (decl
)), decl
);
1468 my_friendly_abort (0);
1472 /* Remove declarations for any `for' variables from inner scopes
1473 that we kept around. */
1474 for (link
= current_binding_level
->dead_vars_from_for
;
1475 link
; link
= TREE_CHAIN (link
))
1476 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
1478 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1479 for (link
= current_binding_level
->type_shadowed
;
1480 link
; link
= TREE_CHAIN (link
))
1481 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1483 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1484 list if a `using' declaration put them there. The debugging
1485 back-ends won't understand OVERLOAD, so we remove them here.
1486 Because the BLOCK_VARS are (temporarily) shared with
1487 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1488 popped all the bindings. */
1493 for (d
= &BLOCK_VARS (block
); *d
; )
1495 if (TREE_CODE (*d
) == TREE_LIST
)
1496 *d
= TREE_CHAIN (*d
);
1498 d
= &TREE_CHAIN (*d
);
1502 /* If the level being exited is the top level of a function,
1503 check over all the labels. */
1507 /* If this is the top level block of a function,
1508 the vars are the function's parameters.
1509 Don't leave them in the BLOCK because they are
1510 found in the FUNCTION_DECL instead. */
1512 BLOCK_VARS (block
) = 0;
1514 /* Clear out the definitions of all label names,
1515 since their scopes end here. */
1517 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1519 register tree label
= TREE_VALUE (link
);
1521 if (DECL_INITIAL (label
) == NULL_TREE
)
1523 cp_error_at ("label `%D' used but not defined", label
);
1524 /* Avoid crashing later. */
1525 define_label (input_filename
, 1, DECL_NAME (label
));
1527 else if (warn_unused
&& !TREE_USED (label
))
1528 cp_warning_at ("label `%D' defined but not used", label
);
1529 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), NULL_TREE
);
1531 /* Put the labels into the "variables" of the
1532 top-level block, so debugger can see them. */
1533 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1534 BLOCK_VARS (block
) = label
;
1537 named_labels
= NULL_TREE
;
1540 /* Any uses of undefined labels now operate under constraints
1541 of next binding contour. */
1543 struct binding_level
*level_chain
;
1544 level_chain
= current_binding_level
->level_chain
;
1547 struct named_label_list
*labels
;
1548 for (labels
= named_label_uses
; labels
; labels
= labels
->next
)
1549 if (labels
->binding_level
== current_binding_level
)
1551 labels
->binding_level
= level_chain
;
1552 labels
->names_in_scope
= level_chain
->names
;
1557 tmp
= current_binding_level
->keep
;
1559 pop_binding_level ();
1561 DECL_INITIAL (current_function_decl
) = block
;
1564 if (!block_previously_created
)
1565 current_binding_level
->blocks
1566 = chainon (current_binding_level
->blocks
, block
);
1568 /* If we did not make a block for the level just exited,
1569 any blocks made for inner levels
1570 (since they cannot be recorded as subblocks in that level)
1571 must be carried forward so they will later become subblocks
1572 of something else. */
1574 current_binding_level
->blocks
1575 = chainon (current_binding_level
->blocks
, subblocks
);
1577 /* Take care of compiler's internal binding structures. */
1580 expand_end_bindings (getdecls (), keep
, 1);
1581 /* Each and every BLOCK node created here in `poplevel' is important
1582 (e.g. for proper debugging information) so if we created one
1583 earlier, mark it as "used". */
1585 TREE_USED (block
) = 1;
1586 block
= poplevel (keep
, reverse
, real_functionbody
);
1589 /* Each and every BLOCK node created here in `poplevel' is important
1590 (e.g. for proper debugging information) so if we created one
1591 earlier, mark it as "used". */
1593 TREE_USED (block
) = 1;
1597 /* Delete the node BLOCK from the current binding level.
1598 This is used for the block inside a stmt expr ({...})
1599 so that the block can be reinserted where appropriate. */
1602 delete_block (block
)
1606 if (current_binding_level
->blocks
== block
)
1607 current_binding_level
->blocks
= TREE_CHAIN (block
);
1608 for (t
= current_binding_level
->blocks
; t
;)
1610 if (TREE_CHAIN (t
) == block
)
1611 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1615 TREE_CHAIN (block
) = NULL_TREE
;
1616 /* Clear TREE_USED which is always set by poplevel.
1617 The flag is set again if insert_block is called. */
1618 TREE_USED (block
) = 0;
1621 /* Insert BLOCK at the end of the list of subblocks of the
1622 current binding level. This is used when a BIND_EXPR is expanded,
1623 to handle the BLOCK node inside the BIND_EXPR. */
1626 insert_block (block
)
1629 TREE_USED (block
) = 1;
1630 current_binding_level
->blocks
1631 = chainon (current_binding_level
->blocks
, block
);
1634 /* Set the BLOCK node for the innermost scope
1635 (the one we are currently in). */
1639 register tree block
;
1641 current_binding_level
->this_block
= block
;
1644 /* Do a pushlevel for class declarations. */
1649 register struct binding_level
*newlevel
;
1651 /* Reuse or create a struct for this binding level. */
1652 #if defined(DEBUG_CP_BINDING_LEVELS)
1654 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1655 if (free_binding_level
)
1656 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1658 newlevel
= free_binding_level
;
1659 free_binding_level
= free_binding_level
->level_chain
;
1662 newlevel
= make_binding_level ();
1664 #if defined(DEBUG_CP_BINDING_LEVELS)
1666 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1668 push_binding_level (newlevel
, 0, 0);
1670 decl_stack
= push_decl_level (decl_stack
, &decl_obstack
);
1671 class_binding_level
= current_binding_level
;
1672 class_binding_level
->parm_flag
= 2;
1675 /* ...and a poplevel for class declarations. */
1680 register struct binding_level
*level
= class_binding_level
;
1683 my_friendly_assert (level
!= 0, 354);
1685 decl_stack
= pop_stack_level (decl_stack
);
1686 /* If we're leaving a toplevel class, don't bother to do the setting
1687 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1688 shouldn't even be used when current_class_type isn't set, and second,
1689 if we don't touch it here, we're able to use the cache effect if the
1690 next time we're entering a class scope, it is the same class. */
1691 if (current_class_depth
!= 1)
1693 struct binding_level
* b
;
1695 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1696 for (shadowed
= level
->class_shadowed
;
1698 shadowed
= TREE_CHAIN (shadowed
))
1699 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = NULL_TREE
;
1701 /* Find the next enclosing class, and recreate
1702 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1703 b
= level
->level_chain
;
1704 while (b
&& b
->parm_flag
!= 2)
1708 for (shadowed
= b
->class_shadowed
;
1710 shadowed
= TREE_CHAIN (shadowed
))
1714 t
= IDENTIFIER_BINDING (TREE_PURPOSE (shadowed
));
1715 while (t
&& BINDING_LEVEL (t
) != b
)
1719 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
))
1720 = BINDING_VALUE (t
);
1724 /* Remember to save what IDENTIFIER's were bound in this scope so we
1725 can recover from cache misses. */
1727 previous_class_type
= current_class_type
;
1728 previous_class_values
= class_binding_level
->class_shadowed
;
1730 for (shadowed
= level
->type_shadowed
;
1732 shadowed
= TREE_CHAIN (shadowed
))
1733 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1735 /* Remove the bindings for all of the class-level declarations. */
1736 for (shadowed
= level
->class_shadowed
;
1738 shadowed
= TREE_CHAIN (shadowed
))
1739 pop_binding (TREE_PURPOSE (shadowed
), TREE_TYPE (shadowed
));
1741 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1742 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1743 class_binding_level
->parm_flag
,
1744 class_binding_level
->keep
);
1746 /* Now, pop out of the binding level which we created up in the
1747 `pushlevel_class' routine. */
1748 #if defined(DEBUG_CP_BINDING_LEVELS)
1750 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1752 pop_binding_level ();
1757 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1758 for any names in enclosing classes. */
1761 clear_identifier_class_values ()
1765 if (!class_binding_level
)
1768 for (t
= class_binding_level
->class_shadowed
;
1771 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t
)) = NULL_TREE
;
1774 /* Returns non-zero if T is a virtual function table. */
1777 vtable_decl_p (t
, data
)
1779 void *data ATTRIBUTE_UNUSED
;
1781 return (TREE_CODE (t
) == VAR_DECL
&& DECL_VIRTUAL_P (t
));
1784 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1788 vtype_decl_p (t
, data
)
1790 void *data ATTRIBUTE_UNUSED
;
1792 return (TREE_CODE (t
) == TYPE_DECL
1793 && TREE_TYPE (t
) != error_mark_node
1794 && TYPE_LANG_SPECIFIC (TREE_TYPE (t
))
1795 && CLASSTYPE_VSIZE (TREE_TYPE (t
)));
1798 /* Returns non-zero if T is a signature table. */
1801 sigtable_decl_p (t
, data
)
1803 void *data ATTRIBUTE_UNUSED
;
1805 return (TREE_CODE (t
) == VAR_DECL
1806 && TREE_TYPE (t
) != error_mark_node
1807 && IS_SIGNATURE (TREE_TYPE (t
)));
1810 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1811 itself, calling F for each. The DATA is passed to F as well. */
1814 walk_namespaces_r (namespace, f
, data
)
1816 walk_namespaces_fn f
;
1822 result
|= (*f
) (namespace, data
);
1824 for (current
= NAMESPACE_LEVEL (namespace)->names
;
1826 current
= TREE_CHAIN (current
))
1828 if (TREE_CODE (current
) != NAMESPACE_DECL
1829 || DECL_NAMESPACE_ALIAS (current
))
1831 if (!DECL_LANG_SPECIFIC (current
))
1834 my_friendly_assert (current
== std_node
, 393);
1838 /* We found a namespace. */
1839 result
|= walk_namespaces_r (current
, f
, data
);
1845 /* Walk all the namespaces, calling F for each. The DATA is passed to
1849 walk_namespaces (f
, data
)
1850 walk_namespaces_fn f
;
1853 return walk_namespaces_r (global_namespace
, f
, data
);
1856 struct walk_globals_data
{
1857 walk_globals_pred p
;
1862 /* Walk the global declarations in NAMESPACE. Whenever one is found
1863 for which P returns non-zero, call F with its address. If any call
1864 to F returns a non-zero value, return a non-zero value. */
1867 walk_globals_r (namespace, data
)
1871 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
1872 walk_globals_pred p
= wgd
->p
;
1873 walk_globals_fn f
= wgd
->f
;
1874 void *d
= wgd
->data
;
1878 t
= &NAMESPACE_LEVEL (namespace)->names
;
1885 result
|= (*f
) (t
, d
);
1887 /* If F changed *T, then *T still points at the next item to
1890 t
= &TREE_CHAIN (*t
);
1896 /* Walk the global declarations. Whenever one is found for which P
1897 returns non-zero, call F with its address. If any call to F
1898 returns a non-zero value, return a non-zero value. */
1901 walk_globals (p
, f
, data
)
1902 walk_globals_pred p
;
1906 struct walk_globals_data wgd
;
1911 return walk_namespaces (walk_globals_r
, &wgd
);
1914 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1915 DATA is non-NULL, this is the last time we will call
1916 wrapup_global_declarations for this NAMESPACE. */
1919 wrapup_globals_for_namespace (namespace, data
)
1923 tree globals
= NAMESPACE_LEVEL (namespace)->names
;
1924 int len
= list_length (globals
);
1925 tree
*vec
= (tree
*) alloca (sizeof (tree
) * len
);
1929 int last_time
= (data
!= 0);
1931 if (last_time
&& namespace == global_namespace
)
1932 /* Let compile_file handle the global namespace. */
1935 /* Process the decls in reverse order--earliest first.
1936 Put them into VEC from back to front, then take out from front. */
1938 for (i
= 0, decl
= globals
; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
1939 vec
[len
- i
- 1] = decl
;
1943 check_global_declarations (vec
, len
);
1947 /* Temporarily mark vtables as external. That prevents
1948 wrapup_global_declarations from writing them out; we must process
1949 them ourselves in finish_vtable_vardecl. */
1950 for (i
= 0; i
< len
; ++i
)
1951 if (vtable_decl_p (vec
[i
], /*data=*/0) && !DECL_EXTERNAL (vec
[i
]))
1953 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 1;
1954 DECL_EXTERNAL (vec
[i
]) = 1;
1957 /* Write out any globals that need to be output. */
1958 result
= wrapup_global_declarations (vec
, len
);
1960 /* Undo the hack to DECL_EXTERNAL above. */
1961 for (i
= 0; i
< len
; ++i
)
1962 if (vtable_decl_p (vec
[i
], /*data=*/0)
1963 && DECL_NOT_REALLY_EXTERN (vec
[i
]))
1965 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 0;
1966 DECL_EXTERNAL (vec
[i
]) = 0;
1973 /* For debugging. */
1974 static int no_print_functions
= 0;
1975 static int no_print_builtins
= 0;
1978 print_binding_level (lvl
)
1979 struct binding_level
*lvl
;
1983 fprintf (stderr
, " blocks=");
1984 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
1985 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
1986 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
1987 if (lvl
->tag_transparent
)
1988 fprintf (stderr
, " tag-transparent");
1989 if (lvl
->more_cleanups_ok
)
1990 fprintf (stderr
, " more-cleanups-ok");
1991 if (lvl
->have_cleanups
)
1992 fprintf (stderr
, " have-cleanups");
1993 fprintf (stderr
, "\n");
1996 fprintf (stderr
, " names:\t");
1997 /* We can probably fit 3 names to a line? */
1998 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
2000 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
2002 if (no_print_builtins
2003 && (TREE_CODE (t
) == TYPE_DECL
)
2004 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
2007 /* Function decls tend to have longer names. */
2008 if (TREE_CODE (t
) == FUNCTION_DECL
)
2015 fprintf (stderr
, "\n\t");
2018 print_node_brief (stderr
, "", t
, 0);
2019 if (t
== error_mark_node
)
2023 fprintf (stderr
, "\n");
2027 fprintf (stderr
, " tags:\t");
2029 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
2031 if (TREE_PURPOSE (t
) == NULL_TREE
)
2033 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2040 fprintf (stderr
, "\n\t");
2043 if (TREE_PURPOSE (t
) == NULL_TREE
)
2045 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
2046 fprintf (stderr
, ">");
2048 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2049 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2052 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
2053 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2054 fprintf (stderr
, ">");
2058 fprintf (stderr
, "\n");
2060 if (lvl
->class_shadowed
)
2062 fprintf (stderr
, " class-shadowed:");
2063 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
2065 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2067 fprintf (stderr
, "\n");
2069 if (lvl
->type_shadowed
)
2071 fprintf (stderr
, " type-shadowed:");
2072 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2074 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2076 fprintf (stderr
, "\n");
2081 print_other_binding_stack (stack
)
2082 struct binding_level
*stack
;
2084 struct binding_level
*level
;
2085 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
2087 fprintf (stderr
, "binding level ");
2088 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
2089 fprintf (stderr
, "\n");
2090 print_binding_level (level
);
2095 print_binding_stack ()
2097 struct binding_level
*b
;
2098 fprintf (stderr
, "current_binding_level=");
2099 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
2100 fprintf (stderr
, "\nclass_binding_level=");
2101 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
2102 fprintf (stderr
, "\nglobal_binding_level=");
2103 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
2104 fprintf (stderr
, "\n");
2105 if (class_binding_level
)
2107 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
2108 if (b
== current_binding_level
)
2111 b
= class_binding_level
;
2113 b
= current_binding_level
;
2116 b
= current_binding_level
;
2117 print_other_binding_stack (b
);
2118 fprintf (stderr
, "global:\n");
2119 print_binding_level (global_binding_level
);
2122 /* Namespace binding access routines: The namespace_bindings field of
2123 the identifier is polymorphic, with three possible values:
2124 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2125 indicating the BINDING_VALUE of global_namespace. */
2127 /* Check whether the a binding for the name to scope is known.
2128 Assumes that the bindings of the name are already a list
2129 of bindings. Returns the binding found, or NULL_TREE. */
2132 find_binding (name
, scope
)
2136 tree iter
, prev
= NULL_TREE
;
2138 scope
= ORIGINAL_NAMESPACE (scope
);
2140 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
2141 iter
= TREE_CHAIN (iter
))
2143 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
2144 if (BINDING_SCOPE (iter
) == scope
)
2146 /* Move binding found to the fron of the list, so
2147 subsequent lookups will find it faster. */
2150 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
2151 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
2152 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
2161 /* Always returns a binding for name in scope. If the
2162 namespace_bindings is not a list, convert it to one first.
2163 If no binding is found, make a new one. */
2166 binding_for_name (name
, scope
)
2170 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2173 scope
= ORIGINAL_NAMESPACE (scope
);
2175 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
2177 /* Get rid of optimization for global scope. */
2178 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
2179 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
2180 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2182 if (b
&& (result
= find_binding (name
, scope
)))
2184 /* Not found, make a new permanent one. */
2185 push_obstacks (&permanent_obstack
, &permanent_obstack
);
2186 result
= make_node (CPLUS_BINDING
);
2187 TREE_CHAIN (result
) = b
;
2188 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2189 BINDING_SCOPE (result
) = scope
;
2190 BINDING_TYPE (result
) = NULL_TREE
;
2191 BINDING_VALUE (result
) = NULL_TREE
;
2196 /* Return the binding value for name in scope, considering that
2197 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2200 namespace_binding (name
, scope
)
2204 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2207 if (scope
== NULL_TREE
)
2208 scope
= global_namespace
;
2209 if (TREE_CODE (b
) != CPLUS_BINDING
)
2210 return (scope
== global_namespace
) ? b
: NULL_TREE
;
2211 name
= find_binding (name
,scope
);
2212 if (name
== NULL_TREE
)
2214 return BINDING_VALUE (name
);
2217 /* Set the binding value for name in scope. If modifying the binding
2218 of global_namespace is attempted, try to optimize it. */
2221 set_namespace_binding (name
, scope
, val
)
2228 if (scope
== NULL_TREE
)
2229 scope
= global_namespace
;
2231 if (scope
== global_namespace
)
2233 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2234 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
2236 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
2240 b
= binding_for_name (name
, scope
);
2241 BINDING_VALUE (b
) = val
;
2244 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2245 select a name that is unique to this compilation unit. */
2248 push_namespace (name
)
2253 int implicit_use
= 0;
2255 if (!global_namespace
)
2257 /* This must be ::. */
2258 my_friendly_assert (name
== get_identifier ("::"), 377);
2263 /* The name of anonymous namespace is unique for the translation
2265 if (!anonymous_namespace_name
)
2266 anonymous_namespace_name
= get_file_function_name ('N');
2267 name
= anonymous_namespace_name
;
2268 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2270 /* Reopening anonymous namespace. */
2274 else if (current_namespace
== global_namespace
2275 && name
== DECL_NAME (std_node
))
2282 /* Check whether this is an extended namespace definition. */
2283 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2284 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2287 if (DECL_NAMESPACE_ALIAS (d
))
2289 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2290 d
, DECL_NAMESPACE_ALIAS (d
));
2291 d
= DECL_NAMESPACE_ALIAS (d
);
2298 /* Make a new namespace, binding the name to it. */
2299 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2300 /* The global namespace is not pushed, and the global binding
2301 level is set elsewhere. */
2306 declare_namespace_level ();
2307 NAMESPACE_LEVEL (d
) = current_binding_level
;
2311 resume_binding_level (NAMESPACE_LEVEL (d
));
2314 do_using_directive (d
);
2315 /* Enter the name space. */
2316 current_namespace
= d
;
2319 /* Pop from the scope of the current namespace. */
2324 if (current_namespace
== global_namespace
)
2326 my_friendly_assert (in_std
>0, 980421);
2330 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2331 /* The binding level is not popped, as it might be re-opened later. */
2332 suspend_binding_level ();
2335 /* Push into the scope of the namespace NS, even if it is deeply
2336 nested within another namespace. */
2339 push_nested_namespace (ns
)
2342 if (ns
== global_namespace
)
2343 push_to_top_level ();
2346 push_nested_namespace (CP_DECL_CONTEXT (ns
));
2347 push_namespace (DECL_NAME (ns
));
2351 /* Pop back from the scope of the namespace NS, which was previously
2352 entered with push_nested_namespace. */
2355 pop_nested_namespace (ns
)
2358 while (ns
!= global_namespace
)
2361 ns
= CP_DECL_CONTEXT (ns
);
2364 pop_from_top_level ();
2368 /* Subroutines for reverting temporarily to top-level for instantiation
2369 of templates and such. We actually need to clear out the class- and
2370 local-value slots of all identifiers, so that only the global values
2371 are at all visible. Simply setting current_binding_level to the global
2372 scope isn't enough, because more binding levels may be pushed. */
2373 struct saved_scope
{
2374 struct binding_level
*old_binding_level
;
2377 struct saved_scope
*prev
;
2378 tree class_name
, class_type
;
2379 tree access_specifier
;
2381 struct binding_level
*class_bindings
;
2382 tree
*lang_base
, *lang_stack
, lang_name
;
2384 int minimal_parse_mode
;
2385 tree last_function_parms
;
2386 tree template_parms
;
2387 HOST_WIDE_INT processing_template_decl
;
2388 tree previous_class_type
, previous_class_values
;
2389 int processing_specialization
;
2390 int processing_explicit_instantiation
;
2391 char *class_cache_firstobj
;
2393 static struct saved_scope
*current_saved_scope
;
2395 /* A chain of the binding vecs created by store_bindings. We create a
2396 whole bunch of these during compilation, on permanent_obstack, so we
2397 can't just throw them away. */
2398 static tree free_binding_vecs
;
2401 store_bindings (names
, old_bindings
)
2402 tree names
, old_bindings
;
2405 for (t
= names
; t
; t
= TREE_CHAIN (t
))
2407 tree binding
, t1
, id
;
2409 if (TREE_CODE (t
) == TREE_LIST
)
2410 id
= TREE_PURPOSE (t
);
2415 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2416 we have no IDENTIFIER_BINDING if we have left the class
2417 scope, but cached the class-level declarations. */
2418 || !(IDENTIFIER_BINDING (id
) || IDENTIFIER_CLASS_VALUE (id
)))
2421 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
2422 if (TREE_VEC_ELT (t1
, 0) == id
)
2425 if (free_binding_vecs
)
2427 binding
= free_binding_vecs
;
2428 free_binding_vecs
= TREE_CHAIN (free_binding_vecs
);
2431 binding
= make_tree_vec (4);
2435 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
2436 TREE_VEC_ELT (binding
, 0) = id
;
2437 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
2438 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_BINDING (id
);
2439 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
2440 IDENTIFIER_BINDING (id
) = NULL_TREE
;
2441 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
2443 TREE_CHAIN (binding
) = old_bindings
;
2444 old_bindings
= binding
;
2448 return old_bindings
;
2452 maybe_push_to_top_level (pseudo
)
2455 extern int current_lang_stacksize
;
2456 struct saved_scope
*s
2457 = (struct saved_scope
*) xmalloc (sizeof (struct saved_scope
));
2458 struct binding_level
*b
= current_binding_level
;
2459 tree old_bindings
= NULL_TREE
;
2461 push_cp_function_context (NULL_TREE
);
2463 if (previous_class_type
)
2464 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
2466 /* Have to include global_binding_level, because class-level decls
2467 aren't listed anywhere useful. */
2468 for (; b
; b
= b
->level_chain
)
2472 /* Template IDs are inserted into the global level. If they were
2473 inserted into namespace level, finish_file wouldn't find them
2474 when doing pending instantiations. Therefore, don't stop at
2475 namespace level, but continue until :: . */
2476 if (b
== global_binding_level
|| (pseudo
&& b
->pseudo_global
))
2479 old_bindings
= store_bindings (b
->names
, old_bindings
);
2480 /* We also need to check class_shadowed to save class-level type
2481 bindings, since pushclass doesn't fill in b->names. */
2482 if (b
->parm_flag
== 2)
2483 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2485 /* Unwind type-value slots back to top level. */
2486 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2487 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2490 s
->old_binding_level
= current_binding_level
;
2491 current_binding_level
= b
;
2493 s
->old_namespace
= current_namespace
;
2494 s
->class_name
= current_class_name
;
2495 s
->class_type
= current_class_type
;
2496 s
->access_specifier
= current_access_specifier
;
2497 s
->function_decl
= current_function_decl
;
2498 s
->class_bindings
= class_binding_level
;
2499 s
->lang_stack
= current_lang_stack
;
2500 s
->lang_base
= current_lang_base
;
2501 s
->lang_stacksize
= current_lang_stacksize
;
2502 s
->lang_name
= current_lang_name
;
2503 s
->minimal_parse_mode
= minimal_parse_mode
;
2504 s
->last_function_parms
= last_function_parms
;
2505 s
->template_parms
= current_template_parms
;
2506 s
->processing_template_decl
= processing_template_decl
;
2507 s
->previous_class_type
= previous_class_type
;
2508 s
->previous_class_values
= previous_class_values
;
2509 s
->class_cache_firstobj
= class_cache_firstobj
;
2510 s
->processing_specialization
= processing_specialization
;
2511 s
->processing_explicit_instantiation
= processing_explicit_instantiation
;
2513 current_class_name
= current_class_type
= NULL_TREE
;
2514 current_function_decl
= NULL_TREE
;
2515 class_binding_level
= (struct binding_level
*)0;
2516 current_lang_stacksize
= 10;
2517 current_lang_stack
= current_lang_base
2518 = (tree
*) xmalloc (current_lang_stacksize
* sizeof (tree
));
2519 current_lang_name
= lang_name_cplusplus
;
2520 strict_prototype
= strict_prototypes_lang_cplusplus
;
2521 named_labels
= NULL_TREE
;
2522 shadowed_labels
= NULL_TREE
;
2523 minimal_parse_mode
= 0;
2524 previous_class_type
= previous_class_values
= NULL_TREE
;
2525 class_cache_firstobj
= 0;
2526 processing_specialization
= 0;
2527 processing_explicit_instantiation
= 0;
2528 current_template_parms
= NULL_TREE
;
2529 processing_template_decl
= 0;
2530 current_namespace
= global_namespace
;
2532 s
->prev
= current_saved_scope
;
2533 s
->old_bindings
= old_bindings
;
2534 current_saved_scope
= s
;
2536 push_obstacks (&permanent_obstack
, &permanent_obstack
);
2540 push_to_top_level ()
2542 maybe_push_to_top_level (0);
2546 pop_from_top_level ()
2548 extern int current_lang_stacksize
;
2549 struct saved_scope
*s
= current_saved_scope
;
2552 /* Clear out class-level bindings cache. */
2553 if (previous_class_type
)
2554 invalidate_class_lookup_cache ();
2558 current_binding_level
= s
->old_binding_level
;
2559 current_saved_scope
= s
->prev
;
2560 for (t
= s
->old_bindings
; t
; )
2563 tree id
= TREE_VEC_ELT (t
, 0);
2566 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2567 IDENTIFIER_BINDING (id
) = TREE_VEC_ELT (t
, 2);
2568 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2571 TREE_CHAIN (save
) = free_binding_vecs
;
2572 free_binding_vecs
= save
;
2574 current_namespace
= s
->old_namespace
;
2575 current_class_name
= s
->class_name
;
2576 current_class_type
= s
->class_type
;
2577 current_access_specifier
= s
->access_specifier
;
2578 current_function_decl
= s
->function_decl
;
2579 class_binding_level
= s
->class_bindings
;
2580 free (current_lang_base
);
2581 current_lang_base
= s
->lang_base
;
2582 current_lang_stack
= s
->lang_stack
;
2583 current_lang_name
= s
->lang_name
;
2584 current_lang_stacksize
= s
->lang_stacksize
;
2585 if (current_lang_name
== lang_name_cplusplus
)
2586 strict_prototype
= strict_prototypes_lang_cplusplus
;
2587 else if (current_lang_name
== lang_name_c
)
2588 strict_prototype
= strict_prototypes_lang_c
;
2589 minimal_parse_mode
= s
->minimal_parse_mode
;
2590 last_function_parms
= s
->last_function_parms
;
2591 current_template_parms
= s
->template_parms
;
2592 processing_template_decl
= s
->processing_template_decl
;
2593 previous_class_type
= s
->previous_class_type
;
2594 previous_class_values
= s
->previous_class_values
;
2595 processing_specialization
= s
->processing_specialization
;
2596 processing_explicit_instantiation
= s
->processing_explicit_instantiation
;
2597 class_cache_firstobj
= s
->class_cache_firstobj
;
2601 pop_cp_function_context (NULL_TREE
);
2604 /* Push a definition of struct, union or enum tag "name".
2605 into binding_level "b". "type" should be the type node,
2606 We assume that the tag "name" is not already defined.
2608 Note that the definition may really be just a forward reference.
2609 In that case, the TYPE_SIZE will be a NULL_TREE.
2611 C++ gratuitously puts all these tags in the name space. */
2613 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2614 record the shadowed value for this binding contour. TYPE is
2615 the type that ID maps to. */
2618 set_identifier_type_value_with_scope (id
, type
, b
)
2621 struct binding_level
*b
;
2623 if (!b
->namespace_p
)
2625 /* Shadow the marker, not the real thing, so that the marker
2626 gets restored later. */
2627 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2629 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2633 tree binding
= binding_for_name (id
, current_namespace
);
2634 BINDING_TYPE (binding
) = type
;
2635 /* Store marker instead of real type. */
2636 type
= global_type_node
;
2638 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2641 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2644 set_identifier_type_value (id
, type
)
2648 set_identifier_type_value_with_scope (id
, type
, current_binding_level
);
2651 /* Return the type associated with id. */
2654 identifier_type_value (id
)
2657 /* There is no type with that name, anywhere. */
2658 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2660 /* This is not the type marker, but the real thing. */
2661 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2662 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2663 /* Have to search for it. It must be on the global level, now.
2664 Ask lookup_name not to return non-types. */
2665 id
= lookup_name_real (id
, 2, 1, 0);
2667 return TREE_TYPE (id
);
2671 /* Pop off extraneous binding levels left over due to syntax errors.
2673 We don't pop past namespaces, as they might be valid. */
2678 #ifdef DEBUG_CP_BINDING_LEVELS
2679 fprintf (stderr
, "XXX entering pop_everything ()\n");
2681 while (!toplevel_bindings_p ())
2683 if (current_binding_level
->parm_flag
== 2)
2684 pop_nested_class ();
2688 #ifdef DEBUG_CP_BINDING_LEVELS
2689 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2693 /* The type TYPE is being declared. If it is a class template, or a
2694 specialization of a class template, do any processing required and
2695 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2696 being declared a friend. B is the binding level at which this TYPE
2699 Returns the TYPE_DECL for TYPE, which may have been altered by this
2703 maybe_process_template_type_declaration (type
, globalize
, b
)
2706 struct binding_level
* b
;
2708 tree decl
= TYPE_NAME (type
);
2710 if (processing_template_parmlist
)
2711 /* You can't declare a new template type in a template parameter
2712 list. But, you can declare a non-template type:
2714 template <class A*> struct S;
2716 is a forward-declaration of `A'. */
2720 maybe_check_template_type (type
);
2722 my_friendly_assert (IS_AGGR_TYPE (type
)
2723 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2726 if (processing_template_decl
)
2728 /* This may change after the call to
2729 push_template_decl_real, but we want the original value. */
2730 tree name
= DECL_NAME (decl
);
2732 decl
= push_template_decl_real (decl
, globalize
);
2733 /* If the current binding level is the binding level for the
2734 template parameters (see the comment in
2735 begin_template_parm_list) and the enclosing level is a class
2736 scope, and we're not looking at a friend, push the
2737 declaration of the member class into the class scope. In the
2738 friend case, push_template_decl will already have put the
2739 friend into global scope, if appropriate. */
2740 if (TREE_CODE (type
) != ENUMERAL_TYPE
2741 && !globalize
&& b
->pseudo_global
2742 && b
->level_chain
->parm_flag
== 2)
2744 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2745 /* Put this tag on the list of tags for the class, since
2746 that won't happen below because B is not the class
2747 binding level, but is instead the pseudo-global level. */
2748 b
->level_chain
->tags
=
2749 saveable_tree_cons (name
, type
, b
->level_chain
->tags
);
2750 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2751 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2759 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2760 Normally put it into the inner-most non-tag-transparent scope,
2761 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2762 The latter is needed for implicit declarations. */
2765 pushtag (name
, type
, globalize
)
2769 register struct binding_level
*b
;
2771 b
= current_binding_level
;
2772 while (b
->tag_transparent
2773 || (globalize
&& b
->parm_flag
== 2))
2776 if (toplevel_bindings_p ())
2777 b
->tags
= perm_tree_cons (name
, type
, b
->tags
);
2779 b
->tags
= saveable_tree_cons (name
, type
, b
->tags
);
2783 /* Do C++ gratuitous typedefing. */
2784 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2786 register tree d
= NULL_TREE
;
2790 context
= type
? TYPE_CONTEXT (type
) : NULL_TREE
;
2793 tree cs
= current_scope ();
2797 else if (cs
!= NULL_TREE
2798 && TREE_CODE_CLASS (TREE_CODE (cs
)) == 't')
2799 /* When declaring a friend class of a local class, we want
2800 to inject the newly named class into the scope
2801 containing the local class, not the namespace scope. */
2802 context
= hack_decl_function_context (get_type_decl (cs
));
2805 context
= current_namespace
;
2807 if ((b
->pseudo_global
&& b
->level_chain
->parm_flag
== 2)
2808 || b
->parm_flag
== 2)
2811 d
= build_decl (TYPE_DECL
, name
, type
);
2812 if (current_lang_name
== lang_name_java
)
2813 TYPE_FOR_JAVA (type
) = 1;
2814 SET_DECL_ARTIFICIAL (d
);
2816 set_identifier_type_value_with_scope (name
, type
, b
);
2818 TYPE_NAME (type
) = d
;
2819 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2821 d
= maybe_process_template_type_declaration (type
,
2824 if (b
->parm_flag
== 2)
2826 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2827 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2828 class. But if it's a member template class, we
2829 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2831 finish_member_declaration (d
);
2833 pushdecl_class_level (d
);
2836 d
= pushdecl_with_scope (d
, b
);
2838 if (ANON_AGGRNAME_P (name
))
2839 DECL_IGNORED_P (d
) = 1;
2841 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2842 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2843 if (!uses_template_parms (type
))
2844 DECL_ASSEMBLER_NAME (d
)
2845 = get_identifier (build_overload_name (type
, 1, 1));
2847 if (b
->parm_flag
== 2)
2849 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2850 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2854 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2855 /* Use the canonical TYPE_DECL for this node. */
2856 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2859 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2860 will be the tagged type we just added to the current
2861 binding level. This fake NULL-named TYPE_DECL node helps
2862 dwarfout.c to know when it needs to output a
2863 representation of a tagged type, and it also gives us a
2864 convenient place to record the "scope start" address for
2867 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2868 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2872 /* Counter used to create anonymous type names. */
2874 static int anon_cnt
= 0;
2876 /* Return an IDENTIFIER which can be used as a name for
2877 anonymous structs and unions. */
2884 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2885 return get_identifier (buf
);
2888 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2889 This keeps dbxout from getting confused. */
2894 register struct binding_level
*b
;
2896 static int last_cnt
= 0;
2898 /* Fast out if no new anon names were declared. */
2899 if (last_cnt
== anon_cnt
)
2902 b
= current_binding_level
;
2903 while (b
->tag_transparent
)
2908 /* A NULL purpose means we have already processed all tags
2909 from here to the end of the list. */
2910 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2912 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2913 TREE_PURPOSE (tags
) = NULL_TREE
;
2914 tags
= TREE_CHAIN (tags
);
2916 last_cnt
= anon_cnt
;
2919 /* Subroutine of duplicate_decls: return truthvalue of whether
2920 or not types of these decls match.
2922 For C++, we must compare the parameter list so that `int' can match
2923 `int&' in a parameter position, but `int&' is not confused with
2927 decls_match (newdecl
, olddecl
)
2928 tree newdecl
, olddecl
;
2932 if (newdecl
== olddecl
)
2935 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
2936 /* If the two DECLs are not even the same kind of thing, we're not
2937 interested in their types. */
2940 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2942 tree f1
= TREE_TYPE (newdecl
);
2943 tree f2
= TREE_TYPE (olddecl
);
2944 tree p1
= TYPE_ARG_TYPES (f1
);
2945 tree p2
= TYPE_ARG_TYPES (f2
);
2947 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
)
2948 && ! (DECL_LANGUAGE (newdecl
) == lang_c
2949 && DECL_LANGUAGE (olddecl
) == lang_c
))
2952 /* When we parse a static member function definition,
2953 we put together a FUNCTION_DECL which thinks its type
2954 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
2956 if (TREE_CODE (f1
) == METHOD_TYPE
&& DECL_STATIC_FUNCTION_P (olddecl
))
2957 revert_static_member_fn (&newdecl
, &f1
, &p1
);
2958 else if (TREE_CODE (f2
) == METHOD_TYPE
2959 && DECL_STATIC_FUNCTION_P (newdecl
))
2960 revert_static_member_fn (&olddecl
, &f2
, &p2
);
2962 /* Here we must take care of the case where new default
2963 parameters are specified. Also, warn if an old
2964 declaration becomes ambiguous because default
2965 parameters may cause the two to be ambiguous. */
2966 if (TREE_CODE (f1
) != TREE_CODE (f2
))
2968 if (TREE_CODE (f1
) == OFFSET_TYPE
)
2969 cp_compiler_error ("`%D' redeclared as member function", newdecl
);
2971 cp_compiler_error ("`%D' redeclared as non-member function", newdecl
);
2975 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
2977 if (! strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
) == lang_c
2980 types_match
= self_promoting_args_p (p1
);
2981 if (p1
== void_list_node
)
2982 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2984 else if (!strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
)==lang_c
2985 && DECL_LANGUAGE (newdecl
) == lang_c
&& p1
== NULL_TREE
)
2987 types_match
= self_promoting_args_p (p2
);
2988 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2991 types_match
= compparms (p1
, p2
);
2996 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2998 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2999 DECL_TEMPLATE_PARMS (olddecl
)))
3002 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3005 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
3006 DECL_TEMPLATE_RESULT (newdecl
));
3010 if (TREE_TYPE (newdecl
) == error_mark_node
)
3011 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
3012 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
3013 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
3014 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
3017 types_match
= comptypes (TREE_TYPE (newdecl
),
3018 TREE_TYPE (olddecl
),
3019 COMPARE_REDECLARATION
);
3025 /* If NEWDECL is `static' and an `extern' was seen previously,
3026 warn about it. (OLDDECL may be NULL_TREE; NAME contains
3027 information about previous usage as an `extern'.)
3029 Note that this does not apply to the C++ case of declaring
3030 a variable `extern const' and then later `const'.
3032 Don't complain about built-in functions, since they are beyond
3033 the user's control. */
3036 warn_extern_redeclared_static (newdecl
, olddecl
)
3037 tree newdecl
, olddecl
;
3041 static const char *explicit_extern_static_warning
3042 = "`%D' was declared `extern' and later `static'";
3043 static const char *implicit_extern_static_warning
3044 = "`%D' was declared implicitly `extern' and later `static'";
3046 if (TREE_CODE (newdecl
) == TYPE_DECL
)
3049 name
= DECL_ASSEMBLER_NAME (newdecl
);
3050 if (TREE_PUBLIC (name
) && DECL_THIS_STATIC (newdecl
))
3052 /* It's okay to redeclare an ANSI built-in function as static,
3053 or to declare a non-ANSI built-in function as anything. */
3054 if (! (TREE_CODE (newdecl
) == FUNCTION_DECL
3055 && olddecl
!= NULL_TREE
3056 && TREE_CODE (olddecl
) == FUNCTION_DECL
3057 && DECL_ARTIFICIAL (olddecl
)))
3059 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
3060 ? implicit_extern_static_warning
3061 : explicit_extern_static_warning
, newdecl
);
3062 if (olddecl
!= NULL_TREE
)
3063 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
3068 /* Handle when a new declaration NEWDECL has the same name as an old
3069 one OLDDECL in the same binding contour. Prints an error message
3072 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3073 Otherwise, return 0. */
3076 duplicate_decls (newdecl
, olddecl
)
3077 tree newdecl
, olddecl
;
3079 extern struct obstack permanent_obstack
;
3080 unsigned olddecl_uid
= DECL_UID (olddecl
);
3081 int olddecl_friend
= 0, types_match
= 0;
3082 int new_defines_function
= 0;
3084 if (newdecl
== olddecl
)
3087 types_match
= decls_match (newdecl
, olddecl
);
3089 /* If either the type of the new decl or the type of the old decl is an
3090 error_mark_node, then that implies that we have already issued an
3091 error (earlier) for some bogus type specification, and in that case,
3092 it is rather pointless to harass the user with yet more error message
3093 about the same declaration, so just pretend the types match here. */
3094 if (TREE_TYPE (newdecl
) == error_mark_node
3095 || TREE_TYPE (olddecl
) == error_mark_node
)
3098 /* Check for redeclaration and other discrepancies. */
3099 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3100 && DECL_ARTIFICIAL (olddecl
))
3102 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
3104 /* If you declare a built-in or predefined function name as static,
3105 the old definition is overridden, but optionally warn this was a
3106 bad choice of name. */
3107 if (! TREE_PUBLIC (newdecl
))
3110 cp_warning ("shadowing %s function `%#D'",
3111 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3113 /* Discard the old built-in function. */
3116 /* If the built-in is not ansi, then programs can override
3117 it even globally without an error. */
3118 else if (! DECL_BUILT_IN (olddecl
))
3119 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3123 cp_error ("declaration of `%#D'", newdecl
);
3124 cp_error ("conflicts with built-in declaration `%#D'",
3129 else if (!types_match
)
3131 if ((DECL_LANGUAGE (newdecl
) == lang_c
3132 && DECL_LANGUAGE (olddecl
) == lang_c
)
3133 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3134 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3136 /* A near match; override the builtin. */
3138 if (TREE_PUBLIC (newdecl
))
3140 cp_warning ("new declaration `%#D'", newdecl
);
3141 cp_warning ("ambiguates built-in declaration `%#D'",
3144 else if (warn_shadow
)
3145 cp_warning ("shadowing %s function `%#D'",
3146 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3150 /* Discard the old built-in function. */
3154 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
3156 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
3157 && TREE_CODE (newdecl
) != TYPE_DECL
3158 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
3159 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
3160 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
3161 && TREE_CODE (olddecl
) != TYPE_DECL
3162 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
3163 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
3166 /* We do nothing special here, because C++ does such nasty
3167 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3168 get shadowed, and know that if we need to find a TYPE_DECL
3169 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3170 slot of the identifier. */
3174 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
3175 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
3176 || (TREE_CODE (olddecl
) == FUNCTION_DECL
3177 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
3180 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
3181 if (TREE_CODE (olddecl
) == TREE_LIST
)
3182 olddecl
= TREE_VALUE (olddecl
);
3183 cp_error_at ("previous declaration of `%#D'", olddecl
);
3185 /* New decl is completely inconsistent with the old one =>
3186 tell caller to replace the old one. */
3190 else if (!types_match
)
3192 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
))
3193 /* These are certainly not duplicate declarations; they're
3194 from different scopes. */
3197 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3199 /* The name of a class template may not be declared to refer to
3200 any other template, class, function, object, namespace, value,
3201 or type in the same scope. */
3202 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
3203 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3205 cp_error ("declaration of template `%#D'", newdecl
);
3206 cp_error_at ("conflicts with previous declaration `%#D'",
3209 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
3210 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
3211 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
3212 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
3213 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3214 DECL_TEMPLATE_PARMS (olddecl
)))
3216 cp_error ("new declaration `%#D'", newdecl
);
3217 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3221 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3223 if (DECL_LANGUAGE (newdecl
) == lang_c
3224 && DECL_LANGUAGE (olddecl
) == lang_c
)
3226 cp_error ("declaration of C function `%#D' conflicts with",
3228 cp_error_at ("previous declaration `%#D' here", olddecl
);
3230 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3231 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3233 cp_error ("new declaration `%#D'", newdecl
);
3234 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3240 /* Already complained about this, so don't do so again. */
3241 else if (current_class_type
== NULL_TREE
3242 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
3244 cp_error ("conflicting types for `%#D'", newdecl
);
3245 cp_error_at ("previous declaration as `%#D'", olddecl
);
3248 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3249 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
3250 && (!DECL_TEMPLATE_INFO (newdecl
)
3251 || (DECL_TI_TEMPLATE (newdecl
)
3252 != DECL_TI_TEMPLATE (olddecl
))))
3253 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
3254 && (!DECL_TEMPLATE_INFO (olddecl
)
3255 || (DECL_TI_TEMPLATE (olddecl
)
3256 != DECL_TI_TEMPLATE (newdecl
))))))
3257 /* It's OK to have a template specialization and a non-template
3258 with the same type, or to have specializations of two
3259 different templates with the same type. Note that if one is a
3260 specialization, and the other is an instantiation of the same
3261 template, that we do not exit at this point. That situation
3262 can occur if we instantiate a template class, and then
3263 specialize one of its methods. This situation is legal, but
3264 the declarations must be merged in the usual way. */
3266 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3267 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
3268 && !DECL_USE_TEMPLATE (newdecl
))
3269 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
3270 && !DECL_USE_TEMPLATE (olddecl
))))
3271 /* One of the declarations is a template instantiation, and the
3272 other is not a template at all. That's OK. */
3274 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
3275 && DECL_NAMESPACE_ALIAS (newdecl
)
3276 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
3277 /* Redeclaration of namespace alias, ignore it. */
3281 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
3284 cp_error (errmsg
, newdecl
);
3285 if (DECL_NAME (olddecl
) != NULL_TREE
)
3286 cp_error_at ((DECL_INITIAL (olddecl
)
3287 && namespace_bindings_p ())
3288 ? "`%#D' previously defined here"
3289 : "`%#D' previously declared here", olddecl
);
3291 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3292 && DECL_INITIAL (olddecl
) != NULL_TREE
3293 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
3294 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
3296 /* Prototype decl follows defn w/o prototype. */
3297 cp_warning_at ("prototype for `%#D'", newdecl
);
3298 cp_warning_at ("follows non-prototype definition here", olddecl
);
3300 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3301 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
3303 /* extern "C" int foo ();
3304 int foo () { bar (); }
3306 if (current_lang_stack
== current_lang_base
)
3307 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3310 cp_error_at ("previous declaration of `%#D' with %L linkage",
3311 olddecl
, DECL_LANGUAGE (olddecl
));
3312 cp_error ("conflicts with new declaration with %L linkage",
3313 DECL_LANGUAGE (newdecl
));
3317 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
3319 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
3321 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
3322 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
3325 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
3326 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
3328 for (; t1
&& t1
!= void_list_node
;
3329 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
3330 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
3332 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
3337 cp_pedwarn ("default argument given for parameter %d of `%#D'",
3339 cp_pedwarn_at ("after previous specification in `%#D'",
3345 cp_error ("default argument given for parameter %d of `%#D'",
3347 cp_error_at ("after previous specification in `%#D'",
3352 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
3353 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
3355 cp_warning ("`%#D' was used before it was declared inline",
3357 cp_warning_at ("previous non-inline declaration here",
3363 /* If new decl is `static' and an `extern' was seen previously,
3365 warn_extern_redeclared_static (newdecl
, olddecl
);
3367 /* We have committed to returning 1 at this point. */
3368 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3370 /* Now that functions must hold information normally held
3371 by field decls, there is extra work to do so that
3372 declaration information does not get destroyed during
3374 if (DECL_VINDEX (olddecl
))
3375 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
3376 if (DECL_CONTEXT (olddecl
))
3377 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
3378 if (DECL_CLASS_CONTEXT (olddecl
))
3379 DECL_CLASS_CONTEXT (newdecl
) = DECL_CLASS_CONTEXT (olddecl
);
3380 if (DECL_PENDING_INLINE_INFO (newdecl
) == (struct pending_inline
*)0)
3381 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
3382 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
3383 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
3384 DECL_ABSTRACT_VIRTUAL_P (newdecl
) |= DECL_ABSTRACT_VIRTUAL_P (olddecl
);
3385 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
3386 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
3387 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
3389 /* Optionally warn about more than one declaration for the same
3390 name, but don't warn about a function declaration followed by a
3392 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
3393 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
3394 /* Don't warn about extern decl followed by definition. */
3395 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
3396 /* Don't warn about friends, let add_friend take care of it. */
3397 && ! DECL_FRIEND_P (newdecl
))
3399 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
3400 cp_warning_at ("previous declaration of `%D'", olddecl
);
3404 /* Deal with C++: must preserve virtual function table size. */
3405 if (TREE_CODE (olddecl
) == TYPE_DECL
)
3407 register tree newtype
= TREE_TYPE (newdecl
);
3408 register tree oldtype
= TREE_TYPE (olddecl
);
3410 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
3411 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
3413 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
3414 CLASSTYPE_FRIEND_CLASSES (newtype
)
3415 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
3419 /* Copy all the DECL_... slots specified in the new decl
3420 except for any that we copy here from the old type. */
3421 DECL_MACHINE_ATTRIBUTES (newdecl
)
3422 = merge_machine_decl_attributes (olddecl
, newdecl
);
3424 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3426 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl
),
3427 DECL_TEMPLATE_RESULT (olddecl
)))
3428 cp_error ("invalid redeclaration of %D", newdecl
);
3429 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
3430 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
3431 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
3432 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3439 /* Automatically handles default parameters. */
3440 tree oldtype
= TREE_TYPE (olddecl
);
3443 /* Make sure we put the new type in the same obstack as the old one. */
3445 push_obstacks (TYPE_OBSTACK (oldtype
), TYPE_OBSTACK (oldtype
));
3448 push_obstacks_nochange ();
3449 end_temporary_allocation ();
3452 /* Merge the data types specified in the two decls. */
3453 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3455 if (TREE_CODE (newdecl
) == VAR_DECL
)
3456 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3457 /* Do this after calling `common_type' so that default
3458 parameters don't confuse us. */
3459 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3460 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3461 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3463 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3464 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3465 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3466 TYPE_RAISES_EXCEPTIONS (oldtype
));
3468 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3469 && DECL_SOURCE_LINE (olddecl
) != 0
3471 && ! compexcepttypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
3473 cp_pedwarn ("declaration of `%D' throws different exceptions",
3475 cp_pedwarn_at ("previous declaration here", olddecl
);
3478 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3480 /* Lay the type out, unless already done. */
3481 if (! same_type_p (newtype
, oldtype
)
3482 && TREE_TYPE (newdecl
) != error_mark_node
3483 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3484 layout_type (TREE_TYPE (newdecl
));
3486 if ((TREE_CODE (newdecl
) == VAR_DECL
3487 || TREE_CODE (newdecl
) == PARM_DECL
3488 || TREE_CODE (newdecl
) == RESULT_DECL
3489 || TREE_CODE (newdecl
) == FIELD_DECL
3490 || TREE_CODE (newdecl
) == TYPE_DECL
)
3491 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3492 layout_decl (newdecl
, 0);
3494 /* Merge the type qualifiers. */
3495 if (TREE_READONLY (newdecl
))
3496 TREE_READONLY (olddecl
) = 1;
3497 if (TREE_THIS_VOLATILE (newdecl
))
3498 TREE_THIS_VOLATILE (olddecl
) = 1;
3500 /* Merge the initialization information. */
3501 if (DECL_INITIAL (newdecl
) == NULL_TREE
3502 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3504 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3505 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3506 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3507 if (DECL_LANG_SPECIFIC (newdecl
)
3508 && DECL_LANG_SPECIFIC (olddecl
))
3509 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3512 /* Merge the section attribute.
3513 We want to issue an error if the sections conflict but that must be
3514 done later in decl_attributes since we are called before attributes
3516 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3517 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3519 /* Keep the old rtl since we can safely use it, unless it's the
3520 call to abort() used for abstract virtuals. */
3521 if ((DECL_LANG_SPECIFIC (olddecl
)
3522 && !DECL_ABSTRACT_VIRTUAL_P (olddecl
))
3523 || DECL_RTL (olddecl
) != DECL_RTL (abort_fndecl
))
3524 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3528 /* If cannot merge, then use the new type and qualifiers,
3529 and don't preserve the old rtl. */
3532 /* Clean out any memory we had of the old declaration. */
3533 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3535 TREE_VALUE (oldstatic
) = error_mark_node
;
3537 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3538 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3539 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3540 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3543 /* Merge the storage class information. */
3544 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3545 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3546 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3547 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3548 if (! DECL_EXTERNAL (olddecl
))
3549 DECL_EXTERNAL (newdecl
) = 0;
3551 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3553 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3554 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3555 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3556 DECL_TEMPLATE_INSTANTIATED (newdecl
)
3557 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
3558 /* Don't really know how much of the language-specific
3559 values we should copy from old to new. */
3560 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3561 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3562 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3563 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3564 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3566 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3567 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3568 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
3569 DECL_BEFRIENDING_CLASSES (newdecl
)
3570 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
3571 DECL_BEFRIENDING_CLASSES (olddecl
));
3574 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3576 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3577 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3579 /* If newdecl is not a specialization, then it is not a
3580 template-related function at all. And that means that we
3581 shoud have exited above, returning 0. */
3582 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3585 if (TREE_USED (olddecl
))
3586 /* From [temp.expl.spec]:
3588 If a template, a member template or the member of a class
3589 template is explicitly specialized then that
3590 specialization shall be declared before the first use of
3591 that specialization that would cause an implicit
3592 instantiation to take place, in every translation unit in
3593 which such a use occurs. */
3594 cp_error ("explicit specialization of %D after first use",
3597 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3599 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3601 /* If either decl says `inline', this fn is inline, unless its
3602 definition was passed already. */
3603 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3604 DECL_INLINE (olddecl
) = 1;
3605 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3609 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3610 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3611 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3613 if (! types_match
|| new_defines_function
)
3615 /* These need to be copied so that the names are available.
3616 Note that if the types do match, we'll preserve inline
3617 info and other bits, but if not, we won't. */
3618 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3619 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3621 if (new_defines_function
)
3622 /* If defining a function declared with other language
3623 linkage, use the previously declared language linkage. */
3624 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3625 else if (types_match
)
3627 /* If redeclaring a builtin function, and not a definition,
3628 it stays built in. */
3629 if (DECL_BUILT_IN (olddecl
))
3631 DECL_BUILT_IN (newdecl
) = 1;
3632 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3633 /* If we're keeping the built-in definition, keep the rtl,
3634 regardless of declaration matches. */
3635 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3638 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3640 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3641 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3642 /* Previously saved insns go together with
3643 the function's previous definition. */
3644 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3645 /* Don't clear out the arguments if we're redefining a function. */
3646 if (DECL_ARGUMENTS (olddecl
))
3647 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3649 if (DECL_LANG_SPECIFIC (olddecl
))
3650 DECL_MAIN_VARIANT (newdecl
) = DECL_MAIN_VARIANT (olddecl
);
3653 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3655 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3658 /* Now preserve various other info from the definition. */
3659 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3660 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3661 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3662 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3664 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3667 struct lang_decl
*ol
= DECL_LANG_SPECIFIC (olddecl
);
3668 struct lang_decl
*nl
= DECL_LANG_SPECIFIC (newdecl
);
3670 function_size
= sizeof (struct tree_decl
);
3672 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3673 (char *) olddecl
+ sizeof (struct tree_common
),
3674 function_size
- sizeof (struct tree_common
));
3676 /* Can we safely free the storage used by newdecl? */
3678 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3679 & ~ obstack_alignment_mask (&permanent_obstack))
3681 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3683 /* If newdecl is a template instantiation, it is possible that
3684 the following sequence of events has occurred:
3686 o A friend function was declared in a class template. The
3687 class template was instantiated.
3689 o The instantiation of the friend declaration was
3690 recorded on the instantiation list, and is newdecl.
3692 o Later, however, instantiate_class_template called pushdecl
3693 on the newdecl to perform name injection. But, pushdecl in
3694 turn called duplicate_decls when it discovered that another
3695 declaration of a global function with the same name already
3698 o Here, in duplicate_decls, we decided to clobber newdecl.
3700 If we're going to do that, we'd better make sure that
3701 olddecl, and not newdecl, is on the list of
3702 instantiations so that if we try to do the instantiation
3703 again we won't get the clobbered declaration. */
3705 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3706 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3708 for (; decls
; decls
= TREE_CHAIN (decls
))
3709 if (TREE_VALUE (decls
) == newdecl
)
3710 TREE_VALUE (decls
) = olddecl
;
3713 if (((char *)newdecl
+ ROUND (function_size
) == (char *)nl
3714 && ((char *)newdecl
+ ROUND (function_size
)
3715 + ROUND (sizeof (struct lang_decl
))
3716 == obstack_next_free (&permanent_obstack
)))
3717 || ((char *)newdecl
+ ROUND (function_size
)
3718 == obstack_next_free (&permanent_obstack
)))
3720 DECL_MAIN_VARIANT (newdecl
) = olddecl
;
3721 DECL_LANG_SPECIFIC (olddecl
) = ol
;
3722 bcopy ((char *)nl
, (char *)ol
, sizeof (struct lang_decl
));
3724 obstack_free (&permanent_obstack
, newdecl
);
3726 else if (LANG_DECL_PERMANENT (ol
) && ol
!= nl
)
3728 if (DECL_MAIN_VARIANT (olddecl
) == olddecl
)
3730 /* Save these lang_decls that would otherwise be lost. */
3731 extern tree free_lang_decl_chain
;
3732 tree free_lang_decl
= (tree
) ol
;
3734 if (DECL_LANG_SPECIFIC (olddecl
) == ol
)
3737 TREE_CHAIN (free_lang_decl
) = free_lang_decl_chain
;
3738 free_lang_decl_chain
= free_lang_decl
;
3742 /* Storage leak. */;
3748 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3749 (char *) olddecl
+ sizeof (struct tree_common
),
3750 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3751 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3754 DECL_UID (olddecl
) = olddecl_uid
;
3756 DECL_FRIEND_P (olddecl
) = 1;
3758 /* NEWDECL contains the merged attribute lists.
3759 Update OLDDECL to be the same. */
3760 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3765 /* Record a decl-node X as belonging to the current lexical scope.
3766 Check for errors (such as an incompatible declaration for the same
3767 name already seen in the same scope).
3769 Returns either X or an old decl for the same name.
3770 If an old decl is returned, it may have been smashed
3771 to agree with what X says. */
3778 register tree name
= DECL_ASSEMBLER_NAME (x
);
3779 int need_new_binding
= 1;
3781 if (DECL_TEMPLATE_PARM_P (x
))
3782 /* Template parameters have no context; they are not X::T even
3783 when declared within a class or namespace. */
3787 if (current_function_decl
&& x
!= current_function_decl
3788 /* A local declaration for a function doesn't constitute
3790 && (TREE_CODE (x
) != FUNCTION_DECL
|| DECL_INITIAL (x
))
3791 /* Don't change DECL_CONTEXT of virtual methods. */
3792 && (TREE_CODE (x
) != FUNCTION_DECL
|| !DECL_VIRTUAL_P (x
))
3793 && !DECL_CONTEXT (x
))
3794 DECL_CONTEXT (x
) = current_function_decl
;
3795 if (!DECL_CONTEXT (x
))
3796 DECL_CONTEXT (x
) = FROB_CONTEXT (current_namespace
);
3799 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3800 compiler wants to use. */
3801 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
3802 || TREE_CODE (x
) == NAMESPACE_DECL
)
3803 name
= DECL_NAME (x
);
3808 /* Not needed...see below. */
3812 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3813 name
= TREE_OPERAND (name
, 0);
3815 /* Namespace-scoped variables are not found in the current level. */
3816 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
))
3817 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3819 t
= lookup_name_current_level (name
);
3820 if (t
== error_mark_node
)
3822 /* error_mark_node is 0 for a while during initialization! */
3824 cp_error_at ("`%#D' used prior to declaration", x
);
3827 else if (t
!= NULL_TREE
)
3830 /* This is turned off until I have time to do it right (bpk). */
3831 /* With the code below that uses it... */
3832 file
= DECL_SOURCE_FILE (t
);
3833 line
= DECL_SOURCE_LINE (t
);
3835 if (TREE_CODE (t
) == PARM_DECL
)
3837 if (DECL_CONTEXT (t
) == NULL_TREE
)
3838 fatal ("parse errors have confused me too much");
3840 /* Check for duplicate params. */
3841 if (duplicate_decls (x
, t
))
3844 else if (((TREE_CODE (x
) == FUNCTION_DECL
&& DECL_LANGUAGE (x
) == lang_c
)
3845 || DECL_FUNCTION_TEMPLATE_P (x
))
3846 && is_overloaded_fn (t
))
3847 /* Don't do anything just yet. */;
3848 else if (t
== wchar_decl_node
)
3850 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3851 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3853 /* Throw away the redeclaration. */
3856 else if (TREE_CODE (t
) != TREE_CODE (x
))
3858 if (duplicate_decls (x
, t
))
3861 else if (duplicate_decls (x
, t
))
3864 /* This is turned off until I have time to do it right (bpk). */
3866 /* Also warn if they did a prototype with `static' on it, but
3867 then later left the `static' off. */
3868 if (! TREE_PUBLIC (name
) && TREE_PUBLIC (x
))
3870 if (DECL_LANG_SPECIFIC (t
) && DECL_FRIEND_P (t
))
3875 cp_warning ("`static' missing from declaration of `%D'",
3877 warning_with_file_and_line (file
, line
,
3878 "previous declaration of `%s'",
3879 decl_as_string (t
, 0));
3882 /* Now fix things so it'll do what they expect. */
3883 if (current_function_decl
)
3884 TREE_PUBLIC (current_function_decl
) = 0;
3886 /* Due to interference in memory reclamation (X may be
3887 obstack-deallocated at this point), we must guard against
3888 one really special case. [jason: This should be handled
3889 by start_function] */
3890 if (current_function_decl
== x
)
3891 current_function_decl
= t
;
3893 if (TREE_CODE (t
) == TYPE_DECL
)
3894 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3895 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3896 check_default_args (t
);
3900 else if (DECL_MAIN_P (x
))
3902 /* A redeclaration of main, but not a duplicate of the
3907 This function shall not be overloaded. */
3908 cp_error_at ("invalid redeclaration of `%D'", t
);
3909 cp_error ("as `%D'", x
);
3910 /* We don't try to push this declaration since that
3916 check_template_shadow (x
);
3918 /* If this is a function conjured up by the backend, massage it
3919 so it looks friendly. */
3920 if (TREE_CODE (x
) == FUNCTION_DECL
3921 && ! DECL_LANG_SPECIFIC (x
))
3923 retrofit_lang_decl (x
);
3924 DECL_LANGUAGE (x
) = lang_c
;
3927 if (TREE_CODE (x
) == FUNCTION_DECL
&& ! DECL_FUNCTION_MEMBER_P (x
))
3929 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
3930 if (t
!= x
|| DECL_LANGUAGE (x
) == lang_c
)
3932 if (!namespace_bindings_p ())
3933 /* We do not need to create a binding for this name;
3934 push_overloaded_decl will have already done so if
3936 need_new_binding
= 0;
3938 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3939 return push_overloaded_decl (x
, PUSH_GLOBAL
);
3941 /* If declaring a type as a typedef, copy the type (unless we're
3942 at line 0), and install this TYPE_DECL as the new type's typedef
3943 name. See the extensive comment in ../c-decl.c (pushdecl). */
3944 if (TREE_CODE (x
) == TYPE_DECL
)
3946 tree type
= TREE_TYPE (x
);
3947 if (DECL_SOURCE_LINE (x
) == 0)
3949 if (TYPE_NAME (type
) == 0)
3950 TYPE_NAME (type
) = x
;
3952 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
3953 /* We don't want to copy the type when all we're
3954 doing is making a TYPE_DECL for the purposes of
3956 && (!TYPE_NAME (type
)
3957 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
3959 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
3961 DECL_ORIGINAL_TYPE (x
) = type
;
3962 type
= build_type_copy (type
);
3963 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
3964 TYPE_NAME (type
) = x
;
3965 TREE_TYPE (x
) = type
;
3970 if (type
!= error_mark_node
3972 && TYPE_IDENTIFIER (type
))
3973 set_identifier_type_value_with_scope (DECL_NAME (x
), type
,
3974 current_binding_level
);
3978 /* Multiple external decls of the same identifier ought to match.
3980 We get warnings about inline functions where they are defined.
3981 We get warnings about other functions from push_overloaded_decl.
3983 Avoid duplicate warnings where they are used. */
3984 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
3988 if (IDENTIFIER_NAMESPACE_VALUE (name
) != NULL_TREE
3989 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name
))
3990 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name
))))
3991 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
3996 /* If different sort of thing, we already gave an error. */
3997 && TREE_CODE (decl
) == TREE_CODE (x
)
3998 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
4000 cp_pedwarn ("type mismatch with previous external decl", x
);
4001 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
4005 /* This name is new in its binding level.
4006 Install the new declaration and return it. */
4007 if (namespace_bindings_p ())
4009 /* Install a global value. */
4011 /* If the first global decl has external linkage,
4012 warn if we later see static one. */
4013 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
4014 TREE_PUBLIC (name
) = 1;
4016 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
4019 if (TREE_CODE (x
) == FUNCTION_DECL
)
4021 ((IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
)
4022 || (IDENTIFIER_GLOBAL_VALUE (name
) == x
), 378);
4023 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
4026 /* Don't forget if the function was used via an implicit decl. */
4027 if (IDENTIFIER_IMPLICIT_DECL (name
)
4028 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
4031 /* Don't forget if its address was taken in that way. */
4032 if (IDENTIFIER_IMPLICIT_DECL (name
)
4033 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
4034 TREE_ADDRESSABLE (x
) = 1;
4036 /* Warn about mismatches against previous implicit decl. */
4037 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
4038 /* If this real decl matches the implicit, don't complain. */
4039 && ! (TREE_CODE (x
) == FUNCTION_DECL
4040 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
4042 ("`%D' was previously implicitly declared to return `int'", x
);
4044 /* If new decl is `static' and an `extern' was seen previously,
4046 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
4047 warn_extern_redeclared_static (x
, t
);
4051 /* Here to install a non-global value. */
4052 tree oldlocal
= IDENTIFIER_VALUE (name
);
4053 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
4055 if (need_new_binding
)
4057 push_local_binding (name
, x
, 0);
4058 /* Because push_local_binding will hook X on to the
4059 current_binding_level's name list, we don't want to
4060 do that again below. */
4061 need_new_binding
= 0;
4064 /* If this is a TYPE_DECL, push it into the type value slot. */
4065 if (TREE_CODE (x
) == TYPE_DECL
)
4066 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
),
4067 current_binding_level
);
4069 /* Clear out any TYPE_DECL shadowed by a namespace so that
4070 we won't think this is a type. The C struct hack doesn't
4071 go through namespaces. */
4072 if (TREE_CODE (x
) == NAMESPACE_DECL
)
4073 set_identifier_type_value_with_scope (name
, NULL_TREE
,
4074 current_binding_level
);
4076 /* If this is an extern function declaration, see if we
4077 have a global definition or declaration for the function. */
4078 if (oldlocal
== NULL_TREE
4079 && DECL_EXTERNAL (x
)
4080 && oldglobal
!= NULL_TREE
4081 && TREE_CODE (x
) == FUNCTION_DECL
4082 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
4084 /* We have one. Their types must agree. */
4085 if (decls_match (x
, oldglobal
))
4089 cp_warning ("extern declaration of `%#D' doesn't match", x
);
4090 cp_warning_at ("global declaration `%#D'", oldglobal
);
4093 /* If we have a local external declaration,
4094 and no file-scope declaration has yet been seen,
4095 then if we later have a file-scope decl it must not be static. */
4096 if (oldlocal
== NULL_TREE
4097 && oldglobal
== NULL_TREE
4098 && DECL_EXTERNAL (x
)
4100 TREE_PUBLIC (name
) = 1;
4102 if (DECL_FROM_INLINE (x
))
4103 /* Inline decls shadow nothing. */;
4105 /* Warn if shadowing an argument at the top level of the body. */
4106 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
4107 && TREE_CODE (oldlocal
) == PARM_DECL
4108 && TREE_CODE (x
) != PARM_DECL
)
4110 /* Go to where the parms should be and see if we
4112 struct binding_level
*b
= current_binding_level
->level_chain
;
4118 if (b
->parm_flag
== 1)
4119 cp_error ("declaration of `%#D' shadows a parameter", name
);
4121 else if (warn_shadow
&& oldlocal
!= NULL_TREE
4122 && current_binding_level
->is_for_scope
4123 && !DECL_DEAD_FOR_LOCAL (oldlocal
))
4125 warning ("variable `%s' shadows local",
4126 IDENTIFIER_POINTER (name
));
4127 cp_warning_at (" this is the shadowed declaration", oldlocal
);
4129 /* Maybe warn if shadowing something else. */
4130 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
4131 /* No shadow warnings for internally generated vars. */
4132 && ! DECL_ARTIFICIAL (x
)
4133 /* No shadow warnings for vars made for inlining. */
4134 && ! DECL_FROM_INLINE (x
))
4136 const char *warnstring
= NULL
;
4138 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
4139 warnstring
= "declaration of `%s' shadows a parameter";
4140 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
4141 && current_class_ptr
4142 && !TREE_STATIC (name
))
4143 warnstring
= "declaration of `%s' shadows a member of `this'";
4144 else if (oldlocal
!= NULL_TREE
)
4145 warnstring
= "declaration of `%s' shadows previous local";
4146 else if (oldglobal
!= NULL_TREE
)
4147 /* XXX shadow warnings in outer-more namespaces */
4148 warnstring
= "declaration of `%s' shadows global declaration";
4151 warning (warnstring
, IDENTIFIER_POINTER (name
));
4155 if (TREE_CODE (x
) == FUNCTION_DECL
)
4156 check_default_args (x
);
4158 /* Keep count of variables in this level with incomplete type. */
4159 if (TREE_CODE (x
) == VAR_DECL
4160 && TREE_TYPE (x
) != error_mark_node
4161 && ((TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
4162 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
4163 /* RTTI TD entries are created while defining the type_info. */
4164 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
4165 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
4166 current_binding_level
->incomplete
4167 = tree_cons (NULL_TREE
, x
, current_binding_level
->incomplete
);
4170 if (need_new_binding
)
4172 /* Put decls on list in reverse order.
4173 We will reverse them later if necessary. */
4174 TREE_CHAIN (x
) = current_binding_level
->names
;
4175 current_binding_level
->names
= x
;
4176 if (current_binding_level
== global_binding_level
4177 && !TREE_PERMANENT (x
))
4178 my_friendly_abort (124);
4184 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4185 caller to set DECL_CONTEXT properly. */
4188 pushdecl_with_scope (x
, level
)
4190 struct binding_level
*level
;
4192 register struct binding_level
*b
;
4193 tree function_decl
= current_function_decl
;
4195 current_function_decl
= NULL_TREE
;
4196 if (level
->parm_flag
== 2)
4198 b
= class_binding_level
;
4199 class_binding_level
= level
;
4200 pushdecl_class_level (x
);
4201 class_binding_level
= b
;
4205 b
= current_binding_level
;
4206 current_binding_level
= level
;
4208 current_binding_level
= b
;
4210 current_function_decl
= function_decl
;
4214 /* Like pushdecl, only it places X in the current namespace,
4218 pushdecl_namespace_level (x
)
4221 register struct binding_level
*b
= current_binding_level
;
4224 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
4226 /* Now, the type_shadowed stack may screw us. Munge it so it does
4228 if (TREE_CODE (x
) == TYPE_DECL
)
4230 tree name
= DECL_NAME (x
);
4232 tree
*ptr
= (tree
*)0;
4233 for (; b
!= global_binding_level
; b
= b
->level_chain
)
4235 tree shadowed
= b
->type_shadowed
;
4236 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
4237 if (TREE_PURPOSE (shadowed
) == name
)
4239 ptr
= &TREE_VALUE (shadowed
);
4240 /* Can't break out of the loop here because sometimes
4241 a binding level will have duplicate bindings for
4242 PT names. It's gross, but I haven't time to fix it. */
4245 newval
= TREE_TYPE (x
);
4246 if (ptr
== (tree
*)0)
4248 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4249 up here if this is changed to an assertion. --KR */
4250 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
4260 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4264 pushdecl_top_level (x
)
4267 tree cur_namespace
= current_namespace
;
4268 current_namespace
= global_namespace
;
4269 x
= pushdecl_namespace_level (x
);
4270 current_namespace
= cur_namespace
;
4274 /* Make the declaration of X appear in CLASS scope. */
4277 pushdecl_class_level (x
)
4280 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4281 scope looks for the pre-mangled name. */
4284 if (TREE_CODE (x
) == OVERLOAD
)
4285 x
= OVL_CURRENT (x
);
4286 name
= DECL_NAME (x
);
4290 push_class_level_binding (name
, x
);
4291 if (TREE_CODE (x
) == TYPE_DECL
)
4292 set_identifier_type_value (name
, TREE_TYPE (x
));
4294 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4298 for (f
= TYPE_FIELDS (TREE_TYPE (x
));
4301 pushdecl_class_level (f
);
4306 /* This function is used to push the mangled decls for nested types into
4307 the appropriate scope. Previously pushdecl_top_level was used, but that
4308 is incorrect for members of local classes. */
4311 pushdecl_nonclass_level (x
)
4314 struct binding_level
*b
= current_binding_level
;
4316 my_friendly_assert (b
->parm_flag
!= 2, 180);
4319 /* Get out of template binding levels */
4320 while (b
->pseudo_global
)
4324 pushdecl_with_scope (x
, b
);
4328 /* Make the declaration(s) of X appear in CLASS scope
4329 under the name NAME. */
4332 push_class_level_binding (name
, x
)
4337 /* The class_binding_level will be NULL if x is a template
4338 parameter name in a member template. */
4339 if (!class_binding_level
)
4342 /* Make sure that this new member does not have the same name
4343 as a template parameter. */
4344 if (TYPE_BEING_DEFINED (current_class_type
))
4345 check_template_shadow (x
);
4347 /* If this declaration shadows a declaration from an enclosing
4348 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4349 we leave this class. Record the shadowed declaration here. */
4350 binding
= IDENTIFIER_BINDING (name
);
4352 && ((TREE_CODE (x
) == OVERLOAD
4353 && BINDING_VALUE (binding
)
4354 && is_overloaded_fn (BINDING_VALUE (binding
)))
4355 || INHERITED_VALUE_BINDING_P (binding
)))
4360 /* If the old binding was from a base class, and was for a tag
4361 name, slide it over to make room for the new binding. The
4362 old binding is still visible if explicitly qualified with a
4364 if (INHERITED_VALUE_BINDING_P (binding
)
4365 && BINDING_VALUE (binding
)
4366 && TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
4367 && DECL_ARTIFICIAL (BINDING_VALUE (binding
))
4368 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
4370 old_decl
= BINDING_TYPE (binding
);
4371 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
4372 BINDING_VALUE (binding
) = NULL_TREE
;
4373 INHERITED_VALUE_BINDING_P (binding
) = 0;
4376 old_decl
= BINDING_VALUE (binding
);
4378 /* There was already a binding for X containing fewer
4379 functions than are named in X. Find the previous
4380 declaration of X on the class-shadowed list, and update it. */
4381 for (shadow
= class_binding_level
->class_shadowed
;
4383 shadow
= TREE_CHAIN (shadow
))
4384 if (TREE_PURPOSE (shadow
) == name
4385 && TREE_TYPE (shadow
) == old_decl
)
4387 BINDING_VALUE (binding
) = x
;
4388 INHERITED_VALUE_BINDING_P (binding
) = 0;
4389 TREE_TYPE (shadow
) = x
;
4394 /* If we didn't replace an existing binding, put the binding on the
4395 stack of bindings for the identifier, and update
4396 IDENTIFIER_CLASS_VALUE. */
4397 if (push_class_binding (name
, x
))
4399 push_cache_obstack ();
4400 class_binding_level
->class_shadowed
4401 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
4402 class_binding_level
->class_shadowed
);
4404 /* Record the value we are binding NAME to so that we can know
4405 what to pop later. */
4406 TREE_TYPE (class_binding_level
->class_shadowed
) = x
;
4410 /* Insert another USING_DECL into the current binding level,
4411 returning this declaration. If this is a redeclaration,
4412 do nothing and return NULL_TREE. */
4415 push_using_decl (scope
, name
)
4421 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
4422 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
4423 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
4424 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
4428 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
4429 DECL_INITIAL (decl
) = scope
;
4430 TREE_CHAIN (decl
) = current_binding_level
->usings
;
4431 current_binding_level
->usings
= decl
;
4435 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4436 changed (i.e. there was already a directive), or the fresh
4437 TREE_LIST otherwise. */
4440 push_using_directive (used
)
4443 tree ud
= current_binding_level
->using_directives
;
4444 tree iter
, ancestor
;
4446 /* Check if we already have this. */
4447 if (purpose_member (used
, ud
) != NULL_TREE
)
4450 /* Recursively add all namespaces used. */
4451 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4452 push_using_directive (TREE_PURPOSE (iter
));
4454 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4455 ud
= current_binding_level
->using_directives
;
4456 ud
= perm_tree_cons (used
, ancestor
, ud
);
4457 current_binding_level
->using_directives
= ud
;
4461 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4462 other definitions already in place. We get around this by making
4463 the value of the identifier point to a list of all the things that
4464 want to be referenced by that name. It is then up to the users of
4465 that name to decide what to do with that list.
4467 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4468 slot. It is dealt with the same way.
4470 FLAGS is a bitwise-or of the following values:
4471 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4473 PUSH_USING: DECL is being pushed as the result of a using
4476 The value returned may be a previous declaration if we guessed wrong
4477 about what language DECL should belong to (C or C++). Otherwise,
4478 it's always DECL (and never something that's not a _DECL). */
4481 push_overloaded_decl (decl
, flags
)
4485 tree name
= DECL_NAME (decl
);
4488 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
4491 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
4493 old
= lookup_name_current_level (name
);
4497 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4499 tree t
= TREE_TYPE (old
);
4500 if (IS_AGGR_TYPE (t
) && warn_shadow
4501 && (! DECL_IN_SYSTEM_HEADER (decl
)
4502 || ! DECL_IN_SYSTEM_HEADER (old
)))
4503 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4506 else if (is_overloaded_fn (old
))
4510 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4512 tree fn
= OVL_CURRENT (tmp
);
4514 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
4515 && !(flags
& PUSH_USING
)
4516 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
4517 TYPE_ARG_TYPES (TREE_TYPE (decl
))))
4518 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4521 if (duplicate_decls (decl
, fn
))
4527 cp_error_at ("previous non-function declaration `%#D'", old
);
4528 cp_error ("conflicts with function declaration `%#D'", decl
);
4533 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4535 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4536 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
4538 new_binding
= ovl_cons (decl
, old
);
4539 if (flags
& PUSH_USING
)
4540 OVL_USED (new_binding
) = 1;
4543 /* NAME is not ambiguous. */
4547 set_namespace_binding (name
, current_namespace
, new_binding
);
4550 /* We only create an OVERLOAD if there was a previous binding at
4551 this level, or if decl is a template. In the former case, we
4552 need to remove the old binding and replace it with the new
4553 binding. We must also run through the NAMES on the binding
4554 level where the name was bound to update the chain. */
4556 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
4560 for (d
= &BINDING_LEVEL (IDENTIFIER_BINDING (name
))->names
;
4562 d
= &TREE_CHAIN (*d
))
4564 || (TREE_CODE (*d
) == TREE_LIST
4565 && TREE_VALUE (*d
) == old
))
4567 if (TREE_CODE (*d
) == TREE_LIST
)
4568 /* Just replace the old binding with the new. */
4569 TREE_VALUE (*d
) = new_binding
;
4571 /* Build a TREE_LIST to wrap the OVERLOAD. */
4572 *d
= build_tree_list (NULL_TREE
, new_binding
);
4574 /* And update the CPLUS_BINDING node. */
4575 BINDING_VALUE (IDENTIFIER_BINDING (name
))
4580 /* We should always find a previous binding in this case. */
4581 my_friendly_abort (0);
4584 /* Install the new binding. */
4585 push_local_binding (name
, new_binding
, flags
);
4591 /* Generate an implicit declaration for identifier FUNCTIONID
4592 as a function of type int (). Print a warning if appropriate. */
4595 implicitly_declare (functionid
)
4599 int temp
= allocation_temporary_p ();
4601 push_obstacks_nochange ();
4603 /* Save the decl permanently so we can warn if definition follows.
4604 In ANSI C, warn_implicit is usually false, so the saves little space.
4605 But in C++, it's usually true, hence the extra code. */
4606 if (temp
&& (! warn_implicit
|| toplevel_bindings_p ()))
4607 end_temporary_allocation ();
4609 /* We used to reuse an old implicit decl here,
4610 but this loses with inline functions because it can clobber
4611 the saved decl chains. */
4612 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4614 DECL_EXTERNAL (decl
) = 1;
4615 TREE_PUBLIC (decl
) = 1;
4617 /* ANSI standard says implicit declarations are in the innermost block.
4618 So we record the decl in the standard fashion. */
4620 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4623 /* Only one warning per identifier. */
4624 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4626 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4629 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4636 /* Return zero if the declaration NEWDECL is valid
4637 when the declaration OLDDECL (assumed to be for the same name)
4638 has already been seen.
4639 Otherwise return an error message format string with a %s
4640 where the identifier should go. */
4643 redeclaration_error_message (newdecl
, olddecl
)
4644 tree newdecl
, olddecl
;
4646 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4648 /* Because C++ can put things into name space for free,
4649 constructs like "typedef struct foo { ... } foo"
4650 would look like an erroneous redeclaration. */
4651 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
4654 return "redefinition of `%#D'";
4656 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4658 /* If this is a pure function, its olddecl will actually be
4659 the original initialization to `0' (which we force to call
4660 abort()). Don't complain about redefinition in this case. */
4661 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_ABSTRACT_VIRTUAL_P (olddecl
))
4664 /* If both functions come from different namespaces, this is not
4665 a redeclaration - this is a conflict with a used function. */
4666 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4667 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4668 return "`%D' conflicts with used function";
4670 /* We'll complain about linkage mismatches in
4671 warn_extern_redeclared_static. */
4673 /* Defining the same name twice is no good. */
4674 if (DECL_INITIAL (olddecl
) != NULL_TREE
4675 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4677 if (DECL_NAME (olddecl
) == NULL_TREE
)
4678 return "`%#D' not declared in class";
4680 return "redefinition of `%#D'";
4684 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4686 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4687 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4688 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4689 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4690 && TYPE_SIZE (TREE_TYPE (newdecl
))
4691 && TYPE_SIZE (TREE_TYPE (olddecl
))))
4692 return "redefinition of `%#D'";
4695 else if (toplevel_bindings_p ())
4697 /* Objects declared at top level: */
4698 /* If at least one is a reference, it's ok. */
4699 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4701 /* Reject two definitions. */
4702 return "redefinition of `%#D'";
4706 /* Objects declared with block scope: */
4707 /* Reject two definitions, and reject a definition
4708 together with an external reference. */
4709 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4710 return "redeclaration of `%#D'";
4715 /* Get the LABEL_DECL corresponding to identifier ID as a label.
4716 Create one if none exists so far for the current function.
4717 This function is called for both label definitions and label references. */
4723 register tree decl
= IDENTIFIER_LABEL_VALUE (id
);
4725 if (current_function_decl
== NULL_TREE
)
4727 error ("label `%s' referenced outside of any function",
4728 IDENTIFIER_POINTER (id
));
4732 if ((decl
== NULL_TREE
4733 || DECL_SOURCE_LINE (decl
) == 0)
4734 && (named_label_uses
== NULL
4735 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4736 || named_label_uses
->label_decl
!= decl
))
4738 struct named_label_list
*new_ent
;
4740 = (struct named_label_list
*)oballoc (sizeof (struct named_label_list
));
4741 new_ent
->label_decl
= decl
;
4742 new_ent
->names_in_scope
= current_binding_level
->names
;
4743 new_ent
->binding_level
= current_binding_level
;
4744 new_ent
->lineno_o_goto
= lineno
;
4745 new_ent
->filename_o_goto
= input_filename
;
4746 new_ent
->next
= named_label_uses
;
4747 named_label_uses
= new_ent
;
4750 /* Use a label already defined or ref'd with this name. */
4751 if (decl
!= NULL_TREE
)
4753 /* But not if it is inherited and wasn't declared to be inheritable. */
4754 if (DECL_CONTEXT (decl
) != current_function_decl
4755 && ! C_DECLARED_LABEL_FLAG (decl
))
4756 return shadow_label (id
);
4760 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4762 /* Make sure every label has an rtx. */
4765 /* A label not explicitly declared must be local to where it's ref'd. */
4766 DECL_CONTEXT (decl
) = current_function_decl
;
4768 DECL_MODE (decl
) = VOIDmode
;
4770 /* Say where one reference is to the label,
4771 for the sake of the error if it is not defined. */
4772 DECL_SOURCE_LINE (decl
) = lineno
;
4773 DECL_SOURCE_FILE (decl
) = input_filename
;
4775 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4777 named_labels
= tree_cons (NULL_TREE
, decl
, named_labels
);
4778 named_label_uses
->label_decl
= decl
;
4783 /* Make a label named NAME in the current function,
4784 shadowing silently any that may be inherited from containing functions
4785 or containing scopes.
4787 Note that valid use, if the label being shadowed
4788 comes from another scope in the same function,
4789 requires calling declare_nonlocal_label right away. */
4795 register tree decl
= IDENTIFIER_LABEL_VALUE (name
);
4797 if (decl
!= NULL_TREE
)
4799 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
4800 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
4803 return lookup_label (name
);
4806 /* Define a label, specifying the location in the source file.
4807 Return the LABEL_DECL node for the label, if the definition is valid.
4808 Otherwise return 0. */
4811 define_label (filename
, line
, name
)
4818 if (minimal_parse_mode
)
4820 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4821 decl
= build_decl (LABEL_DECL
, name
, void_type_node
);
4823 DECL_SOURCE_LINE (decl
) = line
;
4824 DECL_SOURCE_FILE (decl
) = filename
;
4829 decl
= lookup_label (name
);
4831 /* After labels, make any new cleanups go into their
4832 own new (temporary) binding contour. */
4833 current_binding_level
->more_cleanups_ok
= 0;
4835 /* If label with this name is known from an outer context, shadow it. */
4836 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) != current_function_decl
)
4838 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
4839 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
4840 decl
= lookup_label (name
);
4843 if (name
== get_identifier ("wchar_t"))
4844 cp_pedwarn ("label named wchar_t");
4846 if (DECL_INITIAL (decl
) != NULL_TREE
)
4848 cp_error ("duplicate label `%D'", decl
);
4853 struct named_label_list
*uses
, *prev
;
4856 /* Mark label as having been defined. */
4857 DECL_INITIAL (decl
) = error_mark_node
;
4858 /* Say where in the source. */
4859 DECL_SOURCE_FILE (decl
) = filename
;
4860 DECL_SOURCE_LINE (decl
) = line
;
4863 uses
= named_label_uses
;
4864 while (uses
!= NULL
)
4865 if (uses
->label_decl
== decl
)
4867 struct binding_level
*b
= current_binding_level
;
4870 tree new_decls
= b
->names
;
4871 tree old_decls
= (b
== uses
->binding_level
)
4872 ? uses
->names_in_scope
: NULL_TREE
;
4873 while (new_decls
!= old_decls
)
4875 if (TREE_CODE (new_decls
) == VAR_DECL
4876 /* Don't complain about crossing initialization
4877 of internal entities. They can't be accessed,
4878 and they should be cleaned up
4879 by the time we get to the label. */
4880 && ! DECL_ARTIFICIAL (new_decls
)
4881 && !(DECL_INITIAL (new_decls
) == NULL_TREE
4882 && pod_type_p (TREE_TYPE (new_decls
))))
4884 /* This is really only important if we're crossing
4885 an initialization. The POD stuff is just
4886 pedantry; why should it matter if the class
4887 contains a field of pointer to member type? */
4888 int problem
= (DECL_INITIAL (new_decls
)
4889 || (TYPE_NEEDS_CONSTRUCTING
4890 (TREE_TYPE (new_decls
))));
4896 cp_error ("jump to label `%D'", decl
);
4897 error_with_file_and_line
4898 (uses
->filename_o_goto
,
4899 uses
->lineno_o_goto
, " from here");
4903 cp_pedwarn ("jump to label `%D'", decl
);
4904 pedwarn_with_file_and_line
4905 (uses
->filename_o_goto
,
4906 uses
->lineno_o_goto
, " from here");
4912 cp_error_at (" crosses initialization of `%#D'",
4915 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4918 new_decls
= TREE_CHAIN (new_decls
);
4920 if (b
== uses
->binding_level
)
4926 prev
->next
= uses
->next
;
4928 named_label_uses
= uses
->next
;
4937 current_function_return_value
= NULL_TREE
;
4944 struct binding_level
*level
;
4945 struct cp_switch
*next
;
4948 static struct cp_switch
*switch_stack
;
4954 = (struct cp_switch
*) oballoc (sizeof (struct cp_switch
));
4955 p
->level
= current_binding_level
;
4956 p
->next
= switch_stack
;
4963 switch_stack
= switch_stack
->next
;
4966 /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
4967 /* XXX Note decl is never actually used. (bpk) */
4970 define_case_label ()
4972 tree cleanup
= last_cleanup_this_contour ();
4973 struct binding_level
*b
= current_binding_level
;
4978 static int explained
= 0;
4979 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup
));
4980 warning ("where case label appears here");
4983 warning ("(enclose actions of previous case statements requiring");
4984 warning ("destructors in their own binding contours.)");
4989 for (; b
&& b
!= switch_stack
->level
; b
= b
->level_chain
)
4991 tree new_decls
= b
->names
;
4992 for (; new_decls
; new_decls
= TREE_CHAIN (new_decls
))
4994 if (TREE_CODE (new_decls
) == VAR_DECL
4995 /* Don't complain about crossing initialization
4996 of internal entities. They can't be accessed,
4997 and they should be cleaned up
4998 by the time we get to the label. */
4999 && ! DECL_ARTIFICIAL (new_decls
)
5000 && ((DECL_INITIAL (new_decls
) != NULL_TREE
5001 && DECL_INITIAL (new_decls
) != error_mark_node
)
5002 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
5005 error ("jump to case label");
5007 cp_error_at (" crosses initialization of `%#D'",
5013 /* After labels, make any new cleanups go into their
5014 own new (temporary) binding contour. */
5016 current_binding_level
->more_cleanups_ok
= 0;
5017 current_function_return_value
= NULL_TREE
;
5020 /* Return the list of declarations of the current level.
5021 Note that this list is in reverse order unless/until
5022 you nreverse it; and when you do nreverse it, you must
5023 store the result back using `storedecls' or you will lose. */
5028 return current_binding_level
->names
;
5031 /* Return the list of type-tags (for structs, etc) of the current level. */
5036 return current_binding_level
->tags
;
5039 /* Store the list of declarations of the current level.
5040 This is done for the parameter declarations of a function being defined,
5041 after they are modified in the light of any missing parameters. */
5047 current_binding_level
->names
= decls
;
5050 /* Similarly, store the list of tags of the current level. */
5056 current_binding_level
->tags
= tags
;
5059 /* Given NAME, an IDENTIFIER_NODE,
5060 return the structure (or union or enum) definition for that name.
5061 Searches binding levels from BINDING_LEVEL up to the global level.
5062 If THISLEVEL_ONLY is nonzero, searches only the specified context
5063 (but skips any tag-transparent contexts to find one that is
5064 meaningful for tags).
5065 FORM says which kind of type the caller wants;
5066 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5067 If the wrong kind of type is found, and it's not a template, an error is
5071 lookup_tag (form
, name
, binding_level
, thislevel_only
)
5072 enum tree_code form
;
5074 struct binding_level
*binding_level
;
5077 register struct binding_level
*level
;
5078 /* Non-zero if, we should look past a pseudo-global level, even if
5080 int allow_pseudo_global
= 1;
5082 for (level
= binding_level
; level
; level
= level
->level_chain
)
5085 if (ANON_AGGRNAME_P (name
))
5086 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5088 /* There's no need for error checking here, because
5089 anon names are unique throughout the compilation. */
5090 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
5091 return TREE_VALUE (tail
);
5093 else if (level
->namespace_p
)
5094 /* Do namespace lookup. */
5095 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
5097 tree old
= binding_for_name (name
, tail
);
5099 /* If we just skipped past a pseudo global level, even
5100 though THISLEVEL_ONLY, and we find a template class
5101 declaration, then we use the _TYPE node for the
5102 template. See the example below. */
5103 if (thislevel_only
&& !allow_pseudo_global
5104 && old
&& BINDING_VALUE (old
)
5105 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
5106 old
= TREE_TYPE (BINDING_VALUE (old
));
5108 old
= BINDING_TYPE (old
);
5110 /* If it has an original type, it is a typedef, and we
5111 should not return it. */
5112 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
5114 if (old
&& TREE_CODE (old
) != form
5115 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
5117 cp_error ("`%#D' redeclared as %C", old
, form
);
5122 if (thislevel_only
|| tail
== global_namespace
)
5126 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5128 if (TREE_PURPOSE (tail
) == name
)
5130 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
5131 /* Should tighten this up; it'll probably permit
5132 UNION_TYPE and a struct template, for example. */
5134 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
5136 /* Definition isn't the kind we were looking for. */
5137 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
5141 return TREE_VALUE (tail
);
5144 if (thislevel_only
&& ! level
->tag_transparent
)
5146 if (level
->pseudo_global
&& allow_pseudo_global
)
5148 /* We must deal with cases like this:
5150 template <class T> struct S;
5151 template <class T> struct S {};
5153 When looking up `S', for the second declaration, we
5154 would like to find the first declaration. But, we
5155 are in the pseudo-global level created for the
5156 template parameters, rather than the (surrounding)
5157 namespace level. Thus, we keep going one more level,
5158 even though THISLEVEL_ONLY is non-zero. */
5159 allow_pseudo_global
= 0;
5171 set_current_level_tags_transparency (tags_transparent
)
5172 int tags_transparent
;
5174 current_binding_level
->tag_transparent
= tags_transparent
;
5178 /* Given a type, find the tag that was defined for it and return the tag name.
5179 Otherwise return 0. However, the value can never be 0
5180 in the cases in which this is used.
5182 C++: If NAME is non-zero, this is the new name to install. This is
5183 done when replacing anonymous tags with real tag names. */
5186 lookup_tag_reverse (type
, name
)
5190 register struct binding_level
*level
;
5192 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
5195 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5197 if (TREE_VALUE (tail
) == type
)
5200 TREE_PURPOSE (tail
) = name
;
5201 return TREE_PURPOSE (tail
);
5208 /* Look up NAME in the NAMESPACE. */
5211 lookup_namespace_name (namespace, name
)
5212 tree
namespace, name
;
5214 struct tree_binding _b
;
5216 tree template_id
= NULL_TREE
;
5218 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
5220 if (TREE_CODE (name
) == NAMESPACE_DECL
)
5221 /* This happens for A::B<int> when B is a namespace. */
5223 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
5225 /* This happens for A::B where B is a template, and there are no
5226 template arguments. */
5227 cp_error ("invalid use of `%D'", name
);
5228 return error_mark_node
;
5231 namespace = ORIGINAL_NAMESPACE (namespace);
5233 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5236 name
= TREE_OPERAND (name
, 0);
5237 if (TREE_CODE (name
) == OVERLOAD
)
5238 name
= DECL_NAME (OVL_CURRENT (name
));
5239 else if (TREE_CODE_CLASS (TREE_CODE (name
)) == 'd')
5240 name
= DECL_NAME (name
);
5243 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
5245 val
= binding_init (&_b
);
5246 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
5247 return error_mark_node
;
5249 if (BINDING_VALUE (val
))
5251 val
= BINDING_VALUE (val
);
5255 if (DECL_CLASS_TEMPLATE_P (val
))
5256 val
= lookup_template_class (val
,
5257 TREE_OPERAND (template_id
, 1),
5258 /*in_decl=*/NULL_TREE
,
5259 /*context=*/NULL_TREE
,
5260 /*entering_scope=*/0);
5261 else if (DECL_FUNCTION_TEMPLATE_P (val
)
5262 || TREE_CODE (val
) == OVERLOAD
)
5263 val
= lookup_template_function (val
,
5264 TREE_OPERAND (template_id
, 1));
5267 cp_error ("`%D::%D' is not a template",
5269 return error_mark_node
;
5273 /* If we have a single function from a using decl, pull it out. */
5274 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5275 val
= OVL_FUNCTION (val
);
5279 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
5280 return error_mark_node
;
5283 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5285 static unsigned long
5293 hash
= (((unsigned long) TYPE_CONTEXT (t
))
5294 ^ ((unsigned long) DECL_NAME (TYPE_NAME (t
))));
5299 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5302 typename_compare (k1
, k2
)
5313 d1
= TYPE_NAME (t1
);
5314 d2
= TYPE_NAME (t2
);
5316 return (DECL_NAME (d1
) == DECL_NAME (d2
)
5317 && same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
))
5318 && ((TREE_TYPE (t1
) != NULL_TREE
)
5319 == (TREE_TYPE (t2
) != NULL_TREE
))
5320 && same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
5321 && TYPENAME_TYPE_FULLNAME (t1
) == TYPENAME_TYPE_FULLNAME (t2
));
5324 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5325 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5326 is non-NULL, this type is being created by the implicit typename
5327 extension, and BASE_TYPE is a type named `t' in some base class of
5328 `T' which depends on template parameters.
5330 Returns the new TYPENAME_TYPE. */
5333 build_typename_type (context
, name
, fullname
, base_type
)
5341 struct hash_entry
* e
;
5343 static struct hash_table ht
;
5345 push_obstacks (&permanent_obstack
, &permanent_obstack
);
5348 && !hash_table_init (&ht
, &hash_newfunc
, &typename_hash
,
5350 fatal ("virtual memory exhausted");
5352 /* The FULLNAME needs to exist for the life of the hash table, i.e.,
5353 for the entire compilation. */
5354 if (!TREE_PERMANENT (fullname
))
5355 fullname
= copy_to_permanent (fullname
);
5357 /* Build the TYPENAME_TYPE. */
5358 t
= make_lang_type (TYPENAME_TYPE
);
5359 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5360 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
5361 TREE_TYPE (t
) = base_type
;
5363 /* Build the corresponding TYPE_DECL. */
5364 d
= build_decl (TYPE_DECL
, name
, t
);
5365 TYPE_NAME (TREE_TYPE (d
)) = d
;
5366 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
5367 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
5368 DECL_ARTIFICIAL (d
) = 1;
5370 /* See if we already have this type. */
5371 e
= hash_lookup (&ht
, t
, /*create=*/false, /*copy=*/0);
5374 /* This will free not only TREE_TYPE, but the lang-specific data
5375 and the TYPE_DECL as well. */
5376 obstack_free (&permanent_obstack
, t
);
5380 /* Insert the type into the table. */
5381 hash_lookup (&ht
, t
, /*create=*/true, /*copy=*/0);
5389 make_typename_type (context
, name
)
5394 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
5396 if (!(TYPE_LANG_SPECIFIC (name
)
5397 && (CLASSTYPE_IS_TEMPLATE (name
)
5398 || CLASSTYPE_USE_TEMPLATE (name
))))
5399 name
= TYPE_IDENTIFIER (name
);
5401 /* Create a TEMPLATE_ID_EXPR for the type. */
5402 name
= build_nt (TEMPLATE_ID_EXPR
,
5403 CLASSTYPE_TI_TEMPLATE (name
),
5404 CLASSTYPE_TI_ARGS (name
));
5406 else if (TREE_CODE (name
) == TYPE_DECL
)
5407 name
= DECL_NAME (name
);
5411 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5413 name
= TREE_OPERAND (name
, 0);
5414 if (TREE_CODE (name
) == TEMPLATE_DECL
)
5415 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
5417 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
5418 my_friendly_abort (2000);
5420 if (TREE_CODE (context
) == NAMESPACE_DECL
)
5422 /* We can get here from typename_sub0 in the explicit_template_type
5423 expansion. Just fail. */
5424 cp_error ("no class template named `%#T' in `%#T'",
5426 return error_mark_node
;
5429 if (! uses_template_parms (context
)
5430 || currently_open_class (context
))
5432 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
5434 tree tmpl
= NULL_TREE
;
5435 if (IS_AGGR_TYPE (context
))
5436 tmpl
= lookup_field (context
, name
, 0, 0);
5437 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
5439 cp_error ("no class template named `%#T' in `%#T'",
5441 return error_mark_node
;
5444 return lookup_template_class (tmpl
,
5445 TREE_OPERAND (fullname
, 1),
5447 /*entering_scope=*/0);
5453 if (!IS_AGGR_TYPE (context
))
5455 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5456 return error_mark_node
;
5459 t
= lookup_field (context
, name
, 0, 1);
5461 return TREE_TYPE (t
);
5465 /* If the CONTEXT is not a template type, then either the field is
5466 there now or its never going to be. */
5467 if (!uses_template_parms (context
))
5469 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5470 return error_mark_node
;
5474 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
5477 /* Select the right _DECL from multiple choices. */
5480 select_decl (binding
, flags
)
5485 val
= BINDING_VALUE (binding
);
5486 if (LOOKUP_NAMESPACES_ONLY (flags
))
5488 /* We are not interested in types. */
5489 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
5494 /* If we could have a type and
5495 we have nothing or we need a type and have none. */
5496 if (BINDING_TYPE (binding
)
5497 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
5498 && TREE_CODE (val
) != TYPE_DECL
)))
5499 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
5500 /* Don't return non-types if we really prefer types. */
5501 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
5502 && (TREE_CODE (val
) != TEMPLATE_DECL
5503 || !DECL_CLASS_TEMPLATE_P (val
)))
5509 /* Unscoped lookup of a global, iterate over namespaces, considering
5510 using namespace statements. */
5513 unqualified_namespace_lookup (name
, flags
)
5517 struct tree_binding _binding
;
5518 tree b
= binding_init (&_binding
);
5519 tree initial
= current_decl_namespace();
5520 tree scope
= initial
;
5522 struct binding_level
*level
;
5523 tree val
= NULL_TREE
;
5527 val
= binding_for_name (name
, scope
);
5529 /* Initialize binding for this context. */
5530 BINDING_VALUE (b
) = BINDING_VALUE (val
);
5531 BINDING_TYPE (b
) = BINDING_TYPE (val
);
5533 /* Add all _DECLs seen through local using-directives. */
5534 for (level
= current_binding_level
;
5535 !level
->namespace_p
;
5536 level
= level
->level_chain
)
5537 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
5539 /* Give up because of error. */
5540 return error_mark_node
;
5542 /* Add all _DECLs seen through global using-directives. */
5543 /* XXX local and global using lists should work equally. */
5547 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
5549 /* Give up because of error. */
5550 return error_mark_node
;
5551 if (siter
== scope
) break;
5552 siter
= CP_DECL_CONTEXT (siter
);
5555 val
= select_decl (b
, flags
);
5556 if (scope
== global_namespace
)
5558 scope
= CP_DECL_CONTEXT (scope
);
5563 /* Combine prefer_type and namespaces_only into flags. */
5566 lookup_flags (prefer_type
, namespaces_only
)
5567 int prefer_type
, namespaces_only
;
5569 if (namespaces_only
)
5570 return LOOKUP_PREFER_NAMESPACES
;
5571 if (prefer_type
> 1)
5572 return LOOKUP_PREFER_TYPES
;
5573 if (prefer_type
> 0)
5574 return LOOKUP_PREFER_BOTH
;
5578 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5579 ignore it or not. Subroutine of lookup_name_real. */
5582 qualify_lookup (val
, flags
)
5586 if (val
== NULL_TREE
)
5588 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5590 if ((flags
& LOOKUP_PREFER_TYPES
)
5591 && (TREE_CODE (val
) == TYPE_DECL
5592 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5593 && DECL_CLASS_TEMPLATE_P (val
))))
5595 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5600 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5604 warn_about_implicit_typename_lookup (typename
, binding
)
5608 tree subtype
= TREE_TYPE (TREE_TYPE (typename
));
5609 tree name
= DECL_NAME (typename
);
5611 if (! (TREE_CODE (binding
) == TEMPLATE_DECL
5612 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5613 && CLASSTYPE_TI_TEMPLATE (subtype
) == binding
)
5614 && ! (TREE_CODE (binding
) == TYPE_DECL
5615 && same_type_p (TREE_TYPE (binding
), subtype
)))
5617 cp_warning ("lookup of `%D' finds `%#D'",
5619 cp_warning (" instead of `%D' from dependent base class",
5621 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5622 constructor_name (current_class_type
), name
);
5626 /* Look up NAME in the current binding level and its superiors in the
5627 namespace of variables, functions and typedefs. Return a ..._DECL
5628 node of some kind representing its definition if there is only one
5629 such declaration, or return a TREE_LIST with all the overloaded
5630 definitions if there are many, or return 0 if it is undefined.
5632 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5633 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5634 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5635 Otherwise we prefer non-TYPE_DECLs.
5637 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5638 using IDENTIFIER_CLASS_VALUE. */
5641 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5643 int prefer_type
, nonclass
, namespaces_only
;
5646 tree val
= NULL_TREE
;
5648 tree from_obj
= NULL_TREE
;
5650 int val_is_implicit_typename
= 0;
5652 /* Hack: copy flag set by parser, if set. */
5653 if (only_namespace_names
)
5654 namespaces_only
= 1;
5656 if (prefer_type
== -2)
5658 extern int looking_for_typename
;
5659 tree type
= NULL_TREE
;
5662 prefer_type
= looking_for_typename
;
5664 flags
= lookup_flags (prefer_type
, namespaces_only
);
5665 /* If the next thing is '<', class templates are types. */
5666 if (looking_for_template
)
5667 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5669 /* std:: becomes :: for now. */
5670 if (got_scope
== std_node
)
5671 got_scope
= void_type_node
;
5675 else if (got_object
!= error_mark_node
)
5680 if (type
== error_mark_node
)
5681 return error_mark_node
;
5682 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5683 type
= TREE_TYPE (type
);
5686 type
= complete_type (type
);
5688 if (TREE_CODE (type
) == VOID_TYPE
)
5689 type
= global_namespace
;
5690 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5692 struct tree_binding b
;
5693 val
= binding_init (&b
);
5694 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5696 val
= select_decl (val
, flags
);
5698 else if (! IS_AGGR_TYPE (type
)
5699 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5700 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
5701 || TREE_CODE (type
) == TYPENAME_TYPE
)
5702 /* Someone else will give an error about this if needed. */
5704 else if (type
== current_class_type
)
5705 val
= IDENTIFIER_CLASS_VALUE (name
);
5707 val
= lookup_member (type
, name
, 0, prefer_type
);
5714 else if (got_object
&& val
)
5719 flags
= lookup_flags (prefer_type
, namespaces_only
);
5720 /* If we're not parsing, we need to complain. */
5721 flags
|= LOOKUP_COMPLAIN
;
5724 /* First, look in non-namespace scopes. */
5726 if (current_class_type
== NULL_TREE
)
5729 for (t
= IDENTIFIER_BINDING (name
); t
; t
= TREE_CHAIN (t
))
5733 if (!LOCAL_BINDING_P (t
) && nonclass
)
5734 /* We're not looking for class-scoped bindings, so keep going. */
5737 /* If this is the kind of thing we're looking for, we're done. */
5738 if (qualify_lookup (BINDING_VALUE (t
), flags
))
5739 binding
= BINDING_VALUE (t
);
5740 else if ((flags
& LOOKUP_PREFER_TYPES
)
5741 && qualify_lookup (BINDING_TYPE (t
), flags
))
5742 binding
= BINDING_TYPE (t
);
5744 binding
= NULL_TREE
;
5747 && (!val
|| !IMPLICIT_TYPENAME_TYPE_DECL_P (binding
)))
5749 if (val_is_implicit_typename
&& !yylex
)
5750 warn_about_implicit_typename_lookup (val
, binding
);
5752 val_is_implicit_typename
5753 = IMPLICIT_TYPENAME_TYPE_DECL_P (val
);
5754 if (!val_is_implicit_typename
)
5759 /* Now lookup in namespace scopes. */
5760 if (!val
|| val_is_implicit_typename
)
5762 t
= unqualified_namespace_lookup (name
, flags
);
5765 if (val_is_implicit_typename
&& !yylex
)
5766 warn_about_implicit_typename_lookup (val
, t
);
5774 /* This should only warn about types used in qualified-ids. */
5775 if (from_obj
&& from_obj
!= val
)
5777 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
5778 && TREE_CODE (val
) == TYPE_DECL
5779 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
5781 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5782 name
, got_object
, TREE_TYPE (from_obj
));
5783 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5787 /* We don't change val to from_obj if got_object depends on
5788 template parms because that breaks implicit typename for
5789 destructor calls. */
5790 if (! uses_template_parms (got_object
))
5794 /* If we have a single function from a using decl, pull it out. */
5795 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5796 val
= OVL_FUNCTION (val
);
5805 lookup_name_nonclass (name
)
5808 return lookup_name_real (name
, 0, 1, 0);
5812 lookup_function_nonclass (name
, args
)
5816 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
5820 lookup_name_namespace_only (name
)
5823 /* type-or-namespace, nonclass, namespace_only */
5824 return lookup_name_real (name
, 1, 1, 1);
5828 lookup_name (name
, prefer_type
)
5832 return lookup_name_real (name
, prefer_type
, 0, 0);
5835 /* Similar to `lookup_name' but look only in the innermost non-class
5839 lookup_name_current_level (name
)
5842 struct binding_level
*b
;
5845 b
= current_binding_level
;
5846 while (b
->parm_flag
== 2)
5851 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5853 /* extern "C" function() */
5854 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5857 else if (IDENTIFIER_BINDING (name
)
5858 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
5862 if (BINDING_LEVEL (IDENTIFIER_BINDING (name
)) == b
)
5863 return IDENTIFIER_VALUE (name
);
5875 /* Like lookup_name_current_level, but for types. */
5878 lookup_type_current_level (name
)
5881 register tree t
= NULL_TREE
;
5883 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
5885 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5886 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5888 struct binding_level
*b
= current_binding_level
;
5891 if (purpose_member (name
, b
->type_shadowed
))
5892 return REAL_IDENTIFIER_TYPE_VALUE (name
);
5904 begin_only_namespace_names ()
5906 only_namespace_names
= 1;
5910 end_only_namespace_names ()
5912 only_namespace_names
= 0;
5915 /* Arrange for the user to get a source line number, even when the
5916 compiler is going down in flames, so that she at least has a
5917 chance of working around problems in the compiler. We used to
5918 call error(), but that let the segmentation fault continue
5919 through; now, it's much more passive by asking them to send the
5920 maintainers mail about the problem. */
5924 int sig ATTRIBUTE_UNUSED
;
5926 signal (SIGSEGV
, SIG_DFL
);
5928 signal (SIGIOT
, SIG_DFL
);
5931 signal (SIGILL
, SIG_DFL
);
5934 signal (SIGABRT
, SIG_DFL
);
5937 signal (SIGBUS
, SIG_DFL
);
5939 my_friendly_abort (0);
5943 /* Unused -- brendan 970107 */
5944 /* Array for holding types considered "built-in". These types
5945 are output in the module in which `main' is defined. */
5946 static tree
*builtin_type_tdescs_arr
;
5947 static int builtin_type_tdescs_len
, builtin_type_tdescs_max
;
5950 /* Push the declarations of builtin types into the namespace.
5951 RID_INDEX, if < RID_MAX is the index of the builtin type
5952 in the array RID_POINTERS. NAME is the name used when looking
5953 up the builtin type. TYPE is the _TYPE node for the builtin type. */
5956 record_builtin_type (rid_index
, name
, type
)
5961 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
5962 tree tdecl
= NULL_TREE
;
5964 if ((int) rid_index
< (int) RID_MAX
)
5965 rname
= ridpointers
[(int) rid_index
];
5967 tname
= get_identifier (name
);
5969 TYPE_BUILT_IN (type
) = 1;
5973 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
5974 set_identifier_type_value (tname
, NULL_TREE
);
5975 if ((int) rid_index
< (int) RID_MAX
)
5976 /* Built-in types live in the global namespace. */
5977 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
5979 if (rname
!= NULL_TREE
)
5981 if (tname
!= NULL_TREE
)
5983 set_identifier_type_value (rname
, NULL_TREE
);
5984 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
5988 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
5989 set_identifier_type_value (rname
, NULL_TREE
);
5994 /* Record one of the standard Java types.
5995 * Declare it as having the given NAME.
5996 * If SIZE > 0, it is the size of one of the integral types;
5997 * otherwise it is the negative of the size of one of the other types. */
6000 record_builtin_java_type (name
, size
)
6006 type
= make_signed_type (size
);
6007 else if (size
> -32)
6008 { /* "__java_char" or ""__java_boolean". */
6009 type
= make_unsigned_type (-size
);
6010 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6013 { /* "__java_float" or ""__java_double". */
6014 type
= make_node (REAL_TYPE
);
6015 TYPE_PRECISION (type
) = - size
;
6018 record_builtin_type (RID_MAX
, name
, type
);
6019 decl
= TYPE_NAME (type
);
6021 /* Suppress generate debug symbol entries for these types,
6022 since for normal C++ they are just clutter.
6023 However, push_lang_context undoes this if extern "Java" is seen. */
6024 DECL_IGNORED_P (decl
) = 1;
6026 TYPE_FOR_JAVA (type
) = 1;
6030 /* Push a type into the namespace so that the back-ends ignore it. */
6033 record_unknown_type (type
, name
)
6037 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
6038 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
6039 DECL_IGNORED_P (decl
) = 1;
6040 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6041 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
6042 TYPE_ALIGN (type
) = 1;
6043 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
6046 /* Push overloaded decl, in global scope, with one argument so it
6047 can be used as a callback from define_function. */
6050 push_overloaded_decl_1 (x
)
6053 push_overloaded_decl (x
, PUSH_GLOBAL
);
6060 auto_function (name
, type
, code
)
6062 enum built_in_function code
;
6064 return define_function
6065 (IDENTIFIER_POINTER (name
), type
, code
, push_overloaded_decl_1
,
6066 IDENTIFIER_POINTER (build_decl_overload (name
, TYPE_ARG_TYPES (type
),
6070 /* Create the predefined scalar types of C,
6071 and some nodes representing standard constants (0, 1, (void *)0).
6072 Initialize the global binding level.
6073 Make definitions for built-in primitive functions. */
6076 init_decl_processing ()
6079 int wchar_type_size
;
6080 tree array_domain_type
;
6081 tree vb_off_identifier
= NULL_TREE
;
6083 /* Have to make these distinct before we try using them. */
6084 lang_name_cplusplus
= get_identifier ("C++");
6085 lang_name_c
= get_identifier ("C");
6086 lang_name_java
= get_identifier ("Java");
6088 /* Enter the global namespace. */
6089 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
6090 my_friendly_assert (current_lang_name
== NULL_TREE
, 375);
6091 current_lang_name
= lang_name_cplusplus
;
6092 push_namespace (get_identifier ("::"));
6093 global_namespace
= current_namespace
;
6094 current_lang_name
= NULL_TREE
;
6096 if (flag_strict_prototype
== 2)
6097 flag_strict_prototype
= pedantic
;
6098 if (! flag_permissive
&& ! pedantic
)
6099 flag_pedantic_errors
= 1;
6101 strict_prototypes_lang_c
= flag_strict_prototype
;
6104 current_lang_name
= lang_name_c
;
6106 current_function_decl
= NULL_TREE
;
6107 named_labels
= NULL_TREE
;
6108 named_label_uses
= NULL
;
6109 current_binding_level
= NULL_BINDING_LEVEL
;
6110 free_binding_level
= NULL_BINDING_LEVEL
;
6112 /* Because most segmentation signals can be traced back into user
6113 code, catch them and at least give the user a chance of working
6114 around compiler bugs. */
6115 signal (SIGSEGV
, signal_catch
);
6117 /* We will also catch aborts in the back-end through signal_catch and
6118 give the user a chance to see where the error might be, and to defeat
6119 aborts in the back-end when there have been errors previously in their
6122 signal (SIGIOT
, signal_catch
);
6125 signal (SIGILL
, signal_catch
);
6128 signal (SIGABRT
, signal_catch
);
6131 signal (SIGBUS
, signal_catch
);
6134 gcc_obstack_init (&decl_obstack
);
6136 /* Must lay these out before anything else gets laid out. */
6137 error_mark_node
= make_node (ERROR_MARK
);
6138 TREE_PERMANENT (error_mark_node
) = 1;
6139 TREE_TYPE (error_mark_node
) = error_mark_node
;
6140 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
6141 TREE_TYPE (error_mark_list
) = error_mark_node
;
6143 /* Make the binding_level structure for global names. */
6145 global_binding_level
= current_binding_level
;
6146 /* The global level is the namespace level of ::. */
6147 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
6148 declare_namespace_level ();
6150 this_identifier
= get_identifier (THIS_NAME
);
6151 in_charge_identifier
= get_identifier (IN_CHARGE_NAME
);
6152 ctor_identifier
= get_identifier (CTOR_NAME
);
6153 dtor_identifier
= get_identifier (DTOR_NAME
);
6154 pfn_identifier
= get_identifier (VTABLE_PFN_NAME
);
6155 index_identifier
= get_identifier (VTABLE_INDEX_NAME
);
6156 delta_identifier
= get_identifier (VTABLE_DELTA_NAME
);
6157 delta2_identifier
= get_identifier (VTABLE_DELTA2_NAME
);
6158 pfn_or_delta2_identifier
= get_identifier ("__pfn_or_delta2");
6159 if (flag_handle_signatures
)
6161 tag_identifier
= get_identifier (SIGTABLE_TAG_NAME
);
6162 vb_off_identifier
= get_identifier (SIGTABLE_VB_OFF_NAME
);
6163 vt_off_identifier
= get_identifier (SIGTABLE_VT_OFF_NAME
);
6166 /* Define `int' and `char' first so that dbx will output them first. */
6168 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
6169 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
6171 /* Define `char', which is like either `signed char' or `unsigned char'
6172 but not the same as either. */
6176 ? make_signed_type (CHAR_TYPE_SIZE
)
6177 : make_unsigned_type (CHAR_TYPE_SIZE
));
6178 record_builtin_type (RID_CHAR
, "char", char_type_node
);
6180 /* `signed' is the same as `int' */
6181 record_builtin_type (RID_SIGNED
, NULL_PTR
, integer_type_node
);
6183 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
6184 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
6186 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
6187 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
6189 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
6190 record_builtin_type (RID_MAX
, "long unsigned int", long_unsigned_type_node
);
6191 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
6193 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
6194 record_builtin_type (RID_MAX
, "long long int", long_long_integer_type_node
);
6196 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
6197 record_builtin_type (RID_MAX
, "long long unsigned int",
6198 long_long_unsigned_type_node
);
6199 record_builtin_type (RID_MAX
, "long long unsigned",
6200 long_long_unsigned_type_node
);
6202 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
6203 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
6204 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
6205 record_builtin_type (RID_MAX
, "short unsigned int", short_unsigned_type_node
);
6206 record_builtin_type (RID_MAX
, "unsigned short", short_unsigned_type_node
);
6208 /* `unsigned long' is the standard type for sizeof.
6209 Note that stddef.h uses `unsigned long',
6210 and this must agree, even if long and int are the same size. */
6212 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
6215 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
6217 /* Define both `signed char' and `unsigned char'. */
6218 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
6219 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
6220 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
6221 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
6223 /* Create the widest literal types. */
6224 widest_integer_literal_type_node
= make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
6225 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6226 widest_integer_literal_type_node
));
6228 widest_unsigned_literal_type_node
= make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
6229 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6230 widest_unsigned_literal_type_node
));
6232 /* These are types that type_for_size and type_for_mode use. */
6233 intQI_type_node
= make_signed_type (GET_MODE_BITSIZE (QImode
));
6234 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
6235 intHI_type_node
= make_signed_type (GET_MODE_BITSIZE (HImode
));
6236 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
6237 intSI_type_node
= make_signed_type (GET_MODE_BITSIZE (SImode
));
6238 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
6239 intDI_type_node
= make_signed_type (GET_MODE_BITSIZE (DImode
));
6240 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
6241 #if HOST_BITS_PER_WIDE_INT >= 64
6242 intTI_type_node
= make_signed_type (GET_MODE_BITSIZE (TImode
));
6243 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
6245 unsigned_intQI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (QImode
));
6246 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
6247 unsigned_intHI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (HImode
));
6248 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
6249 unsigned_intSI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (SImode
));
6250 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
6251 unsigned_intDI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (DImode
));
6252 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
6253 #if HOST_BITS_PER_WIDE_INT >= 64
6254 unsigned_intTI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (TImode
));
6255 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
6258 float_type_node
= make_node (REAL_TYPE
);
6259 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
6260 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
6261 layout_type (float_type_node
);
6263 double_type_node
= make_node (REAL_TYPE
);
6264 if (flag_short_double
)
6265 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
6267 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
6268 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
6269 layout_type (double_type_node
);
6271 long_double_type_node
= make_node (REAL_TYPE
);
6272 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
6273 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
6274 layout_type (long_double_type_node
);
6276 complex_integer_type_node
= make_node (COMPLEX_TYPE
);
6277 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
6278 complex_integer_type_node
));
6279 TREE_TYPE (complex_integer_type_node
) = integer_type_node
;
6280 layout_type (complex_integer_type_node
);
6282 complex_float_type_node
= make_node (COMPLEX_TYPE
);
6283 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
6284 complex_float_type_node
));
6285 TREE_TYPE (complex_float_type_node
) = float_type_node
;
6286 layout_type (complex_float_type_node
);
6288 complex_double_type_node
= make_node (COMPLEX_TYPE
);
6289 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
6290 complex_double_type_node
));
6291 TREE_TYPE (complex_double_type_node
) = double_type_node
;
6292 layout_type (complex_double_type_node
);
6294 complex_long_double_type_node
= make_node (COMPLEX_TYPE
);
6295 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
6296 complex_long_double_type_node
));
6297 TREE_TYPE (complex_long_double_type_node
) = long_double_type_node
;
6298 layout_type (complex_long_double_type_node
);
6300 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
6301 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
6302 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
6303 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
6304 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
6305 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
6306 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
6307 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
6309 integer_zero_node
= build_int_2 (0, 0);
6310 TREE_TYPE (integer_zero_node
) = integer_type_node
;
6311 integer_one_node
= build_int_2 (1, 0);
6312 TREE_TYPE (integer_one_node
) = integer_type_node
;
6313 integer_two_node
= build_int_2 (2, 0);
6314 TREE_TYPE (integer_two_node
) = integer_type_node
;
6315 integer_three_node
= build_int_2 (3, 0);
6316 TREE_TYPE (integer_three_node
) = integer_type_node
;
6318 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
6319 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
6320 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
6321 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
6322 TYPE_PRECISION (boolean_type_node
) = 1;
6323 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
6324 boolean_false_node
= build_int_2 (0, 0);
6325 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
6326 boolean_true_node
= build_int_2 (1, 0);
6327 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
6329 /* These are needed by stor-layout.c. */
6330 size_zero_node
= size_int (0);
6331 size_one_node
= size_int (1);
6333 signed_size_zero_node
= build_int_2 (0, 0);
6334 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
6336 void_type_node
= make_node (VOID_TYPE
);
6337 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
6338 layout_type (void_type_node
); /* Uses integer_zero_node. */
6339 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
6340 TREE_PARMLIST (void_list_node
) = 1;
6342 null_pointer_node
= build_int_2 (0, 0);
6343 TREE_TYPE (null_pointer_node
) = build_pointer_type (void_type_node
);
6344 layout_type (TREE_TYPE (null_pointer_node
));
6346 /* Used for expressions that do nothing, but are not errors. */
6347 void_zero_node
= build_int_2 (0, 0);
6348 TREE_TYPE (void_zero_node
) = void_type_node
;
6350 string_type_node
= build_pointer_type (char_type_node
);
6351 const_string_type_node
6352 = build_pointer_type (build_qualified_type (char_type_node
,
6355 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
6358 /* Make a type to be the domain of a few array types
6359 whose domains don't really matter.
6360 200 is small enough that it always fits in size_t
6361 and large enough that it can hold most function names for the
6362 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
6363 array_domain_type
= build_index_type (build_int_2 (200, 0));
6365 /* Make a type for arrays of characters.
6366 With luck nothing will ever really depend on the length of this
6368 char_array_type_node
6369 = build_array_type (char_type_node
, array_domain_type
);
6370 /* Likewise for arrays of ints. */
6372 = build_array_type (integer_type_node
, array_domain_type
);
6374 /* This is just some anonymous class type. Nobody should ever
6375 need to look inside this envelope. */
6376 class_star_type_node
= build_pointer_type (make_lang_type (RECORD_TYPE
));
6378 if (flag_huge_objects
)
6379 delta_type_node
= long_integer_type_node
;
6381 delta_type_node
= short_integer_type_node
;
6383 default_function_type
6384 = build_function_type (integer_type_node
, NULL_TREE
);
6386 ptr_type_node
= build_pointer_type (void_type_node
);
6388 = build_pointer_type (build_qualified_type (void_type_node
,
6390 c_common_nodes_and_builtins (1, flag_no_builtin
, flag_no_nonansi_builtin
);
6393 = build_exception_variant (void_ftype_ptr
,
6394 tree_cons (NULL_TREE
, NULL_TREE
, NULL_TREE
));
6396 /* C++ extensions */
6398 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6399 record_unknown_type (unknown_type_node
, "unknown type");
6401 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6402 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6404 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6406 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6408 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6409 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6411 /* This is for handling opaque types in signatures. */
6412 opaque_type_node
= copy_node (ptr_type_node
);
6413 TYPE_MAIN_VARIANT (opaque_type_node
) = opaque_type_node
;
6414 record_builtin_type (RID_MAX
, 0, opaque_type_node
);
6416 /* This is special for C++ so functions can be overloaded. */
6418 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE
)));
6419 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6420 signed_wchar_type_node
= make_signed_type (wchar_type_size
);
6421 unsigned_wchar_type_node
= make_unsigned_type (wchar_type_size
);
6423 = TREE_UNSIGNED (wchar_type_node
)
6424 ? unsigned_wchar_type_node
6425 : signed_wchar_type_node
;
6426 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6428 /* Artificial declaration of wchar_t -- can be bashed */
6429 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6431 pushdecl (wchar_decl_node
);
6433 /* This is for wide string constants. */
6434 wchar_array_type_node
6435 = build_array_type (wchar_type_node
, array_domain_type
);
6437 if (flag_vtable_thunks
)
6439 /* Make sure we get a unique function type, so we can give
6440 its pointer type a name. (This wins for gdb.) */
6441 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6442 TREE_TYPE (vfunc_type
) = integer_type_node
;
6443 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6444 layout_type (vfunc_type
);
6446 vtable_entry_type
= build_pointer_type (vfunc_type
);
6450 vtable_entry_type
= make_lang_type (RECORD_TYPE
);
6451 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
6453 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
6455 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
6457 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6460 /* Make this part of an invisible union. */
6461 fields
[3] = copy_node (fields
[2]);
6462 TREE_TYPE (fields
[3]) = delta_type_node
;
6463 DECL_NAME (fields
[3]) = delta2_identifier
;
6464 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6465 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6466 TREE_UNSIGNED (fields
[3]) = 0;
6467 TREE_CHAIN (fields
[2]) = fields
[3];
6468 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6471 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6474 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
6475 layout_type (vtbl_type_node
);
6476 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6477 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6478 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6479 layout_type (vtbl_ptr_type_node
);
6480 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6482 /* Simplify life by making a "sigtable_entry_type". Give its
6483 fields names so that the debugger can use them. */
6485 if (flag_handle_signatures
)
6487 sigtable_entry_type
= make_lang_type (RECORD_TYPE
);
6488 fields
[0] = build_lang_field_decl (FIELD_DECL
, tag_identifier
,
6490 fields
[1] = build_lang_field_decl (FIELD_DECL
, vb_off_identifier
,
6492 fields
[2] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
6494 fields
[3] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
6496 fields
[4] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
6499 /* Set the alignment to the max of the alignment of ptr_type_node and
6500 delta_type_node. Double alignment wastes a word on the Sparc. */
6501 finish_builtin_type (sigtable_entry_type
, SIGTABLE_PTR_TYPE
, fields
, 4,
6502 (TYPE_ALIGN (ptr_type_node
) > TYPE_ALIGN (delta_type_node
))
6506 /* Make this part of an invisible union. */
6507 fields
[5] = copy_node (fields
[4]);
6508 TREE_TYPE (fields
[5]) = delta_type_node
;
6509 DECL_NAME (fields
[5]) = vt_off_identifier
;
6510 DECL_MODE (fields
[5]) = TYPE_MODE (delta_type_node
);
6511 DECL_SIZE (fields
[5]) = TYPE_SIZE (delta_type_node
);
6512 TREE_UNSIGNED (fields
[5]) = 0;
6513 TREE_CHAIN (fields
[4]) = fields
[5];
6515 sigtable_entry_type
= build_qualified_type (sigtable_entry_type
,
6517 record_builtin_type (RID_MAX
, SIGTABLE_PTR_TYPE
, sigtable_entry_type
);
6520 std_node
= build_decl (NAMESPACE_DECL
,
6521 get_identifier (flag_honor_std
? "fake std":"std"),
6523 pushdecl (std_node
);
6525 global_type_node
= make_node (LANG_TYPE
);
6526 record_unknown_type (global_type_node
, "global type");
6529 current_lang_name
= lang_name_cplusplus
;
6532 tree bad_alloc_type_node
, newtype
, deltype
;
6534 push_namespace (get_identifier ("std"));
6535 bad_alloc_type_node
= xref_tag
6536 (class_type_node
, get_identifier ("bad_alloc"), 1);
6539 newtype
= build_exception_variant
6540 (ptr_ftype_sizetype
, build_tree_list (NULL_TREE
, bad_alloc_type_node
));
6541 deltype
= build_exception_variant
6542 (void_ftype_ptr
, build_tree_list (NULL_TREE
, NULL_TREE
));
6543 auto_function (ansi_opname
[(int) NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6544 auto_function (ansi_opname
[(int) VEC_NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6545 global_delete_fndecl
6546 = auto_function (ansi_opname
[(int) DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6547 auto_function (ansi_opname
[(int) VEC_DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6551 = define_function ("__pure_virtual", void_ftype
,
6552 NOT_BUILT_IN
, 0, 0);
6554 /* Perform other language dependent initializations. */
6555 init_class_processing ();
6556 init_init_processing ();
6557 init_search_processing ();
6559 init_rtti_processing ();
6561 if (flag_exceptions
)
6562 init_exception_processing ();
6565 flag_inline_functions
= 0;
6568 if (! supports_one_only ())
6571 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6572 declare_function_name ();
6574 /* Prepare to check format strings against argument lists. */
6575 init_function_format_info ();
6577 /* Show we use EH for cleanups. */
6578 using_eh_for_cleanups ();
6580 print_error_function
= lang_print_error_function
;
6581 lang_get_alias_set
= &c_get_alias_set
;
6582 valid_lang_attribute
= cp_valid_lang_attribute
;
6584 /* Maintain consistency. Perhaps we should just complain if they
6585 say -fwritable-strings? */
6586 if (flag_writable_strings
)
6587 flag_const_strings
= 0;
6590 /* Function to print any language-specific context for an error message. */
6593 lang_print_error_function (file
)
6596 default_print_error_function (file
);
6597 maybe_print_template_context ();
6600 /* Make a definition for a builtin function named NAME and whose data type
6601 is TYPE. TYPE should be a function type with argument types.
6602 FUNCTION_CODE tells later passes how to compile calls to this function.
6603 See tree.h for its possible values.
6605 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6606 the name to be called if we can't opencode the function. */
6609 define_function (name
, type
, function_code
, pfn
, library_name
)
6612 enum built_in_function function_code
;
6613 void (*pfn
) PROTO((tree
));
6614 const char *library_name
;
6616 tree decl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), type
);
6617 DECL_EXTERNAL (decl
) = 1;
6618 TREE_PUBLIC (decl
) = 1;
6619 DECL_ARTIFICIAL (decl
) = 1;
6621 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6622 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
6624 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6625 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6626 function in the namespace. */
6627 if (pfn
) (*pfn
) (decl
);
6629 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
6630 make_function_rtl (decl
);
6631 if (function_code
!= NOT_BUILT_IN
)
6633 DECL_BUILT_IN (decl
) = 1;
6634 DECL_FUNCTION_CODE (decl
) = function_code
;
6640 builtin_function (name
, type
, code
, libname
)
6643 enum built_in_function code
;
6644 const char *libname
;
6646 return define_function (name
, type
, code
, (void (*) PROTO((tree
)))pushdecl
, libname
);
6649 /* When we call finish_struct for an anonymous union, we create
6650 default copy constructors and such. But, an anonymous union
6651 shouldn't have such things; this function undoes the damage to the
6652 anonymous union type T.
6654 (The reason that we create the synthesized methods is that we don't
6655 distinguish `union { int i; }' from `typedef union { int i; } U'.
6656 The first is an anonymous union; the second is just an ordinary
6660 fixup_anonymous_aggr (t
)
6665 /* Wipe out memory of synthesized methods */
6666 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6667 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6668 TYPE_HAS_INIT_REF (t
) = 0;
6669 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6670 TYPE_HAS_ASSIGN_REF (t
) = 0;
6671 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6673 /* Splice the implicitly generated functions out of the TYPE_METHODS
6675 q
= &TYPE_METHODS (t
);
6678 if (DECL_ARTIFICIAL (*q
))
6679 *q
= TREE_CHAIN (*q
);
6681 q
= &TREE_CHAIN (*q
);
6684 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
6685 function members. */
6686 if (TYPE_METHODS (t
))
6687 error ("an anonymous union cannot have function members");
6690 /* Make sure that a declaration with no declarator is well-formed, i.e.
6691 just defines a tagged type or anonymous union.
6693 Returns the type defined, if any. */
6696 check_tag_decl (declspecs
)
6700 tree ob_modifier
= NULL_TREE
;
6702 register tree t
= NULL_TREE
;
6704 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6706 register tree value
= TREE_VALUE (link
);
6712 if (IS_AGGR_TYPE (value
) || TREE_CODE (value
) == ENUMERAL_TYPE
)
6714 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
6718 else if (value
== ridpointers
[(int) RID_FRIEND
])
6720 if (current_class_type
== NULL_TREE
6721 || current_scope () != current_class_type
)
6722 ob_modifier
= value
;
6724 else if (value
== ridpointers
[(int) RID_STATIC
]
6725 || value
== ridpointers
[(int) RID_EXTERN
]
6726 || value
== ridpointers
[(int) RID_AUTO
]
6727 || value
== ridpointers
[(int) RID_REGISTER
]
6728 || value
== ridpointers
[(int) RID_INLINE
]
6729 || value
== ridpointers
[(int) RID_VIRTUAL
]
6730 || value
== ridpointers
[(int) RID_CONST
]
6731 || value
== ridpointers
[(int) RID_VOLATILE
]
6732 || value
== ridpointers
[(int) RID_EXPLICIT
])
6733 ob_modifier
= value
;
6737 error ("multiple types in one declaration");
6739 /* Inside a class, we might be in a friend or access declaration.
6740 Until we have a good way of detecting the latter, don't warn. */
6741 if (t
== NULL_TREE
&& ! current_class_type
)
6742 pedwarn ("declaration does not declare anything");
6744 /* Check for an anonymous union. We're careful
6745 accessing TYPE_IDENTIFIER because some built-in types, like
6746 pointer-to-member types, do not have TYPE_NAME. */
6747 else if (t
&& IS_AGGR_TYPE_CODE (TREE_CODE (t
))
6749 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
6751 /* Anonymous unions are objects, so they can have specifiers. */;
6752 SET_ANON_AGGR_TYPE_P (t
);
6754 if (TREE_CODE (t
) != UNION_TYPE
&& pedantic
&& ! in_system_header
)
6755 pedwarn ("ISO C++ prohibits anonymous structs");
6758 else if (ob_modifier
)
6760 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
6761 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
6762 cp_error ("`%D' can only be specified for functions", ob_modifier
);
6763 else if (ob_modifier
== ridpointers
[(int) RID_FRIEND
])
6764 cp_error ("`%D' can only be specified inside a class", ob_modifier
);
6765 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
6766 cp_error ("`%D' can only be specified for constructors",
6769 cp_error ("`%D' can only be specified for objects and functions",
6776 /* Called when a declaration is seen that contains no names to declare.
6777 If its type is a reference to a structure, union or enum inherited
6778 from a containing scope, shadow that tag name for the current scope
6779 with a forward reference.
6780 If its type defines a new named structure or union
6781 or defines an enum, it is valid but we need not do anything here.
6782 Otherwise, it is an error.
6784 C++: may have to grok the declspecs to learn about static,
6785 complain for anonymous unions. */
6788 shadow_tag (declspecs
)
6791 tree t
= check_tag_decl (declspecs
);
6794 maybe_process_partial_specialization (t
);
6796 /* This is where the variables in an anonymous union are
6797 declared. An anonymous union declaration looks like:
6799 because there is no declarator after the union, the parser
6800 sends that declaration here. */
6801 if (t
&& ANON_AGGR_TYPE_P (t
))
6803 fixup_anonymous_aggr (t
);
6805 if (TYPE_FIELDS (t
))
6807 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
6809 finish_anon_union (decl
);
6814 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6817 groktypename (typename
)
6820 if (TREE_CODE (typename
) != TREE_LIST
)
6822 return grokdeclarator (TREE_VALUE (typename
),
6823 TREE_PURPOSE (typename
),
6824 TYPENAME
, 0, NULL_TREE
);
6827 /* Decode a declarator in an ordinary declaration or data definition.
6828 This is called as soon as the type information and variable name
6829 have been parsed, before parsing the initializer if any.
6830 Here we create the ..._DECL node, fill in its type,
6831 and put it on the list of decls for the current context.
6832 The ..._DECL node is returned as the value.
6834 Exception: for arrays where the length is not specified,
6835 the type is left null, to be filled in by `cp_finish_decl'.
6837 Function definitions do not come here; they go to start_function
6838 instead. However, external and forward declarations of functions
6839 do go through here. Structure field declarations are done by
6840 grokfield and not through here. */
6842 /* Set this to zero to debug not using the temporary obstack
6843 to parse initializers. */
6844 int debug_temp_inits
= 1;
6847 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
6848 tree declarator
, declspecs
;
6850 tree attributes
, prefix_attributes
;
6853 register tree type
, tem
;
6855 extern int have_extern_spec
;
6856 extern int used_extern_spec
;
6860 /* See code below that used this. */
6861 int init_written
= initialized
;
6864 /* This should only be done once on the top most decl. */
6865 if (have_extern_spec
&& !used_extern_spec
)
6867 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
6869 used_extern_spec
= 1;
6872 if (attributes
|| prefix_attributes
)
6873 attrlist
= build_scratch_list (attributes
, prefix_attributes
);
6875 attrlist
= NULL_TREE
;
6877 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
6880 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
6883 type
= TREE_TYPE (decl
);
6885 if (type
== error_mark_node
)
6888 /* Don't lose if destructors must be executed at file-level. */
6889 if (! processing_template_decl
&& TREE_STATIC (decl
)
6890 && TYPE_NEEDS_DESTRUCTOR (complete_type (type
))
6891 && !TREE_PERMANENT (decl
))
6893 push_obstacks (&permanent_obstack
, &permanent_obstack
);
6894 decl
= copy_node (decl
);
6895 if (TREE_CODE (type
) == ARRAY_TYPE
)
6897 tree itype
= TYPE_DOMAIN (type
);
6898 if (itype
&& ! TREE_PERMANENT (itype
))
6900 itype
= build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype
)));
6901 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
6902 TREE_TYPE (decl
) = type
;
6909 = (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
6910 ? DECL_CLASS_CONTEXT (decl
)
6911 : DECL_CONTEXT (decl
);
6913 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
6914 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
6916 /* When parsing the initializer, lookup should use the object's
6918 push_decl_namespace (context
);
6921 /* We are only interested in class contexts, later. */
6922 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
6923 context
= NULL_TREE
;
6926 /* Is it valid for this decl to have an initializer at all?
6927 If not, set INITIALIZED to zero, which will indirectly
6928 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6929 switch (TREE_CODE (decl
))
6932 /* typedef foo = bar means give foo the same type as bar.
6933 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6934 Any other case of an initialization in a TYPE_DECL is an error. */
6935 if (pedantic
|| list_length (declspecs
) > 1)
6937 cp_error ("typedef `%D' is initialized", decl
);
6943 cp_error ("function `%#D' is initialized like a variable", decl
);
6953 if (! toplevel_bindings_p ()
6954 && DECL_EXTERNAL (decl
))
6955 cp_warning ("declaration of `%#D' has `extern' and is initialized",
6957 DECL_EXTERNAL (decl
) = 0;
6958 if (toplevel_bindings_p ())
6959 TREE_STATIC (decl
) = 1;
6961 /* Tell `pushdecl' this is an initialized decl
6962 even though we don't yet have the initializer expression.
6963 Also tell `cp_finish_decl' it may store the real initializer. */
6964 DECL_INITIAL (decl
) = error_mark_node
;
6967 if (context
&& TYPE_SIZE (complete_type (context
)) != NULL_TREE
)
6969 push_nested_class (context
, 2);
6971 if (TREE_CODE (decl
) == VAR_DECL
)
6973 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
6974 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
6975 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
6978 if (DECL_CONTEXT (field
) != context
)
6980 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6981 DECL_CONTEXT (field
), DECL_NAME (decl
),
6982 context
, DECL_NAME (decl
));
6983 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
6985 /* Static data member are tricky; an in-class initialization
6986 still doesn't provide a definition, so the in-class
6987 declaration will have DECL_EXTERNAL set, but will have an
6988 initialization. Thus, duplicate_decls won't warn
6989 about this situation, and so we check here. */
6990 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
6991 cp_error ("duplicate initialization of %D", decl
);
6992 if (duplicate_decls (decl
, field
))
6998 tree field
= check_classfn (context
, decl
);
6999 if (field
&& duplicate_decls (decl
, field
))
7003 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7004 DECL_IN_AGGR_P (decl
) = 0;
7005 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
7006 || CLASSTYPE_USE_TEMPLATE (context
))
7008 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
7009 /* [temp.expl.spec] An explicit specialization of a static data
7010 member of a template is a definition if the declaration
7011 includes an initializer; otherwise, it is a declaration.
7013 We check for processing_specialization so this only applies
7014 to the new specialization syntax. */
7015 if (DECL_INITIAL (decl
) == NULL_TREE
&& processing_specialization
)
7016 DECL_EXTERNAL (decl
) = 1;
7019 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
7020 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7024 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7025 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
7028 /* Set attributes here so if duplicate decl, will have proper attributes. */
7029 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
7031 /* Add this decl to the current binding level, but not if it
7032 comes from another scope, e.g. a static member variable.
7033 TEM may equal DECL or it may be a previous decl of the same name. */
7035 if ((TREE_CODE (decl
) != PARM_DECL
&& DECL_CONTEXT (decl
) != NULL_TREE
7036 /* Definitions of namespace members outside their namespace are
7038 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
7039 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
7040 || TREE_CODE (type
) == LANG_TYPE
7041 /* The declaration of template specializations does not affect
7042 the functions available for overload resolution, so we do not
7044 || (TREE_CODE (decl
) == FUNCTION_DECL
7045 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
7048 tem
= pushdecl (decl
);
7050 if (processing_template_decl
)
7052 if (! current_function_decl
)
7053 tem
= push_template_decl (tem
);
7054 else if (minimal_parse_mode
)
7056 = build_min_nt (DECL_STMT
, copy_to_permanent (declarator
),
7057 copy_to_permanent (declspecs
),
7062 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7063 /* Tell the back-end to use or not use .common as appropriate. If we say
7064 -fconserve-space, we want this to save .data space, at the expense of
7065 wrong semantics. If we say -fno-conserve-space, we want this to
7066 produce errors about redefs; to do this we force variables into the
7068 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
7071 if (! processing_template_decl
)
7074 /* Corresponding pop_obstacks is done in `cp_finish_decl'. */
7075 push_obstacks_nochange ();
7078 /* We have no way of knowing whether the initializer will need to be
7079 evaluated at run-time or not until we've parsed it, so let's just put
7080 it in the permanent obstack. (jason) */
7082 && ! (TREE_CODE (tem
) == PARM_DECL
7083 || (TREE_READONLY (tem
)
7084 && (TREE_CODE (tem
) == VAR_DECL
7085 || TREE_CODE (tem
) == FIELD_DECL
))))
7087 /* When parsing and digesting the initializer,
7088 use temporary storage. Do this even if we will ignore the value. */
7089 if (toplevel_bindings_p () && debug_temp_inits
)
7091 if (processing_template_decl
7092 || TYPE_NEEDS_CONSTRUCTING (type
)
7093 || TREE_CODE (type
) == REFERENCE_TYPE
)
7094 /* In this case, the initializer must lay down in permanent
7095 storage, since it will be saved until `finish_file' is run. */
7098 temporary_allocation ();
7110 tree type
= TREE_TYPE (decl
);
7111 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
7113 if (type
== error_mark_node
)
7116 /* If this type of object needs a cleanup, and control may
7117 jump past it, make a new binding level so that it is cleaned
7118 up only when it is initialized first. */
7119 if (TYPE_NEEDS_DESTRUCTOR (type
)
7120 && current_binding_level
->more_cleanups_ok
== 0)
7121 pushlevel_temporary (1);
7124 /* Is it valid for this decl to have an initializer at all?
7125 If not, set INITIALIZED to zero, which will indirectly
7126 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7128 /* Don't allow initializations for incomplete types except for
7129 arrays which might be completed by the initialization. */
7130 if (TYPE_SIZE (complete_type (type
)) != NULL_TREE
)
7131 ; /* A complete type is ok. */
7132 else if (TREE_CODE (type
) != ARRAY_TYPE
)
7134 cp_error ("variable `%#D' has initializer but incomplete type",
7137 type
= TREE_TYPE (decl
) = error_mark_node
;
7139 else if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
7141 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
7142 cp_error ("elements of array `%#D' have incomplete type", decl
);
7143 /* else we already gave an error in start_decl. */
7149 && TREE_CODE (decl
) != TYPE_DECL
7150 && TREE_CODE (decl
) != TEMPLATE_DECL
7151 && IS_AGGR_TYPE (type
) && ! DECL_EXTERNAL (decl
))
7153 if ((! processing_template_decl
|| ! uses_template_parms (type
))
7154 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
7156 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7158 /* Change the type so that assemble_variable will give
7159 DECL an rtl we can live with: (mem (const_int 0)). */
7160 type
= TREE_TYPE (decl
) = error_mark_node
;
7164 /* If any base type in the hierarchy of TYPE needs a constructor,
7165 then we set initialized to 1. This way any nodes which are
7166 created for the purposes of initializing this aggregate
7167 will live as long as it does. This is necessary for global
7168 aggregates which do not have their initializers processed until
7169 the end of the file. */
7170 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
7175 /* We don't do this yet for GNU C++. */
7176 /* For a local variable, define the RTL now. */
7177 if (! toplevel_bindings_p ()
7178 /* But not if this is a duplicate decl
7179 and we preserved the rtl from the previous one
7180 (which may or may not happen). */
7181 && DECL_RTL (tem
) == NULL_RTX
)
7183 if (TYPE_SIZE (TREE_TYPE (tem
)) != NULL_TREE
)
7185 else if (TREE_CODE (TREE_TYPE (tem
)) == ARRAY_TYPE
7186 && DECL_INITIAL (tem
) != NULL_TREE
)
7192 DECL_INITIAL (decl
) = NULL_TREE
;
7195 /* Handle initialization of references.
7196 These three arguments are from `cp_finish_decl', and have the
7197 same meaning here that they do there.
7199 Quotes on semantics can be found in ARM 8.4.3. */
7202 grok_reference_init (decl
, type
, init
)
7203 tree decl
, type
, init
;
7207 if (init
== NULL_TREE
)
7209 if ((DECL_LANG_SPECIFIC (decl
) == 0
7210 || DECL_IN_AGGR_P (decl
) == 0)
7211 && ! DECL_THIS_EXTERN (decl
))
7213 cp_error ("`%D' declared as reference but not initialized", decl
);
7214 if (TREE_CODE (decl
) == VAR_DECL
)
7215 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
7220 if (init
== error_mark_node
)
7223 if (TREE_CODE (type
) == REFERENCE_TYPE
7224 && TREE_CODE (init
) == CONSTRUCTOR
)
7226 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl
);
7230 if (TREE_CODE (init
) == TREE_LIST
)
7231 init
= build_compound_expr (init
);
7233 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
7234 init
= convert_from_reference (init
);
7236 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
7237 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
7239 /* Note: default conversion is only called in very special cases. */
7240 init
= default_conversion (init
);
7243 tmp
= convert_to_reference
7244 (type
, init
, CONV_IMPLICIT
,
7245 LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
, decl
);
7247 if (tmp
== error_mark_node
)
7249 else if (tmp
!= NULL_TREE
)
7252 DECL_INITIAL (decl
) = save_expr (init
);
7256 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
7260 /* ?? Can this be optimized in some cases to
7261 hand back the DECL_INITIAL slot?? */
7262 if (TYPE_SIZE (TREE_TYPE (type
)))
7264 init
= convert_from_reference (decl
);
7265 if (TREE_PERMANENT (decl
))
7266 init
= copy_to_permanent (init
);
7267 SET_DECL_REFERENCE_SLOT (decl
, init
);
7270 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
7272 expand_static_init (decl
, DECL_INITIAL (decl
));
7273 DECL_INITIAL (decl
) = NULL_TREE
;
7278 if (TREE_CODE (decl
) == VAR_DECL
)
7279 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
7283 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7284 mucking with forces it does not comprehend (i.e. initialization with a
7285 constructor). If we are at global scope and won't go into COMMON, fill
7286 it in with a dummy CONSTRUCTOR to force the variable into .data;
7287 otherwise we can use error_mark_node. */
7290 obscure_complex_init (decl
, init
)
7293 if (! flag_no_inline
&& TREE_STATIC (decl
))
7295 if (extract_init (decl
, init
))
7299 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7300 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
7301 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
7305 DECL_INITIAL (decl
) = error_mark_node
;
7310 /* Issue an error message if DECL is an uninitialized const variable. */
7313 check_for_uninitialized_const_var (decl
)
7316 tree type
= TREE_TYPE (decl
);
7318 /* ``Unless explicitly declared extern, a const object does not have
7319 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7321 if (TREE_CODE (decl
) == VAR_DECL
7322 && TREE_CODE (type
) != REFERENCE_TYPE
7323 && CP_TYPE_CONST_P (type
)
7324 && !TYPE_NEEDS_CONSTRUCTING (type
)
7325 && !DECL_INITIAL (decl
))
7326 cp_error ("uninitialized const `%D'", decl
);
7329 /* Finish processing of a declaration;
7330 install its line number and initial value.
7331 If the length of an array type is not known before,
7332 it must be determined now, from the initial value, or it is an error.
7334 Call `pop_obstacks' iff NEED_POP is nonzero.
7336 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
7337 for aggregates that have constructors alive on the permanent obstack,
7338 so that the global initializing functions can be written at the end.
7340 INIT0 holds the value of an initializer that should be allowed to escape
7343 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7344 if the (init) syntax was used.
7346 For functions that take default parameters, DECL points to its
7347 "maximal" instantiation. `cp_finish_decl' must then also declared its
7348 subsequently lower and lower forms of instantiation, checking for
7349 ambiguity as it goes. This can be sped up later. */
7352 cp_finish_decl (decl
, init
, asmspec_tree
, need_pop
, flags
)
7359 tree cleanup
= NULL_TREE
, ttype
= NULL_TREE
;
7361 int temporary
= allocation_temporary_p ();
7362 char *asmspec
= NULL
;
7363 int was_readonly
= 0;
7364 int already_used
= 0;
7367 /* If this is 0, then we did not change obstacks. */
7371 error ("assignment (not initialization) in declaration");
7375 /* If a name was specified, get the string. */
7377 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
7379 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
7381 cp_error ("Cannot initialize `%D' to namespace `%D'",
7386 if (current_class_type
7387 && DECL_REAL_CONTEXT (decl
) == current_class_type
7388 && TYPE_BEING_DEFINED (current_class_type
)
7389 && (DECL_INITIAL (decl
) || init
))
7390 DECL_DEFINED_IN_CLASS_P (decl
) = 1;
7392 if (TREE_CODE (decl
) == VAR_DECL
7393 && DECL_CONTEXT (decl
)
7394 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
7395 && DECL_CONTEXT (decl
) != current_namespace
7398 /* Leave the namespace of the object. */
7399 pop_decl_namespace ();
7402 /* If the type of the thing we are declaring either has
7403 a constructor, or has a virtual function table pointer,
7404 AND its initialization was accepted by `start_decl',
7405 then we stayed on the permanent obstack through the
7406 declaration, otherwise, changed obstacks as GCC would. */
7408 type
= TREE_TYPE (decl
);
7410 if (type
== error_mark_node
)
7412 if (toplevel_bindings_p () && temporary
)
7413 end_temporary_allocation ();
7418 if (TYPE_HAS_MUTABLE_P (type
))
7419 TREE_READONLY (decl
) = 0;
7421 if (processing_template_decl
)
7423 if (init
&& DECL_INITIAL (decl
))
7424 DECL_INITIAL (decl
) = init
;
7425 if (minimal_parse_mode
&& ! DECL_ARTIFICIAL (decl
))
7427 tree stmt
= DECL_VINDEX (decl
);
7428 /* If the decl is declaring a member of a local class (in a
7429 template function), the DECL_VINDEX will either be NULL,
7430 or it will be an actual virtual function index, not a
7432 if (stmt
!= NULL_TREE
&& TREE_CODE (stmt
) == DECL_STMT
)
7434 DECL_VINDEX (decl
) = NULL_TREE
;
7435 TREE_OPERAND (stmt
, 2) = copy_to_permanent (init
);
7443 /* Take care of TYPE_DECLs up front. */
7444 if (TREE_CODE (decl
) == TYPE_DECL
)
7446 if (init
&& DECL_INITIAL (decl
))
7448 /* typedef foo = bar; store the type of bar as the type of foo. */
7449 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
7450 DECL_INITIAL (decl
) = init
= NULL_TREE
;
7452 if (type
!= error_mark_node
7453 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
7455 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7456 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
7457 set_identifier_type_value (DECL_NAME (decl
), type
);
7458 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
7460 GNU_xref_decl (current_function_decl
, decl
);
7462 /* If we have installed this as the canonical typedef for this
7463 type, and that type has not been defined yet, delay emitting
7464 the debug information for it, as we will emit it later. */
7465 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7466 && TYPE_SIZE (TREE_TYPE (decl
)) == NULL_TREE
)
7467 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
7469 rest_of_decl_compilation (decl
, NULL_PTR
,
7470 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
7474 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7475 ttype
= target_type (type
);
7477 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
7478 && TYPE_NEEDS_CONSTRUCTING (type
))
7480 /* Currently, GNU C++ puts constants in text space, making them
7481 impossible to initialize. In the future, one would hope for
7482 an operating system which understood the difference between
7483 initialization and the running of a program. */
7485 TREE_READONLY (decl
) = 0;
7488 if (TREE_CODE (decl
) == FIELD_DECL
)
7490 if (init
&& init
!= error_mark_node
)
7491 my_friendly_assert (TREE_PERMANENT (init
), 147);
7495 /* This must override the asm specifier which was placed
7496 by grokclassfn. Lay this out fresh. */
7497 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
7498 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7499 make_decl_rtl (decl
, asmspec
, 0);
7502 /* If `start_decl' didn't like having an initialization, ignore it now. */
7503 else if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7505 else if (DECL_EXTERNAL (decl
))
7507 else if (TREE_CODE (type
) == REFERENCE_TYPE
7508 || (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE_REFERENCE (type
)))
7510 if (TREE_STATIC (decl
))
7511 make_decl_rtl (decl
, NULL_PTR
,
7512 toplevel_bindings_p ()
7513 || pseudo_global_level_p ());
7514 grok_reference_init (decl
, type
, init
);
7518 /* Check for certain invalid initializations. */
7521 if (TYPE_SIZE (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
7523 cp_error ("variable-sized object `%D' may not be initialized", decl
);
7526 if (TREE_CODE (type
) == ARRAY_TYPE
7527 && !TYPE_SIZE (complete_type (TREE_TYPE (type
))))
7529 cp_error ("elements of array `%#D' have incomplete type", decl
);
7534 GNU_xref_decl (current_function_decl
, decl
);
7537 while (TREE_CODE (core_type
) == ARRAY_TYPE
)
7538 core_type
= TREE_TYPE (core_type
);
7540 if (TREE_CODE (decl
) == FIELD_DECL
)
7542 else if (TREE_CODE (decl
) == CONST_DECL
)
7544 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7546 DECL_INITIAL (decl
) = init
;
7548 /* This will keep us from needing to worry about our obstacks. */
7549 my_friendly_assert (init
!= NULL_TREE
, 149);
7554 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7556 if (TREE_CODE (type
) == ARRAY_TYPE
)
7557 init
= digest_init (type
, init
, (tree
*) 0);
7558 else if (TREE_CODE (init
) == CONSTRUCTOR
7559 && TREE_HAS_CONSTRUCTOR (init
))
7561 if (TYPE_NON_AGGREGATE_CLASS (type
))
7563 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7565 init
= error_mark_node
;
7568 goto dont_use_constructor
;
7573 dont_use_constructor
:
7574 if (TREE_CODE (init
) != TREE_VEC
)
7575 init
= store_init_value (decl
, init
);
7579 /* We must hide the initializer so that expand_decl
7580 won't try to do something it does not understand. */
7581 init
= obscure_complex_init (decl
, init
);
7583 else if (DECL_EXTERNAL (decl
))
7585 else if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't'
7586 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7588 if (! TYPE_NEEDS_CONSTRUCTING (core_type
))
7590 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
7591 cp_error ("structure `%D' with uninitialized const members", decl
);
7592 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
7593 cp_error ("structure `%D' with uninitialized reference members",
7597 check_for_uninitialized_const_var (decl
);
7599 if (TYPE_SIZE (type
) != NULL_TREE
7600 && TYPE_NEEDS_CONSTRUCTING (type
))
7601 init
= obscure_complex_init (decl
, NULL_TREE
);
7605 check_for_uninitialized_const_var (decl
);
7607 /* For top-level declaration, the initial value was read in
7608 the temporary obstack. MAXINDEX, rtl, etc. to be made below
7609 must go in the permanent obstack; but don't discard the
7610 temporary data yet. */
7612 if (toplevel_bindings_p () && temporary
)
7613 end_temporary_allocation ();
7615 /* Deduce size of array from initialization, if not already known. */
7617 if (TREE_CODE (type
) == ARRAY_TYPE
7618 && TYPE_DOMAIN (type
) == NULL_TREE
7619 && TREE_CODE (decl
) != TYPE_DECL
)
7622 = (TREE_STATIC (decl
)
7623 /* Even if pedantic, an external linkage array
7624 may have incomplete type at first. */
7625 ? pedantic
&& ! DECL_EXTERNAL (decl
)
7626 : !DECL_EXTERNAL (decl
));
7627 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7628 int failure
= complete_array_type (type
, initializer
, do_default
);
7631 cp_error ("initializer fails to determine size of `%D'", decl
);
7636 cp_error ("array size missing in `%D'", decl
);
7637 /* If a `static' var's size isn't known, make it extern as
7638 well as static, so it does not get allocated. If it's not
7639 `static', then don't mark it extern; finish_incomplete_decl
7640 will give it a default size and it will get allocated. */
7641 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7642 DECL_EXTERNAL (decl
) = 1;
7645 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7646 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7648 cp_error ("zero-size array `%D'", decl
);
7650 layout_decl (decl
, 0);
7653 if (TREE_CODE (decl
) == VAR_DECL
)
7655 if (DECL_SIZE (decl
) == NULL_TREE
7656 && TYPE_SIZE (complete_type (TREE_TYPE (decl
))) != NULL_TREE
)
7657 layout_decl (decl
, 0);
7659 if (TREE_STATIC (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7661 /* A static variable with an incomplete type:
7662 that is an error if it is initialized.
7663 Otherwise, let it through, but if it is not `extern'
7664 then it may cause an error message later. */
7665 if (DECL_INITIAL (decl
) != NULL_TREE
)
7666 cp_error ("storage size of `%D' isn't known", decl
);
7669 else if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7671 /* An automatic variable with an incomplete type: that is an error.
7672 Don't talk about array types here, since we took care of that
7673 message in grokdeclarator. */
7674 cp_error ("storage size of `%D' isn't known", decl
);
7675 TREE_TYPE (decl
) = error_mark_node
;
7677 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7678 /* Let debugger know it should output info for this type. */
7679 note_debug_info_needed (ttype
);
7681 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7682 note_debug_info_needed (DECL_CONTEXT (decl
));
7684 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7685 && DECL_SIZE (decl
) != NULL_TREE
7686 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7688 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7689 constant_expression_warning (DECL_SIZE (decl
));
7691 cp_error ("storage size of `%D' isn't constant", decl
);
7694 if (! DECL_EXTERNAL (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
7695 /* Cleanups for static variables are handled by `finish_file'. */
7696 && ! TREE_STATIC (decl
))
7698 int yes
= suspend_momentary ();
7699 cleanup
= maybe_build_cleanup (decl
);
7700 resume_momentary (yes
);
7703 /* PARM_DECLs get cleanups, too. */
7704 else if (TREE_CODE (decl
) == PARM_DECL
&& TYPE_NEEDS_DESTRUCTOR (type
))
7707 end_temporary_allocation ();
7708 cleanup
= maybe_build_cleanup (decl
);
7710 resume_temporary_allocation ();
7713 /* Output the assembler code and/or RTL code for variables and functions,
7714 unless the type is an undefined structure or union.
7715 If not, it will get done when the type is completed. */
7717 was_incomplete
= (DECL_SIZE (decl
) == NULL_TREE
);
7719 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
7720 || TREE_CODE (decl
) == RESULT_DECL
)
7722 /* ??? FIXME: What about nested classes? */
7723 int toplev
= toplevel_bindings_p () || pseudo_global_level_p ();
7725 = (TREE_STATIC (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
7726 && allocation_temporary_p ());
7729 end_temporary_allocation ();
7731 /* Static data in a function with comdat linkage also has comdat
7733 if (TREE_CODE (decl
) == VAR_DECL
7734 && TREE_STATIC (decl
)
7735 /* Don't mess with __FUNCTION__. */
7736 && ! TREE_ASM_WRITTEN (decl
)
7737 && current_function_decl
7738 && DECL_CONTEXT (decl
) == current_function_decl
7739 && (DECL_THIS_INLINE (current_function_decl
)
7740 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7741 && TREE_PUBLIC (current_function_decl
))
7743 /* Rather than try to get this right with inlining, we suppress
7744 inlining of such functions. */
7745 current_function_cannot_inline
7746 = "function with static variable cannot be inline";
7748 /* If flag_weak, we don't need to mess with this, as we can just
7749 make the function weak, and let it refer to its unique local
7750 copy. This works because we don't allow the function to be
7754 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7756 TREE_PUBLIC (decl
) = 1;
7757 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7759 else if (DECL_INITIAL (decl
) == NULL_TREE
7760 || DECL_INITIAL (decl
) == error_mark_node
)
7762 TREE_PUBLIC (decl
) = 1;
7763 DECL_COMMON (decl
) = 1;
7765 /* else we lose. We can only do this if we can use common,
7766 which we can't if it has been initialized. */
7768 if (TREE_PUBLIC (decl
))
7769 DECL_ASSEMBLER_NAME (decl
)
7770 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7771 else if (! DECL_ARTIFICIAL (decl
))
7773 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7774 cp_warning_at (" you can work around this by removing the initializer", decl
);
7779 else if (TREE_CODE (decl
) == VAR_DECL
7780 && DECL_LANG_SPECIFIC (decl
)
7781 && DECL_COMDAT (decl
))
7782 /* Set it up again; we might have set DECL_INITIAL since the
7784 comdat_linkage (decl
);
7786 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
7787 make_decl_rtl (decl
, NULL_PTR
, toplev
);
7788 else if (TREE_CODE (decl
) == VAR_DECL
7789 && TREE_READONLY (decl
)
7790 && DECL_INITIAL (decl
) != NULL_TREE
7791 && DECL_INITIAL (decl
) != error_mark_node
7792 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7794 DECL_INITIAL (decl
) = save_expr (DECL_INITIAL (decl
));
7797 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7800 && TREE_STATIC (decl
)
7801 && ! TREE_SIDE_EFFECTS (decl
)
7802 && ! TREE_PUBLIC (decl
)
7803 && ! DECL_EXTERNAL (decl
)
7804 && ! TYPE_NEEDS_DESTRUCTOR (type
)
7805 && DECL_MODE (decl
) != BLKmode
)
7807 /* If this variable is really a constant, then fill its DECL_RTL
7808 slot with something which won't take up storage.
7809 If something later should take its address, we can always give
7810 it legitimate RTL at that time. */
7811 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
7812 store_expr (DECL_INITIAL (decl
), DECL_RTL (decl
), 0);
7813 TREE_ASM_WRITTEN (decl
) = 1;
7815 else if (toplev
&& ! TREE_PUBLIC (decl
))
7817 /* If this is a static const, change its apparent linkage
7818 if it belongs to a #pragma interface. */
7819 if (!interface_unknown
)
7821 TREE_PUBLIC (decl
) = 1;
7822 DECL_EXTERNAL (decl
) = interface_only
;
7824 make_decl_rtl (decl
, asmspec
, toplev
);
7827 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7829 else if (TREE_CODE (decl
) == VAR_DECL
7830 && DECL_LANG_SPECIFIC (decl
)
7831 && DECL_IN_AGGR_P (decl
))
7833 if (TREE_STATIC (decl
))
7835 if (init
== NULL_TREE
7836 #ifdef DEFAULT_STATIC_DEFS
7837 /* If this code is dead, then users must
7838 explicitly declare static member variables
7839 outside the class def'n as well. */
7840 && TYPE_NEEDS_CONSTRUCTING (type
)
7844 DECL_EXTERNAL (decl
) = 1;
7845 make_decl_rtl (decl
, asmspec
, 1);
7848 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7851 /* Just a constant field. Should not need any rtl. */
7855 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7858 resume_temporary_allocation ();
7860 if (!abstract_virtuals_error (decl
, core_type
)
7861 && (TREE_CODE (type
) == FUNCTION_TYPE
7862 || TREE_CODE (type
) == METHOD_TYPE
))
7863 abstract_virtuals_error (decl
, TREE_TYPE (type
));
7865 if (TYPE_LANG_SPECIFIC (core_type
) && IS_SIGNATURE (core_type
))
7866 signature_error (decl
, core_type
);
7867 else if ((TREE_CODE (type
) == FUNCTION_TYPE
7868 || TREE_CODE (type
) == METHOD_TYPE
)
7869 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
7870 && IS_SIGNATURE (TREE_TYPE (type
)))
7871 signature_error (decl
, TREE_TYPE (type
));
7873 if (TREE_CODE (decl
) == FUNCTION_DECL
)
7875 else if (DECL_EXTERNAL (decl
)
7876 && ! (DECL_LANG_SPECIFIC (decl
)
7877 && DECL_NOT_REALLY_EXTERN (decl
)))
7880 DECL_INITIAL (decl
) = init
;
7882 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
7884 /* Cleanups for static variables are handled by `finish_file'. */
7885 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
7886 || TYPE_NEEDS_DESTRUCTOR (type
))
7887 expand_static_init (decl
, init
);
7891 /* This is a declared decl which must live until the
7892 end of the binding contour. It may need a cleanup. */
7894 /* Recompute the RTL of a local array now
7895 if it used to be an incomplete type. */
7896 if (was_incomplete
&& ! TREE_STATIC (decl
))
7898 /* If we used it already as memory, it must stay in memory. */
7899 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7900 /* If it's still incomplete now, no init will save it. */
7901 if (DECL_SIZE (decl
) == NULL_TREE
)
7902 DECL_INITIAL (decl
) = NULL_TREE
;
7905 else if (! TREE_ASM_WRITTEN (decl
)
7906 && (TYPE_SIZE (type
) != NULL_TREE
7907 || TREE_CODE (type
) == ARRAY_TYPE
))
7909 /* Do this here, because we did not expand this decl's
7910 rtl in start_decl. */
7911 if (DECL_RTL (decl
) == NULL_RTX
)
7915 /* XXX: Why don't we use decl here? */
7916 /* Ans: Because it was already expanded? */
7917 if (! expand_decl_cleanup (NULL_TREE
, cleanup
))
7918 cp_error ("parser lost in parsing declaration of `%D'",
7920 /* Cleanup used up here. */
7921 cleanup
= NULL_TREE
;
7925 if (current_binding_level
->is_for_scope
)
7927 struct binding_level
*outer
7928 = current_binding_level
->level_chain
;
7930 /* Check to see if the same name is already bound at
7931 the outer level, either because it was directly declared,
7932 or because a dead for-decl got preserved. In either case,
7933 the code would not have been valid under the ARM
7934 scope rules, so clear is_for_scope for the
7935 current_binding_level.
7937 Otherwise, we need to preserve the temp slot for decl
7938 to last into the outer binding level. */
7941 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl
)));
7943 if (outer_binding
&& BINDING_LEVEL (outer_binding
) == outer
7944 && (TREE_CODE (BINDING_VALUE (outer_binding
))
7946 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding
)))
7948 BINDING_VALUE (outer_binding
)
7949 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding
));
7950 current_binding_level
->is_for_scope
= 0;
7952 else if (DECL_IN_MEMORY_P (decl
))
7953 preserve_temp_slots (DECL_RTL (decl
));
7956 expand_start_target_temps ();
7958 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7960 /* Compute and store the initial value. */
7961 expand_decl_init (decl
);
7962 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7964 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7966 emit_line_note (DECL_SOURCE_FILE (decl
),
7967 DECL_SOURCE_LINE (decl
));
7968 expand_aggr_init (decl
, init
, flags
);
7971 /* Set this to 0 so we can tell whether an aggregate which
7972 was initialized was ever used. Don't do this if it has a
7973 destructor, so we don't complain about the 'resource
7974 allocation is initialization' idiom. */
7975 /* Now set attribute((unused)) on types so decls of
7976 that type will be marked used. (see TREE_USED, above.)
7977 This avoids the warning problems this particular code
7978 tried to work around. */
7980 if (TYPE_NEEDS_CONSTRUCTING (type
)
7982 && cleanup
== NULL_TREE
7983 && DECL_NAME (decl
))
7984 TREE_USED (decl
) = 0;
7987 TREE_USED (decl
) = 1;
7990 /* Cleanup any temporaries needed for the initial value. */
7991 expand_end_target_temps ();
7993 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7995 /* Store the cleanup, if there was one. */
7998 if (! expand_decl_cleanup (decl
, cleanup
))
7999 cp_error ("parser lost in parsing declaration of `%D'",
8006 /* Undo call to `pushclass' that was done in `start_decl'
8007 due to initialization of qualified member variable.
8008 I.e., Foo::x = 10; */
8010 tree context
= DECL_REAL_CONTEXT (decl
);
8012 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't'
8013 && (TREE_CODE (decl
) == VAR_DECL
8014 /* We also have a pushclass done that we need to undo here
8015 if we're at top level and declare a method. */
8016 || TREE_CODE (decl
) == FUNCTION_DECL
)
8017 /* If size hasn't been set, we're still defining it,
8018 and therefore inside the class body; don't pop
8019 the binding level.. */
8020 && TYPE_SIZE (context
) != NULL_TREE
8021 && context
== current_class_type
)
8022 pop_nested_class ();
8028 /* If requested, warn about definitions of large data objects. */
8030 if (warn_larger_than
8031 && ! processing_template_decl
8032 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
8033 && !DECL_EXTERNAL (decl
))
8035 register tree decl_size
= DECL_SIZE (decl
);
8037 if (decl_size
&& TREE_CODE (decl_size
) == INTEGER_CST
)
8039 unsigned units
= TREE_INT_CST_LOW (decl_size
) / BITS_PER_UNIT
;
8041 if (units
> larger_than_size
)
8042 warning_with_decl (decl
, "size of `%s' is %u bytes", units
);
8048 /* Resume permanent allocation, if not within a function. */
8049 /* The corresponding push_obstacks_nochange is in start_decl,
8050 start_method, groktypename, and in grokfield. */
8055 TREE_READONLY (decl
) = 1;
8058 /* This is here for a midend callback from c-common.c */
8061 finish_decl (decl
, init
, asmspec_tree
)
8065 cp_finish_decl (decl
, init
, asmspec_tree
, 1, 0);
8069 expand_static_init (decl
, init
)
8073 tree oldstatic
= value_member (decl
, static_aggregates
);
8077 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
8078 cp_error ("multiple initializations given for `%D'", decl
);
8080 else if (! toplevel_bindings_p ())
8082 /* Emit code to perform this initialization but once. */
8085 /* Remember this information until end of file. */
8086 push_obstacks (&permanent_obstack
, &permanent_obstack
);
8088 /* Emit code to perform this initialization but once. This code
8091 static int temp = 0;
8093 // Do initialization.
8095 // Register variable for destruction at end of program.
8098 Note that the `temp' variable is only set to 1 *after* the
8099 initialization is complete. This ensures that an exception,
8100 thrown during the construction, will cause the variable to
8101 reinitialized when we pass through this code again, as per:
8105 If the initialization exits by throwing an exception, the
8106 initialization is not complete, so it will be tried again
8107 the next time control enters the declaration.
8109 In theory, this process should be thread-safe, too; multiple
8110 threads should not be able to initialize the variable more
8111 than once. We don't yet attempt to ensure thread-safety. */
8112 temp
= get_temp_name (integer_type_node
, 1);
8113 rest_of_decl_compilation (temp
, NULL_PTR
, 0, 0);
8115 /* Begin the conditional initialization. */
8116 expand_start_cond (build_binary_op (EQ_EXPR
, temp
,
8117 integer_zero_node
), 0);
8118 expand_start_target_temps ();
8120 /* Do the initialization itself. */
8121 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
8122 || (init
&& TREE_CODE (init
) == TREE_LIST
))
8124 expand_aggr_init (decl
, init
, 0);
8125 do_pending_stack_adjust ();
8128 expand_assignment (decl
, init
, 0, 0);
8130 /* Set TEMP to 1. */
8131 expand_assignment (temp
, integer_one_node
, 0, 0);
8133 /* Cleanup any temporaries needed for the initial value. If
8134 destroying one of the temporaries causes an exception to be
8135 thrown, then the object itself has still been fully
8137 expand_end_target_temps ();
8139 /* Use atexit to register a function for destroying this static
8141 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
8143 tree cleanup
, fcall
;
8144 static tree Atexit
= 0;
8145 int saved_flag_access_control
;
8149 tree atexit_fndecl
, PFV
, pfvlist
;
8150 /* Remember this information until end of file. */
8151 push_obstacks (&permanent_obstack
, &permanent_obstack
);
8152 PFV
= build_pointer_type (build_function_type
8153 (void_type_node
, void_list_node
));
8155 pfvlist
= tree_cons (NULL_TREE
, PFV
, void_list_node
);
8157 push_lang_context (lang_name_c
);
8158 /* Note that we do not call pushdecl for this function;
8159 there's no reason that this declaration should be
8160 accessible to anyone. */
8162 = define_function ("atexit",
8163 build_function_type (void_type_node
,
8168 mark_used (atexit_fndecl
);
8169 Atexit
= default_conversion (atexit_fndecl
);
8170 pop_lang_context ();
8174 /* Call build_cleanup before we enter the anonymous function
8175 so that any access checks will be done relative to the
8176 current scope, rather than the scope of the anonymous
8178 build_cleanup (decl
);
8180 /* Now start the function. */
8181 cleanup
= start_anon_func ();
8183 /* Now, recompute the cleanup. It may contain SAVE_EXPRs
8184 that refer to the original function, rather than the
8185 anonymous one. That will make the back-end think that
8186 nested functions are in use, which causes confusion. */
8187 saved_flag_access_control
= flag_access_control
;
8188 flag_access_control
= 0;
8189 fcall
= build_cleanup (decl
);
8190 flag_access_control
= saved_flag_access_control
;
8192 /* Finish off the function. */
8193 expand_expr_stmt (fcall
);
8196 /* Call atexit with the cleanup function. */
8197 mark_addressable (cleanup
);
8198 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
8199 fcall
= build_function_call (Atexit
,
8200 expr_tree_cons (NULL_TREE
,
8203 expand_expr_stmt (fcall
);
8207 /* Resume old (possibly temporary) allocation. */
8212 /* This code takes into account memory allocation policy of
8213 `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING does not
8214 hold for this object, then we must make permanent the storage
8215 currently in the temporary obstack. */
8216 if (!TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
8217 preserve_initializer ();
8218 static_aggregates
= perm_tree_cons (init
, decl
, static_aggregates
);
8222 /* Make TYPE a complete type based on INITIAL_VALUE.
8223 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8224 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8227 complete_array_type (type
, initial_value
, do_default
)
8228 tree type
, initial_value
;
8231 register tree maxindex
= NULL_TREE
;
8234 /* Allocate on the same obstack as TYPE. */
8235 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8239 /* Note MAXINDEX is really the maximum index,
8240 one less than the size. */
8241 if (TREE_CODE (initial_value
) == STRING_CST
)
8244 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8245 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
8248 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8250 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
8251 maxindex
= size_binop (MINUS_EXPR
, integer_zero_node
, size_one_node
);
8252 for (; elts
; elts
= TREE_CHAIN (elts
))
8254 if (TREE_PURPOSE (elts
))
8255 maxindex
= TREE_PURPOSE (elts
);
8257 maxindex
= size_binop (PLUS_EXPR
, maxindex
, size_one_node
);
8259 maxindex
= copy_node (maxindex
);
8263 /* Make an error message unless that happened already. */
8264 if (initial_value
!= error_mark_node
)
8267 initial_value
= NULL_TREE
;
8269 /* Prevent further error messages. */
8270 maxindex
= build_int_2 (0, 0);
8277 maxindex
= build_int_2 (0, 0);
8286 domain
= build_index_type (maxindex
);
8287 TYPE_DOMAIN (type
) = domain
;
8289 if (! TREE_TYPE (maxindex
))
8290 TREE_TYPE (maxindex
) = domain
;
8292 itype
= TREE_TYPE (initial_value
);
8295 if (itype
&& !TYPE_DOMAIN (itype
))
8296 TYPE_DOMAIN (itype
) = domain
;
8297 /* The type of the main variant should never be used for arrays
8298 of different sizes. It should only ever be completed with the
8299 size of the array. */
8300 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
8301 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = domain
;
8306 /* Lay out the type now that we can get the real answer. */
8313 /* Return zero if something is declared to be a member of type
8314 CTYPE when in the context of CUR_TYPE. STRING is the error
8315 message to print in that case. Otherwise, quietly return 1. */
8318 member_function_or_else (ctype
, cur_type
, string
)
8319 tree ctype
, cur_type
;
8322 if (ctype
&& ctype
!= cur_type
)
8324 error (string
, TYPE_NAME_STRING (ctype
));
8330 /* Subroutine of `grokdeclarator'. */
8332 /* Generate errors possibly applicable for a given set of specifiers.
8333 This is for ARM $7.1.2. */
8336 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
8339 int virtualp
, quals
, friendp
, raises
, inlinep
;
8342 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
8344 cp_error ("`%D' declared as an `inline' %s", object
, type
);
8346 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8349 cp_error_at ("invalid friend declaration", object
);
8351 cp_error_at ("invalid exception specifications", object
);
8354 /* CTYPE is class type, or null if non-class.
8355 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8357 DECLARATOR is the function's name.
8358 VIRTUALP is truthvalue of whether the function is virtual or not.
8359 FLAGS are to be passed through to `grokclassfn'.
8360 QUALS are qualifiers indicating whether the function is `const'
8362 RAISES is a list of exceptions that this function can raise.
8363 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8364 not look, and -1 if we should not call `grokclassfn' at all.
8366 Returns `NULL_TREE' if something goes wrong, after issuing
8367 applicable error messages. */
8370 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8371 raises
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8372 template_count
, in_namespace
)
8375 tree orig_declarator
;
8377 enum overload_flags flags
;
8379 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8383 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8384 int has_default_arg
= 0;
8388 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8389 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8395 type
= build_exception_variant (type
, raises
);
8398 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8399 /* Propagate volatile out from type to decl. */
8400 if (TYPE_VOLATILE (type
))
8401 TREE_THIS_VOLATILE (decl
) = 1;
8403 /* If this decl has namespace scope, set that up. */
8405 set_decl_namespace (decl
, in_namespace
, friendp
);
8406 else if (publicp
&& ! ctype
)
8407 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8409 /* `main' and builtins have implicit 'C' linkage. */
8410 if ((MAIN_NAME_P (declarator
)
8411 || (IDENTIFIER_LENGTH (declarator
) > 10
8412 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8413 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8414 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8415 && current_lang_name
== lang_name_cplusplus
8416 && ctype
== NULL_TREE
8417 /* NULL_TREE means global namespace. */
8418 && DECL_CONTEXT (decl
) == NULL_TREE
)
8419 DECL_LANGUAGE (decl
) = lang_c
;
8421 /* Should probably propagate const out from type to decl I bet (mrs). */
8424 DECL_STATIC_FUNCTION_P (decl
) = 1;
8425 DECL_CONTEXT (decl
) = ctype
;
8429 DECL_CLASS_CONTEXT (decl
) = ctype
;
8431 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8433 if (processing_template_decl
)
8434 error ("cannot declare `main' to be a template");
8436 error ("cannot declare `main' to be inline");
8438 error ("cannot declare `main' to be static");
8443 /* Members of anonymous types and local classes have no linkage; make
8445 if (ctype
&& (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
))
8446 || hack_decl_function_context (TYPE_MAIN_DECL (ctype
))))
8451 /* [basic.link]: A name with no linkage (notably, the name of a class
8452 or enumeration declared in a local scope) shall not be used to
8453 declare an entity with linkage.
8455 Only check this for public decls for now. */
8456 t
= no_linkage_check (TREE_TYPE (decl
));
8459 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8461 if (DECL_LANGUAGE (decl
) == lang_c
)
8462 /* Allow this; it's pretty common in C. */;
8464 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8468 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8473 TREE_PUBLIC (decl
) = publicp
;
8476 DECL_INTERFACE_KNOWN (decl
) = 1;
8477 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8481 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8483 DECL_EXTERNAL (decl
) = 1;
8484 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8486 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8487 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8491 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8492 grok_op_properties (decl
, virtualp
, check
< 0);
8494 if (ctype
&& hack_decl_function_context (decl
))
8495 DECL_NO_STATIC_CHAIN (decl
) = 1;
8497 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8498 if (TREE_PURPOSE (t
)
8499 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8501 has_default_arg
= 1;
8506 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8510 ("defining explicit specialization `%D' in friend declaration",
8514 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8516 /* Something like `template <class T> friend void f<T>()'. */
8517 cp_error ("template-id `%D' in declaration of primary template",
8523 /* A friend declaration of the form friend void f<>(). Record
8524 the information in the TEMPLATE_ID_EXPR. */
8525 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8526 DECL_TEMPLATE_INFO (decl
)
8527 = perm_tree_cons (TREE_OPERAND (orig_declarator
, 0),
8528 TREE_OPERAND (orig_declarator
, 1),
8531 if (has_default_arg
)
8533 cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8540 cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8547 if (has_default_arg
)
8548 add_defarg_fn (decl
);
8550 /* Plain overloading: will not be grok'd by grokclassfn. */
8551 if (! ctype
&& ! processing_template_decl
8552 && DECL_LANGUAGE (decl
) != lang_c
8553 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
8554 set_mangled_name_for_decl (decl
);
8557 /* Make the init_value nonzero so pushdecl knows this is not
8558 tentative. error_mark_node is replaced later with the BLOCK. */
8559 DECL_INITIAL (decl
) = error_mark_node
;
8561 /* Caller will do the rest of this. */
8565 if (check
&& funcdef_flag
)
8566 DECL_INITIAL (decl
) = error_mark_node
;
8568 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8571 /* Just handle constructors here. We could do this
8572 inside the following if stmt, but I think
8573 that the code is more legible by breaking this
8574 case out. See comments below for what each of
8575 the following calls is supposed to do. */
8576 DECL_CONSTRUCTOR_P (decl
) = 1;
8578 grokclassfn (ctype
, decl
, flags
, quals
);
8580 decl
= check_explicit_specialization (orig_declarator
, decl
,
8582 2 * (funcdef_flag
!= 0) +
8583 4 * (friendp
!= 0));
8584 if (decl
== error_mark_node
)
8587 if ((! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8590 tmp
= check_classfn (ctype
, decl
);
8592 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8593 tmp
= DECL_TEMPLATE_RESULT(tmp
);
8595 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8596 cp_error ("definition of implicitly-declared `%D'", tmp
);
8597 if (tmp
&& duplicate_decls (decl
, tmp
))
8600 if (! grok_ctor_properties (ctype
, decl
))
8607 /* Function gets the ugly name, field gets the nice one.
8608 This call may change the type of the function (because
8609 of default parameters)! */
8610 if (ctype
!= NULL_TREE
)
8611 grokclassfn (ctype
, decl
, flags
, quals
);
8613 decl
= check_explicit_specialization (orig_declarator
, decl
,
8615 2 * (funcdef_flag
!= 0) +
8616 4 * (friendp
!= 0));
8617 if (decl
== error_mark_node
)
8620 if (ctype
!= NULL_TREE
8621 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8624 tmp
= check_classfn (ctype
, decl
);
8626 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8627 tmp
= DECL_TEMPLATE_RESULT (tmp
);
8629 if (tmp
&& DECL_STATIC_FUNCTION_P (tmp
)
8630 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8632 /* Remove the `this' parm added by grokclassfn.
8633 XXX Isn't this done in start_function, too? */
8634 revert_static_member_fn (&decl
, NULL
, NULL
);
8635 last_function_parms
= TREE_CHAIN (last_function_parms
);
8637 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8638 cp_error ("definition of implicitly-declared `%D'", tmp
);
8641 /* Attempt to merge the declarations. This can fail, in
8642 the case of some illegal specialization declarations. */
8643 if (!duplicate_decls (decl
, tmp
))
8644 cp_error ("no `%#D' member function declared in class `%T'",
8650 if (ctype
== NULL_TREE
|| check
)
8655 DECL_VIRTUAL_P (decl
) = 1;
8656 if (DECL_VINDEX (decl
) == NULL_TREE
)
8657 DECL_VINDEX (decl
) = error_mark_node
;
8658 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
8665 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
8668 RID_BIT_TYPE
*specbits_in
;
8674 RID_BIT_TYPE specbits
;
8676 specbits
= *specbits_in
;
8678 if (TREE_CODE (type
) == OFFSET_TYPE
)
8680 /* If you declare a static member so that it
8681 can be initialized, the code will reach here. */
8682 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
8683 type
= TREE_TYPE (type
);
8684 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
8685 DECL_CONTEXT (decl
) = basetype
;
8686 DECL_CLASS_CONTEXT (decl
) = basetype
;
8687 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
, declarator
);
8694 context
= in_namespace
;
8695 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
8696 context
= current_namespace
;
8698 context
= NULL_TREE
;
8700 decl
= build_decl (VAR_DECL
, declarator
, complete_type (type
));
8703 set_decl_namespace (decl
, context
, 0);
8705 context
= DECL_CONTEXT (decl
);
8706 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
8707 DECL_ASSEMBLER_NAME (decl
) = build_static_name (context
, declarator
);
8711 set_decl_namespace (decl
, in_namespace
, 0);
8713 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
8715 DECL_THIS_EXTERN (decl
) = 1;
8716 DECL_EXTERNAL (decl
) = !initialized
;
8719 /* In class context, static means one per class,
8720 public access, and static storage. */
8721 if (DECL_CLASS_SCOPE_P (decl
))
8723 TREE_PUBLIC (decl
) = 1;
8724 TREE_STATIC (decl
) = 1;
8725 DECL_EXTERNAL (decl
) = 0;
8727 /* At top level, either `static' or no s.c. makes a definition
8728 (perhaps tentative), and absence of `static' makes it public. */
8729 else if (toplevel_bindings_p ())
8731 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
8732 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8733 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8735 /* Not at top level, only `static' makes a static definition. */
8738 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
8739 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8742 if (TREE_PUBLIC (decl
))
8744 /* [basic.link]: A name with no linkage (notably, the name of a class
8745 or enumeration declared in a local scope) shall not be used to
8746 declare an entity with linkage.
8748 Only check this for public decls for now. */
8749 tree t
= no_linkage_check (TREE_TYPE (decl
));
8752 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8753 /* Ignore for now; `enum { foo } e' is pretty common. */;
8755 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8763 /* Create and return a canonical pointer to member function type, for
8764 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8767 build_ptrmemfunc_type (type
)
8774 /* If a canonical type already exists for this type, use it. We use
8775 this method instead of type_hash_canon, because it only does a
8776 simple equality check on the list of field members. */
8778 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8781 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8783 u
= make_lang_type (UNION_TYPE
);
8784 SET_IS_AGGR_TYPE (u
, 0);
8785 fields
[0] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
, type
);
8786 fields
[1] = build_lang_field_decl (FIELD_DECL
, delta2_identifier
,
8788 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
8789 TYPE_NAME (u
) = NULL_TREE
;
8791 t
= make_lang_type (RECORD_TYPE
);
8793 /* Let the front-end know this is a pointer to member function... */
8794 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8795 /* ... and not really an aggregate. */
8796 SET_IS_AGGR_TYPE (t
, 0);
8798 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
8800 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
8802 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
8803 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
8807 /* Zap out the name so that the back-end will give us the debugging
8808 information for this anonymous RECORD_TYPE. */
8809 TYPE_NAME (t
) = NULL_TREE
;
8811 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8813 /* Seems to be wanted. */
8814 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
8818 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8819 Check to see that the definition is valid. Issue appropriate error
8820 messages. Return 1 if the definition is particularly bad, or 0
8824 check_static_variable_definition (decl
, type
)
8828 /* Motion 10 at San Diego: If a static const integral data member is
8829 initialized with an integral constant expression, the initializer
8830 may appear either in the declaration (within the class), or in
8831 the definition, but not both. If it appears in the class, the
8832 member is a member constant. The file-scope definition is always
8834 if (CLASS_TYPE_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
8836 cp_error ("in-class initialization of static data member of non-integral type `%T'",
8838 /* If we just return the declaration, crashes will sometimes
8839 occur. We therefore return void_type_node, as if this was a
8840 friend declaration, to cause callers to completely ignore
8841 this declaration. */
8844 else if (!CP_TYPE_CONST_P (type
))
8845 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8847 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
8848 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
8853 /* Given declspecs and a declarator,
8854 determine the name and type of the object declared
8855 and construct a ..._DECL node for it.
8856 (In one case we can return a ..._TYPE node instead.
8857 For invalid input we sometimes return 0.)
8859 DECLSPECS is a chain of tree_list nodes whose value fields
8860 are the storage classes and type specifiers.
8862 DECL_CONTEXT says which syntactic context this declaration is in:
8863 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8864 FUNCDEF for a function definition. Like NORMAL but a few different
8865 error messages in each case. Return value may be zero meaning
8866 this definition is too screwy to try to parse.
8867 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8868 handle member functions (which have FIELD context).
8869 Return value may be zero meaning this definition is too screwy to
8871 PARM for a parameter declaration (either within a function prototype
8872 or before a function body). Make a PARM_DECL, or return void_type_node.
8873 CATCHPARM for a parameter declaration before a catch clause.
8874 TYPENAME if for a typename (in a cast or sizeof).
8875 Don't make a DECL node; just return the ..._TYPE node.
8876 FIELD for a struct or union field; make a FIELD_DECL.
8877 BITFIELD for a field with specified width.
8878 INITIALIZED is 1 if the decl has an initializer.
8880 ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
8881 normal attributes in TREE_PURPOSE, or NULL_TREE.
8883 In the TYPENAME case, DECLARATOR is really an absolute declarator.
8884 It may also be so in the PARM case, for a prototype where the
8885 argument type is specified but not the name.
8887 This function is where the complicated C meanings of `static'
8888 and `extern' are interpreted.
8890 For C++, if there is any monkey business to do, the function which
8891 calls this one must do it, i.e., prepending instance variables,
8892 renaming overloaded function names, etc.
8894 Note that for this C++, it is an error to define a method within a class
8895 which does not belong to that class.
8897 Except in the case where SCOPE_REFs are implicitly known (such as
8898 methods within a class being redundantly qualified),
8899 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
8900 (class_name::decl_name). The caller must also deal with this.
8902 If a constructor or destructor is seen, and the context is FIELD,
8903 then the type gains the attribute TREE_HAS_x. If such a declaration
8904 is erroneous, NULL_TREE is returned.
8906 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
8907 function, these are the qualifiers to give to the `this' pointer.
8909 May return void_type_node if the declarator turned out to be a friend.
8910 See grokfield for details. */
8912 enum return_types
{ return_normal
, return_ctor
, return_dtor
, return_conversion
};
8915 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
8918 enum decl_context decl_context
;
8922 RID_BIT_TYPE specbits
;
8925 tree type
= NULL_TREE
;
8931 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8932 int explicit_int
= 0;
8933 int explicit_char
= 0;
8934 int defaulted_int
= 0;
8935 int opaque_typedef
= 0;
8936 tree typedef_decl
= NULL_TREE
;
8938 tree typedef_type
= NULL_TREE
;
8939 int funcdef_flag
= 0;
8940 enum tree_code innermost_code
= ERROR_MARK
;
8943 /* See the code below that used this. */
8944 tree decl_machine_attr
= NULL_TREE
;
8946 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
8947 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
8948 tree init
= NULL_TREE
;
8950 /* Keep track of what sort of function is being processed
8951 so that we can warn about default return values, or explicit
8952 return values which do not match prescribed defaults. */
8953 enum return_types return_type
= return_normal
;
8955 tree dname
= NULL_TREE
;
8956 tree ctype
= current_class_type
;
8957 tree ctor_return_type
= NULL_TREE
;
8958 enum overload_flags flags
= NO_SPECIAL
;
8959 tree quals
= NULL_TREE
;
8960 tree raises
= NULL_TREE
;
8961 int template_count
= 0;
8962 tree in_namespace
= NULL_TREE
;
8966 RIDBIT_RESET_ALL (specbits
);
8967 if (decl_context
== FUNCDEF
)
8968 funcdef_flag
= 1, decl_context
= NORMAL
;
8969 else if (decl_context
== MEMFUNCDEF
)
8970 funcdef_flag
= -1, decl_context
= FIELD
;
8971 else if (decl_context
== BITFIELD
)
8972 bitfield
= 1, decl_context
= FIELD
;
8974 /* Look inside a declarator for the name being declared
8975 and get it as a string, for an error message. */
8977 tree
*next
= &declarator
;
8981 while (next
&& *next
)
8984 switch (TREE_CODE (decl
))
8987 /* For attributes. */
8988 next
= &TREE_VALUE (decl
);
8993 next
= &TREE_OPERAND (decl
, 0);
8996 case BIT_NOT_EXPR
: /* For C++ destructors! */
8998 tree name
= TREE_OPERAND (decl
, 0);
8999 tree rename
= NULL_TREE
;
9001 my_friendly_assert (flags
== NO_SPECIAL
, 152);
9003 return_type
= return_dtor
;
9004 if (TREE_CODE (name
) == TYPE_DECL
)
9005 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
9006 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
9007 if (ctype
== NULL_TREE
)
9009 if (current_class_type
== NULL_TREE
)
9011 error ("destructors must be member functions");
9016 tree t
= constructor_name (current_class_name
);
9023 tree t
= constructor_name (ctype
);
9030 cp_error ("destructor `%T' must match class name `%T'",
9032 TREE_OPERAND (decl
, 0) = rename
;
9038 case ADDR_EXPR
: /* C++ reference declaration */
9043 innermost_code
= TREE_CODE (decl
);
9044 next
= &TREE_OPERAND (decl
, 0);
9048 if (parmlist_is_exprlist (TREE_OPERAND (decl
, 1)))
9050 /* This is actually a variable declaration using
9051 constructor syntax. We need to call start_decl and
9052 cp_finish_decl so we can get the variable
9055 tree attributes
, prefix_attributes
;
9057 *next
= TREE_OPERAND (decl
, 0);
9058 init
= TREE_OPERAND (decl
, 1);
9062 attributes
= TREE_PURPOSE (attrlist
);
9063 prefix_attributes
= TREE_VALUE (attrlist
);
9067 attributes
= NULL_TREE
;
9068 prefix_attributes
= NULL_TREE
;
9071 decl
= start_decl (declarator
, declspecs
, 1,
9072 attributes
, prefix_attributes
);
9075 /* Look for __unused__ attribute */
9076 if (TREE_USED (TREE_TYPE (decl
)))
9077 TREE_USED (decl
) = 1;
9078 finish_decl (decl
, init
, NULL_TREE
);
9081 cp_error ("invalid declarator");
9084 innermost_code
= TREE_CODE (decl
);
9085 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
9086 ctype
= current_class_type
;
9088 && TREE_OPERAND (decl
, 0)
9089 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
9090 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
9091 == constructor_name_full (ctype
))
9092 || (DECL_NAME (TREE_OPERAND (decl
, 0))
9093 == constructor_name (ctype
)))))
9094 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9095 next
= &TREE_OPERAND (decl
, 0);
9097 if (ctype
!= NULL_TREE
9098 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
9099 && decl
== constructor_name (ctype
))
9101 return_type
= return_ctor
;
9102 ctor_return_type
= ctype
;
9107 case TEMPLATE_ID_EXPR
:
9109 tree fns
= TREE_OPERAND (decl
, 0);
9111 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
9112 fns
= TREE_OPERAND (fns
, 0);
9115 if (TREE_CODE (dname
) == COMPONENT_REF
)
9116 dname
= TREE_OPERAND (dname
, 1);
9117 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
9119 my_friendly_assert (is_overloaded_fn (dname
),
9121 dname
= DECL_NAME (get_first_fn (dname
));
9126 case IDENTIFIER_NODE
:
9127 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
9134 cp_error ("declarator-id missing; using reserved word `%D'",
9136 name
= IDENTIFIER_POINTER (dname
);
9138 if (! IDENTIFIER_OPNAME_P (dname
)
9139 /* GNU/Linux headers use '__op'. Arrgh. */
9140 || (IDENTIFIER_TYPENAME_P (dname
) && ! TREE_TYPE (dname
)))
9141 name
= IDENTIFIER_POINTER (dname
);
9144 if (IDENTIFIER_TYPENAME_P (dname
))
9146 my_friendly_assert (flags
== NO_SPECIAL
, 154);
9147 flags
= TYPENAME_FLAG
;
9148 ctor_return_type
= TREE_TYPE (dname
);
9149 return_type
= return_conversion
;
9151 name
= operator_name_string (dname
);
9158 /* Perform error checking, and decide on a ctype. */
9159 tree cname
= TREE_OPERAND (decl
, 0);
9160 if (cname
== NULL_TREE
)
9162 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
9165 in_namespace
= TREE_OPERAND (decl
, 0);
9166 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9168 else if (! is_aggr_type (cname
, 1))
9169 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9170 /* Must test TREE_OPERAND (decl, 1), in case user gives
9171 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9172 else if (TREE_OPERAND (decl
, 1)
9173 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
9175 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
9176 || TREE_CODE (cname
) == TEMPLATE_TEMPLATE_PARM
)
9178 cp_error ("`%T::%D' is not a valid declarator", cname
,
9179 TREE_OPERAND (decl
, 1));
9180 cp_error (" perhaps you want `typename %T::%D' to make it a type",
9181 cname
, TREE_OPERAND (decl
, 1));
9182 return void_type_node
;
9184 else if (ctype
== NULL_TREE
)
9186 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
9187 TREE_OPERAND (decl
, 0) = ctype
;
9190 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
9192 cp_error ("type `%T' is not derived from type `%T'",
9194 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9200 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
9201 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
9202 == constructor_name_full (ctype
))
9203 || (DECL_NAME (TREE_OPERAND (decl
, 1))
9204 == constructor_name (ctype
))))
9205 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
9206 next
= &TREE_OPERAND (decl
, 1);
9210 if (TREE_CODE (decl
) == IDENTIFIER_NODE
9211 && constructor_name (ctype
) == decl
)
9213 return_type
= return_ctor
;
9214 ctor_return_type
= ctype
;
9216 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
9217 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
9218 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
9219 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
9221 return_type
= return_dtor
;
9222 ctor_return_type
= ctype
;
9224 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9225 next
= &TREE_OPERAND (decl
, 0);
9236 /* Parse error puts this typespec where
9237 a declarator should go. */
9238 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
9239 if (TREE_TYPE (decl
) == current_class_type
)
9240 cp_error (" perhaps you want `%T' for a constructor",
9241 current_class_name
);
9242 dname
= DECL_NAME (decl
);
9243 name
= IDENTIFIER_POINTER (dname
);
9245 /* Avoid giving two errors for this. */
9246 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
9248 declspecs
= temp_tree_cons (NULL_TREE
, integer_type_node
,
9255 cp_compiler_error ("`%D' as declarator", decl
);
9256 return 0; /* We used to do a 155 abort here. */
9263 /* A function definition's declarator must have the form of
9264 a function declarator. */
9266 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
9269 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
9270 && innermost_code
!= CALL_EXPR
9271 && ! (ctype
&& declspecs
== NULL_TREE
))
9273 cp_error ("declaration of `%D' as non-function", dname
);
9274 return void_type_node
;
9277 /* Anything declared one level down from the top level
9278 must be one of the parameters of a function
9279 (because the body is at least two levels down). */
9281 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9282 by not allowing C++ class definitions to specify their parameters
9283 with xdecls (must be spec.d in the parmlist).
9285 Since we now wait to push a class scope until we are sure that
9286 we are in a legitimate method context, we must set oldcname
9287 explicitly (since current_class_name is not yet alive).
9289 We also want to avoid calling this a PARM if it is in a namespace. */
9291 if (decl_context
== NORMAL
&& ! namespace_bindings_p ()
9292 && ! pseudo_global_level_p ())
9294 struct binding_level
*b
= current_binding_level
;
9295 current_binding_level
= b
->level_chain
;
9296 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9297 decl_context
= PARM
;
9298 current_binding_level
= b
;
9301 /* Look through the decl specs and record which ones appear.
9302 Some typespecs are defined as built-in typenames.
9303 Others, the ones that are modifiers of other types,
9304 are represented by bits in SPECBITS: set the bits for
9305 the modifiers that appear. Storage class keywords are also in SPECBITS.
9307 If there is a typedef name or a type, store the type in TYPE.
9308 This includes builtin typedefs such as `int'.
9310 Set EXPLICIT_INT if the type is `int' or `char' and did not
9311 come from a user typedef.
9313 Set LONGLONG if `long' is mentioned twice.
9315 For C++, constructors and destructors have their own fast treatment. */
9317 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
9322 /* Certain parse errors slip through. For example,
9323 `int class;' is not caught by the parser. Try
9324 weakly to recover here. */
9325 if (TREE_CODE (spec
) != TREE_LIST
)
9328 id
= TREE_VALUE (spec
);
9330 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9332 if (id
== ridpointers
[(int) RID_INT
]
9333 || id
== ridpointers
[(int) RID_CHAR
]
9334 || id
== ridpointers
[(int) RID_BOOL
]
9335 || id
== ridpointers
[(int) RID_WCHAR
])
9339 if (id
== ridpointers
[(int) RID_BOOL
])
9340 error ("`bool' is now a keyword");
9342 cp_error ("extraneous `%T' ignored", id
);
9346 if (id
== ridpointers
[(int) RID_INT
])
9348 else if (id
== ridpointers
[(int) RID_CHAR
])
9350 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
9354 /* C++ aggregate types. */
9355 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
9358 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
9360 type
= IDENTIFIER_TYPE_VALUE (id
);
9364 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
9366 if (ridpointers
[i
] == id
)
9368 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
9370 if (pedantic
&& ! in_system_header
&& warn_long_long
)
9371 pedwarn ("ANSI C++ does not support `long long'");
9373 error ("`long long long' is too long for GCC");
9377 else if (RIDBIT_SETP (i
, specbits
))
9378 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
9379 RIDBIT_SET (i
, specbits
);
9384 /* C++ aggregate types. */
9385 else if (TREE_CODE (id
) == TYPE_DECL
|| TREE_CODE (id
) == TEMPLATE_DECL
)
9388 cp_error ("multiple declarations `%T' and `%T'", type
,
9392 type
= TREE_TYPE (id
);
9393 TREE_VALUE (spec
) = type
;
9398 error ("two or more data types in declaration of `%s'", name
);
9399 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9401 register tree t
= lookup_name (id
, 1);
9402 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9403 error ("`%s' fails to be a typedef or built in type",
9404 IDENTIFIER_POINTER (id
));
9407 type
= TREE_TYPE (t
);
9409 /* See the code below that used this. */
9410 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
9415 else if (id
!= error_mark_node
)
9416 /* Can't change CLASS nodes into RECORD nodes here! */
9422 typedef_type
= type
;
9424 /* No type at all: default to `int', and set DEFAULTED_INT
9425 because it was not a user-defined typedef.
9426 Except when we have a `typedef' inside a signature, in
9427 which case the type defaults to `unknown type' and is
9428 instantiated when assigning to a signature pointer or ref. */
9430 if (type
== NULL_TREE
9431 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
9432 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9433 || RIDBIT_SETP (RID_LONG
, specbits
)
9434 || RIDBIT_SETP (RID_SHORT
, specbits
)))
9436 /* These imply 'int'. */
9437 type
= integer_type_node
;
9441 if (type
== NULL_TREE
)
9444 if (return_type
== return_dtor
)
9445 type
= void_type_node
;
9446 else if (return_type
== return_ctor
)
9447 type
= build_pointer_type (ctor_return_type
);
9448 else if (return_type
== return_conversion
)
9449 type
= ctor_return_type
;
9450 else if (current_class_type
9451 && IS_SIGNATURE (current_class_type
)
9452 && RIDBIT_SETP (RID_TYPEDEF
, specbits
)
9453 && (decl_context
== FIELD
|| decl_context
== NORMAL
))
9457 type
= copy_node (opaque_type_node
);
9461 /* We handle `main' specially here, because 'main () { }' is so
9462 common. With no options, it is allowed. With -Wreturn-type,
9463 it is a warning. It is only an error with -pedantic-errors. */
9464 int is_main
= (funcdef_flag
9465 && MAIN_NAME_P (dname
)
9466 && ctype
== NULL_TREE
9467 && in_namespace
== NULL_TREE
9468 && current_namespace
== global_namespace
);
9470 if (in_system_header
)
9471 /* Allow it, sigh. */;
9472 else if (pedantic
|| ! is_main
)
9473 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
9475 else if (warn_return_type
)
9476 cp_warning ("ANSI C++ forbids declaration `%D' with no type",
9479 type
= integer_type_node
;
9482 else if (return_type
== return_dtor
)
9484 error ("return type specification for destructor invalid");
9485 type
= void_type_node
;
9487 else if (return_type
== return_ctor
)
9489 error ("return type specification for constructor invalid");
9490 type
= build_pointer_type (ctor_return_type
);
9492 else if (return_type
== return_conversion
)
9494 if (!same_type_p (type
, ctor_return_type
))
9495 cp_error ("operator `%T' declared to return `%T'",
9496 ctor_return_type
, type
);
9498 cp_pedwarn ("return type specified for `operator %T'",
9501 type
= ctor_return_type
;
9506 /* Now process the modifiers that were specified
9507 and check for invalid combinations. */
9509 /* Long double is a special combination. */
9511 if (RIDBIT_SETP (RID_LONG
, specbits
)
9512 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
9514 RIDBIT_RESET (RID_LONG
, specbits
);
9515 type
= build_qualified_type (long_double_type_node
,
9516 CP_TYPE_QUALS (type
));
9519 /* Check all other uses of type modifiers. */
9521 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9522 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9523 || RIDBIT_SETP (RID_LONG
, specbits
)
9524 || RIDBIT_SETP (RID_SHORT
, specbits
))
9528 if (TREE_CODE (type
) == REAL_TYPE
)
9529 error ("short, signed or unsigned invalid for `%s'", name
);
9530 else if (TREE_CODE (type
) != INTEGER_TYPE
)
9531 error ("long, short, signed or unsigned invalid for `%s'", name
);
9532 else if (RIDBIT_SETP (RID_LONG
, specbits
)
9533 && RIDBIT_SETP (RID_SHORT
, specbits
))
9534 error ("long and short specified together for `%s'", name
);
9535 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9536 || RIDBIT_SETP (RID_SHORT
, specbits
))
9538 error ("long or short specified with char for `%s'", name
);
9539 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9540 || RIDBIT_SETP (RID_SHORT
, specbits
))
9541 && TREE_CODE (type
) == REAL_TYPE
)
9542 error ("long or short specified with floating type for `%s'", name
);
9543 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9544 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
9545 error ("signed and unsigned given together for `%s'", name
);
9549 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
9551 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9553 if (flag_pedantic_errors
)
9558 /* Discard the type modifiers if they are invalid. */
9561 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
9562 RIDBIT_RESET (RID_SIGNED
, specbits
);
9563 RIDBIT_RESET (RID_LONG
, specbits
);
9564 RIDBIT_RESET (RID_SHORT
, specbits
);
9569 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
9570 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9572 error ("complex invalid for `%s'", name
);
9573 RIDBIT_RESET (RID_COMPLEX
, specbits
);
9576 /* Decide whether an integer type is signed or not.
9577 Optionally treat bitfields as signed by default. */
9578 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9581 It is implementation-defined whether a plain (neither
9582 explicitly signed or unsigned) char, short, int, or long
9583 bit-field is signed or unsigned.
9585 Naturally, we extend this to long long as well. Note that
9586 this does not include wchar_t. */
9587 || (bitfield
&& !flag_signed_bitfields
9588 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)
9589 /* A typedef for plain `int' without `signed' can be
9590 controlled just like plain `int', but a typedef for
9591 `signed int' cannot be so controlled. */
9593 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9594 && (TREE_CODE (type
) == INTEGER_TYPE
9595 || TREE_CODE (type
) == CHAR_TYPE
)
9596 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9599 type
= long_long_unsigned_type_node
;
9600 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9601 type
= long_unsigned_type_node
;
9602 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9603 type
= short_unsigned_type_node
;
9604 else if (type
== char_type_node
)
9605 type
= unsigned_char_type_node
;
9606 else if (typedef_decl
)
9607 type
= unsigned_type (type
);
9609 type
= unsigned_type_node
;
9611 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9612 && type
== char_type_node
)
9613 type
= signed_char_type_node
;
9615 type
= long_long_integer_type_node
;
9616 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9617 type
= long_integer_type_node
;
9618 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9619 type
= short_integer_type_node
;
9621 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
9623 /* If we just have "complex", it is equivalent to
9624 "complex double", but if any modifiers at all are specified it is
9625 the complex form of TYPE. E.g, "complex short" is
9626 "complex short int". */
9628 if (defaulted_int
&& ! longlong
9629 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
9630 || RIDBIT_SETP (RID_SHORT
, specbits
)
9631 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9632 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
9633 type
= complex_double_type_node
;
9634 else if (type
== integer_type_node
)
9635 type
= complex_integer_type_node
;
9636 else if (type
== float_type_node
)
9637 type
= complex_float_type_node
;
9638 else if (type
== double_type_node
)
9639 type
= complex_double_type_node
;
9640 else if (type
== long_double_type_node
)
9641 type
= complex_long_double_type_node
;
9643 type
= build_complex_type (type
);
9646 if (return_type
== return_conversion
9647 && (RIDBIT_SETP (RID_CONST
, specbits
)
9648 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
9649 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
9650 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9653 /* Set CONSTP if this declaration is `const', whether by
9654 explicit specification or via a typedef.
9655 Likewise for VOLATILEP. */
9657 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
9659 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
9661 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
9662 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9663 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9664 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9665 type
= cp_build_qualified_type (type
, type_quals
);
9667 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
9668 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
9669 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
9670 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
9671 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
9673 if (RIDBIT_SETP (RID_STATIC
, specbits
))
9674 staticp
= 1 + (decl_context
== FIELD
);
9676 if (virtualp
&& staticp
== 2)
9678 cp_error ("member `%D' cannot be declared both virtual and static",
9682 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
9683 RIDBIT_RESET (RID_FRIEND
, specbits
);
9685 /* $7.1.2, Function specifiers */
9686 if (friendp
&& explicitp
)
9687 error ("only declarations of constructors can be `explicit'");
9689 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9691 if (decl_context
== PARM
)
9693 error ("non-member `%s' cannot be declared `mutable'", name
);
9694 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9696 else if (friendp
|| decl_context
== TYPENAME
)
9698 error ("non-object member `%s' cannot be declared `mutable'", name
);
9699 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9703 /* Warn if two storage classes are given. Default to `auto'. */
9705 if (RIDBIT_ANY_SET (specbits
))
9707 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
9708 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
9709 if (decl_context
== PARM
&& nclasses
> 0)
9710 error ("storage class specifiers invalid in parameter declarations");
9711 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9713 if (decl_context
== PARM
)
9714 error ("typedef declaration invalid in parameter declaration");
9717 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
9718 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
9721 /* Give error if `virtual' is used outside of class declaration. */
9723 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9725 error ("virtual outside class declaration");
9728 if (current_class_name
== NULL_TREE
&& RIDBIT_SETP (RID_MUTABLE
, specbits
))
9730 error ("only members can be declared mutable");
9731 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9734 /* Static anonymous unions are dealt with here. */
9735 if (staticp
&& decl_context
== TYPENAME
9736 && TREE_CODE (declspecs
) == TREE_LIST
9737 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs
)))
9738 decl_context
= FIELD
;
9740 /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
9741 is used in a signature member function declaration. */
9742 if (decl_context
== FIELD
9743 && IS_SIGNATURE (current_class_type
)
9744 && RIDBIT_NOTSETP (RID_TYPEDEF
, specbits
))
9746 if (type_quals
!= TYPE_UNQUALIFIED
)
9748 error ("type qualifiers specified for signature member function `%s'", name
);
9749 type_quals
= TYPE_UNQUALIFIED
;
9753 error ("`inline' specified for signature member function `%s'", name
);
9754 /* Later, we'll make signature member functions inline. */
9759 error ("`friend' declaration in signature definition");
9764 error ("`virtual' specified for signature member function `%s'",
9766 /* Later, we'll make signature member functions virtual. */
9771 /* Warn about storage classes that are invalid for certain
9772 kinds of declarations (parameters, typenames, etc.). */
9775 error ("multiple storage classes in declaration of `%s'", name
);
9776 else if (decl_context
!= NORMAL
&& nclasses
> 0)
9778 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9779 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
9780 || RIDBIT_SETP (RID_AUTO
, specbits
)))
9782 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9784 else if (decl_context
== FIELD
9785 && ! IS_SIGNATURE (current_class_type
)
9786 /* C++ allows static class elements */
9787 && RIDBIT_SETP (RID_STATIC
, specbits
))
9788 /* C++ also allows inlines and signed and unsigned elements,
9789 but in those cases we don't come in here. */
9793 if (decl_context
== FIELD
)
9795 tree tmp
= NULL_TREE
;
9796 register int op
= 0;
9800 /* Avoid trying to get an operand off an identifier node. */
9801 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
9804 tmp
= TREE_OPERAND (declarator
, 0);
9805 op
= IDENTIFIER_OPNAME_P (tmp
);
9807 error ("storage class specified for %s `%s'",
9808 IS_SIGNATURE (current_class_type
)
9810 ? "signature member operator"
9811 : "signature member function")
9812 : (op
? "member operator" : "field"),
9813 op
? operator_name_string (tmp
) : name
);
9816 error (((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9817 ? "storage class specified for parameter `%s'"
9818 : "storage class specified for typename"), name
);
9819 RIDBIT_RESET (RID_REGISTER
, specbits
);
9820 RIDBIT_RESET (RID_AUTO
, specbits
);
9821 RIDBIT_RESET (RID_EXTERN
, specbits
);
9823 if (decl_context
== FIELD
&& IS_SIGNATURE (current_class_type
))
9825 RIDBIT_RESET (RID_STATIC
, specbits
);
9830 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
9832 if (toplevel_bindings_p ())
9834 /* It's common practice (and completely valid) to have a const
9835 be initialized and declared extern. */
9836 if (!(type_quals
& TYPE_QUAL_CONST
))
9837 warning ("`%s' initialized and declared `extern'", name
);
9840 error ("`%s' has both `extern' and initializer", name
);
9842 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
9843 && ! toplevel_bindings_p ())
9844 error ("nested function `%s' declared `extern'", name
);
9845 else if (toplevel_bindings_p ())
9847 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9848 error ("top-level declaration of `%s' specifies `auto'", name
);
9851 if (nclasses
> 0 && friendp
)
9852 error ("storage class specifiers invalid in friend function declarations");
9854 /* Now figure out the structure of the declarator proper.
9855 Descend through it, creating more complex types, until we reach
9856 the declared identifier (or NULL_TREE, in an absolute declarator). */
9858 inner_attrs
= NULL_TREE
;
9861 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
9862 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
9864 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9865 an INDIRECT_REF (for *...),
9866 a CALL_EXPR (for ...(...)),
9867 an identifier (for the name being declared)
9868 or a null pointer (for the place in an absolute declarator
9869 where the name was omitted).
9870 For the last two cases, we have just exited the loop.
9872 For C++ it could also be
9873 a SCOPE_REF (for class :: ...). In this case, we have converted
9874 sensible names to types, and those are the values we use to
9875 qualify the member name.
9876 an ADDR_EXPR (for &...),
9877 a BIT_NOT_EXPR (for destructors)
9879 At this point, TYPE is the type of elements of an array,
9880 or for a function to return, or for a pointer to point to.
9881 After this sequence of ifs, TYPE is the type of the
9882 array or function or pointer, and DECLARATOR has had its
9883 outermost layer removed. */
9885 if (type
== error_mark_node
)
9887 if (TREE_CODE (declarator
) == SCOPE_REF
)
9888 declarator
= TREE_OPERAND (declarator
, 1);
9890 declarator
= TREE_OPERAND (declarator
, 0);
9893 if (quals
!= NULL_TREE
9894 && (declarator
== NULL_TREE
9895 || TREE_CODE (declarator
) != SCOPE_REF
))
9897 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
9898 ctype
= TYPE_METHOD_BASETYPE (type
);
9899 if (ctype
!= NULL_TREE
)
9901 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
9902 ctype
= grok_method_quals (ctype
, dummy
, quals
);
9903 type
= TREE_TYPE (dummy
);
9908 /* See the comment for the TREE_LIST case, below. */
9911 else if (inner_attrs
)
9913 decl_attributes (type
, inner_attrs
, NULL_TREE
);
9914 inner_attrs
= NULL_TREE
;
9917 switch (TREE_CODE (declarator
))
9921 /* We encode a declarator with embedded attributes using
9922 a TREE_LIST. The attributes apply to the declarator
9923 directly inside them, so we have to skip an iteration
9924 before applying them to the type. If the declarator just
9925 inside is the declarator-id, we apply the attrs to the
9927 inner_attrs
= TREE_PURPOSE (declarator
);
9929 declarator
= TREE_VALUE (declarator
);
9935 register tree itype
= NULL_TREE
;
9936 register tree size
= TREE_OPERAND (declarator
, 1);
9937 /* The index is a signed object `sizetype' bits wide. */
9938 tree index_type
= signed_type (sizetype
);
9940 declarator
= TREE_OPERAND (declarator
, 0);
9942 /* Check for some types that there cannot be arrays of. */
9944 if (TREE_CODE (type
) == VOID_TYPE
)
9946 cp_error ("declaration of `%D' as array of voids", dname
);
9947 type
= error_mark_node
;
9950 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9952 cp_error ("declaration of `%D' as array of functions", dname
);
9953 type
= error_mark_node
;
9956 /* ARM $8.4.3: Since you can't have a pointer to a reference,
9957 you can't have arrays of references. If we allowed them,
9958 then we'd be saying x[i] is valid for an array x, but
9959 then you'd have to ask: what does `*(x + i)' mean? */
9960 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9962 if (decl_context
== TYPENAME
)
9963 cp_error ("cannot make arrays of references");
9965 cp_error ("declaration of `%D' as array of references",
9967 type
= error_mark_node
;
9970 if (TREE_CODE (type
) == OFFSET_TYPE
)
9972 cp_error ("declaration of `%D' as array of data members",
9974 type
= error_mark_node
;
9977 if (TREE_CODE (type
) == METHOD_TYPE
)
9979 cp_error ("declaration of `%D' as array of function members",
9981 type
= error_mark_node
;
9984 if (size
== error_mark_node
)
9985 type
= error_mark_node
;
9986 else if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9990 the constant expressions that specify the bounds of
9991 the arrays can be omitted only for the first member
9993 cp_error ("declaration of `%D' as multidimensional array",
9995 cp_error ("must have bounds for all dimensions except the first");
9996 type
= error_mark_node
;
9999 if (type
== error_mark_node
)
10002 /* VC++ spells a zero-sized array with []. */
10003 if (size
== NULL_TREE
&& decl_context
== FIELD
&& ! staticp
10004 && ! RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10005 size
= integer_zero_node
;
10009 /* Must suspend_momentary here because the index
10010 type may need to live until the end of the function.
10011 For example, it is used in the declaration of a
10012 variable which requires destructing at the end of
10013 the function; then build_vec_delete will need this
10015 int yes
= suspend_momentary ();
10016 /* Might be a cast. */
10017 if (TREE_CODE (size
) == NOP_EXPR
10018 && TREE_TYPE (size
) == TREE_TYPE (TREE_OPERAND (size
, 0)))
10019 size
= TREE_OPERAND (size
, 0);
10020 if (TREE_READONLY_DECL_P (size
))
10021 size
= decl_constant_value (size
);
10023 /* If this involves a template parameter, it will be a
10024 constant at instantiation time, but we don't know
10025 what the value is yet. Even if no template
10026 parameters are involved, we may an expression that
10027 is not a constant; we don't even simplify `1 + 2'
10028 when processing a template. */
10029 if (processing_template_decl
)
10031 /* Resolve a qualified reference to an enumerator or
10032 static const data member of ours. */
10033 if (TREE_CODE (size
) == SCOPE_REF
10034 && TREE_OPERAND (size
, 0) == current_class_type
)
10036 tree t
= lookup_field (current_class_type
,
10037 TREE_OPERAND (size
, 1), 0, 0);
10042 itype
= make_node (INTEGER_TYPE
);
10043 TYPE_MIN_VALUE (itype
) = size_zero_node
;
10044 TYPE_MAX_VALUE (itype
) = build_min
10045 (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
10046 goto dont_grok_size
;
10049 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
10050 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
10051 && TREE_CODE (TREE_TYPE (size
)) != BOOLEAN_TYPE
)
10053 cp_error ("size of array `%D' has non-integer type",
10055 size
= integer_one_node
;
10057 if (pedantic
&& integer_zerop (size
))
10058 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname
);
10059 if (TREE_CONSTANT (size
))
10061 int old_flag_pedantic_errors
= flag_pedantic_errors
;
10062 int old_pedantic
= pedantic
;
10063 pedantic
= flag_pedantic_errors
= 1;
10064 /* Always give overflow errors on array subscripts. */
10065 constant_expression_warning (size
);
10066 pedantic
= old_pedantic
;
10067 flag_pedantic_errors
= old_flag_pedantic_errors
;
10068 if (INT_CST_LT (size
, integer_zero_node
))
10070 cp_error ("size of array `%D' is negative", dname
);
10071 size
= integer_one_node
;
10079 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
10082 cp_pedwarn ("ANSI C++ forbids variable-size array");
10087 = fold (build_binary_op (MINUS_EXPR
,
10088 cp_convert (index_type
, size
),
10089 cp_convert (index_type
,
10090 integer_one_node
)));
10091 if (! TREE_CONSTANT (itype
))
10092 itype
= variable_size (itype
);
10093 else if (TREE_OVERFLOW (itype
))
10095 error ("overflow in array dimension");
10096 TREE_OVERFLOW (itype
) = 0;
10099 /* If we're a parm, we need to have a permanent type so
10100 mangling checks for re-use will work right. If both the
10101 element and index types are permanent, the array type
10103 if (decl_context
== PARM
10104 && allocation_temporary_p () && TREE_PERMANENT (type
))
10106 push_obstacks (&permanent_obstack
, &permanent_obstack
);
10107 itype
= build_index_type (itype
);
10111 itype
= build_index_type (itype
);
10114 resume_momentary (yes
);
10117 type
= build_cplus_array_type (type
, itype
);
10126 tree inner_parms
= TREE_OPERAND (declarator
, 1);
10127 tree inner_decl
= TREE_OPERAND (declarator
, 0);
10129 /* Declaring a function type.
10130 Make sure we have a valid type for the function to return. */
10132 /* We now know that the TYPE_QUALS don't apply to the
10133 decl, but to its return type. */
10134 type_quals
= TYPE_UNQUALIFIED
;
10136 /* Warn about some types functions can't return. */
10138 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10140 error ("`%s' declared as function returning a function", name
);
10141 type
= integer_type_node
;
10143 if (TREE_CODE (type
) == ARRAY_TYPE
)
10145 error ("`%s' declared as function returning an array", name
);
10146 type
= integer_type_node
;
10149 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
10150 inner_decl
= TREE_OPERAND (inner_decl
, 1);
10152 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
10153 inner_decl
= dname
;
10155 /* Pick up type qualifiers which should be applied to `this'. */
10156 quals
= TREE_OPERAND (declarator
, 2);
10158 /* Pick up the exception specifications. */
10159 raises
= TREE_TYPE (declarator
);
10161 /* Say it's a definition only for the CALL_EXPR
10162 closest to the identifier. */
10165 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
10166 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
10167 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
10169 if (ctype
== NULL_TREE
10170 && decl_context
== FIELD
10172 && (friendp
== 0 || dname
== current_class_name
))
10173 ctype
= current_class_type
;
10175 if (ctype
&& return_type
== return_conversion
)
10176 TYPE_HAS_CONVERSION (ctype
) = 1;
10177 if (ctype
&& constructor_name (ctype
) == dname
)
10179 /* We are within a class's scope. If our declarator name
10180 is the same as the class name, and we are defining
10181 a function, then it is a constructor/destructor, and
10182 therefore returns a void type. */
10184 if (flags
== DTOR_FLAG
)
10186 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
10187 not be declared const or volatile. A destructor
10188 may not be static. */
10190 error ("destructor cannot be static member function");
10193 cp_error ("destructors may not be `%s'",
10194 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10197 if (decl_context
== FIELD
)
10199 if (! member_function_or_else (ctype
, current_class_type
,
10200 "destructor for alien class `%s' cannot be a member"))
10201 return void_type_node
;
10204 else /* It's a constructor. */
10206 if (explicitp
== 1)
10208 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
10209 not be declared const or volatile. A constructor may
10210 not be virtual. A constructor may not be static. */
10212 error ("constructor cannot be static member function");
10215 pedwarn ("constructors cannot be declared virtual");
10220 cp_error ("constructors may not be `%s'",
10221 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10225 RID_BIT_TYPE tmp_bits
;
10226 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
10227 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
10228 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
10229 if (RIDBIT_ANY_SET (tmp_bits
))
10230 error ("return value type specifier for constructor ignored");
10232 type
= build_pointer_type (ctype
);
10233 if (decl_context
== FIELD
10234 && IS_SIGNATURE (current_class_type
))
10236 error ("constructor not allowed in signature");
10237 return void_type_node
;
10239 else if (decl_context
== FIELD
)
10241 if (! member_function_or_else (ctype
, current_class_type
,
10242 "constructor for alien class `%s' cannot be member"))
10243 return void_type_node
;
10244 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
10245 if (return_type
!= return_ctor
)
10249 if (decl_context
== FIELD
)
10255 error ("can't initialize friend function `%s'", name
);
10258 /* Cannot be both friend and virtual. */
10259 error ("virtual functions cannot be friends");
10260 RIDBIT_RESET (RID_FRIEND
, specbits
);
10263 if (decl_context
== NORMAL
)
10264 error ("friend declaration not in class definition");
10265 if (current_function_decl
&& funcdef_flag
)
10266 cp_error ("can't define friend function `%s' in a local class definition",
10270 /* Construct the function type and go to the next
10271 inner layer of declarator. */
10273 declarator
= TREE_OPERAND (declarator
, 0);
10275 /* FIXME: This is where default args should be fully
10278 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
10280 if (declarator
&& flags
== DTOR_FLAG
)
10282 /* A destructor declared in the body of a class will
10283 be represented as a BIT_NOT_EXPR. But, we just
10284 want the underlying IDENTIFIER. */
10285 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
10286 declarator
= TREE_OPERAND (declarator
, 0);
10288 if (strict_prototype
== 0 && arg_types
== NULL_TREE
)
10289 arg_types
= void_list_node
;
10290 else if (arg_types
== NULL_TREE
10291 || arg_types
!= void_list_node
)
10293 cp_error ("destructors may not have parameters");
10294 arg_types
= void_list_node
;
10295 last_function_parms
= NULL_TREE
;
10299 /* ANSI says that `const int foo ();'
10300 does not make the function foo const. */
10301 type
= build_function_type (type
, arg_types
);
10305 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
10306 if (TREE_PURPOSE (t
)
10307 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
10309 add_defarg_fn (type
);
10318 /* Filter out pointers-to-references and references-to-references.
10319 We can get these if a TYPE_DECL is used. */
10321 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10323 error ("cannot declare %s to references",
10324 TREE_CODE (declarator
) == ADDR_EXPR
10325 ? "references" : "pointers");
10326 declarator
= TREE_OPERAND (declarator
, 0);
10330 if (TREE_CODE (type
) == OFFSET_TYPE
10331 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
10332 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
10334 cp_error ("cannot declare pointer to `%#T' member",
10336 type
= TREE_TYPE (type
);
10339 /* Merge any constancy or volatility into the target type
10340 for the pointer. */
10342 /* We now know that the TYPE_QUALS don't apply to the decl,
10343 but to the target of the pointer. */
10344 type_quals
= TYPE_UNQUALIFIED
;
10346 if (IS_SIGNATURE (type
))
10348 if (TREE_CODE (declarator
) == ADDR_EXPR
)
10350 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
10351 && TYPE_SIZE (type
))
10352 cp_warning ("empty signature `%T' used in signature reference declaration",
10355 type
= build_signature_reference_type (type
);
10357 sorry ("signature reference");
10363 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
10364 && TYPE_SIZE (type
))
10365 cp_warning ("empty signature `%T' used in signature pointer declaration",
10367 type
= build_signature_pointer_type (type
);
10370 else if (TREE_CODE (declarator
) == ADDR_EXPR
)
10372 if (TREE_CODE (type
) == VOID_TYPE
)
10373 error ("invalid type: `void &'");
10375 type
= build_reference_type (type
);
10377 else if (TREE_CODE (type
) == METHOD_TYPE
)
10378 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10380 type
= build_pointer_type (type
);
10382 /* Process a list of type modifier keywords (such as
10383 const or volatile) that were given inside the `*' or `&'. */
10385 if (TREE_TYPE (declarator
))
10387 register tree typemodlist
;
10393 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
10394 typemodlist
= TREE_CHAIN (typemodlist
))
10396 tree qualifier
= TREE_VALUE (typemodlist
);
10398 if (qualifier
== ridpointers
[(int) RID_CONST
])
10400 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
10402 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
10407 error ("invalid type modifier within pointer declarator");
10411 pedwarn ("duplicate `const'");
10413 pedwarn ("duplicate `volatile'");
10415 pedwarn ("duplicate `restrict'");
10417 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10418 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10419 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10420 if (TREE_CODE (declarator
) == ADDR_EXPR
10421 && (constp
|| volatilep
))
10424 pedwarn ("discarding `const' applied to a reference");
10426 pedwarn ("discarding `volatile' applied to a reference");
10427 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
10429 type
= cp_build_qualified_type (type
, type_quals
);
10431 declarator
= TREE_OPERAND (declarator
, 0);
10437 /* We have converted type names to NULL_TREE if the
10438 name was bogus, or to a _TYPE node, if not.
10440 The variable CTYPE holds the type we will ultimately
10441 resolve to. The code here just needs to build
10442 up appropriate member types. */
10443 tree sname
= TREE_OPERAND (declarator
, 1);
10446 /* Destructors can have their visibilities changed as well. */
10447 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
10448 sname
= TREE_OPERAND (sname
, 0);
10450 if (TREE_COMPLEXITY (declarator
) == 0)
10451 /* This needs to be here, in case we are called
10452 multiple times. */ ;
10453 else if (TREE_COMPLEXITY (declarator
) == -1)
10454 /* Namespace member. */
10455 pop_decl_namespace ();
10456 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
10457 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10458 else if (! IS_AGGR_TYPE_CODE
10459 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
10461 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
10463 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10464 that refer to ctype. They couldn't be resolved earlier
10465 because we hadn't pushed into the class yet.
10466 Example: resolve 'B<T>::type' in
10467 'B<typename B<T>::type> B<T>::f () { }'. */
10468 if (current_template_parms
10469 && uses_template_parms (type
)
10470 && uses_template_parms (current_class_type
))
10472 tree args
= current_template_args ();
10473 type
= tsubst (type
, args
, /*complain=*/1, NULL_TREE
);
10476 /* This pop_nested_class corresponds to the
10477 push_nested_class used to push into class scope for
10478 parsing the argument list of a function decl, in
10480 pop_nested_class ();
10481 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10484 my_friendly_abort (16);
10486 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10488 /* We had a reference to a global decl, or
10489 perhaps we were given a non-aggregate typedef,
10490 in which case we cleared this out, and should just
10491 keep going as though it wasn't there. */
10492 declarator
= sname
;
10495 ctype
= TREE_OPERAND (declarator
, 0);
10498 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
10500 if (CLASSTYPE_TEMPLATE_INFO (t
) &&
10501 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
10502 template_count
+= 1;
10503 t
= TYPE_MAIN_DECL (t
);
10504 if (DECL_LANG_SPECIFIC (t
))
10505 t
= DECL_CLASS_CONTEXT (t
);
10510 if (sname
== NULL_TREE
)
10513 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10515 /* This is the `standard' use of the scoping operator:
10516 basetype :: member . */
10518 if (ctype
== current_class_type
)
10524 Is this ill-formed? */
10527 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10530 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10532 if (current_class_type
== NULL_TREE
10534 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10535 TYPE_ARG_TYPES (type
));
10538 cp_error ("cannot declare member function `%T::%s' within `%T'",
10539 ctype
, name
, current_class_type
);
10540 return void_type_node
;
10543 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10544 || TYPE_SIZE (complete_type (ctype
)) != NULL_TREE
)
10546 /* Have to move this code elsewhere in this function.
10547 this code is used for i.e., typedef int A::M; M *pm;
10549 It is? How? jason 10/2/94 */
10551 if (current_class_type
)
10553 cp_error ("cannot declare member `%T::%s' within `%T'",
10554 ctype
, name
, current_class_type
);
10555 return void_type_node
;
10557 type
= build_offset_type (ctype
, type
);
10559 else if (uses_template_parms (ctype
))
10561 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10563 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
10564 TYPE_ARG_TYPES (type
));
10568 cp_error ("structure `%T' not yet defined", ctype
);
10569 return error_mark_node
;
10572 declarator
= sname
;
10574 else if (TREE_CODE (sname
) == SCOPE_REF
)
10575 my_friendly_abort (17);
10579 declarator
= TREE_OPERAND (declarator
, 1);
10580 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
10581 /* In this case, we will deal with it later. */
10585 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10586 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10587 TYPE_ARG_TYPES (type
));
10589 type
= build_offset_type (ctype
, type
);
10596 declarator
= TREE_OPERAND (declarator
, 0);
10601 case ENUMERAL_TYPE
:
10602 declarator
= NULL_TREE
;
10606 declarator
= NULL_TREE
;
10610 my_friendly_abort (158);
10614 /* See the comment for the TREE_LIST case, above. */
10617 if (! ignore_attrs
)
10618 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10620 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
10622 attrlist
= build_decl_list (NULL_TREE
, inner_attrs
);
10625 /* Now TYPE has the actual type. */
10627 if (explicitp
== 1)
10629 error ("only constructors can be declared `explicit'");
10633 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10635 if (type_quals
& TYPE_QUAL_CONST
)
10637 error ("const `%s' cannot be declared `mutable'", name
);
10638 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10642 error ("static `%s' cannot be declared `mutable'", name
);
10643 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10647 if (declarator
== NULL_TREE
10648 || TREE_CODE (declarator
) == IDENTIFIER_NODE
10649 || (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
10650 && (TREE_CODE (type
) == FUNCTION_TYPE
10651 || TREE_CODE (type
) == METHOD_TYPE
)))
10653 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10655 cp_error ("template-id `%D' used as a declarator", declarator
);
10656 declarator
= dname
;
10659 /* Unexpected declarator format. */
10660 my_friendly_abort (990210);
10662 /* If this is declaring a typedef name, return a TYPE_DECL. */
10664 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
10668 /* Note that the grammar rejects storage classes
10669 in typenames, fields or parameters. */
10670 if (current_lang_name
== lang_name_java
)
10671 TYPE_FOR_JAVA (type
) = 1;
10673 if (decl_context
== FIELD
)
10675 if (declarator
== constructor_name (current_class_type
))
10676 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10678 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10679 if (IS_SIGNATURE (current_class_type
) && opaque_typedef
)
10680 SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type
) = 1;
10684 /* Make sure this typedef lives as long as its type,
10685 since it might be used as a template parameter. */
10686 if (type
!= error_mark_node
)
10687 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
10688 decl
= build_decl (TYPE_DECL
, declarator
, type
);
10689 if (type
!= error_mark_node
)
10693 /* If the user declares "struct {...} foo" then `foo' will have
10694 an anonymous name. Fill that name in now. Nothing can
10695 refer to it, so nothing needs know about the name change.
10696 The TYPE_NAME field was filled in by build_struct_xref. */
10697 if (type
!= error_mark_node
10698 && TYPE_NAME (type
)
10699 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10700 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
))
10701 && CP_TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
10703 tree oldname
= TYPE_NAME (type
);
10706 /* Replace the anonymous name with the real name everywhere. */
10707 lookup_tag_reverse (type
, declarator
);
10708 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10709 if (TYPE_NAME (t
) == oldname
)
10710 TYPE_NAME (t
) = decl
;
10712 if (TYPE_LANG_SPECIFIC (type
))
10713 TYPE_WAS_ANONYMOUS (type
) = 1;
10715 /* If this is a typedef within a template class, the nested
10716 type is a (non-primary) template. The name for the
10717 template needs updating as well. */
10718 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10719 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10720 = TYPE_IDENTIFIER (type
);
10722 /* XXX Temporarily set the scope.
10723 When returning, start_decl expects it as NULL_TREE,
10724 and will then then set it using pushdecl. */
10725 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
10726 if (current_class_type
)
10727 DECL_CONTEXT (decl
) = current_class_type
;
10729 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10731 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
10732 DECL_ASSEMBLER_NAME (decl
)
10733 = get_identifier (build_overload_name (type
, 1, 1));
10734 DECL_CONTEXT (decl
) = NULL_TREE
;
10736 /* FIXME remangle member functions; member functions of a
10737 type with external linkage have external linkage. */
10740 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10742 cp_error_at ("typedef name may not be class-qualified", decl
);
10747 if (ctype
== NULL_TREE
)
10749 if (TREE_CODE (type
) != METHOD_TYPE
)
10750 cp_error_at ("invalid type qualifier for non-method type", decl
);
10752 ctype
= TYPE_METHOD_BASETYPE (type
);
10754 if (ctype
!= NULL_TREE
)
10755 grok_method_quals (ctype
, decl
, quals
);
10758 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10759 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10760 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10762 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10763 error ("non-object member `%s' cannot be declared mutable", name
);
10765 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
10766 inlinep
, friendp
, raises
!= NULL_TREE
);
10769 error ("typedef declaration includes an initializer");
10774 /* Detect the case of an array type of unspecified size
10775 which came, as such, direct from a typedef name.
10776 We must copy the type, so that each identifier gets
10777 a distinct type, so that each identifier's size can be
10778 controlled separately by its own initializer. */
10780 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
10781 && TYPE_DOMAIN (type
) == NULL_TREE
)
10783 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
10786 /* If this is a type name (such as, in a cast or sizeof),
10787 compute the type and return it now. */
10789 if (decl_context
== TYPENAME
)
10791 /* Note that the grammar rejects storage classes
10792 in typenames, fields or parameters. */
10793 if (type_quals
!= TYPE_UNQUALIFIED
)
10795 if (IS_SIGNATURE (type
))
10796 error ("type qualifiers specified for signature type");
10797 type_quals
= TYPE_UNQUALIFIED
;
10800 /* Special case: "friend class foo" looks like a TYPENAME context. */
10803 if (type_quals
!= TYPE_UNQUALIFIED
)
10805 cp_error ("type qualifiers specified for friend class declaration");
10806 type_quals
= TYPE_UNQUALIFIED
;
10810 cp_error ("`inline' specified for friend class declaration");
10814 /* Only try to do this stuff if we didn't already give up. */
10815 if (type
!= integer_type_node
)
10817 /* A friendly class? */
10818 if (current_class_type
)
10819 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
10821 error ("trying to make class `%s' a friend of global scope",
10822 TYPE_NAME_STRING (type
));
10823 type
= void_type_node
;
10828 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
10829 if (ctype
== NULL_TREE
)
10831 my_friendly_assert (TREE_CODE (type
) == METHOD_TYPE
, 159);
10832 ctype
= TYPE_METHOD_BASETYPE (type
);
10834 grok_method_quals (ctype
, dummy
, quals
);
10835 type
= TREE_TYPE (dummy
);
10840 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
10841 && decl_context
!= CATCHPARM
10842 && TREE_CODE (type
) != UNION_TYPE
10845 cp_error ("abstract declarator `%T' used as declaration", type
);
10846 declarator
= make_anon_name ();
10849 /* `void' at top level (not within pointer)
10850 is allowed only in typedefs or type names.
10851 We don't complain about parms either, but that is because
10852 a better error message can be made later. */
10854 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
10857 error ("unnamed variable or field declared void");
10858 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10860 if (IDENTIFIER_OPNAME_P (declarator
))
10861 my_friendly_abort (356);
10863 error ("variable or field `%s' declared void", name
);
10866 error ("variable or field declared void");
10867 type
= integer_type_node
;
10870 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10871 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10873 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10875 if (ctype
|| in_namespace
)
10876 error ("cannot use `::' in parameter declaration");
10878 /* A parameter declared as an array of T is really a pointer to T.
10879 One declared as a function is really a pointer to a function.
10880 One declared as a member is really a pointer to member. */
10882 if (TREE_CODE (type
) == ARRAY_TYPE
)
10884 /* Transfer const-ness of array into that of type pointed to. */
10885 type
= build_pointer_type (TREE_TYPE (type
));
10886 type_quals
= TYPE_UNQUALIFIED
;
10888 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10889 type
= build_pointer_type (type
);
10890 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10891 type
= build_pointer_type (type
);
10892 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
10894 error ("declaration of `%s' as void", name
);
10900 register tree decl
;
10902 if (decl_context
== PARM
)
10904 decl
= build_decl (PARM_DECL
, declarator
, type
);
10906 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
10907 inlinep
, friendp
, raises
!= NULL_TREE
);
10908 if (current_class_type
10909 && IS_SIGNATURE (current_class_type
))
10912 error ("parameter of signature member function declared `inline'");
10913 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10914 error ("parameter of signature member function declared `auto'");
10915 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10916 error ("parameter of signature member function declared `register'");
10919 /* Compute the type actually passed in the parmlist,
10920 for the case where there is no prototype.
10921 (For example, shorts and chars are passed as ints.)
10922 When there is a prototype, this is overridden later. */
10924 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
10926 else if (decl_context
== FIELD
)
10928 if (type
== error_mark_node
)
10930 /* Happens when declaring arrays of sizes which
10931 are error_mark_node, for example. */
10934 else if (in_namespace
&& !friendp
)
10936 /* Something like struct S { int N::j; }; */
10937 cp_error ("invalid use of `::'");
10940 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10943 tree function_context
;
10945 /* We catch the others as conflicts with the builtin
10947 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
10949 cp_error ("function `%D' cannot be declared friend",
10956 if (ctype
== NULL_TREE
)
10957 ctype
= current_class_type
;
10959 if (ctype
== NULL_TREE
)
10961 cp_error ("can't make `%D' into a method -- not in a class",
10963 return void_type_node
;
10966 /* ``A union may [ ... ] not [ have ] virtual functions.''
10968 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10970 cp_error ("function `%D' declared virtual inside a union",
10972 return void_type_node
;
10975 if (declarator
== ansi_opname
[(int) NEW_EXPR
]
10976 || declarator
== ansi_opname
[(int) VEC_NEW_EXPR
]
10977 || declarator
== ansi_opname
[(int) DELETE_EXPR
]
10978 || declarator
== ansi_opname
[(int) VEC_DELETE_EXPR
])
10982 cp_error ("`%D' cannot be declared virtual, since it is always static",
10987 else if (staticp
< 2)
10988 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10989 TYPE_ARG_TYPES (type
));
10992 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10993 function_context
= (ctype
!= NULL_TREE
) ?
10994 hack_decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10995 publicp
= (! friendp
|| ! staticp
)
10996 && function_context
== NULL_TREE
;
10997 decl
= grokfndecl (ctype
, type
,
10998 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
10999 ? declarator
: dname
,
11001 virtualp
, flags
, quals
, raises
,
11002 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
11003 funcdef_flag
, template_count
, in_namespace
);
11004 if (decl
== NULL_TREE
)
11007 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11008 /* The decl and setting of decl_machine_attr is also turned off. */
11009 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
11012 /* [class.conv.ctor]
11014 A constructor declared without the function-specifier
11015 explicit that can be called with a single parameter
11016 specifies a conversion from the type of its first
11017 parameter to the type of its class. Such a constructor
11018 is called a converting constructor. */
11019 if (explicitp
== 2)
11020 DECL_NONCONVERTING_P (decl
) = 1;
11021 else if (DECL_CONSTRUCTOR_P (decl
))
11023 /* The constructor can be called with exactly one
11024 parameter if there is at least one parameter, and
11025 any subsequent parameters have default arguments.
11026 We don't look at the first parameter, which is
11027 really just the `this' parameter for the new
11030 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
11032 /* Skip the `in_chrg' argument too, if present. */
11033 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl
)))
11034 arg_types
= TREE_CHAIN (arg_types
);
11036 if (arg_types
== void_list_node
11038 && TREE_CHAIN (arg_types
)
11039 && TREE_CHAIN (arg_types
) != void_list_node
11040 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
11041 DECL_NONCONVERTING_P (decl
) = 1;
11044 else if (TREE_CODE (type
) == METHOD_TYPE
)
11046 /* We only get here for friend declarations of
11047 members of other classes. */
11048 /* All method decls are public, so tell grokfndecl to set
11049 TREE_PUBLIC, also. */
11050 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
11051 virtualp
, flags
, quals
, raises
,
11052 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
11053 template_count
, in_namespace
);
11054 if (decl
== NULL_TREE
)
11057 else if (!staticp
&& ! processing_template_decl
11058 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
11059 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
11062 cp_error ("field `%D' has incomplete type", declarator
);
11064 cp_error ("name `%T' has incomplete type", type
);
11066 /* If we're instantiating a template, tell them which
11067 instantiation made the field's type be incomplete. */
11068 if (current_class_type
11069 && TYPE_NAME (current_class_type
)
11070 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
11071 && declspecs
&& TREE_VALUE (declspecs
)
11072 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
11073 cp_error (" in instantiation of template `%T'",
11074 current_class_type
);
11076 type
= error_mark_node
;
11083 error ("`%s' is neither function nor method; cannot be declared friend",
11084 IDENTIFIER_POINTER (declarator
));
11092 /* Friends are treated specially. */
11093 if (ctype
== current_class_type
)
11094 warning ("member functions are implicitly friends of their class");
11097 tree t
= NULL_TREE
;
11098 if (decl
&& DECL_NAME (decl
))
11100 if (template_class_depth (current_class_type
) == 0)
11103 = check_explicit_specialization
11105 template_count
, 2 * (funcdef_flag
!= 0) + 4);
11106 if (decl
== error_mark_node
)
11107 return error_mark_node
;
11110 t
= do_friend (ctype
, declarator
, decl
,
11111 last_function_parms
, attrlist
, flags
, quals
,
11114 if (t
&& funcdef_flag
)
11117 return void_type_node
;
11121 /* Structure field. It may not be a function, except for C++ */
11123 if (decl
== NULL_TREE
)
11129 /* An attempt is being made to initialize a non-static
11130 member. But, from [class.mem]:
11132 4 A member-declarator can contain a
11133 constant-initializer only if it declares a static
11134 member (_class.static_) of integral or enumeration
11135 type, see _class.static.data_.
11137 This used to be relatively common practice, but
11138 the rest of the compiler does not correctly
11139 handle the initialization unless the member is
11140 static so we make it static below. */
11141 cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
11143 cp_pedwarn ("making `%D' static", declarator
);
11147 if (uses_template_parms (type
))
11148 /* We'll check at instantiation time. */
11150 else if (check_static_variable_definition (declarator
,
11152 /* If we just return the declaration, crashes
11153 will sometimes occur. We therefore return
11154 void_type_node, as if this was a friend
11155 declaration, to cause callers to completely
11156 ignore this declaration. */
11157 return void_type_node
;
11160 /* 9.2p13 [class.mem] */
11161 if (declarator
== constructor_name (current_class_type
)
11162 /* Divergence from the standard: In extern "C", we
11163 allow non-static data members here, because C does
11164 and /usr/include/netinet/in.h uses that. */
11165 && (staticp
|| ! in_system_header
))
11166 cp_pedwarn ("ANSI C++ forbids data member `%D' with same name as enclosing class",
11171 /* C++ allows static class members.
11172 All other work for this is done by grokfield.
11173 This VAR_DCL is built by build_lang_field_decl.
11174 All other VAR_DECLs are built by build_decl. */
11175 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
11176 TREE_STATIC (decl
) = 1;
11177 /* In class context, 'static' means public access. */
11178 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
11182 decl
= build_lang_field_decl (FIELD_DECL
, declarator
, type
);
11183 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11185 DECL_MUTABLE_P (decl
) = 1;
11186 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11190 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
11191 inlinep
, friendp
, raises
!= NULL_TREE
);
11194 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11196 tree original_name
;
11202 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
11203 original_name
= dname
;
11205 original_name
= declarator
;
11207 if (RIDBIT_SETP (RID_AUTO
, specbits
))
11208 error ("storage class `auto' invalid for function `%s'", name
);
11209 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11210 error ("storage class `register' invalid for function `%s'", name
);
11212 /* Function declaration not at top level.
11213 Storage classes other than `extern' are not allowed
11214 and `extern' makes no difference. */
11215 if (! toplevel_bindings_p ()
11216 && (RIDBIT_SETP (RID_STATIC
, specbits
)
11217 || RIDBIT_SETP (RID_INLINE
, specbits
))
11220 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11221 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
11223 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
11226 if (ctype
== NULL_TREE
)
11230 error ("virtual non-class function `%s'", name
);
11234 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
11235 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11236 TYPE_ARG_TYPES (type
));
11238 /* Record presence of `static'. */
11239 publicp
= (ctype
!= NULL_TREE
11240 || RIDBIT_SETP (RID_EXTERN
, specbits
)
11241 || !RIDBIT_SETP (RID_STATIC
, specbits
));
11243 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
11244 virtualp
, flags
, quals
, raises
,
11246 publicp
, inlinep
, funcdef_flag
,
11247 template_count
, in_namespace
);
11248 if (decl
== NULL_TREE
)
11253 int illegal_static
= 0;
11255 /* Don't allow a static member function in a class, and forbid
11256 declaring main to be static. */
11257 if (TREE_CODE (type
) == METHOD_TYPE
)
11259 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
11260 illegal_static
= 1;
11262 else if (current_function_decl
)
11264 /* FIXME need arm citation */
11265 error ("cannot declare static function inside another function");
11266 illegal_static
= 1;
11269 if (illegal_static
)
11272 RIDBIT_RESET (RID_STATIC
, specbits
);
11278 /* It's a variable. */
11280 /* An uninitialized decl with `extern' is a reference. */
11281 decl
= grokvardecl (type
, declarator
, &specbits
,
11283 (type_quals
& TYPE_QUAL_CONST
) != 0,
11285 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
11286 inlinep
, friendp
, raises
!= NULL_TREE
);
11290 DECL_CONTEXT (decl
) = ctype
;
11293 cp_pedwarn ("static member `%D' re-declared as static", decl
);
11295 RIDBIT_RESET (RID_STATIC
, specbits
);
11297 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
11299 cp_error ("static member `%D' declared `register'", decl
);
11300 RIDBIT_RESET (RID_REGISTER
, specbits
);
11302 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
11304 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11306 RIDBIT_RESET (RID_EXTERN
, specbits
);
11311 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11313 error ("`%s' cannot be declared mutable", name
);
11316 /* Record `register' declaration for warnings on &
11317 and in case doing stupid register allocation. */
11319 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11320 DECL_REGISTER (decl
) = 1;
11322 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
11323 DECL_THIS_EXTERN (decl
) = 1;
11325 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11326 DECL_THIS_STATIC (decl
) = 1;
11328 /* Record constancy and volatility. There's no need to do this
11329 when processing a template; we'll do this for the instantiated
11330 declaration based on the type of DECL. */
11331 if (!processing_template_decl
)
11332 c_apply_type_quals_to_decl (type_quals
, decl
);
11338 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11339 An empty exprlist is a parmlist. An exprlist which
11340 contains only identifiers at the global level
11341 is a parmlist. Otherwise, it is an exprlist. */
11344 parmlist_is_exprlist (exprs
)
11347 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
11350 if (toplevel_bindings_p ())
11352 /* At the global level, if these are all identifiers,
11353 then it is a parmlist. */
11356 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
11358 exprs
= TREE_CHAIN (exprs
);
11365 /* Subroutine of start_function. Ensure that each of the parameter
11366 types (as listed in PARMS) is complete, as is required for a
11367 function definition. */
11370 require_complete_types_for_parms (parms
)
11375 tree type
= TREE_TYPE (parms
);
11376 if (TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
11378 if (DECL_NAME (parms
))
11379 error ("parameter `%s' has incomplete type",
11380 IDENTIFIER_POINTER (DECL_NAME (parms
)));
11382 error ("parameter has incomplete type");
11383 TREE_TYPE (parms
) = error_mark_node
;
11386 layout_decl (parms
, 0);
11388 parms
= TREE_CHAIN (parms
);
11392 /* Returns DECL if DECL is a local variable (or parameter). Returns
11393 NULL_TREE otherwise. */
11396 local_variable_p (t
)
11399 if ((TREE_CODE (t
) == VAR_DECL
11400 /* A VAR_DECL with a context that is a _TYPE is a static data
11402 && !TYPE_P (CP_DECL_CONTEXT (t
))
11403 /* Any other non-local variable must be at namespace scope. */
11404 && TREE_CODE (CP_DECL_CONTEXT (t
)) != NAMESPACE_DECL
)
11405 || (TREE_CODE (t
) == PARM_DECL
))
11411 /* Check that ARG, which is a default-argument expression for a
11412 parameter DECL, is legal. Returns ARG, or ERROR_MARK_NODE, if
11413 something goes wrong. DECL may also be a _TYPE node, rather than a
11414 DECL, if there is no DECL available. */
11417 check_default_argument (decl
, arg
)
11424 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11425 /* We get a DEFAULT_ARG when looking at an in-class declaration
11426 with a default argument. Ignore the argument for now; we'll
11427 deal with it after the class is complete. */
11430 if (processing_template_decl
|| uses_template_parms (arg
))
11431 /* We don't do anything checking until instantiation-time. Note
11432 that there may be uninstantiated arguments even for an
11433 instantiated function, since default arguments are not
11434 instantiated until they are needed. */
11443 decl_type
= TREE_TYPE (decl
);
11445 if (arg
== error_mark_node
11446 || decl
== error_mark_node
11447 || TREE_TYPE (arg
) == error_mark_node
11448 || decl_type
== error_mark_node
)
11449 /* Something already went wrong. There's no need to check
11451 return error_mark_node
;
11453 /* [dcl.fct.default]
11455 A default argument expression is implicitly converted to the
11457 if (!TREE_TYPE (arg
)
11458 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
))
11461 cp_error ("default argument for `%#D' has type `%T'",
11462 decl
, TREE_TYPE (arg
));
11464 cp_error ("default argument for paramter of type `%T' has type `%T'",
11465 decl_type
, TREE_TYPE (arg
));
11467 return error_mark_node
;
11470 /* [dcl.fct.default]
11472 Local variables shall not be used in default argument
11475 The keyword `this' shall not be used in a default argument of a
11476 member function. */
11477 var
= search_tree (arg
, local_variable_p
);
11480 cp_error ("default argument `%E' uses local variable `%D'",
11482 return error_mark_node
;
11489 /* Decode the list of parameter types for a function type.
11490 Given the list of things declared inside the parens,
11491 return a list of types.
11493 The list we receive can have three kinds of elements:
11494 an IDENTIFIER_NODE for names given without types,
11495 a TREE_LIST node for arguments given as typespecs or names with typespecs,
11496 or void_type_node, to mark the end of an argument list
11497 when additional arguments are not permitted (... was not used).
11499 FUNCDEF_FLAG is nonzero for a function definition, 0 for
11500 a mere declaration. A nonempty identifier-list gets an error message
11501 when FUNCDEF_FLAG is zero.
11502 If FUNCDEF_FLAG is 1, then parameter types must be complete.
11503 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11505 If all elements of the input list contain types,
11506 we return a list of the types.
11507 If all elements contain no type (except perhaps a void_type_node
11508 at the end), we return a null list.
11509 If some have types and some do not, it is an error, and we
11510 return a null list.
11512 Also set last_function_parms to either
11513 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11514 A list of names is converted to a chain of PARM_DECLs
11515 by store_parm_decls so that ultimately it is always a chain of decls.
11517 Note that in C++, parameters can take default values. These default
11518 values are in the TREE_PURPOSE field of the TREE_LIST. It is
11519 an error to specify default values which are followed by parameters
11520 that have no default values, or an ELLIPSES. For simplicities sake,
11521 only parameters which are specified with their types can take on
11525 grokparms (first_parm
, funcdef_flag
)
11529 tree result
= NULL_TREE
;
11530 tree decls
= NULL_TREE
;
11532 if (first_parm
!= NULL_TREE
11533 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
11535 if (! funcdef_flag
)
11536 pedwarn ("parameter names (without types) in function declaration");
11537 last_function_parms
= first_parm
;
11540 else if (first_parm
!= NULL_TREE
11541 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
11542 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
11543 my_friendly_abort (145);
11546 /* Types were specified. This is a list of declarators
11547 each represented as a TREE_LIST node. */
11548 register tree parm
, chain
;
11549 int any_init
= 0, any_error
= 0;
11551 if (first_parm
!= NULL_TREE
)
11553 tree last_result
= NULL_TREE
;
11554 tree last_decl
= NULL_TREE
;
11556 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
11558 tree type
= NULL_TREE
, list_node
= parm
;
11559 register tree decl
= TREE_VALUE (parm
);
11560 tree init
= TREE_PURPOSE (parm
);
11562 chain
= TREE_CHAIN (parm
);
11563 /* @@ weak defense against parse errors. */
11564 if (TREE_CODE (decl
) != VOID_TYPE
11565 && TREE_CODE (decl
) != TREE_LIST
)
11567 /* Give various messages as the need arises. */
11568 if (TREE_CODE (decl
) == STRING_CST
)
11569 cp_error ("invalid string constant `%E'", decl
);
11570 else if (TREE_CODE (decl
) == INTEGER_CST
)
11571 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11575 if (TREE_CODE (decl
) != VOID_TYPE
)
11577 decl
= grokdeclarator (TREE_VALUE (decl
),
11578 TREE_PURPOSE (decl
),
11579 PARM
, init
!= NULL_TREE
,
11581 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11584 /* Top-level qualifiers on the parameters are
11585 ignored for function types. */
11586 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
11588 if (TREE_CODE (type
) == VOID_TYPE
)
11589 decl
= void_type_node
;
11590 else if (TREE_CODE (type
) == METHOD_TYPE
)
11592 if (DECL_NAME (decl
))
11593 /* Cannot use the decl here because
11594 we don't have DECL_CONTEXT set up yet. */
11595 cp_error ("parameter `%D' invalidly declared method type",
11598 error ("parameter invalidly declared method type");
11599 type
= build_pointer_type (type
);
11600 TREE_TYPE (decl
) = type
;
11602 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11604 if (DECL_NAME (decl
))
11605 cp_error ("parameter `%D' invalidly declared offset type",
11608 error ("parameter invalidly declared offset type");
11609 type
= build_pointer_type (type
);
11610 TREE_TYPE (decl
) = type
;
11612 else if (abstract_virtuals_error (decl
, type
))
11613 any_error
= 1; /* Seems like a good idea. */
11614 else if (TREE_CODE (type
) == RECORD_TYPE
11615 && TYPE_LANG_SPECIFIC (type
)
11616 && IS_SIGNATURE (type
))
11618 signature_error (decl
, type
);
11619 any_error
= 1; /* Seems like a good idea. */
11621 else if (POINTER_TYPE_P (type
))
11624 while (POINTER_TYPE_P (t
)
11625 || (TREE_CODE (t
) == ARRAY_TYPE
11626 && TYPE_DOMAIN (t
) != NULL_TREE
))
11628 if (TREE_CODE (t
) == ARRAY_TYPE
)
11629 cp_error ("parameter type `%T' includes %s to array of unknown bound",
11631 TYPE_PTR_P (type
) ? "pointer" : "reference");
11635 if (TREE_CODE (decl
) == VOID_TYPE
)
11637 if (result
== NULL_TREE
)
11639 result
= void_list_node
;
11640 last_result
= result
;
11644 TREE_CHAIN (last_result
) = void_list_node
;
11645 last_result
= void_list_node
;
11648 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
11649 error ("`void' in parameter list must be entire list");
11653 /* Since there is a prototype, args are passed in their own types. */
11654 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
11655 #ifdef PROMOTE_PROTOTYPES
11656 if ((TREE_CODE (type
) == INTEGER_TYPE
11657 || TREE_CODE (type
) == ENUMERAL_TYPE
)
11658 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
11659 DECL_ARG_TYPE (decl
) = integer_type_node
;
11661 if (!any_error
&& init
)
11664 init
= check_default_argument (decl
, init
);
11669 if (decls
== NULL_TREE
)
11676 TREE_CHAIN (last_decl
) = decl
;
11679 if (! current_function_decl
&& TREE_PERMANENT (list_node
))
11681 TREE_PURPOSE (list_node
) = init
;
11682 TREE_VALUE (list_node
) = type
;
11683 TREE_CHAIN (list_node
) = NULL_TREE
;
11686 list_node
= saveable_tree_cons (init
, type
, NULL_TREE
);
11687 if (result
== NULL_TREE
)
11689 result
= list_node
;
11690 last_result
= result
;
11694 TREE_CHAIN (last_result
) = list_node
;
11695 last_result
= list_node
;
11699 TREE_CHAIN (last_result
) = NULL_TREE
;
11700 /* If there are no parameters, and the function does not end
11701 with `...', then last_decl will be NULL_TREE. */
11702 if (last_decl
!= NULL_TREE
)
11703 TREE_CHAIN (last_decl
) = NULL_TREE
;
11707 last_function_parms
= decls
;
11712 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11713 FUNCTION_TYPE with the newly parsed version of its default argument, which
11714 was previously digested as text. See snarf_defarg et al in lex.c. */
11717 replace_defarg (arg
, init
)
11720 if (! processing_template_decl
11721 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
11722 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11723 TREE_TYPE (init
), TREE_VALUE (arg
));
11724 TREE_PURPOSE (arg
) = init
;
11731 tree t
= FUNCTION_ARG_CHAIN (d
);
11732 if (DECL_CONSTRUCTOR_P (d
)
11733 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d
)))
11734 t
= TREE_CHAIN (t
);
11735 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
11736 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
11737 == DECL_CLASS_CONTEXT (d
))
11738 && (TREE_CHAIN (t
) == NULL_TREE
11739 || TREE_CHAIN (t
) == void_list_node
11740 || TREE_PURPOSE (TREE_CHAIN (t
))))
11745 /* These memoizing functions keep track of special properties which
11746 a class may have. `grok_ctor_properties' notices whether a class
11747 has a constructor of the form X(X&), and also complains
11748 if the class has a constructor of the form X(X).
11749 `grok_op_properties' takes notice of the various forms of
11750 operator= which are defined, as well as what sorts of type conversion
11751 may apply. Both functions take a FUNCTION_DECL as an argument. */
11754 grok_ctor_properties (ctype
, decl
)
11757 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
11758 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
11760 /* When a type has virtual baseclasses, a magical first int argument is
11761 added to any ctor so we can tell if the class has been initialized
11762 yet. This could screw things up in this function, so we deliberately
11763 ignore the leading int if we're in that situation. */
11764 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
11766 my_friendly_assert (parmtypes
11767 && TREE_VALUE (parmtypes
) == integer_type_node
,
11769 parmtypes
= TREE_CHAIN (parmtypes
);
11770 parmtype
= TREE_VALUE (parmtypes
);
11775 A non-template constructor for class X is a copy constructor if
11776 its first parameter is of type X&, const X&, volatile X& or const
11777 volatile X&, and either there are no other parameters or else all
11778 other parameters have default arguments. */
11779 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
11780 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
11781 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11782 || TREE_CHAIN (parmtypes
) == void_list_node
11783 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
11784 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11785 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11787 TYPE_HAS_INIT_REF (ctype
) = 1;
11788 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11789 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
11793 A declaration of a constructor for a class X is ill-formed if its
11794 first parameter is of type (optionally cv-qualified) X and either
11795 there are no other parameters or else all other parameters have
11798 We *don't* complain about member template instantiations that
11799 have this form, though; they can occur as we try to decide what
11800 constructor to use during overload resolution. Since overload
11801 resolution will never prefer such a constructor to the
11802 non-template copy constructor (which is either explicitly or
11803 implicitly defined), there's no need to worry about their
11804 existence. Theoretically, they should never even be
11805 instantiated, but that's hard to forestall. */
11806 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
11807 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11808 || TREE_CHAIN (parmtypes
) == void_list_node
11809 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
11810 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11811 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11813 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11815 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
11818 else if (TREE_CODE (parmtype
) == VOID_TYPE
11819 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
11820 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
11825 /* An operator with this name can be either unary or binary. */
11831 return (name
== ansi_opname
[(int) INDIRECT_REF
]
11832 || name
== ansi_opname
[(int) ADDR_EXPR
]
11833 || name
== ansi_opname
[(int) NEGATE_EXPR
]
11834 || name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11835 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]
11836 || name
== ansi_opname
[(int) CONVERT_EXPR
]);
11839 /* An operator with this name can only be unary. */
11845 return (name
== ansi_opname
[(int) TRUTH_NOT_EXPR
]
11846 || name
== ansi_opname
[(int) BIT_NOT_EXPR
]
11847 || name
== ansi_opname
[(int) COMPONENT_REF
]
11848 || IDENTIFIER_TYPENAME_P (name
));
11851 /* Do a little sanity-checking on how they declared their operator. */
11854 grok_op_properties (decl
, virtualp
, friendp
)
11856 int virtualp
, friendp
;
11858 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11859 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11860 tree name
= DECL_NAME (decl
);
11862 if (current_class_type
== NULL_TREE
)
11869 A user-declared copy assignment operator X::operator= is a
11870 non-static non-template member function of class X with
11871 exactly one parameter of type X, X&, const X&, volatile X& or
11872 const volatile X&. */
11873 if (name
== ansi_opname
[(int) MODIFY_EXPR
]
11874 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11875 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11877 else if (name
== ansi_opname
[(int) CALL_EXPR
])
11878 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
11879 else if (name
== ansi_opname
[(int) ARRAY_REF
])
11880 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
11881 else if (name
== ansi_opname
[(int) COMPONENT_REF
]
11882 || name
== ansi_opname
[(int) MEMBER_REF
])
11883 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
11884 else if (name
== ansi_opname
[(int) NEW_EXPR
])
11885 TYPE_GETS_NEW (current_class_type
) |= 1;
11886 else if (name
== ansi_opname
[(int) DELETE_EXPR
])
11887 TYPE_GETS_DELETE (current_class_type
) |= 1;
11888 else if (name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11889 TYPE_GETS_NEW (current_class_type
) |= 2;
11890 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11891 TYPE_GETS_DELETE (current_class_type
) |= 2;
11894 if (name
== ansi_opname
[(int) NEW_EXPR
]
11895 || name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11897 /* When the compiler encounters the definition of A::operator new, it
11898 doesn't look at the class declaration to find out if it's static. */
11900 revert_static_member_fn (&decl
, NULL
, NULL
);
11902 /* Take care of function decl if we had syntax errors. */
11903 if (argtypes
== NULL_TREE
)
11905 = build_function_type (ptr_type_node
,
11906 hash_tree_chain (integer_type_node
,
11909 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11911 else if (name
== ansi_opname
[(int) DELETE_EXPR
]
11912 || name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11915 revert_static_member_fn (&decl
, NULL
, NULL
);
11917 if (argtypes
== NULL_TREE
)
11919 = build_function_type (void_type_node
,
11920 hash_tree_chain (ptr_type_node
,
11924 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11926 if (! friendp
&& name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
11927 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
11928 != void_list_node
))
11929 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type
) = 1;
11934 /* An operator function must either be a non-static member function
11935 or have at least one parameter of a class, a reference to a class,
11936 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11937 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11939 if (IDENTIFIER_TYPENAME_P (name
)
11940 || name
== ansi_opname
[(int) CALL_EXPR
]
11941 || name
== ansi_opname
[(int) MODIFY_EXPR
]
11942 || name
== ansi_opname
[(int) COMPONENT_REF
]
11943 || name
== ansi_opname
[(int) ARRAY_REF
])
11944 cp_error ("`%D' must be a nonstatic member function", decl
);
11949 if (DECL_STATIC_FUNCTION_P (decl
))
11950 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
11953 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
11955 tree arg
= TREE_VALUE (p
);
11956 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
11957 arg
= TREE_TYPE (arg
);
11959 /* This lets bad template code slip through. */
11960 if (IS_AGGR_TYPE (arg
)
11961 || TREE_CODE (arg
) == ENUMERAL_TYPE
11962 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
11963 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11967 ("`%D' must have an argument of class or enumerated type",
11974 if (name
== ansi_opname
[(int) CALL_EXPR
])
11975 return; /* No restrictions on args. */
11977 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
11979 tree t
= TREE_TYPE (name
);
11980 if (TREE_CODE (t
) == VOID_TYPE
)
11981 pedwarn ("void is not a valid type conversion operator");
11982 else if (! friendp
)
11984 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11985 const char *what
= 0;
11987 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11989 if (t
== current_class_type
)
11990 what
= "the same type";
11991 /* Don't force t to be complete here. */
11992 else if (IS_AGGR_TYPE (t
)
11994 && DERIVED_FROM_P (t
, current_class_type
))
11995 what
= "a base class";
11998 warning ("conversion to %s%s will never use a type conversion operator",
11999 ref
? "a reference to " : "", what
);
12003 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
12007 if (list_length (argtypes
) != 3 && methodp
)
12009 cp_error ("`%D' must take exactly one argument", decl
);
12012 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
12014 if (copy_assignment_arg_p (parmtype
, virtualp
)
12017 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
12018 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
12019 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
12020 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
12023 else if (name
== ansi_opname
[(int) COND_EXPR
])
12026 cp_error ("ANSI C++ prohibits overloading operator ?:");
12028 else if (ambi_op_p (name
))
12030 if (list_length (argtypes
) == 2)
12032 else if (list_length (argtypes
) == 3)
12034 if ((name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
12035 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
12036 && ! processing_template_decl
12037 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12040 cp_error ("postfix `%D' must take `int' as its argument",
12044 ("postfix `%D' must take `int' as its second argument",
12051 cp_error ("`%D' must take either zero or one argument", decl
);
12053 cp_error ("`%D' must take either one or two arguments", decl
);
12056 /* More Effective C++ rule 6. */
12058 && (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
12059 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]))
12061 tree arg
= TREE_VALUE (argtypes
);
12062 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12063 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12064 arg
= TREE_TYPE (arg
);
12065 arg
= TYPE_MAIN_VARIANT (arg
);
12066 if (list_length (argtypes
) == 2)
12068 if (TREE_CODE (ret
) != REFERENCE_TYPE
12069 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12071 cp_warning ("prefix `%D' should return `%T'", decl
,
12072 build_reference_type (arg
));
12076 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12077 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
12081 else if (unary_op_p (name
))
12083 if (list_length (argtypes
) != 2)
12086 cp_error ("`%D' must take `void'", decl
);
12088 cp_error ("`%D' must take exactly one argument", decl
);
12091 else /* if (binary_op_p (name)) */
12093 if (list_length (argtypes
) != 3)
12096 cp_error ("`%D' must take exactly one argument", decl
);
12098 cp_error ("`%D' must take exactly two arguments", decl
);
12101 /* More Effective C++ rule 7. */
12103 && (name
== ansi_opname
[TRUTH_ANDIF_EXPR
]
12104 || name
== ansi_opname
[TRUTH_ORIF_EXPR
]
12105 || name
== ansi_opname
[COMPOUND_EXPR
]))
12106 cp_warning ("user-defined `%D' always evaluates both arguments",
12110 /* Effective C++ rule 23. */
12112 && list_length (argtypes
) == 3
12113 && (name
== ansi_opname
[PLUS_EXPR
]
12114 || name
== ansi_opname
[MINUS_EXPR
]
12115 || name
== ansi_opname
[TRUNC_DIV_EXPR
]
12116 || name
== ansi_opname
[MULT_EXPR
])
12117 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12118 cp_warning ("`%D' should return by value", decl
);
12122 for (; argtypes
!= void_list_node
; argtypes
= TREE_CHAIN (argtypes
))
12123 if (TREE_PURPOSE (argtypes
))
12125 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12126 if (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
12127 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
12130 cp_pedwarn ("`%D' cannot have default arguments", decl
);
12133 cp_error ("`%D' cannot have default arguments", decl
);
12138 static const char *
12140 enum tag_types code
;
12152 case signature_type
:
12153 return "signature";
12155 my_friendly_abort (981122);
12159 /* Get the struct, enum or union (CODE says which) with tag NAME.
12160 Define the tag as a forward-reference if it is not defined.
12162 C++: If a class derivation is given, process it here, and report
12163 an error if multiple derivation declarations are not identical.
12165 If this is a definition, come in through xref_tag and only look in
12166 the current frame for the name (since C++ allows new names in any
12170 xref_tag (code_type_node
, name
, globalize
)
12171 tree code_type_node
;
12175 enum tag_types tag_code
;
12176 enum tree_code code
;
12178 register tree ref
, t
;
12179 struct binding_level
*b
= current_binding_level
;
12181 tree attributes
= NULL_TREE
;
12182 tree context
= NULL_TREE
;
12184 /* If we are called from the parser, code_type_node will sometimes be a
12185 TREE_LIST. This indicates that the user wrote
12186 "class __attribute__ ((foo)) bar". Extract the attributes so we can
12188 if (TREE_CODE (code_type_node
) == TREE_LIST
)
12190 attributes
= TREE_PURPOSE (code_type_node
);
12191 code_type_node
= TREE_VALUE (code_type_node
);
12194 tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
12199 case signature_type
:
12200 code
= RECORD_TYPE
;
12206 code
= ENUMERAL_TYPE
;
12209 my_friendly_abort (18);
12212 /* If a cross reference is requested, look up the type
12213 already defined for this tag and return it. */
12214 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
12217 name
= TYPE_IDENTIFIER (t
);
12221 t
= IDENTIFIER_TYPE_VALUE (name
);
12223 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
12224 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
)
12229 /* If we know we are defining this tag, only look it up in
12230 this scope and don't try to find it as a type. */
12231 ref
= lookup_tag (code
, name
, b
, 1);
12237 /* [dcl.type.elab] If the identifier resolves to a
12238 typedef-name or a template type-parameter, the
12239 elaborated-type-specifier is ill-formed. */
12240 if (t
!= TYPE_MAIN_VARIANT (t
)
12241 || (CLASS_TYPE_P (t
) && TYPE_WAS_ANONYMOUS (t
)))
12242 cp_pedwarn ("using typedef-name `%D' after `%s'",
12243 TYPE_NAME (t
), tag_name (tag_code
));
12244 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
12245 cp_error ("using template type parameter `%T' after `%s'",
12246 t
, tag_name (tag_code
));
12251 ref
= lookup_tag (code
, name
, b
, 0);
12255 /* Try finding it as a type declaration. If that wins,
12257 ref
= lookup_name (name
, 1);
12259 if (ref
!= NULL_TREE
12260 && processing_template_decl
12261 && DECL_CLASS_TEMPLATE_P (ref
)
12262 && template_class_depth (current_class_type
) == 0)
12263 /* Since GLOBALIZE is true, we're declaring a global
12264 template, so we want this type. */
12265 ref
= DECL_RESULT (ref
);
12267 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
12268 && TREE_CODE (TREE_TYPE (ref
)) == code
)
12269 ref
= TREE_TYPE (ref
);
12274 if (ref
&& current_class_type
12275 && template_class_depth (current_class_type
)
12276 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12278 /* Since GLOBALIZE is non-zero, we are not looking at a
12279 definition of this tag. Since, in addition, we are currently
12280 processing a (member) template declaration of a template
12281 class, we must be very careful; consider:
12288 { template <class V>
12289 friend struct S1; };
12291 Here, the S2::S1 declaration should not be confused with the
12292 outer declaration. In particular, the inner version should
12293 have a template parameter of level 2, not level 1. This
12294 would be particularly important if the member declaration
12297 template <class V = U> friend struct S1;
12299 say, when we should tsubst into `U' when instantiating
12300 S2. On the other hand, when presented with:
12310 we must find the inner binding eventually. We
12311 accomplish this by making sure that the new type we
12312 create to represent this declaration has the right
12314 context
= TYPE_CONTEXT (ref
);
12319 push_obstacks_nochange ();
12323 /* If no such tag is yet defined, create a forward-reference node
12324 and record it as the "definition".
12325 When a real declaration of this type is found,
12326 the forward-reference will be altered into a real type. */
12328 /* In C++, since these migrate into the global scope, we must
12329 build them on the permanent obstack. */
12331 temp
= allocation_temporary_p ();
12333 end_temporary_allocation ();
12335 if (code
== ENUMERAL_TYPE
)
12337 cp_error ("use of enum `%#D' without previous declaration", name
);
12339 ref
= make_node (ENUMERAL_TYPE
);
12341 /* Give the type a default layout like unsigned int
12342 to avoid crashing if it does not get defined. */
12343 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
12344 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
12345 TREE_UNSIGNED (ref
) = 1;
12346 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
12347 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
12348 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
12350 /* Enable us to recognize when a type is created in class context.
12351 To do nested classes correctly, this should probably be cleared
12352 out when we leave this classes scope. Currently this in only
12353 done in `start_enum'. */
12355 pushtag (name
, ref
, globalize
);
12359 struct binding_level
*old_b
= class_binding_level
;
12361 ref
= make_lang_type (code
);
12362 TYPE_CONTEXT (ref
) = context
;
12364 if (tag_code
== signature_type
)
12366 SET_SIGNATURE (ref
);
12367 /* Since a signature type will be turned into the type
12368 of signature tables, it's not only an interface. */
12369 CLASSTYPE_INTERFACE_ONLY (ref
) = 0;
12370 SET_CLASSTYPE_INTERFACE_KNOWN (ref
);
12371 /* A signature doesn't have a vtable. */
12372 CLASSTYPE_VTABLE_NEEDS_WRITING (ref
) = 0;
12375 #ifdef NONNESTED_CLASSES
12376 /* Class types don't nest the way enums do. */
12377 class_binding_level
= (struct binding_level
*)0;
12379 pushtag (name
, ref
, globalize
);
12380 class_binding_level
= old_b
;
12385 /* If it no longer looks like a nested type, make sure it's
12387 If it is not an IDENTIFIER, this is not a declaration */
12388 if (b
->namespace_p
&& !class_binding_level
12389 && TREE_CODE (name
) == IDENTIFIER_NODE
)
12391 if (IDENTIFIER_NAMESPACE_VALUE (name
) == NULL_TREE
)
12392 SET_IDENTIFIER_NAMESPACE_VALUE (name
, TYPE_NAME (ref
));
12395 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
12396 redeclare_class_template (ref
, current_template_parms
);
12399 /* Until the type is defined, tentatively accept whatever
12400 structure tag the user hands us. */
12401 if (TYPE_SIZE (ref
) == NULL_TREE
12402 && ref
!= current_class_type
12403 /* Have to check this, in case we have contradictory tag info. */
12404 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
12406 if (tag_code
== class_type
)
12407 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
12408 else if (tag_code
== record_type
|| tag_code
== signature_type
)
12409 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
12414 TREE_TYPE (ref
) = attributes
;
12420 xref_tag_from_type (old
, id
, globalize
)
12424 tree code_type_node
;
12426 if (TREE_CODE (old
) == RECORD_TYPE
)
12427 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
12428 ? class_type_node
: record_type_node
);
12430 code_type_node
= union_type_node
;
12432 if (id
== NULL_TREE
)
12433 id
= TYPE_IDENTIFIER (old
);
12435 return xref_tag (code_type_node
, id
, globalize
);
12438 /* REF is a type (named NAME), for which we have just seen some
12439 baseclasses. BINFO is a list of those baseclasses; the
12440 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12441 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12442 struct, or union. */
12445 xref_basetypes (code_type_node
, name
, ref
, binfo
)
12446 tree code_type_node
;
12450 /* In the declaration `A : X, Y, ... Z' we mark all the types
12451 (A, X, Y, ..., Z) so we can check for duplicates. */
12456 enum tag_types tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
12458 if (tag_code
== union_type
)
12460 cp_error ("derived union `%T' invalid", ref
);
12464 len
= list_length (binfo
);
12465 push_obstacks (TYPE_OBSTACK (ref
), TYPE_OBSTACK (ref
));
12467 /* First, make sure that any templates in base-classes are
12468 instantiated. This ensures that if we call ourselves recursively
12469 we do not get confused about which classes are marked and which
12471 for (base
= binfo
; base
; base
= TREE_CHAIN (base
))
12472 complete_type (TREE_VALUE (base
));
12474 SET_CLASSTYPE_MARKED (ref
);
12475 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
12477 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
12479 /* The base of a derived struct is public by default. */
12481 = (TREE_PURPOSE (binfo
) == access_public_node
12482 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12483 || (tag_code
!= class_type
12484 && (TREE_PURPOSE (binfo
) == access_default_node
12485 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
12487 = (TREE_PURPOSE (binfo
) == access_protected_node
12488 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
12490 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
12491 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
12492 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12493 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
12494 tree basetype
= TREE_VALUE (binfo
);
12497 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
12498 basetype
= TREE_TYPE (basetype
);
12500 || (TREE_CODE (basetype
) != RECORD_TYPE
12501 && TREE_CODE (basetype
) != TYPENAME_TYPE
12502 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
12503 && TREE_CODE (basetype
) != TEMPLATE_TEMPLATE_PARM
))
12505 cp_error ("base type `%T' fails to be a struct or class type",
12506 TREE_VALUE (binfo
));
12510 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
12512 /* This code replaces similar code in layout_basetypes.
12513 We put the complete_type first for implicit `typename'. */
12514 if (TYPE_SIZE (basetype
) == NULL_TREE
12515 && ! (current_template_parms
&& uses_template_parms (basetype
)))
12517 cp_error ("base class `%T' has incomplete type", basetype
);
12522 if (CLASSTYPE_MARKED (basetype
))
12524 if (basetype
== ref
)
12525 cp_error ("recursive type `%T' undefined", basetype
);
12527 cp_error ("duplicate base type `%T' invalid", basetype
);
12531 if (TYPE_FOR_JAVA (basetype
)
12532 && current_lang_stack
== current_lang_base
)
12533 TYPE_FOR_JAVA (ref
) = 1;
12535 /* Note that the BINFO records which describe individual
12536 inheritances are *not* shared in the lattice! They
12537 cannot be shared because a given baseclass may be
12538 inherited with different `accessibility' by different
12539 derived classes. (Each BINFO record describing an
12540 individual inheritance contains flags which say what
12541 the `accessibility' of that particular inheritance is.) */
12544 = make_binfo (integer_zero_node
, basetype
,
12545 CLASS_TYPE_P (basetype
)
12546 ? TYPE_BINFO_VTABLE (basetype
) : NULL_TREE
,
12547 CLASS_TYPE_P (basetype
)
12548 ? TYPE_BINFO_VIRTUALS (basetype
) : NULL_TREE
);
12550 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
12551 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
12552 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
12553 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
12554 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
12556 /* We need to unshare the binfos now so that lookups during class
12557 definition work. */
12558 unshare_base_binfos (base_binfo
);
12560 SET_CLASSTYPE_MARKED (basetype
);
12562 /* We are free to modify these bits because they are meaningless
12563 at top level, and BASETYPE is a top-level type. */
12564 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
12566 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
12567 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12570 if (CLASS_TYPE_P (basetype
))
12572 TYPE_GETS_NEW (ref
) |= TYPE_GETS_NEW (basetype
);
12573 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12580 TREE_VEC_LENGTH (binfos
) = i
;
12582 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
12585 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
12588 tree basetype
= BINFO_TYPE (TREE_VEC_ELT (binfos
, 0));
12590 if (CLASS_TYPE_P (basetype
))
12591 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
12592 = TYPE_USES_MULTIPLE_INHERITANCE (basetype
);
12595 if (TYPE_USES_MULTIPLE_INHERITANCE (ref
))
12596 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12598 /* Unmark all the types. */
12600 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
12601 CLEAR_CLASSTYPE_MARKED (ref
);
12603 /* Now that we know all the base-classes, set up the list of virtual
12605 CLASSTYPE_VBASECLASSES (ref
) = get_vbase_types (ref
);
12611 /* Begin compiling the definition of an enumeration type.
12612 NAME is its name (or null if anonymous).
12613 Returns the type object, as yet incomplete.
12614 Also records info about it so that build_enumerator
12615 may be used to declare the individual values as they are read. */
12621 register tree enumtype
= NULL_TREE
;
12622 struct binding_level
*b
= current_binding_level
;
12624 /* We are wasting space here and putting these on the permanent_obstack so
12625 that typeid(local enum) will work correctly. */
12626 push_obstacks (&permanent_obstack
, &permanent_obstack
);
12628 /* If this is the real definition for a previous forward reference,
12629 fill in the contents in the same object that used to be the
12630 forward reference. */
12632 if (name
!= NULL_TREE
)
12633 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
12635 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12636 cp_error ("multiple definition of `%#T'", enumtype
);
12639 enumtype
= make_node (ENUMERAL_TYPE
);
12640 pushtag (name
, enumtype
, 0);
12643 if (current_class_type
)
12644 TREE_ADDRESSABLE (b
->tags
) = 1;
12646 /* We don't copy this value because build_enumerator needs to do it. */
12647 enum_next_value
= integer_zero_node
;
12650 GNU_xref_decl (current_function_decl
, enumtype
);
12654 /* After processing and defining all the values of an enumeration type,
12655 install their decls in the enumeration type and finish it off.
12656 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12657 Returns ENUMTYPE. */
12660 finish_enum (enumtype
)
12663 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
12664 /* Calculate the maximum value of any enumerator in this type. */
12666 tree values
= TYPE_VALUES (enumtype
);
12671 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
12676 /* The TREE_VALUE is a CONST_DECL for this enumeration
12678 decl
= TREE_VALUE (pair
);
12680 /* The DECL_INITIAL will be NULL if we are processing a
12681 template declaration and this enumeration constant had no
12682 explicit initializer. */
12683 value
= DECL_INITIAL (decl
);
12684 if (value
&& !processing_template_decl
)
12686 /* Set the TREE_TYPE for the VALUE as well. That's so
12687 that when we call decl_constant_value we get an
12688 entity of the right type (but with the constant
12689 value). Since we shouldn't ever call
12690 decl_constant_value on a template type, there's no
12691 reason to do that when processing_template_decl.
12692 And, if the expression is something like a
12693 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12694 wreak havoc on the intended type of the expression.
12696 Of course, there's also no point in trying to compute
12697 minimum or maximum values if we're in a template. */
12698 TREE_TYPE (value
) = enumtype
;
12701 minnode
= maxnode
= value
;
12702 else if (tree_int_cst_lt (maxnode
, value
))
12704 else if (tree_int_cst_lt (value
, minnode
))
12708 if (processing_template_decl
)
12709 /* If this is just a template, leave the CONST_DECL
12710 alone. That way tsubst_copy will find CONST_DECLs for
12711 CONST_DECLs, and not INTEGER_CSTs. */
12714 /* In the list we're building up, we want the enumeration
12715 values, not the CONST_DECLs. */
12716 TREE_VALUE (pair
) = value
;
12720 maxnode
= minnode
= integer_zero_node
;
12722 TYPE_VALUES (enumtype
) = nreverse (values
);
12724 if (processing_template_decl
)
12726 tree scope
= current_scope ();
12727 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
12728 add_tree (build_min (TAG_DEFN
, enumtype
));
12732 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12733 int lowprec
= min_precision (minnode
, unsignedp
);
12734 int highprec
= min_precision (maxnode
, unsignedp
);
12735 int precision
= MAX (lowprec
, highprec
);
12738 TYPE_SIZE (enumtype
) = NULL_TREE
;
12740 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12742 TYPE_PRECISION (enumtype
) = precision
;
12744 fixup_unsigned_type (enumtype
);
12746 fixup_signed_type (enumtype
);
12748 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
12749 /* Use the width of the narrowest normal C type which is wide
12751 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
12754 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
12756 TYPE_SIZE (enumtype
) = 0;
12757 layout_type (enumtype
);
12759 /* Fix up all variant types of this enum type. */
12760 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
12761 tem
= TYPE_NEXT_VARIANT (tem
))
12763 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
12764 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
12765 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
12766 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
12767 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
12768 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
12769 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
12770 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
12771 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
12774 /* Finish debugging output for this type. */
12775 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12778 /* In start_enum we pushed obstacks. Here, we must pop them. */
12784 /* Build and install a CONST_DECL for an enumeration constant of the
12785 enumeration type TYPE whose NAME and VALUE (if any) are provided.
12786 Assignment of sequential values by default is handled here. */
12789 build_enumerator (name
, value
, type
)
12797 /* Remove no-op casts from the value. */
12799 STRIP_TYPE_NOPS (value
);
12801 if (! processing_template_decl
)
12803 /* Validate and default VALUE. */
12804 if (value
!= NULL_TREE
)
12806 if (TREE_READONLY_DECL_P (value
))
12807 value
= decl_constant_value (value
);
12809 if (TREE_CODE (value
) == INTEGER_CST
)
12811 value
= default_conversion (value
);
12812 constant_expression_warning (value
);
12816 cp_error ("enumerator value for `%D' not integer constant", name
);
12821 /* Default based on previous value. */
12822 if (value
== NULL_TREE
&& ! processing_template_decl
)
12824 value
= enum_next_value
;
12826 cp_error ("overflow in enumeration values at `%D'", name
);
12829 /* Remove no-op casts from the value. */
12831 STRIP_TYPE_NOPS (value
);
12833 /* To fix MAX_VAL enum consts. (bkoz) */
12834 TREE_TYPE (value
) = integer_type_node
;
12838 /* We always have to copy here; not all INTEGER_CSTs are unshared.
12839 Even in other cases, we will later (in finish_enum) be setting the
12841 if (value
!= NULL_TREE
)
12842 value
= copy_node (value
);
12844 /* C++ associates enums with global, function, or class declarations. */
12846 context
= current_scope ();
12847 if (context
&& context
== current_class_type
)
12848 /* This enum declaration is local to the class. */
12849 decl
= build_lang_field_decl (CONST_DECL
, name
, type
);
12851 /* It's a global enum, or it's local to a function. (Note local to
12852 a function could mean local to a class method. */
12853 decl
= build_decl (CONST_DECL
, name
, type
);
12855 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
12856 DECL_INITIAL (decl
) = value
;
12857 TREE_READONLY (decl
) = 1;
12859 if (context
&& context
== current_class_type
)
12860 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12861 on the TYPE_FIELDS list for `S'. (That's so that you can say
12862 things like `S::i' later.) */
12863 finish_member_declaration (decl
);
12867 GNU_xref_decl (current_function_decl
, decl
);
12870 if (! processing_template_decl
)
12872 /* Set basis for default for next value. */
12873 enum_next_value
= build_binary_op_nodefault (PLUS_EXPR
, value
,
12874 integer_one_node
, PLUS_EXPR
);
12875 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
12878 result
= saveable_tree_cons (name
, decl
, NULL_TREE
);
12883 static int function_depth
;
12885 /* Create the FUNCTION_DECL for a function definition.
12886 DECLSPECS and DECLARATOR are the parts of the declaration;
12887 they describe the function's name and the type it returns,
12888 but twisted together in a fashion that parallels the syntax of C.
12890 If PRE_PARSED_P is non-zero then DECLARATOR is really the DECL for
12891 the function we are about to process; DECLSPECS are ignored. For
12892 example, we set PRE_PARSED_P when processing the definition of
12893 inline function that was defined in-class; the definition is
12894 actually processed when the class is complete. In this case,
12895 PRE_PARSED_P is 2. We also set PRE_PARSED_P when instanting the
12896 body of a template function, and when constructing thunk functions
12897 and such; in these cases PRE_PARSED_P is 1.
12899 This function creates a binding context for the function body
12900 as well as setting up the FUNCTION_DECL in current_function_decl.
12902 Returns 1 on success. If the DECLARATOR is not suitable for a function
12903 (it defines a datum instead), we return 0, which tells
12904 yyparse to report a parse error.
12906 For C++, we must first check whether that datum makes any sense.
12907 For example, "class A local_a(1,2);" means that variable local_a
12908 is an aggregate of type A, which should have a constructor
12909 applied to it with the argument list [1, 2].
12911 @@ There is currently no way to retrieve the storage
12912 @@ allocated to FUNCTION (or all of its parms) if we return
12913 @@ something we had previously. */
12916 start_function (declspecs
, declarator
, attrs
, pre_parsed_p
)
12917 tree declspecs
, declarator
, attrs
;
12921 tree ctype
= NULL_TREE
;
12924 extern int have_extern_spec
;
12925 extern int used_extern_spec
;
12926 int doing_friend
= 0;
12928 /* Sanity check. */
12929 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
12930 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
12932 /* Assume, until we see it does. */
12933 current_function_returns_value
= 0;
12934 current_function_returns_null
= 0;
12936 shadowed_labels
= 0;
12937 current_function_assigns_this
= 0;
12938 current_function_just_assigned_this
= 0;
12939 current_function_parms_stored
= 0;
12940 original_result_rtx
= NULL_RTX
;
12941 base_init_expr
= NULL_TREE
;
12942 current_base_init_list
= NULL_TREE
;
12943 current_member_init_list
= NULL_TREE
;
12944 ctor_label
= dtor_label
= NULL_TREE
;
12945 static_labelno
= 0;
12947 clear_temp_name ();
12949 /* This should only be done once on the top most decl. */
12950 if (have_extern_spec
&& !used_extern_spec
)
12952 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
12953 used_extern_spec
= 1;
12958 decl1
= declarator
;
12961 /* What was this testing for, exactly? */
12962 if (! DECL_ARGUMENTS (decl1
)
12963 && !DECL_STATIC_FUNCTION_P (decl1
)
12964 && !DECL_ARTIFICIAL (decl1
)
12965 && DECL_CLASS_SCOPE_P (decl1
)
12966 && TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))
12967 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))))
12969 tree binding
= binding_for_name (DECL_NAME (decl1
),
12970 current_namespace
);
12971 cp_error ("redeclaration of `%#D'", decl1
);
12972 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)))
12973 cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)));
12974 else if (BINDING_VALUE (binding
))
12975 cp_error_at ("previous declaration here", BINDING_VALUE (binding
));
12979 fntype
= TREE_TYPE (decl1
);
12980 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12981 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12983 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
12984 class is in the (lexical) scope of the class in which it is
12986 if (!ctype
&& DECL_FRIEND_P (decl1
))
12988 ctype
= DECL_CLASS_CONTEXT (decl1
);
12990 /* CTYPE could be null here if we're dealing with a template;
12991 for example, `inline friend float foo()' inside a template
12992 will have no CTYPE set. */
12993 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
12999 last_function_parms
= DECL_ARGUMENTS (decl1
);
13000 last_function_parm_tags
= NULL_TREE
;
13004 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
13005 /* If the declarator is not suitable for a function definition,
13006 cause a syntax error. */
13007 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
13009 fntype
= TREE_TYPE (decl1
);
13011 restype
= TREE_TYPE (fntype
);
13012 if (CLASS_TYPE_P (restype
) && !CLASSTYPE_GOT_SEMICOLON (restype
))
13014 cp_error ("semicolon missing after declaration of `%#T'", restype
);
13015 shadow_tag (build_expr_list (NULL_TREE
, restype
));
13016 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
13017 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
13018 fntype
= build_function_type (integer_type_node
,
13019 TYPE_ARG_TYPES (fntype
));
13021 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
13023 TYPE_ARG_TYPES (fntype
));
13024 TREE_TYPE (decl1
) = fntype
;
13027 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13028 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13029 else if (DECL_MAIN_P (decl1
))
13031 /* If this doesn't return integer_type, complain. */
13032 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
13034 if (pedantic
|| warn_return_type
)
13035 pedwarn ("return type for `main' changed to `int'");
13036 TREE_TYPE (decl1
) = fntype
= default_function_type
;
13041 /* Warn if function was previously implicitly declared
13042 (but not if we warned then). */
13043 if (! warn_implicit
13044 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
13045 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
13047 announce_function (decl1
);
13049 /* Set up current_class_type, and enter the scope of the class, if
13052 push_nested_class (ctype
, 1);
13053 else if (DECL_STATIC_FUNCTION_P (decl1
))
13054 push_nested_class (DECL_CONTEXT (decl1
), 2);
13056 /* Now that we have entered the scope of the class, we must restore
13057 the bindings for any template parameters surrounding DECL1, if it
13058 is an inline member template. (Order is important; consider the
13059 case where a template parameter has the same name as a field of
13060 the class.) It is not until after this point that
13061 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13062 if (pre_parsed_p
== 2)
13063 maybe_begin_member_template_processing (decl1
);
13065 /* We are now in the scope of the function being defined. */
13066 current_function_decl
= decl1
;
13068 /* Save the parm names or decls from this function's declarator
13069 where store_parm_decls will find them. */
13070 current_function_parms
= last_function_parms
;
13071 current_function_parm_tags
= last_function_parm_tags
;
13073 if (! processing_template_decl
)
13075 /* In a function definition, arg types must be complete. */
13076 require_complete_types_for_parms (current_function_parms
);
13078 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype
))) == NULL_TREE
)
13080 cp_error ("return-type `%#T' is an incomplete type",
13081 TREE_TYPE (fntype
));
13083 /* Make it return void instead, but don't change the
13084 type of the DECL_RESULT, in case we have a named return value. */
13087 = build_cplus_method_type (build_type_variant (ctype
,
13088 TREE_READONLY (decl1
),
13089 TREE_SIDE_EFFECTS (decl1
)),
13091 FUNCTION_ARG_CHAIN (decl1
));
13094 = build_function_type (void_type_node
,
13095 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
13096 DECL_RESULT (decl1
)
13097 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype
)));
13098 TREE_READONLY (DECL_RESULT (decl1
))
13099 = CP_TYPE_CONST_P (TREE_TYPE (fntype
));
13100 TREE_THIS_VOLATILE (DECL_RESULT (decl1
))
13101 = CP_TYPE_VOLATILE_P (TREE_TYPE (fntype
));
13104 abstract_virtuals_error (decl1
, TREE_TYPE (fntype
));
13107 /* Effective C++ rule 15. See also c_expand_return. */
13109 && DECL_NAME (decl1
) == ansi_opname
[(int) MODIFY_EXPR
]
13110 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
13111 cp_warning ("`operator=' should return a reference to `*this'");
13113 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13114 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13115 DECL_INITIAL (decl1
) = error_mark_node
;
13117 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13118 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
13121 /* This function exists in static storage.
13122 (This does not mean `static' in the C sense!) */
13123 TREE_STATIC (decl1
) = 1;
13125 /* We must call push_template_decl after current_class_type is set
13126 up. (If we are processing inline definitions after exiting a
13127 class scope, current_class_type will be NULL_TREE until set above
13128 by push_nested_class.) */
13129 if (processing_template_decl
)
13130 decl1
= push_template_decl (decl1
);
13132 /* Record the decl so that the function name is defined.
13133 If we already have a decl for this name, and it is a FUNCTION_DECL,
13134 use the old decl. */
13135 if (!processing_template_decl
&& pre_parsed_p
== 0)
13137 /* A specialization is not used to guide overload resolution. */
13138 if ((flag_guiding_decls
13139 || !DECL_TEMPLATE_SPECIALIZATION (decl1
))
13140 && ! DECL_FUNCTION_MEMBER_P (decl1
))
13141 decl1
= pushdecl (decl1
);
13144 /* We need to set the DECL_CONTEXT. */
13145 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13146 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13147 /* And make sure we have enough default args. */
13148 check_default_args (decl1
);
13150 DECL_MAIN_VARIANT (decl1
) = decl1
;
13151 fntype
= TREE_TYPE (decl1
);
13154 current_function_decl
= decl1
;
13156 if (DECL_INTERFACE_KNOWN (decl1
))
13158 tree ctx
= hack_decl_function_context (decl1
);
13160 if (DECL_NOT_REALLY_EXTERN (decl1
))
13161 DECL_EXTERNAL (decl1
) = 0;
13163 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
13164 && TREE_PUBLIC (ctx
))
13165 /* This is a function in a local class in an extern inline
13167 comdat_linkage (decl1
);
13169 /* If this function belongs to an interface, it is public.
13170 If it belongs to someone else's interface, it is also external.
13171 This only affects inlines and template instantiations. */
13172 else if (interface_unknown
== 0
13173 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13174 || flag_alt_external_templates
))
13176 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
13177 || processing_template_decl
)
13179 DECL_EXTERNAL (decl1
)
13181 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
13182 && !DECL_VINDEX (decl1
)));
13184 /* For WIN32 we also want to put these in linkonce sections. */
13185 maybe_make_one_only (decl1
);
13188 DECL_EXTERNAL (decl1
) = 0;
13189 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13190 DECL_INTERFACE_KNOWN (decl1
) = 1;
13192 else if (interface_unknown
&& interface_only
13193 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13194 || flag_alt_external_templates
))
13196 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13197 interface, we will have interface_only set but not
13198 interface_known. In that case, we don't want to use the normal
13199 heuristics because someone will supply a #pragma implementation
13200 elsewhere, and deducing it here would produce a conflict. */
13201 comdat_linkage (decl1
);
13202 DECL_EXTERNAL (decl1
) = 0;
13203 DECL_INTERFACE_KNOWN (decl1
) = 1;
13204 DECL_DEFER_OUTPUT (decl1
) = 1;
13208 /* This is a definition, not a reference.
13209 So clear DECL_EXTERNAL. */
13210 DECL_EXTERNAL (decl1
) = 0;
13212 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
13213 && ! DECL_INTERFACE_KNOWN (decl1
)
13214 /* Don't try to defer nested functions for now. */
13215 && ! hack_decl_function_context (decl1
))
13216 DECL_DEFER_OUTPUT (decl1
) = 1;
13218 DECL_INTERFACE_KNOWN (decl1
) = 1;
13221 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
))
13223 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13224 TREE_TYPE (decl1
) = fntype
13225 = build_function_type (TREE_TYPE (fntype
),
13226 TREE_CHAIN (TYPE_ARG_TYPES (fntype
)));
13227 current_function_parms
= TREE_CHAIN (current_function_parms
);
13228 DECL_ARGUMENTS (decl1
) = current_function_parms
;
13231 restype
= TREE_TYPE (fntype
);
13235 /* If we're compiling a friend function, neither of the variables
13236 current_class_ptr nor current_class_type will have values. */
13237 if (! doing_friend
)
13239 /* We know that this was set up by `grokclassfn'.
13240 We do not wait until `store_parm_decls', since evil
13241 parse errors may never get us to that point. Here
13242 we keep the consistency between `current_class_type'
13243 and `current_class_ptr'. */
13244 tree t
= current_function_parms
;
13246 my_friendly_assert (t
!= NULL_TREE
13247 && TREE_CODE (t
) == PARM_DECL
, 162);
13249 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
13253 if (! hack_decl_function_context (decl1
))
13254 temporary_allocation ();
13255 i
= suspend_momentary ();
13257 /* Normally, build_indirect_ref returns
13258 current_class_ref whenever current_class_ptr is
13259 dereferenced. This time, however, we want it to
13260 *create* current_class_ref, so we temporarily clear
13261 current_class_ptr to fool it. */
13262 current_class_ptr
= NULL_TREE
;
13263 current_class_ref
= build_indirect_ref (t
, NULL_PTR
);
13264 current_class_ptr
= t
;
13266 resume_momentary (i
);
13267 if (! hack_decl_function_context (decl1
))
13268 end_temporary_allocation ();
13271 /* We're having a signature pointer here. */
13272 current_class_ref
= current_class_ptr
= t
;
13277 current_class_ptr
= current_class_ref
= NULL_TREE
;
13280 current_binding_level
->parm_flag
= 1;
13282 GNU_xref_function (decl1
, current_function_parms
);
13285 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
13287 make_function_rtl (decl1
);
13289 /* Promote the value to int before returning it. */
13290 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
13291 restype
= type_promotes_to (restype
);
13293 /* If this fcn was already referenced via a block-scope `extern' decl
13294 (or an implicit decl), propagate certain information about the usage. */
13295 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
13296 TREE_ADDRESSABLE (decl1
) = 1;
13298 if (DECL_RESULT (decl1
) == NULL_TREE
)
13300 DECL_RESULT (decl1
)
13301 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13302 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
13303 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
13306 /* Allocate further tree nodes temporarily during compilation
13307 of this function only. Tiemann moved up here from bottom of fn. */
13308 /* If this is a nested function, then we must continue to allocate RTL
13309 on the permanent obstack in case we need to inline it later. */
13310 if (! hack_decl_function_context (decl1
))
13311 temporary_allocation ();
13313 if (processing_template_decl
)
13315 ++minimal_parse_mode
;
13316 last_tree
= DECL_SAVED_TREE (decl1
)
13317 = build_nt (EXPR_STMT
, void_zero_node
);
13322 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1
))
13323 && DECL_LANGUAGE (decl1
) == lang_cplusplus
)
13325 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13326 ctor_label
= NULL_TREE
;
13330 dtor_label
= NULL_TREE
;
13331 if (DECL_CONSTRUCTOR_P (decl1
))
13332 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13338 /* Called after store_parm_decls for a function-try-block. We need to update
13339 last_parm_cleanup_insn so that the base initializers for a constructor
13340 are run within this block, not before it. */
13343 expand_start_early_try_stmts ()
13345 expand_start_try_stmts ();
13346 last_parm_cleanup_insn
= get_last_insn ();
13349 /* Store the parameter declarations into the current function declaration.
13350 This is called after parsing the parameter declarations, before
13351 digesting the body of the function.
13353 Also install to binding contour return value identifier, if any. */
13356 store_parm_decls ()
13358 register tree fndecl
= current_function_decl
;
13359 register tree parm
;
13360 int parms_have_cleanups
= 0;
13361 tree cleanups
= NULL_TREE
;
13363 /* This is either a chain of PARM_DECLs (when a prototype is used). */
13364 tree specparms
= current_function_parms
;
13366 /* This is a list of types declared among parms in a prototype. */
13367 tree parmtags
= current_function_parm_tags
;
13369 /* This is a chain of any other decls that came in among the parm
13370 declarations. If a parm is declared with enum {foo, bar} x;
13371 then CONST_DECLs for foo and bar are put here. */
13372 tree nonparms
= NULL_TREE
;
13374 if (toplevel_bindings_p ())
13375 fatal ("parse errors have confused me too much");
13377 /* Initialize RTL machinery. */
13378 init_function_start (fndecl
, input_filename
, lineno
);
13380 /* Create a binding level for the parms. */
13381 expand_start_bindings (0);
13383 if (specparms
!= NULL_TREE
)
13385 /* This case is when the function was defined with an ANSI prototype.
13386 The parms already have decls, so we need not do anything here
13387 except record them as in effect
13388 and complain if any redundant old-style parm decls were written. */
13390 register tree next
;
13392 /* Must clear this because it might contain TYPE_DECLs declared
13394 storedecls (NULL_TREE
);
13396 for (parm
= nreverse (specparms
); parm
; parm
= next
)
13398 next
= TREE_CHAIN (parm
);
13399 if (TREE_CODE (parm
) == PARM_DECL
)
13402 if (DECL_NAME (parm
) == NULL_TREE
)
13406 else if (TREE_CODE (TREE_TYPE (parm
)) == VOID_TYPE
)
13407 cp_error ("parameter `%D' declared void", parm
);
13410 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
13411 A parameter is assumed not to have any side effects.
13412 If this should change for any reason, then this
13413 will have to wrap the bashed reference type in a save_expr.
13415 Also, if the parameter type is declared to be an X
13416 and there is an X(X&) constructor, we cannot lay it
13417 into the stack (any more), so we make this parameter
13418 look like it is really of reference type. Functions
13419 which pass parameters to this function will know to
13420 create a temporary in their frame, and pass a reference
13423 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
13424 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))))
13425 SET_DECL_REFERENCE_SLOT (parm
, convert_from_reference (parm
));
13429 if (! processing_template_decl
13430 && (cleanup
= maybe_build_cleanup (parm
), cleanup
))
13432 expand_decl (parm
);
13433 parms_have_cleanups
= 1;
13435 /* Keep track of the cleanups. */
13436 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
13441 /* If we find an enum constant or a type tag,
13442 put it aside for the moment. */
13443 TREE_CHAIN (parm
) = NULL_TREE
;
13444 nonparms
= chainon (nonparms
, parm
);
13448 /* Get the decls in their original chain order
13449 and record in the function. This is all and only the
13450 PARM_DECLs that were pushed into scope by the loop above. */
13451 DECL_ARGUMENTS (fndecl
) = getdecls ();
13453 storetags (chainon (parmtags
, gettags ()));
13456 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13458 /* Now store the final chain of decls for the arguments
13459 as the decl-chain of the current lexical scope.
13460 Put the enumerators in as well, at the front so that
13461 DECL_ARGUMENTS is not modified. */
13463 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
13465 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
13466 declare_function_name ();
13468 /* Initialize the RTL code for the function. */
13469 DECL_SAVED_INSNS (fndecl
) = NULL_RTX
;
13470 if (! processing_template_decl
)
13471 expand_function_start (fndecl
, parms_have_cleanups
);
13473 current_function_parms_stored
= 1;
13475 /* If this function is `main', emit a call to `__main'
13476 to run global initializers, etc. */
13477 if (DECL_MAIN_P (fndecl
))
13478 expand_main_function ();
13480 /* Now that we have initialized the parms, we can start their
13481 cleanups. We cannot do this before, since expand_decl_cleanup
13482 should not be called before the parm can be used. */
13484 && ! processing_template_decl
)
13486 for (cleanups
= nreverse (cleanups
); cleanups
; cleanups
= TREE_CHAIN (cleanups
))
13488 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups
), TREE_VALUE (cleanups
)))
13489 cp_error ("parser lost in parsing declaration of `%D'",
13490 TREE_PURPOSE (cleanups
));
13494 /* Create a binding contour which can be used to catch
13495 cleanup-generated temporaries. Also, if the return value needs or
13496 has initialization, deal with that now. */
13497 if (parms_have_cleanups
)
13500 expand_start_bindings (0);
13503 if (! processing_template_decl
&& flag_exceptions
)
13505 /* Do the starting of the exception specifications, if we have any. */
13506 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
13507 expand_start_eh_spec ();
13510 last_parm_cleanup_insn
= get_last_insn ();
13511 last_dtor_insn
= get_last_insn ();
13514 /* Bind a name and initialization to the return value of
13515 the current function. */
13518 store_return_init (return_id
, init
)
13519 tree return_id
, init
;
13521 tree decl
= DECL_RESULT (current_function_decl
);
13524 /* Give this error as many times as there are occurrences,
13525 so that users can use Emacs compilation buffers to find
13526 and fix all such places. */
13527 pedwarn ("ANSI C++ does not permit named return values");
13529 if (return_id
!= NULL_TREE
)
13531 if (DECL_NAME (decl
) == NULL_TREE
)
13533 DECL_NAME (decl
) = return_id
;
13534 DECL_ASSEMBLER_NAME (decl
) = return_id
;
13537 cp_error ("return identifier `%D' already in place", decl
);
13540 /* Can't let this happen for constructors. */
13541 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13543 error ("can't redefine default return value for constructors");
13547 /* If we have a named return value, put that in our scope as well. */
13548 if (DECL_NAME (decl
) != NULL_TREE
)
13550 /* If this named return value comes in a register,
13551 put it in a pseudo-register. */
13552 if (DECL_REGISTER (decl
))
13554 original_result_rtx
= DECL_RTL (decl
);
13555 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
13558 /* Let `cp_finish_decl' know that this initializer is ok. */
13559 DECL_INITIAL (decl
) = init
;
13562 if (minimal_parse_mode
)
13563 add_tree (build_min_nt (RETURN_INIT
, return_id
,
13564 copy_to_permanent (init
)));
13566 cp_finish_decl (decl
, init
, NULL_TREE
, 0, 0);
13571 /* Finish up a function declaration and compile that function
13572 all the way to assembler language output. The free the storage
13573 for the function definition.
13575 This is called after parsing the body of the function definition.
13576 LINENO is the current line number.
13578 FLAGS is a bitwise or of the following values:
13580 An extra call to poplevel (and expand_end_bindings) must be
13581 made to take care of the binding contour for the base
13582 initializers. This is only relevant for constructors.
13584 We just finished processing the body of an in-class inline
13585 function definition. (This processing will have taken place
13586 after the class definition is complete.)
13588 NESTED is nonzero if we were in the middle of compiling another function
13589 when we started on this one. */
13592 finish_function (lineno
, flags
, nested
)
13597 register tree fndecl
= current_function_decl
;
13598 tree fntype
, ctype
= NULL_TREE
;
13599 rtx last_parm_insn
, insns
;
13600 /* Label to use if this function is supposed to return a value. */
13601 tree no_return_label
= NULL_TREE
;
13602 tree decls
= NULL_TREE
;
13603 int call_poplevel
= (flags
& 1) != 0;
13604 int inclass_inline
= (flags
& 2) != 0;
13607 /* When we get some parse errors, we can end up without a
13608 current_function_decl, so cope. */
13609 if (fndecl
== NULL_TREE
)
13612 if (function_depth
> 1)
13615 fntype
= TREE_TYPE (fndecl
);
13617 /* TREE_READONLY (fndecl) = 1;
13618 This caused &foo to be of type ptr-to-const-function
13619 which then got a warning when stored in a ptr-to-function variable. */
13621 /* This happens on strange parse errors. */
13622 if (! current_function_parms_stored
)
13625 store_parm_decls ();
13628 if (processing_template_decl
)
13630 if (DECL_CONSTRUCTOR_P (fndecl
) && call_poplevel
)
13632 decls
= getdecls ();
13633 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13634 poplevel (decls
!= NULL_TREE
, 0, 0);
13639 if (write_symbols
!= NO_DEBUG
/*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13641 tree ttype
= target_type (fntype
);
13644 if (IS_AGGR_TYPE (ttype
))
13645 /* Let debugger know it should output info for this type. */
13646 note_debug_info_needed (ttype
);
13648 for (parmdecl
= DECL_ARGUMENTS (fndecl
); parmdecl
; parmdecl
= TREE_CHAIN (parmdecl
))
13650 ttype
= target_type (TREE_TYPE (parmdecl
));
13651 if (IS_AGGR_TYPE (ttype
))
13652 /* Let debugger know it should output info for this type. */
13653 note_debug_info_needed (ttype
);
13657 /* Clean house because we will need to reorder insns here. */
13658 do_pending_stack_adjust ();
13662 tree binfo
= TYPE_BINFO (current_class_type
);
13663 tree cond
= integer_one_node
;
13665 tree in_charge_node
= lookup_name (in_charge_identifier
, 0);
13667 int ok_to_optimize_dtor
= 0;
13668 int empty_dtor
= get_last_insn () == last_dtor_insn
;
13670 if (current_function_assigns_this
)
13671 cond
= build (NE_EXPR
, boolean_type_node
,
13672 current_class_ptr
, integer_zero_node
);
13675 int n_baseclasses
= CLASSTYPE_N_BASECLASSES (current_class_type
);
13677 /* If this destructor is empty, then we don't need to check
13678 whether `this' is NULL in some cases. */
13679 if ((flag_this_is_variable
& 1) == 0)
13680 ok_to_optimize_dtor
= 1;
13681 else if (empty_dtor
)
13682 ok_to_optimize_dtor
13683 = (n_baseclasses
== 0
13684 || (n_baseclasses
== 1
13685 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type
, 0))));
13688 /* These initializations might go inline. Protect
13689 the binding level of the parms. */
13691 expand_start_bindings (0);
13693 if (current_function_assigns_this
)
13695 current_function_assigns_this
= 0;
13696 current_function_just_assigned_this
= 0;
13699 /* Generate the code to call destructor on base class.
13700 If this destructor belongs to a class with virtual
13701 functions, then set the virtual function table
13702 pointer to represent the type of our base class. */
13704 /* This side-effect makes call to `build_delete' generate the
13705 code we have to have at the end of this destructor.
13706 `build_delete' will set the flag again. */
13707 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
13709 /* These are two cases where we cannot delegate deletion. */
13710 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)
13711 || TYPE_GETS_REG_DELETE (current_class_type
))
13712 exprstmt
= build_delete (current_class_type
, current_class_ref
, integer_zero_node
,
13713 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13715 exprstmt
= build_delete (current_class_type
, current_class_ref
, in_charge_node
,
13716 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13718 /* If we did not assign to this, then `this' is non-zero at
13719 the end of a destructor. As a special optimization, don't
13720 emit test if this is an empty destructor. If it does nothing,
13721 it does nothing. If it calls a base destructor, the base
13722 destructor will perform the test. */
13724 if (exprstmt
!= error_mark_node
13725 && (TREE_CODE (exprstmt
) != NOP_EXPR
13726 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
13727 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
13729 expand_label (dtor_label
);
13730 if (cond
!= integer_one_node
)
13731 expand_start_cond (cond
, 0);
13732 if (exprstmt
!= void_zero_node
)
13733 /* Don't call `expand_expr_stmt' if we're not going to do
13734 anything, since -Wall will give a diagnostic. */
13735 expand_expr_stmt (exprstmt
);
13737 /* Run destructor on all virtual baseclasses. */
13738 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13740 tree vbases
= nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type
)));
13741 expand_start_cond (build (BIT_AND_EXPR
, integer_type_node
,
13742 in_charge_node
, integer_two_node
), 0);
13745 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases
)))
13747 tree vb
= get_vbase
13748 (BINFO_TYPE (vbases
),
13749 TYPE_BINFO (current_class_type
));
13751 (build_scoped_method_call
13752 (current_class_ref
, vb
, dtor_identifier
,
13753 build_expr_list (NULL_TREE
, integer_zero_node
)));
13755 vbases
= TREE_CHAIN (vbases
);
13757 expand_end_cond ();
13760 do_pending_stack_adjust ();
13761 if (cond
!= integer_one_node
)
13762 expand_end_cond ();
13765 virtual_size
= c_sizeof (current_class_type
);
13767 /* At the end, call delete if that's what's requested. */
13769 /* FDIS sez: At the point of definition of a virtual destructor
13770 (including an implicit definition), non-placement operator
13771 delete shall be looked up in the scope of the destructor's
13772 class and if found shall be accessible and unambiguous.
13774 This is somewhat unclear, but I take it to mean that if the
13775 class only defines placement deletes we don't do anything here.
13776 So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain
13777 for us if they ever try to delete one of these. */
13779 if (TYPE_GETS_REG_DELETE (current_class_type
)
13780 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13781 exprstmt
= build_op_delete_call
13782 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
13783 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
13785 exprstmt
= NULL_TREE
;
13789 cond
= build (BIT_AND_EXPR
, integer_type_node
,
13790 in_charge_node
, integer_one_node
);
13791 expand_start_cond (cond
, 0);
13792 expand_expr_stmt (exprstmt
);
13793 expand_end_cond ();
13796 /* End of destructor. */
13797 expand_end_bindings (NULL_TREE
, getdecls () != NULL_TREE
, 0);
13798 poplevel (getdecls () != NULL_TREE
, 0, 0);
13800 /* Back to the top of destructor. */
13801 /* Don't execute destructor code if `this' is NULL. */
13805 /* If the dtor is empty, and we know there is not possible way we
13806 could use any vtable entries, before they are possibly set by
13807 a base class dtor, we don't have to setup the vtables, as we
13808 know that any base class dtoring will set up any vtables it
13809 needs. We avoid MI, because one base class dtor can do a
13810 virtual dispatch to an overridden function that would need to
13811 have a non-related vtable set up, we cannot avoid setting up
13812 vtables in that case. We could change this to see if there is
13813 just one vtable. */
13814 if (! empty_dtor
|| TYPE_USES_COMPLEX_INHERITANCE (current_class_type
))
13816 /* Make all virtual function table pointers in non-virtual base
13817 classes point to CURRENT_CLASS_TYPE's virtual function
13819 expand_direct_vtbls_init (binfo
, binfo
, 1, 0, current_class_ptr
);
13821 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13822 expand_indirect_vtbls_init (binfo
, current_class_ref
, current_class_ptr
);
13825 if (! ok_to_optimize_dtor
)
13827 cond
= build_binary_op (NE_EXPR
,
13828 current_class_ptr
, integer_zero_node
);
13829 expand_start_cond (cond
, 0);
13832 insns
= get_insns ();
13835 last_parm_insn
= get_first_nonparm_insn ();
13836 if (last_parm_insn
== NULL_RTX
)
13837 last_parm_insn
= get_last_insn ();
13839 last_parm_insn
= previous_insn (last_parm_insn
);
13841 emit_insns_after (insns
, last_parm_insn
);
13843 if (! ok_to_optimize_dtor
)
13844 expand_end_cond ();
13846 else if (current_function_assigns_this
)
13848 /* Does not need to call emit_base_init, because
13849 that is done (if needed) just after assignment to this
13852 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13854 end_protect_partials ();
13855 expand_label (ctor_label
);
13856 ctor_label
= NULL_TREE
;
13860 decls
= getdecls ();
13861 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13862 poplevel (decls
!= NULL_TREE
, 0, 0);
13864 /* c_expand_return knows to return 'this' from a constructor. */
13865 c_expand_return (NULL_TREE
);
13867 else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl
))) != VOID_TYPE
13868 && return_label
!= NULL_RTX
)
13869 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13871 current_function_assigns_this
= 0;
13872 current_function_just_assigned_this
= 0;
13873 base_init_expr
= NULL_TREE
;
13875 else if (DECL_CONSTRUCTOR_P (fndecl
))
13877 tree cond
= NULL_TREE
, thenclause
= NULL_TREE
;
13878 /* Allow constructor for a type to get a new instance of the object
13879 using `build_new'. */
13880 tree abstract_virtuals
= CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
);
13881 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = NULL_TREE
;
13883 if (flag_this_is_variable
> 0)
13885 cond
= build_binary_op (EQ_EXPR
,
13886 current_class_ptr
, integer_zero_node
);
13887 thenclause
= build_modify_expr (current_class_ptr
, NOP_EXPR
,
13888 build_new (NULL_TREE
, current_class_type
, void_type_node
, 0));
13891 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = abstract_virtuals
;
13895 if (flag_this_is_variable
> 0)
13897 expand_start_cond (cond
, 0);
13898 expand_expr_stmt (thenclause
);
13899 expand_end_cond ();
13902 /* Emit insns from `emit_base_init' which sets up virtual
13903 function table pointer(s). */
13904 if (base_init_expr
)
13906 expand_expr_stmt (base_init_expr
);
13907 base_init_expr
= NULL_TREE
;
13910 insns
= get_insns ();
13913 /* This is where the body of the constructor begins. */
13915 emit_insns_after (insns
, last_parm_cleanup_insn
);
13917 end_protect_partials ();
13919 /* This is where the body of the constructor ends. */
13920 expand_label (ctor_label
);
13921 ctor_label
= NULL_TREE
;
13925 decls
= getdecls ();
13926 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13927 poplevel (decls
!= NULL_TREE
, 1, 0);
13930 /* c_expand_return knows to return 'this' from a constructor. */
13931 c_expand_return (NULL_TREE
);
13933 current_function_assigns_this
= 0;
13934 current_function_just_assigned_this
= 0;
13936 else if (DECL_MAIN_P (fndecl
))
13938 /* Make it so that `main' always returns 0 by default. */
13940 c_expand_return (integer_one_node
);
13942 c_expand_return (integer_zero_node
);
13945 else if (return_label
!= NULL_RTX
13946 && current_function_return_value
== NULL_TREE
13947 && ! DECL_NAME (DECL_RESULT (current_function_decl
)))
13948 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13950 if (flag_exceptions
)
13951 expand_exception_blocks ();
13953 /* If this function is supposed to return a value, ensure that
13954 we do not fall into the cleanups by mistake. The end of our
13955 function will look like this:
13957 user code (may have return stmt somewhere)
13958 goto no_return_label
13963 NOTE_INSN_FUNCTION_END
13967 If the user omits a return stmt in the USER CODE section, we
13968 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13969 Otherwise, we won't. */
13970 if (no_return_label
)
13972 DECL_CONTEXT (no_return_label
) = fndecl
;
13973 DECL_INITIAL (no_return_label
) = error_mark_node
;
13974 DECL_SOURCE_FILE (no_return_label
) = input_filename
;
13975 DECL_SOURCE_LINE (no_return_label
) = lineno
;
13976 expand_goto (no_return_label
);
13981 /* Remove the binding contour which is used
13982 to catch cleanup-generated temporaries. */
13983 expand_end_bindings (0, 0, 0);
13984 poplevel (0, 0, 0);
13986 /* Emit label at beginning of cleanup code for parameters. */
13987 emit_label (cleanup_label
);
13990 /* Get return value into register if that's where it's supposed to be. */
13991 if (original_result_rtx
)
13992 fixup_result_decl (DECL_RESULT (fndecl
), original_result_rtx
);
13994 /* Finish building code that will trigger warnings if users forget
13995 to make their functions return values. */
13996 if (no_return_label
|| cleanup_label
)
13997 emit_jump (return_label
);
13998 if (no_return_label
)
14000 /* We don't need to call `expand_*_return' here because we
14001 don't need any cleanups here--this path of code is only
14002 for error checking purposes. */
14003 expand_label (no_return_label
);
14006 /* Generate rtl for function exit. */
14007 expand_function_end (input_filename
, lineno
, 1);
14010 /* If we're processing a template, squirrel away the definition
14011 until we do an instantiation. */
14012 if (processing_template_decl
)
14014 --minimal_parse_mode
;
14015 DECL_SAVED_TREE (fndecl
) = TREE_CHAIN (DECL_SAVED_TREE (fndecl
));
14016 /* We have to save this value here in case
14017 maybe_end_member_template_processing decides to pop all the
14018 template parameters. */
14024 /* This must come after expand_function_end because cleanups might
14025 have declarations (from inline functions) that need to go into
14026 this function's blocks. */
14027 if (current_binding_level
->parm_flag
!= 1)
14028 my_friendly_abort (122);
14029 poplevel (1, 0, 1);
14031 /* If this is a in-class inline definition, we may have to pop the
14032 bindings for the template parameters that we added in
14033 maybe_begin_member_template_processing when start_function was
14035 if (inclass_inline
)
14036 maybe_end_member_template_processing ();
14038 /* Reset scope for C++: if we were in the scope of a class,
14039 then when we finish this function, we are not longer so.
14040 This cannot be done until we know for sure that no more
14041 class members will ever be referenced in this function
14042 (i.e., calls to destructors). */
14043 if (current_class_name
)
14045 ctype
= current_class_type
;
14046 pop_nested_class ();
14049 /* Must mark the RESULT_DECL as being in this function. */
14050 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14052 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14053 to the FUNCTION_DECL node itself. */
14054 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14058 int saved_flag_keep_inline_functions
=
14059 flag_keep_inline_functions
;
14061 /* So we can tell if jump_optimize sets it to 1. */
14064 if (DECL_CONTEXT (fndecl
) != NULL_TREE
14065 && hack_decl_function_context (fndecl
))
14066 /* Trick rest_of_compilation into not deferring output of this
14067 function, even if it is inline, since the rtl_obstack for
14068 this function is the function_obstack of the enclosing
14069 function and will be deallocated when the enclosing
14070 function is gone. See save_tree_status. */
14071 flag_keep_inline_functions
= 1;
14073 /* Run the optimizers and output the assembler code for this
14076 if (DECL_ARTIFICIAL (fndecl
))
14078 /* Do we really *want* to inline this synthesized method? */
14080 int save_fif
= flag_inline_functions
;
14081 flag_inline_functions
= 1;
14083 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
14084 will check our size. */
14085 DECL_INLINE (fndecl
) = 0;
14087 rest_of_compilation (fndecl
);
14088 flag_inline_functions
= save_fif
;
14091 rest_of_compilation (fndecl
);
14093 flag_keep_inline_functions
= saved_flag_keep_inline_functions
;
14095 if (DECL_SAVED_INSNS (fndecl
) && ! TREE_ASM_WRITTEN (fndecl
))
14097 /* Set DECL_EXTERNAL so that assemble_external will be called as
14098 necessary. We'll clear it again in finish_file. */
14099 if (! DECL_EXTERNAL (fndecl
))
14100 DECL_NOT_REALLY_EXTERN (fndecl
) = 1;
14101 DECL_EXTERNAL (fndecl
) = 1;
14102 mark_inline_for_output (fndecl
);
14105 if (ctype
&& TREE_ASM_WRITTEN (fndecl
))
14106 note_debug_info_needed (ctype
);
14108 current_function_returns_null
|= can_reach_end
;
14110 /* Since we don't normally go through c_expand_return for constructors,
14111 this normally gets the wrong value.
14112 Also, named return values have their return codes emitted after
14113 NOTE_INSN_FUNCTION_END, confusing jump.c. */
14114 if (DECL_CONSTRUCTOR_P (fndecl
)
14115 || DECL_NAME (DECL_RESULT (fndecl
)) != NULL_TREE
)
14116 current_function_returns_null
= 0;
14118 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
14119 cp_warning ("`noreturn' function `%D' does return", fndecl
);
14120 else if ((warn_return_type
|| pedantic
)
14121 && current_function_returns_null
14122 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
)
14124 /* If this function returns non-void and control can drop through,
14126 cp_warning ("control reaches end of non-void function `%D'", fndecl
);
14128 /* With just -W, complain only if function returns both with
14129 and without a value. */
14130 else if (extra_warnings
14131 && current_function_returns_value
&& current_function_returns_null
)
14132 warning ("this function may return with or without a value");
14137 /* Free all the tree nodes making up this function. */
14138 /* Switch back to allocating nodes permanently
14139 until we start another function. */
14141 permanent_allocation (1);
14143 if (DECL_SAVED_INSNS (fndecl
) == NULL_RTX
)
14147 /* Stop pointing to the local nodes about to be freed. */
14148 /* But DECL_INITIAL must remain nonzero so we know this
14149 was an actual function definition. */
14150 DECL_INITIAL (fndecl
) = error_mark_node
;
14151 for (t
= DECL_ARGUMENTS (fndecl
); t
; t
= TREE_CHAIN (t
))
14152 DECL_RTL (t
) = DECL_INCOMING_RTL (t
) = NULL_RTX
;
14155 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
14156 static_ctors
= perm_tree_cons (NULL_TREE
, fndecl
, static_ctors
);
14157 if (DECL_STATIC_DESTRUCTOR (fndecl
))
14158 static_dtors
= perm_tree_cons (NULL_TREE
, fndecl
, static_dtors
);
14162 /* Let the error reporting routines know that we're outside a
14163 function. For a nested function, this value is used in
14164 pop_cp_function_context and then reset via pop_function_context. */
14165 current_function_decl
= NULL_TREE
;
14168 named_label_uses
= NULL
;
14169 current_class_ptr
= NULL_TREE
;
14170 current_class_ref
= NULL_TREE
;
14173 /* Create the FUNCTION_DECL for a function definition.
14174 DECLSPECS and DECLARATOR are the parts of the declaration;
14175 they describe the return type and the name of the function,
14176 but twisted together in a fashion that parallels the syntax of C.
14178 This function creates a binding context for the function body
14179 as well as setting up the FUNCTION_DECL in current_function_decl.
14181 Returns a FUNCTION_DECL on success.
14183 If the DECLARATOR is not suitable for a function (it defines a datum
14184 instead), we return 0, which tells yyparse to report a parse error.
14186 May return void_type_node indicating that this method is actually
14187 a friend. See grokfield for more details.
14189 Came here with a `.pushlevel' .
14191 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14192 CHANGES TO CODE IN `grokfield'. */
14195 start_method (declspecs
, declarator
, attrlist
)
14196 tree declarator
, declspecs
, attrlist
;
14198 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14201 /* Something too ugly to handle. */
14202 if (fndecl
== NULL_TREE
)
14205 /* Pass friends other than inline friend functions back. */
14206 if (fndecl
== void_type_node
)
14209 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
14210 /* Not a function, tell parser to report parse error. */
14213 if (IS_SIGNATURE (current_class_type
))
14214 IS_DEFAULT_IMPLEMENTATION (fndecl
) = 1;
14216 if (DECL_IN_AGGR_P (fndecl
))
14218 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
14220 if (DECL_CONTEXT (fndecl
)
14221 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
14222 cp_error ("`%D' is already defined in class %s", fndecl
,
14223 TYPE_NAME_STRING (DECL_CONTEXT (fndecl
)));
14225 return void_type_node
;
14228 check_template_shadow (fndecl
);
14230 DECL_THIS_INLINE (fndecl
) = 1;
14232 if (flag_default_inline
)
14233 DECL_INLINE (fndecl
) = 1;
14235 /* We process method specializations in finish_struct_1. */
14236 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14237 fndecl
= push_template_decl (fndecl
);
14239 /* We read in the parameters on the maybepermanent_obstack,
14240 but we won't be getting back to them until after we
14241 may have clobbered them. So the call to preserve_data
14242 will keep them safe. */
14245 if (! DECL_FRIEND_P (fndecl
))
14247 if (TREE_CHAIN (fndecl
))
14249 fndecl
= copy_node (fndecl
);
14250 TREE_CHAIN (fndecl
) = NULL_TREE
;
14253 if (DECL_CONSTRUCTOR_P (fndecl
))
14255 if (! grok_ctor_properties (current_class_type
, fndecl
))
14256 return void_type_node
;
14258 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
14259 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
14262 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0, 0);
14264 /* Make a place for the parms */
14266 current_binding_level
->parm_flag
= 1;
14268 DECL_IN_AGGR_P (fndecl
) = 1;
14272 /* Go through the motions of finishing a function definition.
14273 We don't compile this method until after the whole class has
14276 FINISH_METHOD must return something that looks as though it
14277 came from GROKFIELD (since we are defining a method, after all).
14279 This is called after parsing the body of the function definition.
14280 STMTS is the chain of statements that makes up the function body.
14282 DECL is the ..._DECL that `start_method' provided. */
14285 finish_method (decl
)
14288 register tree fndecl
= decl
;
14291 register tree link
;
14293 if (decl
== void_type_node
)
14296 old_initial
= DECL_INITIAL (fndecl
);
14298 /* Undo the level for the parms (from start_method).
14299 This is like poplevel, but it causes nothing to be
14300 saved. Saving information here confuses symbol-table
14301 output routines. Besides, this information will
14302 be correctly output when this method is actually
14305 /* Clear out the meanings of the local variables of this level;
14306 also record in each decl which block it belongs to. */
14308 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
14310 if (DECL_NAME (link
) != NULL_TREE
)
14311 pop_binding (DECL_NAME (link
), link
);
14312 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
14313 DECL_CONTEXT (link
) = NULL_TREE
;
14316 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
14317 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
14318 current_binding_level
->parm_flag
,
14319 current_binding_level
->keep
);
14321 poplevel (0, 0, 0);
14323 DECL_INITIAL (fndecl
) = old_initial
;
14325 /* We used to check if the context of FNDECL was different from
14326 current_class_type as another way to get inside here. This didn't work
14327 for String.cc in libg++. */
14328 if (DECL_FRIEND_P (fndecl
))
14330 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
14331 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
14332 decl
= void_type_node
;
14338 /* Called when a new struct TYPE is defined.
14339 If this structure or union completes the type of any previous
14340 variable declaration, lay it out and output its rtl. */
14343 hack_incomplete_structures (type
)
14348 if (current_binding_level
->incomplete
== NULL_TREE
)
14351 if (!type
) /* Don't do this for class templates. */
14354 for (list
= ¤t_binding_level
->incomplete
; *list
; )
14356 tree decl
= TREE_VALUE (*list
);
14357 if ((decl
&& TREE_TYPE (decl
) == type
)
14358 || (TREE_TYPE (decl
)
14359 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14360 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
14362 int toplevel
= toplevel_bindings_p ();
14363 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14364 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
14365 layout_type (TREE_TYPE (decl
));
14366 layout_decl (decl
, 0);
14367 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
14371 expand_decl (decl
);
14372 cleanup
= maybe_build_cleanup (decl
);
14373 expand_decl_init (decl
);
14374 if (! expand_decl_cleanup (decl
, cleanup
))
14375 cp_error ("parser lost in parsing declaration of `%D'",
14378 *list
= TREE_CHAIN (*list
);
14381 list
= &TREE_CHAIN (*list
);
14385 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14386 See build_delete for information about AUTO_DELETE.
14388 Don't build these on the momentary obstack; they must live
14389 the life of the binding contour. */
14392 maybe_build_cleanup_1 (decl
, auto_delete
)
14393 tree decl
, auto_delete
;
14395 tree type
= TREE_TYPE (decl
);
14396 if (type
!= error_mark_node
&& TYPE_NEEDS_DESTRUCTOR (type
))
14398 int temp
= 0, flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14401 if (TREE_CODE (decl
) != PARM_DECL
)
14402 temp
= suspend_momentary ();
14404 if (TREE_CODE (type
) == ARRAY_TYPE
)
14408 mark_addressable (decl
);
14409 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
14412 /* Optimize for space over speed here. */
14413 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
14414 || flag_expensive_optimizations
)
14415 flags
|= LOOKUP_NONVIRTUAL
;
14417 rval
= build_delete (TREE_TYPE (rval
), rval
, auto_delete
, flags
, 0);
14419 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
14420 && ! TYPE_HAS_DESTRUCTOR (type
))
14421 rval
= build_compound_expr (expr_tree_cons (NULL_TREE
, rval
,
14422 build_expr_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
14424 if (TREE_CODE (decl
) != PARM_DECL
)
14425 resume_momentary (temp
);
14432 /* If DECL is of a type which needs a cleanup, build that cleanup
14433 here. The cleanup does free the storage with a call to delete. */
14436 maybe_build_cleanup_and_delete (decl
)
14439 return maybe_build_cleanup_1 (decl
, integer_three_node
);
14442 /* If DECL is of a type which needs a cleanup, build that cleanup
14443 here. The cleanup does not free the storage with a call a delete. */
14446 maybe_build_cleanup (decl
)
14449 return maybe_build_cleanup_1 (decl
, integer_two_node
);
14452 /* Expand a C++ expression at the statement level.
14453 This is needed to ferret out nodes which have UNKNOWN_TYPE.
14454 The C++ type checker should get all of these out when
14455 expressions are combined with other, type-providing, expressions,
14456 leaving only orphan expressions, such as:
14458 &class::bar; / / takes its address, but does nothing with it. */
14461 cplus_expand_expr_stmt (exp
)
14464 if (processing_template_decl
)
14466 add_tree (build_min_nt (EXPR_STMT
, exp
));
14470 /* Arrange for all temps to disappear. */
14471 expand_start_target_temps ();
14473 exp
= require_complete_type_in_void (exp
);
14475 if (TREE_CODE (exp
) == FUNCTION_DECL
)
14477 cp_warning ("reference, not call, to function `%D'", exp
);
14478 warning ("at this point in file");
14482 /* We should do this eventually, but right now this causes regex.o from
14483 libg++ to miscompile, and tString to core dump. */
14484 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
14487 /* Strip unused implicit INDIRECT_REFs of references. */
14488 if (TREE_CODE (exp
) == INDIRECT_REF
14489 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
14490 exp
= TREE_OPERAND (exp
, 0);
14492 /* If we don't do this, we end up down inside expand_expr
14493 trying to do TYPE_MODE on the ERROR_MARK, and really
14494 go outside the bounds of the type. */
14495 if (exp
!= error_mark_node
)
14496 expand_expr_stmt (break_out_cleanups (exp
));
14498 /* Clean up any pending cleanups. This happens when a function call
14499 returns a cleanup-needing value that nobody uses. */
14500 expand_end_target_temps ();
14503 /* When a stmt has been parsed, this function is called.
14505 Currently, this function only does something within a
14506 constructor's scope: if a stmt has just assigned to this,
14507 and we are in a derived class, we call `emit_base_init'. */
14512 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
14515 if (current_function_assigns_this
14516 || ! current_function_just_assigned_this
)
14518 if (DECL_CONSTRUCTOR_P (current_function_decl
))
14520 /* Constructors must wait until we are out of control
14521 zones before calling base constructors. */
14522 if (cond_stack
|| loop_stack
|| case_stack
)
14524 expand_expr_stmt (base_init_expr
);
14525 check_base_init (current_class_type
);
14527 current_function_assigns_this
= 1;
14530 /* Change a static member function definition into a FUNCTION_TYPE, instead
14531 of the METHOD_TYPE that we create when it's originally parsed.
14533 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14534 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14535 other decls. Either pass the addresses of local variables or NULL. */
14538 revert_static_member_fn (decl
, fn
, argtypes
)
14539 tree
*decl
, *fn
, *argtypes
;
14542 tree function
= fn
? *fn
: TREE_TYPE (*decl
);
14543 tree args
= argtypes
? *argtypes
: TYPE_ARG_TYPES (function
);
14545 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
14546 != TYPE_UNQUALIFIED
)
14547 cp_error ("static member function `%#D' declared with type qualifiers",
14550 args
= TREE_CHAIN (args
);
14551 tmp
= build_function_type (TREE_TYPE (function
), args
);
14552 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
14553 tmp
= build_exception_variant (tmp
,
14554 TYPE_RAISES_EXCEPTIONS (function
));
14555 TREE_TYPE (*decl
) = tmp
;
14556 if (DECL_ARGUMENTS (*decl
))
14557 DECL_ARGUMENTS (*decl
) = TREE_CHAIN (DECL_ARGUMENTS (*decl
));
14558 DECL_STATIC_FUNCTION_P (*decl
) = 1;
14570 int just_assigned_this
;
14572 int temp_name_counter
;
14574 struct named_label_list
*named_label_uses
;
14575 tree shadowed_labels
;
14578 rtx last_dtor_insn
;
14579 rtx last_parm_cleanup_insn
;
14580 tree base_init_list
;
14581 tree member_init_list
;
14582 tree base_init_expr
;
14583 tree current_class_ptr
;
14584 tree current_class_ref
;
14586 struct cp_function
*next
;
14587 struct binding_level
*binding_level
;
14588 int static_labelno
;
14591 static struct cp_function
*cp_function_chain
;
14593 extern int temp_name_counter
;
14595 /* Save and reinitialize the variables
14596 used during compilation of a C++ function. */
14599 push_cp_function_context (context
)
14602 struct cp_function
*p
14603 = (struct cp_function
*) xmalloc (sizeof (struct cp_function
));
14605 push_function_context_to (context
);
14607 p
->next
= cp_function_chain
;
14608 cp_function_chain
= p
;
14610 p
->named_labels
= named_labels
;
14611 p
->named_label_uses
= named_label_uses
;
14612 p
->shadowed_labels
= shadowed_labels
;
14613 p
->returns_value
= current_function_returns_value
;
14614 p
->returns_null
= current_function_returns_null
;
14615 p
->binding_level
= current_binding_level
;
14616 p
->ctor_label
= ctor_label
;
14617 p
->dtor_label
= dtor_label
;
14618 p
->last_dtor_insn
= last_dtor_insn
;
14619 p
->last_parm_cleanup_insn
= last_parm_cleanup_insn
;
14620 p
->assigns_this
= current_function_assigns_this
;
14621 p
->just_assigned_this
= current_function_just_assigned_this
;
14622 p
->parms_stored
= current_function_parms_stored
;
14623 p
->result_rtx
= original_result_rtx
;
14624 p
->base_init_expr
= base_init_expr
;
14625 p
->temp_name_counter
= temp_name_counter
;
14626 p
->base_init_list
= current_base_init_list
;
14627 p
->member_init_list
= current_member_init_list
;
14628 p
->current_class_ptr
= current_class_ptr
;
14629 p
->current_class_ref
= current_class_ref
;
14630 p
->static_labelno
= static_labelno
;
14633 /* Restore the variables used during compilation of a C++ function. */
14636 pop_cp_function_context (context
)
14639 struct cp_function
*p
= cp_function_chain
;
14642 /* Bring back all the labels that were shadowed. */
14643 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
14644 if (DECL_NAME (TREE_VALUE (link
)) != 0)
14645 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)),
14646 TREE_VALUE (link
));
14648 pop_function_context_from (context
);
14650 cp_function_chain
= p
->next
;
14652 named_labels
= p
->named_labels
;
14653 named_label_uses
= p
->named_label_uses
;
14654 shadowed_labels
= p
->shadowed_labels
;
14655 current_function_returns_value
= p
->returns_value
;
14656 current_function_returns_null
= p
->returns_null
;
14657 current_binding_level
= p
->binding_level
;
14658 ctor_label
= p
->ctor_label
;
14659 dtor_label
= p
->dtor_label
;
14660 last_dtor_insn
= p
->last_dtor_insn
;
14661 last_parm_cleanup_insn
= p
->last_parm_cleanup_insn
;
14662 current_function_assigns_this
= p
->assigns_this
;
14663 current_function_just_assigned_this
= p
->just_assigned_this
;
14664 current_function_parms_stored
= p
->parms_stored
;
14665 original_result_rtx
= p
->result_rtx
;
14666 base_init_expr
= p
->base_init_expr
;
14667 temp_name_counter
= p
->temp_name_counter
;
14668 current_base_init_list
= p
->base_init_list
;
14669 current_member_init_list
= p
->member_init_list
;
14670 current_class_ptr
= p
->current_class_ptr
;
14671 current_class_ref
= p
->current_class_ref
;
14672 static_labelno
= p
->static_labelno
;
14680 return function_depth
!= 0;