]> gcc.gnu.org Git - gcc.git/blame - gcc/cp/decl.c
* Makefile.in (FLAGS_TO_PASS): Fix typo.
[gcc.git] / gcc / cp / decl.c
CommitLineData
e5e809f4
JL
1/* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92-97, 1998 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
8d08fdba
MS
4
5This file is part of GNU CC.
6
7GNU CC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
11
12GNU CC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GNU CC; see the file COPYING. If not, write to
e9fa0c7c
RK
19the Free Software Foundation, 59 Temple Place - Suite 330,
20Boston, MA 02111-1307, USA. */
8d08fdba
MS
21
22
23/* Process declarations and symbol lookup for C front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
26
27/* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
29
8d08fdba 30#include "config.h"
8d052bc7 31#include "system.h"
8d08fdba
MS
32#include "tree.h"
33#include "rtl.h"
34#include "flags.h"
35#include "cp-tree.h"
36#include "decl.h"
37#include "lex.h"
8d08fdba
MS
38#include <signal.h>
39#include "obstack.h"
72b7eeff 40#include "defaults.h"
49c249e1
JM
41#include "output.h"
42#include "except.h"
54f92bfb 43#include "toplev.h"
8d08fdba
MS
44
45#define obstack_chunk_alloc xmalloc
46#define obstack_chunk_free free
47
8d2733ca
MS
48extern tree builtin_return_address_fndecl;
49
8d08fdba 50extern struct obstack permanent_obstack;
ae0a6181 51extern struct obstack* saveable_obstack;
8d08fdba
MS
52
53extern int current_class_depth;
54
e1cd6e56
MS
55extern tree static_ctors, static_dtors;
56
42976354
BK
57extern int static_labelno;
58
30394414
JM
59extern tree current_namespace;
60extern tree global_namespace;
61
62c154ed
JM
62extern void (*print_error_function) PROTO((char *));
63
8d08fdba
MS
64/* Stack of places to restore the search obstack back to. */
65
66/* Obstack used for remembering local class declarations (like
67 enums and static (const) members. */
68#include "stack.h"
5566b478 69struct obstack decl_obstack;
8d08fdba
MS
70static struct stack_level *decl_stack;
71
72#ifndef CHAR_TYPE_SIZE
73#define CHAR_TYPE_SIZE BITS_PER_UNIT
74#endif
75
76#ifndef SHORT_TYPE_SIZE
77#define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
78#endif
79
80#ifndef INT_TYPE_SIZE
81#define INT_TYPE_SIZE BITS_PER_WORD
82#endif
83
84#ifndef LONG_TYPE_SIZE
85#define LONG_TYPE_SIZE BITS_PER_WORD
86#endif
87
88#ifndef LONG_LONG_TYPE_SIZE
89#define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
90#endif
91
92#ifndef WCHAR_UNSIGNED
93#define WCHAR_UNSIGNED 0
94#endif
95
96#ifndef FLOAT_TYPE_SIZE
97#define FLOAT_TYPE_SIZE BITS_PER_WORD
98#endif
99
100#ifndef DOUBLE_TYPE_SIZE
101#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
102#endif
103
104#ifndef LONG_DOUBLE_TYPE_SIZE
105#define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
106#endif
107
255512c1 108#ifndef BOOL_TYPE_SIZE
e1cd6e56 109#ifdef SLOW_BYTE_ACCESS
d2e5ee5c 110#define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
e1cd6e56 111#else
d2e5ee5c 112#define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
e1cd6e56 113#endif
255512c1
JM
114#endif
115
8d08fdba
MS
116/* We let tm.h override the types used here, to handle trivial differences
117 such as the choice of unsigned int or long unsigned int for size_t.
118 When machines start needing nontrivial differences in the size type,
119 it would be best to do something here to figure out automatically
120 from other information what type to use. */
121
122#ifndef SIZE_TYPE
123#define SIZE_TYPE "long unsigned int"
124#endif
125
126#ifndef PTRDIFF_TYPE
127#define PTRDIFF_TYPE "long int"
128#endif
129
130#ifndef WCHAR_TYPE
131#define WCHAR_TYPE "int"
132#endif
133
8d08fdba
MS
134static tree grokparms PROTO((tree, int));
135static tree lookup_nested_type PROTO((tree, tree));
136static char *redeclaration_error_message PROTO((tree, tree));
bd6dd845 137static tree push_overloaded_decl PROTO((tree, int));
8d08fdba 138
49c249e1
JM
139static struct stack_level *push_decl_level PROTO((struct stack_level *,
140 struct obstack *));
141static void push_binding_level PROTO((struct binding_level *, int,
142 int));
143static void pop_binding_level PROTO((void));
144static void suspend_binding_level PROTO((void));
145static void resume_binding_level PROTO((struct binding_level *));
146static struct binding_level *make_binding_level PROTO((void));
147static int namespace_bindings_p PROTO((void));
148static void declare_namespace_level PROTO((void));
49c249e1
JM
149static void signal_catch PROTO((int));
150static void storedecls PROTO((tree));
151static void storetags PROTO((tree));
152static void require_complete_types_for_parms PROTO((tree));
153static void push_overloaded_decl_1 PROTO((tree));
154static int ambi_op_p PROTO((tree));
155static int unary_op_p PROTO((tree));
156static tree store_bindings PROTO((tree, tree));
157static tree lookup_tag_reverse PROTO((tree, tree));
158static tree obscure_complex_init PROTO((tree, tree));
159static tree maybe_build_cleanup_1 PROTO((tree, tree));
3e3f722c 160static tree lookup_name_real PROTO((tree, int, int, int));
49c249e1 161static void warn_extern_redeclared_static PROTO((tree, tree));
a703fb38 162static void grok_reference_init PROTO((tree, tree, tree));
386b8a85 163static tree grokfndecl PROTO((tree, tree, tree, tree, int,
2c73f9f5
ML
164 enum overload_flags, tree,
165 tree, tree, int, int, int, int, int, int, tree));
166static tree grokvardecl PROTO((tree, tree, RID_BIT_TYPE *, int, int, tree));
49c249e1
JM
167static tree lookup_tag PROTO((enum tree_code, tree,
168 struct binding_level *, int));
169static void set_identifier_type_value_with_scope
170 PROTO((tree, tree, struct binding_level *));
c6160f8f
JM
171static void set_identifier_local_value_with_scope
172 PROTO((tree, tree, struct binding_level *));
49c249e1 173static void record_builtin_type PROTO((enum rid, char *, tree));
036407f7 174static void record_unknown_type PROTO((tree, char *));
49c249e1
JM
175static int member_function_or_else PROTO((tree, tree, char *));
176static void bad_specifiers PROTO((tree, char *, int, int, int, int,
177 int));
62c154ed 178static void lang_print_error_function PROTO((char *));
39c01e4c 179static tree maybe_process_template_type_declaration PROTO((tree, int, struct binding_level*));
8d08fdba 180
69ac77ce
JL
181#if defined (DEBUG_CP_BINDING_LEVELS)
182static void indent PROTO((void));
183#endif
184
2c73f9f5 185/* A node which has tree code ERROR_MARK, and whose type is itself.
8d08fdba
MS
186 All erroneous expressions are replaced with this node. All functions
187 that accept nodes as arguments should avoid generating error messages
188 if this node is one of the arguments, since it is undesirable to get
189 multiple error messages from one error in the input. */
190
191tree error_mark_node;
192
193/* Erroneous argument lists can use this *IFF* they do not modify it. */
194tree error_mark_list;
195
196/* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
197
198tree short_integer_type_node;
199tree integer_type_node;
200tree long_integer_type_node;
201tree long_long_integer_type_node;
202
203tree short_unsigned_type_node;
204tree unsigned_type_node;
205tree long_unsigned_type_node;
206tree long_long_unsigned_type_node;
207
208tree ptrdiff_type_node;
209
210tree unsigned_char_type_node;
211tree signed_char_type_node;
212tree char_type_node;
213tree wchar_type_node;
214tree signed_wchar_type_node;
215tree unsigned_wchar_type_node;
216
f376e137
MS
217tree wchar_decl_node;
218
8d08fdba
MS
219tree float_type_node;
220tree double_type_node;
221tree long_double_type_node;
222
37c46b43
MS
223tree complex_integer_type_node;
224tree complex_float_type_node;
225tree complex_double_type_node;
226tree complex_long_double_type_node;
227
8d08fdba
MS
228tree intQI_type_node;
229tree intHI_type_node;
230tree intSI_type_node;
231tree intDI_type_node;
f7554e8c 232tree intTI_type_node;
8d08fdba
MS
233
234tree unsigned_intQI_type_node;
235tree unsigned_intHI_type_node;
236tree unsigned_intSI_type_node;
237tree unsigned_intDI_type_node;
f7554e8c 238tree unsigned_intTI_type_node;
8d08fdba 239
eff71ab0
PB
240tree java_byte_type_node;
241tree java_short_type_node;
242tree java_int_type_node;
243tree java_long_type_node;
244tree java_float_type_node;
245tree java_double_type_node;
246tree java_char_type_node;
247tree java_boolean_type_node;
248
2c73f9f5 249/* A VOID_TYPE node, and the same, packaged in a TREE_LIST. */
8d08fdba
MS
250
251tree void_type_node, void_list_node;
252tree void_zero_node;
253
254/* Nodes for types `void *' and `const void *'. */
255
bd6dd845 256tree ptr_type_node;
6c20b7e9 257tree const_ptr_type_node;
8d08fdba
MS
258
259/* Nodes for types `char *' and `const char *'. */
260
261tree string_type_node, const_string_type_node;
262
263/* Type `char[256]' or something like it.
264 Used when an array of char is needed and the size is irrelevant. */
265
266tree char_array_type_node;
267
268/* Type `int[256]' or something like it.
269 Used when an array of int needed and the size is irrelevant. */
270
271tree int_array_type_node;
272
273/* Type `wchar_t[256]' or something like it.
274 Used when a wide string literal is created. */
275
276tree wchar_array_type_node;
277
2986ae00 278/* The bool data type, and constants */
255512c1 279tree boolean_type_node, boolean_true_node, boolean_false_node;
2986ae00 280
2c73f9f5 281/* Type `int ()' -- used for implicit declaration of functions. */
8d08fdba
MS
282
283tree default_function_type;
284
2c73f9f5 285/* Function types `double (double)' and `double (double, double)', etc. */
8d08fdba 286
bd6dd845
MS
287static tree double_ftype_double, double_ftype_double_double;
288static tree int_ftype_int, long_ftype_long;
289static tree float_ftype_float;
290static tree ldouble_ftype_ldouble;
8d08fdba 291
8d08fdba 292/* Function type `int (const void *, const void *, size_t)' */
5566b478 293static tree int_ftype_cptr_cptr_sizet;
8d08fdba
MS
294
295/* C++ extensions */
700f8a87 296tree vtable_entry_type;
8d08fdba 297tree delta_type_node;
db5ae43f 298#if 0
e92cc029 299/* Old rtti stuff. */
db5ae43f
MS
300tree __baselist_desc_type_node;
301tree __i_desc_type_node, __m_desc_type_node;
8d08fdba 302tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
db5ae43f 303#endif
5566b478
MS
304tree __t_desc_type_node;
305#if 0
306tree __tp_desc_type_node;
307#endif
db5ae43f
MS
308tree __access_mode_type_node;
309tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
310tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
311tree __ptmf_desc_type_node, __ptmd_desc_type_node;
312#if 0
313/* Not needed yet? May be needed one day? */
314tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
315tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
316tree __ptmf_desc_array_type, __ptmd_desc_array_type;
317#endif
318
2c73f9f5
ML
319/* Indicates that there is a type value in some namespace, although
320 that is not necessarily in scope at the moment. */
321
322static tree global_type_node;
323
8d08fdba
MS
324tree class_star_type_node;
325tree class_type_node, record_type_node, union_type_node, enum_type_node;
db5ae43f 326tree unknown_type_node;
8d08fdba
MS
327tree opaque_type_node, signature_type_node;
328tree sigtable_entry_type;
8d08fdba 329
8d08fdba
MS
330/* Array type `vtable_entry_type[]' */
331tree vtbl_type_node;
332
6633d636
MS
333/* namespace std */
334tree std_node;
2c73f9f5 335int in_std = 0;
6633d636 336
3e3f722c
ML
337/* Expect only namespace names now. */
338static int only_namespace_names;
339
8d08fdba
MS
340/* In a destructor, the point at which all derived class destroying
341 has been done, just before any base class destroying will be done. */
342
343tree dtor_label;
344
72b7eeff
MS
345/* In a destructor, the last insn emitted after the start of the
346 function and the parms. */
347
bd6dd845 348static rtx last_dtor_insn;
72b7eeff 349
b87692e5 350/* In a constructor, the last insn emitted after the start of the
9664b89e
JM
351 function and the parms, the exception specification and any
352 function-try-block. The constructor initializers are emitted after
353 this insn. */
b87692e5
MS
354
355static rtx last_parm_cleanup_insn;
356
8d08fdba
MS
357/* In a constructor, the point at which we are ready to return
358 the pointer to the initialized object. */
359
360tree ctor_label;
361
8d08fdba
MS
362/* A FUNCTION_DECL which can call `abort'. Not necessarily the
363 one that the user will declare, but sufficient to be called
364 by routines that want to abort the program. */
365
366tree abort_fndecl;
367
368extern rtx cleanup_label, return_label;
369
370/* If original DECL_RESULT of current function was a register,
371 but due to being an addressable named return value, would up
372 on the stack, this variable holds the named return value's
373 original location. */
bd6dd845 374static rtx original_result_rtx;
8d08fdba
MS
375
376/* Sequence of insns which represents base initialization. */
a9aedbc2 377tree base_init_expr;
8d08fdba
MS
378
379/* C++: Keep these around to reduce calls to `get_identifier'.
380 Identifiers for `this' in member functions and the auto-delete
381 parameter for destructors. */
382tree this_identifier, in_charge_identifier;
fc378698 383tree ctor_identifier, dtor_identifier;
e92cc029 384/* Used in pointer to member functions, in vtables, and in sigtables. */
8d08fdba 385tree pfn_identifier, index_identifier, delta_identifier, delta2_identifier;
9dd70aa4 386tree pfn_or_delta2_identifier, tag_identifier;
5566b478 387tree vt_off_identifier;
8d08fdba 388
e349ee73
MS
389struct named_label_list
390{
391 struct binding_level *binding_level;
392 tree names_in_scope;
393 tree label_decl;
394 char *filename_o_goto;
395 int lineno_o_goto;
396 struct named_label_list *next;
397};
398
8d08fdba
MS
399/* A list (chain of TREE_LIST nodes) of named label uses.
400 The TREE_PURPOSE field is the list of variables defined
38e01259 401 in the label's scope defined at the point of use.
8d08fdba
MS
402 The TREE_VALUE field is the LABEL_DECL used.
403 The TREE_TYPE field holds `current_binding_level' at the
404 point of the label's use.
405
e349ee73
MS
406 BWAHAHAAHAHahhahahahaah. No, no, no, said the little chicken.
407
408 Look at the pretty struct named_label_list. See the pretty struct
409 with the pretty named fields that describe what they do. See the
410 pretty lack of gratuitous casts. Notice the code got a lot cleaner.
411
8d08fdba
MS
412 Used only for jumps to as-yet undefined labels, since
413 jumps to defined labels can have their validity checked
414 by stmt.c. */
415
e349ee73 416static struct named_label_list *named_label_uses = NULL;
8d08fdba
MS
417
418/* A list of objects which have constructors or destructors
419 which reside in the global scope. The decl is stored in
420 the TREE_VALUE slot and the initializer is stored
421 in the TREE_PURPOSE slot. */
422tree static_aggregates;
423
8d08fdba
MS
424/* -- end of C++ */
425
426/* Two expressions that are constants with value zero.
427 The first is of type `int', the second of type `void *'. */
428
429tree integer_zero_node;
430tree null_pointer_node;
431
03d0f4af
MM
432/* The value for __null (NULL), namely, a zero of an integer type with
433 the same number of bits as a pointer. */
d11ad92e
MS
434tree null_node;
435
8d08fdba
MS
436/* A node for the integer constants 1, 2, and 3. */
437
438tree integer_one_node, integer_two_node, integer_three_node;
439
8d08fdba
MS
440/* While defining an enum type, this is 1 plus the last enumerator
441 constant value. */
442
443static tree enum_next_value;
444
7177d104
MS
445/* Nonzero means that there was overflow computing enum_next_value. */
446
447static int enum_overflow;
448
8d08fdba
MS
449/* Parsing a function declarator leaves a list of parameter names
450 or a chain or parameter decls here. */
451
452tree last_function_parms;
453
454/* Parsing a function declarator leaves here a chain of structure
455 and enum types declared in the parmlist. */
456
457static tree last_function_parm_tags;
458
459/* After parsing the declarator that starts a function definition,
460 `start_function' puts here the list of parameter names or chain of decls.
461 `store_parm_decls' finds it here. */
462
463static tree current_function_parms;
464
465/* Similar, for last_function_parm_tags. */
466static tree current_function_parm_tags;
467
468/* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
469 that have names. Here so we can clear out their names' definitions
470 at the end of the function. */
471
472static tree named_labels;
473
474/* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
475
476static tree shadowed_labels;
477
8d08fdba
MS
478/* The FUNCTION_DECL for the function currently being compiled,
479 or 0 if between functions. */
480tree current_function_decl;
481
482/* Set to 0 at beginning of a function definition, set to 1 if
483 a return statement that specifies a return value is seen. */
484
485int current_function_returns_value;
486
487/* Set to 0 at beginning of a function definition, set to 1 if
488 a return statement with no argument is seen. */
489
490int current_function_returns_null;
491
492/* Set to 0 at beginning of a function definition, and whenever
493 a label (case or named) is defined. Set to value of expression
494 returned from function when that value can be transformed into
495 a named return value. */
496
497tree current_function_return_value;
498
499/* Set to nonzero by `grokdeclarator' for a function
500 whose return type is defaulted, if warnings for this are desired. */
501
502static int warn_about_return_type;
503
8d08fdba
MS
504/* Nonzero means give `double' the same size as `float'. */
505
506extern int flag_short_double;
507
508/* Nonzero means don't recognize any builtin functions. */
509
510extern int flag_no_builtin;
511
00595019
MS
512/* Nonzero means don't recognize the non-ANSI builtin functions.
513 -ansi sets this. */
514
515extern int flag_no_nonansi_builtin;
516
e1cd6e56
MS
517/* Nonzero means enable obscure ANSI features and disable GNU extensions
518 that might cause ANSI-compliant code to be miscompiled. */
8d08fdba
MS
519
520extern int flag_ansi;
521
522/* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
e92cc029 523 objects. */
8d08fdba
MS
524extern int flag_huge_objects;
525
526/* Nonzero if we want to conserve space in the .o files. We do this
527 by putting uninitialized data and runtime initialized data into
ddd5a7c1 528 .common instead of .data at the expense of not flagging multiple
8d08fdba
MS
529 definitions. */
530extern int flag_conserve_space;
531
532/* Pointers to the base and current top of the language name stack. */
533
534extern tree *current_lang_base, *current_lang_stack;
535\f
51c184be 536/* C and C++ flags are in decl2.c. */
8d08fdba
MS
537
538/* Set to 0 at beginning of a constructor, set to 1
539 if that function does an allocation before referencing its
540 instance variable. */
5566b478 541static int current_function_assigns_this;
8d08fdba
MS
542int current_function_just_assigned_this;
543
544/* Set to 0 at beginning of a function. Set non-zero when
545 store_parm_decls is called. Don't call store_parm_decls
546 if this flag is non-zero! */
547int current_function_parms_stored;
548
51c184be 549/* Flag used when debugging spew.c */
8d08fdba
MS
550
551extern int spew_debug;
552
553/* This is a copy of the class_shadowed list of the previous class binding
554 contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
555 when entering another class scope (i.e. a cache miss). */
556extern tree previous_class_values;
557
e92cc029
MS
558/* A expression of value 0 with the same precision as a sizetype
559 node, but signed. */
560tree signed_size_zero_node;
561
8d08fdba
MS
562\f
563/* Allocate a level of searching. */
e92cc029 564
824b9a4c 565static
8d08fdba
MS
566struct stack_level *
567push_decl_level (stack, obstack)
568 struct stack_level *stack;
569 struct obstack *obstack;
570{
571 struct stack_level tem;
572 tem.prev = stack;
573
574 return push_stack_level (obstack, (char *)&tem, sizeof (tem));
575}
576\f
577/* For each binding contour we allocate a binding_level structure
e92cc029
MS
578 which records the names defined in that contour.
579 Contours include:
580 0) the global one
581 1) one for each function definition,
582 where internal declarations of the parameters appear.
583 2) one for each compound statement,
584 to record its declarations.
585
586 The current meaning of a name can be found by searching the levels
587 from the current one out to the global one.
588
589 Off to the side, may be the class_binding_level. This exists only
590 to catch class-local declarations. It is otherwise nonexistent.
591
592 Also there may be binding levels that catch cleanups that must be
593 run when exceptions occur. */
8d08fdba
MS
594
595/* Note that the information in the `names' component of the global contour
596 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
597
598struct binding_level
599 {
600 /* A chain of _DECL nodes for all variables, constants, functions,
e92cc029
MS
601 and typedef types. These are in the reverse of the order
602 supplied. */
8d08fdba
MS
603 tree names;
604
e92cc029
MS
605 /* A list of structure, union and enum definitions, for looking up
606 tag names.
607 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
608 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
609 or ENUMERAL_TYPE node.
610
611 C++: the TREE_VALUE nodes can be simple types for
612 component_bindings. */
8d08fdba
MS
613 tree tags;
614
2c73f9f5
ML
615 /* A list of USING_DECL nodes. */
616 tree usings;
617
ea9635c7
ML
618 /* A list of used namespaces. PURPOSE is the namespace,
619 VALUE the common ancestor with this binding_level's namespace. */
620 tree using_directives;
621
8d08fdba
MS
622 /* For each level, a list of shadowed outer-level local definitions
623 to be restored when this level is popped.
624 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
625 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
626 tree shadowed;
627
628 /* Same, for IDENTIFIER_CLASS_VALUE. */
629 tree class_shadowed;
630
631 /* Same, for IDENTIFIER_TYPE_VALUE. */
632 tree type_shadowed;
633
634 /* For each level (except not the global one),
635 a chain of BLOCK nodes for all the levels
636 that were entered and exited one level down. */
637 tree blocks;
638
639 /* The BLOCK node for this level, if one has been preallocated.
640 If 0, the BLOCK is allocated (if needed) when the level is popped. */
641 tree this_block;
642
643 /* The binding level which this one is contained in (inherits from). */
644 struct binding_level *level_chain;
645
f30432d7 646 /* List of decls in `names' that have incomplete
8d08fdba 647 structure or union types. */
f30432d7 648 tree incomplete;
8d08fdba 649
8d6e462b 650 /* List of VAR_DECLS saved from a previous for statement.
abc95ed3 651 These would be dead in ANSI-conforming code, but might
d22c8596 652 be referenced in ARM-era code. */
8d6e462b
PB
653 tree dead_vars_from_for;
654
8d08fdba
MS
655 /* 1 for the level that holds the parameters of a function.
656 2 for the level that holds a class declaration.
657 3 for levels that hold parameter declarations. */
658 unsigned parm_flag : 4;
659
660 /* 1 means make a BLOCK for this level regardless of all else.
661 2 for temporary binding contours created by the compiler. */
662 unsigned keep : 3;
663
664 /* Nonzero if this level "doesn't exist" for tags. */
665 unsigned tag_transparent : 1;
666
667 /* Nonzero if this level can safely have additional
668 cleanup-needing variables added to it. */
669 unsigned more_cleanups_ok : 1;
670 unsigned have_cleanups : 1;
671
5566b478
MS
672 /* Nonzero if this level is for storing the decls for template
673 parameters and generic decls; these decls will be discarded and
674 replaced with a TEMPLATE_DECL. */
8d08fdba
MS
675 unsigned pseudo_global : 1;
676
a9aedbc2
MS
677 /* This is set for a namespace binding level. */
678 unsigned namespace_p : 1;
679
2ee887f2 680 /* True if this level is that of a for-statement where we need to
d22c8596 681 worry about ambiguous (ARM or ANSI) scope rules. */
8d6e462b
PB
682 unsigned is_for_scope : 1;
683
5566b478 684 /* Two bits left for this word. */
8d08fdba
MS
685
686#if defined(DEBUG_CP_BINDING_LEVELS)
687 /* Binding depth at which this level began. */
688 unsigned binding_depth;
689#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
690 };
691
692#define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
693
694/* The (non-class) binding level currently in effect. */
695
696static struct binding_level *current_binding_level;
697
698/* The binding level of the current class, if any. */
699
700static struct binding_level *class_binding_level;
701
702/* The current (class or non-class) binding level currently in effect. */
703
704#define inner_binding_level \
705 (class_binding_level ? class_binding_level : current_binding_level)
706
707/* A chain of binding_level structures awaiting reuse. */
708
709static struct binding_level *free_binding_level;
710
711/* The outermost binding level, for names of file scope.
712 This is created when the compiler is started and exists
713 through the entire run. */
714
715static struct binding_level *global_binding_level;
716
717/* Binding level structures are initialized by copying this one. */
718
719static struct binding_level clear_binding_level;
720
721/* Nonzero means unconditionally make a BLOCK for the next level pushed. */
722
723static int keep_next_level_flag;
724
725#if defined(DEBUG_CP_BINDING_LEVELS)
726static int binding_depth = 0;
727static int is_class_level = 0;
728
729static void
730indent ()
731{
732 register unsigned i;
733
734 for (i = 0; i < binding_depth*2; i++)
735 putc (' ', stderr);
736}
737#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
738
739static tree pushdecl_with_scope PROTO((tree, struct binding_level *));
740
741static void
742push_binding_level (newlevel, tag_transparent, keep)
743 struct binding_level *newlevel;
744 int tag_transparent, keep;
745{
746 /* Add this level to the front of the chain (stack) of levels that
747 are active. */
748 *newlevel = clear_binding_level;
749 if (class_binding_level)
750 {
751 newlevel->level_chain = class_binding_level;
752 class_binding_level = (struct binding_level *)0;
753 }
754 else
755 {
756 newlevel->level_chain = current_binding_level;
757 }
758 current_binding_level = newlevel;
759 newlevel->tag_transparent = tag_transparent;
760 newlevel->more_cleanups_ok = 1;
8d08fdba
MS
761 newlevel->keep = keep;
762#if defined(DEBUG_CP_BINDING_LEVELS)
763 newlevel->binding_depth = binding_depth;
764 indent ();
765 fprintf (stderr, "push %s level 0x%08x line %d\n",
766 (is_class_level) ? "class" : "block", newlevel, lineno);
767 is_class_level = 0;
768 binding_depth++;
769#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
770}
771
772static void
773pop_binding_level ()
774{
775 if (class_binding_level)
776 current_binding_level = class_binding_level;
777
778 if (global_binding_level)
779 {
2c73f9f5 780 /* Cannot pop a level, if there are none left to pop. */
8d08fdba
MS
781 if (current_binding_level == global_binding_level)
782 my_friendly_abort (123);
783 }
784 /* Pop the current level, and free the structure for reuse. */
785#if defined(DEBUG_CP_BINDING_LEVELS)
786 binding_depth--;
787 indent ();
788 fprintf (stderr, "pop %s level 0x%08x line %d\n",
789 (is_class_level) ? "class" : "block",
790 current_binding_level, lineno);
791 if (is_class_level != (current_binding_level == class_binding_level))
9e9ff709
MS
792 {
793 indent ();
794 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
795 }
8d08fdba
MS
796 is_class_level = 0;
797#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
798 {
799 register struct binding_level *level = current_binding_level;
800 current_binding_level = current_binding_level->level_chain;
801 level->level_chain = free_binding_level;
802#if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
803 if (level->binding_depth != binding_depth)
804 abort ();
805#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
806 free_binding_level = level;
807
808 class_binding_level = current_binding_level;
809 if (class_binding_level->parm_flag != 2)
810 class_binding_level = 0;
811 while (current_binding_level->parm_flag == 2)
812 current_binding_level = current_binding_level->level_chain;
813 }
814}
a9aedbc2
MS
815
816static void
817suspend_binding_level ()
818{
819 if (class_binding_level)
820 current_binding_level = class_binding_level;
821
822 if (global_binding_level)
823 {
2c73f9f5 824 /* Cannot suspend a level, if there are none left to suspend. */
a9aedbc2
MS
825 if (current_binding_level == global_binding_level)
826 my_friendly_abort (123);
827 }
828 /* Suspend the current level. */
829#if defined(DEBUG_CP_BINDING_LEVELS)
830 binding_depth--;
831 indent ();
832 fprintf (stderr, "suspend %s level 0x%08x line %d\n",
833 (is_class_level) ? "class" : "block",
834 current_binding_level, lineno);
835 if (is_class_level != (current_binding_level == class_binding_level))
9e9ff709
MS
836 {
837 indent ();
838 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
839 }
a9aedbc2
MS
840 is_class_level = 0;
841#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
842 {
a9aedbc2 843 current_binding_level = current_binding_level->level_chain;
a9aedbc2
MS
844 class_binding_level = current_binding_level;
845 if (class_binding_level->parm_flag != 2)
846 class_binding_level = 0;
847 while (current_binding_level->parm_flag == 2)
848 current_binding_level = current_binding_level->level_chain;
849 }
850}
851
824b9a4c 852static void
a9aedbc2
MS
853resume_binding_level (b)
854 struct binding_level *b;
855{
2c73f9f5
ML
856 /* Resuming binding levels is meant only for namespaces,
857 and those cannot nest into classes. */
858 my_friendly_assert(!class_binding_level, 386);
859 /* Also, resuming a non-directly nested namespace is a no-no. */
860 my_friendly_assert(b->level_chain == current_binding_level, 386);
a9aedbc2
MS
861 current_binding_level = b;
862#if defined(DEBUG_CP_BINDING_LEVELS)
863 b->binding_depth = binding_depth;
864 indent ();
865 fprintf (stderr, "resume %s level 0x%08x line %d\n",
866 (is_class_level) ? "class" : "block", b, lineno);
867 is_class_level = 0;
868 binding_depth++;
869#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
870}
8d08fdba 871\f
cffa8729
MS
872/* Create a new `struct binding_level'. */
873
874static
875struct binding_level *
876make_binding_level ()
877{
878 /* NOSTRICT */
879 return (struct binding_level *) xmalloc (sizeof (struct binding_level));
880}
881
8d08fdba
MS
882/* Nonzero if we are currently in the global binding level. */
883
884int
885global_bindings_p ()
886{
887 return current_binding_level == global_binding_level;
888}
889
a9aedbc2
MS
890/* Nonzero if we are currently in a toplevel binding level. This
891 means either the global binding level or a namespace in a toplevel
2c73f9f5
ML
892 binding level.
893 Since there are no non-toplevel namespace levels, this really
894 means any namespace or pseudo-global level. */
a9aedbc2
MS
895
896int
897toplevel_bindings_p ()
898{
2c73f9f5
ML
899 return current_binding_level->namespace_p
900 || current_binding_level->pseudo_global;
a9aedbc2
MS
901}
902
903/* Nonzero if this is a namespace scope. */
904
824b9a4c 905static int
a9aedbc2
MS
906namespace_bindings_p ()
907{
908 return current_binding_level->namespace_p;
909}
910
8d08fdba
MS
911void
912keep_next_level ()
913{
914 keep_next_level_flag = 1;
915}
916
917/* Nonzero if the current level needs to have a BLOCK made. */
918
919int
920kept_level_p ()
921{
922 return (current_binding_level->blocks != NULL_TREE
923 || current_binding_level->keep
924 || current_binding_level->names != NULL_TREE
925 || (current_binding_level->tags != NULL_TREE
926 && !current_binding_level->tag_transparent));
927}
928
929/* Identify this binding level as a level of parameters. */
930
931void
932declare_parm_level ()
933{
934 current_binding_level->parm_flag = 1;
935}
936
8d08fdba
MS
937void
938declare_pseudo_global_level ()
939{
940 current_binding_level->pseudo_global = 1;
941}
942
824b9a4c 943static void
a9aedbc2
MS
944declare_namespace_level ()
945{
946 current_binding_level->namespace_p = 1;
947}
948
8d08fdba
MS
949int
950pseudo_global_level_p ()
951{
952 return current_binding_level->pseudo_global;
953}
954
955void
956set_class_shadows (shadows)
957 tree shadows;
958{
959 class_binding_level->class_shadowed = shadows;
960}
961
962/* Enter a new binding level.
963 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
964 not for that of tags. */
965
966void
967pushlevel (tag_transparent)
968 int tag_transparent;
969{
970 register struct binding_level *newlevel = NULL_BINDING_LEVEL;
971
972 /* If this is the top level of a function,
973 just make sure that NAMED_LABELS is 0.
974 They should have been set to 0 at the end of the previous function. */
975
976 if (current_binding_level == global_binding_level)
977 my_friendly_assert (named_labels == NULL_TREE, 134);
978
979 /* Reuse or create a struct for this binding level. */
980
981#if defined(DEBUG_CP_BINDING_LEVELS)
982 if (0)
983#else /* !defined(DEBUG_CP_BINDING_LEVELS) */
984 if (free_binding_level)
985#endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
986 {
987 newlevel = free_binding_level;
988 free_binding_level = free_binding_level->level_chain;
989 }
990 else
991 {
cffa8729 992 newlevel = make_binding_level ();
8d08fdba 993 }
cffa8729 994
8d08fdba
MS
995 push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
996 GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
997 keep_next_level_flag = 0;
998}
999
5566b478 1000void
8d6e462b
PB
1001note_level_for_for ()
1002{
1003 current_binding_level->is_for_scope = 1;
1004}
1005
8d08fdba
MS
1006void
1007pushlevel_temporary (tag_transparent)
1008 int tag_transparent;
1009{
1010 pushlevel (tag_transparent);
1011 current_binding_level->keep = 2;
1012 clear_last_expr ();
1013
1014 /* Note we don't call push_momentary() here. Otherwise, it would cause
1015 cleanups to be allocated on the momentary obstack, and they will be
1016 overwritten by the next statement. */
1017
1018 expand_start_bindings (0);
1019}
1020
1021/* Exit a binding level.
1022 Pop the level off, and restore the state of the identifier-decl mappings
1023 that were in effect when this level was entered.
1024
1025 If KEEP == 1, this level had explicit declarations, so
1026 and create a "block" (a BLOCK node) for the level
1027 to record its declarations and subblocks for symbol table output.
1028
1029 If KEEP == 2, this level's subblocks go to the front,
1030 not the back of the current binding level. This happens,
1031 for instance, when code for constructors and destructors
1032 need to generate code at the end of a function which must
1033 be moved up to the front of the function.
1034
1035 If FUNCTIONBODY is nonzero, this level is the body of a function,
1036 so create a block as if KEEP were set and also clear out all
1037 label names.
1038
1039 If REVERSE is nonzero, reverse the order of decls before putting
1040 them into the BLOCK. */
1041
1042tree
1043poplevel (keep, reverse, functionbody)
1044 int keep;
1045 int reverse;
1046 int functionbody;
1047{
1048 register tree link;
1049 /* The chain of decls was accumulated in reverse order.
1050 Put it into forward order, just for cleanliness. */
1051 tree decls;
1052 int tmp = functionbody;
8d08fdba
MS
1053 int real_functionbody = current_binding_level->keep == 2
1054 ? ((functionbody = 0), tmp) : functionbody;
1055 tree tags = functionbody >= 0 ? current_binding_level->tags : 0;
1056 tree subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1057 tree block = NULL_TREE;
1058 tree decl;
1059 int block_previously_created;
1060
1061 GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1062 (HOST_WIDE_INT) current_binding_level->level_chain,
1063 current_binding_level->parm_flag,
5566b478 1064 current_binding_level->keep);
8d08fdba
MS
1065
1066 if (current_binding_level->keep == 1)
1067 keep = 1;
1068
8d08fdba
MS
1069 /* Get the decls in the order they were written.
1070 Usually current_binding_level->names is in reverse order.
1071 But parameter decls were previously put in forward order. */
1072
1073 if (reverse)
1074 current_binding_level->names
1075 = decls = nreverse (current_binding_level->names);
1076 else
1077 decls = current_binding_level->names;
1078
1079 /* Output any nested inline functions within this block
1080 if they weren't already output. */
1081
1082 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1083 if (TREE_CODE (decl) == FUNCTION_DECL
1084 && ! TREE_ASM_WRITTEN (decl)
1085 && DECL_INITIAL (decl) != NULL_TREE
6060a796
MS
1086 && TREE_ADDRESSABLE (decl)
1087 && decl_function_context (decl) == current_function_decl)
8d08fdba
MS
1088 {
1089 /* If this decl was copied from a file-scope decl
1090 on account of a block-scope extern decl,
1091 propagate TREE_ADDRESSABLE to the file-scope decl. */
1092 if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1093 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1094 else
1095 {
1096 push_function_context ();
1097 output_inline_function (decl);
1098 pop_function_context ();
1099 }
1100 }
1101
1102 /* If there were any declarations or structure tags in that level,
1103 or if this level is a function body,
1104 create a BLOCK to record them for the life of this function. */
1105
1106 block = NULL_TREE;
1107 block_previously_created = (current_binding_level->this_block != NULL_TREE);
1108 if (block_previously_created)
1109 block = current_binding_level->this_block;
1110 else if (keep == 1 || functionbody)
1111 block = make_node (BLOCK);
1112 if (block != NULL_TREE)
1113 {
72b7eeff
MS
1114 if (block_previously_created)
1115 {
1116 if (decls || tags || subblocks)
1117 {
be99da77 1118 if (BLOCK_VARS (block) || BLOCK_TYPE_TAGS (block))
72b7eeff
MS
1119 {
1120 warning ("internal compiler error: debugging info corrupted");
1121 }
1122 BLOCK_VARS (block) = decls;
1123 BLOCK_TYPE_TAGS (block) = tags;
be99da77
MS
1124
1125 /* We can have previous subblocks and new subblocks when
1126 doing fixup_gotos with complex cleanups. We chain the new
1127 subblocks onto the end of any pre-existing subblocks. */
1128 BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1129 subblocks);
72b7eeff 1130 }
be99da77
MS
1131 /* If we created the block earlier on, and we are just
1132 diddling it now, then it already should have a proper
1133 BLOCK_END_NOTE value associated with it. */
72b7eeff
MS
1134 }
1135 else
1136 {
1137 BLOCK_VARS (block) = decls;
1138 BLOCK_TYPE_TAGS (block) = tags;
1139 BLOCK_SUBBLOCKS (block) = subblocks;
1140 /* Otherwise, for a new block, install a new BLOCK_END_NOTE value. */
1141 remember_end_note (block);
1142 }
8d08fdba
MS
1143 }
1144
1145 /* In each subblock, record that this is its superior. */
1146
1147 if (keep >= 0)
1148 for (link = subblocks; link; link = TREE_CHAIN (link))
1149 BLOCK_SUPERCONTEXT (link) = block;
1150
1151 /* Clear out the meanings of the local variables of this level. */
1152
8d6e462b
PB
1153 if (current_binding_level->is_for_scope && flag_new_for_scope == 1)
1154 {
2ee887f2 1155 struct binding_level *outer = current_binding_level->level_chain;
8d6e462b
PB
1156 for (link = decls; link; link = TREE_CHAIN (link))
1157 {
1158 if (TREE_CODE (link) == VAR_DECL)
1159 DECL_DEAD_FOR_LOCAL (link) = 1;
e76a2646
MS
1160 else
1161 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = NULL_TREE;
8d6e462b 1162 }
2ee887f2
MS
1163
1164 /* Save declarations made in a 'for' statement so we can support pre-ANSI
e92cc029 1165 'for' scoping semantics. */
2ee887f2
MS
1166
1167 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1168 {
1169 tree id = TREE_PURPOSE (link);
1170 tree decl = IDENTIFIER_LOCAL_VALUE (id);
1171
e76a2646
MS
1172 if (decl && DECL_DEAD_FOR_LOCAL (decl))
1173 {
1174 /* In this case keep the dead for-decl visible,
e92cc029 1175 but remember what (if anything) it shadowed. */
e76a2646
MS
1176 DECL_SHADOWED_FOR_VAR (decl) = TREE_VALUE (link);
1177 TREE_CHAIN (decl) = outer->dead_vars_from_for;
1178 outer->dead_vars_from_for = decl;
1179 }
1180 else
1181 IDENTIFIER_LOCAL_VALUE (id) = TREE_VALUE (link);
2ee887f2 1182 }
8d6e462b 1183 }
e92cc029 1184 else /* Not special for scope. */
8d6e462b
PB
1185 {
1186 for (link = decls; link; link = TREE_CHAIN (link))
1187 {
1188 if (DECL_NAME (link) != NULL_TREE)
8d08fdba 1189 {
8d6e462b
PB
1190 /* If the ident. was used or addressed via a local extern decl,
1191 don't forget that fact. */
1192 if (DECL_EXTERNAL (link))
1193 {
1194 if (TREE_USED (link))
1195 TREE_USED (DECL_ASSEMBLER_NAME (link)) = 1;
1196 if (TREE_ADDRESSABLE (link))
1197 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1198 }
1199 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = NULL_TREE;
8d08fdba 1200 }
8d08fdba 1201 }
8d08fdba 1202
2ee887f2
MS
1203 /* Restore all name-meanings of the outer levels
1204 that were shadowed by this level. */
8d08fdba 1205
2ee887f2
MS
1206 for (link = current_binding_level->shadowed;
1207 link; link = TREE_CHAIN (link))
1208 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1209
1210 /* We first restore the regular decls and *then* the dead_vars_from_for
1211 to handle this case:
1212
1213 int i; // i#1
1214 {
1215 for (int i; ; ) { ...} // i#2
1216 int i; // i#3
1217 } // we are here
1218
1219 In this case, we want remove the binding for i#3, restoring
1220 that of i#2. Then we want to remove the binding for i#2,
e92cc029 1221 and restore that of i#1. */
2ee887f2
MS
1222
1223 link = current_binding_level->dead_vars_from_for;
1224 for (; link != NULL_TREE; link = TREE_CHAIN (link))
8d6e462b 1225 {
2ee887f2
MS
1226 tree id = DECL_NAME (link);
1227 if (IDENTIFIER_LOCAL_VALUE (id) == link)
1228 IDENTIFIER_LOCAL_VALUE (id) = DECL_SHADOWED_FOR_VAR (link);
8d6e462b
PB
1229 }
1230
2ee887f2
MS
1231 for (link = current_binding_level->class_shadowed;
1232 link; link = TREE_CHAIN (link))
1233 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1234 for (link = current_binding_level->type_shadowed;
1235 link; link = TREE_CHAIN (link))
2c73f9f5 1236 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
8d6e462b 1237 }
8d08fdba
MS
1238
1239 /* If the level being exited is the top level of a function,
1240 check over all the labels. */
1241
1242 if (functionbody)
1243 {
1244 /* If this is the top level block of a function,
1245 the vars are the function's parameters.
1246 Don't leave them in the BLOCK because they are
1247 found in the FUNCTION_DECL instead. */
1248
1249 BLOCK_VARS (block) = 0;
1250
1251 /* Clear out the definitions of all label names,
1252 since their scopes end here. */
1253
1254 for (link = named_labels; link; link = TREE_CHAIN (link))
1255 {
1256 register tree label = TREE_VALUE (link);
1257
1258 if (DECL_INITIAL (label) == NULL_TREE)
1259 {
1260 cp_error_at ("label `%D' used but not defined", label);
1261 /* Avoid crashing later. */
1262 define_label (input_filename, 1, DECL_NAME (label));
1263 }
1264 else if (warn_unused && !TREE_USED (label))
1265 cp_warning_at ("label `%D' defined but not used", label);
1266 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), NULL_TREE);
1267
1268 /* Put the labels into the "variables" of the
1269 top-level block, so debugger can see them. */
1270 TREE_CHAIN (label) = BLOCK_VARS (block);
1271 BLOCK_VARS (block) = label;
1272 }
1273
1274 named_labels = NULL_TREE;
1275 }
1276
1277 /* Any uses of undefined labels now operate under constraints
1278 of next binding contour. */
1279 {
1280 struct binding_level *level_chain;
1281 level_chain = current_binding_level->level_chain;
1282 if (level_chain)
1283 {
e349ee73
MS
1284 struct named_label_list *labels;
1285 for (labels = named_label_uses; labels; labels = labels->next)
1286 if (labels->binding_level == current_binding_level)
8d08fdba 1287 {
e349ee73
MS
1288 labels->binding_level = level_chain;
1289 labels->names_in_scope = level_chain->names;
8d08fdba
MS
1290 }
1291 }
1292 }
1293
1294 tmp = current_binding_level->keep;
1295
1296 pop_binding_level ();
1297 if (functionbody)
1298 DECL_INITIAL (current_function_decl) = block;
1299 else if (block)
1300 {
1301 if (!block_previously_created)
1302 current_binding_level->blocks
1303 = chainon (current_binding_level->blocks, block);
1304 }
1305 /* If we did not make a block for the level just exited,
1306 any blocks made for inner levels
1307 (since they cannot be recorded as subblocks in that level)
1308 must be carried forward so they will later become subblocks
1309 of something else. */
1310 else if (subblocks)
1311 {
1312 if (keep == 2)
1313 current_binding_level->blocks
1314 = chainon (subblocks, current_binding_level->blocks);
1315 else
1316 current_binding_level->blocks
1317 = chainon (current_binding_level->blocks, subblocks);
1318 }
1319
1320 /* Take care of compiler's internal binding structures. */
a4443a08 1321 if (tmp == 2)
8d08fdba 1322 {
8d08fdba
MS
1323 expand_end_bindings (getdecls (), keep, 1);
1324 /* Each and every BLOCK node created here in `poplevel' is important
1325 (e.g. for proper debugging information) so if we created one
1326 earlier, mark it as "used". */
1327 if (block)
1328 TREE_USED (block) = 1;
1329 block = poplevel (keep, reverse, real_functionbody);
1330 }
1331
1332 /* Each and every BLOCK node created here in `poplevel' is important
1333 (e.g. for proper debugging information) so if we created one
1334 earlier, mark it as "used". */
1335 if (block)
1336 TREE_USED (block) = 1;
1337 return block;
1338}
1339
1340/* Delete the node BLOCK from the current binding level.
1341 This is used for the block inside a stmt expr ({...})
1342 so that the block can be reinserted where appropriate. */
1343
1344void
1345delete_block (block)
1346 tree block;
1347{
1348 tree t;
1349 if (current_binding_level->blocks == block)
1350 current_binding_level->blocks = TREE_CHAIN (block);
1351 for (t = current_binding_level->blocks; t;)
1352 {
1353 if (TREE_CHAIN (t) == block)
1354 TREE_CHAIN (t) = TREE_CHAIN (block);
1355 else
1356 t = TREE_CHAIN (t);
1357 }
1358 TREE_CHAIN (block) = NULL_TREE;
1359 /* Clear TREE_USED which is always set by poplevel.
1360 The flag is set again if insert_block is called. */
1361 TREE_USED (block) = 0;
1362}
1363
1364/* Insert BLOCK at the end of the list of subblocks of the
1365 current binding level. This is used when a BIND_EXPR is expanded,
1366 to handle the BLOCK node inside the BIND_EXPR. */
1367
1368void
1369insert_block (block)
1370 tree block;
1371{
1372 TREE_USED (block) = 1;
1373 current_binding_level->blocks
1374 = chainon (current_binding_level->blocks, block);
1375}
1376
8d08fdba
MS
1377/* Set the BLOCK node for the innermost scope
1378 (the one we are currently in). */
1379
1380void
1381set_block (block)
1382 register tree block;
1383{
1384 current_binding_level->this_block = block;
1385}
1386
1387/* Do a pushlevel for class declarations. */
e92cc029 1388
8d08fdba
MS
1389void
1390pushlevel_class ()
1391{
1392 register struct binding_level *newlevel;
1393
1394 /* Reuse or create a struct for this binding level. */
1395#if defined(DEBUG_CP_BINDING_LEVELS)
1396 if (0)
1397#else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1398 if (free_binding_level)
1399#endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1400 {
1401 newlevel = free_binding_level;
1402 free_binding_level = free_binding_level->level_chain;
1403 }
1404 else
1405 {
cffa8729 1406 newlevel = make_binding_level ();
8d08fdba
MS
1407 }
1408
1409#if defined(DEBUG_CP_BINDING_LEVELS)
1410 is_class_level = 1;
1411#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1412
1413 push_binding_level (newlevel, 0, 0);
1414
1415 decl_stack = push_decl_level (decl_stack, &decl_obstack);
1416 class_binding_level = current_binding_level;
1417 class_binding_level->parm_flag = 2;
1418 /* We have just pushed into a new binding level. Now, fake out the rest
1419 of the compiler. Set the `current_binding_level' back to point to
1420 the most closely containing non-class binding level. */
1421 do
1422 {
1423 current_binding_level = current_binding_level->level_chain;
1424 }
1425 while (current_binding_level->parm_flag == 2);
1426}
1427
700f8a87
MS
1428/* ...and a poplevel for class declarations. FORCE is used to force
1429 clearing out of CLASS_VALUEs after a class definition. */
e92cc029 1430
8d08fdba 1431tree
700f8a87
MS
1432poplevel_class (force)
1433 int force;
8d08fdba
MS
1434{
1435 register struct binding_level *level = class_binding_level;
1436 tree block = NULL_TREE;
1437 tree shadowed;
1438
1439 my_friendly_assert (level != 0, 354);
1440
1441 decl_stack = pop_stack_level (decl_stack);
1442 for (shadowed = level->shadowed; shadowed; shadowed = TREE_CHAIN (shadowed))
1443 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1444 /* If we're leaving a toplevel class, don't bother to do the setting
ddd5a7c1 1445 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
8d08fdba 1446 shouldn't even be used when current_class_type isn't set, and second,
ddd5a7c1 1447 if we don't touch it here, we're able to use the cache effect if the
8d08fdba 1448 next time we're entering a class scope, it is the same class. */
700f8a87 1449 if (current_class_depth != 1 || force)
8d08fdba
MS
1450 for (shadowed = level->class_shadowed;
1451 shadowed;
1452 shadowed = TREE_CHAIN (shadowed))
1453 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1454 else
1455 /* Remember to save what IDENTIFIER's were bound in this scope so we
1456 can recover from cache misses. */
e76a2646
MS
1457 {
1458 previous_class_type = current_class_type;
1459 previous_class_values = class_binding_level->class_shadowed;
1460 }
8d08fdba
MS
1461 for (shadowed = level->type_shadowed;
1462 shadowed;
1463 shadowed = TREE_CHAIN (shadowed))
2c73f9f5 1464 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
8d08fdba
MS
1465
1466 GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1467 (HOST_WIDE_INT) class_binding_level->level_chain,
1468 class_binding_level->parm_flag,
5566b478 1469 class_binding_level->keep);
8d08fdba
MS
1470
1471 if (class_binding_level->parm_flag != 2)
1472 class_binding_level = (struct binding_level *)0;
1473
38e01259 1474 /* Now, pop out of the binding level which we created up in the
8d08fdba
MS
1475 `pushlevel_class' routine. */
1476#if defined(DEBUG_CP_BINDING_LEVELS)
1477 is_class_level = 1;
1478#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1479
1480 pop_binding_level ();
1481
1482 return block;
1483}
1484\f
1485/* For debugging. */
5566b478
MS
1486static int no_print_functions = 0;
1487static int no_print_builtins = 0;
8d08fdba
MS
1488
1489void
1490print_binding_level (lvl)
1491 struct binding_level *lvl;
1492{
1493 tree t;
1494 int i = 0, len;
1495 fprintf (stderr, " blocks=");
1496 fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1497 fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
f30432d7 1498 list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
8d08fdba
MS
1499 if (lvl->tag_transparent)
1500 fprintf (stderr, " tag-transparent");
1501 if (lvl->more_cleanups_ok)
1502 fprintf (stderr, " more-cleanups-ok");
1503 if (lvl->have_cleanups)
1504 fprintf (stderr, " have-cleanups");
8d08fdba
MS
1505 fprintf (stderr, "\n");
1506 if (lvl->names)
1507 {
1508 fprintf (stderr, " names:\t");
1509 /* We can probably fit 3 names to a line? */
1510 for (t = lvl->names; t; t = TREE_CHAIN (t))
1511 {
fc378698 1512 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
8d08fdba
MS
1513 continue;
1514 if (no_print_builtins
fc378698
MS
1515 && (TREE_CODE (t) == TYPE_DECL)
1516 && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
8d08fdba
MS
1517 continue;
1518
1519 /* Function decls tend to have longer names. */
1520 if (TREE_CODE (t) == FUNCTION_DECL)
1521 len = 3;
1522 else
1523 len = 2;
1524 i += len;
1525 if (i > 6)
1526 {
1527 fprintf (stderr, "\n\t");
1528 i = len;
1529 }
1530 print_node_brief (stderr, "", t, 0);
bd6dd845 1531 if (t == error_mark_node)
8d08fdba
MS
1532 break;
1533 }
1534 if (i)
1535 fprintf (stderr, "\n");
1536 }
1537 if (lvl->tags)
1538 {
1539 fprintf (stderr, " tags:\t");
1540 i = 0;
1541 for (t = lvl->tags; t; t = TREE_CHAIN (t))
1542 {
1543 if (TREE_PURPOSE (t) == NULL_TREE)
1544 len = 3;
1545 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1546 len = 2;
1547 else
1548 len = 4;
1549 i += len;
1550 if (i > 5)
1551 {
1552 fprintf (stderr, "\n\t");
1553 i = len;
1554 }
1555 if (TREE_PURPOSE (t) == NULL_TREE)
1556 {
1557 print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1558 fprintf (stderr, ">");
1559 }
1560 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1561 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1562 else
1563 {
1564 print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1565 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1566 fprintf (stderr, ">");
1567 }
1568 }
1569 if (i)
1570 fprintf (stderr, "\n");
1571 }
1572 if (lvl->shadowed)
1573 {
1574 fprintf (stderr, " shadowed:");
1575 for (t = lvl->shadowed; t; t = TREE_CHAIN (t))
1576 {
1577 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1578 }
1579 fprintf (stderr, "\n");
1580 }
1581 if (lvl->class_shadowed)
1582 {
1583 fprintf (stderr, " class-shadowed:");
1584 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1585 {
1586 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1587 }
1588 fprintf (stderr, "\n");
1589 }
1590 if (lvl->type_shadowed)
1591 {
1592 fprintf (stderr, " type-shadowed:");
1593 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1594 {
8d08fdba 1595 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
8d08fdba
MS
1596 }
1597 fprintf (stderr, "\n");
1598 }
1599}
1600
1601void
1602print_other_binding_stack (stack)
1603 struct binding_level *stack;
1604{
1605 struct binding_level *level;
1606 for (level = stack; level != global_binding_level; level = level->level_chain)
1607 {
1608 fprintf (stderr, "binding level ");
1609 fprintf (stderr, HOST_PTR_PRINTF, level);
1610 fprintf (stderr, "\n");
1611 print_binding_level (level);
1612 }
1613}
1614
1615void
1616print_binding_stack ()
1617{
1618 struct binding_level *b;
1619 fprintf (stderr, "current_binding_level=");
1620 fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1621 fprintf (stderr, "\nclass_binding_level=");
1622 fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1623 fprintf (stderr, "\nglobal_binding_level=");
1624 fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1625 fprintf (stderr, "\n");
1626 if (class_binding_level)
1627 {
1628 for (b = class_binding_level; b; b = b->level_chain)
1629 if (b == current_binding_level)
1630 break;
1631 if (b)
1632 b = class_binding_level;
1633 else
1634 b = current_binding_level;
1635 }
1636 else
1637 b = current_binding_level;
1638 print_other_binding_stack (b);
1639 fprintf (stderr, "global:\n");
1640 print_binding_level (global_binding_level);
1641}
a9aedbc2 1642
2c73f9f5
ML
1643/* Namespace binding access routines: The namespace_bindings field of
1644 the identifier is polymorphic, with three possible values:
1645 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1646 indicating the BINDING_VALUE of global_namespace. */
30394414 1647
2c73f9f5
ML
1648/* Check whether the a binding for the name to scope is known.
1649 Assumes that the bindings of the name are already a list
1650 of bindings. Returns the binding found, or NULL_TREE. */
1651
1652static tree
1653find_binding (name, scope)
30394414
JM
1654 tree name;
1655 tree scope;
1656{
2c73f9f5 1657 tree iter, prev = NULL_TREE;
3e3f722c
ML
1658
1659 scope = ORIGINAL_NAMESPACE (scope);
1660
30394414
JM
1661 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
1662 iter = TREE_CHAIN (iter))
1663 {
1664 my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
1665 if (BINDING_SCOPE (iter) == scope)
2c73f9f5
ML
1666 {
1667 /* Move binding found to the fron of the list, so
1668 subsequent lookups will find it faster. */
1669 if (prev)
1670 {
1671 TREE_CHAIN (prev) = TREE_CHAIN (iter);
1672 TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
1673 IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
1674 }
1675 return iter;
1676 }
1677 prev = iter;
30394414 1678 }
2c73f9f5
ML
1679 return NULL_TREE;
1680}
1681
1682/* Always returns a binding for name in scope. If the
1683 namespace_bindings is not a list, convert it to one first.
1684 If no binding is found, make a new one. */
1685
1686tree
1687binding_for_name (name, scope)
1688 tree name;
1689 tree scope;
1690{
1691 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1692 tree result;
3e3f722c
ML
1693
1694 scope = ORIGINAL_NAMESPACE (scope);
1695
2c73f9f5
ML
1696 if (b && TREE_CODE (b) != CPLUS_BINDING)
1697 {
1698 /* Get rid of optimization for global scope. */
1699 IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
1700 BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
1701 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1702 }
1703 if (b && (result = find_binding (name, scope)))
1704 return result;
1705 /* Not found, make a new permanent one. */
30394414 1706 push_obstacks (&permanent_obstack, &permanent_obstack);
2c73f9f5
ML
1707 result = make_node (CPLUS_BINDING);
1708 TREE_CHAIN (result) = b;
1709 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1710 BINDING_SCOPE (result) = scope;
1711 BINDING_TYPE (result) = NULL_TREE;
1712 BINDING_VALUE (result) = NULL_TREE;
30394414 1713 pop_obstacks ();
2c73f9f5
ML
1714 return result;
1715}
1716
1717/* Return the binding value for name in scope, considering that
1718 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
1719
1720tree
1721namespace_binding (name, scope)
1722 tree name;
1723 tree scope;
1724{
1725 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1726 if (b == NULL_TREE)
1727 return NULL_TREE;
cb0dbb9a
JM
1728 if (scope == NULL_TREE)
1729 scope = global_namespace;
2c73f9f5
ML
1730 if (TREE_CODE (b) != CPLUS_BINDING)
1731 return (scope == global_namespace) ? b : NULL_TREE;
1732 name = find_binding (name,scope);
1733 if (name == NULL_TREE)
1734 return name;
1735 return BINDING_VALUE (name);
1736}
1737
1738/* Set the binding value for name in scope. If modifying the binding
1739 of global_namespace is attempted, try to optimize it. */
1740
1741void
1742set_namespace_binding (name, scope, val)
1743 tree name;
1744 tree scope;
1745 tree val;
1746{
1747 tree b;
cb0dbb9a
JM
1748
1749 if (scope == NULL_TREE)
1750 scope = global_namespace;
1751
2c73f9f5
ML
1752 if (scope == global_namespace)
1753 {
1754 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1755 if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
1756 {
1757 IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
1758 return;
1759 }
1760 }
1761 b = binding_for_name (name, scope);
1762 BINDING_VALUE (b) = val;
30394414
JM
1763}
1764
dff6b454
RK
1765/* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
1766 select a name that is unique to this compilation unit. */
e92cc029 1767
a9aedbc2
MS
1768void
1769push_namespace (name)
1770 tree name;
1771{
30394414
JM
1772 tree d;
1773 int need_new = 1;
1774 int implicit_use = 0;
2c73f9f5 1775 int global = 0;
30394414
JM
1776 if (!global_namespace)
1777 {
2c73f9f5 1778 /* This must be ::. */
30394414 1779 my_friendly_assert (name == get_identifier ("::"), 377);
2c73f9f5 1780 global = 1;
30394414
JM
1781 }
1782 else if (!name)
1783 {
3ab52652
ML
1784 /* The name of anonymous namespace is unique for the translation
1785 unit. */
1786 static tree anon_name = NULL_TREE;
1787 if (!anon_name)
1788 anon_name = get_file_function_name ('N');
1789 name = anon_name;
1790 d = IDENTIFIER_NAMESPACE_VALUE (name);
1791 if (d)
1792 /* Reopening anonymous namespace. */
1793 need_new = 0;
30394414 1794 implicit_use = 1;
2c73f9f5
ML
1795 }
1796 else if (current_namespace == global_namespace
1797 && name == DECL_NAME (std_node))
1798 {
1799 in_std++;
1800 return;
1801 }
30394414
JM
1802 else
1803 {
2c73f9f5 1804 /* Check whether this is an extended namespace definition. */
30394414
JM
1805 d = IDENTIFIER_NAMESPACE_VALUE (name);
1806 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3e3f722c
ML
1807 {
1808 need_new = 0;
1809 if (DECL_NAMESPACE_ALIAS (d))
1810 {
1811 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
1812 d, DECL_NAMESPACE_ALIAS (d));
1813 d = DECL_NAMESPACE_ALIAS (d);
1814 }
1815 }
30394414 1816 }
6633d636 1817
30394414
JM
1818 if (need_new)
1819 {
2c73f9f5 1820 /* Make a new namespace, binding the name to it. */
6b57ac29 1821 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2c73f9f5
ML
1822 /* The global namespace is not pushed, and the global binding
1823 level is set elsewhere. */
1824 if (!global)
1825 {
1826 d = pushdecl (d);
1827 pushlevel (0);
1828 declare_namespace_level ();
1829 NAMESPACE_LEVEL (d) = current_binding_level;
1830 }
30394414 1831 }
2c73f9f5
ML
1832 else
1833 resume_binding_level (NAMESPACE_LEVEL (d));
1834
30394414
JM
1835 if (implicit_use)
1836 do_using_directive (d);
2c73f9f5 1837 /* Enter the name space. */
30394414 1838 current_namespace = d;
a9aedbc2
MS
1839}
1840
1841/* Pop from the scope of the current namespace. */
e92cc029 1842
a9aedbc2
MS
1843void
1844pop_namespace ()
1845{
2c73f9f5
ML
1846 if (current_namespace == global_namespace)
1847 {
1848 my_friendly_assert (in_std>0, 980421);
1849 in_std--;
1850 return;
1851 }
cb0dbb9a 1852 current_namespace = CP_DECL_CONTEXT (current_namespace);
2c73f9f5
ML
1853 /* The binding level is not popped, as it might be re-opened later. */
1854 suspend_binding_level ();
1855}
a9aedbc2 1856
2c73f9f5 1857/* Concatenate the binding levels of all namespaces. */
a9aedbc2 1858
2c73f9f5
ML
1859void
1860cat_namespace_levels()
1861{
1862 tree current;
1863 tree last;
1864 struct binding_level *b;
a9aedbc2 1865
2c73f9f5
ML
1866 last = NAMESPACE_LEVEL (global_namespace) -> names;
1867 /* The nested namespaces appear in the names list of their ancestors. */
1868 for (current = last; current; current = TREE_CHAIN (current))
a9aedbc2 1869 {
85c6cbaf
ML
1870 if (TREE_CODE (current) != NAMESPACE_DECL
1871 || DECL_NAMESPACE_ALIAS (current))
2c73f9f5
ML
1872 continue;
1873 if (!DECL_LANG_SPECIFIC (current))
a9aedbc2 1874 {
2c73f9f5
ML
1875 /* Hmm. std. */
1876 my_friendly_assert (current == std_node, 393);
1877 continue;
a9aedbc2 1878 }
2c73f9f5
ML
1879 b = NAMESPACE_LEVEL (current);
1880 while (TREE_CHAIN (last))
1881 last = TREE_CHAIN (last);
1882 TREE_CHAIN (last) = NAMESPACE_LEVEL (current) -> names;
a9aedbc2 1883 }
a9aedbc2 1884}
8d08fdba
MS
1885\f
1886/* Subroutines for reverting temporarily to top-level for instantiation
1887 of templates and such. We actually need to clear out the class- and
1888 local-value slots of all identifiers, so that only the global values
1889 are at all visible. Simply setting current_binding_level to the global
1890 scope isn't enough, because more binding levels may be pushed. */
1891struct saved_scope {
1892 struct binding_level *old_binding_level;
1893 tree old_bindings;
2c73f9f5 1894 tree old_namespace;
8d08fdba 1895 struct saved_scope *prev;
5f34005f 1896 tree class_name, class_type, function_decl;
8d08fdba 1897 struct binding_level *class_bindings;
51c184be
MS
1898 tree *lang_base, *lang_stack, lang_name;
1899 int lang_stacksize;
5566b478
MS
1900 int minimal_parse_mode;
1901 tree last_function_parms;
e76a2646 1902 tree template_parms;
5156628f 1903 HOST_WIDE_INT processing_template_decl;
a50f0918 1904 tree previous_class_type, previous_class_values;
e1467ff2
MM
1905 int processing_specialization;
1906 int processing_explicit_instantiation;
8d08fdba
MS
1907};
1908static struct saved_scope *current_saved_scope;
8d08fdba 1909
78957a2a
JM
1910/* A chain of the binding vecs created by store_bindings. We create a
1911 whole bunch of these during compilation, on permanent_obstack, so we
1912 can't just throw them away. */
1913static tree free_binding_vecs;
1914
e92cc029 1915static tree
45537677
MS
1916store_bindings (names, old_bindings)
1917 tree names, old_bindings;
1918{
1919 tree t;
1920 for (t = names; t; t = TREE_CHAIN (t))
1921 {
1922 tree binding, t1, id;
1923
1924 if (TREE_CODE (t) == TREE_LIST)
1925 id = TREE_PURPOSE (t);
1926 else
1927 id = DECL_NAME (t);
1928
1929 if (!id
1930 || (!IDENTIFIER_LOCAL_VALUE (id)
1931 && !IDENTIFIER_CLASS_VALUE (id)))
1932 continue;
1933
1934 for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
1935 if (TREE_VEC_ELT (t1, 0) == id)
1936 goto skip_it;
78957a2a
JM
1937
1938 if (free_binding_vecs)
1939 {
1940 binding = free_binding_vecs;
1941 free_binding_vecs = TREE_CHAIN (free_binding_vecs);
1942 }
1943 else
1944 binding = make_tree_vec (4);
1945
45537677
MS
1946 if (id)
1947 {
1948 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
1949 TREE_VEC_ELT (binding, 0) = id;
2c73f9f5 1950 TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
45537677
MS
1951 TREE_VEC_ELT (binding, 2) = IDENTIFIER_LOCAL_VALUE (id);
1952 TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
1953 IDENTIFIER_LOCAL_VALUE (id) = NULL_TREE;
1954 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
1955 }
1956 TREE_CHAIN (binding) = old_bindings;
1957 old_bindings = binding;
1958 skip_it:
1959 ;
1960 }
1961 return old_bindings;
1962}
1963
8d08fdba 1964void
5566b478
MS
1965maybe_push_to_top_level (pseudo)
1966 int pseudo;
8d08fdba 1967{
51c184be 1968 extern int current_lang_stacksize;
beb53fb8
JM
1969 struct saved_scope *s
1970 = (struct saved_scope *) xmalloc (sizeof (struct saved_scope));
5566b478 1971 struct binding_level *b = inner_binding_level;
8d08fdba
MS
1972 tree old_bindings = NULL_TREE;
1973
e349ee73
MS
1974 if (current_function_decl)
1975 push_cp_function_context (NULL_TREE);
1976
a50f0918
MS
1977 if (previous_class_type)
1978 old_bindings = store_bindings (previous_class_values, old_bindings);
1979
8d08fdba
MS
1980 /* Have to include global_binding_level, because class-level decls
1981 aren't listed anywhere useful. */
1982 for (; b; b = b->level_chain)
1983 {
1984 tree t;
1985
2c73f9f5
ML
1986 /* Template IDs are inserted into the global level. If they were
1987 inserted into namespace level, finish_file wouldn't find them
1988 when doing pending instantiations. Therefore, don't stop at
1989 namespace level, but continue until :: . */
5566b478
MS
1990 if (b == global_binding_level || (pseudo && b->pseudo_global))
1991 break;
8d08fdba 1992
45537677 1993 old_bindings = store_bindings (b->names, old_bindings);
cffa8729 1994 /* We also need to check class_shadowed to save class-level type
45537677
MS
1995 bindings, since pushclass doesn't fill in b->names. */
1996 if (b->parm_flag == 2)
cffa8729 1997 old_bindings = store_bindings (b->class_shadowed, old_bindings);
8d08fdba 1998
8d08fdba
MS
1999 /* Unwind type-value slots back to top level. */
2000 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2001 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2002 }
8d08fdba
MS
2003
2004 s->old_binding_level = current_binding_level;
5566b478 2005 current_binding_level = b;
8d08fdba 2006
2c73f9f5 2007 s->old_namespace = current_namespace;
8d08fdba
MS
2008 s->class_name = current_class_name;
2009 s->class_type = current_class_type;
8d08fdba
MS
2010 s->function_decl = current_function_decl;
2011 s->class_bindings = class_binding_level;
51c184be
MS
2012 s->lang_stack = current_lang_stack;
2013 s->lang_base = current_lang_base;
2014 s->lang_stacksize = current_lang_stacksize;
2015 s->lang_name = current_lang_name;
5566b478
MS
2016 s->minimal_parse_mode = minimal_parse_mode;
2017 s->last_function_parms = last_function_parms;
e76a2646 2018 s->template_parms = current_template_parms;
5156628f 2019 s->processing_template_decl = processing_template_decl;
a50f0918
MS
2020 s->previous_class_type = previous_class_type;
2021 s->previous_class_values = previous_class_values;
e1467ff2
MM
2022 s->processing_specialization = processing_specialization;
2023 s->processing_explicit_instantiation = processing_explicit_instantiation;
e349ee73 2024
5f34005f 2025 current_class_name = current_class_type = NULL_TREE;
8d08fdba
MS
2026 current_function_decl = NULL_TREE;
2027 class_binding_level = (struct binding_level *)0;
51c184be
MS
2028 current_lang_stacksize = 10;
2029 current_lang_stack = current_lang_base
2030 = (tree *) xmalloc (current_lang_stacksize * sizeof (tree));
2031 current_lang_name = lang_name_cplusplus;
2032 strict_prototype = strict_prototypes_lang_cplusplus;
2033 named_labels = NULL_TREE;
120722ac 2034 shadowed_labels = NULL_TREE;
5566b478 2035 minimal_parse_mode = 0;
a50f0918 2036 previous_class_type = previous_class_values = NULL_TREE;
e1467ff2
MM
2037 processing_specialization = 0;
2038 processing_explicit_instantiation = 0;
eae97bd9
MM
2039 current_template_parms = NULL_TREE;
2040 processing_template_decl = 0;
2c73f9f5 2041 current_namespace = global_namespace;
8d08fdba
MS
2042
2043 s->prev = current_saved_scope;
2044 s->old_bindings = old_bindings;
2045 current_saved_scope = s;
5566b478
MS
2046
2047 push_obstacks (&permanent_obstack, &permanent_obstack);
2048}
2049
2050void
2051push_to_top_level ()
2052{
2053 maybe_push_to_top_level (0);
8d08fdba
MS
2054}
2055
2056void
2057pop_from_top_level ()
2058{
51c184be 2059 extern int current_lang_stacksize;
8d08fdba
MS
2060 struct saved_scope *s = current_saved_scope;
2061 tree t;
2062
e76a2646 2063 /* Clear out class-level bindings cache. */
8d08fdba 2064 if (previous_class_type)
e76a2646
MS
2065 {
2066 popclass (-1);
2067 previous_class_type = NULL_TREE;
2068 }
8d08fdba 2069
5566b478
MS
2070 pop_obstacks ();
2071
8d08fdba
MS
2072 current_binding_level = s->old_binding_level;
2073 current_saved_scope = s->prev;
78957a2a 2074 for (t = s->old_bindings; t; )
8d08fdba 2075 {
78957a2a 2076 tree save = t;
8d08fdba
MS
2077 tree id = TREE_VEC_ELT (t, 0);
2078 if (id)
2079 {
2c73f9f5 2080 SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
8d08fdba
MS
2081 IDENTIFIER_LOCAL_VALUE (id) = TREE_VEC_ELT (t, 2);
2082 IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2083 }
78957a2a
JM
2084 t = TREE_CHAIN (t);
2085 TREE_CHAIN (save) = free_binding_vecs;
2086 free_binding_vecs = save;
8d08fdba 2087 }
2c73f9f5 2088 current_namespace = s->old_namespace;
8d08fdba
MS
2089 current_class_name = s->class_name;
2090 current_class_type = s->class_type;
8d08fdba
MS
2091 current_function_decl = s->function_decl;
2092 class_binding_level = s->class_bindings;
51c184be
MS
2093 free (current_lang_base);
2094 current_lang_base = s->lang_base;
2095 current_lang_stack = s->lang_stack;
2096 current_lang_name = s->lang_name;
2097 current_lang_stacksize = s->lang_stacksize;
2098 if (current_lang_name == lang_name_cplusplus)
2099 strict_prototype = strict_prototypes_lang_cplusplus;
2100 else if (current_lang_name == lang_name_c)
2101 strict_prototype = strict_prototypes_lang_c;
5566b478
MS
2102 minimal_parse_mode = s->minimal_parse_mode;
2103 last_function_parms = s->last_function_parms;
e76a2646 2104 current_template_parms = s->template_parms;
5156628f 2105 processing_template_decl = s->processing_template_decl;
a50f0918
MS
2106 previous_class_type = s->previous_class_type;
2107 previous_class_values = s->previous_class_values;
e1467ff2
MM
2108 processing_specialization = s->processing_specialization;
2109 processing_explicit_instantiation = s->processing_explicit_instantiation;
51c184be 2110
8d08fdba 2111 free (s);
e349ee73
MS
2112
2113 if (current_function_decl)
2114 pop_cp_function_context (NULL_TREE);
8d08fdba
MS
2115}
2116\f
2117/* Push a definition of struct, union or enum tag "name".
2118 into binding_level "b". "type" should be the type node,
2119 We assume that the tag "name" is not already defined.
2120
2121 Note that the definition may really be just a forward reference.
2122 In that case, the TYPE_SIZE will be a NULL_TREE.
2123
e92cc029 2124 C++ gratuitously puts all these tags in the name space. */
8d08fdba
MS
2125
2126/* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2127 record the shadowed value for this binding contour. TYPE is
2128 the type that ID maps to. */
2129
2130static void
2131set_identifier_type_value_with_scope (id, type, b)
2132 tree id;
2133 tree type;
2134 struct binding_level *b;
2135{
2c73f9f5 2136 if (!b->namespace_p)
8d08fdba 2137 {
2c73f9f5
ML
2138 /* Shadow the marker, not the real thing, so that the marker
2139 gets restored later. */
2140 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
8d08fdba
MS
2141 b->type_shadowed
2142 = tree_cons (id, old_type_value, b->type_shadowed);
2143 }
2c73f9f5
ML
2144 else
2145 {
2146 tree binding = binding_for_name (id, current_namespace);
2147 BINDING_TYPE (binding) = type;
2148 /* Store marker instead of real type. */
2149 type = global_type_node;
2150 }
8d08fdba
MS
2151 SET_IDENTIFIER_TYPE_VALUE (id, type);
2152}
2153
e92cc029 2154/* As set_identifier_type_value_with_scope, but using inner_binding_level. */
8d08fdba
MS
2155
2156void
2157set_identifier_type_value (id, type)
2158 tree id;
2159 tree type;
2160{
2161 set_identifier_type_value_with_scope (id, type, inner_binding_level);
2162}
2163
c6160f8f 2164static void
9ed182dc
JM
2165set_identifier_local_value_with_scope (id, val, b)
2166 tree id, val;
2167 struct binding_level *b;
2168{
2169 tree oldlocal;
2170 my_friendly_assert (! b->namespace_p, 980716);
2171
2172 oldlocal = IDENTIFIER_LOCAL_VALUE (id);
2173 b->shadowed = tree_cons (id, oldlocal, b->shadowed);
2174 IDENTIFIER_LOCAL_VALUE (id) = val;
2175}
2176
2177void
2178set_identifier_local_value (id, val)
2179 tree id, val;
2180{
2181 set_identifier_local_value_with_scope (id, val, current_binding_level);
2182}
2183
2c73f9f5
ML
2184/* Return the type associated with id. */
2185
2186tree
2187identifier_type_value (id)
2188 tree id;
2189{
2190 /* There is no type with that name, anywhere. */
2191 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2192 return NULL_TREE;
2193 /* This is not the type marker, but the real thing. */
2194 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2195 return REAL_IDENTIFIER_TYPE_VALUE (id);
2196 /* Have to search for it. It must be on the global level, now.
2197 Ask lookup_name not to return non-types. */
3e3f722c 2198 id = lookup_name_real (id, 2, 1, 0);
2c73f9f5
ML
2199 if (id)
2200 return TREE_TYPE (id);
2201 return NULL_TREE;
2202}
2203
a9aedbc2
MS
2204/* Pop off extraneous binding levels left over due to syntax errors.
2205
2206 We don't pop past namespaces, as they might be valid. */
e92cc029 2207
8926095f
MS
2208void
2209pop_everything ()
2210{
2211#ifdef DEBUG_CP_BINDING_LEVELS
2212 fprintf (stderr, "XXX entering pop_everything ()\n");
2213#endif
a9aedbc2 2214 while (! toplevel_bindings_p () && ! pseudo_global_level_p ())
8926095f
MS
2215 {
2216 if (class_binding_level)
2217 pop_nested_class (1);
2218 else
2219 poplevel (0, 0, 0);
2220 }
2221#ifdef DEBUG_CP_BINDING_LEVELS
2222 fprintf (stderr, "XXX leaving pop_everything ()\n");
2223#endif
2224}
2225
39c01e4c
MM
2226/* The type TYPE is being declared. If it is a class template, or a
2227 specialization of a class template, do any processing required and
2228 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2229 being declared a friend. B is the binding level at which this TYPE
2230 should be bound.
2231
2232 Returns the TYPE_DECL for TYPE, which may have been altered by this
2233 processing. */
2234
2235static tree
2236maybe_process_template_type_declaration (type, globalize, b)
2237 tree type;
2238 int globalize;
2239 struct binding_level* b;
2240{
2241 tree decl = TYPE_NAME (type);
2242
2243 if (processing_template_parmlist)
2244 /* You can't declare a new template type in a template parameter
2245 list. But, you can declare a non-template type:
2246
2247 template <class A*> struct S;
2248
2249 is a forward-declaration of `A'. */
2250 ;
2251 else
2252 {
2253 maybe_check_template_type (type);
2254
ed44da02
MM
2255 my_friendly_assert (IS_AGGR_TYPE (type)
2256 || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2257
2258
2259 if (/* If !GLOBALIZE then we are looking at a definition.
2260 It may not be a primary template. (For example, in:
39c01e4c 2261
ed44da02
MM
2262 template <class T>
2263 struct S1 { class S2 {}; }
39c01e4c 2264
ed44da02
MM
2265 we have to push_template_decl for S2.) */
2266 (processing_template_decl && !globalize)
2267 /* If we are declaring a friend template class, we will
2268 have GLOBALIZE set, since something like:
39c01e4c 2269
ed44da02
MM
2270 template <class T>
2271 struct S1 {
2272 template <class U>
2273 friend class S2;
2274 };
39c01e4c 2275
ed44da02
MM
2276 declares S2 to be at global scope. */
2277 || PROCESSING_REAL_TEMPLATE_DECL_P ())
39c01e4c
MM
2278 {
2279 /* This may change after the call to
2280 push_template_decl_real, but we want the original value. */
2281 tree name = DECL_NAME (decl);
2282
2283 decl = push_template_decl_real (decl, globalize);
2284 /* If the current binding level is the binding level for the
2285 template parameters (see the comment in
2286 begin_template_parm_list) and the enclosing level is a class
2287 scope, and we're not looking at a friend, push the
2288 declaration of the member class into the class scope. In the
2289 friend case, push_template_decl will already have put the
2290 friend into global scope, if appropriate. */
ed44da02
MM
2291 if (TREE_CODE (type) != ENUMERAL_TYPE
2292 && !globalize && b->pseudo_global
39c01e4c
MM
2293 && b->level_chain->parm_flag == 2)
2294 {
2295 pushdecl_with_scope (CLASSTYPE_TI_TEMPLATE (type),
2296 b->level_chain);
2297 /* Put this tag on the list of tags for the class, since
2298 that won't happen below because B is not the class
2299 binding level, but is instead the pseudo-global level. */
2300 b->level_chain->tags =
2301 saveable_tree_cons (name, type, b->level_chain->tags);
2302 TREE_NONLOCAL_FLAG (type) = 1;
2303 if (TYPE_SIZE (current_class_type) == NULL_TREE)
2304 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2305 }
2306 }
2307 }
2308
2309 return decl;
2310}
2311
8d08fdba 2312/* Push a tag name NAME for struct/class/union/enum type TYPE.
6757edfe 2313 Normally put it into the inner-most non-tag-transparent scope,
8d08fdba 2314 but if GLOBALIZE is true, put it in the inner-most non-class scope.
e92cc029 2315 The latter is needed for implicit declarations. */
8d08fdba
MS
2316
2317void
2318pushtag (name, type, globalize)
2319 tree name, type;
2320 int globalize;
2321{
2322 register struct binding_level *b;
7177d104 2323 tree context = 0;
2986ae00 2324 tree c_decl = 0;
8d08fdba
MS
2325
2326 b = inner_binding_level;
2327 while (b->tag_transparent
2328 || (globalize && b->parm_flag == 2))
2329 b = b->level_chain;
2330
a9aedbc2 2331 if (toplevel_bindings_p ())
8d08fdba
MS
2332 b->tags = perm_tree_cons (name, type, b->tags);
2333 else
2334 b->tags = saveable_tree_cons (name, type, b->tags);
2335
2336 if (name)
2337 {
7177d104 2338 context = type ? TYPE_CONTEXT (type) : NULL_TREE;
297dcfb3
MM
2339 if (! context)
2340 {
2341 tree cs = current_scope ();
2342
2343 if (! globalize)
2344 context = cs;
2345 else if (cs != NULL_TREE
2346 && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2347 /* When declaring a friend class of a local class, we want
2348 to inject the newly named class into the scope
2349 containing the local class, not the namespace scope. */
2350 context = hack_decl_function_context (get_type_decl (cs));
2351 }
7177d104 2352 if (context)
2986ae00 2353 c_decl = TREE_CODE (context) == FUNCTION_DECL
e1cd6e56 2354 ? context : TYPE_MAIN_DECL (context);
8d08fdba 2355
2c73f9f5
ML
2356 if (!context)
2357 context = current_namespace;
2358
8d08fdba 2359 /* Do C++ gratuitous typedefing. */
db5ae43f 2360 if (IDENTIFIER_TYPE_VALUE (name) != type)
8d08fdba 2361 {
93cdc044
JM
2362 register tree d = NULL_TREE;
2363 int newdecl = 0, in_class = 0;
8d08fdba 2364
93cdc044
JM
2365 if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2366 || b->parm_flag == 2)
2367 in_class = 1;
8d08fdba 2368 else
93cdc044
JM
2369 d = lookup_nested_type (type, c_decl);
2370
2371 if (d == NULL_TREE)
8d08fdba 2372 {
8d08fdba 2373 newdecl = 1;
a0a33927 2374 d = build_decl (TYPE_DECL, name, type);
eff71ab0
PB
2375 if (current_lang_name == lang_name_java)
2376 TYPE_FOR_JAVA (type) = 1;
00595019 2377 SET_DECL_ARTIFICIAL (d);
93cdc044
JM
2378 if (! in_class)
2379 set_identifier_type_value_with_scope (name, type, b);
2380 }
2381 else
2382 d = TYPE_MAIN_DECL (d);
2383
2384 TYPE_NAME (type) = d;
cb0dbb9a 2385 DECL_CONTEXT (d) = FROB_CONTEXT (context);
e1cd6e56 2386
39c01e4c
MM
2387 d = maybe_process_template_type_declaration (type,
2388 globalize, b);
93cdc044
JM
2389
2390 if (b->parm_flag == 2)
2391 d = pushdecl_class_level (d);
2392 else
2393 d = pushdecl_with_scope (d, b);
2394
8ccc31eb 2395 if (newdecl)
8d08fdba 2396 {
d2e5ee5c
MS
2397 if (ANON_AGGRNAME_P (name))
2398 DECL_IGNORED_P (d) = 1;
8ccc31eb 2399
5566b478 2400 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
1f06b267 2401 DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
e4a84209
MM
2402 if (!uses_template_parms (type))
2403 DECL_ASSEMBLER_NAME (d)
2404 = get_identifier (build_overload_name (type, 1, 1));
8d08fdba 2405 }
8d08fdba
MS
2406 }
2407 if (b->parm_flag == 2)
2408 {
2409 TREE_NONLOCAL_FLAG (type) = 1;
2410 if (TYPE_SIZE (current_class_type) == NULL_TREE)
2411 CLASSTYPE_TAGS (current_class_type) = b->tags;
2412 }
2413 }
2414
2415 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2416 /* Use the canonical TYPE_DECL for this node. */
2417 TYPE_STUB_DECL (type) = TYPE_NAME (type);
2418 else
2419 {
2420 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2421 will be the tagged type we just added to the current
2422 binding level. This fake NULL-named TYPE_DECL node helps
2423 dwarfout.c to know when it needs to output a
2424 representation of a tagged type, and it also gives us a
2425 convenient place to record the "scope start" address for
2426 the tagged type. */
2427
8d08fdba 2428 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
8d08fdba
MS
2429 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2430 }
2431}
2432
2433/* Counter used to create anonymous type names. */
e92cc029 2434
8d08fdba
MS
2435static int anon_cnt = 0;
2436
2437/* Return an IDENTIFIER which can be used as a name for
2438 anonymous structs and unions. */
e92cc029 2439
8d08fdba
MS
2440tree
2441make_anon_name ()
2442{
2443 char buf[32];
2444
2445 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2446 return get_identifier (buf);
2447}
2448
2449/* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2450 This keeps dbxout from getting confused. */
e92cc029 2451
8d08fdba
MS
2452void
2453clear_anon_tags ()
2454{
2455 register struct binding_level *b;
2456 register tree tags;
2457 static int last_cnt = 0;
2458
2459 /* Fast out if no new anon names were declared. */
2460 if (last_cnt == anon_cnt)
2461 return;
2462
2463 b = current_binding_level;
2464 while (b->tag_transparent)
2465 b = b->level_chain;
2466 tags = b->tags;
2467 while (tags)
2468 {
2469 /* A NULL purpose means we have already processed all tags
2470 from here to the end of the list. */
2471 if (TREE_PURPOSE (tags) == NULL_TREE)
2472 break;
2473 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2474 TREE_PURPOSE (tags) = NULL_TREE;
2475 tags = TREE_CHAIN (tags);
2476 }
2477 last_cnt = anon_cnt;
2478}
2479\f
2480/* Subroutine of duplicate_decls: return truthvalue of whether
2481 or not types of these decls match.
2482
2483 For C++, we must compare the parameter list so that `int' can match
2484 `int&' in a parameter position, but `int&' is not confused with
2485 `const int&'. */
e92cc029 2486
6060a796 2487int
8d08fdba
MS
2488decls_match (newdecl, olddecl)
2489 tree newdecl, olddecl;
2490{
2491 int types_match;
2492
a28e3c7f
MS
2493 if (TREE_CODE (newdecl) == FUNCTION_DECL
2494 && TREE_CODE (olddecl) == FUNCTION_DECL)
8d08fdba
MS
2495 {
2496 tree f1 = TREE_TYPE (newdecl);
2497 tree f2 = TREE_TYPE (olddecl);
2498 tree p1 = TYPE_ARG_TYPES (f1);
2499 tree p2 = TYPE_ARG_TYPES (f2);
2500
c5a6fc45
JM
2501 if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl)
2502 && ! (DECL_LANGUAGE (newdecl) == lang_c
2503 && DECL_LANGUAGE (olddecl) == lang_c))
2504 return 0;
2505
8d08fdba
MS
2506 /* When we parse a static member function definition,
2507 we put together a FUNCTION_DECL which thinks its type
2508 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
2509 proceed. */
2510 if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
700f8a87 2511 revert_static_member_fn (&newdecl, &f1, &p1);
8d08fdba
MS
2512 else if (TREE_CODE (f2) == METHOD_TYPE
2513 && DECL_STATIC_FUNCTION_P (newdecl))
700f8a87 2514 revert_static_member_fn (&olddecl, &f2, &p2);
8d08fdba
MS
2515
2516 /* Here we must take care of the case where new default
2517 parameters are specified. Also, warn if an old
2518 declaration becomes ambiguous because default
2519 parameters may cause the two to be ambiguous. */
2520 if (TREE_CODE (f1) != TREE_CODE (f2))
2521 {
2522 if (TREE_CODE (f1) == OFFSET_TYPE)
2523 cp_compiler_error ("`%D' redeclared as member function", newdecl);
2524 else
2525 cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
2526 return 0;
2527 }
2528
39211cd5 2529 if (comptypes (TREE_TYPE (f1), TREE_TYPE (f2), 1))
8926095f 2530 {
a28e3c7f 2531 if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
8926095f 2532 && p2 == NULL_TREE)
a28e3c7f
MS
2533 {
2534 types_match = self_promoting_args_p (p1);
2535 if (p1 == void_list_node)
2536 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2537 }
2538 else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2539 && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2540 {
2541 types_match = self_promoting_args_p (p2);
2542 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2543 }
8926095f 2544 else
a4443a08 2545 types_match = compparms (p1, p2, 3);
8926095f 2546 }
8d08fdba
MS
2547 else
2548 types_match = 0;
2549 }
51c184be
MS
2550 else if (TREE_CODE (newdecl) == TEMPLATE_DECL
2551 && TREE_CODE (olddecl) == TEMPLATE_DECL)
2552 {
f84b4be9
JM
2553 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2554 DECL_TEMPLATE_PARMS (olddecl)))
2555 return 0;
2556
2557 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2558 types_match = 1;
2559 else
2560 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2561 DECL_TEMPLATE_RESULT (newdecl));
51c184be 2562 }
8d08fdba
MS
2563 else
2564 {
2565 if (TREE_TYPE (newdecl) == error_mark_node)
2566 types_match = TREE_TYPE (olddecl) == error_mark_node;
2567 else if (TREE_TYPE (olddecl) == NULL_TREE)
2568 types_match = TREE_TYPE (newdecl) == NULL_TREE;
a0a33927
MS
2569 else if (TREE_TYPE (newdecl) == NULL_TREE)
2570 types_match = 0;
72b7eeff
MS
2571 /* Qualifiers must match, and they may be present on either, the type
2572 or the decl. */
2573 else if ((TREE_READONLY (newdecl)
2574 || TYPE_READONLY (TREE_TYPE (newdecl)))
2575 == (TREE_READONLY (olddecl)
2576 || TYPE_READONLY (TREE_TYPE (olddecl)))
2577 && (TREE_THIS_VOLATILE (newdecl)
2578 || TYPE_VOLATILE (TREE_TYPE (newdecl)))
2579 == (TREE_THIS_VOLATILE (olddecl)
2580 || TYPE_VOLATILE (TREE_TYPE (olddecl))))
2581 types_match = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (newdecl)),
2582 TYPE_MAIN_VARIANT (TREE_TYPE (olddecl)), 1);
8d08fdba 2583 else
72b7eeff 2584 types_match = 0;
8d08fdba
MS
2585 }
2586
2587 return types_match;
2588}
2589
2590/* If NEWDECL is `static' and an `extern' was seen previously,
2591 warn about it. (OLDDECL may be NULL_TREE; NAME contains
2592 information about previous usage as an `extern'.)
2593
2594 Note that this does not apply to the C++ case of declaring
2595 a variable `extern const' and then later `const'.
2596
8d08fdba
MS
2597 Don't complain about built-in functions, since they are beyond
2598 the user's control. */
2599
2600static void
2601warn_extern_redeclared_static (newdecl, olddecl)
2602 tree newdecl, olddecl;
2603{
2604 tree name;
2605
2606 static char *explicit_extern_static_warning
2607 = "`%D' was declared `extern' and later `static'";
2608 static char *implicit_extern_static_warning
2609 = "`%D' was declared implicitly `extern' and later `static'";
2610
d22c8596 2611 if (TREE_CODE (newdecl) == TYPE_DECL)
8d08fdba
MS
2612 return;
2613
2614 name = DECL_ASSEMBLER_NAME (newdecl);
faae18ab 2615 if (TREE_PUBLIC (name) && DECL_THIS_STATIC (newdecl))
8d08fdba
MS
2616 {
2617 /* It's okay to redeclare an ANSI built-in function as static,
2618 or to declare a non-ANSI built-in function as anything. */
2619 if (! (TREE_CODE (newdecl) == FUNCTION_DECL
2620 && olddecl != NULL_TREE
2621 && TREE_CODE (olddecl) == FUNCTION_DECL
2622 && (DECL_BUILT_IN (olddecl)
2623 || DECL_BUILT_IN_NONANSI (olddecl))))
2624 {
a9aedbc2 2625 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
8d08fdba
MS
2626 ? implicit_extern_static_warning
2627 : explicit_extern_static_warning, newdecl);
2628 if (olddecl != NULL_TREE)
a9aedbc2 2629 cp_pedwarn_at ("previous declaration of `%D'", olddecl);
8d08fdba
MS
2630 }
2631 }
2632}
2633
2634/* Handle when a new declaration NEWDECL has the same name as an old
2635 one OLDDECL in the same binding contour. Prints an error message
2636 if appropriate.
2637
2638 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2639 Otherwise, return 0. */
2640
51c184be 2641int
8d08fdba 2642duplicate_decls (newdecl, olddecl)
824b9a4c 2643 tree newdecl, olddecl;
8d08fdba
MS
2644{
2645 extern struct obstack permanent_obstack;
2646 unsigned olddecl_uid = DECL_UID (olddecl);
2647 int olddecl_friend = 0, types_match = 0;
0b60dfe3 2648 int new_defines_function = 0;
5566b478
MS
2649
2650 if (newdecl == olddecl)
2651 return 1;
8d08fdba 2652
8926095f 2653 types_match = decls_match (newdecl, olddecl);
8d08fdba 2654
8d08fdba
MS
2655 /* If either the type of the new decl or the type of the old decl is an
2656 error_mark_node, then that implies that we have already issued an
2657 error (earlier) for some bogus type specification, and in that case,
2658 it is rather pointless to harass the user with yet more error message
0b60dfe3 2659 about the same declaration, so just pretend the types match here. */
bd6dd845
MS
2660 if (TREE_TYPE (newdecl) == error_mark_node
2661 || TREE_TYPE (olddecl) == error_mark_node)
8d08fdba 2662 types_match = 1;
0b60dfe3
BK
2663
2664 /* Check for redeclaration and other discrepancies. */
d22c8596
MS
2665 if (TREE_CODE (olddecl) == FUNCTION_DECL
2666 && DECL_ARTIFICIAL (olddecl)
2667 && (DECL_BUILT_IN (olddecl) || DECL_BUILT_IN_NONANSI (olddecl)))
8d08fdba
MS
2668 {
2669 /* If you declare a built-in or predefined function name as static,
a4443a08
MS
2670 the old definition is overridden, but optionally warn this was a
2671 bad choice of name. Ditto for overloads. */
893de33c 2672 if (! TREE_PUBLIC (newdecl)
a4443a08
MS
2673 || (TREE_CODE (newdecl) == FUNCTION_DECL
2674 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)))
2675 {
2676 if (warn_shadow)
2677 cp_warning ("shadowing %s function `%#D'",
2678 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2679 olddecl);
2680 /* Discard the old built-in function. */
2681 return 0;
2682 }
2683 else if (! types_match)
8d08fdba 2684 {
a4443a08
MS
2685 if (TREE_CODE (newdecl) != FUNCTION_DECL)
2686 {
2687 /* If the built-in is not ansi, then programs can override
2688 it even globally without an error. */
2689 if (! DECL_BUILT_IN (olddecl))
2690 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2691 olddecl, newdecl);
2692 else
2693 {
2694 cp_error ("declaration of `%#D'", newdecl);
2695 cp_error ("conflicts with built-in declaration `%#D'",
2696 olddecl);
2697 }
2698 return 0;
2699 }
2700
8d08fdba
MS
2701 cp_warning ("declaration of `%#D'", newdecl);
2702 cp_warning ("conflicts with built-in declaration `%#D'",
2703 olddecl);
8d08fdba 2704 }
39211cd5
MS
2705 }
2706 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
2707 {
9ed182dc
JM
2708 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
2709 && TREE_CODE (newdecl) != TYPE_DECL
2710 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
2711 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
2712 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
2713 && TREE_CODE (olddecl) != TYPE_DECL
2714 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
2715 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
2716 == TYPE_DECL))))
2717 {
2718 /* We do nothing special here, because C++ does such nasty
2719 things with TYPE_DECLs. Instead, just let the TYPE_DECL
2720 get shadowed, and know that if we need to find a TYPE_DECL
2721 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
2722 slot of the identifier. */
2723 return 0;
2724 }
2725
39211cd5 2726 if ((TREE_CODE (newdecl) == FUNCTION_DECL
5566b478 2727 && DECL_FUNCTION_TEMPLATE_P (olddecl))
39211cd5 2728 || (TREE_CODE (olddecl) == FUNCTION_DECL
5566b478 2729 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
39211cd5 2730 return 0;
9ed182dc 2731
39211cd5
MS
2732 cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
2733 if (TREE_CODE (olddecl) == TREE_LIST)
2734 olddecl = TREE_VALUE (olddecl);
2735 cp_error_at ("previous declaration of `%#D'", olddecl);
2736
2737 /* New decl is completely inconsistent with the old one =>
2738 tell caller to replace the old one. */
2739
2740 return 0;
8d08fdba 2741 }
8d08fdba
MS
2742 else if (!types_match)
2743 {
8926095f 2744 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
f0e01782
MS
2745 {
2746 /* The name of a class template may not be declared to refer to
2747 any other template, class, function, object, namespace, value,
e92cc029 2748 or type in the same scope. */
5566b478
MS
2749 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
2750 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
f0e01782
MS
2751 {
2752 cp_error ("declaration of template `%#D'", newdecl);
2753 cp_error_at ("conflicts with previous declaration `%#D'",
2754 olddecl);
2755 }
ec255269
MS
2756 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
2757 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
2758 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
75650646
MM
2759 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))), 3)
2760 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2761 DECL_TEMPLATE_PARMS (olddecl)))
ec255269
MS
2762 {
2763 cp_error ("new declaration `%#D'", newdecl);
2764 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
2765 }
f0e01782
MS
2766 return 0;
2767 }
8926095f
MS
2768 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2769 {
2770 if (DECL_LANGUAGE (newdecl) == lang_c
2771 && DECL_LANGUAGE (olddecl) == lang_c)
2772 {
2773 cp_error ("declaration of C function `%#D' conflicts with",
2774 newdecl);
2775 cp_error_at ("previous declaration `%#D' here", olddecl);
2776 }
00595019 2777 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
28cbf42c 2778 TYPE_ARG_TYPES (TREE_TYPE (olddecl)), 3))
700f8a87
MS
2779 {
2780 cp_error ("new declaration `%#D'", newdecl);
2781 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
2782 }
2783 else
2784 return 0;
8926095f 2785 }
8d08fdba
MS
2786
2787 /* Already complained about this, so don't do so again. */
a4443a08 2788 else if (current_class_type == NULL_TREE
8d08fdba
MS
2789 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
2790 {
f376e137 2791 cp_error ("conflicting types for `%#D'", newdecl);
8926095f 2792 cp_error_at ("previous declaration as `%#D'", olddecl);
8d08fdba
MS
2793 }
2794 }
75650646
MM
2795 else if (TREE_CODE (newdecl) == FUNCTION_DECL
2796 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
2797 && (!DECL_TEMPLATE_INFO (newdecl)
2798 || (DECL_TI_TEMPLATE (newdecl)
2799 != DECL_TI_TEMPLATE (olddecl))))
2800 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
2801 && (!DECL_TEMPLATE_INFO (olddecl)
2802 || (DECL_TI_TEMPLATE (olddecl)
2803 != DECL_TI_TEMPLATE (newdecl))))))
386b8a85
JM
2804 /* It's OK to have a template specialization and a non-template
2805 with the same type, or to have specializations of two
75650646
MM
2806 different templates with the same type. Note that if one is a
2807 specialization, and the other is an instantiation of the same
2808 template, that we do not exit at this point. That situation
2809 can occur if we instantiate a template class, and then
2810 specialize one of its methods. This situation is legal, but
2811 the declarations must be merged in the usual way. */
2812 return 0;
2813 else if (TREE_CODE (newdecl) == FUNCTION_DECL
2814 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
2815 && !DECL_USE_TEMPLATE (newdecl))
2816 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
2817 && !DECL_USE_TEMPLATE (olddecl))))
2818 /* One of the declarations is a template instantiation, and the
2819 other is not a template at all. That's OK. */
386b8a85 2820 return 0;
85c6cbaf
ML
2821 else if (TREE_CODE (newdecl) == NAMESPACE_DECL
2822 && DECL_NAMESPACE_ALIAS (newdecl)
2823 && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
2824 /* Redeclaration of namespace alias, ignore it. */
2825 return 1;
8d08fdba
MS
2826 else
2827 {
2828 char *errmsg = redeclaration_error_message (newdecl, olddecl);
2829 if (errmsg)
2830 {
51c184be 2831 cp_error (errmsg, newdecl);
8d08fdba
MS
2832 if (DECL_NAME (olddecl) != NULL_TREE)
2833 cp_error_at ((DECL_INITIAL (olddecl)
2c73f9f5 2834 && namespace_bindings_p ())
8d08fdba
MS
2835 ? "`%#D' previously defined here"
2836 : "`%#D' previously declared here", olddecl);
2837 }
2838 else if (TREE_CODE (olddecl) == FUNCTION_DECL
2839 && DECL_INITIAL (olddecl) != NULL_TREE
2840 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
2841 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
2842 {
2843 /* Prototype decl follows defn w/o prototype. */
2844 cp_warning_at ("prototype for `%#D'", newdecl);
2845 cp_warning_at ("follows non-prototype definition here", olddecl);
2846 }
2847 else if (TREE_CODE (olddecl) == FUNCTION_DECL
2848 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
8926095f
MS
2849 {
2850 /* extern "C" int foo ();
2851 int foo () { bar (); }
2852 is OK. */
2853 if (current_lang_stack == current_lang_base)
a28e3c7f 2854 DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
8926095f
MS
2855 else
2856 {
2857 cp_error_at ("previous declaration of `%#D' with %L linkage",
2858 olddecl, DECL_LANGUAGE (olddecl));
2859 cp_error ("conflicts with new declaration with %L linkage",
2860 DECL_LANGUAGE (newdecl));
2861 }
2862 }
e1cd6e56 2863
a6f02587 2864 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
c32381b1
JM
2865 ;
2866 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
e1cd6e56
MS
2867 {
2868 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
2869 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
2870 int i = 1;
2871
2872 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
2873 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
2874
2875 for (; t1 && t1 != void_list_node;
2876 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
2877 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
2878 {
2507f3b5
RK
2879 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
2880 TREE_PURPOSE (t2)))
e1cd6e56
MS
2881 {
2882 if (pedantic)
2883 {
2884 cp_pedwarn ("default argument given for parameter %d of `%#D'",
2885 i, newdecl);
2886 cp_pedwarn_at ("after previous specification in `%#D'",
2887 olddecl);
2888 }
2889 }
2890 else
2891 {
2892 cp_error ("default argument given for parameter %d of `%#D'",
2893 i, newdecl);
da20811c 2894 cp_error_at ("after previous specification in `%#D'",
e1cd6e56
MS
2895 olddecl);
2896 }
2897 }
a5894242 2898
7fcdf4c2
MS
2899 if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
2900 && TREE_ADDRESSABLE (olddecl) && warn_inline)
dff6b454 2901 {
7fcdf4c2
MS
2902 cp_warning ("`%#D' was used before it was declared inline",
2903 newdecl);
2904 cp_warning_at ("previous non-inline declaration here",
2905 olddecl);
dff6b454 2906 }
e1cd6e56 2907 }
8ccc31eb
MS
2908 /* These bits are logically part of the type for non-functions. */
2909 else if (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
2910 || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl))
2911 {
2912 cp_pedwarn ("type qualifiers for `%#D'", newdecl);
2913 cp_pedwarn_at ("conflict with previous decl `%#D'", olddecl);
2914 }
8d08fdba
MS
2915 }
2916
2917 /* If new decl is `static' and an `extern' was seen previously,
2918 warn about it. */
2919 warn_extern_redeclared_static (newdecl, olddecl);
2920
e92cc029 2921 /* We have committed to returning 1 at this point. */
8d08fdba
MS
2922 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2923 {
2924 /* Now that functions must hold information normally held
2925 by field decls, there is extra work to do so that
2926 declaration information does not get destroyed during
2927 definition. */
2928 if (DECL_VINDEX (olddecl))
2929 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
2930 if (DECL_CONTEXT (olddecl))
2931 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2932 if (DECL_CLASS_CONTEXT (olddecl))
2933 DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
8d08fdba
MS
2934 if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
2935 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
e1cd6e56
MS
2936 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
2937 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
7215f9a0 2938 DECL_ABSTRACT_VIRTUAL_P (newdecl) |= DECL_ABSTRACT_VIRTUAL_P (olddecl);
864b83b9 2939 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
4a67c9e9 2940 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
0b60dfe3
BK
2941 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
2942
2943 /* Optionally warn about more than one declaration for the same
2944 name, but don't warn about a function declaration followed by a
2945 definition. */
2946 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
2947 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
2948 /* Don't warn about extern decl followed by definition. */
2949 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
2950 /* Don't warn about friends, let add_friend take care of it. */
2951 && ! DECL_FRIEND_P (newdecl))
2952 {
2953 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
2954 cp_warning_at ("previous declaration of `%D'", olddecl);
2955 }
8d08fdba
MS
2956 }
2957
2958 /* Deal with C++: must preserve virtual function table size. */
2959 if (TREE_CODE (olddecl) == TYPE_DECL)
2960 {
2961 register tree newtype = TREE_TYPE (newdecl);
2962 register tree oldtype = TREE_TYPE (olddecl);
2963
2964 if (newtype != error_mark_node && oldtype != error_mark_node
2965 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
2966 {
2967 CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
2968 CLASSTYPE_FRIEND_CLASSES (newtype)
2969 = CLASSTYPE_FRIEND_CLASSES (oldtype);
2970 }
8d08fdba
MS
2971 }
2972
8d08fdba
MS
2973 /* Copy all the DECL_... slots specified in the new decl
2974 except for any that we copy here from the old type. */
0b60dfe3
BK
2975 DECL_MACHINE_ATTRIBUTES (newdecl)
2976 = merge_machine_decl_attributes (olddecl, newdecl);
8d08fdba 2977
5566b478
MS
2978 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2979 {
4d85e00e
MM
2980 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
2981 DECL_TEMPLATE_RESULT (olddecl)))
2982 cp_error ("invalid redeclaration of %D", newdecl);
2983 TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
2984 DECL_TEMPLATE_PARMS (olddecl) = DECL_TEMPLATE_PARMS (newdecl);
dbfe2124
MM
2985 if (DECL_TEMPLATE_INFO (newdecl))
2986 DECL_TEMPLATE_INFO (olddecl) = DECL_TEMPLATE_INFO (newdecl);
4d85e00e
MM
2987 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
2988 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
2989 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
0b60dfe3 2990
5566b478
MS
2991 return 1;
2992 }
0b60dfe3 2993
8d08fdba
MS
2994 if (types_match)
2995 {
2996 /* Automatically handles default parameters. */
2997 tree oldtype = TREE_TYPE (olddecl);
e1cd6e56 2998 tree newtype;
8d08fdba 2999
e1cd6e56
MS
3000 /* Make sure we put the new type in the same obstack as the old one. */
3001 if (oldtype)
39211cd5
MS
3002 push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype));
3003 else
3004 {
3005 push_obstacks_nochange ();
3006 end_temporary_allocation ();
3007 }
3008
e1cd6e56
MS
3009 /* Merge the data types specified in the two decls. */
3010 newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3011
8d08fdba
MS
3012 if (TREE_CODE (newdecl) == VAR_DECL)
3013 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3014 /* Do this after calling `common_type' so that default
3015 parameters don't confuse us. */
3016 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3017 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3018 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3019 {
f30432d7 3020 TREE_TYPE (newdecl) = build_exception_variant (newtype,
8d08fdba 3021 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
f30432d7 3022 TREE_TYPE (olddecl) = build_exception_variant (newtype,
8d08fdba
MS
3023 TYPE_RAISES_EXCEPTIONS (oldtype));
3024
9a224b4a
JM
3025 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3026 && DECL_SOURCE_LINE (olddecl) != 0
da20811c 3027 && flag_exceptions
824b9a4c 3028 && ! compexcepttypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
8d08fdba 3029 {
824b9a4c 3030 cp_pedwarn ("declaration of `%D' throws different exceptions",
a28e3c7f 3031 newdecl);
824b9a4c 3032 cp_pedwarn_at ("previous declaration here", olddecl);
8d08fdba
MS
3033 }
3034 }
3035 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3036
3037 /* Lay the type out, unless already done. */
53929c47 3038 if (newtype != canonical_type_variant (oldtype)
5566b478 3039 && TREE_TYPE (newdecl) != error_mark_node
5156628f 3040 && !(processing_template_decl && uses_template_parms (newdecl)))
b7484fbe
MS
3041 layout_type (TREE_TYPE (newdecl));
3042
5566b478
MS
3043 if ((TREE_CODE (newdecl) == VAR_DECL
3044 || TREE_CODE (newdecl) == PARM_DECL
3045 || TREE_CODE (newdecl) == RESULT_DECL
3046 || TREE_CODE (newdecl) == FIELD_DECL
3047 || TREE_CODE (newdecl) == TYPE_DECL)
5156628f 3048 && !(processing_template_decl && uses_template_parms (newdecl)))
b7484fbe 3049 layout_decl (newdecl, 0);
8d08fdba
MS
3050
3051 /* Merge the type qualifiers. */
3052 if (TREE_READONLY (newdecl))
3053 TREE_READONLY (olddecl) = 1;
3054 if (TREE_THIS_VOLATILE (newdecl))
3055 TREE_THIS_VOLATILE (olddecl) = 1;
3056
3057 /* Merge the initialization information. */
8926095f
MS
3058 if (DECL_INITIAL (newdecl) == NULL_TREE
3059 && DECL_INITIAL (olddecl) != NULL_TREE)
3060 {
3061 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3062 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3063 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
4d85e00e
MM
3064 if (DECL_LANG_SPECIFIC (newdecl)
3065 && DECL_LANG_SPECIFIC (olddecl))
3066 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
8926095f 3067 }
39211cd5
MS
3068
3069 /* Merge the section attribute.
3070 We want to issue an error if the sections conflict but that must be
3071 done later in decl_attributes since we are called before attributes
3072 are assigned. */
3073 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3074 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3075
8d08fdba
MS
3076 /* Keep the old rtl since we can safely use it, unless it's the
3077 call to abort() used for abstract virtuals. */
3078 if ((DECL_LANG_SPECIFIC (olddecl)
3079 && !DECL_ABSTRACT_VIRTUAL_P (olddecl))
3080 || DECL_RTL (olddecl) != DECL_RTL (abort_fndecl))
3081 DECL_RTL (newdecl) = DECL_RTL (olddecl);
39211cd5
MS
3082
3083 pop_obstacks ();
8d08fdba
MS
3084 }
3085 /* If cannot merge, then use the new type and qualifiers,
3086 and don't preserve the old rtl. */
3087 else
3088 {
3089 /* Clean out any memory we had of the old declaration. */
3090 tree oldstatic = value_member (olddecl, static_aggregates);
3091 if (oldstatic)
3092 TREE_VALUE (oldstatic) = error_mark_node;
3093
3094 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3095 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3096 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3097 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3098 }
3099
3100 /* Merge the storage class information. */
a9aedbc2 3101 DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
e92cc029 3102 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
a9aedbc2
MS
3103 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3104 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3105 if (! DECL_EXTERNAL (olddecl))
3106 DECL_EXTERNAL (newdecl) = 0;
0b60dfe3
BK
3107
3108 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
8d08fdba 3109 {
a9aedbc2
MS
3110 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3111 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
77be6f82 3112 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
0b60dfe3
BK
3113 /* Don't really know how much of the language-specific
3114 values we should copy from old to new. */
3115 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3116 DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3117 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3118 if (DECL_TEMPLATE_INFO (newdecl) == NULL_TREE)
3119 {
3120 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3121 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
3122 }
3123 olddecl_friend = DECL_FRIEND_P (olddecl);
8d08fdba
MS
3124 }
3125
8d08fdba
MS
3126 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3127 {
75650646
MM
3128 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3129 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3130 {
3131 /* If newdecl is not a specialization, then it is not a
3132 template-related function at all. And that means that we
3133 shoud have exited above, returning 0. */
3134 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3135 0);
3136
3137 if (TREE_USED (olddecl))
3138 /* From [temp.expl.spec]:
3139
3140 If a template, a member template or the member of a class
3141 template is explicitly specialized then that
3142 specialization shall be declared before the first use of
3143 that specialization that would cause an implicit
3144 instantiation to take place, in every translation unit in
3145 which such a use occurs. */
3146 cp_error ("explicit specialization of %D after first use",
3147 olddecl);
3148
3149 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3150 }
faae18ab
MS
3151 DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3152
3153 /* If either decl says `inline', this fn is inline, unless its
3154 definition was passed already. */
3155 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3156 DECL_INLINE (olddecl) = 1;
3157 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3158
700f8a87
MS
3159 if (! types_match)
3160 {
3161 DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3162 DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
5566b478
MS
3163 DECL_RTL (olddecl) = DECL_RTL (newdecl);
3164 }
3165 if (! types_match || new_defines_function)
3166 {
3167 /* These need to be copied so that the names are available. */
700f8a87
MS
3168 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3169 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
700f8a87 3170 }
8d08fdba
MS
3171 if (new_defines_function)
3172 /* If defining a function declared with other language
3173 linkage, use the previously declared language linkage. */
3174 DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3175 else
3176 {
3177 /* If redeclaring a builtin function, and not a definition,
3178 it stays built in. */
3179 if (DECL_BUILT_IN (olddecl))
3180 {
3181 DECL_BUILT_IN (newdecl) = 1;
39211cd5 3182 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
8d08fdba
MS
3183 /* If we're keeping the built-in definition, keep the rtl,
3184 regardless of declaration matches. */
3185 DECL_RTL (newdecl) = DECL_RTL (olddecl);
3186 }
3187 else
3188 DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3189
3190 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
8926095f 3191 if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
8d08fdba
MS
3192 /* Previously saved insns go together with
3193 the function's previous definition. */
3194 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3195 /* Don't clear out the arguments if we're redefining a function. */
3196 if (DECL_ARGUMENTS (olddecl))
3197 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3198 }
6060a796
MS
3199 if (DECL_LANG_SPECIFIC (olddecl))
3200 DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
8d08fdba
MS
3201 }
3202
a9aedbc2
MS
3203 if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3204 {
3205 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3206 }
3207
8d08fdba
MS
3208 /* Now preserve various other info from the definition. */
3209 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3210 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3211 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
f376e137 3212 DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
8d08fdba 3213
8d08fdba
MS
3214 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3215 {
3216 int function_size;
3217 struct lang_decl *ol = DECL_LANG_SPECIFIC (olddecl);
3218 struct lang_decl *nl = DECL_LANG_SPECIFIC (newdecl);
3219
3220 function_size = sizeof (struct tree_decl);
3221
3222 bcopy ((char *) newdecl + sizeof (struct tree_common),
3223 (char *) olddecl + sizeof (struct tree_common),
3224 function_size - sizeof (struct tree_common));
3225
3226 /* Can we safely free the storage used by newdecl? */
3227
3228#define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3229 & ~ obstack_alignment_mask (&permanent_obstack))
3230
75650646
MM
3231 if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3232 {
3233 /* If newdecl is a template instantiation, it is possible that
3234 the following sequence of events has occurred:
3235
3236 o A friend function was declared in a class template. The
3237 class template was instantiated.
3238
3239 o The instantiation of the friend declaration was
3240 recorded on the instantiation list, and is newdecl.
3241
3242 o Later, however, instantiate_class_template called pushdecl
3243 on the newdecl to perform name injection. But, pushdecl in
3244 turn called duplicate_decls when it discovered that another
3245 declaration of a global function with the same name already
3246 existed.
3247
3248 o Here, in duplicate_decls, we decided to clobber newdecl.
3249
3250 If we're going to do that, we'd better make sure that
3251 olddecl, and not newdecl, is on the list of
3252 instantiations so that if we try to do the instantiation
3253 again we won't get the clobbered declaration. */
3254
3255 tree tmpl = DECL_TI_TEMPLATE (newdecl);
3256 tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3257
3258 for (; decls; decls = TREE_CHAIN (decls))
3259 if (TREE_VALUE (decls) == newdecl)
3260 TREE_VALUE (decls) = olddecl;
3261 }
3262
3a56f0ab
JM
3263 if (((char *)newdecl + ROUND (function_size) == (char *)nl
3264 && ((char *)newdecl + ROUND (function_size)
3265 + ROUND (sizeof (struct lang_decl))
3266 == obstack_next_free (&permanent_obstack)))
3267 || ((char *)newdecl + ROUND (function_size)
3268 == obstack_next_free (&permanent_obstack)))
8d08fdba
MS
3269 {
3270 DECL_MAIN_VARIANT (newdecl) = olddecl;
3271 DECL_LANG_SPECIFIC (olddecl) = ol;
3272 bcopy ((char *)nl, (char *)ol, sizeof (struct lang_decl));
3273
3274 obstack_free (&permanent_obstack, newdecl);
3275 }
d22c8596 3276 else if (LANG_DECL_PERMANENT (ol) && ol != nl)
8d08fdba
MS
3277 {
3278 if (DECL_MAIN_VARIANT (olddecl) == olddecl)
3279 {
3280 /* Save these lang_decls that would otherwise be lost. */
3281 extern tree free_lang_decl_chain;
3282 tree free_lang_decl = (tree) ol;
d22c8596
MS
3283
3284 if (DECL_LANG_SPECIFIC (olddecl) == ol)
3285 abort ();
3286
8d08fdba
MS
3287 TREE_CHAIN (free_lang_decl) = free_lang_decl_chain;
3288 free_lang_decl_chain = free_lang_decl;
3289 }
3290 else
3291 {
bd6dd845 3292 /* Storage leak. */;
8d08fdba
MS
3293 }
3294 }
3295 }
3296 else
3297 {
3298 bcopy ((char *) newdecl + sizeof (struct tree_common),
3299 (char *) olddecl + sizeof (struct tree_common),
3300 sizeof (struct tree_decl) - sizeof (struct tree_common)
3301 + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3302 }
3303
3304 DECL_UID (olddecl) = olddecl_uid;
3305 if (olddecl_friend)
3306 DECL_FRIEND_P (olddecl) = 1;
3307
d9525bec
BK
3308 /* NEWDECL contains the merged attribute lists.
3309 Update OLDDECL to be the same. */
3310 DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3311
8d08fdba
MS
3312 return 1;
3313}
3314
3315/* Record a decl-node X as belonging to the current lexical scope.
3316 Check for errors (such as an incompatible declaration for the same
3317 name already seen in the same scope).
3318
3319 Returns either X or an old decl for the same name.
3320 If an old decl is returned, it may have been smashed
3321 to agree with what X says. */
3322
3323tree
3324pushdecl (x)
3325 tree x;
3326{
3327 register tree t;
8d08fdba 3328 register tree name = DECL_ASSEMBLER_NAME (x);
8d08fdba
MS
3329 register struct binding_level *b = current_binding_level;
3330
2c73f9f5
ML
3331 if (current_function_decl && x != current_function_decl
3332 /* A local declaration for a function doesn't constitute nesting. */
3333 && (TREE_CODE (x) != FUNCTION_DECL || DECL_INITIAL (x))
700f8a87
MS
3334 /* Don't change DECL_CONTEXT of virtual methods. */
3335 && (TREE_CODE (x) != FUNCTION_DECL || !DECL_VIRTUAL_P (x))
8d08fdba
MS
3336 && ! DECL_CONTEXT (x))
3337 DECL_CONTEXT (x) = current_function_decl;
2c73f9f5 3338 if (!DECL_CONTEXT (x))
cb0dbb9a 3339 DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
8d08fdba 3340
8d08fdba 3341 /* Type are looked up using the DECL_NAME, as that is what the rest of the
e92cc029 3342 compiler wants to use. */
a9aedbc2 3343 if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
73b0fce8
KL
3344 || TREE_CODE (x) == NAMESPACE_DECL || TREE_CODE (x) == TEMPLATE_TYPE_PARM
3345 || TREE_CODE (x) == TEMPLATE_TEMPLATE_PARM)
8d08fdba 3346 name = DECL_NAME (x);
8d08fdba
MS
3347
3348 if (name)
3349 {
5566b478
MS
3350#if 0
3351 /* Not needed...see below. */
8d08fdba
MS
3352 char *file;
3353 int line;
5566b478 3354#endif
386b8a85
JM
3355 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3356 name = TREE_OPERAND (name, 0);
3357
2c73f9f5 3358 /* Namespace-scoped variables are not found in the current level. */
6eb3bb27 3359 if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
2c73f9f5
ML
3360 t = namespace_binding (name, DECL_CONTEXT (x));
3361 else
3362 t = lookup_name_current_level (name);
8d08fdba
MS
3363 if (t == error_mark_node)
3364 {
3365 /* error_mark_node is 0 for a while during initialization! */
3366 t = NULL_TREE;
3367 cp_error_at ("`%#D' used prior to declaration", x);
3368 }
3369
51c184be 3370 else if (t != NULL_TREE)
8d08fdba 3371 {
5566b478
MS
3372#if 0
3373 /* This is turned off until I have time to do it right (bpk). */
e92cc029 3374 /* With the code below that uses it... */
8d6e462b
PB
3375 file = DECL_SOURCE_FILE (t);
3376 line = DECL_SOURCE_LINE (t);
5566b478 3377#endif
2ee887f2 3378 if (TREE_CODE (t) == PARM_DECL)
8d08fdba
MS
3379 {
3380 if (DECL_CONTEXT (t) == NULL_TREE)
3381 fatal ("parse errors have confused me too much");
be99da77 3382
e92cc029 3383 /* Check for duplicate params. */
be99da77
MS
3384 if (duplicate_decls (x, t))
3385 return t;
8d08fdba 3386 }
8d6e462b 3387 else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
5566b478
MS
3388 || DECL_FUNCTION_TEMPLATE_P (x))
3389 && is_overloaded_fn (t))
2c73f9f5 3390 /* Don't do anything just yet. */;
e1cd6e56
MS
3391 else if (t == wchar_decl_node)
3392 {
3393 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3394 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3395
3396 /* Throw away the redeclaration. */
3397 return t;
3398 }
8926095f 3399 else if (TREE_CODE (t) != TREE_CODE (x))
8d08fdba 3400 {
9ed182dc 3401 if (duplicate_decls (x, t))
51c184be 3402 return t;
8d08fdba
MS
3403 }
3404 else if (duplicate_decls (x, t))
51c184be 3405 {
8d08fdba 3406#if 0
8926095f 3407 /* This is turned off until I have time to do it right (bpk). */
8d08fdba 3408
8926095f
MS
3409 /* Also warn if they did a prototype with `static' on it, but
3410 then later left the `static' off. */
3411 if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
8d08fdba 3412 {
8926095f
MS
3413 if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3414 return t;
8d08fdba 3415
8926095f
MS
3416 if (extra_warnings)
3417 {
a28e3c7f
MS
3418 cp_warning ("`static' missing from declaration of `%D'",
3419 t);
8926095f
MS
3420 warning_with_file_and_line (file, line,
3421 "previous declaration of `%s'",
3422 decl_as_string (t, 0));
3423 }
8d08fdba 3424
8926095f
MS
3425 /* Now fix things so it'll do what they expect. */
3426 if (current_function_decl)
3427 TREE_PUBLIC (current_function_decl) = 0;
3428 }
51c184be
MS
3429 /* Due to interference in memory reclamation (X may be
3430 obstack-deallocated at this point), we must guard against
8926095f
MS
3431 one really special case. [jason: This should be handled
3432 by start_function] */
51c184be
MS
3433 if (current_function_decl == x)
3434 current_function_decl = t;
8926095f 3435#endif
7177d104
MS
3436 if (TREE_CODE (t) == TYPE_DECL)
3437 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
f30432d7
MS
3438 else if (TREE_CODE (t) == FUNCTION_DECL)
3439 check_default_args (t);
7177d104 3440
51c184be
MS
3441 return t;
3442 }
35680744
MM
3443 else if (DECL_MAIN_P (x))
3444 {
3445 /* A redeclaration of main, but not a duplicate of the
3446 previous one.
3447
3448 [basic.start.main]
3449
3450 This function shall not be overloaded. */
3451 cp_error_at ("invalid redeclaration of `%D'", t);
3452 cp_error ("as `%D'", x);
3453 /* We don't try to push this declaration since that
3454 causes a crash. */
3455 return x;
3456 }
8d08fdba 3457 }
8926095f
MS
3458
3459 if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3460 {
3461 t = push_overloaded_decl (x, 1);
3462 if (t != x || DECL_LANGUAGE (x) == lang_c)
3463 return t;
3464 }
6eb3bb27 3465 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
8926095f 3466 return push_overloaded_decl (x, 0);
8d08fdba 3467
a1774733
BK
3468 /* If declaring a type as a typedef, copy the type (unless we're
3469 at line 0), and install this TYPE_DECL as the new type's typedef
3470 name. See the extensive comment in ../c-decl.c (pushdecl). */
8d08fdba
MS
3471 if (TREE_CODE (x) == TYPE_DECL)
3472 {
3473 tree type = TREE_TYPE (x);
a1774733
BK
3474 if (DECL_SOURCE_LINE (x) == 0)
3475 {
3476 if (TYPE_NAME (type) == 0)
3477 TYPE_NAME (type) = x;
3478 }
3479 else if (type != error_mark_node && TYPE_NAME (type) != x)
3480 {
ae0a6181
MM
3481 push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
3482
a1774733
BK
3483 DECL_ORIGINAL_TYPE (x) = type;
3484 type = build_type_copy (type);
3485 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3486 TYPE_NAME (type) = x;
3487 TREE_TYPE (x) = type;
ae0a6181
MM
3488
3489 pop_obstacks ();
a1774733 3490 }
8d08fdba 3491
8d08fdba
MS
3492 if (type != error_mark_node
3493 && TYPE_NAME (type)
3494 && TYPE_IDENTIFIER (type))
3495 set_identifier_type_value_with_scope (DECL_NAME (x), type, b);
3496 }
3497
3498 /* Multiple external decls of the same identifier ought to match.
3499
3500 We get warnings about inline functions where they are defined.
39211cd5
MS
3501 We get warnings about other functions from push_overloaded_decl.
3502
8d08fdba 3503 Avoid duplicate warnings where they are used. */
39211cd5 3504 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
8d08fdba
MS
3505 {
3506 tree decl;
3507
31928556
JM
3508 if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3509 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3510 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3511 decl = IDENTIFIER_NAMESPACE_VALUE (name);
8d08fdba
MS
3512 else
3513 decl = NULL_TREE;
3514
39211cd5 3515 if (decl
8d08fdba
MS
3516 /* If different sort of thing, we already gave an error. */
3517 && TREE_CODE (decl) == TREE_CODE (x)
39211cd5 3518 && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl), 1))
8d08fdba
MS
3519 {
3520 cp_pedwarn ("type mismatch with previous external decl", x);
8926095f 3521 cp_pedwarn_at ("previous external decl of `%#D'", decl);
8d08fdba
MS
3522 }
3523 }
3524
8d08fdba
MS
3525 /* This name is new in its binding level.
3526 Install the new declaration and return it. */
2c73f9f5 3527 if (namespace_bindings_p ())
8d08fdba
MS
3528 {
3529 /* Install a global value. */
3530
8d08fdba
MS
3531 /* If the first global decl has external linkage,
3532 warn if we later see static one. */
31928556 3533 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
8d08fdba
MS
3534 TREE_PUBLIC (name) = 1;
3535
e1cd6e56
MS
3536 /* Don't install an artificial TYPE_DECL if we already have
3537 another _DECL with that name. */
8d08fdba
MS
3538 if (TREE_CODE (x) != TYPE_DECL
3539 || t == NULL_TREE
e1cd6e56 3540 || ! DECL_ARTIFICIAL (x))
30394414
JM
3541 {
3542 if (TREE_CODE (x) == FUNCTION_DECL)
31928556
JM
3543 my_friendly_assert
3544 ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3545 || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3546 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
30394414 3547 }
8d08fdba
MS
3548
3549 /* Don't forget if the function was used via an implicit decl. */
3550 if (IDENTIFIER_IMPLICIT_DECL (name)
3551 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3552 TREE_USED (x) = 1;
3553
3554 /* Don't forget if its address was taken in that way. */
3555 if (IDENTIFIER_IMPLICIT_DECL (name)
3556 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3557 TREE_ADDRESSABLE (x) = 1;
3558
3559 /* Warn about mismatches against previous implicit decl. */
3560 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3561 /* If this real decl matches the implicit, don't complain. */
3562 && ! (TREE_CODE (x) == FUNCTION_DECL
3563 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3564 cp_warning
3565 ("`%D' was previously implicitly declared to return `int'", x);
3566
3567 /* If new decl is `static' and an `extern' was seen previously,
3568 warn about it. */
a0a33927
MS
3569 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3570 warn_extern_redeclared_static (x, t);
8d08fdba
MS
3571 }
3572 else
3573 {
3574 /* Here to install a non-global value. */
3575 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
31928556 3576 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
8d08fdba 3577
e1cd6e56
MS
3578 /* Don't install an artificial TYPE_DECL if we already have
3579 another _DECL with that name. */
3580 if (TREE_CODE (x) != TYPE_DECL
3581 || t == NULL_TREE
3582 || ! DECL_ARTIFICIAL (x))
9ed182dc 3583 set_identifier_local_value_with_scope (name, x, b);
8d08fdba
MS
3584
3585 /* If this is a TYPE_DECL, push it into the type value slot. */
3586 if (TREE_CODE (x) == TYPE_DECL)
3587 set_identifier_type_value_with_scope (name, TREE_TYPE (x), b);
3588
a9aedbc2
MS
3589 /* Clear out any TYPE_DECL shadowed by a namespace so that
3590 we won't think this is a type. The C struct hack doesn't
3591 go through namespaces. */
3592 if (TREE_CODE (x) == NAMESPACE_DECL)
3593 set_identifier_type_value_with_scope (name, NULL_TREE, b);
3594
8d08fdba
MS
3595 /* If this is an extern function declaration, see if we
3596 have a global definition or declaration for the function. */
3597 if (oldlocal == NULL_TREE
faae18ab 3598 && DECL_EXTERNAL (x)
31928556 3599 && oldglobal != NULL_TREE
8d08fdba 3600 && TREE_CODE (x) == FUNCTION_DECL
31928556 3601 && TREE_CODE (oldglobal) == FUNCTION_DECL)
8d08fdba
MS
3602 {
3603 /* We have one. Their types must agree. */
31928556 3604 if (decls_match (x, oldglobal))
6060a796
MS
3605 /* OK */;
3606 else
8d08fdba
MS
3607 {
3608 cp_warning ("extern declaration of `%#D' doesn't match", x);
31928556 3609 cp_warning_at ("global declaration `%#D'", oldglobal);
8d08fdba 3610 }
8d08fdba
MS
3611 }
3612 /* If we have a local external declaration,
3613 and no file-scope declaration has yet been seen,
3614 then if we later have a file-scope decl it must not be static. */
3615 if (oldlocal == NULL_TREE
31928556 3616 && oldglobal == NULL_TREE
8d08fdba
MS
3617 && DECL_EXTERNAL (x)
3618 && TREE_PUBLIC (x))
3619 {
3620 TREE_PUBLIC (name) = 1;
3621 }
3622
3623 if (DECL_FROM_INLINE (x))
3624 /* Inline decls shadow nothing. */;
3625
3626 /* Warn if shadowing an argument at the top level of the body. */
3627 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3628 && TREE_CODE (oldlocal) == PARM_DECL
3629 && TREE_CODE (x) != PARM_DECL)
3630 {
3631 /* Go to where the parms should be and see if we
3632 find them there. */
3633 struct binding_level *b = current_binding_level->level_chain;
3634
3635 if (cleanup_label)
3636 b = b->level_chain;
3637
3638 /* ARM $8.3 */
3639 if (b->parm_flag == 1)
3640 cp_error ("declaration of `%#D' shadows a parameter", name);
3641 }
72b7eeff 3642 else if (warn_shadow && oldlocal != NULL_TREE && b->is_for_scope
8d6e462b
PB
3643 && !DECL_DEAD_FOR_LOCAL (oldlocal))
3644 {
3645 warning ("variable `%s' shadows local",
3646 IDENTIFIER_POINTER (name));
3647 cp_warning_at (" this is the shadowed declaration", oldlocal);
3648 }
8d08fdba
MS
3649 /* Maybe warn if shadowing something else. */
3650 else if (warn_shadow && !DECL_EXTERNAL (x)
3651 /* No shadow warnings for internally generated vars. */
700f8a87 3652 && ! DECL_ARTIFICIAL (x)
8d08fdba
MS
3653 /* No shadow warnings for vars made for inlining. */
3654 && ! DECL_FROM_INLINE (x))
3655 {
3656 char *warnstring = NULL;
3657
3658 if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
3659 warnstring = "declaration of `%s' shadows a parameter";
3660 else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4ac14744 3661 && current_class_ptr
8d08fdba
MS
3662 && !TREE_STATIC (name))
3663 warnstring = "declaration of `%s' shadows a member of `this'";
3664 else if (oldlocal != NULL_TREE)
3665 warnstring = "declaration of `%s' shadows previous local";
31928556 3666 else if (oldglobal != NULL_TREE)
30394414 3667 /* XXX shadow warnings in outer-more namespaces */
8d08fdba
MS
3668 warnstring = "declaration of `%s' shadows global declaration";
3669
3670 if (warnstring)
3671 warning (warnstring, IDENTIFIER_POINTER (name));
3672 }
2450bb7d
BK
3673 /* Check to see if decl redeclares a template parameter. */
3674 if (oldlocal && (current_class_type || current_function_decl )
3675 && current_template_parms)
3676 {
3677 if (decl_template_parm_p (oldlocal))
3678 {
3679 cp_error ("redeclaration of template parameter `%T'", name);
3680 cp_error_at (" previously declared here `%#D'", oldlocal);
3681 }
3682 }
e1cd6e56 3683 }
8d08fdba 3684
e1cd6e56 3685 if (TREE_CODE (x) == FUNCTION_DECL)
f30432d7 3686 check_default_args (x);
8145f082
MS
3687
3688 /* Keep count of variables in this level with incomplete type. */
8145f082 3689 if (TREE_CODE (x) == VAR_DECL
28cbf42c 3690 && TREE_TYPE (x) != error_mark_node
f30432d7
MS
3691 && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3692 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
3693 /* RTTI TD entries are created while defining the type_info. */
3694 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
3695 && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
3696 b->incomplete = tree_cons (NULL_TREE, x, b->incomplete);
8d08fdba
MS
3697 }
3698
8d08fdba
MS
3699 /* Put decls on list in reverse order.
3700 We will reverse them later if necessary. */
3701 TREE_CHAIN (x) = b->names;
3702 b->names = x;
3703 if (! (b != global_binding_level || TREE_PERMANENT (x)))
3704 my_friendly_abort (124);
3705
3706 return x;
3707}
3708
5566b478
MS
3709/* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3710 caller to set DECL_CONTEXT properly. */
8d08fdba
MS
3711
3712static tree
3713pushdecl_with_scope (x, level)
3714 tree x;
3715 struct binding_level *level;
3716{
8d019cef 3717 register struct binding_level *b;
5566b478 3718 tree function_decl = current_function_decl;
8d08fdba 3719
5566b478 3720 current_function_decl = NULL_TREE;
8d019cef
JM
3721 if (level->parm_flag == 2)
3722 {
3723 b = class_binding_level;
3724 class_binding_level = level;
3725 pushdecl_class_level (x);
3726 class_binding_level = b;
3727 }
3728 else
3729 {
3730 b = current_binding_level;
3731 current_binding_level = level;
3732 x = pushdecl (x);
3733 current_binding_level = b;
3734 }
5566b478 3735 current_function_decl = function_decl;
8d08fdba
MS
3736 return x;
3737}
3738
2c73f9f5 3739/* Like pushdecl, only it places X in the current namespace,
8d08fdba 3740 if appropriate. */
e92cc029 3741
8d08fdba 3742tree
2c73f9f5 3743pushdecl_namespace_level (x)
8d08fdba
MS
3744 tree x;
3745{
3746 register struct binding_level *b = inner_binding_level;
2c73f9f5
ML
3747 register tree t;
3748
3749 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
8d08fdba
MS
3750
3751 /* Now, the type_shadowed stack may screw us. Munge it so it does
3752 what we want. */
3753 if (TREE_CODE (x) == TYPE_DECL)
3754 {
3755 tree name = DECL_NAME (x);
3756 tree newval;
3757 tree *ptr = (tree *)0;
3758 for (; b != global_binding_level; b = b->level_chain)
3759 {
3760 tree shadowed = b->type_shadowed;
3761 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3762 if (TREE_PURPOSE (shadowed) == name)
3763 {
3764 ptr = &TREE_VALUE (shadowed);
3765 /* Can't break out of the loop here because sometimes
3766 a binding level will have duplicate bindings for
3767 PT names. It's gross, but I haven't time to fix it. */
3768 }
3769 }
3770 newval = TREE_TYPE (x);
3771 if (ptr == (tree *)0)
3772 {
3773 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3774 up here if this is changed to an assertion. --KR */
3775 SET_IDENTIFIER_TYPE_VALUE (name, newval);
3776 }
3777 else
3778 {
8d08fdba
MS
3779 *ptr = newval;
3780 }
3781 }
3782 return t;
3783}
3784
2c73f9f5
ML
3785/* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
3786 if appropriate. */
3787
3788tree
3789pushdecl_top_level (x)
3790 tree x;
3791{
3792 tree cur_namespace = current_namespace;
3793 current_namespace = global_namespace;
3794 x = pushdecl_namespace_level (x);
3795 current_namespace = cur_namespace;
3796 return x;
3797}
3798
8d08fdba 3799/* Make the declaration of X appear in CLASS scope. */
e92cc029 3800
8d08fdba
MS
3801tree
3802pushdecl_class_level (x)
3803 tree x;
3804{
3805 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
3806 scope looks for the pre-mangled name. */
3807 register tree name = DECL_NAME (x);
3808
3809 if (name)
3810 {
8d2733ca
MS
3811 if (TYPE_BEING_DEFINED (current_class_type))
3812 {
57f01f45
JM
3813 /* A name N used in a class S shall refer to the same declaration
3814 in its context and when re-evaluated in the completed scope of S.
3815
8d2733ca
MS
3816 Types, enums, and static vars are checked here; other
3817 members are checked in finish_struct. */
3818 tree icv = IDENTIFIER_CLASS_VALUE (name);
3819
5566b478 3820 if (icv && icv != x
dc8263bc 3821 && flag_optional_diags
a4443a08
MS
3822 /* Don't complain about inherited names. */
3823 && id_in_current_class (name)
3824 /* Or shadowed tags. */
35acd3f2 3825 && !(DECL_DECLARES_TYPE_P (icv)
a4443a08 3826 && DECL_CONTEXT (icv) == current_class_type))
8d2733ca 3827 {
57f01f45
JM
3828 cp_pedwarn ("declaration of identifier `%D' as `%#D'", name, x);
3829 cp_pedwarn_at ("conflicts with previous use in class as `%#D'",
3830 icv);
8d2733ca
MS
3831 }
3832 }
3833
8d08fdba
MS
3834 push_class_level_binding (name, x);
3835 if (TREE_CODE (x) == TYPE_DECL)
3836 {
3837 set_identifier_type_value (name, TREE_TYPE (x));
8d08fdba
MS
3838 }
3839 }
3840 return x;
3841}
3842
bd6dd845 3843#if 0
7177d104
MS
3844/* This function is used to push the mangled decls for nested types into
3845 the appropriate scope. Previously pushdecl_top_level was used, but that
3846 is incorrect for members of local classes. */
e92cc029 3847
5566b478 3848void
7177d104
MS
3849pushdecl_nonclass_level (x)
3850 tree x;
3851{
3852 struct binding_level *b = current_binding_level;
3853
7177d104 3854 my_friendly_assert (b->parm_flag != 2, 180);
7177d104 3855
5566b478 3856#if 0
7177d104
MS
3857 /* Get out of template binding levels */
3858 while (b->pseudo_global)
3859 b = b->level_chain;
5566b478 3860#endif
7177d104
MS
3861
3862 pushdecl_with_scope (x, b);
3863}
bd6dd845 3864#endif
7177d104 3865
8d08fdba
MS
3866/* Make the declaration(s) of X appear in CLASS scope
3867 under the name NAME. */
e92cc029 3868
8d08fdba
MS
3869void
3870push_class_level_binding (name, x)
3871 tree name;
3872 tree x;
3873{
98c1c668
JM
3874 /* The class_binding_level will be NULL if x is a template
3875 parameter name in a member template. */
3876 if (!class_binding_level)
3877 return;
3878
e1cd6e56
MS
3879 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3880 && purpose_member (name, class_binding_level->class_shadowed))
3881 return;
3882
8d08fdba
MS
3883 maybe_push_cache_obstack ();
3884 class_binding_level->class_shadowed
3885 = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
3886 class_binding_level->class_shadowed);
3887 pop_obstacks ();
3888 IDENTIFIER_CLASS_VALUE (name) = x;
3889 obstack_ptr_grow (&decl_obstack, x);
3890}
3891
2c73f9f5
ML
3892/* Insert another USING_DECL into the current binding level,
3893 returning this declaration. If this is a redeclaration,
3894 do nothing and return NULL_TREE. */
e92cc029 3895
2c73f9f5
ML
3896tree
3897push_using_decl (scope, name)
3898 tree scope;
3899 tree name;
8d08fdba 3900{
2c73f9f5
ML
3901 tree decl;
3902
2c73f9f5
ML
3903 my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
3904 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
3905 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
3906 if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
3907 break;
3908 if (decl)
3909 return NULL_TREE;
3910 decl = build_lang_decl (USING_DECL, name, void_type_node);
3911 DECL_INITIAL (decl) = scope;
3912 TREE_CHAIN (decl) = current_binding_level->usings;
3913 current_binding_level->usings = decl;
3914 return decl;
8d08fdba
MS
3915}
3916
ea9635c7
ML
3917/* Add namespace to using_directives. Return NULL_TREE if nothing was
3918 changed (i.e. there was already a directive), or the fresh
3919 TREE_LIST otherwise. */
3920
3921tree
9ed182dc 3922push_using_directive (used)
ea9635c7 3923 tree used;
ea9635c7
ML
3924{
3925 tree ud = current_binding_level->using_directives;
9ed182dc 3926 tree iter, ancestor;
ea9635c7
ML
3927
3928 /* Check if we already have this. */
3929 if (purpose_member (used, ud) != NULL_TREE)
3930 return NULL_TREE;
00dc6358
JM
3931
3932 /* Recursively add all namespaces used. */
3933 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
9ed182dc 3934 push_using_directive (TREE_PURPOSE (iter));
00dc6358 3935
9ed182dc 3936 ancestor = namespace_ancestor (current_decl_namespace (), used);
00dc6358 3937 ud = current_binding_level->using_directives;
ea9635c7
ML
3938 ud = perm_tree_cons (used, ancestor, ud);
3939 current_binding_level->using_directives = ud;
3940 return ud;
3941}
3942
700f8a87
MS
3943/* DECL is a FUNCTION_DECL which may have other definitions already in
3944 place. We get around this by making the value of the identifier point
3945 to a list of all the things that want to be referenced by that name. It
3946 is then up to the users of that name to decide what to do with that
8d08fdba
MS
3947 list.
3948
3949 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
3950 slot. It is dealt with the same way.
3951
3952 The value returned may be a previous declaration if we guessed wrong
3953 about what language DECL should belong to (C or C++). Otherwise,
3954 it's always DECL (and never something that's not a _DECL). */
e92cc029 3955
bd6dd845 3956static tree
8d08fdba
MS
3957push_overloaded_decl (decl, forgettable)
3958 tree decl;
3959 int forgettable;
3960{
3961 tree orig_name = DECL_NAME (decl);
700f8a87 3962 tree old;
2c73f9f5 3963 int doing_global = (namespace_bindings_p () || ! forgettable);
700f8a87
MS
3964
3965 if (doing_global)
3966 {
2c73f9f5 3967 old = namespace_binding (orig_name, DECL_CONTEXT (decl));
700f8a87 3968 if (old && TREE_CODE (old) == FUNCTION_DECL
a4443a08 3969 && DECL_ARTIFICIAL (old)
700f8a87
MS
3970 && (DECL_BUILT_IN (old) || DECL_BUILT_IN_NONANSI (old)))
3971 {
a4443a08
MS
3972 if (duplicate_decls (decl, old))
3973 return old;
700f8a87
MS
3974 old = NULL_TREE;
3975 }
3976 }
3977 else
3978 {
3979 old = IDENTIFIER_LOCAL_VALUE (orig_name);
a4443a08 3980
700f8a87
MS
3981 if (! purpose_member (orig_name, current_binding_level->shadowed))
3982 {
3983 current_binding_level->shadowed
3984 = tree_cons (orig_name, old, current_binding_level->shadowed);
3985 old = NULL_TREE;
3986 }
3987 }
8d08fdba 3988
700f8a87 3989 if (old)
8d08fdba 3990 {
e1cd6e56 3991 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
8926095f 3992 {
700f8a87 3993 tree t = TREE_TYPE (old);
cdf5b885
MS
3994 if (IS_AGGR_TYPE (t) && warn_shadow
3995 && (! DECL_IN_SYSTEM_HEADER (decl)
3996 || ! DECL_IN_SYSTEM_HEADER (old)))
8926095f 3997 cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
5b605f68 3998 old = NULL_TREE;
8926095f 3999 }
700f8a87 4000 else if (is_overloaded_fn (old))
8d08fdba 4001 {
8d08fdba
MS
4002 tree tmp;
4003
2c73f9f5
ML
4004 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4005 if (decl == OVL_CURRENT (tmp)
4006 || duplicate_decls (decl, OVL_CURRENT (tmp)))
4007 return OVL_CURRENT (tmp);
8d08fdba 4008 }
e1cd6e56
MS
4009 else
4010 {
4011 cp_error_at ("previous non-function declaration `%#D'", old);
4012 cp_error ("conflicts with function declaration `%#D'", decl);
a9aedbc2 4013 return decl;
e1cd6e56 4014 }
8d08fdba 4015 }
7177d104 4016
700f8a87 4017 if (old || TREE_CODE (decl) == TEMPLATE_DECL)
8d08fdba 4018 {
2c73f9f5
ML
4019 if (old && TREE_CODE (old) != OVERLOAD)
4020 old = ovl_cons (old, NULL_TREE);
4021 old = ovl_cons (decl, old);
8d08fdba
MS
4022 }
4023 else
4024 /* orig_name is not ambiguous. */
700f8a87
MS
4025 old = decl;
4026
4027 if (doing_global)
19f1bd34 4028 set_namespace_binding (orig_name, current_namespace, old);
700f8a87
MS
4029 else
4030 IDENTIFIER_LOCAL_VALUE (orig_name) = old;
4031
8d08fdba
MS
4032 return decl;
4033}
4034\f
4035/* Generate an implicit declaration for identifier FUNCTIONID
4036 as a function of type int (). Print a warning if appropriate. */
4037
4038tree
4039implicitly_declare (functionid)
4040 tree functionid;
4041{
4042 register tree decl;
4043 int temp = allocation_temporary_p ();
4044
4045 push_obstacks_nochange ();
4046
4047 /* Save the decl permanently so we can warn if definition follows.
4048 In ANSI C, warn_implicit is usually false, so the saves little space.
4049 But in C++, it's usually true, hence the extra code. */
d22c8596 4050 if (temp && (! warn_implicit || toplevel_bindings_p ()))
8d08fdba
MS
4051 end_temporary_allocation ();
4052
4053 /* We used to reuse an old implicit decl here,
4054 but this loses with inline functions because it can clobber
4055 the saved decl chains. */
4056 decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4057
4058 DECL_EXTERNAL (decl) = 1;
4059 TREE_PUBLIC (decl) = 1;
4060
4061 /* ANSI standard says implicit declarations are in the innermost block.
d22c8596 4062 So we record the decl in the standard fashion. */
8d08fdba
MS
4063 pushdecl (decl);
4064 rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4065
4066 if (warn_implicit
4067 /* Only one warning per identifier. */
4068 && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4069 {
4070 cp_pedwarn ("implicit declaration of function `%#D'", decl);
4071 }
4072
4073 SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4074
4075 pop_obstacks ();
4076
4077 return decl;
4078}
4079
4080/* Return zero if the declaration NEWDECL is valid
4081 when the declaration OLDDECL (assumed to be for the same name)
4082 has already been seen.
4083 Otherwise return an error message format string with a %s
4084 where the identifier should go. */
4085
4086static char *
4087redeclaration_error_message (newdecl, olddecl)
4088 tree newdecl, olddecl;
4089{
4090 if (TREE_CODE (newdecl) == TYPE_DECL)
4091 {
4092 /* Because C++ can put things into name space for free,
4093 constructs like "typedef struct foo { ... } foo"
4094 would look like an erroneous redeclaration. */
8926095f 4095 if (comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 0))
8d08fdba
MS
4096 return 0;
4097 else
51c184be 4098 return "redefinition of `%#D'";
8d08fdba
MS
4099 }
4100 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4101 {
4102 /* If this is a pure function, its olddecl will actually be
4103 the original initialization to `0' (which we force to call
4104 abort()). Don't complain about redefinition in this case. */
4105 if (DECL_LANG_SPECIFIC (olddecl) && DECL_ABSTRACT_VIRTUAL_P (olddecl))
4106 return 0;
4107
2c73f9f5
ML
4108 /* If both functions come from different namespaces, this is not
4109 a redeclaration - this is a conflict with a used function. */
6eb3bb27 4110 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2c73f9f5
ML
4111 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4112 return "`%D' conflicts with used function";
4113
db5ae43f
MS
4114 /* We'll complain about linkage mismatches in
4115 warn_extern_redeclared_static. */
4116
2c73f9f5 4117 /* Defining the same name twice is no good. */
8d08fdba 4118 if (DECL_INITIAL (olddecl) != NULL_TREE
faae18ab 4119 && DECL_INITIAL (newdecl) != NULL_TREE)
8d08fdba
MS
4120 {
4121 if (DECL_NAME (olddecl) == NULL_TREE)
51c184be 4122 return "`%#D' not declared in class";
8d08fdba 4123 else
51c184be 4124 return "redefinition of `%#D'";
8d08fdba
MS
4125 }
4126 return 0;
4127 }
51c184be
MS
4128 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4129 {
ec255269
MS
4130 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4131 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4132 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4133 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4134 && TYPE_SIZE (TREE_TYPE (newdecl))
4135 && TYPE_SIZE (TREE_TYPE (olddecl))))
51c184be
MS
4136 return "redefinition of `%#D'";
4137 return 0;
4138 }
5566b478 4139 else if (toplevel_bindings_p ())
8d08fdba
MS
4140 {
4141 /* Objects declared at top level: */
4142 /* If at least one is a reference, it's ok. */
4143 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4144 return 0;
8926095f
MS
4145 /* Reject two definitions. */
4146 return "redefinition of `%#D'";
8d08fdba
MS
4147 }
4148 else
4149 {
4150 /* Objects declared with block scope: */
4151 /* Reject two definitions, and reject a definition
4152 together with an external reference. */
4153 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
51c184be 4154 return "redeclaration of `%#D'";
8d08fdba
MS
4155 return 0;
4156 }
4157}
4158\f
4159/* Get the LABEL_DECL corresponding to identifier ID as a label.
4160 Create one if none exists so far for the current function.
4161 This function is called for both label definitions and label references. */
4162
4163tree
4164lookup_label (id)
4165 tree id;
4166{
4167 register tree decl = IDENTIFIER_LABEL_VALUE (id);
4168
4169 if (current_function_decl == NULL_TREE)
4170 {
4171 error ("label `%s' referenced outside of any function",
4172 IDENTIFIER_POINTER (id));
4173 return NULL_TREE;
4174 }
4175
4176 if ((decl == NULL_TREE
4177 || DECL_SOURCE_LINE (decl) == 0)
e349ee73
MS
4178 && (named_label_uses == NULL
4179 || named_label_uses->names_in_scope != current_binding_level->names
4180 || named_label_uses->label_decl != decl))
4181 {
4182 struct named_label_list *new_ent;
4183 new_ent
4184 = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4185 new_ent->label_decl = decl;
4186 new_ent->names_in_scope = current_binding_level->names;
4187 new_ent->binding_level = current_binding_level;
4188 new_ent->lineno_o_goto = lineno;
4189 new_ent->filename_o_goto = input_filename;
4190 new_ent->next = named_label_uses;
4191 named_label_uses = new_ent;
8d08fdba
MS
4192 }
4193
4194 /* Use a label already defined or ref'd with this name. */
4195 if (decl != NULL_TREE)
4196 {
4197 /* But not if it is inherited and wasn't declared to be inheritable. */
4198 if (DECL_CONTEXT (decl) != current_function_decl
4199 && ! C_DECLARED_LABEL_FLAG (decl))
4200 return shadow_label (id);
4201 return decl;
4202 }
4203
4204 decl = build_decl (LABEL_DECL, id, void_type_node);
4205
cffa8729
MS
4206 /* Make sure every label has an rtx. */
4207 label_rtx (decl);
4208
8d08fdba
MS
4209 /* A label not explicitly declared must be local to where it's ref'd. */
4210 DECL_CONTEXT (decl) = current_function_decl;
4211
4212 DECL_MODE (decl) = VOIDmode;
4213
4214 /* Say where one reference is to the label,
4215 for the sake of the error if it is not defined. */
4216 DECL_SOURCE_LINE (decl) = lineno;
4217 DECL_SOURCE_FILE (decl) = input_filename;
4218
4219 SET_IDENTIFIER_LABEL_VALUE (id, decl);
4220
4221 named_labels = tree_cons (NULL_TREE, decl, named_labels);
e349ee73 4222 named_label_uses->label_decl = decl;
8d08fdba
MS
4223
4224 return decl;
4225}
4226
4227/* Make a label named NAME in the current function,
4228 shadowing silently any that may be inherited from containing functions
4229 or containing scopes.
4230
4231 Note that valid use, if the label being shadowed
4232 comes from another scope in the same function,
4233 requires calling declare_nonlocal_label right away. */
4234
4235tree
4236shadow_label (name)
4237 tree name;
4238{
4239 register tree decl = IDENTIFIER_LABEL_VALUE (name);
4240
4241 if (decl != NULL_TREE)
4242 {
4243 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
4244 SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
8d08fdba
MS
4245 }
4246
4247 return lookup_label (name);
4248}
4249
4250/* Define a label, specifying the location in the source file.
4251 Return the LABEL_DECL node for the label, if the definition is valid.
4252 Otherwise return 0. */
4253
4254tree
4255define_label (filename, line, name)
4256 char *filename;
4257 int line;
4258 tree name;
4259{
5566b478
MS
4260 tree decl;
4261
4262 if (minimal_parse_mode)
4263 {
4264 push_obstacks (&permanent_obstack, &permanent_obstack);
4265 decl = build_decl (LABEL_DECL, name, void_type_node);
4266 pop_obstacks ();
4267 DECL_SOURCE_LINE (decl) = line;
4268 DECL_SOURCE_FILE (decl) = filename;
4269 add_tree (decl);
4270 return decl;
4271 }
4272
4273 decl = lookup_label (name);
8d08fdba
MS
4274
4275 /* After labels, make any new cleanups go into their
4276 own new (temporary) binding contour. */
4277 current_binding_level->more_cleanups_ok = 0;
4278
4279 /* If label with this name is known from an outer context, shadow it. */
4280 if (decl != NULL_TREE && DECL_CONTEXT (decl) != current_function_decl)
4281 {
4282 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
4283 SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
4284 decl = lookup_label (name);
4285 }
4286
e1cd6e56
MS
4287 if (name == get_identifier ("wchar_t"))
4288 cp_pedwarn ("label named wchar_t");
4289
8d08fdba
MS
4290 if (DECL_INITIAL (decl) != NULL_TREE)
4291 {
4292 cp_error ("duplicate label `%D'", decl);
4293 return 0;
4294 }
4295 else
4296 {
e349ee73 4297 struct named_label_list *uses, *prev;
28cbf42c 4298 int identified = 0;
8d08fdba
MS
4299
4300 /* Mark label as having been defined. */
4301 DECL_INITIAL (decl) = error_mark_node;
4302 /* Say where in the source. */
4303 DECL_SOURCE_FILE (decl) = filename;
4304 DECL_SOURCE_LINE (decl) = line;
4305
e349ee73
MS
4306 prev = NULL;
4307 uses = named_label_uses;
4308 while (uses != NULL)
4309 if (uses->label_decl == decl)
8d08fdba
MS
4310 {
4311 struct binding_level *b = current_binding_level;
4312 while (b)
4313 {
4314 tree new_decls = b->names;
e349ee73
MS
4315 tree old_decls = (b == uses->binding_level)
4316 ? uses->names_in_scope : NULL_TREE;
8d08fdba
MS
4317 while (new_decls != old_decls)
4318 {
4319 if (TREE_CODE (new_decls) == VAR_DECL
4320 /* Don't complain about crossing initialization
4321 of internal entities. They can't be accessed,
4322 and they should be cleaned up
4323 by the time we get to the label. */
700f8a87 4324 && ! DECL_ARTIFICIAL (new_decls)
8d08fdba
MS
4325 && ((DECL_INITIAL (new_decls) != NULL_TREE
4326 && DECL_INITIAL (new_decls) != error_mark_node)
4327 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4328 {
e349ee73
MS
4329 if (! identified)
4330 {
4331 cp_error ("jump to label `%D'", decl);
4332 error_with_file_and_line (uses->filename_o_goto,
4333 uses->lineno_o_goto,
4334 " from here");
4335 identified = 1;
4336 }
28cbf42c
MS
4337 cp_error_at (" crosses initialization of `%#D'",
4338 new_decls);
8d08fdba
MS
4339 }
4340 new_decls = TREE_CHAIN (new_decls);
4341 }
e349ee73 4342 if (b == uses->binding_level)
8d08fdba
MS
4343 break;
4344 b = b->level_chain;
4345 }
4346
e349ee73
MS
4347 if (prev != NULL)
4348 prev->next = uses->next;
8d08fdba 4349 else
e349ee73
MS
4350 named_label_uses = uses->next;
4351
4352 uses = uses->next;
4353 }
4354 else
4355 {
4356 prev = uses;
4357 uses = uses->next;
8d08fdba
MS
4358 }
4359 current_function_return_value = NULL_TREE;
4360 return decl;
4361 }
4362}
4363
a5894242
MS
4364struct cp_switch
4365{
4366 struct binding_level *level;
4367 struct cp_switch *next;
4368};
4369
4370static struct cp_switch *switch_stack;
4371
4372void
4373push_switch ()
4374{
4375 struct cp_switch *p
4376 = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4377 p->level = current_binding_level;
4378 p->next = switch_stack;
4379 switch_stack = p;
4380}
4381
4382void
4383pop_switch ()
4384{
4385 switch_stack = switch_stack->next;
4386}
4387
8d08fdba
MS
4388/* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
4389/* XXX Note decl is never actually used. (bpk) */
e92cc029 4390
8d08fdba
MS
4391void
4392define_case_label (decl)
4393 tree decl;
4394{
4395 tree cleanup = last_cleanup_this_contour ();
a5894242
MS
4396 struct binding_level *b = current_binding_level;
4397 int identified = 0;
4398
8d08fdba
MS
4399 if (cleanup)
4400 {
4401 static int explained = 0;
a5894242
MS
4402 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4403 warning ("where case label appears here");
8d08fdba
MS
4404 if (!explained)
4405 {
a5894242
MS
4406 warning ("(enclose actions of previous case statements requiring");
4407 warning ("destructors in their own binding contours.)");
8d08fdba
MS
4408 explained = 1;
4409 }
4410 }
4411
a5894242
MS
4412 for (; b && b != switch_stack->level; b = b->level_chain)
4413 {
4414 tree new_decls = b->names;
4415 for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4416 {
4417 if (TREE_CODE (new_decls) == VAR_DECL
4418 /* Don't complain about crossing initialization
4419 of internal entities. They can't be accessed,
4420 and they should be cleaned up
4421 by the time we get to the label. */
4422 && ! DECL_ARTIFICIAL (new_decls)
4423 && ((DECL_INITIAL (new_decls) != NULL_TREE
4424 && DECL_INITIAL (new_decls) != error_mark_node)
4425 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4426 {
4427 if (! identified)
4428 error ("jump to case label");
4429 identified = 1;
4430 cp_error_at (" crosses initialization of `%#D'",
4431 new_decls);
4432 }
4433 }
4434 }
4435
8d08fdba
MS
4436 /* After labels, make any new cleanups go into their
4437 own new (temporary) binding contour. */
4438
4439 current_binding_level->more_cleanups_ok = 0;
4440 current_function_return_value = NULL_TREE;
4441}
4442\f
4443/* Return the list of declarations of the current level.
4444 Note that this list is in reverse order unless/until
4445 you nreverse it; and when you do nreverse it, you must
4446 store the result back using `storedecls' or you will lose. */
4447
4448tree
4449getdecls ()
4450{
4451 return current_binding_level->names;
4452}
4453
4454/* Return the list of type-tags (for structs, etc) of the current level. */
4455
4456tree
4457gettags ()
4458{
4459 return current_binding_level->tags;
4460}
4461
4462/* Store the list of declarations of the current level.
4463 This is done for the parameter declarations of a function being defined,
4464 after they are modified in the light of any missing parameters. */
4465
4466static void
4467storedecls (decls)
4468 tree decls;
4469{
4470 current_binding_level->names = decls;
4471}
4472
4473/* Similarly, store the list of tags of the current level. */
4474
4475static void
4476storetags (tags)
4477 tree tags;
4478{
4479 current_binding_level->tags = tags;
4480}
4481\f
4482/* Given NAME, an IDENTIFIER_NODE,
4483 return the structure (or union or enum) definition for that name.
4484 Searches binding levels from BINDING_LEVEL up to the global level.
4485 If THISLEVEL_ONLY is nonzero, searches only the specified context
4486 (but skips any tag-transparent contexts to find one that is
4487 meaningful for tags).
4488 FORM says which kind of type the caller wants;
4489 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4490 If the wrong kind of type is found, and it's not a template, an error is
4491 reported. */
4492
4493static tree
4494lookup_tag (form, name, binding_level, thislevel_only)
4495 enum tree_code form;
8d08fdba 4496 tree name;
cffa8729 4497 struct binding_level *binding_level;
8d08fdba
MS
4498 int thislevel_only;
4499{
4500 register struct binding_level *level;
36a117a5
MM
4501 /* Non-zero if, we should look past a pseudo-global level, even if
4502 THISLEVEL_ONLY. */
4503 int allow_pseudo_global = 1;
8d08fdba
MS
4504
4505 for (level = binding_level; level; level = level->level_chain)
4506 {
4507 register tree tail;
4508 if (ANON_AGGRNAME_P (name))
4509 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4510 {
4511 /* There's no need for error checking here, because
4512 anon names are unique throughout the compilation. */
4513 if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4514 return TREE_VALUE (tail);
4515 }
2c73f9f5
ML
4516 else if (level->namespace_p)
4517 /* Do namespace lookup. */
6c011b01 4518 for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
2c73f9f5 4519 {
36a117a5
MM
4520 tree old = binding_for_name (name, tail);
4521
4522 /* If we just skipped past a pseudo global level, even
4523 though THISLEVEL_ONLY, and we find a template class
4524 declaration, then we use the _TYPE node for the
4525 template. See the example below. */
4526 if (thislevel_only && !allow_pseudo_global
4527 && old && BINDING_VALUE (old)
4528 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
4529 old = TREE_TYPE (BINDING_VALUE (old));
4530 else
4531 old = BINDING_TYPE (old);
4532
2c73f9f5
ML
4533 /* If it has an original type, it is a typedef, and we
4534 should not return it. */
4535 if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
4536 old = NULL_TREE;
4537 if (old && TREE_CODE (old) != form
4538 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
4539 {
4540 cp_error ("`%#D' redeclared as %C", old, form);
4541 return NULL_TREE;
4542 }
4543 if (old)
4544 return old;
4545 if (thislevel_only || tail == global_namespace)
4546 return NULL_TREE;
4547 }
8d08fdba
MS
4548 else
4549 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4550 {
a80e4195 4551 if (TREE_PURPOSE (tail) == name)
8d08fdba
MS
4552 {
4553 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
4554 /* Should tighten this up; it'll probably permit
4555 UNION_TYPE and a struct template, for example. */
4556 if (code != form
5566b478 4557 && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
8d08fdba
MS
4558 {
4559 /* Definition isn't the kind we were looking for. */
4560 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
4561 form);
72b7eeff 4562 return NULL_TREE;
8d08fdba
MS
4563 }
4564 return TREE_VALUE (tail);
4565 }
4566 }
4567 if (thislevel_only && ! level->tag_transparent)
5566b478 4568 {
36a117a5 4569 if (level->pseudo_global && allow_pseudo_global)
5566b478 4570 {
36a117a5
MM
4571 /* We must deal with cases like this:
4572
4573 template <class T> struct S;
4574 template <class T> struct S {};
4575
4576 When looking up `S', for the second declaration, we
4577 would like to find the first declaration. But, we
4578 are in the pseudo-global level created for the
4579 template parameters, rather than the (surrounding)
4580 namespace level. Thus, we keep going one more level,
4581 even though THISLEVEL_ONLY is non-zero. */
4582 allow_pseudo_global = 0;
4583 continue;
5566b478 4584 }
36a117a5
MM
4585 else
4586 return NULL_TREE;
5566b478 4587 }
2c73f9f5 4588 if (current_class_type && level->level_chain->namespace_p)
8d08fdba
MS
4589 {
4590 /* Try looking in this class's tags before heading into
4591 global binding level. */
4592 tree context = current_class_type;
4593 while (context)
4594 {
4595 switch (TREE_CODE_CLASS (TREE_CODE (context)))
4596 {
4597 tree these_tags;
4598 case 't':
4599 these_tags = CLASSTYPE_TAGS (context);
4600 if (ANON_AGGRNAME_P (name))
4601 while (these_tags)
4602 {
4603 if (TYPE_IDENTIFIER (TREE_VALUE (these_tags))
4604 == name)
4605 return TREE_VALUE (tail);
4606 these_tags = TREE_CHAIN (these_tags);
4607 }
4608 else
4609 while (these_tags)
4610 {
4611 if (TREE_PURPOSE (these_tags) == name)
4612 {
4613 if (TREE_CODE (TREE_VALUE (these_tags)) != form)
4614 {
4615 cp_error ("`%#D' redeclared as %C in class scope",
4616 TREE_VALUE (tail), form);
72b7eeff 4617 return NULL_TREE;
8d08fdba
MS
4618 }
4619 return TREE_VALUE (tail);
4620 }
4621 these_tags = TREE_CHAIN (these_tags);
4622 }
4623 /* If this type is not yet complete, then don't
4624 look at its context. */
4625 if (TYPE_SIZE (context) == NULL_TREE)
4626 goto no_context;
4627 /* Go to next enclosing type, if any. */
d2e5ee5c 4628 context = DECL_CONTEXT (TYPE_MAIN_DECL (context));
8d08fdba
MS
4629 break;
4630 case 'd':
4631 context = DECL_CONTEXT (context);
4632 break;
4633 default:
4634 my_friendly_abort (10);
4635 }
4636 continue;
4637 no_context:
4638 break;
4639 }
4640 }
4641 }
4642 return NULL_TREE;
4643}
4644
bd6dd845 4645#if 0
8d08fdba
MS
4646void
4647set_current_level_tags_transparency (tags_transparent)
4648 int tags_transparent;
4649{
4650 current_binding_level->tag_transparent = tags_transparent;
4651}
bd6dd845 4652#endif
8d08fdba
MS
4653
4654/* Given a type, find the tag that was defined for it and return the tag name.
4655 Otherwise return 0. However, the value can never be 0
4656 in the cases in which this is used.
4657
4658 C++: If NAME is non-zero, this is the new name to install. This is
4659 done when replacing anonymous tags with real tag names. */
4660
4661static tree
4662lookup_tag_reverse (type, name)
4663 tree type;
4664 tree name;
4665{
4666 register struct binding_level *level;
4667
4668 for (level = current_binding_level; level; level = level->level_chain)
4669 {
4670 register tree tail;
4671 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4672 {
4673 if (TREE_VALUE (tail) == type)
4674 {
4675 if (name)
4676 TREE_PURPOSE (tail) = name;
4677 return TREE_PURPOSE (tail);
4678 }
4679 }
4680 }
4681 return NULL_TREE;
4682}
8d08fdba
MS
4683\f
4684/* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
4685 Return the type value, or NULL_TREE if not found. */
e92cc029 4686
8d08fdba
MS
4687static tree
4688lookup_nested_type (type, context)
4689 tree type;
4690 tree context;
4691{
4692 if (context == NULL_TREE)
4693 return NULL_TREE;
4694 while (context)
4695 {
4696 switch (TREE_CODE (context))
4697 {
4698 case TYPE_DECL:
4699 {
4700 tree ctype = TREE_TYPE (context);
4701 tree match = value_member (type, CLASSTYPE_TAGS (ctype));
4702 if (match)
4703 return TREE_VALUE (match);
4704 context = DECL_CONTEXT (context);
4705
4706 /* When we have a nested class whose member functions have
4707 local types (e.g., a set of enums), we'll arrive here
4708 with the DECL_CONTEXT as the actual RECORD_TYPE node for
4709 the enclosing class. Instead, we want to make sure we
4710 come back in here with the TYPE_DECL, not the RECORD_TYPE. */
4711 if (context && TREE_CODE (context) == RECORD_TYPE)
4712 context = TREE_CHAIN (context);
4713 }
4714 break;
4715 case FUNCTION_DECL:
e1cd6e56
MS
4716 if (TYPE_NAME (type) && TYPE_IDENTIFIER (type))
4717 return lookup_name (TYPE_IDENTIFIER (type), 1);
4718 return NULL_TREE;
8d08fdba
MS
4719 default:
4720 my_friendly_abort (12);
4721 }
4722 }
4723 return NULL_TREE;
4724}
4725
a9aedbc2 4726/* Look up NAME in the NAMESPACE. */
e92cc029 4727
a9aedbc2
MS
4728tree
4729lookup_namespace_name (namespace, name)
4730 tree namespace, name;
4731{
2c73f9f5 4732 struct tree_binding _b;
30394414 4733 tree val;
2c73f9f5 4734
30394414
JM
4735 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
4736 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
4737
2c73f9f5 4738 val = binding_init (&_b);
52c11ef6 4739 if (!qualified_lookup_using_namespace (name, namespace, val, 0))
2c73f9f5
ML
4740 return error_mark_node;
4741
4742 if (BINDING_VALUE (val))
1c35f5b6
JM
4743 {
4744 val = BINDING_VALUE (val);
4745
4746 /* If we have a single function from a using decl, pull it out. */
4747 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
4748 val = OVL_FUNCTION (val);
4749 return val;
4750 }
4751
30394414
JM
4752 cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
4753 return error_mark_node;
a9aedbc2
MS
4754}
4755
5566b478
MS
4756tree
4757make_typename_type (context, name)
4758 tree context, name;
4759{
a80e4195 4760 tree t, d;
b2b7d40a 4761 tree fullname;
a80e4195 4762
653cc74a
JM
4763 if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
4764 name = TYPE_IDENTIFIER (name);
4765 else if (TREE_CODE (name) == TYPE_DECL)
a80e4195 4766 name = DECL_NAME (name);
b2b7d40a
JM
4767
4768 fullname = name;
4769
4770 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
11686454
JM
4771 {
4772 name = TREE_OPERAND (name, 0);
4773 if (TREE_CODE (name) == TEMPLATE_DECL)
4774 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
4775 }
b2b7d40a 4776 if (TREE_CODE (name) != IDENTIFIER_NODE)
a80e4195 4777 my_friendly_abort (2000);
5566b478 4778
85b71cf2 4779 if (! uses_template_parms (context)
b77ead33 4780 || currently_open_class (context))
5566b478 4781 {
b2b7d40a
JM
4782 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
4783 {
4784 if (IS_AGGR_TYPE (context))
4785 t = lookup_field (context, name, 0, 0);
4786 else
4787 t = NULL_TREE;
4788
4789 if (t == NULL_TREE || TREE_CODE (t) != TEMPLATE_DECL
4790 || TREE_CODE (DECL_RESULT (t)) != TYPE_DECL)
4791 {
4792 cp_error ("no class template named `%#T' in `%#T'",
4793 name, context);
4794 return error_mark_node;
4795 }
ffb690bd 4796
b2b7d40a 4797 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
36a117a5
MM
4798 NULL_TREE, context,
4799 /*entering_scope=*/0);
b2b7d40a
JM
4800 }
4801 else
5566b478 4802 {
b2b7d40a
JM
4803 if (IS_AGGR_TYPE (context))
4804 t = lookup_field (context, name, 0, 1);
4805 else
4806 t = NULL_TREE;
4807
4808 if (t == NULL_TREE)
4809 {
4810 cp_error ("no type named `%#T' in `%#T'", name, context);
4811 return error_mark_node;
4812 }
1107c4b3 4813
b2b7d40a 4814 return TREE_TYPE (t);
5566b478 4815 }
5566b478
MS
4816 }
4817
5156628f 4818 if (processing_template_decl)
5566b478
MS
4819 push_obstacks (&permanent_obstack, &permanent_obstack);
4820 t = make_lang_type (TYPENAME_TYPE);
b2b7d40a 4821 TYPENAME_TYPE_FULLNAME (t) = fullname;
5566b478 4822 d = build_decl (TYPE_DECL, name, t);
5156628f 4823 if (processing_template_decl)
5566b478
MS
4824 pop_obstacks ();
4825
cb0dbb9a 4826 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
d2e5ee5c
MS
4827 TYPE_NAME (TREE_TYPE (d)) = d;
4828 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
cb0dbb9a 4829 DECL_CONTEXT (d) = FROB_CONTEXT (context);
7fcdf4c2 4830 CLASSTYPE_GOT_SEMICOLON (t) = 1;
5566b478
MS
4831
4832 return t;
4833}
4834
2c73f9f5
ML
4835/* Select the right _DECL from multiple choices. */
4836
4837static tree
52c11ef6 4838select_decl (binding, flags)
2c73f9f5 4839 tree binding;
52c11ef6 4840 int flags;
2c73f9f5
ML
4841{
4842 tree val;
4843 val = BINDING_VALUE (binding);
52c11ef6 4844 if (LOOKUP_NAMESPACES_ONLY (flags))
3e3f722c
ML
4845 {
4846 /* We are not interested in types. */
4847 if (val && TREE_CODE (val) == NAMESPACE_DECL)
4848 return val;
4849 return NULL_TREE;
4850 }
4851
2c73f9f5
ML
4852 /* If we could have a type and
4853 we have nothing or we need a type and have none. */
4854 if (BINDING_TYPE (binding)
52c11ef6
JM
4855 && (!val || ((flags & LOOKUP_PREFER_TYPES)
4856 && TREE_CODE (val) != TYPE_DECL)))
2c73f9f5
ML
4857 val = TYPE_STUB_DECL (BINDING_TYPE (binding));
4858 /* Don't return non-types if we really prefer types. */
52c11ef6 4859 else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
2c73f9f5
ML
4860 && (!looking_for_template || TREE_CODE (val) != TEMPLATE_DECL))
4861 val = NULL_TREE;
1c35f5b6 4862
2c73f9f5
ML
4863 return val;
4864}
4865
ea9635c7
ML
4866/* Unscoped lookup of a global, iterate over namespaces, considering
4867 using namespace statements. */
4868
4869static tree
52c11ef6 4870unqualified_namespace_lookup (name, flags)
ea9635c7 4871 tree name;
52c11ef6 4872 int flags;
ea9635c7
ML
4873{
4874 struct tree_binding _binding;
4875 tree b = binding_init (&_binding);
4876 tree initial = current_decl_namespace();
4877 tree scope = initial;
4878 tree siter;
4879 struct binding_level *level;
4880 tree val = NULL_TREE;
4881
4882 while (!val)
4883 {
4884 val = binding_for_name (name, scope);
4885
4886 /* Initialize binding for this context. */
4887 BINDING_VALUE (b) = BINDING_VALUE (val);
4888 BINDING_TYPE (b) = BINDING_TYPE (val);
4889
4890 /* Add all _DECLs seen through local using-directives. */
4891 for (level = current_binding_level;
4892 !level->namespace_p;
4893 level = level->level_chain)
52c11ef6
JM
4894 if (!lookup_using_namespace (name, b, level->using_directives,
4895 scope, flags))
ea9635c7
ML
4896 /* Give up because of error. */
4897 return NULL_TREE;
4898
4899 /* Add all _DECLs seen through global using-directives. */
4900 /* XXX local and global using lists should work equally. */
4901 siter = initial;
4902 while (1)
4903 {
4904 if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
52c11ef6 4905 scope, flags))
ea9635c7
ML
4906 /* Give up because of error. */
4907 return NULL_TREE;
4908 if (siter == scope) break;
4909 siter = CP_DECL_CONTEXT (siter);
4910 }
4911
52c11ef6 4912 val = select_decl (b, flags);
ea9635c7
ML
4913 if (scope == global_namespace)
4914 break;
0c64a9ca 4915 scope = CP_DECL_CONTEXT (scope);
ea9635c7
ML
4916 }
4917 return val;
4918}
4919
52c11ef6
JM
4920/* Combine prefer_type and namespaces_only into flags. */
4921
4922static int
4923lookup_flags (prefer_type, namespaces_only)
4924 int prefer_type, namespaces_only;
4925{
4926 if (namespaces_only)
4927 return LOOKUP_PREFER_NAMESPACES;
4928 if (prefer_type > 1)
4929 return LOOKUP_PREFER_TYPES;
4930 if (prefer_type > 0)
4931 return LOOKUP_PREFER_BOTH;
4932 return 0;
4933}
4934
4935/* Given a lookup that returned VAL, use FLAGS to decide if we want to
4936 ignore it or not. Subroutine of lookup_name_real. */
4937
4938static tree
4939qualify_lookup (val, flags)
4940 tree val;
4941 int flags;
4942{
4943 if (val == NULL_TREE)
4944 return val;
6b945830
JM
4945 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
4946 return val;
4947 if ((flags & LOOKUP_PREFER_TYPES)
4948 && (TREE_CODE (val) == TYPE_DECL
4949 || ((flags & LOOKUP_TEMPLATES_EXPECTED)
4950 && DECL_CLASS_TEMPLATE_P (val))))
4951 return val;
4952 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
52c11ef6
JM
4953 return NULL_TREE;
4954 return val;
4955}
4956
8d08fdba
MS
4957/* Look up NAME in the current binding level and its superiors in the
4958 namespace of variables, functions and typedefs. Return a ..._DECL
4959 node of some kind representing its definition if there is only one
4960 such declaration, or return a TREE_LIST with all the overloaded
4961 definitions if there are many, or return 0 if it is undefined.
4962
2c73f9f5
ML
4963 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4964 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
a28e3c7f 4965 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
f84b4be9
JM
4966 Otherwise we prefer non-TYPE_DECLs.
4967
4968 If NONCLASS is non-zero, we don't look for the NAME in class scope,
4969 using IDENTIFIER_CLASS_VALUE. */
8d08fdba 4970
824b9a4c 4971static tree
3e3f722c 4972lookup_name_real (name, prefer_type, nonclass, namespaces_only)
8d08fdba 4973 tree name;
3e3f722c 4974 int prefer_type, nonclass, namespaces_only;
8d08fdba
MS
4975{
4976 register tree val;
a28e3c7f 4977 int yylex = 0;
e1cd6e56 4978 tree from_obj = NULL_TREE;
e76a2646 4979 tree locval, classval;
52c11ef6 4980 int flags;
8d08fdba 4981
3e3f722c
ML
4982 /* Hack: copy flag set by parser, if set. */
4983 if (only_namespace_names)
4984 namespaces_only = 1;
52c11ef6 4985
a28e3c7f
MS
4986 if (prefer_type == -2)
4987 {
4988 extern int looking_for_typename;
fc378698 4989 tree type = NULL_TREE;
a28e3c7f
MS
4990
4991 yylex = 1;
4992 prefer_type = looking_for_typename;
e1cd6e56 4993
52c11ef6
JM
4994 flags = lookup_flags (prefer_type, namespaces_only);
4995 /* During parsing, we need to complain. */
4996 flags |= LOOKUP_COMPLAIN;
4997 /* If the next thing is '<', class templates are types. */
4998 if (looking_for_template)
4999 flags |= LOOKUP_TEMPLATES_EXPECTED;
5000
653cc74a
JM
5001 /* std:: becomes :: for now. */
5002 if (got_scope == std_node)
5003 got_scope = void_type_node;
5004
e1cd6e56
MS
5005 if (got_scope)
5006 type = got_scope;
dff6b454 5007 else if (got_object != error_mark_node)
e1cd6e56 5008 type = got_object;
a28e3c7f 5009
e1cd6e56 5010 if (type)
a28e3c7f 5011 {
e1cd6e56 5012 if (type == error_mark_node)
f376e137 5013 return error_mark_node;
a80e4195
MS
5014 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5015 type = TREE_TYPE (type);
5566b478 5016
2b9dc906
JM
5017 if (TYPE_P (type))
5018 type = complete_type (type);
5566b478 5019
a1774733 5020 if (TREE_CODE (type) == VOID_TYPE)
2c73f9f5
ML
5021 type = global_namespace;
5022 if (TREE_CODE (type) == NAMESPACE_DECL)
a9aedbc2 5023 {
2c73f9f5
ML
5024 struct tree_binding b;
5025 val = binding_init (&b);
52c11ef6 5026 if (!qualified_lookup_using_namespace (name, type, val, flags))
2c73f9f5 5027 return NULL_TREE;
52c11ef6 5028 val = select_decl (val, flags);
a9aedbc2 5029 }
5566b478 5030 else if (! IS_AGGR_TYPE (type)
5156628f 5031 || TREE_CODE (type) == TEMPLATE_TYPE_PARM
73b0fce8 5032 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5156628f 5033 || TREE_CODE (type) == TYPENAME_TYPE)
e92cc029 5034 /* Someone else will give an error about this if needed. */
a28e3c7f 5035 val = NULL_TREE;
e1cd6e56 5036 else if (TYPE_BEING_DEFINED (type))
700f8a87
MS
5037 {
5038 val = IDENTIFIER_CLASS_VALUE (name);
e1cd6e56 5039 if (val && DECL_CONTEXT (val) != type)
700f8a87
MS
5040 {
5041 struct binding_level *b = class_binding_level;
5042 for (val = NULL_TREE; b; b = b->level_chain)
5043 {
5044 tree t = purpose_member (name, b->class_shadowed);
5045 if (t && TREE_VALUE (t)
e1cd6e56 5046 && DECL_CONTEXT (TREE_VALUE (t)) == type)
700f8a87
MS
5047 {
5048 val = TREE_VALUE (t);
5049 break;
5050 }
5051 }
5052 }
5566b478 5053 if (val == NULL_TREE)
e1cd6e56 5054 val = lookup_field (type, name, 0, 1);
700f8a87 5055 }
e1cd6e56 5056 else if (type == current_class_type)
a28e3c7f 5057 val = IDENTIFIER_CLASS_VALUE (name);
a28e3c7f 5058 else
d23a1bb1 5059 val = lookup_member (type, name, 0, prefer_type);
a28e3c7f 5060 }
e1cd6e56
MS
5061 else
5062 val = NULL_TREE;
5063
594740f3 5064 if (got_scope)
e1cd6e56 5065 goto done;
594740f3 5066 else if (got_object && val)
e1cd6e56 5067 from_obj = val;
a28e3c7f 5068 }
52c11ef6
JM
5069 else
5070 flags = lookup_flags (prefer_type, namespaces_only);
e76a2646
MS
5071
5072 locval = classval = NULL_TREE;
5073
52c11ef6
JM
5074 if (! namespace_bindings_p ())
5075 locval = qualify_lookup (IDENTIFIER_LOCAL_VALUE (name), flags);
e76a2646 5076
8d08fdba
MS
5077 /* In C++ class fields are between local and global scope,
5078 just before the global scope. */
e76a2646 5079 if (current_class_type && ! nonclass)
8d08fdba 5080 {
e76a2646
MS
5081 classval = IDENTIFIER_CLASS_VALUE (name);
5082 if (classval == NULL_TREE && TYPE_BEING_DEFINED (current_class_type))
700f8a87
MS
5083 /* Try to find values from base classes if we are presently
5084 defining a type. We are presently only interested in
5085 TYPE_DECLs. */
e76a2646 5086 classval = lookup_field (current_class_type, name, 0, 1);
8d08fdba 5087
b3709d9b 5088 /* Add implicit 'typename' to types from template bases. lookup_field
b9082e8a
JM
5089 will do this for us. If classval is actually from an enclosing
5090 scope, lookup_nested_field will get it for us. */
c1def683
JM
5091 else if (processing_template_decl
5092 && classval && TREE_CODE (classval) == TYPE_DECL
5093 && ! currently_open_class (DECL_CONTEXT (classval))
5094 && uses_template_parms (current_class_type)
5095 && ! DECL_ARTIFICIAL (classval))
b3709d9b 5096 classval = lookup_field (current_class_type, name, 0, 1);
b9082e8a
JM
5097
5098 /* yylex() calls this with -2, since we should never start digging for
5099 the nested name at the point where we haven't even, for example,
5100 created the COMPONENT_REF or anything like that. */
5101 if (classval == NULL_TREE)
5102 classval = lookup_nested_field (name, ! yylex);
52c11ef6
JM
5103
5104 classval = qualify_lookup (classval, flags);
e76a2646 5105 }
8d08fdba 5106
e76a2646
MS
5107 if (locval && classval)
5108 {
5109 if (current_scope () == current_function_decl
5110 && ! hack_decl_function_context (current_function_decl))
5111 /* Not in a nested function. */
5112 val = locval;
5113 else
5114 {
5115 /* This is incredibly horrible. The whole concept of
5116 IDENTIFIER_LOCAL_VALUE / IDENTIFIER_CLASS_VALUE /
5117 IDENTIFIER_GLOBAL_VALUE needs to be scrapped for local
5118 classes. */
5119 tree lctx = hack_decl_function_context (locval);
5120 tree cctx = hack_decl_function_context (classval);
5121
5122 if (lctx == current_scope ())
5123 val = locval;
5124 else if (lctx == cctx)
5125 val = classval;
5126 else
5127 /* I don't know which is right; let's just guess for now. */
5128 val = locval;
5129 }
8d08fdba 5130 }
e76a2646
MS
5131 else if (locval)
5132 val = locval;
5133 else if (classval)
5134 val = classval;
8d08fdba 5135 else
52c11ef6 5136 val = unqualified_namespace_lookup (name, flags);
8d08fdba 5137
c1def683
JM
5138 if (classval && TREE_CODE (val) == TYPE_DECL
5139 && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE
5140 && TREE_TYPE (TREE_TYPE (val)))
5141 {
5142 tree nsval = unqualified_namespace_lookup (name, flags);
5143
5144 if (val && nsval && TREE_CODE (nsval) == TYPE_DECL)
5145 {
5146 static int explained;
5147 cp_warning ("namespace-scope type `%#D'", nsval);
5148 cp_warning
5149 (" is used instead of `%D' from dependent base class", val);
5150 if (! explained)
5151 {
5152 explained = 1;
5153 cp_warning (" (use `typename %D' if that's what you meant)",
5154 val);
5155 }
5156 val = nsval;
5157 }
5158 }
5159
a28e3c7f 5160 done:
8d08fdba
MS
5161 if (val)
5162 {
c91a56d2 5163 /* This should only warn about types used in qualified-ids. */
e1cd6e56 5164 if (from_obj && from_obj != val)
5566b478 5165 {
c91a56d2
MS
5166 if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5167 && TREE_CODE (val) == TYPE_DECL
5168 && TREE_TYPE (from_obj) != TREE_TYPE (val))
5169 {
5170 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5171 name, got_object, TREE_TYPE (from_obj));
5172 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5173 TREE_TYPE (val));
5174 }
594740f3 5175
b8b1a3c1
JM
5176 /* We don't change val to from_obj if got_object depends on
5177 template parms because that breaks implicit typename for
5178 destructor calls. */
5179 if (! uses_template_parms (got_object))
53fdbb3b 5180 val = from_obj;
5566b478 5181 }
e1cd6e56 5182
cf776105 5183 if ((TREE_CODE (val) == TEMPLATE_DECL && looking_for_template)
a0a33927 5184 || TREE_CODE (val) == TYPE_DECL || prefer_type <= 0)
e1cd6e56 5185 ;
2c73f9f5 5186 /* Caller wants a class-or-namespace-name. */
b77ead33 5187 else if (prefer_type == 1 && TREE_CODE (val) == NAMESPACE_DECL)
2c73f9f5 5188 ;
e1cd6e56 5189 else if (IDENTIFIER_HAS_TYPE_VALUE (name))
d2e5ee5c 5190 val = TYPE_MAIN_DECL (IDENTIFIER_TYPE_VALUE (name));
e1cd6e56
MS
5191 else if (TREE_TYPE (val) == error_mark_node)
5192 val = error_mark_node;
0c64a9ca
JM
5193
5194 /* If we have a single function from a using decl, pull it out. */
5195 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5196 val = OVL_FUNCTION (val);
8d08fdba 5197 }
e1cd6e56
MS
5198 else if (from_obj)
5199 val = from_obj;
8d08fdba
MS
5200
5201 return val;
5202}
5203
700f8a87
MS
5204tree
5205lookup_name_nonclass (name)
5206 tree name;
5207{
3e3f722c 5208 return lookup_name_real (name, 0, 1, 0);
700f8a87
MS
5209}
5210
2c73f9f5
ML
5211tree
5212lookup_function_nonclass (name, args)
5213 tree name;
5214 tree args;
5215{
5216 return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5217}
5218
3e3f722c
ML
5219tree
5220lookup_name_namespace_only (name)
5221 tree name;
5222{
5223 /* type-or-namespace, nonclass, namespace_only */
5224 return lookup_name_real (name, 1, 1, 1);
5225}
5226
700f8a87
MS
5227tree
5228lookup_name (name, prefer_type)
5229 tree name;
5230 int prefer_type;
5231{
3e3f722c 5232 return lookup_name_real (name, prefer_type, 0, 0);
700f8a87
MS
5233}
5234
8d08fdba
MS
5235/* Similar to `lookup_name' but look only at current binding level. */
5236
5237tree
5238lookup_name_current_level (name)
5239 tree name;
5240{
5241 register tree t = NULL_TREE;
5242
2c73f9f5 5243 if (current_binding_level->namespace_p)
8d08fdba 5244 {
30394414 5245 t = IDENTIFIER_NAMESPACE_VALUE (name);
8d08fdba
MS
5246
5247 /* extern "C" function() */
5248 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5249 t = TREE_VALUE (t);
5250 }
5251 else if (IDENTIFIER_LOCAL_VALUE (name) != NULL_TREE)
5252 {
a4443a08
MS
5253 struct binding_level *b = current_binding_level;
5254 while (1)
5255 {
9ed182dc
JM
5256 if (purpose_member (name, b->shadowed))
5257 return IDENTIFIER_LOCAL_VALUE (name);
5258 if (b->keep == 2)
5259 b = b->level_chain;
5260 else
5261 break;
5262 }
5263 }
5264
5265 return t;
5266}
5267
5268/* Like lookup_name_current_level, but for types. */
5269
5270tree
5271lookup_type_current_level (name)
5272 tree name;
5273{
5274 register tree t = NULL_TREE;
5275
5276 my_friendly_assert (! current_binding_level->namespace_p, 980716);
5277
5278 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5279 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5280 {
5281 struct binding_level *b = current_binding_level;
5282 while (1)
5283 {
5284 if (purpose_member (name, b->type_shadowed))
5285 return REAL_IDENTIFIER_TYPE_VALUE (name);
a4443a08
MS
5286 if (b->keep == 2)
5287 b = b->level_chain;
5288 else
5289 break;
5290 }
8d08fdba
MS
5291 }
5292
5293 return t;
5294}
3e3f722c
ML
5295
5296void
5297begin_only_namespace_names ()
5298{
5299 only_namespace_names = 1;
5300}
5301
5302void
5303end_only_namespace_names ()
5304{
5305 only_namespace_names = 0;
5306}
8d08fdba
MS
5307\f
5308/* Arrange for the user to get a source line number, even when the
5309 compiler is going down in flames, so that she at least has a
5310 chance of working around problems in the compiler. We used to
5311 call error(), but that let the segmentation fault continue
5312 through; now, it's much more passive by asking them to send the
5313 maintainers mail about the problem. */
5314
5315static void
5316signal_catch (sig)
7dee3f36 5317 int sig ATTRIBUTE_UNUSED;
8d08fdba
MS
5318{
5319 signal (SIGSEGV, SIG_DFL);
5320#ifdef SIGIOT
5321 signal (SIGIOT, SIG_DFL);
5322#endif
5323#ifdef SIGILL
5324 signal (SIGILL, SIG_DFL);
5325#endif
5326#ifdef SIGABRT
5327 signal (SIGABRT, SIG_DFL);
5328#endif
5329#ifdef SIGBUS
5330 signal (SIGBUS, SIG_DFL);
5331#endif
5332 my_friendly_abort (0);
5333}
5334
de22184b
MS
5335#if 0
5336/* Unused -- brendan 970107 */
8d08fdba
MS
5337/* Array for holding types considered "built-in". These types
5338 are output in the module in which `main' is defined. */
5339static tree *builtin_type_tdescs_arr;
5340static int builtin_type_tdescs_len, builtin_type_tdescs_max;
de22184b 5341#endif
8d08fdba
MS
5342
5343/* Push the declarations of builtin types into the namespace.
5344 RID_INDEX, if < RID_MAX is the index of the builtin type
5345 in the array RID_POINTERS. NAME is the name used when looking
5346 up the builtin type. TYPE is the _TYPE node for the builtin type. */
5347
5348static void
5349record_builtin_type (rid_index, name, type)
5350 enum rid rid_index;
5351 char *name;
5352 tree type;
5353{
5354 tree rname = NULL_TREE, tname = NULL_TREE;
a703fb38 5355 tree tdecl = NULL_TREE;
8d08fdba
MS
5356
5357 if ((int) rid_index < (int) RID_MAX)
5358 rname = ridpointers[(int) rid_index];
5359 if (name)
5360 tname = get_identifier (name);
5361
5362 TYPE_BUILT_IN (type) = 1;
5363
5364 if (tname)
5365 {
8d08fdba 5366 tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
8d08fdba
MS
5367 set_identifier_type_value (tname, NULL_TREE);
5368 if ((int) rid_index < (int) RID_MAX)
2c73f9f5
ML
5369 /* Built-in types live in the global namespace. */
5370 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
8d08fdba
MS
5371 }
5372 if (rname != NULL_TREE)
5373 {
5374 if (tname != NULL_TREE)
5375 {
5376 set_identifier_type_value (rname, NULL_TREE);
2c73f9f5 5377 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
8d08fdba
MS
5378 }
5379 else
5380 {
8d08fdba 5381 tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
8d08fdba
MS
5382 set_identifier_type_value (rname, NULL_TREE);
5383 }
5384 }
8d08fdba
MS
5385}
5386
eff71ab0
PB
5387/* Record one of the standard Java types.
5388 * Declare it as having the given NAME.
5389 * If SIZE > 0, it is the size of one of the integral types;
5390 * otherwise it is the negative of the size of one of the other types. */
5391
5392static tree
5393record_builtin_java_type (name, size)
5394 char *name;
5395 int size;
5396{
5397 tree type, decl;
5398 if (size > 0)
5399 type = make_signed_type (size);
5400 else if (size > -32)
5401 { /* "__java_char" or ""__java_boolean". */
5402 type = make_unsigned_type (-size);
5403 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5404 }
5405 else
5406 { /* "__java_float" or ""__java_double". */
5407 type = make_node (REAL_TYPE);
5408 TYPE_PRECISION (type) = - size;
5409 layout_type (type);
5410 }
5411 record_builtin_type (RID_MAX, name, type);
5412 decl = TYPE_NAME (type);
5413 DECL_IGNORED_P (decl) = 1;
5414 TYPE_FOR_JAVA (type) = 1;
5415 return type;
5416}
5417
036407f7
ML
5418/* Push a type into the namespace so that the back-ends ignore it. */
5419
5420static void
5421record_unknown_type (type, name)
5422 tree type;
5423 char *name;
5424{
5425 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
5426 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
5427 DECL_IGNORED_P (decl) = 1;
5428 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5429 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
5430 TYPE_ALIGN (type) = 1;
5431 TYPE_MODE (type) = TYPE_MODE (void_type_node);
5432}
5433
8d08fdba
MS
5434/* Push overloaded decl, in global scope, with one argument so it
5435 can be used as a callback from define_function. */
e92cc029 5436
8d08fdba
MS
5437static void
5438push_overloaded_decl_1 (x)
5439 tree x;
5440{
5441 push_overloaded_decl (x, 0);
5442}
5443
8ccc31eb
MS
5444#ifdef __GNUC__
5445__inline
5446#endif
6b5fbb55
MS
5447tree
5448auto_function (name, type, code)
8ccc31eb
MS
5449 tree name, type;
5450 enum built_in_function code;
5451{
5452 return define_function
49c249e1 5453 (IDENTIFIER_POINTER (name), type, code, push_overloaded_decl_1,
8ccc31eb
MS
5454 IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
5455 0)));
5456}
5457
8d08fdba
MS
5458/* Create the predefined scalar types of C,
5459 and some nodes representing standard constants (0, 1, (void *)0).
5460 Initialize the global binding level.
5461 Make definitions for built-in primitive functions. */
5462
5463void
5464init_decl_processing ()
5465{
de22184b 5466 register tree endlink, int_endlink, double_endlink, unsigned_endlink;
8d08fdba 5467 tree fields[20];
8d08fdba 5468 /* Data type of memcpy. */
cffa8729 5469 tree memcpy_ftype, strlen_ftype;
8d08fdba
MS
5470 int wchar_type_size;
5471 tree temp;
5472 tree array_domain_type;
e1cd6e56 5473 extern int flag_strict_prototype;
a703fb38 5474 tree vb_off_identifier = NULL_TREE;
5566b478
MS
5475 /* Function type `char *(char *, char *)' and similar ones */
5476 tree string_ftype_ptr_ptr, int_ftype_string_string;
de22184b
MS
5477 tree sizetype_endlink;
5478 tree ptr_ftype, ptr_ftype_unsigned, ptr_ftype_sizetype;
ca55abae 5479 tree void_ftype, void_ftype_int, void_ftype_ptr, ptr_ftype_void;
8d08fdba
MS
5480
5481 /* Have to make these distinct before we try using them. */
5482 lang_name_cplusplus = get_identifier ("C++");
5483 lang_name_c = get_identifier ("C");
a1774733 5484 lang_name_java = get_identifier ("Java");
8d08fdba 5485
2c73f9f5 5486 /* Enter the global namespace. */
30394414
JM
5487 my_friendly_assert (global_namespace == NULL_TREE, 375);
5488 my_friendly_assert (current_lang_name == NULL_TREE, 375);
5489 current_lang_name = lang_name_cplusplus;
5490 push_namespace (get_identifier ("::"));
5491 global_namespace = current_namespace;
5492 current_lang_name = NULL_TREE;
5493
e1cd6e56
MS
5494 if (flag_strict_prototype == 2)
5495 {
5496 if (pedantic)
5497 strict_prototypes_lang_c = strict_prototypes_lang_cplusplus;
5498 }
5499 else
5500 strict_prototypes_lang_c = flag_strict_prototype;
8926095f 5501
8d08fdba
MS
5502 /* Initially, C. */
5503 current_lang_name = lang_name_c;
5504
5505 current_function_decl = NULL_TREE;
5506 named_labels = NULL_TREE;
e349ee73 5507 named_label_uses = NULL;
8d08fdba
MS
5508 current_binding_level = NULL_BINDING_LEVEL;
5509 free_binding_level = NULL_BINDING_LEVEL;
5510
42976354 5511#ifndef __CYGWIN32__
8d08fdba
MS
5512 /* Because most segmentation signals can be traced back into user
5513 code, catch them and at least give the user a chance of working
e92cc029 5514 around compiler bugs. */
8d08fdba
MS
5515 signal (SIGSEGV, signal_catch);
5516
5517 /* We will also catch aborts in the back-end through signal_catch and
5518 give the user a chance to see where the error might be, and to defeat
5519 aborts in the back-end when there have been errors previously in their
e92cc029 5520 code. */
8d08fdba
MS
5521#ifdef SIGIOT
5522 signal (SIGIOT, signal_catch);
5523#endif
5524#ifdef SIGILL
5525 signal (SIGILL, signal_catch);
5526#endif
5527#ifdef SIGABRT
5528 signal (SIGABRT, signal_catch);
5529#endif
5530#ifdef SIGBUS
5531 signal (SIGBUS, signal_catch);
5532#endif
7834ab39
MS
5533#else /* ndef __CYGWIN32__ */
5534 /* Cygwin32 cannot handle catching signals other than
5535 SIGABRT yet. We hope this will cease to be the case soon. */
5536#ifdef SIGABRT
5537 signal (SIGABRT, signal_catch);
5538#endif
5539#endif /* ndef __CYGWIN32__ */
8d08fdba
MS
5540
5541 gcc_obstack_init (&decl_obstack);
8d08fdba
MS
5542
5543 /* Must lay these out before anything else gets laid out. */
5544 error_mark_node = make_node (ERROR_MARK);
5545 TREE_PERMANENT (error_mark_node) = 1;
5546 TREE_TYPE (error_mark_node) = error_mark_node;
5547 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
5548 TREE_TYPE (error_mark_list) = error_mark_node;
5549
a28e3c7f
MS
5550 /* Make the binding_level structure for global names. */
5551 pushlevel (0);
8d08fdba 5552 global_binding_level = current_binding_level;
2c73f9f5
ML
5553 /* The global level is the namespace level of ::. */
5554 NAMESPACE_LEVEL (global_namespace) = global_binding_level;
5555 declare_namespace_level ();
8d08fdba
MS
5556
5557 this_identifier = get_identifier (THIS_NAME);
5558 in_charge_identifier = get_identifier (IN_CHARGE_NAME);
fc378698
MS
5559 ctor_identifier = get_identifier (CTOR_NAME);
5560 dtor_identifier = get_identifier (DTOR_NAME);
8d08fdba
MS
5561 pfn_identifier = get_identifier (VTABLE_PFN_NAME);
5562 index_identifier = get_identifier (VTABLE_INDEX_NAME);
5563 delta_identifier = get_identifier (VTABLE_DELTA_NAME);
5564 delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
5565 pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
dff6b454
RK
5566 if (flag_handle_signatures)
5567 {
5568 tag_identifier = get_identifier (SIGTABLE_TAG_NAME);
9dd70aa4
GB
5569 vb_off_identifier = get_identifier (SIGTABLE_VB_OFF_NAME);
5570 vt_off_identifier = get_identifier (SIGTABLE_VT_OFF_NAME);
dff6b454 5571 }
8d08fdba
MS
5572
5573 /* Define `int' and `char' first so that dbx will output them first. */
5574
5575 integer_type_node = make_signed_type (INT_TYPE_SIZE);
5576 record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
5577
5578 /* Define `char', which is like either `signed char' or `unsigned char'
5579 but not the same as either. */
5580
beb53fb8
JM
5581 char_type_node
5582 = (flag_signed_char
5583 ? make_signed_type (CHAR_TYPE_SIZE)
5584 : make_unsigned_type (CHAR_TYPE_SIZE));
8d08fdba
MS
5585 record_builtin_type (RID_CHAR, "char", char_type_node);
5586
5587 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
5588 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
5589
5590 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
5591 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
5592
5593 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
5594 record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
5595 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
5596
5597 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
5598 record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
5599
5600 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
5601 record_builtin_type (RID_MAX, "long long unsigned int",
5602 long_long_unsigned_type_node);
5603 record_builtin_type (RID_MAX, "long long unsigned",
5604 long_long_unsigned_type_node);
5605
5156628f
MS
5606 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
5607 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
5608 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
5609 record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
5610 record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
5611
8d08fdba 5612 /* `unsigned long' is the standard type for sizeof.
8d08fdba 5613 Note that stddef.h uses `unsigned long',
f5426d1e
R
5614 and this must agree, even if long and int are the same size. */
5615 set_sizetype
5616 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
8d08fdba
MS
5617
5618 ptrdiff_type_node
5619 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
5620
8d08fdba
MS
5621 /* Define both `signed char' and `unsigned char'. */
5622 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
5623 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
5624 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
5625 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
5626
5627 /* These are types that type_for_size and type_for_mode use. */
5628 intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
5629 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
5630 intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
5631 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
5632 intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
5633 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
5634 intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
5635 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
f7554e8c
JL
5636 intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
5637 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intTI_type_node));
8d08fdba
MS
5638 unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
5639 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
5640 unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
5641 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
5642 unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
5643 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
5644 unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
5645 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
f7554e8c
JL
5646 unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
5647 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intTI_type_node));
8d08fdba
MS
5648
5649 float_type_node = make_node (REAL_TYPE);
5650 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
5651 record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
5652 layout_type (float_type_node);
5653
5654 double_type_node = make_node (REAL_TYPE);
5655 if (flag_short_double)
5656 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
5657 else
5658 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
5659 record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
5660 layout_type (double_type_node);
5661
5662 long_double_type_node = make_node (REAL_TYPE);
5663 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
5664 record_builtin_type (RID_MAX, "long double", long_double_type_node);
5665 layout_type (long_double_type_node);
5666
37c46b43
MS
5667 complex_integer_type_node = make_node (COMPLEX_TYPE);
5668 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
5669 complex_integer_type_node));
5670 TREE_TYPE (complex_integer_type_node) = integer_type_node;
5671 layout_type (complex_integer_type_node);
5672
5673 complex_float_type_node = make_node (COMPLEX_TYPE);
5674 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
5675 complex_float_type_node));
5676 TREE_TYPE (complex_float_type_node) = float_type_node;
5677 layout_type (complex_float_type_node);
5678
5679 complex_double_type_node = make_node (COMPLEX_TYPE);
5680 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
5681 complex_double_type_node));
5682 TREE_TYPE (complex_double_type_node) = double_type_node;
5683 layout_type (complex_double_type_node);
5684
5685 complex_long_double_type_node = make_node (COMPLEX_TYPE);
5686 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
5687 complex_long_double_type_node));
5688 TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
5689 layout_type (complex_long_double_type_node);
5690
eff71ab0
PB
5691 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
5692 java_short_type_node = record_builtin_java_type ("__java_short", 16);
5693 java_int_type_node = record_builtin_java_type ("__java_int", 32);
5694 java_long_type_node = record_builtin_java_type ("__java_long", 64);
5695 java_float_type_node = record_builtin_java_type ("__java_float", -32);
5696 java_double_type_node = record_builtin_java_type ("__java_double", -64);
5697 java_char_type_node = record_builtin_java_type ("__java_char", -16);
5698 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
5699
8d08fdba
MS
5700 integer_zero_node = build_int_2 (0, 0);
5701 TREE_TYPE (integer_zero_node) = integer_type_node;
5702 integer_one_node = build_int_2 (1, 0);
5703 TREE_TYPE (integer_one_node) = integer_type_node;
5704 integer_two_node = build_int_2 (2, 0);
5705 TREE_TYPE (integer_two_node) = integer_type_node;
5706 integer_three_node = build_int_2 (3, 0);
5707 TREE_TYPE (integer_three_node) = integer_type_node;
8d08fdba 5708
255512c1
JM
5709 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
5710 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
c1ea6a0b
BK
5711 TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
5712 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
5713 TYPE_PRECISION (boolean_type_node) = 1;
255512c1
JM
5714 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
5715 boolean_false_node = build_int_2 (0, 0);
5716 TREE_TYPE (boolean_false_node) = boolean_type_node;
5717 boolean_true_node = build_int_2 (1, 0);
5718 TREE_TYPE (boolean_true_node) = boolean_type_node;
2986ae00 5719
8d08fdba
MS
5720 /* These are needed by stor-layout.c. */
5721 size_zero_node = size_int (0);
5722 size_one_node = size_int (1);
5723
e92cc029
MS
5724 signed_size_zero_node = build_int_2 (0, 0);
5725 TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
5726
8d08fdba
MS
5727 void_type_node = make_node (VOID_TYPE);
5728 record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
5729 layout_type (void_type_node); /* Uses integer_zero_node. */
5730 void_list_node = build_tree_list (NULL_TREE, void_type_node);
5731 TREE_PARMLIST (void_list_node) = 1;
5732
d11ad92e 5733 null_pointer_node = build_int_2 (0, 0);
8d08fdba 5734 TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
d11ad92e
MS
5735 layout_type (TREE_TYPE (null_pointer_node));
5736
8d08fdba
MS
5737 /* Used for expressions that do nothing, but are not errors. */
5738 void_zero_node = build_int_2 (0, 0);
5739 TREE_TYPE (void_zero_node) = void_type_node;
5740
5741 string_type_node = build_pointer_type (char_type_node);
beb53fb8
JM
5742 const_string_type_node
5743 = build_pointer_type (build_type_variant (char_type_node, 1, 0));
6b5fbb55 5744#if 0
8d08fdba 5745 record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6b5fbb55 5746#endif
8d08fdba
MS
5747
5748 /* Make a type to be the domain of a few array types
5749 whose domains don't really matter.
5750 200 is small enough that it always fits in size_t
5751 and large enough that it can hold most function names for the
5752 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5753 array_domain_type = build_index_type (build_int_2 (200, 0));
5754
2c73f9f5 5755 /* Make a type for arrays of characters.
8d08fdba
MS
5756 With luck nothing will ever really depend on the length of this
5757 array type. */
5758 char_array_type_node
5759 = build_array_type (char_type_node, array_domain_type);
5760 /* Likewise for arrays of ints. */
5761 int_array_type_node
5762 = build_array_type (integer_type_node, array_domain_type);
5763
5764 /* This is just some anonymous class type. Nobody should ever
5765 need to look inside this envelope. */
5766 class_star_type_node = build_pointer_type (make_lang_type (RECORD_TYPE));
5767
5768 default_function_type
5769 = build_function_type (integer_type_node, NULL_TREE);
8d08fdba
MS
5770
5771 ptr_type_node = build_pointer_type (void_type_node);
beb53fb8
JM
5772 const_ptr_type_node
5773 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
6b5fbb55 5774#if 0
8d08fdba 5775 record_builtin_type (RID_MAX, NULL_PTR, ptr_type_node);
6b5fbb55 5776#endif
8d08fdba
MS
5777 endlink = void_list_node;
5778 int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
5779 double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
de22184b
MS
5780 unsigned_endlink = tree_cons (NULL_TREE, unsigned_type_node, endlink);
5781
5782 ptr_ftype = build_function_type (ptr_type_node, NULL_TREE);
5783 ptr_ftype_unsigned = build_function_type (ptr_type_node, unsigned_endlink);
5784 sizetype_endlink = tree_cons (NULL_TREE, sizetype, endlink);
5785 /* We realloc here because sizetype could be int or unsigned. S'ok. */
5786 ptr_ftype_sizetype = build_function_type (ptr_type_node, sizetype_endlink);
5787
5788 void_ftype = build_function_type (void_type_node, endlink);
5789 void_ftype_int = build_function_type (void_type_node, int_endlink);
5790 void_ftype_ptr
5791 = build_function_type (void_type_node,
5792 tree_cons (NULL_TREE, ptr_type_node, endlink));
824b9a4c
MS
5793 void_ftype_ptr
5794 = build_exception_variant (void_ftype_ptr,
5795 tree_cons (NULL_TREE, NULL_TREE, NULL_TREE));
8d08fdba 5796
cffa8729
MS
5797 float_ftype_float
5798 = build_function_type (float_type_node,
5799 tree_cons (NULL_TREE, float_type_node, endlink));
5800
8d08fdba
MS
5801 double_ftype_double
5802 = build_function_type (double_type_node, double_endlink);
5803
cffa8729
MS
5804 ldouble_ftype_ldouble
5805 = build_function_type (long_double_type_node,
5806 tree_cons (NULL_TREE, long_double_type_node,
5807 endlink));
5808
8d08fdba
MS
5809 double_ftype_double_double
5810 = build_function_type (double_type_node,
a28e3c7f
MS
5811 tree_cons (NULL_TREE, double_type_node,
5812 double_endlink));
8d08fdba
MS
5813
5814 int_ftype_int
5815 = build_function_type (integer_type_node, int_endlink);
5816
5817 long_ftype_long
5818 = build_function_type (long_integer_type_node,
a28e3c7f
MS
5819 tree_cons (NULL_TREE, long_integer_type_node,
5820 endlink));
8d08fdba 5821
8d08fdba
MS
5822 int_ftype_cptr_cptr_sizet
5823 = build_function_type (integer_type_node,
5824 tree_cons (NULL_TREE, const_ptr_type_node,
5825 tree_cons (NULL_TREE, const_ptr_type_node,
5826 tree_cons (NULL_TREE,
5827 sizetype,
5828 endlink))));
5829
8d08fdba
MS
5830 string_ftype_ptr_ptr /* strcpy prototype */
5831 = build_function_type (string_type_node,
5832 tree_cons (NULL_TREE, string_type_node,
5833 tree_cons (NULL_TREE,
5834 const_string_type_node,
5835 endlink)));
5836
8d08fdba
MS
5837 int_ftype_string_string /* strcmp prototype */
5838 = build_function_type (integer_type_node,
5839 tree_cons (NULL_TREE, const_string_type_node,
5840 tree_cons (NULL_TREE,
5841 const_string_type_node,
5842 endlink)));
5843
cffa8729 5844 strlen_ftype /* strlen prototype */
8d08fdba
MS
5845 = build_function_type (sizetype,
5846 tree_cons (NULL_TREE, const_string_type_node,
5847 endlink));
5848
8d08fdba 5849 memcpy_ftype /* memcpy prototype */
d22c8596 5850 = build_function_type (ptr_type_node,
8d08fdba
MS
5851 tree_cons (NULL_TREE, ptr_type_node,
5852 tree_cons (NULL_TREE, const_ptr_type_node,
de22184b 5853 sizetype_endlink)));
8d08fdba
MS
5854
5855 if (flag_huge_objects)
5856 delta_type_node = long_integer_type_node;
5857 else
5858 delta_type_node = short_integer_type_node;
5859
b9620d0e 5860 builtin_function ("__builtin_constant_p", default_function_type,
8d08fdba
MS
5861 BUILT_IN_CONSTANT_P, NULL_PTR);
5862
beb53fb8
JM
5863 builtin_return_address_fndecl
5864 = builtin_function ("__builtin_return_address", ptr_ftype_unsigned,
5865 BUILT_IN_RETURN_ADDRESS, NULL_PTR);
8926095f 5866
de22184b 5867 builtin_function ("__builtin_frame_address", ptr_ftype_unsigned,
8926095f
MS
5868 BUILT_IN_FRAME_ADDRESS, NULL_PTR);
5869
ca55abae
JM
5870 ptr_ftype_void = build_function_type (ptr_type_node, endlink);
5871 builtin_function ("__builtin_fp", ptr_ftype_void, BUILT_IN_FP, NULL_PTR);
5872 builtin_function ("__builtin_sp", ptr_ftype_void, BUILT_IN_SP, NULL_PTR);
5873
de22184b 5874 builtin_function ("__builtin_alloca", ptr_ftype_sizetype,
8d08fdba 5875 BUILT_IN_ALLOCA, "alloca");
cffa8729 5876 builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
00595019
MS
5877 /* Define alloca, ffs as builtins.
5878 Declare _exit just to mark it as volatile. */
5879 if (! flag_no_builtin && !flag_no_nonansi_builtin)
5880 {
de22184b 5881 temp = builtin_function ("alloca", ptr_ftype_sizetype,
00595019
MS
5882 BUILT_IN_ALLOCA, NULL_PTR);
5883 /* Suppress error if redefined as a non-function. */
5884 DECL_BUILT_IN_NONANSI (temp) = 1;
00595019
MS
5885 temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
5886 /* Suppress error if redefined as a non-function. */
5887 DECL_BUILT_IN_NONANSI (temp) = 1;
de22184b 5888 temp = builtin_function ("_exit", void_ftype_int,
00595019
MS
5889 NOT_BUILT_IN, NULL_PTR);
5890 TREE_THIS_VOLATILE (temp) = 1;
5891 TREE_SIDE_EFFECTS (temp) = 1;
5892 /* Suppress error if redefined as a non-function. */
5893 DECL_BUILT_IN_NONANSI (temp) = 1;
5894 }
8d08fdba 5895
cffa8729
MS
5896 builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
5897 builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
5898 NULL_PTR);
5899 builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
5900 NULL_PTR);
5901 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
5902 NULL_PTR);
8d08fdba
MS
5903 builtin_function ("__builtin_labs", long_ftype_long,
5904 BUILT_IN_LABS, NULL_PTR);
de22184b 5905 builtin_function ("__builtin_saveregs", ptr_ftype,
8d08fdba 5906 BUILT_IN_SAVEREGS, NULL_PTR);
8d08fdba
MS
5907 builtin_function ("__builtin_classify_type", default_function_type,
5908 BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
de22184b 5909 builtin_function ("__builtin_next_arg", ptr_ftype,
8d08fdba 5910 BUILT_IN_NEXT_ARG, NULL_PTR);
de22184b 5911 builtin_function ("__builtin_args_info", int_ftype_int,
8d08fdba 5912 BUILT_IN_ARGS_INFO, NULL_PTR);
eb66be0e
MS
5913 builtin_function ("__builtin_setjmp",
5914 build_function_type (integer_type_node,
5915 tree_cons (NULL_TREE, ptr_type_node,
5916 endlink)),
5917 BUILT_IN_SETJMP, NULL_PTR);
5918 builtin_function ("__builtin_longjmp",
5919 build_function_type (integer_type_node,
5920 tree_cons (NULL_TREE, ptr_type_node,
5921 tree_cons (NULL_TREE,
5922 integer_type_node,
5923 endlink))),
5924 BUILT_IN_LONGJMP, NULL_PTR);
8d08fdba
MS
5925
5926 /* Untyped call and return. */
de22184b 5927 builtin_function ("__builtin_apply_args", ptr_ftype,
8d08fdba
MS
5928 BUILT_IN_APPLY_ARGS, NULL_PTR);
5929
5930 temp = tree_cons (NULL_TREE,
5931 build_pointer_type (build_function_type (void_type_node,
5932 NULL_TREE)),
2c73f9f5 5933 tree_cons (NULL_TREE, ptr_ftype_sizetype, NULL_TREE));
8d08fdba
MS
5934 builtin_function ("__builtin_apply",
5935 build_function_type (ptr_type_node, temp),
5936 BUILT_IN_APPLY, NULL_PTR);
de22184b 5937 builtin_function ("__builtin_return", void_ftype_ptr,
8d08fdba
MS
5938 BUILT_IN_RETURN, NULL_PTR);
5939
5940 /* Currently under experimentation. */
5941 builtin_function ("__builtin_memcpy", memcpy_ftype,
5942 BUILT_IN_MEMCPY, "memcpy");
5943 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
5944 BUILT_IN_MEMCMP, "memcmp");
5945 builtin_function ("__builtin_strcmp", int_ftype_string_string,
5946 BUILT_IN_STRCMP, "strcmp");
5947 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
5948 BUILT_IN_STRCPY, "strcpy");
cffa8729 5949 builtin_function ("__builtin_strlen", strlen_ftype,
8d08fdba 5950 BUILT_IN_STRLEN, "strlen");
cffa8729
MS
5951 builtin_function ("__builtin_sqrtf", float_ftype_float,
5952 BUILT_IN_FSQRT, "sqrtf");
5953 builtin_function ("__builtin_fsqrt", double_ftype_double,
5954 BUILT_IN_FSQRT, NULL_PTR);
5955 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
5956 BUILT_IN_FSQRT, "sqrtl");
5957 builtin_function ("__builtin_sinf", float_ftype_float,
5958 BUILT_IN_SIN, "sinf");
5959 builtin_function ("__builtin_sin", double_ftype_double,
5960 BUILT_IN_SIN, "sin");
5961 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
5962 BUILT_IN_SIN, "sinl");
5963 builtin_function ("__builtin_cosf", float_ftype_float,
5964 BUILT_IN_COS, "cosf");
5965 builtin_function ("__builtin_cos", double_ftype_double,
5966 BUILT_IN_COS, "cos");
5967 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
5968 BUILT_IN_COS, "cosl");
8d08fdba
MS
5969
5970 if (!flag_no_builtin)
5971 {
8d08fdba
MS
5972 builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
5973 builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
5974 builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
cffa8729
MS
5975 builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS, NULL_PTR);
5976 builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
5977 NULL_PTR);
8d08fdba
MS
5978 builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
5979 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
5980 NULL_PTR);
cffa8729
MS
5981 builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
5982 NULL_PTR);
a28e3c7f
MS
5983 builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
5984 NULL_PTR);
cffa8729
MS
5985 builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN, NULL_PTR);
5986 builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT, NULL_PTR);
5987 builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT, NULL_PTR);
5988 builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
5989 NULL_PTR);
5990 builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN, NULL_PTR);
8d08fdba 5991 builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
cffa8729
MS
5992 builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN, NULL_PTR);
5993 builtin_function ("cosf", float_ftype_float, BUILT_IN_COS, NULL_PTR);
8d08fdba 5994 builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
cffa8729 5995 builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS, NULL_PTR);
00595019
MS
5996
5997 /* Declare these functions volatile
5998 to avoid spurious "control drops through" warnings. */
de22184b 5999 temp = builtin_function ("abort", void_ftype,
00595019
MS
6000 NOT_BUILT_IN, NULL_PTR);
6001 TREE_THIS_VOLATILE (temp) = 1;
6002 TREE_SIDE_EFFECTS (temp) = 1;
6003 /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
6004 them... */
6005 DECL_BUILT_IN_NONANSI (temp) = 1;
de22184b 6006 temp = builtin_function ("exit", void_ftype_int,
00595019
MS
6007 NOT_BUILT_IN, NULL_PTR);
6008 TREE_THIS_VOLATILE (temp) = 1;
6009 TREE_SIDE_EFFECTS (temp) = 1;
6010 DECL_BUILT_IN_NONANSI (temp) = 1;
8d08fdba
MS
6011 }
6012
6013#if 0
6014 /* Support for these has not been written in either expand_builtin
6015 or build_function_call. */
72b7eeff
MS
6016 builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR);
6017 builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR);
a28e3c7f 6018 builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
72b7eeff 6019 NULL_PTR);
cffa8729
MS
6020 builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
6021 NULL_PTR);
a28e3c7f 6022 builtin_function ("__builtin_fmod", double_ftype_double_double,
72b7eeff 6023 BUILT_IN_FMOD, NULL_PTR);
a28e3c7f 6024 builtin_function ("__builtin_frem", double_ftype_double_double,
72b7eeff 6025 BUILT_IN_FREM, NULL_PTR);
cffa8729
MS
6026 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int,
6027 BUILT_IN_MEMSET, NULL_PTR);
a28e3c7f 6028 builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
72b7eeff 6029 NULL_PTR);
a28e3c7f 6030 builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
72b7eeff 6031 NULL_PTR);
8d08fdba
MS
6032#endif
6033
6034 /* C++ extensions */
6035
6036 unknown_type_node = make_node (UNKNOWN_TYPE);
036407f7
ML
6037 record_unknown_type (unknown_type_node, "unknown type");
6038
8d08fdba
MS
6039 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6040 TREE_TYPE (unknown_type_node) = unknown_type_node;
a6967cc0 6041
03d0f4af 6042 TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
a6967cc0
JM
6043
6044 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6045 result. */
8d08fdba
MS
6046 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6047 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6048
6049 /* This is for handling opaque types in signatures. */
6050 opaque_type_node = copy_node (ptr_type_node);
6051 TYPE_MAIN_VARIANT (opaque_type_node) = opaque_type_node;
6052 record_builtin_type (RID_MAX, 0, opaque_type_node);
6053
e92cc029 6054 /* This is special for C++ so functions can be overloaded. */
8d08fdba
MS
6055 wchar_type_node
6056 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
6057 wchar_type_size = TYPE_PRECISION (wchar_type_node);
6058 signed_wchar_type_node = make_signed_type (wchar_type_size);
6059 unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6060 wchar_type_node
6061 = TREE_UNSIGNED (wchar_type_node)
6062 ? unsigned_wchar_type_node
6063 : signed_wchar_type_node;
6064 record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6065
f376e137
MS
6066 /* Artificial declaration of wchar_t -- can be bashed */
6067 wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6068 wchar_type_node);
6069 pushdecl (wchar_decl_node);
6070
8d08fdba
MS
6071 /* This is for wide string constants. */
6072 wchar_array_type_node
6073 = build_array_type (wchar_type_node, array_domain_type);
6074
8926095f 6075 if (flag_vtable_thunks)
700f8a87
MS
6076 {
6077 /* Make sure we get a unique function type, so we can give
6078 its pointer type a name. (This wins for gdb.) */
6079 tree vfunc_type = make_node (FUNCTION_TYPE);
6080 TREE_TYPE (vfunc_type) = integer_type_node;
6081 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6082 layout_type (vfunc_type);
6083
6084 vtable_entry_type = build_pointer_type (vfunc_type);
6085 }
8926095f 6086 else
700f8a87
MS
6087 {
6088 vtable_entry_type = make_lang_type (RECORD_TYPE);
6089 fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
6090 delta_type_node);
6091 fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
6092 delta_type_node);
6093 fields[2] = build_lang_field_decl (FIELD_DECL, pfn_identifier,
6094 ptr_type_node);
6095 finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6096 double_type_node);
6097
6098 /* Make this part of an invisible union. */
6099 fields[3] = copy_node (fields[2]);
6100 TREE_TYPE (fields[3]) = delta_type_node;
6101 DECL_NAME (fields[3]) = delta2_identifier;
6102 DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6103 DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6104 TREE_UNSIGNED (fields[3]) = 0;
6105 TREE_CHAIN (fields[2]) = fields[3];
6106 vtable_entry_type = build_type_variant (vtable_entry_type, 1, 0);
6107 }
6108 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
8d08fdba 6109
8d08fdba
MS
6110 vtbl_type_node
6111 = build_array_type (vtable_entry_type, NULL_TREE);
6112 layout_type (vtbl_type_node);
f376e137 6113 vtbl_type_node = cp_build_type_variant (vtbl_type_node, 1, 0);
8d08fdba
MS
6114 record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6115
6116 /* Simplify life by making a "sigtable_entry_type". Give its
6117 fields names so that the debugger can use them. */
6118
6119 if (flag_handle_signatures)
6120 {
6121 sigtable_entry_type = make_lang_type (RECORD_TYPE);
dff6b454
RK
6122 fields[0] = build_lang_field_decl (FIELD_DECL, tag_identifier,
6123 delta_type_node);
9dd70aa4 6124 fields[1] = build_lang_field_decl (FIELD_DECL, vb_off_identifier,
dff6b454 6125 delta_type_node);
9dd70aa4 6126 fields[2] = build_lang_field_decl (FIELD_DECL, delta_identifier,
dff6b454
RK
6127 delta_type_node);
6128 fields[3] = build_lang_field_decl (FIELD_DECL, index_identifier,
6129 delta_type_node);
9dd70aa4
GB
6130 fields[4] = build_lang_field_decl (FIELD_DECL, pfn_identifier,
6131 ptr_type_node);
6132
6133 /* Set the alignment to the max of the alignment of ptr_type_node and
6134 delta_type_node. Double alignment wastes a word on the Sparc. */
6135 finish_builtin_type (sigtable_entry_type, SIGTABLE_PTR_TYPE, fields, 4,
6136 (TYPE_ALIGN (ptr_type_node) > TYPE_ALIGN (delta_type_node))
6137 ? ptr_type_node
6138 : delta_type_node);
dff6b454
RK
6139
6140 /* Make this part of an invisible union. */
9dd70aa4
GB
6141 fields[5] = copy_node (fields[4]);
6142 TREE_TYPE (fields[5]) = delta_type_node;
6143 DECL_NAME (fields[5]) = vt_off_identifier;
6144 DECL_MODE (fields[5]) = TYPE_MODE (delta_type_node);
6145 DECL_SIZE (fields[5]) = TYPE_SIZE (delta_type_node);
6146 TREE_UNSIGNED (fields[5]) = 0;
6147 TREE_CHAIN (fields[4]) = fields[5];
dff6b454 6148
8d08fdba
MS
6149 sigtable_entry_type = build_type_variant (sigtable_entry_type, 1, 0);
6150 record_builtin_type (RID_MAX, SIGTABLE_PTR_TYPE, sigtable_entry_type);
6151 }
6152
2c73f9f5
ML
6153 std_node = build_decl (NAMESPACE_DECL,
6154 get_identifier (flag_honor_std ? "fake std":"std"),
6633d636
MS
6155 void_type_node);
6156 pushdecl (std_node);
6157
2c73f9f5 6158 global_type_node = make_node (LANG_TYPE);
036407f7 6159 record_unknown_type (global_type_node, "global type");
2c73f9f5 6160
db5ae43f
MS
6161 /* Now, C++. */
6162 current_lang_name = lang_name_cplusplus;
8d08fdba 6163
ced78d8b 6164 {
2c73f9f5
ML
6165 tree bad_alloc_type_node, newtype, deltype;
6166 if (flag_honor_std)
6167 push_namespace (get_identifier ("std"));
6168 bad_alloc_type_node = xref_tag
ced78d8b 6169 (class_type_node, get_identifier ("bad_alloc"), NULL_TREE, 1);
2c73f9f5
ML
6170 if (flag_honor_std)
6171 pop_namespace ();
6172 newtype = build_exception_variant
ced78d8b 6173 (ptr_ftype_sizetype, build_tree_list (NULL_TREE, bad_alloc_type_node));
2c73f9f5 6174 deltype = build_exception_variant
ced78d8b
JM
6175 (void_ftype_ptr, build_tree_list (NULL_TREE, NULL_TREE));
6176 auto_function (ansi_opname[(int) NEW_EXPR], newtype, NOT_BUILT_IN);
6177 auto_function (ansi_opname[(int) VEC_NEW_EXPR], newtype, NOT_BUILT_IN);
6178 auto_function (ansi_opname[(int) DELETE_EXPR], deltype, NOT_BUILT_IN);
6179 auto_function (ansi_opname[(int) VEC_DELETE_EXPR], deltype, NOT_BUILT_IN);
6180 }
8d08fdba
MS
6181
6182 abort_fndecl
de22184b 6183 = define_function ("__pure_virtual", void_ftype,
8d08fdba
MS
6184 NOT_BUILT_IN, 0, 0);
6185
8d08fdba
MS
6186 /* Perform other language dependent initializations. */
6187 init_class_processing ();
6188 init_init_processing ();
6189 init_search_processing ();
1737fe20
BK
6190 if (flag_rtti)
6191 init_rtti_processing ();
8d08fdba 6192
6467930b 6193 if (flag_exceptions)
8d2733ca 6194 init_exception_processing ();
8d08fdba
MS
6195 if (flag_no_inline)
6196 {
6197 flag_inline_functions = 0;
8d08fdba 6198 }
9e9ff709 6199
7fcdf4c2 6200 if (! supports_one_only ())
72b7eeff 6201 flag_weak = 0;
8d08fdba
MS
6202
6203 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6204 declare_function_name ();
6205
6206 /* Prepare to check format strings against argument lists. */
6207 init_function_format_info ();
e9a25f70
JL
6208
6209 /* Show we use EH for cleanups. */
6210 using_eh_for_cleanups ();
62c154ed
JM
6211
6212 print_error_function = lang_print_error_function;
501ba25a 6213 lang_get_alias_set = &c_get_alias_set;
d9cf7c82
JM
6214
6215 /* Maintain consistency. Perhaps we should just complain if they
6216 say -fwritable-strings? */
6217 if (flag_writable_strings)
6218 flag_const_strings = 0;
62c154ed
JM
6219}
6220
6221/* Function to print any language-specific context for an error message. */
6222
6223static void
6224lang_print_error_function (file)
6225 char *file;
6226{
6227 default_print_error_function (file);
6228 maybe_print_template_context ();
8d08fdba
MS
6229}
6230
6231/* Make a definition for a builtin function named NAME and whose data type
6232 is TYPE. TYPE should be a function type with argument types.
6233 FUNCTION_CODE tells later passes how to compile calls to this function.
6234 See tree.h for its possible values.
6235
6236 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6237 the name to be called if we can't opencode the function. */
6238
6239tree
6240define_function (name, type, function_code, pfn, library_name)
6241 char *name;
6242 tree type;
6243 enum built_in_function function_code;
49c249e1 6244 void (*pfn) PROTO((tree));
8d08fdba
MS
6245 char *library_name;
6246{
6247 tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
6248 DECL_EXTERNAL (decl) = 1;
6249 TREE_PUBLIC (decl) = 1;
863adfc0 6250 DECL_ARTIFICIAL (decl) = 1;
8d08fdba 6251
2c73f9f5 6252 my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
cb0dbb9a 6253 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2c73f9f5 6254
8d08fdba
MS
6255 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6256 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6257 function in the namespace. */
6258 if (pfn) (*pfn) (decl);
6259 if (library_name)
6260 DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
6261 make_function_rtl (decl);
6262 if (function_code != NOT_BUILT_IN)
6263 {
6264 DECL_BUILT_IN (decl) = 1;
39211cd5 6265 DECL_FUNCTION_CODE (decl) = function_code;
8d08fdba
MS
6266 }
6267 return decl;
6268}
6269\f
6270/* Called when a declaration is seen that contains no names to declare.
6271 If its type is a reference to a structure, union or enum inherited
6272 from a containing scope, shadow that tag name for the current scope
6273 with a forward reference.
6274 If its type defines a new named structure or union
6275 or defines an enum, it is valid but we need not do anything here.
6276 Otherwise, it is an error.
6277
6278 C++: may have to grok the declspecs to learn about static,
6279 complain for anonymous unions. */
6280
6281void
6282shadow_tag (declspecs)
6283 tree declspecs;
6284{
6285 int found_tag = 0;
2986ae00 6286 tree ob_modifier = NULL_TREE;
8d08fdba
MS
6287 register tree link;
6288 register enum tree_code code, ok_code = ERROR_MARK;
6289 register tree t = NULL_TREE;
6290
6291 for (link = declspecs; link; link = TREE_CHAIN (link))
6292 {
6293 register tree value = TREE_VALUE (link);
6294
6295 code = TREE_CODE (value);
6296 if (IS_AGGR_TYPE_CODE (code) || code == ENUMERAL_TYPE)
8d08fdba 6297 {
d2e5ee5c 6298 my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
8d08fdba 6299
36a117a5 6300 maybe_process_partial_specialization (value);
5566b478 6301
b8bca6f2
JM
6302 t = value;
6303 ok_code = code;
6304 found_tag++;
8d08fdba
MS
6305 }
6306 else if (value == ridpointers[(int) RID_STATIC]
2986ae00
MS
6307 || value == ridpointers[(int) RID_EXTERN]
6308 || value == ridpointers[(int) RID_AUTO]
28cbf42c
MS
6309 || value == ridpointers[(int) RID_REGISTER]
6310 || value == ridpointers[(int) RID_INLINE]
6311 || value == ridpointers[(int) RID_VIRTUAL]
6312 || value == ridpointers[(int) RID_EXPLICIT])
2986ae00 6313 ob_modifier = value;
8d08fdba
MS
6314 }
6315
6316 /* This is where the variables in an anonymous union are
6317 declared. An anonymous union declaration looks like:
6318 union { ... } ;
6319 because there is no declarator after the union, the parser
6320 sends that declaration here. */
6321 if (ok_code == UNION_TYPE
6322 && t != NULL_TREE
6323 && ((TREE_CODE (TYPE_NAME (t)) == IDENTIFIER_NODE
6324 && ANON_AGGRNAME_P (TYPE_NAME (t)))
6325 || (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL
6326 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))))
6327 {
d2e5ee5c 6328 /* See also grok_x_components. */
d2e5ee5c
MS
6329 tree *q;
6330
6331 /* Wipe out memory of synthesized methods */
6332 TYPE_HAS_CONSTRUCTOR (t) = 0;
6333 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6334 TYPE_HAS_INIT_REF (t) = 0;
6335 TYPE_HAS_CONST_INIT_REF (t) = 0;
6336 TYPE_HAS_ASSIGN_REF (t) = 0;
6337 TYPE_HAS_ASSIGNMENT (t) = 0;
6338 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6339
6340 q = &TYPE_METHODS (t);
6341 while (*q)
6342 {
6343 if (DECL_ARTIFICIAL (*q))
6344 *q = TREE_CHAIN (*q);
6345 else
6346 q = &TREE_CHAIN (*q);
6347 }
f49422da 6348
8d08fdba
MS
6349 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
6350 function members. */
d2e5ee5c
MS
6351 if (TYPE_METHODS (t))
6352 error ("an anonymous union cannot have function members");
c91a56d2 6353
8d08fdba
MS
6354 if (TYPE_FIELDS (t))
6355 {
a28e3c7f 6356 tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
c11b6f21 6357 NULL_TREE);
8d08fdba
MS
6358 finish_anon_union (decl);
6359 }
8d08fdba
MS
6360 }
6361 else
6362 {
6363 /* Anonymous unions are objects, that's why we only check for
2986ae00 6364 inappropriate specifiers in this branch. */
28cbf42c 6365
2986ae00 6366 if (ob_modifier)
28cbf42c
MS
6367 {
6368 if (ob_modifier == ridpointers[(int) RID_INLINE]
6369 || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6370 cp_error ("`%D' can only be specified for functions", ob_modifier);
6371 else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6372 cp_error ("`%D' can only be specified for constructors",
6373 ob_modifier);
6374 else
6375 cp_error ("`%D' can only be specified for objects and functions",
6376 ob_modifier);
6377 }
8d08fdba 6378
b8bca6f2 6379 if (found_tag == 0)
2df06032 6380 cp_error ("abstract declarator used as declaration");
b8bca6f2 6381 else if (found_tag > 1)
2986ae00 6382 pedwarn ("multiple types in one declaration");
8d08fdba
MS
6383 }
6384}
6385\f
6386/* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6387
6388tree
6389groktypename (typename)
6390 tree typename;
6391{
6392 if (TREE_CODE (typename) != TREE_LIST)
6393 return typename;
6394 return grokdeclarator (TREE_VALUE (typename),
6395 TREE_PURPOSE (typename),
c11b6f21 6396 TYPENAME, 0, NULL_TREE);
8d08fdba
MS
6397}
6398
6399/* Decode a declarator in an ordinary declaration or data definition.
6400 This is called as soon as the type information and variable name
6401 have been parsed, before parsing the initializer if any.
6402 Here we create the ..._DECL node, fill in its type,
6403 and put it on the list of decls for the current context.
6404 The ..._DECL node is returned as the value.
6405
6406 Exception: for arrays where the length is not specified,
82580166 6407 the type is left null, to be filled in by `cp_finish_decl'.
8d08fdba
MS
6408
6409 Function definitions do not come here; they go to start_function
6410 instead. However, external and forward declarations of functions
6411 do go through here. Structure field declarations are done by
6412 grokfield and not through here. */
6413
6414/* Set this to zero to debug not using the temporary obstack
6415 to parse initializers. */
6416int debug_temp_inits = 1;
6417
6418tree
a1774733 6419start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
8d08fdba
MS
6420 tree declarator, declspecs;
6421 int initialized;
a1774733 6422 tree attributes, prefix_attributes;
8d08fdba
MS
6423{
6424 register tree decl;
6425 register tree type, tem;
6426 tree context;
6427 extern int have_extern_spec;
6428 extern int used_extern_spec;
6429
5566b478
MS
6430#if 0
6431 /* See code below that used this. */
8d08fdba 6432 int init_written = initialized;
5566b478 6433#endif
8d08fdba 6434
e92cc029 6435 /* This should only be done once on the top most decl. */
8d08fdba
MS
6436 if (have_extern_spec && !used_extern_spec)
6437 {
a28e3c7f
MS
6438 declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6439 declspecs);
8d08fdba
MS
6440 used_extern_spec = 1;
6441 }
6442
c11b6f21 6443 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
f30432d7 6444 NULL_TREE);
a1774733 6445 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
8d08fdba
MS
6446 return NULL_TREE;
6447
6448 type = TREE_TYPE (decl);
6449
6450 /* Don't lose if destructors must be executed at file-level. */
5156628f 6451 if (! processing_template_decl && TREE_STATIC (decl)
ec255269 6452 && TYPE_NEEDS_DESTRUCTOR (complete_type (type))
8d08fdba
MS
6453 && !TREE_PERMANENT (decl))
6454 {
6455 push_obstacks (&permanent_obstack, &permanent_obstack);
6456 decl = copy_node (decl);
6457 if (TREE_CODE (type) == ARRAY_TYPE)
6458 {
6459 tree itype = TYPE_DOMAIN (type);
6460 if (itype && ! TREE_PERMANENT (itype))
6461 {
6462 itype = build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype)));
6463 type = build_cplus_array_type (TREE_TYPE (type), itype);
6464 TREE_TYPE (decl) = type;
6465 }
6466 }
6467 pop_obstacks ();
6468 }
6469
8d08fdba
MS
6470 context
6471 = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
6472 ? DECL_CLASS_CONTEXT (decl)
6473 : DECL_CONTEXT (decl);
6474
9a68c51f
JM
6475 if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6476 && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6477 {
6478 /* When parsing the initializer, lookup should use the object's
6479 namespace. */
6480 push_decl_namespace (context);
6481 }
6482
2c73f9f5
ML
6483 /* We are only interested in class contexts, later. */
6484 if (context && TREE_CODE (context) == NAMESPACE_DECL)
6485 context = NULL_TREE;
6486
8d08fdba
MS
6487 if (initialized)
6488 /* Is it valid for this decl to have an initializer at all?
6489 If not, set INITIALIZED to zero, which will indirectly
82580166 6490 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
8d08fdba
MS
6491 switch (TREE_CODE (decl))
6492 {
6493 case TYPE_DECL:
6494 /* typedef foo = bar means give foo the same type as bar.
82580166 6495 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
8d08fdba
MS
6496 Any other case of an initialization in a TYPE_DECL is an error. */
6497 if (pedantic || list_length (declspecs) > 1)
6498 {
6499 cp_error ("typedef `%D' is initialized", decl);
6500 initialized = 0;
6501 }
6502 break;
6503
6504 case FUNCTION_DECL:
6505 cp_error ("function `%#D' is initialized like a variable", decl);
6506 initialized = 0;
6507 break;
6508
6509 default:
5156628f 6510 if (! processing_template_decl)
8d08fdba 6511 {
bd6dd845 6512 if (type != error_mark_node)
5156628f 6513 {
bd6dd845
MS
6514 if (TYPE_SIZE (type) != NULL_TREE
6515 && ! TREE_CONSTANT (TYPE_SIZE (type)))
6516 {
6517 cp_error
6518 ("variable-sized object `%D' may not be initialized",
6519 decl);
6520 initialized = 0;
6521 }
5156628f 6522
bd6dd845
MS
6523 if (TREE_CODE (type) == ARRAY_TYPE
6524 && TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6525 {
6526 cp_error
6527 ("elements of array `%#D' have incomplete type", decl);
6528 initialized = 0;
6529 }
5156628f 6530 }
8d08fdba
MS
6531 }
6532 }
6533
8d08fdba
MS
6534 if (initialized)
6535 {
a9aedbc2 6536 if (! toplevel_bindings_p ()
8d08fdba
MS
6537 && DECL_EXTERNAL (decl))
6538 cp_warning ("declaration of `%#D' has `extern' and is initialized",
6539 decl);
6540 DECL_EXTERNAL (decl) = 0;
5566b478 6541 if (toplevel_bindings_p ())
8d08fdba
MS
6542 TREE_STATIC (decl) = 1;
6543
6544 /* Tell `pushdecl' this is an initialized decl
6545 even though we don't yet have the initializer expression.
82580166 6546 Also tell `cp_finish_decl' it may store the real initializer. */
8d08fdba
MS
6547 DECL_INITIAL (decl) = error_mark_node;
6548 }
6549
5566b478 6550 if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
5b605f68
MS
6551 {
6552 if (TREE_CODE (decl) == VAR_DECL)
6553 {
6554 tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
6555 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
6556 cp_error ("`%#D' is not a static member of `%#T'", decl, context);
e349ee73
MS
6557 else
6558 {
6559 if (DECL_CONTEXT (field) != context)
f2d773a2
JM
6560 {
6561 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6562 DECL_CONTEXT (field), DECL_NAME (decl),
6563 context, DECL_NAME (decl));
6564 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
6565 }
75650646
MM
6566 /* Static data member are tricky; an in-class initialization
6567 still doesn't provide a definition, so the in-class
6568 declaration will have DECL_EXTERNAL set, but will have an
6569 initialization. Thus, duplicate_decls won't warn
6570 about this situation, and so we check here. */
6571 if (DECL_INITIAL (decl) && DECL_INITIAL (field))
6572 cp_error ("duplicate initialization of %D", decl);
e349ee73
MS
6573 if (duplicate_decls (decl, field))
6574 decl = field;
6575 }
5b605f68 6576 }
f30432d7
MS
6577 else
6578 {
5566b478 6579 tree field = check_classfn (context, decl);
f30432d7
MS
6580 if (field && duplicate_decls (decl, field))
6581 decl = field;
6582 }
6583
6584 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
dff3e828
BK
6585 DECL_IN_AGGR_P (decl) = 0;
6586 if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
6587 || CLASSTYPE_USE_TEMPLATE (context))
f30432d7
MS
6588 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
6589
b7698cf0 6590 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
f30432d7
MS
6591 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6592 decl);
6593
5b605f68
MS
6594 pushclass (context, 2);
6595 }
6596
a1774733
BK
6597 /* Set attributes here so if duplicate decl, will have proper attributes. */
6598 cplus_decl_attributes (decl, attributes, prefix_attributes);
6599
8d08fdba
MS
6600 /* Add this decl to the current binding level, but not if it
6601 comes from another scope, e.g. a static member variable.
6602 TEM may equal DECL or it may be a previous decl of the same name. */
5b605f68 6603
51bcf661
JM
6604 if ((TREE_CODE (decl) != PARM_DECL && DECL_CONTEXT (decl) != NULL_TREE
6605 /* Definitions of namespace members outside their namespace are
6606 possible. */
6607 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
2c73f9f5 6608 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
75650646
MM
6609 || TREE_CODE (type) == LANG_TYPE
6610 /* The declaration of template specializations does not affect
6611 the functions available for overload resolution, so we do not
6612 call pushdecl. */
e1467ff2 6613 || (TREE_CODE (decl) == FUNCTION_DECL
75650646 6614 && DECL_TEMPLATE_SPECIALIZATION (decl)))
8d08fdba
MS
6615 tem = decl;
6616 else
8926095f 6617 tem = pushdecl (decl);
2ee887f2 6618
5156628f 6619 if (processing_template_decl)
5566b478
MS
6620 {
6621 if (! current_function_decl)
3ac3d9ea 6622 tem = push_template_decl (tem);
5566b478 6623 else if (minimal_parse_mode)
b5effa19 6624 DECL_VINDEX (tem)
5566b478
MS
6625 = build_min_nt (DECL_STMT, copy_to_permanent (declarator),
6626 copy_to_permanent (declspecs),
c11b6f21 6627 NULL_TREE);
5566b478
MS
6628 }
6629
6630
2ee887f2 6631#if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
a3203465 6632 /* Tell the back-end to use or not use .common as appropriate. If we say
a50f0918
MS
6633 -fconserve-space, we want this to save .data space, at the expense of
6634 wrong semantics. If we say -fno-conserve-space, we want this to
6635 produce errors about redefs; to do this we force variables into the
6636 data segment. */
a3203465 6637 DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
2ee887f2 6638#endif
8d08fdba 6639
5156628f 6640 if (! processing_template_decl)
5566b478 6641 start_decl_1 (tem);
8d08fdba 6642
5566b478
MS
6643 /* Corresponding pop_obstacks is done in `cp_finish_decl'. */
6644 push_obstacks_nochange ();
8d08fdba 6645
5566b478
MS
6646#if 0
6647 /* We have no way of knowing whether the initializer will need to be
6648 evaluated at run-time or not until we've parsed it, so let's just put
6649 it in the permanent obstack. (jason) */
8d08fdba
MS
6650 if (init_written
6651 && ! (TREE_CODE (tem) == PARM_DECL
6652 || (TREE_READONLY (tem)
6653 && (TREE_CODE (tem) == VAR_DECL
6654 || TREE_CODE (tem) == FIELD_DECL))))
6655 {
6656 /* When parsing and digesting the initializer,
6657 use temporary storage. Do this even if we will ignore the value. */
a9aedbc2 6658 if (toplevel_bindings_p () && debug_temp_inits)
8d08fdba 6659 {
5156628f 6660 if (processing_template_decl
5566b478 6661 || TYPE_NEEDS_CONSTRUCTING (type)
a28e3c7f 6662 || TREE_CODE (type) == REFERENCE_TYPE)
8d08fdba
MS
6663 /* In this case, the initializer must lay down in permanent
6664 storage, since it will be saved until `finish_file' is run. */
6665 ;
6666 else
6667 temporary_allocation ();
6668 }
6669 }
5566b478 6670#endif
8d08fdba 6671
8d08fdba
MS
6672 return tem;
6673}
6674
5566b478
MS
6675void
6676start_decl_1 (decl)
6677 tree decl;
8d08fdba 6678{
5566b478
MS
6679 tree type = TREE_TYPE (decl);
6680 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
8d08fdba 6681
5566b478
MS
6682 /* If this type of object needs a cleanup, and control may
6683 jump past it, make a new binding level so that it is cleaned
6684 up only when it is initialized first. */
6685 if (TYPE_NEEDS_DESTRUCTOR (type)
6686 && current_binding_level->more_cleanups_ok == 0)
6687 pushlevel_temporary (1);
6688
6689 if (initialized)
6690 /* Is it valid for this decl to have an initializer at all?
6691 If not, set INITIALIZED to zero, which will indirectly
6692 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
8d08fdba 6693 {
5566b478
MS
6694 /* Don't allow initializations for incomplete types except for
6695 arrays which might be completed by the initialization. */
6696 if (type == error_mark_node)
6697 ; /* Don't complain again. */
6698 else if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
6699 ; /* A complete type is ok. */
6700 else if (TREE_CODE (type) != ARRAY_TYPE)
8d08fdba 6701 {
5566b478
MS
6702 cp_error ("variable `%#D' has initializer but incomplete type",
6703 decl);
6704 initialized = 0;
25eb19ff 6705 type = TREE_TYPE (decl) = error_mark_node;
5566b478
MS
6706 }
6707 else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6708 {
6709 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
6710 cp_error ("elements of array `%#D' have incomplete type", decl);
6711 /* else we already gave an error in start_decl. */
6712 initialized = 0;
8d08fdba 6713 }
8d08fdba
MS
6714 }
6715
5566b478
MS
6716 if (!initialized
6717 && TREE_CODE (decl) != TYPE_DECL
6718 && TREE_CODE (decl) != TEMPLATE_DECL
6719 && IS_AGGR_TYPE (type) && ! DECL_EXTERNAL (decl))
8d08fdba 6720 {
5156628f 6721 if ((! processing_template_decl || ! uses_template_parms (type))
7fcdf4c2 6722 && TYPE_SIZE (complete_type (type)) == NULL_TREE)
5566b478
MS
6723 {
6724 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6725 decl);
6726 /* Change the type so that assemble_variable will give
6727 DECL an rtl we can live with: (mem (const_int 0)). */
25eb19ff 6728 type = TREE_TYPE (decl) = error_mark_node;
5566b478
MS
6729 }
6730 else
6731 {
6732 /* If any base type in the hierarchy of TYPE needs a constructor,
6733 then we set initialized to 1. This way any nodes which are
6734 created for the purposes of initializing this aggregate
6735 will live as long as it does. This is necessary for global
6736 aggregates which do not have their initializers processed until
6737 the end of the file. */
6738 initialized = TYPE_NEEDS_CONSTRUCTING (type);
6739 }
6740 }
6741
6742#if 0
6743 /* We don't do this yet for GNU C++. */
6744 /* For a local variable, define the RTL now. */
6745 if (! toplevel_bindings_p ()
6746 /* But not if this is a duplicate decl
6747 and we preserved the rtl from the previous one
6748 (which may or may not happen). */
6749 && DECL_RTL (tem) == NULL_RTX)
6750 {
6751 if (TYPE_SIZE (TREE_TYPE (tem)) != NULL_TREE)
6752 expand_decl (tem);
6753 else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
6754 && DECL_INITIAL (tem) != NULL_TREE)
6755 expand_decl (tem);
6756 }
6757#endif
6758
6759 if (! initialized)
6760 DECL_INITIAL (decl) = NULL_TREE;
6761}
6762
6763/* Handle initialization of references.
38e01259 6764 These three arguments are from `cp_finish_decl', and have the
e92cc029
MS
6765 same meaning here that they do there.
6766
6767 Quotes on semantics can be found in ARM 8.4.3. */
6768
5566b478 6769static void
a703fb38 6770grok_reference_init (decl, type, init)
5566b478 6771 tree decl, type, init;
5566b478
MS
6772{
6773 tree tmp;
6774
6775 if (init == NULL_TREE)
6776 {
6777 if ((DECL_LANG_SPECIFIC (decl) == 0
6778 || DECL_IN_AGGR_P (decl) == 0)
6779 && ! DECL_THIS_EXTERN (decl))
6780 {
6781 cp_error ("`%D' declared as reference but not initialized", decl);
6782 if (TREE_CODE (decl) == VAR_DECL)
6783 SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
6784 }
6785 return;
6786 }
6787
6788 if (init == error_mark_node)
6789 return;
6790
6791 if (TREE_CODE (type) == REFERENCE_TYPE
6792 && TREE_CODE (init) == CONSTRUCTOR)
6793 {
6794 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
8d08fdba
MS
6795 return;
6796 }
6797
ec255269
MS
6798 if (TREE_TYPE (init) && TREE_CODE (TREE_TYPE (init)) == UNKNOWN_TYPE)
6799 /* decay_conversion is probably wrong for references to functions. */
6800 init = decay_conversion (instantiate_type (TREE_TYPE (type), init, 1));
6801
8d08fdba
MS
6802 if (TREE_CODE (init) == TREE_LIST)
6803 init = build_compound_expr (init);
8d08fdba 6804
8ccc31eb
MS
6805 if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
6806 init = convert_from_reference (init);
6807
8d08fdba
MS
6808 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
6809 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
6810 {
a3203465 6811 /* Note: default conversion is only called in very special cases. */
8d08fdba
MS
6812 init = default_conversion (init);
6813 }
6814
a3203465 6815 tmp = convert_to_reference
9a3b49ac
MS
6816 (type, init, CONV_IMPLICIT,
6817 LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
8d08fdba 6818
a3203465
MS
6819 if (tmp == error_mark_node)
6820 goto fail;
6821 else if (tmp != NULL_TREE)
8d08fdba 6822 {
a3203465 6823 init = tmp;
4c7bdca6 6824 DECL_INITIAL (decl) = save_expr (init);
8d08fdba 6825 }
a3203465 6826 else
8d08fdba 6827 {
a3203465
MS
6828 cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
6829 goto fail;
8d08fdba 6830 }
8d08fdba 6831
8d08fdba
MS
6832 /* ?? Can this be optimized in some cases to
6833 hand back the DECL_INITIAL slot?? */
6834 if (TYPE_SIZE (TREE_TYPE (type)))
6835 {
6836 init = convert_from_reference (decl);
6837 if (TREE_PERMANENT (decl))
6838 init = copy_to_permanent (init);
6839 SET_DECL_REFERENCE_SLOT (decl, init);
6840 }
6841
6842 if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
6843 {
6844 expand_static_init (decl, DECL_INITIAL (decl));
6845 DECL_INITIAL (decl) = NULL_TREE;
6846 }
6847 return;
6848
6849 fail:
6850 if (TREE_CODE (decl) == VAR_DECL)
6851 SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
6852 return;
6853}
6854
6060a796
MS
6855/* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6856 mucking with forces it does not comprehend (i.e. initialization with a
6857 constructor). If we are at global scope and won't go into COMMON, fill
6858 it in with a dummy CONSTRUCTOR to force the variable into .data;
6859 otherwise we can use error_mark_node. */
6860
28cbf42c
MS
6861static tree
6862obscure_complex_init (decl, init)
6863 tree decl, init;
6060a796 6864{
28cbf42c
MS
6865 if (! flag_no_inline && TREE_STATIC (decl))
6866 {
6867 if (extract_init (decl, init))
6868 return NULL_TREE;
6869 }
6870
2ee887f2 6871#if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
a9aedbc2 6872 if (toplevel_bindings_p () && ! DECL_COMMON (decl))
6060a796
MS
6873 DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
6874 NULL_TREE);
6875 else
2ee887f2 6876#endif
6060a796 6877 DECL_INITIAL (decl) = error_mark_node;
28cbf42c
MS
6878
6879 return init;
6060a796
MS
6880}
6881
8d08fdba
MS
6882/* Finish processing of a declaration;
6883 install its line number and initial value.
6884 If the length of an array type is not known before,
6885 it must be determined now, from the initial value, or it is an error.
6886
6887 Call `pop_obstacks' iff NEED_POP is nonzero.
6888
82580166 6889 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
8d08fdba
MS
6890 for aggregates that have constructors alive on the permanent obstack,
6891 so that the global initializing functions can be written at the end.
6892
6893 INIT0 holds the value of an initializer that should be allowed to escape
6894 the normal rules.
6895
6060a796
MS
6896 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
6897 if the (init) syntax was used.
6898
8d08fdba 6899 For functions that take default parameters, DECL points to its
82580166 6900 "maximal" instantiation. `cp_finish_decl' must then also declared its
8d08fdba
MS
6901 subsequently lower and lower forms of instantiation, checking for
6902 ambiguity as it goes. This can be sped up later. */
6903
6904void
82580166 6905cp_finish_decl (decl, init, asmspec_tree, need_pop, flags)
8d08fdba
MS
6906 tree decl, init;
6907 tree asmspec_tree;
6908 int need_pop;
6060a796 6909 int flags;
8d08fdba
MS
6910{
6911 register tree type;
a703fb38 6912 tree cleanup = NULL_TREE, ttype = NULL_TREE;
8d08fdba
MS
6913 int was_incomplete;
6914 int temporary = allocation_temporary_p ();
6915 char *asmspec = NULL;
6916 int was_readonly = 0;
0c4b14c4 6917 int already_used = 0;
8d08fdba
MS
6918
6919 /* If this is 0, then we did not change obstacks. */
6920 if (! decl)
6921 {
6922 if (init)
6923 error ("assignment (not initialization) in declaration");
6924 return;
6925 }
6926
a4443a08 6927 /* If a name was specified, get the string. */
8d08fdba 6928 if (asmspec_tree)
8d08fdba 6929 asmspec = TREE_STRING_POINTER (asmspec_tree);
8d08fdba 6930
2c73f9f5
ML
6931 if (init && TREE_CODE (init) == NAMESPACE_DECL)
6932 {
6933 cp_error ("Cannot initialize `%D' to namespace `%D'",
6934 decl, init);
6935 init = NULL_TREE;
6936 }
6937
9a68c51f
JM
6938 if (TREE_CODE (decl) == VAR_DECL
6939 && DECL_CONTEXT (decl)
6940 && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
6941 && DECL_CONTEXT (decl) != current_namespace
6942 && init)
6943 {
6944 /* Leave the namespace of the object. */
6945 pop_decl_namespace ();
6946 }
6947
8d08fdba
MS
6948 /* If the type of the thing we are declaring either has
6949 a constructor, or has a virtual function table pointer,
6950 AND its initialization was accepted by `start_decl',
6951 then we stayed on the permanent obstack through the
6952 declaration, otherwise, changed obstacks as GCC would. */
6953
6954 type = TREE_TYPE (decl);
6955
f376e137 6956 if (type == error_mark_node)
eac293a1 6957 {
a9aedbc2 6958 if (toplevel_bindings_p () && temporary)
eac293a1
MS
6959 end_temporary_allocation ();
6960
6961 return;
6962 }
f376e137 6963
5156628f 6964 if (processing_template_decl)
5566b478
MS
6965 {
6966 if (init && DECL_INITIAL (decl))
6967 DECL_INITIAL (decl) = init;
faf5394a 6968 if (minimal_parse_mode && ! DECL_ARTIFICIAL (decl))
5566b478
MS
6969 {
6970 tree stmt = DECL_VINDEX (decl);
e1467ff2 6971 /* If the decl is declaring a member of a local class (in a
8857f91e
MM
6972 template function), the DECL_VINDEX will either be NULL,
6973 or it will be an actual virtual function index, not a
6974 DECL_STMT. */
6975 if (stmt != NULL_TREE && TREE_CODE (stmt) == DECL_STMT)
75650646
MM
6976 {
6977 DECL_VINDEX (decl) = NULL_TREE;
6978 TREE_OPERAND (stmt, 2) = copy_to_permanent (init);
6979 add_tree (stmt);
6980 }
5566b478 6981 }
8d08fdba 6982
5566b478
MS
6983 goto finish_end0;
6984 }
8d08fdba
MS
6985 /* Take care of TYPE_DECLs up front. */
6986 if (TREE_CODE (decl) == TYPE_DECL)
6987 {
6988 if (init && DECL_INITIAL (decl))
6989 {
6990 /* typedef foo = bar; store the type of bar as the type of foo. */
6991 TREE_TYPE (decl) = type = TREE_TYPE (init);
6992 DECL_INITIAL (decl) = init = NULL_TREE;
6993 }
a0a33927
MS
6994 if (type != error_mark_node
6995 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8d08fdba
MS
6996 {
6997 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
6998 cp_warning ("shadowing previous type declaration of `%#D'", decl);
6999 set_identifier_type_value (DECL_NAME (decl), type);
7000 CLASSTYPE_GOT_SEMICOLON (type) = 1;
7001 }
7002 GNU_xref_decl (current_function_decl, decl);
cffa8729
MS
7003
7004 /* If we have installed this as the canonical typedef for this
7005 type, and that type has not been defined yet, delay emitting
956d6950 7006 the debug information for it, as we will emit it later. */
d2e5ee5c 7007 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
cffa8729
MS
7008 && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
7009 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7010
8d08fdba 7011 rest_of_decl_compilation (decl, NULL_PTR,
5566b478 7012 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8d08fdba
MS
7013 goto finish_end;
7014 }
8d08fdba
MS
7015 if (TREE_CODE (decl) != FUNCTION_DECL)
7016 {
7017 ttype = target_type (type);
8d08fdba
MS
7018 }
7019
7020 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7021 && TYPE_NEEDS_CONSTRUCTING (type))
7022 {
7023
7024 /* Currently, GNU C++ puts constants in text space, making them
7025 impossible to initialize. In the future, one would hope for
7026 an operating system which understood the difference between
7027 initialization and the running of a program. */
7028 was_readonly = 1;
7029 TREE_READONLY (decl) = 0;
7030 }
7031
7032 if (TREE_CODE (decl) == FIELD_DECL)
7033 {
7034 if (init && init != error_mark_node)
7035 my_friendly_assert (TREE_PERMANENT (init), 147);
7036
7037 if (asmspec)
7038 {
7039 /* This must override the asm specifier which was placed
6060a796 7040 by grokclassfn. Lay this out fresh. */
8d08fdba
MS
7041 DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7042 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7043 make_decl_rtl (decl, asmspec, 0);
7044 }
7045 }
7046 /* If `start_decl' didn't like having an initialization, ignore it now. */
7047 else if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7048 init = NULL_TREE;
7049 else if (DECL_EXTERNAL (decl))
7050 ;
7051 else if (TREE_CODE (type) == REFERENCE_TYPE
7052 || (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE_REFERENCE (type)))
7053 {
f376e137
MS
7054 if (TREE_STATIC (decl))
7055 make_decl_rtl (decl, NULL_PTR,
a9aedbc2 7056 toplevel_bindings_p ()
f376e137 7057 || pseudo_global_level_p ());
a703fb38 7058 grok_reference_init (decl, type, init);
8d08fdba
MS
7059 init = NULL_TREE;
7060 }
7061
7062 GNU_xref_decl (current_function_decl, decl);
7063
a0a33927 7064 if (TREE_CODE (decl) == FIELD_DECL)
8d08fdba
MS
7065 ;
7066 else if (TREE_CODE (decl) == CONST_DECL)
7067 {
7068 my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7069
7070 DECL_INITIAL (decl) = init;
7071
7072 /* This will keep us from needing to worry about our obstacks. */
7073 my_friendly_assert (init != NULL_TREE, 149);
7074 init = NULL_TREE;
7075 }
7076 else if (init)
7077 {
7078 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7079 {
7080 if (TREE_CODE (type) == ARRAY_TYPE)
7081 init = digest_init (type, init, (tree *) 0);
a3203465 7082 else if (TREE_CODE (init) == CONSTRUCTOR)
8d08fdba 7083 {
f30432d7 7084 if (TYPE_NON_AGGREGATE_CLASS (type))
8d08fdba 7085 {
a28e3c7f
MS
7086 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7087 decl);
8d08fdba
MS
7088 init = error_mark_node;
7089 }
7090 else
7091 goto dont_use_constructor;
7092 }
8d08fdba
MS
7093 }
7094 else
7095 {
7096 dont_use_constructor:
7097 if (TREE_CODE (init) != TREE_VEC)
7098 init = store_init_value (decl, init);
8d08fdba 7099 }
28cbf42c
MS
7100
7101 if (init)
7102 /* We must hide the initializer so that expand_decl
7103 won't try to do something it does not understand. */
7104 init = obscure_complex_init (decl, init);
8d08fdba 7105 }
a0a33927
MS
7106 else if (DECL_EXTERNAL (decl))
7107 ;
8d08fdba
MS
7108 else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
7109 && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7110 {
7111 tree ctype = type;
7112 while (TREE_CODE (ctype) == ARRAY_TYPE)
7113 ctype = TREE_TYPE (ctype);
7114 if (! TYPE_NEEDS_CONSTRUCTING (ctype))
7115 {
7116 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype))
7117 cp_error ("structure `%D' with uninitialized const members", decl);
7118 if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype))
a28e3c7f
MS
7119 cp_error ("structure `%D' with uninitialized reference members",
7120 decl);
8d08fdba
MS
7121 }
7122
7123 if (TREE_CODE (decl) == VAR_DECL
7124 && !DECL_INITIAL (decl)
7125 && !TYPE_NEEDS_CONSTRUCTING (type)
7126 && (TYPE_READONLY (type) || TREE_READONLY (decl)))
7127 cp_error ("uninitialized const `%D'", decl);
7128
6060a796
MS
7129 if (TYPE_SIZE (type) != NULL_TREE
7130 && TYPE_NEEDS_CONSTRUCTING (type))
28cbf42c 7131 init = obscure_complex_init (decl, NULL_TREE);
8d08fdba
MS
7132 }
7133 else if (TREE_CODE (decl) == VAR_DECL
7134 && TREE_CODE (type) != REFERENCE_TYPE
7135 && (TYPE_READONLY (type) || TREE_READONLY (decl)))
7136 {
7137 /* ``Unless explicitly declared extern, a const object does not have
7138 external linkage and must be initialized. ($8.4; $12.1)'' ARM 7.1.6
7139 However, if it's `const int foo = 1; const int foo;', don't complain
7140 about the second decl, since it does have an initializer before.
7141 We deliberately don't complain about arrays, because they're
7142 supposed to be initialized by a constructor. */
7143 if (! DECL_INITIAL (decl)
7144 && TREE_CODE (type) != ARRAY_TYPE
7145 && (!pedantic || !current_class_type))
7146 cp_error ("uninitialized const `%#D'", decl);
7147 }
7148
7149 /* For top-level declaration, the initial value was read in
7150 the temporary obstack. MAXINDEX, rtl, etc. to be made below
7151 must go in the permanent obstack; but don't discard the
7152 temporary data yet. */
7153
a9aedbc2 7154 if (toplevel_bindings_p () && temporary)
8d08fdba
MS
7155 end_temporary_allocation ();
7156
7157 /* Deduce size of array from initialization, if not already known. */
7158
7159 if (TREE_CODE (type) == ARRAY_TYPE
7160 && TYPE_DOMAIN (type) == NULL_TREE
7161 && TREE_CODE (decl) != TYPE_DECL)
7162 {
7163 int do_default
7164 = (TREE_STATIC (decl)
7165 /* Even if pedantic, an external linkage array
7166 may have incomplete type at first. */
7167 ? pedantic && ! DECL_EXTERNAL (decl)
7168 : !DECL_EXTERNAL (decl));
7169 tree initializer = init ? init : DECL_INITIAL (decl);
7170 int failure = complete_array_type (type, initializer, do_default);
7171
7172 if (failure == 1)
7173 cp_error ("initializer fails to determine size of `%D'", decl);
7174
7175 if (failure == 2)
7176 {
7177 if (do_default)
7178 cp_error ("array size missing in `%D'", decl);
7179 /* If a `static' var's size isn't known, make it extern as
7180 well as static, so it does not get allocated. If it's not
7181 `static', then don't mark it extern; finish_incomplete_decl
7182 will give it a default size and it will get allocated. */
7183 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7184 DECL_EXTERNAL (decl) = 1;
7185 }
7186
7187 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7188 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7189 integer_zero_node))
7190 cp_error ("zero-size array `%D'", decl);
7191
7192 layout_decl (decl, 0);
7193 }
7194
7195 if (TREE_CODE (decl) == VAR_DECL)
7196 {
7197 if (DECL_SIZE (decl) == NULL_TREE
ec255269 7198 && TYPE_SIZE (complete_type (TREE_TYPE (decl))) != NULL_TREE)
8d08fdba
MS
7199 layout_decl (decl, 0);
7200
7201 if (TREE_STATIC (decl) && DECL_SIZE (decl) == NULL_TREE)
7202 {
7203 /* A static variable with an incomplete type:
7204 that is an error if it is initialized.
7205 Otherwise, let it through, but if it is not `extern'
7206 then it may cause an error message later. */
7207 if (DECL_INITIAL (decl) != NULL_TREE)
7208 cp_error ("storage size of `%D' isn't known", decl);
7209 init = NULL_TREE;
7210 }
7211 else if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7212 {
7213 /* An automatic variable with an incomplete type: that is an error.
7214 Don't talk about array types here, since we took care of that
7215 message in grokdeclarator. */
7216 cp_error ("storage size of `%D' isn't known", decl);
7217 TREE_TYPE (decl) = error_mark_node;
7218 }
7219 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7220 /* Let debugger know it should output info for this type. */
7221 note_debug_info_needed (ttype);
7222
6eb3bb27 7223 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
d2e5ee5c
MS
7224 note_debug_info_needed (DECL_CONTEXT (decl));
7225
8d08fdba
MS
7226 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7227 && DECL_SIZE (decl) != NULL_TREE
7228 && ! TREE_CONSTANT (DECL_SIZE (decl)))
7229 {
7230 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7231 constant_expression_warning (DECL_SIZE (decl));
7232 else
7233 cp_error ("storage size of `%D' isn't constant", decl);
7234 }
7235
c91a56d2
MS
7236 if (! DECL_EXTERNAL (decl) && TYPE_NEEDS_DESTRUCTOR (type)
7237 /* Cleanups for static variables are handled by `finish_file'. */
7238 && ! TREE_STATIC (decl))
8d08fdba
MS
7239 {
7240 int yes = suspend_momentary ();
2ee887f2 7241 cleanup = maybe_build_cleanup (decl);
8d08fdba
MS
7242 resume_momentary (yes);
7243 }
7244 }
7245 /* PARM_DECLs get cleanups, too. */
7246 else if (TREE_CODE (decl) == PARM_DECL && TYPE_NEEDS_DESTRUCTOR (type))
7247 {
7248 if (temporary)
7249 end_temporary_allocation ();
7250 cleanup = maybe_build_cleanup (decl);
7251 if (temporary)
7252 resume_temporary_allocation ();
7253 }
7254
7255 /* Output the assembler code and/or RTL code for variables and functions,
7256 unless the type is an undefined structure or union.
7257 If not, it will get done when the type is completed. */
7258
5566b478
MS
7259 was_incomplete = (DECL_SIZE (decl) == NULL_TREE);
7260
8d08fdba
MS
7261 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7262 || TREE_CODE (decl) == RESULT_DECL)
7263 {
7264 /* ??? FIXME: What about nested classes? */
e1467ff2 7265 int toplev = toplevel_bindings_p () || pseudo_global_level_p ();
8d08fdba 7266 int was_temp
d22c8596 7267 = (TREE_STATIC (decl) && TYPE_NEEDS_DESTRUCTOR (type)
8d08fdba
MS
7268 && allocation_temporary_p ());
7269
7270 if (was_temp)
7271 end_temporary_allocation ();
7272
aeb302bb
JM
7273 /* Extern inline function static data has external linkage.
7274 Instead of trying to deal with that, we disable inlining of
7275 such functions. The ASM_WRITTEN check is to avoid hitting this
7276 for __FUNCTION__. */
42976354
BK
7277 if (TREE_CODE (decl) == VAR_DECL
7278 && TREE_STATIC (decl)
aeb302bb 7279 && ! TREE_ASM_WRITTEN (decl)
42976354
BK
7280 && current_function_decl
7281 && DECL_CONTEXT (decl) == current_function_decl
7282 && DECL_THIS_INLINE (current_function_decl)
893de33c 7283 && TREE_PUBLIC (current_function_decl))
42976354 7284 {
aeb302bb
JM
7285 current_function_cannot_inline
7286 = "function with static variable cannot be inline";
42976354
BK
7287 }
7288
77be6f82
JM
7289 else if (TREE_CODE (decl) == VAR_DECL
7290 && DECL_LANG_SPECIFIC (decl)
7291 && DECL_COMDAT (decl))
7292 {
7293 /* Dynamically initialized vars go into common. */
7294 if (DECL_INITIAL (decl) == NULL_TREE
7295 || DECL_INITIAL (decl) == error_mark_node)
7296 DECL_COMMON (decl) = 1;
7297 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7298 {
7299 DECL_COMMON (decl) = 1;
7300 DECL_INITIAL (decl) = error_mark_node;
7301 }
7302 else
7303 {
7304 /* Statically initialized vars are weak or comdat, if
7305 supported. */
7306 if (flag_weak)
7307 make_decl_one_only (decl);
7308 else
be343556 7309 {
2c73f9f5 7310 /* We can't do anything useful; leave vars for explicit
be343556
JM
7311 instantiation. */
7312 DECL_EXTERNAL (decl) = 1;
7313 DECL_NOT_REALLY_EXTERN (decl) = 0;
7314 }
77be6f82
JM
7315 }
7316 }
7317
8d08fdba
MS
7318 if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
7319 make_decl_rtl (decl, NULL_PTR, toplev);
7320 else if (TREE_CODE (decl) == VAR_DECL
7321 && TREE_READONLY (decl)
7322 && DECL_INITIAL (decl) != NULL_TREE
7323 && DECL_INITIAL (decl) != error_mark_node
a3203465 7324 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
8d08fdba
MS
7325 {
7326 DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7327
7328 if (asmspec)
7329 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7330
7331 if (! toplev
7332 && TREE_STATIC (decl)
7333 && ! TREE_SIDE_EFFECTS (decl)
7334 && ! TREE_PUBLIC (decl)
7335 && ! DECL_EXTERNAL (decl)
7336 && ! TYPE_NEEDS_DESTRUCTOR (type)
7337 && DECL_MODE (decl) != BLKmode)
7338 {
7339 /* If this variable is really a constant, then fill its DECL_RTL
7340 slot with something which won't take up storage.
7341 If something later should take its address, we can always give
7342 it legitimate RTL at that time. */
7343 DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
7344 store_expr (DECL_INITIAL (decl), DECL_RTL (decl), 0);
7345 TREE_ASM_WRITTEN (decl) = 1;
7346 }
a0a33927 7347 else if (toplev && ! TREE_PUBLIC (decl))
8d08fdba 7348 {
8d08fdba 7349 /* If this is a static const, change its apparent linkage
db5ae43f 7350 if it belongs to a #pragma interface. */
a0a33927 7351 if (!interface_unknown)
8d08fdba
MS
7352 {
7353 TREE_PUBLIC (decl) = 1;
7354 DECL_EXTERNAL (decl) = interface_only;
7355 }
7356 make_decl_rtl (decl, asmspec, toplev);
7357 }
7358 else
5566b478 7359 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8d08fdba
MS
7360 }
7361 else if (TREE_CODE (decl) == VAR_DECL
7362 && DECL_LANG_SPECIFIC (decl)
7363 && DECL_IN_AGGR_P (decl))
7364 {
7365 if (TREE_STATIC (decl))
7366 {
7367 if (init == NULL_TREE
7368#ifdef DEFAULT_STATIC_DEFS
7369 /* If this code is dead, then users must
7370 explicitly declare static member variables
7371 outside the class def'n as well. */
7372 && TYPE_NEEDS_CONSTRUCTING (type)
7373#endif
7374 )
7375 {
7376 DECL_EXTERNAL (decl) = 1;
7377 make_decl_rtl (decl, asmspec, 1);
7378 }
7379 else
5566b478 7380 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8d08fdba
MS
7381 }
7382 else
7383 /* Just a constant field. Should not need any rtl. */
7384 goto finish_end0;
7385 }
7386 else
5566b478 7387 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8d08fdba
MS
7388
7389 if (was_temp)
7390 resume_temporary_allocation ();
7391
7392 if (type != error_mark_node
7393 && TYPE_LANG_SPECIFIC (type)
7394 && CLASSTYPE_ABSTRACT_VIRTUALS (type))
7395 abstract_virtuals_error (decl, type);
7396 else if ((TREE_CODE (type) == FUNCTION_TYPE
7397 || TREE_CODE (type) == METHOD_TYPE)
7398 && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
7399 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type)))
7400 abstract_virtuals_error (decl, TREE_TYPE (type));
7401
7402 if (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE (type))
7403 signature_error (decl, type);
7404 else if ((TREE_CODE (type) == FUNCTION_TYPE
7405 || TREE_CODE (type) == METHOD_TYPE)
7406 && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
7407 && IS_SIGNATURE (TREE_TYPE (type)))
7408 signature_error (decl, TREE_TYPE (type));
7409
7410 if (TREE_CODE (decl) == FUNCTION_DECL)
faae18ab 7411 ;
67d743fe
MS
7412 else if (DECL_EXTERNAL (decl)
7413 && ! (DECL_LANG_SPECIFIC (decl)
7414 && DECL_NOT_REALLY_EXTERN (decl)))
5566b478
MS
7415 {
7416 if (init)
7417 DECL_INITIAL (decl) = init;
7418 }
8d08fdba
MS
7419 else if (TREE_STATIC (decl) && type != error_mark_node)
7420 {
7421 /* Cleanups for static variables are handled by `finish_file'. */
f30432d7
MS
7422 if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7423 || TYPE_NEEDS_DESTRUCTOR (type))
8d08fdba 7424 expand_static_init (decl, init);
8d08fdba
MS
7425 }
7426 else if (! toplev)
7427 {
7428 /* This is a declared decl which must live until the
7429 end of the binding contour. It may need a cleanup. */
7430
7431 /* Recompute the RTL of a local array now
7432 if it used to be an incomplete type. */
7433 if (was_incomplete && ! TREE_STATIC (decl))
7434 {
7435 /* If we used it already as memory, it must stay in memory. */
7436 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7437 /* If it's still incomplete now, no init will save it. */
7438 if (DECL_SIZE (decl) == NULL_TREE)
7439 DECL_INITIAL (decl) = NULL_TREE;
7440 expand_decl (decl);
7441 }
7442 else if (! TREE_ASM_WRITTEN (decl)
7443 && (TYPE_SIZE (type) != NULL_TREE
7444 || TREE_CODE (type) == ARRAY_TYPE))
7445 {
7446 /* Do this here, because we did not expand this decl's
7447 rtl in start_decl. */
7448 if (DECL_RTL (decl) == NULL_RTX)
7449 expand_decl (decl);
7450 else if (cleanup)
7451 {
8d2733ca
MS
7452 /* XXX: Why don't we use decl here? */
7453 /* Ans: Because it was already expanded? */
e349ee73 7454 if (! expand_decl_cleanup (NULL_TREE, cleanup))
8d2733ca
MS
7455 cp_error ("parser lost in parsing declaration of `%D'",
7456 decl);
8d08fdba
MS
7457 /* Cleanup used up here. */
7458 cleanup = NULL_TREE;
7459 }
7460 }
7461
2ee887f2
MS
7462 if (current_binding_level->is_for_scope)
7463 {
7464 struct binding_level *outer = current_binding_level->level_chain;
7465
7466 /* Check to see if the same name is already bound at
7467 the outer level, either because it was directly declared,
7468 or because a dead for-decl got preserved. In either case,
d22c8596 7469 the code would not have been valid under the ARM
2ee887f2
MS
7470 scope rules, so clear is_for_scope for the
7471 current_binding_level.
7472
7473 Otherwise, we need to preserve the temp slot for decl
e92cc029 7474 to last into the outer binding level. */
2ee887f2
MS
7475
7476 int handling_dead_for_vars = 0;
7477 tree link = outer->names;
7478 for (; ; link = TREE_CHAIN (link))
7479 {
7480 if (link == NULL && handling_dead_for_vars == 0)
7481 {
7482 link = outer->dead_vars_from_for;
7483 handling_dead_for_vars = 1;
7484 }
7485 if (link == NULL)
7486 {
cffa8729 7487 if (DECL_IN_MEMORY_P (decl))
2ee887f2
MS
7488 preserve_temp_slots (DECL_RTL (decl));
7489 break;
7490 }
7491 if (DECL_NAME (link) == DECL_NAME (decl))
7492 {
7493 if (handling_dead_for_vars)
7494 {
7495 tree shadowing
7496 = purpose_member (DECL_NAME (decl),
7497 current_binding_level->shadowed);
7498 if (shadowing && TREE_VALUE (shadowing) == link)
7499 TREE_VALUE (shadowing)
7500 = DECL_SHADOWED_FOR_VAR (link);
7501 }
7502 current_binding_level->is_for_scope = 0;
7503 break;
7504 }
7505 }
7506 }
7507
eb66be0e 7508 expand_start_target_temps ();
72b7eeff 7509
8d08fdba
MS
7510 if (DECL_SIZE (decl) && type != error_mark_node)
7511 {
7512 /* Compute and store the initial value. */
7513 expand_decl_init (decl);
0c4b14c4 7514 already_used = TREE_USED (decl) || TREE_USED (type);
8d08fdba
MS
7515
7516 if (init || TYPE_NEEDS_CONSTRUCTING (type))
7517 {
a28e3c7f
MS
7518 emit_line_note (DECL_SOURCE_FILE (decl),
7519 DECL_SOURCE_LINE (decl));
6060a796 7520 expand_aggr_init (decl, init, 0, flags);
8d08fdba
MS
7521 }
7522
00595019
MS
7523 /* Set this to 0 so we can tell whether an aggregate which
7524 was initialized was ever used. Don't do this if it has a
7525 destructor, so we don't complain about the 'resource
7526 allocation is initialization' idiom. */
249555b0 7527 /* Now set attribute((unused)) on types so decls of
38e01259 7528 that type will be marked used. (see TREE_USED, above.)
249555b0
BK
7529 This avoids the warning problems this particular code
7530 tried to work around. */
0c4b14c4 7531
be99da77 7532 if (TYPE_NEEDS_CONSTRUCTING (type)
0c4b14c4 7533 && ! already_used
be99da77
MS
7534 && cleanup == NULL_TREE
7535 && DECL_NAME (decl))
8d08fdba 7536 TREE_USED (decl) = 0;
0c4b14c4
JM
7537
7538 if (already_used)
7539 TREE_USED (decl) = 1;
934c6b13 7540 }
eb66be0e 7541
934c6b13 7542 /* Cleanup any temporaries needed for the initial value. */
eb66be0e 7543 expand_end_target_temps ();
8d08fdba 7544
934c6b13
MS
7545 if (DECL_SIZE (decl) && type != error_mark_node)
7546 {
8d08fdba
MS
7547 /* Store the cleanup, if there was one. */
7548 if (cleanup)
7549 {
e349ee73 7550 if (! expand_decl_cleanup (decl, cleanup))
a28e3c7f
MS
7551 cp_error ("parser lost in parsing declaration of `%D'",
7552 decl);
8d08fdba
MS
7553 }
7554 }
7555 }
7556 finish_end0:
7557
7558 /* Undo call to `pushclass' that was done in `start_decl'
7559 due to initialization of qualified member variable.
7560 I.e., Foo::x = 10; */
7561 {
f30432d7 7562 tree context = DECL_REAL_CONTEXT (decl);
8d08fdba
MS
7563 if (context
7564 && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
7565 && (TREE_CODE (decl) == VAR_DECL
7566 /* We also have a pushclass done that we need to undo here
7567 if we're at top level and declare a method. */
5566b478
MS
7568 || TREE_CODE (decl) == FUNCTION_DECL)
7569 /* If size hasn't been set, we're still defining it,
7570 and therefore inside the class body; don't pop
7571 the binding level.. */
7572 && TYPE_SIZE (context) != NULL_TREE
7573 && context == current_class_type)
8d08fdba
MS
7574 popclass (1);
7575 }
7576 }
7577
7578 finish_end:
7579
39211cd5
MS
7580 /* If requested, warn about definitions of large data objects. */
7581
7582 if (warn_larger_than
5156628f 7583 && ! processing_template_decl
39211cd5
MS
7584 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
7585 && !DECL_EXTERNAL (decl))
7586 {
7587 register tree decl_size = DECL_SIZE (decl);
7588
7589 if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
7590 {
7591 unsigned units = TREE_INT_CST_LOW (decl_size) / BITS_PER_UNIT;
7592
7593 if (units > larger_than_size)
7594 warning_with_decl (decl, "size of `%s' is %u bytes", units);
7595 }
7596 }
7597
8d08fdba
MS
7598 if (need_pop)
7599 {
7600 /* Resume permanent allocation, if not within a function. */
7601 /* The corresponding push_obstacks_nochange is in start_decl,
7602 start_method, groktypename, and in grokfield. */
7603 pop_obstacks ();
7604 }
7605
7606 if (was_readonly)
7607 TREE_READONLY (decl) = 1;
8d08fdba
MS
7608}
7609
82580166 7610/* This is here for a midend callback from c-common.c */
e92cc029 7611
82580166
MS
7612void
7613finish_decl (decl, init, asmspec_tree)
7614 tree decl, init;
7615 tree asmspec_tree;
7616{
7617 cp_finish_decl (decl, init, asmspec_tree, 1, 0);
7618}
7619
8d08fdba
MS
7620void
7621expand_static_init (decl, init)
7622 tree decl;
7623 tree init;
7624{
7625 tree oldstatic = value_member (decl, static_aggregates);
a4443a08 7626
8d08fdba
MS
7627 if (oldstatic)
7628 {
7629 if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
7630 cp_error ("multiple initializations given for `%D'", decl);
7631 }
a9aedbc2 7632 else if (! toplevel_bindings_p () && ! pseudo_global_level_p ())
8d08fdba
MS
7633 {
7634 /* Emit code to perform this initialization but once. */
7635 tree temp;
7636
e92cc029 7637 /* Remember this information until end of file. */
8d08fdba
MS
7638 push_obstacks (&permanent_obstack, &permanent_obstack);
7639
7640 /* Emit code to perform this initialization but once. */
7641 temp = get_temp_name (integer_type_node, 1);
7642 rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
7643 expand_start_cond (build_binary_op (EQ_EXPR, temp,
7644 integer_zero_node, 1), 0);
eb66be0e 7645 expand_start_target_temps ();
72b7eeff 7646
8d08fdba 7647 expand_assignment (temp, integer_one_node, 0, 0);
28cbf42c 7648 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
f30432d7 7649 || (init && TREE_CODE (init) == TREE_LIST))
8d08fdba 7650 {
6060a796 7651 expand_aggr_init (decl, init, 0, 0);
8d08fdba
MS
7652 do_pending_stack_adjust ();
7653 }
f30432d7 7654 else if (init)
8d08fdba 7655 expand_assignment (decl, init, 0, 0);
f30432d7 7656
a4443a08 7657 /* Cleanup any temporaries needed for the initial value. */
eb66be0e 7658 expand_end_target_temps ();
72b7eeff
MS
7659
7660 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
7661 {
7662 tree cleanup, fcall;
7663 static tree Atexit = 0;
7664 if (Atexit == 0)
7665 {
7666 tree atexit_fndecl, PFV, pfvlist;
e92cc029 7667 /* Remember this information until end of file. */
72b7eeff
MS
7668 push_obstacks (&permanent_obstack, &permanent_obstack);
7669 PFV = build_pointer_type (build_function_type
7670 (void_type_node, void_list_node));
7671
7672 pfvlist = tree_cons (NULL_TREE, PFV, void_list_node);
7673
7674 push_lang_context (lang_name_c);
beb53fb8
JM
7675 atexit_fndecl
7676 = builtin_function ("atexit",
7677 build_function_type (void_type_node,
7678 pfvlist),
7679 NOT_BUILT_IN, NULL_PTR);
be99da77 7680 assemble_external (atexit_fndecl);
72b7eeff
MS
7681 Atexit = default_conversion (atexit_fndecl);
7682 pop_lang_context ();
7683 pop_obstacks ();
7684 }
7685
7686 cleanup = start_anon_func ();
7687 expand_expr_stmt (build_cleanup (decl));
7688 end_anon_func ();
7689 mark_addressable (cleanup);
7690 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
e66d884e 7691 fcall = build_function_call (Atexit, expr_tree_cons (NULL_TREE, cleanup, NULL_TREE));
72b7eeff
MS
7692 expand_expr_stmt (fcall);
7693 }
7694
8d08fdba
MS
7695 expand_end_cond ();
7696 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
7697 {
7698 static_aggregates = perm_tree_cons (temp, decl, static_aggregates);
7699 TREE_STATIC (static_aggregates) = 1;
7700 }
7701
e92cc029 7702 /* Resume old (possibly temporary) allocation. */
8d08fdba
MS
7703 pop_obstacks ();
7704 }
7705 else
7706 {
7707 /* This code takes into account memory allocation
7708 policy of `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING
7709 does not hold for this object, then we must make permanent
7710 the storage currently in the temporary obstack. */
7711 if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
7712 preserve_initializer ();
7713 static_aggregates = perm_tree_cons (init, decl, static_aggregates);
7714 }
7715}
7716\f
7717/* Make TYPE a complete type based on INITIAL_VALUE.
7718 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7719 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
7720
7721int
7722complete_array_type (type, initial_value, do_default)
7723 tree type, initial_value;
7724 int do_default;
7725{
7726 register tree maxindex = NULL_TREE;
7727 int value = 0;
7728
7729 if (initial_value)
7730 {
7731 /* Note MAXINDEX is really the maximum index,
7732 one less than the size. */
7733 if (TREE_CODE (initial_value) == STRING_CST)
e1cd6e56
MS
7734 {
7735 int eltsize
7736 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7737 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
7738 / eltsize) - 1, 0);
7739 }
8d08fdba
MS
7740 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7741 {
e1cd6e56
MS
7742 tree elts = CONSTRUCTOR_ELTS (initial_value);
7743 maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
7744 for (; elts; elts = TREE_CHAIN (elts))
7745 {
7746 if (TREE_PURPOSE (elts))
7747 maxindex = TREE_PURPOSE (elts);
7748 else
7749 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
7750 }
7751 maxindex = copy_node (maxindex);
8d08fdba
MS
7752 }
7753 else
7754 {
7755 /* Make an error message unless that happened already. */
7756 if (initial_value != error_mark_node)
7757 value = 1;
7758
7759 /* Prevent further error messages. */
7760 maxindex = build_int_2 (0, 0);
7761 }
7762 }
7763
7764 if (!maxindex)
7765 {
7766 if (do_default)
7767 maxindex = build_int_2 (0, 0);
7768 value = 2;
7769 }
7770
7771 if (maxindex)
7772 {
51c184be
MS
7773 tree itype;
7774
8d08fdba 7775 TYPE_DOMAIN (type) = build_index_type (maxindex);
dff6b454 7776 if (! TREE_TYPE (maxindex))
8d08fdba 7777 TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
51c184be
MS
7778 if (initial_value)
7779 itype = TREE_TYPE (initial_value);
7780 else
7781 itype = NULL;
7782 if (itype && !TYPE_DOMAIN (itype))
7783 TYPE_DOMAIN (itype) = TYPE_DOMAIN (type);
dff6b454
RK
7784 /* The type of the main variant should never be used for arrays
7785 of different sizes. It should only ever be completed with the
7786 size of the array. */
7787 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
7788 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = TYPE_DOMAIN (type);
8d08fdba
MS
7789 }
7790
7791 /* Lay out the type now that we can get the real answer. */
7792
7793 layout_type (type);
7794
7795 return value;
7796}
7797\f
7798/* Return zero if something is declared to be a member of type
7799 CTYPE when in the context of CUR_TYPE. STRING is the error
7800 message to print in that case. Otherwise, quietly return 1. */
e92cc029 7801
8d08fdba
MS
7802static int
7803member_function_or_else (ctype, cur_type, string)
7804 tree ctype, cur_type;
7805 char *string;
7806{
7807 if (ctype && ctype != cur_type)
7808 {
7809 error (string, TYPE_NAME_STRING (ctype));
7810 return 0;
7811 }
7812 return 1;
7813}
7814\f
7815/* Subroutine of `grokdeclarator'. */
7816
7817/* Generate errors possibly applicable for a given set of specifiers.
7818 This is for ARM $7.1.2. */
e92cc029 7819
8d08fdba
MS
7820static void
7821bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
7822 tree object;
7823 char *type;
7824 int virtualp, quals, friendp, raises, inlinep;
7825{
7826 if (virtualp)
7827 cp_error ("`%D' declared as a `virtual' %s", object, type);
7828 if (inlinep)
7829 cp_error ("`%D' declared as an `inline' %s", object, type);
7830 if (quals)
a28e3c7f
MS
7831 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
7832 object, type);
8d08fdba
MS
7833 if (friendp)
7834 cp_error_at ("invalid friend declaration", object);
7835 if (raises)
6060a796 7836 cp_error_at ("invalid exception specifications", object);
8d08fdba
MS
7837}
7838
7839/* CTYPE is class type, or null if non-class.
7840 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7841 or METHOD_TYPE.
7842 DECLARATOR is the function's name.
7843 VIRTUALP is truthvalue of whether the function is virtual or not.
7844 FLAGS are to be passed through to `grokclassfn'.
7845 QUALS are qualifiers indicating whether the function is `const'
7846 or `volatile'.
7847 RAISES is a list of exceptions that this function can raise.
7848 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7849 not look, and -1 if we should not call `grokclassfn' at all. */
e92cc029 7850
8d08fdba 7851static tree
386b8a85
JM
7852grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
7853 raises, attrlist, check, friendp, publicp, inlinep, funcdef_flag,
2c73f9f5 7854 template_count, in_namespace)
8d08fdba
MS
7855 tree ctype, type;
7856 tree declarator;
386b8a85 7857 tree orig_declarator;
8d08fdba
MS
7858 int virtualp;
7859 enum overload_flags flags;
f30432d7 7860 tree quals, raises, attrlist;
386b8a85 7861 int check, friendp, publicp, inlinep, funcdef_flag, template_count;
2c73f9f5 7862 tree in_namespace;
8d08fdba
MS
7863{
7864 tree cname, decl;
7865 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
42976354 7866 tree t;
8d08fdba
MS
7867
7868 if (ctype)
7869 cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
7870 ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
7871 else
7872 cname = NULL_TREE;
7873
7874 if (raises)
7875 {
f30432d7 7876 type = build_exception_variant (type, raises);
8d08fdba 7877 }
c11b6f21 7878
8d08fdba 7879 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
2c73f9f5 7880 /* Propagate volatile out from type to decl. */
8d08fdba 7881 if (TYPE_VOLATILE (type))
893de33c 7882 TREE_THIS_VOLATILE (decl) = 1;
8d08fdba 7883
2c73f9f5
ML
7884 /* This decl is not from the current namespace. */
7885 if (in_namespace)
7886 set_decl_namespace (decl, in_namespace);
7887
8d08fdba
MS
7888 /* Should probably propagate const out from type to decl I bet (mrs). */
7889 if (staticp)
7890 {
7891 DECL_STATIC_FUNCTION_P (decl) = 1;
7892 DECL_CONTEXT (decl) = ctype;
8d08fdba
MS
7893 }
7894
e76a2646
MS
7895 if (ctype)
7896 DECL_CLASS_CONTEXT (decl) = ctype;
7897
35680744 7898 if (ctype == NULL_TREE && MAIN_NAME_P (declarator))
faae18ab
MS
7899 {
7900 if (inlinep)
7901 error ("cannot declare `main' to be inline");
7902 else if (! publicp)
7903 error ("cannot declare `main' to be static");
7904 inlinep = 0;
7905 publicp = 1;
7906 }
50a6dbd7
JM
7907
7908 /* Members of anonymous types have no linkage; make them internal. */
7909 if (ctype && ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype)))
7910 publicp = 0;
7911
7912 if (publicp)
7913 {
7914 /* [basic.link]: A name with no linkage (notably, the name of a class
7915 or enumeration declared in a local scope) shall not be used to
7916 declare an entity with linkage.
7917
7918 Only check this for public decls for now. */
7919 t = no_linkage_check (TREE_TYPE (decl));
7920 if (t)
7921 {
7922 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
cce2be43 7923 cp_pedwarn ("non-local function `%#D' uses anonymous type", decl);
50a6dbd7 7924 else
cce2be43
JM
7925 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
7926 decl, t);
50a6dbd7
JM
7927 }
7928 }
7929
893de33c 7930 TREE_PUBLIC (decl) = publicp;
faae18ab 7931 if (! publicp)
893de33c
JM
7932 {
7933 DECL_INTERFACE_KNOWN (decl) = 1;
7934 DECL_NOT_REALLY_EXTERN (decl) = 1;
7935 }
faae18ab
MS
7936
7937 if (inlinep)
7938 DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8d08fdba
MS
7939
7940 DECL_EXTERNAL (decl) = 1;
7941 if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
7942 {
7943 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
7944 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
7945 quals = NULL_TREE;
7946 }
7947
7948 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
7949 grok_op_properties (decl, virtualp, check < 0);
7950
e76a2646 7951 if (ctype && hack_decl_function_context (decl))
893de33c 7952 DECL_NO_STATIC_CHAIN (decl) = 1;
e76a2646 7953
42976354
BK
7954 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
7955 if (TREE_PURPOSE (t)
7956 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
7957 {
7958 add_defarg_fn (decl);
7959 break;
7960 }
7961
f9d94ea4
JM
7962 if (friendp
7963 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
7964 {
7965 if (funcdef_flag)
7966 cp_error
7967 ("defining explicit specialization `%D' in friend declaration",
7968 orig_declarator);
7969 else
7970 {
7971 /* A friend declaration of the form friend void f<>(). Record
7972 the information in the TEMPLATE_ID_EXPR. */
7973 SET_DECL_IMPLICIT_INSTANTIATION (decl);
7974 DECL_TEMPLATE_INFO (decl)
7975 = perm_tree_cons (TREE_OPERAND (orig_declarator, 0),
7976 TREE_OPERAND (orig_declarator, 1),
7977 NULL_TREE);
7978 }
f84b4be9 7979 }
386b8a85 7980
75650646 7981 /* Caller will do the rest of this. */
8d08fdba
MS
7982 if (check < 0)
7983 return decl;
7984
5566b478 7985 if (check && funcdef_flag)
d2e5ee5c 7986 DECL_INITIAL (decl) = error_mark_node;
5566b478 7987
8d08fdba
MS
7988 if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
7989 {
7990 tree tmp;
7991 /* Just handle constructors here. We could do this
7992 inside the following if stmt, but I think
7993 that the code is more legible by breaking this
7994 case out. See comments below for what each of
7995 the following calls is supposed to do. */
7996 DECL_CONSTRUCTOR_P (decl) = 1;
7997
7998 grokclassfn (ctype, declarator, decl, flags, quals);
386b8a85 7999
e1467ff2
MM
8000 decl = check_explicit_specialization (orig_declarator, decl,
8001 template_count,
f84b4be9
JM
8002 2 * (funcdef_flag != 0) +
8003 4 * (friendp != 0));
75650646 8004
eff71ab0
PB
8005 if ((! TYPE_FOR_JAVA (ctype) || check_java_method (ctype, decl))
8006 && check)
5566b478
MS
8007 {
8008 tmp = check_classfn (ctype, decl);
98c1c668
JM
8009
8010 if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8011 tmp = DECL_TEMPLATE_RESULT(tmp);
8012
e349ee73
MS
8013 if (tmp && DECL_ARTIFICIAL (tmp))
8014 cp_error ("definition of implicitly-declared `%D'", tmp);
5566b478
MS
8015 if (tmp && duplicate_decls (decl, tmp))
8016 return tmp;
8017 }
a0a33927
MS
8018 if (! grok_ctor_properties (ctype, decl))
8019 return NULL_TREE;
8020
7177d104 8021 if (check == 0 && ! current_function_decl)
8d08fdba 8022 {
2c73f9f5 8023 /* Assembler names live in the global namespace. */
37c46b43 8024 tmp = IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl));
8d08fdba 8025 if (tmp == NULL_TREE)
2c73f9f5 8026 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl), decl);
8d08fdba
MS
8027 else if (TREE_CODE (tmp) != TREE_CODE (decl))
8028 cp_error ("inconsistent declarations for `%D'", decl);
8029 else
8030 {
8031 duplicate_decls (decl, tmp);
8032 decl = tmp;
8d08fdba
MS
8033 }
8034 make_decl_rtl (decl, NULL_PTR, 1);
8035 }
8036 }
8037 else
8038 {
8039 tree tmp;
8040
8041 /* Function gets the ugly name, field gets the nice one.
8042 This call may change the type of the function (because
8043 of default parameters)! */
8044 if (ctype != NULL_TREE)
8045 grokclassfn (ctype, cname, decl, flags, quals);
8046
e1467ff2
MM
8047 decl = check_explicit_specialization (orig_declarator, decl,
8048 template_count,
f84b4be9
JM
8049 2 * (funcdef_flag != 0) +
8050 4 * (friendp != 0));
eff71ab0
PB
8051 if (ctype != NULL_TREE
8052 && (! TYPE_FOR_JAVA (ctype) || check_java_method (ctype, decl))
8053 && check)
5566b478
MS
8054 {
8055 tmp = check_classfn (ctype, decl);
98c1c668
JM
8056
8057 if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
75650646 8058 tmp = DECL_TEMPLATE_RESULT (tmp);
98c1c668 8059
5566b478
MS
8060 if (tmp && DECL_STATIC_FUNCTION_P (tmp)
8061 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8062 {
8063 /* Remove the `this' parm added by grokclassfn.
8064 XXX Isn't this done in start_function, too? */
8065 revert_static_member_fn (&decl, NULL, NULL);
8066 last_function_parms = TREE_CHAIN (last_function_parms);
8067 }
e349ee73
MS
8068 if (tmp && DECL_ARTIFICIAL (tmp))
8069 cp_error ("definition of implicitly-declared `%D'", tmp);
7834ab39
MS
8070 if (tmp)
8071 {
8072 if (!duplicate_decls (decl, tmp))
8073 my_friendly_abort (892);
8074 return tmp;
8075 }
5566b478 8076 }
8d08fdba
MS
8077
8078 if (ctype == NULL_TREE || check)
8079 return decl;
8080
7177d104
MS
8081 /* Now install the declaration of this function so that others may
8082 find it (esp. its DECL_FRIENDLIST). Don't do this for local class
8083 methods, though. */
8084 if (! current_function_decl)
8d08fdba 8085 {
75650646 8086 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
7177d104 8087 {
75650646
MM
8088 /* We don't do this for specializations since the
8089 equivalent checks will be done later. Also, at this
8090 point the DECL_ASSEMBLER_NAME is not yet fully
8091 accurate. */
8092
8093 /* FIXME: this should only need to look at
8094 IDENTIFIER_GLOBAL_VALUE. */
8095 tmp = lookup_name (DECL_ASSEMBLER_NAME (decl), 0);
8096 if (tmp == NULL_TREE)
2c73f9f5 8097 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl), decl);
75650646
MM
8098 else if (TREE_CODE (tmp) != TREE_CODE (decl))
8099 cp_error ("inconsistent declarations for `%D'", decl);
8100 else
8101 {
8102 duplicate_decls (decl, tmp);
8103 decl = tmp;
75650646 8104 }
7177d104 8105 }
f30432d7
MS
8106
8107 if (attrlist)
8108 cplus_decl_attributes (decl, TREE_PURPOSE (attrlist),
8109 TREE_VALUE (attrlist));
7177d104 8110 make_decl_rtl (decl, NULL_PTR, 1);
8d08fdba 8111 }
8d08fdba
MS
8112 if (virtualp)
8113 {
2ee887f2 8114 DECL_VIRTUAL_P (decl) = 1;
8d08fdba
MS
8115 if (DECL_VINDEX (decl) == NULL_TREE)
8116 DECL_VINDEX (decl) = error_mark_node;
8117 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8d08fdba
MS
8118 }
8119 }
8120 return decl;
8121}
8122
8123static tree
2c73f9f5 8124grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8d08fdba
MS
8125 tree type;
8126 tree declarator;
d2e5ee5c 8127 RID_BIT_TYPE *specbits_in;
8d08fdba 8128 int initialized;
a9aedbc2 8129 int constp;
2c73f9f5 8130 tree in_namespace;
8d08fdba
MS
8131{
8132 tree decl;
f7da6097
MS
8133 RID_BIT_TYPE specbits;
8134
8135 specbits = *specbits_in;
8d08fdba
MS
8136
8137 if (TREE_CODE (type) == OFFSET_TYPE)
8138 {
8139 /* If you declare a static member so that it
8140 can be initialized, the code will reach here. */
5b605f68
MS
8141 tree basetype = TYPE_OFFSET_BASETYPE (type);
8142 type = TREE_TYPE (type);
8143 decl = build_lang_field_decl (VAR_DECL, declarator, type);
8144 DECL_CONTEXT (decl) = basetype;
8145 DECL_CLASS_CONTEXT (decl) = basetype;
f376e137 8146 DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8d08fdba
MS
8147 }
8148 else
30394414 8149 {
2c73f9f5 8150 tree context = in_namespace ? in_namespace : current_namespace;
30394414 8151 decl = build_decl (VAR_DECL, declarator, complete_type (type));
03d82991
JM
8152 if (context != global_namespace && namespace_bindings_p ()
8153 && current_lang_name != lang_name_c)
2c73f9f5 8154 DECL_ASSEMBLER_NAME (decl) = build_static_name (context,
30394414
JM
8155 declarator);
8156 }
6060a796 8157
2c73f9f5
ML
8158 if (in_namespace)
8159 set_decl_namespace (decl, in_namespace);
8160
8d08fdba
MS
8161 if (RIDBIT_SETP (RID_EXTERN, specbits))
8162 {
8163 DECL_THIS_EXTERN (decl) = 1;
8164 DECL_EXTERNAL (decl) = !initialized;
8165 }
8166
8167 /* In class context, static means one per class,
8168 public access, and static storage. */
2b9dc906 8169 if (DECL_CLASS_SCOPE_P (decl))
8d08fdba
MS
8170 {
8171 TREE_PUBLIC (decl) = 1;
8172 TREE_STATIC (decl) = 1;
5b605f68 8173 DECL_EXTERNAL (decl) = 0;
8d08fdba
MS
8174 }
8175 /* At top level, either `static' or no s.c. makes a definition
8176 (perhaps tentative), and absence of `static' makes it public. */
a9aedbc2 8177 else if (toplevel_bindings_p ())
8d08fdba 8178 {
a9aedbc2 8179 TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9fffd093 8180 && (DECL_THIS_EXTERN (decl) || ! constp));
8d08fdba
MS
8181 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8182 }
8183 /* Not at top level, only `static' makes a static definition. */
8184 else
8185 {
8186 TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8187 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8188 }
50a6dbd7
JM
8189
8190 if (TREE_PUBLIC (decl))
8191 {
8192 /* [basic.link]: A name with no linkage (notably, the name of a class
8193 or enumeration declared in a local scope) shall not be used to
8194 declare an entity with linkage.
8195
8196 Only check this for public decls for now. */
8197 tree t = no_linkage_check (TREE_TYPE (decl));
8198 if (t)
8199 {
8200 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8201 /* Ignore for now; `enum { foo } e' is pretty common. */;
8202 else
8203 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8204 decl, t);
8205 }
8206 }
8207
8d08fdba
MS
8208 return decl;
8209}
8210
e92cc029 8211/* Create a canonical pointer to member function type. */
8d08fdba
MS
8212
8213tree
8214build_ptrmemfunc_type (type)
8215 tree type;
8216{
8217 tree fields[4];
8218 tree t;
8219 tree u;
8220
8221 /* If a canonical type already exists for this type, use it. We use
8222 this method instead of type_hash_canon, because it only does a
8223 simple equality check on the list of field members. */
8224
8225 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8226 return t;
8227
8228 push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
8229
8230 u = make_lang_type (UNION_TYPE);
f30432d7 8231 IS_AGGR_TYPE (u) = 0;
8d08fdba 8232 fields[0] = build_lang_field_decl (FIELD_DECL, pfn_identifier, type);
a28e3c7f
MS
8233 fields[1] = build_lang_field_decl (FIELD_DECL, delta2_identifier,
8234 delta_type_node);
8d08fdba
MS
8235 finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8236 TYPE_NAME (u) = NULL_TREE;
8237
8238 t = make_lang_type (RECORD_TYPE);
8239
2c73f9f5 8240 /* Let the front-end know this is a pointer to member function... */
db5ae43f 8241 TYPE_PTRMEMFUNC_FLAG (t) = 1;
2c73f9f5 8242 /* ... and not really an aggregate. */
f376e137 8243 IS_AGGR_TYPE (t) = 0;
8d08fdba 8244
a28e3c7f
MS
8245 fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
8246 delta_type_node);
8247 fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
8248 delta_type_node);
8d08fdba
MS
8249 fields[2] = build_lang_field_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
8250 finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
8251
8252 pop_obstacks ();
8253
8254 /* Zap out the name so that the back-end will give us the debugging
8255 information for this anonymous RECORD_TYPE. */
8256 TYPE_NAME (t) = NULL_TREE;
8257
8258 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8259
e92cc029 8260 /* Seems to be wanted. */
8d08fdba
MS
8261 CLASSTYPE_GOT_SEMICOLON (t) = 1;
8262 return t;
8263}
8264
8265/* Given declspecs and a declarator,
8266 determine the name and type of the object declared
8267 and construct a ..._DECL node for it.
8268 (In one case we can return a ..._TYPE node instead.
8269 For invalid input we sometimes return 0.)
8270
8271 DECLSPECS is a chain of tree_list nodes whose value fields
8272 are the storage classes and type specifiers.
8273
8274 DECL_CONTEXT says which syntactic context this declaration is in:
8275 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8276 FUNCDEF for a function definition. Like NORMAL but a few different
8277 error messages in each case. Return value may be zero meaning
8278 this definition is too screwy to try to parse.
8279 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8280 handle member functions (which have FIELD context).
8281 Return value may be zero meaning this definition is too screwy to
8282 try to parse.
8283 PARM for a parameter declaration (either within a function prototype
8284 or before a function body). Make a PARM_DECL, or return void_type_node.
db5ae43f 8285 CATCHPARM for a parameter declaration before a catch clause.
8d08fdba
MS
8286 TYPENAME if for a typename (in a cast or sizeof).
8287 Don't make a DECL node; just return the ..._TYPE node.
8288 FIELD for a struct or union field; make a FIELD_DECL.
8289 BITFIELD for a field with specified width.
8290 INITIALIZED is 1 if the decl has an initializer.
8291
8292 In the TYPENAME case, DECLARATOR is really an absolute declarator.
8293 It may also be so in the PARM case, for a prototype where the
8294 argument type is specified but not the name.
8295
8296 This function is where the complicated C meanings of `static'
8297 and `extern' are interpreted.
8298
8299 For C++, if there is any monkey business to do, the function which
8300 calls this one must do it, i.e., prepending instance variables,
8301 renaming overloaded function names, etc.
8302
8303 Note that for this C++, it is an error to define a method within a class
8304 which does not belong to that class.
8305
8306 Except in the case where SCOPE_REFs are implicitly known (such as
8307 methods within a class being redundantly qualified),
8308 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
8309 (class_name::decl_name). The caller must also deal with this.
8310
8311 If a constructor or destructor is seen, and the context is FIELD,
8312 then the type gains the attribute TREE_HAS_x. If such a declaration
8313 is erroneous, NULL_TREE is returned.
8314
8315 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
8316 function, these are the qualifiers to give to the `this' pointer.
8317
8318 May return void_type_node if the declarator turned out to be a friend.
8319 See grokfield for details. */
8320
8321enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
8322
8323tree
c11b6f21 8324grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
8d08fdba
MS
8325 tree declspecs;
8326 tree declarator;
8327 enum decl_context decl_context;
8328 int initialized;
c11b6f21 8329 tree attrlist;
8d08fdba
MS
8330{
8331 RID_BIT_TYPE specbits;
8332 int nclasses = 0;
8333 tree spec;
8334 tree type = NULL_TREE;
8335 int longlong = 0;
8336 int constp;
8337 int volatilep;
db5ae43f 8338 int virtualp, explicitp, friendp, inlinep, staticp;
8d08fdba
MS
8339 int explicit_int = 0;
8340 int explicit_char = 0;
37c46b43 8341 int defaulted_int = 0;
8d08fdba
MS
8342 int opaque_typedef = 0;
8343 tree typedef_decl = NULL_TREE;
8344 char *name;
8345 tree typedef_type = NULL_TREE;
8346 int funcdef_flag = 0;
8347 enum tree_code innermost_code = ERROR_MARK;
8348 int bitfield = 0;
6125f3be
DE
8349#if 0
8350 /* See the code below that used this. */
f6abb50a 8351 tree decl_machine_attr = NULL_TREE;
6125f3be 8352#endif
8d08fdba
MS
8353 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
8354 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
8355 tree init = NULL_TREE;
8356
8357 /* Keep track of what sort of function is being processed
8358 so that we can warn about default return values, or explicit
8359 return values which do not match prescribed defaults. */
8360 enum return_types return_type = return_normal;
8361
8362 tree dname = NULL_TREE;
8363 tree ctype = current_class_type;
8364 tree ctor_return_type = NULL_TREE;
8365 enum overload_flags flags = NO_SPECIAL;
8d08fdba 8366 tree quals = NULL_TREE;
c11b6f21 8367 tree raises = NULL_TREE;
386b8a85 8368 int template_count = 0;
2c73f9f5 8369 tree in_namespace = NULL_TREE;
8d08fdba
MS
8370
8371 RIDBIT_RESET_ALL (specbits);
8372 if (decl_context == FUNCDEF)
8373 funcdef_flag = 1, decl_context = NORMAL;
8374 else if (decl_context == MEMFUNCDEF)
8375 funcdef_flag = -1, decl_context = FIELD;
8376 else if (decl_context == BITFIELD)
8377 bitfield = 1, decl_context = FIELD;
8378
8d08fdba
MS
8379 /* Look inside a declarator for the name being declared
8380 and get it as a string, for an error message. */
8381 {
be99da77
MS
8382 tree *next = &declarator;
8383 register tree decl;
8d08fdba
MS
8384 name = NULL;
8385
be99da77
MS
8386 while (next && *next)
8387 {
8388 decl = *next;
8389 switch (TREE_CODE (decl))
8d08fdba 8390 {
be99da77
MS
8391 case COND_EXPR:
8392 ctype = NULL_TREE;
8393 next = &TREE_OPERAND (decl, 0);
8394 break;
8d08fdba 8395
2c73f9f5 8396 case BIT_NOT_EXPR: /* For C++ destructors! */
8d08fdba 8397 {
be99da77
MS
8398 tree name = TREE_OPERAND (decl, 0);
8399 tree rename = NULL_TREE;
8400
8401 my_friendly_assert (flags == NO_SPECIAL, 152);
8402 flags = DTOR_FLAG;
8403 return_type = return_dtor;
5566b478
MS
8404 if (TREE_CODE (name) == TYPE_DECL)
8405 TREE_OPERAND (decl, 0) = name = constructor_name (name);
be99da77
MS
8406 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
8407 if (ctype == NULL_TREE)
8408 {
8409 if (current_class_type == NULL_TREE)
8410 {
8411 error ("destructors must be member functions");
8412 flags = NO_SPECIAL;
8413 }
8414 else
8415 {
8416 tree t = constructor_name (current_class_name);
8417 if (t != name)
8418 rename = t;
8419 }
8420 }
8d08fdba 8421 else
be99da77
MS
8422 {
8423 tree t = constructor_name (ctype);
8424 if (t != name)
8425 rename = t;
8426 }
51c184be 8427
be99da77 8428 if (rename)
39211cd5 8429 {
5566b478
MS
8430 cp_error ("destructor `%T' must match class name `%T'",
8431 name, rename);
be99da77 8432 TREE_OPERAND (decl, 0) = rename;
39211cd5 8433 }
be99da77 8434 next = &name;
51c184be 8435 }
be99da77 8436 break;
8d08fdba 8437
be99da77 8438 case ADDR_EXPR: /* C++ reference declaration */
2c73f9f5 8439 /* Fall through. */
be99da77
MS
8440 case ARRAY_REF:
8441 case INDIRECT_REF:
8442 ctype = NULL_TREE;
8443 innermost_code = TREE_CODE (decl);
8444 next = &TREE_OPERAND (decl, 0);
8445 break;
8d08fdba 8446
be99da77
MS
8447 case CALL_EXPR:
8448 if (parmlist_is_exprlist (TREE_OPERAND (decl, 1)))
8d08fdba 8449 {
be99da77
MS
8450 /* This is actually a variable declaration using constructor
8451 syntax. We need to call start_decl and cp_finish_decl so we
8452 can get the variable initialized... */
8453
8454 *next = TREE_OPERAND (decl, 0);
8455 init = TREE_OPERAND (decl, 1);
8456
a1774733 8457 decl = start_decl (declarator, declspecs, 1, NULL_TREE, NULL_TREE);
249555b0
BK
8458 /* Look for __unused__ attribute */
8459 if (TREE_USED (TREE_TYPE (decl)))
8460 TREE_USED (decl) = 1;
be99da77
MS
8461 finish_decl (decl, init, NULL_TREE);
8462 return 0;
8d08fdba 8463 }
be99da77
MS
8464 innermost_code = TREE_CODE (decl);
8465 if (decl_context == FIELD && ctype == NULL_TREE)
8466 ctype = current_class_type;
45537677 8467 if (ctype
c11b6f21 8468 && TREE_OPERAND (decl, 0)
45537677
MS
8469 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
8470 && ((DECL_NAME (TREE_OPERAND (decl, 0))
8471 == constructor_name_full (ctype))
8472 || (DECL_NAME (TREE_OPERAND (decl, 0))
8473 == constructor_name (ctype)))))
be99da77
MS
8474 TREE_OPERAND (decl, 0) = constructor_name (ctype);
8475 next = &TREE_OPERAND (decl, 0);
8476 decl = *next;
8477 if (ctype != NULL_TREE
8478 && decl != NULL_TREE && flags != DTOR_FLAG
8479 && decl == constructor_name (ctype))
8d08fdba 8480 {
be99da77
MS
8481 return_type = return_ctor;
8482 ctor_return_type = ctype;
8d08fdba 8483 }
be99da77
MS
8484 ctype = NULL_TREE;
8485 break;
386b8a85
JM
8486
8487 case TEMPLATE_ID_EXPR:
8488 {
8489 tree fns = TREE_OPERAND (decl, 0);
8490
8491 if (TREE_CODE (fns) == LOOKUP_EXPR)
8492 fns = TREE_OPERAND (fns, 0);
8493
8494 if (TREE_CODE (fns) == IDENTIFIER_NODE)
8495 dname = fns;
f84b4be9 8496 else if (is_overloaded_fn (fns))
386b8a85
JM
8497 dname = DECL_NAME (get_first_fn (fns));
8498 else
f84b4be9 8499 my_friendly_abort (0);
386b8a85 8500 }
2c73f9f5 8501 /* Fall through. */
be99da77
MS
8502
8503 case IDENTIFIER_NODE:
386b8a85
JM
8504 if (TREE_CODE (decl) == IDENTIFIER_NODE)
8505 dname = decl;
8506
be99da77
MS
8507 next = 0;
8508
8509 if (is_rid (dname))
8d08fdba 8510 {
be99da77
MS
8511 cp_error ("declarator-id missing; using reserved word `%D'",
8512 dname);
8513 name = IDENTIFIER_POINTER (dname);
8d08fdba 8514 }
be99da77 8515 if (! IDENTIFIER_OPNAME_P (dname)
956d6950 8516 /* GNU/Linux headers use '__op'. Arrgh. */
a703fb38 8517 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
be99da77 8518 name = IDENTIFIER_POINTER (dname);
8d08fdba
MS
8519 else
8520 {
be99da77 8521 if (IDENTIFIER_TYPENAME_P (dname))
8d08fdba 8522 {
be99da77
MS
8523 my_friendly_assert (flags == NO_SPECIAL, 154);
8524 flags = TYPENAME_FLAG;
8525 ctor_return_type = TREE_TYPE (dname);
8526 return_type = return_conversion;
8d08fdba 8527 }
be99da77 8528 name = operator_name_string (dname);
8d08fdba 8529 }
be99da77 8530 break;
8d08fdba 8531
be99da77
MS
8532 /* C++ extension */
8533 case SCOPE_REF:
8534 {
8535 /* Perform error checking, and decide on a ctype. */
8536 tree cname = TREE_OPERAND (decl, 0);
8537 if (cname == NULL_TREE)
8538 ctype = NULL_TREE;
2c73f9f5
ML
8539 else if (TREE_CODE (cname) == NAMESPACE_DECL)
8540 {
8541 ctype = NULL_TREE;
8542 in_namespace = TREE_OPERAND (decl, 0);
8543 TREE_OPERAND (decl, 0) = NULL_TREE;
8544 }
be99da77
MS
8545 else if (! is_aggr_type (cname, 1))
8546 TREE_OPERAND (decl, 0) = NULL_TREE;
8547 /* Must test TREE_OPERAND (decl, 1), in case user gives
8548 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
8549 else if (TREE_OPERAND (decl, 1)
8550 && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
8551 ctype = cname;
73b0fce8
KL
8552 else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
8553 || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
5566b478
MS
8554 {
8555 cp_error ("`%T::%D' is not a valid declarator", cname,
8556 TREE_OPERAND (decl, 1));
8557 cp_error (" perhaps you want `typename %T::%D' to make it a type",
8558 cname, TREE_OPERAND (decl, 1));
8559 return void_type_node;
8560 }
be99da77
MS
8561 else if (ctype == NULL_TREE)
8562 ctype = cname;
8563 else if (TREE_COMPLEXITY (decl) == current_class_depth)
8564 TREE_OPERAND (decl, 0) = ctype;
8565 else
8566 {
8567 if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
8568 {
8569 cp_error ("type `%T' is not derived from type `%T'",
8570 cname, ctype);
8571 TREE_OPERAND (decl, 0) = NULL_TREE;
8572 }
8573 else
8574 ctype = cname;
8575 }
8576
c91a56d2
MS
8577 if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
8578 && ((DECL_NAME (TREE_OPERAND (decl, 1))
8579 == constructor_name_full (ctype))
8580 || (DECL_NAME (TREE_OPERAND (decl, 1))
8581 == constructor_name (ctype))))
be99da77
MS
8582 TREE_OPERAND (decl, 1) = constructor_name (ctype);
8583 next = &TREE_OPERAND (decl, 1);
8584 decl = *next;
8585 if (ctype)
8586 {
8587 if (TREE_CODE (decl) == IDENTIFIER_NODE
8588 && constructor_name (ctype) == decl)
8589 {
8590 return_type = return_ctor;
8591 ctor_return_type = ctype;
8592 }
8593 else if (TREE_CODE (decl) == BIT_NOT_EXPR
8594 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
8595 && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
8596 || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
8597 {
8598 return_type = return_dtor;
8599 ctor_return_type = ctype;
8600 flags = DTOR_FLAG;
8601 TREE_OPERAND (decl, 0) = constructor_name (ctype);
8602 next = &TREE_OPERAND (decl, 0);
8603 }
8604 }
8605 }
8606 break;
8607
8608 case ERROR_MARK:
8609 next = 0;
8610 break;
8611
45537677
MS
8612 case TYPE_DECL:
8613 /* Parse error puts this typespec where
8614 a declarator should go. */
8615 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
8616 if (TREE_TYPE (decl) == current_class_type)
8617 cp_error (" perhaps you want `%T' for a constructor",
8618 current_class_name);
8619 dname = DECL_NAME (decl);
8620 name = IDENTIFIER_POINTER (dname);
8621
e92cc029 8622 /* Avoid giving two errors for this. */
45537677
MS
8623 IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
8624
8625 declspecs = temp_tree_cons (NULL_TREE, integer_type_node,
8626 declspecs);
8627 *next = dname;
8628 next = 0;
8629 break;
8630
be99da77 8631 default:
be99da77
MS
8632 cp_compiler_error ("`%D' as declarator", decl);
8633 return 0; /* We used to do a 155 abort here. */
8d08fdba 8634 }
be99da77 8635 }
8d08fdba
MS
8636 if (name == NULL)
8637 name = "type name";
8638 }
8639
8640 /* A function definition's declarator must have the form of
8641 a function declarator. */
8642
8643 if (funcdef_flag && innermost_code != CALL_EXPR)
8644 return 0;
8645
e1cd6e56
MS
8646 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
8647 && innermost_code != CALL_EXPR
8648 && ! (ctype && declspecs == NULL_TREE))
8649 {
8650 cp_error ("declaration of `%D' as non-function", dname);
8651 return void_type_node;
8652 }
8653
8d08fdba
MS
8654 /* Anything declared one level down from the top level
8655 must be one of the parameters of a function
8656 (because the body is at least two levels down). */
8657
8658 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8659 by not allowing C++ class definitions to specify their parameters
8660 with xdecls (must be spec.d in the parmlist).
8661
8662 Since we now wait to push a class scope until we are sure that
8663 we are in a legitimate method context, we must set oldcname
a9aedbc2
MS
8664 explicitly (since current_class_name is not yet alive).
8665
8666 We also want to avoid calling this a PARM if it is in a namespace. */
8d08fdba 8667
5566b478
MS
8668 if (decl_context == NORMAL && ! namespace_bindings_p ()
8669 && ! pseudo_global_level_p ())
a9aedbc2
MS
8670 {
8671 struct binding_level *b = current_binding_level;
8672 current_binding_level = b->level_chain;
8673 if (current_binding_level != 0 && toplevel_bindings_p ())
8674 decl_context = PARM;
8675 current_binding_level = b;
8676 }
8d08fdba
MS
8677
8678 /* Look through the decl specs and record which ones appear.
8679 Some typespecs are defined as built-in typenames.
8680 Others, the ones that are modifiers of other types,
8681 are represented by bits in SPECBITS: set the bits for
8682 the modifiers that appear. Storage class keywords are also in SPECBITS.
8683
8684 If there is a typedef name or a type, store the type in TYPE.
8685 This includes builtin typedefs such as `int'.
8686
8687 Set EXPLICIT_INT if the type is `int' or `char' and did not
8688 come from a user typedef.
8689
8690 Set LONGLONG if `long' is mentioned twice.
8691
8692 For C++, constructors and destructors have their own fast treatment. */
8693
8694 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
8695 {
8696 register int i;
8697 register tree id;
8698
8699 /* Certain parse errors slip through. For example,
8700 `int class;' is not caught by the parser. Try
8701 weakly to recover here. */
8702 if (TREE_CODE (spec) != TREE_LIST)
8703 return 0;
8704
8705 id = TREE_VALUE (spec);
8706
8707 if (TREE_CODE (id) == IDENTIFIER_NODE)
8708 {
a3203465
MS
8709 if (id == ridpointers[(int) RID_INT]
8710 || id == ridpointers[(int) RID_CHAR]
8711 || id == ridpointers[(int) RID_BOOL]
8712 || id == ridpointers[(int) RID_WCHAR])
8d08fdba
MS
8713 {
8714 if (type)
8ccc31eb
MS
8715 {
8716 if (id == ridpointers[(int) RID_BOOL])
8717 error ("`bool' is now a keyword");
8718 else
8719 cp_error ("extraneous `%T' ignored", id);
8720 }
8d08fdba
MS
8721 else
8722 {
a3203465
MS
8723 if (id == ridpointers[(int) RID_INT])
8724 explicit_int = 1;
8725 else if (id == ridpointers[(int) RID_CHAR])
8726 explicit_char = 1;
8d08fdba
MS
8727 type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
8728 }
8729 goto found;
8730 }
e92cc029 8731 /* C++ aggregate types. */
8d08fdba
MS
8732 if (IDENTIFIER_HAS_TYPE_VALUE (id))
8733 {
8734 if (type)
8735 cp_error ("multiple declarations `%T' and `%T'", type, id);
8736 else
8737 type = IDENTIFIER_TYPE_VALUE (id);
8738 goto found;
8739 }
8740
f376e137 8741 for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
8d08fdba
MS
8742 {
8743 if (ridpointers[i] == id)
8744 {
8745 if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
8746 {
795add94 8747 if (pedantic && ! in_system_header && warn_long_long)
e1cd6e56 8748 pedwarn ("ANSI C++ does not support `long long'");
9a3b49ac 8749 if (longlong)
a0a33927 8750 error ("`long long long' is too long for GCC");
8d08fdba
MS
8751 else
8752 longlong = 1;
8753 }
8754 else if (RIDBIT_SETP (i, specbits))
a0a33927 8755 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
8d08fdba
MS
8756 RIDBIT_SET (i, specbits);
8757 goto found;
8758 }
8759 }
8760 }
e92cc029 8761 /* C++ aggregate types. */
73b0fce8 8762 else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
45537677
MS
8763 {
8764 if (type)
8765 cp_error ("multiple declarations `%T' and `%T'", type,
8766 TREE_TYPE (id));
8767 else
5566b478
MS
8768 {
8769 type = TREE_TYPE (id);
8770 TREE_VALUE (spec) = type;
8771 }
45537677
MS
8772 goto found;
8773 }
8d08fdba
MS
8774 if (type)
8775 error ("two or more data types in declaration of `%s'", name);
8776 else if (TREE_CODE (id) == IDENTIFIER_NODE)
8777 {
8778 register tree t = lookup_name (id, 1);
8779 if (!t || TREE_CODE (t) != TYPE_DECL)
8780 error ("`%s' fails to be a typedef or built in type",
8781 IDENTIFIER_POINTER (id));
8782 else
8783 {
8784 type = TREE_TYPE (t);
6125f3be
DE
8785#if 0
8786 /* See the code below that used this. */
f6abb50a 8787 decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
6125f3be 8788#endif
8d08fdba
MS
8789 typedef_decl = t;
8790 }
8791 }
bd6dd845 8792 else if (id != error_mark_node)
8d08fdba
MS
8793 /* Can't change CLASS nodes into RECORD nodes here! */
8794 type = id;
8795
8796 found: ;
8797 }
8798
8799 typedef_type = type;
8800
37c46b43 8801 /* No type at all: default to `int', and set DEFAULTED_INT
8d08fdba
MS
8802 because it was not a user-defined typedef.
8803 Except when we have a `typedef' inside a signature, in
8804 which case the type defaults to `unknown type' and is
8805 instantiated when assigning to a signature pointer or ref. */
8806
a3203465
MS
8807 if (type == NULL_TREE
8808 && (RIDBIT_SETP (RID_SIGNED, specbits)
8809 || RIDBIT_SETP (RID_UNSIGNED, specbits)
8810 || RIDBIT_SETP (RID_LONG, specbits)
8811 || RIDBIT_SETP (RID_SHORT, specbits)))
8812 {
8813 /* These imply 'int'. */
8814 type = integer_type_node;
37c46b43 8815 defaulted_int = 1;
a3203465
MS
8816 }
8817
8d08fdba
MS
8818 if (type == NULL_TREE)
8819 {
8820 explicit_int = -1;
8821 if (return_type == return_dtor)
8822 type = void_type_node;
8823 else if (return_type == return_ctor)
f30432d7 8824 type = build_pointer_type (ctor_return_type);
51c184be
MS
8825 else if (return_type == return_conversion)
8826 type = ctor_return_type;
8d08fdba
MS
8827 else if (current_class_type
8828 && IS_SIGNATURE (current_class_type)
fc378698 8829 && RIDBIT_SETP (RID_TYPEDEF, specbits)
8d08fdba
MS
8830 && (decl_context == FIELD || decl_context == NORMAL))
8831 {
8832 explicit_int = 0;
8833 opaque_typedef = 1;
8834 type = copy_node (opaque_type_node);
8835 }
8836 else
8837 {
a28e3c7f
MS
8838 if (funcdef_flag)
8839 {
8840 if (warn_return_type
a3203465 8841 && return_type == return_normal)
a28e3c7f
MS
8842 /* Save warning until we know what is really going on. */
8843 warn_about_return_type = 1;
8844 }
a3203465
MS
8845 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
8846 pedwarn ("ANSI C++ forbids typedef which does not specify a type");
343fdf03
JM
8847 else if (innermost_code != CALL_EXPR || pedantic
8848 || (warn_return_type && return_type == return_normal))
8849 {
8850 if (innermost_code == CALL_EXPR)
8851 cp_pedwarn ("return-type of `%D' defaults to `int'", dname);
8852 else
8853 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
8854 dname);
8855 }
8d08fdba
MS
8856 type = integer_type_node;
8857 }
8858 }
8859 else if (return_type == return_dtor)
8860 {
8861 error ("return type specification for destructor invalid");
8862 type = void_type_node;
8863 }
8864 else if (return_type == return_ctor)
8865 {
8866 error ("return type specification for constructor invalid");
f30432d7 8867 type = build_pointer_type (ctor_return_type);
8d08fdba 8868 }
51c184be
MS
8869 else if (return_type == return_conversion)
8870 {
e1cd6e56 8871 if (comptypes (type, ctor_return_type, 1) == 0)
51c184be
MS
8872 cp_error ("operator `%T' declared to return `%T'",
8873 ctor_return_type, type);
8874 else
8875 cp_pedwarn ("return type specified for `operator %T'",
8876 ctor_return_type);
8877
8878 type = ctor_return_type;
8879 }
8d08fdba
MS
8880
8881 ctype = NULL_TREE;
8882
8883 /* Now process the modifiers that were specified
8884 and check for invalid combinations. */
8885
8886 /* Long double is a special combination. */
8887
8888 if (RIDBIT_SETP (RID_LONG, specbits)
8889 && TYPE_MAIN_VARIANT (type) == double_type_node)
8890 {
8891 RIDBIT_RESET (RID_LONG, specbits);
8892 type = build_type_variant (long_double_type_node, TYPE_READONLY (type),
8893 TYPE_VOLATILE (type));
8894 }
8895
8896 /* Check all other uses of type modifiers. */
8897
8898 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
8899 || RIDBIT_SETP (RID_SIGNED, specbits)
8900 || RIDBIT_SETP (RID_LONG, specbits)
8901 || RIDBIT_SETP (RID_SHORT, specbits))
8902 {
8903 int ok = 0;
8904
8905 if (TREE_CODE (type) == REAL_TYPE)
8906 error ("short, signed or unsigned invalid for `%s'", name);
b7484fbe 8907 else if (TREE_CODE (type) != INTEGER_TYPE)
8d08fdba
MS
8908 error ("long, short, signed or unsigned invalid for `%s'", name);
8909 else if (RIDBIT_SETP (RID_LONG, specbits)
8910 && RIDBIT_SETP (RID_SHORT, specbits))
8911 error ("long and short specified together for `%s'", name);
8912 else if ((RIDBIT_SETP (RID_LONG, specbits)
8913 || RIDBIT_SETP (RID_SHORT, specbits))
8914 && explicit_char)
8915 error ("long or short specified with char for `%s'", name);
8916 else if ((RIDBIT_SETP (RID_LONG, specbits)
8917 || RIDBIT_SETP (RID_SHORT, specbits))
8918 && TREE_CODE (type) == REAL_TYPE)
8919 error ("long or short specified with floating type for `%s'", name);
8920 else if (RIDBIT_SETP (RID_SIGNED, specbits)
8921 && RIDBIT_SETP (RID_UNSIGNED, specbits))
8922 error ("signed and unsigned given together for `%s'", name);
8923 else
8924 {
8925 ok = 1;
37c46b43 8926 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
8d08fdba
MS
8927 {
8928 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
8929 name);
8930 if (flag_pedantic_errors)
8931 ok = 0;
8932 }
8933 }
8934
8935 /* Discard the type modifiers if they are invalid. */
8936 if (! ok)
8937 {
8938 RIDBIT_RESET (RID_UNSIGNED, specbits);
8939 RIDBIT_RESET (RID_SIGNED, specbits);
8940 RIDBIT_RESET (RID_LONG, specbits);
8941 RIDBIT_RESET (RID_SHORT, specbits);
8942 longlong = 0;
8943 }
8944 }
8945
37c46b43
MS
8946 if (RIDBIT_SETP (RID_COMPLEX, specbits)
8947 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
8948 {
8949 error ("complex invalid for `%s'", name);
8950 RIDBIT_RESET (RID_COMPLEX, specbits);
8951 }
8952
8d08fdba
MS
8953 /* Decide whether an integer type is signed or not.
8954 Optionally treat bitfields as signed by default. */
8955 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
8d08fdba 8956 || (bitfield && ! flag_signed_bitfields
37c46b43 8957 && (explicit_int || defaulted_int || explicit_char
8d08fdba
MS
8958 /* A typedef for plain `int' without `signed'
8959 can be controlled just like plain `int'. */
8960 || ! (typedef_decl != NULL_TREE
8961 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8962 && TREE_CODE (type) != ENUMERAL_TYPE
8963 && RIDBIT_NOTSETP (RID_SIGNED, specbits)))
8964 {
8965 if (longlong)
8966 type = long_long_unsigned_type_node;
8967 else if (RIDBIT_SETP (RID_LONG, specbits))
8968 type = long_unsigned_type_node;
8969 else if (RIDBIT_SETP (RID_SHORT, specbits))
8970 type = short_unsigned_type_node;
8971 else if (type == char_type_node)
8972 type = unsigned_char_type_node;
8973 else if (typedef_decl)
8974 type = unsigned_type (type);
8975 else
8976 type = unsigned_type_node;
8977 }
8978 else if (RIDBIT_SETP (RID_SIGNED, specbits)
8979 && type == char_type_node)
8980 type = signed_char_type_node;
8981 else if (longlong)
8982 type = long_long_integer_type_node;
8983 else if (RIDBIT_SETP (RID_LONG, specbits))
8984 type = long_integer_type_node;
8985 else if (RIDBIT_SETP (RID_SHORT, specbits))
8986 type = short_integer_type_node;
8987
37c46b43
MS
8988 if (RIDBIT_SETP (RID_COMPLEX, specbits))
8989 {
8990 /* If we just have "complex", it is equivalent to
8991 "complex double", but if any modifiers at all are specified it is
8992 the complex form of TYPE. E.g, "complex short" is
8993 "complex short int". */
8994
8995 if (defaulted_int && ! longlong
8996 && ! (RIDBIT_SETP (RID_LONG, specbits)
8997 || RIDBIT_SETP (RID_SHORT, specbits)
8998 || RIDBIT_SETP (RID_SIGNED, specbits)
8999 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
9000 type = complex_double_type_node;
9001 else if (type == integer_type_node)
9002 type = complex_integer_type_node;
9003 else if (type == float_type_node)
9004 type = complex_float_type_node;
9005 else if (type == double_type_node)
9006 type = complex_double_type_node;
9007 else if (type == long_double_type_node)
9008 type = complex_long_double_type_node;
9009 else
9010 type = build_complex_type (type);
9011 }
9012
3ac3d9ea
MM
9013 if (return_type == return_conversion
9014 && (RIDBIT_SETP (RID_CONST, specbits)
9015 || RIDBIT_SETP (RID_VOLATILE, specbits)))
9016 cp_error ("`operator %T' cannot be cv-qualified",
9017 ctor_return_type);
9018
8d08fdba
MS
9019 /* Set CONSTP if this declaration is `const', whether by
9020 explicit specification or via a typedef.
9021 Likewise for VOLATILEP. */
9022
9023 constp = !! RIDBIT_SETP (RID_CONST, specbits) + TYPE_READONLY (type);
9024 volatilep = !! RIDBIT_SETP (RID_VOLATILE, specbits) + TYPE_VOLATILE (type);
a1774733 9025 type = build_type_variant (type, 0, 0);
8d08fdba
MS
9026 staticp = 0;
9027 inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
8d08fdba 9028 virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
db5ae43f
MS
9029 RIDBIT_RESET (RID_VIRTUAL, specbits);
9030 explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
9031 RIDBIT_RESET (RID_EXPLICIT, specbits);
8d08fdba 9032
8d08fdba
MS
9033 if (RIDBIT_SETP (RID_STATIC, specbits))
9034 staticp = 1 + (decl_context == FIELD);
9035
9036 if (virtualp && staticp == 2)
9037 {
9038 cp_error ("member `%D' cannot be declared both virtual and static",
9039 dname);
9040 staticp = 0;
9041 }
9042 friendp = RIDBIT_SETP (RID_FRIEND, specbits);
8d08fdba
MS
9043 RIDBIT_RESET (RID_FRIEND, specbits);
9044
9045 if (RIDBIT_SETP (RID_MUTABLE, specbits))
9046 {
9047 if (decl_context == PARM)
9048 {
db5ae43f 9049 error ("non-member `%s' cannot be declared `mutable'", name);
8d08fdba
MS
9050 RIDBIT_RESET (RID_MUTABLE, specbits);
9051 }
9052 else if (friendp || decl_context == TYPENAME)
9053 {
db5ae43f 9054 error ("non-object member `%s' cannot be declared `mutable'", name);
8d08fdba
MS
9055 RIDBIT_RESET (RID_MUTABLE, specbits);
9056 }
8d08fdba
MS
9057 }
9058
9059 /* Warn if two storage classes are given. Default to `auto'. */
9060
9061 if (RIDBIT_ANY_SET (specbits))
9062 {
9063 if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
9064 if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
9065 if (decl_context == PARM && nclasses > 0)
9066 error ("storage class specifiers invalid in parameter declarations");
9067 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9068 {
9069 if (decl_context == PARM)
9070 error ("typedef declaration invalid in parameter declaration");
9071 nclasses++;
9072 }
9073 if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
9074 if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
9075 }
9076
9077 /* Give error if `virtual' is used outside of class declaration. */
b7484fbe
MS
9078 if (virtualp
9079 && (current_class_name == NULL_TREE || decl_context != FIELD))
8d08fdba
MS
9080 {
9081 error ("virtual outside class declaration");
9082 virtualp = 0;
9083 }
9084 if (current_class_name == NULL_TREE && RIDBIT_SETP (RID_MUTABLE, specbits))
9085 {
9086 error ("only members can be declared mutable");
9087 RIDBIT_RESET (RID_MUTABLE, specbits);
9088 }
9089
9090 /* Static anonymous unions are dealt with here. */
9091 if (staticp && decl_context == TYPENAME
9092 && TREE_CODE (declspecs) == TREE_LIST
67ffc812 9093 && ANON_UNION_TYPE_P (TREE_VALUE (declspecs)))
8d08fdba
MS
9094 decl_context = FIELD;
9095
9096 /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
9097 is used in a signature member function declaration. */
9098 if (decl_context == FIELD
9099 && IS_SIGNATURE (current_class_type)
fc378698 9100 && RIDBIT_NOTSETP (RID_TYPEDEF, specbits))
8d08fdba
MS
9101 {
9102 if (constp)
9103 {
9104 error ("`const' specified for signature member function `%s'", name);
9105 constp = 0;
9106 }
9107 if (volatilep)
9108 {
a28e3c7f
MS
9109 error ("`volatile' specified for signature member function `%s'",
9110 name);
8d08fdba
MS
9111 volatilep = 0;
9112 }
9113 if (inlinep)
9114 {
9115 error ("`inline' specified for signature member function `%s'", name);
9116 /* Later, we'll make signature member functions inline. */
9117 inlinep = 0;
9118 }
9119 if (friendp)
9120 {
9121 error ("`friend' declaration in signature definition");
9122 friendp = 0;
9123 }
9124 if (virtualp)
9125 {
a28e3c7f
MS
9126 error ("`virtual' specified for signature member function `%s'",
9127 name);
8d08fdba
MS
9128 /* Later, we'll make signature member functions virtual. */
9129 virtualp = 0;
9130 }
9131 }
9132
9133 /* Warn about storage classes that are invalid for certain
9134 kinds of declarations (parameters, typenames, etc.). */
9135
9136 if (nclasses > 1)
9137 error ("multiple storage classes in declaration of `%s'", name);
9138 else if (decl_context != NORMAL && nclasses > 0)
9139 {
db5ae43f 9140 if ((decl_context == PARM || decl_context == CATCHPARM)
8d08fdba
MS
9141 && (RIDBIT_SETP (RID_REGISTER, specbits)
9142 || RIDBIT_SETP (RID_AUTO, specbits)))
9143 ;
fc378698
MS
9144 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9145 ;
8d08fdba 9146 else if (decl_context == FIELD
fc378698 9147 && ! IS_SIGNATURE (current_class_type)
8d08fdba
MS
9148 /* C++ allows static class elements */
9149 && RIDBIT_SETP (RID_STATIC, specbits))
9150 /* C++ also allows inlines and signed and unsigned elements,
9151 but in those cases we don't come in here. */
9152 ;
9153 else
9154 {
9155 if (decl_context == FIELD)
9156 {
b7484fbe
MS
9157 tree tmp = NULL_TREE;
9158 register int op = 0;
9159
9160 if (declarator)
9161 {
9e9ff709
MS
9162 /* Avoid trying to get an operand off an identifier node. */
9163 if (TREE_CODE (declarator) == IDENTIFIER_NODE)
9164 tmp = declarator;
9165 else
9166 tmp = TREE_OPERAND (declarator, 0);
b7484fbe
MS
9167 op = IDENTIFIER_OPNAME_P (tmp);
9168 }
8d08fdba
MS
9169 error ("storage class specified for %s `%s'",
9170 IS_SIGNATURE (current_class_type)
9171 ? (op
9172 ? "signature member operator"
9173 : "signature member function")
b7484fbe 9174 : (op ? "member operator" : "field"),
8d08fdba
MS
9175 op ? operator_name_string (tmp) : name);
9176 }
9177 else
db5ae43f 9178 error (((decl_context == PARM || decl_context == CATCHPARM)
8d08fdba
MS
9179 ? "storage class specified for parameter `%s'"
9180 : "storage class specified for typename"), name);
9181 RIDBIT_RESET (RID_REGISTER, specbits);
9182 RIDBIT_RESET (RID_AUTO, specbits);
9183 RIDBIT_RESET (RID_EXTERN, specbits);
9184
9185 if (decl_context == FIELD && IS_SIGNATURE (current_class_type))
9186 {
9187 RIDBIT_RESET (RID_STATIC, specbits);
9188 staticp = 0;
9189 }
9190 }
9191 }
9192 else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
9193 {
a9aedbc2 9194 if (toplevel_bindings_p ())
8d08fdba 9195 {
59be0cdd 9196 /* It's common practice (and completely valid) to have a const
8d08fdba
MS
9197 be initialized and declared extern. */
9198 if (! constp)
9199 warning ("`%s' initialized and declared `extern'", name);
9200 }
9201 else
9202 error ("`%s' has both `extern' and initializer", name);
9203 }
9204 else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
a9aedbc2 9205 && ! toplevel_bindings_p ())
8d08fdba 9206 error ("nested function `%s' declared `extern'", name);
a9aedbc2 9207 else if (toplevel_bindings_p ())
8d08fdba
MS
9208 {
9209 if (RIDBIT_SETP (RID_AUTO, specbits))
9210 error ("top-level declaration of `%s' specifies `auto'", name);
8d08fdba
MS
9211 }
9212
909e536a
MS
9213 if (nclasses > 0 && friendp)
9214 error ("storage class specifiers invalid in friend function declarations");
9215
8d08fdba
MS
9216 /* Now figure out the structure of the declarator proper.
9217 Descend through it, creating more complex types, until we reach
9218 the declared identifier (or NULL_TREE, in an absolute declarator). */
9219
386b8a85
JM
9220 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
9221 && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
8d08fdba
MS
9222 {
9223 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9224 an INDIRECT_REF (for *...),
9225 a CALL_EXPR (for ...(...)),
9226 an identifier (for the name being declared)
9227 or a null pointer (for the place in an absolute declarator
9228 where the name was omitted).
9229 For the last two cases, we have just exited the loop.
9230
9231 For C++ it could also be
9232 a SCOPE_REF (for class :: ...). In this case, we have converted
9233 sensible names to types, and those are the values we use to
9234 qualify the member name.
9235 an ADDR_EXPR (for &...),
9236 a BIT_NOT_EXPR (for destructors)
8d08fdba
MS
9237
9238 At this point, TYPE is the type of elements of an array,
9239 or for a function to return, or for a pointer to point to.
9240 After this sequence of ifs, TYPE is the type of the
9241 array or function or pointer, and DECLARATOR has had its
9242 outermost layer removed. */
9243
bd6dd845 9244 if (type == error_mark_node)
8d08fdba
MS
9245 {
9246 if (TREE_CODE (declarator) == SCOPE_REF)
9247 declarator = TREE_OPERAND (declarator, 1);
9248 else
9249 declarator = TREE_OPERAND (declarator, 0);
9250 continue;
9251 }
9252 if (quals != NULL_TREE
9253 && (declarator == NULL_TREE
9254 || TREE_CODE (declarator) != SCOPE_REF))
9255 {
9256 if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
9257 ctype = TYPE_METHOD_BASETYPE (type);
9258 if (ctype != NULL_TREE)
9259 {
8d08fdba 9260 tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
8d08fdba
MS
9261 ctype = grok_method_quals (ctype, dummy, quals);
9262 type = TREE_TYPE (dummy);
9263 quals = NULL_TREE;
9264 }
9265 }
9266 switch (TREE_CODE (declarator))
9267 {
9268 case ARRAY_REF:
9269 {
9270 register tree itype = NULL_TREE;
9271 register tree size = TREE_OPERAND (declarator, 1);
b7484fbe
MS
9272 /* The index is a signed object `sizetype' bits wide. */
9273 tree index_type = signed_type (sizetype);
8d08fdba
MS
9274
9275 declarator = TREE_OPERAND (declarator, 0);
9276
9277 /* Check for some types that there cannot be arrays of. */
9278
a1774733 9279 if (TREE_CODE (type) == VOID_TYPE)
8d08fdba
MS
9280 {
9281 cp_error ("declaration of `%D' as array of voids", dname);
9282 type = error_mark_node;
9283 }
9284
9285 if (TREE_CODE (type) == FUNCTION_TYPE)
9286 {
9287 cp_error ("declaration of `%D' as array of functions", dname);
9288 type = error_mark_node;
9289 }
9290
9291 /* ARM $8.4.3: Since you can't have a pointer to a reference,
9292 you can't have arrays of references. If we allowed them,
59be0cdd 9293 then we'd be saying x[i] is valid for an array x, but
8d08fdba
MS
9294 then you'd have to ask: what does `*(x + i)' mean? */
9295 if (TREE_CODE (type) == REFERENCE_TYPE)
9296 {
9297 if (decl_context == TYPENAME)
9298 cp_error ("cannot make arrays of references");
9299 else
9300 cp_error ("declaration of `%D' as array of references",
9301 dname);
9302 type = error_mark_node;
9303 }
9304
9305 if (TREE_CODE (type) == OFFSET_TYPE)
9306 {
9307 cp_error ("declaration of `%D' as array of data members",
9308 dname);
9309 type = error_mark_node;
9310 }
9311
9312 if (TREE_CODE (type) == METHOD_TYPE)
9313 {
9314 cp_error ("declaration of `%D' as array of function members",
9315 dname);
9316 type = error_mark_node;
9317 }
9318
9319 if (size == error_mark_node)
9320 type = error_mark_node;
9321
9322 if (type == error_mark_node)
9323 continue;
9324
9325 if (size)
9326 {
9327 /* Must suspend_momentary here because the index
9328 type may need to live until the end of the function.
9329 For example, it is used in the declaration of a
9330 variable which requires destructing at the end of
9331 the function; then build_vec_delete will need this
9332 value. */
9333 int yes = suspend_momentary ();
2c73f9f5 9334 /* Might be a cast. */
8d08fdba
MS
9335 if (TREE_CODE (size) == NOP_EXPR
9336 && TREE_TYPE (size) == TREE_TYPE (TREE_OPERAND (size, 0)))
9337 size = TREE_OPERAND (size, 0);
9338
5566b478
MS
9339 /* If this involves a template parameter, it'll be
9340 constant, but we don't know what the value is yet. */
5156628f 9341 if (processing_template_decl)
5566b478
MS
9342 {
9343 itype = make_node (INTEGER_TYPE);
9344 TYPE_MIN_VALUE (itype) = size_zero_node;
9345 TYPE_MAX_VALUE (itype) = build_min
9346 (MINUS_EXPR, sizetype, size, integer_one_node);
9347 goto dont_grok_size;
9348 }
8d08fdba
MS
9349
9350 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9351 && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
9352 {
9353 cp_error ("size of array `%D' has non-integer type",
9354 dname);
9355 size = integer_one_node;
9356 }
9357 if (TREE_READONLY_DECL_P (size))
9358 size = decl_constant_value (size);
e1cd6e56 9359 if (pedantic && integer_zerop (size))
8d08fdba
MS
9360 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname);
9361 if (TREE_CONSTANT (size))
9362 {
dff6b454
RK
9363 int old_flag_pedantic_errors = flag_pedantic_errors;
9364 int old_pedantic = pedantic;
9365 pedantic = flag_pedantic_errors = 1;
9366 /* Always give overflow errors on array subscripts. */
8d08fdba 9367 constant_expression_warning (size);
dff6b454
RK
9368 pedantic = old_pedantic;
9369 flag_pedantic_errors = old_flag_pedantic_errors;
8d08fdba
MS
9370 if (INT_CST_LT (size, integer_zero_node))
9371 {
9372 cp_error ("size of array `%D' is negative", dname);
9373 size = integer_one_node;
9374 }
8d08fdba
MS
9375 }
9376 else
9377 {
e1cd6e56 9378 if (pedantic)
a0a33927
MS
9379 {
9380 if (dname)
9381 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
9382 dname);
9383 else
9384 cp_pedwarn ("ANSI C++ forbids variable-size array");
9385 }
8d08fdba 9386 }
b7484fbe 9387
beb53fb8
JM
9388 itype
9389 = fold (build_binary_op (MINUS_EXPR,
37c46b43
MS
9390 cp_convert (index_type, size),
9391 cp_convert (index_type,
9392 integer_one_node), 1));
b7484fbe
MS
9393 if (! TREE_CONSTANT (itype))
9394 itype = variable_size (itype);
594740f3
MS
9395 else if (TREE_OVERFLOW (itype))
9396 {
9397 error ("overflow in array dimension");
9398 TREE_OVERFLOW (itype) = 0;
9399 }
fc378698
MS
9400
9401 /* If we're a parm, we need to have a permanent type so
9402 mangling checks for re-use will work right. If both the
9403 element and index types are permanent, the array type
9404 will be, too. */
9405 if (decl_context == PARM
9406 && allocation_temporary_p () && TREE_PERMANENT (type))
9407 {
9408 push_obstacks (&permanent_obstack, &permanent_obstack);
9409 itype = build_index_type (itype);
9410 pop_obstacks ();
9411 }
9412 else
9413 itype = build_index_type (itype);
9414
5566b478 9415 dont_grok_size:
8d08fdba
MS
9416 resume_momentary (yes);
9417 }
9418
9419 /* Build the array type itself, then merge any constancy or
9420 volatility into the target type. We must do it in this order
9421 to ensure that the TYPE_MAIN_VARIANT field of the array type
9422 is set correctly. */
9423
9424 type = build_cplus_array_type (type, itype);
9425 if (constp || volatilep)
f376e137 9426 type = cp_build_type_variant (type, constp, volatilep);
8d08fdba
MS
9427
9428 ctype = NULL_TREE;
9429 }
9430 break;
9431
9432 case CALL_EXPR:
9433 {
9434 tree arg_types;
f376e137
MS
9435 int funcdecl_p;
9436 tree inner_parms = TREE_OPERAND (declarator, 1);
9437 tree inner_decl = TREE_OPERAND (declarator, 0);
8d08fdba
MS
9438
9439 /* Declaring a function type.
9440 Make sure we have a valid type for the function to return. */
9441#if 0
9442 /* Is this an error? Should they be merged into TYPE here? */
9443 if (pedantic && (constp || volatilep))
9444 pedwarn ("function declared to return const or volatile result");
9445#else
21474714
MS
9446 /* Merge any constancy or volatility into the function return
9447 type. */
8d08fdba
MS
9448
9449 if (constp || volatilep)
9450 {
f376e137 9451 type = cp_build_type_variant (type, constp, volatilep);
8d08fdba
MS
9452 if (IS_AGGR_TYPE (type))
9453 build_pointer_type (type);
9454 constp = 0;
9455 volatilep = 0;
9456 }
9457#endif
9458
9459 /* Warn about some types functions can't return. */
9460
9461 if (TREE_CODE (type) == FUNCTION_TYPE)
9462 {
9463 error ("`%s' declared as function returning a function", name);
9464 type = integer_type_node;
9465 }
9466 if (TREE_CODE (type) == ARRAY_TYPE)
9467 {
9468 error ("`%s' declared as function returning an array", name);
9469 type = integer_type_node;
9470 }
9471
f376e137
MS
9472 if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
9473 inner_decl = TREE_OPERAND (inner_decl, 1);
9474
386b8a85
JM
9475 if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
9476 inner_decl = dname;
9477
b7484fbe
MS
9478 /* Pick up type qualifiers which should be applied to `this'. */
9479 quals = TREE_OPERAND (declarator, 2);
9480
c11b6f21
MS
9481 /* Pick up the exception specifications. */
9482 raises = TREE_TYPE (declarator);
9483
f376e137
MS
9484 /* Say it's a definition only for the CALL_EXPR
9485 closest to the identifier. */
beb53fb8 9486 funcdecl_p
386b8a85
JM
9487 = inner_decl
9488 && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
9489 || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
9490 || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
9491
8d08fdba
MS
9492 if (ctype == NULL_TREE
9493 && decl_context == FIELD
f376e137 9494 && funcdecl_p
8d08fdba
MS
9495 && (friendp == 0 || dname == current_class_name))
9496 ctype = current_class_type;
9497
51c184be 9498 if (ctype && return_type == return_conversion)
8d08fdba
MS
9499 TYPE_HAS_CONVERSION (ctype) = 1;
9500 if (ctype && constructor_name (ctype) == dname)
9501 {
9502 /* We are within a class's scope. If our declarator name
9503 is the same as the class name, and we are defining
9504 a function, then it is a constructor/destructor, and
9505 therefore returns a void type. */
9506
9507 if (flags == DTOR_FLAG)
9508 {
9509 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
9510 not be declared const or volatile. A destructor
9511 may not be static. */
9512 if (staticp == 2)
9513 error ("destructor cannot be static member function");
b7484fbe 9514 if (quals)
8d08fdba 9515 {
b7484fbe 9516 error ("destructors cannot be declared `const' or `volatile'");
8d08fdba
MS
9517 return void_type_node;
9518 }
9519 if (decl_context == FIELD)
9520 {
9521 if (! member_function_or_else (ctype, current_class_type,
9522 "destructor for alien class `%s' cannot be a member"))
9523 return void_type_node;
9524 }
9525 }
2c73f9f5 9526 else /* It's a constructor. */
8d08fdba 9527 {
db5ae43f
MS
9528 if (explicitp == 1)
9529 explicitp = 2;
8d08fdba
MS
9530 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
9531 not be declared const or volatile. A constructor may
9532 not be virtual. A constructor may not be static. */
9533 if (staticp == 2)
9534 error ("constructor cannot be static member function");
9535 if (virtualp)
9536 {
9537 pedwarn ("constructors cannot be declared virtual");
9538 virtualp = 0;
9539 }
b7484fbe 9540 if (quals)
8d08fdba 9541 {
b7484fbe 9542 error ("constructors cannot be declared `const' or `volatile'");
8d08fdba
MS
9543 return void_type_node;
9544 }
8d08fdba 9545 {
51c184be 9546 RID_BIT_TYPE tmp_bits;
fc378698 9547 bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
51c184be
MS
9548 RIDBIT_RESET (RID_INLINE, tmp_bits);
9549 RIDBIT_RESET (RID_STATIC, tmp_bits);
9550 if (RIDBIT_ANY_SET (tmp_bits))
8d08fdba 9551 error ("return value type specifier for constructor ignored");
8d08fdba 9552 }
f30432d7 9553 type = build_pointer_type (ctype);
beb53fb8
JM
9554 if (decl_context == FIELD
9555 && IS_SIGNATURE (current_class_type))
8d08fdba
MS
9556 {
9557 error ("constructor not allowed in signature");
9558 return void_type_node;
9559 }
9560 else if (decl_context == FIELD)
9561 {
9562 if (! member_function_or_else (ctype, current_class_type,
9563 "constructor for alien class `%s' cannot be member"))
9564 return void_type_node;
9565 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
9566 if (return_type != return_ctor)
9567 return NULL_TREE;
9568 }
9569 }
9570 if (decl_context == FIELD)
9571 staticp = 0;
9572 }
b7484fbe 9573 else if (friendp)
8d08fdba 9574 {
b7484fbe
MS
9575 if (initialized)
9576 error ("can't initialize friend function `%s'", name);
9577 if (virtualp)
9578 {
9579 /* Cannot be both friend and virtual. */
9580 error ("virtual functions cannot be friends");
9581 RIDBIT_RESET (RID_FRIEND, specbits);
9582 friendp = 0;
9583 }
28cbf42c
MS
9584 if (decl_context == NORMAL)
9585 error ("friend declaration not in class definition");
9586 if (current_function_decl && funcdef_flag)
9587 cp_error ("can't define friend function `%s' in a local class definition",
9588 name);
8d08fdba
MS
9589 }
9590
8d08fdba
MS
9591 /* Construct the function type and go to the next
9592 inner layer of declarator. */
9593
f376e137 9594 declarator = TREE_OPERAND (declarator, 0);
8d08fdba 9595
f376e137
MS
9596 /* FIXME: This is where default args should be fully
9597 processed. */
8d08fdba 9598
f376e137 9599 arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
8d08fdba
MS
9600
9601 if (declarator)
9602 {
9603 /* Get past destructors, etc.
9604 We know we have one because FLAGS will be non-zero.
9605
9606 Complain about improper parameter lists here. */
9607 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
9608 {
9609 declarator = TREE_OPERAND (declarator, 0);
9610
9611 if (strict_prototype == 0 && arg_types == NULL_TREE)
9612 arg_types = void_list_node;
9613 else if (arg_types == NULL_TREE
9614 || arg_types != void_list_node)
9615 {
9616 error ("destructors cannot be specified with parameters");
9617 arg_types = void_list_node;
9618 }
9619 }
9620 }
9621
d22c8596 9622 /* ANSI says that `const int foo ();'
8d08fdba 9623 does not make the function foo const. */
d22c8596 9624 type = build_function_type (type, arg_types);
42976354
BK
9625
9626 {
9627 tree t;
9628 for (t = arg_types; t; t = TREE_CHAIN (t))
9629 if (TREE_PURPOSE (t)
9630 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9631 {
9632 add_defarg_fn (type);
9633 break;
9634 }
9635 }
8d08fdba
MS
9636 }
9637 break;
9638
9639 case ADDR_EXPR:
9640 case INDIRECT_REF:
9641 /* Filter out pointers-to-references and references-to-references.
9642 We can get these if a TYPE_DECL is used. */
9643
9644 if (TREE_CODE (type) == REFERENCE_TYPE)
9645 {
9646 error ("cannot declare %s to references",
9647 TREE_CODE (declarator) == ADDR_EXPR
9648 ? "references" : "pointers");
9649 declarator = TREE_OPERAND (declarator, 0);
9650 continue;
9651 }
9652
a5894242
MS
9653 if (TREE_CODE (type) == OFFSET_TYPE
9654 && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
9655 || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
9656 {
9657 cp_error ("cannot declare pointer to `%#T' member",
9658 TREE_TYPE (type));
9659 type = TREE_TYPE (type);
9660 }
9661
8d08fdba
MS
9662 /* Merge any constancy or volatility into the target type
9663 for the pointer. */
9664
9665 if (constp || volatilep)
9666 {
9667 /* A const or volatile signature pointer/reference is
9668 pointing to a const or volatile object, i.e., the
9669 `optr' is const or volatile, respectively, not the
9670 signature pointer/reference itself. */
9671 if (! IS_SIGNATURE (type))
9672 {
f376e137 9673 type = cp_build_type_variant (type, constp, volatilep);
8d08fdba
MS
9674 if (IS_AGGR_TYPE (type))
9675 build_pointer_type (type);
9676 constp = 0;
9677 volatilep = 0;
9678 }
9679 }
9680
9681 if (IS_SIGNATURE (type))
9682 {
9683 if (TREE_CODE (declarator) == ADDR_EXPR)
9684 {
63718c49
GB
9685 if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
9686 && TYPE_SIZE (type))
9687 cp_warning ("empty signature `%T' used in signature reference declaration",
9688 type);
8d08fdba
MS
9689#if 0
9690 type = build_signature_reference_type (type,
9691 constp, volatilep);
9692#else
9693 sorry ("signature reference");
9694 return NULL_TREE;
9695#endif
9696 }
9697 else
9698 {
63718c49
GB
9699 if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
9700 && TYPE_SIZE (type))
9701 cp_warning ("empty signature `%T' used in signature pointer declaration",
9702 type);
8d08fdba
MS
9703 type = build_signature_pointer_type (type,
9704 constp, volatilep);
9705 }
9706 constp = 0;
9707 volatilep = 0;
9708 }
9709 else if (TREE_CODE (declarator) == ADDR_EXPR)
9710 {
9711 if (TREE_CODE (type) == FUNCTION_TYPE)
9712 {
9713 error ("cannot declare references to functions; use pointer to function instead");
9714 type = build_pointer_type (type);
9715 }
9716 else
9717 {
a1774733 9718 if (TREE_CODE (type) == VOID_TYPE)
8d08fdba
MS
9719 error ("invalid type: `void &'");
9720 else
9721 type = build_reference_type (type);
9722 }
9723 }
9724 else if (TREE_CODE (type) == METHOD_TYPE)
9725 {
9726 type = build_ptrmemfunc_type (build_pointer_type (type));
9727 }
9728 else
9729 type = build_pointer_type (type);
9730
9731 /* Process a list of type modifier keywords (such as
9732 const or volatile) that were given inside the `*' or `&'. */
9733
9734 if (TREE_TYPE (declarator))
9735 {
9736 register tree typemodlist;
9737 int erred = 0;
9738 for (typemodlist = TREE_TYPE (declarator); typemodlist;
9739 typemodlist = TREE_CHAIN (typemodlist))
9740 {
9741 if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
9742 constp++;
9743 else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
9744 volatilep++;
9745 else if (!erred)
9746 {
9747 erred = 1;
9748 error ("invalid type modifier within %s declarator",
9749 TREE_CODE (declarator) == ADDR_EXPR
9750 ? "reference" : "pointer");
9751 }
9752 }
9753 if (constp > 1)
a0a33927 9754 pedwarn ("duplicate `const'");
8d08fdba 9755 if (volatilep > 1)
a0a33927
MS
9756 pedwarn ("duplicate `volatile'");
9757 if (TREE_CODE (declarator) == ADDR_EXPR
9758 && (constp || volatilep))
9759 {
9760 if (constp)
e1cd6e56 9761 pedwarn ("discarding `const' applied to a reference");
a0a33927 9762 if (volatilep)
e1cd6e56 9763 pedwarn ("discarding `volatile' applied to a reference");
a0a33927
MS
9764 constp = volatilep = 0;
9765 }
8d08fdba
MS
9766 }
9767 declarator = TREE_OPERAND (declarator, 0);
9768 ctype = NULL_TREE;
9769 break;
9770
9771 case SCOPE_REF:
9772 {
9773 /* We have converted type names to NULL_TREE if the
9774 name was bogus, or to a _TYPE node, if not.
9775
9776 The variable CTYPE holds the type we will ultimately
9777 resolve to. The code here just needs to build
9778 up appropriate member types. */
9779 tree sname = TREE_OPERAND (declarator, 1);
386b8a85
JM
9780 tree t;
9781
8d08fdba
MS
9782 /* Destructors can have their visibilities changed as well. */
9783 if (TREE_CODE (sname) == BIT_NOT_EXPR)
9784 sname = TREE_OPERAND (sname, 0);
9785
9786 if (TREE_COMPLEXITY (declarator) == 0)
9787 /* This needs to be here, in case we are called
9788 multiple times. */ ;
9a68c51f
JM
9789 else if (TREE_COMPLEXITY (declarator) == -1)
9790 /* Namespace member. */
9791 pop_decl_namespace ();
8d08fdba 9792 else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
2c73f9f5 9793 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
5566b478
MS
9794 else if (! IS_AGGR_TYPE_CODE
9795 (TREE_CODE (TREE_OPERAND (declarator, 0))))
9796 ;
8d08fdba
MS
9797 else if (TREE_COMPLEXITY (declarator) == current_class_depth)
9798 {
9a3b49ac
MS
9799 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
9800 that refer to ctype. They couldn't be resolved earlier
9801 because we hadn't pushed into the class yet.
9802 Example: resolve 'B<T>::type' in
9803 'B<typename B<T>::type> B<T>::f () { }'. */
9804 if (current_template_parms
9805 && uses_template_parms (type)
9806 && uses_template_parms (current_class_type))
9807 {
9808 tree args = current_template_args ();
f7d98d58 9809 type = tsubst (type, args, NULL_TREE);
9a3b49ac
MS
9810 }
9811
a28e3c7f
MS
9812 /* This pop_nested_class corresponds to the
9813 push_nested_class used to push into class scope for
9814 parsing the argument list of a function decl, in
9815 qualified_id. */
8d08fdba
MS
9816 pop_nested_class (1);
9817 TREE_COMPLEXITY (declarator) = current_class_depth;
9818 }
9819 else
9820 my_friendly_abort (16);
9821
9822 if (TREE_OPERAND (declarator, 0) == NULL_TREE)
9823 {
9824 /* We had a reference to a global decl, or
9825 perhaps we were given a non-aggregate typedef,
9826 in which case we cleared this out, and should just
9827 keep going as though it wasn't there. */
9828 declarator = sname;
9829 continue;
9830 }
9831 ctype = TREE_OPERAND (declarator, 0);
9832
386b8a85
JM
9833 t = ctype;
9834 while (t != NULL_TREE)
9835 {
75650646
MM
9836 if (CLASSTYPE_TEMPLATE_INFO (t) &&
9837 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
386b8a85
JM
9838 template_count += 1;
9839 t = TYPE_MAIN_DECL (t);
9840 if (DECL_LANG_SPECIFIC (t))
9841 t = DECL_CLASS_CONTEXT (t);
9842 else
9843 t = NULL_TREE;
9844 }
9845
8d08fdba
MS
9846 if (sname == NULL_TREE)
9847 goto done_scoping;
9848
9849 if (TREE_CODE (sname) == IDENTIFIER_NODE)
9850 {
9851 /* This is the `standard' use of the scoping operator:
9852 basetype :: member . */
9853
db5ae43f 9854 if (ctype == current_class_type)
28cbf42c
MS
9855 {
9856 /* class A {
9857 void A::f ();
9858 };
9859
9860 Is this ill-formed? */
9861
9862 if (pedantic)
9863 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
9864 ctype, name);
9865 }
db5ae43f 9866 else if (TREE_CODE (type) == FUNCTION_TYPE)
8d08fdba
MS
9867 {
9868 if (current_class_type == NULL_TREE
8d08fdba
MS
9869 || friendp)
9870 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
9871 TREE_TYPE (type), TYPE_ARG_TYPES (type));
9872 else
9873 {
5b605f68 9874 cp_error ("cannot declare member function `%T::%s' within `%T'",
a3203465 9875 ctype, name, current_class_type);
8d08fdba
MS
9876 return void_type_node;
9877 }
9878 }
5566b478
MS
9879 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
9880 || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
8d08fdba 9881 {
2c73f9f5 9882 /* Have to move this code elsewhere in this function.
db5ae43f
MS
9883 this code is used for i.e., typedef int A::M; M *pm;
9884
9885 It is? How? jason 10/2/94 */
8d08fdba 9886
8d08fdba
MS
9887 if (current_class_type)
9888 {
db5ae43f
MS
9889 cp_error ("cannot declare member `%T::%s' within `%T'",
9890 ctype, name, current_class_type);
9891 return void_type_node;
8d08fdba
MS
9892 }
9893 type = build_offset_type (ctype, type);
9894 }
9895 else if (uses_template_parms (ctype))
9896 {
8d08fdba 9897 if (TREE_CODE (type) == FUNCTION_TYPE)
beb53fb8
JM
9898 type
9899 = build_cplus_method_type (build_type_variant (ctype,
9900 constp,
9901 volatilep),
9902 TREE_TYPE (type),
9903 TYPE_ARG_TYPES (type));
8d08fdba
MS
9904 }
9905 else
9906 {
9907 cp_error ("structure `%T' not yet defined", ctype);
9908 return error_mark_node;
9909 }
9910
9911 declarator = sname;
9912 }
8d08fdba
MS
9913 else if (TREE_CODE (sname) == SCOPE_REF)
9914 my_friendly_abort (17);
9915 else
9916 {
9917 done_scoping:
9918 declarator = TREE_OPERAND (declarator, 1);
9919 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
9920 /* In this case, we will deal with it later. */
9921 ;
9922 else
9923 {
9924 if (TREE_CODE (type) == FUNCTION_TYPE)
9925 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep), TREE_TYPE (type), TYPE_ARG_TYPES (type));
9926 else
9927 type = build_offset_type (ctype, type);
9928 }
9929 }
9930 }
9931 break;
9932
9933 case BIT_NOT_EXPR:
9934 declarator = TREE_OPERAND (declarator, 0);
9935 break;
9936
8d08fdba
MS
9937 case RECORD_TYPE:
9938 case UNION_TYPE:
9939 case ENUMERAL_TYPE:
9940 declarator = NULL_TREE;
9941 break;
9942
9943 case ERROR_MARK:
9944 declarator = NULL_TREE;
9945 break;
9946
9947 default:
9948 my_friendly_abort (158);
9949 }
9950 }
9951
db5ae43f
MS
9952 if (explicitp == 1)
9953 {
9954 error ("only constructors can be declared `explicit'");
9955 explicitp = 0;
9956 }
9957
8d08fdba
MS
9958 /* Now TYPE has the actual type. */
9959
9960 /* If this is declaring a typedef name, return a TYPE_DECL. */
9961
f30432d7
MS
9962 if (RIDBIT_SETP (RID_MUTABLE, specbits))
9963 {
9964 if (constp)
9965 {
9966 error ("const `%s' cannot be declared `mutable'", name);
9967 RIDBIT_RESET (RID_MUTABLE, specbits);
9968 }
9969 else if (staticp)
9970 {
9971 error ("static `%s' cannot be declared `mutable'", name);
9972 RIDBIT_RESET (RID_MUTABLE, specbits);
9973 }
9974 }
9975
fc378698 9976 if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
8d08fdba
MS
9977 {
9978 tree decl;
9979
9980 /* Note that the grammar rejects storage classes
9981 in typenames, fields or parameters. */
9982 if (constp || volatilep)
f376e137 9983 type = cp_build_type_variant (type, constp, volatilep);
eff71ab0
PB
9984 if (current_lang_name == lang_name_java)
9985 TYPE_FOR_JAVA (type) = 1;
8d08fdba 9986
d2e5ee5c
MS
9987 if (decl_context == FIELD)
9988 {
9989 if (declarator == current_class_name)
9990 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
9991 declarator);
9992 decl = build_lang_decl (TYPE_DECL, declarator, type);
9993 if (IS_SIGNATURE (current_class_type) && opaque_typedef)
9994 SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type) = 1;
9995 }
9996 else
7fb4a8f7
JM
9997 {
9998 /* Make sure this typedef lives as long as its type,
9999 since it might be used as a template parameter. */
1aed5355
MM
10000 if (type != error_mark_node)
10001 push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
7fb4a8f7 10002 decl = build_decl (TYPE_DECL, declarator, type);
1aed5355
MM
10003 if (type != error_mark_node)
10004 pop_obstacks ();
7fb4a8f7 10005 }
d2e5ee5c 10006
8d08fdba
MS
10007 /* If the user declares "struct {...} foo" then `foo' will have
10008 an anonymous name. Fill that name in now. Nothing can
10009 refer to it, so nothing needs know about the name change.
10010 The TYPE_NAME field was filled in by build_struct_xref. */
10011 if (type != error_mark_node
10012 && TYPE_NAME (type)
10013 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10014 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
10015 {
0d2a8b1b
BK
10016 /* For anonymous structs that are cv-qualified, need to use
10017 TYPE_MAIN_VARIANT so that name will mangle correctly. As
10018 type not referenced after this block, don't bother
10019 resetting type to original type, ie. TREE_TYPE (decl). */
10020 type = TYPE_MAIN_VARIANT (type);
10021
2c73f9f5 10022 /* Replace the anonymous name with the real name everywhere. */
8d08fdba 10023 lookup_tag_reverse (type, declarator);
d2e5ee5c 10024 TYPE_NAME (type) = decl;
8d08fdba
MS
10025
10026 if (TYPE_LANG_SPECIFIC (type))
10027 TYPE_WAS_ANONYMOUS (type) = 1;
10028
2c73f9f5
ML
10029 /* XXX Temporarily set the scope.
10030 When returning, start_decl expects it as NULL_TREE,
10031 and will then then set it using pushdecl. */
10032 my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10033 if (current_class_type)
10034 DECL_CONTEXT (decl) = current_class_type;
10035 else
cb0dbb9a 10036 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2c73f9f5 10037
d2e5ee5c
MS
10038 DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10039 DECL_ASSEMBLER_NAME (decl)
10040 = get_identifier (build_overload_name (type, 1, 1));
2c73f9f5 10041 DECL_CONTEXT (decl) = NULL_TREE;
50a6dbd7
JM
10042
10043 /* FIXME remangle member functions; member functions of a
10044 type with external linkage have external linkage. */
fc378698 10045 }
fc378698 10046
8d08fdba
MS
10047 if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10048 {
10049 cp_error_at ("typedef name may not be class-qualified", decl);
a3203465 10050 return NULL_TREE;
8d08fdba
MS
10051 }
10052 else if (quals)
10053 {
10054 if (ctype == NULL_TREE)
10055 {
10056 if (TREE_CODE (type) != METHOD_TYPE)
10057 cp_error_at ("invalid type qualifier for non-method type", decl);
10058 else
10059 ctype = TYPE_METHOD_BASETYPE (type);
10060 }
10061 if (ctype != NULL_TREE)
10062 grok_method_quals (ctype, decl, quals);
10063 }
10064
10065 if (RIDBIT_SETP (RID_SIGNED, specbits)
10066 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10067 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10068
10069 if (RIDBIT_SETP (RID_MUTABLE, specbits))
10070 {
10071 error ("non-object member `%s' cannot be declared mutable", name);
10072 }
10073
c91a56d2
MS
10074 bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10075 inlinep, friendp, raises != NULL_TREE);
10076
10077 if (initialized)
10078 error ("typedef declaration includes an initializer");
10079
8d08fdba
MS
10080 return decl;
10081 }
10082
10083 /* Detect the case of an array type of unspecified size
10084 which came, as such, direct from a typedef name.
10085 We must copy the type, so that each identifier gets
10086 a distinct type, so that each identifier's size can be
10087 controlled separately by its own initializer. */
10088
10089 if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10090 && TYPE_DOMAIN (type) == NULL_TREE)
10091 {
10092 type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10093 }
10094
10095 /* If this is a type name (such as, in a cast or sizeof),
10096 compute the type and return it now. */
10097
10098 if (decl_context == TYPENAME)
10099 {
10100 /* Note that the grammar rejects storage classes
10101 in typenames, fields or parameters. */
10102 if (constp || volatilep)
a703fb38
KG
10103 {
10104 if (IS_SIGNATURE (type))
10105 error ("`const' or `volatile' specified with signature type");
10106 else
10107 type = cp_build_type_variant (type, constp, volatilep);
10108 }
8d08fdba
MS
10109
10110 /* Special case: "friend class foo" looks like a TYPENAME context. */
10111 if (friendp)
10112 {
b7484fbe
MS
10113 if (volatilep)
10114 {
10115 cp_error ("`volatile' specified for friend class declaration");
10116 volatilep = 0;
10117 }
10118 if (inlinep)
10119 {
10120 cp_error ("`inline' specified for friend class declaration");
10121 inlinep = 0;
10122 }
10123
10124 /* Only try to do this stuff if we didn't already give up. */
10125 if (type != integer_type_node)
10126 {
10127 /* A friendly class? */
10128 if (current_class_type)
10129 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10130 else
10131 error ("trying to make class `%s' a friend of global scope",
10132 TYPE_NAME_STRING (type));
10133 type = void_type_node;
10134 }
8d08fdba
MS
10135 }
10136 else if (quals)
10137 {
8d08fdba 10138 tree dummy = build_decl (TYPE_DECL, declarator, type);
8d08fdba
MS
10139 if (ctype == NULL_TREE)
10140 {
10141 my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
10142 ctype = TYPE_METHOD_BASETYPE (type);
10143 }
10144 grok_method_quals (ctype, dummy, quals);
10145 type = TREE_TYPE (dummy);
10146 }
10147
10148 return type;
10149 }
10150 else if (declarator == NULL_TREE && decl_context != PARM
db5ae43f 10151 && decl_context != CATCHPARM
8d08fdba
MS
10152 && TREE_CODE (type) != UNION_TYPE
10153 && ! bitfield)
10154 {
10155 cp_error ("abstract declarator `%T' used as declaration", type);
10156 declarator = make_anon_name ();
10157 }
10158
10159 /* `void' at top level (not within pointer)
10160 is allowed only in typedefs or type names.
10161 We don't complain about parms either, but that is because
10162 a better error message can be made later. */
10163
a1774733 10164 if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
8d08fdba 10165 {
b7484fbe
MS
10166 if (! declarator)
10167 error ("unnamed variable or field declared void");
10168 else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
8d08fdba
MS
10169 {
10170 if (IDENTIFIER_OPNAME_P (declarator))
8d08fdba 10171 my_friendly_abort (356);
8d08fdba
MS
10172 else
10173 error ("variable or field `%s' declared void", name);
10174 }
10175 else
10176 error ("variable or field declared void");
10177 type = integer_type_node;
10178 }
10179
10180 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10181 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10182
10183 {
10184 register tree decl;
10185
10186 if (decl_context == PARM)
10187 {
05008fb9 10188 if (ctype || in_namespace)
8d08fdba
MS
10189 error ("cannot use `::' in parameter declaration");
10190
10191 /* A parameter declared as an array of T is really a pointer to T.
10192 One declared as a function is really a pointer to a function.
39211cd5 10193 One declared as a member is really a pointer to member. */
8d08fdba
MS
10194
10195 if (TREE_CODE (type) == ARRAY_TYPE)
10196 {
e92cc029 10197 /* Transfer const-ness of array into that of type pointed to. */
39211cd5 10198 type = build_pointer_type
f376e137 10199 (cp_build_type_variant (TREE_TYPE (type), constp, volatilep));
39211cd5 10200 volatilep = constp = 0;
8d08fdba
MS
10201 }
10202 else if (TREE_CODE (type) == FUNCTION_TYPE)
10203 type = build_pointer_type (type);
10204 else if (TREE_CODE (type) == OFFSET_TYPE)
10205 type = build_pointer_type (type);
a1774733 10206 else if (TREE_CODE (type) == VOID_TYPE && declarator)
b7484fbe
MS
10207 {
10208 error ("declaration of `%s' as void", name);
10209 return NULL_TREE;
10210 }
8d08fdba 10211
e349ee73 10212 decl = build_decl (PARM_DECL, declarator, complete_type (type));
8d08fdba
MS
10213
10214 bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
10215 inlinep, friendp, raises != NULL_TREE);
10216 if (current_class_type
10217 && IS_SIGNATURE (current_class_type))
10218 {
10219 if (inlinep)
10220 error ("parameter of signature member function declared `inline'");
10221 if (RIDBIT_SETP (RID_AUTO, specbits))
10222 error ("parameter of signature member function declared `auto'");
10223 if (RIDBIT_SETP (RID_REGISTER, specbits))
10224 error ("parameter of signature member function declared `register'");
10225 }
10226
10227 /* Compute the type actually passed in the parmlist,
10228 for the case where there is no prototype.
10229 (For example, shorts and chars are passed as ints.)
10230 When there is a prototype, this is overridden later. */
10231
39211cd5 10232 DECL_ARG_TYPE (decl) = type_promotes_to (type);
8d08fdba
MS
10233 }
10234 else if (decl_context == FIELD)
10235 {
10236 if (type == error_mark_node)
10237 {
10238 /* Happens when declaring arrays of sizes which
10239 are error_mark_node, for example. */
10240 decl = NULL_TREE;
10241 }
05008fb9
MM
10242 else if (in_namespace)
10243 {
10244 /* Something like struct S { int N::j; }; */
10245 cp_error ("invalid use of `::'");
10246 decl = NULL_TREE;
10247 }
8d08fdba
MS
10248 else if (TREE_CODE (type) == FUNCTION_TYPE)
10249 {
10250 int publicp = 0;
e1467ff2 10251 tree function_context;
8d08fdba 10252
72b7eeff
MS
10253 /* We catch the others as conflicts with the builtin
10254 typedefs. */
10255 if (friendp && declarator == ridpointers[(int) RID_SIGNED])
10256 {
10257 cp_error ("function `%D' cannot be declared friend",
10258 declarator);
10259 friendp = 0;
10260 }
10261
8d08fdba
MS
10262 if (friendp == 0)
10263 {
10264 if (ctype == NULL_TREE)
10265 ctype = current_class_type;
10266
10267 if (ctype == NULL_TREE)
10268 {
10269 cp_error ("can't make `%D' into a method -- not in a class",
10270 declarator);
10271 return void_type_node;
10272 }
10273
10274 /* ``A union may [ ... ] not [ have ] virtual functions.''
10275 ARM 9.5 */
10276 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10277 {
10278 cp_error ("function `%D' declared virtual inside a union",
10279 declarator);
10280 return void_type_node;
10281 }
10282
10283 if (declarator == ansi_opname[(int) NEW_EXPR]
a28e3c7f
MS
10284 || declarator == ansi_opname[(int) VEC_NEW_EXPR]
10285 || declarator == ansi_opname[(int) DELETE_EXPR]
10286 || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
8d08fdba
MS
10287 {
10288 if (virtualp)
10289 {
10290 cp_error ("`%D' cannot be declared virtual, since it is always static",
10291 declarator);
10292 virtualp = 0;
10293 }
10294 }
10295 else if (staticp < 2)
10296 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
10297 TREE_TYPE (type), TYPE_ARG_TYPES (type));
10298 }
10299
10300 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
e1467ff2
MM
10301 function_context = (ctype != NULL_TREE) ?
10302 hack_decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10303 publicp = (! friendp || ! staticp)
10304 && function_context == NULL_TREE;
386b8a85
JM
10305 decl = grokfndecl (ctype, type,
10306 TREE_CODE (declarator) != TEMPLATE_ID_EXPR
10307 ? declarator : dname,
10308 declarator,
f30432d7 10309 virtualp, flags, quals, raises, attrlist,
386b8a85 10310 friendp ? -1 : 0, friendp, publicp, inlinep,
2c73f9f5 10311 funcdef_flag, template_count, in_namespace);
f0e01782
MS
10312 if (decl == NULL_TREE)
10313 return NULL_TREE;
6125f3be
DE
10314#if 0
10315 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10316 /* The decl and setting of decl_machine_attr is also turned off. */
71851aaa 10317 decl = build_decl_attribute_variant (decl, decl_machine_attr);
6125f3be 10318#endif
f0e01782 10319
db5ae43f
MS
10320 if (explicitp == 2)
10321 DECL_NONCONVERTING_P (decl) = 1;
8d08fdba
MS
10322 }
10323 else if (TREE_CODE (type) == METHOD_TYPE)
10324 {
faae18ab
MS
10325 /* We only get here for friend declarations of
10326 members of other classes. */
8d08fdba
MS
10327 /* All method decls are public, so tell grokfndecl to set
10328 TREE_PUBLIC, also. */
386b8a85 10329 decl = grokfndecl (ctype, type, declarator, declarator,
f30432d7 10330 virtualp, flags, quals, raises, attrlist,
386b8a85 10331 friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
2c73f9f5 10332 template_count, in_namespace);
f0e01782
MS
10333 if (decl == NULL_TREE)
10334 return NULL_TREE;
8d08fdba 10335 }
5566b478
MS
10336 else if (!staticp && ! processing_template_decl
10337 && TYPE_SIZE (complete_type (type)) == NULL_TREE
8d08fdba
MS
10338 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
10339 {
b7484fbe
MS
10340 if (declarator)
10341 cp_error ("field `%D' has incomplete type", declarator);
10342 else
10343 cp_error ("name `%T' has incomplete type", type);
8d08fdba
MS
10344
10345 /* If we're instantiating a template, tell them which
10346 instantiation made the field's type be incomplete. */
10347 if (current_class_type
10348 && TYPE_NAME (current_class_type)
d2e5ee5c 10349 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
8d08fdba
MS
10350 && declspecs && TREE_VALUE (declspecs)
10351 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
db5ae43f
MS
10352 cp_error (" in instantiation of template `%T'",
10353 current_class_type);
10354
8d08fdba
MS
10355 type = error_mark_node;
10356 decl = NULL_TREE;
10357 }
10358 else
10359 {
10360 if (friendp)
10361 {
10362 error ("`%s' is neither function nor method; cannot be declared friend",
10363 IDENTIFIER_POINTER (declarator));
10364 friendp = 0;
10365 }
10366 decl = NULL_TREE;
10367 }
10368
10369 if (friendp)
10370 {
10371 /* Friends are treated specially. */
10372 if (ctype == current_class_type)
10373 warning ("member functions are implicitly friends of their class");
10374 else
10375 {
10376 tree t = NULL_TREE;
10377 if (decl && DECL_NAME (decl))
36a117a5
MM
10378 {
10379 if (template_class_depth (current_class_type) == 0)
10380 decl
10381 = check_explicit_specialization
10382 (declarator, decl,
10383 template_count, 2 * (funcdef_flag != 0) + 4);
10384 t = do_friend (ctype, declarator, decl,
10385 last_function_parms, flags, quals,
10386 funcdef_flag);
10387 }
8d08fdba
MS
10388 if (t && funcdef_flag)
10389 return t;
10390
10391 return void_type_node;
10392 }
10393 }
10394
10395 /* Structure field. It may not be a function, except for C++ */
10396
10397 if (decl == NULL_TREE)
10398 {
8d08fdba
MS
10399 if (initialized)
10400 {
3ac3d9ea
MM
10401 if (!staticp)
10402 {
10403 /* An attempt is being made to initialize a non-static
10404 member. But, from [class.mem]:
10405
10406 4 A member-declarator can contain a
10407 constant-initializer only if it declares a static
10408 member (_class.static_) of integral or enumeration
10409 type, see _class.static.data_.
10410
10411 This used to be relatively common practice, but
10412 the rest of the compiler does not correctly
10413 handle the initialization unless the member is
10414 static so we make it static below. */
10415 cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
10416 constp ? "const member" : "member",
10417 declarator);
10418 cp_pedwarn ("making `%D' static", declarator);
10419 staticp = 1;
10420 }
10421
a0a33927
MS
10422 /* Motion 10 at San Diego: If a static const integral data
10423 member is initialized with an integral constant
10424 expression, the initializer may appear either in the
10425 declaration (within the class), or in the definition,
10426 but not both. If it appears in the class, the member is
10427 a member constant. The file-scope definition is always
10428 required. */
c92366fb 10429 if (CLASS_TYPE_P (type)
d7ceab7b
MM
10430 || TREE_CODE (type) == REFERENCE_TYPE)
10431 {
10432 cp_error ("in-class initialization of static data member of non-integral type `%T'",
10433 type);
10434 /* If we just return the declaration, crashes will
10435 sometimes occur. We therefore return
10436 void_type_node, as if this was a friend
10437 declaration, to cause callers to completely
10438 ignore this declaration. */
10439 return void_type_node;
10440 }
10441 else if (!constp)
3ac3d9ea
MM
10442 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
10443 declarator);
d7ceab7b
MM
10444 else if (pedantic && ! INTEGRAL_TYPE_P (type)
10445 && !uses_template_parms (type))
3ac3d9ea 10446 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", declarator, type);
8d08fdba
MS
10447 }
10448
3ac3d9ea 10449 if (staticp)
8d08fdba 10450 {
f30432d7 10451 /* ANSI C++ Apr '95 wp 9.2 */
3ac3d9ea 10452 if (declarator == current_class_name)
f30432d7
MS
10453 cp_pedwarn ("ANSI C++ forbids static member `%D' with same name as enclosing class",
10454 declarator);
10455
8d08fdba
MS
10456 /* C++ allows static class members.
10457 All other work for this is done by grokfield.
d7ceab7b 10458 This VAR_DCL is built by build_lang_field_decl.
8d08fdba
MS
10459 All other VAR_DECLs are built by build_decl. */
10460 decl = build_lang_field_decl (VAR_DECL, declarator, type);
5b605f68
MS
10461 TREE_STATIC (decl) = 1;
10462 /* In class context, 'static' means public access. */
3ac3d9ea 10463 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
8d08fdba
MS
10464 }
10465 else
10466 {
10467 decl = build_lang_field_decl (FIELD_DECL, declarator, type);
10468 if (RIDBIT_SETP (RID_MUTABLE, specbits))
10469 {
10470 DECL_MUTABLE_P (decl) = 1;
10471 RIDBIT_RESET (RID_MUTABLE, specbits);
10472 }
10473 }
10474
10475 bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
10476 inlinep, friendp, raises != NULL_TREE);
10477 }
10478 }
10479 else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
10480 {
386b8a85 10481 tree original_name;
8d08fdba
MS
10482 int publicp = 0;
10483
10484 if (! declarator)
10485 return NULL_TREE;
10486
386b8a85
JM
10487 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10488 original_name = dname;
10489 else
10490 original_name = declarator;
10491
8926095f
MS
10492 if (RIDBIT_SETP (RID_AUTO, specbits))
10493 error ("storage class `auto' invalid for function `%s'", name);
10494 else if (RIDBIT_SETP (RID_REGISTER, specbits))
10495 error ("storage class `register' invalid for function `%s'", name);
8d08fdba
MS
10496
10497 /* Function declaration not at top level.
10498 Storage classes other than `extern' are not allowed
10499 and `extern' makes no difference. */
a9aedbc2 10500 if (! toplevel_bindings_p ()
8926095f
MS
10501 && (RIDBIT_SETP (RID_STATIC, specbits)
10502 || RIDBIT_SETP (RID_INLINE, specbits))
8d08fdba 10503 && pedantic)
8926095f
MS
10504 {
10505 if (RIDBIT_SETP (RID_STATIC, specbits))
10506 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
10507 else
10508 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
10509 }
10510
8d08fdba
MS
10511 if (ctype == NULL_TREE)
10512 {
10513 if (virtualp)
10514 {
10515 error ("virtual non-class function `%s'", name);
10516 virtualp = 0;
10517 }
10518
10519 if (current_lang_name == lang_name_cplusplus
5156628f 10520 && ! processing_template_decl
35680744 10521 && ! MAIN_NAME_P (original_name)
8d08fdba
MS
10522 && ! (IDENTIFIER_LENGTH (original_name) > 10
10523 && IDENTIFIER_POINTER (original_name)[0] == '_'
10524 && IDENTIFIER_POINTER (original_name)[1] == '_'
10525 && strncmp (IDENTIFIER_POINTER (original_name)+2, "builtin_", 8) == 0))
8926095f 10526 /* Plain overloading: will not be grok'd by grokclassfn. */
386b8a85
JM
10527 if (name_mangling_version < 1
10528 || TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10529 declarator = build_decl_overload (dname, TYPE_ARG_TYPES (type), 0);
8d08fdba
MS
10530 }
10531 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
10532 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
10533 TREE_TYPE (type), TYPE_ARG_TYPES (type));
10534
eb66be0e 10535 /* Record presence of `static'. */
faae18ab 10536 publicp = (ctype != NULL_TREE
a9aedbc2 10537 || RIDBIT_SETP (RID_EXTERN, specbits)
eb66be0e 10538 || !RIDBIT_SETP (RID_STATIC, specbits));
8d08fdba 10539
386b8a85 10540 decl = grokfndecl (ctype, type, original_name, declarator,
f30432d7 10541 virtualp, flags, quals, raises, attrlist,
75650646 10542 1, friendp,
386b8a85 10543 publicp, inlinep, funcdef_flag,
2c73f9f5 10544 template_count, in_namespace);
f0e01782
MS
10545 if (decl == NULL_TREE)
10546 return NULL_TREE;
8d08fdba 10547
f2e48b67
BK
10548 /* Among other times, could occur from check_explicit_specialization
10549 returning an error_mark_node. */
10550 if (decl == error_mark_node)
10551 return error_mark_node;
10552
386b8a85 10553 if (ctype == NULL_TREE && DECL_LANGUAGE (decl) != lang_c
71cc65bd 10554 && (! DECL_USE_TEMPLATE (decl) ||
386b8a85 10555 name_mangling_version < 1))
30394414 10556 DECL_ASSEMBLER_NAME (decl) = declarator;
386b8a85 10557
8d08fdba
MS
10558 if (staticp == 1)
10559 {
10560 int illegal_static = 0;
10561
10562 /* Don't allow a static member function in a class, and forbid
10563 declaring main to be static. */
10564 if (TREE_CODE (type) == METHOD_TYPE)
10565 {
00595019 10566 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
8d08fdba
MS
10567 illegal_static = 1;
10568 }
8d08fdba
MS
10569 else if (current_function_decl)
10570 {
10571 /* FIXME need arm citation */
10572 error ("cannot declare static function inside another function");
10573 illegal_static = 1;
10574 }
10575
10576 if (illegal_static)
10577 {
10578 staticp = 0;
10579 RIDBIT_RESET (RID_STATIC, specbits);
10580 }
10581 }
8d08fdba
MS
10582 }
10583 else
10584 {
10585 /* It's a variable. */
10586
db5ae43f
MS
10587 if (decl_context == CATCHPARM)
10588 {
10589 if (ctype)
10590 {
10591 ctype = NULL_TREE;
10592 error ("cannot use `::' in parameter declaration");
10593 }
10594
10595 /* A parameter declared as an array of T is really a pointer to T.
10596 One declared as a function is really a pointer to a function.
10597 One declared as a member is really a pointer to member. */
10598
10599 if (TREE_CODE (type) == ARRAY_TYPE)
10600 {
e92cc029
MS
10601 /* Transfer const-ness of array into that of type
10602 pointed to. */
db5ae43f
MS
10603 type = build_pointer_type
10604 (cp_build_type_variant (TREE_TYPE (type), constp, volatilep));
10605 volatilep = constp = 0;
10606 }
10607 else if (TREE_CODE (type) == FUNCTION_TYPE)
10608 type = build_pointer_type (type);
10609 else if (TREE_CODE (type) == OFFSET_TYPE)
10610 type = build_pointer_type (type);
10611 }
10612
8d08fdba 10613 /* An uninitialized decl with `extern' is a reference. */
2c73f9f5
ML
10614 decl = grokvardecl (type, declarator, &specbits,
10615 initialized, constp, in_namespace);
8d08fdba
MS
10616 bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
10617 inlinep, friendp, raises != NULL_TREE);
10618
10619 if (ctype)
10620 {
f0e01782 10621 DECL_CONTEXT (decl) = ctype;
8d08fdba
MS
10622 if (staticp == 1)
10623 {
f30432d7 10624 cp_pedwarn ("static member `%D' re-declared as static", decl);
8d08fdba
MS
10625 staticp = 0;
10626 RIDBIT_RESET (RID_STATIC, specbits);
10627 }
b7484fbe
MS
10628 if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
10629 {
10630 cp_error ("static member `%D' declared `register'", decl);
10631 RIDBIT_RESET (RID_REGISTER, specbits);
10632 }
f30432d7 10633 if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
8d08fdba 10634 {
f30432d7
MS
10635 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
10636 decl);
8d08fdba
MS
10637 RIDBIT_RESET (RID_EXTERN, specbits);
10638 }
10639 }
10640 }
10641
10642 if (RIDBIT_SETP (RID_MUTABLE, specbits))
10643 {
10644 error ("`%s' cannot be declared mutable", name);
10645 }
10646
10647 /* Record `register' declaration for warnings on &
10648 and in case doing stupid register allocation. */
10649
10650 if (RIDBIT_SETP (RID_REGISTER, specbits))
10651 DECL_REGISTER (decl) = 1;
10652
8926095f
MS
10653 if (RIDBIT_SETP (RID_EXTERN, specbits))
10654 DECL_THIS_EXTERN (decl) = 1;
10655
faae18ab
MS
10656 if (RIDBIT_SETP (RID_STATIC, specbits))
10657 DECL_THIS_STATIC (decl) = 1;
10658
8d08fdba
MS
10659 /* Record constancy and volatility. */
10660
10661 if (constp)
10662 TREE_READONLY (decl) = TREE_CODE (type) != REFERENCE_TYPE;
10663 if (volatilep)
10664 {
10665 TREE_SIDE_EFFECTS (decl) = 1;
10666 TREE_THIS_VOLATILE (decl) = 1;
10667 }
10668
10669 return decl;
10670 }
10671}
10672\f
10673/* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
10674 An empty exprlist is a parmlist. An exprlist which
10675 contains only identifiers at the global level
10676 is a parmlist. Otherwise, it is an exprlist. */
e92cc029 10677
8d08fdba
MS
10678int
10679parmlist_is_exprlist (exprs)
10680 tree exprs;
10681{
10682 if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
10683 return 0;
10684
a9aedbc2 10685 if (toplevel_bindings_p ())
8d08fdba
MS
10686 {
10687 /* At the global level, if these are all identifiers,
10688 then it is a parmlist. */
10689 while (exprs)
10690 {
10691 if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
10692 return 1;
10693 exprs = TREE_CHAIN (exprs);
10694 }
10695 return 0;
10696 }
10697 return 1;
10698}
10699
10700/* Subroutine of `grokparms'. In a fcn definition, arg types must
10701 be complete.
10702
10703 C++: also subroutine of `start_function'. */
e92cc029 10704
8d08fdba
MS
10705static void
10706require_complete_types_for_parms (parms)
10707 tree parms;
10708{
5566b478
MS
10709 if (processing_template_decl)
10710 return;
10711
8d08fdba
MS
10712 while (parms)
10713 {
10714 tree type = TREE_TYPE (parms);
5566b478 10715 if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
8d08fdba
MS
10716 {
10717 if (DECL_NAME (parms))
10718 error ("parameter `%s' has incomplete type",
10719 IDENTIFIER_POINTER (DECL_NAME (parms)));
10720 else
10721 error ("parameter has incomplete type");
10722 TREE_TYPE (parms) = error_mark_node;
10723 }
10724#if 0
10725 /* If the arg types are incomplete in a declaration,
10726 they must include undefined tags.
10727 These tags can never be defined in the scope of the declaration,
10728 so the types can never be completed,
10729 and no call can be compiled successfully. */
10730 /* This is not the right behavior for C++, but not having
10731 it is also probably wrong. */
10732 else
10733 {
10734 /* Now warn if is a pointer to an incomplete type. */
10735 while (TREE_CODE (type) == POINTER_TYPE
10736 || TREE_CODE (type) == REFERENCE_TYPE)
10737 type = TREE_TYPE (type);
10738 type = TYPE_MAIN_VARIANT (type);
10739 if (TYPE_SIZE (type) == NULL_TREE)
10740 {
10741 if (DECL_NAME (parm) != NULL_TREE)
10742 warning ("parameter `%s' points to incomplete type",
10743 IDENTIFIER_POINTER (DECL_NAME (parm)));
10744 else
10745 warning ("parameter points to incomplete type");
10746 }
10747 }
10748#endif
10749 parms = TREE_CHAIN (parms);
10750 }
10751}
10752
10753/* Decode the list of parameter types for a function type.
10754 Given the list of things declared inside the parens,
10755 return a list of types.
10756
10757 The list we receive can have three kinds of elements:
10758 an IDENTIFIER_NODE for names given without types,
10759 a TREE_LIST node for arguments given as typespecs or names with typespecs,
10760 or void_type_node, to mark the end of an argument list
10761 when additional arguments are not permitted (... was not used).
10762
10763 FUNCDEF_FLAG is nonzero for a function definition, 0 for
10764 a mere declaration. A nonempty identifier-list gets an error message
10765 when FUNCDEF_FLAG is zero.
10766 If FUNCDEF_FLAG is 1, then parameter types must be complete.
10767 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
10768
10769 If all elements of the input list contain types,
10770 we return a list of the types.
10771 If all elements contain no type (except perhaps a void_type_node
10772 at the end), we return a null list.
10773 If some have types and some do not, it is an error, and we
10774 return a null list.
10775
10776 Also set last_function_parms to either
10777 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
10778 A list of names is converted to a chain of PARM_DECLs
10779 by store_parm_decls so that ultimately it is always a chain of decls.
10780
10781 Note that in C++, parameters can take default values. These default
10782 values are in the TREE_PURPOSE field of the TREE_LIST. It is
10783 an error to specify default values which are followed by parameters
10784 that have no default values, or an ELLIPSES. For simplicities sake,
10785 only parameters which are specified with their types can take on
10786 default values. */
10787
10788static tree
10789grokparms (first_parm, funcdef_flag)
10790 tree first_parm;
10791 int funcdef_flag;
10792{
10793 tree result = NULL_TREE;
10794 tree decls = NULL_TREE;
10795
10796 if (first_parm != NULL_TREE
10797 && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
10798 {
10799 if (! funcdef_flag)
10800 pedwarn ("parameter names (without types) in function declaration");
10801 last_function_parms = first_parm;
10802 return NULL_TREE;
10803 }
10804 else if (first_parm != NULL_TREE
10805 && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
a1774733 10806 && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
8d08fdba
MS
10807 my_friendly_abort (145);
10808 else
10809 {
10810 /* Types were specified. This is a list of declarators
10811 each represented as a TREE_LIST node. */
10812 register tree parm, chain;
5566b478 10813 int any_init = 0, any_error = 0;
8d08fdba
MS
10814
10815 if (first_parm != NULL_TREE)
10816 {
10817 tree last_result = NULL_TREE;
10818 tree last_decl = NULL_TREE;
10819
10820 for (parm = first_parm; parm != NULL_TREE; parm = chain)
10821 {
a703fb38 10822 tree type = NULL_TREE, list_node = parm;
8d08fdba
MS
10823 register tree decl = TREE_VALUE (parm);
10824 tree init = TREE_PURPOSE (parm);
10825
10826 chain = TREE_CHAIN (parm);
10827 /* @@ weak defense against parse errors. */
a1774733
BK
10828 if (TREE_CODE (decl) != VOID_TYPE
10829 && TREE_CODE (decl) != TREE_LIST)
8d08fdba
MS
10830 {
10831 /* Give various messages as the need arises. */
10832 if (TREE_CODE (decl) == STRING_CST)
fc378698 10833 cp_error ("invalid string constant `%E'", decl);
8d08fdba
MS
10834 else if (TREE_CODE (decl) == INTEGER_CST)
10835 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
10836 continue;
10837 }
10838
a1774733 10839 if (TREE_CODE (decl) != VOID_TYPE)
8d08fdba 10840 {
8d08fdba
MS
10841 decl = grokdeclarator (TREE_VALUE (decl),
10842 TREE_PURPOSE (decl),
f30432d7 10843 PARM, init != NULL_TREE,
c11b6f21 10844 NULL_TREE);
8d08fdba
MS
10845 if (! decl)
10846 continue;
10847 type = TREE_TYPE (decl);
a1774733 10848 if (TREE_CODE (type) == VOID_TYPE)
8d08fdba
MS
10849 decl = void_type_node;
10850 else if (TREE_CODE (type) == METHOD_TYPE)
10851 {
10852 if (DECL_NAME (decl))
fc378698 10853 /* Cannot use the decl here because
8d08fdba 10854 we don't have DECL_CONTEXT set up yet. */
fc378698
MS
10855 cp_error ("parameter `%D' invalidly declared method type",
10856 DECL_NAME (decl));
8d08fdba
MS
10857 else
10858 error ("parameter invalidly declared method type");
10859 type = build_pointer_type (type);
10860 TREE_TYPE (decl) = type;
10861 }
10862 else if (TREE_CODE (type) == OFFSET_TYPE)
10863 {
10864 if (DECL_NAME (decl))
fc378698
MS
10865 cp_error ("parameter `%D' invalidly declared offset type",
10866 DECL_NAME (decl));
8d08fdba
MS
10867 else
10868 error ("parameter invalidly declared offset type");
10869 type = build_pointer_type (type);
10870 TREE_TYPE (decl) = type;
10871 }
10872 else if (TREE_CODE (type) == RECORD_TYPE
10873 && TYPE_LANG_SPECIFIC (type)
10874 && CLASSTYPE_ABSTRACT_VIRTUALS (type))
10875 {
10876 abstract_virtuals_error (decl, type);
2c73f9f5 10877 any_error = 1; /* Seems like a good idea. */
8d08fdba
MS
10878 }
10879 else if (TREE_CODE (type) == RECORD_TYPE
10880 && TYPE_LANG_SPECIFIC (type)
10881 && IS_SIGNATURE (type))
10882 {
10883 signature_error (decl, type);
2c73f9f5 10884 any_error = 1; /* Seems like a good idea. */
8d08fdba 10885 }
482b883f
JM
10886 else if (POINTER_TYPE_P (type))
10887 {
10888 tree t = type;
10889 while (POINTER_TYPE_P (t)
10890 || (TREE_CODE (t) == ARRAY_TYPE
10891 && TYPE_DOMAIN (t) != NULL_TREE))
10892 t = TREE_TYPE (t);
10893 if (TREE_CODE (t) == ARRAY_TYPE)
10894 cp_error ("parameter type `%T' includes pointer to array of unknown bound",
10895 type);
10896 }
8d08fdba
MS
10897 }
10898
a1774733 10899 if (TREE_CODE (decl) == VOID_TYPE)
8d08fdba
MS
10900 {
10901 if (result == NULL_TREE)
10902 {
10903 result = void_list_node;
10904 last_result = result;
10905 }
10906 else
10907 {
10908 TREE_CHAIN (last_result) = void_list_node;
10909 last_result = void_list_node;
10910 }
8d08fdba
MS
10911 if (chain
10912 && (chain != void_list_node || TREE_CHAIN (chain)))
10913 error ("`void' in parameter list must be entire list");
10914 break;
10915 }
10916
10917 /* Since there is a prototype, args are passed in their own types. */
10918 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
10919#ifdef PROMOTE_PROTOTYPES
10920 if ((TREE_CODE (type) == INTEGER_TYPE
10921 || TREE_CODE (type) == ENUMERAL_TYPE)
10922 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
10923 DECL_ARG_TYPE (decl) = integer_type_node;
10924#endif
10925 if (!any_error)
10926 {
10927 if (init)
10928 {
10929 any_init++;
10930 if (TREE_CODE (init) == SAVE_EXPR)
10931 PARM_DECL_EXPR (init) = 1;
5156628f 10932 else if (processing_template_decl)
5566b478 10933 ;
42976354
BK
10934 /* Unparsed default arg from in-class decl. */
10935 else if (TREE_CODE (init) == DEFAULT_ARG)
10936 ;
b7484fbe
MS
10937 else if (TREE_CODE (init) == VAR_DECL
10938 || TREE_CODE (init) == PARM_DECL)
8d08fdba
MS
10939 {
10940 if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init)))
10941 {
10942 /* ``Local variables may not be used in default
10943 argument expressions.'' dpANSI C++ 8.2.6 */
10944 /* If extern int i; within a function is not
10945 considered a local variable, then this code is
e92cc029 10946 wrong. */
8d08fdba
MS
10947 cp_error ("local variable `%D' may not be used as a default argument", init);
10948 any_error = 1;
10949 }
10950 else if (TREE_READONLY_DECL_P (init))
10951 init = decl_constant_value (init);
10952 }
10953 else
10954 init = require_instantiated_type (type, init, integer_zero_node);
5156628f 10955 if (! processing_template_decl
347b5292 10956 && init != error_mark_node
42976354 10957 && TREE_CODE (init) != DEFAULT_ARG
c11b6f21 10958 && ! can_convert_arg (type, TREE_TYPE (init), init))
c73964b2
MS
10959 cp_pedwarn ("invalid type `%T' for default argument to `%#D'",
10960 TREE_TYPE (init), decl);
8d08fdba
MS
10961 }
10962 }
10963 else
10964 init = NULL_TREE;
10965
10966 if (decls == NULL_TREE)
10967 {
10968 decls = decl;
10969 last_decl = decls;
10970 }
10971 else
10972 {
10973 TREE_CHAIN (last_decl) = decl;
10974 last_decl = decl;
10975 }
66f2e88d 10976 if (! current_function_decl && TREE_PERMANENT (list_node))
8d08fdba
MS
10977 {
10978 TREE_PURPOSE (list_node) = init;
10979 TREE_VALUE (list_node) = type;
10980 TREE_CHAIN (list_node) = NULL_TREE;
10981 }
10982 else
10983 list_node = saveable_tree_cons (init, type, NULL_TREE);
10984 if (result == NULL_TREE)
10985 {
10986 result = list_node;
10987 last_result = result;
10988 }
10989 else
10990 {
10991 TREE_CHAIN (last_result) = list_node;
10992 last_result = list_node;
10993 }
10994 }
10995 if (last_result)
10996 TREE_CHAIN (last_result) = NULL_TREE;
10997 /* If there are no parameters, and the function does not end
10998 with `...', then last_decl will be NULL_TREE. */
10999 if (last_decl != NULL_TREE)
11000 TREE_CHAIN (last_decl) = NULL_TREE;
11001 }
11002 }
11003
11004 last_function_parms = decls;
11005
11006 /* In a fcn definition, arg types must be complete. */
11007 if (funcdef_flag > 0)
11008 require_complete_types_for_parms (last_function_parms);
11009
11010 return result;
11011}
42976354
BK
11012
11013/* Called from the parser to update an element of TYPE_ARG_TYPES for some
11014 FUNCTION_TYPE with the newly parsed version of its default argument, which
11015 was previously digested as text. See snarf_defarg et al in lex.c. */
11016
11017void
11018replace_defarg (arg, init)
11019 tree arg, init;
11020{
aa5f3bad 11021 if (! processing_template_decl
42976354
BK
11022 && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11023 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11024 TREE_TYPE (init), TREE_VALUE (arg));
11025 TREE_PURPOSE (arg) = init;
11026}
8d08fdba 11027\f
c11b6f21
MS
11028int
11029copy_args_p (d)
11030 tree d;
11031{
11032 tree t = FUNCTION_ARG_CHAIN (d);
67437d5b
JM
11033 if (DECL_CONSTRUCTOR_P (d)
11034 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11035 t = TREE_CHAIN (t);
c11b6f21
MS
11036 if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11037 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11038 == DECL_CLASS_CONTEXT (d))
11039 && (TREE_CHAIN (t) == NULL_TREE
11040 || TREE_CHAIN (t) == void_list_node
11041 || TREE_PURPOSE (TREE_CHAIN (t))))
11042 return 1;
11043 return 0;
11044}
11045
8d08fdba
MS
11046/* These memoizing functions keep track of special properties which
11047 a class may have. `grok_ctor_properties' notices whether a class
11048 has a constructor of the form X(X&), and also complains
11049 if the class has a constructor of the form X(X).
11050 `grok_op_properties' takes notice of the various forms of
11051 operator= which are defined, as well as what sorts of type conversion
11052 may apply. Both functions take a FUNCTION_DECL as an argument. */
e92cc029 11053
a0a33927 11054int
8d08fdba
MS
11055grok_ctor_properties (ctype, decl)
11056 tree ctype, decl;
11057{
11058 tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11059 tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11060
11061 /* When a type has virtual baseclasses, a magical first int argument is
11062 added to any ctor so we can tell if the class has been initialized
11063 yet. This could screw things up in this function, so we deliberately
11064 ignore the leading int if we're in that situation. */
711734a9 11065 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
8d08fdba 11066 {
711734a9
JM
11067 my_friendly_assert (parmtypes
11068 && TREE_VALUE (parmtypes) == integer_type_node,
11069 980529);
8d08fdba
MS
11070 parmtypes = TREE_CHAIN (parmtypes);
11071 parmtype = TREE_VALUE (parmtypes);
11072 }
11073
11074 if (TREE_CODE (parmtype) == REFERENCE_TYPE
0b41abe6
JM
11075 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11076 && (TREE_CHAIN (parmtypes) == NULL_TREE
8d08fdba 11077 || TREE_CHAIN (parmtypes) == void_list_node
0b41abe6
JM
11078 || TREE_PURPOSE (TREE_CHAIN (parmtypes))))
11079 {
11080 TYPE_HAS_INIT_REF (ctype) = 1;
11081 if (TYPE_READONLY (TREE_TYPE (parmtype)))
11082 TYPE_HAS_CONST_INIT_REF (ctype) = 1;
8d08fdba 11083 }
0b41abe6
JM
11084 else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11085 && TREE_CHAIN (parmtypes) != NULL_TREE
11086 && TREE_CHAIN (parmtypes) == void_list_node)
8d08fdba 11087 {
0b41abe6
JM
11088 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11089 ctype, ctype);
11090 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11091 return 0;
8d08fdba
MS
11092 }
11093 else if (TREE_CODE (parmtype) == VOID_TYPE
11094 || TREE_PURPOSE (parmtypes) != NULL_TREE)
11095 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
a0a33927
MS
11096
11097 return 1;
8d08fdba
MS
11098}
11099
11100/* An operator with this name can be either unary or binary. */
e92cc029 11101
a28e3c7f
MS
11102static int
11103ambi_op_p (name)
8d08fdba
MS
11104 tree name;
11105{
11106 return (name == ansi_opname [(int) INDIRECT_REF]
11107 || name == ansi_opname [(int) ADDR_EXPR]
11108 || name == ansi_opname [(int) NEGATE_EXPR]
11109 || name == ansi_opname[(int) POSTINCREMENT_EXPR]
11110 || name == ansi_opname[(int) POSTDECREMENT_EXPR]
11111 || name == ansi_opname [(int) CONVERT_EXPR]);
11112}
11113
11114/* An operator with this name can only be unary. */
e92cc029 11115
a28e3c7f
MS
11116static int
11117unary_op_p (name)
8d08fdba
MS
11118 tree name;
11119{
11120 return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
11121 || name == ansi_opname [(int) BIT_NOT_EXPR]
11122 || name == ansi_opname [(int) COMPONENT_REF]
11123 || OPERATOR_TYPENAME_P (name));
11124}
11125
11126/* Do a little sanity-checking on how they declared their operator. */
e92cc029 11127
5566b478 11128void
8d08fdba
MS
11129grok_op_properties (decl, virtualp, friendp)
11130 tree decl;
11131 int virtualp, friendp;
11132{
11133 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11134 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11135 tree name = DECL_NAME (decl);
8d08fdba 11136
a28e3c7f
MS
11137 if (current_class_type == NULL_TREE)
11138 friendp = 1;
8d08fdba 11139
a28e3c7f
MS
11140 if (! friendp)
11141 {
11142 if (name == ansi_opname[(int) MODIFY_EXPR])
11143 TYPE_HAS_ASSIGNMENT (current_class_type) = 1;
11144 else if (name == ansi_opname[(int) CALL_EXPR])
11145 TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
11146 else if (name == ansi_opname[(int) ARRAY_REF])
11147 TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
11148 else if (name == ansi_opname[(int) COMPONENT_REF]
11149 || name == ansi_opname[(int) MEMBER_REF])
11150 TYPE_OVERLOADS_ARROW (current_class_type) = 1;
11151 else if (name == ansi_opname[(int) NEW_EXPR])
11152 TYPE_GETS_NEW (current_class_type) |= 1;
11153 else if (name == ansi_opname[(int) DELETE_EXPR])
11154 TYPE_GETS_DELETE (current_class_type) |= 1;
11155 else if (name == ansi_opname[(int) VEC_NEW_EXPR])
11156 TYPE_GETS_NEW (current_class_type) |= 2;
11157 else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
11158 TYPE_GETS_DELETE (current_class_type) |= 2;
11159 }
11160
11161 if (name == ansi_opname[(int) NEW_EXPR]
11162 || name == ansi_opname[(int) VEC_NEW_EXPR])
8d08fdba 11163 {
8d08fdba
MS
11164 /* When the compiler encounters the definition of A::operator new, it
11165 doesn't look at the class declaration to find out if it's static. */
a28e3c7f 11166 if (methodp)
700f8a87 11167 revert_static_member_fn (&decl, NULL, NULL);
8d08fdba
MS
11168
11169 /* Take care of function decl if we had syntax errors. */
11170 if (argtypes == NULL_TREE)
beb53fb8
JM
11171 TREE_TYPE (decl)
11172 = build_function_type (ptr_type_node,
11173 hash_tree_chain (integer_type_node,
11174 void_list_node));
8d08fdba 11175 else
a28e3c7f 11176 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
8d08fdba 11177 }
a28e3c7f
MS
11178 else if (name == ansi_opname[(int) DELETE_EXPR]
11179 || name == ansi_opname[(int) VEC_DELETE_EXPR])
8d08fdba 11180 {
a28e3c7f 11181 if (methodp)
700f8a87 11182 revert_static_member_fn (&decl, NULL, NULL);
8d08fdba
MS
11183
11184 if (argtypes == NULL_TREE)
beb53fb8
JM
11185 TREE_TYPE (decl)
11186 = build_function_type (void_type_node,
11187 hash_tree_chain (ptr_type_node,
11188 void_list_node));
8d08fdba 11189 else
a28e3c7f
MS
11190 {
11191 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11192
11193 if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
11194 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
11195 != void_list_node))
11196 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
11197 }
8d08fdba 11198 }
8d08fdba
MS
11199 else
11200 {
11201 /* An operator function must either be a non-static member function
11202 or have at least one parameter of a class, a reference to a class,
11203 an enumeration, or a reference to an enumeration. 13.4.0.6 */
700f8a87 11204 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
8d08fdba
MS
11205 {
11206 if (OPERATOR_TYPENAME_P (name)
11207 || name == ansi_opname[(int) CALL_EXPR]
11208 || name == ansi_opname[(int) MODIFY_EXPR]
11209 || name == ansi_opname[(int) COMPONENT_REF]
11210 || name == ansi_opname[(int) ARRAY_REF])
11211 cp_error ("`%D' must be a nonstatic member function", decl);
11212 else
11213 {
11214 tree p = argtypes;
11215
700f8a87
MS
11216 if (DECL_STATIC_FUNCTION_P (decl))
11217 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
11218
8d08fdba 11219 if (p)
a1774733 11220 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
8d08fdba
MS
11221 {
11222 tree arg = TREE_VALUE (p);
11223 if (TREE_CODE (arg) == REFERENCE_TYPE)
11224 arg = TREE_TYPE (arg);
11225
11226 /* This lets bad template code slip through. */
11227 if (IS_AGGR_TYPE (arg)
11228 || TREE_CODE (arg) == ENUMERAL_TYPE
73b0fce8
KL
11229 || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
11230 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
8d08fdba
MS
11231 goto foundaggr;
11232 }
11233 cp_error
11234 ("`%D' must have an argument of class or enumerated type",
11235 decl);
11236 foundaggr:
11237 ;
11238 }
11239 }
11240
277294d7 11241 if (name == ansi_opname[(int) CALL_EXPR])
2c73f9f5 11242 return; /* No restrictions on args. */
8d08fdba 11243
9a3b49ac 11244 if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
a0a33927
MS
11245 {
11246 tree t = TREE_TYPE (name);
11247 if (TREE_CODE (t) == VOID_TYPE)
11248 pedwarn ("void is not a valid type conversion operator");
11249 else if (! friendp)
11250 {
11251 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11252 char *what = 0;
11253 if (ref)
11254 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11255
11256 if (t == current_class_type)
11257 what = "the same type";
9a3b49ac 11258 /* Don't force t to be complete here. */
a0a33927 11259 else if (IS_AGGR_TYPE (t)
9a3b49ac 11260 && TYPE_SIZE (t)
a0a33927
MS
11261 && DERIVED_FROM_P (t, current_class_type))
11262 what = "a base class";
11263
11264 if (what)
11265 warning ("conversion to %s%s will never use a type conversion operator",
11266 ref ? "a reference to " : "", what);
11267 }
11268 }
11269
8d08fdba
MS
11270 if (name == ansi_opname[(int) MODIFY_EXPR])
11271 {
11272 tree parmtype;
11273
11274 if (list_length (argtypes) != 3 && methodp)
11275 {
11276 cp_error ("`%D' must take exactly one argument", decl);
11277 return;
11278 }
11279 parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
11280
f0e01782 11281 if (copy_assignment_arg_p (parmtype, virtualp)
a28e3c7f 11282 && ! friendp)
8d08fdba
MS
11283 {
11284 TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
f0e01782
MS
11285 if (TREE_CODE (parmtype) != REFERENCE_TYPE
11286 || TYPE_READONLY (TREE_TYPE (parmtype)))
8d08fdba
MS
11287 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
11288 }
11289 }
11290 else if (name == ansi_opname[(int) COND_EXPR])
11291 {
11292 /* 13.4.0.3 */
11293 pedwarn ("ANSI C++ prohibits overloading operator ?:");
11294 if (list_length (argtypes) != 4)
11295 cp_error ("`%D' must take exactly three arguments", decl);
11296 }
11297 else if (ambi_op_p (name))
11298 {
11299 if (list_length (argtypes) == 2)
11300 /* prefix */;
11301 else if (list_length (argtypes) == 3)
11302 {
11303 if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
11304 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
5156628f 11305 && ! processing_template_decl
8d08fdba
MS
11306 && TREE_VALUE (TREE_CHAIN (argtypes)) != integer_type_node)
11307 {
11308 if (methodp)
11309 cp_error ("postfix `%D' must take `int' as its argument",
11310 decl);
11311 else
11312 cp_error
11313 ("postfix `%D' must take `int' as its second argument",
11314 decl);
11315 }
11316 }
11317 else
11318 {
11319 if (methodp)
11320 cp_error ("`%D' must take either zero or one argument", decl);
11321 else
11322 cp_error ("`%D' must take either one or two arguments", decl);
11323 }
824b9a4c
MS
11324
11325 /* More Effective C++ rule 6. */
eb448459 11326 if (warn_ecpp
824b9a4c
MS
11327 && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
11328 || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
11329 {
11330 tree arg = TREE_VALUE (argtypes);
11331 tree ret = TREE_TYPE (TREE_TYPE (decl));
11332 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
11333 arg = TREE_TYPE (arg);
11334 arg = TYPE_MAIN_VARIANT (arg);
11335 if (list_length (argtypes) == 2)
11336 {
11337 if (TREE_CODE (ret) != REFERENCE_TYPE
11338 || !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
11339 arg, 1))
11340 cp_warning ("prefix `%D' should return `%T'", decl,
11341 build_reference_type (arg));
11342 }
11343 else
11344 {
11345 if (!comptypes (TYPE_MAIN_VARIANT (ret), arg, 1))
11346 cp_warning ("postfix `%D' should return `%T'", decl, arg);
11347 }
11348 }
8d08fdba
MS
11349 }
11350 else if (unary_op_p (name))
11351 {
11352 if (list_length (argtypes) != 2)
11353 {
11354 if (methodp)
11355 cp_error ("`%D' must take `void'", decl);
11356 else
11357 cp_error ("`%D' must take exactly one argument", decl);
11358 }
11359 }
11360 else /* if (binary_op_p (name)) */
11361 {
11362 if (list_length (argtypes) != 3)
11363 {
11364 if (methodp)
11365 cp_error ("`%D' must take exactly one argument", decl);
11366 else
11367 cp_error ("`%D' must take exactly two arguments", decl);
11368 }
824b9a4c
MS
11369
11370 /* More Effective C++ rule 7. */
eb448459 11371 if (warn_ecpp
824b9a4c
MS
11372 && (name == ansi_opname [TRUTH_ANDIF_EXPR]
11373 || name == ansi_opname [TRUTH_ORIF_EXPR]
11374 || name == ansi_opname [COMPOUND_EXPR]))
11375 cp_warning ("user-defined `%D' always evaluates both arguments",
11376 decl);
11377 }
11378
11379 /* Effective C++ rule 23. */
eb448459 11380 if (warn_ecpp
824b9a4c
MS
11381 && list_length (argtypes) == 3
11382 && (name == ansi_opname [PLUS_EXPR]
11383 || name == ansi_opname [MINUS_EXPR]
11384 || name == ansi_opname [TRUNC_DIV_EXPR]
11385 || name == ansi_opname [MULT_EXPR])
11386 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
11387 cp_warning ("`%D' should return by value", decl);
8d08fdba
MS
11388
11389 /* 13.4.0.8 */
11390 if (argtypes)
11391 for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
11392 if (TREE_PURPOSE (argtypes))
11393 {
11394 TREE_PURPOSE (argtypes) = NULL_TREE;
11395 if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
11396 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
11397 {
11398 if (pedantic)
11399 cp_pedwarn ("`%D' cannot have default arguments", decl);
11400 }
11401 else
11402 cp_error ("`%D' cannot have default arguments", decl);
11403 }
11404 }
11405}
11406\f
11407/* Get the struct, enum or union (CODE says which) with tag NAME.
11408 Define the tag as a forward-reference if it is not defined.
11409
11410 C++: If a class derivation is given, process it here, and report
11411 an error if multiple derivation declarations are not identical.
11412
11413 If this is a definition, come in through xref_tag and only look in
11414 the current frame for the name (since C++ allows new names in any
11415 scope.) */
11416
8d08fdba
MS
11417tree
11418xref_tag (code_type_node, name, binfo, globalize)
11419 tree code_type_node;
11420 tree name, binfo;
11421 int globalize;
11422{
11423 enum tag_types tag_code;
11424 enum tree_code code;
11425 int temp = 0;
8d08fdba
MS
11426 register tree ref, t;
11427 struct binding_level *b = inner_binding_level;
a80e4195 11428 int got_type = 0;
dc8263bc
JM
11429 tree attributes = NULL_TREE;
11430
11431 /* If we are called from the parser, code_type_node will sometimes be a
11432 TREE_LIST. This indicates that the user wrote
11433 "class __attribute__ ((foo)) bar". Extract the attributes so we can
11434 use them later. */
11435 if (TREE_CODE (code_type_node) == TREE_LIST)
11436 {
11437 attributes = TREE_PURPOSE (code_type_node);
11438 code_type_node = TREE_VALUE (code_type_node);
11439 }
8d08fdba
MS
11440
11441 tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
11442 switch (tag_code)
11443 {
11444 case record_type:
11445 case class_type:
8d08fdba
MS
11446 case signature_type:
11447 code = RECORD_TYPE;
8d08fdba
MS
11448 break;
11449 case union_type:
11450 code = UNION_TYPE;
8d08fdba
MS
11451 break;
11452 case enum_type:
11453 code = ENUMERAL_TYPE;
11454 break;
11455 default:
11456 my_friendly_abort (18);
11457 }
11458
11459 /* If a cross reference is requested, look up the type
11460 already defined for this tag and return it. */
be99da77
MS
11461 if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
11462 {
11463 t = name;
a80e4195
MS
11464 name = TYPE_IDENTIFIER (t);
11465 got_type = 1;
be99da77
MS
11466 }
11467 else
11468 t = IDENTIFIER_TYPE_VALUE (name);
73b0fce8
KL
11469 if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
11470 && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
a0a33927
MS
11471 t = NULL_TREE;
11472
8ccc31eb 11473 if (! globalize)
8d08fdba 11474 {
2450bb7d 11475 if (t && (TREE_CODE (t) == TEMPLATE_TYPE_PARM
73b0fce8 11476 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM))
ec255269 11477 {
2450bb7d
BK
11478 cp_error ("redeclaration of template type-parameter `%T'", name);
11479 cp_error_at (" previously declared here `%#D'",
11480 TEMPLATE_TYPE_DECL (t));
ec255269 11481 }
a80e4195 11482 if (t && TYPE_CONTEXT (t) && got_type)
8ccc31eb 11483 ref = t;
8d08fdba 11484 else
36a117a5
MM
11485 /* If we know we are defining this tag, only look it up in
11486 this scope and don't try to find it as a type. */
11487 ref = lookup_tag (code, name, b, 1);
8d08fdba
MS
11488 }
11489 else
11490 {
36a117a5
MM
11491 if (current_class_type
11492 && template_class_depth (current_class_type)
39c01e4c 11493 && PROCESSING_REAL_TEMPLATE_DECL_P ())
36a117a5
MM
11494 /* Since GLOBALIZE is non-zero, we are not looking at a
11495 definition of this tag. Since, in addition, we are currently
11496 processing a (member) template declaration of a template
11497 class, we don't want to do any lookup at all; consider:
11498
11499 template <class X>
11500 struct S1
11501
11502 template <class U>
11503 struct S2
11504 { template <class V>
11505 friend struct S1; };
11506
11507 Here, the S2::S1 declaration should not be confused with the
11508 outer declaration. In particular, the inner version should
11509 have a template parameter of level 2, not level 1. This
11510 would be particularly important if the member declaration
11511 were instead:
11512
11513 template <class V = U> friend struct S1;
11514
11515 say, when we should tsubst into `U' when instantiating S2. */
11516 ref = NULL_TREE;
11517 else
11518 {
11519 if (t)
11520 ref = t;
11521 else
11522 ref = lookup_tag (code, name, b, 0);
11523
11524 if (! ref)
11525 {
11526 /* Try finding it as a type declaration. If that wins,
11527 use it. */
11528 ref = lookup_name (name, 1);
11529
11530 if (ref != NULL_TREE
11531 && processing_template_decl
11532 && DECL_CLASS_TEMPLATE_P (ref)
11533 && template_class_depth (current_class_type) == 0)
11534 /* Since GLOBALIZE is true, we're declaring a global
6757edfe 11535 template, so we want this type. */
36a117a5 11536 ref = DECL_RESULT (ref);
6757edfe 11537
36a117a5
MM
11538 if (ref && TREE_CODE (ref) == TYPE_DECL
11539 && TREE_CODE (TREE_TYPE (ref)) == code)
11540 ref = TREE_TYPE (ref);
11541 else
11542 ref = NULL_TREE;
11543 }
8d08fdba
MS
11544 }
11545 }
11546
11547 push_obstacks_nochange ();
11548
11549 if (! ref)
11550 {
11551 /* If no such tag is yet defined, create a forward-reference node
11552 and record it as the "definition".
11553 When a real declaration of this type is found,
11554 the forward-reference will be altered into a real type. */
11555
11556 /* In C++, since these migrate into the global scope, we must
11557 build them on the permanent obstack. */
11558
11559 temp = allocation_temporary_p ();
11560 if (temp)
11561 end_temporary_allocation ();
11562
11563 if (code == ENUMERAL_TYPE)
11564 {
fc378698
MS
11565 cp_error ("use of enum `%#D' without previous declaration", name);
11566
8d08fdba
MS
11567 ref = make_node (ENUMERAL_TYPE);
11568
11569 /* Give the type a default layout like unsigned int
11570 to avoid crashing if it does not get defined. */
11571 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
11572 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
11573 TREE_UNSIGNED (ref) = 1;
11574 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
11575 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
11576 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
11577
11578 /* Enable us to recognize when a type is created in class context.
11579 To do nested classes correctly, this should probably be cleared
11580 out when we leave this classes scope. Currently this in only
11581 done in `start_enum'. */
11582
11583 pushtag (name, ref, globalize);
8d08fdba 11584 }
8d08fdba
MS
11585 else
11586 {
8d08fdba 11587 struct binding_level *old_b = class_binding_level;
8d08fdba
MS
11588
11589 ref = make_lang_type (code);
11590
8d08fdba
MS
11591 if (tag_code == signature_type)
11592 {
11593 SET_SIGNATURE (ref);
f376e137
MS
11594 /* Since a signature type will be turned into the type
11595 of signature tables, it's not only an interface. */
8d08fdba 11596 CLASSTYPE_INTERFACE_ONLY (ref) = 0;
f376e137
MS
11597 SET_CLASSTYPE_INTERFACE_KNOWN (ref);
11598 /* A signature doesn't have a vtable. */
00595019 11599 CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = 0;
8d08fdba
MS
11600 }
11601
8d08fdba
MS
11602#ifdef NONNESTED_CLASSES
11603 /* Class types don't nest the way enums do. */
11604 class_binding_level = (struct binding_level *)0;
11605#endif
11606 pushtag (name, ref, globalize);
11607 class_binding_level = old_b;
8d08fdba
MS
11608 }
11609 }
11610 else
11611 {
8d08fdba 11612 /* If it no longer looks like a nested type, make sure it's
30394414
JM
11613 in global scope.
11614 If it is not an IDENTIFIER, this is not a declaration */
2c73f9f5 11615 if (b->namespace_p && !class_binding_level
30394414
JM
11616 && TREE_CODE (name) == IDENTIFIER_NODE)
11617 {
2c73f9f5
ML
11618 if (IDENTIFIER_NAMESPACE_VALUE (name) == NULL_TREE)
11619 SET_IDENTIFIER_NAMESPACE_VALUE (name, TYPE_NAME (ref));
30394414 11620 }
7fe6899f
MM
11621
11622 if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
6757edfe 11623 redeclare_class_template (ref, current_template_parms);
8d08fdba
MS
11624 }
11625
11626 if (binfo)
8ccc31eb 11627 xref_basetypes (code_type_node, name, ref, binfo);
8d08fdba 11628
8d08fdba
MS
11629 /* Until the type is defined, tentatively accept whatever
11630 structure tag the user hands us. */
11631 if (TYPE_SIZE (ref) == NULL_TREE
11632 && ref != current_class_type
11633 /* Have to check this, in case we have contradictory tag info. */
11634 && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
11635 {
11636 if (tag_code == class_type)
11637 CLASSTYPE_DECLARED_CLASS (ref) = 1;
11638 else if (tag_code == record_type || tag_code == signature_type)
11639 CLASSTYPE_DECLARED_CLASS (ref) = 0;
11640 }
11641
11642 pop_obstacks ();
11643
dc8263bc
JM
11644 TREE_TYPE (ref) = attributes;
11645
8d08fdba
MS
11646 return ref;
11647}
8ccc31eb 11648
fc378698
MS
11649tree
11650xref_tag_from_type (old, id, globalize)
11651 tree old, id;
11652 int globalize;
11653{
11654 tree code_type_node;
11655
11656 if (TREE_CODE (old) == RECORD_TYPE)
11657 code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
11658 ? class_type_node : record_type_node);
11659 else
11660 code_type_node = union_type_node;
11661
11662 if (id == NULL_TREE)
11663 id = TYPE_IDENTIFIER (old);
11664
11665 return xref_tag (code_type_node, id, NULL_TREE, globalize);
11666}
11667
8ccc31eb
MS
11668void
11669xref_basetypes (code_type_node, name, ref, binfo)
11670 tree code_type_node;
11671 tree name, ref;
11672 tree binfo;
11673{
11674 /* In the declaration `A : X, Y, ... Z' we mark all the types
11675 (A, X, Y, ..., Z) so we can check for duplicates. */
11676 tree binfos;
11677 int i, len;
11678 enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
11679
11680 if (tag_code == union_type)
11681 {
11682 cp_error ("derived union `%T' invalid", ref);
11683 return;
11684 }
11685
11686 len = list_length (binfo);
11687 push_obstacks (TYPE_OBSTACK (ref), TYPE_OBSTACK (ref));
11688
11689 SET_CLASSTYPE_MARKED (ref);
11690 BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
11691
11692 for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
11693 {
11694 /* The base of a derived struct is public by default. */
11695 int via_public
be99da77
MS
11696 = (TREE_PURPOSE (binfo) == access_public_node
11697 || TREE_PURPOSE (binfo) == access_public_virtual_node
8ccc31eb 11698 || (tag_code != class_type
be99da77
MS
11699 && (TREE_PURPOSE (binfo) == access_default_node
11700 || TREE_PURPOSE (binfo) == access_default_virtual_node)));
d8b55a76
JM
11701 int via_protected
11702 = (TREE_PURPOSE (binfo) == access_protected_node
11703 || TREE_PURPOSE (binfo) == access_protected_virtual_node);
8ccc31eb 11704 int via_virtual
be99da77 11705 = (TREE_PURPOSE (binfo) == access_private_virtual_node
d8b55a76 11706 || TREE_PURPOSE (binfo) == access_protected_virtual_node
be99da77
MS
11707 || TREE_PURPOSE (binfo) == access_public_virtual_node
11708 || TREE_PURPOSE (binfo) == access_default_virtual_node);
11709 tree basetype = TREE_VALUE (binfo);
8ccc31eb
MS
11710 tree base_binfo;
11711
8ccc31eb
MS
11712 if (basetype && TREE_CODE (basetype) == TYPE_DECL)
11713 basetype = TREE_TYPE (basetype);
5566b478
MS
11714 if (!basetype
11715 || (TREE_CODE (basetype) != RECORD_TYPE
a80e4195 11716 && TREE_CODE (basetype) != TYPENAME_TYPE
73b0fce8
KL
11717 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
11718 && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
8ccc31eb
MS
11719 {
11720 cp_error ("base type `%T' fails to be a struct or class type",
11721 TREE_VALUE (binfo));
11722 continue;
11723 }
2b9dc906 11724
11b5139c 11725 GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
2b9dc906 11726
8ccc31eb 11727#if 1
8adf5b5e
JM
11728 /* This code replaces similar code in layout_basetypes.
11729 We put the complete_type first for implicit `typename'. */
2b9dc906
JM
11730 if (TYPE_SIZE (complete_type (basetype)) == NULL_TREE
11731 && ! (current_template_parms && uses_template_parms (basetype)))
8ccc31eb
MS
11732 {
11733 cp_error ("base class `%T' has incomplete type", basetype);
11734 continue;
11735 }
11736#endif
11737 else
11738 {
11739 if (CLASSTYPE_MARKED (basetype))
11740 {
11741 if (basetype == ref)
11742 cp_error ("recursive type `%T' undefined", basetype);
11743 else
11744 cp_error ("duplicate base type `%T' invalid", basetype);
11745 continue;
11746 }
11747
eff71ab0
PB
11748 if (TYPE_FOR_JAVA (basetype)
11749 && current_lang_stack == current_lang_base)
11750 TYPE_FOR_JAVA (ref) = 1;
11751
8ccc31eb
MS
11752 /* Note that the BINFO records which describe individual
11753 inheritances are *not* shared in the lattice! They
11754 cannot be shared because a given baseclass may be
11755 inherited with different `accessibility' by different
11756 derived classes. (Each BINFO record describing an
11757 individual inheritance contains flags which say what
11758 the `accessibility' of that particular inheritance is.) */
11759
11760 base_binfo = make_binfo (integer_zero_node, basetype,
11761 TYPE_BINFO_VTABLE (basetype),
11762 TYPE_BINFO_VIRTUALS (basetype), NULL_TREE);
11763
11764 TREE_VEC_ELT (binfos, i) = base_binfo;
11765 TREE_VIA_PUBLIC (base_binfo) = via_public;
11766 TREE_VIA_PROTECTED (base_binfo) = via_protected;
11767 TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
11768 BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
11769
11770 SET_CLASSTYPE_MARKED (basetype);
9e9ff709 11771
8ccc31eb
MS
11772 /* We are free to modify these bits because they are meaningless
11773 at top level, and BASETYPE is a top-level type. */
11774 if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
11775 {
11776 TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
11777 TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
11778 }
11779
8ccc31eb
MS
11780 TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
11781 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
11782 CLASSTYPE_LOCAL_TYPEDECLS (ref) |= CLASSTYPE_LOCAL_TYPEDECLS (basetype);
11783 i += 1;
11784 }
11785 }
11786 if (i)
11787 TREE_VEC_LENGTH (binfos) = i;
11788 else
11789 BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
11790
11791 if (i > 1)
11792 TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
11793 else if (i == 1)
11794 TYPE_USES_MULTIPLE_INHERITANCE (ref)
11795 = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos, 0)));
11796 if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
11797 TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
11798
11799 /* Unmark all the types. */
11800 while (--i >= 0)
11801 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
11802 CLEAR_CLASSTYPE_MARKED (ref);
11803
11804 pop_obstacks ();
11805}
11806
8d08fdba 11807\f
b3d5a58b 11808tree current_local_enum = NULL_TREE;
8d08fdba
MS
11809
11810/* Begin compiling the definition of an enumeration type.
11811 NAME is its name (or null if anonymous).
11812 Returns the type object, as yet incomplete.
11813 Also records info about it so that build_enumerator
11814 may be used to declare the individual values as they are read. */
11815
11816tree
11817start_enum (name)
11818 tree name;
11819{
11820 register tree enumtype = NULL_TREE;
11821 struct binding_level *b = inner_binding_level;
11822
8c1e8edc 11823 /* We are wasting space here and putting these on the permanent_obstack so
6e687e5e
BK
11824 that typeid(local enum) will work correctly. */
11825#if 0
b87692e5 11826 if (processing_template_decl && current_function_decl)
6e687e5e
BK
11827#endif
11828
11829 end_temporary_allocation ();
b87692e5 11830
8d08fdba
MS
11831 /* If this is the real definition for a previous forward reference,
11832 fill in the contents in the same object that used to be the
11833 forward reference. */
11834
11835 if (name != NULL_TREE)
11836 enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
11837
11838 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
c91a56d2 11839 cp_error ("multiple definition of `%#T'", enumtype);
8d08fdba
MS
11840 else
11841 {
11842 enumtype = make_node (ENUMERAL_TYPE);
11843 pushtag (name, enumtype, 0);
11844 }
11845
11846 if (current_class_type)
11847 TREE_ADDRESSABLE (b->tags) = 1;
c91a56d2 11848
8d08fdba
MS
11849 current_local_enum = NULL_TREE;
11850
e92cc029
MS
11851 /* We don't copy this value because build_enumerator needs to do it. */
11852 enum_next_value = integer_zero_node;
7177d104 11853 enum_overflow = 0;
8d08fdba
MS
11854
11855 GNU_xref_decl (current_function_decl, enumtype);
11856 return enumtype;
11857}
11858
11859/* After processing and defining all the values of an enumeration type,
11860 install their decls in the enumeration type and finish it off.
11861 ENUMTYPE is the type object and VALUES a list of name-value pairs.
11862 Returns ENUMTYPE. */
11863
11864tree
dbfe2124
MM
11865finish_enum (enumtype)
11866 tree enumtype;
8d08fdba 11867{
a703fb38 11868 register tree minnode = NULL_TREE, maxnode = NULL_TREE;
8d08fdba
MS
11869 /* Calculate the maximum value of any enumerator in this type. */
11870
dbfe2124 11871 tree values = TYPE_VALUES (enumtype);
8d08fdba
MS
11872 if (values)
11873 {
ed44da02 11874 tree pair;
5566b478 11875
ed44da02 11876 for (pair = values; pair; pair = TREE_CHAIN (pair))
8d08fdba 11877 {
ed44da02
MM
11878 tree decl;
11879 tree value;
11880
11881 /* The TREE_VALUE is a CONST_DECL for this enumeration
11882 constant. */
11883 decl = TREE_VALUE (pair);
11884
11885 /* The type of the CONST_DECL is the type of the enumeration,
11886 not an INTEGER_TYPE. */
11887 TREE_TYPE (decl) = enumtype;
11888
11889 /* The DECL_INITIAL will be NULL if we are processing a
11890 template declaration and this enumeration constant had no
11891 explicit initializer. */
11892 value = DECL_INITIAL (decl);
11893 if (value)
5566b478 11894 {
ed44da02
MM
11895 /* Set the TREE_TYPE for the VALUE as well. When
11896 processing a template, however, we might have a
11897 TEMPLATE_PARM_INDEX, and we should not change the
11898 type of such a thing. */
11899 if (TREE_CODE (value) == TEMPLATE_PARM_INDEX)
11900 DECL_INITIAL (decl) = value
11901 = build1 (NOP_EXPR, enumtype, value);
5566b478 11902 TREE_TYPE (value) = enumtype;
ed44da02 11903
dbfe2124
MM
11904 if (!processing_template_decl)
11905 {
11906 if (!minnode)
11907 minnode = maxnode = value;
11908 else if (tree_int_cst_lt (maxnode, value))
11909 maxnode = value;
11910 else if (tree_int_cst_lt (value, minnode))
11911 minnode = value;
11912 }
5566b478 11913 }
ed44da02
MM
11914
11915 /* In the list we're building up, we want the enumeration
11916 values, not the CONST_DECLs. */
f376e137 11917 TREE_VALUE (pair) = value;
8d08fdba
MS
11918 }
11919 }
f376e137
MS
11920 else
11921 maxnode = minnode = integer_zero_node;
8d08fdba 11922
de22184b 11923 TYPE_VALUES (enumtype) = nreverse (values);
2986ae00 11924
5156628f 11925 if (processing_template_decl)
b87692e5
MS
11926 {
11927 if (current_function_decl)
11928 {
11929 add_tree (build_min (TAG_DEFN, enumtype));
11930 resume_temporary_allocation ();
11931 }
11932 return enumtype;
11933 }
5566b478 11934
f376e137
MS
11935 {
11936 int unsignedp = tree_int_cst_sgn (minnode) >= 0;
11937 int lowprec = min_precision (minnode, unsignedp);
11938 int highprec = min_precision (maxnode, unsignedp);
11939 int precision = MAX (lowprec, highprec);
8d08fdba 11940
6060a796 11941 TYPE_SIZE (enumtype) = NULL_TREE;
13fbb038 11942
8ccc31eb 11943 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
8d08fdba 11944
f376e137 11945 TYPE_PRECISION (enumtype) = precision;
f376e137 11946 if (unsignedp)
8d08fdba 11947 fixup_unsigned_type (enumtype);
f376e137
MS
11948 else
11949 fixup_signed_type (enumtype);
8ccc31eb 11950
5566b478 11951 if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
8ccc31eb
MS
11952 /* Use the width of the narrowest normal C type which is wide enough. */
11953 TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
11954 (precision, 1));
11955 else
11956 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
11957
11958 TYPE_SIZE (enumtype) = 0;
11959 layout_type (enumtype);
f376e137 11960 }
8d08fdba 11961
f376e137
MS
11962 {
11963 register tree tem;
11964
11965 /* Fix up all variant types of this enum type. */
11966 for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
11967 tem = TYPE_NEXT_VARIANT (tem))
11968 {
11969 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
11970 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
11971 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
11972 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
8cd4c175 11973 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
f376e137
MS
11974 TYPE_MODE (tem) = TYPE_MODE (enumtype);
11975 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
11976 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
11977 TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
11978 }
11979 }
8d08fdba
MS
11980
11981 /* Finish debugging output for this type. */
2c73f9f5 11982 rest_of_type_compilation (enumtype, namespace_bindings_p ());
8d08fdba
MS
11983
11984 return enumtype;
11985}
11986
11987/* Build and install a CONST_DECL for one value of the
11988 current enumeration type (one that was begun with start_enum).
11989 Return a tree-list containing the name and its value.
11990 Assignment of sequential values by default is handled here. */
11991
11992tree
11993build_enumerator (name, value)
11994 tree name, value;
11995{
11996 tree decl, result;
8d08fdba
MS
11997
11998 /* Remove no-op casts from the value. */
11999 if (value)
12000 STRIP_TYPE_NOPS (value);
12001
5156628f 12002 if (! processing_template_decl)
5566b478
MS
12003 {
12004 /* Validate and default VALUE. */
12005 if (value != NULL_TREE)
12006 {
12007 if (TREE_READONLY_DECL_P (value))
e92cc029 12008 value = decl_constant_value (value);
5566b478
MS
12009
12010 if (TREE_CODE (value) == INTEGER_CST)
12011 {
12012 value = default_conversion (value);
12013 constant_expression_warning (value);
12014 }
12015 else
12016 {
12017 cp_error ("enumerator value for `%D' not integer constant", name);
12018 value = NULL_TREE;
12019 }
12020 }
12021
5566b478 12022 /* Default based on previous value. */
5156628f 12023 if (value == NULL_TREE && ! processing_template_decl)
5566b478
MS
12024 {
12025 value = enum_next_value;
12026 if (enum_overflow)
12027 cp_error ("overflow in enumeration values at `%D'", name);
12028 }
12029
12030 /* Remove no-op casts from the value. */
12031 if (value)
12032 STRIP_TYPE_NOPS (value);
013bc8af
MS
12033#if 0
12034 /* To fix MAX_VAL enum consts. (bkoz) */
e92cc029 12035 TREE_TYPE (value) = integer_type_node;
013bc8af 12036#endif
5566b478 12037 }
8d08fdba 12038
ed44da02
MM
12039 /* We have to always copy here; not all INTEGER_CSTs are unshared,
12040 and there's no wedding ring. Look at size_int()...*/
12041 if (value != NULL_TREE)
12042 value = copy_node (value);
12043
8d08fdba
MS
12044 /* C++ associates enums with global, function, or class declarations. */
12045
7177d104
MS
12046 decl = current_scope ();
12047 if (decl && decl == current_class_type)
8d08fdba
MS
12048 {
12049 /* This enum declaration is local to the class, so we must put
12050 it in that class's list of decls. */
12051 decl = build_lang_field_decl (CONST_DECL, name, integer_type_node);
12052 DECL_INITIAL (decl) = value;
12053 TREE_READONLY (decl) = 1;
12054 pushdecl_class_level (decl);
12055 TREE_CHAIN (decl) = current_local_enum;
12056 current_local_enum = decl;
12057 }
12058 else
12059 {
12060 /* It's a global enum, or it's local to a function. (Note local to
12061 a function could mean local to a class method. */
12062 decl = build_decl (CONST_DECL, name, integer_type_node);
12063 DECL_INITIAL (decl) = value;
42976354 12064 TREE_READONLY (decl) = 1;
8d08fdba
MS
12065
12066 pushdecl (decl);
12067 GNU_xref_decl (current_function_decl, decl);
12068 }
12069
5156628f 12070 if (! processing_template_decl)
5566b478
MS
12071 {
12072 /* Set basis for default for next value. */
12073 enum_next_value = build_binary_op_nodefault (PLUS_EXPR, value,
12074 integer_one_node, PLUS_EXPR);
12075 enum_overflow = tree_int_cst_lt (enum_next_value, value);
5566b478 12076 }
8d08fdba 12077
8d2733ca 12078 result = saveable_tree_cons (name, decl, NULL_TREE);
8d08fdba
MS
12079 return result;
12080}
12081
ed44da02
MM
12082/* Called after we have finished the declaration of an enumeration
12083 type, and, perhaps, some objects whose type involves the
12084 enumeration type. DECL, if non-NULL, is the declaration of the
12085 first such object.
12086
12087 If CURRENT_LOCAL_ENUM is NULL, the DECL is returned.
12088
12089 If CURRENT_LOCAL_ENUM is non-NULL, it should be the CONST_DECL for
12090 the last enumeration constant of an enumeration type that is a
12091 member of a class. The enumeration constants are already chained
12092 together through their TREE_CHAIN fields. This function sets the
12093 TREE_CHAIN of the last enumeration constant to DECL. The
12094 CONST_DECL for the last enumeration constant is returned.
12095
12096 CURRENT_LOCAL_ENUM will always be NULL when this function
12097 returns. */
12098
8d08fdba 12099tree
86052cc3
JM
12100grok_enum_decls (decl)
12101 tree decl;
8d08fdba
MS
12102{
12103 tree d = current_local_enum;
12104
12105 if (d == NULL_TREE)
12106 return decl;
12107
12108 while (1)
12109 {
8d08fdba
MS
12110 if (TREE_CHAIN (d) == NULL_TREE)
12111 {
12112 TREE_CHAIN (d) = decl;
12113 break;
12114 }
12115 d = TREE_CHAIN (d);
12116 }
12117
12118 decl = current_local_enum;
12119 current_local_enum = NULL_TREE;
12120
12121 return decl;
12122}
12123\f
5566b478
MS
12124static int function_depth;
12125
8d08fdba
MS
12126/* Create the FUNCTION_DECL for a function definition.
12127 DECLSPECS and DECLARATOR are the parts of the declaration;
12128 they describe the function's name and the type it returns,
12129 but twisted together in a fashion that parallels the syntax of C.
12130
12131 This function creates a binding context for the function body
12132 as well as setting up the FUNCTION_DECL in current_function_decl.
12133
12134 Returns 1 on success. If the DECLARATOR is not suitable for a function
12135 (it defines a datum instead), we return 0, which tells
12136 yyparse to report a parse error.
12137
12138 For C++, we must first check whether that datum makes any sense.
12139 For example, "class A local_a(1,2);" means that variable local_a
12140 is an aggregate of type A, which should have a constructor
12141 applied to it with the argument list [1, 2].
12142
12143 @@ There is currently no way to retrieve the storage
12144 @@ allocated to FUNCTION (or all of its parms) if we return
12145 @@ something we had previously. */
12146
12147int
c11b6f21
MS
12148start_function (declspecs, declarator, attrs, pre_parsed_p)
12149 tree declspecs, declarator, attrs;
8d08fdba
MS
12150 int pre_parsed_p;
12151{
5566b478 12152 tree decl1;
8d08fdba
MS
12153 tree ctype = NULL_TREE;
12154 tree fntype;
12155 tree restype;
12156 extern int have_extern_spec;
12157 extern int used_extern_spec;
12158 int doing_friend = 0;
12159
8d08fdba 12160 /* Sanity check. */
a1774733 12161 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
8d08fdba
MS
12162 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
12163
e92cc029 12164 /* Assume, until we see it does. */
8d08fdba
MS
12165 current_function_returns_value = 0;
12166 current_function_returns_null = 0;
12167 warn_about_return_type = 0;
fd378c9d
JM
12168 named_labels = 0;
12169 shadowed_labels = 0;
8d08fdba
MS
12170 current_function_assigns_this = 0;
12171 current_function_just_assigned_this = 0;
12172 current_function_parms_stored = 0;
12173 original_result_rtx = NULL_RTX;
a9aedbc2 12174 base_init_expr = NULL_TREE;
79ff2c6c
MS
12175 current_base_init_list = NULL_TREE;
12176 current_member_init_list = NULL_TREE;
f30432d7 12177 ctor_label = dtor_label = NULL_TREE;
42976354 12178 static_labelno = 0;
8d08fdba
MS
12179
12180 clear_temp_name ();
12181
e92cc029 12182 /* This should only be done once on the top most decl. */
8d08fdba
MS
12183 if (have_extern_spec && !used_extern_spec)
12184 {
12185 declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
12186 used_extern_spec = 1;
12187 }
12188
12189 if (pre_parsed_p)
12190 {
12191 decl1 = declarator;
12192
67f7c391
JM
12193#if 0
12194 /* What was this testing for, exactly? */
8d08fdba
MS
12195 if (! DECL_ARGUMENTS (decl1)
12196 && !DECL_STATIC_FUNCTION_P (decl1)
67f7c391 12197 && !DECL_ARTIFICIAL (decl1)
6eb3bb27 12198 && DECL_CLASS_SCOPE_P (decl1)
d2e5ee5c
MS
12199 && TYPE_IDENTIFIER (DECL_CONTEXT (decl1))
12200 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1))))
8d08fdba 12201 {
30394414
JM
12202 tree binding = binding_for_name (DECL_NAME (decl1),
12203 current_namespace);
8d08fdba
MS
12204 cp_error ("redeclaration of `%#D'", decl1);
12205 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)))
12206 cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)));
30394414
JM
12207 else if (BINDING_VALUE (binding))
12208 cp_error_at ("previous declaration here", BINDING_VALUE (binding));
8d08fdba 12209 }
67f7c391 12210#endif
8d08fdba 12211
8d08fdba
MS
12212 fntype = TREE_TYPE (decl1);
12213 if (TREE_CODE (fntype) == METHOD_TYPE)
12214 ctype = TYPE_METHOD_BASETYPE (fntype);
12215
12216 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
12217 class is in the (lexical) scope of the class in which it is
12218 defined. */
12219 if (!ctype && DECL_FRIEND_P (decl1))
12220 {
12221 ctype = DECL_CLASS_CONTEXT (decl1);
12222
12223 /* CTYPE could be null here if we're dealing with a template;
12224 for example, `inline friend float foo()' inside a template
12225 will have no CTYPE set. */
12226 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
12227 ctype = NULL_TREE;
12228 else
12229 doing_friend = 1;
12230 }
12231
8d08fdba 12232 /* In a fcn definition, arg types must be complete. */
5566b478 12233 require_complete_types_for_parms (DECL_ARGUMENTS (decl1));
9fffd093
RK
12234
12235 /* In case some arg types were completed since the declaration was
12236 parsed, fix up the decls. */
12237 {
5566b478 12238 tree t = DECL_ARGUMENTS (decl1);
9fffd093
RK
12239 for (; t; t = TREE_CHAIN (t))
12240 layout_decl (t, 0);
12241 }
5566b478
MS
12242
12243 last_function_parms = DECL_ARGUMENTS (decl1);
12244 last_function_parm_tags = NULL_TREE;
8d08fdba
MS
12245 }
12246 else
12247 {
c11b6f21 12248 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
8d08fdba
MS
12249 /* If the declarator is not suitable for a function definition,
12250 cause a syntax error. */
12251 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
12252
12253 fntype = TREE_TYPE (decl1);
12254
12255 restype = TREE_TYPE (fntype);
12256 if (IS_AGGR_TYPE (restype) && ! TYPE_PTRMEMFUNC_P (restype)
12257 && ! CLASSTYPE_GOT_SEMICOLON (restype))
12258 {
12259 cp_error ("semicolon missing after declaration of `%#T'", restype);
e66d884e 12260 shadow_tag (build_expr_list (NULL_TREE, restype));
8d08fdba
MS
12261 CLASSTYPE_GOT_SEMICOLON (restype) = 1;
12262 if (TREE_CODE (fntype) == FUNCTION_TYPE)
12263 fntype = build_function_type (integer_type_node,
12264 TYPE_ARG_TYPES (fntype));
12265 else
12266 fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
12267 integer_type_node,
12268 TYPE_ARG_TYPES (fntype));
12269 TREE_TYPE (decl1) = fntype;
12270 }
12271
12272 if (TREE_CODE (fntype) == METHOD_TYPE)
12273 ctype = TYPE_METHOD_BASETYPE (fntype);
35680744 12274 else if (DECL_MAIN_P (decl1))
8d08fdba
MS
12275 {
12276 /* If this doesn't return integer_type, complain. */
12277 if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
12278 {
a28e3c7f 12279 if (pedantic || warn_return_type)
5566b478 12280 pedwarn ("return type for `main' changed to `int'");
8d08fdba
MS
12281 TREE_TYPE (decl1) = fntype = default_function_type;
12282 }
12283 warn_about_return_type = 0;
12284 }
12285 }
12286
12287 /* Warn if function was previously implicitly declared
12288 (but not if we warned then). */
12289 if (! warn_implicit
12290 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
12291 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
12292
12293 current_function_decl = decl1;
5566b478
MS
12294 /* Save the parm names or decls from this function's declarator
12295 where store_parm_decls will find them. */
12296 current_function_parms = last_function_parms;
12297 current_function_parm_tags = last_function_parm_tags;
8d08fdba 12298
9e9ff709 12299 announce_function (decl1);
8d08fdba 12300
5156628f 12301 if (! processing_template_decl)
8d08fdba 12302 {
5566b478
MS
12303 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
12304 {
12305 cp_error ("return-type `%#T' is an incomplete type",
12306 TREE_TYPE (fntype));
8d08fdba 12307
5566b478
MS
12308 /* Make it return void instead, but don't change the
12309 type of the DECL_RESULT, in case we have a named return value. */
12310 if (ctype)
12311 TREE_TYPE (decl1)
12312 = build_cplus_method_type (build_type_variant (ctype,
12313 TREE_READONLY (decl1),
12314 TREE_SIDE_EFFECTS (decl1)),
12315 void_type_node,
12316 FUNCTION_ARG_CHAIN (decl1));
12317 else
12318 TREE_TYPE (decl1)
12319 = build_function_type (void_type_node,
12320 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
12321 DECL_RESULT (decl1)
12322 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype)));
12323 TREE_READONLY (DECL_RESULT (decl1)) = TYPE_READONLY (TREE_TYPE (fntype));
12324 TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = TYPE_VOLATILE (TREE_TYPE (fntype));
12325 }
12326
12327 if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype))
12328 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype)))
12329 abstract_virtuals_error (decl1, TREE_TYPE (fntype));
12330 }
b7484fbe 12331
8d08fdba 12332 if (warn_about_return_type)
59f1f2c4 12333 pedwarn ("return-type defaults to `int'");
8d08fdba 12334
824b9a4c 12335 /* Effective C++ rule 15. See also c_expand_return. */
eb448459 12336 if (warn_ecpp
824b9a4c 12337 && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
a1774733 12338 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
824b9a4c
MS
12339 cp_warning ("`operator=' should return a reference to `*this'");
12340
8d08fdba
MS
12341 /* Make the init_value nonzero so pushdecl knows this is not tentative.
12342 error_mark_node is replaced below (in poplevel) with the BLOCK. */
12343 DECL_INITIAL (decl1) = error_mark_node;
12344
8d08fdba
MS
12345 /* This function exists in static storage.
12346 (This does not mean `static' in the C sense!) */
12347 TREE_STATIC (decl1) = 1;
12348
36a117a5
MM
12349 /* Set up current_class_type, and enter the scope of the class, if
12350 appropriate. */
12351 if (ctype)
12352 push_nested_class (ctype, 1);
12353 else if (DECL_STATIC_FUNCTION_P (decl1))
12354 push_nested_class (DECL_CONTEXT (decl1), 2);
12355
12356 /* We must call push_template_decl after current_class_type is set
12357 up. (If we are processing inline definitions after exiting a
12358 class scope, current_class_type will be NULL_TREE until set above
12359 by push_nested_class.) */
12360 if (processing_template_decl)
12361 decl1 = push_template_decl (decl1);
12362
878cd289
MS
12363 /* Record the decl so that the function name is defined.
12364 If we already have a decl for this name, and it is a FUNCTION_DECL,
12365 use the old decl. */
36a117a5 12366 if (!processing_template_decl && pre_parsed_p == 0)
878cd289 12367 {
75650646 12368 /* A specialization is not used to guide overload resolution. */
959d8796
JM
12369 if ((flag_guiding_decls
12370 || !DECL_TEMPLATE_SPECIALIZATION (decl1))
12371 && ! DECL_FUNCTION_MEMBER_P (decl1))
75650646 12372 decl1 = pushdecl (decl1);
2c73f9f5 12373 else
b7698cf0
JM
12374 {
12375 /* We need to set the DECL_CONTEXT. */
12376 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
12377 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
12378 /* And make sure we have enough default args. */
12379 check_default_args (decl1);
12380 }
878cd289
MS
12381 DECL_MAIN_VARIANT (decl1) = decl1;
12382 fntype = TREE_TYPE (decl1);
12383 }
5566b478
MS
12384
12385 current_function_decl = decl1;
878cd289 12386
db5ae43f 12387 if (DECL_INTERFACE_KNOWN (decl1))
faae18ab 12388 {
86052cc3
JM
12389 tree ctx = hack_decl_function_context (decl1);
12390
faae18ab
MS
12391 if (DECL_NOT_REALLY_EXTERN (decl1))
12392 DECL_EXTERNAL (decl1) = 0;
86052cc3
JM
12393
12394 if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
12395 && TREE_PUBLIC (ctx))
12396 /* This is a function in a local class in an extern inline
12397 function. */
12398 comdat_linkage (decl1);
faae18ab 12399 }
8d08fdba
MS
12400 /* If this function belongs to an interface, it is public.
12401 If it belongs to someone else's interface, it is also external.
12402 It doesn't matter whether it's inline or not. */
5566b478
MS
12403 else if (interface_unknown == 0
12404 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
d11ad92e 12405 || flag_alt_external_templates))
8d08fdba 12406 {
5566b478 12407 if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
5156628f 12408 || processing_template_decl)
db5ae43f
MS
12409 DECL_EXTERNAL (decl1)
12410 = (interface_only
faae18ab 12411 || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines));
db5ae43f 12412 else
893de33c 12413 DECL_EXTERNAL (decl1) = 0;
e8abc66f 12414 DECL_NOT_REALLY_EXTERN (decl1) = 0;
db5ae43f 12415 DECL_INTERFACE_KNOWN (decl1) = 1;
8d08fdba
MS
12416 }
12417 else
a0a33927
MS
12418 {
12419 /* This is a definition, not a reference.
b7484fbe
MS
12420 So clear DECL_EXTERNAL. */
12421 DECL_EXTERNAL (decl1) = 0;
faae18ab 12422
5566b478
MS
12423 if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
12424 && ! DECL_INTERFACE_KNOWN (decl1)
12425 /* Don't try to defer nested functions for now. */
e76a2646 12426 && ! hack_decl_function_context (decl1))
878cd289
MS
12427 DECL_DEFER_OUTPUT (decl1) = 1;
12428 else
893de33c 12429 DECL_INTERFACE_KNOWN (decl1) = 1;
db5ae43f 12430 }
a9aedbc2 12431
8d08fdba
MS
12432 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1))
12433 {
12434 if (TREE_CODE (fntype) == METHOD_TYPE)
12435 TREE_TYPE (decl1) = fntype
12436 = build_function_type (TREE_TYPE (fntype),
12437 TREE_CHAIN (TYPE_ARG_TYPES (fntype)));
5566b478
MS
12438 current_function_parms = TREE_CHAIN (current_function_parms);
12439 DECL_ARGUMENTS (decl1) = current_function_parms;
8d08fdba
MS
12440 ctype = NULL_TREE;
12441 }
12442 restype = TREE_TYPE (fntype);
12443
8d08fdba
MS
12444 if (ctype)
12445 {
8d08fdba 12446 /* If we're compiling a friend function, neither of the variables
4ac14744 12447 current_class_ptr nor current_class_type will have values. */
8d08fdba
MS
12448 if (! doing_friend)
12449 {
12450 /* We know that this was set up by `grokclassfn'.
12451 We do not wait until `store_parm_decls', since evil
12452 parse errors may never get us to that point. Here
12453 we keep the consistency between `current_class_type'
4ac14744 12454 and `current_class_ptr'. */
5566b478 12455 tree t = current_function_parms;
5f34005f
RK
12456
12457 my_friendly_assert (t != NULL_TREE
12458 && TREE_CODE (t) == PARM_DECL, 162);
12459
dff6b454
RK
12460 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
12461 {
12462 int i = suspend_momentary ();
12463
12464 /* Fool build_indirect_ref. */
4ac14744
MS
12465 current_class_ptr = NULL_TREE;
12466 current_class_ref = build_indirect_ref (t, NULL_PTR);
12467 current_class_ptr = t;
dff6b454
RK
12468 resume_momentary (i);
12469 }
12470 else
12471 /* We're having a signature pointer here. */
4ac14744 12472 current_class_ref = current_class_ptr = t;
dff6b454 12473
8d08fdba
MS
12474 }
12475 }
12476 else
12477 {
36a117a5
MM
12478 if (!DECL_STATIC_FUNCTION_P (decl1))
12479 push_memoized_context (NULL_TREE, 1);
4ac14744 12480 current_class_ptr = current_class_ref = NULL_TREE;
8d08fdba
MS
12481 }
12482
db5ae43f
MS
12483 pushlevel (0);
12484 current_binding_level->parm_flag = 1;
12485
db5ae43f
MS
12486 GNU_xref_function (decl1, current_function_parms);
12487
f30432d7
MS
12488 if (attrs)
12489 cplus_decl_attributes (decl1, NULL_TREE, attrs);
db5ae43f
MS
12490 make_function_rtl (decl1);
12491
8d08fdba
MS
12492 /* Promote the value to int before returning it. */
12493 if (C_PROMOTING_INTEGER_TYPE_P (restype))
5566b478
MS
12494 restype = type_promotes_to (restype);
12495
12496 /* If this fcn was already referenced via a block-scope `extern' decl
12497 (or an implicit decl), propagate certain information about the usage. */
12498 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
12499 TREE_ADDRESSABLE (decl1) = 1;
12500
8d08fdba 12501 if (DECL_RESULT (decl1) == NULL_TREE)
f30432d7
MS
12502 {
12503 DECL_RESULT (decl1)
12504 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
12505 TREE_READONLY (DECL_RESULT (decl1)) = TYPE_READONLY (restype);
12506 TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = TYPE_VOLATILE (restype);
12507 }
8d08fdba 12508
948edfa7
JW
12509 /* Allocate further tree nodes temporarily during compilation
12510 of this function only. Tiemann moved up here from bottom of fn. */
12511 /* If this is a nested function, then we must continue to allocate RTL
12512 on the permanent obstack in case we need to inline it later. */
12513 if (! hack_decl_function_context (decl1))
5566b478
MS
12514 temporary_allocation ();
12515
5156628f 12516 if (processing_template_decl)
5566b478 12517 {
5566b478
MS
12518 ++minimal_parse_mode;
12519 last_tree = DECL_SAVED_TREE (decl1)
12520 = build_nt (EXPR_STMT, void_zero_node);
12521 }
12522
12523 ++function_depth;
12524
f30432d7
MS
12525 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
12526 && DECL_LANGUAGE (decl1) == lang_cplusplus)
8d08fdba
MS
12527 {
12528 dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
12529 ctor_label = NULL_TREE;
12530 }
12531 else
12532 {
12533 dtor_label = NULL_TREE;
12534 if (DECL_CONSTRUCTOR_P (decl1))
12535 ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
12536 }
12537
8d08fdba
MS
12538 return 1;
12539}
12540\f
9664b89e
JM
12541/* Called after store_parm_decls for a function-try-block. We need to update
12542 last_parm_cleanup_insn so that the base initializers for a constructor
12543 are run within this block, not before it. */
6467930b
MS
12544
12545void
12546expand_start_early_try_stmts ()
12547{
6467930b 12548 expand_start_try_stmts ();
9664b89e 12549 last_parm_cleanup_insn = get_last_insn ();
f30432d7
MS
12550}
12551
8d08fdba
MS
12552/* Store the parameter declarations into the current function declaration.
12553 This is called after parsing the parameter declarations, before
12554 digesting the body of the function.
12555
12556 Also install to binding contour return value identifier, if any. */
12557
12558void
12559store_parm_decls ()
12560{
12561 register tree fndecl = current_function_decl;
12562 register tree parm;
12563 int parms_have_cleanups = 0;
eb66be0e 12564 tree cleanups = NULL_TREE;
8d08fdba
MS
12565
12566 /* This is either a chain of PARM_DECLs (when a prototype is used). */
12567 tree specparms = current_function_parms;
12568
12569 /* This is a list of types declared among parms in a prototype. */
12570 tree parmtags = current_function_parm_tags;
12571
12572 /* This is a chain of any other decls that came in among the parm
12573 declarations. If a parm is declared with enum {foo, bar} x;
12574 then CONST_DECLs for foo and bar are put here. */
12575 tree nonparms = NULL_TREE;
12576
a9aedbc2 12577 if (toplevel_bindings_p ())
8d08fdba
MS
12578 fatal ("parse errors have confused me too much");
12579
12580 /* Initialize RTL machinery. */
12581 init_function_start (fndecl, input_filename, lineno);
12582
12583 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
12584 declare_function_name ();
12585
12586 /* Create a binding level for the parms. */
12587 expand_start_bindings (0);
12588
8d08fdba
MS
12589 if (specparms != NULL_TREE)
12590 {
12591 /* This case is when the function was defined with an ANSI prototype.
12592 The parms already have decls, so we need not do anything here
12593 except record them as in effect
12594 and complain if any redundant old-style parm decls were written. */
12595
12596 register tree next;
12597
12598 /* Must clear this because it might contain TYPE_DECLs declared
12599 at class level. */
12600 storedecls (NULL_TREE);
5566b478 12601
8d08fdba
MS
12602 for (parm = nreverse (specparms); parm; parm = next)
12603 {
12604 next = TREE_CHAIN (parm);
12605 if (TREE_CODE (parm) == PARM_DECL)
12606 {
5566b478 12607 tree cleanup;
8d08fdba
MS
12608 if (DECL_NAME (parm) == NULL_TREE)
12609 {
8d08fdba 12610 pushdecl (parm);
8d08fdba 12611 }
a1774733 12612 else if (TREE_CODE (TREE_TYPE (parm)) == VOID_TYPE)
8d08fdba
MS
12613 cp_error ("parameter `%D' declared void", parm);
12614 else
12615 {
12616 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
12617 A parameter is assumed not to have any side effects.
12618 If this should change for any reason, then this
12619 will have to wrap the bashed reference type in a save_expr.
12620
12621 Also, if the parameter type is declared to be an X
12622 and there is an X(X&) constructor, we cannot lay it
12623 into the stack (any more), so we make this parameter
12624 look like it is really of reference type. Functions
12625 which pass parameters to this function will know to
12626 create a temporary in their frame, and pass a reference
12627 to that. */
12628
12629 if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
12630 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))))
12631 SET_DECL_REFERENCE_SLOT (parm, convert_from_reference (parm));
12632
12633 pushdecl (parm);
12634 }
5156628f 12635 if (! processing_template_decl
5566b478 12636 && (cleanup = maybe_build_cleanup (parm), cleanup))
8d08fdba
MS
12637 {
12638 expand_decl (parm);
8d08fdba 12639 parms_have_cleanups = 1;
eb66be0e
MS
12640
12641 /* Keep track of the cleanups. */
12642 cleanups = tree_cons (parm, cleanup, cleanups);
8d08fdba
MS
12643 }
12644 }
12645 else
12646 {
12647 /* If we find an enum constant or a type tag,
12648 put it aside for the moment. */
12649 TREE_CHAIN (parm) = NULL_TREE;
12650 nonparms = chainon (nonparms, parm);
12651 }
12652 }
12653
12654 /* Get the decls in their original chain order
12655 and record in the function. This is all and only the
12656 PARM_DECLs that were pushed into scope by the loop above. */
12657 DECL_ARGUMENTS (fndecl) = getdecls ();
12658
12659 storetags (chainon (parmtags, gettags ()));
12660 }
12661 else
12662 DECL_ARGUMENTS (fndecl) = NULL_TREE;
12663
12664 /* Now store the final chain of decls for the arguments
12665 as the decl-chain of the current lexical scope.
12666 Put the enumerators in as well, at the front so that
12667 DECL_ARGUMENTS is not modified. */
12668
12669 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
12670
12671 /* Initialize the RTL code for the function. */
12672 DECL_SAVED_INSNS (fndecl) = NULL_RTX;
5156628f 12673 if (! processing_template_decl)
5566b478 12674 expand_function_start (fndecl, parms_have_cleanups);
8d08fdba 12675
eb448459
MS
12676 current_function_parms_stored = 1;
12677
12678 /* If this function is `main', emit a call to `__main'
12679 to run global initializers, etc. */
35680744
MM
12680 if (DECL_MAIN_P (fndecl))
12681 expand_main_function ();
eb448459 12682
eb66be0e
MS
12683 /* Now that we have initialized the parms, we can start their
12684 cleanups. We cannot do this before, since expand_decl_cleanup
12685 should not be called before the parm can be used. */
eb448459 12686 if (cleanups
eb66be0e
MS
12687 && ! processing_template_decl)
12688 {
12689 for (cleanups = nreverse (cleanups); cleanups; cleanups = TREE_CHAIN (cleanups))
12690 {
12691 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups), TREE_VALUE (cleanups)))
12692 cp_error ("parser lost in parsing declaration of `%D'",
12693 TREE_PURPOSE (cleanups));
12694 }
12695 }
12696
8d08fdba
MS
12697 /* Create a binding contour which can be used to catch
12698 cleanup-generated temporaries. Also, if the return value needs or
12699 has initialization, deal with that now. */
12700 if (parms_have_cleanups)
12701 {
12702 pushlevel (0);
12703 expand_start_bindings (0);
12704 }
12705
5156628f 12706 if (! processing_template_decl && flag_exceptions)
f30432d7 12707 {
f30432d7
MS
12708 /* Do the starting of the exception specifications, if we have any. */
12709 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
12710 expand_start_eh_spec ();
f30432d7 12711 }
eb448459 12712
5c825fc2 12713 last_parm_cleanup_insn = get_last_insn ();
72b7eeff 12714 last_dtor_insn = get_last_insn ();
8d08fdba
MS
12715}
12716
12717/* Bind a name and initialization to the return value of
12718 the current function. */
e92cc029 12719
8d08fdba
MS
12720void
12721store_return_init (return_id, init)
12722 tree return_id, init;
12723{
12724 tree decl = DECL_RESULT (current_function_decl);
12725
e1cd6e56 12726 if (pedantic)
8d08fdba
MS
12727 /* Give this error as many times as there are occurrences,
12728 so that users can use Emacs compilation buffers to find
12729 and fix all such places. */
8926095f 12730 pedwarn ("ANSI C++ does not permit named return values");
8d08fdba
MS
12731
12732 if (return_id != NULL_TREE)
12733 {
12734 if (DECL_NAME (decl) == NULL_TREE)
12735 {
12736 DECL_NAME (decl) = return_id;
12737 DECL_ASSEMBLER_NAME (decl) = return_id;
12738 }
12739 else
e76a2646 12740 cp_error ("return identifier `%D' already in place", decl);
8d08fdba
MS
12741 }
12742
12743 /* Can't let this happen for constructors. */
12744 if (DECL_CONSTRUCTOR_P (current_function_decl))
12745 {
12746 error ("can't redefine default return value for constructors");
12747 return;
12748 }
12749
12750 /* If we have a named return value, put that in our scope as well. */
12751 if (DECL_NAME (decl) != NULL_TREE)
12752 {
12753 /* If this named return value comes in a register,
12754 put it in a pseudo-register. */
12755 if (DECL_REGISTER (decl))
12756 {
12757 original_result_rtx = DECL_RTL (decl);
12758 DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
12759 }
12760
82580166 12761 /* Let `cp_finish_decl' know that this initializer is ok. */
8d08fdba
MS
12762 DECL_INITIAL (decl) = init;
12763 pushdecl (decl);
e76a2646
MS
12764
12765 if (minimal_parse_mode)
12766 add_tree (build_min_nt (RETURN_INIT, return_id,
12767 copy_to_permanent (init)));
12768 else
dae1d6f6 12769 cp_finish_decl (decl, init, NULL_TREE, 0, 0);
8d08fdba
MS
12770 }
12771}
12772
8d08fdba
MS
12773\f
12774/* Finish up a function declaration and compile that function
12775 all the way to assembler language output. The free the storage
12776 for the function definition.
12777
12778 This is called after parsing the body of the function definition.
12779 LINENO is the current line number.
12780
12781 C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
12782 (and expand_end_bindings) must be made to take care of the binding
12783 contour for the base initializers. This is only relevant for
e92cc029
MS
12784 constructors.
12785
12786 NESTED is nonzero if we were in the middle of compiling another function
12787 when we started on this one. */
8d08fdba
MS
12788
12789void
db5ae43f 12790finish_function (lineno, call_poplevel, nested)
8d08fdba
MS
12791 int lineno;
12792 int call_poplevel;
db5ae43f 12793 int nested;
8d08fdba
MS
12794{
12795 register tree fndecl = current_function_decl;
12796 tree fntype, ctype = NULL_TREE;
f30432d7 12797 rtx last_parm_insn, insns;
8d08fdba
MS
12798 /* Label to use if this function is supposed to return a value. */
12799 tree no_return_label = NULL_TREE;
12800 tree decls = NULL_TREE;
12801
12802 /* When we get some parse errors, we can end up without a
12803 current_function_decl, so cope. */
12804 if (fndecl == NULL_TREE)
12805 return;
12806
e92cc029
MS
12807 if (! nested && function_depth > 1)
12808 nested = 1;
12809
8d08fdba
MS
12810 fntype = TREE_TYPE (fndecl);
12811
12812/* TREE_READONLY (fndecl) = 1;
12813 This caused &foo to be of type ptr-to-const-function
12814 which then got a warning when stored in a ptr-to-function variable. */
12815
12816 /* This happens on strange parse errors. */
12817 if (! current_function_parms_stored)
12818 {
12819 call_poplevel = 0;
12820 store_parm_decls ();
12821 }
12822
5156628f 12823 if (processing_template_decl)
8d08fdba 12824 {
5566b478
MS
12825 if (DECL_CONSTRUCTOR_P (fndecl) && call_poplevel)
12826 {
12827 decls = getdecls ();
12828 expand_end_bindings (decls, decls != NULL_TREE, 0);
12829 poplevel (decls != NULL_TREE, 0, 0);
12830 }
12831 }
12832 else
12833 {
12834 if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
8d08fdba 12835 {
5566b478
MS
12836 tree ttype = target_type (fntype);
12837 tree parmdecl;
12838
8d08fdba
MS
12839 if (IS_AGGR_TYPE (ttype))
12840 /* Let debugger know it should output info for this type. */
12841 note_debug_info_needed (ttype);
5566b478
MS
12842
12843 for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
12844 {
12845 ttype = target_type (TREE_TYPE (parmdecl));
12846 if (IS_AGGR_TYPE (ttype))
12847 /* Let debugger know it should output info for this type. */
12848 note_debug_info_needed (ttype);
12849 }
8d08fdba 12850 }
8d08fdba 12851
5566b478
MS
12852 /* Clean house because we will need to reorder insns here. */
12853 do_pending_stack_adjust ();
8d08fdba 12854
5566b478 12855 if (dtor_label)
8d08fdba 12856 {
5566b478
MS
12857 tree binfo = TYPE_BINFO (current_class_type);
12858 tree cond = integer_one_node;
12859 tree exprstmt;
12860 tree in_charge_node = lookup_name (in_charge_identifier, 0);
12861 tree virtual_size;
12862 int ok_to_optimize_dtor = 0;
12863 int empty_dtor = get_last_insn () == last_dtor_insn;
8d08fdba 12864
5566b478
MS
12865 if (current_function_assigns_this)
12866 cond = build (NE_EXPR, boolean_type_node,
4ac14744 12867 current_class_ptr, integer_zero_node);
5566b478
MS
12868 else
12869 {
12870 int n_baseclasses = CLASSTYPE_N_BASECLASSES (current_class_type);
12871
12872 /* If this destructor is empty, then we don't need to check
12873 whether `this' is NULL in some cases. */
12874 if ((flag_this_is_variable & 1) == 0)
12875 ok_to_optimize_dtor = 1;
12876 else if (empty_dtor)
12877 ok_to_optimize_dtor
12878 = (n_baseclasses == 0
12879 || (n_baseclasses == 1
12880 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type, 0))));
12881 }
8d08fdba 12882
5566b478
MS
12883 /* These initializations might go inline. Protect
12884 the binding level of the parms. */
12885 pushlevel (0);
12886 expand_start_bindings (0);
8d08fdba 12887
5566b478
MS
12888 if (current_function_assigns_this)
12889 {
12890 current_function_assigns_this = 0;
12891 current_function_just_assigned_this = 0;
12892 }
8d08fdba 12893
5566b478
MS
12894 /* Generate the code to call destructor on base class.
12895 If this destructor belongs to a class with virtual
12896 functions, then set the virtual function table
12897 pointer to represent the type of our base class. */
8d08fdba 12898
5566b478
MS
12899 /* This side-effect makes call to `build_delete' generate the
12900 code we have to have at the end of this destructor. */
12901 TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
8d08fdba 12902
5566b478
MS
12903 /* These are two cases where we cannot delegate deletion. */
12904 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
12905 || TYPE_GETS_REG_DELETE (current_class_type))
4ac14744 12906 exprstmt = build_delete (current_class_type, current_class_ref, integer_zero_node,
e92cc029 12907 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, 0);
5566b478 12908 else
4ac14744 12909 exprstmt = build_delete (current_class_type, current_class_ref, in_charge_node,
e92cc029 12910 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, 0);
5566b478
MS
12911
12912 /* If we did not assign to this, then `this' is non-zero at
12913 the end of a destructor. As a special optimization, don't
12914 emit test if this is an empty destructor. If it does nothing,
12915 it does nothing. If it calls a base destructor, the base
12916 destructor will perform the test. */
12917
12918 if (exprstmt != error_mark_node
12919 && (TREE_CODE (exprstmt) != NOP_EXPR
12920 || TREE_OPERAND (exprstmt, 0) != integer_zero_node
12921 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
8d08fdba 12922 {
5566b478
MS
12923 expand_label (dtor_label);
12924 if (cond != integer_one_node)
12925 expand_start_cond (cond, 0);
12926 if (exprstmt != void_zero_node)
12927 /* Don't call `expand_expr_stmt' if we're not going to do
12928 anything, since -Wall will give a diagnostic. */
12929 expand_expr_stmt (exprstmt);
12930
12931 /* Run destructor on all virtual baseclasses. */
12932 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
8d08fdba 12933 {
5566b478
MS
12934 tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
12935 expand_start_cond (build (BIT_AND_EXPR, integer_type_node,
12936 in_charge_node, integer_two_node), 0);
12937 while (vbases)
8d08fdba 12938 {
5566b478
MS
12939 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
12940 {
bd6dd845
MS
12941 tree vb = get_vbase
12942 (BINFO_TYPE (vbases),
8ea2460f 12943 TYPE_BINFO (current_class_type));
e92cc029 12944 expand_expr_stmt
bd6dd845
MS
12945 (build_scoped_method_call
12946 (current_class_ref, vb, dtor_identifier,
e66d884e 12947 build_expr_list (NULL_TREE, integer_zero_node)));
5566b478
MS
12948 }
12949 vbases = TREE_CHAIN (vbases);
8d08fdba 12950 }
5566b478 12951 expand_end_cond ();
8d08fdba 12952 }
5566b478
MS
12953
12954 do_pending_stack_adjust ();
12955 if (cond != integer_one_node)
12956 expand_end_cond ();
8d08fdba
MS
12957 }
12958
5566b478
MS
12959 TYPE_HAS_DESTRUCTOR (current_class_type) = 1;
12960
12961 virtual_size = c_sizeof (current_class_type);
12962
12963 /* At the end, call delete if that's what's requested. */
519ebd1e
JM
12964
12965 /* FDIS sez: At the point of definition of a virtual destructor
12966 (including an implicit definition), non-placement operator
12967 delete shall be looked up in the scope of the destructor's
12968 class and if found shall be accessible and unambiguous.
12969
12970 This is somewhat unclear, but I take it to mean that if the
12971 class only defines placement deletes we don't do anything here.
12972 So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain
12973 for us if they ever try to delete one of these. */
12974
12975 if (TYPE_GETS_REG_DELETE (current_class_type)
12976 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
12977 exprstmt = build_op_delete_call
12978 (DELETE_EXPR, current_class_ptr, virtual_size,
12979 LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
5566b478
MS
12980 else
12981 exprstmt = NULL_TREE;
8d08fdba 12982
5566b478
MS
12983 if (exprstmt)
12984 {
12985 cond = build (BIT_AND_EXPR, integer_type_node,
12986 in_charge_node, integer_one_node);
12987 expand_start_cond (cond, 0);
12988 expand_expr_stmt (exprstmt);
12989 expand_end_cond ();
12990 }
8d08fdba 12991
5566b478 12992 /* End of destructor. */
fc378698 12993 expand_end_bindings (NULL_TREE, getdecls () != NULL_TREE, 0);
5566b478
MS
12994 poplevel (2, 0, 0); /* XXX change to 1 */
12995
12996 /* Back to the top of destructor. */
956d6950 12997 /* Don't execute destructor code if `this' is NULL. */
5566b478
MS
12998
12999 start_sequence ();
13000
13001 /* If the dtor is empty, and we know there is not possible way we
13002 could use any vtable entries, before they are possibly set by
13003 a base class dtor, we don't have to setup the vtables, as we
13004 know that any base class dtoring will set up any vtables it
13005 needs. We avoid MI, because one base class dtor can do a
13006 virtual dispatch to an overridden function that would need to
13007 have a non-related vtable set up, we cannot avoid setting up
13008 vtables in that case. We could change this to see if there is
13009 just one vtable. */
13010 if (! empty_dtor || TYPE_USES_COMPLEX_INHERITANCE (current_class_type))
13011 {
13012 /* Make all virtual function table pointers in non-virtual base
13013 classes point to CURRENT_CLASS_TYPE's virtual function
13014 tables. */
4ac14744 13015 expand_direct_vtbls_init (binfo, binfo, 1, 0, current_class_ptr);
8d08fdba 13016
5566b478 13017 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
4ac14744 13018 expand_indirect_vtbls_init (binfo, current_class_ref, current_class_ptr);
5566b478
MS
13019 }
13020
13021 if (! ok_to_optimize_dtor)
13022 {
13023 cond = build_binary_op (NE_EXPR,
4ac14744 13024 current_class_ptr, integer_zero_node, 1);
5566b478
MS
13025 expand_start_cond (cond, 0);
13026 }
8d08fdba 13027
5566b478
MS
13028 insns = get_insns ();
13029 end_sequence ();
f30432d7 13030
5566b478
MS
13031 last_parm_insn = get_first_nonparm_insn ();
13032 if (last_parm_insn == NULL_RTX)
13033 last_parm_insn = get_last_insn ();
13034 else
13035 last_parm_insn = previous_insn (last_parm_insn);
8d08fdba 13036
5566b478 13037 emit_insns_after (insns, last_parm_insn);
72b7eeff 13038
5566b478
MS
13039 if (! ok_to_optimize_dtor)
13040 expand_end_cond ();
72b7eeff 13041 }
5566b478 13042 else if (current_function_assigns_this)
8d08fdba 13043 {
5566b478
MS
13044 /* Does not need to call emit_base_init, because
13045 that is done (if needed) just after assignment to this
13046 is seen. */
13047
13048 if (DECL_CONSTRUCTOR_P (current_function_decl))
13049 {
13050 end_protect_partials ();
13051 expand_label (ctor_label);
13052 ctor_label = NULL_TREE;
13053
13054 if (call_poplevel)
13055 {
13056 decls = getdecls ();
13057 expand_end_bindings (decls, decls != NULL_TREE, 0);
13058 poplevel (decls != NULL_TREE, 0, 0);
13059 }
1c2c08a5
JM
13060 /* c_expand_return knows to return 'this' from a constructor. */
13061 c_expand_return (NULL_TREE);
5566b478 13062 }
a1774733 13063 else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl))) != VOID_TYPE
5566b478
MS
13064 && return_label != NULL_RTX)
13065 no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13066
13067 current_function_assigns_this = 0;
13068 current_function_just_assigned_this = 0;
13069 base_init_expr = NULL_TREE;
8d08fdba 13070 }
5566b478
MS
13071 else if (DECL_CONSTRUCTOR_P (fndecl))
13072 {
a703fb38 13073 tree cond = NULL_TREE, thenclause = NULL_TREE;
5566b478
MS
13074 /* Allow constructor for a type to get a new instance of the object
13075 using `build_new'. */
13076 tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type);
13077 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = NULL_TREE;
f30432d7 13078
5566b478 13079 DECL_RETURNS_FIRST_ARG (fndecl) = 1;
f30432d7 13080
5566b478
MS
13081 if (flag_this_is_variable > 0)
13082 {
13083 cond = build_binary_op (EQ_EXPR,
4ac14744
MS
13084 current_class_ptr, integer_zero_node, 1);
13085 thenclause = build_modify_expr (current_class_ptr, NOP_EXPR,
5566b478
MS
13086 build_new (NULL_TREE, current_class_type, void_type_node, 0));
13087 }
f30432d7 13088
5566b478 13089 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = abstract_virtuals;
f30432d7 13090
5566b478
MS
13091 start_sequence ();
13092
13093 if (flag_this_is_variable > 0)
13094 {
13095 expand_start_cond (cond, 0);
13096 expand_expr_stmt (thenclause);
13097 expand_end_cond ();
13098 }
13099
13100 /* Emit insns from `emit_base_init' which sets up virtual
13101 function table pointer(s). */
13102 if (base_init_expr)
13103 {
13104 expand_expr_stmt (base_init_expr);
13105 base_init_expr = NULL_TREE;
13106 }
13107
13108 insns = get_insns ();
13109 end_sequence ();
13110
b87692e5 13111 /* This is where the body of the constructor begins. */
5566b478 13112
b87692e5 13113 emit_insns_after (insns, last_parm_cleanup_insn);
8d08fdba 13114
b7484fbe 13115 end_protect_partials ();
5566b478
MS
13116
13117 /* This is where the body of the constructor ends. */
8d08fdba
MS
13118 expand_label (ctor_label);
13119 ctor_label = NULL_TREE;
13120
13121 if (call_poplevel)
13122 {
13123 decls = getdecls ();
8d08fdba 13124 expand_end_bindings (decls, decls != NULL_TREE, 0);
5566b478 13125 poplevel (decls != NULL_TREE, 1, 0);
8d08fdba 13126 }
8d08fdba 13127
1c2c08a5
JM
13128 /* c_expand_return knows to return 'this' from a constructor. */
13129 c_expand_return (NULL_TREE);
8d08fdba 13130
5566b478
MS
13131 current_function_assigns_this = 0;
13132 current_function_just_assigned_this = 0;
13133 }
35680744 13134 else if (DECL_MAIN_P (fndecl))
8d08fdba 13135 {
5566b478
MS
13136 /* Make it so that `main' always returns 0 by default. */
13137#ifdef VMS
13138 c_expand_return (integer_one_node);
13139#else
13140 c_expand_return (integer_zero_node);
13141#endif
8d08fdba 13142 }
5566b478
MS
13143 else if (return_label != NULL_RTX
13144 && current_function_return_value == NULL_TREE
13145 && ! DECL_NAME (DECL_RESULT (current_function_decl)))
13146 no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
8d08fdba 13147
eb448459
MS
13148 if (flag_exceptions)
13149 expand_exception_blocks ();
13150
5566b478
MS
13151 /* If this function is supposed to return a value, ensure that
13152 we do not fall into the cleanups by mistake. The end of our
13153 function will look like this:
13154
13155 user code (may have return stmt somewhere)
13156 goto no_return_label
13157 cleanup_label:
13158 cleanups
13159 goto return_label
13160 no_return_label:
13161 NOTE_INSN_FUNCTION_END
13162 return_label:
13163 things for return
13164
13165 If the user omits a return stmt in the USER CODE section, we
13166 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13167 Otherwise, we won't. */
13168 if (no_return_label)
8d08fdba 13169 {
5566b478
MS
13170 DECL_CONTEXT (no_return_label) = fndecl;
13171 DECL_INITIAL (no_return_label) = error_mark_node;
13172 DECL_SOURCE_FILE (no_return_label) = input_filename;
13173 DECL_SOURCE_LINE (no_return_label) = lineno;
13174 expand_goto (no_return_label);
8d08fdba
MS
13175 }
13176
5566b478 13177 if (cleanup_label)
a9aedbc2 13178 {
2c73f9f5 13179 /* Remove the binding contour which is used
5566b478
MS
13180 to catch cleanup-generated temporaries. */
13181 expand_end_bindings (0, 0, 0);
13182 poplevel (0, 0, 0);
8d08fdba 13183
eb448459
MS
13184 /* Emit label at beginning of cleanup code for parameters. */
13185 emit_label (cleanup_label);
13186 }
b7484fbe 13187
5566b478
MS
13188 /* Get return value into register if that's where it's supposed to be. */
13189 if (original_result_rtx)
13190 fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
8d08fdba 13191
5566b478
MS
13192 /* Finish building code that will trigger warnings if users forget
13193 to make their functions return values. */
13194 if (no_return_label || cleanup_label)
13195 emit_jump (return_label);
13196 if (no_return_label)
8d08fdba 13197 {
5566b478
MS
13198 /* We don't need to call `expand_*_return' here because we
13199 don't need any cleanups here--this path of code is only
13200 for error checking purposes. */
13201 expand_label (no_return_label);
8d08fdba
MS
13202 }
13203
5566b478
MS
13204 /* Generate rtl for function exit. */
13205 expand_function_end (input_filename, lineno, 1);
8d08fdba 13206 }
8d2733ca 13207
8d08fdba
MS
13208 /* This must come after expand_function_end because cleanups might
13209 have declarations (from inline functions) that need to go into
13210 this function's blocks. */
13211 if (current_binding_level->parm_flag != 1)
13212 my_friendly_abort (122);
13213 poplevel (1, 0, 1);
13214
2c73f9f5 13215 /* Reset scope for C++: if we were in the scope of a class,
db5ae43f
MS
13216 then when we finish this function, we are not longer so.
13217 This cannot be done until we know for sure that no more
13218 class members will ever be referenced in this function
13219 (i.e., calls to destructors). */
13220 if (current_class_name)
13221 {
13222 ctype = current_class_type;
13223 pop_nested_class (1);
13224 }
13225 else
13226 pop_memoized_context (1);
13227
8d08fdba 13228 /* Must mark the RESULT_DECL as being in this function. */
c73964b2 13229 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
8d08fdba 13230
8d08fdba
MS
13231 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13232 to the FUNCTION_DECL node itself. */
13233 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13234
5156628f 13235 if (! processing_template_decl)
5566b478 13236 {
75650646
MM
13237 int saved_flag_keep_inline_functions =
13238 flag_keep_inline_functions;
13239
5566b478
MS
13240 /* So we can tell if jump_optimize sets it to 1. */
13241 can_reach_end = 0;
8d08fdba 13242
75650646 13243 if (DECL_CONTEXT (fndecl) != NULL_TREE
e1467ff2 13244 && hack_decl_function_context (fndecl))
75650646
MM
13245 /* Trick rest_of_compilation into not deferring output of this
13246 function, even if it is inline, since the rtl_obstack for
13247 this function is the function_obstack of the enclosing
13248 function and will be deallocated when the enclosing
13249 function is gone. See save_tree_status. */
13250 flag_keep_inline_functions = 1;
13251
6633d636
MS
13252 /* Run the optimizers and output the assembler code for this
13253 function. */
13254
13255 if (DECL_ARTIFICIAL (fndecl))
13256 {
13257 /* Do we really *want* to inline this synthesized method? */
13258
13259 int save_fif = flag_inline_functions;
13260 flag_inline_functions = 1;
13261
13262 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13263 will check our size. */
13264 DECL_INLINE (fndecl) = 0;
13265
13266 rest_of_compilation (fndecl);
13267 flag_inline_functions = save_fif;
13268 }
13269 else
13270 rest_of_compilation (fndecl);
8d08fdba 13271
75650646
MM
13272 flag_keep_inline_functions = saved_flag_keep_inline_functions;
13273
5566b478
MS
13274 if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
13275 {
13276 /* Set DECL_EXTERNAL so that assemble_external will be called as
13277 necessary. We'll clear it again in finish_file. */
13278 if (! DECL_EXTERNAL (fndecl))
13279 DECL_NOT_REALLY_EXTERN (fndecl) = 1;
13280 DECL_EXTERNAL (fndecl) = 1;
13281 mark_inline_for_output (fndecl);
13282 }
8926095f 13283
d2e5ee5c
MS
13284 if (ctype && TREE_ASM_WRITTEN (fndecl))
13285 note_debug_info_needed (ctype);
13286
5566b478 13287 current_function_returns_null |= can_reach_end;
8d08fdba 13288
5566b478
MS
13289 /* Since we don't normally go through c_expand_return for constructors,
13290 this normally gets the wrong value.
13291 Also, named return values have their return codes emitted after
13292 NOTE_INSN_FUNCTION_END, confusing jump.c. */
13293 if (DECL_CONSTRUCTOR_P (fndecl)
13294 || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
13295 current_function_returns_null = 0;
8d08fdba 13296
5566b478
MS
13297 if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
13298 cp_warning ("`noreturn' function `%D' does return", fndecl);
13299 else if ((warn_return_type || pedantic)
13300 && current_function_returns_null
a1774733 13301 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
5566b478
MS
13302 {
13303 /* If this function returns non-void and control can drop through,
13304 complain. */
14e403d4 13305 cp_warning ("control reaches end of non-void function `%D'", fndecl);
5566b478
MS
13306 }
13307 /* With just -W, complain only if function returns both with
13308 and without a value. */
13309 else if (extra_warnings
13310 && current_function_returns_value && current_function_returns_null)
13311 warning ("this function may return with or without a value");
8d08fdba 13312 }
5566b478
MS
13313
13314 --function_depth;
8d08fdba
MS
13315
13316 /* Free all the tree nodes making up this function. */
13317 /* Switch back to allocating nodes permanently
13318 until we start another function. */
5156628f 13319 if (processing_template_decl)
5566b478
MS
13320 {
13321 --minimal_parse_mode;
13322 DECL_SAVED_TREE (fndecl) = TREE_CHAIN (DECL_SAVED_TREE (fndecl));
13323 }
13324
db5ae43f
MS
13325 if (! nested)
13326 permanent_allocation (1);
8d08fdba 13327
8d08fdba
MS
13328 if (DECL_SAVED_INSNS (fndecl) == NULL_RTX)
13329 {
d2e5ee5c
MS
13330 tree t;
13331
8d08fdba
MS
13332 /* Stop pointing to the local nodes about to be freed. */
13333 /* But DECL_INITIAL must remain nonzero so we know this
13334 was an actual function definition. */
13335 DECL_INITIAL (fndecl) = error_mark_node;
d2e5ee5c 13336 for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
de22184b 13337 DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
8d08fdba
MS
13338 }
13339
e1cd6e56
MS
13340 if (DECL_STATIC_CONSTRUCTOR (fndecl))
13341 static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
13342 if (DECL_STATIC_DESTRUCTOR (fndecl))
13343 static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
13344
28cbf42c
MS
13345 if (! nested)
13346 {
13347 /* Let the error reporting routines know that we're outside a
13348 function. For a nested function, this value is used in
13349 pop_cp_function_context and then reset via pop_function_context. */
13350 current_function_decl = NULL_TREE;
13351 }
13352
e349ee73 13353 named_label_uses = NULL;
4ac14744
MS
13354 current_class_ptr = NULL_TREE;
13355 current_class_ref = NULL_TREE;
8d08fdba
MS
13356}
13357\f
13358/* Create the FUNCTION_DECL for a function definition.
13359 LINE1 is the line number that the definition absolutely begins on.
13360 LINE2 is the line number that the name of the function appears on.
13361 DECLSPECS and DECLARATOR are the parts of the declaration;
13362 they describe the return type and the name of the function,
13363 but twisted together in a fashion that parallels the syntax of C.
13364
13365 This function creates a binding context for the function body
13366 as well as setting up the FUNCTION_DECL in current_function_decl.
13367
13368 Returns a FUNCTION_DECL on success.
13369
13370 If the DECLARATOR is not suitable for a function (it defines a datum
13371 instead), we return 0, which tells yyparse to report a parse error.
13372
13373 May return void_type_node indicating that this method is actually
13374 a friend. See grokfield for more details.
13375
13376 Came here with a `.pushlevel' .
13377
13378 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13379 CHANGES TO CODE IN `grokfield'. */
e92cc029 13380
8d08fdba 13381tree
c11b6f21
MS
13382start_method (declspecs, declarator)
13383 tree declarator, declspecs;
8d08fdba 13384{
c11b6f21 13385 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
f30432d7 13386 NULL_TREE);
8d08fdba
MS
13387
13388 /* Something too ugly to handle. */
13389 if (fndecl == NULL_TREE)
13390 return NULL_TREE;
13391
13392 /* Pass friends other than inline friend functions back. */
a1774733 13393 if (fndecl == void_type_node)
8d08fdba
MS
13394 return fndecl;
13395
13396 if (TREE_CODE (fndecl) != FUNCTION_DECL)
13397 /* Not a function, tell parser to report parse error. */
13398 return NULL_TREE;
13399
13400 if (IS_SIGNATURE (current_class_type))
824b9a4c 13401 IS_DEFAULT_IMPLEMENTATION (fndecl) = 1;
8d08fdba
MS
13402
13403 if (DECL_IN_AGGR_P (fndecl))
13404 {
13405 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
13406 {
2c73f9f5
ML
13407 if (DECL_CONTEXT (fndecl)
13408 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
8d08fdba
MS
13409 cp_error ("`%D' is already defined in class %s", fndecl,
13410 TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
13411 }
13412 return void_type_node;
13413 }
13414
faae18ab
MS
13415 DECL_THIS_INLINE (fndecl) = 1;
13416
8926095f 13417 if (flag_default_inline)
8d08fdba
MS
13418 DECL_INLINE (fndecl) = 1;
13419
36a117a5
MM
13420 /* We process method specializations in finish_struct_1. */
13421 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
3ac3d9ea 13422 fndecl = push_template_decl (fndecl);
a0a33927 13423
8d08fdba
MS
13424 /* We read in the parameters on the maybepermanent_obstack,
13425 but we won't be getting back to them until after we
13426 may have clobbered them. So the call to preserve_data
13427 will keep them safe. */
13428 preserve_data ();
13429
13430 if (! DECL_FRIEND_P (fndecl))
13431 {
8d08fdba
MS
13432 if (TREE_CHAIN (fndecl))
13433 {
13434 fndecl = copy_node (fndecl);
13435 TREE_CHAIN (fndecl) = NULL_TREE;
13436 }
13437
13438 if (DECL_CONSTRUCTOR_P (fndecl))
a0a33927
MS
13439 {
13440 if (! grok_ctor_properties (current_class_type, fndecl))
13441 return void_type_node;
13442 }
8d08fdba
MS
13443 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
13444 grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
13445 }
13446
82580166 13447 cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0, 0);
8d08fdba
MS
13448
13449 /* Make a place for the parms */
13450 pushlevel (0);
13451 current_binding_level->parm_flag = 1;
13452
13453 DECL_IN_AGGR_P (fndecl) = 1;
13454 return fndecl;
13455}
13456
13457/* Go through the motions of finishing a function definition.
13458 We don't compile this method until after the whole class has
13459 been processed.
13460
13461 FINISH_METHOD must return something that looks as though it
13462 came from GROKFIELD (since we are defining a method, after all).
13463
13464 This is called after parsing the body of the function definition.
13465 STMTS is the chain of statements that makes up the function body.
13466
13467 DECL is the ..._DECL that `start_method' provided. */
13468
13469tree
13470finish_method (decl)
13471 tree decl;
13472{
13473 register tree fndecl = decl;
13474 tree old_initial;
8d08fdba
MS
13475
13476 register tree link;
13477
a1774733 13478 if (decl == void_type_node)
8d08fdba
MS
13479 return decl;
13480
13481 old_initial = DECL_INITIAL (fndecl);
13482
13483 /* Undo the level for the parms (from start_method).
13484 This is like poplevel, but it causes nothing to be
13485 saved. Saving information here confuses symbol-table
13486 output routines. Besides, this information will
13487 be correctly output when this method is actually
13488 compiled. */
13489
13490 /* Clear out the meanings of the local variables of this level;
13491 also record in each decl which block it belongs to. */
13492
13493 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
13494 {
13495 if (DECL_NAME (link) != NULL_TREE)
13496 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
13497 my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
13498 DECL_CONTEXT (link) = NULL_TREE;
13499 }
13500
13501 /* Restore all name-meanings of the outer levels
13502 that were shadowed by this level. */
13503
13504 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
13505 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
13506 for (link = current_binding_level->class_shadowed;
13507 link; link = TREE_CHAIN (link))
13508 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
13509 for (link = current_binding_level->type_shadowed;
13510 link; link = TREE_CHAIN (link))
2c73f9f5 13511 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
8d08fdba
MS
13512
13513 GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
13514 (HOST_WIDE_INT) current_binding_level->level_chain,
13515 current_binding_level->parm_flag,
5566b478 13516 current_binding_level->keep);
8d08fdba
MS
13517
13518 poplevel (0, 0, 0);
13519
13520 DECL_INITIAL (fndecl) = old_initial;
13521
13522 /* We used to check if the context of FNDECL was different from
13523 current_class_type as another way to get inside here. This didn't work
13524 for String.cc in libg++. */
13525 if (DECL_FRIEND_P (fndecl))
13526 {
13527 CLASSTYPE_INLINE_FRIENDS (current_class_type)
13528 = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
13529 decl = void_type_node;
13530 }
13531
13532 return decl;
13533}
13534\f
13535/* Called when a new struct TYPE is defined.
13536 If this structure or union completes the type of any previous
13537 variable declaration, lay it out and output its rtl. */
13538
13539void
13540hack_incomplete_structures (type)
13541 tree type;
13542{
f30432d7 13543 tree *list;
8d08fdba 13544
f30432d7 13545 if (current_binding_level->incomplete == NULL_TREE)
8d08fdba
MS
13546 return;
13547
13548 if (!type) /* Don't do this for class templates. */
13549 return;
13550
f30432d7
MS
13551 for (list = &current_binding_level->incomplete; *list; )
13552 {
13553 tree decl = TREE_VALUE (*list);
a703fb38 13554 if ((decl && TREE_TYPE (decl) == type)
f30432d7
MS
13555 || (TREE_TYPE (decl)
13556 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
13557 && TREE_TYPE (TREE_TYPE (decl)) == type))
13558 {
13559 int toplevel = toplevel_bindings_p ();
13560 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
13561 && TREE_TYPE (TREE_TYPE (decl)) == type)
13562 layout_type (TREE_TYPE (decl));
13563 layout_decl (decl, 0);
13564 rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
13565 if (! toplevel)
13566 {
13567 tree cleanup;
13568 expand_decl (decl);
13569 cleanup = maybe_build_cleanup (decl);
13570 expand_decl_init (decl);
e349ee73 13571 if (! expand_decl_cleanup (decl, cleanup))
f30432d7
MS
13572 cp_error ("parser lost in parsing declaration of `%D'",
13573 decl);
13574 }
13575 *list = TREE_CHAIN (*list);
13576 }
13577 else
13578 list = &TREE_CHAIN (*list);
13579 }
8d08fdba
MS
13580}
13581
8d08fdba 13582/* If DECL is of a type which needs a cleanup, build that cleanup here.
c73964b2 13583 See build_delete for information about AUTO_DELETE.
8d08fdba
MS
13584
13585 Don't build these on the momentary obstack; they must live
13586 the life of the binding contour. */
e92cc029 13587
c73964b2
MS
13588static tree
13589maybe_build_cleanup_1 (decl, auto_delete)
13590 tree decl, auto_delete;
8d08fdba
MS
13591{
13592 tree type = TREE_TYPE (decl);
13593 if (TYPE_NEEDS_DESTRUCTOR (type))
13594 {
13595 int temp = 0, flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
13596 tree rval;
8d08fdba
MS
13597
13598 if (TREE_CODE (decl) != PARM_DECL)
13599 temp = suspend_momentary ();
13600
13601 if (TREE_CODE (type) == ARRAY_TYPE)
13602 rval = decl;
13603 else
13604 {
13605 mark_addressable (decl);
13606 rval = build_unary_op (ADDR_EXPR, decl, 0);
13607 }
13608
13609 /* Optimize for space over speed here. */
13610 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
13611 || flag_expensive_optimizations)
13612 flags |= LOOKUP_NONVIRTUAL;
13613
c73964b2 13614 rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
8d08fdba
MS
13615
13616 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
13617 && ! TYPE_HAS_DESTRUCTOR (type))
e66d884e
JM
13618 rval = build_compound_expr (expr_tree_cons (NULL_TREE, rval,
13619 build_expr_list (NULL_TREE, build_vbase_delete (type, decl))));
8d08fdba 13620
8d08fdba
MS
13621 if (TREE_CODE (decl) != PARM_DECL)
13622 resume_momentary (temp);
13623
8d08fdba
MS
13624 return rval;
13625 }
13626 return 0;
13627}
c73964b2
MS
13628
13629/* If DECL is of a type which needs a cleanup, build that cleanup
13630 here. The cleanup does free the storage with a call to delete. */
13631
13632tree
13633maybe_build_cleanup_and_delete (decl)
13634 tree decl;
13635{
13636 return maybe_build_cleanup_1 (decl, integer_three_node);
13637}
13638
13639/* If DECL is of a type which needs a cleanup, build that cleanup
13640 here. The cleanup does not free the storage with a call a delete. */
13641
13642tree
13643maybe_build_cleanup (decl)
13644 tree decl;
13645{
13646 return maybe_build_cleanup_1 (decl, integer_two_node);
13647}
8d08fdba
MS
13648\f
13649/* Expand a C++ expression at the statement level.
13650 This is needed to ferret out nodes which have UNKNOWN_TYPE.
13651 The C++ type checker should get all of these out when
13652 expressions are combined with other, type-providing, expressions,
13653 leaving only orphan expressions, such as:
13654
e92cc029 13655 &class::bar; / / takes its address, but does nothing with it. */
8d08fdba 13656
8d08fdba
MS
13657void
13658cplus_expand_expr_stmt (exp)
13659 tree exp;
13660{
5156628f 13661 if (processing_template_decl)
5566b478
MS
13662 {
13663 add_tree (build_min_nt (EXPR_STMT, exp));
13664 return;
13665 }
13666
eb66be0e
MS
13667 /* Arrange for all temps to disappear. */
13668 expand_start_target_temps ();
13669
8d08fdba
MS
13670 if (TREE_TYPE (exp) == unknown_type_node)
13671 {
13672 if (TREE_CODE (exp) == ADDR_EXPR || TREE_CODE (exp) == TREE_LIST)
13673 error ("address of overloaded function with no contextual type information");
13674 else if (TREE_CODE (exp) == COMPONENT_REF)
13675 warning ("useless reference to a member function name, did you forget the ()?");
13676 }
13677 else
13678 {
8d08fdba
MS
13679 if (TREE_CODE (exp) == FUNCTION_DECL)
13680 {
13681 cp_warning ("reference, not call, to function `%D'", exp);
13682 warning ("at this point in file");
13683 }
8d08fdba 13684
63c68bb7
MS
13685#if 0
13686 /* We should do this eventually, but right now this causes regex.o from
13687 libg++ to miscompile, and tString to core dump. */
5b605f68 13688 exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
63c68bb7 13689#endif
b3e401c2
JM
13690
13691 /* Strip unused implicit INDIRECT_REFs of references. */
13692 if (TREE_CODE (exp) == INDIRECT_REF
13693 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == REFERENCE_TYPE)
13694 exp = TREE_OPERAND (exp, 0);
13695
d2e5ee5c
MS
13696 /* If we don't do this, we end up down inside expand_expr
13697 trying to do TYPE_MODE on the ERROR_MARK, and really
13698 go outside the bounds of the type. */
13699 if (exp != error_mark_node)
13700 expand_expr_stmt (break_out_cleanups (exp));
8d08fdba
MS
13701 }
13702
13703 /* Clean up any pending cleanups. This happens when a function call
13704 returns a cleanup-needing value that nobody uses. */
eb66be0e 13705 expand_end_target_temps ();
8d08fdba
MS
13706}
13707
13708/* When a stmt has been parsed, this function is called.
13709
13710 Currently, this function only does something within a
13711 constructor's scope: if a stmt has just assigned to this,
13712 and we are in a derived class, we call `emit_base_init'. */
13713
13714void
13715finish_stmt ()
13716{
13717 extern struct nesting *cond_stack, *loop_stack, *case_stack;
13718
13719
13720 if (current_function_assigns_this
13721 || ! current_function_just_assigned_this)
13722 return;
13723 if (DECL_CONSTRUCTOR_P (current_function_decl))
13724 {
13725 /* Constructors must wait until we are out of control
13726 zones before calling base constructors. */
13727 if (cond_stack || loop_stack || case_stack)
13728 return;
a9aedbc2 13729 expand_expr_stmt (base_init_expr);
8d08fdba
MS
13730 check_base_init (current_class_type);
13731 }
13732 current_function_assigns_this = 1;
8d08fdba
MS
13733}
13734
8d08fdba 13735/* Change a static member function definition into a FUNCTION_TYPE, instead
700f8a87
MS
13736 of the METHOD_TYPE that we create when it's originally parsed.
13737
13738 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
13739 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
13740 other decls. Either pass the addresses of local variables or NULL. */
13741
8857f91e 13742void
700f8a87
MS
13743revert_static_member_fn (decl, fn, argtypes)
13744 tree *decl, *fn, *argtypes;
8d08fdba 13745{
700f8a87
MS
13746 tree tmp;
13747 tree function = fn ? *fn : TREE_TYPE (*decl);
13748 tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
8d08fdba 13749
f30432d7
MS
13750 if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (args))))
13751 cp_error ("static member function `%#D' declared const", *decl);
13752 if (TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (args))))
13753 cp_error ("static member function `%#D' declared volatile", *decl);
13754
700f8a87
MS
13755 args = TREE_CHAIN (args);
13756 tmp = build_function_type (TREE_TYPE (function), args);
8d08fdba
MS
13757 tmp = build_type_variant (tmp, TYPE_READONLY (function),
13758 TYPE_VOLATILE (function));
f30432d7 13759 tmp = build_exception_variant (tmp,
8d08fdba
MS
13760 TYPE_RAISES_EXCEPTIONS (function));
13761 TREE_TYPE (*decl) = tmp;
f30432d7
MS
13762 if (DECL_ARGUMENTS (*decl))
13763 DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
8d08fdba 13764 DECL_STATIC_FUNCTION_P (*decl) = 1;
700f8a87
MS
13765 if (fn)
13766 *fn = tmp;
13767 if (argtypes)
13768 *argtypes = args;
8d08fdba 13769}
a4443a08
MS
13770
13771int
13772id_in_current_class (id)
13773 tree id;
13774{
13775 return !!purpose_member (id, class_binding_level->class_shadowed);
13776}
db5ae43f
MS
13777
13778struct cp_function
13779{
13780 int returns_value;
13781 int returns_null;
13782 int warn_about_return_type;
db5ae43f
MS
13783 int assigns_this;
13784 int just_assigned_this;
13785 int parms_stored;
7215f9a0 13786 int temp_name_counter;
db5ae43f
MS
13787 tree named_labels;
13788 tree shadowed_labels;
13789 tree ctor_label;
13790 tree dtor_label;
72b7eeff 13791 rtx last_dtor_insn;
b87692e5 13792 rtx last_parm_cleanup_insn;
79ff2c6c
MS
13793 tree base_init_list;
13794 tree member_init_list;
a9aedbc2 13795 tree base_init_expr;
4ac14744
MS
13796 tree current_class_ptr;
13797 tree current_class_ref;
db5ae43f
MS
13798 rtx result_rtx;
13799 struct cp_function *next;
13800 struct binding_level *binding_level;
42976354 13801 int static_labelno;
db5ae43f
MS
13802};
13803
bd6dd845 13804static struct cp_function *cp_function_chain;
db5ae43f 13805
7215f9a0
MS
13806extern int temp_name_counter;
13807
db5ae43f
MS
13808/* Save and reinitialize the variables
13809 used during compilation of a C++ function. */
13810
13811void
28cbf42c
MS
13812push_cp_function_context (context)
13813 tree context;
db5ae43f
MS
13814{
13815 struct cp_function *p
13816 = (struct cp_function *) xmalloc (sizeof (struct cp_function));
13817
28cbf42c 13818 push_function_context_to (context);
db5ae43f
MS
13819
13820 p->next = cp_function_chain;
13821 cp_function_chain = p;
13822
13823 p->named_labels = named_labels;
13824 p->shadowed_labels = shadowed_labels;
13825 p->returns_value = current_function_returns_value;
13826 p->returns_null = current_function_returns_null;
13827 p->warn_about_return_type = warn_about_return_type;
db5ae43f
MS
13828 p->binding_level = current_binding_level;
13829 p->ctor_label = ctor_label;
13830 p->dtor_label = dtor_label;
72b7eeff 13831 p->last_dtor_insn = last_dtor_insn;
b87692e5 13832 p->last_parm_cleanup_insn = last_parm_cleanup_insn;
db5ae43f
MS
13833 p->assigns_this = current_function_assigns_this;
13834 p->just_assigned_this = current_function_just_assigned_this;
13835 p->parms_stored = current_function_parms_stored;
13836 p->result_rtx = original_result_rtx;
a9aedbc2 13837 p->base_init_expr = base_init_expr;
7215f9a0 13838 p->temp_name_counter = temp_name_counter;
79ff2c6c
MS
13839 p->base_init_list = current_base_init_list;
13840 p->member_init_list = current_member_init_list;
4ac14744
MS
13841 p->current_class_ptr = current_class_ptr;
13842 p->current_class_ref = current_class_ref;
42976354 13843 p->static_labelno = static_labelno;
db5ae43f
MS
13844}
13845
13846/* Restore the variables used during compilation of a C++ function. */
13847
13848void
28cbf42c
MS
13849pop_cp_function_context (context)
13850 tree context;
db5ae43f
MS
13851{
13852 struct cp_function *p = cp_function_chain;
13853 tree link;
13854
13855 /* Bring back all the labels that were shadowed. */
13856 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
13857 if (DECL_NAME (TREE_VALUE (link)) != 0)
13858 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)),
13859 TREE_VALUE (link));
13860
28cbf42c 13861 pop_function_context_from (context);
db5ae43f
MS
13862
13863 cp_function_chain = p->next;
13864
13865 named_labels = p->named_labels;
13866 shadowed_labels = p->shadowed_labels;
13867 current_function_returns_value = p->returns_value;
13868 current_function_returns_null = p->returns_null;
13869 warn_about_return_type = p->warn_about_return_type;
db5ae43f
MS
13870 current_binding_level = p->binding_level;
13871 ctor_label = p->ctor_label;
13872 dtor_label = p->dtor_label;
72b7eeff 13873 last_dtor_insn = p->last_dtor_insn;
b87692e5 13874 last_parm_cleanup_insn = p->last_parm_cleanup_insn;
db5ae43f
MS
13875 current_function_assigns_this = p->assigns_this;
13876 current_function_just_assigned_this = p->just_assigned_this;
13877 current_function_parms_stored = p->parms_stored;
13878 original_result_rtx = p->result_rtx;
a9aedbc2 13879 base_init_expr = p->base_init_expr;
7215f9a0 13880 temp_name_counter = p->temp_name_counter;
79ff2c6c
MS
13881 current_base_init_list = p->base_init_list;
13882 current_member_init_list = p->member_init_list;
4ac14744
MS
13883 current_class_ptr = p->current_class_ptr;
13884 current_class_ref = p->current_class_ref;
42976354 13885 static_labelno = p->static_labelno;
db5ae43f
MS
13886
13887 free (p);
13888}
ebfc180f 13889
5566b478
MS
13890int
13891in_function_p ()
13892{
13893 return function_depth != 0;
13894}
This page took 2.472129 seconds and 5 git commands to generate.