Mercurial > projects > ldc
annotate dmd/expression.c @ 1404:11b122f92136
Now that templates instantiations are no longer emitted for all modules that
even blink at them they seem to break due to being linkonce (if compiled with
any optimization level > 0), so let's give them weak linkage instead.
The difference is that unreferenced linkonce symbols can be deleted, while
weak symbols need to be preserved.
| author | Frits van Bommel <fvbommel wxs.nl> |
|---|---|
| date | Thu, 21 May 2009 15:23:28 +0200 |
| parents | 229e02867307 |
| children | df11cdec45a2 |
| rev | line source |
|---|---|
| 159 | 1 |
| 2 // Compiler implementation of the D programming language | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
3 // Copyright (c) 1999-2009 by Digital Mars |
| 159 | 4 // All Rights Reserved |
| 5 // written by Walter Bright | |
| 6 // http://www.digitalmars.com | |
| 7 // License for redistribution is by either the Artistic License | |
| 8 // in artistic.txt, or the GNU General Public License in gnu.txt. | |
| 9 // See the included readme.txt for details. | |
| 10 | |
| 11 #include <stdio.h> | |
| 12 #include <stdlib.h> | |
| 13 #include <ctype.h> | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
14 #include <math.h> |
| 159 | 15 #include <assert.h> |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
16 #if _MSC_VER |
| 159 | 17 #include <complex> |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
18 #else |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
19 #endif |
| 159 | 20 |
| 21 #if _WIN32 && __DMC__ | |
| 22 extern "C" char * __cdecl __locale_decpoint; | |
| 23 #endif | |
| 24 | |
|
285
297690b5d4a5
[svn r306] Fixed: it's now possible to compile and link llvmdc with MinGW32 and msys on Win32 :D I tried it myself ;) Building the runtime still needs some work, but it's a step in the right direction.
lindquist
parents:
163
diff
changeset
|
25 #if __MINGW32__ |
|
297690b5d4a5
[svn r306] Fixed: it's now possible to compile and link llvmdc with MinGW32 and msys on Win32 :D I tried it myself ;) Building the runtime still needs some work, but it's a step in the right direction.
lindquist
parents:
163
diff
changeset
|
26 #ifndef isnan |
|
297690b5d4a5
[svn r306] Fixed: it's now possible to compile and link llvmdc with MinGW32 and msys on Win32 :D I tried it myself ;) Building the runtime still needs some work, but it's a step in the right direction.
lindquist
parents:
163
diff
changeset
|
27 #define isnan _isnan |
|
297690b5d4a5
[svn r306] Fixed: it's now possible to compile and link llvmdc with MinGW32 and msys on Win32 :D I tried it myself ;) Building the runtime still needs some work, but it's a step in the right direction.
lindquist
parents:
163
diff
changeset
|
28 #endif |
|
297690b5d4a5
[svn r306] Fixed: it's now possible to compile and link llvmdc with MinGW32 and msys on Win32 :D I tried it myself ;) Building the runtime still needs some work, but it's a step in the right direction.
lindquist
parents:
163
diff
changeset
|
29 #endif |
|
297690b5d4a5
[svn r306] Fixed: it's now possible to compile and link llvmdc with MinGW32 and msys on Win32 :D I tried it myself ;) Building the runtime still needs some work, but it's a step in the right direction.
lindquist
parents:
163
diff
changeset
|
30 |
|
536
0d2db7efa105
Add isnan for __APPLE__ and darwin version ident for OSX.
Christian Kamm <kamm incasoftware de>
parents:
535
diff
changeset
|
31 #ifdef __APPLE__ |
|
0d2db7efa105
Add isnan for __APPLE__ and darwin version ident for OSX.
Christian Kamm <kamm incasoftware de>
parents:
535
diff
changeset
|
32 #ifndef isnan |
|
0d2db7efa105
Add isnan for __APPLE__ and darwin version ident for OSX.
Christian Kamm <kamm incasoftware de>
parents:
535
diff
changeset
|
33 int isnan(double); |
|
0d2db7efa105
Add isnan for __APPLE__ and darwin version ident for OSX.
Christian Kamm <kamm incasoftware de>
parents:
535
diff
changeset
|
34 #endif |
|
0d2db7efa105
Add isnan for __APPLE__ and darwin version ident for OSX.
Christian Kamm <kamm incasoftware de>
parents:
535
diff
changeset
|
35 #endif |
|
0d2db7efa105
Add isnan for __APPLE__ and darwin version ident for OSX.
Christian Kamm <kamm incasoftware de>
parents:
535
diff
changeset
|
36 |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
37 #include "rmem.h" |
| 159 | 38 |
| 39 //#include "port.h" | |
| 40 #include "mtype.h" | |
| 41 #include "init.h" | |
| 42 #include "expression.h" | |
| 43 #include "template.h" | |
| 44 #include "utf.h" | |
| 45 #include "enum.h" | |
| 46 #include "scope.h" | |
| 47 #include "statement.h" | |
| 48 #include "declaration.h" | |
| 49 #include "aggregate.h" | |
| 50 #include "import.h" | |
| 51 #include "id.h" | |
| 52 #include "dsymbol.h" | |
| 53 #include "module.h" | |
| 54 #include "attrib.h" | |
| 55 #include "hdrgen.h" | |
| 56 #include "parse.h" | |
| 57 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
58 Expression *expandVar(int result, VarDeclaration *v); |
| 159 | 59 |
| 60 #define LOGSEMANTIC 0 | |
| 61 | |
| 62 /********************************** | |
| 63 * Set operator precedence for each operator. | |
| 64 */ | |
| 65 | |
| 66 // Operator precedence - greater values are higher precedence | |
| 67 | |
| 68 enum PREC | |
| 69 { | |
| 70 PREC_zero, | |
| 71 PREC_expr, | |
| 72 PREC_assign, | |
| 73 PREC_cond, | |
| 74 PREC_oror, | |
| 75 PREC_andand, | |
| 76 PREC_or, | |
| 77 PREC_xor, | |
| 78 PREC_and, | |
| 79 PREC_equal, | |
| 80 PREC_rel, | |
| 81 PREC_shift, | |
| 82 PREC_add, | |
| 83 PREC_mul, | |
| 84 PREC_unary, | |
| 85 PREC_primary, | |
| 86 }; | |
| 87 | |
| 88 enum PREC precedence[TOKMAX]; | |
| 89 | |
| 90 void initPrecedence() | |
| 91 { | |
| 92 precedence[TOKdotvar] = PREC_primary; | |
| 93 precedence[TOKimport] = PREC_primary; | |
| 94 precedence[TOKidentifier] = PREC_primary; | |
| 95 precedence[TOKthis] = PREC_primary; | |
| 96 precedence[TOKsuper] = PREC_primary; | |
| 97 precedence[TOKint64] = PREC_primary; | |
| 98 precedence[TOKfloat64] = PREC_primary; | |
| 99 precedence[TOKnull] = PREC_primary; | |
| 100 precedence[TOKstring] = PREC_primary; | |
| 101 precedence[TOKarrayliteral] = PREC_primary; | |
| 102 precedence[TOKtypeid] = PREC_primary; | |
| 103 precedence[TOKis] = PREC_primary; | |
| 104 precedence[TOKassert] = PREC_primary; | |
| 105 precedence[TOKfunction] = PREC_primary; | |
| 106 precedence[TOKvar] = PREC_primary; | |
| 336 | 107 #if DMDV2 |
| 108 precedence[TOKdefault] = PREC_primary; | |
| 109 #endif | |
| 159 | 110 |
| 111 // post | |
| 112 precedence[TOKdotti] = PREC_primary; | |
| 113 precedence[TOKdot] = PREC_primary; | |
| 114 // precedence[TOKarrow] = PREC_primary; | |
| 115 precedence[TOKplusplus] = PREC_primary; | |
| 116 precedence[TOKminusminus] = PREC_primary; | |
| 117 precedence[TOKcall] = PREC_primary; | |
| 118 precedence[TOKslice] = PREC_primary; | |
| 119 precedence[TOKarray] = PREC_primary; | |
| 120 | |
| 121 precedence[TOKaddress] = PREC_unary; | |
| 122 precedence[TOKstar] = PREC_unary; | |
| 123 precedence[TOKneg] = PREC_unary; | |
| 124 precedence[TOKuadd] = PREC_unary; | |
| 125 precedence[TOKnot] = PREC_unary; | |
| 126 precedence[TOKtobool] = PREC_add; | |
| 127 precedence[TOKtilde] = PREC_unary; | |
| 128 precedence[TOKdelete] = PREC_unary; | |
| 129 precedence[TOKnew] = PREC_unary; | |
| 130 precedence[TOKcast] = PREC_unary; | |
| 131 | |
| 132 precedence[TOKmul] = PREC_mul; | |
| 133 precedence[TOKdiv] = PREC_mul; | |
| 134 precedence[TOKmod] = PREC_mul; | |
| 135 | |
| 136 precedence[TOKadd] = PREC_add; | |
| 137 precedence[TOKmin] = PREC_add; | |
| 138 precedence[TOKcat] = PREC_add; | |
| 139 | |
| 140 precedence[TOKshl] = PREC_shift; | |
| 141 precedence[TOKshr] = PREC_shift; | |
| 142 precedence[TOKushr] = PREC_shift; | |
| 143 | |
| 144 precedence[TOKlt] = PREC_rel; | |
| 145 precedence[TOKle] = PREC_rel; | |
| 146 precedence[TOKgt] = PREC_rel; | |
| 147 precedence[TOKge] = PREC_rel; | |
| 148 precedence[TOKunord] = PREC_rel; | |
| 149 precedence[TOKlg] = PREC_rel; | |
| 150 precedence[TOKleg] = PREC_rel; | |
| 151 precedence[TOKule] = PREC_rel; | |
| 152 precedence[TOKul] = PREC_rel; | |
| 153 precedence[TOKuge] = PREC_rel; | |
| 154 precedence[TOKug] = PREC_rel; | |
| 155 precedence[TOKue] = PREC_rel; | |
| 156 precedence[TOKin] = PREC_rel; | |
| 157 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
158 #if 0 |
| 159 | 159 precedence[TOKequal] = PREC_equal; |
| 160 precedence[TOKnotequal] = PREC_equal; | |
| 161 precedence[TOKidentity] = PREC_equal; | |
| 162 precedence[TOKnotidentity] = PREC_equal; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
163 #else |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
164 /* Note that we changed precedence, so that < and != have the same |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
165 * precedence. This change is in the parser, too. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
166 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
167 precedence[TOKequal] = PREC_rel; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
168 precedence[TOKnotequal] = PREC_rel; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
169 precedence[TOKidentity] = PREC_rel; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
170 precedence[TOKnotidentity] = PREC_rel; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
171 #endif |
| 159 | 172 |
| 173 precedence[TOKand] = PREC_and; | |
| 174 | |
| 175 precedence[TOKxor] = PREC_xor; | |
| 176 | |
| 177 precedence[TOKor] = PREC_or; | |
| 178 | |
| 179 precedence[TOKandand] = PREC_andand; | |
| 180 | |
| 181 precedence[TOKoror] = PREC_oror; | |
| 182 | |
| 183 precedence[TOKquestion] = PREC_cond; | |
| 184 | |
| 185 precedence[TOKassign] = PREC_assign; | |
| 186 precedence[TOKconstruct] = PREC_assign; | |
| 187 precedence[TOKblit] = PREC_assign; | |
| 188 precedence[TOKaddass] = PREC_assign; | |
| 189 precedence[TOKminass] = PREC_assign; | |
| 190 precedence[TOKcatass] = PREC_assign; | |
| 191 precedence[TOKmulass] = PREC_assign; | |
| 192 precedence[TOKdivass] = PREC_assign; | |
| 193 precedence[TOKmodass] = PREC_assign; | |
| 194 precedence[TOKshlass] = PREC_assign; | |
| 195 precedence[TOKshrass] = PREC_assign; | |
| 196 precedence[TOKushrass] = PREC_assign; | |
| 197 precedence[TOKandass] = PREC_assign; | |
| 198 precedence[TOKorass] = PREC_assign; | |
| 199 precedence[TOKxorass] = PREC_assign; | |
| 200 | |
| 201 precedence[TOKcomma] = PREC_expr; | |
| 202 } | |
| 203 | |
| 336 | 204 /************************************************************* |
| 205 * Given var, we need to get the | |
| 206 * right 'this' pointer if var is in an outer class, but our | |
| 207 * existing 'this' pointer is in an inner class. | |
| 208 * Input: | |
| 209 * e1 existing 'this' | |
| 210 * ad struct or class we need the correct 'this' for | |
| 211 * var the specific member of ad we're accessing | |
| 212 */ | |
| 213 | |
| 214 Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad, | |
| 215 Expression *e1, Declaration *var) | |
| 216 { | |
| 217 //printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1->toChars(), ad->toChars(), var->toChars()); | |
| 218 L1: | |
| 219 Type *t = e1->type->toBasetype(); | |
| 220 //printf("e1->type = %s, var->type = %s\n", e1->type->toChars(), var->type->toChars()); | |
| 221 | |
| 222 /* If e1 is not the 'this' pointer for ad | |
| 223 */ | |
| 224 if (ad && | |
| 225 !(t->ty == Tpointer && t->nextOf()->ty == Tstruct && | |
| 226 ((TypeStruct *)t->nextOf())->sym == ad) | |
| 227 && | |
| 228 !(t->ty == Tstruct && | |
| 229 ((TypeStruct *)t)->sym == ad) | |
| 230 ) | |
| 231 { | |
| 232 ClassDeclaration *cd = ad->isClassDeclaration(); | |
| 233 ClassDeclaration *tcd = t->isClassHandle(); | |
| 234 | |
| 235 /* e1 is the right this if ad is a base class of e1 | |
| 236 */ | |
| 237 if (!cd || !tcd || | |
| 238 !(tcd == cd || cd->isBaseOf(tcd, NULL)) | |
| 239 ) | |
| 240 { | |
| 241 /* Only classes can be inner classes with an 'outer' | |
| 242 * member pointing to the enclosing class instance | |
| 243 */ | |
| 244 if (tcd && tcd->isNested()) | |
| 245 { /* e1 is the 'this' pointer for an inner class: tcd. | |
| 246 * Rewrite it as the 'this' pointer for the outer class. | |
| 247 */ | |
| 248 | |
| 249 e1 = new DotVarExp(loc, e1, tcd->vthis); | |
| 250 e1->type = tcd->vthis->type; | |
| 251 // Do not call checkNestedRef() | |
| 252 //e1 = e1->semantic(sc); | |
| 253 | |
| 254 // Skip up over nested functions, and get the enclosing | |
| 255 // class type. | |
| 256 int n = 0; | |
| 257 Dsymbol *s; | |
| 258 for (s = tcd->toParent(); | |
| 259 s && s->isFuncDeclaration(); | |
| 260 s = s->toParent()) | |
| 261 { FuncDeclaration *f = s->isFuncDeclaration(); | |
| 262 if (f->vthis) | |
| 263 { | |
| 264 //printf("rewriting e1 to %s's this\n", f->toChars()); | |
| 265 n++; | |
|
486
a34078905d01
Added pragma(llvmdc, "string") for misc per-module compiler configuration, currently "string" can only be "verbose" which forces -vv for module it appears in.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
471
diff
changeset
|
266 |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
267 // LDC seems dmd misses it sometimes here :/ |
|
486
a34078905d01
Added pragma(llvmdc, "string") for misc per-module compiler configuration, currently "string" can only be "verbose" which forces -vv for module it appears in.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
471
diff
changeset
|
268 f->vthis->nestedref = 1; |
|
a34078905d01
Added pragma(llvmdc, "string") for misc per-module compiler configuration, currently "string" can only be "verbose" which forces -vv for module it appears in.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
471
diff
changeset
|
269 |
| 336 | 270 e1 = new VarExp(loc, f->vthis); |
| 271 } | |
| 272 } | |
| 273 if (s && s->isClassDeclaration()) | |
| 274 { e1->type = s->isClassDeclaration()->type; | |
| 275 if (n > 1) | |
| 276 e1 = e1->semantic(sc); | |
| 277 } | |
| 278 else | |
| 279 e1 = e1->semantic(sc); | |
| 280 goto L1; | |
| 281 } | |
| 282 /* Can't find a path from e1 to ad | |
| 283 */ | |
| 284 e1->error("this for %s needs to be type %s not type %s", | |
| 285 var->toChars(), ad->toChars(), t->toChars()); | |
| 286 } | |
| 287 } | |
| 288 return e1; | |
| 289 } | |
| 290 | |
| 159 | 291 /***************************************** |
| 292 * Determine if 'this' is available. | |
| 293 * If it is, return the FuncDeclaration that has it. | |
| 294 */ | |
| 295 | |
| 296 FuncDeclaration *hasThis(Scope *sc) | |
| 297 { FuncDeclaration *fd; | |
| 298 FuncDeclaration *fdthis; | |
| 299 | |
| 300 //printf("hasThis()\n"); | |
| 301 fdthis = sc->parent->isFuncDeclaration(); | |
| 302 //printf("fdthis = %p, '%s'\n", fdthis, fdthis ? fdthis->toChars() : ""); | |
| 303 | |
| 304 // Go upwards until we find the enclosing member function | |
| 305 fd = fdthis; | |
| 306 while (1) | |
| 307 { | |
| 308 if (!fd) | |
| 309 { | |
| 310 goto Lno; | |
| 311 } | |
| 312 if (!fd->isNested()) | |
| 313 break; | |
| 314 | |
| 315 Dsymbol *parent = fd->parent; | |
| 316 while (parent) | |
| 317 { | |
| 318 TemplateInstance *ti = parent->isTemplateInstance(); | |
| 319 if (ti) | |
| 320 parent = ti->parent; | |
| 321 else | |
| 322 break; | |
| 323 } | |
| 324 | |
| 325 fd = fd->parent->isFuncDeclaration(); | |
| 326 } | |
| 327 | |
| 328 if (!fd->isThis()) | |
| 329 { //printf("test '%s'\n", fd->toChars()); | |
| 330 goto Lno; | |
| 331 } | |
| 332 | |
| 333 assert(fd->vthis); | |
| 334 return fd; | |
| 335 | |
| 336 Lno: | |
| 337 return NULL; // don't have 'this' available | |
| 338 } | |
| 339 | |
| 340 | |
| 341 /*************************************** | |
| 342 * Pull out any properties. | |
| 343 */ | |
| 344 | |
| 345 Expression *resolveProperties(Scope *sc, Expression *e) | |
| 346 { | |
| 347 //printf("resolveProperties(%s)\n", e->toChars()); | |
| 348 if (e->type) | |
| 349 { | |
| 350 Type *t = e->type->toBasetype(); | |
| 351 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
352 if (t->ty == Tfunction /*|| e->op == TOKoverloadset*/) |
| 159 | 353 { |
| 354 e = new CallExp(e->loc, e); | |
| 355 e = e->semantic(sc); | |
| 356 } | |
| 357 | |
| 358 /* Look for e being a lazy parameter; rewrite as delegate call | |
| 359 */ | |
| 360 else if (e->op == TOKvar) | |
| 361 { VarExp *ve = (VarExp *)e; | |
| 362 | |
| 363 if (ve->var->storage_class & STClazy) | |
| 364 { | |
| 365 e = new CallExp(e->loc, e); | |
| 366 e = e->semantic(sc); | |
| 367 } | |
| 368 } | |
| 369 | |
| 370 else if (e->op == TOKdotexp) | |
| 371 { | |
| 372 e->error("expression has no value"); | |
| 373 } | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
374 |
| 159 | 375 } |
| 376 return e; | |
| 377 } | |
| 378 | |
| 379 /****************************** | |
| 380 * Perform semantic() on an array of Expressions. | |
| 381 */ | |
| 382 | |
| 383 void arrayExpressionSemantic(Expressions *exps, Scope *sc) | |
| 384 { | |
| 385 if (exps) | |
| 386 { | |
| 387 for (size_t i = 0; i < exps->dim; i++) | |
| 388 { Expression *e = (Expression *)exps->data[i]; | |
| 389 | |
| 390 e = e->semantic(sc); | |
| 391 exps->data[i] = (void *)e; | |
| 392 } | |
| 393 } | |
| 394 } | |
| 395 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
396 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
397 /****************************** |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
398 * Perform canThrow() on an array of Expressions. |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
399 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
400 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
401 #if DMDV2 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
402 int arrayExpressionCanThrow(Expressions *exps) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
403 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
404 if (exps) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
405 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
406 for (size_t i = 0; i < exps->dim; i++) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
407 { Expression *e = (Expression *)exps->data[i]; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
408 if (e && e->canThrow()) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
409 return 1; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
410 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
411 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
412 return 0; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
413 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
414 #endif |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
415 |
| 159 | 416 /**************************************** |
| 417 * Expand tuples. | |
| 418 */ | |
| 419 | |
| 420 void expandTuples(Expressions *exps) | |
| 421 { | |
| 422 //printf("expandTuples()\n"); | |
| 423 if (exps) | |
| 424 { | |
| 425 for (size_t i = 0; i < exps->dim; i++) | |
| 426 { Expression *arg = (Expression *)exps->data[i]; | |
| 427 if (!arg) | |
| 428 continue; | |
| 429 | |
| 430 // Look for tuple with 0 members | |
| 431 if (arg->op == TOKtype) | |
| 432 { TypeExp *e = (TypeExp *)arg; | |
| 433 if (e->type->toBasetype()->ty == Ttuple) | |
| 434 { TypeTuple *tt = (TypeTuple *)e->type->toBasetype(); | |
| 435 | |
| 436 if (!tt->arguments || tt->arguments->dim == 0) | |
| 437 { | |
| 438 exps->remove(i); | |
| 439 if (i == exps->dim) | |
| 440 return; | |
| 441 i--; | |
| 442 continue; | |
| 443 } | |
| 444 } | |
| 445 } | |
| 446 | |
| 447 // Inline expand all the tuples | |
| 448 while (arg->op == TOKtuple) | |
| 449 { TupleExp *te = (TupleExp *)arg; | |
| 450 | |
| 451 exps->remove(i); // remove arg | |
| 452 exps->insert(i, te->exps); // replace with tuple contents | |
| 453 if (i == exps->dim) | |
| 454 return; // empty tuple, no more arguments | |
| 455 arg = (Expression *)exps->data[i]; | |
| 456 } | |
| 457 } | |
| 458 } | |
| 459 } | |
| 460 | |
| 461 /**************************************** | |
| 462 * Preprocess arguments to function. | |
| 463 */ | |
| 464 | |
| 465 void preFunctionArguments(Loc loc, Scope *sc, Expressions *exps) | |
| 466 { | |
| 467 if (exps) | |
| 468 { | |
| 469 expandTuples(exps); | |
| 470 | |
| 471 for (size_t i = 0; i < exps->dim; i++) | |
| 472 { Expression *arg = (Expression *)exps->data[i]; | |
| 473 | |
| 474 if (!arg->type) | |
| 475 { | |
| 476 #ifdef DEBUG | |
| 477 if (!global.gag) | |
| 478 printf("1: \n"); | |
| 479 #endif | |
| 480 arg->error("%s is not an expression", arg->toChars()); | |
| 481 arg = new IntegerExp(arg->loc, 0, Type::tint32); | |
| 482 } | |
| 483 | |
| 484 arg = resolveProperties(sc, arg); | |
| 485 exps->data[i] = (void *) arg; | |
| 486 | |
| 487 //arg->rvalue(); | |
| 488 #if 0 | |
| 489 if (arg->type->ty == Tfunction) | |
| 490 { | |
| 491 arg = new AddrExp(arg->loc, arg); | |
| 492 arg = arg->semantic(sc); | |
| 493 exps->data[i] = (void *) arg; | |
| 494 } | |
| 495 #endif | |
| 496 } | |
| 497 } | |
| 498 } | |
| 499 | |
| 336 | 500 /********************************************* |
| 501 * Call copy constructor for struct value argument. | |
| 502 */ | |
| 503 #if DMDV2 | |
| 504 Expression *callCpCtor(Loc loc, Scope *sc, Expression *e) | |
| 505 { | |
| 506 Type *tb = e->type->toBasetype(); | |
| 507 assert(tb->ty == Tstruct); | |
| 508 StructDeclaration *sd = ((TypeStruct *)tb)->sym; | |
| 509 if (sd->cpctor) | |
| 510 { | |
| 511 /* Create a variable tmp, and replace the argument e with: | |
| 512 * (tmp = e),tmp | |
| 513 * and let AssignExp() handle the construction. | |
| 514 * This is not the most efficent, ideally tmp would be constructed | |
| 515 * directly onto the stack. | |
| 516 */ | |
| 517 Identifier *idtmp = Lexer::uniqueId("__tmp"); | |
| 518 VarDeclaration *tmp = new VarDeclaration(loc, tb, idtmp, new ExpInitializer(0, e)); | |
| 519 Expression *ae = new DeclarationExp(loc, tmp); | |
| 520 e = new CommaExp(loc, ae, new VarExp(loc, tmp)); | |
| 521 e = e->semantic(sc); | |
| 522 } | |
| 523 return e; | |
| 524 } | |
| 525 #endif | |
| 159 | 526 |
| 527 /**************************************** | |
| 528 * Now that we know the exact type of the function we're calling, | |
| 529 * the arguments[] need to be adjusted: | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
530 * 1. implicitly convert argument to the corresponding parameter type |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
531 * 2. add default arguments for any missing arguments |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
532 * 3. do default promotions on arguments corresponding to ... |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
533 * 4. add hidden _arguments[] argument |
| 159 | 534 */ |
| 535 | |
| 536 void functionArguments(Loc loc, Scope *sc, TypeFunction *tf, Expressions *arguments) | |
| 537 { | |
| 538 unsigned n; | |
| 539 | |
| 540 //printf("functionArguments()\n"); | |
| 541 assert(arguments); | |
| 542 size_t nargs = arguments ? arguments->dim : 0; | |
| 543 size_t nparams = Argument::dim(tf->parameters); | |
| 544 | |
| 545 if (nargs > nparams && tf->varargs == 0) | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
546 error(loc, "expected %zu arguments, not %zu", nparams, nargs); |
| 159 | 547 |
| 548 n = (nargs > nparams) ? nargs : nparams; // n = max(nargs, nparams) | |
| 549 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
550 int done = 0; |
| 159 | 551 for (size_t i = 0; i < n; i++) |
| 552 { | |
| 553 Expression *arg; | |
| 554 | |
| 555 if (i < nargs) | |
| 556 arg = (Expression *)arguments->data[i]; | |
| 557 else | |
| 558 arg = NULL; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
559 Type *tb; |
| 159 | 560 |
| 561 if (i < nparams) | |
| 562 { | |
| 563 Argument *p = Argument::getNth(tf->parameters, i); | |
| 564 | |
| 565 if (!arg) | |
| 566 { | |
| 567 if (!p->defaultArg) | |
| 568 { | |
| 569 if (tf->varargs == 2 && i + 1 == nparams) | |
| 570 goto L2; | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
571 error(loc, "expected %zu arguments, not %zu", nparams, nargs); |
| 159 | 572 break; |
| 573 } | |
| 336 | 574 arg = p->defaultArg; |
| 575 #if DMDV2 | |
| 576 if (arg->op == TOKdefault) | |
| 577 { DefaultInitExp *de = (DefaultInitExp *)arg; | |
| 578 arg = de->resolve(loc, sc); | |
| 579 } | |
| 580 else | |
| 581 #endif | |
| 582 arg = arg->copy(); | |
| 159 | 583 arguments->push(arg); |
| 584 nargs++; | |
| 585 } | |
| 586 | |
| 587 if (tf->varargs == 2 && i + 1 == nparams) | |
| 588 { | |
| 589 //printf("\t\tvarargs == 2, p->type = '%s'\n", p->type->toChars()); | |
| 590 if (arg->implicitConvTo(p->type)) | |
| 591 { | |
| 592 if (nargs != nparams) | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
593 error(loc, "expected %zu arguments, not %zu", nparams, nargs); |
| 159 | 594 goto L1; |
| 595 } | |
| 596 L2: | |
| 597 Type *tb = p->type->toBasetype(); | |
| 598 Type *tret = p->isLazyArray(); | |
| 599 switch (tb->ty) | |
| 600 { | |
| 601 case Tsarray: | |
| 602 case Tarray: | |
| 603 { // Create a static array variable v of type arg->type | |
| 604 #ifdef IN_GCC | |
| 605 /* GCC 4.0 does not like zero length arrays used like | |
| 606 this; pass a null array value instead. Could also | |
| 607 just make a one-element array. */ | |
| 608 if (nargs - i == 0) | |
| 609 { | |
| 610 arg = new NullExp(loc); | |
| 611 break; | |
| 612 } | |
| 613 #endif | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
614 Identifier *id = Lexer::uniqueId("__arrayArg"); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
615 Type *t = new TypeSArray(((TypeArray *)tb)->next, new IntegerExp(nargs - i)); |
| 159 | 616 t = t->semantic(loc, sc); |
| 617 VarDeclaration *v = new VarDeclaration(loc, t, id, new VoidInitializer(loc)); | |
| 618 v->semantic(sc); | |
| 619 v->parent = sc->parent; | |
| 620 //sc->insert(v); | |
| 621 | |
| 622 Expression *c = new DeclarationExp(0, v); | |
| 623 c->type = v->type; | |
| 624 | |
| 625 for (size_t u = i; u < nargs; u++) | |
| 626 { Expression *a = (Expression *)arguments->data[u]; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
627 if (tret && !((TypeArray *)tb)->next->equals(a->type)) |
| 159 | 628 a = a->toDelegate(sc, tret); |
| 629 | |
| 630 Expression *e = new VarExp(loc, v); | |
| 631 e = new IndexExp(loc, e, new IntegerExp(u + 1 - nparams)); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
632 AssignExp *ae = new AssignExp(loc, e, a); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
633 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
634 ae->op = TOKconstruct; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
635 #endif |
| 159 | 636 if (c) |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
637 c = new CommaExp(loc, c, ae); |
| 159 | 638 else |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
639 c = ae; |
| 159 | 640 } |
| 641 arg = new VarExp(loc, v); | |
| 642 if (c) | |
| 643 arg = new CommaExp(loc, c, arg); | |
| 644 break; | |
| 645 } | |
| 646 case Tclass: | |
| 647 { /* Set arg to be: | |
| 648 * new Tclass(arg0, arg1, ..., argn) | |
| 649 */ | |
| 650 Expressions *args = new Expressions(); | |
| 651 args->setDim(nargs - i); | |
| 652 for (size_t u = i; u < nargs; u++) | |
| 653 args->data[u - i] = arguments->data[u]; | |
| 654 arg = new NewExp(loc, NULL, NULL, p->type, args); | |
| 655 break; | |
| 656 } | |
| 657 default: | |
| 658 if (!arg) | |
| 659 { error(loc, "not enough arguments"); | |
| 660 return; | |
| 661 } | |
| 662 break; | |
| 663 } | |
| 664 arg = arg->semantic(sc); | |
| 665 //printf("\targ = '%s'\n", arg->toChars()); | |
| 666 arguments->setDim(i + 1); | |
| 667 done = 1; | |
| 668 } | |
| 669 | |
| 670 L1: | |
| 671 if (!(p->storageClass & STClazy && p->type->ty == Tvoid)) | |
| 672 arg = arg->implicitCastTo(sc, p->type); | |
| 673 if (p->storageClass & (STCout | STCref)) | |
| 674 { | |
| 675 // BUG: should check that argument to ref is type 'invariant' | |
| 676 // BUG: assignments to ref should also be type 'invariant' | |
| 677 arg = arg->modifiableLvalue(sc, arg); | |
| 678 | |
| 679 //if (arg->op == TOKslice) | |
| 680 //arg->error("cannot modify slice %s", arg->toChars()); | |
| 681 } | |
| 682 | |
|
723
55f6c2e454d7
Implemented correct parameter order according to x86-32 ABI documentation.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
683 // LDC we don't want this! |
|
55f6c2e454d7
Implemented correct parameter order according to x86-32 ABI documentation.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
684 #if !IN_LLVM |
| 159 | 685 // Convert static arrays to pointers |
| 686 tb = arg->type->toBasetype(); | |
| 687 if (tb->ty == Tsarray) | |
| 688 { | |
| 689 arg = arg->checkToPointer(); | |
| 690 } | |
|
723
55f6c2e454d7
Implemented correct parameter order according to x86-32 ABI documentation.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
691 #endif |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
692 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
693 if (tb->ty == Tstruct && !(p->storageClass & (STCref | STCout))) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
694 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
695 arg = callCpCtor(loc, sc, arg); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
696 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
697 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
698 |
| 159 | 699 // Convert lazy argument to a delegate |
| 700 if (p->storageClass & STClazy) | |
| 701 { | |
| 702 arg = arg->toDelegate(sc, p->type); | |
| 703 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
704 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
705 /* Look for arguments that cannot 'escape' from the called |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
706 * function. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
707 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
708 if (!tf->parameterEscapes(p)) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
709 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
710 /* Function literals can only appear once, so if this |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
711 * appearance was scoped, there cannot be any others. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
712 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
713 if (arg->op == TOKfunction) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
714 { FuncExp *fe = (FuncExp *)arg; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
715 fe->fd->tookAddressOf = 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
716 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
717 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
718 /* For passing a delegate to a scoped parameter, |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
719 * this doesn't count as taking the address of it. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
720 * We only worry about 'escaping' references to the function. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
721 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
722 else if (arg->op == TOKdelegate) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
723 { DelegateExp *de = (DelegateExp *)arg; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
724 if (de->e1->op == TOKvar) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
725 { VarExp *ve = (VarExp *)de->e1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
726 FuncDeclaration *f = ve->var->isFuncDeclaration(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
727 if (f) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
728 { f->tookAddressOf--; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
729 //printf("tookAddressOf = %d\n", f->tookAddressOf); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
730 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
731 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
732 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
733 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
734 #endif |
| 159 | 735 } |
| 736 else | |
| 737 { | |
| 738 | |
| 739 // If not D linkage, do promotions | |
|
723
55f6c2e454d7
Implemented correct parameter order according to x86-32 ABI documentation.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
740 // LDC: don't do promotions on intrinsics |
|
55f6c2e454d7
Implemented correct parameter order according to x86-32 ABI documentation.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
741 if (tf->linkage != LINKd && tf->linkage != LINKintrinsic) |
| 159 | 742 { |
| 743 // Promote bytes, words, etc., to ints | |
| 744 arg = arg->integralPromotions(sc); | |
| 745 | |
| 746 // Promote floats to doubles | |
| 747 switch (arg->type->ty) | |
| 748 { | |
| 749 case Tfloat32: | |
| 750 arg = arg->castTo(sc, Type::tfloat64); | |
| 751 break; | |
| 752 | |
| 753 case Timaginary32: | |
| 754 arg = arg->castTo(sc, Type::timaginary64); | |
| 755 break; | |
| 756 } | |
| 757 } | |
| 758 | |
| 759 // Convert static arrays to dynamic arrays | |
| 760 tb = arg->type->toBasetype(); | |
| 761 if (tb->ty == Tsarray) | |
| 762 { TypeSArray *ts = (TypeSArray *)tb; | |
| 336 | 763 Type *ta = ts->next->arrayOf(); |
| 159 | 764 if (ts->size(arg->loc) == 0) |
| 765 { arg = new NullExp(arg->loc); | |
| 766 arg->type = ta; | |
| 767 } | |
| 768 else | |
| 769 arg = arg->castTo(sc, ta); | |
| 770 } | |
| 336 | 771 #if DMDV2 |
| 772 if (tb->ty == Tstruct) | |
| 773 { | |
| 774 arg = callCpCtor(loc, sc, arg); | |
| 775 } | |
| 776 | |
| 777 // Give error for overloaded function addresses | |
| 778 if (arg->op == TOKsymoff) | |
| 779 { SymOffExp *se = (SymOffExp *)arg; | |
| 780 if (se->hasOverloads && !se->var->isFuncDeclaration()->isUnique()) | |
| 781 arg->error("function %s is overloaded", arg->toChars()); | |
| 782 } | |
| 783 #endif | |
| 159 | 784 arg->rvalue(); |
| 785 } | |
| 786 arg = arg->optimize(WANTvalue); | |
| 787 arguments->data[i] = (void *) arg; | |
| 788 if (done) | |
| 789 break; | |
| 790 } | |
| 791 | |
| 792 #if !IN_LLVM | |
| 793 // If D linkage and variadic, add _arguments[] as first argument | |
| 794 if (tf->linkage == LINKd && tf->varargs == 1) | |
| 795 { | |
| 796 Expression *e; | |
| 797 | |
| 798 e = createTypeInfoArray(sc, (Expression **)&arguments->data[nparams], | |
| 799 arguments->dim - nparams); | |
| 800 arguments->insert(0, e); | |
| 801 } | |
| 802 #endif | |
| 803 } | |
| 804 | |
| 805 /************************************************** | |
| 806 * Write expression out to buf, but wrap it | |
| 807 * in ( ) if its precedence is less than pr. | |
| 808 */ | |
| 809 | |
| 810 void expToCBuffer(OutBuffer *buf, HdrGenState *hgs, Expression *e, enum PREC pr) | |
| 811 { | |
| 336 | 812 //if (precedence[e->op] == 0) e->dump(0); |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
813 if (precedence[e->op] < pr || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
814 /* Despite precedence, we don't allow a<b<c expressions. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
815 * They must be parenthesized. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
816 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
817 (pr == PREC_rel && precedence[e->op] == pr)) |
| 159 | 818 { |
| 819 buf->writeByte('('); | |
| 820 e->toCBuffer(buf, hgs); | |
| 821 buf->writeByte(')'); | |
| 822 } | |
| 823 else | |
| 824 e->toCBuffer(buf, hgs); | |
| 825 } | |
| 826 | |
| 827 /************************************************** | |
| 828 * Write out argument list to buf. | |
| 829 */ | |
| 830 | |
| 831 void argsToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs) | |
| 832 { | |
| 833 if (arguments) | |
| 834 { | |
| 835 for (size_t i = 0; i < arguments->dim; i++) | |
| 836 { Expression *arg = (Expression *)arguments->data[i]; | |
| 837 | |
| 838 if (arg) | |
| 839 { if (i) | |
| 840 buf->writeByte(','); | |
| 841 expToCBuffer(buf, hgs, arg, PREC_assign); | |
| 842 } | |
| 843 } | |
| 844 } | |
| 845 } | |
| 846 | |
| 847 /************************************************** | |
| 848 * Write out argument types to buf. | |
| 849 */ | |
| 850 | |
| 851 void argExpTypesToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs) | |
| 852 { | |
| 853 if (arguments) | |
| 854 { OutBuffer argbuf; | |
| 855 | |
| 856 for (size_t i = 0; i < arguments->dim; i++) | |
| 857 { Expression *arg = (Expression *)arguments->data[i]; | |
| 858 | |
| 859 if (i) | |
| 860 buf->writeByte(','); | |
| 861 argbuf.reset(); | |
| 862 arg->type->toCBuffer2(&argbuf, hgs, 0); | |
| 863 buf->write(&argbuf); | |
| 864 } | |
| 865 } | |
| 866 } | |
| 867 | |
| 868 /******************************** Expression **************************/ | |
| 869 | |
| 870 Expression::Expression(Loc loc, enum TOK op, int size) | |
| 871 : loc(loc) | |
| 872 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
873 //printf("Expression::Expression(op = %d) this = %p\n", op, this); |
| 159 | 874 this->loc = loc; |
| 875 this->op = op; | |
| 876 this->size = size; | |
| 877 type = NULL; | |
|
1151
3cf0066e6faf
- Versioned Expresssion::toElem with #if IN_DMD/IN_LLVM.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1146
diff
changeset
|
878 |
|
3cf0066e6faf
- Versioned Expresssion::toElem with #if IN_DMD/IN_LLVM.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1146
diff
changeset
|
879 #if IN_LLVM |
|
3cf0066e6faf
- Versioned Expresssion::toElem with #if IN_DMD/IN_LLVM.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1146
diff
changeset
|
880 cachedLvalue = NULL; |
|
3cf0066e6faf
- Versioned Expresssion::toElem with #if IN_DMD/IN_LLVM.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1146
diff
changeset
|
881 #endif |
| 159 | 882 } |
| 883 | |
| 884 Expression *Expression::syntaxCopy() | |
| 885 { | |
| 886 //printf("Expression::syntaxCopy()\n"); | |
| 887 //dump(0); | |
| 888 return copy(); | |
| 889 } | |
| 890 | |
| 891 /********************************* | |
| 892 * Does *not* do a deep copy. | |
| 893 */ | |
| 894 | |
| 895 Expression *Expression::copy() | |
| 896 { | |
| 897 Expression *e; | |
| 898 if (!size) | |
| 899 { | |
| 900 #ifdef DEBUG | |
| 901 fprintf(stdmsg, "No expression copy for: %s\n", toChars()); | |
| 902 printf("op = %d\n", op); | |
| 903 dump(0); | |
| 904 #endif | |
| 905 assert(0); | |
| 906 } | |
| 907 e = (Expression *)mem.malloc(size); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
908 //printf("Expression::copy(op = %d) e = %p\n", op, e); |
| 159 | 909 return (Expression *)memcpy(e, this, size); |
| 910 } | |
| 911 | |
| 912 /************************** | |
| 913 * Semantically analyze Expression. | |
| 914 * Determine types, fold constants, etc. | |
| 915 */ | |
| 916 | |
| 917 Expression *Expression::semantic(Scope *sc) | |
| 918 { | |
| 919 #if LOGSEMANTIC | |
| 336 | 920 printf("Expression::semantic() %s\n", toChars()); |
| 159 | 921 #endif |
| 922 if (type) | |
| 923 type = type->semantic(loc, sc); | |
| 924 else | |
| 925 type = Type::tvoid; | |
| 926 return this; | |
| 927 } | |
| 928 | |
| 929 void Expression::print() | |
| 930 { | |
| 931 fprintf(stdmsg, "%s\n", toChars()); | |
| 932 fflush(stdmsg); | |
| 933 } | |
| 934 | |
| 935 char *Expression::toChars() | |
| 936 { OutBuffer *buf; | |
| 937 HdrGenState hgs; | |
| 938 | |
| 939 memset(&hgs, 0, sizeof(hgs)); | |
| 940 buf = new OutBuffer(); | |
| 941 toCBuffer(buf, &hgs); | |
| 942 return buf->toChars(); | |
| 943 } | |
| 944 | |
| 945 void Expression::error(const char *format, ...) | |
| 946 { | |
| 947 va_list ap; | |
| 948 va_start(ap, format); | |
| 949 ::verror(loc, format, ap); | |
| 950 va_end( ap ); | |
| 951 } | |
| 952 | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
953 void Expression::warning(const char *format, ...) |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
954 { |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
955 if (global.params.warnings && !global.gag) |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
956 { |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
957 va_list ap; |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
958 va_start(ap, format); |
|
1124
e7f0c2b48047
Fix a bug where ::warning() was called with a va_list argument instead of an
Frits van Bommel <fvbommel wxs.nl>
parents:
1120
diff
changeset
|
959 ::vwarning(loc, format, ap); |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
960 va_end( ap ); |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
961 } |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
962 } |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
963 |
| 159 | 964 void Expression::rvalue() |
| 965 { | |
| 966 if (type && type->toBasetype()->ty == Tvoid) | |
| 967 { error("expression %s is void and has no value", toChars()); | |
| 968 #if 0 | |
| 969 dump(0); | |
| 970 halt(); | |
| 971 #endif | |
| 336 | 972 type = Type::tint32; |
| 159 | 973 } |
| 974 } | |
| 975 | |
| 976 Expression *Expression::combine(Expression *e1, Expression *e2) | |
| 977 { | |
| 978 if (e1) | |
| 979 { | |
| 980 if (e2) | |
| 981 { | |
| 982 e1 = new CommaExp(e1->loc, e1, e2); | |
| 983 e1->type = e2->type; | |
| 984 } | |
| 985 } | |
| 986 else | |
| 987 e1 = e2; | |
| 988 return e1; | |
| 989 } | |
| 990 | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
991 dinteger_t Expression::toInteger() |
| 159 | 992 { |
| 993 //printf("Expression %s\n", Token::toChars(op)); | |
| 994 error("Integer constant expression expected instead of %s", toChars()); | |
| 995 return 0; | |
| 996 } | |
| 997 | |
| 998 uinteger_t Expression::toUInteger() | |
| 999 { | |
| 1000 //printf("Expression %s\n", Token::toChars(op)); | |
| 1001 return (uinteger_t)toInteger(); | |
| 1002 } | |
| 1003 | |
| 1004 real_t Expression::toReal() | |
| 1005 { | |
| 1006 error("Floating point constant expression expected instead of %s", toChars()); | |
| 1007 return 0; | |
| 1008 } | |
| 1009 | |
| 1010 real_t Expression::toImaginary() | |
| 1011 { | |
| 1012 error("Floating point constant expression expected instead of %s", toChars()); | |
| 1013 return 0; | |
| 1014 } | |
| 1015 | |
| 1016 complex_t Expression::toComplex() | |
| 1017 { | |
| 1018 error("Floating point constant expression expected instead of %s", toChars()); | |
| 1019 #ifdef IN_GCC | |
| 1020 return complex_t(real_t(0)); // %% nicer | |
| 1021 #else | |
| 1022 return 0; | |
| 1023 #endif | |
| 1024 } | |
| 1025 | |
| 1026 void Expression::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 1027 { | |
| 1028 buf->writestring(Token::toChars(op)); | |
| 1029 } | |
| 1030 | |
| 1031 void Expression::toMangleBuffer(OutBuffer *buf) | |
| 1032 { | |
| 1033 error("expression %s is not a valid template value argument", toChars()); | |
| 1034 } | |
| 1035 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1036 /*************************************** |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1037 * Return !=0 if expression is an lvalue. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1038 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1039 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1040 int Expression::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1041 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1042 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1043 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1044 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1045 |
| 159 | 1046 /******************************* |
| 1047 * Give error if we're not an lvalue. | |
| 1048 * If we can, convert expression to be an lvalue. | |
| 1049 */ | |
| 1050 | |
| 1051 Expression *Expression::toLvalue(Scope *sc, Expression *e) | |
| 1052 { | |
| 1053 if (!e) | |
| 1054 e = this; | |
| 1055 else if (!loc.filename) | |
| 1056 loc = e->loc; | |
| 1057 error("%s is not an lvalue", e->toChars()); | |
| 1058 return this; | |
| 1059 } | |
| 1060 | |
| 1061 Expression *Expression::modifiableLvalue(Scope *sc, Expression *e) | |
| 1062 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
1063 //printf("Expression::modifiableLvalue() %s, type = %s\n", toChars(), type->toChars()); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
1064 |
| 159 | 1065 // See if this expression is a modifiable lvalue (i.e. not const) |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1066 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1067 if (type && (!type->isMutable() || !type->isAssignable())) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1068 error("%s is not mutable", e->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1069 #endif |
| 159 | 1070 return toLvalue(sc, e); |
| 1071 } | |
| 1072 | |
| 1073 /************************************ | |
| 1074 * Detect cases where pointers to the stack can 'escape' the | |
| 1075 * lifetime of the stack frame. | |
| 1076 */ | |
| 1077 | |
| 1078 void Expression::checkEscape() | |
| 1079 { | |
| 1080 } | |
| 1081 | |
| 1082 void Expression::checkScalar() | |
| 1083 { | |
| 1084 if (!type->isscalar()) | |
| 1085 error("'%s' is not a scalar, it is a %s", toChars(), type->toChars()); | |
| 1086 } | |
| 1087 | |
| 1088 void Expression::checkNoBool() | |
| 1089 { | |
| 1090 if (type->toBasetype()->ty == Tbool) | |
| 1091 error("operation not allowed on bool '%s'", toChars()); | |
| 1092 } | |
| 1093 | |
| 1094 Expression *Expression::checkIntegral() | |
| 1095 { | |
| 1096 if (!type->isintegral()) | |
| 1097 { error("'%s' is not of integral type, it is a %s", toChars(), type->toChars()); | |
| 1098 return new IntegerExp(0); | |
| 1099 } | |
| 1100 return this; | |
| 1101 } | |
| 1102 | |
| 1103 Expression *Expression::checkArithmetic() | |
| 1104 { | |
| 1105 if (!type->isintegral() && !type->isfloating()) | |
| 1106 { error("'%s' is not of arithmetic type, it is a %s", toChars(), type->toChars()); | |
| 1107 return new IntegerExp(0); | |
| 1108 } | |
| 1109 return this; | |
| 1110 } | |
| 1111 | |
| 1112 void Expression::checkDeprecated(Scope *sc, Dsymbol *s) | |
| 1113 { | |
| 1114 s->checkDeprecated(loc, sc); | |
| 1115 } | |
| 1116 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1117 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1118 void Expression::checkPurity(Scope *sc, FuncDeclaration *f) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1119 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1120 if (sc->func && sc->func->isPure() && !sc->intypeof && !f->isPure()) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1121 error("pure function '%s' cannot call impure function '%s'\n", |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1122 sc->func->toChars(), f->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1123 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1124 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1125 |
| 159 | 1126 /******************************** |
| 1127 * Check for expressions that have no use. | |
| 1128 * Input: | |
| 1129 * flag 0 not going to use the result, so issue error message if no | |
| 1130 * side effects | |
| 1131 * 1 the result of the expression is used, but still check | |
| 1132 * for useless subexpressions | |
| 1133 * 2 do not issue error messages, just return !=0 if expression | |
| 1134 * has side effects | |
| 1135 */ | |
| 1136 | |
| 1137 int Expression::checkSideEffect(int flag) | |
| 1138 { | |
| 1139 if (flag == 0) | |
| 1140 { if (op == TOKimport) | |
| 1141 { | |
| 1142 error("%s has no effect", toChars()); | |
| 1143 } | |
| 1144 else | |
| 1145 error("%s has no effect in expression (%s)", | |
| 1146 Token::toChars(op), toChars()); | |
| 1147 } | |
| 1148 return 0; | |
| 1149 } | |
| 1150 | |
| 1151 /***************************** | |
| 1152 * Check that expression can be tested for true or false. | |
| 1153 */ | |
| 1154 | |
| 1155 Expression *Expression::checkToBoolean() | |
| 1156 { | |
| 1157 // Default is 'yes' - do nothing | |
| 1158 | |
| 1159 #ifdef DEBUG | |
| 1160 if (!type) | |
| 1161 dump(0); | |
| 1162 #endif | |
| 1163 | |
| 1164 if (!type->checkBoolean()) | |
| 1165 { | |
| 1166 error("expression %s of type %s does not have a boolean value", toChars(), type->toChars()); | |
| 1167 } | |
| 1168 return this; | |
| 1169 } | |
| 1170 | |
| 1171 /**************************** | |
| 1172 */ | |
| 1173 | |
| 1174 Expression *Expression::checkToPointer() | |
| 1175 { | |
| 1176 Expression *e; | |
| 1177 Type *tb; | |
| 1178 | |
| 1179 //printf("Expression::checkToPointer()\n"); | |
| 1180 e = this; | |
| 1181 | |
| 1182 // If C static array, convert to pointer | |
| 1183 tb = type->toBasetype(); | |
| 1184 if (tb->ty == Tsarray) | |
| 1185 { TypeSArray *ts = (TypeSArray *)tb; | |
| 1186 if (ts->size(loc) == 0) | |
| 1187 e = new NullExp(loc); | |
| 1188 else | |
| 1189 e = new AddrExp(loc, this); | |
| 336 | 1190 e->type = ts->next->pointerTo(); |
| 159 | 1191 } |
| 1192 return e; | |
| 1193 } | |
| 1194 | |
| 1195 /****************************** | |
| 1196 * Take address of expression. | |
| 1197 */ | |
| 1198 | |
| 1199 Expression *Expression::addressOf(Scope *sc) | |
| 1200 { | |
| 1201 Expression *e; | |
| 1202 | |
| 1203 //printf("Expression::addressOf()\n"); | |
| 1204 e = toLvalue(sc, NULL); | |
| 1205 e = new AddrExp(loc, e); | |
| 1206 e->type = type->pointerTo(); | |
| 1207 return e; | |
| 1208 } | |
| 1209 | |
| 1210 /****************************** | |
| 1211 * If this is a reference, dereference it. | |
| 1212 */ | |
| 1213 | |
| 1214 Expression *Expression::deref() | |
| 1215 { | |
| 1216 //printf("Expression::deref()\n"); | |
| 1217 if (type->ty == Treference) | |
| 1218 { Expression *e; | |
| 1219 | |
| 1220 e = new PtrExp(loc, this); | |
| 336 | 1221 e->type = ((TypeReference *)type)->next; |
| 159 | 1222 return e; |
| 1223 } | |
| 1224 return this; | |
| 1225 } | |
| 1226 | |
| 1227 /******************************** | |
| 1228 * Does this expression statically evaluate to a boolean TRUE or FALSE? | |
| 1229 */ | |
| 1230 | |
| 1231 int Expression::isBool(int result) | |
| 1232 { | |
| 1233 return FALSE; | |
| 1234 } | |
| 1235 | |
| 1236 /******************************** | |
| 1237 * Does this expression result in either a 1 or a 0? | |
| 1238 */ | |
| 1239 | |
| 1240 int Expression::isBit() | |
| 1241 { | |
| 1242 return FALSE; | |
| 1243 } | |
| 1244 | |
| 336 | 1245 /******************************** |
| 1246 * Can this expression throw an exception? | |
| 1247 * Valid only after semantic() pass. | |
| 1248 */ | |
| 1249 | |
| 1250 int Expression::canThrow() | |
| 1251 { | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1252 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1253 return FALSE; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1254 #else |
| 336 | 1255 return TRUE; |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1256 #endif |
| 336 | 1257 } |
| 1258 | |
| 1259 | |
| 1260 | |
| 159 | 1261 Expressions *Expression::arraySyntaxCopy(Expressions *exps) |
| 1262 { Expressions *a = NULL; | |
| 1263 | |
| 1264 if (exps) | |
| 1265 { | |
| 1266 a = new Expressions(); | |
| 1267 a->setDim(exps->dim); | |
| 1268 for (int i = 0; i < a->dim; i++) | |
| 1269 { Expression *e = (Expression *)exps->data[i]; | |
| 1270 | |
| 1271 e = e->syntaxCopy(); | |
| 1272 a->data[i] = e; | |
| 1273 } | |
| 1274 } | |
| 1275 return a; | |
| 1276 } | |
| 1277 | |
| 1278 /******************************** IntegerExp **************************/ | |
| 1279 | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1280 IntegerExp::IntegerExp(Loc loc, dinteger_t value, Type *type) |
| 159 | 1281 : Expression(loc, TOKint64, sizeof(IntegerExp)) |
| 1282 { | |
| 1283 //printf("IntegerExp(value = %lld, type = '%s')\n", value, type ? type->toChars() : ""); | |
| 1284 if (type && !type->isscalar()) | |
| 1285 { | |
| 336 | 1286 //printf("%s, loc = %d\n", toChars(), loc.linnum); |
| 159 | 1287 error("integral constant must be scalar type, not %s", type->toChars()); |
| 1288 type = Type::terror; | |
| 1289 } | |
| 1290 this->type = type; | |
| 1291 this->value = value; | |
| 1292 } | |
| 1293 | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1294 IntegerExp::IntegerExp(dinteger_t value) |
| 159 | 1295 : Expression(0, TOKint64, sizeof(IntegerExp)) |
| 1296 { | |
| 1297 this->type = Type::tint32; | |
| 1298 this->value = value; | |
| 1299 } | |
| 1300 | |
| 1301 int IntegerExp::equals(Object *o) | |
| 1302 { IntegerExp *ne; | |
| 1303 | |
| 1304 if (this == o || | |
| 1305 (((Expression *)o)->op == TOKint64 && | |
| 1306 ((ne = (IntegerExp *)o), type->equals(ne->type)) && | |
| 1307 value == ne->value)) | |
| 1308 return 1; | |
| 1309 return 0; | |
| 1310 } | |
| 1311 | |
| 1312 char *IntegerExp::toChars() | |
| 1313 { | |
| 1314 #if 1 | |
| 1315 return Expression::toChars(); | |
| 1316 #else | |
| 1317 static char buffer[sizeof(value) * 3 + 1]; | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1318 |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1319 sprintf(buffer, "%jd", value); |
| 159 | 1320 return buffer; |
| 1321 #endif | |
| 1322 } | |
| 1323 | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1324 dinteger_t IntegerExp::toInteger() |
| 159 | 1325 { Type *t; |
| 1326 | |
| 1327 t = type; | |
| 1328 while (t) | |
| 1329 { | |
| 1330 switch (t->ty) | |
| 1331 { | |
| 1332 case Tbit: | |
| 1333 case Tbool: value = (value != 0); break; | |
| 1334 case Tint8: value = (d_int8) value; break; | |
| 1335 case Tchar: | |
| 1336 case Tuns8: value = (d_uns8) value; break; | |
| 1337 case Tint16: value = (d_int16) value; break; | |
| 1338 case Twchar: | |
| 1339 case Tuns16: value = (d_uns16) value; break; | |
| 1340 case Tint32: value = (d_int32) value; break; | |
| 1341 case Tdchar: | |
| 1342 case Tuns32: value = (d_uns32) value; break; | |
| 1343 case Tint64: value = (d_int64) value; break; | |
| 1344 case Tuns64: value = (d_uns64) value; break; | |
|
1120
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1345 case Tpointer: |
|
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1346 if (PTRSIZE == 4) |
|
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1347 value = (d_uns32) value; |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1348 else if (PTRSIZE == 8) |
|
1120
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1349 value = (d_uns64) value; |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1350 else |
|
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1351 assert(0); |
|
1120
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1352 break; |
| 159 | 1353 |
| 1354 case Tenum: | |
| 1355 { | |
| 1356 TypeEnum *te = (TypeEnum *)t; | |
| 1357 t = te->sym->memtype; | |
| 1358 continue; | |
| 1359 } | |
| 1360 | |
| 1361 case Ttypedef: | |
| 1362 { | |
| 1363 TypeTypedef *tt = (TypeTypedef *)t; | |
| 1364 t = tt->sym->basetype; | |
| 1365 continue; | |
| 1366 } | |
| 1367 | |
| 1368 default: | |
| 336 | 1369 /* This can happen if errors, such as |
| 1370 * the type is painted on like in fromConstInitializer(). | |
| 1371 */ | |
| 1372 if (!global.errors) | |
| 1373 { type->print(); | |
| 1374 assert(0); | |
| 1375 } | |
| 159 | 1376 break; |
| 1377 } | |
| 1378 break; | |
| 1379 } | |
| 1380 return value; | |
| 1381 } | |
| 1382 | |
| 1383 real_t IntegerExp::toReal() | |
| 1384 { | |
| 1385 Type *t; | |
| 1386 | |
| 1387 toInteger(); | |
| 1388 t = type->toBasetype(); | |
| 1389 if (t->ty == Tuns64) | |
| 1390 return (real_t)(d_uns64)value; | |
| 1391 else | |
| 1392 return (real_t)(d_int64)value; | |
| 1393 } | |
| 1394 | |
| 1395 real_t IntegerExp::toImaginary() | |
| 1396 { | |
| 1397 return (real_t) 0; | |
| 1398 } | |
| 1399 | |
| 1400 complex_t IntegerExp::toComplex() | |
| 1401 { | |
| 1402 return toReal(); | |
| 1403 } | |
| 1404 | |
| 1405 int IntegerExp::isBool(int result) | |
| 1406 { | |
| 1407 return result ? value != 0 : value == 0; | |
| 1408 } | |
| 1409 | |
| 1410 Expression *IntegerExp::semantic(Scope *sc) | |
| 1411 { | |
| 1412 if (!type) | |
| 1413 { | |
| 1414 // Determine what the type of this number is | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1415 dinteger_t number = value; |
| 159 | 1416 |
| 1417 if (number & 0x8000000000000000LL) | |
| 1418 type = Type::tuns64; | |
| 1419 else if (number & 0xFFFFFFFF80000000LL) | |
| 1420 type = Type::tint64; | |
| 1421 else | |
| 1422 type = Type::tint32; | |
| 1423 } | |
| 1424 else | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
1425 { if (!type->deco) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
1426 type = type->semantic(loc, sc); |
| 159 | 1427 } |
| 1428 return this; | |
| 1429 } | |
| 1430 | |
| 1431 Expression *IntegerExp::toLvalue(Scope *sc, Expression *e) | |
| 1432 { | |
| 1433 if (!e) | |
| 1434 e = this; | |
| 1435 else if (!loc.filename) | |
| 1436 loc = e->loc; | |
| 1437 e->error("constant %s is not an lvalue", e->toChars()); | |
| 1438 return this; | |
| 1439 } | |
| 1440 | |
| 1441 void IntegerExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 1442 { | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1443 dinteger_t v = toInteger(); |
| 159 | 1444 |
| 1445 if (type) | |
| 1446 { Type *t = type; | |
| 1447 | |
| 1448 L1: | |
| 1449 switch (t->ty) | |
| 1450 { | |
| 1451 case Tenum: | |
| 1452 { TypeEnum *te = (TypeEnum *)t; | |
| 1453 buf->printf("cast(%s)", te->sym->toChars()); | |
| 1454 t = te->sym->memtype; | |
| 1455 goto L1; | |
| 1456 } | |
| 1457 | |
| 1458 case Ttypedef: | |
| 1459 { TypeTypedef *tt = (TypeTypedef *)t; | |
| 1460 buf->printf("cast(%s)", tt->sym->toChars()); | |
| 1461 t = tt->sym->basetype; | |
| 1462 goto L1; | |
| 1463 } | |
| 1464 | |
| 1465 case Twchar: // BUG: need to cast(wchar) | |
| 1466 case Tdchar: // BUG: need to cast(dchar) | |
| 1467 if ((uinteger_t)v > 0xFF) | |
| 1468 { | |
|
1372
229e02867307
Fix format-string bugs by adding __attribute__((__format__)) in all applicable
Frits van Bommel <fvbommel wxs.nl>
parents:
1367
diff
changeset
|
1469 buf->printf("'\\U%08x'", (unsigned)v); |
| 159 | 1470 break; |
| 1471 } | |
| 1472 case Tchar: | |
| 1473 if (v == '\'') | |
| 1474 buf->writestring("'\\''"); | |
| 1475 else if (isprint(v) && v != '\\') | |
| 1476 buf->printf("'%c'", (int)v); | |
| 1477 else | |
| 1478 buf->printf("'\\x%02x'", (int)v); | |
| 1479 break; | |
| 1480 | |
| 1481 case Tint8: | |
| 1482 buf->writestring("cast(byte)"); | |
| 1483 goto L2; | |
| 1484 | |
| 1485 case Tint16: | |
| 1486 buf->writestring("cast(short)"); | |
| 1487 goto L2; | |
| 1488 | |
| 1489 case Tint32: | |
| 1490 L2: | |
| 1491 buf->printf("%d", (int)v); | |
| 1492 break; | |
| 1493 | |
| 1494 case Tuns8: | |
| 1495 buf->writestring("cast(ubyte)"); | |
| 1496 goto L3; | |
| 1497 | |
| 1498 case Tuns16: | |
| 1499 buf->writestring("cast(ushort)"); | |
| 1500 goto L3; | |
| 1501 | |
| 1502 case Tuns32: | |
| 1503 L3: | |
| 1504 buf->printf("%du", (unsigned)v); | |
| 1505 break; | |
| 1506 | |
| 1507 case Tint64: | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1508 buf->printf("%jdL", v); |
| 159 | 1509 break; |
| 1510 | |
| 1511 case Tuns64: | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1512 L4: |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1513 buf->printf("%juLU", v); |
| 159 | 1514 break; |
| 1515 | |
| 1516 case Tbit: | |
| 1517 case Tbool: | |
| 1518 buf->writestring((char *)(v ? "true" : "false")); | |
| 1519 break; | |
| 1520 | |
| 1521 case Tpointer: | |
| 1522 buf->writestring("cast("); | |
| 1523 buf->writestring(t->toChars()); | |
| 1524 buf->writeByte(')'); | |
|
1120
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1525 if (PTRSIZE == 4) |
|
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1526 goto L3; |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1527 else if (PTRSIZE == 8) |
|
1120
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1528 goto L4; |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1529 else |
|
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1530 assert(0); |
| 159 | 1531 |
| 1532 default: | |
| 336 | 1533 /* This can happen if errors, such as |
| 1534 * the type is painted on like in fromConstInitializer(). | |
| 1535 */ | |
| 1536 if (!global.errors) | |
| 1537 { | |
| 159 | 1538 #ifdef DEBUG |
| 336 | 1539 t->print(); |
| 159 | 1540 #endif |
| 336 | 1541 assert(0); |
| 1542 } | |
| 1543 break; | |
| 159 | 1544 } |
| 1545 } | |
| 1546 else if (v & 0x8000000000000000LL) | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1547 buf->printf("0x%jx", v); |
| 159 | 1548 else |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1549 buf->printf("%jd", v); |
| 159 | 1550 } |
| 1551 | |
| 1552 void IntegerExp::toMangleBuffer(OutBuffer *buf) | |
| 1553 { | |
| 1554 if ((sinteger_t)value < 0) | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1555 buf->printf("N%jd", -value); |
| 159 | 1556 else |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1557 buf->printf("%jd", value); |
| 159 | 1558 } |
| 1559 | |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1560 /******************************** ErrorExp **************************/ |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1561 |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1562 /* Use this expression for error recovery. |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1563 * It should behave as a 'sink' to prevent further cascaded error messages. |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1564 */ |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1565 |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1566 ErrorExp::ErrorExp() |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1567 : IntegerExp(0, 0, Type::terror) |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1568 { |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1569 } |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1570 |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1571 void ErrorExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1572 { |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1573 buf->writestring("__error"); |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1574 } |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1575 |
| 159 | 1576 /******************************** RealExp **************************/ |
| 1577 | |
| 1578 RealExp::RealExp(Loc loc, real_t value, Type *type) | |
| 1579 : Expression(loc, TOKfloat64, sizeof(RealExp)) | |
| 1580 { | |
| 1581 //printf("RealExp::RealExp(%Lg)\n", value); | |
| 1582 this->value = value; | |
| 1583 this->type = type; | |
| 1584 } | |
| 1585 | |
| 1586 char *RealExp::toChars() | |
| 1587 { | |
| 1588 char buffer[sizeof(value) * 3 + 8 + 1 + 1]; | |
| 1589 | |
| 1590 #ifdef IN_GCC | |
| 1591 value.format(buffer, sizeof(buffer)); | |
| 1592 if (type->isimaginary()) | |
| 1593 strcat(buffer, "i"); | |
| 1594 #else | |
| 1595 sprintf(buffer, type->isimaginary() ? "%Lgi" : "%Lg", value); | |
| 1596 #endif | |
| 1597 assert(strlen(buffer) < sizeof(buffer)); | |
| 1598 return mem.strdup(buffer); | |
| 1599 } | |
| 1600 | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1601 dinteger_t RealExp::toInteger() |
| 159 | 1602 { |
| 1603 #ifdef IN_GCC | |
| 1604 return toReal().toInt(); | |
| 1605 #else | |
| 1606 return (sinteger_t) toReal(); | |
| 1607 #endif | |
| 1608 } | |
| 1609 | |
| 1610 uinteger_t RealExp::toUInteger() | |
| 1611 { | |
| 1612 #ifdef IN_GCC | |
| 1613 return (uinteger_t) toReal().toInt(); | |
| 1614 #else | |
| 1615 return (uinteger_t) toReal(); | |
| 1616 #endif | |
| 1617 } | |
| 1618 | |
| 1619 real_t RealExp::toReal() | |
| 1620 { | |
| 1621 return type->isreal() ? value : 0; | |
| 1622 } | |
| 1623 | |
| 1624 real_t RealExp::toImaginary() | |
| 1625 { | |
| 1626 return type->isreal() ? 0 : value; | |
| 1627 } | |
| 1628 | |
| 1629 complex_t RealExp::toComplex() | |
| 1630 { | |
| 1631 #ifdef __DMC__ | |
| 1632 return toReal() + toImaginary() * I; | |
| 1633 #else | |
| 1634 return complex_t(toReal(), toImaginary()); | |
| 1635 #endif | |
| 1636 } | |
| 1637 | |
| 1638 /******************************** | |
| 1639 * Test to see if two reals are the same. | |
| 1640 * Regard NaN's as equivalent. | |
| 1641 * Regard +0 and -0 as different. | |
| 1642 */ | |
| 1643 | |
| 1644 int RealEquals(real_t x1, real_t x2) | |
| 1645 { | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1646 #if __APPLE__ |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1647 return (__inline_isnan(x1) && __inline_isnan(x2)) || |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1648 #else |
|
421
1c65b5477eaa
Fix real comparison for real: allow +0 to be distinguished from -0.
Christian Kamm <kamm incasoftware de>
parents:
420
diff
changeset
|
1649 return // special case nans |
|
1c65b5477eaa
Fix real comparison for real: allow +0 to be distinguished from -0.
Christian Kamm <kamm incasoftware de>
parents:
420
diff
changeset
|
1650 (isnan(x1) && isnan(x2)) || |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1651 #endif |
|
421
1c65b5477eaa
Fix real comparison for real: allow +0 to be distinguished from -0.
Christian Kamm <kamm incasoftware de>
parents:
420
diff
changeset
|
1652 // and zero, in order to distinguish +0 from -0 |
|
1c65b5477eaa
Fix real comparison for real: allow +0 to be distinguished from -0.
Christian Kamm <kamm incasoftware de>
parents:
420
diff
changeset
|
1653 (x1 == 0 && x2 == 0 && 1./x1 == 1./x2) || |
|
1c65b5477eaa
Fix real comparison for real: allow +0 to be distinguished from -0.
Christian Kamm <kamm incasoftware de>
parents:
420
diff
changeset
|
1654 // otherwise just compare |
|
1c65b5477eaa
Fix real comparison for real: allow +0 to be distinguished from -0.
Christian Kamm <kamm incasoftware de>
parents:
420
diff
changeset
|
1655 (x1 != 0. && x1 == x2); |
| 159 | 1656 } |
| 1657 | |
| 1658 int RealExp::equals(Object *o) | |
| 1659 { RealExp *ne; | |
| 1660 | |
| 1661 if (this == o || | |
| 1662 (((Expression *)o)->op == TOKfloat64 && | |
| 1663 ((ne = (RealExp *)o), type->equals(ne->type)) && | |
| 1664 RealEquals(value, ne->value) | |
| 1665 ) | |
| 1666 ) | |
| 1667 return 1; | |
| 1668 return 0; | |
| 1669 } | |
| 1670 | |
| 1671 Expression *RealExp::semantic(Scope *sc) | |
| 1672 { | |
| 1673 if (!type) | |
| 1674 type = Type::tfloat64; | |
| 1675 else | |
| 1676 type = type->semantic(loc, sc); | |
| 1677 return this; | |
| 1678 } | |
| 1679 | |
| 1680 int RealExp::isBool(int result) | |
| 1681 { | |
| 1682 #ifdef IN_GCC | |
| 1683 return result ? (! value.isZero()) : (value.isZero()); | |
| 1684 #else | |
| 1685 return result ? (value != 0) | |
| 1686 : (value == 0); | |
| 1687 #endif | |
| 1688 } | |
| 1689 | |
| 1690 void floatToBuffer(OutBuffer *buf, Type *type, real_t value) | |
| 1691 { | |
| 1692 /* In order to get an exact representation, try converting it | |
| 1693 * to decimal then back again. If it matches, use it. | |
| 1694 * If it doesn't, fall back to hex, which is | |
| 1695 * always exact. | |
| 1696 */ | |
| 1697 char buffer[25]; | |
| 1698 sprintf(buffer, "%Lg", value); | |
| 1699 assert(strlen(buffer) < sizeof(buffer)); | |
| 1700 #if _WIN32 && __DMC__ | |
| 1701 char *save = __locale_decpoint; | |
| 1702 __locale_decpoint = "."; | |
| 1703 real_t r = strtold(buffer, NULL); | |
| 1704 __locale_decpoint = save; | |
| 1705 #else | |
| 1706 real_t r = strtold(buffer, NULL); | |
| 1707 #endif | |
| 1708 if (r == value) // if exact duplication | |
| 1709 buf->writestring(buffer); | |
| 1710 else | |
| 1711 buf->printf("%La", value); // ensure exact duplication | |
| 1712 | |
| 1713 if (type) | |
| 1714 { | |
| 1715 Type *t = type->toBasetype(); | |
| 1716 switch (t->ty) | |
| 1717 { | |
| 1718 case Tfloat32: | |
| 1719 case Timaginary32: | |
| 1720 case Tcomplex32: | |
| 1721 buf->writeByte('F'); | |
| 1722 break; | |
| 1723 | |
| 1724 case Tfloat80: | |
| 1725 case Timaginary80: | |
| 1726 case Tcomplex80: | |
| 1727 buf->writeByte('L'); | |
| 1728 break; | |
| 1729 | |
| 1730 default: | |
| 1731 break; | |
| 1732 } | |
| 1733 if (t->isimaginary()) | |
| 1734 buf->writeByte('i'); | |
| 1735 } | |
| 1736 } | |
| 1737 | |
| 1738 void RealExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 1739 { | |
| 1740 floatToBuffer(buf, type, value); | |
| 1741 } | |
| 1742 | |
| 1743 void realToMangleBuffer(OutBuffer *buf, real_t value) | |
| 1744 { | |
| 1745 /* Rely on %A to get portable mangling. | |
| 1746 * Must munge result to get only identifier characters. | |
| 1747 * | |
| 1748 * Possible values from %A => mangled result | |
| 1749 * NAN => NAN | |
| 1750 * -INF => NINF | |
| 1751 * INF => INF | |
| 1752 * -0X1.1BC18BA997B95P+79 => N11BC18BA997B95P79 | |
| 1753 * 0X1.9P+2 => 19P2 | |
| 1754 */ | |
| 1755 | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1756 #if __APPLE__ |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1757 if (__inline_isnan(value)) |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1758 #else |
| 159 | 1759 if (isnan(value)) |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1760 #endif |
| 159 | 1761 buf->writestring("NAN"); // no -NAN bugs |
| 1762 else | |
| 1763 { | |
| 1764 char buffer[32]; | |
| 1765 int n = sprintf(buffer, "%LA", value); | |
| 1766 assert(n > 0 && n < sizeof(buffer)); | |
| 1767 for (int i = 0; i < n; i++) | |
| 1768 { char c = buffer[i]; | |
| 1769 | |
| 1770 switch (c) | |
| 1771 { | |
| 1772 case '-': | |
| 1773 buf->writeByte('N'); | |
| 1774 break; | |
| 1775 | |
| 1776 case '+': | |
| 1777 case 'X': | |
| 1778 case '.': | |
| 1779 break; | |
| 1780 | |
| 1781 case '0': | |
| 1782 if (i < 2) | |
| 1783 break; // skip leading 0X | |
| 1784 default: | |
| 1785 buf->writeByte(c); | |
| 1786 break; | |
| 1787 } | |
| 1788 } | |
| 1789 } | |
| 1790 } | |
| 1791 | |
| 1792 void RealExp::toMangleBuffer(OutBuffer *buf) | |
| 1793 { | |
| 1794 buf->writeByte('e'); | |
| 1795 realToMangleBuffer(buf, value); | |
| 1796 } | |
| 1797 | |
| 1798 | |
| 1799 /******************************** ComplexExp **************************/ | |
| 1800 | |
| 1801 ComplexExp::ComplexExp(Loc loc, complex_t value, Type *type) | |
| 1802 : Expression(loc, TOKcomplex80, sizeof(ComplexExp)) | |
| 1803 { | |
| 1804 this->value = value; | |
| 1805 this->type = type; | |
| 1806 //printf("ComplexExp::ComplexExp(%s)\n", toChars()); | |
| 1807 } | |
| 1808 | |
| 1809 char *ComplexExp::toChars() | |
| 1810 { | |
| 1811 char buffer[sizeof(value) * 3 + 8 + 1]; | |
| 1812 | |
| 1813 #ifdef IN_GCC | |
| 1814 char buf1[sizeof(value) * 3 + 8 + 1]; | |
| 1815 char buf2[sizeof(value) * 3 + 8 + 1]; | |
| 1816 creall(value).format(buf1, sizeof(buf1)); | |
| 1817 cimagl(value).format(buf2, sizeof(buf2)); | |
| 1818 sprintf(buffer, "(%s+%si)", buf1, buf2); | |
| 1819 #else | |
| 1820 sprintf(buffer, "(%Lg+%Lgi)", creall(value), cimagl(value)); | |
| 1821 assert(strlen(buffer) < sizeof(buffer)); | |
| 1822 #endif | |
| 1823 return mem.strdup(buffer); | |
| 1824 } | |
| 1825 | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
1826 dinteger_t ComplexExp::toInteger() |
| 159 | 1827 { |
| 1828 #ifdef IN_GCC | |
| 1829 return (sinteger_t) toReal().toInt(); | |
| 1830 #else | |
| 1831 return (sinteger_t) toReal(); | |
| 1832 #endif | |
| 1833 } | |
| 1834 | |
| 1835 uinteger_t ComplexExp::toUInteger() | |
| 1836 { | |
| 1837 #ifdef IN_GCC | |
| 1838 return (uinteger_t) toReal().toInt(); | |
| 1839 #else | |
| 1840 return (uinteger_t) toReal(); | |
| 1841 #endif | |
| 1842 } | |
| 1843 | |
| 1844 real_t ComplexExp::toReal() | |
| 1845 { | |
| 1846 return creall(value); | |
| 1847 } | |
| 1848 | |
| 1849 real_t ComplexExp::toImaginary() | |
| 1850 { | |
| 1851 return cimagl(value); | |
| 1852 } | |
| 1853 | |
| 1854 complex_t ComplexExp::toComplex() | |
| 1855 { | |
| 1856 return value; | |
| 1857 } | |
| 1858 | |
| 1859 int ComplexExp::equals(Object *o) | |
| 1860 { ComplexExp *ne; | |
| 1861 | |
| 1862 if (this == o || | |
| 1863 (((Expression *)o)->op == TOKcomplex80 && | |
| 1864 ((ne = (ComplexExp *)o), type->equals(ne->type)) && | |
| 1865 RealEquals(creall(value), creall(ne->value)) && | |
| 1866 RealEquals(cimagl(value), cimagl(ne->value)) | |
| 1867 ) | |
| 1868 ) | |
| 1869 return 1; | |
| 1870 return 0; | |
| 1871 } | |
| 1872 | |
| 1873 Expression *ComplexExp::semantic(Scope *sc) | |
| 1874 { | |
| 1875 if (!type) | |
| 1876 type = Type::tcomplex80; | |
| 1877 else | |
| 1878 type = type->semantic(loc, sc); | |
| 1879 return this; | |
| 1880 } | |
| 1881 | |
| 1882 int ComplexExp::isBool(int result) | |
| 1883 { | |
| 1884 if (result) | |
| 1885 return (bool)(value); | |
| 1886 else | |
| 1887 return !value; | |
| 1888 } | |
| 1889 | |
| 1890 void ComplexExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 1891 { | |
| 1892 /* Print as: | |
| 1893 * (re+imi) | |
| 1894 */ | |
| 1895 #ifdef IN_GCC | |
| 1896 char buf1[sizeof(value) * 3 + 8 + 1]; | |
| 1897 char buf2[sizeof(value) * 3 + 8 + 1]; | |
| 1898 creall(value).format(buf1, sizeof(buf1)); | |
| 1899 cimagl(value).format(buf2, sizeof(buf2)); | |
| 1900 buf->printf("(%s+%si)", buf1, buf2); | |
| 1901 #else | |
| 1902 buf->writeByte('('); | |
| 1903 floatToBuffer(buf, type, creall(value)); | |
| 1904 buf->writeByte('+'); | |
| 1905 floatToBuffer(buf, type, cimagl(value)); | |
| 1906 buf->writestring("i)"); | |
| 1907 #endif | |
| 1908 } | |
| 1909 | |
| 1910 void ComplexExp::toMangleBuffer(OutBuffer *buf) | |
| 1911 { | |
| 1912 buf->writeByte('c'); | |
| 1913 real_t r = toReal(); | |
| 1914 realToMangleBuffer(buf, r); | |
| 1915 buf->writeByte('c'); // separate the two | |
| 1916 r = toImaginary(); | |
| 1917 realToMangleBuffer(buf, r); | |
| 1918 } | |
| 1919 | |
| 1920 /******************************** IdentifierExp **************************/ | |
| 1921 | |
| 1922 IdentifierExp::IdentifierExp(Loc loc, Identifier *ident) | |
| 1923 : Expression(loc, TOKidentifier, sizeof(IdentifierExp)) | |
| 1924 { | |
| 1925 this->ident = ident; | |
| 1926 } | |
| 1927 | |
| 1928 Expression *IdentifierExp::semantic(Scope *sc) | |
| 1929 { | |
| 1930 Dsymbol *s; | |
| 1931 Dsymbol *scopesym; | |
| 1932 | |
| 1933 #if LOGSEMANTIC | |
| 1934 printf("IdentifierExp::semantic('%s')\n", ident->toChars()); | |
| 1935 #endif | |
| 1936 s = sc->search(loc, ident, &scopesym); | |
| 1937 if (s) | |
| 1938 { Expression *e; | |
| 1939 WithScopeSymbol *withsym; | |
| 1940 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
1941 /* See if the symbol was a member of an enclosing 'with' |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
1942 */ |
| 159 | 1943 withsym = scopesym->isWithScopeSymbol(); |
| 1944 if (withsym) | |
| 1945 { | |
| 1946 s = s->toAlias(); | |
| 1947 | |
| 1948 // Same as wthis.ident | |
| 1949 if (s->needThis() || s->isTemplateDeclaration()) | |
| 1950 { | |
| 1951 e = new VarExp(loc, withsym->withstate->wthis); | |
| 1952 e = new DotIdExp(loc, e, ident); | |
| 1953 } | |
| 1954 else | |
| 1955 { Type *t = withsym->withstate->wthis->type; | |
| 1956 if (t->ty == Tpointer) | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
1957 t = ((TypePointer *)t)->next; |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
1958 e = typeDotIdExp(loc, t, ident); |
| 159 | 1959 } |
| 1960 } | |
| 1961 else | |
| 1962 { | |
| 1963 if (!s->parent && scopesym->isArrayScopeSymbol()) | |
| 1964 { // Kludge to run semantic() here because | |
| 1965 // ArrayScopeSymbol::search() doesn't have access to sc. | |
| 1966 s->semantic(sc); | |
| 1967 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1968 /* If f is really a function template, |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1969 * then replace f with the function template declaration. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1970 */ |
| 159 | 1971 FuncDeclaration *f = s->isFuncDeclaration(); |
| 1972 if (f && f->parent) | |
| 1973 { TemplateInstance *ti = f->parent->isTemplateInstance(); | |
| 1974 | |
| 1975 if (ti && | |
| 1976 !ti->isTemplateMixin() && | |
| 1977 (ti->name == f->ident || | |
| 1978 ti->toAlias()->ident == f->ident) | |
| 1979 && | |
| 1980 ti->tempdecl && ti->tempdecl->onemember) | |
| 1981 { | |
| 1982 TemplateDeclaration *tempdecl = ti->tempdecl; | |
| 1983 if (tempdecl->overroot) // if not start of overloaded list of TemplateDeclaration's | |
| 1984 tempdecl = tempdecl->overroot; // then get the start | |
| 1985 e = new TemplateExp(loc, tempdecl); | |
| 1986 e = e->semantic(sc); | |
| 1987 return e; | |
| 1988 } | |
| 1989 } | |
| 1990 e = new DsymbolExp(loc, s); | |
| 1991 } | |
| 1992 return e->semantic(sc); | |
| 1993 } | |
| 1994 error("undefined identifier %s", ident->toChars()); | |
| 1995 type = Type::terror; | |
| 1996 return this; | |
| 1997 } | |
| 1998 | |
| 1999 char *IdentifierExp::toChars() | |
| 2000 { | |
| 2001 return ident->toChars(); | |
| 2002 } | |
| 2003 | |
| 2004 void IdentifierExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2005 { | |
| 2006 if (hgs->hdrgen) | |
| 2007 buf->writestring(ident->toHChars2()); | |
| 2008 else | |
| 2009 buf->writestring(ident->toChars()); | |
| 2010 } | |
| 2011 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2012 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2013 int IdentifierExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2014 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2015 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2016 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2017 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2018 |
| 159 | 2019 Expression *IdentifierExp::toLvalue(Scope *sc, Expression *e) |
| 2020 { | |
| 2021 #if 0 | |
| 2022 tym = tybasic(e1->ET->Tty); | |
| 2023 if (!(tyscalar(tym) || | |
| 2024 tym == TYstruct || | |
| 2025 tym == TYarray && e->Eoper == TOKaddr)) | |
| 2026 synerr(EM_lvalue); // lvalue expected | |
| 2027 #endif | |
| 2028 return this; | |
| 2029 } | |
| 2030 | |
| 2031 /******************************** DollarExp **************************/ | |
| 2032 | |
| 2033 DollarExp::DollarExp(Loc loc) | |
| 2034 : IdentifierExp(loc, Id::dollar) | |
| 2035 { | |
| 2036 } | |
| 2037 | |
| 2038 /******************************** DsymbolExp **************************/ | |
| 2039 | |
| 2040 DsymbolExp::DsymbolExp(Loc loc, Dsymbol *s) | |
| 2041 : Expression(loc, TOKdsymbol, sizeof(DsymbolExp)) | |
| 2042 { | |
| 2043 this->s = s; | |
| 2044 } | |
| 2045 | |
| 2046 Expression *DsymbolExp::semantic(Scope *sc) | |
| 2047 { | |
| 2048 #if LOGSEMANTIC | |
| 2049 printf("DsymbolExp::semantic('%s')\n", s->toChars()); | |
| 2050 #endif | |
| 2051 | |
| 2052 Lagain: | |
| 2053 EnumMember *em; | |
| 2054 Expression *e; | |
| 2055 VarDeclaration *v; | |
| 2056 FuncDeclaration *f; | |
| 2057 FuncLiteralDeclaration *fld; | |
| 2058 Declaration *d; | |
| 2059 ClassDeclaration *cd; | |
| 2060 ClassDeclaration *thiscd = NULL; | |
| 2061 Import *imp; | |
| 2062 Package *pkg; | |
| 2063 Type *t; | |
| 2064 | |
| 2065 //printf("DsymbolExp:: %p '%s' is a symbol\n", this, toChars()); | |
| 2066 //printf("s = '%s', s->kind = '%s'\n", s->toChars(), s->kind()); | |
| 2067 if (type) | |
| 2068 return this; | |
| 2069 if (!s->isFuncDeclaration()) // functions are checked after overloading | |
| 2070 checkDeprecated(sc, s); | |
| 2071 s = s->toAlias(); | |
| 2072 //printf("s = '%s', s->kind = '%s', s->needThis() = %p\n", s->toChars(), s->kind(), s->needThis()); | |
| 2073 if (!s->isFuncDeclaration()) | |
| 2074 checkDeprecated(sc, s); | |
| 2075 | |
| 2076 if (sc->func) | |
| 2077 thiscd = sc->func->parent->isClassDeclaration(); | |
| 2078 | |
| 2079 // BUG: This should happen after overload resolution for functions, not before | |
| 2080 if (s->needThis()) | |
| 2081 { | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2082 if (hasThis(sc) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2083 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2084 && !s->isFuncDeclaration() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2085 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2086 ) |
| 159 | 2087 { |
| 2088 // Supply an implicit 'this', as in | |
| 2089 // this.ident | |
| 2090 | |
| 2091 DotVarExp *de; | |
| 2092 | |
| 2093 de = new DotVarExp(loc, new ThisExp(loc), s->isDeclaration()); | |
| 2094 return de->semantic(sc); | |
| 2095 } | |
| 2096 } | |
| 2097 | |
| 2098 em = s->isEnumMember(); | |
| 2099 if (em) | |
| 2100 { | |
| 2101 e = em->value->copy(); | |
| 2102 e = e->semantic(sc); | |
| 2103 return e; | |
| 2104 } | |
| 2105 v = s->isVarDeclaration(); | |
| 2106 if (v) | |
| 2107 { | |
| 2108 //printf("Identifier '%s' is a variable, type '%s'\n", toChars(), v->type->toChars()); | |
| 2109 if (!type) | |
| 2110 { type = v->type; | |
| 2111 if (!v->type) | |
| 2112 { error("forward reference of %s", v->toChars()); | |
| 2113 type = Type::terror; | |
| 2114 } | |
| 2115 } | |
| 2116 if (v->isConst() && type->toBasetype()->ty != Tsarray) | |
| 2117 { | |
| 2118 if (v->init) | |
| 2119 { | |
| 2120 if (v->inuse) | |
| 2121 { | |
| 2122 error("circular reference to '%s'", v->toChars()); | |
| 2123 type = Type::tint32; | |
| 2124 return this; | |
| 2125 } | |
| 2126 ExpInitializer *ei = v->init->isExpInitializer(); | |
| 2127 if (ei) | |
| 2128 { | |
| 2129 e = ei->exp->copy(); // make copy so we can change loc | |
| 2130 if (e->op == TOKstring || !e->type) | |
| 2131 e = e->semantic(sc); | |
| 2132 e = e->implicitCastTo(sc, type); | |
| 2133 e->loc = loc; | |
| 2134 return e; | |
| 2135 } | |
| 2136 } | |
| 2137 else | |
| 2138 { | |
| 2139 e = type->defaultInit(); | |
| 2140 e->loc = loc; | |
| 2141 return e; | |
| 2142 } | |
| 2143 } | |
| 2144 e = new VarExp(loc, v); | |
| 2145 e->type = type; | |
| 2146 e = e->semantic(sc); | |
| 2147 return e->deref(); | |
| 2148 } | |
| 2149 fld = s->isFuncLiteralDeclaration(); | |
| 2150 if (fld) | |
| 2151 { //printf("'%s' is a function literal\n", fld->toChars()); | |
| 2152 e = new FuncExp(loc, fld); | |
| 2153 return e->semantic(sc); | |
| 2154 } | |
| 2155 f = s->isFuncDeclaration(); | |
| 2156 if (f) | |
| 2157 { //printf("'%s' is a function\n", f->toChars()); | |
| 2158 return new VarExp(loc, f); | |
| 2159 } | |
| 2160 cd = s->isClassDeclaration(); | |
| 2161 if (cd && thiscd && cd->isBaseOf(thiscd, NULL) && sc->func->needThis()) | |
| 2162 { | |
| 2163 // We need to add an implicit 'this' if cd is this class or a base class. | |
| 2164 DotTypeExp *dte; | |
| 2165 | |
| 2166 dte = new DotTypeExp(loc, new ThisExp(loc), s); | |
| 2167 return dte->semantic(sc); | |
| 2168 } | |
| 2169 imp = s->isImport(); | |
| 2170 if (imp) | |
| 2171 { | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
2172 if (!imp->pkg) |
|
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
2173 { error("forward reference of import %s", imp->toChars()); |
|
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
2174 return this; |
|
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
2175 } |
|
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
2176 ScopeExp *ie = new ScopeExp(loc, imp->pkg); |
| 159 | 2177 return ie->semantic(sc); |
| 2178 } | |
| 2179 pkg = s->isPackage(); | |
| 2180 if (pkg) | |
| 2181 { | |
| 2182 ScopeExp *ie; | |
| 2183 | |
| 2184 ie = new ScopeExp(loc, pkg); | |
| 2185 return ie->semantic(sc); | |
| 2186 } | |
| 2187 Module *mod = s->isModule(); | |
| 2188 if (mod) | |
| 2189 { | |
| 2190 ScopeExp *ie; | |
| 2191 | |
| 2192 ie = new ScopeExp(loc, mod); | |
| 2193 return ie->semantic(sc); | |
| 2194 } | |
| 2195 | |
| 2196 t = s->getType(); | |
| 2197 if (t) | |
| 2198 { | |
| 2199 return new TypeExp(loc, t); | |
| 2200 } | |
| 2201 | |
| 2202 TupleDeclaration *tup = s->isTupleDeclaration(); | |
| 2203 if (tup) | |
| 2204 { | |
| 2205 e = new TupleExp(loc, tup); | |
| 2206 e = e->semantic(sc); | |
| 2207 return e; | |
| 2208 } | |
| 2209 | |
| 2210 TemplateInstance *ti = s->isTemplateInstance(); | |
| 2211 if (ti && !global.errors) | |
| 2212 { if (!ti->semanticdone) | |
| 2213 ti->semantic(sc); | |
| 2214 s = ti->inst->toAlias(); | |
| 2215 if (!s->isTemplateInstance()) | |
| 2216 goto Lagain; | |
| 2217 e = new ScopeExp(loc, ti); | |
| 2218 e = e->semantic(sc); | |
| 2219 return e; | |
| 2220 } | |
| 2221 | |
| 2222 TemplateDeclaration *td = s->isTemplateDeclaration(); | |
| 2223 if (td) | |
| 2224 { | |
| 2225 e = new TemplateExp(loc, td); | |
| 2226 e = e->semantic(sc); | |
| 2227 return e; | |
| 2228 } | |
| 2229 | |
| 2230 Lerr: | |
| 2231 error("%s '%s' is not a variable", s->kind(), s->toChars()); | |
| 2232 type = Type::terror; | |
| 2233 return this; | |
| 2234 } | |
| 2235 | |
| 2236 char *DsymbolExp::toChars() | |
| 2237 { | |
| 2238 return s->toChars(); | |
| 2239 } | |
| 2240 | |
| 2241 void DsymbolExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2242 { | |
| 2243 buf->writestring(s->toChars()); | |
| 2244 } | |
| 2245 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2246 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2247 int DsymbolExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2248 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2249 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2250 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2251 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2252 |
| 159 | 2253 Expression *DsymbolExp::toLvalue(Scope *sc, Expression *e) |
| 2254 { | |
| 2255 #if 0 | |
| 2256 tym = tybasic(e1->ET->Tty); | |
| 2257 if (!(tyscalar(tym) || | |
| 2258 tym == TYstruct || | |
| 2259 tym == TYarray && e->Eoper == TOKaddr)) | |
| 2260 synerr(EM_lvalue); // lvalue expected | |
| 2261 #endif | |
| 2262 return this; | |
| 2263 } | |
| 2264 | |
| 2265 /******************************** ThisExp **************************/ | |
| 2266 | |
| 2267 ThisExp::ThisExp(Loc loc) | |
| 2268 : Expression(loc, TOKthis, sizeof(ThisExp)) | |
| 2269 { | |
| 2270 var = NULL; | |
| 2271 } | |
| 2272 | |
| 2273 Expression *ThisExp::semantic(Scope *sc) | |
| 2274 { FuncDeclaration *fd; | |
| 2275 FuncDeclaration *fdthis; | |
| 2276 int nested = 0; | |
| 2277 | |
| 2278 #if LOGSEMANTIC | |
| 2279 printf("ThisExp::semantic()\n"); | |
| 2280 #endif | |
| 2281 if (type) | |
| 2282 { //assert(global.errors || var); | |
| 2283 return this; | |
| 2284 } | |
| 2285 | |
| 2286 /* Special case for typeof(this) and typeof(super) since both | |
| 2287 * should work even if they are not inside a non-static member function | |
| 2288 */ | |
| 2289 if (sc->intypeof) | |
| 2290 { | |
| 2291 // Find enclosing struct or class | |
| 2292 for (Dsymbol *s = sc->parent; 1; s = s->parent) | |
| 2293 { | |
| 2294 ClassDeclaration *cd; | |
| 2295 StructDeclaration *sd; | |
| 2296 | |
| 2297 if (!s) | |
| 2298 { | |
| 2299 error("%s is not in a struct or class scope", toChars()); | |
| 2300 goto Lerr; | |
| 2301 } | |
| 2302 cd = s->isClassDeclaration(); | |
| 2303 if (cd) | |
| 2304 { | |
| 2305 type = cd->type; | |
| 2306 return this; | |
| 2307 } | |
| 2308 sd = s->isStructDeclaration(); | |
| 2309 if (sd) | |
| 2310 { | |
| 2311 type = sd->type->pointerTo(); | |
| 2312 return this; | |
| 2313 } | |
| 2314 } | |
| 2315 } | |
| 2316 | |
| 2317 fdthis = sc->parent->isFuncDeclaration(); | |
| 2318 fd = hasThis(sc); // fd is the uplevel function with the 'this' variable | |
| 2319 if (!fd) | |
| 2320 goto Lerr; | |
| 2321 | |
| 2322 assert(fd->vthis); | |
| 2323 var = fd->vthis; | |
| 2324 assert(var->parent); | |
| 2325 type = var->type; | |
| 2326 var->isVarDeclaration()->checkNestedReference(sc, loc); | |
| 2327 #if 0 | |
| 2328 if (fd != fdthis) // if nested | |
| 2329 { | |
| 2330 fdthis->getLevel(loc, fd); | |
| 2331 fd->vthis->nestedref = 1; | |
| 2332 fd->nestedFrameRef = 1; | |
| 2333 } | |
| 2334 #endif | |
| 336 | 2335 if (!sc->intypeof) |
| 2336 sc->callSuper |= CSXthis; | |
| 159 | 2337 return this; |
| 2338 | |
| 2339 Lerr: | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
2340 error("'this' is only defined in non-static member functions, not %s", sc->parent->toChars()); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
2341 type = Type::terror; |
| 159 | 2342 return this; |
| 2343 } | |
| 2344 | |
| 2345 int ThisExp::isBool(int result) | |
| 2346 { | |
| 2347 return result ? TRUE : FALSE; | |
| 2348 } | |
| 2349 | |
| 2350 void ThisExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2351 { | |
| 2352 buf->writestring("this"); | |
| 2353 } | |
| 2354 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2355 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2356 int ThisExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2357 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2358 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2359 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2360 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2361 |
| 159 | 2362 Expression *ThisExp::toLvalue(Scope *sc, Expression *e) |
| 2363 { | |
| 2364 return this; | |
| 2365 } | |
| 2366 | |
| 2367 /******************************** SuperExp **************************/ | |
| 2368 | |
| 2369 SuperExp::SuperExp(Loc loc) | |
| 2370 : ThisExp(loc) | |
| 2371 { | |
| 2372 op = TOKsuper; | |
| 2373 } | |
| 2374 | |
| 2375 Expression *SuperExp::semantic(Scope *sc) | |
| 2376 { FuncDeclaration *fd; | |
| 2377 FuncDeclaration *fdthis; | |
| 2378 ClassDeclaration *cd; | |
| 2379 Dsymbol *s; | |
| 2380 | |
| 2381 #if LOGSEMANTIC | |
| 2382 printf("SuperExp::semantic('%s')\n", toChars()); | |
| 2383 #endif | |
| 2384 if (type) | |
| 2385 return this; | |
| 2386 | |
| 2387 /* Special case for typeof(this) and typeof(super) since both | |
| 2388 * should work even if they are not inside a non-static member function | |
| 2389 */ | |
| 2390 if (sc->intypeof) | |
| 2391 { | |
| 2392 // Find enclosing class | |
| 2393 for (Dsymbol *s = sc->parent; 1; s = s->parent) | |
| 2394 { | |
| 2395 ClassDeclaration *cd; | |
| 2396 | |
| 2397 if (!s) | |
| 2398 { | |
| 2399 error("%s is not in a class scope", toChars()); | |
| 2400 goto Lerr; | |
| 2401 } | |
| 2402 cd = s->isClassDeclaration(); | |
| 2403 if (cd) | |
| 2404 { | |
| 2405 cd = cd->baseClass; | |
| 2406 if (!cd) | |
| 2407 { error("class %s has no 'super'", s->toChars()); | |
| 2408 goto Lerr; | |
| 2409 } | |
| 2410 type = cd->type; | |
| 2411 return this; | |
| 2412 } | |
| 2413 } | |
| 2414 } | |
| 2415 | |
| 2416 fdthis = sc->parent->isFuncDeclaration(); | |
| 2417 fd = hasThis(sc); | |
| 2418 if (!fd) | |
| 2419 goto Lerr; | |
| 2420 assert(fd->vthis); | |
| 2421 var = fd->vthis; | |
| 2422 assert(var->parent); | |
| 2423 | |
| 2424 s = fd->toParent(); | |
| 2425 while (s && s->isTemplateInstance()) | |
| 2426 s = s->toParent(); | |
| 2427 assert(s); | |
| 2428 cd = s->isClassDeclaration(); | |
| 2429 //printf("parent is %s %s\n", fd->toParent()->kind(), fd->toParent()->toChars()); | |
| 2430 if (!cd) | |
| 2431 goto Lerr; | |
| 2432 if (!cd->baseClass) | |
| 2433 { | |
| 2434 error("no base class for %s", cd->toChars()); | |
| 2435 type = fd->vthis->type; | |
| 2436 } | |
| 2437 else | |
| 2438 { | |
| 2439 type = cd->baseClass->type; | |
| 2440 } | |
| 2441 | |
| 2442 var->isVarDeclaration()->checkNestedReference(sc, loc); | |
| 2443 #if 0 | |
| 2444 if (fd != fdthis) | |
| 2445 { | |
| 2446 fdthis->getLevel(loc, fd); | |
| 2447 fd->vthis->nestedref = 1; | |
| 2448 fd->nestedFrameRef = 1; | |
| 2449 } | |
| 2450 #endif | |
| 2451 | |
| 336 | 2452 if (!sc->intypeof) |
| 2453 sc->callSuper |= CSXsuper; | |
| 159 | 2454 return this; |
| 2455 | |
| 2456 | |
| 2457 Lerr: | |
| 2458 error("'super' is only allowed in non-static class member functions"); | |
| 2459 type = Type::tint32; | |
| 2460 return this; | |
| 2461 } | |
| 2462 | |
| 2463 void SuperExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2464 { | |
| 2465 buf->writestring("super"); | |
| 2466 } | |
| 2467 | |
| 2468 | |
| 2469 /******************************** NullExp **************************/ | |
| 2470 | |
| 2471 NullExp::NullExp(Loc loc) | |
| 2472 : Expression(loc, TOKnull, sizeof(NullExp)) | |
| 2473 { | |
| 2474 committed = 0; | |
| 2475 } | |
| 2476 | |
| 2477 Expression *NullExp::semantic(Scope *sc) | |
| 2478 { | |
| 2479 #if LOGSEMANTIC | |
| 2480 printf("NullExp::semantic('%s')\n", toChars()); | |
| 2481 #endif | |
| 2482 // NULL is the same as (void *)0 | |
| 2483 if (!type) | |
| 2484 type = Type::tvoid->pointerTo(); | |
| 2485 return this; | |
| 2486 } | |
| 2487 | |
| 2488 int NullExp::isBool(int result) | |
| 2489 { | |
| 2490 return result ? FALSE : TRUE; | |
| 2491 } | |
| 2492 | |
| 2493 void NullExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2494 { | |
| 2495 buf->writestring("null"); | |
| 2496 } | |
| 2497 | |
| 2498 void NullExp::toMangleBuffer(OutBuffer *buf) | |
| 2499 { | |
| 2500 buf->writeByte('n'); | |
| 2501 } | |
| 2502 | |
| 2503 /******************************** StringExp **************************/ | |
| 2504 | |
| 2505 StringExp::StringExp(Loc loc, char *string) | |
| 2506 : Expression(loc, TOKstring, sizeof(StringExp)) | |
| 2507 { | |
| 2508 this->string = string; | |
| 2509 this->len = strlen(string); | |
| 2510 this->sz = 1; | |
| 2511 this->committed = 0; | |
| 2512 this->postfix = 0; | |
| 2513 } | |
| 2514 | |
| 2515 StringExp::StringExp(Loc loc, void *string, size_t len) | |
| 2516 : Expression(loc, TOKstring, sizeof(StringExp)) | |
| 2517 { | |
| 2518 this->string = string; | |
| 2519 this->len = len; | |
| 2520 this->sz = 1; | |
| 2521 this->committed = 0; | |
| 2522 this->postfix = 0; | |
| 2523 } | |
| 2524 | |
| 2525 StringExp::StringExp(Loc loc, void *string, size_t len, unsigned char postfix) | |
| 2526 : Expression(loc, TOKstring, sizeof(StringExp)) | |
| 2527 { | |
| 2528 this->string = string; | |
| 2529 this->len = len; | |
| 2530 this->sz = 1; | |
| 2531 this->committed = 0; | |
| 2532 this->postfix = postfix; | |
| 2533 } | |
| 2534 | |
| 2535 #if 0 | |
| 2536 Expression *StringExp::syntaxCopy() | |
| 2537 { | |
| 2538 printf("StringExp::syntaxCopy() %s\n", toChars()); | |
| 2539 return copy(); | |
| 2540 } | |
| 2541 #endif | |
| 2542 | |
| 2543 int StringExp::equals(Object *o) | |
| 2544 { | |
| 2545 //printf("StringExp::equals('%s')\n", o->toChars()); | |
| 2546 if (o && o->dyncast() == DYNCAST_EXPRESSION) | |
| 2547 { Expression *e = (Expression *)o; | |
| 2548 | |
| 2549 if (e->op == TOKstring) | |
| 2550 { | |
| 2551 return compare(o) == 0; | |
| 2552 } | |
| 2553 } | |
| 2554 return FALSE; | |
| 2555 } | |
| 2556 | |
| 2557 char *StringExp::toChars() | |
| 2558 { | |
| 2559 OutBuffer buf; | |
| 2560 HdrGenState hgs; | |
| 2561 char *p; | |
| 2562 | |
| 2563 memset(&hgs, 0, sizeof(hgs)); | |
| 2564 toCBuffer(&buf, &hgs); | |
| 2565 buf.writeByte(0); | |
| 2566 p = (char *)buf.data; | |
| 2567 buf.data = NULL; | |
| 2568 return p; | |
| 2569 } | |
| 2570 | |
| 2571 Expression *StringExp::semantic(Scope *sc) | |
| 2572 { | |
| 2573 #if LOGSEMANTIC | |
| 2574 printf("StringExp::semantic() %s\n", toChars()); | |
| 2575 #endif | |
| 2576 if (!type) | |
| 2577 { OutBuffer buffer; | |
| 2578 size_t newlen = 0; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2579 const char *p; |
| 159 | 2580 size_t u; |
| 2581 unsigned c; | |
| 2582 | |
| 2583 switch (postfix) | |
| 2584 { | |
| 2585 case 'd': | |
| 2586 for (u = 0; u < len;) | |
| 2587 { | |
| 2588 p = utf_decodeChar((unsigned char *)string, len, &u, &c); | |
| 2589 if (p) | |
| 2590 { error("%s", p); | |
| 2591 break; | |
| 2592 } | |
| 2593 else | |
| 2594 { buffer.write4(c); | |
| 2595 newlen++; | |
| 2596 } | |
| 2597 } | |
| 2598 buffer.write4(0); | |
| 2599 string = buffer.extractData(); | |
| 2600 len = newlen; | |
| 2601 sz = 4; | |
| 2602 type = new TypeSArray(Type::tdchar, new IntegerExp(loc, len, Type::tindex)); | |
| 2603 committed = 1; | |
| 2604 break; | |
| 2605 | |
| 2606 case 'w': | |
| 2607 for (u = 0; u < len;) | |
| 2608 { | |
| 2609 p = utf_decodeChar((unsigned char *)string, len, &u, &c); | |
| 2610 if (p) | |
| 2611 { error("%s", p); | |
| 2612 break; | |
| 2613 } | |
| 2614 else | |
| 2615 { buffer.writeUTF16(c); | |
| 2616 newlen++; | |
| 2617 if (c >= 0x10000) | |
| 2618 newlen++; | |
| 2619 } | |
| 2620 } | |
| 2621 buffer.writeUTF16(0); | |
| 2622 string = buffer.extractData(); | |
| 2623 len = newlen; | |
| 2624 sz = 2; | |
| 2625 type = new TypeSArray(Type::twchar, new IntegerExp(loc, len, Type::tindex)); | |
| 2626 committed = 1; | |
| 2627 break; | |
| 2628 | |
| 2629 case 'c': | |
| 2630 committed = 1; | |
| 2631 default: | |
| 2632 type = new TypeSArray(Type::tchar, new IntegerExp(loc, len, Type::tindex)); | |
| 2633 break; | |
| 2634 } | |
| 2635 type = type->semantic(loc, sc); | |
| 2636 } | |
| 2637 return this; | |
| 2638 } | |
| 2639 | |
| 2640 /**************************************** | |
| 2641 * Convert string to char[]. | |
| 2642 */ | |
| 2643 | |
| 2644 StringExp *StringExp::toUTF8(Scope *sc) | |
| 2645 { | |
| 2646 if (sz != 1) | |
| 2647 { // Convert to UTF-8 string | |
| 2648 committed = 0; | |
| 2649 Expression *e = castTo(sc, Type::tchar->arrayOf()); | |
| 2650 e = e->optimize(WANTvalue); | |
| 2651 assert(e->op == TOKstring); | |
| 2652 StringExp *se = (StringExp *)e; | |
| 2653 assert(se->sz == 1); | |
| 2654 return se; | |
| 2655 } | |
| 2656 return this; | |
| 2657 } | |
| 2658 | |
| 2659 int StringExp::compare(Object *obj) | |
| 2660 { | |
| 2661 // Used to sort case statement expressions so we can do an efficient lookup | |
| 2662 StringExp *se2 = (StringExp *)(obj); | |
| 2663 | |
| 2664 // This is a kludge so isExpression() in template.c will return 5 | |
| 2665 // for StringExp's. | |
| 2666 if (!se2) | |
| 2667 return 5; | |
| 2668 | |
| 2669 assert(se2->op == TOKstring); | |
| 2670 | |
| 2671 int len1 = len; | |
| 2672 int len2 = se2->len; | |
| 2673 | |
| 2674 if (len1 == len2) | |
| 2675 { | |
| 2676 switch (sz) | |
| 2677 { | |
| 2678 case 1: | |
| 2679 return strcmp((char *)string, (char *)se2->string); | |
| 2680 | |
| 2681 case 2: | |
| 2682 { unsigned u; | |
| 2683 d_wchar *s1 = (d_wchar *)string; | |
| 2684 d_wchar *s2 = (d_wchar *)se2->string; | |
| 2685 | |
| 2686 for (u = 0; u < len; u++) | |
| 2687 { | |
| 2688 if (s1[u] != s2[u]) | |
| 2689 return s1[u] - s2[u]; | |
| 2690 } | |
| 2691 } | |
| 2692 | |
| 2693 case 4: | |
| 2694 { unsigned u; | |
| 2695 d_dchar *s1 = (d_dchar *)string; | |
| 2696 d_dchar *s2 = (d_dchar *)se2->string; | |
| 2697 | |
| 2698 for (u = 0; u < len; u++) | |
| 2699 { | |
| 2700 if (s1[u] != s2[u]) | |
| 2701 return s1[u] - s2[u]; | |
| 2702 } | |
| 2703 } | |
| 2704 break; | |
| 2705 | |
| 2706 default: | |
| 2707 assert(0); | |
| 2708 } | |
| 2709 } | |
| 2710 return len1 - len2; | |
| 2711 } | |
| 2712 | |
| 2713 int StringExp::isBool(int result) | |
| 2714 { | |
| 2715 return result ? TRUE : FALSE; | |
| 2716 } | |
| 2717 | |
| 2718 unsigned StringExp::charAt(size_t i) | |
| 2719 { unsigned value; | |
| 2720 | |
| 2721 switch (sz) | |
| 2722 { | |
| 2723 case 1: | |
| 2724 value = ((unsigned char *)string)[i]; | |
| 2725 break; | |
| 2726 | |
| 2727 case 2: | |
| 2728 value = ((unsigned short *)string)[i]; | |
| 2729 break; | |
| 2730 | |
| 2731 case 4: | |
| 2732 value = ((unsigned int *)string)[i]; | |
| 2733 break; | |
| 2734 | |
| 2735 default: | |
| 2736 assert(0); | |
| 2737 break; | |
| 2738 } | |
| 2739 return value; | |
| 2740 } | |
| 2741 | |
| 2742 void StringExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2743 { | |
| 2744 buf->writeByte('"'); | |
| 2745 for (size_t i = 0; i < len; i++) | |
| 2746 { unsigned c = charAt(i); | |
| 2747 | |
| 2748 switch (c) | |
| 2749 { | |
| 2750 case '"': | |
| 2751 case '\\': | |
| 2752 if (!hgs->console) | |
| 2753 buf->writeByte('\\'); | |
| 2754 default: | |
| 2755 if (c <= 0xFF) | |
| 2756 { if (c <= 0x7F && (isprint(c) || hgs->console)) | |
| 2757 buf->writeByte(c); | |
| 2758 else | |
| 2759 buf->printf("\\x%02x", c); | |
| 2760 } | |
| 2761 else if (c <= 0xFFFF) | |
| 2762 buf->printf("\\x%02x\\x%02x", c & 0xFF, c >> 8); | |
| 2763 else | |
| 2764 buf->printf("\\x%02x\\x%02x\\x%02x\\x%02x", | |
| 2765 c & 0xFF, (c >> 8) & 0xFF, (c >> 16) & 0xFF, c >> 24); | |
| 2766 break; | |
| 2767 } | |
| 2768 } | |
| 2769 buf->writeByte('"'); | |
| 2770 if (postfix) | |
| 2771 buf->writeByte(postfix); | |
| 2772 } | |
| 2773 | |
| 2774 void StringExp::toMangleBuffer(OutBuffer *buf) | |
| 2775 { char m; | |
| 2776 OutBuffer tmp; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2777 const char *p; |
| 159 | 2778 unsigned c; |
| 2779 size_t u; | |
| 2780 unsigned char *q; | |
| 2781 unsigned qlen; | |
| 2782 | |
| 2783 /* Write string in UTF-8 format | |
| 2784 */ | |
| 2785 switch (sz) | |
| 2786 { case 1: | |
| 2787 m = 'a'; | |
| 2788 q = (unsigned char *)string; | |
| 2789 qlen = len; | |
| 2790 break; | |
| 2791 case 2: | |
| 2792 m = 'w'; | |
| 2793 for (u = 0; u < len; ) | |
| 2794 { | |
| 2795 p = utf_decodeWchar((unsigned short *)string, len, &u, &c); | |
| 2796 if (p) | |
| 2797 error("%s", p); | |
| 2798 else | |
| 2799 tmp.writeUTF8(c); | |
| 2800 } | |
| 2801 q = tmp.data; | |
| 2802 qlen = tmp.offset; | |
| 2803 break; | |
| 2804 case 4: | |
| 2805 m = 'd'; | |
| 2806 for (u = 0; u < len; u++) | |
| 2807 { | |
| 2808 c = ((unsigned *)string)[u]; | |
| 2809 if (!utf_isValidDchar(c)) | |
| 2810 error("invalid UCS-32 char \\U%08x", c); | |
| 2811 else | |
| 2812 tmp.writeUTF8(c); | |
| 2813 } | |
| 2814 q = tmp.data; | |
| 2815 qlen = tmp.offset; | |
| 2816 break; | |
| 2817 default: | |
| 2818 assert(0); | |
| 2819 } | |
| 2820 buf->writeByte(m); | |
| 2821 buf->printf("%d_", qlen); | |
| 2822 for (size_t i = 0; i < qlen; i++) | |
| 2823 buf->printf("%02x", q[i]); | |
| 2824 } | |
| 2825 | |
| 2826 /************************ ArrayLiteralExp ************************************/ | |
| 2827 | |
| 2828 // [ e1, e2, e3, ... ] | |
| 2829 | |
| 2830 ArrayLiteralExp::ArrayLiteralExp(Loc loc, Expressions *elements) | |
| 2831 : Expression(loc, TOKarrayliteral, sizeof(ArrayLiteralExp)) | |
| 2832 { | |
| 2833 this->elements = elements; | |
| 2834 } | |
| 2835 | |
| 2836 ArrayLiteralExp::ArrayLiteralExp(Loc loc, Expression *e) | |
| 2837 : Expression(loc, TOKarrayliteral, sizeof(ArrayLiteralExp)) | |
| 2838 { | |
| 2839 elements = new Expressions; | |
| 2840 elements->push(e); | |
| 2841 } | |
| 2842 | |
| 2843 Expression *ArrayLiteralExp::syntaxCopy() | |
| 2844 { | |
| 2845 return new ArrayLiteralExp(loc, arraySyntaxCopy(elements)); | |
| 2846 } | |
| 2847 | |
| 2848 Expression *ArrayLiteralExp::semantic(Scope *sc) | |
| 2849 { Expression *e; | |
| 2850 Type *t0 = NULL; | |
| 2851 | |
| 2852 #if LOGSEMANTIC | |
| 2853 printf("ArrayLiteralExp::semantic('%s')\n", toChars()); | |
| 2854 #endif | |
| 2855 if (type) | |
| 2856 return this; | |
| 2857 | |
| 2858 // Run semantic() on each element | |
| 2859 for (int i = 0; i < elements->dim; i++) | |
| 2860 { e = (Expression *)elements->data[i]; | |
| 2861 e = e->semantic(sc); | |
| 2862 elements->data[i] = (void *)e; | |
| 2863 } | |
| 2864 expandTuples(elements); | |
| 2865 for (int i = 0; i < elements->dim; i++) | |
| 2866 { e = (Expression *)elements->data[i]; | |
| 2867 | |
| 2868 if (!e->type) | |
| 2869 error("%s has no value", e->toChars()); | |
| 2870 e = resolveProperties(sc, e); | |
| 2871 | |
| 2872 unsigned char committed = 1; | |
| 2873 if (e->op == TOKstring) | |
| 2874 committed = ((StringExp *)e)->committed; | |
| 2875 | |
| 2876 if (!t0) | |
| 2877 { t0 = e->type; | |
| 2878 // Convert any static arrays to dynamic arrays | |
| 2879 if (t0->ty == Tsarray) | |
| 2880 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
2881 t0 = ((TypeSArray *)t0)->next->arrayOf(); |
| 159 | 2882 e = e->implicitCastTo(sc, t0); |
| 2883 } | |
| 2884 } | |
| 2885 else | |
| 2886 e = e->implicitCastTo(sc, t0); | |
| 2887 if (!committed && e->op == TOKstring) | |
| 2888 { StringExp *se = (StringExp *)e; | |
| 2889 se->committed = 0; | |
| 2890 } | |
| 2891 elements->data[i] = (void *)e; | |
| 2892 } | |
| 2893 | |
| 2894 if (!t0) | |
| 2895 t0 = Type::tvoid; | |
| 2896 type = new TypeSArray(t0, new IntegerExp(elements->dim)); | |
| 2897 type = type->semantic(loc, sc); | |
| 2898 return this; | |
| 2899 } | |
| 2900 | |
| 2901 int ArrayLiteralExp::checkSideEffect(int flag) | |
| 2902 { int f = 0; | |
| 2903 | |
| 2904 for (size_t i = 0; i < elements->dim; i++) | |
| 2905 { Expression *e = (Expression *)elements->data[i]; | |
| 2906 | |
| 2907 f |= e->checkSideEffect(2); | |
| 2908 } | |
| 2909 if (flag == 0 && f == 0) | |
| 2910 Expression::checkSideEffect(0); | |
| 2911 return f; | |
| 2912 } | |
| 2913 | |
| 2914 int ArrayLiteralExp::isBool(int result) | |
| 2915 { | |
| 2916 size_t dim = elements ? elements->dim : 0; | |
| 2917 return result ? (dim != 0) : (dim == 0); | |
| 2918 } | |
| 2919 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2920 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2921 int ArrayLiteralExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2922 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2923 return 1; // because it can fail allocating memory |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2924 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2925 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2926 |
| 159 | 2927 void ArrayLiteralExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 2928 { | |
| 2929 buf->writeByte('['); | |
| 2930 argsToCBuffer(buf, elements, hgs); | |
| 2931 buf->writeByte(']'); | |
| 2932 } | |
| 2933 | |
| 2934 void ArrayLiteralExp::toMangleBuffer(OutBuffer *buf) | |
| 2935 { | |
| 2936 size_t dim = elements ? elements->dim : 0; | |
|
1372
229e02867307
Fix format-string bugs by adding __attribute__((__format__)) in all applicable
Frits van Bommel <fvbommel wxs.nl>
parents:
1367
diff
changeset
|
2937 buf->printf("A%zu", dim); |
| 159 | 2938 for (size_t i = 0; i < dim; i++) |
| 2939 { Expression *e = (Expression *)elements->data[i]; | |
| 2940 e->toMangleBuffer(buf); | |
| 2941 } | |
| 2942 } | |
| 2943 | |
| 2944 /************************ AssocArrayLiteralExp ************************************/ | |
| 2945 | |
| 2946 // [ key0 : value0, key1 : value1, ... ] | |
| 2947 | |
| 2948 AssocArrayLiteralExp::AssocArrayLiteralExp(Loc loc, | |
| 2949 Expressions *keys, Expressions *values) | |
| 2950 : Expression(loc, TOKassocarrayliteral, sizeof(AssocArrayLiteralExp)) | |
| 2951 { | |
| 2952 assert(keys->dim == values->dim); | |
| 2953 this->keys = keys; | |
| 2954 this->values = values; | |
| 2955 } | |
| 2956 | |
| 2957 Expression *AssocArrayLiteralExp::syntaxCopy() | |
| 2958 { | |
| 2959 return new AssocArrayLiteralExp(loc, | |
| 2960 arraySyntaxCopy(keys), arraySyntaxCopy(values)); | |
| 2961 } | |
| 2962 | |
| 2963 Expression *AssocArrayLiteralExp::semantic(Scope *sc) | |
| 2964 { Expression *e; | |
| 2965 Type *tkey = NULL; | |
| 2966 Type *tvalue = NULL; | |
| 2967 | |
| 2968 #if LOGSEMANTIC | |
| 2969 printf("AssocArrayLiteralExp::semantic('%s')\n", toChars()); | |
| 2970 #endif | |
| 2971 | |
| 2972 // Run semantic() on each element | |
| 2973 for (size_t i = 0; i < keys->dim; i++) | |
| 2974 { Expression *key = (Expression *)keys->data[i]; | |
| 2975 Expression *value = (Expression *)values->data[i]; | |
| 2976 | |
| 2977 key = key->semantic(sc); | |
| 2978 value = value->semantic(sc); | |
| 2979 | |
| 2980 keys->data[i] = (void *)key; | |
| 2981 values->data[i] = (void *)value; | |
| 2982 } | |
| 2983 expandTuples(keys); | |
| 2984 expandTuples(values); | |
| 2985 if (keys->dim != values->dim) | |
| 2986 { | |
| 2987 error("number of keys is %u, must match number of values %u", keys->dim, values->dim); | |
| 2988 keys->setDim(0); | |
| 2989 values->setDim(0); | |
| 2990 } | |
| 2991 for (size_t i = 0; i < keys->dim; i++) | |
| 2992 { Expression *key = (Expression *)keys->data[i]; | |
| 2993 Expression *value = (Expression *)values->data[i]; | |
| 2994 | |
| 2995 if (!key->type) | |
| 2996 error("%s has no value", key->toChars()); | |
| 2997 if (!value->type) | |
| 2998 error("%s has no value", value->toChars()); | |
| 2999 key = resolveProperties(sc, key); | |
| 3000 value = resolveProperties(sc, value); | |
| 3001 | |
| 3002 if (!tkey) | |
| 3003 tkey = key->type; | |
| 3004 else | |
| 3005 key = key->implicitCastTo(sc, tkey); | |
| 3006 keys->data[i] = (void *)key; | |
| 3007 | |
| 3008 if (!tvalue) | |
| 3009 tvalue = value->type; | |
| 3010 else | |
| 3011 value = value->implicitCastTo(sc, tvalue); | |
| 3012 values->data[i] = (void *)value; | |
| 3013 } | |
| 3014 | |
| 3015 if (!tkey) | |
| 3016 tkey = Type::tvoid; | |
| 3017 if (!tvalue) | |
| 3018 tvalue = Type::tvoid; | |
| 3019 type = new TypeAArray(tvalue, tkey); | |
| 3020 type = type->semantic(loc, sc); | |
| 3021 return this; | |
| 3022 } | |
| 3023 | |
| 3024 int AssocArrayLiteralExp::checkSideEffect(int flag) | |
| 3025 { int f = 0; | |
| 3026 | |
| 3027 for (size_t i = 0; i < keys->dim; i++) | |
| 3028 { Expression *key = (Expression *)keys->data[i]; | |
| 3029 Expression *value = (Expression *)values->data[i]; | |
| 3030 | |
| 3031 f |= key->checkSideEffect(2); | |
| 3032 f |= value->checkSideEffect(2); | |
| 3033 } | |
| 3034 if (flag == 0 && f == 0) | |
| 3035 Expression::checkSideEffect(0); | |
| 3036 return f; | |
| 3037 } | |
| 3038 | |
| 3039 int AssocArrayLiteralExp::isBool(int result) | |
| 3040 { | |
| 3041 size_t dim = keys->dim; | |
| 3042 return result ? (dim != 0) : (dim == 0); | |
| 3043 } | |
| 3044 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3045 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3046 int AssocArrayLiteralExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3047 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3048 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3049 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3050 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3051 |
| 159 | 3052 void AssocArrayLiteralExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 3053 { | |
| 3054 buf->writeByte('['); | |
| 3055 for (size_t i = 0; i < keys->dim; i++) | |
| 3056 { Expression *key = (Expression *)keys->data[i]; | |
| 3057 Expression *value = (Expression *)values->data[i]; | |
| 3058 | |
| 3059 if (i) | |
| 3060 buf->writeByte(','); | |
| 3061 expToCBuffer(buf, hgs, key, PREC_assign); | |
| 3062 buf->writeByte(':'); | |
| 3063 expToCBuffer(buf, hgs, value, PREC_assign); | |
| 3064 } | |
| 3065 buf->writeByte(']'); | |
| 3066 } | |
| 3067 | |
| 3068 void AssocArrayLiteralExp::toMangleBuffer(OutBuffer *buf) | |
| 3069 { | |
| 3070 size_t dim = keys->dim; | |
|
1372
229e02867307
Fix format-string bugs by adding __attribute__((__format__)) in all applicable
Frits van Bommel <fvbommel wxs.nl>
parents:
1367
diff
changeset
|
3071 buf->printf("A%zu", dim); |
| 159 | 3072 for (size_t i = 0; i < dim; i++) |
| 3073 { Expression *key = (Expression *)keys->data[i]; | |
| 3074 Expression *value = (Expression *)values->data[i]; | |
| 3075 | |
| 3076 key->toMangleBuffer(buf); | |
| 3077 value->toMangleBuffer(buf); | |
| 3078 } | |
| 3079 } | |
| 3080 | |
| 3081 /************************ StructLiteralExp ************************************/ | |
| 3082 | |
| 3083 // sd( e1, e2, e3, ... ) | |
| 3084 | |
| 3085 StructLiteralExp::StructLiteralExp(Loc loc, StructDeclaration *sd, Expressions *elements) | |
| 3086 : Expression(loc, TOKstructliteral, sizeof(StructLiteralExp)) | |
| 3087 { | |
| 3088 this->sd = sd; | |
| 3089 this->elements = elements; | |
|
1146
1860414bf3b7
* Moved ir/irsymbol.cpp/h into ir/irdsymbol.cpp/h.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1133
diff
changeset
|
3090 #if IN_DMD |
| 159 | 3091 this->sym = NULL; |
|
1146
1860414bf3b7
* Moved ir/irsymbol.cpp/h into ir/irdsymbol.cpp/h.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1133
diff
changeset
|
3092 #endif |
| 159 | 3093 this->soffset = 0; |
| 3094 this->fillHoles = 1; | |
| 3095 } | |
| 3096 | |
| 3097 Expression *StructLiteralExp::syntaxCopy() | |
| 3098 { | |
| 3099 return new StructLiteralExp(loc, sd, arraySyntaxCopy(elements)); | |
| 3100 } | |
| 3101 | |
| 3102 Expression *StructLiteralExp::semantic(Scope *sc) | |
| 3103 { Expression *e; | |
| 3104 | |
| 3105 #if LOGSEMANTIC | |
| 3106 printf("StructLiteralExp::semantic('%s')\n", toChars()); | |
| 3107 #endif | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3108 if (type) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3109 return this; |
| 159 | 3110 |
| 3111 // Run semantic() on each element | |
| 3112 for (size_t i = 0; i < elements->dim; i++) | |
| 3113 { e = (Expression *)elements->data[i]; | |
| 3114 if (!e) | |
| 3115 continue; | |
| 3116 e = e->semantic(sc); | |
| 3117 elements->data[i] = (void *)e; | |
| 3118 } | |
| 3119 expandTuples(elements); | |
| 3120 size_t offset = 0; | |
| 3121 for (size_t i = 0; i < elements->dim; i++) | |
| 3122 { e = (Expression *)elements->data[i]; | |
| 3123 if (!e) | |
| 3124 continue; | |
| 3125 | |
| 3126 if (!e->type) | |
| 3127 error("%s has no value", e->toChars()); | |
| 3128 e = resolveProperties(sc, e); | |
| 3129 if (i >= sd->fields.dim) | |
| 3130 { error("more initializers than fields of %s", sd->toChars()); | |
| 3131 break; | |
| 3132 } | |
| 3133 Dsymbol *s = (Dsymbol *)sd->fields.data[i]; | |
| 3134 VarDeclaration *v = s->isVarDeclaration(); | |
| 3135 assert(v); | |
| 3136 if (v->offset < offset) | |
| 3137 error("overlapping initialization for %s", v->toChars()); | |
| 3138 offset = v->offset + v->type->size(); | |
| 3139 | |
| 3140 Type *telem = v->type; | |
| 3141 while (!e->implicitConvTo(telem) && telem->toBasetype()->ty == Tsarray) | |
| 3142 { /* Static array initialization, as in: | |
| 3143 * T[3][5] = e; | |
| 3144 */ | |
| 3145 telem = telem->toBasetype()->nextOf(); | |
| 3146 } | |
| 3147 | |
| 3148 e = e->implicitCastTo(sc, telem); | |
| 3149 | |
| 3150 elements->data[i] = (void *)e; | |
| 3151 } | |
| 3152 | |
| 3153 /* Fill out remainder of elements[] with default initializers for fields[] | |
| 3154 */ | |
| 3155 for (size_t i = elements->dim; i < sd->fields.dim; i++) | |
| 3156 { Dsymbol *s = (Dsymbol *)sd->fields.data[i]; | |
| 3157 VarDeclaration *v = s->isVarDeclaration(); | |
| 3158 assert(v); | |
| 3159 | |
| 3160 if (v->offset < offset) | |
| 3161 { e = NULL; | |
| 3162 sd->hasUnions = 1; | |
| 3163 } | |
| 3164 else | |
| 3165 { | |
| 3166 if (v->init) | |
| 3167 { e = v->init->toExpression(); | |
| 3168 if (!e) | |
| 3169 error("cannot make expression out of initializer for %s", v->toChars()); | |
| 3170 } | |
| 3171 else | |
| 3172 { e = v->type->defaultInit(); | |
| 3173 e->loc = loc; | |
| 3174 } | |
| 3175 offset = v->offset + v->type->size(); | |
| 3176 } | |
| 3177 elements->push(e); | |
| 3178 } | |
| 3179 | |
| 3180 type = sd->type; | |
| 3181 return this; | |
| 3182 } | |
| 3183 | |
| 3184 /************************************** | |
| 3185 * Gets expression at offset of type. | |
| 3186 * Returns NULL if not found. | |
| 3187 */ | |
| 3188 | |
| 3189 Expression *StructLiteralExp::getField(Type *type, unsigned offset) | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3190 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3191 //printf("StructLiteralExp::getField(this = %s, type = %s, offset = %u)\n", |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3192 // /*toChars()*/"", type->toChars(), offset); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3193 Expression *e = NULL; |
| 159 | 3194 int i = getFieldIndex(type, offset); |
| 3195 | |
| 3196 if (i != -1) | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3197 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3198 //printf("\ti = %d\n", i); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3199 assert(i < elements->dim); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3200 e = (Expression *)elements->data[i]; |
| 159 | 3201 if (e) |
| 3202 { | |
| 3203 e = e->copy(); | |
| 3204 e->type = type; | |
| 3205 } | |
| 3206 } | |
| 3207 return e; | |
| 3208 } | |
| 3209 | |
| 3210 /************************************ | |
| 3211 * Get index of field. | |
| 3212 * Returns -1 if not found. | |
| 3213 */ | |
| 3214 | |
| 3215 int StructLiteralExp::getFieldIndex(Type *type, unsigned offset) | |
| 3216 { | |
| 3217 /* Find which field offset is by looking at the field offsets | |
| 3218 */ | |
| 3219 for (size_t i = 0; i < sd->fields.dim; i++) | |
| 3220 { | |
| 3221 Dsymbol *s = (Dsymbol *)sd->fields.data[i]; | |
| 3222 VarDeclaration *v = s->isVarDeclaration(); | |
| 3223 assert(v); | |
| 3224 | |
| 3225 if (offset == v->offset && | |
| 3226 type->size() == v->type->size()) | |
| 3227 { Expression *e = (Expression *)elements->data[i]; | |
| 3228 if (e) | |
| 3229 { | |
| 3230 return i; | |
| 3231 } | |
| 3232 break; | |
| 3233 } | |
| 3234 } | |
| 3235 return -1; | |
| 3236 } | |
| 3237 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3238 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3239 int StructLiteralExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3240 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3241 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3242 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3243 #endif |
| 159 | 3244 |
|
1168
ab186e535e72
A different fix to #218 and DMD2682 that does not lead to constant folding regressions.
Christian Kamm <kamm incasoftware de>
parents:
1151
diff
changeset
|
3245 /* |
|
ab186e535e72
A different fix to #218 and DMD2682 that does not lead to constant folding regressions.
Christian Kamm <kamm incasoftware de>
parents:
1151
diff
changeset
|
3246 Removed in LDC. See declaration. |
| 159 | 3247 Expression *StructLiteralExp::toLvalue(Scope *sc, Expression *e) |
| 3248 { | |
| 3249 return this; | |
| 3250 } | |
|
1168
ab186e535e72
A different fix to #218 and DMD2682 that does not lead to constant folding regressions.
Christian Kamm <kamm incasoftware de>
parents:
1151
diff
changeset
|
3251 */ |
| 159 | 3252 |
| 3253 | |
| 3254 int StructLiteralExp::checkSideEffect(int flag) | |
| 3255 { int f = 0; | |
| 3256 | |
| 3257 for (size_t i = 0; i < elements->dim; i++) | |
| 3258 { Expression *e = (Expression *)elements->data[i]; | |
| 3259 if (!e) | |
| 3260 continue; | |
| 3261 | |
| 3262 f |= e->checkSideEffect(2); | |
| 3263 } | |
| 3264 if (flag == 0 && f == 0) | |
| 3265 Expression::checkSideEffect(0); | |
| 3266 return f; | |
| 3267 } | |
| 3268 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3269 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3270 int StructLiteralExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3271 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3272 return arrayExpressionCanThrow(elements); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3273 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3274 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3275 |
| 159 | 3276 void StructLiteralExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 3277 { | |
| 3278 buf->writestring(sd->toChars()); | |
| 3279 buf->writeByte('('); | |
| 3280 argsToCBuffer(buf, elements, hgs); | |
| 3281 buf->writeByte(')'); | |
| 3282 } | |
| 3283 | |
| 3284 void StructLiteralExp::toMangleBuffer(OutBuffer *buf) | |
| 3285 { | |
| 3286 size_t dim = elements ? elements->dim : 0; | |
|
1372
229e02867307
Fix format-string bugs by adding __attribute__((__format__)) in all applicable
Frits van Bommel <fvbommel wxs.nl>
parents:
1367
diff
changeset
|
3287 buf->printf("S%zu", dim); |
| 159 | 3288 for (size_t i = 0; i < dim; i++) |
| 3289 { Expression *e = (Expression *)elements->data[i]; | |
| 3290 if (e) | |
| 3291 e->toMangleBuffer(buf); | |
| 3292 else | |
| 3293 buf->writeByte('v'); // 'v' for void | |
| 3294 } | |
| 3295 } | |
| 3296 | |
| 3297 /************************ TypeDotIdExp ************************************/ | |
| 3298 | |
| 3299 /* Things like: | |
| 3300 * int.size | |
| 3301 * foo.size | |
| 3302 * (foo).size | |
| 3303 * cast(foo).size | |
| 3304 */ | |
| 3305 | |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
3306 Expression *typeDotIdExp(Loc loc, Type *type, Identifier *ident) |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
3307 { |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
3308 return new DotIdExp(loc, new TypeExp(loc, type), ident); |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
3309 } |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
3310 |
| 159 | 3311 |
| 3312 /************************************************************/ | |
| 3313 | |
| 3314 // Mainly just a placeholder | |
| 3315 | |
| 3316 TypeExp::TypeExp(Loc loc, Type *type) | |
| 3317 : Expression(loc, TOKtype, sizeof(TypeExp)) | |
| 3318 { | |
| 3319 //printf("TypeExp::TypeExp(%s)\n", type->toChars()); | |
| 3320 this->type = type; | |
| 3321 } | |
| 3322 | |
|
876
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3323 Expression *TypeExp::syntaxCopy() |
|
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3324 { |
|
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3325 //printf("TypeExp::syntaxCopy()\n"); |
|
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3326 return new TypeExp(loc, type->syntaxCopy()); |
|
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3327 } |
|
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3328 |
| 159 | 3329 Expression *TypeExp::semantic(Scope *sc) |
| 3330 { | |
| 3331 //printf("TypeExp::semantic(%s)\n", type->toChars()); | |
| 3332 type = type->semantic(loc, sc); | |
| 3333 return this; | |
| 3334 } | |
| 3335 | |
| 3336 void TypeExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3337 { | |
| 3338 type->toCBuffer(buf, NULL, hgs); | |
| 3339 } | |
| 3340 | |
| 3341 /************************************************************/ | |
| 3342 | |
| 3343 // Mainly just a placeholder | |
| 3344 | |
| 3345 ScopeExp::ScopeExp(Loc loc, ScopeDsymbol *pkg) | |
| 3346 : Expression(loc, TOKimport, sizeof(ScopeExp)) | |
| 3347 { | |
| 3348 //printf("ScopeExp::ScopeExp(pkg = '%s')\n", pkg->toChars()); | |
| 3349 //static int count; if (++count == 38) *(char*)0=0; | |
| 3350 this->sds = pkg; | |
| 3351 } | |
| 3352 | |
| 3353 Expression *ScopeExp::syntaxCopy() | |
| 3354 { | |
| 3355 ScopeExp *se = new ScopeExp(loc, (ScopeDsymbol *)sds->syntaxCopy(NULL)); | |
| 3356 return se; | |
| 3357 } | |
| 3358 | |
| 3359 Expression *ScopeExp::semantic(Scope *sc) | |
| 3360 { | |
| 3361 TemplateInstance *ti; | |
| 3362 ScopeDsymbol *sds2; | |
| 3363 | |
| 3364 #if LOGSEMANTIC | |
| 3365 printf("+ScopeExp::semantic('%s')\n", toChars()); | |
| 3366 #endif | |
| 3367 Lagain: | |
| 3368 ti = sds->isTemplateInstance(); | |
| 3369 if (ti && !global.errors) | |
| 3370 { Dsymbol *s; | |
| 3371 if (!ti->semanticdone) | |
| 3372 ti->semantic(sc); | |
| 3373 s = ti->inst->toAlias(); | |
| 3374 sds2 = s->isScopeDsymbol(); | |
| 3375 if (!sds2) | |
| 3376 { Expression *e; | |
| 3377 | |
| 3378 //printf("s = %s, '%s'\n", s->kind(), s->toChars()); | |
| 3379 if (ti->withsym) | |
| 3380 { | |
| 3381 // Same as wthis.s | |
| 3382 e = new VarExp(loc, ti->withsym->withstate->wthis); | |
| 3383 e = new DotVarExp(loc, e, s->isDeclaration()); | |
| 3384 } | |
| 3385 else | |
| 3386 e = new DsymbolExp(loc, s); | |
| 3387 e = e->semantic(sc); | |
| 3388 //printf("-1ScopeExp::semantic()\n"); | |
| 3389 return e; | |
| 3390 } | |
| 3391 if (sds2 != sds) | |
| 3392 { | |
| 3393 sds = sds2; | |
| 3394 goto Lagain; | |
| 3395 } | |
| 3396 //printf("sds = %s, '%s'\n", sds->kind(), sds->toChars()); | |
| 3397 } | |
| 3398 else | |
| 3399 { | |
| 3400 //printf("sds = %s, '%s'\n", sds->kind(), sds->toChars()); | |
| 3401 //printf("\tparent = '%s'\n", sds->parent->toChars()); | |
| 3402 sds->semantic(sc); | |
| 3403 } | |
| 3404 type = Type::tvoid; | |
| 3405 //printf("-2ScopeExp::semantic() %s\n", toChars()); | |
| 3406 return this; | |
| 3407 } | |
| 3408 | |
| 3409 void ScopeExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3410 { | |
| 3411 if (sds->isTemplateInstance()) | |
| 3412 { | |
| 3413 sds->toCBuffer(buf, hgs); | |
| 3414 } | |
| 3415 else | |
| 3416 { | |
| 3417 buf->writestring(sds->kind()); | |
| 3418 buf->writestring(" "); | |
| 3419 buf->writestring(sds->toChars()); | |
| 3420 } | |
| 3421 } | |
| 3422 | |
| 3423 /********************** TemplateExp **************************************/ | |
| 3424 | |
| 3425 // Mainly just a placeholder | |
| 3426 | |
| 3427 TemplateExp::TemplateExp(Loc loc, TemplateDeclaration *td) | |
| 3428 : Expression(loc, TOKtemplate, sizeof(TemplateExp)) | |
| 3429 { | |
| 3430 //printf("TemplateExp(): %s\n", td->toChars()); | |
| 3431 this->td = td; | |
| 3432 } | |
| 3433 | |
| 3434 void TemplateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3435 { | |
| 3436 buf->writestring(td->toChars()); | |
| 3437 } | |
| 3438 | |
| 3439 void TemplateExp::rvalue() | |
| 3440 { | |
| 3441 error("template %s has no value", toChars()); | |
| 3442 } | |
| 3443 | |
| 3444 /********************** NewExp **************************************/ | |
| 3445 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3446 /* thisexp.new(newargs) newtype(arguments) */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3447 |
| 159 | 3448 NewExp::NewExp(Loc loc, Expression *thisexp, Expressions *newargs, |
| 3449 Type *newtype, Expressions *arguments) | |
| 3450 : Expression(loc, TOKnew, sizeof(NewExp)) | |
| 3451 { | |
| 3452 this->thisexp = thisexp; | |
| 3453 this->newargs = newargs; | |
| 3454 this->newtype = newtype; | |
| 3455 this->arguments = arguments; | |
| 3456 member = NULL; | |
| 3457 allocator = NULL; | |
| 3458 onstack = 0; | |
| 3459 } | |
| 3460 | |
| 3461 Expression *NewExp::syntaxCopy() | |
| 3462 { | |
| 3463 return new NewExp(loc, | |
| 3464 thisexp ? thisexp->syntaxCopy() : NULL, | |
| 3465 arraySyntaxCopy(newargs), | |
| 3466 newtype->syntaxCopy(), arraySyntaxCopy(arguments)); | |
| 3467 } | |
| 3468 | |
| 3469 | |
| 3470 Expression *NewExp::semantic(Scope *sc) | |
| 3471 { int i; | |
| 3472 Type *tb; | |
| 3473 ClassDeclaration *cdthis = NULL; | |
| 3474 | |
| 3475 #if LOGSEMANTIC | |
| 3476 printf("NewExp::semantic() %s\n", toChars()); | |
| 3477 if (thisexp) | |
| 3478 printf("\tthisexp = %s\n", thisexp->toChars()); | |
| 3479 printf("\tnewtype: %s\n", newtype->toChars()); | |
| 3480 #endif | |
| 3481 if (type) // if semantic() already run | |
| 3482 return this; | |
| 3483 | |
| 3484 Lagain: | |
| 3485 if (thisexp) | |
| 3486 { thisexp = thisexp->semantic(sc); | |
| 3487 cdthis = thisexp->type->isClassHandle(); | |
| 3488 if (cdthis) | |
| 3489 { | |
| 3490 sc = sc->push(cdthis); | |
| 3491 type = newtype->semantic(loc, sc); | |
| 3492 sc = sc->pop(); | |
| 3493 } | |
| 3494 else | |
| 3495 { | |
| 3496 error("'this' for nested class must be a class type, not %s", thisexp->type->toChars()); | |
| 3497 type = newtype->semantic(loc, sc); | |
| 3498 } | |
| 3499 } | |
| 3500 else | |
| 3501 type = newtype->semantic(loc, sc); | |
| 3502 newtype = type; // in case type gets cast to something else | |
| 3503 tb = type->toBasetype(); | |
| 3504 //printf("tb: %s, deco = %s\n", tb->toChars(), tb->deco); | |
| 3505 | |
| 3506 arrayExpressionSemantic(newargs, sc); | |
| 3507 preFunctionArguments(loc, sc, newargs); | |
| 3508 arrayExpressionSemantic(arguments, sc); | |
| 3509 preFunctionArguments(loc, sc, arguments); | |
| 3510 | |
| 3511 if (thisexp && tb->ty != Tclass) | |
| 3512 error("e.new is only for allocating nested classes, not %s", tb->toChars()); | |
| 3513 | |
| 3514 if (tb->ty == Tclass) | |
| 3515 { TypeFunction *tf; | |
| 3516 | |
| 3517 TypeClass *tc = (TypeClass *)(tb); | |
| 3518 ClassDeclaration *cd = tc->sym->isClassDeclaration(); | |
| 3519 if (cd->isInterfaceDeclaration()) | |
| 3520 error("cannot create instance of interface %s", cd->toChars()); | |
| 3521 else if (cd->isAbstract()) | |
| 3522 { error("cannot create instance of abstract class %s", cd->toChars()); | |
| 3523 for (int i = 0; i < cd->vtbl.dim; i++) | |
| 3524 { FuncDeclaration *fd = ((Dsymbol *)cd->vtbl.data[i])->isFuncDeclaration(); | |
| 3525 if (fd && fd->isAbstract()) | |
| 3526 error("function %s is abstract", fd->toChars()); | |
| 3527 } | |
| 3528 } | |
| 3529 checkDeprecated(sc, cd); | |
| 3530 if (cd->isNested()) | |
| 3531 { /* We need a 'this' pointer for the nested class. | |
| 3532 * Ensure we have the right one. | |
| 3533 */ | |
| 3534 Dsymbol *s = cd->toParent2(); | |
| 3535 ClassDeclaration *cdn = s->isClassDeclaration(); | |
|
639
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3536 FuncDeclaration *fdn = s->isFuncDeclaration(); |
| 159 | 3537 |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3538 //printf("cd isNested, cdn = %s\n", cdn ? cdn->toChars() : "null"); |
| 159 | 3539 if (cdn) |
| 3540 { | |
| 3541 if (!cdthis) | |
| 3542 { | |
| 3543 // Supply an implicit 'this' and try again | |
| 3544 thisexp = new ThisExp(loc); | |
| 3545 for (Dsymbol *sp = sc->parent; 1; sp = sp->parent) | |
| 3546 { if (!sp) | |
| 3547 { | |
| 3548 error("outer class %s 'this' needed to 'new' nested class %s", cdn->toChars(), cd->toChars()); | |
| 3549 break; | |
| 3550 } | |
| 3551 ClassDeclaration *cdp = sp->isClassDeclaration(); | |
| 3552 if (!cdp) | |
| 3553 continue; | |
| 3554 if (cdp == cdn || cdn->isBaseOf(cdp, NULL)) | |
| 3555 break; | |
| 3556 // Add a '.outer' and try again | |
| 3557 thisexp = new DotIdExp(loc, thisexp, Id::outer); | |
| 3558 } | |
| 3559 if (!global.errors) | |
| 3560 goto Lagain; | |
| 3561 } | |
| 3562 if (cdthis) | |
| 3563 { | |
| 3564 //printf("cdthis = %s\n", cdthis->toChars()); | |
| 3565 if (cdthis != cdn && !cdn->isBaseOf(cdthis, NULL)) | |
| 3566 error("'this' for nested class must be of type %s, not %s", cdn->toChars(), thisexp->type->toChars()); | |
| 3567 } | |
| 3568 #if 0 | |
| 3569 else | |
| 3570 { | |
| 3571 for (Dsymbol *sf = sc->func; 1; sf= sf->toParent2()->isFuncDeclaration()) | |
| 3572 { | |
| 3573 if (!sf) | |
| 3574 { | |
| 3575 error("outer class %s 'this' needed to 'new' nested class %s", cdn->toChars(), cd->toChars()); | |
| 3576 break; | |
| 3577 } | |
| 3578 printf("sf = %s\n", sf->toChars()); | |
| 3579 AggregateDeclaration *ad = sf->isThis(); | |
| 3580 if (ad && (ad == cdn || cdn->isBaseOf(ad->isClassDeclaration(), NULL))) | |
| 3581 break; | |
| 3582 } | |
| 3583 } | |
| 3584 #endif | |
| 3585 } | |
| 3586 else if (thisexp) | |
| 3587 error("e.new is only for allocating nested classes"); | |
|
639
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3588 else if (fdn) |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3589 { |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3590 // make sure the parent context fdn of cd is reachable from sc |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3591 for (Dsymbol *sp = sc->parent; 1; sp = sp->parent) |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3592 { |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3593 if (fdn == sp) |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3594 break; |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3595 FuncDeclaration *fsp = sp ? sp->isFuncDeclaration() : NULL; |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3596 if (!sp || (fsp && fsp->isStatic())) |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3597 { |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3598 error("outer function context of %s is needed to 'new' nested class %s", fdn->toPrettyChars(), cd->toPrettyChars()); |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3599 break; |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3600 } |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3601 } |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3602 |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3603 } |
| 159 | 3604 } |
| 3605 else if (thisexp) | |
| 3606 error("e.new is only for allocating nested classes"); | |
| 3607 | |
| 3608 FuncDeclaration *f = cd->ctor; | |
| 3609 if (f) | |
| 3610 { | |
| 3611 assert(f); | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
3612 f = f->overloadResolve(loc, arguments, sc->module); |
| 159 | 3613 checkDeprecated(sc, f); |
| 3614 member = f->isCtorDeclaration(); | |
| 3615 assert(member); | |
| 3616 | |
| 3617 cd->accessCheck(loc, sc, member); | |
| 3618 | |
| 3619 tf = (TypeFunction *)f->type; | |
| 3620 type = tf->next; | |
| 3621 | |
| 3622 if (!arguments) | |
| 3623 arguments = new Expressions(); | |
| 3624 functionArguments(loc, sc, tf, arguments); | |
| 3625 } | |
| 3626 else | |
| 3627 { | |
| 3628 if (arguments && arguments->dim) | |
| 3629 error("no constructor for %s", cd->toChars()); | |
| 3630 } | |
| 3631 | |
| 3632 if (cd->aggNew) | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3633 { |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
3634 // Prepend the size argument to newargs[] |
|
891
ea82e2077f9d
Change custom allocator new size argument to size_t instead of uint. See #175.
Christian Kamm <kamm incasoftware de>
parents:
876
diff
changeset
|
3635 Expression *e = new IntegerExp(loc, cd->size(loc), Type::tsize_t); |
| 159 | 3636 if (!newargs) |
| 3637 newargs = new Expressions(); | |
| 3638 newargs->shift(e); | |
| 3639 | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
3640 f = cd->aggNew->overloadResolve(loc, newargs, sc->module); |
| 159 | 3641 allocator = f->isNewDeclaration(); |
| 3642 assert(allocator); | |
| 3643 | |
| 3644 tf = (TypeFunction *)f->type; | |
| 3645 functionArguments(loc, sc, tf, newargs); | |
| 3646 } | |
| 3647 else | |
| 3648 { | |
| 3649 if (newargs && newargs->dim) | |
| 3650 error("no allocator for %s", cd->toChars()); | |
| 3651 } | |
| 3652 } | |
| 3653 else if (tb->ty == Tstruct) | |
| 3654 { | |
| 3655 TypeStruct *ts = (TypeStruct *)tb; | |
| 3656 StructDeclaration *sd = ts->sym; | |
| 3657 FuncDeclaration *f = sd->aggNew; | |
| 3658 TypeFunction *tf; | |
| 3659 | |
| 3660 if (arguments && arguments->dim) | |
| 3661 error("no constructor for %s", type->toChars()); | |
| 3662 | |
| 3663 if (f) | |
| 3664 { | |
| 3665 Expression *e; | |
| 3666 | |
| 3667 // Prepend the uint size argument to newargs[] | |
| 3668 e = new IntegerExp(loc, sd->size(loc), Type::tuns32); | |
| 3669 if (!newargs) | |
| 3670 newargs = new Expressions(); | |
| 3671 newargs->shift(e); | |
| 3672 | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
3673 f = f->overloadResolve(loc, newargs, sc->module); |
| 159 | 3674 allocator = f->isNewDeclaration(); |
| 3675 assert(allocator); | |
| 3676 | |
| 3677 tf = (TypeFunction *)f->type; | |
| 3678 functionArguments(loc, sc, tf, newargs); | |
| 3679 | |
| 3680 e = new VarExp(loc, f); | |
| 3681 e = new CallExp(loc, e, newargs); | |
| 3682 e = e->semantic(sc); | |
| 3683 e->type = type->pointerTo(); | |
| 3684 return e; | |
| 3685 } | |
| 3686 | |
| 3687 type = type->pointerTo(); | |
| 3688 } | |
| 3689 else if (tb->ty == Tarray && (arguments && arguments->dim)) | |
| 3690 { | |
| 3691 for (size_t i = 0; i < arguments->dim; i++) | |
| 3692 { | |
| 3693 if (tb->ty != Tarray) | |
| 3694 { error("too many arguments for array"); | |
| 3695 arguments->dim = i; | |
| 3696 break; | |
| 3697 } | |
| 3698 | |
| 3699 Expression *arg = (Expression *)arguments->data[i]; | |
| 3700 arg = resolveProperties(sc, arg); | |
| 3701 arg = arg->implicitCastTo(sc, Type::tsize_t); | |
| 3702 if (arg->op == TOKint64 && (long long)arg->toInteger() < 0) | |
| 3703 error("negative array index %s", arg->toChars()); | |
| 3704 arguments->data[i] = (void *) arg; | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3705 tb = ((TypeDArray *)tb)->next->toBasetype(); |
| 159 | 3706 } |
| 3707 } | |
| 3708 else if (tb->isscalar()) | |
| 3709 { | |
| 3710 if (arguments && arguments->dim) | |
| 3711 error("no constructor for %s", type->toChars()); | |
| 3712 | |
| 3713 type = type->pointerTo(); | |
| 3714 } | |
| 3715 else | |
| 3716 { | |
| 3717 error("new can only create structs, dynamic arrays or class objects, not %s's", type->toChars()); | |
| 3718 type = type->pointerTo(); | |
| 3719 } | |
| 3720 | |
| 3721 //printf("NewExp: '%s'\n", toChars()); | |
| 3722 //printf("NewExp:type '%s'\n", type->toChars()); | |
| 3723 | |
| 3724 return this; | |
| 3725 } | |
| 3726 | |
| 3727 int NewExp::checkSideEffect(int flag) | |
| 3728 { | |
| 3729 return 1; | |
| 3730 } | |
| 3731 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3732 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3733 int NewExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3734 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3735 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3736 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3737 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3738 |
| 159 | 3739 void NewExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 3740 { int i; | |
| 3741 | |
| 3742 if (thisexp) | |
| 3743 { expToCBuffer(buf, hgs, thisexp, PREC_primary); | |
| 3744 buf->writeByte('.'); | |
| 3745 } | |
| 3746 buf->writestring("new "); | |
| 3747 if (newargs && newargs->dim) | |
| 3748 { | |
| 3749 buf->writeByte('('); | |
| 3750 argsToCBuffer(buf, newargs, hgs); | |
| 3751 buf->writeByte(')'); | |
| 3752 } | |
| 3753 newtype->toCBuffer(buf, NULL, hgs); | |
| 3754 if (arguments && arguments->dim) | |
| 3755 { | |
| 3756 buf->writeByte('('); | |
| 3757 argsToCBuffer(buf, arguments, hgs); | |
| 3758 buf->writeByte(')'); | |
| 3759 } | |
| 3760 } | |
| 3761 | |
| 3762 /********************** NewAnonClassExp **************************************/ | |
| 3763 | |
| 3764 NewAnonClassExp::NewAnonClassExp(Loc loc, Expression *thisexp, | |
| 3765 Expressions *newargs, ClassDeclaration *cd, Expressions *arguments) | |
| 3766 : Expression(loc, TOKnewanonclass, sizeof(NewAnonClassExp)) | |
| 3767 { | |
| 3768 this->thisexp = thisexp; | |
| 3769 this->newargs = newargs; | |
| 3770 this->cd = cd; | |
| 3771 this->arguments = arguments; | |
| 3772 } | |
| 3773 | |
| 3774 Expression *NewAnonClassExp::syntaxCopy() | |
| 3775 { | |
| 3776 return new NewAnonClassExp(loc, | |
| 3777 thisexp ? thisexp->syntaxCopy() : NULL, | |
| 3778 arraySyntaxCopy(newargs), | |
| 3779 (ClassDeclaration *)cd->syntaxCopy(NULL), | |
| 3780 arraySyntaxCopy(arguments)); | |
| 3781 } | |
| 3782 | |
| 3783 | |
| 3784 Expression *NewAnonClassExp::semantic(Scope *sc) | |
| 3785 { | |
| 3786 #if LOGSEMANTIC | |
| 3787 printf("NewAnonClassExp::semantic() %s\n", toChars()); | |
| 336 | 3788 //printf("thisexp = %p\n", thisexp); |
| 159 | 3789 //printf("type: %s\n", type->toChars()); |
| 3790 #endif | |
| 3791 | |
| 3792 Expression *d = new DeclarationExp(loc, cd); | |
| 3793 d = d->semantic(sc); | |
| 3794 | |
| 3795 Expression *n = new NewExp(loc, thisexp, newargs, cd->type, arguments); | |
| 3796 | |
| 3797 Expression *c = new CommaExp(loc, d, n); | |
| 3798 return c->semantic(sc); | |
| 3799 } | |
| 3800 | |
| 3801 int NewAnonClassExp::checkSideEffect(int flag) | |
| 3802 { | |
| 3803 return 1; | |
| 3804 } | |
| 3805 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3806 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3807 int NewAnonClassExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3808 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3809 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3810 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3811 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3812 |
| 159 | 3813 void NewAnonClassExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 3814 { int i; | |
| 3815 | |
| 3816 if (thisexp) | |
| 3817 { expToCBuffer(buf, hgs, thisexp, PREC_primary); | |
| 3818 buf->writeByte('.'); | |
| 3819 } | |
| 3820 buf->writestring("new"); | |
| 3821 if (newargs && newargs->dim) | |
| 3822 { | |
| 3823 buf->writeByte('('); | |
| 3824 argsToCBuffer(buf, newargs, hgs); | |
| 3825 buf->writeByte(')'); | |
| 3826 } | |
| 3827 buf->writestring(" class "); | |
| 3828 if (arguments && arguments->dim) | |
| 3829 { | |
| 3830 buf->writeByte('('); | |
| 3831 argsToCBuffer(buf, arguments, hgs); | |
| 3832 buf->writeByte(')'); | |
| 3833 } | |
| 3834 //buf->writestring(" { }"); | |
| 3835 if (cd) | |
| 3836 { | |
| 3837 cd->toCBuffer(buf, hgs); | |
| 3838 } | |
| 3839 } | |
| 3840 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3841 /********************** SymbolExp **************************************/ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3842 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3843 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3844 SymbolExp::SymbolExp(Loc loc, enum TOK op, int size, Declaration *var, int hasOverloads) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3845 : Expression(loc, op, size) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3846 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3847 assert(var); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3848 this->var = var; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3849 this->hasOverloads = hasOverloads; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3850 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3851 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3852 |
| 159 | 3853 /********************** SymOffExp **************************************/ |
| 3854 | |
| 3855 SymOffExp::SymOffExp(Loc loc, Declaration *var, unsigned offset) | |
| 3856 : Expression(loc, TOKsymoff, sizeof(SymOffExp)) | |
| 3857 { | |
| 3858 assert(var); | |
| 3859 this->var = var; | |
| 3860 this->offset = offset; | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
3861 m = NULL; |
| 159 | 3862 VarDeclaration *v = var->isVarDeclaration(); |
| 3863 if (v && v->needThis()) | |
| 3864 error("need 'this' for address of %s", v->toChars()); | |
| 3865 } | |
| 3866 | |
| 3867 Expression *SymOffExp::semantic(Scope *sc) | |
| 3868 { | |
| 3869 #if LOGSEMANTIC | |
| 3870 printf("SymOffExp::semantic('%s')\n", toChars()); | |
| 3871 #endif | |
| 3872 //var->semantic(sc); | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
3873 m = sc->module; |
| 159 | 3874 if (!type) |
| 3875 type = var->type->pointerTo(); | |
| 3876 VarDeclaration *v = var->isVarDeclaration(); | |
| 3877 if (v) | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
3878 v->checkNestedReference(sc, loc); |
| 159 | 3879 return this; |
| 3880 } | |
| 3881 | |
| 3882 int SymOffExp::isBool(int result) | |
| 3883 { | |
| 3884 return result ? TRUE : FALSE; | |
| 3885 } | |
| 3886 | |
| 3887 void SymOffExp::checkEscape() | |
| 3888 { | |
| 3889 VarDeclaration *v = var->isVarDeclaration(); | |
| 3890 if (v) | |
| 3891 { | |
| 3892 if (!v->isDataseg()) | |
| 3893 error("escaping reference to local variable %s", v->toChars()); | |
| 3894 } | |
| 3895 } | |
| 3896 | |
| 3897 void SymOffExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3898 { | |
| 3899 if (offset) | |
| 3900 buf->printf("(& %s+%u)", var->toChars(), offset); | |
| 3901 else | |
| 3902 buf->printf("& %s", var->toChars()); | |
| 3903 } | |
| 3904 | |
| 3905 /******************************** VarExp **************************/ | |
| 3906 | |
| 3907 VarExp::VarExp(Loc loc, Declaration *var) | |
| 3908 : Expression(loc, TOKvar, sizeof(VarExp)) | |
| 3909 { | |
| 3910 //printf("VarExp(this = %p, '%s')\n", this, var->toChars()); | |
| 3911 this->var = var; | |
| 3912 this->type = var->type; | |
| 3913 } | |
| 3914 | |
| 3915 int VarExp::equals(Object *o) | |
| 3916 { VarExp *ne; | |
| 3917 | |
| 3918 if (this == o || | |
| 3919 (((Expression *)o)->op == TOKvar && | |
| 3920 ((ne = (VarExp *)o), type->equals(ne->type)) && | |
| 3921 var == ne->var)) | |
| 3922 return 1; | |
| 3923 return 0; | |
| 3924 } | |
| 3925 | |
| 3926 Expression *VarExp::semantic(Scope *sc) | |
| 3927 { FuncLiteralDeclaration *fd; | |
| 3928 | |
| 3929 #if LOGSEMANTIC | |
| 3930 printf("VarExp::semantic(%s)\n", toChars()); | |
| 3931 #endif | |
| 3932 if (!type) | |
| 3933 { type = var->type; | |
| 3934 #if 0 | |
| 3935 if (var->storage_class & STClazy) | |
| 3936 { | |
| 3937 TypeFunction *tf = new TypeFunction(NULL, type, 0, LINKd); | |
| 3938 type = new TypeDelegate(tf); | |
| 3939 type = type->semantic(loc, sc); | |
| 3940 } | |
| 3941 #endif | |
| 3942 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3943 /* Fix for 1161 doesn't work because it causes protection |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3944 * problems when instantiating imported templates passing private |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3945 * variables as alias template parameters. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3946 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3947 //accessCheck(loc, sc, NULL, var); |
| 159 | 3948 |
| 3949 VarDeclaration *v = var->isVarDeclaration(); | |
| 3950 if (v) | |
| 3951 { | |
| 3952 if (v->isConst() && type->toBasetype()->ty != Tsarray && v->init) | |
| 3953 { | |
| 3954 ExpInitializer *ei = v->init->isExpInitializer(); | |
| 3955 if (ei) | |
| 3956 { | |
| 3957 //ei->exp->implicitCastTo(sc, type)->print(); | |
| 3958 return ei->exp->implicitCastTo(sc, type); | |
| 3959 } | |
| 3960 } | |
| 3961 v->checkNestedReference(sc, loc); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3962 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3963 if (sc->func && sc->func->isPure() && !sc->intypeof) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3964 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3965 if (v->isDataseg() && !v->isInvariant()) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3966 error("pure function '%s' cannot access mutable static data '%s'", sc->func->toChars(), v->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3967 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3968 #endif |
| 159 | 3969 } |
| 3970 #if 0 | |
| 3971 else if ((fd = var->isFuncLiteralDeclaration()) != NULL) | |
| 3972 { Expression *e; | |
| 3973 e = new FuncExp(loc, fd); | |
| 3974 e->type = type; | |
| 3975 return e; | |
| 3976 } | |
| 3977 #endif | |
| 3978 return this; | |
| 3979 } | |
| 3980 | |
| 3981 char *VarExp::toChars() | |
| 3982 { | |
| 3983 return var->toChars(); | |
| 3984 } | |
| 3985 | |
| 3986 void VarExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3987 { | |
| 3988 buf->writestring(var->toChars()); | |
| 3989 } | |
| 3990 | |
| 3991 void VarExp::checkEscape() | |
| 3992 { | |
| 3993 VarDeclaration *v = var->isVarDeclaration(); | |
| 3994 if (v) | |
| 3995 { Type *tb = v->type->toBasetype(); | |
| 3996 // if reference type | |
| 3997 if (tb->ty == Tarray || tb->ty == Tsarray || tb->ty == Tclass) | |
| 3998 { | |
| 3999 if ((v->isAuto() || v->isScope()) && !v->noauto) | |
| 4000 error("escaping reference to auto local %s", v->toChars()); | |
| 4001 else if (v->storage_class & STCvariadic) | |
| 4002 error("escaping reference to variadic parameter %s", v->toChars()); | |
| 4003 } | |
| 4004 } | |
| 4005 } | |
| 4006 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4007 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4008 int VarExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4009 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4010 if (var->storage_class & STClazy) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4011 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4012 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4013 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4014 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4015 |
| 159 | 4016 Expression *VarExp::toLvalue(Scope *sc, Expression *e) |
| 4017 { | |
| 4018 #if 0 | |
| 4019 tym = tybasic(e1->ET->Tty); | |
| 4020 if (!(tyscalar(tym) || | |
| 4021 tym == TYstruct || | |
| 4022 tym == TYarray && e->Eoper == TOKaddr)) | |
| 4023 synerr(EM_lvalue); // lvalue expected | |
| 4024 #endif | |
| 4025 if (var->storage_class & STClazy) | |
| 4026 error("lazy variables cannot be lvalues"); | |
| 4027 return this; | |
| 4028 } | |
| 4029 | |
| 4030 Expression *VarExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 4031 { | |
| 4032 //printf("VarExp::modifiableLvalue('%s')\n", var->toChars()); | |
| 4033 if (sc->incontract && var->isParameter()) | |
| 4034 error("cannot modify parameter '%s' in contract", var->toChars()); | |
| 4035 | |
| 4036 if (type && type->toBasetype()->ty == Tsarray) | |
| 4037 error("cannot change reference to static array '%s'", var->toChars()); | |
| 4038 | |
| 4039 VarDeclaration *v = var->isVarDeclaration(); | |
| 4040 if (v && v->canassign == 0 && | |
| 4041 (var->isConst() || (global.params.Dversion > 1 && var->isFinal()))) | |
| 4042 error("cannot modify final variable '%s'", var->toChars()); | |
| 4043 | |
| 4044 if (var->isCtorinit()) | |
| 4045 { // It's only modifiable if inside the right constructor | |
| 4046 Dsymbol *s = sc->func; | |
| 4047 while (1) | |
| 4048 { | |
| 4049 FuncDeclaration *fd = NULL; | |
| 4050 if (s) | |
| 4051 fd = s->isFuncDeclaration(); | |
| 4052 if (fd && | |
| 4053 ((fd->isCtorDeclaration() && var->storage_class & STCfield) || | |
| 4054 (fd->isStaticCtorDeclaration() && !(var->storage_class & STCfield))) && | |
| 4055 fd->toParent() == var->toParent() | |
| 4056 ) | |
| 4057 { | |
| 4058 VarDeclaration *v = var->isVarDeclaration(); | |
| 4059 assert(v); | |
| 4060 v->ctorinit = 1; | |
| 4061 //printf("setting ctorinit\n"); | |
| 4062 } | |
| 4063 else | |
| 4064 { | |
| 4065 if (s) | |
| 4066 { s = s->toParent2(); | |
| 4067 continue; | |
| 4068 } | |
| 4069 else | |
| 4070 { | |
| 4071 const char *p = var->isStatic() ? "static " : ""; | |
| 4072 error("can only initialize %sconst %s inside %sconstructor", | |
| 4073 p, var->toChars(), p); | |
| 4074 } | |
| 4075 } | |
| 4076 break; | |
| 4077 } | |
| 4078 } | |
| 4079 | |
| 4080 // See if this expression is a modifiable lvalue (i.e. not const) | |
| 4081 return toLvalue(sc, e); | |
| 4082 } | |
| 4083 | |
| 4084 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4085 /******************************** OverExp **************************/ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4086 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4087 #if DMDV2 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4088 OverExp::OverExp(OverloadSet *s) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4089 : Expression(loc, TOKoverloadset, sizeof(OverExp)) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4090 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4091 //printf("OverExp(this = %p, '%s')\n", this, var->toChars()); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4092 vars = s; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4093 type = Type::tvoid; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4094 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4095 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4096 int OverExp::isLvalue() |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4097 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4098 return 1; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4099 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4100 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4101 Expression *OverExp::toLvalue(Scope *sc, Expression *e) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4102 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4103 return this; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4104 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4105 #endif |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4106 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4107 |
| 159 | 4108 /******************************** TupleExp **************************/ |
| 4109 | |
| 4110 TupleExp::TupleExp(Loc loc, Expressions *exps) | |
| 4111 : Expression(loc, TOKtuple, sizeof(TupleExp)) | |
| 4112 { | |
| 4113 //printf("TupleExp(this = %p)\n", this); | |
| 4114 this->exps = exps; | |
| 4115 this->type = NULL; | |
| 4116 } | |
| 4117 | |
| 4118 | |
| 4119 TupleExp::TupleExp(Loc loc, TupleDeclaration *tup) | |
| 4120 : Expression(loc, TOKtuple, sizeof(TupleExp)) | |
| 4121 { | |
| 4122 exps = new Expressions(); | |
| 4123 type = NULL; | |
| 4124 | |
| 4125 exps->reserve(tup->objects->dim); | |
| 4126 for (size_t i = 0; i < tup->objects->dim; i++) | |
| 4127 { Object *o = (Object *)tup->objects->data[i]; | |
| 4128 if (o->dyncast() == DYNCAST_EXPRESSION) | |
| 4129 { | |
| 4130 Expression *e = (Expression *)o; | |
| 4131 e = e->syntaxCopy(); | |
| 4132 exps->push(e); | |
| 4133 } | |
| 4134 else if (o->dyncast() == DYNCAST_DSYMBOL) | |
| 4135 { | |
| 4136 Dsymbol *s = (Dsymbol *)o; | |
| 4137 Expression *e = new DsymbolExp(loc, s); | |
| 4138 exps->push(e); | |
| 4139 } | |
| 4140 else if (o->dyncast() == DYNCAST_TYPE) | |
| 4141 { | |
| 4142 Type *t = (Type *)o; | |
| 4143 Expression *e = new TypeExp(loc, t); | |
| 4144 exps->push(e); | |
| 4145 } | |
| 4146 else | |
| 4147 { | |
| 4148 error("%s is not an expression", o->toChars()); | |
| 4149 } | |
| 4150 } | |
| 4151 } | |
| 4152 | |
| 4153 int TupleExp::equals(Object *o) | |
| 4154 { TupleExp *ne; | |
| 4155 | |
| 4156 if (this == o) | |
| 4157 return 1; | |
| 4158 if (((Expression *)o)->op == TOKtuple) | |
| 4159 { | |
| 4160 TupleExp *te = (TupleExp *)o; | |
| 4161 if (exps->dim != te->exps->dim) | |
| 4162 return 0; | |
| 4163 for (size_t i = 0; i < exps->dim; i++) | |
| 4164 { Expression *e1 = (Expression *)exps->data[i]; | |
| 4165 Expression *e2 = (Expression *)te->exps->data[i]; | |
| 4166 | |
| 4167 if (!e1->equals(e2)) | |
| 4168 return 0; | |
| 4169 } | |
| 4170 return 1; | |
| 4171 } | |
| 4172 return 0; | |
| 4173 } | |
| 4174 | |
| 4175 Expression *TupleExp::syntaxCopy() | |
| 4176 { | |
| 4177 return new TupleExp(loc, arraySyntaxCopy(exps)); | |
| 4178 } | |
| 4179 | |
| 4180 Expression *TupleExp::semantic(Scope *sc) | |
| 4181 { | |
| 4182 #if LOGSEMANTIC | |
| 4183 printf("+TupleExp::semantic(%s)\n", toChars()); | |
| 4184 #endif | |
| 4185 if (type) | |
| 4186 return this; | |
| 4187 | |
| 4188 // Run semantic() on each argument | |
| 4189 for (size_t i = 0; i < exps->dim; i++) | |
| 4190 { Expression *e = (Expression *)exps->data[i]; | |
| 4191 | |
| 4192 e = e->semantic(sc); | |
| 4193 if (!e->type) | |
| 4194 { error("%s has no value", e->toChars()); | |
| 4195 e->type = Type::terror; | |
| 4196 } | |
| 4197 exps->data[i] = (void *)e; | |
| 4198 } | |
| 4199 | |
| 4200 expandTuples(exps); | |
| 4201 if (0 && exps->dim == 1) | |
| 4202 { | |
| 4203 return (Expression *)exps->data[0]; | |
| 4204 } | |
| 4205 type = new TypeTuple(exps); | |
| 4206 //printf("-TupleExp::semantic(%s)\n", toChars()); | |
| 4207 return this; | |
| 4208 } | |
| 4209 | |
| 4210 void TupleExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4211 { | |
| 4212 buf->writestring("tuple("); | |
| 4213 argsToCBuffer(buf, exps, hgs); | |
| 4214 buf->writeByte(')'); | |
| 4215 } | |
| 4216 | |
| 4217 int TupleExp::checkSideEffect(int flag) | |
| 4218 { int f = 0; | |
| 4219 | |
| 4220 for (int i = 0; i < exps->dim; i++) | |
| 4221 { Expression *e = (Expression *)exps->data[i]; | |
| 4222 | |
| 4223 f |= e->checkSideEffect(2); | |
| 4224 } | |
| 4225 if (flag == 0 && f == 0) | |
| 4226 Expression::checkSideEffect(0); | |
| 4227 return f; | |
| 4228 } | |
| 4229 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4230 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4231 int TupleExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4232 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4233 return arrayExpressionCanThrow(exps); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4234 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4235 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4236 |
| 159 | 4237 void TupleExp::checkEscape() |
| 4238 { | |
| 4239 for (size_t i = 0; i < exps->dim; i++) | |
| 4240 { Expression *e = (Expression *)exps->data[i]; | |
| 4241 e->checkEscape(); | |
| 4242 } | |
| 4243 } | |
| 4244 | |
| 4245 /******************************** FuncExp *********************************/ | |
| 4246 | |
| 4247 FuncExp::FuncExp(Loc loc, FuncLiteralDeclaration *fd) | |
| 4248 : Expression(loc, TOKfunction, sizeof(FuncExp)) | |
| 4249 { | |
| 4250 this->fd = fd; | |
| 4251 } | |
| 4252 | |
| 4253 Expression *FuncExp::syntaxCopy() | |
| 4254 { | |
| 4255 return new FuncExp(loc, (FuncLiteralDeclaration *)fd->syntaxCopy(NULL)); | |
| 4256 } | |
| 4257 | |
| 4258 Expression *FuncExp::semantic(Scope *sc) | |
| 4259 { | |
| 4260 #if LOGSEMANTIC | |
| 4261 printf("FuncExp::semantic(%s)\n", toChars()); | |
| 4262 #endif | |
| 4263 if (!type) | |
| 4264 { | |
| 4265 fd->semantic(sc); | |
| 4266 fd->parent = sc->parent; | |
| 4267 if (global.errors) | |
| 4268 { | |
| 4269 if (!fd->type->next) | |
| 4270 fd->type->next = Type::terror; | |
| 4271 } | |
| 4272 else | |
| 4273 { | |
| 4274 fd->semantic2(sc); | |
| 4275 if (!global.errors) | |
| 4276 { | |
| 4277 fd->semantic3(sc); | |
| 4278 | |
| 4279 if (!global.errors && global.params.useInline) | |
| 4280 fd->inlineScan(); | |
| 4281 } | |
| 4282 } | |
| 4283 | |
| 4284 // Type is a "delegate to" or "pointer to" the function literal | |
| 4285 if (fd->isNested()) | |
| 4286 { | |
| 4287 type = new TypeDelegate(fd->type); | |
| 4288 type = type->semantic(loc, sc); | |
| 4289 } | |
| 4290 else | |
| 4291 { | |
| 4292 type = fd->type->pointerTo(); | |
| 4293 } | |
| 4294 } | |
| 4295 return this; | |
| 4296 } | |
| 4297 | |
| 4298 char *FuncExp::toChars() | |
| 4299 { | |
| 4300 return fd->toChars(); | |
| 4301 } | |
| 4302 | |
| 4303 void FuncExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4304 { | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
4305 fd->toCBuffer(buf, hgs); |
|
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
4306 //buf->writestring(fd->toChars()); |
| 159 | 4307 } |
| 4308 | |
| 4309 | |
| 4310 /******************************** DeclarationExp **************************/ | |
| 4311 | |
| 4312 DeclarationExp::DeclarationExp(Loc loc, Dsymbol *declaration) | |
| 4313 : Expression(loc, TOKdeclaration, sizeof(DeclarationExp)) | |
| 4314 { | |
| 4315 this->declaration = declaration; | |
| 4316 } | |
| 4317 | |
| 4318 Expression *DeclarationExp::syntaxCopy() | |
| 4319 { | |
| 4320 return new DeclarationExp(loc, declaration->syntaxCopy(NULL)); | |
| 4321 } | |
| 4322 | |
| 4323 Expression *DeclarationExp::semantic(Scope *sc) | |
| 4324 { | |
| 4325 if (type) | |
| 4326 return this; | |
| 4327 | |
| 4328 #if LOGSEMANTIC | |
| 4329 printf("DeclarationExp::semantic() %s\n", toChars()); | |
| 4330 #endif | |
| 4331 | |
| 4332 /* This is here to support extern(linkage) declaration, | |
| 4333 * where the extern(linkage) winds up being an AttribDeclaration | |
| 4334 * wrapper. | |
| 4335 */ | |
| 4336 Dsymbol *s = declaration; | |
| 4337 | |
| 4338 AttribDeclaration *ad = declaration->isAttribDeclaration(); | |
| 4339 if (ad) | |
| 4340 { | |
| 4341 if (ad->decl && ad->decl->dim == 1) | |
| 4342 s = (Dsymbol *)ad->decl->data[0]; | |
| 4343 } | |
| 4344 | |
| 4345 if (s->isVarDeclaration()) | |
| 4346 { // Do semantic() on initializer first, so: | |
| 4347 // int a = a; | |
| 4348 // will be illegal. | |
| 4349 declaration->semantic(sc); | |
| 4350 s->parent = sc->parent; | |
| 4351 } | |
| 4352 | |
| 4353 //printf("inserting '%s' %p into sc = %p\n", s->toChars(), s, sc); | |
| 4354 // Insert into both local scope and function scope. | |
| 4355 // Must be unique in both. | |
| 4356 if (s->ident) | |
| 4357 { | |
| 4358 if (!sc->insert(s)) | |
| 4359 error("declaration %s is already defined", s->toPrettyChars()); | |
| 4360 else if (sc->func) | |
| 4361 { VarDeclaration *v = s->isVarDeclaration(); | |
| 4362 if ((s->isFuncDeclaration() /*|| v && v->storage_class & STCstatic*/) && | |
| 4363 !sc->func->localsymtab->insert(s)) | |
| 4364 error("declaration %s is already defined in another scope in %s", s->toPrettyChars(), sc->func->toChars()); | |
| 4365 else if (!global.params.useDeprecated) | |
| 4366 { // Disallow shadowing | |
| 4367 | |
| 4368 for (Scope *scx = sc->enclosing; scx && scx->func == sc->func; scx = scx->enclosing) | |
| 4369 { Dsymbol *s2; | |
| 4370 | |
| 4371 if (scx->scopesym && scx->scopesym->symtab && | |
| 4372 (s2 = scx->scopesym->symtab->lookup(s->ident)) != NULL && | |
| 4373 s != s2) | |
| 4374 { | |
| 4375 error("shadowing declaration %s is deprecated", s->toPrettyChars()); | |
| 4376 } | |
| 4377 } | |
| 4378 } | |
| 4379 } | |
| 4380 } | |
| 4381 if (!s->isVarDeclaration()) | |
| 4382 { | |
| 4383 declaration->semantic(sc); | |
| 4384 s->parent = sc->parent; | |
| 4385 } | |
| 4386 if (!global.errors) | |
| 4387 { | |
| 4388 declaration->semantic2(sc); | |
| 4389 if (!global.errors) | |
| 4390 { | |
| 4391 declaration->semantic3(sc); | |
| 4392 | |
| 4393 if (!global.errors && global.params.useInline) | |
| 4394 declaration->inlineScan(); | |
| 4395 } | |
| 4396 } | |
| 4397 | |
| 4398 type = Type::tvoid; | |
| 4399 return this; | |
| 4400 } | |
| 4401 | |
| 4402 int DeclarationExp::checkSideEffect(int flag) | |
| 4403 { | |
| 4404 return 1; | |
| 4405 } | |
| 4406 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4407 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4408 int DeclarationExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4409 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4410 VarDeclaration *v = declaration->isVarDeclaration(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4411 if (v && v->init) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4412 { ExpInitializer *ie = v->init->isExpInitializer(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4413 return ie && ie->exp->canThrow(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4414 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4415 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4416 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4417 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4418 |
| 159 | 4419 void DeclarationExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 4420 { | |
| 4421 declaration->toCBuffer(buf, hgs); | |
| 4422 } | |
| 4423 | |
| 4424 | |
| 4425 /************************ TypeidExp ************************************/ | |
| 4426 | |
| 4427 /* | |
| 4428 * typeid(int) | |
| 4429 */ | |
| 4430 | |
| 4431 TypeidExp::TypeidExp(Loc loc, Type *typeidType) | |
| 4432 : Expression(loc, TOKtypeid, sizeof(TypeidExp)) | |
| 4433 { | |
| 4434 this->typeidType = typeidType; | |
| 4435 } | |
| 4436 | |
| 4437 | |
| 4438 Expression *TypeidExp::syntaxCopy() | |
| 4439 { | |
| 4440 return new TypeidExp(loc, typeidType->syntaxCopy()); | |
| 4441 } | |
| 4442 | |
| 4443 | |
| 4444 Expression *TypeidExp::semantic(Scope *sc) | |
| 4445 { Expression *e; | |
| 4446 | |
| 4447 #if LOGSEMANTIC | |
| 4448 printf("TypeidExp::semantic()\n"); | |
| 4449 #endif | |
| 4450 typeidType = typeidType->semantic(loc, sc); | |
| 4451 e = typeidType->getTypeInfo(sc); | |
| 336 | 4452 if (e->loc.linnum == 0) |
| 4453 e->loc = loc; // so there's at least some line number info | |
| 159 | 4454 return e; |
| 4455 } | |
| 4456 | |
| 4457 void TypeidExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4458 { | |
| 4459 buf->writestring("typeid("); | |
| 4460 typeidType->toCBuffer(buf, NULL, hgs); | |
| 4461 buf->writeByte(')'); | |
| 4462 } | |
| 4463 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4464 /************************ TraitsExp ************************************/ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4465 #if DMDV2 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4466 /* |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4467 * __traits(identifier, args...) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4468 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4469 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4470 TraitsExp::TraitsExp(Loc loc, Identifier *ident, Objects *args) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4471 : Expression(loc, TOKtraits, sizeof(TraitsExp)) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4472 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4473 this->ident = ident; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4474 this->args = args; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4475 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4476 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4477 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4478 Expression *TraitsExp::syntaxCopy() |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4479 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4480 return new TraitsExp(loc, ident, TemplateInstance::arraySyntaxCopy(args)); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4481 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4482 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4483 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4484 void TraitsExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4485 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4486 buf->writestring("__traits("); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4487 buf->writestring(ident->toChars()); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4488 if (args) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4489 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4490 for (int i = 0; i < args->dim; i++) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4491 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4492 buf->writeByte(','); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4493 Object *oarg = (Object *)args->data[i]; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4494 ObjectToCBuffer(buf, hgs, oarg); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4495 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4496 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4497 buf->writeByte(')'); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4498 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4499 #endif |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4500 |
| 159 | 4501 /************************************************************/ |
| 4502 | |
| 4503 HaltExp::HaltExp(Loc loc) | |
| 4504 : Expression(loc, TOKhalt, sizeof(HaltExp)) | |
| 4505 { | |
| 4506 } | |
| 4507 | |
| 4508 Expression *HaltExp::semantic(Scope *sc) | |
| 4509 { | |
| 4510 #if LOGSEMANTIC | |
| 4511 printf("HaltExp::semantic()\n"); | |
| 4512 #endif | |
| 4513 type = Type::tvoid; | |
| 4514 return this; | |
| 4515 } | |
| 4516 | |
| 4517 int HaltExp::checkSideEffect(int flag) | |
| 4518 { | |
| 4519 return 1; | |
| 4520 } | |
| 4521 | |
| 4522 void HaltExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4523 { | |
| 4524 buf->writestring("halt"); | |
| 4525 } | |
| 4526 | |
| 4527 /************************************************************/ | |
| 4528 | |
| 4529 IsExp::IsExp(Loc loc, Type *targ, Identifier *id, enum TOK tok, | |
| 4530 Type *tspec, enum TOK tok2) | |
| 4531 : Expression(loc, TOKis, sizeof(IsExp)) | |
| 4532 { | |
| 4533 this->targ = targ; | |
| 4534 this->id = id; | |
| 4535 this->tok = tok; | |
| 4536 this->tspec = tspec; | |
| 4537 this->tok2 = tok2; | |
| 4538 } | |
| 4539 | |
| 4540 Expression *IsExp::syntaxCopy() | |
| 4541 { | |
| 4542 return new IsExp(loc, | |
| 4543 targ->syntaxCopy(), | |
| 4544 id, | |
| 4545 tok, | |
| 4546 tspec ? tspec->syntaxCopy() : NULL, | |
| 4547 tok2); | |
| 4548 } | |
| 4549 | |
| 4550 Expression *IsExp::semantic(Scope *sc) | |
| 4551 { Type *tded; | |
| 4552 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4553 /* is(targ id tok tspec) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4554 * is(targ id == tok2) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4555 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4556 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4557 //printf("IsExp::semantic(%s)\n", toChars()); |
| 159 | 4558 if (id && !(sc->flags & SCOPEstaticif)) |
| 4559 error("can only declare type aliases within static if conditionals"); | |
| 4560 | |
| 4561 unsigned errors_save = global.errors; | |
| 4562 global.errors = 0; | |
| 4563 global.gag++; // suppress printing of error messages | |
| 4564 targ = targ->semantic(loc, sc); | |
| 4565 global.gag--; | |
| 4566 unsigned gerrors = global.errors; | |
| 4567 global.errors = errors_save; | |
| 4568 | |
| 4569 if (gerrors) // if any errors happened | |
| 4570 { // then condition is false | |
| 4571 goto Lno; | |
| 4572 } | |
| 4573 else if (tok2 != TOKreserved) | |
| 4574 { | |
| 4575 switch (tok2) | |
| 4576 { | |
| 4577 case TOKtypedef: | |
| 4578 if (targ->ty != Ttypedef) | |
| 4579 goto Lno; | |
| 4580 tded = ((TypeTypedef *)targ)->sym->basetype; | |
| 4581 break; | |
| 4582 | |
| 4583 case TOKstruct: | |
| 4584 if (targ->ty != Tstruct) | |
| 4585 goto Lno; | |
| 4586 if (((TypeStruct *)targ)->sym->isUnionDeclaration()) | |
| 4587 goto Lno; | |
| 4588 tded = targ; | |
| 4589 break; | |
| 4590 | |
| 4591 case TOKunion: | |
| 4592 if (targ->ty != Tstruct) | |
| 4593 goto Lno; | |
| 4594 if (!((TypeStruct *)targ)->sym->isUnionDeclaration()) | |
| 4595 goto Lno; | |
| 4596 tded = targ; | |
| 4597 break; | |
| 4598 | |
| 4599 case TOKclass: | |
| 4600 if (targ->ty != Tclass) | |
| 4601 goto Lno; | |
| 4602 if (((TypeClass *)targ)->sym->isInterfaceDeclaration()) | |
| 4603 goto Lno; | |
| 4604 tded = targ; | |
| 4605 break; | |
| 4606 | |
| 4607 case TOKinterface: | |
| 4608 if (targ->ty != Tclass) | |
| 4609 goto Lno; | |
| 4610 if (!((TypeClass *)targ)->sym->isInterfaceDeclaration()) | |
| 4611 goto Lno; | |
| 4612 tded = targ; | |
| 4613 break; | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4614 #if DMDV2 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4615 case TOKconst: |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4616 if (!targ->isConst()) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4617 goto Lno; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4618 tded = targ; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4619 break; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4620 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4621 case TOKinvariant: |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4622 case TOKimmutable: |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4623 if (!targ->isInvariant()) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4624 goto Lno; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4625 tded = targ; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4626 break; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4627 #endif |
| 159 | 4628 |
| 4629 case TOKsuper: | |
| 4630 // If class or interface, get the base class and interfaces | |
| 4631 if (targ->ty != Tclass) | |
| 4632 goto Lno; | |
| 4633 else | |
| 4634 { ClassDeclaration *cd = ((TypeClass *)targ)->sym; | |
| 4635 Arguments *args = new Arguments; | |
| 4636 args->reserve(cd->baseclasses.dim); | |
| 4637 for (size_t i = 0; i < cd->baseclasses.dim; i++) | |
| 4638 { BaseClass *b = (BaseClass *)cd->baseclasses.data[i]; | |
| 4639 args->push(new Argument(STCin, b->type, NULL, NULL)); | |
| 4640 } | |
| 4641 tded = new TypeTuple(args); | |
| 4642 } | |
| 4643 break; | |
| 4644 | |
| 4645 case TOKenum: | |
| 4646 if (targ->ty != Tenum) | |
| 4647 goto Lno; | |
| 4648 tded = ((TypeEnum *)targ)->sym->memtype; | |
| 4649 break; | |
| 4650 | |
| 4651 case TOKdelegate: | |
| 4652 if (targ->ty != Tdelegate) | |
| 4653 goto Lno; | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4654 tded = ((TypeDelegate *)targ)->next; // the underlying function type |
| 159 | 4655 break; |
| 4656 | |
| 4657 case TOKfunction: | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4658 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4659 if (targ->ty != Tfunction) |
| 159 | 4660 goto Lno; |
| 4661 tded = targ; | |
| 4662 | |
| 4663 /* Generate tuple from function parameter types. | |
| 4664 */ | |
| 4665 assert(tded->ty == Tfunction); | |
| 4666 Arguments *params = ((TypeFunction *)tded)->parameters; | |
| 4667 size_t dim = Argument::dim(params); | |
| 4668 Arguments *args = new Arguments; | |
| 4669 args->reserve(dim); | |
| 4670 for (size_t i = 0; i < dim; i++) | |
| 4671 { Argument *arg = Argument::getNth(params, i); | |
| 4672 assert(arg && arg->type); | |
| 4673 args->push(new Argument(arg->storageClass, arg->type, NULL, NULL)); | |
| 4674 } | |
| 4675 tded = new TypeTuple(args); | |
| 4676 break; | |
| 4677 } | |
| 4678 case TOKreturn: | |
| 4679 /* Get the 'return type' for the function, | |
| 4680 * delegate, or pointer to function. | |
| 4681 */ | |
| 4682 if (targ->ty == Tfunction) | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4683 tded = ((TypeFunction *)targ)->next; |
| 159 | 4684 else if (targ->ty == Tdelegate) |
| 4685 tded = targ->next->next; | |
| 4686 else if (targ->ty == Tpointer && targ->next->ty == Tfunction) | |
| 4687 tded = targ->next->next; | |
| 4688 else | |
| 4689 goto Lno; | |
| 4690 break; | |
| 4691 | |
| 4692 default: | |
| 4693 assert(0); | |
| 4694 } | |
| 4695 goto Lyes; | |
| 4696 } | |
| 4697 else if (id && tspec) | |
| 4698 { | |
| 4699 /* Evaluate to TRUE if targ matches tspec. | |
| 4700 * If TRUE, declare id as an alias for the specialized type. | |
| 4701 */ | |
| 4702 | |
| 4703 MATCH m; | |
| 4704 TemplateTypeParameter tp(loc, id, NULL, NULL); | |
| 4705 | |
| 4706 TemplateParameters parameters; | |
| 4707 parameters.setDim(1); | |
| 4708 parameters.data[0] = (void *)&tp; | |
| 4709 | |
| 4710 Objects dedtypes; | |
| 4711 dedtypes.setDim(1); | |
| 4712 dedtypes.data[0] = NULL; | |
| 4713 | |
| 4714 m = targ->deduceType(NULL, tspec, ¶meters, &dedtypes); | |
| 4715 if (m == MATCHnomatch || | |
| 4716 (m != MATCHexact && tok == TOKequal)) | |
| 4717 goto Lno; | |
| 4718 else | |
| 4719 { | |
| 4720 assert(dedtypes.dim == 1); | |
| 4721 tded = (Type *)dedtypes.data[0]; | |
| 4722 if (!tded) | |
| 4723 tded = targ; | |
| 4724 goto Lyes; | |
| 4725 } | |
| 4726 } | |
| 4727 else if (id) | |
| 4728 { | |
| 4729 /* Declare id as an alias for type targ. Evaluate to TRUE | |
| 4730 */ | |
| 4731 tded = targ; | |
| 4732 goto Lyes; | |
| 4733 } | |
| 4734 else if (tspec) | |
| 4735 { | |
| 4736 /* Evaluate to TRUE if targ matches tspec | |
| 4737 */ | |
| 4738 tspec = tspec->semantic(loc, sc); | |
| 4739 //printf("targ = %s\n", targ->toChars()); | |
| 4740 //printf("tspec = %s\n", tspec->toChars()); | |
| 4741 if (tok == TOKcolon) | |
| 4742 { if (targ->implicitConvTo(tspec)) | |
| 4743 goto Lyes; | |
| 4744 else | |
| 4745 goto Lno; | |
| 4746 } | |
| 4747 else /* == */ | |
| 4748 { if (targ->equals(tspec)) | |
| 4749 goto Lyes; | |
| 4750 else | |
| 4751 goto Lno; | |
| 4752 } | |
| 4753 } | |
| 4754 | |
| 4755 Lyes: | |
| 4756 if (id) | |
| 4757 { | |
| 4758 Dsymbol *s = new AliasDeclaration(loc, id, tded); | |
| 4759 s->semantic(sc); | |
| 4760 sc->insert(s); | |
| 4761 if (sc->sd) | |
| 4762 s->addMember(sc, sc->sd, 1); | |
| 4763 } | |
| 4764 return new IntegerExp(1); | |
| 4765 | |
| 4766 Lno: | |
| 4767 return new IntegerExp(0); | |
| 4768 } | |
| 4769 | |
| 4770 void IsExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4771 { | |
| 4772 buf->writestring("is("); | |
| 4773 targ->toCBuffer(buf, id, hgs); | |
| 4774 if (tok2 != TOKreserved) | |
| 4775 { | |
| 4776 buf->printf(" %s %s", Token::toChars(tok), Token::toChars(tok2)); | |
| 4777 } | |
| 4778 else if (tspec) | |
| 4779 { | |
| 4780 if (tok == TOKcolon) | |
| 4781 buf->writestring(" : "); | |
| 4782 else | |
| 4783 buf->writestring(" == "); | |
| 4784 tspec->toCBuffer(buf, NULL, hgs); | |
| 4785 } | |
| 336 | 4786 #if DMDV2 |
| 159 | 4787 if (parameters) |
| 4788 { // First parameter is already output, so start with second | |
| 4789 for (int i = 1; i < parameters->dim; i++) | |
| 4790 { | |
| 4791 buf->writeByte(','); | |
| 4792 TemplateParameter *tp = (TemplateParameter *)parameters->data[i]; | |
| 4793 tp->toCBuffer(buf, hgs); | |
| 4794 } | |
| 4795 } | |
| 4796 #endif | |
| 4797 buf->writeByte(')'); | |
| 4798 } | |
| 4799 | |
| 4800 | |
| 4801 /************************************************************/ | |
| 4802 | |
| 4803 UnaExp::UnaExp(Loc loc, enum TOK op, int size, Expression *e1) | |
| 4804 : Expression(loc, op, size) | |
| 4805 { | |
| 4806 this->e1 = e1; | |
| 4807 } | |
| 4808 | |
| 4809 Expression *UnaExp::syntaxCopy() | |
| 4810 { UnaExp *e; | |
| 4811 | |
| 4812 e = (UnaExp *)copy(); | |
| 4813 e->type = NULL; | |
| 4814 e->e1 = e->e1->syntaxCopy(); | |
| 4815 return e; | |
| 4816 } | |
| 4817 | |
| 4818 Expression *UnaExp::semantic(Scope *sc) | |
| 4819 { | |
| 4820 #if LOGSEMANTIC | |
| 4821 printf("UnaExp::semantic('%s')\n", toChars()); | |
| 4822 #endif | |
| 4823 e1 = e1->semantic(sc); | |
| 4824 // if (!e1->type) | |
| 4825 // error("%s has no value", e1->toChars()); | |
| 4826 return this; | |
| 4827 } | |
| 4828 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4829 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4830 int UnaExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4831 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4832 return e1->canThrow(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4833 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4834 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4835 |
| 159 | 4836 void UnaExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 4837 { | |
| 4838 buf->writestring(Token::toChars(op)); | |
| 4839 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 4840 } | |
| 4841 | |
| 4842 /************************************************************/ | |
| 4843 | |
| 4844 BinExp::BinExp(Loc loc, enum TOK op, int size, Expression *e1, Expression *e2) | |
| 4845 : Expression(loc, op, size) | |
| 4846 { | |
| 4847 this->e1 = e1; | |
| 4848 this->e2 = e2; | |
| 4849 } | |
| 4850 | |
| 4851 Expression *BinExp::syntaxCopy() | |
| 4852 { BinExp *e; | |
| 4853 | |
| 4854 e = (BinExp *)copy(); | |
| 4855 e->type = NULL; | |
| 4856 e->e1 = e->e1->syntaxCopy(); | |
| 4857 e->e2 = e->e2->syntaxCopy(); | |
| 4858 return e; | |
| 4859 } | |
| 4860 | |
| 4861 Expression *BinExp::semantic(Scope *sc) | |
| 4862 { | |
| 4863 #if LOGSEMANTIC | |
| 4864 printf("BinExp::semantic('%s')\n", toChars()); | |
| 4865 #endif | |
| 4866 e1 = e1->semantic(sc); | |
|
717
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
4867 if (!e1->type && |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
4868 !(op == TOKassign && e1->op == TOKdottd)) // a.template = e2 |
| 159 | 4869 { |
| 4870 error("%s has no value", e1->toChars()); | |
| 4871 e1->type = Type::terror; | |
| 4872 } | |
| 4873 e2 = e2->semantic(sc); | |
| 4874 if (!e2->type) | |
| 4875 { | |
| 4876 error("%s has no value", e2->toChars()); | |
| 4877 e2->type = Type::terror; | |
| 4878 } | |
| 4879 return this; | |
| 4880 } | |
| 4881 | |
| 4882 Expression *BinExp::semanticp(Scope *sc) | |
| 4883 { | |
| 4884 BinExp::semantic(sc); | |
| 4885 e1 = resolveProperties(sc, e1); | |
| 4886 e2 = resolveProperties(sc, e2); | |
| 4887 return this; | |
| 4888 } | |
| 4889 | |
| 4890 /*************************** | |
| 4891 * Common semantic routine for some xxxAssignExp's. | |
| 4892 */ | |
| 4893 | |
| 4894 Expression *BinExp::commonSemanticAssign(Scope *sc) | |
| 4895 { Expression *e; | |
| 4896 | |
| 4897 if (!type) | |
| 4898 { | |
| 4899 BinExp::semantic(sc); | |
| 4900 e2 = resolveProperties(sc, e2); | |
| 4901 | |
| 4902 e = op_overload(sc); | |
| 4903 if (e) | |
| 4904 return e; | |
| 4905 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4906 if (e1->op == TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4907 { // T[] op= ... |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4908 typeCombine(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4909 type = e1->type; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4910 return arrayOp(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4911 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4912 |
| 159 | 4913 e1 = e1->modifiableLvalue(sc, e1); |
| 4914 e1->checkScalar(); | |
| 4915 type = e1->type; | |
| 4916 if (type->toBasetype()->ty == Tbool) | |
| 4917 { | |
| 4918 error("operator not allowed on bool expression %s", toChars()); | |
| 4919 } | |
| 4920 typeCombine(sc); | |
| 4921 e1->checkArithmetic(); | |
| 4922 e2->checkArithmetic(); | |
| 4923 | |
| 4924 if (op == TOKmodass && e2->type->iscomplex()) | |
| 4925 { error("cannot perform modulo complex arithmetic"); | |
| 4926 return new IntegerExp(0); | |
| 4927 } | |
| 4928 } | |
| 4929 return this; | |
| 4930 } | |
| 4931 | |
| 4932 Expression *BinExp::commonSemanticAssignIntegral(Scope *sc) | |
| 4933 { Expression *e; | |
| 4934 | |
| 4935 if (!type) | |
| 4936 { | |
| 4937 BinExp::semantic(sc); | |
| 4938 e2 = resolveProperties(sc, e2); | |
| 4939 | |
| 4940 e = op_overload(sc); | |
| 4941 if (e) | |
| 4942 return e; | |
| 4943 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4944 if (e1->op == TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4945 { // T[] op= ... |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4946 typeCombine(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4947 type = e1->type; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4948 return arrayOp(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4949 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4950 |
| 159 | 4951 e1 = e1->modifiableLvalue(sc, e1); |
| 4952 e1->checkScalar(); | |
| 4953 type = e1->type; | |
| 4954 if (type->toBasetype()->ty == Tbool) | |
| 4955 { | |
| 4956 e2 = e2->implicitCastTo(sc, type); | |
| 4957 } | |
| 4958 | |
| 4959 typeCombine(sc); | |
| 4960 e1->checkIntegral(); | |
| 4961 e2->checkIntegral(); | |
| 4962 } | |
| 4963 return this; | |
| 4964 } | |
| 4965 | |
| 4966 int BinExp::checkSideEffect(int flag) | |
| 4967 { | |
| 4968 if (op == TOKplusplus || | |
| 4969 op == TOKminusminus || | |
| 4970 op == TOKassign || | |
| 4971 op == TOKconstruct || | |
| 4972 op == TOKblit || | |
| 4973 op == TOKaddass || | |
| 4974 op == TOKminass || | |
| 4975 op == TOKcatass || | |
| 4976 op == TOKmulass || | |
| 4977 op == TOKdivass || | |
| 4978 op == TOKmodass || | |
| 4979 op == TOKshlass || | |
| 4980 op == TOKshrass || | |
| 4981 op == TOKushrass || | |
| 4982 op == TOKandass || | |
| 4983 op == TOKorass || | |
| 4984 op == TOKxorass || | |
| 4985 op == TOKin || | |
| 4986 op == TOKremove) | |
| 4987 return 1; | |
| 4988 return Expression::checkSideEffect(flag); | |
| 4989 } | |
| 4990 | |
| 4991 void BinExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4992 { | |
| 4993 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 4994 buf->writeByte(' '); | |
| 4995 buf->writestring(Token::toChars(op)); | |
| 4996 buf->writeByte(' '); | |
| 4997 expToCBuffer(buf, hgs, e2, (enum PREC)(precedence[op] + 1)); | |
| 4998 } | |
| 4999 | |
| 5000 int BinExp::isunsigned() | |
| 5001 { | |
| 5002 return e1->type->isunsigned() || e2->type->isunsigned(); | |
| 5003 } | |
| 5004 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5005 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5006 int BinExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5007 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5008 return e1->canThrow() || e2->canThrow(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5009 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5010 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5011 |
| 159 | 5012 void BinExp::incompatibleTypes() |
| 5013 { | |
| 5014 error("incompatible types for ((%s) %s (%s)): '%s' and '%s'", | |
| 5015 e1->toChars(), Token::toChars(op), e2->toChars(), | |
| 5016 e1->type->toChars(), e2->type->toChars()); | |
| 5017 } | |
| 5018 | |
| 5019 /************************************************************/ | |
| 5020 | |
| 5021 CompileExp::CompileExp(Loc loc, Expression *e) | |
| 5022 : UnaExp(loc, TOKmixin, sizeof(CompileExp), e) | |
| 5023 { | |
| 5024 } | |
| 5025 | |
| 5026 Expression *CompileExp::semantic(Scope *sc) | |
| 5027 { | |
| 5028 #if LOGSEMANTIC | |
| 5029 printf("CompileExp::semantic('%s')\n", toChars()); | |
| 5030 #endif | |
| 5031 UnaExp::semantic(sc); | |
| 5032 e1 = resolveProperties(sc, e1); | |
| 5033 e1 = e1->optimize(WANTvalue | WANTinterpret); | |
| 5034 if (e1->op != TOKstring) | |
| 5035 { error("argument to mixin must be a string, not (%s)", e1->toChars()); | |
| 5036 type = Type::terror; | |
| 5037 return this; | |
| 5038 } | |
| 5039 StringExp *se = (StringExp *)e1; | |
| 5040 se = se->toUTF8(sc); | |
| 5041 Parser p(sc->module, (unsigned char *)se->string, se->len, 0); | |
| 5042 p.loc = loc; | |
| 5043 p.nextToken(); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5044 //printf("p.loc.linnum = %d\n", p.loc.linnum); |
| 159 | 5045 Expression *e = p.parseExpression(); |
| 5046 if (p.token.value != TOKeof) | |
| 5047 error("incomplete mixin expression (%s)", se->toChars()); | |
| 5048 return e->semantic(sc); | |
| 5049 } | |
| 5050 | |
| 5051 void CompileExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5052 { | |
| 5053 buf->writestring("mixin("); | |
| 5054 expToCBuffer(buf, hgs, e1, PREC_assign); | |
| 5055 buf->writeByte(')'); | |
| 5056 } | |
| 5057 | |
| 5058 /************************************************************/ | |
| 5059 | |
| 5060 FileExp::FileExp(Loc loc, Expression *e) | |
| 5061 : UnaExp(loc, TOKmixin, sizeof(FileExp), e) | |
| 5062 { | |
| 5063 } | |
| 5064 | |
| 5065 Expression *FileExp::semantic(Scope *sc) | |
| 5066 { char *name; | |
| 5067 StringExp *se; | |
| 5068 | |
| 5069 #if LOGSEMANTIC | |
| 5070 printf("FileExp::semantic('%s')\n", toChars()); | |
| 5071 #endif | |
| 5072 UnaExp::semantic(sc); | |
| 5073 e1 = resolveProperties(sc, e1); | |
| 5074 e1 = e1->optimize(WANTvalue); | |
| 5075 if (e1->op != TOKstring) | |
| 5076 { error("file name argument must be a string, not (%s)", e1->toChars()); | |
| 5077 goto Lerror; | |
| 5078 } | |
| 5079 se = (StringExp *)e1; | |
| 5080 se = se->toUTF8(sc); | |
| 5081 name = (char *)se->string; | |
| 5082 | |
| 5083 if (!global.params.fileImppath) | |
| 5084 { error("need -Jpath switch to import text file %s", name); | |
| 5085 goto Lerror; | |
| 5086 } | |
| 5087 | |
| 5088 if (name != FileName::name(name)) | |
| 5089 { error("use -Jpath switch to provide path for filename %s", name); | |
| 5090 goto Lerror; | |
| 5091 } | |
| 5092 | |
| 5093 name = FileName::searchPath(global.filePath, name, 0); | |
| 5094 if (!name) | |
| 5095 { error("file %s cannot be found, check -Jpath", se->toChars()); | |
| 5096 goto Lerror; | |
| 5097 } | |
| 5098 | |
| 5099 if (global.params.verbose) | |
|
794
661384d6a936
Fix warnings on x86-64. By fvbommel.
Christian Kamm <kamm incasoftware de>
parents:
779
diff
changeset
|
5100 printf("file %s\t(%s)\n", (char*)se->string, name); |
| 159 | 5101 |
| 5102 { File f(name); | |
| 5103 if (f.read()) | |
| 5104 { error("cannot read file %s", f.toChars()); | |
| 5105 goto Lerror; | |
| 5106 } | |
| 5107 else | |
| 5108 { | |
| 5109 f.ref = 1; | |
| 5110 se = new StringExp(loc, f.buffer, f.len); | |
| 5111 } | |
| 5112 } | |
| 5113 Lret: | |
| 5114 return se->semantic(sc); | |
| 5115 | |
| 5116 Lerror: | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5117 se = new StringExp(loc, (char *)""); |
| 159 | 5118 goto Lret; |
| 5119 } | |
| 5120 | |
| 5121 void FileExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5122 { | |
| 5123 buf->writestring("import("); | |
| 5124 expToCBuffer(buf, hgs, e1, PREC_assign); | |
| 5125 buf->writeByte(')'); | |
| 5126 } | |
| 5127 | |
| 5128 /************************************************************/ | |
| 5129 | |
| 5130 AssertExp::AssertExp(Loc loc, Expression *e, Expression *msg) | |
| 5131 : UnaExp(loc, TOKassert, sizeof(AssertExp), e) | |
| 5132 { | |
| 5133 this->msg = msg; | |
| 5134 } | |
| 5135 | |
| 5136 Expression *AssertExp::syntaxCopy() | |
| 5137 { | |
| 5138 AssertExp *ae = new AssertExp(loc, e1->syntaxCopy(), | |
| 5139 msg ? msg->syntaxCopy() : NULL); | |
| 5140 return ae; | |
| 5141 } | |
| 5142 | |
| 5143 Expression *AssertExp::semantic(Scope *sc) | |
| 5144 { | |
| 5145 #if LOGSEMANTIC | |
| 5146 printf("AssertExp::semantic('%s')\n", toChars()); | |
| 5147 #endif | |
| 5148 UnaExp::semantic(sc); | |
| 5149 e1 = resolveProperties(sc, e1); | |
| 5150 // BUG: see if we can do compile time elimination of the Assert | |
| 5151 e1 = e1->optimize(WANTvalue); | |
| 5152 e1 = e1->checkToBoolean(); | |
| 5153 if (msg) | |
| 5154 { | |
| 5155 msg = msg->semantic(sc); | |
| 5156 msg = resolveProperties(sc, msg); | |
| 5157 msg = msg->implicitCastTo(sc, Type::tchar->arrayOf()); | |
| 5158 msg = msg->optimize(WANTvalue); | |
| 5159 } | |
| 5160 if (e1->isBool(FALSE)) | |
| 5161 { | |
| 5162 FuncDeclaration *fd = sc->parent->isFuncDeclaration(); | |
| 5163 fd->hasReturnExp |= 4; | |
| 5164 | |
| 5165 if (!global.params.useAssert) | |
| 5166 { Expression *e = new HaltExp(loc); | |
| 5167 e = e->semantic(sc); | |
| 5168 return e; | |
| 5169 } | |
| 5170 } | |
| 5171 type = Type::tvoid; | |
| 5172 return this; | |
| 5173 } | |
| 5174 | |
| 5175 int AssertExp::checkSideEffect(int flag) | |
| 5176 { | |
| 5177 return 1; | |
| 5178 } | |
| 5179 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5180 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5181 int AssertExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5182 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5183 return (global.params.useAssert != 0); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5184 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5185 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5186 |
| 159 | 5187 void AssertExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 5188 { | |
| 5189 buf->writestring("assert("); | |
| 5190 expToCBuffer(buf, hgs, e1, PREC_assign); | |
| 5191 if (msg) | |
| 5192 { | |
| 5193 buf->writeByte(','); | |
| 5194 expToCBuffer(buf, hgs, msg, PREC_assign); | |
| 5195 } | |
| 5196 buf->writeByte(')'); | |
| 5197 } | |
| 5198 | |
| 5199 /************************************************************/ | |
| 5200 | |
| 5201 DotIdExp::DotIdExp(Loc loc, Expression *e, Identifier *ident) | |
| 5202 : UnaExp(loc, TOKdot, sizeof(DotIdExp), e) | |
| 5203 { | |
| 5204 this->ident = ident; | |
| 5205 } | |
| 5206 | |
| 5207 Expression *DotIdExp::semantic(Scope *sc) | |
| 5208 { Expression *e; | |
| 5209 Expression *eleft; | |
| 5210 Expression *eright; | |
| 5211 | |
| 5212 #if LOGSEMANTIC | |
| 5213 printf("DotIdExp::semantic(this = %p, '%s')\n", this, toChars()); | |
| 5214 //printf("e1->op = %d, '%s'\n", e1->op, Token::toChars(e1->op)); | |
| 5215 #endif | |
| 5216 | |
| 5217 //{ static int z; fflush(stdout); if (++z == 10) *(char*)0=0; } | |
| 5218 | |
| 5219 #if 0 | |
| 5220 /* Don't do semantic analysis if we'll be converting | |
| 5221 * it to a string. | |
| 5222 */ | |
| 5223 if (ident == Id::stringof) | |
| 5224 { char *s = e1->toChars(); | |
| 5225 e = new StringExp(loc, s, strlen(s), 'c'); | |
| 5226 e = e->semantic(sc); | |
| 5227 return e; | |
| 5228 } | |
| 5229 #endif | |
| 5230 | |
| 5231 /* Special case: rewrite this.id and super.id | |
| 5232 * to be classtype.id and baseclasstype.id | |
| 5233 * if we have no this pointer. | |
| 5234 */ | |
| 5235 if ((e1->op == TOKthis || e1->op == TOKsuper) && !hasThis(sc)) | |
| 5236 { ClassDeclaration *cd; | |
| 5237 StructDeclaration *sd; | |
| 5238 AggregateDeclaration *ad; | |
| 5239 | |
| 5240 ad = sc->getStructClassScope(); | |
| 5241 if (ad) | |
| 5242 { | |
| 5243 cd = ad->isClassDeclaration(); | |
| 5244 if (cd) | |
| 5245 { | |
| 5246 if (e1->op == TOKthis) | |
| 5247 { | |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5248 e = typeDotIdExp(loc, cd->type, ident); |
| 159 | 5249 return e->semantic(sc); |
| 5250 } | |
| 5251 else if (cd->baseClass && e1->op == TOKsuper) | |
| 5252 { | |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5253 e = typeDotIdExp(loc, cd->baseClass->type, ident); |
| 159 | 5254 return e->semantic(sc); |
| 5255 } | |
| 5256 } | |
| 5257 else | |
| 5258 { | |
| 5259 sd = ad->isStructDeclaration(); | |
| 5260 if (sd) | |
| 5261 { | |
| 5262 if (e1->op == TOKthis) | |
| 5263 { | |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5264 e = typeDotIdExp(loc, sd->type, ident); |
| 159 | 5265 return e->semantic(sc); |
| 5266 } | |
| 5267 } | |
| 5268 } | |
| 5269 } | |
| 5270 } | |
| 5271 | |
| 5272 UnaExp::semantic(sc); | |
| 5273 | |
| 5274 if (e1->op == TOKdotexp) | |
| 5275 { | |
| 5276 DotExp *de = (DotExp *)e1; | |
| 5277 eleft = de->e1; | |
| 5278 eright = de->e2; | |
| 5279 } | |
| 5280 else | |
| 5281 { | |
| 5282 e1 = resolveProperties(sc, e1); | |
| 5283 eleft = NULL; | |
| 5284 eright = e1; | |
| 5285 } | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5286 #if DMDV2 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5287 if (e1->op == TOKtuple && ident == Id::offsetof) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5288 { /* 'distribute' the .offsetof to each of the tuple elements. |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5289 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5290 TupleExp *te = (TupleExp *)e1; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5291 Expressions *exps = new Expressions(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5292 exps->setDim(te->exps->dim); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5293 for (int i = 0; i < exps->dim; i++) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5294 { Expression *e = (Expression *)te->exps->data[i]; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5295 e = e->semantic(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5296 e = new DotIdExp(e->loc, e, Id::offsetof); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5297 exps->data[i] = (void *)e; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5298 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5299 e = new TupleExp(loc, exps); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5300 e = e->semantic(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5301 return e; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5302 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5303 #endif |
| 159 | 5304 |
| 5305 if (e1->op == TOKtuple && ident == Id::length) | |
| 5306 { | |
| 5307 TupleExp *te = (TupleExp *)e1; | |
| 5308 e = new IntegerExp(loc, te->exps->dim, Type::tsize_t); | |
| 5309 return e; | |
| 5310 } | |
| 5311 | |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5312 if (e1->op == TOKdottd) |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5313 { |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5314 error("template %s does not have property %s", e1->toChars(), ident->toChars()); |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5315 return e1; |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5316 } |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5317 |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5318 if (!e1->type) |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5319 { |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5320 error("expression %s does not have property %s", e1->toChars(), ident->toChars()); |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5321 return e1; |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5322 } |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5323 |
| 159 | 5324 if (eright->op == TOKimport) // also used for template alias's |
| 5325 { | |
| 5326 ScopeExp *ie = (ScopeExp *)eright; | |
| 5327 | |
|
846
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
841
diff
changeset
|
5328 /* Disable access to another module's private imports. |
|
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
841
diff
changeset
|
5329 * The check for 'is sds our current module' is because |
|
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
841
diff
changeset
|
5330 * the current module should have access to its own imports. |
|
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
841
diff
changeset
|
5331 */ |
|
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
841
diff
changeset
|
5332 Dsymbol *s = ie->sds->search(loc, ident, |
|
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
841
diff
changeset
|
5333 (ie->sds->isModule() && ie->sds != sc->module) ? 1 : 0); |
| 159 | 5334 if (s) |
| 5335 { | |
| 5336 s = s->toAlias(); | |
| 5337 checkDeprecated(sc, s); | |
| 5338 | |
| 5339 EnumMember *em = s->isEnumMember(); | |
| 5340 if (em) | |
| 5341 { | |
| 5342 e = em->value; | |
| 5343 e = e->semantic(sc); | |
| 5344 return e; | |
| 5345 } | |
| 5346 | |
| 5347 VarDeclaration *v = s->isVarDeclaration(); | |
| 5348 if (v) | |
| 5349 { | |
| 5350 //printf("DotIdExp:: Identifier '%s' is a variable, type '%s'\n", toChars(), v->type->toChars()); | |
| 5351 if (v->inuse) | |
| 5352 { | |
| 5353 error("circular reference to '%s'", v->toChars()); | |
| 5354 type = Type::tint32; | |
| 5355 return this; | |
| 5356 } | |
| 5357 type = v->type; | |
| 5358 if (v->isConst()) | |
| 5359 { | |
| 5360 if (v->init) | |
| 5361 { | |
| 5362 ExpInitializer *ei = v->init->isExpInitializer(); | |
| 5363 if (ei) | |
| 5364 { | |
| 5365 //printf("\tei: %p (%s)\n", ei->exp, ei->exp->toChars()); | |
| 5366 //ei->exp = ei->exp->semantic(sc); | |
| 5367 if (ei->exp->type == type) | |
| 5368 { | |
| 5369 e = ei->exp->copy(); // make copy so we can change loc | |
| 5370 e->loc = loc; | |
| 5371 return e; | |
| 5372 } | |
| 5373 } | |
| 5374 } | |
| 5375 else if (type->isscalar()) | |
| 5376 { | |
| 5377 e = type->defaultInit(); | |
| 5378 e->loc = loc; | |
| 5379 return e; | |
| 5380 } | |
| 5381 } | |
| 5382 if (v->needThis()) | |
| 5383 { | |
| 5384 if (!eleft) | |
| 5385 eleft = new ThisExp(loc); | |
| 5386 e = new DotVarExp(loc, eleft, v); | |
| 5387 e = e->semantic(sc); | |
| 5388 } | |
| 5389 else | |
| 5390 { | |
| 5391 e = new VarExp(loc, v); | |
| 5392 if (eleft) | |
| 5393 { e = new CommaExp(loc, eleft, e); | |
| 5394 e->type = v->type; | |
| 5395 } | |
| 5396 } | |
| 5397 return e->deref(); | |
| 5398 } | |
| 5399 | |
| 5400 FuncDeclaration *f = s->isFuncDeclaration(); | |
| 5401 if (f) | |
| 5402 { | |
| 5403 //printf("it's a function\n"); | |
| 5404 if (f->needThis()) | |
| 5405 { | |
| 5406 if (!eleft) | |
| 5407 eleft = new ThisExp(loc); | |
| 5408 e = new DotVarExp(loc, eleft, f); | |
| 5409 e = e->semantic(sc); | |
| 5410 } | |
| 5411 else | |
| 5412 { | |
| 5413 e = new VarExp(loc, f); | |
| 5414 if (eleft) | |
| 5415 { e = new CommaExp(loc, eleft, e); | |
| 5416 e->type = f->type; | |
| 5417 } | |
| 5418 } | |
| 5419 return e; | |
| 5420 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5421 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5422 OverloadSet *o = s->isOverloadSet(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5423 if (o) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5424 { //printf("'%s' is an overload set\n", o->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5425 return new OverExp(o); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5426 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5427 #endif |
| 159 | 5428 |
| 5429 Type *t = s->getType(); | |
| 5430 if (t) | |
| 5431 { | |
| 5432 return new TypeExp(loc, t); | |
| 5433 } | |
| 5434 | |
| 336 | 5435 TupleDeclaration *tup = s->isTupleDeclaration(); |
| 5436 if (tup) | |
| 5437 { | |
| 5438 if (eleft) | |
| 5439 error("cannot have e.tuple"); | |
| 5440 e = new TupleExp(loc, tup); | |
| 5441 e = e->semantic(sc); | |
| 5442 return e; | |
| 5443 } | |
| 5444 | |
| 159 | 5445 ScopeDsymbol *sds = s->isScopeDsymbol(); |
| 5446 if (sds) | |
| 5447 { | |
| 5448 //printf("it's a ScopeDsymbol\n"); | |
| 5449 e = new ScopeExp(loc, sds); | |
| 5450 e = e->semantic(sc); | |
| 5451 if (eleft) | |
| 5452 e = new DotExp(loc, eleft, e); | |
| 5453 return e; | |
| 5454 } | |
| 5455 | |
| 5456 Import *imp = s->isImport(); | |
| 5457 if (imp) | |
| 5458 { | |
| 5459 ScopeExp *ie; | |
| 5460 | |
| 5461 ie = new ScopeExp(loc, imp->pkg); | |
| 5462 return ie->semantic(sc); | |
| 5463 } | |
| 5464 | |
| 5465 // BUG: handle other cases like in IdentifierExp::semantic() | |
| 5466 #ifdef DEBUG | |
| 5467 printf("s = '%s', kind = '%s'\n", s->toChars(), s->kind()); | |
| 5468 #endif | |
| 5469 assert(0); | |
| 5470 } | |
| 5471 else if (ident == Id::stringof) | |
| 5472 { char *s = ie->toChars(); | |
| 5473 e = new StringExp(loc, s, strlen(s), 'c'); | |
| 5474 e = e->semantic(sc); | |
| 5475 return e; | |
| 5476 } | |
| 5477 error("undefined identifier %s", toChars()); | |
| 5478 type = Type::tvoid; | |
| 5479 return this; | |
| 5480 } | |
| 5481 else if (e1->type->ty == Tpointer && | |
| 5482 ident != Id::init && ident != Id::__sizeof && | |
| 5483 ident != Id::alignof && ident != Id::offsetof && | |
| 5484 ident != Id::mangleof && ident != Id::stringof) | |
| 5485 { | |
| 5486 e = new PtrExp(loc, e1); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5487 e->type = ((TypePointer *)e1->type)->next; |
| 159 | 5488 return e->type->dotExp(sc, e, ident); |
| 5489 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5490 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5491 else if (t1b->ty == Tarray || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5492 t1b->ty == Tsarray || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5493 t1b->ty == Taarray) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5494 { /* If ident is not a valid property, rewrite: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5495 * e1.ident |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5496 * as: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5497 * .ident(e1) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5498 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5499 unsigned errors = global.errors; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5500 global.gag++; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5501 e = e1->type->dotExp(sc, e1, ident); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5502 global.gag--; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5503 if (errors != global.errors) // if failed to find the property |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5504 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5505 global.errors = errors; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5506 e = new DotIdExp(loc, new IdentifierExp(loc, Id::empty), ident); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5507 e = new CallExp(loc, e, e1); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5508 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5509 e = e->semantic(sc); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5510 return e; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5511 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5512 #endif |
| 159 | 5513 else |
| 5514 { | |
| 5515 e = e1->type->dotExp(sc, e1, ident); | |
| 5516 e = e->semantic(sc); | |
| 5517 return e; | |
| 5518 } | |
| 5519 } | |
| 5520 | |
| 5521 void DotIdExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5522 { | |
| 5523 //printf("DotIdExp::toCBuffer()\n"); | |
| 5524 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5525 buf->writeByte('.'); | |
| 5526 buf->writestring(ident->toChars()); | |
| 5527 } | |
| 5528 | |
| 5529 /********************** DotTemplateExp ***********************************/ | |
| 5530 | |
| 5531 // Mainly just a placeholder | |
| 5532 | |
| 5533 DotTemplateExp::DotTemplateExp(Loc loc, Expression *e, TemplateDeclaration *td) | |
| 5534 : UnaExp(loc, TOKdottd, sizeof(DotTemplateExp), e) | |
| 5535 | |
| 5536 { | |
| 5537 this->td = td; | |
| 5538 } | |
| 5539 | |
| 5540 void DotTemplateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5541 { | |
| 5542 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5543 buf->writeByte('.'); | |
| 5544 buf->writestring(td->toChars()); | |
| 5545 } | |
| 5546 | |
| 5547 | |
| 5548 /************************************************************/ | |
| 5549 | |
| 5550 DotVarExp::DotVarExp(Loc loc, Expression *e, Declaration *v) | |
| 5551 : UnaExp(loc, TOKdotvar, sizeof(DotVarExp), e) | |
| 5552 { | |
| 5553 //printf("DotVarExp()\n"); | |
| 5554 this->var = v; | |
| 5555 } | |
| 5556 | |
| 5557 Expression *DotVarExp::semantic(Scope *sc) | |
| 5558 { | |
| 5559 #if LOGSEMANTIC | |
| 5560 printf("DotVarExp::semantic('%s')\n", toChars()); | |
| 5561 #endif | |
| 5562 if (!type) | |
| 5563 { | |
| 5564 var = var->toAlias()->isDeclaration(); | |
| 5565 | |
| 5566 TupleDeclaration *tup = var->isTupleDeclaration(); | |
| 5567 if (tup) | |
| 5568 { /* Replace: | |
| 5569 * e1.tuple(a, b, c) | |
| 5570 * with: | |
| 5571 * tuple(e1.a, e1.b, e1.c) | |
| 5572 */ | |
| 5573 Expressions *exps = new Expressions; | |
| 5574 | |
| 5575 exps->reserve(tup->objects->dim); | |
| 5576 for (size_t i = 0; i < tup->objects->dim; i++) | |
| 5577 { Object *o = (Object *)tup->objects->data[i]; | |
| 5578 if (o->dyncast() != DYNCAST_EXPRESSION) | |
| 5579 { | |
| 5580 error("%s is not an expression", o->toChars()); | |
| 5581 } | |
| 5582 else | |
| 5583 { | |
| 5584 Expression *e = (Expression *)o; | |
| 5585 if (e->op != TOKdsymbol) | |
| 5586 error("%s is not a member", e->toChars()); | |
| 5587 else | |
| 5588 { DsymbolExp *ve = (DsymbolExp *)e; | |
| 5589 | |
| 5590 e = new DotVarExp(loc, e1, ve->s->isDeclaration()); | |
| 5591 exps->push(e); | |
| 5592 } | |
| 5593 } | |
| 5594 } | |
| 5595 Expression *e = new TupleExp(loc, exps); | |
| 5596 e = e->semantic(sc); | |
| 5597 return e; | |
| 5598 } | |
| 5599 | |
| 5600 e1 = e1->semantic(sc); | |
| 5601 type = var->type; | |
| 5602 if (!type && global.errors) | |
| 5603 { // var is goofed up, just return 0 | |
| 5604 return new IntegerExp(0); | |
| 5605 } | |
| 5606 assert(type); | |
| 5607 | |
| 5608 if (!var->isFuncDeclaration()) // for functions, do checks after overload resolution | |
| 5609 { | |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5610 Dsymbol *vparent = var->toParent(); |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5611 AggregateDeclaration *ad = vparent ? vparent->isAggregateDeclaration() : NULL; |
| 336 | 5612 e1 = getRightThis(loc, sc, ad, e1, var); |
| 5613 if (!sc->noaccesscheck) | |
| 5614 accessCheck(loc, sc, e1, var); | |
| 5615 | |
| 5616 VarDeclaration *v = var->isVarDeclaration(); | |
| 5617 if (v && v->isConst()) | |
| 5618 { ExpInitializer *ei = v->getExpInitializer(); | |
| 5619 if (ei) | |
| 5620 { Expression *e = ei->exp->copy(); | |
| 5621 e = e->semantic(sc); | |
| 5622 return e; | |
| 159 | 5623 } |
| 5624 } | |
| 5625 } | |
| 5626 } | |
| 5627 //printf("-DotVarExp::semantic('%s')\n", toChars()); | |
| 5628 return this; | |
| 5629 } | |
| 5630 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5631 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5632 int DotVarExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5633 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5634 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5635 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5636 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5637 |
| 159 | 5638 Expression *DotVarExp::toLvalue(Scope *sc, Expression *e) |
| 5639 { | |
| 5640 //printf("DotVarExp::toLvalue(%s)\n", toChars()); | |
| 5641 return this; | |
| 5642 } | |
| 5643 | |
| 5644 Expression *DotVarExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 5645 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5646 #if 0 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5647 printf("DotVarExp::modifiableLvalue(%s)\n", toChars()); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5648 printf("e1->type = %s\n", e1->type->toChars()); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5649 printf("var->type = %s\n", var->type->toChars()); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5650 #endif |
| 159 | 5651 |
| 5652 if (var->isCtorinit()) | |
| 5653 { // It's only modifiable if inside the right constructor | |
| 5654 Dsymbol *s = sc->func; | |
| 5655 while (1) | |
| 5656 { | |
| 5657 FuncDeclaration *fd = NULL; | |
| 5658 if (s) | |
| 5659 fd = s->isFuncDeclaration(); | |
| 5660 if (fd && | |
| 5661 ((fd->isCtorDeclaration() && var->storage_class & STCfield) || | |
| 5662 (fd->isStaticCtorDeclaration() && !(var->storage_class & STCfield))) && | |
| 5663 fd->toParent() == var->toParent() && | |
| 5664 e1->op == TOKthis | |
| 5665 ) | |
| 5666 { | |
| 5667 VarDeclaration *v = var->isVarDeclaration(); | |
| 5668 assert(v); | |
| 5669 v->ctorinit = 1; | |
| 5670 //printf("setting ctorinit\n"); | |
| 5671 } | |
| 5672 else | |
| 5673 { | |
| 5674 if (s) | |
| 5675 { s = s->toParent2(); | |
| 5676 continue; | |
| 5677 } | |
| 5678 else | |
| 5679 { | |
| 5680 const char *p = var->isStatic() ? "static " : ""; | |
| 5681 error("can only initialize %sconst member %s inside %sconstructor", | |
| 5682 p, var->toChars(), p); | |
| 5683 } | |
| 5684 } | |
| 5685 break; | |
| 5686 } | |
| 5687 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5688 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5689 else |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5690 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5691 Type *t1 = e1->type->toBasetype(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5692 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5693 if (!t1->isMutable() || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5694 (t1->ty == Tpointer && !t1->nextOf()->isMutable()) || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5695 !var->type->isMutable() || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5696 !var->type->isAssignable() || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5697 var->storage_class & STCmanifest |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5698 ) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5699 error("cannot modify const/invariant %s", toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5700 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5701 #endif |
| 159 | 5702 return this; |
| 5703 } | |
| 5704 | |
| 5705 void DotVarExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5706 { | |
| 5707 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5708 buf->writeByte('.'); | |
| 5709 buf->writestring(var->toChars()); | |
| 5710 } | |
| 5711 | |
| 5712 /************************************************************/ | |
| 5713 | |
| 5714 /* Things like: | |
| 5715 * foo.bar!(args) | |
| 5716 */ | |
| 5717 | |
| 5718 DotTemplateInstanceExp::DotTemplateInstanceExp(Loc loc, Expression *e, TemplateInstance *ti) | |
| 5719 : UnaExp(loc, TOKdotti, sizeof(DotTemplateInstanceExp), e) | |
| 5720 { | |
| 5721 //printf("DotTemplateInstanceExp()\n"); | |
| 5722 this->ti = ti; | |
| 5723 } | |
| 5724 | |
| 5725 Expression *DotTemplateInstanceExp::syntaxCopy() | |
| 5726 { | |
| 5727 DotTemplateInstanceExp *de = new DotTemplateInstanceExp(loc, | |
| 5728 e1->syntaxCopy(), | |
| 5729 (TemplateInstance *)ti->syntaxCopy(NULL)); | |
| 5730 return de; | |
| 5731 } | |
| 5732 | |
| 5733 Expression *DotTemplateInstanceExp::semantic(Scope *sc) | |
| 5734 { Dsymbol *s; | |
| 5735 Dsymbol *s2; | |
| 5736 TemplateDeclaration *td; | |
| 5737 Expression *e; | |
| 5738 Identifier *id; | |
| 5739 Type *t1; | |
| 5740 Expression *eleft = NULL; | |
| 5741 Expression *eright; | |
| 5742 | |
| 5743 #if LOGSEMANTIC | |
| 5744 printf("DotTemplateInstanceExp::semantic('%s')\n", toChars()); | |
| 5745 #endif | |
| 5746 //e1->print(); | |
| 5747 //print(); | |
| 5748 e1 = e1->semantic(sc); | |
| 5749 t1 = e1->type; | |
| 5750 if (t1) | |
| 5751 t1 = t1->toBasetype(); | |
| 5752 //t1->print(); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5753 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5754 /* Extract the following from e1: |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5755 * s: the symbol which ti should be a member of |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5756 * eleft: if not NULL, it is the 'this' pointer for ti |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5757 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5758 |
| 159 | 5759 if (e1->op == TOKdotexp) |
| 5760 { DotExp *de = (DotExp *)e1; | |
| 5761 eleft = de->e1; | |
| 5762 eright = de->e2; | |
| 5763 } | |
| 5764 else | |
| 5765 { eleft = NULL; | |
| 5766 eright = e1; | |
| 5767 } | |
| 5768 if (eright->op == TOKimport) | |
| 5769 { | |
| 5770 s = ((ScopeExp *)eright)->sds; | |
| 5771 } | |
| 5772 else if (e1->op == TOKtype) | |
| 5773 { | |
| 5774 s = t1->isClassHandle(); | |
| 5775 if (!s) | |
| 5776 { if (t1->ty == Tstruct) | |
| 5777 s = ((TypeStruct *)t1)->sym; | |
| 5778 else | |
| 5779 goto L1; | |
| 5780 } | |
| 5781 } | |
| 5782 else if (t1 && (t1->ty == Tstruct || t1->ty == Tclass)) | |
| 5783 { | |
| 5784 s = t1->toDsymbol(sc); | |
| 5785 eleft = e1; | |
| 5786 } | |
| 5787 else if (t1 && t1->ty == Tpointer) | |
| 5788 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5789 t1 = ((TypePointer *)t1)->next->toBasetype(); |
| 159 | 5790 if (t1->ty != Tstruct) |
| 5791 goto L1; | |
| 5792 s = t1->toDsymbol(sc); | |
| 5793 eleft = e1; | |
| 5794 } | |
| 5795 else | |
| 5796 { | |
| 5797 L1: | |
| 5798 error("template %s is not a member of %s", ti->toChars(), e1->toChars()); | |
| 5799 goto Lerr; | |
| 5800 } | |
| 5801 | |
| 5802 assert(s); | |
| 5803 id = ti->name; | |
| 5804 s2 = s->search(loc, id, 0); | |
| 5805 if (!s2) | |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5806 { |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5807 if (!s->ident) |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5808 error("template identifier %s is not a member of undefined %s", id->toChars(), s->kind()); |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
5809 else |
|
1258
192529570813
Trivial fix for bug #265
Christian Kamm <kamm incasoftware de>
parents:
1228
diff
changeset
|
5810 error("template identifier %s is not a member of %s %s", id->toChars(), s->kind(), s->ident->toChars()); |
| 159 | 5811 goto Lerr; |
| 5812 } | |
| 5813 s = s2; | |
| 5814 s->semantic(sc); | |
| 5815 s = s->toAlias(); | |
| 5816 td = s->isTemplateDeclaration(); | |
| 5817 if (!td) | |
| 5818 { | |
| 5819 error("%s is not a template", id->toChars()); | |
| 5820 goto Lerr; | |
| 5821 } | |
| 5822 if (global.errors) | |
| 5823 goto Lerr; | |
| 5824 | |
| 5825 ti->tempdecl = td; | |
| 5826 | |
| 5827 if (eleft) | |
| 5828 { Declaration *v; | |
| 5829 | |
| 5830 ti->semantic(sc); | |
| 5831 s = ti->inst->toAlias(); | |
| 5832 v = s->isDeclaration(); | |
| 5833 if (v) | |
| 5834 { e = new DotVarExp(loc, eleft, v); | |
| 5835 e = e->semantic(sc); | |
| 5836 return e; | |
| 5837 } | |
| 5838 } | |
| 5839 | |
| 5840 e = new ScopeExp(loc, ti); | |
| 5841 if (eleft) | |
| 5842 { | |
| 5843 e = new DotExp(loc, eleft, e); | |
| 5844 } | |
| 5845 e = e->semantic(sc); | |
| 5846 return e; | |
| 5847 | |
| 5848 Lerr: | |
| 336 | 5849 return new IntegerExp(loc, 0, Type::tint32); |
| 159 | 5850 } |
| 5851 | |
| 5852 void DotTemplateInstanceExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5853 { | |
| 5854 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5855 buf->writeByte('.'); | |
| 5856 ti->toCBuffer(buf, hgs); | |
| 5857 } | |
| 5858 | |
| 5859 /************************************************************/ | |
| 5860 | |
| 5861 DelegateExp::DelegateExp(Loc loc, Expression *e, FuncDeclaration *f) | |
| 5862 : UnaExp(loc, TOKdelegate, sizeof(DelegateExp), e) | |
| 5863 { | |
| 5864 this->func = f; | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
5865 m = NULL; |
| 159 | 5866 } |
| 5867 | |
| 5868 Expression *DelegateExp::semantic(Scope *sc) | |
| 5869 { | |
| 5870 #if LOGSEMANTIC | |
| 5871 printf("DelegateExp::semantic('%s')\n", toChars()); | |
| 5872 #endif | |
| 5873 if (!type) | |
| 5874 { | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
5875 m = sc->module; |
| 159 | 5876 e1 = e1->semantic(sc); |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
5877 // LDC we need a copy as we store the LLVM tpye in TypeFunction, and delegate/members have different types for 'this' |
|
471
e19e20103119
Changed DMD to make a copy of the TypeFunction in DelegateExp.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
468
diff
changeset
|
5878 type = new TypeDelegate(func->type->syntaxCopy()); |
| 159 | 5879 type = type->semantic(loc, sc); |
| 5880 AggregateDeclaration *ad = func->toParent()->isAggregateDeclaration(); | |
| 336 | 5881 if (func->needThis()) |
| 5882 e1 = getRightThis(loc, sc, ad, e1, func); | |
| 159 | 5883 } |
| 5884 return this; | |
| 5885 } | |
| 5886 | |
| 5887 void DelegateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5888 { | |
| 5889 buf->writeByte('&'); | |
| 5890 if (!func->isNested()) | |
| 5891 { | |
| 5892 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5893 buf->writeByte('.'); | |
| 5894 } | |
| 5895 buf->writestring(func->toChars()); | |
| 5896 } | |
| 5897 | |
| 5898 /************************************************************/ | |
| 5899 | |
| 5900 DotTypeExp::DotTypeExp(Loc loc, Expression *e, Dsymbol *s) | |
| 5901 : UnaExp(loc, TOKdottype, sizeof(DotTypeExp), e) | |
| 5902 { | |
| 5903 this->sym = s; | |
| 5904 this->type = s->getType(); | |
| 5905 } | |
| 5906 | |
| 5907 Expression *DotTypeExp::semantic(Scope *sc) | |
| 5908 { | |
| 5909 #if LOGSEMANTIC | |
| 5910 printf("DotTypeExp::semantic('%s')\n", toChars()); | |
| 5911 #endif | |
| 5912 UnaExp::semantic(sc); | |
| 5913 return this; | |
| 5914 } | |
| 5915 | |
| 5916 void DotTypeExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5917 { | |
| 5918 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5919 buf->writeByte('.'); | |
| 5920 buf->writestring(sym->toChars()); | |
| 5921 } | |
| 5922 | |
| 5923 /************************************************************/ | |
| 5924 | |
| 5925 CallExp::CallExp(Loc loc, Expression *e, Expressions *exps) | |
| 5926 : UnaExp(loc, TOKcall, sizeof(CallExp), e) | |
| 5927 { | |
| 5928 this->arguments = exps; | |
| 5929 } | |
| 5930 | |
| 5931 CallExp::CallExp(Loc loc, Expression *e) | |
| 5932 : UnaExp(loc, TOKcall, sizeof(CallExp), e) | |
| 5933 { | |
| 5934 this->arguments = NULL; | |
| 5935 } | |
| 5936 | |
| 5937 CallExp::CallExp(Loc loc, Expression *e, Expression *earg1) | |
| 5938 : UnaExp(loc, TOKcall, sizeof(CallExp), e) | |
| 5939 { | |
| 5940 Expressions *arguments = new Expressions(); | |
| 5941 arguments->setDim(1); | |
| 5942 arguments->data[0] = (void *)earg1; | |
| 5943 | |
| 5944 this->arguments = arguments; | |
| 5945 } | |
| 5946 | |
| 5947 CallExp::CallExp(Loc loc, Expression *e, Expression *earg1, Expression *earg2) | |
| 5948 : UnaExp(loc, TOKcall, sizeof(CallExp), e) | |
| 5949 { | |
| 5950 Expressions *arguments = new Expressions(); | |
| 5951 arguments->setDim(2); | |
| 5952 arguments->data[0] = (void *)earg1; | |
| 5953 arguments->data[1] = (void *)earg2; | |
| 5954 | |
| 5955 this->arguments = arguments; | |
| 5956 } | |
| 5957 | |
| 5958 Expression *CallExp::syntaxCopy() | |
| 5959 { | |
| 5960 return new CallExp(loc, e1->syntaxCopy(), arraySyntaxCopy(arguments)); | |
| 5961 } | |
| 5962 | |
| 5963 | |
| 5964 Expression *CallExp::semantic(Scope *sc) | |
| 5965 { | |
| 5966 TypeFunction *tf; | |
| 5967 FuncDeclaration *f; | |
| 5968 int i; | |
| 5969 Type *t1; | |
| 5970 int istemp; | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5971 Objects *targsi = NULL; // initial list of template arguments |
| 159 | 5972 |
| 5973 #if LOGSEMANTIC | |
| 5974 printf("CallExp::semantic() %s\n", toChars()); | |
| 5975 #endif | |
| 5976 if (type) | |
| 5977 return this; // semantic() already run | |
| 5978 #if 0 | |
| 5979 if (arguments && arguments->dim) | |
| 5980 { | |
| 5981 Expression *earg = (Expression *)arguments->data[0]; | |
| 5982 earg->print(); | |
| 5983 if (earg->type) earg->type->print(); | |
| 5984 } | |
| 5985 #endif | |
| 5986 | |
| 5987 if (e1->op == TOKdelegate) | |
| 5988 { DelegateExp *de = (DelegateExp *)e1; | |
| 5989 | |
| 5990 e1 = new DotVarExp(de->loc, de->e1, de->func); | |
| 5991 return semantic(sc); | |
| 5992 } | |
| 5993 | |
| 5994 /* Transform: | |
| 5995 * array.id(args) into id(array,args) | |
| 5996 * aa.remove(arg) into delete aa[arg] | |
| 5997 */ | |
| 5998 if (e1->op == TOKdot) | |
| 5999 { | |
| 6000 // BUG: we should handle array.a.b.c.e(args) too | |
| 6001 | |
| 6002 DotIdExp *dotid = (DotIdExp *)(e1); | |
| 6003 dotid->e1 = dotid->e1->semantic(sc); | |
| 6004 assert(dotid->e1); | |
| 6005 if (dotid->e1->type) | |
| 6006 { | |
| 6007 TY e1ty = dotid->e1->type->toBasetype()->ty; | |
| 6008 if (e1ty == Taarray && dotid->ident == Id::remove) | |
| 6009 { | |
| 6010 if (!arguments || arguments->dim != 1) | |
| 6011 { error("expected key as argument to aa.remove()"); | |
| 6012 goto Lagain; | |
| 6013 } | |
| 6014 Expression *key = (Expression *)arguments->data[0]; | |
| 6015 key = key->semantic(sc); | |
| 6016 key = resolveProperties(sc, key); | |
| 6017 key->rvalue(); | |
| 6018 | |
| 6019 TypeAArray *taa = (TypeAArray *)dotid->e1->type->toBasetype(); | |
| 6020 key = key->implicitCastTo(sc, taa->index); | |
| 6021 key = key->implicitCastTo(sc, taa->key); | |
| 6022 | |
| 6023 return new RemoveExp(loc, dotid->e1, key); | |
| 6024 } | |
| 6025 else if (e1ty == Tarray || e1ty == Tsarray || e1ty == Taarray) | |
| 6026 { | |
| 6027 if (!arguments) | |
| 6028 arguments = new Expressions(); | |
| 6029 arguments->shift(dotid->e1); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6030 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6031 e1 = new DotIdExp(dotid->loc, new IdentifierExp(dotid->loc, Id::empty), dotid->ident); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6032 #else |
| 159 | 6033 e1 = new IdentifierExp(dotid->loc, dotid->ident); |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6034 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6035 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6036 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6037 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6038 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6039 #if 1 |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6040 /* This recognizes: |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6041 * foo!(tiargs)(funcargs) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6042 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6043 if (e1->op == TOKimport && !e1->type) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6044 { ScopeExp *se = (ScopeExp *)e1; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6045 TemplateInstance *ti = se->sds->isTemplateInstance(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6046 if (ti && !ti->semanticdone) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6047 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6048 /* Attempt to instantiate ti. If that works, go with it. |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6049 * If not, go with partial explicit specialization. |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6050 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6051 ti->semanticTiargs(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6052 unsigned errors = global.errors; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6053 global.gag++; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6054 ti->semantic(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6055 global.gag--; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6056 if (errors != global.errors) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6057 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6058 /* Didn't work, go with partial explicit specialization |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6059 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6060 global.errors = errors; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6061 targsi = ti->tiargs; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6062 e1 = new IdentifierExp(loc, ti->name); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6063 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6064 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6065 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6066 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6067 /* This recognizes: |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6068 * expr.foo!(tiargs)(funcargs) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6069 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6070 if (e1->op == TOKdotti && !e1->type) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6071 { DotTemplateInstanceExp *se = (DotTemplateInstanceExp *)e1; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6072 TemplateInstance *ti = se->ti; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6073 if (!ti->semanticdone) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6074 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6075 /* Attempt to instantiate ti. If that works, go with it. |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6076 * If not, go with partial explicit specialization. |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6077 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6078 ti->semanticTiargs(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6079 Expression *etmp; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6080 unsigned errors = global.errors; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6081 global.gag++; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6082 etmp = e1->semantic(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6083 global.gag--; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6084 if (errors != global.errors) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6085 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6086 global.errors = errors; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6087 targsi = ti->tiargs; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6088 e1 = new DotIdExp(loc, se->e1, ti->name); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6089 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6090 else |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6091 e1 = etmp; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6092 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6093 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6094 #endif |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6095 |
| 159 | 6096 istemp = 0; |
| 6097 Lagain: | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6098 //printf("Lagain: %s\n", toChars()); |
| 159 | 6099 f = NULL; |
| 6100 if (e1->op == TOKthis || e1->op == TOKsuper) | |
| 6101 { | |
| 6102 // semantic() run later for these | |
| 6103 } | |
| 6104 else | |
| 6105 { | |
| 6106 UnaExp::semantic(sc); | |
| 6107 | |
| 6108 /* Look for e1 being a lazy parameter | |
| 6109 */ | |
| 6110 if (e1->op == TOKvar) | |
| 6111 { VarExp *ve = (VarExp *)e1; | |
| 6112 | |
| 6113 if (ve->var->storage_class & STClazy) | |
| 6114 { | |
| 6115 TypeFunction *tf = new TypeFunction(NULL, ve->var->type, 0, LINKd); | |
| 6116 TypeDelegate *t = new TypeDelegate(tf); | |
| 6117 ve->type = t->semantic(loc, sc); | |
| 6118 } | |
| 6119 } | |
| 6120 | |
| 6121 if (e1->op == TOKimport) | |
| 6122 { // Perhaps this should be moved to ScopeExp::semantic() | |
| 6123 ScopeExp *se = (ScopeExp *)e1; | |
| 6124 e1 = new DsymbolExp(loc, se->sds); | |
| 6125 e1 = e1->semantic(sc); | |
| 6126 } | |
| 6127 #if 1 // patch for #540 by Oskar Linde | |
| 6128 else if (e1->op == TOKdotexp) | |
| 6129 { | |
| 6130 DotExp *de = (DotExp *) e1; | |
| 6131 | |
| 6132 if (de->e2->op == TOKimport) | |
| 6133 { // This should *really* be moved to ScopeExp::semantic() | |
| 6134 ScopeExp *se = (ScopeExp *)de->e2; | |
| 6135 de->e2 = new DsymbolExp(loc, se->sds); | |
| 6136 de->e2 = de->e2->semantic(sc); | |
| 6137 } | |
| 6138 | |
| 6139 if (de->e2->op == TOKtemplate) | |
| 6140 { TemplateExp *te = (TemplateExp *) de->e2; | |
| 6141 e1 = new DotTemplateExp(loc,de->e1,te->td); | |
| 6142 } | |
| 6143 } | |
| 6144 #endif | |
| 6145 } | |
| 6146 | |
| 6147 if (e1->op == TOKcomma) | |
| 6148 { | |
| 6149 CommaExp *ce = (CommaExp *)e1; | |
| 6150 | |
| 6151 e1 = ce->e2; | |
| 6152 e1->type = ce->type; | |
| 6153 ce->e2 = this; | |
| 6154 ce->type = NULL; | |
| 6155 return ce->semantic(sc); | |
| 6156 } | |
| 6157 | |
| 6158 t1 = NULL; | |
| 6159 if (e1->type) | |
| 6160 t1 = e1->type->toBasetype(); | |
| 6161 | |
| 6162 // Check for call operator overload | |
| 6163 if (t1) | |
| 6164 { AggregateDeclaration *ad; | |
| 6165 | |
| 6166 if (t1->ty == Tstruct) | |
| 6167 { | |
| 6168 ad = ((TypeStruct *)t1)->sym; | |
| 6169 if (search_function(ad, Id::call)) | |
| 6170 goto L1; // overload of opCall, therefore it's a call | |
| 6171 | |
| 6172 if (e1->op != TOKtype) | |
| 6173 error("%s %s does not overload ()", ad->kind(), ad->toChars()); | |
| 6174 /* It's a struct literal | |
| 6175 */ | |
| 6176 Expression *e = new StructLiteralExp(loc, (StructDeclaration *)ad, arguments); | |
| 6177 e = e->semantic(sc); | |
| 6178 e->type = e1->type; // in case e1->type was a typedef | |
| 6179 return e; | |
| 6180 } | |
| 6181 else if (t1->ty == Tclass) | |
| 6182 { | |
| 6183 ad = ((TypeClass *)t1)->sym; | |
| 6184 goto L1; | |
| 6185 L1: | |
| 6186 // Rewrite as e1.call(arguments) | |
| 6187 Expression *e = new DotIdExp(loc, e1, Id::call); | |
| 6188 e = new CallExp(loc, e, arguments); | |
| 6189 e = e->semantic(sc); | |
| 6190 return e; | |
| 6191 } | |
| 6192 } | |
| 6193 | |
| 6194 arrayExpressionSemantic(arguments, sc); | |
| 6195 preFunctionArguments(loc, sc, arguments); | |
| 6196 | |
| 6197 if (e1->op == TOKdotvar && t1->ty == Tfunction || | |
| 6198 e1->op == TOKdottd) | |
| 6199 { | |
| 6200 DotVarExp *dve; | |
| 6201 DotTemplateExp *dte; | |
| 6202 AggregateDeclaration *ad; | |
| 6203 UnaExp *ue = (UnaExp *)(e1); | |
| 336 | 6204 |
| 159 | 6205 if (e1->op == TOKdotvar) |
| 6206 { // Do overload resolution | |
| 6207 dve = (DotVarExp *)(e1); | |
| 6208 | |
| 6209 f = dve->var->isFuncDeclaration(); | |
| 6210 assert(f); | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
6211 f = f->overloadResolve(loc, arguments, sc->module); |
| 159 | 6212 |
| 6213 ad = f->toParent()->isAggregateDeclaration(); | |
| 6214 } | |
| 6215 else | |
| 6216 { dte = (DotTemplateExp *)(e1); | |
| 6217 TemplateDeclaration *td = dte->td; | |
| 6218 assert(td); | |
| 6219 if (!arguments) | |
| 6220 // Should fix deduceFunctionTemplate() so it works on NULL argument | |
| 6221 arguments = new Expressions(); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6222 f = td->deduceFunctionTemplate(sc, loc, targsi, NULL, arguments); |
| 159 | 6223 if (!f) |
| 6224 { type = Type::terror; | |
| 6225 return this; | |
| 6226 } | |
| 6227 ad = td->toParent()->isAggregateDeclaration(); | |
| 6228 } | |
| 336 | 6229 if (f->needThis()) |
| 6230 { | |
| 6231 ue->e1 = getRightThis(loc, sc, ad, ue->e1, f); | |
| 6232 } | |
| 6233 | |
| 6234 /* Cannot call public functions from inside invariant | |
| 6235 * (because then the invariant would have infinite recursion) | |
| 159 | 6236 */ |
| 336 | 6237 if (sc->func && sc->func->isInvariantDeclaration() && |
| 6238 ue->e1->op == TOKthis && | |
| 6239 f->addPostInvariant() | |
| 159 | 6240 ) |
| 6241 { | |
| 336 | 6242 error("cannot call public/export function %s from invariant", f->toChars()); |
| 159 | 6243 } |
| 6244 | |
| 6245 checkDeprecated(sc, f); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6246 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6247 checkPurity(sc, f); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6248 #endif |
| 159 | 6249 accessCheck(loc, sc, ue->e1, f); |
| 6250 if (!f->needThis()) | |
| 6251 { | |
| 6252 VarExp *ve = new VarExp(loc, f); | |
| 6253 e1 = new CommaExp(loc, ue->e1, ve); | |
| 6254 e1->type = f->type; | |
| 6255 } | |
| 6256 else | |
| 6257 { | |
| 6258 if (e1->op == TOKdotvar) | |
| 6259 dve->var = f; | |
| 6260 else | |
| 6261 e1 = new DotVarExp(loc, dte->e1, f); | |
| 6262 e1->type = f->type; | |
| 6263 | |
| 6264 // See if we need to adjust the 'this' pointer | |
| 6265 AggregateDeclaration *ad = f->isThis(); | |
| 6266 ClassDeclaration *cd = ue->e1->type->isClassHandle(); | |
| 6267 if (ad && cd && ad->isClassDeclaration() && ad != cd && | |
| 6268 ue->e1->op != TOKsuper) | |
| 6269 { | |
| 6270 ue->e1 = ue->e1->castTo(sc, ad->type); //new CastExp(loc, ue->e1, ad->type); | |
| 6271 ue->e1 = ue->e1->semantic(sc); | |
| 6272 } | |
| 6273 } | |
| 6274 t1 = e1->type; | |
| 6275 } | |
| 6276 else if (e1->op == TOKsuper) | |
| 6277 { | |
| 6278 // Base class constructor call | |
| 6279 ClassDeclaration *cd = NULL; | |
| 6280 | |
| 6281 if (sc->func) | |
| 6282 cd = sc->func->toParent()->isClassDeclaration(); | |
| 6283 if (!cd || !cd->baseClass || !sc->func->isCtorDeclaration()) | |
| 6284 { | |
| 6285 error("super class constructor call must be in a constructor"); | |
| 6286 type = Type::terror; | |
| 6287 return this; | |
| 6288 } | |
| 6289 else | |
| 6290 { | |
| 6291 f = cd->baseClass->ctor; | |
| 6292 if (!f) | |
| 6293 { error("no super class constructor for %s", cd->baseClass->toChars()); | |
| 6294 type = Type::terror; | |
| 6295 return this; | |
| 6296 } | |
| 6297 else | |
| 6298 { | |
| 336 | 6299 if (!sc->intypeof) |
| 6300 { | |
| 159 | 6301 #if 0 |
| 336 | 6302 if (sc->callSuper & (CSXthis | CSXsuper)) |
| 6303 error("reference to this before super()"); | |
| 159 | 6304 #endif |
| 336 | 6305 if (sc->noctor || sc->callSuper & CSXlabel) |
| 6306 error("constructor calls not allowed in loops or after labels"); | |
| 6307 if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor)) | |
| 6308 error("multiple constructor calls"); | |
| 6309 sc->callSuper |= CSXany_ctor | CSXsuper_ctor; | |
| 6310 } | |
| 159 | 6311 |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
6312 f = f->overloadResolve(loc, arguments, sc->module); |
| 159 | 6313 checkDeprecated(sc, f); |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6314 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6315 checkPurity(sc, f); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6316 #endif |
| 159 | 6317 e1 = new DotVarExp(e1->loc, e1, f); |
| 6318 e1 = e1->semantic(sc); | |
| 6319 t1 = e1->type; | |
| 6320 } | |
| 6321 } | |
| 6322 } | |
| 6323 else if (e1->op == TOKthis) | |
| 6324 { | |
| 6325 // same class constructor call | |
| 6326 ClassDeclaration *cd = NULL; | |
| 6327 | |
| 6328 if (sc->func) | |
| 6329 cd = sc->func->toParent()->isClassDeclaration(); | |
| 6330 if (!cd || !sc->func->isCtorDeclaration()) | |
| 6331 { | |
| 6332 error("class constructor call must be in a constructor"); | |
| 6333 type = Type::terror; | |
| 6334 return this; | |
| 6335 } | |
| 6336 else | |
| 6337 { | |
| 336 | 6338 if (!sc->intypeof) |
| 6339 { | |
| 159 | 6340 #if 0 |
| 336 | 6341 if (sc->callSuper & (CSXthis | CSXsuper)) |
| 6342 error("reference to this before super()"); | |
| 159 | 6343 #endif |
| 336 | 6344 if (sc->noctor || sc->callSuper & CSXlabel) |
| 6345 error("constructor calls not allowed in loops or after labels"); | |
| 6346 if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor)) | |
| 6347 error("multiple constructor calls"); | |
| 6348 sc->callSuper |= CSXany_ctor | CSXthis_ctor; | |
| 6349 } | |
| 159 | 6350 |
| 6351 f = cd->ctor; | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
6352 f = f->overloadResolve(loc, arguments, sc->module); |
| 159 | 6353 checkDeprecated(sc, f); |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6354 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6355 checkPurity(sc, f); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6356 #endif |
| 159 | 6357 e1 = new DotVarExp(e1->loc, e1, f); |
| 6358 e1 = e1->semantic(sc); | |
| 6359 t1 = e1->type; | |
| 6360 | |
| 6361 // BUG: this should really be done by checking the static | |
| 6362 // call graph | |
| 6363 if (f == sc->func) | |
| 6364 error("cyclic constructor call"); | |
| 6365 } | |
| 6366 } | |
| 6367 else if (!t1) | |
| 6368 { | |
| 6369 error("function expected before (), not '%s'", e1->toChars()); | |
| 6370 type = Type::terror; | |
| 6371 return this; | |
| 6372 } | |
| 6373 else if (t1->ty != Tfunction) | |
| 6374 { | |
| 6375 if (t1->ty == Tdelegate) | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6376 { TypeDelegate *td = (TypeDelegate *)t1; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6377 assert(td->next->ty == Tfunction); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6378 tf = (TypeFunction *)(td->next); |
| 159 | 6379 goto Lcheckargs; |
| 6380 } | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6381 else if (t1->ty == Tpointer && ((TypePointer *)t1)->next->ty == Tfunction) |
| 159 | 6382 { Expression *e; |
| 6383 | |
| 6384 e = new PtrExp(loc, e1); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6385 t1 = ((TypePointer *)t1)->next; |
| 159 | 6386 e->type = t1; |
| 6387 e1 = e; | |
| 6388 } | |
| 6389 else if (e1->op == TOKtemplate) | |
| 6390 { | |
| 6391 TemplateExp *te = (TemplateExp *)e1; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6392 f = te->td->deduceFunctionTemplate(sc, loc, targsi, NULL, arguments); |
| 159 | 6393 if (!f) |
| 6394 { type = Type::terror; | |
| 6395 return this; | |
| 6396 } | |
| 6397 if (f->needThis() && hasThis(sc)) | |
| 6398 { | |
| 6399 // Supply an implicit 'this', as in | |
| 6400 // this.ident | |
| 6401 | |
| 6402 e1 = new DotTemplateExp(loc, (new ThisExp(loc))->semantic(sc), te->td); | |
| 6403 goto Lagain; | |
| 6404 } | |
| 6405 | |
| 6406 e1 = new VarExp(loc, f); | |
| 6407 goto Lagain; | |
| 6408 } | |
| 6409 else | |
| 6410 { error("function expected before (), not %s of type %s", e1->toChars(), e1->type->toChars()); | |
| 6411 type = Type::terror; | |
| 6412 return this; | |
| 6413 } | |
| 6414 } | |
| 6415 else if (e1->op == TOKvar) | |
| 6416 { | |
| 6417 // Do overload resolution | |
| 6418 VarExp *ve = (VarExp *)e1; | |
| 6419 | |
| 6420 f = ve->var->isFuncDeclaration(); | |
| 6421 assert(f); | |
| 6422 | |
| 6423 // Look to see if f is really a function template | |
| 6424 if (0 && !istemp && f->parent) | |
| 6425 { TemplateInstance *ti = f->parent->isTemplateInstance(); | |
| 6426 | |
| 6427 if (ti && | |
| 6428 (ti->name == f->ident || | |
| 6429 ti->toAlias()->ident == f->ident) | |
| 6430 && | |
| 6431 ti->tempdecl) | |
| 6432 { | |
| 6433 /* This is so that one can refer to the enclosing | |
| 6434 * template, even if it has the same name as a member | |
| 6435 * of the template, if it has a !(arguments) | |
| 6436 */ | |
| 6437 TemplateDeclaration *tempdecl = ti->tempdecl; | |
| 6438 if (tempdecl->overroot) // if not start of overloaded list of TemplateDeclaration's | |
| 6439 tempdecl = tempdecl->overroot; // then get the start | |
| 6440 e1 = new TemplateExp(loc, tempdecl); | |
| 6441 istemp = 1; | |
| 6442 goto Lagain; | |
| 6443 } | |
| 6444 } | |
| 6445 | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
6446 f = f->overloadResolve(loc, arguments, sc->module); |
| 159 | 6447 checkDeprecated(sc, f); |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6448 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6449 checkPurity(sc, f); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6450 #endif |
| 159 | 6451 |
| 6452 if (f->needThis() && hasThis(sc)) | |
| 6453 { | |
| 6454 // Supply an implicit 'this', as in | |
| 6455 // this.ident | |
| 6456 | |
| 6457 e1 = new DotVarExp(loc, new ThisExp(loc), f); | |
| 6458 goto Lagain; | |
| 6459 } | |
| 6460 | |
| 6461 accessCheck(loc, sc, NULL, f); | |
| 6462 | |
| 6463 ve->var = f; | |
| 6464 ve->type = f->type; | |
| 6465 t1 = f->type; | |
| 6466 } | |
| 6467 assert(t1->ty == Tfunction); | |
| 6468 tf = (TypeFunction *)(t1); | |
| 6469 | |
| 6470 Lcheckargs: | |
| 6471 assert(tf->ty == Tfunction); | |
| 6472 type = tf->next; | |
| 6473 | |
| 6474 if (!arguments) | |
| 6475 arguments = new Expressions(); | |
| 6476 functionArguments(loc, sc, tf, arguments); | |
| 6477 | |
| 6478 assert(type); | |
| 6479 | |
| 6480 if (f && f->tintro) | |
| 6481 { | |
| 6482 Type *t = type; | |
| 6483 int offset = 0; | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6484 TypeFunction *tf = (TypeFunction *)f->tintro; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6485 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6486 if (tf->next->isBaseOf(t, &offset) && offset) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6487 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6488 type = tf->next; |
| 159 | 6489 return castTo(sc, t); |
| 6490 } | |
| 6491 } | |
| 6492 | |
| 6493 return this; | |
| 6494 } | |
| 6495 | |
| 6496 int CallExp::checkSideEffect(int flag) | |
| 6497 { | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6498 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6499 if (flag != 2) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6500 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6501 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6502 if (e1->checkSideEffect(2)) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6503 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6504 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6505 /* If any of the arguments have side effects, this expression does |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6506 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6507 for (size_t i = 0; i < arguments->dim; i++) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6508 { Expression *e = (Expression *)arguments->data[i]; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6509 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6510 if (e->checkSideEffect(2)) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6511 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6512 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6513 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6514 /* If calling a function or delegate that is typed as pure, |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6515 * then this expression has no side effects. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6516 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6517 Type *t = e1->type->toBasetype(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6518 if (t->ty == Tfunction && ((TypeFunction *)t)->ispure) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6519 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6520 if (t->ty == Tdelegate && ((TypeFunction *)((TypeDelegate *)t)->next)->ispure) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6521 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6522 #endif |
| 159 | 6523 return 1; |
| 6524 } | |
| 6525 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6526 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6527 int CallExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6528 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6529 if (e1->canThrow()) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6530 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6531 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6532 /* If any of the arguments can throw, then this expression can throw |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6533 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6534 for (size_t i = 0; i < arguments->dim; i++) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6535 { Expression *e = (Expression *)arguments->data[i]; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6536 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6537 if (e->canThrow()) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6538 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6539 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6540 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6541 /* If calling a function or delegate that is typed as nothrow, |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6542 * then this expression cannot throw. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6543 * Note that pure functions can throw. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6544 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6545 Type *t = e1->type->toBasetype(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6546 if (t->ty == Tfunction && ((TypeFunction *)t)->isnothrow) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6547 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6548 if (t->ty == Tdelegate && ((TypeFunction *)((TypeDelegate *)t)->next)->isnothrow) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6549 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6550 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6551 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6552 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6553 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6554 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6555 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6556 int CallExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6557 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6558 if (type->toBasetype()->ty == Tstruct) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6559 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6560 Type *tb = e1->type->toBasetype(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6561 if (tb->ty == Tfunction && ((TypeFunction *)tb)->isref) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6562 return 1; // function returns a reference |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6563 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6564 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6565 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6566 |
| 159 | 6567 Expression *CallExp::toLvalue(Scope *sc, Expression *e) |
| 6568 { | |
| 6569 if (type->toBasetype()->ty == Tstruct) | |
| 6570 return this; | |
| 6571 else | |
| 6572 return Expression::toLvalue(sc, e); | |
| 6573 } | |
| 6574 | |
| 6575 void CallExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 6576 { int i; | |
| 6577 | |
| 6578 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 6579 buf->writeByte('('); | |
| 6580 argsToCBuffer(buf, arguments, hgs); | |
| 6581 buf->writeByte(')'); | |
| 6582 } | |
| 6583 | |
| 6584 | |
| 6585 /************************************************************/ | |
| 6586 | |
| 6587 AddrExp::AddrExp(Loc loc, Expression *e) | |
| 6588 : UnaExp(loc, TOKaddress, sizeof(AddrExp), e) | |
| 6589 { | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
6590 m = NULL; |
| 159 | 6591 } |
| 6592 | |
| 6593 Expression *AddrExp::semantic(Scope *sc) | |
| 6594 { | |
| 6595 #if LOGSEMANTIC | |
| 6596 printf("AddrExp::semantic('%s')\n", toChars()); | |
| 6597 #endif | |
| 6598 if (!type) | |
| 6599 { | |
|
1358
78038e540342
Fix overload resolution issue in dmd bug 313/314 fix.
Christian Kamm <kamm incasoftware de>
parents:
1258
diff
changeset
|
6600 m = sc->module; |
| 159 | 6601 UnaExp::semantic(sc); |
| 6602 e1 = e1->toLvalue(sc, NULL); | |
| 6603 if (!e1->type) | |
| 6604 { | |
| 6605 error("cannot take address of %s", e1->toChars()); | |
| 6606 type = Type::tint32; | |
| 6607 return this; | |
| 6608 } | |
| 6609 type = e1->type->pointerTo(); | |
| 6610 | |
| 6611 // See if this should really be a delegate | |
| 6612 if (e1->op == TOKdotvar) | |
| 6613 { | |
| 6614 DotVarExp *dve = (DotVarExp *)e1; | |
| 6615 FuncDeclaration *f = dve->var->isFuncDeclaration(); | |
| 6616 | |
| 6617 if (f) | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6618 { Expression *e = new DelegateExp(loc, dve->e1, f); |
| 159 | 6619 e = e->semantic(sc); |
| 6620 return e; | |
| 6621 } | |
| 6622 } | |
| 6623 else if (e1->op == TOKvar) | |
| 6624 { | |
| 6625 VarExp *dve = (VarExp *)e1; | |
| 6626 FuncDeclaration *f = dve->var->isFuncDeclaration(); | |
| 6627 VarDeclaration *v = dve->var->isVarDeclaration(); | |
| 6628 | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
6629 // LDC |
|
486
a34078905d01
Added pragma(llvmdc, "string") for misc per-module compiler configuration, currently "string" can only be "verbose" which forces -vv for module it appears in.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
471
diff
changeset
|
6630 if (f && f->isIntrinsic()) |
|
a34078905d01
Added pragma(llvmdc, "string") for misc per-module compiler configuration, currently "string" can only be "verbose" which forces -vv for module it appears in.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
471
diff
changeset
|
6631 { |
|
a34078905d01
Added pragma(llvmdc, "string") for misc per-module compiler configuration, currently "string" can only be "verbose" which forces -vv for module it appears in.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
471
diff
changeset
|
6632 error("cannot take the address of intrinsic function %s", e1->toChars()); |
|
a34078905d01
Added pragma(llvmdc, "string") for misc per-module compiler configuration, currently "string" can only be "verbose" which forces -vv for module it appears in.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
471
diff
changeset
|
6633 return this; |
|
a34078905d01
Added pragma(llvmdc, "string") for misc per-module compiler configuration, currently "string" can only be "verbose" which forces -vv for module it appears in.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
471
diff
changeset
|
6634 } |
|
a34078905d01
Added pragma(llvmdc, "string") for misc per-module compiler configuration, currently "string" can only be "verbose" which forces -vv for module it appears in.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
471
diff
changeset
|
6635 |
| 159 | 6636 if (f && f->isNested()) |
| 6637 { Expression *e; | |
| 6638 | |
| 6639 e = new DelegateExp(loc, e1, f); | |
| 6640 e = e->semantic(sc); | |
| 6641 return e; | |
| 6642 } | |
| 6643 } | |
| 6644 else if (e1->op == TOKarray) | |
| 6645 { | |
| 6646 if (e1->type->toBasetype()->ty == Tbit) | |
| 6647 error("cannot take address of bit in array"); | |
| 6648 } | |
| 6649 return optimize(WANTvalue); | |
| 6650 } | |
| 6651 return this; | |
| 6652 } | |
| 6653 | |
| 6654 /************************************************************/ | |
| 6655 | |
| 6656 PtrExp::PtrExp(Loc loc, Expression *e) | |
| 6657 : UnaExp(loc, TOKstar, sizeof(PtrExp), e) | |
| 6658 { | |
| 6659 if (e->type) | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6660 type = ((TypePointer *)e->type)->next; |
| 159 | 6661 } |
| 6662 | |
| 6663 PtrExp::PtrExp(Loc loc, Expression *e, Type *t) | |
| 6664 : UnaExp(loc, TOKstar, sizeof(PtrExp), e) | |
| 6665 { | |
| 6666 type = t; | |
| 6667 } | |
| 6668 | |
| 6669 Expression *PtrExp::semantic(Scope *sc) | |
| 6670 { Type *tb; | |
| 6671 | |
| 6672 #if LOGSEMANTIC | |
| 6673 printf("PtrExp::semantic('%s')\n", toChars()); | |
| 6674 #endif | |
| 6675 UnaExp::semantic(sc); | |
| 6676 e1 = resolveProperties(sc, e1); | |
| 6677 if (type) | |
| 6678 return this; | |
| 6679 if (!e1->type) | |
| 6680 printf("PtrExp::semantic('%s')\n", toChars()); | |
| 6681 tb = e1->type->toBasetype(); | |
| 6682 switch (tb->ty) | |
| 6683 { | |
| 6684 case Tpointer: | |
| 6685 type = tb->next; | |
| 6686 if (type->isbit()) | |
| 6687 { Expression *e; | |
| 6688 | |
| 6689 // Rewrite *p as p[0] | |
| 6690 e = new IndexExp(loc, e1, new IntegerExp(0)); | |
| 6691 return e->semantic(sc); | |
| 6692 } | |
| 6693 break; | |
| 6694 | |
| 6695 case Tsarray: | |
| 6696 case Tarray: | |
| 6697 type = tb->next; | |
| 6698 e1 = e1->castTo(sc, type->pointerTo()); | |
| 6699 break; | |
| 6700 | |
| 6701 default: | |
| 6702 error("can only * a pointer, not a '%s'", e1->type->toChars()); | |
| 6703 type = Type::tint32; | |
| 6704 break; | |
| 6705 } | |
| 6706 rvalue(); | |
| 6707 return this; | |
| 6708 } | |
| 6709 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6710 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6711 int PtrExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6712 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6713 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6714 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6715 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6716 |
| 159 | 6717 Expression *PtrExp::toLvalue(Scope *sc, Expression *e) |
| 6718 { | |
| 6719 #if 0 | |
| 6720 tym = tybasic(e1->ET->Tty); | |
| 6721 if (!(tyscalar(tym) || | |
| 6722 tym == TYstruct || | |
| 6723 tym == TYarray && e->Eoper == TOKaddr)) | |
| 6724 synerr(EM_lvalue); // lvalue expected | |
| 6725 #endif | |
| 6726 return this; | |
| 6727 } | |
| 6728 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6729 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6730 Expression *PtrExp::modifiableLvalue(Scope *sc, Expression *e) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6731 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6732 //printf("PtrExp::modifiableLvalue() %s, type %s\n", toChars(), type->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6733 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6734 if (e1->op == TOKsymoff) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6735 { SymOffExp *se = (SymOffExp *)e1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6736 se->var->checkModify(loc, sc, type); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6737 //return toLvalue(sc, e); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6738 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6739 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6740 return Expression::modifiableLvalue(sc, e); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6741 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6742 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6743 |
| 159 | 6744 void PtrExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 6745 { | |
| 6746 buf->writeByte('*'); | |
| 6747 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 6748 } | |
| 6749 | |
| 6750 /************************************************************/ | |
| 6751 | |
| 6752 NegExp::NegExp(Loc loc, Expression *e) | |
| 6753 : UnaExp(loc, TOKneg, sizeof(NegExp), e) | |
| 6754 { | |
| 6755 } | |
| 6756 | |
| 6757 Expression *NegExp::semantic(Scope *sc) | |
| 6758 { Expression *e; | |
| 6759 | |
| 6760 #if LOGSEMANTIC | |
| 6761 printf("NegExp::semantic('%s')\n", toChars()); | |
| 6762 #endif | |
| 6763 if (!type) | |
| 6764 { | |
| 6765 UnaExp::semantic(sc); | |
| 6766 e1 = resolveProperties(sc, e1); | |
| 6767 e = op_overload(sc); | |
| 6768 if (e) | |
| 6769 return e; | |
| 6770 | |
| 6771 e1->checkNoBool(); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6772 if (e1->op != TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6773 e1->checkArithmetic(); |
| 159 | 6774 type = e1->type; |
| 6775 } | |
| 6776 return this; | |
| 6777 } | |
| 6778 | |
| 6779 /************************************************************/ | |
| 6780 | |
| 6781 UAddExp::UAddExp(Loc loc, Expression *e) | |
| 6782 : UnaExp(loc, TOKuadd, sizeof(UAddExp), e) | |
| 6783 { | |
| 6784 } | |
| 6785 | |
| 6786 Expression *UAddExp::semantic(Scope *sc) | |
| 6787 { Expression *e; | |
| 6788 | |
| 6789 #if LOGSEMANTIC | |
| 6790 printf("UAddExp::semantic('%s')\n", toChars()); | |
| 6791 #endif | |
| 6792 assert(!type); | |
| 6793 UnaExp::semantic(sc); | |
| 6794 e1 = resolveProperties(sc, e1); | |
| 6795 e = op_overload(sc); | |
| 6796 if (e) | |
| 6797 return e; | |
| 6798 e1->checkNoBool(); | |
| 6799 e1->checkArithmetic(); | |
| 6800 return e1; | |
| 6801 } | |
| 6802 | |
| 6803 /************************************************************/ | |
| 6804 | |
| 6805 ComExp::ComExp(Loc loc, Expression *e) | |
| 6806 : UnaExp(loc, TOKtilde, sizeof(ComExp), e) | |
| 6807 { | |
| 6808 } | |
| 6809 | |
| 6810 Expression *ComExp::semantic(Scope *sc) | |
| 6811 { Expression *e; | |
| 6812 | |
| 6813 if (!type) | |
| 6814 { | |
| 6815 UnaExp::semantic(sc); | |
| 6816 e1 = resolveProperties(sc, e1); | |
| 6817 e = op_overload(sc); | |
| 6818 if (e) | |
| 6819 return e; | |
| 6820 | |
| 6821 e1->checkNoBool(); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6822 if (e1->op != TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6823 e1 = e1->checkIntegral(); |
| 159 | 6824 type = e1->type; |
| 6825 } | |
| 6826 return this; | |
| 6827 } | |
| 6828 | |
| 6829 /************************************************************/ | |
| 6830 | |
| 6831 NotExp::NotExp(Loc loc, Expression *e) | |
| 6832 : UnaExp(loc, TOKnot, sizeof(NotExp), e) | |
| 6833 { | |
| 6834 } | |
| 6835 | |
| 6836 Expression *NotExp::semantic(Scope *sc) | |
| 6837 { | |
| 6838 UnaExp::semantic(sc); | |
| 6839 e1 = resolveProperties(sc, e1); | |
| 6840 e1 = e1->checkToBoolean(); | |
| 6841 type = Type::tboolean; | |
| 6842 return this; | |
| 6843 } | |
| 6844 | |
| 6845 int NotExp::isBit() | |
| 6846 { | |
| 6847 return TRUE; | |
| 6848 } | |
| 6849 | |
| 6850 | |
| 6851 | |
| 6852 /************************************************************/ | |
| 6853 | |
| 6854 BoolExp::BoolExp(Loc loc, Expression *e, Type *t) | |
| 6855 : UnaExp(loc, TOKtobool, sizeof(BoolExp), e) | |
| 6856 { | |
| 6857 type = t; | |
| 6858 } | |
| 6859 | |
| 6860 Expression *BoolExp::semantic(Scope *sc) | |
| 6861 { | |
| 6862 UnaExp::semantic(sc); | |
| 6863 e1 = resolveProperties(sc, e1); | |
| 6864 e1 = e1->checkToBoolean(); | |
| 6865 type = Type::tboolean; | |
| 6866 return this; | |
| 6867 } | |
| 6868 | |
| 6869 int BoolExp::isBit() | |
| 6870 { | |
| 6871 return TRUE; | |
| 6872 } | |
| 6873 | |
| 6874 /************************************************************/ | |
| 6875 | |
| 6876 DeleteExp::DeleteExp(Loc loc, Expression *e) | |
| 6877 : UnaExp(loc, TOKdelete, sizeof(DeleteExp), e) | |
| 6878 { | |
| 6879 } | |
| 6880 | |
| 6881 Expression *DeleteExp::semantic(Scope *sc) | |
| 6882 { | |
| 6883 Type *tb; | |
| 6884 | |
| 6885 UnaExp::semantic(sc); | |
| 6886 e1 = resolveProperties(sc, e1); | |
| 6887 e1 = e1->toLvalue(sc, NULL); | |
| 6888 type = Type::tvoid; | |
| 6889 | |
| 6890 tb = e1->type->toBasetype(); | |
| 6891 switch (tb->ty) | |
| 6892 { case Tclass: | |
| 6893 { TypeClass *tc = (TypeClass *)tb; | |
| 6894 ClassDeclaration *cd = tc->sym; | |
| 6895 | |
| 6896 if (cd->isCOMinterface()) | |
| 6897 { /* Because COM classes are deleted by IUnknown.Release() | |
| 6898 */ | |
| 6899 error("cannot delete instance of COM interface %s", cd->toChars()); | |
| 6900 } | |
| 6901 break; | |
| 6902 } | |
| 6903 case Tpointer: | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6904 tb = ((TypePointer *)tb)->next->toBasetype(); |
| 159 | 6905 if (tb->ty == Tstruct) |
| 6906 { | |
| 6907 TypeStruct *ts = (TypeStruct *)tb; | |
| 6908 StructDeclaration *sd = ts->sym; | |
| 6909 FuncDeclaration *f = sd->aggDelete; | |
| 6910 | |
| 6911 if (f) | |
| 6912 { | |
| 6913 Type *tpv = Type::tvoid->pointerTo(); | |
| 6914 | |
| 6915 Expression *e = e1->castTo(sc, tpv); | |
| 6916 Expression *ec = new VarExp(loc, f); | |
| 6917 e = new CallExp(loc, ec, e); | |
| 6918 return e->semantic(sc); | |
| 6919 } | |
| 6920 } | |
| 6921 break; | |
| 6922 | |
| 6923 case Tarray: | |
| 6924 break; | |
| 6925 | |
| 6926 default: | |
| 6927 if (e1->op == TOKindex) | |
| 6928 { | |
| 6929 IndexExp *ae = (IndexExp *)(e1); | |
| 6930 Type *tb1 = ae->e1->type->toBasetype(); | |
| 6931 if (tb1->ty == Taarray) | |
| 6932 break; | |
| 6933 } | |
| 6934 error("cannot delete type %s", e1->type->toChars()); | |
| 6935 break; | |
| 6936 } | |
| 6937 | |
| 6938 if (e1->op == TOKindex) | |
| 6939 { | |
| 6940 IndexExp *ae = (IndexExp *)(e1); | |
| 6941 Type *tb1 = ae->e1->type->toBasetype(); | |
| 6942 if (tb1->ty == Taarray) | |
| 6943 { if (!global.params.useDeprecated) | |
| 6944 error("delete aa[key] deprecated, use aa.remove(key)"); | |
| 6945 } | |
| 6946 } | |
| 6947 | |
| 6948 return this; | |
| 6949 } | |
| 6950 | |
| 6951 int DeleteExp::checkSideEffect(int flag) | |
| 6952 { | |
| 6953 return 1; | |
| 6954 } | |
| 6955 | |
| 6956 Expression *DeleteExp::checkToBoolean() | |
| 6957 { | |
| 6958 error("delete does not give a boolean result"); | |
| 6959 return this; | |
| 6960 } | |
| 6961 | |
| 6962 void DeleteExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 6963 { | |
| 6964 buf->writestring("delete "); | |
| 6965 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 6966 } | |
| 6967 | |
| 6968 /************************************************************/ | |
| 6969 | |
| 6970 CastExp::CastExp(Loc loc, Expression *e, Type *t) | |
| 6971 : UnaExp(loc, TOKcast, sizeof(CastExp), e) | |
| 6972 { | |
| 6973 to = t; | |
| 6974 } | |
| 6975 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6976 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6977 /* For cast(const) and cast(immutable) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6978 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6979 CastExp::CastExp(Loc loc, Expression *e, unsigned mod) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6980 : UnaExp(loc, TOKcast, sizeof(CastExp), e) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6981 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6982 to = NULL; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6983 this->mod = mod; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6984 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6985 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6986 |
| 159 | 6987 Expression *CastExp::syntaxCopy() |
| 6988 { | |
| 6989 return new CastExp(loc, e1->syntaxCopy(), to->syntaxCopy()); | |
| 6990 } | |
| 6991 | |
| 6992 | |
| 6993 Expression *CastExp::semantic(Scope *sc) | |
| 6994 { Expression *e; | |
| 6995 BinExp *b; | |
| 6996 UnaExp *u; | |
| 6997 | |
| 6998 #if LOGSEMANTIC | |
| 6999 printf("CastExp::semantic('%s')\n", toChars()); | |
| 7000 #endif | |
| 7001 | |
| 7002 //static int x; assert(++x < 10); | |
| 7003 | |
| 7004 if (type) | |
| 7005 return this; | |
| 7006 UnaExp::semantic(sc); | |
| 7007 if (e1->type) // if not a tuple | |
| 7008 { | |
| 7009 e1 = resolveProperties(sc, e1); | |
| 7010 to = to->semantic(loc, sc); | |
| 7011 | |
| 7012 e = op_overload(sc); | |
| 7013 if (e) | |
| 7014 { | |
| 7015 return e->implicitCastTo(sc, to); | |
| 7016 } | |
| 7017 | |
| 7018 Type *tob = to->toBasetype(); | |
| 7019 if (tob->ty == Tstruct && | |
| 7020 !tob->equals(e1->type->toBasetype()) && | |
| 7021 ((TypeStruct *)to)->sym->search(0, Id::call, 0) | |
| 7022 ) | |
| 7023 { | |
| 7024 /* Look to replace: | |
| 7025 * cast(S)t | |
| 7026 * with: | |
| 7027 * S(t) | |
| 7028 */ | |
| 7029 | |
| 7030 // Rewrite as to.call(e1) | |
| 7031 e = new TypeExp(loc, to); | |
| 7032 e = new DotIdExp(loc, e, Id::call); | |
| 7033 e = new CallExp(loc, e, e1); | |
| 7034 e = e->semantic(sc); | |
| 7035 return e; | |
| 7036 } | |
| 7037 } | |
| 7038 e = e1->castTo(sc, to); | |
| 7039 return e; | |
| 7040 } | |
| 7041 | |
| 7042 int CastExp::checkSideEffect(int flag) | |
| 7043 { | |
| 7044 /* if not: | |
| 7045 * cast(void) | |
| 7046 * cast(classtype)func() | |
| 7047 */ | |
| 7048 if (!to->equals(Type::tvoid) && | |
| 7049 !(to->ty == Tclass && e1->op == TOKcall && e1->type->ty == Tclass)) | |
| 7050 return Expression::checkSideEffect(flag); | |
| 7051 return 1; | |
| 7052 } | |
| 7053 | |
| 7054 void CastExp::checkEscape() | |
| 7055 { Type *tb = type->toBasetype(); | |
| 7056 if (tb->ty == Tarray && e1->op == TOKvar && | |
| 7057 e1->type->toBasetype()->ty == Tsarray) | |
| 7058 { VarExp *ve = (VarExp *)e1; | |
| 7059 VarDeclaration *v = ve->var->isVarDeclaration(); | |
| 7060 if (v) | |
| 7061 { | |
| 7062 if (!v->isDataseg() && !v->isParameter()) | |
| 7063 error("escaping reference to local %s", v->toChars()); | |
| 7064 } | |
| 7065 } | |
| 7066 } | |
| 7067 | |
| 7068 void CastExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7069 { | |
| 7070 buf->writestring("cast("); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7071 #if DMDV1 |
| 159 | 7072 to->toCBuffer(buf, NULL, hgs); |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7073 #else |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7074 if (to) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7075 to->toCBuffer(buf, NULL, hgs); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7076 else |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7077 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7078 switch (mod) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7079 { case 0: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7080 break; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7081 case MODconst: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7082 buf->writestring(Token::tochars[TOKconst]); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7083 break; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7084 case MODinvariant: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7085 buf->writestring(Token::tochars[TOKimmutable]); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7086 break; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7087 case MODshared: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7088 buf->writestring(Token::tochars[TOKshared]); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7089 break; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7090 case MODshared | MODconst: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7091 buf->writestring(Token::tochars[TOKshared]); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7092 buf->writeByte(' '); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7093 buf->writestring(Token::tochars[TOKconst]); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7094 break; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7095 default: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7096 assert(0); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7097 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7098 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7099 #endif |
| 159 | 7100 buf->writeByte(')'); |
| 7101 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 7102 } | |
| 7103 | |
| 7104 | |
| 7105 /************************************************************/ | |
| 7106 | |
| 7107 SliceExp::SliceExp(Loc loc, Expression *e1, Expression *lwr, Expression *upr) | |
| 7108 : UnaExp(loc, TOKslice, sizeof(SliceExp), e1) | |
| 7109 { | |
| 7110 this->upr = upr; | |
| 7111 this->lwr = lwr; | |
| 7112 lengthVar = NULL; | |
| 7113 } | |
| 7114 | |
| 7115 Expression *SliceExp::syntaxCopy() | |
| 7116 { | |
| 7117 Expression *lwr = NULL; | |
| 7118 if (this->lwr) | |
| 7119 lwr = this->lwr->syntaxCopy(); | |
| 7120 | |
| 7121 Expression *upr = NULL; | |
| 7122 if (this->upr) | |
| 7123 upr = this->upr->syntaxCopy(); | |
| 7124 | |
| 7125 return new SliceExp(loc, e1->syntaxCopy(), lwr, upr); | |
| 7126 } | |
| 7127 | |
| 7128 Expression *SliceExp::semantic(Scope *sc) | |
| 7129 { Expression *e; | |
| 7130 AggregateDeclaration *ad; | |
| 7131 //FuncDeclaration *fd; | |
| 7132 ScopeDsymbol *sym; | |
| 7133 | |
| 7134 #if LOGSEMANTIC | |
| 7135 printf("SliceExp::semantic('%s')\n", toChars()); | |
| 7136 #endif | |
| 7137 if (type) | |
| 7138 return this; | |
| 7139 | |
| 7140 UnaExp::semantic(sc); | |
| 7141 e1 = resolveProperties(sc, e1); | |
| 7142 | |
| 7143 e = this; | |
| 7144 | |
| 7145 Type *t = e1->type->toBasetype(); | |
| 7146 if (t->ty == Tpointer) | |
| 7147 { | |
| 7148 if (!lwr || !upr) | |
| 7149 error("need upper and lower bound to slice pointer"); | |
| 7150 } | |
| 7151 else if (t->ty == Tarray) | |
| 7152 { | |
| 7153 } | |
| 7154 else if (t->ty == Tsarray) | |
| 7155 { | |
| 7156 } | |
| 7157 else if (t->ty == Tclass) | |
| 7158 { | |
| 7159 ad = ((TypeClass *)t)->sym; | |
| 7160 goto L1; | |
| 7161 } | |
| 7162 else if (t->ty == Tstruct) | |
| 7163 { | |
| 7164 ad = ((TypeStruct *)t)->sym; | |
| 7165 | |
| 7166 L1: | |
| 7167 if (search_function(ad, Id::slice)) | |
| 7168 { | |
| 7169 // Rewrite as e1.slice(lwr, upr) | |
| 7170 e = new DotIdExp(loc, e1, Id::slice); | |
| 7171 | |
| 7172 if (lwr) | |
| 7173 { | |
| 7174 assert(upr); | |
| 7175 e = new CallExp(loc, e, lwr, upr); | |
| 7176 } | |
| 7177 else | |
| 7178 { assert(!upr); | |
| 7179 e = new CallExp(loc, e); | |
| 7180 } | |
| 7181 e = e->semantic(sc); | |
| 7182 return e; | |
| 7183 } | |
| 7184 goto Lerror; | |
| 7185 } | |
| 7186 else if (t->ty == Ttuple) | |
| 7187 { | |
| 7188 if (!lwr && !upr) | |
| 7189 return e1; | |
| 7190 if (!lwr || !upr) | |
| 7191 { error("need upper and lower bound to slice tuple"); | |
| 7192 goto Lerror; | |
| 7193 } | |
| 7194 } | |
| 7195 else | |
| 7196 goto Lerror; | |
| 7197 | |
| 7198 if (t->ty == Tsarray || t->ty == Tarray || t->ty == Ttuple) | |
| 7199 { | |
| 7200 sym = new ArrayScopeSymbol(this); | |
| 7201 sym->loc = loc; | |
| 7202 sym->parent = sc->scopesym; | |
| 7203 sc = sc->push(sym); | |
| 7204 } | |
| 7205 | |
| 7206 if (lwr) | |
| 7207 { lwr = lwr->semantic(sc); | |
| 7208 lwr = resolveProperties(sc, lwr); | |
| 7209 lwr = lwr->implicitCastTo(sc, Type::tsize_t); | |
| 7210 } | |
| 7211 if (upr) | |
| 7212 { upr = upr->semantic(sc); | |
| 7213 upr = resolveProperties(sc, upr); | |
| 7214 upr = upr->implicitCastTo(sc, Type::tsize_t); | |
| 7215 } | |
| 7216 | |
| 7217 if (t->ty == Tsarray || t->ty == Tarray || t->ty == Ttuple) | |
| 7218 sc->pop(); | |
| 7219 | |
| 7220 if (t->ty == Ttuple) | |
| 7221 { | |
| 7222 lwr = lwr->optimize(WANTvalue); | |
| 7223 upr = upr->optimize(WANTvalue); | |
| 7224 uinteger_t i1 = lwr->toUInteger(); | |
| 7225 uinteger_t i2 = upr->toUInteger(); | |
| 7226 | |
| 7227 size_t length; | |
| 7228 TupleExp *te; | |
| 7229 TypeTuple *tup; | |
| 7230 | |
| 7231 if (e1->op == TOKtuple) // slicing an expression tuple | |
| 7232 { te = (TupleExp *)e1; | |
| 7233 length = te->exps->dim; | |
| 7234 } | |
| 7235 else if (e1->op == TOKtype) // slicing a type tuple | |
| 7236 { tup = (TypeTuple *)t; | |
| 7237 length = Argument::dim(tup->arguments); | |
| 7238 } | |
| 7239 else | |
| 7240 assert(0); | |
| 7241 | |
| 7242 if (i1 <= i2 && i2 <= length) | |
| 7243 { size_t j1 = (size_t) i1; | |
| 7244 size_t j2 = (size_t) i2; | |
| 7245 | |
| 7246 if (e1->op == TOKtuple) | |
| 7247 { Expressions *exps = new Expressions; | |
| 7248 exps->setDim(j2 - j1); | |
| 7249 for (size_t i = 0; i < j2 - j1; i++) | |
| 7250 { Expression *e = (Expression *)te->exps->data[j1 + i]; | |
| 7251 exps->data[i] = (void *)e; | |
| 7252 } | |
| 7253 e = new TupleExp(loc, exps); | |
| 7254 } | |
| 7255 else | |
| 7256 { Arguments *args = new Arguments; | |
| 7257 args->reserve(j2 - j1); | |
| 7258 for (size_t i = j1; i < j2; i++) | |
| 7259 { Argument *arg = Argument::getNth(tup->arguments, i); | |
| 7260 args->push(arg); | |
| 7261 } | |
| 7262 e = new TypeExp(e1->loc, new TypeTuple(args)); | |
| 7263 } | |
| 7264 e = e->semantic(sc); | |
| 7265 } | |
| 7266 else | |
| 7267 { | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7268 error("string slice [%ju .. %ju] is out of bounds", i1, i2); |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
7269 e = new IntegerExp(0); |
| 159 | 7270 } |
| 7271 return e; | |
| 7272 } | |
| 7273 | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7274 if (t->ty == Tarray) |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7275 type = e1->type; |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7276 else |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7277 type = t->nextOf()->arrayOf(); |
| 159 | 7278 return e; |
| 7279 | |
| 7280 Lerror: | |
| 7281 char *s; | |
| 7282 if (t->ty == Tvoid) | |
| 7283 s = e1->toChars(); | |
| 7284 else | |
| 7285 s = t->toChars(); | |
| 7286 error("%s cannot be sliced with []", s); | |
|
876
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
7287 e = new IntegerExp(0); |
| 159 | 7288 return e; |
| 7289 } | |
| 7290 | |
| 7291 void SliceExp::checkEscape() | |
| 7292 { | |
| 7293 e1->checkEscape(); | |
| 7294 } | |
| 7295 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7296 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7297 int SliceExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7298 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7299 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7300 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7301 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7302 |
| 159 | 7303 Expression *SliceExp::toLvalue(Scope *sc, Expression *e) |
| 7304 { | |
| 7305 return this; | |
| 7306 } | |
| 7307 | |
| 7308 Expression *SliceExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 7309 { | |
| 7310 error("slice expression %s is not a modifiable lvalue", toChars()); | |
| 7311 return this; | |
| 7312 } | |
| 7313 | |
| 7314 void SliceExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7315 { | |
| 7316 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 7317 buf->writeByte('['); | |
| 7318 if (upr || lwr) | |
| 7319 { | |
| 7320 if (lwr) | |
| 7321 expToCBuffer(buf, hgs, lwr, PREC_assign); | |
| 7322 else | |
| 7323 buf->writeByte('0'); | |
| 7324 buf->writestring(".."); | |
| 7325 if (upr) | |
| 7326 expToCBuffer(buf, hgs, upr, PREC_assign); | |
| 7327 else | |
| 7328 buf->writestring("length"); // BUG: should be array.length | |
| 7329 } | |
| 7330 buf->writeByte(']'); | |
| 7331 } | |
| 7332 | |
| 7333 /********************** ArrayLength **************************************/ | |
| 7334 | |
| 7335 ArrayLengthExp::ArrayLengthExp(Loc loc, Expression *e1) | |
| 7336 : UnaExp(loc, TOKarraylength, sizeof(ArrayLengthExp), e1) | |
| 7337 { | |
| 7338 } | |
| 7339 | |
| 7340 Expression *ArrayLengthExp::semantic(Scope *sc) | |
| 7341 { Expression *e; | |
| 7342 | |
| 7343 #if LOGSEMANTIC | |
| 7344 printf("ArrayLengthExp::semantic('%s')\n", toChars()); | |
| 7345 #endif | |
| 7346 if (!type) | |
| 7347 { | |
| 7348 UnaExp::semantic(sc); | |
| 7349 e1 = resolveProperties(sc, e1); | |
| 7350 | |
| 7351 type = Type::tsize_t; | |
| 7352 } | |
| 7353 return this; | |
| 7354 } | |
| 7355 | |
| 7356 void ArrayLengthExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7357 { | |
| 7358 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 7359 buf->writestring(".length"); | |
| 7360 } | |
| 7361 | |
| 7362 /*********************** ArrayExp *************************************/ | |
| 7363 | |
| 7364 // e1 [ i1, i2, i3, ... ] | |
| 7365 | |
| 7366 ArrayExp::ArrayExp(Loc loc, Expression *e1, Expressions *args) | |
| 7367 : UnaExp(loc, TOKarray, sizeof(ArrayExp), e1) | |
| 7368 { | |
| 7369 arguments = args; | |
| 7370 } | |
| 7371 | |
| 7372 Expression *ArrayExp::syntaxCopy() | |
| 7373 { | |
| 7374 return new ArrayExp(loc, e1->syntaxCopy(), arraySyntaxCopy(arguments)); | |
| 7375 } | |
| 7376 | |
| 7377 Expression *ArrayExp::semantic(Scope *sc) | |
| 7378 { Expression *e; | |
| 7379 Type *t1; | |
| 7380 | |
| 7381 #if LOGSEMANTIC | |
| 7382 printf("ArrayExp::semantic('%s')\n", toChars()); | |
| 7383 #endif | |
| 7384 UnaExp::semantic(sc); | |
| 7385 e1 = resolveProperties(sc, e1); | |
| 7386 | |
| 7387 t1 = e1->type->toBasetype(); | |
| 7388 if (t1->ty != Tclass && t1->ty != Tstruct) | |
| 7389 { // Convert to IndexExp | |
| 7390 if (arguments->dim != 1) | |
| 7391 error("only one index allowed to index %s", t1->toChars()); | |
| 7392 e = new IndexExp(loc, e1, (Expression *)arguments->data[0]); | |
| 7393 return e->semantic(sc); | |
| 7394 } | |
| 7395 | |
| 7396 // Run semantic() on each argument | |
| 7397 for (size_t i = 0; i < arguments->dim; i++) | |
| 7398 { e = (Expression *)arguments->data[i]; | |
| 7399 | |
| 7400 e = e->semantic(sc); | |
| 7401 if (!e->type) | |
| 7402 error("%s has no value", e->toChars()); | |
| 7403 arguments->data[i] = (void *)e; | |
| 7404 } | |
| 7405 | |
| 7406 expandTuples(arguments); | |
| 7407 assert(arguments && arguments->dim); | |
| 7408 | |
| 7409 e = op_overload(sc); | |
| 7410 if (!e) | |
| 7411 { error("no [] operator overload for type %s", e1->type->toChars()); | |
| 7412 e = e1; | |
| 7413 } | |
| 7414 return e; | |
| 7415 } | |
| 7416 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7417 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7418 int ArrayExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7419 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7420 if (type && type->toBasetype()->ty == Tvoid) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7421 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7422 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7423 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7424 #endif |
| 159 | 7425 |
| 7426 Expression *ArrayExp::toLvalue(Scope *sc, Expression *e) | |
| 7427 { | |
| 7428 if (type && type->toBasetype()->ty == Tvoid) | |
| 7429 error("voids have no value"); | |
| 7430 return this; | |
| 7431 } | |
| 7432 | |
| 7433 | |
| 7434 void ArrayExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7435 { int i; | |
| 7436 | |
| 7437 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 7438 buf->writeByte('['); | |
| 7439 argsToCBuffer(buf, arguments, hgs); | |
| 7440 buf->writeByte(']'); | |
| 7441 } | |
| 7442 | |
| 7443 /************************* DotExp ***********************************/ | |
| 7444 | |
| 7445 DotExp::DotExp(Loc loc, Expression *e1, Expression *e2) | |
| 7446 : BinExp(loc, TOKdotexp, sizeof(DotExp), e1, e2) | |
| 7447 { | |
| 7448 } | |
| 7449 | |
| 7450 Expression *DotExp::semantic(Scope *sc) | |
| 7451 { | |
| 7452 #if LOGSEMANTIC | |
| 7453 printf("DotExp::semantic('%s')\n", toChars()); | |
| 7454 if (type) printf("\ttype = %s\n", type->toChars()); | |
| 7455 #endif | |
| 7456 e1 = e1->semantic(sc); | |
| 7457 e2 = e2->semantic(sc); | |
| 7458 if (e2->op == TOKimport) | |
| 7459 { | |
| 7460 ScopeExp *se = (ScopeExp *)e2; | |
| 7461 TemplateDeclaration *td = se->sds->isTemplateDeclaration(); | |
| 7462 if (td) | |
| 7463 { Expression *e = new DotTemplateExp(loc, e1, td); | |
| 7464 e = e->semantic(sc); | |
| 7465 return e; | |
| 7466 } | |
| 7467 } | |
| 7468 if (!type) | |
| 7469 type = e2->type; | |
| 7470 return this; | |
| 7471 } | |
| 7472 | |
| 7473 | |
| 7474 /************************* CommaExp ***********************************/ | |
| 7475 | |
| 7476 CommaExp::CommaExp(Loc loc, Expression *e1, Expression *e2) | |
| 7477 : BinExp(loc, TOKcomma, sizeof(CommaExp), e1, e2) | |
| 7478 { | |
| 7479 } | |
| 7480 | |
| 7481 Expression *CommaExp::semantic(Scope *sc) | |
| 7482 { | |
| 7483 if (!type) | |
| 7484 { BinExp::semanticp(sc); | |
| 7485 type = e2->type; | |
| 7486 } | |
| 7487 return this; | |
| 7488 } | |
| 7489 | |
| 7490 void CommaExp::checkEscape() | |
| 7491 { | |
| 7492 e2->checkEscape(); | |
| 7493 } | |
| 7494 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7495 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7496 int CommaExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7497 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7498 return e2->isLvalue(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7499 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7500 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7501 |
| 159 | 7502 Expression *CommaExp::toLvalue(Scope *sc, Expression *e) |
| 7503 { | |
| 7504 e2 = e2->toLvalue(sc, NULL); | |
| 7505 return this; | |
| 7506 } | |
| 7507 | |
| 7508 Expression *CommaExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 7509 { | |
| 7510 e2 = e2->modifiableLvalue(sc, e); | |
| 7511 return this; | |
| 7512 } | |
| 7513 | |
| 7514 int CommaExp::isBool(int result) | |
| 7515 { | |
| 7516 return e2->isBool(result); | |
| 7517 } | |
| 7518 | |
| 7519 int CommaExp::checkSideEffect(int flag) | |
| 7520 { | |
| 7521 if (flag == 2) | |
| 7522 return e1->checkSideEffect(2) || e2->checkSideEffect(2); | |
| 7523 else | |
| 7524 { | |
| 7525 // Don't check e1 until we cast(void) the a,b code generation | |
| 7526 return e2->checkSideEffect(flag); | |
| 7527 } | |
| 7528 } | |
| 7529 | |
| 7530 /************************** IndexExp **********************************/ | |
| 7531 | |
| 7532 // e1 [ e2 ] | |
| 7533 | |
| 7534 IndexExp::IndexExp(Loc loc, Expression *e1, Expression *e2) | |
| 7535 : BinExp(loc, TOKindex, sizeof(IndexExp), e1, e2) | |
| 7536 { | |
| 7537 //printf("IndexExp::IndexExp('%s')\n", toChars()); | |
| 7538 lengthVar = NULL; | |
| 7539 modifiable = 0; // assume it is an rvalue | |
| 7540 } | |
| 7541 | |
| 7542 Expression *IndexExp::semantic(Scope *sc) | |
| 7543 { Expression *e; | |
| 7544 BinExp *b; | |
| 7545 UnaExp *u; | |
| 7546 Type *t1; | |
| 7547 ScopeDsymbol *sym; | |
| 7548 | |
| 7549 #if LOGSEMANTIC | |
| 7550 printf("IndexExp::semantic('%s')\n", toChars()); | |
| 7551 #endif | |
| 7552 if (type) | |
| 7553 return this; | |
| 7554 if (!e1->type) | |
| 7555 e1 = e1->semantic(sc); | |
| 7556 assert(e1->type); // semantic() should already be run on it | |
| 7557 e = this; | |
| 7558 | |
| 7559 // Note that unlike C we do not implement the int[ptr] | |
| 7560 | |
| 7561 t1 = e1->type->toBasetype(); | |
| 7562 | |
| 7563 if (t1->ty == Tsarray || t1->ty == Tarray || t1->ty == Ttuple) | |
| 7564 { // Create scope for 'length' variable | |
| 7565 sym = new ArrayScopeSymbol(this); | |
| 7566 sym->loc = loc; | |
| 7567 sym->parent = sc->scopesym; | |
| 7568 sc = sc->push(sym); | |
| 7569 } | |
| 7570 | |
| 7571 e2 = e2->semantic(sc); | |
| 7572 if (!e2->type) | |
| 7573 { | |
| 7574 error("%s has no value", e2->toChars()); | |
| 7575 e2->type = Type::terror; | |
| 7576 } | |
| 7577 e2 = resolveProperties(sc, e2); | |
| 7578 | |
| 7579 if (t1->ty == Tsarray || t1->ty == Tarray || t1->ty == Ttuple) | |
| 7580 sc = sc->pop(); | |
| 7581 | |
| 7582 switch (t1->ty) | |
| 7583 { | |
| 7584 case Tpointer: | |
| 7585 case Tarray: | |
| 7586 e2 = e2->implicitCastTo(sc, Type::tsize_t); | |
| 7587 e->type = t1->next; | |
| 7588 break; | |
| 7589 | |
| 7590 case Tsarray: | |
| 7591 { | |
| 7592 e2 = e2->implicitCastTo(sc, Type::tsize_t); | |
| 7593 | |
| 7594 TypeSArray *tsa = (TypeSArray *)t1; | |
| 7595 | |
| 7596 #if 0 // Don't do now, because it might be short-circuit evaluated | |
| 7597 // Do compile time array bounds checking if possible | |
| 7598 e2 = e2->optimize(WANTvalue); | |
| 7599 if (e2->op == TOKint64) | |
| 7600 { | |
|
1195
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
7601 dinteger_t index = e2->toInteger(); |
|
e961851fb8be
Merged DMD 1.042.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1168
diff
changeset
|
7602 dinteger_t length = tsa->dim->toInteger(); |
| 159 | 7603 if (index < 0 || index >= length) |
| 7604 error("array index [%lld] is outside array bounds [0 .. %lld]", | |
| 7605 index, length); | |
| 7606 } | |
| 7607 #endif | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7608 e->type = t1->nextOf(); |
| 159 | 7609 break; |
| 7610 } | |
| 7611 | |
| 7612 case Taarray: | |
| 7613 { TypeAArray *taa = (TypeAArray *)t1; | |
| 7614 | |
| 7615 e2 = e2->implicitCastTo(sc, taa->index); // type checking | |
| 7616 e2 = e2->implicitCastTo(sc, taa->key); // actual argument type | |
| 7617 type = taa->next; | |
| 7618 break; | |
| 7619 } | |
| 7620 | |
| 7621 case Ttuple: | |
| 7622 { | |
| 7623 e2 = e2->implicitCastTo(sc, Type::tsize_t); | |
| 7624 e2 = e2->optimize(WANTvalue); | |
| 7625 uinteger_t index = e2->toUInteger(); | |
| 7626 size_t length; | |
| 7627 TupleExp *te; | |
| 7628 TypeTuple *tup; | |
| 7629 | |
| 7630 if (e1->op == TOKtuple) | |
| 7631 { te = (TupleExp *)e1; | |
| 7632 length = te->exps->dim; | |
| 7633 } | |
| 7634 else if (e1->op == TOKtype) | |
| 7635 { | |
| 7636 tup = (TypeTuple *)t1; | |
| 7637 length = Argument::dim(tup->arguments); | |
| 7638 } | |
| 7639 else | |
| 7640 assert(0); | |
| 7641 | |
| 7642 if (index < length) | |
| 7643 { | |
| 7644 | |
| 7645 if (e1->op == TOKtuple) | |
| 7646 e = (Expression *)te->exps->data[(size_t)index]; | |
| 7647 else | |
| 7648 e = new TypeExp(e1->loc, Argument::getNth(tup->arguments, (size_t)index)->type); | |
| 7649 } | |
| 7650 else | |
| 7651 { | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7652 error("array index [%ju] is outside array bounds [0 .. %zu]", |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7653 index, length); |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7654 e = e1; |
| 159 | 7655 } |
| 7656 break; | |
| 7657 } | |
| 7658 | |
| 7659 default: | |
| 7660 error("%s must be an array or pointer type, not %s", | |
| 7661 e1->toChars(), e1->type->toChars()); | |
| 7662 type = Type::tint32; | |
| 7663 break; | |
| 7664 } | |
| 7665 return e; | |
| 7666 } | |
| 7667 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7668 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7669 int IndexExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7670 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7671 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7672 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7673 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7674 |
| 159 | 7675 Expression *IndexExp::toLvalue(Scope *sc, Expression *e) |
| 7676 { | |
| 7677 // if (type && type->toBasetype()->ty == Tvoid) | |
| 7678 // error("voids have no value"); | |
| 7679 return this; | |
| 7680 } | |
| 7681 | |
| 7682 Expression *IndexExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 7683 { | |
| 7684 //printf("IndexExp::modifiableLvalue(%s)\n", toChars()); | |
| 7685 modifiable = 1; | |
| 7686 if (e1->op == TOKstring) | |
| 7687 error("string literals are immutable"); | |
| 7688 if (e1->type->toBasetype()->ty == Taarray) | |
| 7689 e1 = e1->modifiableLvalue(sc, e1); | |
| 7690 return toLvalue(sc, e); | |
| 7691 } | |
| 7692 | |
| 7693 void IndexExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7694 { | |
| 7695 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 7696 buf->writeByte('['); | |
| 7697 expToCBuffer(buf, hgs, e2, PREC_assign); | |
| 7698 buf->writeByte(']'); | |
| 7699 } | |
| 7700 | |
| 7701 | |
| 7702 /************************* PostExp ***********************************/ | |
| 7703 | |
| 7704 PostExp::PostExp(enum TOK op, Loc loc, Expression *e) | |
| 7705 : BinExp(loc, op, sizeof(PostExp), e, | |
| 7706 new IntegerExp(loc, 1, Type::tint32)) | |
| 7707 { | |
| 7708 } | |
| 7709 | |
| 7710 Expression *PostExp::semantic(Scope *sc) | |
| 7711 { Expression *e = this; | |
| 7712 | |
| 7713 if (!type) | |
| 7714 { | |
| 7715 BinExp::semantic(sc); | |
| 7716 e2 = resolveProperties(sc, e2); | |
| 7717 | |
| 7718 e = op_overload(sc); | |
| 7719 if (e) | |
| 7720 return e; | |
| 7721 | |
| 7722 e = this; | |
| 7723 e1 = e1->modifiableLvalue(sc, e1); | |
| 7724 e1->checkScalar(); | |
| 7725 e1->checkNoBool(); | |
| 7726 if (e1->type->ty == Tpointer) | |
| 7727 e = scaleFactor(sc); | |
| 7728 else | |
| 7729 e2 = e2->castTo(sc, e1->type); | |
| 7730 e->type = e1->type; | |
| 7731 } | |
| 7732 return e; | |
| 7733 } | |
| 7734 | |
| 7735 void PostExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7736 { | |
| 7737 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 7738 buf->writestring((op == TOKplusplus) ? (char *)"++" : (char *)"--"); | |
| 7739 } | |
| 7740 | |
| 7741 /************************************************************/ | |
| 7742 | |
| 7743 /* Can be TOKconstruct too */ | |
| 7744 | |
| 7745 AssignExp::AssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 7746 : BinExp(loc, TOKassign, sizeof(AssignExp), e1, e2) | |
| 7747 { | |
| 7748 ismemset = 0; | |
| 7749 } | |
| 7750 | |
| 7751 Expression *AssignExp::semantic(Scope *sc) | |
| 7752 { Type *t1; | |
| 7753 Expression *e1old = e1; | |
| 7754 | |
| 7755 #if LOGSEMANTIC | |
| 7756 printf("AssignExp::semantic('%s')\n", toChars()); | |
| 7757 #endif | |
| 7758 //printf("e1->op = %d, '%s'\n", e1->op, Token::toChars(e1->op)); | |
| 7759 | |
| 7760 /* Look for operator overloading of a[i]=value. | |
| 7761 * Do it before semantic() otherwise the a[i] will have been | |
| 7762 * converted to a.opIndex() already. | |
| 7763 */ | |
| 7764 if (e1->op == TOKarray) | |
| 7765 { Type *t1; | |
| 7766 ArrayExp *ae = (ArrayExp *)e1; | |
| 7767 AggregateDeclaration *ad; | |
| 7768 Identifier *id = Id::index; | |
| 7769 | |
| 7770 ae->e1 = ae->e1->semantic(sc); | |
| 7771 t1 = ae->e1->type->toBasetype(); | |
| 7772 if (t1->ty == Tstruct) | |
| 7773 { | |
| 7774 ad = ((TypeStruct *)t1)->sym; | |
| 7775 goto L1; | |
| 7776 } | |
| 7777 else if (t1->ty == Tclass) | |
| 7778 { | |
| 7779 ad = ((TypeClass *)t1)->sym; | |
| 7780 L1: | |
| 7781 // Rewrite (a[i] = value) to (a.opIndexAssign(value, i)) | |
| 7782 if (search_function(ad, Id::indexass)) | |
| 7783 { Expression *e = new DotIdExp(loc, ae->e1, Id::indexass); | |
| 7784 Expressions *a = (Expressions *)ae->arguments->copy(); | |
| 7785 | |
| 7786 a->insert(0, e2); | |
| 7787 e = new CallExp(loc, e, a); | |
| 7788 e = e->semantic(sc); | |
| 7789 return e; | |
| 7790 } | |
| 7791 else | |
| 7792 { | |
| 7793 // Rewrite (a[i] = value) to (a.opIndex(i, value)) | |
| 7794 if (search_function(ad, id)) | |
| 7795 { Expression *e = new DotIdExp(loc, ae->e1, id); | |
| 7796 | |
| 7797 if (1 || !global.params.useDeprecated) | |
| 7798 error("operator [] assignment overload with opIndex(i, value) illegal, use opIndexAssign(value, i)"); | |
| 7799 | |
| 7800 e = new CallExp(loc, e, (Expression *)ae->arguments->data[0], e2); | |
| 7801 e = e->semantic(sc); | |
| 7802 return e; | |
| 7803 } | |
| 7804 } | |
| 7805 } | |
| 7806 } | |
| 7807 /* Look for operator overloading of a[i..j]=value. | |
| 7808 * Do it before semantic() otherwise the a[i..j] will have been | |
| 7809 * converted to a.opSlice() already. | |
| 7810 */ | |
| 7811 if (e1->op == TOKslice) | |
| 7812 { Type *t1; | |
| 7813 SliceExp *ae = (SliceExp *)e1; | |
| 7814 AggregateDeclaration *ad; | |
| 7815 Identifier *id = Id::index; | |
| 7816 | |
| 7817 ae->e1 = ae->e1->semantic(sc); | |
| 7818 ae->e1 = resolveProperties(sc, ae->e1); | |
| 7819 t1 = ae->e1->type->toBasetype(); | |
| 7820 if (t1->ty == Tstruct) | |
| 7821 { | |
| 7822 ad = ((TypeStruct *)t1)->sym; | |
| 7823 goto L2; | |
| 7824 } | |
| 7825 else if (t1->ty == Tclass) | |
| 7826 { | |
| 7827 ad = ((TypeClass *)t1)->sym; | |
| 7828 L2: | |
| 7829 // Rewrite (a[i..j] = value) to (a.opIndexAssign(value, i, j)) | |
| 7830 if (search_function(ad, Id::sliceass)) | |
| 7831 { Expression *e = new DotIdExp(loc, ae->e1, Id::sliceass); | |
| 7832 Expressions *a = new Expressions(); | |
| 7833 | |
| 7834 a->push(e2); | |
| 7835 if (ae->lwr) | |
| 7836 { a->push(ae->lwr); | |
| 7837 assert(ae->upr); | |
| 7838 a->push(ae->upr); | |
| 7839 } | |
| 7840 else | |
| 7841 assert(!ae->upr); | |
| 7842 e = new CallExp(loc, e, a); | |
| 7843 e = e->semantic(sc); | |
| 7844 return e; | |
| 7845 } | |
| 7846 } | |
| 7847 } | |
| 7848 | |
| 7849 BinExp::semantic(sc); | |
|
717
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7850 |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7851 if (e1->op == TOKdottd) |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7852 { // Rewrite a.b=e2, when b is a template, as a.b(e2) |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7853 Expression *e = new CallExp(loc, e1, e2); |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7854 e = e->semantic(sc); |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7855 return e; |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7856 } |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7857 |
| 159 | 7858 e2 = resolveProperties(sc, e2); |
| 7859 assert(e1->type); | |
| 7860 | |
| 7861 /* Rewrite tuple assignment as a tuple of assignments. | |
| 7862 */ | |
| 7863 if (e1->op == TOKtuple && e2->op == TOKtuple) | |
| 7864 { TupleExp *tup1 = (TupleExp *)e1; | |
| 7865 TupleExp *tup2 = (TupleExp *)e2; | |
| 7866 size_t dim = tup1->exps->dim; | |
| 7867 if (dim != tup2->exps->dim) | |
| 7868 { | |
| 7869 error("mismatched tuple lengths, %d and %d", (int)dim, (int)tup2->exps->dim); | |
| 7870 } | |
| 7871 else | |
| 7872 { Expressions *exps = new Expressions; | |
| 7873 exps->setDim(dim); | |
| 7874 | |
| 7875 for (int i = 0; i < dim; i++) | |
| 7876 { Expression *ex1 = (Expression *)tup1->exps->data[i]; | |
| 7877 Expression *ex2 = (Expression *)tup2->exps->data[i]; | |
| 7878 exps->data[i] = (void *) new AssignExp(loc, ex1, ex2); | |
| 7879 } | |
| 7880 Expression *e = new TupleExp(loc, exps); | |
| 7881 e = e->semantic(sc); | |
| 7882 return e; | |
| 7883 } | |
| 7884 } | |
| 7885 | |
| 7886 t1 = e1->type->toBasetype(); | |
| 7887 | |
| 7888 if (t1->ty == Tfunction) | |
| 7889 { // Rewrite f=value to f(value) | |
| 7890 Expression *e; | |
| 7891 | |
| 7892 e = new CallExp(loc, e1, e2); | |
| 7893 e = e->semantic(sc); | |
| 7894 return e; | |
| 7895 } | |
| 7896 | |
| 7897 /* If it is an assignment from a 'foreign' type, | |
| 7898 * check for operator overloading. | |
| 7899 */ | |
| 7900 if (t1->ty == Tclass || t1->ty == Tstruct) | |
| 7901 { | |
| 7902 if (!e2->type->implicitConvTo(e1->type)) | |
| 7903 { | |
| 7904 Expression *e = op_overload(sc); | |
| 7905 if (e) | |
| 7906 return e; | |
| 7907 } | |
| 7908 } | |
| 7909 | |
| 7910 e2->rvalue(); | |
| 7911 | |
| 7912 if (e1->op == TOKarraylength) | |
| 7913 { | |
| 7914 // e1 is not an lvalue, but we let code generator handle it | |
| 7915 ArrayLengthExp *ale = (ArrayLengthExp *)e1; | |
| 7916 | |
| 7917 ale->e1 = ale->e1->modifiableLvalue(sc, e1); | |
| 7918 } | |
| 7919 else if (e1->op == TOKslice) | |
| 7920 ; | |
| 7921 else | |
| 7922 { // Try to do a decent error message with the expression | |
| 7923 // before it got constant folded | |
| 7924 e1 = e1->modifiableLvalue(sc, e1old); | |
| 7925 } | |
| 7926 | |
| 7927 if (e1->op == TOKslice && | |
| 7928 t1->nextOf() && | |
| 7929 e2->implicitConvTo(t1->nextOf()) | |
| 7930 // !(t1->nextOf()->equals(e2->type->nextOf())) | |
| 7931 ) | |
| 7932 { // memset | |
| 7933 ismemset = 1; // make it easy for back end to tell what this is | |
| 7934 e2 = e2->implicitCastTo(sc, t1->next); | |
| 7935 } | |
| 7936 else if (t1->ty == Tsarray) | |
| 7937 { | |
| 7938 error("cannot assign to static array %s", e1->toChars()); | |
| 7939 } | |
| 7940 else | |
| 7941 { | |
| 7942 e2 = e2->implicitCastTo(sc, e1->type); | |
| 7943 } | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7944 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7945 /* Look for array operations |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7946 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7947 if (e1->op == TOKslice && !ismemset && |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7948 (e2->op == TOKadd || e2->op == TOKmin || |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7949 e2->op == TOKmul || e2->op == TOKdiv || |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7950 e2->op == TOKmod || e2->op == TOKxor || |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7951 e2->op == TOKand || e2->op == TOKor || |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7952 e2->op == TOKtilde || e2->op == TOKneg)) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7953 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7954 type = e1->type; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7955 return arrayOp(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7956 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7957 |
| 159 | 7958 type = e1->type; |
| 7959 assert(type); | |
| 7960 return this; | |
| 7961 } | |
| 7962 | |
| 7963 Expression *AssignExp::checkToBoolean() | |
| 7964 { | |
| 7965 // Things like: | |
| 7966 // if (a = b) ... | |
| 7967 // are usually mistakes. | |
| 7968 | |
| 7969 error("'=' does not give a boolean result"); | |
| 7970 return this; | |
| 7971 } | |
| 7972 | |
| 7973 /************************************************************/ | |
| 7974 | |
| 7975 AddAssignExp::AddAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 7976 : BinExp(loc, TOKaddass, sizeof(AddAssignExp), e1, e2) | |
| 7977 { | |
| 7978 } | |
| 7979 | |
| 7980 Expression *AddAssignExp::semantic(Scope *sc) | |
| 7981 { Expression *e; | |
| 7982 | |
| 7983 if (type) | |
| 7984 return this; | |
| 7985 | |
| 7986 BinExp::semantic(sc); | |
| 7987 e2 = resolveProperties(sc, e2); | |
| 7988 | |
| 7989 e = op_overload(sc); | |
| 7990 if (e) | |
| 7991 return e; | |
| 7992 | |
| 7993 Type *tb1 = e1->type->toBasetype(); | |
| 7994 Type *tb2 = e2->type->toBasetype(); | |
| 7995 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7996 if (e1->op == TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7997 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7998 typeCombine(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7999 type = e1->type; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8000 return arrayOp(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8001 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8002 else |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8003 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8004 e1 = e1->modifiableLvalue(sc, e1); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8005 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8006 |
| 159 | 8007 if ((tb1->ty == Tarray || tb1->ty == Tsarray) && |
| 8008 (tb2->ty == Tarray || tb2->ty == Tsarray) && | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8009 tb1->nextOf()->equals(tb2->nextOf()) |
| 159 | 8010 ) |
| 8011 { | |
| 8012 type = e1->type; | |
| 8013 e = this; | |
| 8014 } | |
| 8015 else | |
| 8016 { | |
| 8017 e1->checkScalar(); | |
| 8018 e1->checkNoBool(); | |
| 8019 if (tb1->ty == Tpointer && tb2->isintegral()) | |
| 8020 e = scaleFactor(sc); | |
| 8021 else if (tb1->ty == Tbit || tb1->ty == Tbool) | |
| 8022 { | |
| 8023 #if 0 | |
| 8024 // Need to rethink this | |
| 8025 if (e1->op != TOKvar) | |
| 8026 { // Rewrite e1+=e2 to (v=&e1),*v=*v+e2 | |
| 8027 VarDeclaration *v; | |
| 8028 Expression *ea; | |
| 8029 Expression *ex; | |
| 8030 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8031 Identifier *id = Lexer::uniqueId("__name"); |
| 159 | 8032 |
| 8033 v = new VarDeclaration(loc, tb1->pointerTo(), id, NULL); | |
| 8034 v->semantic(sc); | |
| 8035 if (!sc->insert(v)) | |
| 8036 assert(0); | |
| 8037 v->parent = sc->func; | |
| 8038 | |
| 8039 ea = new AddrExp(loc, e1); | |
| 8040 ea = new AssignExp(loc, new VarExp(loc, v), ea); | |
| 8041 | |
| 8042 ex = new VarExp(loc, v); | |
| 8043 ex = new PtrExp(loc, ex); | |
| 8044 e = new AddExp(loc, ex, e2); | |
| 8045 e = new CastExp(loc, e, e1->type); | |
| 8046 e = new AssignExp(loc, ex->syntaxCopy(), e); | |
| 8047 | |
| 8048 e = new CommaExp(loc, ea, e); | |
| 8049 } | |
| 8050 else | |
| 8051 #endif | |
| 8052 { // Rewrite e1+=e2 to e1=e1+e2 | |
| 8053 // BUG: doesn't account for side effects in e1 | |
| 8054 // BUG: other assignment operators for bits aren't handled at all | |
| 8055 e = new AddExp(loc, e1, e2); | |
| 8056 e = new CastExp(loc, e, e1->type); | |
| 8057 e = new AssignExp(loc, e1->syntaxCopy(), e); | |
| 8058 } | |
| 8059 e = e->semantic(sc); | |
| 8060 } | |
| 8061 else | |
| 8062 { | |
| 8063 type = e1->type; | |
| 8064 typeCombine(sc); | |
| 8065 e1->checkArithmetic(); | |
| 8066 e2->checkArithmetic(); | |
| 8067 if (type->isreal() || type->isimaginary()) | |
| 8068 { | |
| 8069 assert(global.errors || e2->type->isfloating()); | |
| 8070 e2 = e2->castTo(sc, e1->type); | |
| 8071 } | |
| 8072 e = this; | |
|
1012
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8073 |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8074 if (e2->type->iscomplex() && !type->iscomplex()) |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8075 error("Cannot assign %s to %s", e2->type->toChars(), type->toChars()); |
| 159 | 8076 } |
| 8077 } | |
| 8078 return e; | |
| 8079 } | |
| 8080 | |
| 8081 /************************************************************/ | |
| 8082 | |
| 8083 MinAssignExp::MinAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8084 : BinExp(loc, TOKminass, sizeof(MinAssignExp), e1, e2) | |
| 8085 { | |
| 8086 } | |
| 8087 | |
| 8088 Expression *MinAssignExp::semantic(Scope *sc) | |
| 8089 { Expression *e; | |
| 8090 | |
| 8091 if (type) | |
| 8092 return this; | |
| 8093 | |
| 8094 BinExp::semantic(sc); | |
| 8095 e2 = resolveProperties(sc, e2); | |
| 8096 | |
| 8097 e = op_overload(sc); | |
| 8098 if (e) | |
| 8099 return e; | |
| 8100 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8101 if (e1->op == TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8102 { // T[] -= ... |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8103 typeCombine(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8104 type = e1->type; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8105 return arrayOp(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8106 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8107 |
| 159 | 8108 e1 = e1->modifiableLvalue(sc, e1); |
| 8109 e1->checkScalar(); | |
| 8110 e1->checkNoBool(); | |
| 8111 if (e1->type->ty == Tpointer && e2->type->isintegral()) | |
| 8112 e = scaleFactor(sc); | |
| 8113 else | |
| 8114 { | |
| 8115 e1 = e1->checkArithmetic(); | |
| 8116 e2 = e2->checkArithmetic(); | |
| 8117 type = e1->type; | |
| 8118 typeCombine(sc); | |
| 8119 if (type->isreal() || type->isimaginary()) | |
| 8120 { | |
| 8121 assert(e2->type->isfloating()); | |
| 8122 e2 = e2->castTo(sc, e1->type); | |
| 8123 } | |
| 8124 e = this; | |
|
1012
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8125 |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8126 if (e2->type->iscomplex() && !type->iscomplex()) |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8127 error("Cannot assign %s to %s", e2->type->toChars(), type->toChars()); |
| 159 | 8128 } |
| 8129 return e; | |
| 8130 } | |
| 8131 | |
| 8132 /************************************************************/ | |
| 8133 | |
| 8134 CatAssignExp::CatAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8135 : BinExp(loc, TOKcatass, sizeof(CatAssignExp), e1, e2) | |
| 8136 { | |
| 8137 } | |
| 8138 | |
| 8139 Expression *CatAssignExp::semantic(Scope *sc) | |
| 8140 { Expression *e; | |
| 8141 | |
| 8142 BinExp::semantic(sc); | |
| 8143 e2 = resolveProperties(sc, e2); | |
| 8144 | |
| 8145 e = op_overload(sc); | |
| 8146 if (e) | |
| 8147 return e; | |
| 8148 | |
| 8149 if (e1->op == TOKslice) | |
| 8150 { SliceExp *se = (SliceExp *)e1; | |
| 8151 | |
| 8152 if (se->e1->type->toBasetype()->ty == Tsarray) | |
| 8153 error("cannot append to static array %s", se->e1->type->toChars()); | |
| 8154 } | |
| 8155 | |
| 8156 e1 = e1->modifiableLvalue(sc, e1); | |
| 8157 | |
| 8158 Type *tb1 = e1->type->toBasetype(); | |
| 8159 Type *tb2 = e2->type->toBasetype(); | |
| 8160 | |
| 8161 e2->rvalue(); | |
| 8162 | |
| 8163 if ((tb1->ty == Tarray) && | |
| 8164 (tb2->ty == Tarray || tb2->ty == Tsarray) && | |
| 8165 e2->implicitConvTo(e1->type) | |
| 8166 //e1->type->next->equals(e2->type->next) | |
| 8167 ) | |
| 8168 { // Append array | |
| 8169 e2 = e2->castTo(sc, e1->type); | |
| 8170 type = e1->type; | |
| 8171 e = this; | |
| 8172 } | |
| 8173 else if ((tb1->ty == Tarray) && | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8174 e2->implicitConvTo(tb1->nextOf()) |
| 159 | 8175 ) |
| 8176 { // Append element | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8177 e2 = e2->castTo(sc, tb1->nextOf()); |
| 159 | 8178 type = e1->type; |
| 8179 e = this; | |
| 8180 } | |
| 8181 else | |
| 8182 { | |
| 8183 error("cannot append type %s to type %s", tb2->toChars(), tb1->toChars()); | |
| 8184 type = Type::tint32; | |
| 8185 e = this; | |
| 8186 } | |
| 8187 return e; | |
| 8188 } | |
| 8189 | |
| 8190 /************************************************************/ | |
| 8191 | |
| 8192 MulAssignExp::MulAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8193 : BinExp(loc, TOKmulass, sizeof(MulAssignExp), e1, e2) | |
| 8194 { | |
| 8195 } | |
| 8196 | |
| 8197 Expression *MulAssignExp::semantic(Scope *sc) | |
| 8198 { Expression *e; | |
| 8199 | |
| 8200 BinExp::semantic(sc); | |
| 8201 e2 = resolveProperties(sc, e2); | |
| 8202 | |
| 8203 e = op_overload(sc); | |
| 8204 if (e) | |
| 8205 return e; | |
| 8206 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8207 if (e1->op == TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8208 { // T[] -= ... |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8209 typeCombine(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8210 type = e1->type; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8211 return arrayOp(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8212 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8213 |
| 159 | 8214 e1 = e1->modifiableLvalue(sc, e1); |
| 8215 e1->checkScalar(); | |
| 8216 e1->checkNoBool(); | |
| 8217 type = e1->type; | |
| 8218 typeCombine(sc); | |
| 8219 e1->checkArithmetic(); | |
| 8220 e2->checkArithmetic(); | |
| 8221 if (e2->type->isfloating()) | |
| 8222 { Type *t1; | |
| 8223 Type *t2; | |
| 8224 | |
| 8225 t1 = e1->type; | |
| 8226 t2 = e2->type; | |
| 8227 if (t1->isreal()) | |
| 8228 { | |
| 8229 if (t2->isimaginary() || t2->iscomplex()) | |
| 8230 { | |
| 8231 e2 = e2->castTo(sc, t1); | |
| 8232 } | |
| 8233 } | |
| 8234 else if (t1->isimaginary()) | |
| 8235 { | |
| 8236 if (t2->isimaginary() || t2->iscomplex()) | |
| 8237 { | |
| 8238 switch (t1->ty) | |
| 8239 { | |
| 8240 case Timaginary32: t2 = Type::tfloat32; break; | |
| 8241 case Timaginary64: t2 = Type::tfloat64; break; | |
| 8242 case Timaginary80: t2 = Type::tfloat80; break; | |
| 8243 default: | |
| 8244 assert(0); | |
| 8245 } | |
| 8246 e2 = e2->castTo(sc, t2); | |
| 8247 } | |
| 8248 } | |
|
1012
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8249 |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8250 if (e2->type->iscomplex() && !type->iscomplex()) |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8251 error("Cannot assign %s to %s", e2->type->toChars(), type->toChars()); |
| 159 | 8252 } |
| 8253 return this; | |
| 8254 } | |
| 8255 | |
| 8256 /************************************************************/ | |
| 8257 | |
| 8258 DivAssignExp::DivAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8259 : BinExp(loc, TOKdivass, sizeof(DivAssignExp), e1, e2) | |
| 8260 { | |
| 8261 } | |
| 8262 | |
| 8263 Expression *DivAssignExp::semantic(Scope *sc) | |
| 8264 { Expression *e; | |
| 8265 | |
| 8266 BinExp::semantic(sc); | |
| 8267 e2 = resolveProperties(sc, e2); | |
| 8268 | |
| 8269 e = op_overload(sc); | |
| 8270 if (e) | |
| 8271 return e; | |
| 8272 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8273 if (e1->op == TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8274 { // T[] -= ... |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8275 typeCombine(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8276 type = e1->type; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8277 return arrayOp(sc); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8278 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8279 |
| 159 | 8280 e1 = e1->modifiableLvalue(sc, e1); |
| 8281 e1->checkScalar(); | |
| 8282 e1->checkNoBool(); | |
| 8283 type = e1->type; | |
| 8284 typeCombine(sc); | |
| 8285 e1->checkArithmetic(); | |
| 8286 e2->checkArithmetic(); | |
| 8287 if (e2->type->isimaginary()) | |
| 8288 { Type *t1; | |
| 8289 Type *t2; | |
| 8290 | |
| 8291 t1 = e1->type; | |
| 8292 if (t1->isreal()) | |
| 8293 { // x/iv = i(-x/v) | |
| 8294 // Therefore, the result is 0 | |
| 8295 e2 = new CommaExp(loc, e2, new RealExp(loc, 0, t1)); | |
| 8296 e2->type = t1; | |
| 8297 e = new AssignExp(loc, e1, e2); | |
| 8298 e->type = t1; | |
| 8299 return e; | |
| 8300 } | |
| 8301 else if (t1->isimaginary()) | |
| 8302 { Expression *e; | |
| 8303 | |
| 8304 switch (t1->ty) | |
| 8305 { | |
| 8306 case Timaginary32: t2 = Type::tfloat32; break; | |
| 8307 case Timaginary64: t2 = Type::tfloat64; break; | |
| 8308 case Timaginary80: t2 = Type::tfloat80; break; | |
| 8309 default: | |
| 8310 assert(0); | |
| 8311 } | |
| 8312 e2 = e2->castTo(sc, t2); | |
| 8313 e = new AssignExp(loc, e1, e2); | |
| 8314 e->type = t1; | |
| 8315 return e; | |
| 8316 } | |
| 8317 } | |
|
1012
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8318 |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8319 if (e2->type->iscomplex() && !type->iscomplex()) |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8320 error("Cannot assign %s to %s", e2->type->toChars(), type->toChars()); |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8321 |
| 159 | 8322 return this; |
| 8323 } | |
| 8324 | |
| 8325 /************************************************************/ | |
| 8326 | |
| 8327 ModAssignExp::ModAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8328 : BinExp(loc, TOKmodass, sizeof(ModAssignExp), e1, e2) | |
| 8329 { | |
| 8330 } | |
| 8331 | |
| 8332 Expression *ModAssignExp::semantic(Scope *sc) | |
| 8333 { | |
| 8334 return commonSemanticAssign(sc); | |
| 8335 } | |
| 8336 | |
| 8337 /************************************************************/ | |
| 8338 | |
| 8339 ShlAssignExp::ShlAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8340 : BinExp(loc, TOKshlass, sizeof(ShlAssignExp), e1, e2) | |
| 8341 { | |
| 8342 } | |
| 8343 | |
| 8344 Expression *ShlAssignExp::semantic(Scope *sc) | |
| 8345 { Expression *e; | |
| 8346 | |
| 8347 //printf("ShlAssignExp::semantic()\n"); | |
| 8348 BinExp::semantic(sc); | |
| 8349 e2 = resolveProperties(sc, e2); | |
| 8350 | |
| 8351 e = op_overload(sc); | |
| 8352 if (e) | |
| 8353 return e; | |
| 8354 | |
| 8355 e1 = e1->modifiableLvalue(sc, e1); | |
| 8356 e1->checkScalar(); | |
| 8357 e1->checkNoBool(); | |
| 8358 type = e1->type; | |
| 8359 typeCombine(sc); | |
| 8360 e1->checkIntegral(); | |
| 8361 e2 = e2->checkIntegral(); | |
| 8362 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8363 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8364 return this; |
| 8365 } | |
| 8366 | |
| 8367 /************************************************************/ | |
| 8368 | |
| 8369 ShrAssignExp::ShrAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8370 : BinExp(loc, TOKshrass, sizeof(ShrAssignExp), e1, e2) | |
| 8371 { | |
| 8372 } | |
| 8373 | |
| 8374 Expression *ShrAssignExp::semantic(Scope *sc) | |
| 8375 { Expression *e; | |
| 8376 | |
| 8377 BinExp::semantic(sc); | |
| 8378 e2 = resolveProperties(sc, e2); | |
| 8379 | |
| 8380 e = op_overload(sc); | |
| 8381 if (e) | |
| 8382 return e; | |
| 8383 | |
| 8384 e1 = e1->modifiableLvalue(sc, e1); | |
| 8385 e1->checkScalar(); | |
| 8386 e1->checkNoBool(); | |
| 8387 type = e1->type; | |
| 8388 typeCombine(sc); | |
| 8389 e1->checkIntegral(); | |
| 8390 e2 = e2->checkIntegral(); | |
| 8391 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8392 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8393 return this; |
| 8394 } | |
| 8395 | |
| 8396 /************************************************************/ | |
| 8397 | |
| 8398 UshrAssignExp::UshrAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8399 : BinExp(loc, TOKushrass, sizeof(UshrAssignExp), e1, e2) | |
| 8400 { | |
| 8401 } | |
| 8402 | |
| 8403 Expression *UshrAssignExp::semantic(Scope *sc) | |
| 8404 { Expression *e; | |
| 8405 | |
| 8406 BinExp::semantic(sc); | |
| 8407 e2 = resolveProperties(sc, e2); | |
| 8408 | |
| 8409 e = op_overload(sc); | |
| 8410 if (e) | |
| 8411 return e; | |
| 8412 | |
| 8413 e1 = e1->modifiableLvalue(sc, e1); | |
| 8414 e1->checkScalar(); | |
| 8415 e1->checkNoBool(); | |
| 8416 type = e1->type; | |
| 8417 typeCombine(sc); | |
| 8418 e1->checkIntegral(); | |
| 8419 e2 = e2->checkIntegral(); | |
| 8420 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8421 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8422 return this; |
| 8423 } | |
| 8424 | |
| 8425 /************************************************************/ | |
| 8426 | |
| 8427 AndAssignExp::AndAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8428 : BinExp(loc, TOKandass, sizeof(AndAssignExp), e1, e2) | |
| 8429 { | |
| 8430 } | |
| 8431 | |
| 8432 Expression *AndAssignExp::semantic(Scope *sc) | |
| 8433 { | |
| 8434 return commonSemanticAssignIntegral(sc); | |
| 8435 } | |
| 8436 | |
| 8437 /************************************************************/ | |
| 8438 | |
| 8439 OrAssignExp::OrAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8440 : BinExp(loc, TOKorass, sizeof(OrAssignExp), e1, e2) | |
| 8441 { | |
| 8442 } | |
| 8443 | |
| 8444 Expression *OrAssignExp::semantic(Scope *sc) | |
| 8445 { | |
| 8446 return commonSemanticAssignIntegral(sc); | |
| 8447 } | |
| 8448 | |
| 8449 /************************************************************/ | |
| 8450 | |
| 8451 XorAssignExp::XorAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8452 : BinExp(loc, TOKxorass, sizeof(XorAssignExp), e1, e2) | |
| 8453 { | |
| 8454 } | |
| 8455 | |
| 8456 Expression *XorAssignExp::semantic(Scope *sc) | |
| 8457 { | |
| 8458 return commonSemanticAssignIntegral(sc); | |
| 8459 } | |
| 8460 | |
| 8461 /************************* AddExp *****************************/ | |
| 8462 | |
| 8463 AddExp::AddExp(Loc loc, Expression *e1, Expression *e2) | |
| 8464 : BinExp(loc, TOKadd, sizeof(AddExp), e1, e2) | |
| 8465 { | |
| 8466 } | |
| 8467 | |
| 8468 Expression *AddExp::semantic(Scope *sc) | |
| 8469 { Expression *e; | |
| 8470 | |
| 8471 #if LOGSEMANTIC | |
| 8472 printf("AddExp::semantic('%s')\n", toChars()); | |
| 8473 #endif | |
| 8474 if (!type) | |
| 8475 { | |
| 8476 BinExp::semanticp(sc); | |
| 8477 | |
| 8478 e = op_overload(sc); | |
| 8479 if (e) | |
| 8480 return e; | |
| 8481 | |
| 8482 Type *tb1 = e1->type->toBasetype(); | |
| 8483 Type *tb2 = e2->type->toBasetype(); | |
| 8484 | |
| 8485 if ((tb1->ty == Tarray || tb1->ty == Tsarray) && | |
| 8486 (tb2->ty == Tarray || tb2->ty == Tsarray) && | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8487 tb1->nextOf()->equals(tb2->nextOf()) |
| 159 | 8488 ) |
| 8489 { | |
| 8490 type = e1->type; | |
| 8491 e = this; | |
| 8492 } | |
| 8493 else if (tb1->ty == Tpointer && e2->type->isintegral() || | |
| 8494 tb2->ty == Tpointer && e1->type->isintegral()) | |
| 8495 e = scaleFactor(sc); | |
| 8496 else if (tb1->ty == Tpointer && tb2->ty == Tpointer) | |
| 8497 { | |
| 8498 incompatibleTypes(); | |
| 8499 type = e1->type; | |
| 8500 e = this; | |
| 8501 } | |
| 8502 else | |
| 8503 { | |
| 8504 typeCombine(sc); | |
| 8505 if ((e1->type->isreal() && e2->type->isimaginary()) || | |
| 8506 (e1->type->isimaginary() && e2->type->isreal())) | |
| 8507 { | |
| 8508 switch (type->toBasetype()->ty) | |
| 8509 { | |
| 8510 case Tfloat32: | |
| 8511 case Timaginary32: | |
| 8512 type = Type::tcomplex32; | |
| 8513 break; | |
| 8514 | |
| 8515 case Tfloat64: | |
| 8516 case Timaginary64: | |
| 8517 type = Type::tcomplex64; | |
| 8518 break; | |
| 8519 | |
| 8520 case Tfloat80: | |
| 8521 case Timaginary80: | |
| 8522 type = Type::tcomplex80; | |
| 8523 break; | |
| 8524 | |
| 8525 default: | |
| 8526 assert(0); | |
| 8527 } | |
| 8528 } | |
| 8529 e = this; | |
| 8530 } | |
| 8531 return e; | |
| 8532 } | |
| 8533 return this; | |
| 8534 } | |
| 8535 | |
| 8536 /************************************************************/ | |
| 8537 | |
| 8538 MinExp::MinExp(Loc loc, Expression *e1, Expression *e2) | |
| 8539 : BinExp(loc, TOKmin, sizeof(MinExp), e1, e2) | |
| 8540 { | |
| 8541 } | |
| 8542 | |
| 8543 Expression *MinExp::semantic(Scope *sc) | |
| 8544 { Expression *e; | |
| 8545 Type *t1; | |
| 8546 Type *t2; | |
| 8547 | |
| 8548 #if LOGSEMANTIC | |
| 8549 printf("MinExp::semantic('%s')\n", toChars()); | |
| 8550 #endif | |
| 8551 if (type) | |
| 8552 return this; | |
| 8553 | |
| 8554 BinExp::semanticp(sc); | |
| 8555 | |
| 8556 e = op_overload(sc); | |
| 8557 if (e) | |
| 8558 return e; | |
| 8559 | |
| 8560 e = this; | |
| 8561 t1 = e1->type->toBasetype(); | |
| 8562 t2 = e2->type->toBasetype(); | |
| 8563 if (t1->ty == Tpointer) | |
| 8564 { | |
| 8565 if (t2->ty == Tpointer) | |
| 8566 { // Need to divide the result by the stride | |
| 8567 // Replace (ptr - ptr) with (ptr - ptr) / stride | |
| 8568 d_int64 stride; | |
| 8569 Expression *e; | |
| 8570 | |
| 8571 typeCombine(sc); // make sure pointer types are compatible | |
| 8572 type = Type::tptrdiff_t; | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8573 stride = t2->nextOf()->size(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8574 if (stride == 0) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8575 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8576 e = new IntegerExp(loc, 0, Type::tptrdiff_t); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8577 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8578 else |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8579 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8580 e = new DivExp(loc, this, new IntegerExp(0, stride, Type::tptrdiff_t)); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8581 e->type = Type::tptrdiff_t; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8582 } |
| 159 | 8583 return e; |
| 8584 } | |
| 8585 else if (t2->isintegral()) | |
| 8586 e = scaleFactor(sc); | |
| 8587 else | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8588 { error("incompatible types for minus"); |
| 159 | 8589 return new IntegerExp(0); |
| 8590 } | |
| 8591 } | |
| 8592 else if (t2->ty == Tpointer) | |
| 8593 { | |
| 8594 type = e2->type; | |
| 8595 error("can't subtract pointer from %s", e1->type->toChars()); | |
| 8596 return new IntegerExp(0); | |
| 8597 } | |
| 8598 else | |
| 8599 { | |
| 8600 typeCombine(sc); | |
| 8601 t1 = e1->type->toBasetype(); | |
| 8602 t2 = e2->type->toBasetype(); | |
| 8603 if ((t1->isreal() && t2->isimaginary()) || | |
| 8604 (t1->isimaginary() && t2->isreal())) | |
| 8605 { | |
| 8606 switch (type->ty) | |
| 8607 { | |
| 8608 case Tfloat32: | |
| 8609 case Timaginary32: | |
| 8610 type = Type::tcomplex32; | |
| 8611 break; | |
| 8612 | |
| 8613 case Tfloat64: | |
| 8614 case Timaginary64: | |
| 8615 type = Type::tcomplex64; | |
| 8616 break; | |
| 8617 | |
| 8618 case Tfloat80: | |
| 8619 case Timaginary80: | |
| 8620 type = Type::tcomplex80; | |
| 8621 break; | |
| 8622 | |
| 8623 default: | |
| 8624 assert(0); | |
| 8625 } | |
| 8626 } | |
| 8627 } | |
| 8628 return e; | |
| 8629 } | |
| 8630 | |
| 8631 /************************* CatExp *****************************/ | |
| 8632 | |
| 8633 CatExp::CatExp(Loc loc, Expression *e1, Expression *e2) | |
| 8634 : BinExp(loc, TOKcat, sizeof(CatExp), e1, e2) | |
| 8635 { | |
| 8636 } | |
| 8637 | |
| 8638 Expression *CatExp::semantic(Scope *sc) | |
| 8639 { Expression *e; | |
| 8640 | |
| 8641 //printf("CatExp::semantic() %s\n", toChars()); | |
| 8642 if (!type) | |
| 8643 { | |
| 8644 BinExp::semanticp(sc); | |
| 8645 e = op_overload(sc); | |
| 8646 if (e) | |
| 8647 return e; | |
| 8648 | |
| 8649 Type *tb1 = e1->type->toBasetype(); | |
| 8650 Type *tb2 = e2->type->toBasetype(); | |
| 8651 | |
| 8652 | |
| 8653 /* BUG: Should handle things like: | |
| 8654 * char c; | |
| 8655 * c ~ ' ' | |
| 8656 * ' ' ~ c; | |
| 8657 */ | |
| 8658 | |
| 8659 #if 0 | |
| 8660 e1->type->print(); | |
| 8661 e2->type->print(); | |
| 8662 #endif | |
| 8663 if ((tb1->ty == Tsarray || tb1->ty == Tarray) && | |
| 8664 e2->type->equals(tb1->next)) | |
| 8665 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8666 type = tb1->nextOf()->arrayOf(); |
| 159 | 8667 if (tb2->ty == Tarray) |
| 8668 { // Make e2 into [e2] | |
| 8669 e2 = new ArrayLiteralExp(e2->loc, e2); | |
| 8670 e2->type = type; | |
| 8671 } | |
| 8672 return this; | |
| 8673 } | |
| 8674 else if ((tb2->ty == Tsarray || tb2->ty == Tarray) && | |
| 8675 e1->type->equals(tb2->next)) | |
| 8676 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8677 type = tb2->nextOf()->arrayOf(); |
| 159 | 8678 if (tb1->ty == Tarray) |
| 8679 { // Make e1 into [e1] | |
| 8680 e1 = new ArrayLiteralExp(e1->loc, e1); | |
| 8681 e1->type = type; | |
| 8682 } | |
| 8683 return this; | |
| 8684 } | |
| 8685 | |
| 8686 typeCombine(sc); | |
| 8687 | |
| 8688 if (type->toBasetype()->ty == Tsarray) | |
| 8689 type = type->toBasetype()->next->arrayOf(); | |
| 8690 #if 0 | |
| 8691 e1->type->print(); | |
| 8692 e2->type->print(); | |
| 8693 type->print(); | |
| 8694 print(); | |
| 8695 #endif | |
| 8696 if (e1->op == TOKstring && e2->op == TOKstring) | |
| 8697 e = optimize(WANTvalue); | |
| 8698 else if (e1->type->equals(e2->type) && | |
| 8699 (e1->type->toBasetype()->ty == Tarray || | |
| 8700 e1->type->toBasetype()->ty == Tsarray)) | |
| 8701 { | |
| 8702 e = this; | |
| 8703 } | |
| 8704 else | |
| 8705 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8706 //printf("(%s) ~ (%s)\n", e1->toChars(), e2->toChars()); |
| 159 | 8707 error("Can only concatenate arrays, not (%s ~ %s)", |
| 8708 e1->type->toChars(), e2->type->toChars()); | |
| 8709 type = Type::tint32; | |
| 8710 e = this; | |
| 8711 } | |
| 8712 e->type = e->type->semantic(loc, sc); | |
| 8713 return e; | |
| 8714 } | |
| 8715 return this; | |
| 8716 } | |
| 8717 | |
| 8718 /************************************************************/ | |
| 8719 | |
| 8720 MulExp::MulExp(Loc loc, Expression *e1, Expression *e2) | |
| 8721 : BinExp(loc, TOKmul, sizeof(MulExp), e1, e2) | |
| 8722 { | |
| 8723 } | |
| 8724 | |
| 8725 Expression *MulExp::semantic(Scope *sc) | |
| 8726 { Expression *e; | |
| 8727 | |
| 8728 #if 0 | |
| 8729 printf("MulExp::semantic() %s\n", toChars()); | |
| 8730 #endif | |
| 8731 if (type) | |
| 8732 { | |
| 8733 return this; | |
| 8734 } | |
| 8735 | |
| 8736 BinExp::semanticp(sc); | |
| 8737 e = op_overload(sc); | |
| 8738 if (e) | |
| 8739 return e; | |
| 8740 | |
| 8741 typeCombine(sc); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8742 if (e1->op != TOKslice && e2->op != TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8743 { e1->checkArithmetic(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8744 e2->checkArithmetic(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8745 } |
| 159 | 8746 if (type->isfloating()) |
| 8747 { Type *t1 = e1->type; | |
| 8748 Type *t2 = e2->type; | |
| 8749 | |
| 8750 if (t1->isreal()) | |
| 8751 { | |
| 8752 type = t2; | |
| 8753 } | |
| 8754 else if (t2->isreal()) | |
| 8755 { | |
| 8756 type = t1; | |
| 8757 } | |
| 8758 else if (t1->isimaginary()) | |
| 8759 { | |
| 8760 if (t2->isimaginary()) | |
| 8761 { Expression *e; | |
| 8762 | |
| 8763 switch (t1->ty) | |
| 8764 { | |
| 8765 case Timaginary32: type = Type::tfloat32; break; | |
| 8766 case Timaginary64: type = Type::tfloat64; break; | |
| 8767 case Timaginary80: type = Type::tfloat80; break; | |
| 8768 default: assert(0); | |
| 8769 } | |
| 8770 | |
| 8771 // iy * iv = -yv | |
| 8772 e1->type = type; | |
| 8773 e2->type = type; | |
| 8774 e = new NegExp(loc, this); | |
| 8775 e = e->semantic(sc); | |
| 8776 return e; | |
| 8777 } | |
| 8778 else | |
| 8779 type = t2; // t2 is complex | |
| 8780 } | |
| 8781 else if (t2->isimaginary()) | |
| 8782 { | |
| 8783 type = t1; // t1 is complex | |
| 8784 } | |
| 8785 } | |
| 8786 return this; | |
| 8787 } | |
| 8788 | |
| 8789 /************************************************************/ | |
| 8790 | |
| 8791 DivExp::DivExp(Loc loc, Expression *e1, Expression *e2) | |
| 8792 : BinExp(loc, TOKdiv, sizeof(DivExp), e1, e2) | |
| 8793 { | |
| 8794 } | |
| 8795 | |
| 8796 Expression *DivExp::semantic(Scope *sc) | |
| 8797 { Expression *e; | |
| 8798 | |
| 8799 if (type) | |
| 8800 return this; | |
| 8801 | |
| 8802 BinExp::semanticp(sc); | |
| 8803 e = op_overload(sc); | |
| 8804 if (e) | |
| 8805 return e; | |
| 8806 | |
| 8807 typeCombine(sc); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8808 if (e1->op != TOKslice && e2->op != TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8809 { e1->checkArithmetic(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8810 e2->checkArithmetic(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8811 } |
| 159 | 8812 if (type->isfloating()) |
| 8813 { Type *t1 = e1->type; | |
| 8814 Type *t2 = e2->type; | |
| 8815 | |
| 8816 if (t1->isreal()) | |
| 8817 { | |
| 8818 type = t2; | |
| 8819 if (t2->isimaginary()) | |
| 8820 { Expression *e; | |
| 8821 | |
| 8822 // x/iv = i(-x/v) | |
| 8823 e2->type = t1; | |
| 8824 e = new NegExp(loc, this); | |
| 8825 e = e->semantic(sc); | |
| 8826 return e; | |
| 8827 } | |
| 8828 } | |
| 8829 else if (t2->isreal()) | |
| 8830 { | |
| 8831 type = t1; | |
| 8832 } | |
| 8833 else if (t1->isimaginary()) | |
| 8834 { | |
| 8835 if (t2->isimaginary()) | |
| 8836 { | |
| 8837 switch (t1->ty) | |
| 8838 { | |
| 8839 case Timaginary32: type = Type::tfloat32; break; | |
| 8840 case Timaginary64: type = Type::tfloat64; break; | |
| 8841 case Timaginary80: type = Type::tfloat80; break; | |
| 8842 default: assert(0); | |
| 8843 } | |
| 8844 } | |
| 8845 else | |
| 8846 type = t2; // t2 is complex | |
| 8847 } | |
| 8848 else if (t2->isimaginary()) | |
| 8849 { | |
| 8850 type = t1; // t1 is complex | |
| 8851 } | |
| 8852 } | |
| 8853 return this; | |
| 8854 } | |
| 8855 | |
| 8856 /************************************************************/ | |
| 8857 | |
| 8858 ModExp::ModExp(Loc loc, Expression *e1, Expression *e2) | |
| 8859 : BinExp(loc, TOKmod, sizeof(ModExp), e1, e2) | |
| 8860 { | |
| 8861 } | |
| 8862 | |
| 8863 Expression *ModExp::semantic(Scope *sc) | |
| 8864 { Expression *e; | |
| 8865 | |
| 8866 if (type) | |
| 8867 return this; | |
| 8868 | |
| 8869 BinExp::semanticp(sc); | |
| 8870 e = op_overload(sc); | |
| 8871 if (e) | |
| 8872 return e; | |
| 8873 | |
| 8874 typeCombine(sc); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8875 if (e1->op != TOKslice && e2->op != TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8876 { e1->checkArithmetic(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8877 e2->checkArithmetic(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8878 } |
| 159 | 8879 if (type->isfloating()) |
| 8880 { type = e1->type; | |
| 8881 if (e2->type->iscomplex()) | |
| 8882 { error("cannot perform modulo complex arithmetic"); | |
| 8883 return new IntegerExp(0); | |
| 8884 } | |
| 8885 } | |
| 8886 return this; | |
| 8887 } | |
| 8888 | |
| 8889 /************************************************************/ | |
| 8890 | |
| 8891 ShlExp::ShlExp(Loc loc, Expression *e1, Expression *e2) | |
| 8892 : BinExp(loc, TOKshl, sizeof(ShlExp), e1, e2) | |
| 8893 { | |
| 8894 } | |
| 8895 | |
| 8896 Expression *ShlExp::semantic(Scope *sc) | |
| 8897 { Expression *e; | |
| 8898 | |
| 8899 //printf("ShlExp::semantic(), type = %p\n", type); | |
| 8900 if (!type) | |
| 8901 { BinExp::semanticp(sc); | |
| 8902 e = op_overload(sc); | |
| 8903 if (e) | |
| 8904 return e; | |
| 8905 e1 = e1->checkIntegral(); | |
| 8906 e2 = e2->checkIntegral(); | |
| 8907 e1 = e1->integralPromotions(sc); | |
| 8908 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8909 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8910 type = e1->type; |
| 8911 } | |
| 8912 return this; | |
| 8913 } | |
| 8914 | |
| 8915 /************************************************************/ | |
| 8916 | |
| 8917 ShrExp::ShrExp(Loc loc, Expression *e1, Expression *e2) | |
| 8918 : BinExp(loc, TOKshr, sizeof(ShrExp), e1, e2) | |
| 8919 { | |
| 8920 } | |
| 8921 | |
| 8922 Expression *ShrExp::semantic(Scope *sc) | |
| 8923 { Expression *e; | |
| 8924 | |
| 8925 if (!type) | |
| 8926 { BinExp::semanticp(sc); | |
| 8927 e = op_overload(sc); | |
| 8928 if (e) | |
| 8929 return e; | |
| 8930 e1 = e1->checkIntegral(); | |
| 8931 e2 = e2->checkIntegral(); | |
| 8932 e1 = e1->integralPromotions(sc); | |
| 8933 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8934 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8935 type = e1->type; |
| 8936 } | |
| 8937 return this; | |
| 8938 } | |
| 8939 | |
| 8940 /************************************************************/ | |
| 8941 | |
| 8942 UshrExp::UshrExp(Loc loc, Expression *e1, Expression *e2) | |
| 8943 : BinExp(loc, TOKushr, sizeof(UshrExp), e1, e2) | |
| 8944 { | |
| 8945 } | |
| 8946 | |
| 8947 Expression *UshrExp::semantic(Scope *sc) | |
| 8948 { Expression *e; | |
| 8949 | |
| 8950 if (!type) | |
| 8951 { BinExp::semanticp(sc); | |
| 8952 e = op_overload(sc); | |
| 8953 if (e) | |
| 8954 return e; | |
| 8955 e1 = e1->checkIntegral(); | |
| 8956 e2 = e2->checkIntegral(); | |
| 8957 e1 = e1->integralPromotions(sc); | |
| 8958 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8959 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8960 type = e1->type; |
| 8961 } | |
| 8962 return this; | |
| 8963 } | |
| 8964 | |
| 8965 /************************************************************/ | |
| 8966 | |
| 8967 AndExp::AndExp(Loc loc, Expression *e1, Expression *e2) | |
| 8968 : BinExp(loc, TOKand, sizeof(AndExp), e1, e2) | |
| 8969 { | |
| 8970 } | |
| 8971 | |
| 8972 Expression *AndExp::semantic(Scope *sc) | |
| 8973 { Expression *e; | |
| 8974 | |
| 8975 if (!type) | |
| 8976 { BinExp::semanticp(sc); | |
| 8977 e = op_overload(sc); | |
| 8978 if (e) | |
| 8979 return e; | |
| 8980 if (e1->type->toBasetype()->ty == Tbool && | |
| 8981 e2->type->toBasetype()->ty == Tbool) | |
| 8982 { | |
| 8983 type = e1->type; | |
| 8984 e = this; | |
| 8985 } | |
| 8986 else | |
| 8987 { | |
| 8988 typeCombine(sc); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8989 if (e1->op != TOKslice && e2->op != TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8990 { e1->checkIntegral(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8991 e2->checkIntegral(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8992 } |
| 159 | 8993 } |
| 8994 } | |
| 8995 return this; | |
| 8996 } | |
| 8997 | |
| 8998 /************************************************************/ | |
| 8999 | |
| 9000 OrExp::OrExp(Loc loc, Expression *e1, Expression *e2) | |
| 9001 : BinExp(loc, TOKor, sizeof(OrExp), e1, e2) | |
| 9002 { | |
| 9003 } | |
| 9004 | |
| 9005 Expression *OrExp::semantic(Scope *sc) | |
| 9006 { Expression *e; | |
| 9007 | |
| 9008 if (!type) | |
| 9009 { BinExp::semanticp(sc); | |
| 9010 e = op_overload(sc); | |
| 9011 if (e) | |
| 9012 return e; | |
| 9013 if (e1->type->toBasetype()->ty == Tbool && | |
| 9014 e2->type->toBasetype()->ty == Tbool) | |
| 9015 { | |
| 9016 type = e1->type; | |
| 9017 e = this; | |
| 9018 } | |
| 9019 else | |
| 9020 { | |
| 9021 typeCombine(sc); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
9022 if (e1->op != TOKslice && e2->op != TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
9023 { e1->checkIntegral(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
9024 e2->checkIntegral(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
9025 } |
| 159 | 9026 } |
| 9027 } | |
| 9028 return this; | |
| 9029 } | |
| 9030 | |
| 9031 /************************************************************/ | |
| 9032 | |
| 9033 XorExp::XorExp(Loc loc, Expression *e1, Expression *e2) | |
| 9034 : BinExp(loc, TOKxor, sizeof(XorExp), e1, e2) | |
| 9035 { | |
| 9036 } | |
| 9037 | |
| 9038 Expression *XorExp::semantic(Scope *sc) | |
| 9039 { Expression *e; | |
| 9040 | |
| 9041 if (!type) | |
| 9042 { BinExp::semanticp(sc); | |
| 9043 e = op_overload(sc); | |
| 9044 if (e) | |
| 9045 return e; | |
| 9046 if (e1->type->toBasetype()->ty == Tbool && | |
| 9047 e2->type->toBasetype()->ty == Tbool) | |
| 9048 { | |
| 9049 type = e1->type; | |
| 9050 e = this; | |
| 9051 } | |
| 9052 else | |
| 9053 { | |
| 9054 typeCombine(sc); | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
9055 if (e1->op != TOKslice && e2->op != TOKslice) |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
9056 { e1->checkIntegral(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
9057 e2->checkIntegral(); |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
9058 } |
| 159 | 9059 } |
| 9060 } | |
| 9061 return this; | |
| 9062 } | |
| 9063 | |
| 9064 | |
| 9065 /************************************************************/ | |
| 9066 | |
| 9067 OrOrExp::OrOrExp(Loc loc, Expression *e1, Expression *e2) | |
| 9068 : BinExp(loc, TOKoror, sizeof(OrOrExp), e1, e2) | |
| 9069 { | |
| 9070 } | |
| 9071 | |
| 9072 Expression *OrOrExp::semantic(Scope *sc) | |
| 9073 { | |
| 9074 unsigned cs1; | |
| 9075 | |
| 9076 // same as for AndAnd | |
| 9077 e1 = e1->semantic(sc); | |
| 9078 e1 = resolveProperties(sc, e1); | |
| 9079 e1 = e1->checkToPointer(); | |
| 9080 e1 = e1->checkToBoolean(); | |
| 9081 cs1 = sc->callSuper; | |
| 9082 | |
| 9083 if (sc->flags & SCOPEstaticif) | |
| 9084 { | |
| 9085 /* If in static if, don't evaluate e2 if we don't have to. | |
| 9086 */ | |
| 9087 e1 = e1->optimize(WANTflags); | |
| 9088 if (e1->isBool(TRUE)) | |
| 9089 { | |
| 9090 return new IntegerExp(loc, 1, Type::tboolean); | |
| 9091 } | |
| 9092 } | |
| 9093 | |
| 9094 e2 = e2->semantic(sc); | |
| 9095 sc->mergeCallSuper(loc, cs1); | |
| 9096 e2 = resolveProperties(sc, e2); | |
| 9097 e2 = e2->checkToPointer(); | |
| 9098 | |
| 9099 type = Type::tboolean; | |
|
779
ef7fe998f9b3
Fix return type of OrOr and AndAndExp being set incorrectly if rhs is void. Thanks wilsonk!
Christian Kamm <kamm incasoftware de>
parents:
723
diff
changeset
|
9100 if (e2->type->ty == Tvoid) |
| 159 | 9101 type = Type::tvoid; |
| 9102 if (e2->op == TOKtype || e2->op == TOKimport) | |
| 9103 error("%s is not an expression", e2->toChars()); | |
| 9104 return this; | |
| 9105 } | |
| 9106 | |
| 9107 Expression *OrOrExp::checkToBoolean() | |
| 9108 { | |
| 9109 e2 = e2->checkToBoolean(); | |
| 9110 return this; | |
| 9111 } | |
| 9112 | |
| 9113 int OrOrExp::isBit() | |
| 9114 { | |
| 9115 return TRUE; | |
| 9116 } | |
| 9117 | |
| 9118 int OrOrExp::checkSideEffect(int flag) | |
| 9119 { | |
| 9120 if (flag == 2) | |
| 9121 { | |
| 9122 return e1->checkSideEffect(2) || e2->checkSideEffect(2); | |
| 9123 } | |
| 9124 else | |
| 9125 { e1->checkSideEffect(1); | |
| 9126 return e2->checkSideEffect(flag); | |
| 9127 } | |
| 9128 } | |
| 9129 | |
| 9130 /************************************************************/ | |
| 9131 | |
| 9132 AndAndExp::AndAndExp(Loc loc, Expression *e1, Expression *e2) | |
| 9133 : BinExp(loc, TOKandand, sizeof(AndAndExp), e1, e2) | |
| 9134 { | |
| 9135 } | |
| 9136 | |
| 9137 Expression *AndAndExp::semantic(Scope *sc) | |
| 9138 { | |
| 9139 unsigned cs1; | |
| 9140 | |
| 9141 // same as for OrOr | |
| 9142 e1 = e1->semantic(sc); | |
| 9143 e1 = resolveProperties(sc, e1); | |
| 9144 e1 = e1->checkToPointer(); | |
| 9145 e1 = e1->checkToBoolean(); | |
| 9146 cs1 = sc->callSuper; | |
| 9147 | |
| 9148 if (sc->flags & SCOPEstaticif) | |
| 9149 { | |
| 9150 /* If in static if, don't evaluate e2 if we don't have to. | |
| 9151 */ | |
| 9152 e1 = e1->optimize(WANTflags); | |
| 9153 if (e1->isBool(FALSE)) | |
| 9154 { | |
| 9155 return new IntegerExp(loc, 0, Type::tboolean); | |
| 9156 } | |
| 9157 } | |
| 9158 | |
| 9159 e2 = e2->semantic(sc); | |
| 9160 sc->mergeCallSuper(loc, cs1); | |
| 9161 e2 = resolveProperties(sc, e2); | |
| 9162 e2 = e2->checkToPointer(); | |
| 9163 | |
| 9164 type = Type::tboolean; | |
|
779
ef7fe998f9b3
Fix return type of OrOr and AndAndExp being set incorrectly if rhs is void. Thanks wilsonk!
Christian Kamm <kamm incasoftware de>
parents:
723
diff
changeset
|
9165 if (e2->type->ty == Tvoid) |
| 159 | 9166 type = Type::tvoid; |
| 9167 if (e2->op == TOKtype || e2->op == TOKimport) | |
| 9168 error("%s is not an expression", e2->toChars()); | |
| 9169 return this; | |
| 9170 } | |
| 9171 | |
| 9172 Expression *AndAndExp::checkToBoolean() | |
| 9173 { | |
| 9174 e2 = e2->checkToBoolean(); | |
| 9175 return this; | |
| 9176 } | |
| 9177 | |
| 9178 int AndAndExp::isBit() | |
| 9179 { | |
| 9180 return TRUE; | |
| 9181 } | |
| 9182 | |
| 9183 int AndAndExp::checkSideEffect(int flag) | |
| 9184 { | |
| 9185 if (flag == 2) | |
| 9186 { | |
| 9187 return e1->checkSideEffect(2) || e2->checkSideEffect(2); | |
| 9188 } | |
| 9189 else | |
| 9190 { | |
| 9191 e1->checkSideEffect(1); | |
| 9192 return e2->checkSideEffect(flag); | |
| 9193 } | |
| 9194 } | |
| 9195 | |
| 9196 /************************************************************/ | |
| 9197 | |
| 9198 InExp::InExp(Loc loc, Expression *e1, Expression *e2) | |
| 9199 : BinExp(loc, TOKin, sizeof(InExp), e1, e2) | |
| 9200 { | |
| 9201 } | |
| 9202 | |
| 9203 Expression *InExp::semantic(Scope *sc) | |
| 9204 { Expression *e; | |
| 9205 | |
| 9206 if (type) | |
| 9207 return this; | |
| 9208 | |
| 9209 BinExp::semanticp(sc); | |
| 9210 e = op_overload(sc); | |
| 9211 if (e) | |
| 9212 return e; | |
| 9213 | |
| 9214 //type = Type::tboolean; | |
| 9215 Type *t2b = e2->type->toBasetype(); | |
| 9216 if (t2b->ty != Taarray) | |
| 9217 { | |
| 9218 error("rvalue of in expression must be an associative array, not %s", e2->type->toChars()); | |
| 9219 type = Type::terror; | |
| 9220 } | |
| 9221 else | |
| 9222 { | |
| 9223 TypeAArray *ta = (TypeAArray *)t2b; | |
| 9224 | |
| 9225 // Convert key to type of key | |
| 9226 e1 = e1->implicitCastTo(sc, ta->index); | |
| 9227 | |
| 9228 // Return type is pointer to value | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
9229 type = ta->nextOf()->pointerTo(); |
| 159 | 9230 } |
| 9231 return this; | |
| 9232 } | |
| 9233 | |
| 9234 int InExp::isBit() | |
| 9235 { | |
| 9236 return FALSE; | |
| 9237 } | |
| 9238 | |
| 9239 | |
| 9240 /************************************************************/ | |
| 9241 | |
| 9242 /* This deletes the key e1 from the associative array e2 | |
| 9243 */ | |
| 9244 | |
| 9245 RemoveExp::RemoveExp(Loc loc, Expression *e1, Expression *e2) | |
| 9246 : BinExp(loc, TOKremove, sizeof(RemoveExp), e1, e2) | |
| 9247 { | |
| 9248 type = Type::tvoid; | |
| 9249 } | |
| 9250 | |
| 9251 /************************************************************/ | |
| 9252 | |
| 9253 CmpExp::CmpExp(enum TOK op, Loc loc, Expression *e1, Expression *e2) | |
| 9254 : BinExp(loc, op, sizeof(CmpExp), e1, e2) | |
| 9255 { | |
| 9256 } | |
| 9257 | |
| 9258 Expression *CmpExp::semantic(Scope *sc) | |
| 9259 { Expression *e; | |
| 9260 Type *t1; | |
| 9261 Type *t2; | |
| 9262 | |
| 9263 #if LOGSEMANTIC | |
| 9264 printf("CmpExp::semantic('%s')\n", toChars()); | |
| 9265 #endif | |
| 9266 if (type) | |
| 9267 return this; | |
| 9268 | |
| 9269 BinExp::semanticp(sc); | |
| 9270 | |
| 9271 if (e1->type->toBasetype()->ty == Tclass && e2->op == TOKnull || | |
| 9272 e2->type->toBasetype()->ty == Tclass && e1->op == TOKnull) | |
| 9273 { | |
| 9274 error("do not use null when comparing class types"); | |
| 9275 } | |
| 9276 | |
| 9277 e = op_overload(sc); | |
| 9278 if (e) | |
| 9279 { | |
|
1367
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
9280 if (!e->type->isscalar() && e->type->equals(e1->type)) |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
9281 { |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
9282 error("recursive opCmp expansion"); |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
9283 e = new ErrorExp(); |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
9284 } |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
9285 else |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
9286 { e = new CmpExp(op, loc, e, new IntegerExp(loc, 0, Type::tint32)); |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
9287 e = e->semantic(sc); |
|
8026319762be
Merged DMD 1.045 !!!
Tomas Lindquist Olsen <tomas.l.olsen gmail com>
parents:
1358
diff
changeset
|
9288 } |
| 159 | 9289 return e; |
| 9290 } | |
| 9291 | |
| 9292 typeCombine(sc); | |
| 9293 type = Type::tboolean; | |
| 9294 | |
| 9295 // Special handling for array comparisons | |
| 9296 t1 = e1->type->toBasetype(); | |
| 9297 t2 = e2->type->toBasetype(); | |
| 9298 if ((t1->ty == Tarray || t1->ty == Tsarray) && | |
| 9299 (t2->ty == Tarray || t2->ty == Tsarray)) | |
| 9300 { | |
| 9301 if (!t1->next->equals(t2->next)) | |
| 9302 error("array comparison type mismatch, %s vs %s", t1->next->toChars(), t2->next->toChars()); | |
| 9303 e = this; | |
| 9304 } | |
| 9305 else if (t1->ty == Tstruct || t2->ty == Tstruct || | |
| 9306 (t1->ty == Tclass && t2->ty == Tclass)) | |
| 9307 { | |
| 9308 if (t2->ty == Tstruct) | |
| 9309 error("need member function opCmp() for %s %s to compare", t2->toDsymbol(sc)->kind(), t2->toChars()); | |
| 9310 else | |
| 9311 error("need member function opCmp() for %s %s to compare", t1->toDsymbol(sc)->kind(), t1->toChars()); | |
| 9312 e = this; | |
| 9313 } | |
| 9314 #if 1 | |
| 9315 else if (t1->iscomplex() || t2->iscomplex()) | |
| 9316 { | |
| 9317 error("compare not defined for complex operands"); | |
| 9318 e = new IntegerExp(0); | |
| 9319 } | |
| 9320 #endif | |
| 9321 else | |
| 9322 e = this; | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
9323 //printf("CmpExp: %s\n", e->toChars()); |
| 159 | 9324 return e; |
| 9325 } | |
| 9326 | |
| 9327 int CmpExp::isBit() | |
| 9328 { | |
| 9329 return TRUE; | |
| 9330 } | |
| 9331 | |
| 9332 | |
| 9333 /************************************************************/ | |
| 9334 | |
| 9335 EqualExp::EqualExp(enum TOK op, Loc loc, Expression *e1, Expression *e2) | |
| 9336 : BinExp(loc, op, sizeof(EqualExp), e1, e2) | |
| 9337 { | |
| 9338 assert(op == TOKequal || op == TOKnotequal); | |
| 9339 } | |
| 9340 | |
| 9341 Expression *EqualExp::semantic(Scope *sc) | |
| 9342 { Expression *e; | |
| 9343 Type *t1; | |
| 9344 Type *t2; | |
| 9345 | |
| 9346 //printf("EqualExp::semantic('%s')\n", toChars()); | |
| 9347 if (type) | |
| 9348 return this; | |
| 9349 | |
| 9350 BinExp::semanticp(sc); | |
| 9351 | |
| 9352 /* Before checking for operator overloading, check to see if we're | |
| 9353 * comparing the addresses of two statics. If so, we can just see | |
| 9354 * if they are the same symbol. | |
| 9355 */ | |
| 9356 if (e1->op == TOKaddress && e2->op == TOKaddress) | |
| 9357 { AddrExp *ae1 = (AddrExp *)e1; | |
| 9358 AddrExp *ae2 = (AddrExp *)e2; | |
| 9359 | |
| 9360 if (ae1->e1->op == TOKvar && ae2->e1->op == TOKvar) | |
| 9361 { VarExp *ve1 = (VarExp *)ae1->e1; | |
| 9362 VarExp *ve2 = (VarExp *)ae2->e1; | |
| 9363 | |
| 9364 if (ve1->var == ve2->var /*|| ve1->var->toSymbol() == ve2->var->toSymbol()*/) | |
| 9365 { | |
| 9366 // They are the same, result is 'true' for ==, 'false' for != | |
| 9367 e = new IntegerExp(loc, (op == TOKequal), Type::tboolean); | |
| 9368 return e; | |
| 9369 } | |
| 9370 } | |
| 9371 } | |
| 9372 | |
| 9373 if (e1->type->toBasetype()->ty == Tclass && e2->op == TOKnull || | |
| 9374 e2->type->toBasetype()->ty == Tclass && e1->op == TOKnull) | |
| 9375 { | |
| 9376 error("use '%s' instead of '%s' when comparing with null", | |
| 9377 Token::toChars(op == TOKequal ? TOKidentity : TOKnotidentity), | |
| 9378 Token::toChars(op)); | |
| 9379 } | |
| 9380 | |
| 9381 //if (e2->op != TOKnull) | |
| 9382 { | |
| 9383 e = op_overload(sc); | |
| 9384 if (e) | |
| 9385 { | |
| 9386 if (op == TOKnotequal) | |
| 9387 { | |
| 9388 e = new NotExp(e->loc, e); | |
| 9389 e = e->semantic(sc); | |
| 9390 } | |
| 9391 return e; | |
| 9392 } | |
| 9393 } | |
| 9394 | |
| 9395 e = typeCombine(sc); | |
| 9396 type = Type::tboolean; | |
| 9397 | |
| 9398 // Special handling for array comparisons | |
| 9399 t1 = e1->type->toBasetype(); | |
| 9400 t2 = e2->type->toBasetype(); | |
| 9401 if ((t1->ty == Tarray || t1->ty == Tsarray) && | |
| 9402 (t2->ty == Tarray || t2->ty == Tsarray)) | |
| 9403 { | |
| 9404 if (!t1->next->equals(t2->next)) | |
| 9405 error("array comparison type mismatch, %s vs %s", t1->next->toChars(), t2->next->toChars()); | |
| 9406 } | |
| 9407 else | |
| 9408 { | |
| 9409 if (e1->type != e2->type && e1->type->isfloating() && e2->type->isfloating()) | |
| 9410 { | |
| 9411 // Cast both to complex | |
| 9412 e1 = e1->castTo(sc, Type::tcomplex80); | |
| 9413 e2 = e2->castTo(sc, Type::tcomplex80); | |
| 9414 } | |
| 9415 } | |
| 9416 return e; | |
| 9417 } | |
| 9418 | |
| 9419 int EqualExp::isBit() | |
| 9420 { | |
| 9421 return TRUE; | |
| 9422 } | |
| 9423 | |
| 9424 | |
| 9425 | |
| 9426 /************************************************************/ | |
| 9427 | |
| 9428 IdentityExp::IdentityExp(enum TOK op, Loc loc, Expression *e1, Expression *e2) | |
| 9429 : BinExp(loc, op, sizeof(IdentityExp), e1, e2) | |
| 9430 { | |
| 9431 } | |
| 9432 | |
| 9433 Expression *IdentityExp::semantic(Scope *sc) | |
| 9434 { | |
| 9435 if (type) | |
| 9436 return this; | |
| 9437 | |
| 9438 BinExp::semanticp(sc); | |
| 9439 type = Type::tboolean; | |
| 9440 typeCombine(sc); | |
| 9441 if (e1->type != e2->type && e1->type->isfloating() && e2->type->isfloating()) | |
| 9442 { | |
| 9443 // Cast both to complex | |
| 9444 e1 = e1->castTo(sc, Type::tcomplex80); | |
| 9445 e2 = e2->castTo(sc, Type::tcomplex80); | |
| 9446 } | |
| 9447 return this; | |
| 9448 } | |
| 9449 | |
| 9450 int IdentityExp::isBit() | |
| 9451 { | |
| 9452 return TRUE; | |
| 9453 } | |
| 9454 | |
| 9455 | |
| 9456 /****************************************************************/ | |
| 9457 | |
| 9458 CondExp::CondExp(Loc loc, Expression *econd, Expression *e1, Expression *e2) | |
| 9459 : BinExp(loc, TOKquestion, sizeof(CondExp), e1, e2) | |
| 9460 { | |
| 9461 this->econd = econd; | |
| 9462 } | |
| 9463 | |
| 9464 Expression *CondExp::syntaxCopy() | |
| 9465 { | |
| 9466 return new CondExp(loc, econd->syntaxCopy(), e1->syntaxCopy(), e2->syntaxCopy()); | |
| 9467 } | |
| 9468 | |
| 9469 | |
| 9470 Expression *CondExp::semantic(Scope *sc) | |
| 9471 { Type *t1; | |
| 9472 Type *t2; | |
| 9473 unsigned cs0; | |
| 9474 unsigned cs1; | |
| 9475 | |
| 9476 #if LOGSEMANTIC | |
| 9477 printf("CondExp::semantic('%s')\n", toChars()); | |
| 9478 #endif | |
| 9479 if (type) | |
| 9480 return this; | |
| 9481 | |
| 9482 econd = econd->semantic(sc); | |
| 9483 econd = resolveProperties(sc, econd); | |
| 9484 econd = econd->checkToPointer(); | |
| 9485 econd = econd->checkToBoolean(); | |
| 9486 | |
| 9487 #if 0 /* this cannot work right because the types of e1 and e2 | |
| 9488 * both contribute to the type of the result. | |
| 9489 */ | |
| 9490 if (sc->flags & SCOPEstaticif) | |
| 9491 { | |
| 9492 /* If in static if, don't evaluate what we don't have to. | |
| 9493 */ | |
| 9494 econd = econd->optimize(WANTflags); | |
| 9495 if (econd->isBool(TRUE)) | |
| 9496 { | |
| 9497 e1 = e1->semantic(sc); | |
| 9498 e1 = resolveProperties(sc, e1); | |
| 9499 return e1; | |
| 9500 } | |
| 9501 else if (econd->isBool(FALSE)) | |
| 9502 { | |
| 9503 e2 = e2->semantic(sc); | |
| 9504 e2 = resolveProperties(sc, e2); | |
| 9505 return e2; | |
| 9506 } | |
| 9507 } | |
| 9508 #endif | |
| 9509 | |
| 9510 | |
| 9511 cs0 = sc->callSuper; | |
| 9512 e1 = e1->semantic(sc); | |
| 9513 e1 = resolveProperties(sc, e1); | |
| 9514 cs1 = sc->callSuper; | |
| 9515 sc->callSuper = cs0; | |
| 9516 e2 = e2->semantic(sc); | |
| 9517 e2 = resolveProperties(sc, e2); | |
| 9518 sc->mergeCallSuper(loc, cs1); | |
| 9519 | |
| 9520 | |
| 9521 // If either operand is void, the result is void | |
| 9522 t1 = e1->type; | |
| 9523 t2 = e2->type; | |
| 9524 if (t1->ty == Tvoid || t2->ty == Tvoid) | |
| 9525 type = Type::tvoid; | |
| 9526 else if (t1 == t2) | |
| 9527 type = t1; | |
| 9528 else | |
| 9529 { | |
| 9530 typeCombine(sc); | |
| 9531 switch (e1->type->toBasetype()->ty) | |
| 9532 { | |
| 9533 case Tcomplex32: | |
| 9534 case Tcomplex64: | |
| 9535 case Tcomplex80: | |
| 9536 e2 = e2->castTo(sc, e1->type); | |
| 9537 break; | |
| 9538 } | |
| 9539 switch (e2->type->toBasetype()->ty) | |
| 9540 { | |
| 9541 case Tcomplex32: | |
| 9542 case Tcomplex64: | |
| 9543 case Tcomplex80: | |
| 9544 e1 = e1->castTo(sc, e2->type); | |
| 9545 break; | |
| 9546 } | |
| 9547 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9548 #if 0 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9549 printf("res: %s\n", type->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9550 printf("e1 : %s\n", e1->type->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9551 printf("e2 : %s\n", e2->type->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9552 #endif |
| 159 | 9553 return this; |
| 9554 } | |
| 9555 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9556 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9557 int CondExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9558 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9559 return e1->isLvalue() && e2->isLvalue(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9560 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9561 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9562 |
| 159 | 9563 Expression *CondExp::toLvalue(Scope *sc, Expression *ex) |
| 9564 { | |
| 9565 PtrExp *e; | |
| 9566 | |
| 9567 // convert (econd ? e1 : e2) to *(econd ? &e1 : &e2) | |
| 9568 e = new PtrExp(loc, this, type); | |
| 9569 | |
| 9570 e1 = e1->addressOf(sc); | |
| 9571 //e1 = e1->toLvalue(sc, NULL); | |
| 9572 | |
| 9573 e2 = e2->addressOf(sc); | |
| 9574 //e2 = e2->toLvalue(sc, NULL); | |
| 9575 | |
| 9576 typeCombine(sc); | |
| 9577 | |
| 9578 type = e2->type; | |
| 9579 return e; | |
| 9580 } | |
| 9581 | |
| 9582 Expression *CondExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 9583 { | |
| 9584 error("conditional expression %s is not a modifiable lvalue", toChars()); | |
| 9585 return this; | |
| 9586 } | |
| 9587 | |
| 9588 void CondExp::checkEscape() | |
| 9589 { | |
| 9590 e1->checkEscape(); | |
| 9591 e2->checkEscape(); | |
| 9592 } | |
| 9593 | |
| 9594 | |
| 9595 Expression *CondExp::checkToBoolean() | |
| 9596 { | |
| 9597 e1 = e1->checkToBoolean(); | |
| 9598 e2 = e2->checkToBoolean(); | |
| 9599 return this; | |
| 9600 } | |
| 9601 | |
| 9602 int CondExp::checkSideEffect(int flag) | |
| 9603 { | |
| 9604 if (flag == 2) | |
| 9605 { | |
| 9606 return econd->checkSideEffect(2) || | |
| 9607 e1->checkSideEffect(2) || | |
| 9608 e2->checkSideEffect(2); | |
| 9609 } | |
| 9610 else | |
| 9611 { | |
| 9612 econd->checkSideEffect(1); | |
| 9613 e1->checkSideEffect(flag); | |
| 9614 return e2->checkSideEffect(flag); | |
| 9615 } | |
| 9616 } | |
| 9617 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9618 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9619 int CondExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9620 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9621 return econd->canThrow() || e1->canThrow() || e2->canThrow(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9622 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9623 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9624 |
| 159 | 9625 void CondExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 9626 { | |
| 9627 expToCBuffer(buf, hgs, econd, PREC_oror); | |
| 9628 buf->writestring(" ? "); | |
| 9629 expToCBuffer(buf, hgs, e1, PREC_expr); | |
| 9630 buf->writestring(" : "); | |
| 9631 expToCBuffer(buf, hgs, e2, PREC_cond); | |
| 9632 } | |
| 9633 | |
|
599
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9634 /************************************************************/ |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9635 |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9636 #if IN_LLVM |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9637 |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
9638 // Strictly LDC specific stuff |
|
599
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9639 |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9640 GEPExp::GEPExp(Loc loc, Expression* e, Identifier* id, unsigned idx) |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9641 : UnaExp(loc, TOKgep, sizeof(GEPExp), e) |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9642 { |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9643 index = idx; |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9644 ident = id; |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9645 } |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9646 |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9647 void GEPExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9648 { |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9649 expToCBuffer(buf, hgs, e1, PREC_primary); |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9650 buf->writeByte('.'); |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9651 buf->writestring(ident->toChars()); |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9652 } |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9653 |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9654 Expression* GEPExp::toLvalue(Scope* sc, Expression* e) |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9655 { |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9656 // GEP's are always lvalues, at least in the "LLVM sense" ... |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9657 return this; |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9658 } |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9659 |
|
4435f57956e7
Fixed .funcptr property of delegates, no longer uses the infamous DMD rewrites to pointer arithmetic, instead a GEPExp has been introduced.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
585
diff
changeset
|
9660 #endif |