![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cvt.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 cvt.c CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 root 1: /* Language-level data type conversion for GNU C++.
2: Copyright (C) 1987, 1988, 1992, 1993 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: /* This file contains the functions for converting C expressions
23: to different data types. The only entry point is `convert'.
24: Every language front end must have a `convert' function
25: but what kind of conversions it does will depend on the language. */
26:
27: #include "config.h"
28: #include "tree.h"
29: #include "flags.h"
30: #include "cp-tree.h"
31: #include "class.h"
32: #include "convert.h"
33:
34: #undef NULL
35: #define NULL (char *)0
36:
37: /* Change of width--truncation and extension of integers or reals--
38: is represented with NOP_EXPR. Proper functioning of many things
39: assumes that no other conversions can be NOP_EXPRs.
40:
41: Conversion between integer and pointer is represented with CONVERT_EXPR.
42: Converting integer to real uses FLOAT_EXPR
43: and real to integer uses FIX_TRUNC_EXPR.
44:
45: Here is a list of all the functions that assume that widening and
46: narrowing is always done with a NOP_EXPR:
47: In convert.c, convert_to_integer.
48: In c-typeck.c, build_binary_op_nodefault (boolean ops),
49: and truthvalue_conversion.
50: In expr.c: expand_expr, for operands of a MULT_EXPR.
51: In fold-const.c: fold.
52: In tree.c: get_narrower and get_unwidened.
53:
54: C++: in multiple-inheritance, converting between pointers may involve
55: adjusting them by a delta stored within the class definition. */
56:
57: /* Subroutines of `convert'. */
58:
59: /* Build a thunk. What it is, is an entry point that when called will
60: adjust the this pointer (the first argument) by offset, and then
61: goto the real address of the function given by REAL_ADDR that we
62: would like called. What we return is the address of the thunk. */
63: static tree
64: build_thunk (offset, real_addr)
65: tree offset, real_addr;
66: {
67: if (TREE_CODE (real_addr) != ADDR_EXPR
68: || TREE_CODE (TREE_OPERAND (real_addr, 0)) != FUNCTION_DECL)
69: {
70: sorry ("MI pointer to member conversion too complex");
71: return error_mark_node;
72: }
73: sorry ("MI pointer to member conversion too complex");
74: return error_mark_node;
75: }
76:
77: /* Convert a `pointer to member' (POINTER_TYPE to METHOD_TYPE) into
78: another `pointer to method'. This may involved the creation of
79: a thunk to handle the this offset calculation. */
80: static tree
81: convert_fn_ptr (type, expr)
82: tree type, expr;
83: {
84: tree binfo = get_binfo (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (expr))),
85: TYPE_METHOD_BASETYPE (TREE_TYPE (type)),
86: 1);
87: if (binfo == error_mark_node)
88: {
89: error (" in pointer to member conversion");
90: return error_mark_node;
91: }
92: if (binfo == NULL_TREE)
93: {
94: /* ARM 4.8 restriction. */
95: error ("invalid pointer to member conversion");
96: return error_mark_node;
97: }
98: if (BINFO_OFFSET_ZEROP (binfo))
99: return build1 (NOP_EXPR, type, expr);
100: return build1 (NOP_EXPR, type, build_thunk (BINFO_OFFSET (binfo), expr));
101: }
102:
103: /* if converting pointer to pointer
104: if dealing with classes, check for derived->base or vice versa
105: else if dealing with method pointers, delegate
106: else convert blindly
107: else if converting class, pass off to build_type_conversion
108: else try C-style pointer conversion */
109: static tree
110: cp_convert_to_pointer (type, expr)
111: tree type, expr;
112: {
113: register tree intype = TREE_TYPE (expr);
114: register enum tree_code form = TREE_CODE (intype);
115:
116: if (form == POINTER_TYPE)
117: {
118: intype = TYPE_MAIN_VARIANT (intype);
119:
120: if (TYPE_MAIN_VARIANT (type) != intype
121: && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
122: && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
123: {
124: enum tree_code code = PLUS_EXPR;
125: tree binfo = get_binfo (TREE_TYPE (type), TREE_TYPE (intype), 1);
126: if (binfo == error_mark_node)
127: return error_mark_node;
128: if (binfo == NULL_TREE)
129: {
130: binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 1);
131: if (binfo == error_mark_node)
132: return error_mark_node;
133: code = MINUS_EXPR;
134: }
135: if (binfo)
136: {
137: if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type))
138: || TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype))
139: || ! BINFO_OFFSET_ZEROP (binfo))
140: {
141: /* Need to get the path we took. */
142: tree path;
143:
144: if (code == PLUS_EXPR)
145: get_base_distance (TREE_TYPE (type), TREE_TYPE (intype), 0, &path);
146: else
147: get_base_distance (TREE_TYPE (intype), TREE_TYPE (type), 0, &path);
148: return build_vbase_path (code, type, expr, path, 0);
149: }
150: }
151: }
152: if (TYPE_MAIN_VARIANT (type) != intype
153: && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
154: && TREE_CODE (type) == POINTER_TYPE
155: && TREE_CODE (TREE_TYPE (intype)) == METHOD_TYPE)
156: return convert_fn_ptr (type, expr);
157:
158: return build1 (NOP_EXPR, type, expr);
159: }
160:
161: my_friendly_assert (form != OFFSET_TYPE, 186);
162:
163: if (TYPE_LANG_SPECIFIC (intype)
164: && (IS_SIGNATURE_POINTER (intype) || IS_SIGNATURE_REFERENCE (intype)))
165: return convert_to_pointer (type, build_optr_ref (expr));
166:
167: if (IS_AGGR_TYPE (intype))
168: {
169: tree rval;
170: rval = build_type_conversion (CONVERT_EXPR, type, expr, 1);
171: if (rval)
172: {
173: if (rval == error_mark_node)
174: cp_error ("conversion of `%E' from `%T' to `%T' is ambiguous",
175: expr, intype, type);
176: return rval;
177: }
178: }
179:
180: if (integer_zerop (expr))
181: {
182: if (type == TREE_TYPE (null_pointer_node))
183: return null_pointer_node;
184: expr = build_int_2 (0, 0);
185: TREE_TYPE (expr) = type;
186: return expr;
187: }
188:
189: if (INTEGRAL_CODE_P (form))
190: {
191: if (type_precision (intype) == POINTER_SIZE)
192: return build1 (CONVERT_EXPR, type, expr);
193: expr = convert (type_for_size (POINTER_SIZE, 0), expr);
194: /* Modes may be different but sizes should be the same. */
195: if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
196: != GET_MODE_SIZE (TYPE_MODE (type)))
197: /* There is supposed to be some integral type
198: that is the same width as a pointer. */
199: abort ();
200: return convert_to_pointer (type, expr);
201: }
202:
203: cp_error ("cannot convert `%E' from type `%T' to type `%T'",
204: expr, intype, type);
205: return error_mark_node;
206: }
207:
208: /* Like convert, except permit conversions to take place which
209: are not normally allowed due to access restrictions
210: (such as conversion from sub-type to private super-type). */
211: static tree
212: convert_to_pointer_force (type, expr)
213: tree type, expr;
214: {
215: register tree intype = TREE_TYPE (expr);
216: register enum tree_code form = TREE_CODE (intype);
217:
218: if (integer_zerop (expr))
219: {
220: if (type == TREE_TYPE (null_pointer_node))
221: return null_pointer_node;
222: expr = build_int_2 (0, 0);
223: TREE_TYPE (expr) = type;
224: return expr;
225: }
226:
227: /* Convert signature pointer/reference to `void *' first. */
228: if (form == RECORD_TYPE
229: && (IS_SIGNATURE_POINTER (intype) || IS_SIGNATURE_REFERENCE (intype)))
230: {
231: expr = build_optr_ref (expr);
232: intype = TREE_TYPE (expr);
233: form = TREE_CODE (intype);
234: }
235:
236: if (form == POINTER_TYPE)
237: {
238: intype = TYPE_MAIN_VARIANT (intype);
239:
240: if (TYPE_MAIN_VARIANT (type) != intype
241: && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
242: && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
243: {
244: enum tree_code code = PLUS_EXPR;
245: tree path;
246: int distance = get_base_distance (TREE_TYPE (type),
247: TREE_TYPE (intype), 0, &path);
248: if (distance == -2)
249: {
250: ambig:
251: cp_error ("type `%T' is ambiguous baseclass of `%s'", TREE_TYPE (type),
252: TYPE_NAME_STRING (TREE_TYPE (intype)));
253: return error_mark_node;
254: }
255: if (distance == -1)
256: {
257: distance = get_base_distance (TREE_TYPE (intype),
258: TREE_TYPE (type), 0, &path);
259: if (distance == -2)
260: goto ambig;
261: if (distance < 0)
262: /* Doesn't need any special help from us. */
263: return build1 (NOP_EXPR, type, expr);
264:
265: code = MINUS_EXPR;
266: }
267: return build_vbase_path (code, type, expr, path, 0);
268: }
269: return build1 (NOP_EXPR, type, expr);
270: }
271:
272: return cp_convert_to_pointer (type, expr);
273: }
274:
275: /* We are passing something to a function which requires a reference.
276: The type we are interested in is in TYPE. The initial
277: value we have to begin with is in ARG.
278:
279: FLAGS controls how we manage access checking.
280: CHECKCONST controls if we report error messages on const subversion. */
281: static tree
282: build_up_reference (type, arg, flags, checkconst)
283: tree type, arg;
284: int flags, checkconst;
285: {
286: tree rval, targ;
287: int literal_flag = 0;
288: tree argtype = TREE_TYPE (arg);
289: tree target_type = TREE_TYPE (type);
290: tree binfo = NULL_TREE;
291:
292: my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187);
293: if ((flags & LOOKUP_PROTECT)
294: && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
295: && IS_AGGR_TYPE (argtype)
296: && IS_AGGR_TYPE (target_type))
297: {
298: binfo = get_binfo (target_type, argtype, 1);
299: if (binfo == error_mark_node)
300: return error_mark_node;
301: if (binfo == NULL_TREE)
302: return error_not_base_type (target_type, argtype);
303: }
304:
305: /* Pass along const and volatile down into the type. */
306: if (TYPE_READONLY (type) || TYPE_VOLATILE (type))
307: target_type = cp_build_type_variant (target_type, TYPE_READONLY (type),
308: TYPE_VOLATILE (type));
309: targ = arg;
310: if (TREE_CODE (targ) == SAVE_EXPR)
311: targ = TREE_OPERAND (targ, 0);
312:
313: switch (TREE_CODE (targ))
314: {
315: case INDIRECT_REF:
316: /* This is a call to a constructor which did not know what it was
317: initializing until now: it needs to initialize a temporary. */
318: if (TREE_HAS_CONSTRUCTOR (targ))
319: {
320: tree temp = build_cplus_new (argtype, TREE_OPERAND (targ, 0), 1);
321: TREE_HAS_CONSTRUCTOR (targ) = 0;
322: return build_up_reference (type, temp, flags, 1);
323: }
324: /* Let &* cancel out to simplify resulting code.
325: Also, throw away intervening NOP_EXPRs. */
326: arg = TREE_OPERAND (targ, 0);
327: if (TREE_CODE (arg) == NOP_EXPR || TREE_CODE (arg) == NON_LVALUE_EXPR
328: || (TREE_CODE (arg) == CONVERT_EXPR && TREE_REFERENCE_EXPR (arg)))
329: arg = TREE_OPERAND (arg, 0);
330:
331: /* in doing a &*, we have to get rid of the const'ness on the pointer
332: value. Haven't thought about volatile here. Pointers come to mind
333: here. */
334: if (TREE_READONLY (arg))
335: {
336: arg = copy_node (arg);
337: TREE_READONLY (arg) = 0;
338: }
339:
340: rval = build1 (CONVERT_EXPR, type, arg);
341: TREE_REFERENCE_EXPR (rval) = 1;
342:
343: /* propagate the const flag on something like:
344:
345: class Base {
346: public:
347: int foo;
348: };
349:
350: class Derived : public Base {
351: public:
352: int bar;
353: };
354:
355: void func(Base&);
356:
357: void func2(const Derived& d) {
358: func(d);
359: }
360:
361: on the d parameter. The below could have been avoided, if the flags
362: were down in the tree, not sure why they are not. (mrs) */
363: /* The below code may have to be propagated to other parts of this
364: switch. */
365: if (TREE_READONLY (targ) && !TREE_READONLY (arg)
366: && (TREE_CODE (arg) == PARM_DECL || TREE_CODE (arg) == VAR_DECL)
367: && TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE
368: && (TYPE_READONLY (target_type) && checkconst))
369: {
370: arg = copy_node (arg);
371: TREE_READONLY (arg) = TREE_READONLY (targ);
372: }
373: literal_flag = TREE_CONSTANT (arg);
374:
375: goto done;
376:
377: /* Get this out of a register if we happened to be in one by accident.
378: Also, build up references to non-lvalues it we must. */
379: /* For &x[y], return (&) x+y */
380: case ARRAY_REF:
381: if (mark_addressable (TREE_OPERAND (targ, 0)) == 0)
382: return error_mark_node;
383: rval = build_binary_op (PLUS_EXPR, TREE_OPERAND (targ, 0),
384: TREE_OPERAND (targ, 1), 1);
385: TREE_TYPE (rval) = type;
386: if (TREE_CONSTANT (TREE_OPERAND (targ, 1))
387: && staticp (TREE_OPERAND (targ, 0)))
388: TREE_CONSTANT (rval) = 1;
389: goto done;
390:
391: case SCOPE_REF:
392: /* Could be a reference to a static member. */
393: {
394: tree field = TREE_OPERAND (targ, 1);
395: if (TREE_STATIC (field))
396: {
397: rval = build1 (ADDR_EXPR, type, field);
398: literal_flag = 1;
399: goto done;
400: }
401: }
402:
403: /* We should have farmed out member pointers above. */
404: my_friendly_abort (188);
405:
406: case COMPONENT_REF:
407: rval = build_component_addr (targ, build_pointer_type (argtype),
408: "attempt to make a reference to bit-field structure member `%s'");
409: TREE_TYPE (rval) = type;
410: literal_flag = staticp (TREE_OPERAND (targ, 0));
411:
412: goto done;
413:
414: /* Anything not already handled and not a true memory reference
415: needs to have a reference built up. Do so silently for
416: things like integers and return values from function,
417: but complain if we need a reference to something declared
418: as `register'. */
419:
420: case RESULT_DECL:
421: if (staticp (targ))
422: literal_flag = 1;
423: TREE_ADDRESSABLE (targ) = 1;
424: put_var_into_stack (targ);
425: break;
426:
427: case PARM_DECL:
428: #if 0
429: if (targ == current_class_decl)
430: {
431: error ("address of `this' not available");
432: /* #if 0 */
433: /* This code makes the following core dump the compiler on a sun4,
434: if the code below is used.
435:
436: class e_decl;
437: class a_decl;
438: typedef a_decl* a_ref;
439:
440: class a_s {
441: public:
442: a_s();
443: void* append(a_ref& item);
444: };
445: class a_decl {
446: public:
447: a_decl (e_decl *parent);
448: a_s generic_s;
449: a_s decls;
450: e_decl* parent;
451: };
452:
453: class e_decl {
454: public:
455: e_decl();
456: a_s implementations;
457: };
458:
459: void foobar(void *);
460:
461: a_decl::a_decl(e_decl *parent) {
462: parent->implementations.append(this);
463: }
464: */
465:
466: TREE_ADDRESSABLE (targ) = 1; /* so compiler doesn't die later */
467: put_var_into_stack (targ);
468: break;
469: /* #else */
470: return error_mark_node;
471: /* #endif */
472: }
473: #endif
474: /* Fall through. */
475: case VAR_DECL:
476: case CONST_DECL:
477: if (DECL_REGISTER (targ) && !TREE_ADDRESSABLE (targ)
478: && !DECL_ARTIFICIAL (targ))
479: cp_warning ("address needed to build reference for `%D', which is declared `register'",
480: targ);
481: else if (staticp (targ))
482: literal_flag = 1;
483:
484: TREE_ADDRESSABLE (targ) = 1;
485: put_var_into_stack (targ);
486: break;
487:
488: case COMPOUND_EXPR:
489: {
490: tree real_reference = build_up_reference (type, TREE_OPERAND (targ, 1),
491: LOOKUP_PROTECT, checkconst);
492: rval = build (COMPOUND_EXPR, type, TREE_OPERAND (targ, 0), real_reference);
493: TREE_CONSTANT (rval) = staticp (TREE_OPERAND (targ, 1));
494: return rval;
495: }
496:
497: case PREINCREMENT_EXPR:
498: case PREDECREMENT_EXPR:
499: case MODIFY_EXPR:
500: case INIT_EXPR:
501: {
502: tree real_reference = build_up_reference (type, TREE_OPERAND (targ, 0),
503: LOOKUP_PROTECT, checkconst);
504: rval = build (COMPOUND_EXPR, type, arg, real_reference);
505: TREE_CONSTANT (rval) = staticp (TREE_OPERAND (targ, 0));
506: return rval;
507: }
508:
509: case COND_EXPR:
510: return build (COND_EXPR, type,
511: TREE_OPERAND (targ, 0),
512: build_up_reference (type, TREE_OPERAND (targ, 1),
513: LOOKUP_PROTECT, checkconst),
514: build_up_reference (type, TREE_OPERAND (targ, 2),
515: LOOKUP_PROTECT, checkconst));
516:
517: case WITH_CLEANUP_EXPR:
518: return build (WITH_CLEANUP_EXPR, type,
519: build_up_reference (type, TREE_OPERAND (targ, 0),
520: LOOKUP_PROTECT, checkconst),
521: 0, TREE_OPERAND (targ, 2));
522:
523: case BIND_EXPR:
524: arg = TREE_OPERAND (targ, 1);
525: if (arg == NULL_TREE)
526: {
527: compiler_error ("({ ... }) expression not expanded when needed for reference");
528: return error_mark_node;
529: }
530: rval = build1 (ADDR_EXPR, type, arg);
531: TREE_REFERENCE_EXPR (rval) = 1;
532: return rval;
533:
534: default:
535: break;
536: }
537:
538: if (TREE_ADDRESSABLE (targ) == 0)
539: {
540: tree temp;
541:
542: if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (argtype))
543: {
544: temp = build_cplus_new (argtype, targ, 1);
545: if (TREE_CODE (temp) == WITH_CLEANUP_EXPR)
546: rval = build (WITH_CLEANUP_EXPR, type,
547: build1 (ADDR_EXPR, type, TREE_OPERAND (temp, 0)),
548: 0, TREE_OPERAND (temp, 2));
549: else
550: rval = build1 (ADDR_EXPR, type, temp);
551: goto done;
552: }
553: else
554: {
555: temp = get_temp_name (argtype, 0);
556: if (global_bindings_p ())
557: {
558: /* Give this new temp some rtl and initialize it. */
559: DECL_INITIAL (temp) = targ;
560: TREE_STATIC (temp) = 1;
561: finish_decl (temp, targ, NULL_TREE, 0);
562: /* Do this after declaring it static. */
563: rval = build_unary_op (ADDR_EXPR, temp, 0);
564: TREE_TYPE (rval) = type;
565: literal_flag = TREE_CONSTANT (rval);
566: goto done;
567: }
568: else
569: {
570: rval = build_unary_op (ADDR_EXPR, temp, 0);
571: if (binfo && !BINFO_OFFSET_ZEROP (binfo))
572: rval = convert_pointer_to (target_type, rval);
573: else
574: TREE_TYPE (rval) = type;
575:
576: temp = build (MODIFY_EXPR, argtype, temp, arg);
577: TREE_SIDE_EFFECTS (temp) = 1;
578: return build (COMPOUND_EXPR, type, temp, rval);
579: }
580: }
581: }
582: else
583: rval = build1 (ADDR_EXPR, type, arg);
584:
585: done:
586: if (TYPE_USES_COMPLEX_INHERITANCE (argtype)
587: || TYPE_USES_COMPLEX_INHERITANCE (target_type))
588: {
589: TREE_TYPE (rval) = build_pointer_type (argtype);
590: if (flags & LOOKUP_PROTECT)
591: rval = convert_pointer_to (target_type, rval);
592: else
593: rval
594: = convert_to_pointer_force (build_pointer_type (target_type), rval);
595: TREE_TYPE (rval) = type;
596: }
597: TREE_CONSTANT (rval) = literal_flag;
598: return rval;
599: }
600:
601: /* For C++: Only need to do one-level references, but cannot
602: get tripped up on signed/unsigned differences.
603:
604: DECL is either NULL_TREE or the _DECL node for a reference that is being
605: initialized. It can be error_mark_node if we don't know the _DECL but
606: we know it's an initialization. */
607:
608: tree cp_convert PROTO((tree, tree, int, int));
609:
610: tree
611: convert_to_reference (reftype, expr, convtype, flags, decl)
612: tree reftype, expr;
613: int convtype, flags;
614: tree decl;
615: {
616: register tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
617: register tree intype = TREE_TYPE (expr);
618: register enum tree_code form = TREE_CODE (intype);
619: tree rval = NULL_TREE;
620:
621: if (form == REFERENCE_TYPE)
622: intype = TREE_TYPE (intype);
623: intype = TYPE_MAIN_VARIANT (intype);
624:
625: if (((convtype & CONV_STATIC) && comptypes (type, intype, -1))
626: || ((convtype & CONV_IMPLICIT) && comptypes (type, intype, 0)))
627: {
628: if (flags & LOOKUP_COMPLAIN)
629: {
630: tree ttl = TREE_TYPE (reftype);
631: tree ttr;
632:
633: if (form == REFERENCE_TYPE)
634: ttr = TREE_TYPE (TREE_TYPE (expr));
635: else
636: {
637: int r = TREE_READONLY (expr);
638: int v = TREE_THIS_VOLATILE (expr);
639: ttr = cp_build_type_variant (TREE_TYPE (expr), r, v);
640: }
641:
642: if (! lvalue_p (expr) &&
643: (decl == NULL_TREE || ! TYPE_READONLY (ttl)))
644: {
645: if (decl)
646: /* Ensure semantics of [dcl.init.ref] */
647: cp_pedwarn ("initialization of non-const `%T' from rvalue `%T'",
648: reftype, intype);
649: else
650: cp_pedwarn ("conversion to `%T' from rvalue `%T'",
651: reftype, intype);
652: }
653: else if (! (convtype & CONV_CONST))
654: {
655: if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
656: cp_pedwarn ("conversion from `%T' to `%T' discards const",
657: ttr, reftype);
658: else if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
659: cp_pedwarn ("conversion from `%T' to `%T' discards volatile",
660: ttr, reftype);
661: }
662: }
663:
664: if (form == REFERENCE_TYPE)
665: {
666: tree type = TREE_TYPE (expr);
667: tree tmp = copy_node (expr);
668: TREE_TYPE (tmp) = build_pointer_type (TREE_TYPE (TREE_TYPE (expr)));
669: rval = cp_convert (build_pointer_type (TREE_TYPE (reftype)), tmp,
670: convtype, flags);
671: TREE_TYPE (tmp) = type;
672: TREE_TYPE (rval) = reftype;
673: return rval;
674: }
675:
676: return build_up_reference (reftype, expr, flags,
677: ! (convtype & CONV_CONST));
678: }
679:
680: if ((convtype & CONV_IMPLICIT)
681: && IS_AGGR_TYPE (intype)
682: && ! (flags & LOOKUP_NO_CONVERSION)
683: && (rval = build_type_conversion (CONVERT_EXPR, reftype, expr, 1)))
684: {
685: if (rval == error_mark_node)
686: cp_error ("conversion from `%T' to `%T' is ambiguous",
687: intype, reftype);
688: return rval;
689: }
690: else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr))
691: {
692: /* When casting an lvalue to a reference type, just convert into
693: a pointer to the new type and deference it. This is allowed
694: by San Diego WP section 5.2.9 paragraph 12, though perhaps it
695: should be done directly (jason). (int &)ri ---> *(int*)&ri */
696:
697: /* B* bp; A& ar = (A&)bp; is legal, but it's probably not what they
698: meant. */
699: if (form == POINTER_TYPE
700: && (comptypes (TREE_TYPE (intype), type, -1)))
701: cp_warning ("casting `%T' to `%T' does not dereference pointer",
702: intype, reftype);
703:
704: rval = build_unary_op (ADDR_EXPR, expr, 0);
705: if (rval != error_mark_node)
706: rval = convert_force (build_pointer_type (TREE_TYPE (reftype)), rval);
707: if (rval != error_mark_node)
708: rval = build1 (NOP_EXPR, reftype, rval);
709: }
710: else if (decl)
711: {
712: tree rval_as_conversion = NULL_TREE;
713: tree rval_as_ctor = NULL_TREE;
714:
715: if (IS_AGGR_TYPE (intype)
716: && (rval = build_type_conversion (CONVERT_EXPR, type, expr, 1)))
717: {
718: if (rval == error_mark_node)
719: return rval;
720:
721: rval_as_conversion = build_up_reference (reftype, rval, flags, 1);
722: }
723:
724: /* Definitely need to go through a constructor here. */
725: if (TYPE_HAS_CONSTRUCTOR (type)
726: && ! CLASSTYPE_ABSTRACT_VIRTUALS (type)
727: && (rval = build_method_call
728: (NULL_TREE, constructor_name_full (type),
729: build_tree_list (NULL_TREE, expr), TYPE_BINFO (type),
730: LOOKUP_NO_CONVERSION|LOOKUP_SPECULATIVELY)))
731: {
732: tree init;
733:
734: if (global_bindings_p ())
735: {
736: extern tree static_aggregates;
737: tree t = get_temp_name (type, global_bindings_p ());
738: init = build_method_call (t, constructor_name_full (type),
739: build_tree_list (NULL_TREE, expr),
740: TYPE_BINFO (type),
741: LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
742:
743: if (init == error_mark_node)
744: return error_mark_node;
745:
746: make_decl_rtl (t, NULL_PTR, 1);
747: static_aggregates = perm_tree_cons (expr, t, static_aggregates);
748: rval = build_unary_op (ADDR_EXPR, t, 0);
749: }
750: else
751: {
752: init = build_method_call (NULL_TREE, constructor_name_full (type),
753: build_tree_list (NULL_TREE, expr),
754: TYPE_BINFO (type),
755: LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
756:
757: if (init == error_mark_node)
758: return error_mark_node;
759:
760: rval = build_cplus_new (type, init, 1);
761: rval = build_up_reference (reftype, rval, flags, 1);
762: }
763: rval_as_ctor = rval;
764: }
765:
766: if (rval_as_ctor && rval_as_conversion)
767: {
768: cp_error ("ambiguous conversion from `%T' to `%T'; both user-defined conversion and constructor apply",
769: intype, reftype);
770: return error_mark_node;
771: }
772: else if (rval_as_ctor)
773: rval = rval_as_ctor;
774: else if (rval_as_conversion)
775: rval = rval_as_conversion;
776: else if (! IS_AGGR_TYPE (type) && ! IS_AGGR_TYPE (intype))
777: {
778: rval = convert (type, expr);
779: if (rval == error_mark_node)
780: return error_mark_node;
781:
782: rval = build_up_reference (reftype, rval, flags, 1);
783: }
784:
785: if (rval && ! TYPE_READONLY (TREE_TYPE (reftype)))
786: cp_pedwarn ("initializing non-const `%T' with `%T' will use a temporary",
787: reftype, intype);
788: }
789:
790: if (rval)
791: {
792: /* If we found a way to convert earlier, then use it. */
793: return rval;
794: }
795:
796: my_friendly_assert (form != OFFSET_TYPE, 189);
797:
798: if (flags & LOOKUP_SPECULATIVELY)
799: return NULL_TREE;
800:
801: else if (flags & LOOKUP_COMPLAIN)
802: cp_error ("cannot convert type `%T' to type `%T'", intype, reftype);
803:
804: return error_mark_node;
805: }
806:
807: /* We are using a reference VAL for its value. Bash that reference all the
808: way down to its lowest form. */
809: tree
810: convert_from_reference (val)
811: tree val;
812: {
813: tree type = TREE_TYPE (val);
814:
815: if (TREE_CODE (type) == OFFSET_TYPE)
816: type = TREE_TYPE (type);
817: if (TREE_CODE (type) == REFERENCE_TYPE)
818: {
819: tree target_type = TREE_TYPE (type);
820: tree nval;
821:
822: /* This can happen if we cast to a reference type. */
823: if (TREE_CODE (val) == ADDR_EXPR)
824: {
825: nval = build1 (NOP_EXPR, build_pointer_type (target_type), val);
826: nval = build_indirect_ref (nval, NULL_PTR);
827: /* The below was missing, are other important flags missing too? */
828: TREE_SIDE_EFFECTS (nval) = TREE_SIDE_EFFECTS (val);
829: return nval;
830: }
831:
832: nval = build1 (INDIRECT_REF, target_type, val);
833:
834: TREE_THIS_VOLATILE (nval) = TYPE_VOLATILE (target_type);
835: TREE_SIDE_EFFECTS (nval) = TYPE_VOLATILE (target_type);
836: TREE_READONLY (nval) = TYPE_READONLY (target_type);
837: /* The below was missing, are other important flags missing too? */
838: TREE_SIDE_EFFECTS (nval) |= TREE_SIDE_EFFECTS (val);
839: return nval;
840: }
841: return val;
842: }
843:
844: /* See if there is a constructor of type TYPE which will convert
845: EXPR. The reference manual seems to suggest (8.5.6) that we need
846: not worry about finding constructors for base classes, then converting
847: to the derived class.
848:
849: MSGP is a pointer to a message that would be an appropriate error
850: string. If MSGP is NULL, then we are not interested in reporting
851: errors. */
852: tree
853: convert_to_aggr (type, expr, msgp, protect)
854: tree type, expr;
855: char **msgp;
856: int protect;
857: {
858: tree basetype = type;
859: tree name = TYPE_IDENTIFIER (basetype);
860: tree function, fndecl, fntype, parmtypes, parmlist, result;
861: tree method_name;
862: enum access_type access;
863: int can_be_private, can_be_protected;
864:
865: if (! TYPE_HAS_CONSTRUCTOR (basetype))
866: {
867: if (msgp)
868: *msgp = "type `%s' does not have a constructor";
869: return error_mark_node;
870: }
871:
872: access = access_public;
873: can_be_private = 0;
874: can_be_protected = IDENTIFIER_CLASS_VALUE (name) || name == current_class_name;
875:
876: parmlist = build_tree_list (NULL_TREE, expr);
877: parmtypes = tree_cons (NULL_TREE, TREE_TYPE (expr), void_list_node);
878:
879: if (TYPE_USES_VIRTUAL_BASECLASSES (basetype))
880: {
881: parmtypes = tree_cons (NULL_TREE, integer_type_node, parmtypes);
882: parmlist = tree_cons (NULL_TREE, integer_one_node, parmlist);
883: }
884:
885: /* The type of the first argument will be filled in inside the loop. */
886: parmlist = tree_cons (NULL_TREE, integer_zero_node, parmlist);
887: parmtypes = tree_cons (NULL_TREE, TYPE_POINTER_TO (basetype), parmtypes);
888:
889: method_name = build_decl_overload (name, parmtypes, 1);
890:
891: /* constructors are up front. */
892: fndecl = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0);
893: if (TYPE_HAS_DESTRUCTOR (basetype))
894: fndecl = DECL_CHAIN (fndecl);
895:
896: while (fndecl)
897: {
898: if (DECL_ASSEMBLER_NAME (fndecl) == method_name)
899: {
900: function = fndecl;
901: if (protect)
902: {
903: if (TREE_PRIVATE (fndecl))
904: {
905: can_be_private =
906: (basetype == current_class_type
907: || is_friend (basetype, current_function_decl)
908: || purpose_member (basetype, DECL_ACCESS (fndecl)));
909: if (! can_be_private)
910: goto found;
911: }
912: else if (TREE_PROTECTED (fndecl))
913: {
914: if (! can_be_protected)
915: goto found;
916: }
917: }
918: goto found_and_ok;
919: }
920: fndecl = DECL_CHAIN (fndecl);
921: }
922:
923: /* No exact conversion was found. See if an approximate
924: one will do. */
925: fndecl = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0);
926: if (TYPE_HAS_DESTRUCTOR (basetype))
927: fndecl = DECL_CHAIN (fndecl);
928:
929: {
930: int saw_private = 0;
931: int saw_protected = 0;
932: struct candidate *candidates =
933: (struct candidate *) alloca ((decl_list_length (fndecl)+1) * sizeof (struct candidate));
934: struct candidate *cp = candidates;
935:
936: while (fndecl)
937: {
938: function = fndecl;
939: cp->h_len = 2;
940: cp->harshness = (struct harshness_code *)
941: alloca (3 * sizeof (struct harshness_code));
942:
943: compute_conversion_costs (fndecl, parmlist, cp, 2);
944: if ((cp->h.code & EVIL_CODE) == 0)
945: {
946: cp->u.field = fndecl;
947: if (protect)
948: {
949: if (TREE_PRIVATE (fndecl))
950: access = access_private;
951: else if (TREE_PROTECTED (fndecl))
952: access = access_protected;
953: else
954: access = access_public;
955: }
956: else
957: access = access_public;
958:
959: if (access == access_private
960: ? (basetype == current_class_type
961: || is_friend (basetype, cp->function)
962: || purpose_member (basetype, DECL_ACCESS (fndecl)))
963: : access == access_protected
964: ? (can_be_protected
965: || purpose_member (basetype, DECL_ACCESS (fndecl)))
966: : 1)
967: {
968: if (cp->h.code <= TRIVIAL_CODE)
969: goto found_and_ok;
970: cp++;
971: }
972: else
973: {
974: if (access == access_private)
975: saw_private = 1;
976: else
977: saw_protected = 1;
978: }
979: }
980: fndecl = DECL_CHAIN (fndecl);
981: }
982: if (cp - candidates)
983: {
984: /* Rank from worst to best. Then cp will point to best one.
985: Private fields have their bits flipped. For unsigned
986: numbers, this should make them look very large.
987: If the best alternate has a (signed) negative value,
988: then all we ever saw were private members. */
989: if (cp - candidates > 1)
990: qsort (candidates, /* char *base */
991: cp - candidates, /* int nel */
992: sizeof (struct candidate), /* int width */
993: rank_for_overload); /* int (*compar)() */
994:
995: --cp;
996: if (cp->h.code & EVIL_CODE)
997: {
998: if (msgp)
999: *msgp = "ambiguous type conversion possible for `%s'";
1000: return error_mark_node;
1001: }
1002:
1003: function = cp->function;
1004: fndecl = cp->u.field;
1005: goto found_and_ok;
1006: }
1007: else if (msgp)
1008: {
1009: if (saw_private)
1010: if (saw_protected)
1011: *msgp = "only private and protected conversions apply";
1012: else
1013: *msgp = "only private conversions apply";
1014: else if (saw_protected)
1015: *msgp = "only protected conversions apply";
1016: else
1017: *msgp = "no appropriate conversion to type `%s'";
1018: }
1019: return error_mark_node;
1020: }
1021: /* NOTREACHED */
1022:
1023: found:
1024: if (access == access_private)
1025: if (! can_be_private)
1026: {
1027: if (msgp)
1028: *msgp = TREE_PRIVATE (fndecl)
1029: ? "conversion to type `%s' is private"
1030: : "conversion to type `%s' is from private base class";
1031: return error_mark_node;
1032: }
1033: if (access == access_protected)
1034: if (! can_be_protected)
1035: {
1036: if (msgp)
1037: *msgp = TREE_PRIVATE (fndecl)
1038: ? "conversion to type `%s' is protected"
1039: : "conversion to type `%s' is from protected base class";
1040: return error_mark_node;
1041: }
1042: function = fndecl;
1043: found_and_ok:
1044:
1045: /* It will convert, but we don't do anything about it yet. */
1046: if (msgp == 0)
1047: return NULL_TREE;
1048:
1049: fntype = TREE_TYPE (function);
1050: if (DECL_INLINE (function) && TREE_CODE (function) == FUNCTION_DECL)
1051: function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1052: else
1053: function = default_conversion (function);
1054:
1055: result = build_nt (CALL_EXPR, function,
1056: convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype),
1057: parmlist, NULL_TREE, LOOKUP_NORMAL),
1058: NULL_TREE);
1059: TREE_TYPE (result) = TREE_TYPE (fntype);
1060: TREE_SIDE_EFFECTS (result) = 1;
1061: TREE_RAISES (result) = !! TYPE_RAISES_EXCEPTIONS (fntype);
1062: return result;
1063: }
1064:
1065: /* Call this when we know (for any reason) that expr is not, in fact,
1066: zero. This routine is like convert_pointer_to, but it pays
1067: attention to which specific instance of what type we want to
1068: convert to. This routine should eventually become
1069: convert_to_pointer after all references to convert_to_pointer
1070: are removed. */
1071: tree
1072: convert_pointer_to_real (binfo, expr)
1073: tree binfo, expr;
1074: {
1075: register tree intype = TREE_TYPE (expr);
1076: tree ptr_type;
1077: tree type, rval;
1078:
1079: if (TREE_CODE (binfo) == TREE_VEC)
1080: type = BINFO_TYPE (binfo);
1081: else if (IS_AGGR_TYPE (binfo))
1082: {
1083: type = binfo;
1084: }
1085: else
1086: {
1087: type = binfo;
1088: binfo = NULL_TREE;
1089: }
1090:
1091: ptr_type = build_pointer_type (type);
1092: if (ptr_type == TYPE_MAIN_VARIANT (intype))
1093: return expr;
1094:
1095: if (intype == error_mark_node)
1096: return error_mark_node;
1097:
1098: my_friendly_assert (!integer_zerop (expr), 191);
1099:
1100: if (TREE_CODE (type) == RECORD_TYPE
1101: && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE
1102: && type != TYPE_MAIN_VARIANT (TREE_TYPE (intype)))
1103: {
1104: tree path;
1105: int distance
1106: = get_base_distance (binfo, TYPE_MAIN_VARIANT (TREE_TYPE (intype)),
1107: 0, &path);
1108:
1109: /* This function shouldn't be called with unqualified arguments
1110: but if it is, give them an error message that they can read. */
1111: if (distance < 0)
1112: {
1113: cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
1114: TREE_TYPE (intype), type);
1115:
1116: if (distance == -2)
1117: cp_error ("because `%T' is an ambiguous base class", type);
1118: return error_mark_node;
1119: }
1120:
1121: return build_vbase_path (PLUS_EXPR, ptr_type, expr, path, 1);
1122: }
1123: rval = build1 (NOP_EXPR, ptr_type,
1124: TREE_CODE (expr) == NOP_EXPR ? TREE_OPERAND (expr, 0) : expr);
1125: TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
1126: return rval;
1127: }
1128:
1129: /* Call this when we know (for any reason) that expr is
1130: not, in fact, zero. This routine gets a type out of the first
1131: argument and uses it to search for the type to convert to. If there
1132: is more than one instance of that type in the expr, the conversion is
1133: ambiguous. This routine should eventually go away, and all
1134: callers should use convert_to_pointer_real. */
1135: tree
1136: convert_pointer_to (binfo, expr)
1137: tree binfo, expr;
1138: {
1139: tree type;
1140:
1141: if (TREE_CODE (binfo) == TREE_VEC)
1142: type = BINFO_TYPE (binfo);
1143: else if (IS_AGGR_TYPE (binfo))
1144: type = binfo;
1145: else
1146: type = binfo;
1147: return convert_pointer_to_real (type, expr);
1148: }
1149:
1150: /* Same as above, but don't abort if we get an "ambiguous" baseclass.
1151: There's only one virtual baseclass we are looking for, and once
1152: we find one such virtual baseclass, we have found them all. */
1153:
1154: tree
1155: convert_pointer_to_vbase (binfo, expr)
1156: tree binfo;
1157: tree expr;
1158: {
1159: tree intype = TREE_TYPE (TREE_TYPE (expr));
1160: tree binfos = TYPE_BINFO_BASETYPES (intype);
1161: int i;
1162:
1163: for (i = TREE_VEC_LENGTH (binfos)-1; i >= 0; i--)
1164: {
1165: tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
1166: if (BINFO_TYPE (binfo) == basetype)
1167: return convert_pointer_to (binfo, expr);
1168: if (binfo_member (BINFO_TYPE (binfo), CLASSTYPE_VBASECLASSES (basetype)))
1169: return convert_pointer_to_vbase (binfo, convert_pointer_to (basetype, expr));
1170: }
1171: my_friendly_abort (6);
1172: /* NOTREACHED */
1173: return NULL_TREE;
1174: }
1175:
1176: tree
1177: cp_convert (type, expr, convtype, flags)
1178: tree type, expr;
1179: int convtype, flags;
1180: {
1181: register tree e = expr;
1182: register enum tree_code code = TREE_CODE (type);
1183:
1184: if (type == TREE_TYPE (e)
1185: || TREE_CODE (e) == ERROR_MARK)
1186: return e;
1187: if (TREE_CODE (TREE_TYPE (e)) == ERROR_MARK)
1188: return error_mark_node;
1189:
1190: /* Trivial conversion: cv-qualifiers do not matter on rvalues. */
1191: if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e)))
1192: return fold (build1 (NOP_EXPR, type, e));
1193:
1194: if (code == VOID_TYPE && (convtype & CONV_STATIC))
1195: return build1 (CONVERT_EXPR, type, e);
1196:
1197: #if 0
1198: /* This is incorrect. A truncation can't be stripped this way.
1199: Extensions will be stripped by the use of get_unwidened. */
1200: if (TREE_CODE (e) == NOP_EXPR)
1201: return convert (type, TREE_OPERAND (e, 0));
1202: #endif
1203:
1204: /* Just convert to the type of the member. */
1205: if (code == OFFSET_TYPE)
1206: {
1207: type = TREE_TYPE (type);
1208: code = TREE_CODE (type);
1209: }
1210:
1211: if (code == REFERENCE_TYPE)
1212: return fold (convert_to_reference (type, e, convtype, flags, NULL_TREE));
1213: else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
1214: e = convert_from_reference (e);
1215:
1216: if (TREE_CODE (e) == OFFSET_REF)
1217: e = resolve_offset_ref (e);
1218:
1219: if (TREE_READONLY_DECL_P (e))
1220: e = decl_constant_value (e);
1221:
1222: if (INTEGRAL_CODE_P (code))
1223: {
1224: tree intype = TREE_TYPE (e);
1225: enum tree_code form = TREE_CODE (intype);
1226: /* enum = enum, enum = int, enum = float are all errors. */
1227: if (flag_int_enum_equivalence == 0
1228: && TREE_CODE (type) == ENUMERAL_TYPE
1229: && ARITHMETIC_TYPE_P (intype))
1230: {
1231: cp_pedwarn ("conversion from `%#T' to `%#T'", intype, type);
1232:
1233: if (flag_pedantic_errors)
1234: return error_mark_node;
1235: }
1236: if (IS_AGGR_TYPE (intype))
1237: {
1238: tree rval;
1239: rval = build_type_conversion (CONVERT_EXPR, type, e, 1);
1240: if (rval)
1241: return rval;
1242: cp_error ("`%#T' used where a `%T' was expected", intype, type);
1243: return error_mark_node;
1244: }
1245: if (code == BOOLEAN_TYPE)
1246: {
1247: tree newe = truthvalue_conversion (e);
1248: /* Avoid stupid (infinite) recursion from backend. */
1249: if (TREE_CODE (newe) != NOP_EXPR || e != TREE_OPERAND (newe, 0))
1250: e = newe;
1251: if (TREE_TYPE (e) == bool_type_node)
1252: return e;
1253: else if (TREE_CODE (e) == INTEGER_CST)
1254: {
1255: if (e == integer_zero_node)
1256: e = false_node;
1257: else
1258: e = true_node;
1259: }
1260: else
1261: return build1 (NOP_EXPR, bool_type_node, e);
1262: }
1263: return fold (convert_to_integer (type, e));
1264: }
1265: if (code == POINTER_TYPE)
1266: return fold (cp_convert_to_pointer (type, e));
1267: if (code == REAL_TYPE)
1268: {
1269: if (IS_AGGR_TYPE (TREE_TYPE (e)))
1270: {
1271: tree rval;
1272: rval = build_type_conversion (CONVERT_EXPR, type, e, 1);
1273: if (rval)
1274: return rval;
1275: else
1276: cp_error ("`%#T' used where a floating point value was expected",
1277: TREE_TYPE (e));
1278: }
1279: return fold (convert_to_real (type, e));
1280: }
1281:
1282: /* New C++ semantics: since assignment is now based on
1283: memberwise copying, if the rhs type is derived from the
1284: lhs type, then we may still do a conversion. */
1285: if (IS_AGGR_TYPE_CODE (code))
1286: {
1287: tree dtype = TREE_TYPE (e);
1288: tree ctor = NULL_TREE;
1289: tree conversion = NULL_TREE;
1290:
1291: dtype = TYPE_MAIN_VARIANT (dtype);
1292:
1293: /* Conversion of object pointers or signature pointers/references
1294: to signature pointers/references. */
1295:
1296: if (TYPE_LANG_SPECIFIC (type)
1297: && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
1298: {
1299: tree constructor = build_signature_pointer_constructor (type, expr);
1300: tree sig_ty = SIGNATURE_TYPE (type);
1301: tree sig_ptr;
1302:
1303: if (constructor == error_mark_node)
1304: return error_mark_node;
1305:
1306: sig_ptr = get_temp_name (type, 1);
1307: DECL_INITIAL (sig_ptr) = constructor;
1308: CLEAR_SIGNATURE (sig_ty);
1309: finish_decl (sig_ptr, constructor, 0, 0);
1310: SET_SIGNATURE (sig_ty);
1311: TREE_READONLY (sig_ptr) = 1;
1312:
1313: return sig_ptr;
1314: }
1315:
1316: /* Conversion between aggregate types. New C++ semantics allow
1317: objects of derived type to be cast to objects of base type.
1318: Old semantics only allowed this between pointers.
1319:
1320: There may be some ambiguity between using a constructor
1321: vs. using a type conversion operator when both apply. */
1322:
1323: if (IS_AGGR_TYPE (dtype) && ! DERIVED_FROM_P (type, dtype)
1324: && TYPE_HAS_CONVERSION (dtype))
1325: conversion = build_type_conversion (CONVERT_EXPR, type, e, 1);
1326:
1327: if (conversion == error_mark_node)
1328: {
1329: error ("ambiguous pointer conversion");
1330: return conversion;
1331: }
1332:
1333: if (TYPE_HAS_CONSTRUCTOR (type))
1334: ctor = build_method_call (NULL_TREE, constructor_name_full (type),
1335: build_tree_list (NULL_TREE, e),
1336: TYPE_BINFO (type),
1337: LOOKUP_NORMAL | LOOKUP_SPECULATIVELY
1338: | (conversion ? LOOKUP_NO_CONVERSION : 0));
1339:
1340: if (ctor == error_mark_node)
1341: {
1342: cp_error ("in conversion to type `%T'", type);
1343: return error_mark_node;
1344: }
1345:
1346: if (conversion && ctor)
1347: {
1348: error ("both constructor and type conversion operator apply");
1349: return error_mark_node;
1350: }
1351: else if (conversion)
1352: return conversion;
1353: else if (ctor)
1354: {
1355: if (current_function_decl)
1356: /* We can't pass 1 to the with_cleanup_p arg here, because that
1357: screws up passing classes by value. */
1358: ctor = build_cplus_new (type, ctor, 0);
1359: else
1360: {
1361: register tree parm = TREE_OPERAND (ctor, 1);
1362:
1363: /* Initializers for static variables and parameters
1364: have to handle doing the initialization and
1365: cleanup themselves. */
1366: my_friendly_assert (TREE_CODE (ctor) == CALL_EXPR, 322);
1367: #if 0
1368: /* The following assertion fails in cases where we
1369: are initializing a static member variable of a
1370: particular instance of a template class with a
1371: call to a constructor of the given instance, as
1372: in:
1373:
1374: TMPL<int> object = TMPL<int>();
1375:
1376: Curiously, the assertion does not fail if we do
1377: the same thing for a static member of a
1378: non-template class, as in:
1379:
1380: T object = T();
1381:
1382: I can't see why we should care here whether or not
1383: the initializer expression involves a call to
1384: `new', so for the time being, it seems best to
1385: just avoid doing this assertion. */
1386: my_friendly_assert (TREE_CALLS_NEW (TREE_VALUE (parm)),
1387: 323);
1388: #endif
1389: TREE_VALUE (parm) = NULL_TREE;
1390: ctor = build_indirect_ref (ctor, NULL_PTR);
1391: TREE_HAS_CONSTRUCTOR (ctor) = 1;
1392: }
1393: return ctor;
1394: }
1395: }
1396:
1397: /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
1398: then the it won't be hashed and hence compare as not equal,
1399: even when it is. */
1400: if (code == ARRAY_TYPE
1401: && TREE_TYPE (TREE_TYPE (e)) == TREE_TYPE (type)
1402: && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e)), TYPE_DOMAIN (type)))
1403: return e;
1404:
1405: cp_error ("conversion from `%T' to non-scalar type `%T' requested",
1406: TREE_TYPE (expr), type);
1407: return error_mark_node;
1408: }
1409:
1410: /* Create an expression whose value is that of EXPR,
1411: converted to type TYPE. The TREE_TYPE of the value
1412: is always TYPE. This function implements all reasonable
1413: conversions; callers should filter out those that are
1414: not permitted by the language being compiled. */
1415:
1416: tree
1417: convert (type, expr)
1418: tree type, expr;
1419: {
1420: return cp_convert (type, expr, CONV_OLD_CONVERT, 0);
1421: }
1422:
1423: /* Like convert, except permit conversions to take place which
1424: are not normally allowed due to access restrictions
1425: (such as conversion from sub-type to private super-type). */
1426: tree
1427: convert_force (type, expr)
1428: tree type;
1429: tree expr;
1430: {
1431: register tree e = expr;
1432: register enum tree_code code = TREE_CODE (type);
1433:
1434: if (code == REFERENCE_TYPE)
1435: return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
1436: NULL_TREE));
1437: else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
1438: e = convert_from_reference (e);
1439:
1440: if (code == POINTER_TYPE)
1441: return fold (convert_to_pointer_force (type, e));
1442:
1443: /* From typeck.c convert_for_assignment */
1444: if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
1445: && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
1446: && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
1447: || integer_zerop (e)
1448: || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
1449: && TYPE_PTRMEMFUNC_P (type))
1450: {
1451: /* compatible pointer to member functions. */
1452: return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1);
1453: }
1454: {
1455: int old_equiv = flag_int_enum_equivalence;
1456: flag_int_enum_equivalence = 1;
1457: e = convert (type, e);
1458: flag_int_enum_equivalence = old_equiv;
1459: }
1460: return e;
1461: }
1462:
1463: /* Subroutine of build_type_conversion. */
1464: static tree
1465: build_type_conversion_1 (xtype, basetype, expr, typename, for_sure)
1466: tree xtype, basetype;
1467: tree expr;
1468: tree typename;
1469: int for_sure;
1470: {
1471: tree rval;
1472: int flags;
1473:
1474: if (for_sure == 0)
1475: flags = LOOKUP_PROTECT;
1476: else
1477: flags = LOOKUP_NORMAL;
1478:
1479: rval = build_method_call (expr, typename, NULL_TREE, NULL_TREE, flags);
1480: if (rval == error_mark_node)
1481: {
1482: if (for_sure == 0)
1483: return NULL_TREE;
1484: return error_mark_node;
1485: }
1486: if (TREE_CODE (TREE_TYPE (rval)) == REFERENCE_TYPE
1487: && TREE_CODE (xtype) != REFERENCE_TYPE)
1488: rval = default_conversion (rval);
1489:
1490: if (warn_cast_qual
1491: && TREE_TYPE (xtype)
1492: && (TREE_READONLY (TREE_TYPE (TREE_TYPE (rval)))
1493: > TREE_READONLY (TREE_TYPE (xtype))))
1494: warning ("user-defined conversion casting away `const'");
1495: return convert (xtype, rval);
1496: }
1497:
1498: /* Convert an aggregate EXPR to type XTYPE. If a conversion
1499: exists, return the attempted conversion. This may
1500: return ERROR_MARK_NODE if the conversion is not
1501: allowed (references private members, etc).
1502: If no conversion exists, NULL_TREE is returned.
1503:
1504: If (FOR_SURE & 1) is non-zero, then we allow this type conversion
1505: to take place immediately. Otherwise, we build a SAVE_EXPR
1506: which can be evaluated if the results are ever needed.
1507:
1508: If FOR_SURE >= 2, then we only look for exact conversions.
1509:
1510: TYPE may be a reference type, in which case we first look
1511: for something that will convert to a reference type. If
1512: that fails, we will try to look for something of the
1513: reference's target type, and then return a reference to that. */
1514: tree
1515: build_type_conversion (code, xtype, expr, for_sure)
1516: enum tree_code code;
1517: tree xtype, expr;
1518: int for_sure;
1519: {
1520: /* C++: check to see if we can convert this aggregate type
1521: into the required scalar type. */
1522: tree type, type_default;
1523: tree typename = build_typename_overload (xtype), *typenames;
1524: int n_variants = 0;
1525: tree basetype, save_basetype;
1526: tree rval;
1527: int exact_conversion = for_sure >= 2;
1528: for_sure &= 1;
1529:
1530: if (expr == error_mark_node)
1531: return error_mark_node;
1532:
1533: basetype = TREE_TYPE (expr);
1534: if (TREE_CODE (basetype) == REFERENCE_TYPE)
1535: basetype = TREE_TYPE (basetype);
1536:
1537: if (TYPE_PTRMEMFUNC_P (basetype) && TREE_CODE (xtype) == BOOLEAN_TYPE)
1538: {
1539: /* We convert a pointer to member function into a boolean,
1540: by just checking the index value, for == 0, we want false, for
1541: != 0, we want true. */
1542: return convert (xtype, build_component_ref (expr, index_identifier, 0, 0));
1543: }
1544:
1545: basetype = TYPE_MAIN_VARIANT (basetype);
1546: if (! TYPE_LANG_SPECIFIC (basetype) || ! TYPE_HAS_CONVERSION (basetype))
1547: return NULL_TREE;
1548:
1549: if (TREE_CODE (xtype) == POINTER_TYPE
1550: || TREE_CODE (xtype) == REFERENCE_TYPE)
1551: {
1552: /* Prepare to match a variant of this type. */
1553: type = TYPE_MAIN_VARIANT (TREE_TYPE (xtype));
1554: for (n_variants = 0; type; type = TYPE_NEXT_VARIANT (type))
1555: n_variants++;
1556: typenames = (tree *)alloca (n_variants * sizeof (tree));
1557: for (n_variants = 0, type = TYPE_MAIN_VARIANT (TREE_TYPE (xtype));
1558: type; n_variants++, type = TYPE_NEXT_VARIANT (type))
1559: {
1560: if (type == TREE_TYPE (xtype))
1561: typenames[n_variants] = typename;
1562: else if (TREE_CODE (xtype) == POINTER_TYPE)
1563: typenames[n_variants] = build_typename_overload (build_pointer_type (type));
1564: else
1565: typenames[n_variants] = build_typename_overload (build_reference_type (type));
1566: }
1567: }
1568:
1569: save_basetype = basetype;
1570: type = xtype;
1571:
1572: while (TYPE_HAS_CONVERSION (basetype))
1573: {
1574: int i;
1575: if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0))
1576: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
1577: for (i = 0; i < n_variants; i++)
1578: if (typenames[i] != typename
1579: && lookup_fnfields (TYPE_BINFO (basetype), typenames[i], 0))
1580: return build_type_conversion_1 (xtype, basetype, expr, typenames[i], for_sure);
1581:
1582: if (TYPE_BINFO_BASETYPES (basetype))
1583: basetype = TYPE_BINFO_BASETYPE (basetype, 0);
1584: else
1585: break;
1586: }
1587:
1588: if (TREE_CODE (type) == REFERENCE_TYPE)
1589: {
1590: #if 0
1591: /* Only reference variable initializations can use a temporary; this
1592: must be handled elsewhere (like convert_to_reference and
1593: compute_conversion_costs). */
1594:
1595: type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
1596: typename = build_typename_overload (type);
1597: basetype = save_basetype;
1598:
1599: /* May need to build a temporary for this. */
1600: while (TYPE_HAS_CONVERSION (basetype))
1601: {
1602: if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0))
1603: {
1604: int flags;
1605:
1606: if (for_sure == 0)
1607: flags = LOOKUP_PROTECT;
1608: else
1609: flags = LOOKUP_NORMAL;
1610: rval = build_method_call (expr,
1611: constructor_name_full (typename),
1612: NULL_TREE, NULL_TREE, flags);
1613: if (rval == error_mark_node)
1614: {
1615: if (for_sure == 0)
1616: return NULL_TREE;
1617: return error_mark_node;
1618: }
1619:
1620: return convert (xtype, rval);
1621: }
1622: if (TYPE_BINFO_BASETYPES (basetype))
1623: basetype = TYPE_BINFO_BASETYPE (basetype, 0);
1624: else
1625: break;
1626: }
1627: #endif
1628: /* No free conversions for reference types, right?. */
1629: return NULL_TREE;
1630: }
1631:
1632: if (exact_conversion)
1633: return NULL_TREE;
1634:
1635: if (TREE_CODE (type) == BOOLEAN_TYPE)
1636: {
1637: tree as_int = build_type_conversion (code, long_long_unsigned_type_node, expr, 0);
1638: tree as_ptr = build_type_conversion (code, ptr_type_node, expr, 0);
1639: /* We are missing the conversion to pointer to member type. */
1640: /* We are missing the conversion to floating type. */
1641: if (as_int && as_ptr && for_sure)
1642: {
1643: cp_error ("ambiguous conversion from `%T' to `bool', can convert to integral type or pointer", TREE_TYPE (expr));
1644: return error_mark_node;
1645: }
1646: if (as_int)
1647: {
1648: as_int = build_type_conversion (code, long_long_unsigned_type_node, expr, for_sure+exact_conversion*2);
1649: return convert (xtype, as_int);
1650: }
1651: if (as_ptr)
1652: {
1653: as_ptr = build_type_conversion (code, ptr_type_node, expr, for_sure+exact_conversion*2);
1654: return convert (xtype, as_ptr);
1655: }
1656: return NULL_TREE;
1657: }
1658:
1659: /* No perfect match found, try default. */
1660: #if 0 /* This is wrong; there is no standard conversion from void* to
1661: anything. -jason */
1662: if (code == CONVERT_EXPR && TREE_CODE (type) == POINTER_TYPE)
1663: type_default = ptr_type_node;
1664: else
1665: #endif
1666: if (type == void_type_node)
1667: return NULL_TREE;
1668: else
1669: {
1670: tree tmp = default_conversion (build1 (NOP_EXPR, type, integer_zero_node));
1671: if (tmp == error_mark_node)
1672: return NULL_TREE;
1673: type_default = TREE_TYPE (tmp);
1674: }
1675:
1676: basetype = save_basetype;
1677:
1678: if (type_default != type)
1679: {
1680: type = type_default;
1681: typename = build_typename_overload (type);
1682:
1683: while (TYPE_HAS_CONVERSION (basetype))
1684: {
1685: if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0))
1686: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
1687: if (TYPE_BINFO_BASETYPES (basetype))
1688: basetype = TYPE_BINFO_BASETYPE (basetype, 0);
1689: else
1690: break;
1691: }
1692: }
1693:
1694: if (TREE_CODE (type) == POINTER_TYPE && TYPE_READONLY (TREE_TYPE (type)))
1695: {
1696: /* Try converting to some other const pointer type and then using
1697: standard conversions. */
1698:
1699: while (TYPE_HAS_CONVERSION (basetype))
1700: {
1701: if (CLASSTYPE_CONVERSION (basetype, constptr_conv) != 0)
1702: {
1703: if (CLASSTYPE_CONVERSION (basetype, constptr_conv) == error_mark_node)
1704: return error_mark_node;
1705: typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, constptr_conv));
1706: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
1707: }
1708: if (TYPE_BINFO_BASETYPES (basetype))
1709: basetype = TYPE_BINFO_BASETYPE (basetype, 0);
1710: else
1711: break;
1712: }
1713: }
1714: if (TREE_CODE (type) == POINTER_TYPE)
1715: {
1716: /* Try converting to some other pointer type and then using standard
1717: conversions. */
1718:
1719: while (TYPE_HAS_CONVERSION (basetype))
1720: {
1721: if (CLASSTYPE_CONVERSION (basetype, ptr_conv) != 0)
1722: {
1723: if (CLASSTYPE_CONVERSION (basetype, ptr_conv) == error_mark_node)
1724: return error_mark_node;
1725: typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, ptr_conv));
1726: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
1727: }
1728: if (TYPE_BINFO_BASETYPES (basetype))
1729: basetype = TYPE_BINFO_BASETYPE (basetype, 0);
1730: else
1731: break;
1732: }
1733: }
1734:
1735: /* Use the longer or shorter conversion that is appropriate. Have
1736: to check against 0 because the conversion may come from a baseclass. */
1737: if (TREE_CODE (type) == INTEGER_TYPE
1738: && TYPE_HAS_INT_CONVERSION (basetype)
1739: && CLASSTYPE_CONVERSION (basetype, int_conv) != 0
1740: && CLASSTYPE_CONVERSION (basetype, int_conv) != error_mark_node)
1741: {
1742: typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, int_conv));
1743: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
1744: }
1745:
1746: if (TREE_CODE (type) == REAL_TYPE
1747: && TYPE_HAS_REAL_CONVERSION (basetype)
1748: && CLASSTYPE_CONVERSION (basetype, real_conv) != 0
1749: && CLASSTYPE_CONVERSION (basetype, real_conv) != error_mark_node)
1750: {
1751: /* Only accept using an operator double() if there isn't a conflicting
1752: operator int(). */
1753: if (TYPE_HAS_INT_CONVERSION (basetype))
1754: {
1755: if (for_sure)
1756: {
1757: cp_error ("two possible conversions for type `%T'", type);
1758: return error_mark_node;
1759: }
1760: else
1761: return NULL_TREE;
1762: }
1763:
1764: typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, real_conv));
1765: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
1766: }
1767:
1768: /* THESE ARE TOTAL KLUDGES. */
1769: /* Default promotion yields no new alternatives, try
1770: conversions which are anti-default, such as
1771:
1772: double -> float or int -> unsigned or unsigned -> long
1773:
1774: */
1775: if (type_default == type
1776: && (INTEGRAL_TYPE_P (type) || TREE_CODE (type) == REAL_TYPE))
1777: {
1778: int not_again = 0;
1779:
1780: if (type == double_type_node)
1781: typename = build_typename_overload (float_type_node);
1782: else if (type == integer_type_node)
1783: typename = build_typename_overload (unsigned_type_node);
1784: else if (type == unsigned_type_node)
1785: typename = build_typename_overload (long_integer_type_node);
1786:
1787: again:
1788: basetype = save_basetype;
1789: while (TYPE_HAS_CONVERSION (basetype))
1790: {
1791: if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0))
1792: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
1793: if (TYPE_BINFO_BASETYPES (basetype))
1794: basetype = TYPE_BINFO_BASETYPE (basetype, 0);
1795: else
1796: break;
1797: }
1798: if (! not_again)
1799: {
1800: if (type == integer_type_node)
1801: {
1802: typename = build_typename_overload (long_integer_type_node);
1803: not_again = 1;
1804: goto again;
1805: }
1806: else
1807: {
1808: typename = build_typename_overload (integer_type_node);
1809: not_again = 1;
1810: goto again;
1811: }
1812: }
1813: }
1814:
1815: /* Now, try C promotions...
1816:
1817: float -> int
1818: int -> float */
1819:
1820: basetype = save_basetype;
1821: if (TREE_CODE (type) == REAL_TYPE)
1822: type = integer_type_node;
1823: else if (TREE_CODE (type) == INTEGER_TYPE)
1824: if (TYPE_HAS_REAL_CONVERSION (basetype))
1825: type = double_type_node;
1826: else
1827: return NULL_TREE;
1828: else
1829: return NULL_TREE;
1830:
1831: typename = build_typename_overload (type);
1832: while (TYPE_HAS_CONVERSION (basetype))
1833: {
1834: if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0))
1835: {
1836: rval = build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
1837: return rval;
1838: }
1839: if (TYPE_BINFO_BASETYPES (basetype))
1840: basetype = TYPE_BINFO_BASETYPE (basetype, 0);
1841: else
1842: break;
1843: }
1844:
1845: return NULL_TREE;
1846: }
1847:
1848: /* Must convert two aggregate types to non-aggregate type.
1849: Attempts to find a non-ambiguous, "best" type conversion.
1850:
1851: Return 1 on success, 0 on failure.
1852:
1853: @@ What are the real semantics of this supposed to be??? */
1854: int
1855: build_default_binary_type_conversion (code, arg1, arg2)
1856: enum tree_code code;
1857: tree *arg1, *arg2;
1858: {
1859: tree type1 = TREE_TYPE (*arg1);
1860: tree type2 = TREE_TYPE (*arg2);
1861:
1862: if (TREE_CODE (type1) == REFERENCE_TYPE
1863: || TREE_CODE (type1) == POINTER_TYPE)
1864: type1 = TREE_TYPE (type1);
1865: if (TREE_CODE (type2) == REFERENCE_TYPE
1866: || TREE_CODE (type2) == POINTER_TYPE)
1867: type2 = TREE_TYPE (type2);
1868:
1869: if (TREE_CODE (TYPE_NAME (type1)) != TYPE_DECL)
1870: {
1871: tree decl = typedecl_for_tag (type1);
1872: if (decl)
1873: error ("type conversion nonexistent for type `%s'",
1874: IDENTIFIER_POINTER (DECL_NAME (decl)));
1875: else
1876: error ("type conversion nonexistent for non-C++ type");
1877: return 0;
1878: }
1879: if (TREE_CODE (TYPE_NAME (type2)) != TYPE_DECL)
1880: {
1881: tree decl = typedecl_for_tag (type2);
1882: if (decl)
1883: error ("type conversion nonexistent for type `%s'",
1884: IDENTIFIER_POINTER (decl));
1885: else
1886: error ("type conversion nonexistent for non-C++ type");
1887: return 0;
1888: }
1889:
1890: if (!IS_AGGR_TYPE (type1) || !TYPE_HAS_CONVERSION (type1))
1891: {
1892: if (!IS_AGGR_TYPE (type2) || !TYPE_HAS_CONVERSION (type2))
1893: cp_error ("no conversion from `%T' and `%T' to types with default `%O' ",
1894: type1, type2, code);
1895: else
1896: cp_error ("no conversion from `%T' to type with default `%O'",
1897: type1, code);
1898: return 0;
1899: }
1900: else if (!IS_AGGR_TYPE (type2) || !TYPE_HAS_CONVERSION (type2))
1901: {
1902: cp_error ("no conversion from `%T' to type with default `%O'",
1903: type2, code);
1904: return 0;
1905: }
1906:
1907: if (code == TRUTH_ANDIF_EXPR
1908: || code == TRUTH_ORIF_EXPR)
1909: {
1910: *arg1 = convert (bool_type_node, *arg1);
1911: *arg2 = convert (bool_type_node, *arg2);
1912: }
1913: else if (TYPE_HAS_INT_CONVERSION (type1))
1914: {
1915: if (TYPE_HAS_REAL_CONVERSION (type1))
1916: cp_pedwarn ("ambiguous type conversion for type `%T', defaulting to int",
1917: type1);
1918: *arg1 = build_type_conversion (code, integer_type_node, *arg1, 1);
1919: *arg2 = build_type_conversion (code, integer_type_node, *arg2, 1);
1920: }
1921: else if (TYPE_HAS_REAL_CONVERSION (type1))
1922: {
1923: *arg1 = build_type_conversion (code, double_type_node, *arg1, 1);
1924: *arg2 = build_type_conversion (code, double_type_node, *arg2, 1);
1925: }
1926: else
1927: {
1928: *arg1 = build_type_conversion (code, ptr_type_node, *arg1, 1);
1929: if (*arg1 == error_mark_node)
1930: error ("ambiguous pointer conversion");
1931: *arg2 = build_type_conversion (code, ptr_type_node, *arg2, 1);
1932: if (*arg1 != error_mark_node && *arg2 == error_mark_node)
1933: error ("ambiguous pointer conversion");
1934: }
1935: if (*arg1 == 0)
1936: {
1937: if (*arg2 == 0 && type1 != type2)
1938: cp_error ("default type conversion for types `%T' and `%T' failed",
1939: type1, type2);
1940: else
1941: cp_error ("default type conversion for type `%T' failed", type1);
1942: return 0;
1943: }
1944: else if (*arg2 == 0)
1945: {
1946: cp_error ("default type conversion for type `%T' failed", type2);
1947: return 0;
1948: }
1949: return 1;
1950: }
1951:
1952: /* Must convert an aggregate type to non-aggregate type.
1953: Attempts to find a non-ambiguous, "best" type conversion.
1954:
1955: Return 1 on success, 0 on failure.
1956:
1957: The type of the argument is expected to be of aggregate type here.
1958:
1959: @@ What are the real semantics of this supposed to be??? */
1960: int
1961: build_default_unary_type_conversion (code, arg)
1962: enum tree_code code;
1963: tree *arg;
1964: {
1965: tree type = TREE_TYPE (*arg);
1966:
1967: if (! TYPE_HAS_CONVERSION (type))
1968: {
1969: cp_error ("type conversion required for type `%T'", type);
1970: return 0;
1971: }
1972:
1973: if (code == TRUTH_NOT_EXPR)
1974: *arg = convert (bool_type_node, *arg);
1975: else if (TYPE_HAS_INT_CONVERSION (type))
1976: {
1977: if (TYPE_HAS_REAL_CONVERSION (type))
1978: cp_pedwarn ("ambiguous type conversion for type `%T', defaulting to int",
1979: type);
1980: *arg = build_type_conversion (code, integer_type_node, *arg, 1);
1981: }
1982: else if (TYPE_HAS_REAL_CONVERSION (type))
1983: *arg = build_type_conversion (code, double_type_node, *arg, 1);
1984: else
1985: {
1986: *arg = build_type_conversion (code, ptr_type_node, *arg, 1);
1987: if (*arg == error_mark_node)
1988: error ("ambiguous pointer conversion");
1989: }
1990: if (*arg == NULL_TREE)
1991: {
1992: cp_error ("default type conversion for type `%T' failed", type);
1993: return 0;
1994: }
1995: return 1;
1996: }
1997:
1998: /* Implements integral promotion (4.1) and float->double promotion. */
1999: tree
2000: type_promotes_to (type)
2001: tree type;
2002: {
2003: int constp = TYPE_READONLY (type);
2004: int volatilep = TYPE_VOLATILE (type);
2005: type = TYPE_MAIN_VARIANT (type);
2006:
2007: /* bool always promotes to int (not unsigned), even if it's the same
2008: size. */
2009: if (type == bool_type_node)
2010: type = integer_type_node;
2011:
2012: /* Normally convert enums to int, but convert wide enums to something
2013: wider. */
2014: else if (TREE_CODE (type) == ENUMERAL_TYPE
2015: || type == wchar_type_node)
2016: {
2017: int precision = MAX (TYPE_PRECISION (type),
2018: TYPE_PRECISION (integer_type_node));
2019: tree totype = type_for_size (precision, 0);
2020: if (TREE_UNSIGNED (type)
2021: && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
2022: type = type_for_size (precision, 1);
2023: else
2024: type = totype;
2025: }
2026: else if (C_PROMOTING_INTEGER_TYPE_P (type))
2027: {
2028: /* Traditionally, unsignedness is preserved in default promotions.
2029: Otherwise, retain unsignedness if really not getting bigger. */
2030: if (TREE_UNSIGNED (type)
2031: && (flag_traditional
2032: || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
2033: type = unsigned_type_node;
2034: else
2035: type = integer_type_node;
2036: }
2037: else if (type == float_type_node)
2038: type = double_type_node;
2039:
2040: return cp_build_type_variant (type, constp, volatilep);
2041: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.