1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* Process declarations and symbol lookup for C front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
38 #include "tree-inline.h"
50 #include "diagnostic.h"
53 static tree grokparms PARAMS ((tree));
54 static const char *redeclaration_error_message PARAMS ((tree, tree));
56 static void push_binding_level PARAMS ((struct cp_binding_level *, int,
58 static void pop_binding_level PARAMS ((void));
59 static void suspend_binding_level PARAMS ((void));
60 static void resume_binding_level PARAMS ((struct cp_binding_level *));
61 static struct cp_binding_level *make_binding_level PARAMS ((void));
62 static void declare_namespace_level PARAMS ((void));
63 static int decl_jump_unsafe PARAMS ((tree));
64 static void storedecls PARAMS ((tree));
65 static void require_complete_types_for_parms PARAMS ((tree));
66 static int ambi_op_p PARAMS ((enum tree_code));
67 static int unary_op_p PARAMS ((enum tree_code));
68 static tree store_bindings PARAMS ((tree, tree));
69 static tree lookup_tag_reverse PARAMS ((tree, tree));
70 static tree obscure_complex_init PARAMS ((tree, tree));
71 static tree lookup_name_real PARAMS ((tree, int, int, int));
72 static void push_local_name PARAMS ((tree));
73 static void warn_extern_redeclared_static PARAMS ((tree, tree));
74 static tree grok_reference_init PARAMS ((tree, tree, tree));
75 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
76 enum overload_flags, tree,
77 tree, int, int, int, int, int, int, tree));
78 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
79 static tree follow_tag_typedef PARAMS ((tree));
80 static tree lookup_tag PARAMS ((enum tree_code, tree,
81 struct cp_binding_level *, int));
82 static void set_identifier_type_value_with_scope
83 PARAMS ((tree, tree, struct cp_binding_level *));
84 static void record_unknown_type PARAMS ((tree, const char *));
85 static tree builtin_function_1 PARAMS ((const char *, tree, tree, int,
86 enum built_in_class, const char *,
88 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
89 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
90 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
92 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct cp_binding_level*));
93 static void check_for_uninitialized_const_var PARAMS ((tree));
94 static hashval_t typename_hash PARAMS ((const void *));
95 static int typename_compare PARAMS ((const void *, const void *));
96 static void push_binding PARAMS ((tree, tree, struct cp_binding_level*));
97 static int add_binding PARAMS ((tree, tree));
98 static void pop_binding PARAMS ((tree, tree));
99 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
100 static tree find_binding PARAMS ((tree, tree));
101 static tree select_decl PARAMS ((tree, int));
102 static int lookup_flags PARAMS ((int, int));
103 static tree qualify_lookup PARAMS ((tree, int));
104 static tree record_builtin_java_type PARAMS ((const char *, int));
105 static const char *tag_name PARAMS ((enum tag_types code));
106 static void find_class_binding_level PARAMS ((void));
107 static struct cp_binding_level *innermost_nonclass_level PARAMS ((void));
108 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
109 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
110 static int walk_globals_r PARAMS ((tree, void *));
111 static void add_decl_to_level PARAMS ((tree, struct cp_binding_level *));
112 static tree make_label_decl PARAMS ((tree, int));
113 static void use_label PARAMS ((tree));
114 static void check_previous_goto_1 PARAMS ((tree, struct cp_binding_level *, tree,
116 static void check_previous_goto PARAMS ((struct named_label_use_list *));
117 static void check_switch_goto PARAMS ((struct cp_binding_level *));
118 static void check_previous_gotos PARAMS ((tree));
119 static void pop_label PARAMS ((tree, tree));
120 static void pop_labels PARAMS ((tree));
121 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
122 static void layout_var_decl PARAMS ((tree));
123 static void maybe_commonize_var PARAMS ((tree));
124 static tree check_initializer PARAMS ((tree, tree));
125 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
126 static void save_function_data PARAMS ((tree));
127 static void check_function_type PARAMS ((tree, tree));
128 static void destroy_local_var PARAMS ((tree));
129 static void begin_constructor_body PARAMS ((void));
130 static void finish_constructor_body PARAMS ((void));
131 static void begin_destructor_body PARAMS ((void));
132 static void finish_destructor_body PARAMS ((void));
133 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
134 static tree get_atexit_node PARAMS ((void));
135 static tree get_dso_handle_node PARAMS ((void));
136 static tree start_cleanup_fn PARAMS ((void));
137 static void end_cleanup_fn PARAMS ((void));
138 static tree cp_make_fname_decl PARAMS ((tree, int));
139 static void initialize_predefined_identifiers PARAMS ((void));
140 static tree check_special_function_return_type
141 PARAMS ((special_function_kind, tree, tree));
142 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
143 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
144 static void store_parm_decls PARAMS ((tree));
145 static int cp_missing_noreturn_ok_p PARAMS ((tree));
147 #if defined (DEBUG_BINDING_LEVELS)
148 static void indent PARAMS ((void));
151 /* Erroneous argument lists can use this *IFF* they do not modify it. */
152 tree error_mark_list;
154 /* The following symbols are subsumed in the cp_global_trees array, and
155 listed here individually for documentation purposes.
158 tree wchar_decl_node;
160 tree vtable_entry_type;
161 tree delta_type_node;
162 tree __t_desc_type_node;
163 tree ti_desc_type_node;
164 tree bltn_desc_type_node, ptr_desc_type_node;
165 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
166 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
167 tree ptm_desc_type_node;
168 tree base_desc_type_node;
170 tree class_type_node, record_type_node, union_type_node, enum_type_node;
171 tree unknown_type_node;
173 Array type `vtable_entry_type[]'
176 tree vtbl_ptr_type_node;
183 A FUNCTION_DECL which can call `abort'. Not necessarily the
184 one that the user will declare, but sufficient to be called
185 by routines that want to abort the program.
189 The FUNCTION_DECL for the default `::operator delete'.
191 tree global_delete_fndecl;
194 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
199 tree cp_global_trees[CPTI_MAX];
201 /* Indicates that there is a type value in some namespace, although
202 that is not necessarily in scope at the moment. */
204 static GTY(()) tree global_type_node;
206 /* Expect only namespace names now. */
207 static int only_namespace_names;
209 /* Used only for jumps to as-yet undefined labels, since jumps to
210 defined labels can have their validity checked immediately. */
212 struct named_label_use_list GTY(())
214 struct cp_binding_level *binding_level;
217 const char *filename_o_goto;
219 struct named_label_use_list *next;
222 #define named_label_uses cp_function_chain->x_named_label_uses
224 #define local_names cp_function_chain->x_local_names
226 /* A list of objects which have constructors or destructors
227 which reside in the global scope. The decl is stored in
228 the TREE_VALUE slot and the initializer is stored
229 in the TREE_PURPOSE slot. */
230 tree static_aggregates;
234 /* A node for the integer constants 2, and 3. */
236 tree integer_two_node, integer_three_node;
238 /* Similar, for last_function_parm_tags. */
239 tree last_function_parms;
241 /* A list of all LABEL_DECLs in the function that have names. Here so
242 we can clear out their names' definitions at the end of the
243 function, and so we can check the validity of jumps to these labels. */
245 struct named_label_list GTY(())
247 struct cp_binding_level *binding_level;
252 struct named_label_list *next;
253 unsigned int in_try_scope : 1;
254 unsigned int in_catch_scope : 1;
257 #define named_labels cp_function_chain->x_named_labels
259 /* The name of the anonymous namespace, throughout this translation
261 tree anonymous_namespace_name;
263 /* The number of function bodies which we are currently processing.
264 (Zero if we are at namespace scope, one inside the body of a
265 function, two inside the body of a function in a local class, etc.) */
268 /* States indicating how grokdeclarator() should handle declspecs marked
269 with __attribute__((deprecated)). An object declared as
270 __attribute__((deprecated)) suppresses warnings of uses of other
273 enum deprecated_states {
278 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
280 /* Set by add_implicitly_declared_members() to keep those members from
281 being flagged as deprecated or reported as using deprecated
283 int adding_implicit_members = 0;
285 /* True if a declaration with an `extern' linkage specifier is being
287 bool have_extern_spec;
290 /* For each binding contour we allocate a binding_level structure
291 which records the names defined in that contour.
294 1) one for each function definition,
295 where internal declarations of the parameters appear.
296 2) one for each compound statement,
297 to record its declarations.
299 The current meaning of a name can be found by searching the levels
300 from the current one out to the global one.
302 Off to the side, may be the class_binding_level. This exists only
303 to catch class-local declarations. It is otherwise nonexistent.
305 Also there may be binding levels that catch cleanups that must be
306 run when exceptions occur. Thus, to see whether a name is bound in
307 the current scope, it is not enough to look in the
308 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
311 /* Note that the information in the `names' component of the global contour
312 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
314 struct cp_binding_level GTY(())
316 /* A chain of _DECL nodes for all variables, constants, functions,
317 and typedef types. These are in the reverse of the order
318 supplied. There may be OVERLOADs on this list, too, but they
319 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
322 /* A list of structure, union and enum definitions, for looking up
324 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
325 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
326 or ENUMERAL_TYPE node.
328 C++: the TREE_VALUE nodes can be simple types for
329 component_bindings. */
332 /* A list of USING_DECL nodes. */
335 /* A list of used namespaces. PURPOSE is the namespace,
336 VALUE the common ancestor with this binding_level's namespace. */
337 tree using_directives;
339 /* If this binding level is the binding level for a class, then
340 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
341 is the name of an entity bound in the class. The TREE_TYPE is
342 the DECL bound by this name in the class. */
345 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
346 is used for all binding levels. In addition the TREE_VALUE is the
347 IDENTIFIER_TYPE_VALUE before we entered the class. */
350 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
351 label in this scope. The TREE_PURPOSE is the previous value of
352 the IDENTIFIER_LABEL VALUE. */
353 tree shadowed_labels;
355 /* For each level (except not the global one),
356 a chain of BLOCK nodes for all the levels
357 that were entered and exited one level down. */
360 /* The _TYPE node for this level, if parm_flag == 2. */
363 /* The binding level which this one is contained in (inherits from). */
364 struct cp_binding_level *level_chain;
366 /* List of VAR_DECLS saved from a previous for statement.
367 These would be dead in ISO-conforming code, but might
368 be referenced in ARM-era code. These are stored in a
369 TREE_LIST; the TREE_VALUE is the actual declaration. */
370 tree dead_vars_from_for;
372 /* 1 for the level that holds the parameters of a function.
373 2 for the level that holds a class declaration. */
374 unsigned parm_flag : 2;
376 /* 1 means make a BLOCK for this level regardless of all else.
377 2 for temporary binding contours created by the compiler. */
380 /* Nonzero if this level "doesn't exist" for tags. */
381 unsigned tag_transparent : 1;
383 /* Nonzero if this level can safely have additional
384 cleanup-needing variables added to it. */
385 unsigned more_cleanups_ok : 1;
386 unsigned have_cleanups : 1;
388 /* Nonzero if this scope is for storing the decls for template
389 parameters and generic decls; these decls will be discarded and
390 replaced with a TEMPLATE_DECL. */
391 unsigned template_parms_p : 1;
393 /* Nonzero if this scope corresponds to the `<>' in a
394 `template <>' clause. Whenever this flag is set,
395 TEMPLATE_PARMS_P will be set as well. */
396 unsigned template_spec_p : 1;
398 /* This is set for a namespace binding level. */
399 unsigned namespace_p : 1;
401 /* True if this level is that of a for-statement where we need to
402 worry about ambiguous (ARM or ISO) scope rules. */
403 unsigned is_for_scope : 1;
405 /* True if this level corresponds to a TRY block. Currently this
406 information is only available while building the tree structure. */
407 unsigned is_try_scope : 1;
409 /* True if this level corresponds to a CATCH block. Currently this
410 information is only available while building the tree structure. */
411 unsigned is_catch_scope : 1;
413 /* Three bits left for this word. */
415 /* Binding depth at which this level began. */
416 unsigned binding_depth;
419 #define NULL_BINDING_LEVEL ((struct cp_binding_level *) NULL)
421 /* The binding level currently in effect. */
423 #define current_binding_level \
424 (cfun && cp_function_chain->bindings \
425 ? cp_function_chain->bindings \
426 : scope_chain->bindings)
428 /* The binding level of the current class, if any. */
430 #define class_binding_level scope_chain->class_bindings
432 /* A chain of binding_level structures awaiting reuse. */
434 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
436 /* The outermost binding level, for names of file scope.
437 This is created when the compiler is started and exists
438 through the entire run. */
440 static GTY(()) struct cp_binding_level *global_binding_level;
442 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
444 static int keep_next_level_flag;
446 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
447 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
448 time the VAR_DECL was declared, the type was incomplete. */
450 static GTY(()) tree incomplete_vars;
452 #if defined(DEBUG_BINDING_LEVELS)
453 static int binding_depth = 0;
454 static int is_class_level = 0;
461 for (i = 0; i < binding_depth*2; i++)
464 #endif /* defined(DEBUG_BINDING_LEVELS) */
466 static tree pushdecl_with_scope PARAMS ((tree, struct cp_binding_level *));
469 push_binding_level (newlevel, tag_transparent, keep)
470 struct cp_binding_level *newlevel;
471 int tag_transparent, keep;
473 /* Add this level to the front of the chain (stack) of levels that
475 memset ((char*) newlevel, 0, sizeof (struct cp_binding_level));
476 newlevel->level_chain = current_binding_level;
477 current_binding_level = newlevel;
478 newlevel->tag_transparent = tag_transparent;
479 newlevel->more_cleanups_ok = 1;
481 newlevel->keep = keep;
482 #if defined(DEBUG_BINDING_LEVELS)
483 newlevel->binding_depth = binding_depth;
485 fprintf (stderr, "push %s level 0x%08x line %d\n",
486 (is_class_level) ? "class" : "block", newlevel, lineno);
489 #endif /* defined(DEBUG_BINDING_LEVELS) */
492 /* Find the innermost enclosing class scope, and reset
493 CLASS_BINDING_LEVEL appropriately. */
496 find_class_binding_level ()
498 struct cp_binding_level *level = current_binding_level;
500 while (level && level->parm_flag != 2)
501 level = level->level_chain;
502 if (level && level->parm_flag == 2)
503 class_binding_level = level;
505 class_binding_level = 0;
511 if (global_binding_level)
513 /* Cannot pop a level, if there are none left to pop. */
514 if (current_binding_level == global_binding_level)
517 /* Pop the current level, and free the structure for reuse. */
518 #if defined(DEBUG_BINDING_LEVELS)
521 fprintf (stderr, "pop %s level 0x%08x line %d\n",
522 (is_class_level) ? "class" : "block",
523 current_binding_level, lineno);
524 if (is_class_level != (current_binding_level == class_binding_level))
527 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
530 #endif /* defined(DEBUG_BINDING_LEVELS) */
532 register struct cp_binding_level *level = current_binding_level;
533 current_binding_level = current_binding_level->level_chain;
534 level->level_chain = free_binding_level;
535 #if 0 /* defined(DEBUG_BINDING_LEVELS) */
536 if (level->binding_depth != binding_depth)
538 #endif /* defined(DEBUG_BINDING_LEVELS) */
539 free_binding_level = level;
540 find_class_binding_level ();
545 suspend_binding_level ()
547 if (class_binding_level)
548 current_binding_level = class_binding_level;
550 if (global_binding_level)
552 /* Cannot suspend a level, if there are none left to suspend. */
553 if (current_binding_level == global_binding_level)
556 /* Suspend the current level. */
557 #if defined(DEBUG_BINDING_LEVELS)
560 fprintf (stderr, "suspend %s level 0x%08x line %d\n",
561 (is_class_level) ? "class" : "block",
562 current_binding_level, lineno);
563 if (is_class_level != (current_binding_level == class_binding_level))
566 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
569 #endif /* defined(DEBUG_BINDING_LEVELS) */
570 current_binding_level = current_binding_level->level_chain;
571 find_class_binding_level ();
575 resume_binding_level (b)
576 struct cp_binding_level *b;
578 /* Resuming binding levels is meant only for namespaces,
579 and those cannot nest into classes. */
580 my_friendly_assert(!class_binding_level, 386);
581 /* Also, resuming a non-directly nested namespace is a no-no. */
582 my_friendly_assert(b->level_chain == current_binding_level, 386);
583 current_binding_level = b;
584 #if defined(DEBUG_BINDING_LEVELS)
585 b->binding_depth = binding_depth;
587 fprintf (stderr, "resume %s level 0x%08x line %d\n",
588 (is_class_level) ? "class" : "block", b, lineno);
591 #endif /* defined(DEBUG_BINDING_LEVELS) */
594 /* Create a new `struct cp_binding_level'. */
597 struct cp_binding_level *
598 make_binding_level ()
601 return (struct cp_binding_level *) ggc_alloc (sizeof (struct cp_binding_level));
604 /* Nonzero if we are currently in the global binding level. */
609 return current_binding_level == global_binding_level;
612 /* Return the innermost binding level that is not for a class scope. */
614 static struct cp_binding_level *
615 innermost_nonclass_level ()
617 struct cp_binding_level *b;
619 b = current_binding_level;
620 while (b->parm_flag == 2)
626 /* Nonzero if we are currently in a toplevel binding level. This
627 means either the global binding level or a namespace in a toplevel
628 binding level. Since there are no non-toplevel namespace levels,
629 this really means any namespace or template parameter level. We
630 also include a class whose context is toplevel. */
633 toplevel_bindings_p ()
635 struct cp_binding_level *b = innermost_nonclass_level ();
637 return b->namespace_p || b->template_parms_p;
640 /* Nonzero if this is a namespace scope, or if we are defining a class
641 which is itself at namespace scope, or whose enclosing class is
642 such a class, etc. */
645 namespace_bindings_p ()
647 struct cp_binding_level *b = innermost_nonclass_level ();
649 return b->namespace_p;
652 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
653 unconditionally. Otherwise, use the normal logic to decide whether
654 or not to create a BLOCK. */
657 keep_next_level (keep)
660 keep_next_level_flag = keep;
663 /* Nonzero if the current level needs to have a BLOCK made. */
668 return (current_binding_level->blocks != NULL_TREE
669 || current_binding_level->keep
670 || current_binding_level->names != NULL_TREE
671 || (current_binding_level->tags != NULL_TREE
672 && !current_binding_level->tag_transparent));
676 declare_namespace_level ()
678 current_binding_level->namespace_p = 1;
681 /* Returns non-zero if this scope was created to store template
685 template_parm_scope_p ()
687 return current_binding_level->template_parms_p;
690 /* Returns the kind of template specialization we are currently
691 processing, given that it's declaration contained N_CLASS_SCOPES
692 explicit scope qualifications. */
695 current_tmpl_spec_kind (n_class_scopes)
698 int n_template_parm_scopes = 0;
699 int seen_specialization_p = 0;
700 int innermost_specialization_p = 0;
701 struct cp_binding_level *b;
703 /* Scan through the template parameter scopes. */
704 for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
706 /* If we see a specialization scope inside a parameter scope,
707 then something is wrong. That corresponds to a declaration
710 template <class T> template <> ...
712 which is always invalid since [temp.expl.spec] forbids the
713 specialization of a class member template if the enclosing
714 class templates are not explicitly specialized as well. */
715 if (b->template_spec_p)
717 if (n_template_parm_scopes == 0)
718 innermost_specialization_p = 1;
720 seen_specialization_p = 1;
722 else if (seen_specialization_p == 1)
723 return tsk_invalid_member_spec;
725 ++n_template_parm_scopes;
728 /* Handle explicit instantiations. */
729 if (processing_explicit_instantiation)
731 if (n_template_parm_scopes != 0)
732 /* We've seen a template parameter list during an explicit
733 instantiation. For example:
735 template <class T> template void f(int);
737 This is erroneous. */
738 return tsk_invalid_expl_inst;
740 return tsk_expl_inst;
743 if (n_template_parm_scopes < n_class_scopes)
744 /* We've not seen enough template headers to match all the
745 specialized classes present. For example:
747 template <class T> void R<T>::S<T>::f(int);
749 This is invalid; there needs to be one set of template
750 parameters for each class. */
751 return tsk_insufficient_parms;
752 else if (n_template_parm_scopes == n_class_scopes)
753 /* We're processing a non-template declaration (even though it may
754 be a member of a template class.) For example:
756 template <class T> void S<T>::f(int);
758 The `class T' maches the `S<T>', leaving no template headers
759 corresponding to the `f'. */
761 else if (n_template_parm_scopes > n_class_scopes + 1)
762 /* We've got too many template headers. For example:
764 template <> template <class T> void f (T);
766 There need to be more enclosing classes. */
767 return tsk_excessive_parms;
769 /* This must be a template. It's of the form:
771 template <class T> template <class U> void S<T>::f(U);
773 This is a specialization if the innermost level was a
774 specialization; otherwise it's just a definition of the
776 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
780 set_class_shadows (shadows)
783 class_binding_level->class_shadowed = shadows;
786 /* Enter a new binding level.
787 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
788 not for that of tags. */
791 pushlevel (tag_transparent)
794 struct cp_binding_level *newlevel;
796 if (cfun && !doing_semantic_analysis_p ())
799 /* Reuse or create a struct for this binding level. */
800 #if defined(DEBUG_BINDING_LEVELS)
802 #else /* !defined(DEBUG_BINDING_LEVELS) */
803 if (free_binding_level)
804 #endif /* !defined(DEBUG_BINDING_LEVELS) */
806 newlevel = free_binding_level;
807 free_binding_level = free_binding_level->level_chain;
810 newlevel = make_binding_level ();
812 push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
813 keep_next_level_flag = 0;
816 /* We're defining an object of type TYPE. If it needs a cleanup, but
817 we're not allowed to add any more objects with cleanups to the current
818 scope, create a new binding level. */
821 maybe_push_cleanup_level (type)
824 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
825 && current_binding_level->more_cleanups_ok == 0)
830 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
834 /* Enter a new scope. The KIND indicates what kind of scope is being
845 case sk_template_spec:
846 current_binding_level->template_spec_p = 1;
849 case sk_template_parms:
850 current_binding_level->template_parms_p = 1;
858 /* Exit the current scope. */
867 note_level_for_for ()
869 current_binding_level->is_for_scope = 1;
872 /* Record that the current binding level represents a try block. */
875 note_level_for_try ()
877 current_binding_level->is_try_scope = 1;
880 /* Record that the current binding level represents a catch block. */
883 note_level_for_catch ()
885 current_binding_level->is_catch_scope = 1;
888 /* For a binding between a name and an entity at a block scope,
889 this is the `struct cp_binding_level' for the block. */
890 #define BINDING_LEVEL(NODE) \
891 (((struct tree_binding*)(NODE))->scope.level)
893 /* A free list of CPLUS_BINDING nodes, connected by their
896 static GTY((deletable (""))) tree free_bindings;
898 /* Make DECL the innermost binding for ID. The LEVEL is the binding
899 level at which this declaration is being bound. */
902 push_binding (id, decl, level)
905 struct cp_binding_level* level;
911 binding = free_bindings;
912 free_bindings = TREE_CHAIN (binding);
915 binding = make_node (CPLUS_BINDING);
917 /* Now, fill in the binding information. */
918 BINDING_VALUE (binding) = decl;
919 BINDING_TYPE (binding) = NULL_TREE;
920 BINDING_LEVEL (binding) = level;
921 INHERITED_VALUE_BINDING_P (binding) = 0;
922 LOCAL_BINDING_P (binding) = (level != class_binding_level);
923 BINDING_HAS_LEVEL_P (binding) = 1;
925 /* And put it on the front of the list of bindings for ID. */
926 TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
927 IDENTIFIER_BINDING (id) = binding;
930 /* ID is already bound in the current scope. But, DECL is an
931 additional binding for ID in the same scope. This is the `struct
932 stat' hack whereby a non-typedef class-name or enum-name can be
933 bound at the same level as some other kind of entity. It's the
934 responsibility of the caller to check that inserting this name is
935 valid here. Returns nonzero if the new binding was successful. */
937 add_binding (id, decl)
941 tree binding = IDENTIFIER_BINDING (id);
944 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
945 /* The new name is the type name. */
946 BINDING_TYPE (binding) = decl;
947 else if (!BINDING_VALUE (binding))
948 /* This situation arises when push_class_level_binding moves an
949 inherited type-binding out of the way to make room for a new
951 BINDING_VALUE (binding) = decl;
952 else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
953 && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
955 /* The old binding was a type name. It was placed in
956 BINDING_VALUE because it was thought, at the point it was
957 declared, to be the only entity with such a name. Move the
958 type name into the type slot; it is now hidden by the new
960 BINDING_TYPE (binding) = BINDING_VALUE (binding);
961 BINDING_VALUE (binding) = decl;
962 INHERITED_VALUE_BINDING_P (binding) = 0;
964 else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
965 && TREE_CODE (decl) == TYPE_DECL
966 && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
967 && (same_type_p (TREE_TYPE (decl),
968 TREE_TYPE (BINDING_VALUE (binding)))
969 /* If either type involves template parameters, we must
970 wait until instantiation. */
971 || uses_template_parms (TREE_TYPE (decl))
972 || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
973 /* We have two typedef-names, both naming the same type to have
974 the same name. This is OK because of:
978 In a given scope, a typedef specifier can be used to redefine
979 the name of any type declared in that scope to refer to the
980 type to which it already refers. */
982 /* There can be two block-scope declarations of the same variable,
983 so long as they are `extern' declarations. */
984 else if (TREE_CODE (decl) == VAR_DECL
985 && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
986 && DECL_EXTERNAL (decl)
987 && DECL_EXTERNAL (BINDING_VALUE (binding)))
989 duplicate_decls (decl, BINDING_VALUE (binding));
994 error ("declaration of `%#D'", decl);
995 cp_error_at ("conflicts with previous declaration `%#D'",
996 BINDING_VALUE (binding));
1003 /* Add DECL to the list of things declared in B. */
1006 add_decl_to_level (decl, b)
1008 struct cp_binding_level *b;
1010 /* We build up the list in reverse order, and reverse it later if
1012 TREE_CHAIN (decl) = b->names;
1016 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1017 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1018 doesn't really belong to this binding level, that it got here
1019 through a using-declaration. */
1022 push_local_binding (id, decl, flags)
1027 struct cp_binding_level *b;
1029 /* Skip over any local classes. This makes sense if we call
1030 push_local_binding with a friend decl of a local class. */
1031 b = current_binding_level;
1032 while (b->parm_flag == 2)
1035 if (lookup_name_current_level (id))
1037 /* Supplement the existing binding. */
1038 if (!add_binding (id, decl))
1039 /* It didn't work. Something else must be bound at this
1040 level. Do not add DECL to the list of things to pop
1045 /* Create a new binding. */
1046 push_binding (id, decl, b);
1048 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1049 /* We must put the OVERLOAD into a TREE_LIST since the
1050 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1051 decls that got here through a using-declaration. */
1052 decl = build_tree_list (NULL_TREE, decl);
1054 /* And put DECL on the list of things declared by the current
1056 add_decl_to_level (decl, b);
1059 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1060 binding was successful. */
1063 push_class_binding (id, decl)
1068 tree binding = IDENTIFIER_BINDING (id);
1071 /* Note that we declared this value so that we can issue an error if
1072 this is an invalid redeclaration of a name already used for some
1074 note_name_declared_in_class (id, decl);
1076 if (binding && BINDING_LEVEL (binding) == class_binding_level)
1077 /* Supplement the existing binding. */
1078 result = add_binding (id, decl);
1080 /* Create a new binding. */
1081 push_binding (id, decl, class_binding_level);
1083 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1084 class-level declaration. Note that we do not use DECL here
1085 because of the possibility of the `struct stat' hack; if DECL is
1086 a class-name or enum-name we might prefer a field-name, or some
1088 IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1090 /* If this is a binding from a base class, mark it as such. */
1091 binding = IDENTIFIER_BINDING (id);
1092 if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1094 /* Any implicit typename must be from a base-class. The
1095 context for an implicit typename declaration is always
1096 the derived class in which the lookup was done, so the checks
1097 based on the context of DECL below will not trigger. */
1098 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1099 INHERITED_VALUE_BINDING_P (binding) = 1;
1102 if (TREE_CODE (decl) == OVERLOAD)
1103 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1106 my_friendly_assert (DECL_P (decl), 0);
1107 context = context_for_name_lookup (decl);
1110 if (is_properly_derived_from (current_class_type, context))
1111 INHERITED_VALUE_BINDING_P (binding) = 1;
1113 INHERITED_VALUE_BINDING_P (binding) = 0;
1116 else if (BINDING_VALUE (binding) == decl)
1117 /* We only encounter a TREE_LIST when push_class_decls detects an
1118 ambiguity. Such an ambiguity can be overridden by a definition
1120 INHERITED_VALUE_BINDING_P (binding) = 1;
1125 /* Remove the binding for DECL which should be the innermost binding
1129 pop_binding (id, decl)
1135 if (id == NULL_TREE)
1136 /* It's easiest to write the loops that call this function without
1137 checking whether or not the entities involved have names. We
1138 get here for such an entity. */
1141 /* Get the innermost binding for ID. */
1142 binding = IDENTIFIER_BINDING (id);
1144 /* The name should be bound. */
1145 my_friendly_assert (binding != NULL_TREE, 0);
1147 /* The DECL will be either the ordinary binding or the type
1148 binding for this identifier. Remove that binding. */
1149 if (BINDING_VALUE (binding) == decl)
1150 BINDING_VALUE (binding) = NULL_TREE;
1151 else if (BINDING_TYPE (binding) == decl)
1152 BINDING_TYPE (binding) = NULL_TREE;
1156 if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1158 /* We're completely done with the innermost binding for this
1159 identifier. Unhook it from the list of bindings. */
1160 IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1162 /* Add it to the free list. */
1163 TREE_CHAIN (binding) = free_bindings;
1164 free_bindings = binding;
1166 /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1168 BINDING_LEVEL (binding) = NULL;
1172 /* When a label goes out of scope, check to see if that label was used
1173 in a valid manner, and issue any appropriate warnings or errors. */
1176 pop_label (label, old_value)
1180 if (!processing_template_decl && doing_semantic_analysis_p ())
1182 if (DECL_INITIAL (label) == NULL_TREE)
1184 cp_error_at ("label `%D' used but not defined", label);
1185 /* Avoid crashing later. */
1186 define_label (input_filename, 1, DECL_NAME (label));
1188 else if (warn_unused_label && !TREE_USED (label))
1189 cp_warning_at ("label `%D' defined but not used", label);
1192 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1195 /* At the end of a function, all labels declared within the function
1196 go out of scope. BLOCK is the top-level block for the
1203 struct named_label_list *link;
1205 /* Clear out the definitions of all label names, since their scopes
1207 for (link = named_labels; link; link = link->next)
1209 pop_label (link->label_decl, link->old_value);
1210 /* Put the labels into the "variables" of the top-level block,
1211 so debugger can see them. */
1212 TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1213 BLOCK_VARS (block) = link->label_decl;
1216 named_labels = NULL;
1219 /* Exit a binding level.
1220 Pop the level off, and restore the state of the identifier-decl mappings
1221 that were in effect when this level was entered.
1223 If KEEP == 1, this level had explicit declarations, so
1224 and create a "block" (a BLOCK node) for the level
1225 to record its declarations and subblocks for symbol table output.
1227 If FUNCTIONBODY is nonzero, this level is the body of a function,
1228 so create a block as if KEEP were set and also clear out all
1231 If REVERSE is nonzero, reverse the order of decls before putting
1232 them into the BLOCK. */
1235 poplevel (keep, reverse, functionbody)
1241 /* The chain of decls was accumulated in reverse order.
1242 Put it into forward order, just for cleanliness. */
1244 int tmp = functionbody;
1245 int real_functionbody;
1248 tree block = NULL_TREE;
1250 int leaving_for_scope;
1252 if (cfun && !doing_semantic_analysis_p ())
1255 my_friendly_assert (current_binding_level->parm_flag != 2,
1258 real_functionbody = (current_binding_level->keep == 2
1259 ? ((functionbody = 0), tmp) : functionbody);
1260 tags = functionbody >= 0 ? current_binding_level->tags : 0;
1261 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1263 my_friendly_assert (!current_binding_level->class_shadowed,
1266 /* We used to use KEEP == 2 to indicate that the new block should go
1267 at the beginning of the list of blocks at this binding level,
1268 rather than the end. This hack is no longer used. */
1269 my_friendly_assert (keep == 0 || keep == 1, 0);
1271 if (current_binding_level->keep == 1)
1274 /* Any uses of undefined labels, and any defined labels, now operate
1275 under constraints of next binding contour. */
1276 if (cfun && !functionbody)
1278 struct cp_binding_level *level_chain;
1279 level_chain = current_binding_level->level_chain;
1282 struct named_label_use_list *uses;
1283 struct named_label_list *labels;
1284 for (labels = named_labels; labels; labels = labels->next)
1285 if (labels->binding_level == current_binding_level)
1288 if (current_binding_level->is_try_scope)
1289 labels->in_try_scope = 1;
1290 if (current_binding_level->is_catch_scope)
1291 labels->in_catch_scope = 1;
1292 for (decl = labels->names_in_scope; decl;
1293 decl = TREE_CHAIN (decl))
1294 if (decl_jump_unsafe (decl))
1295 labels->bad_decls = tree_cons (NULL_TREE, decl,
1297 labels->binding_level = level_chain;
1298 labels->names_in_scope = level_chain->names;
1301 for (uses = named_label_uses; uses; uses = uses->next)
1302 if (uses->binding_level == current_binding_level)
1304 uses->binding_level = level_chain;
1305 uses->names_in_scope = level_chain->names;
1310 /* Get the decls in the order they were written.
1311 Usually current_binding_level->names is in reverse order.
1312 But parameter decls were previously put in forward order. */
1315 current_binding_level->names
1316 = decls = nreverse (current_binding_level->names);
1318 decls = current_binding_level->names;
1320 /* Output any nested inline functions within this block
1321 if they weren't already output. */
1322 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1323 if (TREE_CODE (decl) == FUNCTION_DECL
1324 && ! TREE_ASM_WRITTEN (decl)
1325 && DECL_INITIAL (decl) != NULL_TREE
1326 && TREE_ADDRESSABLE (decl)
1327 && decl_function_context (decl) == current_function_decl)
1329 /* If this decl was copied from a file-scope decl
1330 on account of a block-scope extern decl,
1331 propagate TREE_ADDRESSABLE to the file-scope decl. */
1332 if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1333 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1336 push_function_context ();
1337 output_inline_function (decl);
1338 pop_function_context ();
1342 /* When not in function-at-a-time mode, expand_end_bindings will
1343 warn about unused variables. But, in function-at-a-time mode
1344 expand_end_bindings is not passed the list of variables in the
1345 current scope, and therefore no warning is emitted. So, we
1346 explicitly warn here. */
1347 if (!processing_template_decl)
1348 warn_about_unused_variables (getdecls ());
1350 /* If there were any declarations or structure tags in that level,
1351 or if this level is a function body,
1352 create a BLOCK to record them for the life of this function. */
1354 if (keep == 1 || functionbody)
1355 block = make_node (BLOCK);
1356 if (block != NULL_TREE)
1358 BLOCK_VARS (block) = decls;
1359 BLOCK_SUBBLOCKS (block) = subblocks;
1362 /* In each subblock, record that this is its superior. */
1364 for (link = subblocks; link; link = TREE_CHAIN (link))
1365 BLOCK_SUPERCONTEXT (link) = block;
1367 /* We still support the old for-scope rules, whereby the variables
1368 in a for-init statement were in scope after the for-statement
1369 ended. We only use the new rules in flag_new_for_scope is
1372 = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1374 /* Remove declarations for all the DECLs in this level. */
1375 for (link = decls; link; link = TREE_CHAIN (link))
1377 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1378 && DECL_NAME (link))
1381 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1385 ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1387 ns_binding = NULL_TREE;
1390 && (BINDING_LEVEL (outer_binding)
1391 == current_binding_level->level_chain))
1392 /* We have something like:
1397 and we are leaving the `for' scope. There's no reason to
1398 keep the binding of the inner `i' in this case. */
1399 pop_binding (DECL_NAME (link), link);
1400 else if ((outer_binding
1401 && (TREE_CODE (BINDING_VALUE (outer_binding))
1404 && TREE_CODE (ns_binding) == TYPE_DECL))
1405 /* Here, we have something like:
1413 We must pop the for-scope binding so we know what's a
1414 type and what isn't. */
1415 pop_binding (DECL_NAME (link), link);
1418 /* Mark this VAR_DECL as dead so that we can tell we left it
1419 there only for backward compatibility. */
1420 DECL_DEAD_FOR_LOCAL (link) = 1;
1422 /* Keep track of what should of have happenned when we
1423 popped the binding. */
1424 if (outer_binding && BINDING_VALUE (outer_binding))
1425 DECL_SHADOWED_FOR_VAR (link)
1426 = BINDING_VALUE (outer_binding);
1428 /* Add it to the list of dead variables in the next
1429 outermost binding to that we can remove these when we
1430 leave that binding. */
1431 current_binding_level->level_chain->dead_vars_from_for
1432 = tree_cons (NULL_TREE, link,
1433 current_binding_level->level_chain->
1434 dead_vars_from_for);
1436 /* Although we don't pop the CPLUS_BINDING, we do clear
1437 its BINDING_LEVEL since the level is going away now. */
1438 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1444 /* Remove the binding. */
1446 if (TREE_CODE (decl) == TREE_LIST)
1447 decl = TREE_VALUE (decl);
1449 pop_binding (DECL_NAME (decl), decl);
1450 else if (TREE_CODE (decl) == OVERLOAD)
1451 pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1457 /* Remove declarations for any `for' variables from inner scopes
1458 that we kept around. */
1459 for (link = current_binding_level->dead_vars_from_for;
1460 link; link = TREE_CHAIN (link))
1461 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1463 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1464 for (link = current_binding_level->type_shadowed;
1465 link; link = TREE_CHAIN (link))
1466 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1468 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1469 for (link = current_binding_level->shadowed_labels;
1471 link = TREE_CHAIN (link))
1472 pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1474 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1475 list if a `using' declaration put them there. The debugging
1476 back-ends won't understand OVERLOAD, so we remove them here.
1477 Because the BLOCK_VARS are (temporarily) shared with
1478 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1479 popped all the bindings. */
1484 for (d = &BLOCK_VARS (block); *d; )
1486 if (TREE_CODE (*d) == TREE_LIST)
1487 *d = TREE_CHAIN (*d);
1489 d = &TREE_CHAIN (*d);
1493 /* If the level being exited is the top level of a function,
1494 check over all the labels. */
1497 /* Since this is the top level block of a function, the vars are
1498 the function's parameters. Don't leave them in the BLOCK
1499 because they are found in the FUNCTION_DECL instead. */
1500 BLOCK_VARS (block) = 0;
1504 tmp = current_binding_level->keep;
1506 pop_binding_level ();
1508 DECL_INITIAL (current_function_decl) = block;
1510 current_binding_level->blocks
1511 = chainon (current_binding_level->blocks, block);
1513 /* If we did not make a block for the level just exited,
1514 any blocks made for inner levels
1515 (since they cannot be recorded as subblocks in that level)
1516 must be carried forward so they will later become subblocks
1517 of something else. */
1519 current_binding_level->blocks
1520 = chainon (current_binding_level->blocks, subblocks);
1522 /* Each and every BLOCK node created here in `poplevel' is important
1523 (e.g. for proper debugging information) so if we created one
1524 earlier, mark it as "used". */
1526 TREE_USED (block) = 1;
1528 /* Take care of compiler's internal binding structures. */
1534 = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1537 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1538 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1541 block = poplevel (keep, reverse, functionbody);
1547 /* Delete the node BLOCK from the current binding level.
1548 This is used for the block inside a stmt expr ({...})
1549 so that the block can be reinserted where appropriate. */
1552 delete_block (block)
1556 if (current_binding_level->blocks == block)
1557 current_binding_level->blocks = TREE_CHAIN (block);
1558 for (t = current_binding_level->blocks; t;)
1560 if (TREE_CHAIN (t) == block)
1561 TREE_CHAIN (t) = TREE_CHAIN (block);
1565 TREE_CHAIN (block) = NULL_TREE;
1566 /* Clear TREE_USED which is always set by poplevel.
1567 The flag is set again if insert_block is called. */
1568 TREE_USED (block) = 0;
1571 /* Insert BLOCK at the end of the list of subblocks of the
1572 current binding level. This is used when a BIND_EXPR is expanded,
1573 to handle the BLOCK node inside the BIND_EXPR. */
1576 insert_block (block)
1579 TREE_USED (block) = 1;
1580 current_binding_level->blocks
1581 = chainon (current_binding_level->blocks, block);
1584 /* Set the BLOCK node for the innermost scope
1585 (the one we are currently in). */
1589 tree block ATTRIBUTE_UNUSED;
1591 /* The RTL expansion machinery requires us to provide this callback,
1592 but it is not applicable in function-at-a-time mode. */
1593 my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1596 /* Do a pushlevel for class declarations. */
1601 register struct cp_binding_level *newlevel;
1603 /* Reuse or create a struct for this binding level. */
1604 #if defined(DEBUG_BINDING_LEVELS)
1606 #else /* !defined(DEBUG_BINDING_LEVELS) */
1607 if (free_binding_level)
1608 #endif /* !defined(DEBUG_BINDING_LEVELS) */
1610 newlevel = free_binding_level;
1611 free_binding_level = free_binding_level->level_chain;
1614 newlevel = make_binding_level ();
1616 #if defined(DEBUG_BINDING_LEVELS)
1618 #endif /* defined(DEBUG_BINDING_LEVELS) */
1620 push_binding_level (newlevel, 0, 0);
1622 class_binding_level = current_binding_level;
1623 class_binding_level->parm_flag = 2;
1624 class_binding_level->this_class = current_class_type;
1627 /* ...and a poplevel for class declarations. */
1632 register struct cp_binding_level *level = class_binding_level;
1635 my_friendly_assert (level != 0, 354);
1637 /* If we're leaving a toplevel class, don't bother to do the setting
1638 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1639 shouldn't even be used when current_class_type isn't set, and second,
1640 if we don't touch it here, we're able to use the cache effect if the
1641 next time we're entering a class scope, it is the same class. */
1642 if (current_class_depth != 1)
1644 struct cp_binding_level* b;
1646 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1647 for (shadowed = level->class_shadowed;
1649 shadowed = TREE_CHAIN (shadowed))
1650 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1652 /* Find the next enclosing class, and recreate
1653 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1654 b = level->level_chain;
1655 while (b && b->parm_flag != 2)
1659 for (shadowed = b->class_shadowed;
1661 shadowed = TREE_CHAIN (shadowed))
1665 t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1666 while (t && BINDING_LEVEL (t) != b)
1670 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1671 = BINDING_VALUE (t);
1675 /* Remember to save what IDENTIFIER's were bound in this scope so we
1676 can recover from cache misses. */
1678 previous_class_type = current_class_type;
1679 previous_class_values = class_binding_level->class_shadowed;
1681 for (shadowed = level->type_shadowed;
1683 shadowed = TREE_CHAIN (shadowed))
1684 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1686 /* Remove the bindings for all of the class-level declarations. */
1687 for (shadowed = level->class_shadowed;
1689 shadowed = TREE_CHAIN (shadowed))
1690 pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1692 /* Now, pop out of the binding level which we created up in the
1693 `pushlevel_class' routine. */
1694 #if defined(DEBUG_BINDING_LEVELS)
1696 #endif /* defined(DEBUG_BINDING_LEVELS) */
1698 pop_binding_level ();
1701 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1702 for any names in enclosing classes. */
1705 clear_identifier_class_values ()
1709 if (!class_binding_level)
1712 for (t = class_binding_level->class_shadowed;
1715 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1718 /* Returns non-zero if T is a virtual function table. */
1721 vtable_decl_p (t, data)
1723 void *data ATTRIBUTE_UNUSED;
1725 return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1728 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1732 vtype_decl_p (t, data)
1734 void *data ATTRIBUTE_UNUSED;
1736 return (TREE_CODE (t) == TYPE_DECL
1737 && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1738 && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1741 /* Return the declarations that are members of the namespace NS. */
1744 cp_namespace_decls (ns)
1747 return NAMESPACE_LEVEL (ns)->names;
1750 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1751 itself, calling F for each. The DATA is passed to F as well. */
1754 walk_namespaces_r (namespace, f, data)
1756 walk_namespaces_fn f;
1762 result |= (*f) (namespace, data);
1764 for (current = cp_namespace_decls (namespace);
1766 current = TREE_CHAIN (current))
1768 if (TREE_CODE (current) != NAMESPACE_DECL
1769 || DECL_NAMESPACE_ALIAS (current))
1772 /* We found a namespace. */
1773 result |= walk_namespaces_r (current, f, data);
1779 /* Walk all the namespaces, calling F for each. The DATA is passed to
1783 walk_namespaces (f, data)
1784 walk_namespaces_fn f;
1787 return walk_namespaces_r (global_namespace, f, data);
1790 struct walk_globals_data {
1791 walk_globals_pred p;
1796 /* Walk the global declarations in NAMESPACE. Whenever one is found
1797 for which P returns non-zero, call F with its address. If any call
1798 to F returns a non-zero value, return a non-zero value. */
1801 walk_globals_r (namespace, data)
1805 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1806 walk_globals_pred p = wgd->p;
1807 walk_globals_fn f = wgd->f;
1808 void *d = wgd->data;
1812 t = &NAMESPACE_LEVEL (namespace)->names;
1819 result |= (*f) (t, d);
1821 /* If F changed *T, then *T still points at the next item to
1824 t = &TREE_CHAIN (*t);
1830 /* Walk the global declarations. Whenever one is found for which P
1831 returns non-zero, call F with its address. If any call to F
1832 returns a non-zero value, return a non-zero value. */
1835 walk_globals (p, f, data)
1836 walk_globals_pred p;
1840 struct walk_globals_data wgd;
1845 return walk_namespaces (walk_globals_r, &wgd);
1848 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1849 DATA is non-NULL, this is the last time we will call
1850 wrapup_global_declarations for this NAMESPACE. */
1853 wrapup_globals_for_namespace (namespace, data)
1857 tree globals = cp_namespace_decls (namespace);
1858 int len = list_length (globals);
1859 tree *vec = (tree *) alloca (sizeof (tree) * len);
1863 int last_time = (data != 0);
1865 if (last_time && namespace == global_namespace)
1866 /* Let compile_file handle the global namespace. */
1869 /* Process the decls in reverse order--earliest first.
1870 Put them into VEC from back to front, then take out from front. */
1871 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1872 vec[len - i - 1] = decl;
1876 check_global_declarations (vec, len);
1880 /* Temporarily mark vtables as external. That prevents
1881 wrapup_global_declarations from writing them out; we must process
1882 them ourselves in finish_vtable_vardecl. */
1883 for (i = 0; i < len; ++i)
1884 if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1886 DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1887 DECL_EXTERNAL (vec[i]) = 1;
1890 /* Write out any globals that need to be output. */
1891 result = wrapup_global_declarations (vec, len);
1893 /* Undo the hack to DECL_EXTERNAL above. */
1894 for (i = 0; i < len; ++i)
1895 if (vtable_decl_p (vec[i], /*data=*/0)
1896 && DECL_NOT_REALLY_EXTERN (vec[i]))
1898 DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1899 DECL_EXTERNAL (vec[i]) = 0;
1906 /* For debugging. */
1907 static int no_print_functions = 0;
1908 static int no_print_builtins = 0;
1911 print_binding_level (lvl)
1912 struct cp_binding_level *lvl;
1916 fprintf (stderr, " blocks=");
1917 fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1918 if (lvl->tag_transparent)
1919 fprintf (stderr, " tag-transparent");
1920 if (lvl->more_cleanups_ok)
1921 fprintf (stderr, " more-cleanups-ok");
1922 if (lvl->have_cleanups)
1923 fprintf (stderr, " have-cleanups");
1924 fprintf (stderr, "\n");
1927 fprintf (stderr, " names:\t");
1928 /* We can probably fit 3 names to a line? */
1929 for (t = lvl->names; t; t = TREE_CHAIN (t))
1931 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1933 if (no_print_builtins
1934 && (TREE_CODE (t) == TYPE_DECL)
1935 && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1938 /* Function decls tend to have longer names. */
1939 if (TREE_CODE (t) == FUNCTION_DECL)
1946 fprintf (stderr, "\n\t");
1949 print_node_brief (stderr, "", t, 0);
1950 if (t == error_mark_node)
1954 fprintf (stderr, "\n");
1958 fprintf (stderr, " tags:\t");
1960 for (t = lvl->tags; t; t = TREE_CHAIN (t))
1962 if (TREE_PURPOSE (t) == NULL_TREE)
1964 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1971 fprintf (stderr, "\n\t");
1974 if (TREE_PURPOSE (t) == NULL_TREE)
1976 print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1977 fprintf (stderr, ">");
1979 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1980 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1983 print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1984 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1985 fprintf (stderr, ">");
1989 fprintf (stderr, "\n");
1991 if (lvl->class_shadowed)
1993 fprintf (stderr, " class-shadowed:");
1994 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1996 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1998 fprintf (stderr, "\n");
2000 if (lvl->type_shadowed)
2002 fprintf (stderr, " type-shadowed:");
2003 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2005 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2007 fprintf (stderr, "\n");
2012 print_other_binding_stack (stack)
2013 struct cp_binding_level *stack;
2015 struct cp_binding_level *level;
2016 for (level = stack; level != global_binding_level; level = level->level_chain)
2018 fprintf (stderr, "binding level ");
2019 fprintf (stderr, HOST_PTR_PRINTF, level);
2020 fprintf (stderr, "\n");
2021 print_binding_level (level);
2026 print_binding_stack ()
2028 struct cp_binding_level *b;
2029 fprintf (stderr, "current_binding_level=");
2030 fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2031 fprintf (stderr, "\nclass_binding_level=");
2032 fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2033 fprintf (stderr, "\nglobal_binding_level=");
2034 fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2035 fprintf (stderr, "\n");
2036 if (class_binding_level)
2038 for (b = class_binding_level; b; b = b->level_chain)
2039 if (b == current_binding_level)
2042 b = class_binding_level;
2044 b = current_binding_level;
2047 b = current_binding_level;
2048 print_other_binding_stack (b);
2049 fprintf (stderr, "global:\n");
2050 print_binding_level (global_binding_level);
2053 /* Namespace binding access routines: The namespace_bindings field of
2054 the identifier is polymorphic, with three possible values:
2055 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2056 indicating the BINDING_VALUE of global_namespace. */
2058 /* Check whether the a binding for the name to scope is known.
2059 Assumes that the bindings of the name are already a list
2060 of bindings. Returns the binding found, or NULL_TREE. */
2063 find_binding (name, scope)
2067 tree iter, prev = NULL_TREE;
2069 scope = ORIGINAL_NAMESPACE (scope);
2071 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2072 iter = TREE_CHAIN (iter))
2074 my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2075 if (BINDING_SCOPE (iter) == scope)
2077 /* Move binding found to the front of the list, so
2078 subsequent lookups will find it faster. */
2081 TREE_CHAIN (prev) = TREE_CHAIN (iter);
2082 TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2083 IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2092 /* Always returns a binding for name in scope. If the
2093 namespace_bindings is not a list, convert it to one first.
2094 If no binding is found, make a new one. */
2097 binding_for_name (name, scope)
2101 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2104 scope = ORIGINAL_NAMESPACE (scope);
2106 if (b && TREE_CODE (b) != CPLUS_BINDING)
2108 /* Get rid of optimization for global scope. */
2109 IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2110 BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2111 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2113 if (b && (result = find_binding (name, scope)))
2115 /* Not found, make a new one. */
2116 result = make_node (CPLUS_BINDING);
2117 TREE_CHAIN (result) = b;
2118 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2119 BINDING_SCOPE (result) = scope;
2120 BINDING_TYPE (result) = NULL_TREE;
2121 BINDING_VALUE (result) = NULL_TREE;
2125 /* Return the binding value for name in scope, considering that
2126 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2129 namespace_binding (name, scope)
2133 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2136 if (scope == NULL_TREE)
2137 scope = global_namespace;
2138 if (TREE_CODE (b) != CPLUS_BINDING)
2139 return (scope == global_namespace) ? b : NULL_TREE;
2140 name = find_binding (name,scope);
2141 if (name == NULL_TREE)
2143 return BINDING_VALUE (name);
2146 /* Set the binding value for name in scope. If modifying the binding
2147 of global_namespace is attempted, try to optimize it. */
2150 set_namespace_binding (name, scope, val)
2157 if (scope == NULL_TREE)
2158 scope = global_namespace;
2160 if (scope == global_namespace)
2162 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2163 if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2165 IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2169 b = binding_for_name (name, scope);
2170 BINDING_VALUE (b) = val;
2173 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2174 select a name that is unique to this compilation unit. */
2177 push_namespace (name)
2182 int implicit_use = 0;
2184 if (!global_namespace)
2186 /* This must be ::. */
2187 my_friendly_assert (name == get_identifier ("::"), 377);
2192 /* The name of anonymous namespace is unique for the translation
2194 if (!anonymous_namespace_name)
2195 anonymous_namespace_name = get_file_function_name ('N');
2196 name = anonymous_namespace_name;
2197 d = IDENTIFIER_NAMESPACE_VALUE (name);
2199 /* Reopening anonymous namespace. */
2205 /* Check whether this is an extended namespace definition. */
2206 d = IDENTIFIER_NAMESPACE_VALUE (name);
2207 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2210 if (DECL_NAMESPACE_ALIAS (d))
2212 error ("namespace alias `%D' not allowed here, assuming `%D'",
2213 d, DECL_NAMESPACE_ALIAS (d));
2214 d = DECL_NAMESPACE_ALIAS (d);
2221 /* Make a new namespace, binding the name to it. */
2222 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2223 /* The global namespace is not pushed, and the global binding
2224 level is set elsewhere. */
2227 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2230 declare_namespace_level ();
2231 NAMESPACE_LEVEL (d) = current_binding_level;
2235 resume_binding_level (NAMESPACE_LEVEL (d));
2238 do_using_directive (d);
2239 /* Enter the name space. */
2240 current_namespace = d;
2243 /* Pop from the scope of the current namespace. */
2248 my_friendly_assert (current_namespace != global_namespace, 20010801);
2249 current_namespace = CP_DECL_CONTEXT (current_namespace);
2250 /* The binding level is not popped, as it might be re-opened later. */
2251 suspend_binding_level ();
2254 /* Push into the scope of the namespace NS, even if it is deeply
2255 nested within another namespace. */
2258 push_nested_namespace (ns)
2261 if (ns == global_namespace)
2262 push_to_top_level ();
2265 push_nested_namespace (CP_DECL_CONTEXT (ns));
2266 push_namespace (DECL_NAME (ns));
2270 /* Pop back from the scope of the namespace NS, which was previously
2271 entered with push_nested_namespace. */
2274 pop_nested_namespace (ns)
2277 while (ns != global_namespace)
2280 ns = CP_DECL_CONTEXT (ns);
2283 pop_from_top_level ();
2287 /* Subroutines for reverting temporarily to top-level for instantiation
2288 of templates and such. We actually need to clear out the class- and
2289 local-value slots of all identifiers, so that only the global values
2290 are at all visible. Simply setting current_binding_level to the global
2291 scope isn't enough, because more binding levels may be pushed. */
2292 struct saved_scope *scope_chain;
2295 store_bindings (names, old_bindings)
2296 tree names, old_bindings;
2299 tree search_bindings = old_bindings;
2301 for (t = names; t; t = TREE_CHAIN (t))
2303 tree binding, t1, id;
2305 if (TREE_CODE (t) == TREE_LIST)
2306 id = TREE_PURPOSE (t);
2311 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2312 we have no IDENTIFIER_BINDING if we have left the class
2313 scope, but cached the class-level declarations. */
2314 || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2317 for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2318 if (TREE_VEC_ELT (t1, 0) == id)
2321 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2322 binding = make_tree_vec (4);
2323 TREE_VEC_ELT (binding, 0) = id;
2324 TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2325 TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2326 TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2327 IDENTIFIER_BINDING (id) = NULL_TREE;
2328 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2329 TREE_CHAIN (binding) = old_bindings;
2330 old_bindings = binding;
2334 return old_bindings;
2338 maybe_push_to_top_level (pseudo)
2341 struct saved_scope *s;
2342 struct cp_binding_level *b;
2346 s = (struct saved_scope *) ggc_alloc_cleared (sizeof (struct saved_scope));
2348 b = scope_chain ? current_binding_level : 0;
2350 /* If we're in the middle of some function, save our state. */
2354 push_function_context_to (NULL_TREE);
2359 old_bindings = NULL_TREE;
2360 if (scope_chain && previous_class_type)
2361 old_bindings = store_bindings (previous_class_values, old_bindings);
2363 /* Have to include global_binding_level, because class-level decls
2364 aren't listed anywhere useful. */
2365 for (; b; b = b->level_chain)
2369 /* Template IDs are inserted into the global level. If they were
2370 inserted into namespace level, finish_file wouldn't find them
2371 when doing pending instantiations. Therefore, don't stop at
2372 namespace level, but continue until :: . */
2373 if (b == global_binding_level || (pseudo && b->template_parms_p))
2376 old_bindings = store_bindings (b->names, old_bindings);
2377 /* We also need to check class_shadowed to save class-level type
2378 bindings, since pushclass doesn't fill in b->names. */
2379 if (b->parm_flag == 2)
2380 old_bindings = store_bindings (b->class_shadowed, old_bindings);
2382 /* Unwind type-value slots back to top level. */
2383 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2384 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2386 s->prev = scope_chain;
2387 s->old_bindings = old_bindings;
2389 s->need_pop_function_context = need_pop;
2390 s->function_decl = current_function_decl;
2391 s->last_parms = last_function_parms;
2394 current_function_decl = NULL_TREE;
2395 VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2396 current_lang_name = lang_name_cplusplus;
2397 current_namespace = global_namespace;
2401 push_to_top_level ()
2403 maybe_push_to_top_level (0);
2407 pop_from_top_level ()
2409 struct saved_scope *s = scope_chain;
2412 /* Clear out class-level bindings cache. */
2413 if (previous_class_type)
2414 invalidate_class_lookup_cache ();
2416 current_lang_base = 0;
2418 scope_chain = s->prev;
2419 for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2421 tree id = TREE_VEC_ELT (t, 0);
2423 SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2424 IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2425 IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2428 /* If we were in the middle of compiling a function, restore our
2430 if (s->need_pop_function_context)
2431 pop_function_context_from (NULL_TREE);
2432 current_function_decl = s->function_decl;
2433 last_function_parms = s->last_parms;
2436 /* Push a definition of struct, union or enum tag "name".
2437 into binding_level "b". "type" should be the type node,
2438 We assume that the tag "name" is not already defined.
2440 Note that the definition may really be just a forward reference.
2441 In that case, the TYPE_SIZE will be a NULL_TREE.
2443 C++ gratuitously puts all these tags in the name space. */
2445 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2446 record the shadowed value for this binding contour. TYPE is
2447 the type that ID maps to. */
2450 set_identifier_type_value_with_scope (id, type, b)
2453 struct cp_binding_level *b;
2455 if (!b->namespace_p)
2457 /* Shadow the marker, not the real thing, so that the marker
2458 gets restored later. */
2459 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2461 = tree_cons (id, old_type_value, b->type_shadowed);
2465 tree binding = binding_for_name (id, current_namespace);
2466 BINDING_TYPE (binding) = type;
2467 /* Store marker instead of real type. */
2468 type = global_type_node;
2470 SET_IDENTIFIER_TYPE_VALUE (id, type);
2473 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2476 set_identifier_type_value (id, type)
2480 set_identifier_type_value_with_scope (id, type, current_binding_level);
2483 /* Return the type associated with id. */
2486 identifier_type_value (id)
2489 /* There is no type with that name, anywhere. */
2490 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2492 /* This is not the type marker, but the real thing. */
2493 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2494 return REAL_IDENTIFIER_TYPE_VALUE (id);
2495 /* Have to search for it. It must be on the global level, now.
2496 Ask lookup_name not to return non-types. */
2497 id = lookup_name_real (id, 2, 1, 0);
2499 return TREE_TYPE (id);
2503 /* Pop off extraneous binding levels left over due to syntax errors.
2505 We don't pop past namespaces, as they might be valid. */
2510 #ifdef DEBUG_BINDING_LEVELS
2511 fprintf (stderr, "XXX entering pop_everything ()\n");
2513 while (!toplevel_bindings_p ())
2515 if (current_binding_level->parm_flag == 2)
2516 pop_nested_class ();
2520 #ifdef DEBUG_BINDING_LEVELS
2521 fprintf (stderr, "XXX leaving pop_everything ()\n");
2525 /* The type TYPE is being declared. If it is a class template, or a
2526 specialization of a class template, do any processing required and
2527 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2528 being declared a friend. B is the binding level at which this TYPE
2531 Returns the TYPE_DECL for TYPE, which may have been altered by this
2535 maybe_process_template_type_declaration (type, globalize, b)
2538 struct cp_binding_level* b;
2540 tree decl = TYPE_NAME (type);
2542 if (processing_template_parmlist)
2543 /* You can't declare a new template type in a template parameter
2544 list. But, you can declare a non-template type:
2546 template <class A*> struct S;
2548 is a forward-declaration of `A'. */
2552 maybe_check_template_type (type);
2554 my_friendly_assert (IS_AGGR_TYPE (type)
2555 || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2558 if (processing_template_decl)
2560 /* This may change after the call to
2561 push_template_decl_real, but we want the original value. */
2562 tree name = DECL_NAME (decl);
2564 decl = push_template_decl_real (decl, globalize);
2565 /* If the current binding level is the binding level for the
2566 template parameters (see the comment in
2567 begin_template_parm_list) and the enclosing level is a class
2568 scope, and we're not looking at a friend, push the
2569 declaration of the member class into the class scope. In the
2570 friend case, push_template_decl will already have put the
2571 friend into global scope, if appropriate. */
2572 if (TREE_CODE (type) != ENUMERAL_TYPE
2573 && !globalize && b->template_parms_p
2574 && b->level_chain->parm_flag == 2)
2576 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2577 /* Put this tag on the list of tags for the class, since
2578 that won't happen below because B is not the class
2579 binding level, but is instead the pseudo-global level. */
2580 b->level_chain->tags =
2581 tree_cons (name, type, b->level_chain->tags);
2582 if (!COMPLETE_TYPE_P (current_class_type))
2583 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2591 /* In C++, you don't have to write `struct S' to refer to `S'; you
2592 can just use `S'. We accomplish this by creating a TYPE_DECL as
2593 if the user had written `typedef struct S S'. Create and return
2594 the TYPE_DECL for TYPE. */
2597 create_implicit_typedef (name, type)
2603 decl = build_decl (TYPE_DECL, name, type);
2604 DECL_ARTIFICIAL (decl) = 1;
2605 /* There are other implicit type declarations, like the one *within*
2606 a class that allows you to write `S::S'. We must distinguish
2608 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2609 TYPE_NAME (type) = decl;
2614 /* Remember a local name for name-mangling purposes. */
2617 push_local_name (decl)
2624 VARRAY_TREE_INIT (local_names, 8, "local_names");
2626 name = DECL_NAME (decl);
2628 nelts = VARRAY_ACTIVE_SIZE (local_names);
2629 for (i = 0; i < nelts; i++)
2631 t = VARRAY_TREE (local_names, i);
2632 if (DECL_NAME (t) == name)
2634 if (!DECL_LANG_SPECIFIC (decl))
2635 retrofit_lang_decl (decl);
2636 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
2637 if (DECL_LANG_SPECIFIC (t))
2638 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2640 DECL_DISCRIMINATOR (decl) = 1;
2642 VARRAY_TREE (local_names, i) = decl;
2647 VARRAY_PUSH_TREE (local_names, decl);
2650 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2651 Normally put it into the inner-most non-tag-transparent scope,
2652 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2653 The latter is needed for implicit declarations. */
2656 pushtag (name, type, globalize)
2660 register struct cp_binding_level *b;
2662 b = current_binding_level;
2663 while (b->tag_transparent
2664 || (b->parm_flag == 2
2666 /* We may be defining a new type in the initializer
2667 of a static member variable. We allow this when
2668 not pedantic, and it is particularly useful for
2669 type punning via an anonymous union. */
2670 || COMPLETE_TYPE_P (b->this_class))))
2673 b->tags = tree_cons (name, type, b->tags);
2677 /* Do C++ gratuitous typedefing. */
2678 if (IDENTIFIER_TYPE_VALUE (name) != type)
2680 register tree d = NULL_TREE;
2682 tree context = TYPE_CONTEXT (type);
2686 tree cs = current_scope ();
2690 else if (cs != NULL_TREE && TYPE_P (cs))
2691 /* When declaring a friend class of a local class, we want
2692 to inject the newly named class into the scope
2693 containing the local class, not the namespace scope. */
2694 context = decl_function_context (get_type_decl (cs));
2697 context = current_namespace;
2699 if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2700 || b->parm_flag == 2)
2703 if (current_lang_name == lang_name_java)
2704 TYPE_FOR_JAVA (type) = 1;
2706 d = create_implicit_typedef (name, type);
2707 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2709 set_identifier_type_value_with_scope (name, type, b);
2711 d = maybe_process_template_type_declaration (type,
2714 if (b->parm_flag == 2)
2716 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2717 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2718 class. But if it's a member template class, we
2719 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2721 finish_member_declaration (d);
2723 pushdecl_class_level (d);
2726 d = pushdecl_with_scope (d, b);
2728 /* FIXME what if it gets a name from typedef? */
2729 if (ANON_AGGRNAME_P (name))
2730 DECL_IGNORED_P (d) = 1;
2732 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2734 /* If this is a local class, keep track of it. We need this
2735 information for name-mangling, and so that it is possible to find
2736 all function definitions in a translation unit in a convenient
2737 way. (It's otherwise tricky to find a member function definition
2738 it's only pointed to from within a local class.) */
2739 if (TYPE_CONTEXT (type)
2740 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2741 && !processing_template_decl)
2742 VARRAY_PUSH_TREE (local_classes, type);
2744 if (b->parm_flag == 2)
2746 if (!COMPLETE_TYPE_P (current_class_type))
2747 CLASSTYPE_TAGS (current_class_type) = b->tags;
2751 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2752 /* Use the canonical TYPE_DECL for this node. */
2753 TYPE_STUB_DECL (type) = TYPE_NAME (type);
2756 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2757 will be the tagged type we just added to the current
2758 binding level. This fake NULL-named TYPE_DECL node helps
2759 dwarfout.c to know when it needs to output a
2760 representation of a tagged type, and it also gives us a
2761 convenient place to record the "scope start" address for
2764 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2765 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2769 /* Counter used to create anonymous type names. */
2771 static int anon_cnt = 0;
2773 /* Return an IDENTIFIER which can be used as a name for
2774 anonymous structs and unions. */
2781 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2782 return get_identifier (buf);
2785 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2786 This keeps dbxout from getting confused. */
2791 register struct cp_binding_level *b;
2793 static int last_cnt = 0;
2795 /* Fast out if no new anon names were declared. */
2796 if (last_cnt == anon_cnt)
2799 b = current_binding_level;
2800 while (b->tag_transparent)
2805 /* A NULL purpose means we have already processed all tags
2806 from here to the end of the list. */
2807 if (TREE_PURPOSE (tags) == NULL_TREE)
2809 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2810 TREE_PURPOSE (tags) = NULL_TREE;
2811 tags = TREE_CHAIN (tags);
2813 last_cnt = anon_cnt;
2816 /* Subroutine of duplicate_decls: return truthvalue of whether
2817 or not types of these decls match.
2819 For C++, we must compare the parameter list so that `int' can match
2820 `int&' in a parameter position, but `int&' is not confused with
2824 decls_match (newdecl, olddecl)
2825 tree newdecl, olddecl;
2829 if (newdecl == olddecl)
2832 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2833 /* If the two DECLs are not even the same kind of thing, we're not
2834 interested in their types. */
2837 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2839 tree f1 = TREE_TYPE (newdecl);
2840 tree f2 = TREE_TYPE (olddecl);
2841 tree p1 = TYPE_ARG_TYPES (f1);
2842 tree p2 = TYPE_ARG_TYPES (f2);
2844 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2845 && ! (DECL_EXTERN_C_P (newdecl)
2846 && DECL_EXTERN_C_P (olddecl)))
2849 if (TREE_CODE (f1) != TREE_CODE (f2))
2852 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2854 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2855 && (DECL_BUILT_IN (olddecl)
2856 #ifndef NO_IMPLICIT_EXTERN_C
2857 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2858 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2862 types_match = self_promoting_args_p (p1);
2863 if (p1 == void_list_node)
2864 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2866 #ifndef NO_IMPLICIT_EXTERN_C
2867 else if (p1 == NULL_TREE
2868 && (DECL_EXTERN_C_P (olddecl)
2869 && DECL_IN_SYSTEM_HEADER (olddecl)
2870 && !DECL_CLASS_SCOPE_P (olddecl))
2871 && (DECL_EXTERN_C_P (newdecl)
2872 && DECL_IN_SYSTEM_HEADER (newdecl)
2873 && !DECL_CLASS_SCOPE_P (newdecl)))
2875 types_match = self_promoting_args_p (p2);
2876 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2880 types_match = compparms (p1, p2);
2885 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2887 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2888 DECL_TEMPLATE_PARMS (olddecl)))
2891 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2892 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2895 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2898 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2899 DECL_TEMPLATE_RESULT (newdecl));
2903 if (TREE_TYPE (newdecl) == error_mark_node)
2904 types_match = TREE_TYPE (olddecl) == error_mark_node;
2905 else if (TREE_TYPE (olddecl) == NULL_TREE)
2906 types_match = TREE_TYPE (newdecl) == NULL_TREE;
2907 else if (TREE_TYPE (newdecl) == NULL_TREE)
2910 types_match = comptypes (TREE_TYPE (newdecl),
2911 TREE_TYPE (olddecl),
2912 COMPARE_REDECLARATION);
2918 /* If NEWDECL is `static' and an `extern' was seen previously,
2919 warn about it. OLDDECL is the previous declaration.
2921 Note that this does not apply to the C++ case of declaring
2922 a variable `extern const' and then later `const'.
2924 Don't complain about built-in functions, since they are beyond
2925 the user's control. */
2928 warn_extern_redeclared_static (newdecl, olddecl)
2929 tree newdecl, olddecl;
2931 static const char *const explicit_extern_static_warning
2932 = "`%D' was declared `extern' and later `static'";
2933 static const char *const implicit_extern_static_warning
2934 = "`%D' was declared implicitly `extern' and later `static'";
2938 if (TREE_CODE (newdecl) == TYPE_DECL
2939 || TREE_CODE (newdecl) == TEMPLATE_DECL
2940 || TREE_CODE (newdecl) == CONST_DECL)
2943 /* Don't get confused by static member functions; that's a different
2945 if (TREE_CODE (newdecl) == FUNCTION_DECL
2946 && DECL_STATIC_FUNCTION_P (newdecl))
2949 /* If the old declaration was `static', or the new one isn't, then
2950 then everything is OK. */
2951 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2954 /* It's OK to declare a builtin function as `static'. */
2955 if (TREE_CODE (olddecl) == FUNCTION_DECL
2956 && DECL_ARTIFICIAL (olddecl))
2959 name = DECL_ASSEMBLER_NAME (newdecl);
2960 pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2961 ? implicit_extern_static_warning
2962 : explicit_extern_static_warning, newdecl);
2963 cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2966 /* Handle when a new declaration NEWDECL has the same name as an old
2967 one OLDDECL in the same binding contour. Prints an error message
2970 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2971 Otherwise, return 0. */
2974 duplicate_decls (newdecl, olddecl)
2975 tree newdecl, olddecl;
2977 unsigned olddecl_uid = DECL_UID (olddecl);
2978 int olddecl_friend = 0, types_match = 0;
2979 int new_defines_function = 0;
2981 if (newdecl == olddecl)
2984 types_match = decls_match (newdecl, olddecl);
2986 /* If either the type of the new decl or the type of the old decl is an
2987 error_mark_node, then that implies that we have already issued an
2988 error (earlier) for some bogus type specification, and in that case,
2989 it is rather pointless to harass the user with yet more error message
2990 about the same declaration, so just pretend the types match here. */
2991 if (TREE_TYPE (newdecl) == error_mark_node
2992 || TREE_TYPE (olddecl) == error_mark_node)
2995 if (DECL_P (olddecl)
2996 && TREE_CODE (newdecl) == FUNCTION_DECL
2997 && TREE_CODE (olddecl) == FUNCTION_DECL
2998 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
3000 if (DECL_DECLARED_INLINE_P (newdecl)
3001 && DECL_UNINLINABLE (newdecl)
3002 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3003 /* Already warned elsewhere. */;
3004 else if (DECL_DECLARED_INLINE_P (olddecl)
3005 && DECL_UNINLINABLE (olddecl)
3006 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3007 /* Already warned. */;
3008 else if (DECL_DECLARED_INLINE_P (newdecl)
3009 && DECL_UNINLINABLE (olddecl)
3010 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3012 warning_with_decl (newdecl,
3013 "function `%s' redeclared as inline");
3014 warning_with_decl (olddecl,
3015 "previous declaration of function `%s' with attribute noinline");
3017 else if (DECL_DECLARED_INLINE_P (olddecl)
3018 && DECL_UNINLINABLE (newdecl)
3019 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3021 warning_with_decl (newdecl,
3022 "function `%s' redeclared with attribute noinline");
3023 warning_with_decl (olddecl,
3024 "previous declaration of function `%s' was inline");
3028 /* Check for redeclaration and other discrepancies. */
3029 if (TREE_CODE (olddecl) == FUNCTION_DECL
3030 && DECL_ARTIFICIAL (olddecl))
3032 if (TREE_CODE (newdecl) != FUNCTION_DECL)
3034 /* Avoid warnings redeclaring anticipated built-ins. */
3035 if (DECL_ANTICIPATED (olddecl))
3038 /* If you declare a built-in or predefined function name as static,
3039 the old definition is overridden, but optionally warn this was a
3040 bad choice of name. */
3041 if (! TREE_PUBLIC (newdecl))
3044 warning ("shadowing %s function `%#D'",
3045 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3047 /* Discard the old built-in function. */
3050 /* If the built-in is not ansi, then programs can override
3051 it even globally without an error. */
3052 else if (! DECL_BUILT_IN (olddecl))
3053 warning ("library function `%#D' redeclared as non-function `%#D'",
3057 error ("declaration of `%#D'", newdecl);
3058 error ("conflicts with built-in declaration `%#D'",
3063 else if (!types_match)
3065 /* Avoid warnings redeclaring anticipated built-ins. */
3066 if (DECL_ANTICIPATED (olddecl))
3067 ; /* Do nothing yet. */
3068 else if ((DECL_EXTERN_C_P (newdecl)
3069 && DECL_EXTERN_C_P (olddecl))
3070 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3071 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3073 /* A near match; override the builtin. */
3075 if (TREE_PUBLIC (newdecl))
3077 warning ("new declaration `%#D'", newdecl);
3078 warning ("ambiguates built-in declaration `%#D'",
3081 else if (warn_shadow)
3082 warning ("shadowing %s function `%#D'",
3083 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3087 /* Discard the old built-in function. */
3090 /* Replace the old RTL to avoid problems with inlining. */
3091 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3094 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3096 /* If a builtin function is redeclared as `static', merge
3097 the declarations, but make the original one static. */
3098 DECL_THIS_STATIC (olddecl) = 1;
3099 TREE_PUBLIC (olddecl) = 0;
3101 /* Make the old declaration consistent with the new one so
3102 that all remnants of the builtin-ness of this function
3103 will be banished. */
3104 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3105 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3108 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3110 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3111 && TREE_CODE (newdecl) != TYPE_DECL
3112 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3113 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3114 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3115 && TREE_CODE (olddecl) != TYPE_DECL
3116 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3117 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3120 /* We do nothing special here, because C++ does such nasty
3121 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3122 get shadowed, and know that if we need to find a TYPE_DECL
3123 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3124 slot of the identifier. */
3128 if ((TREE_CODE (newdecl) == FUNCTION_DECL
3129 && DECL_FUNCTION_TEMPLATE_P (olddecl))
3130 || (TREE_CODE (olddecl) == FUNCTION_DECL
3131 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3134 error ("`%#D' redeclared as different kind of symbol", newdecl);
3135 if (TREE_CODE (olddecl) == TREE_LIST)
3136 olddecl = TREE_VALUE (olddecl);
3137 cp_error_at ("previous declaration of `%#D'", olddecl);
3139 /* New decl is completely inconsistent with the old one =>
3140 tell caller to replace the old one. */
3144 else if (!types_match)
3146 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3147 /* These are certainly not duplicate declarations; they're
3148 from different scopes. */
3151 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3153 /* The name of a class template may not be declared to refer to
3154 any other template, class, function, object, namespace, value,
3155 or type in the same scope. */
3156 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3157 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3159 error ("declaration of template `%#D'", newdecl);
3160 cp_error_at ("conflicts with previous declaration `%#D'",
3163 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3164 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3165 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3166 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3167 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3168 DECL_TEMPLATE_PARMS (olddecl)))
3170 error ("new declaration `%#D'", newdecl);
3171 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3175 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3177 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3179 error ("declaration of C function `%#D' conflicts with",
3181 cp_error_at ("previous declaration `%#D' here", olddecl);
3183 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3184 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3186 error ("new declaration `%#D'", newdecl);
3187 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3193 /* Already complained about this, so don't do so again. */
3194 else if (current_class_type == NULL_TREE
3195 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3197 error ("conflicting types for `%#D'", newdecl);
3198 cp_error_at ("previous declaration as `%#D'", olddecl);
3201 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3202 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3203 && (!DECL_TEMPLATE_INFO (newdecl)
3204 || (DECL_TI_TEMPLATE (newdecl)
3205 != DECL_TI_TEMPLATE (olddecl))))
3206 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3207 && (!DECL_TEMPLATE_INFO (olddecl)
3208 || (DECL_TI_TEMPLATE (olddecl)
3209 != DECL_TI_TEMPLATE (newdecl))))))
3210 /* It's OK to have a template specialization and a non-template
3211 with the same type, or to have specializations of two
3212 different templates with the same type. Note that if one is a
3213 specialization, and the other is an instantiation of the same
3214 template, that we do not exit at this point. That situation
3215 can occur if we instantiate a template class, and then
3216 specialize one of its methods. This situation is valid, but
3217 the declarations must be merged in the usual way. */
3219 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3220 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3221 && !DECL_USE_TEMPLATE (newdecl))
3222 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3223 && !DECL_USE_TEMPLATE (olddecl))))
3224 /* One of the declarations is a template instantiation, and the
3225 other is not a template at all. That's OK. */
3227 else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3228 && DECL_NAMESPACE_ALIAS (newdecl)
3229 && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3230 /* Redeclaration of namespace alias, ignore it. */
3234 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3237 error (errmsg, newdecl);
3238 if (DECL_NAME (olddecl) != NULL_TREE)
3239 cp_error_at ((DECL_INITIAL (olddecl)
3240 && namespace_bindings_p ())
3241 ? "`%#D' previously defined here"
3242 : "`%#D' previously declared here", olddecl);
3245 else if (TREE_CODE (olddecl) == FUNCTION_DECL
3246 && DECL_INITIAL (olddecl) != NULL_TREE
3247 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3248 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3250 /* Prototype decl follows defn w/o prototype. */
3251 cp_warning_at ("prototype for `%#D'", newdecl);
3252 cp_warning_at ("follows non-prototype definition here", olddecl);
3254 else if (TREE_CODE (olddecl) == FUNCTION_DECL
3255 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3257 /* extern "C" int foo ();
3258 int foo () { bar (); }
3260 if (current_lang_depth () == 0)
3261 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3264 cp_error_at ("previous declaration of `%#D' with %L linkage",
3265 olddecl, DECL_LANGUAGE (olddecl));
3266 error ("conflicts with new declaration with %L linkage",
3267 DECL_LANGUAGE (newdecl));
3271 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3273 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3275 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3276 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3279 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3280 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3282 for (; t1 && t1 != void_list_node;
3283 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3284 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3286 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3289 pedwarn ("default argument given for parameter %d of `%#D'",
3291 cp_pedwarn_at ("after previous specification in `%#D'",
3296 error ("default argument given for parameter %d of `%#D'",
3298 cp_error_at ("after previous specification in `%#D'",
3303 if (DECL_DECLARED_INLINE_P (newdecl)
3304 && ! DECL_DECLARED_INLINE_P (olddecl)
3305 && TREE_ADDRESSABLE (olddecl) && warn_inline)
3307 warning ("`%#D' was used before it was declared inline",
3309 cp_warning_at ("previous non-inline declaration here",
3315 /* Do not merge an implicit typedef with an explicit one. In:
3319 typedef class A A __attribute__ ((foo));
3321 the attribute should apply only to the typedef. */
3322 if (TREE_CODE (olddecl) == TYPE_DECL
3323 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
3324 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
3327 /* If new decl is `static' and an `extern' was seen previously,
3329 warn_extern_redeclared_static (newdecl, olddecl);
3331 /* We have committed to returning 1 at this point. */
3332 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3334 /* Now that functions must hold information normally held
3335 by field decls, there is extra work to do so that
3336 declaration information does not get destroyed during
3338 if (DECL_VINDEX (olddecl))
3339 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3340 if (DECL_VIRTUAL_CONTEXT (olddecl))
3341 DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3342 if (DECL_CONTEXT (olddecl))
3343 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3344 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3345 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3346 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3347 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3348 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3349 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3350 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3351 SET_OVERLOADED_OPERATOR_CODE
3352 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3353 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3355 /* Optionally warn about more than one declaration for the same
3356 name, but don't warn about a function declaration followed by a
3358 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3359 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3360 /* Don't warn about extern decl followed by definition. */
3361 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3362 /* Don't warn about friends, let add_friend take care of it. */
3363 && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3365 warning ("redundant redeclaration of `%D' in same scope", newdecl);
3366 cp_warning_at ("previous declaration of `%D'", olddecl);
3370 /* Deal with C++: must preserve virtual function table size. */
3371 if (TREE_CODE (olddecl) == TYPE_DECL)
3373 register tree newtype = TREE_TYPE (newdecl);
3374 register tree oldtype = TREE_TYPE (olddecl);
3376 if (newtype != error_mark_node && oldtype != error_mark_node
3377 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3379 CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3380 CLASSTYPE_FRIEND_CLASSES (newtype)
3381 = CLASSTYPE_FRIEND_CLASSES (oldtype);
3384 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3387 /* Copy all the DECL_... slots specified in the new decl
3388 except for any that we copy here from the old type. */
3389 DECL_ATTRIBUTES (newdecl)
3390 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3391 decl_attributes (&newdecl, DECL_ATTRIBUTES (newdecl), 0);
3393 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3395 TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3396 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3397 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3398 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3400 /* If the new declaration is a definition, update the file and
3401 line information on the declaration. */
3402 if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3403 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3405 DECL_SOURCE_LINE (olddecl)
3406 = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3407 = DECL_SOURCE_LINE (newdecl);
3408 DECL_SOURCE_FILE (olddecl)
3409 = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3410 = DECL_SOURCE_FILE (newdecl);
3418 /* Automatically handles default parameters. */
3419 tree oldtype = TREE_TYPE (olddecl);
3422 /* Merge the data types specified in the two decls. */
3423 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3425 /* If merge_types produces a non-typedef type, just use the old type. */
3426 if (TREE_CODE (newdecl) == TYPE_DECL
3427 && newtype == DECL_ORIGINAL_TYPE (newdecl))
3430 if (TREE_CODE (newdecl) == VAR_DECL)
3431 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3432 /* Do this after calling `merge_types' so that default
3433 parameters don't confuse us. */
3434 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3435 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3436 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3438 TREE_TYPE (newdecl) = build_exception_variant (newtype,
3439 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3440 TREE_TYPE (olddecl) = build_exception_variant (newtype,
3441 TYPE_RAISES_EXCEPTIONS (oldtype));
3443 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3444 && DECL_SOURCE_LINE (olddecl) != 0
3446 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3447 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3449 error ("declaration of `%F' throws different exceptions",
3451 cp_error_at ("than previous declaration `%F'", olddecl);
3454 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3456 /* Lay the type out, unless already done. */
3457 if (! same_type_p (newtype, oldtype)
3458 && TREE_TYPE (newdecl) != error_mark_node
3459 && !(processing_template_decl && uses_template_parms (newdecl)))
3460 layout_type (TREE_TYPE (newdecl));
3462 if ((TREE_CODE (newdecl) == VAR_DECL
3463 || TREE_CODE (newdecl) == PARM_DECL
3464 || TREE_CODE (newdecl) == RESULT_DECL
3465 || TREE_CODE (newdecl) == FIELD_DECL
3466 || TREE_CODE (newdecl) == TYPE_DECL)
3467 && !(processing_template_decl && uses_template_parms (newdecl)))
3468 layout_decl (newdecl, 0);
3470 /* Merge the type qualifiers. */
3471 if (TREE_READONLY (newdecl))
3472 TREE_READONLY (olddecl) = 1;
3473 if (TREE_THIS_VOLATILE (newdecl))
3474 TREE_THIS_VOLATILE (olddecl) = 1;
3476 /* Merge the initialization information. */
3477 if (DECL_INITIAL (newdecl) == NULL_TREE
3478 && DECL_INITIAL (olddecl) != NULL_TREE)
3480 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3481 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3482 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3483 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3484 && DECL_LANG_SPECIFIC (newdecl)
3485 && DECL_LANG_SPECIFIC (olddecl))
3486 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3489 /* Merge the section attribute.
3490 We want to issue an error if the sections conflict but that must be
3491 done later in decl_attributes since we are called before attributes
3493 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3494 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3496 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3498 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3499 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3500 DECL_NO_LIMIT_STACK (newdecl)
3501 |= DECL_NO_LIMIT_STACK (olddecl);
3502 /* Keep the old RTL. */
3503 COPY_DECL_RTL (olddecl, newdecl);
3505 else if (TREE_CODE (newdecl) == VAR_DECL
3506 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
3508 /* Keep the old RTL. We cannot keep the old RTL if the old
3509 declaration was for an incomplete object and the new
3510 declaration is not since many attributes of the RTL will
3512 COPY_DECL_RTL (olddecl, newdecl);
3515 /* If cannot merge, then use the new type and qualifiers,
3516 and don't preserve the old rtl. */
3519 /* Clean out any memory we had of the old declaration. */
3520 tree oldstatic = value_member (olddecl, static_aggregates);
3522 TREE_VALUE (oldstatic) = error_mark_node;
3524 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3525 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3526 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3527 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3530 /* Merge the storage class information. */
3531 merge_weak (newdecl, olddecl);
3533 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3534 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3535 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3536 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3537 if (! DECL_EXTERNAL (olddecl))
3538 DECL_EXTERNAL (newdecl) = 0;
3540 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3542 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3543 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3544 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3545 DECL_TEMPLATE_INSTANTIATED (newdecl)
3546 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3547 /* Don't really know how much of the language-specific
3548 values we should copy from old to new. */
3549 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3550 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
3551 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
3552 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3553 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3554 DECL_INITIALIZED_IN_CLASS_P (newdecl)
3555 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3556 olddecl_friend = DECL_FRIEND_P (olddecl);
3558 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3559 if (TREE_CODE (newdecl) == FUNCTION_DECL
3560 || DECL_FUNCTION_TEMPLATE_P (newdecl))
3561 DECL_BEFRIENDING_CLASSES (newdecl)
3562 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3563 DECL_BEFRIENDING_CLASSES (olddecl));
3566 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3568 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3569 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3571 /* If newdecl is not a specialization, then it is not a
3572 template-related function at all. And that means that we
3573 shoud have exited above, returning 0. */
3574 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3577 if (TREE_USED (olddecl))
3578 /* From [temp.expl.spec]:
3580 If a template, a member template or the member of a class
3581 template is explicitly specialized then that
3582 specialization shall be declared before the first use of
3583 that specialization that would cause an implicit
3584 instantiation to take place, in every translation unit in
3585 which such a use occurs. */
3586 error ("explicit specialization of %D after first use",
3589 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3591 /* [temp.expl.spec/14] We don't inline explicit specialization
3592 just because the primary template says so. */
3596 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3597 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3599 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3601 /* If either decl says `inline', this fn is inline, unless
3602 its definition was passed already. */
3603 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3604 DECL_INLINE (olddecl) = 1;
3605 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3607 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3608 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3611 /* Preserve abstractness on cloned [cd]tors. */
3612 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3616 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3617 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3618 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3620 if (! types_match || new_defines_function)
3622 /* These need to be copied so that the names are available.
3623 Note that if the types do match, we'll preserve inline
3624 info and other bits, but if not, we won't. */
3625 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3626 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3628 if (new_defines_function)
3629 /* If defining a function declared with other language
3630 linkage, use the previously declared language linkage. */
3631 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3632 else if (types_match)
3634 /* If redeclaring a builtin function, and not a definition,
3635 it stays built in. */
3636 if (DECL_BUILT_IN (olddecl))
3638 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3639 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3640 /* If we're keeping the built-in definition, keep the rtl,
3641 regardless of declaration matches. */
3642 SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3645 DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3647 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3648 /* Don't clear out the arguments if we're redefining a function. */
3649 if (DECL_ARGUMENTS (olddecl))
3650 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3653 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3654 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3656 /* Now preserve various other info from the definition. */
3657 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3658 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3659 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3660 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3662 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3666 function_size = sizeof (struct tree_decl);
3668 memcpy ((char *) olddecl + sizeof (struct tree_common),
3669 (char *) newdecl + sizeof (struct tree_common),
3670 function_size - sizeof (struct tree_common));
3672 if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3674 /* If newdecl is a template instantiation, it is possible that
3675 the following sequence of events has occurred:
3677 o A friend function was declared in a class template. The
3678 class template was instantiated.
3680 o The instantiation of the friend declaration was
3681 recorded on the instantiation list, and is newdecl.
3683 o Later, however, instantiate_class_template called pushdecl
3684 on the newdecl to perform name injection. But, pushdecl in
3685 turn called duplicate_decls when it discovered that another
3686 declaration of a global function with the same name already
3689 o Here, in duplicate_decls, we decided to clobber newdecl.
3691 If we're going to do that, we'd better make sure that
3692 olddecl, and not newdecl, is on the list of
3693 instantiations so that if we try to do the instantiation
3694 again we won't get the clobbered declaration. */
3696 tree tmpl = DECL_TI_TEMPLATE (newdecl);
3697 tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3699 for (; decls; decls = TREE_CHAIN (decls))
3700 if (TREE_VALUE (decls) == newdecl)
3701 TREE_VALUE (decls) = olddecl;
3706 memcpy ((char *) olddecl + sizeof (struct tree_common),
3707 (char *) newdecl + sizeof (struct tree_common),
3708 sizeof (struct tree_decl) - sizeof (struct tree_common)
3709 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
3712 DECL_UID (olddecl) = olddecl_uid;
3714 DECL_FRIEND_P (olddecl) = 1;
3716 /* NEWDECL contains the merged attribute lists.
3717 Update OLDDECL to be the same. */
3718 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3723 /* Record a decl-node X as belonging to the current lexical scope.
3724 Check for errors (such as an incompatible declaration for the same
3725 name already seen in the same scope).
3727 Returns either X or an old decl for the same name.
3728 If an old decl is returned, it may have been smashed
3729 to agree with what X says. */
3737 int need_new_binding;
3739 /* We shouldn't be calling pushdecl when we're generating RTL for a
3740 function that we already did semantic analysis on previously. */
3741 my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3744 need_new_binding = 1;
3746 if (DECL_TEMPLATE_PARM_P (x))
3747 /* Template parameters have no context; they are not X::T even
3748 when declared within a class or namespace. */
3752 if (current_function_decl && x != current_function_decl
3753 /* A local declaration for a function doesn't constitute
3755 && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3756 /* A local declaration for an `extern' variable is in the
3757 scope of the current namespace, not the current
3759 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3760 && !DECL_CONTEXT (x))
3761 DECL_CONTEXT (x) = current_function_decl;
3763 /* If this is the declaration for a namespace-scope function,
3764 but the declaration itself is in a local scope, mark the
3766 if (TREE_CODE (x) == FUNCTION_DECL
3767 && DECL_NAMESPACE_SCOPE_P (x)
3768 && current_function_decl
3769 && x != current_function_decl)
3770 DECL_LOCAL_FUNCTION_P (x) = 1;
3773 name = DECL_NAME (x);
3776 int different_binding_level = 0;
3778 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3779 name = TREE_OPERAND (name, 0);
3781 /* In case this decl was explicitly namespace-qualified, look it
3782 up in its namespace context. */
3783 if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3784 && namespace_bindings_p ())
3785 t = namespace_binding (name, DECL_CONTEXT (x));
3787 t = lookup_name_current_level (name);
3789 /* [basic.link] If there is a visible declaration of an entity
3790 with linkage having the same name and type, ignoring entities
3791 declared outside the innermost enclosing namespace scope, the
3792 block scope declaration declares that same entity and
3793 receives the linkage of the previous declaration. */
3794 if (! t && current_function_decl && x != current_function_decl
3795 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3796 && DECL_EXTERNAL (x))
3798 /* Look in block scope. */
3799 t = IDENTIFIER_VALUE (name);
3800 /* Or in the innermost namespace. */
3802 t = namespace_binding (name, DECL_CONTEXT (x));
3803 /* Does it have linkage? Note that if this isn't a DECL, it's an
3804 OVERLOAD, which is OK. */
3805 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3808 different_binding_level = 1;
3811 /* If we are declaring a function, and the result of name-lookup
3812 was an OVERLOAD, look for an overloaded instance that is
3813 actually the same as the function we are declaring. (If
3814 there is one, we have to merge our declaration with the
3815 previous declaration.) */
3816 if (t && TREE_CODE (t) == OVERLOAD)
3820 if (TREE_CODE (x) == FUNCTION_DECL)
3821 for (match = t; match; match = OVL_NEXT (match))
3823 if (decls_match (OVL_CURRENT (match), x))
3827 /* Just choose one. */
3831 t = OVL_CURRENT (match);
3836 if (t == error_mark_node)
3838 /* error_mark_node is 0 for a while during initialization! */
3840 cp_error_at ("`%#D' used prior to declaration", x);
3842 else if (t != NULL_TREE)
3844 if (different_binding_level)
3846 if (decls_match (x, t))
3847 /* The standard only says that the local extern
3848 inherits linkage from the previous decl; in
3849 particular, default args are not shared. It would
3850 be nice to propagate inlining info, though. FIXME. */
3851 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3853 else if (TREE_CODE (t) == PARM_DECL)
3855 if (DECL_CONTEXT (t) == NULL_TREE)
3856 /* This is probaby caused by too many errors, but calling
3857 abort will say that if errors have occurred. */
3860 /* Check for duplicate params. */
3861 if (duplicate_decls (x, t))
3864 else if ((DECL_EXTERN_C_FUNCTION_P (x)
3865 || DECL_FUNCTION_TEMPLATE_P (x))
3866 && is_overloaded_fn (t))
3867 /* Don't do anything just yet. */;
3868 else if (t == wchar_decl_node)
3870 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3871 pedwarn ("redeclaration of `wchar_t' as `%T'",
3874 /* Throw away the redeclaration. */
3877 else if (TREE_CODE (t) != TREE_CODE (x))
3879 if (duplicate_decls (x, t))
3882 else if (duplicate_decls (x, t))
3884 if (TREE_CODE (t) == TYPE_DECL)
3885 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3886 else if (TREE_CODE (t) == FUNCTION_DECL)
3887 check_default_args (t);
3891 else if (DECL_MAIN_P (x))
3893 /* A redeclaration of main, but not a duplicate of the
3898 This function shall not be overloaded. */
3899 cp_error_at ("invalid redeclaration of `%D'", t);
3900 error ("as `%D'", x);
3901 /* We don't try to push this declaration since that
3907 check_template_shadow (x);
3909 /* If this is a function conjured up by the backend, massage it
3910 so it looks friendly. */
3911 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3913 retrofit_lang_decl (x);
3914 SET_DECL_LANGUAGE (x, lang_c);
3917 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3919 t = push_overloaded_decl (x, PUSH_LOCAL);
3922 if (!namespace_bindings_p ())
3923 /* We do not need to create a binding for this name;
3924 push_overloaded_decl will have already done so if
3926 need_new_binding = 0;
3928 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3930 t = push_overloaded_decl (x, PUSH_GLOBAL);
3932 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3936 /* If declaring a type as a typedef, copy the type (unless we're
3937 at line 0), and install this TYPE_DECL as the new type's typedef
3938 name. See the extensive comment in ../c-decl.c (pushdecl). */
3939 if (TREE_CODE (x) == TYPE_DECL)
3941 tree type = TREE_TYPE (x);
3942 if (DECL_SOURCE_LINE (x) == 0)
3944 if (TYPE_NAME (type) == 0)
3945 TYPE_NAME (type) = x;
3947 else if (type != error_mark_node && TYPE_NAME (type) != x
3948 /* We don't want to copy the type when all we're
3949 doing is making a TYPE_DECL for the purposes of
3951 && (!TYPE_NAME (type)
3952 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3954 DECL_ORIGINAL_TYPE (x) = type;
3955 type = build_type_copy (type);
3956 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3957 TYPE_NAME (type) = x;
3958 TREE_TYPE (x) = type;
3961 if (type != error_mark_node
3963 && TYPE_IDENTIFIER (type))
3964 set_identifier_type_value_with_scope (DECL_NAME (x), type,
3965 current_binding_level);
3969 /* Multiple external decls of the same identifier ought to match.
3971 We get warnings about inline functions where they are defined.
3972 We get warnings about other functions from push_overloaded_decl.
3974 Avoid duplicate warnings where they are used. */
3975 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3979 decl = IDENTIFIER_NAMESPACE_VALUE (name);
3980 if (decl && TREE_CODE (decl) == OVERLOAD)
3981 decl = OVL_FUNCTION (decl);
3983 if (decl && decl != error_mark_node
3984 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
3985 /* If different sort of thing, we already gave an error. */
3986 && TREE_CODE (decl) == TREE_CODE (x)
3987 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3989 pedwarn ("type mismatch with previous external decl", x);
3990 cp_pedwarn_at ("previous external decl of `%#D'", decl);
3994 /* This name is new in its binding level.
3995 Install the new declaration and return it. */
3996 if (namespace_bindings_p ())
3998 /* Install a global value. */
4000 /* If the first global decl has external linkage,
4001 warn if we later see static one. */
4002 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4003 TREE_PUBLIC (name) = 1;
4005 /* Bind the name for the entity. */
4006 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4008 && (TREE_CODE (x) == TYPE_DECL
4009 || TREE_CODE (x) == VAR_DECL
4010 || TREE_CODE (x) == NAMESPACE_DECL
4011 || TREE_CODE (x) == CONST_DECL
4012 || TREE_CODE (x) == TEMPLATE_DECL))
4013 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4015 /* Don't forget if the function was used via an implicit decl. */
4016 if (IDENTIFIER_IMPLICIT_DECL (name)
4017 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4020 /* Don't forget if its address was taken in that way. */
4021 if (IDENTIFIER_IMPLICIT_DECL (name)
4022 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4023 TREE_ADDRESSABLE (x) = 1;
4025 /* Warn about mismatches against previous implicit decl. */
4026 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4027 /* If this real decl matches the implicit, don't complain. */
4028 && ! (TREE_CODE (x) == FUNCTION_DECL
4029 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4031 ("`%D' was previously implicitly declared to return `int'", x);
4033 /* If new decl is `static' and an `extern' was seen previously,
4035 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4036 warn_extern_redeclared_static (x, t);
4040 /* Here to install a non-global value. */
4041 tree oldlocal = IDENTIFIER_VALUE (name);
4042 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4044 if (need_new_binding)
4046 push_local_binding (name, x, 0);
4047 /* Because push_local_binding will hook X on to the
4048 current_binding_level's name list, we don't want to
4049 do that again below. */
4050 need_new_binding = 0;
4053 /* If this is a TYPE_DECL, push it into the type value slot. */
4054 if (TREE_CODE (x) == TYPE_DECL)
4055 set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4056 current_binding_level);
4058 /* Clear out any TYPE_DECL shadowed by a namespace so that
4059 we won't think this is a type. The C struct hack doesn't
4060 go through namespaces. */
4061 if (TREE_CODE (x) == NAMESPACE_DECL)
4062 set_identifier_type_value_with_scope (name, NULL_TREE,
4063 current_binding_level);
4070 && TREE_CODE (oldlocal) == VAR_DECL
4071 && DECL_DEAD_FOR_LOCAL (oldlocal))
4072 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4074 if (oldlocal == NULL_TREE)
4075 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4078 /* If this is an extern function declaration, see if we
4079 have a global definition or declaration for the function. */
4080 if (oldlocal == NULL_TREE
4081 && DECL_EXTERNAL (x)
4082 && oldglobal != NULL_TREE
4083 && TREE_CODE (x) == FUNCTION_DECL
4084 && TREE_CODE (oldglobal) == FUNCTION_DECL)
4086 /* We have one. Their types must agree. */
4087 if (decls_match (x, oldglobal))
4091 warning ("extern declaration of `%#D' doesn't match", x);
4092 cp_warning_at ("global declaration `%#D'", oldglobal);
4095 /* If we have a local external declaration,
4096 and no file-scope declaration has yet been seen,
4097 then if we later have a file-scope decl it must not be static. */
4098 if (oldlocal == NULL_TREE
4099 && oldglobal == NULL_TREE
4100 && DECL_EXTERNAL (x)
4102 TREE_PUBLIC (name) = 1;
4104 /* Warn if shadowing an argument at the top level of the body. */
4105 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4106 /* Inline decls shadow nothing. */
4107 && !DECL_FROM_INLINE (x)
4108 && TREE_CODE (oldlocal) == PARM_DECL)
4112 /* Don't complain if it's from an enclosing function. */
4113 if (DECL_CONTEXT (oldlocal) == current_function_decl
4114 && TREE_CODE (x) != PARM_DECL)
4116 /* Go to where the parms should be and see if we find
4118 struct cp_binding_level *b = current_binding_level->level_chain;
4121 if (b->parm_flag == 1)
4123 error ("declaration of `%#D' shadows a parameter",
4129 if (warn_shadow && !err)
4130 shadow_warning ("a parameter", name, oldlocal);
4133 /* Maybe warn if shadowing something else. */
4134 else if (warn_shadow && !DECL_EXTERNAL (x)
4135 /* No shadow warnings for internally generated vars. */
4136 && ! DECL_ARTIFICIAL (x)
4137 /* No shadow warnings for vars made for inlining. */
4138 && ! DECL_FROM_INLINE (x))
4140 if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4141 && current_class_ptr
4142 && !TREE_STATIC (name))
4143 warning ("declaration of `%s' shadows a member of `this'",
4144 IDENTIFIER_POINTER (name));
4145 else if (oldlocal != NULL_TREE
4146 && TREE_CODE (oldlocal) == VAR_DECL)
4147 shadow_warning ("a previous local", name, oldlocal);
4148 else if (oldglobal != NULL_TREE
4149 && TREE_CODE (oldglobal) == VAR_DECL)
4150 /* XXX shadow warnings in outer-more namespaces */
4151 shadow_warning ("a global declaration", name, oldglobal);
4155 if (TREE_CODE (x) == FUNCTION_DECL)
4156 check_default_args (x);
4158 if (TREE_CODE (x) == VAR_DECL)
4159 maybe_register_incomplete_var (x);
4162 if (need_new_binding)
4163 add_decl_to_level (x,
4164 DECL_NAMESPACE_SCOPE_P (x)
4165 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4166 : current_binding_level);
4171 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4172 caller to set DECL_CONTEXT properly. */
4175 pushdecl_with_scope (x, level)
4177 struct cp_binding_level *level;
4179 register struct cp_binding_level *b;
4180 tree function_decl = current_function_decl;
4182 current_function_decl = NULL_TREE;
4183 if (level->parm_flag == 2)
4185 b = class_binding_level;
4186 class_binding_level = level;
4187 pushdecl_class_level (x);
4188 class_binding_level = b;
4192 b = current_binding_level;
4193 current_binding_level = level;
4195 current_binding_level = b;
4197 current_function_decl = function_decl;
4201 /* Like pushdecl, only it places X in the current namespace,
4205 pushdecl_namespace_level (x)
4208 register struct cp_binding_level *b = current_binding_level;
4211 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4213 /* Now, the type_shadowed stack may screw us. Munge it so it does
4215 if (TREE_CODE (x) == TYPE_DECL)
4217 tree name = DECL_NAME (x);
4219 tree *ptr = (tree *)0;
4220 for (; b != global_binding_level; b = b->level_chain)
4222 tree shadowed = b->type_shadowed;
4223 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4224 if (TREE_PURPOSE (shadowed) == name)
4226 ptr = &TREE_VALUE (shadowed);
4227 /* Can't break out of the loop here because sometimes
4228 a binding level will have duplicate bindings for
4229 PT names. It's gross, but I haven't time to fix it. */
4232 newval = TREE_TYPE (x);
4233 if (ptr == (tree *)0)
4235 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4236 up here if this is changed to an assertion. --KR */
4237 SET_IDENTIFIER_TYPE_VALUE (name, newval);
4247 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4251 pushdecl_top_level (x)
4254 push_to_top_level ();
4255 x = pushdecl_namespace_level (x);
4256 pop_from_top_level ();
4260 /* Make the declaration of X appear in CLASS scope. */
4263 pushdecl_class_level (x)
4266 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4267 scope looks for the pre-mangled name. */
4270 if (TREE_CODE (x) == OVERLOAD)
4271 x = OVL_CURRENT (x);
4272 name = DECL_NAME (x);
4276 push_class_level_binding (name, x);
4277 if (TREE_CODE (x) == TYPE_DECL)
4278 set_identifier_type_value (name, TREE_TYPE (x));
4280 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4284 for (f = TYPE_FIELDS (TREE_TYPE (x));
4287 pushdecl_class_level (f);
4291 /* Enter DECL into the symbol table, if that's appropriate. Returns
4292 DECL, or a modified version thereof. */
4295 maybe_push_decl (decl)
4298 tree type = TREE_TYPE (decl);
4300 /* Add this decl to the current binding level, but not if it comes
4301 from another scope, e.g. a static member variable. TEM may equal
4302 DECL or it may be a previous decl of the same name. */
4303 if (decl == error_mark_node
4304 || (TREE_CODE (decl) != PARM_DECL
4305 && DECL_CONTEXT (decl) != NULL_TREE
4306 /* Definitions of namespace members outside their namespace are
4308 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4309 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4310 || TREE_CODE (type) == UNKNOWN_TYPE
4311 /* The declaration of a template specialization does not affect
4312 the functions available for overload resolution, so we do not
4314 || (TREE_CODE (decl) == FUNCTION_DECL
4315 && DECL_TEMPLATE_SPECIALIZATION (decl)))
4318 return pushdecl (decl);
4321 /* Make the declaration(s) of X appear in CLASS scope
4322 under the name NAME. */
4325 push_class_level_binding (name, x)
4330 /* The class_binding_level will be NULL if x is a template
4331 parameter name in a member template. */
4332 if (!class_binding_level)
4335 /* Make sure that this new member does not have the same name
4336 as a template parameter. */
4337 if (TYPE_BEING_DEFINED (current_class_type))
4338 check_template_shadow (x);
4340 /* If this declaration shadows a declaration from an enclosing
4341 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4342 we leave this class. Record the shadowed declaration here. */
4343 binding = IDENTIFIER_BINDING (name);
4345 && ((TREE_CODE (x) == OVERLOAD
4346 && BINDING_VALUE (binding)
4347 && is_overloaded_fn (BINDING_VALUE (binding)))
4348 || INHERITED_VALUE_BINDING_P (binding)))
4353 /* If the old binding was from a base class, and was for a tag
4354 name, slide it over to make room for the new binding. The
4355 old binding is still visible if explicitly qualified with a
4357 if (INHERITED_VALUE_BINDING_P (binding)
4358 && BINDING_VALUE (binding)
4359 && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4360 && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4361 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4363 old_decl = BINDING_TYPE (binding);
4364 BINDING_TYPE (binding) = BINDING_VALUE (binding);
4365 BINDING_VALUE (binding) = NULL_TREE;
4366 INHERITED_VALUE_BINDING_P (binding) = 0;
4369 old_decl = BINDING_VALUE (binding);
4371 /* Find the previous binding of name on the class-shadowed
4372 list, and update it. */
4373 for (shadow = class_binding_level->class_shadowed;
4375 shadow = TREE_CHAIN (shadow))
4376 if (TREE_PURPOSE (shadow) == name
4377 && TREE_TYPE (shadow) == old_decl)
4379 BINDING_VALUE (binding) = x;
4380 INHERITED_VALUE_BINDING_P (binding) = 0;
4381 TREE_TYPE (shadow) = x;
4382 IDENTIFIER_CLASS_VALUE (name) = x;
4387 /* If we didn't replace an existing binding, put the binding on the
4388 stack of bindings for the identifier, and update the shadowed list. */
4389 if (push_class_binding (name, x))
4391 class_binding_level->class_shadowed
4392 = tree_cons (name, NULL,
4393 class_binding_level->class_shadowed);
4394 /* Record the value we are binding NAME to so that we can know
4395 what to pop later. */
4396 TREE_TYPE (class_binding_level->class_shadowed) = x;
4400 /* Insert another USING_DECL into the current binding level, returning
4401 this declaration. If this is a redeclaration, do nothing, and
4402 return NULL_TREE if this not in namespace scope (in namespace
4403 scope, a using decl might extend any previous bindings). */
4406 push_using_decl (scope, name)
4412 my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4413 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4414 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4415 if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4418 return namespace_bindings_p () ? decl : NULL_TREE;
4419 decl = build_lang_decl (USING_DECL, name, void_type_node);
4420 DECL_INITIAL (decl) = scope;
4421 TREE_CHAIN (decl) = current_binding_level->usings;
4422 current_binding_level->usings = decl;
4426 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4427 changed (i.e. there was already a directive), or the fresh
4428 TREE_LIST otherwise. */
4431 push_using_directive (used)
4434 tree ud = current_binding_level->using_directives;
4435 tree iter, ancestor;
4437 /* Check if we already have this. */
4438 if (purpose_member (used, ud) != NULL_TREE)
4441 /* Recursively add all namespaces used. */
4442 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4443 push_using_directive (TREE_PURPOSE (iter));
4445 ancestor = namespace_ancestor (current_decl_namespace (), used);
4446 ud = current_binding_level->using_directives;
4447 ud = tree_cons (used, ancestor, ud);
4448 current_binding_level->using_directives = ud;
4452 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4453 other definitions already in place. We get around this by making
4454 the value of the identifier point to a list of all the things that
4455 want to be referenced by that name. It is then up to the users of
4456 that name to decide what to do with that list.
4458 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4459 DECL_TEMPLATE_RESULT. It is dealt with the same way.
4461 FLAGS is a bitwise-or of the following values:
4462 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4464 PUSH_USING: DECL is being pushed as the result of a using
4467 The value returned may be a previous declaration if we guessed wrong
4468 about what language DECL should belong to (C or C++). Otherwise,
4469 it's always DECL (and never something that's not a _DECL). */
4472 push_overloaded_decl (decl, flags)
4476 tree name = DECL_NAME (decl);
4479 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4482 old = namespace_binding (name, DECL_CONTEXT (decl));
4484 old = lookup_name_current_level (name);
4488 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4490 tree t = TREE_TYPE (old);
4491 if (IS_AGGR_TYPE (t) && warn_shadow
4492 && (! DECL_IN_SYSTEM_HEADER (decl)
4493 || ! DECL_IN_SYSTEM_HEADER (old)))
4494 warning ("`%#D' hides constructor for `%#T'", decl, t);
4497 else if (is_overloaded_fn (old))
4501 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4503 tree fn = OVL_CURRENT (tmp);
4505 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4506 && !(flags & PUSH_USING)
4507 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4508 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4509 error ("`%#D' conflicts with previous using declaration `%#D'",
4512 if (duplicate_decls (decl, fn))
4516 else if (old == error_mark_node)
4517 /* Ignore the undefined symbol marker. */
4521 cp_error_at ("previous non-function declaration `%#D'", old);
4522 error ("conflicts with function declaration `%#D'", decl);
4527 if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4529 if (old && TREE_CODE (old) != OVERLOAD)
4530 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4532 new_binding = ovl_cons (decl, old);
4533 if (flags & PUSH_USING)
4534 OVL_USED (new_binding) = 1;
4537 /* NAME is not ambiguous. */
4541 set_namespace_binding (name, current_namespace, new_binding);
4544 /* We only create an OVERLOAD if there was a previous binding at
4545 this level, or if decl is a template. In the former case, we
4546 need to remove the old binding and replace it with the new
4547 binding. We must also run through the NAMES on the binding
4548 level where the name was bound to update the chain. */
4550 if (TREE_CODE (new_binding) == OVERLOAD && old)
4554 for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4556 d = &TREE_CHAIN (*d))
4558 || (TREE_CODE (*d) == TREE_LIST
4559 && TREE_VALUE (*d) == old))
4561 if (TREE_CODE (*d) == TREE_LIST)
4562 /* Just replace the old binding with the new. */
4563 TREE_VALUE (*d) = new_binding;
4565 /* Build a TREE_LIST to wrap the OVERLOAD. */
4566 *d = tree_cons (NULL_TREE, new_binding,
4569 /* And update the CPLUS_BINDING node. */
4570 BINDING_VALUE (IDENTIFIER_BINDING (name))
4575 /* We should always find a previous binding in this case. */
4579 /* Install the new binding. */
4580 push_local_binding (name, new_binding, flags);
4586 /* Generate an implicit declaration for identifier FUNCTIONID
4587 as a function of type int (). Print a warning if appropriate. */
4590 implicitly_declare (functionid)
4595 /* We used to reuse an old implicit decl here,
4596 but this loses with inline functions because it can clobber
4597 the saved decl chains. */
4598 decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4600 DECL_EXTERNAL (decl) = 1;
4601 TREE_PUBLIC (decl) = 1;
4603 /* ISO standard says implicit declarations are in the innermost block.
4604 So we record the decl in the standard fashion. */
4606 rest_of_decl_compilation (decl, NULL, 0, 0);
4609 /* Only one warning per identifier. */
4610 && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4612 pedwarn ("implicit declaration of function `%#D'", decl);
4615 SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4620 /* Return zero if the declaration NEWDECL is valid
4621 when the declaration OLDDECL (assumed to be for the same name)
4622 has already been seen.
4623 Otherwise return an error message format string with a %s
4624 where the identifier should go. */
4627 redeclaration_error_message (newdecl, olddecl)
4628 tree newdecl, olddecl;
4630 if (TREE_CODE (newdecl) == TYPE_DECL)
4632 /* Because C++ can put things into name space for free,
4633 constructs like "typedef struct foo { ... } foo"
4634 would look like an erroneous redeclaration. */
4635 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4638 return "redefinition of `%#D'";
4640 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4642 /* If this is a pure function, its olddecl will actually be
4643 the original initialization to `0' (which we force to call
4644 abort()). Don't complain about redefinition in this case. */
4645 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4648 /* If both functions come from different namespaces, this is not
4649 a redeclaration - this is a conflict with a used function. */
4650 if (DECL_NAMESPACE_SCOPE_P (olddecl)
4651 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4652 return "`%D' conflicts with used function";
4654 /* We'll complain about linkage mismatches in
4655 warn_extern_redeclared_static. */
4657 /* Defining the same name twice is no good. */
4658 if (DECL_INITIAL (olddecl) != NULL_TREE
4659 && DECL_INITIAL (newdecl) != NULL_TREE)
4661 if (DECL_NAME (olddecl) == NULL_TREE)
4662 return "`%#D' not declared in class";
4664 return "redefinition of `%#D'";
4668 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4670 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4671 && (DECL_TEMPLATE_RESULT (newdecl)
4672 != DECL_TEMPLATE_RESULT (olddecl))
4673 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4674 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4675 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4676 && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4677 && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4678 return "redefinition of `%#D'";
4681 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4683 /* Objects declared at top level: */
4684 /* If at least one is a reference, it's ok. */
4685 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4687 /* Reject two definitions. */
4688 return "redefinition of `%#D'";
4692 /* Objects declared with block scope: */
4693 /* Reject two definitions, and reject a definition
4694 together with an external reference. */
4695 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4696 return "redeclaration of `%#D'";
4701 /* Create a new label, named ID. */
4704 make_label_decl (id, local_p)
4710 decl = build_decl (LABEL_DECL, id, void_type_node);
4712 /* Make sure every label has an rtx. */
4715 DECL_CONTEXT (decl) = current_function_decl;
4716 DECL_MODE (decl) = VOIDmode;
4717 C_DECLARED_LABEL_FLAG (decl) = local_p;
4719 /* Say where one reference is to the label, for the sake of the
4720 error if it is not defined. */
4721 DECL_SOURCE_LINE (decl) = lineno;
4722 DECL_SOURCE_FILE (decl) = input_filename;
4724 /* Record the fact that this identifier is bound to this label. */
4725 SET_IDENTIFIER_LABEL_VALUE (id, decl);
4730 /* Record this label on the list of used labels so that we can check
4731 at the end of the function to see whether or not the label was
4732 actually defined, and so we can check when the label is defined whether
4733 this use is valid. */
4739 if (named_label_uses == NULL
4740 || named_label_uses->names_in_scope != current_binding_level->names
4741 || named_label_uses->label_decl != decl)
4743 struct named_label_use_list *new_ent;
4744 new_ent = ((struct named_label_use_list *)
4745 ggc_alloc (sizeof (struct named_label_use_list)));
4746 new_ent->label_decl = decl;
4747 new_ent->names_in_scope = current_binding_level->names;
4748 new_ent->binding_level = current_binding_level;
4749 new_ent->lineno_o_goto = lineno;
4750 new_ent->filename_o_goto = input_filename;
4751 new_ent->next = named_label_uses;
4752 named_label_uses = new_ent;
4756 /* Look for a label named ID in the current function. If one cannot
4757 be found, create one. (We keep track of used, but undefined,
4758 labels, and complain about them at the end of a function.) */
4765 struct named_label_list *ent;
4767 /* You can't use labels at global scope. */
4768 if (current_function_decl == NULL_TREE)
4770 error ("label `%s' referenced outside of any function",
4771 IDENTIFIER_POINTER (id));
4775 /* See if we've already got this label. */
4776 decl = IDENTIFIER_LABEL_VALUE (id);
4777 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4780 /* Record this label on the list of labels used in this function.
4781 We do this before calling make_label_decl so that we get the
4782 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4783 ent = ((struct named_label_list *)
4784 ggc_alloc_cleared (sizeof (struct named_label_list)));
4785 ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4786 ent->next = named_labels;
4789 /* We need a new label. */
4790 decl = make_label_decl (id, /*local_p=*/0);
4792 /* Now fill in the information we didn't have before. */
4793 ent->label_decl = decl;
4798 /* Declare a local label named ID. */
4801 declare_local_label (id)
4806 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4807 this scope we can restore the old value of
4808 IDENTIFIER_TYPE_VALUE. */
4809 current_binding_level->shadowed_labels
4810 = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4811 current_binding_level->shadowed_labels);
4812 /* Look for the label. */
4813 decl = make_label_decl (id, /*local_p=*/1);
4814 /* Now fill in the information we didn't have before. */
4815 TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4820 /* Returns nonzero if it is ill-formed to jump past the declaration of
4821 DECL. Returns 2 if it's also a real problem. */
4824 decl_jump_unsafe (decl)
4827 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4830 if (DECL_INITIAL (decl) == NULL_TREE
4831 && pod_type_p (TREE_TYPE (decl)))
4834 /* This is really only important if we're crossing an initialization.
4835 The POD stuff is just pedantry; why should it matter if the class
4836 contains a field of pointer to member type? */
4837 if (DECL_INITIAL (decl)
4838 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4843 /* Check that a single previously seen jump to a newly defined label
4844 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4845 the jump context; NAMES are the names in scope in LEVEL at the jump
4846 context; FILE and LINE are the source position of the jump or 0. */
4849 check_previous_goto_1 (decl, level, names, file, line)
4851 struct cp_binding_level *level;
4858 struct cp_binding_level *b = current_binding_level;
4859 for (; b; b = b->level_chain)
4861 tree new_decls = b->names;
4862 tree old_decls = (b == level ? names : NULL_TREE);
4863 for (; new_decls != old_decls;
4864 new_decls = TREE_CHAIN (new_decls))
4866 int problem = decl_jump_unsafe (new_decls);
4873 pedwarn ("jump to label `%D'", decl);
4875 pedwarn ("jump to case label");
4878 pedwarn_with_file_and_line (file, line, " from here");
4883 cp_error_at (" crosses initialization of `%#D'",
4886 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4892 if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4897 pedwarn ("jump to label `%D'", decl);
4899 pedwarn ("jump to case label");
4902 pedwarn_with_file_and_line (file, line, " from here");
4905 if (b->is_try_scope)
4906 error (" enters try block");
4908 error (" enters catch block");
4915 check_previous_goto (use)
4916 struct named_label_use_list *use;
4918 check_previous_goto_1 (use->label_decl, use->binding_level,
4919 use->names_in_scope, use->filename_o_goto,
4920 use->lineno_o_goto);
4924 check_switch_goto (level)
4925 struct cp_binding_level *level;
4927 check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4930 /* Check that any previously seen jumps to a newly defined label DECL
4931 are OK. Called by define_label. */
4934 check_previous_gotos (decl)
4937 struct named_label_use_list **usep;
4939 if (! TREE_USED (decl))
4942 for (usep = &named_label_uses; *usep; )
4944 struct named_label_use_list *use = *usep;
4945 if (use->label_decl == decl)
4947 check_previous_goto (use);
4951 usep = &(use->next);
4955 /* Check that a new jump to a label DECL is OK. Called by
4956 finish_goto_stmt. */
4964 struct named_label_list *lab;
4966 /* We can't know where a computed goto is jumping. So we assume
4968 if (! DECL_P (decl))
4971 /* If the label hasn't been defined yet, defer checking. */
4972 if (! DECL_INITIAL (decl))
4978 for (lab = named_labels; lab; lab = lab->next)
4979 if (decl == lab->label_decl)
4982 /* If the label is not on named_labels it's a gcc local label, so
4983 it must be in an outer scope, so jumping to it is always OK. */
4987 if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
4990 cp_pedwarn_at ("jump to label `%D'", decl);
4991 pedwarn (" from here");
4995 for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
4997 tree b = TREE_VALUE (bad);
4998 int u = decl_jump_unsafe (b);
5000 if (u > 1 && DECL_ARTIFICIAL (b))
5001 /* Can't skip init of __exception_info. */
5002 cp_error_at (" enters catch block", b);
5004 cp_error_at (" skips initialization of `%#D'", b);
5006 cp_pedwarn_at (" enters scope of non-POD `%#D'", b);
5009 if (lab->in_try_scope)
5010 error (" enters try block");
5011 else if (lab->in_catch_scope)
5012 error (" enters catch block");
5015 /* Define a label, specifying the location in the source file.
5016 Return the LABEL_DECL node for the label, if the definition is valid.
5017 Otherwise return 0. */
5020 define_label (filename, line, name)
5021 const char *filename;
5025 tree decl = lookup_label (name);
5026 struct named_label_list *ent;
5027 register struct cp_binding_level *p;
5029 for (ent = named_labels; ent; ent = ent->next)
5030 if (ent->label_decl == decl)
5033 /* After labels, make any new cleanups in the function go into their
5034 own new (temporary) binding contour. */
5035 for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5036 p->more_cleanups_ok = 0;
5038 if (name == get_identifier ("wchar_t"))
5039 pedwarn ("label named wchar_t");
5041 if (DECL_INITIAL (decl) != NULL_TREE)
5043 error ("duplicate label `%D'", decl);
5048 /* Mark label as having been defined. */
5049 DECL_INITIAL (decl) = error_mark_node;
5050 /* Say where in the source. */
5051 DECL_SOURCE_FILE (decl) = filename;
5052 DECL_SOURCE_LINE (decl) = line;
5055 ent->names_in_scope = current_binding_level->names;
5056 ent->binding_level = current_binding_level;
5058 check_previous_gotos (decl);
5065 struct cp_binding_level *level;
5066 struct cp_switch *next;
5067 /* The SWITCH_STMT being built. */
5069 /* A splay-tree mapping the low element of a case range to the high
5070 element, or NULL_TREE if there is no high element. Used to
5071 determine whether or not a new case label duplicates an old case
5072 label. We need a tree, rather than simply a hash table, because
5073 of the GNU case range extension. */
5077 /* A stack of the currently active switch statements. The innermost
5078 switch statement is on the top of the stack. There is no need to
5079 mark the stack for garbage collection because it is only active
5080 during the processing of the body of a function, and we never
5081 collect at that point. */
5083 static struct cp_switch *switch_stack;
5085 /* Called right after a switch-statement condition is parsed.
5086 SWITCH_STMT is the switch statement being parsed. */
5089 push_switch (switch_stmt)
5093 = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5094 p->level = current_binding_level;
5095 p->next = switch_stack;
5096 p->switch_stmt = switch_stmt;
5097 p->cases = splay_tree_new (case_compare, NULL, NULL);
5104 struct cp_switch *cs;
5107 splay_tree_delete (cs->cases);
5108 switch_stack = switch_stack->next;
5112 /* Note that we've seen a definition of a case label, and complain if this
5113 is a bad place for one. */
5116 finish_case_label (low_value, high_value)
5121 register struct cp_binding_level *p;
5126 error ("case label not within a switch statement");
5128 error ("case label `%E' not within a switch statement",
5131 error ("`default' label not within a switch statement");
5135 if (processing_template_decl)
5139 /* For templates, just add the case label; we'll do semantic
5140 analysis at instantiation-time. */
5141 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5142 return add_stmt (build_case_label (low_value, high_value, label));
5145 /* Find the condition on which this switch statement depends. */
5146 cond = SWITCH_COND (switch_stack->switch_stmt);
5147 if (cond && TREE_CODE (cond) == TREE_LIST)
5148 cond = TREE_VALUE (cond);
5150 r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5151 if (r == error_mark_node)
5154 check_switch_goto (switch_stack->level);
5156 /* After labels, make any new cleanups in the function go into their
5157 own new (temporary) binding contour. */
5158 for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5159 p->more_cleanups_ok = 0;
5164 /* Return the list of declarations of the current level.
5165 Note that this list is in reverse order unless/until
5166 you nreverse it; and when you do nreverse it, you must
5167 store the result back using `storedecls' or you will lose. */
5172 return current_binding_level->names;
5175 /* Return the list of type-tags (for structs, etc) of the current level. */
5180 return current_binding_level->tags;
5183 /* Store the list of declarations of the current level.
5184 This is done for the parameter declarations of a function being defined,
5185 after they are modified in the light of any missing parameters. */
5191 current_binding_level->names = decls;
5194 /* Similarly, store the list of tags of the current level. */
5200 current_binding_level->tags = tags;
5203 /* Return the type that should be used when TYPE's name is preceded
5204 by a tag such as 'struct' or 'union', or null if the name cannot
5205 be used in this way.
5207 For example, when processing the third line of:
5213 lookup of A will find the typedef. Given A's typedef, this function
5214 will return the type associated with "struct A". For the tag to be
5215 anything other than TYPE, TYPE must be a typedef whose original type
5216 has the same name and context as TYPE itself.
5218 It is not valid for a typedef of an anonymous type to be used with
5221 typedef struct { ... } B;
5224 Return null for this case. */
5227 follow_tag_typedef (type)
5232 original = original_type (type);
5233 if (! TYPE_NAME (original))
5235 if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
5236 && (CP_DECL_CONTEXT (TYPE_NAME (original))
5237 == CP_DECL_CONTEXT (TYPE_NAME (type)))
5238 && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
5244 /* Given NAME, an IDENTIFIER_NODE,
5245 return the structure (or union or enum) definition for that name.
5246 Searches binding levels from BINDING_LEVEL up to the global level.
5247 If THISLEVEL_ONLY is nonzero, searches only the specified context
5248 (but skips any tag-transparent contexts to find one that is
5249 meaningful for tags).
5250 FORM says which kind of type the caller wants;
5251 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5252 If the wrong kind of type is found, and it's not a template, an error is
5256 lookup_tag (form, name, binding_level, thislevel_only)
5257 enum tree_code form;
5259 struct cp_binding_level *binding_level;
5262 register struct cp_binding_level *level;
5263 /* Non-zero if, we should look past a template parameter level, even
5264 if THISLEVEL_ONLY. */
5265 int allow_template_parms_p = 1;
5267 for (level = binding_level; level; level = level->level_chain)
5270 if (ANON_AGGRNAME_P (name))
5271 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5273 /* There's no need for error checking here, because
5274 anon names are unique throughout the compilation. */
5275 if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5276 return TREE_VALUE (tail);
5278 else if (level->namespace_p)
5279 /* Do namespace lookup. */
5280 for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5282 tree old = binding_for_name (name, tail);
5284 /* If we just skipped past a template parameter level,
5285 even though THISLEVEL_ONLY, and we find a template
5286 class declaration, then we use the _TYPE node for the
5287 template. See the example below. */
5288 if (thislevel_only && !allow_template_parms_p
5289 && old && BINDING_VALUE (old)
5290 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5291 old = TREE_TYPE (BINDING_VALUE (old));
5293 old = BINDING_TYPE (old);
5297 /* We've found something at this binding level. If it is
5298 a typedef, extract the tag it refers to. Lookup fails
5299 if the typedef doesn't refer to a taggable type. */
5300 old = follow_tag_typedef (old);
5303 if (TREE_CODE (old) != form
5304 && (form == ENUMERAL_TYPE
5305 || TREE_CODE (old) == ENUMERAL_TYPE))
5307 error ("`%#D' redeclared as %C", old, form);
5312 if (thislevel_only || tail == global_namespace)
5316 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5318 if (TREE_PURPOSE (tail) == name)
5320 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5323 && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
5325 /* Definition isn't the kind we were looking for. */
5326 error ("`%#D' redeclared as %C", TREE_VALUE (tail), form);
5329 return TREE_VALUE (tail);
5332 if (thislevel_only && ! level->tag_transparent)
5334 if (level->template_parms_p && allow_template_parms_p)
5336 /* We must deal with cases like this:
5338 template <class T> struct S;
5339 template <class T> struct S {};
5341 When looking up `S', for the second declaration, we
5342 would like to find the first declaration. But, we
5343 are in the pseudo-global level created for the
5344 template parameters, rather than the (surrounding)
5345 namespace level. Thus, we keep going one more level,
5346 even though THISLEVEL_ONLY is non-zero. */
5347 allow_template_parms_p = 0;
5359 set_current_level_tags_transparency (tags_transparent)
5360 int tags_transparent;
5362 current_binding_level->tag_transparent = tags_transparent;
5366 /* Given a type, find the tag that was defined for it and return the tag name.
5367 Otherwise return 0. However, the value can never be 0
5368 in the cases in which this is used.
5370 C++: If NAME is non-zero, this is the new name to install. This is
5371 done when replacing anonymous tags with real tag names. */
5374 lookup_tag_reverse (type, name)
5378 register struct cp_binding_level *level;
5380 for (level = current_binding_level; level; level = level->level_chain)
5383 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5385 if (TREE_VALUE (tail) == type)
5388 TREE_PURPOSE (tail) = name;
5389 return TREE_PURPOSE (tail);
5396 /* Look up NAME in the NAMESPACE. */
5399 lookup_namespace_name (namespace, name)
5400 tree namespace, name;
5403 tree template_id = NULL_TREE;
5405 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5407 if (TREE_CODE (name) == NAMESPACE_DECL)
5408 /* This happens for A::B<int> when B is a namespace. */
5410 else if (TREE_CODE (name) == TEMPLATE_DECL)
5412 /* This happens for A::B where B is a template, and there are no
5413 template arguments. */
5414 error ("invalid use of `%D'", name);
5415 return error_mark_node;
5418 namespace = ORIGINAL_NAMESPACE (namespace);
5420 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5423 name = TREE_OPERAND (name, 0);
5424 if (TREE_CODE (name) == OVERLOAD)
5425 name = DECL_NAME (OVL_CURRENT (name));
5426 else if (DECL_P (name))
5427 name = DECL_NAME (name);
5430 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5432 val = make_node (CPLUS_BINDING);
5433 if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5434 return error_mark_node;
5436 if (BINDING_VALUE (val))
5438 val = BINDING_VALUE (val);
5442 if (DECL_CLASS_TEMPLATE_P (val))
5443 val = lookup_template_class (val,
5444 TREE_OPERAND (template_id, 1),
5445 /*in_decl=*/NULL_TREE,
5446 /*context=*/NULL_TREE,
5447 /*entering_scope=*/0,
5448 tf_error | tf_warning);
5449 else if (DECL_FUNCTION_TEMPLATE_P (val)
5450 || TREE_CODE (val) == OVERLOAD)
5451 val = lookup_template_function (val,
5452 TREE_OPERAND (template_id, 1));
5455 error ("`%D::%D' is not a template",
5457 return error_mark_node;
5461 /* If we have a single function from a using decl, pull it out. */
5462 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5463 val = OVL_FUNCTION (val);
5465 /* Ignore built-in functions that haven't been prototyped yet. */
5466 if (!val || !DECL_P(val)
5467 || !DECL_LANG_SPECIFIC(val)
5468 || !DECL_ANTICIPATED (val))
5472 error ("`%D' undeclared in namespace `%D'", name, namespace);
5473 return error_mark_node;
5476 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5485 hash = (((hashval_t) TYPE_CONTEXT (t))
5486 ^ ((hashval_t) DECL_NAME (TYPE_NAME (t))));
5491 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5494 typename_compare (k1, k2)
5505 d1 = TYPE_NAME (t1);
5506 d2 = TYPE_NAME (t2);
5508 return (DECL_NAME (d1) == DECL_NAME (d2)
5509 && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
5510 && ((TREE_TYPE (t1) != NULL_TREE)
5511 == (TREE_TYPE (t2) != NULL_TREE))
5512 && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5513 && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5516 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5517 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5518 is non-NULL, this type is being created by the implicit typename
5519 extension, and BASE_TYPE is a type named `t' in some base class of
5520 `T' which depends on template parameters.
5522 Returns the new TYPENAME_TYPE. */
5524 static GTY ((param_is (union tree_node))) htab_t typename_htab;
5527 build_typename_type (context, name, fullname, base_type)
5537 if (typename_htab == NULL)
5539 typename_htab = htab_create_ggc (61, &typename_hash,
5540 &typename_compare, NULL);
5543 /* Build the TYPENAME_TYPE. */
5544 t = make_aggr_type (TYPENAME_TYPE);
5545 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5546 TYPENAME_TYPE_FULLNAME (t) = fullname;
5547 TREE_TYPE (t) = base_type;
5549 /* Build the corresponding TYPE_DECL. */
5550 d = build_decl (TYPE_DECL, name, t);
5551 TYPE_NAME (TREE_TYPE (d)) = d;
5552 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5553 DECL_CONTEXT (d) = FROB_CONTEXT (context);
5554 DECL_ARTIFICIAL (d) = 1;
5556 /* See if we already have this type. */
5557 e = htab_find_slot (typename_htab, t, INSERT);
5566 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
5567 unless an error occurs, in which case error_mark_node is returned.
5568 If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
5569 set, we return that, rather than the _TYPE it corresponds to, in
5570 other cases we look through the type decl. If TF_ERROR is set,
5571 complain about errors, otherwise be quiet. */
5574 make_typename_type (context, name, complain)
5576 tsubst_flags_t complain;
5582 if (!(TYPE_LANG_SPECIFIC (name)
5583 && (CLASSTYPE_IS_TEMPLATE (name)
5584 || CLASSTYPE_USE_TEMPLATE (name))))
5585 name = TYPE_IDENTIFIER (name);
5587 /* Create a TEMPLATE_ID_EXPR for the type. */
5588 name = build_nt (TEMPLATE_ID_EXPR,
5589 CLASSTYPE_TI_TEMPLATE (name),
5590 CLASSTYPE_TI_ARGS (name));
5592 else if (TREE_CODE (name) == TYPE_DECL)
5593 name = DECL_NAME (name);
5597 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5599 name = TREE_OPERAND (name, 0);
5600 if (TREE_CODE (name) == TEMPLATE_DECL)
5601 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5603 if (TREE_CODE (name) == TEMPLATE_DECL)
5605 error ("`%D' used without template parameters", name);
5606 return error_mark_node;
5608 if (TREE_CODE (name) != IDENTIFIER_NODE)
5611 if (TREE_CODE (context) == NAMESPACE_DECL)
5613 /* We can get here from typename_sub0 in the explicit_template_type
5614 expansion. Just fail. */
5615 if (complain & tf_error)
5616 error ("no class template named `%#T' in `%#T'",
5618 return error_mark_node;
5621 if (! uses_template_parms (context)
5622 || currently_open_class (context))
5624 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5626 tree tmpl = NULL_TREE;
5627 if (IS_AGGR_TYPE (context))
5628 tmpl = lookup_field (context, name, 0, 0);
5629 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5631 if (complain & tf_error)
5632 error ("no class template named `%#T' in `%#T'",
5634 return error_mark_node;
5637 if (complain & tf_parsing)
5638 type_access_control (context, tmpl);
5640 enforce_access (context, tmpl);
5642 return lookup_template_class (tmpl,
5643 TREE_OPERAND (fullname, 1),
5645 /*entering_scope=*/0,
5646 tf_error | tf_warning);
5652 if (!IS_AGGR_TYPE (context))
5654 if (complain & tf_error)
5655 error ("no type named `%#T' in `%#T'", name, context);
5656 return error_mark_node;
5659 t = lookup_field (context, name, 0, 1);
5662 if (complain & tf_parsing)
5663 type_access_control (context, t);
5665 enforce_access (context, t);
5667 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
5669 if (IMPLICIT_TYPENAME_P (t))
5671 /* Lookup found an implicit typename that we had
5672 injected into the current scope. Doing things
5673 properly would have located the exact same type,
5674 so there is no error here. We must remove the
5675 implicitness so that we do not warn about it. */
5677 TREE_TYPE (t) = NULL_TREE;
5685 /* If the CONTEXT is not a template type, then either the field is
5686 there now or its never going to be. */
5687 if (!uses_template_parms (context))
5689 if (complain & tf_error)
5690 error ("no type named `%#T' in `%#T'", name, context);
5691 return error_mark_node;
5694 return build_typename_type (context, name, fullname, NULL_TREE);
5697 /* Resolve `CONTEXT::template NAME'. Returns an appropriate type,
5698 unless an error occurs, in which case error_mark_node is returned.
5699 If we locate a TYPE_DECL, we return that, rather than the _TYPE it
5700 corresponds to. If COMPLAIN zero, don't complain about any errors
5704 make_unbound_class_template (context, name, complain)
5712 name = TYPE_IDENTIFIER (name);
5713 else if (DECL_P (name))
5714 name = DECL_NAME (name);
5715 if (TREE_CODE (name) != IDENTIFIER_NODE)
5718 if (!uses_template_parms (context)
5719 || currently_open_class (context))
5721 tree tmpl = NULL_TREE;
5723 if (IS_AGGR_TYPE (context))
5724 tmpl = lookup_field (context, name, 0, 0);
5726 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5729 error ("no class template named `%#T' in `%#T'", name, context);
5730 return error_mark_node;
5733 if (complain & tf_parsing)
5734 type_access_control (context, tmpl);
5736 enforce_access (context, tmpl);
5741 /* Build the UNBOUND_CLASS_TEMPLATE. */
5742 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5743 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5744 TREE_TYPE (t) = NULL_TREE;
5746 /* Build the corresponding TEMPLATE_DECL. */
5747 d = build_decl (TEMPLATE_DECL, name, t);
5748 TYPE_NAME (TREE_TYPE (d)) = d;
5749 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5750 DECL_CONTEXT (d) = FROB_CONTEXT (context);
5751 DECL_ARTIFICIAL (d) = 1;
5756 /* Select the right _DECL from multiple choices. */
5759 select_decl (binding, flags)
5764 val = BINDING_VALUE (binding);
5766 if (LOOKUP_NAMESPACES_ONLY (flags))
5768 /* We are not interested in types. */
5769 if (val && TREE_CODE (val) == NAMESPACE_DECL)
5774 /* If we could have a type and
5775 we have nothing or we need a type and have none. */
5776 if (BINDING_TYPE (binding)
5777 && (!val || ((flags & LOOKUP_PREFER_TYPES)
5778 && TREE_CODE (val) != TYPE_DECL)))
5779 val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5780 /* Don't return non-types if we really prefer types. */
5781 else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
5782 && (TREE_CODE (val) != TEMPLATE_DECL
5783 || !DECL_CLASS_TEMPLATE_P (val)))
5789 /* Unscoped lookup of a global: iterate over current namespaces,
5790 considering using-directives. If SPACESP is non-NULL, store a list
5791 of the namespaces we've considered in it. */
5794 unqualified_namespace_lookup (name, flags, spacesp)
5799 tree b = make_node (CPLUS_BINDING);
5800 tree initial = current_decl_namespace ();
5801 tree scope = initial;
5803 struct cp_binding_level *level;
5804 tree val = NULL_TREE;
5807 *spacesp = NULL_TREE;
5809 for (; !val; scope = CP_DECL_CONTEXT (scope))
5812 *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5813 val = binding_for_name (name, scope);
5815 /* Ignore anticipated built-in functions. */
5816 if (val && BINDING_VALUE (val)
5817 && DECL_P (BINDING_VALUE (val))
5818 && DECL_LANG_SPECIFIC (BINDING_VALUE (val))
5819 && DECL_ANTICIPATED (BINDING_VALUE (val)))
5821 BINDING_VALUE (b) = NULL_TREE;
5822 BINDING_TYPE (b) = NULL_TREE;
5826 /* Initialize binding for this context. */
5827 BINDING_VALUE (b) = BINDING_VALUE (val);
5828 BINDING_TYPE (b) = BINDING_TYPE (val);
5831 /* Add all _DECLs seen through local using-directives. */
5832 for (level = current_binding_level;
5833 !level->namespace_p;
5834 level = level->level_chain)
5835 if (!lookup_using_namespace (name, b, level->using_directives,
5836 scope, flags, spacesp))
5837 /* Give up because of error. */
5838 return error_mark_node;
5840 /* Add all _DECLs seen through global using-directives. */
5841 /* XXX local and global using lists should work equally. */
5845 if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5846 scope, flags, spacesp))
5847 /* Give up because of error. */
5848 return error_mark_node;
5849 if (siter == scope) break;
5850 siter = CP_DECL_CONTEXT (siter);
5853 val = select_decl (b, flags);
5854 if (scope == global_namespace)
5860 /* Combine prefer_type and namespaces_only into flags. */
5863 lookup_flags (prefer_type, namespaces_only)
5864 int prefer_type, namespaces_only;
5866 if (namespaces_only)
5867 return LOOKUP_PREFER_NAMESPACES;
5868 if (prefer_type > 1)
5869 return LOOKUP_PREFER_TYPES;
5870 if (prefer_type > 0)
5871 return LOOKUP_PREFER_BOTH;
5875 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5876 ignore it or not. Subroutine of lookup_name_real. */
5879 qualify_lookup (val, flags)
5883 if (val == NULL_TREE)
5885 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5887 if ((flags & LOOKUP_PREFER_TYPES)
5888 && (TREE_CODE (val) == TYPE_DECL
5889 || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5890 && DECL_CLASS_TEMPLATE_P (val))))
5892 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5897 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5901 warn_about_implicit_typename_lookup (typename, binding)
5905 tree subtype = TREE_TYPE (TREE_TYPE (typename));
5906 tree name = DECL_NAME (typename);
5908 if (! (TREE_CODE (binding) == TEMPLATE_DECL
5909 && CLASSTYPE_TEMPLATE_INFO (subtype)
5910 && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5911 && ! (TREE_CODE (binding) == TYPE_DECL
5912 && same_type_p (TREE_TYPE (binding), subtype)))
5914 warning ("lookup of `%D' finds `%#D'",
5916 warning (" instead of `%D' from dependent base class",
5918 warning (" (use `typename %T::%D' if that's what you meant)",
5919 constructor_name (current_class_type), name);
5923 /* Check to see whether or not DECL is a variable that would have been
5924 in scope under the ARM, but is not in scope under the ANSI/ISO
5925 standard. If so, issue an error message. If name lookup would
5926 work in both cases, but return a different result, this function
5927 returns the result of ANSI/ISO lookup. Otherwise, it returns
5931 check_for_out_of_scope_variable (tree decl)
5935 /* We only care about out of scope variables. */
5936 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
5939 shadowed = DECL_SHADOWED_FOR_VAR (decl);
5940 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
5941 && DECL_DEAD_FOR_LOCAL (shadowed))
5942 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
5944 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
5947 if (!DECL_ERROR_REPORTED (decl))
5949 warning ("name lookup of `%D' changed",
5951 cp_warning_at (" matches this `%D' under ISO standard rules",
5953 cp_warning_at (" matches this `%D' under old rules", decl);
5954 DECL_ERROR_REPORTED (decl) = 1;
5959 /* If we have already complained about this declaration, there's no
5960 need to do it again. */
5961 if (DECL_ERROR_REPORTED (decl))
5964 DECL_ERROR_REPORTED (decl) = 1;
5965 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5967 error ("name lookup of `%D' changed for new ISO `for' scoping",
5969 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", decl);
5970 return error_mark_node;
5974 pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
5976 cp_pedwarn_at (" using obsolete binding at `%D'", decl);
5982 /* Look up NAME in the current binding level and its superiors in the
5983 namespace of variables, functions and typedefs. Return a ..._DECL
5984 node of some kind representing its definition if there is only one
5985 such declaration, or return a TREE_LIST with all the overloaded
5986 definitions if there are many, or return 0 if it is undefined.
5988 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5989 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5990 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5991 Otherwise we prefer non-TYPE_DECLs.
5993 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5994 using IDENTIFIER_CLASS_VALUE. */
5997 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5999 int prefer_type, nonclass, namespaces_only;
6002 tree val = NULL_TREE;
6004 tree from_obj = NULL_TREE;
6006 int val_is_implicit_typename = 0;
6008 /* Hack: copy flag set by parser, if set. */
6009 if (only_namespace_names)
6010 namespaces_only = 1;
6012 if (prefer_type == -2)
6014 extern int looking_for_typename;
6015 tree type = NULL_TREE;
6018 prefer_type = looking_for_typename;
6020 flags = lookup_flags (prefer_type, namespaces_only);
6021 /* If the next thing is '<', class templates are types. */
6022 if (looking_for_template)
6023 flags |= LOOKUP_TEMPLATES_EXPECTED;
6027 else if (got_object != error_mark_node)
6032 if (type == error_mark_node)
6033 return error_mark_node;
6034 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6035 type = TREE_TYPE (type);
6038 type = complete_type (type);
6040 if (TREE_CODE (type) == VOID_TYPE)
6041 type = global_namespace;
6042 if (TREE_CODE (type) == NAMESPACE_DECL)
6044 val = make_node (CPLUS_BINDING);
6045 flags |= LOOKUP_COMPLAIN;
6046 if (!qualified_lookup_using_namespace (name, type, val, flags))
6048 val = select_decl (val, flags);
6050 else if (! IS_AGGR_TYPE (type)
6051 || TREE_CODE (type) == TEMPLATE_TYPE_PARM
6052 || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
6053 || TREE_CODE (type) == TYPENAME_TYPE)
6054 /* Someone else will give an error about this if needed. */
6056 else if (type == current_class_type)
6057 val = IDENTIFIER_CLASS_VALUE (name);
6060 val = lookup_member (type, name, 0, prefer_type);
6061 if (!uses_template_parms (type))
6062 type_access_control (type, val);
6064 /* Restore the containing TYPENAME_TYPE if we looked
6065 through it before. */
6066 if (got_scope && got_scope != type
6067 && val && TREE_CODE (val) == TYPE_DECL
6068 && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
6070 val = TREE_TYPE (val);
6071 val = build_typename_type (got_scope, name,
6072 TYPENAME_TYPE_FULLNAME (val),
6074 val = TYPE_STUB_DECL (val);
6083 else if (got_object && val)
6091 flags = lookup_flags (prefer_type, namespaces_only);
6092 /* If we're not parsing, we need to complain. */
6093 flags |= LOOKUP_COMPLAIN;
6096 /* First, look in non-namespace scopes. */
6098 if (current_class_type == NULL_TREE)
6101 for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6105 if (!LOCAL_BINDING_P (t) && nonclass)
6106 /* We're not looking for class-scoped bindings, so keep going. */
6109 /* If this is the kind of thing we're looking for, we're done. */
6110 if (qualify_lookup (BINDING_VALUE (t), flags))
6111 binding = BINDING_VALUE (t);
6112 else if ((flags & LOOKUP_PREFER_TYPES)
6113 && qualify_lookup (BINDING_TYPE (t), flags))
6114 binding = BINDING_TYPE (t);
6116 binding = NULL_TREE;
6118 /* Handle access control on types from enclosing or base classes. */
6119 if (binding && ! yylex
6120 && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6121 type_access_control (BINDING_LEVEL (t)->this_class, binding);
6124 && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6126 if (val_is_implicit_typename && !yylex)
6127 warn_about_implicit_typename_lookup (val, binding);
6129 val_is_implicit_typename
6130 = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6131 if (!val_is_implicit_typename)
6136 /* Now lookup in namespace scopes. */
6137 if (!val || val_is_implicit_typename)
6139 t = unqualified_namespace_lookup (name, flags, 0);
6142 if (val_is_implicit_typename && !yylex)
6143 warn_about_implicit_typename_lookup (val, t);
6151 /* This should only warn about types used in qualified-ids. */
6152 if (from_obj && from_obj != val)
6154 if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6155 && TREE_CODE (val) == TYPE_DECL
6156 && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6158 lookup of `%D' in the scope of `%#T' (`%#D') \
6159 does not match lookup in the current scope (`%#D')",
6160 name, got_object, from_obj, val);
6162 /* We don't change val to from_obj if got_object depends on
6163 template parms because that breaks implicit typename for
6164 destructor calls. */
6165 if (! uses_template_parms (got_object))
6169 /* If we have a single function from a using decl, pull it out. */
6170 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6171 val = OVL_FUNCTION (val);
6180 lookup_name_nonclass (name)
6183 return lookup_name_real (name, 0, 1, 0);
6187 lookup_function_nonclass (name, args)
6191 return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6195 lookup_name_namespace_only (name)
6198 /* type-or-namespace, nonclass, namespace_only */
6199 return lookup_name_real (name, 1, 1, 1);
6203 lookup_name (name, prefer_type)
6207 return lookup_name_real (name, prefer_type, 0, 0);
6210 /* Similar to `lookup_name' but look only in the innermost non-class
6214 lookup_name_current_level (name)
6217 struct cp_binding_level *b;
6220 b = current_binding_level;
6221 while (b->parm_flag == 2)
6226 t = IDENTIFIER_NAMESPACE_VALUE (name);
6228 /* extern "C" function() */
6229 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6232 else if (IDENTIFIER_BINDING (name)
6233 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6237 if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6238 return IDENTIFIER_VALUE (name);
6250 /* Like lookup_name_current_level, but for types. */
6253 lookup_type_current_level (name)
6256 register tree t = NULL_TREE;
6258 my_friendly_assert (! current_binding_level->namespace_p, 980716);
6260 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6261 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6263 struct cp_binding_level *b = current_binding_level;
6266 if (purpose_member (name, b->type_shadowed))
6267 return REAL_IDENTIFIER_TYPE_VALUE (name);
6279 begin_only_namespace_names ()
6281 only_namespace_names = 1;
6285 end_only_namespace_names ()
6287 only_namespace_names = 0;
6290 /* Push the declarations of builtin types into the namespace.
6291 RID_INDEX is the index of the builtin type
6292 in the array RID_POINTERS. NAME is the name used when looking
6293 up the builtin type. TYPE is the _TYPE node for the builtin type. */
6296 record_builtin_type (rid_index, name, type)
6301 tree rname = NULL_TREE, tname = NULL_TREE;
6302 tree tdecl = NULL_TREE;
6304 if ((int) rid_index < (int) RID_MAX)
6305 rname = ridpointers[(int) rid_index];
6307 tname = get_identifier (name);
6309 TYPE_BUILT_IN (type) = 1;
6313 tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6314 set_identifier_type_value (tname, NULL_TREE);
6315 if ((int) rid_index < (int) RID_MAX)
6316 /* Built-in types live in the global namespace. */
6317 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6319 if (rname != NULL_TREE)
6321 if (tname != NULL_TREE)
6323 set_identifier_type_value (rname, NULL_TREE);
6324 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6328 tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6329 set_identifier_type_value (rname, NULL_TREE);
6334 /* Record one of the standard Java types.
6335 * Declare it as having the given NAME.
6336 * If SIZE > 0, it is the size of one of the integral types;
6337 * otherwise it is the negative of the size of one of the other types. */
6340 record_builtin_java_type (name, size)
6346 type = make_signed_type (size);
6347 else if (size > -32)
6348 { /* "__java_char" or ""__java_boolean". */
6349 type = make_unsigned_type (-size);
6350 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6353 { /* "__java_float" or ""__java_double". */
6354 type = make_node (REAL_TYPE);
6355 TYPE_PRECISION (type) = - size;
6358 record_builtin_type (RID_MAX, name, type);
6359 decl = TYPE_NAME (type);
6361 /* Suppress generate debug symbol entries for these types,
6362 since for normal C++ they are just clutter.
6363 However, push_lang_context undoes this if extern "Java" is seen. */
6364 DECL_IGNORED_P (decl) = 1;
6366 TYPE_FOR_JAVA (type) = 1;
6370 /* Push a type into the namespace so that the back-ends ignore it. */
6373 record_unknown_type (type, name)
6377 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6378 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
6379 DECL_IGNORED_P (decl) = 1;
6380 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6381 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6382 TYPE_ALIGN (type) = 1;
6383 TYPE_USER_ALIGN (type) = 0;
6384 TYPE_MODE (type) = TYPE_MODE (void_type_node);
6387 /* An string for which we should create an IDENTIFIER_NODE at
6390 typedef struct predefined_identifier
6392 /* The name of the identifier. */
6393 const char *const name;
6394 /* The place where the IDENTIFIER_NODE should be stored. */
6396 /* Non-zero if this is the name of a constructor or destructor. */
6397 const int ctor_or_dtor_p;
6398 } predefined_identifier;
6400 /* Create all the predefined identifiers. */
6403 initialize_predefined_identifiers ()
6405 const predefined_identifier *pid;
6407 /* A table of identifiers to create at startup. */
6408 static const predefined_identifier predefined_identifiers[] = {
6409 { "C++", &lang_name_cplusplus, 0 },
6410 { "C", &lang_name_c, 0 },
6411 { "Java", &lang_name_java, 0 },
6412 { CTOR_NAME, &ctor_identifier, 1 },
6413 { "__base_ctor", &base_ctor_identifier, 1 },
6414 { "__comp_ctor", &complete_ctor_identifier, 1 },
6415 { DTOR_NAME, &dtor_identifier, 1 },
6416 { "__comp_dtor", &complete_dtor_identifier, 1 },
6417 { "__base_dtor", &base_dtor_identifier, 1 },
6418 { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6419 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6420 { "nelts", &nelts_identifier, 0 },
6421 { THIS_NAME, &this_identifier, 0 },
6422 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6423 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6424 { "_vptr", &vptr_identifier, 0 },
6425 { "__vtt_parm", &vtt_parm_identifier, 0 },
6426 { "std", &std_identifier, 0 },
6430 for (pid = predefined_identifiers; pid->name; ++pid)
6432 *pid->node = get_identifier (pid->name);
6433 if (pid->ctor_or_dtor_p)
6434 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6438 /* Create the predefined scalar types of C,
6439 and some nodes representing standard constants (0, 1, (void *)0).
6440 Initialize the global binding level.
6441 Make definitions for built-in primitive functions. */
6444 cxx_init_decl_processing ()
6447 tree void_ftype_ptr;
6449 /* Create all the identifiers we need. */
6450 initialize_predefined_identifiers ();
6452 /* Fill in back-end hooks. */
6453 lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6455 /* Create the global variables. */
6456 push_to_top_level ();
6458 /* Enter the global namespace. */
6459 my_friendly_assert (global_namespace == NULL_TREE, 375);
6460 push_namespace (get_identifier ("::"));
6461 global_namespace = current_namespace;
6462 current_lang_name = NULL_TREE;
6464 /* Adjust various flags based on command-line settings. */
6465 if (! flag_permissive && ! pedantic)
6466 flag_pedantic_errors = 1;
6467 if (!flag_no_inline)
6469 flag_inline_trees = 1;
6472 if (flag_inline_functions)
6474 flag_inline_trees = 2;
6475 flag_inline_functions = 0;
6479 current_lang_name = lang_name_c;
6481 current_function_decl = NULL_TREE;
6482 current_binding_level = NULL_BINDING_LEVEL;
6483 free_binding_level = NULL_BINDING_LEVEL;
6485 build_common_tree_nodes (flag_signed_char);
6487 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6488 TREE_TYPE (error_mark_list) = error_mark_node;
6490 /* Make the binding_level structure for global names. */
6492 global_binding_level = current_binding_level;
6493 /* The global level is the namespace level of ::. */
6494 NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6495 declare_namespace_level ();
6497 /* Create the `std' namespace. */
6498 push_namespace (std_identifier);
6499 std_node = current_namespace;
6502 c_common_nodes_and_builtins ();
6504 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6505 java_short_type_node = record_builtin_java_type ("__java_short", 16);
6506 java_int_type_node = record_builtin_java_type ("__java_int", 32);
6507 java_long_type_node = record_builtin_java_type ("__java_long", 64);
6508 java_float_type_node = record_builtin_java_type ("__java_float", -32);
6509 java_double_type_node = record_builtin_java_type ("__java_double", -64);
6510 java_char_type_node = record_builtin_java_type ("__java_char", -16);
6511 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6513 integer_two_node = build_int_2 (2, 0);
6514 TREE_TYPE (integer_two_node) = integer_type_node;
6515 integer_three_node = build_int_2 (3, 0);
6516 TREE_TYPE (integer_three_node) = integer_type_node;
6518 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6519 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6520 TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6521 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6522 TYPE_PRECISION (boolean_type_node) = 1;
6523 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6524 boolean_false_node = build_int_2 (0, 0);
6525 TREE_TYPE (boolean_false_node) = boolean_type_node;
6526 boolean_true_node = build_int_2 (1, 0);
6527 TREE_TYPE (boolean_true_node) = boolean_type_node;
6529 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6532 record_builtin_type (RID_MAX, NULL, string_type_node);
6535 delta_type_node = ptrdiff_type_node;
6536 vtable_index_type = ptrdiff_type_node;
6538 vtt_parm_type = build_pointer_type (const_ptr_type_node);
6539 void_ftype = build_function_type (void_type_node, void_list_node);
6540 void_ftype_ptr = build_function_type (void_type_node,
6541 tree_cons (NULL_TREE,
6545 = build_exception_variant (void_ftype_ptr, empty_except_spec);
6547 /* C++ extensions */
6549 unknown_type_node = make_node (UNKNOWN_TYPE);
6550 record_unknown_type (unknown_type_node, "unknown type");
6552 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6553 TREE_TYPE (unknown_type_node) = unknown_type_node;
6555 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6557 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6558 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6561 /* Make sure we get a unique function type, so we can give
6562 its pointer type a name. (This wins for gdb.) */
6563 tree vfunc_type = make_node (FUNCTION_TYPE);
6564 TREE_TYPE (vfunc_type) = integer_type_node;
6565 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6566 layout_type (vfunc_type);
6568 vtable_entry_type = build_pointer_type (vfunc_type);
6570 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6573 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6574 layout_type (vtbl_type_node);
6575 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6576 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6577 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6578 layout_type (vtbl_ptr_type_node);
6579 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6581 push_namespace (get_identifier ("__cxxabiv1"));
6582 abi_node = current_namespace;
6585 global_type_node = make_node (LANG_TYPE);
6586 record_unknown_type (global_type_node, "global type");
6589 current_lang_name = lang_name_cplusplus;
6592 tree bad_alloc_type_node, newtype, deltype;
6593 tree ptr_ftype_sizetype;
6595 push_namespace (std_identifier);
6597 = xref_tag (class_type, get_identifier ("bad_alloc"),
6598 /*attributes=*/NULL_TREE, 1);
6601 = build_function_type (ptr_type_node,
6602 tree_cons (NULL_TREE,
6605 newtype = build_exception_variant
6606 (ptr_ftype_sizetype, add_exception_specifier
6607 (NULL_TREE, bad_alloc_type_node, -1));
6608 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6609 push_cp_library_fn (NEW_EXPR, newtype);
6610 push_cp_library_fn (VEC_NEW_EXPR, newtype);
6611 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6612 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6616 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6618 /* Perform other language dependent initializations. */
6619 init_class_processing ();
6620 init_search_processing ();
6621 init_rtti_processing ();
6623 if (flag_exceptions)
6624 init_exception_processing ();
6626 if (! supports_one_only ())
6629 make_fname_decl = cp_make_fname_decl;
6630 start_fname_decls ();
6632 /* Show we use EH for cleanups. */
6633 using_eh_for_cleanups ();
6635 /* Maintain consistency. Perhaps we should just complain if they
6636 say -fwritable-strings? */
6637 if (flag_writable_strings)
6638 flag_const_strings = 0;
6641 /* Generate an initializer for a function naming variable from
6642 NAME. NAME may be NULL, in which case we generate a special
6643 ERROR_MARK node which should be replaced later. */
6646 cp_fname_init (name)
6649 tree domain = NULL_TREE;
6651 tree init = NULL_TREE;
6656 length = strlen (name);
6657 domain = build_index_type (size_int (length));
6658 init = build_string (length + 1, name);
6661 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6662 type = build_cplus_array_type (type, domain);
6665 TREE_TYPE (init) = type;
6667 /* We don't know the value until instantiation time. Make
6668 something which will be digested now, but replaced later. */
6669 init = build (ERROR_MARK, type);
6674 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6675 decl, NAME is the initialization string and TYPE_DEP indicates whether
6676 NAME depended on the type of the function. We make use of that to detect
6677 __PRETTY_FUNCTION__ inside a template fn. This is being done
6678 lazily at the point of first use, so we musn't push the decl now. */
6681 cp_make_fname_decl (id, type_dep)
6685 const char *const name = (type_dep && processing_template_decl
6686 ? NULL : fname_as_string (type_dep));
6687 tree init = cp_fname_init (name);
6688 tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6690 /* As we don't push the decl here, we must set the context. */
6691 DECL_CONTEXT (decl) = current_function_decl;
6692 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6694 TREE_STATIC (decl) = 1;
6695 TREE_READONLY (decl) = 1;
6696 DECL_ARTIFICIAL (decl) = 1;
6697 DECL_INITIAL (decl) = init;
6699 TREE_USED (decl) = 1;
6701 cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6706 /* Make a definition for a builtin function named NAME in the current
6707 namespace, whose data type is TYPE and whose context is CONTEXT.
6708 TYPE should be a function type with argument types.
6710 CLASS and CODE tell later passes how to compile calls to this function.
6711 See tree.h for possible values.
6713 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6714 the name to be called if we can't opencode the function.
6715 If ATTRS is nonzero, use that for the function's attribute
6719 builtin_function_1 (name, type, context, code, class, libname, attrs)
6724 enum built_in_class class;
6725 const char *libname;
6728 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6729 DECL_BUILT_IN_CLASS (decl) = class;
6730 DECL_FUNCTION_CODE (decl) = code;
6731 DECL_CONTEXT (decl) = context;
6735 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6736 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6737 function in the namespace. */
6739 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6740 make_decl_rtl (decl, NULL);
6742 /* Warn if a function in the namespace for users
6743 is used without an occasion to consider it declared. */
6744 if (name[0] != '_' || name[1] != '_')
6745 DECL_ANTICIPATED (decl) = 1;
6747 /* Possibly apply some default attributes to this built-in function. */
6749 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
6751 decl_attributes (&decl, NULL_TREE, 0);
6756 /* Entry point for the benefit of c_common_nodes_and_builtins.
6758 Make a defintion for a builtin function named NAME and whose data type
6759 is TYPE. TYPE should be a function type with argument types. This
6760 function places the anticipated declaration in the global namespace
6761 and additionally in the std namespace if appropriate.
6763 CLASS and CODE tell later passes how to compile calls to this function.
6764 See tree.h for possible values.
6766 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6767 the name to be called if we can't opencode the function.
6769 If ATTRS is nonzero, use that for the function's attribute
6773 builtin_function (name, type, code, class, libname, attrs)
6777 enum built_in_class class;
6778 const char *libname;
6781 /* All builtins that don't begin with an '_' should additionally
6782 go in the 'std' namespace. */
6785 push_namespace (std_identifier);
6786 builtin_function_1 (name, type, std_node, code, class, libname, attrs);
6790 return builtin_function_1 (name, type, NULL_TREE, code,
6791 class, libname, attrs);
6794 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6795 function. Not called directly. */
6798 build_library_fn_1 (name, operator_code, type)
6800 enum tree_code operator_code;
6803 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6804 DECL_EXTERNAL (fn) = 1;
6805 TREE_PUBLIC (fn) = 1;
6806 DECL_ARTIFICIAL (fn) = 1;
6807 TREE_NOTHROW (fn) = 1;
6808 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6809 SET_DECL_LANGUAGE (fn, lang_c);
6813 /* Returns the _DECL for a library function with C linkage.
6814 We assume that such functions never throw; if this is incorrect,
6815 callers should unset TREE_NOTHROW. */
6818 build_library_fn (name, type)
6822 return build_library_fn_1 (name, ERROR_MARK, type);
6825 /* Returns the _DECL for a library function with C++ linkage. */
6828 build_cp_library_fn (name, operator_code, type)
6830 enum tree_code operator_code;
6833 tree fn = build_library_fn_1 (name, operator_code, type);
6834 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6835 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6836 SET_DECL_LANGUAGE (fn, lang_cplusplus);
6837 set_mangled_name_for_decl (fn);
6841 /* Like build_library_fn, but takes a C string instead of an
6845 build_library_fn_ptr (name, type)
6849 return build_library_fn (get_identifier (name), type);
6852 /* Like build_cp_library_fn, but takes a C string instead of an
6856 build_cp_library_fn_ptr (name, type)
6860 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6863 /* Like build_library_fn, but also pushes the function so that we will
6864 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
6867 push_library_fn (name, type)
6870 tree fn = build_library_fn (name, type);
6871 pushdecl_top_level (fn);
6875 /* Like build_cp_library_fn, but also pushes the function so that it
6876 will be found by normal lookup. */
6879 push_cp_library_fn (operator_code, type)
6880 enum tree_code operator_code;
6883 tree fn = build_cp_library_fn (ansi_opname (operator_code),
6890 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6894 push_void_library_fn (name, parmtypes)
6895 tree name, parmtypes;
6897 tree type = build_function_type (void_type_node, parmtypes);
6898 return push_library_fn (name, type);
6901 /* Like push_library_fn, but also note that this function throws
6902 and does not return. Used for __throw_foo and the like. */
6905 push_throw_library_fn (name, type)
6908 tree fn = push_library_fn (name, type);
6909 TREE_THIS_VOLATILE (fn) = 1;
6910 TREE_NOTHROW (fn) = 0;
6914 /* Apply default attributes to a function, if a system function with default
6918 cxx_insert_default_attributes (decl)
6921 if (!DECL_EXTERN_C_FUNCTION_P (decl))
6923 if (!TREE_PUBLIC (decl))
6925 c_common_insert_default_attributes (decl);
6928 /* When we call finish_struct for an anonymous union, we create
6929 default copy constructors and such. But, an anonymous union
6930 shouldn't have such things; this function undoes the damage to the
6931 anonymous union type T.
6933 (The reason that we create the synthesized methods is that we don't
6934 distinguish `union { int i; }' from `typedef union { int i; } U'.
6935 The first is an anonymous union; the second is just an ordinary
6939 fixup_anonymous_aggr (t)
6944 /* Wipe out memory of synthesized methods */
6945 TYPE_HAS_CONSTRUCTOR (t) = 0;
6946 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6947 TYPE_HAS_INIT_REF (t) = 0;
6948 TYPE_HAS_CONST_INIT_REF (t) = 0;
6949 TYPE_HAS_ASSIGN_REF (t) = 0;
6950 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6952 /* Splice the implicitly generated functions out of the TYPE_METHODS
6954 q = &TYPE_METHODS (t);
6957 if (DECL_ARTIFICIAL (*q))
6958 *q = TREE_CHAIN (*q);
6960 q = &TREE_CHAIN (*q);
6963 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
6964 if (TYPE_METHODS (t))
6965 cp_error_at ("an anonymous union cannot have function members", t);
6967 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6968 assignment operators (because they cannot have these methods themselves).
6969 For anonymous unions this is already checked because they are not allowed
6970 in any union, otherwise we have to check it. */
6971 if (TREE_CODE (t) != UNION_TYPE)
6975 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6976 if (TREE_CODE (field) == FIELD_DECL)
6978 type = TREE_TYPE (field);
6979 if (CLASS_TYPE_P (type))
6981 if (TYPE_NEEDS_CONSTRUCTING (type))
6982 cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6984 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6985 cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6987 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6988 cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6995 /* Make sure that a declaration with no declarator is well-formed, i.e.
6996 just defines a tagged type or anonymous union.
6998 Returns the type defined, if any. */
7001 check_tag_decl (declspecs)
7006 int saw_typedef = 0;
7007 tree ob_modifier = NULL_TREE;
7009 register tree t = NULL_TREE;
7011 for (link = declspecs; link; link = TREE_CHAIN (link))
7013 register tree value = TREE_VALUE (link);
7016 || TREE_CODE (value) == TYPE_DECL
7017 || (TREE_CODE (value) == IDENTIFIER_NODE
7018 && IDENTIFIER_GLOBAL_VALUE (value)
7019 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
7023 if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
7025 if (! in_system_header)
7026 pedwarn ("redeclaration of C++ built-in type `%T'", value);
7031 && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7032 || TREE_CODE (value) == ENUMERAL_TYPE))
7034 my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7038 else if (value == ridpointers[(int) RID_TYPEDEF])
7040 else if (value == ridpointers[(int) RID_FRIEND])
7042 if (current_class_type == NULL_TREE
7043 || current_scope () != current_class_type)
7044 ob_modifier = value;
7048 else if (value == ridpointers[(int) RID_STATIC]
7049 || value == ridpointers[(int) RID_EXTERN]
7050 || value == ridpointers[(int) RID_AUTO]
7051 || value == ridpointers[(int) RID_REGISTER]
7052 || value == ridpointers[(int) RID_INLINE]
7053 || value == ridpointers[(int) RID_VIRTUAL]
7054 || value == ridpointers[(int) RID_CONST]
7055 || value == ridpointers[(int) RID_VOLATILE]
7056 || value == ridpointers[(int) RID_EXPLICIT]
7057 || value == ridpointers[(int) RID_THREAD])
7058 ob_modifier = value;
7062 error ("multiple types in one declaration");
7064 if (t == NULL_TREE && ! saw_friend)
7065 pedwarn ("declaration does not declare anything");
7067 /* Check for an anonymous union. */
7068 else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7069 && TYPE_ANONYMOUS_P (t))
7071 /* 7/3 In a simple-declaration, the optional init-declarator-list
7072 can be omitted only when declaring a class (clause 9) or
7073 enumeration (7.2), that is, when the decl-specifier-seq contains
7074 either a class-specifier, an elaborated-type-specifier with
7075 a class-key (9.1), or an enum-specifier. In these cases and
7076 whenever a class-specifier or enum-specifier is present in the
7077 decl-specifier-seq, the identifiers in these specifiers are among
7078 the names being declared by the declaration (as class-name,
7079 enum-names, or enumerators, depending on the syntax). In such
7080 cases, and except for the declaration of an unnamed bit-field (9.6),
7081 the decl-specifier-seq shall introduce one or more names into the
7082 program, or shall redeclare a name introduced by a previous
7083 declaration. [Example:
7084 enum { }; // ill-formed
7085 typedef class { }; // ill-formed
7089 error ("missing type-name in typedef-declaration");
7092 /* Anonymous unions are objects, so they can have specifiers. */;
7093 SET_ANON_AGGR_TYPE_P (t);
7095 if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7096 pedwarn ("ISO C++ prohibits anonymous structs");
7099 else if (ob_modifier)
7101 if (ob_modifier == ridpointers[(int) RID_INLINE]
7102 || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7103 error ("`%D' can only be specified for functions", ob_modifier);
7104 else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7105 error ("`%D' can only be specified inside a class", ob_modifier);
7106 else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7107 error ("`%D' can only be specified for constructors",
7110 error ("`%D' can only be specified for objects and functions",
7117 /* Called when a declaration is seen that contains no names to declare.
7118 If its type is a reference to a structure, union or enum inherited
7119 from a containing scope, shadow that tag name for the current scope
7120 with a forward reference.
7121 If its type defines a new named structure or union
7122 or defines an enum, it is valid but we need not do anything here.
7123 Otherwise, it is an error.
7125 C++: may have to grok the declspecs to learn about static,
7126 complain for anonymous unions. */
7129 shadow_tag (declspecs)
7132 tree t = check_tag_decl (declspecs);
7135 maybe_process_partial_specialization (t);
7137 /* This is where the variables in an anonymous union are
7138 declared. An anonymous union declaration looks like:
7140 because there is no declarator after the union, the parser
7141 sends that declaration here. */
7142 if (t && ANON_AGGR_TYPE_P (t))
7144 fixup_anonymous_aggr (t);
7146 if (TYPE_FIELDS (t))
7148 tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7150 finish_anon_union (decl);
7155 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
7158 groktypename (typename)
7163 if (TREE_CODE (typename) != TREE_LIST)
7165 split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
7166 type = grokdeclarator (TREE_VALUE (typename), specs,
7167 TYPENAME, 0, &attrs);
7169 cplus_decl_attributes (&type, attrs, 0);
7173 /* Decode a declarator in an ordinary declaration or data definition.
7174 This is called as soon as the type information and variable name
7175 have been parsed, before parsing the initializer if any.
7176 Here we create the ..._DECL node, fill in its type,
7177 and put it on the list of decls for the current context.
7178 The ..._DECL node is returned as the value.
7180 Exception: for arrays where the length is not specified,
7181 the type is left null, to be filled in by `cp_finish_decl'.
7183 Function definitions do not come here; they go to start_function
7184 instead. However, external and forward declarations of functions
7185 do go through here. Structure field declarations are done by
7186 grokfield and not through here. */
7189 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7190 tree declarator, declspecs;
7192 tree attributes, prefix_attributes;
7195 register tree type, tem;
7199 /* See code below that used this. */
7200 int init_written = initialized;
7203 /* This should only be done once on the top most decl. */
7204 if (have_extern_spec)
7206 declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7208 have_extern_spec = false;
7211 /* An object declared as __attribute__((deprecated)) suppresses
7212 warnings of uses of other deprecated items. */
7213 if (lookup_attribute ("deprecated", attributes))
7214 deprecated_state = DEPRECATED_SUPPRESS;
7216 attributes = chainon (attributes, prefix_attributes);
7218 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7221 deprecated_state = DEPRECATED_NORMAL;
7223 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7226 type = TREE_TYPE (decl);
7228 if (type == error_mark_node)
7231 context = DECL_CONTEXT (decl);
7233 if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7234 && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7236 /* When parsing the initializer, lookup should use the object's
7238 push_decl_namespace (context);
7241 /* We are only interested in class contexts, later. */
7242 if (context && TREE_CODE (context) == NAMESPACE_DECL)
7243 context = NULL_TREE;
7246 /* Is it valid for this decl to have an initializer at all?
7247 If not, set INITIALIZED to zero, which will indirectly
7248 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7249 switch (TREE_CODE (decl))
7252 /* typedef foo = bar means give foo the same type as bar.
7253 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7254 Any other case of an initialization in a TYPE_DECL is an error. */
7255 if (pedantic || list_length (declspecs) > 1)
7257 error ("typedef `%D' is initialized", decl);
7263 error ("function `%#D' is initialized like a variable", decl);
7273 if (! toplevel_bindings_p ()
7274 && DECL_EXTERNAL (decl))
7275 warning ("declaration of `%#D' has `extern' and is initialized",
7277 DECL_EXTERNAL (decl) = 0;
7278 if (toplevel_bindings_p ())
7279 TREE_STATIC (decl) = 1;
7281 /* Tell `pushdecl' this is an initialized decl
7282 even though we don't yet have the initializer expression.
7283 Also tell `cp_finish_decl' it may store the real initializer. */
7284 DECL_INITIAL (decl) = error_mark_node;
7287 /* Set attributes here so if duplicate decl, will have proper attributes. */
7288 cplus_decl_attributes (&decl, attributes, 0);
7290 /* If #pragma weak was used, mark the decl weak now. */
7291 if (current_binding_level == global_binding_level)
7292 maybe_apply_pragma_weak (decl);
7294 if (TREE_CODE (decl) == FUNCTION_DECL
7295 && DECL_DECLARED_INLINE_P (decl)
7296 && DECL_UNINLINABLE (decl)
7297 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7298 warning_with_decl (decl,
7299 "inline function `%s' given attribute noinline");
7301 if (context && COMPLETE_TYPE_P (complete_type (context)))
7303 push_nested_class (context, 2);
7305 if (TREE_CODE (decl) == VAR_DECL)
7307 tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7308 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7309 error ("`%#D' is not a static member of `%#T'", decl, context);
7312 if (DECL_CONTEXT (field) != context)
7314 pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7315 DECL_CONTEXT (field), DECL_NAME (decl),
7316 context, DECL_NAME (decl));
7317 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7319 /* Static data member are tricky; an in-class initialization
7320 still doesn't provide a definition, so the in-class
7321 declaration will have DECL_EXTERNAL set, but will have an
7322 initialization. Thus, duplicate_decls won't warn
7323 about this situation, and so we check here. */
7324 if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7325 error ("duplicate initialization of %D", decl);
7326 if (duplicate_decls (decl, field))
7332 tree field = check_classfn (context, decl);
7333 if (field && duplicate_decls (decl, field))
7337 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7338 DECL_IN_AGGR_P (decl) = 0;
7339 if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7340 || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7342 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7343 /* [temp.expl.spec] An explicit specialization of a static data
7344 member of a template is a definition if the declaration
7345 includes an initializer; otherwise, it is a declaration.
7347 We check for processing_specialization so this only applies
7348 to the new specialization syntax. */
7349 if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7350 DECL_EXTERNAL (decl) = 1;
7353 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7354 pedwarn ("declaration of `%#D' outside of class is not definition",
7358 /* Enter this declaration into the symbol table. */
7359 tem = maybe_push_decl (decl);
7361 if (processing_template_decl)
7362 tem = push_template_decl (tem);
7364 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7365 /* Tell the back-end to use or not use .common as appropriate. If we say
7366 -fconserve-space, we want this to save .data space, at the expense of
7367 wrong semantics. If we say -fno-conserve-space, we want this to
7368 produce errors about redefs; to do this we force variables into the
7370 DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7373 if (! processing_template_decl)
7383 tree type = TREE_TYPE (decl);
7384 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7386 if (type == error_mark_node)
7389 maybe_push_cleanup_level (type);
7392 /* Is it valid for this decl to have an initializer at all?
7393 If not, set INITIALIZED to zero, which will indirectly
7394 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7396 /* Don't allow initializations for incomplete types except for
7397 arrays which might be completed by the initialization. */
7398 if (COMPLETE_TYPE_P (complete_type (type)))
7399 ; /* A complete type is ok. */
7400 else if (TREE_CODE (type) != ARRAY_TYPE)
7402 error ("variable `%#D' has initializer but incomplete type",
7405 type = TREE_TYPE (decl) = error_mark_node;
7407 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7409 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7410 error ("elements of array `%#D' have incomplete type", decl);
7411 /* else we already gave an error in start_decl. */
7417 && TREE_CODE (decl) != TYPE_DECL
7418 && TREE_CODE (decl) != TEMPLATE_DECL
7419 && type != error_mark_node
7420 && IS_AGGR_TYPE (type)
7421 && ! DECL_EXTERNAL (decl))
7423 if ((! processing_template_decl || ! uses_template_parms (type))
7424 && !COMPLETE_TYPE_P (complete_type (type)))
7426 error ("aggregate `%#D' has incomplete type and cannot be defined",
7428 /* Change the type so that assemble_variable will give
7429 DECL an rtl we can live with: (mem (const_int 0)). */
7430 type = TREE_TYPE (decl) = error_mark_node;
7434 /* If any base type in the hierarchy of TYPE needs a constructor,
7435 then we set initialized to 1. This way any nodes which are
7436 created for the purposes of initializing this aggregate
7437 will live as long as it does. This is necessary for global
7438 aggregates which do not have their initializers processed until
7439 the end of the file. */
7440 initialized = TYPE_NEEDS_CONSTRUCTING (type);
7445 DECL_INITIAL (decl) = NULL_TREE;
7448 /* Handle initialization of references.
7449 These three arguments are from `cp_finish_decl', and have the
7450 same meaning here that they do there.
7452 Quotes on semantics can be found in ARM 8.4.3. */
7455 grok_reference_init (decl, type, init)
7456 tree decl, type, init;
7460 if (init == NULL_TREE)
7462 if ((DECL_LANG_SPECIFIC (decl) == 0
7463 || DECL_IN_AGGR_P (decl) == 0)
7464 && ! DECL_THIS_EXTERN (decl))
7465 error ("`%D' declared as reference but not initialized", decl);
7469 if (init == error_mark_node)
7472 if (TREE_CODE (init) == CONSTRUCTOR)
7474 error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7478 if (TREE_CODE (init) == TREE_LIST)
7479 init = build_compound_expr (init);
7481 if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7482 init = convert_from_reference (init);
7484 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7485 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7487 /* Note: default conversion is only called in very special cases. */
7488 init = default_conversion (init);
7491 /* Convert INIT to the reference type TYPE. This may involve the
7492 creation of a temporary, whose lifetime must be the same as that
7493 of the reference. If so, a DECL_STMT for the temporary will be
7494 added just after the DECL_STMT for DECL. That's why we don't set
7495 DECL_INITIAL for local references (instead assigning to them
7496 explicitly); we need to allow the temporary to be initialized
7498 tmp = convert_to_reference
7499 (type, init, CONV_IMPLICIT,
7500 LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7503 if (tmp == error_mark_node)
7505 else if (tmp == NULL_TREE)
7507 error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7511 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7514 DECL_INITIAL (decl) = tmp;
7519 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7520 mucking with forces it does not comprehend (i.e. initialization with a
7521 constructor). If we are at global scope and won't go into COMMON, fill
7522 it in with a dummy CONSTRUCTOR to force the variable into .data;
7523 otherwise we can use error_mark_node. */
7526 obscure_complex_init (decl, init)
7529 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
7531 error ("run-time initialization of thread-local storage");
7535 if (! flag_no_inline && TREE_STATIC (decl))
7537 if (extract_init (decl, init))
7541 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7542 if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7543 DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7548 if (zero_init_p (TREE_TYPE (decl)))
7549 DECL_INITIAL (decl) = error_mark_node;
7550 /* Otherwise, force_store_init_value will have already stored a
7551 zero-init initializer in DECL_INITIAL, that should be
7558 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7559 array until we finish parsing the initializer. If that's the
7560 situation we're in, update DECL accordingly. */
7563 maybe_deduce_size_from_array_init (decl, init)
7567 tree type = TREE_TYPE (decl);
7569 if (TREE_CODE (type) == ARRAY_TYPE
7570 && TYPE_DOMAIN (type) == NULL_TREE
7571 && TREE_CODE (decl) != TYPE_DECL)
7573 /* do_default is really a C-ism to deal with tentative definitions.
7574 But let's leave it here to ease the eventual merge. */
7575 int do_default = !DECL_EXTERNAL (decl);
7576 tree initializer = init ? init : DECL_INITIAL (decl);
7577 int failure = complete_array_type (type, initializer, do_default);
7580 error ("initializer fails to determine size of `%D'", decl);
7585 error ("array size missing in `%D'", decl);
7586 /* If a `static' var's size isn't known, make it extern as
7587 well as static, so it does not get allocated. If it's not
7588 `static', then don't mark it extern; finish_incomplete_decl
7589 will give it a default size and it will get allocated. */
7590 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7591 DECL_EXTERNAL (decl) = 1;
7594 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7595 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7597 error ("zero-size array `%D'", decl);
7599 layout_decl (decl, 0);
7603 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7604 any appropriate error messages regarding the layout. */
7607 layout_var_decl (decl)
7610 tree type = TREE_TYPE (decl);
7612 tree ttype = target_type (type);
7615 /* If we haven't already layed out this declaration, do so now.
7616 Note that we must not call complete type for an external object
7617 because it's type might involve templates that we are not
7618 supposed to isntantiate yet. (And it's perfectly valid to say
7619 `extern X x' for some incomplete type `X'.) */
7620 if (!DECL_EXTERNAL (decl))
7621 complete_type (type);
7622 if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7623 layout_decl (decl, 0);
7625 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7627 /* An automatic variable with an incomplete type: that is an error.
7628 Don't talk about array types here, since we took care of that
7629 message in grokdeclarator. */
7630 error ("storage size of `%D' isn't known", decl);
7631 TREE_TYPE (decl) = error_mark_node;
7634 /* Keep this code around in case we later want to control debug info
7635 based on whether a type is "used". (jason 1999-11-11) */
7637 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7638 /* Let debugger know it should output info for this type. */
7639 note_debug_info_needed (ttype);
7641 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7642 note_debug_info_needed (DECL_CONTEXT (decl));
7645 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7646 && DECL_SIZE (decl) != NULL_TREE
7647 && ! TREE_CONSTANT (DECL_SIZE (decl)))
7649 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7650 constant_expression_warning (DECL_SIZE (decl));
7652 error ("storage size of `%D' isn't constant", decl);
7655 if (TREE_STATIC (decl)
7656 && !DECL_ARTIFICIAL (decl)
7657 && current_function_decl
7658 && DECL_CONTEXT (decl) == current_function_decl)
7659 push_local_name (decl);
7662 /* If a local static variable is declared in an inline function, or if
7663 we have a weak definition, we must endeavor to create only one
7664 instance of the variable at link-time. */
7667 maybe_commonize_var (decl)
7670 /* Static data in a function with comdat linkage also has comdat
7672 if (TREE_STATIC (decl)
7673 /* Don't mess with __FUNCTION__. */
7674 && ! DECL_ARTIFICIAL (decl)
7675 && current_function_decl
7676 && DECL_CONTEXT (decl) == current_function_decl
7677 && (DECL_DECLARED_INLINE_P (current_function_decl)
7678 || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7679 && TREE_PUBLIC (current_function_decl))
7681 /* If flag_weak, we don't need to mess with this, as we can just
7682 make the function weak, and let it refer to its unique local
7683 copy. This works because we don't allow the function to be
7687 if (DECL_INTERFACE_KNOWN (current_function_decl))
7689 TREE_PUBLIC (decl) = 1;
7690 DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7692 else if (DECL_INITIAL (decl) == NULL_TREE
7693 || DECL_INITIAL (decl) == error_mark_node)
7695 TREE_PUBLIC (decl) = 1;
7696 DECL_COMMON (decl) = 1;
7698 /* else we lose. We can only do this if we can use common,
7699 which we can't if it has been initialized. */
7701 if (!TREE_PUBLIC (decl))
7703 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7704 cp_warning_at (" you can work around this by removing the initializer", decl);
7708 comdat_linkage (decl);
7710 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7711 /* Set it up again; we might have set DECL_INITIAL since the last
7713 comdat_linkage (decl);
7716 /* Issue an error message if DECL is an uninitialized const variable. */
7719 check_for_uninitialized_const_var (decl)
7722 tree type = TREE_TYPE (decl);
7724 /* ``Unless explicitly declared extern, a const object does not have
7725 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7727 if (TREE_CODE (decl) == VAR_DECL
7728 && TREE_CODE (type) != REFERENCE_TYPE
7729 && CP_TYPE_CONST_P (type)
7730 && !TYPE_NEEDS_CONSTRUCTING (type)
7731 && !DECL_INITIAL (decl))
7732 error ("uninitialized const `%D'", decl);
7735 /* Verify INIT (the initializer for DECL), and record the
7736 initialization in DECL_INITIAL, if appropriate. Returns a new
7740 check_initializer (decl, init)
7746 if (TREE_CODE (decl) == FIELD_DECL)
7749 type = TREE_TYPE (decl);
7751 /* If `start_decl' didn't like having an initialization, ignore it now. */
7752 if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7755 /* Check the initializer. */
7758 /* Things that are going to be initialized need to have complete
7760 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7762 if (type == error_mark_node)
7763 /* We will have already complained. */
7765 else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7767 error ("variable-sized object `%D' may not be initialized", decl);
7770 else if (TREE_CODE (type) == ARRAY_TYPE
7771 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7773 error ("elements of array `%#D' have incomplete type", decl);
7776 else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7778 error ("`%D' has incomplete type", decl);
7779 TREE_TYPE (decl) = error_mark_node;
7784 if (TREE_CODE (decl) == CONST_DECL)
7786 my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7788 DECL_INITIAL (decl) = init;
7790 my_friendly_assert (init != NULL_TREE, 149);
7793 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7795 init = grok_reference_init (decl, type, init);
7797 init = obscure_complex_init (decl, init);
7799 else if (!DECL_EXTERNAL (decl) && !zero_init_p (type))
7801 force_store_init_value (decl, build_forced_zero_init (type));
7809 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7811 if (TREE_CODE (type) == ARRAY_TYPE)
7812 init = digest_init (type, init, (tree *) 0);
7813 else if (TREE_CODE (init) == CONSTRUCTOR
7814 && TREE_HAS_CONSTRUCTOR (init))
7816 if (TYPE_NON_AGGREGATE_CLASS (type))
7818 error ("`%D' must be initialized by constructor, not by `{...}'",
7820 init = error_mark_node;
7823 goto dont_use_constructor;
7828 dont_use_constructor:
7829 if (TREE_CODE (init) != TREE_VEC)
7830 init = store_init_value (decl, init);
7834 /* We must hide the initializer so that expand_decl
7835 won't try to do something it does not understand. */
7836 init = obscure_complex_init (decl, init);
7838 else if (DECL_EXTERNAL (decl))
7840 else if (TYPE_P (type)
7841 && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7843 tree core_type = strip_array_types (type);
7845 if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7847 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7848 error ("structure `%D' with uninitialized const members", decl);
7849 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7850 error ("structure `%D' with uninitialized reference members",
7854 check_for_uninitialized_const_var (decl);
7856 if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7857 init = obscure_complex_init (decl, NULL_TREE);
7861 check_for_uninitialized_const_var (decl);
7866 /* If DECL is not a local variable, give it RTL. */
7869 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7872 const char *asmspec;
7874 int toplev = toplevel_bindings_p ();
7877 /* Handle non-variables up front. */
7878 if (TREE_CODE (decl) != VAR_DECL)
7880 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7884 /* If we see a class member here, it should be a static data
7886 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7888 my_friendly_assert (TREE_STATIC (decl), 19990828);
7889 /* An in-class declaration of a static data member should be
7890 external; it is only a declaration, and not a definition. */
7891 if (init == NULL_TREE)
7892 my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7895 /* Set the DECL_ASSEMBLER_NAME for the variable. */
7898 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7899 /* The `register' keyword, when used together with an
7900 asm-specification, indicates that the variable should be
7901 placed in a particular register. */
7902 if (DECL_REGISTER (decl))
7903 DECL_C_HARD_REGISTER (decl) = 1;
7906 /* We don't create any RTL for local variables. */
7907 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7910 /* We defer emission of local statics until the corresponding
7911 DECL_STMT is expanded. */
7912 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7914 /* We try to defer namespace-scope static constants so that they are
7915 not emitted into the object file unnecessarily. */
7916 if (!DECL_VIRTUAL_P (decl)
7917 && TREE_READONLY (decl)
7918 && DECL_INITIAL (decl) != NULL_TREE
7919 && DECL_INITIAL (decl) != error_mark_node
7920 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7922 && !TREE_PUBLIC (decl))
7924 /* Fool with the linkage of static consts according to #pragma
7926 if (!interface_unknown && !TREE_PUBLIC (decl))
7928 TREE_PUBLIC (decl) = 1;
7929 DECL_EXTERNAL (decl) = interface_only;
7934 /* Likewise for template instantiations. */
7935 else if (DECL_COMDAT (decl))
7938 /* If we're deferring the variable, we only need to make RTL if
7939 there's an ASMSPEC. Otherwise, we'll lazily create it later when
7940 we need it. (There's no way to lazily create RTL for things that
7941 have assembly specs because the information about the specifier
7942 isn't stored in the tree, yet) */
7943 if (defer_p && asmspec)
7944 make_decl_rtl (decl, asmspec);
7945 /* If we're not deferring, go ahead and assemble the variable. */
7947 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7950 /* The old ARM scoping rules injected variables declared in the
7951 initialization statement of a for-statement into the surrounding
7952 scope. We support this usage, in order to be backward-compatible.
7953 DECL is a just-declared VAR_DECL; if necessary inject its
7954 declaration into the surrounding scope. */
7957 maybe_inject_for_scope_var (decl)
7960 if (!DECL_NAME (decl))
7963 if (current_binding_level->is_for_scope)
7965 struct cp_binding_level *outer
7966 = current_binding_level->level_chain;
7968 /* Check to see if the same name is already bound at the outer
7969 level, either because it was directly declared, or because a
7970 dead for-decl got preserved. In either case, the code would
7971 not have been valid under the ARM scope rules, so clear
7972 is_for_scope for the current_binding_level.
7974 Otherwise, we need to preserve the temp slot for decl to last
7975 into the outer binding level. */
7978 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7980 if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7981 && (TREE_CODE (BINDING_VALUE (outer_binding))
7983 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7985 BINDING_VALUE (outer_binding)
7986 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7987 current_binding_level->is_for_scope = 0;
7989 else if (DECL_IN_MEMORY_P (decl))
7990 preserve_temp_slots (DECL_RTL (decl));
7994 /* Generate code to initialize DECL (a local variable). */
7997 initialize_local_var (decl, init, flags)
8002 tree type = TREE_TYPE (decl);
8004 /* If the type is bogus, don't bother initializing the variable. */
8005 if (type == error_mark_node)
8008 if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
8010 /* If we used it already as memory, it must stay in memory. */
8011 DECL_INITIAL (decl) = NULL_TREE;
8012 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
8015 /* Local statics are handled differently from ordinary automatic
8017 if (TREE_STATIC (decl))
8019 if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8020 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8021 expand_static_init (decl, init);
8025 if (DECL_SIZE (decl) && type != error_mark_node)
8029 /* Compute and store the initial value. */
8030 already_used = TREE_USED (decl) || TREE_USED (type);
8032 if (init || TYPE_NEEDS_CONSTRUCTING (type))
8034 int saved_stmts_are_full_exprs_p;
8036 my_friendly_assert (building_stmt_tree (), 20000906);
8037 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8038 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8039 finish_expr_stmt (build_aggr_init (decl, init, flags));
8040 current_stmt_tree ()->stmts_are_full_exprs_p =
8041 saved_stmts_are_full_exprs_p;
8044 /* Set this to 0 so we can tell whether an aggregate which was
8045 initialized was ever used. Don't do this if it has a
8046 destructor, so we don't complain about the 'resource
8047 allocation is initialization' idiom. Now set
8048 attribute((unused)) on types so decls of that type will be
8049 marked used. (see TREE_USED, above.) */
8050 if (TYPE_NEEDS_CONSTRUCTING (type)
8052 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8053 && DECL_NAME (decl))
8054 TREE_USED (decl) = 0;
8055 else if (already_used)
8056 TREE_USED (decl) = 1;
8060 /* Generate code to destroy DECL (a local variable). */
8063 destroy_local_var (decl)
8066 tree type = TREE_TYPE (decl);
8069 /* Only variables get cleaned up. */
8070 if (TREE_CODE (decl) != VAR_DECL)
8073 /* And only things with destructors need cleaning up. */
8074 if (type == error_mark_node
8075 || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8078 if (TREE_CODE (decl) == VAR_DECL &&
8079 (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8080 /* We don't clean up things that aren't defined in this
8081 translation unit, or that need a static cleanup. The latter
8082 are handled by finish_file. */
8085 /* Compute the cleanup. */
8086 cleanup = cxx_maybe_build_cleanup (decl);
8088 /* Record the cleanup required for this declaration. */
8089 if (DECL_SIZE (decl) && cleanup)
8090 finish_decl_cleanup (decl, cleanup);
8093 /* Finish processing of a declaration;
8094 install its line number and initial value.
8095 If the length of an array type is not known before,
8096 it must be determined now, from the initial value, or it is an error.
8098 INIT holds the value of an initializer that should be allowed to escape
8101 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8102 if the (init) syntax was used. */
8105 cp_finish_decl (decl, init, asmspec_tree, flags)
8111 tree ttype = NULL_TREE;
8112 const char *asmspec = NULL;
8113 int was_readonly = 0;
8118 error ("assignment (not initialization) in declaration");
8122 /* If a name was specified, get the string. */
8123 if (current_binding_level == global_binding_level)
8124 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
8126 asmspec = TREE_STRING_POINTER (asmspec_tree);
8128 if (init && TREE_CODE (init) == NAMESPACE_DECL)
8130 error ("cannot initialize `%D' to namespace `%D'",
8135 if (current_class_type
8136 && CP_DECL_CONTEXT (decl) == current_class_type
8137 && TYPE_BEING_DEFINED (current_class_type)
8138 && (DECL_INITIAL (decl) || init))
8139 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8141 if (TREE_CODE (decl) == VAR_DECL
8142 && DECL_CONTEXT (decl)
8143 && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8144 && DECL_CONTEXT (decl) != current_namespace
8147 /* Leave the namespace of the object. */
8148 pop_decl_namespace ();
8151 type = TREE_TYPE (decl);
8153 if (type == error_mark_node)
8156 if (TYPE_HAS_MUTABLE_P (type))
8157 TREE_READONLY (decl) = 0;
8159 if (processing_template_decl)
8161 /* Add this declaration to the statement-tree. */
8162 if (at_function_scope_p ()
8163 && TREE_CODE (decl) != RESULT_DECL)
8164 add_decl_stmt (decl);
8166 if (init && DECL_INITIAL (decl))
8167 DECL_INITIAL (decl) = init;
8171 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8172 my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8174 /* Take care of TYPE_DECLs up front. */
8175 if (TREE_CODE (decl) == TYPE_DECL)
8177 if (init && DECL_INITIAL (decl))
8179 /* typedef foo = bar; store the type of bar as the type of foo. */
8180 TREE_TYPE (decl) = type = TREE_TYPE (init);
8181 DECL_INITIAL (decl) = init = NULL_TREE;
8183 if (type != error_mark_node
8184 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8186 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8187 warning ("shadowing previous type declaration of `%#D'", decl);
8188 set_identifier_type_value (DECL_NAME (decl), type);
8189 CLASSTYPE_GOT_SEMICOLON (type) = 1;
8192 /* If we have installed this as the canonical typedef for this
8193 type, and that type has not been defined yet, delay emitting
8194 the debug information for it, as we will emit it later. */
8195 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8196 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8197 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8199 rest_of_decl_compilation (decl, NULL,
8200 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8204 if (TREE_CODE (decl) != FUNCTION_DECL)
8205 ttype = target_type (type);
8207 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8208 && TYPE_NEEDS_CONSTRUCTING (type))
8210 /* Currently, GNU C++ puts constants in text space, making them
8211 impossible to initialize. In the future, one would hope for
8212 an operating system which understood the difference between
8213 initialization and the running of a program. */
8215 TREE_READONLY (decl) = 0;
8218 if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8220 /* This must override the asm specifier which was placed by
8221 grokclassfn. Lay this out fresh. */
8222 SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8223 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8224 make_decl_rtl (decl, asmspec);
8227 /* Deduce size of array from initialization, if not already known. */
8228 init = check_initializer (decl, init);
8229 maybe_deduce_size_from_array_init (decl, init);
8231 /* Add this declaration to the statement-tree. This needs to happen
8232 after the call to check_initializer so that the DECL_STMT for a
8233 reference temp is added before the DECL_STMT for the reference itself. */
8234 if (building_stmt_tree ()
8235 && at_function_scope_p ()
8236 && TREE_CODE (decl) != RESULT_DECL)
8237 add_decl_stmt (decl);
8239 if (TREE_CODE (decl) == VAR_DECL)
8240 layout_var_decl (decl);
8242 /* Output the assembler code and/or RTL code for variables and functions,
8243 unless the type is an undefined structure or union.
8244 If not, it will get done when the type is completed. */
8245 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8246 || TREE_CODE (decl) == RESULT_DECL)
8248 if (TREE_CODE (decl) == VAR_DECL)
8249 maybe_commonize_var (decl);
8251 make_rtl_for_nonlocal_decl (decl, init, asmspec);
8253 if (TREE_CODE (type) == FUNCTION_TYPE
8254 || TREE_CODE (type) == METHOD_TYPE)
8255 abstract_virtuals_error (decl,
8256 strip_array_types (TREE_TYPE (type)));
8258 abstract_virtuals_error (decl, strip_array_types (type));
8260 if (TREE_CODE (decl) == FUNCTION_DECL)
8262 else if (DECL_EXTERNAL (decl)
8263 && ! (DECL_LANG_SPECIFIC (decl)
8264 && DECL_NOT_REALLY_EXTERN (decl)))
8267 DECL_INITIAL (decl) = init;
8269 else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8271 /* This is a local declaration. */
8272 if (doing_semantic_analysis_p ())
8273 maybe_inject_for_scope_var (decl);
8274 /* Initialize the local variable. But, if we're building a
8275 statement-tree, we'll do the initialization when we
8277 if (processing_template_decl)
8279 if (init || DECL_INITIAL (decl) == error_mark_node)
8280 DECL_INITIAL (decl) = init;
8284 /* If we're not building RTL, then we need to do so
8286 my_friendly_assert (building_stmt_tree (), 20000906);
8287 /* Initialize the variable. */
8288 initialize_local_var (decl, init, flags);
8289 /* Clean up the variable. */
8290 destroy_local_var (decl);
8293 else if (TREE_STATIC (decl) && type != error_mark_node)
8295 /* Cleanups for static variables are handled by `finish_file'. */
8296 if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8297 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8298 expand_static_init (decl, init);
8302 /* Undo call to `pushclass' that was done in `start_decl'
8303 due to initialization of qualified member variable.
8304 I.e., Foo::x = 10; */
8306 tree context = CP_DECL_CONTEXT (decl);
8309 && (TREE_CODE (decl) == VAR_DECL
8310 /* We also have a pushclass done that we need to undo here
8311 if we're at top level and declare a method. */
8312 || TREE_CODE (decl) == FUNCTION_DECL)
8313 /* If size hasn't been set, we're still defining it,
8314 and therefore inside the class body; don't pop
8315 the binding level.. */
8316 && COMPLETE_TYPE_P (context)
8317 && context == current_class_type)
8318 pop_nested_class ();
8325 TREE_READONLY (decl) = 1;
8328 /* This is here for a midend callback from c-common.c */
8331 finish_decl (decl, init, asmspec_tree)
8335 cp_finish_decl (decl, init, asmspec_tree, 0);
8338 /* Returns a declaration for a VAR_DECL as if:
8340 extern "C" TYPE NAME;
8342 had been seen. Used to create compiler-generated global
8346 declare_global_var (name, type)
8352 push_to_top_level ();
8353 decl = build_decl (VAR_DECL, name, type);
8354 TREE_PUBLIC (decl) = 1;
8355 DECL_EXTERNAL (decl) = 1;
8356 DECL_ARTIFICIAL (decl) = 1;
8358 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8359 pop_from_top_level ();
8364 /* Returns a pointer to the `atexit' function. Note that if
8365 FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8366 `__cxa_atexit' function specified in the IA64 C++ ABI. */
8380 if (flag_use_cxa_atexit)
8382 /* The declaration for `__cxa_atexit' is:
8384 int __cxa_atexit (void (*)(void *), void *, void *)
8386 We build up the argument types and then then function type
8389 /* First, build the pointer-to-function type for the first
8391 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8392 fn_type = build_function_type (void_type_node, arg_types);
8393 fn_ptr_type = build_pointer_type (fn_type);
8394 /* Then, build the rest of the argument types. */
8395 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8396 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8397 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8398 /* And the final __cxa_atexit type. */
8399 fn_type = build_function_type (integer_type_node, arg_types);
8400 fn_ptr_type = build_pointer_type (fn_type);
8401 name = "__cxa_atexit";
8405 /* The declaration for `atexit' is:
8407 int atexit (void (*)());
8409 We build up the argument types and then then function type
8411 fn_type = build_function_type (void_type_node, void_list_node);
8412 fn_ptr_type = build_pointer_type (fn_type);
8413 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8414 /* Build the final atexit type. */
8415 fn_type = build_function_type (integer_type_node, arg_types);
8419 /* Now, build the function declaration. */
8420 push_lang_context (lang_name_c);
8421 atexit_fndecl = build_library_fn_ptr (name, fn_type);
8422 mark_used (atexit_fndecl);
8423 pop_lang_context ();
8424 atexit_node = default_conversion (atexit_fndecl);
8429 /* Returns the __dso_handle VAR_DECL. */
8432 get_dso_handle_node ()
8434 if (dso_handle_node)
8435 return dso_handle_node;
8437 /* Declare the variable. */
8438 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8441 return dso_handle_node;
8444 /* Begin a new function with internal linkage whose job will be simply
8445 to destroy some particular variable. */
8450 static int counter = 0;
8451 int old_interface_unknown = interface_unknown;
8457 push_to_top_level ();
8459 /* No need to mangle this. */
8460 push_lang_context (lang_name_c);
8462 interface_unknown = 1;
8464 /* Build the parameter-types. */
8465 parmtypes = void_list_node;
8466 /* Functions passed to __cxa_atexit take an additional parameter.
8467 We'll just ignore it. After we implement the new calling
8468 convention for destructors, we can eliminate the use of
8469 additional cleanup functions entirely in the -fnew-abi case. */
8470 if (flag_use_cxa_atexit)
8471 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8472 /* Build the function type itself. */
8473 fntype = build_function_type (void_type_node, parmtypes);
8474 /* Build the name of the function. */
8475 sprintf (name, "__tcf_%d", counter++);
8476 /* Build the function declaration. */
8477 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8478 /* It's a function with internal linkage, generated by the
8480 TREE_PUBLIC (fndecl) = 0;
8481 DECL_ARTIFICIAL (fndecl) = 1;
8482 /* Make the function `inline' so that it is only emitted if it is
8483 actually needed. It is unlikely that it will be inlined, since
8484 it is only called via a function pointer, but we avoid unnecessary
8485 emissions this way. */
8486 DECL_INLINE (fndecl) = 1;
8487 /* Build the parameter. */
8488 if (flag_use_cxa_atexit)
8492 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
8493 DECL_CONTEXT (parmdecl) = fndecl;
8494 TREE_USED (parmdecl) = 1;
8495 DECL_ARGUMENTS (fndecl) = parmdecl;
8499 start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8501 interface_unknown = old_interface_unknown;
8503 pop_lang_context ();
8505 return current_function_decl;
8508 /* Finish the cleanup function begun by start_cleanup_fn. */
8513 expand_body (finish_function (0));
8515 pop_from_top_level ();
8518 /* Generate code to handle the destruction of DECL, an object with
8519 static storage duration. */
8522 register_dtor_fn (decl)
8530 int saved_flag_access_control;
8532 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8535 /* Call build_cleanup before we enter the anonymous function so that
8536 any access checks will be done relative to the current scope,
8537 rather than the scope of the anonymous function. */
8538 build_cleanup (decl);
8540 /* Now start the function. */
8541 cleanup = start_cleanup_fn ();
8543 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8544 to the original function, rather than the anonymous one. That
8545 will make the back-end think that nested functions are in use,
8546 which causes confusion. */
8547 saved_flag_access_control = flag_access_control;
8548 flag_access_control = 0;
8549 fcall = build_cleanup (decl);
8550 flag_access_control = saved_flag_access_control;
8552 /* Create the body of the anonymous function. */
8553 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8554 finish_expr_stmt (fcall);
8555 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8558 /* Call atexit with the cleanup function. */
8559 cxx_mark_addressable (cleanup);
8560 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8561 if (flag_use_cxa_atexit)
8563 args = tree_cons (NULL_TREE,
8564 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
8566 args = tree_cons (NULL_TREE, null_pointer_node, args);
8567 args = tree_cons (NULL_TREE, cleanup, args);
8570 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8571 finish_expr_stmt (build_function_call (get_atexit_node (), args));
8575 expand_static_init (decl, init)
8579 tree oldstatic = value_member (decl, static_aggregates);
8583 if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8584 error ("multiple initializations given for `%D'", decl);
8586 else if (! toplevel_bindings_p ())
8588 /* Emit code to perform this initialization but once. */
8595 /* Emit code to perform this initialization but once. This code
8598 static int guard = 0;
8600 // Do initialization.
8602 // Register variable for destruction at end of program.
8605 Note that the `temp' variable is only set to 1 *after* the
8606 initialization is complete. This ensures that an exception,
8607 thrown during the construction, will cause the variable to
8608 reinitialized when we pass through this code again, as per:
8612 If the initialization exits by throwing an exception, the
8613 initialization is not complete, so it will be tried again
8614 the next time control enters the declaration.
8616 In theory, this process should be thread-safe, too; multiple
8617 threads should not be able to initialize the variable more
8618 than once. We don't yet attempt to ensure thread-safety. */
8620 /* Create the guard variable. */
8621 guard = get_guard (decl);
8623 /* Begin the conditional initialization. */
8624 if_stmt = begin_if_stmt ();
8625 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8626 then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8628 /* Do the initialization itself. */
8629 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8630 || (init && TREE_CODE (init) == TREE_LIST))
8631 assignment = build_aggr_init (decl, init, 0);
8633 /* The initialization we're doing here is just a bitwise
8635 assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8637 assignment = NULL_TREE;
8639 /* Once the assignment is complete, set TEMP to 1. Since the
8640 construction of the static object is complete at this point,
8641 we want to make sure TEMP is set to 1 even if a temporary
8642 constructed during the initialization throws an exception
8643 when it is destroyed. So, we combine the initialization and
8644 the assignment to TEMP into a single expression, ensuring
8645 that when we call finish_expr_stmt the cleanups will not be
8646 run until after TEMP is set to 1. */
8647 guard_init = set_guard (guard);
8650 assignment = tree_cons (NULL_TREE, assignment,
8651 build_tree_list (NULL_TREE,
8653 assignment = build_compound_expr (assignment);
8656 assignment = guard_init;
8657 finish_expr_stmt (assignment);
8659 /* Use atexit to register a function for destroying this static
8661 register_dtor_fn (decl);
8663 finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8664 finish_then_clause (if_stmt);
8668 static_aggregates = tree_cons (init, decl, static_aggregates);
8671 /* Finish the declaration of a catch-parameter. */
8674 start_handler_parms (declspecs, declarator)
8681 decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8683 if (decl == NULL_TREE)
8684 error ("invalid catch parameter");
8693 /* Make TYPE a complete type based on INITIAL_VALUE.
8694 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8695 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8698 complete_array_type (type, initial_value, do_default)
8699 tree type, initial_value;
8702 register tree maxindex = NULL_TREE;
8707 /* An array of character type can be initialized from a
8708 brace-enclosed string constant. */
8709 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8710 && TREE_CODE (initial_value) == CONSTRUCTOR
8711 && CONSTRUCTOR_ELTS (initial_value)
8712 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8714 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8715 initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8717 /* Note MAXINDEX is really the maximum index, one less than the
8719 if (TREE_CODE (initial_value) == STRING_CST)
8722 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8723 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8726 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8728 tree elts = CONSTRUCTOR_ELTS (initial_value);
8730 maxindex = ssize_int (-1);
8731 for (; elts; elts = TREE_CHAIN (elts))
8733 if (TREE_PURPOSE (elts))
8734 maxindex = TREE_PURPOSE (elts);
8736 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8738 maxindex = copy_node (maxindex);
8742 /* Make an error message unless that happened already. */
8743 if (initial_value != error_mark_node)
8746 initial_value = NULL_TREE;
8748 /* Prevent further error messages. */
8749 maxindex = build_int_2 (0, 0);
8756 maxindex = build_int_2 (0, 0);
8765 domain = build_index_type (maxindex);
8766 TYPE_DOMAIN (type) = domain;
8768 if (! TREE_TYPE (maxindex))
8769 TREE_TYPE (maxindex) = domain;
8771 itype = TREE_TYPE (initial_value);
8774 if (itype && !TYPE_DOMAIN (itype))
8775 TYPE_DOMAIN (itype) = domain;
8776 /* The type of the main variant should never be used for arrays
8777 of different sizes. It should only ever be completed with the
8778 size of the array. */
8779 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8780 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8783 /* Lay out the type now that we can get the real answer. */
8790 /* Return zero if something is declared to be a member of type
8791 CTYPE when in the context of CUR_TYPE. STRING is the error
8792 message to print in that case. Otherwise, quietly return 1. */
8795 member_function_or_else (ctype, cur_type, flags)
8796 tree ctype, cur_type;
8797 enum overload_flags flags;
8799 if (ctype && ctype != cur_type)
8801 if (flags == DTOR_FLAG)
8802 error ("destructor for alien class `%T' cannot be a member",
8805 error ("constructor for alien class `%T' cannot be a member",
8812 /* Subroutine of `grokdeclarator'. */
8814 /* Generate errors possibly applicable for a given set of specifiers.
8815 This is for ARM $7.1.2. */
8818 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8821 int virtualp, quals, friendp, raises, inlinep;
8824 error ("`%D' declared as a `virtual' %s", object, type);
8826 error ("`%D' declared as an `inline' %s", object, type);
8828 error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8831 cp_error_at ("`%D' declared as a friend", object);
8833 && (TREE_CODE (object) == TYPE_DECL
8834 || (!TYPE_PTRFN_P (TREE_TYPE (object))
8835 && !TYPE_REFFN_P (TREE_TYPE (object))
8836 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
8837 cp_error_at ("`%D' declared with an exception specification", object);
8840 /* CTYPE is class type, or null if non-class.
8841 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8843 DECLARATOR is the function's name.
8844 VIRTUALP is truthvalue of whether the function is virtual or not.
8845 FLAGS are to be passed through to `grokclassfn'.
8846 QUALS are qualifiers indicating whether the function is `const'
8848 RAISES is a list of exceptions that this function can raise.
8849 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8850 not look, and -1 if we should not call `grokclassfn' at all.
8852 Returns `NULL_TREE' if something goes wrong, after issuing
8853 applicable error messages. */
8856 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8857 raises, check, friendp, publicp, inlinep, funcdef_flag,
8858 template_count, in_namespace)
8861 tree orig_declarator;
8863 enum overload_flags flags;
8865 int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8869 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8870 int has_default_arg = 0;
8874 type = build_exception_variant (type, raises);
8876 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8877 /* Propagate volatile out from type to decl. */
8878 if (TYPE_VOLATILE (type))
8879 TREE_THIS_VOLATILE (decl) = 1;
8881 /* If this decl has namespace scope, set that up. */
8883 set_decl_namespace (decl, in_namespace, friendp);
8885 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8887 /* `main' and builtins have implicit 'C' linkage. */
8888 if ((MAIN_NAME_P (declarator)
8889 || (IDENTIFIER_LENGTH (declarator) > 10
8890 && IDENTIFIER_POINTER (declarator)[0] == '_'
8891 && IDENTIFIER_POINTER (declarator)[1] == '_'
8892 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8893 && current_lang_name == lang_name_cplusplus
8894 && ctype == NULL_TREE
8895 /* NULL_TREE means global namespace. */
8896 && DECL_CONTEXT (decl) == NULL_TREE)
8897 SET_DECL_LANGUAGE (decl, lang_c);
8899 /* Should probably propagate const out from type to decl I bet (mrs). */
8902 DECL_STATIC_FUNCTION_P (decl) = 1;
8903 DECL_CONTEXT (decl) = ctype;
8907 DECL_CONTEXT (decl) = ctype;
8909 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8911 if (processing_template_decl)
8912 error ("cannot declare `::main' to be a template");
8914 error ("cannot declare `::main' to be inline");
8916 error ("cannot declare `::main' to be static");
8917 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8919 error ("`main' must return `int'");
8924 /* Members of anonymous types and local classes have no linkage; make
8926 /* FIXME what if it gets a name from typedef? */
8927 if (ctype && (TYPE_ANONYMOUS_P (ctype)
8928 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8933 /* [basic.link]: A name with no linkage (notably, the name of a class
8934 or enumeration declared in a local scope) shall not be used to
8935 declare an entity with linkage.
8937 Only check this for public decls for now. */
8938 t = no_linkage_check (TREE_TYPE (decl));
8941 if (TYPE_ANONYMOUS_P (t))
8943 if (DECL_EXTERN_C_P (decl))
8944 /* Allow this; it's pretty common in C. */;
8947 pedwarn ("non-local function `%#D' uses anonymous type",
8949 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8951 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8956 pedwarn ("non-local function `%#D' uses local type `%T'",
8961 TREE_PUBLIC (decl) = publicp;
8964 DECL_INTERFACE_KNOWN (decl) = 1;
8965 DECL_NOT_REALLY_EXTERN (decl) = 1;
8968 /* If the declaration was declared inline, mark it as such. */
8970 DECL_DECLARED_INLINE_P (decl) = 1;
8971 /* We inline functions that are explicitly declared inline, or, when
8972 the user explicitly asks us to, all functions. */
8973 if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8974 DECL_INLINE (decl) = 1;
8976 DECL_EXTERNAL (decl) = 1;
8977 if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8979 error ("%smember function `%D' cannot have `%T' method qualifier",
8980 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8984 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8985 grok_op_properties (decl, friendp);
8987 if (ctype && decl_function_context (decl))
8988 DECL_NO_STATIC_CHAIN (decl) = 1;
8990 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8991 if (TREE_PURPOSE (t)
8992 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8994 has_default_arg = 1;
8999 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
9003 ("defining explicit specialization `%D' in friend declaration",
9007 tree fns = TREE_OPERAND (orig_declarator, 0);
9008 tree args = TREE_OPERAND (orig_declarator, 1);
9010 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9012 /* Something like `template <class T> friend void f<T>()'. */
9013 error ("invalid use of template-id `%D' in declaration of primary template",
9019 /* A friend declaration of the form friend void f<>(). Record
9020 the information in the TEMPLATE_ID_EXPR. */
9021 SET_DECL_IMPLICIT_INSTANTIATION (decl);
9023 if (TREE_CODE (fns) == COMPONENT_REF)
9025 /* Due to bison parser ickiness, we will have already looked
9026 up an operator_name or PFUNCNAME within the current class
9027 (see template_id in parse.y). If the current class contains
9028 such a name, we'll get a COMPONENT_REF here. Undo that. */
9030 my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
9031 == current_class_type, 20001120);
9032 fns = TREE_OPERAND (fns, 1);
9034 my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
9035 || TREE_CODE (fns) == LOOKUP_EXPR
9036 || TREE_CODE (fns) == OVERLOAD, 20001120);
9037 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
9039 if (has_default_arg)
9041 error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9048 error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9055 if (has_default_arg)
9056 add_defarg_fn (decl);
9059 /* Make the init_value nonzero so pushdecl knows this is not
9060 tentative. error_mark_node is replaced later with the BLOCK. */
9061 DECL_INITIAL (decl) = error_mark_node;
9063 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9064 TREE_NOTHROW (decl) = 1;
9066 /* Caller will do the rest of this. */
9070 if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
9071 DECL_CONSTRUCTOR_P (decl) = 1;
9073 /* Function gets the ugly name, field gets the nice one. This call
9074 may change the type of the function (because of default
9076 if (ctype != NULL_TREE)
9077 grokclassfn (ctype, decl, flags, quals);
9079 decl = check_explicit_specialization (orig_declarator, decl,
9081 2 * (funcdef_flag != 0) +
9082 4 * (friendp != 0));
9083 if (decl == error_mark_node)
9086 if (ctype != NULL_TREE
9087 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9092 old_decl = check_classfn (ctype, decl);
9094 if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9095 /* Because grokfndecl is always supposed to return a
9096 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9097 here. We depend on our callers to figure out that its
9098 really a template that's being returned. */
9099 old_decl = DECL_TEMPLATE_RESULT (old_decl);
9101 if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9102 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9104 /* Remove the `this' parm added by grokclassfn.
9105 XXX Isn't this done in start_function, too? */
9106 revert_static_member_fn (decl);
9107 last_function_parms = TREE_CHAIN (last_function_parms);
9109 if (old_decl && DECL_ARTIFICIAL (old_decl))
9110 error ("definition of implicitly-declared `%D'", old_decl);
9114 /* Since we've smashed OLD_DECL to its
9115 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
9116 if (TREE_CODE (decl) == TEMPLATE_DECL)
9117 decl = DECL_TEMPLATE_RESULT (decl);
9119 /* Attempt to merge the declarations. This can fail, in
9120 the case of some invalid specialization declarations. */
9121 if (!duplicate_decls (decl, old_decl))
9122 error ("no `%#D' member function declared in class `%T'",
9128 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9131 if (ctype == NULL_TREE || check)
9135 DECL_VIRTUAL_P (decl) = 1;
9141 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9144 RID_BIT_TYPE *specbits_in;
9150 RID_BIT_TYPE specbits;
9152 specbits = *specbits_in;
9154 if (TREE_CODE (type) == OFFSET_TYPE)
9156 /* If you declare a static member so that it
9157 can be initialized, the code will reach here. */
9158 tree basetype = TYPE_OFFSET_BASETYPE (type);
9159 type = TREE_TYPE (type);
9160 decl = build_lang_decl (VAR_DECL, declarator, type);
9161 DECL_CONTEXT (decl) = basetype;
9168 context = in_namespace;
9169 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9170 context = current_namespace;
9172 context = NULL_TREE;
9174 /* For namespace-scope variables, declared in a template, we
9175 need the full lang_decl. The same is true for
9176 namespace-scope variables that do not have C++ language
9179 && (processing_template_decl
9180 || current_lang_name != lang_name_cplusplus))
9181 decl = build_lang_decl (VAR_DECL, declarator, type);
9183 decl = build_decl (VAR_DECL, declarator, type);
9186 set_decl_namespace (decl, context, 0);
9188 context = DECL_CONTEXT (decl);
9189 if (declarator && context && current_lang_name != lang_name_c)
9190 /* We can't mangle lazily here because we don't have any
9191 way to recover whether or not a variable was `extern
9197 set_decl_namespace (decl, in_namespace, 0);
9199 if (RIDBIT_SETP (RID_EXTERN, specbits))
9201 DECL_THIS_EXTERN (decl) = 1;
9202 DECL_EXTERNAL (decl) = !initialized;
9205 /* In class context, static means one per class,
9206 public access, and static storage. */
9207 if (DECL_CLASS_SCOPE_P (decl))
9209 TREE_PUBLIC (decl) = 1;
9210 TREE_STATIC (decl) = 1;
9211 DECL_EXTERNAL (decl) = 0;
9213 /* At top level, either `static' or no s.c. makes a definition
9214 (perhaps tentative), and absence of `static' makes it public. */
9215 else if (toplevel_bindings_p ())
9217 TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9218 && (DECL_THIS_EXTERN (decl) || ! constp));
9219 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9221 /* Not at top level, only `static' makes a static definition. */
9224 TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9225 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9228 if (RIDBIT_SETP (RID_THREAD, specbits))
9230 if (targetm.have_tls)
9231 DECL_THREAD_LOCAL (decl) = 1;
9233 /* A mere warning is sure to result in improper semantics
9234 at runtime. Don't bother to allow this to compile. */
9235 error ("thread-local storage not supported for this target");
9238 if (TREE_PUBLIC (decl))
9240 /* [basic.link]: A name with no linkage (notably, the name of a class
9241 or enumeration declared in a local scope) shall not be used to
9242 declare an entity with linkage.
9244 Only check this for public decls for now. */
9245 tree t = no_linkage_check (TREE_TYPE (decl));
9248 if (TYPE_ANONYMOUS_P (t))
9249 /* Ignore for now; `enum { foo } e' is pretty common. */;
9251 pedwarn ("non-local variable `%#D' uses local type `%T'",
9259 /* Create and return a canonical pointer to member function type, for
9260 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9263 build_ptrmemfunc_type (type)
9268 tree unqualified_variant = NULL_TREE;
9270 if (type == error_mark_node)
9273 /* If a canonical type already exists for this type, use it. We use
9274 this method instead of type_hash_canon, because it only does a
9275 simple equality check on the list of field members. */
9277 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9280 /* Make sure that we always have the unqualified pointer-to-member
9282 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9284 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9286 t = make_aggr_type (RECORD_TYPE);
9287 /* Let the front-end know this is a pointer to member function... */
9288 TYPE_PTRMEMFUNC_FLAG (t) = 1;
9289 /* ... and not really an aggregate. */
9290 SET_IS_AGGR_TYPE (t, 0);
9292 fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9293 fields[1] = build_decl (FIELD_DECL, delta_identifier,
9295 finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9297 /* Zap out the name so that the back-end will give us the debugging
9298 information for this anonymous RECORD_TYPE. */
9299 TYPE_NAME (t) = NULL_TREE;
9301 /* If this is not the unqualified form of this pointer-to-member
9302 type, set the TYPE_MAIN_VARIANT for this type to be the
9303 unqualified type. Since they are actually RECORD_TYPEs that are
9304 not variants of each other, we must do this manually. */
9305 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9307 t = build_qualified_type (t, cp_type_quals (type));
9308 TYPE_MAIN_VARIANT (t) = unqualified_variant;
9309 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9310 TYPE_NEXT_VARIANT (unqualified_variant) = t;
9313 /* Cache this pointer-to-member type so that we can find it again
9315 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9317 /* Seems to be wanted. */
9318 CLASSTYPE_GOT_SEMICOLON (t) = 1;
9323 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9324 Check to see that the definition is valid. Issue appropriate error
9325 messages. Return 1 if the definition is particularly bad, or 0
9329 check_static_variable_definition (decl, type)
9333 /* Motion 10 at San Diego: If a static const integral data member is
9334 initialized with an integral constant expression, the initializer
9335 may appear either in the declaration (within the class), or in
9336 the definition, but not both. If it appears in the class, the
9337 member is a member constant. The file-scope definition is always
9339 if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9341 error ("invalid in-class initialization of static data member of non-integral type `%T'",
9343 /* If we just return the declaration, crashes will sometimes
9344 occur. We therefore return void_type_node, as if this was a
9345 friend declaration, to cause callers to completely ignore
9346 this declaration. */
9349 else if (!CP_TYPE_CONST_P (type))
9350 error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9352 else if (pedantic && !INTEGRAL_TYPE_P (type))
9353 pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9358 /* Given the SIZE (i.e., number of elements) in an array, compute an
9359 appropriate index type for the array. If non-NULL, NAME is the
9360 name of the thing being declared. */
9363 compute_array_index_type (name, size)
9369 /* If this involves a template parameter, it will be a constant at
9370 instantiation time, but we don't know what the value is yet.
9371 Even if no template parameters are involved, we may an expression
9372 that is not a constant; we don't even simplify `1 + 2' when
9373 processing a template. */
9374 if (processing_template_decl)
9376 /* Resolve a qualified reference to an enumerator or static
9377 const data member of ours. */
9378 if (TREE_CODE (size) == SCOPE_REF
9379 && TREE_OPERAND (size, 0) == current_class_type)
9381 tree t = lookup_field (current_class_type,
9382 TREE_OPERAND (size, 1), 0, 0);
9387 return build_index_type (build_min (MINUS_EXPR, sizetype,
9388 size, integer_one_node));
9391 /* The size might be the result of a cast. */
9392 STRIP_TYPE_NOPS (size);
9394 /* It might be a const variable or enumeration constant. */
9395 size = decl_constant_value (size);
9397 /* The array bound must be an integer type. */
9398 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9399 && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9400 && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9403 error ("size of array `%D' has non-integer type", name);
9405 error ("size of array has non-integer type");
9406 size = integer_one_node;
9409 /* Normally, the array-bound will be a constant. */
9410 if (TREE_CODE (size) == INTEGER_CST)
9412 /* Check to see if the array bound overflowed. Make that an
9413 error, no matter how generous we're being. */
9414 int old_flag_pedantic_errors = flag_pedantic_errors;
9415 int old_pedantic = pedantic;
9416 pedantic = flag_pedantic_errors = 1;
9417 constant_expression_warning (size);
9418 pedantic = old_pedantic;
9419 flag_pedantic_errors = old_flag_pedantic_errors;
9421 /* An array must have a positive number of elements. */
9422 if (INT_CST_LT (size, integer_zero_node))
9425 error ("size of array `%D' is negative", name);
9427 error ("size of array is negative");
9428 size = integer_one_node;
9430 /* Except that an extension we allow zero-sized arrays. We
9431 always allow them in system headers because glibc uses
9433 else if (integer_zerop (size) && pedantic && !in_system_header)
9436 pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9438 pedwarn ("ISO C++ forbids zero-size array");
9441 else if (TREE_CONSTANT (size))
9443 /* `(int) &fn' is not a valid array bound. */
9445 error ("size of array `%D' is not an integral constant-expression",
9448 error ("size of array is not an integral constant-expression");
9451 /* Compute the index of the largest element in the array. It is
9452 one less than the number of elements in the array. */
9454 = fold (cp_build_binary_op (MINUS_EXPR,
9455 cp_convert (ssizetype, size),
9456 cp_convert (ssizetype,
9457 integer_one_node)));
9459 /* Check for variable-sized arrays. We allow such things as an
9460 extension, even though they are not allowed in ANSI/ISO C++. */
9461 if (!TREE_CONSTANT (itype))
9466 pedwarn ("ISO C++ forbids variable-size array `%D'",
9469 pedwarn ("ISO C++ forbids variable-size array");
9472 /* Create a variable-sized array index type. */
9473 itype = variable_size (itype);
9475 /* Make sure that there was no overflow when creating to a signed
9476 index type. (For example, on a 32-bit machine, an array with
9477 size 2^32 - 1 is too big.) */
9478 else if (TREE_OVERFLOW (itype))
9480 error ("overflow in array dimension");
9481 TREE_OVERFLOW (itype) = 0;
9484 /* Create and return the appropriate index type. */
9485 return build_index_type (itype);
9488 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9489 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9493 create_array_type_for_decl (name, type, size)
9498 tree itype = NULL_TREE;
9499 const char* error_msg;
9501 /* If things have already gone awry, bail now. */
9502 if (type == error_mark_node || size == error_mark_node)
9503 return error_mark_node;
9505 /* Assume that everything will go OK. */
9508 /* There are some types which cannot be array elements. */
9509 switch (TREE_CODE (type))
9512 error_msg = "array of void";
9516 error_msg = "array of functions";
9519 case REFERENCE_TYPE:
9520 error_msg = "array of references";
9524 error_msg = "array of data members";
9528 error_msg = "array of function members";
9535 /* If something went wrong, issue an error-message and return. */
9539 error ("declaration of `%D' as %s", name, error_msg);
9541 error ("creating %s", error_msg);
9543 return error_mark_node;
9548 The constant expressions that specify the bounds of the arrays
9549 can be omitted only for the first member of the sequence. */
9550 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9553 error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9556 error ("multidimensional array must have bounds for all dimensions except the first");
9558 return error_mark_node;
9561 /* Figure out the index type for the array. */
9563 itype = compute_array_index_type (name, size);
9565 return build_cplus_array_type (type, itype);
9568 /* Check that it's OK to declare a function with the indicated TYPE.
9569 SFK indicates the kind of special function (if any) that this
9570 function is. OPTYPE is the type given in a conversion operator
9571 declaration. Returns the actual return type of the function; that
9572 may be different than TYPE if an error occurs, or for certain
9573 special functions. */
9576 check_special_function_return_type (sfk, type, optype)
9577 special_function_kind sfk;
9583 case sfk_constructor:
9585 error ("return type specification for constructor invalid");
9587 type = void_type_node;
9590 case sfk_destructor:
9592 error ("return type specification for destructor invalid");
9593 type = void_type_node;
9596 case sfk_conversion:
9597 if (type && !same_type_p (type, optype))
9598 error ("operator `%T' declared to return `%T'", optype, type);
9600 pedwarn ("return type specified for `operator %T'", optype);
9612 /* Given declspecs and a declarator,
9613 determine the name and type of the object declared
9614 and construct a ..._DECL node for it.
9615 (In one case we can return a ..._TYPE node instead.
9616 For invalid input we sometimes return 0.)
9618 DECLSPECS is a chain of tree_list nodes whose value fields
9619 are the storage classes and type specifiers.
9621 DECL_CONTEXT says which syntactic context this declaration is in:
9622 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9623 FUNCDEF for a function definition. Like NORMAL but a few different
9624 error messages in each case. Return value may be zero meaning
9625 this definition is too screwy to try to parse.
9626 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9627 handle member functions (which have FIELD context).
9628 Return value may be zero meaning this definition is too screwy to
9630 PARM for a parameter declaration (either within a function prototype
9631 or before a function body). Make a PARM_DECL, or return void_type_node.
9632 CATCHPARM for a parameter declaration before a catch clause.
9633 TYPENAME if for a typename (in a cast or sizeof).
9634 Don't make a DECL node; just return the ..._TYPE node.
9635 FIELD for a struct or union field; make a FIELD_DECL.
9636 BITFIELD for a field with specified width.
9637 INITIALIZED is 1 if the decl has an initializer.
9639 ATTRLIST is a pointer to the list of attributes, which may be NULL
9640 if there are none; *ATTRLIST may be modified if attributes from inside
9641 the declarator should be applied to the declaration.
9643 In the TYPENAME case, DECLARATOR is really an abstract declarator.
9644 It may also be so in the PARM case, for a prototype where the
9645 argument type is specified but not the name.
9647 This function is where the complicated C meanings of `static'
9648 and `extern' are interpreted.
9650 For C++, if there is any monkey business to do, the function which
9651 calls this one must do it, i.e., prepending instance variables,
9652 renaming overloaded function names, etc.
9654 Note that for this C++, it is an error to define a method within a class
9655 which does not belong to that class.
9657 Except in the case where SCOPE_REFs are implicitly known (such as
9658 methods within a class being redundantly qualified),
9659 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9660 (class_name::decl_name). The caller must also deal with this.
9662 If a constructor or destructor is seen, and the context is FIELD,
9663 then the type gains the attribute TREE_HAS_x. If such a declaration
9664 is erroneous, NULL_TREE is returned.
9666 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
9667 function, these are the qualifiers to give to the `this' pointer. We
9668 apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9670 May return void_type_node if the declarator turned out to be a friend.
9671 See grokfield for details. */
9674 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9677 enum decl_context decl_context;
9681 RID_BIT_TYPE specbits;
9684 tree type = NULL_TREE;
9687 int virtualp, explicitp, friendp, inlinep, staticp;
9688 int explicit_int = 0;
9689 int explicit_char = 0;
9690 int defaulted_int = 0;
9691 int extern_langp = 0;
9692 tree dependant_name = NULL_TREE;
9694 tree typedef_decl = NULL_TREE;
9696 tree typedef_type = NULL_TREE;
9697 int funcdef_flag = 0;
9698 enum tree_code innermost_code = ERROR_MARK;
9701 /* See the code below that used this. */
9702 tree decl_attr = NULL_TREE;
9704 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9705 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
9706 tree init = NULL_TREE;
9708 /* Keep track of what sort of function is being processed
9709 so that we can warn about default return values, or explicit
9710 return values which do not match prescribed defaults. */
9711 special_function_kind sfk = sfk_none;
9713 tree dname = NULL_TREE;
9714 tree ctype = current_class_type;
9715 tree ctor_return_type = NULL_TREE;
9716 enum overload_flags flags = NO_SPECIAL;
9717 tree quals = NULL_TREE;
9718 tree raises = NULL_TREE;
9719 int template_count = 0;
9720 tree in_namespace = NULL_TREE;
9721 tree returned_attrs = NULL_TREE;
9723 RIDBIT_RESET_ALL (specbits);
9724 if (decl_context == FUNCDEF)
9725 funcdef_flag = 1, decl_context = NORMAL;
9726 else if (decl_context == MEMFUNCDEF)
9727 funcdef_flag = -1, decl_context = FIELD;
9728 else if (decl_context == BITFIELD)
9729 bitfield = 1, decl_context = FIELD;
9731 /* Look inside a declarator for the name being declared
9732 and get it as a string, for an error message. */
9734 tree *next = &declarator;
9738 while (next && *next)
9741 switch (TREE_CODE (decl))
9744 /* For attributes. */
9745 next = &TREE_VALUE (decl);
9750 next = &TREE_OPERAND (decl, 0);
9753 case BIT_NOT_EXPR: /* For C++ destructors! */
9755 tree name = TREE_OPERAND (decl, 0);
9756 tree rename = NULL_TREE;
9758 my_friendly_assert (flags == NO_SPECIAL, 152);
9760 sfk = sfk_destructor;
9761 if (TREE_CODE (name) == TYPE_DECL)
9762 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9763 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9764 if (ctype == NULL_TREE)
9766 if (current_class_type == NULL_TREE)
9768 error ("destructors must be member functions");
9773 tree t = constructor_name (current_class_name);
9780 tree t = constructor_name (ctype);
9787 error ("destructor `%T' must match class name `%T'",
9789 TREE_OPERAND (decl, 0) = rename;
9795 case ADDR_EXPR: /* C++ reference declaration */
9800 innermost_code = TREE_CODE (decl);
9801 next = &TREE_OPERAND (decl, 0);
9805 if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9807 /* This is actually a variable declaration using
9808 constructor syntax. We need to call start_decl and
9809 cp_finish_decl so we can get the variable
9814 *next = TREE_OPERAND (decl, 0);
9815 init = CALL_DECLARATOR_PARMS (decl);
9819 attributes = *attrlist;
9823 attributes = NULL_TREE;
9826 decl = start_decl (declarator, declspecs, 1,
9827 attributes, NULL_TREE);
9828 decl_type_access_control (decl);
9831 /* Look for __unused__ attribute */
9832 if (TREE_USED (TREE_TYPE (decl)))
9833 TREE_USED (decl) = 1;
9834 finish_decl (decl, init, NULL_TREE);
9837 error ("invalid declarator");
9840 innermost_code = TREE_CODE (decl);
9841 if (decl_context == FIELD && ctype == NULL_TREE)
9842 ctype = current_class_type;
9844 && TREE_OPERAND (decl, 0)
9845 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9846 && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 0)),
9848 TREE_OPERAND (decl, 0) = constructor_name (ctype);
9849 next = &TREE_OPERAND (decl, 0);
9851 if (ctype != NULL_TREE
9852 && decl != NULL_TREE && flags != DTOR_FLAG
9853 && decl == constructor_name (ctype))
9855 sfk = sfk_constructor;
9856 ctor_return_type = ctype;
9861 case TEMPLATE_ID_EXPR:
9863 tree fns = TREE_OPERAND (decl, 0);
9865 if (TREE_CODE (fns) == LOOKUP_EXPR)
9866 fns = TREE_OPERAND (fns, 0);
9869 if (TREE_CODE (dname) == COMPONENT_REF)
9870 dname = TREE_OPERAND (dname, 1);
9871 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9873 my_friendly_assert (is_overloaded_fn (dname),
9875 dname = DECL_NAME (get_first_fn (dname));
9880 case IDENTIFIER_NODE:
9881 if (TREE_CODE (decl) == IDENTIFIER_NODE)
9886 if (C_IS_RESERVED_WORD (dname))
9888 error ("declarator-id missing; using reserved word `%D'",
9890 name = IDENTIFIER_POINTER (dname);
9892 else if (!IDENTIFIER_TYPENAME_P (dname))
9893 name = IDENTIFIER_POINTER (dname);
9896 my_friendly_assert (flags == NO_SPECIAL, 154);
9897 flags = TYPENAME_FLAG;
9898 ctor_return_type = TREE_TYPE (dname);
9899 sfk = sfk_conversion;
9900 if (IDENTIFIER_GLOBAL_VALUE (dname)
9901 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9903 name = IDENTIFIER_POINTER (dname);
9905 name = "<invalid operator>";
9912 /* Perform error checking, and decide on a ctype. */
9913 tree cname = TREE_OPERAND (decl, 0);
9914 if (cname == NULL_TREE)
9916 else if (TREE_CODE (cname) == NAMESPACE_DECL)
9919 in_namespace = TREE_OPERAND (decl, 0);
9920 TREE_OPERAND (decl, 0) = NULL_TREE;
9922 else if (! is_aggr_type (cname, 1))
9923 TREE_OPERAND (decl, 0) = NULL_TREE;
9924 /* Must test TREE_OPERAND (decl, 1), in case user gives
9925 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9926 else if (TREE_OPERAND (decl, 1)
9927 && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9929 else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9930 || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9932 /* This might be declaring a member of a template
9933 parm to be a friend. */
9935 dependant_name = TREE_OPERAND (decl, 1);
9937 else if (ctype == NULL_TREE)
9939 else if (TREE_COMPLEXITY (decl) == current_class_depth)
9940 TREE_OPERAND (decl, 0) = ctype;
9943 if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9945 error ("type `%T' is not derived from type `%T'",
9947 TREE_OPERAND (decl, 0) = NULL_TREE;
9953 if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9954 && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 1)),
9956 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9957 next = &TREE_OPERAND (decl, 1);
9961 if (TREE_CODE (decl) == IDENTIFIER_NODE
9962 && constructor_name (ctype) == decl)
9964 sfk = sfk_constructor;
9965 ctor_return_type = ctype;
9967 else if (TREE_CODE (decl) == BIT_NOT_EXPR
9968 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9969 && constructor_name_p (TREE_OPERAND (decl, 0),
9972 sfk = sfk_destructor;
9973 ctor_return_type = ctype;
9975 TREE_OPERAND (decl, 0) = constructor_name (ctype);
9976 next = &TREE_OPERAND (decl, 0);
9987 /* Parse error puts this typespec where
9988 a declarator should go. */
9989 error ("`%T' specified as declarator-id", DECL_NAME (decl));
9990 if (TREE_TYPE (decl) == current_class_type)
9991 error (" perhaps you want `%T' for a constructor",
9992 current_class_name);
9993 dname = DECL_NAME (decl);
9994 name = IDENTIFIER_POINTER (dname);
9996 /* Avoid giving two errors for this. */
9997 IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9999 declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
10005 next = &BASELINK_FUNCTIONS (decl);
10009 internal_error ("`%D' as declarator", decl);
10014 /* A function definition's declarator must have the form of
10015 a function declarator. */
10017 if (funcdef_flag && innermost_code != CALL_EXPR)
10020 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10021 && innermost_code != CALL_EXPR
10022 && ! (ctype && declspecs == NULL_TREE))
10024 error ("declaration of `%D' as non-function", dname);
10025 return void_type_node;
10028 /* Anything declared one level down from the top level
10029 must be one of the parameters of a function
10030 (because the body is at least two levels down). */
10032 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10033 by not allowing C++ class definitions to specify their parameters
10034 with xdecls (must be spec.d in the parmlist).
10036 Since we now wait to push a class scope until we are sure that
10037 we are in a legitimate method context, we must set oldcname
10038 explicitly (since current_class_name is not yet alive).
10040 We also want to avoid calling this a PARM if it is in a namespace. */
10042 if (decl_context == NORMAL && !toplevel_bindings_p ())
10044 struct cp_binding_level *b = current_binding_level;
10045 current_binding_level = b->level_chain;
10046 if (current_binding_level != 0 && toplevel_bindings_p ())
10047 decl_context = PARM;
10048 current_binding_level = b;
10052 name = decl_context == PARM ? "parameter" : "type name";
10054 /* Look through the decl specs and record which ones appear.
10055 Some typespecs are defined as built-in typenames.
10056 Others, the ones that are modifiers of other types,
10057 are represented by bits in SPECBITS: set the bits for
10058 the modifiers that appear. Storage class keywords are also in SPECBITS.
10060 If there is a typedef name or a type, store the type in TYPE.
10061 This includes builtin typedefs such as `int'.
10063 Set EXPLICIT_INT if the type is `int' or `char' and did not
10064 come from a user typedef.
10066 Set LONGLONG if `long' is mentioned twice.
10068 For C++, constructors and destructors have their own fast treatment. */
10070 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10075 /* Certain parse errors slip through. For example,
10076 `int class;' is not caught by the parser. Try
10077 weakly to recover here. */
10078 if (TREE_CODE (spec) != TREE_LIST)
10081 id = TREE_VALUE (spec);
10083 /* If the entire declaration is itself tagged as deprecated then
10084 suppress reports of deprecated items. */
10085 if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10087 if (deprecated_state != DEPRECATED_SUPPRESS)
10088 warn_deprecated_use (id);
10091 if (TREE_CODE (id) == IDENTIFIER_NODE)
10093 if (id == ridpointers[(int) RID_INT]
10094 || id == ridpointers[(int) RID_CHAR]
10095 || id == ridpointers[(int) RID_BOOL]
10096 || id == ridpointers[(int) RID_WCHAR])
10100 if (id == ridpointers[(int) RID_BOOL])
10101 error ("`bool' is now a keyword");
10103 error ("extraneous `%T' ignored", id);
10107 if (id == ridpointers[(int) RID_INT])
10109 else if (id == ridpointers[(int) RID_CHAR])
10111 type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10115 /* C++ aggregate types. */
10116 if (IDENTIFIER_HAS_TYPE_VALUE (id))
10119 error ("multiple declarations `%T' and `%T'", type, id);
10121 type = IDENTIFIER_TYPE_VALUE (id);
10125 for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10127 if (ridpointers[i] == id)
10129 if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10131 if (pedantic && ! in_system_header && warn_long_long)
10132 pedwarn ("ISO C++ does not support `long long'");
10134 error ("`long long long' is too long for GCC");
10138 else if (RIDBIT_SETP (i, specbits))
10139 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10141 /* Diagnose "__thread extern". Recall that this list
10142 is in the reverse order seen in the text. */
10143 if (i == (int)RID_THREAD)
10145 if (RIDBIT_SETP (RID_EXTERN, specbits))
10146 error ("`__thread' before `extern'");
10147 if (RIDBIT_SETP (RID_STATIC, specbits))
10148 error ("`__thread' before `static'");
10151 if (i == (int)RID_EXTERN
10152 && TREE_PURPOSE (spec) == error_mark_node)
10153 /* This extern was part of a language linkage. */
10156 RIDBIT_SET (i, specbits);
10161 else if (TREE_CODE (id) == TYPE_DECL)
10164 error ("multiple declarations `%T' and `%T'", type,
10168 type = TREE_TYPE (id);
10169 TREE_VALUE (spec) = type;
10175 error ("two or more data types in declaration of `%s'", name);
10176 else if (TREE_CODE (id) == IDENTIFIER_NODE)
10178 register tree t = lookup_name (id, 1);
10179 if (!t || TREE_CODE (t) != TYPE_DECL)
10180 error ("`%s' fails to be a typedef or built in type",
10181 IDENTIFIER_POINTER (id));
10184 type = TREE_TYPE (t);
10188 else if (id != error_mark_node)
10189 /* Can't change CLASS nodes into RECORD nodes here! */
10196 /* See the code below that used this. */
10198 decl_attr = DECL_ATTRIBUTES (typedef_decl);
10200 typedef_type = type;
10202 /* No type at all: default to `int', and set DEFAULTED_INT
10203 because it was not a user-defined typedef. */
10205 if (type == NULL_TREE
10206 && (RIDBIT_SETP (RID_SIGNED, specbits)
10207 || RIDBIT_SETP (RID_UNSIGNED, specbits)
10208 || RIDBIT_SETP (RID_LONG, specbits)
10209 || RIDBIT_SETP (RID_SHORT, specbits)))
10211 /* These imply 'int'. */
10212 type = integer_type_node;
10216 if (sfk != sfk_none)
10217 type = check_special_function_return_type (sfk, type,
10219 else if (type == NULL_TREE)
10225 /* We handle `main' specially here, because 'main () { }' is so
10226 common. With no options, it is allowed. With -Wreturn-type,
10227 it is a warning. It is only an error with -pedantic-errors. */
10228 is_main = (funcdef_flag
10229 && dname && MAIN_NAME_P (dname)
10230 && ctype == NULL_TREE
10231 && in_namespace == NULL_TREE
10232 && current_namespace == global_namespace);
10234 if (in_system_header || flag_ms_extensions)
10235 /* Allow it, sigh. */;
10236 else if (pedantic || ! is_main)
10237 pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10239 else if (warn_return_type)
10240 warning ("ISO C++ forbids declaration of `%s' with no type",
10243 type = integer_type_node;
10246 if (type && IMPLICIT_TYPENAME_P (type))
10248 /* The implicit typename extension is deprecated and will be
10249 removed. Warn about its use now. */
10250 warning ("`%T' is implicitly a typename", type);
10251 cp_deprecated ("implicit typename");
10253 /* Now remove its implicitness, so that we don't warn again.
10254 For instance this might be a typedef, and we do not want to
10255 warn on uses of the typedef itself. Simply clearing the
10256 TREE_TYPE is insufficient. */
10257 type = copy_node (type);
10258 TREE_TYPE (type) = NULL_TREE;
10263 /* Now process the modifiers that were specified
10264 and check for invalid combinations. */
10266 /* Long double is a special combination. */
10268 if (RIDBIT_SETP (RID_LONG, specbits)
10269 && TYPE_MAIN_VARIANT (type) == double_type_node)
10271 RIDBIT_RESET (RID_LONG, specbits);
10272 type = build_qualified_type (long_double_type_node,
10273 cp_type_quals (type));
10276 /* Check all other uses of type modifiers. */
10278 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10279 || RIDBIT_SETP (RID_SIGNED, specbits)
10280 || RIDBIT_SETP (RID_LONG, specbits)
10281 || RIDBIT_SETP (RID_SHORT, specbits))
10285 if (TREE_CODE (type) == REAL_TYPE)
10286 error ("short, signed or unsigned invalid for `%s'", name);
10287 else if (TREE_CODE (type) != INTEGER_TYPE)
10288 error ("long, short, signed or unsigned invalid for `%s'", name);
10289 else if (RIDBIT_SETP (RID_LONG, specbits)
10290 && RIDBIT_SETP (RID_SHORT, specbits))
10291 error ("long and short specified together for `%s'", name);
10292 else if ((RIDBIT_SETP (RID_LONG, specbits)
10293 || RIDBIT_SETP (RID_SHORT, specbits))
10295 error ("long or short specified with char for `%s'", name);
10296 else if ((RIDBIT_SETP (RID_LONG, specbits)
10297 || RIDBIT_SETP (RID_SHORT, specbits))
10298 && TREE_CODE (type) == REAL_TYPE)
10299 error ("long or short specified with floating type for `%s'", name);
10300 else if (RIDBIT_SETP (RID_SIGNED, specbits)
10301 && RIDBIT_SETP (RID_UNSIGNED, specbits))
10302 error ("signed and unsigned given together for `%s'", name);
10306 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10308 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10310 if (flag_pedantic_errors)
10315 /* Discard the type modifiers if they are invalid. */
10318 RIDBIT_RESET (RID_UNSIGNED, specbits);
10319 RIDBIT_RESET (RID_SIGNED, specbits);
10320 RIDBIT_RESET (RID_LONG, specbits);
10321 RIDBIT_RESET (RID_SHORT, specbits);
10326 if (RIDBIT_SETP (RID_COMPLEX, specbits)
10327 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10329 error ("complex invalid for `%s'", name);
10330 RIDBIT_RESET (RID_COMPLEX, specbits);
10333 /* Decide whether an integer type is signed or not.
10334 Optionally treat bitfields as signed by default. */
10335 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10338 It is implementation-defined whether a plain (neither
10339 explicitly signed or unsigned) char, short, int, or long
10340 bit-field is signed or unsigned.
10342 Naturally, we extend this to long long as well. Note that
10343 this does not include wchar_t. */
10344 || (bitfield && !flag_signed_bitfields
10345 && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10346 /* A typedef for plain `int' without `signed' can be
10347 controlled just like plain `int', but a typedef for
10348 `signed int' cannot be so controlled. */
10350 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10351 && (TREE_CODE (type) == INTEGER_TYPE
10352 || TREE_CODE (type) == CHAR_TYPE)
10353 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10356 type = long_long_unsigned_type_node;
10357 else if (RIDBIT_SETP (RID_LONG, specbits))
10358 type = long_unsigned_type_node;
10359 else if (RIDBIT_SETP (RID_SHORT, specbits))
10360 type = short_unsigned_type_node;
10361 else if (type == char_type_node)
10362 type = unsigned_char_type_node;
10363 else if (typedef_decl)
10364 type = c_common_unsigned_type (type);
10366 type = unsigned_type_node;
10368 else if (RIDBIT_SETP (RID_SIGNED, specbits)
10369 && type == char_type_node)
10370 type = signed_char_type_node;
10372 type = long_long_integer_type_node;
10373 else if (RIDBIT_SETP (RID_LONG, specbits))
10374 type = long_integer_type_node;
10375 else if (RIDBIT_SETP (RID_SHORT, specbits))
10376 type = short_integer_type_node;
10378 if (RIDBIT_SETP (RID_COMPLEX, specbits))
10380 /* If we just have "complex", it is equivalent to
10381 "complex double", but if any modifiers at all are specified it is
10382 the complex form of TYPE. E.g, "complex short" is
10383 "complex short int". */
10385 if (defaulted_int && ! longlong
10386 && ! (RIDBIT_SETP (RID_LONG, specbits)
10387 || RIDBIT_SETP (RID_SHORT, specbits)
10388 || RIDBIT_SETP (RID_SIGNED, specbits)
10389 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10390 type = complex_double_type_node;
10391 else if (type == integer_type_node)
10392 type = complex_integer_type_node;
10393 else if (type == float_type_node)
10394 type = complex_float_type_node;
10395 else if (type == double_type_node)
10396 type = complex_double_type_node;
10397 else if (type == long_double_type_node)
10398 type = complex_long_double_type_node;
10400 type = build_complex_type (type);
10403 type_quals = TYPE_UNQUALIFIED;
10404 if (RIDBIT_SETP (RID_CONST, specbits))
10405 type_quals |= TYPE_QUAL_CONST;
10406 if (RIDBIT_SETP (RID_VOLATILE, specbits))
10407 type_quals |= TYPE_QUAL_VOLATILE;
10408 if (RIDBIT_SETP (RID_RESTRICT, specbits))
10409 type_quals |= TYPE_QUAL_RESTRICT;
10410 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
10411 error ("qualifiers are not allowed on declaration of `operator %T'",
10414 type_quals |= cp_type_quals (type);
10415 type = cp_build_qualified_type_real
10416 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
10417 ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
10418 /* We might have ignored or rejected some of the qualifiers. */
10419 type_quals = cp_type_quals (type);
10422 inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10423 virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10424 RIDBIT_RESET (RID_VIRTUAL, specbits);
10425 explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10426 RIDBIT_RESET (RID_EXPLICIT, specbits);
10428 if (RIDBIT_SETP (RID_STATIC, specbits))
10429 staticp = 1 + (decl_context == FIELD);
10431 if (virtualp && staticp == 2)
10433 error ("member `%D' cannot be declared both virtual and static",
10437 friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10438 RIDBIT_RESET (RID_FRIEND, specbits);
10440 if (dependant_name && !friendp)
10442 error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
10443 return void_type_node;
10446 /* Warn if two storage classes are given. Default to `auto'. */
10448 if (RIDBIT_ANY_SET (specbits))
10450 if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10451 if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10452 if (RIDBIT_SETP (RID_THREAD, specbits)) nclasses++;
10453 if (decl_context == PARM && nclasses > 0)
10454 error ("storage class specifiers invalid in parameter declarations");
10455 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10457 if (decl_context == PARM)
10458 error ("typedef declaration invalid in parameter declaration");
10461 if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10462 if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10463 if (!nclasses && !friendp && extern_langp)
10467 /* Give error if `virtual' is used outside of class declaration. */
10469 && (current_class_name == NULL_TREE || decl_context != FIELD))
10471 error ("virtual outside class declaration");
10475 /* Static anonymous unions are dealt with here. */
10476 if (staticp && decl_context == TYPENAME
10477 && TREE_CODE (declspecs) == TREE_LIST
10478 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10479 decl_context = FIELD;
10481 /* Warn about storage classes that are invalid for certain
10482 kinds of declarations (parameters, typenames, etc.). */
10484 /* "static __thread" and "extern __thread" are allowed. */
10486 && RIDBIT_SETP (RID_THREAD, specbits)
10487 && (RIDBIT_SETP (RID_EXTERN, specbits)
10488 || RIDBIT_SETP (RID_STATIC, specbits)))
10492 error ("multiple storage classes in declaration of `%s'", name);
10493 else if (decl_context != NORMAL && nclasses > 0)
10495 if ((decl_context == PARM || decl_context == CATCHPARM)
10496 && (RIDBIT_SETP (RID_REGISTER, specbits)
10497 || RIDBIT_SETP (RID_AUTO, specbits)))
10499 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10501 else if (decl_context == FIELD
10502 /* C++ allows static class elements */
10503 && RIDBIT_SETP (RID_STATIC, specbits))
10504 /* C++ also allows inlines and signed and unsigned elements,
10505 but in those cases we don't come in here. */
10509 if (decl_context == FIELD)
10511 tree tmp = NULL_TREE;
10512 register int op = 0;
10516 /* Avoid trying to get an operand off an identifier node. */
10517 if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10520 tmp = TREE_OPERAND (declarator, 0);
10521 op = IDENTIFIER_OPNAME_P (tmp);
10522 if (IDENTIFIER_TYPENAME_P (tmp))
10524 if (IDENTIFIER_GLOBAL_VALUE (tmp)
10525 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10527 name = IDENTIFIER_POINTER (tmp);
10529 name = "<invalid operator>";
10532 error ("storage class specified for %s `%s'",
10533 op ? "member operator" : "field",
10538 if (decl_context == PARM || decl_context == CATCHPARM)
10539 error ("storage class specified for parameter `%s'", name);
10541 error ("storage class specified for typename");
10543 RIDBIT_RESET (RID_REGISTER, specbits);
10544 RIDBIT_RESET (RID_AUTO, specbits);
10545 RIDBIT_RESET (RID_EXTERN, specbits);
10546 RIDBIT_RESET (RID_THREAD, specbits);
10549 else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10551 if (toplevel_bindings_p ())
10553 /* It's common practice (and completely valid) to have a const
10554 be initialized and declared extern. */
10555 if (!(type_quals & TYPE_QUAL_CONST))
10556 warning ("`%s' initialized and declared `extern'", name);
10559 error ("`%s' has both `extern' and initializer", name);
10561 else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10562 && ! toplevel_bindings_p ())
10563 error ("nested function `%s' declared `extern'", name);
10564 else if (toplevel_bindings_p ())
10566 if (RIDBIT_SETP (RID_AUTO, specbits))
10567 error ("top-level declaration of `%s' specifies `auto'", name);
10569 else if (RIDBIT_SETP (RID_THREAD, specbits)
10570 && !RIDBIT_SETP (RID_EXTERN, specbits)
10571 && !RIDBIT_SETP (RID_STATIC, specbits))
10573 error ("function-scope `%s' implicitly auto and declared `__thread'",
10575 RIDBIT_RESET (RID_THREAD, specbits);
10578 if (nclasses > 0 && friendp)
10579 error ("storage class specifiers invalid in friend function declarations");
10581 /* Now figure out the structure of the declarator proper.
10582 Descend through it, creating more complex types, until we reach
10583 the declared identifier (or NULL_TREE, in an absolute declarator). */
10585 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10586 && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10588 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10589 an INDIRECT_REF (for *...),
10590 a CALL_EXPR (for ...(...)),
10591 an identifier (for the name being declared)
10592 or a null pointer (for the place in an absolute declarator
10593 where the name was omitted).
10594 For the last two cases, we have just exited the loop.
10596 For C++ it could also be
10597 a SCOPE_REF (for class :: ...). In this case, we have converted
10598 sensible names to types, and those are the values we use to
10599 qualify the member name.
10600 an ADDR_EXPR (for &...),
10601 a BIT_NOT_EXPR (for destructors)
10603 At this point, TYPE is the type of elements of an array,
10604 or for a function to return, or for a pointer to point to.
10605 After this sequence of ifs, TYPE is the type of the
10606 array or function or pointer, and DECLARATOR has had its
10607 outermost layer removed. */
10609 if (type == error_mark_node)
10611 if (TREE_CODE (declarator) == SCOPE_REF)
10612 declarator = TREE_OPERAND (declarator, 1);
10614 declarator = TREE_OPERAND (declarator, 0);
10617 if (quals != NULL_TREE
10618 && (declarator == NULL_TREE
10619 || TREE_CODE (declarator) != SCOPE_REF))
10621 if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10622 ctype = TYPE_METHOD_BASETYPE (type);
10623 if (ctype != NULL_TREE)
10625 tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10626 grok_method_quals (ctype, dummy, quals);
10627 type = TREE_TYPE (dummy);
10628 ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10633 switch (TREE_CODE (declarator))
10637 /* We encode a declarator with embedded attributes using
10639 tree attrs = TREE_PURPOSE (declarator);
10643 declarator = TREE_VALUE (declarator);
10644 inner_decl = declarator;
10645 while (inner_decl != NULL_TREE
10646 && TREE_CODE (inner_decl) == TREE_LIST)
10647 inner_decl = TREE_VALUE (inner_decl);
10649 if (inner_decl == NULL_TREE
10650 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10651 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10652 if (TREE_CODE (inner_decl) == CALL_EXPR)
10653 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10654 if (TREE_CODE (inner_decl) == ARRAY_REF)
10655 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10656 returned_attrs = decl_attributes (&type,
10657 chainon (returned_attrs, attrs),
10664 register tree size;
10666 size = TREE_OPERAND (declarator, 1);
10668 /* VC++ spells a zero-sized array with []. */
10669 if (size == NULL_TREE && decl_context == FIELD && ! staticp
10670 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10671 size = integer_zero_node;
10673 declarator = TREE_OPERAND (declarator, 0);
10675 type = create_array_type_for_decl (dname, type, size);
10677 /* VLAs never work as fields. */
10678 if (decl_context == FIELD && !processing_template_decl
10679 && TREE_CODE (type) == ARRAY_TYPE
10680 && TYPE_DOMAIN (type) != NULL_TREE
10681 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10683 error ("size of member `%D' is not constant", dname);
10684 /* Proceed with arbitrary constant size, so that offset
10685 computations don't get confused. */
10686 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10698 tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10699 tree inner_decl = TREE_OPERAND (declarator, 0);
10701 /* Declaring a function type.
10702 Make sure we have a valid type for the function to return. */
10704 /* We now know that the TYPE_QUALS don't apply to the
10705 decl, but to its return type. */
10706 type_quals = TYPE_UNQUALIFIED;
10708 /* Warn about some types functions can't return. */
10710 if (TREE_CODE (type) == FUNCTION_TYPE)
10712 error ("`%s' declared as function returning a function", name);
10713 type = integer_type_node;
10715 if (TREE_CODE (type) == ARRAY_TYPE)
10717 error ("`%s' declared as function returning an array", name);
10718 type = integer_type_node;
10721 if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10722 inner_decl = TREE_OPERAND (inner_decl, 1);
10724 if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10725 inner_decl = dname;
10727 /* Pick up type qualifiers which should be applied to `this'. */
10728 quals = CALL_DECLARATOR_QUALS (declarator);
10730 /* Pick up the exception specifications. */
10731 raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10733 /* Say it's a definition only for the CALL_EXPR
10734 closest to the identifier. */
10737 && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10738 || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10739 || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10741 if (ctype == NULL_TREE
10742 && decl_context == FIELD
10744 && (friendp == 0 || dname == current_class_name))
10745 ctype = current_class_type;
10747 if (ctype && sfk == sfk_conversion)
10748 TYPE_HAS_CONVERSION (ctype) = 1;
10749 if (ctype && constructor_name (ctype) == dname)
10751 /* We are within a class's scope. If our declarator name
10752 is the same as the class name, and we are defining
10753 a function, then it is a constructor/destructor, and
10754 therefore returns a void type. */
10756 if (flags == DTOR_FLAG)
10758 /* ISO C++ 12.4/2. A destructor may not be
10759 declared const or volatile. A destructor may
10762 error ("destructor cannot be static member function");
10765 error ("destructors may not be `%s'",
10766 IDENTIFIER_POINTER (TREE_VALUE (quals)));
10769 if (decl_context == FIELD)
10771 if (! member_function_or_else (ctype,
10772 current_class_type,
10774 return void_type_node;
10777 else /* It's a constructor. */
10779 if (explicitp == 1)
10781 /* ISO C++ 12.1. A constructor may not be
10782 declared const or volatile. A constructor may
10783 not be virtual. A constructor may not be
10786 error ("constructor cannot be static member function");
10789 pedwarn ("constructors cannot be declared virtual");
10794 error ("constructors may not be `%s'",
10795 IDENTIFIER_POINTER (TREE_VALUE (quals)));
10799 RID_BIT_TYPE tmp_bits;
10800 memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10801 RIDBIT_RESET (RID_INLINE, tmp_bits);
10802 RIDBIT_RESET (RID_STATIC, tmp_bits);
10803 if (RIDBIT_ANY_SET (tmp_bits))
10804 error ("return value type specifier for constructor ignored");
10806 if (decl_context == FIELD)
10808 if (! member_function_or_else (ctype,
10809 current_class_type,
10811 return void_type_node;
10812 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10813 if (sfk != sfk_constructor)
10817 if (decl_context == FIELD)
10823 error ("can't initialize friend function `%s'", name);
10826 /* Cannot be both friend and virtual. */
10827 error ("virtual functions cannot be friends");
10828 RIDBIT_RESET (RID_FRIEND, specbits);
10831 if (decl_context == NORMAL)
10832 error ("friend declaration not in class definition");
10833 if (current_function_decl && funcdef_flag)
10834 error ("can't define friend function `%s' in a local class definition",
10838 /* Construct the function type and go to the next
10839 inner layer of declarator. */
10841 declarator = TREE_OPERAND (declarator, 0);
10843 /* FIXME: This is where default args should be fully
10846 arg_types = grokparms (inner_parms);
10848 if (declarator && flags == DTOR_FLAG)
10850 /* A destructor declared in the body of a class will
10851 be represented as a BIT_NOT_EXPR. But, we just
10852 want the underlying IDENTIFIER. */
10853 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10854 declarator = TREE_OPERAND (declarator, 0);
10856 if (arg_types != void_list_node)
10858 error ("destructors may not have parameters");
10859 arg_types = void_list_node;
10860 last_function_parms = NULL_TREE;
10864 /* ANSI says that `const int foo ();'
10865 does not make the function foo const. */
10866 type = build_function_type (type, arg_types);
10870 for (t = arg_types; t; t = TREE_CHAIN (t))
10871 if (TREE_PURPOSE (t)
10872 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10874 add_defarg_fn (type);
10883 /* Filter out pointers-to-references and references-to-references.
10884 We can get these if a TYPE_DECL is used. */
10886 if (TREE_CODE (type) == REFERENCE_TYPE)
10888 error ("cannot declare %s to references",
10889 TREE_CODE (declarator) == ADDR_EXPR
10890 ? "references" : "pointers");
10891 declarator = TREE_OPERAND (declarator, 0);
10895 if (TREE_CODE (type) == OFFSET_TYPE
10896 && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10897 || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10899 error ("cannot declare pointer to `%#T' member",
10901 type = TREE_TYPE (type);
10904 /* Merge any constancy or volatility into the target type
10905 for the pointer. */
10907 /* We now know that the TYPE_QUALS don't apply to the decl,
10908 but to the target of the pointer. */
10909 type_quals = TYPE_UNQUALIFIED;
10911 if (TREE_CODE (declarator) == ADDR_EXPR)
10913 if (TREE_CODE (type) == VOID_TYPE)
10914 error ("invalid type: `void &'");
10916 type = build_reference_type (type);
10918 else if (TREE_CODE (type) == METHOD_TYPE)
10919 type = build_ptrmemfunc_type (build_pointer_type (type));
10921 type = build_pointer_type (type);
10923 /* Process a list of type modifier keywords (such as
10924 const or volatile) that were given inside the `*' or `&'. */
10926 if (TREE_TYPE (declarator))
10928 register tree typemodlist;
10934 for (typemodlist = TREE_TYPE (declarator); typemodlist;
10935 typemodlist = TREE_CHAIN (typemodlist))
10937 tree qualifier = TREE_VALUE (typemodlist);
10939 if (qualifier == ridpointers[(int) RID_CONST])
10942 type_quals |= TYPE_QUAL_CONST;
10944 else if (qualifier == ridpointers[(int) RID_VOLATILE])
10947 type_quals |= TYPE_QUAL_VOLATILE;
10949 else if (qualifier == ridpointers[(int) RID_RESTRICT])
10952 type_quals |= TYPE_QUAL_RESTRICT;
10957 error ("invalid type modifier within pointer declarator");
10961 pedwarn ("duplicate `const'");
10963 pedwarn ("duplicate `volatile'");
10965 pedwarn ("duplicate `restrict'");
10966 type = cp_build_qualified_type (type, type_quals);
10967 type_quals = cp_type_quals (type);
10969 declarator = TREE_OPERAND (declarator, 0);
10975 /* We have converted type names to NULL_TREE if the
10976 name was bogus, or to a _TYPE node, if not.
10978 The variable CTYPE holds the type we will ultimately
10979 resolve to. The code here just needs to build
10980 up appropriate member types. */
10981 tree sname = TREE_OPERAND (declarator, 1);
10984 /* Destructors can have their visibilities changed as well. */
10985 if (TREE_CODE (sname) == BIT_NOT_EXPR)
10986 sname = TREE_OPERAND (sname, 0);
10988 if (TREE_COMPLEXITY (declarator) == 0)
10989 /* This needs to be here, in case we are called
10990 multiple times. */ ;
10991 else if (TREE_COMPLEXITY (declarator) == -1)
10992 /* Namespace member. */
10993 pop_decl_namespace ();
10994 else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10995 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10996 else if (! IS_AGGR_TYPE_CODE
10997 (TREE_CODE (TREE_OPERAND (declarator, 0))))
10999 else if (TREE_COMPLEXITY (declarator) == current_class_depth)
11001 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
11002 that refer to ctype. They couldn't be resolved earlier
11003 because we hadn't pushed into the class yet.
11004 Example: resolve 'B<T>::type' in
11005 'B<typename B<T>::type> B<T>::f () { }'. */
11006 if (current_template_parms
11007 && uses_template_parms (type)
11008 && uses_template_parms (current_class_type))
11010 tree args = current_template_args ();
11011 type = tsubst (type, args, tf_error | tf_warning,
11015 /* This pop_nested_class corresponds to the
11016 push_nested_class used to push into class scope for
11017 parsing the argument list of a function decl, in
11019 pop_nested_class ();
11020 TREE_COMPLEXITY (declarator) = current_class_depth;
11025 if (TREE_OPERAND (declarator, 0) == NULL_TREE)
11027 /* We had a reference to a global decl, or
11028 perhaps we were given a non-aggregate typedef,
11029 in which case we cleared this out, and should just
11030 keep going as though it wasn't there. */
11031 declarator = sname;
11034 ctype = TREE_OPERAND (declarator, 0);
11037 while (t != NULL_TREE && CLASS_TYPE_P (t))
11039 /* You're supposed to have one `template <...>'
11040 for every template class, but you don't need one
11041 for a full specialization. For example:
11043 template <class T> struct S{};
11044 template <> struct S<int> { void f(); };
11045 void S<int>::f () {}
11047 is correct; there shouldn't be a `template <>' for
11048 the definition of `S<int>::f'. */
11049 if (CLASSTYPE_TEMPLATE_INFO (t)
11050 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
11051 || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
11052 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
11053 template_count += 1;
11055 t = TYPE_MAIN_DECL (t);
11056 t = DECL_CONTEXT (t);
11059 if (sname == NULL_TREE)
11062 if (TREE_CODE (sname) == IDENTIFIER_NODE)
11064 /* This is the `standard' use of the scoping operator:
11065 basetype :: member . */
11067 if (ctype == current_class_type)
11073 Is this ill-formed? */
11076 pedwarn ("extra qualification `%T::' on member `%s' ignored",
11079 else if (TREE_CODE (type) == FUNCTION_TYPE)
11081 if (current_class_type == NULL_TREE || friendp)
11082 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11083 TYPE_ARG_TYPES (type));
11086 error ("cannot declare member function `%T::%s' within `%T'",
11087 ctype, name, current_class_type);
11088 return void_type_node;
11091 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11092 || COMPLETE_TYPE_P (complete_type (ctype)))
11094 /* Have to move this code elsewhere in this function.
11095 this code is used for i.e., typedef int A::M; M *pm;
11097 It is? How? jason 10/2/94 */
11099 if (current_class_type)
11101 error ("cannot declare member `%T::%s' within `%T'",
11102 ctype, name, current_class_type);
11103 return void_type_node;
11105 type = build_offset_type (ctype, type);
11109 cxx_incomplete_type_error (NULL_TREE, ctype);
11110 return error_mark_node;
11113 declarator = sname;
11115 else if (TREE_CODE (sname) == SCOPE_REF)
11120 declarator = TREE_OPERAND (declarator, 1);
11121 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11122 /* In this case, we will deal with it later. */
11126 if (TREE_CODE (type) == FUNCTION_TYPE)
11127 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11128 TYPE_ARG_TYPES (type));
11130 type = build_offset_type (ctype, type);
11137 declarator = TREE_OPERAND (declarator, 0);
11141 declarator = BASELINK_FUNCTIONS (declarator);
11146 case ENUMERAL_TYPE:
11147 declarator = NULL_TREE;
11151 declarator = NULL_TREE;
11159 if (returned_attrs)
11162 *attrlist = chainon (returned_attrs, *attrlist);
11164 attrlist = &returned_attrs;
11167 /* Now TYPE has the actual type. */
11169 /* Did array size calculations overflow? */
11171 if (TREE_CODE (type) == ARRAY_TYPE
11172 && COMPLETE_TYPE_P (type)
11173 && TREE_OVERFLOW (TYPE_SIZE (type)))
11175 error ("size of array `%s' is too large", name);
11176 /* If we proceed with the array type as it is, we'll eventually
11177 crash in tree_low_cst(). */
11178 type = error_mark_node;
11181 if (explicitp == 1 || (explicitp && friendp))
11183 /* [dcl.fct.spec] The explicit specifier shall only be used in
11184 declarations of constructors within a class definition. */
11185 error ("only declarations of constructors can be `explicit'");
11189 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11191 if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11193 error ("non-member `%s' cannot be declared `mutable'", name);
11194 RIDBIT_RESET (RID_MUTABLE, specbits);
11196 else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11198 error ("non-object member `%s' cannot be declared `mutable'", name);
11199 RIDBIT_RESET (RID_MUTABLE, specbits);
11201 else if (TREE_CODE (type) == FUNCTION_TYPE
11202 || TREE_CODE (type) == METHOD_TYPE)
11204 error ("function `%s' cannot be declared `mutable'", name);
11205 RIDBIT_RESET (RID_MUTABLE, specbits);
11209 error ("static `%s' cannot be declared `mutable'", name);
11210 RIDBIT_RESET (RID_MUTABLE, specbits);
11212 else if (type_quals & TYPE_QUAL_CONST)
11214 error ("const `%s' cannot be declared `mutable'", name);
11215 RIDBIT_RESET (RID_MUTABLE, specbits);
11219 if (declarator == NULL_TREE
11220 || TREE_CODE (declarator) == IDENTIFIER_NODE
11221 || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11222 && (TREE_CODE (type) == FUNCTION_TYPE
11223 || TREE_CODE (type) == METHOD_TYPE)))
11225 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11227 error ("template-id `%D' used as a declarator", declarator);
11228 declarator = dname;
11231 /* Unexpected declarator format. */
11234 /* If this is declaring a typedef name, return a TYPE_DECL. */
11236 if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11240 /* Note that the grammar rejects storage classes
11241 in typenames, fields or parameters. */
11242 if (current_lang_name == lang_name_java)
11243 TYPE_FOR_JAVA (type) = 1;
11245 if (decl_context == FIELD)
11247 if (declarator == constructor_name (current_class_type))
11248 pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11250 decl = build_lang_decl (TYPE_DECL, declarator, type);
11254 decl = build_decl (TYPE_DECL, declarator, type);
11255 if (!current_function_decl)
11256 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11259 /* If the user declares "typedef struct {...} foo" then the
11260 struct will have an anonymous name. Fill that name in now.
11261 Nothing can refer to it, so nothing needs know about the name
11263 if (type != error_mark_node
11265 && TYPE_NAME (type)
11266 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11267 && TYPE_ANONYMOUS_P (type)
11268 /* Don't do this if there are attributes. */
11269 && (!attrlist || !*attrlist)
11270 && cp_type_quals (type) == TYPE_UNQUALIFIED)
11272 tree oldname = TYPE_NAME (type);
11275 /* Replace the anonymous name with the real name everywhere. */
11276 lookup_tag_reverse (type, declarator);
11277 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11278 if (TYPE_NAME (t) == oldname)
11279 TYPE_NAME (t) = decl;
11281 if (TYPE_LANG_SPECIFIC (type))
11282 TYPE_WAS_ANONYMOUS (type) = 1;
11284 /* If this is a typedef within a template class, the nested
11285 type is a (non-primary) template. The name for the
11286 template needs updating as well. */
11287 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11288 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11289 = TYPE_IDENTIFIER (type);
11291 /* FIXME remangle member functions; member functions of a
11292 type with external linkage have external linkage. */
11295 if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11297 cp_error_at ("typedef name may not be class-qualified", decl);
11302 if (ctype == NULL_TREE)
11304 if (TREE_CODE (type) != METHOD_TYPE)
11305 cp_error_at ("invalid type qualifier for non-member function type", decl);
11307 ctype = TYPE_METHOD_BASETYPE (type);
11309 if (ctype != NULL_TREE)
11310 grok_method_quals (ctype, decl, quals);
11313 if (RIDBIT_SETP (RID_SIGNED, specbits)
11314 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11315 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11317 bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11318 inlinep, friendp, raises != NULL_TREE);
11321 error ("typedef declaration includes an initializer");
11326 /* Detect the case of an array type of unspecified size
11327 which came, as such, direct from a typedef name.
11328 We must copy the type, so that the array's domain can be
11329 individually set by the object's initializer. */
11331 if (type && typedef_type
11332 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
11333 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11334 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
11336 /* Detect where we're using a typedef of function type to declare a
11337 function. last_function_parms will not be set, so we must create
11340 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11342 tree decls = NULL_TREE;
11345 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11347 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
11349 TREE_CHAIN (decl) = decls;
11353 last_function_parms = nreverse (decls);
11356 /* If this is a type name (such as, in a cast or sizeof),
11357 compute the type and return it now. */
11359 if (decl_context == TYPENAME)
11361 /* Note that the grammar rejects storage classes
11362 in typenames, fields or parameters. */
11363 if (type_quals != TYPE_UNQUALIFIED)
11364 type_quals = TYPE_UNQUALIFIED;
11366 /* Special case: "friend class foo" looks like a TYPENAME context. */
11369 if (type_quals != TYPE_UNQUALIFIED)
11371 error ("type qualifiers specified for friend class declaration");
11372 type_quals = TYPE_UNQUALIFIED;
11376 error ("`inline' specified for friend class declaration");
11380 /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11381 But don't allow implicit typenames except with a class-key. */
11382 if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11383 || IMPLICIT_TYPENAME_P (type)))
11385 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11386 pedwarn ("template parameters cannot be friends");
11387 else if (TREE_CODE (type) == TYPENAME_TYPE)
11389 friend declaration requires class-key, i.e. `friend class %T::%T'",
11390 constructor_name (current_class_type),
11391 TYPE_IDENTIFIER (type));
11394 friend declaration requires class-key, i.e. `friend %#T'",
11398 /* Only try to do this stuff if we didn't already give up. */
11399 if (type != integer_type_node)
11401 decl_type_access_control (TYPE_NAME (type));
11403 /* A friendly class? */
11404 if (current_class_type)
11405 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11407 error ("trying to make class `%T' a friend of global scope",
11410 type = void_type_node;
11415 if (ctype == NULL_TREE)
11417 if (TREE_CODE (type) != METHOD_TYPE)
11418 error ("invalid qualifiers on non-member function type");
11420 ctype = TYPE_METHOD_BASETYPE (type);
11424 tree dummy = build_decl (TYPE_DECL, declarator, type);
11425 grok_method_quals (ctype, dummy, quals);
11426 type = TREE_TYPE (dummy);
11432 else if (declarator == NULL_TREE && decl_context != PARM
11433 && decl_context != CATCHPARM
11434 && TREE_CODE (type) != UNION_TYPE
11437 error ("abstract declarator `%T' used as declaration", type);
11438 declarator = make_anon_name ();
11441 /* `void' at top level (not within pointer)
11442 is allowed only in typedefs or type names.
11443 We don't complain about parms either, but that is because
11444 a better error message can be made later. */
11446 if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11449 error ("unnamed variable or field declared void");
11450 else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11452 if (IDENTIFIER_OPNAME_P (declarator))
11455 error ("variable or field `%s' declared void", name);
11458 error ("variable or field declared void");
11459 type = integer_type_node;
11462 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11463 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11465 if (decl_context == PARM || decl_context == CATCHPARM)
11467 if (ctype || in_namespace)
11468 error ("cannot use `::' in parameter declaration");
11470 /* A parameter declared as an array of T is really a pointer to T.
11471 One declared as a function is really a pointer to a function.
11472 One declared as a member is really a pointer to member. */
11474 if (TREE_CODE (type) == ARRAY_TYPE)
11476 /* Transfer const-ness of array into that of type pointed to. */
11477 type = build_pointer_type (TREE_TYPE (type));
11478 type_quals = TYPE_UNQUALIFIED;
11480 else if (TREE_CODE (type) == FUNCTION_TYPE)
11481 type = build_pointer_type (type);
11482 else if (TREE_CODE (type) == OFFSET_TYPE)
11483 type = build_pointer_type (type);
11487 register tree decl;
11489 if (decl_context == PARM)
11491 decl = cp_build_parm_decl (declarator, type);
11493 bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11494 inlinep, friendp, raises != NULL_TREE);
11496 else if (decl_context == FIELD)
11498 if (type == error_mark_node)
11500 /* Happens when declaring arrays of sizes which
11501 are error_mark_node, for example. */
11504 else if (in_namespace && !friendp)
11506 /* Something like struct S { int N::j; }; */
11507 error ("invalid use of `::'");
11510 else if (TREE_CODE (type) == FUNCTION_TYPE)
11513 tree function_context;
11515 /* We catch the others as conflicts with the builtin
11517 if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11519 error ("function `%D' cannot be declared friend",
11526 if (ctype == NULL_TREE)
11527 ctype = current_class_type;
11529 if (ctype == NULL_TREE)
11531 error ("can't make `%D' into a method -- not in a class",
11533 return void_type_node;
11536 /* ``A union may [ ... ] not [ have ] virtual functions.''
11538 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11540 error ("function `%D' declared virtual inside a union",
11542 return void_type_node;
11545 if (declarator == ansi_opname (NEW_EXPR)
11546 || declarator == ansi_opname (VEC_NEW_EXPR)
11547 || declarator == ansi_opname (DELETE_EXPR)
11548 || declarator == ansi_opname (VEC_DELETE_EXPR))
11552 error ("`%D' cannot be declared virtual, since it is always static",
11557 else if (staticp < 2)
11558 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11559 TYPE_ARG_TYPES (type));
11562 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11563 function_context = (ctype != NULL_TREE) ?
11564 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11565 publicp = (! friendp || ! staticp)
11566 && function_context == NULL_TREE;
11567 decl = grokfndecl (ctype, type,
11568 TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11569 ? declarator : dname,
11571 virtualp, flags, quals, raises,
11572 friendp ? -1 : 0, friendp, publicp, inlinep,
11573 funcdef_flag, template_count, in_namespace);
11574 if (decl == NULL_TREE)
11577 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11578 /* The decl and setting of decl_attr is also turned off. */
11579 decl = build_decl_attribute_variant (decl, decl_attr);
11582 /* [class.conv.ctor]
11584 A constructor declared without the function-specifier
11585 explicit that can be called with a single parameter
11586 specifies a conversion from the type of its first
11587 parameter to the type of its class. Such a constructor
11588 is called a converting constructor. */
11589 if (explicitp == 2)
11590 DECL_NONCONVERTING_P (decl) = 1;
11591 else if (DECL_CONSTRUCTOR_P (decl))
11593 /* The constructor can be called with exactly one
11594 parameter if there is at least one parameter, and
11595 any subsequent parameters have default arguments.
11596 Ignore any compiler-added parms. */
11597 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11599 if (arg_types == void_list_node
11601 && TREE_CHAIN (arg_types)
11602 && TREE_CHAIN (arg_types) != void_list_node
11603 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11604 DECL_NONCONVERTING_P (decl) = 1;
11607 else if (TREE_CODE (type) == METHOD_TYPE)
11609 /* We only get here for friend declarations of
11610 members of other classes. */
11611 /* All method decls are public, so tell grokfndecl to set
11612 TREE_PUBLIC, also. */
11613 decl = grokfndecl (ctype, type, declarator, declarator,
11614 virtualp, flags, quals, raises,
11615 friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11616 template_count, in_namespace);
11617 if (decl == NULL_TREE)
11620 else if (!staticp && ! processing_template_decl
11621 && !COMPLETE_TYPE_P (complete_type (type))
11622 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11625 error ("field `%D' has incomplete type", declarator);
11627 error ("name `%T' has incomplete type", type);
11629 /* If we're instantiating a template, tell them which
11630 instantiation made the field's type be incomplete. */
11631 if (current_class_type
11632 && TYPE_NAME (current_class_type)
11633 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11634 && declspecs && TREE_VALUE (declspecs)
11635 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11636 error (" in instantiation of template `%T'",
11637 current_class_type);
11639 type = error_mark_node;
11646 error ("`%s' is neither function nor member function; cannot be declared friend",
11647 IDENTIFIER_POINTER (declarator));
11655 /* Friends are treated specially. */
11656 if (ctype == current_class_type)
11657 warning ("member functions are implicitly friends of their class");
11660 tree t = NULL_TREE;
11661 if (decl && DECL_NAME (decl))
11663 if (template_class_depth (current_class_type) == 0)
11666 = check_explicit_specialization
11668 template_count, 2 * (funcdef_flag != 0) + 4);
11669 if (decl == error_mark_node)
11670 return error_mark_node;
11673 t = do_friend (ctype, declarator, decl,
11674 last_function_parms, *attrlist,
11675 flags, quals, funcdef_flag);
11677 if (t && funcdef_flag)
11680 return void_type_node;
11684 /* Structure field. It may not be a function, except for C++ */
11686 if (decl == NULL_TREE)
11692 /* An attempt is being made to initialize a non-static
11693 member. But, from [class.mem]:
11695 4 A member-declarator can contain a
11696 constant-initializer only if it declares a static
11697 member (_class.static_) of integral or enumeration
11698 type, see _class.static.data_.
11700 This used to be relatively common practice, but
11701 the rest of the compiler does not correctly
11702 handle the initialization unless the member is
11703 static so we make it static below. */
11704 pedwarn ("ISO C++ forbids initialization of member `%D'",
11706 pedwarn ("making `%D' static", declarator);
11710 if (uses_template_parms (type))
11711 /* We'll check at instantiation time. */
11713 else if (check_static_variable_definition (declarator,
11715 /* If we just return the declaration, crashes
11716 will sometimes occur. We therefore return
11717 void_type_node, as if this was a friend
11718 declaration, to cause callers to completely
11719 ignore this declaration. */
11720 return void_type_node;
11723 /* 9.2p13 [class.mem] */
11724 if (declarator == constructor_name (current_class_type)
11725 /* The standard does not allow non-static data members
11726 here either, but we agreed at the 10/99 meeting
11727 to change that in TC 1 so that they are allowed in
11728 classes with no user-defined constructors. */
11730 pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11735 /* C++ allows static class members. All other work
11736 for this is done by grokfield. */
11737 decl = build_lang_decl (VAR_DECL, declarator, type);
11738 TREE_STATIC (decl) = 1;
11739 /* In class context, 'static' means public access. */
11740 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11744 decl = build_decl (FIELD_DECL, declarator, type);
11745 DECL_NONADDRESSABLE_P (decl) = bitfield;
11746 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11748 DECL_MUTABLE_P (decl) = 1;
11749 RIDBIT_RESET (RID_MUTABLE, specbits);
11753 bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11754 inlinep, friendp, raises != NULL_TREE);
11757 else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11759 tree original_name;
11765 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11766 original_name = dname;
11768 original_name = declarator;
11770 if (RIDBIT_SETP (RID_AUTO, specbits))
11771 error ("storage class `auto' invalid for function `%s'", name);
11772 else if (RIDBIT_SETP (RID_REGISTER, specbits))
11773 error ("storage class `register' invalid for function `%s'", name);
11774 else if (RIDBIT_SETP (RID_THREAD, specbits))
11775 error ("storage class `__thread' invalid for function `%s'", name);
11777 /* Function declaration not at top level.
11778 Storage classes other than `extern' are not allowed
11779 and `extern' makes no difference. */
11780 if (! toplevel_bindings_p ()
11781 && (RIDBIT_SETP (RID_STATIC, specbits)
11782 || RIDBIT_SETP (RID_INLINE, specbits))
11785 if (RIDBIT_SETP (RID_STATIC, specbits))
11786 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11788 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11791 if (ctype == NULL_TREE)
11795 error ("virtual non-class function `%s'", name);
11799 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11800 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11801 TYPE_ARG_TYPES (type));
11803 /* Record presence of `static'. */
11804 publicp = (ctype != NULL_TREE
11805 || RIDBIT_SETP (RID_EXTERN, specbits)
11806 || !RIDBIT_SETP (RID_STATIC, specbits));
11808 decl = grokfndecl (ctype, type, original_name, declarator,
11809 virtualp, flags, quals, raises,
11811 publicp, inlinep, funcdef_flag,
11812 template_count, in_namespace);
11813 if (decl == NULL_TREE)
11818 int invalid_static = 0;
11820 /* Don't allow a static member function in a class, and forbid
11821 declaring main to be static. */
11822 if (TREE_CODE (type) == METHOD_TYPE)
11824 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11825 invalid_static = 1;
11827 else if (current_function_decl)
11829 /* FIXME need arm citation */
11830 error ("cannot declare static function inside another function");
11831 invalid_static = 1;
11834 if (invalid_static)
11837 RIDBIT_RESET (RID_STATIC, specbits);
11843 /* It's a variable. */
11845 /* An uninitialized decl with `extern' is a reference. */
11846 decl = grokvardecl (type, declarator, &specbits,
11848 (type_quals & TYPE_QUAL_CONST) != 0,
11850 bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11851 inlinep, friendp, raises != NULL_TREE);
11855 DECL_CONTEXT (decl) = ctype;
11858 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11860 RIDBIT_RESET (RID_STATIC, specbits);
11862 if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11864 error ("static member `%D' declared `register'", decl);
11865 RIDBIT_RESET (RID_REGISTER, specbits);
11867 if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11869 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11871 RIDBIT_RESET (RID_EXTERN, specbits);
11876 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11878 /* Record `register' declaration for warnings on &
11879 and in case doing stupid register allocation. */
11881 if (RIDBIT_SETP (RID_REGISTER, specbits))
11882 DECL_REGISTER (decl) = 1;
11884 if (RIDBIT_SETP (RID_EXTERN, specbits))
11885 DECL_THIS_EXTERN (decl) = 1;
11887 if (RIDBIT_SETP (RID_STATIC, specbits))
11888 DECL_THIS_STATIC (decl) = 1;
11890 /* Record constancy and volatility. There's no need to do this
11891 when processing a template; we'll do this for the instantiated
11892 declaration based on the type of DECL. */
11893 if (!processing_template_decl)
11894 c_apply_type_quals_to_decl (type_quals, decl);
11900 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11901 An empty exprlist is a parmlist. An exprlist which
11902 contains only identifiers at the global level
11903 is a parmlist. Otherwise, it is an exprlist. */
11906 parmlist_is_exprlist (exprs)
11909 if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11912 if (toplevel_bindings_p ())
11914 /* At the global level, if these are all identifiers,
11915 then it is a parmlist. */
11918 if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11920 exprs = TREE_CHAIN (exprs);
11927 /* Subroutine of start_function. Ensure that each of the parameter
11928 types (as listed in PARMS) is complete, as is required for a
11929 function definition. */
11932 require_complete_types_for_parms (parms)
11935 for (; parms; parms = TREE_CHAIN (parms))
11937 if (VOID_TYPE_P (TREE_TYPE (parms)))
11938 /* grokparms will have already issued an error */
11939 TREE_TYPE (parms) = error_mark_node;
11940 else if (complete_type_or_else (TREE_TYPE (parms), parms))
11941 layout_decl (parms, 0);
11943 TREE_TYPE (parms) = error_mark_node;
11947 /* Returns non-zero if T is a local variable. */
11950 local_variable_p (t)
11953 if ((TREE_CODE (t) == VAR_DECL
11954 /* A VAR_DECL with a context that is a _TYPE is a static data
11956 && !TYPE_P (CP_DECL_CONTEXT (t))
11957 /* Any other non-local variable must be at namespace scope. */
11958 && !DECL_NAMESPACE_SCOPE_P (t))
11959 || (TREE_CODE (t) == PARM_DECL))
11965 /* Returns non-zero if T is an automatic local variable or a label.
11966 (These are the declarations that need to be remapped when the code
11967 containing them is duplicated.) */
11970 nonstatic_local_decl_p (t)
11973 return ((local_variable_p (t) && !TREE_STATIC (t))
11974 || TREE_CODE (t) == LABEL_DECL
11975 || TREE_CODE (t) == RESULT_DECL);
11978 /* Like local_variable_p, but suitable for use as a tree-walking
11982 local_variable_p_walkfn (tp, walk_subtrees, data)
11984 int *walk_subtrees ATTRIBUTE_UNUSED;
11985 void *data ATTRIBUTE_UNUSED;
11987 return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11988 ? *tp : NULL_TREE);
11991 /* Check that ARG, which is a default-argument expression for a
11992 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11993 something goes wrong. DECL may also be a _TYPE node, rather than a
11994 DECL, if there is no DECL available. */
11997 check_default_argument (decl, arg)
12004 if (TREE_CODE (arg) == DEFAULT_ARG)
12005 /* We get a DEFAULT_ARG when looking at an in-class declaration
12006 with a default argument. Ignore the argument for now; we'll
12007 deal with it after the class is complete. */
12010 if (processing_template_decl || uses_template_parms (arg))
12011 /* We don't do anything checking until instantiation-time. Note
12012 that there may be uninstantiated arguments even for an
12013 instantiated function, since default arguments are not
12014 instantiated until they are needed. */
12023 decl_type = TREE_TYPE (decl);
12025 if (arg == error_mark_node
12026 || decl == error_mark_node
12027 || TREE_TYPE (arg) == error_mark_node
12028 || decl_type == error_mark_node)
12029 /* Something already went wrong. There's no need to check
12031 return error_mark_node;
12033 /* [dcl.fct.default]
12035 A default argument expression is implicitly converted to the
12037 if (!TREE_TYPE (arg)
12038 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
12041 error ("default argument for `%#D' has type `%T'",
12042 decl, TREE_TYPE (arg));
12044 error ("default argument for parameter of type `%T' has type `%T'",
12045 decl_type, TREE_TYPE (arg));
12047 return error_mark_node;
12050 /* [dcl.fct.default]
12052 Local variables shall not be used in default argument
12055 The keyword `this' shall not be used in a default argument of a
12056 member function. */
12057 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
12061 error ("default argument `%E' uses local variable `%D'",
12063 return error_mark_node;
12070 /* Decode the list of parameter types for a function type.
12071 Given the list of things declared inside the parens,
12072 return a list of types.
12074 We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
12075 flag. If unset, we append void_list_node. A parmlist declared
12076 as `(void)' is accepted as the empty parmlist.
12078 Also set last_function_parms to the chain of PARM_DECLs. */
12081 grokparms (first_parm)
12084 tree result = NULL_TREE;
12085 tree decls = NULL_TREE;
12086 int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
12090 my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
12092 for (parm = first_parm; parm != NULL_TREE; parm = chain)
12094 tree type = NULL_TREE;
12095 tree decl = TREE_VALUE (parm);
12096 tree init = TREE_PURPOSE (parm);
12099 chain = TREE_CHAIN (parm);
12100 /* @@ weak defense against parse errors. */
12101 if (TREE_CODE (decl) != VOID_TYPE
12102 && TREE_CODE (decl) != TREE_LIST)
12104 /* Give various messages as the need arises. */
12105 if (TREE_CODE (decl) == STRING_CST)
12106 error ("invalid string constant `%E'", decl);
12107 else if (TREE_CODE (decl) == INTEGER_CST)
12108 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12112 if (parm == void_list_node)
12115 split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
12116 decl = grokdeclarator (TREE_VALUE (decl), specs,
12117 PARM, init != NULL_TREE, &attrs);
12118 if (! decl || TREE_TYPE (decl) == error_mark_node)
12122 cplus_decl_attributes (&decl, attrs, 0);
12124 type = TREE_TYPE (decl);
12125 if (VOID_TYPE_P (type))
12127 if (same_type_p (type, void_type_node)
12128 && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12129 /* this is a parmlist of `(void)', which is ok. */
12131 cxx_incomplete_type_error (decl, type);
12132 /* It's not a good idea to actually create parameters of
12133 type `void'; other parts of the compiler assume that a
12134 void type terminates the parameter list. */
12135 type = error_mark_node;
12136 TREE_TYPE (decl) = error_mark_node;
12139 if (type != error_mark_node)
12141 /* Top-level qualifiers on the parameters are
12142 ignored for function types. */
12143 type = TYPE_MAIN_VARIANT (type);
12144 if (TREE_CODE (type) == METHOD_TYPE)
12146 error ("parameter `%D' invalidly declared method type", decl);
12147 type = build_pointer_type (type);
12148 TREE_TYPE (decl) = type;
12150 else if (TREE_CODE (type) == OFFSET_TYPE)
12152 error ("parameter `%D' invalidly declared offset type", decl);
12153 type = build_pointer_type (type);
12154 TREE_TYPE (decl) = type;
12156 else if (abstract_virtuals_error (decl, type))
12157 any_error = 1; /* Seems like a good idea. */
12158 else if (POINTER_TYPE_P (type))
12160 /* [dcl.fct]/6, parameter types cannot contain pointers
12161 (references) to arrays of unknown bound. */
12162 tree t = TREE_TYPE (type);
12163 int ptr = TYPE_PTR_P (type);
12167 if (TYPE_PTR_P (t))
12169 else if (TREE_CODE (t) != ARRAY_TYPE)
12171 else if (!TYPE_DOMAIN (t))
12175 if (TREE_CODE (t) == ARRAY_TYPE)
12176 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12177 decl, ptr ? "pointer" : "reference", t);
12180 if (!any_error && init)
12181 init = check_default_argument (decl, init);
12186 TREE_CHAIN (decl) = decls;
12188 result = tree_cons (init, type, result);
12190 decls = nreverse (decls);
12191 result = nreverse (result);
12193 result = chainon (result, void_list_node);
12194 last_function_parms = decls;
12200 /* D is a constructor or overloaded `operator='.
12202 Let T be the class in which D is declared. Then, this function
12205 -1 if D's is an ill-formed constructor or copy assignment operator
12206 whose first parameter is of type `T'.
12207 0 if D is not a copy constructor or copy assignment
12209 1 if D is a copy constructor or copy assignment operator whose
12210 first parameter is a reference to const qualified T.
12211 2 if D is a copy constructor or copy assignment operator whose
12212 first parameter is a reference to non-const qualified T.
12214 This function can be used as a predicate. Positive values indicate
12215 a copy constructor and non-zero values indicate a copy assignment
12226 my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12228 if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12229 /* Instantiations of template member functions are never copy
12230 functions. Note that member functions of templated classes are
12231 represented as template functions internally, and we must
12232 accept those as copy functions. */
12235 args = FUNCTION_FIRST_USER_PARMTYPE (d);
12239 arg_type = TREE_VALUE (args);
12241 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12243 /* Pass by value copy assignment operator. */
12246 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12247 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12249 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12255 args = TREE_CHAIN (args);
12257 if (args && args != void_list_node && !TREE_PURPOSE (args))
12258 /* There are more non-optional args. */
12264 /* Remember any special properties of member function DECL. */
12266 void grok_special_member_properties (decl)
12269 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12270 ; /* Not special. */
12271 else if (DECL_CONSTRUCTOR_P (decl))
12273 int ctor = copy_fn_p (decl);
12279 A non-template constructor for class X is a copy
12280 constructor if its first parameter is of type X&, const
12281 X&, volatile X& or const volatile X&, and either there
12282 are no other parameters or else all other parameters have
12283 default arguments. */
12284 TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12286 TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12288 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12289 TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12291 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12295 A non-template assignment operator for class X is a copy
12296 assignment operator if its parameter is of type X, X&, const
12297 X&, volatile X& or const volatile X&. */
12299 int assop = copy_fn_p (decl);
12303 TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12305 TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12306 if (DECL_PURE_VIRTUAL_P (decl))
12307 TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12312 /* Check a constructor DECL has the correct form. Complains
12313 if the class has a constructor of the form X(X). */
12316 grok_ctor_properties (ctype, decl)
12319 int ctor_parm = copy_fn_p (decl);
12325 A declaration of a constructor for a class X is ill-formed if
12326 its first parameter is of type (optionally cv-qualified) X
12327 and either there are no other parameters or else all other
12328 parameters have default arguments.
12330 We *don't* complain about member template instantiations that
12331 have this form, though; they can occur as we try to decide
12332 what constructor to use during overload resolution. Since
12333 overload resolution will never prefer such a constructor to
12334 the non-template copy constructor (which is either explicitly
12335 or implicitly defined), there's no need to worry about their
12336 existence. Theoretically, they should never even be
12337 instantiated, but that's hard to forestall. */
12338 error ("invalid constructor; you probably meant `%T (const %T&)'",
12340 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12347 /* An operator with this code is unary, but can also be binary. */
12351 enum tree_code code;
12353 return (code == INDIRECT_REF
12354 || code == ADDR_EXPR
12355 || code == CONVERT_EXPR
12356 || code == NEGATE_EXPR
12357 || code == PREINCREMENT_EXPR
12358 || code == PREDECREMENT_EXPR);
12361 /* An operator with this name can only be unary. */
12365 enum tree_code code;
12367 return (code == TRUTH_NOT_EXPR
12368 || code == BIT_NOT_EXPR
12369 || code == COMPONENT_REF
12370 || code == TYPE_EXPR);
12373 /* Do a little sanity-checking on how they declared their operator. */
12376 grok_op_properties (decl, friendp)
12380 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12382 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12383 tree name = DECL_NAME (decl);
12384 enum tree_code operator_code;
12387 /* Count the number of arguments. */
12388 for (argtype = argtypes, arity = 0;
12389 argtype && argtype != void_list_node;
12390 argtype = TREE_CHAIN (argtype))
12393 if (current_class_type == NULL_TREE)
12396 if (DECL_CONV_FN_P (decl))
12397 operator_code = TYPE_EXPR;
12401 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
12402 if (ansi_opname (CODE) == name) \
12404 operator_code = (CODE); \
12407 else if (ansi_assopname (CODE) == name) \
12409 operator_code = (CODE); \
12410 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12414 #include "operators.def"
12415 #undef DEF_OPERATOR
12420 my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12421 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12425 switch (operator_code)
12428 TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12432 TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12435 case COMPONENT_REF:
12437 TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12441 TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12445 TYPE_GETS_DELETE (current_class_type) |= 1;
12449 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12452 case VEC_DELETE_EXPR:
12453 TYPE_GETS_DELETE (current_class_type) |= 2;
12461 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12463 /* When the compiler encounters the definition of A::operator new, it
12464 doesn't look at the class declaration to find out if it's static. */
12466 revert_static_member_fn (decl);
12468 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12470 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12473 revert_static_member_fn (decl);
12475 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12479 /* An operator function must either be a non-static member function
12480 or have at least one parameter of a class, a reference to a class,
12481 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12482 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12484 if (operator_code == TYPE_EXPR
12485 || operator_code == CALL_EXPR
12486 || operator_code == COMPONENT_REF
12487 || operator_code == ARRAY_REF
12488 || operator_code == NOP_EXPR)
12489 error ("`%D' must be a nonstatic member function", decl);
12494 if (DECL_STATIC_FUNCTION_P (decl))
12495 error ("`%D' must be either a non-static member function or a non-member function", decl);
12498 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12500 tree arg = TREE_VALUE (p);
12501 if (TREE_CODE (arg) == REFERENCE_TYPE)
12502 arg = TREE_TYPE (arg);
12504 /* This lets bad template code slip through. */
12505 if (IS_AGGR_TYPE (arg)
12506 || TREE_CODE (arg) == ENUMERAL_TYPE
12507 || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12508 || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12512 ("`%D' must have an argument of class or enumerated type",
12519 if (operator_code == CALL_EXPR)
12520 return; /* No restrictions on args. */
12522 if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12524 tree t = TREE_TYPE (name);
12527 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12528 const char *what = 0;
12531 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12533 if (TREE_CODE (t) == VOID_TYPE)
12535 else if (t == current_class_type)
12536 what = "the same type";
12537 /* Don't force t to be complete here. */
12538 else if (IS_AGGR_TYPE (t)
12539 && COMPLETE_TYPE_P (t)
12540 && DERIVED_FROM_P (t, current_class_type))
12541 what = "a base class";
12544 warning ("conversion to %s%s will never use a type conversion operator",
12545 ref ? "a reference to " : "", what);
12548 if (operator_code == COND_EXPR)
12551 error ("ISO C++ prohibits overloading operator ?:");
12553 else if (ambi_op_p (operator_code))
12556 /* We pick the one-argument operator codes by default, so
12557 we don't have to change anything. */
12559 else if (arity == 2)
12561 /* If we thought this was a unary operator, we now know
12562 it to be a binary operator. */
12563 switch (operator_code)
12566 operator_code = MULT_EXPR;
12570 operator_code = BIT_AND_EXPR;
12574 operator_code = PLUS_EXPR;
12578 operator_code = MINUS_EXPR;
12581 case PREINCREMENT_EXPR:
12582 operator_code = POSTINCREMENT_EXPR;
12585 case PREDECREMENT_EXPR:
12586 operator_code = POSTDECREMENT_EXPR;
12593 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12595 if ((operator_code == POSTINCREMENT_EXPR
12596 || operator_code == POSTDECREMENT_EXPR)
12597 && ! processing_template_decl
12598 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12601 error ("postfix `%D' must take `int' as its argument",
12605 ("postfix `%D' must take `int' as its second argument",
12612 error ("`%D' must take either zero or one argument", decl);
12614 error ("`%D' must take either one or two arguments", decl);
12617 /* More Effective C++ rule 6. */
12619 && (operator_code == POSTINCREMENT_EXPR
12620 || operator_code == POSTDECREMENT_EXPR
12621 || operator_code == PREINCREMENT_EXPR
12622 || operator_code == PREDECREMENT_EXPR))
12624 tree arg = TREE_VALUE (argtypes);
12625 tree ret = TREE_TYPE (TREE_TYPE (decl));
12626 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12627 arg = TREE_TYPE (arg);
12628 arg = TYPE_MAIN_VARIANT (arg);
12629 if (operator_code == PREINCREMENT_EXPR
12630 || operator_code == PREDECREMENT_EXPR)
12632 if (TREE_CODE (ret) != REFERENCE_TYPE
12633 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12635 warning ("prefix `%D' should return `%T'", decl,
12636 build_reference_type (arg));
12640 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12641 warning ("postfix `%D' should return `%T'", decl, arg);
12645 else if (unary_op_p (operator_code))
12650 error ("`%D' must take `void'", decl);
12652 error ("`%D' must take exactly one argument", decl);
12655 else /* if (binary_op_p (operator_code)) */
12660 error ("`%D' must take exactly one argument", decl);
12662 error ("`%D' must take exactly two arguments", decl);
12665 /* More Effective C++ rule 7. */
12667 && (operator_code == TRUTH_ANDIF_EXPR
12668 || operator_code == TRUTH_ORIF_EXPR
12669 || operator_code == COMPOUND_EXPR))
12670 warning ("user-defined `%D' always evaluates both arguments",
12674 /* Effective C++ rule 23. */
12677 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12678 && (operator_code == PLUS_EXPR
12679 || operator_code == MINUS_EXPR
12680 || operator_code == TRUNC_DIV_EXPR
12681 || operator_code == MULT_EXPR
12682 || operator_code == TRUNC_MOD_EXPR)
12683 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12684 warning ("`%D' should return by value", decl);
12686 /* [over.oper]/8 */
12687 for (; argtypes && argtypes != void_list_node;
12688 argtypes = TREE_CHAIN (argtypes))
12689 if (TREE_PURPOSE (argtypes))
12691 TREE_PURPOSE (argtypes) = NULL_TREE;
12692 if (operator_code == POSTINCREMENT_EXPR
12693 || operator_code == POSTDECREMENT_EXPR)
12696 pedwarn ("`%D' cannot have default arguments", decl);
12699 error ("`%D' cannot have default arguments", decl);
12705 static const char *
12707 enum tag_types code;
12724 /* Get the struct, enum or union (CODE says which) with tag NAME.
12725 Define the tag as a forward-reference if it is not defined.
12727 C++: If a class derivation is given, process it here, and report
12728 an error if multiple derivation declarations are not identical.
12730 If this is a definition, come in through xref_tag and only look in
12731 the current frame for the name (since C++ allows new names in any
12735 xref_tag (enum tag_types tag_code, tree name, tree attributes,
12738 enum tree_code code;
12739 register tree ref, t;
12740 struct cp_binding_level *b = current_binding_level;
12741 tree context = NULL_TREE;
12747 code = RECORD_TYPE;
12753 code = ENUMERAL_TYPE;
12759 /* If a cross reference is requested, look up the type
12760 already defined for this tag and return it. */
12764 name = TYPE_IDENTIFIER (t);
12767 t = IDENTIFIER_TYPE_VALUE (name);
12769 /* Warn about 'friend struct Inherited;' doing the wrong thing. */
12770 if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12772 static int explained;
12775 warning ("`%s %T' declares a new type at namespace scope",
12776 tag_name (tag_code), name);
12778 warning (" names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12779 tag_name (tag_code),
12780 constructor_name (current_class_type),
12781 TYPE_IDENTIFIER (t));
12783 /* We need to remove the class scope binding for the
12784 TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12785 for (shadowed = b->class_shadowed;
12787 shadowed = TREE_CHAIN (shadowed))
12788 if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12790 TREE_PURPOSE (shadowed) = NULL_TREE;
12795 if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12796 && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12801 /* If we know we are defining this tag, only look it up in
12802 this scope and don't try to find it as a type. */
12803 ref = lookup_tag (code, name, b, 1);
12809 ref = follow_tag_typedef (t);
12811 /* [dcl.type.elab] If the identifier resolves to a
12812 typedef-name or a template type-parameter, the
12813 elaborated-type-specifier is ill-formed. */
12816 pedwarn ("using typedef-name `%D' after `%s'",
12817 TYPE_NAME (t), tag_name (tag_code));
12820 else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12821 error ("using template type parameter `%T' after `%s'",
12822 t, tag_name (tag_code));
12825 ref = lookup_tag (code, name, b, 0);
12829 /* Try finding it as a type declaration. If that wins,
12831 ref = lookup_name (name, 1);
12833 if (ref != NULL_TREE
12834 && processing_template_decl
12835 && DECL_CLASS_TEMPLATE_P (ref)
12836 && template_class_depth (current_class_type) == 0)
12837 /* Since GLOBALIZE is true, we're declaring a global
12838 template, so we want this type. */
12839 ref = DECL_TEMPLATE_RESULT (ref);
12841 if (ref && TREE_CODE (ref) == TYPE_DECL
12842 && TREE_CODE (TREE_TYPE (ref)) == code)
12843 ref = TREE_TYPE (ref);
12848 if (ref && current_class_type
12849 && template_class_depth (current_class_type)
12850 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12852 /* Since GLOBALIZE is non-zero, we are not looking at a
12853 definition of this tag. Since, in addition, we are currently
12854 processing a (member) template declaration of a template
12855 class, we must be very careful; consider:
12862 { template <class V>
12863 friend struct S1; };
12865 Here, the S2::S1 declaration should not be confused with the
12866 outer declaration. In particular, the inner version should
12867 have a template parameter of level 2, not level 1. This
12868 would be particularly important if the member declaration
12871 template <class V = U> friend struct S1;
12873 say, when we should tsubst into `U' when instantiating
12874 S2. On the other hand, when presented with:
12884 we must find the inner binding eventually. We
12885 accomplish this by making sure that the new type we
12886 create to represent this declaration has the right
12888 context = TYPE_CONTEXT (ref);
12895 /* If no such tag is yet defined, create a forward-reference node
12896 and record it as the "definition".
12897 When a real declaration of this type is found,
12898 the forward-reference will be altered into a real type. */
12899 if (code == ENUMERAL_TYPE)
12901 error ("use of enum `%#D' without previous declaration", name);
12903 ref = make_node (ENUMERAL_TYPE);
12905 /* Give the type a default layout like unsigned int
12906 to avoid crashing if it does not get defined. */
12907 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12908 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12909 TYPE_USER_ALIGN (ref) = 0;
12910 TREE_UNSIGNED (ref) = 1;
12911 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12912 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12913 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12915 /* Enable us to recognize when a type is created in class context.
12916 To do nested classes correctly, this should probably be cleared
12917 out when we leave this classes scope. Currently this in only
12918 done in `start_enum'. */
12920 pushtag (name, ref, globalize);
12924 struct cp_binding_level *old_b = class_binding_level;
12926 ref = make_aggr_type (code);
12927 TYPE_CONTEXT (ref) = context;
12929 #ifdef NONNESTED_CLASSES
12930 /* Class types don't nest the way enums do. */
12931 class_binding_level = (struct cp_binding_level *)0;
12933 pushtag (name, ref, globalize);
12934 class_binding_level = old_b;
12939 if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12940 redeclare_class_template (ref, current_template_parms);
12943 TYPE_ATTRIBUTES (ref) = attributes;
12949 xref_tag_from_type (old, id, globalize)
12953 enum tag_types tag_kind;
12955 if (TREE_CODE (old) == RECORD_TYPE)
12956 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
12958 tag_kind = union_type;
12960 if (id == NULL_TREE)
12961 id = TYPE_IDENTIFIER (old);
12963 return xref_tag (tag_kind, id, /*attributes=*/NULL_TREE, globalize);
12966 /* REF is a type (named NAME), for which we have just seen some
12967 baseclasses. BINFO is a list of those baseclasses; the
12968 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12969 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12970 struct, or union. */
12973 xref_basetypes (ref, binfo)
12977 /* In the declaration `A : X, Y, ... Z' we mark all the types
12978 (A, X, Y, ..., Z) so we can check for duplicates. */
12983 enum tag_types tag_code;
12985 if (TREE_CODE (ref) == UNION_TYPE)
12987 error ("derived union `%T' invalid", ref);
12991 tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);
12993 len = list_length (binfo);
12995 /* First, make sure that any templates in base-classes are
12996 instantiated. This ensures that if we call ourselves recursively
12997 we do not get confused about which classes are marked and which
12999 for (base = binfo; base; base = TREE_CHAIN (base))
13000 complete_type (TREE_VALUE (base));
13002 SET_CLASSTYPE_MARKED (ref);
13003 BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13005 for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13007 /* The base of a derived struct is public by default. */
13009 = (TREE_PURPOSE (binfo) == access_public_node
13010 || TREE_PURPOSE (binfo) == access_public_virtual_node
13011 || (tag_code != class_type
13012 && (TREE_PURPOSE (binfo) == access_default_node
13013 || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13015 = (TREE_PURPOSE (binfo) == access_protected_node
13016 || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13018 = (TREE_PURPOSE (binfo) == access_private_virtual_node
13019 || TREE_PURPOSE (binfo) == access_protected_virtual_node
13020 || TREE_PURPOSE (binfo) == access_public_virtual_node
13021 || TREE_PURPOSE (binfo) == access_default_virtual_node);
13022 tree basetype = TREE_VALUE (binfo);
13025 if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13026 basetype = TREE_TYPE (basetype);
13028 || (TREE_CODE (basetype) != RECORD_TYPE
13029 && TREE_CODE (basetype) != TYPENAME_TYPE
13030 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13031 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13033 error ("base type `%T' fails to be a struct or class type",
13034 TREE_VALUE (binfo));
13038 /* This code replaces similar code in layout_basetypes.
13039 We put the complete_type first for implicit `typename'. */
13040 if (!COMPLETE_TYPE_P (basetype)
13041 && ! (current_template_parms && uses_template_parms (basetype)))
13043 error ("base class `%T' has incomplete type", basetype);
13048 if (CLASSTYPE_MARKED (basetype))
13050 if (basetype == ref)
13051 error ("recursive type `%T' undefined", basetype);
13053 error ("duplicate base type `%T' invalid", basetype);
13057 if (TYPE_FOR_JAVA (basetype)
13058 && (current_lang_depth () == 0))
13059 TYPE_FOR_JAVA (ref) = 1;
13061 /* Note that the BINFO records which describe individual
13062 inheritances are *not* shared in the lattice! They
13063 cannot be shared because a given baseclass may be
13064 inherited with different `accessibility' by different
13065 derived classes. (Each BINFO record describing an
13066 individual inheritance contains flags which say what
13067 the `accessibility' of that particular inheritance is.) */
13070 = make_binfo (size_zero_node, basetype,
13071 CLASS_TYPE_P (basetype)
13072 ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13073 CLASS_TYPE_P (basetype)
13074 ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13076 TREE_VEC_ELT (binfos, i) = base_binfo;
13077 TREE_VIA_PUBLIC (base_binfo) = via_public;
13078 TREE_VIA_PROTECTED (base_binfo) = via_protected;
13079 TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13080 BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13082 /* We need to unshare the binfos now so that lookups during class
13083 definition work. */
13084 unshare_base_binfos (base_binfo);
13086 SET_CLASSTYPE_MARKED (basetype);
13088 /* We are free to modify these bits because they are meaningless
13089 at top level, and BASETYPE is a top-level type. */
13090 if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13092 TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13093 /* Converting to a virtual base class requires looking
13094 up the offset of the virtual base. */
13095 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13098 if (CLASS_TYPE_P (basetype))
13100 TYPE_HAS_NEW_OPERATOR (ref)
13101 |= TYPE_HAS_NEW_OPERATOR (basetype);
13102 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13103 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13104 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13105 /* If the base-class uses multiple inheritance, so do we. */
13106 TYPE_USES_MULTIPLE_INHERITANCE (ref)
13107 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13108 /* Likewise, if converting to a base of the base may require
13109 code, then we may need to generate code to convert to a
13111 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13112 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13119 TREE_VEC_LENGTH (binfos) = i;
13121 BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13125 TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13126 /* If there is more than one non-empty they cannot be at the same
13128 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13131 /* Unmark all the types. */
13133 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13134 CLEAR_CLASSTYPE_MARKED (ref);
13136 /* Now that we know all the base-classes, set up the list of virtual
13138 get_vbase_types (ref);
13142 /* Begin compiling the definition of an enumeration type.
13143 NAME is its name (or null if anonymous).
13144 Returns the type object, as yet incomplete.
13145 Also records info about it so that build_enumerator
13146 may be used to declare the individual values as they are read. */
13152 register tree enumtype = NULL_TREE;
13153 struct cp_binding_level *b = current_binding_level;
13155 /* If this is the real definition for a previous forward reference,
13156 fill in the contents in the same object that used to be the
13157 forward reference. */
13159 if (name != NULL_TREE)
13160 enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13162 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13164 error ("multiple definition of `%#T'", enumtype);
13165 cp_error_at ("previous definition here", enumtype);
13166 /* Clear out TYPE_VALUES, and start again. */
13167 TYPE_VALUES (enumtype) = NULL_TREE;
13171 enumtype = make_node (ENUMERAL_TYPE);
13172 pushtag (name, enumtype, 0);
13178 /* After processing and defining all the values of an enumeration type,
13179 install their decls in the enumeration type and finish it off.
13180 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
13183 finish_enum (enumtype)
13195 /* We built up the VALUES in reverse order. */
13196 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13200 Following the closing brace of an enum-specifier, each
13201 enumerator has the type of its enumeration. Prior to the
13202 closing brace, the type of each enumerator is the type of
13203 its initializing value. */
13204 for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13205 TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13207 /* For a enum defined in a template, all further processing is
13208 postponed until the template is instantiated. */
13209 if (processing_template_decl)
13211 if (at_function_scope_p ())
13212 add_stmt (build_min (TAG_DEFN, enumtype));
13216 /* Figure out what the minimum and maximum values of the enumerators
13218 if (TYPE_VALUES (enumtype))
13220 minnode = maxnode = NULL_TREE;
13222 for (pair = TYPE_VALUES (enumtype);
13224 pair = TREE_CHAIN (pair))
13228 value = DECL_INITIAL (TREE_VALUE (pair));
13231 minnode = maxnode = value;
13232 else if (tree_int_cst_lt (maxnode, value))
13234 else if (tree_int_cst_lt (value, minnode))
13239 minnode = maxnode = integer_zero_node;
13241 /* Compute the number of bits require to represent all values of the
13242 enumeration. We must do this before the type of MINNODE and
13243 MAXNODE are transformed, since min_precision relies on the
13244 TREE_TYPE of the value it is passed. */
13245 unsignedp = tree_int_cst_sgn (minnode) >= 0;
13246 lowprec = min_precision (minnode, unsignedp);
13247 highprec = min_precision (maxnode, unsignedp);
13248 precision = MAX (lowprec, highprec);
13250 /* Set the TREE_TYPE for the values as well. That's so that when we
13251 call decl_constant_value we get an entity of the right type (but
13252 with the constant value). In addition, transform the TYPE_VALUES
13253 list to contain the values, rather than the CONST_DECLs for them. */
13254 for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13256 tree value = DECL_INITIAL (TREE_VALUE (pair));
13258 TREE_TYPE (value) = enumtype;
13259 TREE_VALUE (pair) = value;
13262 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
13263 TYPE_SIZE (enumtype) = NULL_TREE;
13264 TYPE_PRECISION (enumtype) = precision;
13266 fixup_unsigned_type (enumtype);
13268 fixup_signed_type (enumtype);
13270 if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13271 /* Use the width of the narrowest normal C type which is wide
13273 TYPE_PRECISION (enumtype) = TYPE_PRECISION (c_common_type_for_size
13276 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13278 TYPE_SIZE (enumtype) = NULL_TREE;
13279 layout_type (enumtype);
13281 /* Fix up all variant types of this enum type. */
13282 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13284 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13285 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13286 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13287 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13288 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13289 TYPE_MODE (t) = TYPE_MODE (enumtype);
13290 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13291 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13292 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13293 TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13296 /* Finish debugging output for this type. */
13297 rest_of_type_compilation (enumtype, namespace_bindings_p ());
13300 /* Build and install a CONST_DECL for an enumeration constant of the
13301 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13302 Assignment of sequential values by default is handled here. */
13305 build_enumerator (name, value, enumtype)
13315 /* Remove no-op casts from the value. */
13317 STRIP_TYPE_NOPS (value);
13319 if (! processing_template_decl)
13321 /* Validate and default VALUE. */
13322 if (value != NULL_TREE)
13324 value = decl_constant_value (value);
13326 if (TREE_CODE (value) == INTEGER_CST)
13328 value = default_conversion (value);
13329 constant_expression_warning (value);
13333 error ("enumerator value for `%D' not integer constant", name);
13338 /* Default based on previous value. */
13339 if (value == NULL_TREE && ! processing_template_decl)
13343 if (TYPE_VALUES (enumtype))
13345 /* The next value is the previous value ... */
13346 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13347 /* ... plus one. */
13348 value = cp_build_binary_op (PLUS_EXPR,
13352 if (tree_int_cst_lt (value, prev_value))
13353 error ("overflow in enumeration values at `%D'", name);
13356 value = integer_zero_node;
13359 /* Remove no-op casts from the value. */
13361 STRIP_TYPE_NOPS (value);
13363 /* To fix MAX_VAL enum consts. (bkoz) */
13364 TREE_TYPE (value) = integer_type_node;
13368 /* We always have to copy here; not all INTEGER_CSTs are unshared.
13369 Even in other cases, we will later (in finish_enum) be setting
13370 the type of VALUE. But, we don't need to make a copy if this
13371 VALUE is one of the enumeration constants for this same
13372 enumeration type. */
13373 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13374 if (TREE_VALUE (values) == value)
13376 /* If we didn't break out of the loop, then we do need a copy. */
13377 if (!values && value)
13378 value = copy_node (value);
13380 /* C++ associates enums with global, function, or class declarations. */
13381 context = current_scope ();
13383 /* Build the actual enumeration constant. Note that the enumeration
13384 constants have the type of their initializers until the
13385 enumeration is complete:
13389 Following the closing brace of an enum-specifier, each enumer-
13390 ator has the type of its enumeration. Prior to the closing
13391 brace, the type of each enumerator is the type of its
13392 initializing value.
13394 In finish_enum we will reset the type. Of course, if we're
13395 processing a template, there may be no value. */
13396 type = value ? TREE_TYPE (value) : NULL_TREE;
13398 if (context && context == current_class_type)
13399 /* This enum declaration is local to the class. We need the full
13400 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
13401 decl = build_lang_decl (CONST_DECL, name, type);
13403 /* It's a global enum, or it's local to a function. (Note local to
13404 a function could mean local to a class method. */
13405 decl = build_decl (CONST_DECL, name, type);
13407 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13408 DECL_INITIAL (decl) = value;
13409 TREE_READONLY (decl) = 1;
13411 if (context && context == current_class_type)
13412 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13413 on the TYPE_FIELDS list for `S'. (That's so that you can say
13414 things like `S::i' later.) */
13415 finish_member_declaration (decl);
13419 /* Add this enumeration constant to the list for this type. */
13420 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13424 /* We're defining DECL. Make sure that it's type is OK. */
13427 check_function_type (decl, current_function_parms)
13429 tree current_function_parms;
13431 tree fntype = TREE_TYPE (decl);
13432 tree return_type = complete_type (TREE_TYPE (fntype));
13434 /* In a function definition, arg types must be complete. */
13435 require_complete_types_for_parms (current_function_parms);
13437 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13439 error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13441 /* Make it return void instead, but don't change the
13442 type of the DECL_RESULT, in case we have a named return value. */
13443 if (TREE_CODE (fntype) == METHOD_TYPE)
13445 tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13447 = build_cplus_method_type (ctype,
13449 FUNCTION_ARG_CHAIN (decl));
13453 = build_function_type (void_type_node,
13454 TYPE_ARG_TYPES (TREE_TYPE (decl)));
13456 = build_exception_variant (fntype,
13457 TYPE_RAISES_EXCEPTIONS (fntype));
13460 abstract_virtuals_error (decl, TREE_TYPE (fntype));
13463 /* Create the FUNCTION_DECL for a function definition.
13464 DECLSPECS and DECLARATOR are the parts of the declaration;
13465 they describe the function's name and the type it returns,
13466 but twisted together in a fashion that parallels the syntax of C.
13468 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13469 DECLARATOR is really the DECL for the function we are about to
13470 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13471 indicating that the function is an inline defined in-class.
13473 This function creates a binding context for the function body
13474 as well as setting up the FUNCTION_DECL in current_function_decl.
13476 Returns 1 on success. If the DECLARATOR is not suitable for a function
13477 (it defines a datum instead), we return 0, which tells
13478 yyparse to report a parse error.
13480 For C++, we must first check whether that datum makes any sense.
13481 For example, "class A local_a(1,2);" means that variable local_a
13482 is an aggregate of type A, which should have a constructor
13483 applied to it with the argument list [1, 2]. */
13486 start_function (declspecs, declarator, attrs, flags)
13487 tree declspecs, declarator, attrs;
13491 tree ctype = NULL_TREE;
13494 int doing_friend = 0;
13495 struct cp_binding_level *bl;
13496 tree current_function_parms;
13498 /* Sanity check. */
13499 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13500 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13502 /* This should only be done once on the top most decl. */
13503 if (have_extern_spec)
13505 declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13506 have_extern_spec = false;
13509 if (flags & SF_PRE_PARSED)
13511 decl1 = declarator;
13513 fntype = TREE_TYPE (decl1);
13514 if (TREE_CODE (fntype) == METHOD_TYPE)
13515 ctype = TYPE_METHOD_BASETYPE (fntype);
13517 /* ISO C++ 11.4/5. A friend function defined in a class is in
13518 the (lexical) scope of the class in which it is defined. */
13519 if (!ctype && DECL_FRIEND_P (decl1))
13521 ctype = DECL_FRIEND_CONTEXT (decl1);
13523 /* CTYPE could be null here if we're dealing with a template;
13524 for example, `inline friend float foo()' inside a template
13525 will have no CTYPE set. */
13526 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13532 last_function_parms = DECL_ARGUMENTS (decl1);
13536 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13537 /* If the declarator is not suitable for a function definition,
13538 cause a syntax error. */
13539 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13542 cplus_decl_attributes (&decl1, attrs, 0);
13544 /* If #pragma weak was used, mark the decl weak now. */
13545 if (current_binding_level == global_binding_level)
13546 maybe_apply_pragma_weak (decl1);
13548 fntype = TREE_TYPE (decl1);
13550 restype = TREE_TYPE (fntype);
13551 if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13553 error ("semicolon missing after declaration of `%#T'", restype);
13554 shadow_tag (build_tree_list (NULL_TREE, restype));
13555 CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13556 if (TREE_CODE (fntype) == FUNCTION_TYPE)
13557 fntype = build_function_type (integer_type_node,
13558 TYPE_ARG_TYPES (fntype));
13560 fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13562 TYPE_ARG_TYPES (fntype));
13563 TREE_TYPE (decl1) = fntype;
13566 if (TREE_CODE (fntype) == METHOD_TYPE)
13567 ctype = TYPE_METHOD_BASETYPE (fntype);
13568 else if (DECL_MAIN_P (decl1))
13570 /* If this doesn't return integer_type, complain. */
13571 if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13573 if (pedantic || warn_return_type)
13574 pedwarn ("return type for `main' changed to `int'");
13575 TREE_TYPE (decl1) = fntype = default_function_type;
13580 if (DECL_DECLARED_INLINE_P (decl1)
13581 && lookup_attribute ("noinline", attrs))
13582 warning_with_decl (decl1,
13583 "inline function `%s' given attribute noinline");
13585 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13586 /* This is a constructor, we must ensure that any default args
13587 introduced by this definition are propagated to the clones
13588 now. The clones are used directly in overload resolution. */
13589 adjust_clone_args (decl1);
13591 /* Sometimes we don't notice that a function is a static member, and
13592 build a METHOD_TYPE for it. Fix that up now. */
13593 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13594 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13596 revert_static_member_fn (decl1);
13597 last_function_parms = TREE_CHAIN (last_function_parms);
13601 /* Warn if function was previously implicitly declared
13602 (but not if we warned then). */
13603 if (! warn_implicit
13604 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13605 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13607 /* Set up current_class_type, and enter the scope of the class, if
13610 push_nested_class (ctype, 1);
13611 else if (DECL_STATIC_FUNCTION_P (decl1))
13612 push_nested_class (DECL_CONTEXT (decl1), 2);
13614 /* Now that we have entered the scope of the class, we must restore
13615 the bindings for any template parameters surrounding DECL1, if it
13616 is an inline member template. (Order is important; consider the
13617 case where a template parameter has the same name as a field of
13618 the class.) It is not until after this point that
13619 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13620 if (flags & SF_INCLASS_INLINE)
13621 maybe_begin_member_template_processing (decl1);
13623 /* Effective C++ rule 15. */
13625 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13626 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13627 warning ("`operator=' should return a reference to `*this'");
13629 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13630 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13631 if (!DECL_INITIAL (decl1))
13632 DECL_INITIAL (decl1) = error_mark_node;
13634 /* This function exists in static storage.
13635 (This does not mean `static' in the C sense!) */
13636 TREE_STATIC (decl1) = 1;
13638 /* We must call push_template_decl after current_class_type is set
13639 up. (If we are processing inline definitions after exiting a
13640 class scope, current_class_type will be NULL_TREE until set above
13641 by push_nested_class.) */
13642 if (processing_template_decl)
13643 decl1 = push_template_decl (decl1);
13645 /* We are now in the scope of the function being defined. */
13646 current_function_decl = decl1;
13648 /* Save the parm names or decls from this function's declarator
13649 where store_parm_decls will find them. */
13650 current_function_parms = last_function_parms;
13652 /* Make sure the parameter and return types are reasonable. When
13653 you declare a function, these types can be incomplete, but they
13654 must be complete when you define the function. */
13655 if (! processing_template_decl)
13656 check_function_type (decl1, current_function_parms);
13658 /* Build the return declaration for the function. */
13659 restype = TREE_TYPE (fntype);
13660 /* Promote the value to int before returning it. */
13661 if (c_promoting_integer_type_p (restype))
13662 restype = type_promotes_to (restype);
13663 if (DECL_RESULT (decl1) == NULL_TREE)
13665 DECL_RESULT (decl1)
13666 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13667 c_apply_type_quals_to_decl (cp_type_quals (restype),
13668 DECL_RESULT (decl1));
13671 /* Initialize RTL machinery. We cannot do this until
13672 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13673 even when processing a template; this is how we get
13674 CFUN set up, and our per-function variables initialized.
13675 FIXME factor out the non-RTL stuff. */
13676 bl = current_binding_level;
13677 init_function_start (decl1, input_filename, lineno);
13678 current_binding_level = bl;
13680 /* Even though we're inside a function body, we still don't want to
13681 call expand_expr to calculate the size of a variable-sized array.
13682 We haven't necessarily assigned RTL to all variables yet, so it's
13683 not safe to try to expand expressions involving them. */
13684 immediate_size_expand = 0;
13685 cfun->x_dont_save_pending_sizes_p = 1;
13687 /* Start the statement-tree, start the tree now. */
13688 begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13690 /* Let the user know we're compiling this function. */
13691 announce_function (decl1);
13693 /* Record the decl so that the function name is defined.
13694 If we already have a decl for this name, and it is a FUNCTION_DECL,
13695 use the old decl. */
13696 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13698 /* A specialization is not used to guide overload resolution. */
13699 if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13700 && ! DECL_FUNCTION_MEMBER_P (decl1))
13701 decl1 = pushdecl (decl1);
13704 /* We need to set the DECL_CONTEXT. */
13705 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13706 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13707 /* And make sure we have enough default args. */
13708 check_default_args (decl1);
13710 fntype = TREE_TYPE (decl1);
13713 /* Reset these in case the call to pushdecl changed them. */
13714 current_function_decl = decl1;
13715 cfun->decl = decl1;
13717 /* If we are (erroneously) defining a function that we have already
13718 defined before, wipe out what we knew before. */
13719 if (!DECL_PENDING_INLINE_P (decl1))
13720 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13722 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13724 /* We know that this was set up by `grokclassfn'. We do not
13725 wait until `store_parm_decls', since evil parse errors may
13726 never get us to that point. Here we keep the consistency
13727 between `current_class_type' and `current_class_ptr'. */
13728 tree t = DECL_ARGUMENTS (decl1);
13730 my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13732 my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13735 cp_function_chain->x_current_class_ref
13736 = build_indirect_ref (t, NULL);
13737 cp_function_chain->x_current_class_ptr = t;
13739 /* Constructors and destructors need to know whether they're "in
13740 charge" of initializing virtual base classes. */
13741 t = TREE_CHAIN (t);
13742 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13744 current_in_charge_parm = t;
13745 t = TREE_CHAIN (t);
13747 if (DECL_HAS_VTT_PARM_P (decl1))
13749 if (DECL_NAME (t) != vtt_parm_identifier)
13751 current_vtt_parm = t;
13755 if (DECL_INTERFACE_KNOWN (decl1))
13757 tree ctx = decl_function_context (decl1);
13759 if (DECL_NOT_REALLY_EXTERN (decl1))
13760 DECL_EXTERNAL (decl1) = 0;
13762 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13763 && TREE_PUBLIC (ctx))
13764 /* This is a function in a local class in an extern inline
13766 comdat_linkage (decl1);
13768 /* If this function belongs to an interface, it is public.
13769 If it belongs to someone else's interface, it is also external.
13770 This only affects inlines and template instantiations. */
13771 else if (interface_unknown == 0
13772 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13773 || flag_alt_external_templates))
13775 if (DECL_DECLARED_INLINE_P (decl1)
13776 || DECL_TEMPLATE_INSTANTIATION (decl1)
13777 || processing_template_decl)
13779 DECL_EXTERNAL (decl1)
13781 || (DECL_DECLARED_INLINE_P (decl1)
13782 && ! flag_implement_inlines
13783 && !DECL_VINDEX (decl1)));
13785 /* For WIN32 we also want to put these in linkonce sections. */
13786 maybe_make_one_only (decl1);
13789 DECL_EXTERNAL (decl1) = 0;
13790 DECL_NOT_REALLY_EXTERN (decl1) = 0;
13791 DECL_INTERFACE_KNOWN (decl1) = 1;
13793 else if (interface_unknown && interface_only
13794 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13795 || flag_alt_external_templates))
13797 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13798 interface, we will have interface_only set but not
13799 interface_known. In that case, we don't want to use the normal
13800 heuristics because someone will supply a #pragma implementation
13801 elsewhere, and deducing it here would produce a conflict. */
13802 comdat_linkage (decl1);
13803 DECL_EXTERNAL (decl1) = 0;
13804 DECL_INTERFACE_KNOWN (decl1) = 1;
13805 DECL_DEFER_OUTPUT (decl1) = 1;
13809 /* This is a definition, not a reference.
13810 So clear DECL_EXTERNAL. */
13811 DECL_EXTERNAL (decl1) = 0;
13813 if ((DECL_DECLARED_INLINE_P (decl1)
13814 || DECL_TEMPLATE_INSTANTIATION (decl1))
13815 && ! DECL_INTERFACE_KNOWN (decl1)
13816 /* Don't try to defer nested functions for now. */
13817 && ! decl_function_context (decl1))
13818 DECL_DEFER_OUTPUT (decl1) = 1;
13820 DECL_INTERFACE_KNOWN (decl1) = 1;
13824 current_binding_level->parm_flag = 1;
13828 if (DECL_DESTRUCTOR_P (decl1))
13830 dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13831 DECL_CONTEXT (dtor_label) = current_function_decl;
13834 start_fname_decls ();
13836 store_parm_decls (current_function_parms);
13841 /* Store the parameter declarations into the current function declaration.
13842 This is called after parsing the parameter declarations, before
13843 digesting the body of the function.
13845 Also install to binding contour return value identifier, if any. */
13848 store_parm_decls (current_function_parms)
13849 tree current_function_parms;
13851 register tree fndecl = current_function_decl;
13852 register tree parm;
13854 /* This is a chain of any other decls that came in among the parm
13855 declarations. If a parm is declared with enum {foo, bar} x;
13856 then CONST_DECLs for foo and bar are put here. */
13857 tree nonparms = NULL_TREE;
13859 if (current_function_parms)
13861 /* This case is when the function was defined with an ANSI prototype.
13862 The parms already have decls, so we need not do anything here
13863 except record them as in effect
13864 and complain if any redundant old-style parm decls were written. */
13866 tree specparms = current_function_parms;
13869 /* Must clear this because it might contain TYPE_DECLs declared
13871 storedecls (NULL_TREE);
13873 /* If we're doing semantic analysis, then we'll call pushdecl
13874 for each of these. We must do them in reverse order so that
13875 they end in the correct forward order. */
13876 specparms = nreverse (specparms);
13878 for (parm = specparms; parm; parm = next)
13880 next = TREE_CHAIN (parm);
13881 if (TREE_CODE (parm) == PARM_DECL)
13883 if (DECL_NAME (parm) == NULL_TREE
13884 || TREE_CODE (parm) != VOID_TYPE)
13887 error ("parameter `%D' declared void", parm);
13891 /* If we find an enum constant or a type tag,
13892 put it aside for the moment. */
13893 TREE_CHAIN (parm) = NULL_TREE;
13894 nonparms = chainon (nonparms, parm);
13898 /* Get the decls in their original chain order and record in the
13899 function. This is all and only the PARM_DECLs that were
13900 pushed into scope by the loop above. */
13901 DECL_ARGUMENTS (fndecl) = getdecls ();
13902 storetags (gettags ());
13905 DECL_ARGUMENTS (fndecl) = NULL_TREE;
13907 /* Now store the final chain of decls for the arguments
13908 as the decl-chain of the current lexical scope.
13909 Put the enumerators in as well, at the front so that
13910 DECL_ARGUMENTS is not modified. */
13911 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13913 /* Do the starting of the exception specifications, if we have any. */
13914 if (flag_exceptions && !processing_template_decl
13915 && flag_enforce_eh_specs
13916 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13917 current_eh_spec_block = begin_eh_spec_block ();
13921 /* We have finished doing semantic analysis on DECL, but have not yet
13922 generated RTL for its body. Save away our current state, so that
13923 when we want to generate RTL later we know what to do. */
13926 save_function_data (decl)
13929 struct language_function *f;
13931 /* Save the language-specific per-function data so that we can
13932 get it back when we really expand this function. */
13933 my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13937 f = ((struct language_function *)
13938 ggc_alloc (sizeof (struct language_function)));
13939 memcpy (f, cp_function_chain, sizeof (struct language_function));
13940 DECL_SAVED_FUNCTION_DATA (decl) = f;
13942 /* Clear out the bits we don't need. */
13943 f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13944 f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13945 f->x_named_label_uses = NULL;
13946 f->bindings = NULL;
13947 f->x_local_names = NULL;
13949 /* When we get back here again, we will be expanding. */
13950 f->x_expanding_p = 1;
13952 /* If we've already decided that we cannot inline this function, we
13953 must remember that fact when we actually go to expand the
13955 if (current_function_cannot_inline)
13957 f->cannot_inline = current_function_cannot_inline;
13958 DECL_INLINE (decl) = 0;
13962 /* Add a note to mark the beginning of the main body of the constructor.
13963 This is used to set up the data structures for the cleanup regions for
13964 fully-constructed bases and members. */
13967 begin_constructor_body ()
13971 /* Add a note to mark the end of the main body of the constructor. This is
13972 used to end the cleanup regions for fully-constructed bases and
13976 finish_constructor_body ()
13980 /* Do all the processing for the beginning of a destructor; set up the
13981 vtable pointers and cleanups for bases and members. */
13984 begin_destructor_body ()
13987 tree compound_stmt;
13989 /* If the dtor is empty, and we know there is not any possible
13990 way we could use any vtable entries, before they are possibly
13991 set by a base class dtor, we don't have to setup the vtables,
13992 as we know that any base class dtor will set up any vtables
13993 it needs. We avoid MI, because one base class dtor can do a
13994 virtual dispatch to an overridden function that would need to
13995 have a non-related vtable set up, we cannot avoid setting up
13996 vtables in that case. We could change this to see if there
13997 is just one vtable.
13999 ??? In the destructor for a class, the vtables are set
14000 appropriately for that class. There will be no non-related
14001 vtables. jason 2001-12-11. */
14002 if_stmt = begin_if_stmt ();
14004 /* If it is not safe to avoid setting up the vtables, then
14005 someone will change the condition to be boolean_true_node.
14006 (Actually, for now, we do not have code to set the condition
14007 appropriately, so we just assume that we always need to
14008 initialize the vtables.) */
14009 finish_if_stmt_cond (boolean_true_node, if_stmt);
14011 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14013 /* Make all virtual function table pointers in non-virtual base
14014 classes point to CURRENT_CLASS_TYPE's virtual function
14016 initialize_vtbl_ptrs (current_class_ptr);
14018 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14019 finish_then_clause (if_stmt);
14022 /* And insert cleanups for our bases and members so that they
14023 will be properly destroyed if we throw. */
14024 push_base_cleanups ();
14027 /* At the end of every destructor we generate code to delete the object if
14028 necessary. Do that now. */
14031 finish_destructor_body ()
14035 /* In a virtual destructor, we must call delete. */
14036 if (DECL_VIRTUAL_P (current_function_decl))
14039 tree virtual_size = cxx_sizeof (current_class_type);
14043 At the point of definition of a virtual destructor (including
14044 an implicit definition), non-placement operator delete shall
14045 be looked up in the scope of the destructor's class and if
14046 found shall be accessible and unambiguous. */
14047 exprstmt = build_op_delete_call
14048 (DELETE_EXPR, current_class_ptr, virtual_size,
14049 LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14051 if_stmt = begin_if_stmt ();
14052 finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14053 current_in_charge_parm,
14056 finish_expr_stmt (exprstmt);
14057 finish_then_clause (if_stmt);
14062 /* Do the necessary processing for the beginning of a function body, which
14063 in this case includes member-initializers, but not the catch clauses of
14064 a function-try-block. Currently, this means opening a binding level
14065 for the member-initializers (in a ctor) and member cleanups (in a dtor).
14066 In other functions, this isn't necessary, but it doesn't hurt. */
14069 begin_function_body ()
14073 if (processing_template_decl)
14074 /* Do nothing now. */;
14076 /* Always keep the BLOCK node associated with the outermost pair of
14077 curly braces of a function. These are needed for correct
14078 operation of dwarfout.c. */
14079 keep_next_level (1);
14081 stmt = begin_compound_stmt (0);
14082 COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
14084 if (processing_template_decl)
14085 /* Do nothing now. */;
14086 else if (DECL_CONSTRUCTOR_P (current_function_decl))
14087 begin_constructor_body ();
14088 else if (DECL_DESTRUCTOR_P (current_function_decl))
14089 begin_destructor_body ();
14094 /* Do the processing for the end of a function body. Currently, this means
14095 closing out the cleanups for fully-constructed bases and members, and in
14096 the case of the destructor, deleting the object if desired. Again, this
14097 is only meaningful for [cd]tors, since they are the only functions where
14098 there is a significant distinction between the main body and any
14099 function catch clauses. Handling, say, main() return semantics here
14100 would be wrong, as flowing off the end of a function catch clause for
14101 main() would also need to return 0. */
14104 finish_function_body (compstmt)
14107 if (processing_template_decl)
14108 /* Do nothing now. */;
14109 else if (DECL_DESTRUCTOR_P (current_function_decl))
14110 /* Any return from a destructor will end up here. Put it before the
14111 cleanups so that an explicit return doesn't duplicate them. */
14112 add_stmt (build_stmt (LABEL_STMT, dtor_label));
14114 /* Close the block; in a destructor, run the member cleanups. */
14115 finish_compound_stmt (0, compstmt);
14117 if (processing_template_decl)
14118 /* Do nothing now. */;
14119 else if (DECL_CONSTRUCTOR_P (current_function_decl))
14120 finish_constructor_body ();
14121 else if (DECL_DESTRUCTOR_P (current_function_decl))
14122 finish_destructor_body ();
14125 /* Finish up a function declaration and compile that function
14126 all the way to assembler language output. The free the storage
14127 for the function definition.
14129 FLAGS is a bitwise or of the following values:
14131 We just finished processing the body of an in-class inline
14132 function definition. (This processing will have taken place
14133 after the class definition is complete.) */
14136 finish_function (flags)
14139 register tree fndecl = current_function_decl;
14140 tree fntype, ctype = NULL_TREE;
14141 int inclass_inline = (flags & 2) != 0;
14144 /* When we get some parse errors, we can end up without a
14145 current_function_decl, so cope. */
14146 if (fndecl == NULL_TREE)
14147 return error_mark_node;
14149 nested = function_depth > 1;
14150 fntype = TREE_TYPE (fndecl);
14152 /* TREE_READONLY (fndecl) = 1;
14153 This caused &foo to be of type ptr-to-const-function
14154 which then got a warning when stored in a ptr-to-function variable. */
14156 my_friendly_assert (building_stmt_tree (), 20000911);
14158 finish_fname_decls ();
14160 /* For a cloned function, we've already got all the code we need;
14161 there's no need to add any extra bits. */
14162 if (!DECL_CLONED_FUNCTION_P (fndecl))
14164 if (DECL_MAIN_P (current_function_decl))
14166 /* Make it so that `main' always returns 0 by default. */
14168 finish_return_stmt (integer_one_node);
14170 finish_return_stmt (integer_zero_node);
14174 /* Finish dealing with exception specifiers. */
14175 if (flag_exceptions && !processing_template_decl
14176 && flag_enforce_eh_specs
14177 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14178 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14179 (TREE_TYPE (current_function_decl)),
14180 current_eh_spec_block);
14183 /* If we're saving up tree structure, tie off the function now. */
14184 finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14186 /* This must come after expand_function_end because cleanups might
14187 have declarations (from inline functions) that need to go into
14188 this function's blocks. */
14190 /* If the current binding level isn't the outermost binding level
14191 for this function, either there is a bug, or we have experienced
14192 syntax errors and the statement tree is malformed. */
14193 if (current_binding_level->parm_flag != 1)
14195 /* Make sure we have already experienced errors. */
14196 if (errorcount == 0)
14199 /* Throw away the broken statement tree and extra binding
14201 DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14203 while (current_binding_level->parm_flag != 1)
14205 if (current_binding_level->parm_flag == 2)
14206 pop_nested_class ();
14208 poplevel (0, 0, 0);
14211 poplevel (1, 0, 1);
14213 /* Set up the named return value optimization, if we can. Here, we
14214 eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14215 for the nrv. genrtl_start_function and declare_return_variable
14216 handle making the nrv and RESULT_DECL share space. */
14217 if (current_function_return_value)
14219 tree r = current_function_return_value;
14220 /* This is only worth doing for fns that return in memory--and
14221 simpler, since we don't have to worry about promoted modes. */
14222 if (r != error_mark_node
14223 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14225 DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14226 walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14227 nullify_returns_r, r);
14230 /* Clear it so genrtl_start_function and declare_return_variable
14231 know we're not optimizing. */
14232 current_function_return_value = NULL_TREE;
14235 /* Remember that we were in class scope. */
14236 if (current_class_name)
14237 ctype = current_class_type;
14239 /* Must mark the RESULT_DECL as being in this function. */
14240 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14242 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14243 to the FUNCTION_DECL node itself. */
14244 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14246 /* Save away current state, if appropriate. */
14247 if (!processing_template_decl)
14248 save_function_data (fndecl);
14250 /* If this function calls `setjmp' it cannot be inlined. When
14251 `longjmp' is called it is not guaranteed to restore the value of
14252 local variables that have been modified since the call to
14253 `setjmp'. So, if were to inline this function into some caller
14254 `c', then when we `longjmp', we might not restore all variables
14255 in `c'. (It might seem, at first blush, that there's no way for
14256 this function to modify local variables in `c', but their
14257 addresses may have been stored somewhere accessible to this
14259 if (!processing_template_decl && calls_setjmp_p (fndecl))
14260 DECL_UNINLINABLE (fndecl) = 1;
14262 /* Complain if there's just no return statement. */
14263 if (warn_return_type
14264 && !processing_template_decl
14265 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
14266 && !current_function_returns_value && !current_function_returns_null
14267 /* Don't complain if we abort or throw. */
14268 && !current_function_returns_abnormally
14269 && !DECL_NAME (DECL_RESULT (fndecl))
14270 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
14271 inline function, as we might never be compiled separately. */
14272 && DECL_INLINE (fndecl))
14273 warning ("no return statement in function returning non-void");
14275 /* Clear out memory we no longer need. */
14276 free_after_parsing (cfun);
14277 /* Since we never call rest_of_compilation, we never clear
14278 CFUN. Do so explicitly. */
14279 free_after_compilation (cfun);
14282 /* If this is a in-class inline definition, we may have to pop the
14283 bindings for the template parameters that we added in
14284 maybe_begin_member_template_processing when start_function was
14286 if (inclass_inline)
14287 maybe_end_member_template_processing ();
14289 /* Leave the scope of the class. */
14291 pop_nested_class ();
14297 /* Let the error reporting routines know that we're outside a
14298 function. For a nested function, this value is used in
14299 cxx_pop_function_context and then reset via pop_function_context. */
14300 current_function_decl = NULL_TREE;
14305 /* Create the FUNCTION_DECL for a function definition.
14306 DECLSPECS and DECLARATOR are the parts of the declaration;
14307 they describe the return type and the name of the function,
14308 but twisted together in a fashion that parallels the syntax of C.
14310 This function creates a binding context for the function body
14311 as well as setting up the FUNCTION_DECL in current_function_decl.
14313 Returns a FUNCTION_DECL on success.
14315 If the DECLARATOR is not suitable for a function (it defines a datum
14316 instead), we return 0, which tells yyparse to report a parse error.
14318 May return void_type_node indicating that this method is actually
14319 a friend. See grokfield for more details.
14321 Came here with a `.pushlevel' .
14323 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14324 CHANGES TO CODE IN `grokfield'. */
14327 start_method (declspecs, declarator, attrlist)
14328 tree declarator, declspecs, attrlist;
14330 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14333 /* Something too ugly to handle. */
14334 if (fndecl == NULL_TREE)
14338 cplus_decl_attributes (&fndecl, attrlist, 0);
14340 /* Pass friends other than inline friend functions back. */
14341 if (fndecl == void_type_node)
14344 if (TREE_CODE (fndecl) != FUNCTION_DECL)
14345 /* Not a function, tell parser to report parse error. */
14348 if (DECL_IN_AGGR_P (fndecl))
14350 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14352 if (DECL_CONTEXT (fndecl)
14353 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14354 error ("`%D' is already defined in class `%T'", fndecl,
14355 DECL_CONTEXT (fndecl));
14357 return void_type_node;
14360 check_template_shadow (fndecl);
14362 DECL_DECLARED_INLINE_P (fndecl) = 1;
14364 if (flag_default_inline)
14365 DECL_INLINE (fndecl) = 1;
14367 /* We process method specializations in finish_struct_1. */
14368 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14369 fndecl = push_template_decl (fndecl);
14371 if (! DECL_FRIEND_P (fndecl))
14373 if (TREE_CHAIN (fndecl))
14375 fndecl = copy_node (fndecl);
14376 TREE_CHAIN (fndecl) = NULL_TREE;
14378 grok_special_member_properties (fndecl);
14381 cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14383 /* Make a place for the parms */
14385 current_binding_level->parm_flag = 1;
14387 DECL_IN_AGGR_P (fndecl) = 1;
14391 /* Go through the motions of finishing a function definition.
14392 We don't compile this method until after the whole class has
14395 FINISH_METHOD must return something that looks as though it
14396 came from GROKFIELD (since we are defining a method, after all).
14398 This is called after parsing the body of the function definition.
14399 STMTS is the chain of statements that makes up the function body.
14401 DECL is the ..._DECL that `start_method' provided. */
14404 finish_method (decl)
14407 register tree fndecl = decl;
14410 register tree link;
14412 if (decl == void_type_node)
14415 old_initial = DECL_INITIAL (fndecl);
14417 /* Undo the level for the parms (from start_method).
14418 This is like poplevel, but it causes nothing to be
14419 saved. Saving information here confuses symbol-table
14420 output routines. Besides, this information will
14421 be correctly output when this method is actually
14424 /* Clear out the meanings of the local variables of this level;
14425 also record in each decl which block it belongs to. */
14427 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14429 if (DECL_NAME (link) != NULL_TREE)
14430 pop_binding (DECL_NAME (link), link);
14431 my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14432 DECL_CONTEXT (link) = NULL_TREE;
14435 poplevel (0, 0, 0);
14437 DECL_INITIAL (fndecl) = old_initial;
14439 /* We used to check if the context of FNDECL was different from
14440 current_class_type as another way to get inside here. This didn't work
14441 for String.cc in libg++. */
14442 if (DECL_FRIEND_P (fndecl))
14444 CLASSTYPE_INLINE_FRIENDS (current_class_type)
14445 = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14446 decl = void_type_node;
14453 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14454 we can lay it out later, when and if its type becomes complete. */
14457 maybe_register_incomplete_var (var)
14460 my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
14462 /* Keep track of variables with incomplete types. */
14463 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14464 && DECL_EXTERNAL (var))
14466 tree inner_type = TREE_TYPE (var);
14468 while (TREE_CODE (inner_type) == ARRAY_TYPE)
14469 inner_type = TREE_TYPE (inner_type);
14470 inner_type = TYPE_MAIN_VARIANT (inner_type);
14472 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14473 /* RTTI TD entries are created while defining the type_info. */
14474 || (TYPE_LANG_SPECIFIC (inner_type)
14475 && TYPE_BEING_DEFINED (inner_type)))
14476 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
14480 /* Called when a class type (given by TYPE) is defined. If there are
14481 any existing VAR_DECLs whose type hsa been completed by this
14482 declaration, update them now. */
14485 complete_vars (type)
14488 tree *list = &incomplete_vars;
14490 my_friendly_assert (CLASS_TYPE_P (type), 20020406);
14493 if (same_type_p (type, TREE_PURPOSE (*list)))
14495 tree var = TREE_VALUE (*list);
14496 /* Complete the type of the variable. The VAR_DECL itself
14497 will be laid out in expand_expr. */
14498 complete_type (TREE_TYPE (var));
14499 /* Remove this entry from the list. */
14500 *list = TREE_CHAIN (*list);
14503 list = &TREE_CHAIN (*list);
14507 /* If DECL is of a type which needs a cleanup, build that cleanup
14511 cxx_maybe_build_cleanup (decl)
14514 tree type = TREE_TYPE (decl);
14516 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14518 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14521 if (TREE_CODE (type) == ARRAY_TYPE)
14525 cxx_mark_addressable (decl);
14526 rval = build_unary_op (ADDR_EXPR, decl, 0);
14529 /* Optimize for space over speed here. */
14530 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14531 || flag_expensive_optimizations)
14532 flags |= LOOKUP_NONVIRTUAL;
14534 rval = build_delete (TREE_TYPE (rval), rval,
14535 sfk_complete_destructor, flags, 0);
14537 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14538 && ! TYPE_HAS_DESTRUCTOR (type))
14539 rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14540 build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14547 /* When a stmt has been parsed, this function is called. */
14552 /* Always assume this statement was not an expression statement. If
14553 it actually was an expression statement, its our callers
14554 responsibility to fix this up. */
14555 last_expr_type = NULL_TREE;
14558 /* DECL was originally constructed as a non-static member function,
14559 but turned out to be static. Update it accordingly. */
14562 revert_static_member_fn (decl)
14566 tree function = TREE_TYPE (decl);
14567 tree args = TYPE_ARG_TYPES (function);
14569 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14570 != TYPE_UNQUALIFIED)
14571 error ("static member function `%#D' declared with type qualifiers",
14574 args = TREE_CHAIN (args);
14575 tmp = build_function_type (TREE_TYPE (function), args);
14576 tmp = build_qualified_type (tmp, cp_type_quals (function));
14577 tmp = build_exception_variant (tmp,
14578 TYPE_RAISES_EXCEPTIONS (function));
14579 TREE_TYPE (decl) = tmp;
14580 if (DECL_ARGUMENTS (decl))
14581 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14582 DECL_STATIC_FUNCTION_P (decl) = 1;
14585 /* Initialize the variables used during compilation of a C++
14589 cxx_push_function_context (f)
14590 struct function *f;
14592 struct language_function *p
14593 = ((struct language_function *)
14594 ggc_alloc_cleared (sizeof (struct language_function)));
14597 /* It takes an explicit call to expand_body to generate RTL for a
14601 /* Whenever we start a new function, we destroy temporaries in the
14603 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14606 /* Free the language-specific parts of F, now that we've finished
14607 compiling the function. */
14610 cxx_pop_function_context (f)
14611 struct function *f;
14616 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14617 one of the language-independent trees. */
14619 enum cp_tree_node_structure_enum
14620 cp_tree_node_structure (t)
14621 union lang_tree_node *t;
14623 switch (TREE_CODE (&t->generic))
14625 case DEFAULT_ARG: return TS_CP_IDENTIFIER;
14626 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
14627 case CPLUS_BINDING: return TS_CP_BINDING;
14628 case OVERLOAD: return TS_CP_OVERLOAD;
14629 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
14630 case PTRMEM_CST: return TS_CP_PTRMEM;
14631 case WRAPPER: return TS_CP_WRAPPER;
14632 case SRCLOC: return TS_CP_SRCLOC;
14633 default: return TS_CP_GENERIC;
14637 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14638 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
14641 identifier_global_value (t)
14644 return IDENTIFIER_GLOBAL_VALUE (t);
14647 /* Build the void_list_node (void_type_node having been created). */
14649 build_void_list_node ()
14651 tree t = build_tree_list (NULL_TREE, void_type_node);
14652 TREE_PARMLIST (t) = 1;
14657 cp_missing_noreturn_ok_p (decl)
14660 /* A missing noreturn is ok for the `main' function. */
14661 return DECL_MAIN_P (decl);
14664 #include "gt-cp-decl.h"
14665 #include "gtype-cp.h"