![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to decl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / cp|
Return to decl.c CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 root 1: /* Process declarations and variables for C compiler.
2: Copyright (C) 1988, 1992, 1993, 1994 Free Software Foundation, Inc.
3: Hacked by Michael Tiemann ([email protected])
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21:
22: /* Process declarations and symbol lookup for C front end.
23: Also constructs types; the standard scalar types at initialization,
24: and structure, union, array and enum types when they are declared. */
25:
26: /* ??? not all decl nodes are given the most useful possible
27: line numbers. For example, the CONST_DECLs for enum values. */
28:
29: #include <stdio.h>
30: #include "config.h"
31: #include "tree.h"
32: #include "rtl.h"
33: #include "flags.h"
34: #include "cp-tree.h"
35: #include "decl.h"
36: #include "lex.h"
37: #include <sys/types.h>
38: #include <signal.h>
39: #include "obstack.h"
40:
41: #define obstack_chunk_alloc xmalloc
42: #define obstack_chunk_free free
43:
44: extern tree builtin_return_address_fndecl;
45:
46: extern struct obstack permanent_obstack;
47:
48: extern int current_class_depth;
49:
50: extern tree cleanups_this_call;
51:
52: /* Stack of places to restore the search obstack back to. */
53:
54: /* Obstack used for remembering local class declarations (like
55: enums and static (const) members. */
56: #include "stack.h"
57: static struct obstack decl_obstack;
58: static struct stack_level *decl_stack;
59:
60: #ifndef CHAR_TYPE_SIZE
61: #define CHAR_TYPE_SIZE BITS_PER_UNIT
62: #endif
63:
64: #ifndef SHORT_TYPE_SIZE
65: #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
66: #endif
67:
68: #ifndef INT_TYPE_SIZE
69: #define INT_TYPE_SIZE BITS_PER_WORD
70: #endif
71:
72: #ifndef LONG_TYPE_SIZE
73: #define LONG_TYPE_SIZE BITS_PER_WORD
74: #endif
75:
76: #ifndef LONG_LONG_TYPE_SIZE
77: #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
78: #endif
79:
80: #ifndef WCHAR_UNSIGNED
81: #define WCHAR_UNSIGNED 0
82: #endif
83:
84: #ifndef FLOAT_TYPE_SIZE
85: #define FLOAT_TYPE_SIZE BITS_PER_WORD
86: #endif
87:
88: #ifndef DOUBLE_TYPE_SIZE
89: #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
90: #endif
91:
92: #ifndef LONG_DOUBLE_TYPE_SIZE
93: #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
94: #endif
95:
96: /* We let tm.h override the types used here, to handle trivial differences
97: such as the choice of unsigned int or long unsigned int for size_t.
98: When machines start needing nontrivial differences in the size type,
99: it would be best to do something here to figure out automatically
100: from other information what type to use. */
101:
102: #ifndef SIZE_TYPE
103: #define SIZE_TYPE "long unsigned int"
104: #endif
105:
106: #ifndef PTRDIFF_TYPE
107: #define PTRDIFF_TYPE "long int"
108: #endif
109:
110: #ifndef WCHAR_TYPE
111: #define WCHAR_TYPE "int"
112: #endif
113:
114: #define builtin_function(NAME, TYPE, CODE, LIBNAME) \
115: define_function (NAME, TYPE, CODE, (void (*)())pushdecl, LIBNAME)
116: #define auto_function(NAME, TYPE, CODE) \
117: do { \
118: tree __name = NAME; \
119: tree __type = TYPE; \
120: define_function (IDENTIFIER_POINTER (__name), __type, CODE, \
121: (void (*)())push_overloaded_decl_1, \
122: IDENTIFIER_POINTER (build_decl_overload (__name, TYPE_ARG_TYPES (__type), 0)));\
123: } while (0)
124:
125: static tree grokparms PROTO((tree, int));
126: static tree lookup_nested_type PROTO((tree, tree));
127: static char *redeclaration_error_message PROTO((tree, tree));
128: static void grok_op_properties PROTO((tree, int, int));
129:
130: tree define_function
131: PROTO((char *, tree, enum built_in_function, void (*)(), char *));
132:
133: /* a node which has tree code ERROR_MARK, and whose type is itself.
134: All erroneous expressions are replaced with this node. All functions
135: that accept nodes as arguments should avoid generating error messages
136: if this node is one of the arguments, since it is undesirable to get
137: multiple error messages from one error in the input. */
138:
139: tree error_mark_node;
140:
141: /* Erroneous argument lists can use this *IFF* they do not modify it. */
142: tree error_mark_list;
143:
144: /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
145:
146: tree short_integer_type_node;
147: tree integer_type_node;
148: tree long_integer_type_node;
149: tree long_long_integer_type_node;
150:
151: tree short_unsigned_type_node;
152: tree unsigned_type_node;
153: tree long_unsigned_type_node;
154: tree long_long_unsigned_type_node;
155:
156: tree ptrdiff_type_node;
157:
158: tree unsigned_char_type_node;
159: tree signed_char_type_node;
160: tree char_type_node;
161: tree wchar_type_node;
162: tree signed_wchar_type_node;
163: tree unsigned_wchar_type_node;
164:
165: tree wchar_decl_node;
166:
167: tree float_type_node;
168: tree double_type_node;
169: tree long_double_type_node;
170:
171: tree intQI_type_node;
172: tree intHI_type_node;
173: tree intSI_type_node;
174: tree intDI_type_node;
175:
176: tree unsigned_intQI_type_node;
177: tree unsigned_intHI_type_node;
178: tree unsigned_intSI_type_node;
179: tree unsigned_intDI_type_node;
180:
181: /* a VOID_TYPE node, and the same, packaged in a TREE_LIST. */
182:
183: tree void_type_node, void_list_node;
184: tree void_zero_node;
185:
186: /* Nodes for types `void *' and `const void *'. */
187:
188: tree ptr_type_node, const_ptr_type_node;
189:
190: /* Nodes for types `char *' and `const char *'. */
191:
192: tree string_type_node, const_string_type_node;
193:
194: /* Type `char[256]' or something like it.
195: Used when an array of char is needed and the size is irrelevant. */
196:
197: tree char_array_type_node;
198:
199: /* Type `int[256]' or something like it.
200: Used when an array of int needed and the size is irrelevant. */
201:
202: tree int_array_type_node;
203:
204: /* Type `wchar_t[256]' or something like it.
205: Used when a wide string literal is created. */
206:
207: tree wchar_array_type_node;
208:
209: /* The bool data type, and constants */
210: tree bool_type_node, true_node, false_node;
211:
212: /* type `int ()' -- used for implicit declaration of functions. */
213:
214: tree default_function_type;
215:
216: /* function types `double (double)' and `double (double, double)', etc. */
217:
218: tree double_ftype_double, double_ftype_double_double;
219: tree int_ftype_int, long_ftype_long;
220:
221: /* Function type `void (void *, void *, int)' and similar ones. */
222:
223: tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int, void_ftype_ptr_int_int;
224:
225: /* Function type `char *(char *, char *)' and similar ones */
226: tree string_ftype_ptr_ptr, int_ftype_string_string;
227:
228: /* Function type `size_t (const char *)' */
229: tree sizet_ftype_string;
230:
231: /* Function type `int (const void *, const void *, size_t)' */
232: tree int_ftype_cptr_cptr_sizet;
233:
234: /* C++ extensions */
235: tree vtable_entry_type;
236: tree delta_type_node;
237: tree __t_desc_type_node, __i_desc_type_node, __m_desc_type_node;
238: tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
239: tree class_star_type_node;
240: tree class_type_node, record_type_node, union_type_node, enum_type_node;
241: tree exception_type_node, unknown_type_node;
242: tree opaque_type_node, signature_type_node;
243: tree sigtable_entry_type;
244: tree maybe_gc_cleanup;
245:
246: /* Array type `vtable_entry_type[]' */
247: tree vtbl_type_node;
248:
249: /* In a destructor, the point at which all derived class destroying
250: has been done, just before any base class destroying will be done. */
251:
252: tree dtor_label;
253:
254: /* In a constructor, the point at which we are ready to return
255: the pointer to the initialized object. */
256:
257: tree ctor_label;
258:
259: /* A FUNCTION_DECL which can call `abort'. Not necessarily the
260: one that the user will declare, but sufficient to be called
261: by routines that want to abort the program. */
262:
263: tree abort_fndecl;
264:
265: extern rtx cleanup_label, return_label;
266:
267: /* If original DECL_RESULT of current function was a register,
268: but due to being an addressable named return value, would up
269: on the stack, this variable holds the named return value's
270: original location. */
271: rtx original_result_rtx;
272:
273: /* Sequence of insns which represents base initialization. */
274: rtx base_init_insns;
275:
276: /* C++: Keep these around to reduce calls to `get_identifier'.
277: Identifiers for `this' in member functions and the auto-delete
278: parameter for destructors. */
279: tree this_identifier, in_charge_identifier;
280: /* Used in pointer to member functions, and in vtables. */
281: tree pfn_identifier, index_identifier, delta_identifier, delta2_identifier;
282: tree pfn_or_delta2_identifier;
283:
284: /* A list (chain of TREE_LIST nodes) of named label uses.
285: The TREE_PURPOSE field is the list of variables defined
286: the the label's scope defined at the point of use.
287: The TREE_VALUE field is the LABEL_DECL used.
288: The TREE_TYPE field holds `current_binding_level' at the
289: point of the label's use.
290:
291: Used only for jumps to as-yet undefined labels, since
292: jumps to defined labels can have their validity checked
293: by stmt.c. */
294:
295: static tree named_label_uses;
296:
297: /* A list of objects which have constructors or destructors
298: which reside in the global scope. The decl is stored in
299: the TREE_VALUE slot and the initializer is stored
300: in the TREE_PURPOSE slot. */
301: tree static_aggregates;
302:
303: /* -- end of C++ */
304:
305: /* Two expressions that are constants with value zero.
306: The first is of type `int', the second of type `void *'. */
307:
308: tree integer_zero_node;
309: tree null_pointer_node;
310:
311: /* A node for the integer constants 1, 2, and 3. */
312:
313: tree integer_one_node, integer_two_node, integer_three_node;
314:
315: /* Nonzero if we have seen an invalid cross reference
316: to a struct, union, or enum, but not yet printed the message. */
317:
318: tree pending_invalid_xref;
319: /* File and line to appear in the eventual error message. */
320: char *pending_invalid_xref_file;
321: int pending_invalid_xref_line;
322:
323: /* While defining an enum type, this is 1 plus the last enumerator
324: constant value. */
325:
326: static tree enum_next_value;
327:
328: /* Nonzero means that there was overflow computing enum_next_value. */
329:
330: static int enum_overflow;
331:
332: /* Parsing a function declarator leaves a list of parameter names
333: or a chain or parameter decls here. */
334:
335: tree last_function_parms;
336:
337: /* Parsing a function declarator leaves here a chain of structure
338: and enum types declared in the parmlist. */
339:
340: static tree last_function_parm_tags;
341:
342: /* After parsing the declarator that starts a function definition,
343: `start_function' puts here the list of parameter names or chain of decls.
344: `store_parm_decls' finds it here. */
345:
346: static tree current_function_parms;
347:
348: /* Similar, for last_function_parm_tags. */
349: static tree current_function_parm_tags;
350:
351: /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
352: that have names. Here so we can clear out their names' definitions
353: at the end of the function. */
354:
355: static tree named_labels;
356:
357: /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
358:
359: static tree shadowed_labels;
360:
361: #if 0 /* Not needed by C++ */
362: /* Nonzero when store_parm_decls is called indicates a varargs function.
363: Value not meaningful after store_parm_decls. */
364:
365: static int c_function_varargs;
366: #endif
367:
368: /* The FUNCTION_DECL for the function currently being compiled,
369: or 0 if between functions. */
370: tree current_function_decl;
371:
372: /* Set to 0 at beginning of a function definition, set to 1 if
373: a return statement that specifies a return value is seen. */
374:
375: int current_function_returns_value;
376:
377: /* Set to 0 at beginning of a function definition, set to 1 if
378: a return statement with no argument is seen. */
379:
380: int current_function_returns_null;
381:
382: /* Set to 0 at beginning of a function definition, and whenever
383: a label (case or named) is defined. Set to value of expression
384: returned from function when that value can be transformed into
385: a named return value. */
386:
387: tree current_function_return_value;
388:
389: /* Set to nonzero by `grokdeclarator' for a function
390: whose return type is defaulted, if warnings for this are desired. */
391:
392: static int warn_about_return_type;
393:
394: /* Nonzero when starting a function declared `extern inline'. */
395:
396: static int current_extern_inline;
397:
398: /* Nonzero means give `double' the same size as `float'. */
399:
400: extern int flag_short_double;
401:
402: /* Nonzero means don't recognize any builtin functions. */
403:
404: extern int flag_no_builtin;
405:
406: /* Nonzero means don't recognize the non-ANSI builtin functions.
407: -ansi sets this. */
408:
409: extern int flag_no_nonansi_builtin;
410:
411: /* Nonzero means disable GNU extensions. */
412:
413: extern int flag_ansi;
414:
415: /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
416: objects. */
417: extern int flag_huge_objects;
418:
419: /* Nonzero if we want to conserve space in the .o files. We do this
420: by putting uninitialized data and runtime initialized data into
421: .common instead of .data at the expense of not flaging multiple
422: definitions. */
423: extern int flag_conserve_space;
424:
425: /* Pointers to the base and current top of the language name stack. */
426:
427: extern tree *current_lang_base, *current_lang_stack;
428:
429: /* C and C++ flags are in decl2.c. */
430:
431: /* Set to 0 at beginning of a constructor, set to 1
432: if that function does an allocation before referencing its
433: instance variable. */
434: int current_function_assigns_this;
435: int current_function_just_assigned_this;
436:
437: /* Set to 0 at beginning of a function. Set non-zero when
438: store_parm_decls is called. Don't call store_parm_decls
439: if this flag is non-zero! */
440: int current_function_parms_stored;
441:
442: /* Current end of entries in the gc obstack for stack pointer variables. */
443:
444: int current_function_obstack_index;
445:
446: /* Flag saying whether we have used the obstack in this function or not. */
447:
448: int current_function_obstack_usage;
449:
450: /* Flag used when debugging spew.c */
451:
452: extern int spew_debug;
453:
454: /* This is a copy of the class_shadowed list of the previous class binding
455: contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
456: when entering another class scope (i.e. a cache miss). */
457: extern tree previous_class_values;
458:
459:
460: /* Allocate a level of searching. */
461: struct stack_level *
462: push_decl_level (stack, obstack)
463: struct stack_level *stack;
464: struct obstack *obstack;
465: {
466: struct stack_level tem;
467: tem.prev = stack;
468:
469: return push_stack_level (obstack, (char *)&tem, sizeof (tem));
470: }
471:
472: /* For each binding contour we allocate a binding_level structure
473: * which records the names defined in that contour.
474: * Contours include:
475: * 0) the global one
476: * 1) one for each function definition,
477: * where internal declarations of the parameters appear.
478: * 2) one for each compound statement,
479: * to record its declarations.
480: *
481: * The current meaning of a name can be found by searching the levels from
482: * the current one out to the global one.
483: *
484: * Off to the side, may be the class_binding_level. This exists
485: * only to catch class-local declarations. It is otherwise
486: * nonexistent.
487: *
488: * Also there may be binding levels that catch cleanups that
489: * must be run when exceptions occur.
490: */
491:
492: /* Note that the information in the `names' component of the global contour
493: is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
494:
495: struct binding_level
496: {
497: /* A chain of _DECL nodes for all variables, constants, functions,
498: * and typedef types. These are in the reverse of the order supplied.
499: */
500: tree names;
501:
502: /* A list of structure, union and enum definitions,
503: * for looking up tag names.
504: * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
505: * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
506: * or ENUMERAL_TYPE node.
507: *
508: * C++: the TREE_VALUE nodes can be simple types for component_bindings.
509: *
510: */
511: tree tags;
512:
513: /* For each level, a list of shadowed outer-level local definitions
514: to be restored when this level is popped.
515: Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
516: whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
517: tree shadowed;
518:
519: /* Same, for IDENTIFIER_CLASS_VALUE. */
520: tree class_shadowed;
521:
522: /* Same, for IDENTIFIER_TYPE_VALUE. */
523: tree type_shadowed;
524:
525: /* For each level (except not the global one),
526: a chain of BLOCK nodes for all the levels
527: that were entered and exited one level down. */
528: tree blocks;
529:
530: /* The BLOCK node for this level, if one has been preallocated.
531: If 0, the BLOCK is allocated (if needed) when the level is popped. */
532: tree this_block;
533:
534: /* The binding level which this one is contained in (inherits from). */
535: struct binding_level *level_chain;
536:
537: /* Number of decls in `names' that have incomplete
538: structure or union types. */
539: unsigned short n_incomplete;
540:
541: /* 1 for the level that holds the parameters of a function.
542: 2 for the level that holds a class declaration.
543: 3 for levels that hold parameter declarations. */
544: unsigned parm_flag : 4;
545:
546: /* 1 means make a BLOCK for this level regardless of all else.
547: 2 for temporary binding contours created by the compiler. */
548: unsigned keep : 3;
549:
550: /* Nonzero if this level "doesn't exist" for tags. */
551: unsigned tag_transparent : 1;
552:
553: /* Nonzero if this level can safely have additional
554: cleanup-needing variables added to it. */
555: unsigned more_cleanups_ok : 1;
556: unsigned have_cleanups : 1;
557:
558: /* Nonzero if we should accept any name as an identifier in
559: this scope. This happens in some template definitions. */
560: unsigned accept_any : 1;
561:
562: /* Nonzero if this level is for completing a template class definition
563: inside a binding level that temporarily binds the parameters. This
564: means that definitions here should not be popped off when unwinding
565: this binding level. (Not actually implemented this way,
566: unfortunately.) */
567: unsigned pseudo_global : 1;
568:
569: /* Two bits left for this word. */
570:
571: #if defined(DEBUG_CP_BINDING_LEVELS)
572: /* Binding depth at which this level began. */
573: unsigned binding_depth;
574: #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
575: };
576:
577: #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
578:
579: /* The (non-class) binding level currently in effect. */
580:
581: static struct binding_level *current_binding_level;
582:
583: /* The binding level of the current class, if any. */
584:
585: static struct binding_level *class_binding_level;
586:
587: /* The current (class or non-class) binding level currently in effect. */
588:
589: #define inner_binding_level \
590: (class_binding_level ? class_binding_level : current_binding_level)
591:
592: /* A chain of binding_level structures awaiting reuse. */
593:
594: static struct binding_level *free_binding_level;
595:
596: /* The outermost binding level, for names of file scope.
597: This is created when the compiler is started and exists
598: through the entire run. */
599:
600: static struct binding_level *global_binding_level;
601:
602: /* Binding level structures are initialized by copying this one. */
603:
604: static struct binding_level clear_binding_level;
605:
606: /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
607:
608: static int keep_next_level_flag;
609:
610: #if defined(DEBUG_CP_BINDING_LEVELS)
611: static int binding_depth = 0;
612: static int is_class_level = 0;
613:
614: static void
615: indent ()
616: {
617: register unsigned i;
618:
619: for (i = 0; i < binding_depth*2; i++)
620: putc (' ', stderr);
621: }
622: #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
623:
624: static tree pushdecl_with_scope PROTO((tree, struct binding_level *));
625:
626: static void
627: push_binding_level (newlevel, tag_transparent, keep)
628: struct binding_level *newlevel;
629: int tag_transparent, keep;
630: {
631: /* Add this level to the front of the chain (stack) of levels that
632: are active. */
633: *newlevel = clear_binding_level;
634: if (class_binding_level)
635: {
636: newlevel->level_chain = class_binding_level;
637: class_binding_level = (struct binding_level *)0;
638: }
639: else
640: {
641: newlevel->level_chain = current_binding_level;
642: }
643: current_binding_level = newlevel;
644: newlevel->tag_transparent = tag_transparent;
645: newlevel->more_cleanups_ok = 1;
646: newlevel->keep = keep;
647: #if defined(DEBUG_CP_BINDING_LEVELS)
648: newlevel->binding_depth = binding_depth;
649: indent ();
650: fprintf (stderr, "push %s level 0x%08x line %d\n",
651: (is_class_level) ? "class" : "block", newlevel, lineno);
652: is_class_level = 0;
653: binding_depth++;
654: #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
655: }
656:
657: static void
658: pop_binding_level ()
659: {
660: if (class_binding_level)
661: current_binding_level = class_binding_level;
662:
663: if (global_binding_level)
664: {
665: /* cannot pop a level, if there are none left to pop. */
666: if (current_binding_level == global_binding_level)
667: my_friendly_abort (123);
668: }
669: /* Pop the current level, and free the structure for reuse. */
670: #if defined(DEBUG_CP_BINDING_LEVELS)
671: binding_depth--;
672: indent ();
673: fprintf (stderr, "pop %s level 0x%08x line %d\n",
674: (is_class_level) ? "class" : "block",
675: current_binding_level, lineno);
676: if (is_class_level != (current_binding_level == class_binding_level))
677: #if 0 /* XXX Don't abort when we're watching how things are being managed. */
678: abort ();
679: #else
680: {
681: indent ();
682: fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
683: }
684: #endif
685: is_class_level = 0;
686: #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
687: {
688: register struct binding_level *level = current_binding_level;
689: current_binding_level = current_binding_level->level_chain;
690: level->level_chain = free_binding_level;
691: #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
692: if (level->binding_depth != binding_depth)
693: abort ();
694: #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
695: free_binding_level = level;
696:
697: class_binding_level = current_binding_level;
698: if (class_binding_level->parm_flag != 2)
699: class_binding_level = 0;
700: while (current_binding_level->parm_flag == 2)
701: current_binding_level = current_binding_level->level_chain;
702: }
703: }
704:
705: /* Nonzero if we are currently in the global binding level. */
706:
707: int
708: global_bindings_p ()
709: {
710: return current_binding_level == global_binding_level;
711: }
712:
713: void
714: keep_next_level ()
715: {
716: keep_next_level_flag = 1;
717: }
718:
719: /* Nonzero if the current level needs to have a BLOCK made. */
720:
721: int
722: kept_level_p ()
723: {
724: return (current_binding_level->blocks != NULL_TREE
725: || current_binding_level->keep
726: || current_binding_level->names != NULL_TREE
727: || (current_binding_level->tags != NULL_TREE
728: && !current_binding_level->tag_transparent));
729: }
730:
731: /* Identify this binding level as a level of parameters. */
732:
733: void
734: declare_parm_level ()
735: {
736: current_binding_level->parm_flag = 1;
737: }
738:
739: void
740: declare_uninstantiated_type_level ()
741: {
742: current_binding_level->accept_any = 1;
743: }
744:
745: int
746: uninstantiated_type_level_p ()
747: {
748: return current_binding_level->accept_any;
749: }
750:
751: void
752: declare_pseudo_global_level ()
753: {
754: current_binding_level->pseudo_global = 1;
755: }
756:
757: int
758: pseudo_global_level_p ()
759: {
760: return current_binding_level->pseudo_global;
761: }
762:
763: void
764: set_class_shadows (shadows)
765: tree shadows;
766: {
767: class_binding_level->class_shadowed = shadows;
768: }
769:
770: /* Enter a new binding level.
771: If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
772: not for that of tags. */
773:
774: void
775: pushlevel (tag_transparent)
776: int tag_transparent;
777: {
778: register struct binding_level *newlevel = NULL_BINDING_LEVEL;
779:
780: /* If this is the top level of a function,
781: just make sure that NAMED_LABELS is 0.
782: They should have been set to 0 at the end of the previous function. */
783:
784: if (current_binding_level == global_binding_level)
785: my_friendly_assert (named_labels == NULL_TREE, 134);
786:
787: /* Reuse or create a struct for this binding level. */
788:
789: #if defined(DEBUG_CP_BINDING_LEVELS)
790: if (0)
791: #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
792: if (free_binding_level)
793: #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
794: {
795: newlevel = free_binding_level;
796: free_binding_level = free_binding_level->level_chain;
797: }
798: else
799: {
800: /* Create a new `struct binding_level'. */
801: newlevel = (struct binding_level *) xmalloc (sizeof (struct binding_level));
802: }
803: push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
804: GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
805: keep_next_level_flag = 0;
806: }
807:
808: void
809: pushlevel_temporary (tag_transparent)
810: int tag_transparent;
811: {
812: pushlevel (tag_transparent);
813: current_binding_level->keep = 2;
814: clear_last_expr ();
815:
816: /* Note we don't call push_momentary() here. Otherwise, it would cause
817: cleanups to be allocated on the momentary obstack, and they will be
818: overwritten by the next statement. */
819:
820: expand_start_bindings (0);
821: }
822:
823: /* Exit a binding level.
824: Pop the level off, and restore the state of the identifier-decl mappings
825: that were in effect when this level was entered.
826:
827: If KEEP == 1, this level had explicit declarations, so
828: and create a "block" (a BLOCK node) for the level
829: to record its declarations and subblocks for symbol table output.
830:
831: If KEEP == 2, this level's subblocks go to the front,
832: not the back of the current binding level. This happens,
833: for instance, when code for constructors and destructors
834: need to generate code at the end of a function which must
835: be moved up to the front of the function.
836:
837: If FUNCTIONBODY is nonzero, this level is the body of a function,
838: so create a block as if KEEP were set and also clear out all
839: label names.
840:
841: If REVERSE is nonzero, reverse the order of decls before putting
842: them into the BLOCK. */
843:
844: tree
845: poplevel (keep, reverse, functionbody)
846: int keep;
847: int reverse;
848: int functionbody;
849: {
850: register tree link;
851: /* The chain of decls was accumulated in reverse order.
852: Put it into forward order, just for cleanliness. */
853: tree decls;
854: int tmp = functionbody;
855: int implicit_try_block = current_binding_level->parm_flag == 3;
856: int real_functionbody = current_binding_level->keep == 2
857: ? ((functionbody = 0), tmp) : functionbody;
858: tree tags = functionbody >= 0 ? current_binding_level->tags : 0;
859: tree subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
860: tree block = NULL_TREE;
861: tree decl;
862: int block_previously_created;
863:
864: GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
865: (HOST_WIDE_INT) current_binding_level->level_chain,
866: current_binding_level->parm_flag,
867: current_binding_level->keep,
868: current_binding_level->tag_transparent);
869:
870: if (current_binding_level->keep == 1)
871: keep = 1;
872:
873: /* This warning is turned off because it causes warnings for
874: declarations like `extern struct foo *x'. */
875: #if 0
876: /* Warn about incomplete structure types in this level. */
877: for (link = tags; link; link = TREE_CHAIN (link))
878: if (TYPE_SIZE (TREE_VALUE (link)) == NULL_TREE)
879: {
880: tree type = TREE_VALUE (link);
881: char *errmsg;
882: switch (TREE_CODE (type))
883: {
884: case RECORD_TYPE:
885: errmsg = "`struct %s' incomplete in scope ending here";
886: break;
887: case UNION_TYPE:
888: errmsg = "`union %s' incomplete in scope ending here";
889: break;
890: case ENUMERAL_TYPE:
891: errmsg = "`enum %s' incomplete in scope ending here";
892: break;
893: }
894: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
895: error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
896: else
897: /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
898: error (errmsg, TYPE_NAME_STRING (type));
899: }
900: #endif /* 0 */
901:
902: /* Get the decls in the order they were written.
903: Usually current_binding_level->names is in reverse order.
904: But parameter decls were previously put in forward order. */
905:
906: if (reverse)
907: current_binding_level->names
908: = decls = nreverse (current_binding_level->names);
909: else
910: decls = current_binding_level->names;
911:
912: /* Output any nested inline functions within this block
913: if they weren't already output. */
914:
915: for (decl = decls; decl; decl = TREE_CHAIN (decl))
916: if (TREE_CODE (decl) == FUNCTION_DECL
917: && ! TREE_ASM_WRITTEN (decl)
918: && DECL_INITIAL (decl) != NULL_TREE
919: && TREE_ADDRESSABLE (decl))
920: {
921: /* If this decl was copied from a file-scope decl
922: on account of a block-scope extern decl,
923: propagate TREE_ADDRESSABLE to the file-scope decl. */
924: if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
925: TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
926: else
927: {
928: push_function_context ();
929: output_inline_function (decl);
930: pop_function_context ();
931: }
932: }
933:
934: /* If there were any declarations or structure tags in that level,
935: or if this level is a function body,
936: create a BLOCK to record them for the life of this function. */
937:
938: block = NULL_TREE;
939: block_previously_created = (current_binding_level->this_block != NULL_TREE);
940: if (block_previously_created)
941: block = current_binding_level->this_block;
942: else if (keep == 1 || functionbody)
943: block = make_node (BLOCK);
944: if (block != NULL_TREE)
945: {
946: BLOCK_VARS (block) = decls;
947: BLOCK_TYPE_TAGS (block) = tags;
948: BLOCK_SUBBLOCKS (block) = subblocks;
949: /* If we created the block earlier on, and we are just diddling it now,
950: then it already should have a proper BLOCK_END_NOTE value associated
951: with it, so avoid trashing that. Otherwise, for a new block, install
952: a new BLOCK_END_NOTE value. */
953: if (! block_previously_created)
954: remember_end_note (block);
955: }
956:
957: /* In each subblock, record that this is its superior. */
958:
959: if (keep >= 0)
960: for (link = subblocks; link; link = TREE_CHAIN (link))
961: BLOCK_SUPERCONTEXT (link) = block;
962:
963: /* Clear out the meanings of the local variables of this level. */
964:
965: for (link = decls; link; link = TREE_CHAIN (link))
966: {
967: if (DECL_NAME (link) != NULL_TREE)
968: {
969: /* If the ident. was used or addressed via a local extern decl,
970: don't forget that fact. */
971: if (DECL_EXTERNAL (link))
972: {
973: if (TREE_USED (link))
974: TREE_USED (DECL_ASSEMBLER_NAME (link)) = 1;
975: if (TREE_ADDRESSABLE (link))
976: TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
977: }
978: IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = NULL_TREE;
979: }
980: }
981:
982: /* Restore all name-meanings of the outer levels
983: that were shadowed by this level. */
984:
985: for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
986: IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
987: for (link = current_binding_level->class_shadowed;
988: link; link = TREE_CHAIN (link))
989: IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
990: for (link = current_binding_level->type_shadowed;
991: link; link = TREE_CHAIN (link))
992: IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
993:
994: /* If the level being exited is the top level of a function,
995: check over all the labels. */
996:
997: if (functionbody)
998: {
999: /* If this is the top level block of a function,
1000: the vars are the function's parameters.
1001: Don't leave them in the BLOCK because they are
1002: found in the FUNCTION_DECL instead. */
1003:
1004: BLOCK_VARS (block) = 0;
1005:
1006: /* Clear out the definitions of all label names,
1007: since their scopes end here. */
1008:
1009: for (link = named_labels; link; link = TREE_CHAIN (link))
1010: {
1011: register tree label = TREE_VALUE (link);
1012:
1013: if (DECL_INITIAL (label) == NULL_TREE)
1014: {
1015: cp_error_at ("label `%D' used but not defined", label);
1016: /* Avoid crashing later. */
1017: define_label (input_filename, 1, DECL_NAME (label));
1018: }
1019: else if (warn_unused && !TREE_USED (label))
1020: cp_warning_at ("label `%D' defined but not used", label);
1021: SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), NULL_TREE);
1022:
1023: /* Put the labels into the "variables" of the
1024: top-level block, so debugger can see them. */
1025: TREE_CHAIN (label) = BLOCK_VARS (block);
1026: BLOCK_VARS (block) = label;
1027: }
1028:
1029: named_labels = NULL_TREE;
1030: }
1031:
1032: /* Any uses of undefined labels now operate under constraints
1033: of next binding contour. */
1034: {
1035: struct binding_level *level_chain;
1036: level_chain = current_binding_level->level_chain;
1037: if (level_chain)
1038: {
1039: tree labels;
1040: for (labels = named_label_uses; labels; labels = TREE_CHAIN (labels))
1041: if (TREE_TYPE (labels) == (tree)current_binding_level)
1042: {
1043: TREE_TYPE (labels) = (tree)level_chain;
1044: TREE_PURPOSE (labels) = level_chain->names;
1045: }
1046: }
1047: }
1048:
1049: tmp = current_binding_level->keep;
1050:
1051: pop_binding_level ();
1052: if (functionbody)
1053: DECL_INITIAL (current_function_decl) = block;
1054: else if (block)
1055: {
1056: if (!block_previously_created)
1057: current_binding_level->blocks
1058: = chainon (current_binding_level->blocks, block);
1059: }
1060: /* If we did not make a block for the level just exited,
1061: any blocks made for inner levels
1062: (since they cannot be recorded as subblocks in that level)
1063: must be carried forward so they will later become subblocks
1064: of something else. */
1065: else if (subblocks)
1066: {
1067: if (keep == 2)
1068: current_binding_level->blocks
1069: = chainon (subblocks, current_binding_level->blocks);
1070: else
1071: current_binding_level->blocks
1072: = chainon (current_binding_level->blocks, subblocks);
1073: }
1074:
1075: /* Take care of compiler's internal binding structures. */
1076: if (tmp == 2)
1077: {
1078: #if 0
1079: /* We did not call push_momentary for this
1080: binding contour, so there is nothing to pop. */
1081: pop_momentary ();
1082: #endif
1083: expand_end_bindings (getdecls (), keep, 1);
1084: /* Each and every BLOCK node created here in `poplevel' is important
1085: (e.g. for proper debugging information) so if we created one
1086: earlier, mark it as "used". */
1087: if (block)
1088: TREE_USED (block) = 1;
1089: block = poplevel (keep, reverse, real_functionbody);
1090: }
1091:
1092: /* Each and every BLOCK node created here in `poplevel' is important
1093: (e.g. for proper debugging information) so if we created one
1094: earlier, mark it as "used". */
1095: if (block)
1096: TREE_USED (block) = 1;
1097: return block;
1098: }
1099:
1100: /* Delete the node BLOCK from the current binding level.
1101: This is used for the block inside a stmt expr ({...})
1102: so that the block can be reinserted where appropriate. */
1103:
1104: void
1105: delete_block (block)
1106: tree block;
1107: {
1108: tree t;
1109: if (current_binding_level->blocks == block)
1110: current_binding_level->blocks = TREE_CHAIN (block);
1111: for (t = current_binding_level->blocks; t;)
1112: {
1113: if (TREE_CHAIN (t) == block)
1114: TREE_CHAIN (t) = TREE_CHAIN (block);
1115: else
1116: t = TREE_CHAIN (t);
1117: }
1118: TREE_CHAIN (block) = NULL_TREE;
1119: /* Clear TREE_USED which is always set by poplevel.
1120: The flag is set again if insert_block is called. */
1121: TREE_USED (block) = 0;
1122: }
1123:
1124: /* Insert BLOCK at the end of the list of subblocks of the
1125: current binding level. This is used when a BIND_EXPR is expanded,
1126: to handle the BLOCK node inside the BIND_EXPR. */
1127:
1128: void
1129: insert_block (block)
1130: tree block;
1131: {
1132: TREE_USED (block) = 1;
1133: current_binding_level->blocks
1134: = chainon (current_binding_level->blocks, block);
1135: }
1136:
1137: /* Add BLOCK to the current list of blocks for this binding contour. */
1138: void
1139: add_block_current_level (block)
1140: tree block;
1141: {
1142: current_binding_level->blocks
1143: = chainon (current_binding_level->blocks, block);
1144: }
1145:
1146: /* Set the BLOCK node for the innermost scope
1147: (the one we are currently in). */
1148:
1149: void
1150: set_block (block)
1151: register tree block;
1152: {
1153: current_binding_level->this_block = block;
1154: }
1155:
1156: /* Do a pushlevel for class declarations. */
1157: void
1158: pushlevel_class ()
1159: {
1160: register struct binding_level *newlevel;
1161:
1162: /* Reuse or create a struct for this binding level. */
1163: #if defined(DEBUG_CP_BINDING_LEVELS)
1164: if (0)
1165: #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1166: if (free_binding_level)
1167: #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1168: {
1169: newlevel = free_binding_level;
1170: free_binding_level = free_binding_level->level_chain;
1171: }
1172: else
1173: {
1174: /* Create a new `struct binding_level'. */
1175: newlevel = (struct binding_level *) xmalloc (sizeof (struct binding_level));
1176: }
1177:
1178: #if defined(DEBUG_CP_BINDING_LEVELS)
1179: is_class_level = 1;
1180: #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1181:
1182: push_binding_level (newlevel, 0, 0);
1183:
1184: decl_stack = push_decl_level (decl_stack, &decl_obstack);
1185: class_binding_level = current_binding_level;
1186: class_binding_level->parm_flag = 2;
1187: /* We have just pushed into a new binding level. Now, fake out the rest
1188: of the compiler. Set the `current_binding_level' back to point to
1189: the most closely containing non-class binding level. */
1190: do
1191: {
1192: current_binding_level = current_binding_level->level_chain;
1193: }
1194: while (current_binding_level->parm_flag == 2);
1195: }
1196:
1197: /* ...and a poplevel for class declarations. FORCE is used to force
1198: clearing out of CLASS_VALUEs after a class definition. */
1199: tree
1200: poplevel_class (force)
1201: int force;
1202: {
1203: register struct binding_level *level = class_binding_level;
1204: tree block = NULL_TREE;
1205: tree shadowed;
1206:
1207: my_friendly_assert (level != 0, 354);
1208:
1209: decl_stack = pop_stack_level (decl_stack);
1210: for (shadowed = level->shadowed; shadowed; shadowed = TREE_CHAIN (shadowed))
1211: IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1212: /* If we're leaving a toplevel class, don't bother to do the setting
1213: of IDENTIFER_CLASS_VALUE to NULL_TREE, since first of all this slot
1214: shouldn't even be used when current_class_type isn't set, and second,
1215: if we don't touch it here, we're able to use the caching effect if the
1216: next time we're entering a class scope, it is the same class. */
1217: if (current_class_depth != 1 || force)
1218: for (shadowed = level->class_shadowed;
1219: shadowed;
1220: shadowed = TREE_CHAIN (shadowed))
1221: IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1222: else
1223: /* Remember to save what IDENTIFIER's were bound in this scope so we
1224: can recover from cache misses. */
1225: previous_class_values = class_binding_level->class_shadowed;
1226: for (shadowed = level->type_shadowed;
1227: shadowed;
1228: shadowed = TREE_CHAIN (shadowed))
1229: IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1230:
1231: GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1232: (HOST_WIDE_INT) class_binding_level->level_chain,
1233: class_binding_level->parm_flag,
1234: class_binding_level->keep,
1235: class_binding_level->tag_transparent);
1236:
1237: if (class_binding_level->parm_flag != 2)
1238: class_binding_level = (struct binding_level *)0;
1239:
1240: /* Now, pop out of the the binding level which we created up in the
1241: `pushlevel_class' routine. */
1242: #if defined(DEBUG_CP_BINDING_LEVELS)
1243: is_class_level = 1;
1244: #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1245:
1246: pop_binding_level ();
1247:
1248: return block;
1249: }
1250:
1251: /* For debugging. */
1252: int no_print_functions = 0;
1253: int no_print_builtins = 0;
1254:
1255: void
1256: print_binding_level (lvl)
1257: struct binding_level *lvl;
1258: {
1259: tree t;
1260: int i = 0, len;
1261: fprintf (stderr, " blocks=");
1262: fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1263: fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1264: lvl->n_incomplete, lvl->parm_flag, lvl->keep);
1265: if (lvl->tag_transparent)
1266: fprintf (stderr, " tag-transparent");
1267: if (lvl->more_cleanups_ok)
1268: fprintf (stderr, " more-cleanups-ok");
1269: if (lvl->have_cleanups)
1270: fprintf (stderr, " have-cleanups");
1271: fprintf (stderr, "\n");
1272: if (lvl->names)
1273: {
1274: fprintf (stderr, " names:\t");
1275: /* We can probably fit 3 names to a line? */
1276: for (t = lvl->names; t; t = TREE_CHAIN (t))
1277: {
1278: if (no_print_functions && (TREE_CODE(t) == FUNCTION_DECL))
1279: continue;
1280: if (no_print_builtins
1281: && (TREE_CODE(t) == TYPE_DECL)
1282: && (!strcmp(DECL_SOURCE_FILE(t),"<built-in>")))
1283: continue;
1284:
1285: /* Function decls tend to have longer names. */
1286: if (TREE_CODE (t) == FUNCTION_DECL)
1287: len = 3;
1288: else
1289: len = 2;
1290: i += len;
1291: if (i > 6)
1292: {
1293: fprintf (stderr, "\n\t");
1294: i = len;
1295: }
1296: print_node_brief (stderr, "", t, 0);
1297: if (TREE_CODE (t) == ERROR_MARK)
1298: break;
1299: }
1300: if (i)
1301: fprintf (stderr, "\n");
1302: }
1303: if (lvl->tags)
1304: {
1305: fprintf (stderr, " tags:\t");
1306: i = 0;
1307: for (t = lvl->tags; t; t = TREE_CHAIN (t))
1308: {
1309: if (TREE_PURPOSE (t) == NULL_TREE)
1310: len = 3;
1311: else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1312: len = 2;
1313: else
1314: len = 4;
1315: i += len;
1316: if (i > 5)
1317: {
1318: fprintf (stderr, "\n\t");
1319: i = len;
1320: }
1321: if (TREE_PURPOSE (t) == NULL_TREE)
1322: {
1323: print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1324: fprintf (stderr, ">");
1325: }
1326: else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1327: print_node_brief (stderr, "", TREE_VALUE (t), 0);
1328: else
1329: {
1330: print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1331: print_node_brief (stderr, "", TREE_VALUE (t), 0);
1332: fprintf (stderr, ">");
1333: }
1334: }
1335: if (i)
1336: fprintf (stderr, "\n");
1337: }
1338: if (lvl->shadowed)
1339: {
1340: fprintf (stderr, " shadowed:");
1341: for (t = lvl->shadowed; t; t = TREE_CHAIN (t))
1342: {
1343: fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1344: }
1345: fprintf (stderr, "\n");
1346: }
1347: if (lvl->class_shadowed)
1348: {
1349: fprintf (stderr, " class-shadowed:");
1350: for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1351: {
1352: fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1353: }
1354: fprintf (stderr, "\n");
1355: }
1356: if (lvl->type_shadowed)
1357: {
1358: fprintf (stderr, " type-shadowed:");
1359: for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1360: {
1361: #if 0
1362: fprintf (stderr, "\n\t");
1363: print_node_brief (stderr, "<", TREE_PURPOSE (t), 0);
1364: if (TREE_VALUE (t))
1365: print_node_brief (stderr, " ", TREE_VALUE (t), 0);
1366: else
1367: fprintf (stderr, " (none)");
1368: fprintf (stderr, ">");
1369: #else
1370: fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1371: #endif
1372: }
1373: fprintf (stderr, "\n");
1374: }
1375: }
1376:
1377: void
1378: print_other_binding_stack (stack)
1379: struct binding_level *stack;
1380: {
1381: struct binding_level *level;
1382: for (level = stack; level != global_binding_level; level = level->level_chain)
1383: {
1384: fprintf (stderr, "binding level ");
1385: fprintf (stderr, HOST_PTR_PRINTF, level);
1386: fprintf (stderr, "\n");
1387: print_binding_level (level);
1388: }
1389: }
1390:
1391: void
1392: print_binding_stack ()
1393: {
1394: struct binding_level *b;
1395: fprintf (stderr, "current_binding_level=");
1396: fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1397: fprintf (stderr, "\nclass_binding_level=");
1398: fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1399: fprintf (stderr, "\nglobal_binding_level=");
1400: fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1401: fprintf (stderr, "\n");
1402: if (class_binding_level)
1403: {
1404: for (b = class_binding_level; b; b = b->level_chain)
1405: if (b == current_binding_level)
1406: break;
1407: if (b)
1408: b = class_binding_level;
1409: else
1410: b = current_binding_level;
1411: }
1412: else
1413: b = current_binding_level;
1414: print_other_binding_stack (b);
1415: fprintf (stderr, "global:\n");
1416: print_binding_level (global_binding_level);
1417: }
1418:
1419: /* Subroutines for reverting temporarily to top-level for instantiation
1420: of templates and such. We actually need to clear out the class- and
1421: local-value slots of all identifiers, so that only the global values
1422: are at all visible. Simply setting current_binding_level to the global
1423: scope isn't enough, because more binding levels may be pushed. */
1424: struct saved_scope {
1425: struct binding_level *old_binding_level;
1426: tree old_bindings;
1427: struct saved_scope *prev;
1428: tree class_name, class_type, class_decl, function_decl;
1429: struct binding_level *class_bindings;
1430: tree previous_class_type;
1431: tree *lang_base, *lang_stack, lang_name;
1432: int lang_stacksize;
1433: tree named_labels;
1434: };
1435: static struct saved_scope *current_saved_scope;
1436: extern tree prev_class_type;
1437:
1438: void
1439: push_to_top_level ()
1440: {
1441: extern int current_lang_stacksize;
1442: struct saved_scope *s =
1443: (struct saved_scope *) xmalloc (sizeof (struct saved_scope));
1444: struct binding_level *b = current_binding_level;
1445: tree old_bindings = NULL_TREE;
1446:
1447: /* Have to include global_binding_level, because class-level decls
1448: aren't listed anywhere useful. */
1449: for (; b; b = b->level_chain)
1450: {
1451: tree t;
1452:
1453: if (b == global_binding_level)
1454: continue;
1455:
1456: for (t = b->names; t; t = TREE_CHAIN (t))
1457: {
1458: tree binding, t1, t2 = t;
1459: tree id = DECL_ASSEMBLER_NAME (t2);
1460:
1461: if (!id
1462: || (!IDENTIFIER_LOCAL_VALUE (id)
1463: && !IDENTIFIER_CLASS_VALUE (id)))
1464: continue;
1465:
1466: for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
1467: if (TREE_VEC_ELT (t1, 0) == id)
1468: goto skip_it;
1469:
1470: binding = make_tree_vec (4);
1471: if (id)
1472: {
1473: my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
1474: TREE_VEC_ELT (binding, 0) = id;
1475: TREE_VEC_ELT (binding, 1) = IDENTIFIER_TYPE_VALUE (id);
1476: TREE_VEC_ELT (binding, 2) = IDENTIFIER_LOCAL_VALUE (id);
1477: TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
1478: IDENTIFIER_LOCAL_VALUE (id) = NULL_TREE;
1479: IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
1480: }
1481: TREE_CHAIN (binding) = old_bindings;
1482: old_bindings = binding;
1483: skip_it:
1484: ;
1485: }
1486: /* Unwind type-value slots back to top level. */
1487: for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
1488: SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
1489: }
1490: /* Clear out class-level bindings cache. */
1491: if (current_binding_level == global_binding_level
1492: && previous_class_type != NULL_TREE)
1493: {
1494: popclass (-1);
1495: previous_class_type = NULL_TREE;
1496: }
1497:
1498: s->old_binding_level = current_binding_level;
1499: current_binding_level = global_binding_level;
1500:
1501: s->class_name = current_class_name;
1502: s->class_type = current_class_type;
1503: s->class_decl = current_class_decl;
1504: s->function_decl = current_function_decl;
1505: s->class_bindings = class_binding_level;
1506: s->previous_class_type = previous_class_type;
1507: s->lang_stack = current_lang_stack;
1508: s->lang_base = current_lang_base;
1509: s->lang_stacksize = current_lang_stacksize;
1510: s->lang_name = current_lang_name;
1511: s->named_labels = named_labels;
1512: current_class_name = current_class_type = current_class_decl = NULL_TREE;
1513: current_function_decl = NULL_TREE;
1514: class_binding_level = (struct binding_level *)0;
1515: previous_class_type = NULL_TREE;
1516: current_lang_stacksize = 10;
1517: current_lang_stack = current_lang_base
1518: = (tree *) xmalloc (current_lang_stacksize * sizeof (tree));
1519: current_lang_name = lang_name_cplusplus;
1520: strict_prototype = strict_prototypes_lang_cplusplus;
1521: named_labels = NULL_TREE;
1522:
1523: s->prev = current_saved_scope;
1524: s->old_bindings = old_bindings;
1525: current_saved_scope = s;
1526: }
1527:
1528: void
1529: pop_from_top_level ()
1530: {
1531: extern int current_lang_stacksize;
1532: struct saved_scope *s = current_saved_scope;
1533: tree t;
1534:
1535: if (previous_class_type)
1536: previous_class_type = NULL_TREE;
1537:
1538: current_binding_level = s->old_binding_level;
1539: current_saved_scope = s->prev;
1540: for (t = s->old_bindings; t; t = TREE_CHAIN (t))
1541: {
1542: tree id = TREE_VEC_ELT (t, 0);
1543: if (id)
1544: {
1545: IDENTIFIER_TYPE_VALUE (id) = TREE_VEC_ELT (t, 1);
1546: IDENTIFIER_LOCAL_VALUE (id) = TREE_VEC_ELT (t, 2);
1547: IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
1548: }
1549: }
1550: current_class_name = s->class_name;
1551: current_class_type = s->class_type;
1552: current_class_decl = s->class_decl;
1553: if (current_class_type)
1554: C_C_D = CLASSTYPE_INST_VAR (current_class_type);
1555: else
1556: C_C_D = NULL_TREE;
1557: current_function_decl = s->function_decl;
1558: class_binding_level = s->class_bindings;
1559: previous_class_type = s->previous_class_type;
1560: free (current_lang_base);
1561: current_lang_base = s->lang_base;
1562: current_lang_stack = s->lang_stack;
1563: current_lang_name = s->lang_name;
1564: current_lang_stacksize = s->lang_stacksize;
1565: if (current_lang_name == lang_name_cplusplus)
1566: strict_prototype = strict_prototypes_lang_cplusplus;
1567: else if (current_lang_name == lang_name_c)
1568: strict_prototype = strict_prototypes_lang_c;
1569: named_labels = s->named_labels;
1570:
1571: free (s);
1572: }
1573:
1574: /* Push a definition of struct, union or enum tag "name".
1575: into binding_level "b". "type" should be the type node,
1576: We assume that the tag "name" is not already defined.
1577:
1578: Note that the definition may really be just a forward reference.
1579: In that case, the TYPE_SIZE will be a NULL_TREE.
1580:
1581: C++ gratuitously puts all these tags in the name space. */
1582:
1583: /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
1584: record the shadowed value for this binding contour. TYPE is
1585: the type that ID maps to. */
1586:
1587: static void
1588: set_identifier_type_value_with_scope (id, type, b)
1589: tree id;
1590: tree type;
1591: struct binding_level *b;
1592: {
1593: if (b != global_binding_level)
1594: {
1595: tree old_type_value = IDENTIFIER_TYPE_VALUE (id);
1596: b->type_shadowed
1597: = tree_cons (id, old_type_value, b->type_shadowed);
1598: }
1599: SET_IDENTIFIER_TYPE_VALUE (id, type);
1600: }
1601:
1602: /* As set_identifier_type_value_with_scope, but using inner_binding_level. */
1603:
1604: void
1605: set_identifier_type_value (id, type)
1606: tree id;
1607: tree type;
1608: {
1609: set_identifier_type_value_with_scope (id, type, inner_binding_level);
1610: }
1611:
1612: /* Subroutine "set_nested_typename" builds the nested-typename of
1613: the type decl in question. (Argument CLASSNAME can actually be
1614: a function as well, if that's the smallest containing scope.) */
1615:
1616: static void
1617: set_nested_typename (decl, classname, name, type)
1618: tree decl, classname, name, type;
1619: {
1620: my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 136);
1621: if (classname != NULL_TREE)
1622: {
1623: char *buf;
1624: my_friendly_assert (TREE_CODE (classname) == IDENTIFIER_NODE, 137);
1625: my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 138);
1626: buf = (char *) alloca (4 + IDENTIFIER_LENGTH (classname)
1627: + IDENTIFIER_LENGTH (name));
1628: sprintf (buf, "%s::%s", IDENTIFIER_POINTER (classname),
1629: IDENTIFIER_POINTER (name));
1630: DECL_NESTED_TYPENAME (decl) = get_identifier (buf);
1631: TREE_MANGLED (DECL_NESTED_TYPENAME (decl)) = 1;
1632:
1633: /* This is a special usage of IDENTIFIER_TYPE_VALUE which have no
1634: correspondence in any binding_level. This is ok since the
1635: DECL_NESTED_TYPENAME is just a convenience identifier whose
1636: IDENTIFIER_TYPE_VALUE will remain constant from now on. */
1637: SET_IDENTIFIER_TYPE_VALUE (DECL_NESTED_TYPENAME (decl), type);
1638: }
1639: else
1640: DECL_NESTED_TYPENAME (decl) = name;
1641: }
1642:
1643: /* Pop off extraneous binding levels left over due to syntax errors. */
1644: void
1645: pop_everything ()
1646: {
1647: #ifdef DEBUG_CP_BINDING_LEVELS
1648: fprintf (stderr, "XXX entering pop_everything ()\n");
1649: #endif
1650: while (current_binding_level != global_binding_level
1651: && ! current_binding_level->pseudo_global)
1652: {
1653: if (class_binding_level)
1654: pop_nested_class (1);
1655: else
1656: poplevel (0, 0, 0);
1657: }
1658: #ifdef DEBUG_CP_BINDING_LEVELS
1659: fprintf (stderr, "XXX leaving pop_everything ()\n");
1660: #endif
1661: }
1662:
1663: #if 0 /* not yet, should get fixed properly later */
1664: /* Create a TYPE_DECL node with the correct DECL_ASSEMBLER_NAME.
1665: Other routines shouldn't use build_decl directly; they'll produce
1666: incorrect results with `-g' unless they duplicate this code.
1667:
1668: This is currently needed mainly for dbxout.c, but we can make
1669: use of it in method.c later as well. */
1670: tree
1671: make_type_decl (name, type)
1672: tree name, type;
1673: {
1674: tree decl, id;
1675: decl = build_decl (TYPE_DECL, name, type);
1676: if (TYPE_NAME (type) == name)
1677: /* Class/union/enum definition, or a redundant typedef for same. */
1678: {
1679: id = get_identifier (build_overload_name (type, 1, 1));
1680: DECL_ASSEMBLER_NAME (decl) = id;
1681: }
1682: else if (TYPE_NAME (type) != NULL_TREE)
1683: /* Explicit typedef, or implicit typedef for template expansion. */
1684: DECL_ASSEMBLER_NAME (decl) = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
1685: else
1686: {
1687: /* XXX: Typedef for unnamed struct; some other situations.
1688: TYPE_NAME is null; what's right here? */
1689: }
1690: return decl;
1691: }
1692: #endif
1693:
1694: /* Push a tag name NAME for struct/class/union/enum type TYPE.
1695: Normally put into into the inner-most non-tag-tranparent scope,
1696: but if GLOBALIZE is true, put it in the inner-most non-class scope.
1697: The latter is needed for implicit declarations. */
1698:
1699: void
1700: pushtag (name, type, globalize)
1701: tree name, type;
1702: int globalize;
1703: {
1704: register struct binding_level *b;
1705: tree context = 0;
1706: tree c_decl = 0;
1707:
1708: b = inner_binding_level;
1709: while (b->tag_transparent
1710: || (globalize && b->parm_flag == 2))
1711: b = b->level_chain;
1712:
1713: if (b == global_binding_level)
1714: b->tags = perm_tree_cons (name, type, b->tags);
1715: else
1716: b->tags = saveable_tree_cons (name, type, b->tags);
1717:
1718: if (name)
1719: {
1720: context = type ? TYPE_CONTEXT (type) : NULL_TREE;
1721: if (! context && ! globalize)
1722: context = current_scope ();
1723: if (context)
1724: c_decl = TREE_CODE (context) == FUNCTION_DECL
1725: ? context : TYPE_NAME (context);
1726:
1727: /* Record the identifier as the type's name if it has none. */
1728: if (TYPE_NAME (type) == NULL_TREE)
1729: TYPE_NAME (type) = name;
1730:
1731: /* Do C++ gratuitous typedefing. */
1732: if (IDENTIFIER_TYPE_VALUE (name) != type
1733: && (TREE_CODE (type) != RECORD_TYPE
1734: || b->parm_flag != 2
1735: || !CLASSTYPE_DECLARED_EXCEPTION (type)))
1736: {
1737: register tree d;
1738: int newdecl = 0;
1739:
1740: if (b->parm_flag != 2
1741: || TYPE_SIZE (current_class_type) != NULL_TREE)
1742: {
1743: d = lookup_nested_type (type, c_decl);
1744:
1745: if (d == NULL_TREE)
1746: {
1747: newdecl = 1;
1748: #if 0 /* not yet, should get fixed properly later */
1749: d = make_type_decl (name, type);
1750: #else
1751: d = build_decl (TYPE_DECL, name, type);
1752: #endif
1753: SET_DECL_ARTIFICIAL (d);
1754: #ifdef DWARF_DEBUGGING_INFO
1755: if (write_symbols == DWARF_DEBUG)
1756: {
1757: /* Mark the TYPE_DECL node we created just above as an
1758: gratuitous one. We need to do this so that dwarfout.c
1759: will understand that it is not supposed to output a
1760: TAG_typedef DIE for it. */
1761: DECL_IGNORED_P (d) = 1;
1762: }
1763: #endif /* DWARF_DEBUGGING_INFO */
1764: set_identifier_type_value_with_scope (name, type, b);
1765: }
1766: else
1767: d = TYPE_NAME (d);
1768:
1769: /* If it is anonymous, then we are called from pushdecl,
1770: and we don't want to infinitely recurse. Also, if the
1771: name is already in scope, we don't want to push it
1772: again--pushdecl is only for pushing new decls. */
1773: if (! ANON_AGGRNAME_P (name)
1774: && TYPE_NAME (type)
1775: && (TREE_CODE (TYPE_NAME (type)) != TYPE_DECL
1776: || lookup_name (name, 1) != TYPE_NAME (type)))
1777: {
1778: if (b->parm_flag == 2)
1779: d = pushdecl_class_level (d);
1780: else
1781: d = pushdecl_with_scope (d, b);
1782: }
1783: }
1784: else
1785: {
1786: /* Make nested declarations go into class-level scope. */
1787: newdecl = 1;
1788: d = build_decl (TYPE_DECL, name, type);
1789: SET_DECL_ARTIFICIAL (d);
1790: #ifdef DWARF_DEBUGGING_INFO
1791: if (write_symbols == DWARF_DEBUG)
1792: {
1793: /* Mark the TYPE_DECL node we created just above as an
1794: gratuitous one. We need to do this so that dwarfout.c
1795: will understand that it is not supposed to output a
1796: TAG_typedef DIE for it. */
1797: DECL_IGNORED_P (d) = 1;
1798: }
1799: #endif /* DWARF_DEBUGGING_INFO */
1800: /* Make sure we're in this type's scope when we push the
1801: decl for a template, otherwise class_binding_level will
1802: be NULL and we'll end up dying inside of
1803: push_class_level_binding. */
1804: if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
1805: pushclass (type, 0);
1806: d = pushdecl_class_level (d);
1807: if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
1808: popclass (0);
1809: }
1810: if (write_symbols != DWARF_DEBUG)
1811: {
1812: if (ANON_AGGRNAME_P (name))
1813: DECL_IGNORED_P (d) = 1;
1814: }
1815: TYPE_NAME (type) = d;
1816:
1817: if (context == NULL_TREE)
1818: /* Non-nested class. */
1819: DECL_NESTED_TYPENAME (d) = name;
1820: else if (context && TREE_CODE (context) == FUNCTION_DECL)
1821: {
1822: /* Function-nested class. */
1823: set_nested_typename (d, DECL_ASSEMBLER_NAME (c_decl),
1824: name, type);
1825: /* This builds the links for classes nested in fn scope. */
1826: DECL_CONTEXT (d) = context;
1827: }
1828: /* else if (TYPE_SIZE (current_class_type) == NULL_TREE)
1829: */
1830: else if (context && IS_AGGR_TYPE (context))
1831: {
1832: /* Class-nested class. */
1833: set_nested_typename (d, DECL_NESTED_TYPENAME (c_decl),
1834: name, type);
1835: /* This builds the links for classes nested in type scope. */
1836: DECL_CONTEXT (d) = context;
1837: }
1838: TYPE_CONTEXT (type) = DECL_CONTEXT (d);
1839: if (newdecl)
1840: DECL_ASSEMBLER_NAME (d)
1841: = get_identifier (build_overload_name (type, 1, 1));
1842: }
1843: if (b->parm_flag == 2)
1844: {
1845: TREE_NONLOCAL_FLAG (type) = 1;
1846: if (TYPE_SIZE (current_class_type) == NULL_TREE)
1847: CLASSTYPE_TAGS (current_class_type) = b->tags;
1848: }
1849: }
1850:
1851: if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1852: /* Use the canonical TYPE_DECL for this node. */
1853: TYPE_STUB_DECL (type) = TYPE_NAME (type);
1854: else
1855: {
1856: /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
1857: will be the tagged type we just added to the current
1858: binding level. This fake NULL-named TYPE_DECL node helps
1859: dwarfout.c to know when it needs to output a
1860: representation of a tagged type, and it also gives us a
1861: convenient place to record the "scope start" address for
1862: the tagged type. */
1863:
1864: #if 0 /* not yet, should get fixed properly later */
1865: tree d = make_type_decl (NULL_TREE, type);
1866: #else
1867: tree d = build_decl (TYPE_DECL, NULL_TREE, type);
1868: #endif
1869: TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
1870: }
1871: }
1872:
1873: /* Counter used to create anonymous type names. */
1874: static int anon_cnt = 0;
1875:
1876: /* Return an IDENTIFIER which can be used as a name for
1877: anonymous structs and unions. */
1878: tree
1879: make_anon_name ()
1880: {
1881: char buf[32];
1882:
1883: sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1884: return get_identifier (buf);
1885: }
1886:
1887: /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
1888: This keeps dbxout from getting confused. */
1889: void
1890: clear_anon_tags ()
1891: {
1892: register struct binding_level *b;
1893: register tree tags;
1894: static int last_cnt = 0;
1895:
1896: /* Fast out if no new anon names were declared. */
1897: if (last_cnt == anon_cnt)
1898: return;
1899:
1900: b = current_binding_level;
1901: while (b->tag_transparent)
1902: b = b->level_chain;
1903: tags = b->tags;
1904: while (tags)
1905: {
1906: /* A NULL purpose means we have already processed all tags
1907: from here to the end of the list. */
1908: if (TREE_PURPOSE (tags) == NULL_TREE)
1909: break;
1910: if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
1911: TREE_PURPOSE (tags) = NULL_TREE;
1912: tags = TREE_CHAIN (tags);
1913: }
1914: last_cnt = anon_cnt;
1915: }
1916:
1917: /* Subroutine of duplicate_decls: return truthvalue of whether
1918: or not types of these decls match.
1919:
1920: For C++, we must compare the parameter list so that `int' can match
1921: `int&' in a parameter position, but `int&' is not confused with
1922: `const int&'. */
1923: static int
1924: decls_match (newdecl, olddecl)
1925: tree newdecl, olddecl;
1926: {
1927: int types_match;
1928:
1929: if (TREE_CODE (newdecl) == FUNCTION_DECL
1930: && TREE_CODE (olddecl) == FUNCTION_DECL)
1931: {
1932: tree f1 = TREE_TYPE (newdecl);
1933: tree f2 = TREE_TYPE (olddecl);
1934: tree p1 = TYPE_ARG_TYPES (f1);
1935: tree p2 = TYPE_ARG_TYPES (f2);
1936:
1937: /* When we parse a static member function definition,
1938: we put together a FUNCTION_DECL which thinks its type
1939: is METHOD_TYPE. Change that to FUNCTION_TYPE, and
1940: proceed. */
1941: if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
1942: revert_static_member_fn (&newdecl, &f1, &p1);
1943: else if (TREE_CODE (f2) == METHOD_TYPE
1944: && DECL_STATIC_FUNCTION_P (newdecl))
1945: revert_static_member_fn (&olddecl, &f2, &p2);
1946:
1947: /* Here we must take care of the case where new default
1948: parameters are specified. Also, warn if an old
1949: declaration becomes ambiguous because default
1950: parameters may cause the two to be ambiguous. */
1951: if (TREE_CODE (f1) != TREE_CODE (f2))
1952: {
1953: if (TREE_CODE (f1) == OFFSET_TYPE)
1954: cp_compiler_error ("`%D' redeclared as member function", newdecl);
1955: else
1956: cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
1957: return 0;
1958: }
1959:
1960: if (comptypes (TREE_TYPE (f1), TREE_TYPE (f2), 1))
1961: {
1962: if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
1963: && p2 == NULL_TREE)
1964: {
1965: types_match = self_promoting_args_p (p1);
1966: if (p1 == void_list_node)
1967: TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1968: }
1969: else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
1970: && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
1971: {
1972: types_match = self_promoting_args_p (p2);
1973: TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1974: }
1975: else
1976: types_match = compparms (p1, p2, 3);
1977: }
1978: else
1979: types_match = 0;
1980: }
1981: else if (TREE_CODE (newdecl) == TEMPLATE_DECL
1982: && TREE_CODE (olddecl) == TEMPLATE_DECL)
1983: {
1984: tree newargs = DECL_TEMPLATE_PARMS (newdecl);
1985: tree oldargs = DECL_TEMPLATE_PARMS (olddecl);
1986: int i, len = TREE_VEC_LENGTH (newargs);
1987:
1988: if (TREE_VEC_LENGTH (oldargs) != len)
1989: return 0;
1990:
1991: for (i = 0; i < len; i++)
1992: {
1993: tree newarg = TREE_VALUE (TREE_VEC_ELT (newargs, i));
1994: tree oldarg = TREE_VALUE (TREE_VEC_ELT (oldargs, i));
1995: if (TREE_CODE (newarg) != TREE_CODE (oldarg))
1996: return 0;
1997: else if (TREE_CODE (newarg) == TYPE_DECL)
1998: /* continue */;
1999: else if (! comptypes (TREE_TYPE (newarg), TREE_TYPE (oldarg), 1))
2000: return 0;
2001: }
2002:
2003: if (DECL_TEMPLATE_IS_CLASS (newdecl)
2004: != DECL_TEMPLATE_IS_CLASS (olddecl))
2005: types_match = 0;
2006: else if (DECL_TEMPLATE_IS_CLASS (newdecl))
2007: types_match = 1;
2008: else
2009: types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2010: DECL_TEMPLATE_RESULT (newdecl));
2011: }
2012: else
2013: {
2014: if (TREE_TYPE (newdecl) == error_mark_node)
2015: types_match = TREE_TYPE (olddecl) == error_mark_node;
2016: else if (TREE_TYPE (olddecl) == NULL_TREE)
2017: types_match = TREE_TYPE (newdecl) == NULL_TREE;
2018: else if (TREE_TYPE (newdecl) == NULL_TREE)
2019: types_match = 0;
2020: else
2021: types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 1);
2022: }
2023:
2024: return types_match;
2025: }
2026:
2027: /* If NEWDECL is `static' and an `extern' was seen previously,
2028: warn about it. (OLDDECL may be NULL_TREE; NAME contains
2029: information about previous usage as an `extern'.)
2030:
2031: Note that this does not apply to the C++ case of declaring
2032: a variable `extern const' and then later `const'.
2033:
2034: Don't complain if -traditional, since traditional compilers
2035: don't complain.
2036:
2037: Don't complain about built-in functions, since they are beyond
2038: the user's control. */
2039:
2040: static void
2041: warn_extern_redeclared_static (newdecl, olddecl)
2042: tree newdecl, olddecl;
2043: {
2044: tree name;
2045:
2046: static char *explicit_extern_static_warning
2047: = "`%D' was declared `extern' and later `static'";
2048: static char *implicit_extern_static_warning
2049: = "`%D' was declared implicitly `extern' and later `static'";
2050:
2051: if (flag_traditional
2052: || TREE_CODE (newdecl) == TYPE_DECL
2053: || (! warn_extern_inline
2054: && DECL_INLINE (newdecl)))
2055: return;
2056:
2057: name = DECL_ASSEMBLER_NAME (newdecl);
2058: if (TREE_PUBLIC (name) && ! TREE_PUBLIC (newdecl))
2059: {
2060: /* It's okay to redeclare an ANSI built-in function as static,
2061: or to declare a non-ANSI built-in function as anything. */
2062: if (! (TREE_CODE (newdecl) == FUNCTION_DECL
2063: && olddecl != NULL_TREE
2064: && TREE_CODE (olddecl) == FUNCTION_DECL
2065: && (DECL_BUILT_IN (olddecl)
2066: || DECL_BUILT_IN_NONANSI (olddecl))))
2067: {
2068: cp_warning (IDENTIFIER_IMPLICIT_DECL (name)
2069: ? implicit_extern_static_warning
2070: : explicit_extern_static_warning, newdecl);
2071: if (olddecl != NULL_TREE)
2072: cp_warning_at ("previous declaration of `%D'", olddecl);
2073: }
2074: }
2075: }
2076:
2077: /* Handle when a new declaration NEWDECL has the same name as an old
2078: one OLDDECL in the same binding contour. Prints an error message
2079: if appropriate.
2080:
2081: If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2082: Otherwise, return 0. */
2083:
2084: int
2085: duplicate_decls (newdecl, olddecl)
2086: register tree newdecl, olddecl;
2087: {
2088: extern struct obstack permanent_obstack;
2089: unsigned olddecl_uid = DECL_UID (olddecl);
2090: int olddecl_friend = 0, types_match = 0;
2091: int new_defines_function;
2092: tree previous_c_decl = NULL_TREE;
2093:
2094: types_match = decls_match (newdecl, olddecl);
2095:
2096: if (TREE_CODE (olddecl) != TREE_LIST)
2097: olddecl_friend = DECL_LANG_SPECIFIC (olddecl) && DECL_FRIEND_P (olddecl);
2098:
2099: /* If either the type of the new decl or the type of the old decl is an
2100: error_mark_node, then that implies that we have already issued an
2101: error (earlier) for some bogus type specification, and in that case,
2102: it is rather pointless to harass the user with yet more error message
2103: about the same declaration, so well just pretent the types match here. */
2104: if ((TREE_TYPE (newdecl)
2105: && TREE_CODE (TREE_TYPE (newdecl)) == ERROR_MARK)
2106: || (TREE_TYPE (olddecl)
2107: && TREE_CODE (TREE_TYPE (olddecl)) == ERROR_MARK))
2108: types_match = 1;
2109:
2110: if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
2111: && IDENTIFIER_IMPLICIT_DECL (DECL_ASSEMBLER_NAME (newdecl)) == olddecl)
2112: /* If -traditional, avoid error for redeclaring fcn
2113: after implicit decl. */
2114: ;
2115: else if (TREE_CODE (olddecl) == FUNCTION_DECL
2116: && DECL_ARTIFICIAL (olddecl)
2117: && (DECL_BUILT_IN (olddecl) || DECL_BUILT_IN_NONANSI (olddecl)))
2118: {
2119: /* If you declare a built-in or predefined function name as static,
2120: the old definition is overridden, but optionally warn this was a
2121: bad choice of name. Ditto for overloads. */
2122: if (! TREE_PUBLIC (newdecl)
2123: || (TREE_CODE (newdecl) == FUNCTION_DECL
2124: && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)))
2125: {
2126: if (warn_shadow)
2127: cp_warning ("shadowing %s function `%#D'",
2128: DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2129: olddecl);
2130: /* Discard the old built-in function. */
2131: return 0;
2132: }
2133: else if (! types_match)
2134: {
2135: if (TREE_CODE (newdecl) != FUNCTION_DECL)
2136: {
2137: /* If the built-in is not ansi, then programs can override
2138: it even globally without an error. */
2139: if (! DECL_BUILT_IN (olddecl))
2140: cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2141: olddecl, newdecl);
2142: else
2143: {
2144: cp_error ("declaration of `%#D'", newdecl);
2145: cp_error ("conflicts with built-in declaration `%#D'",
2146: olddecl);
2147: }
2148: return 0;
2149: }
2150:
2151: cp_warning ("declaration of `%#D'", newdecl);
2152: cp_warning ("conflicts with built-in declaration `%#D'",
2153: olddecl);
2154: }
2155: }
2156: else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
2157: {
2158: if ((TREE_CODE (newdecl) == FUNCTION_DECL
2159: && TREE_CODE (olddecl) == TEMPLATE_DECL
2160: && ! DECL_TEMPLATE_IS_CLASS (olddecl))
2161: || (TREE_CODE (olddecl) == FUNCTION_DECL
2162: && TREE_CODE (newdecl) == TEMPLATE_DECL
2163: && ! DECL_TEMPLATE_IS_CLASS (newdecl)))
2164: return 0;
2165:
2166: cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
2167: if (TREE_CODE (olddecl) == TREE_LIST)
2168: olddecl = TREE_VALUE (olddecl);
2169: cp_error_at ("previous declaration of `%#D'", olddecl);
2170:
2171: /* New decl is completely inconsistent with the old one =>
2172: tell caller to replace the old one. */
2173:
2174: return 0;
2175: }
2176: else if (!types_match)
2177: {
2178: if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2179: {
2180: /* The name of a class template may not be declared to refer to
2181: any other template, class, function, object, namespace, value,
2182: or type in the same scope. */
2183: if (DECL_TEMPLATE_IS_CLASS (olddecl)
2184: || DECL_TEMPLATE_IS_CLASS (newdecl))
2185: {
2186: cp_error ("declaration of template `%#D'", newdecl);
2187: cp_error_at ("conflicts with previous declaration `%#D'",
2188: olddecl);
2189: }
2190: return 0;
2191: }
2192: if (TREE_CODE (newdecl) == FUNCTION_DECL)
2193: {
2194: if (DECL_LANGUAGE (newdecl) == lang_c
2195: && DECL_LANGUAGE (olddecl) == lang_c)
2196: {
2197: cp_error ("declaration of C function `%#D' conflicts with",
2198: newdecl);
2199: cp_error_at ("previous declaration `%#D' here", olddecl);
2200: }
2201: else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2202: TYPE_ARG_TYPES (TREE_TYPE (olddecl)), 2))
2203: {
2204: cp_error ("new declaration `%#D'", newdecl);
2205: cp_error_at ("ambiguates old declaration `%#D'", olddecl);
2206: }
2207: else
2208: return 0;
2209: }
2210:
2211: if (olddecl == wchar_decl_node)
2212: {
2213: if (pedantic && ! DECL_IN_SYSTEM_HEADER (newdecl))
2214: cp_pedwarn ("redeclaration of wchar_t as `%T'",
2215: TREE_TYPE (newdecl));
2216:
2217: /* Throw away the redeclaration. */
2218: return 1;
2219: }
2220:
2221: /* Already complained about this, so don't do so again. */
2222: else if (current_class_type == NULL_TREE
2223: || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
2224: {
2225: cp_error ("conflicting types for `%#D'", newdecl);
2226: cp_error_at ("previous declaration as `%#D'", olddecl);
2227: }
2228: }
2229: else
2230: {
2231: char *errmsg = redeclaration_error_message (newdecl, olddecl);
2232: if (errmsg)
2233: {
2234: cp_error (errmsg, newdecl);
2235: if (DECL_NAME (olddecl) != NULL_TREE)
2236: cp_error_at ((DECL_INITIAL (olddecl)
2237: && current_binding_level == global_binding_level)
2238: ? "`%#D' previously defined here"
2239: : "`%#D' previously declared here", olddecl);
2240: }
2241: else if (TREE_CODE (olddecl) == FUNCTION_DECL
2242: && DECL_INITIAL (olddecl) != NULL_TREE
2243: && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
2244: && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
2245: {
2246: /* Prototype decl follows defn w/o prototype. */
2247: cp_warning_at ("prototype for `%#D'", newdecl);
2248: cp_warning_at ("follows non-prototype definition here", olddecl);
2249: }
2250: else if (TREE_CODE (olddecl) == FUNCTION_DECL
2251: && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
2252: {
2253: /* extern "C" int foo ();
2254: int foo () { bar (); }
2255: is OK. */
2256: if (current_lang_stack == current_lang_base)
2257: DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
2258: else
2259: {
2260: cp_error_at ("previous declaration of `%#D' with %L linkage",
2261: olddecl, DECL_LANGUAGE (olddecl));
2262: cp_error ("conflicts with new declaration with %L linkage",
2263: DECL_LANGUAGE (newdecl));
2264: }
2265: }
2266:
2267: /* These bits are logically part of the type. */
2268: if (pedantic
2269: && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
2270: || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
2271: cp_error_at ("type qualifiers for `%D' conflict with previous decl",
2272: newdecl);
2273: }
2274:
2275: /* If new decl is `static' and an `extern' was seen previously,
2276: warn about it. */
2277: warn_extern_redeclared_static (newdecl, olddecl);
2278:
2279: /* We have committed to returning 1 at this point. */
2280: if (TREE_CODE (newdecl) == FUNCTION_DECL)
2281: {
2282: /* Now that functions must hold information normally held
2283: by field decls, there is extra work to do so that
2284: declaration information does not get destroyed during
2285: definition. */
2286: if (DECL_VINDEX (olddecl))
2287: DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
2288: if (DECL_CONTEXT (olddecl))
2289: DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2290: if (DECL_CLASS_CONTEXT (olddecl))
2291: DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
2292: if (DECL_CHAIN (newdecl) == NULL_TREE)
2293: DECL_CHAIN (newdecl) = DECL_CHAIN (olddecl);
2294: if (DECL_NEXT_METHOD (newdecl) == NULL_TREE)
2295: DECL_NEXT_METHOD (newdecl) = DECL_NEXT_METHOD (olddecl);
2296: if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
2297: DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
2298: }
2299:
2300: /* Deal with C++: must preserve virtual function table size. */
2301: if (TREE_CODE (olddecl) == TYPE_DECL)
2302: {
2303: register tree newtype = TREE_TYPE (newdecl);
2304: register tree oldtype = TREE_TYPE (olddecl);
2305:
2306: if (newtype != error_mark_node && oldtype != error_mark_node
2307: && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
2308: {
2309: CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
2310: CLASSTYPE_FRIEND_CLASSES (newtype)
2311: = CLASSTYPE_FRIEND_CLASSES (oldtype);
2312: }
2313: #if 0
2314: /* why assert here? Just because debugging information is
2315: messed up? (mrs) */
2316: /* it happens on something like:
2317: typedef struct Thing {
2318: Thing();
2319: int x;
2320: } Thing;
2321: */
2322: my_friendly_assert (DECL_IGNORED_P (olddecl) == DECL_IGNORED_P (newdecl),
2323: 139);
2324: #endif
2325: }
2326:
2327: /* Special handling ensues if new decl is a function definition. */
2328: new_defines_function = (TREE_CODE (newdecl) == FUNCTION_DECL
2329: && DECL_INITIAL (newdecl) != NULL_TREE);
2330:
2331: /* Optionally warn about more than one declaration for the same name,
2332: but don't warn about a function declaration followed by a definition. */
2333: if (warn_redundant_decls
2334: && ! DECL_ARTIFICIAL (olddecl)
2335: && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
2336: /* Don't warn about extern decl followed by (tentative) definition. */
2337: && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
2338: {
2339: cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
2340: cp_warning ("previous declaration of `%D'", olddecl);
2341: }
2342:
2343: /* Copy all the DECL_... slots specified in the new decl
2344: except for any that we copy here from the old type. */
2345:
2346: if (types_match)
2347: {
2348: /* Automatically handles default parameters. */
2349: tree oldtype = TREE_TYPE (olddecl);
2350: /* Merge the data types specified in the two decls. */
2351: tree newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
2352:
2353: /* Make sure we put the new type in the same obstack as the old ones.
2354: If the old types are not both in the same obstack, use the permanent
2355: one. */
2356: if (oldtype && TYPE_OBSTACK (oldtype) == TYPE_OBSTACK (newtype))
2357: push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype));
2358: else
2359: {
2360: push_obstacks_nochange ();
2361: end_temporary_allocation ();
2362: }
2363:
2364: if (TREE_CODE (newdecl) == VAR_DECL)
2365: DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
2366: /* Do this after calling `common_type' so that default
2367: parameters don't confuse us. */
2368: else if (TREE_CODE (newdecl) == FUNCTION_DECL
2369: && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
2370: != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
2371: {
2372: tree ctype = NULL_TREE;
2373: ctype = DECL_CLASS_CONTEXT (newdecl);
2374: TREE_TYPE (newdecl) = build_exception_variant (ctype, newtype,
2375: TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
2376: TREE_TYPE (olddecl) = build_exception_variant (ctype, newtype,
2377: TYPE_RAISES_EXCEPTIONS (oldtype));
2378:
2379: if (! compexcepttypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 0))
2380: {
2381: cp_error ("declaration of `%D' raises different exceptions...",
2382: newdecl);
2383: cp_error_at ("...from previous declaration here", olddecl);
2384: }
2385: }
2386: TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
2387:
2388: /* Lay the type out, unless already done. */
2389: if (oldtype != TREE_TYPE (newdecl))
2390: {
2391: if (TREE_TYPE (newdecl) != error_mark_node)
2392: layout_type (TREE_TYPE (newdecl));
2393: if (TREE_CODE (newdecl) != FUNCTION_DECL
2394: && TREE_CODE (newdecl) != TYPE_DECL
2395: && TREE_CODE (newdecl) != CONST_DECL
2396: && TREE_CODE (newdecl) != TEMPLATE_DECL)
2397: layout_decl (newdecl, 0);
2398: }
2399: else
2400: {
2401: /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2402: DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
2403: }
2404:
2405: /* Merge the type qualifiers. */
2406: if (TREE_READONLY (newdecl))
2407: TREE_READONLY (olddecl) = 1;
2408: if (TREE_THIS_VOLATILE (newdecl))
2409: TREE_THIS_VOLATILE (olddecl) = 1;
2410:
2411: /* Merge the initialization information. */
2412: if (DECL_INITIAL (newdecl) == NULL_TREE
2413: && DECL_INITIAL (olddecl) != NULL_TREE)
2414: {
2415: DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2416: DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
2417: DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
2418: }
2419:
2420: /* Merge the section attribute.
2421: We want to issue an error if the sections conflict but that must be
2422: done later in decl_attributes since we are called before attributes
2423: are assigned. */
2424: if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
2425: DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
2426:
2427: /* Keep the old rtl since we can safely use it, unless it's the
2428: call to abort() used for abstract virtuals. */
2429: if ((DECL_LANG_SPECIFIC (olddecl)
2430: && !DECL_ABSTRACT_VIRTUAL_P (olddecl))
2431: || DECL_RTL (olddecl) != DECL_RTL (abort_fndecl))
2432: DECL_RTL (newdecl) = DECL_RTL (olddecl);
2433:
2434: pop_obstacks ();
2435: }
2436: /* If cannot merge, then use the new type and qualifiers,
2437: and don't preserve the old rtl. */
2438: else
2439: {
2440: /* Clean out any memory we had of the old declaration. */
2441: tree oldstatic = value_member (olddecl, static_aggregates);
2442: if (oldstatic)
2443: TREE_VALUE (oldstatic) = error_mark_node;
2444:
2445: TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
2446: TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
2447: TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
2448: TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
2449: }
2450:
2451: /* Merge the storage class information. */
2452: if (DECL_EXTERNAL (newdecl))
2453: {
2454: TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
2455: DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
2456:
2457: if (TREE_CODE (newdecl) != FUNCTION_DECL)
2458: TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2459: }
2460: else
2461: {
2462: TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
2463: /* A `const' which was not declared `extern' and is
2464: in static storage is invisible. */
2465: if (TREE_CODE (newdecl) == VAR_DECL
2466: && TREE_READONLY (newdecl) && TREE_STATIC (newdecl)
2467: && ! DECL_THIS_EXTERN (newdecl))
2468: TREE_PUBLIC (newdecl) = 0;
2469: else if (TREE_CODE (newdecl) != FUNCTION_DECL)
2470: TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2471: }
2472:
2473: /* For functions, static overrides non-static. */
2474: if (TREE_CODE (newdecl) == FUNCTION_DECL)
2475: {
2476: TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
2477: /* This is since we don't automatically
2478: copy the attributes of NEWDECL into OLDDECL. */
2479: TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2480: /* If this clears `static', clear it in the identifier too. */
2481: if (! TREE_PUBLIC (olddecl))
2482: TREE_PUBLIC (DECL_ASSEMBLER_NAME (olddecl)) = 0;
2483: }
2484:
2485: /* If either decl says `inline', this fn is inline,
2486: unless its definition was passed already. */
2487: if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
2488: DECL_INLINE (olddecl) = 1;
2489: DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
2490:
2491: if (TREE_CODE (newdecl) == FUNCTION_DECL)
2492: {
2493: if (! types_match)
2494: {
2495: DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
2496: DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
2497: DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2498: DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2499: DECL_RTL (olddecl) = DECL_RTL (newdecl);
2500: }
2501: if (new_defines_function)
2502: /* If defining a function declared with other language
2503: linkage, use the previously declared language linkage. */
2504: DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
2505: else
2506: {
2507: /* If redeclaring a builtin function, and not a definition,
2508: it stays built in. */
2509: if (DECL_BUILT_IN (olddecl))
2510: {
2511: DECL_BUILT_IN (newdecl) = 1;
2512: DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2513: /* If we're keeping the built-in definition, keep the rtl,
2514: regardless of declaration matches. */
2515: DECL_RTL (newdecl) = DECL_RTL (olddecl);
2516: }
2517: else
2518: DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
2519:
2520: DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2521: if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
2522: /* Previously saved insns go together with
2523: the function's previous definition. */
2524: DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2525: /* Don't clear out the arguments if we're redefining a function. */
2526: if (DECL_ARGUMENTS (olddecl))
2527: DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2528: }
2529: }
2530:
2531: if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2532: {
2533: if (DECL_TEMPLATE_INFO (olddecl)->length)
2534: DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
2535: DECL_TEMPLATE_MEMBERS (newdecl) = DECL_TEMPLATE_MEMBERS (olddecl);
2536: DECL_TEMPLATE_INSTANTIATIONS (newdecl)
2537: = DECL_TEMPLATE_INSTANTIATIONS (olddecl);
2538: if (DECL_CHAIN (newdecl) == NULL_TREE)
2539: DECL_CHAIN (newdecl) = DECL_CHAIN (olddecl);
2540: }
2541:
2542: /* Now preserve various other info from the definition. */
2543: TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2544: TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2545: DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2546: DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
2547:
2548: /* Don't really know how much of the language-specific
2549: values we should copy from old to new. */
2550: if (DECL_LANG_SPECIFIC (olddecl))
2551: {
2552: DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
2553: DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
2554: }
2555:
2556: if (TREE_CODE (newdecl) == FUNCTION_DECL)
2557: {
2558: int function_size;
2559: struct lang_decl *ol = DECL_LANG_SPECIFIC (olddecl);
2560: struct lang_decl *nl = DECL_LANG_SPECIFIC (newdecl);
2561:
2562: function_size = sizeof (struct tree_decl);
2563:
2564: bcopy ((char *) newdecl + sizeof (struct tree_common),
2565: (char *) olddecl + sizeof (struct tree_common),
2566: function_size - sizeof (struct tree_common));
2567:
2568: /* Can we safely free the storage used by newdecl? */
2569:
2570: #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
2571: & ~ obstack_alignment_mask (&permanent_obstack))
2572:
2573: if ((char *)newdecl + ROUND (function_size)
2574: + ROUND (sizeof (struct lang_decl))
2575: == obstack_next_free (&permanent_obstack))
2576: {
2577: DECL_MAIN_VARIANT (newdecl) = olddecl;
2578: DECL_LANG_SPECIFIC (olddecl) = ol;
2579: bcopy ((char *)nl, (char *)ol, sizeof (struct lang_decl));
2580:
2581: obstack_free (&permanent_obstack, newdecl);
2582: }
2583: else if (LANG_DECL_PERMANENT (ol))
2584: {
2585: if (DECL_MAIN_VARIANT (olddecl) == olddecl)
2586: {
2587: /* Save these lang_decls that would otherwise be lost. */
2588: extern tree free_lang_decl_chain;
2589: tree free_lang_decl = (tree) ol;
2590: TREE_CHAIN (free_lang_decl) = free_lang_decl_chain;
2591: free_lang_decl_chain = free_lang_decl;
2592: }
2593: else
2594: {
2595: /* Storage leak. */
2596: }
2597: }
2598: }
2599: else
2600: {
2601: bcopy ((char *) newdecl + sizeof (struct tree_common),
2602: (char *) olddecl + sizeof (struct tree_common),
2603: sizeof (struct tree_decl) - sizeof (struct tree_common)
2604: + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
2605: }
2606:
2607: DECL_UID (olddecl) = olddecl_uid;
2608: if (olddecl_friend)
2609: DECL_FRIEND_P (olddecl) = 1;
2610:
2611: return 1;
2612: }
2613:
2614: /* Record a decl-node X as belonging to the current lexical scope.
2615: Check for errors (such as an incompatible declaration for the same
2616: name already seen in the same scope).
2617:
2618: Returns either X or an old decl for the same name.
2619: If an old decl is returned, it may have been smashed
2620: to agree with what X says. */
2621:
2622: tree
2623: pushdecl (x)
2624: tree x;
2625: {
2626: register tree t;
2627: #if 0 /* not yet, should get fixed properly later */
2628: register tree name;
2629: #else
2630: register tree name = DECL_ASSEMBLER_NAME (x);
2631: #endif
2632: register struct binding_level *b = current_binding_level;
2633:
2634: #if 0
2635: static int nglobals; int len;
2636:
2637: len = list_length (global_binding_level->names);
2638: if (len < nglobals)
2639: my_friendly_abort (8);
2640: else if (len > nglobals)
2641: nglobals = len;
2642: #endif
2643:
2644: if (x != current_function_decl
2645: /* Don't change DECL_CONTEXT of virtual methods. */
2646: && (TREE_CODE (x) != FUNCTION_DECL || !DECL_VIRTUAL_P (x))
2647: && ! DECL_CONTEXT (x))
2648: DECL_CONTEXT (x) = current_function_decl;
2649: /* A local declaration for a function doesn't constitute nesting. */
2650: if (TREE_CODE (x) == FUNCTION_DECL && DECL_INITIAL (x) == 0)
2651: DECL_CONTEXT (x) = 0;
2652:
2653: #if 0 /* not yet, should get fixed properly later */
2654: /* For functions and class static data, we currently look up the encoded
2655: form of the name. For types, we want the real name. The former will
2656: probably be changed soon, according to MDT. */
2657: if (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
2658: name = DECL_ASSEMBLER_NAME (x);
2659: else
2660: name = DECL_NAME (x);
2661: #else
2662: /* Type are looked up using the DECL_NAME, as that is what the rest of the
2663: compiler wants to use. */
2664: if (TREE_CODE (x) == TYPE_DECL)
2665: name = DECL_NAME (x);
2666: #endif
2667:
2668: if (name)
2669: {
2670: char *file;
2671: int line;
2672:
2673: t = lookup_name_current_level (name);
2674: if (t == error_mark_node)
2675: {
2676: /* error_mark_node is 0 for a while during initialization! */
2677: t = NULL_TREE;
2678: cp_error_at ("`%#D' used prior to declaration", x);
2679: }
2680:
2681: else if (t != NULL_TREE)
2682: {
2683: if (TREE_CODE (t) == PARM_DECL)
2684: {
2685: if (DECL_CONTEXT (t) == NULL_TREE)
2686: fatal ("parse errors have confused me too much");
2687: }
2688: file = DECL_SOURCE_FILE (t);
2689: line = DECL_SOURCE_LINE (t);
2690:
2691: if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
2692: || (TREE_CODE (x) == TEMPLATE_DECL
2693: && ! DECL_TEMPLATE_IS_CLASS (x)))
2694: && is_overloaded_fn (t))
2695: /* don't do anything just yet */;
2696: else if (TREE_CODE (t) != TREE_CODE (x))
2697: {
2698: if ((TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t))
2699: || (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2700: {
2701: /* We do nothing special here, because C++ does such nasty
2702: things with TYPE_DECLs. Instead, just let the TYPE_DECL
2703: get shadowed, and know that if we need to find a TYPE_DECL
2704: for a given name, we can look in the IDENTIFIER_TYPE_VALUE
2705: slot of the identifier. */
2706: ;
2707: }
2708: else if (duplicate_decls (x, t))
2709: return t;
2710: }
2711: else if (duplicate_decls (x, t))
2712: {
2713: #if 0
2714: /* This is turned off until I have time to do it right (bpk). */
2715:
2716: /* Also warn if they did a prototype with `static' on it, but
2717: then later left the `static' off. */
2718: if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
2719: {
2720: if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
2721: return t;
2722:
2723: if (extra_warnings)
2724: {
2725: cp_warning ("`static' missing from declaration of `%D'",
2726: t);
2727: warning_with_file_and_line (file, line,
2728: "previous declaration of `%s'",
2729: decl_as_string (t, 0));
2730: }
2731:
2732: /* Now fix things so it'll do what they expect. */
2733: if (current_function_decl)
2734: TREE_PUBLIC (current_function_decl) = 0;
2735: }
2736: /* Due to interference in memory reclamation (X may be
2737: obstack-deallocated at this point), we must guard against
2738: one really special case. [jason: This should be handled
2739: by start_function] */
2740: if (current_function_decl == x)
2741: current_function_decl = t;
2742: #endif
2743: if (TREE_CODE (t) == TYPE_DECL)
2744: SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
2745:
2746: return t;
2747: }
2748: }
2749:
2750: if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
2751: {
2752: t = push_overloaded_decl (x, 1);
2753: if (t != x || DECL_LANGUAGE (x) == lang_c)
2754: return t;
2755: }
2756: else if (TREE_CODE (x) == TEMPLATE_DECL && ! DECL_TEMPLATE_IS_CLASS (x))
2757: return push_overloaded_decl (x, 0);
2758:
2759: /* If declaring a type as a typedef, and the type has no known
2760: typedef name, install this TYPE_DECL as its typedef name. */
2761: if (TREE_CODE (x) == TYPE_DECL)
2762: {
2763: tree type = TREE_TYPE (x);
2764: tree name = (type != error_mark_node) ? TYPE_NAME (type) : x;
2765:
2766: if (name == NULL_TREE || TREE_CODE (name) != TYPE_DECL)
2767: {
2768: /* If these are different names, and we're at the global
2769: binding level, make two equivalent definitions. */
2770: name = x;
2771: if (global_bindings_p ())
2772: TYPE_NAME (type) = x;
2773: }
2774: else
2775: {
2776: tree tname = DECL_NAME (name);
2777:
2778: if (global_bindings_p () && ANON_AGGRNAME_P (tname))
2779: {
2780: /* do gratuitous C++ typedefing, and make sure that
2781: we access this type either through TREE_TYPE field
2782: or via the tags list. */
2783: TYPE_NAME (TREE_TYPE (x)) = x;
2784: pushtag (tname, TREE_TYPE (x), 0);
2785: }
2786: }
2787: my_friendly_assert (TREE_CODE (name) == TYPE_DECL, 140);
2788:
2789: if (DECL_NAME (name) && !DECL_NESTED_TYPENAME (name))
2790: set_nested_typename (x, current_class_name,
2791: DECL_NAME (name), type);
2792:
2793: if (type != error_mark_node
2794: && TYPE_NAME (type)
2795: && TYPE_IDENTIFIER (type))
2796: set_identifier_type_value_with_scope (DECL_NAME (x), type, b);
2797: }
2798:
2799: /* Multiple external decls of the same identifier ought to match.
2800:
2801: We get warnings about inline functions where they are defined.
2802: We get warnings about other functions from push_overloaded_decl.
2803:
2804: Avoid duplicate warnings where they are used. */
2805: if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
2806: {
2807: tree decl;
2808:
2809: if (IDENTIFIER_GLOBAL_VALUE (name) != NULL_TREE
2810: && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
2811: || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name))))
2812: decl = IDENTIFIER_GLOBAL_VALUE (name);
2813: else
2814: decl = NULL_TREE;
2815:
2816: if (decl
2817: /* If different sort of thing, we already gave an error. */
2818: && TREE_CODE (decl) == TREE_CODE (x)
2819: && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl), 1))
2820: {
2821: cp_pedwarn ("type mismatch with previous external decl", x);
2822: cp_pedwarn_at ("previous external decl of `%#D'", decl);
2823: }
2824: }
2825:
2826: /* In PCC-compatibility mode, extern decls of vars with no current decl
2827: take effect at top level no matter where they are. */
2828: if (flag_traditional && DECL_EXTERNAL (x)
2829: && lookup_name (name, 0) == NULL_TREE)
2830: b = global_binding_level;
2831:
2832: /* This name is new in its binding level.
2833: Install the new declaration and return it. */
2834: if (b == global_binding_level)
2835: {
2836: /* Install a global value. */
2837:
2838: /* Rule for VAR_DECLs, but not for other kinds of _DECLs:
2839: A `const' which was not declared `extern' is invisible. */
2840: if (TREE_CODE (x) == VAR_DECL
2841: && TREE_READONLY (x) && ! DECL_THIS_EXTERN (x))
2842: TREE_PUBLIC (x) = 0;
2843:
2844: /* If the first global decl has external linkage,
2845: warn if we later see static one. */
2846: if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
2847: TREE_PUBLIC (name) = 1;
2848:
2849: /* Don't install a TYPE_DECL if we already have another
2850: sort of _DECL with that name. */
2851: if (TREE_CODE (x) != TYPE_DECL
2852: || t == NULL_TREE
2853: || TREE_CODE (t) == TYPE_DECL)
2854: IDENTIFIER_GLOBAL_VALUE (name) = x;
2855:
2856: /* Don't forget if the function was used via an implicit decl. */
2857: if (IDENTIFIER_IMPLICIT_DECL (name)
2858: && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
2859: TREE_USED (x) = 1;
2860:
2861: /* Don't forget if its address was taken in that way. */
2862: if (IDENTIFIER_IMPLICIT_DECL (name)
2863: && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
2864: TREE_ADDRESSABLE (x) = 1;
2865:
2866: /* Warn about mismatches against previous implicit decl. */
2867: if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
2868: /* If this real decl matches the implicit, don't complain. */
2869: && ! (TREE_CODE (x) == FUNCTION_DECL
2870: && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
2871: cp_warning
2872: ("`%D' was previously implicitly declared to return `int'", x);
2873:
2874: /* If new decl is `static' and an `extern' was seen previously,
2875: warn about it. */
2876: if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
2877: warn_extern_redeclared_static (x, t);
2878: }
2879: else
2880: {
2881: /* Here to install a non-global value. */
2882: tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
2883: tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
2884:
2885: b->shadowed = tree_cons (name, oldlocal, b->shadowed);
2886: IDENTIFIER_LOCAL_VALUE (name) = x;
2887:
2888: /* If this is a TYPE_DECL, push it into the type value slot. */
2889: if (TREE_CODE (x) == TYPE_DECL)
2890: set_identifier_type_value_with_scope (name, TREE_TYPE (x), b);
2891:
2892: /* If this is an extern function declaration, see if we
2893: have a global definition or declaration for the function. */
2894: if (oldlocal == NULL_TREE
2895: && DECL_EXTERNAL (x) && !DECL_INLINE (x)
2896: && oldglobal != NULL_TREE
2897: && TREE_CODE (x) == FUNCTION_DECL
2898: && TREE_CODE (oldglobal) == FUNCTION_DECL)
2899: {
2900: /* We have one. Their types must agree. */
2901: if (! comptypes (TREE_TYPE (x), TREE_TYPE (oldglobal), 1))
2902: {
2903: cp_warning ("extern declaration of `%#D' doesn't match", x);
2904: cp_warning_at ("global declaration `%#D'", oldglobal);
2905: }
2906: else
2907: {
2908: /* Inner extern decl is inline if global one is.
2909: Copy enough to really inline it. */
2910: if (DECL_INLINE (oldglobal))
2911: {
2912: DECL_INLINE (x) = DECL_INLINE (oldglobal);
2913: DECL_INITIAL (x) = (current_function_decl == oldglobal
2914: ? NULL_TREE : DECL_INITIAL (oldglobal));
2915: DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
2916: DECL_FRAME_SIZE (x) = DECL_FRAME_SIZE (oldglobal);
2917: DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
2918: DECL_RESULT (x) = DECL_RESULT (oldglobal);
2919: TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
2920: DECL_ABSTRACT_ORIGIN (x) = oldglobal;
2921: }
2922: /* Inner extern decl is built-in if global one is. */
2923: if (DECL_BUILT_IN (oldglobal))
2924: {
2925: DECL_BUILT_IN (x) = DECL_BUILT_IN (oldglobal);
2926: DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal);
2927: }
2928: /* Keep the arg types from a file-scope fcn defn. */
2929: if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != NULL_TREE
2930: && DECL_INITIAL (oldglobal)
2931: && TYPE_ARG_TYPES (TREE_TYPE (x)) == NULL_TREE)
2932: TREE_TYPE (x) = TREE_TYPE (oldglobal);
2933: }
2934: }
2935: /* If we have a local external declaration,
2936: and no file-scope declaration has yet been seen,
2937: then if we later have a file-scope decl it must not be static. */
2938: if (oldlocal == NULL_TREE
2939: && oldglobal == NULL_TREE
2940: && DECL_EXTERNAL (x)
2941: && TREE_PUBLIC (x))
2942: {
2943: TREE_PUBLIC (name) = 1;
2944: }
2945:
2946: if (DECL_FROM_INLINE (x))
2947: /* Inline decls shadow nothing. */;
2948:
2949: /* Warn if shadowing an argument at the top level of the body. */
2950: else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
2951: && TREE_CODE (oldlocal) == PARM_DECL
2952: && TREE_CODE (x) != PARM_DECL)
2953: {
2954: /* Go to where the parms should be and see if we
2955: find them there. */
2956: struct binding_level *b = current_binding_level->level_chain;
2957:
2958: if (cleanup_label)
2959: b = b->level_chain;
2960:
2961: /* ARM $8.3 */
2962: if (b->parm_flag == 1)
2963: cp_error ("declaration of `%#D' shadows a parameter", name);
2964: }
2965: /* Maybe warn if shadowing something else. */
2966: else if (warn_shadow && !DECL_EXTERNAL (x)
2967: /* No shadow warnings for internally generated vars. */
2968: && ! DECL_ARTIFICIAL (x)
2969: /* No shadow warnings for vars made for inlining. */
2970: && ! DECL_FROM_INLINE (x))
2971: {
2972: char *warnstring = NULL;
2973:
2974: if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
2975: warnstring = "declaration of `%s' shadows a parameter";
2976: else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
2977: && !TREE_STATIC (name))
2978: warnstring = "declaration of `%s' shadows a member of `this'";
2979: else if (oldlocal != NULL_TREE)
2980: warnstring = "declaration of `%s' shadows previous local";
2981: else if (oldglobal != NULL_TREE)
2982: warnstring = "declaration of `%s' shadows global declaration";
2983:
2984: if (warnstring)
2985: warning (warnstring, IDENTIFIER_POINTER (name));
2986: }
2987:
2988: /* If storing a local value, there may already be one (inherited).
2989: If so, record it for restoration when this binding level ends. */
2990: if (oldlocal != NULL_TREE)
2991: b->shadowed = tree_cons (name, oldlocal, b->shadowed);
2992: }
2993:
2994: /* Keep count of variables in this level with incomplete type. */
2995: if (TREE_CODE (x) != TEMPLATE_DECL
2996: && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
2997: && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
2998: {
2999: if (++b->n_incomplete == 0)
3000: error ("too many incomplete variables at this point");
3001: }
3002: }
3003:
3004: if (TREE_CODE (x) == TYPE_DECL && name != NULL_TREE)
3005: {
3006: if (current_class_name)
3007: {
3008: if (! TREE_MANGLED (name))
3009: set_nested_typename (x, current_class_name, DECL_NAME (x),
3010: TREE_TYPE (x));
3011: }
3012: }
3013:
3014: /* Put decls on list in reverse order.
3015: We will reverse them later if necessary. */
3016: TREE_CHAIN (x) = b->names;
3017: b->names = x;
3018: if (! (b != global_binding_level || TREE_PERMANENT (x)))
3019: my_friendly_abort (124);
3020:
3021: return x;
3022: }
3023:
3024: /* Same as pushdecl, but define X in binding-level LEVEL. */
3025:
3026: static tree
3027: pushdecl_with_scope (x, level)
3028: tree x;
3029: struct binding_level *level;
3030: {
3031: register struct binding_level *b = current_binding_level;
3032:
3033: current_binding_level = level;
3034: x = pushdecl (x);
3035: current_binding_level = b;
3036: return x;
3037: }
3038:
3039: /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
3040: if appropriate. */
3041: tree
3042: pushdecl_top_level (x)
3043: tree x;
3044: {
3045: register struct binding_level *b = inner_binding_level;
3046: register tree t = pushdecl_with_scope (x, global_binding_level);
3047:
3048: /* Now, the type_shadowed stack may screw us. Munge it so it does
3049: what we want. */
3050: if (TREE_CODE (x) == TYPE_DECL)
3051: {
3052: tree name = DECL_NAME (x);
3053: tree newval;
3054: tree *ptr = (tree *)0;
3055: for (; b != global_binding_level; b = b->level_chain)
3056: {
3057: tree shadowed = b->type_shadowed;
3058: for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3059: if (TREE_PURPOSE (shadowed) == name)
3060: {
3061: ptr = &TREE_VALUE (shadowed);
3062: /* Can't break out of the loop here because sometimes
3063: a binding level will have duplicate bindings for
3064: PT names. It's gross, but I haven't time to fix it. */
3065: }
3066: }
3067: newval = TREE_TYPE (x);
3068: if (ptr == (tree *)0)
3069: {
3070: /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3071: up here if this is changed to an assertion. --KR */
3072: SET_IDENTIFIER_TYPE_VALUE (name, newval);
3073: }
3074: else
3075: {
3076: #if 0
3077: /* Disabled this 11/10/92, since there are many cases which
3078: behave just fine when *ptr doesn't satisfy either of these.
3079: For example, nested classes declared as friends of their enclosing
3080: class will not meet this criteria. (bpk) */
3081: my_friendly_assert (*ptr == NULL_TREE || *ptr == newval, 141);
3082: #endif
3083: *ptr = newval;
3084: }
3085: }
3086: return t;
3087: }
3088:
3089: /* Like push_overloaded_decl, only it places X in GLOBAL_BINDING_LEVEL,
3090: if appropriate. */
3091: void
3092: push_overloaded_decl_top_level (x, forget)
3093: tree x;
3094: int forget;
3095: {
3096: struct binding_level *b = current_binding_level;
3097:
3098: current_binding_level = global_binding_level;
3099: push_overloaded_decl (x, forget);
3100: current_binding_level = b;
3101: }
3102:
3103: /* Make the declaration of X appear in CLASS scope. */
3104: tree
3105: pushdecl_class_level (x)
3106: tree x;
3107: {
3108: /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
3109: scope looks for the pre-mangled name. */
3110: register tree name = DECL_NAME (x);
3111:
3112: if (name)
3113: {
3114: if (TYPE_BEING_DEFINED (current_class_type))
3115: {
3116: /* Check for inconsistent use of this name in the class body.
3117: Types, enums, and static vars are checked here; other
3118: members are checked in finish_struct. */
3119: tree icv = IDENTIFIER_CLASS_VALUE (name);
3120:
3121: if (icv
3122: /* Don't complain about inherited names. */
3123: && id_in_current_class (name)
3124: /* Or shadowed tags. */
3125: && !(TREE_CODE (icv) == TYPE_DECL
3126: && DECL_CONTEXT (icv) == current_class_type))
3127: {
3128: cp_error ("declaration of identifier `%D' as `%#D'", name, x);
3129: cp_error_at ("conflicts with previous use in class as `%#D'",
3130: icv);
3131: }
3132: }
3133:
3134: push_class_level_binding (name, x);
3135: if (TREE_CODE (x) == TYPE_DECL)
3136: {
3137: set_identifier_type_value (name, TREE_TYPE (x));
3138: if (!DECL_NESTED_TYPENAME (x))
3139: set_nested_typename (x, current_class_name, name, TREE_TYPE (x));
3140: }
3141: }
3142: return x;
3143: }
3144:
3145: /* This function is used to push the mangled decls for nested types into
3146: the appropriate scope. Previously pushdecl_top_level was used, but that
3147: is incorrect for members of local classes. */
3148: tree
3149: pushdecl_nonclass_level (x)
3150: tree x;
3151: {
3152: struct binding_level *b = current_binding_level;
3153:
3154: #if 0
3155: /* Get out of class scope -- this isn't necessary, because class scope
3156: doesn't make it into current_binding_level. */
3157: while (b->parm_flag == 2)
3158: b = b->level_chain;
3159: #else
3160: my_friendly_assert (b->parm_flag != 2, 180);
3161: #endif
3162:
3163: /* Get out of template binding levels */
3164: while (b->pseudo_global)
3165: b = b->level_chain;
3166:
3167: pushdecl_with_scope (x, b);
3168: }
3169:
3170: /* Make the declaration(s) of X appear in CLASS scope
3171: under the name NAME. */
3172: void
3173: push_class_level_binding (name, x)
3174: tree name;
3175: tree x;
3176: {
3177: maybe_push_cache_obstack ();
3178: class_binding_level->class_shadowed
3179: = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
3180: class_binding_level->class_shadowed);
3181: pop_obstacks ();
3182: IDENTIFIER_CLASS_VALUE (name) = x;
3183: obstack_ptr_grow (&decl_obstack, x);
3184: }
3185:
3186: /* Tell caller how to interpret a TREE_LIST which contains
3187: chains of FUNCTION_DECLS. */
3188: int
3189: overloaded_globals_p (list)
3190: tree list;
3191: {
3192: my_friendly_assert (TREE_CODE (list) == TREE_LIST, 142);
3193:
3194: /* Don't commit caller to seeing them as globals. */
3195: if (TREE_NONLOCAL_FLAG (list))
3196: return -1;
3197: /* Do commit caller to seeing them as globals. */
3198: if (TREE_CODE (TREE_PURPOSE (list)) == IDENTIFIER_NODE)
3199: return 1;
3200: /* Do commit caller to not seeing them as globals. */
3201: return 0;
3202: }
3203:
3204: /* DECL is a FUNCTION_DECL which may have other definitions already in
3205: place. We get around this by making the value of the identifier point
3206: to a list of all the things that want to be referenced by that name. It
3207: is then up to the users of that name to decide what to do with that
3208: list.
3209:
3210: DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
3211: slot. It is dealt with the same way.
3212:
3213: The value returned may be a previous declaration if we guessed wrong
3214: about what language DECL should belong to (C or C++). Otherwise,
3215: it's always DECL (and never something that's not a _DECL). */
3216: tree
3217: push_overloaded_decl (decl, forgettable)
3218: tree decl;
3219: int forgettable;
3220: {
3221: tree orig_name = DECL_NAME (decl);
3222: tree old;
3223: int doing_global = (global_bindings_p () || ! forgettable
3224: || flag_traditional || pseudo_global_level_p ());
3225:
3226: if (doing_global)
3227: {
3228: old = IDENTIFIER_GLOBAL_VALUE (orig_name);
3229: if (old && TREE_CODE (old) == FUNCTION_DECL
3230: && DECL_ARTIFICIAL (old)
3231: && (DECL_BUILT_IN (old) || DECL_BUILT_IN_NONANSI (old)))
3232: {
3233: if (duplicate_decls (decl, old))
3234: return old;
3235: old = NULL_TREE;
3236: }
3237: }
3238: else
3239: {
3240: old = IDENTIFIER_LOCAL_VALUE (orig_name);
3241:
3242: if (! purpose_member (orig_name, current_binding_level->shadowed))
3243: {
3244: current_binding_level->shadowed
3245: = tree_cons (orig_name, old, current_binding_level->shadowed);
3246: old = NULL_TREE;
3247: }
3248: }
3249:
3250: if (old)
3251: {
3252: #if 0
3253: /* We cache the value of builtin functions as ADDR_EXPRs
3254: in the name space. Convert it to some kind of _DECL after
3255: remembering what to forget. */
3256: if (TREE_CODE (old) == ADDR_EXPR)
3257: old = TREE_OPERAND (old, 0);
3258: else
3259: #endif
3260: if (TREE_CODE (old) == VAR_DECL)
3261: {
3262: cp_error_at ("previous non-function declaration `%#D'", old);
3263: cp_error ("conflicts with function declaration `%#D'", decl);
3264: return error_mark_node;
3265: }
3266: else if (TREE_CODE (old) == TYPE_DECL)
3267: {
3268: tree t = TREE_TYPE (old);
3269: if (IS_AGGR_TYPE (t) && warn_shadow)
3270: cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
3271: old = NULL_TREE;
3272: }
3273: else if (is_overloaded_fn (old))
3274: {
3275: tree tmp;
3276:
3277: for (tmp = get_first_fn (old); tmp; tmp = DECL_CHAIN (tmp))
3278: if (decl == tmp || duplicate_decls (decl, tmp))
3279: return tmp;
3280: }
3281: }
3282:
3283: if (old || TREE_CODE (decl) == TEMPLATE_DECL)
3284: {
3285: if (old && is_overloaded_fn (old))
3286: DECL_CHAIN (decl) = get_first_fn (old);
3287: else
3288: DECL_CHAIN (decl) = NULL_TREE;
3289: old = tree_cons (orig_name, decl, NULL_TREE);
3290: TREE_TYPE (old) = unknown_type_node;
3291: }
3292: else
3293: /* orig_name is not ambiguous. */
3294: old = decl;
3295:
3296: if (doing_global)
3297: IDENTIFIER_GLOBAL_VALUE (orig_name) = old;
3298: else
3299: IDENTIFIER_LOCAL_VALUE (orig_name) = old;
3300:
3301: return decl;
3302: }
3303:
3304: /* Generate an implicit declaration for identifier FUNCTIONID
3305: as a function of type int (). Print a warning if appropriate. */
3306:
3307: tree
3308: implicitly_declare (functionid)
3309: tree functionid;
3310: {
3311: register tree decl;
3312: int temp = allocation_temporary_p ();
3313:
3314: push_obstacks_nochange ();
3315:
3316: /* Save the decl permanently so we can warn if definition follows.
3317: In ANSI C, warn_implicit is usually false, so the saves little space.
3318: But in C++, it's usually true, hence the extra code. */
3319: if (temp && (flag_traditional || !warn_implicit
3320: || current_binding_level == global_binding_level))
3321: end_temporary_allocation ();
3322:
3323: /* We used to reuse an old implicit decl here,
3324: but this loses with inline functions because it can clobber
3325: the saved decl chains. */
3326: decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
3327:
3328: DECL_EXTERNAL (decl) = 1;
3329: TREE_PUBLIC (decl) = 1;
3330:
3331: /* ANSI standard says implicit declarations are in the innermost block.
3332: So we record the decl in the standard fashion.
3333: If flag_traditional is set, pushdecl does it top-level. */
3334: pushdecl (decl);
3335: rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
3336:
3337: if (warn_implicit
3338: /* Only one warning per identifier. */
3339: && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
3340: {
3341: cp_pedwarn ("implicit declaration of function `%#D'", decl);
3342: }
3343:
3344: SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
3345:
3346: pop_obstacks ();
3347:
3348: return decl;
3349: }
3350:
3351: /* Return zero if the declaration NEWDECL is valid
3352: when the declaration OLDDECL (assumed to be for the same name)
3353: has already been seen.
3354: Otherwise return an error message format string with a %s
3355: where the identifier should go. */
3356:
3357: static char *
3358: redeclaration_error_message (newdecl, olddecl)
3359: tree newdecl, olddecl;
3360: {
3361: if (TREE_CODE (newdecl) == TYPE_DECL)
3362: {
3363: /* Because C++ can put things into name space for free,
3364: constructs like "typedef struct foo { ... } foo"
3365: would look like an erroneous redeclaration. */
3366: if (comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 0))
3367: return 0;
3368: else
3369: return "redefinition of `%#D'";
3370: }
3371: else if (TREE_CODE (newdecl) == FUNCTION_DECL)
3372: {
3373: /* If this is a pure function, its olddecl will actually be
3374: the original initialization to `0' (which we force to call
3375: abort()). Don't complain about redefinition in this case. */
3376: if (DECL_LANG_SPECIFIC (olddecl) && DECL_ABSTRACT_VIRTUAL_P (olddecl))
3377: return 0;
3378:
3379: /* Declarations of functions can insist on internal linkage
3380: but they can't be inconsistent with internal linkage,
3381: so there can be no error on that account.
3382: However defining the same name twice is no good. */
3383: if (DECL_INITIAL (olddecl) != NULL_TREE
3384: && DECL_INITIAL (newdecl) != NULL_TREE
3385: /* However, defining once as extern inline and a second
3386: time in another way is ok. */
3387: && !(DECL_INLINE (olddecl) && DECL_EXTERNAL (olddecl)
3388: && !(DECL_INLINE (newdecl) && DECL_EXTERNAL (newdecl))))
3389: {
3390: if (DECL_NAME (olddecl) == NULL_TREE)
3391: return "`%#D' not declared in class";
3392: else
3393: return "redefinition of `%#D'";
3394: }
3395:
3396: {
3397: tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3398: tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3399:
3400: if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3401: t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3402:
3403: for (; t1; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
3404: if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3405: return "duplicate default arguments given for `%#D'";
3406: }
3407: return 0;
3408: }
3409: else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3410: {
3411: if (DECL_INITIAL (olddecl) && DECL_INITIAL (newdecl))
3412: return "redefinition of `%#D'";
3413: return 0;
3414: }
3415: else if (current_binding_level == global_binding_level)
3416: {
3417: /* Objects declared at top level: */
3418: /* If at least one is a reference, it's ok. */
3419: if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
3420: return 0;
3421: /* Now we have two tentative defs, or one tentative and one real def. */
3422: /* Insist that the linkage match. */
3423: if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
3424: return "conflicting declarations of `%#D'";
3425: /* Reject two definitions. */
3426: return "redefinition of `%#D'";
3427: }
3428: else
3429: {
3430: /* Objects declared with block scope: */
3431: /* Reject two definitions, and reject a definition
3432: together with an external reference. */
3433: if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
3434: return "redeclaration of `%#D'";
3435: return 0;
3436: }
3437: }
3438:
3439: /* Get the LABEL_DECL corresponding to identifier ID as a label.
3440: Create one if none exists so far for the current function.
3441: This function is called for both label definitions and label references. */
3442:
3443: tree
3444: lookup_label (id)
3445: tree id;
3446: {
3447: register tree decl = IDENTIFIER_LABEL_VALUE (id);
3448:
3449: if (current_function_decl == NULL_TREE)
3450: {
3451: error ("label `%s' referenced outside of any function",
3452: IDENTIFIER_POINTER (id));
3453: return NULL_TREE;
3454: }
3455:
3456: if ((decl == NULL_TREE
3457: || DECL_SOURCE_LINE (decl) == 0)
3458: && (named_label_uses == NULL_TREE
3459: || TREE_PURPOSE (named_label_uses) != current_binding_level->names
3460: || TREE_VALUE (named_label_uses) != decl))
3461: {
3462: named_label_uses
3463: = tree_cons (current_binding_level->names, decl, named_label_uses);
3464: TREE_TYPE (named_label_uses) = (tree)current_binding_level;
3465: }
3466:
3467: /* Use a label already defined or ref'd with this name. */
3468: if (decl != NULL_TREE)
3469: {
3470: /* But not if it is inherited and wasn't declared to be inheritable. */
3471: if (DECL_CONTEXT (decl) != current_function_decl
3472: && ! C_DECLARED_LABEL_FLAG (decl))
3473: return shadow_label (id);
3474: return decl;
3475: }
3476:
3477: decl = build_decl (LABEL_DECL, id, void_type_node);
3478:
3479: /* A label not explicitly declared must be local to where it's ref'd. */
3480: DECL_CONTEXT (decl) = current_function_decl;
3481:
3482: DECL_MODE (decl) = VOIDmode;
3483:
3484: /* Say where one reference is to the label,
3485: for the sake of the error if it is not defined. */
3486: DECL_SOURCE_LINE (decl) = lineno;
3487: DECL_SOURCE_FILE (decl) = input_filename;
3488:
3489: SET_IDENTIFIER_LABEL_VALUE (id, decl);
3490:
3491: named_labels = tree_cons (NULL_TREE, decl, named_labels);
3492: TREE_VALUE (named_label_uses) = decl;
3493:
3494: return decl;
3495: }
3496:
3497: /* Make a label named NAME in the current function,
3498: shadowing silently any that may be inherited from containing functions
3499: or containing scopes.
3500:
3501: Note that valid use, if the label being shadowed
3502: comes from another scope in the same function,
3503: requires calling declare_nonlocal_label right away. */
3504:
3505: tree
3506: shadow_label (name)
3507: tree name;
3508: {
3509: register tree decl = IDENTIFIER_LABEL_VALUE (name);
3510:
3511: if (decl != NULL_TREE)
3512: {
3513: shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
3514: SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
3515: SET_IDENTIFIER_LABEL_VALUE (decl, NULL_TREE);
3516: }
3517:
3518: return lookup_label (name);
3519: }
3520:
3521: /* Define a label, specifying the location in the source file.
3522: Return the LABEL_DECL node for the label, if the definition is valid.
3523: Otherwise return 0. */
3524:
3525: tree
3526: define_label (filename, line, name)
3527: char *filename;
3528: int line;
3529: tree name;
3530: {
3531: tree decl = lookup_label (name);
3532:
3533: /* After labels, make any new cleanups go into their
3534: own new (temporary) binding contour. */
3535: current_binding_level->more_cleanups_ok = 0;
3536:
3537: /* If label with this name is known from an outer context, shadow it. */
3538: if (decl != NULL_TREE && DECL_CONTEXT (decl) != current_function_decl)
3539: {
3540: shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
3541: SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
3542: decl = lookup_label (name);
3543: }
3544:
3545: if (DECL_INITIAL (decl) != NULL_TREE)
3546: {
3547: cp_error ("duplicate label `%D'", decl);
3548: return 0;
3549: }
3550: else
3551: {
3552: tree uses, prev;
3553:
3554: /* Mark label as having been defined. */
3555: DECL_INITIAL (decl) = error_mark_node;
3556: /* Say where in the source. */
3557: DECL_SOURCE_FILE (decl) = filename;
3558: DECL_SOURCE_LINE (decl) = line;
3559:
3560: for (prev = NULL_TREE, uses = named_label_uses;
3561: uses;
3562: prev = uses, uses = TREE_CHAIN (uses))
3563: if (TREE_VALUE (uses) == decl)
3564: {
3565: struct binding_level *b = current_binding_level;
3566: while (b)
3567: {
3568: tree new_decls = b->names;
3569: tree old_decls = ((tree)b == TREE_TYPE (uses)
3570: ? TREE_PURPOSE (uses) : NULL_TREE);
3571: while (new_decls != old_decls)
3572: {
3573: if (TREE_CODE (new_decls) == VAR_DECL
3574: /* Don't complain about crossing initialization
3575: of internal entities. They can't be accessed,
3576: and they should be cleaned up
3577: by the time we get to the label. */
3578: && ! DECL_ARTIFICIAL (new_decls)
3579: && ((DECL_INITIAL (new_decls) != NULL_TREE
3580: && DECL_INITIAL (new_decls) != error_mark_node)
3581: || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
3582: {
3583: if (IDENTIFIER_ERROR_LOCUS (decl) == NULL_TREE)
3584: cp_error ("invalid jump to label `%D'", decl);
3585: SET_IDENTIFIER_ERROR_LOCUS (decl, current_function_decl);
3586: cp_error ("crosses initialization of `%D'", new_decls);
3587: }
3588: new_decls = TREE_CHAIN (new_decls);
3589: }
3590: if ((tree)b == TREE_TYPE (uses))
3591: break;
3592: b = b->level_chain;
3593: }
3594:
3595: if (prev)
3596: TREE_CHAIN (prev) = TREE_CHAIN (uses);
3597: else
3598: named_label_uses = TREE_CHAIN (uses);
3599: }
3600: current_function_return_value = NULL_TREE;
3601: return decl;
3602: }
3603: }
3604:
3605: /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
3606: /* XXX Note decl is never actually used. (bpk) */
3607: void
3608: define_case_label (decl)
3609: tree decl;
3610: {
3611: tree cleanup = last_cleanup_this_contour ();
3612: if (cleanup)
3613: {
3614: static int explained = 0;
3615: cp_error_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
3616: error ("where case label appears here");
3617: if (!explained)
3618: {
3619: error ("(enclose actions of previous case statements requiring");
3620: error ("destructors in their own binding contours.)");
3621: explained = 1;
3622: }
3623: }
3624:
3625: /* After labels, make any new cleanups go into their
3626: own new (temporary) binding contour. */
3627:
3628: current_binding_level->more_cleanups_ok = 0;
3629: current_function_return_value = NULL_TREE;
3630: }
3631:
3632: /* Return the list of declarations of the current level.
3633: Note that this list is in reverse order unless/until
3634: you nreverse it; and when you do nreverse it, you must
3635: store the result back using `storedecls' or you will lose. */
3636:
3637: tree
3638: getdecls ()
3639: {
3640: return current_binding_level->names;
3641: }
3642:
3643: /* Return the list of type-tags (for structs, etc) of the current level. */
3644:
3645: tree
3646: gettags ()
3647: {
3648: return current_binding_level->tags;
3649: }
3650:
3651: /* Store the list of declarations of the current level.
3652: This is done for the parameter declarations of a function being defined,
3653: after they are modified in the light of any missing parameters. */
3654:
3655: static void
3656: storedecls (decls)
3657: tree decls;
3658: {
3659: current_binding_level->names = decls;
3660: }
3661:
3662: /* Similarly, store the list of tags of the current level. */
3663:
3664: static void
3665: storetags (tags)
3666: tree tags;
3667: {
3668: current_binding_level->tags = tags;
3669: }
3670:
3671: /* Given NAME, an IDENTIFIER_NODE,
3672: return the structure (or union or enum) definition for that name.
3673: Searches binding levels from BINDING_LEVEL up to the global level.
3674: If THISLEVEL_ONLY is nonzero, searches only the specified context
3675: (but skips any tag-transparent contexts to find one that is
3676: meaningful for tags).
3677: FORM says which kind of type the caller wants;
3678: it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3679: If the wrong kind of type is found, and it's not a template, an error is
3680: reported. */
3681:
3682: static tree
3683: lookup_tag (form, name, binding_level, thislevel_only)
3684: enum tree_code form;
3685: struct binding_level *binding_level;
3686: tree name;
3687: int thislevel_only;
3688: {
3689: register struct binding_level *level;
3690:
3691: for (level = binding_level; level; level = level->level_chain)
3692: {
3693: register tree tail;
3694: if (ANON_AGGRNAME_P (name))
3695: for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
3696: {
3697: /* There's no need for error checking here, because
3698: anon names are unique throughout the compilation. */
3699: if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
3700: return TREE_VALUE (tail);
3701: }
3702: else
3703: for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
3704: {
3705: if (TREE_PURPOSE (tail) == name)
3706: {
3707: enum tree_code code = TREE_CODE (TREE_VALUE (tail));
3708: /* Should tighten this up; it'll probably permit
3709: UNION_TYPE and a struct template, for example. */
3710: if (code != form
3711: && !(form != ENUMERAL_TYPE
3712: && (code == TEMPLATE_DECL
3713: || code == UNINSTANTIATED_P_TYPE)))
3714:
3715: {
3716: /* Definition isn't the kind we were looking for. */
3717: cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
3718: form);
3719: }
3720: return TREE_VALUE (tail);
3721: }
3722: }
3723: if (thislevel_only && ! level->tag_transparent)
3724: return NULL_TREE;
3725: if (current_class_type && level->level_chain == global_binding_level)
3726: {
3727: /* Try looking in this class's tags before heading into
3728: global binding level. */
3729: tree context = current_class_type;
3730: while (context)
3731: {
3732: switch (TREE_CODE_CLASS (TREE_CODE (context)))
3733: {
3734: tree these_tags;
3735: case 't':
3736: these_tags = CLASSTYPE_TAGS (context);
3737: if (ANON_AGGRNAME_P (name))
3738: while (these_tags)
3739: {
3740: if (TYPE_IDENTIFIER (TREE_VALUE (these_tags))
3741: == name)
3742: return TREE_VALUE (tail);
3743: these_tags = TREE_CHAIN (these_tags);
3744: }
3745: else
3746: while (these_tags)
3747: {
3748: if (TREE_PURPOSE (these_tags) == name)
3749: {
3750: if (TREE_CODE (TREE_VALUE (these_tags)) != form)
3751: {
3752: cp_error ("`%#D' redeclared as %C in class scope",
3753: TREE_VALUE (tail), form);
3754: }
3755: return TREE_VALUE (tail);
3756: }
3757: these_tags = TREE_CHAIN (these_tags);
3758: }
3759: /* If this type is not yet complete, then don't
3760: look at its context. */
3761: if (TYPE_SIZE (context) == NULL_TREE)
3762: goto no_context;
3763: /* Go to next enclosing type, if any. */
3764: context = DECL_CONTEXT (TYPE_NAME (context));
3765: break;
3766: case 'd':
3767: context = DECL_CONTEXT (context);
3768: break;
3769: default:
3770: my_friendly_abort (10);
3771: }
3772: continue;
3773: no_context:
3774: break;
3775: }
3776: }
3777: }
3778: return NULL_TREE;
3779: }
3780:
3781: void
3782: set_current_level_tags_transparency (tags_transparent)
3783: int tags_transparent;
3784: {
3785: current_binding_level->tag_transparent = tags_transparent;
3786: }
3787:
3788: /* Given a type, find the tag that was defined for it and return the tag name.
3789: Otherwise return 0. However, the value can never be 0
3790: in the cases in which this is used.
3791:
3792: C++: If NAME is non-zero, this is the new name to install. This is
3793: done when replacing anonymous tags with real tag names. */
3794:
3795: static tree
3796: lookup_tag_reverse (type, name)
3797: tree type;
3798: tree name;
3799: {
3800: register struct binding_level *level;
3801:
3802: for (level = current_binding_level; level; level = level->level_chain)
3803: {
3804: register tree tail;
3805: for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
3806: {
3807: if (TREE_VALUE (tail) == type)
3808: {
3809: if (name)
3810: TREE_PURPOSE (tail) = name;
3811: return TREE_PURPOSE (tail);
3812: }
3813: }
3814: }
3815: return NULL_TREE;
3816: }
3817:
3818: /* Given type TYPE which was not declared in C++ language context,
3819: attempt to find a name by which it is referred. */
3820: tree
3821: typedecl_for_tag (tag)
3822: tree tag;
3823: {
3824: struct binding_level *b = current_binding_level;
3825:
3826: if (TREE_CODE (TYPE_NAME (tag)) == TYPE_DECL)
3827: return TYPE_NAME (tag);
3828:
3829: while (b)
3830: {
3831: tree decls = b->names;
3832: while (decls)
3833: {
3834: if (TREE_CODE (decls) == TYPE_DECL && TREE_TYPE (decls) == tag)
3835: break;
3836: decls = TREE_CHAIN (decls);
3837: }
3838: if (decls)
3839: return decls;
3840: b = b->level_chain;
3841: }
3842: return NULL_TREE;
3843: }
3844:
3845: /* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
3846: Return the type value, or NULL_TREE if not found. */
3847: static tree
3848: lookup_nested_type (type, context)
3849: tree type;
3850: tree context;
3851: {
3852: if (context == NULL_TREE)
3853: return NULL_TREE;
3854: while (context)
3855: {
3856: switch (TREE_CODE (context))
3857: {
3858: case TYPE_DECL:
3859: {
3860: tree ctype = TREE_TYPE (context);
3861: tree match = value_member (type, CLASSTYPE_TAGS (ctype));
3862: if (match)
3863: return TREE_VALUE (match);
3864: context = DECL_CONTEXT (context);
3865:
3866: /* When we have a nested class whose member functions have
3867: local types (e.g., a set of enums), we'll arrive here
3868: with the DECL_CONTEXT as the actual RECORD_TYPE node for
3869: the enclosing class. Instead, we want to make sure we
3870: come back in here with the TYPE_DECL, not the RECORD_TYPE. */
3871: if (context && TREE_CODE (context) == RECORD_TYPE)
3872: context = TREE_CHAIN (context);
3873: }
3874: break;
3875: case FUNCTION_DECL:
3876: return TYPE_IDENTIFIER (type) ?
3877: lookup_name (TYPE_IDENTIFIER (type), 1) : NULL_TREE;
3878: break;
3879: default:
3880: my_friendly_abort (12);
3881: }
3882: }
3883: return NULL_TREE;
3884: }
3885:
3886: /* Look up NAME in the current binding level and its superiors in the
3887: namespace of variables, functions and typedefs. Return a ..._DECL
3888: node of some kind representing its definition if there is only one
3889: such declaration, or return a TREE_LIST with all the overloaded
3890: definitions if there are many, or return 0 if it is undefined.
3891:
3892: If PREFER_TYPE is > 0, we prefer TYPE_DECLs.
3893: If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
3894: Otherwise we prefer non-TYPE_DECLs. */
3895:
3896: tree
3897: lookup_name_real (name, prefer_type, nonclass)
3898: tree name;
3899: int prefer_type, nonclass;
3900: {
3901: register tree val;
3902: int yylex = 0;
3903:
3904: if (prefer_type == -2)
3905: {
3906: extern int looking_for_typename;
3907:
3908: yylex = 1;
3909: prefer_type = looking_for_typename;
3910:
3911: if (got_scope != NULL_TREE)
3912: {
3913: if (got_scope == error_mark_node)
3914: return error_mark_node;
3915: else if (got_scope == void_type_node)
3916: val = IDENTIFIER_GLOBAL_VALUE (name);
3917: else if (TREE_CODE (got_scope) == TEMPLATE_TYPE_PARM
3918: /* TFIXME -- don't do this for UPTs in new model. */
3919: || TREE_CODE (got_scope) == UNINSTANTIATED_P_TYPE)
3920: {
3921: if (prefer_type > 0)
3922: val = create_nested_upt (got_scope, name);
3923: else
3924: val = NULL_TREE;
3925: }
3926: else if (! IS_AGGR_TYPE (got_scope))
3927: /* Someone else will give an error about this if needed. */
3928: val = NULL_TREE;
3929: else if (TYPE_BEING_DEFINED (got_scope))
3930: {
3931: val = IDENTIFIER_CLASS_VALUE (name);
3932: if (val && DECL_CONTEXT (val) != got_scope)
3933: {
3934: struct binding_level *b = class_binding_level;
3935: for (val = NULL_TREE; b; b = b->level_chain)
3936: {
3937: tree t = purpose_member (name, b->class_shadowed);
3938: if (t && TREE_VALUE (t)
3939: && DECL_CONTEXT (TREE_VALUE (t)) == got_scope)
3940: {
3941: val = TREE_VALUE (t);
3942: break;
3943: }
3944: }
3945: }
3946: if (val == NULL_TREE
3947: && CLASSTYPE_LOCAL_TYPEDECLS (got_scope))
3948: val = lookup_field (got_scope, name, 0, 1);
3949: }
3950: else if (got_scope == current_class_type)
3951: val = IDENTIFIER_CLASS_VALUE (name);
3952: else
3953: val = lookup_field (got_scope, name, 0, 0);
3954:
3955: goto done;
3956: }
3957: }
3958:
3959: if (current_binding_level != global_binding_level
3960: && IDENTIFIER_LOCAL_VALUE (name))
3961: val = IDENTIFIER_LOCAL_VALUE (name);
3962: /* In C++ class fields are between local and global scope,
3963: just before the global scope. */
3964: else if (current_class_type && ! nonclass)
3965: {
3966: val = IDENTIFIER_CLASS_VALUE (name);
3967: if (val == NULL_TREE
3968: && TYPE_BEING_DEFINED (current_class_type)
3969: && CLASSTYPE_LOCAL_TYPEDECLS (current_class_type))
3970: /* Try to find values from base classes if we are presently
3971: defining a type. We are presently only interested in
3972: TYPE_DECLs. */
3973: val = lookup_field (current_class_type, name, 0, 1);
3974:
3975: /* yylex() calls this with -2, since we should never start digging for
3976: the nested name at the point where we haven't even, for example,
3977: created the COMPONENT_REF or anything like that. */
3978: if (val == NULL_TREE)
3979: val = lookup_nested_field (name, ! yylex);
3980:
3981: if (val == NULL_TREE)
3982: val = IDENTIFIER_GLOBAL_VALUE (name);
3983: }
3984: else
3985: val = IDENTIFIER_GLOBAL_VALUE (name);
3986:
3987: done:
3988: if (val)
3989: {
3990: if ((TREE_CODE (val) == TEMPLATE_DECL && looking_for_template)
3991: || TREE_CODE (val) == TYPE_DECL || prefer_type <= 0)
3992: return val;
3993:
3994: if (IDENTIFIER_HAS_TYPE_VALUE (name))
3995: return TYPE_NAME (IDENTIFIER_TYPE_VALUE (name));
3996:
3997: if (TREE_TYPE (val) == error_mark_node)
3998: return error_mark_node;
3999: }
4000:
4001: return val;
4002: }
4003:
4004: tree
4005: lookup_name_nonclass (name)
4006: tree name;
4007: {
4008: return lookup_name_real (name, 0, 1);
4009: }
4010:
4011: tree
4012: lookup_name (name, prefer_type)
4013: tree name;
4014: int prefer_type;
4015: {
4016: return lookup_name_real (name, prefer_type, 0);
4017: }
4018:
4019: /* Similar to `lookup_name' but look only at current binding level. */
4020:
4021: tree
4022: lookup_name_current_level (name)
4023: tree name;
4024: {
4025: register tree t = NULL_TREE;
4026:
4027: if (current_binding_level == global_binding_level)
4028: {
4029: t = IDENTIFIER_GLOBAL_VALUE (name);
4030:
4031: /* extern "C" function() */
4032: if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4033: t = TREE_VALUE (t);
4034: }
4035: else if (IDENTIFIER_LOCAL_VALUE (name) != NULL_TREE)
4036: {
4037: struct binding_level *b = current_binding_level;
4038: while (1)
4039: {
4040: for (t = b->names; t; t = TREE_CHAIN (t))
4041: if (DECL_NAME (t) == name)
4042: goto out;
4043: if (b->keep == 2)
4044: b = b->level_chain;
4045: else
4046: break;
4047: }
4048: out:
4049: ;
4050: }
4051:
4052: return t;
4053: }
4054:
4055: /* Arrange for the user to get a source line number, even when the
4056: compiler is going down in flames, so that she at least has a
4057: chance of working around problems in the compiler. We used to
4058: call error(), but that let the segmentation fault continue
4059: through; now, it's much more passive by asking them to send the
4060: maintainers mail about the problem. */
4061:
4062: static void
4063: signal_catch (sig)
4064: int sig;
4065: {
4066: signal (SIGSEGV, SIG_DFL);
4067: #ifdef SIGIOT
4068: signal (SIGIOT, SIG_DFL);
4069: #endif
4070: #ifdef SIGILL
4071: signal (SIGILL, SIG_DFL);
4072: #endif
4073: #ifdef SIGABRT
4074: signal (SIGABRT, SIG_DFL);
4075: #endif
4076: #ifdef SIGBUS
4077: signal (SIGBUS, SIG_DFL);
4078: #endif
4079: my_friendly_abort (0);
4080: }
4081:
4082: /* Array for holding types considered "built-in". These types
4083: are output in the module in which `main' is defined. */
4084: static tree *builtin_type_tdescs_arr;
4085: static int builtin_type_tdescs_len, builtin_type_tdescs_max;
4086:
4087: /* Push the declarations of builtin types into the namespace.
4088: RID_INDEX, if < RID_MAX is the index of the builtin type
4089: in the array RID_POINTERS. NAME is the name used when looking
4090: up the builtin type. TYPE is the _TYPE node for the builtin type. */
4091:
4092: static void
4093: record_builtin_type (rid_index, name, type)
4094: enum rid rid_index;
4095: char *name;
4096: tree type;
4097: {
4098: tree rname = NULL_TREE, tname = NULL_TREE;
4099: tree tdecl;
4100:
4101: if ((int) rid_index < (int) RID_MAX)
4102: rname = ridpointers[(int) rid_index];
4103: if (name)
4104: tname = get_identifier (name);
4105:
4106: TYPE_BUILT_IN (type) = 1;
4107:
4108: if (tname)
4109: {
4110: #if 0 /* not yet, should get fixed properly later */
4111: tdecl = pushdecl (make_type_decl (tname, type));
4112: #else
4113: tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
4114: #endif
4115: set_identifier_type_value (tname, NULL_TREE);
4116: if ((int) rid_index < (int) RID_MAX)
4117: IDENTIFIER_GLOBAL_VALUE (tname) = tdecl;
4118: }
4119: if (rname != NULL_TREE)
4120: {
4121: if (tname != NULL_TREE)
4122: {
4123: set_identifier_type_value (rname, NULL_TREE);
4124: IDENTIFIER_GLOBAL_VALUE (rname) = tdecl;
4125: }
4126: else
4127: {
4128: #if 0 /* not yet, should get fixed properly later */
4129: tdecl = pushdecl (make_type_decl (rname, type));
4130: #else
4131: tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
4132: #endif
4133: set_identifier_type_value (rname, NULL_TREE);
4134: }
4135: }
4136:
4137: if (flag_dossier)
4138: {
4139: if (builtin_type_tdescs_len+5 >= builtin_type_tdescs_max)
4140: {
4141: builtin_type_tdescs_max *= 2;
4142: builtin_type_tdescs_arr
4143: = (tree *)xrealloc (builtin_type_tdescs_arr,
4144: builtin_type_tdescs_max * sizeof (tree));
4145: }
4146: builtin_type_tdescs_arr[builtin_type_tdescs_len++] = type;
4147: if (TREE_CODE (type) != POINTER_TYPE)
4148: {
4149: builtin_type_tdescs_arr[builtin_type_tdescs_len++]
4150: = build_pointer_type (type);
4151: builtin_type_tdescs_arr[builtin_type_tdescs_len++]
4152: = build_pointer_type (build_type_variant (type, 1, 0));
4153: }
4154: if (TREE_CODE (type) != VOID_TYPE)
4155: {
4156: builtin_type_tdescs_arr[builtin_type_tdescs_len++]
4157: = build_reference_type (type);
4158: builtin_type_tdescs_arr[builtin_type_tdescs_len++]
4159: = build_reference_type (build_type_variant (type, 1, 0));
4160: }
4161: }
4162: }
4163:
4164: static void
4165: output_builtin_tdesc_entries ()
4166: {
4167: extern struct obstack permanent_obstack;
4168:
4169: /* If there's more than one main in this file, don't crash. */
4170: if (builtin_type_tdescs_arr == 0)
4171: return;
4172:
4173: push_obstacks (&permanent_obstack, &permanent_obstack);
4174: while (builtin_type_tdescs_len > 0)
4175: {
4176: tree type = builtin_type_tdescs_arr[--builtin_type_tdescs_len];
4177: tree tdesc = build_t_desc (type, 0);
4178: TREE_ASM_WRITTEN (tdesc) = 0;
4179: build_t_desc (type, 2);
4180: }
4181: free (builtin_type_tdescs_arr);
4182: builtin_type_tdescs_arr = 0;
4183: pop_obstacks ();
4184: }
4185:
4186: /* Push overloaded decl, in global scope, with one argument so it
4187: can be used as a callback from define_function. */
4188: static void
4189: push_overloaded_decl_1 (x)
4190: tree x;
4191: {
4192: push_overloaded_decl (x, 0);
4193: }
4194:
4195: /* Create the predefined scalar types of C,
4196: and some nodes representing standard constants (0, 1, (void *)0).
4197: Initialize the global binding level.
4198: Make definitions for built-in primitive functions. */
4199:
4200: void
4201: init_decl_processing ()
4202: {
4203: tree decl;
4204: register tree endlink, int_endlink, double_endlink, ptr_endlink;
4205: tree fields[20];
4206: /* Either char* or void*. */
4207: tree traditional_ptr_type_node;
4208: /* Data type of memcpy. */
4209: tree memcpy_ftype;
4210: #if 0 /* Not yet. */
4211: /* Data type of strncpy. */
4212: tree strncpy_ftype;
4213: #endif
4214: int wchar_type_size;
4215: tree temp;
4216: tree array_domain_type;
4217:
4218: /* Have to make these distinct before we try using them. */
4219: lang_name_cplusplus = get_identifier ("C++");
4220: lang_name_c = get_identifier ("C");
4221:
4222: if (flag_ansi || pedantic)
4223: strict_prototypes_lang_c = strict_prototypes_lang_cplusplus;
4224:
4225: /* Initially, C. */
4226: current_lang_name = lang_name_c;
4227:
4228: current_function_decl = NULL_TREE;
4229: named_labels = NULL_TREE;
4230: named_label_uses = NULL_TREE;
4231: current_binding_level = NULL_BINDING_LEVEL;
4232: free_binding_level = NULL_BINDING_LEVEL;
4233:
4234: /* Because most segmentation signals can be traced back into user
4235: code, catch them and at least give the user a chance of working
4236: around compiler bugs. */
4237: signal (SIGSEGV, signal_catch);
4238:
4239: /* We will also catch aborts in the back-end through signal_catch and
4240: give the user a chance to see where the error might be, and to defeat
4241: aborts in the back-end when there have been errors previously in their
4242: code. */
4243: #ifdef SIGIOT
4244: signal (SIGIOT, signal_catch);
4245: #endif
4246: #ifdef SIGILL
4247: signal (SIGILL, signal_catch);
4248: #endif
4249: #ifdef SIGABRT
4250: signal (SIGABRT, signal_catch);
4251: #endif
4252: #ifdef SIGBUS
4253: signal (SIGBUS, signal_catch);
4254: #endif
4255:
4256: gcc_obstack_init (&decl_obstack);
4257: if (flag_dossier)
4258: {
4259: builtin_type_tdescs_max = 100;
4260: builtin_type_tdescs_arr = (tree *)xmalloc (100 * sizeof (tree));
4261: }
4262:
4263: /* Must lay these out before anything else gets laid out. */
4264: error_mark_node = make_node (ERROR_MARK);
4265: TREE_PERMANENT (error_mark_node) = 1;
4266: TREE_TYPE (error_mark_node) = error_mark_node;
4267: error_mark_list = build_tree_list (error_mark_node, error_mark_node);
4268: TREE_TYPE (error_mark_list) = error_mark_node;
4269:
4270: /* Make the binding_level structure for global names. */
4271: pushlevel (0);
4272: global_binding_level = current_binding_level;
4273:
4274: this_identifier = get_identifier (THIS_NAME);
4275: in_charge_identifier = get_identifier (IN_CHARGE_NAME);
4276: pfn_identifier = get_identifier (VTABLE_PFN_NAME);
4277: index_identifier = get_identifier (VTABLE_INDEX_NAME);
4278: delta_identifier = get_identifier (VTABLE_DELTA_NAME);
4279: delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
4280: pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
4281:
4282: /* Define `int' and `char' first so that dbx will output them first. */
4283:
4284: integer_type_node = make_signed_type (INT_TYPE_SIZE);
4285: record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
4286:
4287: /* Define `char', which is like either `signed char' or `unsigned char'
4288: but not the same as either. */
4289:
4290: char_type_node =
4291: (flag_signed_char
4292: ? make_signed_type (CHAR_TYPE_SIZE)
4293: : make_unsigned_type (CHAR_TYPE_SIZE));
4294: record_builtin_type (RID_CHAR, "char", char_type_node);
4295:
4296: long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
4297: record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4298:
4299: unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
4300: record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4301:
4302: long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
4303: record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
4304: record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4305:
4306: long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
4307: record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
4308:
4309: long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
4310: record_builtin_type (RID_MAX, "long long unsigned int",
4311: long_long_unsigned_type_node);
4312: record_builtin_type (RID_MAX, "long long unsigned",
4313: long_long_unsigned_type_node);
4314:
4315: /* `unsigned long' is the standard type for sizeof.
4316: Traditionally, use a signed type.
4317: Note that stddef.h uses `unsigned long',
4318: and this must agree, even of long and int are the same size. */
4319: sizetype
4320: = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
4321: if (flag_traditional && TREE_UNSIGNED (sizetype))
4322: sizetype = signed_type (sizetype);
4323:
4324: ptrdiff_type_node
4325: = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
4326:
4327: TREE_TYPE (TYPE_SIZE (integer_type_node)) = sizetype;
4328: TREE_TYPE (TYPE_SIZE (char_type_node)) = sizetype;
4329: TREE_TYPE (TYPE_SIZE (unsigned_type_node)) = sizetype;
4330: TREE_TYPE (TYPE_SIZE (long_unsigned_type_node)) = sizetype;
4331: TREE_TYPE (TYPE_SIZE (long_integer_type_node)) = sizetype;
4332: TREE_TYPE (TYPE_SIZE (long_long_integer_type_node)) = sizetype;
4333: TREE_TYPE (TYPE_SIZE (long_long_unsigned_type_node)) = sizetype;
4334:
4335: short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
4336: record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4337: short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
4338: record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
4339: record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
4340:
4341: /* Define both `signed char' and `unsigned char'. */
4342: signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
4343: record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4344: unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
4345: record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4346:
4347: /* These are types that type_for_size and type_for_mode use. */
4348: intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
4349: pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
4350: intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
4351: pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
4352: intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
4353: pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
4354: intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
4355: pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
4356: unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
4357: pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
4358: unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
4359: pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
4360: unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
4361: pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
4362: unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
4363: pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
4364:
4365: float_type_node = make_node (REAL_TYPE);
4366: TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
4367: record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
4368: layout_type (float_type_node);
4369:
4370: double_type_node = make_node (REAL_TYPE);
4371: if (flag_short_double)
4372: TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
4373: else
4374: TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
4375: record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
4376: layout_type (double_type_node);
4377:
4378: long_double_type_node = make_node (REAL_TYPE);
4379: TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
4380: record_builtin_type (RID_MAX, "long double", long_double_type_node);
4381: layout_type (long_double_type_node);
4382:
4383: integer_zero_node = build_int_2 (0, 0);
4384: TREE_TYPE (integer_zero_node) = integer_type_node;
4385: integer_one_node = build_int_2 (1, 0);
4386: TREE_TYPE (integer_one_node) = integer_type_node;
4387: integer_two_node = build_int_2 (2, 0);
4388: TREE_TYPE (integer_two_node) = integer_type_node;
4389: integer_three_node = build_int_2 (3, 0);
4390: TREE_TYPE (integer_three_node) = integer_type_node;
4391:
4392: bool_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
4393: TREE_SET_CODE (bool_type_node, BOOLEAN_TYPE);
4394: record_builtin_type (RID_BOOL, "bool", bool_type_node);
4395: false_node = build_int_2 (0, 0);
4396: TREE_TYPE (false_node) = bool_type_node;
4397: true_node = build_int_2 (1, 0);
4398: TREE_TYPE (true_node) = bool_type_node;
4399:
4400: /* These are needed by stor-layout.c. */
4401: size_zero_node = size_int (0);
4402: size_one_node = size_int (1);
4403:
4404: void_type_node = make_node (VOID_TYPE);
4405: record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
4406: layout_type (void_type_node); /* Uses integer_zero_node. */
4407: void_list_node = build_tree_list (NULL_TREE, void_type_node);
4408: TREE_PARMLIST (void_list_node) = 1;
4409:
4410: null_pointer_node = build_int_2 (0, 0);
4411: TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
4412: layout_type (TREE_TYPE (null_pointer_node));
4413:
4414: /* Used for expressions that do nothing, but are not errors. */
4415: void_zero_node = build_int_2 (0, 0);
4416: TREE_TYPE (void_zero_node) = void_type_node;
4417:
4418: string_type_node = build_pointer_type (char_type_node);
4419: const_string_type_node =
4420: build_pointer_type (build_type_variant (char_type_node, 1, 0));
4421: record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
4422:
4423: /* Make a type to be the domain of a few array types
4424: whose domains don't really matter.
4425: 200 is small enough that it always fits in size_t
4426: and large enough that it can hold most function names for the
4427: initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4428: array_domain_type = build_index_type (build_int_2 (200, 0));
4429:
4430: /* make a type for arrays of characters.
4431: With luck nothing will ever really depend on the length of this
4432: array type. */
4433: char_array_type_node
4434: = build_array_type (char_type_node, array_domain_type);
4435: /* Likewise for arrays of ints. */
4436: int_array_type_node
4437: = build_array_type (integer_type_node, array_domain_type);
4438:
4439: /* This is just some anonymous class type. Nobody should ever
4440: need to look inside this envelope. */
4441: class_star_type_node = build_pointer_type (make_lang_type (RECORD_TYPE));
4442:
4443: default_function_type
4444: = build_function_type (integer_type_node, NULL_TREE);
4445: build_pointer_type (default_function_type);
4446:
4447: ptr_type_node = build_pointer_type (void_type_node);
4448: const_ptr_type_node =
4449: build_pointer_type (build_type_variant (void_type_node, 1, 0));
4450: record_builtin_type (RID_MAX, NULL_PTR, ptr_type_node);
4451: endlink = void_list_node;
4452: int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
4453: double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
4454: ptr_endlink = tree_cons (NULL_TREE, ptr_type_node, endlink);
4455:
4456: double_ftype_double
4457: = build_function_type (double_type_node, double_endlink);
4458:
4459: double_ftype_double_double
4460: = build_function_type (double_type_node,
4461: tree_cons (NULL_TREE, double_type_node,
4462: double_endlink));
4463:
4464: int_ftype_int
4465: = build_function_type (integer_type_node, int_endlink);
4466:
4467: long_ftype_long
4468: = build_function_type (long_integer_type_node,
4469: tree_cons (NULL_TREE, long_integer_type_node,
4470: endlink));
4471:
4472: void_ftype_ptr_ptr_int
4473: = build_function_type (void_type_node,
4474: tree_cons (NULL_TREE, ptr_type_node,
4475: tree_cons (NULL_TREE, ptr_type_node,
4476: int_endlink)));
4477:
4478: int_ftype_cptr_cptr_sizet
4479: = build_function_type (integer_type_node,
4480: tree_cons (NULL_TREE, const_ptr_type_node,
4481: tree_cons (NULL_TREE, const_ptr_type_node,
4482: tree_cons (NULL_TREE,
4483: sizetype,
4484: endlink))));
4485:
4486: void_ftype_ptr_int_int
4487: = build_function_type (void_type_node,
4488: tree_cons (NULL_TREE, ptr_type_node,
4489: tree_cons (NULL_TREE, integer_type_node,
4490: int_endlink)));
4491:
4492: string_ftype_ptr_ptr /* strcpy prototype */
4493: = build_function_type (string_type_node,
4494: tree_cons (NULL_TREE, string_type_node,
4495: tree_cons (NULL_TREE,
4496: const_string_type_node,
4497: endlink)));
4498:
4499: #if 0
4500: /* Not yet. */
4501: strncpy_ftype /* strncpy prototype */
4502: = build_function_type (string_type_node,
4503: tree_cons (NULL_TREE, string_type_node,
4504: tree_cons (NULL_TREE, const_string_type_node,
4505: tree_cons (NULL_TREE,
4506: sizetype,
4507: endlink))));
4508: #endif
4509:
4510: int_ftype_string_string /* strcmp prototype */
4511: = build_function_type (integer_type_node,
4512: tree_cons (NULL_TREE, const_string_type_node,
4513: tree_cons (NULL_TREE,
4514: const_string_type_node,
4515: endlink)));
4516:
4517: sizet_ftype_string /* strlen prototype */
4518: = build_function_type (sizetype,
4519: tree_cons (NULL_TREE, const_string_type_node,
4520: endlink));
4521:
4522: traditional_ptr_type_node
4523: = (flag_traditional ? string_type_node : ptr_type_node);
4524:
4525: memcpy_ftype /* memcpy prototype */
4526: = build_function_type (traditional_ptr_type_node,
4527: tree_cons (NULL_TREE, ptr_type_node,
4528: tree_cons (NULL_TREE, const_ptr_type_node,
4529: tree_cons (NULL_TREE,
4530: sizetype,
4531: endlink))));
4532:
4533: if (flag_huge_objects)
4534: delta_type_node = long_integer_type_node;
4535: else
4536: delta_type_node = short_integer_type_node;
4537:
4538: builtin_function ("__builtin_constant_p", int_ftype_int,
4539: BUILT_IN_CONSTANT_P, NULL_PTR);
4540:
4541: builtin_return_address_fndecl =
4542: builtin_function ("__builtin_return_address",
4543: build_function_type (ptr_type_node,
4544: tree_cons (NULL_TREE,
4545: unsigned_type_node,
4546: endlink)),
4547: BUILT_IN_RETURN_ADDRESS, NULL_PTR);
4548:
4549: builtin_function ("__builtin_frame_address",
4550: build_function_type (ptr_type_node,
4551: tree_cons (NULL_TREE,
4552: unsigned_type_node,
4553: endlink)),
4554: BUILT_IN_FRAME_ADDRESS, NULL_PTR);
4555:
4556:
4557: builtin_function ("__builtin_alloca",
4558: build_function_type (ptr_type_node,
4559: tree_cons (NULL_TREE,
4560: sizetype,
4561: endlink)),
4562: BUILT_IN_ALLOCA, "alloca");
4563: /* Define alloca, ffs as builtins.
4564: Declare _exit just to mark it as volatile. */
4565: if (! flag_no_builtin && !flag_no_nonansi_builtin)
4566: {
4567: temp = builtin_function ("alloca",
4568: build_function_type (ptr_type_node,
4569: tree_cons (NULL_TREE,
4570: sizetype,
4571: endlink)),
4572: BUILT_IN_ALLOCA, NULL_PTR);
4573: /* Suppress error if redefined as a non-function. */
4574: DECL_BUILT_IN_NONANSI (temp) = 1;
4575: temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
4576: /* Suppress error if redefined as a non-function. */
4577: DECL_BUILT_IN_NONANSI (temp) = 1;
4578: temp = builtin_function ("_exit", build_function_type (void_type_node,
4579: int_endlink),
4580: NOT_BUILT_IN, NULL_PTR);
4581: TREE_THIS_VOLATILE (temp) = 1;
4582: TREE_SIDE_EFFECTS (temp) = 1;
4583: /* Suppress error if redefined as a non-function. */
4584: DECL_BUILT_IN_NONANSI (temp) = 1;
4585: }
4586:
4587: builtin_function ("__builtin_abs", int_ftype_int,
4588: BUILT_IN_ABS, NULL_PTR);
4589: builtin_function ("__builtin_fabs", double_ftype_double,
4590: BUILT_IN_FABS, NULL_PTR);
4591: builtin_function ("__builtin_labs", long_ftype_long,
4592: BUILT_IN_LABS, NULL_PTR);
4593: builtin_function ("__builtin_ffs", int_ftype_int,
4594: BUILT_IN_FFS, NULL_PTR);
4595: builtin_function ("__builtin_fsqrt", double_ftype_double,
4596: BUILT_IN_FSQRT, NULL_PTR);
4597: builtin_function ("__builtin_sin", double_ftype_double,
4598: BUILT_IN_SIN, "sin");
4599: builtin_function ("__builtin_cos", double_ftype_double,
4600: BUILT_IN_COS, "cos");
4601: builtin_function ("__builtin_saveregs",
4602: build_function_type (ptr_type_node, NULL_TREE),
4603: BUILT_IN_SAVEREGS, NULL_PTR);
4604: /* EXPAND_BUILTIN_VARARGS is obsolete. */
4605: #if 0
4606: builtin_function ("__builtin_varargs",
4607: build_function_type (ptr_type_node,
4608: tree_cons (NULL_TREE,
4609: integer_type_node,
4610: endlink)),
4611: BUILT_IN_VARARGS, NULL_PTR);
4612: #endif
4613: builtin_function ("__builtin_classify_type", default_function_type,
4614: BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
4615: builtin_function ("__builtin_next_arg",
4616: build_function_type (ptr_type_node, NULL_TREE),
4617: BUILT_IN_NEXT_ARG, NULL_PTR);
4618: builtin_function ("__builtin_args_info",
4619: build_function_type (integer_type_node,
4620: tree_cons (NULL_TREE,
4621: integer_type_node,
4622: endlink)),
4623: BUILT_IN_ARGS_INFO, NULL_PTR);
4624:
4625: /* Untyped call and return. */
4626: builtin_function ("__builtin_apply_args",
4627: build_function_type (ptr_type_node, NULL_TREE),
4628: BUILT_IN_APPLY_ARGS, NULL_PTR);
4629:
4630: temp = tree_cons (NULL_TREE,
4631: build_pointer_type (build_function_type (void_type_node,
4632: NULL_TREE)),
4633: tree_cons (NULL_TREE,
4634: ptr_type_node,
4635: tree_cons (NULL_TREE,
4636: sizetype,
4637: endlink)));
4638: builtin_function ("__builtin_apply",
4639: build_function_type (ptr_type_node, temp),
4640: BUILT_IN_APPLY, NULL_PTR);
4641: builtin_function ("__builtin_return",
4642: build_function_type (void_type_node,
4643: tree_cons (NULL_TREE,
4644: ptr_type_node,
4645: endlink)),
4646: BUILT_IN_RETURN, NULL_PTR);
4647:
4648: /* Currently under experimentation. */
4649: builtin_function ("__builtin_memcpy", memcpy_ftype,
4650: BUILT_IN_MEMCPY, "memcpy");
4651: builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
4652: BUILT_IN_MEMCMP, "memcmp");
4653: builtin_function ("__builtin_strcmp", int_ftype_string_string,
4654: BUILT_IN_STRCMP, "strcmp");
4655: builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
4656: BUILT_IN_STRCPY, "strcpy");
4657: #if 0
4658: /* Not yet. */
4659: builtin_function ("__builtin_strncpy", strncpy_ftype,
4660: BUILT_IN_STRNCPY, "strncpy");
4661: #endif
4662: builtin_function ("__builtin_strlen", sizet_ftype_string,
4663: BUILT_IN_STRLEN, "strlen");
4664:
4665: if (!flag_no_builtin)
4666: {
4667: #if 0 /* These do not work well with libg++. */
4668: builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
4669: builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
4670: builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
4671: #endif
4672: builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
4673: builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
4674: NULL_PTR);
4675: builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP, NULL_PTR);
4676: builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
4677: NULL_PTR);
4678: #if 0
4679: /* Not yet. */
4680: builtin_function ("strncpy", strncpy_ftype, BUILT_IN_STRNCPY, NULL_PTR);
4681: #endif
4682: builtin_function ("strlen", sizet_ftype_string, BUILT_IN_STRLEN, NULL_PTR);
4683: builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
4684: builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
4685:
4686: /* Declare these functions volatile
4687: to avoid spurious "control drops through" warnings. */
4688: temp = builtin_function ("abort",
4689: build_function_type (void_type_node, endlink),
4690: NOT_BUILT_IN, NULL_PTR);
4691: TREE_THIS_VOLATILE (temp) = 1;
4692: TREE_SIDE_EFFECTS (temp) = 1;
4693: /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
4694: them... */
4695: DECL_BUILT_IN_NONANSI (temp) = 1;
4696: temp = builtin_function ("exit", build_function_type (void_type_node,
4697: int_endlink),
4698: NOT_BUILT_IN, NULL_PTR);
4699: TREE_THIS_VOLATILE (temp) = 1;
4700: TREE_SIDE_EFFECTS (temp) = 1;
4701: DECL_BUILT_IN_NONANSI (temp) = 1;
4702: }
4703:
4704: #if 0
4705: /* Support for these has not been written in either expand_builtin
4706: or build_function_call. */
4707: builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, 0);
4708: builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, 0);
4709: builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
4710: 0);
4711: builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL, 0);
4712: builtin_function ("__builtin_fmod", double_ftype_double_double,
4713: BUILT_IN_FMOD, 0);
4714: builtin_function ("__builtin_frem", double_ftype_double_double,
4715: BUILT_IN_FREM, 0);
4716: builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int, BUILT_IN_MEMSET,
4717: 0);
4718: builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
4719: 0);
4720: builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
4721: 0);
4722: #endif
4723:
4724: /* C++ extensions */
4725:
4726: unknown_type_node = make_node (UNKNOWN_TYPE);
4727: #if 0 /* not yet, should get fixed properly later */
4728: pushdecl (make_type_decl (get_identifier ("unknown type"),
4729: unknown_type_node));
4730: #else
4731: decl = pushdecl (build_decl (TYPE_DECL, get_identifier ("unknown type"),
4732: unknown_type_node));
4733: /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4734: DECL_IGNORED_P (decl) = 1;
4735: TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4736: #endif
4737: TYPE_SIZE (unknown_type_node) = TYPE_SIZE (void_type_node);
4738: TYPE_ALIGN (unknown_type_node) = 1;
4739: TYPE_MODE (unknown_type_node) = TYPE_MODE (void_type_node);
4740: /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4741: TREE_TYPE (unknown_type_node) = unknown_type_node;
4742: /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same result. */
4743: TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
4744: TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
4745:
4746: /* This is for handling opaque types in signatures. */
4747: opaque_type_node = copy_node (ptr_type_node);
4748: TYPE_MAIN_VARIANT (opaque_type_node) = opaque_type_node;
4749: record_builtin_type (RID_MAX, 0, opaque_type_node);
4750:
4751: /* This is special for C++ so functions can be overloaded. */
4752: wchar_type_node
4753: = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
4754: wchar_type_size = TYPE_PRECISION (wchar_type_node);
4755: signed_wchar_type_node = make_signed_type (wchar_type_size);
4756: unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
4757: wchar_type_node
4758: = TREE_UNSIGNED (wchar_type_node)
4759: ? unsigned_wchar_type_node
4760: : signed_wchar_type_node;
4761: record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
4762:
4763: /* Artificial declaration of wchar_t -- can be bashed */
4764: wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
4765: wchar_type_node);
4766: pushdecl (wchar_decl_node);
4767:
4768: /* This is for wide string constants. */
4769: wchar_array_type_node
4770: = build_array_type (wchar_type_node, array_domain_type);
4771:
4772: /* This is a hack that should go away when we deliver the
4773: real gc code. */
4774: if (flag_gc)
4775: {
4776: builtin_function ("__gc_main", default_function_type, NOT_BUILT_IN, 0);
4777: pushdecl (lookup_name (get_identifier ("__gc_main"), 0));
4778: }
4779:
4780: if (flag_vtable_thunks)
4781: {
4782: /* Make sure we get a unique function type, so we can give
4783: its pointer type a name. (This wins for gdb.) */
4784: tree vfunc_type = make_node (FUNCTION_TYPE);
4785: TREE_TYPE (vfunc_type) = integer_type_node;
4786: TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
4787: layout_type (vfunc_type);
4788:
4789: vtable_entry_type = build_pointer_type (vfunc_type);
4790: }
4791: else
4792: {
4793: vtable_entry_type = make_lang_type (RECORD_TYPE);
4794: fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
4795: delta_type_node);
4796: fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
4797: delta_type_node);
4798: fields[2] = build_lang_field_decl (FIELD_DECL, pfn_identifier,
4799: ptr_type_node);
4800: finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
4801: double_type_node);
4802:
4803: /* Make this part of an invisible union. */
4804: fields[3] = copy_node (fields[2]);
4805: TREE_TYPE (fields[3]) = delta_type_node;
4806: DECL_NAME (fields[3]) = delta2_identifier;
4807: DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
4808: DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
4809: TREE_UNSIGNED (fields[3]) = 0;
4810: TREE_CHAIN (fields[2]) = fields[3];
4811: vtable_entry_type = build_type_variant (vtable_entry_type, 1, 0);
4812: }
4813: record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
4814:
4815: vtbl_type_node
4816: = build_array_type (vtable_entry_type, NULL_TREE);
4817: layout_type (vtbl_type_node);
4818: vtbl_type_node = cp_build_type_variant (vtbl_type_node, 1, 0);
4819: record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
4820:
4821: /* Simplify life by making a "sigtable_entry_type". Give its
4822: fields names so that the debugger can use them. */
4823:
4824: if (flag_handle_signatures)
4825: {
4826: sigtable_entry_type = make_lang_type (RECORD_TYPE);
4827: fields[0] = build_lang_field_decl (FIELD_DECL,
4828: get_identifier (SIGTABLE_CODE_NAME),
4829: short_integer_type_node);
4830: fields[1] = build_lang_field_decl (FIELD_DECL,
4831: get_identifier (SIGTABLE_OFFSET_NAME),
4832: short_integer_type_node);
4833: fields[2] = build_lang_field_decl (FIELD_DECL,
4834: get_identifier (SIGTABLE_PFN_NAME),
4835: ptr_type_node);
4836: finish_builtin_type (sigtable_entry_type, SIGTABLE_PTR_TYPE, fields, 2,
4837: double_type_node);
4838: sigtable_entry_type = build_type_variant (sigtable_entry_type, 1, 0);
4839: record_builtin_type (RID_MAX, SIGTABLE_PTR_TYPE, sigtable_entry_type);
4840: }
4841:
4842: if (flag_dossier)
4843: {
4844: /* Must build __t_desc type. Currently, type descriptors look like this:
4845:
4846: struct __t_desc
4847: {
4848: const char *name;
4849: int size;
4850: int bits;
4851: struct __t_desc *points_to;
4852: int ivars_count, meths_count;
4853: struct __i_desc *ivars[];
4854: struct __m_desc *meths[];
4855: struct __t_desc *parents[];
4856: struct __t_desc *vbases[];
4857: int offsets[];
4858: };
4859:
4860: ...as per Linton's paper. */
4861:
4862: __t_desc_type_node = make_lang_type (RECORD_TYPE);
4863: __i_desc_type_node = make_lang_type (RECORD_TYPE);
4864: __m_desc_type_node = make_lang_type (RECORD_TYPE);
4865: __t_desc_array_type =
4866: build_array_type (TYPE_POINTER_TO (__t_desc_type_node), NULL_TREE);
4867: __i_desc_array_type =
4868: build_array_type (TYPE_POINTER_TO (__i_desc_type_node), NULL_TREE);
4869: __m_desc_array_type =
4870: build_array_type (TYPE_POINTER_TO (__m_desc_type_node), NULL_TREE);
4871:
4872: fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
4873: string_type_node);
4874: fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("size"),
4875: unsigned_type_node);
4876: fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("bits"),
4877: unsigned_type_node);
4878: fields[3] = build_lang_field_decl (FIELD_DECL,
4879: get_identifier ("points_to"),
4880: TYPE_POINTER_TO (__t_desc_type_node));
4881: fields[4] = build_lang_field_decl (FIELD_DECL,
4882: get_identifier ("ivars_count"),
4883: integer_type_node);
4884: fields[5] = build_lang_field_decl (FIELD_DECL,
4885: get_identifier ("meths_count"),
4886: integer_type_node);
4887: fields[6] = build_lang_field_decl (FIELD_DECL, get_identifier ("ivars"),
4888: build_pointer_type (__i_desc_array_type));
4889: fields[7] = build_lang_field_decl (FIELD_DECL, get_identifier ("meths"),
4890: build_pointer_type (__m_desc_array_type));
4891: fields[8] = build_lang_field_decl (FIELD_DECL, get_identifier ("parents"),
4892: build_pointer_type (__t_desc_array_type));
4893: fields[9] = build_lang_field_decl (FIELD_DECL, get_identifier ("vbases"),
4894: build_pointer_type (__t_desc_array_type));
4895: fields[10] = build_lang_field_decl (FIELD_DECL, get_identifier ("offsets"),
4896: build_pointer_type (integer_type_node));
4897: finish_builtin_type (__t_desc_type_node, "__t_desc", fields, 10, integer_type_node);
4898:
4899: /* ivar descriptors look like this:
4900:
4901: struct __i_desc
4902: {
4903: const char *name;
4904: int offset;
4905: struct __t_desc *type;
4906: };
4907: */
4908:
4909: fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
4910: string_type_node);
4911: fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("offset"),
4912: integer_type_node);
4913: fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("type"),
4914: TYPE_POINTER_TO (__t_desc_type_node));
4915: finish_builtin_type (__i_desc_type_node, "__i_desc", fields, 2,
4916: integer_type_node);
4917:
4918: /* method descriptors look like this:
4919:
4920: struct __m_desc
4921: {
4922: const char *name;
4923: int vindex;
4924: struct __t_desc *vcontext;
4925: struct __t_desc *return_type;
4926: void (*address)();
4927: short parm_count;
4928: short required_parms;
4929: struct __t_desc *parm_types[];
4930: };
4931: */
4932:
4933: fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
4934: string_type_node);
4935: fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("vindex"),
4936: integer_type_node);
4937: fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("vcontext"),
4938: TYPE_POINTER_TO (__t_desc_type_node));
4939: fields[3] = build_lang_field_decl (FIELD_DECL, get_identifier ("return_type"),
4940: TYPE_POINTER_TO (__t_desc_type_node));
4941: fields[4] = build_lang_field_decl (FIELD_DECL, get_identifier ("address"),
4942: build_pointer_type (default_function_type));
4943: fields[5] = build_lang_field_decl (FIELD_DECL, get_identifier ("parm_count"),
4944: short_integer_type_node);
4945: fields[6] = build_lang_field_decl (FIELD_DECL, get_identifier ("required_parms"),
4946: short_integer_type_node);
4947: fields[7] = build_lang_field_decl (FIELD_DECL, get_identifier ("parm_types"),
4948: build_pointer_type (build_array_type (TYPE_POINTER_TO (__t_desc_type_node), NULL_TREE)));
4949: finish_builtin_type (__m_desc_type_node, "__m_desc", fields, 7,
4950: integer_type_node);
4951: }
4952:
4953: /* Now, C++. */
4954: current_lang_name = lang_name_cplusplus;
4955: if (flag_dossier)
4956: {
4957: int i = builtin_type_tdescs_len;
4958: while (i > 0)
4959: {
4960: tree tdesc = build_t_desc (builtin_type_tdescs_arr[--i], 0);
4961: TREE_ASM_WRITTEN (tdesc) = 1;
4962: TREE_PUBLIC (TREE_OPERAND (tdesc, 0)) = 1;
4963: }
4964: }
4965:
4966: auto_function (ansi_opname[(int) NEW_EXPR],
4967: build_function_type (ptr_type_node,
4968: tree_cons (NULL_TREE, sizetype,
4969: void_list_node)),
4970: NOT_BUILT_IN);
4971: auto_function (ansi_opname[(int) VEC_NEW_EXPR],
4972: build_function_type (ptr_type_node,
4973: tree_cons (NULL_TREE, sizetype,
4974: void_list_node)),
4975: NOT_BUILT_IN);
4976: auto_function (ansi_opname[(int) DELETE_EXPR],
4977: build_function_type (void_type_node,
4978: tree_cons (NULL_TREE, ptr_type_node,
4979: void_list_node)),
4980: NOT_BUILT_IN);
4981: auto_function (ansi_opname[(int) VEC_DELETE_EXPR],
4982: build_function_type (void_type_node,
4983: tree_cons (NULL_TREE, ptr_type_node,
4984: void_list_node)),
4985: NOT_BUILT_IN);
4986:
4987: abort_fndecl
4988: = define_function ("__pure_virtual",
4989: build_function_type (void_type_node, void_list_node),
4990: NOT_BUILT_IN, 0, 0);
4991:
4992: /* Perform other language dependent initializations. */
4993: init_class_processing ();
4994: init_init_processing ();
4995: init_search_processing ();
4996:
4997: if (flag_handle_exceptions)
4998: init_exception_processing ();
4999: if (flag_gc)
5000: init_gc_processing ();
5001: if (flag_no_inline)
5002: {
5003: flag_inline_functions = 0;
5004: #if 0
5005: /* This causes uneccessary emission of inline functions. */
5006: flag_default_inline = 0;
5007: #endif
5008: }
5009: if (flag_cadillac)
5010: init_cadillac ();
5011:
5012: /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
5013: declare_function_name ();
5014:
5015: /* Prepare to check format strings against argument lists. */
5016: init_function_format_info ();
5017: }
5018:
5019: /* Make a definition for a builtin function named NAME and whose data type
5020: is TYPE. TYPE should be a function type with argument types.
5021: FUNCTION_CODE tells later passes how to compile calls to this function.
5022: See tree.h for its possible values.
5023:
5024: If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
5025: the name to be called if we can't opencode the function. */
5026:
5027: tree
5028: define_function (name, type, function_code, pfn, library_name)
5029: char *name;
5030: tree type;
5031: enum built_in_function function_code;
5032: void (*pfn)();
5033: char *library_name;
5034: {
5035: tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
5036: DECL_EXTERNAL (decl) = 1;
5037: TREE_PUBLIC (decl) = 1;
5038:
5039: /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
5040: we cannot change DECL_ASSEMBLER_NAME until we have installed this
5041: function in the namespace. */
5042: if (pfn) (*pfn) (decl);
5043: if (library_name)
5044: DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
5045: make_function_rtl (decl);
5046: if (function_code != NOT_BUILT_IN)
5047: {
5048: DECL_BUILT_IN (decl) = 1;
5049: DECL_FUNCTION_CODE (decl) = function_code;
5050: }
5051: return decl;
5052: }
5053:
5054: /* Called when a declaration is seen that contains no names to declare.
5055: If its type is a reference to a structure, union or enum inherited
5056: from a containing scope, shadow that tag name for the current scope
5057: with a forward reference.
5058: If its type defines a new named structure or union
5059: or defines an enum, it is valid but we need not do anything here.
5060: Otherwise, it is an error.
5061:
5062: C++: may have to grok the declspecs to learn about static,
5063: complain for anonymous unions. */
5064:
5065: void
5066: shadow_tag (declspecs)
5067: tree declspecs;
5068: {
5069: int found_tag = 0;
5070: tree ob_modifier = NULL_TREE;
5071: register tree link;
5072: register enum tree_code code, ok_code = ERROR_MARK;
5073: register tree t = NULL_TREE;
5074:
5075: for (link = declspecs; link; link = TREE_CHAIN (link))
5076: {
5077: register tree value = TREE_VALUE (link);
5078:
5079: code = TREE_CODE (value);
5080: if (IS_AGGR_TYPE_CODE (code) || code == ENUMERAL_TYPE)
5081: {
5082: my_friendly_assert (TYPE_NAME (value) != NULL_TREE, 261);
5083:
5084: if (code == ENUMERAL_TYPE && TYPE_SIZE (value) == 0)
5085: cp_error ("forward declaration of `%#T'", value);
5086:
5087: t = value;
5088: ok_code = code;
5089: found_tag++;
5090: }
5091: else if (value == ridpointers[(int) RID_STATIC]
5092: || value == ridpointers[(int) RID_EXTERN]
5093: || value == ridpointers[(int) RID_AUTO]
5094: || value == ridpointers[(int) RID_REGISTER])
5095: ob_modifier = value;
5096: }
5097:
5098: /* This is where the variables in an anonymous union are
5099: declared. An anonymous union declaration looks like:
5100: union { ... } ;
5101: because there is no declarator after the union, the parser
5102: sends that declaration here. */
5103: if (ok_code == UNION_TYPE
5104: && t != NULL_TREE
5105: && ((TREE_CODE (TYPE_NAME (t)) == IDENTIFIER_NODE
5106: && ANON_AGGRNAME_P (TYPE_NAME (t)))
5107: || (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL
5108: && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))))
5109: {
5110: /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
5111: function members. */
5112: if (TYPE_FIELDS (t))
5113: {
5114: tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
5115: NULL_TREE);
5116: finish_anon_union (decl);
5117: }
5118: else
5119: error ("anonymous union cannot have a function member");
5120: }
5121: else
5122: {
5123: /* Anonymous unions are objects, that's why we only check for
5124: inappropriate specifiers in this branch. */
5125: if (ob_modifier)
5126: cp_error ("`%D' can only be specified for objects and functions",
5127: ob_modifier);
5128:
5129: if (found_tag == 0)
5130: pedwarn ("abstract declarator used as declaration");
5131: else if (found_tag > 1)
5132: pedwarn ("multiple types in one declaration");
5133: }
5134: }
5135:
5136: /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5137:
5138: tree
5139: groktypename (typename)
5140: tree typename;
5141: {
5142: if (TREE_CODE (typename) != TREE_LIST)
5143: return typename;
5144: return grokdeclarator (TREE_VALUE (typename),
5145: TREE_PURPOSE (typename),
5146: TYPENAME, 0, NULL_TREE);
5147: }
5148:
5149: /* Decode a declarator in an ordinary declaration or data definition.
5150: This is called as soon as the type information and variable name
5151: have been parsed, before parsing the initializer if any.
5152: Here we create the ..._DECL node, fill in its type,
5153: and put it on the list of decls for the current context.
5154: The ..._DECL node is returned as the value.
5155:
5156: Exception: for arrays where the length is not specified,
5157: the type is left null, to be filled in by `finish_decl'.
5158:
5159: Function definitions do not come here; they go to start_function
5160: instead. However, external and forward declarations of functions
5161: do go through here. Structure field declarations are done by
5162: grokfield and not through here. */
5163:
5164: /* Set this to zero to debug not using the temporary obstack
5165: to parse initializers. */
5166: int debug_temp_inits = 1;
5167:
5168: tree
5169: start_decl (declarator, declspecs, initialized, raises)
5170: tree declarator, declspecs;
5171: int initialized;
5172: tree raises;
5173: {
5174: register tree decl;
5175: register tree type, tem;
5176: tree context;
5177: extern int have_extern_spec;
5178: extern int used_extern_spec;
5179:
5180: int init_written = initialized;
5181:
5182: /* This should only be done once on the top most decl. */
5183: if (have_extern_spec && !used_extern_spec)
5184: {
5185: declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
5186: declspecs);
5187: used_extern_spec = 1;
5188: }
5189:
5190: decl = grokdeclarator (declarator, declspecs, NORMAL, initialized, raises);
5191: if (decl == NULL_TREE || decl == void_type_node)
5192: return NULL_TREE;
5193:
5194: type = TREE_TYPE (decl);
5195:
5196: /* Don't lose if destructors must be executed at file-level. */
5197: if (TREE_STATIC (decl)
5198: && TYPE_NEEDS_DESTRUCTOR (type)
5199: && !TREE_PERMANENT (decl))
5200: {
5201: push_obstacks (&permanent_obstack, &permanent_obstack);
5202: decl = copy_node (decl);
5203: if (TREE_CODE (type) == ARRAY_TYPE)
5204: {
5205: tree itype = TYPE_DOMAIN (type);
5206: if (itype && ! TREE_PERMANENT (itype))
5207: {
5208: itype = build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype)));
5209: type = build_cplus_array_type (TREE_TYPE (type), itype);
5210: TREE_TYPE (decl) = type;
5211: }
5212: }
5213: pop_obstacks ();
5214: }
5215:
5216: /* Interesting work for this is done in `finish_exception_decl'. */
5217: if (TREE_CODE (type) == RECORD_TYPE
5218: && CLASSTYPE_DECLARED_EXCEPTION (type))
5219: return decl;
5220:
5221: /* Corresponding pop_obstacks is done in `finish_decl'. */
5222: push_obstacks_nochange ();
5223:
5224: context
5225: = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
5226: ? DECL_CLASS_CONTEXT (decl)
5227: : DECL_CONTEXT (decl);
5228:
5229: if (processing_template_decl)
5230: {
5231: tree d;
5232: if (TREE_CODE (decl) == FUNCTION_DECL)
5233: {
5234: /* Declarator is a call_expr; extract arguments from it, since
5235: grokdeclarator didn't do it. */
5236: tree args;
5237: args = copy_to_permanent (last_function_parms);
5238: if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
5239: {
5240: tree t = TREE_TYPE (decl);
5241:
5242: t = TYPE_METHOD_BASETYPE (t); /* type method belongs to */
5243: if (TREE_CODE (t) != UNINSTANTIATED_P_TYPE)
5244: {
5245: t = build_pointer_type (t); /* base type of `this' */
5246: #if 1
5247: /* I suspect this is wrong. */
5248: t = build_type_variant (t, flag_this_is_variable <= 0,
5249: 0); /* type of `this' */
5250: #else
5251: t = build_type_variant (t, 0, 0); /* type of `this' */
5252: #endif
5253: t = build (PARM_DECL, t, this_identifier);
5254: TREE_CHAIN (t) = args;
5255: args = t;
5256: }
5257: }
5258: DECL_ARGUMENTS (decl) = args;
5259: }
5260: d = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), TREE_TYPE (decl));
5261: if (interface_unknown && flag_external_templates
5262: && ! DECL_IN_SYSTEM_HEADER (decl))
5263: warn_if_unknown_interface ();
5264: TREE_PUBLIC (d) = TREE_PUBLIC (decl);
5265: TREE_STATIC (d) = TREE_STATIC (decl);
5266: DECL_EXTERNAL (d) = (DECL_EXTERNAL (decl)
5267: && !(context && !DECL_THIS_EXTERN (decl)));
5268: DECL_TEMPLATE_RESULT (d) = decl;
5269: decl = d;
5270: }
5271:
5272: /* If this type of object needs a cleanup, and control may
5273: jump past it, make a new binding level so that it is cleaned
5274: up only when it is initialized first. */
5275: if (TYPE_NEEDS_DESTRUCTOR (type)
5276: && current_binding_level->more_cleanups_ok == 0)
5277: pushlevel_temporary (1);
5278:
5279: if (initialized)
5280: /* Is it valid for this decl to have an initializer at all?
5281: If not, set INITIALIZED to zero, which will indirectly
5282: tell `finish_decl' to ignore the initializer once it is parsed. */
5283: switch (TREE_CODE (decl))
5284: {
5285: case TYPE_DECL:
5286: /* typedef foo = bar means give foo the same type as bar.
5287: We haven't parsed bar yet, so `finish_decl' will fix that up.
5288: Any other case of an initialization in a TYPE_DECL is an error. */
5289: if (pedantic || list_length (declspecs) > 1)
5290: {
5291: cp_error ("typedef `%D' is initialized", decl);
5292: initialized = 0;
5293: }
5294: break;
5295:
5296: case FUNCTION_DECL:
5297: cp_error ("function `%#D' is initialized like a variable", decl);
5298: initialized = 0;
5299: break;
5300:
5301: default:
5302: /* Don't allow initializations for incomplete types except for
5303: arrays which might be completed by the initialization. */
5304: if (type == error_mark_node)
5305: ; /* Don't complain again. */
5306: else if (TYPE_SIZE (type) != NULL_TREE)
5307: ; /* A complete type is ok. */
5308: else if (TREE_CODE (type) != ARRAY_TYPE)
5309: {
5310: cp_error ("variable `%#D' has initializer but incomplete type",
5311: decl);
5312: initialized = 0;
5313: }
5314: else if (TYPE_SIZE (TREE_TYPE (type)) == NULL_TREE)
5315: {
5316: cp_error ("elements of array `%#D' have incomplete type", decl);
5317: initialized = 0;
5318: }
5319: }
5320:
5321: if (!initialized
5322: && TREE_CODE (decl) != TYPE_DECL
5323: && TREE_CODE (decl) != TEMPLATE_DECL
5324: && IS_AGGR_TYPE (type) && ! DECL_EXTERNAL (decl))
5325: {
5326: if (TYPE_SIZE (type) == NULL_TREE)
5327: {
5328: cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
5329: decl);
5330: /* Change the type so that assemble_variable will give
5331: DECL an rtl we can live with: (mem (const_int 0)). */
5332: TREE_TYPE (decl) = error_mark_node;
5333: type = error_mark_node;
5334: }
5335: else
5336: {
5337: /* If any base type in the hierarchy of TYPE needs a constructor,
5338: then we set initialized to 1. This way any nodes which are
5339: created for the purposes of initializing this aggregate
5340: will live as long as it does. This is necessary for global
5341: aggregates which do not have their initializers processed until
5342: the end of the file. */
5343: initialized = TYPE_NEEDS_CONSTRUCTING (type);
5344: }
5345: }
5346:
5347: if (initialized)
5348: {
5349: if (current_binding_level != global_binding_level
5350: && DECL_EXTERNAL (decl))
5351: cp_warning ("declaration of `%#D' has `extern' and is initialized",
5352: decl);
5353: DECL_EXTERNAL (decl) = 0;
5354: if (current_binding_level == global_binding_level)
5355: TREE_STATIC (decl) = 1;
5356:
5357: /* Tell `pushdecl' this is an initialized decl
5358: even though we don't yet have the initializer expression.
5359: Also tell `finish_decl' it may store the real initializer. */
5360: DECL_INITIAL (decl) = error_mark_node;
5361: }
5362:
5363: if (context && TYPE_SIZE (context) != NULL_TREE)
5364: {
5365: if (TREE_CODE (decl) == VAR_DECL)
5366: {
5367: tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
5368: if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
5369: cp_error ("`%#D' is not a static member of `%#T'", decl, context);
5370: else if (duplicate_decls (decl, field))
5371: decl = field;
5372: }
5373:
5374: /* If it was not explicitly declared `extern',
5375: revoke any previous claims of DECL_EXTERNAL. */
5376: if (DECL_THIS_EXTERN (decl) == 0)
5377: DECL_EXTERNAL (decl) = 0;
5378: if (DECL_LANG_SPECIFIC (decl))
5379: DECL_IN_AGGR_P (decl) = 0;
5380: pushclass (context, 2);
5381: }
5382:
5383: /* Add this decl to the current binding level, but not if it
5384: comes from another scope, e.g. a static member variable.
5385: TEM may equal DECL or it may be a previous decl of the same name. */
5386:
5387: if ((TREE_CODE (decl) != PARM_DECL && DECL_CONTEXT (decl) != NULL_TREE)
5388: || (TREE_CODE (decl) == TEMPLATE_DECL && !global_bindings_p ())
5389: || TREE_CODE (type) == LANG_TYPE)
5390: tem = decl;
5391: else
5392: tem = pushdecl (decl);
5393:
5394: /* Tell the back-end to use or not use .common as appropriate. If we say
5395: -fconserve-space, we want this to save space, at the expense of wrong
5396: semantics. If we say -fno-conserve-space, we want this to produce
5397: errors about redefs; to do this we force variables into the data
5398: segment. Common storage is okay for non-public uninitialized data;
5399: the linker can't match it with storage from other files, and we may
5400: save some disk space. */
5401: DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
5402:
5403: #if 0
5404: /* We don't do this yet for GNU C++. */
5405: /* For a local variable, define the RTL now. */
5406: if (current_binding_level != global_binding_level
5407: /* But not if this is a duplicate decl
5408: and we preserved the rtl from the previous one
5409: (which may or may not happen). */
5410: && DECL_RTL (tem) == NULL_RTX)
5411: {
5412: if (TYPE_SIZE (TREE_TYPE (tem)) != NULL_TREE)
5413: expand_decl (tem);
5414: else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
5415: && DECL_INITIAL (tem) != NULL_TREE)
5416: expand_decl (tem);
5417: }
5418: #endif
5419:
5420: if (TREE_CODE (decl) == TEMPLATE_DECL)
5421: {
5422: tree result = DECL_TEMPLATE_RESULT (decl);
5423: if (DECL_CONTEXT (result) != NULL_TREE)
5424: {
5425: tree type;
5426: type = DECL_CONTEXT (result);
5427:
5428: if (TREE_CODE (type) != UNINSTANTIATED_P_TYPE)
5429: {
5430: cp_error ("declaration of `%D' in non-template type `%T'",
5431: decl, type);
5432: return NULL_TREE;
5433: }
5434:
5435: if (TREE_CODE (result) == FUNCTION_DECL)
5436: return tem;
5437: else if (TREE_CODE (result) == VAR_DECL)
5438: {
5439: #if 0
5440: tree tmpl = UPT_TEMPLATE (type);
5441:
5442: fprintf (stderr, "%s:%d: adding ", __FILE__, __LINE__);
5443: print_node_brief (stderr, "", DECL_NAME (tem), 0);
5444: fprintf (stderr, " to class %s\n",
5445: IDENTIFIER_POINTER (DECL_NAME (tmpl)));
5446: DECL_TEMPLATE_MEMBERS (tmpl)
5447: = perm_tree_cons (DECL_NAME (tem), tem,
5448: DECL_TEMPLATE_MEMBERS (tmpl));
5449: return tem;
5450: #else
5451: sorry ("static data member templates");
5452: return NULL_TREE;
5453: #endif
5454: }
5455: else
5456: my_friendly_abort (13);
5457: }
5458: else if (TREE_CODE (result) == FUNCTION_DECL)
5459: /*tem = push_overloaded_decl (tem, 0)*/;
5460: else if (TREE_CODE (result) == VAR_DECL)
5461: {
5462: cp_error ("data template `%#D' must be member of a class template",
5463: result);
5464: return NULL_TREE;
5465: }
5466: else if (TREE_CODE (result) == TYPE_DECL)
5467: {
5468: cp_error ("invalid template `%#D'", result);
5469: return NULL_TREE;
5470: }
5471: else
5472: my_friendly_abort (14);
5473: }
5474:
5475: if (init_written
5476: && ! (TREE_CODE (tem) == PARM_DECL
5477: || (TREE_READONLY (tem)
5478: && (TREE_CODE (tem) == VAR_DECL
5479: || TREE_CODE (tem) == FIELD_DECL))))
5480: {
5481: /* When parsing and digesting the initializer,
5482: use temporary storage. Do this even if we will ignore the value. */
5483: if (current_binding_level == global_binding_level && debug_temp_inits)
5484: {
5485: if (TYPE_NEEDS_CONSTRUCTING (type)
5486: || TREE_CODE (type) == REFERENCE_TYPE)
5487: /* In this case, the initializer must lay down in permanent
5488: storage, since it will be saved until `finish_file' is run. */
5489: ;
5490: else
5491: temporary_allocation ();
5492: }
5493: }
5494:
5495: if (flag_cadillac)
5496: cadillac_start_decl (tem);
5497:
5498: return tem;
5499: }
5500:
5501: #if 0 /* unused */
5502: static void
5503: make_temporary_for_reference (decl, ctor_call, init, cleanupp)
5504: tree decl, ctor_call, init;
5505: tree *cleanupp;
5506: {
5507: tree type = TREE_TYPE (decl);
5508: tree target_type = TREE_TYPE (type);
5509: tree tmp, tmp_addr;
5510:
5511: if (ctor_call)
5512: {
5513: tmp_addr = TREE_VALUE (TREE_OPERAND (ctor_call, 1));
5514: if (TREE_CODE (tmp_addr) == NOP_EXPR)
5515: tmp_addr = TREE_OPERAND (tmp_addr, 0);
5516: my_friendly_assert (TREE_CODE (tmp_addr) == ADDR_EXPR, 146);
5517: tmp = TREE_OPERAND (tmp_addr, 0);
5518: }
5519: else
5520: {
5521: tmp = get_temp_name (target_type,
5522: current_binding_level == global_binding_level);
5523: tmp_addr = build_unary_op (ADDR_EXPR, tmp, 0);
5524: }
5525:
5526: TREE_TYPE (tmp_addr) = build_pointer_type (target_type);
5527: DECL_INITIAL (decl) = convert (TYPE_POINTER_TO (target_type), tmp_addr);
5528: TREE_TYPE (DECL_INITIAL (decl)) = type;
5529: if (TYPE_NEEDS_CONSTRUCTING (target_type))
5530: {
5531: if (current_binding_level == global_binding_level)
5532: {
5533: /* lay this variable out now. Otherwise `output_addressed_constants'
5534: gets confused by its initializer. */
5535: make_decl_rtl (tmp, NULL_PTR, 1);
5536: static_aggregates = perm_tree_cons (init, tmp, static_aggregates);
5537: }
5538: else
5539: {
5540: if (ctor_call != NULL_TREE)
5541: init = ctor_call;
5542: else
5543: init = build_method_call (tmp, constructor_name_full (target_type),
5544: build_tree_list (NULL_TREE, init),
5545: NULL_TREE, LOOKUP_NORMAL);
5546: DECL_INITIAL (decl) = build (COMPOUND_EXPR, type, init,
5547: DECL_INITIAL (decl));
5548: *cleanupp = maybe_build_cleanup (tmp);
5549: }
5550: }
5551: else
5552: {
5553: DECL_INITIAL (tmp) = init;
5554: TREE_STATIC (tmp) = current_binding_level == global_binding_level;
5555: finish_decl (tmp, init, 0, 0);
5556: }
5557: if (TREE_STATIC (tmp))
5558: preserve_initializer ();
5559: }
5560: #endif
5561:
5562: /* Handle initialization of references.
5563: These three arguments from from `finish_decl', and have the
5564: same meaning here that they do there. */
5565: /* quotes on semantics can be found in ARM 8.4.3. */
5566: static void
5567: grok_reference_init (decl, type, init, cleanupp)
5568: tree decl, type, init;
5569: tree *cleanupp;
5570: {
5571: tree tmp;
5572:
5573: if (init == NULL_TREE)
5574: {
5575: if (DECL_LANG_SPECIFIC (decl) == 0
5576: || DECL_IN_AGGR_P (decl) == 0)
5577: {
5578: cp_error ("`%D' declared as reference but not initialized", decl);
5579: if (TREE_CODE (decl) == VAR_DECL)
5580: SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
5581: }
5582: return;
5583: }
5584:
5585: if (init == error_mark_node)
5586: return;
5587:
5588: if (TREE_CODE (type) == REFERENCE_TYPE
5589: && TREE_CODE (init) == CONSTRUCTOR)
5590: {
5591: cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
5592: return;
5593: }
5594:
5595: if (TREE_CODE (init) == TREE_LIST)
5596: init = build_compound_expr (init);
5597:
5598: if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
5599: && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
5600: {
5601: /* Note: default conversion is only called in very special cases. */
5602: init = default_conversion (init);
5603: }
5604:
5605: tmp = convert_to_reference
5606: (type, init, CONV_IMPLICIT, LOOKUP_SPECULATIVELY|LOOKUP_NORMAL, decl);
5607:
5608: if (tmp == error_mark_node)
5609: goto fail;
5610: else if (tmp != NULL_TREE)
5611: {
5612: tree subtype = TREE_TYPE (type);
5613: init = tmp;
5614:
5615: /* Associate the cleanup with the reference so that we
5616: don't get burned by "aggressive" cleanup policy. */
5617: if (TYPE_NEEDS_DESTRUCTOR (subtype))
5618: {
5619: if (TREE_CODE (init) == WITH_CLEANUP_EXPR)
5620: {
5621: *cleanupp = TREE_OPERAND (init, 2);
5622: TREE_OPERAND (init, 2) = error_mark_node;
5623: }
5624: else
5625: {
5626: if (TREE_CODE (tmp) == ADDR_EXPR)
5627: tmp = TREE_OPERAND (tmp, 0);
5628: if (TREE_CODE (tmp) == TARGET_EXPR)
5629: {
5630: *cleanupp = build_delete
5631: (TYPE_POINTER_TO (subtype),
5632: build_unary_op (ADDR_EXPR, TREE_OPERAND (tmp, 0), 0),
5633: integer_two_node, LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
5634: TREE_OPERAND (tmp, 2) = error_mark_node;
5635: }
5636: }
5637: }
5638:
5639: DECL_INITIAL (decl) = save_expr (init);
5640: }
5641: else
5642: {
5643: cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
5644: goto fail;
5645: }
5646:
5647: /* ?? Can this be optimized in some cases to
5648: hand back the DECL_INITIAL slot?? */
5649: if (TYPE_SIZE (TREE_TYPE (type)))
5650: {
5651: init = convert_from_reference (decl);
5652: if (TREE_PERMANENT (decl))
5653: init = copy_to_permanent (init);
5654: SET_DECL_REFERENCE_SLOT (decl, init);
5655: }
5656:
5657: if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
5658: {
5659: expand_static_init (decl, DECL_INITIAL (decl));
5660: DECL_INITIAL (decl) = NULL_TREE;
5661: }
5662: return;
5663:
5664: fail:
5665: if (TREE_CODE (decl) == VAR_DECL)
5666: SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
5667: return;
5668: }
5669:
5670: /* Finish processing of a declaration;
5671: install its line number and initial value.
5672: If the length of an array type is not known before,
5673: it must be determined now, from the initial value, or it is an error.
5674:
5675: Call `pop_obstacks' iff NEED_POP is nonzero.
5676:
5677: For C++, `finish_decl' must be fairly evasive: it must keep initializers
5678: for aggregates that have constructors alive on the permanent obstack,
5679: so that the global initializing functions can be written at the end.
5680:
5681: INIT0 holds the value of an initializer that should be allowed to escape
5682: the normal rules.
5683:
5684: For functions that take default parameters, DECL points to its
5685: "maximal" instantiation. `finish_decl' must then also declared its
5686: subsequently lower and lower forms of instantiation, checking for
5687: ambiguity as it goes. This can be sped up later. */
5688:
5689: void
5690: finish_decl (decl, init, asmspec_tree, need_pop)
5691: tree decl, init;
5692: tree asmspec_tree;
5693: int need_pop;
5694: {
5695: register tree type;
5696: tree cleanup = NULL_TREE, ttype;
5697: int was_incomplete;
5698: int temporary = allocation_temporary_p ();
5699: char *asmspec = NULL;
5700: int was_readonly = 0;
5701:
5702: /* If this is 0, then we did not change obstacks. */
5703: if (! decl)
5704: {
5705: if (init)
5706: error ("assignment (not initialization) in declaration");
5707: return;
5708: }
5709:
5710: /* If a name was specified, get the string. */
5711: if (asmspec_tree)
5712: asmspec = TREE_STRING_POINTER (asmspec_tree);
5713:
5714: /* If the type of the thing we are declaring either has
5715: a constructor, or has a virtual function table pointer,
5716: AND its initialization was accepted by `start_decl',
5717: then we stayed on the permanent obstack through the
5718: declaration, otherwise, changed obstacks as GCC would. */
5719:
5720: type = TREE_TYPE (decl);
5721:
5722: if (type == error_mark_node)
5723: {
5724: if (current_binding_level == global_binding_level && temporary)
5725: end_temporary_allocation ();
5726:
5727: return;
5728: }
5729:
5730: was_incomplete = (DECL_SIZE (decl) == NULL_TREE);
5731:
5732: /* Take care of TYPE_DECLs up front. */
5733: if (TREE_CODE (decl) == TYPE_DECL)
5734: {
5735: if (init && DECL_INITIAL (decl))
5736: {
5737: /* typedef foo = bar; store the type of bar as the type of foo. */
5738: TREE_TYPE (decl) = type = TREE_TYPE (init);
5739: DECL_INITIAL (decl) = init = NULL_TREE;
5740: }
5741: if (type != error_mark_node
5742: && IS_AGGR_TYPE (type) && DECL_NAME (decl))
5743: {
5744: if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5745: cp_warning ("shadowing previous type declaration of `%#D'", decl);
5746: set_identifier_type_value (DECL_NAME (decl), type);
5747: CLASSTYPE_GOT_SEMICOLON (type) = 1;
5748: }
5749: GNU_xref_decl (current_function_decl, decl);
5750: rest_of_decl_compilation (decl, NULL_PTR,
5751: DECL_CONTEXT (decl) == NULL_TREE, 0);
5752: goto finish_end;
5753: }
5754: if (type != error_mark_node && IS_AGGR_TYPE (type)
5755: && CLASSTYPE_DECLARED_EXCEPTION (type))
5756: {
5757: CLASSTYPE_GOT_SEMICOLON (type) = 1;
5758: goto finish_end;
5759: }
5760: if (TREE_CODE (decl) != FUNCTION_DECL)
5761: {
5762: ttype = target_type (type);
5763: #if 0 /* WTF? -KR
5764: Leave this out until we can figure out why it was
5765: needed/desirable in the first place. Then put a comment
5766: here explaining why. Or just delete the code if no ill
5767: effects arise. */
5768: if (TYPE_NAME (ttype)
5769: && TREE_CODE (TYPE_NAME (ttype)) == TYPE_DECL
5770: && ANON_AGGRNAME_P (TYPE_IDENTIFIER (ttype)))
5771: {
5772: tree old_id = TYPE_IDENTIFIER (ttype);
5773: char *newname = (char *)alloca (IDENTIFIER_LENGTH (old_id) + 2);
5774: /* Need to preserve template data for UPT nodes. */
5775: tree old_template = IDENTIFIER_TEMPLATE (old_id);
5776: newname[0] = '_';
5777: bcopy (IDENTIFIER_POINTER (old_id), newname + 1,
5778: IDENTIFIER_LENGTH (old_id) + 1);
5779: old_id = get_identifier (newname);
5780: lookup_tag_reverse (ttype, old_id);
5781: TYPE_IDENTIFIER (ttype) = old_id;
5782: IDENTIFIER_TEMPLATE (old_id) = old_template;
5783: }
5784: #endif
5785: }
5786:
5787: if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
5788: && TYPE_NEEDS_CONSTRUCTING (type))
5789: {
5790:
5791: /* Currently, GNU C++ puts constants in text space, making them
5792: impossible to initialize. In the future, one would hope for
5793: an operating system which understood the difference between
5794: initialization and the running of a program. */
5795: was_readonly = 1;
5796: TREE_READONLY (decl) = 0;
5797: }
5798:
5799: if (TREE_CODE (decl) == FIELD_DECL)
5800: {
5801: if (init && init != error_mark_node)
5802: my_friendly_assert (TREE_PERMANENT (init), 147);
5803:
5804: if (asmspec)
5805: {
5806: /* This must override the asm specifier which was placed
5807: by grokclassfn. Lay this out fresh.
5808:
5809: @@ Should emit an error if this redefines an asm-specified
5810: @@ name, or if we have already used the function's name. */
5811: DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
5812: DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
5813: make_decl_rtl (decl, asmspec, 0);
5814: }
5815: }
5816: /* If `start_decl' didn't like having an initialization, ignore it now. */
5817: else if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
5818: init = NULL_TREE;
5819: else if (DECL_EXTERNAL (decl))
5820: ;
5821: else if (TREE_CODE (type) == REFERENCE_TYPE
5822: || (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE_REFERENCE (type)))
5823: {
5824: if (TREE_STATIC (decl))
5825: make_decl_rtl (decl, NULL_PTR,
5826: current_binding_level == global_binding_level
5827: || pseudo_global_level_p ());
5828: grok_reference_init (decl, type, init, &cleanup);
5829: init = NULL_TREE;
5830: }
5831:
5832: GNU_xref_decl (current_function_decl, decl);
5833:
5834: if (TREE_CODE (decl) == FIELD_DECL)
5835: ;
5836: else if (TREE_CODE (decl) == CONST_DECL)
5837: {
5838: my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
5839:
5840: DECL_INITIAL (decl) = init;
5841:
5842: /* This will keep us from needing to worry about our obstacks. */
5843: my_friendly_assert (init != NULL_TREE, 149);
5844: init = NULL_TREE;
5845: }
5846: else if (init)
5847: {
5848: if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
5849: {
5850: if (TREE_CODE (type) == ARRAY_TYPE)
5851: init = digest_init (type, init, (tree *) 0);
5852: else if (TREE_CODE (init) == CONSTRUCTOR)
5853: {
5854: if (TYPE_NEEDS_CONSTRUCTING (type))
5855: {
5856: cp_error ("`%D' must be initialized by constructor, not by `{...}'",
5857: decl);
5858: init = error_mark_node;
5859: }
5860: else
5861: goto dont_use_constructor;
5862: }
5863: #if 0
5864: /* fix this in `build_functional_cast' instead.
5865: Here's the trigger code:
5866:
5867: struct ostream
5868: {
5869: ostream ();
5870: ostream (int, char *);
5871: ostream (char *);
5872: operator char *();
5873: ostream (void *);
5874: operator void *();
5875: operator << (int);
5876: };
5877: int buf_size = 1024;
5878: static char buf[buf_size];
5879: const char *debug(int i) {
5880: char *b = &buf[0];
5881: ostream o = ostream(buf_size, b);
5882: o << i;
5883: return buf;
5884: }
5885: */
5886:
5887: else if (TREE_CODE (init) == TARGET_EXPR
5888: && TREE_CODE (TREE_OPERAND (init, 1) == NEW_EXPR))
5889: {
5890: /* User wrote something like `foo x = foo (args)' */
5891: my_friendly_assert (TREE_CODE (TREE_OPERAND (init, 0)) == VAR_DECL, 150);
5892: my_friendly_assert (DECL_NAME (TREE_OPERAND (init, 0)) == NULL_TREE, 151);
5893:
5894: /* User wrote exactly `foo x = foo (args)' */
5895: if (TYPE_MAIN_VARIANT (type) == TREE_TYPE (init))
5896: {
5897: init = build (CALL_EXPR, TREE_TYPE (init),
5898: TREE_OPERAND (TREE_OPERAND (init, 1), 0),
5899: TREE_OPERAND (TREE_OPERAND (init, 1), 1), 0);
5900: TREE_SIDE_EFFECTS (init) = 1;
5901: }
5902: }
5903: #endif
5904:
5905: /* We must hide the initializer so that expand_decl
5906: won't try to do something it does not understand. */
5907: if (current_binding_level == global_binding_level)
5908: {
5909: tree value;
5910: if (DECL_COMMON (decl))
5911: /* Should this be a NULL_TREE? */
5912: value = error_mark_node;
5913: else
5914: value = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
5915: DECL_INITIAL (decl) = value;
5916: }
5917: else
5918: DECL_INITIAL (decl) = error_mark_node;
5919: }
5920: else
5921: {
5922: dont_use_constructor:
5923: if (TREE_CODE (init) != TREE_VEC)
5924: init = store_init_value (decl, init);
5925:
5926: /* Don't let anyone try to initialize this variable
5927: until we are ready to do so. */
5928: if (init)
5929: {
5930: tree value;
5931: if (DECL_COMMON (decl))
5932: value = error_mark_node;
5933: else
5934: value = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
5935: DECL_INITIAL (decl) = value;
5936: }
5937: }
5938: }
5939: else if (DECL_EXTERNAL (decl))
5940: ;
5941: else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
5942: && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
5943: {
5944: tree ctype = type;
5945: while (TREE_CODE (ctype) == ARRAY_TYPE)
5946: ctype = TREE_TYPE (ctype);
5947: if (! TYPE_NEEDS_CONSTRUCTING (ctype))
5948: {
5949: if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype))
5950: cp_error ("structure `%D' with uninitialized const members", decl);
5951: if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype))
5952: cp_error ("structure `%D' with uninitialized reference members",
5953: decl);
5954: }
5955:
5956: if (TREE_CODE (decl) == VAR_DECL
5957: && !DECL_INITIAL (decl)
5958: && !TYPE_NEEDS_CONSTRUCTING (type)
5959: && (TYPE_READONLY (type) || TREE_READONLY (decl)))
5960: cp_error ("uninitialized const `%D'", decl);
5961:
5962: /* Initialize variables in need of static initialization with
5963: an empty CONSTRUCTOR to keep assemble_variable from putting them in
5964: the wrong program space. */
5965: if (flag_pic == 0
5966: && TREE_STATIC (decl)
5967: && TREE_PUBLIC (decl)
5968: && ! DECL_EXTERNAL (decl)
5969: && TREE_CODE (decl) == VAR_DECL
5970: && TYPE_NEEDS_CONSTRUCTING (type)
5971: && (DECL_INITIAL (decl) == NULL_TREE
5972: || DECL_INITIAL (decl) == error_mark_node)
5973: && ! DECL_COMMON (decl))
5974: DECL_INITIAL (decl) = build (CONSTRUCTOR, type, NULL_TREE,
5975: NULL_TREE);
5976: }
5977: else if (TREE_CODE (decl) == VAR_DECL
5978: && TREE_CODE (type) != REFERENCE_TYPE
5979: && (TYPE_READONLY (type) || TREE_READONLY (decl)))
5980: {
5981: /* ``Unless explicitly declared extern, a const object does not have
5982: external linkage and must be initialized. ($8.4; $12.1)'' ARM 7.1.6
5983: However, if it's `const int foo = 1; const int foo;', don't complain
5984: about the second decl, since it does have an initializer before.
5985: We deliberately don't complain about arrays, because they're
5986: supposed to be initialized by a constructor. */
5987: if (! DECL_INITIAL (decl)
5988: && TREE_CODE (type) != ARRAY_TYPE
5989: && (!pedantic || !current_class_type))
5990: cp_error ("uninitialized const `%#D'", decl);
5991: }
5992:
5993: /* For top-level declaration, the initial value was read in
5994: the temporary obstack. MAXINDEX, rtl, etc. to be made below
5995: must go in the permanent obstack; but don't discard the
5996: temporary data yet. */
5997:
5998: if (current_binding_level == global_binding_level && temporary)
5999: end_temporary_allocation ();
6000:
6001: /* Deduce size of array from initialization, if not already known. */
6002:
6003: if (TREE_CODE (type) == ARRAY_TYPE
6004: && TYPE_DOMAIN (type) == NULL_TREE
6005: && TREE_CODE (decl) != TYPE_DECL)
6006: {
6007: int do_default
6008: = (TREE_STATIC (decl)
6009: /* Even if pedantic, an external linkage array
6010: may have incomplete type at first. */
6011: ? pedantic && ! DECL_EXTERNAL (decl)
6012: : !DECL_EXTERNAL (decl));
6013: tree initializer = init ? init : DECL_INITIAL (decl);
6014: int failure = complete_array_type (type, initializer, do_default);
6015:
6016: if (failure == 1)
6017: cp_error ("initializer fails to determine size of `%D'", decl);
6018:
6019: if (failure == 2)
6020: {
6021: if (do_default)
6022: cp_error ("array size missing in `%D'", decl);
6023: /* If a `static' var's size isn't known, make it extern as
6024: well as static, so it does not get allocated. If it's not
6025: `static', then don't mark it extern; finish_incomplete_decl
6026: will give it a default size and it will get allocated. */
6027: else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
6028: DECL_EXTERNAL (decl) = 1;
6029: }
6030:
6031: if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
6032: && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
6033: integer_zero_node))
6034: cp_error ("zero-size array `%D'", decl);
6035:
6036: layout_decl (decl, 0);
6037: }
6038:
6039: if (TREE_CODE (decl) == VAR_DECL)
6040: {
6041: if (DECL_SIZE (decl) == NULL_TREE
6042: && TYPE_SIZE (TREE_TYPE (decl)) != NULL_TREE)
6043: layout_decl (decl, 0);
6044:
6045: if (TREE_STATIC (decl) && DECL_SIZE (decl) == NULL_TREE)
6046: {
6047: /* A static variable with an incomplete type:
6048: that is an error if it is initialized.
6049: Otherwise, let it through, but if it is not `extern'
6050: then it may cause an error message later. */
6051: if (DECL_INITIAL (decl) != NULL_TREE)
6052: cp_error ("storage size of `%D' isn't known", decl);
6053: init = NULL_TREE;
6054: }
6055: else if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
6056: {
6057: /* An automatic variable with an incomplete type: that is an error.
6058: Don't talk about array types here, since we took care of that
6059: message in grokdeclarator. */
6060: cp_error ("storage size of `%D' isn't known", decl);
6061: TREE_TYPE (decl) = error_mark_node;
6062: }
6063: else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
6064: /* Let debugger know it should output info for this type. */
6065: note_debug_info_needed (ttype);
6066:
6067: if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
6068: && DECL_SIZE (decl) != NULL_TREE
6069: && ! TREE_CONSTANT (DECL_SIZE (decl)))
6070: {
6071: if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
6072: constant_expression_warning (DECL_SIZE (decl));
6073: else
6074: cp_error ("storage size of `%D' isn't constant", decl);
6075: }
6076:
6077: if (!DECL_EXTERNAL (decl) && TYPE_NEEDS_DESTRUCTOR (type))
6078: {
6079: int yes = suspend_momentary ();
6080:
6081: /* If INIT comes from a functional cast, use the cleanup
6082: we built for that. Otherwise, make our own cleanup. */
6083: if (init && TREE_CODE (init) == WITH_CLEANUP_EXPR
6084: && comptypes (TREE_TYPE (decl), TREE_TYPE (init), 1))
6085: {
6086: cleanup = TREE_OPERAND (init, 2);
6087: init = TREE_OPERAND (init, 0);
6088: current_binding_level->have_cleanups = 1;
6089: }
6090: else
6091: cleanup = maybe_build_cleanup (decl);
6092: resume_momentary (yes);
6093: }
6094: }
6095: /* PARM_DECLs get cleanups, too. */
6096: else if (TREE_CODE (decl) == PARM_DECL && TYPE_NEEDS_DESTRUCTOR (type))
6097: {
6098: if (temporary)
6099: end_temporary_allocation ();
6100: cleanup = maybe_build_cleanup (decl);
6101: if (temporary)
6102: resume_temporary_allocation ();
6103: }
6104:
6105: /* Output the assembler code and/or RTL code for variables and functions,
6106: unless the type is an undefined structure or union.
6107: If not, it will get done when the type is completed. */
6108:
6109: if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
6110: || TREE_CODE (decl) == RESULT_DECL)
6111: {
6112: /* ??? FIXME: What about nested classes? */
6113: int toplev = (current_binding_level == global_binding_level
6114: || pseudo_global_level_p ());
6115: int was_temp
6116: = ((flag_traditional
6117: || (TREE_STATIC (decl) && TYPE_NEEDS_DESTRUCTOR (type)))
6118: && allocation_temporary_p ());
6119:
6120: if (was_temp)
6121: end_temporary_allocation ();
6122:
6123: if (TREE_CODE (decl) == VAR_DECL
6124: && current_binding_level != global_binding_level
6125: && ! TREE_STATIC (decl)
6126: && type_needs_gc_entry (type))
6127: DECL_GC_OFFSET (decl) = size_int (++current_function_obstack_index);
6128:
6129: if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
6130: make_decl_rtl (decl, NULL_PTR, toplev);
6131: else if (TREE_CODE (decl) == VAR_DECL
6132: && TREE_READONLY (decl)
6133: && DECL_INITIAL (decl) != NULL_TREE
6134: && DECL_INITIAL (decl) != error_mark_node
6135: && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
6136: {
6137: DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
6138:
6139: if (asmspec)
6140: DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
6141:
6142: if (! toplev
6143: && TREE_STATIC (decl)
6144: && ! TREE_SIDE_EFFECTS (decl)
6145: && ! TREE_PUBLIC (decl)
6146: && ! DECL_EXTERNAL (decl)
6147: && ! TYPE_NEEDS_DESTRUCTOR (type)
6148: && DECL_MODE (decl) != BLKmode)
6149: {
6150: /* If this variable is really a constant, then fill its DECL_RTL
6151: slot with something which won't take up storage.
6152: If something later should take its address, we can always give
6153: it legitimate RTL at that time. */
6154: DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
6155: store_expr (DECL_INITIAL (decl), DECL_RTL (decl), 0);
6156: TREE_ASM_WRITTEN (decl) = 1;
6157: }
6158: else if (toplev && ! TREE_PUBLIC (decl))
6159: {
6160: /* If this is a static const, change its apparent linkage
6161: if it belongs to a #pragma interface. */
6162: if (!interface_unknown)
6163: {
6164: TREE_PUBLIC (decl) = 1;
6165: DECL_EXTERNAL (decl) = interface_only;
6166: }
6167: make_decl_rtl (decl, asmspec, toplev);
6168: }
6169: else
6170: rest_of_decl_compilation (decl, asmspec, toplev, 0);
6171: }
6172: else if (TREE_CODE (decl) == VAR_DECL
6173: && DECL_LANG_SPECIFIC (decl)
6174: && DECL_IN_AGGR_P (decl))
6175: {
6176: if (TREE_STATIC (decl))
6177: {
6178: if (init == NULL_TREE
6179: #ifdef DEFAULT_STATIC_DEFS
6180: /* If this code is dead, then users must
6181: explicitly declare static member variables
6182: outside the class def'n as well. */
6183: && TYPE_NEEDS_CONSTRUCTING (type)
6184: #endif
6185: )
6186: {
6187: DECL_EXTERNAL (decl) = 1;
6188: make_decl_rtl (decl, asmspec, 1);
6189: }
6190: else
6191: rest_of_decl_compilation (decl, asmspec, toplev, 0);
6192: }
6193: else
6194: /* Just a constant field. Should not need any rtl. */
6195: goto finish_end0;
6196: }
6197: else
6198: rest_of_decl_compilation (decl, asmspec, toplev, 0);
6199:
6200: if (was_temp)
6201: resume_temporary_allocation ();
6202:
6203: if (type != error_mark_node
6204: && TYPE_LANG_SPECIFIC (type)
6205: && CLASSTYPE_ABSTRACT_VIRTUALS (type))
6206: abstract_virtuals_error (decl, type);
6207: else if ((TREE_CODE (type) == FUNCTION_TYPE
6208: || TREE_CODE (type) == METHOD_TYPE)
6209: && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
6210: && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type)))
6211: abstract_virtuals_error (decl, TREE_TYPE (type));
6212:
6213: if (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE (type))
6214: signature_error (decl, type);
6215: else if ((TREE_CODE (type) == FUNCTION_TYPE
6216: || TREE_CODE (type) == METHOD_TYPE)
6217: && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
6218: && IS_SIGNATURE (TREE_TYPE (type)))
6219: signature_error (decl, TREE_TYPE (type));
6220:
6221: if (TREE_CODE (decl) == FUNCTION_DECL)
6222: {
6223: #if 0
6224: /* C++: Handle overloaded functions with default parameters. */
6225: if (DECL_OVERLOADED (decl))
6226: {
6227: tree parmtypes = TYPE_ARG_TYPES (type);
6228: tree prev = NULL_TREE;
6229: tree original_name = DECL_NAME (decl);
6230: struct lang_decl *tmp_lang_decl = DECL_LANG_SPECIFIC (decl);
6231: /* All variants will share an uncollectible lang_decl. */
6232: copy_decl_lang_specific (decl);
6233:
6234: while (parmtypes && parmtypes != void_list_node)
6235: {
6236: /* The default value for the parameter in parmtypes is
6237: stored in the TREE_PURPOSE of the TREE_LIST. */
6238: if (TREE_PURPOSE (parmtypes))
6239: {
6240: tree fnname, fndecl;
6241: tree *argp;
6242:
6243: argp = prev ? & TREE_CHAIN (prev)
6244: : & TYPE_ARG_TYPES (type);
6245:
6246: *argp = NULL_TREE;
6247: fnname = build_decl_overload (original_name,
6248: TYPE_ARG_TYPES (type), 0);
6249: *argp = parmtypes;
6250: fndecl = build_decl (FUNCTION_DECL, fnname, type);
6251: DECL_EXTERNAL (fndecl) = DECL_EXTERNAL (decl);
6252: TREE_PUBLIC (fndecl) = TREE_PUBLIC (decl);
6253: DECL_INLINE (fndecl) = DECL_INLINE (decl);
6254: /* Keep G++ from thinking this function is unused.
6255: It is only used to speed up search in name space. */
6256: TREE_USED (fndecl) = 1;
6257: TREE_ASM_WRITTEN (fndecl) = 1;
6258: DECL_INITIAL (fndecl) = NULL_TREE;
6259: DECL_LANG_SPECIFIC (fndecl) = DECL_LANG_SPECIFIC (decl);
6260: fndecl = pushdecl (fndecl);
6261: DECL_INITIAL (fndecl) = error_mark_node;
6262: DECL_RTL (fndecl) = DECL_RTL (decl);
6263: }
6264: prev = parmtypes;
6265: parmtypes = TREE_CHAIN (parmtypes);
6266: }
6267: DECL_LANG_SPECIFIC (decl) = tmp_lang_decl;
6268: }
6269: #endif
6270: }
6271: else if (DECL_EXTERNAL (decl))
6272: ;
6273: else if (TREE_STATIC (decl) && type != error_mark_node)
6274: {
6275: /* Cleanups for static variables are handled by `finish_file'. */
6276: if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE)
6277: expand_static_init (decl, init);
6278: else if (TYPE_NEEDS_DESTRUCTOR (type))
6279: static_aggregates = perm_tree_cons (NULL_TREE, decl,
6280: static_aggregates);
6281:
6282: /* Make entry in appropriate vector. */
6283: if (flag_gc && type_needs_gc_entry (type))
6284: build_static_gc_entry (decl, type);
6285: }
6286: else if (! toplev)
6287: {
6288: tree old_cleanups = cleanups_this_call;
6289: /* This is a declared decl which must live until the
6290: end of the binding contour. It may need a cleanup. */
6291:
6292: /* Recompute the RTL of a local array now
6293: if it used to be an incomplete type. */
6294: if (was_incomplete && ! TREE_STATIC (decl))
6295: {
6296: /* If we used it already as memory, it must stay in memory. */
6297: TREE_ADDRESSABLE (decl) = TREE_USED (decl);
6298: /* If it's still incomplete now, no init will save it. */
6299: if (DECL_SIZE (decl) == NULL_TREE)
6300: DECL_INITIAL (decl) = NULL_TREE;
6301: expand_decl (decl);
6302: }
6303: else if (! TREE_ASM_WRITTEN (decl)
6304: && (TYPE_SIZE (type) != NULL_TREE
6305: || TREE_CODE (type) == ARRAY_TYPE))
6306: {
6307: /* Do this here, because we did not expand this decl's
6308: rtl in start_decl. */
6309: if (DECL_RTL (decl) == NULL_RTX)
6310: expand_decl (decl);
6311: else if (cleanup)
6312: {
6313: /* XXX: Why don't we use decl here? */
6314: /* Ans: Because it was already expanded? */
6315: if (! expand_decl_cleanup (NULL_TREE, cleanup))
6316: cp_error ("parser lost in parsing declaration of `%D'",
6317: decl);
6318: /* Cleanup used up here. */
6319: cleanup = NULL_TREE;
6320: }
6321: }
6322:
6323: if (DECL_SIZE (decl) && type != error_mark_node)
6324: {
6325: /* Compute and store the initial value. */
6326: expand_decl_init (decl);
6327:
6328: if (init || TYPE_NEEDS_CONSTRUCTING (type))
6329: {
6330: emit_line_note (DECL_SOURCE_FILE (decl),
6331: DECL_SOURCE_LINE (decl));
6332: expand_aggr_init (decl, init, 0);
6333: }
6334:
6335: /* Set this to 0 so we can tell whether an aggregate which
6336: was initialized was ever used. Don't do this if it has a
6337: destructor, so we don't complain about the 'resource
6338: allocation is initialization' idiom. */
6339: if (TYPE_NEEDS_CONSTRUCTING (type) && cleanup == NULL_TREE)
6340: TREE_USED (decl) = 0;
6341:
6342: /* Store the cleanup, if there was one. */
6343: if (cleanup)
6344: {
6345: if (! expand_decl_cleanup (decl, cleanup))
6346: cp_error ("parser lost in parsing declaration of `%D'",
6347: decl);
6348: }
6349: }
6350: /* Cleanup any temporaries needed for the initial value. */
6351: expand_cleanups_to (old_cleanups);
6352: }
6353: finish_end0:
6354:
6355: /* Undo call to `pushclass' that was done in `start_decl'
6356: due to initialization of qualified member variable.
6357: I.e., Foo::x = 10; */
6358: {
6359: tree context = DECL_CONTEXT (decl);
6360: if (context
6361: && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
6362: && (TREE_CODE (decl) == VAR_DECL
6363: /* We also have a pushclass done that we need to undo here
6364: if we're at top level and declare a method. */
6365: || (TREE_CODE (decl) == FUNCTION_DECL
6366: /* If size hasn't been set, we're still defining it,
6367: and therefore inside the class body; don't pop
6368: the binding level.. */
6369: && TYPE_SIZE (context) != NULL_TREE
6370: /* The binding level gets popped elsewhere for a
6371: friend declaration inside another class. */
6372: /*
6373: && TYPE_IDENTIFIER (context) == current_class_name
6374: */
6375: && context == current_class_type
6376: )))
6377: popclass (1);
6378: }
6379: }
6380:
6381: finish_end:
6382:
6383: /* If requested, warn about definitions of large data objects. */
6384:
6385: if (warn_larger_than
6386: && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
6387: && !DECL_EXTERNAL (decl))
6388: {
6389: register tree decl_size = DECL_SIZE (decl);
6390:
6391: if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
6392: {
6393: unsigned units = TREE_INT_CST_LOW (decl_size) / BITS_PER_UNIT;
6394:
6395: if (units > larger_than_size)
6396: warning_with_decl (decl, "size of `%s' is %u bytes", units);
6397: }
6398: }
6399:
6400: if (need_pop)
6401: {
6402: /* Resume permanent allocation, if not within a function. */
6403: /* The corresponding push_obstacks_nochange is in start_decl,
6404: start_method, groktypename, and in grokfield. */
6405: pop_obstacks ();
6406: }
6407:
6408: if (was_readonly)
6409: TREE_READONLY (decl) = 1;
6410:
6411: if (flag_cadillac)
6412: cadillac_finish_decl (decl);
6413: }
6414:
6415: void
6416: expand_static_init (decl, init)
6417: tree decl;
6418: tree init;
6419: {
6420: tree oldstatic = value_member (decl, static_aggregates);
6421: tree old_cleanups;
6422:
6423: if (oldstatic)
6424: {
6425: if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
6426: cp_error ("multiple initializations given for `%D'", decl);
6427: }
6428: else if (current_binding_level != global_binding_level
6429: && current_binding_level->pseudo_global == 0)
6430: {
6431: /* Emit code to perform this initialization but once. */
6432: tree temp;
6433:
6434: /* Remember this information until end of file. */
6435: push_obstacks (&permanent_obstack, &permanent_obstack);
6436:
6437: /* Emit code to perform this initialization but once. */
6438: temp = get_temp_name (integer_type_node, 1);
6439: rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
6440: expand_start_cond (build_binary_op (EQ_EXPR, temp,
6441: integer_zero_node, 1), 0);
6442: old_cleanups = cleanups_this_call;
6443: expand_assignment (temp, integer_one_node, 0, 0);
6444: if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
6445: {
6446: expand_aggr_init (decl, init, 0);
6447: do_pending_stack_adjust ();
6448: }
6449: else
6450: expand_assignment (decl, init, 0, 0);
6451: /* Cleanup any temporaries needed for the initial value. */
6452: expand_cleanups_to (old_cleanups);
6453: expand_end_cond ();
6454: if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
6455: {
6456: static_aggregates = perm_tree_cons (temp, decl, static_aggregates);
6457: TREE_STATIC (static_aggregates) = 1;
6458: }
6459:
6460: /* Resume old (possibly temporary) allocation. */
6461: pop_obstacks ();
6462: }
6463: else
6464: {
6465: /* This code takes into account memory allocation
6466: policy of `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING
6467: does not hold for this object, then we must make permanent
6468: the storage currently in the temporary obstack. */
6469: if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
6470: preserve_initializer ();
6471: static_aggregates = perm_tree_cons (init, decl, static_aggregates);
6472: }
6473: }
6474:
6475: /* Make TYPE a complete type based on INITIAL_VALUE.
6476: Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6477: 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
6478:
6479: int
6480: complete_array_type (type, initial_value, do_default)
6481: tree type, initial_value;
6482: int do_default;
6483: {
6484: register tree maxindex = NULL_TREE;
6485: int value = 0;
6486:
6487: if (initial_value)
6488: {
6489: /* Note MAXINDEX is really the maximum index,
6490: one less than the size. */
6491: if (TREE_CODE (initial_value) == STRING_CST)
6492: maxindex = build_int_2 (TREE_STRING_LENGTH (initial_value) - 1, 0);
6493: else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6494: {
6495: register int nelts
6496: = list_length (CONSTRUCTOR_ELTS (initial_value));
6497: maxindex = build_int_2 (nelts - 1, - (nelts == 0));
6498: }
6499: else
6500: {
6501: /* Make an error message unless that happened already. */
6502: if (initial_value != error_mark_node)
6503: value = 1;
6504:
6505: /* Prevent further error messages. */
6506: maxindex = build_int_2 (0, 0);
6507: }
6508: }
6509:
6510: if (!maxindex)
6511: {
6512: if (do_default)
6513: maxindex = build_int_2 (0, 0);
6514: value = 2;
6515: }
6516:
6517: if (maxindex)
6518: {
6519: tree itype;
6520:
6521: TYPE_DOMAIN (type) = build_index_type (maxindex);
6522: if (!TREE_TYPE (maxindex))
6523: TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
6524: if (initial_value)
6525: itype = TREE_TYPE (initial_value);
6526: else
6527: itype = NULL;
6528: if (itype && !TYPE_DOMAIN (itype))
6529: TYPE_DOMAIN (itype) = TYPE_DOMAIN (type);
6530: }
6531:
6532: /* Lay out the type now that we can get the real answer. */
6533:
6534: layout_type (type);
6535:
6536: return value;
6537: }
6538:
6539: /* Return zero if something is declared to be a member of type
6540: CTYPE when in the context of CUR_TYPE. STRING is the error
6541: message to print in that case. Otherwise, quietly return 1. */
6542: static int
6543: member_function_or_else (ctype, cur_type, string)
6544: tree ctype, cur_type;
6545: char *string;
6546: {
6547: if (ctype && ctype != cur_type)
6548: {
6549: error (string, TYPE_NAME_STRING (ctype));
6550: return 0;
6551: }
6552: return 1;
6553: }
6554:
6555: /* Subroutine of `grokdeclarator'. */
6556:
6557: /* Generate errors possibly applicable for a given set of specifiers.
6558: This is for ARM $7.1.2. */
6559: static void
6560: bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
6561: tree object;
6562: char *type;
6563: int virtualp, quals, friendp, raises, inlinep;
6564: {
6565: if (virtualp)
6566: cp_error ("`%D' declared as a `virtual' %s", object, type);
6567: if (inlinep)
6568: cp_error ("`%D' declared as an `inline' %s", object, type);
6569: if (quals)
6570: cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
6571: object, type);
6572: if (friendp)
6573: cp_error_at ("invalid friend declaration", object);
6574: if (raises)
6575: cp_error_at ("invalid raises declaration", object);
6576: }
6577:
6578: /* CTYPE is class type, or null if non-class.
6579: TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6580: or METHOD_TYPE.
6581: DECLARATOR is the function's name.
6582: VIRTUALP is truthvalue of whether the function is virtual or not.
6583: FLAGS are to be passed through to `grokclassfn'.
6584: QUALS are qualifiers indicating whether the function is `const'
6585: or `volatile'.
6586: RAISES is a list of exceptions that this function can raise.
6587: CHECK is 1 if we must find this method in CTYPE, 0 if we should
6588: not look, and -1 if we should not call `grokclassfn' at all. */
6589: static tree
6590: grokfndecl (ctype, type, declarator, virtualp, flags, quals,
6591: raises, check, publicp)
6592: tree ctype, type;
6593: tree declarator;
6594: int virtualp;
6595: enum overload_flags flags;
6596: tree quals, raises;
6597: int check, publicp;
6598: {
6599: tree cname, decl;
6600: int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6601:
6602: if (ctype)
6603: cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
6604: ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
6605: else
6606: cname = NULL_TREE;
6607:
6608: if (raises)
6609: {
6610: type = build_exception_variant (ctype, type, raises);
6611: raises = TYPE_RAISES_EXCEPTIONS (type);
6612: }
6613: decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6614: /* propagate volatile out from type to decl */
6615: if (TYPE_VOLATILE (type))
6616: TREE_THIS_VOLATILE (decl) = 1;
6617:
6618: /* Should probably propagate const out from type to decl I bet (mrs). */
6619: if (staticp)
6620: {
6621: DECL_STATIC_FUNCTION_P (decl) = 1;
6622: DECL_CONTEXT (decl) = ctype;
6623: DECL_CLASS_CONTEXT (decl) = ctype;
6624: }
6625:
6626: if (publicp)
6627: TREE_PUBLIC (decl) = 1;
6628:
6629: DECL_EXTERNAL (decl) = 1;
6630: if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
6631: {
6632: cp_error ("%smember function `%D' cannot have `%T' method qualifier",
6633: (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
6634: quals = NULL_TREE;
6635: }
6636:
6637: if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
6638: grok_op_properties (decl, virtualp, check < 0);
6639:
6640: /* Caller will do the rest of this. */
6641: if (check < 0)
6642: return decl;
6643:
6644: if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
6645: {
6646: tree tmp;
6647: /* Just handle constructors here. We could do this
6648: inside the following if stmt, but I think
6649: that the code is more legible by breaking this
6650: case out. See comments below for what each of
6651: the following calls is supposed to do. */
6652: DECL_CONSTRUCTOR_P (decl) = 1;
6653:
6654: grokclassfn (ctype, declarator, decl, flags, quals);
6655: if (check)
6656: check_classfn (ctype, declarator, decl);
6657: if (! grok_ctor_properties (ctype, decl))
6658: return NULL_TREE;
6659:
6660: if (check == 0 && ! current_function_decl)
6661: {
6662: /* FIXME: this should only need to look at
6663: IDENTIFIER_GLOBAL_VALUE. */
6664: tmp = lookup_name (DECL_ASSEMBLER_NAME (decl), 0);
6665: if (tmp == NULL_TREE)
6666: IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl)) = decl;
6667: else if (TREE_CODE (tmp) != TREE_CODE (decl))
6668: cp_error ("inconsistent declarations for `%D'", decl);
6669: else
6670: {
6671: duplicate_decls (decl, tmp);
6672: decl = tmp;
6673: /* avoid creating circularities. */
6674: DECL_CHAIN (decl) = NULL_TREE;
6675: }
6676: make_decl_rtl (decl, NULL_PTR, 1);
6677: }
6678: }
6679: else
6680: {
6681: tree tmp;
6682:
6683: /* Function gets the ugly name, field gets the nice one.
6684: This call may change the type of the function (because
6685: of default parameters)! */
6686: if (ctype != NULL_TREE)
6687: grokclassfn (ctype, cname, decl, flags, quals);
6688:
6689: if (ctype != NULL_TREE && check)
6690: check_classfn (ctype, cname, decl);
6691:
6692: if (ctype == NULL_TREE || check)
6693: return decl;
6694:
6695: /* Now install the declaration of this function so that others may
6696: find it (esp. its DECL_FRIENDLIST). Don't do this for local class
6697: methods, though. */
6698: if (! current_function_decl)
6699: {
6700: /* FIXME: this should only need to look at
6701: IDENTIFIER_GLOBAL_VALUE. */
6702: tmp = lookup_name (DECL_ASSEMBLER_NAME (decl), 0);
6703: if (tmp == NULL_TREE)
6704: IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl)) = decl;
6705: else if (TREE_CODE (tmp) != TREE_CODE (decl))
6706: cp_error ("inconsistent declarations for `%D'", decl);
6707: else
6708: {
6709: duplicate_decls (decl, tmp);
6710: decl = tmp;
6711: /* avoid creating circularities. */
6712: DECL_CHAIN (decl) = NULL_TREE;
6713: }
6714: make_decl_rtl (decl, NULL_PTR, 1);
6715: }
6716:
6717: /* If this declaration supersedes the declaration of
6718: a method declared virtual in the base class, then
6719: mark this field as being virtual as well. */
6720: {
6721: tree binfos = BINFO_BASETYPES (TYPE_BINFO (ctype));
6722: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
6723:
6724: for (i = 0; i < n_baselinks; i++)
6725: {
6726: tree base_binfo = TREE_VEC_ELT (binfos, i);
6727: if (TYPE_VIRTUAL_P (BINFO_TYPE (base_binfo))
6728: || flag_all_virtual == 1)
6729: {
6730: tmp = get_matching_virtual (base_binfo, decl,
6731: flags == DTOR_FLAG);
6732: if (tmp)
6733: {
6734: /* If this function overrides some virtual in some base
6735: class, then the function itself is also necessarily
6736: virtual, even if the user didn't explicitly say so. */
6737: DECL_VIRTUAL_P (decl) = 1;
6738:
6739: /* The TMP we really want is the one from the deepest
6740: baseclass on this path, taking care not to
6741: duplicate if we have already found it (via another
6742: path to its virtual baseclass. */
6743: if (staticp)
6744: {
6745: cp_error ("method `%D' may not be declared static",
6746: decl);
6747: cp_error_at ("(since `%D' declared virtual in base class.)",
6748: tmp);
6749: break;
6750: }
6751: virtualp = 1;
6752:
6753: {
6754: /* The argument types may have changed... */
6755: tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
6756: tree base_variant = TREE_TYPE (TREE_VALUE (argtypes));
6757:
6758: argtypes = commonparms (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (tmp))),
6759: TREE_CHAIN (argtypes));
6760: /* But the return type has not. */
6761: type = build_cplus_method_type (base_variant, TREE_TYPE (type), argtypes);
6762: if (raises)
6763: {
6764: type = build_exception_variant (ctype, type, raises);
6765: raises = TYPE_RAISES_EXCEPTIONS (type);
6766: }
6767: TREE_TYPE (decl) = type;
6768: DECL_VINDEX (decl)
6769: = tree_cons (NULL_TREE, tmp, DECL_VINDEX (decl));
6770: }
6771: break;
6772: }
6773: }
6774: }
6775: }
6776: if (virtualp)
6777: {
6778: if (DECL_VINDEX (decl) == NULL_TREE)
6779: DECL_VINDEX (decl) = error_mark_node;
6780: IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
6781: if (ctype && CLASSTYPE_VTABLE_NEEDS_WRITING (ctype)
6782: /* If this function is derived from a template, don't
6783: make it public. This shouldn't be here, but there's
6784: no good way to override the interface pragmas for one
6785: function or class only. Bletch. */
6786: && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (ctype)) == NULL_TREE
6787: && (write_virtuals == 2
6788: || (write_virtuals == 3
6789: && CLASSTYPE_INTERFACE_KNOWN (ctype))))
6790: TREE_PUBLIC (decl) = 1;
6791: }
6792: }
6793: return decl;
6794: }
6795:
6796: static tree
6797: grokvardecl (type, declarator, specbits, initialized)
6798: tree type;
6799: tree declarator;
6800: RID_BIT_TYPE specbits;
6801: int initialized;
6802: {
6803: tree decl;
6804:
6805: if (TREE_CODE (type) == OFFSET_TYPE)
6806: {
6807: /* If you declare a static member so that it
6808: can be initialized, the code will reach here. */
6809: tree basetype = TYPE_OFFSET_BASETYPE (type);
6810: type = TREE_TYPE (type);
6811: decl = build_lang_field_decl (VAR_DECL, declarator, type);
6812: DECL_CONTEXT (decl) = basetype;
6813: DECL_CLASS_CONTEXT (decl) = basetype;
6814: DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
6815: }
6816: else
6817: decl = build_decl (VAR_DECL, declarator, type);
6818:
6819: if (RIDBIT_SETP (RID_EXTERN, specbits))
6820: {
6821: DECL_THIS_EXTERN (decl) = 1;
6822: DECL_EXTERNAL (decl) = !initialized;
6823: }
6824:
6825: /* In class context, static means one per class,
6826: public access, and static storage. */
6827: if (DECL_FIELD_CONTEXT (decl) != NULL_TREE
6828: && IS_AGGR_TYPE (DECL_FIELD_CONTEXT (decl)))
6829: {
6830: TREE_PUBLIC (decl) = 1;
6831: TREE_STATIC (decl) = 1;
6832: DECL_EXTERNAL (decl) = 0;
6833: }
6834: /* At top level, either `static' or no s.c. makes a definition
6835: (perhaps tentative), and absence of `static' makes it public. */
6836: else if (current_binding_level == global_binding_level)
6837: {
6838: TREE_PUBLIC (decl) = RIDBIT_NOTSETP (RID_STATIC, specbits);
6839: TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6840: }
6841: /* Not at top level, only `static' makes a static definition. */
6842: else
6843: {
6844: TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
6845: TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6846: }
6847: return decl;
6848: }
6849:
6850: /* Create a canonical pointer to member function type. */
6851:
6852: tree
6853: build_ptrmemfunc_type (type)
6854: tree type;
6855: {
6856: tree fields[4];
6857: tree t;
6858: tree u;
6859:
6860: /* If a canonical type already exists for this type, use it. We use
6861: this method instead of type_hash_canon, because it only does a
6862: simple equality check on the list of field members. */
6863:
6864: if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
6865: return t;
6866:
6867: push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
6868:
6869: u = make_lang_type (UNION_TYPE);
6870: fields[0] = build_lang_field_decl (FIELD_DECL, pfn_identifier, type);
6871: fields[1] = build_lang_field_decl (FIELD_DECL, delta2_identifier,
6872: delta_type_node);
6873: finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
6874: TYPE_NAME (u) = NULL_TREE;
6875:
6876: t = make_lang_type (RECORD_TYPE);
6877:
6878: /* Let the front-end know this is a pointer to member function. */
6879: TYPE_PTRMEMFUNC_FLAG(t) = 1;
6880: /* and not really an aggregate. */
6881: IS_AGGR_TYPE (t) = 0;
6882:
6883: fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
6884: delta_type_node);
6885: fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
6886: delta_type_node);
6887: fields[2] = build_lang_field_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
6888: finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
6889:
6890: pop_obstacks ();
6891:
6892: /* Zap out the name so that the back-end will give us the debugging
6893: information for this anonymous RECORD_TYPE. */
6894: TYPE_NAME (t) = NULL_TREE;
6895:
6896: TYPE_SET_PTRMEMFUNC_TYPE (type, t);
6897:
6898: /* Seems to be wanted. */
6899: CLASSTYPE_GOT_SEMICOLON (t) = 1;
6900: return t;
6901: }
6902:
6903: /* Given declspecs and a declarator,
6904: determine the name and type of the object declared
6905: and construct a ..._DECL node for it.
6906: (In one case we can return a ..._TYPE node instead.
6907: For invalid input we sometimes return 0.)
6908:
6909: DECLSPECS is a chain of tree_list nodes whose value fields
6910: are the storage classes and type specifiers.
6911:
6912: DECL_CONTEXT says which syntactic context this declaration is in:
6913: NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6914: FUNCDEF for a function definition. Like NORMAL but a few different
6915: error messages in each case. Return value may be zero meaning
6916: this definition is too screwy to try to parse.
6917: MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
6918: handle member functions (which have FIELD context).
6919: Return value may be zero meaning this definition is too screwy to
6920: try to parse.
6921: PARM for a parameter declaration (either within a function prototype
6922: or before a function body). Make a PARM_DECL, or return void_type_node.
6923: TYPENAME if for a typename (in a cast or sizeof).
6924: Don't make a DECL node; just return the ..._TYPE node.
6925: FIELD for a struct or union field; make a FIELD_DECL.
6926: BITFIELD for a field with specified width.
6927: INITIALIZED is 1 if the decl has an initializer.
6928:
6929: In the TYPENAME case, DECLARATOR is really an absolute declarator.
6930: It may also be so in the PARM case, for a prototype where the
6931: argument type is specified but not the name.
6932:
6933: This function is where the complicated C meanings of `static'
6934: and `extern' are interpreted.
6935:
6936: For C++, if there is any monkey business to do, the function which
6937: calls this one must do it, i.e., prepending instance variables,
6938: renaming overloaded function names, etc.
6939:
6940: Note that for this C++, it is an error to define a method within a class
6941: which does not belong to that class.
6942:
6943: Except in the case where SCOPE_REFs are implicitly known (such as
6944: methods within a class being redundantly qualified),
6945: declarations which involve SCOPE_REFs are returned as SCOPE_REFs
6946: (class_name::decl_name). The caller must also deal with this.
6947:
6948: If a constructor or destructor is seen, and the context is FIELD,
6949: then the type gains the attribute TREE_HAS_x. If such a declaration
6950: is erroneous, NULL_TREE is returned.
6951:
6952: QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
6953: function, these are the qualifiers to give to the `this' pointer.
6954:
6955: May return void_type_node if the declarator turned out to be a friend.
6956: See grokfield for details. */
6957:
6958: enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
6959:
6960: tree
6961: grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
6962: tree declspecs;
6963: tree declarator;
6964: enum decl_context decl_context;
6965: int initialized;
6966: tree raises;
6967: {
6968: RID_BIT_TYPE specbits;
6969: int nclasses = 0;
6970: tree spec;
6971: tree type = NULL_TREE;
6972: int longlong = 0;
6973: int constp;
6974: int volatilep;
6975: int virtualp, friendp, inlinep, staticp;
6976: int explicit_int = 0;
6977: int explicit_char = 0;
6978: int opaque_typedef = 0;
6979: tree typedef_decl = NULL_TREE;
6980: char *name;
6981: tree typedef_type = NULL_TREE;
6982: int funcdef_flag = 0;
6983: enum tree_code innermost_code = ERROR_MARK;
6984: int bitfield = 0;
6985: int size_varies = 0;
6986: /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
6987: All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
6988: tree init = NULL_TREE;
6989:
6990: /* Keep track of what sort of function is being processed
6991: so that we can warn about default return values, or explicit
6992: return values which do not match prescribed defaults. */
6993: enum return_types return_type = return_normal;
6994:
6995: tree dname = NULL_TREE;
6996: tree ctype = current_class_type;
6997: tree ctor_return_type = NULL_TREE;
6998: enum overload_flags flags = NO_SPECIAL;
6999: tree quals = NULL_TREE;
7000:
7001: RIDBIT_RESET_ALL (specbits);
7002: if (decl_context == FUNCDEF)
7003: funcdef_flag = 1, decl_context = NORMAL;
7004: else if (decl_context == MEMFUNCDEF)
7005: funcdef_flag = -1, decl_context = FIELD;
7006: else if (decl_context == BITFIELD)
7007: bitfield = 1, decl_context = FIELD;
7008:
7009: if (flag_traditional && allocation_temporary_p ())
7010: end_temporary_allocation ();
7011:
7012: /* Look inside a declarator for the name being declared
7013: and get it as a string, for an error message. */
7014: {
7015: tree last = NULL_TREE;
7016: register tree decl = declarator;
7017: name = NULL;
7018:
7019: while (decl)
7020: switch (TREE_CODE (decl))
7021: {
7022: case COND_EXPR:
7023: ctype = NULL_TREE;
7024: decl = TREE_OPERAND (decl, 0);
7025: break;
7026:
7027: case BIT_NOT_EXPR: /* for C++ destructors! */
7028: {
7029: tree name = TREE_OPERAND (decl, 0);
7030: tree rename = NULL_TREE;
7031:
7032: my_friendly_assert (flags == NO_SPECIAL, 152);
7033: flags = DTOR_FLAG;
7034: return_type = return_dtor;
7035: my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
7036: if (ctype == NULL_TREE)
7037: {
7038: if (current_class_type == NULL_TREE)
7039: {
7040: error ("destructors must be member functions");
7041: flags = NO_SPECIAL;
7042: }
7043: else
7044: {
7045: tree t = constructor_name (current_class_name);
7046: if (t != name)
7047: rename = t;
7048: }
7049: }
7050: else
7051: {
7052: tree t = constructor_name (ctype);
7053: if (t != name)
7054: rename = t;
7055: }
7056:
7057: if (rename)
7058: {
7059: error ("destructor `%s' must match class name `%s'",
7060: IDENTIFIER_POINTER (name),
7061: IDENTIFIER_POINTER (rename));
7062: TREE_OPERAND (decl, 0) = rename;
7063: }
7064: decl = name;
7065: }
7066: break;
7067:
7068: case ADDR_EXPR: /* C++ reference declaration */
7069: /* fall through */
7070: case ARRAY_REF:
7071: case INDIRECT_REF:
7072: ctype = NULL_TREE;
7073: innermost_code = TREE_CODE (decl);
7074: last = decl;
7075: decl = TREE_OPERAND (decl, 0);
7076: break;
7077:
7078: case CALL_EXPR:
7079: if (parmlist_is_exprlist (TREE_OPERAND (decl, 1)))
7080: {
7081: /* This is actually a variable declaration using constructor
7082: syntax. We need to call start_decl and finish_decl so we
7083: can get the variable initialized... */
7084:
7085: if (last)
7086: /* We need to insinuate ourselves into the declarator in place
7087: of the CALL_EXPR. */
7088: TREE_OPERAND (last, 0) = TREE_OPERAND (decl, 0);
7089: else
7090: declarator = TREE_OPERAND (decl, 0);
7091:
7092: init = TREE_OPERAND (decl, 1);
7093:
7094: decl = start_decl (declarator, declspecs, 1, NULL_TREE);
7095: finish_decl (decl, init, NULL_TREE, 1);
7096: return 0;
7097: }
7098: innermost_code = TREE_CODE (decl);
7099: decl = TREE_OPERAND (decl, 0);
7100: if (decl_context == FIELD && ctype == NULL_TREE)
7101: ctype = current_class_type;
7102: if (ctype != NULL_TREE
7103: && decl != NULL_TREE && flags != DTOR_FLAG
7104: && decl == constructor_name (ctype))
7105: {
7106: return_type = return_ctor;
7107: ctor_return_type = ctype;
7108: }
7109: ctype = NULL_TREE;
7110: break;
7111:
7112: case IDENTIFIER_NODE:
7113: dname = decl;
7114: decl = NULL_TREE;
7115:
7116: if (! IDENTIFIER_OPNAME_P (dname)
7117: /* Linux headers use '__op'. Arrgh. */
7118: || IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname))
7119: name = IDENTIFIER_POINTER (dname);
7120: else
7121: {
7122: if (IDENTIFIER_TYPENAME_P (dname))
7123: {
7124: my_friendly_assert (flags == NO_SPECIAL, 154);
7125: flags = TYPENAME_FLAG;
7126: ctor_return_type = TREE_TYPE (dname);
7127: return_type = return_conversion;
7128: }
7129: name = operator_name_string (dname);
7130: }
7131: break;
7132:
7133: case RECORD_TYPE:
7134: case UNION_TYPE:
7135: case ENUMERAL_TYPE:
7136: /* Parse error puts this typespec where
7137: a declarator should go. */
7138: error ("declarator name missing");
7139: dname = TYPE_NAME (decl);
7140: if (dname && TREE_CODE (dname) == TYPE_DECL)
7141: dname = DECL_NAME (dname);
7142: name = dname ? IDENTIFIER_POINTER (dname) : "<nameless>";
7143: declspecs = temp_tree_cons (NULL_TREE, decl, declspecs);
7144: decl = NULL_TREE;
7145: break;
7146:
7147: /* C++ extension */
7148: case SCOPE_REF:
7149: {
7150: /* Perform error checking, and convert class names to types.
7151: We may call grokdeclarator multiple times for the same
7152: tree structure, so only do the conversion once. In this
7153: case, we have exactly what we want for `ctype'. */
7154: tree cname = TREE_OPERAND (decl, 0);
7155: if (cname == NULL_TREE)
7156: ctype = NULL_TREE;
7157: /* Can't use IS_AGGR_TYPE because CNAME might not be a type. */
7158: else if (IS_AGGR_TYPE_CODE (TREE_CODE (cname))
7159: || TREE_CODE (cname) == UNINSTANTIATED_P_TYPE)
7160: ctype = cname;
7161: else if (! is_aggr_typedef (cname, 1))
7162: {
7163: TREE_OPERAND (decl, 0) = NULL_TREE;
7164: }
7165: /* Must test TREE_OPERAND (decl, 1), in case user gives
7166: us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
7167: else if (TREE_OPERAND (decl, 1)
7168: && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
7169: {
7170: TREE_OPERAND (decl, 0) = IDENTIFIER_TYPE_VALUE (cname);
7171: }
7172: else if (ctype == NULL_TREE)
7173: {
7174: ctype = IDENTIFIER_TYPE_VALUE (cname);
7175: TREE_OPERAND (decl, 0) = ctype;
7176: }
7177: else if (TREE_COMPLEXITY (decl) == current_class_depth)
7178: TREE_OPERAND (decl, 0) = ctype;
7179: else
7180: {
7181: if (! UNIQUELY_DERIVED_FROM_P (IDENTIFIER_TYPE_VALUE (cname),
7182: ctype))
7183: {
7184: cp_error ("type `%T' is not derived from type `%T'",
7185: IDENTIFIER_TYPE_VALUE (cname), ctype);
7186: TREE_OPERAND (decl, 0) = NULL_TREE;
7187: }
7188: else
7189: {
7190: ctype = IDENTIFIER_TYPE_VALUE (cname);
7191: TREE_OPERAND (decl, 0) = ctype;
7192: }
7193: }
7194:
7195: decl = TREE_OPERAND (decl, 1);
7196: if (ctype)
7197: {
7198: if (TREE_CODE (decl) == IDENTIFIER_NODE
7199: && constructor_name (ctype) == decl)
7200: {
7201: return_type = return_ctor;
7202: ctor_return_type = ctype;
7203: }
7204: else if (TREE_CODE (decl) == BIT_NOT_EXPR
7205: && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
7206: && constructor_name (ctype) == TREE_OPERAND (decl, 0))
7207: {
7208: return_type = return_dtor;
7209: ctor_return_type = ctype;
7210: flags = DTOR_FLAG;
7211: decl = TREE_OPERAND (decl, 0);
7212: }
7213: }
7214: }
7215: break;
7216:
7217: case ERROR_MARK:
7218: decl = NULL_TREE;
7219: break;
7220:
7221: default:
7222: return 0; /* We used to do a 155 abort here. */
7223: }
7224: if (name == NULL)
7225: name = "type name";
7226: }
7227:
7228: /* A function definition's declarator must have the form of
7229: a function declarator. */
7230:
7231: if (funcdef_flag && innermost_code != CALL_EXPR)
7232: return 0;
7233:
7234: /* Anything declared one level down from the top level
7235: must be one of the parameters of a function
7236: (because the body is at least two levels down). */
7237:
7238: /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7239: by not allowing C++ class definitions to specify their parameters
7240: with xdecls (must be spec.d in the parmlist).
7241:
7242: Since we now wait to push a class scope until we are sure that
7243: we are in a legitimate method context, we must set oldcname
7244: explicitly (since current_class_name is not yet alive). */
7245:
7246: if (decl_context == NORMAL
7247: && current_binding_level->level_chain == global_binding_level)
7248: decl_context = PARM;
7249:
7250: /* Look through the decl specs and record which ones appear.
7251: Some typespecs are defined as built-in typenames.
7252: Others, the ones that are modifiers of other types,
7253: are represented by bits in SPECBITS: set the bits for
7254: the modifiers that appear. Storage class keywords are also in SPECBITS.
7255:
7256: If there is a typedef name or a type, store the type in TYPE.
7257: This includes builtin typedefs such as `int'.
7258:
7259: Set EXPLICIT_INT if the type is `int' or `char' and did not
7260: come from a user typedef.
7261:
7262: Set LONGLONG if `long' is mentioned twice.
7263:
7264: For C++, constructors and destructors have their own fast treatment. */
7265:
7266: for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
7267: {
7268: register int i;
7269: register tree id;
7270:
7271: /* Certain parse errors slip through. For example,
7272: `int class;' is not caught by the parser. Try
7273: weakly to recover here. */
7274: if (TREE_CODE (spec) != TREE_LIST)
7275: return 0;
7276:
7277: id = TREE_VALUE (spec);
7278:
7279: if (TREE_CODE (id) == IDENTIFIER_NODE)
7280: {
7281: if (id == ridpointers[(int) RID_INT]
7282: || id == ridpointers[(int) RID_CHAR]
7283: || id == ridpointers[(int) RID_BOOL]
7284: || id == ridpointers[(int) RID_WCHAR])
7285: {
7286: if (type)
7287: error ("extraneous `%T' ignored", id);
7288: else
7289: {
7290: if (id == ridpointers[(int) RID_INT])
7291: explicit_int = 1;
7292: else if (id == ridpointers[(int) RID_CHAR])
7293: explicit_char = 1;
7294: type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
7295: }
7296: goto found;
7297: }
7298: /* C++ aggregate types. */
7299: if (IDENTIFIER_HAS_TYPE_VALUE (id))
7300: {
7301: if (type)
7302: cp_error ("multiple declarations `%T' and `%T'", type, id);
7303: else
7304: type = IDENTIFIER_TYPE_VALUE (id);
7305: goto found;
7306: }
7307:
7308: for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
7309: {
7310: if (ridpointers[i] == id)
7311: {
7312: if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
7313: {
7314: if (pedantic && flag_ansi)
7315: pedwarn ("duplicate `long'");
7316: else if (longlong)
7317: error ("`long long long' is too long for GCC");
7318: else
7319: longlong = 1;
7320: }
7321: else if (RIDBIT_SETP (i, specbits))
7322: pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
7323: RIDBIT_SET (i, specbits);
7324: goto found;
7325: }
7326: }
7327: }
7328: if (type)
7329: error ("two or more data types in declaration of `%s'", name);
7330: else if (TREE_CODE (id) == IDENTIFIER_NODE)
7331: {
7332: register tree t = lookup_name (id, 1);
7333: if (!t || TREE_CODE (t) != TYPE_DECL)
7334: error ("`%s' fails to be a typedef or built in type",
7335: IDENTIFIER_POINTER (id));
7336: else
7337: {
7338: type = TREE_TYPE (t);
7339: typedef_decl = t;
7340: }
7341: }
7342: else if (TREE_CODE (id) != ERROR_MARK)
7343: /* Can't change CLASS nodes into RECORD nodes here! */
7344: type = id;
7345:
7346: found: ;
7347: }
7348:
7349: typedef_type = type;
7350:
7351: /* No type at all: default to `int', and set EXPLICIT_INT
7352: because it was not a user-defined typedef.
7353: Except when we have a `typedef' inside a signature, in
7354: which case the type defaults to `unknown type' and is
7355: instantiated when assigning to a signature pointer or ref. */
7356:
7357: if (type == NULL_TREE
7358: && (RIDBIT_SETP (RID_SIGNED, specbits)
7359: || RIDBIT_SETP (RID_UNSIGNED, specbits)
7360: || RIDBIT_SETP (RID_LONG, specbits)
7361: || RIDBIT_SETP (RID_SHORT, specbits)))
7362: {
7363: /* These imply 'int'. */
7364: type = integer_type_node;
7365: explicit_int = 1;
7366: }
7367:
7368: if (type == NULL_TREE)
7369: {
7370: explicit_int = -1;
7371: if (return_type == return_dtor)
7372: type = void_type_node;
7373: else if (return_type == return_ctor)
7374: type = TYPE_POINTER_TO (ctor_return_type);
7375: else if (return_type == return_conversion)
7376: type = ctor_return_type;
7377: else if (current_class_type
7378: && IS_SIGNATURE (current_class_type)
7379: && (RIDBIT_SETP (RID_TYPEDEF, specbits)
7380: || SIGNATURE_GROKKING_TYPEDEF (current_class_type))
7381: && (decl_context == FIELD || decl_context == NORMAL))
7382: {
7383: explicit_int = 0;
7384: opaque_typedef = 1;
7385: type = copy_node (opaque_type_node);
7386: }
7387: /* access declaration */
7388: else if (decl_context == FIELD && declarator
7389: && TREE_CODE (declarator) == SCOPE_REF)
7390: type = void_type_node;
7391: else
7392: {
7393: if (funcdef_flag)
7394: {
7395: if (warn_return_type
7396: && return_type == return_normal)
7397: /* Save warning until we know what is really going on. */
7398: warn_about_return_type = 1;
7399: }
7400: else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
7401: pedwarn ("ANSI C++ forbids typedef which does not specify a type");
7402: else if (declspecs == NULL_TREE &&
7403: (innermost_code != CALL_EXPR || pedantic))
7404: cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type or storage class",
7405: dname);
7406: type = integer_type_node;
7407: }
7408: }
7409: else if (return_type == return_dtor)
7410: {
7411: error ("return type specification for destructor invalid");
7412: type = void_type_node;
7413: }
7414: else if (return_type == return_ctor)
7415: {
7416: error ("return type specification for constructor invalid");
7417: type = TYPE_POINTER_TO (ctor_return_type);
7418: }
7419: else if (return_type == return_conversion)
7420: {
7421: if (comp_target_types (type, ctor_return_type, 1) == 0)
7422: cp_error ("operator `%T' declared to return `%T'",
7423: ctor_return_type, type);
7424: else
7425: cp_pedwarn ("return type specified for `operator %T'",
7426: ctor_return_type);
7427:
7428: type = ctor_return_type;
7429: }
7430: /* Catch typedefs that only specify a type, like 'typedef int;'. */
7431: else if (RIDBIT_SETP (RID_TYPEDEF, specbits) && declarator == NULL_TREE)
7432: {
7433: /* Template "this is a type" syntax; just ignore for now. */
7434: if (processing_template_defn)
7435: return void_type_node;
7436: }
7437:
7438: ctype = NULL_TREE;
7439:
7440: /* Now process the modifiers that were specified
7441: and check for invalid combinations. */
7442:
7443: /* Long double is a special combination. */
7444:
7445: if (RIDBIT_SETP (RID_LONG, specbits)
7446: && TYPE_MAIN_VARIANT (type) == double_type_node)
7447: {
7448: RIDBIT_RESET (RID_LONG, specbits);
7449: type = build_type_variant (long_double_type_node, TYPE_READONLY (type),
7450: TYPE_VOLATILE (type));
7451: }
7452:
7453: /* Check all other uses of type modifiers. */
7454:
7455: if (RIDBIT_SETP (RID_UNSIGNED, specbits)
7456: || RIDBIT_SETP (RID_SIGNED, specbits)
7457: || RIDBIT_SETP (RID_LONG, specbits)
7458: || RIDBIT_SETP (RID_SHORT, specbits))
7459: {
7460: int ok = 0;
7461:
7462: if (TREE_CODE (type) == REAL_TYPE)
7463: error ("short, signed or unsigned invalid for `%s'", name);
7464: else if (TREE_CODE (type) != INTEGER_TYPE || type == wchar_type_node)
7465: error ("long, short, signed or unsigned invalid for `%s'", name);
7466: else if (RIDBIT_SETP (RID_LONG, specbits)
7467: && RIDBIT_SETP (RID_SHORT, specbits))
7468: error ("long and short specified together for `%s'", name);
7469: else if ((RIDBIT_SETP (RID_LONG, specbits)
7470: || RIDBIT_SETP (RID_SHORT, specbits))
7471: && explicit_char)
7472: error ("long or short specified with char for `%s'", name);
7473: else if ((RIDBIT_SETP (RID_LONG, specbits)
7474: || RIDBIT_SETP (RID_SHORT, specbits))
7475: && TREE_CODE (type) == REAL_TYPE)
7476: error ("long or short specified with floating type for `%s'", name);
7477: else if (RIDBIT_SETP (RID_SIGNED, specbits)
7478: && RIDBIT_SETP (RID_UNSIGNED, specbits))
7479: error ("signed and unsigned given together for `%s'", name);
7480: else
7481: {
7482: ok = 1;
7483: if (!explicit_int && !explicit_char && pedantic)
7484: {
7485: pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
7486: name);
7487: if (flag_pedantic_errors)
7488: ok = 0;
7489: }
7490: }
7491:
7492: /* Discard the type modifiers if they are invalid. */
7493: if (! ok)
7494: {
7495: RIDBIT_RESET (RID_UNSIGNED, specbits);
7496: RIDBIT_RESET (RID_SIGNED, specbits);
7497: RIDBIT_RESET (RID_LONG, specbits);
7498: RIDBIT_RESET (RID_SHORT, specbits);
7499: longlong = 0;
7500: }
7501: }
7502:
7503: /* Decide whether an integer type is signed or not.
7504: Optionally treat bitfields as signed by default. */
7505: if (RIDBIT_SETP (RID_UNSIGNED, specbits)
7506: /* Traditionally, all bitfields are unsigned. */
7507: || (bitfield && flag_traditional)
7508: || (bitfield && ! flag_signed_bitfields
7509: && (explicit_int || explicit_char
7510: /* A typedef for plain `int' without `signed'
7511: can be controlled just like plain `int'. */
7512: || ! (typedef_decl != NULL_TREE
7513: && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7514: && TREE_CODE (type) != ENUMERAL_TYPE
7515: && RIDBIT_NOTSETP (RID_SIGNED, specbits)))
7516: {
7517: if (longlong)
7518: type = long_long_unsigned_type_node;
7519: else if (RIDBIT_SETP (RID_LONG, specbits))
7520: type = long_unsigned_type_node;
7521: else if (RIDBIT_SETP (RID_SHORT, specbits))
7522: type = short_unsigned_type_node;
7523: else if (type == char_type_node)
7524: type = unsigned_char_type_node;
7525: else if (typedef_decl)
7526: type = unsigned_type (type);
7527: else
7528: type = unsigned_type_node;
7529: }
7530: else if (RIDBIT_SETP (RID_SIGNED, specbits)
7531: && type == char_type_node)
7532: type = signed_char_type_node;
7533: else if (longlong)
7534: type = long_long_integer_type_node;
7535: else if (RIDBIT_SETP (RID_LONG, specbits))
7536: type = long_integer_type_node;
7537: else if (RIDBIT_SETP (RID_SHORT, specbits))
7538: type = short_integer_type_node;
7539:
7540: /* Set CONSTP if this declaration is `const', whether by
7541: explicit specification or via a typedef.
7542: Likewise for VOLATILEP. */
7543:
7544: constp = !! RIDBIT_SETP (RID_CONST, specbits) + TYPE_READONLY (type);
7545: volatilep = !! RIDBIT_SETP (RID_VOLATILE, specbits) + TYPE_VOLATILE (type);
7546: staticp = 0;
7547: inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
7548: #if 0
7549: /* This sort of redundancy is blessed in a footnote to the Sep 94 WP. */
7550: if (constp > 1)
7551: warning ("duplicate `const'");
7552: if (volatilep > 1)
7553: warning ("duplicate `volatile'");
7554: #endif
7555: virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
7556:
7557: if (RIDBIT_SETP (RID_STATIC, specbits))
7558: staticp = 1 + (decl_context == FIELD);
7559:
7560: if (virtualp && staticp == 2)
7561: {
7562: cp_error ("member `%D' cannot be declared both virtual and static",
7563: dname);
7564: staticp = 0;
7565: }
7566: friendp = RIDBIT_SETP (RID_FRIEND, specbits);
7567: RIDBIT_RESET (RID_VIRTUAL, specbits);
7568: RIDBIT_RESET (RID_FRIEND, specbits);
7569:
7570: if (RIDBIT_SETP (RID_MUTABLE, specbits))
7571: {
7572: if (decl_context == PARM)
7573: {
7574: error ("non-member `%s' cannot be declared mutable", name);
7575: RIDBIT_RESET (RID_MUTABLE, specbits);
7576: }
7577: else if (friendp || decl_context == TYPENAME)
7578: {
7579: error ("non-object member `%s' cannot be declared mutable", name);
7580: RIDBIT_RESET (RID_MUTABLE, specbits);
7581: }
7582: else if (staticp)
7583: {
7584: error ("static `%s' cannot be declared mutable", name);
7585: RIDBIT_RESET (RID_MUTABLE, specbits);
7586: }
7587: #if 0
7588: if (RIDBIT_SETP (RID_TYPEDEF, specbits))
7589: {
7590: error ("non-object member `%s' cannot be declared mutable", name);
7591: RIDBIT_RESET (RID_MUTABLE, specbits);
7592: }
7593: /* Because local typedefs are parsed twice, we don't want this
7594: message here. */
7595: else if (decl_context != FIELD)
7596: {
7597: error ("non-member `%s' cannot be declared mutable", name);
7598: RIDBIT_RESET (RID_MUTABLE, specbits);
7599: }
7600: #endif
7601: }
7602:
7603: /* Warn if two storage classes are given. Default to `auto'. */
7604:
7605: if (RIDBIT_ANY_SET (specbits))
7606: {
7607: if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
7608: if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
7609: if (decl_context == PARM && nclasses > 0)
7610: error ("storage class specifiers invalid in parameter declarations");
7611: if (RIDBIT_SETP (RID_TYPEDEF, specbits))
7612: {
7613: if (decl_context == PARM)
7614: error ("typedef declaration invalid in parameter declaration");
7615: nclasses++;
7616: }
7617: if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
7618: if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
7619: }
7620:
7621: /* Give error if `virtual' is used outside of class declaration. */
7622: if (virtualp && current_class_name == NULL_TREE)
7623: {
7624: error ("virtual outside class declaration");
7625: virtualp = 0;
7626: }
7627: if (current_class_name == NULL_TREE && RIDBIT_SETP (RID_MUTABLE, specbits))
7628: {
7629: error ("only members can be declared mutable");
7630: RIDBIT_RESET (RID_MUTABLE, specbits);
7631: }
7632:
7633: /* Static anonymous unions are dealt with here. */
7634: if (staticp && decl_context == TYPENAME
7635: && TREE_CODE (declspecs) == TREE_LIST
7636: && TREE_CODE (TREE_VALUE (declspecs)) == UNION_TYPE
7637: && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_VALUE (declspecs))))
7638: decl_context = FIELD;
7639:
7640: /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
7641: is used in a signature member function declaration. */
7642: if (decl_context == FIELD
7643: && IS_SIGNATURE (current_class_type)
7644: && RIDBIT_NOTSETP(RID_TYPEDEF, specbits)
7645: && !SIGNATURE_GROKKING_TYPEDEF (current_class_type))
7646: {
7647: if (constp)
7648: {
7649: error ("`const' specified for signature member function `%s'", name);
7650: constp = 0;
7651: }
7652: if (volatilep)
7653: {
7654: error ("`volatile' specified for signature member function `%s'",
7655: name);
7656: volatilep = 0;
7657: }
7658: if (inlinep)
7659: {
7660: error ("`inline' specified for signature member function `%s'", name);
7661: /* Later, we'll make signature member functions inline. */
7662: inlinep = 0;
7663: }
7664: if (friendp)
7665: {
7666: error ("`friend' declaration in signature definition");
7667: friendp = 0;
7668: }
7669: if (virtualp)
7670: {
7671: error ("`virtual' specified for signature member function `%s'",
7672: name);
7673: /* Later, we'll make signature member functions virtual. */
7674: virtualp = 0;
7675: }
7676: }
7677:
7678: /* Warn about storage classes that are invalid for certain
7679: kinds of declarations (parameters, typenames, etc.). */
7680:
7681: if (nclasses > 1)
7682: error ("multiple storage classes in declaration of `%s'", name);
7683: else if (decl_context != NORMAL && nclasses > 0)
7684: {
7685: if (decl_context == PARM
7686: && (RIDBIT_SETP (RID_REGISTER, specbits)
7687: || RIDBIT_SETP (RID_AUTO, specbits)))
7688: ;
7689: else if (decl_context == FIELD
7690: && RIDBIT_SETP (RID_TYPEDEF, specbits))
7691: {
7692: /* Processing a typedef declaration nested within a class type
7693: definition. */
7694: register tree scanner;
7695: register tree previous_declspec;
7696: tree loc_typedecl;
7697:
7698: if (initialized)
7699: error ("typedef declaration includes an initializer");
7700:
7701: /* To process a class-local typedef declaration, we descend down
7702: the chain of declspecs looking for the `typedef' spec. When
7703: we find it, we replace it with `static', and then recursively
7704: call `grokdeclarator' with the original declarator and with
7705: the newly adjusted declspecs. This call should return a
7706: FIELD_DECL node with the TREE_TYPE (and other parts) set
7707: appropriately. We can then just change the TREE_CODE on that
7708: from FIELD_DECL to TYPE_DECL and we're done. */
7709:
7710: for (previous_declspec = NULL_TREE, scanner = declspecs;
7711: scanner;
7712: previous_declspec = scanner, scanner = TREE_CHAIN (scanner))
7713: {
7714: if (TREE_VALUE (scanner) == ridpointers[(int) RID_TYPEDEF])
7715: break;
7716: }
7717:
7718: if (previous_declspec)
7719: TREE_CHAIN (previous_declspec) = TREE_CHAIN (scanner);
7720: else
7721: declspecs = TREE_CHAIN (scanner);
7722:
7723: declspecs = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC],
7724: declspecs);
7725:
7726: /* In the recursive call to grokdeclarator we need to know
7727: whether we are working on a signature-local typedef. */
7728: if (IS_SIGNATURE (current_class_type))
7729: SIGNATURE_GROKKING_TYPEDEF (current_class_type) = 1;
7730:
7731: loc_typedecl =
7732: grokdeclarator (declarator, declspecs, FIELD, 0, NULL_TREE);
7733:
7734: if (previous_declspec)
7735: TREE_CHAIN (previous_declspec) = scanner;
7736:
7737: if (loc_typedecl != error_mark_node)
7738: {
7739: register int i = sizeof (struct lang_decl_flags) / sizeof (int);
7740: register int *pi;
7741:
7742: TREE_SET_CODE (loc_typedecl, TYPE_DECL);
7743: /* This is the same field as DECL_ARGUMENTS, which is set for
7744: function typedefs by the above grokdeclarator. */
7745: DECL_NESTED_TYPENAME (loc_typedecl) = 0;
7746:
7747: pi = (int *) permalloc (sizeof (struct lang_decl_flags));
7748: while (i > 0)
7749: pi[--i] = 0;
7750: DECL_LANG_SPECIFIC (loc_typedecl) = (struct lang_decl *) pi;
7751: }
7752:
7753: if (IS_SIGNATURE (current_class_type))
7754: {
7755: SIGNATURE_GROKKING_TYPEDEF (current_class_type) = 0;
7756: if (loc_typedecl != error_mark_node && opaque_typedef)
7757: SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type) = 1;
7758: }
7759:
7760: return loc_typedecl;
7761: }
7762: else if (decl_context == FIELD
7763: && (! IS_SIGNATURE (current_class_type)
7764: || SIGNATURE_GROKKING_TYPEDEF (current_class_type))
7765: /* C++ allows static class elements */
7766: && RIDBIT_SETP (RID_STATIC, specbits))
7767: /* C++ also allows inlines and signed and unsigned elements,
7768: but in those cases we don't come in here. */
7769: ;
7770: else
7771: {
7772: if (decl_context == FIELD)
7773: {
7774: tree tmp = TREE_OPERAND (declarator, 0);
7775: register int op = IDENTIFIER_OPNAME_P (tmp);
7776: error ("storage class specified for %s `%s'",
7777: IS_SIGNATURE (current_class_type)
7778: ? (op
7779: ? "signature member operator"
7780: : "signature member function")
7781: : (op ? "member operator" : "structure field"),
7782: op ? operator_name_string (tmp) : name);
7783: }
7784: else
7785: error ((decl_context == PARM
7786: ? "storage class specified for parameter `%s'"
7787: : "storage class specified for typename"), name);
7788: RIDBIT_RESET (RID_REGISTER, specbits);
7789: RIDBIT_RESET (RID_AUTO, specbits);
7790: RIDBIT_RESET (RID_EXTERN, specbits);
7791:
7792: if (decl_context == FIELD && IS_SIGNATURE (current_class_type))
7793: {
7794: RIDBIT_RESET (RID_STATIC, specbits);
7795: staticp = 0;
7796: }
7797: }
7798: }
7799: else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
7800: {
7801: if (current_binding_level == global_binding_level)
7802: {
7803: /* It's common practice (and completely legal) to have a const
7804: be initialized and declared extern. */
7805: if (! constp)
7806: warning ("`%s' initialized and declared `extern'", name);
7807: }
7808: else
7809: error ("`%s' has both `extern' and initializer", name);
7810: }
7811: else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
7812: && current_binding_level != global_binding_level)
7813: error ("nested function `%s' declared `extern'", name);
7814: else if (current_binding_level == global_binding_level)
7815: {
7816: if (RIDBIT_SETP (RID_AUTO, specbits))
7817: error ("top-level declaration of `%s' specifies `auto'", name);
7818: #if 0
7819: if (RIDBIT_SETP (RID_REGISTER, specbits))
7820: error ("top-level declaration of `%s' specifies `register'", name);
7821: #endif
7822: #if 0
7823: /* I'm not sure under what circumstances we should turn
7824: on the extern bit, and under what circumstances we should
7825: warn if other bits are turned on. */
7826: if (decl_context == NORMAL
7827: && RIDBIT_NOSETP (RID_EXTERN, specbits)
7828: && ! root_lang_context_p ())
7829: {
7830: RIDBIT_SET (RID_EXTERN, specbits);
7831: }
7832: #endif
7833: }
7834:
7835: /* Now figure out the structure of the declarator proper.
7836: Descend through it, creating more complex types, until we reach
7837: the declared identifier (or NULL_TREE, in an absolute declarator). */
7838:
7839: while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
7840: {
7841: /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
7842: an INDIRECT_REF (for *...),
7843: a CALL_EXPR (for ...(...)),
7844: an identifier (for the name being declared)
7845: or a null pointer (for the place in an absolute declarator
7846: where the name was omitted).
7847: For the last two cases, we have just exited the loop.
7848:
7849: For C++ it could also be
7850: a SCOPE_REF (for class :: ...). In this case, we have converted
7851: sensible names to types, and those are the values we use to
7852: qualify the member name.
7853: an ADDR_EXPR (for &...),
7854: a BIT_NOT_EXPR (for destructors)
7855:
7856: At this point, TYPE is the type of elements of an array,
7857: or for a function to return, or for a pointer to point to.
7858: After this sequence of ifs, TYPE is the type of the
7859: array or function or pointer, and DECLARATOR has had its
7860: outermost layer removed. */
7861:
7862: if (TREE_CODE (type) == ERROR_MARK)
7863: {
7864: if (TREE_CODE (declarator) == SCOPE_REF)
7865: declarator = TREE_OPERAND (declarator, 1);
7866: else
7867: declarator = TREE_OPERAND (declarator, 0);
7868: continue;
7869: }
7870: if (quals != NULL_TREE
7871: && (declarator == NULL_TREE
7872: || TREE_CODE (declarator) != SCOPE_REF))
7873: {
7874: if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
7875: ctype = TYPE_METHOD_BASETYPE (type);
7876: if (ctype != NULL_TREE)
7877: {
7878: #if 0 /* not yet, should get fixed properly later */
7879: tree dummy = make_type_decl (NULL_TREE, type);
7880: #else
7881: tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
7882: #endif
7883: ctype = grok_method_quals (ctype, dummy, quals);
7884: type = TREE_TYPE (dummy);
7885: quals = NULL_TREE;
7886: }
7887: }
7888: switch (TREE_CODE (declarator))
7889: {
7890: case ARRAY_REF:
7891: {
7892: register tree itype = NULL_TREE;
7893: register tree size = TREE_OPERAND (declarator, 1);
7894:
7895: declarator = TREE_OPERAND (declarator, 0);
7896:
7897: /* Check for some types that there cannot be arrays of. */
7898:
7899: if (TYPE_MAIN_VARIANT (type) == void_type_node)
7900: {
7901: cp_error ("declaration of `%D' as array of voids", dname);
7902: type = error_mark_node;
7903: }
7904:
7905: if (TREE_CODE (type) == FUNCTION_TYPE)
7906: {
7907: cp_error ("declaration of `%D' as array of functions", dname);
7908: type = error_mark_node;
7909: }
7910:
7911: /* ARM $8.4.3: Since you can't have a pointer to a reference,
7912: you can't have arrays of references. If we allowed them,
7913: then we'd be saying x[i] is legal for an array x, but
7914: then you'd have to ask: what does `*(x + i)' mean? */
7915: if (TREE_CODE (type) == REFERENCE_TYPE)
7916: {
7917: if (decl_context == TYPENAME)
7918: cp_error ("cannot make arrays of references");
7919: else
7920: cp_error ("declaration of `%D' as array of references",
7921: dname);
7922: type = error_mark_node;
7923: }
7924:
7925: if (TREE_CODE (type) == OFFSET_TYPE)
7926: {
7927: cp_error ("declaration of `%D' as array of data members",
7928: dname);
7929: type = error_mark_node;
7930: }
7931:
7932: if (TREE_CODE (type) == METHOD_TYPE)
7933: {
7934: cp_error ("declaration of `%D' as array of function members",
7935: dname);
7936: type = error_mark_node;
7937: }
7938:
7939: if (size == error_mark_node)
7940: type = error_mark_node;
7941:
7942: if (type == error_mark_node)
7943: continue;
7944:
7945: if (size)
7946: {
7947: /* Must suspend_momentary here because the index
7948: type may need to live until the end of the function.
7949: For example, it is used in the declaration of a
7950: variable which requires destructing at the end of
7951: the function; then build_vec_delete will need this
7952: value. */
7953: int yes = suspend_momentary ();
7954: /* might be a cast */
7955: if (TREE_CODE (size) == NOP_EXPR
7956: && TREE_TYPE (size) == TREE_TYPE (TREE_OPERAND (size, 0)))
7957: size = TREE_OPERAND (size, 0);
7958:
7959: /* If this is a template parameter, it'll be constant, but
7960: we don't know what the value is yet. */
7961: if (TREE_CODE (size) == TEMPLATE_CONST_PARM)
7962: goto dont_grok_size;
7963:
7964: if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
7965: && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
7966: {
7967: cp_error ("size of array `%D' has non-integer type",
7968: dname);
7969: size = integer_one_node;
7970: }
7971: if (TREE_READONLY_DECL_P (size))
7972: size = decl_constant_value (size);
7973: if (flag_ansi && integer_zerop (size))
7974: cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname);
7975: if (TREE_CONSTANT (size))
7976: {
7977: constant_expression_warning (size);
7978: if (INT_CST_LT (size, integer_zero_node))
7979: {
7980: cp_error ("size of array `%D' is negative", dname);
7981: size = integer_one_node;
7982: }
7983: itype = build_index_type (size_binop (MINUS_EXPR, size,
7984: integer_one_node));
7985: }
7986: else
7987: {
7988: if (flag_ansi)
7989: {
7990: if (dname)
7991: cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
7992: dname);
7993: else
7994: cp_pedwarn ("ANSI C++ forbids variable-size array");
7995: }
7996: dont_grok_size:
7997: itype =
7998: build_binary_op (MINUS_EXPR, size, integer_one_node, 1);
7999: /* Make sure the array size remains visibly nonconstant
8000: even if it is (eg) a const variable with known value. */
8001: size_varies = 1;
8002: itype = variable_size (itype);
8003: itype = build_index_type (itype);
8004: }
8005: resume_momentary (yes);
8006: }
8007:
8008: /* Build the array type itself, then merge any constancy or
8009: volatility into the target type. We must do it in this order
8010: to ensure that the TYPE_MAIN_VARIANT field of the array type
8011: is set correctly. */
8012:
8013: type = build_cplus_array_type (type, itype);
8014: if (constp || volatilep)
8015: type = cp_build_type_variant (type, constp, volatilep);
8016:
8017: ctype = NULL_TREE;
8018: }
8019: break;
8020:
8021: case CALL_EXPR:
8022: {
8023: tree arg_types;
8024: int funcdecl_p;
8025: tree inner_parms = TREE_OPERAND (declarator, 1);
8026: tree inner_decl = TREE_OPERAND (declarator, 0);
8027:
8028: /* Declaring a function type.
8029: Make sure we have a valid type for the function to return. */
8030: #if 0
8031: /* Is this an error? Should they be merged into TYPE here? */
8032: if (pedantic && (constp || volatilep))
8033: pedwarn ("function declared to return const or volatile result");
8034: #else
8035: /* Merge any constancy or volatility into the function return
8036: type. */
8037:
8038: if (constp || volatilep)
8039: {
8040: type = cp_build_type_variant (type, constp, volatilep);
8041: if (IS_AGGR_TYPE (type))
8042: build_pointer_type (type);
8043: constp = 0;
8044: volatilep = 0;
8045: }
8046: #endif
8047:
8048: /* Warn about some types functions can't return. */
8049:
8050: if (TREE_CODE (type) == FUNCTION_TYPE)
8051: {
8052: error ("`%s' declared as function returning a function", name);
8053: type = integer_type_node;
8054: }
8055: if (TREE_CODE (type) == ARRAY_TYPE)
8056: {
8057: error ("`%s' declared as function returning an array", name);
8058: type = integer_type_node;
8059: }
8060:
8061: if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
8062: inner_decl = TREE_OPERAND (inner_decl, 1);
8063:
8064: /* Say it's a definition only for the CALL_EXPR
8065: closest to the identifier. */
8066: funcdecl_p =
8067: inner_decl && TREE_CODE (inner_decl) == IDENTIFIER_NODE;
8068:
8069: if (ctype == NULL_TREE
8070: && decl_context == FIELD
8071: && funcdecl_p
8072: && (friendp == 0 || dname == current_class_name))
8073: ctype = current_class_type;
8074:
8075: if (ctype && return_type == return_conversion)
8076: TYPE_HAS_CONVERSION (ctype) = 1;
8077: if (ctype && constructor_name (ctype) == dname)
8078: {
8079: /* We are within a class's scope. If our declarator name
8080: is the same as the class name, and we are defining
8081: a function, then it is a constructor/destructor, and
8082: therefore returns a void type. */
8083:
8084: if (flags == DTOR_FLAG)
8085: {
8086: /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
8087: not be declared const or volatile. A destructor
8088: may not be static. */
8089: if (staticp == 2)
8090: error ("destructor cannot be static member function");
8091: if (TYPE_READONLY (type))
8092: {
8093: error ("destructors cannot be declared `const'");
8094: return void_type_node;
8095: }
8096: if (TYPE_VOLATILE (type))
8097: {
8098: error ("destructors cannot be declared `volatile'");
8099: return void_type_node;
8100: }
8101: if (decl_context == FIELD)
8102: {
8103: if (! member_function_or_else (ctype, current_class_type,
8104: "destructor for alien class `%s' cannot be a member"))
8105: return void_type_node;
8106: }
8107: }
8108: else /* it's a constructor. */
8109: {
8110: /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
8111: not be declared const or volatile. A constructor may
8112: not be virtual. A constructor may not be static. */
8113: if (staticp == 2)
8114: error ("constructor cannot be static member function");
8115: if (virtualp)
8116: {
8117: pedwarn ("constructors cannot be declared virtual");
8118: virtualp = 0;
8119: }
8120: if (TYPE_READONLY (type))
8121: {
8122: error ("constructors cannot be declared `const'");
8123: return void_type_node;
8124: }
8125: if (TYPE_VOLATILE (type))
8126: {
8127: error ("constructors cannot be declared `volatile'");
8128: return void_type_node;
8129: }
8130: {
8131: RID_BIT_TYPE tmp_bits;
8132: bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof(RID_BIT_TYPE));
8133: RIDBIT_RESET (RID_INLINE, tmp_bits);
8134: RIDBIT_RESET (RID_STATIC, tmp_bits);
8135: if (RIDBIT_ANY_SET (tmp_bits))
8136: error ("return value type specifier for constructor ignored");
8137: }
8138: type = TYPE_POINTER_TO (ctype);
8139: if (decl_context == FIELD &&
8140: IS_SIGNATURE (current_class_type))
8141: {
8142: error ("constructor not allowed in signature");
8143: return void_type_node;
8144: }
8145: else if (decl_context == FIELD)
8146: {
8147: if (! member_function_or_else (ctype, current_class_type,
8148: "constructor for alien class `%s' cannot be member"))
8149: return void_type_node;
8150: TYPE_HAS_CONSTRUCTOR (ctype) = 1;
8151: if (return_type != return_ctor)
8152: return NULL_TREE;
8153: }
8154: }
8155: if (decl_context == FIELD)
8156: staticp = 0;
8157: }
8158: else if (friendp && virtualp)
8159: {
8160: /* Cannot be both friend and virtual. */
8161: error ("virtual functions cannot be friends");
8162: RIDBIT_RESET (RID_FRIEND, specbits);
8163: friendp = 0;
8164: }
8165:
8166: if (decl_context == NORMAL && friendp)
8167: error ("friend declaration not in class definition");
8168:
8169: /* Pick up type qualifiers which should be applied to `this'. */
8170: quals = TREE_OPERAND (declarator, 2);
8171:
8172: /* Traditionally, declaring return type float means double. */
8173:
8174: if (flag_traditional
8175: && TYPE_MAIN_VARIANT (type) == float_type_node)
8176: {
8177: type = build_type_variant (double_type_node,
8178: TYPE_READONLY (type),
8179: TYPE_VOLATILE (type));
8180: }
8181:
8182: /* Construct the function type and go to the next
8183: inner layer of declarator. */
8184:
8185: declarator = TREE_OPERAND (declarator, 0);
8186:
8187: /* FIXME: This is where default args should be fully
8188: processed. */
8189:
8190: arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
8191:
8192: if (declarator)
8193: {
8194: /* Get past destructors, etc.
8195: We know we have one because FLAGS will be non-zero.
8196:
8197: Complain about improper parameter lists here. */
8198: if (TREE_CODE (declarator) == BIT_NOT_EXPR)
8199: {
8200: declarator = TREE_OPERAND (declarator, 0);
8201:
8202: if (strict_prototype == 0 && arg_types == NULL_TREE)
8203: arg_types = void_list_node;
8204: else if (arg_types == NULL_TREE
8205: || arg_types != void_list_node)
8206: {
8207: error ("destructors cannot be specified with parameters");
8208: arg_types = void_list_node;
8209: }
8210: }
8211: }
8212:
8213: /* ANSI seems to say that `const int foo ();'
8214: does not make the function foo const. */
8215: type = build_function_type (type,
8216: flag_traditional ? 0 : arg_types);
8217: }
8218: break;
8219:
8220: case ADDR_EXPR:
8221: case INDIRECT_REF:
8222: /* Filter out pointers-to-references and references-to-references.
8223: We can get these if a TYPE_DECL is used. */
8224:
8225: if (TREE_CODE (type) == REFERENCE_TYPE)
8226: {
8227: error ("cannot declare %s to references",
8228: TREE_CODE (declarator) == ADDR_EXPR
8229: ? "references" : "pointers");
8230: declarator = TREE_OPERAND (declarator, 0);
8231: continue;
8232: }
8233:
8234: /* Merge any constancy or volatility into the target type
8235: for the pointer. */
8236:
8237: if (constp || volatilep)
8238: {
8239: /* A const or volatile signature pointer/reference is
8240: pointing to a const or volatile object, i.e., the
8241: `optr' is const or volatile, respectively, not the
8242: signature pointer/reference itself. */
8243: if (! IS_SIGNATURE (type))
8244: {
8245: type = cp_build_type_variant (type, constp, volatilep);
8246: if (IS_AGGR_TYPE (type))
8247: build_pointer_type (type);
8248: constp = 0;
8249: volatilep = 0;
8250: }
8251: }
8252:
8253: if (IS_SIGNATURE (type))
8254: {
8255: if (TREE_CODE (declarator) == ADDR_EXPR)
8256: {
8257: if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
8258: && TYPE_SIZE (type))
8259: cp_warning ("empty signature `%T' used in signature reference declaration",
8260: type);
8261: #if 0
8262: type = build_signature_reference_type (type,
8263: constp, volatilep);
8264: #else
8265: sorry ("signature reference");
8266: return NULL_TREE;
8267: #endif
8268: }
8269: else
8270: {
8271: if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
8272: && TYPE_SIZE (type))
8273: cp_warning ("empty signature `%T' used in signature pointer declaration",
8274: type);
8275: type = build_signature_pointer_type (type,
8276: constp, volatilep);
8277: }
8278: constp = 0;
8279: volatilep = 0;
8280: }
8281: else if (TREE_CODE (declarator) == ADDR_EXPR)
8282: {
8283: if (TREE_CODE (type) == FUNCTION_TYPE)
8284: {
8285: error ("cannot declare references to functions; use pointer to function instead");
8286: type = build_pointer_type (type);
8287: }
8288: else
8289: {
8290: if (TYPE_MAIN_VARIANT (type) == void_type_node)
8291: error ("invalid type: `void &'");
8292: else
8293: type = build_reference_type (type);
8294: }
8295: }
8296: else if (TREE_CODE (type) == METHOD_TYPE)
8297: {
8298: type = build_ptrmemfunc_type (build_pointer_type (type));
8299: }
8300: else
8301: type = build_pointer_type (type);
8302:
8303: /* Process a list of type modifier keywords (such as
8304: const or volatile) that were given inside the `*' or `&'. */
8305:
8306: if (TREE_TYPE (declarator))
8307: {
8308: register tree typemodlist;
8309: int erred = 0;
8310: for (typemodlist = TREE_TYPE (declarator); typemodlist;
8311: typemodlist = TREE_CHAIN (typemodlist))
8312: {
8313: if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
8314: constp++;
8315: else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
8316: volatilep++;
8317: else if (!erred)
8318: {
8319: erred = 1;
8320: error ("invalid type modifier within %s declarator",
8321: TREE_CODE (declarator) == ADDR_EXPR
8322: ? "reference" : "pointer");
8323: }
8324: }
8325: if (constp > 1)
8326: pedwarn ("duplicate `const'");
8327: if (volatilep > 1)
8328: pedwarn ("duplicate `volatile'");
8329: if (TREE_CODE (declarator) == ADDR_EXPR
8330: && (constp || volatilep))
8331: {
8332: if (constp)
8333: warning ("discarding `const' applied to a reference");
8334: if (volatilep)
8335: warning ("discarding `volatile' applied to a reference");
8336: constp = volatilep = 0;
8337: }
8338: }
8339: declarator = TREE_OPERAND (declarator, 0);
8340: ctype = NULL_TREE;
8341: break;
8342:
8343: case SCOPE_REF:
8344: {
8345: /* We have converted type names to NULL_TREE if the
8346: name was bogus, or to a _TYPE node, if not.
8347:
8348: The variable CTYPE holds the type we will ultimately
8349: resolve to. The code here just needs to build
8350: up appropriate member types. */
8351: tree sname = TREE_OPERAND (declarator, 1);
8352: /* Destructors can have their visibilities changed as well. */
8353: if (TREE_CODE (sname) == BIT_NOT_EXPR)
8354: sname = TREE_OPERAND (sname, 0);
8355:
8356: if (TREE_COMPLEXITY (declarator) == 0)
8357: /* This needs to be here, in case we are called
8358: multiple times. */ ;
8359: else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
8360: /* don't fall out into global scope. Hides real bug? --eichin */ ;
8361: else if (TREE_COMPLEXITY (declarator) == current_class_depth)
8362: {
8363: /* This pop_nested_class corresponds to the
8364: push_nested_class used to push into class scope for
8365: parsing the argument list of a function decl, in
8366: qualified_id. */
8367: pop_nested_class (1);
8368: TREE_COMPLEXITY (declarator) = current_class_depth;
8369: }
8370: else
8371: my_friendly_abort (16);
8372:
8373: if (TREE_OPERAND (declarator, 0) == NULL_TREE)
8374: {
8375: /* We had a reference to a global decl, or
8376: perhaps we were given a non-aggregate typedef,
8377: in which case we cleared this out, and should just
8378: keep going as though it wasn't there. */
8379: declarator = sname;
8380: continue;
8381: }
8382: ctype = TREE_OPERAND (declarator, 0);
8383:
8384: if (sname == NULL_TREE)
8385: goto done_scoping;
8386:
8387: if (TREE_CODE (sname) == IDENTIFIER_NODE)
8388: {
8389: /* This is the `standard' use of the scoping operator:
8390: basetype :: member . */
8391:
8392: if (TREE_CODE (type) == FUNCTION_TYPE)
8393: {
8394: if (current_class_type == NULL_TREE
8395: || TYPE_MAIN_VARIANT (ctype) == current_class_type
8396: || friendp)
8397: type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
8398: TREE_TYPE (type), TYPE_ARG_TYPES (type));
8399: else
8400: {
8401: cp_error ("cannot declare member function `%T::%s' within `%T'",
8402: ctype, name, current_class_type);
8403: return void_type_node;
8404: }
8405: }
8406: else if (TYPE_MAIN_VARIANT (ctype) == current_class_type)
8407: {
8408: if (extra_warnings)
8409: cp_warning ("redundant qualification `%T' on member `%s' ignored",
8410: ctype, name);
8411: type = build_offset_type (ctype, type);
8412: }
8413: else if (TYPE_SIZE (ctype) != NULL_TREE
8414: || (RIDBIT_SETP (RID_TYPEDEF, specbits)))
8415: {
8416: tree t;
8417: /* have to move this code elsewhere in this function.
8418: this code is used for i.e., typedef int A::M; M *pm; */
8419:
8420: if (explicit_int == -1 && decl_context == FIELD
8421: && funcdef_flag == 0)
8422: {
8423: /* The code in here should only be used to build
8424: stuff that will be grokked as access decls. */
8425: t = lookup_field (ctype, sname, 0, 0);
8426: if (t)
8427: {
8428: t = build_lang_field_decl (FIELD_DECL, build_nt (SCOPE_REF, ctype, t), type);
8429: DECL_INITIAL (t) = init;
8430: return t;
8431: }
8432: /* No such field, try member functions. */
8433: t = lookup_fnfields (TYPE_BINFO (ctype), sname, 0);
8434: if (t)
8435: {
8436: if (flags == DTOR_FLAG)
8437: t = TREE_VALUE (t);
8438: else if (CLASSTYPE_METHOD_VEC (ctype)
8439: && TREE_VALUE (t) == TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype), 0))
8440: {
8441: /* Don't include destructor with constructors. */
8442: t = DECL_CHAIN (TREE_VALUE (t));
8443: if (t == NULL_TREE)
8444: error ("class `%s' does not have any constructors", IDENTIFIER_POINTER (sname));
8445: t = build_tree_list (NULL_TREE, t);
8446: }
8447: t = build_lang_field_decl (FIELD_DECL, build_nt (SCOPE_REF, ctype, t), type);
8448: DECL_INITIAL (t) = init;
8449: return t;
8450: }
8451:
8452: cp_error
8453: ("field `%D' is not a member of structure `%T'",
8454: sname, ctype);
8455: }
8456:
8457: if (current_class_type)
8458: {
8459: if (TYPE_MAIN_VARIANT (ctype) != current_class_type)
8460: {
8461: cp_error ("cannot declare member `%T::%s' within `%T'",
8462: ctype, name, current_class_type);
8463: return void_type_node;
8464: }
8465: else if (extra_warnings)
8466: cp_warning ("extra qualification `%T' on member `%s' ignored",
8467: ctype, name);
8468: }
8469: type = build_offset_type (ctype, type);
8470: }
8471: else if (uses_template_parms (ctype))
8472: {
8473: enum tree_code c;
8474: if (TREE_CODE (type) == FUNCTION_TYPE)
8475: {
8476: type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
8477: TREE_TYPE (type),
8478: TYPE_ARG_TYPES (type));
8479: c = FUNCTION_DECL;
8480: }
8481: }
8482: else
8483: {
8484: cp_error ("structure `%T' not yet defined", ctype);
8485: return error_mark_node;
8486: }
8487:
8488: declarator = sname;
8489: }
8490: else if (TREE_CODE (sname) == SCOPE_REF)
8491: my_friendly_abort (17);
8492: else
8493: {
8494: done_scoping:
8495: declarator = TREE_OPERAND (declarator, 1);
8496: if (declarator && TREE_CODE (declarator) == CALL_EXPR)
8497: /* In this case, we will deal with it later. */
8498: ;
8499: else
8500: {
8501: if (TREE_CODE (type) == FUNCTION_TYPE)
8502: type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep), TREE_TYPE (type), TYPE_ARG_TYPES (type));
8503: else
8504: type = build_offset_type (ctype, type);
8505: }
8506: }
8507: }
8508: break;
8509:
8510: case BIT_NOT_EXPR:
8511: declarator = TREE_OPERAND (declarator, 0);
8512: break;
8513:
8514: case RECORD_TYPE:
8515: case UNION_TYPE:
8516: case ENUMERAL_TYPE:
8517: declarator = NULL_TREE;
8518: break;
8519:
8520: case ERROR_MARK:
8521: declarator = NULL_TREE;
8522: break;
8523:
8524: default:
8525: my_friendly_abort (158);
8526: }
8527: }
8528:
8529: /* Now TYPE has the actual type. */
8530:
8531: /* If this is declaring a typedef name, return a TYPE_DECL. */
8532:
8533: if (RIDBIT_SETP (RID_TYPEDEF, specbits))
8534: {
8535: tree decl;
8536:
8537: /* Note that the grammar rejects storage classes
8538: in typenames, fields or parameters. */
8539: if (constp || volatilep)
8540: type = cp_build_type_variant (type, constp, volatilep);
8541:
8542: /* If the user declares "struct {...} foo" then `foo' will have
8543: an anonymous name. Fill that name in now. Nothing can
8544: refer to it, so nothing needs know about the name change.
8545: The TYPE_NAME field was filled in by build_struct_xref. */
8546: if (type != error_mark_node
8547: && TYPE_NAME (type)
8548: && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8549: && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
8550: {
8551: /* replace the anonymous name with the real name everywhere. */
8552: lookup_tag_reverse (type, declarator);
8553: TYPE_IDENTIFIER (type) = declarator;
8554:
8555: if (TYPE_LANG_SPECIFIC (type))
8556: TYPE_WAS_ANONYMOUS (type) = 1;
8557:
8558: {
8559: tree d = TYPE_NAME (type), c = DECL_CONTEXT (d);
8560:
8561: if (!c)
8562: set_nested_typename (d, 0, declarator, type);
8563: else if (TREE_CODE (c) == FUNCTION_DECL)
8564: set_nested_typename (d, DECL_ASSEMBLER_NAME (c),
8565: declarator, type);
8566: else
8567: set_nested_typename (d, TYPE_NESTED_NAME (c), declarator, type);
8568: }
8569: }
8570:
8571: #if 0 /* not yet, should get fixed properly later */
8572: decl = make_type_decl (declarator, type);
8573: #else
8574: decl = build_decl (TYPE_DECL, declarator, type);
8575: #endif
8576: if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
8577: {
8578: cp_error_at ("typedef name may not be class-qualified", decl);
8579: return NULL_TREE;
8580: }
8581: else if (quals)
8582: {
8583: if (ctype == NULL_TREE)
8584: {
8585: if (TREE_CODE (type) != METHOD_TYPE)
8586: cp_error_at ("invalid type qualifier for non-method type", decl);
8587: else
8588: ctype = TYPE_METHOD_BASETYPE (type);
8589: }
8590: if (ctype != NULL_TREE)
8591: grok_method_quals (ctype, decl, quals);
8592: }
8593:
8594: if (RIDBIT_SETP (RID_SIGNED, specbits)
8595: || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8596: C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8597:
8598: if (RIDBIT_SETP (RID_MUTABLE, specbits))
8599: {
8600: error ("non-object member `%s' cannot be declared mutable", name);
8601: }
8602:
8603: return decl;
8604: }
8605:
8606: /* Detect the case of an array type of unspecified size
8607: which came, as such, direct from a typedef name.
8608: We must copy the type, so that each identifier gets
8609: a distinct type, so that each identifier's size can be
8610: controlled separately by its own initializer. */
8611:
8612: if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
8613: && TYPE_DOMAIN (type) == NULL_TREE)
8614: {
8615: type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
8616: }
8617:
8618: /* If this is a type name (such as, in a cast or sizeof),
8619: compute the type and return it now. */
8620:
8621: if (decl_context == TYPENAME)
8622: {
8623: /* Note that the grammar rejects storage classes
8624: in typenames, fields or parameters. */
8625: if (constp || volatilep)
8626: if (IS_SIGNATURE (type))
8627: error ("`const' or `volatile' specified with signature type");
8628: else
8629: type = cp_build_type_variant (type, constp, volatilep);
8630:
8631: /* Special case: "friend class foo" looks like a TYPENAME context. */
8632: if (friendp)
8633: {
8634: /* A friendly class? */
8635: if (current_class_type)
8636: make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
8637: else
8638: error("trying to make class `%s' a friend of global scope",
8639: TYPE_NAME_STRING (type));
8640: type = void_type_node;
8641: }
8642: else if (quals)
8643: {
8644: #if 0 /* not yet, should get fixed properly later */
8645: tree dummy = make_type_decl (declarator, type);
8646: #else
8647: tree dummy = build_decl (TYPE_DECL, declarator, type);
8648: #endif
8649: if (ctype == NULL_TREE)
8650: {
8651: my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
8652: ctype = TYPE_METHOD_BASETYPE (type);
8653: }
8654: grok_method_quals (ctype, dummy, quals);
8655: type = TREE_TYPE (dummy);
8656: }
8657:
8658: return type;
8659: }
8660: else if (declarator == NULL_TREE && decl_context != PARM
8661: && TREE_CODE (type) != UNION_TYPE
8662: && ! bitfield)
8663: {
8664: cp_error ("abstract declarator `%T' used as declaration", type);
8665: declarator = make_anon_name ();
8666: }
8667:
8668: /* `void' at top level (not within pointer)
8669: is allowed only in typedefs or type names.
8670: We don't complain about parms either, but that is because
8671: a better error message can be made later. */
8672:
8673: if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM)
8674: {
8675: if (TREE_CODE (declarator) == IDENTIFIER_NODE)
8676: {
8677: if (IDENTIFIER_OPNAME_P (declarator))
8678: #if 0 /* How could this happen? */
8679: error ("operator `%s' declared void",
8680: operator_name_string (declarator));
8681: #else
8682: my_friendly_abort (356);
8683: #endif
8684: else
8685: error ("variable or field `%s' declared void", name);
8686: }
8687: else
8688: error ("variable or field declared void");
8689: type = integer_type_node;
8690: }
8691:
8692: /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8693: or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8694:
8695: {
8696: register tree decl;
8697:
8698: if (decl_context == PARM)
8699: {
8700: if (ctype)
8701: error ("cannot use `::' in parameter declaration");
8702:
8703: /* A parameter declared as an array of T is really a pointer to T.
8704: One declared as a function is really a pointer to a function.
8705: One declared as a member is really a pointer to member. */
8706:
8707: if (TREE_CODE (type) == ARRAY_TYPE)
8708: {
8709: /* Transfer const-ness of array into that of type pointed to. */
8710: type = build_pointer_type
8711: (cp_build_type_variant (TREE_TYPE (type), constp, volatilep));
8712: volatilep = constp = 0;
8713: }
8714: else if (TREE_CODE (type) == FUNCTION_TYPE)
8715: type = build_pointer_type (type);
8716: else if (TREE_CODE (type) == OFFSET_TYPE)
8717: type = build_pointer_type (type);
8718:
8719: decl = build_decl (PARM_DECL, declarator, type);
8720:
8721: bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
8722: inlinep, friendp, raises != NULL_TREE);
8723: if (current_class_type
8724: && IS_SIGNATURE (current_class_type))
8725: {
8726: if (inlinep)
8727: error ("parameter of signature member function declared `inline'");
8728: if (RIDBIT_SETP (RID_AUTO, specbits))
8729: error ("parameter of signature member function declared `auto'");
8730: if (RIDBIT_SETP (RID_REGISTER, specbits))
8731: error ("parameter of signature member function declared `register'");
8732: }
8733:
8734: /* Compute the type actually passed in the parmlist,
8735: for the case where there is no prototype.
8736: (For example, shorts and chars are passed as ints.)
8737: When there is a prototype, this is overridden later. */
8738:
8739: DECL_ARG_TYPE (decl) = type_promotes_to (type);
8740: }
8741: else if (decl_context == FIELD)
8742: {
8743: if (type == error_mark_node)
8744: {
8745: /* Happens when declaring arrays of sizes which
8746: are error_mark_node, for example. */
8747: decl = NULL_TREE;
8748: }
8749: else if (TREE_CODE (type) == FUNCTION_TYPE)
8750: {
8751: int publicp = 0;
8752:
8753: if (friendp == 0)
8754: {
8755: if (ctype == NULL_TREE)
8756: ctype = current_class_type;
8757:
8758: if (ctype == NULL_TREE)
8759: {
8760: cp_error ("can't make `%D' into a method -- not in a class",
8761: declarator);
8762: return void_type_node;
8763: }
8764:
8765: /* ``A union may [ ... ] not [ have ] virtual functions.''
8766: ARM 9.5 */
8767: if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8768: {
8769: cp_error ("function `%D' declared virtual inside a union",
8770: declarator);
8771: return void_type_node;
8772: }
8773:
8774: if (declarator == ansi_opname[(int) NEW_EXPR]
8775: || declarator == ansi_opname[(int) VEC_NEW_EXPR]
8776: || declarator == ansi_opname[(int) DELETE_EXPR]
8777: || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
8778: {
8779: if (virtualp)
8780: {
8781: cp_error ("`%D' cannot be declared virtual, since it is always static",
8782: declarator);
8783: virtualp = 0;
8784: }
8785: }
8786: else if (staticp < 2)
8787: type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
8788: TREE_TYPE (type), TYPE_ARG_TYPES (type));
8789: }
8790:
8791: /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8792: publicp = (RIDBIT_SETP (RID_EXTERN, specbits)
8793: || (ctype != NULL_TREE
8794: && funcdef_flag >= 0
8795: && RIDBIT_NOTSETP (RID_INLINE, specbits))
8796: || (friendp
8797: && ! funcdef_flag
8798: && RIDBIT_NOTSETP (RID_STATIC, specbits)
8799: && RIDBIT_NOTSETP (RID_INLINE, specbits)));
8800: decl = grokfndecl (ctype, type, declarator,
8801: virtualp, flags, quals,
8802: raises, friendp ? -1 : 0, publicp);
8803: if (decl == NULL_TREE)
8804: return NULL_TREE;
8805:
8806: DECL_INLINE (decl) = inlinep;
8807: }
8808: else if (TREE_CODE (type) == METHOD_TYPE)
8809: {
8810: /* All method decls are public, so tell grokfndecl to set
8811: TREE_PUBLIC, also. */
8812: decl = grokfndecl (ctype, type, declarator,
8813: virtualp, flags, quals,
8814: raises, friendp ? -1 : 0, 1);
8815: if (decl == NULL_TREE)
8816: return NULL_TREE;
8817:
8818: DECL_INLINE (decl) = inlinep;
8819: }
8820: else if (TREE_CODE (type) == RECORD_TYPE
8821: && CLASSTYPE_DECLARED_EXCEPTION (type))
8822: {
8823: /* Handle a class-local exception declaration. */
8824: decl = build_lang_field_decl (VAR_DECL, declarator, type);
8825: if (ctype == NULL_TREE)
8826: ctype = current_class_type;
8827: return void_type_node;
8828: }
8829: else if (TYPE_SIZE (type) == NULL_TREE && !staticp
8830: && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
8831: {
8832: error ("field `%s' has incomplete type",
8833: IDENTIFIER_POINTER (declarator));
8834:
8835: /* If we're instantiating a template, tell them which
8836: instantiation made the field's type be incomplete. */
8837: if (current_class_type
8838: && TYPE_NAME (current_class_type)
8839: && IDENTIFIER_TEMPLATE (DECL_NAME (TYPE_NAME (current_class_type)))
8840: && declspecs && TREE_VALUE (declspecs)
8841: && TREE_TYPE (TREE_VALUE (declspecs)) == type)
8842: error (" in instantiation of template `%s'",
8843: TYPE_NAME_STRING (current_class_type));
8844:
8845: type = error_mark_node;
8846: decl = NULL_TREE;
8847: }
8848: else
8849: {
8850: if (friendp)
8851: {
8852: error ("`%s' is neither function nor method; cannot be declared friend",
8853: IDENTIFIER_POINTER (declarator));
8854: friendp = 0;
8855: }
8856: decl = NULL_TREE;
8857: }
8858:
8859: if (friendp)
8860: {
8861: /* Friends are treated specially. */
8862: if (ctype == current_class_type)
8863: warning ("member functions are implicitly friends of their class");
8864: else
8865: {
8866: tree t = NULL_TREE;
8867: if (decl && DECL_NAME (decl))
8868: t = do_friend (ctype, declarator, decl,
8869: last_function_parms, flags, quals);
8870: if (t && funcdef_flag)
8871: return t;
8872:
8873: return void_type_node;
8874: }
8875: }
8876:
8877: /* Structure field. It may not be a function, except for C++ */
8878:
8879: if (decl == NULL_TREE)
8880: {
8881: if (initialized)
8882: {
8883: /* Motion 10 at San Diego: If a static const integral data
8884: member is initialized with an integral constant
8885: expression, the initializer may appear either in the
8886: declaration (within the class), or in the definition,
8887: but not both. If it appears in the class, the member is
8888: a member constant. The file-scope definition is always
8889: required. */
8890: if (staticp)
8891: {
8892: if (pedantic)
8893: {
8894: if (! constp)
8895: cp_pedwarn ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8896: declarator);
8897:
8898: else if (! INTEGRAL_TYPE_P (type))
8899: cp_pedwarn ("ANSI C++ forbids member constant `%D' of non-integral type `%T'", declarator, type);
8900: }
8901: }
8902:
8903: /* Note that initialization of const members is prohibited
8904: by the draft ANSI standard, though it appears to be in
8905: common practice. 12.6.2: The argument list is used to
8906: initialize the named nonstatic member.... This (or an
8907: initializer list) is the only way to initialize
8908: nonstatic const and reference members. */
8909: else if (flag_ansi || ! constp)
8910: cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
8911: constp ? "const member" : "member", declarator);
8912: }
8913:
8914: if (staticp || (constp && initialized))
8915: {
8916: /* C++ allows static class members.
8917: All other work for this is done by grokfield.
8918: This VAR_DECL is built by build_lang_field_decl.
8919: All other VAR_DECLs are built by build_decl. */
8920: decl = build_lang_field_decl (VAR_DECL, declarator, type);
8921: TREE_STATIC (decl) = 1;
8922: /* In class context, 'static' means public access. */
8923: TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = !!staticp;
8924: }
8925: else
8926: {
8927: decl = build_lang_field_decl (FIELD_DECL, declarator, type);
8928: if (RIDBIT_SETP (RID_MUTABLE, specbits))
8929: {
8930: DECL_MUTABLE_P (decl) = 1;
8931: RIDBIT_RESET (RID_MUTABLE, specbits);
8932: }
8933: }
8934:
8935: bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
8936: inlinep, friendp, raises != NULL_TREE);
8937: }
8938: }
8939: else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
8940: {
8941: tree original_name = declarator;
8942: int publicp = 0;
8943:
8944: if (! declarator)
8945: return NULL_TREE;
8946:
8947: if (RIDBIT_SETP (RID_AUTO, specbits))
8948: error ("storage class `auto' invalid for function `%s'", name);
8949: else if (RIDBIT_SETP (RID_REGISTER, specbits))
8950: error ("storage class `register' invalid for function `%s'", name);
8951:
8952: /* Function declaration not at top level.
8953: Storage classes other than `extern' are not allowed
8954: and `extern' makes no difference. */
8955: if (current_binding_level != global_binding_level
8956: && ! processing_template_decl
8957: && (RIDBIT_SETP (RID_STATIC, specbits)
8958: || RIDBIT_SETP (RID_INLINE, specbits))
8959: && pedantic)
8960: {
8961: if (RIDBIT_SETP (RID_STATIC, specbits))
8962: pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
8963: else
8964: pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
8965: }
8966:
8967: if (ctype == NULL_TREE)
8968: {
8969: if (virtualp)
8970: {
8971: error ("virtual non-class function `%s'", name);
8972: virtualp = 0;
8973: }
8974:
8975: if (current_lang_name == lang_name_cplusplus
8976: && ! (IDENTIFIER_LENGTH (original_name) == 4
8977: && IDENTIFIER_POINTER (original_name)[0] == 'm'
8978: && strcmp (IDENTIFIER_POINTER (original_name), "main") == 0)
8979: && ! (IDENTIFIER_LENGTH (original_name) > 10
8980: && IDENTIFIER_POINTER (original_name)[0] == '_'
8981: && IDENTIFIER_POINTER (original_name)[1] == '_'
8982: && strncmp (IDENTIFIER_POINTER (original_name)+2, "builtin_", 8) == 0))
8983: /* Plain overloading: will not be grok'd by grokclassfn. */
8984: declarator = build_decl_overload (dname, TYPE_ARG_TYPES (type), 0);
8985: }
8986: else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
8987: type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
8988: TREE_TYPE (type), TYPE_ARG_TYPES (type));
8989:
8990: /* Record presence of `static'. In C++, `inline' is like `static'. */
8991: publicp
8992: = !(RIDBIT_SETP (RID_STATIC, specbits)
8993: || RIDBIT_SETP (RID_INLINE, specbits));
8994:
8995: decl = grokfndecl (ctype, type, original_name,
8996: virtualp, flags, quals,
8997: raises,
8998: processing_template_decl ? 0 : friendp ? 2 : 1,
8999: publicp);
9000: if (decl == NULL_TREE)
9001: return NULL_TREE;
9002:
9003: if (ctype == NULL_TREE && DECL_LANGUAGE (decl) != lang_c)
9004: DECL_ASSEMBLER_NAME (decl) = declarator;
9005:
9006: if (staticp == 1)
9007: {
9008: int illegal_static = 0;
9009:
9010: /* Don't allow a static member function in a class, and forbid
9011: declaring main to be static. */
9012: if (TREE_CODE (type) == METHOD_TYPE)
9013: {
9014: cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
9015: illegal_static = 1;
9016: }
9017: else if (! ctype
9018: && IDENTIFIER_LENGTH (original_name) == 4
9019: && IDENTIFIER_POINTER (original_name)[0] == 'm'
9020: && ! strcmp (IDENTIFIER_POINTER (original_name), "main"))
9021: {
9022: error ("cannot declare function `main' to have static linkage");
9023: illegal_static = 1;
9024: }
9025: else if (current_function_decl)
9026: {
9027: /* FIXME need arm citation */
9028: error ("cannot declare static function inside another function");
9029: illegal_static = 1;
9030: }
9031:
9032: if (illegal_static)
9033: {
9034: staticp = 0;
9035: RIDBIT_RESET (RID_STATIC, specbits);
9036: }
9037: }
9038:
9039: /* Record presence of `inline', if it is reasonable. */
9040: if (inlinep)
9041: {
9042: tree last = tree_last (TYPE_ARG_TYPES (type));
9043:
9044: if (! ctype
9045: && ! strcmp (IDENTIFIER_POINTER (original_name), "main"))
9046: error ("cannot inline function `main'");
9047: else if (last && last != void_list_node)
9048: cp_warning ("cannot inline function `%D' which takes `...'", original_name);
9049: else
9050: /* Assume that otherwise the function can be inlined. */
9051: DECL_INLINE (decl) = 1;
9052:
9053: if (RIDBIT_SETP (RID_EXTERN, specbits))
9054: {
9055: current_extern_inline = 1;
9056: if (flag_ansi)
9057: pedwarn ("ANSI C++ does not permit `extern inline'");
9058: }
9059: }
9060: }
9061: else
9062: {
9063: /* It's a variable. */
9064:
9065: /* An uninitialized decl with `extern' is a reference. */
9066: decl = grokvardecl (type, declarator, specbits, initialized);
9067: bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
9068: inlinep, friendp, raises != NULL_TREE);
9069:
9070: if (ctype)
9071: {
9072: DECL_CONTEXT (decl) = ctype;
9073: if (staticp == 1)
9074: {
9075: cp_error ("static member `%D' re-declared as static",
9076: decl);
9077: staticp = 0;
9078: RIDBIT_RESET (RID_STATIC, specbits);
9079: }
9080: if (RIDBIT_SETP (RID_EXTERN, specbits))
9081: {
9082: cp_error ("cannot explicitly declare member `%#D' to have extern linkage",
9083: decl);
9084: RIDBIT_RESET (RID_EXTERN, specbits);
9085: }
9086: }
9087: }
9088:
9089: if (RIDBIT_SETP (RID_MUTABLE, specbits))
9090: {
9091: error ("`%s' cannot be declared mutable", name);
9092: }
9093:
9094: /* Record `register' declaration for warnings on &
9095: and in case doing stupid register allocation. */
9096:
9097: if (RIDBIT_SETP (RID_REGISTER, specbits))
9098: DECL_REGISTER (decl) = 1;
9099:
9100: if (RIDBIT_SETP (RID_EXTERN, specbits))
9101: DECL_THIS_EXTERN (decl) = 1;
9102:
9103: /* Record constancy and volatility. */
9104:
9105: if (constp)
9106: TREE_READONLY (decl) = TREE_CODE (type) != REFERENCE_TYPE;
9107: if (volatilep)
9108: {
9109: TREE_SIDE_EFFECTS (decl) = 1;
9110: TREE_THIS_VOLATILE (decl) = 1;
9111: }
9112:
9113: return decl;
9114: }
9115: }
9116:
9117: /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
9118: An empty exprlist is a parmlist. An exprlist which
9119: contains only identifiers at the global level
9120: is a parmlist. Otherwise, it is an exprlist. */
9121: int
9122: parmlist_is_exprlist (exprs)
9123: tree exprs;
9124: {
9125: if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
9126: return 0;
9127:
9128: if (current_binding_level == global_binding_level)
9129: {
9130: /* At the global level, if these are all identifiers,
9131: then it is a parmlist. */
9132: while (exprs)
9133: {
9134: if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
9135: return 1;
9136: exprs = TREE_CHAIN (exprs);
9137: }
9138: return 0;
9139: }
9140: return 1;
9141: }
9142:
9143: /* Subroutine of `grokparms'. In a fcn definition, arg types must
9144: be complete.
9145:
9146: C++: also subroutine of `start_function'. */
9147: static void
9148: require_complete_types_for_parms (parms)
9149: tree parms;
9150: {
9151: while (parms)
9152: {
9153: tree type = TREE_TYPE (parms);
9154: if (TYPE_SIZE (type) == NULL_TREE)
9155: {
9156: if (DECL_NAME (parms))
9157: error ("parameter `%s' has incomplete type",
9158: IDENTIFIER_POINTER (DECL_NAME (parms)));
9159: else
9160: error ("parameter has incomplete type");
9161: TREE_TYPE (parms) = error_mark_node;
9162: }
9163: #if 0
9164: /* If the arg types are incomplete in a declaration,
9165: they must include undefined tags.
9166: These tags can never be defined in the scope of the declaration,
9167: so the types can never be completed,
9168: and no call can be compiled successfully. */
9169: /* This is not the right behavior for C++, but not having
9170: it is also probably wrong. */
9171: else
9172: {
9173: /* Now warn if is a pointer to an incomplete type. */
9174: while (TREE_CODE (type) == POINTER_TYPE
9175: || TREE_CODE (type) == REFERENCE_TYPE)
9176: type = TREE_TYPE (type);
9177: type = TYPE_MAIN_VARIANT (type);
9178: if (TYPE_SIZE (type) == NULL_TREE)
9179: {
9180: if (DECL_NAME (parm) != NULL_TREE)
9181: warning ("parameter `%s' points to incomplete type",
9182: IDENTIFIER_POINTER (DECL_NAME (parm)));
9183: else
9184: warning ("parameter points to incomplete type");
9185: }
9186: }
9187: #endif
9188: parms = TREE_CHAIN (parms);
9189: }
9190: }
9191:
9192: /* Decode the list of parameter types for a function type.
9193: Given the list of things declared inside the parens,
9194: return a list of types.
9195:
9196: The list we receive can have three kinds of elements:
9197: an IDENTIFIER_NODE for names given without types,
9198: a TREE_LIST node for arguments given as typespecs or names with typespecs,
9199: or void_type_node, to mark the end of an argument list
9200: when additional arguments are not permitted (... was not used).
9201:
9202: FUNCDEF_FLAG is nonzero for a function definition, 0 for
9203: a mere declaration. A nonempty identifier-list gets an error message
9204: when FUNCDEF_FLAG is zero.
9205: If FUNCDEF_FLAG is 1, then parameter types must be complete.
9206: If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
9207:
9208: If all elements of the input list contain types,
9209: we return a list of the types.
9210: If all elements contain no type (except perhaps a void_type_node
9211: at the end), we return a null list.
9212: If some have types and some do not, it is an error, and we
9213: return a null list.
9214:
9215: Also set last_function_parms to either
9216: a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
9217: A list of names is converted to a chain of PARM_DECLs
9218: by store_parm_decls so that ultimately it is always a chain of decls.
9219:
9220: Note that in C++, parameters can take default values. These default
9221: values are in the TREE_PURPOSE field of the TREE_LIST. It is
9222: an error to specify default values which are followed by parameters
9223: that have no default values, or an ELLIPSES. For simplicities sake,
9224: only parameters which are specified with their types can take on
9225: default values. */
9226:
9227: static tree
9228: grokparms (first_parm, funcdef_flag)
9229: tree first_parm;
9230: int funcdef_flag;
9231: {
9232: tree result = NULL_TREE;
9233: tree decls = NULL_TREE;
9234:
9235: if (first_parm != NULL_TREE
9236: && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
9237: {
9238: if (! funcdef_flag)
9239: pedwarn ("parameter names (without types) in function declaration");
9240: last_function_parms = first_parm;
9241: return NULL_TREE;
9242: }
9243: else if (first_parm != NULL_TREE
9244: && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
9245: && TREE_VALUE (first_parm) != void_type_node)
9246: my_friendly_abort (145);
9247: else
9248: {
9249: /* Types were specified. This is a list of declarators
9250: each represented as a TREE_LIST node. */
9251: register tree parm, chain;
9252: int any_init = 0, any_error = 0, saw_void = 0;
9253:
9254: if (first_parm != NULL_TREE)
9255: {
9256: tree last_result = NULL_TREE;
9257: tree last_decl = NULL_TREE;
9258:
9259: for (parm = first_parm; parm != NULL_TREE; parm = chain)
9260: {
9261: tree type, list_node = parm;
9262: register tree decl = TREE_VALUE (parm);
9263: tree init = TREE_PURPOSE (parm);
9264:
9265: chain = TREE_CHAIN (parm);
9266: /* @@ weak defense against parse errors. */
9267: if (decl != void_type_node && TREE_CODE (decl) != TREE_LIST)
9268: {
9269: /* Give various messages as the need arises. */
9270: if (TREE_CODE (decl) == STRING_CST)
9271: error ("invalid string constant `%s'",
9272: TREE_STRING_POINTER (decl));
9273: else if (TREE_CODE (decl) == INTEGER_CST)
9274: error ("invalid integer constant in parameter list, did you forget to give parameter name?");
9275: continue;
9276: }
9277:
9278: if (decl != void_type_node)
9279: {
9280: /* @@ May need to fetch out a `raises' here. */
9281: decl = grokdeclarator (TREE_VALUE (decl),
9282: TREE_PURPOSE (decl),
9283: PARM, init != NULL_TREE, NULL_TREE);
9284: if (! decl)
9285: continue;
9286: type = TREE_TYPE (decl);
9287: if (TYPE_MAIN_VARIANT (type) == void_type_node)
9288: decl = void_type_node;
9289: else if (TREE_CODE (type) == METHOD_TYPE)
9290: {
9291: if (DECL_NAME (decl))
9292: /* Cannot use `error_with_decl' here because
9293: we don't have DECL_CONTEXT set up yet. */
9294: error ("parameter `%s' invalidly declared method type",
9295: IDENTIFIER_POINTER (DECL_NAME (decl)));
9296: else
9297: error ("parameter invalidly declared method type");
9298: type = build_pointer_type (type);
9299: TREE_TYPE (decl) = type;
9300: }
9301: else if (TREE_CODE (type) == OFFSET_TYPE)
9302: {
9303: if (DECL_NAME (decl))
9304: error ("parameter `%s' invalidly declared offset type",
9305: IDENTIFIER_POINTER (DECL_NAME (decl)));
9306: else
9307: error ("parameter invalidly declared offset type");
9308: type = build_pointer_type (type);
9309: TREE_TYPE (decl) = type;
9310: }
9311: else if (TREE_CODE (type) == RECORD_TYPE
9312: && TYPE_LANG_SPECIFIC (type)
9313: && CLASSTYPE_ABSTRACT_VIRTUALS (type))
9314: {
9315: abstract_virtuals_error (decl, type);
9316: any_error = 1; /* seems like a good idea */
9317: }
9318: else if (TREE_CODE (type) == RECORD_TYPE
9319: && TYPE_LANG_SPECIFIC (type)
9320: && IS_SIGNATURE (type))
9321: {
9322: signature_error (decl, type);
9323: any_error = 1; /* seems like a good idea */
9324: }
9325: }
9326:
9327: if (decl == void_type_node)
9328: {
9329: if (result == NULL_TREE)
9330: {
9331: result = void_list_node;
9332: last_result = result;
9333: }
9334: else
9335: {
9336: TREE_CHAIN (last_result) = void_list_node;
9337: last_result = void_list_node;
9338: }
9339: saw_void = 1;
9340: if (chain
9341: && (chain != void_list_node || TREE_CHAIN (chain)))
9342: error ("`void' in parameter list must be entire list");
9343: break;
9344: }
9345:
9346: /* Since there is a prototype, args are passed in their own types. */
9347: DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
9348: #ifdef PROMOTE_PROTOTYPES
9349: if ((TREE_CODE (type) == INTEGER_TYPE
9350: || TREE_CODE (type) == ENUMERAL_TYPE)
9351: && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
9352: DECL_ARG_TYPE (decl) = integer_type_node;
9353: #endif
9354: if (!any_error)
9355: {
9356: if (init)
9357: {
9358: any_init++;
9359: if (TREE_CODE (init) == SAVE_EXPR)
9360: PARM_DECL_EXPR (init) = 1;
9361: else if (TREE_CODE (init) == VAR_DECL)
9362: {
9363: if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init)))
9364: {
9365: /* ``Local variables may not be used in default
9366: argument expressions.'' dpANSI C++ 8.2.6 */
9367: /* If extern int i; within a function is not
9368: considered a local variable, then this code is
9369: wrong. */
9370: cp_error ("local variable `%D' may not be used as a default argument", init);
9371: any_error = 1;
9372: }
9373: else if (TREE_READONLY_DECL_P (init))
9374: init = decl_constant_value (init);
9375: }
9376: else
9377: init = require_instantiated_type (type, init, integer_zero_node);
9378: }
9379: else if (any_init)
9380: {
9381: error ("all trailing parameters must have default arguments");
9382: any_error = 1;
9383: }
9384: }
9385: else
9386: init = NULL_TREE;
9387:
9388: if (decls == NULL_TREE)
9389: {
9390: decls = decl;
9391: last_decl = decls;
9392: }
9393: else
9394: {
9395: TREE_CHAIN (last_decl) = decl;
9396: last_decl = decl;
9397: }
9398: if (TREE_PERMANENT (list_node))
9399: {
9400: TREE_PURPOSE (list_node) = init;
9401: TREE_VALUE (list_node) = type;
9402: TREE_CHAIN (list_node) = NULL_TREE;
9403: }
9404: else
9405: list_node = saveable_tree_cons (init, type, NULL_TREE);
9406: if (result == NULL_TREE)
9407: {
9408: result = list_node;
9409: last_result = result;
9410: }
9411: else
9412: {
9413: TREE_CHAIN (last_result) = list_node;
9414: last_result = list_node;
9415: }
9416: }
9417: if (last_result)
9418: TREE_CHAIN (last_result) = NULL_TREE;
9419: /* If there are no parameters, and the function does not end
9420: with `...', then last_decl will be NULL_TREE. */
9421: if (last_decl != NULL_TREE)
9422: TREE_CHAIN (last_decl) = NULL_TREE;
9423: }
9424: }
9425:
9426: last_function_parms = decls;
9427:
9428: /* In a fcn definition, arg types must be complete. */
9429: if (funcdef_flag > 0)
9430: require_complete_types_for_parms (last_function_parms);
9431:
9432: return result;
9433: }
9434:
9435: /* These memoizing functions keep track of special properties which
9436: a class may have. `grok_ctor_properties' notices whether a class
9437: has a constructor of the form X(X&), and also complains
9438: if the class has a constructor of the form X(X).
9439: `grok_op_properties' takes notice of the various forms of
9440: operator= which are defined, as well as what sorts of type conversion
9441: may apply. Both functions take a FUNCTION_DECL as an argument. */
9442: int
9443: grok_ctor_properties (ctype, decl)
9444: tree ctype, decl;
9445: {
9446: tree parmtypes = FUNCTION_ARG_CHAIN (decl);
9447: tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
9448:
9449: /* When a type has virtual baseclasses, a magical first int argument is
9450: added to any ctor so we can tell if the class has been initialized
9451: yet. This could screw things up in this function, so we deliberately
9452: ignore the leading int if we're in that situation. */
9453: if (parmtypes
9454: && TREE_VALUE (parmtypes) == integer_type_node
9455: && TYPE_USES_VIRTUAL_BASECLASSES (ctype))
9456: {
9457: parmtypes = TREE_CHAIN (parmtypes);
9458: parmtype = TREE_VALUE (parmtypes);
9459: }
9460:
9461: if (TREE_CODE (parmtype) == REFERENCE_TYPE
9462: && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype)
9463: {
9464: if (TREE_CHAIN (parmtypes) == NULL_TREE
9465: || TREE_CHAIN (parmtypes) == void_list_node
9466: || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
9467: {
9468: TYPE_HAS_INIT_REF (ctype) = 1;
9469: if (TYPE_READONLY (TREE_TYPE (parmtype)))
9470: TYPE_HAS_CONST_INIT_REF (ctype) = 1;
9471: }
9472: else
9473: TYPE_GETS_INIT_AGGR (ctype) = 1;
9474: }
9475: else if (TYPE_MAIN_VARIANT (parmtype) == ctype)
9476: {
9477: if (TREE_CHAIN (parmtypes) != NULL_TREE
9478: && TREE_CHAIN (parmtypes) == void_list_node)
9479: {
9480: cp_error ("invalid constructor; you probably meant `%T (%T&)'",
9481: ctype, ctype);
9482: SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
9483:
9484: return 0;
9485: }
9486: else
9487: TYPE_GETS_INIT_AGGR (ctype) = 1;
9488: }
9489: else if (TREE_CODE (parmtype) == VOID_TYPE
9490: || TREE_PURPOSE (parmtypes) != NULL_TREE)
9491: TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
9492:
9493: return 1;
9494: }
9495:
9496: /* An operator with this name can be either unary or binary. */
9497: static int
9498: ambi_op_p (name)
9499: tree name;
9500: {
9501: return (name == ansi_opname [(int) INDIRECT_REF]
9502: || name == ansi_opname [(int) ADDR_EXPR]
9503: || name == ansi_opname [(int) NEGATE_EXPR]
9504: || name == ansi_opname[(int) POSTINCREMENT_EXPR]
9505: || name == ansi_opname[(int) POSTDECREMENT_EXPR]
9506: || name == ansi_opname [(int) CONVERT_EXPR]);
9507: }
9508:
9509: /* An operator with this name can only be unary. */
9510: static int
9511: unary_op_p (name)
9512: tree name;
9513: {
9514: return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
9515: || name == ansi_opname [(int) BIT_NOT_EXPR]
9516: || name == ansi_opname [(int) COMPONENT_REF]
9517: || OPERATOR_TYPENAME_P (name));
9518: }
9519:
9520: /* Do a little sanity-checking on how they declared their operator. */
9521: static void
9522: grok_op_properties (decl, virtualp, friendp)
9523: tree decl;
9524: int virtualp, friendp;
9525: {
9526: tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
9527: int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
9528: tree name = DECL_NAME (decl);
9529:
9530: if (current_class_type == NULL_TREE)
9531: friendp = 1;
9532:
9533: if (! friendp)
9534: {
9535: if (name == ansi_opname[(int) MODIFY_EXPR])
9536: TYPE_HAS_ASSIGNMENT (current_class_type) = 1;
9537: else if (name == ansi_opname[(int) CALL_EXPR])
9538: TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
9539: else if (name == ansi_opname[(int) ARRAY_REF])
9540: TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
9541: else if (name == ansi_opname[(int) COMPONENT_REF]
9542: || name == ansi_opname[(int) MEMBER_REF])
9543: TYPE_OVERLOADS_ARROW (current_class_type) = 1;
9544: else if (name == ansi_opname[(int) NEW_EXPR])
9545: TYPE_GETS_NEW (current_class_type) |= 1;
9546: else if (name == ansi_opname[(int) DELETE_EXPR])
9547: TYPE_GETS_DELETE (current_class_type) |= 1;
9548: else if (name == ansi_opname[(int) VEC_NEW_EXPR])
9549: TYPE_GETS_NEW (current_class_type) |= 2;
9550: else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
9551: TYPE_GETS_DELETE (current_class_type) |= 2;
9552: }
9553:
9554: if (name == ansi_opname[(int) NEW_EXPR]
9555: || name == ansi_opname[(int) VEC_NEW_EXPR])
9556: {
9557: /* When the compiler encounters the definition of A::operator new, it
9558: doesn't look at the class declaration to find out if it's static. */
9559: if (methodp)
9560: revert_static_member_fn (&decl, NULL, NULL);
9561:
9562: /* Take care of function decl if we had syntax errors. */
9563: if (argtypes == NULL_TREE)
9564: TREE_TYPE (decl) =
9565: build_function_type (ptr_type_node,
9566: hash_tree_chain (integer_type_node,
9567: void_list_node));
9568: else
9569: TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9570: }
9571: else if (name == ansi_opname[(int) DELETE_EXPR]
9572: || name == ansi_opname[(int) VEC_DELETE_EXPR])
9573: {
9574: if (methodp)
9575: revert_static_member_fn (&decl, NULL, NULL);
9576:
9577: if (argtypes == NULL_TREE)
9578: TREE_TYPE (decl) =
9579: build_function_type (void_type_node,
9580: hash_tree_chain (ptr_type_node,
9581: void_list_node));
9582: else
9583: {
9584: TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
9585:
9586: if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
9587: && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
9588: != void_list_node))
9589: TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
9590: }
9591: }
9592: else
9593: {
9594: /* An operator function must either be a non-static member function
9595: or have at least one parameter of a class, a reference to a class,
9596: an enumeration, or a reference to an enumeration. 13.4.0.6 */
9597: if (! methodp || DECL_STATIC_FUNCTION_P (decl))
9598: {
9599: if (OPERATOR_TYPENAME_P (name)
9600: || name == ansi_opname[(int) CALL_EXPR]
9601: || name == ansi_opname[(int) MODIFY_EXPR]
9602: || name == ansi_opname[(int) COMPONENT_REF]
9603: || name == ansi_opname[(int) ARRAY_REF])
9604: cp_error ("`%D' must be a nonstatic member function", decl);
9605: else
9606: {
9607: tree p = argtypes;
9608:
9609: if (DECL_STATIC_FUNCTION_P (decl))
9610: cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
9611:
9612: if (p)
9613: for (; TREE_VALUE (p) != void_type_node ; p = TREE_CHAIN (p))
9614: {
9615: tree arg = TREE_VALUE (p);
9616: if (TREE_CODE (arg) == REFERENCE_TYPE)
9617: arg = TREE_TYPE (arg);
9618:
9619: /* This lets bad template code slip through. */
9620: if (IS_AGGR_TYPE (arg)
9621: || TREE_CODE (arg) == ENUMERAL_TYPE
9622: || TREE_CODE (arg) == TEMPLATE_TYPE_PARM)
9623: goto foundaggr;
9624: }
9625: cp_error
9626: ("`%D' must have an argument of class or enumerated type",
9627: decl);
9628: foundaggr:
9629: ;
9630: }
9631: }
9632:
9633: if (name == ansi_opname[(int) CALL_EXPR]
9634: || name == ansi_opname[(int) METHOD_CALL_EXPR])
9635: return; /* no restrictions on args */
9636:
9637: if (IDENTIFIER_TYPENAME_P (name))
9638: {
9639: tree t = TREE_TYPE (name);
9640: if (TREE_CODE (t) == VOID_TYPE)
9641: pedwarn ("void is not a valid type conversion operator");
9642: else if (! friendp)
9643: {
9644: int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9645: char *what = 0;
9646: if (ref)
9647: t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9648:
9649: if (t == current_class_type)
9650: what = "the same type";
9651: else if (IS_AGGR_TYPE (t)
9652: && DERIVED_FROM_P (t, current_class_type))
9653: what = "a base class";
9654:
9655: if (what)
9656: warning ("conversion to %s%s will never use a type conversion operator",
9657: ref ? "a reference to " : "", what);
9658: }
9659: }
9660:
9661: if (name == ansi_opname[(int) MODIFY_EXPR])
9662: {
9663: tree parmtype;
9664:
9665: if (list_length (argtypes) != 3 && methodp)
9666: {
9667: cp_error ("`%D' must take exactly one argument", decl);
9668: return;
9669: }
9670: parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
9671:
9672: if (copy_assignment_arg_p (parmtype, virtualp)
9673: && ! friendp)
9674: {
9675: TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
9676: if (TREE_CODE (parmtype) != REFERENCE_TYPE
9677: || TYPE_READONLY (TREE_TYPE (parmtype)))
9678: TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
9679: #if 0 /* Too soon; done in grok_function_init */
9680: if (DECL_ABSTRACT_VIRTUAL_P (decl))
9681: TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type) = 1;
9682: #endif
9683: }
9684: }
9685: else if (name == ansi_opname[(int) COND_EXPR])
9686: {
9687: /* 13.4.0.3 */
9688: pedwarn ("ANSI C++ prohibits overloading operator ?:");
9689: if (list_length (argtypes) != 4)
9690: cp_error ("`%D' must take exactly three arguments", decl);
9691: }
9692: else if (ambi_op_p (name))
9693: {
9694: if (list_length (argtypes) == 2)
9695: /* prefix */;
9696: else if (list_length (argtypes) == 3)
9697: {
9698: if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
9699: || name == ansi_opname[(int) POSTDECREMENT_EXPR])
9700: && TREE_VALUE (TREE_CHAIN (argtypes)) != integer_type_node)
9701: {
9702: if (methodp)
9703: cp_error ("postfix `%D' must take `int' as its argument",
9704: decl);
9705: else
9706: cp_error
9707: ("postfix `%D' must take `int' as its second argument",
9708: decl);
9709: }
9710: }
9711: else
9712: {
9713: if (methodp)
9714: cp_error ("`%D' must take either zero or one argument", decl);
9715: else
9716: cp_error ("`%D' must take either one or two arguments", decl);
9717: }
9718: }
9719: else if (unary_op_p (name))
9720: {
9721: if (list_length (argtypes) != 2)
9722: {
9723: if (methodp)
9724: cp_error ("`%D' must take `void'", decl);
9725: else
9726: cp_error ("`%D' must take exactly one argument", decl);
9727: }
9728: }
9729: else /* if (binary_op_p (name)) */
9730: {
9731: if (list_length (argtypes) != 3)
9732: {
9733: if (methodp)
9734: cp_error ("`%D' must take exactly one argument", decl);
9735: else
9736: cp_error ("`%D' must take exactly two arguments", decl);
9737: }
9738: }
9739:
9740: /* 13.4.0.8 */
9741: if (argtypes)
9742: for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
9743: if (TREE_PURPOSE (argtypes))
9744: {
9745: TREE_PURPOSE (argtypes) = NULL_TREE;
9746: if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
9747: || name == ansi_opname[(int) POSTDECREMENT_EXPR])
9748: {
9749: if (pedantic)
9750: cp_pedwarn ("`%D' cannot have default arguments", decl);
9751: }
9752: else
9753: cp_error ("`%D' cannot have default arguments", decl);
9754: }
9755: }
9756: }
9757:
9758: /* Get the struct, enum or union (CODE says which) with tag NAME.
9759: Define the tag as a forward-reference if it is not defined.
9760:
9761: C++: If a class derivation is given, process it here, and report
9762: an error if multiple derivation declarations are not identical.
9763:
9764: If this is a definition, come in through xref_tag and only look in
9765: the current frame for the name (since C++ allows new names in any
9766: scope.) */
9767:
9768: /* avoid rewriting all callers of xref_tag */
9769: static int xref_next_defn = 0;
9770:
9771: tree
9772: xref_defn_tag (code_type_node, name, binfo)
9773: tree code_type_node;
9774: tree name, binfo;
9775: {
9776: tree rv, ncp;
9777: xref_next_defn = 1;
9778:
9779: if (class_binding_level)
9780: {
9781: tree n1;
9782: char *buf;
9783: /* we need to build a new IDENTIFIER_NODE for name which nukes
9784: * the pieces... */
9785: /*
9786: n1 = IDENTIFIER_LOCAL_VALUE (current_class_name);
9787: if (n1)
9788: n1 = DECL_NAME (n1);
9789: else
9790: n1 = current_class_name;
9791: */
9792: n1 = TYPE_NAME (current_class_type);
9793: if (n1)
9794: n1 = DECL_NESTED_TYPENAME(n1);
9795: else
9796: n1 = current_class_name;
9797:
9798: buf = (char *) alloca (4 + IDENTIFIER_LENGTH (n1)
9799: + IDENTIFIER_LENGTH (name));
9800:
9801: sprintf (buf, "%s::%s", IDENTIFIER_POINTER (n1),
9802: IDENTIFIER_POINTER (name));
9803: ncp = get_identifier (buf);
9804: #ifdef SPEW_DEBUG
9805: if (spew_debug)
9806: printf("*** %s ***\n", IDENTIFIER_POINTER (ncp));
9807: #endif
9808: #if 0
9809: IDENTIFIER_LOCAL_VALUE (name) =
9810: build_decl (TYPE_DECL, ncp, NULL_TREE);
9811: #endif
9812: rv = xref_tag (code_type_node, name, binfo, 0);
9813: if (! ANON_AGGRNAME_P (name))
9814: {
9815: register tree type_decl = build_decl (TYPE_DECL, ncp, rv);
9816: SET_DECL_ARTIFICIAL (type_decl);
9817: #ifdef DWARF_DEBUGGING_INFO
9818: /* Mark the TYPE_DECL node created just above as a gratuitous one
9819: so that dwarfout.c will know not to generate a TAG_typedef DIE
9820: for it. */
9821: if (write_symbols == DWARF_DEBUG)
9822: DECL_IGNORED_P (type_decl) = 1;
9823: #endif /* DWARF_DEBUGGING_INFO */
9824: pushdecl_nonclass_level (type_decl);
9825: }
9826: }
9827: else
9828: {
9829: rv = xref_tag (code_type_node, name, binfo, 0);
9830: }
9831: xref_next_defn = 0;
9832: return rv;
9833: }
9834:
9835: tree
9836: xref_tag (code_type_node, name, binfo, globalize)
9837: tree code_type_node;
9838: tree name, binfo;
9839: int globalize;
9840: {
9841: enum tag_types tag_code;
9842: enum tree_code code;
9843: int temp = 0;
9844: int i, len;
9845: register tree ref, t;
9846: struct binding_level *b = inner_binding_level;
9847:
9848: tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
9849: switch (tag_code)
9850: {
9851: case record_type:
9852: case class_type:
9853: case exception_type:
9854: case signature_type:
9855: code = RECORD_TYPE;
9856: len = list_length (binfo);
9857: break;
9858: case union_type:
9859: code = UNION_TYPE;
9860: if (binfo)
9861: {
9862: cp_error ("derived union `%T' invalid", name);
9863: binfo = NULL_TREE;
9864: }
9865: len = 0;
9866: break;
9867: case enum_type:
9868: code = ENUMERAL_TYPE;
9869: break;
9870: default:
9871: my_friendly_abort (18);
9872: }
9873:
9874: /* If a cross reference is requested, look up the type
9875: already defined for this tag and return it. */
9876: t = IDENTIFIER_TYPE_VALUE (name);
9877: if (t && TREE_CODE (t) != code)
9878: t = NULL_TREE;
9879:
9880: if (xref_next_defn)
9881: {
9882: /* If we know we are defining this tag, only look it up in this scope
9883: * and don't try to find it as a type. */
9884: xref_next_defn = 0;
9885: if (t && TYPE_CONTEXT(t))
9886: {
9887: if (TREE_MANGLED (name))
9888: ref = t;
9889: else
9890: ref = lookup_tag (code, name, b, 1);
9891: }
9892: else
9893: ref = lookup_tag (code, name, b, 1);
9894: }
9895: else
9896: {
9897: if (t)
9898: ref = t;
9899: else
9900: ref = lookup_tag (code, name, b, 0);
9901:
9902: if (! ref)
9903: {
9904: /* Try finding it as a type declaration. If that wins, use it. */
9905: ref = lookup_name (name, 1);
9906: if (ref && TREE_CODE (ref) == TYPE_DECL
9907: && TREE_CODE (TREE_TYPE (ref)) == code)
9908: ref = TREE_TYPE (ref);
9909: else
9910: ref = NULL_TREE;
9911: }
9912: }
9913:
9914: push_obstacks_nochange ();
9915:
9916: if (! ref)
9917: {
9918: /* If no such tag is yet defined, create a forward-reference node
9919: and record it as the "definition".
9920: When a real declaration of this type is found,
9921: the forward-reference will be altered into a real type. */
9922:
9923: /* In C++, since these migrate into the global scope, we must
9924: build them on the permanent obstack. */
9925:
9926: temp = allocation_temporary_p ();
9927: if (temp)
9928: end_temporary_allocation ();
9929:
9930: if (code == ENUMERAL_TYPE)
9931: {
9932: ref = make_node (ENUMERAL_TYPE);
9933:
9934: /* Give the type a default layout like unsigned int
9935: to avoid crashing if it does not get defined. */
9936: TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
9937: TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
9938: TREE_UNSIGNED (ref) = 1;
9939: TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
9940: TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
9941: TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
9942:
9943: /* Enable us to recognize when a type is created in class context.
9944: To do nested classes correctly, this should probably be cleared
9945: out when we leave this classes scope. Currently this in only
9946: done in `start_enum'. */
9947:
9948: pushtag (name, ref, globalize);
9949: if (flag_cadillac)
9950: cadillac_start_enum (ref);
9951: }
9952: else if (tag_code == exception_type)
9953: {
9954: ref = make_lang_type (code);
9955: /* Enable us to recognize when an exception type is created in
9956: class context. To do nested classes correctly, this should
9957: probably be cleared out when we leave this class's scope. */
9958: CLASSTYPE_DECLARED_EXCEPTION (ref) = 1;
9959: pushtag (name, ref, globalize);
9960: if (flag_cadillac)
9961: cadillac_start_struct (ref);
9962: }
9963: else
9964: {
9965: struct binding_level *old_b = class_binding_level;
9966:
9967: ref = make_lang_type (code);
9968:
9969: if (tag_code == signature_type)
9970: {
9971: SET_SIGNATURE (ref);
9972: /* Since a signature type will be turned into the type
9973: of signature tables, it's not only an interface. */
9974: CLASSTYPE_INTERFACE_ONLY (ref) = 0;
9975: SET_CLASSTYPE_INTERFACE_KNOWN (ref);
9976: /* A signature doesn't have a vtable. */
9977: CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = 0;
9978: }
9979:
9980: #ifdef NONNESTED_CLASSES
9981: /* Class types don't nest the way enums do. */
9982: class_binding_level = (struct binding_level *)0;
9983: #endif
9984: pushtag (name, ref, globalize);
9985: class_binding_level = old_b;
9986:
9987: if (flag_cadillac)
9988: cadillac_start_struct (ref);
9989: }
9990: }
9991: else
9992: {
9993: if (IS_AGGR_TYPE_CODE (code))
9994: {
9995: if (IS_AGGR_TYPE (ref)
9996: && ((tag_code == exception_type)
9997: != (CLASSTYPE_DECLARED_EXCEPTION (ref) == 1)))
9998: {
9999: cp_error ("type `%T' is both exception and aggregate type", ref);
10000: CLASSTYPE_DECLARED_EXCEPTION (ref) = (tag_code == exception_type);
10001: }
10002: }
10003:
10004: /* If it no longer looks like a nested type, make sure it's
10005: in global scope. */
10006: if (b == global_binding_level && !class_binding_level
10007: && IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
10008: IDENTIFIER_GLOBAL_VALUE (name) = TYPE_NAME (ref);
10009:
10010: if (binfo)
10011: {
10012: tree tt1 = binfo;
10013: tree tt2 = TYPE_BINFO_BASETYPES (ref);
10014:
10015: if (TYPE_BINFO_BASETYPES (ref))
10016: for (i = 0; tt1; i++, tt1 = TREE_CHAIN (tt1))
10017: if (TREE_VALUE (tt1) != TYPE_IDENTIFIER (BINFO_TYPE (TREE_VEC_ELT (tt2, i))))
10018: {
10019: cp_error ("redeclaration of derivation chain of type `%#T'",
10020: ref);
10021: break;
10022: }
10023:
10024: if (tt1 == NULL_TREE)
10025: /* The user told us something we already knew. */
10026: goto just_return;
10027:
10028: /* In C++, since these migrate into the global scope, we must
10029: build them on the permanent obstack. */
10030: end_temporary_allocation ();
10031: }
10032: }
10033:
10034: if (binfo)
10035: {
10036: /* In the declaration `A : X, Y, ... Z' we mark all the types
10037: (A, X, Y, ..., Z) so we can check for duplicates. */
10038: tree binfos;
10039:
10040: SET_CLASSTYPE_MARKED (ref);
10041: BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
10042:
10043: for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
10044: {
10045: /* The base of a derived struct is public by default. */
10046: int via_public
10047: = (TREE_PURPOSE (binfo) == (tree)access_public
10048: || TREE_PURPOSE (binfo) == (tree)access_public_virtual
10049: || (tag_code != class_type
10050: && (TREE_PURPOSE (binfo) == (tree)access_default
10051: || TREE_PURPOSE (binfo) == (tree)access_default_virtual)));
10052: int via_protected = TREE_PURPOSE (binfo) == (tree)access_protected;
10053: int via_virtual
10054: = (TREE_PURPOSE (binfo) == (tree)access_private_virtual
10055: || TREE_PURPOSE (binfo) == (tree)access_public_virtual
10056: || TREE_PURPOSE (binfo) == (tree)access_default_virtual);
10057: tree basetype = TREE_TYPE (TREE_VALUE (binfo));
10058: tree base_binfo;
10059:
10060: GNU_xref_hier (IDENTIFIER_POINTER (name),
10061: IDENTIFIER_POINTER (TREE_VALUE (binfo)),
10062: via_public, via_virtual, 0);
10063:
10064: if (basetype && TREE_CODE (basetype) == TYPE_DECL)
10065: basetype = TREE_TYPE (basetype);
10066: if (!basetype || TREE_CODE (basetype) != RECORD_TYPE)
10067: {
10068: error ("base type `%s' fails to be a struct or class type",
10069: IDENTIFIER_POINTER (TREE_VALUE (binfo)));
10070: continue;
10071: }
10072: #if 1
10073: /* This code replaces similar code in layout_basetypes. */
10074: else if (TYPE_SIZE (basetype) == NULL_TREE)
10075: {
10076: cp_error ("base class `%T' has incomplete type", basetype);
10077: continue;
10078: }
10079: #endif
10080: else
10081: {
10082: if (CLASSTYPE_MARKED (basetype))
10083: {
10084: if (basetype == ref)
10085: cp_error ("recursive type `%T' undefined", basetype);
10086: else
10087: cp_error ("duplicate base type `%T' invalid", basetype);
10088: continue;
10089: }
10090:
10091: /* Note that the BINFO records which describe individual
10092: inheritances are *not* shared in the lattice! They
10093: cannot be shared because a given baseclass may be
10094: inherited with different `accessibility' by different
10095: derived classes. (Each BINFO record describing an
10096: individual inheritance contains flags which say what
10097: the `accessibility' of that particular inheritance is.) */
10098:
10099: base_binfo = make_binfo (integer_zero_node, basetype,
10100: TYPE_BINFO_VTABLE (basetype),
10101: TYPE_BINFO_VIRTUALS (basetype), NULL_TREE);
10102:
10103: TREE_VEC_ELT (binfos, i) = base_binfo;
10104: TREE_VIA_PUBLIC (base_binfo) = via_public;
10105: TREE_VIA_PROTECTED (base_binfo) = via_protected;
10106: TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
10107: BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
10108:
10109: SET_CLASSTYPE_MARKED (basetype);
10110: #if 0
10111: /* XYZZY TEST VIRTUAL BASECLASSES */
10112: if (CLASSTYPE_N_BASECLASSES (basetype) == NULL_TREE
10113: && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype)
10114: && via_virtual == 0)
10115: {
10116: warning ("making type `%s' a virtual baseclass",
10117: TYPE_NAME_STRING (basetype));
10118: via_virtual = 1;
10119: }
10120: #endif
10121: /* We are free to modify these bits because they are meaningless
10122: at top level, and BASETYPE is a top-level type. */
10123: if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
10124: {
10125: TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
10126: TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
10127: }
10128:
10129: TYPE_OVERLOADS_METHOD_CALL_EXPR (ref) |= TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype);
10130: TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
10131: TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10132: CLASSTYPE_LOCAL_TYPEDECLS (ref) |= CLASSTYPE_LOCAL_TYPEDECLS (basetype);
10133: i += 1;
10134: }
10135: }
10136: if (i)
10137: TREE_VEC_LENGTH (binfos) = i;
10138: else
10139: BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
10140:
10141: if (i > 1)
10142: TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
10143: else if (i == 1)
10144: TYPE_USES_MULTIPLE_INHERITANCE (ref)
10145: = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos, 0)));
10146: if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
10147: TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
10148:
10149: /* Unmark all the types. */
10150: while (--i >= 0)
10151: CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
10152: CLEAR_CLASSTYPE_MARKED (ref);
10153: }
10154:
10155: just_return:
10156:
10157: /* Until the type is defined, tentatively accept whatever
10158: structure tag the user hands us. */
10159: if (TYPE_SIZE (ref) == NULL_TREE
10160: && ref != current_class_type
10161: /* Have to check this, in case we have contradictory tag info. */
10162: && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
10163: {
10164: if (tag_code == class_type)
10165: CLASSTYPE_DECLARED_CLASS (ref) = 1;
10166: else if (tag_code == record_type || tag_code == signature_type)
10167: CLASSTYPE_DECLARED_CLASS (ref) = 0;
10168: }
10169:
10170: pop_obstacks ();
10171:
10172: return ref;
10173: }
10174:
10175: static tree current_local_enum = NULL_TREE;
10176:
10177: /* Begin compiling the definition of an enumeration type.
10178: NAME is its name (or null if anonymous).
10179: Returns the type object, as yet incomplete.
10180: Also records info about it so that build_enumerator
10181: may be used to declare the individual values as they are read. */
10182:
10183: tree
10184: start_enum (name)
10185: tree name;
10186: {
10187: register tree enumtype = NULL_TREE;
10188: struct binding_level *b = inner_binding_level;
10189:
10190: /* If this is the real definition for a previous forward reference,
10191: fill in the contents in the same object that used to be the
10192: forward reference. */
10193:
10194: if (name != NULL_TREE)
10195: enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
10196:
10197: if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10198: cp_error ("multiple definition of enum `%T'", enumtype);
10199: else
10200: {
10201: enumtype = make_node (ENUMERAL_TYPE);
10202: pushtag (name, enumtype, 0);
10203: }
10204:
10205: if (current_class_type)
10206: TREE_ADDRESSABLE (b->tags) = 1;
10207: current_local_enum = NULL_TREE;
10208:
10209: #if 0 /* This stuff gets cleared in finish_enum anyway. */
10210: if (TYPE_VALUES (enumtype) != NULL_TREE)
10211: /* Completely replace its old definition.
10212: The old enumerators remain defined, however. */
10213: TYPE_VALUES (enumtype) = NULL_TREE;
10214:
10215: /* Initially, set up this enum as like `int'
10216: so that we can create the enumerators' declarations and values.
10217: Later on, the precision of the type may be changed and
10218: it may be laid out again. */
10219:
10220: TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
10221: TYPE_SIZE (enumtype) = NULL_TREE;
10222: fixup_signed_type (enumtype);
10223: #endif
10224:
10225: /* We copy this value because enumerated type constants
10226: are really of the type of the enumerator, not integer_type_node. */
10227: enum_next_value = copy_node (integer_zero_node);
10228: enum_overflow = 0;
10229:
10230: GNU_xref_decl (current_function_decl, enumtype);
10231: return enumtype;
10232: }
10233:
10234: /* After processing and defining all the values of an enumeration type,
10235: install their decls in the enumeration type and finish it off.
10236: ENUMTYPE is the type object and VALUES a list of name-value pairs.
10237: Returns ENUMTYPE. */
10238:
10239: tree
10240: finish_enum (enumtype, values)
10241: register tree enumtype, values;
10242: {
10243: register tree minnode, maxnode;
10244: /* Calculate the maximum value of any enumerator in this type. */
10245:
10246: if (values)
10247: {
10248: register tree pair;
10249: register tree value = DECL_INITIAL (TREE_VALUE (values));
10250:
10251: /* Speed up the main loop by performing some precalculations */
10252: TREE_TYPE (TREE_VALUE (values)) = enumtype;
10253: TREE_TYPE (value) = enumtype;
10254: TREE_VALUE (values) = value;
10255: minnode = maxnode = value;
10256:
10257: for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
10258: {
10259: value = DECL_INITIAL (TREE_VALUE (pair));
10260: TREE_TYPE (TREE_VALUE (pair)) = enumtype;
10261: TREE_TYPE (value) = enumtype;
10262: TREE_VALUE (pair) = value;
10263: if (tree_int_cst_lt (maxnode, value))
10264: maxnode = value;
10265: else if (tree_int_cst_lt (value, minnode))
10266: minnode = value;
10267: }
10268: }
10269: else
10270: maxnode = minnode = integer_zero_node;
10271:
10272: TYPE_VALUES (enumtype) = values;
10273:
10274: {
10275: int unsignedp = tree_int_cst_sgn (minnode) >= 0;
10276: int lowprec = min_precision (minnode, unsignedp);
10277: int highprec = min_precision (maxnode, unsignedp);
10278: int precision = MAX (lowprec, highprec);
10279:
10280: if (! flag_short_enums && precision < TYPE_PRECISION (integer_type_node))
10281: precision = TYPE_PRECISION (integer_type_node);
10282:
10283:
10284: /*
10285: * The following code is unnecessary since the function
10286: * type_promotes_to deals correctly with promotion of enums of
10287: * underlying unsigned types to signed integer types.
10288: * Moreover, it causes an enum bitfield to require one more bit of
10289: * storage than defined by the ANSI/ISO C++ resolution section r.7.2
10290: * which defines the range of an enum.
10291: */
10292: #if 0
10293: /* Unlike the C frontend, we prefer signed types. */
10294: if (unsignedp && int_fits_type_p (maxnode, type_for_size (precision, 0)))
10295: unsignedp = 0;
10296: #endif
10297:
10298: TYPE_PRECISION (enumtype) = precision;
10299: TYPE_SIZE (enumtype) = NULL_TREE;
10300: if (unsignedp)
10301: fixup_unsigned_type (enumtype);
10302: else
10303: fixup_signed_type (enumtype);
10304: }
10305:
10306: if (flag_cadillac)
10307: cadillac_finish_enum (enumtype);
10308:
10309: {
10310: register tree tem;
10311:
10312: /* Fix up all variant types of this enum type. */
10313: for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
10314: tem = TYPE_NEXT_VARIANT (tem))
10315: {
10316: TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
10317: TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
10318: TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
10319: TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
10320: TYPE_MODE (tem) = TYPE_MODE (enumtype);
10321: TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
10322: TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
10323: TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
10324: }
10325: }
10326:
10327: /* Finish debugging output for this type. */
10328: #if 0
10329: /* @@ Do we ever generate generate ENUMERAL_TYPE nodes for which debugging
10330: information should *not* be generated? I think not. */
10331: if (! DECL_IGNORED_P (TYPE_NAME (enumtype)))
10332: #endif
10333: rest_of_type_compilation (enumtype, global_bindings_p ());
10334:
10335: return enumtype;
10336: }
10337:
10338: /* Build and install a CONST_DECL for one value of the
10339: current enumeration type (one that was begun with start_enum).
10340: Return a tree-list containing the name and its value.
10341: Assignment of sequential values by default is handled here. */
10342:
10343: tree
10344: build_enumerator (name, value)
10345: tree name, value;
10346: {
10347: tree decl, result;
10348: /* Change this to zero if we find VALUE is not shareable. */
10349: int shareable = 1;
10350:
10351: /* Remove no-op casts from the value. */
10352: if (value)
10353: STRIP_TYPE_NOPS (value);
10354:
10355: /* Validate and default VALUE. */
10356: if (value != NULL_TREE)
10357: {
10358: if (TREE_READONLY_DECL_P (value))
10359: {
10360: value = decl_constant_value (value);
10361: shareable = 0;
10362: }
10363:
10364: if (TREE_CODE (value) == INTEGER_CST)
10365: {
10366: value = default_conversion (value);
10367: constant_expression_warning (value);
10368: }
10369: else
10370: {
10371: cp_error ("enumerator value for `%D' not integer constant", name);
10372: value = NULL_TREE;
10373: }
10374: }
10375:
10376: /* The order of things is reversed here so that we
10377: can check for possible sharing of enum values,
10378: to keep that from happening. */
10379: /* Default based on previous value. */
10380: if (value == NULL_TREE)
10381: {
10382: value = enum_next_value;
10383: if (enum_overflow)
10384: cp_error ("overflow in enumeration values at `%D'", name);
10385: }
10386:
10387: /* Remove no-op casts from the value. */
10388: if (value)
10389: STRIP_TYPE_NOPS (value);
10390:
10391: /* Make up for hacks in lex.c. */
10392: if (value == integer_zero_node)
10393: value = build_int_2 (0, 0);
10394: else if (value == integer_one_node)
10395: value = build_int_2 (1, 0);
10396: else if (TREE_CODE (value) == INTEGER_CST
10397: && (shareable == 0
10398: || TREE_CODE (TREE_TYPE (value)) == ENUMERAL_TYPE))
10399: {
10400: value = copy_node (value);
10401: TREE_TYPE (value) = integer_type_node;
10402: }
10403:
10404: /* C++ associates enums with global, function, or class declarations. */
10405:
10406: decl = current_scope ();
10407: if (decl && decl == current_class_type)
10408: {
10409: /* This enum declaration is local to the class, so we must put
10410: it in that class's list of decls. */
10411: decl = build_lang_field_decl (CONST_DECL, name, integer_type_node);
10412: DECL_INITIAL (decl) = value;
10413: TREE_READONLY (decl) = 1;
10414: pushdecl_class_level (decl);
10415: TREE_CHAIN (decl) = current_local_enum;
10416: current_local_enum = decl;
10417: }
10418: else
10419: {
10420: /* It's a global enum, or it's local to a function. (Note local to
10421: a function could mean local to a class method. */
10422: decl = build_decl (CONST_DECL, name, integer_type_node);
10423: DECL_INITIAL (decl) = value;
10424:
10425: pushdecl (decl);
10426: GNU_xref_decl (current_function_decl, decl);
10427: }
10428:
10429: /* Set basis for default for next value. */
10430: enum_next_value = build_binary_op_nodefault (PLUS_EXPR, value,
10431: integer_one_node, PLUS_EXPR);
10432: enum_overflow = tree_int_cst_lt (enum_next_value, value);
10433:
10434: if (enum_next_value == integer_one_node)
10435: enum_next_value = copy_node (enum_next_value);
10436:
10437: result = saveable_tree_cons (name, decl, NULL_TREE);
10438: return result;
10439: }
10440:
10441: tree
10442: grok_enum_decls (type, decl)
10443: tree type, decl;
10444: {
10445: tree d = current_local_enum;
10446:
10447: if (d == NULL_TREE)
10448: return decl;
10449:
10450: while (1)
10451: {
10452: TREE_TYPE (d) = type;
10453: if (TREE_CHAIN (d) == NULL_TREE)
10454: {
10455: TREE_CHAIN (d) = decl;
10456: break;
10457: }
10458: d = TREE_CHAIN (d);
10459: }
10460:
10461: decl = current_local_enum;
10462: current_local_enum = NULL_TREE;
10463:
10464: return decl;
10465: }
10466:
10467: /* Create the FUNCTION_DECL for a function definition.
10468: DECLSPECS and DECLARATOR are the parts of the declaration;
10469: they describe the function's name and the type it returns,
10470: but twisted together in a fashion that parallels the syntax of C.
10471:
10472: This function creates a binding context for the function body
10473: as well as setting up the FUNCTION_DECL in current_function_decl.
10474:
10475: Returns 1 on success. If the DECLARATOR is not suitable for a function
10476: (it defines a datum instead), we return 0, which tells
10477: yyparse to report a parse error.
10478:
10479: For C++, we must first check whether that datum makes any sense.
10480: For example, "class A local_a(1,2);" means that variable local_a
10481: is an aggregate of type A, which should have a constructor
10482: applied to it with the argument list [1, 2].
10483:
10484: @@ There is currently no way to retrieve the storage
10485: @@ allocated to FUNCTION (or all of its parms) if we return
10486: @@ something we had previously. */
10487:
10488: int
10489: start_function (declspecs, declarator, raises, pre_parsed_p)
10490: tree declarator, declspecs, raises;
10491: int pre_parsed_p;
10492: {
10493: tree decl1, olddecl;
10494: tree ctype = NULL_TREE;
10495: tree fntype;
10496: tree restype;
10497: extern int have_extern_spec;
10498: extern int used_extern_spec;
10499: int doing_friend = 0;
10500:
10501: /* Sanity check. */
10502: my_friendly_assert (TREE_VALUE (void_list_node) == void_type_node, 160);
10503: my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
10504:
10505: /* Assume, until we see it does. */
10506: current_function_returns_value = 0;
10507: current_function_returns_null = 0;
10508: warn_about_return_type = 0;
10509: current_extern_inline = 0;
10510: current_function_assigns_this = 0;
10511: current_function_just_assigned_this = 0;
10512: current_function_parms_stored = 0;
10513: original_result_rtx = NULL_RTX;
10514: current_function_obstack_index = 0;
10515: current_function_obstack_usage = 0;
10516:
10517: clear_temp_name ();
10518:
10519: /* This should only be done once on the top most decl. */
10520: if (have_extern_spec && !used_extern_spec)
10521: {
10522: declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
10523: used_extern_spec = 1;
10524: }
10525:
10526: if (pre_parsed_p)
10527: {
10528: decl1 = declarator;
10529:
10530: if (! DECL_ARGUMENTS (decl1)
10531: && !DECL_STATIC_FUNCTION_P (decl1)
10532: && DECL_CONTEXT (decl1)
10533: && DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl1)))
10534: && IDENTIFIER_TEMPLATE (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl1)))))
10535: {
10536: cp_error ("redeclaration of `%#D'", decl1);
10537: if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)))
10538: cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)));
10539: else if (IDENTIFIER_GLOBAL_VALUE (DECL_NAME (decl1)))
10540: cp_error_at ("previous declaration here", IDENTIFIER_GLOBAL_VALUE (DECL_NAME (decl1)));
10541: }
10542:
10543: last_function_parms = DECL_ARGUMENTS (decl1);
10544: last_function_parm_tags = NULL_TREE;
10545: fntype = TREE_TYPE (decl1);
10546: if (TREE_CODE (fntype) == METHOD_TYPE)
10547: ctype = TYPE_METHOD_BASETYPE (fntype);
10548:
10549: /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
10550: class is in the (lexical) scope of the class in which it is
10551: defined. */
10552: if (!ctype && DECL_FRIEND_P (decl1))
10553: {
10554: ctype = DECL_CLASS_CONTEXT (decl1);
10555:
10556: /* CTYPE could be null here if we're dealing with a template;
10557: for example, `inline friend float foo()' inside a template
10558: will have no CTYPE set. */
10559: if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10560: ctype = NULL_TREE;
10561: else
10562: doing_friend = 1;
10563: }
10564:
10565: if ( !(DECL_VINDEX (decl1)
10566: && write_virtuals >= 2
10567: && CLASSTYPE_VTABLE_NEEDS_WRITING (ctype)))
10568: current_extern_inline = DECL_THIS_EXTERN (decl1) && DECL_INLINE (decl1);
10569:
10570: raises = TYPE_RAISES_EXCEPTIONS (fntype);
10571:
10572: /* In a fcn definition, arg types must be complete. */
10573: require_complete_types_for_parms (last_function_parms);
10574: }
10575: else
10576: {
10577: decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, raises);
10578: /* If the declarator is not suitable for a function definition,
10579: cause a syntax error. */
10580: if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
10581:
10582: fntype = TREE_TYPE (decl1);
10583:
10584: restype = TREE_TYPE (fntype);
10585: if (IS_AGGR_TYPE (restype) && ! TYPE_PTRMEMFUNC_P (restype)
10586: && ! CLASSTYPE_GOT_SEMICOLON (restype))
10587: {
10588: cp_error ("semicolon missing after declaration of `%#T'", restype);
10589: shadow_tag (build_tree_list (NULL_TREE, restype));
10590: CLASSTYPE_GOT_SEMICOLON (restype) = 1;
10591: if (TREE_CODE (fntype) == FUNCTION_TYPE)
10592: fntype = build_function_type (integer_type_node,
10593: TYPE_ARG_TYPES (fntype));
10594: else
10595: fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
10596: integer_type_node,
10597: TYPE_ARG_TYPES (fntype));
10598: TREE_TYPE (decl1) = fntype;
10599: }
10600:
10601: if (TREE_CODE (fntype) == METHOD_TYPE)
10602: ctype = TYPE_METHOD_BASETYPE (fntype);
10603: else if (IDENTIFIER_LENGTH (DECL_NAME (decl1)) == 4
10604: && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (decl1)), "main")
10605: && DECL_CONTEXT (decl1) == NULL_TREE)
10606: {
10607: /* If this doesn't return integer_type, complain. */
10608: if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
10609: {
10610: if (pedantic || warn_return_type)
10611: warning ("return type for `main' changed to integer type");
10612: TREE_TYPE (decl1) = fntype = default_function_type;
10613: }
10614: warn_about_return_type = 0;
10615: }
10616: }
10617:
10618: /* Warn if function was previously implicitly declared
10619: (but not if we warned then). */
10620: if (! warn_implicit
10621: && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
10622: cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
10623:
10624: current_function_decl = decl1;
10625:
10626: if (flag_cadillac)
10627: cadillac_start_function (decl1);
10628: else
10629: announce_function (decl1);
10630:
10631: if (TYPE_SIZE (TREE_TYPE (fntype)) == NULL_TREE)
10632: {
10633: if (IS_AGGR_TYPE (TREE_TYPE (fntype)))
10634: error_with_aggr_type (TREE_TYPE (fntype),
10635: "return-type `%s' is an incomplete type");
10636: else
10637: error ("return-type is an incomplete type");
10638:
10639: /* Make it return void instead, but don't change the
10640: type of the DECL_RESULT, in case we have a named return value. */
10641: if (ctype)
10642: TREE_TYPE (decl1)
10643: = build_cplus_method_type (build_type_variant (ctype,
10644: TREE_READONLY (decl1),
10645: TREE_SIDE_EFFECTS (decl1)),
10646: void_type_node,
10647: FUNCTION_ARG_CHAIN (decl1));
10648: else
10649: TREE_TYPE (decl1)
10650: = build_function_type (void_type_node,
10651: TYPE_ARG_TYPES (TREE_TYPE (decl1)));
10652: DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, TREE_TYPE (fntype));
10653: }
10654:
10655: if (warn_about_return_type)
10656: warning ("return-type defaults to `int'");
10657:
10658: /* Make the init_value nonzero so pushdecl knows this is not tentative.
10659: error_mark_node is replaced below (in poplevel) with the BLOCK. */
10660: DECL_INITIAL (decl1) = error_mark_node;
10661:
10662: /* Didn't get anything from C. */
10663: olddecl = NULL_TREE;
10664:
10665: /* This function exists in static storage.
10666: (This does not mean `static' in the C sense!) */
10667: TREE_STATIC (decl1) = 1;
10668:
10669: /* Record the decl so that the function name is defined.
10670: If we already have a decl for this name, and it is a FUNCTION_DECL,
10671: use the old decl. */
10672:
10673: if (pre_parsed_p == 0)
10674: {
10675: current_function_decl = decl1 = pushdecl (decl1);
10676: DECL_MAIN_VARIANT (decl1) = decl1;
10677: fntype = TREE_TYPE (decl1);
10678: }
10679: else
10680: current_function_decl = decl1;
10681:
10682: /* If this function belongs to an interface, it is public.
10683: If it belongs to someone else's interface, it is also external.
10684: It doesn't matter whether it's inline or not. */
10685: if (interface_unknown == 0
10686: && ! TREE_PUBLIC (decl1))
10687: {
10688: TREE_PUBLIC (decl1) = 1;
10689: DECL_EXTERNAL (decl1)
10690: = (interface_only
10691: || (DECL_INLINE (decl1) && ! flag_implement_inlines));
10692: }
10693: else
10694: {
10695: /* This is a definition, not a reference.
10696: So normally clear DECL_EXTERNAL.
10697: However, `extern inline' acts like a declaration except for
10698: defining how to inline. So set DECL_EXTERNAL in that case. */
10699: DECL_EXTERNAL (decl1) = current_extern_inline;
10700:
10701: DECL_DEFER_OUTPUT (decl1)
10702: = DECL_INLINE (decl1) && ! TREE_PUBLIC (decl1)
10703: && (DECL_FUNCTION_MEMBER_P (decl1)
10704: || DECL_TEMPLATE_INSTANTIATION (decl1));
10705: }
10706:
10707: if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1))
10708: {
10709: if (TREE_CODE (fntype) == METHOD_TYPE)
10710: TREE_TYPE (decl1) = fntype
10711: = build_function_type (TREE_TYPE (fntype),
10712: TREE_CHAIN (TYPE_ARG_TYPES (fntype)));
10713: last_function_parms = TREE_CHAIN (last_function_parms);
10714: DECL_ARGUMENTS (decl1) = last_function_parms;
10715: ctype = NULL_TREE;
10716: }
10717: restype = TREE_TYPE (fntype);
10718:
10719: pushlevel (0);
10720: current_binding_level->parm_flag = 1;
10721:
10722: /* Save the parm names or decls from this function's declarator
10723: where store_parm_decls will find them. */
10724: current_function_parms = last_function_parms;
10725: current_function_parm_tags = last_function_parm_tags;
10726:
10727: GNU_xref_function (decl1, current_function_parms);
10728:
10729: make_function_rtl (decl1);
10730:
10731: if (ctype)
10732: {
10733: push_nested_class (ctype, 1);
10734:
10735: /* If we're compiling a friend function, neither of the variables
10736: current_class_decl nor current_class_type will have values. */
10737: if (! doing_friend)
10738: {
10739: /* We know that this was set up by `grokclassfn'.
10740: We do not wait until `store_parm_decls', since evil
10741: parse errors may never get us to that point. Here
10742: we keep the consistency between `current_class_type'
10743: and `current_class_decl'. */
10744: current_class_decl = last_function_parms;
10745: my_friendly_assert (current_class_decl != NULL_TREE
10746: && TREE_CODE (current_class_decl) == PARM_DECL, 162);
10747: if (TREE_CODE (TREE_TYPE (current_class_decl)) == POINTER_TYPE)
10748: {
10749: tree variant = TREE_TYPE (TREE_TYPE (current_class_decl));
10750: if (CLASSTYPE_INST_VAR (ctype) == NULL_TREE)
10751: {
10752: /* Can't call build_indirect_ref here, because it has special
10753: logic to return C_C_D given this argument. */
10754: C_C_D = build1 (INDIRECT_REF, current_class_type, current_class_decl);
10755: CLASSTYPE_INST_VAR (ctype) = C_C_D;
10756: }
10757: else
10758: {
10759: C_C_D = CLASSTYPE_INST_VAR (ctype);
10760: /* `current_class_decl' is different for every
10761: function we compile. */
10762: TREE_OPERAND (C_C_D, 0) = current_class_decl;
10763: }
10764: TREE_READONLY (C_C_D) = TYPE_READONLY (variant);
10765: TREE_SIDE_EFFECTS (C_C_D) = TYPE_VOLATILE (variant);
10766: TREE_THIS_VOLATILE (C_C_D) = TYPE_VOLATILE (variant);
10767: }
10768: else
10769: C_C_D = current_class_decl;
10770: }
10771: }
10772: else
10773: {
10774: if (DECL_STATIC_FUNCTION_P (decl1))
10775: push_nested_class (DECL_CONTEXT (decl1), 2);
10776: else
10777: push_memoized_context (0, 1);
10778: }
10779:
10780: /* Allocate further tree nodes temporarily during compilation
10781: of this function only. Tiemann moved up here from bottom of fn. */
10782: temporary_allocation ();
10783:
10784: /* Promote the value to int before returning it. */
10785: if (C_PROMOTING_INTEGER_TYPE_P (restype))
10786: {
10787: /* It retains unsignedness if traditional or if it isn't
10788: really getting wider. */
10789: if (TREE_UNSIGNED (restype)
10790: && (flag_traditional
10791: || TYPE_PRECISION (restype)
10792: == TYPE_PRECISION (integer_type_node)))
10793: restype = unsigned_type_node;
10794: else
10795: restype = integer_type_node;
10796: }
10797: if (DECL_RESULT (decl1) == NULL_TREE)
10798: DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, restype);
10799:
10800: if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1)))
10801: {
10802: dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10803: ctor_label = NULL_TREE;
10804: }
10805: else
10806: {
10807: dtor_label = NULL_TREE;
10808: if (DECL_CONSTRUCTOR_P (decl1))
10809: ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10810: }
10811:
10812: /* If this fcn was already referenced via a block-scope `extern' decl
10813: (or an implicit decl), propagate certain information about the usage. */
10814: if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
10815: TREE_ADDRESSABLE (decl1) = 1;
10816:
10817: return 1;
10818: }
10819:
10820: /* Store the parameter declarations into the current function declaration.
10821: This is called after parsing the parameter declarations, before
10822: digesting the body of the function.
10823:
10824: Also install to binding contour return value identifier, if any. */
10825:
10826: void
10827: store_parm_decls ()
10828: {
10829: register tree fndecl = current_function_decl;
10830: register tree parm;
10831: int parms_have_cleanups = 0;
10832:
10833: /* This is either a chain of PARM_DECLs (when a prototype is used). */
10834: tree specparms = current_function_parms;
10835:
10836: /* This is a list of types declared among parms in a prototype. */
10837: tree parmtags = current_function_parm_tags;
10838:
10839: /* This is a chain of any other decls that came in among the parm
10840: declarations. If a parm is declared with enum {foo, bar} x;
10841: then CONST_DECLs for foo and bar are put here. */
10842: tree nonparms = NULL_TREE;
10843:
10844: if (current_binding_level == global_binding_level)
10845: fatal ("parse errors have confused me too much");
10846:
10847: /* Initialize RTL machinery. */
10848: init_function_start (fndecl, input_filename, lineno);
10849:
10850: /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
10851: declare_function_name ();
10852:
10853: /* Create a binding level for the parms. */
10854: expand_start_bindings (0);
10855:
10856: if (specparms != NULL_TREE)
10857: {
10858: /* This case is when the function was defined with an ANSI prototype.
10859: The parms already have decls, so we need not do anything here
10860: except record them as in effect
10861: and complain if any redundant old-style parm decls were written. */
10862:
10863: register tree next;
10864:
10865: /* Must clear this because it might contain TYPE_DECLs declared
10866: at class level. */
10867: storedecls (NULL_TREE);
10868: for (parm = nreverse (specparms); parm; parm = next)
10869: {
10870: next = TREE_CHAIN (parm);
10871: if (TREE_CODE (parm) == PARM_DECL)
10872: {
10873: tree cleanup = maybe_build_cleanup (parm);
10874: if (DECL_NAME (parm) == NULL_TREE)
10875: {
10876: #if 0
10877: cp_error_at ("parameter name omitted", parm);
10878: #else
10879: /* for C++, this is not an error. */
10880: pushdecl (parm);
10881: #endif
10882: }
10883: else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
10884: cp_error ("parameter `%D' declared void", parm);
10885: else
10886: {
10887: /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
10888: A parameter is assumed not to have any side effects.
10889: If this should change for any reason, then this
10890: will have to wrap the bashed reference type in a save_expr.
10891:
10892: Also, if the parameter type is declared to be an X
10893: and there is an X(X&) constructor, we cannot lay it
10894: into the stack (any more), so we make this parameter
10895: look like it is really of reference type. Functions
10896: which pass parameters to this function will know to
10897: create a temporary in their frame, and pass a reference
10898: to that. */
10899:
10900: if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
10901: && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))))
10902: SET_DECL_REFERENCE_SLOT (parm, convert_from_reference (parm));
10903:
10904: pushdecl (parm);
10905: }
10906: if (cleanup)
10907: {
10908: expand_decl (parm);
10909: if (! expand_decl_cleanup (parm, cleanup))
10910: cp_error ("parser lost in parsing declaration of `%D'",
10911: parm);
10912: parms_have_cleanups = 1;
10913: }
10914: }
10915: else
10916: {
10917: /* If we find an enum constant or a type tag,
10918: put it aside for the moment. */
10919: TREE_CHAIN (parm) = NULL_TREE;
10920: nonparms = chainon (nonparms, parm);
10921: }
10922: }
10923:
10924: /* Get the decls in their original chain order
10925: and record in the function. This is all and only the
10926: PARM_DECLs that were pushed into scope by the loop above. */
10927: DECL_ARGUMENTS (fndecl) = getdecls ();
10928:
10929: storetags (chainon (parmtags, gettags ()));
10930: }
10931: else
10932: DECL_ARGUMENTS (fndecl) = NULL_TREE;
10933:
10934: /* Now store the final chain of decls for the arguments
10935: as the decl-chain of the current lexical scope.
10936: Put the enumerators in as well, at the front so that
10937: DECL_ARGUMENTS is not modified. */
10938:
10939: storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
10940:
10941: /* Initialize the RTL code for the function. */
10942: DECL_SAVED_INSNS (fndecl) = NULL_RTX;
10943: expand_function_start (fndecl, parms_have_cleanups);
10944:
10945: /* Create a binding contour which can be used to catch
10946: cleanup-generated temporaries. Also, if the return value needs or
10947: has initialization, deal with that now. */
10948: if (parms_have_cleanups)
10949: {
10950: pushlevel (0);
10951: expand_start_bindings (0);
10952: }
10953:
10954: current_function_parms_stored = 1;
10955:
10956: if (flag_gc)
10957: {
10958: maybe_gc_cleanup = build_tree_list (NULL_TREE, error_mark_node);
10959: if (! expand_decl_cleanup (NULL_TREE, maybe_gc_cleanup))
10960: cp_error ("parser lost in parsing declaration of `%D'", fndecl);
10961: }
10962:
10963: /* If this function is `main', emit a call to `__main'
10964: to run global initializers, etc. */
10965: if (DECL_NAME (fndecl)
10966: && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 4
10967: && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
10968: && DECL_CONTEXT (fndecl) == NULL_TREE)
10969: {
10970: expand_main_function ();
10971:
10972: if (flag_gc)
10973: expand_expr (build_function_call (lookup_name (get_identifier ("__gc_main"), 0), NULL_TREE),
10974: 0, VOIDmode, 0);
10975:
10976: if (flag_dossier)
10977: output_builtin_tdesc_entries ();
10978: }
10979: }
10980:
10981: /* Bind a name and initialization to the return value of
10982: the current function. */
10983: void
10984: store_return_init (return_id, init)
10985: tree return_id, init;
10986: {
10987: tree decl = DECL_RESULT (current_function_decl);
10988:
10989: if (flag_ansi)
10990: /* Give this error as many times as there are occurrences,
10991: so that users can use Emacs compilation buffers to find
10992: and fix all such places. */
10993: pedwarn ("ANSI C++ does not permit named return values");
10994:
10995: if (return_id != NULL_TREE)
10996: {
10997: if (DECL_NAME (decl) == NULL_TREE)
10998: {
10999: DECL_NAME (decl) = return_id;
11000: DECL_ASSEMBLER_NAME (decl) = return_id;
11001: }
11002: else
11003: error ("return identifier `%s' already in place",
11004: IDENTIFIER_POINTER (DECL_NAME (decl)));
11005: }
11006:
11007: /* Can't let this happen for constructors. */
11008: if (DECL_CONSTRUCTOR_P (current_function_decl))
11009: {
11010: error ("can't redefine default return value for constructors");
11011: return;
11012: }
11013:
11014: /* If we have a named return value, put that in our scope as well. */
11015: if (DECL_NAME (decl) != NULL_TREE)
11016: {
11017: /* If this named return value comes in a register,
11018: put it in a pseudo-register. */
11019: if (DECL_REGISTER (decl))
11020: {
11021: original_result_rtx = DECL_RTL (decl);
11022: DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
11023: }
11024:
11025: /* Let `finish_decl' know that this initializer is ok. */
11026: DECL_INITIAL (decl) = init;
11027: pushdecl (decl);
11028: finish_decl (decl, init, 0, 0);
11029: }
11030: }
11031:
11032:
11033: /* Finish up a function declaration and compile that function
11034: all the way to assembler language output. The free the storage
11035: for the function definition.
11036:
11037: This is called after parsing the body of the function definition.
11038: LINENO is the current line number.
11039:
11040: C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
11041: (and expand_end_bindings) must be made to take care of the binding
11042: contour for the base initializers. This is only relevant for
11043: constructors. */
11044:
11045: void
11046: finish_function (lineno, call_poplevel)
11047: int lineno;
11048: int call_poplevel;
11049: {
11050: register tree fndecl = current_function_decl;
11051: tree fntype, ctype = NULL_TREE;
11052: rtx head, last_parm_insn, mark;
11053: /* Label to use if this function is supposed to return a value. */
11054: tree no_return_label = NULL_TREE;
11055: tree decls = NULL_TREE;
11056:
11057: /* When we get some parse errors, we can end up without a
11058: current_function_decl, so cope. */
11059: if (fndecl == NULL_TREE)
11060: return;
11061:
11062: fntype = TREE_TYPE (fndecl);
11063:
11064: /* TREE_READONLY (fndecl) = 1;
11065: This caused &foo to be of type ptr-to-const-function
11066: which then got a warning when stored in a ptr-to-function variable. */
11067:
11068: /* This happens on strange parse errors. */
11069: if (! current_function_parms_stored)
11070: {
11071: call_poplevel = 0;
11072: store_parm_decls ();
11073: }
11074:
11075: if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
11076: {
11077: tree ttype = target_type (fntype);
11078: tree parmdecl;
11079:
11080: if (IS_AGGR_TYPE (ttype))
11081: /* Let debugger know it should output info for this type. */
11082: note_debug_info_needed (ttype);
11083:
11084: for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
11085: {
11086: ttype = target_type (TREE_TYPE (parmdecl));
11087: if (IS_AGGR_TYPE (ttype))
11088: /* Let debugger know it should output info for this type. */
11089: note_debug_info_needed (ttype);
11090: }
11091: }
11092:
11093: /* Clean house because we will need to reorder insns here. */
11094: do_pending_stack_adjust ();
11095:
11096: if (dtor_label)
11097: {
11098: tree binfo = TYPE_BINFO (current_class_type);
11099: tree cond = integer_one_node;
11100: tree exprstmt, vfields;
11101: tree in_charge_node = lookup_name (in_charge_identifier, 0);
11102: tree virtual_size;
11103: int ok_to_optimize_dtor = 0;
11104:
11105: if (current_function_assigns_this)
11106: cond = build (NE_EXPR, integer_type_node,
11107: current_class_decl, integer_zero_node);
11108: else
11109: {
11110: int n_baseclasses = CLASSTYPE_N_BASECLASSES (current_class_type);
11111:
11112: /* If this destructor is empty, then we don't need to check
11113: whether `this' is NULL in some cases. */
11114: mark = get_last_insn ();
11115: last_parm_insn = get_first_nonparm_insn ();
11116:
11117: if ((flag_this_is_variable & 1) == 0)
11118: ok_to_optimize_dtor = 1;
11119: else if (mark == last_parm_insn)
11120: ok_to_optimize_dtor
11121: = (n_baseclasses == 0
11122: || (n_baseclasses == 1
11123: && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type, 0))));
11124: }
11125:
11126: /* These initializations might go inline. Protect
11127: the binding level of the parms. */
11128: pushlevel (0);
11129: expand_start_bindings (0);
11130:
11131: if (current_function_assigns_this)
11132: {
11133: current_function_assigns_this = 0;
11134: current_function_just_assigned_this = 0;
11135: }
11136:
11137: /* Generate the code to call destructor on base class.
11138: If this destructor belongs to a class with virtual
11139: functions, then set the virtual function table
11140: pointer to represent the type of our base class. */
11141:
11142: /* This side-effect makes call to `build_delete' generate the
11143: code we have to have at the end of this destructor. */
11144: TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
11145:
11146: /* These are two cases where we cannot delegate deletion. */
11147: if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
11148: || TYPE_GETS_REG_DELETE (current_class_type))
11149: exprstmt = build_delete (current_class_type, C_C_D, integer_zero_node,
11150: LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
11151: else
11152: exprstmt = build_delete (current_class_type, C_C_D, in_charge_node,
11153: LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
11154:
11155: /* If we did not assign to this, then `this' is non-zero at
11156: the end of a destructor. As a special optimization, don't
11157: emit test if this is an empty destructor. If it does nothing,
11158: it does nothing. If it calls a base destructor, the base
11159: destructor will perform the test. */
11160:
11161: if (exprstmt != error_mark_node
11162: && (TREE_CODE (exprstmt) != NOP_EXPR
11163: || TREE_OPERAND (exprstmt, 0) != integer_zero_node
11164: || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
11165: {
11166: expand_label (dtor_label);
11167: if (cond != integer_one_node)
11168: expand_start_cond (cond, 0);
11169: if (exprstmt != void_zero_node)
11170: /* Don't call `expand_expr_stmt' if we're not going to do
11171: anything, since -Wall will give a diagnostic. */
11172: expand_expr_stmt (exprstmt);
11173:
11174: /* Run destructor on all virtual baseclasses. */
11175: if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
11176: {
11177: tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
11178: expand_start_cond (build (BIT_AND_EXPR, integer_type_node,
11179: in_charge_node, integer_two_node), 0);
11180: while (vbases)
11181: {
11182: if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
11183: {
11184: tree ptr = convert_pointer_to_vbase (vbases, current_class_decl);
11185: expand_expr_stmt (build_delete (TYPE_POINTER_TO (BINFO_TYPE (vbases)),
11186: ptr, integer_zero_node,
11187: LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_HAS_IN_CHARGE, 0));
11188: }
11189: vbases = TREE_CHAIN (vbases);
11190: }
11191: expand_end_cond ();
11192: }
11193:
11194: do_pending_stack_adjust ();
11195: if (cond != integer_one_node)
11196: expand_end_cond ();
11197: }
11198:
11199: TYPE_HAS_DESTRUCTOR (current_class_type) = 1;
11200:
11201: virtual_size = c_sizeof (current_class_type);
11202:
11203: /* At the end, call delete if that's what's requested. */
11204: if (TYPE_GETS_REG_DELETE (current_class_type))
11205: /* This NOP_EXPR means we are in a static call context. */
11206: exprstmt =
11207: build_method_call
11208: (build_indirect_ref
11209: (build1 (NOP_EXPR, TYPE_POINTER_TO (current_class_type),
11210: error_mark_node),
11211: NULL_PTR),
11212: ansi_opname[(int) DELETE_EXPR],
11213: tree_cons (NULL_TREE, current_class_decl,
11214: build_tree_list (NULL_TREE, virtual_size)),
11215: NULL_TREE, LOOKUP_NORMAL);
11216: else if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
11217: exprstmt = build_x_delete (ptr_type_node, current_class_decl, 0,
11218: virtual_size);
11219: else
11220: exprstmt = NULL_TREE;
11221:
11222: if (exprstmt)
11223: {
11224: cond = build (BIT_AND_EXPR, integer_type_node,
11225: in_charge_node, integer_one_node);
11226: expand_start_cond (cond, 0);
11227: expand_expr_stmt (exprstmt);
11228: expand_end_cond ();
11229: }
11230:
11231: /* End of destructor. */
11232: expand_end_bindings (NULL_TREE, getdecls() != NULL_TREE, 0);
11233: poplevel (2, 0, 0); /* XXX change to 1 */
11234:
11235: /* Back to the top of destructor. */
11236: /* Dont execute destructor code if `this' is NULL. */
11237: mark = get_last_insn ();
11238: last_parm_insn = get_first_nonparm_insn ();
11239: if (last_parm_insn == NULL_RTX)
11240: last_parm_insn = mark;
11241: else
11242: last_parm_insn = previous_insn (last_parm_insn);
11243:
11244: /* Make all virtual function table pointers in non-virtual base
11245: classes point to CURRENT_CLASS_TYPE's virtual function
11246: tables. */
11247: expand_direct_vtbls_init (binfo, binfo, 1, 0, current_class_decl);
11248: if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
11249: expand_indirect_vtbls_init (binfo, C_C_D, current_class_decl, 0);
11250: if (! ok_to_optimize_dtor)
11251: {
11252: cond = build_binary_op (NE_EXPR,
11253: current_class_decl, integer_zero_node, 1);
11254: expand_start_cond (cond, 0);
11255: }
11256: if (mark != get_last_insn ())
11257: reorder_insns (next_insn (mark), get_last_insn (), last_parm_insn);
11258: if (! ok_to_optimize_dtor)
11259: expand_end_cond ();
11260: }
11261: else if (current_function_assigns_this)
11262: {
11263: /* Does not need to call emit_base_init, because
11264: that is done (if needed) just after assignment to this
11265: is seen. */
11266:
11267: if (DECL_CONSTRUCTOR_P (current_function_decl))
11268: {
11269: expand_label (ctor_label);
11270: ctor_label = NULL_TREE;
11271:
11272: if (call_poplevel)
11273: {
11274: decls = getdecls ();
11275: expand_end_bindings (decls, decls != NULL_TREE, 0);
11276: poplevel (decls != NULL_TREE, 0, 0);
11277: }
11278: c_expand_return (current_class_decl);
11279: }
11280: else if (TYPE_MAIN_VARIANT (TREE_TYPE (
11281: DECL_RESULT (current_function_decl))) != void_type_node
11282: && return_label != NULL_RTX)
11283: no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11284:
11285: current_function_assigns_this = 0;
11286: current_function_just_assigned_this = 0;
11287: base_init_insns = NULL_RTX;
11288: }
11289: else if (DECL_CONSTRUCTOR_P (fndecl))
11290: {
11291: tree allocated_this;
11292: tree cond, thenclause;
11293: /* Allow constructor for a type to get a new instance of the object
11294: using `build_new'. */
11295: tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type);
11296: CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = NULL_TREE;
11297:
11298: DECL_RETURNS_FIRST_ARG (fndecl) = 1;
11299:
11300: if (flag_this_is_variable > 0)
11301: {
11302: cond = build_binary_op (EQ_EXPR,
11303: current_class_decl, integer_zero_node, 1);
11304: thenclause = build_modify_expr (current_class_decl, NOP_EXPR,
11305: build_new (NULL_TREE, current_class_type, void_type_node, 0));
11306: }
11307:
11308: CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = abstract_virtuals;
11309:
11310: /* must keep the first insn safe. */
11311: head = get_insns ();
11312:
11313: /* this note will come up to the top with us. */
11314: mark = get_last_insn ();
11315:
11316: if (flag_this_is_variable > 0)
11317: {
11318: expand_start_cond (cond, 0);
11319: expand_expr_stmt (thenclause);
11320: expand_end_cond ();
11321: }
11322:
11323: #if 0
11324: if (DECL_NAME (fndecl) == NULL_TREE
11325: && TREE_CHAIN (DECL_ARGUMENTS (fndecl)) != NULL_TREE)
11326: build_default_constructor (fndecl);
11327: #endif
11328:
11329: /* Emit insns from `emit_base_init' which sets up virtual
11330: function table pointer(s). */
11331: emit_insns (base_init_insns);
11332: base_init_insns = NULL_RTX;
11333:
11334: /* This is where the body of the constructor begins.
11335: If there were no insns in this function body, then the
11336: last_parm_insn is also the last insn.
11337:
11338: If optimization is enabled, last_parm_insn may move, so
11339: we don't hold on to it (across emit_base_init). */
11340: last_parm_insn = get_first_nonparm_insn ();
11341: if (last_parm_insn == NULL_RTX)
11342: last_parm_insn = mark;
11343: else
11344: last_parm_insn = previous_insn (last_parm_insn);
11345:
11346: if (mark != get_last_insn ())
11347: reorder_insns (next_insn (mark), get_last_insn (), last_parm_insn);
11348:
11349: /* This is where the body of the constructor ends. */
11350: expand_label (ctor_label);
11351: ctor_label = NULL_TREE;
11352:
11353: if (call_poplevel)
11354: {
11355: expand_end_bindings (decls = getdecls (), decls != NULL_TREE, 0);
11356: poplevel (decls != NULL_TREE, 1, 0);
11357: }
11358:
11359: c_expand_return (current_class_decl);
11360:
11361: current_function_assigns_this = 0;
11362: current_function_just_assigned_this = 0;
11363: }
11364: else if (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 4
11365: && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main")
11366: && DECL_CONTEXT (fndecl) == NULL_TREE)
11367: {
11368: /* Make it so that `main' always returns 0 by default. */
11369: #ifdef VMS
11370: c_expand_return (integer_one_node);
11371: #else
11372: c_expand_return (integer_zero_node);
11373: #endif
11374: }
11375: else if (return_label != NULL_RTX
11376: && current_function_return_value == NULL_TREE
11377: && ! DECL_NAME (DECL_RESULT (current_function_decl)))
11378: no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11379:
11380: if (flag_gc)
11381: expand_gc_prologue_and_epilogue ();
11382:
11383: /* That's the end of the vtable decl's life. Need to mark it such
11384: if doing stupid register allocation.
11385:
11386: Note that current_vtable_decl is really an INDIRECT_REF
11387: on top of a VAR_DECL here. */
11388: if (obey_regdecls && current_vtable_decl)
11389: use_variable (DECL_RTL (TREE_OPERAND (current_vtable_decl, 0)));
11390:
11391: /* If this function is supposed to return a value, ensure that
11392: we do not fall into the cleanups by mistake. The end of our
11393: function will look like this:
11394:
11395: user code (may have return stmt somewhere)
11396: goto no_return_label
11397: cleanup_label:
11398: cleanups
11399: goto return_label
11400: no_return_label:
11401: NOTE_INSN_FUNCTION_END
11402: return_label:
11403: things for return
11404:
11405: If the user omits a return stmt in the USER CODE section, we
11406: will have a control path which reaches NOTE_INSN_FUNCTION_END.
11407: Otherwise, we won't. */
11408: if (no_return_label)
11409: {
11410: DECL_CONTEXT (no_return_label) = fndecl;
11411: DECL_INITIAL (no_return_label) = error_mark_node;
11412: DECL_SOURCE_FILE (no_return_label) = input_filename;
11413: DECL_SOURCE_LINE (no_return_label) = lineno;
11414: expand_goto (no_return_label);
11415: }
11416:
11417: if (cleanup_label)
11418: {
11419: /* remove the binding contour which is used
11420: to catch cleanup-generated temporaries. */
11421: expand_end_bindings (0, 0, 0);
11422: poplevel (0, 0, 0);
11423: }
11424:
11425: if (cleanup_label)
11426: /* Emit label at beginning of cleanup code for parameters. */
11427: emit_label (cleanup_label);
11428:
11429: /* Get return value into register if that's where it's supposed to be. */
11430: if (original_result_rtx)
11431: fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
11432:
11433: /* Finish building code that will trigger warnings if users forget
11434: to make their functions return values. */
11435: if (no_return_label || cleanup_label)
11436: emit_jump (return_label);
11437: if (no_return_label)
11438: {
11439: /* We don't need to call `expand_*_return' here because we
11440: don't need any cleanups here--this path of code is only
11441: for error checking purposes. */
11442: expand_label (no_return_label);
11443: }
11444:
11445: /* reset scope for C++: if we were in the scope of a class,
11446: then when we finish this function, we are not longer so.
11447: This cannot be done until we know for sure that no more
11448: class members will ever be referenced in this function
11449: (i.e., calls to destructors). */
11450: if (current_class_name)
11451: {
11452: ctype = current_class_type;
11453: pop_nested_class (1);
11454: }
11455: else
11456: pop_memoized_context (1);
11457:
11458: /* Generate rtl for function exit. */
11459: expand_function_end (input_filename, lineno, 1);
11460:
11461: if (flag_handle_exceptions)
11462: expand_exception_blocks();
11463:
11464: /* This must come after expand_function_end because cleanups might
11465: have declarations (from inline functions) that need to go into
11466: this function's blocks. */
11467: if (current_binding_level->parm_flag != 1)
11468: my_friendly_abort (122);
11469: poplevel (1, 0, 1);
11470:
11471: /* Must mark the RESULT_DECL as being in this function. */
11472: DECL_CONTEXT (DECL_RESULT (fndecl)) = DECL_INITIAL (fndecl);
11473:
11474: /* Obey `register' declarations if `setjmp' is called in this fn. */
11475: if (flag_traditional && current_function_calls_setjmp)
11476: setjmp_protect (DECL_INITIAL (fndecl));
11477:
11478: /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11479: to the FUNCTION_DECL node itself. */
11480: BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11481:
11482: /* So we can tell if jump_optimize sets it to 1. */
11483: can_reach_end = 0;
11484:
11485: if (DECL_EXTERNAL (fndecl)
11486: /* This function is just along for the ride. If we can make
11487: it inline, that's great. Otherwise, just punt it. */
11488: && (DECL_INLINE (fndecl) == 0
11489: || flag_no_inline
11490: || function_cannot_inline_p (fndecl)
11491: /* ??? Compensate for Sun brain damage in dealing with
11492: data segments of PIC code. */
11493: || (flag_pic
11494: && (DECL_CONSTRUCTOR_P (fndecl)
11495: || DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
11496: && CLASSTYPE_NEEDS_VIRTUAL_REINIT (TYPE_METHOD_BASETYPE (fntype)))))
11497:
11498: {
11499: extern int rtl_dump_and_exit;
11500: int old_rtl_dump_and_exit = rtl_dump_and_exit;
11501: int inline_spec = DECL_INLINE (fndecl);
11502:
11503: /* This throws away the code for FNDECL. */
11504: rtl_dump_and_exit = 1;
11505: /* This throws away the memory of the code for FNDECL. */
11506: if (flag_no_inline)
11507: DECL_INLINE (fndecl) = 0;
11508: rest_of_compilation (fndecl);
11509: rtl_dump_and_exit = old_rtl_dump_and_exit;
11510: DECL_INLINE (fndecl) = inline_spec;
11511: }
11512: else
11513: {
11514: /* Run the optimizers and output the assembler code for this
11515: function. */
11516: rest_of_compilation (fndecl);
11517: }
11518:
11519: if (DECL_INLINE (fndecl) && !TREE_ASM_WRITTEN (fndecl)
11520: && DECL_DEFER_OUTPUT (fndecl))
11521: {
11522: mark_inline_for_output (fndecl);
11523: }
11524:
11525: if (ctype && TREE_ASM_WRITTEN (fndecl))
11526: note_debug_info_needed (ctype);
11527:
11528: current_function_returns_null |= can_reach_end;
11529:
11530: /* Since we don't normally go through c_expand_return for constructors,
11531: this normally gets the wrong value.
11532: Also, named return values have their return codes emitted after
11533: NOTE_INSN_FUNCTION_END, confusing jump.c. */
11534: if (DECL_CONSTRUCTOR_P (fndecl)
11535: || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
11536: current_function_returns_null = 0;
11537:
11538: if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
11539: cp_warning ("`noreturn' function `%D' does return", fndecl);
11540: else if ((warn_return_type || pedantic)
11541: && current_function_returns_null
11542: && TYPE_MAIN_VARIANT (TREE_TYPE (fntype)) != void_type_node)
11543: {
11544: /* If this function returns non-void and control can drop through,
11545: complain. */
11546: cp_pedwarn ("control reaches end of non-void function `%D'", fndecl);
11547: }
11548: /* With just -W, complain only if function returns both with
11549: and without a value. */
11550: else if (extra_warnings
11551: && current_function_returns_value && current_function_returns_null)
11552: warning ("this function may return with or without a value");
11553:
11554: /* Free all the tree nodes making up this function. */
11555: /* Switch back to allocating nodes permanently
11556: until we start another function. */
11557: permanent_allocation (1);
11558:
11559: if (flag_cadillac)
11560: cadillac_finish_function (fndecl);
11561:
11562: if (DECL_SAVED_INSNS (fndecl) == NULL_RTX)
11563: {
11564: /* Stop pointing to the local nodes about to be freed. */
11565: /* But DECL_INITIAL must remain nonzero so we know this
11566: was an actual function definition. */
11567: DECL_INITIAL (fndecl) = error_mark_node;
11568: if (! DECL_CONSTRUCTOR_P (fndecl)
11569: || !TYPE_USES_VIRTUAL_BASECLASSES (TYPE_METHOD_BASETYPE (fntype)))
11570: DECL_ARGUMENTS (fndecl) = NULL_TREE;
11571: }
11572:
11573: /* Let the error reporting routines know that we're outside a function. */
11574: current_function_decl = NULL_TREE;
11575: named_label_uses = NULL_TREE;
11576: }
11577:
11578: /* Create the FUNCTION_DECL for a function definition.
11579: LINE1 is the line number that the definition absolutely begins on.
11580: LINE2 is the line number that the name of the function appears on.
11581: DECLSPECS and DECLARATOR are the parts of the declaration;
11582: they describe the return type and the name of the function,
11583: but twisted together in a fashion that parallels the syntax of C.
11584:
11585: This function creates a binding context for the function body
11586: as well as setting up the FUNCTION_DECL in current_function_decl.
11587:
11588: Returns a FUNCTION_DECL on success.
11589:
11590: If the DECLARATOR is not suitable for a function (it defines a datum
11591: instead), we return 0, which tells yyparse to report a parse error.
11592:
11593: May return void_type_node indicating that this method is actually
11594: a friend. See grokfield for more details.
11595:
11596: Came here with a `.pushlevel' .
11597:
11598: DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
11599: CHANGES TO CODE IN `grokfield'. */
11600: tree
11601: start_method (declspecs, declarator, raises)
11602: tree declarator, declspecs, raises;
11603: {
11604: tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0, raises);
11605:
11606: /* Something too ugly to handle. */
11607: if (fndecl == NULL_TREE)
11608: return NULL_TREE;
11609:
11610: /* Pass friends other than inline friend functions back. */
11611: if (TYPE_MAIN_VARIANT (fndecl) == void_type_node)
11612: return fndecl;
11613:
11614: if (TREE_CODE (fndecl) != FUNCTION_DECL)
11615: /* Not a function, tell parser to report parse error. */
11616: return NULL_TREE;
11617:
11618: if (IS_SIGNATURE (current_class_type))
11619: {
11620: IS_DEFAULT_IMPLEMENTATION (fndecl) = 1;
11621: /* In case we need this info later. */
11622: HAS_DEFAULT_IMPLEMENTATION (current_class_type) = 1;
11623: }
11624:
11625: if (DECL_IN_AGGR_P (fndecl))
11626: {
11627: if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
11628: {
11629: if (DECL_CONTEXT (fndecl))
11630: cp_error ("`%D' is already defined in class %s", fndecl,
11631: TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
11632: }
11633: return void_type_node;
11634: }
11635:
11636: if (flag_default_inline)
11637: DECL_INLINE (fndecl) = 1;
11638:
11639: if (processing_template_defn)
11640: SET_DECL_IMPLICIT_INSTANTIATION (fndecl);
11641:
11642: /* We read in the parameters on the maybepermanent_obstack,
11643: but we won't be getting back to them until after we
11644: may have clobbered them. So the call to preserve_data
11645: will keep them safe. */
11646: preserve_data ();
11647:
11648: if (! DECL_FRIEND_P (fndecl))
11649: {
11650: if (DECL_CHAIN (fndecl) != NULL_TREE)
11651: {
11652: /* Need a fresh node here so that we don't get circularity
11653: when we link these together. If FNDECL was a friend, then
11654: `pushdecl' does the right thing, which is nothing wrt its
11655: current value of DECL_CHAIN. */
11656: fndecl = copy_node (fndecl);
11657: }
11658: if (TREE_CHAIN (fndecl))
11659: {
11660: fndecl = copy_node (fndecl);
11661: TREE_CHAIN (fndecl) = NULL_TREE;
11662: }
11663:
11664: if (DECL_CONSTRUCTOR_P (fndecl))
11665: {
11666: if (! grok_ctor_properties (current_class_type, fndecl))
11667: return void_type_node;
11668: }
11669: else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
11670: grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
11671: }
11672:
11673: finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
11674:
11675: /* Make a place for the parms */
11676: pushlevel (0);
11677: current_binding_level->parm_flag = 1;
11678:
11679: DECL_IN_AGGR_P (fndecl) = 1;
11680: return fndecl;
11681: }
11682:
11683: /* Go through the motions of finishing a function definition.
11684: We don't compile this method until after the whole class has
11685: been processed.
11686:
11687: FINISH_METHOD must return something that looks as though it
11688: came from GROKFIELD (since we are defining a method, after all).
11689:
11690: This is called after parsing the body of the function definition.
11691: STMTS is the chain of statements that makes up the function body.
11692:
11693: DECL is the ..._DECL that `start_method' provided. */
11694:
11695: tree
11696: finish_method (decl)
11697: tree decl;
11698: {
11699: register tree fndecl = decl;
11700: tree old_initial;
11701:
11702: register tree link;
11703:
11704: if (TYPE_MAIN_VARIANT (decl) == void_type_node)
11705: return decl;
11706:
11707: old_initial = DECL_INITIAL (fndecl);
11708:
11709: /* Undo the level for the parms (from start_method).
11710: This is like poplevel, but it causes nothing to be
11711: saved. Saving information here confuses symbol-table
11712: output routines. Besides, this information will
11713: be correctly output when this method is actually
11714: compiled. */
11715:
11716: /* Clear out the meanings of the local variables of this level;
11717: also record in each decl which block it belongs to. */
11718:
11719: for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
11720: {
11721: if (DECL_NAME (link) != NULL_TREE)
11722: IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
11723: my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
11724: DECL_CONTEXT (link) = NULL_TREE;
11725: }
11726:
11727: /* Restore all name-meanings of the outer levels
11728: that were shadowed by this level. */
11729:
11730: for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
11731: IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
11732: for (link = current_binding_level->class_shadowed;
11733: link; link = TREE_CHAIN (link))
11734: IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
11735: for (link = current_binding_level->type_shadowed;
11736: link; link = TREE_CHAIN (link))
11737: IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
11738:
11739: GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
11740: (HOST_WIDE_INT) current_binding_level->level_chain,
11741: current_binding_level->parm_flag,
11742: current_binding_level->keep,
11743: current_binding_level->tag_transparent);
11744:
11745: poplevel (0, 0, 0);
11746:
11747: DECL_INITIAL (fndecl) = old_initial;
11748:
11749: /* We used to check if the context of FNDECL was different from
11750: current_class_type as another way to get inside here. This didn't work
11751: for String.cc in libg++. */
11752: if (DECL_FRIEND_P (fndecl))
11753: {
11754: CLASSTYPE_INLINE_FRIENDS (current_class_type)
11755: = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
11756: decl = void_type_node;
11757: }
11758:
11759: return decl;
11760: }
11761:
11762: /* Called when a new struct TYPE is defined.
11763: If this structure or union completes the type of any previous
11764: variable declaration, lay it out and output its rtl. */
11765:
11766: void
11767: hack_incomplete_structures (type)
11768: tree type;
11769: {
11770: tree decl;
11771:
11772: if (current_binding_level->n_incomplete == 0)
11773: return;
11774:
11775: if (!type) /* Don't do this for class templates. */
11776: return;
11777:
11778: for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
11779: if (TREE_TYPE (decl) == type
11780: || (TREE_TYPE (decl)
11781: && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
11782: && TREE_TYPE (TREE_TYPE (decl)) == type))
11783: {
11784: if (TREE_CODE (decl) == TYPE_DECL)
11785: layout_type (TREE_TYPE (decl));
11786: else
11787: {
11788: int toplevel = global_binding_level == current_binding_level;
11789: if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
11790: && TREE_TYPE (TREE_TYPE (decl)) == type)
11791: layout_type (TREE_TYPE (decl));
11792: layout_decl (decl, 0);
11793: rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
11794: if (! toplevel)
11795: {
11796: tree cleanup;
11797: expand_decl (decl);
11798: cleanup = maybe_build_cleanup (decl);
11799: expand_decl_init (decl);
11800: if (! expand_decl_cleanup (decl, cleanup))
11801: cp_error ("parser lost in parsing declaration of `%D'",
11802: decl);
11803: }
11804: }
11805: my_friendly_assert (current_binding_level->n_incomplete > 0, 164);
11806: --current_binding_level->n_incomplete;
11807: }
11808: }
11809:
11810: /* Nonzero if presently building a cleanup. Needed because
11811: SAVE_EXPRs are not the right things to use inside of cleanups.
11812: They are only ever evaluated once, where the cleanup
11813: might be evaluated several times. In this case, a later evaluation
11814: of the cleanup might fill in the SAVE_EXPR_RTL, and it will
11815: not be valid for an earlier cleanup. */
11816:
11817: int building_cleanup;
11818:
11819: /* If DECL is of a type which needs a cleanup, build that cleanup here.
11820: We don't build cleanups if just going for syntax checking, since
11821: fixup_cleanups does not know how to not handle them.
11822:
11823: Don't build these on the momentary obstack; they must live
11824: the life of the binding contour. */
11825: tree
11826: maybe_build_cleanup (decl)
11827: tree decl;
11828: {
11829: tree type = TREE_TYPE (decl);
11830: if (TYPE_NEEDS_DESTRUCTOR (type))
11831: {
11832: int temp = 0, flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
11833: tree rval;
11834: int old_building_cleanup = building_cleanup;
11835: building_cleanup = 1;
11836:
11837: if (TREE_CODE (decl) != PARM_DECL)
11838: temp = suspend_momentary ();
11839:
11840: if (TREE_CODE (type) == ARRAY_TYPE)
11841: rval = decl;
11842: else
11843: {
11844: mark_addressable (decl);
11845: rval = build_unary_op (ADDR_EXPR, decl, 0);
11846: }
11847:
11848: /* Optimize for space over speed here. */
11849: if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
11850: || flag_expensive_optimizations)
11851: flags |= LOOKUP_NONVIRTUAL;
11852:
11853: /* Use TYPE_MAIN_VARIANT so we don't get a warning about
11854: calling delete on a `const' variable. */
11855: if (TYPE_READONLY (TREE_TYPE (TREE_TYPE (rval))))
11856: rval = build1 (NOP_EXPR, TYPE_POINTER_TO (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (rval)))), rval);
11857:
11858: rval = build_delete (TREE_TYPE (rval), rval, integer_two_node, flags, 0);
11859:
11860: if (TYPE_USES_VIRTUAL_BASECLASSES (type)
11861: && ! TYPE_HAS_DESTRUCTOR (type))
11862: rval = build_compound_expr (tree_cons (NULL_TREE, rval,
11863: build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
11864:
11865: if (TREE_CODE (decl) != PARM_DECL)
11866: resume_momentary (temp);
11867:
11868: building_cleanup = old_building_cleanup;
11869:
11870: return rval;
11871: }
11872: return 0;
11873: }
11874:
11875: /* Expand a C++ expression at the statement level.
11876: This is needed to ferret out nodes which have UNKNOWN_TYPE.
11877: The C++ type checker should get all of these out when
11878: expressions are combined with other, type-providing, expressions,
11879: leaving only orphan expressions, such as:
11880:
11881: &class::bar; / / takes its address, but does nothing with it.
11882:
11883: */
11884: void
11885: cplus_expand_expr_stmt (exp)
11886: tree exp;
11887: {
11888: if (TREE_TYPE (exp) == unknown_type_node)
11889: {
11890: if (TREE_CODE (exp) == ADDR_EXPR || TREE_CODE (exp) == TREE_LIST)
11891: error ("address of overloaded function with no contextual type information");
11892: else if (TREE_CODE (exp) == COMPONENT_REF)
11893: warning ("useless reference to a member function name, did you forget the ()?");
11894: }
11895: else
11896: {
11897: int remove_implicit_immediately = 0;
11898:
11899: if (TREE_CODE (exp) == FUNCTION_DECL)
11900: {
11901: cp_warning ("reference, not call, to function `%D'", exp);
11902: warning ("at this point in file");
11903: }
11904:
11905: #if 0
11906: /* We should do this eventually, but right now this causes regex.o from
11907: libg++ to miscompile, and tString to core dump. */
11908: exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
11909: #endif
11910: expand_expr_stmt (break_out_cleanups (exp));
11911: }
11912:
11913: /* Clean up any pending cleanups. This happens when a function call
11914: returns a cleanup-needing value that nobody uses. */
11915: expand_cleanups_to (NULL_TREE);
11916: }
11917:
11918: /* When a stmt has been parsed, this function is called.
11919:
11920: Currently, this function only does something within a
11921: constructor's scope: if a stmt has just assigned to this,
11922: and we are in a derived class, we call `emit_base_init'. */
11923:
11924: void
11925: finish_stmt ()
11926: {
11927: extern struct nesting *cond_stack, *loop_stack, *case_stack;
11928:
11929:
11930: if (current_function_assigns_this
11931: || ! current_function_just_assigned_this)
11932: return;
11933: if (DECL_CONSTRUCTOR_P (current_function_decl))
11934: {
11935: /* Constructors must wait until we are out of control
11936: zones before calling base constructors. */
11937: if (cond_stack || loop_stack || case_stack)
11938: return;
11939: emit_insns (base_init_insns);
11940: check_base_init (current_class_type);
11941: }
11942: current_function_assigns_this = 1;
11943:
11944: if (flag_cadillac)
11945: cadillac_finish_stmt ();
11946: }
11947:
11948: /* Change a static member function definition into a FUNCTION_TYPE, instead
11949: of the METHOD_TYPE that we create when it's originally parsed.
11950:
11951: WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
11952: (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
11953: other decls. Either pass the addresses of local variables or NULL. */
11954:
11955: void
11956: revert_static_member_fn (decl, fn, argtypes)
11957: tree *decl, *fn, *argtypes;
11958: {
11959: tree tmp;
11960: tree function = fn ? *fn : TREE_TYPE (*decl);
11961: tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
11962:
11963: args = TREE_CHAIN (args);
11964: tmp = build_function_type (TREE_TYPE (function), args);
11965: tmp = build_type_variant (tmp, TYPE_READONLY (function),
11966: TYPE_VOLATILE (function));
11967: tmp = build_exception_variant (TYPE_METHOD_BASETYPE (function), tmp,
11968: TYPE_RAISES_EXCEPTIONS (function));
11969: TREE_TYPE (*decl) = tmp;
11970: DECL_STATIC_FUNCTION_P (*decl) = 1;
11971: if (fn)
11972: *fn = tmp;
11973: if (argtypes)
11974: *argtypes = args;
11975: }
11976:
11977: int
11978: id_in_current_class (id)
11979: tree id;
11980: {
11981: return !!purpose_member (id, class_binding_level->class_shadowed);
11982: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.