Mercurial > projects > ldc
annotate dmd/cast.c @ 1343:c21a6654cce2
Update for metadata changes in LLVM trunk.
author | Frits van Bommel <fvbommel wxs.nl> |
---|---|
date | Mon, 11 May 2009 11:59:22 +0200 |
parents | e961851fb8be |
children | 78038e540342 |
rev | line source |
---|---|
159 | 1 |
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1133
diff
changeset
|
2 // Copyright (c) 1999-2009 by Digital Mars |
159 | 3 // All Rights Reserved |
4 // written by Walter Bright | |
5 // http://www.digitalmars.com | |
6 // License for redistribution is by either the Artistic License | |
7 // in artistic.txt, or the GNU General Public License in gnu.txt. | |
8 // See the included readme.txt for details. | |
9 | |
10 #include <stdio.h> | |
11 #include <assert.h> | |
12 | |
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
846
diff
changeset
|
13 #include "rmem.h" |
159 | 14 |
15 #include "expression.h" | |
16 #include "mtype.h" | |
17 #include "utf.h" | |
18 #include "declaration.h" | |
19 #include "aggregate.h" | |
20 | |
21 /* ==================== implicitCast ====================== */ | |
22 | |
23 /************************************** | |
24 * Do an implicit cast. | |
25 * Issue error if it can't be done. | |
26 */ | |
27 | |
28 Expression *Expression::implicitCastTo(Scope *sc, Type *t) | |
29 { | |
30 //printf("implicitCastTo(%s) => %s\n", type->toChars(), t->toChars()); | |
31 if (implicitConvTo(t)) | |
846
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
32 { TY tyfrom = type->toBasetype()->ty; |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
33 TY tyto = t->toBasetype()->ty; |
159 | 34 if (global.params.warnings && |
846
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
35 Type::impcnvWarn[tyfrom][tyto] && |
159 | 36 op != TOKint64) |
37 { | |
38 Expression *e = optimize(WANTflags | WANTvalue); | |
39 | |
40 if (e->op == TOKint64) | |
41 return e->implicitCastTo(sc, t); | |
42 | |
846
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
43 if (tyfrom == Tint32 && |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
44 (op == TOKadd || op == TOKmin || |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
45 op == TOKand || op == TOKor || op == TOKxor) |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
46 ) |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
47 { |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
48 /* This is really only a semi-kludge fix, |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
49 * we really should look at the operands of op |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
50 * and see if they are narrower types. |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
51 * For example, b=b|b and b=b|7 and s=b+b should be allowed, |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
52 * but b=b|i should be an error. |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
53 */ |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
54 ; |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
55 } |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
56 else |
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
57 { |
1133
eeb8b95ea92e
Cleanup DMD 1.041 merge.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1103
diff
changeset
|
58 warning("implicit conversion of expression (%s) of type %s to %s can cause loss of data", |
eeb8b95ea92e
Cleanup DMD 1.041 merge.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1103
diff
changeset
|
59 toChars(), type->toChars(), t->toChars()); |
846
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
60 } |
159 | 61 } |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
62 #if DMDV2 |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
63 if (match == MATCHconst && t == type->constOf()) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
64 { |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
65 Expression *e = copy(); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
66 e->type = t; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
67 return e; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
68 } |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
69 #endif |
159 | 70 return castTo(sc, t); |
71 } | |
72 | |
73 Expression *e = optimize(WANTflags | WANTvalue); | |
74 if (e != this) | |
75 return e->implicitCastTo(sc, t); | |
76 | |
77 #if 0 | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
78 printf("ty = %d\n", type->ty); |
159 | 79 print(); |
80 type->print(); | |
81 printf("to:\n"); | |
82 t->print(); | |
83 printf("%p %p type: %s to: %s\n", type->deco, t->deco, type->deco, t->deco); | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
84 //printf("%p %p %p\n", type->nextOf()->arrayOf(), type, t); |
159 | 85 fflush(stdout); |
86 #endif | |
87 if (!t->deco) | |
88 { /* Can happen with: | |
89 * enum E { One } | |
90 * class A | |
91 * { static void fork(EDG dg) { dg(E.One); } | |
92 * alias void delegate(E) EDG; | |
93 * } | |
94 * Should eventually make it work. | |
95 */ | |
96 error("forward reference to type %s", t->toChars()); | |
97 } | |
98 else if (t->reliesOnTident()) | |
99 error("forward reference to type %s", t->reliesOnTident()->toChars()); | |
100 | |
101 error("cannot implicitly convert expression (%s) of type %s to %s", | |
102 toChars(), type->toChars(), t->toChars()); | |
103 return castTo(sc, t); | |
104 } | |
105 | |
106 /******************************************* | |
107 * Return !=0 if we can implicitly convert this to type t. | |
108 * Don't do the actual cast. | |
109 */ | |
110 | |
111 MATCH Expression::implicitConvTo(Type *t) | |
112 { | |
113 #if 0 | |
114 printf("Expression::implicitConvTo(this=%s, type=%s, t=%s)\n", | |
115 toChars(), type->toChars(), t->toChars()); | |
116 #endif | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
117 //static int nest; if (++nest == 10) halt(); |
159 | 118 if (!type) |
119 { error("%s is not an expression", toChars()); | |
120 type = Type::terror; | |
121 } | |
122 if (t->ty == Tbit && isBit()) | |
123 return MATCHconvert; | |
124 Expression *e = optimize(WANTvalue | WANTflags); | |
125 if (e != this) | |
126 { //printf("optimzed to %s\n", e->toChars()); | |
127 return e->implicitConvTo(t); | |
128 } | |
129 MATCH match = type->implicitConvTo(t); | |
130 if (match) | |
131 return match; | |
132 #if 0 | |
133 Type *tb = t->toBasetype(); | |
134 if (tb->ty == Tdelegate) | |
135 { TypeDelegate *td = (TypeDelegate *)tb; | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
136 TypeFunction *tf = (TypeFunction *)td->nextOf(); |
159 | 137 |
138 if (!tf->varargs && | |
139 !(tf->arguments && tf->arguments->dim) | |
140 ) | |
141 { | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
142 match = type->implicitConvTo(tf->nextOf()); |
159 | 143 if (match) |
144 return match; | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
145 if (tf->nextOf()->toBasetype()->ty == Tvoid) |
159 | 146 return MATCHconvert; |
147 } | |
148 } | |
149 #endif | |
150 return MATCHnomatch; | |
151 } | |
152 | |
153 | |
154 MATCH IntegerExp::implicitConvTo(Type *t) | |
155 { | |
156 #if 0 | |
157 printf("IntegerExp::implicitConvTo(this=%s, type=%s, t=%s)\n", | |
158 toChars(), type->toChars(), t->toChars()); | |
159 #endif | |
160 if (type->equals(t)) | |
161 return MATCHexact; | |
162 | |
163 enum TY ty = type->toBasetype()->ty; | |
164 enum TY toty = t->toBasetype()->ty; | |
165 | |
166 if (type->implicitConvTo(t) == MATCHnomatch && t->ty == Tenum) | |
167 { | |
168 return MATCHnomatch; | |
169 } | |
170 | |
171 switch (ty) | |
172 { | |
173 case Tbit: | |
174 case Tbool: | |
175 value &= 1; | |
176 ty = Tint32; | |
177 break; | |
178 | |
179 case Tint8: | |
180 value = (signed char)value; | |
181 ty = Tint32; | |
182 break; | |
183 | |
184 case Tchar: | |
185 case Tuns8: | |
186 value &= 0xFF; | |
187 ty = Tint32; | |
188 break; | |
189 | |
190 case Tint16: | |
191 value = (short)value; | |
192 ty = Tint32; | |
193 break; | |
194 | |
195 case Tuns16: | |
196 case Twchar: | |
197 value &= 0xFFFF; | |
198 ty = Tint32; | |
199 break; | |
200 | |
201 case Tint32: | |
202 value = (int)value; | |
203 break; | |
204 | |
205 case Tuns32: | |
206 case Tdchar: | |
207 value &= 0xFFFFFFFF; | |
208 ty = Tuns32; | |
209 break; | |
210 | |
211 default: | |
212 break; | |
213 } | |
214 | |
215 // Only allow conversion if no change in value | |
216 switch (toty) | |
217 { | |
218 case Tbit: | |
219 case Tbool: | |
220 if ((value & 1) != value) | |
221 goto Lno; | |
222 goto Lyes; | |
223 | |
224 case Tint8: | |
225 if ((signed char)value != value) | |
226 goto Lno; | |
227 goto Lyes; | |
228 | |
229 case Tchar: | |
230 case Tuns8: | |
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1133
diff
changeset
|
231 //printf("value = %llu %llu\n", (dinteger_t)(unsigned char)value, value); |
159 | 232 if ((unsigned char)value != value) |
233 goto Lno; | |
234 goto Lyes; | |
235 | |
236 case Tint16: | |
237 if ((short)value != value) | |
238 goto Lno; | |
239 goto Lyes; | |
240 | |
241 case Tuns16: | |
242 if ((unsigned short)value != value) | |
243 goto Lno; | |
244 goto Lyes; | |
245 | |
246 case Tint32: | |
247 if (ty == Tuns32) | |
248 { | |
249 } | |
250 else if ((int)value != value) | |
251 goto Lno; | |
252 goto Lyes; | |
253 | |
254 case Tuns32: | |
255 if (ty == Tint32) | |
256 { | |
257 } | |
258 else if ((unsigned)value != value) | |
259 goto Lno; | |
260 goto Lyes; | |
261 | |
262 case Tdchar: | |
263 if (value > 0x10FFFFUL) | |
264 goto Lno; | |
265 goto Lyes; | |
266 | |
267 case Twchar: | |
268 if ((unsigned short)value != value) | |
269 goto Lno; | |
270 goto Lyes; | |
271 | |
272 case Tfloat32: | |
273 { | |
274 volatile float f; | |
275 if (type->isunsigned()) | |
276 { | |
277 f = (float)value; | |
278 if (f != value) | |
279 goto Lno; | |
280 } | |
281 else | |
282 { | |
283 f = (float)(long long)value; | |
284 if (f != (long long)value) | |
285 goto Lno; | |
286 } | |
287 goto Lyes; | |
288 } | |
289 | |
290 case Tfloat64: | |
291 { | |
292 volatile double f; | |
293 if (type->isunsigned()) | |
294 { | |
295 f = (double)value; | |
296 if (f != value) | |
297 goto Lno; | |
298 } | |
299 else | |
300 { | |
301 f = (double)(long long)value; | |
302 if (f != (long long)value) | |
303 goto Lno; | |
304 } | |
305 goto Lyes; | |
306 } | |
307 | |
308 case Tfloat80: | |
309 { | |
310 volatile long double f; | |
311 if (type->isunsigned()) | |
312 { | |
313 f = (long double)value; | |
314 if (f != value) | |
315 goto Lno; | |
316 } | |
317 else | |
318 { | |
319 f = (long double)(long long)value; | |
320 if (f != (long long)value) | |
321 goto Lno; | |
322 } | |
323 goto Lyes; | |
324 } | |
325 } | |
326 return Expression::implicitConvTo(t); | |
327 | |
328 Lyes: | |
329 //printf("MATCHconvert\n"); | |
330 return MATCHconvert; | |
331 | |
332 Lno: | |
333 //printf("MATCHnomatch\n"); | |
334 return MATCHnomatch; | |
335 } | |
336 | |
337 MATCH NullExp::implicitConvTo(Type *t) | |
338 { | |
339 #if 0 | |
717
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
340 printf("NullExp::implicitConvTo(this=%s, type=%s, t=%s, committed = %d)\n", |
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
341 toChars(), type->toChars(), t->toChars(), committed); |
159 | 342 #endif |
343 if (this->type->equals(t)) | |
344 return MATCHexact; | |
345 // NULL implicitly converts to any pointer type or dynamic array | |
346 if (type->ty == Tpointer && type->next->ty == Tvoid) | |
347 { | |
348 if (t->ty == Ttypedef) | |
349 t = ((TypeTypedef *)t)->sym->basetype; | |
350 if (t->ty == Tpointer || t->ty == Tarray || | |
351 t->ty == Taarray || t->ty == Tclass || | |
352 t->ty == Tdelegate) | |
353 return committed ? MATCHconvert : MATCHexact; | |
354 } | |
355 return Expression::implicitConvTo(t); | |
356 } | |
357 | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
358 #if DMDV2 |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
359 MATCH StructLiteralExp::implicitConvTo(Type *t) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
360 { |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
361 #if 0 |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
362 printf("StructLiteralExp::implicitConvTo(this=%s, type=%s, t=%s)\n", |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
363 toChars(), type->toChars(), t->toChars()); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
364 #endif |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
365 MATCH m = Expression::implicitConvTo(t); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
366 if (m != MATCHnomatch) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
367 return m; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
368 if (type->ty == t->ty && type->ty == Tstruct && |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
369 ((TypeStruct *)type)->sym == ((TypeStruct *)t)->sym) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
370 { |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
371 m = MATCHconst; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
372 for (int i = 0; i < elements->dim; i++) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
373 { Expression *e = (Expression *)elements->data[i]; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
374 Type *te = e->type; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
375 if (t->mod == 0) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
376 te = te->mutableOf(); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
377 else |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
378 { assert(t->mod == MODinvariant); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
379 te = te->invariantOf(); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
380 } |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
381 MATCH m2 = e->implicitConvTo(te); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
382 //printf("\t%s => %s, match = %d\n", e->toChars(), te->toChars(), m2); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
383 if (m2 < m) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
384 m = m2; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
385 } |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
386 } |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
387 return m; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
388 } |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
389 #endif |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
390 |
159 | 391 MATCH StringExp::implicitConvTo(Type *t) |
392 { MATCH m; | |
393 | |
394 #if 0 | |
395 printf("StringExp::implicitConvTo(this=%s, committed=%d, type=%s, t=%s)\n", | |
396 toChars(), committed, type->toChars(), t->toChars()); | |
397 #endif | |
398 if (!committed) | |
399 { | |
400 if (!committed && t->ty == Tpointer && t->next->ty == Tvoid) | |
401 { | |
402 return MATCHnomatch; | |
403 } | |
404 if (type->ty == Tsarray || type->ty == Tarray || type->ty == Tpointer) | |
405 { | |
406 if (type->next->ty == Tchar) | |
407 { | |
408 switch (t->ty) | |
409 { | |
410 case Tsarray: | |
411 if (type->ty == Tsarray && | |
412 ((TypeSArray *)type)->dim->toInteger() != | |
413 ((TypeSArray *)t)->dim->toInteger()) | |
414 return MATCHnomatch; | |
415 goto L1; | |
416 case Tarray: | |
417 goto L1; | |
418 case Tpointer: | |
419 L1: | |
420 if (t->next->ty == Tchar) | |
421 return MATCHexact; | |
422 else if (t->next->ty == Twchar) | |
423 return MATCHexact; | |
424 else if (t->next->ty == Tdchar) | |
425 return MATCHexact; | |
426 break; | |
427 } | |
428 } | |
429 } | |
430 } | |
431 return Expression::implicitConvTo(t); | |
432 #if 0 | |
433 m = (MATCH)type->implicitConvTo(t); | |
434 if (m) | |
435 { | |
436 return m; | |
437 } | |
438 | |
439 return MATCHnomatch; | |
440 #endif | |
441 } | |
442 | |
443 MATCH ArrayLiteralExp::implicitConvTo(Type *t) | |
444 { MATCH result = MATCHexact; | |
445 | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
446 #if 0 |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
447 printf("ArrayLiteralExp::implicitConvTo(this=%s, type=%s, t=%s)\n", |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
448 toChars(), type->toChars(), t->toChars()); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
449 #endif |
159 | 450 Type *typeb = type->toBasetype(); |
451 Type *tb = t->toBasetype(); | |
452 if ((tb->ty == Tarray || tb->ty == Tsarray) && | |
453 (typeb->ty == Tarray || typeb->ty == Tsarray)) | |
454 { | |
455 if (tb->ty == Tsarray) | |
456 { TypeSArray *tsa = (TypeSArray *)tb; | |
457 if (elements->dim != tsa->dim->toInteger()) | |
458 result = MATCHnomatch; | |
459 } | |
460 | |
461 for (int i = 0; i < elements->dim; i++) | |
462 { Expression *e = (Expression *)elements->data[i]; | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
463 MATCH m = (MATCH)e->implicitConvTo(tb->nextOf()); |
159 | 464 if (m < result) |
465 result = m; // remember worst match | |
466 if (result == MATCHnomatch) | |
467 break; // no need to check for worse | |
468 } | |
469 return result; | |
470 } | |
471 else | |
472 return Expression::implicitConvTo(t); | |
473 } | |
474 | |
475 MATCH AssocArrayLiteralExp::implicitConvTo(Type *t) | |
476 { MATCH result = MATCHexact; | |
477 | |
478 Type *typeb = type->toBasetype(); | |
479 Type *tb = t->toBasetype(); | |
480 if (tb->ty == Taarray && typeb->ty == Taarray) | |
481 { | |
482 for (size_t i = 0; i < keys->dim; i++) | |
483 { Expression *e = (Expression *)keys->data[i]; | |
484 MATCH m = (MATCH)e->implicitConvTo(((TypeAArray *)tb)->key); | |
485 if (m < result) | |
486 result = m; // remember worst match | |
487 if (result == MATCHnomatch) | |
488 break; // no need to check for worse | |
489 e = (Expression *)values->data[i]; | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
490 m = (MATCH)e->implicitConvTo(tb->nextOf()); |
159 | 491 if (m < result) |
492 result = m; // remember worst match | |
493 if (result == MATCHnomatch) | |
494 break; // no need to check for worse | |
495 } | |
496 return result; | |
497 } | |
498 else | |
499 return Expression::implicitConvTo(t); | |
500 } | |
501 | |
502 MATCH AddrExp::implicitConvTo(Type *t) | |
503 { | |
504 #if 0 | |
505 printf("AddrExp::implicitConvTo(this=%s, type=%s, t=%s)\n", | |
506 toChars(), type->toChars(), t->toChars()); | |
507 #endif | |
508 MATCH result; | |
509 | |
510 result = type->implicitConvTo(t); | |
511 //printf("\tresult = %d\n", result); | |
512 | |
513 if (result == MATCHnomatch) | |
514 { | |
515 // Look for pointers to functions where the functions are overloaded. | |
516 VarExp *ve; | |
517 FuncDeclaration *f; | |
518 | |
519 t = t->toBasetype(); | |
520 if (type->ty == Tpointer && type->next->ty == Tfunction && | |
521 t->ty == Tpointer && t->next->ty == Tfunction && | |
522 e1->op == TOKvar) | |
523 { | |
524 ve = (VarExp *)e1; | |
525 f = ve->var->isFuncDeclaration(); | |
526 if (f && f->overloadExactMatch(t->next)) | |
527 result = MATCHexact; | |
528 } | |
529 } | |
530 //printf("\tresult = %d\n", result); | |
531 return result; | |
532 } | |
533 | |
534 MATCH SymOffExp::implicitConvTo(Type *t) | |
535 { | |
536 #if 0 | |
537 printf("SymOffExp::implicitConvTo(this=%s, type=%s, t=%s)\n", | |
538 toChars(), type->toChars(), t->toChars()); | |
539 #endif | |
540 MATCH result; | |
541 | |
542 result = type->implicitConvTo(t); | |
543 //printf("\tresult = %d\n", result); | |
544 | |
545 if (result == MATCHnomatch) | |
546 { | |
547 // Look for pointers to functions where the functions are overloaded. | |
548 FuncDeclaration *f; | |
549 | |
550 t = t->toBasetype(); | |
551 if (type->ty == Tpointer && type->next->ty == Tfunction && | |
552 t->ty == Tpointer && t->next->ty == Tfunction) | |
553 { | |
554 f = var->isFuncDeclaration(); | |
555 if (f && f->overloadExactMatch(t->next)) | |
556 result = MATCHexact; | |
557 } | |
558 } | |
559 //printf("\tresult = %d\n", result); | |
560 return result; | |
561 } | |
562 | |
563 MATCH DelegateExp::implicitConvTo(Type *t) | |
564 { | |
565 #if 0 | |
566 printf("DelegateExp::implicitConvTo(this=%s, type=%s, t=%s)\n", | |
567 toChars(), type->toChars(), t->toChars()); | |
568 #endif | |
569 MATCH result; | |
570 | |
571 result = type->implicitConvTo(t); | |
572 | |
573 if (result == 0) | |
574 { | |
575 // Look for pointers to functions where the functions are overloaded. | |
576 FuncDeclaration *f; | |
577 | |
578 t = t->toBasetype(); | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
579 if (type->ty == Tdelegate && type->nextOf()->ty == Tfunction && |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
580 t->ty == Tdelegate && t->nextOf()->ty == Tfunction) |
159 | 581 { |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
582 if (func && func->overloadExactMatch(t->nextOf())) |
159 | 583 result = MATCHexact; |
584 } | |
585 } | |
586 return result; | |
587 } | |
588 | |
589 MATCH CondExp::implicitConvTo(Type *t) | |
590 { | |
591 MATCH m1; | |
592 MATCH m2; | |
593 | |
594 m1 = e1->implicitConvTo(t); | |
595 m2 = e2->implicitConvTo(t); | |
596 | |
597 // Pick the worst match | |
598 return (m1 < m2) ? m1 : m2; | |
599 } | |
600 | |
601 | |
602 /* ==================== castTo ====================== */ | |
603 | |
604 /************************************** | |
605 * Do an explicit cast. | |
606 */ | |
607 | |
608 Expression *Expression::castTo(Scope *sc, Type *t) | |
609 { | |
610 //printf("Expression::castTo(this=%s, t=%s)\n", toChars(), t->toChars()); | |
611 #if 0 | |
612 printf("Expression::castTo(this=%s, type=%s, t=%s)\n", | |
613 toChars(), type->toChars(), t->toChars()); | |
614 #endif | |
615 if (type == t) | |
616 return this; | |
617 Expression *e = this; | |
618 Type *tb = t->toBasetype(); | |
619 Type *typeb = type->toBasetype(); | |
620 if (tb != typeb) | |
621 { | |
622 // Do (type *) cast of (type [dim]) | |
623 if (tb->ty == Tpointer && | |
624 typeb->ty == Tsarray | |
625 ) | |
626 { | |
627 //printf("Converting [dim] to *\n"); | |
628 | |
629 if (typeb->size(loc) == 0) | |
630 e = new NullExp(loc); | |
631 else | |
632 e = new AddrExp(loc, e); | |
633 } | |
634 #if 0 | |
635 else if (tb->ty == Tdelegate && type->ty != Tdelegate) | |
636 { | |
637 TypeDelegate *td = (TypeDelegate *)tb; | |
638 TypeFunction *tf = (TypeFunction *)td->nextOf(); | |
639 return toDelegate(sc, tf->nextOf()); | |
640 } | |
641 #endif | |
642 else | |
643 { | |
644 e = new CastExp(loc, e, tb); | |
645 } | |
646 } | |
647 else | |
648 { | |
649 e = e->copy(); // because of COW for assignment to e->type | |
650 } | |
651 assert(e != this); | |
652 e->type = t; | |
653 //printf("Returning: %s\n", e->toChars()); | |
654 return e; | |
655 } | |
656 | |
657 | |
658 Expression *RealExp::castTo(Scope *sc, Type *t) | |
659 { Expression *e = this; | |
660 if (type != t) | |
661 { | |
662 if ((type->isreal() && t->isreal()) || | |
663 (type->isimaginary() && t->isimaginary()) | |
664 ) | |
665 { e = copy(); | |
666 e->type = t; | |
667 } | |
668 else | |
669 e = Expression::castTo(sc, t); | |
670 } | |
671 return e; | |
672 } | |
673 | |
674 | |
675 Expression *ComplexExp::castTo(Scope *sc, Type *t) | |
676 { Expression *e = this; | |
677 if (type != t) | |
678 { | |
679 if (type->iscomplex() && t->iscomplex()) | |
680 { e = copy(); | |
681 e->type = t; | |
682 } | |
683 else | |
684 e = Expression::castTo(sc, t); | |
685 } | |
686 return e; | |
687 } | |
688 | |
689 | |
690 Expression *NullExp::castTo(Scope *sc, Type *t) | |
691 { NullExp *e; | |
692 Type *tb; | |
693 | |
694 //printf("NullExp::castTo(t = %p)\n", t); | |
695 if (type == t) | |
696 { | |
697 committed = 1; | |
698 return this; | |
699 } | |
700 e = (NullExp *)copy(); | |
701 e->committed = 1; | |
702 tb = t->toBasetype(); | |
703 e->type = type->toBasetype(); | |
704 if (tb != e->type) | |
705 { | |
706 // NULL implicitly converts to any pointer type or dynamic array | |
707 if (e->type->ty == Tpointer && e->type->nextOf()->ty == Tvoid && | |
708 (tb->ty == Tpointer || tb->ty == Tarray || tb->ty == Taarray || | |
709 tb->ty == Tdelegate)) | |
710 { | |
711 #if 0 | |
712 if (tb->ty == Tdelegate) | |
713 { TypeDelegate *td = (TypeDelegate *)tb; | |
714 TypeFunction *tf = (TypeFunction *)td->nextOf(); | |
715 | |
716 if (!tf->varargs && | |
717 !(tf->arguments && tf->arguments->dim) | |
718 ) | |
719 { | |
720 return Expression::castTo(sc, t); | |
721 } | |
722 } | |
723 #endif | |
724 } | |
725 else | |
726 { | |
727 return e->Expression::castTo(sc, t); | |
728 } | |
729 } | |
730 e->type = t; | |
731 return e; | |
732 } | |
733 | |
734 Expression *StringExp::castTo(Scope *sc, Type *t) | |
735 { | |
736 /* This follows copy-on-write; any changes to 'this' | |
737 * will result in a copy. | |
738 * The this->string member is considered immutable. | |
739 */ | |
740 StringExp *se; | |
741 Type *tb; | |
742 int copied = 0; | |
743 | |
744 //printf("StringExp::castTo(t = %s), '%s' committed = %d\n", t->toChars(), toChars(), committed); | |
745 | |
746 if (!committed && t->ty == Tpointer && t->nextOf()->ty == Tvoid) | |
747 { | |
748 error("cannot convert string literal to void*"); | |
749 } | |
750 | |
751 se = this; | |
752 if (!committed) | |
753 { se = (StringExp *)copy(); | |
754 se->committed = 1; | |
755 copied = 1; | |
756 } | |
757 | |
758 if (type == t) | |
759 { | |
760 return se; | |
761 } | |
762 | |
763 tb = t->toBasetype(); | |
764 //printf("\ttype = %s\n", type->toChars()); | |
765 if (tb->ty == Tdelegate && type->toBasetype()->ty != Tdelegate) | |
766 return Expression::castTo(sc, t); | |
767 | |
768 Type *typeb = type->toBasetype(); | |
769 if (typeb == tb) | |
770 { | |
771 if (!copied) | |
772 { se = (StringExp *)copy(); | |
773 copied = 1; | |
774 } | |
775 se->type = t; | |
776 return se; | |
777 } | |
778 | |
779 if (tb->ty != Tsarray && tb->ty != Tarray && tb->ty != Tpointer) | |
780 { if (!copied) | |
781 { se = (StringExp *)copy(); | |
782 copied = 1; | |
783 } | |
784 goto Lcast; | |
785 } | |
786 if (typeb->ty != Tsarray && typeb->ty != Tarray && typeb->ty != Tpointer) | |
787 { if (!copied) | |
788 { se = (StringExp *)copy(); | |
789 copied = 1; | |
790 } | |
791 goto Lcast; | |
792 } | |
793 | |
794 if (typeb->nextOf()->size() == tb->nextOf()->size()) | |
795 { | |
796 if (!copied) | |
797 { se = (StringExp *)copy(); | |
798 copied = 1; | |
799 } | |
800 if (tb->ty == Tsarray) | |
801 goto L2; // handle possible change in static array dimension | |
802 se->type = t; | |
803 return se; | |
804 } | |
805 | |
806 if (committed) | |
807 goto Lcast; | |
808 | |
809 #define X(tf,tt) ((tf) * 256 + (tt)) | |
810 { | |
811 OutBuffer buffer; | |
812 size_t newlen = 0; | |
813 int tfty = typeb->nextOf()->toBasetype()->ty; | |
814 int ttty = tb->nextOf()->toBasetype()->ty; | |
815 switch (X(tfty, ttty)) | |
816 { | |
817 case X(Tchar, Tchar): | |
818 case X(Twchar,Twchar): | |
819 case X(Tdchar,Tdchar): | |
820 break; | |
821 | |
822 case X(Tchar, Twchar): | |
823 for (size_t u = 0; u < len;) | |
824 { unsigned c; | |
825 char *p = utf_decodeChar((unsigned char *)se->string, len, &u, &c); | |
826 if (p) | |
827 error("%s", p); | |
828 else | |
829 buffer.writeUTF16(c); | |
830 } | |
831 newlen = buffer.offset / 2; | |
832 buffer.writeUTF16(0); | |
833 goto L1; | |
834 | |
835 case X(Tchar, Tdchar): | |
836 for (size_t u = 0; u < len;) | |
837 { unsigned c; | |
838 char *p = utf_decodeChar((unsigned char *)se->string, len, &u, &c); | |
839 if (p) | |
840 error("%s", p); | |
841 buffer.write4(c); | |
842 newlen++; | |
843 } | |
844 buffer.write4(0); | |
845 goto L1; | |
846 | |
847 case X(Twchar,Tchar): | |
848 for (size_t u = 0; u < len;) | |
849 { unsigned c; | |
850 char *p = utf_decodeWchar((unsigned short *)se->string, len, &u, &c); | |
851 if (p) | |
852 error("%s", p); | |
853 else | |
854 buffer.writeUTF8(c); | |
855 } | |
856 newlen = buffer.offset; | |
857 buffer.writeUTF8(0); | |
858 goto L1; | |
859 | |
860 case X(Twchar,Tdchar): | |
861 for (size_t u = 0; u < len;) | |
862 { unsigned c; | |
863 char *p = utf_decodeWchar((unsigned short *)se->string, len, &u, &c); | |
864 if (p) | |
865 error("%s", p); | |
866 buffer.write4(c); | |
867 newlen++; | |
868 } | |
869 buffer.write4(0); | |
870 goto L1; | |
871 | |
872 case X(Tdchar,Tchar): | |
873 for (size_t u = 0; u < len; u++) | |
874 { | |
875 unsigned c = ((unsigned *)se->string)[u]; | |
876 if (!utf_isValidDchar(c)) | |
877 error("invalid UCS-32 char \\U%08x", c); | |
878 else | |
879 buffer.writeUTF8(c); | |
880 newlen++; | |
881 } | |
882 newlen = buffer.offset; | |
883 buffer.writeUTF8(0); | |
884 goto L1; | |
885 | |
886 case X(Tdchar,Twchar): | |
887 for (size_t u = 0; u < len; u++) | |
888 { | |
889 unsigned c = ((unsigned *)se->string)[u]; | |
890 if (!utf_isValidDchar(c)) | |
891 error("invalid UCS-32 char \\U%08x", c); | |
892 else | |
893 buffer.writeUTF16(c); | |
894 newlen++; | |
895 } | |
896 newlen = buffer.offset / 2; | |
897 buffer.writeUTF16(0); | |
898 goto L1; | |
899 | |
900 L1: | |
901 if (!copied) | |
902 { se = (StringExp *)copy(); | |
903 copied = 1; | |
904 } | |
905 se->string = buffer.extractData(); | |
906 se->len = newlen; | |
907 se->sz = tb->nextOf()->size(); | |
908 break; | |
909 | |
910 default: | |
911 assert(typeb->nextOf()->size() != tb->nextOf()->size()); | |
912 goto Lcast; | |
913 } | |
914 } | |
915 #undef X | |
916 L2: | |
917 assert(copied); | |
918 | |
919 // See if need to truncate or extend the literal | |
920 if (tb->ty == Tsarray) | |
921 { | |
922 int dim2 = ((TypeSArray *)tb)->dim->toInteger(); | |
923 | |
924 //printf("dim from = %d, to = %d\n", se->len, dim2); | |
925 | |
926 // Changing dimensions | |
927 if (dim2 != se->len) | |
928 { | |
929 // Copy when changing the string literal | |
930 unsigned newsz = se->sz; | |
931 void *s; | |
932 int d; | |
933 | |
934 d = (dim2 < se->len) ? dim2 : se->len; | |
935 s = (unsigned char *)mem.malloc((dim2 + 1) * newsz); | |
936 memcpy(s, se->string, d * newsz); | |
937 // Extend with 0, add terminating 0 | |
938 memset((char *)s + d * newsz, 0, (dim2 + 1 - d) * newsz); | |
939 se->string = s; | |
940 se->len = dim2; | |
941 } | |
942 } | |
943 se->type = t; | |
944 return se; | |
945 | |
946 Lcast: | |
947 Expression *e = new CastExp(loc, se, t); | |
948 e->type = t; // so semantic() won't be run on e | |
949 return e; | |
950 } | |
951 | |
952 Expression *AddrExp::castTo(Scope *sc, Type *t) | |
953 { | |
954 Type *tb; | |
955 | |
956 #if 0 | |
957 printf("AddrExp::castTo(this=%s, type=%s, t=%s)\n", | |
958 toChars(), type->toChars(), t->toChars()); | |
959 #endif | |
960 Expression *e = this; | |
961 | |
962 tb = t->toBasetype(); | |
963 type = type->toBasetype(); | |
964 if (tb != type) | |
965 { | |
966 // Look for pointers to functions where the functions are overloaded. | |
967 VarExp *ve; | |
968 FuncDeclaration *f; | |
969 | |
970 if (type->ty == Tpointer && type->next->ty == Tfunction && | |
971 tb->ty == Tpointer && tb->next->ty == Tfunction && | |
972 e1->op == TOKvar) | |
973 { | |
974 ve = (VarExp *)e1; | |
975 f = ve->var->isFuncDeclaration(); | |
976 if (f) | |
977 { | |
978 f = f->overloadExactMatch(tb->next); | |
979 if (f) | |
980 { | |
981 e = new VarExp(loc, f); | |
982 e->type = f->type; | |
983 e = new AddrExp(loc, e); | |
984 e->type = t; | |
985 return e; | |
986 } | |
987 } | |
988 } | |
989 e = Expression::castTo(sc, t); | |
990 } | |
991 e->type = t; | |
992 return e; | |
993 } | |
994 | |
995 | |
996 Expression *TupleExp::castTo(Scope *sc, Type *t) | |
997 { TupleExp *e = (TupleExp *)copy(); | |
998 e->exps = (Expressions *)exps->copy(); | |
999 for (size_t i = 0; i < e->exps->dim; i++) | |
1000 { Expression *ex = (Expression *)e->exps->data[i]; | |
1001 ex = ex->castTo(sc, t); | |
1002 e->exps->data[i] = (void *)ex; | |
1003 } | |
1004 return e; | |
1005 } | |
1006 | |
1007 | |
1008 Expression *ArrayLiteralExp::castTo(Scope *sc, Type *t) | |
1009 { | |
1010 #if 0 | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1011 printf("ArrayLiteralExp::castTo(this=%s, type=%s, => %s)\n", |
159 | 1012 toChars(), type->toChars(), t->toChars()); |
1013 #endif | |
1014 if (type == t) | |
1015 return this; | |
1016 ArrayLiteralExp *e = this; | |
1017 Type *typeb = type->toBasetype(); | |
1018 Type *tb = t->toBasetype(); | |
1019 if ((tb->ty == Tarray || tb->ty == Tsarray) && | |
1020 (typeb->ty == Tarray || typeb->ty == Tsarray) && | |
1021 // Not trying to convert non-void[] to void[] | |
1022 !(tb->nextOf()->toBasetype()->ty == Tvoid && typeb->nextOf()->toBasetype()->ty != Tvoid)) | |
1023 { | |
1024 if (tb->ty == Tsarray) | |
1025 { TypeSArray *tsa = (TypeSArray *)tb; | |
1026 if (elements->dim != tsa->dim->toInteger()) | |
1027 goto L1; | |
1028 } | |
1029 | |
1030 e = (ArrayLiteralExp *)copy(); | |
1031 e->elements = (Expressions *)elements->copy(); | |
1032 for (int i = 0; i < elements->dim; i++) | |
1033 { Expression *ex = (Expression *)elements->data[i]; | |
1034 ex = ex->castTo(sc, tb->nextOf()); | |
1035 e->elements->data[i] = (void *)ex; | |
1036 } | |
1037 e->type = t; | |
1038 return e; | |
1039 } | |
1040 if (tb->ty == Tpointer && typeb->ty == Tsarray) | |
1041 { | |
1042 e = (ArrayLiteralExp *)copy(); | |
1043 e->type = typeb->nextOf()->pointerTo(); | |
1044 } | |
1045 L1: | |
1046 return e->Expression::castTo(sc, t); | |
1047 } | |
1048 | |
1049 Expression *AssocArrayLiteralExp::castTo(Scope *sc, Type *t) | |
1050 { | |
1051 if (type == t) | |
1052 return this; | |
1053 AssocArrayLiteralExp *e = this; | |
1054 Type *typeb = type->toBasetype(); | |
1055 Type *tb = t->toBasetype(); | |
1056 if (tb->ty == Taarray && typeb->ty == Taarray && | |
1057 tb->nextOf()->toBasetype()->ty != Tvoid) | |
1058 { | |
1059 e = (AssocArrayLiteralExp *)copy(); | |
1060 e->keys = (Expressions *)keys->copy(); | |
1061 e->values = (Expressions *)values->copy(); | |
1062 assert(keys->dim == values->dim); | |
1063 for (size_t i = 0; i < keys->dim; i++) | |
1064 { Expression *ex = (Expression *)values->data[i]; | |
1065 ex = ex->castTo(sc, tb->nextOf()); | |
1066 e->values->data[i] = (void *)ex; | |
1067 | |
1068 ex = (Expression *)keys->data[i]; | |
1069 ex = ex->castTo(sc, ((TypeAArray *)tb)->index); | |
1070 e->keys->data[i] = (void *)ex; | |
1071 } | |
1072 e->type = t; | |
1073 return e; | |
1074 } | |
1075 L1: | |
1076 return e->Expression::castTo(sc, t); | |
1077 } | |
1078 | |
1079 Expression *SymOffExp::castTo(Scope *sc, Type *t) | |
1080 { | |
1081 Type *tb; | |
1082 | |
1083 #if 0 | |
1084 printf("SymOffExp::castTo(this=%s, type=%s, t=%s)\n", | |
1085 toChars(), type->toChars(), t->toChars()); | |
1086 #endif | |
1087 Expression *e = this; | |
1088 | |
1089 tb = t->toBasetype(); | |
1090 type = type->toBasetype(); | |
1091 if (tb != type) | |
1092 { | |
1093 // Look for pointers to functions where the functions are overloaded. | |
1094 FuncDeclaration *f; | |
1095 | |
1096 if (type->ty == Tpointer && type->next->ty == Tfunction && | |
1097 tb->ty == Tpointer && tb->next->ty == Tfunction) | |
1098 { | |
1099 f = var->isFuncDeclaration(); | |
1100 if (f) | |
1101 { | |
1102 f = f->overloadExactMatch(tb->next); | |
1103 if (f) | |
1104 { | |
1105 e = new SymOffExp(loc, f, 0); | |
1106 e->type = t; | |
1107 return e; | |
1108 } | |
1109 } | |
1110 } | |
1111 e = Expression::castTo(sc, t); | |
1112 } | |
1113 e->type = t; | |
1114 return e; | |
1115 } | |
1116 | |
1117 Expression *DelegateExp::castTo(Scope *sc, Type *t) | |
1118 { | |
1119 Type *tb; | |
1120 #if 0 | |
1121 printf("DelegateExp::castTo(this=%s, type=%s, t=%s)\n", | |
1122 toChars(), type->toChars(), t->toChars()); | |
1123 #endif | |
1124 Expression *e = this; | |
1125 static char msg[] = "cannot form delegate due to covariant return type"; | |
1126 | |
1127 tb = t->toBasetype(); | |
1128 type = type->toBasetype(); | |
1129 if (tb != type) | |
1130 { | |
1131 // Look for delegates to functions where the functions are overloaded. | |
1132 FuncDeclaration *f; | |
1133 | |
1134 if (type->ty == Tdelegate && type->next->ty == Tfunction && | |
1135 tb->ty == Tdelegate && tb->next->ty == Tfunction) | |
1136 { | |
1137 if (func) | |
1138 { | |
1139 f = func->overloadExactMatch(tb->next); | |
1140 if (f) | |
1141 { int offset; | |
1142 if (f->tintro && f->tintro->next->isBaseOf(f->type->next, &offset) && offset) | |
1143 error("%s", msg); | |
1144 e = new DelegateExp(loc, e1, f); | |
1145 e->type = t; | |
1146 return e; | |
1147 } | |
1148 if (func->tintro) | |
1149 error("%s", msg); | |
1150 } | |
1151 } | |
1152 e = Expression::castTo(sc, t); | |
1153 } | |
1154 else | |
1155 { int offset; | |
1156 | |
1157 if (func->tintro && func->tintro->next->isBaseOf(func->type->next, &offset) && offset) | |
1158 error("%s", msg); | |
1159 } | |
1160 e->type = t; | |
1161 return e; | |
1162 } | |
1163 | |
1164 Expression *CondExp::castTo(Scope *sc, Type *t) | |
1165 { | |
1166 Expression *e = this; | |
1167 | |
1168 if (type != t) | |
1169 { | |
1170 if (1 || e1->op == TOKstring || e2->op == TOKstring) | |
1171 { e = new CondExp(loc, econd, e1->castTo(sc, t), e2->castTo(sc, t)); | |
1172 e->type = t; | |
1173 } | |
1174 else | |
1175 e = Expression::castTo(sc, t); | |
1176 } | |
1177 return e; | |
1178 } | |
1179 | |
1180 /* ==================== ====================== */ | |
1181 | |
1182 /**************************************** | |
1183 * Scale addition/subtraction to/from pointer. | |
1184 */ | |
1185 | |
1186 Expression *BinExp::scaleFactor(Scope *sc) | |
1187 { d_uns64 stride; | |
1188 Type *t1b = e1->type->toBasetype(); | |
1189 Type *t2b = e2->type->toBasetype(); | |
1190 | |
1191 if (t1b->ty == Tpointer && t2b->isintegral()) | |
1192 { // Need to adjust operator by the stride | |
1193 // Replace (ptr + int) with (ptr + (int * stride)) | |
1194 Type *t = Type::tptrdiff_t; | |
1195 | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1196 stride = t1b->nextOf()->size(loc); |
159 | 1197 if (!t->equals(t2b)) |
1198 e2 = e2->castTo(sc, t); | |
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
510
diff
changeset
|
1199 // LDC: llvm uses typesafe pointer arithmetic |
159 | 1200 #if !IN_LLVM |
1201 if (t1b->next->isbit()) | |
1202 // BUG: should add runtime check for misaligned offsets | |
1203 // This perhaps should be done by rewriting as &p[i] | |
1204 // and letting back end do it. | |
1205 e2 = new UshrExp(loc, e2, new IntegerExp(0, 3, t)); | |
1206 else | |
1207 e2 = new MulExp(loc, e2, new IntegerExp(0, stride, t)); | |
1208 #endif | |
1209 e2->type = t; | |
1210 type = e1->type; | |
1211 } | |
1212 else if (t2b->ty == Tpointer && t1b->isintegral()) | |
1213 { // Need to adjust operator by the stride | |
1214 // Replace (int + ptr) with (ptr + (int * stride)) | |
1215 Type *t = Type::tptrdiff_t; | |
1216 Expression *e; | |
1217 | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1218 stride = t2b->nextOf()->size(loc); |
159 | 1219 if (!t->equals(t1b)) |
1220 e = e1->castTo(sc, t); | |
1221 else | |
1222 e = e1; | |
1223 #if !IN_LLVM | |
1224 if (t2b->next->isbit()) | |
1225 // BUG: should add runtime check for misaligned offsets | |
1226 e = new UshrExp(loc, e, new IntegerExp(0, 3, t)); | |
1227 else | |
1228 e = new MulExp(loc, e, new IntegerExp(0, stride, t)); | |
1229 #endif | |
1230 e->type = t; | |
1231 type = e2->type; | |
1232 e1 = e2; | |
1233 e2 = e; | |
1234 } | |
1235 return this; | |
1236 } | |
1237 | |
1238 /************************************ | |
1239 * Bring leaves to common type. | |
1240 */ | |
1241 | |
1242 Expression *BinExp::typeCombine(Scope *sc) | |
1243 { | |
1244 Type *t1; | |
1245 Type *t2; | |
1246 Type *t; | |
1247 TY ty; | |
1248 | |
1249 //printf("BinExp::typeCombine()\n"); | |
1250 //dump(0); | |
1251 | |
1252 e1 = e1->integralPromotions(sc); | |
1253 e2 = e2->integralPromotions(sc); | |
1254 | |
1255 // BUG: do toBasetype() | |
1256 t1 = e1->type; | |
1257 t2 = e2->type; | |
1258 assert(t1); | |
1259 | |
1260 //if (t1) printf("\tt1 = %s\n", t1->toChars()); | |
1261 //if (t2) printf("\tt2 = %s\n", t2->toChars()); | |
1262 #ifdef DEBUG | |
1263 if (!t2) printf("\te2 = '%s'\n", e2->toChars()); | |
1264 #endif | |
1265 assert(t2); | |
1266 | |
1267 Type *t1b = t1->toBasetype(); | |
1268 Type *t2b = t2->toBasetype(); | |
1269 | |
1270 ty = (TY)Type::impcnvResult[t1b->ty][t2b->ty]; | |
1271 if (ty != Terror) | |
1272 { TY ty1; | |
1273 TY ty2; | |
1274 | |
1275 ty1 = (TY)Type::impcnvType1[t1b->ty][t2b->ty]; | |
1276 ty2 = (TY)Type::impcnvType2[t1b->ty][t2b->ty]; | |
1277 | |
1278 if (t1b->ty == ty1) // if no promotions | |
1279 { | |
1280 if (t1 == t2) | |
1281 { | |
1282 if (!type) | |
1283 type = t1; | |
1284 return this; | |
1285 } | |
1286 | |
1287 if (t1b == t2b) | |
1288 { | |
1289 if (!type) | |
1290 type = t1b; | |
1291 return this; | |
1292 } | |
1293 } | |
1294 | |
1295 if (!type) | |
1296 type = Type::basic[ty]; | |
1297 | |
1298 t1 = Type::basic[ty1]; | |
1299 t2 = Type::basic[ty2]; | |
1300 e1 = e1->castTo(sc, t1); | |
1301 e2 = e2->castTo(sc, t2); | |
1302 #if 0 | |
1303 if (type != Type::basic[ty]) | |
1304 { t = type; | |
1305 type = Type::basic[ty]; | |
1306 return castTo(sc, t); | |
1307 } | |
1308 #endif | |
1309 //printf("after typeCombine():\n"); | |
1310 //dump(0); | |
1311 //printf("ty = %d, ty1 = %d, ty2 = %d\n", ty, ty1, ty2); | |
1312 return this; | |
1313 } | |
1314 | |
1315 t = t1; | |
1316 if (t1 == t2) | |
1317 { | |
1318 if ((t1->ty == Tstruct || t1->ty == Tclass) && | |
1319 (op == TOKmin || op == TOKadd)) | |
1320 goto Lincompatible; | |
1321 } | |
1322 else if (t1->isintegral() && t2->isintegral()) | |
1323 { | |
1324 printf("t1 = %s, t2 = %s\n", t1->toChars(), t2->toChars()); | |
1325 int sz1 = t1->size(); | |
1326 int sz2 = t2->size(); | |
1327 int sign1 = t1->isunsigned() == 0; | |
1328 int sign2 = t2->isunsigned() == 0; | |
1329 | |
1330 if (sign1 == sign2) | |
1331 { | |
1332 if (sz1 < sz2) | |
1333 goto Lt2; | |
1334 else | |
1335 goto Lt1; | |
1336 } | |
1337 if (!sign1) | |
1338 { | |
1339 if (sz1 >= sz2) | |
1340 goto Lt1; | |
1341 else | |
1342 goto Lt2; | |
1343 } | |
1344 else | |
1345 { | |
1346 if (sz2 >= sz1) | |
1347 goto Lt2; | |
1348 else | |
1349 goto Lt1; | |
1350 } | |
1351 } | |
1352 else if (t1->ty == Tpointer && t2->ty == Tpointer) | |
1353 { | |
1354 // Bring pointers to compatible type | |
1355 Type *t1n = t1->next; | |
1356 Type *t2n = t2->next; | |
1357 | |
1358 //t1->print(); | |
1359 //t2->print(); | |
1360 //if (t1n == t2n) *(char *)0 = 0; | |
1361 assert(t1n != t2n); | |
1362 if (t1n->ty == Tvoid) // pointers to void are always compatible | |
1363 t = t2; | |
1364 else if (t2n->ty == Tvoid) | |
1365 ; | |
1366 else if (t1n->ty == Tclass && t2n->ty == Tclass) | |
1367 { ClassDeclaration *cd1 = t1n->isClassHandle(); | |
1368 ClassDeclaration *cd2 = t2n->isClassHandle(); | |
1369 int offset; | |
1370 | |
1371 if (cd1->isBaseOf(cd2, &offset)) | |
1372 { | |
1373 if (offset) | |
1374 e2 = e2->castTo(sc, t); | |
1375 } | |
1376 else if (cd2->isBaseOf(cd1, &offset)) | |
1377 { | |
1378 t = t2; | |
1379 if (offset) | |
1380 e1 = e1->castTo(sc, t); | |
1381 } | |
1382 else | |
1383 goto Lincompatible; | |
1384 } | |
1385 else | |
1386 goto Lincompatible; | |
1387 } | |
1388 else if ((t1->ty == Tsarray || t1->ty == Tarray) && | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1389 e2->op == TOKnull && t2->ty == Tpointer && t2->nextOf()->ty == Tvoid) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1390 { /* (T[n] op void*) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1391 * (T[] op void*) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1392 */ |
159 | 1393 goto Lx1; |
1394 } | |
1395 else if ((t2->ty == Tsarray || t2->ty == Tarray) && | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1396 e1->op == TOKnull && t1->ty == Tpointer && t1->nextOf()->ty == Tvoid) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1397 { /* (void* op T[n]) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1398 * (void* op T[]) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1399 */ |
159 | 1400 goto Lx2; |
1401 } | |
1402 else if ((t1->ty == Tsarray || t1->ty == Tarray) && t1->implicitConvTo(t2)) | |
1403 { | |
1404 goto Lt2; | |
1405 } | |
1406 else if ((t2->ty == Tsarray || t2->ty == Tarray) && t2->implicitConvTo(t1)) | |
1407 { | |
1408 goto Lt1; | |
1409 } | |
1410 else if (t1->ty == Tclass || t2->ty == Tclass) | |
336 | 1411 { |
1412 while (1) | |
159 | 1413 { |
336 | 1414 int i1 = e2->implicitConvTo(t1); |
1415 int i2 = e1->implicitConvTo(t2); | |
1416 | |
1417 if (i1 && i2) | |
1418 { | |
1419 // We have the case of class vs. void*, so pick class | |
1420 if (t1->ty == Tpointer) | |
1421 i1 = 0; | |
1422 else if (t2->ty == Tpointer) | |
1423 i2 = 0; | |
1424 } | |
159 | 1425 |
336 | 1426 if (i2) |
1427 { | |
1428 goto Lt2; | |
1429 } | |
1430 else if (i1) | |
1431 { | |
1432 goto Lt1; | |
1433 } | |
1434 else if (t1->ty == Tclass && t2->ty == Tclass) | |
1435 { TypeClass *tc1 = (TypeClass *)t1; | |
1436 TypeClass *tc2 = (TypeClass *)t2; | |
1437 | |
1438 /* Pick 'tightest' type | |
1439 */ | |
1440 ClassDeclaration *cd1 = tc1->sym->baseClass; | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1441 ClassDeclaration *cd2 = tc2->sym->baseClass; |
336 | 1442 |
1443 if (cd1 && cd2) | |
1444 { t1 = cd1->type; | |
1445 t2 = cd2->type; | |
1446 } | |
1447 else if (cd1) | |
1448 t1 = cd1->type; | |
1449 else if (cd2) | |
1450 t2 = cd2->type; | |
1451 else | |
1452 goto Lincompatible; | |
1453 } | |
1454 else | |
1455 goto Lincompatible; | |
159 | 1456 } |
1457 } | |
1458 else if ((e1->op == TOKstring || e1->op == TOKnull) && e1->implicitConvTo(t2)) | |
1459 { | |
1460 goto Lt2; | |
1461 } | |
1462 //else if (e2->op == TOKstring) { printf("test2\n"); } | |
1463 else if ((e2->op == TOKstring || e2->op == TOKnull) && e2->implicitConvTo(t1)) | |
1464 { | |
1465 goto Lt1; | |
1466 } | |
1467 else if (t1->ty == Tsarray && t2->ty == Tsarray && | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1468 e2->implicitConvTo(t1->nextOf()->arrayOf())) |
159 | 1469 { |
1470 Lx1: | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1471 t = t1->nextOf()->arrayOf(); |
159 | 1472 e1 = e1->castTo(sc, t); |
1473 e2 = e2->castTo(sc, t); | |
1474 } | |
1475 else if (t1->ty == Tsarray && t2->ty == Tsarray && | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1476 e1->implicitConvTo(t2->nextOf()->arrayOf())) |
159 | 1477 { |
1478 Lx2: | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1479 t = t2->nextOf()->arrayOf(); |
159 | 1480 e1 = e1->castTo(sc, t); |
1481 e2 = e2->castTo(sc, t); | |
1482 } | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1483 else if (t1->isintegral() && t2->isintegral()) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1484 { |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1485 assert(0); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1486 } |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1487 else if (e1->op == TOKslice && t1->ty == Tarray && |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1488 e2->implicitConvTo(t1->nextOf())) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1489 { // T[] op T |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1490 e2 = e2->castTo(sc, t1->nextOf()); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1491 t = t1->nextOf()->arrayOf(); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1492 } |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1493 else if (e2->op == TOKslice && t2->ty == Tarray && |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1494 e1->implicitConvTo(t2->nextOf())) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1495 { // T op T[] |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1496 e1 = e1->castTo(sc, t2->nextOf()); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1497 t = t2->nextOf()->arrayOf(); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1498 |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1499 //printf("test %s\n", e->toChars()); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1500 e1 = e1->optimize(WANTvalue); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1501 if (isCommutative() && e1->isConst()) |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1502 { /* Swap operands to minimize number of functions generated |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1503 */ |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1504 //printf("swap %s\n", e->toChars()); |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1505 Expression *tmp = e1; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1506 e1 = e2; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1507 e2 = tmp; |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1508 } |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1509 } |
159 | 1510 else |
1511 { | |
1512 Lincompatible: | |
1513 incompatibleTypes(); | |
1514 } | |
1515 Lret: | |
1516 if (!type) | |
1517 type = t; | |
1518 //dump(0); | |
1519 return this; | |
1520 | |
1521 | |
1522 Lt1: | |
1523 e2 = e2->castTo(sc, t1); | |
1524 t = t1; | |
1525 goto Lret; | |
1526 | |
1527 Lt2: | |
1528 e1 = e1->castTo(sc, t2); | |
1529 t = t2; | |
1530 goto Lret; | |
1531 } | |
1532 | |
1533 /*********************************** | |
1534 * Do integral promotions (convertchk). | |
1535 * Don't convert <array of> to <pointer to> | |
1536 */ | |
1537 | |
1538 Expression *Expression::integralPromotions(Scope *sc) | |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1539 { |
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1540 Expression *e = this; |
159 | 1541 |
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
336
diff
changeset
|
1542 //printf("integralPromotions %s %s\n", e->toChars(), e->type->toChars()); |
159 | 1543 switch (type->toBasetype()->ty) |
1544 { | |
1545 case Tvoid: | |
1546 error("void has no value"); | |
1547 break; | |
1548 | |
1549 case Tint8: | |
1550 case Tuns8: | |
1551 case Tint16: | |
1552 case Tuns16: | |
1553 case Tbit: | |
1554 case Tbool: | |
1555 case Tchar: | |
1556 case Twchar: | |
1557 e = e->castTo(sc, Type::tint32); | |
1558 break; | |
1559 | |
1560 case Tdchar: | |
1561 e = e->castTo(sc, Type::tuns32); | |
1562 break; | |
1563 } | |
1564 return e; | |
1565 } | |
1566 |