OSDN Git Service

46 Cygnus<->FSF merge
[pf3gnuchains/gcc-fork.git] / gcc / cp / typeck2.c
1 /* Report error messages, build initializers, and perform
2    some front-end optimizations for C++ compiler.
3    Copyright (C) '87, '88, '89, '92, 1993, 1994 Free Software Foundation, Inc.
4    Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GNU CC.
7
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING.  If not, write to
20 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
21
22
23 /* This file is part of the C++ front end.
24    It contains routines to build C++ expressions given their operands,
25    including computing the types of the result, C and C++ specific error
26    checks, and some optimization.
27
28    There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
29    and to process initializations in declarations (since they work
30    like a strange sort of assignment).  */
31
32 #include "config.h"
33 #include <stdio.h>
34 #include "tree.h"
35 #include "cp-tree.h"
36 #include "flags.h"
37
38 static tree process_init_constructor ();
39 extern void pedwarn (), error ();
40
41 extern int errorcount;
42 extern int sorrycount;
43
44 /* Print an error message stemming from an attempt to use
45    BASETYPE as a base class for TYPE.  */
46 tree
47 error_not_base_type (basetype, type)
48      tree basetype, type;
49 {
50   if (TREE_CODE (basetype) == FUNCTION_DECL)
51     basetype = DECL_CLASS_CONTEXT (basetype);
52   cp_error ("type `%T' is not a base type for type `%T'", basetype, type);
53   return error_mark_node;
54 }
55
56 tree
57 binfo_or_else (parent_or_type, type)
58      tree parent_or_type, type;
59 {
60   tree binfo;
61   if (TYPE_MAIN_VARIANT (parent_or_type) == TYPE_MAIN_VARIANT (type))
62     return TYPE_BINFO (parent_or_type);
63   if ((binfo = get_binfo (parent_or_type, TYPE_MAIN_VARIANT (type), 0)))
64     {
65       if (binfo == error_mark_node)
66         return NULL_TREE;
67       return binfo;
68     }
69   error_not_base_type (parent_or_type, type);
70   return NULL_TREE;
71 }
72
73 /* Print an error message stemming from an invalid use of an
74    aggregate type.
75
76    TYPE is the type or binfo which draws the error.
77    MSG is the message to print.
78    ARG is an optional argument which may provide more information.  */
79 void
80 error_with_aggr_type (type, msg, arg)
81      tree type;
82      char *msg;
83      HOST_WIDE_INT arg;
84 {
85   tree name;
86
87   if (TREE_CODE (type) == TREE_VEC)
88     type = BINFO_TYPE (type);
89
90   name = TYPE_NAME (type);
91   if (TREE_CODE (name) == TYPE_DECL)
92     name = DECL_NAME (name);
93   error (msg, IDENTIFIER_POINTER (name), arg);
94 }
95
96 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
97    value may not be changed thereafter.  Thus, we emit hard errors for these,
98    rather than just pedwarns.  If `SOFT' is 1, then we just pedwarn.  (For
99    example, conversions to references.)  */
100 void
101 readonly_error (arg, string, soft)
102      tree arg;
103      char *string;
104      int soft;
105 {
106   char *fmt;
107   void (*fn)();
108
109   if (soft)
110     fn = pedwarn;
111   else
112     fn = error;
113
114   if (TREE_CODE (arg) == COMPONENT_REF)
115     {
116       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
117         fmt = "%s of member `%s' in read-only structure";
118       else
119         fmt = "%s of read-only member `%s'";
120       (*fn) (fmt, string, lang_printable_name (TREE_OPERAND (arg, 1)));
121     }
122   else if (TREE_CODE (arg) == VAR_DECL)
123     {
124       if (DECL_LANG_SPECIFIC (arg)
125           && DECL_IN_AGGR_P (arg)
126           && !TREE_STATIC (arg))
127         fmt = "%s of constant field `%s'";
128       else
129         fmt = "%s of read-only variable `%s'";
130       (*fn) (fmt, string, lang_printable_name (arg));
131     }
132   else if (TREE_CODE (arg) == PARM_DECL)
133     (*fn) ("%s of read-only parameter `%s'", string,
134            lang_printable_name (arg));
135   else if (TREE_CODE (arg) == INDIRECT_REF
136            && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
137            && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
138                || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
139     (*fn) ("%s of read-only reference `%s'",
140            string, lang_printable_name (TREE_OPERAND (arg, 0)));
141   else if (TREE_CODE (arg) == RESULT_DECL)
142     (*fn) ("%s of read-only named return value `%s'",
143            string, lang_printable_name (arg));
144   else         
145     (*fn) ("%s of read-only location", string);
146 }
147
148 /* Print an error message for invalid use of a type which declares
149    virtual functions which are not inheritable.  */
150 void
151 abstract_virtuals_error (decl, type)
152      tree decl;
153      tree type;
154 {
155   tree u = CLASSTYPE_ABSTRACT_VIRTUALS (type);
156
157   if (decl)
158     {
159       if (TREE_CODE (decl) == RESULT_DECL)
160         return;
161
162       if (TREE_CODE (decl) == VAR_DECL)
163         cp_error ("cannot declare variable `%D' to be of type `%T'",
164                     decl, type);
165       else if (TREE_CODE (decl) == PARM_DECL)
166         cp_error ("cannot declare parameter `%D' to be of type `%T'",
167                     decl, type);
168       else if (TREE_CODE (decl) == FIELD_DECL)
169         cp_error ("cannot declare field `%D' to be of type `%T'",
170                     decl, type);
171       else if (TREE_CODE (decl) == FUNCTION_DECL
172                && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
173         cp_error ("invalid return type for method `%#D'", decl);
174       else if (TREE_CODE (decl) == FUNCTION_DECL)
175         cp_error ("invalid return type for function `%#D'", decl);
176     }
177   else cp_error ("cannot allocate an object of type `%T'", type);
178   /* Only go through this once.  */
179   if (TREE_PURPOSE (u) == NULL_TREE)
180     {
181       error ("  since the following virtual functions are abstract:");
182       TREE_PURPOSE (u) = error_mark_node;
183       while (u)
184         {
185           cp_error ("\t%#D", TREE_VALUE (u));
186           u = TREE_CHAIN (u);
187         }
188     }
189   else cp_error ("  since type `%T' has abstract virtual functions", type);
190 }
191
192 /* Print an error message for invalid use of a signature type.
193    Signatures are treated similar to abstract classes here, they
194    cannot be instantiated.  */
195 void
196 signature_error (decl, type)
197      tree decl;
198      tree type;
199 {
200   if (decl)
201     {
202       if (TREE_CODE (decl) == RESULT_DECL)
203         return;
204
205       if (TREE_CODE (decl) == VAR_DECL)
206         cp_error ("cannot declare variable `%D' to be of signature type `%T'",
207                   decl, type);
208       else if (TREE_CODE (decl) == PARM_DECL)
209         cp_error ("cannot declare parameter `%D' to be of signature type `%T'",
210                   decl, type);
211       else if (TREE_CODE (decl) == FIELD_DECL)
212         cp_error ("cannot declare field `%D' to be of signature type `%T'",
213                   decl, type);
214       else if (TREE_CODE (decl) == FUNCTION_DECL
215                && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
216         cp_error ("invalid return type for method `%#D'", decl);
217       else if (TREE_CODE (decl) == FUNCTION_DECL)
218         cp_error ("invalid return type for function `%#D'", decl);
219     }
220   else
221     cp_error ("cannot allocate an object of signature type `%T'", type);
222 }
223
224 /* Print an error message for invalid use of an incomplete type.
225    VALUE is the expression that was used (or 0 if that isn't known)
226    and TYPE is the type that was invalid.  */
227
228 void
229 incomplete_type_error (value, type)
230      tree value;
231      tree type;
232 {
233   char *errmsg;
234
235   /* Avoid duplicate error message.  */
236   if (TREE_CODE (type) == ERROR_MARK)
237     return;
238
239   if (value != 0 && (TREE_CODE (value) == VAR_DECL
240                      || TREE_CODE (value) == PARM_DECL))
241     error ("`%s' has an incomplete type",
242            IDENTIFIER_POINTER (DECL_NAME (value)));
243   else
244     {
245     retry:
246       /* We must print an error message.  Be clever about what it says.  */
247
248       switch (TREE_CODE (type))
249         {
250         case RECORD_TYPE:
251           errmsg = "invalid use of undefined type `struct %s'";
252           break;
253
254         case UNION_TYPE:
255           errmsg = "invalid use of undefined type `union %s'";
256           break;
257
258         case ENUMERAL_TYPE:
259           errmsg = "invalid use of undefined type `enum %s'";
260           break;
261
262         case VOID_TYPE:
263           error ("invalid use of void expression");
264           return;
265
266         case ARRAY_TYPE:
267           if (TYPE_DOMAIN (type))
268             {
269               type = TREE_TYPE (type);
270               goto retry;
271             }
272           error ("invalid use of array with unspecified bounds");
273           return;
274
275         case OFFSET_TYPE:
276           error ("invalid use of member type (did you forget the `&' ?)");
277           return;
278
279         default:
280           my_friendly_abort (108);
281         }
282
283       error_with_aggr_type (type, errmsg);
284     }
285 }
286
287 /* Like error(), but don't call report_error_function().  */
288 static void
289 ack (s, v, v2)
290      char *s;
291      HOST_WIDE_INT v;
292      HOST_WIDE_INT v2;
293 {
294   extern char * progname;
295   
296   if (input_filename)
297     fprintf (stderr, "%s:%d: ", input_filename, lineno);
298   else
299     fprintf (stderr, "%s: ", progname);
300
301   fprintf (stderr, s, v, v2);
302   fprintf (stderr, "\n");
303 }
304   
305 /* There are times when the compiler can get very confused, confused
306    to the point of giving up by aborting, simply because of previous
307    input errors.  It is much better to have the user go back and
308    correct those errors first, and see if it makes us happier, than it
309    is to abort on him.  This is because when one has a 10,000 line
310    program, and the compiler comes back with ``core dump'', the user
311    is left not knowing even where to begin to fix things and no place
312    to even try and work around things.
313
314    The parameter is to uniquely identify the problem to the user, so
315    that they can say, I am having problem 59, and know that fix 7 will
316    probably solve their problem.  Or, we can document what problem
317    59 is, so they can understand how to work around it, should they
318    ever run into it.
319
320    Note, there will be no more calls in the C++ front end to abort,
321    because the C++ front end is so unreliable still.  The C front end
322    can get away with calling abort, because for most of the calls to
323    abort on most machines, it, I suspect, can be proven that it is
324    impossible to ever call abort.  The same is not yet true for C++,
325    one day, maybe it will be.
326
327    We used to tell people to "fix the above error[s] and try recompiling
328    the program" via a call to fatal, but that message tended to look
329    silly.  So instead, we just do the equivalent of a call to fatal in the
330    same situation (call exit).  */
331
332 /* First used: 0 (reserved), Last used: 360.  Free: 261.  */
333
334 static int abortcount = 0;
335
336 void
337 my_friendly_abort (i)
338      int i;
339 {
340   /* if the previous error came through here, i.e. report_error_function
341      ended up calling us again, don't just exit; we want a diagnostic of
342      some kind.  */
343   if (abortcount == 1)
344     current_function_decl = NULL_TREE;
345   else if (errorcount > 0 || sorrycount > 0)
346     {
347       if (abortcount > 1)
348         {
349           if (i == 0)
350             ack ("Internal compiler error.");
351           else
352             ack ("Internal compiler error %d.", i);
353           ack ("Please submit a full bug report to `bug-g++@prep.ai.mit.edu'.");
354         }
355       else
356         error ("confused by earlier errors, bailing out");
357       
358       exit (34);
359     }
360   ++abortcount;
361
362   if (i == 0)
363     error ("Internal compiler error.");
364   else
365     error ("Internal compiler error %d.", i);
366
367   fatal ("Please submit a full bug report to `bug-g++@prep.ai.mit.edu'.");
368 }
369
370 void
371 my_friendly_assert (cond, where)
372      int cond, where;
373 {
374   if (cond == 0)
375     my_friendly_abort (where);
376 }
377 \f
378 /* Return nonzero if VALUE is a valid constant-valued expression
379    for use in initializing a static variable; one that can be an
380    element of a "constant" initializer.
381
382    Return 1 if the value is absolute; return 2 if it is relocatable.
383    We assume that VALUE has been folded as much as possible;
384    therefore, we do not need to check for such things as
385    arithmetic-combinations of integers.  */
386
387 static int
388 initializer_constant_valid_p (value)
389      tree value;
390 {
391   switch (TREE_CODE (value))
392     {
393     case CONSTRUCTOR:
394       return TREE_STATIC (value);
395
396     case INTEGER_CST:
397     case REAL_CST:
398     case STRING_CST:
399       return 1;
400
401     case ADDR_EXPR:
402       return 2;
403
404     case CONVERT_EXPR:
405     case NOP_EXPR:
406       /* Allow conversions between types of the same kind.  */
407       if (TREE_CODE (TREE_TYPE (value))
408           == TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))))
409         return initializer_constant_valid_p (TREE_OPERAND (value, 0));
410       /* Allow (int) &foo provided int is as wide as a pointer.  */
411       if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
412           && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE
413           && ! tree_int_cst_lt (TYPE_SIZE (TREE_TYPE (value)),
414                                 TYPE_SIZE (TREE_TYPE (TREE_OPERAND (value, 0)))))
415         return initializer_constant_valid_p (TREE_OPERAND (value, 0));
416       return 0;
417
418     case PLUS_EXPR:
419       {
420         int valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0));
421         int valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1));
422         if (valid0 == 1 && valid1 == 2)
423           return 2;
424         if (valid0 == 2 && valid1 == 1)
425           return 2;
426         return 0;
427       }
428
429     case MINUS_EXPR:
430       {
431         int valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0));
432         int valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1));
433         if (valid0 == 2 && valid1 == 1)
434           return 2;
435         return 0;
436       }
437
438     default:
439       return 0;
440     }
441 }
442 \f
443 /* Perform appropriate conversions on the initial value of a variable,
444    store it in the declaration DECL,
445    and print any error messages that are appropriate.
446    If the init is invalid, store an ERROR_MARK.
447
448    C++: Note that INIT might be a TREE_LIST, which would mean that it is
449    a base class initializer for some aggregate type, hopefully compatible
450    with DECL.  If INIT is a single element, and DECL is an aggregate
451    type, we silently convert INIT into a TREE_LIST, allowing a constructor
452    to be called.
453
454    If INIT is a TREE_LIST and there is no constructor, turn INIT
455    into a CONSTRUCTOR and use standard initialization techniques.
456    Perhaps a warning should be generated?
457
458    Returns value of initializer if initialization could not be
459    performed for static variable.  In that case, caller must do
460    the storing.  */
461
462 tree
463 store_init_value (decl, init)
464      tree decl, init;
465 {
466   register tree value, type;
467
468   /* If variable's type was invalidly declared, just ignore it.  */
469
470   type = TREE_TYPE (decl);
471   if (TREE_CODE (type) == ERROR_MARK)
472     return NULL_TREE;
473
474   /* Take care of C++ business up here.  */
475   type = TYPE_MAIN_VARIANT (type);
476
477   /* implicitly tests if IS_AGGR_TYPE.  */
478   if (TYPE_NEEDS_CONSTRUCTING (type) && TREE_CODE (init) != CONSTRUCTOR)
479     my_friendly_abort (109);
480   else if (IS_AGGR_TYPE (type))
481     {
482       /* Although we are not allowed to declare variables of signature
483          type, we complain about a possible constructor call in such a
484          declaration as well.  */
485       if (TREE_CODE (init) == TREE_LIST
486           && IS_SIGNATURE (type))
487         {
488           cp_error ("constructor syntax cannot be used with signature type `%T'",
489                     type);
490           init = error_mark_node;
491         }
492       else if (TREE_CODE (init) == TREE_LIST)
493         {
494           cp_error ("constructor syntax used, but no constructor declared for type `%T'", type);
495           init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (init));
496         }
497 #if 0
498       if (TREE_CODE (init) == CONSTRUCTOR)
499         {
500           tree field;
501           tree funcs;
502           int func;
503
504           /* Check that we're really an aggregate as ARM 8.4.1 defines it.  */
505           if (CLASSTYPE_N_BASECLASSES (type))
506             cp_error_at ("initializer list construction illegal for derived class object `%D'", decl);
507           if (CLASSTYPE_VTBL_PTR (type))
508             cp_error_at ("initializer list construction illegal for polymorphic class object `%D'", decl);
509           if (TYPE_NEEDS_CONSTRUCTING (type))
510             {
511               cp_error_at ("initializer list construction illegal for `%D'", decl);
512               error ("due to the presence of a constructor");
513             }
514           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
515             if (TREE_PRIVATE (field) || TREE_PROTECTED (field))
516               {
517                 cp_error_at ("initializer list construction illegal for `%D'", decl);
518                 cp_error_at ("due to non-public access of member `%D'", field);
519               }
520           funcs = TYPE_METHODS (type);
521           if (funcs)
522             for (func = 0; func < TREE_VEC_LENGTH (funcs); func++)
523               {
524                 field = TREE_VEC_ELT (funcs, func);
525                 if (field && (TREE_PRIVATE (field) || TREE_PROTECTED (field)))
526                   {
527                     cp_error_at ("initializer list construction illegal for `%D'", decl);
528                     cp_error_at ("due to non-public access of member `%D'", field);
529                   }
530               }
531         }
532 #endif
533     }
534   else if (TREE_CODE (init) == TREE_LIST
535            && TREE_TYPE (init) != unknown_type_node)
536     {
537       if (TREE_CODE (decl) == RESULT_DECL)
538         {
539           if (TREE_CHAIN (init))
540             {
541               warning ("comma expression used to initialize return value");
542               init = build_compound_expr (init);
543             }
544           else
545             init = TREE_VALUE (init);
546         }
547       else if (TREE_TYPE (init) != 0
548                && TREE_CODE (TREE_TYPE (init)) == OFFSET_TYPE)
549         {
550           /* Use the type of our variable to instantiate
551              the type of our initializer.  */
552           init = instantiate_type (type, init, 1);
553         }
554       else if (TREE_CODE (init) == TREE_LIST
555                && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
556         {
557           error ("cannot initialize arrays using this syntax");
558           return NULL_TREE;
559         }
560       else
561         {
562           /* We get here with code like `int a (2);' */
563              
564           if (TREE_CHAIN (init) != NULL_TREE)
565             {
566               pedwarn ("initializer list being treated as compound expression");
567               init = build_compound_expr (init);
568             }
569           else
570             init = TREE_VALUE (init);
571         }
572     }
573
574   /* End of special C++ code.  */
575
576   /* Digest the specified initializer into an expression.  */
577
578   value = digest_init (type, init, (tree *) 0);
579
580   /* Store the expression if valid; else report error.  */
581
582   if (TREE_CODE (value) == ERROR_MARK)
583     ;
584   else if (TREE_STATIC (decl)
585            && (! TREE_CONSTANT (value)
586                || ! initializer_constant_valid_p (value)
587 #if 0
588                /* A STATIC PUBLIC int variable doesn't have to be
589                   run time inited when doing pic.  (mrs) */
590                /* Since ctors and dtors are the only things that can
591                   reference vtables, and they are always written down
592                   the the vtable definition, we can leave the
593                   vtables in initialized data space.
594                   However, other initialized data cannot be initialized
595                   this way.  Instead a global file-level initializer
596                   must do the job.  */
597                || (flag_pic && !DECL_VIRTUAL_P (decl) && TREE_PUBLIC (decl))
598 #endif
599                ))
600
601     return value;
602   else
603     {
604       if (pedantic && TREE_CODE (value) == CONSTRUCTOR
605           /* Don't complain about non-constant initializers of
606              signature tables and signature pointers/references.  */
607           && ! (TYPE_LANG_SPECIFIC (type)
608                 && (IS_SIGNATURE (type)
609                     || IS_SIGNATURE_POINTER (type)
610                     || IS_SIGNATURE_REFERENCE (type))))
611         {
612           if (! TREE_CONSTANT (value) || ! TREE_STATIC (value))
613             pedwarn ("ANSI C++ forbids non-constant aggregate initializer expressions");
614         }
615     }
616   DECL_INITIAL (decl) = value;
617   return NULL_TREE;
618 }
619 \f
620 /* Digest the parser output INIT as an initializer for type TYPE.
621    Return a C expression of type TYPE to represent the initial value.
622
623    If TAIL is nonzero, it points to a variable holding a list of elements
624    of which INIT is the first.  We update the list stored there by
625    removing from the head all the elements that we use.
626    Normally this is only one; we use more than one element only if
627    TYPE is an aggregate and INIT is not a constructor.  */
628
629 tree
630 digest_init (type, init, tail)
631      tree type, init, *tail;
632 {
633   enum tree_code code = TREE_CODE (type);
634   tree element = NULL_TREE;
635   tree old_tail_contents;
636   /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
637      tree node which has no TREE_TYPE.  */
638   int raw_constructor;
639
640   /* By default, assume we use one element from a list.
641      We correct this later in the sole case where it is not true.  */
642
643   if (tail)
644     {
645       old_tail_contents = *tail;
646       *tail = TREE_CHAIN (*tail);
647     }
648
649   if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
650                                   && TREE_VALUE (init) == error_mark_node))
651     return error_mark_node;
652
653   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
654   if (TREE_CODE (init) == NON_LVALUE_EXPR)
655     init = TREE_OPERAND (init, 0);
656
657   if (init && TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (type))
658     init = default_conversion (init);
659
660   if (init && TYPE_PTRMEMFUNC_P (type)
661       && ((TREE_CODE (init) == ADDR_EXPR
662            && TREE_CODE (TREE_TYPE (init)) == POINTER_TYPE
663            && TREE_CODE (TREE_TYPE (TREE_TYPE (init))) == METHOD_TYPE)
664           || TREE_CODE (init) == TREE_LIST
665           || integer_zerop (init)
666           || (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))))
667     {
668       return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), init, 0);
669     }
670
671   raw_constructor = TREE_CODE (init) == CONSTRUCTOR && TREE_TYPE (init) == 0;
672
673   if (init && raw_constructor
674       && CONSTRUCTOR_ELTS (init) != 0
675       && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)
676     {
677       element = TREE_VALUE (CONSTRUCTOR_ELTS (init));
678       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
679       if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
680         element = TREE_OPERAND (element, 0);
681       if (element == error_mark_node)
682         return element;
683     }
684
685   /* Any type can be initialized from an expression of the same type,
686      optionally with braces.  */
687
688   if (init && TREE_TYPE (init)
689       && (TYPE_MAIN_VARIANT (TREE_TYPE (init)) == type
690           || (code == ARRAY_TYPE && comptypes (TREE_TYPE (init), type, 1))))
691     {
692       if (pedantic && code == ARRAY_TYPE
693           && TREE_CODE (init) != STRING_CST)
694         pedwarn ("ANSI C++ forbids initializing array from array expression");
695       if (TREE_CODE (init) == CONST_DECL)
696         init = DECL_INITIAL (init);
697       else if (TREE_READONLY_DECL_P (init))
698         init = decl_constant_value (init);
699       return init;
700     }
701
702   if (element && (TREE_TYPE (element) == type
703                   || (code == ARRAY_TYPE && TREE_TYPE (element)
704                       && comptypes (TREE_TYPE (element), type, 1))))
705     {
706       if (pedantic && code == ARRAY_TYPE)
707         pedwarn ("ANSI C++ forbids initializing array from array expression");
708       if (pedantic && (code == RECORD_TYPE || code == UNION_TYPE))
709         pedwarn ("ANSI C++ forbids single nonscalar initializer with braces");
710       if (TREE_CODE (element) == CONST_DECL)
711         element = DECL_INITIAL (element);
712       else if (TREE_READONLY_DECL_P (element))
713         element = decl_constant_value (element);
714       return element;
715     }
716
717   /* Initialization of an array of chars from a string constant
718      optionally enclosed in braces.  */
719
720   if (code == ARRAY_TYPE)
721     {
722       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
723       if ((typ1 == char_type_node
724            || typ1 == signed_char_type_node
725            || typ1 == unsigned_char_type_node
726            || typ1 == unsigned_wchar_type_node
727            || typ1 == signed_wchar_type_node)
728           && ((init && TREE_CODE (init) == STRING_CST)
729               || (element && TREE_CODE (element) == STRING_CST)))
730         {
731           tree string = element ? element : init;
732
733           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
734                != char_type_node)
735               && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
736             {
737               error ("char-array initialized from wide string");
738               return error_mark_node;
739             }
740           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
741                == char_type_node)
742               && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
743             {
744               error ("int-array initialized from non-wide string");
745               return error_mark_node;
746             }
747
748           if (pedantic
749               && typ1 != char_type_node
750               && typ1 != signed_char_type_node
751               && typ1 != unsigned_char_type_node)
752             pedwarn ("ANSI C++ forbids string initializer except for `char' elements");
753           TREE_TYPE (string) = type;
754           if (TYPE_DOMAIN (type) != 0
755               && TREE_CONSTANT (TYPE_SIZE (type)))
756             {
757               register int size
758                 = TREE_INT_CST_LOW (TYPE_SIZE (type));
759               size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
760               /* In C it is ok to subtract 1 from the length of the string
761                  because it's ok to ignore the terminating null char that is
762                  counted in the length of the constant, but in C++ this would
763                  be invalid.  */
764               if (size < TREE_STRING_LENGTH (string))
765                 pedwarn ("initializer-string for array of chars is too long");
766             }
767           return string;
768         }
769     }
770
771   /* Handle scalar types, including conversions,
772      and signature pointers and references.  */
773
774   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
775       || code == ENUMERAL_TYPE || code == REFERENCE_TYPE
776       || code == BOOLEAN_TYPE
777       || (code == RECORD_TYPE && ! raw_constructor
778           && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type))))
779     {
780       if (raw_constructor)
781         {
782           if (element == 0)
783             {
784               error ("initializer for scalar variable requires one element");
785               return error_mark_node;
786             }
787           init = element;
788         }
789
790       return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
791                                          "initialization", NULL_TREE, 0);
792     }
793
794   /* Come here only for records and arrays (and unions with constructors).  */
795
796   if (TYPE_SIZE (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
797     {
798       cp_error ("variable-sized object of type `%T' may not be initialized",
799                 type);
800       return error_mark_node;
801     }
802
803   if (code == ARRAY_TYPE || code == RECORD_TYPE || code == UNION_TYPE)
804     {
805       if (raw_constructor)
806         return process_init_constructor (type, init, (tree *)0);
807       else if (TYPE_NEEDS_CONSTRUCTING (type))
808         {
809           /* This can only be reached when caller is initializing
810              ARRAY_TYPE.  In that case, we don't want to convert
811              INIT to TYPE.  We will let `expand_vec_init' do it.  */
812           return init;
813         }
814       else if (tail != 0)
815         {
816           *tail = old_tail_contents;
817           return process_init_constructor (type, 0, tail);
818         }
819       else if (flag_traditional)
820         /* Traditionally one can say `char x[100] = 0;'.  */
821         return process_init_constructor (type,
822                                          build_nt (CONSTRUCTOR, 0,
823                                                    tree_cons (0, init, 0)),
824                                          0);
825       if (code != ARRAY_TYPE)
826         return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
827                                            "initialization", NULL_TREE, 0);
828     }
829
830   error ("invalid initializer");
831   return error_mark_node;
832 }
833 \f
834 /* Process a constructor for a variable of type TYPE.
835    The constructor elements may be specified either with INIT or with ELTS,
836    only one of which should be non-null.
837
838    If INIT is specified, it is a CONSTRUCTOR node which is specifically
839    and solely for initializing this datum.
840
841    If ELTS is specified, it is the address of a variable containing
842    a list of expressions.  We take as many elements as we need
843    from the head of the list and update the list.
844
845    In the resulting constructor, TREE_CONSTANT is set if all elts are
846    constant, and TREE_STATIC is set if, in addition, all elts are simple enough
847    constants that the assembler and linker can compute them.  */
848
849 static tree
850 process_init_constructor (type, init, elts)
851      tree type, init, *elts;
852 {
853   register tree tail;
854   /* List of the elements of the result constructor,
855      in reverse order.  */
856   register tree members = NULL;
857   tree result;
858   int allconstant = 1;
859   int allsimple = 1;
860   int erroneous = 0;
861
862   /* Make TAIL be the list of elements to use for the initialization,
863      no matter how the data was given to us.  */
864
865   if (elts)
866     {
867       if (warn_missing_braces)
868         warning ("aggregate has a partly bracketed initializer");
869       tail = *elts;
870     }
871   else
872     tail = CONSTRUCTOR_ELTS (init);
873
874   /* Gobble as many elements as needed, and make a constructor or initial value
875      for each element of this aggregate.  Chain them together in result.
876      If there are too few, use 0 for each scalar ultimate component.  */
877
878   if (TREE_CODE (type) == ARRAY_TYPE)
879     {
880       tree domain = TYPE_DOMAIN (type);
881       register long len;
882       register int i;
883
884       if (domain)
885         len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
886                - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
887                + 1);
888       else
889         len = -1;  /* Take as many as there are */
890
891       for (i = 0; (len < 0 || i < len) && tail != 0; i++)
892         {
893           register tree next1;
894
895           if (TREE_VALUE (tail) != 0)
896             {
897               tree tail1 = tail;
898               next1 = digest_init (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
899                                    TREE_VALUE (tail), &tail1);
900               my_friendly_assert (tail1 == 0
901                                   || TREE_CODE (tail1) == TREE_LIST, 319);
902               if (tail == tail1 && len < 0)
903                 {
904                   error ("non-empty initializer for array of empty elements");
905                   /* Just ignore what we were supposed to use.  */
906                   tail1 = 0;
907                 }
908               tail = tail1;
909             }
910           else
911             {
912               next1 = error_mark_node;
913               tail = TREE_CHAIN (tail);
914             }
915
916           if (next1 == error_mark_node)
917             erroneous = 1;
918           else if (!TREE_CONSTANT (next1))
919             allconstant = 0;
920           else if (! initializer_constant_valid_p (next1))
921             allsimple = 0;
922           members = tree_cons (NULL_TREE, next1, members);
923         }
924     }
925   if (TREE_CODE (type) == RECORD_TYPE)
926     {
927       register tree field;
928
929       if (tail)
930         {
931           if (TYPE_USES_VIRTUAL_BASECLASSES (type))
932             {
933               sorry ("initializer list for object of class with virtual baseclasses");
934               return error_mark_node;
935             }
936
937           if (TYPE_BINFO_BASETYPES (type))
938             {
939               sorry ("initializer list for object of class with baseclasses");
940               return error_mark_node;
941             }
942
943           if (TYPE_VIRTUAL_P (type))
944             {
945               sorry ("initializer list for object using virtual functions");
946               return error_mark_node;
947             }
948         }
949
950       for (field = TYPE_FIELDS (type); field && tail;
951            field = TREE_CHAIN (field))
952         {
953           register tree next1;
954
955           if (! DECL_NAME (field))
956             {
957               members = tree_cons (field, integer_zero_node, members);
958               continue;
959             }
960
961           if (TREE_CODE (field) != FIELD_DECL)
962             continue;
963
964           if (TREE_VALUE (tail) != 0)
965             {
966               tree tail1 = tail;
967
968               next1 = digest_init (TREE_TYPE (field),
969                                    TREE_VALUE (tail), &tail1);
970               my_friendly_assert (tail1 == 0
971                                   || TREE_CODE (tail1) == TREE_LIST, 320);
972               tail = tail1;
973             }
974           else
975             {
976               next1 = error_mark_node;
977               tail = TREE_CHAIN (tail);
978             }
979
980           if (next1 == error_mark_node)
981             erroneous = 1;
982           else if (!TREE_CONSTANT (next1))
983             allconstant = 0;
984           else if (! initializer_constant_valid_p (next1))
985             allsimple = 0;
986           members = tree_cons (field, next1, members);
987         }
988       for (; field; field = TREE_CHAIN (field))
989         {
990           if (TREE_CODE (field) != FIELD_DECL)
991             continue;
992
993           /* Does this field have a default initialization?  */
994           if (DECL_INITIAL (field))
995             {
996               register tree next1 = DECL_INITIAL (field);
997               if (TREE_CODE (next1) == ERROR_MARK)
998                 erroneous = 1;
999               else if (!TREE_CONSTANT (next1))
1000                 allconstant = 0;
1001               else if (! initializer_constant_valid_p (next1))
1002                 allsimple = 0;
1003               members = tree_cons (field, next1, members);
1004             }
1005           else if (TREE_READONLY (field))
1006             error ("uninitialized const member `%s'",
1007                    IDENTIFIER_POINTER (DECL_NAME (field)));
1008           else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field))
1009                    && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1010             error ("member `%s' with uninitialized const fields",
1011                    IDENTIFIER_POINTER (DECL_NAME (field)));
1012           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1013             error ("member `%s' is uninitialized reference",
1014                    IDENTIFIER_POINTER (DECL_NAME (field)));
1015         }
1016     }
1017
1018   if (TREE_CODE (type) == UNION_TYPE)
1019     {
1020       register tree field = TYPE_FIELDS (type);
1021       register tree next1;
1022
1023       /* Find the first named field.  ANSI decided in September 1990
1024          that only named fields count here.  */
1025       while (field && DECL_NAME (field) == 0)
1026         field = TREE_CHAIN (field);
1027
1028       /* If this element specifies a field, initialize via that field.  */
1029       if (TREE_PURPOSE (tail) != NULL_TREE)
1030         {
1031           int win = 0;
1032
1033           if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
1034             /* Handle the case of a call by build_c_cast.  */
1035             field = TREE_PURPOSE (tail), win = 1;
1036           else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
1037             error ("index value instead of field name in union initializer");
1038           else
1039             {
1040               tree temp;
1041               for (temp = TYPE_FIELDS (type);
1042                    temp;
1043                    temp = TREE_CHAIN (temp))
1044                 if (DECL_NAME (temp) == TREE_PURPOSE (tail))
1045                   break;
1046               if (temp)
1047                 field = temp, win = 1;
1048               else
1049                 error ("no field `%s' in union being initialized",
1050                        IDENTIFIER_POINTER (TREE_PURPOSE (tail)));
1051             }
1052           if (!win)
1053             TREE_VALUE (tail) = error_mark_node;
1054         }
1055       else if (field == 0)
1056         {
1057           cp_error ("union `%T' with no named members cannot be initialized",
1058                     type);
1059           TREE_VALUE (tail) = error_mark_node;
1060         }
1061
1062       if (TREE_VALUE (tail) != 0)
1063         {
1064           tree tail1 = tail;
1065
1066           next1 = digest_init (TREE_TYPE (field),
1067                                TREE_VALUE (tail), &tail1);
1068           if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
1069             my_friendly_abort (357);
1070           tail = tail1;
1071         }
1072       else
1073         {
1074           next1 = error_mark_node;
1075           tail = TREE_CHAIN (tail);
1076         }
1077
1078       if (next1 == error_mark_node)
1079         erroneous = 1;
1080       else if (!TREE_CONSTANT (next1))
1081         allconstant = 0;
1082       else if (initializer_constant_valid_p (next1) == 0)
1083         allsimple = 0;
1084       members = tree_cons (field, next1, members);
1085     }
1086
1087   /* If arguments were specified as a list, just remove the ones we used.  */
1088   if (elts)
1089     *elts = tail;
1090   /* If arguments were specified as a constructor,
1091      complain unless we used all the elements of the constructor.  */
1092   else if (tail)
1093     pedwarn ("excess elements in aggregate initializer");
1094
1095   if (erroneous)
1096     return error_mark_node;
1097
1098   result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members));
1099   if (init)
1100     TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
1101   if (allconstant) TREE_CONSTANT (result) = 1;
1102   if (allconstant && allsimple) TREE_STATIC (result) = 1;
1103   return result;
1104 }
1105 \f
1106 /* Given a structure or union value DATUM, construct and return
1107    the structure or union component which results from narrowing
1108    that value by the types specified in TYPES.  For example, given the
1109    hierarchy
1110
1111    class L { int ii; };
1112    class A : L { ... };
1113    class B : L { ... };
1114    class C : A, B { ... };
1115
1116    and the declaration
1117
1118    C x;
1119
1120    then the expression
1121
1122    x::C::A::L::ii refers to the ii member of the L part of
1123    of A part of the C object named by X.  In this case,
1124    DATUM would be x, and TYPES would be a SCOPE_REF consisting of
1125
1126         SCOPE_REF
1127                 SCOPE_REF
1128                         C       A
1129                 L
1130
1131    The last entry in the SCOPE_REF is always an IDENTIFIER_NODE.
1132
1133 */
1134
1135 tree
1136 build_scoped_ref (datum, types)
1137      tree datum;
1138      tree types;
1139 {
1140   tree ref;
1141   tree type = TREE_TYPE (datum);
1142
1143   if (datum == error_mark_node)
1144     return error_mark_node;
1145
1146   if (TREE_CODE (type) == REFERENCE_TYPE)
1147     type = TREE_TYPE (type);
1148
1149   type = TYPE_MAIN_VARIANT (type);
1150
1151   if (TREE_CODE (types) == SCOPE_REF)
1152     {
1153       /* We have some work to do.  */
1154       struct type_chain { tree type; struct type_chain *next; } *chain = 0, *head = 0, scratch;
1155       ref = build_unary_op (ADDR_EXPR, datum, 0);
1156       while (TREE_CODE (types) == SCOPE_REF)
1157         {
1158           tree t = TREE_OPERAND (types, 1);
1159           if (is_aggr_typedef (t, 1))
1160             {
1161               head = (struct type_chain *)alloca (sizeof (struct type_chain));
1162               head->type = IDENTIFIER_TYPE_VALUE (t);
1163               head->next = chain;
1164               chain = head;
1165               types = TREE_OPERAND (types, 0);
1166             }
1167           else return error_mark_node;
1168         }
1169       if (! is_aggr_typedef (types, 1))
1170         return error_mark_node;
1171
1172       head = &scratch;
1173       head->type = IDENTIFIER_TYPE_VALUE (types);
1174       head->next = chain;
1175       chain = head;
1176       while (chain)
1177         {
1178           tree binfo = chain->type;
1179           type = TREE_TYPE (TREE_TYPE (ref));
1180           if (binfo != TYPE_BINFO (type))
1181             {
1182               binfo = get_binfo (binfo, type, 1);
1183               if (binfo == error_mark_node)
1184                 return error_mark_node;
1185               if (binfo == 0)
1186                 return error_not_base_type (chain->type, type);
1187               ref = convert_pointer_to (binfo, ref);
1188             }
1189           chain = chain->next;
1190         }
1191       return build_indirect_ref (ref, "(compiler error in build_scoped_ref)");
1192     }
1193
1194   /* This is an easy conversion.  */
1195   if (is_aggr_typedef (types, 1))
1196     {
1197       tree binfo = TYPE_BINFO (IDENTIFIER_TYPE_VALUE (types));
1198       if (binfo != TYPE_BINFO (type))
1199         {
1200           binfo = get_binfo (binfo, type, 1);
1201           if (binfo == error_mark_node)
1202             return error_mark_node;
1203           if (binfo == 0)
1204             return error_not_base_type (IDENTIFIER_TYPE_VALUE (types), type);
1205         }
1206
1207       switch (TREE_CODE (datum))
1208         {
1209         case NOP_EXPR:
1210         case CONVERT_EXPR:
1211         case FLOAT_EXPR:
1212         case FIX_TRUNC_EXPR:
1213         case FIX_FLOOR_EXPR:
1214         case FIX_ROUND_EXPR:
1215         case FIX_CEIL_EXPR:
1216           ref = convert_pointer_to (binfo,
1217                                     build_unary_op (ADDR_EXPR, TREE_OPERAND (datum, 0), 0));
1218           break;
1219         default:
1220           ref = convert_pointer_to (binfo,
1221                                     build_unary_op (ADDR_EXPR, datum, 0));
1222         }
1223       return build_indirect_ref (ref, "(compiler error in build_scoped_ref)");
1224     }
1225   return error_mark_node;
1226 }
1227
1228 /* Build a reference to an object specified by the C++ `->' operator.
1229    Usually this just involves dereferencing the object, but if the
1230    `->' operator is overloaded, then such overloads must be
1231    performed until an object which does not have the `->' operator
1232    overloaded is found.  An error is reported when circular pointer
1233    delegation is detected.  */
1234 tree
1235 build_x_arrow (datum)
1236      tree datum;
1237 {
1238   tree types_memoized = NULL_TREE;
1239   register tree rval = datum;
1240   tree type = TREE_TYPE (rval);
1241   tree last_rval;
1242
1243   if (type == error_mark_node)
1244     return error_mark_node;
1245
1246   if (TREE_CODE (rval) == OFFSET_REF)
1247     {
1248       rval = resolve_offset_ref (datum);
1249       type = TREE_TYPE (rval);
1250     }
1251
1252   if (TREE_CODE (type) == REFERENCE_TYPE)
1253     {
1254       rval = convert_from_reference (rval);
1255       type = TREE_TYPE (rval);
1256     }
1257
1258   if (IS_AGGR_TYPE (type) && TYPE_OVERLOADS_ARROW (type))
1259     {
1260       while ((rval = build_opfncall (COMPONENT_REF, LOOKUP_NORMAL, rval, NULL_TREE, NULL_TREE)))
1261         {
1262           if (rval == error_mark_node)
1263             return error_mark_node;
1264
1265           if (value_member (TREE_TYPE (rval), types_memoized))
1266             {
1267               error ("circular pointer delegation detected");
1268               return error_mark_node;
1269             }
1270           else
1271             {
1272               types_memoized = tree_cons (NULL_TREE, TREE_TYPE (rval),
1273                                           types_memoized);
1274             }
1275           last_rval = rval;
1276         }     
1277       if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1278         last_rval = convert_from_reference (last_rval);
1279     }
1280   else
1281     last_rval = default_conversion (rval);
1282
1283   /* Signature pointers are not dereferenced.  */
1284   if (TYPE_LANG_SPECIFIC (TREE_TYPE (last_rval))
1285       && IS_SIGNATURE_POINTER (TREE_TYPE (last_rval)))
1286     return last_rval;
1287
1288   if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1289     return build_indirect_ref (last_rval, NULL_PTR);
1290
1291   if (types_memoized)
1292     error ("result of `operator->()' yields non-pointer result");
1293   else
1294     error ("base operand of `->' is not a pointer");
1295   return error_mark_node;
1296 }
1297
1298 /* Make an expression to refer to the COMPONENT field of
1299    structure or union value DATUM.  COMPONENT is an arbitrary
1300    expression.  DATUM has not already been checked out to be of
1301    aggregate type.
1302
1303    For C++, COMPONENT may be a TREE_LIST.  This happens when we must
1304    return an object of member type to a method of the current class,
1305    but there is not yet enough typing information to know which one.
1306    As a special case, if there is only one method by that name,
1307    it is returned.  Otherwise we return an expression which other
1308    routines will have to know how to deal with later.  */
1309 tree
1310 build_m_component_ref (datum, component)
1311      tree datum, component;
1312 {
1313   tree type;
1314   tree objtype = TREE_TYPE (datum);
1315   tree rettype;
1316
1317   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component)))
1318     {
1319       type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component)));
1320       rettype = type;
1321     }
1322   else
1323     {
1324       component = build_indirect_ref (component, NULL_PTR);
1325       type = TREE_TYPE (component);
1326       rettype = TREE_TYPE (TREE_TYPE (component));
1327     }
1328
1329   if (datum == error_mark_node || component == error_mark_node)
1330     return error_mark_node;
1331
1332   if (TREE_CODE (type) != OFFSET_TYPE && TREE_CODE (type) != METHOD_TYPE)
1333     {
1334       cp_error ("`%E' cannot be used as a member pointer, since it is of type `%T'", component, type);
1335       return error_mark_node;
1336     }
1337
1338   if (TREE_CODE (objtype) == REFERENCE_TYPE)
1339     objtype = TREE_TYPE (objtype);
1340
1341   if (! IS_AGGR_TYPE (objtype))
1342     {
1343       cp_error ("cannot apply member pointer `%E' to `%E'", component, datum);
1344       cp_error ("which is of non-aggregate type `%T'", objtype);
1345       return error_mark_node;
1346     }
1347   
1348   if (! comptypes (TYPE_METHOD_BASETYPE (type), objtype, 0))
1349     {
1350       cp_error ("member type `%T::' incompatible with object type `%T'",
1351                 TYPE_METHOD_BASETYPE (type), objtype);
1352       return error_mark_node;
1353     }
1354
1355   return build (OFFSET_REF, rettype, datum, component);
1356 }
1357
1358 /* Return a tree node for the expression TYPENAME '(' PARMS ')'.
1359
1360    Because we cannot tell whether this construct is really a call to a
1361    constructor or a request for a type conversion, we try both, and
1362    report any ambiguities we find.  */
1363 tree
1364 build_functional_cast (exp, parms)
1365      tree exp;
1366      tree parms;
1367 {
1368   /* This is either a call to a constructor,
1369      or a C cast in C++'s `functional' notation.  */
1370   tree type, name = NULL_TREE;
1371   tree expr_as_ctor = NULL_TREE;
1372
1373   if (exp == error_mark_node || parms == error_mark_node)
1374     return error_mark_node;
1375
1376   if (TREE_CODE (exp) == IDENTIFIER_NODE)
1377     {
1378       name = exp;
1379
1380       if (IDENTIFIER_HAS_TYPE_VALUE (exp))
1381         /* Either an enum or an aggregate type.  */
1382         type = IDENTIFIER_TYPE_VALUE (exp);
1383       else
1384         {
1385           type = lookup_name (exp, 1);
1386           if (!type || TREE_CODE (type) != TYPE_DECL)
1387             {
1388               cp_error ("`%T' fails to be a typedef or built-in type", name);
1389               return error_mark_node;
1390             }
1391           type = TREE_TYPE (type);
1392         }
1393     }
1394   else
1395     type = exp;
1396
1397   if (IS_SIGNATURE (type))
1398     {
1399       error ("signature type not allowed in cast or constructor expression");
1400       return error_mark_node;
1401     }
1402
1403   /* Prepare to evaluate as a call to a constructor.  If this expression
1404      is actually used, for example,
1405          
1406      return X (arg1, arg2, ...);
1407          
1408      then the slot being initialized will be filled in.  */
1409
1410   if (name == NULL_TREE)
1411     {
1412       name = TYPE_NAME (type);
1413       if (TREE_CODE (name) == TYPE_DECL)
1414         name = DECL_NAME (name);
1415     }
1416
1417   if (! IS_AGGR_TYPE (type))
1418     {
1419       /* this must build a C cast */
1420       if (parms == NULL_TREE)
1421         return build1 (NOP_EXPR, type, integer_zero_node);
1422       else if (TREE_CHAIN (parms) != NULL_TREE)
1423         {
1424           pedwarn ("initializer list being treated as compound expression");
1425           parms = build_compound_expr (parms);
1426         }
1427       return build_c_cast (type, parms);
1428     }
1429
1430   if (TYPE_SIZE (type) == NULL_TREE)
1431     {
1432       cp_error ("type `%T' is not yet defined", type);
1433       return error_mark_node;
1434     }
1435
1436   if (parms && TREE_CHAIN (parms) == NULL_TREE)
1437     return build_c_cast (type, parms);
1438
1439   expr_as_ctor = build_method_call (NULL_TREE, name, parms,
1440                                     NULL_TREE, LOOKUP_NORMAL);
1441
1442   if (expr_as_ctor == error_mark_node)
1443     return error_mark_node;
1444
1445   if (current_function_decl)
1446     return build_cplus_new (type, expr_as_ctor, 1);
1447
1448   {
1449     register tree parm = TREE_OPERAND (expr_as_ctor, 1);
1450
1451     /* Initializers for static variables and parameters have
1452        to handle doing the initialization and cleanup themselves.  */
1453     my_friendly_assert (TREE_CODE (expr_as_ctor) == CALL_EXPR, 322);
1454 #if 0
1455     /* The following assertion fails in cases where we are initializing
1456        a static member variable of a particular instance of a template
1457        class with a call to a constructor of the given instance, as in:
1458        
1459        TMPL<int> object = TMPL<int>();
1460        
1461        Curiously, the assertion does not fail if we do the same thing
1462        for a static member of a non-template class, as in:
1463        
1464        T object = T();
1465        
1466        I can't see why we should care here whether or not the initializer
1467        expression involves a call to `new', so for the time being, it
1468        seems best to just avoid doing this assertion.  */
1469     my_friendly_assert (TREE_CALLS_NEW (TREE_VALUE (parm)), 323);
1470 #endif
1471     TREE_VALUE (parm) = NULL_TREE;
1472     expr_as_ctor = build_indirect_ref (expr_as_ctor, NULL_PTR);
1473     TREE_HAS_CONSTRUCTOR (expr_as_ctor) = 1;
1474   }
1475   return expr_as_ctor;
1476 }
1477 \f
1478 /* Return the character string for the name that encodes the
1479    enumeral value VALUE in the domain TYPE.  */
1480 char *
1481 enum_name_string (value, type)
1482      tree value;
1483      tree type;
1484 {
1485   register tree values = TYPE_VALUES (type);
1486   register HOST_WIDE_INT intval = TREE_INT_CST_LOW (value);
1487
1488   my_friendly_assert (TREE_CODE (type) == ENUMERAL_TYPE, 324);
1489   while (values
1490          && TREE_INT_CST_LOW (TREE_VALUE (values)) != intval)
1491     values = TREE_CHAIN (values);
1492   if (values == NULL_TREE)
1493     {
1494       char *buf = (char *)oballoc (16 + TYPE_NAME_LENGTH (type));
1495
1496       /* Value must have been cast.  */
1497       sprintf (buf, "(enum %s)%d",
1498                TYPE_NAME_STRING (type), intval);
1499       return buf;
1500     }
1501   return IDENTIFIER_POINTER (TREE_PURPOSE (values));
1502 }
1503
1504 #if 0
1505 /* Print out a language-specific error message for
1506    (Pascal) case or (C) switch statements.
1507    CODE tells what sort of message to print. 
1508    TYPE is the type of the switch index expression.
1509    NEW is the new value that we were trying to add.
1510    OLD is the old value that stopped us from adding it.  */
1511 void
1512 report_case_error (code, type, new_value, old_value)
1513      int code;
1514      tree type;
1515      tree new_value, old_value;
1516 {
1517   if (code == 1)
1518     {
1519       if (new_value)
1520         error ("case label not within a switch statement");
1521       else
1522         error ("default label not within a switch statement");
1523     }
1524   else if (code == 2)
1525     {
1526       if (new_value == 0)
1527         {
1528           error ("multiple default labels in one switch");
1529           return;
1530         }
1531       if (TREE_CODE (new_value) == RANGE_EXPR)
1532         if (TREE_CODE (old_value) == RANGE_EXPR)
1533           {
1534             char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
1535             if (TREE_CODE (type) == ENUMERAL_TYPE)
1536               sprintf (buf, "overlapping ranges [%s..%s], [%s..%s] in case expression",
1537                        enum_name_string (TREE_OPERAND (new_value, 0), type),
1538                        enum_name_string (TREE_OPERAND (new_value, 1), type),
1539                        enum_name_string (TREE_OPERAND (old_value, 0), type),
1540                        enum_name_string (TREE_OPERAND (old_value, 1), type));
1541             else
1542               sprintf (buf, "overlapping ranges [%d..%d], [%d..%d] in case expression",
1543                        TREE_INT_CST_LOW (TREE_OPERAND (new_value, 0)),
1544                        TREE_INT_CST_LOW (TREE_OPERAND (new_value, 1)),
1545                        TREE_INT_CST_LOW (TREE_OPERAND (old_value, 0)),
1546                        TREE_INT_CST_LOW (TREE_OPERAND (old_value, 1)));
1547             error (buf);
1548           }
1549         else
1550           {
1551             char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
1552             if (TREE_CODE (type) == ENUMERAL_TYPE)
1553               sprintf (buf, "range [%s..%s] includes element `%s' in case expression",
1554                        enum_name_string (TREE_OPERAND (new_value, 0), type),
1555                        enum_name_string (TREE_OPERAND (new_value, 1), type),
1556                        enum_name_string (old_value, type));
1557             else
1558               sprintf (buf, "range [%d..%d] includes (%d) in case expression",
1559                        TREE_INT_CST_LOW (TREE_OPERAND (new_value, 0)),
1560                        TREE_INT_CST_LOW (TREE_OPERAND (new_value, 1)),
1561                        TREE_INT_CST_LOW (old_value));
1562             error (buf);
1563           }
1564       else if (TREE_CODE (old_value) == RANGE_EXPR)
1565         {
1566           char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
1567           if (TREE_CODE (type) == ENUMERAL_TYPE)
1568             sprintf (buf, "range [%s..%s] includes element `%s' in case expression",
1569                      enum_name_string (TREE_OPERAND (old_value, 0), type),
1570                      enum_name_string (TREE_OPERAND (old_value, 1), type),
1571                      enum_name_string (new_value, type));
1572           else
1573             sprintf (buf, "range [%d..%d] includes (%d) in case expression",
1574                      TREE_INT_CST_LOW (TREE_OPERAND (old_value, 0)),
1575                      TREE_INT_CST_LOW (TREE_OPERAND (old_value, 1)),
1576                      TREE_INT_CST_LOW (new_value));
1577           error (buf);
1578         }
1579       else
1580         {
1581           if (TREE_CODE (type) == ENUMERAL_TYPE)
1582             error ("duplicate label `%s' in switch statement",
1583                    enum_name_string (new_value, type));
1584           else
1585             error ("duplicate label (%d) in switch statement",
1586                    TREE_INT_CST_LOW (new_value));
1587         }
1588     }
1589   else if (code == 3)
1590     {
1591       if (TREE_CODE (type) == ENUMERAL_TYPE)
1592         warning ("case value out of range for enum %s",
1593                  TYPE_NAME_STRING (type));
1594       else
1595         warning ("case value out of range");
1596     }
1597   else if (code == 4)
1598     {
1599       if (TREE_CODE (type) == ENUMERAL_TYPE)
1600         error ("range values `%s' and `%s' reversed",
1601                enum_name_string (new_value, type),
1602                enum_name_string (old_value, type));
1603       else
1604         error ("range values reversed");
1605     }
1606 }
1607 #endif