1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92-98, 1999 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Process declarations and symbol lookup for C front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
27 /* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
48 #define obstack_chunk_alloc xmalloc
49 #define obstack_chunk_free free
51 extern struct obstack permanent_obstack
;
52 extern struct obstack
* saveable_obstack
;
54 extern int current_class_depth
;
56 extern tree static_ctors
, static_dtors
;
58 extern tree global_namespace
;
60 extern int (*valid_lang_attribute
) PROTO ((tree
, tree
, tree
, tree
));
62 /* Use garbage collection. */
66 #ifndef WCHAR_UNSIGNED
67 #define WCHAR_UNSIGNED 0
70 #ifndef CHAR_TYPE_SIZE
71 #define CHAR_TYPE_SIZE BITS_PER_UNIT
74 #ifndef BOOL_TYPE_SIZE
75 #ifdef SLOW_BYTE_ACCESS
76 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
78 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
82 /* We let tm.h override the types used here, to handle trivial differences
83 such as the choice of unsigned int or long unsigned int for size_t.
84 When machines start needing nontrivial differences in the size type,
85 it would be best to do something here to figure out automatically
86 from other information what type to use. */
89 #define SIZE_TYPE "long unsigned int"
93 #define PTRDIFF_TYPE "long int"
97 #define WCHAR_TYPE "int"
100 static tree grokparms
PROTO((tree
, int));
101 static const char *redeclaration_error_message
PROTO((tree
, tree
));
103 static void push_binding_level
PROTO((struct binding_level
*, int,
105 static void pop_binding_level
PROTO((void));
106 static void suspend_binding_level
PROTO((void));
107 static void resume_binding_level
PROTO((struct binding_level
*));
108 static struct binding_level
*make_binding_level
PROTO((void));
109 static void declare_namespace_level
PROTO((void));
110 static void signal_catch
PROTO((int)) ATTRIBUTE_NORETURN
;
111 static void storedecls
PROTO((tree
));
112 static void require_complete_types_for_parms
PROTO((tree
));
113 static void push_overloaded_decl_1
PROTO((tree
));
114 static int ambi_op_p
PROTO((tree
));
115 static int unary_op_p
PROTO((tree
));
116 static tree store_bindings
PROTO((tree
, tree
));
117 static tree lookup_tag_reverse
PROTO((tree
, tree
));
118 static tree obscure_complex_init
PROTO((tree
, tree
));
119 static tree maybe_build_cleanup_1
PROTO((tree
, tree
));
120 static tree lookup_name_real
PROTO((tree
, int, int, int));
121 static void warn_extern_redeclared_static
PROTO((tree
, tree
));
122 static void grok_reference_init
PROTO((tree
, tree
, tree
));
123 static tree grokfndecl
PROTO((tree
, tree
, tree
, tree
, int,
124 enum overload_flags
, tree
,
125 tree
, int, int, int, int, int, int, tree
));
126 static tree grokvardecl
PROTO((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
127 static tree lookup_tag
PROTO((enum tree_code
, tree
,
128 struct binding_level
*, int));
129 static void set_identifier_type_value_with_scope
130 PROTO((tree
, tree
, struct binding_level
*));
131 static void record_builtin_type
PROTO((enum rid
, const char *, tree
));
132 static void record_unknown_type
PROTO((tree
, const char *));
133 static int member_function_or_else
PROTO((tree
, tree
, const char *));
134 static void bad_specifiers
PROTO((tree
, const char *, int, int, int, int,
136 static void lang_print_error_function
PROTO((const char *));
137 static tree maybe_process_template_type_declaration
PROTO((tree
, int, struct binding_level
*));
138 static void check_for_uninitialized_const_var
PROTO((tree
));
139 static unsigned long typename_hash
PROTO((hash_table_key
));
140 static boolean typename_compare
PROTO((hash_table_key
, hash_table_key
));
141 static void push_binding
PROTO((tree
, tree
, struct binding_level
*));
142 static int add_binding
PROTO((tree
, tree
));
143 static void pop_binding
PROTO((tree
, tree
));
144 static tree local_variable_p
PROTO((tree
*, int *, void *));
145 static tree find_binding
PROTO((tree
, tree
));
146 static tree select_decl
PROTO((tree
, int));
147 static int lookup_flags
PROTO((int, int));
148 static tree qualify_lookup
PROTO((tree
, int));
149 static tree record_builtin_java_type
PROTO((const char *, int));
150 static const char *tag_name
PROTO((enum tag_types code
));
151 static void find_class_binding_level
PROTO((void));
152 static struct binding_level
*innermost_nonclass_level
PROTO((void));
153 static void warn_about_implicit_typename_lookup
PROTO((tree
, tree
));
154 static int walk_namespaces_r
PROTO((tree
, walk_namespaces_fn
, void *));
155 static int walk_globals_r
PROTO((tree
, void *));
156 static void add_decl_to_level
PROTO((tree
, struct binding_level
*));
157 static tree make_label_decl
PROTO((tree
, int));
158 static void pop_label
PROTO((tree
));
159 static void pop_labels
PROTO((tree
));
160 static void maybe_deduce_size_from_array_init
PROTO((tree
, tree
));
161 static void layout_var_decl
PROTO((tree
));
162 static void maybe_commonize_var
PROTO((tree
));
163 static tree check_initializer
PROTO((tree
, tree
));
164 static void make_rtl_for_nonlocal_decl
PROTO((tree
, tree
, const char *));
165 static void push_cp_function_context
PROTO((struct function
*));
166 static void pop_cp_function_context
PROTO((struct function
*));
167 static void mark_binding_level
PROTO((void *));
168 static void mark_cp_function_context
PROTO((struct function
*));
169 static void mark_saved_scope
PROTO((void *));
170 static void mark_lang_function
PROTO((struct language_function
*));
171 static void mark_stmt_tree
PROTO((struct stmt_tree
*));
172 static void save_function_data
PROTO((tree
));
173 static void check_function_type
PROTO((tree
));
174 static void destroy_local_static
PROTO((tree
));
175 static void destroy_local_var
PROTO((tree
));
176 static void finish_constructor_body
PROTO((void));
177 static void finish_destructor_body
PROTO((void));
178 static tree create_array_type_for_decl
PROTO((tree
, tree
, tree
));
180 #if defined (DEBUG_CP_BINDING_LEVELS)
181 static void indent
PROTO((void));
184 /* Erroneous argument lists can use this *IFF* they do not modify it. */
185 tree error_mark_list
;
187 /* The following symbols are subsumed in the cp_global_trees array, and
188 listed here individually for documentation purposes.
191 tree wchar_decl_node;
194 tree vtable_entry_type;
195 tree delta_type_node;
198 tree __baselist_desc_type_node;
199 tree __i_desc_type_node, __m_desc_type_node;
200 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
202 tree __t_desc_type_node;
204 tree __tp_desc_type_node;
206 tree __access_mode_type_node;
207 tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
208 tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
209 tree __ptmf_desc_type_node, __ptmd_desc_type_node;
211 Not needed yet? May be needed one day?
212 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
213 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
214 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
217 tree class_star_type_node;
218 tree class_type_node, record_type_node, union_type_node, enum_type_node;
219 tree unknown_type_node;
221 Array type `vtable_entry_type[]'
224 tree vtbl_ptr_type_node;
230 A FUNCTION_DECL which can call `abort'. Not necessarily the
231 one that the user will declare, but sufficient to be called
232 by routines that want to abort the program.
236 The FUNCTION_DECL for the default `::operator delete'.
238 tree global_delete_fndecl;
241 tree type_info_type_node, tinfo_fn_id, tinfo_fn_type;
245 tree cp_global_trees
[CPTI_MAX
];
247 /* Indicates that there is a type value in some namespace, although
248 that is not necessarily in scope at the moment. */
250 static tree global_type_node
;
255 /* Expect only namespace names now. */
256 static int only_namespace_names
;
258 /* If original DECL_RESULT of current function was a register,
259 but due to being an addressable named return value, would up
260 on the stack, this variable holds the named return value's
261 original location. */
263 #define original_result_rtx cp_function_chain->x_result_rtx
265 struct named_label_list
267 struct binding_level
*binding_level
;
270 const char *filename_o_goto
;
272 struct named_label_list
*next
;
275 /* Used only for jumps to as-yet undefined labels, since jumps to
276 defined labels can have their validity checked by stmt.c. */
278 #define named_label_uses cp_function_chain->x_named_label_uses
280 /* A list of objects which have constructors or destructors
281 which reside in the global scope. The decl is stored in
282 the TREE_VALUE slot and the initializer is stored
283 in the TREE_PURPOSE slot. */
284 tree static_aggregates
;
288 /* A node for the integer constants 2, and 3. */
290 tree integer_two_node
, integer_three_node
;
292 /* Parsing a function declarator leaves here a chain of structure
293 and enum types declared in the parmlist. */
295 static tree last_function_parm_tags
;
297 /* Similar, for last_function_parm_tags. */
298 tree last_function_parms
;
299 static tree current_function_parm_tags
;
301 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
302 that have names. Here so we can clear out their names' definitions
303 at the end of the function. The TREE_VALUE is a LABEL_DECL; the
304 TREE_PURPOSE is the previous binding of the label. */
306 #define named_labels cp_function_chain->x_named_labels
308 /* The FUNCTION_DECL for the function currently being compiled,
309 or 0 if between functions. */
310 tree current_function_decl
;
312 /* Set to 0 at beginning of a function definition, and whenever
313 a label (case or named) is defined. Set to value of expression
314 returned from function when that value can be transformed into
315 a named return value. */
317 tree current_function_return_value
;
319 /* Nonzero means give `double' the same size as `float'. */
321 extern int flag_short_double
;
323 /* Nonzero means don't recognize any builtin functions. */
325 extern int flag_no_builtin
;
327 /* Nonzero means don't recognize the non-ANSI builtin functions.
330 extern int flag_no_nonansi_builtin
;
332 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
334 extern int flag_huge_objects
;
336 /* Nonzero if we want to conserve space in the .o files. We do this
337 by putting uninitialized data and runtime initialized data into
338 .common instead of .data at the expense of not flagging multiple
340 extern int flag_conserve_space
;
342 /* C and C++ flags are in decl2.c. */
344 /* Flag used when debugging spew.c */
346 extern int spew_debug
;
348 /* A expression of value 0 with the same precision as a sizetype
350 tree signed_size_zero_node
;
352 /* The name of the anonymous namespace, throughout this translation
354 tree anonymous_namespace_name
;
357 /* For each binding contour we allocate a binding_level structure
358 which records the names defined in that contour.
361 1) one for each function definition,
362 where internal declarations of the parameters appear.
363 2) one for each compound statement,
364 to record its declarations.
366 The current meaning of a name can be found by searching the levels
367 from the current one out to the global one.
369 Off to the side, may be the class_binding_level. This exists only
370 to catch class-local declarations. It is otherwise nonexistent.
372 Also there may be binding levels that catch cleanups that must be
373 run when exceptions occur. Thus, to see whether a name is bound in
374 the current scope, it is not enough to look in the
375 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
378 /* Note that the information in the `names' component of the global contour
379 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
383 /* A chain of _DECL nodes for all variables, constants, functions,
384 and typedef types. These are in the reverse of the order
385 supplied. There may be OVERLOADs on this list, too, but they
386 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
389 /* A list of structure, union and enum definitions, for looking up
391 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
392 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
393 or ENUMERAL_TYPE node.
395 C++: the TREE_VALUE nodes can be simple types for
396 component_bindings. */
399 /* A list of USING_DECL nodes. */
402 /* A list of used namespaces. PURPOSE is the namespace,
403 VALUE the common ancestor with this binding_level's namespace. */
404 tree using_directives
;
406 /* If this binding level is the binding level for a class, then
407 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
408 is the name of an entity bound in the class; the TREE_VALUE is
409 the IDENTIFIER_CLASS_VALUE before we entered the class. Thus,
410 when leaving class scope, we can restore the
411 IDENTIFIER_CLASS_VALUE by walking this list. The TREE_TYPE is
412 the DECL bound by this name in the class. */
415 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
416 is used for all binding levels. */
419 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
420 label in this scope. The TREE_PURPOSE is the previous value of
421 the IDENTIFIER_LABEL VALUE. */
422 tree shadowed_labels
;
424 /* For each level (except not the global one),
425 a chain of BLOCK nodes for all the levels
426 that were entered and exited one level down. */
429 /* The BLOCK node for this level, if one has been preallocated.
430 If 0, the BLOCK is allocated (if needed) when the level is popped. */
433 /* The binding level which this one is contained in (inherits from). */
434 struct binding_level
*level_chain
;
436 /* List of decls in `names' that have incomplete
437 structure or union types. */
440 /* List of VAR_DECLS saved from a previous for statement.
441 These would be dead in ANSI-conforming code, but might
442 be referenced in ARM-era code. These are stored in a
443 TREE_LIST; the TREE_VALUE is the actual declaration. */
444 tree dead_vars_from_for
;
446 /* 1 for the level that holds the parameters of a function.
447 2 for the level that holds a class declaration.
448 3 for levels that hold parameter declarations. */
449 unsigned parm_flag
: 4;
451 /* 1 means make a BLOCK for this level regardless of all else.
452 2 for temporary binding contours created by the compiler. */
455 /* Nonzero if this level "doesn't exist" for tags. */
456 unsigned tag_transparent
: 1;
458 /* Nonzero if this level can safely have additional
459 cleanup-needing variables added to it. */
460 unsigned more_cleanups_ok
: 1;
461 unsigned have_cleanups
: 1;
463 /* Nonzero if this level is for storing the decls for template
464 parameters and generic decls; these decls will be discarded and
465 replaced with a TEMPLATE_DECL. */
466 unsigned pseudo_global
: 1;
468 /* This is set for a namespace binding level. */
469 unsigned namespace_p
: 1;
471 /* True if this level is that of a for-statement where we need to
472 worry about ambiguous (ARM or ANSI) scope rules. */
473 unsigned is_for_scope
: 1;
475 /* True if this level corresponds to an EH region, as for a try block. */
476 unsigned eh_region
: 1;
478 /* One bit left for this word. */
480 #if defined(DEBUG_CP_BINDING_LEVELS)
481 /* Binding depth at which this level began. */
482 unsigned binding_depth
;
483 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
486 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
488 /* The binding level currently in effect. */
490 #define current_binding_level \
492 ? cp_function_chain->bindings \
493 : scope_chain->bindings)
495 /* The binding level of the current class, if any. */
497 #define class_binding_level scope_chain->class_bindings
499 /* A chain of binding_level structures awaiting reuse. */
501 static struct binding_level
*free_binding_level
;
503 /* The outermost binding level, for names of file scope.
504 This is created when the compiler is started and exists
505 through the entire run. */
507 static struct binding_level
*global_binding_level
;
509 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
511 static int keep_next_level_flag
;
513 #if defined(DEBUG_CP_BINDING_LEVELS)
514 static int binding_depth
= 0;
515 static int is_class_level
= 0;
522 for (i
= 0; i
< binding_depth
*2; i
++)
525 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
527 static tree pushdecl_with_scope
PROTO((tree
, struct binding_level
*));
530 push_binding_level (newlevel
, tag_transparent
, keep
)
531 struct binding_level
*newlevel
;
532 int tag_transparent
, keep
;
534 /* Add this level to the front of the chain (stack) of levels that
536 bzero ((char*) newlevel
, sizeof (struct binding_level
));
537 newlevel
->level_chain
= current_binding_level
;
538 current_binding_level
= newlevel
;
539 newlevel
->tag_transparent
= tag_transparent
;
540 newlevel
->more_cleanups_ok
= 1;
542 /* We are called before expand_start_bindings, but after
543 expand_eh_region_start for a try block; so we check this now,
544 before the EH block is covered up. */
545 newlevel
->eh_region
= is_eh_region ();
547 newlevel
->keep
= keep
;
548 #if defined(DEBUG_CP_BINDING_LEVELS)
549 newlevel
->binding_depth
= binding_depth
;
551 fprintf (stderr
, "push %s level 0x%08x line %d\n",
552 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
555 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
558 /* Find the innermost enclosing class scope, and reset
559 CLASS_BINDING_LEVEL appropriately. */
562 find_class_binding_level ()
564 struct binding_level
*level
= current_binding_level
;
566 while (level
&& level
->parm_flag
!= 2)
567 level
= level
->level_chain
;
568 if (level
&& level
->parm_flag
== 2)
569 class_binding_level
= level
;
571 class_binding_level
= 0;
577 if (global_binding_level
)
579 /* Cannot pop a level, if there are none left to pop. */
580 if (current_binding_level
== global_binding_level
)
581 my_friendly_abort (123);
583 /* Pop the current level, and free the structure for reuse. */
584 #if defined(DEBUG_CP_BINDING_LEVELS)
587 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
588 (is_class_level
) ? "class" : "block",
589 current_binding_level
, lineno
);
590 if (is_class_level
!= (current_binding_level
== class_binding_level
))
593 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
596 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
598 register struct binding_level
*level
= current_binding_level
;
599 current_binding_level
= current_binding_level
->level_chain
;
600 level
->level_chain
= free_binding_level
;
601 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
602 if (level
->binding_depth
!= binding_depth
)
604 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
605 free_binding_level
= level
;
606 find_class_binding_level ();
611 suspend_binding_level ()
613 if (class_binding_level
)
614 current_binding_level
= class_binding_level
;
616 if (global_binding_level
)
618 /* Cannot suspend a level, if there are none left to suspend. */
619 if (current_binding_level
== global_binding_level
)
620 my_friendly_abort (123);
622 /* Suspend the current level. */
623 #if defined(DEBUG_CP_BINDING_LEVELS)
626 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
627 (is_class_level
) ? "class" : "block",
628 current_binding_level
, lineno
);
629 if (is_class_level
!= (current_binding_level
== class_binding_level
))
632 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
635 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
636 current_binding_level
= current_binding_level
->level_chain
;
637 find_class_binding_level ();
641 resume_binding_level (b
)
642 struct binding_level
*b
;
644 /* Resuming binding levels is meant only for namespaces,
645 and those cannot nest into classes. */
646 my_friendly_assert(!class_binding_level
, 386);
647 /* Also, resuming a non-directly nested namespace is a no-no. */
648 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
649 current_binding_level
= b
;
650 #if defined(DEBUG_CP_BINDING_LEVELS)
651 b
->binding_depth
= binding_depth
;
653 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
654 (is_class_level
) ? "class" : "block", b
, lineno
);
657 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
660 /* Create a new `struct binding_level'. */
663 struct binding_level
*
664 make_binding_level ()
667 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
670 /* Nonzero if we are currently in the global binding level. */
675 return current_binding_level
== global_binding_level
;
678 /* Return the innermost binding level that is not for a class scope. */
680 static struct binding_level
*
681 innermost_nonclass_level ()
683 struct binding_level
*b
;
685 b
= current_binding_level
;
686 while (b
->parm_flag
== 2)
692 /* Nonzero if we are currently in a toplevel binding level. This
693 means either the global binding level or a namespace in a toplevel
694 binding level. Since there are no non-toplevel namespace levels,
695 this really means any namespace or pseudo-global level. We also
696 include a class whose context is toplevel. */
699 toplevel_bindings_p ()
701 struct binding_level
*b
= innermost_nonclass_level ();
703 return b
->namespace_p
|| b
->pseudo_global
;
706 /* Nonzero if this is a namespace scope, or if we are defining a class
707 which is itself at namespace scope, or whose enclosing class is
708 such a class, etc. */
711 namespace_bindings_p ()
713 struct binding_level
*b
= innermost_nonclass_level ();
715 return b
->namespace_p
;
718 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
719 unconditionally. Otherwise, use the normal logic to decide whether
720 or not to create a BLOCK. */
723 keep_next_level (keep
)
726 keep_next_level_flag
= keep
;
729 /* Nonzero if the current level needs to have a BLOCK made. */
734 return (current_binding_level
->blocks
!= NULL_TREE
735 || current_binding_level
->keep
736 || current_binding_level
->names
!= NULL_TREE
737 || (current_binding_level
->tags
!= NULL_TREE
738 && !current_binding_level
->tag_transparent
));
742 declare_pseudo_global_level ()
744 current_binding_level
->pseudo_global
= 1;
748 declare_namespace_level ()
750 current_binding_level
->namespace_p
= 1;
754 pseudo_global_level_p ()
756 return current_binding_level
->pseudo_global
;
760 set_class_shadows (shadows
)
763 class_binding_level
->class_shadowed
= shadows
;
766 /* Enter a new binding level.
767 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
768 not for that of tags. */
771 pushlevel (tag_transparent
)
774 struct binding_level
*newlevel
;
776 if (current_function
&& !doing_semantic_analysis_p ())
779 /* Reuse or create a struct for this binding level. */
780 #if defined(DEBUG_CP_BINDING_LEVELS)
782 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
783 if (free_binding_level
)
784 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
786 newlevel
= free_binding_level
;
787 free_binding_level
= free_binding_level
->level_chain
;
790 newlevel
= make_binding_level ();
792 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
793 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
794 keep_next_level_flag
= 0;
798 note_level_for_for ()
800 current_binding_level
->is_for_scope
= 1;
803 /* For a binding between a name and an entity at a block scope,
804 this is the `struct binding_level' for the block. */
805 #define BINDING_LEVEL(NODE) \
806 (((struct tree_binding*)NODE)->scope.level)
808 /* Make DECL the innermost binding for ID. The LEVEL is the binding
809 level at which this declaration is being bound. */
812 push_binding (id
, decl
, level
)
815 struct binding_level
* level
;
819 binding
= make_node (CPLUS_BINDING
);
821 /* Now, fill in the binding information. */
822 BINDING_VALUE (binding
) = decl
;
823 BINDING_TYPE (binding
) = NULL_TREE
;
824 BINDING_LEVEL (binding
) = level
;
825 INHERITED_VALUE_BINDING_P (binding
) = 0;
826 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
827 BINDING_HAS_LEVEL_P (binding
) = 1;
829 /* And put it on the front of the list of bindings for ID. */
830 TREE_CHAIN (binding
) = IDENTIFIER_BINDING (id
);
831 IDENTIFIER_BINDING (id
) = binding
;
834 /* ID is already bound in the current scope. But, DECL is an
835 additional binding for ID in the same scope. This is the `struct
836 stat' hack whereby a non-typedef class-name or enum-name can be
837 bound at the same level as some other kind of entity. It's the
838 responsibility of the caller to check that inserting this name is
839 legal here. Returns nonzero if the new binding was successful. */
841 add_binding (id
, decl
)
845 tree binding
= IDENTIFIER_BINDING (id
);
848 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
849 /* The new name is the type name. */
850 BINDING_TYPE (binding
) = decl
;
851 else if (!BINDING_VALUE (binding
))
852 /* This situation arises when push_class_level_binding moves an
853 inherited type-binding out of the way to make room for a new
855 BINDING_VALUE (binding
) = decl
;
856 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
857 && DECL_ARTIFICIAL (BINDING_VALUE (binding
)))
859 /* The old binding was a type name. It was placed in
860 BINDING_VALUE because it was thought, at the point it was
861 declared, to be the only entity with such a name. Move the
862 type name into the type slot; it is now hidden by the new
864 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
865 BINDING_VALUE (binding
) = decl
;
866 INHERITED_VALUE_BINDING_P (binding
) = 0;
868 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
869 && TREE_CODE (decl
) == TYPE_DECL
870 && DECL_NAME (decl
) == DECL_NAME (BINDING_VALUE (binding
))
871 && same_type_p (TREE_TYPE (decl
),
872 TREE_TYPE (BINDING_VALUE (binding
))))
873 /* We have two typedef-names, both naming the same type to have
874 the same name. This is OK because of:
878 In a given scope, a typedef specifier can be used to redefine
879 the name of any type declared in that scope to refer to the
880 type to which it already refers. */
884 cp_error ("declaration of `%#D'", decl
);
885 cp_error_at ("conflicts with previous declaration `%#D'",
886 BINDING_VALUE (binding
));
893 /* Add DECL to the list of things declared in B. */
896 add_decl_to_level (decl
, b
)
898 struct binding_level
*b
;
900 /* We build up the list in reverse order, and reverse it later if
902 TREE_CHAIN (decl
) = b
->names
;
906 /* Bind DECL to ID in the current_binding_level, assumed to be a local
907 binding level. If PUSH_USING is set in FLAGS, we know that DECL
908 doesn't really belong to this binding level, that it got here
909 through a using-declaration. */
912 push_local_binding (id
, decl
, flags
)
917 struct binding_level
*b
;
919 /* Skip over any local classes. This makes sense if we call
920 push_local_binding with a friend decl of a local class. */
921 b
= current_binding_level
;
922 while (b
->parm_flag
== 2)
925 if (lookup_name_current_level (id
))
927 /* Supplement the existing binding. */
928 if (!add_binding (id
, decl
))
929 /* It didn't work. Something else must be bound at this
930 level. Do not add DECL to the list of things to pop
935 /* Create a new binding. */
936 push_binding (id
, decl
, b
);
938 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
939 /* We must put the OVERLOAD into a TREE_LIST since the
940 TREE_CHAIN of an OVERLOAD is already used. Similarly for
941 decls that got here through a using-declaration. */
942 decl
= build_tree_list (NULL_TREE
, decl
);
944 /* And put DECL on the list of things declared by the current
946 add_decl_to_level (decl
, b
);
949 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
950 binding was successful. */
953 push_class_binding (id
, decl
)
958 tree binding
= IDENTIFIER_BINDING (id
);
961 /* Note that we declared this value so that we can issue an error if
962 this an illegal redeclaration of a name already used for some
964 note_name_declared_in_class (id
, decl
);
966 if (binding
&& BINDING_LEVEL (binding
) == class_binding_level
)
967 /* Supplement the existing binding. */
968 result
= add_binding (id
, decl
);
970 /* Create a new binding. */
971 push_binding (id
, decl
, class_binding_level
);
973 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
974 class-level declaration. Note that we do not use DECL here
975 because of the possibility of the `struct stat' hack; if DECL is
976 a class-name or enum-name we might prefer a field-name, or some
978 IDENTIFIER_CLASS_VALUE (id
) = BINDING_VALUE (IDENTIFIER_BINDING (id
));
980 /* If this is a binding from a base class, mark it as such. */
981 binding
= IDENTIFIER_BINDING (id
);
982 if (BINDING_VALUE (binding
) == decl
&& TREE_CODE (decl
) != TREE_LIST
)
984 /* Any implicit typename must be from a base-class. The
985 context for an implicit typename declaration is always
986 the derived class in which the lookup was done, so the checks
987 based on the context of DECL below will not trigger. */
988 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl
))
989 INHERITED_VALUE_BINDING_P (binding
) = 1;
992 if (TREE_CODE (decl
) == OVERLOAD
)
993 context
= DECL_REAL_CONTEXT (OVL_CURRENT (decl
));
996 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd',
998 context
= DECL_REAL_CONTEXT (decl
);
1001 if (is_properly_derived_from (current_class_type
, context
))
1002 INHERITED_VALUE_BINDING_P (binding
) = 1;
1004 INHERITED_VALUE_BINDING_P (binding
) = 0;
1007 else if (BINDING_VALUE (binding
) == decl
)
1008 /* We only encounter a TREE_LIST when push_class_decls detects an
1009 ambiguity. Such an ambiguity can be overridden by a definition
1011 INHERITED_VALUE_BINDING_P (binding
) = 1;
1016 /* Remove the binding for DECL which should be the innermost binding
1020 pop_binding (id
, decl
)
1026 if (id
== NULL_TREE
)
1027 /* It's easiest to write the loops that call this function without
1028 checking whether or not the entities involved have names. We
1029 get here for such an entity. */
1032 /* Get the innermost binding for ID. */
1033 binding
= IDENTIFIER_BINDING (id
);
1035 /* The name should be bound. */
1036 my_friendly_assert (binding
!= NULL_TREE
, 0);
1038 /* The DECL will be either the ordinary binding or the type
1039 binding for this identifier. Remove that binding. */
1040 if (BINDING_VALUE (binding
) == decl
)
1041 BINDING_VALUE (binding
) = NULL_TREE
;
1042 else if (BINDING_TYPE (binding
) == decl
)
1043 BINDING_TYPE (binding
) = NULL_TREE
;
1045 my_friendly_abort (0);
1047 if (!BINDING_VALUE (binding
) && !BINDING_TYPE (binding
))
1048 /* We're completely done with the innermost binding for this
1049 identifier. Unhook it from the list of bindings. */
1050 IDENTIFIER_BINDING (id
) = TREE_CHAIN (binding
);
1053 /* When a label goes out of scope, check to see if that label was used
1054 in a valid manner, and issue any appropriate warnings or errors. */
1060 tree label
= TREE_VALUE (link
);
1062 if (!processing_template_decl
&& doing_semantic_analysis_p ())
1064 if (DECL_INITIAL (label
) == NULL_TREE
)
1066 cp_error_at ("label `%D' used but not defined", label
);
1067 /* Avoid crashing later. */
1068 define_label (input_filename
, 1, DECL_NAME (label
));
1070 else if (warn_unused
&& !TREE_USED (label
))
1071 cp_warning_at ("label `%D' defined but not used", label
);
1074 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), TREE_PURPOSE (link
));
1077 /* At the end of a function, all labels declared within the fucntion
1078 go out of scope. BLOCK is the top-level block for the
1087 /* Clear out the definitions of all label names, since their scopes
1089 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1092 /* Put the labels into the "variables" of the top-level block,
1093 so debugger can see them. */
1094 TREE_CHAIN (TREE_VALUE (link
)) = BLOCK_VARS (block
);
1095 BLOCK_VARS (block
) = TREE_VALUE (link
);
1098 named_labels
= NULL_TREE
;
1101 /* Exit a binding level.
1102 Pop the level off, and restore the state of the identifier-decl mappings
1103 that were in effect when this level was entered.
1105 If KEEP == 1, this level had explicit declarations, so
1106 and create a "block" (a BLOCK node) for the level
1107 to record its declarations and subblocks for symbol table output.
1109 If FUNCTIONBODY is nonzero, this level is the body of a function,
1110 so create a block as if KEEP were set and also clear out all
1113 If REVERSE is nonzero, reverse the order of decls before putting
1114 them into the BLOCK. */
1117 poplevel (keep
, reverse
, functionbody
)
1123 /* The chain of decls was accumulated in reverse order.
1124 Put it into forward order, just for cleanliness. */
1126 int tmp
= functionbody
;
1127 int real_functionbody
;
1130 tree block
= NULL_TREE
;
1132 int block_previously_created
;
1133 int leaving_for_scope
;
1135 if (current_function
&& !doing_semantic_analysis_p ())
1138 my_friendly_assert (current_binding_level
->parm_flag
!= 2,
1141 real_functionbody
= (current_binding_level
->keep
== 2
1142 ? ((functionbody
= 0), tmp
) : functionbody
);
1143 tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1144 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1146 my_friendly_assert (!current_binding_level
->class_shadowed
,
1149 /* We used to use KEEP == 2 to indicate that the new block should go
1150 at the beginning of the list of blocks at this binding level,
1151 rather than the end. This hack is no longer used. */
1152 my_friendly_assert (keep
== 0 || keep
== 1, 0);
1154 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1155 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1156 current_binding_level
->parm_flag
,
1157 current_binding_level
->keep
);
1159 if (current_binding_level
->keep
== 1)
1162 /* Get the decls in the order they were written.
1163 Usually current_binding_level->names is in reverse order.
1164 But parameter decls were previously put in forward order. */
1167 current_binding_level
->names
1168 = decls
= nreverse (current_binding_level
->names
);
1170 decls
= current_binding_level
->names
;
1172 /* Output any nested inline functions within this block
1173 if they weren't already output. */
1175 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1176 if (TREE_CODE (decl
) == FUNCTION_DECL
1177 && ! TREE_ASM_WRITTEN (decl
)
1178 && DECL_INITIAL (decl
) != NULL_TREE
1179 && TREE_ADDRESSABLE (decl
)
1180 && decl_function_context (decl
) == current_function_decl
)
1182 /* If this decl was copied from a file-scope decl
1183 on account of a block-scope extern decl,
1184 propagate TREE_ADDRESSABLE to the file-scope decl. */
1185 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1186 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1189 push_function_context ();
1190 output_inline_function (decl
);
1191 pop_function_context ();
1195 /* If there were any declarations or structure tags in that level,
1196 or if this level is a function body,
1197 create a BLOCK to record them for the life of this function. */
1200 block_previously_created
= (current_binding_level
->this_block
!= NULL_TREE
);
1201 if (block_previously_created
)
1202 block
= current_binding_level
->this_block
;
1203 else if (keep
== 1 || functionbody
)
1204 block
= make_node (BLOCK
);
1205 if (block
!= NULL_TREE
)
1207 if (block_previously_created
)
1209 if (decls
|| tags
|| subblocks
)
1211 if (BLOCK_VARS (block
))
1212 warning ("internal compiler error: debugging info corrupted");
1214 BLOCK_VARS (block
) = decls
;
1216 /* We can have previous subblocks and new subblocks when
1217 doing fixup_gotos with complex cleanups. We chain the new
1218 subblocks onto the end of any pre-existing subblocks. */
1219 BLOCK_SUBBLOCKS (block
) = chainon (BLOCK_SUBBLOCKS (block
),
1225 BLOCK_VARS (block
) = decls
;
1226 BLOCK_SUBBLOCKS (block
) = subblocks
;
1230 /* In each subblock, record that this is its superior. */
1233 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1234 BLOCK_SUPERCONTEXT (link
) = block
;
1236 /* We still support the old for-scope rules, whereby the variables
1237 in a for-init statement were in scope after the for-statement
1238 ended. We only use the new rules in flag_new_for_scope is
1241 = current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1;
1243 /* Remove declarations for all the DECLs in this level. */
1244 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1246 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
)
1249 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link
)));
1253 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link
));
1255 ns_binding
= NULL_TREE
;
1258 && (BINDING_LEVEL (outer_binding
)
1259 == current_binding_level
->level_chain
))
1260 /* We have something like:
1265 and we are leaving the `for' scope. There's no reason to
1266 keep the binding of the inner `i' in this case. */
1267 pop_binding (DECL_NAME (link
), link
);
1268 else if ((outer_binding
1269 && (TREE_CODE (BINDING_VALUE (outer_binding
))
1272 && TREE_CODE (ns_binding
) == TYPE_DECL
))
1273 /* Here, we have something like:
1281 We must pop the for-scope binding so we know what's a
1282 type and what isn't. */
1283 pop_binding (DECL_NAME (link
), link
);
1286 /* Mark this VAR_DECL as dead so that we can tell we left it
1287 there only for backward compatibility. */
1288 DECL_DEAD_FOR_LOCAL (link
) = 1;
1290 /* Keep track of what should of have happenned when we
1291 popped the binding. */
1292 if (outer_binding
&& BINDING_VALUE (outer_binding
))
1293 DECL_SHADOWED_FOR_VAR (link
)
1294 = BINDING_VALUE (outer_binding
);
1296 /* Add it to the list of dead variables in the next
1297 outermost binding to that we can remove these when we
1298 leave that binding. */
1299 current_binding_level
->level_chain
->dead_vars_from_for
1300 = tree_cons (NULL_TREE
, link
,
1301 current_binding_level
->level_chain
->
1302 dead_vars_from_for
);
1304 /* Although we don't pop the CPLUS_BINDING, we do clear
1305 its BINDING_LEVEL since the level is going away now. */
1306 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link
)))
1312 /* Remove the binding. */
1314 if (TREE_CODE (decl
) == TREE_LIST
)
1315 decl
= TREE_VALUE (decl
);
1316 if (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd')
1317 pop_binding (DECL_NAME (decl
), decl
);
1318 else if (TREE_CODE (decl
) == OVERLOAD
)
1319 pop_binding (DECL_NAME (OVL_FUNCTION (decl
)), decl
);
1321 my_friendly_abort (0);
1325 /* Remove declarations for any `for' variables from inner scopes
1326 that we kept around. */
1327 for (link
= current_binding_level
->dead_vars_from_for
;
1328 link
; link
= TREE_CHAIN (link
))
1329 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
1331 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1332 for (link
= current_binding_level
->type_shadowed
;
1333 link
; link
= TREE_CHAIN (link
))
1334 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1336 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1337 for (link
= current_binding_level
->shadowed_labels
;
1339 link
= TREE_CHAIN (link
))
1342 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1343 list if a `using' declaration put them there. The debugging
1344 back-ends won't understand OVERLOAD, so we remove them here.
1345 Because the BLOCK_VARS are (temporarily) shared with
1346 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1347 popped all the bindings. */
1352 for (d
= &BLOCK_VARS (block
); *d
; )
1354 if (TREE_CODE (*d
) == TREE_LIST
)
1355 *d
= TREE_CHAIN (*d
);
1357 d
= &TREE_CHAIN (*d
);
1361 /* If the level being exited is the top level of a function,
1362 check over all the labels. */
1365 /* Since this is the top level block of a function, the vars are
1366 the function's parameters. Don't leave them in the BLOCK
1367 because they are found in the FUNCTION_DECL instead. */
1368 BLOCK_VARS (block
) = 0;
1372 /* Any uses of undefined labels now operate under constraints
1373 of next binding contour. */
1374 if (current_function
)
1376 struct binding_level
*level_chain
;
1377 level_chain
= current_binding_level
->level_chain
;
1380 struct named_label_list
*labels
;
1381 for (labels
= named_label_uses
; labels
; labels
= labels
->next
)
1382 if (labels
->binding_level
== current_binding_level
)
1384 labels
->binding_level
= level_chain
;
1385 labels
->names_in_scope
= level_chain
->names
;
1390 tmp
= current_binding_level
->keep
;
1392 pop_binding_level ();
1394 DECL_INITIAL (current_function_decl
) = block
;
1397 if (!block_previously_created
)
1398 current_binding_level
->blocks
1399 = chainon (current_binding_level
->blocks
, block
);
1401 /* If we did not make a block for the level just exited,
1402 any blocks made for inner levels
1403 (since they cannot be recorded as subblocks in that level)
1404 must be carried forward so they will later become subblocks
1405 of something else. */
1407 current_binding_level
->blocks
1408 = chainon (current_binding_level
->blocks
, subblocks
);
1410 /* Take care of compiler's internal binding structures. */
1413 add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1414 /* Each and every BLOCK node created here in `poplevel' is important
1415 (e.g. for proper debugging information) so if we created one
1416 earlier, mark it as "used". */
1418 TREE_USED (block
) = 1;
1419 block
= poplevel (keep
, reverse
, functionbody
);
1422 /* Each and every BLOCK node created here in `poplevel' is important
1423 (e.g. for proper debugging information) so if we created one
1424 earlier, mark it as "used". */
1426 TREE_USED (block
) = 1;
1430 /* Delete the node BLOCK from the current binding level.
1431 This is used for the block inside a stmt expr ({...})
1432 so that the block can be reinserted where appropriate. */
1435 delete_block (block
)
1439 if (current_binding_level
->blocks
== block
)
1440 current_binding_level
->blocks
= TREE_CHAIN (block
);
1441 for (t
= current_binding_level
->blocks
; t
;)
1443 if (TREE_CHAIN (t
) == block
)
1444 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1448 TREE_CHAIN (block
) = NULL_TREE
;
1449 /* Clear TREE_USED which is always set by poplevel.
1450 The flag is set again if insert_block is called. */
1451 TREE_USED (block
) = 0;
1454 /* Insert BLOCK at the end of the list of subblocks of the
1455 current binding level. This is used when a BIND_EXPR is expanded,
1456 to handle the BLOCK node inside the BIND_EXPR. */
1459 insert_block (block
)
1462 TREE_USED (block
) = 1;
1463 current_binding_level
->blocks
1464 = chainon (current_binding_level
->blocks
, block
);
1467 /* Set the BLOCK node for the innermost scope
1468 (the one we are currently in). */
1472 register tree block
;
1474 current_binding_level
->this_block
= block
;
1477 /* Do a pushlevel for class declarations. */
1482 register struct binding_level
*newlevel
;
1484 /* Reuse or create a struct for this binding level. */
1485 #if defined(DEBUG_CP_BINDING_LEVELS)
1487 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1488 if (free_binding_level
)
1489 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1491 newlevel
= free_binding_level
;
1492 free_binding_level
= free_binding_level
->level_chain
;
1495 newlevel
= make_binding_level ();
1497 #if defined(DEBUG_CP_BINDING_LEVELS)
1499 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1501 push_binding_level (newlevel
, 0, 0);
1503 class_binding_level
= current_binding_level
;
1504 class_binding_level
->parm_flag
= 2;
1507 /* ...and a poplevel for class declarations. */
1512 register struct binding_level
*level
= class_binding_level
;
1515 my_friendly_assert (level
!= 0, 354);
1517 /* If we're leaving a toplevel class, don't bother to do the setting
1518 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1519 shouldn't even be used when current_class_type isn't set, and second,
1520 if we don't touch it here, we're able to use the cache effect if the
1521 next time we're entering a class scope, it is the same class. */
1522 if (current_class_depth
!= 1)
1524 struct binding_level
* b
;
1526 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1527 for (shadowed
= level
->class_shadowed
;
1529 shadowed
= TREE_CHAIN (shadowed
))
1530 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = NULL_TREE
;
1532 /* Find the next enclosing class, and recreate
1533 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1534 b
= level
->level_chain
;
1535 while (b
&& b
->parm_flag
!= 2)
1539 for (shadowed
= b
->class_shadowed
;
1541 shadowed
= TREE_CHAIN (shadowed
))
1545 t
= IDENTIFIER_BINDING (TREE_PURPOSE (shadowed
));
1546 while (t
&& BINDING_LEVEL (t
) != b
)
1550 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
))
1551 = BINDING_VALUE (t
);
1555 /* Remember to save what IDENTIFIER's were bound in this scope so we
1556 can recover from cache misses. */
1558 previous_class_type
= current_class_type
;
1559 previous_class_values
= class_binding_level
->class_shadowed
;
1561 for (shadowed
= level
->type_shadowed
;
1563 shadowed
= TREE_CHAIN (shadowed
))
1564 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1566 /* Remove the bindings for all of the class-level declarations. */
1567 for (shadowed
= level
->class_shadowed
;
1569 shadowed
= TREE_CHAIN (shadowed
))
1570 pop_binding (TREE_PURPOSE (shadowed
), TREE_TYPE (shadowed
));
1572 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1573 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1574 class_binding_level
->parm_flag
,
1575 class_binding_level
->keep
);
1577 /* Now, pop out of the binding level which we created up in the
1578 `pushlevel_class' routine. */
1579 #if defined(DEBUG_CP_BINDING_LEVELS)
1581 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1583 pop_binding_level ();
1586 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1587 for any names in enclosing classes. */
1590 clear_identifier_class_values ()
1594 if (!class_binding_level
)
1597 for (t
= class_binding_level
->class_shadowed
;
1600 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t
)) = NULL_TREE
;
1603 /* Returns non-zero if T is a virtual function table. */
1606 vtable_decl_p (t
, data
)
1608 void *data ATTRIBUTE_UNUSED
;
1610 return (TREE_CODE (t
) == VAR_DECL
&& DECL_VIRTUAL_P (t
));
1613 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1617 vtype_decl_p (t
, data
)
1619 void *data ATTRIBUTE_UNUSED
;
1621 return (TREE_CODE (t
) == TYPE_DECL
1622 && TREE_TYPE (t
) != error_mark_node
1623 && TYPE_LANG_SPECIFIC (TREE_TYPE (t
))
1624 && CLASSTYPE_VSIZE (TREE_TYPE (t
)));
1627 /* Return the declarations that are members of the namespace NS. */
1630 cp_namespace_decls (ns
)
1633 return NAMESPACE_LEVEL (ns
)->names
;
1636 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1637 itself, calling F for each. The DATA is passed to F as well. */
1640 walk_namespaces_r (namespace, f
, data
)
1642 walk_namespaces_fn f
;
1648 result
|= (*f
) (namespace, data
);
1650 for (current
= cp_namespace_decls (namespace);
1652 current
= TREE_CHAIN (current
))
1654 if (TREE_CODE (current
) != NAMESPACE_DECL
1655 || DECL_NAMESPACE_ALIAS (current
))
1657 if (!DECL_LANG_SPECIFIC (current
))
1660 my_friendly_assert (current
== std_node
, 393);
1664 /* We found a namespace. */
1665 result
|= walk_namespaces_r (current
, f
, data
);
1671 /* Walk all the namespaces, calling F for each. The DATA is passed to
1675 walk_namespaces (f
, data
)
1676 walk_namespaces_fn f
;
1679 return walk_namespaces_r (global_namespace
, f
, data
);
1682 struct walk_globals_data
{
1683 walk_globals_pred p
;
1688 /* Walk the global declarations in NAMESPACE. Whenever one is found
1689 for which P returns non-zero, call F with its address. If any call
1690 to F returns a non-zero value, return a non-zero value. */
1693 walk_globals_r (namespace, data
)
1697 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
1698 walk_globals_pred p
= wgd
->p
;
1699 walk_globals_fn f
= wgd
->f
;
1700 void *d
= wgd
->data
;
1704 t
= &NAMESPACE_LEVEL (namespace)->names
;
1711 result
|= (*f
) (t
, d
);
1713 /* If F changed *T, then *T still points at the next item to
1716 t
= &TREE_CHAIN (*t
);
1722 /* Walk the global declarations. Whenever one is found for which P
1723 returns non-zero, call F with its address. If any call to F
1724 returns a non-zero value, return a non-zero value. */
1727 walk_globals (p
, f
, data
)
1728 walk_globals_pred p
;
1732 struct walk_globals_data wgd
;
1737 return walk_namespaces (walk_globals_r
, &wgd
);
1740 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1741 DATA is non-NULL, this is the last time we will call
1742 wrapup_global_declarations for this NAMESPACE. */
1745 wrapup_globals_for_namespace (namespace, data
)
1749 tree globals
= cp_namespace_decls (namespace);
1750 int len
= list_length (globals
);
1751 tree
*vec
= (tree
*) alloca (sizeof (tree
) * len
);
1755 int last_time
= (data
!= 0);
1757 if (last_time
&& namespace == global_namespace
)
1758 /* Let compile_file handle the global namespace. */
1761 /* Process the decls in reverse order--earliest first.
1762 Put them into VEC from back to front, then take out from front. */
1764 for (i
= 0, decl
= globals
; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
1765 vec
[len
- i
- 1] = decl
;
1769 check_global_declarations (vec
, len
);
1773 /* Temporarily mark vtables as external. That prevents
1774 wrapup_global_declarations from writing them out; we must process
1775 them ourselves in finish_vtable_vardecl. */
1776 for (i
= 0; i
< len
; ++i
)
1777 if (vtable_decl_p (vec
[i
], /*data=*/0) && !DECL_EXTERNAL (vec
[i
]))
1779 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 1;
1780 DECL_EXTERNAL (vec
[i
]) = 1;
1783 /* Write out any globals that need to be output. */
1784 result
= wrapup_global_declarations (vec
, len
);
1786 /* Undo the hack to DECL_EXTERNAL above. */
1787 for (i
= 0; i
< len
; ++i
)
1788 if (vtable_decl_p (vec
[i
], /*data=*/0)
1789 && DECL_NOT_REALLY_EXTERN (vec
[i
]))
1791 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 0;
1792 DECL_EXTERNAL (vec
[i
]) = 0;
1799 /* Mark ARG (which is really a struct binding_level **) for GC. */
1802 mark_binding_level (arg
)
1805 struct binding_level
*lvl
= *(struct binding_level
**)arg
;
1809 ggc_mark_tree (lvl
->names
);
1810 ggc_mark_tree (lvl
->tags
);
1811 ggc_mark_tree (lvl
->usings
);
1812 ggc_mark_tree (lvl
->using_directives
);
1813 ggc_mark_tree (lvl
->class_shadowed
);
1814 ggc_mark_tree (lvl
->type_shadowed
);
1815 ggc_mark_tree (lvl
->shadowed_labels
);
1816 ggc_mark_tree (lvl
->blocks
);
1817 ggc_mark_tree (lvl
->this_block
);
1818 ggc_mark_tree (lvl
->incomplete
);
1819 ggc_mark_tree (lvl
->dead_vars_from_for
);
1821 lvl
= lvl
->level_chain
;
1825 /* For debugging. */
1826 static int no_print_functions
= 0;
1827 static int no_print_builtins
= 0;
1830 print_binding_level (lvl
)
1831 struct binding_level
*lvl
;
1835 fprintf (stderr
, " blocks=");
1836 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
1837 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
1838 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
1839 if (lvl
->tag_transparent
)
1840 fprintf (stderr
, " tag-transparent");
1841 if (lvl
->more_cleanups_ok
)
1842 fprintf (stderr
, " more-cleanups-ok");
1843 if (lvl
->have_cleanups
)
1844 fprintf (stderr
, " have-cleanups");
1845 fprintf (stderr
, "\n");
1848 fprintf (stderr
, " names:\t");
1849 /* We can probably fit 3 names to a line? */
1850 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1852 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1854 if (no_print_builtins
1855 && (TREE_CODE (t
) == TYPE_DECL
)
1856 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
1859 /* Function decls tend to have longer names. */
1860 if (TREE_CODE (t
) == FUNCTION_DECL
)
1867 fprintf (stderr
, "\n\t");
1870 print_node_brief (stderr
, "", t
, 0);
1871 if (t
== error_mark_node
)
1875 fprintf (stderr
, "\n");
1879 fprintf (stderr
, " tags:\t");
1881 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
1883 if (TREE_PURPOSE (t
) == NULL_TREE
)
1885 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
1892 fprintf (stderr
, "\n\t");
1895 if (TREE_PURPOSE (t
) == NULL_TREE
)
1897 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
1898 fprintf (stderr
, ">");
1900 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
1901 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
1904 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
1905 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
1906 fprintf (stderr
, ">");
1910 fprintf (stderr
, "\n");
1912 if (lvl
->class_shadowed
)
1914 fprintf (stderr
, " class-shadowed:");
1915 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
1917 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1919 fprintf (stderr
, "\n");
1921 if (lvl
->type_shadowed
)
1923 fprintf (stderr
, " type-shadowed:");
1924 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1926 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1928 fprintf (stderr
, "\n");
1933 print_other_binding_stack (stack
)
1934 struct binding_level
*stack
;
1936 struct binding_level
*level
;
1937 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
1939 fprintf (stderr
, "binding level ");
1940 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
1941 fprintf (stderr
, "\n");
1942 print_binding_level (level
);
1947 print_binding_stack ()
1949 struct binding_level
*b
;
1950 fprintf (stderr
, "current_binding_level=");
1951 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
1952 fprintf (stderr
, "\nclass_binding_level=");
1953 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
1954 fprintf (stderr
, "\nglobal_binding_level=");
1955 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
1956 fprintf (stderr
, "\n");
1957 if (class_binding_level
)
1959 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1960 if (b
== current_binding_level
)
1963 b
= class_binding_level
;
1965 b
= current_binding_level
;
1968 b
= current_binding_level
;
1969 print_other_binding_stack (b
);
1970 fprintf (stderr
, "global:\n");
1971 print_binding_level (global_binding_level
);
1974 /* Namespace binding access routines: The namespace_bindings field of
1975 the identifier is polymorphic, with three possible values:
1976 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1977 indicating the BINDING_VALUE of global_namespace. */
1979 /* Check whether the a binding for the name to scope is known.
1980 Assumes that the bindings of the name are already a list
1981 of bindings. Returns the binding found, or NULL_TREE. */
1984 find_binding (name
, scope
)
1988 tree iter
, prev
= NULL_TREE
;
1990 scope
= ORIGINAL_NAMESPACE (scope
);
1992 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
1993 iter
= TREE_CHAIN (iter
))
1995 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
1996 if (BINDING_SCOPE (iter
) == scope
)
1998 /* Move binding found to the front of the list, so
1999 subsequent lookups will find it faster. */
2002 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
2003 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
2004 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
2013 /* Always returns a binding for name in scope. If the
2014 namespace_bindings is not a list, convert it to one first.
2015 If no binding is found, make a new one. */
2018 binding_for_name (name
, scope
)
2022 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2025 scope
= ORIGINAL_NAMESPACE (scope
);
2027 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
2029 /* Get rid of optimization for global scope. */
2030 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
2031 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
2032 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2034 if (b
&& (result
= find_binding (name
, scope
)))
2036 /* Not found, make a new one. */
2037 result
= make_node (CPLUS_BINDING
);
2038 TREE_CHAIN (result
) = b
;
2039 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2040 BINDING_SCOPE (result
) = scope
;
2041 BINDING_TYPE (result
) = NULL_TREE
;
2042 BINDING_VALUE (result
) = NULL_TREE
;
2046 /* Return the binding value for name in scope, considering that
2047 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2050 namespace_binding (name
, scope
)
2054 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2057 if (scope
== NULL_TREE
)
2058 scope
= global_namespace
;
2059 if (TREE_CODE (b
) != CPLUS_BINDING
)
2060 return (scope
== global_namespace
) ? b
: NULL_TREE
;
2061 name
= find_binding (name
,scope
);
2062 if (name
== NULL_TREE
)
2064 return BINDING_VALUE (name
);
2067 /* Set the binding value for name in scope. If modifying the binding
2068 of global_namespace is attempted, try to optimize it. */
2071 set_namespace_binding (name
, scope
, val
)
2078 if (scope
== NULL_TREE
)
2079 scope
= global_namespace
;
2081 if (scope
== global_namespace
)
2083 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2084 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
2086 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
2090 b
= binding_for_name (name
, scope
);
2091 BINDING_VALUE (b
) = val
;
2094 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2095 select a name that is unique to this compilation unit. */
2098 push_namespace (name
)
2103 int implicit_use
= 0;
2105 if (!global_namespace
)
2107 /* This must be ::. */
2108 my_friendly_assert (name
== get_identifier ("::"), 377);
2113 /* The name of anonymous namespace is unique for the translation
2115 if (!anonymous_namespace_name
)
2116 anonymous_namespace_name
= get_file_function_name ('N');
2117 name
= anonymous_namespace_name
;
2118 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2120 /* Reopening anonymous namespace. */
2124 else if (current_namespace
== global_namespace
2125 && name
== DECL_NAME (std_node
))
2132 /* Check whether this is an extended namespace definition. */
2133 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2134 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2137 if (DECL_NAMESPACE_ALIAS (d
))
2139 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2140 d
, DECL_NAMESPACE_ALIAS (d
));
2141 d
= DECL_NAMESPACE_ALIAS (d
);
2148 /* Make a new namespace, binding the name to it. */
2149 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2150 /* The global namespace is not pushed, and the global binding
2151 level is set elsewhere. */
2156 declare_namespace_level ();
2157 NAMESPACE_LEVEL (d
) = current_binding_level
;
2161 resume_binding_level (NAMESPACE_LEVEL (d
));
2164 do_using_directive (d
);
2165 /* Enter the name space. */
2166 current_namespace
= d
;
2169 /* Pop from the scope of the current namespace. */
2174 if (current_namespace
== global_namespace
)
2176 my_friendly_assert (in_std
>0, 980421);
2180 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2181 /* The binding level is not popped, as it might be re-opened later. */
2182 suspend_binding_level ();
2185 /* Push into the scope of the namespace NS, even if it is deeply
2186 nested within another namespace. */
2189 push_nested_namespace (ns
)
2192 if (ns
== global_namespace
)
2193 push_to_top_level ();
2196 push_nested_namespace (CP_DECL_CONTEXT (ns
));
2197 push_namespace (DECL_NAME (ns
));
2201 /* Pop back from the scope of the namespace NS, which was previously
2202 entered with push_nested_namespace. */
2205 pop_nested_namespace (ns
)
2208 while (ns
!= global_namespace
)
2211 ns
= CP_DECL_CONTEXT (ns
);
2214 pop_from_top_level ();
2218 /* Subroutines for reverting temporarily to top-level for instantiation
2219 of templates and such. We actually need to clear out the class- and
2220 local-value slots of all identifiers, so that only the global values
2221 are at all visible. Simply setting current_binding_level to the global
2222 scope isn't enough, because more binding levels may be pushed. */
2223 struct saved_scope
*scope_chain
;
2225 /* Mark ST for GC. */
2229 struct stmt_tree
*st
;
2231 ggc_mark_tree (st
->x_last_stmt
);
2232 ggc_mark_tree (st
->x_last_expr_type
);
2235 /* Mark ARG (which is really a struct saved_scope **) for GC. */
2238 mark_saved_scope (arg
)
2241 struct saved_scope
*t
= *(struct saved_scope
**)arg
;
2244 mark_binding_level (&t
->class_bindings
);
2245 ggc_mark_tree (t
->old_bindings
);
2246 ggc_mark_tree (t
->old_namespace
);
2247 ggc_mark_tree (t
->class_name
);
2248 ggc_mark_tree (t
->class_type
);
2249 ggc_mark_tree (t
->access_specifier
);
2250 ggc_mark_tree (t
->function_decl
);
2252 ggc_mark_tree_varray (t
->lang_base
);
2253 ggc_mark_tree (t
->lang_name
);
2254 ggc_mark_tree (t
->x_function_parms
);
2255 ggc_mark_tree (t
->template_parms
);
2256 ggc_mark_tree (t
->x_previous_class_type
);
2257 ggc_mark_tree (t
->x_previous_class_values
);
2258 ggc_mark_tree (t
->x_saved_tree
);
2260 mark_stmt_tree (&t
->x_stmt_tree
);
2261 mark_binding_level (&t
->bindings
);
2267 store_bindings (names
, old_bindings
)
2268 tree names
, old_bindings
;
2271 for (t
= names
; t
; t
= TREE_CHAIN (t
))
2273 tree binding
, t1
, id
;
2275 if (TREE_CODE (t
) == TREE_LIST
)
2276 id
= TREE_PURPOSE (t
);
2281 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2282 we have no IDENTIFIER_BINDING if we have left the class
2283 scope, but cached the class-level declarations. */
2284 || !(IDENTIFIER_BINDING (id
) || IDENTIFIER_CLASS_VALUE (id
)))
2287 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
2288 if (TREE_VEC_ELT (t1
, 0) == id
)
2291 binding
= make_tree_vec (4);
2295 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
2296 TREE_VEC_ELT (binding
, 0) = id
;
2297 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
2298 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_BINDING (id
);
2299 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
2300 IDENTIFIER_BINDING (id
) = NULL_TREE
;
2301 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
2303 TREE_CHAIN (binding
) = old_bindings
;
2304 old_bindings
= binding
;
2308 return old_bindings
;
2312 maybe_push_to_top_level (pseudo
)
2315 struct saved_scope
*s
;
2316 struct binding_level
*b
;
2320 s
= (struct saved_scope
*) xcalloc (1, sizeof (struct saved_scope
));
2322 b
= scope_chain
? current_binding_level
: 0;
2324 /* If we're in the middle of some function, save our state. */
2325 if (current_function
)
2328 push_function_context_to (NULL_TREE
);
2333 old_bindings
= NULL_TREE
;
2334 if (scope_chain
&& previous_class_type
)
2335 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
2337 /* Have to include global_binding_level, because class-level decls
2338 aren't listed anywhere useful. */
2339 for (; b
; b
= b
->level_chain
)
2343 /* Template IDs are inserted into the global level. If they were
2344 inserted into namespace level, finish_file wouldn't find them
2345 when doing pending instantiations. Therefore, don't stop at
2346 namespace level, but continue until :: . */
2347 if (b
== global_binding_level
|| (pseudo
&& b
->pseudo_global
))
2350 old_bindings
= store_bindings (b
->names
, old_bindings
);
2351 /* We also need to check class_shadowed to save class-level type
2352 bindings, since pushclass doesn't fill in b->names. */
2353 if (b
->parm_flag
== 2)
2354 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2356 /* Unwind type-value slots back to top level. */
2357 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2358 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2360 s
->prev
= scope_chain
;
2361 s
->old_bindings
= old_bindings
;
2363 s
->need_pop_function_context
= need_pop
;
2364 s
->function_decl
= current_function_decl
;
2367 current_function_decl
= NULL_TREE
;
2368 VARRAY_TREE_INIT (current_lang_base
, 10, "current_lang_base");
2369 current_lang_stack
= &VARRAY_TREE (current_lang_base
, 0);
2370 current_lang_name
= lang_name_cplusplus
;
2371 strict_prototype
= strict_prototypes_lang_cplusplus
;
2372 current_namespace
= global_namespace
;
2376 push_to_top_level ()
2378 maybe_push_to_top_level (0);
2382 pop_from_top_level ()
2384 struct saved_scope
*s
= scope_chain
;
2387 /* Clear out class-level bindings cache. */
2388 if (previous_class_type
)
2389 invalidate_class_lookup_cache ();
2391 VARRAY_FREE (current_lang_base
);
2393 scope_chain
= s
->prev
;
2394 for (t
= s
->old_bindings
; t
; t
= TREE_CHAIN (t
))
2396 tree id
= TREE_VEC_ELT (t
, 0);
2399 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2400 IDENTIFIER_BINDING (id
) = TREE_VEC_ELT (t
, 2);
2401 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2405 if (current_lang_name
== lang_name_cplusplus
)
2406 strict_prototype
= strict_prototypes_lang_cplusplus
;
2407 else if (current_lang_name
== lang_name_c
)
2408 strict_prototype
= strict_prototypes_lang_c
;
2410 /* If we were in the middle of compiling a function, restore our
2412 if (s
->need_pop_function_context
)
2413 pop_function_context_from (NULL_TREE
);
2414 current_function_decl
= s
->function_decl
;
2419 /* Push a definition of struct, union or enum tag "name".
2420 into binding_level "b". "type" should be the type node,
2421 We assume that the tag "name" is not already defined.
2423 Note that the definition may really be just a forward reference.
2424 In that case, the TYPE_SIZE will be a NULL_TREE.
2426 C++ gratuitously puts all these tags in the name space. */
2428 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2429 record the shadowed value for this binding contour. TYPE is
2430 the type that ID maps to. */
2433 set_identifier_type_value_with_scope (id
, type
, b
)
2436 struct binding_level
*b
;
2438 if (!b
->namespace_p
)
2440 /* Shadow the marker, not the real thing, so that the marker
2441 gets restored later. */
2442 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2444 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2448 tree binding
= binding_for_name (id
, current_namespace
);
2449 BINDING_TYPE (binding
) = type
;
2450 /* Store marker instead of real type. */
2451 type
= global_type_node
;
2453 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2456 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2459 set_identifier_type_value (id
, type
)
2463 set_identifier_type_value_with_scope (id
, type
, current_binding_level
);
2466 /* Return the type associated with id. */
2469 identifier_type_value (id
)
2472 /* There is no type with that name, anywhere. */
2473 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2475 /* This is not the type marker, but the real thing. */
2476 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2477 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2478 /* Have to search for it. It must be on the global level, now.
2479 Ask lookup_name not to return non-types. */
2480 id
= lookup_name_real (id
, 2, 1, 0);
2482 return TREE_TYPE (id
);
2486 /* Pop off extraneous binding levels left over due to syntax errors.
2488 We don't pop past namespaces, as they might be valid. */
2493 #ifdef DEBUG_CP_BINDING_LEVELS
2494 fprintf (stderr
, "XXX entering pop_everything ()\n");
2496 while (!toplevel_bindings_p ())
2498 if (current_binding_level
->parm_flag
== 2)
2499 pop_nested_class ();
2503 #ifdef DEBUG_CP_BINDING_LEVELS
2504 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2508 /* The type TYPE is being declared. If it is a class template, or a
2509 specialization of a class template, do any processing required and
2510 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2511 being declared a friend. B is the binding level at which this TYPE
2514 Returns the TYPE_DECL for TYPE, which may have been altered by this
2518 maybe_process_template_type_declaration (type
, globalize
, b
)
2521 struct binding_level
* b
;
2523 tree decl
= TYPE_NAME (type
);
2525 if (processing_template_parmlist
)
2526 /* You can't declare a new template type in a template parameter
2527 list. But, you can declare a non-template type:
2529 template <class A*> struct S;
2531 is a forward-declaration of `A'. */
2535 maybe_check_template_type (type
);
2537 my_friendly_assert (IS_AGGR_TYPE (type
)
2538 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2541 if (processing_template_decl
)
2543 /* This may change after the call to
2544 push_template_decl_real, but we want the original value. */
2545 tree name
= DECL_NAME (decl
);
2547 decl
= push_template_decl_real (decl
, globalize
);
2548 /* If the current binding level is the binding level for the
2549 template parameters (see the comment in
2550 begin_template_parm_list) and the enclosing level is a class
2551 scope, and we're not looking at a friend, push the
2552 declaration of the member class into the class scope. In the
2553 friend case, push_template_decl will already have put the
2554 friend into global scope, if appropriate. */
2555 if (TREE_CODE (type
) != ENUMERAL_TYPE
2556 && !globalize
&& b
->pseudo_global
2557 && b
->level_chain
->parm_flag
== 2)
2559 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2560 /* Put this tag on the list of tags for the class, since
2561 that won't happen below because B is not the class
2562 binding level, but is instead the pseudo-global level. */
2563 b
->level_chain
->tags
=
2564 tree_cons (name
, type
, b
->level_chain
->tags
);
2565 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2566 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2574 /* In C++, you don't have to write `struct S' to refer to `S'; you
2575 can just use `S'. We accomplish this by creating a TYPE_DECL as
2576 if the user had written `typedef struct S S'. Create and return
2577 the TYPE_DECL for TYPE. */
2580 create_implicit_typedef (name
, type
)
2586 decl
= build_decl (TYPE_DECL
, name
, type
);
2587 SET_DECL_ARTIFICIAL (decl
);
2588 /* There are other implicit type declarations, like the one *within*
2589 a class that allows you to write `S::S'. We must distinguish
2591 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
2592 TYPE_NAME (type
) = decl
;
2597 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2598 Normally put it into the inner-most non-tag-transparent scope,
2599 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2600 The latter is needed for implicit declarations. */
2603 pushtag (name
, type
, globalize
)
2607 register struct binding_level
*b
;
2609 b
= current_binding_level
;
2610 while (b
->tag_transparent
2611 || (globalize
&& b
->parm_flag
== 2))
2614 b
->tags
= tree_cons (name
, type
, b
->tags
);
2618 /* Do C++ gratuitous typedefing. */
2619 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2621 register tree d
= NULL_TREE
;
2623 tree context
= TYPE_CONTEXT (type
);
2627 tree cs
= current_scope ();
2631 else if (cs
!= NULL_TREE
2632 && TREE_CODE_CLASS (TREE_CODE (cs
)) == 't')
2633 /* When declaring a friend class of a local class, we want
2634 to inject the newly named class into the scope
2635 containing the local class, not the namespace scope. */
2636 context
= hack_decl_function_context (get_type_decl (cs
));
2639 context
= current_namespace
;
2641 if ((b
->pseudo_global
&& b
->level_chain
->parm_flag
== 2)
2642 || b
->parm_flag
== 2)
2645 if (current_lang_name
== lang_name_java
)
2646 TYPE_FOR_JAVA (type
) = 1;
2648 d
= create_implicit_typedef (name
, type
);
2649 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2651 set_identifier_type_value_with_scope (name
, type
, b
);
2653 d
= maybe_process_template_type_declaration (type
,
2656 if (b
->parm_flag
== 2)
2658 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2659 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2660 class. But if it's a member template class, we
2661 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2663 finish_member_declaration (d
);
2665 pushdecl_class_level (d
);
2668 d
= pushdecl_with_scope (d
, b
);
2670 if (ANON_AGGRNAME_P (name
))
2671 DECL_IGNORED_P (d
) = 1;
2673 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2674 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2675 if (!uses_template_parms (type
))
2676 DECL_ASSEMBLER_NAME (d
)
2677 = get_identifier (build_overload_name (type
, 1, 1));
2679 if (b
->parm_flag
== 2)
2681 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2682 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2686 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2687 /* Use the canonical TYPE_DECL for this node. */
2688 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2691 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2692 will be the tagged type we just added to the current
2693 binding level. This fake NULL-named TYPE_DECL node helps
2694 dwarfout.c to know when it needs to output a
2695 representation of a tagged type, and it also gives us a
2696 convenient place to record the "scope start" address for
2699 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2700 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2704 /* Counter used to create anonymous type names. */
2706 static int anon_cnt
= 0;
2708 /* Return an IDENTIFIER which can be used as a name for
2709 anonymous structs and unions. */
2716 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2717 return get_identifier (buf
);
2720 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2721 This keeps dbxout from getting confused. */
2726 register struct binding_level
*b
;
2728 static int last_cnt
= 0;
2730 /* Fast out if no new anon names were declared. */
2731 if (last_cnt
== anon_cnt
)
2734 b
= current_binding_level
;
2735 while (b
->tag_transparent
)
2740 /* A NULL purpose means we have already processed all tags
2741 from here to the end of the list. */
2742 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2744 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2745 TREE_PURPOSE (tags
) = NULL_TREE
;
2746 tags
= TREE_CHAIN (tags
);
2748 last_cnt
= anon_cnt
;
2751 /* Subroutine of duplicate_decls: return truthvalue of whether
2752 or not types of these decls match.
2754 For C++, we must compare the parameter list so that `int' can match
2755 `int&' in a parameter position, but `int&' is not confused with
2759 decls_match (newdecl
, olddecl
)
2760 tree newdecl
, olddecl
;
2764 if (newdecl
== olddecl
)
2767 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
2768 /* If the two DECLs are not even the same kind of thing, we're not
2769 interested in their types. */
2772 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2774 tree f1
= TREE_TYPE (newdecl
);
2775 tree f2
= TREE_TYPE (olddecl
);
2776 tree p1
= TYPE_ARG_TYPES (f1
);
2777 tree p2
= TYPE_ARG_TYPES (f2
);
2779 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
)
2780 && ! (DECL_LANGUAGE (newdecl
) == lang_c
2781 && DECL_LANGUAGE (olddecl
) == lang_c
))
2784 /* When we parse a static member function definition,
2785 we put together a FUNCTION_DECL which thinks its type
2786 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
2788 if (TREE_CODE (f1
) == METHOD_TYPE
&& DECL_STATIC_FUNCTION_P (olddecl
))
2789 revert_static_member_fn (&newdecl
, &f1
, &p1
);
2790 else if (TREE_CODE (f2
) == METHOD_TYPE
2791 && DECL_STATIC_FUNCTION_P (newdecl
))
2792 revert_static_member_fn (&olddecl
, &f2
, &p2
);
2794 /* Here we must take care of the case where new default
2795 parameters are specified. Also, warn if an old
2796 declaration becomes ambiguous because default
2797 parameters may cause the two to be ambiguous. */
2798 if (TREE_CODE (f1
) != TREE_CODE (f2
))
2800 if (TREE_CODE (f1
) == OFFSET_TYPE
)
2801 cp_compiler_error ("`%D' redeclared as member function", newdecl
);
2803 cp_compiler_error ("`%D' redeclared as non-member function", newdecl
);
2807 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
2809 if (! strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
) == lang_c
2812 types_match
= self_promoting_args_p (p1
);
2813 if (p1
== void_list_node
)
2814 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2816 else if (!strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
)==lang_c
2817 && DECL_LANGUAGE (newdecl
) == lang_c
&& p1
== NULL_TREE
)
2819 types_match
= self_promoting_args_p (p2
);
2820 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2823 types_match
= compparms (p1
, p2
);
2828 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2830 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2831 DECL_TEMPLATE_PARMS (olddecl
)))
2834 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2837 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
2838 DECL_TEMPLATE_RESULT (newdecl
));
2842 if (TREE_TYPE (newdecl
) == error_mark_node
)
2843 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
2844 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
2845 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
2846 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
2849 types_match
= comptypes (TREE_TYPE (newdecl
),
2850 TREE_TYPE (olddecl
),
2851 COMPARE_REDECLARATION
);
2857 /* If NEWDECL is `static' and an `extern' was seen previously,
2858 warn about it. OLDDECL is the previous declaration.
2860 Note that this does not apply to the C++ case of declaring
2861 a variable `extern const' and then later `const'.
2863 Don't complain about built-in functions, since they are beyond
2864 the user's control. */
2867 warn_extern_redeclared_static (newdecl
, olddecl
)
2868 tree newdecl
, olddecl
;
2870 static const char *explicit_extern_static_warning
2871 = "`%D' was declared `extern' and later `static'";
2872 static const char *implicit_extern_static_warning
2873 = "`%D' was declared implicitly `extern' and later `static'";
2877 if (TREE_CODE (newdecl
) == TYPE_DECL
2878 || TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2881 /* Don't get confused by static member functions; that's a different
2883 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2884 && DECL_STATIC_FUNCTION_P (newdecl
))
2887 /* If the old declaration was `static', or the new one isn't, then
2888 then everything is OK. */
2889 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
2892 /* It's OK to declare a builtin function as `static'. */
2893 if (TREE_CODE (olddecl
) == FUNCTION_DECL
2894 && DECL_ARTIFICIAL (olddecl
))
2897 name
= DECL_ASSEMBLER_NAME (newdecl
);
2898 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
2899 ? implicit_extern_static_warning
2900 : explicit_extern_static_warning
, newdecl
);
2901 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
2904 /* Handle when a new declaration NEWDECL has the same name as an old
2905 one OLDDECL in the same binding contour. Prints an error message
2908 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2909 Otherwise, return 0. */
2912 duplicate_decls (newdecl
, olddecl
)
2913 tree newdecl
, olddecl
;
2915 unsigned olddecl_uid
= DECL_UID (olddecl
);
2916 int olddecl_friend
= 0, types_match
= 0;
2917 int new_defines_function
= 0;
2919 if (newdecl
== olddecl
)
2922 types_match
= decls_match (newdecl
, olddecl
);
2924 /* If either the type of the new decl or the type of the old decl is an
2925 error_mark_node, then that implies that we have already issued an
2926 error (earlier) for some bogus type specification, and in that case,
2927 it is rather pointless to harass the user with yet more error message
2928 about the same declaration, so just pretend the types match here. */
2929 if (TREE_TYPE (newdecl
) == error_mark_node
2930 || TREE_TYPE (olddecl
) == error_mark_node
)
2933 /* Check for redeclaration and other discrepancies. */
2934 if (TREE_CODE (olddecl
) == FUNCTION_DECL
2935 && DECL_ARTIFICIAL (olddecl
))
2937 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
2939 /* If you declare a built-in or predefined function name as static,
2940 the old definition is overridden, but optionally warn this was a
2941 bad choice of name. */
2942 if (! TREE_PUBLIC (newdecl
))
2945 cp_warning ("shadowing %s function `%#D'",
2946 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
2948 /* Discard the old built-in function. */
2951 /* If the built-in is not ansi, then programs can override
2952 it even globally without an error. */
2953 else if (! DECL_BUILT_IN (olddecl
))
2954 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2958 cp_error ("declaration of `%#D'", newdecl
);
2959 cp_error ("conflicts with built-in declaration `%#D'",
2964 else if (!types_match
)
2966 if ((DECL_LANGUAGE (newdecl
) == lang_c
2967 && DECL_LANGUAGE (olddecl
) == lang_c
)
2968 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
2969 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
2971 /* A near match; override the builtin. */
2973 if (TREE_PUBLIC (newdecl
))
2975 cp_warning ("new declaration `%#D'", newdecl
);
2976 cp_warning ("ambiguates built-in declaration `%#D'",
2979 else if (warn_shadow
)
2980 cp_warning ("shadowing %s function `%#D'",
2981 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
2985 /* Discard the old built-in function. */
2989 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
2991 /* If a builtin function is redeclared as `static', merge
2992 the declarations, but make the original one static. */
2993 DECL_THIS_STATIC (olddecl
) = 1;
2994 TREE_PUBLIC (olddecl
) = 0;
2996 /* Make the olddeclaration consistent with the new one so that
2997 all remnants of the builtin-ness of this function will be
2999 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3000 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3001 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3002 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl
),
3006 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
3008 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
3009 && TREE_CODE (newdecl
) != TYPE_DECL
3010 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
3011 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
3012 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
3013 && TREE_CODE (olddecl
) != TYPE_DECL
3014 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
3015 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
3018 /* We do nothing special here, because C++ does such nasty
3019 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3020 get shadowed, and know that if we need to find a TYPE_DECL
3021 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3022 slot of the identifier. */
3026 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
3027 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
3028 || (TREE_CODE (olddecl
) == FUNCTION_DECL
3029 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
3032 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
3033 if (TREE_CODE (olddecl
) == TREE_LIST
)
3034 olddecl
= TREE_VALUE (olddecl
);
3035 cp_error_at ("previous declaration of `%#D'", olddecl
);
3037 /* New decl is completely inconsistent with the old one =>
3038 tell caller to replace the old one. */
3042 else if (!types_match
)
3044 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
))
3045 /* These are certainly not duplicate declarations; they're
3046 from different scopes. */
3049 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3051 /* The name of a class template may not be declared to refer to
3052 any other template, class, function, object, namespace, value,
3053 or type in the same scope. */
3054 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
3055 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3057 cp_error ("declaration of template `%#D'", newdecl
);
3058 cp_error_at ("conflicts with previous declaration `%#D'",
3061 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
3062 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
3063 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
3064 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
3065 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3066 DECL_TEMPLATE_PARMS (olddecl
)))
3068 cp_error ("new declaration `%#D'", newdecl
);
3069 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3073 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3075 if (DECL_LANGUAGE (newdecl
) == lang_c
3076 && DECL_LANGUAGE (olddecl
) == lang_c
)
3078 cp_error ("declaration of C function `%#D' conflicts with",
3080 cp_error_at ("previous declaration `%#D' here", olddecl
);
3082 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3083 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3085 cp_error ("new declaration `%#D'", newdecl
);
3086 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3092 /* Already complained about this, so don't do so again. */
3093 else if (current_class_type
== NULL_TREE
3094 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
3096 cp_error ("conflicting types for `%#D'", newdecl
);
3097 cp_error_at ("previous declaration as `%#D'", olddecl
);
3100 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3101 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
3102 && (!DECL_TEMPLATE_INFO (newdecl
)
3103 || (DECL_TI_TEMPLATE (newdecl
)
3104 != DECL_TI_TEMPLATE (olddecl
))))
3105 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
3106 && (!DECL_TEMPLATE_INFO (olddecl
)
3107 || (DECL_TI_TEMPLATE (olddecl
)
3108 != DECL_TI_TEMPLATE (newdecl
))))))
3109 /* It's OK to have a template specialization and a non-template
3110 with the same type, or to have specializations of two
3111 different templates with the same type. Note that if one is a
3112 specialization, and the other is an instantiation of the same
3113 template, that we do not exit at this point. That situation
3114 can occur if we instantiate a template class, and then
3115 specialize one of its methods. This situation is legal, but
3116 the declarations must be merged in the usual way. */
3118 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3119 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
3120 && !DECL_USE_TEMPLATE (newdecl
))
3121 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
3122 && !DECL_USE_TEMPLATE (olddecl
))))
3123 /* One of the declarations is a template instantiation, and the
3124 other is not a template at all. That's OK. */
3126 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
3127 && DECL_NAMESPACE_ALIAS (newdecl
)
3128 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
3129 /* Redeclaration of namespace alias, ignore it. */
3133 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
3136 cp_error (errmsg
, newdecl
);
3137 if (DECL_NAME (olddecl
) != NULL_TREE
)
3138 cp_error_at ((DECL_INITIAL (olddecl
)
3139 && namespace_bindings_p ())
3140 ? "`%#D' previously defined here"
3141 : "`%#D' previously declared here", olddecl
);
3143 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3144 && DECL_INITIAL (olddecl
) != NULL_TREE
3145 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
3146 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
3148 /* Prototype decl follows defn w/o prototype. */
3149 cp_warning_at ("prototype for `%#D'", newdecl
);
3150 cp_warning_at ("follows non-prototype definition here", olddecl
);
3152 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3153 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
3155 /* extern "C" int foo ();
3156 int foo () { bar (); }
3158 if (current_lang_stack
3159 == &VARRAY_TREE (current_lang_base
, 0))
3160 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3163 cp_error_at ("previous declaration of `%#D' with %L linkage",
3164 olddecl
, DECL_LANGUAGE (olddecl
));
3165 cp_error ("conflicts with new declaration with %L linkage",
3166 DECL_LANGUAGE (newdecl
));
3170 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
3172 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
3174 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
3175 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
3178 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
3179 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
3181 for (; t1
&& t1
!= void_list_node
;
3182 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
3183 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
3185 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
3190 cp_pedwarn ("default argument given for parameter %d of `%#D'",
3192 cp_pedwarn_at ("after previous specification in `%#D'",
3198 cp_error ("default argument given for parameter %d of `%#D'",
3200 cp_error_at ("after previous specification in `%#D'",
3205 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
3206 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
3208 cp_warning ("`%#D' was used before it was declared inline",
3210 cp_warning_at ("previous non-inline declaration here",
3216 /* If new decl is `static' and an `extern' was seen previously,
3218 warn_extern_redeclared_static (newdecl
, olddecl
);
3220 /* We have committed to returning 1 at this point. */
3221 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3223 /* Now that functions must hold information normally held
3224 by field decls, there is extra work to do so that
3225 declaration information does not get destroyed during
3227 if (DECL_VINDEX (olddecl
))
3228 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
3229 if (DECL_CONTEXT (olddecl
))
3230 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
3231 if (DECL_CLASS_CONTEXT (olddecl
))
3232 DECL_CLASS_CONTEXT (newdecl
) = DECL_CLASS_CONTEXT (olddecl
);
3233 if (DECL_PENDING_INLINE_INFO (newdecl
) == (struct pending_inline
*)0)
3234 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
3235 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
3236 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
3237 DECL_ABSTRACT_VIRTUAL_P (newdecl
) |= DECL_ABSTRACT_VIRTUAL_P (olddecl
);
3238 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
3239 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
3240 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
3241 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
3243 /* Optionally warn about more than one declaration for the same
3244 name, but don't warn about a function declaration followed by a
3246 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
3247 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
3248 /* Don't warn about extern decl followed by definition. */
3249 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
3250 /* Don't warn about friends, let add_friend take care of it. */
3251 && ! DECL_FRIEND_P (newdecl
))
3253 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
3254 cp_warning_at ("previous declaration of `%D'", olddecl
);
3258 /* Deal with C++: must preserve virtual function table size. */
3259 if (TREE_CODE (olddecl
) == TYPE_DECL
)
3261 register tree newtype
= TREE_TYPE (newdecl
);
3262 register tree oldtype
= TREE_TYPE (olddecl
);
3264 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
3265 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
3267 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
3268 CLASSTYPE_FRIEND_CLASSES (newtype
)
3269 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
3273 /* Copy all the DECL_... slots specified in the new decl
3274 except for any that we copy here from the old type. */
3275 DECL_MACHINE_ATTRIBUTES (newdecl
)
3276 = merge_machine_decl_attributes (olddecl
, newdecl
);
3278 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3280 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl
),
3281 DECL_TEMPLATE_RESULT (olddecl
)))
3282 cp_error ("invalid redeclaration of %D", newdecl
);
3283 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
3284 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
3285 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
3286 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3293 /* Automatically handles default parameters. */
3294 tree oldtype
= TREE_TYPE (olddecl
);
3297 /* Merge the data types specified in the two decls. */
3298 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3300 if (TREE_CODE (newdecl
) == VAR_DECL
)
3301 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3302 /* Do this after calling `common_type' so that default
3303 parameters don't confuse us. */
3304 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3305 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3306 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3308 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3309 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3310 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3311 TYPE_RAISES_EXCEPTIONS (oldtype
));
3313 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3314 && DECL_SOURCE_LINE (olddecl
) != 0
3316 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)),
3317 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
)), 1))
3319 cp_error ("declaration of `%F' throws different exceptions",
3321 cp_error_at ("to previous declaration `%F'", olddecl
);
3324 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3326 /* Lay the type out, unless already done. */
3327 if (! same_type_p (newtype
, oldtype
)
3328 && TREE_TYPE (newdecl
) != error_mark_node
3329 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3330 layout_type (TREE_TYPE (newdecl
));
3332 if ((TREE_CODE (newdecl
) == VAR_DECL
3333 || TREE_CODE (newdecl
) == PARM_DECL
3334 || TREE_CODE (newdecl
) == RESULT_DECL
3335 || TREE_CODE (newdecl
) == FIELD_DECL
3336 || TREE_CODE (newdecl
) == TYPE_DECL
)
3337 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3338 layout_decl (newdecl
, 0);
3340 /* Merge the type qualifiers. */
3341 if (TREE_READONLY (newdecl
))
3342 TREE_READONLY (olddecl
) = 1;
3343 if (TREE_THIS_VOLATILE (newdecl
))
3344 TREE_THIS_VOLATILE (olddecl
) = 1;
3346 /* Merge the initialization information. */
3347 if (DECL_INITIAL (newdecl
) == NULL_TREE
3348 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3350 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3351 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3352 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3353 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
3354 && DECL_LANG_SPECIFIC (newdecl
)
3355 && DECL_LANG_SPECIFIC (olddecl
))
3356 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3359 /* Merge the section attribute.
3360 We want to issue an error if the sections conflict but that must be
3361 done later in decl_attributes since we are called before attributes
3363 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3364 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3366 /* Keep the old rtl since we can safely use it. */
3367 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3369 /* If cannot merge, then use the new type and qualifiers,
3370 and don't preserve the old rtl. */
3373 /* Clean out any memory we had of the old declaration. */
3374 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3376 TREE_VALUE (oldstatic
) = error_mark_node
;
3378 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3379 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3380 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3381 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3384 /* Merge the storage class information. */
3385 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3386 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3387 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
3388 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3389 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3390 if (! DECL_EXTERNAL (olddecl
))
3391 DECL_EXTERNAL (newdecl
) = 0;
3393 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3395 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3396 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3397 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3398 DECL_TEMPLATE_INSTANTIATED (newdecl
)
3399 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
3400 /* Don't really know how much of the language-specific
3401 values we should copy from old to new. */
3402 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3403 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3404 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3405 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3406 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3408 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3409 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3410 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
3411 DECL_BEFRIENDING_CLASSES (newdecl
)
3412 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
3413 DECL_BEFRIENDING_CLASSES (olddecl
));
3416 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3418 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3419 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3421 /* If newdecl is not a specialization, then it is not a
3422 template-related function at all. And that means that we
3423 shoud have exited above, returning 0. */
3424 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3427 if (TREE_USED (olddecl
))
3428 /* From [temp.expl.spec]:
3430 If a template, a member template or the member of a class
3431 template is explicitly specialized then that
3432 specialization shall be declared before the first use of
3433 that specialization that would cause an implicit
3434 instantiation to take place, in every translation unit in
3435 which such a use occurs. */
3436 cp_error ("explicit specialization of %D after first use",
3439 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3441 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3443 /* If either decl says `inline', this fn is inline, unless its
3444 definition was passed already. */
3445 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3446 DECL_INLINE (olddecl
) = 1;
3447 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3451 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3452 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3453 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3455 if (! types_match
|| new_defines_function
)
3457 /* These need to be copied so that the names are available.
3458 Note that if the types do match, we'll preserve inline
3459 info and other bits, but if not, we won't. */
3460 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3461 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3463 if (new_defines_function
)
3464 /* If defining a function declared with other language
3465 linkage, use the previously declared language linkage. */
3466 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3467 else if (types_match
)
3469 /* If redeclaring a builtin function, and not a definition,
3470 it stays built in. */
3471 if (DECL_BUILT_IN (olddecl
))
3473 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
3474 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3475 /* If we're keeping the built-in definition, keep the rtl,
3476 regardless of declaration matches. */
3477 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3480 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3482 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3483 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3484 /* Previously saved insns go together with
3485 the function's previous definition. */
3486 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3487 /* Don't clear out the arguments if we're redefining a function. */
3488 if (DECL_ARGUMENTS (olddecl
))
3489 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3491 if (DECL_LANG_SPECIFIC (olddecl
))
3492 DECL_MAIN_VARIANT (newdecl
) = DECL_MAIN_VARIANT (olddecl
);
3495 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3497 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3500 /* Now preserve various other info from the definition. */
3501 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3502 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3503 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3504 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3506 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3510 function_size
= sizeof (struct tree_decl
);
3512 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3513 (char *) olddecl
+ sizeof (struct tree_common
),
3514 function_size
- sizeof (struct tree_common
));
3516 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3518 /* If newdecl is a template instantiation, it is possible that
3519 the following sequence of events has occurred:
3521 o A friend function was declared in a class template. The
3522 class template was instantiated.
3524 o The instantiation of the friend declaration was
3525 recorded on the instantiation list, and is newdecl.
3527 o Later, however, instantiate_class_template called pushdecl
3528 on the newdecl to perform name injection. But, pushdecl in
3529 turn called duplicate_decls when it discovered that another
3530 declaration of a global function with the same name already
3533 o Here, in duplicate_decls, we decided to clobber newdecl.
3535 If we're going to do that, we'd better make sure that
3536 olddecl, and not newdecl, is on the list of
3537 instantiations so that if we try to do the instantiation
3538 again we won't get the clobbered declaration. */
3540 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3541 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3543 for (; decls
; decls
= TREE_CHAIN (decls
))
3544 if (TREE_VALUE (decls
) == newdecl
)
3545 TREE_VALUE (decls
) = olddecl
;
3550 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3551 (char *) olddecl
+ sizeof (struct tree_common
),
3552 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3553 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3556 DECL_UID (olddecl
) = olddecl_uid
;
3558 DECL_FRIEND_P (olddecl
) = 1;
3560 /* NEWDECL contains the merged attribute lists.
3561 Update OLDDECL to be the same. */
3562 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3567 /* Record a decl-node X as belonging to the current lexical scope.
3568 Check for errors (such as an incompatible declaration for the same
3569 name already seen in the same scope).
3571 Returns either X or an old decl for the same name.
3572 If an old decl is returned, it may have been smashed
3573 to agree with what X says. */
3581 int need_new_binding
;
3583 /* We shouldn't be calling pushdecl when we're generating RTL for a
3584 function that we already did semantic analysis on previously. */
3585 my_friendly_assert (!current_function
|| doing_semantic_analysis_p (),
3588 name
= DECL_ASSEMBLER_NAME (x
);
3589 need_new_binding
= 1;
3591 if (DECL_TEMPLATE_PARM_P (x
))
3592 /* Template parameters have no context; they are not X::T even
3593 when declared within a class or namespace. */
3597 if (current_function_decl
&& x
!= current_function_decl
3598 /* A local declaration for a function doesn't constitute
3600 && !(TREE_CODE (x
) == FUNCTION_DECL
&& !DECL_INITIAL (x
))
3601 /* A local declaration for an `extern' variable is in the
3602 scoped of the current namespace, not the current
3604 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
3605 /* Don't change DECL_CONTEXT of virtual methods. */
3606 && (TREE_CODE (x
) != FUNCTION_DECL
|| !DECL_VIRTUAL_P (x
))
3607 && !DECL_CONTEXT (x
))
3608 DECL_CONTEXT (x
) = current_function_decl
;
3609 if (!DECL_CONTEXT (x
))
3610 DECL_CONTEXT (x
) = FROB_CONTEXT (current_namespace
);
3612 /* If this is the declaration for a namespace-scope function,
3613 but the declaration itself is in a local scope, mark the
3615 if (TREE_CODE (x
) == FUNCTION_DECL
3616 && DECL_NAMESPACE_SCOPE_P (x
)
3617 && current_function_decl
3618 && x
!= current_function_decl
)
3619 DECL_LOCAL_FUNCTION_P (x
) = 1;
3622 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3623 compiler wants to use. */
3624 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
3625 || TREE_CODE (x
) == NAMESPACE_DECL
)
3626 name
= DECL_NAME (x
);
3631 /* Not needed...see below. */
3635 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3636 name
= TREE_OPERAND (name
, 0);
3638 /* Namespace-scoped variables are not found in the current level. */
3639 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
))
3640 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3642 t
= lookup_name_current_level (name
);
3643 if (t
== error_mark_node
)
3645 /* error_mark_node is 0 for a while during initialization! */
3647 cp_error_at ("`%#D' used prior to declaration", x
);
3650 else if (t
!= NULL_TREE
)
3653 /* This is turned off until I have time to do it right (bpk). */
3654 /* With the code below that uses it... */
3655 file
= DECL_SOURCE_FILE (t
);
3656 line
= DECL_SOURCE_LINE (t
);
3658 if (TREE_CODE (t
) == PARM_DECL
)
3660 if (DECL_CONTEXT (t
) == NULL_TREE
)
3661 fatal ("parse errors have confused me too much");
3663 /* Check for duplicate params. */
3664 if (duplicate_decls (x
, t
))
3667 else if (((TREE_CODE (x
) == FUNCTION_DECL
&& DECL_LANGUAGE (x
) == lang_c
)
3668 || DECL_FUNCTION_TEMPLATE_P (x
))
3669 && is_overloaded_fn (t
))
3670 /* Don't do anything just yet. */;
3671 else if (t
== wchar_decl_node
)
3673 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3674 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3676 /* Throw away the redeclaration. */
3679 else if (TREE_CODE (t
) != TREE_CODE (x
))
3681 if (duplicate_decls (x
, t
))
3684 else if (duplicate_decls (x
, t
))
3687 /* This is turned off until I have time to do it right (bpk). */
3689 /* Also warn if they did a prototype with `static' on it, but
3690 then later left the `static' off. */
3691 if (! TREE_PUBLIC (name
) && TREE_PUBLIC (x
))
3693 if (DECL_LANG_SPECIFIC (t
) && DECL_FRIEND_P (t
))
3698 cp_warning ("`static' missing from declaration of `%D'",
3700 warning_with_file_and_line (file
, line
,
3701 "previous declaration of `%s'",
3702 decl_as_string (t
, 0));
3705 /* Now fix things so it'll do what they expect. */
3706 if (current_function_decl
)
3707 TREE_PUBLIC (current_function_decl
) = 0;
3709 /* Due to interference in memory reclamation (X may be
3710 obstack-deallocated at this point), we must guard against
3711 one really special case. [jason: This should be handled
3712 by start_function] */
3713 if (current_function_decl
== x
)
3714 current_function_decl
= t
;
3716 if (TREE_CODE (t
) == TYPE_DECL
)
3717 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3718 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3719 check_default_args (t
);
3723 else if (DECL_MAIN_P (x
))
3725 /* A redeclaration of main, but not a duplicate of the
3730 This function shall not be overloaded. */
3731 cp_error_at ("invalid redeclaration of `%D'", t
);
3732 cp_error ("as `%D'", x
);
3733 /* We don't try to push this declaration since that
3739 check_template_shadow (x
);
3741 /* If this is a function conjured up by the backend, massage it
3742 so it looks friendly. */
3743 if (TREE_CODE (x
) == FUNCTION_DECL
3744 && ! DECL_LANG_SPECIFIC (x
))
3746 retrofit_lang_decl (x
);
3747 DECL_LANGUAGE (x
) = lang_c
;
3750 if (TREE_CODE (x
) == FUNCTION_DECL
&& ! DECL_FUNCTION_MEMBER_P (x
))
3752 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
3755 if (!namespace_bindings_p ())
3756 /* We do not need to create a binding for this name;
3757 push_overloaded_decl will have already done so if
3759 need_new_binding
= 0;
3761 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3763 t
= push_overloaded_decl (x
, PUSH_GLOBAL
);
3765 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
3769 /* If declaring a type as a typedef, copy the type (unless we're
3770 at line 0), and install this TYPE_DECL as the new type's typedef
3771 name. See the extensive comment in ../c-decl.c (pushdecl). */
3772 if (TREE_CODE (x
) == TYPE_DECL
)
3774 tree type
= TREE_TYPE (x
);
3775 if (DECL_SOURCE_LINE (x
) == 0)
3777 if (TYPE_NAME (type
) == 0)
3778 TYPE_NAME (type
) = x
;
3780 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
3781 /* We don't want to copy the type when all we're
3782 doing is making a TYPE_DECL for the purposes of
3784 && (!TYPE_NAME (type
)
3785 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
3787 DECL_ORIGINAL_TYPE (x
) = type
;
3788 type
= build_type_copy (type
);
3789 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
3790 TYPE_NAME (type
) = x
;
3791 TREE_TYPE (x
) = type
;
3794 if (type
!= error_mark_node
3796 && TYPE_IDENTIFIER (type
))
3797 set_identifier_type_value_with_scope (DECL_NAME (x
), type
,
3798 current_binding_level
);
3802 /* Multiple external decls of the same identifier ought to match.
3804 We get warnings about inline functions where they are defined.
3805 We get warnings about other functions from push_overloaded_decl.
3807 Avoid duplicate warnings where they are used. */
3808 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
3812 if (IDENTIFIER_NAMESPACE_VALUE (name
) != NULL_TREE
3813 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name
))
3814 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name
))))
3815 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
3820 /* If different sort of thing, we already gave an error. */
3821 && TREE_CODE (decl
) == TREE_CODE (x
)
3822 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
3824 cp_pedwarn ("type mismatch with previous external decl", x
);
3825 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
3829 /* This name is new in its binding level.
3830 Install the new declaration and return it. */
3831 if (namespace_bindings_p ())
3833 /* Install a global value. */
3835 /* If the first global decl has external linkage,
3836 warn if we later see static one. */
3837 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
3838 TREE_PUBLIC (name
) = 1;
3840 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
3842 /* For an ordinary function, we create a binding from
3843 the mangled name (i.e., NAME) to the DECL. But, for
3844 an `extern "C"' function, the mangled name and the
3845 ordinary name are the same so we need not do this. */
3846 && !(TREE_CODE (x
) == FUNCTION_DECL
&&
3847 DECL_LANGUAGE (x
) == lang_c
))
3849 if (TREE_CODE (x
) == FUNCTION_DECL
)
3851 ((IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
)
3852 || (IDENTIFIER_GLOBAL_VALUE (name
) == x
), 378);
3853 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
3856 /* Don't forget if the function was used via an implicit decl. */
3857 if (IDENTIFIER_IMPLICIT_DECL (name
)
3858 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
3861 /* Don't forget if its address was taken in that way. */
3862 if (IDENTIFIER_IMPLICIT_DECL (name
)
3863 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
3864 TREE_ADDRESSABLE (x
) = 1;
3866 /* Warn about mismatches against previous implicit decl. */
3867 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
3868 /* If this real decl matches the implicit, don't complain. */
3869 && ! (TREE_CODE (x
) == FUNCTION_DECL
3870 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
3872 ("`%D' was previously implicitly declared to return `int'", x
);
3874 /* If new decl is `static' and an `extern' was seen previously,
3876 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
3877 warn_extern_redeclared_static (x
, t
);
3881 /* Here to install a non-global value. */
3882 tree oldlocal
= IDENTIFIER_VALUE (name
);
3883 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
3885 if (need_new_binding
)
3887 push_local_binding (name
, x
, 0);
3888 /* Because push_local_binding will hook X on to the
3889 current_binding_level's name list, we don't want to
3890 do that again below. */
3891 need_new_binding
= 0;
3894 /* If this is a TYPE_DECL, push it into the type value slot. */
3895 if (TREE_CODE (x
) == TYPE_DECL
)
3896 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
),
3897 current_binding_level
);
3899 /* Clear out any TYPE_DECL shadowed by a namespace so that
3900 we won't think this is a type. The C struct hack doesn't
3901 go through namespaces. */
3902 if (TREE_CODE (x
) == NAMESPACE_DECL
)
3903 set_identifier_type_value_with_scope (name
, NULL_TREE
,
3904 current_binding_level
);
3906 /* If this is an extern function declaration, see if we
3907 have a global definition or declaration for the function. */
3908 if (oldlocal
== NULL_TREE
3909 && DECL_EXTERNAL (x
)
3910 && oldglobal
!= NULL_TREE
3911 && TREE_CODE (x
) == FUNCTION_DECL
3912 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
3914 /* We have one. Their types must agree. */
3915 if (decls_match (x
, oldglobal
))
3919 cp_warning ("extern declaration of `%#D' doesn't match", x
);
3920 cp_warning_at ("global declaration `%#D'", oldglobal
);
3923 /* If we have a local external declaration,
3924 and no file-scope declaration has yet been seen,
3925 then if we later have a file-scope decl it must not be static. */
3926 if (oldlocal
== NULL_TREE
3927 && oldglobal
== NULL_TREE
3928 && DECL_EXTERNAL (x
)
3930 TREE_PUBLIC (name
) = 1;
3932 if (DECL_FROM_INLINE (x
))
3933 /* Inline decls shadow nothing. */;
3935 /* Warn if shadowing an argument at the top level of the body. */
3936 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
3937 && TREE_CODE (oldlocal
) == PARM_DECL
3938 /* Don't complain if it's from an enclosing function. */
3939 && DECL_CONTEXT (oldlocal
) == current_function_decl
3940 && TREE_CODE (x
) != PARM_DECL
)
3942 /* Go to where the parms should be and see if we
3944 struct binding_level
*b
= current_binding_level
->level_chain
;
3950 if (b
->parm_flag
== 1)
3951 cp_error ("declaration of `%#D' shadows a parameter", name
);
3953 else if (warn_shadow
&& oldlocal
!= NULL_TREE
3954 && current_binding_level
->is_for_scope
3955 && !DECL_DEAD_FOR_LOCAL (oldlocal
))
3957 warning ("variable `%s' shadows local",
3958 IDENTIFIER_POINTER (name
));
3959 cp_warning_at (" this is the shadowed declaration", oldlocal
);
3961 /* Maybe warn if shadowing something else. */
3962 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
3963 /* No shadow warnings for internally generated vars. */
3964 && ! DECL_ARTIFICIAL (x
)
3965 /* No shadow warnings for vars made for inlining. */
3966 && ! DECL_FROM_INLINE (x
))
3968 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
3969 warning ("declaration of `%s' shadows a parameter",
3970 IDENTIFIER_POINTER (name
));
3971 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
3972 && current_class_ptr
3973 && !TREE_STATIC (name
))
3974 warning ("declaration of `%s' shadows a member of `this'",
3975 IDENTIFIER_POINTER (name
));
3976 else if (oldlocal
!= NULL_TREE
)
3977 warning ("declaration of `%s' shadows previous local",
3978 IDENTIFIER_POINTER (name
));
3979 else if (oldglobal
!= NULL_TREE
)
3980 /* XXX shadow warnings in outer-more namespaces */
3981 warning ("declaration of `%s' shadows global declaration",
3982 IDENTIFIER_POINTER (name
));
3986 if (TREE_CODE (x
) == FUNCTION_DECL
)
3987 check_default_args (x
);
3989 /* Keep count of variables in this level with incomplete type. */
3990 if (TREE_CODE (x
) == VAR_DECL
3991 && TREE_TYPE (x
) != error_mark_node
3992 && ((TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
3993 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
3994 /* RTTI TD entries are created while defining the type_info. */
3995 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
3996 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
3997 current_binding_level
->incomplete
3998 = tree_cons (NULL_TREE
, x
, current_binding_level
->incomplete
);
4001 if (need_new_binding
)
4002 add_decl_to_level (x
,
4003 DECL_NAMESPACE_SCOPE_P (x
)
4004 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
4005 : current_binding_level
);
4010 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4011 caller to set DECL_CONTEXT properly. */
4014 pushdecl_with_scope (x
, level
)
4016 struct binding_level
*level
;
4018 register struct binding_level
*b
;
4019 tree function_decl
= current_function_decl
;
4021 current_function_decl
= NULL_TREE
;
4022 if (level
->parm_flag
== 2)
4024 b
= class_binding_level
;
4025 class_binding_level
= level
;
4026 pushdecl_class_level (x
);
4027 class_binding_level
= b
;
4031 b
= current_binding_level
;
4032 current_binding_level
= level
;
4034 current_binding_level
= b
;
4036 current_function_decl
= function_decl
;
4040 /* Like pushdecl, only it places X in the current namespace,
4044 pushdecl_namespace_level (x
)
4047 register struct binding_level
*b
= current_binding_level
;
4050 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
4052 /* Now, the type_shadowed stack may screw us. Munge it so it does
4054 if (TREE_CODE (x
) == TYPE_DECL
)
4056 tree name
= DECL_NAME (x
);
4058 tree
*ptr
= (tree
*)0;
4059 for (; b
!= global_binding_level
; b
= b
->level_chain
)
4061 tree shadowed
= b
->type_shadowed
;
4062 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
4063 if (TREE_PURPOSE (shadowed
) == name
)
4065 ptr
= &TREE_VALUE (shadowed
);
4066 /* Can't break out of the loop here because sometimes
4067 a binding level will have duplicate bindings for
4068 PT names. It's gross, but I haven't time to fix it. */
4071 newval
= TREE_TYPE (x
);
4072 if (ptr
== (tree
*)0)
4074 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4075 up here if this is changed to an assertion. --KR */
4076 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
4086 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4090 pushdecl_top_level (x
)
4093 push_to_top_level ();
4094 x
= pushdecl_namespace_level (x
);
4095 pop_from_top_level ();
4099 /* Make the declaration of X appear in CLASS scope. */
4102 pushdecl_class_level (x
)
4105 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4106 scope looks for the pre-mangled name. */
4109 if (TREE_CODE (x
) == OVERLOAD
)
4110 x
= OVL_CURRENT (x
);
4111 name
= DECL_NAME (x
);
4115 push_class_level_binding (name
, x
);
4116 if (TREE_CODE (x
) == TYPE_DECL
)
4117 set_identifier_type_value (name
, TREE_TYPE (x
));
4119 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4123 for (f
= TYPE_FIELDS (TREE_TYPE (x
));
4126 pushdecl_class_level (f
);
4130 /* Enter DECL into the symbol table, if that's appropriate. Returns
4131 DECL, or a modified version thereof. */
4134 maybe_push_decl (decl
)
4137 tree type
= TREE_TYPE (decl
);
4139 /* Add this decl to the current binding level, but not if it comes
4140 from another scope, e.g. a static member variable. TEM may equal
4141 DECL or it may be a previous decl of the same name. */
4142 if ((TREE_CODE (decl
) != PARM_DECL
4143 && DECL_CONTEXT (decl
) != NULL_TREE
4144 /* Definitions of namespace members outside their namespace are
4146 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4147 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
4148 || TREE_CODE (type
) == UNKNOWN_TYPE
4149 /* The declaration of a template specialization does not affect
4150 the functions available for overload resolution, so we do not
4152 || (TREE_CODE (decl
) == FUNCTION_DECL
4153 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
4156 return pushdecl (decl
);
4160 /* This function is used to push the mangled decls for nested types into
4161 the appropriate scope. Previously pushdecl_top_level was used, but that
4162 is incorrect for members of local classes. */
4165 pushdecl_nonclass_level (x
)
4168 struct binding_level
*b
= current_binding_level
;
4170 my_friendly_assert (b
->parm_flag
!= 2, 180);
4173 /* Get out of template binding levels */
4174 while (b
->pseudo_global
)
4178 pushdecl_with_scope (x
, b
);
4182 /* Make the declaration(s) of X appear in CLASS scope
4183 under the name NAME. */
4186 push_class_level_binding (name
, x
)
4191 /* The class_binding_level will be NULL if x is a template
4192 parameter name in a member template. */
4193 if (!class_binding_level
)
4196 /* Make sure that this new member does not have the same name
4197 as a template parameter. */
4198 if (TYPE_BEING_DEFINED (current_class_type
))
4199 check_template_shadow (x
);
4201 /* If this declaration shadows a declaration from an enclosing
4202 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4203 we leave this class. Record the shadowed declaration here. */
4204 binding
= IDENTIFIER_BINDING (name
);
4206 && ((TREE_CODE (x
) == OVERLOAD
4207 && BINDING_VALUE (binding
)
4208 && is_overloaded_fn (BINDING_VALUE (binding
)))
4209 || INHERITED_VALUE_BINDING_P (binding
)))
4214 /* If the old binding was from a base class, and was for a tag
4215 name, slide it over to make room for the new binding. The
4216 old binding is still visible if explicitly qualified with a
4218 if (INHERITED_VALUE_BINDING_P (binding
)
4219 && BINDING_VALUE (binding
)
4220 && TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
4221 && DECL_ARTIFICIAL (BINDING_VALUE (binding
))
4222 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
4224 old_decl
= BINDING_TYPE (binding
);
4225 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
4226 BINDING_VALUE (binding
) = NULL_TREE
;
4227 INHERITED_VALUE_BINDING_P (binding
) = 0;
4230 old_decl
= BINDING_VALUE (binding
);
4232 /* There was already a binding for X containing fewer
4233 functions than are named in X. Find the previous
4234 declaration of X on the class-shadowed list, and update it. */
4235 for (shadow
= class_binding_level
->class_shadowed
;
4237 shadow
= TREE_CHAIN (shadow
))
4238 if (TREE_PURPOSE (shadow
) == name
4239 && TREE_TYPE (shadow
) == old_decl
)
4241 BINDING_VALUE (binding
) = x
;
4242 INHERITED_VALUE_BINDING_P (binding
) = 0;
4243 TREE_TYPE (shadow
) = x
;
4248 /* If we didn't replace an existing binding, put the binding on the
4249 stack of bindings for the identifier, and update
4250 IDENTIFIER_CLASS_VALUE. */
4251 if (push_class_binding (name
, x
))
4253 class_binding_level
->class_shadowed
4254 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
4255 class_binding_level
->class_shadowed
);
4256 /* Record the value we are binding NAME to so that we can know
4257 what to pop later. */
4258 TREE_TYPE (class_binding_level
->class_shadowed
) = x
;
4262 /* Insert another USING_DECL into the current binding level,
4263 returning this declaration. If this is a redeclaration,
4264 do nothing and return NULL_TREE. */
4267 push_using_decl (scope
, name
)
4273 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
4274 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
4275 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
4276 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
4280 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
4281 DECL_INITIAL (decl
) = scope
;
4282 TREE_CHAIN (decl
) = current_binding_level
->usings
;
4283 current_binding_level
->usings
= decl
;
4287 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4288 changed (i.e. there was already a directive), or the fresh
4289 TREE_LIST otherwise. */
4292 push_using_directive (used
)
4295 tree ud
= current_binding_level
->using_directives
;
4296 tree iter
, ancestor
;
4298 /* Check if we already have this. */
4299 if (purpose_member (used
, ud
) != NULL_TREE
)
4302 /* Recursively add all namespaces used. */
4303 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4304 push_using_directive (TREE_PURPOSE (iter
));
4306 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4307 ud
= current_binding_level
->using_directives
;
4308 ud
= tree_cons (used
, ancestor
, ud
);
4309 current_binding_level
->using_directives
= ud
;
4313 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4314 other definitions already in place. We get around this by making
4315 the value of the identifier point to a list of all the things that
4316 want to be referenced by that name. It is then up to the users of
4317 that name to decide what to do with that list.
4319 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4320 slot. It is dealt with the same way.
4322 FLAGS is a bitwise-or of the following values:
4323 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4325 PUSH_USING: DECL is being pushed as the result of a using
4328 The value returned may be a previous declaration if we guessed wrong
4329 about what language DECL should belong to (C or C++). Otherwise,
4330 it's always DECL (and never something that's not a _DECL). */
4333 push_overloaded_decl (decl
, flags
)
4337 tree name
= DECL_NAME (decl
);
4340 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
4343 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
4345 old
= lookup_name_current_level (name
);
4349 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4351 tree t
= TREE_TYPE (old
);
4352 if (IS_AGGR_TYPE (t
) && warn_shadow
4353 && (! DECL_IN_SYSTEM_HEADER (decl
)
4354 || ! DECL_IN_SYSTEM_HEADER (old
)))
4355 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4358 else if (is_overloaded_fn (old
))
4362 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4364 tree fn
= OVL_CURRENT (tmp
);
4366 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
4367 && !(flags
& PUSH_USING
)
4368 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
4369 TYPE_ARG_TYPES (TREE_TYPE (decl
))))
4370 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4373 if (duplicate_decls (decl
, fn
))
4379 cp_error_at ("previous non-function declaration `%#D'", old
);
4380 cp_error ("conflicts with function declaration `%#D'", decl
);
4385 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4387 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4388 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
4390 new_binding
= ovl_cons (decl
, old
);
4391 if (flags
& PUSH_USING
)
4392 OVL_USED (new_binding
) = 1;
4395 /* NAME is not ambiguous. */
4399 set_namespace_binding (name
, current_namespace
, new_binding
);
4402 /* We only create an OVERLOAD if there was a previous binding at
4403 this level, or if decl is a template. In the former case, we
4404 need to remove the old binding and replace it with the new
4405 binding. We must also run through the NAMES on the binding
4406 level where the name was bound to update the chain. */
4408 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
4412 for (d
= &BINDING_LEVEL (IDENTIFIER_BINDING (name
))->names
;
4414 d
= &TREE_CHAIN (*d
))
4416 || (TREE_CODE (*d
) == TREE_LIST
4417 && TREE_VALUE (*d
) == old
))
4419 if (TREE_CODE (*d
) == TREE_LIST
)
4420 /* Just replace the old binding with the new. */
4421 TREE_VALUE (*d
) = new_binding
;
4423 /* Build a TREE_LIST to wrap the OVERLOAD. */
4424 *d
= tree_cons (NULL_TREE
, new_binding
,
4427 /* And update the CPLUS_BINDING node. */
4428 BINDING_VALUE (IDENTIFIER_BINDING (name
))
4433 /* We should always find a previous binding in this case. */
4434 my_friendly_abort (0);
4437 /* Install the new binding. */
4438 push_local_binding (name
, new_binding
, flags
);
4444 /* Generate an implicit declaration for identifier FUNCTIONID
4445 as a function of type int (). Print a warning if appropriate. */
4448 implicitly_declare (functionid
)
4453 /* We used to reuse an old implicit decl here,
4454 but this loses with inline functions because it can clobber
4455 the saved decl chains. */
4456 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4458 DECL_EXTERNAL (decl
) = 1;
4459 TREE_PUBLIC (decl
) = 1;
4461 /* ANSI standard says implicit declarations are in the innermost block.
4462 So we record the decl in the standard fashion. */
4464 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4467 /* Only one warning per identifier. */
4468 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4470 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4473 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4478 /* Return zero if the declaration NEWDECL is valid
4479 when the declaration OLDDECL (assumed to be for the same name)
4480 has already been seen.
4481 Otherwise return an error message format string with a %s
4482 where the identifier should go. */
4485 redeclaration_error_message (newdecl
, olddecl
)
4486 tree newdecl
, olddecl
;
4488 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4490 /* Because C++ can put things into name space for free,
4491 constructs like "typedef struct foo { ... } foo"
4492 would look like an erroneous redeclaration. */
4493 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
4496 return "redefinition of `%#D'";
4498 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4500 /* If this is a pure function, its olddecl will actually be
4501 the original initialization to `0' (which we force to call
4502 abort()). Don't complain about redefinition in this case. */
4503 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_ABSTRACT_VIRTUAL_P (olddecl
))
4506 /* If both functions come from different namespaces, this is not
4507 a redeclaration - this is a conflict with a used function. */
4508 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4509 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4510 return "`%D' conflicts with used function";
4512 /* We'll complain about linkage mismatches in
4513 warn_extern_redeclared_static. */
4515 /* Defining the same name twice is no good. */
4516 if (DECL_INITIAL (olddecl
) != NULL_TREE
4517 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4519 if (DECL_NAME (olddecl
) == NULL_TREE
)
4520 return "`%#D' not declared in class";
4522 return "redefinition of `%#D'";
4526 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4528 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4529 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4530 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4531 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4532 && TYPE_SIZE (TREE_TYPE (newdecl
))
4533 && TYPE_SIZE (TREE_TYPE (olddecl
))))
4534 return "redefinition of `%#D'";
4537 else if (toplevel_bindings_p ())
4539 /* Objects declared at top level: */
4540 /* If at least one is a reference, it's ok. */
4541 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4543 /* Reject two definitions. */
4544 return "redefinition of `%#D'";
4548 /* Objects declared with block scope: */
4549 /* Reject two definitions, and reject a definition
4550 together with an external reference. */
4551 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4552 return "redeclaration of `%#D'";
4557 /* Create a new label, named ID. */
4560 make_label_decl (id
, local_p
)
4566 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4568 /* Make sure every label has an rtx. */
4571 DECL_CONTEXT (decl
) = current_function_decl
;
4572 DECL_MODE (decl
) = VOIDmode
;
4573 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
4575 /* Say where one reference is to the label, for the sake of the
4576 error if it is not defined. */
4577 DECL_SOURCE_LINE (decl
) = lineno
;
4578 DECL_SOURCE_FILE (decl
) = input_filename
;
4580 /* Record the fact that this identifier is bound to this label. */
4581 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4583 /* Record this label on the list of used labels so that we can check
4584 at the end of the function to see whether or not the label was
4585 actually defined. */
4586 if ((named_label_uses
== NULL
|| named_label_uses
->label_decl
!= decl
)
4587 && (named_label_uses
== NULL
4588 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4589 || named_label_uses
->label_decl
!= decl
))
4591 struct named_label_list
*new_ent
;
4593 = (struct named_label_list
*)oballoc (sizeof (struct named_label_list
));
4594 new_ent
->label_decl
= decl
;
4595 new_ent
->names_in_scope
= current_binding_level
->names
;
4596 new_ent
->binding_level
= current_binding_level
;
4597 new_ent
->lineno_o_goto
= lineno
;
4598 new_ent
->filename_o_goto
= input_filename
;
4599 new_ent
->next
= named_label_uses
;
4600 named_label_uses
= new_ent
;
4606 /* Look for a label named ID in the current function. If one cannot
4607 be found, create one. (We keep track of used, but undefined,
4608 labels, and complain about them at the end of a function.) */
4616 /* You can't use labels at global scope. */
4617 if (current_function_decl
== NULL_TREE
)
4619 error ("label `%s' referenced outside of any function",
4620 IDENTIFIER_POINTER (id
));
4624 /* See if we've already got this label. */
4625 decl
= IDENTIFIER_LABEL_VALUE (id
);
4626 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
4629 /* Record this label on the list of labels used in this function.
4630 We do this before calling make_label_decl so that we get the
4631 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4632 named_labels
= tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
4634 /* We need a new label. */
4635 decl
= make_label_decl (id
, /*local_p=*/0);
4636 /* Now fill in the information we didn't have before. */
4637 TREE_VALUE (named_labels
) = decl
;
4642 /* Declare a local label named ID. */
4645 declare_local_label (id
)
4650 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4651 this scope we can restore the old value of
4652 IDENTIFIER_TYPE_VALUE. */
4653 current_binding_level
->shadowed_labels
4654 = tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
4655 current_binding_level
->shadowed_labels
);
4656 /* Look for the label. */
4657 decl
= make_label_decl (id
, /*local_p=*/1);
4658 /* Now fill in the information we didn't have before. */
4659 TREE_VALUE (current_binding_level
->shadowed_labels
) = decl
;
4664 /* Define a label, specifying the location in the source file.
4665 Return the LABEL_DECL node for the label, if the definition is valid.
4666 Otherwise return 0. */
4669 define_label (filename
, line
, name
)
4674 tree decl
= lookup_label (name
);
4676 /* After labels, make any new cleanups go into their
4677 own new (temporary) binding contour. */
4678 current_binding_level
->more_cleanups_ok
= 0;
4680 if (name
== get_identifier ("wchar_t"))
4681 cp_pedwarn ("label named wchar_t");
4683 if (DECL_INITIAL (decl
) != NULL_TREE
)
4685 cp_error ("duplicate label `%D'", decl
);
4690 struct named_label_list
*uses
, *prev
;
4694 /* Mark label as having been defined. */
4695 DECL_INITIAL (decl
) = error_mark_node
;
4696 /* Say where in the source. */
4697 DECL_SOURCE_FILE (decl
) = filename
;
4698 DECL_SOURCE_LINE (decl
) = line
;
4701 uses
= named_label_uses
;
4702 while (uses
!= NULL
)
4703 if (uses
->label_decl
== decl
)
4705 struct binding_level
*b
= current_binding_level
;
4708 tree new_decls
= b
->names
;
4709 tree old_decls
= (b
== uses
->binding_level
)
4710 ? uses
->names_in_scope
: NULL_TREE
;
4711 while (new_decls
!= old_decls
)
4713 if (TREE_CODE (new_decls
) == VAR_DECL
4714 /* Don't complain about crossing initialization
4715 of internal entities. They can't be accessed,
4716 and they should be cleaned up
4717 by the time we get to the label. */
4718 && ! DECL_ARTIFICIAL (new_decls
)
4719 && !(DECL_INITIAL (new_decls
) == NULL_TREE
4720 && pod_type_p (TREE_TYPE (new_decls
))))
4722 /* This is really only important if we're crossing
4723 an initialization. The POD stuff is just
4724 pedantry; why should it matter if the class
4725 contains a field of pointer to member type? */
4726 int problem
= (DECL_INITIAL (new_decls
)
4727 || (TYPE_NEEDS_CONSTRUCTING
4728 (TREE_TYPE (new_decls
))));
4734 cp_error ("jump to label `%D'", decl
);
4735 error_with_file_and_line
4736 (uses
->filename_o_goto
,
4737 uses
->lineno_o_goto
, " from here");
4741 cp_pedwarn ("jump to label `%D'", decl
);
4742 pedwarn_with_file_and_line
4743 (uses
->filename_o_goto
,
4744 uses
->lineno_o_goto
, " from here");
4750 cp_error_at (" crosses initialization of `%#D'",
4753 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4756 new_decls
= TREE_CHAIN (new_decls
);
4758 if (b
== uses
->binding_level
)
4760 if (b
->eh_region
&& ! saw_eh
)
4764 cp_error ("jump to label `%D'", decl
);
4765 error_with_file_and_line
4766 (uses
->filename_o_goto
,
4767 uses
->lineno_o_goto
, " from here");
4770 error (" enters exception handling block");
4777 prev
->next
= uses
->next
;
4779 named_label_uses
= uses
->next
;
4788 current_function_return_value
= NULL_TREE
;
4795 struct binding_level
*level
;
4796 struct cp_switch
*next
;
4799 static struct cp_switch
*switch_stack
;
4805 = (struct cp_switch
*) oballoc (sizeof (struct cp_switch
));
4806 p
->level
= current_binding_level
;
4807 p
->next
= switch_stack
;
4814 switch_stack
= switch_stack
->next
;
4817 /* Note that we've seen a definition of a case label, and complain if this
4818 is a bad place for one. */
4821 define_case_label ()
4823 tree cleanup
= last_cleanup_this_contour ();
4824 struct binding_level
*b
= current_binding_level
;
4828 /* Don't crash; we'll complain in do_case. */
4833 static int explained
= 0;
4834 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup
));
4835 warning ("where case label appears here");
4838 warning ("(enclose actions of previous case statements requiring");
4839 warning ("destructors in their own binding contours.)");
4844 for (; b
&& b
!= switch_stack
->level
; b
= b
->level_chain
)
4846 tree new_decls
= b
->names
;
4847 for (; new_decls
; new_decls
= TREE_CHAIN (new_decls
))
4849 if (TREE_CODE (new_decls
) == VAR_DECL
4850 /* Don't complain about crossing initialization
4851 of internal entities. They can't be accessed,
4852 and they should be cleaned up
4853 by the time we get to the label. */
4854 && ! DECL_ARTIFICIAL (new_decls
)
4855 && ((DECL_INITIAL (new_decls
) != NULL_TREE
4856 && DECL_INITIAL (new_decls
) != error_mark_node
)
4857 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
4860 error ("jump to case label");
4862 cp_error_at (" crosses initialization of `%#D'",
4868 /* After labels, make any new cleanups go into their
4869 own new (temporary) binding contour. */
4871 current_binding_level
->more_cleanups_ok
= 0;
4872 current_function_return_value
= NULL_TREE
;
4875 /* Return the list of declarations of the current level.
4876 Note that this list is in reverse order unless/until
4877 you nreverse it; and when you do nreverse it, you must
4878 store the result back using `storedecls' or you will lose. */
4883 return current_binding_level
->names
;
4886 /* Return the list of type-tags (for structs, etc) of the current level. */
4891 return current_binding_level
->tags
;
4894 /* Store the list of declarations of the current level.
4895 This is done for the parameter declarations of a function being defined,
4896 after they are modified in the light of any missing parameters. */
4902 current_binding_level
->names
= decls
;
4905 /* Similarly, store the list of tags of the current level. */
4911 current_binding_level
->tags
= tags
;
4914 /* Given NAME, an IDENTIFIER_NODE,
4915 return the structure (or union or enum) definition for that name.
4916 Searches binding levels from BINDING_LEVEL up to the global level.
4917 If THISLEVEL_ONLY is nonzero, searches only the specified context
4918 (but skips any tag-transparent contexts to find one that is
4919 meaningful for tags).
4920 FORM says which kind of type the caller wants;
4921 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4922 If the wrong kind of type is found, and it's not a template, an error is
4926 lookup_tag (form
, name
, binding_level
, thislevel_only
)
4927 enum tree_code form
;
4929 struct binding_level
*binding_level
;
4932 register struct binding_level
*level
;
4933 /* Non-zero if, we should look past a pseudo-global level, even if
4935 int allow_pseudo_global
= 1;
4937 for (level
= binding_level
; level
; level
= level
->level_chain
)
4940 if (ANON_AGGRNAME_P (name
))
4941 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4943 /* There's no need for error checking here, because
4944 anon names are unique throughout the compilation. */
4945 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
4946 return TREE_VALUE (tail
);
4948 else if (level
->namespace_p
)
4949 /* Do namespace lookup. */
4950 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
4952 tree old
= binding_for_name (name
, tail
);
4954 /* If we just skipped past a pseudo global level, even
4955 though THISLEVEL_ONLY, and we find a template class
4956 declaration, then we use the _TYPE node for the
4957 template. See the example below. */
4958 if (thislevel_only
&& !allow_pseudo_global
4959 && old
&& BINDING_VALUE (old
)
4960 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
4961 old
= TREE_TYPE (BINDING_VALUE (old
));
4963 old
= BINDING_TYPE (old
);
4965 /* If it has an original type, it is a typedef, and we
4966 should not return it. */
4967 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
4969 if (old
&& TREE_CODE (old
) != form
4970 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
4972 cp_error ("`%#D' redeclared as %C", old
, form
);
4977 if (thislevel_only
|| tail
== global_namespace
)
4981 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4983 if (TREE_PURPOSE (tail
) == name
)
4985 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
4986 /* Should tighten this up; it'll probably permit
4987 UNION_TYPE and a struct template, for example. */
4989 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
4991 /* Definition isn't the kind we were looking for. */
4992 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
4996 return TREE_VALUE (tail
);
4999 if (thislevel_only
&& ! level
->tag_transparent
)
5001 if (level
->pseudo_global
&& allow_pseudo_global
)
5003 /* We must deal with cases like this:
5005 template <class T> struct S;
5006 template <class T> struct S {};
5008 When looking up `S', for the second declaration, we
5009 would like to find the first declaration. But, we
5010 are in the pseudo-global level created for the
5011 template parameters, rather than the (surrounding)
5012 namespace level. Thus, we keep going one more level,
5013 even though THISLEVEL_ONLY is non-zero. */
5014 allow_pseudo_global
= 0;
5026 set_current_level_tags_transparency (tags_transparent
)
5027 int tags_transparent
;
5029 current_binding_level
->tag_transparent
= tags_transparent
;
5033 /* Given a type, find the tag that was defined for it and return the tag name.
5034 Otherwise return 0. However, the value can never be 0
5035 in the cases in which this is used.
5037 C++: If NAME is non-zero, this is the new name to install. This is
5038 done when replacing anonymous tags with real tag names. */
5041 lookup_tag_reverse (type
, name
)
5045 register struct binding_level
*level
;
5047 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
5050 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5052 if (TREE_VALUE (tail
) == type
)
5055 TREE_PURPOSE (tail
) = name
;
5056 return TREE_PURPOSE (tail
);
5063 /* Look up NAME in the NAMESPACE. */
5066 lookup_namespace_name (namespace, name
)
5067 tree
namespace, name
;
5070 tree template_id
= NULL_TREE
;
5072 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
5074 if (TREE_CODE (name
) == NAMESPACE_DECL
)
5075 /* This happens for A::B<int> when B is a namespace. */
5077 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
5079 /* This happens for A::B where B is a template, and there are no
5080 template arguments. */
5081 cp_error ("invalid use of `%D'", name
);
5082 return error_mark_node
;
5085 namespace = ORIGINAL_NAMESPACE (namespace);
5087 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5090 name
= TREE_OPERAND (name
, 0);
5091 if (TREE_CODE (name
) == OVERLOAD
)
5092 name
= DECL_NAME (OVL_CURRENT (name
));
5093 else if (TREE_CODE_CLASS (TREE_CODE (name
)) == 'd')
5094 name
= DECL_NAME (name
);
5097 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
5099 val
= make_node (CPLUS_BINDING
);
5100 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
5101 return error_mark_node
;
5103 if (BINDING_VALUE (val
))
5105 val
= BINDING_VALUE (val
);
5109 if (DECL_CLASS_TEMPLATE_P (val
))
5110 val
= lookup_template_class (val
,
5111 TREE_OPERAND (template_id
, 1),
5112 /*in_decl=*/NULL_TREE
,
5113 /*context=*/NULL_TREE
,
5114 /*entering_scope=*/0);
5115 else if (DECL_FUNCTION_TEMPLATE_P (val
)
5116 || TREE_CODE (val
) == OVERLOAD
)
5117 val
= lookup_template_function (val
,
5118 TREE_OPERAND (template_id
, 1));
5121 cp_error ("`%D::%D' is not a template",
5123 return error_mark_node
;
5127 /* If we have a single function from a using decl, pull it out. */
5128 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5129 val
= OVL_FUNCTION (val
);
5133 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
5134 return error_mark_node
;
5137 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5139 static unsigned long
5147 hash
= (((unsigned long) TYPE_CONTEXT (t
))
5148 ^ ((unsigned long) DECL_NAME (TYPE_NAME (t
))));
5153 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5156 typename_compare (k1
, k2
)
5167 d1
= TYPE_NAME (t1
);
5168 d2
= TYPE_NAME (t2
);
5170 return (DECL_NAME (d1
) == DECL_NAME (d2
)
5171 && same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
))
5172 && ((TREE_TYPE (t1
) != NULL_TREE
)
5173 == (TREE_TYPE (t2
) != NULL_TREE
))
5174 && same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
5175 && TYPENAME_TYPE_FULLNAME (t1
) == TYPENAME_TYPE_FULLNAME (t2
));
5178 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5179 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5180 is non-NULL, this type is being created by the implicit typename
5181 extension, and BASE_TYPE is a type named `t' in some base class of
5182 `T' which depends on template parameters.
5184 Returns the new TYPENAME_TYPE. */
5187 build_typename_type (context
, name
, fullname
, base_type
)
5195 struct hash_entry
* e
;
5197 static struct hash_table ht
;
5201 static struct hash_table
*h
= &ht
;
5202 if (!hash_table_init (&ht
, &hash_newfunc
, &typename_hash
,
5204 fatal ("virtual memory exhausted");
5205 ggc_add_tree_hash_table_root (&h
, 1);
5208 /* Build the TYPENAME_TYPE. */
5209 t
= make_lang_type (TYPENAME_TYPE
);
5210 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5211 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
5212 TREE_TYPE (t
) = base_type
;
5214 /* Build the corresponding TYPE_DECL. */
5215 d
= build_decl (TYPE_DECL
, name
, t
);
5216 TYPE_NAME (TREE_TYPE (d
)) = d
;
5217 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
5218 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
5219 DECL_ARTIFICIAL (d
) = 1;
5221 /* See if we already have this type. */
5222 e
= hash_lookup (&ht
, t
, /*create=*/false, /*copy=*/0);
5226 /* Insert the type into the table. */
5227 hash_lookup (&ht
, t
, /*create=*/true, /*copy=*/0);
5232 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
5233 unless an error occurs, in which case error_mark_node is returned.
5234 If COMPLAIN zero, don't complain about any errors that occur. */
5237 make_typename_type (context
, name
, complain
)
5243 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
5245 if (!(TYPE_LANG_SPECIFIC (name
)
5246 && (CLASSTYPE_IS_TEMPLATE (name
)
5247 || CLASSTYPE_USE_TEMPLATE (name
))))
5248 name
= TYPE_IDENTIFIER (name
);
5250 /* Create a TEMPLATE_ID_EXPR for the type. */
5251 name
= build_nt (TEMPLATE_ID_EXPR
,
5252 CLASSTYPE_TI_TEMPLATE (name
),
5253 CLASSTYPE_TI_ARGS (name
));
5255 else if (TREE_CODE (name
) == TYPE_DECL
)
5256 name
= DECL_NAME (name
);
5260 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5262 name
= TREE_OPERAND (name
, 0);
5263 if (TREE_CODE (name
) == TEMPLATE_DECL
)
5264 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
5266 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
5267 my_friendly_abort (2000);
5269 if (TREE_CODE (context
) == NAMESPACE_DECL
)
5271 /* We can get here from typename_sub0 in the explicit_template_type
5272 expansion. Just fail. */
5274 cp_error ("no class template named `%#T' in `%#T'",
5276 return error_mark_node
;
5279 if (! uses_template_parms (context
)
5280 || currently_open_class (context
))
5282 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
5284 tree tmpl
= NULL_TREE
;
5285 if (IS_AGGR_TYPE (context
))
5286 tmpl
= lookup_field (context
, name
, 0, 0);
5287 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
5290 cp_error ("no class template named `%#T' in `%#T'",
5292 return error_mark_node
;
5295 return lookup_template_class (tmpl
,
5296 TREE_OPERAND (fullname
, 1),
5298 /*entering_scope=*/0);
5304 if (!IS_AGGR_TYPE (context
))
5307 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5308 return error_mark_node
;
5311 t
= lookup_field (context
, name
, 0, 1);
5313 return TREE_TYPE (t
);
5317 /* If the CONTEXT is not a template type, then either the field is
5318 there now or its never going to be. */
5319 if (!uses_template_parms (context
))
5322 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5323 return error_mark_node
;
5327 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
5330 /* Select the right _DECL from multiple choices. */
5333 select_decl (binding
, flags
)
5338 val
= BINDING_VALUE (binding
);
5339 if (LOOKUP_NAMESPACES_ONLY (flags
))
5341 /* We are not interested in types. */
5342 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
5347 /* If we could have a type and
5348 we have nothing or we need a type and have none. */
5349 if (BINDING_TYPE (binding
)
5350 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
5351 && TREE_CODE (val
) != TYPE_DECL
)))
5352 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
5353 /* Don't return non-types if we really prefer types. */
5354 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
5355 && (TREE_CODE (val
) != TEMPLATE_DECL
5356 || !DECL_CLASS_TEMPLATE_P (val
)))
5362 /* Unscoped lookup of a global: iterate over current namespaces,
5363 considering using-directives. If SPACESP is non-NULL, store a list
5364 of the namespaces we've considered in it. */
5367 unqualified_namespace_lookup (name
, flags
, spacesp
)
5372 tree b
= make_node (CPLUS_BINDING
);
5373 tree initial
= current_decl_namespace();
5374 tree scope
= initial
;
5376 struct binding_level
*level
;
5377 tree val
= NULL_TREE
;
5380 *spacesp
= NULL_TREE
;
5382 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
5385 *spacesp
= tree_cons (scope
, NULL_TREE
, *spacesp
);
5386 val
= binding_for_name (name
, scope
);
5388 /* Initialize binding for this context. */
5389 BINDING_VALUE (b
) = BINDING_VALUE (val
);
5390 BINDING_TYPE (b
) = BINDING_TYPE (val
);
5392 /* Add all _DECLs seen through local using-directives. */
5393 for (level
= current_binding_level
;
5394 !level
->namespace_p
;
5395 level
= level
->level_chain
)
5396 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
5397 scope
, flags
, spacesp
))
5398 /* Give up because of error. */
5399 return error_mark_node
;
5401 /* Add all _DECLs seen through global using-directives. */
5402 /* XXX local and global using lists should work equally. */
5406 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
5407 scope
, flags
, spacesp
))
5408 /* Give up because of error. */
5409 return error_mark_node
;
5410 if (siter
== scope
) break;
5411 siter
= CP_DECL_CONTEXT (siter
);
5414 val
= select_decl (b
, flags
);
5415 if (scope
== global_namespace
)
5421 /* Combine prefer_type and namespaces_only into flags. */
5424 lookup_flags (prefer_type
, namespaces_only
)
5425 int prefer_type
, namespaces_only
;
5427 if (namespaces_only
)
5428 return LOOKUP_PREFER_NAMESPACES
;
5429 if (prefer_type
> 1)
5430 return LOOKUP_PREFER_TYPES
;
5431 if (prefer_type
> 0)
5432 return LOOKUP_PREFER_BOTH
;
5436 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5437 ignore it or not. Subroutine of lookup_name_real. */
5440 qualify_lookup (val
, flags
)
5444 if (val
== NULL_TREE
)
5446 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5448 if ((flags
& LOOKUP_PREFER_TYPES
)
5449 && (TREE_CODE (val
) == TYPE_DECL
5450 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5451 && DECL_CLASS_TEMPLATE_P (val
))))
5453 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5458 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5462 warn_about_implicit_typename_lookup (typename
, binding
)
5466 tree subtype
= TREE_TYPE (TREE_TYPE (typename
));
5467 tree name
= DECL_NAME (typename
);
5469 if (! (TREE_CODE (binding
) == TEMPLATE_DECL
5470 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5471 && CLASSTYPE_TI_TEMPLATE (subtype
) == binding
)
5472 && ! (TREE_CODE (binding
) == TYPE_DECL
5473 && same_type_p (TREE_TYPE (binding
), subtype
)))
5475 cp_warning ("lookup of `%D' finds `%#D'",
5477 cp_warning (" instead of `%D' from dependent base class",
5479 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5480 constructor_name (current_class_type
), name
);
5484 /* Look up NAME in the current binding level and its superiors in the
5485 namespace of variables, functions and typedefs. Return a ..._DECL
5486 node of some kind representing its definition if there is only one
5487 such declaration, or return a TREE_LIST with all the overloaded
5488 definitions if there are many, or return 0 if it is undefined.
5490 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5491 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5492 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5493 Otherwise we prefer non-TYPE_DECLs.
5495 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5496 using IDENTIFIER_CLASS_VALUE. */
5499 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5501 int prefer_type
, nonclass
, namespaces_only
;
5504 tree val
= NULL_TREE
;
5506 tree from_obj
= NULL_TREE
;
5508 int val_is_implicit_typename
= 0;
5510 /* Hack: copy flag set by parser, if set. */
5511 if (only_namespace_names
)
5512 namespaces_only
= 1;
5514 if (prefer_type
== -2)
5516 extern int looking_for_typename
;
5517 tree type
= NULL_TREE
;
5520 prefer_type
= looking_for_typename
;
5522 flags
= lookup_flags (prefer_type
, namespaces_only
);
5523 /* If the next thing is '<', class templates are types. */
5524 if (looking_for_template
)
5525 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5527 /* std:: becomes :: for now. */
5528 if (got_scope
== std_node
)
5529 got_scope
= void_type_node
;
5533 else if (got_object
!= error_mark_node
)
5538 if (type
== error_mark_node
)
5539 return error_mark_node
;
5540 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5541 type
= TREE_TYPE (type
);
5544 type
= complete_type (type
);
5546 if (TREE_CODE (type
) == VOID_TYPE
)
5547 type
= global_namespace
;
5548 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5550 val
= make_node (CPLUS_BINDING
);
5551 flags
|= LOOKUP_COMPLAIN
;
5552 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5554 val
= select_decl (val
, flags
);
5556 else if (! IS_AGGR_TYPE (type
)
5557 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5558 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
5559 || TREE_CODE (type
) == TYPENAME_TYPE
)
5560 /* Someone else will give an error about this if needed. */
5562 else if (type
== current_class_type
)
5563 val
= IDENTIFIER_CLASS_VALUE (name
);
5565 val
= lookup_member (type
, name
, 0, prefer_type
);
5572 else if (got_object
&& val
)
5577 flags
= lookup_flags (prefer_type
, namespaces_only
);
5578 /* If we're not parsing, we need to complain. */
5579 flags
|= LOOKUP_COMPLAIN
;
5582 /* First, look in non-namespace scopes. */
5584 if (current_class_type
== NULL_TREE
)
5587 for (t
= IDENTIFIER_BINDING (name
); t
; t
= TREE_CHAIN (t
))
5591 if (!LOCAL_BINDING_P (t
) && nonclass
)
5592 /* We're not looking for class-scoped bindings, so keep going. */
5595 /* If this is the kind of thing we're looking for, we're done. */
5596 if (qualify_lookup (BINDING_VALUE (t
), flags
))
5597 binding
= BINDING_VALUE (t
);
5598 else if ((flags
& LOOKUP_PREFER_TYPES
)
5599 && qualify_lookup (BINDING_TYPE (t
), flags
))
5600 binding
= BINDING_TYPE (t
);
5602 binding
= NULL_TREE
;
5605 && (!val
|| !IMPLICIT_TYPENAME_TYPE_DECL_P (binding
)))
5607 if (val_is_implicit_typename
&& !yylex
)
5608 warn_about_implicit_typename_lookup (val
, binding
);
5610 val_is_implicit_typename
5611 = IMPLICIT_TYPENAME_TYPE_DECL_P (val
);
5612 if (!val_is_implicit_typename
)
5617 /* Now lookup in namespace scopes. */
5618 if (!val
|| val_is_implicit_typename
)
5620 t
= unqualified_namespace_lookup (name
, flags
, 0);
5623 if (val_is_implicit_typename
&& !yylex
)
5624 warn_about_implicit_typename_lookup (val
, t
);
5632 /* This should only warn about types used in qualified-ids. */
5633 if (from_obj
&& from_obj
!= val
)
5635 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
5636 && TREE_CODE (val
) == TYPE_DECL
5637 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
5639 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5640 name
, got_object
, TREE_TYPE (from_obj
));
5641 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5645 /* We don't change val to from_obj if got_object depends on
5646 template parms because that breaks implicit typename for
5647 destructor calls. */
5648 if (! uses_template_parms (got_object
))
5652 /* If we have a single function from a using decl, pull it out. */
5653 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5654 val
= OVL_FUNCTION (val
);
5663 lookup_name_nonclass (name
)
5666 return lookup_name_real (name
, 0, 1, 0);
5670 lookup_function_nonclass (name
, args
)
5674 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
5678 lookup_name_namespace_only (name
)
5681 /* type-or-namespace, nonclass, namespace_only */
5682 return lookup_name_real (name
, 1, 1, 1);
5686 lookup_name (name
, prefer_type
)
5690 return lookup_name_real (name
, prefer_type
, 0, 0);
5693 /* Similar to `lookup_name' but look only in the innermost non-class
5697 lookup_name_current_level (name
)
5700 struct binding_level
*b
;
5703 b
= current_binding_level
;
5704 while (b
->parm_flag
== 2)
5709 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5711 /* extern "C" function() */
5712 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5715 else if (IDENTIFIER_BINDING (name
)
5716 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
5720 if (BINDING_LEVEL (IDENTIFIER_BINDING (name
)) == b
)
5721 return IDENTIFIER_VALUE (name
);
5733 /* Like lookup_name_current_level, but for types. */
5736 lookup_type_current_level (name
)
5739 register tree t
= NULL_TREE
;
5741 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
5743 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5744 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5746 struct binding_level
*b
= current_binding_level
;
5749 if (purpose_member (name
, b
->type_shadowed
))
5750 return REAL_IDENTIFIER_TYPE_VALUE (name
);
5762 begin_only_namespace_names ()
5764 only_namespace_names
= 1;
5768 end_only_namespace_names ()
5770 only_namespace_names
= 0;
5773 /* Arrange for the user to get a source line number, even when the
5774 compiler is going down in flames, so that she at least has a
5775 chance of working around problems in the compiler. We used to
5776 call error(), but that let the segmentation fault continue
5777 through; now, it's much more passive by asking them to send the
5778 maintainers mail about the problem. */
5782 int sig ATTRIBUTE_UNUSED
;
5784 signal (SIGSEGV
, SIG_DFL
);
5786 signal (SIGIOT
, SIG_DFL
);
5789 signal (SIGILL
, SIG_DFL
);
5792 signal (SIGABRT
, SIG_DFL
);
5795 signal (SIGBUS
, SIG_DFL
);
5797 my_friendly_abort (0);
5800 /* Push the declarations of builtin types into the namespace.
5801 RID_INDEX, if < RID_MAX is the index of the builtin type
5802 in the array RID_POINTERS. NAME is the name used when looking
5803 up the builtin type. TYPE is the _TYPE node for the builtin type. */
5806 record_builtin_type (rid_index
, name
, type
)
5811 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
5812 tree tdecl
= NULL_TREE
;
5814 if ((int) rid_index
< (int) RID_MAX
)
5815 rname
= ridpointers
[(int) rid_index
];
5817 tname
= get_identifier (name
);
5819 TYPE_BUILT_IN (type
) = 1;
5823 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
5824 set_identifier_type_value (tname
, NULL_TREE
);
5825 if ((int) rid_index
< (int) RID_MAX
)
5826 /* Built-in types live in the global namespace. */
5827 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
5829 if (rname
!= NULL_TREE
)
5831 if (tname
!= NULL_TREE
)
5833 set_identifier_type_value (rname
, NULL_TREE
);
5834 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
5838 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
5839 set_identifier_type_value (rname
, NULL_TREE
);
5844 /* Record one of the standard Java types.
5845 * Declare it as having the given NAME.
5846 * If SIZE > 0, it is the size of one of the integral types;
5847 * otherwise it is the negative of the size of one of the other types. */
5850 record_builtin_java_type (name
, size
)
5856 type
= make_signed_type (size
);
5857 else if (size
> -32)
5858 { /* "__java_char" or ""__java_boolean". */
5859 type
= make_unsigned_type (-size
);
5860 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5863 { /* "__java_float" or ""__java_double". */
5864 type
= make_node (REAL_TYPE
);
5865 TYPE_PRECISION (type
) = - size
;
5868 record_builtin_type (RID_MAX
, name
, type
);
5869 decl
= TYPE_NAME (type
);
5871 /* Suppress generate debug symbol entries for these types,
5872 since for normal C++ they are just clutter.
5873 However, push_lang_context undoes this if extern "Java" is seen. */
5874 DECL_IGNORED_P (decl
) = 1;
5876 TYPE_FOR_JAVA (type
) = 1;
5880 /* Push a type into the namespace so that the back-ends ignore it. */
5883 record_unknown_type (type
, name
)
5887 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
5888 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
5889 DECL_IGNORED_P (decl
) = 1;
5890 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
5891 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
5892 TYPE_ALIGN (type
) = 1;
5893 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
5896 /* Push overloaded decl, in global scope, with one argument so it
5897 can be used as a callback from define_function. */
5900 push_overloaded_decl_1 (x
)
5907 auto_function (name
, type
)
5910 return define_function
5911 (IDENTIFIER_POINTER (name
), type
, push_overloaded_decl_1
,
5912 IDENTIFIER_POINTER (build_decl_overload (name
, TYPE_ARG_TYPES (type
),
5916 /* Create the predefined scalar types of C,
5917 and some nodes representing standard constants (0, 1, (void *)0).
5918 Initialize the global binding level.
5919 Make definitions for built-in primitive functions. */
5922 init_decl_processing ()
5925 int wchar_type_size
;
5926 tree array_domain_type
;
5928 /* Have to make these distinct before we try using them. */
5929 lang_name_cplusplus
= get_identifier ("C++");
5930 lang_name_c
= get_identifier ("C");
5931 lang_name_java
= get_identifier ("Java");
5933 /* Let the back-end now how to save and restore language-specific
5934 per-function globals. */
5935 init_lang_status
= &push_cp_function_context
;
5936 free_lang_status
= &pop_cp_function_context
;
5937 mark_lang_status
= &mark_cp_function_context
;
5943 /* Create the global variables. */
5944 push_to_top_level ();
5946 /* Enter the global namespace. */
5947 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
5948 push_namespace (get_identifier ("::"));
5949 global_namespace
= current_namespace
;
5950 current_lang_name
= NULL_TREE
;
5952 if (flag_strict_prototype
== 2)
5953 flag_strict_prototype
= pedantic
;
5954 if (! flag_permissive
&& ! pedantic
)
5955 flag_pedantic_errors
= 1;
5957 strict_prototypes_lang_c
= flag_strict_prototype
;
5960 current_lang_name
= lang_name_c
;
5962 current_function_decl
= NULL_TREE
;
5963 current_binding_level
= NULL_BINDING_LEVEL
;
5964 free_binding_level
= NULL_BINDING_LEVEL
;
5966 /* Because most segmentation signals can be traced back into user
5967 code, catch them and at least give the user a chance of working
5968 around compiler bugs. */
5969 signal (SIGSEGV
, signal_catch
);
5971 /* We will also catch aborts in the back-end through signal_catch and
5972 give the user a chance to see where the error might be, and to defeat
5973 aborts in the back-end when there have been errors previously in their
5976 signal (SIGIOT
, signal_catch
);
5979 signal (SIGILL
, signal_catch
);
5982 signal (SIGABRT
, signal_catch
);
5985 signal (SIGBUS
, signal_catch
);
5988 build_common_tree_nodes (flag_signed_char
);
5990 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
5991 TREE_TYPE (error_mark_list
) = error_mark_node
;
5993 /* Make the binding_level structure for global names. */
5995 global_binding_level
= current_binding_level
;
5996 /* The global level is the namespace level of ::. */
5997 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
5998 declare_namespace_level ();
6000 this_identifier
= get_identifier (THIS_NAME
);
6001 in_charge_identifier
= get_identifier (IN_CHARGE_NAME
);
6002 ctor_identifier
= get_identifier (CTOR_NAME
);
6003 dtor_identifier
= get_identifier (DTOR_NAME
);
6004 pfn_identifier
= get_identifier (VTABLE_PFN_NAME
);
6005 index_identifier
= get_identifier (VTABLE_INDEX_NAME
);
6006 delta_identifier
= get_identifier (VTABLE_DELTA_NAME
);
6007 delta2_identifier
= get_identifier (VTABLE_DELTA2_NAME
);
6008 pfn_or_delta2_identifier
= get_identifier ("__pfn_or_delta2");
6010 /* Define `int' and `char' first so that dbx will output them first. */
6011 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
6012 record_builtin_type (RID_CHAR
, "char", char_type_node
);
6014 /* `signed' is the same as `int' */
6015 record_builtin_type (RID_SIGNED
, NULL_PTR
, integer_type_node
);
6016 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
6017 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
6018 record_builtin_type (RID_MAX
, "long unsigned int", long_unsigned_type_node
);
6019 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
6020 record_builtin_type (RID_MAX
, "long long int", long_long_integer_type_node
);
6021 record_builtin_type (RID_MAX
, "long long unsigned int",
6022 long_long_unsigned_type_node
);
6023 record_builtin_type (RID_MAX
, "long long unsigned",
6024 long_long_unsigned_type_node
);
6025 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
6026 record_builtin_type (RID_MAX
, "short unsigned int", short_unsigned_type_node
);
6027 record_builtin_type (RID_MAX
, "unsigned short", short_unsigned_type_node
);
6030 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
6032 /* Define both `signed char' and `unsigned char'. */
6033 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
6034 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
6036 /* `unsigned long' is the standard type for sizeof.
6037 Note that stddef.h uses `unsigned long',
6038 and this must agree, even if long and int are the same size. */
6040 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
6042 /* Create the widest literal types. */
6043 widest_integer_literal_type_node
= make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
6044 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6045 widest_integer_literal_type_node
));
6047 widest_unsigned_literal_type_node
= make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
6048 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6049 widest_unsigned_literal_type_node
));
6051 /* These are types that type_for_size and type_for_mode use. */
6052 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
6053 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
6054 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
6055 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
6056 #if HOST_BITS_PER_WIDE_INT >= 64
6057 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
6059 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
6060 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
6061 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
6062 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
6063 #if HOST_BITS_PER_WIDE_INT >= 64
6064 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
6067 build_common_tree_nodes_2 (flag_short_double
);
6069 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
6070 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
6071 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
6072 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
6073 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
6074 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
6075 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
6076 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
6078 integer_two_node
= build_int_2 (2, 0);
6079 TREE_TYPE (integer_two_node
) = integer_type_node
;
6080 integer_three_node
= build_int_2 (3, 0);
6081 TREE_TYPE (integer_three_node
) = integer_type_node
;
6083 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
6084 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
6085 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
6086 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
6087 TYPE_PRECISION (boolean_type_node
) = 1;
6088 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
6089 boolean_false_node
= build_int_2 (0, 0);
6090 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
6091 boolean_true_node
= build_int_2 (1, 0);
6092 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
6094 signed_size_zero_node
= build_int_2 (0, 0); record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
6095 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
6096 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
6098 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
6099 complex_integer_type_node
));
6100 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
6101 complex_float_type_node
));
6102 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
6103 complex_double_type_node
));
6104 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
6105 complex_long_double_type_node
));
6107 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
6109 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
6110 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
6111 TREE_PARMLIST (void_list_node
) = 1;
6113 /* Used for expressions that do nothing, but are not errors. */
6114 void_zero_node
= build_int_2 (0, 0);
6115 TREE_TYPE (void_zero_node
) = void_type_node
;
6117 string_type_node
= build_pointer_type (char_type_node
);
6118 const_string_type_node
6119 = build_pointer_type (build_qualified_type (char_type_node
,
6121 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
6123 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
6126 /* Make a type to be the domain of a few array types
6127 whose domains don't really matter.
6128 200 is small enough that it always fits in size_t
6129 and large enough that it can hold most function names for the
6130 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
6131 array_domain_type
= build_index_type (build_int_2 (200, 0));
6133 /* Make a type for arrays of characters.
6134 With luck nothing will ever really depend on the length of this
6136 char_array_type_node
6137 = build_array_type (char_type_node
, array_domain_type
);
6138 /* Likewise for arrays of ints. */
6140 = build_array_type (integer_type_node
, array_domain_type
);
6142 /* This is just some anonymous class type. Nobody should ever
6143 need to look inside this envelope. */
6144 class_star_type_node
= build_pointer_type (make_lang_type (RECORD_TYPE
));
6146 if (flag_huge_objects
)
6147 delta_type_node
= long_integer_type_node
;
6149 delta_type_node
= short_integer_type_node
;
6151 default_function_type
6152 = build_function_type (integer_type_node
, NULL_TREE
);
6154 ptr_type_node
= build_pointer_type (void_type_node
);
6156 = build_pointer_type (build_qualified_type (void_type_node
,
6158 c_common_nodes_and_builtins (1, flag_no_builtin
, flag_no_nonansi_builtin
);
6159 lang_type_promotes_to
= convert_type_from_ellipsis
;
6162 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6164 /* C++ extensions */
6166 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6167 record_unknown_type (unknown_type_node
, "unknown type");
6169 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6170 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6172 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6174 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6176 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6177 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6179 /* This is special for C++ so functions can be overloaded. */
6180 wchar_type_node
= get_identifier (flag_short_wchar
6181 ? "short unsigned int"
6183 wchar_type_node
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node
));
6184 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6185 signed_wchar_type_node
= make_signed_type (wchar_type_size
);
6186 unsigned_wchar_type_node
= make_unsigned_type (wchar_type_size
);
6188 = TREE_UNSIGNED (wchar_type_node
)
6189 ? unsigned_wchar_type_node
6190 : signed_wchar_type_node
;
6191 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6193 /* Artificial declaration of wchar_t -- can be bashed */
6194 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6196 pushdecl (wchar_decl_node
);
6198 /* This is for wide string constants. */
6199 wchar_array_type_node
6200 = build_array_type (wchar_type_node
, array_domain_type
);
6202 if (flag_vtable_thunks
)
6204 /* Make sure we get a unique function type, so we can give
6205 its pointer type a name. (This wins for gdb.) */
6206 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6207 TREE_TYPE (vfunc_type
) = integer_type_node
;
6208 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6209 layout_type (vfunc_type
);
6211 vtable_entry_type
= build_pointer_type (vfunc_type
);
6215 vtable_entry_type
= make_lang_type (RECORD_TYPE
);
6216 fields
[0] = build_lang_decl (FIELD_DECL
, delta_identifier
,
6218 fields
[1] = build_lang_decl (FIELD_DECL
, index_identifier
,
6220 fields
[2] = build_lang_decl (FIELD_DECL
, pfn_identifier
,
6222 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6225 /* Make this part of an invisible union. */
6226 fields
[3] = copy_node (fields
[2]);
6227 TREE_TYPE (fields
[3]) = delta_type_node
;
6228 DECL_NAME (fields
[3]) = delta2_identifier
;
6229 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6230 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6231 TREE_UNSIGNED (fields
[3]) = 0;
6232 TREE_CHAIN (fields
[2]) = fields
[3];
6233 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6236 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6239 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
6240 layout_type (vtbl_type_node
);
6241 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6242 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6243 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6244 layout_type (vtbl_ptr_type_node
);
6245 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6247 std_node
= build_decl (NAMESPACE_DECL
,
6248 get_identifier (flag_honor_std
? "fake std":"std"),
6250 pushdecl (std_node
);
6252 global_type_node
= make_node (LANG_TYPE
);
6253 record_unknown_type (global_type_node
, "global type");
6256 current_lang_name
= lang_name_cplusplus
;
6259 tree bad_alloc_type_node
, newtype
, deltype
;
6261 push_namespace (get_identifier ("std"));
6262 bad_alloc_type_node
= xref_tag
6263 (class_type_node
, get_identifier ("bad_alloc"), 1);
6266 newtype
= build_exception_variant
6267 (ptr_ftype_sizetype
, add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1));
6268 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6269 auto_function (ansi_opname
[(int) NEW_EXPR
], newtype
);
6270 auto_function (ansi_opname
[(int) VEC_NEW_EXPR
], newtype
);
6271 global_delete_fndecl
= auto_function (ansi_opname
[(int) DELETE_EXPR
],
6273 auto_function (ansi_opname
[(int) VEC_DELETE_EXPR
], deltype
);
6277 = define_function ("__pure_virtual", void_ftype
, 0, 0);
6279 /* Perform other language dependent initializations. */
6280 init_class_processing ();
6281 init_init_processing ();
6282 init_search_processing ();
6283 init_rtti_processing ();
6285 if (flag_exceptions
)
6286 init_exception_processing ();
6289 flag_inline_functions
= 0;
6292 if (! supports_one_only ())
6295 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6296 declare_function_name ();
6298 /* Prepare to check format strings against argument lists. */
6299 init_function_format_info ();
6301 /* Show we use EH for cleanups. */
6302 using_eh_for_cleanups ();
6304 print_error_function
= lang_print_error_function
;
6305 lang_get_alias_set
= &c_get_alias_set
;
6306 valid_lang_attribute
= cp_valid_lang_attribute
;
6308 /* Maintain consistency. Perhaps we should just complain if they
6309 say -fwritable-strings? */
6310 if (flag_writable_strings
)
6311 flag_const_strings
= 0;
6313 /* Add GC roots for all of our global variables. */
6314 ggc_add_tree_root (c_global_trees
, sizeof c_global_trees
/ sizeof(tree
));
6315 ggc_add_tree_root (cp_global_trees
, sizeof cp_global_trees
/ sizeof(tree
));
6316 ggc_add_tree_root (&integer_three_node
, 1);
6317 ggc_add_tree_root (&integer_two_node
, 1);
6318 ggc_add_tree_root (&signed_size_zero_node
, 1);
6319 ggc_add_tree_root (&size_one_node
, 1);
6320 ggc_add_tree_root (&size_zero_node
, 1);
6321 ggc_add_root (&global_binding_level
, 1, sizeof global_binding_level
,
6322 mark_binding_level
);
6323 ggc_add_root (&scope_chain
, 1, sizeof scope_chain
, &mark_saved_scope
);
6324 ggc_add_tree_root (&static_ctors
, 1);
6325 ggc_add_tree_root (&static_dtors
, 1);
6326 ggc_add_tree_root (&lastiddecl
, 1);
6328 ggc_add_tree_root (&last_function_parm_tags
, 1);
6329 ggc_add_tree_root (¤t_function_return_value
, 1);
6330 ggc_add_tree_root (¤t_function_parms
, 1);
6331 ggc_add_tree_root (¤t_function_parm_tags
, 1);
6332 ggc_add_tree_root (&last_function_parms
, 1);
6333 ggc_add_tree_root (&error_mark_list
, 1);
6335 ggc_add_tree_root (&global_namespace
, 1);
6336 ggc_add_tree_root (&global_type_node
, 1);
6337 ggc_add_tree_root (&anonymous_namespace_name
, 1);
6339 ggc_add_tree_root (&got_object
, 1);
6340 ggc_add_tree_root (&got_scope
, 1);
6342 ggc_add_tree_root (¤t_lang_name
, 1);
6343 ggc_add_tree_root (&static_aggregates
, 1);
6346 /* Function to print any language-specific context for an error message. */
6349 lang_print_error_function (file
)
6352 default_print_error_function (file
);
6353 maybe_print_template_context ();
6356 /* Make a definition for a builtin function named NAME and whose data type
6357 is TYPE. TYPE should be a function type with argument types.
6359 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6360 the name to be called if we can't opencode the function. */
6363 define_function (name
, type
, pfn
, library_name
)
6366 void (*pfn
) PROTO((tree
));
6367 const char *library_name
;
6369 tree decl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), type
);
6370 DECL_EXTERNAL (decl
) = 1;
6371 TREE_PUBLIC (decl
) = 1;
6372 DECL_ARTIFICIAL (decl
) = 1;
6374 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6375 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
6377 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6378 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6379 function in the namespace. */
6380 if (pfn
) (*pfn
) (decl
);
6382 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
6383 make_function_rtl (decl
);
6388 /* Wrapper around define_function, for the benefit of
6389 c_common_nodes_and_builtins.
6390 FUNCTION_CODE tells later passes how to compile calls to this function.
6391 See tree.h for its possible values. */
6394 builtin_function (name
, type
, code
, class, libname
)
6398 enum built_in_class
class;
6399 const char *libname
;
6401 tree decl
= define_function (name
, type
, (void (*) PROTO((tree
)))pushdecl
,
6403 DECL_BUILT_IN_CLASS (decl
) = class;
6404 DECL_FUNCTION_CODE (decl
) = code
;
6408 /* When we call finish_struct for an anonymous union, we create
6409 default copy constructors and such. But, an anonymous union
6410 shouldn't have such things; this function undoes the damage to the
6411 anonymous union type T.
6413 (The reason that we create the synthesized methods is that we don't
6414 distinguish `union { int i; }' from `typedef union { int i; } U'.
6415 The first is an anonymous union; the second is just an ordinary
6419 fixup_anonymous_aggr (t
)
6424 /* Wipe out memory of synthesized methods */
6425 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6426 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6427 TYPE_HAS_INIT_REF (t
) = 0;
6428 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6429 TYPE_HAS_ASSIGN_REF (t
) = 0;
6430 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6432 /* Splice the implicitly generated functions out of the TYPE_METHODS
6434 q
= &TYPE_METHODS (t
);
6437 if (DECL_ARTIFICIAL (*q
))
6438 *q
= TREE_CHAIN (*q
);
6440 q
= &TREE_CHAIN (*q
);
6443 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
6444 function members. */
6445 if (TYPE_METHODS (t
))
6446 error ("an anonymous union cannot have function members");
6449 /* Make sure that a declaration with no declarator is well-formed, i.e.
6450 just defines a tagged type or anonymous union.
6452 Returns the type defined, if any. */
6455 check_tag_decl (declspecs
)
6459 tree ob_modifier
= NULL_TREE
;
6461 register tree t
= NULL_TREE
;
6463 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6465 register tree value
= TREE_VALUE (link
);
6471 if (IS_AGGR_TYPE (value
) || TREE_CODE (value
) == ENUMERAL_TYPE
)
6473 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
6477 else if (value
== ridpointers
[(int) RID_FRIEND
])
6479 if (current_class_type
== NULL_TREE
6480 || current_scope () != current_class_type
)
6481 ob_modifier
= value
;
6483 else if (value
== ridpointers
[(int) RID_STATIC
]
6484 || value
== ridpointers
[(int) RID_EXTERN
]
6485 || value
== ridpointers
[(int) RID_AUTO
]
6486 || value
== ridpointers
[(int) RID_REGISTER
]
6487 || value
== ridpointers
[(int) RID_INLINE
]
6488 || value
== ridpointers
[(int) RID_VIRTUAL
]
6489 || value
== ridpointers
[(int) RID_CONST
]
6490 || value
== ridpointers
[(int) RID_VOLATILE
]
6491 || value
== ridpointers
[(int) RID_EXPLICIT
])
6492 ob_modifier
= value
;
6496 error ("multiple types in one declaration");
6498 /* Inside a class, we might be in a friend or access declaration.
6499 Until we have a good way of detecting the latter, don't warn. */
6500 if (t
== NULL_TREE
&& ! current_class_type
)
6501 pedwarn ("declaration does not declare anything");
6503 /* Check for an anonymous union. We're careful
6504 accessing TYPE_IDENTIFIER because some built-in types, like
6505 pointer-to-member types, do not have TYPE_NAME. */
6506 else if (t
&& IS_AGGR_TYPE_CODE (TREE_CODE (t
))
6508 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
6510 /* Anonymous unions are objects, so they can have specifiers. */;
6511 SET_ANON_AGGR_TYPE_P (t
);
6513 if (TREE_CODE (t
) != UNION_TYPE
&& pedantic
&& ! in_system_header
)
6514 pedwarn ("ISO C++ prohibits anonymous structs");
6517 else if (ob_modifier
)
6519 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
6520 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
6521 cp_error ("`%D' can only be specified for functions", ob_modifier
);
6522 else if (ob_modifier
== ridpointers
[(int) RID_FRIEND
])
6523 cp_error ("`%D' can only be specified inside a class", ob_modifier
);
6524 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
6525 cp_error ("`%D' can only be specified for constructors",
6528 cp_error ("`%D' can only be specified for objects and functions",
6535 /* Called when a declaration is seen that contains no names to declare.
6536 If its type is a reference to a structure, union or enum inherited
6537 from a containing scope, shadow that tag name for the current scope
6538 with a forward reference.
6539 If its type defines a new named structure or union
6540 or defines an enum, it is valid but we need not do anything here.
6541 Otherwise, it is an error.
6543 C++: may have to grok the declspecs to learn about static,
6544 complain for anonymous unions. */
6547 shadow_tag (declspecs
)
6550 tree t
= check_tag_decl (declspecs
);
6553 maybe_process_partial_specialization (t
);
6555 /* This is where the variables in an anonymous union are
6556 declared. An anonymous union declaration looks like:
6558 because there is no declarator after the union, the parser
6559 sends that declaration here. */
6560 if (t
&& ANON_AGGR_TYPE_P (t
))
6562 fixup_anonymous_aggr (t
);
6564 if (TYPE_FIELDS (t
))
6566 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
6568 finish_anon_union (decl
);
6573 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6576 groktypename (typename
)
6579 if (TREE_CODE (typename
) != TREE_LIST
)
6581 return grokdeclarator (TREE_VALUE (typename
),
6582 TREE_PURPOSE (typename
),
6583 TYPENAME
, 0, NULL_TREE
);
6586 /* Decode a declarator in an ordinary declaration or data definition.
6587 This is called as soon as the type information and variable name
6588 have been parsed, before parsing the initializer if any.
6589 Here we create the ..._DECL node, fill in its type,
6590 and put it on the list of decls for the current context.
6591 The ..._DECL node is returned as the value.
6593 Exception: for arrays where the length is not specified,
6594 the type is left null, to be filled in by `cp_finish_decl'.
6596 Function definitions do not come here; they go to start_function
6597 instead. However, external and forward declarations of functions
6598 do go through here. Structure field declarations are done by
6599 grokfield and not through here. */
6601 /* Set this to zero to debug not using the temporary obstack
6602 to parse initializers. */
6603 int debug_temp_inits
= 1;
6606 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
6607 tree declarator
, declspecs
;
6609 tree attributes
, prefix_attributes
;
6612 register tree type
, tem
;
6614 extern int have_extern_spec
;
6615 extern int used_extern_spec
;
6619 /* See code below that used this. */
6620 int init_written
= initialized
;
6623 /* This should only be done once on the top most decl. */
6624 if (have_extern_spec
&& !used_extern_spec
)
6626 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
6628 used_extern_spec
= 1;
6631 if (attributes
|| prefix_attributes
)
6632 attrlist
= build_scratch_list (attributes
, prefix_attributes
);
6634 attrlist
= NULL_TREE
;
6636 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
6639 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
6642 type
= TREE_TYPE (decl
);
6644 if (type
== error_mark_node
)
6648 = (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
6649 ? DECL_CLASS_CONTEXT (decl
)
6650 : DECL_CONTEXT (decl
);
6652 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
6653 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
6655 /* When parsing the initializer, lookup should use the object's
6657 push_decl_namespace (context
);
6660 /* We are only interested in class contexts, later. */
6661 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
6662 context
= NULL_TREE
;
6665 /* Is it valid for this decl to have an initializer at all?
6666 If not, set INITIALIZED to zero, which will indirectly
6667 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6668 switch (TREE_CODE (decl
))
6671 /* typedef foo = bar means give foo the same type as bar.
6672 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6673 Any other case of an initialization in a TYPE_DECL is an error. */
6674 if (pedantic
|| list_length (declspecs
) > 1)
6676 cp_error ("typedef `%D' is initialized", decl
);
6682 cp_error ("function `%#D' is initialized like a variable", decl
);
6692 if (! toplevel_bindings_p ()
6693 && DECL_EXTERNAL (decl
))
6694 cp_warning ("declaration of `%#D' has `extern' and is initialized",
6696 DECL_EXTERNAL (decl
) = 0;
6697 if (toplevel_bindings_p ())
6698 TREE_STATIC (decl
) = 1;
6700 /* Tell `pushdecl' this is an initialized decl
6701 even though we don't yet have the initializer expression.
6702 Also tell `cp_finish_decl' it may store the real initializer. */
6703 DECL_INITIAL (decl
) = error_mark_node
;
6706 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6707 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
6710 /* Set attributes here so if duplicate decl, will have proper attributes. */
6711 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
6713 if (context
&& TYPE_SIZE (complete_type (context
)) != NULL_TREE
)
6715 push_nested_class (context
, 2);
6717 if (TREE_CODE (decl
) == VAR_DECL
)
6719 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
6720 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
6721 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
6724 if (DECL_CONTEXT (field
) != context
)
6726 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6727 DECL_CONTEXT (field
), DECL_NAME (decl
),
6728 context
, DECL_NAME (decl
));
6729 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
6731 /* Static data member are tricky; an in-class initialization
6732 still doesn't provide a definition, so the in-class
6733 declaration will have DECL_EXTERNAL set, but will have an
6734 initialization. Thus, duplicate_decls won't warn
6735 about this situation, and so we check here. */
6736 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
6737 cp_error ("duplicate initialization of %D", decl
);
6738 if (duplicate_decls (decl
, field
))
6744 tree field
= check_classfn (context
, decl
);
6745 if (field
&& duplicate_decls (decl
, field
))
6749 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6750 DECL_IN_AGGR_P (decl
) = 0;
6751 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
6752 || CLASSTYPE_USE_TEMPLATE (context
))
6754 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
6755 /* [temp.expl.spec] An explicit specialization of a static data
6756 member of a template is a definition if the declaration
6757 includes an initializer; otherwise, it is a declaration.
6759 We check for processing_specialization so this only applies
6760 to the new specialization syntax. */
6761 if (DECL_INITIAL (decl
) == NULL_TREE
&& processing_specialization
)
6762 DECL_EXTERNAL (decl
) = 1;
6765 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
6766 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6770 /* Enter this declaration into the symbol table. */
6771 tem
= maybe_push_decl (decl
);
6773 if (processing_template_decl
)
6774 tem
= push_template_decl (tem
);
6776 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6777 /* Tell the back-end to use or not use .common as appropriate. If we say
6778 -fconserve-space, we want this to save .data space, at the expense of
6779 wrong semantics. If we say -fno-conserve-space, we want this to
6780 produce errors about redefs; to do this we force variables into the
6782 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
6785 if (! processing_template_decl
)
6795 tree type
= TREE_TYPE (decl
);
6796 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
6798 if (type
== error_mark_node
)
6801 /* If this type of object needs a cleanup, but we're not allowed to
6802 add any more objects with cleanups to the current scope, create a
6803 new binding level. */
6804 if (TYPE_NEEDS_DESTRUCTOR (type
)
6805 && current_binding_level
->more_cleanups_ok
== 0)
6807 keep_next_level (2);
6810 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
6814 /* Is it valid for this decl to have an initializer at all?
6815 If not, set INITIALIZED to zero, which will indirectly
6816 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6818 /* Don't allow initializations for incomplete types except for
6819 arrays which might be completed by the initialization. */
6820 if (TYPE_SIZE (complete_type (type
)) != NULL_TREE
)
6821 ; /* A complete type is ok. */
6822 else if (TREE_CODE (type
) != ARRAY_TYPE
)
6824 cp_error ("variable `%#D' has initializer but incomplete type",
6827 type
= TREE_TYPE (decl
) = error_mark_node
;
6829 else if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6831 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
6832 cp_error ("elements of array `%#D' have incomplete type", decl
);
6833 /* else we already gave an error in start_decl. */
6839 && TREE_CODE (decl
) != TYPE_DECL
6840 && TREE_CODE (decl
) != TEMPLATE_DECL
6841 && IS_AGGR_TYPE (type
) && ! DECL_EXTERNAL (decl
))
6843 if ((! processing_template_decl
|| ! uses_template_parms (type
))
6844 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
6846 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6848 /* Change the type so that assemble_variable will give
6849 DECL an rtl we can live with: (mem (const_int 0)). */
6850 type
= TREE_TYPE (decl
) = error_mark_node
;
6854 /* If any base type in the hierarchy of TYPE needs a constructor,
6855 then we set initialized to 1. This way any nodes which are
6856 created for the purposes of initializing this aggregate
6857 will live as long as it does. This is necessary for global
6858 aggregates which do not have their initializers processed until
6859 the end of the file. */
6860 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
6865 DECL_INITIAL (decl
) = NULL_TREE
;
6868 /* Handle initialization of references.
6869 These three arguments are from `cp_finish_decl', and have the
6870 same meaning here that they do there.
6872 Quotes on semantics can be found in ARM 8.4.3. */
6875 grok_reference_init (decl
, type
, init
)
6876 tree decl
, type
, init
;
6880 if (init
== NULL_TREE
)
6882 if ((DECL_LANG_SPECIFIC (decl
) == 0
6883 || DECL_IN_AGGR_P (decl
) == 0)
6884 && ! DECL_THIS_EXTERN (decl
))
6885 cp_error ("`%D' declared as reference but not initialized", decl
);
6889 if (init
== error_mark_node
)
6892 if (TREE_CODE (init
) == CONSTRUCTOR
)
6894 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl
);
6898 if (TREE_CODE (init
) == TREE_LIST
)
6899 init
= build_compound_expr (init
);
6901 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
6902 init
= convert_from_reference (init
);
6904 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
6905 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
6907 /* Note: default conversion is only called in very special cases. */
6908 init
= default_conversion (init
);
6911 /* Convert INIT to the reference type TYPE. This may involve the
6912 creation of a temporary, whose lifetime must be the same as that
6913 of the reference. If so, a DECL_STMT for the temporary will be
6914 added just after the DECL_STMT for DECL. That's why we don't set
6915 DECL_INITIAL for local references (instead assigning to them
6916 explicitly); we need to allow the temporary to be initialized
6918 tmp
= convert_to_reference
6919 (type
, init
, CONV_IMPLICIT
,
6920 LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
, decl
);
6922 if (tmp
== error_mark_node
)
6924 else if (tmp
!= NULL_TREE
)
6927 tmp
= save_expr (tmp
);
6928 if (building_stmt_tree ())
6930 /* Initialize the declaration. */
6931 tmp
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, tmp
);
6932 finish_expr_stmt (tmp
);
6935 DECL_INITIAL (decl
) = tmp
;
6939 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
6943 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
6945 expand_static_init (decl
, DECL_INITIAL (decl
));
6946 DECL_INITIAL (decl
) = NULL_TREE
;
6951 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6952 mucking with forces it does not comprehend (i.e. initialization with a
6953 constructor). If we are at global scope and won't go into COMMON, fill
6954 it in with a dummy CONSTRUCTOR to force the variable into .data;
6955 otherwise we can use error_mark_node. */
6958 obscure_complex_init (decl
, init
)
6961 if (! flag_no_inline
&& TREE_STATIC (decl
))
6963 if (extract_init (decl
, init
))
6967 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6968 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
6969 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
6973 DECL_INITIAL (decl
) = error_mark_node
;
6978 /* When parsing `int a[] = {1, 2};' we don't know the size of the
6979 array until we finish parsing the initializer. If that's the
6980 situation we're in, update DECL accordingly. */
6983 maybe_deduce_size_from_array_init (decl
, init
)
6987 tree type
= TREE_TYPE (decl
);
6989 if (TREE_CODE (type
) == ARRAY_TYPE
6990 && TYPE_DOMAIN (type
) == NULL_TREE
6991 && TREE_CODE (decl
) != TYPE_DECL
)
6994 = (TREE_STATIC (decl
)
6995 /* Even if pedantic, an external linkage array
6996 may have incomplete type at first. */
6997 ? pedantic
&& ! DECL_EXTERNAL (decl
)
6998 : !DECL_EXTERNAL (decl
));
6999 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7000 int failure
= complete_array_type (type
, initializer
, do_default
);
7003 cp_error ("initializer fails to determine size of `%D'", decl
);
7008 cp_error ("array size missing in `%D'", decl
);
7009 /* If a `static' var's size isn't known, make it extern as
7010 well as static, so it does not get allocated. If it's not
7011 `static', then don't mark it extern; finish_incomplete_decl
7012 will give it a default size and it will get allocated. */
7013 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7014 DECL_EXTERNAL (decl
) = 1;
7017 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7018 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7020 cp_error ("zero-size array `%D'", decl
);
7022 layout_decl (decl
, 0);
7026 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7027 any appropriate error messages regarding the layout. */
7030 layout_var_decl (decl
)
7033 tree type
= TREE_TYPE (decl
);
7035 tree ttype
= target_type (type
);
7038 /* If we haven't already layed out this declaration, do so now.
7039 Note that we must not call complete type for an external object
7040 because it's type might involve templates that we are not
7041 supposed to isntantiate yet. (And it's perfectly legal to say
7042 `extern X x' for some incomplete type `X'.) */
7043 if (!DECL_EXTERNAL (decl
))
7044 complete_type (type
);
7045 if (!DECL_SIZE (decl
)&& TYPE_SIZE (type
))
7046 layout_decl (decl
, 0);
7048 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7050 /* An automatic variable with an incomplete type: that is an error.
7051 Don't talk about array types here, since we took care of that
7052 message in grokdeclarator. */
7053 cp_error ("storage size of `%D' isn't known", decl
);
7054 TREE_TYPE (decl
) = error_mark_node
;
7057 /* Keep this code around in case we later want to control debug info
7058 based on whether a type is "used". (jason 1999-11-11) */
7060 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7061 /* Let debugger know it should output info for this type. */
7062 note_debug_info_needed (ttype
);
7064 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7065 note_debug_info_needed (DECL_CONTEXT (decl
));
7068 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7069 && DECL_SIZE (decl
) != NULL_TREE
7070 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7072 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7073 constant_expression_warning (DECL_SIZE (decl
));
7075 cp_error ("storage size of `%D' isn't constant", decl
);
7079 /* If a local static variable is declared in an inline function, or if
7080 we have a weak definition, we must endeavor to create only one
7081 instance of the variable at link-time. */
7084 maybe_commonize_var (decl
)
7087 /* Static data in a function with comdat linkage also has comdat
7089 if (TREE_STATIC (decl
)
7090 /* Don't mess with __FUNCTION__. */
7091 && ! TREE_ASM_WRITTEN (decl
)
7092 && current_function_decl
7093 && DECL_CONTEXT (decl
) == current_function_decl
7094 && (DECL_THIS_INLINE (current_function_decl
)
7095 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7096 && TREE_PUBLIC (current_function_decl
))
7098 /* Rather than try to get this right with inlining, we suppress
7099 inlining of such functions. */
7100 current_function_cannot_inline
7101 = "function with static variable cannot be inline";
7103 /* If flag_weak, we don't need to mess with this, as we can just
7104 make the function weak, and let it refer to its unique local
7105 copy. This works because we don't allow the function to be
7109 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7111 TREE_PUBLIC (decl
) = 1;
7112 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7114 else if (DECL_INITIAL (decl
) == NULL_TREE
7115 || DECL_INITIAL (decl
) == error_mark_node
)
7117 TREE_PUBLIC (decl
) = 1;
7118 DECL_COMMON (decl
) = 1;
7120 /* else we lose. We can only do this if we can use common,
7121 which we can't if it has been initialized. */
7123 if (TREE_PUBLIC (decl
))
7124 DECL_ASSEMBLER_NAME (decl
)
7125 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7126 else if (! DECL_ARTIFICIAL (decl
))
7128 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7129 cp_warning_at (" you can work around this by removing the initializer", decl
);
7133 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
7134 /* Set it up again; we might have set DECL_INITIAL since the last
7136 comdat_linkage (decl
);
7139 /* Issue an error message if DECL is an uninitialized const variable. */
7142 check_for_uninitialized_const_var (decl
)
7145 tree type
= TREE_TYPE (decl
);
7147 /* ``Unless explicitly declared extern, a const object does not have
7148 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7150 if (TREE_CODE (decl
) == VAR_DECL
7151 && TREE_CODE (type
) != REFERENCE_TYPE
7152 && CP_TYPE_CONST_P (type
)
7153 && !TYPE_NEEDS_CONSTRUCTING (type
)
7154 && !DECL_INITIAL (decl
))
7155 cp_error ("uninitialized const `%D'", decl
);
7158 /* Verify INIT (the initializer for DECL), and record the
7159 initialization in DECL_INITIAL, if appropriate. Returns a new
7163 check_initializer (decl
, init
)
7169 if (TREE_CODE (decl
) == FIELD_DECL
)
7172 type
= TREE_TYPE (decl
);
7174 /* If `start_decl' didn't like having an initialization, ignore it now. */
7175 if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7178 /* Check the initializer. */
7181 /* Things that are going to be initialized need to have complete
7183 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
7185 if (type
== error_mark_node
)
7186 /* We will have already complained. */
7188 else if (TYPE_SIZE (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
7190 cp_error ("variable-sized object `%D' may not be initialized", decl
);
7193 else if (TREE_CODE (type
) == ARRAY_TYPE
7194 && !TYPE_SIZE (TREE_TYPE (type
)))
7196 cp_error ("elements of array `%#D' have incomplete type", decl
);
7199 else if (!TYPE_SIZE (type
))
7201 cp_error ("`%D' has incomplete type", decl
);
7202 TREE_TYPE (decl
) = error_mark_node
;
7207 if (TREE_CODE (decl
) == CONST_DECL
)
7209 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7211 DECL_INITIAL (decl
) = init
;
7213 /* This will keep us from needing to worry about our obstacks. */
7214 my_friendly_assert (init
!= NULL_TREE
, 149);
7217 else if (!DECL_EXTERNAL (decl
) && TREE_CODE (type
) == REFERENCE_TYPE
)
7219 if (TREE_STATIC (decl
))
7220 make_decl_rtl (decl
, NULL_PTR
, toplevel_bindings_p ());
7221 grok_reference_init (decl
, type
, init
);
7226 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7228 if (TREE_CODE (type
) == ARRAY_TYPE
)
7229 init
= digest_init (type
, init
, (tree
*) 0);
7230 else if (TREE_CODE (init
) == CONSTRUCTOR
7231 && TREE_HAS_CONSTRUCTOR (init
))
7233 if (TYPE_NON_AGGREGATE_CLASS (type
))
7235 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7237 init
= error_mark_node
;
7240 goto dont_use_constructor
;
7245 dont_use_constructor
:
7246 if (TREE_CODE (init
) != TREE_VEC
)
7247 init
= store_init_value (decl
, init
);
7251 /* We must hide the initializer so that expand_decl
7252 won't try to do something it does not understand. */
7253 init
= obscure_complex_init (decl
, init
);
7255 else if (DECL_EXTERNAL (decl
))
7257 else if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't'
7258 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7260 tree core_type
= strip_array_types (type
);
7262 if (! TYPE_NEEDS_CONSTRUCTING (core_type
))
7264 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
7265 cp_error ("structure `%D' with uninitialized const members", decl
);
7266 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
7267 cp_error ("structure `%D' with uninitialized reference members",
7271 check_for_uninitialized_const_var (decl
);
7273 if (TYPE_SIZE (type
) != NULL_TREE
7274 && TYPE_NEEDS_CONSTRUCTING (type
))
7275 init
= obscure_complex_init (decl
, NULL_TREE
);
7279 check_for_uninitialized_const_var (decl
);
7284 /* If DECL is not a local variable, give it RTL. */
7287 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
)
7290 const char *asmspec
;
7295 type
= TREE_TYPE (decl
);
7296 toplev
= toplevel_bindings_p ();
7298 /* Handle non-variables up front. */
7299 if (TREE_CODE (decl
) != VAR_DECL
)
7301 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7305 /* Set the DECL_ASSEMBLER_NAME for the variable. */
7307 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7309 if (DECL_VIRTUAL_P (decl
))
7310 make_decl_rtl (decl
, NULL_PTR
, toplev
);
7311 else if (TREE_READONLY (decl
)
7312 && DECL_INITIAL (decl
) != NULL_TREE
7313 && DECL_INITIAL (decl
) != error_mark_node
7314 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7316 DECL_INITIAL (decl
) = save_expr (DECL_INITIAL (decl
));
7318 if (toplev
&& ! TREE_PUBLIC (decl
))
7320 /* If this is a static const, change its apparent linkage
7321 if it belongs to a #pragma interface. */
7322 if (!interface_unknown
)
7324 TREE_PUBLIC (decl
) = 1;
7325 DECL_EXTERNAL (decl
) = interface_only
;
7327 make_decl_rtl (decl
, asmspec
, toplev
);
7330 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7332 else if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
7334 my_friendly_assert (TREE_STATIC (decl
), 19990828);
7336 if (init
== NULL_TREE
7337 #ifdef DEFAULT_STATIC_DEFS
7338 /* If this code is dead, then users must
7339 explicitly declare static member variables
7340 outside the class def'n as well. */
7341 && TYPE_NEEDS_CONSTRUCTING (type
)
7345 DECL_EXTERNAL (decl
) = 1;
7346 make_decl_rtl (decl
, asmspec
, 1);
7349 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7351 else if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == NAMESPACE_DECL
7352 || (TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
)))
7353 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7356 /* Create RTL for the local static variable DECL. */
7359 make_rtl_for_local_static (decl
)
7362 tree type
= TREE_TYPE (decl
);
7363 const char *asmspec
= NULL
;
7365 if (TREE_READONLY (decl
)
7366 && DECL_INITIAL (decl
) != NULL_TREE
7367 && DECL_INITIAL (decl
) != error_mark_node
7368 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
7369 && ! TREE_SIDE_EFFECTS (decl
)
7370 && ! TREE_PUBLIC (decl
)
7371 && ! DECL_EXTERNAL (decl
)
7372 && ! TYPE_NEEDS_DESTRUCTOR (type
)
7373 && ! TREE_ADDRESSABLE (decl
)
7374 && DECL_MODE (decl
) != BLKmode
)
7376 /* As an optimization, we try to put register-sized static
7377 constants in a register, rather than writing them out. If we
7378 take the address of the constant later, we'll make RTL for it
7380 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
7381 store_expr (DECL_INITIAL (decl
), DECL_RTL (decl
), 0);
7382 TREE_ASM_WRITTEN (decl
) = 1;
7386 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
7388 /* The only way this situaton can occur is if the
7389 user specified a name for this DECL using the
7390 `attribute' syntax. */
7391 asmspec
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
7392 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
7395 rest_of_decl_compilation (decl
, asmspec
, /*top_level=*/0, /*at_end=*/0);
7398 /* The old ARM scoping rules injected variables declared in the
7399 initialization statement of a for-statement into the surrounding
7400 scope. We support this usage, in order to be backward-compatible.
7401 DECL is a just-declared VAR_DECL; if necessary inject its
7402 declaration into the surrounding scope. */
7405 maybe_inject_for_scope_var (decl
)
7408 if (current_binding_level
->is_for_scope
)
7410 struct binding_level
*outer
7411 = current_binding_level
->level_chain
;
7413 /* Check to see if the same name is already bound at the outer
7414 level, either because it was directly declared, or because a
7415 dead for-decl got preserved. In either case, the code would
7416 not have been valid under the ARM scope rules, so clear
7417 is_for_scope for the current_binding_level.
7419 Otherwise, we need to preserve the temp slot for decl to last
7420 into the outer binding level. */
7423 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl
)));
7425 if (outer_binding
&& BINDING_LEVEL (outer_binding
) == outer
7426 && (TREE_CODE (BINDING_VALUE (outer_binding
))
7428 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding
)))
7430 BINDING_VALUE (outer_binding
)
7431 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding
));
7432 current_binding_level
->is_for_scope
= 0;
7434 else if (DECL_IN_MEMORY_P (decl
))
7435 preserve_temp_slots (DECL_RTL (decl
));
7439 /* Generate code to initialize DECL (a local variable). */
7442 initialize_local_var (decl
, init
, flags
)
7447 tree type
= TREE_TYPE (decl
);
7449 /* If the type is bogus, don't bother initializing the variable. */
7450 if (type
== error_mark_node
)
7453 if (DECL_SIZE (decl
) == NULL_TREE
&& !TREE_STATIC (decl
))
7455 /* If we used it already as memory, it must stay in memory. */
7456 DECL_INITIAL (decl
) = NULL_TREE
;
7457 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7460 /* Local statics are handled differently from ordinary automatic
7462 if (TREE_STATIC (decl
))
7464 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
7465 || TYPE_NEEDS_DESTRUCTOR (type
))
7466 expand_static_init (decl
, init
);
7470 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7474 /* Compute and store the initial value. */
7475 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7477 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7479 int saved_stmts_are_full_exprs_p
;
7481 emit_line_note (DECL_SOURCE_FILE (decl
),
7482 DECL_SOURCE_LINE (decl
));
7483 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p
;
7484 stmts_are_full_exprs_p
= 1;
7485 finish_expr_stmt (build_aggr_init (decl
, init
, flags
));
7486 stmts_are_full_exprs_p
= saved_stmts_are_full_exprs_p
;
7489 /* Set this to 0 so we can tell whether an aggregate which was
7490 initialized was ever used. Don't do this if it has a
7491 destructor, so we don't complain about the 'resource
7492 allocation is initialization' idiom. Now set
7493 attribute((unused)) on types so decls of that type will be
7494 marked used. (see TREE_USED, above.) */
7495 if (TYPE_NEEDS_CONSTRUCTING (type
)
7497 && !TYPE_NEEDS_DESTRUCTOR (type
)
7498 && DECL_NAME (decl
))
7499 TREE_USED (decl
) = 0;
7500 else if (already_used
)
7501 TREE_USED (decl
) = 1;
7505 /* Generate code to destroy DECL (a local variable). */
7508 destroy_local_var (decl
)
7511 tree type
= TREE_TYPE (decl
);
7514 /* Only variables get cleaned up. */
7515 if (TREE_CODE (decl
) != VAR_DECL
)
7518 /* And only things with destructors need cleaning up. */
7519 if (!TYPE_NEEDS_DESTRUCTOR (type
))
7522 if (TREE_CODE (decl
) == VAR_DECL
&&
7523 (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
)))
7524 /* We don't clean up things that aren't defined in this
7525 translation unit, or that need a static cleanup. The latter
7526 are handled by finish_file. */
7529 /* Compute the cleanup. */
7530 cleanup
= maybe_build_cleanup (decl
);
7532 /* Record the cleanup required for this declaration. */
7533 if (DECL_SIZE (decl
) && TREE_TYPE (decl
) != error_mark_node
7535 finish_decl_cleanup (decl
, cleanup
);
7538 /* Let the back-end know about DECL. */
7541 emit_local_var (decl
)
7544 /* Create RTL for this variable. */
7545 if (DECL_RTL (decl
))
7546 /* Only a RESULT_DECL should have non-NULL RTL when
7547 arriving here. All other local variables are
7548 assigned RTL in this function. */
7549 my_friendly_assert (TREE_CODE (decl
) == RESULT_DECL
,
7553 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
7554 /* The user must have specified an assembler name for this
7555 variable. Set that up now. */
7556 rest_of_decl_compilation
7557 (decl
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
7558 /*top_level=*/0, /*at_end=*/0);
7563 /* Actually do the initialization. */
7564 expand_start_target_temps ();
7565 expand_decl_init (decl
);
7566 expand_end_target_temps ();
7569 /* Finish processing of a declaration;
7570 install its line number and initial value.
7571 If the length of an array type is not known before,
7572 it must be determined now, from the initial value, or it is an error.
7574 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
7575 for aggregates that have constructors alive on the permanent obstack,
7576 so that the global initializing functions can be written at the end.
7578 INIT0 holds the value of an initializer that should be allowed to escape
7581 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7582 if the (init) syntax was used.
7584 For functions that take default parameters, DECL points to its
7585 "maximal" instantiation. `cp_finish_decl' must then also declared its
7586 subsequently lower and lower forms of instantiation, checking for
7587 ambiguity as it goes. This can be sped up later. */
7590 cp_finish_decl (decl
, init
, asmspec_tree
, flags
)
7596 tree ttype
= NULL_TREE
;
7597 const char *asmspec
= NULL
;
7598 int was_readonly
= 0;
7600 /* If this is 0, then we did not change obstacks. */
7604 error ("assignment (not initialization) in declaration");
7608 /* Handling __FUNCTION__ and its ilk in a template-function requires
7609 some special processing because we are called from
7610 language-independent code. */
7611 if (current_function
&& processing_template_decl
7612 && current_function_name_declared
== 2)
7614 /* Since we're in a template function, we need to
7615 push_template_decl. The language-independent code in
7616 declare_hidden_char_array doesn't know to do this. */
7617 retrofit_lang_decl (decl
);
7618 decl
= push_template_decl (decl
);
7620 if (strcmp (IDENTIFIER_POINTER (DECL_NAME (decl
)),
7621 "__PRETTY_FUNCTION__") == 0)
7623 init
= build (FUNCTION_NAME
, const_string_type_node
);
7624 DECL_PRETTY_FUNCTION_P (decl
) = 1;
7628 /* If a name was specified, get the string. */
7630 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
7632 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
7634 cp_error ("Cannot initialize `%D' to namespace `%D'",
7639 if (current_class_type
7640 && DECL_REAL_CONTEXT (decl
) == current_class_type
7641 && TYPE_BEING_DEFINED (current_class_type
)
7642 && (DECL_INITIAL (decl
) || init
))
7643 DECL_DEFINED_IN_CLASS_P (decl
) = 1;
7645 if (TREE_CODE (decl
) == VAR_DECL
7646 && DECL_CONTEXT (decl
)
7647 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
7648 && DECL_CONTEXT (decl
) != current_namespace
7651 /* Leave the namespace of the object. */
7652 pop_decl_namespace ();
7655 type
= TREE_TYPE (decl
);
7657 if (type
== error_mark_node
)
7660 /* Add this declaration to the statement-tree. */
7661 if (building_stmt_tree () && at_function_scope_p ())
7662 add_decl_stmt (decl
);
7664 if (TYPE_HAS_MUTABLE_P (type
))
7665 TREE_READONLY (decl
) = 0;
7667 if (processing_template_decl
)
7669 if (init
&& DECL_INITIAL (decl
))
7670 DECL_INITIAL (decl
) = init
;
7674 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
7675 my_friendly_assert (TREE_CODE (decl
) != PARM_DECL
, 19990828);
7677 /* Take care of TYPE_DECLs up front. */
7678 if (TREE_CODE (decl
) == TYPE_DECL
)
7680 if (init
&& DECL_INITIAL (decl
))
7682 /* typedef foo = bar; store the type of bar as the type of foo. */
7683 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
7684 DECL_INITIAL (decl
) = init
= NULL_TREE
;
7686 if (type
!= error_mark_node
7687 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
7689 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7690 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
7691 set_identifier_type_value (DECL_NAME (decl
), type
);
7692 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
7694 GNU_xref_decl (current_function_decl
, decl
);
7696 /* If we have installed this as the canonical typedef for this
7697 type, and that type has not been defined yet, delay emitting
7698 the debug information for it, as we will emit it later. */
7699 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7700 && TYPE_SIZE (TREE_TYPE (decl
)) == NULL_TREE
)
7701 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
7703 rest_of_decl_compilation (decl
, NULL_PTR
,
7704 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
7708 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7709 ttype
= target_type (type
);
7711 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
7712 && TYPE_NEEDS_CONSTRUCTING (type
))
7714 /* Currently, GNU C++ puts constants in text space, making them
7715 impossible to initialize. In the future, one would hope for
7716 an operating system which understood the difference between
7717 initialization and the running of a program. */
7719 TREE_READONLY (decl
) = 0;
7722 if (TREE_CODE (decl
) == FIELD_DECL
&& asmspec
)
7724 /* This must override the asm specifier which was placed by
7725 grokclassfn. Lay this out fresh. */
7726 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
7727 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7728 make_decl_rtl (decl
, asmspec
, 0);
7731 /* Deduce size of array from initialization, if not already known. */
7732 maybe_deduce_size_from_array_init (decl
, init
);
7733 init
= check_initializer (decl
, init
);
7735 GNU_xref_decl (current_function_decl
, decl
);
7737 if (TREE_CODE (decl
) == VAR_DECL
)
7738 layout_var_decl (decl
);
7740 /* Output the assembler code and/or RTL code for variables and functions,
7741 unless the type is an undefined structure or union.
7742 If not, it will get done when the type is completed. */
7743 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
7744 || TREE_CODE (decl
) == RESULT_DECL
)
7746 if (TREE_CODE (decl
) == VAR_DECL
)
7747 maybe_commonize_var (decl
);
7749 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
7751 if (TREE_CODE (type
) == FUNCTION_TYPE
7752 || TREE_CODE (type
) == METHOD_TYPE
)
7753 abstract_virtuals_error (decl
,
7754 strip_array_types (TREE_TYPE (type
)));
7756 abstract_virtuals_error (decl
, strip_array_types (type
));
7758 if (TREE_CODE (decl
) == FUNCTION_DECL
)
7760 else if (DECL_EXTERNAL (decl
)
7761 && ! (DECL_LANG_SPECIFIC (decl
)
7762 && DECL_NOT_REALLY_EXTERN (decl
)))
7765 DECL_INITIAL (decl
) = init
;
7767 else if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
7769 /* This is a local declaration. */
7770 if (doing_semantic_analysis_p ())
7771 maybe_inject_for_scope_var (decl
);
7772 /* Initialize the local variable. But, if we're building a
7773 statement-tree, we'll do the initialization when we
7775 if (processing_template_decl
)
7777 if (init
|| DECL_INITIAL (decl
) == error_mark_node
)
7778 DECL_INITIAL (decl
) = init
;
7782 /* If we're not building RTL, then we need to do so
7784 if (!building_stmt_tree ())
7785 emit_local_var (decl
);
7786 /* Initialize the variable. */
7787 initialize_local_var (decl
, init
, flags
);
7788 /* Clean up the variable. */
7789 destroy_local_var (decl
);
7792 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
7794 /* Cleanups for static variables are handled by `finish_file'. */
7795 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
7796 || TYPE_NEEDS_DESTRUCTOR (type
))
7797 expand_static_init (decl
, init
);
7801 /* Undo call to `pushclass' that was done in `start_decl'
7802 due to initialization of qualified member variable.
7803 I.e., Foo::x = 10; */
7805 tree context
= DECL_REAL_CONTEXT (decl
);
7807 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't'
7808 && (TREE_CODE (decl
) == VAR_DECL
7809 /* We also have a pushclass done that we need to undo here
7810 if we're at top level and declare a method. */
7811 || TREE_CODE (decl
) == FUNCTION_DECL
)
7812 /* If size hasn't been set, we're still defining it,
7813 and therefore inside the class body; don't pop
7814 the binding level.. */
7815 && TYPE_SIZE (context
) != NULL_TREE
7816 && context
== current_class_type
)
7817 pop_nested_class ();
7823 /* If requested, warn about definitions of large data objects. */
7825 if (warn_larger_than
7826 && ! processing_template_decl
7827 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
7828 && !DECL_EXTERNAL (decl
))
7830 register tree decl_size
= DECL_SIZE (decl
);
7832 if (decl_size
&& TREE_CODE (decl_size
) == INTEGER_CST
)
7834 unsigned units
= TREE_INT_CST_LOW (decl_size
) / BITS_PER_UNIT
;
7836 if (units
> larger_than_size
)
7837 warning_with_decl (decl
, "size of `%s' is %u bytes", units
);
7842 TREE_READONLY (decl
) = 1;
7845 /* This is here for a midend callback from c-common.c */
7848 finish_decl (decl
, init
, asmspec_tree
)
7852 cp_finish_decl (decl
, init
, asmspec_tree
, 0);
7855 /* Generate code to handle the destruction of the function-scoped
7856 static variable DECL. */
7859 destroy_local_static (decl
)
7862 tree cleanup
, fcall
;
7864 int saved_flag_access_control
;
7866 if (atexit_node
== 0)
7868 tree atexit_fndecl
, PFV
, pfvlist
;
7870 PFV
= build_pointer_type (build_function_type
7871 (void_type_node
, void_list_node
));
7873 pfvlist
= tree_cons (NULL_TREE
, PFV
, void_list_node
);
7875 push_lang_context (lang_name_c
);
7876 /* Note that we do not call pushdecl for this function;
7877 there's no reason that this declaration should be
7878 accessible to anyone. */
7880 = define_function ("atexit",
7881 build_function_type (void_type_node
,
7883 /*pfn=*/0, NULL_PTR
);
7884 mark_used (atexit_fndecl
);
7885 atexit_node
= default_conversion (atexit_fndecl
);
7886 pop_lang_context ();
7889 /* Call build_cleanup before we enter the anonymous function so that
7890 any access checks will be done relative to the current scope,
7891 rather than the scope of the anonymous function. */
7892 build_cleanup (decl
);
7894 /* Now start the function. */
7895 cleanup
= start_anon_func ();
7897 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7898 to the original function, rather than the anonymous one. That
7899 will make the back-end think that nested functions are in use,
7900 which causes confusion. */
7901 saved_flag_access_control
= flag_access_control
;
7902 flag_access_control
= 0;
7903 fcall
= build_cleanup (decl
);
7904 flag_access_control
= saved_flag_access_control
;
7906 /* Create the body of the anonymous function. */
7907 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
7908 finish_expr_stmt (fcall
);
7909 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
7912 /* Call atexit with the cleanup function. */
7913 mark_addressable (cleanup
);
7914 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
7915 fcall
= build_function_call (atexit_node
,
7916 tree_cons (NULL_TREE
,
7919 finish_expr_stmt (fcall
);
7923 expand_static_init (decl
, init
)
7927 tree oldstatic
= value_member (decl
, static_aggregates
);
7931 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
7932 cp_error ("multiple initializations given for `%D'", decl
);
7934 else if (! toplevel_bindings_p ())
7936 /* Emit code to perform this initialization but once. */
7943 /* Emit code to perform this initialization but once. This code
7946 static int temp = 0;
7948 // Do initialization.
7950 // Register variable for destruction at end of program.
7953 Note that the `temp' variable is only set to 1 *after* the
7954 initialization is complete. This ensures that an exception,
7955 thrown during the construction, will cause the variable to
7956 reinitialized when we pass through this code again, as per:
7960 If the initialization exits by throwing an exception, the
7961 initialization is not complete, so it will be tried again
7962 the next time control enters the declaration.
7964 In theory, this process should be thread-safe, too; multiple
7965 threads should not be able to initialize the variable more
7966 than once. We don't yet attempt to ensure thread-safety. */
7967 temp
= get_temp_name (integer_type_node
, 1);
7968 rest_of_decl_compilation (temp
, NULL_PTR
, 0, 0);
7970 /* Begin the conditional initialization. */
7971 if_stmt
= begin_if_stmt ();
7972 finish_if_stmt_cond (build_binary_op (EQ_EXPR
, temp
,
7975 then_clause
= begin_compound_stmt (/*has_no_scope=*/0);
7977 /* Do the initialization itself. */
7978 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
7979 || (init
&& TREE_CODE (init
) == TREE_LIST
))
7980 assignment
= build_aggr_init (decl
, init
, 0);
7982 /* The initialization we're doing here is just a bitwise
7984 assignment
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, init
);
7986 assignment
= NULL_TREE
;
7988 /* Once the assignment is complete, set TEMP to 1. Since the
7989 construction of the static object is complete at this point,
7990 we want to make sure TEMP is set to 1 even if a temporary
7991 constructed during the initialization throws an exception
7992 when it is destroyed. So, we combine the initialization and
7993 the assignment to TEMP into a single expression, ensuring
7994 that when we call finish_expr_stmt the cleanups will not be
7995 run until after TEMP is set to 1. */
7996 temp_init
= build_modify_expr (temp
, NOP_EXPR
, integer_one_node
);
7999 assignment
= tree_cons (NULL_TREE
, assignment
,
8000 build_tree_list (NULL_TREE
,
8002 assignment
= build_compound_expr (assignment
);
8005 assignment
= temp_init
;
8006 finish_expr_stmt (assignment
);
8008 /* Use atexit to register a function for destroying this static
8010 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
8011 destroy_local_static (decl
);
8013 finish_compound_stmt (/*has_no_scope=*/0, then_clause
);
8014 finish_then_clause (if_stmt
);
8019 /* This code takes into account memory allocation policy of
8020 `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING does not
8021 hold for this object, then we must make permanent the storage
8022 currently in the temporary obstack. */
8023 if (!TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
8024 preserve_initializer ();
8025 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
8029 /* Finish the declaration of a catch-parameter. */
8032 start_handler_parms (declspecs
, declarator
)
8039 decl
= grokdeclarator (declarator
, declspecs
, CATCHPARM
,
8041 if (decl
== NULL_TREE
)
8042 error ("invalid catch parameter");
8051 /* Make TYPE a complete type based on INITIAL_VALUE.
8052 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8053 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8056 complete_array_type (type
, initial_value
, do_default
)
8057 tree type
, initial_value
;
8060 register tree maxindex
= NULL_TREE
;
8065 /* Note MAXINDEX is really the maximum index,
8066 one less than the size. */
8067 if (TREE_CODE (initial_value
) == STRING_CST
)
8070 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8071 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
8074 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8076 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
8077 maxindex
= size_binop (MINUS_EXPR
, integer_zero_node
, size_one_node
);
8078 for (; elts
; elts
= TREE_CHAIN (elts
))
8080 if (TREE_PURPOSE (elts
))
8081 maxindex
= TREE_PURPOSE (elts
);
8083 maxindex
= size_binop (PLUS_EXPR
, maxindex
, size_one_node
);
8085 maxindex
= copy_node (maxindex
);
8089 /* Make an error message unless that happened already. */
8090 if (initial_value
!= error_mark_node
)
8093 initial_value
= NULL_TREE
;
8095 /* Prevent further error messages. */
8096 maxindex
= build_int_2 (0, 0);
8103 maxindex
= build_int_2 (0, 0);
8112 domain
= build_index_type (maxindex
);
8113 TYPE_DOMAIN (type
) = domain
;
8115 if (! TREE_TYPE (maxindex
))
8116 TREE_TYPE (maxindex
) = domain
;
8118 itype
= TREE_TYPE (initial_value
);
8121 if (itype
&& !TYPE_DOMAIN (itype
))
8122 TYPE_DOMAIN (itype
) = domain
;
8123 /* The type of the main variant should never be used for arrays
8124 of different sizes. It should only ever be completed with the
8125 size of the array. */
8126 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
8127 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = domain
;
8130 /* Lay out the type now that we can get the real answer. */
8137 /* Return zero if something is declared to be a member of type
8138 CTYPE when in the context of CUR_TYPE. STRING is the error
8139 message to print in that case. Otherwise, quietly return 1. */
8142 member_function_or_else (ctype
, cur_type
, string
)
8143 tree ctype
, cur_type
;
8146 if (ctype
&& ctype
!= cur_type
)
8148 error (string
, TYPE_NAME_STRING (ctype
));
8154 /* Subroutine of `grokdeclarator'. */
8156 /* Generate errors possibly applicable for a given set of specifiers.
8157 This is for ARM $7.1.2. */
8160 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
8163 int virtualp
, quals
, friendp
, raises
, inlinep
;
8166 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
8168 cp_error ("`%D' declared as an `inline' %s", object
, type
);
8170 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8173 cp_error_at ("`%D' declared as a friend", object
);
8175 cp_error_at ("`%D' declared with an exception specification", object
);
8178 /* CTYPE is class type, or null if non-class.
8179 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8181 DECLARATOR is the function's name.
8182 VIRTUALP is truthvalue of whether the function is virtual or not.
8183 FLAGS are to be passed through to `grokclassfn'.
8184 QUALS are qualifiers indicating whether the function is `const'
8186 RAISES is a list of exceptions that this function can raise.
8187 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8188 not look, and -1 if we should not call `grokclassfn' at all.
8190 Returns `NULL_TREE' if something goes wrong, after issuing
8191 applicable error messages. */
8194 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8195 raises
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8196 template_count
, in_namespace
)
8199 tree orig_declarator
;
8201 enum overload_flags flags
;
8203 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8207 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8208 int has_default_arg
= 0;
8212 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8213 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8219 type
= build_exception_variant (type
, raises
);
8222 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8223 /* Propagate volatile out from type to decl. */
8224 if (TYPE_VOLATILE (type
))
8225 TREE_THIS_VOLATILE (decl
) = 1;
8227 /* If this decl has namespace scope, set that up. */
8229 set_decl_namespace (decl
, in_namespace
, friendp
);
8230 else if (publicp
&& ! ctype
)
8231 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8233 /* `main' and builtins have implicit 'C' linkage. */
8234 if ((MAIN_NAME_P (declarator
)
8235 || (IDENTIFIER_LENGTH (declarator
) > 10
8236 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8237 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8238 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8239 && current_lang_name
== lang_name_cplusplus
8240 && ctype
== NULL_TREE
8241 /* NULL_TREE means global namespace. */
8242 && DECL_CONTEXT (decl
) == NULL_TREE
)
8243 DECL_LANGUAGE (decl
) = lang_c
;
8245 /* Should probably propagate const out from type to decl I bet (mrs). */
8248 DECL_STATIC_FUNCTION_P (decl
) = 1;
8249 DECL_CONTEXT (decl
) = ctype
;
8253 DECL_CLASS_CONTEXT (decl
) = ctype
;
8255 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8257 if (processing_template_decl
)
8258 error ("cannot declare `main' to be a template");
8260 error ("cannot declare `main' to be inline");
8262 error ("cannot declare `main' to be static");
8267 /* Members of anonymous types and local classes have no linkage; make
8269 if (ctype
&& (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
))
8270 || hack_decl_function_context (TYPE_MAIN_DECL (ctype
))))
8275 /* [basic.link]: A name with no linkage (notably, the name of a class
8276 or enumeration declared in a local scope) shall not be used to
8277 declare an entity with linkage.
8279 Only check this for public decls for now. */
8280 t
= no_linkage_check (TREE_TYPE (decl
));
8283 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8285 if (DECL_LANGUAGE (decl
) == lang_c
)
8286 /* Allow this; it's pretty common in C. */;
8288 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8292 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8297 TREE_PUBLIC (decl
) = publicp
;
8300 DECL_INTERFACE_KNOWN (decl
) = 1;
8301 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8305 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8307 DECL_EXTERNAL (decl
) = 1;
8308 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8310 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8311 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8315 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8316 grok_op_properties (decl
, virtualp
, check
< 0);
8318 if (ctype
&& hack_decl_function_context (decl
))
8319 DECL_NO_STATIC_CHAIN (decl
) = 1;
8321 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8322 if (TREE_PURPOSE (t
)
8323 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8325 has_default_arg
= 1;
8330 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8334 ("defining explicit specialization `%D' in friend declaration",
8338 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8340 /* Something like `template <class T> friend void f<T>()'. */
8341 cp_error ("template-id `%D' in declaration of primary template",
8347 /* A friend declaration of the form friend void f<>(). Record
8348 the information in the TEMPLATE_ID_EXPR. */
8349 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8350 DECL_TEMPLATE_INFO (decl
)
8351 = tree_cons (TREE_OPERAND (orig_declarator
, 0),
8352 TREE_OPERAND (orig_declarator
, 1),
8355 if (has_default_arg
)
8357 cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8364 cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8371 if (has_default_arg
)
8372 add_defarg_fn (decl
);
8374 /* Plain overloading: will not be grok'd by grokclassfn. */
8375 if (! ctype
&& ! processing_template_decl
8376 && DECL_LANGUAGE (decl
) != lang_c
8377 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
8378 set_mangled_name_for_decl (decl
);
8381 /* Make the init_value nonzero so pushdecl knows this is not
8382 tentative. error_mark_node is replaced later with the BLOCK. */
8383 DECL_INITIAL (decl
) = error_mark_node
;
8385 /* Caller will do the rest of this. */
8389 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8392 /* Just handle constructors here. We could do this
8393 inside the following if stmt, but I think
8394 that the code is more legible by breaking this
8395 case out. See comments below for what each of
8396 the following calls is supposed to do. */
8397 DECL_CONSTRUCTOR_P (decl
) = 1;
8399 grokclassfn (ctype
, decl
, flags
, quals
);
8401 decl
= check_explicit_specialization (orig_declarator
, decl
,
8403 2 * (funcdef_flag
!= 0) +
8404 4 * (friendp
!= 0));
8405 if (decl
== error_mark_node
)
8408 if ((! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8411 tmp
= check_classfn (ctype
, decl
);
8413 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8414 tmp
= DECL_TEMPLATE_RESULT(tmp
);
8416 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8417 cp_error ("definition of implicitly-declared `%D'", tmp
);
8418 if (tmp
&& duplicate_decls (decl
, tmp
))
8421 if (! grok_ctor_properties (ctype
, decl
))
8428 /* Function gets the ugly name, field gets the nice one.
8429 This call may change the type of the function (because
8430 of default parameters)! */
8431 if (ctype
!= NULL_TREE
)
8432 grokclassfn (ctype
, decl
, flags
, quals
);
8434 decl
= check_explicit_specialization (orig_declarator
, decl
,
8436 2 * (funcdef_flag
!= 0) +
8437 4 * (friendp
!= 0));
8438 if (decl
== error_mark_node
)
8441 if (ctype
!= NULL_TREE
8442 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8445 tmp
= check_classfn (ctype
, decl
);
8447 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8448 tmp
= DECL_TEMPLATE_RESULT (tmp
);
8450 if (tmp
&& DECL_STATIC_FUNCTION_P (tmp
)
8451 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8453 /* Remove the `this' parm added by grokclassfn.
8454 XXX Isn't this done in start_function, too? */
8455 revert_static_member_fn (&decl
, NULL
, NULL
);
8456 last_function_parms
= TREE_CHAIN (last_function_parms
);
8458 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8459 cp_error ("definition of implicitly-declared `%D'", tmp
);
8462 /* Attempt to merge the declarations. This can fail, in
8463 the case of some illegal specialization declarations. */
8464 if (!duplicate_decls (decl
, tmp
))
8465 cp_error ("no `%#D' member function declared in class `%T'",
8471 if (ctype
== NULL_TREE
|| check
)
8476 DECL_VIRTUAL_P (decl
) = 1;
8477 if (DECL_VINDEX (decl
) == NULL_TREE
)
8478 DECL_VINDEX (decl
) = error_mark_node
;
8479 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
8486 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
8489 RID_BIT_TYPE
*specbits_in
;
8495 RID_BIT_TYPE specbits
;
8497 specbits
= *specbits_in
;
8499 if (TREE_CODE (type
) == OFFSET_TYPE
)
8501 /* If you declare a static member so that it
8502 can be initialized, the code will reach here. */
8503 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
8504 type
= TREE_TYPE (type
);
8505 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
8506 DECL_CONTEXT (decl
) = basetype
;
8507 DECL_CLASS_CONTEXT (decl
) = basetype
;
8508 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
, declarator
);
8515 context
= in_namespace
;
8516 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
8517 context
= current_namespace
;
8519 context
= NULL_TREE
;
8521 if (processing_template_decl
)
8522 /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8523 we can call push_template_decl. */
8524 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
8526 decl
= build_decl (VAR_DECL
, declarator
, type
);
8529 set_decl_namespace (decl
, context
, 0);
8531 context
= DECL_CONTEXT (decl
);
8532 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
8533 DECL_ASSEMBLER_NAME (decl
) = build_static_name (context
, declarator
);
8537 set_decl_namespace (decl
, in_namespace
, 0);
8539 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
8541 DECL_THIS_EXTERN (decl
) = 1;
8542 DECL_EXTERNAL (decl
) = !initialized
;
8545 /* In class context, static means one per class,
8546 public access, and static storage. */
8547 if (DECL_CLASS_SCOPE_P (decl
))
8549 TREE_PUBLIC (decl
) = 1;
8550 TREE_STATIC (decl
) = 1;
8551 DECL_EXTERNAL (decl
) = 0;
8553 /* At top level, either `static' or no s.c. makes a definition
8554 (perhaps tentative), and absence of `static' makes it public. */
8555 else if (toplevel_bindings_p ())
8557 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
8558 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8559 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8561 /* Not at top level, only `static' makes a static definition. */
8564 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
8565 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8568 if (TREE_PUBLIC (decl
))
8570 /* [basic.link]: A name with no linkage (notably, the name of a class
8571 or enumeration declared in a local scope) shall not be used to
8572 declare an entity with linkage.
8574 Only check this for public decls for now. */
8575 tree t
= no_linkage_check (TREE_TYPE (decl
));
8578 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8579 /* Ignore for now; `enum { foo } e' is pretty common. */;
8581 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8589 /* Create and return a canonical pointer to member function type, for
8590 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8593 build_ptrmemfunc_type (type
)
8599 tree unqualified_variant
= NULL_TREE
;
8601 /* If a canonical type already exists for this type, use it. We use
8602 this method instead of type_hash_canon, because it only does a
8603 simple equality check on the list of field members. */
8605 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8608 /* Make sure that we always have the unqualified pointer-to-member
8610 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
8612 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8614 u
= make_lang_type (UNION_TYPE
);
8615 SET_IS_AGGR_TYPE (u
, 0);
8616 fields
[0] = build_lang_decl (FIELD_DECL
, pfn_identifier
, type
);
8617 fields
[1] = build_lang_decl (FIELD_DECL
, delta2_identifier
,
8619 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
8620 TYPE_NAME (u
) = NULL_TREE
;
8622 t
= make_lang_type (RECORD_TYPE
);
8624 /* Let the front-end know this is a pointer to member function... */
8625 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8626 /* ... and not really an aggregate. */
8627 SET_IS_AGGR_TYPE (t
, 0);
8629 fields
[0] = build_lang_decl (FIELD_DECL
, delta_identifier
,
8631 fields
[1] = build_lang_decl (FIELD_DECL
, index_identifier
,
8633 fields
[2] = build_lang_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
8634 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
8636 /* Zap out the name so that the back-end will give us the debugging
8637 information for this anonymous RECORD_TYPE. */
8638 TYPE_NAME (t
) = NULL_TREE
;
8640 /* If this is not the unqualified form of this pointer-to-member
8641 type, set the TYPE_MAIN_VARIANT for this type to be the
8642 unqualified type. Since they are actually RECORD_TYPEs that are
8643 not variants of each other, we must do this manually. */
8644 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
8646 t
= build_qualified_type (t
, CP_TYPE_QUALS (type
));
8647 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
8648 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
8649 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
8652 /* Cache this pointer-to-member type so that we can find it again
8654 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8656 /* Seems to be wanted. */
8657 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
8662 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8663 Check to see that the definition is valid. Issue appropriate error
8664 messages. Return 1 if the definition is particularly bad, or 0
8668 check_static_variable_definition (decl
, type
)
8672 /* Motion 10 at San Diego: If a static const integral data member is
8673 initialized with an integral constant expression, the initializer
8674 may appear either in the declaration (within the class), or in
8675 the definition, but not both. If it appears in the class, the
8676 member is a member constant. The file-scope definition is always
8678 if (CLASS_TYPE_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
8680 cp_error ("in-class initialization of static data member of non-integral type `%T'",
8682 /* If we just return the declaration, crashes will sometimes
8683 occur. We therefore return void_type_node, as if this was a
8684 friend declaration, to cause callers to completely ignore
8685 this declaration. */
8688 else if (!CP_TYPE_CONST_P (type
))
8689 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8691 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
8692 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
8697 /* Given the SIZE (i.e., number of elements) in an array, compute an
8698 appropriate index type for the array. If non-NULL, NAME is the
8699 name of the thing being declared. */
8702 compute_array_index_type (name
, size
)
8708 /* The size might be the result of a cast. */
8709 STRIP_TYPE_NOPS (size
);
8711 /* It might be a const variable or enumeration constant. */
8712 if (TREE_READONLY_DECL_P (size
))
8713 size
= decl_constant_value (size
);
8715 /* If this involves a template parameter, it will be a constant at
8716 instantiation time, but we don't know what the value is yet.
8717 Even if no template parameters are involved, we may an expression
8718 that is not a constant; we don't even simplify `1 + 2' when
8719 processing a template. */
8720 if (processing_template_decl
)
8722 /* Resolve a qualified reference to an enumerator or static
8723 const data member of ours. */
8724 if (TREE_CODE (size
) == SCOPE_REF
8725 && TREE_OPERAND (size
, 0) == current_class_type
)
8727 tree t
= lookup_field (current_class_type
,
8728 TREE_OPERAND (size
, 1), 0, 0);
8733 return build_index_type (build_min (MINUS_EXPR
, sizetype
,
8734 size
, integer_one_node
));
8737 /* The array bound must be an integer type. */
8738 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
8739 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
8740 && TREE_CODE (TREE_TYPE (size
)) != BOOLEAN_TYPE
)
8742 cp_error ("size of array `%D' has non-integer type", name
);
8743 size
= integer_one_node
;
8746 /* Normally, the array-bound will be a constant. */
8747 if (TREE_CONSTANT (size
))
8749 /* Check to see if the array bound overflowed. Make that an
8750 error, no matter how generous we're being. */
8751 int old_flag_pedantic_errors
= flag_pedantic_errors
;
8752 int old_pedantic
= pedantic
;
8753 pedantic
= flag_pedantic_errors
= 1;
8754 constant_expression_warning (size
);
8755 pedantic
= old_pedantic
;
8756 flag_pedantic_errors
= old_flag_pedantic_errors
;
8758 /* An array must have a positive number of elements. */
8759 if (INT_CST_LT (size
, integer_zero_node
))
8761 cp_error ("size of array `%D' is negative", name
);
8762 size
= integer_one_node
;
8764 /* Except that an extension we allow zero-sized arrays. We
8765 always allow them in system headers because glibc uses
8767 else if (integer_zerop (size
) && pedantic
&& !in_system_header
)
8768 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", name
);
8771 /* Compute the index of the largest element in the array. It is
8772 one less than the number of elements in the array. */
8774 = fold (build_binary_op (MINUS_EXPR
,
8775 cp_convert (ssizetype
, size
),
8776 cp_convert (ssizetype
,
8777 integer_one_node
)));
8779 /* Check for variable-sized arrays. We allow such things as an
8780 extension, even though they are not allowed in ANSI/ISO C++. */
8781 if (!TREE_CONSTANT (itype
))
8786 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
8789 cp_pedwarn ("ANSI C++ forbids variable-size array");
8792 /* Create a variable-sized array index type. */
8793 itype
= variable_size (itype
);
8795 /* Make sure that there was no overflow when creating to a signed
8796 index type. (For example, on a 32-bit machine, an array with
8797 size 2^32 - 1 is too big.) */
8798 else if (TREE_OVERFLOW (itype
))
8800 error ("overflow in array dimension");
8801 TREE_OVERFLOW (itype
) = 0;
8804 /* Create and return the appropriate index type. */
8805 return build_index_type (itype
);
8808 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8809 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8813 create_array_type_for_decl (name
, type
, size
)
8818 tree itype
= NULL_TREE
;
8819 const char* error_msg
;
8821 /* If things have already gone awry, bail now. */
8822 if (type
== error_mark_node
|| size
== error_mark_node
)
8823 return error_mark_node
;
8825 /* Assume that everything will go OK. */
8828 /* There are some types which cannot be array elements. */
8829 switch (TREE_CODE (type
))
8832 error_msg
= "array of void";
8836 error_msg
= "array of functions";
8839 case REFERENCE_TYPE
:
8840 error_msg
= "array of references";
8844 error_msg
= "array of data members";
8848 error_msg
= "array of function members";
8855 /* If something went wrong, issue an error-message and return. */
8859 cp_error ("declaration of `%D' as %s", name
, error_msg
);
8861 cp_error ("creating %s", error_msg
);
8863 return error_mark_node
;
8868 The constant expressions that specify the bounds of the arrays
8869 can be omitted only for the first member of the sequence. */
8870 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8872 cp_error ("declaration of `%D' as multidimensional array",
8874 cp_error ("must have bounds for all dimensions except the first");
8876 return error_mark_node
;
8879 /* Figure out the index type for the array. */
8881 itype
= compute_array_index_type (name
, size
);
8883 return build_cplus_array_type (type
, itype
);
8886 /* Given declspecs and a declarator,
8887 determine the name and type of the object declared
8888 and construct a ..._DECL node for it.
8889 (In one case we can return a ..._TYPE node instead.
8890 For invalid input we sometimes return 0.)
8892 DECLSPECS is a chain of tree_list nodes whose value fields
8893 are the storage classes and type specifiers.
8895 DECL_CONTEXT says which syntactic context this declaration is in:
8896 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8897 FUNCDEF for a function definition. Like NORMAL but a few different
8898 error messages in each case. Return value may be zero meaning
8899 this definition is too screwy to try to parse.
8900 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8901 handle member functions (which have FIELD context).
8902 Return value may be zero meaning this definition is too screwy to
8904 PARM for a parameter declaration (either within a function prototype
8905 or before a function body). Make a PARM_DECL, or return void_type_node.
8906 CATCHPARM for a parameter declaration before a catch clause.
8907 TYPENAME if for a typename (in a cast or sizeof).
8908 Don't make a DECL node; just return the ..._TYPE node.
8909 FIELD for a struct or union field; make a FIELD_DECL.
8910 BITFIELD for a field with specified width.
8911 INITIALIZED is 1 if the decl has an initializer.
8913 ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
8914 normal attributes in TREE_PURPOSE, or NULL_TREE.
8916 In the TYPENAME case, DECLARATOR is really an absolute declarator.
8917 It may also be so in the PARM case, for a prototype where the
8918 argument type is specified but not the name.
8920 This function is where the complicated C meanings of `static'
8921 and `extern' are interpreted.
8923 For C++, if there is any monkey business to do, the function which
8924 calls this one must do it, i.e., prepending instance variables,
8925 renaming overloaded function names, etc.
8927 Note that for this C++, it is an error to define a method within a class
8928 which does not belong to that class.
8930 Except in the case where SCOPE_REFs are implicitly known (such as
8931 methods within a class being redundantly qualified),
8932 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
8933 (class_name::decl_name). The caller must also deal with this.
8935 If a constructor or destructor is seen, and the context is FIELD,
8936 then the type gains the attribute TREE_HAS_x. If such a declaration
8937 is erroneous, NULL_TREE is returned.
8939 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
8940 function, these are the qualifiers to give to the `this' pointer. We
8941 apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
8943 May return void_type_node if the declarator turned out to be a friend.
8944 See grokfield for details. */
8946 enum return_types
{ return_normal
, return_ctor
, return_dtor
, return_conversion
};
8949 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
8952 enum decl_context decl_context
;
8956 RID_BIT_TYPE specbits
;
8959 tree type
= NULL_TREE
;
8965 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8966 int explicit_int
= 0;
8967 int explicit_char
= 0;
8968 int defaulted_int
= 0;
8969 tree typedef_decl
= NULL_TREE
;
8971 tree typedef_type
= NULL_TREE
;
8972 int funcdef_flag
= 0;
8973 enum tree_code innermost_code
= ERROR_MARK
;
8976 /* See the code below that used this. */
8977 tree decl_machine_attr
= NULL_TREE
;
8979 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
8980 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
8981 tree init
= NULL_TREE
;
8983 /* Keep track of what sort of function is being processed
8984 so that we can warn about default return values, or explicit
8985 return values which do not match prescribed defaults. */
8986 enum return_types return_type
= return_normal
;
8988 tree dname
= NULL_TREE
;
8989 tree ctype
= current_class_type
;
8990 tree ctor_return_type
= NULL_TREE
;
8991 enum overload_flags flags
= NO_SPECIAL
;
8992 tree quals
= NULL_TREE
;
8993 tree raises
= NULL_TREE
;
8994 int template_count
= 0;
8995 tree in_namespace
= NULL_TREE
;
8999 RIDBIT_RESET_ALL (specbits
);
9000 if (decl_context
== FUNCDEF
)
9001 funcdef_flag
= 1, decl_context
= NORMAL
;
9002 else if (decl_context
== MEMFUNCDEF
)
9003 funcdef_flag
= -1, decl_context
= FIELD
;
9004 else if (decl_context
== BITFIELD
)
9005 bitfield
= 1, decl_context
= FIELD
;
9007 /* Look inside a declarator for the name being declared
9008 and get it as a string, for an error message. */
9010 tree
*next
= &declarator
;
9014 while (next
&& *next
)
9017 switch (TREE_CODE (decl
))
9020 /* For attributes. */
9021 next
= &TREE_VALUE (decl
);
9026 next
= &TREE_OPERAND (decl
, 0);
9029 case BIT_NOT_EXPR
: /* For C++ destructors! */
9031 tree name
= TREE_OPERAND (decl
, 0);
9032 tree rename
= NULL_TREE
;
9034 my_friendly_assert (flags
== NO_SPECIAL
, 152);
9036 return_type
= return_dtor
;
9037 if (TREE_CODE (name
) == TYPE_DECL
)
9038 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
9039 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
9040 if (ctype
== NULL_TREE
)
9042 if (current_class_type
== NULL_TREE
)
9044 error ("destructors must be member functions");
9049 tree t
= constructor_name (current_class_name
);
9056 tree t
= constructor_name (ctype
);
9063 cp_error ("destructor `%T' must match class name `%T'",
9065 TREE_OPERAND (decl
, 0) = rename
;
9071 case ADDR_EXPR
: /* C++ reference declaration */
9076 innermost_code
= TREE_CODE (decl
);
9077 next
= &TREE_OPERAND (decl
, 0);
9081 if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl
)))
9083 /* This is actually a variable declaration using
9084 constructor syntax. We need to call start_decl and
9085 cp_finish_decl so we can get the variable
9088 tree attributes
, prefix_attributes
;
9090 *next
= TREE_OPERAND (decl
, 0);
9091 init
= CALL_DECLARATOR_PARMS (decl
);
9095 attributes
= TREE_PURPOSE (attrlist
);
9096 prefix_attributes
= TREE_VALUE (attrlist
);
9100 attributes
= NULL_TREE
;
9101 prefix_attributes
= NULL_TREE
;
9104 decl
= start_decl (declarator
, declspecs
, 1,
9105 attributes
, prefix_attributes
);
9108 /* Look for __unused__ attribute */
9109 if (TREE_USED (TREE_TYPE (decl
)))
9110 TREE_USED (decl
) = 1;
9111 finish_decl (decl
, init
, NULL_TREE
);
9114 cp_error ("invalid declarator");
9117 innermost_code
= TREE_CODE (decl
);
9118 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
9119 ctype
= current_class_type
;
9121 && TREE_OPERAND (decl
, 0)
9122 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
9123 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
9124 == constructor_name_full (ctype
))
9125 || (DECL_NAME (TREE_OPERAND (decl
, 0))
9126 == constructor_name (ctype
)))))
9127 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9128 next
= &TREE_OPERAND (decl
, 0);
9130 if (ctype
!= NULL_TREE
9131 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
9132 && decl
== constructor_name (ctype
))
9134 return_type
= return_ctor
;
9135 ctor_return_type
= ctype
;
9140 case TEMPLATE_ID_EXPR
:
9142 tree fns
= TREE_OPERAND (decl
, 0);
9144 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
9145 fns
= TREE_OPERAND (fns
, 0);
9148 if (TREE_CODE (dname
) == COMPONENT_REF
)
9149 dname
= TREE_OPERAND (dname
, 1);
9150 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
9152 my_friendly_assert (is_overloaded_fn (dname
),
9154 dname
= DECL_NAME (get_first_fn (dname
));
9159 case IDENTIFIER_NODE
:
9160 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
9167 cp_error ("declarator-id missing; using reserved word `%D'",
9169 name
= IDENTIFIER_POINTER (dname
);
9171 if (! IDENTIFIER_OPNAME_P (dname
)
9172 /* GNU/Linux headers use '__op'. Arrgh. */
9173 || (IDENTIFIER_TYPENAME_P (dname
) && ! TREE_TYPE (dname
)))
9174 name
= IDENTIFIER_POINTER (dname
);
9177 if (IDENTIFIER_TYPENAME_P (dname
))
9179 my_friendly_assert (flags
== NO_SPECIAL
, 154);
9180 flags
= TYPENAME_FLAG
;
9181 ctor_return_type
= TREE_TYPE (dname
);
9182 return_type
= return_conversion
;
9184 name
= operator_name_string (dname
);
9191 /* Perform error checking, and decide on a ctype. */
9192 tree cname
= TREE_OPERAND (decl
, 0);
9193 if (cname
== NULL_TREE
)
9195 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
9198 in_namespace
= TREE_OPERAND (decl
, 0);
9199 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9201 else if (! is_aggr_type (cname
, 1))
9202 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9203 /* Must test TREE_OPERAND (decl, 1), in case user gives
9204 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9205 else if (TREE_OPERAND (decl
, 1)
9206 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
9208 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
9209 || TREE_CODE (cname
) == TEMPLATE_TEMPLATE_PARM
)
9211 cp_error ("`%T::%D' is not a valid declarator", cname
,
9212 TREE_OPERAND (decl
, 1));
9213 cp_error (" perhaps you want `typename %T::%D' to make it a type",
9214 cname
, TREE_OPERAND (decl
, 1));
9215 return void_type_node
;
9217 else if (ctype
== NULL_TREE
)
9219 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
9220 TREE_OPERAND (decl
, 0) = ctype
;
9223 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
9225 cp_error ("type `%T' is not derived from type `%T'",
9227 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9233 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
9234 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
9235 == constructor_name_full (ctype
))
9236 || (DECL_NAME (TREE_OPERAND (decl
, 1))
9237 == constructor_name (ctype
))))
9238 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
9239 next
= &TREE_OPERAND (decl
, 1);
9243 if (TREE_CODE (decl
) == IDENTIFIER_NODE
9244 && constructor_name (ctype
) == decl
)
9246 return_type
= return_ctor
;
9247 ctor_return_type
= ctype
;
9249 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
9250 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
9251 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
9252 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
9254 return_type
= return_dtor
;
9255 ctor_return_type
= ctype
;
9257 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9258 next
= &TREE_OPERAND (decl
, 0);
9269 /* Parse error puts this typespec where
9270 a declarator should go. */
9271 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
9272 if (TREE_TYPE (decl
) == current_class_type
)
9273 cp_error (" perhaps you want `%T' for a constructor",
9274 current_class_name
);
9275 dname
= DECL_NAME (decl
);
9276 name
= IDENTIFIER_POINTER (dname
);
9278 /* Avoid giving two errors for this. */
9279 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
9281 declspecs
= temp_tree_cons (NULL_TREE
, integer_type_node
,
9288 cp_compiler_error ("`%D' as declarator", decl
);
9289 return 0; /* We used to do a 155 abort here. */
9294 /* A function definition's declarator must have the form of
9295 a function declarator. */
9297 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
9300 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
9301 && innermost_code
!= CALL_EXPR
9302 && ! (ctype
&& declspecs
== NULL_TREE
))
9304 cp_error ("declaration of `%D' as non-function", dname
);
9305 return void_type_node
;
9308 /* Anything declared one level down from the top level
9309 must be one of the parameters of a function
9310 (because the body is at least two levels down). */
9312 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9313 by not allowing C++ class definitions to specify their parameters
9314 with xdecls (must be spec.d in the parmlist).
9316 Since we now wait to push a class scope until we are sure that
9317 we are in a legitimate method context, we must set oldcname
9318 explicitly (since current_class_name is not yet alive).
9320 We also want to avoid calling this a PARM if it is in a namespace. */
9322 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9324 struct binding_level
*b
= current_binding_level
;
9325 current_binding_level
= b
->level_chain
;
9326 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9327 decl_context
= PARM
;
9328 current_binding_level
= b
;
9332 name
= decl_context
== PARM
? "parameter" : "type name";
9334 /* Look through the decl specs and record which ones appear.
9335 Some typespecs are defined as built-in typenames.
9336 Others, the ones that are modifiers of other types,
9337 are represented by bits in SPECBITS: set the bits for
9338 the modifiers that appear. Storage class keywords are also in SPECBITS.
9340 If there is a typedef name or a type, store the type in TYPE.
9341 This includes builtin typedefs such as `int'.
9343 Set EXPLICIT_INT if the type is `int' or `char' and did not
9344 come from a user typedef.
9346 Set LONGLONG if `long' is mentioned twice.
9348 For C++, constructors and destructors have their own fast treatment. */
9350 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
9355 /* Certain parse errors slip through. For example,
9356 `int class;' is not caught by the parser. Try
9357 weakly to recover here. */
9358 if (TREE_CODE (spec
) != TREE_LIST
)
9361 id
= TREE_VALUE (spec
);
9363 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9365 if (id
== ridpointers
[(int) RID_INT
]
9366 || id
== ridpointers
[(int) RID_CHAR
]
9367 || id
== ridpointers
[(int) RID_BOOL
]
9368 || id
== ridpointers
[(int) RID_WCHAR
])
9372 if (id
== ridpointers
[(int) RID_BOOL
])
9373 error ("`bool' is now a keyword");
9375 cp_error ("extraneous `%T' ignored", id
);
9379 if (id
== ridpointers
[(int) RID_INT
])
9381 else if (id
== ridpointers
[(int) RID_CHAR
])
9383 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
9387 /* C++ aggregate types. */
9388 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
9391 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
9393 type
= IDENTIFIER_TYPE_VALUE (id
);
9397 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
9399 if (ridpointers
[i
] == id
)
9401 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
9403 if (pedantic
&& ! in_system_header
&& warn_long_long
)
9404 pedwarn ("ANSI C++ does not support `long long'");
9406 error ("`long long long' is too long for GCC");
9410 else if (RIDBIT_SETP (i
, specbits
))
9411 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
9412 RIDBIT_SET (i
, specbits
);
9417 /* C++ aggregate types. */
9418 else if (TREE_CODE (id
) == TYPE_DECL
|| TREE_CODE (id
) == TEMPLATE_DECL
)
9421 cp_error ("multiple declarations `%T' and `%T'", type
,
9425 type
= TREE_TYPE (id
);
9426 TREE_VALUE (spec
) = type
;
9431 error ("two or more data types in declaration of `%s'", name
);
9432 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9434 register tree t
= lookup_name (id
, 1);
9435 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9436 error ("`%s' fails to be a typedef or built in type",
9437 IDENTIFIER_POINTER (id
));
9440 type
= TREE_TYPE (t
);
9442 /* See the code below that used this. */
9443 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
9448 else if (id
!= error_mark_node
)
9449 /* Can't change CLASS nodes into RECORD nodes here! */
9455 typedef_type
= type
;
9457 /* No type at all: default to `int', and set DEFAULTED_INT
9458 because it was not a user-defined typedef. */
9460 if (type
== NULL_TREE
9461 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
9462 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9463 || RIDBIT_SETP (RID_LONG
, specbits
)
9464 || RIDBIT_SETP (RID_SHORT
, specbits
)))
9466 /* These imply 'int'. */
9467 type
= integer_type_node
;
9471 if (type
== NULL_TREE
)
9474 if (return_type
== return_dtor
)
9475 type
= void_type_node
;
9476 else if (return_type
== return_ctor
)
9477 type
= build_pointer_type (ctor_return_type
);
9478 else if (return_type
== return_conversion
)
9479 type
= ctor_return_type
;
9482 /* We handle `main' specially here, because 'main () { }' is so
9483 common. With no options, it is allowed. With -Wreturn-type,
9484 it is a warning. It is only an error with -pedantic-errors. */
9485 int is_main
= (funcdef_flag
9486 && MAIN_NAME_P (dname
)
9487 && ctype
== NULL_TREE
9488 && in_namespace
== NULL_TREE
9489 && current_namespace
== global_namespace
);
9491 if (in_system_header
|| flag_ms_extensions
)
9492 /* Allow it, sigh. */;
9493 else if (pedantic
|| ! is_main
)
9494 cp_pedwarn ("ANSI C++ forbids declaration of `%s' with no type",
9496 else if (warn_return_type
)
9497 cp_warning ("ANSI C++ forbids declaration of `%s' with no type",
9500 type
= integer_type_node
;
9503 else if (return_type
== return_dtor
)
9505 error ("return type specification for destructor invalid");
9506 type
= void_type_node
;
9508 else if (return_type
== return_ctor
)
9510 error ("return type specification for constructor invalid");
9511 type
= build_pointer_type (ctor_return_type
);
9513 else if (return_type
== return_conversion
)
9515 if (!same_type_p (type
, ctor_return_type
))
9516 cp_error ("operator `%T' declared to return `%T'",
9517 ctor_return_type
, type
);
9519 cp_pedwarn ("return type specified for `operator %T'",
9522 type
= ctor_return_type
;
9527 /* Now process the modifiers that were specified
9528 and check for invalid combinations. */
9530 /* Long double is a special combination. */
9532 if (RIDBIT_SETP (RID_LONG
, specbits
)
9533 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
9535 RIDBIT_RESET (RID_LONG
, specbits
);
9536 type
= build_qualified_type (long_double_type_node
,
9537 CP_TYPE_QUALS (type
));
9540 /* Check all other uses of type modifiers. */
9542 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9543 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9544 || RIDBIT_SETP (RID_LONG
, specbits
)
9545 || RIDBIT_SETP (RID_SHORT
, specbits
))
9549 if (TREE_CODE (type
) == REAL_TYPE
)
9550 error ("short, signed or unsigned invalid for `%s'", name
);
9551 else if (TREE_CODE (type
) != INTEGER_TYPE
)
9552 error ("long, short, signed or unsigned invalid for `%s'", name
);
9553 else if (RIDBIT_SETP (RID_LONG
, specbits
)
9554 && RIDBIT_SETP (RID_SHORT
, specbits
))
9555 error ("long and short specified together for `%s'", name
);
9556 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9557 || RIDBIT_SETP (RID_SHORT
, specbits
))
9559 error ("long or short specified with char for `%s'", name
);
9560 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9561 || RIDBIT_SETP (RID_SHORT
, specbits
))
9562 && TREE_CODE (type
) == REAL_TYPE
)
9563 error ("long or short specified with floating type for `%s'", name
);
9564 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9565 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
9566 error ("signed and unsigned given together for `%s'", name
);
9570 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
9572 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9574 if (flag_pedantic_errors
)
9579 /* Discard the type modifiers if they are invalid. */
9582 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
9583 RIDBIT_RESET (RID_SIGNED
, specbits
);
9584 RIDBIT_RESET (RID_LONG
, specbits
);
9585 RIDBIT_RESET (RID_SHORT
, specbits
);
9590 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
9591 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9593 error ("complex invalid for `%s'", name
);
9594 RIDBIT_RESET (RID_COMPLEX
, specbits
);
9597 /* Decide whether an integer type is signed or not.
9598 Optionally treat bitfields as signed by default. */
9599 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9602 It is implementation-defined whether a plain (neither
9603 explicitly signed or unsigned) char, short, int, or long
9604 bit-field is signed or unsigned.
9606 Naturally, we extend this to long long as well. Note that
9607 this does not include wchar_t. */
9608 || (bitfield
&& !flag_signed_bitfields
9609 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)
9610 /* A typedef for plain `int' without `signed' can be
9611 controlled just like plain `int', but a typedef for
9612 `signed int' cannot be so controlled. */
9614 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9615 && (TREE_CODE (type
) == INTEGER_TYPE
9616 || TREE_CODE (type
) == CHAR_TYPE
)
9617 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9620 type
= long_long_unsigned_type_node
;
9621 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9622 type
= long_unsigned_type_node
;
9623 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9624 type
= short_unsigned_type_node
;
9625 else if (type
== char_type_node
)
9626 type
= unsigned_char_type_node
;
9627 else if (typedef_decl
)
9628 type
= unsigned_type (type
);
9630 type
= unsigned_type_node
;
9632 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9633 && type
== char_type_node
)
9634 type
= signed_char_type_node
;
9636 type
= long_long_integer_type_node
;
9637 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9638 type
= long_integer_type_node
;
9639 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9640 type
= short_integer_type_node
;
9642 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
9644 /* If we just have "complex", it is equivalent to
9645 "complex double", but if any modifiers at all are specified it is
9646 the complex form of TYPE. E.g, "complex short" is
9647 "complex short int". */
9649 if (defaulted_int
&& ! longlong
9650 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
9651 || RIDBIT_SETP (RID_SHORT
, specbits
)
9652 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9653 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
9654 type
= complex_double_type_node
;
9655 else if (type
== integer_type_node
)
9656 type
= complex_integer_type_node
;
9657 else if (type
== float_type_node
)
9658 type
= complex_float_type_node
;
9659 else if (type
== double_type_node
)
9660 type
= complex_double_type_node
;
9661 else if (type
== long_double_type_node
)
9662 type
= complex_long_double_type_node
;
9664 type
= build_complex_type (type
);
9667 if (return_type
== return_conversion
9668 && (RIDBIT_SETP (RID_CONST
, specbits
)
9669 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
9670 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
9671 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9674 /* Set CONSTP if this declaration is `const', whether by
9675 explicit specification or via a typedef.
9676 Likewise for VOLATILEP. */
9678 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
9680 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
9682 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
9683 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9684 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9685 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9686 type
= cp_build_qualified_type (type
, type_quals
);
9688 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
9689 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
9690 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
9691 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
9692 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
9694 if (RIDBIT_SETP (RID_STATIC
, specbits
))
9695 staticp
= 1 + (decl_context
== FIELD
);
9697 if (virtualp
&& staticp
== 2)
9699 cp_error ("member `%D' cannot be declared both virtual and static",
9703 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
9704 RIDBIT_RESET (RID_FRIEND
, specbits
);
9706 /* Warn if two storage classes are given. Default to `auto'. */
9708 if (RIDBIT_ANY_SET (specbits
))
9710 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
9711 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
9712 if (decl_context
== PARM
&& nclasses
> 0)
9713 error ("storage class specifiers invalid in parameter declarations");
9714 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9716 if (decl_context
== PARM
)
9717 error ("typedef declaration invalid in parameter declaration");
9720 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
9721 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
9724 /* Give error if `virtual' is used outside of class declaration. */
9726 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9728 error ("virtual outside class declaration");
9732 /* Static anonymous unions are dealt with here. */
9733 if (staticp
&& decl_context
== TYPENAME
9734 && TREE_CODE (declspecs
) == TREE_LIST
9735 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs
)))
9736 decl_context
= FIELD
;
9738 /* Warn about storage classes that are invalid for certain
9739 kinds of declarations (parameters, typenames, etc.). */
9742 error ("multiple storage classes in declaration of `%s'", name
);
9743 else if (decl_context
!= NORMAL
&& nclasses
> 0)
9745 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9746 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
9747 || RIDBIT_SETP (RID_AUTO
, specbits
)))
9749 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9751 else if (decl_context
== FIELD
9752 /* C++ allows static class elements */
9753 && RIDBIT_SETP (RID_STATIC
, specbits
))
9754 /* C++ also allows inlines and signed and unsigned elements,
9755 but in those cases we don't come in here. */
9759 if (decl_context
== FIELD
)
9761 tree tmp
= NULL_TREE
;
9762 register int op
= 0;
9766 /* Avoid trying to get an operand off an identifier node. */
9767 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
9770 tmp
= TREE_OPERAND (declarator
, 0);
9771 op
= IDENTIFIER_OPNAME_P (tmp
);
9773 error ("storage class specified for %s `%s'",
9774 op
? "member operator" : "field",
9775 op
? operator_name_string (tmp
) : name
);
9779 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9780 error ("storage class specified for parameter `%s'", name
);
9782 error ("storage class specified for typename");
9784 RIDBIT_RESET (RID_REGISTER
, specbits
);
9785 RIDBIT_RESET (RID_AUTO
, specbits
);
9786 RIDBIT_RESET (RID_EXTERN
, specbits
);
9789 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
9791 if (toplevel_bindings_p ())
9793 /* It's common practice (and completely valid) to have a const
9794 be initialized and declared extern. */
9795 if (!(type_quals
& TYPE_QUAL_CONST
))
9796 warning ("`%s' initialized and declared `extern'", name
);
9799 error ("`%s' has both `extern' and initializer", name
);
9801 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
9802 && ! toplevel_bindings_p ())
9803 error ("nested function `%s' declared `extern'", name
);
9804 else if (toplevel_bindings_p ())
9806 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9807 error ("top-level declaration of `%s' specifies `auto'", name
);
9810 if (nclasses
> 0 && friendp
)
9811 error ("storage class specifiers invalid in friend function declarations");
9813 /* Now figure out the structure of the declarator proper.
9814 Descend through it, creating more complex types, until we reach
9815 the declared identifier (or NULL_TREE, in an absolute declarator). */
9817 inner_attrs
= NULL_TREE
;
9820 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
9821 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
9823 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9824 an INDIRECT_REF (for *...),
9825 a CALL_EXPR (for ...(...)),
9826 an identifier (for the name being declared)
9827 or a null pointer (for the place in an absolute declarator
9828 where the name was omitted).
9829 For the last two cases, we have just exited the loop.
9831 For C++ it could also be
9832 a SCOPE_REF (for class :: ...). In this case, we have converted
9833 sensible names to types, and those are the values we use to
9834 qualify the member name.
9835 an ADDR_EXPR (for &...),
9836 a BIT_NOT_EXPR (for destructors)
9838 At this point, TYPE is the type of elements of an array,
9839 or for a function to return, or for a pointer to point to.
9840 After this sequence of ifs, TYPE is the type of the
9841 array or function or pointer, and DECLARATOR has had its
9842 outermost layer removed. */
9844 if (type
== error_mark_node
)
9846 if (TREE_CODE (declarator
) == SCOPE_REF
)
9847 declarator
= TREE_OPERAND (declarator
, 1);
9849 declarator
= TREE_OPERAND (declarator
, 0);
9852 if (quals
!= NULL_TREE
9853 && (declarator
== NULL_TREE
9854 || TREE_CODE (declarator
) != SCOPE_REF
))
9856 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
9857 ctype
= TYPE_METHOD_BASETYPE (type
);
9858 if (ctype
!= NULL_TREE
)
9860 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
9861 grok_method_quals (ctype
, dummy
, quals
);
9862 type
= TREE_TYPE (dummy
);
9863 ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
)));
9868 /* See the comment for the TREE_LIST case, below. */
9871 else if (inner_attrs
)
9873 decl_attributes (type
, inner_attrs
, NULL_TREE
);
9874 inner_attrs
= NULL_TREE
;
9877 switch (TREE_CODE (declarator
))
9881 /* We encode a declarator with embedded attributes using
9882 a TREE_LIST. The attributes apply to the declarator
9883 directly inside them, so we have to skip an iteration
9884 before applying them to the type. If the declarator just
9885 inside is the declarator-id, we apply the attrs to the
9887 inner_attrs
= TREE_PURPOSE (declarator
);
9889 declarator
= TREE_VALUE (declarator
);
9897 size
= TREE_OPERAND (declarator
, 1);
9899 /* VC++ spells a zero-sized array with []. */
9900 if (size
== NULL_TREE
&& decl_context
== FIELD
&& ! staticp
9901 && ! RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9902 size
= integer_zero_node
;
9904 declarator
= TREE_OPERAND (declarator
, 0);
9906 type
= create_array_type_for_decl (dname
, type
, size
);
9915 tree inner_parms
= CALL_DECLARATOR_PARMS (declarator
);
9916 tree inner_decl
= TREE_OPERAND (declarator
, 0);
9918 /* Declaring a function type.
9919 Make sure we have a valid type for the function to return. */
9921 /* We now know that the TYPE_QUALS don't apply to the
9922 decl, but to its return type. */
9923 type_quals
= TYPE_UNQUALIFIED
;
9925 /* Warn about some types functions can't return. */
9927 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9929 error ("`%s' declared as function returning a function", name
);
9930 type
= integer_type_node
;
9932 if (TREE_CODE (type
) == ARRAY_TYPE
)
9934 error ("`%s' declared as function returning an array", name
);
9935 type
= integer_type_node
;
9938 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
9939 inner_decl
= TREE_OPERAND (inner_decl
, 1);
9941 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
9944 /* Pick up type qualifiers which should be applied to `this'. */
9945 quals
= CALL_DECLARATOR_QUALS (declarator
);
9947 /* Pick up the exception specifications. */
9948 raises
= CALL_DECLARATOR_EXCEPTION_SPEC (declarator
);
9950 /* Say it's a definition only for the CALL_EXPR
9951 closest to the identifier. */
9954 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
9955 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
9956 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
9958 if (ctype
== NULL_TREE
9959 && decl_context
== FIELD
9961 && (friendp
== 0 || dname
== current_class_name
))
9962 ctype
= current_class_type
;
9964 if (ctype
&& return_type
== return_conversion
)
9965 TYPE_HAS_CONVERSION (ctype
) = 1;
9966 if (ctype
&& constructor_name (ctype
) == dname
)
9968 /* We are within a class's scope. If our declarator name
9969 is the same as the class name, and we are defining
9970 a function, then it is a constructor/destructor, and
9971 therefore returns a void type. */
9973 if (flags
== DTOR_FLAG
)
9975 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
9976 not be declared const or volatile. A destructor
9977 may not be static. */
9979 error ("destructor cannot be static member function");
9982 cp_error ("destructors may not be `%s'",
9983 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9986 if (decl_context
== FIELD
)
9988 if (! member_function_or_else (ctype
, current_class_type
,
9989 "destructor for alien class `%s' cannot be a member"))
9990 return void_type_node
;
9993 else /* It's a constructor. */
9997 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
9998 not be declared const or volatile. A constructor may
9999 not be virtual. A constructor may not be static. */
10001 error ("constructor cannot be static member function");
10004 pedwarn ("constructors cannot be declared virtual");
10009 cp_error ("constructors may not be `%s'",
10010 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10014 RID_BIT_TYPE tmp_bits
;
10015 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
10016 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
10017 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
10018 if (RIDBIT_ANY_SET (tmp_bits
))
10019 error ("return value type specifier for constructor ignored");
10021 type
= build_pointer_type (ctype
);
10022 if (decl_context
== FIELD
)
10024 if (! member_function_or_else (ctype
, current_class_type
,
10025 "constructor for alien class `%s' cannot be member"))
10026 return void_type_node
;
10027 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
10028 if (return_type
!= return_ctor
)
10032 if (decl_context
== FIELD
)
10038 error ("can't initialize friend function `%s'", name
);
10041 /* Cannot be both friend and virtual. */
10042 error ("virtual functions cannot be friends");
10043 RIDBIT_RESET (RID_FRIEND
, specbits
);
10046 if (decl_context
== NORMAL
)
10047 error ("friend declaration not in class definition");
10048 if (current_function_decl
&& funcdef_flag
)
10049 cp_error ("can't define friend function `%s' in a local class definition",
10053 /* Construct the function type and go to the next
10054 inner layer of declarator. */
10056 declarator
= TREE_OPERAND (declarator
, 0);
10058 /* FIXME: This is where default args should be fully
10061 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
10063 if (declarator
&& flags
== DTOR_FLAG
)
10065 /* A destructor declared in the body of a class will
10066 be represented as a BIT_NOT_EXPR. But, we just
10067 want the underlying IDENTIFIER. */
10068 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
10069 declarator
= TREE_OPERAND (declarator
, 0);
10071 if (strict_prototype
== 0 && arg_types
== NULL_TREE
)
10072 arg_types
= void_list_node
;
10073 else if (arg_types
== NULL_TREE
10074 || arg_types
!= void_list_node
)
10076 cp_error ("destructors may not have parameters");
10077 arg_types
= void_list_node
;
10078 last_function_parms
= NULL_TREE
;
10082 /* ANSI says that `const int foo ();'
10083 does not make the function foo const. */
10084 type
= build_function_type (type
, arg_types
);
10088 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
10089 if (TREE_PURPOSE (t
)
10090 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
10092 add_defarg_fn (type
);
10101 /* Filter out pointers-to-references and references-to-references.
10102 We can get these if a TYPE_DECL is used. */
10104 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10106 error ("cannot declare %s to references",
10107 TREE_CODE (declarator
) == ADDR_EXPR
10108 ? "references" : "pointers");
10109 declarator
= TREE_OPERAND (declarator
, 0);
10113 if (TREE_CODE (type
) == OFFSET_TYPE
10114 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
10115 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
10117 cp_error ("cannot declare pointer to `%#T' member",
10119 type
= TREE_TYPE (type
);
10122 /* Merge any constancy or volatility into the target type
10123 for the pointer. */
10125 /* We now know that the TYPE_QUALS don't apply to the decl,
10126 but to the target of the pointer. */
10127 type_quals
= TYPE_UNQUALIFIED
;
10129 if (TREE_CODE (declarator
) == ADDR_EXPR
)
10131 if (TREE_CODE (type
) == VOID_TYPE
)
10132 error ("invalid type: `void &'");
10134 type
= build_reference_type (type
);
10136 else if (TREE_CODE (type
) == METHOD_TYPE
)
10137 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10139 type
= build_pointer_type (type
);
10141 /* Process a list of type modifier keywords (such as
10142 const or volatile) that were given inside the `*' or `&'. */
10144 if (TREE_TYPE (declarator
))
10146 register tree typemodlist
;
10152 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
10153 typemodlist
= TREE_CHAIN (typemodlist
))
10155 tree qualifier
= TREE_VALUE (typemodlist
);
10157 if (qualifier
== ridpointers
[(int) RID_CONST
])
10159 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
10161 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
10166 error ("invalid type modifier within pointer declarator");
10170 pedwarn ("duplicate `const'");
10172 pedwarn ("duplicate `volatile'");
10174 pedwarn ("duplicate `restrict'");
10176 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10177 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10178 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10179 if (TREE_CODE (declarator
) == ADDR_EXPR
10180 && (constp
|| volatilep
))
10183 pedwarn ("discarding `const' applied to a reference");
10185 pedwarn ("discarding `volatile' applied to a reference");
10186 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
10188 type
= cp_build_qualified_type (type
, type_quals
);
10190 declarator
= TREE_OPERAND (declarator
, 0);
10196 /* We have converted type names to NULL_TREE if the
10197 name was bogus, or to a _TYPE node, if not.
10199 The variable CTYPE holds the type we will ultimately
10200 resolve to. The code here just needs to build
10201 up appropriate member types. */
10202 tree sname
= TREE_OPERAND (declarator
, 1);
10205 /* Destructors can have their visibilities changed as well. */
10206 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
10207 sname
= TREE_OPERAND (sname
, 0);
10209 if (TREE_COMPLEXITY (declarator
) == 0)
10210 /* This needs to be here, in case we are called
10211 multiple times. */ ;
10212 else if (TREE_COMPLEXITY (declarator
) == -1)
10213 /* Namespace member. */
10214 pop_decl_namespace ();
10215 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
10216 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10217 else if (! IS_AGGR_TYPE_CODE
10218 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
10220 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
10222 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10223 that refer to ctype. They couldn't be resolved earlier
10224 because we hadn't pushed into the class yet.
10225 Example: resolve 'B<T>::type' in
10226 'B<typename B<T>::type> B<T>::f () { }'. */
10227 if (current_template_parms
10228 && uses_template_parms (type
)
10229 && uses_template_parms (current_class_type
))
10231 tree args
= current_template_args ();
10232 type
= tsubst (type
, args
, /*complain=*/1, NULL_TREE
);
10235 /* This pop_nested_class corresponds to the
10236 push_nested_class used to push into class scope for
10237 parsing the argument list of a function decl, in
10239 pop_nested_class ();
10240 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10243 my_friendly_abort (16);
10245 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10247 /* We had a reference to a global decl, or
10248 perhaps we were given a non-aggregate typedef,
10249 in which case we cleared this out, and should just
10250 keep going as though it wasn't there. */
10251 declarator
= sname
;
10254 ctype
= TREE_OPERAND (declarator
, 0);
10257 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
10259 if (CLASSTYPE_TEMPLATE_INFO (t
) &&
10260 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
10261 template_count
+= 1;
10262 t
= TYPE_MAIN_DECL (t
);
10263 if (DECL_LANG_SPECIFIC (t
))
10264 t
= DECL_CLASS_CONTEXT (t
);
10269 if (sname
== NULL_TREE
)
10272 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10274 /* This is the `standard' use of the scoping operator:
10275 basetype :: member . */
10277 if (ctype
== current_class_type
)
10283 Is this ill-formed? */
10286 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10289 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10291 if (current_class_type
== NULL_TREE
10293 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10294 TYPE_ARG_TYPES (type
));
10297 cp_error ("cannot declare member function `%T::%s' within `%T'",
10298 ctype
, name
, current_class_type
);
10299 return void_type_node
;
10302 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10303 || TYPE_SIZE (complete_type (ctype
)) != NULL_TREE
)
10305 /* Have to move this code elsewhere in this function.
10306 this code is used for i.e., typedef int A::M; M *pm;
10308 It is? How? jason 10/2/94 */
10310 if (current_class_type
)
10312 cp_error ("cannot declare member `%T::%s' within `%T'",
10313 ctype
, name
, current_class_type
);
10314 return void_type_node
;
10316 type
= build_offset_type (ctype
, type
);
10318 else if (uses_template_parms (ctype
))
10320 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10322 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
10323 TYPE_ARG_TYPES (type
));
10327 cp_error ("structure `%T' not yet defined", ctype
);
10328 return error_mark_node
;
10331 declarator
= sname
;
10333 else if (TREE_CODE (sname
) == SCOPE_REF
)
10334 my_friendly_abort (17);
10338 declarator
= TREE_OPERAND (declarator
, 1);
10339 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
10340 /* In this case, we will deal with it later. */
10344 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10345 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10346 TYPE_ARG_TYPES (type
));
10348 type
= build_offset_type (ctype
, type
);
10355 declarator
= TREE_OPERAND (declarator
, 0);
10360 case ENUMERAL_TYPE
:
10361 declarator
= NULL_TREE
;
10365 declarator
= NULL_TREE
;
10369 my_friendly_abort (158);
10373 /* See the comment for the TREE_LIST case, above. */
10376 if (! ignore_attrs
)
10377 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10379 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
10381 attrlist
= build_decl_list (NULL_TREE
, inner_attrs
);
10384 /* Now TYPE has the actual type. */
10386 if (explicitp
== 1 || (explicitp
&& friendp
))
10388 /* [dcl.fct.spec] The explicit specifier shall only be used in
10389 declarations of constructors within a class definition. */
10390 error ("only declarations of constructors can be `explicit'");
10394 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10396 if (current_class_name
== NULL_TREE
|| decl_context
== PARM
|| friendp
)
10398 error ("non-member `%s' cannot be declared `mutable'", name
);
10399 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10401 else if (decl_context
== TYPENAME
|| RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10403 error ("non-object member `%s' cannot be declared `mutable'", name
);
10404 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10406 else if (TREE_CODE (type
) == FUNCTION_TYPE
10407 || TREE_CODE (type
) == METHOD_TYPE
)
10409 error ("function `%s' cannot be declared `mutable'", name
);
10410 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10414 error ("static `%s' cannot be declared `mutable'", name
);
10415 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10417 else if (type_quals
& TYPE_QUAL_CONST
)
10419 error ("const `%s' cannot be declared `mutable'", name
);
10420 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10424 if (declarator
== NULL_TREE
10425 || TREE_CODE (declarator
) == IDENTIFIER_NODE
10426 || (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
10427 && (TREE_CODE (type
) == FUNCTION_TYPE
10428 || TREE_CODE (type
) == METHOD_TYPE
)))
10430 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10432 cp_error ("template-id `%D' used as a declarator", declarator
);
10433 declarator
= dname
;
10436 /* Unexpected declarator format. */
10437 my_friendly_abort (990210);
10439 /* If this is declaring a typedef name, return a TYPE_DECL. */
10441 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
10445 /* Note that the grammar rejects storage classes
10446 in typenames, fields or parameters. */
10447 if (current_lang_name
== lang_name_java
)
10448 TYPE_FOR_JAVA (type
) = 1;
10450 if (decl_context
== FIELD
)
10452 if (declarator
== constructor_name (current_class_type
))
10453 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10455 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10459 /* Make sure this typedef lives as long as its type,
10460 since it might be used as a template parameter. */
10461 if (processing_template_decl
)
10462 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10464 decl
= build_decl (TYPE_DECL
, declarator
, type
);
10467 /* If the user declares "typedef struct {...} foo" then the
10468 struct will have an anonymous name. Fill that name in now.
10469 Nothing can refer to it, so nothing needs know about the name
10471 if (type
!= error_mark_node
10472 && TYPE_NAME (type
)
10473 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10474 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
))
10475 && CP_TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
10477 tree oldname
= TYPE_NAME (type
);
10480 /* Replace the anonymous name with the real name everywhere. */
10481 lookup_tag_reverse (type
, declarator
);
10482 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10483 if (TYPE_NAME (t
) == oldname
)
10484 TYPE_NAME (t
) = decl
;
10486 if (TYPE_LANG_SPECIFIC (type
))
10487 TYPE_WAS_ANONYMOUS (type
) = 1;
10489 /* If this is a typedef within a template class, the nested
10490 type is a (non-primary) template. The name for the
10491 template needs updating as well. */
10492 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10493 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10494 = TYPE_IDENTIFIER (type
);
10496 /* XXX Temporarily set the scope.
10497 When returning, start_decl expects it as NULL_TREE,
10498 and will then then set it using pushdecl. */
10499 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
10500 if (current_class_type
)
10501 DECL_CONTEXT (decl
) = current_class_type
;
10503 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10505 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
10506 DECL_ASSEMBLER_NAME (decl
)
10507 = get_identifier (build_overload_name (type
, 1, 1));
10508 DECL_CONTEXT (decl
) = NULL_TREE
;
10510 /* FIXME remangle member functions; member functions of a
10511 type with external linkage have external linkage. */
10514 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10516 cp_error_at ("typedef name may not be class-qualified", decl
);
10521 if (ctype
== NULL_TREE
)
10523 if (TREE_CODE (type
) != METHOD_TYPE
)
10524 cp_error_at ("invalid type qualifier for non-method type", decl
);
10526 ctype
= TYPE_METHOD_BASETYPE (type
);
10528 if (ctype
!= NULL_TREE
)
10529 grok_method_quals (ctype
, decl
, quals
);
10532 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10533 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10534 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10536 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
10537 inlinep
, friendp
, raises
!= NULL_TREE
);
10540 error ("typedef declaration includes an initializer");
10545 /* Detect the case of an array type of unspecified size
10546 which came, as such, direct from a typedef name.
10547 We must copy the type, so that each identifier gets
10548 a distinct type, so that each identifier's size can be
10549 controlled separately by its own initializer. */
10551 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
10552 && TYPE_DOMAIN (type
) == NULL_TREE
)
10554 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
10557 /* If this is a type name (such as, in a cast or sizeof),
10558 compute the type and return it now. */
10560 if (decl_context
== TYPENAME
)
10562 /* Note that the grammar rejects storage classes
10563 in typenames, fields or parameters. */
10564 if (type_quals
!= TYPE_UNQUALIFIED
)
10565 type_quals
= TYPE_UNQUALIFIED
;
10567 /* Special case: "friend class foo" looks like a TYPENAME context. */
10570 if (type_quals
!= TYPE_UNQUALIFIED
)
10572 cp_error ("type qualifiers specified for friend class declaration");
10573 type_quals
= TYPE_UNQUALIFIED
;
10577 cp_error ("`inline' specified for friend class declaration");
10581 /* Only try to do this stuff if we didn't already give up. */
10582 if (type
!= integer_type_node
)
10584 /* A friendly class? */
10585 if (current_class_type
)
10586 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
10588 error ("trying to make class `%s' a friend of global scope",
10589 TYPE_NAME_STRING (type
));
10590 type
= void_type_node
;
10595 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
10596 if (ctype
== NULL_TREE
)
10598 my_friendly_assert (TREE_CODE (type
) == METHOD_TYPE
, 159);
10599 ctype
= TYPE_METHOD_BASETYPE (type
);
10601 grok_method_quals (ctype
, dummy
, quals
);
10602 type
= TREE_TYPE (dummy
);
10607 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
10608 && decl_context
!= CATCHPARM
10609 && TREE_CODE (type
) != UNION_TYPE
10612 cp_error ("abstract declarator `%T' used as declaration", type
);
10613 declarator
= make_anon_name ();
10616 /* `void' at top level (not within pointer)
10617 is allowed only in typedefs or type names.
10618 We don't complain about parms either, but that is because
10619 a better error message can be made later. */
10621 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
10624 error ("unnamed variable or field declared void");
10625 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10627 if (IDENTIFIER_OPNAME_P (declarator
))
10628 my_friendly_abort (356);
10630 error ("variable or field `%s' declared void", name
);
10633 error ("variable or field declared void");
10634 type
= integer_type_node
;
10637 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10638 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10640 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10642 if (ctype
|| in_namespace
)
10643 error ("cannot use `::' in parameter declaration");
10645 /* A parameter declared as an array of T is really a pointer to T.
10646 One declared as a function is really a pointer to a function.
10647 One declared as a member is really a pointer to member. */
10649 if (TREE_CODE (type
) == ARRAY_TYPE
)
10651 /* Transfer const-ness of array into that of type pointed to. */
10652 type
= build_pointer_type (TREE_TYPE (type
));
10653 type_quals
= TYPE_UNQUALIFIED
;
10655 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10656 type
= build_pointer_type (type
);
10657 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10658 type
= build_pointer_type (type
);
10659 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
10661 error ("declaration of `%s' as void", name
);
10667 register tree decl
;
10669 if (decl_context
== PARM
)
10671 decl
= build_decl (PARM_DECL
, declarator
, type
);
10673 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
10674 inlinep
, friendp
, raises
!= NULL_TREE
);
10676 /* Compute the type actually passed in the parmlist,
10677 for the case where there is no prototype.
10678 (For example, shorts and chars are passed as ints.)
10679 When there is a prototype, this is overridden later. */
10681 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
10683 else if (decl_context
== FIELD
)
10685 if (type
== error_mark_node
)
10687 /* Happens when declaring arrays of sizes which
10688 are error_mark_node, for example. */
10691 else if (in_namespace
&& !friendp
)
10693 /* Something like struct S { int N::j; }; */
10694 cp_error ("invalid use of `::'");
10697 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10700 tree function_context
;
10702 /* We catch the others as conflicts with the builtin
10704 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
10706 cp_error ("function `%D' cannot be declared friend",
10713 if (ctype
== NULL_TREE
)
10714 ctype
= current_class_type
;
10716 if (ctype
== NULL_TREE
)
10718 cp_error ("can't make `%D' into a method -- not in a class",
10720 return void_type_node
;
10723 /* ``A union may [ ... ] not [ have ] virtual functions.''
10725 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10727 cp_error ("function `%D' declared virtual inside a union",
10729 return void_type_node
;
10732 if (declarator
== ansi_opname
[(int) NEW_EXPR
]
10733 || declarator
== ansi_opname
[(int) VEC_NEW_EXPR
]
10734 || declarator
== ansi_opname
[(int) DELETE_EXPR
]
10735 || declarator
== ansi_opname
[(int) VEC_DELETE_EXPR
])
10739 cp_error ("`%D' cannot be declared virtual, since it is always static",
10744 else if (staticp
< 2)
10745 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10746 TYPE_ARG_TYPES (type
));
10749 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10750 function_context
= (ctype
!= NULL_TREE
) ?
10751 hack_decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10752 publicp
= (! friendp
|| ! staticp
)
10753 && function_context
== NULL_TREE
;
10754 decl
= grokfndecl (ctype
, type
,
10755 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
10756 ? declarator
: dname
,
10758 virtualp
, flags
, quals
, raises
,
10759 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
10760 funcdef_flag
, template_count
, in_namespace
);
10761 if (decl
== NULL_TREE
)
10764 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10765 /* The decl and setting of decl_machine_attr is also turned off. */
10766 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
10769 /* [class.conv.ctor]
10771 A constructor declared without the function-specifier
10772 explicit that can be called with a single parameter
10773 specifies a conversion from the type of its first
10774 parameter to the type of its class. Such a constructor
10775 is called a converting constructor. */
10776 if (explicitp
== 2)
10777 DECL_NONCONVERTING_P (decl
) = 1;
10778 else if (DECL_CONSTRUCTOR_P (decl
))
10780 /* The constructor can be called with exactly one
10781 parameter if there is at least one parameter, and
10782 any subsequent parameters have default arguments.
10783 We don't look at the first parameter, which is
10784 really just the `this' parameter for the new
10787 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
10789 /* Skip the `in_chrg' argument too, if present. */
10790 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl
)))
10791 arg_types
= TREE_CHAIN (arg_types
);
10793 if (arg_types
== void_list_node
10795 && TREE_CHAIN (arg_types
)
10796 && TREE_CHAIN (arg_types
) != void_list_node
10797 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
10798 DECL_NONCONVERTING_P (decl
) = 1;
10801 else if (TREE_CODE (type
) == METHOD_TYPE
)
10803 /* We only get here for friend declarations of
10804 members of other classes. */
10805 /* All method decls are public, so tell grokfndecl to set
10806 TREE_PUBLIC, also. */
10807 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
10808 virtualp
, flags
, quals
, raises
,
10809 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
10810 template_count
, in_namespace
);
10811 if (decl
== NULL_TREE
)
10814 else if (!staticp
&& ! processing_template_decl
10815 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
10816 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10819 cp_error ("field `%D' has incomplete type", declarator
);
10821 cp_error ("name `%T' has incomplete type", type
);
10823 /* If we're instantiating a template, tell them which
10824 instantiation made the field's type be incomplete. */
10825 if (current_class_type
10826 && TYPE_NAME (current_class_type
)
10827 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
10828 && declspecs
&& TREE_VALUE (declspecs
)
10829 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
10830 cp_error (" in instantiation of template `%T'",
10831 current_class_type
);
10833 type
= error_mark_node
;
10840 error ("`%s' is neither function nor method; cannot be declared friend",
10841 IDENTIFIER_POINTER (declarator
));
10849 /* Friends are treated specially. */
10850 if (ctype
== current_class_type
)
10851 warning ("member functions are implicitly friends of their class");
10854 tree t
= NULL_TREE
;
10855 if (decl
&& DECL_NAME (decl
))
10857 if (template_class_depth (current_class_type
) == 0)
10860 = check_explicit_specialization
10862 template_count
, 2 * (funcdef_flag
!= 0) + 4);
10863 if (decl
== error_mark_node
)
10864 return error_mark_node
;
10867 t
= do_friend (ctype
, declarator
, decl
,
10868 last_function_parms
, attrlist
, flags
, quals
,
10871 if (t
&& funcdef_flag
)
10874 return void_type_node
;
10878 /* Structure field. It may not be a function, except for C++ */
10880 if (decl
== NULL_TREE
)
10886 /* An attempt is being made to initialize a non-static
10887 member. But, from [class.mem]:
10889 4 A member-declarator can contain a
10890 constant-initializer only if it declares a static
10891 member (_class.static_) of integral or enumeration
10892 type, see _class.static.data_.
10894 This used to be relatively common practice, but
10895 the rest of the compiler does not correctly
10896 handle the initialization unless the member is
10897 static so we make it static below. */
10898 cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
10900 cp_pedwarn ("making `%D' static", declarator
);
10904 if (uses_template_parms (type
))
10905 /* We'll check at instantiation time. */
10907 else if (check_static_variable_definition (declarator
,
10909 /* If we just return the declaration, crashes
10910 will sometimes occur. We therefore return
10911 void_type_node, as if this was a friend
10912 declaration, to cause callers to completely
10913 ignore this declaration. */
10914 return void_type_node
;
10917 /* 9.2p13 [class.mem] */
10918 if (declarator
== constructor_name (current_class_type
)
10919 /* Divergence from the standard: In extern "C", we
10920 allow non-static data members here, because C does
10921 and /usr/include/netinet/in.h uses that. */
10922 && (staticp
|| ! in_system_header
))
10923 cp_pedwarn ("ANSI C++ forbids data member `%D' with same name as enclosing class",
10928 /* C++ allows static class members. All other work
10929 for this is done by grokfield. */
10930 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
10931 TREE_STATIC (decl
) = 1;
10932 /* In class context, 'static' means public access. */
10933 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
10937 decl
= build_lang_decl (FIELD_DECL
, declarator
, type
);
10938 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10940 DECL_MUTABLE_P (decl
) = 1;
10941 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10945 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
10946 inlinep
, friendp
, raises
!= NULL_TREE
);
10949 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10951 tree original_name
;
10957 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10958 original_name
= dname
;
10960 original_name
= declarator
;
10962 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10963 error ("storage class `auto' invalid for function `%s'", name
);
10964 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10965 error ("storage class `register' invalid for function `%s'", name
);
10967 /* Function declaration not at top level.
10968 Storage classes other than `extern' are not allowed
10969 and `extern' makes no difference. */
10970 if (! toplevel_bindings_p ()
10971 && (RIDBIT_SETP (RID_STATIC
, specbits
)
10972 || RIDBIT_SETP (RID_INLINE
, specbits
))
10975 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10976 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
10978 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
10981 if (ctype
== NULL_TREE
)
10985 error ("virtual non-class function `%s'", name
);
10989 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
10990 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10991 TYPE_ARG_TYPES (type
));
10993 /* Record presence of `static'. */
10994 publicp
= (ctype
!= NULL_TREE
10995 || RIDBIT_SETP (RID_EXTERN
, specbits
)
10996 || !RIDBIT_SETP (RID_STATIC
, specbits
));
10998 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
10999 virtualp
, flags
, quals
, raises
,
11001 publicp
, inlinep
, funcdef_flag
,
11002 template_count
, in_namespace
);
11003 if (decl
== NULL_TREE
)
11008 int illegal_static
= 0;
11010 /* Don't allow a static member function in a class, and forbid
11011 declaring main to be static. */
11012 if (TREE_CODE (type
) == METHOD_TYPE
)
11014 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
11015 illegal_static
= 1;
11017 else if (current_function_decl
)
11019 /* FIXME need arm citation */
11020 error ("cannot declare static function inside another function");
11021 illegal_static
= 1;
11024 if (illegal_static
)
11027 RIDBIT_RESET (RID_STATIC
, specbits
);
11033 /* It's a variable. */
11035 /* An uninitialized decl with `extern' is a reference. */
11036 decl
= grokvardecl (type
, declarator
, &specbits
,
11038 (type_quals
& TYPE_QUAL_CONST
) != 0,
11040 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
11041 inlinep
, friendp
, raises
!= NULL_TREE
);
11045 DECL_CONTEXT (decl
) = ctype
;
11048 cp_pedwarn ("static member `%D' re-declared as static", decl
);
11050 RIDBIT_RESET (RID_STATIC
, specbits
);
11052 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
11054 cp_error ("static member `%D' declared `register'", decl
);
11055 RIDBIT_RESET (RID_REGISTER
, specbits
);
11057 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
11059 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11061 RIDBIT_RESET (RID_EXTERN
, specbits
);
11066 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE
, specbits
), 19990927);
11068 /* Record `register' declaration for warnings on &
11069 and in case doing stupid register allocation. */
11071 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11072 DECL_REGISTER (decl
) = 1;
11074 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
11075 DECL_THIS_EXTERN (decl
) = 1;
11077 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11078 DECL_THIS_STATIC (decl
) = 1;
11080 /* Record constancy and volatility. There's no need to do this
11081 when processing a template; we'll do this for the instantiated
11082 declaration based on the type of DECL. */
11083 if (!processing_template_decl
)
11084 c_apply_type_quals_to_decl (type_quals
, decl
);
11090 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11091 An empty exprlist is a parmlist. An exprlist which
11092 contains only identifiers at the global level
11093 is a parmlist. Otherwise, it is an exprlist. */
11096 parmlist_is_exprlist (exprs
)
11099 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
11102 if (toplevel_bindings_p ())
11104 /* At the global level, if these are all identifiers,
11105 then it is a parmlist. */
11108 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
11110 exprs
= TREE_CHAIN (exprs
);
11117 /* Subroutine of start_function. Ensure that each of the parameter
11118 types (as listed in PARMS) is complete, as is required for a
11119 function definition. */
11122 require_complete_types_for_parms (parms
)
11127 tree type
= TREE_TYPE (parms
);
11128 if (TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
11130 if (DECL_NAME (parms
))
11131 error ("parameter `%s' has incomplete type",
11132 IDENTIFIER_POINTER (DECL_NAME (parms
)));
11134 error ("parameter has incomplete type");
11135 TREE_TYPE (parms
) = error_mark_node
;
11138 layout_decl (parms
, 0);
11140 parms
= TREE_CHAIN (parms
);
11144 /* Returns *TP if *TP is a local variable (or parameter). Returns
11145 NULL_TREE otherwise. */
11148 local_variable_p (tp
, walk_subtrees
, data
)
11150 int *walk_subtrees ATTRIBUTE_UNUSED
;
11151 void *data ATTRIBUTE_UNUSED
;
11155 if ((TREE_CODE (t
) == VAR_DECL
11156 /* A VAR_DECL with a context that is a _TYPE is a static data
11158 && !TYPE_P (CP_DECL_CONTEXT (t
))
11159 /* Any other non-local variable must be at namespace scope. */
11160 && TREE_CODE (CP_DECL_CONTEXT (t
)) != NAMESPACE_DECL
)
11161 || (TREE_CODE (t
) == PARM_DECL
))
11167 /* Check that ARG, which is a default-argument expression for a
11168 parameter DECL, is legal. Returns ARG, or ERROR_MARK_NODE, if
11169 something goes wrong. DECL may also be a _TYPE node, rather than a
11170 DECL, if there is no DECL available. */
11173 check_default_argument (decl
, arg
)
11180 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11181 /* We get a DEFAULT_ARG when looking at an in-class declaration
11182 with a default argument. Ignore the argument for now; we'll
11183 deal with it after the class is complete. */
11186 if (processing_template_decl
|| uses_template_parms (arg
))
11187 /* We don't do anything checking until instantiation-time. Note
11188 that there may be uninstantiated arguments even for an
11189 instantiated function, since default arguments are not
11190 instantiated until they are needed. */
11199 decl_type
= TREE_TYPE (decl
);
11201 if (arg
== error_mark_node
11202 || decl
== error_mark_node
11203 || TREE_TYPE (arg
) == error_mark_node
11204 || decl_type
== error_mark_node
)
11205 /* Something already went wrong. There's no need to check
11207 return error_mark_node
;
11209 /* [dcl.fct.default]
11211 A default argument expression is implicitly converted to the
11213 if (!TREE_TYPE (arg
)
11214 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
))
11217 cp_error ("default argument for `%#D' has type `%T'",
11218 decl
, TREE_TYPE (arg
));
11220 cp_error ("default argument for parameter of type `%T' has type `%T'",
11221 decl_type
, TREE_TYPE (arg
));
11223 return error_mark_node
;
11226 /* [dcl.fct.default]
11228 Local variables shall not be used in default argument
11231 The keyword `this' shall not be used in a default argument of a
11232 member function. */
11233 var
= walk_tree (&arg
, local_variable_p
, NULL
);
11236 cp_error ("default argument `%E' uses local variable `%D'",
11238 return error_mark_node
;
11245 /* Decode the list of parameter types for a function type.
11246 Given the list of things declared inside the parens,
11247 return a list of types.
11249 The list we receive can have three kinds of elements:
11250 an IDENTIFIER_NODE for names given without types,
11251 a TREE_LIST node for arguments given as typespecs or names with typespecs,
11252 or void_type_node, to mark the end of an argument list
11253 when additional arguments are not permitted (... was not used).
11255 FUNCDEF_FLAG is nonzero for a function definition, 0 for
11256 a mere declaration. A nonempty identifier-list gets an error message
11257 when FUNCDEF_FLAG is zero.
11258 If FUNCDEF_FLAG is 1, then parameter types must be complete.
11259 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11261 If all elements of the input list contain types,
11262 we return a list of the types.
11263 If all elements contain no type (except perhaps a void_type_node
11264 at the end), we return a null list.
11265 If some have types and some do not, it is an error, and we
11266 return a null list.
11268 Also set last_function_parms to either
11269 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11270 A list of names is converted to a chain of PARM_DECLs
11271 by store_parm_decls so that ultimately it is always a chain of decls.
11273 Note that in C++, parameters can take default values. These default
11274 values are in the TREE_PURPOSE field of the TREE_LIST. It is
11275 an error to specify default values which are followed by parameters
11276 that have no default values, or an ELLIPSES. For simplicities sake,
11277 only parameters which are specified with their types can take on
11281 grokparms (first_parm
, funcdef_flag
)
11285 tree result
= NULL_TREE
;
11286 tree decls
= NULL_TREE
;
11288 if (first_parm
!= NULL_TREE
11289 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
11291 if (! funcdef_flag
)
11292 pedwarn ("parameter names (without types) in function declaration");
11293 last_function_parms
= first_parm
;
11296 else if (first_parm
!= NULL_TREE
11297 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
11298 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
11299 my_friendly_abort (145);
11302 /* Types were specified. This is a list of declarators
11303 each represented as a TREE_LIST node. */
11304 register tree parm
, chain
;
11305 int any_init
= 0, any_error
= 0;
11307 if (first_parm
!= NULL_TREE
)
11309 tree last_result
= NULL_TREE
;
11310 tree last_decl
= NULL_TREE
;
11312 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
11314 tree type
= NULL_TREE
, list_node
= parm
;
11315 register tree decl
= TREE_VALUE (parm
);
11316 tree init
= TREE_PURPOSE (parm
);
11318 chain
= TREE_CHAIN (parm
);
11319 /* @@ weak defense against parse errors. */
11320 if (TREE_CODE (decl
) != VOID_TYPE
11321 && TREE_CODE (decl
) != TREE_LIST
)
11323 /* Give various messages as the need arises. */
11324 if (TREE_CODE (decl
) == STRING_CST
)
11325 cp_error ("invalid string constant `%E'", decl
);
11326 else if (TREE_CODE (decl
) == INTEGER_CST
)
11327 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11331 if (TREE_CODE (decl
) != VOID_TYPE
)
11333 decl
= grokdeclarator (TREE_VALUE (decl
),
11334 TREE_PURPOSE (decl
),
11335 PARM
, init
!= NULL_TREE
,
11337 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11340 /* Top-level qualifiers on the parameters are
11341 ignored for function types. */
11342 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
11344 if (TREE_CODE (type
) == VOID_TYPE
)
11345 decl
= void_type_node
;
11346 else if (TREE_CODE (type
) == METHOD_TYPE
)
11348 if (DECL_NAME (decl
))
11349 /* Cannot use the decl here because
11350 we don't have DECL_CONTEXT set up yet. */
11351 cp_error ("parameter `%D' invalidly declared method type",
11354 error ("parameter invalidly declared method type");
11355 type
= build_pointer_type (type
);
11356 TREE_TYPE (decl
) = type
;
11358 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11360 if (DECL_NAME (decl
))
11361 cp_error ("parameter `%D' invalidly declared offset type",
11364 error ("parameter invalidly declared offset type");
11365 type
= build_pointer_type (type
);
11366 TREE_TYPE (decl
) = type
;
11368 else if (abstract_virtuals_error (decl
, type
))
11369 any_error
= 1; /* Seems like a good idea. */
11370 else if (POINTER_TYPE_P (type
))
11373 while (POINTER_TYPE_P (t
)
11374 || (TREE_CODE (t
) == ARRAY_TYPE
11375 && TYPE_DOMAIN (t
) != NULL_TREE
))
11377 if (TREE_CODE (t
) == ARRAY_TYPE
)
11378 cp_error ("parameter type `%T' includes %s to array of unknown bound",
11380 TYPE_PTR_P (type
) ? "pointer" : "reference");
11384 if (TREE_CODE (decl
) == VOID_TYPE
)
11386 if (result
== NULL_TREE
)
11388 result
= void_list_node
;
11389 last_result
= result
;
11393 TREE_CHAIN (last_result
) = void_list_node
;
11394 last_result
= void_list_node
;
11397 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
11398 error ("`void' in parameter list must be entire list");
11402 /* Since there is a prototype, args are passed in their own types. */
11403 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
11404 if (PROMOTE_PROTOTYPES
11405 && (TREE_CODE (type
) == INTEGER_TYPE
11406 || TREE_CODE (type
) == ENUMERAL_TYPE
)
11407 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
11408 DECL_ARG_TYPE (decl
) = integer_type_node
;
11409 if (!any_error
&& init
)
11412 init
= check_default_argument (decl
, init
);
11417 if (decls
== NULL_TREE
)
11424 TREE_CHAIN (last_decl
) = decl
;
11427 list_node
= tree_cons (init
, type
, NULL_TREE
);
11428 if (result
== NULL_TREE
)
11430 result
= list_node
;
11431 last_result
= result
;
11435 TREE_CHAIN (last_result
) = list_node
;
11436 last_result
= list_node
;
11440 TREE_CHAIN (last_result
) = NULL_TREE
;
11441 /* If there are no parameters, and the function does not end
11442 with `...', then last_decl will be NULL_TREE. */
11443 if (last_decl
!= NULL_TREE
)
11444 TREE_CHAIN (last_decl
) = NULL_TREE
;
11448 last_function_parms
= decls
;
11453 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11454 FUNCTION_TYPE with the newly parsed version of its default argument, which
11455 was previously digested as text. See snarf_defarg et al in lex.c. */
11458 replace_defarg (arg
, init
)
11461 if (! processing_template_decl
11462 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
11463 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11464 TREE_TYPE (init
), TREE_VALUE (arg
));
11465 TREE_PURPOSE (arg
) = init
;
11472 tree t
= FUNCTION_ARG_CHAIN (d
);
11473 if (DECL_CONSTRUCTOR_P (d
)
11474 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d
)))
11475 t
= TREE_CHAIN (t
);
11476 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
11477 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
11478 == DECL_CLASS_CONTEXT (d
))
11479 && (TREE_CHAIN (t
) == NULL_TREE
11480 || TREE_CHAIN (t
) == void_list_node
11481 || TREE_PURPOSE (TREE_CHAIN (t
))))
11486 /* These memoizing functions keep track of special properties which
11487 a class may have. `grok_ctor_properties' notices whether a class
11488 has a constructor of the form X(X&), and also complains
11489 if the class has a constructor of the form X(X).
11490 `grok_op_properties' takes notice of the various forms of
11491 operator= which are defined, as well as what sorts of type conversion
11492 may apply. Both functions take a FUNCTION_DECL as an argument. */
11495 grok_ctor_properties (ctype
, decl
)
11498 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
11499 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
11501 /* When a type has virtual baseclasses, a magical first int argument is
11502 added to any ctor so we can tell if the class has been initialized
11503 yet. This could screw things up in this function, so we deliberately
11504 ignore the leading int if we're in that situation. */
11505 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
11507 my_friendly_assert (parmtypes
11508 && TREE_VALUE (parmtypes
) == integer_type_node
,
11510 parmtypes
= TREE_CHAIN (parmtypes
);
11511 parmtype
= TREE_VALUE (parmtypes
);
11516 A non-template constructor for class X is a copy constructor if
11517 its first parameter is of type X&, const X&, volatile X& or const
11518 volatile X&, and either there are no other parameters or else all
11519 other parameters have default arguments. */
11520 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
11521 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
11522 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11523 || TREE_CHAIN (parmtypes
) == void_list_node
11524 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
11525 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11526 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11528 TYPE_HAS_INIT_REF (ctype
) = 1;
11529 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11530 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
11534 A declaration of a constructor for a class X is ill-formed if its
11535 first parameter is of type (optionally cv-qualified) X and either
11536 there are no other parameters or else all other parameters have
11539 We *don't* complain about member template instantiations that
11540 have this form, though; they can occur as we try to decide what
11541 constructor to use during overload resolution. Since overload
11542 resolution will never prefer such a constructor to the
11543 non-template copy constructor (which is either explicitly or
11544 implicitly defined), there's no need to worry about their
11545 existence. Theoretically, they should never even be
11546 instantiated, but that's hard to forestall. */
11547 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
11548 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11549 || TREE_CHAIN (parmtypes
) == void_list_node
11550 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
11551 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11552 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11554 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11556 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
11559 else if (TREE_CODE (parmtype
) == VOID_TYPE
11560 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
11561 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
11566 /* An operator with this name can be either unary or binary. */
11572 return (name
== ansi_opname
[(int) INDIRECT_REF
]
11573 || name
== ansi_opname
[(int) ADDR_EXPR
]
11574 || name
== ansi_opname
[(int) NEGATE_EXPR
]
11575 || name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11576 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]
11577 || name
== ansi_opname
[(int) CONVERT_EXPR
]);
11580 /* An operator with this name can only be unary. */
11586 return (name
== ansi_opname
[(int) TRUTH_NOT_EXPR
]
11587 || name
== ansi_opname
[(int) BIT_NOT_EXPR
]
11588 || name
== ansi_opname
[(int) COMPONENT_REF
]
11589 || IDENTIFIER_TYPENAME_P (name
));
11592 /* Do a little sanity-checking on how they declared their operator. */
11595 grok_op_properties (decl
, virtualp
, friendp
)
11597 int virtualp
, friendp
;
11599 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11600 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11601 tree name
= DECL_NAME (decl
);
11603 if (current_class_type
== NULL_TREE
)
11610 A user-declared copy assignment operator X::operator= is a
11611 non-static non-template member function of class X with
11612 exactly one parameter of type X, X&, const X&, volatile X& or
11613 const volatile X&. */
11614 if (name
== ansi_opname
[(int) MODIFY_EXPR
]
11615 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11616 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11618 else if (name
== ansi_opname
[(int) CALL_EXPR
])
11619 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
11620 else if (name
== ansi_opname
[(int) ARRAY_REF
])
11621 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
11622 else if (name
== ansi_opname
[(int) COMPONENT_REF
]
11623 || name
== ansi_opname
[(int) MEMBER_REF
])
11624 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
11625 else if (name
== ansi_opname
[(int) NEW_EXPR
])
11626 TYPE_GETS_NEW (current_class_type
) |= 1;
11627 else if (name
== ansi_opname
[(int) DELETE_EXPR
])
11628 TYPE_GETS_DELETE (current_class_type
) |= 1;
11629 else if (name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11630 TYPE_GETS_NEW (current_class_type
) |= 2;
11631 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11632 TYPE_GETS_DELETE (current_class_type
) |= 2;
11635 if (name
== ansi_opname
[(int) NEW_EXPR
]
11636 || name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11638 /* When the compiler encounters the definition of A::operator new, it
11639 doesn't look at the class declaration to find out if it's static. */
11641 revert_static_member_fn (&decl
, NULL
, NULL
);
11643 /* Take care of function decl if we had syntax errors. */
11644 if (argtypes
== NULL_TREE
)
11646 = build_function_type (ptr_type_node
,
11647 hash_tree_chain (integer_type_node
,
11650 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11652 else if (name
== ansi_opname
[(int) DELETE_EXPR
]
11653 || name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11656 revert_static_member_fn (&decl
, NULL
, NULL
);
11658 if (argtypes
== NULL_TREE
)
11660 = build_function_type (void_type_node
,
11661 hash_tree_chain (ptr_type_node
,
11665 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11667 if (! friendp
&& name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
11668 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
11669 != void_list_node
))
11670 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type
) = 1;
11675 /* An operator function must either be a non-static member function
11676 or have at least one parameter of a class, a reference to a class,
11677 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11678 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11680 if (IDENTIFIER_TYPENAME_P (name
)
11681 || name
== ansi_opname
[(int) CALL_EXPR
]
11682 || name
== ansi_opname
[(int) MODIFY_EXPR
]
11683 || name
== ansi_opname
[(int) COMPONENT_REF
]
11684 || name
== ansi_opname
[(int) ARRAY_REF
])
11685 cp_error ("`%D' must be a nonstatic member function", decl
);
11690 if (DECL_STATIC_FUNCTION_P (decl
))
11691 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
11694 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
11696 tree arg
= TREE_VALUE (p
);
11697 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
11698 arg
= TREE_TYPE (arg
);
11700 /* This lets bad template code slip through. */
11701 if (IS_AGGR_TYPE (arg
)
11702 || TREE_CODE (arg
) == ENUMERAL_TYPE
11703 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
11704 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11708 ("`%D' must have an argument of class or enumerated type",
11715 if (name
== ansi_opname
[(int) CALL_EXPR
])
11716 return; /* No restrictions on args. */
11718 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
11720 tree t
= TREE_TYPE (name
);
11721 if (TREE_CODE (t
) == VOID_TYPE
)
11722 pedwarn ("void is not a valid type conversion operator");
11723 else if (! friendp
)
11725 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11726 const char *what
= 0;
11728 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11730 if (t
== current_class_type
)
11731 what
= "the same type";
11732 /* Don't force t to be complete here. */
11733 else if (IS_AGGR_TYPE (t
)
11735 && DERIVED_FROM_P (t
, current_class_type
))
11736 what
= "a base class";
11739 warning ("conversion to %s%s will never use a type conversion operator",
11740 ref
? "a reference to " : "", what
);
11744 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11748 if (list_length (argtypes
) != 3 && methodp
)
11750 cp_error ("`%D' must take exactly one argument", decl
);
11753 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
11755 if (copy_assignment_arg_p (parmtype
, virtualp
)
11758 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
11759 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
11760 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11761 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
11764 else if (name
== ansi_opname
[(int) COND_EXPR
])
11767 cp_error ("ANSI C++ prohibits overloading operator ?:");
11769 else if (ambi_op_p (name
))
11771 if (list_length (argtypes
) == 2)
11773 else if (list_length (argtypes
) == 3)
11775 if ((name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11776 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11777 && ! processing_template_decl
11778 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11781 cp_error ("postfix `%D' must take `int' as its argument",
11785 ("postfix `%D' must take `int' as its second argument",
11792 cp_error ("`%D' must take either zero or one argument", decl
);
11794 cp_error ("`%D' must take either one or two arguments", decl
);
11797 /* More Effective C++ rule 6. */
11799 && (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11800 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]))
11802 tree arg
= TREE_VALUE (argtypes
);
11803 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11804 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11805 arg
= TREE_TYPE (arg
);
11806 arg
= TYPE_MAIN_VARIANT (arg
);
11807 if (list_length (argtypes
) == 2)
11809 if (TREE_CODE (ret
) != REFERENCE_TYPE
11810 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11812 cp_warning ("prefix `%D' should return `%T'", decl
,
11813 build_reference_type (arg
));
11817 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11818 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
11822 else if (unary_op_p (name
))
11824 if (list_length (argtypes
) != 2)
11827 cp_error ("`%D' must take `void'", decl
);
11829 cp_error ("`%D' must take exactly one argument", decl
);
11832 else /* if (binary_op_p (name)) */
11834 if (list_length (argtypes
) != 3)
11837 cp_error ("`%D' must take exactly one argument", decl
);
11839 cp_error ("`%D' must take exactly two arguments", decl
);
11842 /* More Effective C++ rule 7. */
11844 && (name
== ansi_opname
[TRUTH_ANDIF_EXPR
]
11845 || name
== ansi_opname
[TRUTH_ORIF_EXPR
]
11846 || name
== ansi_opname
[COMPOUND_EXPR
]))
11847 cp_warning ("user-defined `%D' always evaluates both arguments",
11851 /* Effective C++ rule 23. */
11853 && list_length (argtypes
) == 3
11854 && (name
== ansi_opname
[PLUS_EXPR
]
11855 || name
== ansi_opname
[MINUS_EXPR
]
11856 || name
== ansi_opname
[TRUNC_DIV_EXPR
]
11857 || name
== ansi_opname
[MULT_EXPR
])
11858 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11859 cp_warning ("`%D' should return by value", decl
);
11863 for (; argtypes
!= void_list_node
; argtypes
= TREE_CHAIN (argtypes
))
11864 if (TREE_PURPOSE (argtypes
))
11866 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11867 if (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11868 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11871 cp_pedwarn ("`%D' cannot have default arguments", decl
);
11874 cp_error ("`%D' cannot have default arguments", decl
);
11879 static const char *
11881 enum tag_types code
;
11894 my_friendly_abort (981122);
11898 /* Get the struct, enum or union (CODE says which) with tag NAME.
11899 Define the tag as a forward-reference if it is not defined.
11901 C++: If a class derivation is given, process it here, and report
11902 an error if multiple derivation declarations are not identical.
11904 If this is a definition, come in through xref_tag and only look in
11905 the current frame for the name (since C++ allows new names in any
11909 xref_tag (code_type_node
, name
, globalize
)
11910 tree code_type_node
;
11914 enum tag_types tag_code
;
11915 enum tree_code code
;
11916 register tree ref
, t
;
11917 struct binding_level
*b
= current_binding_level
;
11919 tree attributes
= NULL_TREE
;
11920 tree context
= NULL_TREE
;
11922 /* If we are called from the parser, code_type_node will sometimes be a
11923 TREE_LIST. This indicates that the user wrote
11924 "class __attribute__ ((foo)) bar". Extract the attributes so we can
11926 if (TREE_CODE (code_type_node
) == TREE_LIST
)
11928 attributes
= TREE_PURPOSE (code_type_node
);
11929 code_type_node
= TREE_VALUE (code_type_node
);
11932 tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11937 code
= RECORD_TYPE
;
11943 code
= ENUMERAL_TYPE
;
11946 my_friendly_abort (18);
11949 /* If a cross reference is requested, look up the type
11950 already defined for this tag and return it. */
11951 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
11954 name
= TYPE_IDENTIFIER (t
);
11958 t
= IDENTIFIER_TYPE_VALUE (name
);
11960 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
11961 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
)
11966 /* If we know we are defining this tag, only look it up in
11967 this scope and don't try to find it as a type. */
11968 ref
= lookup_tag (code
, name
, b
, 1);
11974 /* [dcl.type.elab] If the identifier resolves to a
11975 typedef-name or a template type-parameter, the
11976 elaborated-type-specifier is ill-formed. */
11977 if (t
!= TYPE_MAIN_VARIANT (t
)
11978 || (CLASS_TYPE_P (t
) && TYPE_WAS_ANONYMOUS (t
)))
11979 cp_pedwarn ("using typedef-name `%D' after `%s'",
11980 TYPE_NAME (t
), tag_name (tag_code
));
11981 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
11982 cp_error ("using template type parameter `%T' after `%s'",
11983 t
, tag_name (tag_code
));
11988 ref
= lookup_tag (code
, name
, b
, 0);
11992 /* Try finding it as a type declaration. If that wins,
11994 ref
= lookup_name (name
, 1);
11996 if (ref
!= NULL_TREE
11997 && processing_template_decl
11998 && DECL_CLASS_TEMPLATE_P (ref
)
11999 && template_class_depth (current_class_type
) == 0)
12000 /* Since GLOBALIZE is true, we're declaring a global
12001 template, so we want this type. */
12002 ref
= DECL_RESULT (ref
);
12004 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
12005 && TREE_CODE (TREE_TYPE (ref
)) == code
)
12006 ref
= TREE_TYPE (ref
);
12011 if (ref
&& current_class_type
12012 && template_class_depth (current_class_type
)
12013 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12015 /* Since GLOBALIZE is non-zero, we are not looking at a
12016 definition of this tag. Since, in addition, we are currently
12017 processing a (member) template declaration of a template
12018 class, we must be very careful; consider:
12025 { template <class V>
12026 friend struct S1; };
12028 Here, the S2::S1 declaration should not be confused with the
12029 outer declaration. In particular, the inner version should
12030 have a template parameter of level 2, not level 1. This
12031 would be particularly important if the member declaration
12034 template <class V = U> friend struct S1;
12036 say, when we should tsubst into `U' when instantiating
12037 S2. On the other hand, when presented with:
12047 we must find the inner binding eventually. We
12048 accomplish this by making sure that the new type we
12049 create to represent this declaration has the right
12051 context
= TYPE_CONTEXT (ref
);
12058 /* If no such tag is yet defined, create a forward-reference node
12059 and record it as the "definition".
12060 When a real declaration of this type is found,
12061 the forward-reference will be altered into a real type. */
12062 if (code
== ENUMERAL_TYPE
)
12064 cp_error ("use of enum `%#D' without previous declaration", name
);
12066 ref
= make_node (ENUMERAL_TYPE
);
12068 /* Give the type a default layout like unsigned int
12069 to avoid crashing if it does not get defined. */
12070 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
12071 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
12072 TREE_UNSIGNED (ref
) = 1;
12073 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
12074 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
12075 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
12077 /* Enable us to recognize when a type is created in class context.
12078 To do nested classes correctly, this should probably be cleared
12079 out when we leave this classes scope. Currently this in only
12080 done in `start_enum'. */
12082 pushtag (name
, ref
, globalize
);
12086 struct binding_level
*old_b
= class_binding_level
;
12088 ref
= make_lang_type (code
);
12089 TYPE_CONTEXT (ref
) = context
;
12091 #ifdef NONNESTED_CLASSES
12092 /* Class types don't nest the way enums do. */
12093 class_binding_level
= (struct binding_level
*)0;
12095 pushtag (name
, ref
, globalize
);
12096 class_binding_level
= old_b
;
12101 /* If it no longer looks like a nested type, make sure it's
12103 If it is not an IDENTIFIER, this is not a declaration */
12104 if (b
->namespace_p
&& !class_binding_level
12105 && TREE_CODE (name
) == IDENTIFIER_NODE
12106 && IDENTIFIER_NAMESPACE_VALUE (name
) == NULL_TREE
)
12107 SET_IDENTIFIER_NAMESPACE_VALUE (name
, TYPE_NAME (ref
));
12109 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
12110 redeclare_class_template (ref
, current_template_parms
);
12113 /* Until the type is defined, tentatively accept whatever
12114 structure tag the user hands us. */
12115 if (TYPE_SIZE (ref
) == NULL_TREE
12116 && ref
!= current_class_type
12117 /* Have to check this, in case we have contradictory tag info. */
12118 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
12120 if (tag_code
== class_type
)
12121 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
12122 else if (tag_code
== record_type
)
12123 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
12126 TREE_TYPE (ref
) = attributes
;
12132 xref_tag_from_type (old
, id
, globalize
)
12136 tree code_type_node
;
12138 if (TREE_CODE (old
) == RECORD_TYPE
)
12139 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
12140 ? class_type_node
: record_type_node
);
12142 code_type_node
= union_type_node
;
12144 if (id
== NULL_TREE
)
12145 id
= TYPE_IDENTIFIER (old
);
12147 return xref_tag (code_type_node
, id
, globalize
);
12150 /* REF is a type (named NAME), for which we have just seen some
12151 baseclasses. BINFO is a list of those baseclasses; the
12152 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12153 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12154 struct, or union. */
12157 xref_basetypes (code_type_node
, name
, ref
, binfo
)
12158 tree code_type_node
;
12162 /* In the declaration `A : X, Y, ... Z' we mark all the types
12163 (A, X, Y, ..., Z) so we can check for duplicates. */
12168 enum tag_types tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
12170 if (tag_code
== union_type
)
12172 cp_error ("derived union `%T' invalid", ref
);
12176 len
= list_length (binfo
);
12178 /* First, make sure that any templates in base-classes are
12179 instantiated. This ensures that if we call ourselves recursively
12180 we do not get confused about which classes are marked and which
12182 for (base
= binfo
; base
; base
= TREE_CHAIN (base
))
12183 complete_type (TREE_VALUE (base
));
12185 SET_CLASSTYPE_MARKED (ref
);
12186 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
12188 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
12190 /* The base of a derived struct is public by default. */
12192 = (TREE_PURPOSE (binfo
) == access_public_node
12193 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12194 || (tag_code
!= class_type
12195 && (TREE_PURPOSE (binfo
) == access_default_node
12196 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
12198 = (TREE_PURPOSE (binfo
) == access_protected_node
12199 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
12201 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
12202 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
12203 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12204 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
12205 tree basetype
= TREE_VALUE (binfo
);
12208 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
12209 basetype
= TREE_TYPE (basetype
);
12211 || (TREE_CODE (basetype
) != RECORD_TYPE
12212 && TREE_CODE (basetype
) != TYPENAME_TYPE
12213 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
12214 && TREE_CODE (basetype
) != TEMPLATE_TEMPLATE_PARM
))
12216 cp_error ("base type `%T' fails to be a struct or class type",
12217 TREE_VALUE (binfo
));
12221 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
12223 /* This code replaces similar code in layout_basetypes.
12224 We put the complete_type first for implicit `typename'. */
12225 if (TYPE_SIZE (basetype
) == NULL_TREE
12226 && ! (current_template_parms
&& uses_template_parms (basetype
)))
12228 cp_error ("base class `%T' has incomplete type", basetype
);
12233 if (CLASSTYPE_MARKED (basetype
))
12235 if (basetype
== ref
)
12236 cp_error ("recursive type `%T' undefined", basetype
);
12238 cp_error ("duplicate base type `%T' invalid", basetype
);
12242 if (TYPE_FOR_JAVA (basetype
)
12243 && (current_lang_stack
12244 == &VARRAY_TREE (current_lang_base
, 0)))
12245 TYPE_FOR_JAVA (ref
) = 1;
12247 /* Note that the BINFO records which describe individual
12248 inheritances are *not* shared in the lattice! They
12249 cannot be shared because a given baseclass may be
12250 inherited with different `accessibility' by different
12251 derived classes. (Each BINFO record describing an
12252 individual inheritance contains flags which say what
12253 the `accessibility' of that particular inheritance is.) */
12256 = make_binfo (integer_zero_node
, basetype
,
12257 CLASS_TYPE_P (basetype
)
12258 ? TYPE_BINFO_VTABLE (basetype
) : NULL_TREE
,
12259 CLASS_TYPE_P (basetype
)
12260 ? TYPE_BINFO_VIRTUALS (basetype
) : NULL_TREE
);
12262 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
12263 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
12264 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
12265 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
12266 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
12268 /* We need to unshare the binfos now so that lookups during class
12269 definition work. */
12270 unshare_base_binfos (base_binfo
);
12272 SET_CLASSTYPE_MARKED (basetype
);
12274 /* We are free to modify these bits because they are meaningless
12275 at top level, and BASETYPE is a top-level type. */
12276 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
12278 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
12279 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12282 if (CLASS_TYPE_P (basetype
))
12284 TYPE_GETS_NEW (ref
) |= TYPE_GETS_NEW (basetype
);
12285 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12292 TREE_VEC_LENGTH (binfos
) = i
;
12294 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
12297 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
12300 tree basetype
= BINFO_TYPE (TREE_VEC_ELT (binfos
, 0));
12302 if (CLASS_TYPE_P (basetype
))
12303 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
12304 = TYPE_USES_MULTIPLE_INHERITANCE (basetype
);
12307 if (TYPE_USES_MULTIPLE_INHERITANCE (ref
))
12308 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12310 /* Unmark all the types. */
12312 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
12313 CLEAR_CLASSTYPE_MARKED (ref
);
12315 /* Now that we know all the base-classes, set up the list of virtual
12317 CLASSTYPE_VBASECLASSES (ref
) = get_vbase_types (ref
);
12321 /* Begin compiling the definition of an enumeration type.
12322 NAME is its name (or null if anonymous).
12323 Returns the type object, as yet incomplete.
12324 Also records info about it so that build_enumerator
12325 may be used to declare the individual values as they are read. */
12331 register tree enumtype
= NULL_TREE
;
12332 struct binding_level
*b
= current_binding_level
;
12334 /* If this is the real definition for a previous forward reference,
12335 fill in the contents in the same object that used to be the
12336 forward reference. */
12338 if (name
!= NULL_TREE
)
12339 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
12341 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12343 cp_error ("multiple definition of `%#T'", enumtype
);
12344 cp_error_at ("previous definition here", enumtype
);
12345 /* Clear out TYPE_VALUES, and start again. */
12346 TYPE_VALUES (enumtype
) = NULL_TREE
;
12350 enumtype
= make_node (ENUMERAL_TYPE
);
12351 pushtag (name
, enumtype
, 0);
12354 if (current_class_type
)
12355 TREE_ADDRESSABLE (b
->tags
) = 1;
12357 GNU_xref_decl (current_function_decl
, enumtype
);
12361 /* After processing and defining all the values of an enumeration type,
12362 install their decls in the enumeration type and finish it off.
12363 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12364 Returns ENUMTYPE. */
12367 finish_enum (enumtype
)
12370 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
12371 /* Calculate the maximum value of any enumerator in this type. */
12373 tree values
= TYPE_VALUES (enumtype
);
12378 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
12383 /* The TREE_VALUE is a CONST_DECL for this enumeration
12385 decl
= TREE_VALUE (pair
);
12389 Following the closing brace of an enum-specifier, each
12390 enumerator has the type of its enumeration. Prior to the
12391 closing brace, the type of each enumerator is the type of
12392 its initializing value. */
12393 TREE_TYPE (decl
) = enumtype
;
12395 /* The DECL_INITIAL will be NULL if we are processing a
12396 template declaration and this enumeration constant had no
12397 explicit initializer. */
12398 value
= DECL_INITIAL (decl
);
12399 if (value
&& !processing_template_decl
)
12401 /* Set the TREE_TYPE for the VALUE as well. That's so
12402 that when we call decl_constant_value we get an
12403 entity of the right type (but with the constant
12404 value). Since we shouldn't ever call
12405 decl_constant_value on a template type, there's no
12406 reason to do that when processing_template_decl.
12407 And, if the expression is something like a
12408 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12409 wreak havoc on the intended type of the expression.
12411 Of course, there's also no point in trying to compute
12412 minimum or maximum values if we're in a template. */
12413 TREE_TYPE (value
) = enumtype
;
12416 minnode
= maxnode
= value
;
12417 else if (tree_int_cst_lt (maxnode
, value
))
12419 else if (tree_int_cst_lt (value
, minnode
))
12423 if (processing_template_decl
)
12424 /* If this is just a template, leave the CONST_DECL
12425 alone. That way tsubst_copy will find CONST_DECLs for
12426 CONST_DECLs, and not INTEGER_CSTs. */
12429 /* In the list we're building up, we want the enumeration
12430 values, not the CONST_DECLs. */
12431 TREE_VALUE (pair
) = value
;
12435 maxnode
= minnode
= integer_zero_node
;
12437 TYPE_VALUES (enumtype
) = nreverse (values
);
12439 if (processing_template_decl
)
12441 tree scope
= current_scope ();
12442 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
12443 add_tree (build_min (TAG_DEFN
, enumtype
));
12447 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12448 int lowprec
= min_precision (minnode
, unsignedp
);
12449 int highprec
= min_precision (maxnode
, unsignedp
);
12450 int precision
= MAX (lowprec
, highprec
);
12453 TYPE_SIZE (enumtype
) = NULL_TREE
;
12455 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12457 TYPE_PRECISION (enumtype
) = precision
;
12459 fixup_unsigned_type (enumtype
);
12461 fixup_signed_type (enumtype
);
12463 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
12464 /* Use the width of the narrowest normal C type which is wide
12466 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
12469 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
12471 TYPE_SIZE (enumtype
) = 0;
12472 layout_type (enumtype
);
12474 /* Fix up all variant types of this enum type. */
12475 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
12476 tem
= TYPE_NEXT_VARIANT (tem
))
12478 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
12479 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
12480 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
12481 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
12482 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
12483 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
12484 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
12485 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
12486 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
12489 /* Finish debugging output for this type. */
12490 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12496 /* Build and install a CONST_DECL for an enumeration constant of the
12497 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12498 Assignment of sequential values by default is handled here. */
12501 build_enumerator (name
, value
, enumtype
)
12511 /* Remove no-op casts from the value. */
12513 STRIP_TYPE_NOPS (value
);
12515 if (! processing_template_decl
)
12517 /* Validate and default VALUE. */
12518 if (value
!= NULL_TREE
)
12520 if (TREE_READONLY_DECL_P (value
))
12521 value
= decl_constant_value (value
);
12523 if (TREE_CODE (value
) == INTEGER_CST
)
12525 value
= default_conversion (value
);
12526 constant_expression_warning (value
);
12530 cp_error ("enumerator value for `%D' not integer constant", name
);
12535 /* Default based on previous value. */
12536 if (value
== NULL_TREE
&& ! processing_template_decl
)
12540 if (TYPE_VALUES (enumtype
))
12542 /* The next value is the previous value ... */
12543 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
12544 /* ... plus one. */
12545 value
= build_binary_op_nodefault (PLUS_EXPR
,
12550 if (tree_int_cst_lt (value
, prev_value
))
12551 cp_error ("overflow in enumeration values at `%D'", name
);
12554 value
= integer_zero_node
;
12557 /* Remove no-op casts from the value. */
12559 STRIP_TYPE_NOPS (value
);
12561 /* To fix MAX_VAL enum consts. (bkoz) */
12562 TREE_TYPE (value
) = integer_type_node
;
12566 /* We always have to copy here; not all INTEGER_CSTs are unshared.
12567 Even in other cases, we will later (in finish_enum) be setting
12568 the type of VALUE. But, we don't need to make a copy if this
12569 VALUE is one of the enumeration constants for this same
12570 enumeration type. */
12571 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
12572 if (TREE_VALUE (values
) == value
)
12574 /* If we didn't break out of the loop, then we do need a copy. */
12575 if (!values
&& value
)
12576 value
= copy_node (value
);
12578 /* C++ associates enums with global, function, or class declarations. */
12579 context
= current_scope ();
12581 /* Build the actual enumeration constant. Note that the enumeration
12582 constants have the type of their initializers until the
12583 enumeration is complete:
12587 Following the closing brace of an enum-specifier, each enumer-
12588 ator has the type of its enumeration. Prior to the closing
12589 brace, the type of each enumerator is the type of its
12590 initializing value.
12592 In finish_enum we will reset the type. Of course, if we're
12593 processing a template, there may be no value. */
12594 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
12596 if (context
&& context
== current_class_type
)
12597 /* This enum declaration is local to the class. We need the full
12598 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
12599 decl
= build_lang_decl (CONST_DECL
, name
, type
);
12601 /* It's a global enum, or it's local to a function. (Note local to
12602 a function could mean local to a class method. */
12603 decl
= build_decl (CONST_DECL
, name
, type
);
12605 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
12606 DECL_INITIAL (decl
) = value
;
12607 TREE_READONLY (decl
) = 1;
12609 if (context
&& context
== current_class_type
)
12610 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12611 on the TYPE_FIELDS list for `S'. (That's so that you can say
12612 things like `S::i' later.) */
12613 finish_member_declaration (decl
);
12617 GNU_xref_decl (current_function_decl
, decl
);
12620 /* Add this enumeration constant to the list for this type. */
12621 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
12625 static int function_depth
;
12627 /* We're defining DECL. Make sure that it's type is OK. */
12630 check_function_type (decl
)
12633 tree fntype
= TREE_TYPE (decl
);
12635 /* In a function definition, arg types must be complete. */
12636 require_complete_types_for_parms (current_function_parms
);
12638 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype
))) == NULL_TREE
)
12640 cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype
));
12642 /* Make it return void instead, but don't change the
12643 type of the DECL_RESULT, in case we have a named return value. */
12644 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12646 tree ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
)));
12648 = build_cplus_method_type (ctype
,
12650 FUNCTION_ARG_CHAIN (decl
));
12654 = build_function_type (void_type_node
,
12655 TYPE_ARG_TYPES (TREE_TYPE (decl
)));
12657 = build_exception_variant (fntype
,
12658 TYPE_RAISES_EXCEPTIONS (fntype
));
12661 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
12664 /* Create the FUNCTION_DECL for a function definition.
12665 DECLSPECS and DECLARATOR are the parts of the declaration;
12666 they describe the function's name and the type it returns,
12667 but twisted together in a fashion that parallels the syntax of C.
12669 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12670 DECLARATOR is really the DECL for the function we are about to
12671 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12672 indicating that the function is an inline defined in-class, and
12673 SF_EXPAND indicating that we should generate RTL for this
12676 This function creates a binding context for the function body
12677 as well as setting up the FUNCTION_DECL in current_function_decl.
12679 Returns 1 on success. If the DECLARATOR is not suitable for a function
12680 (it defines a datum instead), we return 0, which tells
12681 yyparse to report a parse error.
12683 For C++, we must first check whether that datum makes any sense.
12684 For example, "class A local_a(1,2);" means that variable local_a
12685 is an aggregate of type A, which should have a constructor
12686 applied to it with the argument list [1, 2]. */
12689 start_function (declspecs
, declarator
, attrs
, flags
)
12690 tree declspecs
, declarator
, attrs
;
12694 tree ctype
= NULL_TREE
;
12697 extern int have_extern_spec
;
12698 extern int used_extern_spec
;
12699 int doing_friend
= 0;
12700 struct binding_level
*bl
;
12702 /* Sanity check. */
12703 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
12704 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
12706 /* This should only be done once on the top most decl. */
12707 if (have_extern_spec
&& !used_extern_spec
)
12709 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
12710 used_extern_spec
= 1;
12713 if (flags
& SF_PRE_PARSED
)
12715 decl1
= declarator
;
12717 fntype
= TREE_TYPE (decl1
);
12718 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12719 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12721 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
12722 class is in the (lexical) scope of the class in which it is
12724 if (!ctype
&& DECL_FRIEND_P (decl1
))
12726 ctype
= DECL_CLASS_CONTEXT (decl1
);
12728 /* CTYPE could be null here if we're dealing with a template;
12729 for example, `inline friend float foo()' inside a template
12730 will have no CTYPE set. */
12731 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
12737 last_function_parms
= DECL_ARGUMENTS (decl1
);
12738 last_function_parm_tags
= NULL_TREE
;
12742 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
12743 /* If the declarator is not suitable for a function definition,
12744 cause a syntax error. */
12745 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
12747 fntype
= TREE_TYPE (decl1
);
12749 restype
= TREE_TYPE (fntype
);
12750 if (CLASS_TYPE_P (restype
) && !CLASSTYPE_GOT_SEMICOLON (restype
))
12752 cp_error ("semicolon missing after declaration of `%#T'", restype
);
12753 shadow_tag (build_expr_list (NULL_TREE
, restype
));
12754 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
12755 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
12756 fntype
= build_function_type (integer_type_node
,
12757 TYPE_ARG_TYPES (fntype
));
12759 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
12761 TYPE_ARG_TYPES (fntype
));
12762 TREE_TYPE (decl1
) = fntype
;
12765 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12766 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12767 else if (DECL_MAIN_P (decl1
))
12769 /* If this doesn't return integer_type, complain. */
12770 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
12772 if (pedantic
|| warn_return_type
)
12773 pedwarn ("return type for `main' changed to `int'");
12774 TREE_TYPE (decl1
) = fntype
= default_function_type
;
12779 /* Sometimes we don't notice that a function is a static member, and
12780 build a METHOD_TYPE for it. Fix that up now. */
12781 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
12782 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
)
12784 revert_static_member_fn (&decl1
, NULL
, NULL
);
12785 last_function_parms
= TREE_CHAIN (last_function_parms
);
12789 /* Warn if function was previously implicitly declared
12790 (but not if we warned then). */
12791 if (! warn_implicit
12792 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
12793 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
12795 /* Set up current_class_type, and enter the scope of the class, if
12798 push_nested_class (ctype
, 1);
12799 else if (DECL_STATIC_FUNCTION_P (decl1
))
12800 push_nested_class (DECL_CONTEXT (decl1
), 2);
12802 /* Now that we have entered the scope of the class, we must restore
12803 the bindings for any template parameters surrounding DECL1, if it
12804 is an inline member template. (Order is important; consider the
12805 case where a template parameter has the same name as a field of
12806 the class.) It is not until after this point that
12807 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
12808 if (flags
& SF_INCLASS_INLINE
)
12809 maybe_begin_member_template_processing (decl1
);
12811 /* Effective C++ rule 15. See also c_expand_return. */
12813 && DECL_NAME (decl1
) == ansi_opname
[(int) MODIFY_EXPR
]
12814 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
12815 cp_warning ("`operator=' should return a reference to `*this'");
12817 /* Make the init_value nonzero so pushdecl knows this is not tentative.
12818 error_mark_node is replaced below (in poplevel) with the BLOCK. */
12819 if (!DECL_INITIAL (decl1
))
12820 DECL_INITIAL (decl1
) = error_mark_node
;
12822 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
12823 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
12826 /* This function exists in static storage.
12827 (This does not mean `static' in the C sense!) */
12828 TREE_STATIC (decl1
) = 1;
12830 /* We must call push_template_decl after current_class_type is set
12831 up. (If we are processing inline definitions after exiting a
12832 class scope, current_class_type will be NULL_TREE until set above
12833 by push_nested_class.) */
12834 if (processing_template_decl
)
12835 decl1
= push_template_decl (decl1
);
12837 /* We are now in the scope of the function being defined. */
12838 current_function_decl
= decl1
;
12840 /* Save the parm names or decls from this function's declarator
12841 where store_parm_decls will find them. */
12842 current_function_parms
= last_function_parms
;
12843 current_function_parm_tags
= last_function_parm_tags
;
12845 /* Make sure the parameter and return types are reasonable. When
12846 you declare a function, these types can be incomplete, but they
12847 must be complete when you define the function. */
12848 if (! processing_template_decl
)
12849 check_function_type (decl1
);
12851 /* Build the return declaration for the function. */
12852 restype
= TREE_TYPE (fntype
);
12853 if (!processing_template_decl
)
12855 if (!DECL_RESULT (decl1
))
12857 DECL_RESULT (decl1
)
12858 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
12859 c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype
),
12860 DECL_RESULT (decl1
));
12864 /* Just use `void'. Nobody will ever look at this anyhow. */
12865 DECL_RESULT (decl1
) = build_decl (RESULT_DECL
, 0, void_type_node
);
12867 /* Initialize RTL machinery. We cannot do this until
12868 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
12869 even when processing a template; this is how we get
12870 CURRENT_FUNCTION set up, and our per-function variables
12872 bl
= current_binding_level
;
12873 init_function_start (decl1
, input_filename
, lineno
);
12874 current_binding_level
= bl
;
12875 expanding_p
= (flags
& SF_EXPAND
) != 0;
12877 /* Even though we're inside a function body, we still don't want to
12878 call expand_expr to calculate the size of a variable-sized array.
12879 We haven't necessarily assigned RTL to all variables yet, so it's
12880 not safe to try to expand expressions involving them. */
12881 immediate_size_expand
= 0;
12882 current_function
->x_dont_save_pending_sizes_p
= 1;
12884 /* If we're building a statement-tree, start the tree now. */
12885 if (processing_template_decl
|| !expanding_p
)
12886 begin_stmt_tree (&DECL_SAVED_TREE (decl1
));
12888 /* Let the user know we're compiling this function. */
12889 if (processing_template_decl
|| !building_stmt_tree ())
12890 announce_function (decl1
);
12892 /* Record the decl so that the function name is defined.
12893 If we already have a decl for this name, and it is a FUNCTION_DECL,
12894 use the old decl. */
12895 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
12897 /* A specialization is not used to guide overload resolution. */
12898 if ((flag_guiding_decls
12899 || !DECL_TEMPLATE_SPECIALIZATION (decl1
))
12900 && ! DECL_FUNCTION_MEMBER_P (decl1
))
12901 decl1
= pushdecl (decl1
);
12904 /* We need to set the DECL_CONTEXT. */
12905 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
12906 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
12907 /* And make sure we have enough default args. */
12908 check_default_args (decl1
);
12910 DECL_MAIN_VARIANT (decl1
) = decl1
;
12911 fntype
= TREE_TYPE (decl1
);
12914 /* Reset these in case the call to pushdecl changed them. */
12915 current_function_decl
= decl1
;
12916 current_function
->decl
= decl1
;
12918 /* Initialize the per-function data. */
12919 if (!DECL_PENDING_INLINE_P (decl1
) && DECL_SAVED_FUNCTION_DATA (decl1
))
12921 /* If we already parsed this function, and we're just expanding it
12922 now, restore saved state. */
12923 struct binding_level
*bl
= current_binding_level
;
12924 *cp_function_chain
= *DECL_SAVED_FUNCTION_DATA (decl1
);
12925 current_binding_level
= bl
;
12927 /* This function is being processed in whole-function mode; we
12928 already did semantic analysis. */
12929 current_function
->x_whole_function_mode_p
= 1;
12931 /* If we decided that we didn't want to inline this function,
12932 make sure the back-end knows that. */
12933 if (!current_function_cannot_inline
)
12934 current_function_cannot_inline
= cp_function_chain
->cannot_inline
;
12936 /* We don't need the saved data anymore. */
12937 free (DECL_SAVED_FUNCTION_DATA (decl1
));
12938 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
12940 else if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
12942 /* We know that this was set up by `grokclassfn'. We do not
12943 wait until `store_parm_decls', since evil parse errors may
12944 never get us to that point. Here we keep the consistency
12945 between `current_class_type' and `current_class_ptr'. */
12946 tree t
= DECL_ARGUMENTS (decl1
);
12948 my_friendly_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
,
12950 my_friendly_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
,
12953 cp_function_chain
->x_current_class_ref
12954 = build_indirect_ref (t
, NULL_PTR
);
12955 cp_function_chain
->x_current_class_ptr
= t
;
12957 /* Constructors and destructors need to know whether they're "in
12958 charge" of initializing virtual base classes. */
12959 if (DECL_DESTRUCTOR_P (decl1
))
12960 current_in_charge_parm
= TREE_CHAIN (t
);
12961 else if (DECL_CONSTRUCTOR_P (decl1
)
12963 && DECL_ARTIFICIAL (TREE_CHAIN (t
))
12964 && (DECL_NAME (TREE_CHAIN (t
))
12965 == in_charge_identifier
))
12966 current_in_charge_parm
= TREE_CHAIN (t
);
12969 if (DECL_INTERFACE_KNOWN (decl1
))
12971 tree ctx
= hack_decl_function_context (decl1
);
12973 if (DECL_NOT_REALLY_EXTERN (decl1
))
12974 DECL_EXTERNAL (decl1
) = 0;
12976 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
12977 && TREE_PUBLIC (ctx
))
12978 /* This is a function in a local class in an extern inline
12980 comdat_linkage (decl1
);
12982 /* If this function belongs to an interface, it is public.
12983 If it belongs to someone else's interface, it is also external.
12984 This only affects inlines and template instantiations. */
12985 else if (interface_unknown
== 0
12986 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
12987 || flag_alt_external_templates
))
12989 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
12990 || processing_template_decl
)
12992 DECL_EXTERNAL (decl1
)
12994 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
12995 && !DECL_VINDEX (decl1
)));
12997 /* For WIN32 we also want to put these in linkonce sections. */
12998 maybe_make_one_only (decl1
);
13001 DECL_EXTERNAL (decl1
) = 0;
13002 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13003 DECL_INTERFACE_KNOWN (decl1
) = 1;
13005 else if (interface_unknown
&& interface_only
13006 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13007 || flag_alt_external_templates
))
13009 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13010 interface, we will have interface_only set but not
13011 interface_known. In that case, we don't want to use the normal
13012 heuristics because someone will supply a #pragma implementation
13013 elsewhere, and deducing it here would produce a conflict. */
13014 comdat_linkage (decl1
);
13015 DECL_EXTERNAL (decl1
) = 0;
13016 DECL_INTERFACE_KNOWN (decl1
) = 1;
13017 DECL_DEFER_OUTPUT (decl1
) = 1;
13021 /* This is a definition, not a reference.
13022 So clear DECL_EXTERNAL. */
13023 DECL_EXTERNAL (decl1
) = 0;
13025 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
13026 && ! DECL_INTERFACE_KNOWN (decl1
)
13027 /* Don't try to defer nested functions for now. */
13028 && ! hack_decl_function_context (decl1
))
13029 DECL_DEFER_OUTPUT (decl1
) = 1;
13031 DECL_INTERFACE_KNOWN (decl1
) = 1;
13034 if (doing_semantic_analysis_p ())
13037 current_binding_level
->parm_flag
= 1;
13041 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
13043 if (!building_stmt_tree ())
13045 GNU_xref_function (decl1
, current_function_parms
);
13046 make_function_rtl (decl1
);
13049 /* Promote the value to int before returning it. */
13050 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
13051 restype
= type_promotes_to (restype
);
13053 /* If this fcn was already referenced via a block-scope `extern' decl
13054 (or an implicit decl), propagate certain information about the usage. */
13055 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
13056 TREE_ADDRESSABLE (decl1
) = 1;
13058 if (DECL_RESULT (decl1
) == NULL_TREE
)
13060 DECL_RESULT (decl1
)
13061 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13062 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
13063 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
13068 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1
))
13069 && DECL_LANGUAGE (decl1
) == lang_cplusplus
)
13070 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13071 else if (DECL_CONSTRUCTOR_P (decl1
))
13072 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13077 /* Called after store_parm_decls for a function-try-block. */
13080 expand_start_early_try_stmts ()
13082 expand_start_try_stmts ();
13085 /* Store the parameter declarations into the current function declaration.
13086 This is called after parsing the parameter declarations, before
13087 digesting the body of the function.
13089 Also install to binding contour return value identifier, if any. */
13092 store_parm_decls ()
13094 register tree fndecl
= current_function_decl
;
13095 register tree parm
;
13096 int parms_have_cleanups
= 0;
13097 tree cleanups
= NULL_TREE
;
13099 /* This is a list of types declared among parms in a prototype. */
13100 tree parmtags
= current_function_parm_tags
;
13102 /* This is a chain of any other decls that came in among the parm
13103 declarations. If a parm is declared with enum {foo, bar} x;
13104 then CONST_DECLs for foo and bar are put here. */
13105 tree nonparms
= NULL_TREE
;
13107 /* Create a binding level for the parms. */
13108 if (!building_stmt_tree ())
13109 expand_start_bindings (2);
13111 if (current_function_parms
)
13113 /* This case is when the function was defined with an ANSI prototype.
13114 The parms already have decls, so we need not do anything here
13115 except record them as in effect
13116 and complain if any redundant old-style parm decls were written. */
13118 tree specparms
= current_function_parms
;
13121 if (doing_semantic_analysis_p ())
13123 /* Must clear this because it might contain TYPE_DECLs declared
13125 storedecls (NULL_TREE
);
13127 /* If we're doing semantic analysis, then we'll call pushdecl
13128 for each of these. We must do them in reverse order so that
13129 they end in the correct forward order. */
13130 specparms
= nreverse (specparms
);
13133 for (parm
= specparms
; parm
; parm
= next
)
13135 next
= TREE_CHAIN (parm
);
13136 if (TREE_CODE (parm
) == PARM_DECL
)
13138 tree type
= TREE_TYPE (parm
);
13140 if (doing_semantic_analysis_p ())
13144 if (DECL_NAME (parm
) == NULL_TREE
13145 || TREE_CODE (parm
) != VOID_TYPE
)
13148 cp_error ("parameter `%D' declared void", parm
);
13150 cleanup
= maybe_build_cleanup (parm
);
13153 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
13155 else if (type
!= error_mark_node
13156 && TYPE_NEEDS_DESTRUCTOR (type
))
13157 parms_have_cleanups
= 1;
13161 /* If we find an enum constant or a type tag,
13162 put it aside for the moment. */
13163 TREE_CHAIN (parm
) = NULL_TREE
;
13164 nonparms
= chainon (nonparms
, parm
);
13168 if (doing_semantic_analysis_p ())
13170 /* Get the decls in their original chain order
13171 and record in the function. This is all and only the
13172 PARM_DECLs that were pushed into scope by the loop above. */
13173 DECL_ARGUMENTS (fndecl
) = getdecls ();
13174 storetags (chainon (parmtags
, gettags ()));
13178 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13180 /* Now store the final chain of decls for the arguments
13181 as the decl-chain of the current lexical scope.
13182 Put the enumerators in as well, at the front so that
13183 DECL_ARGUMENTS is not modified. */
13184 if (doing_semantic_analysis_p ())
13185 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
13187 /* Initialize the RTL code for the function. */
13188 DECL_SAVED_INSNS (fndecl
) = 0;
13189 if (! building_stmt_tree ())
13190 expand_function_start (fndecl
, parms_have_cleanups
);
13192 current_function_parms_stored
= 1;
13194 /* If this function is `main', emit a call to `__main'
13195 to run global initializers, etc. */
13196 if (DECL_MAIN_P (fndecl
) && !building_stmt_tree ())
13197 expand_main_function ();
13199 /* Now that we have initialized the parms, we can start their
13200 cleanups. We cannot do this before, since expand_decl_cleanup
13201 should not be called before the parm can be used. */
13204 finish_decl_cleanup (TREE_PURPOSE (cleanups
),
13205 TREE_VALUE (cleanups
));
13206 cleanups
= TREE_CHAIN (cleanups
);
13209 /* Create a binding contour which can be used to catch
13210 cleanup-generated temporaries. Also, if the return value needs or
13211 has initialization, deal with that now. */
13212 if (parms_have_cleanups
)
13215 if (!building_stmt_tree ())
13216 expand_start_bindings (2);
13219 /* Do the starting of the exception specifications, if we have any. */
13220 if (flag_exceptions
&& !processing_template_decl
13221 && building_stmt_tree ()
13222 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
13223 current_eh_spec_try_block
= expand_start_eh_spec ();
13226 /* Bind a name and initialization to the return value of
13227 the current function. */
13230 store_return_init (decl
)
13233 /* If this named return value comes in a register, put it in a
13234 pseudo-register. */
13235 if (DECL_REGISTER (decl
))
13237 original_result_rtx
= DECL_RTL (decl
);
13238 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
13243 /* We have finished doing semantic analysis on DECL, but have not yet
13244 generated RTL for its body. Save away our current state, so that
13245 when we want to generate RTL later we know what to do. */
13248 save_function_data (decl
)
13251 struct language_function
*f
;
13253 /* Save the language-specific per-function data so that we can
13254 get it back when we really expand this function. */
13255 my_friendly_assert (!DECL_PENDING_INLINE_P (decl
),
13259 f
= ((struct language_function
*)
13260 xmalloc (sizeof (struct language_function
)));
13261 bcopy ((char *) cp_function_chain
, (char *) f
,
13262 sizeof (struct language_function
));
13263 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13265 /* Clear out the bits we don't need. */
13266 f
->x_base_init_list
= NULL_TREE
;
13267 f
->x_member_init_list
= NULL_TREE
;
13268 f
->x_stmt_tree
.x_last_stmt
= NULL_TREE
;
13269 f
->x_stmt_tree
.x_last_expr_type
= NULL_TREE
;
13270 f
->x_result_rtx
= NULL_RTX
;
13271 f
->x_named_label_uses
= NULL
;
13272 f
->bindings
= NULL
;
13274 /* When we get back here again, we will be expanding. */
13275 f
->x_expanding_p
= 1;
13277 /* If we've already decided that we cannot inline this function, we
13278 must remember that fact when we actually go to expand the
13280 f
->cannot_inline
= current_function_cannot_inline
;
13283 /* At the end of every constructor we generate to code to return
13284 `this'. Do that now. */
13287 finish_constructor_body ()
13289 /* Any return from a constructor will end up here. */
13290 add_tree (build_min_nt (LABEL_STMT
, ctor_label
));
13292 /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13293 generate the return, rather than a goto to CTOR_LABEL. */
13294 ctor_label
= NULL_TREE
;
13295 /* In check_return_expr we translate an empty return from a
13296 constructor to a return of `this'. */
13297 finish_return_stmt (NULL_TREE
);
13299 /* Mark the end of the main constructor body. */
13300 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13301 add_tree (build_min_nt (CTOR_COMPLETE
));
13304 /* At the end of every destructor we generate code to restore virtual
13305 function tables to the values desired by base classes and to call
13306 to base class destructors. Do that now. */
13309 finish_destructor_body ()
13311 tree compound_stmt
;
13316 /* Create a block to contain all the extra code. */
13317 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
13319 /* Any return from a destructor will end up here. */
13320 add_tree (build_min_nt (LABEL_STMT
, dtor_label
));
13322 /* Generate the code to call destructor on base class. If this
13323 destructor belongs to a class with virtual functions, then set
13324 the virtual function table pointer to represent the type of our
13327 /* This side-effect makes call to `build_delete' generate the code
13328 we have to have at the end of this destructor. `build_delete'
13329 will set the flag again. */
13330 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
13332 /* These are two cases where we cannot delegate deletion. */
13333 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)
13334 || TYPE_GETS_REG_DELETE (current_class_type
))
13335 in_charge
= integer_zero_node
;
13337 in_charge
= current_in_charge_parm
;
13339 exprstmt
= build_delete (current_class_type
,
13342 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
13345 if (exprstmt
!= error_mark_node
13346 && (TREE_CODE (exprstmt
) != NOP_EXPR
13347 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
13348 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
13350 if (exprstmt
!= void_zero_node
)
13351 /* Don't call `expand_expr_stmt' if we're not going to do
13352 anything, since -Wall will give a diagnostic. */
13353 finish_expr_stmt (exprstmt
);
13355 /* Run destructors for all virtual baseclasses. */
13356 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13358 tree vbases
= nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type
)));
13359 tree if_stmt
= begin_if_stmt ();
13360 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
13361 current_in_charge_parm
,
13367 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases
)))
13369 tree vb
= get_vbase
13370 (BINFO_TYPE (vbases
),
13371 TYPE_BINFO (current_class_type
));
13373 (build_scoped_method_call
13374 (current_class_ref
, vb
, dtor_identifier
,
13375 build_expr_list (NULL_TREE
, integer_zero_node
)));
13377 vbases
= TREE_CHAIN (vbases
);
13380 finish_then_clause (if_stmt
);
13385 virtual_size
= c_sizeof (current_class_type
);
13387 /* At the end, call delete if that's what's requested. */
13389 /* FDIS sez: At the point of definition of a virtual destructor
13390 (including an implicit definition), non-placement operator delete
13391 shall be looked up in the scope of the destructor's class and if
13392 found shall be accessible and unambiguous.
13394 This is somewhat unclear, but I take it to mean that if the class
13395 only defines placement deletes we don't do anything here. So we
13396 pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13397 they ever try to delete one of these. */
13398 if (TYPE_GETS_REG_DELETE (current_class_type
)
13399 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13403 exprstmt
= build_op_delete_call
13404 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
13405 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
13407 if_stmt
= begin_if_stmt ();
13408 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
13409 current_in_charge_parm
,
13412 finish_expr_stmt (exprstmt
);
13413 finish_then_clause (if_stmt
);
13417 /* Close the block we started above. */
13418 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
13421 /* Finish up a function declaration and compile that function
13422 all the way to assembler language output. The free the storage
13423 for the function definition.
13425 This is called after parsing the body of the function definition.
13426 LINENO is the current line number.
13428 FLAGS is a bitwise or of the following values:
13430 An extra call to poplevel (and expand_end_bindings) must be
13431 made to take care of the binding contour for the base
13432 initializers. This is only relevant for constructors.
13434 We just finished processing the body of an in-class inline
13435 function definition. (This processing will have taken place
13436 after the class definition is complete.) */
13439 finish_function (lineno
, flags
)
13443 register tree fndecl
= current_function_decl
;
13444 tree fntype
, ctype
= NULL_TREE
;
13445 /* Label to use if this function is supposed to return a value. */
13446 tree no_return_label
= NULL_TREE
;
13447 int call_poplevel
= (flags
& 1) != 0;
13448 int inclass_inline
= (flags
& 2) != 0;
13452 /* When we get some parse errors, we can end up without a
13453 current_function_decl, so cope. */
13454 if (fndecl
== NULL_TREE
)
13455 return error_mark_node
;
13457 nested
= function_depth
> 1;
13458 fntype
= TREE_TYPE (fndecl
);
13460 /* TREE_READONLY (fndecl) = 1;
13461 This caused &foo to be of type ptr-to-const-function
13462 which then got a warning when stored in a ptr-to-function variable. */
13464 /* This happens on strange parse errors. */
13465 if (! current_function_parms_stored
)
13468 store_parm_decls ();
13471 if (building_stmt_tree ())
13473 if (DECL_CONSTRUCTOR_P (fndecl
))
13475 finish_constructor_body ();
13479 else if (DECL_DESTRUCTOR_P (fndecl
) && !processing_template_decl
)
13480 finish_destructor_body ();
13481 else if (DECL_MAIN_P (fndecl
))
13483 /* Make it so that `main' always returns 0 by default. */
13485 finish_return_stmt (integer_one_node
);
13487 finish_return_stmt (integer_zero_node
);
13491 /* Finish dealing with exception specifiers. */
13492 if (flag_exceptions
&& !processing_template_decl
13493 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
13494 expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13495 (TREE_TYPE (current_function_decl
)),
13496 current_eh_spec_try_block
);
13501 if (write_symbols
!= NO_DEBUG
/*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13503 /* Keep this code around in case we later want to control debug info
13504 based on whether a type is "used". (jason 1999-11-11) */
13506 tree ttype
= target_type (fntype
);
13509 if (IS_AGGR_TYPE (ttype
))
13510 /* Let debugger know it should output info for this type. */
13511 note_debug_info_needed (ttype
);
13513 for (parmdecl
= DECL_ARGUMENTS (fndecl
); parmdecl
; parmdecl
= TREE_CHAIN (parmdecl
))
13515 ttype
= target_type (TREE_TYPE (parmdecl
));
13516 if (IS_AGGR_TYPE (ttype
))
13517 /* Let debugger know it should output info for this type. */
13518 note_debug_info_needed (ttype
);
13523 /* Clean house because we will need to reorder insns here. */
13524 do_pending_stack_adjust ();
13528 else if (DECL_CONSTRUCTOR_P (fndecl
))
13533 else if (return_label
!= NULL_RTX
13534 && flag_this_is_variable
<= 0
13535 && current_function_return_value
== NULL_TREE
13536 && ! DECL_NAME (DECL_RESULT (current_function_decl
)))
13537 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13539 if (flag_exceptions
)
13540 expand_exception_blocks ();
13542 /* If this function is supposed to return a value, ensure that
13543 we do not fall into the cleanups by mistake. The end of our
13544 function will look like this:
13546 user code (may have return stmt somewhere)
13547 goto no_return_label
13552 NOTE_INSN_FUNCTION_END
13556 If the user omits a return stmt in the USER CODE section, we
13557 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13558 Otherwise, we won't. */
13559 if (no_return_label
)
13561 DECL_CONTEXT (no_return_label
) = fndecl
;
13562 DECL_INITIAL (no_return_label
) = error_mark_node
;
13563 DECL_SOURCE_FILE (no_return_label
) = input_filename
;
13564 DECL_SOURCE_LINE (no_return_label
) = lineno
;
13565 expand_goto (no_return_label
);
13570 /* Remove the binding contour which is used
13571 to catch cleanup-generated temporaries. */
13572 expand_end_bindings (0, 0, 0);
13573 poplevel (0, 0, 0);
13575 /* Emit label at beginning of cleanup code for parameters. */
13576 emit_label (cleanup_label
);
13579 /* Get return value into register if that's where it's supposed
13581 if (original_result_rtx
)
13582 fixup_result_decl (DECL_RESULT (fndecl
), original_result_rtx
);
13584 /* Finish building code that will trigger warnings if users forget
13585 to make their functions return values. */
13586 if (no_return_label
|| cleanup_label
)
13587 emit_jump (return_label
);
13588 if (no_return_label
)
13590 /* We don't need to call `expand_*_return' here because we
13591 don't need any cleanups here--this path of code is only
13592 for error checking purposes. */
13593 expand_label (no_return_label
);
13596 /* We hard-wired immediate_size_expand to zero in
13597 start_function. Expand_function_end will decrement this
13598 variable. So, we set the variable to one here, so that after
13599 the decrement it will remain zero. */
13600 immediate_size_expand
= 1;
13602 /* Generate rtl for function exit. */
13603 expand_function_end (input_filename
, lineno
, 1);
13606 /* We have to save this value here in case
13607 maybe_end_member_template_processing decides to pop all the
13608 template parameters. */
13609 expand_p
= !building_stmt_tree ();
13611 /* If we're saving up tree structure, tie off the function now. */
13613 finish_stmt_tree (&DECL_SAVED_TREE (fndecl
));
13615 /* This must come after expand_function_end because cleanups might
13616 have declarations (from inline functions) that need to go into
13617 this function's blocks. */
13618 if (doing_semantic_analysis_p ())
13620 if (current_binding_level
->parm_flag
!= 1)
13621 my_friendly_abort (122);
13622 poplevel (1, 0, 1);
13625 /* Remember that we were in class scope. */
13626 if (current_class_name
)
13627 ctype
= current_class_type
;
13629 /* Must mark the RESULT_DECL as being in this function. */
13630 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13632 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13633 to the FUNCTION_DECL node itself. */
13634 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13636 /* Save away current state, if appropriate. */
13637 if (!expanding_p
&& !processing_template_decl
)
13638 save_function_data (fndecl
);
13644 int saved_flag_keep_inline_functions
=
13645 flag_keep_inline_functions
;
13647 /* So we can tell if jump_optimize sets it to 1. */
13650 if (DECL_CONTEXT (fndecl
) != NULL_TREE
13651 && hack_decl_function_context (fndecl
))
13652 /* Trick rest_of_compilation into not deferring output of this
13653 function, even if it is inline, since the rtl_obstack for
13654 this function is the function_obstack of the enclosing
13655 function and will be deallocated when the enclosing
13656 function is gone. See save_tree_status. */
13657 flag_keep_inline_functions
= 1;
13659 /* Before we call rest_of_compilation (which will pop the
13660 CURRENT_FUNCTION), we must save these values. */
13661 returns_null
= current_function_returns_null
;
13662 returns_value
= current_function_returns_value
;
13664 /* If this is a nested function (like a template instantiation
13665 that we're compiling in the midst of compiling something
13666 else), push a new GC context. That will keep local variables
13667 on the stack from being collected while we're doing the
13668 compilation of this function. */
13669 if (function_depth
> 1)
13670 ggc_push_context ();
13672 /* Run the optimizers and output the assembler code for this
13674 if (DECL_ARTIFICIAL (fndecl
))
13676 /* Do we really *want* to inline this synthesized method? */
13678 int save_fif
= flag_inline_functions
;
13679 flag_inline_functions
= 1;
13681 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13682 will check our size. */
13683 DECL_INLINE (fndecl
) = 0;
13685 rest_of_compilation (fndecl
);
13686 flag_inline_functions
= save_fif
;
13689 rest_of_compilation (fndecl
);
13691 /* Undo the call to ggc_push_context above. */
13692 if (function_depth
> 1)
13693 ggc_pop_context ();
13695 flag_keep_inline_functions
= saved_flag_keep_inline_functions
;
13697 if (DECL_SAVED_INSNS (fndecl
) && ! TREE_ASM_WRITTEN (fndecl
))
13699 /* Set DECL_EXTERNAL so that assemble_external will be called as
13700 necessary. We'll clear it again in finish_file. */
13701 if (! DECL_EXTERNAL (fndecl
))
13702 DECL_NOT_REALLY_EXTERN (fndecl
) = 1;
13703 DECL_EXTERNAL (fndecl
) = 1;
13704 mark_inline_for_output (fndecl
);
13708 /* Keep this code around in case we later want to control debug info
13709 based on whether a type is "used". (jason 1999-11-11) */
13711 if (ctype
&& TREE_ASM_WRITTEN (fndecl
))
13712 note_debug_info_needed (ctype
);
13715 returns_null
|= can_reach_end
;
13717 /* Since we don't normally go through c_expand_return for constructors,
13718 this normally gets the wrong value.
13719 Also, named return values have their return codes emitted after
13720 NOTE_INSN_FUNCTION_END, confusing jump.c. */
13721 if (DECL_CONSTRUCTOR_P (fndecl
)
13722 || DECL_NAME (DECL_RESULT (fndecl
)) != NULL_TREE
)
13725 if (TREE_THIS_VOLATILE (fndecl
) && returns_null
)
13726 cp_warning ("`noreturn' function `%D' does return", fndecl
);
13727 else if ((warn_return_type
|| pedantic
)
13729 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
)
13731 /* If this function returns non-void and control can drop through,
13733 cp_warning ("control reaches end of non-void function `%D'", fndecl
);
13735 /* With just -W, complain only if function returns both with
13736 and without a value. */
13737 else if (extra_warnings
&& returns_value
&& returns_null
)
13738 warning ("this function may return with or without a value");
13742 /* Clear out memory we no longer need. */
13743 free_after_parsing (current_function
);
13744 /* Since we never call rest_of_compilation, we never clear
13745 CURRENT_FUNCTION. Do so explicitly. */
13746 free_after_compilation (current_function
);
13747 current_function
= NULL
;
13750 /* If this is a in-class inline definition, we may have to pop the
13751 bindings for the template parameters that we added in
13752 maybe_begin_member_template_processing when start_function was
13754 if (inclass_inline
)
13755 maybe_end_member_template_processing ();
13757 /* Leave the scope of the class. */
13759 pop_nested_class ();
13763 if (!DECL_SAVED_INSNS (fndecl
) && !DECL_SAVED_FUNCTION_DATA (fndecl
))
13767 /* Stop pointing to the local nodes about to be freed. */
13768 /* But DECL_INITIAL must remain nonzero so we know this
13769 was an actual function definition. */
13770 DECL_INITIAL (fndecl
) = error_mark_node
;
13771 for (t
= DECL_ARGUMENTS (fndecl
); t
; t
= TREE_CHAIN (t
))
13772 DECL_RTL (t
) = DECL_INCOMING_RTL (t
) = NULL_RTX
;
13775 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
13776 static_ctors
= tree_cons (NULL_TREE
, fndecl
, static_ctors
);
13777 if (DECL_STATIC_DESTRUCTOR (fndecl
))
13778 static_dtors
= tree_cons (NULL_TREE
, fndecl
, static_dtors
);
13783 /* Let the error reporting routines know that we're outside a
13784 function. For a nested function, this value is used in
13785 pop_cp_function_context and then reset via pop_function_context. */
13786 current_function_decl
= NULL_TREE
;
13792 /* Create the FUNCTION_DECL for a function definition.
13793 DECLSPECS and DECLARATOR are the parts of the declaration;
13794 they describe the return type and the name of the function,
13795 but twisted together in a fashion that parallels the syntax of C.
13797 This function creates a binding context for the function body
13798 as well as setting up the FUNCTION_DECL in current_function_decl.
13800 Returns a FUNCTION_DECL on success.
13802 If the DECLARATOR is not suitable for a function (it defines a datum
13803 instead), we return 0, which tells yyparse to report a parse error.
13805 May return void_type_node indicating that this method is actually
13806 a friend. See grokfield for more details.
13808 Came here with a `.pushlevel' .
13810 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13811 CHANGES TO CODE IN `grokfield'. */
13814 start_method (declspecs
, declarator
, attrlist
)
13815 tree declarator
, declspecs
, attrlist
;
13817 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
13820 /* Something too ugly to handle. */
13821 if (fndecl
== NULL_TREE
)
13824 /* Pass friends other than inline friend functions back. */
13825 if (fndecl
== void_type_node
)
13828 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
13829 /* Not a function, tell parser to report parse error. */
13832 if (DECL_IN_AGGR_P (fndecl
))
13834 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
13836 if (DECL_CONTEXT (fndecl
)
13837 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
13838 cp_error ("`%D' is already defined in class %s", fndecl
,
13839 TYPE_NAME_STRING (DECL_CONTEXT (fndecl
)));
13841 return void_type_node
;
13844 check_template_shadow (fndecl
);
13846 DECL_THIS_INLINE (fndecl
) = 1;
13848 if (flag_default_inline
)
13849 DECL_INLINE (fndecl
) = 1;
13851 /* We process method specializations in finish_struct_1. */
13852 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
13853 fndecl
= push_template_decl (fndecl
);
13855 /* We read in the parameters on the maybepermanent_obstack,
13856 but we won't be getting back to them until after we
13857 may have clobbered them. So the call to preserve_data
13858 will keep them safe. */
13861 if (! DECL_FRIEND_P (fndecl
))
13863 if (TREE_CHAIN (fndecl
))
13865 fndecl
= copy_node (fndecl
);
13866 TREE_CHAIN (fndecl
) = NULL_TREE
;
13869 if (DECL_CONSTRUCTOR_P (fndecl
))
13871 if (! grok_ctor_properties (current_class_type
, fndecl
))
13872 return void_type_node
;
13874 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
13875 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
13878 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0);
13880 /* Make a place for the parms */
13882 current_binding_level
->parm_flag
= 1;
13884 DECL_IN_AGGR_P (fndecl
) = 1;
13888 /* Go through the motions of finishing a function definition.
13889 We don't compile this method until after the whole class has
13892 FINISH_METHOD must return something that looks as though it
13893 came from GROKFIELD (since we are defining a method, after all).
13895 This is called after parsing the body of the function definition.
13896 STMTS is the chain of statements that makes up the function body.
13898 DECL is the ..._DECL that `start_method' provided. */
13901 finish_method (decl
)
13904 register tree fndecl
= decl
;
13907 register tree link
;
13909 if (decl
== void_type_node
)
13912 old_initial
= DECL_INITIAL (fndecl
);
13914 /* Undo the level for the parms (from start_method).
13915 This is like poplevel, but it causes nothing to be
13916 saved. Saving information here confuses symbol-table
13917 output routines. Besides, this information will
13918 be correctly output when this method is actually
13921 /* Clear out the meanings of the local variables of this level;
13922 also record in each decl which block it belongs to. */
13924 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
13926 if (DECL_NAME (link
) != NULL_TREE
)
13927 pop_binding (DECL_NAME (link
), link
);
13928 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
13929 DECL_CONTEXT (link
) = NULL_TREE
;
13932 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
13933 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
13934 current_binding_level
->parm_flag
,
13935 current_binding_level
->keep
);
13937 poplevel (0, 0, 0);
13939 DECL_INITIAL (fndecl
) = old_initial
;
13941 /* We used to check if the context of FNDECL was different from
13942 current_class_type as another way to get inside here. This didn't work
13943 for String.cc in libg++. */
13944 if (DECL_FRIEND_P (fndecl
))
13946 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
13947 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
13948 decl
= void_type_node
;
13954 /* Called when a new struct TYPE is defined.
13955 If this structure or union completes the type of any previous
13956 variable declaration, lay it out and output its rtl. */
13959 hack_incomplete_structures (type
)
13964 if (current_binding_level
->incomplete
== NULL_TREE
)
13967 if (!type
) /* Don't do this for class templates. */
13970 for (list
= ¤t_binding_level
->incomplete
; *list
; )
13972 tree decl
= TREE_VALUE (*list
);
13973 if ((decl
&& TREE_TYPE (decl
) == type
)
13974 || (TREE_TYPE (decl
)
13975 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13976 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
13978 int toplevel
= toplevel_bindings_p ();
13979 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13980 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
13981 layout_type (TREE_TYPE (decl
));
13982 layout_decl (decl
, 0);
13983 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
13987 expand_decl (decl
);
13988 cleanup
= maybe_build_cleanup (decl
);
13989 expand_decl_init (decl
);
13990 if (! expand_decl_cleanup (decl
, cleanup
))
13991 cp_error ("parser lost in parsing declaration of `%D'",
13994 *list
= TREE_CHAIN (*list
);
13997 list
= &TREE_CHAIN (*list
);
14001 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14002 See build_delete for information about AUTO_DELETE.
14004 Don't build these on the momentary obstack; they must live
14005 the life of the binding contour. */
14008 maybe_build_cleanup_1 (decl
, auto_delete
)
14009 tree decl
, auto_delete
;
14011 tree type
= TREE_TYPE (decl
);
14012 if (type
!= error_mark_node
&& TYPE_NEEDS_DESTRUCTOR (type
))
14014 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14017 if (TREE_CODE (type
) == ARRAY_TYPE
)
14021 mark_addressable (decl
);
14022 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
14025 /* Optimize for space over speed here. */
14026 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
14027 || flag_expensive_optimizations
)
14028 flags
|= LOOKUP_NONVIRTUAL
;
14030 rval
= build_delete (TREE_TYPE (rval
), rval
, auto_delete
, flags
, 0);
14032 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
14033 && ! TYPE_HAS_DESTRUCTOR (type
))
14034 rval
= build_compound_expr (tree_cons (NULL_TREE
, rval
,
14035 build_expr_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
14042 /* If DECL is of a type which needs a cleanup, build that cleanup
14043 here. The cleanup does free the storage with a call to delete. */
14046 maybe_build_cleanup_and_delete (decl
)
14049 return maybe_build_cleanup_1 (decl
, integer_three_node
);
14052 /* If DECL is of a type which needs a cleanup, build that cleanup
14053 here. The cleanup does not free the storage with a call a delete. */
14056 maybe_build_cleanup (decl
)
14059 return maybe_build_cleanup_1 (decl
, integer_two_node
);
14062 /* Expand a C++ expression at the statement level.
14063 This is needed to ferret out nodes which have UNKNOWN_TYPE.
14064 The C++ type checker should get all of these out when
14065 expressions are combined with other, type-providing, expressions,
14066 leaving only orphan expressions, such as:
14068 &class::bar; / / takes its address, but does nothing with it. */
14071 cplus_expand_expr_stmt (exp
)
14074 if (stmts_are_full_exprs_p
)
14075 exp
= convert_to_void (exp
, "statement");
14078 /* We should do this eventually, but right now this causes regex.o from
14079 libg++ to miscompile, and tString to core dump. */
14080 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
14083 /* If we don't do this, we end up down inside expand_expr
14084 trying to do TYPE_MODE on the ERROR_MARK, and really
14085 go outside the bounds of the type. */
14086 if (exp
!= error_mark_node
)
14087 expand_expr_stmt (exp
);
14090 /* When a stmt has been parsed, this function is called. */
14095 /* Always assume this statement was not an expression statement. If
14096 it actually was an expression statement, its our callers
14097 responsibility to fix this up. */
14098 last_expr_type
= NULL_TREE
;
14101 /* Change a static member function definition into a FUNCTION_TYPE, instead
14102 of the METHOD_TYPE that we create when it's originally parsed.
14104 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14105 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14106 other decls. Either pass the addresses of local variables or NULL. */
14109 revert_static_member_fn (decl
, fn
, argtypes
)
14110 tree
*decl
, *fn
, *argtypes
;
14113 tree function
= fn
? *fn
: TREE_TYPE (*decl
);
14114 tree args
= argtypes
? *argtypes
: TYPE_ARG_TYPES (function
);
14116 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
14117 != TYPE_UNQUALIFIED
)
14118 cp_error ("static member function `%#D' declared with type qualifiers",
14121 args
= TREE_CHAIN (args
);
14122 tmp
= build_function_type (TREE_TYPE (function
), args
);
14123 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
14124 tmp
= build_exception_variant (tmp
,
14125 TYPE_RAISES_EXCEPTIONS (function
));
14126 TREE_TYPE (*decl
) = tmp
;
14127 if (DECL_ARGUMENTS (*decl
))
14128 DECL_ARGUMENTS (*decl
) = TREE_CHAIN (DECL_ARGUMENTS (*decl
));
14129 DECL_STATIC_FUNCTION_P (*decl
) = 1;
14136 /* Initialize the variables used during compilation of a C++
14140 push_cp_function_context (f
)
14141 struct function
*f
;
14143 struct language_function
*p
14144 = ((struct language_function
*)
14145 xcalloc (1, sizeof (struct language_function
)));
14148 /* It takes an explicit call to expand_body to generate RTL for a
14152 /* Whenever we start a new function, we destroy temporaries in the
14154 stmts_are_full_exprs_p
= 1;
14157 /* Free the language-specific parts of F, now that we've finished
14158 compiling the function. */
14161 pop_cp_function_context (f
)
14162 struct function
*f
;
14165 free (f
->language
);
14169 /* Mark P for GC. */
14172 mark_lang_function (p
)
14173 struct language_function
*p
;
14178 ggc_mark_tree (p
->x_named_labels
);
14179 ggc_mark_tree (p
->x_ctor_label
);
14180 ggc_mark_tree (p
->x_dtor_label
);
14181 ggc_mark_tree (p
->x_base_init_list
);
14182 ggc_mark_tree (p
->x_member_init_list
);
14183 ggc_mark_tree (p
->x_current_class_ptr
);
14184 ggc_mark_tree (p
->x_current_class_ref
);
14185 ggc_mark_tree (p
->x_eh_spec_try_block
);
14186 ggc_mark_tree (p
->x_scope_stmt_stack
);
14188 ggc_mark_rtx (p
->x_result_rtx
);
14190 mark_stmt_tree (&p
->x_stmt_tree
);
14191 mark_binding_level (&p
->bindings
);
14194 /* Mark the language-specific data in F for GC. */
14197 mark_cp_function_context (f
)
14198 struct function
*f
;
14200 mark_lang_function (f
->language
);
14206 return function_depth
!= 0;
14211 lang_mark_false_label_stack (l
)
14212 struct label_node
*l
;
14214 /* C++ doesn't use false_label_stack. It better be NULL. */
14215 my_friendly_assert (l
== NULL
, 19990904);
14222 enum tree_code code
= TREE_CODE (t
);
14223 if (code
== IDENTIFIER_NODE
)
14225 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
14226 struct lang_id2
*li2
= li
->x
;
14227 ggc_mark_tree (li
->namespace_bindings
);
14228 ggc_mark_tree (li
->bindings
);
14229 ggc_mark_tree (li
->class_value
);
14230 ggc_mark_tree (li
->class_template_info
);
14234 ggc_mark_tree (li2
->label_value
);
14235 ggc_mark_tree (li2
->implicit_decl
);
14236 ggc_mark_tree (li2
->error_locus
);
14239 else if (code
== CPLUS_BINDING
)
14241 if (BINDING_HAS_LEVEL_P (t
))
14242 mark_binding_level (&BINDING_LEVEL (t
));
14244 ggc_mark_tree (BINDING_SCOPE (t
));
14245 ggc_mark_tree (BINDING_VALUE (t
));
14247 else if (code
== OVERLOAD
)
14248 ggc_mark_tree (OVL_FUNCTION (t
));
14249 else if (code
== TEMPLATE_PARM_INDEX
)
14250 ggc_mark_tree (TEMPLATE_PARM_DECL (t
));
14251 else if (TREE_CODE_CLASS (code
) == 'd')
14253 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
14258 if (!DECL_GLOBAL_CTOR_P (t
) && !DECL_GLOBAL_DTOR_P (t
))
14259 ggc_mark_tree (ld
->decl_flags
.u2
.access
);
14260 ggc_mark_tree (ld
->decl_flags
.context
);
14261 if (TREE_CODE (t
) != NAMESPACE_DECL
)
14262 ggc_mark_tree (ld
->decl_flags
.u
.template_info
);
14264 mark_binding_level (&NAMESPACE_LEVEL (t
));
14265 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
14267 ggc_mark_tree (ld
->main_decl_variant
);
14268 ggc_mark_tree (ld
->befriending_classes
);
14269 ggc_mark_tree (ld
->saved_tree
);
14270 if (TREE_CODE (t
) == TYPE_DECL
)
14271 ggc_mark_tree (ld
->u
.sorted_fields
);
14272 else if (TREE_CODE (t
) == FUNCTION_DECL
14273 && !DECL_PENDING_INLINE_P (t
))
14274 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t
));
14278 else if (TREE_CODE_CLASS (code
) == 't')
14280 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
14282 if (lt
&& !(TREE_CODE (t
) == POINTER_TYPE
14283 && TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
))
14286 ggc_mark_tree (lt
->vfields
);
14287 ggc_mark_tree (lt
->vbases
);
14288 ggc_mark_tree (lt
->tags
);
14289 ggc_mark_tree (lt
->search_slot
);
14290 ggc_mark_tree (lt
->size
);
14291 ggc_mark_tree (lt
->abstract_virtuals
);
14292 ggc_mark_tree (lt
->friend_classes
);
14293 ggc_mark_tree (lt
->rtti
);
14294 ggc_mark_tree (lt
->methods
);
14295 ggc_mark_tree (lt
->template_info
);
14296 ggc_mark_tree (lt
->befriending_classes
);
14299 /* In the case of pointer-to-member function types, the
14300 TYPE_LANG_SPECIFIC is really just a tree. */
14301 ggc_mark_tree ((tree
) lt
);