1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92-97, 1998 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Process declarations and symbol lookup for C front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
27 /* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
45 #define obstack_chunk_alloc xmalloc
46 #define obstack_chunk_free free
48 extern tree builtin_return_address_fndecl
;
50 extern struct obstack permanent_obstack
;
51 extern struct obstack
* saveable_obstack
;
53 extern int current_class_depth
;
55 extern tree static_ctors
, static_dtors
;
57 extern int static_labelno
;
59 extern tree current_namespace
;
60 extern tree global_namespace
;
62 extern void (*print_error_function
) PROTO((char *));
64 /* Stack of places to restore the search obstack back to. */
66 /* Obstack used for remembering local class declarations (like
67 enums and static (const) members. */
69 struct obstack decl_obstack
;
70 static struct stack_level
*decl_stack
;
72 #ifndef CHAR_TYPE_SIZE
73 #define CHAR_TYPE_SIZE BITS_PER_UNIT
76 #ifndef SHORT_TYPE_SIZE
77 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
81 #define INT_TYPE_SIZE BITS_PER_WORD
84 #ifndef LONG_TYPE_SIZE
85 #define LONG_TYPE_SIZE BITS_PER_WORD
88 #ifndef LONG_LONG_TYPE_SIZE
89 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
92 #ifndef WCHAR_UNSIGNED
93 #define WCHAR_UNSIGNED 0
96 #ifndef FLOAT_TYPE_SIZE
97 #define FLOAT_TYPE_SIZE BITS_PER_WORD
100 #ifndef DOUBLE_TYPE_SIZE
101 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
104 #ifndef LONG_DOUBLE_TYPE_SIZE
105 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
108 #ifndef BOOL_TYPE_SIZE
109 #ifdef SLOW_BYTE_ACCESS
110 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
112 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
116 /* We let tm.h override the types used here, to handle trivial differences
117 such as the choice of unsigned int or long unsigned int for size_t.
118 When machines start needing nontrivial differences in the size type,
119 it would be best to do something here to figure out automatically
120 from other information what type to use. */
123 #define SIZE_TYPE "long unsigned int"
127 #define PTRDIFF_TYPE "long int"
131 #define WCHAR_TYPE "int"
134 static tree grokparms
PROTO((tree
, int));
135 static tree lookup_nested_type
PROTO((tree
, tree
));
136 static char *redeclaration_error_message
PROTO((tree
, tree
));
137 static tree push_overloaded_decl
PROTO((tree
, int));
139 static struct stack_level
*push_decl_level
PROTO((struct stack_level
*,
141 static void push_binding_level
PROTO((struct binding_level
*, int,
143 static void pop_binding_level
PROTO((void));
144 static void suspend_binding_level
PROTO((void));
145 static void resume_binding_level
PROTO((struct binding_level
*));
146 static struct binding_level
*make_binding_level
PROTO((void));
147 static int namespace_bindings_p
PROTO((void));
148 static void declare_namespace_level
PROTO((void));
149 static void signal_catch
PROTO((int));
150 static void storedecls
PROTO((tree
));
151 static void storetags
PROTO((tree
));
152 static void require_complete_types_for_parms
PROTO((tree
));
153 static void push_overloaded_decl_1
PROTO((tree
));
154 static int ambi_op_p
PROTO((tree
));
155 static int unary_op_p
PROTO((tree
));
156 static tree store_bindings
PROTO((tree
, tree
));
157 static tree lookup_tag_reverse
PROTO((tree
, tree
));
158 static tree obscure_complex_init
PROTO((tree
, tree
));
159 static tree maybe_build_cleanup_1
PROTO((tree
, tree
));
160 static tree lookup_name_real
PROTO((tree
, int, int, int));
161 static void warn_extern_redeclared_static
PROTO((tree
, tree
));
162 static void grok_reference_init
PROTO((tree
, tree
, tree
));
163 static tree grokfndecl
PROTO((tree
, tree
, tree
, tree
, int,
164 enum overload_flags
, tree
,
165 tree
, tree
, int, int, int, int, int, int, tree
));
166 static tree grokvardecl
PROTO((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
167 static tree lookup_tag
PROTO((enum tree_code
, tree
,
168 struct binding_level
*, int));
169 static void set_identifier_type_value_with_scope
170 PROTO((tree
, tree
, struct binding_level
*));
171 static void set_identifier_local_value_with_scope
172 PROTO((tree
, tree
, struct binding_level
*));
173 static void record_builtin_type
PROTO((enum rid
, char *, tree
));
174 static void record_unknown_type
PROTO((tree
, char *));
175 static int member_function_or_else
PROTO((tree
, tree
, char *));
176 static void bad_specifiers
PROTO((tree
, char *, int, int, int, int,
178 static void lang_print_error_function
PROTO((char *));
179 static tree maybe_process_template_type_declaration
PROTO((tree
, int, struct binding_level
*));
181 #if defined (DEBUG_CP_BINDING_LEVELS)
182 static void indent
PROTO((void));
185 /* A node which has tree code ERROR_MARK, and whose type is itself.
186 All erroneous expressions are replaced with this node. All functions
187 that accept nodes as arguments should avoid generating error messages
188 if this node is one of the arguments, since it is undesirable to get
189 multiple error messages from one error in the input. */
191 tree error_mark_node
;
193 /* Erroneous argument lists can use this *IFF* they do not modify it. */
194 tree error_mark_list
;
196 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
198 tree short_integer_type_node
;
199 tree integer_type_node
;
200 tree long_integer_type_node
;
201 tree long_long_integer_type_node
;
203 tree short_unsigned_type_node
;
204 tree unsigned_type_node
;
205 tree long_unsigned_type_node
;
206 tree long_long_unsigned_type_node
;
208 tree ptrdiff_type_node
;
210 tree unsigned_char_type_node
;
211 tree signed_char_type_node
;
213 tree wchar_type_node
;
214 tree signed_wchar_type_node
;
215 tree unsigned_wchar_type_node
;
217 tree wchar_decl_node
;
219 tree float_type_node
;
220 tree double_type_node
;
221 tree long_double_type_node
;
223 tree complex_integer_type_node
;
224 tree complex_float_type_node
;
225 tree complex_double_type_node
;
226 tree complex_long_double_type_node
;
228 tree intQI_type_node
;
229 tree intHI_type_node
;
230 tree intSI_type_node
;
231 tree intDI_type_node
;
232 tree intTI_type_node
;
234 tree unsigned_intQI_type_node
;
235 tree unsigned_intHI_type_node
;
236 tree unsigned_intSI_type_node
;
237 tree unsigned_intDI_type_node
;
238 tree unsigned_intTI_type_node
;
240 tree java_byte_type_node
;
241 tree java_short_type_node
;
242 tree java_int_type_node
;
243 tree java_long_type_node
;
244 tree java_float_type_node
;
245 tree java_double_type_node
;
246 tree java_char_type_node
;
247 tree java_boolean_type_node
;
249 /* A VOID_TYPE node, and the same, packaged in a TREE_LIST. */
251 tree void_type_node
, void_list_node
;
254 /* Nodes for types `void *' and `const void *'. */
257 tree const_ptr_type_node
;
259 /* Nodes for types `char *' and `const char *'. */
261 tree string_type_node
, const_string_type_node
;
263 /* Type `char[256]' or something like it.
264 Used when an array of char is needed and the size is irrelevant. */
266 tree char_array_type_node
;
268 /* Type `int[256]' or something like it.
269 Used when an array of int needed and the size is irrelevant. */
271 tree int_array_type_node
;
273 /* Type `wchar_t[256]' or something like it.
274 Used when a wide string literal is created. */
276 tree wchar_array_type_node
;
278 /* The bool data type, and constants */
279 tree boolean_type_node
, boolean_true_node
, boolean_false_node
;
281 /* Type `int ()' -- used for implicit declaration of functions. */
283 tree default_function_type
;
285 /* Function types `double (double)' and `double (double, double)', etc. */
287 static tree double_ftype_double
, double_ftype_double_double
;
288 static tree int_ftype_int
, long_ftype_long
;
289 static tree float_ftype_float
;
290 static tree ldouble_ftype_ldouble
;
292 /* Function type `int (const void *, const void *, size_t)' */
293 static tree int_ftype_cptr_cptr_sizet
;
296 tree vtable_entry_type
;
297 tree delta_type_node
;
299 /* Old rtti stuff. */
300 tree __baselist_desc_type_node
;
301 tree __i_desc_type_node
, __m_desc_type_node
;
302 tree __t_desc_array_type
, __i_desc_array_type
, __m_desc_array_type
;
304 tree __t_desc_type_node
;
306 tree __tp_desc_type_node
;
308 tree __access_mode_type_node
;
309 tree __bltn_desc_type_node
, __user_desc_type_node
, __class_desc_type_node
;
310 tree __ptr_desc_type_node
, __attr_desc_type_node
, __func_desc_type_node
;
311 tree __ptmf_desc_type_node
, __ptmd_desc_type_node
;
313 /* Not needed yet? May be needed one day? */
314 tree __bltn_desc_array_type
, __user_desc_array_type
, __class_desc_array_type
;
315 tree __ptr_desc_array_type
, __attr_dec_array_type
, __func_desc_array_type
;
316 tree __ptmf_desc_array_type
, __ptmd_desc_array_type
;
319 /* Indicates that there is a type value in some namespace, although
320 that is not necessarily in scope at the moment. */
322 static tree global_type_node
;
324 tree class_star_type_node
;
325 tree class_type_node
, record_type_node
, union_type_node
, enum_type_node
;
326 tree unknown_type_node
;
327 tree opaque_type_node
, signature_type_node
;
328 tree sigtable_entry_type
;
330 /* Array type `vtable_entry_type[]' */
332 tree vtbl_ptr_type_node
;
338 /* Expect only namespace names now. */
339 static int only_namespace_names
;
341 /* In a destructor, the point at which all derived class destroying
342 has been done, just before any base class destroying will be done. */
346 /* In a destructor, the last insn emitted after the start of the
347 function and the parms. */
349 static rtx last_dtor_insn
;
351 /* In a constructor, the last insn emitted after the start of the
352 function and the parms, the exception specification and any
353 function-try-block. The constructor initializers are emitted after
356 static rtx last_parm_cleanup_insn
;
358 /* In a constructor, the point at which we are ready to return
359 the pointer to the initialized object. */
363 /* A FUNCTION_DECL which can call `abort'. Not necessarily the
364 one that the user will declare, but sufficient to be called
365 by routines that want to abort the program. */
369 extern rtx cleanup_label
, return_label
;
371 /* If original DECL_RESULT of current function was a register,
372 but due to being an addressable named return value, would up
373 on the stack, this variable holds the named return value's
374 original location. */
375 static rtx original_result_rtx
;
377 /* Sequence of insns which represents base initialization. */
380 /* C++: Keep these around to reduce calls to `get_identifier'.
381 Identifiers for `this' in member functions and the auto-delete
382 parameter for destructors. */
383 tree this_identifier
, in_charge_identifier
;
384 tree ctor_identifier
, dtor_identifier
;
385 /* Used in pointer to member functions, in vtables, and in sigtables. */
386 tree pfn_identifier
, index_identifier
, delta_identifier
, delta2_identifier
;
387 tree pfn_or_delta2_identifier
, tag_identifier
;
388 tree vt_off_identifier
;
390 struct named_label_list
392 struct binding_level
*binding_level
;
395 char *filename_o_goto
;
397 struct named_label_list
*next
;
400 /* A list (chain of TREE_LIST nodes) of named label uses.
401 The TREE_PURPOSE field is the list of variables defined
402 in the label's scope defined at the point of use.
403 The TREE_VALUE field is the LABEL_DECL used.
404 The TREE_TYPE field holds `current_binding_level' at the
405 point of the label's use.
407 BWAHAHAAHAHahhahahahaah. No, no, no, said the little chicken.
409 Look at the pretty struct named_label_list. See the pretty struct
410 with the pretty named fields that describe what they do. See the
411 pretty lack of gratuitous casts. Notice the code got a lot cleaner.
413 Used only for jumps to as-yet undefined labels, since
414 jumps to defined labels can have their validity checked
417 static struct named_label_list
*named_label_uses
= NULL
;
419 /* A list of objects which have constructors or destructors
420 which reside in the global scope. The decl is stored in
421 the TREE_VALUE slot and the initializer is stored
422 in the TREE_PURPOSE slot. */
423 tree static_aggregates
;
427 /* Two expressions that are constants with value zero.
428 The first is of type `int', the second of type `void *'. */
430 tree integer_zero_node
;
431 tree null_pointer_node
;
433 /* The value for __null (NULL), namely, a zero of an integer type with
434 the same number of bits as a pointer. */
437 /* A node for the integer constants 1, 2, and 3. */
439 tree integer_one_node
, integer_two_node
, integer_three_node
;
441 /* While defining an enum type, this is 1 plus the last enumerator
444 static tree enum_next_value
;
446 /* Nonzero means that there was overflow computing enum_next_value. */
448 static int enum_overflow
;
450 /* Parsing a function declarator leaves a list of parameter names
451 or a chain or parameter decls here. */
453 tree last_function_parms
;
455 /* Parsing a function declarator leaves here a chain of structure
456 and enum types declared in the parmlist. */
458 static tree last_function_parm_tags
;
460 /* After parsing the declarator that starts a function definition,
461 `start_function' puts here the list of parameter names or chain of decls.
462 `store_parm_decls' finds it here. */
464 static tree current_function_parms
;
466 /* Similar, for last_function_parm_tags. */
467 static tree current_function_parm_tags
;
469 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
470 that have names. Here so we can clear out their names' definitions
471 at the end of the function. */
473 static tree named_labels
;
475 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
477 static tree shadowed_labels
;
479 /* The FUNCTION_DECL for the function currently being compiled,
480 or 0 if between functions. */
481 tree current_function_decl
;
483 /* Set to 0 at beginning of a function definition, set to 1 if
484 a return statement that specifies a return value is seen. */
486 int current_function_returns_value
;
488 /* Set to 0 at beginning of a function definition, set to 1 if
489 a return statement with no argument is seen. */
491 int current_function_returns_null
;
493 /* Set to 0 at beginning of a function definition, and whenever
494 a label (case or named) is defined. Set to value of expression
495 returned from function when that value can be transformed into
496 a named return value. */
498 tree current_function_return_value
;
500 /* Set to nonzero by `grokdeclarator' for a function
501 whose return type is defaulted, if warnings for this are desired. */
503 static int warn_about_return_type
;
505 /* Nonzero means give `double' the same size as `float'. */
507 extern int flag_short_double
;
509 /* Nonzero means don't recognize any builtin functions. */
511 extern int flag_no_builtin
;
513 /* Nonzero means don't recognize the non-ANSI builtin functions.
516 extern int flag_no_nonansi_builtin
;
518 /* Nonzero means enable obscure ANSI features and disable GNU extensions
519 that might cause ANSI-compliant code to be miscompiled. */
521 extern int flag_ansi
;
523 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
525 extern int flag_huge_objects
;
527 /* Nonzero if we want to conserve space in the .o files. We do this
528 by putting uninitialized data and runtime initialized data into
529 .common instead of .data at the expense of not flagging multiple
531 extern int flag_conserve_space
;
533 /* Pointers to the base and current top of the language name stack. */
535 extern tree
*current_lang_base
, *current_lang_stack
;
537 /* C and C++ flags are in decl2.c. */
539 /* Set to 0 at beginning of a constructor, set to 1
540 if that function does an allocation before referencing its
541 instance variable. */
542 static int current_function_assigns_this
;
543 int current_function_just_assigned_this
;
545 /* Set to 0 at beginning of a function. Set non-zero when
546 store_parm_decls is called. Don't call store_parm_decls
547 if this flag is non-zero! */
548 int current_function_parms_stored
;
550 /* Flag used when debugging spew.c */
552 extern int spew_debug
;
554 /* This is a copy of the class_shadowed list of the previous class binding
555 contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
556 when entering another class scope (i.e. a cache miss). */
557 extern tree previous_class_values
;
559 /* A expression of value 0 with the same precision as a sizetype
561 tree signed_size_zero_node
;
563 /* The name of the anonymous namespace, throughout this translation
565 tree anonymous_namespace_name
;
568 /* Allocate a level of searching. */
572 push_decl_level (stack
, obstack
)
573 struct stack_level
*stack
;
574 struct obstack
*obstack
;
576 struct stack_level tem
;
579 return push_stack_level (obstack
, (char *)&tem
, sizeof (tem
));
582 /* For each binding contour we allocate a binding_level structure
583 which records the names defined in that contour.
586 1) one for each function definition,
587 where internal declarations of the parameters appear.
588 2) one for each compound statement,
589 to record its declarations.
591 The current meaning of a name can be found by searching the levels
592 from the current one out to the global one.
594 Off to the side, may be the class_binding_level. This exists only
595 to catch class-local declarations. It is otherwise nonexistent.
597 Also there may be binding levels that catch cleanups that must be
598 run when exceptions occur. */
600 /* Note that the information in the `names' component of the global contour
601 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
605 /* A chain of _DECL nodes for all variables, constants, functions,
606 and typedef types. These are in the reverse of the order
610 /* A list of structure, union and enum definitions, for looking up
612 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
613 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
614 or ENUMERAL_TYPE node.
616 C++: the TREE_VALUE nodes can be simple types for
617 component_bindings. */
620 /* A list of USING_DECL nodes. */
623 /* A list of used namespaces. PURPOSE is the namespace,
624 VALUE the common ancestor with this binding_level's namespace. */
625 tree using_directives
;
627 /* For each level, a list of shadowed outer-level local definitions
628 to be restored when this level is popped.
629 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
630 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
633 /* Same, for IDENTIFIER_CLASS_VALUE. */
636 /* Same, for IDENTIFIER_TYPE_VALUE. */
639 /* For each level (except not the global one),
640 a chain of BLOCK nodes for all the levels
641 that were entered and exited one level down. */
644 /* The BLOCK node for this level, if one has been preallocated.
645 If 0, the BLOCK is allocated (if needed) when the level is popped. */
648 /* The binding level which this one is contained in (inherits from). */
649 struct binding_level
*level_chain
;
651 /* List of decls in `names' that have incomplete
652 structure or union types. */
655 /* List of VAR_DECLS saved from a previous for statement.
656 These would be dead in ANSI-conforming code, but might
657 be referenced in ARM-era code. */
658 tree dead_vars_from_for
;
660 /* 1 for the level that holds the parameters of a function.
661 2 for the level that holds a class declaration.
662 3 for levels that hold parameter declarations. */
663 unsigned parm_flag
: 4;
665 /* 1 means make a BLOCK for this level regardless of all else.
666 2 for temporary binding contours created by the compiler. */
669 /* Nonzero if this level "doesn't exist" for tags. */
670 unsigned tag_transparent
: 1;
672 /* Nonzero if this level can safely have additional
673 cleanup-needing variables added to it. */
674 unsigned more_cleanups_ok
: 1;
675 unsigned have_cleanups
: 1;
677 /* Nonzero if this level is for storing the decls for template
678 parameters and generic decls; these decls will be discarded and
679 replaced with a TEMPLATE_DECL. */
680 unsigned pseudo_global
: 1;
682 /* This is set for a namespace binding level. */
683 unsigned namespace_p
: 1;
685 /* True if this level is that of a for-statement where we need to
686 worry about ambiguous (ARM or ANSI) scope rules. */
687 unsigned is_for_scope
: 1;
689 /* Two bits left for this word. */
691 #if defined(DEBUG_CP_BINDING_LEVELS)
692 /* Binding depth at which this level began. */
693 unsigned binding_depth
;
694 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
697 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
699 /* The (non-class) binding level currently in effect. */
701 static struct binding_level
*current_binding_level
;
703 /* The binding level of the current class, if any. */
705 static struct binding_level
*class_binding_level
;
707 /* The current (class or non-class) binding level currently in effect. */
709 #define inner_binding_level \
710 (class_binding_level ? class_binding_level : current_binding_level)
712 /* A chain of binding_level structures awaiting reuse. */
714 static struct binding_level
*free_binding_level
;
716 /* The outermost binding level, for names of file scope.
717 This is created when the compiler is started and exists
718 through the entire run. */
720 static struct binding_level
*global_binding_level
;
722 /* Binding level structures are initialized by copying this one. */
724 static struct binding_level clear_binding_level
;
726 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
728 static int keep_next_level_flag
;
730 #if defined(DEBUG_CP_BINDING_LEVELS)
731 static int binding_depth
= 0;
732 static int is_class_level
= 0;
739 for (i
= 0; i
< binding_depth
*2; i
++)
742 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
744 static tree pushdecl_with_scope
PROTO((tree
, struct binding_level
*));
747 push_binding_level (newlevel
, tag_transparent
, keep
)
748 struct binding_level
*newlevel
;
749 int tag_transparent
, keep
;
751 /* Add this level to the front of the chain (stack) of levels that
753 *newlevel
= clear_binding_level
;
754 if (class_binding_level
)
756 newlevel
->level_chain
= class_binding_level
;
757 class_binding_level
= (struct binding_level
*)0;
761 newlevel
->level_chain
= current_binding_level
;
763 current_binding_level
= newlevel
;
764 newlevel
->tag_transparent
= tag_transparent
;
765 newlevel
->more_cleanups_ok
= 1;
766 newlevel
->keep
= keep
;
767 #if defined(DEBUG_CP_BINDING_LEVELS)
768 newlevel
->binding_depth
= binding_depth
;
770 fprintf (stderr
, "push %s level 0x%08x line %d\n",
771 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
774 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
780 if (class_binding_level
)
781 current_binding_level
= class_binding_level
;
783 if (global_binding_level
)
785 /* Cannot pop a level, if there are none left to pop. */
786 if (current_binding_level
== global_binding_level
)
787 my_friendly_abort (123);
789 /* Pop the current level, and free the structure for reuse. */
790 #if defined(DEBUG_CP_BINDING_LEVELS)
793 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
794 (is_class_level
) ? "class" : "block",
795 current_binding_level
, lineno
);
796 if (is_class_level
!= (current_binding_level
== class_binding_level
))
799 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
802 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
804 register struct binding_level
*level
= current_binding_level
;
805 current_binding_level
= current_binding_level
->level_chain
;
806 level
->level_chain
= free_binding_level
;
807 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
808 if (level
->binding_depth
!= binding_depth
)
810 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
811 free_binding_level
= level
;
813 class_binding_level
= current_binding_level
;
814 if (class_binding_level
->parm_flag
!= 2)
815 class_binding_level
= 0;
816 while (current_binding_level
->parm_flag
== 2)
817 current_binding_level
= current_binding_level
->level_chain
;
822 suspend_binding_level ()
824 if (class_binding_level
)
825 current_binding_level
= class_binding_level
;
827 if (global_binding_level
)
829 /* Cannot suspend a level, if there are none left to suspend. */
830 if (current_binding_level
== global_binding_level
)
831 my_friendly_abort (123);
833 /* Suspend the current level. */
834 #if defined(DEBUG_CP_BINDING_LEVELS)
837 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
838 (is_class_level
) ? "class" : "block",
839 current_binding_level
, lineno
);
840 if (is_class_level
!= (current_binding_level
== class_binding_level
))
843 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
846 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
848 current_binding_level
= current_binding_level
->level_chain
;
849 class_binding_level
= current_binding_level
;
850 if (class_binding_level
->parm_flag
!= 2)
851 class_binding_level
= 0;
852 while (current_binding_level
->parm_flag
== 2)
853 current_binding_level
= current_binding_level
->level_chain
;
858 resume_binding_level (b
)
859 struct binding_level
*b
;
861 /* Resuming binding levels is meant only for namespaces,
862 and those cannot nest into classes. */
863 my_friendly_assert(!class_binding_level
, 386);
864 /* Also, resuming a non-directly nested namespace is a no-no. */
865 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
866 current_binding_level
= b
;
867 #if defined(DEBUG_CP_BINDING_LEVELS)
868 b
->binding_depth
= binding_depth
;
870 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
871 (is_class_level
) ? "class" : "block", b
, lineno
);
874 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
877 /* Create a new `struct binding_level'. */
880 struct binding_level
*
881 make_binding_level ()
884 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
887 /* Nonzero if we are currently in the global binding level. */
892 return current_binding_level
== global_binding_level
;
895 /* Nonzero if we are currently in a toplevel binding level. This
896 means either the global binding level or a namespace in a toplevel
898 Since there are no non-toplevel namespace levels, this really
899 means any namespace or pseudo-global level. */
902 toplevel_bindings_p ()
904 return current_binding_level
->namespace_p
905 || current_binding_level
->pseudo_global
;
908 /* Nonzero if this is a namespace scope. */
911 namespace_bindings_p ()
913 return current_binding_level
->namespace_p
;
919 keep_next_level_flag
= 1;
922 /* Nonzero if the current level needs to have a BLOCK made. */
927 return (current_binding_level
->blocks
!= NULL_TREE
928 || current_binding_level
->keep
929 || current_binding_level
->names
!= NULL_TREE
930 || (current_binding_level
->tags
!= NULL_TREE
931 && !current_binding_level
->tag_transparent
));
934 /* Identify this binding level as a level of parameters. */
937 declare_parm_level ()
939 current_binding_level
->parm_flag
= 1;
943 declare_pseudo_global_level ()
945 current_binding_level
->pseudo_global
= 1;
949 declare_namespace_level ()
951 current_binding_level
->namespace_p
= 1;
955 pseudo_global_level_p ()
957 return current_binding_level
->pseudo_global
;
961 set_class_shadows (shadows
)
964 class_binding_level
->class_shadowed
= shadows
;
967 /* Enter a new binding level.
968 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
969 not for that of tags. */
972 pushlevel (tag_transparent
)
975 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
977 /* If this is the top level of a function,
978 just make sure that NAMED_LABELS is 0.
979 They should have been set to 0 at the end of the previous function. */
981 if (current_binding_level
== global_binding_level
)
982 my_friendly_assert (named_labels
== NULL_TREE
, 134);
984 /* Reuse or create a struct for this binding level. */
986 #if defined(DEBUG_CP_BINDING_LEVELS)
988 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
989 if (free_binding_level
)
990 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
992 newlevel
= free_binding_level
;
993 free_binding_level
= free_binding_level
->level_chain
;
997 newlevel
= make_binding_level ();
1000 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
1001 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
1002 keep_next_level_flag
= 0;
1006 note_level_for_for ()
1008 current_binding_level
->is_for_scope
= 1;
1012 pushlevel_temporary (tag_transparent
)
1013 int tag_transparent
;
1015 pushlevel (tag_transparent
);
1016 current_binding_level
->keep
= 2;
1019 /* Note we don't call push_momentary() here. Otherwise, it would cause
1020 cleanups to be allocated on the momentary obstack, and they will be
1021 overwritten by the next statement. */
1023 expand_start_bindings (0);
1026 /* Exit a binding level.
1027 Pop the level off, and restore the state of the identifier-decl mappings
1028 that were in effect when this level was entered.
1030 If KEEP == 1, this level had explicit declarations, so
1031 and create a "block" (a BLOCK node) for the level
1032 to record its declarations and subblocks for symbol table output.
1034 If KEEP == 2, this level's subblocks go to the front,
1035 not the back of the current binding level. This happens,
1036 for instance, when code for constructors and destructors
1037 need to generate code at the end of a function which must
1038 be moved up to the front of the function.
1040 If FUNCTIONBODY is nonzero, this level is the body of a function,
1041 so create a block as if KEEP were set and also clear out all
1044 If REVERSE is nonzero, reverse the order of decls before putting
1045 them into the BLOCK. */
1048 poplevel (keep
, reverse
, functionbody
)
1054 /* The chain of decls was accumulated in reverse order.
1055 Put it into forward order, just for cleanliness. */
1057 int tmp
= functionbody
;
1058 int real_functionbody
= current_binding_level
->keep
== 2
1059 ? ((functionbody
= 0), tmp
) : functionbody
;
1060 tree tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1061 tree subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1062 tree block
= NULL_TREE
;
1064 int block_previously_created
;
1066 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1067 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1068 current_binding_level
->parm_flag
,
1069 current_binding_level
->keep
);
1071 if (current_binding_level
->keep
== 1)
1074 /* Get the decls in the order they were written.
1075 Usually current_binding_level->names is in reverse order.
1076 But parameter decls were previously put in forward order. */
1079 current_binding_level
->names
1080 = decls
= nreverse (current_binding_level
->names
);
1082 decls
= current_binding_level
->names
;
1084 /* Output any nested inline functions within this block
1085 if they weren't already output. */
1087 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1088 if (TREE_CODE (decl
) == FUNCTION_DECL
1089 && ! TREE_ASM_WRITTEN (decl
)
1090 && DECL_INITIAL (decl
) != NULL_TREE
1091 && TREE_ADDRESSABLE (decl
)
1092 && decl_function_context (decl
) == current_function_decl
)
1094 /* If this decl was copied from a file-scope decl
1095 on account of a block-scope extern decl,
1096 propagate TREE_ADDRESSABLE to the file-scope decl. */
1097 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1098 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1101 push_function_context ();
1102 output_inline_function (decl
);
1103 pop_function_context ();
1107 /* If there were any declarations or structure tags in that level,
1108 or if this level is a function body,
1109 create a BLOCK to record them for the life of this function. */
1112 block_previously_created
= (current_binding_level
->this_block
!= NULL_TREE
);
1113 if (block_previously_created
)
1114 block
= current_binding_level
->this_block
;
1115 else if (keep
== 1 || functionbody
)
1116 block
= make_node (BLOCK
);
1117 if (block
!= NULL_TREE
)
1119 if (block_previously_created
)
1121 if (decls
|| tags
|| subblocks
)
1123 if (BLOCK_VARS (block
) || BLOCK_TYPE_TAGS (block
))
1125 warning ("internal compiler error: debugging info corrupted");
1127 BLOCK_VARS (block
) = decls
;
1128 BLOCK_TYPE_TAGS (block
) = tags
;
1130 /* We can have previous subblocks and new subblocks when
1131 doing fixup_gotos with complex cleanups. We chain the new
1132 subblocks onto the end of any pre-existing subblocks. */
1133 BLOCK_SUBBLOCKS (block
) = chainon (BLOCK_SUBBLOCKS (block
),
1136 /* If we created the block earlier on, and we are just
1137 diddling it now, then it already should have a proper
1138 BLOCK_END_NOTE value associated with it. */
1142 BLOCK_VARS (block
) = decls
;
1143 BLOCK_TYPE_TAGS (block
) = tags
;
1144 BLOCK_SUBBLOCKS (block
) = subblocks
;
1145 /* Otherwise, for a new block, install a new BLOCK_END_NOTE value. */
1146 remember_end_note (block
);
1150 /* In each subblock, record that this is its superior. */
1153 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1154 BLOCK_SUPERCONTEXT (link
) = block
;
1156 /* Clear out the meanings of the local variables of this level. */
1158 if (current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1)
1160 struct binding_level
*outer
= current_binding_level
->level_chain
;
1161 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1163 if (TREE_CODE (link
) == VAR_DECL
)
1164 DECL_DEAD_FOR_LOCAL (link
) = 1;
1166 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = NULL_TREE
;
1169 /* Save declarations made in a 'for' statement so we can support pre-ANSI
1170 'for' scoping semantics. */
1172 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1174 tree id
= TREE_PURPOSE (link
);
1175 tree decl
= IDENTIFIER_LOCAL_VALUE (id
);
1177 if (decl
&& DECL_DEAD_FOR_LOCAL (decl
))
1179 /* In this case keep the dead for-decl visible,
1180 but remember what (if anything) it shadowed. */
1181 DECL_SHADOWED_FOR_VAR (decl
) = TREE_VALUE (link
);
1182 TREE_CHAIN (decl
) = outer
->dead_vars_from_for
;
1183 outer
->dead_vars_from_for
= decl
;
1186 IDENTIFIER_LOCAL_VALUE (id
) = TREE_VALUE (link
);
1189 else /* Not special for scope. */
1191 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1193 if (DECL_NAME (link
) != NULL_TREE
)
1195 /* If the ident. was used or addressed via a local extern decl,
1196 don't forget that fact. */
1197 if (DECL_EXTERNAL (link
))
1199 if (TREE_USED (link
))
1200 TREE_USED (DECL_ASSEMBLER_NAME (link
)) = 1;
1201 if (TREE_ADDRESSABLE (link
))
1202 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1204 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = NULL_TREE
;
1208 /* Restore all name-meanings of the outer levels
1209 that were shadowed by this level. */
1211 for (link
= current_binding_level
->shadowed
;
1212 link
; link
= TREE_CHAIN (link
))
1213 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1215 /* We first restore the regular decls and *then* the dead_vars_from_for
1216 to handle this case:
1220 for (int i; ; ) { ...} // i#2
1224 In this case, we want remove the binding for i#3, restoring
1225 that of i#2. Then we want to remove the binding for i#2,
1226 and restore that of i#1. */
1228 link
= current_binding_level
->dead_vars_from_for
;
1229 for (; link
!= NULL_TREE
; link
= TREE_CHAIN (link
))
1231 tree id
= DECL_NAME (link
);
1232 if (IDENTIFIER_LOCAL_VALUE (id
) == link
)
1233 IDENTIFIER_LOCAL_VALUE (id
) = DECL_SHADOWED_FOR_VAR (link
);
1236 for (link
= current_binding_level
->class_shadowed
;
1237 link
; link
= TREE_CHAIN (link
))
1238 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1239 for (link
= current_binding_level
->type_shadowed
;
1240 link
; link
= TREE_CHAIN (link
))
1241 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1244 /* If the level being exited is the top level of a function,
1245 check over all the labels. */
1249 /* If this is the top level block of a function,
1250 the vars are the function's parameters.
1251 Don't leave them in the BLOCK because they are
1252 found in the FUNCTION_DECL instead. */
1254 BLOCK_VARS (block
) = 0;
1256 /* Clear out the definitions of all label names,
1257 since their scopes end here. */
1259 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1261 register tree label
= TREE_VALUE (link
);
1263 if (DECL_INITIAL (label
) == NULL_TREE
)
1265 cp_error_at ("label `%D' used but not defined", label
);
1266 /* Avoid crashing later. */
1267 define_label (input_filename
, 1, DECL_NAME (label
));
1269 else if (warn_unused
&& !TREE_USED (label
))
1270 cp_warning_at ("label `%D' defined but not used", label
);
1271 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), NULL_TREE
);
1273 /* Put the labels into the "variables" of the
1274 top-level block, so debugger can see them. */
1275 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1276 BLOCK_VARS (block
) = label
;
1279 named_labels
= NULL_TREE
;
1282 /* Any uses of undefined labels now operate under constraints
1283 of next binding contour. */
1285 struct binding_level
*level_chain
;
1286 level_chain
= current_binding_level
->level_chain
;
1289 struct named_label_list
*labels
;
1290 for (labels
= named_label_uses
; labels
; labels
= labels
->next
)
1291 if (labels
->binding_level
== current_binding_level
)
1293 labels
->binding_level
= level_chain
;
1294 labels
->names_in_scope
= level_chain
->names
;
1299 tmp
= current_binding_level
->keep
;
1301 pop_binding_level ();
1303 DECL_INITIAL (current_function_decl
) = block
;
1306 if (!block_previously_created
)
1307 current_binding_level
->blocks
1308 = chainon (current_binding_level
->blocks
, block
);
1310 /* If we did not make a block for the level just exited,
1311 any blocks made for inner levels
1312 (since they cannot be recorded as subblocks in that level)
1313 must be carried forward so they will later become subblocks
1314 of something else. */
1318 current_binding_level
->blocks
1319 = chainon (subblocks
, current_binding_level
->blocks
);
1321 current_binding_level
->blocks
1322 = chainon (current_binding_level
->blocks
, subblocks
);
1325 /* Take care of compiler's internal binding structures. */
1328 expand_end_bindings (getdecls (), keep
, 1);
1329 /* Each and every BLOCK node created here in `poplevel' is important
1330 (e.g. for proper debugging information) so if we created one
1331 earlier, mark it as "used". */
1333 TREE_USED (block
) = 1;
1334 block
= poplevel (keep
, reverse
, real_functionbody
);
1337 /* Each and every BLOCK node created here in `poplevel' is important
1338 (e.g. for proper debugging information) so if we created one
1339 earlier, mark it as "used". */
1341 TREE_USED (block
) = 1;
1345 /* Delete the node BLOCK from the current binding level.
1346 This is used for the block inside a stmt expr ({...})
1347 so that the block can be reinserted where appropriate. */
1350 delete_block (block
)
1354 if (current_binding_level
->blocks
== block
)
1355 current_binding_level
->blocks
= TREE_CHAIN (block
);
1356 for (t
= current_binding_level
->blocks
; t
;)
1358 if (TREE_CHAIN (t
) == block
)
1359 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1363 TREE_CHAIN (block
) = NULL_TREE
;
1364 /* Clear TREE_USED which is always set by poplevel.
1365 The flag is set again if insert_block is called. */
1366 TREE_USED (block
) = 0;
1369 /* Insert BLOCK at the end of the list of subblocks of the
1370 current binding level. This is used when a BIND_EXPR is expanded,
1371 to handle the BLOCK node inside the BIND_EXPR. */
1374 insert_block (block
)
1377 TREE_USED (block
) = 1;
1378 current_binding_level
->blocks
1379 = chainon (current_binding_level
->blocks
, block
);
1382 /* Set the BLOCK node for the innermost scope
1383 (the one we are currently in). */
1387 register tree block
;
1389 current_binding_level
->this_block
= block
;
1392 /* Do a pushlevel for class declarations. */
1397 register struct binding_level
*newlevel
;
1399 /* Reuse or create a struct for this binding level. */
1400 #if defined(DEBUG_CP_BINDING_LEVELS)
1402 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1403 if (free_binding_level
)
1404 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1406 newlevel
= free_binding_level
;
1407 free_binding_level
= free_binding_level
->level_chain
;
1411 newlevel
= make_binding_level ();
1414 #if defined(DEBUG_CP_BINDING_LEVELS)
1416 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1418 push_binding_level (newlevel
, 0, 0);
1420 decl_stack
= push_decl_level (decl_stack
, &decl_obstack
);
1421 class_binding_level
= current_binding_level
;
1422 class_binding_level
->parm_flag
= 2;
1423 /* We have just pushed into a new binding level. Now, fake out the rest
1424 of the compiler. Set the `current_binding_level' back to point to
1425 the most closely containing non-class binding level. */
1428 current_binding_level
= current_binding_level
->level_chain
;
1430 while (current_binding_level
->parm_flag
== 2);
1433 /* ...and a poplevel for class declarations. FORCE is used to force
1434 clearing out of CLASS_VALUEs after a class definition. */
1437 poplevel_class (force
)
1440 register struct binding_level
*level
= class_binding_level
;
1441 tree block
= NULL_TREE
;
1444 my_friendly_assert (level
!= 0, 354);
1446 decl_stack
= pop_stack_level (decl_stack
);
1447 for (shadowed
= level
->shadowed
; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
1448 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed
)) = TREE_VALUE (shadowed
);
1449 /* If we're leaving a toplevel class, don't bother to do the setting
1450 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1451 shouldn't even be used when current_class_type isn't set, and second,
1452 if we don't touch it here, we're able to use the cache effect if the
1453 next time we're entering a class scope, it is the same class. */
1454 if (current_class_depth
!= 1 || force
)
1455 for (shadowed
= level
->class_shadowed
;
1457 shadowed
= TREE_CHAIN (shadowed
))
1458 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = TREE_VALUE (shadowed
);
1460 /* Remember to save what IDENTIFIER's were bound in this scope so we
1461 can recover from cache misses. */
1463 previous_class_type
= current_class_type
;
1464 previous_class_values
= class_binding_level
->class_shadowed
;
1466 for (shadowed
= level
->type_shadowed
;
1468 shadowed
= TREE_CHAIN (shadowed
))
1469 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1471 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1472 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1473 class_binding_level
->parm_flag
,
1474 class_binding_level
->keep
);
1476 if (class_binding_level
->parm_flag
!= 2)
1477 class_binding_level
= (struct binding_level
*)0;
1479 /* Now, pop out of the binding level which we created up in the
1480 `pushlevel_class' routine. */
1481 #if defined(DEBUG_CP_BINDING_LEVELS)
1483 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1485 pop_binding_level ();
1490 /* For debugging. */
1491 static int no_print_functions
= 0;
1492 static int no_print_builtins
= 0;
1495 print_binding_level (lvl
)
1496 struct binding_level
*lvl
;
1500 fprintf (stderr
, " blocks=");
1501 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
1502 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
1503 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
1504 if (lvl
->tag_transparent
)
1505 fprintf (stderr
, " tag-transparent");
1506 if (lvl
->more_cleanups_ok
)
1507 fprintf (stderr
, " more-cleanups-ok");
1508 if (lvl
->have_cleanups
)
1509 fprintf (stderr
, " have-cleanups");
1510 fprintf (stderr
, "\n");
1513 fprintf (stderr
, " names:\t");
1514 /* We can probably fit 3 names to a line? */
1515 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1517 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1519 if (no_print_builtins
1520 && (TREE_CODE (t
) == TYPE_DECL
)
1521 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
1524 /* Function decls tend to have longer names. */
1525 if (TREE_CODE (t
) == FUNCTION_DECL
)
1532 fprintf (stderr
, "\n\t");
1535 print_node_brief (stderr
, "", t
, 0);
1536 if (t
== error_mark_node
)
1540 fprintf (stderr
, "\n");
1544 fprintf (stderr
, " tags:\t");
1546 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
1548 if (TREE_PURPOSE (t
) == NULL_TREE
)
1550 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
1557 fprintf (stderr
, "\n\t");
1560 if (TREE_PURPOSE (t
) == NULL_TREE
)
1562 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
1563 fprintf (stderr
, ">");
1565 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
1566 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
1569 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
1570 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
1571 fprintf (stderr
, ">");
1575 fprintf (stderr
, "\n");
1579 fprintf (stderr
, " shadowed:");
1580 for (t
= lvl
->shadowed
; t
; t
= TREE_CHAIN (t
))
1582 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1584 fprintf (stderr
, "\n");
1586 if (lvl
->class_shadowed
)
1588 fprintf (stderr
, " class-shadowed:");
1589 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
1591 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1593 fprintf (stderr
, "\n");
1595 if (lvl
->type_shadowed
)
1597 fprintf (stderr
, " type-shadowed:");
1598 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1600 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1602 fprintf (stderr
, "\n");
1607 print_other_binding_stack (stack
)
1608 struct binding_level
*stack
;
1610 struct binding_level
*level
;
1611 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
1613 fprintf (stderr
, "binding level ");
1614 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
1615 fprintf (stderr
, "\n");
1616 print_binding_level (level
);
1621 print_binding_stack ()
1623 struct binding_level
*b
;
1624 fprintf (stderr
, "current_binding_level=");
1625 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
1626 fprintf (stderr
, "\nclass_binding_level=");
1627 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
1628 fprintf (stderr
, "\nglobal_binding_level=");
1629 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
1630 fprintf (stderr
, "\n");
1631 if (class_binding_level
)
1633 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1634 if (b
== current_binding_level
)
1637 b
= class_binding_level
;
1639 b
= current_binding_level
;
1642 b
= current_binding_level
;
1643 print_other_binding_stack (b
);
1644 fprintf (stderr
, "global:\n");
1645 print_binding_level (global_binding_level
);
1648 /* Namespace binding access routines: The namespace_bindings field of
1649 the identifier is polymorphic, with three possible values:
1650 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1651 indicating the BINDING_VALUE of global_namespace. */
1653 /* Check whether the a binding for the name to scope is known.
1654 Assumes that the bindings of the name are already a list
1655 of bindings. Returns the binding found, or NULL_TREE. */
1658 find_binding (name
, scope
)
1662 tree iter
, prev
= NULL_TREE
;
1664 scope
= ORIGINAL_NAMESPACE (scope
);
1666 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
1667 iter
= TREE_CHAIN (iter
))
1669 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
1670 if (BINDING_SCOPE (iter
) == scope
)
1672 /* Move binding found to the fron of the list, so
1673 subsequent lookups will find it faster. */
1676 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
1677 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
1678 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
1687 /* Always returns a binding for name in scope. If the
1688 namespace_bindings is not a list, convert it to one first.
1689 If no binding is found, make a new one. */
1692 binding_for_name (name
, scope
)
1696 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1699 scope
= ORIGINAL_NAMESPACE (scope
);
1701 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
1703 /* Get rid of optimization for global scope. */
1704 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
1705 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
1706 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1708 if (b
&& (result
= find_binding (name
, scope
)))
1710 /* Not found, make a new permanent one. */
1711 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1712 result
= make_node (CPLUS_BINDING
);
1713 TREE_CHAIN (result
) = b
;
1714 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1715 BINDING_SCOPE (result
) = scope
;
1716 BINDING_TYPE (result
) = NULL_TREE
;
1717 BINDING_VALUE (result
) = NULL_TREE
;
1722 /* Return the binding value for name in scope, considering that
1723 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
1726 namespace_binding (name
, scope
)
1730 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1733 if (scope
== NULL_TREE
)
1734 scope
= global_namespace
;
1735 if (TREE_CODE (b
) != CPLUS_BINDING
)
1736 return (scope
== global_namespace
) ? b
: NULL_TREE
;
1737 name
= find_binding (name
,scope
);
1738 if (name
== NULL_TREE
)
1740 return BINDING_VALUE (name
);
1743 /* Set the binding value for name in scope. If modifying the binding
1744 of global_namespace is attempted, try to optimize it. */
1747 set_namespace_binding (name
, scope
, val
)
1754 if (scope
== NULL_TREE
)
1755 scope
= global_namespace
;
1757 if (scope
== global_namespace
)
1759 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1760 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
1762 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
1766 b
= binding_for_name (name
, scope
);
1767 BINDING_VALUE (b
) = val
;
1770 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
1771 select a name that is unique to this compilation unit. */
1774 push_namespace (name
)
1779 int implicit_use
= 0;
1781 if (!global_namespace
)
1783 /* This must be ::. */
1784 my_friendly_assert (name
== get_identifier ("::"), 377);
1789 /* The name of anonymous namespace is unique for the translation
1791 if (!anonymous_namespace_name
)
1792 anonymous_namespace_name
= get_file_function_name ('N');
1793 name
= anonymous_namespace_name
;
1794 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
1796 /* Reopening anonymous namespace. */
1800 else if (current_namespace
== global_namespace
1801 && name
== DECL_NAME (std_node
))
1808 /* Check whether this is an extended namespace definition. */
1809 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
1810 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
1813 if (DECL_NAMESPACE_ALIAS (d
))
1815 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
1816 d
, DECL_NAMESPACE_ALIAS (d
));
1817 d
= DECL_NAMESPACE_ALIAS (d
);
1824 /* Make a new namespace, binding the name to it. */
1825 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
1826 /* The global namespace is not pushed, and the global binding
1827 level is set elsewhere. */
1832 declare_namespace_level ();
1833 NAMESPACE_LEVEL (d
) = current_binding_level
;
1837 resume_binding_level (NAMESPACE_LEVEL (d
));
1840 do_using_directive (d
);
1841 /* Enter the name space. */
1842 current_namespace
= d
;
1845 /* Pop from the scope of the current namespace. */
1850 if (current_namespace
== global_namespace
)
1852 my_friendly_assert (in_std
>0, 980421);
1856 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
1857 /* The binding level is not popped, as it might be re-opened later. */
1858 suspend_binding_level ();
1861 /* Concatenate the binding levels of all namespaces. */
1864 cat_namespace_levels()
1868 struct binding_level
*b
;
1870 last
= NAMESPACE_LEVEL (global_namespace
) -> names
;
1871 /* The nested namespaces appear in the names list of their ancestors. */
1872 for (current
= last
; current
; current
= TREE_CHAIN (current
))
1874 if (TREE_CODE (current
) != NAMESPACE_DECL
1875 || DECL_NAMESPACE_ALIAS (current
))
1877 if (!DECL_LANG_SPECIFIC (current
))
1880 my_friendly_assert (current
== std_node
, 393);
1883 b
= NAMESPACE_LEVEL (current
);
1884 while (TREE_CHAIN (last
))
1885 last
= TREE_CHAIN (last
);
1886 TREE_CHAIN (last
) = NAMESPACE_LEVEL (current
) -> names
;
1890 /* Subroutines for reverting temporarily to top-level for instantiation
1891 of templates and such. We actually need to clear out the class- and
1892 local-value slots of all identifiers, so that only the global values
1893 are at all visible. Simply setting current_binding_level to the global
1894 scope isn't enough, because more binding levels may be pushed. */
1895 struct saved_scope
{
1896 struct binding_level
*old_binding_level
;
1899 struct saved_scope
*prev
;
1900 tree class_name
, class_type
;
1901 tree access_specifier
;
1903 struct binding_level
*class_bindings
;
1904 tree
*lang_base
, *lang_stack
, lang_name
;
1906 int minimal_parse_mode
;
1907 tree last_function_parms
;
1908 tree template_parms
;
1909 HOST_WIDE_INT processing_template_decl
;
1910 tree previous_class_type
, previous_class_values
;
1911 int processing_specialization
;
1912 int processing_explicit_instantiation
;
1914 static struct saved_scope
*current_saved_scope
;
1916 /* A chain of the binding vecs created by store_bindings. We create a
1917 whole bunch of these during compilation, on permanent_obstack, so we
1918 can't just throw them away. */
1919 static tree free_binding_vecs
;
1922 store_bindings (names
, old_bindings
)
1923 tree names
, old_bindings
;
1926 for (t
= names
; t
; t
= TREE_CHAIN (t
))
1928 tree binding
, t1
, id
;
1930 if (TREE_CODE (t
) == TREE_LIST
)
1931 id
= TREE_PURPOSE (t
);
1936 || (!IDENTIFIER_LOCAL_VALUE (id
)
1937 && !IDENTIFIER_CLASS_VALUE (id
)))
1940 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
1941 if (TREE_VEC_ELT (t1
, 0) == id
)
1944 if (free_binding_vecs
)
1946 binding
= free_binding_vecs
;
1947 free_binding_vecs
= TREE_CHAIN (free_binding_vecs
);
1950 binding
= make_tree_vec (4);
1954 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
1955 TREE_VEC_ELT (binding
, 0) = id
;
1956 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
1957 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_LOCAL_VALUE (id
);
1958 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
1959 IDENTIFIER_LOCAL_VALUE (id
) = NULL_TREE
;
1960 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
1962 TREE_CHAIN (binding
) = old_bindings
;
1963 old_bindings
= binding
;
1967 return old_bindings
;
1971 maybe_push_to_top_level (pseudo
)
1974 extern int current_lang_stacksize
;
1975 struct saved_scope
*s
1976 = (struct saved_scope
*) xmalloc (sizeof (struct saved_scope
));
1977 struct binding_level
*b
= inner_binding_level
;
1978 tree old_bindings
= NULL_TREE
;
1980 if (current_function_decl
)
1981 push_cp_function_context (NULL_TREE
);
1983 if (previous_class_type
)
1984 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
1986 /* Have to include global_binding_level, because class-level decls
1987 aren't listed anywhere useful. */
1988 for (; b
; b
= b
->level_chain
)
1992 /* Template IDs are inserted into the global level. If they were
1993 inserted into namespace level, finish_file wouldn't find them
1994 when doing pending instantiations. Therefore, don't stop at
1995 namespace level, but continue until :: . */
1996 if (b
== global_binding_level
|| (pseudo
&& b
->pseudo_global
))
1999 old_bindings
= store_bindings (b
->names
, old_bindings
);
2000 /* We also need to check class_shadowed to save class-level type
2001 bindings, since pushclass doesn't fill in b->names. */
2002 if (b
->parm_flag
== 2)
2003 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2005 /* Unwind type-value slots back to top level. */
2006 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2007 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2010 s
->old_binding_level
= current_binding_level
;
2011 current_binding_level
= b
;
2013 s
->old_namespace
= current_namespace
;
2014 s
->class_name
= current_class_name
;
2015 s
->class_type
= current_class_type
;
2016 s
->access_specifier
= current_access_specifier
;
2017 s
->function_decl
= current_function_decl
;
2018 s
->class_bindings
= class_binding_level
;
2019 s
->lang_stack
= current_lang_stack
;
2020 s
->lang_base
= current_lang_base
;
2021 s
->lang_stacksize
= current_lang_stacksize
;
2022 s
->lang_name
= current_lang_name
;
2023 s
->minimal_parse_mode
= minimal_parse_mode
;
2024 s
->last_function_parms
= last_function_parms
;
2025 s
->template_parms
= current_template_parms
;
2026 s
->processing_template_decl
= processing_template_decl
;
2027 s
->previous_class_type
= previous_class_type
;
2028 s
->previous_class_values
= previous_class_values
;
2029 s
->processing_specialization
= processing_specialization
;
2030 s
->processing_explicit_instantiation
= processing_explicit_instantiation
;
2032 current_class_name
= current_class_type
= NULL_TREE
;
2033 current_function_decl
= NULL_TREE
;
2034 class_binding_level
= (struct binding_level
*)0;
2035 current_lang_stacksize
= 10;
2036 current_lang_stack
= current_lang_base
2037 = (tree
*) xmalloc (current_lang_stacksize
* sizeof (tree
));
2038 current_lang_name
= lang_name_cplusplus
;
2039 strict_prototype
= strict_prototypes_lang_cplusplus
;
2040 named_labels
= NULL_TREE
;
2041 shadowed_labels
= NULL_TREE
;
2042 minimal_parse_mode
= 0;
2043 previous_class_type
= previous_class_values
= NULL_TREE
;
2044 processing_specialization
= 0;
2045 processing_explicit_instantiation
= 0;
2046 current_template_parms
= NULL_TREE
;
2047 processing_template_decl
= 0;
2048 current_namespace
= global_namespace
;
2050 s
->prev
= current_saved_scope
;
2051 s
->old_bindings
= old_bindings
;
2052 current_saved_scope
= s
;
2054 push_obstacks (&permanent_obstack
, &permanent_obstack
);
2058 push_to_top_level ()
2060 maybe_push_to_top_level (0);
2064 pop_from_top_level ()
2066 extern int current_lang_stacksize
;
2067 struct saved_scope
*s
= current_saved_scope
;
2070 /* Clear out class-level bindings cache. */
2071 if (previous_class_type
)
2074 previous_class_type
= NULL_TREE
;
2079 current_binding_level
= s
->old_binding_level
;
2080 current_saved_scope
= s
->prev
;
2081 for (t
= s
->old_bindings
; t
; )
2084 tree id
= TREE_VEC_ELT (t
, 0);
2087 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2088 IDENTIFIER_LOCAL_VALUE (id
) = TREE_VEC_ELT (t
, 2);
2089 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2092 TREE_CHAIN (save
) = free_binding_vecs
;
2093 free_binding_vecs
= save
;
2095 current_namespace
= s
->old_namespace
;
2096 current_class_name
= s
->class_name
;
2097 current_class_type
= s
->class_type
;
2098 current_access_specifier
= s
->access_specifier
;
2099 current_function_decl
= s
->function_decl
;
2100 class_binding_level
= s
->class_bindings
;
2101 free (current_lang_base
);
2102 current_lang_base
= s
->lang_base
;
2103 current_lang_stack
= s
->lang_stack
;
2104 current_lang_name
= s
->lang_name
;
2105 current_lang_stacksize
= s
->lang_stacksize
;
2106 if (current_lang_name
== lang_name_cplusplus
)
2107 strict_prototype
= strict_prototypes_lang_cplusplus
;
2108 else if (current_lang_name
== lang_name_c
)
2109 strict_prototype
= strict_prototypes_lang_c
;
2110 minimal_parse_mode
= s
->minimal_parse_mode
;
2111 last_function_parms
= s
->last_function_parms
;
2112 current_template_parms
= s
->template_parms
;
2113 processing_template_decl
= s
->processing_template_decl
;
2114 previous_class_type
= s
->previous_class_type
;
2115 previous_class_values
= s
->previous_class_values
;
2116 processing_specialization
= s
->processing_specialization
;
2117 processing_explicit_instantiation
= s
->processing_explicit_instantiation
;
2121 if (current_function_decl
)
2122 pop_cp_function_context (NULL_TREE
);
2125 /* Push a definition of struct, union or enum tag "name".
2126 into binding_level "b". "type" should be the type node,
2127 We assume that the tag "name" is not already defined.
2129 Note that the definition may really be just a forward reference.
2130 In that case, the TYPE_SIZE will be a NULL_TREE.
2132 C++ gratuitously puts all these tags in the name space. */
2134 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2135 record the shadowed value for this binding contour. TYPE is
2136 the type that ID maps to. */
2139 set_identifier_type_value_with_scope (id
, type
, b
)
2142 struct binding_level
*b
;
2144 if (!b
->namespace_p
)
2146 /* Shadow the marker, not the real thing, so that the marker
2147 gets restored later. */
2148 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2150 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2154 tree binding
= binding_for_name (id
, current_namespace
);
2155 BINDING_TYPE (binding
) = type
;
2156 /* Store marker instead of real type. */
2157 type
= global_type_node
;
2159 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2162 /* As set_identifier_type_value_with_scope, but using inner_binding_level. */
2165 set_identifier_type_value (id
, type
)
2169 set_identifier_type_value_with_scope (id
, type
, inner_binding_level
);
2173 set_identifier_local_value_with_scope (id
, val
, b
)
2175 struct binding_level
*b
;
2178 my_friendly_assert (! b
->namespace_p
, 980716);
2180 oldlocal
= IDENTIFIER_LOCAL_VALUE (id
);
2181 b
->shadowed
= tree_cons (id
, oldlocal
, b
->shadowed
);
2182 IDENTIFIER_LOCAL_VALUE (id
) = val
;
2186 set_identifier_local_value (id
, val
)
2189 set_identifier_local_value_with_scope (id
, val
, current_binding_level
);
2192 /* Return the type associated with id. */
2195 identifier_type_value (id
)
2198 /* There is no type with that name, anywhere. */
2199 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2201 /* This is not the type marker, but the real thing. */
2202 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2203 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2204 /* Have to search for it. It must be on the global level, now.
2205 Ask lookup_name not to return non-types. */
2206 id
= lookup_name_real (id
, 2, 1, 0);
2208 return TREE_TYPE (id
);
2212 /* Pop off extraneous binding levels left over due to syntax errors.
2214 We don't pop past namespaces, as they might be valid. */
2219 #ifdef DEBUG_CP_BINDING_LEVELS
2220 fprintf (stderr
, "XXX entering pop_everything ()\n");
2222 while (! toplevel_bindings_p () && ! pseudo_global_level_p ())
2224 if (class_binding_level
)
2225 pop_nested_class (1);
2229 #ifdef DEBUG_CP_BINDING_LEVELS
2230 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2234 /* The type TYPE is being declared. If it is a class template, or a
2235 specialization of a class template, do any processing required and
2236 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2237 being declared a friend. B is the binding level at which this TYPE
2240 Returns the TYPE_DECL for TYPE, which may have been altered by this
2244 maybe_process_template_type_declaration (type
, globalize
, b
)
2247 struct binding_level
* b
;
2249 tree decl
= TYPE_NAME (type
);
2251 if (processing_template_parmlist
)
2252 /* You can't declare a new template type in a template parameter
2253 list. But, you can declare a non-template type:
2255 template <class A*> struct S;
2257 is a forward-declaration of `A'. */
2261 maybe_check_template_type (type
);
2263 my_friendly_assert (IS_AGGR_TYPE (type
)
2264 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2267 if (/* If !GLOBALIZE then we are looking at a definition.
2268 It may not be a primary template. (For example, in:
2271 struct S1 { class S2 {}; }
2273 we have to push_template_decl for S2.) */
2274 (processing_template_decl
&& !globalize
)
2275 /* If we are declaring a friend template class, we will
2276 have GLOBALIZE set, since something like:
2284 declares S2 to be at global scope. */
2285 || PROCESSING_REAL_TEMPLATE_DECL_P ())
2287 /* This may change after the call to
2288 push_template_decl_real, but we want the original value. */
2289 tree name
= DECL_NAME (decl
);
2291 decl
= push_template_decl_real (decl
, globalize
);
2292 /* If the current binding level is the binding level for the
2293 template parameters (see the comment in
2294 begin_template_parm_list) and the enclosing level is a class
2295 scope, and we're not looking at a friend, push the
2296 declaration of the member class into the class scope. In the
2297 friend case, push_template_decl will already have put the
2298 friend into global scope, if appropriate. */
2299 if (TREE_CODE (type
) != ENUMERAL_TYPE
2300 && !globalize
&& b
->pseudo_global
2301 && b
->level_chain
->parm_flag
== 2)
2303 pushdecl_with_scope (CLASSTYPE_TI_TEMPLATE (type
),
2305 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2306 /* Put this tag on the list of tags for the class, since
2307 that won't happen below because B is not the class
2308 binding level, but is instead the pseudo-global level. */
2309 b
->level_chain
->tags
=
2310 saveable_tree_cons (name
, type
, b
->level_chain
->tags
);
2311 TREE_NONLOCAL_FLAG (type
) = 1;
2312 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2313 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2321 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2322 Normally put it into the inner-most non-tag-transparent scope,
2323 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2324 The latter is needed for implicit declarations. */
2327 pushtag (name
, type
, globalize
)
2331 register struct binding_level
*b
;
2335 b
= inner_binding_level
;
2336 while (b
->tag_transparent
2337 || (globalize
&& b
->parm_flag
== 2))
2340 if (toplevel_bindings_p ())
2341 b
->tags
= perm_tree_cons (name
, type
, b
->tags
);
2343 b
->tags
= saveable_tree_cons (name
, type
, b
->tags
);
2347 context
= type
? TYPE_CONTEXT (type
) : NULL_TREE
;
2350 tree cs
= current_scope ();
2354 else if (cs
!= NULL_TREE
2355 && TREE_CODE_CLASS (TREE_CODE (cs
)) == 't')
2356 /* When declaring a friend class of a local class, we want
2357 to inject the newly named class into the scope
2358 containing the local class, not the namespace scope. */
2359 context
= hack_decl_function_context (get_type_decl (cs
));
2362 c_decl
= TREE_CODE (context
) == FUNCTION_DECL
2363 ? context
: TYPE_MAIN_DECL (context
);
2366 context
= current_namespace
;
2368 /* Do C++ gratuitous typedefing. */
2369 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2371 register tree d
= NULL_TREE
;
2372 int newdecl
= 0, in_class
= 0;
2374 if ((b
->pseudo_global
&& b
->level_chain
->parm_flag
== 2)
2375 || b
->parm_flag
== 2)
2378 d
= lookup_nested_type (type
, c_decl
);
2383 d
= build_decl (TYPE_DECL
, name
, type
);
2384 if (current_lang_name
== lang_name_java
)
2385 TYPE_FOR_JAVA (type
) = 1;
2386 SET_DECL_ARTIFICIAL (d
);
2388 set_identifier_type_value_with_scope (name
, type
, b
);
2391 d
= TYPE_MAIN_DECL (d
);
2393 TYPE_NAME (type
) = d
;
2394 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2396 d
= maybe_process_template_type_declaration (type
,
2399 if (b
->parm_flag
== 2)
2401 pushdecl_class_level (d
);
2402 if (newdecl
&& !PROCESSING_REAL_TEMPLATE_DECL_P ())
2403 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2404 class. But if it's a member template class, we
2405 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2407 finish_member_declaration (d
);
2410 d
= pushdecl_with_scope (d
, b
);
2414 if (ANON_AGGRNAME_P (name
))
2415 DECL_IGNORED_P (d
) = 1;
2417 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2418 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2419 if (!uses_template_parms (type
))
2420 DECL_ASSEMBLER_NAME (d
)
2421 = get_identifier (build_overload_name (type
, 1, 1));
2424 if (b
->parm_flag
== 2)
2426 TREE_NONLOCAL_FLAG (type
) = 1;
2427 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2428 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2432 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2433 /* Use the canonical TYPE_DECL for this node. */
2434 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2437 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2438 will be the tagged type we just added to the current
2439 binding level. This fake NULL-named TYPE_DECL node helps
2440 dwarfout.c to know when it needs to output a
2441 representation of a tagged type, and it also gives us a
2442 convenient place to record the "scope start" address for
2445 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2446 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2450 /* Counter used to create anonymous type names. */
2452 static int anon_cnt
= 0;
2454 /* Return an IDENTIFIER which can be used as a name for
2455 anonymous structs and unions. */
2462 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2463 return get_identifier (buf
);
2466 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2467 This keeps dbxout from getting confused. */
2472 register struct binding_level
*b
;
2474 static int last_cnt
= 0;
2476 /* Fast out if no new anon names were declared. */
2477 if (last_cnt
== anon_cnt
)
2480 b
= current_binding_level
;
2481 while (b
->tag_transparent
)
2486 /* A NULL purpose means we have already processed all tags
2487 from here to the end of the list. */
2488 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2490 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2491 TREE_PURPOSE (tags
) = NULL_TREE
;
2492 tags
= TREE_CHAIN (tags
);
2494 last_cnt
= anon_cnt
;
2497 /* Subroutine of duplicate_decls: return truthvalue of whether
2498 or not types of these decls match.
2500 For C++, we must compare the parameter list so that `int' can match
2501 `int&' in a parameter position, but `int&' is not confused with
2505 decls_match (newdecl
, olddecl
)
2506 tree newdecl
, olddecl
;
2510 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2511 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2513 tree f1
= TREE_TYPE (newdecl
);
2514 tree f2
= TREE_TYPE (olddecl
);
2515 tree p1
= TYPE_ARG_TYPES (f1
);
2516 tree p2
= TYPE_ARG_TYPES (f2
);
2518 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
)
2519 && ! (DECL_LANGUAGE (newdecl
) == lang_c
2520 && DECL_LANGUAGE (olddecl
) == lang_c
))
2523 /* When we parse a static member function definition,
2524 we put together a FUNCTION_DECL which thinks its type
2525 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
2527 if (TREE_CODE (f1
) == METHOD_TYPE
&& DECL_STATIC_FUNCTION_P (olddecl
))
2528 revert_static_member_fn (&newdecl
, &f1
, &p1
);
2529 else if (TREE_CODE (f2
) == METHOD_TYPE
2530 && DECL_STATIC_FUNCTION_P (newdecl
))
2531 revert_static_member_fn (&olddecl
, &f2
, &p2
);
2533 /* Here we must take care of the case where new default
2534 parameters are specified. Also, warn if an old
2535 declaration becomes ambiguous because default
2536 parameters may cause the two to be ambiguous. */
2537 if (TREE_CODE (f1
) != TREE_CODE (f2
))
2539 if (TREE_CODE (f1
) == OFFSET_TYPE
)
2540 cp_compiler_error ("`%D' redeclared as member function", newdecl
);
2542 cp_compiler_error ("`%D' redeclared as non-member function", newdecl
);
2546 if (comptypes (TREE_TYPE (f1
), TREE_TYPE (f2
), 1))
2548 if (! strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
) == lang_c
2551 types_match
= self_promoting_args_p (p1
);
2552 if (p1
== void_list_node
)
2553 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2555 else if (!strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
)==lang_c
2556 && DECL_LANGUAGE (newdecl
) == lang_c
&& p1
== NULL_TREE
)
2558 types_match
= self_promoting_args_p (p2
);
2559 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2562 types_match
= compparms (p1
, p2
, 3);
2567 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
2568 && TREE_CODE (olddecl
) == TEMPLATE_DECL
)
2570 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2571 DECL_TEMPLATE_PARMS (olddecl
)))
2574 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2577 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
2578 DECL_TEMPLATE_RESULT (newdecl
));
2582 if (TREE_TYPE (newdecl
) == error_mark_node
)
2583 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
2584 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
2585 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
2586 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
2589 types_match
= comptypes (TREE_TYPE (newdecl
),
2590 TREE_TYPE (olddecl
), 1);
2596 /* If NEWDECL is `static' and an `extern' was seen previously,
2597 warn about it. (OLDDECL may be NULL_TREE; NAME contains
2598 information about previous usage as an `extern'.)
2600 Note that this does not apply to the C++ case of declaring
2601 a variable `extern const' and then later `const'.
2603 Don't complain about built-in functions, since they are beyond
2604 the user's control. */
2607 warn_extern_redeclared_static (newdecl
, olddecl
)
2608 tree newdecl
, olddecl
;
2612 static char *explicit_extern_static_warning
2613 = "`%D' was declared `extern' and later `static'";
2614 static char *implicit_extern_static_warning
2615 = "`%D' was declared implicitly `extern' and later `static'";
2617 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2620 name
= DECL_ASSEMBLER_NAME (newdecl
);
2621 if (TREE_PUBLIC (name
) && DECL_THIS_STATIC (newdecl
))
2623 /* It's okay to redeclare an ANSI built-in function as static,
2624 or to declare a non-ANSI built-in function as anything. */
2625 if (! (TREE_CODE (newdecl
) == FUNCTION_DECL
2626 && olddecl
!= NULL_TREE
2627 && TREE_CODE (olddecl
) == FUNCTION_DECL
2628 && (DECL_BUILT_IN (olddecl
)
2629 || DECL_BUILT_IN_NONANSI (olddecl
))))
2631 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
2632 ? implicit_extern_static_warning
2633 : explicit_extern_static_warning
, newdecl
);
2634 if (olddecl
!= NULL_TREE
)
2635 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
2640 /* Handle when a new declaration NEWDECL has the same name as an old
2641 one OLDDECL in the same binding contour. Prints an error message
2644 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2645 Otherwise, return 0. */
2648 duplicate_decls (newdecl
, olddecl
)
2649 tree newdecl
, olddecl
;
2651 extern struct obstack permanent_obstack
;
2652 unsigned olddecl_uid
= DECL_UID (olddecl
);
2653 int olddecl_friend
= 0, types_match
= 0;
2654 int new_defines_function
= 0;
2656 if (newdecl
== olddecl
)
2659 types_match
= decls_match (newdecl
, olddecl
);
2661 /* If either the type of the new decl or the type of the old decl is an
2662 error_mark_node, then that implies that we have already issued an
2663 error (earlier) for some bogus type specification, and in that case,
2664 it is rather pointless to harass the user with yet more error message
2665 about the same declaration, so just pretend the types match here. */
2666 if (TREE_TYPE (newdecl
) == error_mark_node
2667 || TREE_TYPE (olddecl
) == error_mark_node
)
2670 /* Check for redeclaration and other discrepancies. */
2671 if (TREE_CODE (olddecl
) == FUNCTION_DECL
2672 && DECL_ARTIFICIAL (olddecl
)
2673 && (DECL_BUILT_IN (olddecl
) || DECL_BUILT_IN_NONANSI (olddecl
)))
2675 /* If you declare a built-in or predefined function name as static,
2676 the old definition is overridden, but optionally warn this was a
2677 bad choice of name. Ditto for overloads. */
2678 if (! TREE_PUBLIC (newdecl
)
2679 || (TREE_CODE (newdecl
) == FUNCTION_DECL
2680 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
)))
2683 cp_warning ("shadowing %s function `%#D'",
2684 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
2686 /* Discard the old built-in function. */
2689 else if (! types_match
)
2691 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
2693 /* If the built-in is not ansi, then programs can override
2694 it even globally without an error. */
2695 if (! DECL_BUILT_IN (olddecl
))
2696 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2700 cp_error ("declaration of `%#D'", newdecl
);
2701 cp_error ("conflicts with built-in declaration `%#D'",
2707 cp_warning ("declaration of `%#D'", newdecl
);
2708 cp_warning ("conflicts with built-in declaration `%#D'",
2712 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
2714 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
2715 && TREE_CODE (newdecl
) != TYPE_DECL
2716 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
2717 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
2718 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
2719 && TREE_CODE (olddecl
) != TYPE_DECL
2720 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
2721 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2724 /* We do nothing special here, because C++ does such nasty
2725 things with TYPE_DECLs. Instead, just let the TYPE_DECL
2726 get shadowed, and know that if we need to find a TYPE_DECL
2727 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
2728 slot of the identifier. */
2732 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
2733 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
2734 || (TREE_CODE (olddecl
) == FUNCTION_DECL
2735 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
2738 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
2739 if (TREE_CODE (olddecl
) == TREE_LIST
)
2740 olddecl
= TREE_VALUE (olddecl
);
2741 cp_error_at ("previous declaration of `%#D'", olddecl
);
2743 /* New decl is completely inconsistent with the old one =>
2744 tell caller to replace the old one. */
2748 else if (!types_match
)
2750 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2752 /* The name of a class template may not be declared to refer to
2753 any other template, class, function, object, namespace, value,
2754 or type in the same scope. */
2755 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
2756 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2758 cp_error ("declaration of template `%#D'", newdecl
);
2759 cp_error_at ("conflicts with previous declaration `%#D'",
2762 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
2763 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
2764 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
2765 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))), 3)
2766 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2767 DECL_TEMPLATE_PARMS (olddecl
)))
2769 cp_error ("new declaration `%#D'", newdecl
);
2770 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
2774 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2776 if (DECL_LANGUAGE (newdecl
) == lang_c
2777 && DECL_LANGUAGE (olddecl
) == lang_c
)
2779 cp_error ("declaration of C function `%#D' conflicts with",
2781 cp_error_at ("previous declaration `%#D' here", olddecl
);
2783 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
2784 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)), 3))
2786 cp_error ("new declaration `%#D'", newdecl
);
2787 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
2793 /* Already complained about this, so don't do so again. */
2794 else if (current_class_type
== NULL_TREE
2795 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
2797 cp_error ("conflicting types for `%#D'", newdecl
);
2798 cp_error_at ("previous declaration as `%#D'", olddecl
);
2801 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2802 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
2803 && (!DECL_TEMPLATE_INFO (newdecl
)
2804 || (DECL_TI_TEMPLATE (newdecl
)
2805 != DECL_TI_TEMPLATE (olddecl
))))
2806 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2807 && (!DECL_TEMPLATE_INFO (olddecl
)
2808 || (DECL_TI_TEMPLATE (olddecl
)
2809 != DECL_TI_TEMPLATE (newdecl
))))))
2810 /* It's OK to have a template specialization and a non-template
2811 with the same type, or to have specializations of two
2812 different templates with the same type. Note that if one is a
2813 specialization, and the other is an instantiation of the same
2814 template, that we do not exit at this point. That situation
2815 can occur if we instantiate a template class, and then
2816 specialize one of its methods. This situation is legal, but
2817 the declarations must be merged in the usual way. */
2819 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2820 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
2821 && !DECL_USE_TEMPLATE (newdecl
))
2822 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
2823 && !DECL_USE_TEMPLATE (olddecl
))))
2824 /* One of the declarations is a template instantiation, and the
2825 other is not a template at all. That's OK. */
2827 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
2828 && DECL_NAMESPACE_ALIAS (newdecl
)
2829 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
2830 /* Redeclaration of namespace alias, ignore it. */
2834 char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
2837 cp_error (errmsg
, newdecl
);
2838 if (DECL_NAME (olddecl
) != NULL_TREE
)
2839 cp_error_at ((DECL_INITIAL (olddecl
)
2840 && namespace_bindings_p ())
2841 ? "`%#D' previously defined here"
2842 : "`%#D' previously declared here", olddecl
);
2844 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
2845 && DECL_INITIAL (olddecl
) != NULL_TREE
2846 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
2847 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
2849 /* Prototype decl follows defn w/o prototype. */
2850 cp_warning_at ("prototype for `%#D'", newdecl
);
2851 cp_warning_at ("follows non-prototype definition here", olddecl
);
2853 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
2854 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
2856 /* extern "C" int foo ();
2857 int foo () { bar (); }
2859 if (current_lang_stack
== current_lang_base
)
2860 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
2863 cp_error_at ("previous declaration of `%#D' with %L linkage",
2864 olddecl
, DECL_LANGUAGE (olddecl
));
2865 cp_error ("conflicts with new declaration with %L linkage",
2866 DECL_LANGUAGE (newdecl
));
2870 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
2872 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2874 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
2875 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
2878 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
2879 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
2881 for (; t1
&& t1
!= void_list_node
;
2882 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
2883 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
2885 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
2890 cp_pedwarn ("default argument given for parameter %d of `%#D'",
2892 cp_pedwarn_at ("after previous specification in `%#D'",
2898 cp_error ("default argument given for parameter %d of `%#D'",
2900 cp_error_at ("after previous specification in `%#D'",
2905 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
2906 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
2908 cp_warning ("`%#D' was used before it was declared inline",
2910 cp_warning_at ("previous non-inline declaration here",
2916 /* If new decl is `static' and an `extern' was seen previously,
2918 warn_extern_redeclared_static (newdecl
, olddecl
);
2920 /* We have committed to returning 1 at this point. */
2921 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2923 /* Now that functions must hold information normally held
2924 by field decls, there is extra work to do so that
2925 declaration information does not get destroyed during
2927 if (DECL_VINDEX (olddecl
))
2928 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
2929 if (DECL_CONTEXT (olddecl
))
2930 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2931 if (DECL_CLASS_CONTEXT (olddecl
))
2932 DECL_CLASS_CONTEXT (newdecl
) = DECL_CLASS_CONTEXT (olddecl
);
2933 if (DECL_PENDING_INLINE_INFO (newdecl
) == (struct pending_inline
*)0)
2934 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2935 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
2936 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2937 DECL_ABSTRACT_VIRTUAL_P (newdecl
) |= DECL_ABSTRACT_VIRTUAL_P (olddecl
);
2938 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
2939 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
2940 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
2942 /* Optionally warn about more than one declaration for the same
2943 name, but don't warn about a function declaration followed by a
2945 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
2946 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
2947 /* Don't warn about extern decl followed by definition. */
2948 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
2949 /* Don't warn about friends, let add_friend take care of it. */
2950 && ! DECL_FRIEND_P (newdecl
))
2952 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
2953 cp_warning_at ("previous declaration of `%D'", olddecl
);
2957 /* Deal with C++: must preserve virtual function table size. */
2958 if (TREE_CODE (olddecl
) == TYPE_DECL
)
2960 register tree newtype
= TREE_TYPE (newdecl
);
2961 register tree oldtype
= TREE_TYPE (olddecl
);
2963 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
2964 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
2966 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
2967 CLASSTYPE_FRIEND_CLASSES (newtype
)
2968 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
2972 /* Copy all the DECL_... slots specified in the new decl
2973 except for any that we copy here from the old type. */
2974 DECL_MACHINE_ATTRIBUTES (newdecl
)
2975 = merge_machine_decl_attributes (olddecl
, newdecl
);
2977 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2979 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl
),
2980 DECL_TEMPLATE_RESULT (olddecl
)))
2981 cp_error ("invalid redeclaration of %D", newdecl
);
2982 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
2983 DECL_TEMPLATE_PARMS (olddecl
) = DECL_TEMPLATE_PARMS (newdecl
);
2984 if (DECL_TEMPLATE_INFO (newdecl
))
2985 DECL_TEMPLATE_INFO (olddecl
) = DECL_TEMPLATE_INFO (newdecl
);
2986 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
2987 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
2988 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
2995 /* Automatically handles default parameters. */
2996 tree oldtype
= TREE_TYPE (olddecl
);
2999 /* Make sure we put the new type in the same obstack as the old one. */
3001 push_obstacks (TYPE_OBSTACK (oldtype
), TYPE_OBSTACK (oldtype
));
3004 push_obstacks_nochange ();
3005 end_temporary_allocation ();
3008 /* Merge the data types specified in the two decls. */
3009 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3011 if (TREE_CODE (newdecl
) == VAR_DECL
)
3012 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3013 /* Do this after calling `common_type' so that default
3014 parameters don't confuse us. */
3015 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3016 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3017 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3019 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3020 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3021 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3022 TYPE_RAISES_EXCEPTIONS (oldtype
));
3024 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3025 && DECL_SOURCE_LINE (olddecl
) != 0
3027 && ! compexcepttypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
3029 cp_pedwarn ("declaration of `%D' throws different exceptions",
3031 cp_pedwarn_at ("previous declaration here", olddecl
);
3034 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3036 /* Lay the type out, unless already done. */
3037 if (newtype
!= canonical_type_variant (oldtype
)
3038 && TREE_TYPE (newdecl
) != error_mark_node
3039 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3040 layout_type (TREE_TYPE (newdecl
));
3042 if ((TREE_CODE (newdecl
) == VAR_DECL
3043 || TREE_CODE (newdecl
) == PARM_DECL
3044 || TREE_CODE (newdecl
) == RESULT_DECL
3045 || TREE_CODE (newdecl
) == FIELD_DECL
3046 || TREE_CODE (newdecl
) == TYPE_DECL
)
3047 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3048 layout_decl (newdecl
, 0);
3050 /* Merge the type qualifiers. */
3051 if (TREE_READONLY (newdecl
))
3052 TREE_READONLY (olddecl
) = 1;
3053 if (TREE_THIS_VOLATILE (newdecl
))
3054 TREE_THIS_VOLATILE (olddecl
) = 1;
3056 /* Merge the initialization information. */
3057 if (DECL_INITIAL (newdecl
) == NULL_TREE
3058 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3060 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3061 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3062 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3063 if (DECL_LANG_SPECIFIC (newdecl
)
3064 && DECL_LANG_SPECIFIC (olddecl
))
3065 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3068 /* Merge the section attribute.
3069 We want to issue an error if the sections conflict but that must be
3070 done later in decl_attributes since we are called before attributes
3072 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3073 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3075 /* Keep the old rtl since we can safely use it, unless it's the
3076 call to abort() used for abstract virtuals. */
3077 if ((DECL_LANG_SPECIFIC (olddecl
)
3078 && !DECL_ABSTRACT_VIRTUAL_P (olddecl
))
3079 || DECL_RTL (olddecl
) != DECL_RTL (abort_fndecl
))
3080 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3084 /* If cannot merge, then use the new type and qualifiers,
3085 and don't preserve the old rtl. */
3088 /* Clean out any memory we had of the old declaration. */
3089 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3091 TREE_VALUE (oldstatic
) = error_mark_node
;
3093 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3094 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3095 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3096 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3099 /* Merge the storage class information. */
3100 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3101 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3102 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3103 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3104 if (! DECL_EXTERNAL (olddecl
))
3105 DECL_EXTERNAL (newdecl
) = 0;
3107 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3109 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3110 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3111 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3112 /* Don't really know how much of the language-specific
3113 values we should copy from old to new. */
3114 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3115 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3116 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3117 if (DECL_TEMPLATE_INFO (newdecl
) == NULL_TREE
)
3119 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3120 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
3122 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3125 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3127 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3128 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3130 /* If newdecl is not a specialization, then it is not a
3131 template-related function at all. And that means that we
3132 shoud have exited above, returning 0. */
3133 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3136 if (TREE_USED (olddecl
))
3137 /* From [temp.expl.spec]:
3139 If a template, a member template or the member of a class
3140 template is explicitly specialized then that
3141 specialization shall be declared before the first use of
3142 that specialization that would cause an implicit
3143 instantiation to take place, in every translation unit in
3144 which such a use occurs. */
3145 cp_error ("explicit specialization of %D after first use",
3148 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3150 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3152 /* If either decl says `inline', this fn is inline, unless its
3153 definition was passed already. */
3154 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3155 DECL_INLINE (olddecl
) = 1;
3156 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3160 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3161 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3162 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3164 if (! types_match
|| new_defines_function
)
3166 /* These need to be copied so that the names are available. */
3167 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3168 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3170 if (new_defines_function
)
3171 /* If defining a function declared with other language
3172 linkage, use the previously declared language linkage. */
3173 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3176 /* If redeclaring a builtin function, and not a definition,
3177 it stays built in. */
3178 if (DECL_BUILT_IN (olddecl
))
3180 DECL_BUILT_IN (newdecl
) = 1;
3181 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3182 /* If we're keeping the built-in definition, keep the rtl,
3183 regardless of declaration matches. */
3184 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3187 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3189 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3190 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3191 /* Previously saved insns go together with
3192 the function's previous definition. */
3193 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3194 /* Don't clear out the arguments if we're redefining a function. */
3195 if (DECL_ARGUMENTS (olddecl
))
3196 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3198 if (DECL_LANG_SPECIFIC (olddecl
))
3199 DECL_MAIN_VARIANT (newdecl
) = DECL_MAIN_VARIANT (olddecl
);
3202 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3204 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3207 /* Now preserve various other info from the definition. */
3208 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3209 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3210 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3211 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3213 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3216 struct lang_decl
*ol
= DECL_LANG_SPECIFIC (olddecl
);
3217 struct lang_decl
*nl
= DECL_LANG_SPECIFIC (newdecl
);
3219 function_size
= sizeof (struct tree_decl
);
3221 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3222 (char *) olddecl
+ sizeof (struct tree_common
),
3223 function_size
- sizeof (struct tree_common
));
3225 /* Can we safely free the storage used by newdecl? */
3227 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3228 & ~ obstack_alignment_mask (&permanent_obstack))
3230 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3232 /* If newdecl is a template instantiation, it is possible that
3233 the following sequence of events has occurred:
3235 o A friend function was declared in a class template. The
3236 class template was instantiated.
3238 o The instantiation of the friend declaration was
3239 recorded on the instantiation list, and is newdecl.
3241 o Later, however, instantiate_class_template called pushdecl
3242 on the newdecl to perform name injection. But, pushdecl in
3243 turn called duplicate_decls when it discovered that another
3244 declaration of a global function with the same name already
3247 o Here, in duplicate_decls, we decided to clobber newdecl.
3249 If we're going to do that, we'd better make sure that
3250 olddecl, and not newdecl, is on the list of
3251 instantiations so that if we try to do the instantiation
3252 again we won't get the clobbered declaration. */
3254 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3255 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3257 for (; decls
; decls
= TREE_CHAIN (decls
))
3258 if (TREE_VALUE (decls
) == newdecl
)
3259 TREE_VALUE (decls
) = olddecl
;
3262 if (((char *)newdecl
+ ROUND (function_size
) == (char *)nl
3263 && ((char *)newdecl
+ ROUND (function_size
)
3264 + ROUND (sizeof (struct lang_decl
))
3265 == obstack_next_free (&permanent_obstack
)))
3266 || ((char *)newdecl
+ ROUND (function_size
)
3267 == obstack_next_free (&permanent_obstack
)))
3269 DECL_MAIN_VARIANT (newdecl
) = olddecl
;
3270 DECL_LANG_SPECIFIC (olddecl
) = ol
;
3271 bcopy ((char *)nl
, (char *)ol
, sizeof (struct lang_decl
));
3273 obstack_free (&permanent_obstack
, newdecl
);
3275 else if (LANG_DECL_PERMANENT (ol
) && ol
!= nl
)
3277 if (DECL_MAIN_VARIANT (olddecl
) == olddecl
)
3279 /* Save these lang_decls that would otherwise be lost. */
3280 extern tree free_lang_decl_chain
;
3281 tree free_lang_decl
= (tree
) ol
;
3283 if (DECL_LANG_SPECIFIC (olddecl
) == ol
)
3286 TREE_CHAIN (free_lang_decl
) = free_lang_decl_chain
;
3287 free_lang_decl_chain
= free_lang_decl
;
3291 /* Storage leak. */;
3297 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3298 (char *) olddecl
+ sizeof (struct tree_common
),
3299 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3300 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3303 DECL_UID (olddecl
) = olddecl_uid
;
3305 DECL_FRIEND_P (olddecl
) = 1;
3307 /* NEWDECL contains the merged attribute lists.
3308 Update OLDDECL to be the same. */
3309 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3314 /* Record a decl-node X as belonging to the current lexical scope.
3315 Check for errors (such as an incompatible declaration for the same
3316 name already seen in the same scope).
3318 Returns either X or an old decl for the same name.
3319 If an old decl is returned, it may have been smashed
3320 to agree with what X says. */
3327 register tree name
= DECL_ASSEMBLER_NAME (x
);
3328 register struct binding_level
*b
= current_binding_level
;
3330 if (current_function_decl
&& x
!= current_function_decl
3331 /* A local declaration for a function doesn't constitute nesting. */
3332 && (TREE_CODE (x
) != FUNCTION_DECL
|| DECL_INITIAL (x
))
3333 /* Don't change DECL_CONTEXT of virtual methods. */
3334 && (TREE_CODE (x
) != FUNCTION_DECL
|| !DECL_VIRTUAL_P (x
))
3335 && ! DECL_CONTEXT (x
))
3336 DECL_CONTEXT (x
) = current_function_decl
;
3337 if (!DECL_CONTEXT (x
))
3338 DECL_CONTEXT (x
) = FROB_CONTEXT (current_namespace
);
3340 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3341 compiler wants to use. */
3342 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
3343 || TREE_CODE (x
) == NAMESPACE_DECL
|| TREE_CODE (x
) == TEMPLATE_TYPE_PARM
3344 || TREE_CODE (x
) == TEMPLATE_TEMPLATE_PARM
)
3345 name
= DECL_NAME (x
);
3350 /* Not needed...see below. */
3354 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3355 name
= TREE_OPERAND (name
, 0);
3357 /* Namespace-scoped variables are not found in the current level. */
3358 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
))
3359 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3361 t
= lookup_name_current_level (name
);
3362 if (t
== error_mark_node
)
3364 /* error_mark_node is 0 for a while during initialization! */
3366 cp_error_at ("`%#D' used prior to declaration", x
);
3369 else if (t
!= NULL_TREE
)
3372 /* This is turned off until I have time to do it right (bpk). */
3373 /* With the code below that uses it... */
3374 file
= DECL_SOURCE_FILE (t
);
3375 line
= DECL_SOURCE_LINE (t
);
3377 if (TREE_CODE (t
) == PARM_DECL
)
3379 if (DECL_CONTEXT (t
) == NULL_TREE
)
3380 fatal ("parse errors have confused me too much");
3382 /* Check for duplicate params. */
3383 if (duplicate_decls (x
, t
))
3386 else if (((TREE_CODE (x
) == FUNCTION_DECL
&& DECL_LANGUAGE (x
) == lang_c
)
3387 || DECL_FUNCTION_TEMPLATE_P (x
))
3388 && is_overloaded_fn (t
))
3389 /* Don't do anything just yet. */;
3390 else if (t
== wchar_decl_node
)
3392 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3393 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3395 /* Throw away the redeclaration. */
3398 else if (TREE_CODE (t
) != TREE_CODE (x
))
3400 if (duplicate_decls (x
, t
))
3403 else if (duplicate_decls (x
, t
))
3406 /* This is turned off until I have time to do it right (bpk). */
3408 /* Also warn if they did a prototype with `static' on it, but
3409 then later left the `static' off. */
3410 if (! TREE_PUBLIC (name
) && TREE_PUBLIC (x
))
3412 if (DECL_LANG_SPECIFIC (t
) && DECL_FRIEND_P (t
))
3417 cp_warning ("`static' missing from declaration of `%D'",
3419 warning_with_file_and_line (file
, line
,
3420 "previous declaration of `%s'",
3421 decl_as_string (t
, 0));
3424 /* Now fix things so it'll do what they expect. */
3425 if (current_function_decl
)
3426 TREE_PUBLIC (current_function_decl
) = 0;
3428 /* Due to interference in memory reclamation (X may be
3429 obstack-deallocated at this point), we must guard against
3430 one really special case. [jason: This should be handled
3431 by start_function] */
3432 if (current_function_decl
== x
)
3433 current_function_decl
= t
;
3435 if (TREE_CODE (t
) == TYPE_DECL
)
3436 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3437 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3438 check_default_args (t
);
3442 else if (DECL_MAIN_P (x
))
3444 /* A redeclaration of main, but not a duplicate of the
3449 This function shall not be overloaded. */
3450 cp_error_at ("invalid redeclaration of `%D'", t
);
3451 cp_error ("as `%D'", x
);
3452 /* We don't try to push this declaration since that
3458 if (TREE_CODE (x
) == FUNCTION_DECL
&& ! DECL_FUNCTION_MEMBER_P (x
))
3460 t
= push_overloaded_decl (x
, 1);
3461 if (t
!= x
|| DECL_LANGUAGE (x
) == lang_c
)
3464 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3465 return push_overloaded_decl (x
, 0);
3467 /* If declaring a type as a typedef, copy the type (unless we're
3468 at line 0), and install this TYPE_DECL as the new type's typedef
3469 name. See the extensive comment in ../c-decl.c (pushdecl). */
3470 if (TREE_CODE (x
) == TYPE_DECL
)
3472 tree type
= TREE_TYPE (x
);
3473 if (DECL_SOURCE_LINE (x
) == 0)
3475 if (TYPE_NAME (type
) == 0)
3476 TYPE_NAME (type
) = x
;
3478 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
3479 /* We don't want to copy the type when all we're
3480 doing is making a TYPE_DECL for the purposes of
3482 && (!TYPE_NAME (type
)
3483 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
3485 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
3487 DECL_ORIGINAL_TYPE (x
) = type
;
3488 type
= build_type_copy (type
);
3489 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
3490 TYPE_NAME (type
) = x
;
3491 TREE_TYPE (x
) = type
;
3496 if (type
!= error_mark_node
3498 && TYPE_IDENTIFIER (type
))
3499 set_identifier_type_value_with_scope (DECL_NAME (x
), type
, b
);
3502 /* Multiple external decls of the same identifier ought to match.
3504 We get warnings about inline functions where they are defined.
3505 We get warnings about other functions from push_overloaded_decl.
3507 Avoid duplicate warnings where they are used. */
3508 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
3512 if (IDENTIFIER_NAMESPACE_VALUE (name
) != NULL_TREE
3513 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name
))
3514 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name
))))
3515 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
3520 /* If different sort of thing, we already gave an error. */
3521 && TREE_CODE (decl
) == TREE_CODE (x
)
3522 && ! comptypes (TREE_TYPE (x
), TREE_TYPE (decl
), 1))
3524 cp_pedwarn ("type mismatch with previous external decl", x
);
3525 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
3529 /* This name is new in its binding level.
3530 Install the new declaration and return it. */
3531 if (namespace_bindings_p ())
3533 /* Install a global value. */
3535 /* If the first global decl has external linkage,
3536 warn if we later see static one. */
3537 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
3538 TREE_PUBLIC (name
) = 1;
3540 /* Don't install an artificial TYPE_DECL if we already have
3541 another _DECL with that name. */
3542 if (TREE_CODE (x
) != TYPE_DECL
3544 || ! DECL_ARTIFICIAL (x
))
3546 if (TREE_CODE (x
) == FUNCTION_DECL
)
3548 ((IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
)
3549 || (IDENTIFIER_GLOBAL_VALUE (name
) == x
), 378);
3550 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
3553 /* Don't forget if the function was used via an implicit decl. */
3554 if (IDENTIFIER_IMPLICIT_DECL (name
)
3555 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
3558 /* Don't forget if its address was taken in that way. */
3559 if (IDENTIFIER_IMPLICIT_DECL (name
)
3560 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
3561 TREE_ADDRESSABLE (x
) = 1;
3563 /* Warn about mismatches against previous implicit decl. */
3564 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
3565 /* If this real decl matches the implicit, don't complain. */
3566 && ! (TREE_CODE (x
) == FUNCTION_DECL
3567 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
3569 ("`%D' was previously implicitly declared to return `int'", x
);
3571 /* If new decl is `static' and an `extern' was seen previously,
3573 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
3574 warn_extern_redeclared_static (x
, t
);
3578 /* Here to install a non-global value. */
3579 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
3580 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
3582 /* Don't install an artificial TYPE_DECL if we already have
3583 another _DECL with that name. */
3584 if (TREE_CODE (x
) != TYPE_DECL
3586 || ! DECL_ARTIFICIAL (x
))
3587 set_identifier_local_value_with_scope (name
, x
, b
);
3589 /* If this is a TYPE_DECL, push it into the type value slot. */
3590 if (TREE_CODE (x
) == TYPE_DECL
)
3591 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
), b
);
3593 /* Clear out any TYPE_DECL shadowed by a namespace so that
3594 we won't think this is a type. The C struct hack doesn't
3595 go through namespaces. */
3596 if (TREE_CODE (x
) == NAMESPACE_DECL
)
3597 set_identifier_type_value_with_scope (name
, NULL_TREE
, b
);
3599 /* If this is an extern function declaration, see if we
3600 have a global definition or declaration for the function. */
3601 if (oldlocal
== NULL_TREE
3602 && DECL_EXTERNAL (x
)
3603 && oldglobal
!= NULL_TREE
3604 && TREE_CODE (x
) == FUNCTION_DECL
3605 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
3607 /* We have one. Their types must agree. */
3608 if (decls_match (x
, oldglobal
))
3612 cp_warning ("extern declaration of `%#D' doesn't match", x
);
3613 cp_warning_at ("global declaration `%#D'", oldglobal
);
3616 /* If we have a local external declaration,
3617 and no file-scope declaration has yet been seen,
3618 then if we later have a file-scope decl it must not be static. */
3619 if (oldlocal
== NULL_TREE
3620 && oldglobal
== NULL_TREE
3621 && DECL_EXTERNAL (x
)
3624 TREE_PUBLIC (name
) = 1;
3627 if (DECL_FROM_INLINE (x
))
3628 /* Inline decls shadow nothing. */;
3630 /* Warn if shadowing an argument at the top level of the body. */
3631 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
3632 && TREE_CODE (oldlocal
) == PARM_DECL
3633 && TREE_CODE (x
) != PARM_DECL
)
3635 /* Go to where the parms should be and see if we
3637 struct binding_level
*b
= current_binding_level
->level_chain
;
3643 if (b
->parm_flag
== 1)
3644 cp_error ("declaration of `%#D' shadows a parameter", name
);
3646 else if (warn_shadow
&& oldlocal
!= NULL_TREE
&& b
->is_for_scope
3647 && !DECL_DEAD_FOR_LOCAL (oldlocal
))
3649 warning ("variable `%s' shadows local",
3650 IDENTIFIER_POINTER (name
));
3651 cp_warning_at (" this is the shadowed declaration", oldlocal
);
3653 /* Maybe warn if shadowing something else. */
3654 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
3655 /* No shadow warnings for internally generated vars. */
3656 && ! DECL_ARTIFICIAL (x
)
3657 /* No shadow warnings for vars made for inlining. */
3658 && ! DECL_FROM_INLINE (x
))
3660 char *warnstring
= NULL
;
3662 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
3663 warnstring
= "declaration of `%s' shadows a parameter";
3664 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
3665 && current_class_ptr
3666 && !TREE_STATIC (name
))
3667 warnstring
= "declaration of `%s' shadows a member of `this'";
3668 else if (oldlocal
!= NULL_TREE
)
3669 warnstring
= "declaration of `%s' shadows previous local";
3670 else if (oldglobal
!= NULL_TREE
)
3671 /* XXX shadow warnings in outer-more namespaces */
3672 warnstring
= "declaration of `%s' shadows global declaration";
3675 warning (warnstring
, IDENTIFIER_POINTER (name
));
3677 /* Check to see if decl redeclares a template parameter. */
3678 if (oldlocal
&& (current_class_type
|| current_function_decl
)
3679 && current_template_parms
)
3681 if (decl_template_parm_p (oldlocal
))
3683 cp_error ("re-using name of template parameter `%T' in this scope", name
);
3684 cp_error_at (" previously declared here `%#D'", oldlocal
);
3689 if (TREE_CODE (x
) == FUNCTION_DECL
)
3690 check_default_args (x
);
3692 /* Keep count of variables in this level with incomplete type. */
3693 if (TREE_CODE (x
) == VAR_DECL
3694 && TREE_TYPE (x
) != error_mark_node
3695 && ((TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
3696 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
3697 /* RTTI TD entries are created while defining the type_info. */
3698 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
3699 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
3700 b
->incomplete
= tree_cons (NULL_TREE
, x
, b
->incomplete
);
3703 /* Put decls on list in reverse order.
3704 We will reverse them later if necessary. */
3705 TREE_CHAIN (x
) = b
->names
;
3707 if (! (b
!= global_binding_level
|| TREE_PERMANENT (x
)))
3708 my_friendly_abort (124);
3713 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3714 caller to set DECL_CONTEXT properly. */
3717 pushdecl_with_scope (x
, level
)
3719 struct binding_level
*level
;
3721 register struct binding_level
*b
;
3722 tree function_decl
= current_function_decl
;
3724 current_function_decl
= NULL_TREE
;
3725 if (level
->parm_flag
== 2)
3727 b
= class_binding_level
;
3728 class_binding_level
= level
;
3729 pushdecl_class_level (x
);
3730 class_binding_level
= b
;
3734 b
= current_binding_level
;
3735 current_binding_level
= level
;
3737 current_binding_level
= b
;
3739 current_function_decl
= function_decl
;
3743 /* Like pushdecl, only it places X in the current namespace,
3747 pushdecl_namespace_level (x
)
3750 register struct binding_level
*b
= inner_binding_level
;
3753 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
3755 /* Now, the type_shadowed stack may screw us. Munge it so it does
3757 if (TREE_CODE (x
) == TYPE_DECL
)
3759 tree name
= DECL_NAME (x
);
3761 tree
*ptr
= (tree
*)0;
3762 for (; b
!= global_binding_level
; b
= b
->level_chain
)
3764 tree shadowed
= b
->type_shadowed
;
3765 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3766 if (TREE_PURPOSE (shadowed
) == name
)
3768 ptr
= &TREE_VALUE (shadowed
);
3769 /* Can't break out of the loop here because sometimes
3770 a binding level will have duplicate bindings for
3771 PT names. It's gross, but I haven't time to fix it. */
3774 newval
= TREE_TYPE (x
);
3775 if (ptr
== (tree
*)0)
3777 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3778 up here if this is changed to an assertion. --KR */
3779 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
3789 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
3793 pushdecl_top_level (x
)
3796 tree cur_namespace
= current_namespace
;
3797 current_namespace
= global_namespace
;
3798 x
= pushdecl_namespace_level (x
);
3799 current_namespace
= cur_namespace
;
3803 /* Make the declaration of X appear in CLASS scope. */
3806 pushdecl_class_level (x
)
3809 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
3810 scope looks for the pre-mangled name. */
3811 register tree name
= DECL_NAME (x
);
3815 if (TYPE_BEING_DEFINED (current_class_type
))
3817 /* A name N used in a class S shall refer to the same declaration
3818 in its context and when re-evaluated in the completed scope of S.
3819 Types, enums, and static vars are checked here; other
3820 members are checked in finish_struct. */
3821 tree icv
= IDENTIFIER_CLASS_VALUE (name
);
3822 tree ilv
= IDENTIFIER_LOCAL_VALUE (name
);
3825 && flag_optional_diags
3826 /* Don't complain about inherited names. */
3827 && id_in_current_class (name
)
3828 /* Or shadowed tags. */
3829 && !(DECL_DECLARES_TYPE_P (icv
)
3830 && DECL_CONTEXT (icv
) == current_class_type
))
3832 cp_pedwarn ("declaration of identifier `%D' as `%#D'", name
, x
);
3833 cp_pedwarn_at ("conflicts with previous use in class as `%#D'",
3837 /* Check to see if decl redeclares a template parameter. */
3838 if (ilv
&& ! decls_match (ilv
, x
)
3839 && (current_class_type
|| current_function_decl
)
3840 && current_template_parms
)
3842 if (decl_template_parm_p (ilv
))
3844 cp_error ("re-using name of template parameter `%T' in this scope", name
);
3845 cp_error_at (" previously declared here `%#D'", ilv
);
3850 push_class_level_binding (name
, x
);
3851 if (TREE_CODE (x
) == TYPE_DECL
)
3853 set_identifier_type_value (name
, TREE_TYPE (x
));
3859 /* This function is used to push the mangled decls for nested types into
3860 the appropriate scope. Previously pushdecl_top_level was used, but that
3861 is incorrect for members of local classes. */
3864 pushdecl_nonclass_level (x
)
3867 struct binding_level
*b
= current_binding_level
;
3869 my_friendly_assert (b
->parm_flag
!= 2, 180);
3872 /* Get out of template binding levels */
3873 while (b
->pseudo_global
)
3877 pushdecl_with_scope (x
, b
);
3881 /* Make the declaration(s) of X appear in CLASS scope
3882 under the name NAME. */
3885 push_class_level_binding (name
, x
)
3889 /* The class_binding_level will be NULL if x is a template
3890 parameter name in a member template. */
3891 if (!class_binding_level
)
3894 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
3895 && purpose_member (name
, class_binding_level
->class_shadowed
))
3898 maybe_push_cache_obstack ();
3899 class_binding_level
->class_shadowed
3900 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
3901 class_binding_level
->class_shadowed
);
3903 IDENTIFIER_CLASS_VALUE (name
) = x
;
3904 obstack_ptr_grow (&decl_obstack
, x
);
3907 /* Insert another USING_DECL into the current binding level,
3908 returning this declaration. If this is a redeclaration,
3909 do nothing and return NULL_TREE. */
3912 push_using_decl (scope
, name
)
3918 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
3919 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
3920 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
3921 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
3925 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
3926 DECL_INITIAL (decl
) = scope
;
3927 TREE_CHAIN (decl
) = current_binding_level
->usings
;
3928 current_binding_level
->usings
= decl
;
3932 /* Add namespace to using_directives. Return NULL_TREE if nothing was
3933 changed (i.e. there was already a directive), or the fresh
3934 TREE_LIST otherwise. */
3937 push_using_directive (used
)
3940 tree ud
= current_binding_level
->using_directives
;
3941 tree iter
, ancestor
;
3943 /* Check if we already have this. */
3944 if (purpose_member (used
, ud
) != NULL_TREE
)
3947 /* Recursively add all namespaces used. */
3948 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
3949 push_using_directive (TREE_PURPOSE (iter
));
3951 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
3952 ud
= current_binding_level
->using_directives
;
3953 ud
= perm_tree_cons (used
, ancestor
, ud
);
3954 current_binding_level
->using_directives
= ud
;
3958 /* DECL is a FUNCTION_DECL which may have other definitions already in
3959 place. We get around this by making the value of the identifier point
3960 to a list of all the things that want to be referenced by that name. It
3961 is then up to the users of that name to decide what to do with that
3964 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
3965 slot. It is dealt with the same way.
3967 The value returned may be a previous declaration if we guessed wrong
3968 about what language DECL should belong to (C or C++). Otherwise,
3969 it's always DECL (and never something that's not a _DECL). */
3972 push_overloaded_decl (decl
, forgettable
)
3976 tree orig_name
= DECL_NAME (decl
);
3978 int doing_global
= (namespace_bindings_p () || ! forgettable
);
3982 old
= namespace_binding (orig_name
, DECL_CONTEXT (decl
));
3983 if (old
&& TREE_CODE (old
) == FUNCTION_DECL
3984 && DECL_ARTIFICIAL (old
)
3985 && (DECL_BUILT_IN (old
) || DECL_BUILT_IN_NONANSI (old
)))
3987 if (duplicate_decls (decl
, old
))
3994 old
= IDENTIFIER_LOCAL_VALUE (orig_name
);
3996 if (! purpose_member (orig_name
, current_binding_level
->shadowed
))
3998 current_binding_level
->shadowed
3999 = tree_cons (orig_name
, old
, current_binding_level
->shadowed
);
4006 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4008 tree t
= TREE_TYPE (old
);
4009 if (IS_AGGR_TYPE (t
) && warn_shadow
4010 && (! DECL_IN_SYSTEM_HEADER (decl
)
4011 || ! DECL_IN_SYSTEM_HEADER (old
)))
4012 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4015 else if (is_overloaded_fn (old
))
4019 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4020 if (decl
== OVL_CURRENT (tmp
)
4021 || duplicate_decls (decl
, OVL_CURRENT (tmp
)))
4022 return OVL_CURRENT (tmp
);
4026 cp_error_at ("previous non-function declaration `%#D'", old
);
4027 cp_error ("conflicts with function declaration `%#D'", decl
);
4032 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4034 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4035 old
= ovl_cons (old
, NULL_TREE
);
4036 old
= ovl_cons (decl
, old
);
4039 /* orig_name is not ambiguous. */
4043 set_namespace_binding (orig_name
, current_namespace
, old
);
4045 IDENTIFIER_LOCAL_VALUE (orig_name
) = old
;
4050 /* Generate an implicit declaration for identifier FUNCTIONID
4051 as a function of type int (). Print a warning if appropriate. */
4054 implicitly_declare (functionid
)
4058 int temp
= allocation_temporary_p ();
4060 push_obstacks_nochange ();
4062 /* Save the decl permanently so we can warn if definition follows.
4063 In ANSI C, warn_implicit is usually false, so the saves little space.
4064 But in C++, it's usually true, hence the extra code. */
4065 if (temp
&& (! warn_implicit
|| toplevel_bindings_p ()))
4066 end_temporary_allocation ();
4068 /* We used to reuse an old implicit decl here,
4069 but this loses with inline functions because it can clobber
4070 the saved decl chains. */
4071 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4073 DECL_EXTERNAL (decl
) = 1;
4074 TREE_PUBLIC (decl
) = 1;
4076 /* ANSI standard says implicit declarations are in the innermost block.
4077 So we record the decl in the standard fashion. */
4079 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4082 /* Only one warning per identifier. */
4083 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4085 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4088 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4095 /* Return zero if the declaration NEWDECL is valid
4096 when the declaration OLDDECL (assumed to be for the same name)
4097 has already been seen.
4098 Otherwise return an error message format string with a %s
4099 where the identifier should go. */
4102 redeclaration_error_message (newdecl
, olddecl
)
4103 tree newdecl
, olddecl
;
4105 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4107 /* Because C++ can put things into name space for free,
4108 constructs like "typedef struct foo { ... } foo"
4109 would look like an erroneous redeclaration. */
4110 if (comptypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
), 0))
4113 return "redefinition of `%#D'";
4115 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4117 /* If this is a pure function, its olddecl will actually be
4118 the original initialization to `0' (which we force to call
4119 abort()). Don't complain about redefinition in this case. */
4120 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_ABSTRACT_VIRTUAL_P (olddecl
))
4123 /* If both functions come from different namespaces, this is not
4124 a redeclaration - this is a conflict with a used function. */
4125 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4126 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4127 return "`%D' conflicts with used function";
4129 /* We'll complain about linkage mismatches in
4130 warn_extern_redeclared_static. */
4132 /* Defining the same name twice is no good. */
4133 if (DECL_INITIAL (olddecl
) != NULL_TREE
4134 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4136 if (DECL_NAME (olddecl
) == NULL_TREE
)
4137 return "`%#D' not declared in class";
4139 return "redefinition of `%#D'";
4143 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4145 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4146 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4147 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4148 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4149 && TYPE_SIZE (TREE_TYPE (newdecl
))
4150 && TYPE_SIZE (TREE_TYPE (olddecl
))))
4151 return "redefinition of `%#D'";
4154 else if (toplevel_bindings_p ())
4156 /* Objects declared at top level: */
4157 /* If at least one is a reference, it's ok. */
4158 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4160 /* Reject two definitions. */
4161 return "redefinition of `%#D'";
4165 /* Objects declared with block scope: */
4166 /* Reject two definitions, and reject a definition
4167 together with an external reference. */
4168 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4169 return "redeclaration of `%#D'";
4174 /* Get the LABEL_DECL corresponding to identifier ID as a label.
4175 Create one if none exists so far for the current function.
4176 This function is called for both label definitions and label references. */
4182 register tree decl
= IDENTIFIER_LABEL_VALUE (id
);
4184 if (current_function_decl
== NULL_TREE
)
4186 error ("label `%s' referenced outside of any function",
4187 IDENTIFIER_POINTER (id
));
4191 if ((decl
== NULL_TREE
4192 || DECL_SOURCE_LINE (decl
) == 0)
4193 && (named_label_uses
== NULL
4194 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4195 || named_label_uses
->label_decl
!= decl
))
4197 struct named_label_list
*new_ent
;
4199 = (struct named_label_list
*)oballoc (sizeof (struct named_label_list
));
4200 new_ent
->label_decl
= decl
;
4201 new_ent
->names_in_scope
= current_binding_level
->names
;
4202 new_ent
->binding_level
= current_binding_level
;
4203 new_ent
->lineno_o_goto
= lineno
;
4204 new_ent
->filename_o_goto
= input_filename
;
4205 new_ent
->next
= named_label_uses
;
4206 named_label_uses
= new_ent
;
4209 /* Use a label already defined or ref'd with this name. */
4210 if (decl
!= NULL_TREE
)
4212 /* But not if it is inherited and wasn't declared to be inheritable. */
4213 if (DECL_CONTEXT (decl
) != current_function_decl
4214 && ! C_DECLARED_LABEL_FLAG (decl
))
4215 return shadow_label (id
);
4219 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4221 /* Make sure every label has an rtx. */
4224 /* A label not explicitly declared must be local to where it's ref'd. */
4225 DECL_CONTEXT (decl
) = current_function_decl
;
4227 DECL_MODE (decl
) = VOIDmode
;
4229 /* Say where one reference is to the label,
4230 for the sake of the error if it is not defined. */
4231 DECL_SOURCE_LINE (decl
) = lineno
;
4232 DECL_SOURCE_FILE (decl
) = input_filename
;
4234 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4236 named_labels
= tree_cons (NULL_TREE
, decl
, named_labels
);
4237 named_label_uses
->label_decl
= decl
;
4242 /* Make a label named NAME in the current function,
4243 shadowing silently any that may be inherited from containing functions
4244 or containing scopes.
4246 Note that valid use, if the label being shadowed
4247 comes from another scope in the same function,
4248 requires calling declare_nonlocal_label right away. */
4254 register tree decl
= IDENTIFIER_LABEL_VALUE (name
);
4256 if (decl
!= NULL_TREE
)
4258 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
4259 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
4262 return lookup_label (name
);
4265 /* Define a label, specifying the location in the source file.
4266 Return the LABEL_DECL node for the label, if the definition is valid.
4267 Otherwise return 0. */
4270 define_label (filename
, line
, name
)
4277 if (minimal_parse_mode
)
4279 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4280 decl
= build_decl (LABEL_DECL
, name
, void_type_node
);
4282 DECL_SOURCE_LINE (decl
) = line
;
4283 DECL_SOURCE_FILE (decl
) = filename
;
4288 decl
= lookup_label (name
);
4290 /* After labels, make any new cleanups go into their
4291 own new (temporary) binding contour. */
4292 current_binding_level
->more_cleanups_ok
= 0;
4294 /* If label with this name is known from an outer context, shadow it. */
4295 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) != current_function_decl
)
4297 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
4298 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
4299 decl
= lookup_label (name
);
4302 if (name
== get_identifier ("wchar_t"))
4303 cp_pedwarn ("label named wchar_t");
4305 if (DECL_INITIAL (decl
) != NULL_TREE
)
4307 cp_error ("duplicate label `%D'", decl
);
4312 struct named_label_list
*uses
, *prev
;
4315 /* Mark label as having been defined. */
4316 DECL_INITIAL (decl
) = error_mark_node
;
4317 /* Say where in the source. */
4318 DECL_SOURCE_FILE (decl
) = filename
;
4319 DECL_SOURCE_LINE (decl
) = line
;
4322 uses
= named_label_uses
;
4323 while (uses
!= NULL
)
4324 if (uses
->label_decl
== decl
)
4326 struct binding_level
*b
= current_binding_level
;
4329 tree new_decls
= b
->names
;
4330 tree old_decls
= (b
== uses
->binding_level
)
4331 ? uses
->names_in_scope
: NULL_TREE
;
4332 while (new_decls
!= old_decls
)
4334 if (TREE_CODE (new_decls
) == VAR_DECL
4335 /* Don't complain about crossing initialization
4336 of internal entities. They can't be accessed,
4337 and they should be cleaned up
4338 by the time we get to the label. */
4339 && ! DECL_ARTIFICIAL (new_decls
)
4340 && ((DECL_INITIAL (new_decls
) != NULL_TREE
4341 && DECL_INITIAL (new_decls
) != error_mark_node
)
4342 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
4346 cp_error ("jump to label `%D'", decl
);
4347 error_with_file_and_line (uses
->filename_o_goto
,
4348 uses
->lineno_o_goto
,
4352 cp_error_at (" crosses initialization of `%#D'",
4355 new_decls
= TREE_CHAIN (new_decls
);
4357 if (b
== uses
->binding_level
)
4363 prev
->next
= uses
->next
;
4365 named_label_uses
= uses
->next
;
4374 current_function_return_value
= NULL_TREE
;
4381 struct binding_level
*level
;
4382 struct cp_switch
*next
;
4385 static struct cp_switch
*switch_stack
;
4391 = (struct cp_switch
*) oballoc (sizeof (struct cp_switch
));
4392 p
->level
= current_binding_level
;
4393 p
->next
= switch_stack
;
4400 switch_stack
= switch_stack
->next
;
4403 /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
4404 /* XXX Note decl is never actually used. (bpk) */
4407 define_case_label ()
4409 tree cleanup
= last_cleanup_this_contour ();
4410 struct binding_level
*b
= current_binding_level
;
4415 static int explained
= 0;
4416 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup
));
4417 warning ("where case label appears here");
4420 warning ("(enclose actions of previous case statements requiring");
4421 warning ("destructors in their own binding contours.)");
4426 for (; b
&& b
!= switch_stack
->level
; b
= b
->level_chain
)
4428 tree new_decls
= b
->names
;
4429 for (; new_decls
; new_decls
= TREE_CHAIN (new_decls
))
4431 if (TREE_CODE (new_decls
) == VAR_DECL
4432 /* Don't complain about crossing initialization
4433 of internal entities. They can't be accessed,
4434 and they should be cleaned up
4435 by the time we get to the label. */
4436 && ! DECL_ARTIFICIAL (new_decls
)
4437 && ((DECL_INITIAL (new_decls
) != NULL_TREE
4438 && DECL_INITIAL (new_decls
) != error_mark_node
)
4439 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
4442 error ("jump to case label");
4444 cp_error_at (" crosses initialization of `%#D'",
4450 /* After labels, make any new cleanups go into their
4451 own new (temporary) binding contour. */
4453 current_binding_level
->more_cleanups_ok
= 0;
4454 current_function_return_value
= NULL_TREE
;
4457 /* Return the list of declarations of the current level.
4458 Note that this list is in reverse order unless/until
4459 you nreverse it; and when you do nreverse it, you must
4460 store the result back using `storedecls' or you will lose. */
4465 return current_binding_level
->names
;
4468 /* Return the list of type-tags (for structs, etc) of the current level. */
4473 return current_binding_level
->tags
;
4476 /* Store the list of declarations of the current level.
4477 This is done for the parameter declarations of a function being defined,
4478 after they are modified in the light of any missing parameters. */
4484 current_binding_level
->names
= decls
;
4487 /* Similarly, store the list of tags of the current level. */
4493 current_binding_level
->tags
= tags
;
4496 /* Given NAME, an IDENTIFIER_NODE,
4497 return the structure (or union or enum) definition for that name.
4498 Searches binding levels from BINDING_LEVEL up to the global level.
4499 If THISLEVEL_ONLY is nonzero, searches only the specified context
4500 (but skips any tag-transparent contexts to find one that is
4501 meaningful for tags).
4502 FORM says which kind of type the caller wants;
4503 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4504 If the wrong kind of type is found, and it's not a template, an error is
4508 lookup_tag (form
, name
, binding_level
, thislevel_only
)
4509 enum tree_code form
;
4511 struct binding_level
*binding_level
;
4514 register struct binding_level
*level
;
4515 /* Non-zero if, we should look past a pseudo-global level, even if
4517 int allow_pseudo_global
= 1;
4519 for (level
= binding_level
; level
; level
= level
->level_chain
)
4522 if (ANON_AGGRNAME_P (name
))
4523 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4525 /* There's no need for error checking here, because
4526 anon names are unique throughout the compilation. */
4527 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
4528 return TREE_VALUE (tail
);
4530 else if (level
->namespace_p
)
4531 /* Do namespace lookup. */
4532 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
4534 tree old
= binding_for_name (name
, tail
);
4536 /* If we just skipped past a pseudo global level, even
4537 though THISLEVEL_ONLY, and we find a template class
4538 declaration, then we use the _TYPE node for the
4539 template. See the example below. */
4540 if (thislevel_only
&& !allow_pseudo_global
4541 && old
&& BINDING_VALUE (old
)
4542 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
4543 old
= TREE_TYPE (BINDING_VALUE (old
));
4545 old
= BINDING_TYPE (old
);
4547 /* If it has an original type, it is a typedef, and we
4548 should not return it. */
4549 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
4551 if (old
&& TREE_CODE (old
) != form
4552 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
4554 cp_error ("`%#D' redeclared as %C", old
, form
);
4559 if (thislevel_only
|| tail
== global_namespace
)
4563 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4565 if (TREE_PURPOSE (tail
) == name
)
4567 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
4568 /* Should tighten this up; it'll probably permit
4569 UNION_TYPE and a struct template, for example. */
4571 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
4573 /* Definition isn't the kind we were looking for. */
4574 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
4578 return TREE_VALUE (tail
);
4581 if (thislevel_only
&& ! level
->tag_transparent
)
4583 if (level
->pseudo_global
&& allow_pseudo_global
)
4585 /* We must deal with cases like this:
4587 template <class T> struct S;
4588 template <class T> struct S {};
4590 When looking up `S', for the second declaration, we
4591 would like to find the first declaration. But, we
4592 are in the pseudo-global level created for the
4593 template parameters, rather than the (surrounding)
4594 namespace level. Thus, we keep going one more level,
4595 even though THISLEVEL_ONLY is non-zero. */
4596 allow_pseudo_global
= 0;
4602 if (current_class_type
&& level
->level_chain
->namespace_p
)
4604 /* Try looking in this class's tags before heading into
4605 global binding level. */
4606 tree context
= current_class_type
;
4609 switch (TREE_CODE_CLASS (TREE_CODE (context
)))
4613 these_tags
= CLASSTYPE_TAGS (context
);
4614 if (ANON_AGGRNAME_P (name
))
4617 if (TYPE_IDENTIFIER (TREE_VALUE (these_tags
))
4619 return TREE_VALUE (tail
);
4620 these_tags
= TREE_CHAIN (these_tags
);
4625 if (TREE_PURPOSE (these_tags
) == name
)
4627 if (TREE_CODE (TREE_VALUE (these_tags
)) != form
)
4629 cp_error ("`%#D' redeclared as %C in class scope",
4630 TREE_VALUE (tail
), form
);
4633 return TREE_VALUE (tail
);
4635 these_tags
= TREE_CHAIN (these_tags
);
4637 /* If this type is not yet complete, then don't
4638 look at its context. */
4639 if (TYPE_SIZE (context
) == NULL_TREE
)
4641 /* Go to next enclosing type, if any. */
4642 context
= DECL_CONTEXT (TYPE_MAIN_DECL (context
));
4645 context
= DECL_CONTEXT (context
);
4648 my_friendly_abort (10);
4661 set_current_level_tags_transparency (tags_transparent
)
4662 int tags_transparent
;
4664 current_binding_level
->tag_transparent
= tags_transparent
;
4668 /* Given a type, find the tag that was defined for it and return the tag name.
4669 Otherwise return 0. However, the value can never be 0
4670 in the cases in which this is used.
4672 C++: If NAME is non-zero, this is the new name to install. This is
4673 done when replacing anonymous tags with real tag names. */
4676 lookup_tag_reverse (type
, name
)
4680 register struct binding_level
*level
;
4682 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
4685 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4687 if (TREE_VALUE (tail
) == type
)
4690 TREE_PURPOSE (tail
) = name
;
4691 return TREE_PURPOSE (tail
);
4698 /* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
4699 Return the type value, or NULL_TREE if not found. */
4702 lookup_nested_type (type
, context
)
4706 if (context
== NULL_TREE
)
4710 switch (TREE_CODE (context
))
4714 tree ctype
= TREE_TYPE (context
);
4715 tree match
= value_member (type
, CLASSTYPE_TAGS (ctype
));
4717 return TREE_VALUE (match
);
4718 context
= DECL_CONTEXT (context
);
4720 /* When we have a nested class whose member functions have
4721 local types (e.g., a set of enums), we'll arrive here
4722 with the DECL_CONTEXT as the actual RECORD_TYPE node for
4723 the enclosing class. Instead, we want to make sure we
4724 come back in here with the TYPE_DECL, not the RECORD_TYPE. */
4725 if (context
&& TREE_CODE (context
) == RECORD_TYPE
)
4726 context
= TREE_CHAIN (context
);
4730 if (TYPE_NAME (type
) && TYPE_IDENTIFIER (type
))
4731 return lookup_name (TYPE_IDENTIFIER (type
), 1);
4734 my_friendly_abort (12);
4740 /* Look up NAME in the NAMESPACE. */
4743 lookup_namespace_name (namespace, name
)
4744 tree
namespace, name
;
4746 struct tree_binding _b
;
4749 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
4751 /* This happens for A::B<int> when B is a namespace. */
4752 if (TREE_CODE (name
) == NAMESPACE_DECL
)
4755 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
4757 val
= binding_init (&_b
);
4758 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
4759 return error_mark_node
;
4761 if (BINDING_VALUE (val
))
4763 val
= BINDING_VALUE (val
);
4765 /* If we have a single function from a using decl, pull it out. */
4766 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
4767 val
= OVL_FUNCTION (val
);
4771 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
4772 return error_mark_node
;
4776 make_typename_type (context
, name
)
4782 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
4783 name
= TYPE_IDENTIFIER (name
);
4784 else if (TREE_CODE (name
) == TYPE_DECL
)
4785 name
= DECL_NAME (name
);
4789 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
4791 name
= TREE_OPERAND (name
, 0);
4792 if (TREE_CODE (name
) == TEMPLATE_DECL
)
4793 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
4795 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
4796 my_friendly_abort (2000);
4798 if (TREE_CODE (context
) == NAMESPACE_DECL
)
4800 /* We can get here from typename_sub0 in the explicit_template_type
4801 expansion. Just fail. */
4802 cp_error ("no class template named `%#T' in `%#T'",
4804 return error_mark_node
;
4807 if (! uses_template_parms (context
)
4808 || currently_open_class (context
))
4810 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
4812 if (IS_AGGR_TYPE (context
))
4813 t
= lookup_field (context
, name
, 0, 0);
4817 if (t
== NULL_TREE
|| TREE_CODE (t
) != TEMPLATE_DECL
4818 || TREE_CODE (DECL_RESULT (t
)) != TYPE_DECL
)
4820 cp_error ("no class template named `%#T' in `%#T'",
4822 return error_mark_node
;
4825 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
4827 /*entering_scope=*/0);
4831 if (IS_AGGR_TYPE (context
))
4832 t
= lookup_field (context
, name
, 0, 1);
4838 cp_error ("no type named `%#T' in `%#T'", name
, context
);
4839 return error_mark_node
;
4842 return TREE_TYPE (t
);
4846 if (processing_template_decl
)
4847 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4848 t
= make_lang_type (TYPENAME_TYPE
);
4849 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
4850 d
= build_decl (TYPE_DECL
, name
, t
);
4851 if (processing_template_decl
)
4854 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
4855 TYPE_NAME (TREE_TYPE (d
)) = d
;
4856 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
4857 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
4858 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
4863 /* Select the right _DECL from multiple choices. */
4866 select_decl (binding
, flags
)
4871 val
= BINDING_VALUE (binding
);
4872 if (LOOKUP_NAMESPACES_ONLY (flags
))
4874 /* We are not interested in types. */
4875 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
4880 /* If we could have a type and
4881 we have nothing or we need a type and have none. */
4882 if (BINDING_TYPE (binding
)
4883 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
4884 && TREE_CODE (val
) != TYPE_DECL
)))
4885 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
4886 /* Don't return non-types if we really prefer types. */
4887 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
4888 && (!looking_for_template
|| TREE_CODE (val
) != TEMPLATE_DECL
))
4894 /* Unscoped lookup of a global, iterate over namespaces, considering
4895 using namespace statements. */
4898 unqualified_namespace_lookup (name
, flags
)
4902 struct tree_binding _binding
;
4903 tree b
= binding_init (&_binding
);
4904 tree initial
= current_decl_namespace();
4905 tree scope
= initial
;
4907 struct binding_level
*level
;
4908 tree val
= NULL_TREE
;
4912 val
= binding_for_name (name
, scope
);
4914 /* Initialize binding for this context. */
4915 BINDING_VALUE (b
) = BINDING_VALUE (val
);
4916 BINDING_TYPE (b
) = BINDING_TYPE (val
);
4918 /* Add all _DECLs seen through local using-directives. */
4919 for (level
= current_binding_level
;
4920 !level
->namespace_p
;
4921 level
= level
->level_chain
)
4922 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
4924 /* Give up because of error. */
4927 /* Add all _DECLs seen through global using-directives. */
4928 /* XXX local and global using lists should work equally. */
4932 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
4934 /* Give up because of error. */
4936 if (siter
== scope
) break;
4937 siter
= CP_DECL_CONTEXT (siter
);
4940 val
= select_decl (b
, flags
);
4941 if (scope
== global_namespace
)
4943 scope
= CP_DECL_CONTEXT (scope
);
4948 /* Combine prefer_type and namespaces_only into flags. */
4951 lookup_flags (prefer_type
, namespaces_only
)
4952 int prefer_type
, namespaces_only
;
4954 if (namespaces_only
)
4955 return LOOKUP_PREFER_NAMESPACES
;
4956 if (prefer_type
> 1)
4957 return LOOKUP_PREFER_TYPES
;
4958 if (prefer_type
> 0)
4959 return LOOKUP_PREFER_BOTH
;
4963 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4964 ignore it or not. Subroutine of lookup_name_real. */
4967 qualify_lookup (val
, flags
)
4971 if (val
== NULL_TREE
)
4973 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
4975 if ((flags
& LOOKUP_PREFER_TYPES
)
4976 && (TREE_CODE (val
) == TYPE_DECL
4977 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
4978 && DECL_CLASS_TEMPLATE_P (val
))))
4980 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
4985 /* Look up NAME in the current binding level and its superiors in the
4986 namespace of variables, functions and typedefs. Return a ..._DECL
4987 node of some kind representing its definition if there is only one
4988 such declaration, or return a TREE_LIST with all the overloaded
4989 definitions if there are many, or return 0 if it is undefined.
4991 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4992 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4993 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
4994 Otherwise we prefer non-TYPE_DECLs.
4996 If NONCLASS is non-zero, we don't look for the NAME in class scope,
4997 using IDENTIFIER_CLASS_VALUE. */
5000 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5002 int prefer_type
, nonclass
, namespaces_only
;
5006 tree from_obj
= NULL_TREE
;
5007 tree locval
, classval
;
5010 /* Hack: copy flag set by parser, if set. */
5011 if (only_namespace_names
)
5012 namespaces_only
= 1;
5014 if (prefer_type
== -2)
5016 extern int looking_for_typename
;
5017 tree type
= NULL_TREE
;
5020 prefer_type
= looking_for_typename
;
5022 flags
= lookup_flags (prefer_type
, namespaces_only
);
5023 /* During parsing, we need to complain. */
5024 flags
|= LOOKUP_COMPLAIN
;
5025 /* If the next thing is '<', class templates are types. */
5026 if (looking_for_template
)
5027 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5029 /* std:: becomes :: for now. */
5030 if (got_scope
== std_node
)
5031 got_scope
= void_type_node
;
5035 else if (got_object
!= error_mark_node
)
5040 if (type
== error_mark_node
)
5041 return error_mark_node
;
5042 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5043 type
= TREE_TYPE (type
);
5046 type
= complete_type (type
);
5048 if (TREE_CODE (type
) == VOID_TYPE
)
5049 type
= global_namespace
;
5050 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5052 struct tree_binding b
;
5053 val
= binding_init (&b
);
5054 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5056 val
= select_decl (val
, flags
);
5058 else if (! IS_AGGR_TYPE (type
)
5059 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5060 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
5061 || TREE_CODE (type
) == TYPENAME_TYPE
)
5062 /* Someone else will give an error about this if needed. */
5064 else if (TYPE_BEING_DEFINED (type
))
5066 val
= IDENTIFIER_CLASS_VALUE (name
);
5067 if (val
&& DECL_CONTEXT (val
) != type
)
5069 struct binding_level
*b
= class_binding_level
;
5070 for (val
= NULL_TREE
; b
; b
= b
->level_chain
)
5072 tree t
= purpose_member (name
, b
->class_shadowed
);
5073 if (t
&& TREE_VALUE (t
)
5074 && DECL_CONTEXT (TREE_VALUE (t
)) == type
)
5076 val
= TREE_VALUE (t
);
5081 if (val
== NULL_TREE
)
5082 val
= lookup_field (type
, name
, 0, 1);
5084 else if (type
== current_class_type
)
5085 val
= IDENTIFIER_CLASS_VALUE (name
);
5087 val
= lookup_member (type
, name
, 0, prefer_type
);
5094 else if (got_object
&& val
)
5098 flags
= lookup_flags (prefer_type
, namespaces_only
);
5100 locval
= classval
= NULL_TREE
;
5102 if (! namespace_bindings_p ())
5103 locval
= qualify_lookup (IDENTIFIER_LOCAL_VALUE (name
), flags
);
5105 /* In C++ class fields are between local and global scope,
5106 just before the global scope. */
5107 if (current_class_type
&& ! nonclass
)
5109 classval
= IDENTIFIER_CLASS_VALUE (name
);
5110 if (classval
== NULL_TREE
&& TYPE_BEING_DEFINED (current_class_type
))
5111 /* Try to find values from base classes if we are presently
5112 defining a type. We are presently only interested in
5114 classval
= lookup_field (current_class_type
, name
, 0, 1);
5116 /* Add implicit 'typename' to types from template bases. lookup_field
5117 will do this for us. If classval is actually from an enclosing
5118 scope, lookup_nested_field will get it for us. */
5119 else if (processing_template_decl
5120 && classval
&& TREE_CODE (classval
) == TYPE_DECL
5121 && ! currently_open_class (DECL_CONTEXT (classval
))
5122 && uses_template_parms (current_class_type
))
5123 classval
= lookup_field (current_class_type
, name
, 0, 1);
5125 /* yylex() calls this with -2, since we should never start digging for
5126 the nested name at the point where we haven't even, for example,
5127 created the COMPONENT_REF or anything like that. */
5128 if (classval
== NULL_TREE
)
5129 classval
= lookup_nested_field (name
, ! yylex
);
5131 classval
= qualify_lookup (classval
, flags
);
5134 if (locval
&& classval
)
5136 if (current_scope () == current_function_decl
5137 && ! hack_decl_function_context (current_function_decl
))
5138 /* Not in a nested function. */
5142 /* This is incredibly horrible. The whole concept of
5143 IDENTIFIER_LOCAL_VALUE / IDENTIFIER_CLASS_VALUE /
5144 IDENTIFIER_GLOBAL_VALUE needs to be scrapped for local
5146 tree lctx
= hack_decl_function_context (locval
);
5147 tree cctx
= hack_decl_function_context (classval
);
5149 if (lctx
== current_scope ())
5151 else if (lctx
== cctx
)
5154 /* I don't know which is right; let's just guess for now. */
5163 val
= unqualified_namespace_lookup (name
, flags
);
5165 /* Any other name takes precedence over an implicit typename. Warn the
5166 user about this potentially confusing lookup. */
5167 if (classval
&& TREE_CODE (val
) == TYPE_DECL
5168 && TREE_CODE (TREE_TYPE (val
)) == TYPENAME_TYPE
5169 && TREE_TYPE (TREE_TYPE (val
)))
5171 if (locval
== NULL_TREE
)
5172 locval
= unqualified_namespace_lookup (name
, flags
);
5174 if (locval
&& val
!= locval
)
5180 /* To avoid redundant warnings, only warn when lexing, and the
5181 decls are significantly different. */
5182 subtype
= TREE_TYPE (TREE_TYPE (classval
));
5184 && ! (TREE_CODE (locval
) == TEMPLATE_DECL
5185 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5186 && CLASSTYPE_TI_TEMPLATE (subtype
) == locval
)
5187 && ! (TREE_CODE (locval
) == TYPE_DECL
5188 && comptypes (TREE_TYPE (locval
), subtype
, 1)))
5190 static int explained
;
5192 cp_warning ("lookup of `%D' finds `%#D'", name
, locval
);
5194 (" instead of `%D' from dependent base class", classval
);
5198 cp_warning (" (use `typename %D' if that's what you meant)",
5208 /* This should only warn about types used in qualified-ids. */
5209 if (from_obj
&& from_obj
!= val
)
5211 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
5212 && TREE_CODE (val
) == TYPE_DECL
5213 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
5215 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5216 name
, got_object
, TREE_TYPE (from_obj
));
5217 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5221 /* We don't change val to from_obj if got_object depends on
5222 template parms because that breaks implicit typename for
5223 destructor calls. */
5224 if (! uses_template_parms (got_object
))
5228 if ((TREE_CODE (val
) == TEMPLATE_DECL
&& looking_for_template
)
5229 || TREE_CODE (val
) == TYPE_DECL
|| prefer_type
<= 0)
5231 /* Caller wants a class-or-namespace-name. */
5232 else if (prefer_type
== 1 && TREE_CODE (val
) == NAMESPACE_DECL
)
5234 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
5235 val
= TYPE_MAIN_DECL (IDENTIFIER_TYPE_VALUE (name
));
5236 else if (TREE_TYPE (val
) == error_mark_node
)
5237 val
= error_mark_node
;
5239 /* If we have a single function from a using decl, pull it out. */
5240 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5241 val
= OVL_FUNCTION (val
);
5250 lookup_name_nonclass (name
)
5253 return lookup_name_real (name
, 0, 1, 0);
5257 lookup_function_nonclass (name
, args
)
5261 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
5265 lookup_name_namespace_only (name
)
5268 /* type-or-namespace, nonclass, namespace_only */
5269 return lookup_name_real (name
, 1, 1, 1);
5273 lookup_name (name
, prefer_type
)
5277 return lookup_name_real (name
, prefer_type
, 0, 0);
5280 /* Similar to `lookup_name' but look only at current binding level. */
5283 lookup_name_current_level (name
)
5286 register tree t
= NULL_TREE
;
5288 if (current_binding_level
->namespace_p
)
5290 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5292 /* extern "C" function() */
5293 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5296 else if (IDENTIFIER_LOCAL_VALUE (name
) != NULL_TREE
)
5298 struct binding_level
*b
= current_binding_level
;
5301 if (purpose_member (name
, b
->shadowed
))
5302 return IDENTIFIER_LOCAL_VALUE (name
);
5313 /* Like lookup_name_current_level, but for types. */
5316 lookup_type_current_level (name
)
5319 register tree t
= NULL_TREE
;
5321 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
5323 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5324 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5326 struct binding_level
*b
= current_binding_level
;
5329 if (purpose_member (name
, b
->type_shadowed
))
5330 return REAL_IDENTIFIER_TYPE_VALUE (name
);
5342 begin_only_namespace_names ()
5344 only_namespace_names
= 1;
5348 end_only_namespace_names ()
5350 only_namespace_names
= 0;
5353 /* Arrange for the user to get a source line number, even when the
5354 compiler is going down in flames, so that she at least has a
5355 chance of working around problems in the compiler. We used to
5356 call error(), but that let the segmentation fault continue
5357 through; now, it's much more passive by asking them to send the
5358 maintainers mail about the problem. */
5362 int sig ATTRIBUTE_UNUSED
;
5364 signal (SIGSEGV
, SIG_DFL
);
5366 signal (SIGIOT
, SIG_DFL
);
5369 signal (SIGILL
, SIG_DFL
);
5372 signal (SIGABRT
, SIG_DFL
);
5375 signal (SIGBUS
, SIG_DFL
);
5377 my_friendly_abort (0);
5381 /* Unused -- brendan 970107 */
5382 /* Array for holding types considered "built-in". These types
5383 are output in the module in which `main' is defined. */
5384 static tree
*builtin_type_tdescs_arr
;
5385 static int builtin_type_tdescs_len
, builtin_type_tdescs_max
;
5388 /* Push the declarations of builtin types into the namespace.
5389 RID_INDEX, if < RID_MAX is the index of the builtin type
5390 in the array RID_POINTERS. NAME is the name used when looking
5391 up the builtin type. TYPE is the _TYPE node for the builtin type. */
5394 record_builtin_type (rid_index
, name
, type
)
5399 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
5400 tree tdecl
= NULL_TREE
;
5402 if ((int) rid_index
< (int) RID_MAX
)
5403 rname
= ridpointers
[(int) rid_index
];
5405 tname
= get_identifier (name
);
5407 TYPE_BUILT_IN (type
) = 1;
5411 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
5412 set_identifier_type_value (tname
, NULL_TREE
);
5413 if ((int) rid_index
< (int) RID_MAX
)
5414 /* Built-in types live in the global namespace. */
5415 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
5417 if (rname
!= NULL_TREE
)
5419 if (tname
!= NULL_TREE
)
5421 set_identifier_type_value (rname
, NULL_TREE
);
5422 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
5426 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
5427 set_identifier_type_value (rname
, NULL_TREE
);
5432 /* Record one of the standard Java types.
5433 * Declare it as having the given NAME.
5434 * If SIZE > 0, it is the size of one of the integral types;
5435 * otherwise it is the negative of the size of one of the other types. */
5438 record_builtin_java_type (name
, size
)
5444 type
= make_signed_type (size
);
5445 else if (size
> -32)
5446 { /* "__java_char" or ""__java_boolean". */
5447 type
= make_unsigned_type (-size
);
5448 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5451 { /* "__java_float" or ""__java_double". */
5452 type
= make_node (REAL_TYPE
);
5453 TYPE_PRECISION (type
) = - size
;
5456 record_builtin_type (RID_MAX
, name
, type
);
5457 decl
= TYPE_NAME (type
);
5458 DECL_IGNORED_P (decl
) = 1;
5459 TYPE_FOR_JAVA (type
) = 1;
5463 /* Push a type into the namespace so that the back-ends ignore it. */
5466 record_unknown_type (type
, name
)
5470 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
5471 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
5472 DECL_IGNORED_P (decl
) = 1;
5473 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
5474 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
5475 TYPE_ALIGN (type
) = 1;
5476 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
5479 /* Push overloaded decl, in global scope, with one argument so it
5480 can be used as a callback from define_function. */
5483 push_overloaded_decl_1 (x
)
5486 push_overloaded_decl (x
, 0);
5493 auto_function (name
, type
, code
)
5495 enum built_in_function code
;
5497 return define_function
5498 (IDENTIFIER_POINTER (name
), type
, code
, push_overloaded_decl_1
,
5499 IDENTIFIER_POINTER (build_decl_overload (name
, TYPE_ARG_TYPES (type
),
5503 /* Create the predefined scalar types of C,
5504 and some nodes representing standard constants (0, 1, (void *)0).
5505 Initialize the global binding level.
5506 Make definitions for built-in primitive functions. */
5509 init_decl_processing ()
5511 register tree endlink
, int_endlink
, double_endlink
, unsigned_endlink
;
5513 /* Data type of memcpy. */
5514 tree memcpy_ftype
, strlen_ftype
;
5515 int wchar_type_size
;
5517 tree array_domain_type
;
5518 tree vb_off_identifier
= NULL_TREE
;
5519 /* Function type `char *(char *, char *)' and similar ones */
5520 tree string_ftype_ptr_ptr
, int_ftype_string_string
;
5521 tree sizetype_endlink
;
5522 tree ptr_ftype
, ptr_ftype_unsigned
, ptr_ftype_sizetype
;
5523 tree void_ftype
, void_ftype_int
, void_ftype_ptr
;
5525 /* Have to make these distinct before we try using them. */
5526 lang_name_cplusplus
= get_identifier ("C++");
5527 lang_name_c
= get_identifier ("C");
5528 lang_name_java
= get_identifier ("Java");
5530 /* Enter the global namespace. */
5531 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
5532 my_friendly_assert (current_lang_name
== NULL_TREE
, 375);
5533 current_lang_name
= lang_name_cplusplus
;
5534 push_namespace (get_identifier ("::"));
5535 global_namespace
= current_namespace
;
5536 current_lang_name
= NULL_TREE
;
5538 if (flag_strict_prototype
== 2)
5539 flag_strict_prototype
= pedantic
;
5541 strict_prototypes_lang_c
= flag_strict_prototype
;
5544 current_lang_name
= lang_name_c
;
5546 current_function_decl
= NULL_TREE
;
5547 named_labels
= NULL_TREE
;
5548 named_label_uses
= NULL
;
5549 current_binding_level
= NULL_BINDING_LEVEL
;
5550 free_binding_level
= NULL_BINDING_LEVEL
;
5552 #ifndef __CYGWIN32__
5553 /* Because most segmentation signals can be traced back into user
5554 code, catch them and at least give the user a chance of working
5555 around compiler bugs. */
5556 signal (SIGSEGV
, signal_catch
);
5558 /* We will also catch aborts in the back-end through signal_catch and
5559 give the user a chance to see where the error might be, and to defeat
5560 aborts in the back-end when there have been errors previously in their
5563 signal (SIGIOT
, signal_catch
);
5566 signal (SIGILL
, signal_catch
);
5569 signal (SIGABRT
, signal_catch
);
5572 signal (SIGBUS
, signal_catch
);
5574 #else /* ndef __CYGWIN32__ */
5575 /* Cygwin32 cannot handle catching signals other than
5576 SIGABRT yet. We hope this will cease to be the case soon. */
5578 signal (SIGABRT
, signal_catch
);
5580 #endif /* ndef __CYGWIN32__ */
5582 gcc_obstack_init (&decl_obstack
);
5584 /* Must lay these out before anything else gets laid out. */
5585 error_mark_node
= make_node (ERROR_MARK
);
5586 TREE_PERMANENT (error_mark_node
) = 1;
5587 TREE_TYPE (error_mark_node
) = error_mark_node
;
5588 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
5589 TREE_TYPE (error_mark_list
) = error_mark_node
;
5591 /* Make the binding_level structure for global names. */
5593 global_binding_level
= current_binding_level
;
5594 /* The global level is the namespace level of ::. */
5595 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
5596 declare_namespace_level ();
5598 this_identifier
= get_identifier (THIS_NAME
);
5599 in_charge_identifier
= get_identifier (IN_CHARGE_NAME
);
5600 ctor_identifier
= get_identifier (CTOR_NAME
);
5601 dtor_identifier
= get_identifier (DTOR_NAME
);
5602 pfn_identifier
= get_identifier (VTABLE_PFN_NAME
);
5603 index_identifier
= get_identifier (VTABLE_INDEX_NAME
);
5604 delta_identifier
= get_identifier (VTABLE_DELTA_NAME
);
5605 delta2_identifier
= get_identifier (VTABLE_DELTA2_NAME
);
5606 pfn_or_delta2_identifier
= get_identifier ("__pfn_or_delta2");
5607 if (flag_handle_signatures
)
5609 tag_identifier
= get_identifier (SIGTABLE_TAG_NAME
);
5610 vb_off_identifier
= get_identifier (SIGTABLE_VB_OFF_NAME
);
5611 vt_off_identifier
= get_identifier (SIGTABLE_VT_OFF_NAME
);
5614 /* Define `int' and `char' first so that dbx will output them first. */
5616 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
5617 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
5619 /* Define `char', which is like either `signed char' or `unsigned char'
5620 but not the same as either. */
5624 ? make_signed_type (CHAR_TYPE_SIZE
)
5625 : make_unsigned_type (CHAR_TYPE_SIZE
));
5626 record_builtin_type (RID_CHAR
, "char", char_type_node
);
5628 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
5629 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
5631 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
5632 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
5634 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
5635 record_builtin_type (RID_MAX
, "long unsigned int", long_unsigned_type_node
);
5636 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
5638 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
5639 record_builtin_type (RID_MAX
, "long long int", long_long_integer_type_node
);
5641 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
5642 record_builtin_type (RID_MAX
, "long long unsigned int",
5643 long_long_unsigned_type_node
);
5644 record_builtin_type (RID_MAX
, "long long unsigned",
5645 long_long_unsigned_type_node
);
5647 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
5648 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
5649 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
5650 record_builtin_type (RID_MAX
, "short unsigned int", short_unsigned_type_node
);
5651 record_builtin_type (RID_MAX
, "unsigned short", short_unsigned_type_node
);
5653 /* `unsigned long' is the standard type for sizeof.
5654 Note that stddef.h uses `unsigned long',
5655 and this must agree, even if long and int are the same size. */
5657 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
5660 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
5662 /* Define both `signed char' and `unsigned char'. */
5663 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
5664 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
5665 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
5666 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
5668 /* These are types that type_for_size and type_for_mode use. */
5669 intQI_type_node
= make_signed_type (GET_MODE_BITSIZE (QImode
));
5670 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
5671 intHI_type_node
= make_signed_type (GET_MODE_BITSIZE (HImode
));
5672 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
5673 intSI_type_node
= make_signed_type (GET_MODE_BITSIZE (SImode
));
5674 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
5675 intDI_type_node
= make_signed_type (GET_MODE_BITSIZE (DImode
));
5676 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
5677 intTI_type_node
= make_signed_type (GET_MODE_BITSIZE (TImode
));
5678 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intTI_type_node
));
5679 unsigned_intQI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (QImode
));
5680 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
5681 unsigned_intHI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (HImode
));
5682 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
5683 unsigned_intSI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (SImode
));
5684 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
5685 unsigned_intDI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (DImode
));
5686 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
5687 unsigned_intTI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (TImode
));
5688 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intTI_type_node
));
5690 float_type_node
= make_node (REAL_TYPE
);
5691 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
5692 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
5693 layout_type (float_type_node
);
5695 double_type_node
= make_node (REAL_TYPE
);
5696 if (flag_short_double
)
5697 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
5699 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
5700 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
5701 layout_type (double_type_node
);
5703 long_double_type_node
= make_node (REAL_TYPE
);
5704 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
5705 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
5706 layout_type (long_double_type_node
);
5708 complex_integer_type_node
= make_node (COMPLEX_TYPE
);
5709 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
5710 complex_integer_type_node
));
5711 TREE_TYPE (complex_integer_type_node
) = integer_type_node
;
5712 layout_type (complex_integer_type_node
);
5714 complex_float_type_node
= make_node (COMPLEX_TYPE
);
5715 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
5716 complex_float_type_node
));
5717 TREE_TYPE (complex_float_type_node
) = float_type_node
;
5718 layout_type (complex_float_type_node
);
5720 complex_double_type_node
= make_node (COMPLEX_TYPE
);
5721 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
5722 complex_double_type_node
));
5723 TREE_TYPE (complex_double_type_node
) = double_type_node
;
5724 layout_type (complex_double_type_node
);
5726 complex_long_double_type_node
= make_node (COMPLEX_TYPE
);
5727 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
5728 complex_long_double_type_node
));
5729 TREE_TYPE (complex_long_double_type_node
) = long_double_type_node
;
5730 layout_type (complex_long_double_type_node
);
5732 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
5733 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
5734 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
5735 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
5736 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
5737 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
5738 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
5739 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
5741 integer_zero_node
= build_int_2 (0, 0);
5742 TREE_TYPE (integer_zero_node
) = integer_type_node
;
5743 integer_one_node
= build_int_2 (1, 0);
5744 TREE_TYPE (integer_one_node
) = integer_type_node
;
5745 integer_two_node
= build_int_2 (2, 0);
5746 TREE_TYPE (integer_two_node
) = integer_type_node
;
5747 integer_three_node
= build_int_2 (3, 0);
5748 TREE_TYPE (integer_three_node
) = integer_type_node
;
5750 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
5751 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
5752 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
5753 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
5754 TYPE_PRECISION (boolean_type_node
) = 1;
5755 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
5756 boolean_false_node
= build_int_2 (0, 0);
5757 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
5758 boolean_true_node
= build_int_2 (1, 0);
5759 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
5761 /* These are needed by stor-layout.c. */
5762 size_zero_node
= size_int (0);
5763 size_one_node
= size_int (1);
5765 signed_size_zero_node
= build_int_2 (0, 0);
5766 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
5768 void_type_node
= make_node (VOID_TYPE
);
5769 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
5770 layout_type (void_type_node
); /* Uses integer_zero_node. */
5771 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
5772 TREE_PARMLIST (void_list_node
) = 1;
5774 null_pointer_node
= build_int_2 (0, 0);
5775 TREE_TYPE (null_pointer_node
) = build_pointer_type (void_type_node
);
5776 layout_type (TREE_TYPE (null_pointer_node
));
5778 /* Used for expressions that do nothing, but are not errors. */
5779 void_zero_node
= build_int_2 (0, 0);
5780 TREE_TYPE (void_zero_node
) = void_type_node
;
5782 string_type_node
= build_pointer_type (char_type_node
);
5783 const_string_type_node
5784 = build_pointer_type (build_type_variant (char_type_node
, 1, 0));
5786 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
5789 /* Make a type to be the domain of a few array types
5790 whose domains don't really matter.
5791 200 is small enough that it always fits in size_t
5792 and large enough that it can hold most function names for the
5793 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5794 array_domain_type
= build_index_type (build_int_2 (200, 0));
5796 /* Make a type for arrays of characters.
5797 With luck nothing will ever really depend on the length of this
5799 char_array_type_node
5800 = build_array_type (char_type_node
, array_domain_type
);
5801 /* Likewise for arrays of ints. */
5803 = build_array_type (integer_type_node
, array_domain_type
);
5805 /* This is just some anonymous class type. Nobody should ever
5806 need to look inside this envelope. */
5807 class_star_type_node
= build_pointer_type (make_lang_type (RECORD_TYPE
));
5809 default_function_type
5810 = build_function_type (integer_type_node
, NULL_TREE
);
5812 ptr_type_node
= build_pointer_type (void_type_node
);
5814 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
5816 record_builtin_type (RID_MAX
, NULL_PTR
, ptr_type_node
);
5818 endlink
= void_list_node
;
5819 int_endlink
= tree_cons (NULL_TREE
, integer_type_node
, endlink
);
5820 double_endlink
= tree_cons (NULL_TREE
, double_type_node
, endlink
);
5821 unsigned_endlink
= tree_cons (NULL_TREE
, unsigned_type_node
, endlink
);
5823 ptr_ftype
= build_function_type (ptr_type_node
, NULL_TREE
);
5824 ptr_ftype_unsigned
= build_function_type (ptr_type_node
, unsigned_endlink
);
5825 sizetype_endlink
= tree_cons (NULL_TREE
, sizetype
, endlink
);
5826 /* We realloc here because sizetype could be int or unsigned. S'ok. */
5827 ptr_ftype_sizetype
= build_function_type (ptr_type_node
, sizetype_endlink
);
5829 void_ftype
= build_function_type (void_type_node
, endlink
);
5830 void_ftype_int
= build_function_type (void_type_node
, int_endlink
);
5832 = build_function_type (void_type_node
,
5833 tree_cons (NULL_TREE
, ptr_type_node
, endlink
));
5835 = build_exception_variant (void_ftype_ptr
,
5836 tree_cons (NULL_TREE
, NULL_TREE
, NULL_TREE
));
5839 = build_function_type (float_type_node
,
5840 tree_cons (NULL_TREE
, float_type_node
, endlink
));
5843 = build_function_type (double_type_node
, double_endlink
);
5845 ldouble_ftype_ldouble
5846 = build_function_type (long_double_type_node
,
5847 tree_cons (NULL_TREE
, long_double_type_node
,
5850 double_ftype_double_double
5851 = build_function_type (double_type_node
,
5852 tree_cons (NULL_TREE
, double_type_node
,
5856 = build_function_type (integer_type_node
, int_endlink
);
5859 = build_function_type (long_integer_type_node
,
5860 tree_cons (NULL_TREE
, long_integer_type_node
,
5863 int_ftype_cptr_cptr_sizet
5864 = build_function_type (integer_type_node
,
5865 tree_cons (NULL_TREE
, const_ptr_type_node
,
5866 tree_cons (NULL_TREE
, const_ptr_type_node
,
5867 tree_cons (NULL_TREE
,
5871 string_ftype_ptr_ptr
/* strcpy prototype */
5872 = build_function_type (string_type_node
,
5873 tree_cons (NULL_TREE
, string_type_node
,
5874 tree_cons (NULL_TREE
,
5875 const_string_type_node
,
5878 int_ftype_string_string
/* strcmp prototype */
5879 = build_function_type (integer_type_node
,
5880 tree_cons (NULL_TREE
, const_string_type_node
,
5881 tree_cons (NULL_TREE
,
5882 const_string_type_node
,
5885 strlen_ftype
/* strlen prototype */
5886 = build_function_type (sizetype
,
5887 tree_cons (NULL_TREE
, const_string_type_node
,
5890 memcpy_ftype
/* memcpy prototype */
5891 = build_function_type (ptr_type_node
,
5892 tree_cons (NULL_TREE
, ptr_type_node
,
5893 tree_cons (NULL_TREE
, const_ptr_type_node
,
5894 sizetype_endlink
)));
5896 if (flag_huge_objects
)
5897 delta_type_node
= long_integer_type_node
;
5899 delta_type_node
= short_integer_type_node
;
5901 builtin_function ("__builtin_constant_p", default_function_type
,
5902 BUILT_IN_CONSTANT_P
, NULL_PTR
);
5904 builtin_return_address_fndecl
5905 = builtin_function ("__builtin_return_address", ptr_ftype_unsigned
,
5906 BUILT_IN_RETURN_ADDRESS
, NULL_PTR
);
5908 builtin_function ("__builtin_frame_address", ptr_ftype_unsigned
,
5909 BUILT_IN_FRAME_ADDRESS
, NULL_PTR
);
5911 builtin_function ("__builtin_alloca", ptr_ftype_sizetype
,
5912 BUILT_IN_ALLOCA
, "alloca");
5913 builtin_function ("__builtin_ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
5914 /* Define alloca, ffs as builtins.
5915 Declare _exit just to mark it as volatile. */
5916 if (! flag_no_builtin
&& !flag_no_nonansi_builtin
)
5918 temp
= builtin_function ("alloca", ptr_ftype_sizetype
,
5919 BUILT_IN_ALLOCA
, NULL_PTR
);
5920 /* Suppress error if redefined as a non-function. */
5921 DECL_BUILT_IN_NONANSI (temp
) = 1;
5922 temp
= builtin_function ("ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
5923 /* Suppress error if redefined as a non-function. */
5924 DECL_BUILT_IN_NONANSI (temp
) = 1;
5925 temp
= builtin_function ("_exit", void_ftype_int
,
5926 NOT_BUILT_IN
, NULL_PTR
);
5927 TREE_THIS_VOLATILE (temp
) = 1;
5928 TREE_SIDE_EFFECTS (temp
) = 1;
5929 /* Suppress error if redefined as a non-function. */
5930 DECL_BUILT_IN_NONANSI (temp
) = 1;
5933 builtin_function ("__builtin_abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
5934 builtin_function ("__builtin_fabsf", float_ftype_float
, BUILT_IN_FABS
,
5936 builtin_function ("__builtin_fabs", double_ftype_double
, BUILT_IN_FABS
,
5938 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
5940 builtin_function ("__builtin_labs", long_ftype_long
,
5941 BUILT_IN_LABS
, NULL_PTR
);
5942 builtin_function ("__builtin_saveregs", ptr_ftype
,
5943 BUILT_IN_SAVEREGS
, NULL_PTR
);
5944 builtin_function ("__builtin_classify_type", default_function_type
,
5945 BUILT_IN_CLASSIFY_TYPE
, NULL_PTR
);
5946 builtin_function ("__builtin_next_arg", ptr_ftype
,
5947 BUILT_IN_NEXT_ARG
, NULL_PTR
);
5948 builtin_function ("__builtin_args_info", int_ftype_int
,
5949 BUILT_IN_ARGS_INFO
, NULL_PTR
);
5950 builtin_function ("__builtin_setjmp",
5951 build_function_type (integer_type_node
,
5952 tree_cons (NULL_TREE
, ptr_type_node
,
5954 BUILT_IN_SETJMP
, NULL_PTR
);
5955 builtin_function ("__builtin_longjmp",
5956 build_function_type (integer_type_node
,
5957 tree_cons (NULL_TREE
, ptr_type_node
,
5958 tree_cons (NULL_TREE
,
5961 BUILT_IN_LONGJMP
, NULL_PTR
);
5963 /* Untyped call and return. */
5964 builtin_function ("__builtin_apply_args", ptr_ftype
,
5965 BUILT_IN_APPLY_ARGS
, NULL_PTR
);
5967 temp
= tree_cons (NULL_TREE
,
5968 build_pointer_type (build_function_type (void_type_node
,
5970 tree_cons (NULL_TREE
, ptr_ftype_sizetype
, NULL_TREE
));
5971 builtin_function ("__builtin_apply",
5972 build_function_type (ptr_type_node
, temp
),
5973 BUILT_IN_APPLY
, NULL_PTR
);
5974 builtin_function ("__builtin_return", void_ftype_ptr
,
5975 BUILT_IN_RETURN
, NULL_PTR
);
5977 /* Currently under experimentation. */
5978 builtin_function ("__builtin_memcpy", memcpy_ftype
,
5979 BUILT_IN_MEMCPY
, "memcpy");
5980 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet
,
5981 BUILT_IN_MEMCMP
, "memcmp");
5982 builtin_function ("__builtin_strcmp", int_ftype_string_string
,
5983 BUILT_IN_STRCMP
, "strcmp");
5984 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr
,
5985 BUILT_IN_STRCPY
, "strcpy");
5986 builtin_function ("__builtin_strlen", strlen_ftype
,
5987 BUILT_IN_STRLEN
, "strlen");
5988 builtin_function ("__builtin_sqrtf", float_ftype_float
,
5989 BUILT_IN_FSQRT
, "sqrtf");
5990 builtin_function ("__builtin_fsqrt", double_ftype_double
,
5991 BUILT_IN_FSQRT
, NULL_PTR
);
5992 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble
,
5993 BUILT_IN_FSQRT
, "sqrtl");
5994 builtin_function ("__builtin_sinf", float_ftype_float
,
5995 BUILT_IN_SIN
, "sinf");
5996 builtin_function ("__builtin_sin", double_ftype_double
,
5997 BUILT_IN_SIN
, "sin");
5998 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble
,
5999 BUILT_IN_SIN
, "sinl");
6000 builtin_function ("__builtin_cosf", float_ftype_float
,
6001 BUILT_IN_COS
, "cosf");
6002 builtin_function ("__builtin_cos", double_ftype_double
,
6003 BUILT_IN_COS
, "cos");
6004 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble
,
6005 BUILT_IN_COS
, "cosl");
6007 if (!flag_no_builtin
)
6009 builtin_function ("abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
6010 builtin_function ("fabs", double_ftype_double
, BUILT_IN_FABS
, NULL_PTR
);
6011 builtin_function ("labs", long_ftype_long
, BUILT_IN_LABS
, NULL_PTR
);
6012 builtin_function ("fabsf", float_ftype_float
, BUILT_IN_FABS
, NULL_PTR
);
6013 builtin_function ("fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
6015 builtin_function ("memcpy", memcpy_ftype
, BUILT_IN_MEMCPY
, NULL_PTR
);
6016 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet
, BUILT_IN_MEMCMP
,
6018 builtin_function ("strcmp", int_ftype_string_string
, BUILT_IN_STRCMP
,
6020 builtin_function ("strcpy", string_ftype_ptr_ptr
, BUILT_IN_STRCPY
,
6022 builtin_function ("strlen", strlen_ftype
, BUILT_IN_STRLEN
, NULL_PTR
);
6023 builtin_function ("sqrtf", float_ftype_float
, BUILT_IN_FSQRT
, NULL_PTR
);
6024 builtin_function ("sqrt", double_ftype_double
, BUILT_IN_FSQRT
, NULL_PTR
);
6025 builtin_function ("sqrtl", ldouble_ftype_ldouble
, BUILT_IN_FSQRT
,
6027 builtin_function ("sinf", float_ftype_float
, BUILT_IN_SIN
, NULL_PTR
);
6028 builtin_function ("sin", double_ftype_double
, BUILT_IN_SIN
, NULL_PTR
);
6029 builtin_function ("sinl", ldouble_ftype_ldouble
, BUILT_IN_SIN
, NULL_PTR
);
6030 builtin_function ("cosf", float_ftype_float
, BUILT_IN_COS
, NULL_PTR
);
6031 builtin_function ("cos", double_ftype_double
, BUILT_IN_COS
, NULL_PTR
);
6032 builtin_function ("cosl", ldouble_ftype_ldouble
, BUILT_IN_COS
, NULL_PTR
);
6034 /* Declare these functions volatile
6035 to avoid spurious "control drops through" warnings. */
6036 temp
= builtin_function ("abort", void_ftype
,
6037 NOT_BUILT_IN
, NULL_PTR
);
6038 TREE_THIS_VOLATILE (temp
) = 1;
6039 TREE_SIDE_EFFECTS (temp
) = 1;
6040 /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
6042 DECL_BUILT_IN_NONANSI (temp
) = 1;
6043 temp
= builtin_function ("exit", void_ftype_int
,
6044 NOT_BUILT_IN
, NULL_PTR
);
6045 TREE_THIS_VOLATILE (temp
) = 1;
6046 TREE_SIDE_EFFECTS (temp
) = 1;
6047 DECL_BUILT_IN_NONANSI (temp
) = 1;
6051 /* Support for these has not been written in either expand_builtin
6052 or build_function_call. */
6053 builtin_function ("__builtin_div", default_ftype
, BUILT_IN_DIV
, NULL_PTR
);
6054 builtin_function ("__builtin_ldiv", default_ftype
, BUILT_IN_LDIV
, NULL_PTR
);
6055 builtin_function ("__builtin_ffloor", double_ftype_double
, BUILT_IN_FFLOOR
,
6057 builtin_function ("__builtin_fceil", double_ftype_double
, BUILT_IN_FCEIL
,
6059 builtin_function ("__builtin_fmod", double_ftype_double_double
,
6060 BUILT_IN_FMOD
, NULL_PTR
);
6061 builtin_function ("__builtin_frem", double_ftype_double_double
,
6062 BUILT_IN_FREM
, NULL_PTR
);
6063 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int
,
6064 BUILT_IN_MEMSET
, NULL_PTR
);
6065 builtin_function ("__builtin_getexp", double_ftype_double
, BUILT_IN_GETEXP
,
6067 builtin_function ("__builtin_getman", double_ftype_double
, BUILT_IN_GETMAN
,
6071 /* C++ extensions */
6073 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6074 record_unknown_type (unknown_type_node
, "unknown type");
6076 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6077 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6079 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6081 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6083 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6084 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6086 /* This is for handling opaque types in signatures. */
6087 opaque_type_node
= copy_node (ptr_type_node
);
6088 TYPE_MAIN_VARIANT (opaque_type_node
) = opaque_type_node
;
6089 record_builtin_type (RID_MAX
, 0, opaque_type_node
);
6091 /* This is special for C++ so functions can be overloaded. */
6093 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE
)));
6094 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6095 signed_wchar_type_node
= make_signed_type (wchar_type_size
);
6096 unsigned_wchar_type_node
= make_unsigned_type (wchar_type_size
);
6098 = TREE_UNSIGNED (wchar_type_node
)
6099 ? unsigned_wchar_type_node
6100 : signed_wchar_type_node
;
6101 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6103 /* Artificial declaration of wchar_t -- can be bashed */
6104 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6106 pushdecl (wchar_decl_node
);
6108 /* This is for wide string constants. */
6109 wchar_array_type_node
6110 = build_array_type (wchar_type_node
, array_domain_type
);
6112 if (flag_vtable_thunks
)
6114 /* Make sure we get a unique function type, so we can give
6115 its pointer type a name. (This wins for gdb.) */
6116 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6117 TREE_TYPE (vfunc_type
) = integer_type_node
;
6118 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6119 layout_type (vfunc_type
);
6121 vtable_entry_type
= build_pointer_type (vfunc_type
);
6125 vtable_entry_type
= make_lang_type (RECORD_TYPE
);
6126 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
6128 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
6130 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
6132 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6135 /* Make this part of an invisible union. */
6136 fields
[3] = copy_node (fields
[2]);
6137 TREE_TYPE (fields
[3]) = delta_type_node
;
6138 DECL_NAME (fields
[3]) = delta2_identifier
;
6139 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6140 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6141 TREE_UNSIGNED (fields
[3]) = 0;
6142 TREE_CHAIN (fields
[2]) = fields
[3];
6143 vtable_entry_type
= build_type_variant (vtable_entry_type
, 1, 0);
6145 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6148 = build_array_type (vtable_entry_type
, NULL_TREE
);
6149 layout_type (vtbl_type_node
);
6150 vtbl_type_node
= cp_build_type_variant (vtbl_type_node
, 1, 0);
6151 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6152 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6153 layout_type (vtbl_ptr_type_node
);
6154 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6156 /* Simplify life by making a "sigtable_entry_type". Give its
6157 fields names so that the debugger can use them. */
6159 if (flag_handle_signatures
)
6161 sigtable_entry_type
= make_lang_type (RECORD_TYPE
);
6162 fields
[0] = build_lang_field_decl (FIELD_DECL
, tag_identifier
,
6164 fields
[1] = build_lang_field_decl (FIELD_DECL
, vb_off_identifier
,
6166 fields
[2] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
6168 fields
[3] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
6170 fields
[4] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
6173 /* Set the alignment to the max of the alignment of ptr_type_node and
6174 delta_type_node. Double alignment wastes a word on the Sparc. */
6175 finish_builtin_type (sigtable_entry_type
, SIGTABLE_PTR_TYPE
, fields
, 4,
6176 (TYPE_ALIGN (ptr_type_node
) > TYPE_ALIGN (delta_type_node
))
6180 /* Make this part of an invisible union. */
6181 fields
[5] = copy_node (fields
[4]);
6182 TREE_TYPE (fields
[5]) = delta_type_node
;
6183 DECL_NAME (fields
[5]) = vt_off_identifier
;
6184 DECL_MODE (fields
[5]) = TYPE_MODE (delta_type_node
);
6185 DECL_SIZE (fields
[5]) = TYPE_SIZE (delta_type_node
);
6186 TREE_UNSIGNED (fields
[5]) = 0;
6187 TREE_CHAIN (fields
[4]) = fields
[5];
6189 sigtable_entry_type
= build_type_variant (sigtable_entry_type
, 1, 0);
6190 record_builtin_type (RID_MAX
, SIGTABLE_PTR_TYPE
, sigtable_entry_type
);
6193 std_node
= build_decl (NAMESPACE_DECL
,
6194 get_identifier (flag_honor_std
? "fake std":"std"),
6196 pushdecl (std_node
);
6198 global_type_node
= make_node (LANG_TYPE
);
6199 record_unknown_type (global_type_node
, "global type");
6202 current_lang_name
= lang_name_cplusplus
;
6205 tree bad_alloc_type_node
, newtype
, deltype
;
6207 push_namespace (get_identifier ("std"));
6208 bad_alloc_type_node
= xref_tag
6209 (class_type_node
, get_identifier ("bad_alloc"), 1);
6212 newtype
= build_exception_variant
6213 (ptr_ftype_sizetype
, build_tree_list (NULL_TREE
, bad_alloc_type_node
));
6214 deltype
= build_exception_variant
6215 (void_ftype_ptr
, build_tree_list (NULL_TREE
, NULL_TREE
));
6216 auto_function (ansi_opname
[(int) NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6217 auto_function (ansi_opname
[(int) VEC_NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6218 auto_function (ansi_opname
[(int) DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6219 auto_function (ansi_opname
[(int) VEC_DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6223 = define_function ("__pure_virtual", void_ftype
,
6224 NOT_BUILT_IN
, 0, 0);
6226 /* Perform other language dependent initializations. */
6227 init_class_processing ();
6228 init_init_processing ();
6229 init_search_processing ();
6231 init_rtti_processing ();
6233 if (flag_exceptions
)
6234 init_exception_processing ();
6237 flag_inline_functions
= 0;
6240 if (! supports_one_only ())
6243 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6244 declare_function_name ();
6246 /* Prepare to check format strings against argument lists. */
6247 init_function_format_info ();
6249 /* Show we use EH for cleanups. */
6250 using_eh_for_cleanups ();
6252 print_error_function
= lang_print_error_function
;
6253 lang_get_alias_set
= &c_get_alias_set
;
6255 /* Maintain consistency. Perhaps we should just complain if they
6256 say -fwritable-strings? */
6257 if (flag_writable_strings
)
6258 flag_const_strings
= 0;
6261 /* Function to print any language-specific context for an error message. */
6264 lang_print_error_function (file
)
6267 default_print_error_function (file
);
6268 maybe_print_template_context ();
6271 /* Make a definition for a builtin function named NAME and whose data type
6272 is TYPE. TYPE should be a function type with argument types.
6273 FUNCTION_CODE tells later passes how to compile calls to this function.
6274 See tree.h for its possible values.
6276 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6277 the name to be called if we can't opencode the function. */
6280 define_function (name
, type
, function_code
, pfn
, library_name
)
6283 enum built_in_function function_code
;
6284 void (*pfn
) PROTO((tree
));
6287 tree decl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), type
);
6288 DECL_EXTERNAL (decl
) = 1;
6289 TREE_PUBLIC (decl
) = 1;
6290 DECL_ARTIFICIAL (decl
) = 1;
6292 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6293 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
6295 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6296 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6297 function in the namespace. */
6298 if (pfn
) (*pfn
) (decl
);
6300 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
6301 make_function_rtl (decl
);
6302 if (function_code
!= NOT_BUILT_IN
)
6304 DECL_BUILT_IN (decl
) = 1;
6305 DECL_FUNCTION_CODE (decl
) = function_code
;
6310 /* When we call finish_struct for an anonymous union, we create
6311 default copy constructors and such. But, an anonymous union
6312 shouldn't have such things; this function undoes the damage to the
6313 anonymous union type T.
6315 (The reason that we create the synthesized methods is that we don't
6316 distinguish `union { int i; }' from `typedef union { int i; } U'.
6317 The first is an anonymous union; the second is just an ordinary
6321 fixup_anonymous_union (t
)
6326 /* Wipe out memory of synthesized methods */
6327 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6328 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6329 TYPE_HAS_INIT_REF (t
) = 0;
6330 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6331 TYPE_HAS_ASSIGN_REF (t
) = 0;
6332 TYPE_HAS_ASSIGNMENT (t
) = 0;
6333 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6335 /* Splice the implicitly generated functions out of the TYPE_METHODS
6337 q
= &TYPE_METHODS (t
);
6340 if (DECL_ARTIFICIAL (*q
))
6341 *q
= TREE_CHAIN (*q
);
6343 q
= &TREE_CHAIN (*q
);
6346 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
6347 function members. */
6348 if (TYPE_METHODS (t
))
6349 error ("an anonymous union cannot have function members");
6352 /* Called when a declaration is seen that contains no names to declare.
6353 If its type is a reference to a structure, union or enum inherited
6354 from a containing scope, shadow that tag name for the current scope
6355 with a forward reference.
6356 If its type defines a new named structure or union
6357 or defines an enum, it is valid but we need not do anything here.
6358 Otherwise, it is an error.
6360 C++: may have to grok the declspecs to learn about static,
6361 complain for anonymous unions. */
6364 shadow_tag (declspecs
)
6368 tree ob_modifier
= NULL_TREE
;
6370 register enum tree_code code
, ok_code
= ERROR_MARK
;
6371 register tree t
= NULL_TREE
;
6373 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6375 register tree value
= TREE_VALUE (link
);
6377 code
= TREE_CODE (value
);
6378 if (IS_AGGR_TYPE_CODE (code
) || code
== ENUMERAL_TYPE
)
6380 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
6382 maybe_process_partial_specialization (value
);
6388 else if (value
== ridpointers
[(int) RID_STATIC
]
6389 || value
== ridpointers
[(int) RID_EXTERN
]
6390 || value
== ridpointers
[(int) RID_AUTO
]
6391 || value
== ridpointers
[(int) RID_REGISTER
]
6392 || value
== ridpointers
[(int) RID_INLINE
]
6393 || value
== ridpointers
[(int) RID_VIRTUAL
]
6394 || value
== ridpointers
[(int) RID_EXPLICIT
])
6395 ob_modifier
= value
;
6398 /* This is where the variables in an anonymous union are
6399 declared. An anonymous union declaration looks like:
6401 because there is no declarator after the union, the parser
6402 sends that declaration here. */
6403 if (ok_code
== UNION_TYPE
6405 && ((TREE_CODE (TYPE_NAME (t
)) == IDENTIFIER_NODE
6406 && ANON_AGGRNAME_P (TYPE_NAME (t
)))
6407 || (TREE_CODE (TYPE_NAME (t
)) == TYPE_DECL
6408 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))))
6410 fixup_anonymous_union (t
);
6412 if (TYPE_FIELDS (t
))
6414 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
6416 finish_anon_union (decl
);
6421 /* Anonymous unions are objects, that's why we only check for
6422 inappropriate specifiers in this branch. */
6426 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
6427 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
6428 cp_error ("`%D' can only be specified for functions", ob_modifier
);
6429 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
6430 cp_error ("`%D' can only be specified for constructors",
6433 cp_error ("`%D' can only be specified for objects and functions",
6438 cp_error ("abstract declarator used as declaration");
6439 else if (found_tag
> 1)
6440 pedwarn ("multiple types in one declaration");
6444 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6447 groktypename (typename
)
6450 if (TREE_CODE (typename
) != TREE_LIST
)
6452 return grokdeclarator (TREE_VALUE (typename
),
6453 TREE_PURPOSE (typename
),
6454 TYPENAME
, 0, NULL_TREE
);
6457 /* Decode a declarator in an ordinary declaration or data definition.
6458 This is called as soon as the type information and variable name
6459 have been parsed, before parsing the initializer if any.
6460 Here we create the ..._DECL node, fill in its type,
6461 and put it on the list of decls for the current context.
6462 The ..._DECL node is returned as the value.
6464 Exception: for arrays where the length is not specified,
6465 the type is left null, to be filled in by `cp_finish_decl'.
6467 Function definitions do not come here; they go to start_function
6468 instead. However, external and forward declarations of functions
6469 do go through here. Structure field declarations are done by
6470 grokfield and not through here. */
6472 /* Set this to zero to debug not using the temporary obstack
6473 to parse initializers. */
6474 int debug_temp_inits
= 1;
6477 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
6478 tree declarator
, declspecs
;
6480 tree attributes
, prefix_attributes
;
6483 register tree type
, tem
;
6485 extern int have_extern_spec
;
6486 extern int used_extern_spec
;
6489 /* See code below that used this. */
6490 int init_written
= initialized
;
6493 /* This should only be done once on the top most decl. */
6494 if (have_extern_spec
&& !used_extern_spec
)
6496 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
6498 used_extern_spec
= 1;
6501 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
6503 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
6506 type
= TREE_TYPE (decl
);
6508 /* Don't lose if destructors must be executed at file-level. */
6509 if (! processing_template_decl
&& TREE_STATIC (decl
)
6510 && TYPE_NEEDS_DESTRUCTOR (complete_type (type
))
6511 && !TREE_PERMANENT (decl
))
6513 push_obstacks (&permanent_obstack
, &permanent_obstack
);
6514 decl
= copy_node (decl
);
6515 if (TREE_CODE (type
) == ARRAY_TYPE
)
6517 tree itype
= TYPE_DOMAIN (type
);
6518 if (itype
&& ! TREE_PERMANENT (itype
))
6520 itype
= build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype
)));
6521 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
6522 TREE_TYPE (decl
) = type
;
6529 = (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
6530 ? DECL_CLASS_CONTEXT (decl
)
6531 : DECL_CONTEXT (decl
);
6533 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
6534 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
6536 /* When parsing the initializer, lookup should use the object's
6538 push_decl_namespace (context
);
6541 /* We are only interested in class contexts, later. */
6542 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
6543 context
= NULL_TREE
;
6546 /* Is it valid for this decl to have an initializer at all?
6547 If not, set INITIALIZED to zero, which will indirectly
6548 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6549 switch (TREE_CODE (decl
))
6552 /* typedef foo = bar means give foo the same type as bar.
6553 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6554 Any other case of an initialization in a TYPE_DECL is an error. */
6555 if (pedantic
|| list_length (declspecs
) > 1)
6557 cp_error ("typedef `%D' is initialized", decl
);
6563 cp_error ("function `%#D' is initialized like a variable", decl
);
6568 if (! processing_template_decl
)
6570 if (type
!= error_mark_node
)
6572 if (TYPE_SIZE (type
) != NULL_TREE
6573 && ! TREE_CONSTANT (TYPE_SIZE (type
)))
6576 ("variable-sized object `%D' may not be initialized",
6581 if (TREE_CODE (type
) == ARRAY_TYPE
6582 && TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6585 ("elements of array `%#D' have incomplete type", decl
);
6594 if (! toplevel_bindings_p ()
6595 && DECL_EXTERNAL (decl
))
6596 cp_warning ("declaration of `%#D' has `extern' and is initialized",
6598 DECL_EXTERNAL (decl
) = 0;
6599 if (toplevel_bindings_p ())
6600 TREE_STATIC (decl
) = 1;
6602 /* Tell `pushdecl' this is an initialized decl
6603 even though we don't yet have the initializer expression.
6604 Also tell `cp_finish_decl' it may store the real initializer. */
6605 DECL_INITIAL (decl
) = error_mark_node
;
6608 if (context
&& TYPE_SIZE (complete_type (context
)) != NULL_TREE
)
6610 if (TREE_CODE (decl
) == VAR_DECL
)
6612 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
6613 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
6614 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
6617 if (DECL_CONTEXT (field
) != context
)
6619 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6620 DECL_CONTEXT (field
), DECL_NAME (decl
),
6621 context
, DECL_NAME (decl
));
6622 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
6624 /* Static data member are tricky; an in-class initialization
6625 still doesn't provide a definition, so the in-class
6626 declaration will have DECL_EXTERNAL set, but will have an
6627 initialization. Thus, duplicate_decls won't warn
6628 about this situation, and so we check here. */
6629 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
6630 cp_error ("duplicate initialization of %D", decl
);
6631 if (duplicate_decls (decl
, field
))
6637 tree field
= check_classfn (context
, decl
);
6638 if (field
&& duplicate_decls (decl
, field
))
6642 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6643 DECL_IN_AGGR_P (decl
) = 0;
6644 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
6645 || CLASSTYPE_USE_TEMPLATE (context
))
6646 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
6648 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
6649 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6652 pushclass (context
, 2);
6655 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6656 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
6659 /* Set attributes here so if duplicate decl, will have proper attributes. */
6660 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
6662 /* Add this decl to the current binding level, but not if it
6663 comes from another scope, e.g. a static member variable.
6664 TEM may equal DECL or it may be a previous decl of the same name. */
6666 if ((TREE_CODE (decl
) != PARM_DECL
&& DECL_CONTEXT (decl
) != NULL_TREE
6667 /* Definitions of namespace members outside their namespace are
6669 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
6670 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
6671 || TREE_CODE (type
) == LANG_TYPE
6672 /* The declaration of template specializations does not affect
6673 the functions available for overload resolution, so we do not
6675 || (TREE_CODE (decl
) == FUNCTION_DECL
6676 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
6679 tem
= pushdecl (decl
);
6681 if (processing_template_decl
)
6683 if (! current_function_decl
)
6684 tem
= push_template_decl (tem
);
6685 else if (minimal_parse_mode
)
6687 = build_min_nt (DECL_STMT
, copy_to_permanent (declarator
),
6688 copy_to_permanent (declspecs
),
6693 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6694 /* Tell the back-end to use or not use .common as appropriate. If we say
6695 -fconserve-space, we want this to save .data space, at the expense of
6696 wrong semantics. If we say -fno-conserve-space, we want this to
6697 produce errors about redefs; to do this we force variables into the
6699 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
6702 if (! processing_template_decl
)
6705 /* Corresponding pop_obstacks is done in `cp_finish_decl'. */
6706 push_obstacks_nochange ();
6709 /* We have no way of knowing whether the initializer will need to be
6710 evaluated at run-time or not until we've parsed it, so let's just put
6711 it in the permanent obstack. (jason) */
6713 && ! (TREE_CODE (tem
) == PARM_DECL
6714 || (TREE_READONLY (tem
)
6715 && (TREE_CODE (tem
) == VAR_DECL
6716 || TREE_CODE (tem
) == FIELD_DECL
))))
6718 /* When parsing and digesting the initializer,
6719 use temporary storage. Do this even if we will ignore the value. */
6720 if (toplevel_bindings_p () && debug_temp_inits
)
6722 if (processing_template_decl
6723 || TYPE_NEEDS_CONSTRUCTING (type
)
6724 || TREE_CODE (type
) == REFERENCE_TYPE
)
6725 /* In this case, the initializer must lay down in permanent
6726 storage, since it will be saved until `finish_file' is run. */
6729 temporary_allocation ();
6741 tree type
= TREE_TYPE (decl
);
6742 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
6744 /* If this type of object needs a cleanup, and control may
6745 jump past it, make a new binding level so that it is cleaned
6746 up only when it is initialized first. */
6747 if (TYPE_NEEDS_DESTRUCTOR (type
)
6748 && current_binding_level
->more_cleanups_ok
== 0)
6749 pushlevel_temporary (1);
6752 /* Is it valid for this decl to have an initializer at all?
6753 If not, set INITIALIZED to zero, which will indirectly
6754 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6756 /* Don't allow initializations for incomplete types except for
6757 arrays which might be completed by the initialization. */
6758 if (type
== error_mark_node
)
6759 ; /* Don't complain again. */
6760 else if (TYPE_SIZE (complete_type (type
)) != NULL_TREE
)
6761 ; /* A complete type is ok. */
6762 else if (TREE_CODE (type
) != ARRAY_TYPE
)
6764 cp_error ("variable `%#D' has initializer but incomplete type",
6767 type
= TREE_TYPE (decl
) = error_mark_node
;
6769 else if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6771 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
6772 cp_error ("elements of array `%#D' have incomplete type", decl
);
6773 /* else we already gave an error in start_decl. */
6779 && TREE_CODE (decl
) != TYPE_DECL
6780 && TREE_CODE (decl
) != TEMPLATE_DECL
6781 && IS_AGGR_TYPE (type
) && ! DECL_EXTERNAL (decl
))
6783 if ((! processing_template_decl
|| ! uses_template_parms (type
))
6784 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
6786 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6788 /* Change the type so that assemble_variable will give
6789 DECL an rtl we can live with: (mem (const_int 0)). */
6790 type
= TREE_TYPE (decl
) = error_mark_node
;
6794 /* If any base type in the hierarchy of TYPE needs a constructor,
6795 then we set initialized to 1. This way any nodes which are
6796 created for the purposes of initializing this aggregate
6797 will live as long as it does. This is necessary for global
6798 aggregates which do not have their initializers processed until
6799 the end of the file. */
6800 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
6805 /* We don't do this yet for GNU C++. */
6806 /* For a local variable, define the RTL now. */
6807 if (! toplevel_bindings_p ()
6808 /* But not if this is a duplicate decl
6809 and we preserved the rtl from the previous one
6810 (which may or may not happen). */
6811 && DECL_RTL (tem
) == NULL_RTX
)
6813 if (TYPE_SIZE (TREE_TYPE (tem
)) != NULL_TREE
)
6815 else if (TREE_CODE (TREE_TYPE (tem
)) == ARRAY_TYPE
6816 && DECL_INITIAL (tem
) != NULL_TREE
)
6822 DECL_INITIAL (decl
) = NULL_TREE
;
6825 /* Handle initialization of references.
6826 These three arguments are from `cp_finish_decl', and have the
6827 same meaning here that they do there.
6829 Quotes on semantics can be found in ARM 8.4.3. */
6832 grok_reference_init (decl
, type
, init
)
6833 tree decl
, type
, init
;
6837 if (init
== NULL_TREE
)
6839 if ((DECL_LANG_SPECIFIC (decl
) == 0
6840 || DECL_IN_AGGR_P (decl
) == 0)
6841 && ! DECL_THIS_EXTERN (decl
))
6843 cp_error ("`%D' declared as reference but not initialized", decl
);
6844 if (TREE_CODE (decl
) == VAR_DECL
)
6845 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
6850 if (init
== error_mark_node
)
6853 if (TREE_CODE (type
) == REFERENCE_TYPE
6854 && TREE_CODE (init
) == CONSTRUCTOR
)
6856 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl
);
6860 if (TREE_TYPE (init
) && TREE_CODE (TREE_TYPE (init
)) == UNKNOWN_TYPE
)
6861 /* decay_conversion is probably wrong for references to functions. */
6862 init
= decay_conversion (instantiate_type (TREE_TYPE (type
), init
, 1));
6864 if (TREE_CODE (init
) == TREE_LIST
)
6865 init
= build_compound_expr (init
);
6867 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
6868 init
= convert_from_reference (init
);
6870 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
6871 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
6873 /* Note: default conversion is only called in very special cases. */
6874 init
= default_conversion (init
);
6877 tmp
= convert_to_reference
6878 (type
, init
, CONV_IMPLICIT
,
6879 LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
, decl
);
6881 if (tmp
== error_mark_node
)
6883 else if (tmp
!= NULL_TREE
)
6886 DECL_INITIAL (decl
) = save_expr (init
);
6890 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
6894 /* ?? Can this be optimized in some cases to
6895 hand back the DECL_INITIAL slot?? */
6896 if (TYPE_SIZE (TREE_TYPE (type
)))
6898 init
= convert_from_reference (decl
);
6899 if (TREE_PERMANENT (decl
))
6900 init
= copy_to_permanent (init
);
6901 SET_DECL_REFERENCE_SLOT (decl
, init
);
6904 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
6906 expand_static_init (decl
, DECL_INITIAL (decl
));
6907 DECL_INITIAL (decl
) = NULL_TREE
;
6912 if (TREE_CODE (decl
) == VAR_DECL
)
6913 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
6917 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6918 mucking with forces it does not comprehend (i.e. initialization with a
6919 constructor). If we are at global scope and won't go into COMMON, fill
6920 it in with a dummy CONSTRUCTOR to force the variable into .data;
6921 otherwise we can use error_mark_node. */
6924 obscure_complex_init (decl
, init
)
6927 if (! flag_no_inline
&& TREE_STATIC (decl
))
6929 if (extract_init (decl
, init
))
6933 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6934 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
6935 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
6939 DECL_INITIAL (decl
) = error_mark_node
;
6944 /* Finish processing of a declaration;
6945 install its line number and initial value.
6946 If the length of an array type is not known before,
6947 it must be determined now, from the initial value, or it is an error.
6949 Call `pop_obstacks' iff NEED_POP is nonzero.
6951 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
6952 for aggregates that have constructors alive on the permanent obstack,
6953 so that the global initializing functions can be written at the end.
6955 INIT0 holds the value of an initializer that should be allowed to escape
6958 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
6959 if the (init) syntax was used.
6961 For functions that take default parameters, DECL points to its
6962 "maximal" instantiation. `cp_finish_decl' must then also declared its
6963 subsequently lower and lower forms of instantiation, checking for
6964 ambiguity as it goes. This can be sped up later. */
6967 cp_finish_decl (decl
, init
, asmspec_tree
, need_pop
, flags
)
6974 tree cleanup
= NULL_TREE
, ttype
= NULL_TREE
;
6976 int temporary
= allocation_temporary_p ();
6977 char *asmspec
= NULL
;
6978 int was_readonly
= 0;
6979 int already_used
= 0;
6981 /* If this is 0, then we did not change obstacks. */
6985 error ("assignment (not initialization) in declaration");
6989 /* If a name was specified, get the string. */
6991 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6993 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
6995 cp_error ("Cannot initialize `%D' to namespace `%D'",
7000 if (TREE_CODE (decl
) == VAR_DECL
7001 && DECL_CONTEXT (decl
)
7002 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
7003 && DECL_CONTEXT (decl
) != current_namespace
7006 /* Leave the namespace of the object. */
7007 pop_decl_namespace ();
7010 /* If the type of the thing we are declaring either has
7011 a constructor, or has a virtual function table pointer,
7012 AND its initialization was accepted by `start_decl',
7013 then we stayed on the permanent obstack through the
7014 declaration, otherwise, changed obstacks as GCC would. */
7016 type
= TREE_TYPE (decl
);
7018 if (type
== error_mark_node
)
7020 if (toplevel_bindings_p () && temporary
)
7021 end_temporary_allocation ();
7026 if (processing_template_decl
)
7028 if (init
&& DECL_INITIAL (decl
))
7029 DECL_INITIAL (decl
) = init
;
7030 if (minimal_parse_mode
&& ! DECL_ARTIFICIAL (decl
))
7032 tree stmt
= DECL_VINDEX (decl
);
7033 /* If the decl is declaring a member of a local class (in a
7034 template function), the DECL_VINDEX will either be NULL,
7035 or it will be an actual virtual function index, not a
7037 if (stmt
!= NULL_TREE
&& TREE_CODE (stmt
) == DECL_STMT
)
7039 DECL_VINDEX (decl
) = NULL_TREE
;
7040 TREE_OPERAND (stmt
, 2) = copy_to_permanent (init
);
7047 /* Take care of TYPE_DECLs up front. */
7048 if (TREE_CODE (decl
) == TYPE_DECL
)
7050 if (init
&& DECL_INITIAL (decl
))
7052 /* typedef foo = bar; store the type of bar as the type of foo. */
7053 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
7054 DECL_INITIAL (decl
) = init
= NULL_TREE
;
7056 if (type
!= error_mark_node
7057 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
7059 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7060 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
7061 set_identifier_type_value (DECL_NAME (decl
), type
);
7062 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
7064 GNU_xref_decl (current_function_decl
, decl
);
7066 /* If we have installed this as the canonical typedef for this
7067 type, and that type has not been defined yet, delay emitting
7068 the debug information for it, as we will emit it later. */
7069 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7070 && TYPE_SIZE (TREE_TYPE (decl
)) == NULL_TREE
)
7071 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
7073 rest_of_decl_compilation (decl
, NULL_PTR
,
7074 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
7077 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7079 ttype
= target_type (type
);
7082 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
7083 && TYPE_NEEDS_CONSTRUCTING (type
))
7086 /* Currently, GNU C++ puts constants in text space, making them
7087 impossible to initialize. In the future, one would hope for
7088 an operating system which understood the difference between
7089 initialization and the running of a program. */
7091 TREE_READONLY (decl
) = 0;
7094 if (TREE_CODE (decl
) == FIELD_DECL
)
7096 if (init
&& init
!= error_mark_node
)
7097 my_friendly_assert (TREE_PERMANENT (init
), 147);
7101 /* This must override the asm specifier which was placed
7102 by grokclassfn. Lay this out fresh. */
7103 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
7104 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7105 make_decl_rtl (decl
, asmspec
, 0);
7108 /* If `start_decl' didn't like having an initialization, ignore it now. */
7109 else if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7111 else if (DECL_EXTERNAL (decl
))
7113 else if (TREE_CODE (type
) == REFERENCE_TYPE
7114 || (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE_REFERENCE (type
)))
7116 if (TREE_STATIC (decl
))
7117 make_decl_rtl (decl
, NULL_PTR
,
7118 toplevel_bindings_p ()
7119 || pseudo_global_level_p ());
7120 grok_reference_init (decl
, type
, init
);
7124 GNU_xref_decl (current_function_decl
, decl
);
7126 if (TREE_CODE (decl
) == FIELD_DECL
)
7128 else if (TREE_CODE (decl
) == CONST_DECL
)
7130 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7132 DECL_INITIAL (decl
) = init
;
7134 /* This will keep us from needing to worry about our obstacks. */
7135 my_friendly_assert (init
!= NULL_TREE
, 149);
7140 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7142 if (TREE_CODE (type
) == ARRAY_TYPE
)
7143 init
= digest_init (type
, init
, (tree
*) 0);
7144 else if (TREE_CODE (init
) == CONSTRUCTOR
)
7146 if (TYPE_NON_AGGREGATE_CLASS (type
))
7148 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7150 init
= error_mark_node
;
7153 goto dont_use_constructor
;
7158 dont_use_constructor
:
7159 if (TREE_CODE (init
) != TREE_VEC
)
7160 init
= store_init_value (decl
, init
);
7164 /* We must hide the initializer so that expand_decl
7165 won't try to do something it does not understand. */
7166 init
= obscure_complex_init (decl
, init
);
7168 else if (DECL_EXTERNAL (decl
))
7170 else if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't'
7171 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7174 while (TREE_CODE (ctype
) == ARRAY_TYPE
)
7175 ctype
= TREE_TYPE (ctype
);
7176 if (! TYPE_NEEDS_CONSTRUCTING (ctype
))
7178 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype
))
7179 cp_error ("structure `%D' with uninitialized const members", decl
);
7180 if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype
))
7181 cp_error ("structure `%D' with uninitialized reference members",
7185 if (TREE_CODE (decl
) == VAR_DECL
7186 && !DECL_INITIAL (decl
)
7187 && !TYPE_NEEDS_CONSTRUCTING (type
)
7188 && (TYPE_READONLY (type
) || TREE_READONLY (decl
)))
7189 cp_error ("uninitialized const `%D'", decl
);
7191 if (TYPE_SIZE (type
) != NULL_TREE
7192 && TYPE_NEEDS_CONSTRUCTING (type
))
7193 init
= obscure_complex_init (decl
, NULL_TREE
);
7195 else if (TREE_CODE (decl
) == VAR_DECL
7196 && TREE_CODE (type
) != REFERENCE_TYPE
7197 && (TYPE_READONLY (type
) || TREE_READONLY (decl
)))
7199 /* ``Unless explicitly declared extern, a const object does not have
7200 external linkage and must be initialized. ($8.4; $12.1)'' ARM 7.1.6
7201 However, if it's `const int foo = 1; const int foo;', don't complain
7202 about the second decl, since it does have an initializer before.
7203 We deliberately don't complain about arrays, because they're
7204 supposed to be initialized by a constructor. */
7205 if (! DECL_INITIAL (decl
)
7206 && TREE_CODE (type
) != ARRAY_TYPE
7207 && (!pedantic
|| !current_class_type
))
7208 cp_error ("uninitialized const `%#D'", decl
);
7211 /* For top-level declaration, the initial value was read in
7212 the temporary obstack. MAXINDEX, rtl, etc. to be made below
7213 must go in the permanent obstack; but don't discard the
7214 temporary data yet. */
7216 if (toplevel_bindings_p () && temporary
)
7217 end_temporary_allocation ();
7219 /* Deduce size of array from initialization, if not already known. */
7221 if (TREE_CODE (type
) == ARRAY_TYPE
7222 && TYPE_DOMAIN (type
) == NULL_TREE
7223 && TREE_CODE (decl
) != TYPE_DECL
)
7226 = (TREE_STATIC (decl
)
7227 /* Even if pedantic, an external linkage array
7228 may have incomplete type at first. */
7229 ? pedantic
&& ! DECL_EXTERNAL (decl
)
7230 : !DECL_EXTERNAL (decl
));
7231 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7232 int failure
= complete_array_type (type
, initializer
, do_default
);
7235 cp_error ("initializer fails to determine size of `%D'", decl
);
7240 cp_error ("array size missing in `%D'", decl
);
7241 /* If a `static' var's size isn't known, make it extern as
7242 well as static, so it does not get allocated. If it's not
7243 `static', then don't mark it extern; finish_incomplete_decl
7244 will give it a default size and it will get allocated. */
7245 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7246 DECL_EXTERNAL (decl
) = 1;
7249 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7250 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7252 cp_error ("zero-size array `%D'", decl
);
7254 layout_decl (decl
, 0);
7257 if (TREE_CODE (decl
) == VAR_DECL
)
7259 if (DECL_SIZE (decl
) == NULL_TREE
7260 && TYPE_SIZE (complete_type (TREE_TYPE (decl
))) != NULL_TREE
)
7261 layout_decl (decl
, 0);
7263 if (TREE_STATIC (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7265 /* A static variable with an incomplete type:
7266 that is an error if it is initialized.
7267 Otherwise, let it through, but if it is not `extern'
7268 then it may cause an error message later. */
7269 if (DECL_INITIAL (decl
) != NULL_TREE
)
7270 cp_error ("storage size of `%D' isn't known", decl
);
7273 else if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7275 /* An automatic variable with an incomplete type: that is an error.
7276 Don't talk about array types here, since we took care of that
7277 message in grokdeclarator. */
7278 cp_error ("storage size of `%D' isn't known", decl
);
7279 TREE_TYPE (decl
) = error_mark_node
;
7281 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7282 /* Let debugger know it should output info for this type. */
7283 note_debug_info_needed (ttype
);
7285 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7286 note_debug_info_needed (DECL_CONTEXT (decl
));
7288 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7289 && DECL_SIZE (decl
) != NULL_TREE
7290 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7292 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7293 constant_expression_warning (DECL_SIZE (decl
));
7295 cp_error ("storage size of `%D' isn't constant", decl
);
7298 if (! DECL_EXTERNAL (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
7299 /* Cleanups for static variables are handled by `finish_file'. */
7300 && ! TREE_STATIC (decl
))
7302 int yes
= suspend_momentary ();
7303 cleanup
= maybe_build_cleanup (decl
);
7304 resume_momentary (yes
);
7307 /* PARM_DECLs get cleanups, too. */
7308 else if (TREE_CODE (decl
) == PARM_DECL
&& TYPE_NEEDS_DESTRUCTOR (type
))
7311 end_temporary_allocation ();
7312 cleanup
= maybe_build_cleanup (decl
);
7314 resume_temporary_allocation ();
7317 /* Output the assembler code and/or RTL code for variables and functions,
7318 unless the type is an undefined structure or union.
7319 If not, it will get done when the type is completed. */
7321 was_incomplete
= (DECL_SIZE (decl
) == NULL_TREE
);
7323 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
7324 || TREE_CODE (decl
) == RESULT_DECL
)
7326 /* ??? FIXME: What about nested classes? */
7327 int toplev
= toplevel_bindings_p () || pseudo_global_level_p ();
7329 = (TREE_STATIC (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
7330 && allocation_temporary_p ());
7333 end_temporary_allocation ();
7335 /* Static data in a function with comdat linkage also has comdat
7337 if (TREE_CODE (decl
) == VAR_DECL
7338 && TREE_STATIC (decl
)
7339 /* Don't mess with __FUNCTION__. */
7340 && ! TREE_ASM_WRITTEN (decl
)
7341 && current_function_decl
7342 && DECL_CONTEXT (decl
) == current_function_decl
7343 && (DECL_THIS_INLINE (current_function_decl
)
7344 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7345 && TREE_PUBLIC (current_function_decl
))
7347 /* Rather than try to get this right with inlining, we suppress
7348 inlining of such functions. */
7349 current_function_cannot_inline
7350 = "function with static variable cannot be inline";
7352 /* If flag_weak, we don't need to mess with this, as we can just
7353 make the function weak, and let it refer to its unique local
7354 copy. This works because we don't allow the function to be
7358 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7360 TREE_PUBLIC (decl
) = 1;
7361 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7363 else if (DECL_INITIAL (decl
) == NULL_TREE
7364 || DECL_INITIAL (decl
) == error_mark_node
)
7366 TREE_PUBLIC (decl
) = 1;
7367 DECL_COMMON (decl
) = 1;
7369 /* else we lose. We can only do this if we can use common,
7370 which we can't if it has been initialized. */
7372 if (TREE_PUBLIC (decl
))
7373 DECL_ASSEMBLER_NAME (decl
)
7374 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7375 else if (! DECL_ARTIFICIAL (decl
))
7377 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7378 cp_warning_at (" you can work around this by removing the initializer"), decl
;
7383 else if (TREE_CODE (decl
) == VAR_DECL
7384 && DECL_LANG_SPECIFIC (decl
)
7385 && DECL_COMDAT (decl
))
7387 /* Dynamically initialized vars go into common. */
7388 if (DECL_INITIAL (decl
) == NULL_TREE
7389 || DECL_INITIAL (decl
) == error_mark_node
)
7390 DECL_COMMON (decl
) = 1;
7391 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7393 DECL_COMMON (decl
) = 1;
7394 DECL_INITIAL (decl
) = error_mark_node
;
7398 /* Statically initialized vars are weak or comdat, if
7401 make_decl_one_only (decl
);
7404 /* We can't do anything useful; leave vars for explicit
7406 DECL_EXTERNAL (decl
) = 1;
7407 DECL_NOT_REALLY_EXTERN (decl
) = 0;
7412 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
7413 make_decl_rtl (decl
, NULL_PTR
, toplev
);
7414 else if (TREE_CODE (decl
) == VAR_DECL
7415 && TREE_READONLY (decl
)
7416 && DECL_INITIAL (decl
) != NULL_TREE
7417 && DECL_INITIAL (decl
) != error_mark_node
7418 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7420 DECL_INITIAL (decl
) = save_expr (DECL_INITIAL (decl
));
7423 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7426 && TREE_STATIC (decl
)
7427 && ! TREE_SIDE_EFFECTS (decl
)
7428 && ! TREE_PUBLIC (decl
)
7429 && ! DECL_EXTERNAL (decl
)
7430 && ! TYPE_NEEDS_DESTRUCTOR (type
)
7431 && DECL_MODE (decl
) != BLKmode
)
7433 /* If this variable is really a constant, then fill its DECL_RTL
7434 slot with something which won't take up storage.
7435 If something later should take its address, we can always give
7436 it legitimate RTL at that time. */
7437 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
7438 store_expr (DECL_INITIAL (decl
), DECL_RTL (decl
), 0);
7439 TREE_ASM_WRITTEN (decl
) = 1;
7441 else if (toplev
&& ! TREE_PUBLIC (decl
))
7443 /* If this is a static const, change its apparent linkage
7444 if it belongs to a #pragma interface. */
7445 if (!interface_unknown
)
7447 TREE_PUBLIC (decl
) = 1;
7448 DECL_EXTERNAL (decl
) = interface_only
;
7450 make_decl_rtl (decl
, asmspec
, toplev
);
7453 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7455 else if (TREE_CODE (decl
) == VAR_DECL
7456 && DECL_LANG_SPECIFIC (decl
)
7457 && DECL_IN_AGGR_P (decl
))
7459 if (TREE_STATIC (decl
))
7461 if (init
== NULL_TREE
7462 #ifdef DEFAULT_STATIC_DEFS
7463 /* If this code is dead, then users must
7464 explicitly declare static member variables
7465 outside the class def'n as well. */
7466 && TYPE_NEEDS_CONSTRUCTING (type
)
7470 DECL_EXTERNAL (decl
) = 1;
7471 make_decl_rtl (decl
, asmspec
, 1);
7474 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7477 /* Just a constant field. Should not need any rtl. */
7481 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7484 resume_temporary_allocation ();
7486 if (type
!= error_mark_node
7487 && TYPE_LANG_SPECIFIC (type
)
7488 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
7489 abstract_virtuals_error (decl
, type
);
7490 else if ((TREE_CODE (type
) == FUNCTION_TYPE
7491 || TREE_CODE (type
) == METHOD_TYPE
)
7492 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
7493 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type
)))
7494 abstract_virtuals_error (decl
, TREE_TYPE (type
));
7496 if (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE (type
))
7497 signature_error (decl
, type
);
7498 else if ((TREE_CODE (type
) == FUNCTION_TYPE
7499 || TREE_CODE (type
) == METHOD_TYPE
)
7500 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
7501 && IS_SIGNATURE (TREE_TYPE (type
)))
7502 signature_error (decl
, TREE_TYPE (type
));
7504 if (TREE_CODE (decl
) == FUNCTION_DECL
)
7506 else if (DECL_EXTERNAL (decl
)
7507 && ! (DECL_LANG_SPECIFIC (decl
)
7508 && DECL_NOT_REALLY_EXTERN (decl
)))
7511 DECL_INITIAL (decl
) = init
;
7513 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
7515 /* Cleanups for static variables are handled by `finish_file'. */
7516 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
7517 || TYPE_NEEDS_DESTRUCTOR (type
))
7518 expand_static_init (decl
, init
);
7522 /* This is a declared decl which must live until the
7523 end of the binding contour. It may need a cleanup. */
7525 /* Recompute the RTL of a local array now
7526 if it used to be an incomplete type. */
7527 if (was_incomplete
&& ! TREE_STATIC (decl
))
7529 /* If we used it already as memory, it must stay in memory. */
7530 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7531 /* If it's still incomplete now, no init will save it. */
7532 if (DECL_SIZE (decl
) == NULL_TREE
)
7533 DECL_INITIAL (decl
) = NULL_TREE
;
7536 else if (! TREE_ASM_WRITTEN (decl
)
7537 && (TYPE_SIZE (type
) != NULL_TREE
7538 || TREE_CODE (type
) == ARRAY_TYPE
))
7540 /* Do this here, because we did not expand this decl's
7541 rtl in start_decl. */
7542 if (DECL_RTL (decl
) == NULL_RTX
)
7546 /* XXX: Why don't we use decl here? */
7547 /* Ans: Because it was already expanded? */
7548 if (! expand_decl_cleanup (NULL_TREE
, cleanup
))
7549 cp_error ("parser lost in parsing declaration of `%D'",
7551 /* Cleanup used up here. */
7552 cleanup
= NULL_TREE
;
7556 if (current_binding_level
->is_for_scope
)
7558 struct binding_level
*outer
= current_binding_level
->level_chain
;
7560 /* Check to see if the same name is already bound at
7561 the outer level, either because it was directly declared,
7562 or because a dead for-decl got preserved. In either case,
7563 the code would not have been valid under the ARM
7564 scope rules, so clear is_for_scope for the
7565 current_binding_level.
7567 Otherwise, we need to preserve the temp slot for decl
7568 to last into the outer binding level. */
7570 int handling_dead_for_vars
= 0;
7571 tree link
= outer
->names
;
7572 for (; ; link
= TREE_CHAIN (link
))
7574 if (link
== NULL
&& handling_dead_for_vars
== 0)
7576 link
= outer
->dead_vars_from_for
;
7577 handling_dead_for_vars
= 1;
7581 if (DECL_IN_MEMORY_P (decl
))
7582 preserve_temp_slots (DECL_RTL (decl
));
7585 if (DECL_NAME (link
) == DECL_NAME (decl
))
7587 if (handling_dead_for_vars
)
7590 = purpose_member (DECL_NAME (decl
),
7591 current_binding_level
->shadowed
);
7592 if (shadowing
&& TREE_VALUE (shadowing
) == link
)
7593 TREE_VALUE (shadowing
)
7594 = DECL_SHADOWED_FOR_VAR (link
);
7596 current_binding_level
->is_for_scope
= 0;
7602 expand_start_target_temps ();
7604 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7606 /* Compute and store the initial value. */
7607 expand_decl_init (decl
);
7608 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7610 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7612 emit_line_note (DECL_SOURCE_FILE (decl
),
7613 DECL_SOURCE_LINE (decl
));
7614 expand_aggr_init (decl
, init
, flags
);
7617 /* Set this to 0 so we can tell whether an aggregate which
7618 was initialized was ever used. Don't do this if it has a
7619 destructor, so we don't complain about the 'resource
7620 allocation is initialization' idiom. */
7621 /* Now set attribute((unused)) on types so decls of
7622 that type will be marked used. (see TREE_USED, above.)
7623 This avoids the warning problems this particular code
7624 tried to work around. */
7626 if (TYPE_NEEDS_CONSTRUCTING (type
)
7628 && cleanup
== NULL_TREE
7629 && DECL_NAME (decl
))
7630 TREE_USED (decl
) = 0;
7633 TREE_USED (decl
) = 1;
7636 /* Cleanup any temporaries needed for the initial value. */
7637 expand_end_target_temps ();
7639 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7641 /* Store the cleanup, if there was one. */
7644 if (! expand_decl_cleanup (decl
, cleanup
))
7645 cp_error ("parser lost in parsing declaration of `%D'",
7652 /* Undo call to `pushclass' that was done in `start_decl'
7653 due to initialization of qualified member variable.
7654 I.e., Foo::x = 10; */
7656 tree context
= DECL_REAL_CONTEXT (decl
);
7658 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't'
7659 && (TREE_CODE (decl
) == VAR_DECL
7660 /* We also have a pushclass done that we need to undo here
7661 if we're at top level and declare a method. */
7662 || TREE_CODE (decl
) == FUNCTION_DECL
)
7663 /* If size hasn't been set, we're still defining it,
7664 and therefore inside the class body; don't pop
7665 the binding level.. */
7666 && TYPE_SIZE (context
) != NULL_TREE
7667 && context
== current_class_type
)
7674 /* If requested, warn about definitions of large data objects. */
7676 if (warn_larger_than
7677 && ! processing_template_decl
7678 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
7679 && !DECL_EXTERNAL (decl
))
7681 register tree decl_size
= DECL_SIZE (decl
);
7683 if (decl_size
&& TREE_CODE (decl_size
) == INTEGER_CST
)
7685 unsigned units
= TREE_INT_CST_LOW (decl_size
) / BITS_PER_UNIT
;
7687 if (units
> larger_than_size
)
7688 warning_with_decl (decl
, "size of `%s' is %u bytes", units
);
7694 /* Resume permanent allocation, if not within a function. */
7695 /* The corresponding push_obstacks_nochange is in start_decl,
7696 start_method, groktypename, and in grokfield. */
7701 TREE_READONLY (decl
) = 1;
7704 /* This is here for a midend callback from c-common.c */
7707 finish_decl (decl
, init
, asmspec_tree
)
7711 cp_finish_decl (decl
, init
, asmspec_tree
, 1, 0);
7715 expand_static_init (decl
, init
)
7719 tree oldstatic
= value_member (decl
, static_aggregates
);
7723 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
7724 cp_error ("multiple initializations given for `%D'", decl
);
7726 else if (! toplevel_bindings_p () && ! pseudo_global_level_p ())
7728 /* Emit code to perform this initialization but once. */
7731 /* Remember this information until end of file. */
7732 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7734 /* Emit code to perform this initialization but once. */
7735 temp
= get_temp_name (integer_type_node
, 1);
7736 rest_of_decl_compilation (temp
, NULL_PTR
, 0, 0);
7737 expand_start_cond (build_binary_op (EQ_EXPR
, temp
,
7738 integer_zero_node
, 1), 0);
7739 expand_start_target_temps ();
7741 expand_assignment (temp
, integer_one_node
, 0, 0);
7742 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
7743 || (init
&& TREE_CODE (init
) == TREE_LIST
))
7745 expand_aggr_init (decl
, init
, 0);
7746 do_pending_stack_adjust ();
7749 expand_assignment (decl
, init
, 0, 0);
7751 /* Cleanup any temporaries needed for the initial value. */
7752 expand_end_target_temps ();
7754 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
7756 tree cleanup
, fcall
;
7757 static tree Atexit
= 0;
7760 tree atexit_fndecl
, PFV
, pfvlist
;
7761 /* Remember this information until end of file. */
7762 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7763 PFV
= build_pointer_type (build_function_type
7764 (void_type_node
, void_list_node
));
7766 pfvlist
= tree_cons (NULL_TREE
, PFV
, void_list_node
);
7768 push_lang_context (lang_name_c
);
7770 = builtin_function ("atexit",
7771 build_function_type (void_type_node
,
7773 NOT_BUILT_IN
, NULL_PTR
);
7774 assemble_external (atexit_fndecl
);
7775 Atexit
= default_conversion (atexit_fndecl
);
7776 pop_lang_context ();
7780 cleanup
= start_anon_func ();
7781 expand_expr_stmt (build_cleanup (decl
));
7783 mark_addressable (cleanup
);
7784 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
7785 fcall
= build_function_call (Atexit
, expr_tree_cons (NULL_TREE
, cleanup
, NULL_TREE
));
7786 expand_expr_stmt (fcall
);
7790 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
7792 static_aggregates
= perm_tree_cons (temp
, decl
, static_aggregates
);
7793 TREE_STATIC (static_aggregates
) = 1;
7796 /* Resume old (possibly temporary) allocation. */
7801 /* This code takes into account memory allocation
7802 policy of `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING
7803 does not hold for this object, then we must make permanent
7804 the storage currently in the temporary obstack. */
7805 if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
7806 preserve_initializer ();
7807 static_aggregates
= perm_tree_cons (init
, decl
, static_aggregates
);
7811 /* Make TYPE a complete type based on INITIAL_VALUE.
7812 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7813 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
7816 complete_array_type (type
, initial_value
, do_default
)
7817 tree type
, initial_value
;
7820 register tree maxindex
= NULL_TREE
;
7825 /* Note MAXINDEX is really the maximum index,
7826 one less than the size. */
7827 if (TREE_CODE (initial_value
) == STRING_CST
)
7830 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
7831 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
7834 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7836 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
7837 maxindex
= size_binop (MINUS_EXPR
, integer_zero_node
, size_one_node
);
7838 for (; elts
; elts
= TREE_CHAIN (elts
))
7840 if (TREE_PURPOSE (elts
))
7841 maxindex
= TREE_PURPOSE (elts
);
7843 maxindex
= size_binop (PLUS_EXPR
, maxindex
, size_one_node
);
7845 maxindex
= copy_node (maxindex
);
7849 /* Make an error message unless that happened already. */
7850 if (initial_value
!= error_mark_node
)
7853 /* Prevent further error messages. */
7854 maxindex
= build_int_2 (0, 0);
7861 maxindex
= build_int_2 (0, 0);
7869 TYPE_DOMAIN (type
) = build_index_type (maxindex
);
7870 if (! TREE_TYPE (maxindex
))
7871 TREE_TYPE (maxindex
) = TYPE_DOMAIN (type
);
7873 itype
= TREE_TYPE (initial_value
);
7876 if (itype
&& !TYPE_DOMAIN (itype
))
7877 TYPE_DOMAIN (itype
) = TYPE_DOMAIN (type
);
7878 /* The type of the main variant should never be used for arrays
7879 of different sizes. It should only ever be completed with the
7880 size of the array. */
7881 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
7882 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = TYPE_DOMAIN (type
);
7885 /* Lay out the type now that we can get the real answer. */
7892 /* Return zero if something is declared to be a member of type
7893 CTYPE when in the context of CUR_TYPE. STRING is the error
7894 message to print in that case. Otherwise, quietly return 1. */
7897 member_function_or_else (ctype
, cur_type
, string
)
7898 tree ctype
, cur_type
;
7901 if (ctype
&& ctype
!= cur_type
)
7903 error (string
, TYPE_NAME_STRING (ctype
));
7909 /* Subroutine of `grokdeclarator'. */
7911 /* Generate errors possibly applicable for a given set of specifiers.
7912 This is for ARM $7.1.2. */
7915 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
7918 int virtualp
, quals
, friendp
, raises
, inlinep
;
7921 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
7923 cp_error ("`%D' declared as an `inline' %s", object
, type
);
7925 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
7928 cp_error_at ("invalid friend declaration", object
);
7930 cp_error_at ("invalid exception specifications", object
);
7933 /* CTYPE is class type, or null if non-class.
7934 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7936 DECLARATOR is the function's name.
7937 VIRTUALP is truthvalue of whether the function is virtual or not.
7938 FLAGS are to be passed through to `grokclassfn'.
7939 QUALS are qualifiers indicating whether the function is `const'
7941 RAISES is a list of exceptions that this function can raise.
7942 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7943 not look, and -1 if we should not call `grokclassfn' at all.
7945 Returns `error_mark_node' if something goes wrong, after issuing
7946 applicable error messages. */
7949 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
7950 raises
, attrlist
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
7951 template_count
, in_namespace
)
7954 tree orig_declarator
;
7956 enum overload_flags flags
;
7957 tree quals
, raises
, attrlist
;
7958 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
7962 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7966 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
7967 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
7973 type
= build_exception_variant (type
, raises
);
7976 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7977 /* Propagate volatile out from type to decl. */
7978 if (TYPE_VOLATILE (type
))
7979 TREE_THIS_VOLATILE (decl
) = 1;
7981 /* This decl is not from the current namespace. */
7983 set_decl_namespace (decl
, in_namespace
);
7985 /* Should probably propagate const out from type to decl I bet (mrs). */
7988 DECL_STATIC_FUNCTION_P (decl
) = 1;
7989 DECL_CONTEXT (decl
) = ctype
;
7993 DECL_CLASS_CONTEXT (decl
) = ctype
;
7995 if (ctype
== NULL_TREE
&& MAIN_NAME_P (declarator
))
7998 error ("cannot declare `main' to be inline");
8000 error ("cannot declare `main' to be static");
8005 /* Members of anonymous types have no linkage; make them internal. */
8006 if (ctype
&& ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
)))
8011 /* [basic.link]: A name with no linkage (notably, the name of a class
8012 or enumeration declared in a local scope) shall not be used to
8013 declare an entity with linkage.
8015 Only check this for public decls for now. */
8016 t
= no_linkage_check (TREE_TYPE (decl
));
8019 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8020 cp_pedwarn ("non-local function `%#D' uses anonymous type", decl
);
8022 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8027 TREE_PUBLIC (decl
) = publicp
;
8030 DECL_INTERFACE_KNOWN (decl
) = 1;
8031 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8035 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8037 DECL_EXTERNAL (decl
) = 1;
8038 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8040 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8041 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8045 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8046 grok_op_properties (decl
, virtualp
, check
< 0);
8048 if (ctype
&& hack_decl_function_context (decl
))
8049 DECL_NO_STATIC_CHAIN (decl
) = 1;
8051 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8052 if (TREE_PURPOSE (t
)
8053 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8055 add_defarg_fn (decl
);
8060 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8064 ("defining explicit specialization `%D' in friend declaration",
8068 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8070 /* Something like `template <class T> friend void f<T>()'. */
8071 cp_error ("template-id `%D' in declaration of primary template",
8073 return error_mark_node
;
8076 /* A friend declaration of the form friend void f<>(). Record
8077 the information in the TEMPLATE_ID_EXPR. */
8078 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8079 DECL_TEMPLATE_INFO (decl
)
8080 = perm_tree_cons (TREE_OPERAND (orig_declarator
, 0),
8081 TREE_OPERAND (orig_declarator
, 1),
8086 /* Caller will do the rest of this. */
8090 if (check
&& funcdef_flag
)
8091 DECL_INITIAL (decl
) = error_mark_node
;
8093 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8096 /* Just handle constructors here. We could do this
8097 inside the following if stmt, but I think
8098 that the code is more legible by breaking this
8099 case out. See comments below for what each of
8100 the following calls is supposed to do. */
8101 DECL_CONSTRUCTOR_P (decl
) = 1;
8103 grokclassfn (ctype
, decl
, flags
, quals
);
8105 decl
= check_explicit_specialization (orig_declarator
, decl
,
8107 2 * (funcdef_flag
!= 0) +
8108 4 * (friendp
!= 0));
8109 if (decl
== error_mark_node
)
8110 return error_mark_node
;
8112 if ((! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8115 tmp
= check_classfn (ctype
, decl
);
8117 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8118 tmp
= DECL_TEMPLATE_RESULT(tmp
);
8120 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8121 cp_error ("definition of implicitly-declared `%D'", tmp
);
8122 if (tmp
&& duplicate_decls (decl
, tmp
))
8125 if (! grok_ctor_properties (ctype
, decl
))
8126 return error_mark_node
;
8128 if (check
== 0 && ! current_function_decl
)
8130 /* Assembler names live in the global namespace. */
8131 tmp
= IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl
));
8132 if (tmp
== NULL_TREE
)
8133 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl
), decl
);
8134 else if (TREE_CODE (tmp
) != TREE_CODE (decl
))
8135 cp_error ("inconsistent declarations for `%D'", decl
);
8138 duplicate_decls (decl
, tmp
);
8141 make_decl_rtl (decl
, NULL_PTR
, 1);
8148 /* Function gets the ugly name, field gets the nice one.
8149 This call may change the type of the function (because
8150 of default parameters)! */
8151 if (ctype
!= NULL_TREE
)
8152 grokclassfn (ctype
, decl
, flags
, quals
);
8154 decl
= check_explicit_specialization (orig_declarator
, decl
,
8156 2 * (funcdef_flag
!= 0) +
8157 4 * (friendp
!= 0));
8158 if (decl
== error_mark_node
)
8159 return error_mark_node
;
8161 if (ctype
!= NULL_TREE
8162 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8165 tmp
= check_classfn (ctype
, decl
);
8167 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8168 tmp
= DECL_TEMPLATE_RESULT (tmp
);
8170 if (tmp
&& DECL_STATIC_FUNCTION_P (tmp
)
8171 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8173 /* Remove the `this' parm added by grokclassfn.
8174 XXX Isn't this done in start_function, too? */
8175 revert_static_member_fn (&decl
, NULL
, NULL
);
8176 last_function_parms
= TREE_CHAIN (last_function_parms
);
8178 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8179 cp_error ("definition of implicitly-declared `%D'", tmp
);
8182 if (!duplicate_decls (decl
, tmp
))
8183 my_friendly_abort (892);
8188 if (ctype
== NULL_TREE
|| check
)
8191 /* Now install the declaration of this function so that others may
8192 find it (esp. its DECL_FRIENDLIST). Don't do this for local class
8194 if (! current_function_decl
)
8196 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
8198 /* We don't do this for specializations since the
8199 equivalent checks will be done later. Also, at this
8200 point the DECL_ASSEMBLER_NAME is not yet fully
8203 /* FIXME: this should only need to look at
8204 IDENTIFIER_GLOBAL_VALUE. */
8205 tmp
= lookup_name (DECL_ASSEMBLER_NAME (decl
), 0);
8206 if (tmp
== NULL_TREE
)
8207 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl
), decl
);
8208 else if (TREE_CODE (tmp
) != TREE_CODE (decl
))
8209 cp_error ("inconsistent declarations for `%D'", decl
);
8212 duplicate_decls (decl
, tmp
);
8218 cplus_decl_attributes (decl
, TREE_PURPOSE (attrlist
),
8219 TREE_VALUE (attrlist
));
8220 make_decl_rtl (decl
, NULL_PTR
, 1);
8224 DECL_VIRTUAL_P (decl
) = 1;
8225 if (DECL_VINDEX (decl
) == NULL_TREE
)
8226 DECL_VINDEX (decl
) = error_mark_node
;
8227 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
8234 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
8237 RID_BIT_TYPE
*specbits_in
;
8243 RID_BIT_TYPE specbits
;
8245 specbits
= *specbits_in
;
8247 if (TREE_CODE (type
) == OFFSET_TYPE
)
8249 /* If you declare a static member so that it
8250 can be initialized, the code will reach here. */
8251 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
8252 type
= TREE_TYPE (type
);
8253 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
8254 DECL_CONTEXT (decl
) = basetype
;
8255 DECL_CLASS_CONTEXT (decl
) = basetype
;
8256 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
, declarator
);
8260 tree context
= in_namespace
? in_namespace
: current_namespace
;
8261 decl
= build_decl (VAR_DECL
, declarator
, complete_type (type
));
8262 if (context
!= global_namespace
&& namespace_bindings_p ()
8263 && current_lang_name
!= lang_name_c
)
8264 DECL_ASSEMBLER_NAME (decl
) = build_static_name (context
,
8269 set_decl_namespace (decl
, in_namespace
);
8271 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
8273 DECL_THIS_EXTERN (decl
) = 1;
8274 DECL_EXTERNAL (decl
) = !initialized
;
8277 /* In class context, static means one per class,
8278 public access, and static storage. */
8279 if (DECL_CLASS_SCOPE_P (decl
))
8281 TREE_PUBLIC (decl
) = 1;
8282 TREE_STATIC (decl
) = 1;
8283 DECL_EXTERNAL (decl
) = 0;
8285 /* At top level, either `static' or no s.c. makes a definition
8286 (perhaps tentative), and absence of `static' makes it public. */
8287 else if (toplevel_bindings_p ())
8289 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
8290 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8291 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8293 /* Not at top level, only `static' makes a static definition. */
8296 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
8297 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8300 if (TREE_PUBLIC (decl
))
8302 /* [basic.link]: A name with no linkage (notably, the name of a class
8303 or enumeration declared in a local scope) shall not be used to
8304 declare an entity with linkage.
8306 Only check this for public decls for now. */
8307 tree t
= no_linkage_check (TREE_TYPE (decl
));
8310 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8311 /* Ignore for now; `enum { foo } e' is pretty common. */;
8313 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8321 /* Create a canonical pointer to member function type. */
8324 build_ptrmemfunc_type (type
)
8331 /* If a canonical type already exists for this type, use it. We use
8332 this method instead of type_hash_canon, because it only does a
8333 simple equality check on the list of field members. */
8335 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8338 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8340 u
= make_lang_type (UNION_TYPE
);
8341 IS_AGGR_TYPE (u
) = 0;
8342 fields
[0] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
, type
);
8343 fields
[1] = build_lang_field_decl (FIELD_DECL
, delta2_identifier
,
8345 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
8346 TYPE_NAME (u
) = NULL_TREE
;
8348 t
= make_lang_type (RECORD_TYPE
);
8350 /* Let the front-end know this is a pointer to member function... */
8351 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8352 /* ... and not really an aggregate. */
8353 IS_AGGR_TYPE (t
) = 0;
8355 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
8357 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
8359 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
8360 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
8364 /* Zap out the name so that the back-end will give us the debugging
8365 information for this anonymous RECORD_TYPE. */
8366 TYPE_NAME (t
) = NULL_TREE
;
8368 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8370 /* Seems to be wanted. */
8371 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
8375 /* Given declspecs and a declarator,
8376 determine the name and type of the object declared
8377 and construct a ..._DECL node for it.
8378 (In one case we can return a ..._TYPE node instead.
8379 For invalid input we sometimes return 0.)
8381 DECLSPECS is a chain of tree_list nodes whose value fields
8382 are the storage classes and type specifiers.
8384 DECL_CONTEXT says which syntactic context this declaration is in:
8385 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8386 FUNCDEF for a function definition. Like NORMAL but a few different
8387 error messages in each case. Return value may be zero meaning
8388 this definition is too screwy to try to parse.
8389 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8390 handle member functions (which have FIELD context).
8391 Return value may be zero meaning this definition is too screwy to
8393 PARM for a parameter declaration (either within a function prototype
8394 or before a function body). Make a PARM_DECL, or return void_type_node.
8395 CATCHPARM for a parameter declaration before a catch clause.
8396 TYPENAME if for a typename (in a cast or sizeof).
8397 Don't make a DECL node; just return the ..._TYPE node.
8398 FIELD for a struct or union field; make a FIELD_DECL.
8399 BITFIELD for a field with specified width.
8400 INITIALIZED is 1 if the decl has an initializer.
8402 In the TYPENAME case, DECLARATOR is really an absolute declarator.
8403 It may also be so in the PARM case, for a prototype where the
8404 argument type is specified but not the name.
8406 This function is where the complicated C meanings of `static'
8407 and `extern' are interpreted.
8409 For C++, if there is any monkey business to do, the function which
8410 calls this one must do it, i.e., prepending instance variables,
8411 renaming overloaded function names, etc.
8413 Note that for this C++, it is an error to define a method within a class
8414 which does not belong to that class.
8416 Except in the case where SCOPE_REFs are implicitly known (such as
8417 methods within a class being redundantly qualified),
8418 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
8419 (class_name::decl_name). The caller must also deal with this.
8421 If a constructor or destructor is seen, and the context is FIELD,
8422 then the type gains the attribute TREE_HAS_x. If such a declaration
8423 is erroneous, NULL_TREE is returned.
8425 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
8426 function, these are the qualifiers to give to the `this' pointer.
8428 May return void_type_node if the declarator turned out to be a friend.
8429 See grokfield for details. */
8431 enum return_types
{ return_normal
, return_ctor
, return_dtor
, return_conversion
};
8434 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
8437 enum decl_context decl_context
;
8441 RID_BIT_TYPE specbits
;
8444 tree type
= NULL_TREE
;
8448 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8449 int explicit_int
= 0;
8450 int explicit_char
= 0;
8451 int defaulted_int
= 0;
8452 int opaque_typedef
= 0;
8453 tree typedef_decl
= NULL_TREE
;
8455 tree typedef_type
= NULL_TREE
;
8456 int funcdef_flag
= 0;
8457 enum tree_code innermost_code
= ERROR_MARK
;
8460 /* See the code below that used this. */
8461 tree decl_machine_attr
= NULL_TREE
;
8463 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
8464 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
8465 tree init
= NULL_TREE
;
8467 /* Keep track of what sort of function is being processed
8468 so that we can warn about default return values, or explicit
8469 return values which do not match prescribed defaults. */
8470 enum return_types return_type
= return_normal
;
8472 tree dname
= NULL_TREE
;
8473 tree ctype
= current_class_type
;
8474 tree ctor_return_type
= NULL_TREE
;
8475 enum overload_flags flags
= NO_SPECIAL
;
8476 tree quals
= NULL_TREE
;
8477 tree raises
= NULL_TREE
;
8478 int template_count
= 0;
8479 tree in_namespace
= NULL_TREE
;
8481 RIDBIT_RESET_ALL (specbits
);
8482 if (decl_context
== FUNCDEF
)
8483 funcdef_flag
= 1, decl_context
= NORMAL
;
8484 else if (decl_context
== MEMFUNCDEF
)
8485 funcdef_flag
= -1, decl_context
= FIELD
;
8486 else if (decl_context
== BITFIELD
)
8487 bitfield
= 1, decl_context
= FIELD
;
8489 /* Look inside a declarator for the name being declared
8490 and get it as a string, for an error message. */
8492 tree
*next
= &declarator
;
8496 while (next
&& *next
)
8499 switch (TREE_CODE (decl
))
8503 next
= &TREE_OPERAND (decl
, 0);
8506 case BIT_NOT_EXPR
: /* For C++ destructors! */
8508 tree name
= TREE_OPERAND (decl
, 0);
8509 tree rename
= NULL_TREE
;
8511 my_friendly_assert (flags
== NO_SPECIAL
, 152);
8513 return_type
= return_dtor
;
8514 if (TREE_CODE (name
) == TYPE_DECL
)
8515 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
8516 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
8517 if (ctype
== NULL_TREE
)
8519 if (current_class_type
== NULL_TREE
)
8521 error ("destructors must be member functions");
8526 tree t
= constructor_name (current_class_name
);
8533 tree t
= constructor_name (ctype
);
8540 cp_error ("destructor `%T' must match class name `%T'",
8542 TREE_OPERAND (decl
, 0) = rename
;
8548 case ADDR_EXPR
: /* C++ reference declaration */
8553 innermost_code
= TREE_CODE (decl
);
8554 next
= &TREE_OPERAND (decl
, 0);
8558 if (parmlist_is_exprlist (TREE_OPERAND (decl
, 1)))
8560 /* This is actually a variable declaration using constructor
8561 syntax. We need to call start_decl and cp_finish_decl so we
8562 can get the variable initialized... */
8564 *next
= TREE_OPERAND (decl
, 0);
8565 init
= TREE_OPERAND (decl
, 1);
8567 decl
= start_decl (declarator
, declspecs
, 1, NULL_TREE
, NULL_TREE
);
8568 /* Look for __unused__ attribute */
8569 if (TREE_USED (TREE_TYPE (decl
)))
8570 TREE_USED (decl
) = 1;
8571 finish_decl (decl
, init
, NULL_TREE
);
8574 innermost_code
= TREE_CODE (decl
);
8575 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
8576 ctype
= current_class_type
;
8578 && TREE_OPERAND (decl
, 0)
8579 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
8580 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
8581 == constructor_name_full (ctype
))
8582 || (DECL_NAME (TREE_OPERAND (decl
, 0))
8583 == constructor_name (ctype
)))))
8584 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8585 next
= &TREE_OPERAND (decl
, 0);
8587 if (ctype
!= NULL_TREE
8588 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
8589 && decl
== constructor_name (ctype
))
8591 return_type
= return_ctor
;
8592 ctor_return_type
= ctype
;
8597 case TEMPLATE_ID_EXPR
:
8599 tree fns
= TREE_OPERAND (decl
, 0);
8601 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
8602 fns
= TREE_OPERAND (fns
, 0);
8604 if (TREE_CODE (fns
) == IDENTIFIER_NODE
)
8606 else if (is_overloaded_fn (fns
))
8607 dname
= DECL_NAME (get_first_fn (fns
));
8609 my_friendly_abort (0);
8613 case IDENTIFIER_NODE
:
8614 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
8621 cp_error ("declarator-id missing; using reserved word `%D'",
8623 name
= IDENTIFIER_POINTER (dname
);
8625 if (! IDENTIFIER_OPNAME_P (dname
)
8626 /* GNU/Linux headers use '__op'. Arrgh. */
8627 || (IDENTIFIER_TYPENAME_P (dname
) && ! TREE_TYPE (dname
)))
8628 name
= IDENTIFIER_POINTER (dname
);
8631 if (IDENTIFIER_TYPENAME_P (dname
))
8633 my_friendly_assert (flags
== NO_SPECIAL
, 154);
8634 flags
= TYPENAME_FLAG
;
8635 ctor_return_type
= TREE_TYPE (dname
);
8636 return_type
= return_conversion
;
8638 name
= operator_name_string (dname
);
8645 /* Perform error checking, and decide on a ctype. */
8646 tree cname
= TREE_OPERAND (decl
, 0);
8647 if (cname
== NULL_TREE
)
8649 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
8652 in_namespace
= TREE_OPERAND (decl
, 0);
8653 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8655 else if (! is_aggr_type (cname
, 1))
8656 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8657 /* Must test TREE_OPERAND (decl, 1), in case user gives
8658 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
8659 else if (TREE_OPERAND (decl
, 1)
8660 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
8662 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
8663 || TREE_CODE (cname
) == TEMPLATE_TEMPLATE_PARM
)
8665 cp_error ("`%T::%D' is not a valid declarator", cname
,
8666 TREE_OPERAND (decl
, 1));
8667 cp_error (" perhaps you want `typename %T::%D' to make it a type",
8668 cname
, TREE_OPERAND (decl
, 1));
8669 return void_type_node
;
8671 else if (ctype
== NULL_TREE
)
8673 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
8674 TREE_OPERAND (decl
, 0) = ctype
;
8677 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
8679 cp_error ("type `%T' is not derived from type `%T'",
8681 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8687 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
8688 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
8689 == constructor_name_full (ctype
))
8690 || (DECL_NAME (TREE_OPERAND (decl
, 1))
8691 == constructor_name (ctype
))))
8692 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
8693 next
= &TREE_OPERAND (decl
, 1);
8697 if (TREE_CODE (decl
) == IDENTIFIER_NODE
8698 && constructor_name (ctype
) == decl
)
8700 return_type
= return_ctor
;
8701 ctor_return_type
= ctype
;
8703 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
8704 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
8705 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
8706 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
8708 return_type
= return_dtor
;
8709 ctor_return_type
= ctype
;
8711 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8712 next
= &TREE_OPERAND (decl
, 0);
8723 /* Parse error puts this typespec where
8724 a declarator should go. */
8725 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
8726 if (TREE_TYPE (decl
) == current_class_type
)
8727 cp_error (" perhaps you want `%T' for a constructor",
8728 current_class_name
);
8729 dname
= DECL_NAME (decl
);
8730 name
= IDENTIFIER_POINTER (dname
);
8732 /* Avoid giving two errors for this. */
8733 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
8735 declspecs
= temp_tree_cons (NULL_TREE
, integer_type_node
,
8742 cp_compiler_error ("`%D' as declarator", decl
);
8743 return 0; /* We used to do a 155 abort here. */
8750 /* A function definition's declarator must have the form of
8751 a function declarator. */
8753 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
8756 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8757 && innermost_code
!= CALL_EXPR
8758 && ! (ctype
&& declspecs
== NULL_TREE
))
8760 cp_error ("declaration of `%D' as non-function", dname
);
8761 return void_type_node
;
8764 /* Anything declared one level down from the top level
8765 must be one of the parameters of a function
8766 (because the body is at least two levels down). */
8768 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8769 by not allowing C++ class definitions to specify their parameters
8770 with xdecls (must be spec.d in the parmlist).
8772 Since we now wait to push a class scope until we are sure that
8773 we are in a legitimate method context, we must set oldcname
8774 explicitly (since current_class_name is not yet alive).
8776 We also want to avoid calling this a PARM if it is in a namespace. */
8778 if (decl_context
== NORMAL
&& ! namespace_bindings_p ()
8779 && ! pseudo_global_level_p ())
8781 struct binding_level
*b
= current_binding_level
;
8782 current_binding_level
= b
->level_chain
;
8783 if (current_binding_level
!= 0 && toplevel_bindings_p ())
8784 decl_context
= PARM
;
8785 current_binding_level
= b
;
8788 /* Look through the decl specs and record which ones appear.
8789 Some typespecs are defined as built-in typenames.
8790 Others, the ones that are modifiers of other types,
8791 are represented by bits in SPECBITS: set the bits for
8792 the modifiers that appear. Storage class keywords are also in SPECBITS.
8794 If there is a typedef name or a type, store the type in TYPE.
8795 This includes builtin typedefs such as `int'.
8797 Set EXPLICIT_INT if the type is `int' or `char' and did not
8798 come from a user typedef.
8800 Set LONGLONG if `long' is mentioned twice.
8802 For C++, constructors and destructors have their own fast treatment. */
8804 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
8809 /* Certain parse errors slip through. For example,
8810 `int class;' is not caught by the parser. Try
8811 weakly to recover here. */
8812 if (TREE_CODE (spec
) != TREE_LIST
)
8815 id
= TREE_VALUE (spec
);
8817 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8819 if (id
== ridpointers
[(int) RID_INT
]
8820 || id
== ridpointers
[(int) RID_CHAR
]
8821 || id
== ridpointers
[(int) RID_BOOL
]
8822 || id
== ridpointers
[(int) RID_WCHAR
])
8826 if (id
== ridpointers
[(int) RID_BOOL
])
8827 error ("`bool' is now a keyword");
8829 cp_error ("extraneous `%T' ignored", id
);
8833 if (id
== ridpointers
[(int) RID_INT
])
8835 else if (id
== ridpointers
[(int) RID_CHAR
])
8837 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
8841 /* C++ aggregate types. */
8842 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
8845 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
8847 type
= IDENTIFIER_TYPE_VALUE (id
);
8851 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
8853 if (ridpointers
[i
] == id
)
8855 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
8857 if (pedantic
&& ! in_system_header
&& warn_long_long
)
8858 pedwarn ("ANSI C++ does not support `long long'");
8860 error ("`long long long' is too long for GCC");
8864 else if (RIDBIT_SETP (i
, specbits
))
8865 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
8866 RIDBIT_SET (i
, specbits
);
8871 /* C++ aggregate types. */
8872 else if (TREE_CODE (id
) == TYPE_DECL
|| TREE_CODE (id
) == TEMPLATE_DECL
)
8875 cp_error ("multiple declarations `%T' and `%T'", type
,
8879 type
= TREE_TYPE (id
);
8880 TREE_VALUE (spec
) = type
;
8885 error ("two or more data types in declaration of `%s'", name
);
8886 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8888 register tree t
= lookup_name (id
, 1);
8889 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
8890 error ("`%s' fails to be a typedef or built in type",
8891 IDENTIFIER_POINTER (id
));
8894 type
= TREE_TYPE (t
);
8896 /* See the code below that used this. */
8897 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
8902 else if (id
!= error_mark_node
)
8903 /* Can't change CLASS nodes into RECORD nodes here! */
8909 typedef_type
= type
;
8911 /* No type at all: default to `int', and set DEFAULTED_INT
8912 because it was not a user-defined typedef.
8913 Except when we have a `typedef' inside a signature, in
8914 which case the type defaults to `unknown type' and is
8915 instantiated when assigning to a signature pointer or ref. */
8917 if (type
== NULL_TREE
8918 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
8919 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
8920 || RIDBIT_SETP (RID_LONG
, specbits
)
8921 || RIDBIT_SETP (RID_SHORT
, specbits
)))
8923 /* These imply 'int'. */
8924 type
= integer_type_node
;
8928 if (type
== NULL_TREE
)
8931 if (return_type
== return_dtor
)
8932 type
= void_type_node
;
8933 else if (return_type
== return_ctor
)
8934 type
= build_pointer_type (ctor_return_type
);
8935 else if (return_type
== return_conversion
)
8936 type
= ctor_return_type
;
8937 else if (current_class_type
8938 && IS_SIGNATURE (current_class_type
)
8939 && RIDBIT_SETP (RID_TYPEDEF
, specbits
)
8940 && (decl_context
== FIELD
|| decl_context
== NORMAL
))
8944 type
= copy_node (opaque_type_node
);
8950 if (warn_return_type
8951 && return_type
== return_normal
)
8952 /* Save warning until we know what is really going on. */
8953 warn_about_return_type
= 1;
8955 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
8956 pedwarn ("ANSI C++ forbids typedef which does not specify a type");
8957 else if (innermost_code
!= CALL_EXPR
|| pedantic
8958 || (warn_return_type
&& return_type
== return_normal
))
8960 if (innermost_code
== CALL_EXPR
)
8961 cp_pedwarn ("return-type of `%D' defaults to `int'", dname
);
8963 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
8966 type
= integer_type_node
;
8969 else if (return_type
== return_dtor
)
8971 error ("return type specification for destructor invalid");
8972 type
= void_type_node
;
8974 else if (return_type
== return_ctor
)
8976 error ("return type specification for constructor invalid");
8977 type
= build_pointer_type (ctor_return_type
);
8979 else if (return_type
== return_conversion
)
8981 if (comptypes (type
, ctor_return_type
, 1) == 0)
8982 cp_error ("operator `%T' declared to return `%T'",
8983 ctor_return_type
, type
);
8985 cp_pedwarn ("return type specified for `operator %T'",
8988 type
= ctor_return_type
;
8993 /* Now process the modifiers that were specified
8994 and check for invalid combinations. */
8996 /* Long double is a special combination. */
8998 if (RIDBIT_SETP (RID_LONG
, specbits
)
8999 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
9001 RIDBIT_RESET (RID_LONG
, specbits
);
9002 type
= build_type_variant (long_double_type_node
, TYPE_READONLY (type
),
9003 TYPE_VOLATILE (type
));
9006 /* Check all other uses of type modifiers. */
9008 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9009 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9010 || RIDBIT_SETP (RID_LONG
, specbits
)
9011 || RIDBIT_SETP (RID_SHORT
, specbits
))
9015 if (TREE_CODE (type
) == REAL_TYPE
)
9016 error ("short, signed or unsigned invalid for `%s'", name
);
9017 else if (TREE_CODE (type
) != INTEGER_TYPE
)
9018 error ("long, short, signed or unsigned invalid for `%s'", name
);
9019 else if (RIDBIT_SETP (RID_LONG
, specbits
)
9020 && RIDBIT_SETP (RID_SHORT
, specbits
))
9021 error ("long and short specified together for `%s'", name
);
9022 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9023 || RIDBIT_SETP (RID_SHORT
, specbits
))
9025 error ("long or short specified with char for `%s'", name
);
9026 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9027 || RIDBIT_SETP (RID_SHORT
, specbits
))
9028 && TREE_CODE (type
) == REAL_TYPE
)
9029 error ("long or short specified with floating type for `%s'", name
);
9030 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9031 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
9032 error ("signed and unsigned given together for `%s'", name
);
9036 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
9038 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9040 if (flag_pedantic_errors
)
9045 /* Discard the type modifiers if they are invalid. */
9048 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
9049 RIDBIT_RESET (RID_SIGNED
, specbits
);
9050 RIDBIT_RESET (RID_LONG
, specbits
);
9051 RIDBIT_RESET (RID_SHORT
, specbits
);
9056 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
9057 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9059 error ("complex invalid for `%s'", name
);
9060 RIDBIT_RESET (RID_COMPLEX
, specbits
);
9063 /* Decide whether an integer type is signed or not.
9064 Optionally treat bitfields as signed by default. */
9065 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9066 || (bitfield
&& ! flag_signed_bitfields
9067 && (explicit_int
|| defaulted_int
|| explicit_char
9068 /* A typedef for plain `int' without `signed'
9069 can be controlled just like plain `int'. */
9070 || ! (typedef_decl
!= NULL_TREE
9071 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
9072 && TREE_CODE (type
) != ENUMERAL_TYPE
9073 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)))
9076 type
= long_long_unsigned_type_node
;
9077 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9078 type
= long_unsigned_type_node
;
9079 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9080 type
= short_unsigned_type_node
;
9081 else if (type
== char_type_node
)
9082 type
= unsigned_char_type_node
;
9083 else if (typedef_decl
)
9084 type
= unsigned_type (type
);
9086 type
= unsigned_type_node
;
9088 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9089 && type
== char_type_node
)
9090 type
= signed_char_type_node
;
9092 type
= long_long_integer_type_node
;
9093 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9094 type
= long_integer_type_node
;
9095 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9096 type
= short_integer_type_node
;
9098 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
9100 /* If we just have "complex", it is equivalent to
9101 "complex double", but if any modifiers at all are specified it is
9102 the complex form of TYPE. E.g, "complex short" is
9103 "complex short int". */
9105 if (defaulted_int
&& ! longlong
9106 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
9107 || RIDBIT_SETP (RID_SHORT
, specbits
)
9108 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9109 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
9110 type
= complex_double_type_node
;
9111 else if (type
== integer_type_node
)
9112 type
= complex_integer_type_node
;
9113 else if (type
== float_type_node
)
9114 type
= complex_float_type_node
;
9115 else if (type
== double_type_node
)
9116 type
= complex_double_type_node
;
9117 else if (type
== long_double_type_node
)
9118 type
= complex_long_double_type_node
;
9120 type
= build_complex_type (type
);
9123 if (return_type
== return_conversion
9124 && (RIDBIT_SETP (RID_CONST
, specbits
)
9125 || RIDBIT_SETP (RID_VOLATILE
, specbits
)))
9126 cp_error ("`operator %T' cannot be cv-qualified",
9129 /* Set CONSTP if this declaration is `const', whether by
9130 explicit specification or via a typedef.
9131 Likewise for VOLATILEP. */
9133 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + TYPE_READONLY (type
);
9134 volatilep
= !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + TYPE_VOLATILE (type
);
9135 type
= cp_build_type_variant (type
, constp
, volatilep
);
9137 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
9138 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
9139 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
9140 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
9141 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
9143 if (RIDBIT_SETP (RID_STATIC
, specbits
))
9144 staticp
= 1 + (decl_context
== FIELD
);
9146 if (virtualp
&& staticp
== 2)
9148 cp_error ("member `%D' cannot be declared both virtual and static",
9152 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
9153 RIDBIT_RESET (RID_FRIEND
, specbits
);
9155 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9157 if (decl_context
== PARM
)
9159 error ("non-member `%s' cannot be declared `mutable'", name
);
9160 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9162 else if (friendp
|| decl_context
== TYPENAME
)
9164 error ("non-object member `%s' cannot be declared `mutable'", name
);
9165 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9169 /* Warn if two storage classes are given. Default to `auto'. */
9171 if (RIDBIT_ANY_SET (specbits
))
9173 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
9174 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
9175 if (decl_context
== PARM
&& nclasses
> 0)
9176 error ("storage class specifiers invalid in parameter declarations");
9177 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9179 if (decl_context
== PARM
)
9180 error ("typedef declaration invalid in parameter declaration");
9183 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
9184 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
9187 /* Give error if `virtual' is used outside of class declaration. */
9189 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9191 error ("virtual outside class declaration");
9194 if (current_class_name
== NULL_TREE
&& RIDBIT_SETP (RID_MUTABLE
, specbits
))
9196 error ("only members can be declared mutable");
9197 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9200 /* Static anonymous unions are dealt with here. */
9201 if (staticp
&& decl_context
== TYPENAME
9202 && TREE_CODE (declspecs
) == TREE_LIST
9203 && ANON_UNION_TYPE_P (TREE_VALUE (declspecs
)))
9204 decl_context
= FIELD
;
9206 /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
9207 is used in a signature member function declaration. */
9208 if (decl_context
== FIELD
9209 && IS_SIGNATURE (current_class_type
)
9210 && RIDBIT_NOTSETP (RID_TYPEDEF
, specbits
))
9214 error ("`const' specified for signature member function `%s'", name
);
9219 error ("`volatile' specified for signature member function `%s'",
9225 error ("`inline' specified for signature member function `%s'", name
);
9226 /* Later, we'll make signature member functions inline. */
9231 error ("`friend' declaration in signature definition");
9236 error ("`virtual' specified for signature member function `%s'",
9238 /* Later, we'll make signature member functions virtual. */
9243 /* Warn about storage classes that are invalid for certain
9244 kinds of declarations (parameters, typenames, etc.). */
9247 error ("multiple storage classes in declaration of `%s'", name
);
9248 else if (decl_context
!= NORMAL
&& nclasses
> 0)
9250 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9251 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
9252 || RIDBIT_SETP (RID_AUTO
, specbits
)))
9254 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9256 else if (decl_context
== FIELD
9257 && ! IS_SIGNATURE (current_class_type
)
9258 /* C++ allows static class elements */
9259 && RIDBIT_SETP (RID_STATIC
, specbits
))
9260 /* C++ also allows inlines and signed and unsigned elements,
9261 but in those cases we don't come in here. */
9265 if (decl_context
== FIELD
)
9267 tree tmp
= NULL_TREE
;
9268 register int op
= 0;
9272 /* Avoid trying to get an operand off an identifier node. */
9273 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
9276 tmp
= TREE_OPERAND (declarator
, 0);
9277 op
= IDENTIFIER_OPNAME_P (tmp
);
9279 error ("storage class specified for %s `%s'",
9280 IS_SIGNATURE (current_class_type
)
9282 ? "signature member operator"
9283 : "signature member function")
9284 : (op
? "member operator" : "field"),
9285 op
? operator_name_string (tmp
) : name
);
9288 error (((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9289 ? "storage class specified for parameter `%s'"
9290 : "storage class specified for typename"), name
);
9291 RIDBIT_RESET (RID_REGISTER
, specbits
);
9292 RIDBIT_RESET (RID_AUTO
, specbits
);
9293 RIDBIT_RESET (RID_EXTERN
, specbits
);
9295 if (decl_context
== FIELD
&& IS_SIGNATURE (current_class_type
))
9297 RIDBIT_RESET (RID_STATIC
, specbits
);
9302 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
9304 if (toplevel_bindings_p ())
9306 /* It's common practice (and completely valid) to have a const
9307 be initialized and declared extern. */
9309 warning ("`%s' initialized and declared `extern'", name
);
9312 error ("`%s' has both `extern' and initializer", name
);
9314 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
9315 && ! toplevel_bindings_p ())
9316 error ("nested function `%s' declared `extern'", name
);
9317 else if (toplevel_bindings_p ())
9319 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9320 error ("top-level declaration of `%s' specifies `auto'", name
);
9323 if (nclasses
> 0 && friendp
)
9324 error ("storage class specifiers invalid in friend function declarations");
9326 /* Now figure out the structure of the declarator proper.
9327 Descend through it, creating more complex types, until we reach
9328 the declared identifier (or NULL_TREE, in an absolute declarator). */
9330 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
9331 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
9333 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9334 an INDIRECT_REF (for *...),
9335 a CALL_EXPR (for ...(...)),
9336 an identifier (for the name being declared)
9337 or a null pointer (for the place in an absolute declarator
9338 where the name was omitted).
9339 For the last two cases, we have just exited the loop.
9341 For C++ it could also be
9342 a SCOPE_REF (for class :: ...). In this case, we have converted
9343 sensible names to types, and those are the values we use to
9344 qualify the member name.
9345 an ADDR_EXPR (for &...),
9346 a BIT_NOT_EXPR (for destructors)
9348 At this point, TYPE is the type of elements of an array,
9349 or for a function to return, or for a pointer to point to.
9350 After this sequence of ifs, TYPE is the type of the
9351 array or function or pointer, and DECLARATOR has had its
9352 outermost layer removed. */
9354 if (type
== error_mark_node
)
9356 if (TREE_CODE (declarator
) == SCOPE_REF
)
9357 declarator
= TREE_OPERAND (declarator
, 1);
9359 declarator
= TREE_OPERAND (declarator
, 0);
9362 if (quals
!= NULL_TREE
9363 && (declarator
== NULL_TREE
9364 || TREE_CODE (declarator
) != SCOPE_REF
))
9366 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
9367 ctype
= TYPE_METHOD_BASETYPE (type
);
9368 if (ctype
!= NULL_TREE
)
9370 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
9371 ctype
= grok_method_quals (ctype
, dummy
, quals
);
9372 type
= TREE_TYPE (dummy
);
9376 switch (TREE_CODE (declarator
))
9380 register tree itype
= NULL_TREE
;
9381 register tree size
= TREE_OPERAND (declarator
, 1);
9382 /* The index is a signed object `sizetype' bits wide. */
9383 tree index_type
= signed_type (sizetype
);
9385 declarator
= TREE_OPERAND (declarator
, 0);
9387 /* Check for some types that there cannot be arrays of. */
9389 if (TREE_CODE (type
) == VOID_TYPE
)
9391 cp_error ("declaration of `%D' as array of voids", dname
);
9392 type
= error_mark_node
;
9395 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9397 cp_error ("declaration of `%D' as array of functions", dname
);
9398 type
= error_mark_node
;
9401 /* ARM $8.4.3: Since you can't have a pointer to a reference,
9402 you can't have arrays of references. If we allowed them,
9403 then we'd be saying x[i] is valid for an array x, but
9404 then you'd have to ask: what does `*(x + i)' mean? */
9405 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9407 if (decl_context
== TYPENAME
)
9408 cp_error ("cannot make arrays of references");
9410 cp_error ("declaration of `%D' as array of references",
9412 type
= error_mark_node
;
9415 if (TREE_CODE (type
) == OFFSET_TYPE
)
9417 cp_error ("declaration of `%D' as array of data members",
9419 type
= error_mark_node
;
9422 if (TREE_CODE (type
) == METHOD_TYPE
)
9424 cp_error ("declaration of `%D' as array of function members",
9426 type
= error_mark_node
;
9429 if (size
== error_mark_node
)
9430 type
= error_mark_node
;
9432 if (type
== error_mark_node
)
9437 /* Must suspend_momentary here because the index
9438 type may need to live until the end of the function.
9439 For example, it is used in the declaration of a
9440 variable which requires destructing at the end of
9441 the function; then build_vec_delete will need this
9443 int yes
= suspend_momentary ();
9444 /* Might be a cast. */
9445 if (TREE_CODE (size
) == NOP_EXPR
9446 && TREE_TYPE (size
) == TREE_TYPE (TREE_OPERAND (size
, 0)))
9447 size
= TREE_OPERAND (size
, 0);
9449 /* If this involves a template parameter, it'll be
9450 constant, but we don't know what the value is yet. */
9451 if (processing_template_decl
)
9453 itype
= make_node (INTEGER_TYPE
);
9454 TYPE_MIN_VALUE (itype
) = size_zero_node
;
9455 TYPE_MAX_VALUE (itype
) = build_min
9456 (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
9457 goto dont_grok_size
;
9460 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
9461 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
)
9463 cp_error ("size of array `%D' has non-integer type",
9465 size
= integer_one_node
;
9467 if (TREE_READONLY_DECL_P (size
))
9468 size
= decl_constant_value (size
);
9469 if (pedantic
&& integer_zerop (size
))
9470 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname
);
9471 if (TREE_CONSTANT (size
))
9473 int old_flag_pedantic_errors
= flag_pedantic_errors
;
9474 int old_pedantic
= pedantic
;
9475 pedantic
= flag_pedantic_errors
= 1;
9476 /* Always give overflow errors on array subscripts. */
9477 constant_expression_warning (size
);
9478 pedantic
= old_pedantic
;
9479 flag_pedantic_errors
= old_flag_pedantic_errors
;
9480 if (INT_CST_LT (size
, integer_zero_node
))
9482 cp_error ("size of array `%D' is negative", dname
);
9483 size
= integer_one_node
;
9491 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
9494 cp_pedwarn ("ANSI C++ forbids variable-size array");
9499 = fold (build_binary_op (MINUS_EXPR
,
9500 cp_convert (index_type
, size
),
9501 cp_convert (index_type
,
9502 integer_one_node
), 1));
9503 if (! TREE_CONSTANT (itype
))
9504 itype
= variable_size (itype
);
9505 else if (TREE_OVERFLOW (itype
))
9507 error ("overflow in array dimension");
9508 TREE_OVERFLOW (itype
) = 0;
9511 /* If we're a parm, we need to have a permanent type so
9512 mangling checks for re-use will work right. If both the
9513 element and index types are permanent, the array type
9515 if (decl_context
== PARM
9516 && allocation_temporary_p () && TREE_PERMANENT (type
))
9518 push_obstacks (&permanent_obstack
, &permanent_obstack
);
9519 itype
= build_index_type (itype
);
9523 itype
= build_index_type (itype
);
9526 resume_momentary (yes
);
9529 type
= build_cplus_array_type (type
, itype
);
9538 tree inner_parms
= TREE_OPERAND (declarator
, 1);
9539 tree inner_decl
= TREE_OPERAND (declarator
, 0);
9541 /* Declaring a function type.
9542 Make sure we have a valid type for the function to return. */
9544 /* We now know that constp and volatilep don't apply to the
9545 decl, but to its return type. */
9546 constp
= volatilep
= 0;
9548 /* Warn about some types functions can't return. */
9550 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9552 error ("`%s' declared as function returning a function", name
);
9553 type
= integer_type_node
;
9555 if (TREE_CODE (type
) == ARRAY_TYPE
)
9557 error ("`%s' declared as function returning an array", name
);
9558 type
= integer_type_node
;
9561 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
9562 inner_decl
= TREE_OPERAND (inner_decl
, 1);
9564 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
9567 /* Pick up type qualifiers which should be applied to `this'. */
9568 quals
= TREE_OPERAND (declarator
, 2);
9570 /* Pick up the exception specifications. */
9571 raises
= TREE_TYPE (declarator
);
9573 /* Say it's a definition only for the CALL_EXPR
9574 closest to the identifier. */
9577 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
9578 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
9579 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
9581 if (ctype
== NULL_TREE
9582 && decl_context
== FIELD
9584 && (friendp
== 0 || dname
== current_class_name
))
9585 ctype
= current_class_type
;
9587 if (ctype
&& return_type
== return_conversion
)
9588 TYPE_HAS_CONVERSION (ctype
) = 1;
9589 if (ctype
&& constructor_name (ctype
) == dname
)
9591 /* We are within a class's scope. If our declarator name
9592 is the same as the class name, and we are defining
9593 a function, then it is a constructor/destructor, and
9594 therefore returns a void type. */
9596 if (flags
== DTOR_FLAG
)
9598 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
9599 not be declared const or volatile. A destructor
9600 may not be static. */
9602 error ("destructor cannot be static member function");
9605 cp_error ("destructors may not be `%s'",
9606 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9609 if (decl_context
== FIELD
)
9611 if (! member_function_or_else (ctype
, current_class_type
,
9612 "destructor for alien class `%s' cannot be a member"))
9613 return void_type_node
;
9616 else /* It's a constructor. */
9620 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
9621 not be declared const or volatile. A constructor may
9622 not be virtual. A constructor may not be static. */
9624 error ("constructor cannot be static member function");
9627 pedwarn ("constructors cannot be declared virtual");
9632 cp_error ("constructors may not be `%s'",
9633 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9637 RID_BIT_TYPE tmp_bits
;
9638 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
9639 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
9640 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
9641 if (RIDBIT_ANY_SET (tmp_bits
))
9642 error ("return value type specifier for constructor ignored");
9644 type
= build_pointer_type (ctype
);
9645 if (decl_context
== FIELD
9646 && IS_SIGNATURE (current_class_type
))
9648 error ("constructor not allowed in signature");
9649 return void_type_node
;
9651 else if (decl_context
== FIELD
)
9653 if (! member_function_or_else (ctype
, current_class_type
,
9654 "constructor for alien class `%s' cannot be member"))
9655 return void_type_node
;
9656 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
9657 if (return_type
!= return_ctor
)
9661 if (decl_context
== FIELD
)
9667 error ("can't initialize friend function `%s'", name
);
9670 /* Cannot be both friend and virtual. */
9671 error ("virtual functions cannot be friends");
9672 RIDBIT_RESET (RID_FRIEND
, specbits
);
9675 if (decl_context
== NORMAL
)
9676 error ("friend declaration not in class definition");
9677 if (current_function_decl
&& funcdef_flag
)
9678 cp_error ("can't define friend function `%s' in a local class definition",
9682 /* Construct the function type and go to the next
9683 inner layer of declarator. */
9685 declarator
= TREE_OPERAND (declarator
, 0);
9687 /* FIXME: This is where default args should be fully
9690 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
9692 if (declarator
&& flags
== DTOR_FLAG
)
9694 /* A destructor declared in the body of a class will
9695 be represented as a BIT_NOT_EXPR. But, we just
9696 want the underlying IDENTIFIER. */
9697 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
9698 declarator
= TREE_OPERAND (declarator
, 0);
9700 if (strict_prototype
== 0 && arg_types
== NULL_TREE
)
9701 arg_types
= void_list_node
;
9702 else if (arg_types
== NULL_TREE
9703 || arg_types
!= void_list_node
)
9705 cp_error ("destructors may not have parameters");
9706 arg_types
= void_list_node
;
9707 last_function_parms
= NULL_TREE
;
9711 /* ANSI says that `const int foo ();'
9712 does not make the function foo const. */
9713 type
= build_function_type (type
, arg_types
);
9717 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
9718 if (TREE_PURPOSE (t
)
9719 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
9721 add_defarg_fn (type
);
9730 /* Filter out pointers-to-references and references-to-references.
9731 We can get these if a TYPE_DECL is used. */
9733 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9735 error ("cannot declare %s to references",
9736 TREE_CODE (declarator
) == ADDR_EXPR
9737 ? "references" : "pointers");
9738 declarator
= TREE_OPERAND (declarator
, 0);
9742 if (TREE_CODE (type
) == OFFSET_TYPE
9743 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
9744 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
9746 cp_error ("cannot declare pointer to `%#T' member",
9748 type
= TREE_TYPE (type
);
9751 /* Merge any constancy or volatility into the target type
9754 /* We now know that constp and volatilep don't apply to the
9755 decl, but to the target of the pointer. */
9756 constp
= volatilep
= 0;
9758 if (IS_SIGNATURE (type
))
9760 if (TREE_CODE (declarator
) == ADDR_EXPR
)
9762 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9763 && TYPE_SIZE (type
))
9764 cp_warning ("empty signature `%T' used in signature reference declaration",
9767 type
= build_signature_reference_type (type
);
9769 sorry ("signature reference");
9775 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9776 && TYPE_SIZE (type
))
9777 cp_warning ("empty signature `%T' used in signature pointer declaration",
9779 type
= build_signature_pointer_type (type
);
9784 else if (TREE_CODE (declarator
) == ADDR_EXPR
)
9786 if (TREE_CODE (type
) == VOID_TYPE
)
9787 error ("invalid type: `void &'");
9789 type
= build_reference_type (type
);
9791 else if (TREE_CODE (type
) == METHOD_TYPE
)
9793 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9796 type
= build_pointer_type (type
);
9798 /* Process a list of type modifier keywords (such as
9799 const or volatile) that were given inside the `*' or `&'. */
9801 if (TREE_TYPE (declarator
))
9803 register tree typemodlist
;
9805 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
9806 typemodlist
= TREE_CHAIN (typemodlist
))
9808 if (TREE_VALUE (typemodlist
) == ridpointers
[(int) RID_CONST
])
9810 else if (TREE_VALUE (typemodlist
) == ridpointers
[(int) RID_VOLATILE
])
9815 error ("invalid type modifier within %s declarator",
9816 TREE_CODE (declarator
) == ADDR_EXPR
9817 ? "reference" : "pointer");
9821 pedwarn ("duplicate `const'");
9823 pedwarn ("duplicate `volatile'");
9824 if (TREE_CODE (declarator
) == ADDR_EXPR
9825 && (constp
|| volatilep
))
9828 pedwarn ("discarding `const' applied to a reference");
9830 pedwarn ("discarding `volatile' applied to a reference");
9831 constp
= volatilep
= 0;
9833 type
= cp_build_type_variant (type
, constp
, volatilep
);
9835 declarator
= TREE_OPERAND (declarator
, 0);
9841 /* We have converted type names to NULL_TREE if the
9842 name was bogus, or to a _TYPE node, if not.
9844 The variable CTYPE holds the type we will ultimately
9845 resolve to. The code here just needs to build
9846 up appropriate member types. */
9847 tree sname
= TREE_OPERAND (declarator
, 1);
9850 /* Destructors can have their visibilities changed as well. */
9851 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
9852 sname
= TREE_OPERAND (sname
, 0);
9854 if (TREE_COMPLEXITY (declarator
) == 0)
9855 /* This needs to be here, in case we are called
9856 multiple times. */ ;
9857 else if (TREE_COMPLEXITY (declarator
) == -1)
9858 /* Namespace member. */
9859 pop_decl_namespace ();
9860 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
9861 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
9862 else if (! IS_AGGR_TYPE_CODE
9863 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
9865 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
9867 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
9868 that refer to ctype. They couldn't be resolved earlier
9869 because we hadn't pushed into the class yet.
9870 Example: resolve 'B<T>::type' in
9871 'B<typename B<T>::type> B<T>::f () { }'. */
9872 if (current_template_parms
9873 && uses_template_parms (type
)
9874 && uses_template_parms (current_class_type
))
9876 tree args
= current_template_args ();
9877 type
= tsubst (type
, args
, NULL_TREE
);
9880 /* This pop_nested_class corresponds to the
9881 push_nested_class used to push into class scope for
9882 parsing the argument list of a function decl, in
9884 pop_nested_class (1);
9885 TREE_COMPLEXITY (declarator
) = current_class_depth
;
9888 my_friendly_abort (16);
9890 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
9892 /* We had a reference to a global decl, or
9893 perhaps we were given a non-aggregate typedef,
9894 in which case we cleared this out, and should just
9895 keep going as though it wasn't there. */
9899 ctype
= TREE_OPERAND (declarator
, 0);
9902 while (t
!= NULL_TREE
)
9904 if (CLASSTYPE_TEMPLATE_INFO (t
) &&
9905 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
9906 template_count
+= 1;
9907 t
= TYPE_MAIN_DECL (t
);
9908 if (DECL_LANG_SPECIFIC (t
))
9909 t
= DECL_CLASS_CONTEXT (t
);
9914 if (sname
== NULL_TREE
)
9917 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
9919 /* This is the `standard' use of the scoping operator:
9920 basetype :: member . */
9922 if (ctype
== current_class_type
)
9928 Is this ill-formed? */
9931 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
9934 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9936 if (current_class_type
== NULL_TREE
9938 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
9939 TYPE_ARG_TYPES (type
));
9942 cp_error ("cannot declare member function `%T::%s' within `%T'",
9943 ctype
, name
, current_class_type
);
9944 return void_type_node
;
9947 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
9948 || TYPE_SIZE (complete_type (ctype
)) != NULL_TREE
)
9950 /* Have to move this code elsewhere in this function.
9951 this code is used for i.e., typedef int A::M; M *pm;
9953 It is? How? jason 10/2/94 */
9955 if (current_class_type
)
9957 cp_error ("cannot declare member `%T::%s' within `%T'",
9958 ctype
, name
, current_class_type
);
9959 return void_type_node
;
9961 type
= build_offset_type (ctype
, type
);
9963 else if (uses_template_parms (ctype
))
9965 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9967 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
9968 TYPE_ARG_TYPES (type
));
9972 cp_error ("structure `%T' not yet defined", ctype
);
9973 return error_mark_node
;
9978 else if (TREE_CODE (sname
) == SCOPE_REF
)
9979 my_friendly_abort (17);
9983 declarator
= TREE_OPERAND (declarator
, 1);
9984 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
9985 /* In this case, we will deal with it later. */
9989 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9990 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
9991 TYPE_ARG_TYPES (type
));
9993 type
= build_offset_type (ctype
, type
);
10000 declarator
= TREE_OPERAND (declarator
, 0);
10005 case ENUMERAL_TYPE
:
10006 declarator
= NULL_TREE
;
10010 declarator
= NULL_TREE
;
10014 my_friendly_abort (158);
10018 if (explicitp
== 1)
10020 error ("only constructors can be declared `explicit'");
10024 /* Now TYPE has the actual type. */
10026 /* If this is declaring a typedef name, return a TYPE_DECL. */
10028 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10032 error ("const `%s' cannot be declared `mutable'", name
);
10033 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10037 error ("static `%s' cannot be declared `mutable'", name
);
10038 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10042 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
10046 /* Note that the grammar rejects storage classes
10047 in typenames, fields or parameters. */
10048 if (current_lang_name
== lang_name_java
)
10049 TYPE_FOR_JAVA (type
) = 1;
10051 if (decl_context
== FIELD
)
10053 if (declarator
== current_class_name
)
10054 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10056 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10057 if (IS_SIGNATURE (current_class_type
) && opaque_typedef
)
10058 SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type
) = 1;
10062 /* Make sure this typedef lives as long as its type,
10063 since it might be used as a template parameter. */
10064 if (type
!= error_mark_node
)
10065 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
10066 decl
= build_decl (TYPE_DECL
, declarator
, type
);
10067 if (type
!= error_mark_node
)
10071 /* If the user declares "struct {...} foo" then `foo' will have
10072 an anonymous name. Fill that name in now. Nothing can
10073 refer to it, so nothing needs know about the name change.
10074 The TYPE_NAME field was filled in by build_struct_xref. */
10075 if (type
!= error_mark_node
10076 && TYPE_NAME (type
)
10077 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10078 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
10080 /* FIXME: This is bogus; we should not be doing this for
10081 cv-qualified types. */
10083 /* For anonymous structs that are cv-qualified, need to use
10084 TYPE_MAIN_VARIANT so that name will mangle correctly. As
10085 type not referenced after this block, don't bother
10086 resetting type to original type, ie. TREE_TYPE (decl). */
10087 type
= TYPE_MAIN_VARIANT (type
);
10089 /* Replace the anonymous name with the real name everywhere. */
10090 lookup_tag_reverse (type
, declarator
);
10091 TYPE_NAME (type
) = decl
;
10093 if (TYPE_LANG_SPECIFIC (type
))
10094 TYPE_WAS_ANONYMOUS (type
) = 1;
10096 /* XXX Temporarily set the scope.
10097 When returning, start_decl expects it as NULL_TREE,
10098 and will then then set it using pushdecl. */
10099 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
10100 if (current_class_type
)
10101 DECL_CONTEXT (decl
) = current_class_type
;
10103 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10105 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
10106 DECL_ASSEMBLER_NAME (decl
)
10107 = get_identifier (build_overload_name (type
, 1, 1));
10108 DECL_CONTEXT (decl
) = NULL_TREE
;
10110 /* FIXME remangle member functions; member functions of a
10111 type with external linkage have external linkage. */
10114 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10116 cp_error_at ("typedef name may not be class-qualified", decl
);
10121 if (ctype
== NULL_TREE
)
10123 if (TREE_CODE (type
) != METHOD_TYPE
)
10124 cp_error_at ("invalid type qualifier for non-method type", decl
);
10126 ctype
= TYPE_METHOD_BASETYPE (type
);
10128 if (ctype
!= NULL_TREE
)
10129 grok_method_quals (ctype
, decl
, quals
);
10132 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10133 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10134 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10136 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10137 error ("non-object member `%s' cannot be declared mutable", name
);
10139 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
10140 inlinep
, friendp
, raises
!= NULL_TREE
);
10143 error ("typedef declaration includes an initializer");
10148 /* Detect the case of an array type of unspecified size
10149 which came, as such, direct from a typedef name.
10150 We must copy the type, so that each identifier gets
10151 a distinct type, so that each identifier's size can be
10152 controlled separately by its own initializer. */
10154 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
10155 && TYPE_DOMAIN (type
) == NULL_TREE
)
10157 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
10160 /* If this is a type name (such as, in a cast or sizeof),
10161 compute the type and return it now. */
10163 if (decl_context
== TYPENAME
)
10165 /* Note that the grammar rejects storage classes
10166 in typenames, fields or parameters. */
10167 if (constp
|| volatilep
)
10169 if (IS_SIGNATURE (type
))
10170 error ("`const' or `volatile' specified with signature type");
10173 /* Special case: "friend class foo" looks like a TYPENAME context. */
10178 cp_error ("`volatile' specified for friend class declaration");
10183 cp_error ("`inline' specified for friend class declaration");
10187 /* Only try to do this stuff if we didn't already give up. */
10188 if (type
!= integer_type_node
)
10190 /* A friendly class? */
10191 if (current_class_type
)
10192 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
10194 error ("trying to make class `%s' a friend of global scope",
10195 TYPE_NAME_STRING (type
));
10196 type
= void_type_node
;
10201 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
10202 if (ctype
== NULL_TREE
)
10204 my_friendly_assert (TREE_CODE (type
) == METHOD_TYPE
, 159);
10205 ctype
= TYPE_METHOD_BASETYPE (type
);
10207 grok_method_quals (ctype
, dummy
, quals
);
10208 type
= TREE_TYPE (dummy
);
10213 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
10214 && decl_context
!= CATCHPARM
10215 && TREE_CODE (type
) != UNION_TYPE
10218 cp_error ("abstract declarator `%T' used as declaration", type
);
10219 declarator
= make_anon_name ();
10222 /* `void' at top level (not within pointer)
10223 is allowed only in typedefs or type names.
10224 We don't complain about parms either, but that is because
10225 a better error message can be made later. */
10227 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
10230 error ("unnamed variable or field declared void");
10231 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10233 if (IDENTIFIER_OPNAME_P (declarator
))
10234 my_friendly_abort (356);
10236 error ("variable or field `%s' declared void", name
);
10239 error ("variable or field declared void");
10240 type
= integer_type_node
;
10243 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10244 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10246 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10248 if (ctype
|| in_namespace
)
10249 error ("cannot use `::' in parameter declaration");
10251 /* A parameter declared as an array of T is really a pointer to T.
10252 One declared as a function is really a pointer to a function.
10253 One declared as a member is really a pointer to member. */
10255 if (TREE_CODE (type
) == ARRAY_TYPE
)
10257 /* Transfer const-ness of array into that of type pointed to. */
10258 type
= build_pointer_type (TREE_TYPE (type
));
10259 volatilep
= constp
= 0;
10261 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10262 type
= build_pointer_type (type
);
10263 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10264 type
= build_pointer_type (type
);
10265 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
10267 error ("declaration of `%s' as void", name
);
10273 register tree decl
;
10275 if (decl_context
== PARM
)
10277 decl
= build_decl (PARM_DECL
, declarator
, complete_type (type
));
10279 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
10280 inlinep
, friendp
, raises
!= NULL_TREE
);
10281 if (current_class_type
10282 && IS_SIGNATURE (current_class_type
))
10285 error ("parameter of signature member function declared `inline'");
10286 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10287 error ("parameter of signature member function declared `auto'");
10288 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10289 error ("parameter of signature member function declared `register'");
10292 /* Compute the type actually passed in the parmlist,
10293 for the case where there is no prototype.
10294 (For example, shorts and chars are passed as ints.)
10295 When there is a prototype, this is overridden later. */
10297 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
10299 else if (decl_context
== FIELD
)
10301 if (type
== error_mark_node
)
10303 /* Happens when declaring arrays of sizes which
10304 are error_mark_node, for example. */
10307 else if (in_namespace
)
10309 /* Something like struct S { int N::j; }; */
10310 cp_error ("invalid use of `::'");
10313 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10316 tree function_context
;
10318 /* We catch the others as conflicts with the builtin
10320 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
10322 cp_error ("function `%D' cannot be declared friend",
10329 if (ctype
== NULL_TREE
)
10330 ctype
= current_class_type
;
10332 if (ctype
== NULL_TREE
)
10334 cp_error ("can't make `%D' into a method -- not in a class",
10336 return void_type_node
;
10339 /* ``A union may [ ... ] not [ have ] virtual functions.''
10341 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10343 cp_error ("function `%D' declared virtual inside a union",
10345 return void_type_node
;
10348 if (declarator
== ansi_opname
[(int) NEW_EXPR
]
10349 || declarator
== ansi_opname
[(int) VEC_NEW_EXPR
]
10350 || declarator
== ansi_opname
[(int) DELETE_EXPR
]
10351 || declarator
== ansi_opname
[(int) VEC_DELETE_EXPR
])
10355 cp_error ("`%D' cannot be declared virtual, since it is always static",
10360 else if (staticp
< 2)
10361 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10362 TYPE_ARG_TYPES (type
));
10365 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10366 function_context
= (ctype
!= NULL_TREE
) ?
10367 hack_decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10368 publicp
= (! friendp
|| ! staticp
)
10369 && function_context
== NULL_TREE
;
10370 decl
= grokfndecl (ctype
, type
,
10371 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
10372 ? declarator
: dname
,
10374 virtualp
, flags
, quals
, raises
, attrlist
,
10375 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
10376 funcdef_flag
, template_count
, in_namespace
);
10377 if (decl
== NULL_TREE
|| decl
== error_mark_node
)
10380 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10381 /* The decl and setting of decl_machine_attr is also turned off. */
10382 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
10385 if (explicitp
== 2)
10386 DECL_NONCONVERTING_P (decl
) = 1;
10388 else if (TREE_CODE (type
) == METHOD_TYPE
)
10390 /* We only get here for friend declarations of
10391 members of other classes. */
10392 /* All method decls are public, so tell grokfndecl to set
10393 TREE_PUBLIC, also. */
10394 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
10395 virtualp
, flags
, quals
, raises
, attrlist
,
10396 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
10397 template_count
, in_namespace
);
10398 if (decl
== NULL_TREE
)
10401 else if (!staticp
&& ! processing_template_decl
10402 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
10403 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10406 cp_error ("field `%D' has incomplete type", declarator
);
10408 cp_error ("name `%T' has incomplete type", type
);
10410 /* If we're instantiating a template, tell them which
10411 instantiation made the field's type be incomplete. */
10412 if (current_class_type
10413 && TYPE_NAME (current_class_type
)
10414 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
10415 && declspecs
&& TREE_VALUE (declspecs
)
10416 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
10417 cp_error (" in instantiation of template `%T'",
10418 current_class_type
);
10420 type
= error_mark_node
;
10427 error ("`%s' is neither function nor method; cannot be declared friend",
10428 IDENTIFIER_POINTER (declarator
));
10436 /* Friends are treated specially. */
10437 if (ctype
== current_class_type
)
10438 warning ("member functions are implicitly friends of their class");
10441 tree t
= NULL_TREE
;
10442 if (decl
&& DECL_NAME (decl
))
10444 if (template_class_depth (current_class_type
) == 0)
10447 = check_explicit_specialization
10449 template_count
, 2 * (funcdef_flag
!= 0) + 4);
10450 if (decl
== error_mark_node
)
10451 return error_mark_node
;
10454 t
= do_friend (ctype
, declarator
, decl
,
10455 last_function_parms
, flags
, quals
,
10458 if (t
&& funcdef_flag
)
10461 return void_type_node
;
10465 /* Structure field. It may not be a function, except for C++ */
10467 if (decl
== NULL_TREE
)
10473 /* An attempt is being made to initialize a non-static
10474 member. But, from [class.mem]:
10476 4 A member-declarator can contain a
10477 constant-initializer only if it declares a static
10478 member (_class.static_) of integral or enumeration
10479 type, see _class.static.data_.
10481 This used to be relatively common practice, but
10482 the rest of the compiler does not correctly
10483 handle the initialization unless the member is
10484 static so we make it static below. */
10485 cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
10486 constp
? "const member" : "member",
10488 cp_pedwarn ("making `%D' static", declarator
);
10492 /* Motion 10 at San Diego: If a static const integral data
10493 member is initialized with an integral constant
10494 expression, the initializer may appear either in the
10495 declaration (within the class), or in the definition,
10496 but not both. If it appears in the class, the member is
10497 a member constant. The file-scope definition is always
10499 if (CLASS_TYPE_P (type
)
10500 || TREE_CODE (type
) == REFERENCE_TYPE
)
10502 cp_error ("in-class initialization of static data member of non-integral type `%T'",
10504 /* If we just return the declaration, crashes will
10505 sometimes occur. We therefore return
10506 void_type_node, as if this was a friend
10507 declaration, to cause callers to completely
10508 ignore this declaration. */
10509 return void_type_node
;
10512 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
10514 else if (pedantic
&& ! INTEGRAL_TYPE_P (type
)
10515 && !uses_template_parms (type
))
10516 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", declarator
, type
);
10521 /* ANSI C++ Apr '95 wp 9.2 */
10522 if (declarator
== current_class_name
)
10523 cp_pedwarn ("ANSI C++ forbids static member `%D' with same name as enclosing class",
10526 /* C++ allows static class members.
10527 All other work for this is done by grokfield.
10528 This VAR_DCL is built by build_lang_field_decl.
10529 All other VAR_DECLs are built by build_decl. */
10530 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
10531 TREE_STATIC (decl
) = 1;
10532 /* In class context, 'static' means public access. */
10533 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
10537 decl
= build_lang_field_decl (FIELD_DECL
, declarator
, type
);
10538 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10540 DECL_MUTABLE_P (decl
) = 1;
10541 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10545 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
10546 inlinep
, friendp
, raises
!= NULL_TREE
);
10549 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10551 tree original_name
;
10557 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10558 original_name
= dname
;
10560 original_name
= declarator
;
10562 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10563 error ("storage class `auto' invalid for function `%s'", name
);
10564 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10565 error ("storage class `register' invalid for function `%s'", name
);
10567 /* Function declaration not at top level.
10568 Storage classes other than `extern' are not allowed
10569 and `extern' makes no difference. */
10570 if (! toplevel_bindings_p ()
10571 && (RIDBIT_SETP (RID_STATIC
, specbits
)
10572 || RIDBIT_SETP (RID_INLINE
, specbits
))
10575 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10576 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
10578 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
10581 if (ctype
== NULL_TREE
)
10585 error ("virtual non-class function `%s'", name
);
10589 if (current_lang_name
== lang_name_cplusplus
10590 && ! processing_template_decl
10591 && ! MAIN_NAME_P (original_name
)
10592 && ! (IDENTIFIER_LENGTH (original_name
) > 10
10593 && IDENTIFIER_POINTER (original_name
)[0] == '_'
10594 && IDENTIFIER_POINTER (original_name
)[1] == '_'
10595 && strncmp (IDENTIFIER_POINTER (original_name
)+2, "builtin_", 8) == 0))
10596 /* Plain overloading: will not be grok'd by grokclassfn. */
10597 if (name_mangling_version
< 1
10598 || TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
10599 declarator
= build_decl_overload (dname
, TYPE_ARG_TYPES (type
), 0);
10601 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
10602 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10603 TYPE_ARG_TYPES (type
));
10605 /* Record presence of `static'. */
10606 publicp
= (ctype
!= NULL_TREE
10607 || RIDBIT_SETP (RID_EXTERN
, specbits
)
10608 || !RIDBIT_SETP (RID_STATIC
, specbits
));
10610 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
10611 virtualp
, flags
, quals
, raises
, attrlist
,
10613 publicp
, inlinep
, funcdef_flag
,
10614 template_count
, in_namespace
);
10615 if (decl
== NULL_TREE
)
10618 /* Among other times, could occur from check_explicit_specialization
10619 returning an error_mark_node. */
10620 if (decl
== error_mark_node
)
10621 return error_mark_node
;
10623 if (ctype
== NULL_TREE
&& DECL_LANGUAGE (decl
) != lang_c
10624 && (! DECL_USE_TEMPLATE (decl
) ||
10625 name_mangling_version
< 1))
10626 DECL_ASSEMBLER_NAME (decl
) = declarator
;
10630 int illegal_static
= 0;
10632 /* Don't allow a static member function in a class, and forbid
10633 declaring main to be static. */
10634 if (TREE_CODE (type
) == METHOD_TYPE
)
10636 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
10637 illegal_static
= 1;
10639 else if (current_function_decl
)
10641 /* FIXME need arm citation */
10642 error ("cannot declare static function inside another function");
10643 illegal_static
= 1;
10646 if (illegal_static
)
10649 RIDBIT_RESET (RID_STATIC
, specbits
);
10655 /* It's a variable. */
10657 /* An uninitialized decl with `extern' is a reference. */
10658 decl
= grokvardecl (type
, declarator
, &specbits
,
10659 initialized
, constp
, in_namespace
);
10660 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
10661 inlinep
, friendp
, raises
!= NULL_TREE
);
10665 DECL_CONTEXT (decl
) = ctype
;
10668 cp_pedwarn ("static member `%D' re-declared as static", decl
);
10670 RIDBIT_RESET (RID_STATIC
, specbits
);
10672 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
10674 cp_error ("static member `%D' declared `register'", decl
);
10675 RIDBIT_RESET (RID_REGISTER
, specbits
);
10677 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
10679 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
10681 RIDBIT_RESET (RID_EXTERN
, specbits
);
10686 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10688 error ("`%s' cannot be declared mutable", name
);
10691 /* Record `register' declaration for warnings on &
10692 and in case doing stupid register allocation. */
10694 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10695 DECL_REGISTER (decl
) = 1;
10697 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
10698 DECL_THIS_EXTERN (decl
) = 1;
10700 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10701 DECL_THIS_STATIC (decl
) = 1;
10703 /* Record constancy and volatility. */
10706 TREE_READONLY (decl
) = TREE_CODE (type
) != REFERENCE_TYPE
;
10709 TREE_SIDE_EFFECTS (decl
) = 1;
10710 TREE_THIS_VOLATILE (decl
) = 1;
10717 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
10718 An empty exprlist is a parmlist. An exprlist which
10719 contains only identifiers at the global level
10720 is a parmlist. Otherwise, it is an exprlist. */
10723 parmlist_is_exprlist (exprs
)
10726 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
10729 if (toplevel_bindings_p ())
10731 /* At the global level, if these are all identifiers,
10732 then it is a parmlist. */
10735 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
10737 exprs
= TREE_CHAIN (exprs
);
10744 /* Subroutine of `grokparms'. In a fcn definition, arg types must
10747 C++: also subroutine of `start_function'. */
10750 require_complete_types_for_parms (parms
)
10753 if (processing_template_decl
)
10758 tree type
= TREE_TYPE (parms
);
10759 if (TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
10761 if (DECL_NAME (parms
))
10762 error ("parameter `%s' has incomplete type",
10763 IDENTIFIER_POINTER (DECL_NAME (parms
)));
10765 error ("parameter has incomplete type");
10766 TREE_TYPE (parms
) = error_mark_node
;
10769 /* If the arg types are incomplete in a declaration,
10770 they must include undefined tags.
10771 These tags can never be defined in the scope of the declaration,
10772 so the types can never be completed,
10773 and no call can be compiled successfully. */
10774 /* This is not the right behavior for C++, but not having
10775 it is also probably wrong. */
10778 /* Now warn if is a pointer to an incomplete type. */
10779 while (TREE_CODE (type
) == POINTER_TYPE
10780 || TREE_CODE (type
) == REFERENCE_TYPE
)
10781 type
= TREE_TYPE (type
);
10782 type
= TYPE_MAIN_VARIANT (type
);
10783 if (TYPE_SIZE (type
) == NULL_TREE
)
10785 if (DECL_NAME (parm
) != NULL_TREE
)
10786 warning ("parameter `%s' points to incomplete type",
10787 IDENTIFIER_POINTER (DECL_NAME (parm
)));
10789 warning ("parameter points to incomplete type");
10793 parms
= TREE_CHAIN (parms
);
10797 /* Decode the list of parameter types for a function type.
10798 Given the list of things declared inside the parens,
10799 return a list of types.
10801 The list we receive can have three kinds of elements:
10802 an IDENTIFIER_NODE for names given without types,
10803 a TREE_LIST node for arguments given as typespecs or names with typespecs,
10804 or void_type_node, to mark the end of an argument list
10805 when additional arguments are not permitted (... was not used).
10807 FUNCDEF_FLAG is nonzero for a function definition, 0 for
10808 a mere declaration. A nonempty identifier-list gets an error message
10809 when FUNCDEF_FLAG is zero.
10810 If FUNCDEF_FLAG is 1, then parameter types must be complete.
10811 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
10813 If all elements of the input list contain types,
10814 we return a list of the types.
10815 If all elements contain no type (except perhaps a void_type_node
10816 at the end), we return a null list.
10817 If some have types and some do not, it is an error, and we
10818 return a null list.
10820 Also set last_function_parms to either
10821 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
10822 A list of names is converted to a chain of PARM_DECLs
10823 by store_parm_decls so that ultimately it is always a chain of decls.
10825 Note that in C++, parameters can take default values. These default
10826 values are in the TREE_PURPOSE field of the TREE_LIST. It is
10827 an error to specify default values which are followed by parameters
10828 that have no default values, or an ELLIPSES. For simplicities sake,
10829 only parameters which are specified with their types can take on
10833 grokparms (first_parm
, funcdef_flag
)
10837 tree result
= NULL_TREE
;
10838 tree decls
= NULL_TREE
;
10840 if (first_parm
!= NULL_TREE
10841 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
10843 if (! funcdef_flag
)
10844 pedwarn ("parameter names (without types) in function declaration");
10845 last_function_parms
= first_parm
;
10848 else if (first_parm
!= NULL_TREE
10849 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
10850 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
10851 my_friendly_abort (145);
10854 /* Types were specified. This is a list of declarators
10855 each represented as a TREE_LIST node. */
10856 register tree parm
, chain
;
10857 int any_init
= 0, any_error
= 0;
10859 if (first_parm
!= NULL_TREE
)
10861 tree last_result
= NULL_TREE
;
10862 tree last_decl
= NULL_TREE
;
10864 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
10866 tree type
= NULL_TREE
, list_node
= parm
;
10867 register tree decl
= TREE_VALUE (parm
);
10868 tree init
= TREE_PURPOSE (parm
);
10870 chain
= TREE_CHAIN (parm
);
10871 /* @@ weak defense against parse errors. */
10872 if (TREE_CODE (decl
) != VOID_TYPE
10873 && TREE_CODE (decl
) != TREE_LIST
)
10875 /* Give various messages as the need arises. */
10876 if (TREE_CODE (decl
) == STRING_CST
)
10877 cp_error ("invalid string constant `%E'", decl
);
10878 else if (TREE_CODE (decl
) == INTEGER_CST
)
10879 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
10883 if (TREE_CODE (decl
) != VOID_TYPE
)
10885 decl
= grokdeclarator (TREE_VALUE (decl
),
10886 TREE_PURPOSE (decl
),
10887 PARM
, init
!= NULL_TREE
,
10892 /* Top-level qualifiers on the parameters are
10893 ignored for function types. */
10894 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
10896 if (TREE_CODE (type
) == VOID_TYPE
)
10897 decl
= void_type_node
;
10898 else if (TREE_CODE (type
) == METHOD_TYPE
)
10900 if (DECL_NAME (decl
))
10901 /* Cannot use the decl here because
10902 we don't have DECL_CONTEXT set up yet. */
10903 cp_error ("parameter `%D' invalidly declared method type",
10906 error ("parameter invalidly declared method type");
10907 type
= build_pointer_type (type
);
10908 TREE_TYPE (decl
) = type
;
10910 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10912 if (DECL_NAME (decl
))
10913 cp_error ("parameter `%D' invalidly declared offset type",
10916 error ("parameter invalidly declared offset type");
10917 type
= build_pointer_type (type
);
10918 TREE_TYPE (decl
) = type
;
10920 else if (TREE_CODE (type
) == RECORD_TYPE
10921 && TYPE_LANG_SPECIFIC (type
)
10922 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
10924 abstract_virtuals_error (decl
, type
);
10925 any_error
= 1; /* Seems like a good idea. */
10927 else if (TREE_CODE (type
) == RECORD_TYPE
10928 && TYPE_LANG_SPECIFIC (type
)
10929 && IS_SIGNATURE (type
))
10931 signature_error (decl
, type
);
10932 any_error
= 1; /* Seems like a good idea. */
10934 else if (POINTER_TYPE_P (type
))
10937 while (POINTER_TYPE_P (t
)
10938 || (TREE_CODE (t
) == ARRAY_TYPE
10939 && TYPE_DOMAIN (t
) != NULL_TREE
))
10941 if (TREE_CODE (t
) == ARRAY_TYPE
)
10942 cp_error ("parameter type `%T' includes %s to array of unknown bound",
10944 TYPE_PTR_P (type
) ? "pointer" : "reference");
10948 if (TREE_CODE (decl
) == VOID_TYPE
)
10950 if (result
== NULL_TREE
)
10952 result
= void_list_node
;
10953 last_result
= result
;
10957 TREE_CHAIN (last_result
) = void_list_node
;
10958 last_result
= void_list_node
;
10961 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
10962 error ("`void' in parameter list must be entire list");
10966 /* Since there is a prototype, args are passed in their own types. */
10967 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
10968 #ifdef PROMOTE_PROTOTYPES
10969 if ((TREE_CODE (type
) == INTEGER_TYPE
10970 || TREE_CODE (type
) == ENUMERAL_TYPE
)
10971 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
10972 DECL_ARG_TYPE (decl
) = integer_type_node
;
10979 if (TREE_CODE (init
) == SAVE_EXPR
)
10980 PARM_DECL_EXPR (init
) = 1;
10981 else if (processing_template_decl
)
10983 /* Unparsed default arg from in-class decl. */
10984 else if (TREE_CODE (init
) == DEFAULT_ARG
)
10986 else if (TREE_CODE (init
) == VAR_DECL
10987 || TREE_CODE (init
) == PARM_DECL
)
10989 if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init
)))
10991 /* ``Local variables may not be used in default
10992 argument expressions.'' dpANSI C++ 8.2.6 */
10993 /* If extern int i; within a function is not
10994 considered a local variable, then this code is
10996 cp_error ("local variable `%D' may not be used as a default argument", init
);
10999 else if (TREE_READONLY_DECL_P (init
))
11000 init
= decl_constant_value (init
);
11003 init
= require_instantiated_type (type
, init
, integer_zero_node
);
11004 if (! processing_template_decl
11005 && init
!= error_mark_node
11006 && TREE_CODE (init
) != DEFAULT_ARG
11007 && ! can_convert_arg (type
, TREE_TYPE (init
), init
))
11008 cp_pedwarn ("invalid type `%T' for default argument to `%#D'",
11009 TREE_TYPE (init
), decl
);
11015 if (decls
== NULL_TREE
)
11022 TREE_CHAIN (last_decl
) = decl
;
11025 if (! current_function_decl
&& TREE_PERMANENT (list_node
))
11027 TREE_PURPOSE (list_node
) = init
;
11028 TREE_VALUE (list_node
) = type
;
11029 TREE_CHAIN (list_node
) = NULL_TREE
;
11032 list_node
= saveable_tree_cons (init
, type
, NULL_TREE
);
11033 if (result
== NULL_TREE
)
11035 result
= list_node
;
11036 last_result
= result
;
11040 TREE_CHAIN (last_result
) = list_node
;
11041 last_result
= list_node
;
11045 TREE_CHAIN (last_result
) = NULL_TREE
;
11046 /* If there are no parameters, and the function does not end
11047 with `...', then last_decl will be NULL_TREE. */
11048 if (last_decl
!= NULL_TREE
)
11049 TREE_CHAIN (last_decl
) = NULL_TREE
;
11053 last_function_parms
= decls
;
11055 /* In a fcn definition, arg types must be complete. */
11056 if (funcdef_flag
> 0)
11057 require_complete_types_for_parms (last_function_parms
);
11062 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11063 FUNCTION_TYPE with the newly parsed version of its default argument, which
11064 was previously digested as text. See snarf_defarg et al in lex.c. */
11067 replace_defarg (arg
, init
)
11070 if (! processing_template_decl
11071 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
11072 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11073 TREE_TYPE (init
), TREE_VALUE (arg
));
11074 TREE_PURPOSE (arg
) = init
;
11081 tree t
= FUNCTION_ARG_CHAIN (d
);
11082 if (DECL_CONSTRUCTOR_P (d
)
11083 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d
)))
11084 t
= TREE_CHAIN (t
);
11085 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
11086 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
11087 == DECL_CLASS_CONTEXT (d
))
11088 && (TREE_CHAIN (t
) == NULL_TREE
11089 || TREE_CHAIN (t
) == void_list_node
11090 || TREE_PURPOSE (TREE_CHAIN (t
))))
11095 /* These memoizing functions keep track of special properties which
11096 a class may have. `grok_ctor_properties' notices whether a class
11097 has a constructor of the form X(X&), and also complains
11098 if the class has a constructor of the form X(X).
11099 `grok_op_properties' takes notice of the various forms of
11100 operator= which are defined, as well as what sorts of type conversion
11101 may apply. Both functions take a FUNCTION_DECL as an argument. */
11104 grok_ctor_properties (ctype
, decl
)
11107 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
11108 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
11110 /* When a type has virtual baseclasses, a magical first int argument is
11111 added to any ctor so we can tell if the class has been initialized
11112 yet. This could screw things up in this function, so we deliberately
11113 ignore the leading int if we're in that situation. */
11114 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
11116 my_friendly_assert (parmtypes
11117 && TREE_VALUE (parmtypes
) == integer_type_node
,
11119 parmtypes
= TREE_CHAIN (parmtypes
);
11120 parmtype
= TREE_VALUE (parmtypes
);
11123 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
11124 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
11125 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11126 || TREE_CHAIN (parmtypes
) == void_list_node
11127 || TREE_PURPOSE (TREE_CHAIN (parmtypes
))))
11129 TYPE_HAS_INIT_REF (ctype
) = 1;
11130 if (TYPE_READONLY (TREE_TYPE (parmtype
)))
11131 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
11133 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
11134 && TREE_CHAIN (parmtypes
) != NULL_TREE
11135 && TREE_CHAIN (parmtypes
) == void_list_node
)
11137 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11139 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
11142 else if (TREE_CODE (parmtype
) == VOID_TYPE
11143 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
11144 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
11149 /* An operator with this name can be either unary or binary. */
11155 return (name
== ansi_opname
[(int) INDIRECT_REF
]
11156 || name
== ansi_opname
[(int) ADDR_EXPR
]
11157 || name
== ansi_opname
[(int) NEGATE_EXPR
]
11158 || name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11159 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]
11160 || name
== ansi_opname
[(int) CONVERT_EXPR
]);
11163 /* An operator with this name can only be unary. */
11169 return (name
== ansi_opname
[(int) TRUTH_NOT_EXPR
]
11170 || name
== ansi_opname
[(int) BIT_NOT_EXPR
]
11171 || name
== ansi_opname
[(int) COMPONENT_REF
]
11172 || OPERATOR_TYPENAME_P (name
));
11175 /* Do a little sanity-checking on how they declared their operator. */
11178 grok_op_properties (decl
, virtualp
, friendp
)
11180 int virtualp
, friendp
;
11182 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11183 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11184 tree name
= DECL_NAME (decl
);
11186 if (current_class_type
== NULL_TREE
)
11191 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11192 TYPE_HAS_ASSIGNMENT (current_class_type
) = 1;
11193 else if (name
== ansi_opname
[(int) CALL_EXPR
])
11194 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
11195 else if (name
== ansi_opname
[(int) ARRAY_REF
])
11196 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
11197 else if (name
== ansi_opname
[(int) COMPONENT_REF
]
11198 || name
== ansi_opname
[(int) MEMBER_REF
])
11199 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
11200 else if (name
== ansi_opname
[(int) NEW_EXPR
])
11201 TYPE_GETS_NEW (current_class_type
) |= 1;
11202 else if (name
== ansi_opname
[(int) DELETE_EXPR
])
11203 TYPE_GETS_DELETE (current_class_type
) |= 1;
11204 else if (name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11205 TYPE_GETS_NEW (current_class_type
) |= 2;
11206 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11207 TYPE_GETS_DELETE (current_class_type
) |= 2;
11210 if (name
== ansi_opname
[(int) NEW_EXPR
]
11211 || name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11213 /* When the compiler encounters the definition of A::operator new, it
11214 doesn't look at the class declaration to find out if it's static. */
11216 revert_static_member_fn (&decl
, NULL
, NULL
);
11218 /* Take care of function decl if we had syntax errors. */
11219 if (argtypes
== NULL_TREE
)
11221 = build_function_type (ptr_type_node
,
11222 hash_tree_chain (integer_type_node
,
11225 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11227 else if (name
== ansi_opname
[(int) DELETE_EXPR
]
11228 || name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11231 revert_static_member_fn (&decl
, NULL
, NULL
);
11233 if (argtypes
== NULL_TREE
)
11235 = build_function_type (void_type_node
,
11236 hash_tree_chain (ptr_type_node
,
11240 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11242 if (! friendp
&& name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
11243 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
11244 != void_list_node
))
11245 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type
) = 1;
11250 /* An operator function must either be a non-static member function
11251 or have at least one parameter of a class, a reference to a class,
11252 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11253 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11255 if (OPERATOR_TYPENAME_P (name
)
11256 || name
== ansi_opname
[(int) CALL_EXPR
]
11257 || name
== ansi_opname
[(int) MODIFY_EXPR
]
11258 || name
== ansi_opname
[(int) COMPONENT_REF
]
11259 || name
== ansi_opname
[(int) ARRAY_REF
])
11260 cp_error ("`%D' must be a nonstatic member function", decl
);
11265 if (DECL_STATIC_FUNCTION_P (decl
))
11266 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
11269 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
11271 tree arg
= TREE_VALUE (p
);
11272 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
11273 arg
= TREE_TYPE (arg
);
11275 /* This lets bad template code slip through. */
11276 if (IS_AGGR_TYPE (arg
)
11277 || TREE_CODE (arg
) == ENUMERAL_TYPE
11278 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
11279 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11283 ("`%D' must have an argument of class or enumerated type",
11290 if (name
== ansi_opname
[(int) CALL_EXPR
])
11291 return; /* No restrictions on args. */
11293 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
11295 tree t
= TREE_TYPE (name
);
11296 if (TREE_CODE (t
) == VOID_TYPE
)
11297 pedwarn ("void is not a valid type conversion operator");
11298 else if (! friendp
)
11300 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11303 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11305 if (t
== current_class_type
)
11306 what
= "the same type";
11307 /* Don't force t to be complete here. */
11308 else if (IS_AGGR_TYPE (t
)
11310 && DERIVED_FROM_P (t
, current_class_type
))
11311 what
= "a base class";
11314 warning ("conversion to %s%s will never use a type conversion operator",
11315 ref
? "a reference to " : "", what
);
11319 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11323 if (list_length (argtypes
) != 3 && methodp
)
11325 cp_error ("`%D' must take exactly one argument", decl
);
11328 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
11330 if (copy_assignment_arg_p (parmtype
, virtualp
)
11333 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
11334 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
11335 || TYPE_READONLY (TREE_TYPE (parmtype
)))
11336 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
11339 else if (name
== ansi_opname
[(int) COND_EXPR
])
11342 pedwarn ("ANSI C++ prohibits overloading operator ?:");
11343 if (list_length (argtypes
) != 4)
11344 cp_error ("`%D' must take exactly three arguments", decl
);
11346 else if (ambi_op_p (name
))
11348 if (list_length (argtypes
) == 2)
11350 else if (list_length (argtypes
) == 3)
11352 if ((name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11353 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11354 && ! processing_template_decl
11355 && TREE_VALUE (TREE_CHAIN (argtypes
)) != integer_type_node
)
11358 cp_error ("postfix `%D' must take `int' as its argument",
11362 ("postfix `%D' must take `int' as its second argument",
11369 cp_error ("`%D' must take either zero or one argument", decl
);
11371 cp_error ("`%D' must take either one or two arguments", decl
);
11374 /* More Effective C++ rule 6. */
11376 && (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11377 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]))
11379 tree arg
= TREE_VALUE (argtypes
);
11380 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11381 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11382 arg
= TREE_TYPE (arg
);
11383 arg
= TYPE_MAIN_VARIANT (arg
);
11384 if (list_length (argtypes
) == 2)
11386 if (TREE_CODE (ret
) != REFERENCE_TYPE
11387 || !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11389 cp_warning ("prefix `%D' should return `%T'", decl
,
11390 build_reference_type (arg
));
11394 if (!comptypes (TYPE_MAIN_VARIANT (ret
), arg
, 1))
11395 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
11399 else if (unary_op_p (name
))
11401 if (list_length (argtypes
) != 2)
11404 cp_error ("`%D' must take `void'", decl
);
11406 cp_error ("`%D' must take exactly one argument", decl
);
11409 else /* if (binary_op_p (name)) */
11411 if (list_length (argtypes
) != 3)
11414 cp_error ("`%D' must take exactly one argument", decl
);
11416 cp_error ("`%D' must take exactly two arguments", decl
);
11419 /* More Effective C++ rule 7. */
11421 && (name
== ansi_opname
[TRUTH_ANDIF_EXPR
]
11422 || name
== ansi_opname
[TRUTH_ORIF_EXPR
]
11423 || name
== ansi_opname
[COMPOUND_EXPR
]))
11424 cp_warning ("user-defined `%D' always evaluates both arguments",
11428 /* Effective C++ rule 23. */
11430 && list_length (argtypes
) == 3
11431 && (name
== ansi_opname
[PLUS_EXPR
]
11432 || name
== ansi_opname
[MINUS_EXPR
]
11433 || name
== ansi_opname
[TRUNC_DIV_EXPR
]
11434 || name
== ansi_opname
[MULT_EXPR
])
11435 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11436 cp_warning ("`%D' should return by value", decl
);
11440 for (; argtypes
!= void_list_node
; argtypes
= TREE_CHAIN (argtypes
))
11441 if (TREE_PURPOSE (argtypes
))
11443 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11444 if (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11445 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11448 cp_pedwarn ("`%D' cannot have default arguments", decl
);
11451 cp_error ("`%D' cannot have default arguments", decl
);
11456 /* Get the struct, enum or union (CODE says which) with tag NAME.
11457 Define the tag as a forward-reference if it is not defined.
11459 C++: If a class derivation is given, process it here, and report
11460 an error if multiple derivation declarations are not identical.
11462 If this is a definition, come in through xref_tag and only look in
11463 the current frame for the name (since C++ allows new names in any
11467 xref_tag (code_type_node
, name
, globalize
)
11468 tree code_type_node
;
11472 enum tag_types tag_code
;
11473 enum tree_code code
;
11475 register tree ref
, t
;
11476 struct binding_level
*b
= inner_binding_level
;
11478 tree attributes
= NULL_TREE
;
11480 /* If we are called from the parser, code_type_node will sometimes be a
11481 TREE_LIST. This indicates that the user wrote
11482 "class __attribute__ ((foo)) bar". Extract the attributes so we can
11484 if (TREE_CODE (code_type_node
) == TREE_LIST
)
11486 attributes
= TREE_PURPOSE (code_type_node
);
11487 code_type_node
= TREE_VALUE (code_type_node
);
11490 tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11495 case signature_type
:
11496 code
= RECORD_TYPE
;
11502 code
= ENUMERAL_TYPE
;
11505 my_friendly_abort (18);
11508 /* If a cross reference is requested, look up the type
11509 already defined for this tag and return it. */
11510 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
11513 name
= TYPE_IDENTIFIER (t
);
11517 t
= IDENTIFIER_TYPE_VALUE (name
);
11519 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
11520 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
)
11525 if (t
&& (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
11526 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
))
11528 cp_error ("redeclaration of template type-parameter `%T'", name
);
11529 cp_error_at (" previously declared here `%#D'",
11530 TEMPLATE_TYPE_DECL (t
));
11532 if (t
&& TYPE_CONTEXT (t
) && got_type
)
11535 /* If we know we are defining this tag, only look it up in
11536 this scope and don't try to find it as a type. */
11537 ref
= lookup_tag (code
, name
, b
, 1);
11541 if (current_class_type
11542 && template_class_depth (current_class_type
)
11543 && PROCESSING_REAL_TEMPLATE_DECL_P ())
11544 /* Since GLOBALIZE is non-zero, we are not looking at a
11545 definition of this tag. Since, in addition, we are currently
11546 processing a (member) template declaration of a template
11547 class, we don't want to do any lookup at all; consider:
11554 { template <class V>
11555 friend struct S1; };
11557 Here, the S2::S1 declaration should not be confused with the
11558 outer declaration. In particular, the inner version should
11559 have a template parameter of level 2, not level 1. This
11560 would be particularly important if the member declaration
11563 template <class V = U> friend struct S1;
11565 say, when we should tsubst into `U' when instantiating S2. */
11572 ref
= lookup_tag (code
, name
, b
, 0);
11576 /* Try finding it as a type declaration. If that wins,
11578 ref
= lookup_name (name
, 1);
11580 if (ref
!= NULL_TREE
11581 && processing_template_decl
11582 && DECL_CLASS_TEMPLATE_P (ref
)
11583 && template_class_depth (current_class_type
) == 0)
11584 /* Since GLOBALIZE is true, we're declaring a global
11585 template, so we want this type. */
11586 ref
= DECL_RESULT (ref
);
11588 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
11589 && TREE_CODE (TREE_TYPE (ref
)) == code
)
11590 ref
= TREE_TYPE (ref
);
11597 push_obstacks_nochange ();
11601 /* If no such tag is yet defined, create a forward-reference node
11602 and record it as the "definition".
11603 When a real declaration of this type is found,
11604 the forward-reference will be altered into a real type. */
11606 /* In C++, since these migrate into the global scope, we must
11607 build them on the permanent obstack. */
11609 temp
= allocation_temporary_p ();
11611 end_temporary_allocation ();
11613 if (code
== ENUMERAL_TYPE
)
11615 cp_error ("use of enum `%#D' without previous declaration", name
);
11617 ref
= make_node (ENUMERAL_TYPE
);
11619 /* Give the type a default layout like unsigned int
11620 to avoid crashing if it does not get defined. */
11621 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
11622 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
11623 TREE_UNSIGNED (ref
) = 1;
11624 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
11625 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
11626 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
11628 /* Enable us to recognize when a type is created in class context.
11629 To do nested classes correctly, this should probably be cleared
11630 out when we leave this classes scope. Currently this in only
11631 done in `start_enum'. */
11633 pushtag (name
, ref
, globalize
);
11637 struct binding_level
*old_b
= class_binding_level
;
11639 ref
= make_lang_type (code
);
11641 if (tag_code
== signature_type
)
11643 SET_SIGNATURE (ref
);
11644 /* Since a signature type will be turned into the type
11645 of signature tables, it's not only an interface. */
11646 CLASSTYPE_INTERFACE_ONLY (ref
) = 0;
11647 SET_CLASSTYPE_INTERFACE_KNOWN (ref
);
11648 /* A signature doesn't have a vtable. */
11649 CLASSTYPE_VTABLE_NEEDS_WRITING (ref
) = 0;
11652 #ifdef NONNESTED_CLASSES
11653 /* Class types don't nest the way enums do. */
11654 class_binding_level
= (struct binding_level
*)0;
11656 pushtag (name
, ref
, globalize
);
11657 class_binding_level
= old_b
;
11662 /* If it no longer looks like a nested type, make sure it's
11664 If it is not an IDENTIFIER, this is not a declaration */
11665 if (b
->namespace_p
&& !class_binding_level
11666 && TREE_CODE (name
) == IDENTIFIER_NODE
)
11668 if (IDENTIFIER_NAMESPACE_VALUE (name
) == NULL_TREE
)
11669 SET_IDENTIFIER_NAMESPACE_VALUE (name
, TYPE_NAME (ref
));
11672 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
11673 redeclare_class_template (ref
, current_template_parms
);
11676 /* Until the type is defined, tentatively accept whatever
11677 structure tag the user hands us. */
11678 if (TYPE_SIZE (ref
) == NULL_TREE
11679 && ref
!= current_class_type
11680 /* Have to check this, in case we have contradictory tag info. */
11681 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
11683 if (tag_code
== class_type
)
11684 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
11685 else if (tag_code
== record_type
|| tag_code
== signature_type
)
11686 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
11691 TREE_TYPE (ref
) = attributes
;
11693 if (ref
&& TYPE_P (ref
))
11697 If the identifier resolves to a typedef-name or a template
11698 type-parameter, the elaborated-type-specifier is
11700 if (TYPE_LANG_SPECIFIC (ref
) && TYPE_WAS_ANONYMOUS (ref
))
11701 cp_error ("`%T' is a typedef name", ref
);
11702 else if (TREE_CODE (ref
) == TEMPLATE_TYPE_PARM
)
11703 cp_error ("`%T' is a template type paramter", ref
);
11710 xref_tag_from_type (old
, id
, globalize
)
11714 tree code_type_node
;
11716 if (TREE_CODE (old
) == RECORD_TYPE
)
11717 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
11718 ? class_type_node
: record_type_node
);
11720 code_type_node
= union_type_node
;
11722 if (id
== NULL_TREE
)
11723 id
= TYPE_IDENTIFIER (old
);
11725 return xref_tag (code_type_node
, id
, globalize
);
11729 xref_basetypes (code_type_node
, name
, ref
, binfo
)
11730 tree code_type_node
;
11734 /* In the declaration `A : X, Y, ... Z' we mark all the types
11735 (A, X, Y, ..., Z) so we can check for duplicates. */
11738 enum tag_types tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11740 if (tag_code
== union_type
)
11742 cp_error ("derived union `%T' invalid", ref
);
11746 len
= list_length (binfo
);
11747 push_obstacks (TYPE_OBSTACK (ref
), TYPE_OBSTACK (ref
));
11749 SET_CLASSTYPE_MARKED (ref
);
11750 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
11752 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
11754 /* The base of a derived struct is public by default. */
11756 = (TREE_PURPOSE (binfo
) == access_public_node
11757 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11758 || (tag_code
!= class_type
11759 && (TREE_PURPOSE (binfo
) == access_default_node
11760 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
11762 = (TREE_PURPOSE (binfo
) == access_protected_node
11763 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
11765 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
11766 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
11767 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11768 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
11769 tree basetype
= TREE_VALUE (binfo
);
11772 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
11773 basetype
= TREE_TYPE (basetype
);
11775 || (TREE_CODE (basetype
) != RECORD_TYPE
11776 && TREE_CODE (basetype
) != TYPENAME_TYPE
11777 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
11778 && TREE_CODE (basetype
) != TEMPLATE_TEMPLATE_PARM
))
11780 cp_error ("base type `%T' fails to be a struct or class type",
11781 TREE_VALUE (binfo
));
11785 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
11788 /* This code replaces similar code in layout_basetypes.
11789 We put the complete_type first for implicit `typename'. */
11790 if (TYPE_SIZE (complete_type (basetype
)) == NULL_TREE
11791 && ! (current_template_parms
&& uses_template_parms (basetype
)))
11793 cp_error ("base class `%T' has incomplete type", basetype
);
11799 if (CLASSTYPE_MARKED (basetype
))
11801 if (basetype
== ref
)
11802 cp_error ("recursive type `%T' undefined", basetype
);
11804 cp_error ("duplicate base type `%T' invalid", basetype
);
11808 if (TYPE_FOR_JAVA (basetype
)
11809 && current_lang_stack
== current_lang_base
)
11810 TYPE_FOR_JAVA (ref
) = 1;
11812 /* Note that the BINFO records which describe individual
11813 inheritances are *not* shared in the lattice! They
11814 cannot be shared because a given baseclass may be
11815 inherited with different `accessibility' by different
11816 derived classes. (Each BINFO record describing an
11817 individual inheritance contains flags which say what
11818 the `accessibility' of that particular inheritance is.) */
11820 base_binfo
= make_binfo (integer_zero_node
, basetype
,
11821 TYPE_BINFO_VTABLE (basetype
),
11822 TYPE_BINFO_VIRTUALS (basetype
));
11824 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
11825 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
11826 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
11827 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
11828 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
11830 /* We need to unshare the binfos now so that lookups during class
11831 definition work. */
11832 unshare_base_binfos (base_binfo
);
11834 SET_CLASSTYPE_MARKED (basetype
);
11836 /* We are free to modify these bits because they are meaningless
11837 at top level, and BASETYPE is a top-level type. */
11838 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
11840 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
11841 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
11844 TYPE_GETS_NEW (ref
) |= TYPE_GETS_NEW (basetype
);
11845 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
11850 TREE_VEC_LENGTH (binfos
) = i
;
11852 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
11855 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
11857 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
11858 = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos
, 0)));
11859 if (TYPE_USES_MULTIPLE_INHERITANCE (ref
))
11860 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
11862 /* Unmark all the types. */
11864 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
11865 CLEAR_CLASSTYPE_MARKED (ref
);
11871 /* Begin compiling the definition of an enumeration type.
11872 NAME is its name (or null if anonymous).
11873 Returns the type object, as yet incomplete.
11874 Also records info about it so that build_enumerator
11875 may be used to declare the individual values as they are read. */
11881 register tree enumtype
= NULL_TREE
;
11882 struct binding_level
*b
= inner_binding_level
;
11884 /* We are wasting space here and putting these on the permanent_obstack so
11885 that typeid(local enum) will work correctly. */
11887 if (processing_template_decl
&& current_function_decl
)
11890 end_temporary_allocation ();
11892 /* If this is the real definition for a previous forward reference,
11893 fill in the contents in the same object that used to be the
11894 forward reference. */
11896 if (name
!= NULL_TREE
)
11897 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
11899 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
11900 cp_error ("multiple definition of `%#T'", enumtype
);
11903 enumtype
= make_node (ENUMERAL_TYPE
);
11904 pushtag (name
, enumtype
, 0);
11907 if (current_class_type
)
11908 TREE_ADDRESSABLE (b
->tags
) = 1;
11910 /* We don't copy this value because build_enumerator needs to do it. */
11911 enum_next_value
= integer_zero_node
;
11914 GNU_xref_decl (current_function_decl
, enumtype
);
11918 /* After processing and defining all the values of an enumeration type,
11919 install their decls in the enumeration type and finish it off.
11920 ENUMTYPE is the type object and VALUES a list of name-value pairs.
11921 Returns ENUMTYPE. */
11924 finish_enum (enumtype
)
11927 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
11928 /* Calculate the maximum value of any enumerator in this type. */
11930 tree values
= TYPE_VALUES (enumtype
);
11935 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
11940 /* The TREE_VALUE is a CONST_DECL for this enumeration
11942 decl
= TREE_VALUE (pair
);
11944 /* The DECL_INITIAL will be NULL if we are processing a
11945 template declaration and this enumeration constant had no
11946 explicit initializer. */
11947 value
= DECL_INITIAL (decl
);
11948 if (value
&& !processing_template_decl
)
11950 /* Set the TREE_TYPE for the VALUE as well. That's so
11951 that when we call decl_constant_value we get an
11952 entity of the right type (but with the constant
11953 value). Since we shouldn't ever call
11954 decl_constant_value on a template type, there's no
11955 reason to do that when processing_template_decl.
11956 And, if the expression is something like a
11957 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
11958 wreak havoc on the intended type of the expression.
11960 Of course, there's also no point in trying to compute
11961 minimum or maximum values if we're in a template. */
11962 TREE_TYPE (value
) = enumtype
;
11965 minnode
= maxnode
= value
;
11966 else if (tree_int_cst_lt (maxnode
, value
))
11968 else if (tree_int_cst_lt (value
, minnode
))
11972 if (processing_template_decl
)
11973 /* If this is just a template, leave the CONST_DECL
11974 alone. That way tsubst_copy will find CONST_DECLs for
11975 CONST_DECLs, and not INTEGER_CSTs. */
11978 /* In the list we're building up, we want the enumeration
11979 values, not the CONST_DECLs. */
11980 TREE_VALUE (pair
) = value
;
11984 maxnode
= minnode
= integer_zero_node
;
11986 TYPE_VALUES (enumtype
) = nreverse (values
);
11988 if (processing_template_decl
)
11990 tree scope
= current_scope ();
11991 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
11993 add_tree (build_min (TAG_DEFN
, enumtype
));
11994 resume_temporary_allocation ();
12000 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12001 int lowprec
= min_precision (minnode
, unsignedp
);
12002 int highprec
= min_precision (maxnode
, unsignedp
);
12003 int precision
= MAX (lowprec
, highprec
);
12005 TYPE_SIZE (enumtype
) = NULL_TREE
;
12007 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12009 TYPE_PRECISION (enumtype
) = precision
;
12011 fixup_unsigned_type (enumtype
);
12013 fixup_signed_type (enumtype
);
12015 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
12016 /* Use the width of the narrowest normal C type which is wide enough. */
12017 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
12020 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
12022 TYPE_SIZE (enumtype
) = 0;
12023 layout_type (enumtype
);
12029 /* Fix up all variant types of this enum type. */
12030 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
12031 tem
= TYPE_NEXT_VARIANT (tem
))
12033 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
12034 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
12035 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
12036 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
12037 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
12038 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
12039 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
12040 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
12041 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
12045 /* Finish debugging output for this type. */
12046 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12051 /* Build and install a CONST_DECL for an enumeration constant of the
12052 enumeration type TYPE whose NAME and VALUE (if any) are provided.
12053 Assignment of sequential values by default is handled here. */
12056 build_enumerator (name
, value
, type
)
12064 /* Remove no-op casts from the value. */
12066 STRIP_TYPE_NOPS (value
);
12068 if (! processing_template_decl
)
12070 /* Validate and default VALUE. */
12071 if (value
!= NULL_TREE
)
12073 if (TREE_READONLY_DECL_P (value
))
12074 value
= decl_constant_value (value
);
12076 if (TREE_CODE (value
) == INTEGER_CST
)
12078 value
= default_conversion (value
);
12079 constant_expression_warning (value
);
12083 cp_error ("enumerator value for `%D' not integer constant", name
);
12088 /* Default based on previous value. */
12089 if (value
== NULL_TREE
&& ! processing_template_decl
)
12091 value
= enum_next_value
;
12093 cp_error ("overflow in enumeration values at `%D'", name
);
12096 /* Remove no-op casts from the value. */
12098 STRIP_TYPE_NOPS (value
);
12100 /* To fix MAX_VAL enum consts. (bkoz) */
12101 TREE_TYPE (value
) = integer_type_node
;
12105 /* We always have to copy here; not all INTEGER_CSTs are unshared.
12106 Even in other cases, we will later (in finish_enum) be setting the
12108 if (value
!= NULL_TREE
)
12109 value
= copy_node (value
);
12111 /* C++ associates enums with global, function, or class declarations. */
12113 context
= current_scope ();
12114 if (context
&& context
== current_class_type
)
12115 /* This enum declaration is local to the class. */
12116 decl
= build_lang_field_decl (CONST_DECL
, name
, type
);
12118 /* It's a global enum, or it's local to a function. (Note local to
12119 a function could mean local to a class method. */
12120 decl
= build_decl (CONST_DECL
, name
, type
);
12122 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
12123 DECL_INITIAL (decl
) = value
;
12124 TREE_READONLY (decl
) = 1;
12126 if (context
&& context
== current_class_type
)
12128 pushdecl_class_level (decl
);
12129 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12130 on the TYPE_FIELDS list for `S'. (That's so that you can say
12131 things like `S::i' later.) */
12132 finish_member_declaration (decl
);
12137 GNU_xref_decl (current_function_decl
, decl
);
12140 if (! processing_template_decl
)
12142 /* Set basis for default for next value. */
12143 enum_next_value
= build_binary_op_nodefault (PLUS_EXPR
, value
,
12144 integer_one_node
, PLUS_EXPR
);
12145 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
12148 result
= saveable_tree_cons (name
, decl
, NULL_TREE
);
12153 static int function_depth
;
12155 /* Create the FUNCTION_DECL for a function definition.
12156 DECLSPECS and DECLARATOR are the parts of the declaration;
12157 they describe the function's name and the type it returns,
12158 but twisted together in a fashion that parallels the syntax of C.
12160 This function creates a binding context for the function body
12161 as well as setting up the FUNCTION_DECL in current_function_decl.
12163 Returns 1 on success. If the DECLARATOR is not suitable for a function
12164 (it defines a datum instead), we return 0, which tells
12165 yyparse to report a parse error.
12167 For C++, we must first check whether that datum makes any sense.
12168 For example, "class A local_a(1,2);" means that variable local_a
12169 is an aggregate of type A, which should have a constructor
12170 applied to it with the argument list [1, 2].
12172 @@ There is currently no way to retrieve the storage
12173 @@ allocated to FUNCTION (or all of its parms) if we return
12174 @@ something we had previously. */
12177 start_function (declspecs
, declarator
, attrs
, pre_parsed_p
)
12178 tree declspecs
, declarator
, attrs
;
12182 tree ctype
= NULL_TREE
;
12185 extern int have_extern_spec
;
12186 extern int used_extern_spec
;
12187 int doing_friend
= 0;
12189 /* Sanity check. */
12190 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
12191 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
12193 /* Assume, until we see it does. */
12194 current_function_returns_value
= 0;
12195 current_function_returns_null
= 0;
12196 warn_about_return_type
= 0;
12198 shadowed_labels
= 0;
12199 current_function_assigns_this
= 0;
12200 current_function_just_assigned_this
= 0;
12201 current_function_parms_stored
= 0;
12202 original_result_rtx
= NULL_RTX
;
12203 base_init_expr
= NULL_TREE
;
12204 current_base_init_list
= NULL_TREE
;
12205 current_member_init_list
= NULL_TREE
;
12206 ctor_label
= dtor_label
= NULL_TREE
;
12207 static_labelno
= 0;
12209 clear_temp_name ();
12211 /* This should only be done once on the top most decl. */
12212 if (have_extern_spec
&& !used_extern_spec
)
12214 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
12215 used_extern_spec
= 1;
12220 decl1
= declarator
;
12223 /* What was this testing for, exactly? */
12224 if (! DECL_ARGUMENTS (decl1
)
12225 && !DECL_STATIC_FUNCTION_P (decl1
)
12226 && !DECL_ARTIFICIAL (decl1
)
12227 && DECL_CLASS_SCOPE_P (decl1
)
12228 && TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))
12229 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))))
12231 tree binding
= binding_for_name (DECL_NAME (decl1
),
12232 current_namespace
);
12233 cp_error ("redeclaration of `%#D'", decl1
);
12234 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)))
12235 cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)));
12236 else if (BINDING_VALUE (binding
))
12237 cp_error_at ("previous declaration here", BINDING_VALUE (binding
));
12241 fntype
= TREE_TYPE (decl1
);
12242 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12243 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12245 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
12246 class is in the (lexical) scope of the class in which it is
12248 if (!ctype
&& DECL_FRIEND_P (decl1
))
12250 ctype
= DECL_CLASS_CONTEXT (decl1
);
12252 /* CTYPE could be null here if we're dealing with a template;
12253 for example, `inline friend float foo()' inside a template
12254 will have no CTYPE set. */
12255 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
12261 /* In a fcn definition, arg types must be complete. */
12262 require_complete_types_for_parms (DECL_ARGUMENTS (decl1
));
12264 /* In case some arg types were completed since the declaration was
12265 parsed, fix up the decls. */
12267 tree t
= DECL_ARGUMENTS (decl1
);
12268 for (; t
; t
= TREE_CHAIN (t
))
12269 layout_decl (t
, 0);
12272 last_function_parms
= DECL_ARGUMENTS (decl1
);
12273 last_function_parm_tags
= NULL_TREE
;
12277 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
12278 /* If the declarator is not suitable for a function definition,
12279 cause a syntax error. */
12280 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
12282 fntype
= TREE_TYPE (decl1
);
12284 restype
= TREE_TYPE (fntype
);
12285 if (IS_AGGR_TYPE (restype
) && ! TYPE_PTRMEMFUNC_P (restype
)
12286 && ! CLASSTYPE_GOT_SEMICOLON (restype
))
12288 cp_error ("semicolon missing after declaration of `%#T'", restype
);
12289 shadow_tag (build_expr_list (NULL_TREE
, restype
));
12290 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
12291 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
12292 fntype
= build_function_type (integer_type_node
,
12293 TYPE_ARG_TYPES (fntype
));
12295 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
12297 TYPE_ARG_TYPES (fntype
));
12298 TREE_TYPE (decl1
) = fntype
;
12301 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12302 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12303 else if (DECL_MAIN_P (decl1
))
12305 /* If this doesn't return integer_type, complain. */
12306 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
12308 if (pedantic
|| warn_return_type
)
12309 pedwarn ("return type for `main' changed to `int'");
12310 TREE_TYPE (decl1
) = fntype
= default_function_type
;
12312 warn_about_return_type
= 0;
12316 /* Warn if function was previously implicitly declared
12317 (but not if we warned then). */
12318 if (! warn_implicit
12319 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
12320 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
12322 current_function_decl
= decl1
;
12323 /* Save the parm names or decls from this function's declarator
12324 where store_parm_decls will find them. */
12325 current_function_parms
= last_function_parms
;
12326 current_function_parm_tags
= last_function_parm_tags
;
12328 announce_function (decl1
);
12330 if (! processing_template_decl
)
12332 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype
))) == NULL_TREE
)
12334 cp_error ("return-type `%#T' is an incomplete type",
12335 TREE_TYPE (fntype
));
12337 /* Make it return void instead, but don't change the
12338 type of the DECL_RESULT, in case we have a named return value. */
12341 = build_cplus_method_type (build_type_variant (ctype
,
12342 TREE_READONLY (decl1
),
12343 TREE_SIDE_EFFECTS (decl1
)),
12345 FUNCTION_ARG_CHAIN (decl1
));
12348 = build_function_type (void_type_node
,
12349 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
12350 DECL_RESULT (decl1
)
12351 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype
)));
12352 TREE_READONLY (DECL_RESULT (decl1
)) = TYPE_READONLY (TREE_TYPE (fntype
));
12353 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = TYPE_VOLATILE (TREE_TYPE (fntype
));
12356 if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype
))
12357 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype
)))
12358 abstract_virtuals_error (decl1
, TREE_TYPE (fntype
));
12361 if (warn_about_return_type
)
12362 pedwarn ("return-type defaults to `int'");
12364 /* Effective C++ rule 15. See also c_expand_return. */
12366 && DECL_NAME (decl1
) == ansi_opname
[(int) MODIFY_EXPR
]
12367 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
12368 cp_warning ("`operator=' should return a reference to `*this'");
12370 /* Make the init_value nonzero so pushdecl knows this is not tentative.
12371 error_mark_node is replaced below (in poplevel) with the BLOCK. */
12372 DECL_INITIAL (decl1
) = error_mark_node
;
12374 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
12375 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attributes
);
12378 /* This function exists in static storage.
12379 (This does not mean `static' in the C sense!) */
12380 TREE_STATIC (decl1
) = 1;
12382 /* Set up current_class_type, and enter the scope of the class, if
12385 push_nested_class (ctype
, 1);
12386 else if (DECL_STATIC_FUNCTION_P (decl1
))
12387 push_nested_class (DECL_CONTEXT (decl1
), 2);
12389 /* We must call push_template_decl after current_class_type is set
12390 up. (If we are processing inline definitions after exiting a
12391 class scope, current_class_type will be NULL_TREE until set above
12392 by push_nested_class.) */
12393 if (processing_template_decl
)
12394 decl1
= push_template_decl (decl1
);
12396 /* Record the decl so that the function name is defined.
12397 If we already have a decl for this name, and it is a FUNCTION_DECL,
12398 use the old decl. */
12399 if (!processing_template_decl
&& pre_parsed_p
== 0)
12401 /* A specialization is not used to guide overload resolution. */
12402 if ((flag_guiding_decls
12403 || !DECL_TEMPLATE_SPECIALIZATION (decl1
))
12404 && ! DECL_FUNCTION_MEMBER_P (decl1
))
12405 decl1
= pushdecl (decl1
);
12408 /* We need to set the DECL_CONTEXT. */
12409 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
12410 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
12411 /* And make sure we have enough default args. */
12412 check_default_args (decl1
);
12414 DECL_MAIN_VARIANT (decl1
) = decl1
;
12415 fntype
= TREE_TYPE (decl1
);
12418 current_function_decl
= decl1
;
12420 if (DECL_INTERFACE_KNOWN (decl1
))
12422 tree ctx
= hack_decl_function_context (decl1
);
12424 if (DECL_NOT_REALLY_EXTERN (decl1
))
12425 DECL_EXTERNAL (decl1
) = 0;
12427 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
12428 && TREE_PUBLIC (ctx
))
12429 /* This is a function in a local class in an extern inline
12431 comdat_linkage (decl1
);
12433 /* If this function belongs to an interface, it is public.
12434 If it belongs to someone else's interface, it is also external.
12435 It doesn't matter whether it's inline or not. */
12436 else if (interface_unknown
== 0
12437 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
12438 || flag_alt_external_templates
))
12440 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
12441 || processing_template_decl
)
12442 DECL_EXTERNAL (decl1
)
12444 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
));
12446 DECL_EXTERNAL (decl1
) = 0;
12447 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
12448 DECL_INTERFACE_KNOWN (decl1
) = 1;
12452 /* This is a definition, not a reference.
12453 So clear DECL_EXTERNAL. */
12454 DECL_EXTERNAL (decl1
) = 0;
12456 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
12457 && ! DECL_INTERFACE_KNOWN (decl1
)
12458 /* Don't try to defer nested functions for now. */
12459 && ! hack_decl_function_context (decl1
))
12460 DECL_DEFER_OUTPUT (decl1
) = 1;
12462 DECL_INTERFACE_KNOWN (decl1
) = 1;
12465 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
))
12467 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12468 TREE_TYPE (decl1
) = fntype
12469 = build_function_type (TREE_TYPE (fntype
),
12470 TREE_CHAIN (TYPE_ARG_TYPES (fntype
)));
12471 current_function_parms
= TREE_CHAIN (current_function_parms
);
12472 DECL_ARGUMENTS (decl1
) = current_function_parms
;
12475 restype
= TREE_TYPE (fntype
);
12479 /* If we're compiling a friend function, neither of the variables
12480 current_class_ptr nor current_class_type will have values. */
12481 if (! doing_friend
)
12483 /* We know that this was set up by `grokclassfn'.
12484 We do not wait until `store_parm_decls', since evil
12485 parse errors may never get us to that point. Here
12486 we keep the consistency between `current_class_type'
12487 and `current_class_ptr'. */
12488 tree t
= current_function_parms
;
12490 my_friendly_assert (t
!= NULL_TREE
12491 && TREE_CODE (t
) == PARM_DECL
, 162);
12493 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
12495 int i
= suspend_momentary ();
12497 /* Fool build_indirect_ref. */
12498 current_class_ptr
= NULL_TREE
;
12499 current_class_ref
= build_indirect_ref (t
, NULL_PTR
);
12500 current_class_ptr
= t
;
12501 resume_momentary (i
);
12504 /* We're having a signature pointer here. */
12505 current_class_ref
= current_class_ptr
= t
;
12511 current_class_ptr
= current_class_ref
= NULL_TREE
;
12515 current_binding_level
->parm_flag
= 1;
12517 GNU_xref_function (decl1
, current_function_parms
);
12520 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
12522 make_function_rtl (decl1
);
12524 /* Promote the value to int before returning it. */
12525 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
12526 restype
= type_promotes_to (restype
);
12528 /* If this fcn was already referenced via a block-scope `extern' decl
12529 (or an implicit decl), propagate certain information about the usage. */
12530 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
12531 TREE_ADDRESSABLE (decl1
) = 1;
12533 if (DECL_RESULT (decl1
) == NULL_TREE
)
12535 DECL_RESULT (decl1
)
12536 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
12537 TREE_READONLY (DECL_RESULT (decl1
)) = TYPE_READONLY (restype
);
12538 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = TYPE_VOLATILE (restype
);
12541 /* Allocate further tree nodes temporarily during compilation
12542 of this function only. Tiemann moved up here from bottom of fn. */
12543 /* If this is a nested function, then we must continue to allocate RTL
12544 on the permanent obstack in case we need to inline it later. */
12545 if (! hack_decl_function_context (decl1
))
12546 temporary_allocation ();
12548 if (processing_template_decl
)
12550 ++minimal_parse_mode
;
12551 last_tree
= DECL_SAVED_TREE (decl1
)
12552 = build_nt (EXPR_STMT
, void_zero_node
);
12557 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1
))
12558 && DECL_LANGUAGE (decl1
) == lang_cplusplus
)
12560 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12561 ctor_label
= NULL_TREE
;
12565 dtor_label
= NULL_TREE
;
12566 if (DECL_CONSTRUCTOR_P (decl1
))
12567 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12573 /* Called after store_parm_decls for a function-try-block. We need to update
12574 last_parm_cleanup_insn so that the base initializers for a constructor
12575 are run within this block, not before it. */
12578 expand_start_early_try_stmts ()
12580 expand_start_try_stmts ();
12581 last_parm_cleanup_insn
= get_last_insn ();
12584 /* Store the parameter declarations into the current function declaration.
12585 This is called after parsing the parameter declarations, before
12586 digesting the body of the function.
12588 Also install to binding contour return value identifier, if any. */
12591 store_parm_decls ()
12593 register tree fndecl
= current_function_decl
;
12594 register tree parm
;
12595 int parms_have_cleanups
= 0;
12596 tree cleanups
= NULL_TREE
;
12598 /* This is either a chain of PARM_DECLs (when a prototype is used). */
12599 tree specparms
= current_function_parms
;
12601 /* This is a list of types declared among parms in a prototype. */
12602 tree parmtags
= current_function_parm_tags
;
12604 /* This is a chain of any other decls that came in among the parm
12605 declarations. If a parm is declared with enum {foo, bar} x;
12606 then CONST_DECLs for foo and bar are put here. */
12607 tree nonparms
= NULL_TREE
;
12609 if (toplevel_bindings_p ())
12610 fatal ("parse errors have confused me too much");
12612 /* Initialize RTL machinery. */
12613 init_function_start (fndecl
, input_filename
, lineno
);
12615 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
12616 declare_function_name ();
12618 /* Create a binding level for the parms. */
12619 expand_start_bindings (0);
12621 if (specparms
!= NULL_TREE
)
12623 /* This case is when the function was defined with an ANSI prototype.
12624 The parms already have decls, so we need not do anything here
12625 except record them as in effect
12626 and complain if any redundant old-style parm decls were written. */
12628 register tree next
;
12630 /* Must clear this because it might contain TYPE_DECLs declared
12632 storedecls (NULL_TREE
);
12634 for (parm
= nreverse (specparms
); parm
; parm
= next
)
12636 next
= TREE_CHAIN (parm
);
12637 if (TREE_CODE (parm
) == PARM_DECL
)
12640 if (DECL_NAME (parm
) == NULL_TREE
)
12644 else if (TREE_CODE (TREE_TYPE (parm
)) == VOID_TYPE
)
12645 cp_error ("parameter `%D' declared void", parm
);
12648 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
12649 A parameter is assumed not to have any side effects.
12650 If this should change for any reason, then this
12651 will have to wrap the bashed reference type in a save_expr.
12653 Also, if the parameter type is declared to be an X
12654 and there is an X(X&) constructor, we cannot lay it
12655 into the stack (any more), so we make this parameter
12656 look like it is really of reference type. Functions
12657 which pass parameters to this function will know to
12658 create a temporary in their frame, and pass a reference
12661 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
12662 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))))
12663 SET_DECL_REFERENCE_SLOT (parm
, convert_from_reference (parm
));
12667 if (! processing_template_decl
12668 && (cleanup
= maybe_build_cleanup (parm
), cleanup
))
12670 expand_decl (parm
);
12671 parms_have_cleanups
= 1;
12673 /* Keep track of the cleanups. */
12674 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
12679 /* If we find an enum constant or a type tag,
12680 put it aside for the moment. */
12681 TREE_CHAIN (parm
) = NULL_TREE
;
12682 nonparms
= chainon (nonparms
, parm
);
12686 /* Get the decls in their original chain order
12687 and record in the function. This is all and only the
12688 PARM_DECLs that were pushed into scope by the loop above. */
12689 DECL_ARGUMENTS (fndecl
) = getdecls ();
12691 storetags (chainon (parmtags
, gettags ()));
12694 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
12696 /* Now store the final chain of decls for the arguments
12697 as the decl-chain of the current lexical scope.
12698 Put the enumerators in as well, at the front so that
12699 DECL_ARGUMENTS is not modified. */
12701 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
12703 /* Initialize the RTL code for the function. */
12704 DECL_SAVED_INSNS (fndecl
) = NULL_RTX
;
12705 if (! processing_template_decl
)
12706 expand_function_start (fndecl
, parms_have_cleanups
);
12708 current_function_parms_stored
= 1;
12710 /* If this function is `main', emit a call to `__main'
12711 to run global initializers, etc. */
12712 if (DECL_MAIN_P (fndecl
))
12713 expand_main_function ();
12715 /* Now that we have initialized the parms, we can start their
12716 cleanups. We cannot do this before, since expand_decl_cleanup
12717 should not be called before the parm can be used. */
12719 && ! processing_template_decl
)
12721 for (cleanups
= nreverse (cleanups
); cleanups
; cleanups
= TREE_CHAIN (cleanups
))
12723 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups
), TREE_VALUE (cleanups
)))
12724 cp_error ("parser lost in parsing declaration of `%D'",
12725 TREE_PURPOSE (cleanups
));
12729 /* Create a binding contour which can be used to catch
12730 cleanup-generated temporaries. Also, if the return value needs or
12731 has initialization, deal with that now. */
12732 if (parms_have_cleanups
)
12735 expand_start_bindings (0);
12738 if (! processing_template_decl
&& flag_exceptions
)
12740 /* Do the starting of the exception specifications, if we have any. */
12741 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
12742 expand_start_eh_spec ();
12745 last_parm_cleanup_insn
= get_last_insn ();
12746 last_dtor_insn
= get_last_insn ();
12749 /* Bind a name and initialization to the return value of
12750 the current function. */
12753 store_return_init (return_id
, init
)
12754 tree return_id
, init
;
12756 tree decl
= DECL_RESULT (current_function_decl
);
12759 /* Give this error as many times as there are occurrences,
12760 so that users can use Emacs compilation buffers to find
12761 and fix all such places. */
12762 pedwarn ("ANSI C++ does not permit named return values");
12764 if (return_id
!= NULL_TREE
)
12766 if (DECL_NAME (decl
) == NULL_TREE
)
12768 DECL_NAME (decl
) = return_id
;
12769 DECL_ASSEMBLER_NAME (decl
) = return_id
;
12772 cp_error ("return identifier `%D' already in place", decl
);
12775 /* Can't let this happen for constructors. */
12776 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12778 error ("can't redefine default return value for constructors");
12782 /* If we have a named return value, put that in our scope as well. */
12783 if (DECL_NAME (decl
) != NULL_TREE
)
12785 /* If this named return value comes in a register,
12786 put it in a pseudo-register. */
12787 if (DECL_REGISTER (decl
))
12789 original_result_rtx
= DECL_RTL (decl
);
12790 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
12793 /* Let `cp_finish_decl' know that this initializer is ok. */
12794 DECL_INITIAL (decl
) = init
;
12797 if (minimal_parse_mode
)
12798 add_tree (build_min_nt (RETURN_INIT
, return_id
,
12799 copy_to_permanent (init
)));
12801 cp_finish_decl (decl
, init
, NULL_TREE
, 0, 0);
12806 /* Finish up a function declaration and compile that function
12807 all the way to assembler language output. The free the storage
12808 for the function definition.
12810 This is called after parsing the body of the function definition.
12811 LINENO is the current line number.
12813 C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
12814 (and expand_end_bindings) must be made to take care of the binding
12815 contour for the base initializers. This is only relevant for
12818 NESTED is nonzero if we were in the middle of compiling another function
12819 when we started on this one. */
12822 finish_function (lineno
, call_poplevel
, nested
)
12827 register tree fndecl
= current_function_decl
;
12828 tree fntype
, ctype
= NULL_TREE
;
12829 rtx last_parm_insn
, insns
;
12830 /* Label to use if this function is supposed to return a value. */
12831 tree no_return_label
= NULL_TREE
;
12832 tree decls
= NULL_TREE
;
12834 /* When we get some parse errors, we can end up without a
12835 current_function_decl, so cope. */
12836 if (fndecl
== NULL_TREE
)
12839 if (! nested
&& function_depth
> 1)
12842 fntype
= TREE_TYPE (fndecl
);
12844 /* TREE_READONLY (fndecl) = 1;
12845 This caused &foo to be of type ptr-to-const-function
12846 which then got a warning when stored in a ptr-to-function variable. */
12848 /* This happens on strange parse errors. */
12849 if (! current_function_parms_stored
)
12852 store_parm_decls ();
12855 if (processing_template_decl
)
12857 if (DECL_CONSTRUCTOR_P (fndecl
) && call_poplevel
)
12859 decls
= getdecls ();
12860 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
12861 poplevel (decls
!= NULL_TREE
, 0, 0);
12866 if (write_symbols
!= NO_DEBUG
/*&& TREE_CODE (fntype) != METHOD_TYPE*/)
12868 tree ttype
= target_type (fntype
);
12871 if (IS_AGGR_TYPE (ttype
))
12872 /* Let debugger know it should output info for this type. */
12873 note_debug_info_needed (ttype
);
12875 for (parmdecl
= DECL_ARGUMENTS (fndecl
); parmdecl
; parmdecl
= TREE_CHAIN (parmdecl
))
12877 ttype
= target_type (TREE_TYPE (parmdecl
));
12878 if (IS_AGGR_TYPE (ttype
))
12879 /* Let debugger know it should output info for this type. */
12880 note_debug_info_needed (ttype
);
12884 /* Clean house because we will need to reorder insns here. */
12885 do_pending_stack_adjust ();
12889 tree binfo
= TYPE_BINFO (current_class_type
);
12890 tree cond
= integer_one_node
;
12892 tree in_charge_node
= lookup_name (in_charge_identifier
, 0);
12894 int ok_to_optimize_dtor
= 0;
12895 int empty_dtor
= get_last_insn () == last_dtor_insn
;
12897 if (current_function_assigns_this
)
12898 cond
= build (NE_EXPR
, boolean_type_node
,
12899 current_class_ptr
, integer_zero_node
);
12902 int n_baseclasses
= CLASSTYPE_N_BASECLASSES (current_class_type
);
12904 /* If this destructor is empty, then we don't need to check
12905 whether `this' is NULL in some cases. */
12906 if ((flag_this_is_variable
& 1) == 0)
12907 ok_to_optimize_dtor
= 1;
12908 else if (empty_dtor
)
12909 ok_to_optimize_dtor
12910 = (n_baseclasses
== 0
12911 || (n_baseclasses
== 1
12912 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type
, 0))));
12915 /* These initializations might go inline. Protect
12916 the binding level of the parms. */
12918 expand_start_bindings (0);
12920 if (current_function_assigns_this
)
12922 current_function_assigns_this
= 0;
12923 current_function_just_assigned_this
= 0;
12926 /* Generate the code to call destructor on base class.
12927 If this destructor belongs to a class with virtual
12928 functions, then set the virtual function table
12929 pointer to represent the type of our base class. */
12931 /* This side-effect makes call to `build_delete' generate the
12932 code we have to have at the end of this destructor. */
12933 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
12935 /* These are two cases where we cannot delegate deletion. */
12936 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)
12937 || TYPE_GETS_REG_DELETE (current_class_type
))
12938 exprstmt
= build_delete (current_class_type
, current_class_ref
, integer_zero_node
,
12939 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
12941 exprstmt
= build_delete (current_class_type
, current_class_ref
, in_charge_node
,
12942 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
12944 /* If we did not assign to this, then `this' is non-zero at
12945 the end of a destructor. As a special optimization, don't
12946 emit test if this is an empty destructor. If it does nothing,
12947 it does nothing. If it calls a base destructor, the base
12948 destructor will perform the test. */
12950 if (exprstmt
!= error_mark_node
12951 && (TREE_CODE (exprstmt
) != NOP_EXPR
12952 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
12953 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
12955 expand_label (dtor_label
);
12956 if (cond
!= integer_one_node
)
12957 expand_start_cond (cond
, 0);
12958 if (exprstmt
!= void_zero_node
)
12959 /* Don't call `expand_expr_stmt' if we're not going to do
12960 anything, since -Wall will give a diagnostic. */
12961 expand_expr_stmt (exprstmt
);
12963 /* Run destructor on all virtual baseclasses. */
12964 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
12966 tree vbases
= nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type
)));
12967 expand_start_cond (build (BIT_AND_EXPR
, integer_type_node
,
12968 in_charge_node
, integer_two_node
), 0);
12971 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases
)))
12973 tree vb
= get_vbase
12974 (BINFO_TYPE (vbases
),
12975 TYPE_BINFO (current_class_type
));
12977 (build_scoped_method_call
12978 (current_class_ref
, vb
, dtor_identifier
,
12979 build_expr_list (NULL_TREE
, integer_zero_node
)));
12981 vbases
= TREE_CHAIN (vbases
);
12983 expand_end_cond ();
12986 do_pending_stack_adjust ();
12987 if (cond
!= integer_one_node
)
12988 expand_end_cond ();
12991 TYPE_HAS_DESTRUCTOR (current_class_type
) = 1;
12993 virtual_size
= c_sizeof (current_class_type
);
12995 /* At the end, call delete if that's what's requested. */
12997 /* FDIS sez: At the point of definition of a virtual destructor
12998 (including an implicit definition), non-placement operator
12999 delete shall be looked up in the scope of the destructor's
13000 class and if found shall be accessible and unambiguous.
13002 This is somewhat unclear, but I take it to mean that if the
13003 class only defines placement deletes we don't do anything here.
13004 So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain
13005 for us if they ever try to delete one of these. */
13007 if (TYPE_GETS_REG_DELETE (current_class_type
)
13008 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13009 exprstmt
= build_op_delete_call
13010 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
13011 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
13013 exprstmt
= NULL_TREE
;
13017 cond
= build (BIT_AND_EXPR
, integer_type_node
,
13018 in_charge_node
, integer_one_node
);
13019 expand_start_cond (cond
, 0);
13020 expand_expr_stmt (exprstmt
);
13021 expand_end_cond ();
13024 /* End of destructor. */
13025 expand_end_bindings (NULL_TREE
, getdecls () != NULL_TREE
, 0);
13026 poplevel (2, 0, 0); /* XXX change to 1 */
13028 /* Back to the top of destructor. */
13029 /* Don't execute destructor code if `this' is NULL. */
13033 /* If the dtor is empty, and we know there is not possible way we
13034 could use any vtable entries, before they are possibly set by
13035 a base class dtor, we don't have to setup the vtables, as we
13036 know that any base class dtoring will set up any vtables it
13037 needs. We avoid MI, because one base class dtor can do a
13038 virtual dispatch to an overridden function that would need to
13039 have a non-related vtable set up, we cannot avoid setting up
13040 vtables in that case. We could change this to see if there is
13041 just one vtable. */
13042 if (! empty_dtor
|| TYPE_USES_COMPLEX_INHERITANCE (current_class_type
))
13044 /* Make all virtual function table pointers in non-virtual base
13045 classes point to CURRENT_CLASS_TYPE's virtual function
13047 expand_direct_vtbls_init (binfo
, binfo
, 1, 0, current_class_ptr
);
13049 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13050 expand_indirect_vtbls_init (binfo
, current_class_ref
, current_class_ptr
);
13053 if (! ok_to_optimize_dtor
)
13055 cond
= build_binary_op (NE_EXPR
,
13056 current_class_ptr
, integer_zero_node
, 1);
13057 expand_start_cond (cond
, 0);
13060 insns
= get_insns ();
13063 last_parm_insn
= get_first_nonparm_insn ();
13064 if (last_parm_insn
== NULL_RTX
)
13065 last_parm_insn
= get_last_insn ();
13067 last_parm_insn
= previous_insn (last_parm_insn
);
13069 emit_insns_after (insns
, last_parm_insn
);
13071 if (! ok_to_optimize_dtor
)
13072 expand_end_cond ();
13074 else if (current_function_assigns_this
)
13076 /* Does not need to call emit_base_init, because
13077 that is done (if needed) just after assignment to this
13080 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13082 end_protect_partials ();
13083 expand_label (ctor_label
);
13084 ctor_label
= NULL_TREE
;
13088 decls
= getdecls ();
13089 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13090 poplevel (decls
!= NULL_TREE
, 0, 0);
13092 /* c_expand_return knows to return 'this' from a constructor. */
13093 c_expand_return (NULL_TREE
);
13095 else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl
))) != VOID_TYPE
13096 && return_label
!= NULL_RTX
)
13097 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13099 current_function_assigns_this
= 0;
13100 current_function_just_assigned_this
= 0;
13101 base_init_expr
= NULL_TREE
;
13103 else if (DECL_CONSTRUCTOR_P (fndecl
))
13105 tree cond
= NULL_TREE
, thenclause
= NULL_TREE
;
13106 /* Allow constructor for a type to get a new instance of the object
13107 using `build_new'. */
13108 tree abstract_virtuals
= CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
);
13109 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = NULL_TREE
;
13111 DECL_RETURNS_FIRST_ARG (fndecl
) = 1;
13113 if (flag_this_is_variable
> 0)
13115 cond
= build_binary_op (EQ_EXPR
,
13116 current_class_ptr
, integer_zero_node
, 1);
13117 thenclause
= build_modify_expr (current_class_ptr
, NOP_EXPR
,
13118 build_new (NULL_TREE
, current_class_type
, void_type_node
, 0));
13121 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = abstract_virtuals
;
13125 if (flag_this_is_variable
> 0)
13127 expand_start_cond (cond
, 0);
13128 expand_expr_stmt (thenclause
);
13129 expand_end_cond ();
13132 /* Emit insns from `emit_base_init' which sets up virtual
13133 function table pointer(s). */
13134 if (base_init_expr
)
13136 expand_expr_stmt (base_init_expr
);
13137 base_init_expr
= NULL_TREE
;
13140 insns
= get_insns ();
13143 /* This is where the body of the constructor begins. */
13145 emit_insns_after (insns
, last_parm_cleanup_insn
);
13147 end_protect_partials ();
13149 /* This is where the body of the constructor ends. */
13150 expand_label (ctor_label
);
13151 ctor_label
= NULL_TREE
;
13155 decls
= getdecls ();
13156 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13157 poplevel (decls
!= NULL_TREE
, 1, 0);
13160 /* c_expand_return knows to return 'this' from a constructor. */
13161 c_expand_return (NULL_TREE
);
13163 current_function_assigns_this
= 0;
13164 current_function_just_assigned_this
= 0;
13166 else if (DECL_MAIN_P (fndecl
))
13168 /* Make it so that `main' always returns 0 by default. */
13170 c_expand_return (integer_one_node
);
13172 c_expand_return (integer_zero_node
);
13175 else if (return_label
!= NULL_RTX
13176 && current_function_return_value
== NULL_TREE
13177 && ! DECL_NAME (DECL_RESULT (current_function_decl
)))
13178 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13180 if (flag_exceptions
)
13181 expand_exception_blocks ();
13183 /* If this function is supposed to return a value, ensure that
13184 we do not fall into the cleanups by mistake. The end of our
13185 function will look like this:
13187 user code (may have return stmt somewhere)
13188 goto no_return_label
13193 NOTE_INSN_FUNCTION_END
13197 If the user omits a return stmt in the USER CODE section, we
13198 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13199 Otherwise, we won't. */
13200 if (no_return_label
)
13202 DECL_CONTEXT (no_return_label
) = fndecl
;
13203 DECL_INITIAL (no_return_label
) = error_mark_node
;
13204 DECL_SOURCE_FILE (no_return_label
) = input_filename
;
13205 DECL_SOURCE_LINE (no_return_label
) = lineno
;
13206 expand_goto (no_return_label
);
13211 /* Remove the binding contour which is used
13212 to catch cleanup-generated temporaries. */
13213 expand_end_bindings (0, 0, 0);
13214 poplevel (0, 0, 0);
13216 /* Emit label at beginning of cleanup code for parameters. */
13217 emit_label (cleanup_label
);
13220 /* Get return value into register if that's where it's supposed to be. */
13221 if (original_result_rtx
)
13222 fixup_result_decl (DECL_RESULT (fndecl
), original_result_rtx
);
13224 /* Finish building code that will trigger warnings if users forget
13225 to make their functions return values. */
13226 if (no_return_label
|| cleanup_label
)
13227 emit_jump (return_label
);
13228 if (no_return_label
)
13230 /* We don't need to call `expand_*_return' here because we
13231 don't need any cleanups here--this path of code is only
13232 for error checking purposes. */
13233 expand_label (no_return_label
);
13236 /* Generate rtl for function exit. */
13237 expand_function_end (input_filename
, lineno
, 1);
13240 /* This must come after expand_function_end because cleanups might
13241 have declarations (from inline functions) that need to go into
13242 this function's blocks. */
13243 if (current_binding_level
->parm_flag
!= 1)
13244 my_friendly_abort (122);
13245 poplevel (1, 0, 1);
13247 /* Reset scope for C++: if we were in the scope of a class,
13248 then when we finish this function, we are not longer so.
13249 This cannot be done until we know for sure that no more
13250 class members will ever be referenced in this function
13251 (i.e., calls to destructors). */
13252 if (current_class_name
)
13254 ctype
= current_class_type
;
13255 pop_nested_class (1);
13258 /* Must mark the RESULT_DECL as being in this function. */
13259 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13261 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13262 to the FUNCTION_DECL node itself. */
13263 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13265 if (! processing_template_decl
)
13267 int saved_flag_keep_inline_functions
=
13268 flag_keep_inline_functions
;
13270 /* So we can tell if jump_optimize sets it to 1. */
13273 if (DECL_CONTEXT (fndecl
) != NULL_TREE
13274 && hack_decl_function_context (fndecl
))
13275 /* Trick rest_of_compilation into not deferring output of this
13276 function, even if it is inline, since the rtl_obstack for
13277 this function is the function_obstack of the enclosing
13278 function and will be deallocated when the enclosing
13279 function is gone. See save_tree_status. */
13280 flag_keep_inline_functions
= 1;
13282 /* Run the optimizers and output the assembler code for this
13285 if (DECL_ARTIFICIAL (fndecl
))
13287 /* Do we really *want* to inline this synthesized method? */
13289 int save_fif
= flag_inline_functions
;
13290 flag_inline_functions
= 1;
13292 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13293 will check our size. */
13294 DECL_INLINE (fndecl
) = 0;
13296 rest_of_compilation (fndecl
);
13297 flag_inline_functions
= save_fif
;
13300 rest_of_compilation (fndecl
);
13302 flag_keep_inline_functions
= saved_flag_keep_inline_functions
;
13304 if (DECL_SAVED_INSNS (fndecl
) && ! TREE_ASM_WRITTEN (fndecl
))
13306 /* Set DECL_EXTERNAL so that assemble_external will be called as
13307 necessary. We'll clear it again in finish_file. */
13308 if (! DECL_EXTERNAL (fndecl
))
13309 DECL_NOT_REALLY_EXTERN (fndecl
) = 1;
13310 DECL_EXTERNAL (fndecl
) = 1;
13311 mark_inline_for_output (fndecl
);
13314 if (ctype
&& TREE_ASM_WRITTEN (fndecl
))
13315 note_debug_info_needed (ctype
);
13317 current_function_returns_null
|= can_reach_end
;
13319 /* Since we don't normally go through c_expand_return for constructors,
13320 this normally gets the wrong value.
13321 Also, named return values have their return codes emitted after
13322 NOTE_INSN_FUNCTION_END, confusing jump.c. */
13323 if (DECL_CONSTRUCTOR_P (fndecl
)
13324 || DECL_NAME (DECL_RESULT (fndecl
)) != NULL_TREE
)
13325 current_function_returns_null
= 0;
13327 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
13328 cp_warning ("`noreturn' function `%D' does return", fndecl
);
13329 else if ((warn_return_type
|| pedantic
)
13330 && current_function_returns_null
13331 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
)
13333 /* If this function returns non-void and control can drop through,
13335 cp_warning ("control reaches end of non-void function `%D'", fndecl
);
13337 /* With just -W, complain only if function returns both with
13338 and without a value. */
13339 else if (extra_warnings
13340 && current_function_returns_value
&& current_function_returns_null
)
13341 warning ("this function may return with or without a value");
13346 /* Free all the tree nodes making up this function. */
13347 /* Switch back to allocating nodes permanently
13348 until we start another function. */
13349 if (processing_template_decl
)
13351 --minimal_parse_mode
;
13352 DECL_SAVED_TREE (fndecl
) = TREE_CHAIN (DECL_SAVED_TREE (fndecl
));
13356 permanent_allocation (1);
13358 if (DECL_SAVED_INSNS (fndecl
) == NULL_RTX
)
13362 /* Stop pointing to the local nodes about to be freed. */
13363 /* But DECL_INITIAL must remain nonzero so we know this
13364 was an actual function definition. */
13365 DECL_INITIAL (fndecl
) = error_mark_node
;
13366 for (t
= DECL_ARGUMENTS (fndecl
); t
; t
= TREE_CHAIN (t
))
13367 DECL_RTL (t
) = DECL_INCOMING_RTL (t
) = NULL_RTX
;
13370 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
13371 static_ctors
= perm_tree_cons (NULL_TREE
, fndecl
, static_ctors
);
13372 if (DECL_STATIC_DESTRUCTOR (fndecl
))
13373 static_dtors
= perm_tree_cons (NULL_TREE
, fndecl
, static_dtors
);
13377 /* Let the error reporting routines know that we're outside a
13378 function. For a nested function, this value is used in
13379 pop_cp_function_context and then reset via pop_function_context. */
13380 current_function_decl
= NULL_TREE
;
13383 named_label_uses
= NULL
;
13384 current_class_ptr
= NULL_TREE
;
13385 current_class_ref
= NULL_TREE
;
13388 /* Create the FUNCTION_DECL for a function definition.
13389 LINE1 is the line number that the definition absolutely begins on.
13390 LINE2 is the line number that the name of the function appears on.
13391 DECLSPECS and DECLARATOR are the parts of the declaration;
13392 they describe the return type and the name of the function,
13393 but twisted together in a fashion that parallels the syntax of C.
13395 This function creates a binding context for the function body
13396 as well as setting up the FUNCTION_DECL in current_function_decl.
13398 Returns a FUNCTION_DECL on success.
13400 If the DECLARATOR is not suitable for a function (it defines a datum
13401 instead), we return 0, which tells yyparse to report a parse error.
13403 May return void_type_node indicating that this method is actually
13404 a friend. See grokfield for more details.
13406 Came here with a `.pushlevel' .
13408 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13409 CHANGES TO CODE IN `grokfield'. */
13412 start_method (declspecs
, declarator
)
13413 tree declarator
, declspecs
;
13415 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
13418 /* Something too ugly to handle. */
13419 if (fndecl
== NULL_TREE
)
13422 /* Pass friends other than inline friend functions back. */
13423 if (fndecl
== void_type_node
)
13426 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
13427 /* Not a function, tell parser to report parse error. */
13430 if (IS_SIGNATURE (current_class_type
))
13431 IS_DEFAULT_IMPLEMENTATION (fndecl
) = 1;
13433 if (DECL_IN_AGGR_P (fndecl
))
13435 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
13437 if (DECL_CONTEXT (fndecl
)
13438 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
13439 cp_error ("`%D' is already defined in class %s", fndecl
,
13440 TYPE_NAME_STRING (DECL_CONTEXT (fndecl
)));
13442 return void_type_node
;
13445 DECL_THIS_INLINE (fndecl
) = 1;
13447 if (flag_default_inline
)
13448 DECL_INLINE (fndecl
) = 1;
13450 /* We process method specializations in finish_struct_1. */
13451 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
13452 fndecl
= push_template_decl (fndecl
);
13454 /* We read in the parameters on the maybepermanent_obstack,
13455 but we won't be getting back to them until after we
13456 may have clobbered them. So the call to preserve_data
13457 will keep them safe. */
13460 if (! DECL_FRIEND_P (fndecl
))
13462 if (TREE_CHAIN (fndecl
))
13464 fndecl
= copy_node (fndecl
);
13465 TREE_CHAIN (fndecl
) = NULL_TREE
;
13468 if (DECL_CONSTRUCTOR_P (fndecl
))
13470 if (! grok_ctor_properties (current_class_type
, fndecl
))
13471 return void_type_node
;
13473 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
13474 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
13477 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0, 0);
13479 /* Make a place for the parms */
13481 current_binding_level
->parm_flag
= 1;
13483 DECL_IN_AGGR_P (fndecl
) = 1;
13487 /* Go through the motions of finishing a function definition.
13488 We don't compile this method until after the whole class has
13491 FINISH_METHOD must return something that looks as though it
13492 came from GROKFIELD (since we are defining a method, after all).
13494 This is called after parsing the body of the function definition.
13495 STMTS is the chain of statements that makes up the function body.
13497 DECL is the ..._DECL that `start_method' provided. */
13500 finish_method (decl
)
13503 register tree fndecl
= decl
;
13506 register tree link
;
13508 if (decl
== void_type_node
)
13511 old_initial
= DECL_INITIAL (fndecl
);
13513 /* Undo the level for the parms (from start_method).
13514 This is like poplevel, but it causes nothing to be
13515 saved. Saving information here confuses symbol-table
13516 output routines. Besides, this information will
13517 be correctly output when this method is actually
13520 /* Clear out the meanings of the local variables of this level;
13521 also record in each decl which block it belongs to. */
13523 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
13525 if (DECL_NAME (link
) != NULL_TREE
)
13526 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = 0;
13527 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
13528 DECL_CONTEXT (link
) = NULL_TREE
;
13531 /* Restore all name-meanings of the outer levels
13532 that were shadowed by this level. */
13534 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
13535 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
13536 for (link
= current_binding_level
->class_shadowed
;
13537 link
; link
= TREE_CHAIN (link
))
13538 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
13539 for (link
= current_binding_level
->type_shadowed
;
13540 link
; link
= TREE_CHAIN (link
))
13541 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
13543 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
13544 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
13545 current_binding_level
->parm_flag
,
13546 current_binding_level
->keep
);
13548 poplevel (0, 0, 0);
13550 DECL_INITIAL (fndecl
) = old_initial
;
13552 /* We used to check if the context of FNDECL was different from
13553 current_class_type as another way to get inside here. This didn't work
13554 for String.cc in libg++. */
13555 if (DECL_FRIEND_P (fndecl
))
13557 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
13558 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
13559 decl
= void_type_node
;
13565 /* Called when a new struct TYPE is defined.
13566 If this structure or union completes the type of any previous
13567 variable declaration, lay it out and output its rtl. */
13570 hack_incomplete_structures (type
)
13575 if (current_binding_level
->incomplete
== NULL_TREE
)
13578 if (!type
) /* Don't do this for class templates. */
13581 for (list
= ¤t_binding_level
->incomplete
; *list
; )
13583 tree decl
= TREE_VALUE (*list
);
13584 if ((decl
&& TREE_TYPE (decl
) == type
)
13585 || (TREE_TYPE (decl
)
13586 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13587 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
13589 int toplevel
= toplevel_bindings_p ();
13590 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13591 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
13592 layout_type (TREE_TYPE (decl
));
13593 layout_decl (decl
, 0);
13594 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
13598 expand_decl (decl
);
13599 cleanup
= maybe_build_cleanup (decl
);
13600 expand_decl_init (decl
);
13601 if (! expand_decl_cleanup (decl
, cleanup
))
13602 cp_error ("parser lost in parsing declaration of `%D'",
13605 *list
= TREE_CHAIN (*list
);
13608 list
= &TREE_CHAIN (*list
);
13612 /* If DECL is of a type which needs a cleanup, build that cleanup here.
13613 See build_delete for information about AUTO_DELETE.
13615 Don't build these on the momentary obstack; they must live
13616 the life of the binding contour. */
13619 maybe_build_cleanup_1 (decl
, auto_delete
)
13620 tree decl
, auto_delete
;
13622 tree type
= TREE_TYPE (decl
);
13623 if (TYPE_NEEDS_DESTRUCTOR (type
))
13625 int temp
= 0, flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
13628 if (TREE_CODE (decl
) != PARM_DECL
)
13629 temp
= suspend_momentary ();
13631 if (TREE_CODE (type
) == ARRAY_TYPE
)
13635 mark_addressable (decl
);
13636 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
13639 /* Optimize for space over speed here. */
13640 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
13641 || flag_expensive_optimizations
)
13642 flags
|= LOOKUP_NONVIRTUAL
;
13644 rval
= build_delete (TREE_TYPE (rval
), rval
, auto_delete
, flags
, 0);
13646 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
13647 && ! TYPE_HAS_DESTRUCTOR (type
))
13648 rval
= build_compound_expr (expr_tree_cons (NULL_TREE
, rval
,
13649 build_expr_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
13651 if (TREE_CODE (decl
) != PARM_DECL
)
13652 resume_momentary (temp
);
13659 /* If DECL is of a type which needs a cleanup, build that cleanup
13660 here. The cleanup does free the storage with a call to delete. */
13663 maybe_build_cleanup_and_delete (decl
)
13666 return maybe_build_cleanup_1 (decl
, integer_three_node
);
13669 /* If DECL is of a type which needs a cleanup, build that cleanup
13670 here. The cleanup does not free the storage with a call a delete. */
13673 maybe_build_cleanup (decl
)
13676 return maybe_build_cleanup_1 (decl
, integer_two_node
);
13679 /* Expand a C++ expression at the statement level.
13680 This is needed to ferret out nodes which have UNKNOWN_TYPE.
13681 The C++ type checker should get all of these out when
13682 expressions are combined with other, type-providing, expressions,
13683 leaving only orphan expressions, such as:
13685 &class::bar; / / takes its address, but does nothing with it. */
13688 cplus_expand_expr_stmt (exp
)
13691 if (processing_template_decl
)
13693 add_tree (build_min_nt (EXPR_STMT
, exp
));
13697 /* Arrange for all temps to disappear. */
13698 expand_start_target_temps ();
13700 if (TREE_TYPE (exp
) == unknown_type_node
)
13702 if (TREE_CODE (exp
) == ADDR_EXPR
|| TREE_CODE (exp
) == TREE_LIST
)
13703 error ("address of overloaded function with no contextual type information");
13704 else if (TREE_CODE (exp
) == COMPONENT_REF
)
13705 warning ("useless reference to a member function name, did you forget the ()?");
13709 if (TREE_CODE (exp
) == FUNCTION_DECL
)
13711 cp_warning ("reference, not call, to function `%D'", exp
);
13712 warning ("at this point in file");
13716 /* We should do this eventually, but right now this causes regex.o from
13717 libg++ to miscompile, and tString to core dump. */
13718 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
13721 /* Strip unused implicit INDIRECT_REFs of references. */
13722 if (TREE_CODE (exp
) == INDIRECT_REF
13723 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
13724 exp
= TREE_OPERAND (exp
, 0);
13726 /* If we don't do this, we end up down inside expand_expr
13727 trying to do TYPE_MODE on the ERROR_MARK, and really
13728 go outside the bounds of the type. */
13729 if (exp
!= error_mark_node
)
13730 expand_expr_stmt (break_out_cleanups (exp
));
13733 /* Clean up any pending cleanups. This happens when a function call
13734 returns a cleanup-needing value that nobody uses. */
13735 expand_end_target_temps ();
13738 /* When a stmt has been parsed, this function is called.
13740 Currently, this function only does something within a
13741 constructor's scope: if a stmt has just assigned to this,
13742 and we are in a derived class, we call `emit_base_init'. */
13747 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
13750 if (current_function_assigns_this
13751 || ! current_function_just_assigned_this
)
13753 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13755 /* Constructors must wait until we are out of control
13756 zones before calling base constructors. */
13757 if (cond_stack
|| loop_stack
|| case_stack
)
13759 expand_expr_stmt (base_init_expr
);
13760 check_base_init (current_class_type
);
13762 current_function_assigns_this
= 1;
13765 /* Change a static member function definition into a FUNCTION_TYPE, instead
13766 of the METHOD_TYPE that we create when it's originally parsed.
13768 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
13769 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
13770 other decls. Either pass the addresses of local variables or NULL. */
13773 revert_static_member_fn (decl
, fn
, argtypes
)
13774 tree
*decl
, *fn
, *argtypes
;
13777 tree function
= fn
? *fn
: TREE_TYPE (*decl
);
13778 tree args
= argtypes
? *argtypes
: TYPE_ARG_TYPES (function
);
13780 if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (args
))))
13781 cp_error ("static member function `%#D' declared const", *decl
);
13782 if (TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (args
))))
13783 cp_error ("static member function `%#D' declared volatile", *decl
);
13785 args
= TREE_CHAIN (args
);
13786 tmp
= build_function_type (TREE_TYPE (function
), args
);
13787 tmp
= build_type_variant (tmp
, TYPE_READONLY (function
),
13788 TYPE_VOLATILE (function
));
13789 tmp
= build_exception_variant (tmp
,
13790 TYPE_RAISES_EXCEPTIONS (function
));
13791 TREE_TYPE (*decl
) = tmp
;
13792 if (DECL_ARGUMENTS (*decl
))
13793 DECL_ARGUMENTS (*decl
) = TREE_CHAIN (DECL_ARGUMENTS (*decl
));
13794 DECL_STATIC_FUNCTION_P (*decl
) = 1;
13802 id_in_current_class (id
)
13805 return !!purpose_member (id
, class_binding_level
->class_shadowed
);
13812 int warn_about_return_type
;
13814 int just_assigned_this
;
13816 int temp_name_counter
;
13818 tree shadowed_labels
;
13821 rtx last_dtor_insn
;
13822 rtx last_parm_cleanup_insn
;
13823 tree base_init_list
;
13824 tree member_init_list
;
13825 tree base_init_expr
;
13826 tree current_class_ptr
;
13827 tree current_class_ref
;
13829 struct cp_function
*next
;
13830 struct binding_level
*binding_level
;
13831 int static_labelno
;
13834 static struct cp_function
*cp_function_chain
;
13836 extern int temp_name_counter
;
13838 /* Save and reinitialize the variables
13839 used during compilation of a C++ function. */
13842 push_cp_function_context (context
)
13845 struct cp_function
*p
13846 = (struct cp_function
*) xmalloc (sizeof (struct cp_function
));
13848 push_function_context_to (context
);
13850 p
->next
= cp_function_chain
;
13851 cp_function_chain
= p
;
13853 p
->named_labels
= named_labels
;
13854 p
->shadowed_labels
= shadowed_labels
;
13855 p
->returns_value
= current_function_returns_value
;
13856 p
->returns_null
= current_function_returns_null
;
13857 p
->warn_about_return_type
= warn_about_return_type
;
13858 p
->binding_level
= current_binding_level
;
13859 p
->ctor_label
= ctor_label
;
13860 p
->dtor_label
= dtor_label
;
13861 p
->last_dtor_insn
= last_dtor_insn
;
13862 p
->last_parm_cleanup_insn
= last_parm_cleanup_insn
;
13863 p
->assigns_this
= current_function_assigns_this
;
13864 p
->just_assigned_this
= current_function_just_assigned_this
;
13865 p
->parms_stored
= current_function_parms_stored
;
13866 p
->result_rtx
= original_result_rtx
;
13867 p
->base_init_expr
= base_init_expr
;
13868 p
->temp_name_counter
= temp_name_counter
;
13869 p
->base_init_list
= current_base_init_list
;
13870 p
->member_init_list
= current_member_init_list
;
13871 p
->current_class_ptr
= current_class_ptr
;
13872 p
->current_class_ref
= current_class_ref
;
13873 p
->static_labelno
= static_labelno
;
13876 /* Restore the variables used during compilation of a C++ function. */
13879 pop_cp_function_context (context
)
13882 struct cp_function
*p
= cp_function_chain
;
13885 /* Bring back all the labels that were shadowed. */
13886 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
13887 if (DECL_NAME (TREE_VALUE (link
)) != 0)
13888 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)),
13889 TREE_VALUE (link
));
13891 pop_function_context_from (context
);
13893 cp_function_chain
= p
->next
;
13895 named_labels
= p
->named_labels
;
13896 shadowed_labels
= p
->shadowed_labels
;
13897 current_function_returns_value
= p
->returns_value
;
13898 current_function_returns_null
= p
->returns_null
;
13899 warn_about_return_type
= p
->warn_about_return_type
;
13900 current_binding_level
= p
->binding_level
;
13901 ctor_label
= p
->ctor_label
;
13902 dtor_label
= p
->dtor_label
;
13903 last_dtor_insn
= p
->last_dtor_insn
;
13904 last_parm_cleanup_insn
= p
->last_parm_cleanup_insn
;
13905 current_function_assigns_this
= p
->assigns_this
;
13906 current_function_just_assigned_this
= p
->just_assigned_this
;
13907 current_function_parms_stored
= p
->parms_stored
;
13908 original_result_rtx
= p
->result_rtx
;
13909 base_init_expr
= p
->base_init_expr
;
13910 temp_name_counter
= p
->temp_name_counter
;
13911 current_base_init_list
= p
->base_init_list
;
13912 current_member_init_list
= p
->member_init_list
;
13913 current_class_ptr
= p
->current_class_ptr
;
13914 current_class_ref
= p
->current_class_ref
;
13915 static_labelno
= p
->static_labelno
;
13923 return function_depth
!= 0;